From 086bd1eef17d63b36a47ac954b1d90fff3d4115d Mon Sep 17 00:00:00 2001 From: Andrew Sidwell Date: Sun, 10 Aug 2008 15:49:52 +0000 Subject: 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 --- src/treebuilder/after_after_body.c | 12 +++---- src/treebuilder/after_after_frameset.c | 12 +++---- src/treebuilder/after_body.c | 12 +++---- src/treebuilder/after_frameset.c | 6 ++-- src/treebuilder/after_head.c | 18 +++++------ src/treebuilder/before_head.c | 18 +++++------ src/treebuilder/before_html.c | 16 +++++----- src/treebuilder/generic_rcdata.c | 9 +++--- src/treebuilder/in_body.c | 20 ++++++------ src/treebuilder/in_caption.c | 12 +++---- src/treebuilder/in_cell.c | 16 +++++----- src/treebuilder/in_column_group.c | 16 +++++----- src/treebuilder/in_foreign_content.c | 10 +++--- src/treebuilder/in_frameset.c | 6 ++-- src/treebuilder/in_head.c | 16 +++++----- src/treebuilder/in_head_noscript.c | 20 ++++++------ src/treebuilder/in_row.c | 20 ++++++------ src/treebuilder/in_select.c | 8 ++--- src/treebuilder/in_select_in_table.c | 10 +++--- src/treebuilder/in_table.c | 12 +++---- src/treebuilder/in_table_body.c | 24 +++++++------- src/treebuilder/initial.c | 12 +++---- src/treebuilder/internal.h | 2 +- src/treebuilder/modes.h | 46 +++++++++++++-------------- src/treebuilder/script_collect.c | 9 +++--- src/treebuilder/treebuilder.c | 58 +++++++++++++++++----------------- src/utils/errors.c | 3 ++ 27 files changed, 214 insertions(+), 209 deletions(-) (limited to 'src') 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; -- cgit v1.2.3