Begin implementation of DocumentType class

Remove dom_document_set_doctype() -- dom_node_insert_before() (and thus _append_child()) can be used to achieve the same effect.
DocumentType node is now a child of the Document node (as it should have been) rather than a hidden field.
Make dom_node_destroy() aware of DocumentType nodes potentially having no owner.
Make dom_node_finalise() aware of it, too.
Make dom_node_get_owner_document() return NULL for Document nodes, as per the spec.
Fix bug in dom_node_insert_before() -- previously it failed to catch attempts to insert a second root element.
Make dom_node_insert_before() handle DocumentType nodes appropriately.
Implement XML binding's dom_implementation_create_document_type() function.
Fix XML binding's dom_implementation_create_document() implementation to cope with changed API relating to doctype insertion.
Fix up XML parser wrapper to cater for new doctype insertion mechanism. Also sprinkle some NULL about for paranoia purposes.

svn path=/trunk/dom/; revision=3551

1 files changed, 79 insertions, 0 deletions

diff --git a/src/core/document_type.c b/src/core/document_type.c
index 2bd0f5b..30d8fe2 100644
--- a/src/core/document_type.c
+++ b/src/core/document_type.c
@@ -7,7 +7,10 @@
  */
 
 #include <dom/core/document_type.h>
+#include <dom/core/string.h>
+#include <dom/bootstrap/implpriv.h>
 
+#include "core/document_type.h"
 #include "core/node.h"
 #include "utils/utils.h"
 
@@ -18,9 +21,85 @@ struct dom_document_type {
 	struct dom_node base;		/**< Base node */
 
 	/** \todo other members */
+	struct dom_string *public_id;	/**< Doctype public ID */
+	struct dom_string *system_id;	/**< Doctype system ID */
+
+	dom_alloc alloc;		/**< Memory (de)allocation function */
+	void *pw;			/**< Pointer to private data */
 };
 
 /**
+ * Create a document type node
+ *
+ * \param qname      The qualified name of the document type
+ * \param public_id  The external subset public identifier
+ * \param system_id  The external subset system identifier
+ * \param alloc      Memory (de)allocation function
+ * \param pw         Pointer to client-specific private data
+ * \param doctype    Pointer to location to receive result
+ * \return DOM_NO_ERR on success, DOM_NO_MEM_ERR on memory exhaustion.
+ *
+ * The doctype will be referenced, so the client need not do so
+ * explicitly. The client must unref the doctype once it has
+ * finished with it.
+ */
+dom_exception dom_document_type_create(struct dom_string *qname,
+		struct dom_string *public_id, struct dom_string *system_id,
+		dom_alloc alloc, void *pw, struct dom_document_type **doctype)
+{
+	struct dom_document_type *result;
+	dom_exception err;
+
+	/* Create node */
+	result = alloc(NULL, sizeof(struct dom_document_type), pw);
+	if (result == NULL)
+		return DOM_NO_MEM_ERR;
+
+	/* Initialise base node */
+	err = dom_node_initialise(&result->base, NULL, DOM_DOCUMENT_TYPE_NODE,
+			qname, NULL);
+	if (err != DOM_NO_ERR) {
+		alloc(result, 0, pw);
+		return err;
+	}
+
+	/* Get public and system IDs */
+	dom_string_ref(public_id);
+	result->public_id = public_id;
+
+	dom_string_ref(system_id);
+	result->system_id = system_id;
+
+	/* Fill in allocation information */
+	result->alloc = alloc;
+	result->pw = pw;
+
+	*doctype = result;
+
+	return DOM_NO_ERR;
+}
+
+/**
+ * Destroy a DocumentType node
+ *
+ * \param doctype  The DocumentType node to destroy
+ *
+ * The contents of ::doctype will be destroyed and ::doctype will be freed.
+ */
+void dom_document_type_destroy(struct dom_document_type *doctype)
+{
+	/* Finish with public and system IDs */
+	dom_string_unref(doctype->system_id);
+	dom_string_unref(doctype->public_id);
+
+	/* Finalise base class */
+	dom_node_finalise(doctype->base.owner, &doctype->base);
+
+	/* Free doctype */
+	doctype->alloc(doctype, 0, doctype->pw);
+}
+
+/**
  * Retrieve a document type's name
  *
  * \param doc_type  Document type to retrieve name from