diff --git a/ChangeLog b/ChangeLog
index 0f620b1..96002ae 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+Sun Jan 31 22:06:48 CET 1999 Daniel Veillard <Daniel.Veillard@w3.org>
+
+	* valid.[ch], tree.c, parser.c : more work toward full parsing
+	  of XML DTDs.
+	* README: added informations about mailing-list and on-line
+	  documentation
+
 1999-01-27  Raja R Harinath  <harinath@cs.umn.edu>
 
 	* configure.in (XML_INCLUDEDIR): Use -I not -L for includes.
diff --git a/README b/README
index e69de29..39c315c 100644
--- a/README
+++ b/README
@@ -0,0 +1,14 @@
+
+                  XML parser for Gnome
+
+Documentation is available on-line at
+    http://rufus.w3.org/veillard/XML/xml.html
+
+A mailing-list has been set-up, to subscribe:
+    echo "subscribe xml" | mail majordomo@rufus.w3.org
+
+The list archive is at:
+    http://rufus.w3.org/veillard/XML/messages/
+
+
+Daniel.Veillard@w3.org
diff --git a/include/libxml/valid.h b/include/libxml/valid.h
index d6765ff..bef45dc 100644
--- a/include/libxml/valid.h
+++ b/include/libxml/valid.h
@@ -11,8 +11,25 @@
 #define __XML_VALID_H__
 #include "tree.h"
 
+/*
+ * ALl element declarations are stored in a table
+ * there is one table per DTD
+ */
+
+#define XML_MIN_ELEMENT_TABLE	32
+
+typedef struct xmlElementTable {
+    int nb_elements;		/* number of elements stored */
+    int max_elements;		/* maximum number of elements */
+    xmlElementPtr table;	/* the table of entities */
+} xmlElementTable, *xmlElementTablePtr;
+
 extern xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, char *name, int type, 
                                        xmlElementContentPtr content);
 extern xmlElementContentPtr xmlNewElementContent(CHAR *name, int type);
+extern xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
 extern void xmlFreeElementContent(xmlElementContentPtr cur);
+
+extern xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table);
+extern void xmlFreeElementTable(xmlElementTablePtr table);
 #endif /* __XML_VALID_H__ */
diff --git a/parser.c b/parser.c
index a466b8b..03cfa4e 100644
--- a/parser.c
+++ b/parser.c
@@ -2388,16 +2388,21 @@
         (NXT(6) == 'A')) {
 	SKIP(7);
 	SKIP_BLANKS;
+	if (CUR == ')') {
+	    NEXT;
+	    ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
+	    return(ret);
+	}
 	if ((CUR == '(') || (CUR == '|')) {
 	    ret = cur = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_PCDATA);
 	    if (ret == NULL) return(NULL);
-	} else {
+	} /********** else {
 	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
 		ctxt->sax->error(ctxt, 
 		    "xmlParseElementMixedContentDecl : '|' or ')' expected\n");
 	    ctxt->wellFormed = 0;
 	    return(NULL);
-	}
+	} **********/
 	while (CUR == '|') {
 	    if (elem == NULL) {
 	        ret = xmlNewElementContent(NULL, XML_ELEMENT_CONTENT_OR);
@@ -2422,7 +2427,7 @@
 	    }
 	    SKIP_BLANKS;
 	}
-	if (CUR == ')') {
+	if ((CUR == ')') && (NXT(1) == '*')) {
 	    if (elem != NULL)
 		cur->c2 = xmlNewElementContent(elem,
 		                               XML_ELEMENT_CONTENT_ELEMENT);
@@ -2430,7 +2435,7 @@
 	} else {
 	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
 		ctxt->sax->error(ctxt, 
-		    "xmlParseElementMixedContentDecl : '|' or ')' expected\n");
+		    "xmlParseElementMixedContentDecl : '|' or ')*' expected\n");
 	    ctxt->wellFormed = 0;
 	    xmlFreeElementContent(ret);
 	    return(NULL);
@@ -2671,6 +2676,7 @@
 	return(-1);
     }
      ****************************/
+    *result = tree;
     return(res);
 }
 
diff --git a/tree.c b/tree.c
index 4d643d8..5892a4e 100644
--- a/tree.c
+++ b/tree.c
@@ -20,6 +20,7 @@
 
 #include "tree.h"
 #include "entities.h"
+#include "valid.h"
 
 static CHAR xmlStringText[] = { 't', 'e', 'x', 't', 0 };
 int oldXMLWDcompatibility = 0;
@@ -345,7 +346,7 @@
     if (cur->SystemID != NULL) free((char *) cur->SystemID);
     if (cur->ExternalID != NULL) free((char *) cur->ExternalID);
     if (cur->elements != NULL)
