r5404 jmb - in /trunk/netsurf: Makefile.sources render/directory.c render/html.c render/html.h render/hubbub_binding.c render/libxml_binding.c render/parser_binding.h

netsurf at semichrome.net netsurf at semichrome.net
Tue Sep 23 03:19:50 BST 2008


Author: jmb
Date: Mon Sep 22 21:19:50 2008
New Revision: 5404

URL: http://source.netsurf-browser.org?rev=5404&view=rev
Log:
Rework html parser bindings to have a common API and reside in separate files for ease of reading.
Add error handling to hubbub binding.

Added:
    trunk/netsurf/render/hubbub_binding.c
    trunk/netsurf/render/libxml_binding.c
    trunk/netsurf/render/parser_binding.h
Modified:
    trunk/netsurf/Makefile.sources
    trunk/netsurf/render/directory.c
    trunk/netsurf/render/html.c
    trunk/netsurf/render/html.h

Modified: trunk/netsurf/Makefile.sources
URL: http://source.netsurf-browser.org/trunk/netsurf/Makefile.sources?rev=5404&r1=5403&r2=5404&view=diff
==============================================================================
--- trunk/netsurf/Makefile.sources (original)
+++ trunk/netsurf/Makefile.sources Mon Sep 22 21:19:50 2008
@@ -9,8 +9,8 @@
 	fetchers/fetch_curl.c fetchers/fetch_data.c
 S_CSS := css.c css_enum.c parser.c ruleset.c scanner.c
 S_RENDER := box.c box_construct.c box_normalise.c directory.c		\
-	form.c html.c html_redraw.c imagemap.c layout.c list.c		\
-	table.c textplain.c
+	form.c html.c html_redraw.c hubbub_binding.c imagemap.c 	\
+	layout.c libxml_binding.c list.c table.c textplain.c
 S_UTILS := base64.c filename.c hashtable.c locale.c messages.c talloc.c	\
 	url.c utf8.c utils.c useragent.c
 S_DESKTOP := knockout.c options.c tree.c version.c

Modified: trunk/netsurf/render/directory.c
URL: http://source.netsurf-browser.org/trunk/netsurf/render/directory.c?rev=5404&r1=5403&r2=5404&view=diff
==============================================================================
--- trunk/netsurf/render/directory.c (original)
+++ trunk/netsurf/render/directory.c Mon Sep 22 21:19:50 2008
@@ -48,12 +48,10 @@
 		/* html_create() must have broadcast MSG_ERROR already, so we
 		* don't need to. */
 		return false;
-#ifndef WITH_HUBBUB
-	htmlParseChunk(c->data.html.parser, header, sizeof(header) - 1, 0);
-#else
-	hubbub_parser_parse_chunk(c->data.html.parser, 
-				(uint8_t *) header, sizeof(header) - 1);
-#endif
+
+	binding_parse_chunk(c->data.html.parser_binding,
+			(uint8_t *) header, sizeof(header) - 1);
+
 	return true;
 }
 
@@ -100,12 +98,9 @@
 			"<body>\n<h1>\nIndex of %s</h1>\n<hr><pre>",
 			nice_path, nice_path);
 	free(nice_path);
