kc3-lang/libxml2/valid.c

• Show log

  Commit

• Hash : 1899e853
  Author :
  Date : 1999-02-01T12:18:54
  

  Header cleanup and work on parsing/output of element declarations, Daniel.
  

Download

• valid.c

• /*
   * valid.c : part of the code use to do the DTD handling and the validity
   *           checking
   *
   * See Copyright for the status of this software.
   *
   * Daniel.Veillard@w3.org
   */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include "valid.h"
  #include "parser.h"
  
  /****************************************************************
   *								*
   *	Util functions for data allocation/deallocation		*
   *								*
   ****************************************************************/
  
  /**
   * xmlNewElementContent:
   * @name:  the subelement name or NULL
   * @type:  the type of element content decl
   *
   * Allocate an element content structure.
   *
   * return values: NULL if not, othervise the new element content structure
   */
  xmlElementContentPtr
  xmlNewElementContent(CHAR *name, int type) {
      xmlElementContentPtr ret;
  
      switch(type) {
  	case XML_ELEMENT_CONTENT_ELEMENT:
  	    if (name == NULL) {
  	        fprintf(stderr, "xmlNewElementContent : name == NULL !\n");
  	    }
  	    break;
          case XML_ELEMENT_CONTENT_PCDATA:
  	case XML_ELEMENT_CONTENT_SEQ:
  	case XML_ELEMENT_CONTENT_OR:
  	    if (name != NULL) {
  	        fprintf(stderr, "xmlNewElementContent : name != NULL !\n");
  	    }
  	    break;
  	default:
  	    fprintf(stderr, "xmlNewElementContent: unknown type %d\n", type);
  	    exit(1);
      }
      ret = (xmlElementContentPtr) malloc(sizeof(xmlElementContent));
      if (ret == NULL) {
  	fprintf(stderr, "xmlNewElementContent : out of memory!\n");
  	return(NULL);
      }
      ret->type = type;
      ret->ocur = XML_ELEMENT_CONTENT_ONCE;
      if (name != NULL)
          ret->name = xmlStrdup(name);
      else
          ret->name = NULL;
      return(ret);
  }
  
  /**
   * xmlCopyElementContent:
   * @content:  An element content pointer.
   *
   * Build a copy of an element content description.
   * 
   * return values: the new xmlElementContentPtr or NULL in case of error.
   */
  xmlElementContentPtr
  xmlCopyElementContent(xmlElementContentPtr content) {
  /* TODO !!! */
      return(NULL);
  }
  
  /**
   * xmlFreeElementContent:
   * @cur:  the element content tree to free
   *
   * Free an element content structure. This is a recursive call !
   */
  void
  xmlFreeElementContent(xmlElementContentPtr cur) {
  /* TODO !!! */
  }
  
  /**
   * xmlDumpElementContent:
   * @content:  An element table
   * @glob: 1 if one must print the englobing parenthesis, 0 otherwise
   *
   * This will dump the content of the element table as an XML DTD definition
   *
   * NOTE: TODO an extra parameter allowing a reentant implementation will
   *       be added.
   */
  void
  xmlDumpElementContent(xmlElementContentPtr content, int glob) {
      if (content == NULL) return;
  
      if (glob) xmlBufferWriteChar("(");
      switch (content->type) {
          case XML_ELEMENT_CONTENT_PCDATA:
              xmlBufferWriteChar("#PCDATA");
  	    break;
  	case XML_ELEMENT_CONTENT_ELEMENT:
  	    xmlBufferWriteCHAR(content->name);
  	    break;
  	case XML_ELEMENT_CONTENT_SEQ:
  	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
  	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
  		xmlDumpElementContent(content->c1, 1);
  	    else
  		xmlDumpElementContent(content->c1, 0);
              xmlBufferWriteChar(" , ");
  	    if (content->c2->type == XML_ELEMENT_CONTENT_OR)
  		xmlDumpElementContent(content->c2, 1);
  	    else
  		xmlDumpElementContent(content->c2, 0);
  	    break;
  	case XML_ELEMENT_CONTENT_OR:
  	    if ((content->c1->type == XML_ELEMENT_CONTENT_OR) ||
  	        (content->c1->type == XML_ELEMENT_CONTENT_SEQ))
  		xmlDumpElementContent(content->c1, 1);
  	    else
  		xmlDumpElementContent(content->c1, 0);
              xmlBufferWriteChar(" | ");
  	    if (content->c2->type == XML_ELEMENT_CONTENT_SEQ)
  		xmlDumpElementContent(content->c2, 1);
  	    else
  		xmlDumpElementContent(content->c2, 0);
  	    break;
  	default:
  	    fprintf(stderr, "xmlDumpElementContent: unknown type %d\n",
  	            content->type);
      }
      if (glob)
          xmlBufferWriteChar(")");
      switch (content->ocur) {
          case XML_ELEMENT_CONTENT_ONCE:
  	    break;
          case XML_ELEMENT_CONTENT_OPT:
  	    xmlBufferWriteChar("?");
  	    break;
          case XML_ELEMENT_CONTENT_MULT:
  	    xmlBufferWriteChar("*");
  	    break;
          case XML_ELEMENT_CONTENT_PLUS:
  	    xmlBufferWriteChar("+");
  	    break;
      }
  }
  
  /****************************************************************
   *								*
   *	Registration of DTD declarations			*
   *								*
   ****************************************************************/
  
  /**
   * xmlCreateElementTable:
   *
   * create and initialize an empty element hash table.
   *
   * return values: the xmlElementTablePtr just created or NULL in case of error.
   */
  xmlElementTablePtr
  xmlCreateElementTable(void) {
      xmlElementTablePtr ret;
  
      ret = (xmlElementTablePtr) 
           malloc(sizeof(xmlElementTable));
      if (ret == NULL) {
          fprintf(stderr, "xmlCreateElementTable : malloc(%d) failed\n",
  	        sizeof(xmlElementTable));
          return(NULL);
      }
      ret->max_elements = XML_MIN_ENTITIES_TABLE;
      ret->nb_elements = 0;
      ret->table = (xmlElementPtr ) 
           malloc(ret->max_elements * sizeof(xmlElement));
      if (ret == NULL) {
          fprintf(stderr, "xmlCreateElementTable : malloc(%d) failed\n",
  	        ret->max_elements * sizeof(xmlElement));
  	free(ret);
          return(NULL);
      }
      return(ret);
  }
  
  
  /**
   * xmlAddElementDecl:
   * @name:  the entity name
   *
   * Register a new element declaration
   *
   * return values: NULL if not, othervise the entity
   */
  xmlElementPtr
  xmlAddElementDecl(xmlDtdPtr dtd, char *name, int type, 
                    xmlElementContentPtr content) {
      xmlElementPtr ret, cur;
      xmlElementTablePtr table;
      int i;
  
      if (dtd == NULL) {
          fprintf(stderr, "xmlAddElementDecl: dtd == NULL\n");
  	return(NULL);
      }
      if (name == NULL) {
          fprintf(stderr, "xmlAddElementDecl: name == NULL\n");
  	return(NULL);
      }
      switch (type) {
          case XML_ELEMENT_TYPE_EMPTY:
  	    if (content != NULL) {
  	        fprintf(stderr,
  		        "xmlAddElementDecl: content != NULL for EMPTY\n");
  		return(NULL);
  	    }
  	    break;
  	case XML_ELEMENT_TYPE_ANY:
  	    if (content != NULL) {
  	        fprintf(stderr,
  		        "xmlAddElementDecl: content != NULL for ANY\n");
  		return(NULL);
  	    }
  	    break;
  	case XML_ELEMENT_TYPE_MIXED:
  	    if (content == NULL) {
  	        fprintf(stderr,
  		        "xmlAddElementDecl: content == NULL for MIXED\n");
  		return(NULL);
  	    }
  	    break;
  	case XML_ELEMENT_TYPE_ELEMENT:
  	    if (content == NULL) {
  	        fprintf(stderr,
  		        "xmlAddElementDecl: content == NULL for ELEMENT\n");
  		return(NULL);
  	    }
  	    break;
  	default:
  	    fprintf(stderr, "xmlAddElementDecl: unknown type %d\n", type);
  	    return(NULL);
      }
  
      /*
       * Create the Element table if needed.
       */
      table = dtd->elements;
      if (table == NULL) 
          table = dtd->elements = xmlCreateElementTable();
      if (table == NULL) {
  	fprintf(stderr, "xmlAddElementDecl: Table creation failed!\n");
          return(NULL);
      }
  
      /*
       * Validity Check:
       * Search the DTD for previous declarations of the ELEMENT
       */
      for (i = 0;i < table->nb_elements;i++) {
          cur = &table->table[i];
  	if (!xmlStrcmp(cur->name, name)) {
  	    /*
  	     * The element is already defined in this Dtd.
  	     */
  	    fprintf(stderr,
  		    "xmlAddElementDecl: %s already defined\n", name);
  	    return(NULL);
  	}
      }
  
      /*
       * Grow the table, if needed.
       */
      if (table->nb_elements >= table->max_elements) {
          /*
  	 * need more elements.
  	 */
  	table->max_elements *= 2;
  	table->table = (xmlElementPtr) 
  	    realloc(table->table, table->max_elements * sizeof(xmlElement));
  	if (table->table) {
  	    fprintf(stderr, "xmlAddElementDecl: out of memory\n");
  	    return(NULL);
  	}
      }
      ret = &table->table[table->nb_elements];
  
      /*
       * fill the structure.
       */
      ret->type = type;
      ret->name = xmlStrdup(name);
      ret->content = content;
      table->nb_elements++;
  
      return(ret);
  }
  
  /**
   * xmlFreeElement:
   * @elem:  An element
   *
   * Deallocate the memory used by an element definition
   */
  void
  xmlFreeElement(xmlElementPtr elem) {
      if (elem == NULL) return;
      xmlFreeElementContent(elem->content);
      if (elem->name != NULL)
  	free((CHAR *) elem->name);
      memset(elem, -1, sizeof(xmlElement));
      free(elem);
  }
  
  /**
   * xmlFreeElementTable:
   * @table:  An element table
   *
   * Deallocate the memory used by an entities hash table.
   */
  void
  xmlFreeElementTable(xmlElementTablePtr table) {
      int i;
  
      if (table == NULL) return;
  
      for (i = 0;i < table->nb_elements;i++) {
          xmlFreeElement(&table->table[i]);
      }
      free(table->table);
      free(table);
  }
  
  /**
   * xmlCopyElementTable:
   * @table:  An element table
   *
   * Build a copy of an element table.
   * 
   * return values: the new xmlElementTablePtr or NULL in case of error.
   */
  xmlElementTablePtr
  xmlCopyElementTable(xmlElementTablePtr table) {
      xmlElementTablePtr ret;
      xmlElementPtr cur, ent;
      int i;
  
      ret = (xmlElementTablePtr) malloc(sizeof(xmlElementTable));
      if (ret == NULL) {
          fprintf(stderr, "xmlCopyElementTable: out of memory !\n");
  	return(NULL);
      }
      ret->table = (xmlElementPtr) malloc(table->max_elements *
                                           sizeof(xmlElement));
      if (ret->table == NULL) {
          fprintf(stderr, "xmlCopyElementTable: out of memory !\n");
  	free(ret);
  	return(NULL);
      }
      ret->max_elements = table->max_elements;
      ret->nb_elements = table->nb_elements;
      for (i = 0;i < ret->nb_elements;i++) {
  	cur = &ret->table[i];
  	ent = &table->table[i];
  	cur->type = ent->type;
  	if (ent->name != NULL)
  	    cur->name = xmlStrdup(ent->name);
  	else
  	    cur->name = NULL;
  	cur->content = xmlCopyElementContent(ent->content);
      }
      return(ret);
  }
  
  /**
   * xmlDumpElementTable:
   * @table:  An element table
   *
   * This will dump the content of the element table as an XML DTD definition
   *
   * NOTE: TODO an extra parameter allowing a reentant implementation will
   *       be added.
   */
  void
  xmlDumpElementTable(xmlElementTablePtr table) {
      int i;
      xmlElementPtr cur;
  
      if (table == NULL) return;
  
      for (i = 0;i < table->nb_elements;i++) {
          cur = &table->table[i];
          switch (cur->type) {
  	    case XML_ELEMENT_TYPE_EMPTY:
  	        xmlBufferWriteChar("<!ELEMENT ");
  		xmlBufferWriteCHAR(cur->name);
  		xmlBufferWriteChar(" EMPTY>\n");
  	        break;
  	    case XML_ELEMENT_TYPE_ANY:
  	        xmlBufferWriteChar("<!ELEMENT ");
  		xmlBufferWriteCHAR(cur->name);
  		xmlBufferWriteChar(" ANY>\n");
  	        break;
  	    case XML_ELEMENT_TYPE_MIXED:
  	        xmlBufferWriteChar("<!ELEMENT ");
  		xmlBufferWriteCHAR(cur->name);
  		xmlBufferWriteChar(" ");
  		xmlDumpElementContent(cur->content, 1);
  		xmlBufferWriteChar(">\n");
  	        break;
  	    case XML_ELEMENT_TYPE_ELEMENT:
  	        xmlBufferWriteChar("<!ELEMENT ");
  		xmlBufferWriteCHAR(cur->name);
  		xmlBufferWriteChar(" ");
  		xmlDumpElementContent(cur->content, 1);
  		xmlBufferWriteChar(">\n");
  	        break;
  	    default:
  	        fprintf(stderr,
  		    "xmlDumpElementTable: internal: unknown type %d\n",
  		        cur->type);
  	}
      }
  }
  

Download