-        fprintf(stderr, "xmlFreeDtd: cur->elements != NULL !!! \n");
+        xmlFreeElementTable((xmlElementTablePtr) cur->elements);
     if (cur->entities != NULL)
         xmlFreeEntitiesTable((xmlEntitiesTablePtr) cur->entities);
     memset(cur, -1, sizeof(xmlDtd));
@@ -2268,13 +2269,15 @@
 	xmlBufferWriteCHAR(cur->SystemID);
 	xmlBufferWriteChar("\"");
     }
-    if (cur->entities == NULL) {
+    if ((cur->entities == NULL) && (cur->elements == NULL)) {
 	xmlBufferWriteChar(">\n");
 	return;
     }
     xmlBufferWriteChar(" [\n");
     if (cur->entities != NULL)
 	xmlDumpEntitiesTable((xmlEntitiesTablePtr) cur->entities);
+    if (cur->elements != NULL)
+	xmlDumpElementTable((xmlElementTablePtr) cur->elements);
     xmlBufferWriteChar("]");
 
     /* TODO !!! a lot more things to dump ... */
diff --git a/valid.c b/valid.c
index 215e463..6f2f440 100644
--- a/valid.c
+++ b/valid.c
@@ -56,11 +56,28 @@
     }
     ret->type = type;
     ret->ocur = XML_ELEMENT_CONTENT_ONCE;
-    ret->name = xmlStrdup(name);
+    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);
+}
+
+/**
  * xmlNewElementContent:
  * @name:  the subelement name or NULL
  * @type:  the type of element content decl
@@ -78,6 +95,37 @@
  *								*
  ****************************************************************/
 
+/**
+ * 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:
@@ -90,7 +138,9 @@
 xmlElementPtr
 xmlAddElementDecl(xmlDtdPtr dtd, char *name, int type, 
                   xmlElementContentPtr content) {
-    xmlElementPtr ret;
+    xmlElementPtr ret, cur;
+    xmlElementTablePtr table;
+    int i;
 
     if (dtd == NULL) {
         fprintf(stderr, "xmlAddElementDecl: dtd == NULL\n");
@@ -135,28 +185,175 @@
     }
 
     /*
+     * 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
      */
-    /* TODO */
+    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);
+	}
+    }
 
     /*
-     * Create and fill the structure.
+     * Grow the table, if needed.
      */
-    ret = (xmlElementPtr) malloc(sizeof(xmlElement));
-    if (ret == NULL) {
-        fprintf(stderr, "xmlAddElementDecl: out of memory\n");
-	return(NULL);
+    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;
-
-    /*
-     * Insert the structure in the DTD Element table
-     */
-    /* TODO */
+    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>");
+	        break;
+	    case XML_ELEMENT_TYPE_ANY:
+	        xmlBufferWriteChar("<!ELEMENT ");
+		xmlBufferWriteCHAR(cur->name);
+		xmlBufferWriteChar(" ANY>");
+	        break;
+	    case XML_ELEMENT_TYPE_MIXED:
+		/* TODO !!! */
+	        break;
+	    case XML_ELEMENT_TYPE_ELEMENT:
+		/* TODO !!! */
+	        break;
+	    default:
+	        fprintf(stderr,
+		    "xmlDumpElementTable: internal: unknown type %d\n",
+		        cur->type);
+	}
+    }
+}
diff --git a/valid.h b/valid.h
index d6765ff..bef45dc 100644
--- a/valid.h
+++ b/valid.h
@@ -11,8 +11,25 @@
 #define __XML_VALID_H__
 #include "tree.h"
 
+/*
+ * ALl element declarations are stored in a table
+ * there is one table per DTD
+ */
+
+#define XML_MIN_ELEMENT_TABLE	32
+
+typedef struct xmlElementTable {
+    int nb_elements;		/* number of elements stored */
+    int max_elements;		/* maximum number of elements */
+    xmlElementPtr table;	/* the table of entities */
+} xmlElementTable, *xmlElementTablePtr;
+
 extern xmlElementPtr xmlAddElementDecl(xmlDtdPtr dtd, char *name, int type, 
                                        xmlElementContentPtr content);
 extern xmlElementContentPtr xmlNewElementContent(CHAR *name, int type);
+extern xmlElementContentPtr xmlCopyElementContent(xmlElementContentPtr content);
 extern void xmlFreeElementContent(xmlElementContentPtr cur);
+
+extern xmlElementTablePtr xmlCopyElementTable(xmlElementTablePtr table);
+extern void xmlFreeElementTable(xmlElementTablePtr table);
 #endif /* __XML_VALID_H__ */