-#ifndef WITH_HUBBUB
-	htmlParseChunk(c->data.html.parser, buffer, strlen(buffer), 0);
-#else
-	hubbub_parser_parse_chunk(c->data.html.parser, 
+
+	binding_parse_chunk(c->data.html.parser_binding, 
 			(uint8_t *) buffer, strlen(buffer));
-#endif
 
 	res = url_parent(c->url, &up);
 	if (res == URL_FUNC_OK) {
@@ -113,14 +108,9 @@
 		if ((res == URL_FUNC_OK) && !compare) {
 			snprintf(buffer, sizeof(buffer),
 				"<a href=\"..\">[..]</a>\n");
-#ifndef WITH_HUBBUB
-			htmlParseChunk(c->data.html.parser, buffer,
-					strlen(buffer), 0);
-#else
-			hubbub_parser_parse_chunk(c->data.html.parser, 
-					(uint8_t *) buffer, 
-					strlen(buffer));
-#endif
+
+			binding_parse_chunk(c->data.html.parser_binding,
+					(uint8_t *) buffer, strlen(buffer));
 		}
 		free(up);
 	}
@@ -137,21 +127,15 @@
 
 		snprintf(buffer, sizeof(buffer), "<a href=\"%s/%s\">%s</a>\n",
 				c->url, entry->d_name, entry->d_name);
-#ifndef WITH_HUBBUB
-		htmlParseChunk(c->data.html.parser, buffer, strlen(buffer), 0);
-#else
-		hubbub_parser_parse_chunk(c->data.html.parser,
+
+		binding_parse_chunk(c->data.html.parser_binding,
 				(uint8_t *) buffer, strlen(buffer));
-#endif
 	}
 	closedir(parent);
 
-#ifndef WITH_HUBBUB
-	htmlParseChunk(c->data.html.parser, footer, sizeof(footer) - 1, 0);
-#else
-	hubbub_parser_parse_chunk(c->data.html.parser, 
+	binding_parse_chunk(c->data.html.parser_binding,
 			(uint8_t *) footer, sizeof(footer) - 1);
-#endif
+
 	c->type = CONTENT_HTML;
 	return html_convert(c, width, height);
 }

Modified: trunk/netsurf/render/html.c
URL: http://source.netsurf-browser.org/trunk/netsurf/render/html.c?rev=5404&r1=5403&r2=5404&view=diff
==============================================================================
--- trunk/netsurf/render/html.c (original)
+++ trunk/netsurf/render/html.c Mon Sep 22 21:19:50 2008
@@ -28,14 +28,6 @@
 #include <string.h>
 #include <strings.h>
 #include <stdlib.h>
-#ifdef WITH_HUBBUB
-#include <hubbub/hubbub.h>
-#include <hubbub/parser.h>
-#include <hubbub/tree.h>
-#endif
-#include <libxml/tree.h>
-#include <libxml/parser.h>
-#include <libxml/parserInternals.h>
 #include "utils/config.h"
 #include "content/content.h"
 #include "content/fetch.h"
@@ -57,10 +49,6 @@
 #define CHUNK 4096
 
 
-#ifndef WITH_HUBBUB
-static bool html_set_parser_encoding(struct content *c, const char *encoding);
-static const char *html_detect_encoding(const char **data, unsigned int *size);
-#endif
 static void html_convert_css_callback(content_msg msg, struct content *css,
 		intptr_t p1, intptr_t p2, union content_msg_data data);
 static bool html_meta_refresh(struct content *c, xmlNode *head);
@@ -98,380 +86,6 @@
 	"</html>";
 
 
-#ifdef WITH_HUBBUB
-
-const char const *ns_prefixes[NUM_NAMESPACES] =
-		{ NULL, NULL, "math", "svg", "xlink", "xml", "xmlns" };
-
-const char const *ns_urls[NUM_NAMESPACES] = {
-	NULL,
-	"http://www.w3.org/1999/xhtml",
-	"http://www.w3.org/1998/Math/MathML",
-	"http://www.w3.org/2000/svg",
-	"http://www.w3.org/1999/xlink",
-	"http://www.w3.org/XML/1998/namespace",
-	"http://www.w3.org/2000/xmlns/"
-};
-
-
-static int create_comment(void *ctx, const hubbub_string *data, void **result);
-static int create_doctype(void *ctx, const hubbub_doctype *doctype,
-		void **result);
-static int create_element(void *ctx, const hubbub_tag *tag, void **result);
-static int create_text(void *ctx, const hubbub_string *data, void **result);
-static int ref_node(void *ctx, void *node);
-static int unref_node(void *ctx, void *node);
-static int append_child(void *ctx, void *parent, void *child, void **result);
-static int insert_before(void *ctx, void *parent, void *child, void *ref_child,
-		void **result);
-static int remove_child(void *ctx, void *parent, void *child, void **result);
-static int clone_node(void *ctx, void *node, bool deep, void **result);
-static int reparent_children(void *ctx, void *node, void *new_parent);
-static int get_parent(void *ctx, void *node, bool element_only, void **result);
-static int has_children(void *ctx, void *node, bool *result);
-static int form_associate(void *ctx, void *form, void *node);
-static int add_attributes(void *ctx, void *node,
-		const hubbub_attribute *attributes, uint32_t n_attributes);
-static int set_quirks_mode(void *ctx, hubbub_quirks_mode mode);
-static int change_encoding(void *ctx, const char *mibenum);
-
-static hubbub_tree_handler tree_handler = {
-	create_comment,
-	create_doctype,
-	create_element,
-	create_text,
-	ref_node,
-	unref_node,
-	append_child,
-	insert_before,
-	remove_child,
-	clone_node,
-	reparent_children,
-	get_parent,
-	has_children,
-	form_associate,
-	add_attributes,
-	set_quirks_mode,
-	change_encoding,
-	NULL
-};
-
-
-
-/*** Tree construction functions ***/
-
-int create_comment(void *ctx, const hubbub_string *data, void **result)
-{
-	xmlNode *node = xmlNewComment(NULL);
-
-	node->content = xmlStrndup(data->ptr, data->len);
-	node->_private = (void *)1;
-	*result = node;
-
-	return 0;
-}
-
-int create_doctype(void *ctx, const hubbub_doctype *doctype, void **result)
-{
-	/* Make a node that doesn't really exist, then don't append it
-	 * later. */
-	xmlNode *node = xmlNewComment(NULL);
-
-	node->_private = (void *)1;
-	*result = node;
-
-	return 0;
-}
-
-int create_element(void *ctx, const hubbub_tag *tag, void **result)
-{
-	struct content *c = ctx;
-	struct content_html_data *html = &c->data.html;
-
-	char *name = strndup((const char *) tag->name.ptr,
-			tag->name.len);
-
-	xmlNode *node = xmlNewNode(NULL, BAD_CAST name);
-	node->_private = (void *)1;
-	*result = node;
-
-	if (html->has_ns == false) {
-		for (size_t i = 1; i < NUM_NAMESPACES; i++) {
-			html->ns[i] = xmlNewNs(node,
-					BAD_CAST ns_urls[i],
-					BAD_CAST ns_prefixes[i]);
-		}
-		html->has_ns = true;
-	}
-
-	xmlSetNs(node, html->ns[tag->ns]);
-
-	free(name);
-
-	for (size_t i = 0; i < tag->n_attributes; i++) {
-		hubbub_attribute *attr = &tag->attributes[i];
-
-		char *name = strndup((const char *) attr->name.ptr,
-				attr->name.len);
-		char *value = strndup((const char *) attr->value.ptr,
-				attr->value.len);
-
-		if (attr->ns == HUBBUB_NS_NULL) {
-			xmlNewProp(node, BAD_CAST name, BAD_CAST value);
-		} else {
-			xmlNewNsProp(node, html->ns[attr->ns], BAD_CAST name,
-					BAD_CAST value);
-		}
-
-		free(name);
-		free(value);
-	}
-
-	return 0;
-}
-
-int create_text(void *ctx, const hubbub_string *data, void **result)
-{
-	xmlNode *node = xmlNewTextLen(BAD_CAST data->ptr, data->len);
-	node->_private = (void *)1;
-	*result = node;
-
-	return 0;
-}
-
-int ref_node(void *ctx, void *node)
-{
-	xmlNode *n = node;
-	n->_private = (void *)((uintptr_t)n->_private + 1);
-
-	return 0;
-}
-
-int unref_node(void *ctx, void *node)
-{
-	xmlNode *n = node;
-	n->_private = (void *)((uintptr_t)n->_private - 1);
-
-	if (n->_private == (void *)0 && n->parent == NULL) {
-		xmlFreeNode(n);
-	}
-
-	return 0;
-}
-
-int append_child(void *ctx, void *parent, void *child, void **result)
-{
-	xmlNode *nparent = parent;
-	xmlNode *nchild = child;
-
-	if (nchild->type == XML_TEXT_NODE &&
-			nparent->last != NULL &&
-			nparent->last->type == XML_TEXT_NODE) {
-		xmlNode *clone;
-		clone_node(ctx, nchild, false, (void **) &clone);
-		*result = xmlAddChild(parent, clone);
-		/* node referenced by clone_node */
-	} else {
-		*result = xmlAddChild(parent, child);
-		ref_node(ctx, *result);
-	}
-
-	return 0;
-}
-
-/* insert 'child' before 'ref_child', under 'parent' */
-int insert_before(void *ctx, void *parent, void *child, void *ref_child,
-		void **result)
-{
-	*result = xmlAddPrevSibling(ref_child, child);
-	ref_node(ctx, *result);
-
-	return 0;
-}
-
-int remove_child(void *ctx, void *parent, void *child, void **result)
-{
-	xmlUnlinkNode(child);
-	*result = child;
-
-	ref_node(ctx, *result);
-
-	return 0;
-}
-
-int clone_node(void *ctx, void *node, bool deep, void **result)
-{
-	xmlNode *n = xmlCopyNode(node, deep ? 1 : 2);
-	n->_private = (void *)1;
-	*result = n;
-
-	return 0;
-}
-
-/* Take all of the child nodes of "node" and append them to "new_parent" */
-int reparent_children(void *ctx, void *node, void *new_parent)
-{
-	xmlNode *n = (xmlNode *) node;
-	xmlNode *p = (xmlNode *) new_parent;
-
-	for (xmlNode *child = n->children; child != NULL; ) {
-		xmlNode *next = child->next;
-
-		xmlUnlinkNode(child);
-
-		if (xmlAddChild(p, child) == NULL)
-			return 1;
-
-		child = next;
-	}
-
-	return 0;
-}
-
-int get_parent(void *ctx, void *node, bool element_only, void **result)
-{
-	*result = ((xmlNode *)node)->parent;
-
-	if (*result != NULL && element_only &&
-			((xmlNode *) *result)->type != XML_ELEMENT_NODE)
-		*result = NULL;
-
-	if (*result != NULL)
-		ref_node(ctx, *result);
-
-	return 0;
-}
-
-int has_children(void *ctx, void *node, bool *result)
-{
-	*result = ((xmlNode *)node)->children ? true : false;
-
-	return 0;
-}
-
-int form_associate(void *ctx, void *form, void *node)
-{
-	return 0;
-}
-
-int add_attributes(void *ctx, void *node,
-		const hubbub_attribute *attributes, uint32_t n_attributes)
-{
-	struct content *c = ctx;
-	struct content_html_data *html = &c->data.html;
-
-	for (size_t i = 0; i < n_attributes; i++) {
-		const hubbub_attribute *attr = &attributes[i];
-
-		char *name = strndup((const char *) attr->name.ptr,
-				attr->name.len);
-		char *value = strndup((const char *) attr->value.ptr,
-				attr->value.len);
-
-		if (attr->ns == HUBBUB_NS_NULL) {
-			xmlNewProp(node, BAD_CAST name, BAD_CAST value);
-		} else {
-			xmlNewNsProp(node, html->ns[attr->ns], BAD_CAST name,
-					BAD_CAST value);
-		}
-
-		free(name);
-		free(value);
-	}
-
-	return 0;
-}
-
-int set_quirks_mode(void *ctx, hubbub_quirks_mode mode)
-{
-	return 0;
-}
-
-int change_encoding(void *ctx, const char *name)
-{
-	struct content *c = ctx;
-	struct content_html_data *html = &c->data.html;
-
-	/* If we have an encoding here, it means we are *certain* */
-	if (html->encoding) {
-		return 0;
-	}
-
-	/* Find the confidence otherwise (can only be from a BOM) */
-	uint32_t source;
-	const char *charset = hubbub_parser_read_charset(html->parser, &source);
-
-	if (source == HUBBUB_CHARSET_CONFIDENT) {
-		html->encoding_source = ENCODING_SOURCE_DETECTED;
-		html->encoding = (char *) charset;
-		return 0;
-	}
-
-	/* So here we have something of confidence tentative... */
-	/* http://www.whatwg.org/specs/web-apps/current-work/#change */
-
-	/* 2. "If the new encoding is identical or equivalent to the encoding
-	 * that is already being used to interpret the input stream, then set
-	 * the confidence to confident and abort these steps." */
-
-	/* Whatever happens, the encoding should be set here; either for
-	 * reprocessing with a different charset, or for confirming that the
-	 * charset is in fact correct */
-	html->encoding = (char *) name;
-	html->encoding_source = ENCODING_SOURCE_META;
-
-	/* Equal encodings will have the same string pointers */
-	return (charset == name) ? 0 : 1;
-}
-
-
-/**
- * Talloc'd-up allocation hook for Hubbub.
- */
-static void *html_hubbub_realloc(void *ptr, size_t len, void *pw)
-{
-	return talloc_realloc_size(pw, ptr, len);
-}
-
-
-
-/**
- * Create, set up, and whatnot, a Hubbub parser instance, along with the
- * relevant libxml2 bits.
- */
-static int html_create_parser(struct content *c)
-{
-	struct content_html_data *html = &c->data.html;
-	hubbub_parser_optparams param;
-
-	html->parser = hubbub_parser_create(html->encoding,
-			html_hubbub_realloc,
-			c);
-	if (!html->parser)
-		return 1;
-
-	html->document = xmlNewDoc(BAD_CAST "1.0");
-	if (!html->document)
-		return 1;
-
-	html->tree_handler = tree_handler;
-	html->tree_handler.ctx = c;
-	param.tree_handler = &html->tree_handler;
-	hubbub_parser_setopt(html->parser, HUBBUB_PARSER_TREE_HANDLER, &param);
-
-	param.document_node = html->document;
-	hubbub_parser_setopt(html->parser, HUBBUB_PARSER_DOCUMENT_NODE, &param);
-
-	return 0;
-}
-
-
-
-#endif
-
-
-
-
 /**
  * Create a CONTENT_HTML.
  *
@@ -485,15 +99,9 @@
 	struct content_html_data *html = &c->data.html;
 	union content_msg_data msg_data;
 
-	html->parser = 0;
+	html->parser_binding = NULL;
 	html->document = 0;
-#ifdef WITH_HUBBUB
-	html->has_ns = false;
-	memset(html->ns, 0, sizeof(html->ns));
-#endif
-	html->encoding_handler = 0;
 	html->encoding = 0;
-	html->getenc = true;
 	html->base_url = c->url;
 	html->base_target = NULL;
 	html->layout = 0;
@@ -520,31 +128,14 @@
 			if (!html->encoding)
 				goto no_memory;
 			html->encoding_source = ENCODING_SOURCE_HEADER;
-			html->getenc = false;
-			break;
-		}
-	}
-
-#ifndef WITH_HUBBUB
-	html->parser = htmlCreatePushParserCtxt(0, 0, "", 0, 0,
-			XML_CHAR_ENCODING_NONE);
-	if (!html->parser)
+			break;
+		}
+	}
+
+	/* Create the parser binding */
+	html->parser_binding = binding_create_tree(c, html->encoding);
+	if (!html->parser_binding)
 		goto no_memory;
-#else
-
-	/* Set up the parser, libxml2 document, and that */
-	if (html_create_parser(c) != 0)
-		goto no_memory;
-
-#endif
-
-#ifndef WITH_HUBBUB
-	if (html->encoding) {
-		/* an encoding was specified in the Content-Type header */
-		if (!html_set_parser_encoding(c, html->encoding))
-			return false;
-	}
-#endif
 
 	return true;
 
@@ -564,150 +155,53 @@
 bool html_process_data(struct content *c, char *data, unsigned int size)
 {
 	unsigned long x;
-
-#ifndef WITH_HUBBUB
-	if (c->data.html.getenc) {
-		/* No encoding was specified in the Content-Type header.
-		 * Attempt to detect if the encoding is not 8-bit. If the
-		 * encoding is 8-bit, leave the parser unchanged, so that it
-		 * searches for a <meta http-equiv="content-type"
-		 * content="text/html; charset=...">. */
-		const char *encoding;
-		encoding = html_detect_encoding((const char **) &data, &size);
-		if (encoding) {
-			if (!html_set_parser_encoding(c, encoding))
-				return false;
-			c->data.html.encoding = talloc_strdup(c, encoding);
-			if (!c->data.html.encoding)
-				return false;
-			c->data.html.encoding_source =
-					ENCODING_SOURCE_DETECTED;
-		}
-		c->data.html.getenc = false;
-
-		/* The data we received may have solely consisted of a BOM.
-		 * If so, it will have been stripped by html_detect_encoding.
-		 * Therefore, we'll have nothing to do in that case. */
-		if (size == 0)
-			return true;
-	}
-#endif
-
-#ifdef WITH_HUBBUB
-	hubbub_error err;
-#endif
+	binding_error err;
 
 	for (x = 0; x + CHUNK <= size; x += CHUNK) {
-#ifdef WITH_HUBBUB
 		LOG(("Parsing %d bytes", CHUNK));
-		err = hubbub_parser_parse_chunk(
-				c->data.html.parser, 
+		err = binding_parse_chunk(c->data.html.parser_binding,
 				(uint8_t *) data + x, CHUNK);
-		if (err == HUBBUB_ENCODINGCHANGE) {
+		if (err == BINDING_ENCODINGCHANGE) {
 			goto encoding_change;
 		}
-#else
-		htmlParseChunk(c->data.html.parser, data + x, CHUNK, 0);
-#endif
+
 		gui_multitask();
 	}
 
-#ifdef WITH_HUBBUB
 	LOG(("Parsing %lu bytes", (size - x)));
-	err = hubbub_parser_parse_chunk(
-			c->data.html.parser, 
+	err = binding_parse_chunk(c->data.html.parser_binding, 
 			(uint8_t *) data + x, (size - x));
-	if (err == HUBBUB_ENCODINGCHANGE) {
+	if (err == BINDING_ENCODINGCHANGE) {
 		goto encoding_change;
 	}
-#else
-	htmlParseChunk(c->data.html.parser, data + x, (int) (size - x), 0);
-#endif
-
-#ifndef WITH_HUBBUB
-	if (!c->data.html.encoding && c->data.html.parser->input->encoding) {
-		/* The encoding was not in headers or detected,
-		 * and the parser found a <meta http-equiv="content-type"
-		 * content="text/html; charset=...">. */
-
-		/* However, if that encoding is non-ASCII-compatible,
-		 * ignore it, as it can't possibly be correct */
-		if (strncasecmp((const char *) c->data.html.parser->
-					input->encoding,
-				"UTF-16", 6) == 0 || /* UTF-16(LE|BE)? */
-			strncasecmp((const char *) c->data.html.parser->
-					input->encoding,
-				"UTF-32", 6) == 0) { /* UTF-32(LE|BE)? */
-			c->data.html.encoding = talloc_strdup(c, "ISO-8859-1");
-			c->data.html.encoding_source =
-					ENCODING_SOURCE_DETECTED;
-		} else {
-			c->data.html.encoding = talloc_strdup(c,
-				(const char *) c->data.html.parser->
-						input->encoding);
-			c->data.html.encoding_source = ENCODING_SOURCE_META;
-		}
-
-		if (!c->data.html.encoding) {
-			union content_msg_data msg_data;
-
-			msg_data.error = messages_get("NoMemory");
-			content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
-			return false;
-		}
-
-		/* have the encoding; don't attempt to detect it */
-		c->data.html.getenc = false;
-
-		/* now, we must reset the parser such that it reparses
-		 * using the correct charset, and then reparse any document
-		 * source we've got. we achieve this by recreating the
-		 * parser in its entirety as this is simpler than resetting
-		 * the existing one and ensuring it's still set up correctly.
-		 */
-		if (c->data.html.parser->myDoc)
-			xmlFreeDoc(c->data.html.parser->myDoc);
-		htmlFreeParserCtxt(c->data.html.parser);
-
-		c->data.html.parser = htmlCreatePushParserCtxt(0, 0, "", 0,
-				0, XML_CHAR_ENCODING_NONE);
-		if (!c->data.html.parser) {
-			union content_msg_data msg_data;
-
-			msg_data.error = messages_get("NoMemory");
-			content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
-			return false;
-		}
-		if (!html_set_parser_encoding(c, c->data.html.encoding))
-			return false;
-
-		/* and reparse received document source - the recursion
-		 * is safe as we've just set c->data.html.encoding so
-		 * we'll never get back in here. */
-		if (!html_process_data(c, c->source_data, c->source_size))
-			return false;
-	}
-#endif
 
 	return true;
 
-#ifdef WITH_HUBBUB
-
 encoding_change:
 
 	LOG(("Changing encoding"));
 
-	/* Free up hubbub, libxml2 etc */
-	hubbub_parser_destroy(c->data.html.parser);
-	if (c->data.html.document) {
-		xmlFreeDoc(c->data.html.document);
-		c->data.html.document = NULL;
-	}
-	c->data.html.has_ns = false;
-	memset(c->data.html.ns, 0, sizeof(c->data.html.ns));
-
-	/* Set up the parser, libxml2 document, and that */
-	if (html_create_parser(c) != 0) {
+	/* Retrieve new encoding */
+	const char *encoding = binding_get_encoding(
+			c->data.html.parser_binding, 
+			&c->data.html.encoding_source);
+
+	c->data.html.encoding = strdup(encoding);
+	if (!c->data.html.encoding) {
+		union content_msg_data msg_data;
+
+		msg_data.error = messages_get("NoMemory");
+		content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
+		return false;
+	}
+
+	/* Destroy binding */
+	binding_destroy_tree(c->data.html.parser_binding);
+
+	/* Create new binding, using the new encoding */
+	c->data.html.parser_binding = binding_create_tree(c,
+			c->data.html.encoding);
+	if (!c->data.html.parser_binding) {
 		union content_msg_data msg_data;
 
 		msg_data.error = messages_get("NoMemory");
@@ -719,139 +213,7 @@
 	 * the encoding is now specified at parser-start which means
 	 * it cannot be changed again. */
 	return html_process_data(c, c->source_data, c->source_size);
-
-#endif
-
-}
-
-
-#ifndef WITH_HUBBUB
-
-/**
- * Set the HTML parser character encoding.
- *
- * \param  c         content of type CONTENT_HTML
- * \param  encoding  name of encoding
- * \return  true on success, false on error and error reported
- */
-bool html_set_parser_encoding(struct content *c, const char *encoding)
-{
-	struct content_html_data *html = &c->data.html;
-	xmlError *error;
-	char error_message[500];
-	union content_msg_data msg_data;
-
-	html->encoding_handler = xmlFindCharEncodingHandler(encoding);
-	if (!html->encoding_handler) {
-		/* either out of memory, or no handler available */
-		/* assume no handler available, which is not a fatal error */
-		LOG(("no encoding handler for \"%s\"", encoding));
-		/* \todo  warn user and ask them to install iconv? */
-		return true;
-	}
-
-	xmlCtxtResetLastError(html->parser);
-	if (xmlSwitchToEncoding(html->parser, html->encoding_handler)) {
-		error = xmlCtxtGetLastError(html->parser);
-		snprintf(error_message, sizeof error_message,
-				"%s xmlSwitchToEncoding(): %s",
-				messages_get("MiscError"),
-				error ? error->message : "failed");
-		msg_data.error = error_message;
-		content_broadcast(c, CONTENT_MSG_ERROR, msg_data);
-		return false;
-	}
-
-	/* Dirty hack to get around libxml oddness:
-	 * 1) When creating a push parser context, the input flow's encoding
-	 *    string is not set (whether an encoding is specified or not)
-	 * 2) When switching encoding (as above), the input flow's encoding
-	 *    string is never changed
-	 * 3) When handling a meta charset, the input flow's encoding string
-	 *    is checked to determine if an encoding has already been set.
-	 *    If it has been set, then the meta charset is ignored.
-	 *
-	 * The upshot of this is that, if we don't explicitly set the input
-	 * flow's encoding string here, any meta charset in the document
-	 * will override our setting, which is incorrect behaviour.
-	 *
-	 * Ideally, this would be fixed in libxml, but that requires rather
-	 * more knowledge than I currently have of what libxml is doing.
-	 */
-	if (!html->parser->input->encoding)
-		html->parser->input->encoding =
-				xmlStrdup((const xmlChar *) encoding);
-
-	/* Ensure noone else attempts to reset the encoding */
-	html->getenc = false;
-
-	return true;
-}
-
-
-/**
- * Attempt to detect the encoding of some HTML data.
- *
- * \param  data  Pointer to HTML source data
- * \param  size  Pointer to length of data
- * \return  a constant string giving the encoding, or 0 if the encoding
- *          appears to be some 8-bit encoding
- *
- * If a BOM is encountered, *data and *size will be modified to skip over it
- */
-
-const char *html_detect_encoding(const char **data, unsigned int *size)
-{
-	const unsigned char *d = (const unsigned char *) *data;
-
-	/* this detection assumes that the first two characters are <= 0xff */
-	if (*size < 4)
-		return 0;
-
-	if (d[0] == 0x00 && d[1] == 0x00 &&
-			d[2] == 0xfe && d[3] == 0xff) { /* BOM 00 00 fe ff */
-		*data += 4;
-		*size -= 4;
-		return "UTF-32BE";
-	} else if (d[0] == 0xff && d[1] == 0xfe &&
-			d[2] == 0x00 && d[3] == 0x00) { /* BOM ff fe 00 00 */
-		*data += 4;
-		*size -= 4;
-		return "UTF-32LE";
-	}
-	else if (d[0] == 0x00 && d[1] != 0x00 &&
-			d[2] == 0x00 && d[3] != 0x00)   /* 00 xx 00 xx */
-		return "UTF-16BE";
-	else if (d[0] != 0x00 && d[1] == 0x00 &&
-			d[2] != 0x00 && d[3] == 0x00)   /* xx 00 xx 00 */
-		return "UTF-16LE";
-	else if (d[0] == 0x00 && d[1] == 0x00 &&
-			d[2] == 0x00 && d[3] != 0x00)   /* 00 00 00 xx */
-		return "ISO-10646-UCS-4";
-	else if (d[0] != 0x00 && d[1] == 0x00 &&
-			d[2] == 0x00 && d[3] == 0x00)   /* xx 00 00 00 */
-		return "ISO-10646-UCS-4";
-	else if (d[0] == 0xfe && d[1] == 0xff) {        /* BOM fe ff */
-		*data += 2;
-		*size -= 2;
-		return "UTF-16BE";
-	} else if (d[0] == 0xff && d[1] == 0xfe) {      /* BOM ff fe */
-		*data += 2;
-		*size -= 2;
-		return "UTF-16LE";
-	} else if (d[0] == 0xef && d[1] == 0xbb &&
-			d[2] == 0xbf) {                 /* BOM ef bb bf */
-		*data += 3;
-		*size -= 3;
-		return "UTF-8";
-	}
-
-	return 0;
-}
-
-
-#endif
-
+}
 
 /**
  * Convert a CONTENT_HTML for display.
@@ -875,29 +237,19 @@
 	unsigned int time_before, time_taken;
 
 	/* finish parsing */
-	if (c->source_size == 0)
-#ifndef WITH_HUBBUB
-		htmlParseChunk(c->data.html.parser, empty_document,
-				sizeof empty_document, 0);
-#else
-		hubbub_parser_parse_chunk(c->data.html.parser,
+	if (c->source_size == 0) {
+		binding_parse_chunk(c->data.html.parser_binding,
 				(uint8_t *) empty_document,
 				sizeof empty_document);
-#endif
-
-#ifndef WITH_HUBBUB
-	htmlParseChunk(c->data.html.parser, "", 0, 1);
-	c->data.html.document = c->data.html.parser->myDoc;
+	}
+
+	binding_parse_completed(c->data.html.parser_binding);
+	c->data.html.document = 
+			binding_get_document(c->data.html.parser_binding);
 	/*xmlDebugDumpDocument(stderr, c->data.html.document);*/
-	htmlFreeParserCtxt(c->data.html.parser);
-	c->data.html.parser = 0;
-#else
-	hubbub_parser_completed(c->data.html.parser);
-	hubbub_parser_destroy(c->data.html.parser);
-	c->data.html.parser = 0;
-	c->data.html.document = c->data.html.document;
-	/*xmlDebugDumpDocument(stderr, document);*/
-#endif
+	binding_destroy_tree(c->data.html.parser_binding);
+	c->data.html.parser_binding = NULL;
+
 	if (!c->data.html.document) {
 		LOG(("Parsing failed"));
 		msg_data.error = messages_get("ParsingFail");
@@ -2206,12 +1558,8 @@
 	  	c->bitmap = NULL;
 	}
 
-	if (c->data.html.parser)
-#ifndef WITH_HUBBUB
-		htmlFreeParserCtxt(c->data.html.parser);
-#else
-		hubbub_parser_destroy(c->data.html.parser);
-#endif
+	if (c->data.html.parser_binding)
+		binding_destroy_tree(c->data.html.parser_binding);
 
 	if (c->data.html.document)
 		xmlFreeDoc(c->data.html.document);

Modified: trunk/netsurf/render/html.h
URL: http://source.netsurf-browser.org/trunk/netsurf/render/html.h?rev=5404&r1=5403&r2=5404&view=diff
==============================================================================
--- trunk/netsurf/render/html.h (original)
+++ trunk/netsurf/render/html.h Mon Sep 22 21:19:50 2008
@@ -26,13 +26,9 @@
 #define _NETSURF_RENDER_HTML_H_
 
 #include <stdbool.h>
-#ifdef WITH_HUBBUB
-#include <hubbub/parser.h>
-#include <hubbub/tree.h>
-#endif
-#include <libxml/HTMLparser.h>
 #include "content/content_type.h"
 #include "css/css.h"
+#include "render/parser_binding.h"
 
 struct box;
 struct rect;
@@ -43,9 +39,6 @@
 struct object_params;
 struct plotters;
 
-/* Number of namespaces we support */
-#define NUM_NAMESPACES		7
-
 /* entries in stylesheet_content */
 #define STYLESHEET_BASE		0	/* base style sheet */
 #define STYLESHEET_ADBLOCK	1	/* adblocking stylesheet */
@@ -121,26 +114,12 @@
 
 /** Data specific to CONTENT_HTML. */
 struct content_html_data {
-#ifndef WITH_HUBBUB
-	htmlParserCtxt *parser;  /**< HTML parser context. */
-#else
-	hubbub_parser *parser; /**< HTML parser context. */
-	hubbub_tree_handler tree_handler;
-
-	bool has_ns;
-	xmlNs *ns[NUM_NAMESPACES];
-#endif
+	void *parser_binding;
 	xmlDoc *document;
 
-	/** HTML parser encoding handler. */
-	xmlCharEncodingHandler *encoding_handler;
-
 	char *encoding;	/**< Encoding of source, 0 if unknown. */
-	enum { ENCODING_SOURCE_HEADER, ENCODING_SOURCE_DETECTED,
-			ENCODING_SOURCE_META } encoding_source;
+	binding_encoding_source encoding_source;
 				/**< Source of encoding information. */
-	bool getenc; /**< Need to get the encoding from the document, as it
-	              * wasn't specified in the Content-Type header. */
 
 	char *base_url;	/**< Base URL (may be a copy of content->url). */
 	char *base_target;	/**< Base target */

Added: trunk/netsurf/render/hubbub_binding.c
URL: http://source.netsurf-browser.org/trunk/netsurf/render/hubbub_binding.c?rev=5404&view=auto
==============================================================================
--- trunk/netsurf/render/hubbub_binding.c (added)
+++ trunk/netsurf/render/hubbub_binding.c Mon Sep 22 21:19:50 2008
@@ -1,0 +1,643 @@
+/*
+ * Copyright 2008 Andrew Sidwell <takkaria at netsurf-browser.org> 
+ * Copyright 2008 John-Mark Bell <jmb at netsurf-browser.org>
+ *
+ * This file is part of NetSurf, http://www.netsurf-browser.org/
+ *
+ * NetSurf is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * NetSurf is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef WITH_HUBBUB
+
+#define _GNU_SOURCE /* for strndup */
+#include <assert.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+
+#include <hubbub/parser.h>
+#include <hubbub/tree.h>
+
+#include "render/parser_binding.h"
+
+#include "utils/log.h"
+#include "utils/talloc.h"
+
+typedef struct hubbub_ctx {
+	hubbub_parser *parser;
+
+	htmlDocPtr document;
+	bool owns_doc;
+
+	const char *encoding;
+	binding_encoding_source encoding_source;
+
+#define NUM_NAMESPACES (6)
+	xmlNsPtr namespaces[NUM_NAMESPACES];
+#undef NUM_NAMESPACES
+
+	hubbub_tree_handler tree_handler;
+} hubbub_ctx;
+
+static struct {
+	const char *prefix;
+	const char *url;
+} namespaces[] = {
+	{ NULL, NULL },
+	{ NULL, "http://www.w3.org/1999/xhtml" },
+	{ "math", "http://www.w3.org/1998/Math/MathML" },
+	{ "svg", "http://www.w3.org/2000/svg" },
+	{ "xlink", "http://www.w3.org/1999/xlink" },
+	/** \todo Oh dear. LibXML2 refuses to create any namespace with a 
+	 * prefix of "xml". That sucks, royally. */
+	{ "xml", "http://www.w3.org/XML/1998/namespace" },
+	{ "xmlns", "http://www.w3.org/2000/xmlns/" }
+};
+
+static inline char *c_string_from_hubbub_string(hubbub_ctx *ctx, 
+		const hubbub_string *str);
+static void create_namespaces(hubbub_ctx *ctx, xmlNode *root);
+static int create_comment(void *ctx, const hubbub_string *data, void **result);
+static int create_doctype(void *ctx, const hubbub_doctype *doctype,
+		void **result);
+static int create_element(void *ctx, const hubbub_tag *tag, void **result);
+static int create_text(void *ctx, const hubbub_string *data, void **result);
+static int ref_node(void *ctx, void *node);
+static int unref_node(void *ctx, void *node);
+static int append_child(void *ctx, void *parent, void *child, void **result);
+static int insert_before(void *ctx, void *parent, void *child, void *ref_child,
+		void **result);
+static int remove_child(void *ctx, void *parent, void *child, void **result);
+static int clone_node(void *ctx, void *node, bool deep, void **result);
+static int reparent_children(void *ctx, void *node, void *new_parent);
+static int get_parent(void *ctx, void *node, bool element_only, void **result);
+static int has_children(void *ctx, void *node, bool *result);
+static int form_associate(void *ctx, void *form, void *node);
+static int add_attributes(void *ctx, void *node,
+		const hubbub_attribute *attributes, uint32_t n_attributes);
+static int set_quirks_mode(void *ctx, hubbub_quirks_mode mode);
+static int change_encoding(void *ctx, const char *charset);
+
+static hubbub_tree_handler tree_handler = {
+	create_comment,
+	create_doctype,
+	create_element,
+	create_text,
+	ref_node,
+	unref_node,
+	append_child,
+	insert_before,
+	remove_child,
+	clone_node,
+	reparent_children,
+	get_parent,
+	has_children,
+	form_associate,
+	add_attributes,
+	set_quirks_mode,
+	change_encoding,
+	NULL
+};
+
+static void *myrealloc(void *ptr, size_t len, void *pw)
+{
+	return talloc_realloc_size(pw, ptr, len);
+}
+
+void *binding_create_tree(void *arena, const char *charset)
+{
+	hubbub_ctx *ctx;
+	hubbub_parser_optparams params;
+
+	ctx = malloc(sizeof(hubbub_ctx));
+	if (ctx == NULL)
+		return NULL;
+
+	ctx->parser = NULL;
+	ctx->encoding = charset;
+	ctx->encoding_source = ENCODING_SOURCE_HEADER;
+	ctx->document = NULL;
+	ctx->owns_doc = true;
+
+	ctx->parser = hubbub_parser_create(charset, myrealloc, arena);
+	if (ctx->parser == NULL) {
+		free(ctx);
+		return NULL;
+	}
+
+	ctx->document = htmlNewDocNoDtD(NULL, NULL);
+	if (ctx->document == NULL) {
+		hubbub_parser_destroy(ctx->parser);
+		free(ctx);
+		return NULL;
+	}
+	ctx->document->_private = (void *) 0;
+
+	for (uint32_t i = 0; 
+		i < sizeof(ctx->namespaces) / sizeof(ctx->namespaces[0]); i++) {
+		ctx->namespaces[i] = NULL;
+	}
+
+	ctx->tree_handler = tree_handler;
+	ctx->tree_handler.ctx = (void *) ctx;
+
+	params.tree_handler = &ctx->tree_handler;
+	hubbub_parser_setopt(ctx->parser, HUBBUB_PARSER_TREE_HANDLER, &params);
+
+	ref_node(ctx, ctx->document);
+	params.document_node = ctx->document;
+	hubbub_parser_setopt(ctx->parser, HUBBUB_PARSER_DOCUMENT_NODE, &params);
+
+	return (void *) ctx;
+}
+
+void binding_destroy_tree(void *ctx)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+
+	if (ctx == NULL)
+		return;
+
+	if (c->parser != NULL)
+		hubbub_parser_destroy(c->parser);
+
+	if (c->owns_doc)
+		xmlFreeDoc(c->document);
+
+	c->parser = NULL;
+	c->encoding = NULL;
+	c->document = NULL;
+
+	free(c);
+}
+
+binding_error binding_parse_chunk(void *ctx, const uint8_t *data, size_t len)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	hubbub_error err;
+
+	err = hubbub_parser_parse_chunk(c->parser, (uint8_t *) data, len);
+	if (err == HUBBUB_ENCODINGCHANGE)
+		return BINDING_ENCODINGCHANGE;
+
+	return BINDING_OK;
+}
+
+binding_error binding_parse_completed(void *ctx)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	hubbub_error error;
+
+	error = hubbub_parser_completed(c->parser);
+	/** \todo error handling */
+
+	return BINDING_OK;
+}
+
+const char *binding_get_encoding(void *ctx, binding_encoding_source *source)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+
+	*source = c->encoding_source;
+
+	return c->encoding;
+}
+
+xmlDocPtr binding_get_document(void *ctx)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	xmlDocPtr doc = c->document;
+
+	c->owns_doc = false;
+
+	return doc;
+}
+
+/*****************************************************************************/
+
+char *c_string_from_hubbub_string(hubbub_ctx *ctx, const hubbub_string *str)
+{
+	return strndup((const char *) str->ptr, (int) str->len);
+}
+
+void create_namespaces(hubbub_ctx *ctx, xmlNode *root)
+{
+	for (uint32_t i = 1; 
+			i < sizeof(namespaces) / sizeof(namespaces[0]); i++) {
+		ctx->namespaces[i - 1] = xmlNewNs(root, 
+				BAD_CAST namespaces[i].url, 
+				BAD_CAST namespaces[i].prefix);
+
+		if (ctx->namespaces[i - 1] == NULL) {
+			LOG(("Failed creating namespace %s\n", 
+					namespaces[i].prefix));
+		}
+	}
+}
+
+int create_comment(void *ctx, const hubbub_string *data, void **result)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	char *content;
+	xmlNodePtr n;
+
+	content = c_string_from_hubbub_string(c, data);
+	if (content == NULL)
+		return 1;
+
+	n = xmlNewDocComment(c->document, BAD_CAST content);
+	if (n == NULL) {
+		free(content);
+		return 1;
+	}
+	n->_private = (void *) (uintptr_t) 1;
+
+	free(content);
+
+	*result = (void *) n;
+
+	return 0;
+}
+
+int create_doctype(void *ctx, const hubbub_doctype *doctype, void **result)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	char *name, *public = NULL, *system = NULL;
+	xmlDtdPtr n;
+
+	name = c_string_from_hubbub_string(c, &doctype->name);
+	if (name == NULL)
+		return 1;
+
+	if (!doctype->public_missing) {
+		public = c_string_from_hubbub_string(c, &doctype->public_id);
+		if (public == NULL) {
+			free(name);
+			return 1;
+		}
+	}
+
+	if (!doctype->system_missing) {
+		system = c_string_from_hubbub_string(c, &doctype->system_id);
+		if (system == NULL) {
+			free(public);
+			free(name);
+			return 1;
+		}
+	}
+
+	n = xmlNewDtd(c->document, BAD_CAST name, 
+			BAD_CAST (public ? public : ""),
+			BAD_CAST (system ? system : ""));
+	if (n == NULL) {
+		free(system);
+		free(public);
+		free(name);
+		return 1;
+	}
+	n->_private = (void *) (uintptr_t) 1;
+
+	*result = (void *) n;
+
+	free(system);
+	free(public);
+	free(name);
+
+	return 0;
+}
+
+int create_element(void *ctx, const hubbub_tag *tag, void **result)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	char *name;
+	xmlNodePtr n;
+
+	name = c_string_from_hubbub_string(c, &tag->name);
+	if (name == NULL)
+		return 1;
+
+	if (c->namespaces[0] != NULL) {
+		n = xmlNewDocNode(c->document, c->namespaces[tag->ns - 1], 
+				BAD_CAST name, NULL);
+	} else {
+		n = xmlNewDocNode(c->document, NULL, BAD_CAST name, NULL);
+
+		/* We're creating the root node of the document. Therefore,
+		 * create the namespaces and set this node's namespace */
+		if (n != NULL && c->namespaces[0] == NULL) {
+			create_namespaces(c, (void *) n);
+
+			xmlSetNs(n, c->namespaces[tag->ns - 1]);
+		}
+	}
+	if (n == NULL) {
+		free(name);
+		return 1;
+	}
+	n->_private = (void *) (uintptr_t) 1;
+
+	if (tag->n_attributes > 0 && add_attributes(ctx, (void *) n, 
+			tag->attributes, tag->n_attributes) != 0) {
+		xmlFreeNode(n);
+		free(name);
+		return 1;
+	}
+
+	*result = (void *) n;
+
+	free(name);
+
+	return 0;
+}
+
+int create_text(void *ctx, const hubbub_string *data, void **result)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	xmlNodePtr n;
+
+	n = xmlNewDocTextLen(c->document, BAD_CAST data->ptr, (int) data->len);
+	if (n == NULL) {
+		return 1;
+	}
+	n->_private = (void *) (uintptr_t) 1;
+
+	*result = (void *) n;
+
+	return 0;
+}
+
+int ref_node(void *ctx, void *node)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+
+	if (node == c->document) {
+		xmlDoc *n = (xmlDoc *) node;
+		uintptr_t count = (uintptr_t) n->_private;
+
+		n->_private = (void *) ++count;
+	} else {
+		xmlNode *n = (xmlNode *) node;
+		uintptr_t count = (uintptr_t) n->_private;
+
+		n->_private = (void *) ++count;
+	}
+
+	return 0;
+}
+
+int unref_node(void *ctx, void *node)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+
+	if (node == c->document) {
+		xmlDoc *n = (xmlDoc *) node;
+		uintptr_t count = (uintptr_t) n->_private;
+
+		assert(count != 0 && "Node has refcount of zero");
+
+		n->_private = (void *) --count;
+	} else {
+		xmlNode *n = (xmlNode *) node;
+		uintptr_t count = (uintptr_t) n->_private;
+
+		assert(count != 0 && "Node has refcount of zero");
+
+		n->_private = (void *) --count;
+
+		if (count == 0 && n->parent == NULL) {
+			xmlFreeNode(n);
+		}
+	}
+
+	return 0;
+}
+
+int append_child(void *ctx, void *parent, void *child, void **result)
+{
+	xmlNode *chld = (xmlNode *) child;
+	xmlNode *p = (xmlNode *) parent;
+
+	if (chld->type == XML_TEXT_NODE && p->last != NULL && 
+			p->last->type == XML_TEXT_NODE) {
+		/* Need to clone the child, as libxml will free it if it 
+		 * merges the content with a pre-existing text node. */
+		chld = xmlCopyNode(chld, 0);
+		if (chld == NULL)
+			return 1;
+
+		*result = xmlAddChild(p, chld);
+
+		assert(*result != (void *) chld);
+	} else {
+		*result = xmlAddChild(p, chld);
+	}
+
+	if (*result == NULL)
+		return 1;
+
+	ref_node(ctx, *result);
+
+	return 0;
+}
+
+int insert_before(void *ctx, void *parent, void *child, void *ref_child,
+		void **result)
+{
+	xmlNode *chld = (xmlNode *) child;
+	xmlNode *ref = (xmlNode *) ref_child;
+
+	if (chld->type == XML_TEXT_NODE && ref->prev != NULL && 
+			ref->prev->type == XML_TEXT_NODE) {
+		/* Clone text node, as it'll be freed by libxml */
+		chld = xmlCopyNode(chld, 0);
+		if (chld == NULL)
+			return 1;
+
+		*result = xmlAddNextSibling(ref->prev, chld);
+
+		assert(*result != (void *) chld);
+	} else {
+		*result = xmlAddPrevSibling(ref, chld);
+	}
+
+	if (*result == NULL)
+		return 1;
+
+	ref_node(ctx, *result);
+
+	return 0;
+}
+
+int remove_child(void *ctx, void *parent, void *child, void **result)
+{
+	xmlNode *chld = (xmlNode *) child;
+
+	xmlUnlinkNode(chld);
+
+	*result = child;
+
+	ref_node(ctx, *result);
+
+	return 0;
+}
+
+int clone_node(void *ctx, void *node, bool deep, void **result)
+{
+	xmlNode *n = (xmlNode *) node;
+
+	*result = xmlCopyNode(n, deep ? 1 : 2);
+
+	if (*result == NULL)
+		return 1;
+
+	((xmlNode *)(*result))->_private = (void *) (uintptr_t) 1;
+
+	return 0;
+}
+
+int reparent_children(void *ctx, void *node, void *new_parent)
+{
+	xmlNode *n = (xmlNode *) node;
+	xmlNode *p = (xmlNode *) new_parent;
+
+	for (xmlNode *child = n->children; child != NULL; ) {
+		xmlNode *next = child->next;
+
+		xmlUnlinkNode(child);
+
+		if (xmlAddChild(p, child) == NULL)
+			return 1;
+
+		child = next;
+	}
+
+	return 0;
+}
+
+int get_parent(void *ctx, void *node, bool element_only, void **result)
+{
+	xmlNode *n = (xmlNode *) node;
+
+	*result = (void *) n->parent;
+
+	if (*result != NULL && element_only && 
+			((xmlNode *) *result)->type != XML_ELEMENT_NODE) {
+		*result = NULL;
+	}
+
+	if (*result != NULL)
+		ref_node(ctx, *result);
+
+	return 0;
+}
+
+int has_children(void *ctx, void *node, bool *result)
+{
+	xmlNode *n = (xmlNode *) node;
+
+	*result = n->children != NULL;
+
+	return 0;
+}
+
+int form_associate(void *ctx, void *form, void *node)
+{
+	return 0;
+}
+
+int add_attributes(void *ctx, void *node, 
+		const hubbub_attribute *attributes, uint32_t n_attributes)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+	xmlNode *n = (xmlNode *) node;
+
+	for (uint32_t attr = 0; attr < n_attributes; attr++) {
+		xmlAttr *prop;
+		char *name, *value;
+
+		name = c_string_from_hubbub_string(c, &attributes[attr].name);
+		if (name == NULL)
+			return 1;
+
+		value = c_string_from_hubbub_string(c, &attributes[attr].value);
+		if (value == NULL) {
+			free(name);
+			return 1;
+		}
+
+		if (attributes[attr].ns != HUBBUB_NS_NULL && 
+				c->namespaces[0] != NULL) {
+			prop = xmlNewNsProp(n, 
+					c->namespaces[attributes[attr].ns - 1],
+					BAD_CAST name, BAD_CAST value);
+		} else {
+			prop = xmlNewProp(n, BAD_CAST name, BAD_CAST value);
+		}
+		if (prop == NULL) {
+			free(value);
+			free(name);
+			return 1;
+		}
+
+		free(value);
+		free(name);
+	}
+
+	return 0;
+}
+
+int set_quirks_mode(void *ctx, hubbub_quirks_mode mode)
+{
+	return 0;
+}
+
+int change_encoding(void *ctx, const char *charset)
+{
+	hubbub_ctx *c = (hubbub_ctx *) ctx;
+
+	/* If we have an encoding here, it means we are *certain* */
+	if (c->encoding != NULL) {
+		return 0;
+	}
+
+	/* Find the confidence otherwise (can only be from a BOM) */
+	uint32_t source;
+	const char *name = hubbub_parser_read_charset(c->parser, &source);
+
+	if (source == HUBBUB_CHARSET_CONFIDENT) {
+		c->encoding_source = ENCODING_SOURCE_DETECTED;
+		c->encoding = (char *) charset;
+		return 0;
+	}
+
+	/* So here we have something of confidence tentative... */
+	/* http://www.whatwg.org/specs/web-apps/current-work/#change */
+
+	/* 2. "If the new encoding is identical or equivalent to the encoding
+	 * that is already being used to interpret the input stream, then set
+	 * the confidence to confident and abort these steps." */
+
+	/* Whatever happens, the encoding should be set here; either for
+	 * reprocessing with a different charset, or for confirming that the
+	 * charset is in fact correct */
+	c->encoding = charset;
+	c->encoding_source = ENCODING_SOURCE_META;
+
+	/* Equal encodings will have the same string pointers */
+	return (charset == name) ? 0 : 1;
+}
+
+#endif
+

