开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
entities.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：30k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

entities.c：源码内容
  1. /*
  2.  * entities.c : implementation for the XML entities handking
  3.  *
  4.  * See Copyright for the status of this software.
  5.  *
  6.  * Daniel.Veillard@w3.org
  7.  */
  9. #ifdef WIN32
  10. #include "win32config.h"
  11. #else
  12. #include "config.h"
  13. #endif
  15. #include <stdio.h>
  16. #include <string.h>
  17. #ifdef HAVE_STDLIB_H
  18. #include <stdlib.h>
  19. #endif
  20. #include <libxml/xmlmemory.h>
  21. #include <libxml/entities.h>
  22. #include <libxml/parser.h>
  24. #define DEBUG_ENT_REF /* debugging of cross entities dependancies */
  26. /*
  27.  * The XML predefined entities.
  28.  */
  30. struct xmlPredefinedEntityValue {
  31.     const char *name;
  32.     const char *value;
  33. };
  34. struct xmlPredefinedEntityValue xmlPredefinedEntityValues[] = {
  35.     { "lt", "<" },
  36.     { "gt", ">" },
  37.     { "apos", "'" },
  38.     { "quot", """ },
  39.     { "amp", "&" }
  40. };
  42. xmlEntitiesTablePtr xmlPredefinedEntities = NULL;
  44. /*
  45.  * xmlFreeEntity : clean-up an entity record.
  46.  */
  47. void xmlFreeEntity(xmlEntityPtr entity) {
  48.     if (entity == NULL) return;
  50.     if (entity->children)
  51. xmlFreeNodeList(entity->children);
  52.     if (entity->name != NULL)
  53. xmlFree((char *) entity->name);
  54.     if (entity->ExternalID != NULL)
  55.         xmlFree((char *) entity->ExternalID);
  56.     if (entity->SystemID != NULL)
  57.         xmlFree((char *) entity->SystemID);
  58.     if (entity->content != NULL)
  59.         xmlFree((char *) entity->content);
  60.     if (entity->orig != NULL)
  61.         xmlFree((char *) entity->orig);
  62. #ifdef WITH_EXTRA_ENT_DETECT
  63.     if (entity->entTab != NULL) {
  64. int i;
  66. for (i = 0; i < entity->entNr; i++)
  67.     xmlFree(entity->entTab[i]);
  68. xmlFree(entity->entTab);
  69.     }
  70. #endif
  71.     memset(entity, -1, sizeof(xmlEntity));
  72.     xmlFree(entity);
  73. }
  75. /*
  76.  * xmlAddEntity : register a new entity for an entities table.
  77.  */
  78. static xmlEntityPtr
  79. xmlAddEntity(xmlEntitiesTablePtr table, const xmlChar *name, int type,
  80.   const xmlChar *ExternalID, const xmlChar *SystemID, const xmlChar *content) {
  81.     int i;
  82.     xmlEntityPtr ret;
  84.     for (i = 0;i < table->nb_entities;i++) {
  85.         ret = table->table[i];
  86. if (!xmlStrcmp(ret->name, name)) {
  87.     /*
  88.      * The entity is already defined in this Dtd, the spec says to NOT
  89.      * override it ... Is it worth a Warning ??? !!!
  90.      * Not having a cprinting context this seems hard ...
  91.      */
  92.     if (((type == XML_INTERNAL_PARAMETER_ENTITY) ||
  93.          (type == XML_EXTERNAL_PARAMETER_ENTITY)) &&
  94.         ((ret->etype == XML_INTERNAL_PARAMETER_ENTITY) ||
  95.          (ret->etype == XML_EXTERNAL_PARAMETER_ENTITY)))
  96. return(NULL);
  97.     else
  98.     if (((type != XML_INTERNAL_PARAMETER_ENTITY) &&
  99.          (type != XML_EXTERNAL_PARAMETER_ENTITY)) &&
  100.         ((ret->etype != XML_INTERNAL_PARAMETER_ENTITY) &&
  101.          (ret->etype != XML_EXTERNAL_PARAMETER_ENTITY)))
  102. return(NULL);
  103. }
  104.     }
  105.     if (table->nb_entities >= table->max_entities) {
  106.         /*
  107.  * need more elements.
  108.  */
  109. table->max_entities *= 2;
  110. table->table = (xmlEntityPtr *) 
  111.     xmlRealloc(table->table,
  112.        table->max_entities * sizeof(xmlEntityPtr));
  113. if (table->table == NULL) {
  114.     perror("realloc failed");
  115.     return(NULL);
  116. }
  117.     }
  118.     ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
  119.     if (ret == NULL) {
  120. fprintf(stderr, "xmlAddEntity: out of memoryn");
  121. return(NULL);
  122.     }
  123.     memset(ret, 0, sizeof(xmlEntity));
  124.     ret->type = XML_ENTITY_DECL;
  125.     table->table[table->nb_entities] = ret;
  127.     /*
  128.      * fill the structure.
  129.      */
  130.     ret->name = xmlStrdup(name);
  131.     ret->etype = type;
  132.     if (ExternalID != NULL)
  133. ret->ExternalID = xmlStrdup(ExternalID);
  134.     if (SystemID != NULL)
  135. ret->SystemID = xmlStrdup(SystemID);
  136.     if (content != NULL) {
  137.         ret->length = xmlStrlen(content);
  138. ret->content = xmlStrndup(content, ret->length);
  139.      } else {
  140.         ret->length = 0;
  141.         ret->content = NULL;
  142.     }
  143.     ret->orig = NULL;
  144.     table->nb_entities++;
  146.     return(ret);
  147. }
  149. /**
  150.  * xmlInitializePredefinedEntities:
  151.  *
  152.  * Set up the predefined entities.
  153.  */
  154. void xmlInitializePredefinedEntities(void) {
  155.     int i;
  156.     xmlChar name[50];
  157.     xmlChar value[50];
  158.     const char *in;
  159.     xmlChar *out;
  161.     if (xmlPredefinedEntities != NULL) return;
  163.     xmlPredefinedEntities = xmlCreateEntitiesTable();
  164.     for (i = 0;i < sizeof(xmlPredefinedEntityValues) / 
  165.                    sizeof(xmlPredefinedEntityValues[0]);i++) {
  166.         in = xmlPredefinedEntityValues[i].name;
  167. out = &name[0];
  168. for (;(*out++ = (xmlChar) *in);)in++;
  169.         in = xmlPredefinedEntityValues[i].value;
  170. out = &value[0];
  171. for (;(*out++ = (xmlChar) *in);)in++;
  172.         xmlAddEntity(xmlPredefinedEntities, (const xmlChar *) &name[0],
  173.              XML_INTERNAL_PREDEFINED_ENTITY, NULL, NULL,
  174.      &value[0]);
  175.     }
  176. }
  178. /**
  179.  * xmlCleanupPredefinedEntities:
  180.  *
  181.  * Cleanup up the predefined entities table.
  182.  */
  183. void xmlCleanupPredefinedEntities(void) {
  184.     if (xmlPredefinedEntities == NULL) return;
  186.     xmlFreeEntitiesTable(xmlPredefinedEntities);
  187.     xmlPredefinedEntities = NULL;
  188. }
  190. /**
  191.  * xmlGetPredefinedEntity:
  192.  * @name:  the entity name
  193.  *
  194.  * Check whether this name is an predefined entity.
  195.  *
  196.  * Returns NULL if not, othervise the entity
  197.  */
  198. xmlEntityPtr
  199. xmlGetPredefinedEntity(const xmlChar *name) {
  200.     int i;
  201.     xmlEntityPtr cur;
  203.     if (xmlPredefinedEntities == NULL)
  204.         xmlInitializePredefinedEntities();
  205.     for (i = 0;i < xmlPredefinedEntities->nb_entities;i++) {
  206. cur = xmlPredefinedEntities->table[i];
  207. if (!xmlStrcmp(cur->name, name)) return(cur);
  208.     }
  209.     return(NULL);
  210. }
  212. /**
  213.  * xmlAddDtdEntity:
  214.  * @doc:  the document
  215.  * @name:  the entity name
  216.  * @type:  the entity type XML_xxx_yyy_ENTITY
  217.  * @ExternalID:  the entity external ID if available
  218.  * @SystemID:  the entity system ID if available
  219.  * @content:  the entity content
  220.  *
  221.  * Register a new entity for this document DTD external subset.
  222.  *
  223.  * Returns a pointer to the entity or NULL in case of error
  224.  */
  225. xmlEntityPtr
  226. xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
  227.         const xmlChar *ExternalID, const xmlChar *SystemID,
  228. const xmlChar *content) {
  229.     xmlEntitiesTablePtr table;
  230.     xmlEntityPtr ret;
  231.     xmlDtdPtr dtd;
  233.     if (doc == NULL) {
  234.         fprintf(stderr,
  235.         "xmlAddDtdEntity: doc == NULL !n");
  236. return(NULL);
  237.     }
  238.     if (doc->extSubset == NULL) {
  239.         fprintf(stderr,
  240.         "xmlAddDtdEntity: document without external subset !n");
  241. return(NULL);
  242.     }
  243.     dtd = doc->extSubset;
  244.     table = (xmlEntitiesTablePtr) dtd->entities;
  245.     if (table == NULL) {
  246.         table = xmlCreateEntitiesTable();
  247. dtd->entities = table;
  248.     }
  249.     ret = xmlAddEntity(table, name, type, ExternalID, SystemID, content);
  250.     if (ret == NULL) return(NULL);
  252.     /*
  253.      * Link it to the Dtd
  254.      */
  255.     ret->parent = dtd;
  256.     ret->doc = dtd->doc;
  257.     if (dtd->last == NULL) {
  258. dtd->children = dtd->last = (xmlNodePtr) ret;
  259.     } else {
  260.         dtd->last->next = (xmlNodePtr) ret;
  261. ret->prev = dtd->last;
  262. dtd->last = (xmlNodePtr) ret;
  263.     }
  264.     return(ret);
  265. }
  267. /**
  268.  * xmlAddDocEntity:
  269.  * @doc:  the document
  270.  * @name:  the entity name
  271.  * @type:  the entity type XML_xxx_yyy_ENTITY
  272.  * @ExternalID:  the entity external ID if available
  273.  * @SystemID:  the entity system ID if available
  274.  * @content:  the entity content
  275.  *
  276.  * Register a new entity for this document.
  277.  *
  278.  * Returns a pointer to the entity or NULL in case of error
  279.  */
  280. xmlEntityPtr
  281. xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
  282.         const xmlChar *ExternalID, const xmlChar *SystemID,
  283.         const xmlChar *content) {
  284.     xmlEntitiesTablePtr table;
  285.     xmlEntityPtr ret;
  286.     xmlDtdPtr dtd;
  288.     if (doc == NULL) {
  289.         fprintf(stderr,
  290.         "xmlAddDocEntity: document is NULL !n");
  291. return(NULL);
  292.     }
  293.     if (doc->intSubset == NULL) {
  294.         fprintf(stderr,
  295.         "xmlAddDtdEntity: document without internal subset !n");
  296. return(NULL);
  297.     }
  298.     dtd = doc->intSubset;
  299.     table = (xmlEntitiesTablePtr) doc->intSubset->entities;
  300.     if (table == NULL) {
  301.         table = xmlCreateEntitiesTable();
  302. doc->intSubset->entities = table;
  303.     }
  304.     ret = xmlAddEntity(table, name, type, ExternalID, SystemID, content);
  305.     if (ret == NULL) return(NULL);
  307.     /*
  308.      * Link it to the Dtd
  309.      */
  310.     ret->parent = dtd;
  311.     ret->doc = dtd->doc;
  312.     if (dtd->last == NULL) {
  313. dtd->children = dtd->last = (xmlNodePtr) ret;
  314.     } else {
  315. dtd->last->next = (xmlNodePtr) ret;
  316. ret->prev = dtd->last;
  317. dtd->last = (xmlNodePtr) ret;
  318.     }
  319.     return(ret);
  320. }
  322. #ifdef WITH_EXTRA_ENT_DETECT
  323. /**
  324.  * xmlEntityCheckReference:
  325.  * @ent:  an existing entity
  326.  * @to:  the entity name it's referencing
  327.  *
  328.  * Function to keep track of references and detect cycles (well formedness 
  329.  * errors !).
  330.  *
  331.  * Returns: 0 if Okay, -1 in case of general error, 1 in case of loop 
  332.  *      detection.
  333.  */
  334. int
  335. xmlEntityCheckReference(xmlEntityPtr ent, const xmlChar *to) {
  336.     int i;
  337.     xmlDocPtr doc;
  339.     if (ent == NULL) return(-1);
  340.     if (to == NULL) return(-1);
  342.     doc = ent->doc;
  343.     if (doc == NULL) return(-1);
  345. #ifdef DEBUG_ENT_REF
  346.     printf("xmlEntityCheckReference(%s to %s)n", ent->name, to);
  347. #endif
  350.     /*
  351.      * Do a recursive checking
  352.      */
  353.     for (i = 0;i < ent->entNr;i++) {
  354. xmlEntityPtr indir = NULL;
  356. if (!xmlStrcmp(to, ent->entTab[i]))
  357.     return(1);
  359. switch (ent->etype) {
  360.             case XML_INTERNAL_GENERAL_ENTITY:
  361.             case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
  362. indir = xmlGetDocEntity(doc, ent->entTab[i]);
  363. break;
  364.             case XML_INTERNAL_PARAMETER_ENTITY:
  365.             case XML_EXTERNAL_PARAMETER_ENTITY:
  366. indir = xmlGetDtdEntity(doc, ent->entTab[i]);
  367. break;
  368.             case XML_INTERNAL_PREDEFINED_ENTITY:
  369.             case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
  370. break;
  371. }
  372. if (xmlEntityCheckReference(indir, to) == 1)
  373.     return(1);
  374.     }
  375.     return(0);
  376. }
  378. /**
  379.  * xmlEntityAddReference:
  380.  * @ent:  an existing entity
  381.  * @to:  the entity name it's referencing
  382.  *
  383.  * Function to register reuse of an existing entity from a (new) one
  384.  * Used to keep track of references and detect cycles (well formedness 
  385.  * errors !).
  386.  *
  387.  * Returns: 0 if Okay, -1 in case of general error, 1 in case of loop 
  388.  *      detection.
  389.  */
  390. int
  391. xmlEntityAddReference(xmlEntityPtr ent, const xmlChar *to) {
  392.     int i;
  393.     xmlDocPtr doc;
  394.     xmlEntityPtr indir = NULL;
  396.     if (ent == NULL) return(-1);
  397.     if (to == NULL) return(-1);
  399.     doc = ent->doc;
  400.     if (doc == NULL) return(-1);
  402. #ifdef DEBUG_ENT_REF
  403.     printf("xmlEntityAddReference(%s to %s)n", ent->name, to);
  404. #endif
  405.     if (ent->entTab == NULL) {
  406. ent->entNr = 0;
  407. ent->entMax = 5;
  408. ent->entTab = (xmlChar **) xmlMalloc(ent->entMax * sizeof(xmlChar *));
  409. if (ent->entTab == NULL) {
  410.     fprintf(stderr, "xmlEntityAddReference: out of memory !n");
  411.     return(-1);
  412. }
  413.     }
  415.     for (i = 0;i < ent->entNr;i++) {
  416. if (!xmlStrcmp(to, ent->entTab[i]))
  417.     return(0);
  418.     }
  420.     /*
  421.      * Do a recursive checking
  422.      */
  424.     switch (ent->etype) {
  425. case XML_INTERNAL_GENERAL_ENTITY:
  426. case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
  427.     indir = xmlGetDocEntity(doc, to);
  428.     break;
  429. case XML_INTERNAL_PARAMETER_ENTITY:
  430. case XML_EXTERNAL_PARAMETER_ENTITY:
  431.     indir = xmlGetDtdEntity(doc, to);
  432.     break;
  433. case XML_INTERNAL_PREDEFINED_ENTITY:
  434. case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
  435.     break;
  436.     }
  437.     if ((indir != NULL) &&
  438. (xmlEntityCheckReference(indir, ent->name) == 1))
  439. return(1);
  441.     /*
  442.      * Add this to the list
  443.      */
  444.     if (ent->entMax <= ent->entNr) {
  445. ent->entMax *= 2;
  446. ent->entTab = (xmlChar **) xmlRealloc(ent->entTab,
  447.                               ent->entMax * sizeof(xmlChar *));
  448. if (ent->entTab == NULL) {
  449.     fprintf(stderr, "xmlEntityAddReference: out of memory !n");
  450.     return(-1);
  451. }
  452.     }
  453.     ent->entTab[ent->entNr++] = xmlStrdup(to);
  454.     return(0);
  455. }
  456. #endif
  458. /**
  459.  * xmlGetParameterEntity:
  460.  * @doc:  the document referencing the entity
  461.  * @name:  the entity name
  462.  *
  463.  * Do an entity lookup in the internal and external subsets and
  464.  * returns the corresponding parameter entity, if found.
  465.  * 
  466.  * Returns A pointer to the entity structure or NULL if not found.
  467.  */
  468. xmlEntityPtr
  469. xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
  470.     int i;
  471.     xmlEntityPtr cur;
  472.     xmlEntitiesTablePtr table;
  474.     if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
  475. table = (xmlEntitiesTablePtr) doc->intSubset->entities;
  476. for (i = 0;i < table->nb_entities;i++) {
  477.     cur = table->table[i];
  478.     if (((cur->etype ==  XML_INTERNAL_PARAMETER_ENTITY) ||
  479.          (cur->etype ==  XML_EXTERNAL_PARAMETER_ENTITY)) &&
  480. (!xmlStrcmp(cur->name, name))) return(cur);
  481. }
  482.     }
  483.     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
  484. table = (xmlEntitiesTablePtr) doc->extSubset->entities;
  485. for (i = 0;i < table->nb_entities;i++) {
  486.     cur = table->table[i];
  487.     if (((cur->etype ==  XML_INTERNAL_PARAMETER_ENTITY) ||
  488.          (cur->etype ==  XML_EXTERNAL_PARAMETER_ENTITY)) &&
  489. (!xmlStrcmp(cur->name, name))) return(cur);
  490. }
  491.     }
  492.     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
  493. table = (xmlEntitiesTablePtr) doc->extSubset->entities;
  494. for (i = 0;i < table->nb_entities;i++) {
  495.     cur = table->table[i];
  496.     if (((cur->etype ==  XML_INTERNAL_PARAMETER_ENTITY) ||
  497.          (cur->etype ==  XML_EXTERNAL_PARAMETER_ENTITY)) &&
  498. (!xmlStrcmp(cur->name, name))) return(cur);
  499. }
  500.     }
  501.     return(NULL);
  502. }
  504. /**
  505.  * xmlGetDtdEntity:
  506.  * @doc:  the document referencing the entity
  507.  * @name:  the entity name
  508.  *
  509.  * Do an entity lookup in the Dtd entity hash table and
  510.  * returns the corresponding entity, if found.
  511.  * 
  512.  * Returns A pointer to the entity structure or NULL if not found.
  513.  */
  514. xmlEntityPtr
  515. xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
  516.     int i;
  517.     xmlEntityPtr cur;
  518.     xmlEntitiesTablePtr table;
  520.     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
  521. table = (xmlEntitiesTablePtr) doc->extSubset->entities;
  522. for (i = 0;i < table->nb_entities;i++) {
  523.     cur = table->table[i];
  524.     if ((cur->etype !=  XML_INTERNAL_PARAMETER_ENTITY) &&
  525.         (cur->etype !=  XML_EXTERNAL_PARAMETER_ENTITY) &&
  526.         (!xmlStrcmp(cur->name, name))) return(cur);
  527. }
  528.     }
  529.     return(NULL);
  530. }
  532. /**
  533.  * xmlGetDocEntity:
  534.  * @doc:  the document referencing the entity
  535.  * @name:  the entity name
  536.  *
  537.  * Do an entity lookup in the document entity hash table and
  538.  * returns the corrsponding entity, otherwise a lookup is done
  539.  * in the predefined entities too.
  540.  * 
  541.  * Returns A pointer to the entity structure or NULL if not found.
  542.  */
  543. xmlEntityPtr
  544. xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
  545.     int i;
  546.     xmlEntityPtr cur;
  547.     xmlEntitiesTablePtr table;
  549.     if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
  550. table = (xmlEntitiesTablePtr) doc->intSubset->entities;
  551. for (i = 0;i < table->nb_entities;i++) {
  552.     cur = table->table[i];
  553.     if ((cur->etype !=  XML_INTERNAL_PARAMETER_ENTITY) &&
  554.         (cur->etype !=  XML_EXTERNAL_PARAMETER_ENTITY) &&
  555.         (!xmlStrcmp(cur->name, name))) return(cur);
  556. }
  557.     }
  558.     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
  559. table = (xmlEntitiesTablePtr) doc->extSubset->entities;
  560. for (i = 0;i < table->nb_entities;i++) {
  561.     cur = table->table[i];
  562.     if ((cur->etype !=  XML_INTERNAL_PARAMETER_ENTITY) &&
  563.         (cur->etype !=  XML_EXTERNAL_PARAMETER_ENTITY) &&
  564.         (!xmlStrcmp(cur->name, name))) return(cur);
  565. }
  566.     }
  567.     if (xmlPredefinedEntities == NULL)
  568.         xmlInitializePredefinedEntities();
  569.     table = xmlPredefinedEntities;
  570.     for (i = 0;i < table->nb_entities;i++) {
  571. cur = table->table[i];
  572. if ((cur->etype !=  XML_INTERNAL_PARAMETER_ENTITY) &&
  573.     (cur->etype !=  XML_EXTERNAL_PARAMETER_ENTITY) &&
  574.     (!xmlStrcmp(cur->name, name))) return(cur);
  575.     }
  577.     return(NULL);
  578. }
  580. /*
  581.  * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD]
  582.  *                  | [#x10000-#x10FFFF]
  583.  * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF.
  584.  */
  585. #define IS_CHAR(c)
  586.     (((c) == 0x09) || ((c) == 0x0a) || ((c) == 0x0d) ||
  587.      (((c) >= 0x20) && ((c) != 0xFFFE) && ((c) != 0xFFFF)))
  589. /*
  590.  * A buffer used for converting entities to their equivalent and back.
  591.  */
  592. static int buffer_size = 0;
  593. static xmlChar *buffer = NULL;
  595. int growBuffer(void) {
  596.     buffer_size *= 2;
  597.     buffer = (xmlChar *) xmlRealloc(buffer, buffer_size * sizeof(xmlChar));
  598.     if (buffer == NULL) {
  599.         perror("realloc failed");
  600. return(-1);
  601.     }
  602.     return(0);
  603. }
  606. /**
  607.  * xmlEncodeEntities:
  608.  * @doc:  the document containing the string
  609.  * @input:  A string to convert to XML.
  610.  *
  611.  * Do a global encoding of a string, replacing the predefined entities
  612.  * and non ASCII values with their entities and CharRef counterparts.
  613.  *
  614.  * TODO: remove xmlEncodeEntities, once we are not afraid of breaking binary
  615.  *       compatibility
  616.  *
  617.  * People must migrate their code to xmlEncodeEntitiesReentrant !
  618.  * This routine will issue a warning when encountered.
  619.  * 
  620.  * Returns A newly allocated string with the substitution done.
  621.  */
  622. const xmlChar *
  623. xmlEncodeEntities(xmlDocPtr doc, const xmlChar *input) {
  624.     const xmlChar *cur = input;
  625.     xmlChar *out = buffer;
  626.     static int warning = 1;
  627.     int html = 0;
  630.     if (warning) {
  631.     fprintf(stderr, "Deprecated API xmlEncodeEntities() usedn");
  632.     fprintf(stderr, "   change code to use xmlEncodeEntitiesReentrant()n");
  633.     warning = 0;
  634.     }
  636.     if (input == NULL) return(NULL);
  637.     if (doc != NULL)
  638.         html = (doc->type == XML_HTML_DOCUMENT_NODE);
  640.     if (buffer == NULL) {
  641.         buffer_size = 1000;
  642.         buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
  643. if (buffer == NULL) {
  644.     perror("malloc failed");
  645.             return(NULL);
  646. }
  647. out = buffer;
  648.     }
  649.     while (*cur != '') {
  650.         if (out - buffer > buffer_size - 100) {
  651.     int index = out - buffer;
  653.     growBuffer();
  654.     out = &buffer[index];
  655. }
  657. /*
  658.  * By default one have to encode at least '<', '>', '"' and '&' !
  659.  */
  660. if (*cur == '<') {
  661.     *out++ = '&';
  662.     *out++ = 'l';
  663.     *out++ = 't';
  664.     *out++ = ';';
  665. } else if (*cur == '>') {
  666.     *out++ = '&';
  667.     *out++ = 'g';
  668.     *out++ = 't';
  669.     *out++ = ';';
  670. } else if (*cur == '&') {
  671.     *out++ = '&';
  672.     *out++ = 'a';
  673.     *out++ = 'm';
  674.     *out++ = 'p';
  675.     *out++ = ';';
  676. } else if (*cur == '"') {
  677.     *out++ = '&';
  678.     *out++ = 'q';
  679.     *out++ = 'u';
  680.     *out++ = 'o';
  681.     *out++ = 't';
  682.     *out++ = ';';
  683. } else if ((*cur == ''') && (!html)) {
  684.     *out++ = '&';
  685.     *out++ = 'a';
  686.     *out++ = 'p';
  687.     *out++ = 'o';
  688.     *out++ = 's';
  689.     *out++ = ';';
  690. } else if (((*cur >= 0x20) && (*cur < 0x80)) ||
  691.     (*cur == 'n') || (*cur == 'r') || (*cur == 't')) {
  692.     /*
  693.      * default case, just copy !
  694.      */
  695.     *out++ = *cur;
  696. #ifndef USE_UTF_8
  697. } else if ((sizeof(xmlChar) == 1) && (*cur >= 0x80)) {
  698.     char buf[10], *ptr;
  699. #ifdef HAVE_SNPRINTF
  700.     snprintf(buf, 9, "&#%d;", *cur);
  701. #else
  702.     sprintf(buf, "&#%d;", *cur);
  703. #endif
  704.             ptr = buf;
  705.     while (*ptr != 0) *out++ = *ptr++;
  706. #endif
  707. } else if (IS_CHAR(*cur)) {
  708.     char buf[10], *ptr;
  710. #ifdef HAVE_SNPRINTF
  711.     snprintf(buf, 9, "&#%d;", *cur);
  712. #else
  713.     sprintf(buf, "&#%d;", *cur);
  714. #endif
  715.             ptr = buf;
  716.     while (*ptr != 0) *out++ = *ptr++;
  717. }
  718. #if 0
  719. else {
  720.     /*
  721.      * default case, this is not a valid char !
  722.      * Skip it...
  723.      */
  724.     fprintf(stderr, "xmlEncodeEntities: invalid char %dn", (int) *cur);
  725. }
  726. #endif
  727. cur++;
  728.     }
  729.     *out++ = 0;
  730.     return(buffer);
  731. }
  733. /*
  734.  * Macro used to grow the current buffer.
  735.  */
  736. #define growBufferReentrant() {
  737.     buffer_size *= 2;
  738.     buffer = (xmlChar *)
  739.      xmlRealloc(buffer, buffer_size * sizeof(xmlChar));
  740.     if (buffer == NULL) {
  741. perror("realloc failed");
  742. return(NULL);
  743.     }
  744. }
  747. /**
  748.  * xmlEncodeEntitiesReentrant:
  749.  * @doc:  the document containing the string
  750.  * @input:  A string to convert to XML.
  751.  *
  752.  * Do a global encoding of a string, replacing the predefined entities
  753.  * and non ASCII values with their entities and CharRef counterparts.
  754.  * Contrary to xmlEncodeEntities, this routine is reentrant, and result
  755.  * must be deallocated.
  756.  *
  757.  * TODO !!!! Once moved to UTF-8 internal encoding, the encoding of non-ascii
  758.  *           get erroneous.
  759.  *
  760.  * Returns A newly allocated string with the substitution done.
  761.  */
  762. xmlChar *
  763. xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
  764.     const xmlChar *cur = input;
  765.     xmlChar *buffer = NULL;
  766.     xmlChar *out = NULL;
  767.     int buffer_size = 0;
  768.     int html = 0;
  770.     if (input == NULL) return(NULL);
  771.     if (doc != NULL)
  772.         html = (doc->type == XML_HTML_DOCUMENT_NODE);
  774.     /*
  775.      * allocate an translation buffer.
  776.      */
  777.     buffer_size = 1000;
  778.     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
  779.     if (buffer == NULL) {
  780. perror("malloc failed");
  781. return(NULL);
  782.     }
  783.     out = buffer;
  785.     while (*cur != '') {
  786.         if (out - buffer > buffer_size - 100) {
  787.     int index = out - buffer;
  789.     growBufferReentrant();
  790.     out = &buffer[index];
  791. }
  793. /*
  794.  * By default one have to encode at least '<', '>', '"' and '&' !
  795.  */
  796. if (*cur == '<') {
  797.     *out++ = '&';
  798.     *out++ = 'l';
  799.     *out++ = 't';
  800.     *out++ = ';';
  801. } else if (*cur == '>') {
  802.     *out++ = '&';
  803.     *out++ = 'g';
  804.     *out++ = 't';
  805.     *out++ = ';';
  806. } else if (*cur == '&') {
  807.     *out++ = '&';
  808.     *out++ = 'a';
  809.     *out++ = 'm';
  810.     *out++ = 'p';
  811.     *out++ = ';';
  812. } else if (*cur == '"') {
  813.     *out++ = '&';
  814.     *out++ = 'q';
  815.     *out++ = 'u';
  816.     *out++ = 'o';
  817.     *out++ = 't';
  818.     *out++ = ';';
  819. #if 0
  820. } else if ((*cur == ''') && (!html)) {
  821.     *out++ = '&';
  822.     *out++ = 'a';
  823.     *out++ = 'p';
  824.     *out++ = 'o';
  825.     *out++ = 's';
  826.     *out++ = ';';
  827. #endif
  828. } else if (((*cur >= 0x20) && (*cur < 0x80)) ||
  829.     (*cur == 'n') || (*cur == 'r') || (*cur == 't')) {
  830.     /*
  831.      * default case, just copy !
  832.      */
  833.     *out++ = *cur;
  834. } else if (*cur >= 0x80) {
  835.     if (html) {
  836. char buf[15], *ptr;
  838. /*
  839.  * TODO: improve by searching in html40EntitiesTable
  840.  */
  841. #ifdef HAVE_SNPRINTF
  842. snprintf(buf, 9, "&#%d;", *cur);
  843. #else
  844. sprintf(buf, "&#%d;", *cur);
  845. #endif
  846. ptr = buf;
  847. while (*ptr != 0) *out++ = *ptr++;
  848.     } else if (doc->encoding != NULL) {
  849. /*
  850.  * TODO !!!
  851.  */
  852. *out++ = *cur;
  853.     } else {
  854. /*
  855.  * We assume we have UTF-8 input.
  856.  */
  857. char buf[10], *ptr;
  858. int val = 0, l = 1;
  860. if (*cur < 0xC0) {
  861.     fprintf(stderr,
  862.     "xmlEncodeEntitiesReentrant : input not UTF-8n");
  863.     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
  864. #ifdef HAVE_SNPRINTF
  865.     snprintf(buf, 9, "&#%d;", *cur);
  866. #else
  867.     sprintf(buf, "&#%d;", *cur);
  868. #endif
  869.     ptr = buf;
  870.     while (*ptr != 0) *out++ = *ptr++;
  871.     continue;
  872. } else if (*cur < 0xE0) {
  873.                     val = (cur[0]) & 0x1F;
  874.     val <<= 6;
  875.     val |= (cur[1]) & 0x3F;
  876.     l = 2;
  877. } else if (*cur < 0xF0) {
  878.                     val = (cur[0]) & 0x0F;
  879.     val <<= 6;
  880.     val |= (cur[1]) & 0x3F;
  881.     val <<= 6;
  882.     val |= (cur[2]) & 0x3F;
  883.     l = 3;
  884. } else if (*cur < 0xF8) {
  885.                     val = (cur[0]) & 0x07;
  886.     val <<= 6;
  887.     val |= (cur[1]) & 0x3F;
  888.     val <<= 6;
  889.     val |= (cur[2]) & 0x3F;
  890.     val <<= 6;
  891.     val |= (cur[3]) & 0x3F;
  892.     l = 4;
  893. }
  894. if ((l == 1) || (!IS_CHAR(val))) {
  895.     fprintf(stderr,
  896. "xmlEncodeEntitiesReentrant : char out of rangen");
  897.     doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
  898. #ifdef HAVE_SNPRINTF
  899.     snprintf(buf, 9, "&#%d;", *cur);
  900. #else
  901.     sprintf(buf, "&#%d;", *cur);
  902. #endif
  903.     ptr = buf;
  904.     while (*ptr != 0) *out++ = *ptr++;
  905.     cur++;
  906.     continue;
  907. }
  908. /*
  909.  * We could do multiple things here. Just save as a char ref
  910.  */
  911. #ifdef HAVE_SNPRINTF
  912. snprintf(buf, 14, "&#x%X;", val);
  913. #else
  914. sprintf(buf, "&#x%X;", val);
  915. #endif
  916. buf[14] = 0;
  917. ptr = buf;
  918. while (*ptr != 0) *out++ = *ptr++;
  919. cur += l;
  920. continue;
  921.     }
  922. } else if (IS_CHAR(*cur)) {
  923.     char buf[10], *ptr;
  925. #ifdef HAVE_SNPRINTF
  926.     snprintf(buf, 9, "&#%d;", *cur);
  927. #else
  928.     sprintf(buf, "&#%d;", *cur);
  929. #endif
  930.             ptr = buf;
  931.     while (*ptr != 0) *out++ = *ptr++;
  932. }
  933. #if 0
  934. else {
  935.     /*
  936.      * default case, this is not a valid char !
  937.      * Skip it...
  938.      */
  939.     fprintf(stderr, "xmlEncodeEntities: invalid char %dn", (int) *cur);
  940. }
  941. #endif
  942. cur++;
  943.     }
  944.     *out++ = 0;
  945.     return(buffer);
  946. }
  948. /**
  949.  * xmlCreateEntitiesTable:
  950.  *
  951.  * create and initialize an empty entities hash table.
  952.  *
  953.  * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
  954.  */
  955. xmlEntitiesTablePtr
  956. xmlCreateEntitiesTable(void) {
  957.     xmlEntitiesTablePtr ret;
  959.     ret = (xmlEntitiesTablePtr) 
  960.          xmlMalloc(sizeof(xmlEntitiesTable));
  961.     if (ret == NULL) {
  962.         fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failedn",
  963.         (long)sizeof(xmlEntitiesTable));
  964.         return(NULL);
  965.     }
  966.     ret->max_entities = XML_MIN_ENTITIES_TABLE;
  967.     ret->nb_entities = 0;
  968.     ret->table = (xmlEntityPtr *) 
  969.          xmlMalloc(ret->max_entities * sizeof(xmlEntityPtr));
  970.     if (ret == NULL) {
  971.         fprintf(stderr, "xmlCreateEntitiesTable : xmlMalloc(%ld) failedn",
  972.         ret->max_entities * (long)sizeof(xmlEntityPtr));
  973. xmlFree(ret);
  974.         return(NULL);
  975.     }
  976.     return(ret);
  977. }
  979. /**
  980.  * xmlFreeEntitiesTable:
  981.  * @table:  An entity table
  982.  *
  983.  * Deallocate the memory used by an entities hash table.
  984.  */
  985. void
  986. xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
  987.     int i;
  989.     if (table == NULL) return;
  991.     for (i = 0;i < table->nb_entities;i++) {
  992.         xmlFreeEntity(table->table[i]);
  993.     }
  994.     xmlFree(table->table);
  995.     xmlFree(table);
  996. }
  998. /**
  999.  * xmlCopyEntitiesTable:
  1000.  * @table:  An entity table
  1001.  *
  1002.  * Build a copy of an entity table.
  1003.  * 
  1004.  * Returns the new xmlEntitiesTablePtr or NULL in case of error.
  1005.  */
  1006. xmlEntitiesTablePtr
  1007. xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
  1008.     xmlEntitiesTablePtr ret;
  1009.     xmlEntityPtr cur, ent;
  1010.     int i;
  1012.     ret = (xmlEntitiesTablePtr) xmlMalloc(sizeof(xmlEntitiesTable));
  1013.     if (ret == NULL) {
  1014.         fprintf(stderr, "xmlCopyEntitiesTable: out of memory !n");
  1015. return(NULL);
  1016.     }
  1017.     ret->table = (xmlEntityPtr *) xmlMalloc(table->max_entities *
  1018.                                             sizeof(xmlEntityPtr));
  1019.     if (ret->table == NULL) {
  1020.         fprintf(stderr, "xmlCopyEntitiesTable: out of memory !n");
  1021. xmlFree(ret);
  1022. return(NULL);
  1023.     }
  1024.     ret->max_entities = table->max_entities;
  1025.     ret->nb_entities = table->nb_entities;
  1026.     for (i = 0;i < ret->nb_entities;i++) {
  1027. cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
  1028. if (cur == NULL) {
  1029.     fprintf(stderr, "xmlCopyEntityTable: out of memory !n");
  1030.     xmlFree(ret);
  1031.     xmlFree(ret->table);
  1032.     return(NULL);
  1033. }
  1034. memset(cur, 0, sizeof(xmlEntity));
  1035. cur->type = XML_ELEMENT_DECL;
  1036. ret->table[i] = cur;
  1037. ent = table->table[i];
  1039. cur->etype = ent->etype;
  1040. if (ent->name != NULL)
  1041.     cur->name = xmlStrdup(ent->name);
  1042. if (ent->ExternalID != NULL)
  1043.     cur->ExternalID = xmlStrdup(ent->ExternalID);
  1044. if (ent->SystemID != NULL)
  1045.     cur->SystemID = xmlStrdup(ent->SystemID);
  1046. if (ent->content != NULL)
  1047.     cur->content = xmlStrdup(ent->content);
  1048. if (ent->orig != NULL)
  1049.     cur->orig = xmlStrdup(ent->orig);
  1050.     }
  1051.     return(ret);
  1052. }
  1054. /**
  1055.  * xmlDumpEntityDecl:
  1056.  * @buf:  An XML buffer.
  1057.  * @ent:  An entity table
  1058.  *
  1059.  * This will dump the content of the entity table as an XML DTD definition
  1060.  */
  1061. void
  1062. xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
  1063.     switch (ent->etype) {
  1064. case XML_INTERNAL_GENERAL_ENTITY:
  1065.     xmlBufferWriteChar(buf, "<!ENTITY ");
  1066.     xmlBufferWriteCHAR(buf, ent->name);
  1067.     xmlBufferWriteChar(buf, " ");
  1068.     if (ent->orig != NULL)
  1069. xmlBufferWriteQuotedString(buf, ent->orig);
  1070.     else
  1071. xmlBufferWriteQuotedString(buf, ent->content);
  1072.     xmlBufferWriteChar(buf, ">n");
  1073.     break;
  1074. case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
  1075.     xmlBufferWriteChar(buf, "<!ENTITY ");
  1076.     xmlBufferWriteCHAR(buf, ent->name);
  1077.     if (ent->ExternalID != NULL) {
  1078.  xmlBufferWriteChar(buf, " PUBLIC ");
  1079.  xmlBufferWriteQuotedString(buf, ent->ExternalID);
  1080.  xmlBufferWriteChar(buf, " ");
  1081.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1082.     } else {
  1083.  xmlBufferWriteChar(buf, " SYSTEM ");
  1084.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1085.     }
  1086.     xmlBufferWriteChar(buf, ">n");
  1087.     break;
  1088. case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
  1089.     xmlBufferWriteChar(buf, "<!ENTITY ");
  1090.     xmlBufferWriteCHAR(buf, ent->name);
  1091.     if (ent->ExternalID != NULL) {
  1092.  xmlBufferWriteChar(buf, " PUBLIC ");
  1093.  xmlBufferWriteQuotedString(buf, ent->ExternalID);
  1094.  xmlBufferWriteChar(buf, " ");
  1095.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1096.     } else {
  1097.  xmlBufferWriteChar(buf, " SYSTEM ");
  1098.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1099.     }
  1100.     if (ent->content != NULL) { /* Should be true ! */
  1101. xmlBufferWriteChar(buf, " NDATA ");
  1102. if (ent->orig != NULL)
  1103.     xmlBufferWriteCHAR(buf, ent->orig);
  1104. else
  1105.     xmlBufferWriteCHAR(buf, ent->content);
  1106.     }
  1107.     xmlBufferWriteChar(buf, ">n");
  1108.     break;
  1109. case XML_INTERNAL_PARAMETER_ENTITY:
  1110.     xmlBufferWriteChar(buf, "<!ENTITY % ");
  1111.     xmlBufferWriteCHAR(buf, ent->name);
  1112.     xmlBufferWriteChar(buf, " ");
  1113.     if (ent->orig == NULL)
  1114. xmlBufferWriteQuotedString(buf, ent->content);
  1115.     else
  1116. xmlBufferWriteQuotedString(buf, ent->orig);
  1117.     xmlBufferWriteChar(buf, ">n");
  1118.     break;
  1119. case XML_EXTERNAL_PARAMETER_ENTITY:
  1120.     xmlBufferWriteChar(buf, "<!ENTITY % ");
  1121.     xmlBufferWriteCHAR(buf, ent->name);
  1122.     if (ent->ExternalID != NULL) {
  1123.  xmlBufferWriteChar(buf, " PUBLIC ");
  1124.  xmlBufferWriteQuotedString(buf, ent->ExternalID);
  1125.  xmlBufferWriteChar(buf, " ");
  1126.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1127.     } else {
  1128.  xmlBufferWriteChar(buf, " SYSTEM ");
  1129.  xmlBufferWriteQuotedString(buf, ent->SystemID);
  1130.     }
  1131.     xmlBufferWriteChar(buf, ">n");
  1132.     break;
  1133. default:
  1134.     fprintf(stderr,
  1135. "xmlDumpEntitiesTable: internal: unknown type %dn",
  1136.     ent->etype);
  1137.     }
  1138. }
  1140. /**
  1141.  * xmlDumpEntitiesTable:
  1142.  * @buf:  An XML buffer.
  1143.  * @table:  An entity table
  1144.  *
  1145.  * This will dump the content of the entity table as an XML DTD definition
  1146.  */
  1147. void
  1148. xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
  1149.     int i;
  1150.     xmlEntityPtr cur;
  1152.     if (table == NULL) return;
  1154.     for (i = 0;i < table->nb_entities;i++) {
  1155.         cur = table->table[i];
  1156. xmlDumpEntityDecl(buf, cur);
  1157.     }
  1158. }