mirror of
https://gitlab.gnome.org/GNOME/libxml2.git
synced 2024-10-27 04:55:04 +03:00
434 lines
11 KiB
C
434 lines
11 KiB
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);
|
|
}
|
|
}
|
|
}
|