Added: trunk/netsurf/render/libxml_binding.c
URL: http://source.netsurf-browser.org/trunk/netsurf/render/libxml_binding.c?rev=5404&view=auto
==============================================================================
--- trunk/netsurf/render/libxml_binding.c (added)
+++ trunk/netsurf/render/libxml_binding.c Mon Sep 22 21:19:50 2008
@@ -1,0 +1,308 @@
+/*
+ * Copyright 2007 James Bursa <bursa at users.sourceforge.net>
+ * Copyright 2008 John-Mark Bell <jmb at netsurf-browser.org>
+ *
+ * This file is part of NetSurf, http://www.netsurf-browser.org/
+ *
+ * NetSurf is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * NetSurf is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef WITH_HUBBUB
+
+#include <stdbool.h>
+#include <string.h>
+
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+
+#include "render/parser_binding.h"
+
+#include "utils/log.h"
+#include "utils/talloc.h"
+
+typedef struct libxml_ctx {
+	htmlParserCtxt *parser;
+
+	/** HTML parser encoding handler. */
+	xmlCharEncodingHandler *encoding_handler;
+
+	const char *encoding;
+	binding_encoding_source encoding_source;
+
+	bool getenc;
+} libxml_ctx;
+
+static bool set_parser_encoding(libxml_ctx *c, const char *encoding);
+static const char *detect_encoding(const char **data, size_t *size);
+
+void *binding_create_tree(void *arena, const char *charset)
+{
+	libxml_ctx *ctx;
+
+	ctx = malloc(sizeof(libxml_ctx));
+	if (ctx == NULL)
+		return NULL;
+
+	ctx->parser = NULL;
+	ctx->encoding_handler = NULL;
+	ctx->encoding = charset;
+	ctx->encoding_source = ENCODING_SOURCE_HEADER;
+	ctx->getenc = true;
+
+	ctx->parser = htmlCreatePushParserCtxt(0, 0, "", 0, 0, 
+			XML_CHAR_ENCODING_NONE);
+	if (ctx->parser == NULL) {
+		free(ctx);
+		return NULL;
+	}
+
+	if (ctx->encoding != NULL && !set_parser_encoding(ctx, charset)) {
+		if (ctx->parser->myDoc != NULL)
+			xmlFreeDoc(ctx->parser->myDoc);
+		htmlFreeParserCtxt(ctx->parser);
+		free(ctx);
+		return NULL;
+	}
+
+	return (void *) ctx;
+}
+
+void binding_destroy_tree(void *ctx)
+{
+	libxml_ctx *c = (libxml_ctx *) ctx;
+
+	if (ctx == NULL)
+		return;
+
+	if (c->parser->myDoc != NULL)
+		xmlFreeDoc(c->parser->myDoc);
+
+	if (c->parser != NULL)
+		htmlFreeParserCtxt(c->parser);
+
+	c->parser = NULL;
+	c->encoding = NULL;
+
+	free(c);
+}
+
+binding_error binding_parse_chunk(void *ctx, const uint8_t *data, size_t len)
+{
+	libxml_ctx *c = (libxml_ctx *) ctx;
+
+	if (c->getenc) {
+		/* No encoding was specified in the Content-Type header.
+		 * Attempt to detect if the encoding is not 8-bit. If the
+		 * encoding is 8-bit, leave the parser unchanged, so that it
+		 * searches for a <meta http-equiv="content-type"
+		 * content="text/html; charset=...">. */
+		const char *encoding;
+		encoding = detect_encoding((const char **) (void *) &data, 
+				&len);
+		if (encoding) {
+			if (!set_parser_encoding(c, encoding))
+				return BINDING_NOMEM;
+			c->encoding = encoding;
+			c->encoding_source = ENCODING_SOURCE_DETECTED;
+		}
+		c->getenc = false;
+
+		/* The data we received may have solely consisted of a BOM.
+		 * If so, it will have been stripped by html_detect_encoding.
+		 * Therefore, we'll have nothing to do in that case. */
+		if (len == 0)
+			return BINDING_OK;
+	}
+
+	htmlParseChunk(c->parser, (const char *) data, len, 0);
+	/** \todo error handling */
+
+	if (!c->encoding && c->parser->input->encoding) {
+		/* The encoding was not in headers or detected,
+		 * and the parser found a <meta http-equiv="content-type"
+		 * content="text/html; charset=...">. */
+
+		/* However, if that encoding is non-ASCII-compatible,
+		 * ignore it, as it can't possibly be correct */
+		if (strncasecmp((const char *) c->parser->input->encoding,
+				"UTF-16", 6) == 0 || /* UTF-16(LE|BE)? */
+			strncasecmp((const char *) c->parser->input->encoding,
+				"UTF-32", 6) == 0) { /* UTF-32(LE|BE)? */
+			c->encoding = "ISO-8859-1";
+			c->encoding_source = ENCODING_SOURCE_DETECTED;
+		} else {
+			c->encoding = (const char *) c->parser->input->encoding;
+			c->encoding_source = ENCODING_SOURCE_META;
+		}
+
+		if (!c->encoding)
+			return BINDING_NOMEM;
+
+		/* have the encoding; don't attempt to detect it */
+		c->getenc = false;
+
+		return BINDING_ENCODINGCHANGE;
+	}
+
+	return BINDING_OK;
+}
+
+binding_error binding_parse_completed(void *ctx)
+{
+	libxml_ctx *c = (libxml_ctx *) ctx;
+
+	htmlParseChunk(c->parser, "", 0, 1);
+	/** \todo error handling */
+
+	return BINDING_OK;
+}
+
+const char *binding_get_encoding(void *ctx, binding_encoding_source *source)
+{
+	libxml_ctx *c = (libxml_ctx *) ctx;
+
+	*source = c->encoding_source;
+
+	return c->encoding;
+}
+
+xmlDocPtr binding_get_document(void *ctx)
+{
+	libxml_ctx *c = (libxml_ctx *) ctx;
+	xmlDocPtr doc = c->parser->myDoc;
+
+	c->parser->myDoc = NULL;
+
+	return doc;
+}
+
+/******************************************************************************/
+
+/**
+ * Set the HTML parser character encoding.
+ *
+ * \param  c         context
+ * \param  encoding  name of encoding
+ * \return  true on success, false on error and error reported
+ */
+bool set_parser_encoding(libxml_ctx *c, const char *encoding)
+{
+	xmlError *error;
+
+	c->encoding_handler = xmlFindCharEncodingHandler(encoding);
+	if (!c->encoding_handler) {
+		/* either out of memory, or no handler available */
+		/* assume no handler available, which is not a fatal error */
+		LOG(("no encoding handler for \"%s\"", encoding));
+		/* \todo  warn user and ask them to install iconv? */
+		return true;
+	}
+
+	xmlCtxtResetLastError(c->parser);
+	if (xmlSwitchToEncoding(c->parser, c->encoding_handler)) {
+		error = xmlCtxtGetLastError(c->parser);
+		LOG(("xmlSwitchToEncoding(): %s",
+				error ? error->message : "failed"));
+		return false;
+	}
+
+	/* Dirty hack to get around libxml oddness:
+	 * 1) When creating a push parser context, the input flow's encoding
+	 *    string is not set (whether an encoding is specified or not)
+	 * 2) When switching encoding (as above), the input flow's encoding
+	 *    string is never changed
+	 * 3) When handling a meta charset, the input flow's encoding string
+	 *    is checked to determine if an encoding has already been set.
+	 *    If it has been set, then the meta charset is ignored.
+	 *
+	 * The upshot of this is that, if we don't explicitly set the input
+	 * flow's encoding string here, any meta charset in the document
+	 * will override our setting, which is incorrect behaviour.
+	 *
+	 * Ideally, this would be fixed in libxml, but that requires rather
+	 * more knowledge than I currently have of what libxml is doing.
+	 */
+	if (!c->parser->input->encoding)
+		c->parser->input->encoding =
+				xmlStrdup((const xmlChar *) encoding);
+
+	/* Ensure noone else attempts to reset the encoding */
+	c->getenc = false;
+
+	return true;
+}
+
+/**
+ * Attempt to detect the encoding of some HTML data.
+ *
+ * \param  data  Pointer to HTML source data
+ * \param  size  Pointer to length of data
+ * \return  a constant string giving the encoding, or 0 if the encoding
+ *          appears to be some 8-bit encoding
+ *
+ * If a BOM is encountered, *data and *size will be modified to skip over it
+ */
+
+const char *detect_encoding(const char **data, size_t *size)
+{
+	const unsigned char *d = (const unsigned char *) *data;
+
+	/* this detection assumes that the first two characters are <= 0xff */
+	if (*size < 4)
+		return 0;
+
+	if (d[0] == 0x00 && d[1] == 0x00 &&
+			d[2] == 0xfe && d[3] == 0xff) { /* BOM 00 00 fe ff */
+		*data += 4;
+		*size -= 4;
+		return "UTF-32BE";
+	} else if (d[0] == 0xff && d[1] == 0xfe &&
+			d[2] == 0x00 && d[3] == 0x00) { /* BOM ff fe 00 00 */
+		*data += 4;
+		*size -= 4;
+		return "UTF-32LE";
+	}
+	else if (d[0] == 0x00 && d[1] != 0x00 &&
+			d[2] == 0x00 && d[3] != 0x00)   /* 00 xx 00 xx */
+		return "UTF-16BE";
+	else if (d[0] != 0x00 && d[1] == 0x00 &&
+			d[2] != 0x00 && d[3] == 0x00)   /* xx 00 xx 00 */
+		return "UTF-16LE";
+	else if (d[0] == 0x00 && d[1] == 0x00 &&
+			d[2] == 0x00 && d[3] != 0x00)   /* 00 00 00 xx */
+		return "ISO-10646-UCS-4";
+	else if (d[0] != 0x00 && d[1] == 0x00 &&
+			d[2] == 0x00 && d[3] == 0x00)   /* xx 00 00 00 */
+		return "ISO-10646-UCS-4";
+	else if (d[0] == 0xfe && d[1] == 0xff) {        /* BOM fe ff */
+		*data += 2;
+		*size -= 2;
+		return "UTF-16BE";
+	} else if (d[0] == 0xff && d[1] == 0xfe) {      /* BOM ff fe */
+		*data += 2;
+		*size -= 2;
+		return "UTF-16LE";
+	} else if (d[0] == 0xef && d[1] == 0xbb &&
+			d[2] == 0xbf) {                 /* BOM ef bb bf */
+		*data += 3;
+		*size -= 3;
+		return "UTF-8";
+	}
+
+	return 0;
+}
+
+#endif
+

