kc3-lang/libxml2/xml_entities.c

• Show log

  Commit

• Hash : 01791d57
  Author :
  Date : 1998-07-24T19:24:09
  

  Added the XML code developped at W3C, Daniel.
  

Download

• xml_entities.c

• /*
   * entities.c : implementation for the XML entities handking
   *
   * See Copyright for the status of this software.
   *
   * $Id$
   */
  
  #include <stdio.h>
  #include <malloc.h>
  #include <strings.h>
  #include "xml_entities.h"
  
  /*
   * A buffer used for converting entities to their equivalent and back.
   */
  static CHAR *buffer = NULL;
  static int buffer_size = 0;
  
  void growBuffer(void) {
      buffer_size *= 2;
      buffer = (CHAR *) realloc(buffer, buffer_size * sizeof(CHAR));
      if (buffer == NULL) {
  	perror("realloc failed");
  	exit(1);
      }
  }
  
  /*
   * xmlFreeEntity : clean-up an entity record.
   */
  
  void xmlFreeEntity(xmlEntityPtr entity) {
      if (entity == NULL) return;
  
      if (entity->value != NULL) free(entity->value);
      entity->value = NULL;
      if (entity->id != NULL)
  	free((char *) entity->id);
  }
  
  /*
   * xmlAddDocEntity : register a new entity for an entities table.
   */
  static void xmlAddEntity(xmlEntitiesTablePtr table, CHAR *value,
                           const CHAR *id) {
      int i;
      xmlEntityPtr cur;
  
      for (i = 0;i < table->nb_entities;i++) {
          cur = &table->table[i];
  	if (!xmlStrcmp(cur->id, id)) {
  	    free(cur->value);
  	    cur->value = xmlStrdup(value);
  	}
      }
      if (table->nb_entities >= table->max_entities) {
          /*
  	 * need more elements.
  	 */
  	table->max_entities *= 2;
  	table->table = (xmlEntityPtr) 
  	    realloc(table->table, table->max_entities * sizeof(xmlEntity));
  	if (table->table) {
  	    perror("realloc failed");
  	    exit(1);
  	}
      }
      cur = &table->table[table->nb_entities];
      cur->value = xmlStrdup(value);
      cur->id = xmlStrdup(id);
      table->nb_entities++;
  }
  
  
  /*
   * xmlAddDtdEntity : register a new entity for this document.
   */
  void xmlAddDtdEntity(xmlDtdPtr dtd, CHAR *value, const CHAR *id) {
      xmlEntitiesTablePtr table;
  
      table = (xmlEntitiesTablePtr) dtd->entities;
      if (table == NULL) {
          table = xmlCreateEntitiesTable();
  	dtd->entities = table;
      }
      xmlAddEntity(table, value, id);
  }
  
  /*
   * xmlAddDocEntity : register a new entity for this document.
   */
  void xmlAddDocEntity(xmlDocPtr doc, CHAR *value, const CHAR *id) {
      xmlEntitiesTablePtr table;
  
      table = (xmlEntitiesTablePtr) doc->entities;
      if (table == NULL) {
          table = xmlCreateEntitiesTable();
  	doc->entities = table;
      }
      xmlAddEntity(table, value, id);
  }
  
  /*
   * xmlGetEntity : do an entity lookup in the hash table and
   *       returns the corrsponding CHAR *, if found, zero otherwise.
   */
  CHAR *xmlGetEntity(xmlDocPtr doc, const CHAR *id) {
      int i;
      xmlEntityPtr cur;
      xmlEntitiesTablePtr table;
  
      if (doc->entities == NULL) return(0);
      table = (xmlEntitiesTablePtr) doc->entities;
      for (i = 0;i < table->nb_entities;i++) {
          cur = &table->table[i];
  	if (!xmlStrcmp(cur->id, id)) return(cur->value);
      }
      return(NULL);
  }
  
  /*
   * xmlReadEntities : read an entity.
   */
  const CHAR *xmlReadEntity(xmlDocPtr doc, const CHAR **input) {
      static CHAR *entity = NULL;
      static int entity_size = 100;
      const CHAR *cur = *input;
  
      if (entity == NULL) {
          entity = (CHAR *) malloc(entity_size * sizeof(CHAR));
  	if (entity == NULL) {
  	    fprintf(stderr, "xmlReadEntity : cannot allocate %d bytes\n",
  	            entity_size * sizeof(CHAR));
              return(NULL);
  	}
      }
      if (*cur == '&') {
          cur++;
  	if (*cur == '#') {
  	    /* TODO !!!! 
  	    fprintf(stderr, "Character reference not yet implemented\n"); */
  	} else {
  	    /* TODO !!!! 
  	    fprintf(stderr, "Entity search not yet implemented\n"); */
  	}
      }
  
      /*
       * The few predefined entities.
       */
      if ((cur[0] == 'a') && (cur[1] == 'm') && (cur[2] == 'p') &&
          (cur[3] == ';')) {
          entity[0] = '%';
          entity[1] = 0;
  	cur += 3;
  	*input = cur;
          return(entity);
      } else if ((cur[0] == 'q') && (cur[1] == 'u') && (cur[2] == 'o') &&
          (cur[3] == 't') && (cur[4] == ';')) {
          entity[0] = '"';
          entity[1] = 0;
  	cur += 4;
  	*input = cur;
          return(entity);
      } else if ((cur[0] == 'a') && (cur[1] == 'p') && (cur[2] == 'o') &&
          (cur[3] == 's') && (cur[4] == ';')) {
          entity[0] = '\'';
          entity[1] = 0;
  	cur += 4;
  	*input = cur;
          return(entity);
      } else if ((cur[0] == 'l') && (cur[1] == 't') && (cur[2] == ';')) {
          entity[0] = '<';
          entity[1] = 0;
  	cur += 2;
  	*input = cur;
          return(entity);
      } else if ((cur[0] == 'g') && (cur[1] == 't') && (cur[2] == ';')) {
          entity[0] = '>';
          entity[1] = 0;
  	cur += 2;
  	*input = cur;
          return(entity);
      }
  
      return(NULL);
  }
  
  /*
   * xmlDecodeEntities : do a global entities lookup on a input string
   *        and returns a duplicate after the entities substitution.
   */
  CHAR *xmlDecodeEntities(xmlDocPtr doc, const CHAR *input, int len) {
      const CHAR *cur = input;
      CHAR *out = buffer;
      int i;
  
      if (buffer == NULL) {
          buffer_size = 1000;
          buffer = (CHAR *) malloc(buffer_size * sizeof(CHAR));
  	if (buffer == NULL) {
  	    perror("malloc failed");
              exit(1);
  	}
  	out = buffer;
      }
      for (i = 0;(*cur != 0) && (cur - input < len);cur++) {
          if (*cur == '&') {
              const CHAR *entity = xmlReadEntity(doc, &cur);
  	    if (entity != NULL)
  	        while (*entity != 0) { 
  		    *out++ = *entity++;
  		    i++;
  		    if (i + 10 > buffer_size) {
  			int index = out - buffer;
  
  			growBuffer();
  			out = &buffer[index];
  		    }
  		}
  	} else if (*cur == '%') {
  	    /* TODO !!!!!
  	    fprintf(stderr, " \n"); */
  	} else {
  	    *out++ = *cur;
  	    i++;
  	}
  
  	if (i + 10 > buffer_size) {
  	    int index = out - buffer;
  
  	    growBuffer();
  	    out = &buffer[index];
  	}
      }
      *out++ = 0;
      return(buffer);
  }
  
  /*
   * xmlEncodeEntities : do a global encoding of a string, replacing the
   *                     basic values with their entities form.
   */
  CHAR *xmlEncodeEntities(xmlDocPtr doc, const CHAR *input) {
      const CHAR *cur = input;
      CHAR *out = buffer;
  
      if (buffer == NULL) {
          buffer_size = 1000;
          buffer = (CHAR *) malloc(buffer_size * sizeof(CHAR));
  	if (buffer == NULL) {
  	    perror("malloc failed");
              exit(1);
  	}
  	out = buffer;
      }
      while (*cur != '\0') {
          if (out - buffer > buffer_size - 100) {
  	    int index = out - buffer;
  
  	    growBuffer();
  	    out = &buffer[index];
  	}
  
  	/*
  	 * By default one have to encode at least '<', '>', '"' and '&' !
  	 * One could try a better encoding using the entities defined and
  	 * used as a compression code !!!.
  	 */
  	if (*cur == '<') {
  	    *out++ = '&';
  	    *out++ = 'l';
  	    *out++ = 't';
  	    *out++ = ';';
  	} else if (*cur == '>') {
  	    *out++ = '&';
  	    *out++ = 'g';
  	    *out++ = 't';
  	    *out++ = ';';
  	} else if (*cur == '&') {
  	    *out++ = '&';
  	    *out++ = 'a';
  	    *out++ = 'm';
  	    *out++ = 'p';
  	    *out++ = ';';
  	} else if (*cur == '"') {
  	    *out++ = '&';
  	    *out++ = 'q';
  	    *out++ = 'u';
  	    *out++ = 'o';
  	    *out++ = 't';
  	    *out++ = ';';
  	} else if (*cur == '\'') {
  	    *out++ = '&';
  	    *out++ = 'a';
  	    *out++ = 'p';
  	    *out++ = 'o';
  	    *out++ = 's';
  	    *out++ = ';';
  	} else {
  	    /*
  	     * default case, just copy !
  	     */
  	    *out++ = *cur;
  	}
  	cur++;
      }
      *out++ = 0;
      return(buffer);
  }
  
  /*
   * xmlCreateEntitiesTable : create and initialize an enmpty hash table
   */
  xmlEntitiesTablePtr xmlCreateEntitiesTable(void) {
      xmlEntitiesTablePtr ret;
  
      ret = (xmlEntitiesTablePtr) 
           malloc(sizeof(xmlEntitiesTable));
      if (ret == NULL) {
          fprintf(stderr, "xmlCreateEntitiesTable : malloc(%d) failed\n",
  	        sizeof(xmlEntitiesTable));
          return(NULL);
      }
      ret->max_entities = XML_MIN_ENTITIES_TABLE;
      ret->nb_entities = 0;
      ret->table = (xmlEntityPtr ) 
           malloc(ret->max_entities * sizeof(xmlEntity));
      if (ret == NULL) {
          fprintf(stderr, "xmlCreateEntitiesTable : malloc(%d) failed\n",
  	        ret->max_entities * sizeof(xmlEntity));
  	free(ret);
          return(NULL);
      }
      return(ret);
  }
  
  /*
   * xmlFreeEntitiesTable : clean up and free an entities hash table.
   */
  void xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
      int i;
  
      if (table == NULL) return;
  
      for (i = 0;i < table->nb_entities;i++) {
          xmlFreeEntity(&table->table[i]);
      }
      free(table->table);
      free(table);
  }
  
  

Download