Switch to using hubbub_error for reprocessing state from just a bool, to allow for encoding change info to be returned more easily.

svn path=/trunk/hubbub/; revision=4989

27 files changed, 214 insertions, 209 deletions

diff --git a/src/treebuilder/after_after_body.c b/src/treebuilder/after_after_body.c
index e9460af..372d12c 100644
--- a/src/treebuilder/after_after_body.c
+++ b/src/treebuilder/after_after_body.c
@@ -21,17 +21,17 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_after_after_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_after_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
 		if (process_characters_expect_whitespace(treebuilder,
 				token, true)) {
 			treebuilder->context.mode = IN_BODY;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -52,19 +52,19 @@ bool handle_after_after_body(hubbub_treebuilder *treebuilder,
 		} else {
 			/** \todo parse error */
 			treebuilder->context.mode = IN_BODY;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
 	case HUBBUB_TOKEN_END_TAG:
 		/** \todo parse error */
 		treebuilder->context.mode = IN_BODY;
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	case HUBBUB_TOKEN_EOF:
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/after_after_frameset.c b/src/treebuilder/after_after_frameset.c
index 11fcf5a..78abc20 100644
--- a/src/treebuilder/after_after_frameset.c
+++ b/src/treebuilder/after_after_frameset.c
@@ -21,17 +21,17 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_after_after_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_after_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
 		if (process_characters_expect_whitespace(treebuilder,
 				token, true)) {
 			treebuilder->context.mode = IN_FRAMESET;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -53,19 +53,19 @@ bool handle_after_after_frameset(hubbub_treebuilder *treebuilder,
 		} else {
 			/** \todo parse error */
 			treebuilder->context.mode = IN_FRAMESET;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
 	case HUBBUB_TOKEN_END_TAG:
 		/** \todo parse error */
 		treebuilder->context.mode = IN_FRAMESET;
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	case HUBBUB_TOKEN_EOF:
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/after_body.c b/src/treebuilder/after_body.c
index 98191c0..e2d967d 100644
--- a/src/treebuilder/after_body.c
+++ b/src/treebuilder/after_body.c
@@ -21,10 +21,10 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_after_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
@@ -59,7 +59,7 @@ bool handle_after_body(hubbub_treebuilder *treebuilder,
 			((hubbub_token *) token)->data.character.len -= c;
 
 			treebuilder->context.mode = IN_BODY;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -82,7 +82,7 @@ bool handle_after_body(hubbub_treebuilder *treebuilder,
 		} else {
 			/** \todo parse error */
 			treebuilder->context.mode = IN_BODY;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -98,7 +98,7 @@ bool handle_after_body(hubbub_treebuilder *treebuilder,
 		} else {
 			/** \todo parse error */
 			treebuilder->context.mode = IN_BODY;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -106,6 +106,6 @@ bool handle_after_body(hubbub_treebuilder *treebuilder,
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/after_frameset.c b/src/treebuilder/after_frameset.c
index b80d815..0719b07 100644
--- a/src/treebuilder/after_frameset.c
+++ b/src/treebuilder/after_frameset.c
@@ -21,10 +21,10 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_after_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
@@ -73,6 +73,6 @@ bool handle_after_frameset(hubbub_treebuilder *treebuilder,
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/after_head.c b/src/treebuilder/after_head.c
index 3148e69..144496f 100644
--- a/src/treebuilder/after_head.c
+++ b/src/treebuilder/after_head.c
@@ -21,15 +21,15 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_after_head(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_head(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
-		reprocess = process_characters_expect_whitespace(treebuilder,
+		err = process_characters_expect_whitespace(treebuilder,
 				token, true);
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -70,7 +70,7 @@ bool handle_after_head(hubbub_treebuilder *treebuilder,
 			}
 
 			/* Process as "in head" */
-			reprocess = handle_in_head(treebuilder, token);
+			err = handle_in_head(treebuilder, token);
 
 			if (!element_stack_pop(treebuilder, &ns, &otype,
 					&node)) {
@@ -82,7 +82,7 @@ bool handle_after_head(hubbub_treebuilder *treebuilder,
 		} else if (type == HEAD) {
 			/** \todo parse error */
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -90,14 +90,14 @@ bool handle_after_head(hubbub_treebuilder *treebuilder,
 		/** \parse error */
 		break;
 	case HUBBUB_TOKEN_EOF:
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_tag tag;
 
-		if (reprocess) {
+		if (err == HUBBUB_REPROCESS) {
 			/* Manufacture body */
 			tag.ns = HUBBUB_NS_HTML;
 			tag.name.ptr = (const uint8_t *) "body";
@@ -114,6 +114,6 @@ bool handle_after_head(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = IN_BODY;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/before_head.c b/src/treebuilder/before_head.c
index eb9c917..a2f4386 100644
--- a/src/treebuilder/before_head.c
+++ b/src/treebuilder/before_head.c
@@ -21,15 +21,15 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_before_head(hubbub_treebuilder *treebuilder, 
+hubbub_error handle_before_head(hubbub_treebuilder *treebuilder, 
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
-		reprocess = process_characters_expect_whitespace(treebuilder,
+		err = process_characters_expect_whitespace(treebuilder,
 				token, false);
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -51,7 +51,7 @@ bool handle_before_head(hubbub_treebuilder *treebuilder,
 		} else if (type == HEAD) {
 			handled = true;
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -61,21 +61,21 @@ bool handle_before_head(hubbub_treebuilder *treebuilder,
 				&token->data.tag.name);
 
 		if (type == HEAD || type == BR) {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else {
 			/** \todo parse error */
 		}
 	}
 		break;
 	case HUBBUB_TOKEN_EOF:
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_tag tag;
 
-		if (reprocess) {
+		if (err == HUBBUB_REPROCESS) {
 			/* Manufacture head tag */
 			tag.ns = HUBBUB_NS_HTML;
 			tag.name.ptr = (const uint8_t *) "head";
@@ -101,6 +101,6 @@ bool handle_before_head(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = IN_HEAD;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/before_html.c b/src/treebuilder/before_html.c
index 70eebde..7aaf3ae 100644
--- a/src/treebuilder/before_html.c
+++ b/src/treebuilder/before_html.c
@@ -21,10 +21,10 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_before_html(hubbub_treebuilder *treebuilder, 
+hubbub_error handle_before_html(hubbub_treebuilder *treebuilder, 
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
@@ -36,7 +36,7 @@ bool handle_before_html(hubbub_treebuilder *treebuilder,
 				treebuilder->context.document);
 		break;
 	case HUBBUB_TOKEN_CHARACTER:
-		reprocess = process_characters_expect_whitespace(treebuilder,
+		err = process_characters_expect_whitespace(treebuilder,
 				token, false);
 		break;
 	case HUBBUB_TOKEN_START_TAG:
@@ -47,18 +47,18 @@ bool handle_before_html(hubbub_treebuilder *treebuilder,
 		if (type == HTML) {
 			handled = true;
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
 	case HUBBUB_TOKEN_END_TAG:
 	case HUBBUB_TOKEN_EOF:
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		int success;
 		void *html, *appended;
 
@@ -67,7 +67,7 @@ bool handle_before_html(hubbub_treebuilder *treebuilder,
 		 * no current_node to insert into at this point so
 		 * we get to do it manually. */
 
-		if (reprocess) {
+		if (err == HUBBUB_REPROCESS) {
 			/* Need to manufacture html element */
 			hubbub_tag tag;
 
@@ -121,6 +121,6 @@ bool handle_before_html(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = BEFORE_HEAD;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/generic_rcdata.c b/src/treebuilder/generic_rcdata.c
index e15cf97..65dc0e5 100644
--- a/src/treebuilder/generic_rcdata.c
+++ b/src/treebuilder/generic_rcdata.c
@@ -21,10 +21,10 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_generic_rcdata(hubbub_treebuilder *treebuilder,
+hubbub_error handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool done = false;
 
 	if (treebuilder->context.strip_leading_lr &&
@@ -65,7 +65,8 @@ bool handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 		break;
 	case HUBBUB_TOKEN_EOF:
 		/** \todo parse error */
-		done = reprocess = true;
+		done = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	case HUBBUB_TOKEN_COMMENT:
 	case HUBBUB_TOKEN_DOCTYPE:
@@ -117,6 +118,6 @@ bool handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = treebuilder->context.collect.mode;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_body.c b/src/treebuilder/in_body.c
index c0bb019..556862b 100644
--- a/src/treebuilder/in_body.c
+++ b/src/treebuilder/in_body.c
@@ -109,10 +109,10 @@ static void aa_clone_and_replace_entries(hubbub_treebuilder *treebuilder,
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 #if !defined(NDEBUG) && defined(DEBUG_IN_BODY)
 	fprintf(stdout, "Processing token %d\n", token->type);
@@ -139,10 +139,10 @@ bool handle_in_body(hubbub_treebuilder *treebuilder,
 		/** \todo parse error */
 		break;
 	case HUBBUB_TOKEN_START_TAG:
-		reprocess = process_start_tag(treebuilder, token);
+		err = process_start_tag(treebuilder, token);
 		break;
 	case HUBBUB_TOKEN_END_TAG:
-		reprocess = process_end_tag(treebuilder, token);
+		err = process_end_tag(treebuilder, token);
 		break;
 	case HUBBUB_TOKEN_EOF:
 		for (uint32_t i = treebuilder->context.current_node; 
@@ -168,7 +168,7 @@ bool handle_in_body(hubbub_treebuilder *treebuilder,
 	formatting_list_dump(treebuilder, stdout);
 #endif
 
-	return reprocess;
+	return err;
 }
 
 /**
@@ -210,7 +210,7 @@ void process_character(hubbub_treebuilder *treebuilder,
 bool process_start_tag(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	element_type type = element_type_from_name(treebuilder,
 			&token->data.tag.name);
 
@@ -339,7 +339,7 @@ bool process_start_tag(hubbub_treebuilder *treebuilder,
 		process_phrasing_in_body(treebuilder, token);
 	}
 
-	return reprocess;
+	return err;
 }
 
 /**
@@ -352,7 +352,7 @@ bool process_start_tag(hubbub_treebuilder *treebuilder,
 bool process_end_tag(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	element_type type = element_type_from_name(treebuilder,
 			&token->data.tag.name);
 
@@ -368,7 +368,7 @@ bool process_end_tag(hubbub_treebuilder *treebuilder,
 				treebuilder->context.mode == IN_BODY) {
 			treebuilder->context.mode = AFTER_BODY;
 		}
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 	} else if (type == ADDRESS || type == BLOCKQUOTE || 
 			type == CENTER || type == DIR || type == DIV ||
 			type == DL || type == FIELDSET || 
@@ -416,7 +416,7 @@ bool process_end_tag(hubbub_treebuilder *treebuilder,
 		process_0generic_in_body(treebuilder, type);
 	}
 
-	return reprocess;
+	return err;
 }
 
 /**
diff --git a/src/treebuilder/in_caption.c b/src/treebuilder/in_caption.c
index 312a6f1..6e6eb6a 100644
--- a/src/treebuilder/in_caption.c
+++ b/src/treebuilder/in_caption.c
@@ -21,10 +21,10 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_caption(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_caption(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
@@ -37,7 +37,7 @@ bool handle_in_caption(hubbub_treebuilder *treebuilder,
 				type == TBODY || type == TD || type == TFOOT ||
 				type == TH || type == THEAD || type == TR) {
 			/** \todo parse error */
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else {
 			/* Process as if "in body" */
 			handle_in_body(treebuilder, token);
@@ -53,7 +53,7 @@ bool handle_in_caption(hubbub_treebuilder *treebuilder,
 			handled = true;
 		} else if (type == TABLE) {
 			/** \todo parse error if type == TABLE */
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else if (type == BODY || type == COL || type == COLGROUP ||
 				type == HTML || type == TBODY || type == TD ||
 				type == TFOOT || type == TH ||
@@ -75,7 +75,7 @@ bool handle_in_caption(hubbub_treebuilder *treebuilder,
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_ns ns;
 		element_type otype = UNKNOWN;
 		void *node;
@@ -103,6 +103,6 @@ bool handle_in_caption(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = IN_TABLE;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_cell.c b/src/treebuilder/in_cell.c
index 18c7b41..6a6c918 100644
--- a/src/treebuilder/in_cell.c
+++ b/src/treebuilder/in_cell.c
@@ -62,9 +62,9 @@ static inline void close_cell(hubbub_treebuilder *treebuilder)
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_cell(hubbub_treebuilder *treebuilder, const hubbub_token *token)
+hubbub_error handle_in_cell(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_START_TAG:
@@ -78,9 +78,9 @@ bool handle_in_cell(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 				type == THEAD || type == TR) {
 			/** \todo fragment case */
 			close_cell(treebuilder);
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else {
-			reprocess = handle_in_body(treebuilder, token);
+			err = handle_in_body(treebuilder, token);
 		}
 	}
 		break;
@@ -123,12 +123,12 @@ bool handle_in_cell(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 				type == THEAD || type == TR) {
 			if (element_in_scope(treebuilder, type, true)) {
 				close_cell(treebuilder);
-				reprocess = true;
+				err = HUBBUB_REPROCESS;
 			} else {
 				/** \todo parse error */
 			}
 		} else {
-			reprocess = handle_in_body(treebuilder, token);
+			err = handle_in_body(treebuilder, token);
 		}
 	}
 		break;
@@ -136,10 +136,10 @@ bool handle_in_cell(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 	case HUBBUB_TOKEN_COMMENT:
 	case HUBBUB_TOKEN_DOCTYPE:
 	case HUBBUB_TOKEN_EOF:
-		reprocess = handle_in_body(treebuilder, token);
+		err = handle_in_body(treebuilder, token);
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_column_group.c b/src/treebuilder/in_column_group.c
index bcd1ebe..cd6d589 100644
--- a/src/treebuilder/in_column_group.c
+++ b/src/treebuilder/in_column_group.c
@@ -21,17 +21,17 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_column_group(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_column_group(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
 		if (process_characters_expect_whitespace(treebuilder,
 				token, true)) {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -55,7 +55,7 @@ bool handle_in_column_group(hubbub_treebuilder *treebuilder,
 
 			/** \todo ack sc flag */
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -70,17 +70,17 @@ bool handle_in_column_group(hubbub_treebuilder *treebuilder,
 		} else if (type == COL) {
 			/** \todo parse error */
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
 	case HUBBUB_TOKEN_EOF:
 		/** \todo fragment case */
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_ns ns;
 		element_type otype;
 		void *node;
@@ -97,6 +97,6 @@ bool handle_in_column_group(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = IN_TABLE;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_foreign_content.c b/src/treebuilder/in_foreign_content.c
index a5dda6b..2603b77 100644
--- a/src/treebuilder/in_foreign_content.c
+++ b/src/treebuilder/in_foreign_content.c
@@ -344,10 +344,10 @@ static void foreign_break_out(hubbub_treebuilder *treebuilder)
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_foreign_content(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_foreign_content(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
@@ -400,7 +400,7 @@ bool handle_in_foreign_content(hubbub_treebuilder *treebuilder,
 				type == TABLE || type == TT || type == U ||
 				type == UL || type == VAR) {
 			foreign_break_out(treebuilder);
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else {
 			hubbub_tag tag = token->data.tag;
 
@@ -428,9 +428,9 @@ bool handle_in_foreign_content(hubbub_treebuilder *treebuilder,
 		break;
 	case HUBBUB_TOKEN_EOF:
 		foreign_break_out(treebuilder);
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
diff --git a/src/treebuilder/in_frameset.c b/src/treebuilder/in_frameset.c
index 8e1d86d..2cae20c 100644
--- a/src/treebuilder/in_frameset.c
+++ b/src/treebuilder/in_frameset.c
@@ -21,10 +21,10 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_in_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
@@ -97,6 +97,6 @@ bool handle_in_frameset(hubbub_treebuilder *treebuilder,
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_head.c b/src/treebuilder/in_head.c
index 4867a5d..710fdce 100644
--- a/src/treebuilder/in_head.c
+++ b/src/treebuilder/in_head.c
@@ -85,15 +85,15 @@ static void process_script_in_head(hubbub_treebuilder *treebuilder,
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_in_head(hubbub_treebuilder *treebuilder, 
+hubbub_error handle_in_head(hubbub_treebuilder *treebuilder, 
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
-		reprocess = process_characters_expect_whitespace(treebuilder,
+		err = process_characters_expect_whitespace(treebuilder,
 				token, true);
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -141,7 +141,7 @@ bool handle_in_head(hubbub_treebuilder *treebuilder,
 		} else if (type == HEAD) {
 			/** \todo parse error */
 		} else {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -153,16 +153,16 @@ bool handle_in_head(hubbub_treebuilder *treebuilder,
 		if (type == HEAD) {
 			handled = true;
 		} else if (type == BR) {
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} /** \todo parse error */
 	}
 		break;
 	case HUBBUB_TOKEN_EOF:
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_ns ns;
 		element_type otype;
 		void *node;
@@ -178,5 +178,5 @@ bool handle_in_head(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = AFTER_HEAD;
 	}
 
-	return reprocess;
+	return err;
 }
diff --git a/src/treebuilder/in_head_noscript.c b/src/treebuilder/in_head_noscript.c
index c4addee..5a577b6 100644
--- a/src/treebuilder/in_head_noscript.c
+++ b/src/treebuilder/in_head_noscript.c
@@ -21,18 +21,18 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = false;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
-		reprocess = handle_in_head(treebuilder, token);
+		err = handle_in_head(treebuilder, token);
 		break;
 	case HUBBUB_TOKEN_COMMENT:
-		reprocess = handle_in_head(treebuilder, token);
+		err = handle_in_head(treebuilder, token);
 		break;
 	case HUBBUB_TOKEN_DOCTYPE:
 		/** \todo parse error */
@@ -50,12 +50,12 @@ bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 		} else if (type == LINK || type == META || type == NOFRAMES ||
 				type == STYLE) {
 			/* Process as "in head" */
-			reprocess = handle_in_head(treebuilder, token);
+			err = handle_in_head(treebuilder, token);
 		} else if (type == HEAD || type == NOSCRIPT) {
 			/** \todo parse error */
 		} else {
 			/** \todo parse error */
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 	}
 		break;
@@ -68,7 +68,7 @@ bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 			handled = true;
 		} else if (type == BR) {
 			/** \todo parse error */
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else {
 			/** \todo parse error */
 		}
@@ -76,11 +76,11 @@ bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 		break;
 	case HUBBUB_TOKEN_EOF:
 		/** \todo parse error */
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (handled || reprocess) {
+	if (handled || err == HUBBUB_REPROCESS) {
 		hubbub_ns ns;
 		element_type otype;
 		void *node;
@@ -96,6 +96,6 @@ bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 		treebuilder->context.mode = IN_HEAD;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_row.c b/src/treebuilder/in_row.c
index a980af7..b0fd897 100644
--- a/src/treebuilder/in_row.c
+++ b/src/treebuilder/in_row.c
@@ -49,7 +49,7 @@ static void table_clear_stack(hubbub_treebuilder *treebuilder)
  * \param treebuilder	The treebuilder instance
  * \return True to reprocess the token, false otherwise
  */
-static inline bool act_as_if_end_tag_tr(hubbub_treebuilder *treebuilder)
+static hubbub_error act_as_if_end_tag_tr(hubbub_treebuilder *treebuilder)
 {
 	hubbub_ns ns;
 	element_type otype;
@@ -67,7 +67,7 @@ static inline bool act_as_if_end_tag_tr(hubbub_treebuilder *treebuilder)
 
 	treebuilder->context.mode = IN_TABLE_BODY;
 
-	return true;
+	return HUBBUB_REPROCESS;
 }
 
 
@@ -78,10 +78,10 @@ static inline bool act_as_if_end_tag_tr(hubbub_treebuilder *treebuilder)
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_row(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_row(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_START_TAG:
@@ -109,9 +109,9 @@ bool handle_in_row(hubbub_treebuilder *treebuilder,
 		} else if (type == CAPTION || type == COL ||
 				type == COLGROUP || type == TBODY ||
 				type == TFOOT || type == THEAD || type == TR) {
-			reprocess = act_as_if_end_tag_tr(treebuilder);
+			err = act_as_if_end_tag_tr(treebuilder);
 		} else {
-			reprocess = handle_in_table(treebuilder, token);
+			err = handle_in_table(treebuilder, token);
 		}
 	}
 		break;
@@ -123,14 +123,14 @@ bool handle_in_row(hubbub_treebuilder *treebuilder,
 		if (type == TR) {
 			(void)act_as_if_end_tag_tr(treebuilder);
 		} else if (type == TABLE) {
-			reprocess = act_as_if_end_tag_tr(treebuilder);
+			err = act_as_if_end_tag_tr(treebuilder);
 		} else if (type == BODY || type == CAPTION || type == COL ||
 				type == COLGROUP || type == HTML ||
 				type == TD || type == TH) {
 			/** \todo parse error */
 			/* Ignore the token */
 		} else {
-			reprocess = handle_in_table(treebuilder, token);
+			err = handle_in_table(treebuilder, token);
 		}
 	}
 		break;
@@ -138,10 +138,10 @@ bool handle_in_row(hubbub_treebuilder *treebuilder,
 	case HUBBUB_TOKEN_COMMENT:
 	case HUBBUB_TOKEN_DOCTYPE:
 	case HUBBUB_TOKEN_EOF:
-		reprocess = handle_in_table(treebuilder, token);
+		err = handle_in_table(treebuilder, token);
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_select.c b/src/treebuilder/in_select.c
index 8a60b60..e8c78f8 100644
--- a/src/treebuilder/in_select.c
+++ b/src/treebuilder/in_select.c
@@ -21,10 +21,10 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_in_select(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_select(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	hubbub_ns ns;
 	element_type otype;
@@ -98,7 +98,7 @@ bool handle_in_select(hubbub_treebuilder *treebuilder,
 				/** \todo parse error */
 			}
 
-			if (type != SELECT) reprocess = true;
+			if (type != SELECT) err = HUBBUB_REPROCESS;
 		} else {
 			/** \todo parse error */
 		}
@@ -162,6 +162,6 @@ bool handle_in_select(hubbub_treebuilder *treebuilder,
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/in_select_in_table.c b/src/treebuilder/in_select_in_table.c
index dabb0ff..5ddce11 100644
--- a/src/treebuilder/in_select_in_table.c
+++ b/src/treebuilder/in_select_in_table.c
@@ -21,11 +21,11 @@
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_in_select_in_table(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_select_in_table(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
 	bool handled = false;
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	if (token->type == HUBBUB_TOKEN_END_TAG ||
 			token->type == HUBBUB_TOKEN_START_TAG) {
@@ -47,14 +47,14 @@ bool handle_in_select_in_table(hubbub_treebuilder *treebuilder,
 
 				element_stack_pop_until(treebuilder, SELECT);
 				reset_insertion_mode(treebuilder);
-				reprocess = true;
+				err = HUBBUB_REPROCESS;
 			}
 		}
 	}
 
 	if (!handled) {
-		reprocess = handle_in_select(treebuilder, token);
+		err = handle_in_select(treebuilder, token);
 	}
 
-	return reprocess;
+	return err;
 }
diff --git a/src/treebuilder/in_table.c b/src/treebuilder/in_table.c
index 68d5ec7..65a8b94 100644
--- a/src/treebuilder/in_table.c
+++ b/src/treebuilder/in_table.c
@@ -79,10 +79,10 @@ static inline bool process_input_in_table(hubbub_treebuilder *treebuilder,
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_in_table(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_table(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool handled = true;
 
 	switch (token->type) {
@@ -134,7 +134,7 @@ bool handle_in_table(hubbub_treebuilder *treebuilder,
 				tag.name.ptr = (const uint8_t *) "colgroup";
 				tag.name.len = SLEN("colgroup");
 
-				reprocess = true;
+				err = HUBBUB_REPROCESS;
 			}
 
 			clear_stack_table_context(treebuilder);
@@ -149,7 +149,7 @@ bool handle_in_table(hubbub_treebuilder *treebuilder,
 				tag.name.ptr = (const uint8_t *) "tbody";
 				tag.name.len = SLEN("tbody");
 
-				reprocess = true;
+				err = HUBBUB_REPROCESS;
 			}
 
 			clear_stack_table_context(treebuilder);
@@ -162,7 +162,7 @@ bool handle_in_table(hubbub_treebuilder *treebuilder,
 			element_stack_pop_until(treebuilder, TABLE);
 			reset_insertion_mode(treebuilder);
 
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else if (!tainted && (type == STYLE || type == SCRIPT)) {
 			handle_in_head(treebuilder, token);
 		} else if (!tainted && type == INPUT) {
@@ -206,5 +206,5 @@ bool handle_in_table(hubbub_treebuilder *treebuilder,
 	}
 
 
-	return reprocess;
+	return err;
 }
diff --git a/src/treebuilder/in_table_body.c b/src/treebuilder/in_table_body.c
index 0efab9c..24fea5c 100644
--- a/src/treebuilder/in_table_body.c
+++ b/src/treebuilder/in_table_body.c
@@ -50,7 +50,7 @@ static void table_clear_stack(hubbub_treebuilder *treebuilder)
  * \param treebuilder	The treebuilder instance
  * \return Whether to reprocess the current token
  */
-static bool table_sub_start_or_table_end(hubbub_treebuilder *treebuilder)
+static hubbub_error table_sub_start_or_table_end(hubbub_treebuilder *treebuilder)
 {
 	if (element_in_scope(treebuilder, TBODY, true) ||
 			element_in_scope(treebuilder, THEAD, true) ||
@@ -74,12 +74,12 @@ static bool table_sub_start_or_table_end(hubbub_treebuilder *treebuilder)
 
 		treebuilder->context.mode = IN_TABLE;
 
-		return true;
+		return HUBBUB_REPROCESS;
 	} else {
 		/** \todo parse error */
 	}
 
-	return false;
+	return HUBBUB_OK;
 }
 
 
@@ -90,10 +90,10 @@ static bool table_sub_start_or_table_end(hubbub_treebuilder *treebuilder)
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_in_table_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_table_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_START_TAG:
@@ -122,13 +122,13 @@ bool handle_in_table_body(hubbub_treebuilder *treebuilder,
 			insert_element(treebuilder, &tag);
 			treebuilder->context.mode = IN_ROW;
 
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		} else if (type == CAPTION || type == COL ||
 				type == COLGROUP || type == TBODY ||
 				type == TFOOT || type == THEAD) {
-			reprocess = table_sub_start_or_table_end(treebuilder);
+			err = table_sub_start_or_table_end(treebuilder);
 		} else {
-			reprocess = handle_in_table(treebuilder, token);
+			err = handle_in_table(treebuilder, token);
 		}
 	}
 		break;
@@ -159,14 +159,14 @@ bool handle_in_table_body(hubbub_treebuilder *treebuilder,
 				treebuilder->context.mode = IN_TABLE;
 			}
 		} else if (type == TABLE) {
-			reprocess = table_sub_start_or_table_end(treebuilder);
+			err = table_sub_start_or_table_end(treebuilder);
 		} else if (type == BODY || type == CAPTION || type == COL ||
 				type == COLGROUP || type == HTML ||
 				type == TD || type == TH || type == TR) {
 			/** \todo parse error */
 			/* Ignore the token */
 		} else {
-			reprocess = handle_in_table(treebuilder, token);
+			err = handle_in_table(treebuilder, token);
 		}
 	}
 		break;
@@ -174,10 +174,10 @@ bool handle_in_table_body(hubbub_treebuilder *treebuilder,
 	case HUBBUB_TOKEN_COMMENT:
 	case HUBBUB_TOKEN_DOCTYPE:
 	case HUBBUB_TOKEN_EOF:
-		reprocess = handle_in_table(treebuilder, token);
+		err = handle_in_table(treebuilder, token);
 		break;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/initial.c b/src/treebuilder/initial.c
index 639a9ca..b23f3f7 100644
--- a/src/treebuilder/initial.c
+++ b/src/treebuilder/initial.c
@@ -213,9 +213,9 @@ static bool lookup_limited_quirks(hubbub_treebuilder *treebuilder,
  * \param token        The token to handle
  * \return True to reprocess token, false otherwise
  */
-bool handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token *token)
+hubbub_error handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 
 	switch (token->type) {
 	case HUBBUB_TOKEN_CHARACTER:
@@ -227,7 +227,7 @@ bool handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 					treebuilder->tree_handler->ctx,
 					HUBBUB_QUIRKS_MODE_FULL);
 			treebuilder->context.mode = BEFORE_HTML;
-			reprocess = true;
+			err = HUBBUB_REPROCESS;
 		}
 		break;
 	case HUBBUB_TOKEN_COMMENT:
@@ -291,14 +291,14 @@ bool handle_initial(hubbub_treebuilder *treebuilder, const hubbub_token *token)
 		treebuilder->tree_handler->set_quirks_mode(
 				treebuilder->tree_handler->ctx,
 				HUBBUB_QUIRKS_MODE_FULL);
-		reprocess = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
-	if (reprocess) {
+	if (err == HUBBUB_REPROCESS) {
 		treebuilder->context.mode = BEFORE_HTML;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/internal.h b/src/treebuilder/internal.h
index c63ee99..884674e 100644
--- a/src/treebuilder/internal.h
+++ b/src/treebuilder/internal.h
@@ -118,7 +118,7 @@ struct hubbub_treebuilder
 hubbub_error hubbub_treebuilder_token_handler(
 		const hubbub_token *token, void *pw);
 
-bool process_characters_expect_whitespace(
+hubbub_error process_characters_expect_whitespace(
 		hubbub_treebuilder *treebuilder, const hubbub_token *token,
 		bool insert_into_current_node);
 void process_comment_append(hubbub_treebuilder *treebuilder,
diff --git a/src/treebuilder/modes.h b/src/treebuilder/modes.h
index 16aacd9..225ed4b 100644
--- a/src/treebuilder/modes.h
+++ b/src/treebuilder/modes.h
@@ -41,51 +41,51 @@ typedef enum
 
 
 
-bool handle_initial(hubbub_treebuilder *treebuilder,
+hubbub_error handle_initial(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_before_html(hubbub_treebuilder *treebuilder,
+hubbub_error handle_before_html(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_before_head(hubbub_treebuilder *treebuilder,
+hubbub_error handle_before_head(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_head(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_head(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_head_noscript(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_head_noscript(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_after_head(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_head(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_table(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_table(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_caption(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_caption(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_column_group(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_column_group(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_table_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_table_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_row(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_row(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_cell(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_cell(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_select(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_select(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_select_in_table(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_select_in_table(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_generic_rcdata(hubbub_treebuilder *treebuilder,
+hubbub_error handle_generic_rcdata(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_script_collect_characters(hubbub_treebuilder *treebuilder,
+hubbub_error handle_script_collect_characters(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_foreign_content(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_foreign_content(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_after_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_in_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_in_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_after_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_after_after_body(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_after_body(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
-bool handle_after_after_frameset(hubbub_treebuilder *treebuilder,
+hubbub_error handle_after_after_frameset(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token);
 
 #endif
diff --git a/src/treebuilder/script_collect.c b/src/treebuilder/script_collect.c
index e016409..eb6f67b 100644
--- a/src/treebuilder/script_collect.c
+++ b/src/treebuilder/script_collect.c
@@ -21,10 +21,10 @@
  * \param token        The token to process
  * \return True to reprocess the token, false otherwise
  */
-bool handle_script_collect_characters(hubbub_treebuilder *treebuilder,
+hubbub_error handle_script_collect_characters(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token)
 {
-	bool reprocess = false;
+	hubbub_error err = HUBBUB_OK;
 	bool done = false;
 
 	switch (token->type) {
@@ -55,7 +55,8 @@ bool handle_script_collect_characters(hubbub_treebuilder *treebuilder,
 	case HUBBUB_TOKEN_START_TAG:
 		/** \todo parse error */
 		/** \todo Mark script as "already executed" */
-		done = reprocess = true;
+		done = true;
+		err = HUBBUB_REPROCESS;
 		break;
 	}
 
@@ -143,6 +144,6 @@ bool handle_script_collect_characters(hubbub_treebuilder *treebuilder,
 				treebuilder->context.collect.mode;
 	}
 
-	return reprocess;
+	return err;
 }
 
diff --git a/src/treebuilder/treebuilder.c b/src/treebuilder/treebuilder.c
index 8bc9d52..5878bc3 100644
--- a/src/treebuilder/treebuilder.c
+++ b/src/treebuilder/treebuilder.c
@@ -255,7 +255,7 @@ hubbub_error hubbub_treebuilder_token_handler(const hubbub_token *token,
 		void *pw)
 {
 	hubbub_treebuilder *treebuilder = (hubbub_treebuilder *) pw;
-	bool reprocess = true;
+	hubbub_error err = HUBBUB_REPROCESS;
 
 	/* Do nothing if we have no document node or there's no tree handler */
 	if (treebuilder->context.document == NULL ||
@@ -274,82 +274,82 @@ hubbub_error hubbub_treebuilder_token_handler(const hubbub_token *token,
 			printf( #x "\n");
 #endif
 
-	while (reprocess) {
+	while (err == HUBBUB_REPROCESS) {
 		switch (treebuilder->context.mode) {
 		mode(INITIAL)
-			reprocess = handle_initial(treebuilder, token);
+			err = handle_initial(treebuilder, token);
 			break;
 		mode(BEFORE_HTML)
-			reprocess = handle_before_html(treebuilder, token);
+			err = handle_before_html(treebuilder, token);
 			break;
 		mode(BEFORE_HEAD)
-			reprocess = handle_before_head(treebuilder, token);
+			err = handle_before_head(treebuilder, token);
 			break;
 		mode(IN_HEAD)
-			reprocess = handle_in_head(treebuilder, token);
+			err = handle_in_head(treebuilder, token);
 			break;
 		mode(IN_HEAD_NOSCRIPT)
-			reprocess = handle_in_head_noscript(treebuilder, token);
+			err = handle_in_head_noscript(treebuilder, token);
 			break;
 		mode(AFTER_HEAD)
-			reprocess = handle_after_head(treebuilder, token);
+			err = handle_after_head(treebuilder, token);
 			break;
 		mode(IN_BODY)
-			reprocess = handle_in_body(treebuilder, token);
+			err = handle_in_body(treebuilder, token);
 			break;
 		mode(IN_TABLE)
-			reprocess = handle_in_table(treebuilder, token);
+			err = handle_in_table(treebuilder, token);
 			break;
 		mode(IN_CAPTION)
-			reprocess = handle_in_caption(treebuilder, token);
+			err = handle_in_caption(treebuilder, token);
 			break;
 		mode(IN_COLUMN_GROUP)
-			reprocess = handle_in_column_group(treebuilder, token);
+			err = handle_in_column_group(treebuilder, token);
 			break;
 		mode(IN_TABLE_BODY)
-			reprocess = handle_in_table_body(treebuilder, token);
+			err = handle_in_table_body(treebuilder, token);
 			break;
 		mode(IN_ROW)
-			reprocess = handle_in_row(treebuilder, token);
+			err = handle_in_row(treebuilder, token);
 			break;
 		mode(IN_CELL)
-			reprocess = handle_in_cell(treebuilder, token);
+			err = handle_in_cell(treebuilder, token);
 			break;
 		mode(IN_SELECT)
-			reprocess = handle_in_select(treebuilder, token);
+			err = handle_in_select(treebuilder, token);
 			break;
 		mode(IN_SELECT_IN_TABLE)
-			reprocess = handle_in_select_in_table(treebuilder, token);
+			err = handle_in_select_in_table(treebuilder, token);
 			break;
 		mode(IN_FOREIGN_CONTENT)
-			reprocess = handle_in_foreign_content(treebuilder, token);
+			err = handle_in_foreign_content(treebuilder, token);
 			break;
 		mode(AFTER_BODY)
-			reprocess = handle_after_body(treebuilder, token);
+			err = handle_after_body(treebuilder, token);
 			break;
 		mode(IN_FRAMESET)
-			reprocess = handle_in_frameset(treebuilder, token);
+			err = handle_in_frameset(treebuilder, token);
 			break;
 		mode(AFTER_FRAMESET)
-			reprocess = handle_after_frameset(treebuilder, token);
+			err = handle_after_frameset(treebuilder, token);
 			break;
 		mode(AFTER_AFTER_BODY)
-			reprocess = handle_after_after_body(treebuilder, token);
+			err = handle_after_after_body(treebuilder, token);
 			break;
 		mode(AFTER_AFTER_FRAMESET)
-			reprocess = handle_after_after_frameset(treebuilder, token);
+			err = handle_after_after_frameset(treebuilder, token);
 			break;
 		mode(GENERIC_RCDATA)
-			reprocess = handle_generic_rcdata(treebuilder, token);
+			err = handle_generic_rcdata(treebuilder, token);
 			break;
 		mode(SCRIPT_COLLECT_CHARACTERS)
-			reprocess = handle_script_collect_characters(
+			err = handle_script_collect_characters(
 					treebuilder, token);
 			break;
 		}
 	}
 
-	return HUBBUB_OK;
+	return err;
 }
 
 
@@ -364,7 +364,7 @@ hubbub_error hubbub_treebuilder_token_handler(const hubbub_token *token,
  *              (token data updated to skip any leading whitespace), 
  *         false if it contained only whitespace
  */
-bool process_characters_expect_whitespace(hubbub_treebuilder *treebuilder,
+hubbub_error process_characters_expect_whitespace(hubbub_treebuilder *treebuilder,
 		const hubbub_token *token, bool insert_into_current_node)
 {
 	const uint8_t *data = token->data.character.ptr;
@@ -394,10 +394,10 @@ bool process_characters_expect_whitespace(hubbub_treebuilder *treebuilder,
 		((hubbub_token *) token)->data.character.ptr += c;
 		((hubbub_token *) token)->data.character.len -= c;
 
-		return true;
+		return HUBBUB_REPROCESS;
 	}
 
-	return false;
+	return HUBBUB_OK;
 }
 
 /**
diff --git a/src/utils/errors.c b/src/utils/errors.c
index ada48cd..9b9dfdb 100644
--- a/src/utils/errors.c
+++ b/src/utils/errors.c
@@ -26,6 +26,9 @@ const char *hubbub_error_to_string(hubbub_error error)
 	case HUBBUB_OOD:
 		result = "Out of data";
 		break;
+	case HUBBUB_REPROCESS:
+		result = "Internal (reprocess token)";
+		break;
 	case HUBBUB_NOMEM:
 		result = "Insufficient memory";
 		break;