Added: trunk/netsurf/render/parser_binding.h
URL: http://source.netsurf-browser.org/trunk/netsurf/render/parser_binding.h?rev=5404&view=auto
==============================================================================
--- trunk/netsurf/render/parser_binding.h (added)
+++ trunk/netsurf/render/parser_binding.h Mon Sep 22 21:19:50 2008
@@ -1,0 +1,48 @@
+/*
+ * Copyright 2008 John-Mark Bell <jmb at netsurf-browser.org>
+ *
+ * This file is part of NetSurf, http://www.netsurf-browser.org/
+ *
+ * NetSurf is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * NetSurf is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _NETSURF_RENDER_PARSER_BINDING_H_
+#define _NETSURF_RENDER_PARSER_BINDING_H_
+
+#include <stdint.h>
+
+#include <libxml/tree.h>
+
+typedef enum binding_error {
+	BINDING_OK,
+	BINDING_NOMEM,
+	BINDING_ENCODINGCHANGE
+} binding_error;
+
+typedef enum binding_encoding_source { 
+	ENCODING_SOURCE_HEADER, 
+	ENCODING_SOURCE_DETECTED,
+	ENCODING_SOURCE_META 
+} binding_encoding_source;
+
+void *binding_create_tree(void *arena, const char *charset);
+void binding_destroy_tree(void *ctx);
+
+binding_error binding_parse_chunk(void *ctx, const uint8_t *data, size_t len);
+binding_error binding_parse_completed(void *ctx);
+
+const char *binding_get_encoding(void *ctx, binding_encoding_source *source);
+xmlDocPtr binding_get_document(void *ctx);
+
+#endif
+




More information about the netsurf-commits mailing list