nokogumbo 2.0.0.pre.alpha → 2.0.0

data/gumbo-parser/src/error.h

@@ -7,6 +7,7 @@
 #include "insertion_mode.h"
 #include "string_buffer.h"
 #include "token_type.h"
+#include "tokenizer_states.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -15,85 +16,66 @@ extern "C" {
 struct GumboInternalParser;
 
 typedef enum {
+  // Defined errors.
+  // https://html.spec.whatwg.org/multipage/parsing.html#parse-errors
+  GUMBO_ERR_ABRUPT_CLOSING_OF_EMPTY_COMMENT,
+  GUMBO_ERR_ABRUPT_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_ABRUPT_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE,
+  GUMBO_ERR_CDATA_IN_HTML_CONTENT,
+  GUMBO_ERR_CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE,
+  GUMBO_ERR_CONTROL_CHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_CONTROL_CHARACTER_REFERENCE,
+  GUMBO_ERR_END_TAG_WITH_ATTRIBUTES,
+  GUMBO_ERR_DUPLICATE_ATTRIBUTE,
+  GUMBO_ERR_END_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_EOF_BEFORE_TAG_NAME,
+  GUMBO_ERR_EOF_IN_CDATA,
+  GUMBO_ERR_EOF_IN_COMMENT,
+  GUMBO_ERR_EOF_IN_DOCTYPE,
+  GUMBO_ERR_EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT,
+  GUMBO_ERR_EOF_IN_TAG,
+  GUMBO_ERR_INCORRECTLY_CLOSED_COMMENT,
+  GUMBO_ERR_INCORRECTLY_OPENED_COMMENT,
+  GUMBO_ERR_INVALID_CHARACTER_SEQUENCE_AFTER_DOCTYPE_NAME,
+  GUMBO_ERR_INVALID_FIRST_CHARACTER_OF_TAG_NAME,
+  GUMBO_ERR_MISSING_ATTRIBUTE_VALUE,
+  GUMBO_ERR_MISSING_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_END_TAG_NAME,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_PUBLIC_IDENTIFIER,
+  GUMBO_ERR_MISSING_QUOTE_BEFORE_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_PUBLIC_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_AFTER_DOCTYPE_SYSTEM_KEYWORD,
+  GUMBO_ERR_MISSING_WHITESPACE_BEFORE_DOCTYPE_NAME,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_ATTRIBUTES,
+  GUMBO_ERR_MISSING_WHITESPACE_BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
+  GUMBO_ERR_NESTED_COMMENT,
+  GUMBO_ERR_NONCHARACTER_CHARACTER_REFERENCE,
+  GUMBO_ERR_NONCHARACTER_IN_INPUT_STREAM,
+  GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS,
+  GUMBO_ERR_NULL_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_CHARACTER_REFERENCE,
+  GUMBO_ERR_SURROGATE_IN_INPUT_STREAM,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_AFTER_DOCTYPE_SYSTEM_IDENTIFIER,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
+  GUMBO_ERR_UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME,
+  GUMBO_ERR_UNEXPECTED_NULL_CHARACTER,
+  GUMBO_ERR_UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
+  GUMBO_ERR_UNEXPECTED_SOLIDUS_IN_TAG,
+  GUMBO_ERR_UNKNOWN_NAMED_CHARACTER_REFERENCE,
+
+  // Encoding errors.
   GUMBO_ERR_UTF8_INVALID,
   GUMBO_ERR_UTF8_TRUNCATED,
-  GUMBO_ERR_UTF8_NULL,
-  GUMBO_ERR_NUMERIC_CHAR_REF_NO_DIGITS,
-  GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON,
-  GUMBO_ERR_NUMERIC_CHAR_REF_INVALID,
-  GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON,
-  GUMBO_ERR_NAMED_CHAR_REF_INVALID,
-  GUMBO_ERR_TAG_STARTS_WITH_QUESTION,
-  GUMBO_ERR_TAG_EOF,
-  GUMBO_ERR_TAG_INVALID,
-  GUMBO_ERR_CLOSE_TAG_EMPTY,
-  GUMBO_ERR_CLOSE_TAG_EOF,
-  GUMBO_ERR_CLOSE_TAG_INVALID,
-  GUMBO_ERR_SCRIPT_EOF,
-  GUMBO_ERR_ATTR_NAME_EOF,
-  GUMBO_ERR_ATTR_NAME_INVALID,
-  GUMBO_ERR_ATTR_DOUBLE_QUOTE_EOF,
-  GUMBO_ERR_ATTR_SINGLE_QUOTE_EOF,
-  GUMBO_ERR_ATTR_UNQUOTED_EOF,
-  GUMBO_ERR_ATTR_UNQUOTED_RIGHT_BRACKET,
-  GUMBO_ERR_ATTR_UNQUOTED_EQUALS,
-  GUMBO_ERR_ATTR_AFTER_EOF,
-  GUMBO_ERR_ATTR_AFTER_INVALID,
-  GUMBO_ERR_DUPLICATE_ATTR,
-  GUMBO_ERR_SOLIDUS_EOF,
-  GUMBO_ERR_SOLIDUS_INVALID,
-  GUMBO_ERR_DASHES_OR_DOCTYPE,
-  GUMBO_ERR_COMMENT_EOF,
-  GUMBO_ERR_COMMENT_INVALID,
-  GUMBO_ERR_COMMENT_BANG_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_DASH_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_SPACE_AFTER_DOUBLE_DASH,
-  GUMBO_ERR_COMMENT_END_BANG_EOF,
-  GUMBO_ERR_DOCTYPE_EOF,
-  GUMBO_ERR_DOCTYPE_INVALID,
-  GUMBO_ERR_DOCTYPE_SPACE,
-  GUMBO_ERR_DOCTYPE_RIGHT_BRACKET,
-  GUMBO_ERR_DOCTYPE_SPACE_OR_RIGHT_BRACKET,
-  GUMBO_ERR_DOCTYPE_END,
+
+  // Generic parser error.
   GUMBO_ERR_PARSER,
-  GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG,
-  GUMBO_ERR_SELF_CLOSING_END_TAG,
 } GumboErrorType;
 
-// Additional data for duplicated attributes.
-typedef struct GumboInternalDuplicateAttrError {
-  // The name of the attribute. Owned by this struct.
-  const char* name;
-
-  // The (0-based) index within the attributes vector of the original
-  // occurrence.
-  unsigned int original_index;
-
-  // The (0-based) index where the new occurrence would be.
-  unsigned int new_index;
-} GumboDuplicateAttrError;
-
-// A simplified representation of the tokenizer state, designed to be more
-// useful to clients of this library than the internal representation. This
-// condenses the actual states used in the tokenizer state machine into a few
-// values that will be familiar to users of HTML.
-typedef enum {
-  GUMBO_ERR_TOKENIZER_DATA,
-  GUMBO_ERR_TOKENIZER_CHAR_REF,
-  GUMBO_ERR_TOKENIZER_RCDATA,
-  GUMBO_ERR_TOKENIZER_RAWTEXT,
-  GUMBO_ERR_TOKENIZER_PLAINTEXT,
-  GUMBO_ERR_TOKENIZER_SCRIPT,
-  GUMBO_ERR_TOKENIZER_TAG,
-  GUMBO_ERR_TOKENIZER_SELF_CLOSING_TAG,
-  GUMBO_ERR_TOKENIZER_ATTR_NAME,
-  GUMBO_ERR_TOKENIZER_ATTR_VALUE,
-  GUMBO_ERR_TOKENIZER_MARKUP_DECLARATION,
-  GUMBO_ERR_TOKENIZER_COMMENT,
-  GUMBO_ERR_TOKENIZER_DOCTYPE,
-  GUMBO_ERR_TOKENIZER_CDATA,
-} GumboTokenizerErrorState;
-
 // Additional data for tokenizer errors.
 // This records the current state and codepoint encountered - this is usually
 // enough to reconstruct what went wrong and provide a friendly error message.
@@ -102,7 +84,7 @@ typedef struct GumboInternalTokenizerError {
   int codepoint;
 
   // The state that the tokenizer was in at the time.
-  GumboTokenizerErrorState state;
+  GumboTokenizerEnum state;
 } GumboTokenizerError;
 
 // Additional data for parse errors.
@@ -125,43 +107,25 @@ typedef struct GumboInternalParserError {
 // The overall error struct representing an error in decoding/tokenizing/parsing
 // the HTML. This contains an enumerated type flag, a source position, and then
 // a union of fields containing data specific to the error.
-typedef struct GumboInternalError {
+struct GumboInternalError {
   // The type of error.
   GumboErrorType type;
 
   // The position within the source file where the error occurred.
   GumboSourcePosition position;
 
-  // A pointer to the byte within the original source file text where the error
-  // occurred (note that this is not the same as position.offset, as that gives
-  // character-based instead of byte-based offsets).
-  const char* original_text;
+  // The piece of text that caused the error.
+  GumboStringPiece original_text;
 
   // Type-specific error information.
   union {
-    // The code point we encountered, for:
-    // * GUMBO_ERR_UTF8_INVALID
-    // * GUMBO_ERR_UTF8_TRUNCATED
-    // * GUMBO_ERR_NUMERIC_CHAR_REF_WITHOUT_SEMICOLON
-    // * GUMBO_ERR_NUMERIC_CHAR_REF_INVALID
-    uint32_t codepoint;
-
     // Tokenizer errors.
     GumboTokenizerError tokenizer;
 
-    // Short textual data, for:
-    // * GUMBO_ERR_NAMED_CHAR_REF_WITHOUT_SEMICOLON
-    // * GUMBO_ERR_NAMED_CHAR_REF_INVALID
-    GumboStringPiece text;
-
-    // Duplicate attribute data, for GUMBO_ERR_DUPLICATE_ATTR.
-    GumboDuplicateAttrError duplicate_attr;
-
-    // Parser state, for GUMBO_ERR_PARSER and
-    // GUMBO_ERR_UNACKNOWLEDGE_SELF_CLOSING_TAG.
-    struct GumboInternalParserError parser;
+    // Parser errors.
+    GumboParserError parser;
   } v;
-} GumboError;
+};
 
 // Adds a new error to the parser's error list, and returns a pointer to it so
 // that clients can fill out the rest of its fields. May return NULL if we're
@@ -177,32 +141,6 @@ void gumbo_destroy_errors(struct GumboInternalParser* errors);
 // Frees the memory used for a single GumboError.
 void gumbo_error_destroy(GumboError* error);
 
-// Prints an error to a string. This fills an empty GumboStringBuffer with a
-// freshly-allocated buffer containing the error message text. The caller is
-// responsible for freeing the buffer.
-void gumbo_error_to_string (
-  const GumboError* error,
-  GumboStringBuffer* output
-);
-
-// Prints a caret diagnostic to a string. This fills an empty GumboStringBuffer
-// with a freshly-allocated buffer containing the error message text. The
-// caller is responsible for freeing the buffer.
-void gumbo_caret_diagnostic_to_string (
-  const GumboError* error,
-  const char* source_text,
-  size_t source_length,
-  GumboStringBuffer* output
-);
-
-// Like gumbo_caret_diagnostic_to_string, but prints the text to stdout instead
-// of writing to a string.
-void gumbo_print_caret_diagnostic (
-  const GumboError* error,
-  const char* source_text,
-  size_t source_length
-);
-
 #ifdef __cplusplus
 }
 #endif

data/gumbo-parser/src/gumbo.h

@@ -817,10 +817,6 @@ typedef struct GumboInternalOutput {
 
   /**
    * A list of errors that occurred during the parse.
-   * NOTE: In version 1.0 of this library, the API for errors hasn't been fully
-   * fleshed out and may change in the future. For this reason, the GumboError
-   * header isn't part of the public API. Contact us if you need errors
-   * reported so we can work out something appropriate for your use-case.
    */
   GumboVector /* GumboError */ errors;
 
@@ -866,6 +862,53 @@ const char* gumbo_status_to_string(GumboOutputStatus status);
 /** Release the memory used for the parse tree and parse errors. */
 void gumbo_destroy_output(GumboOutput* output);
 
+/** Opaque GumboError type */
+typedef struct GumboInternalError GumboError;
+
+/**
+ * Returns the position of the error.
+ */
+GumboSourcePosition gumbo_error_position(const GumboError* error);
+
+/**
+ * Returns a constant string representation of the error's code. This is owned
+ * by the library and should not be freed by the caller.
+ */
+const char* gumbo_error_code(const GumboError* error);
+
+/**
+ * Prints an error to a string. This stores a freshly-allocated buffer
+ * containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_error_to_string(const GumboError* error, char **output);
+
+/**
+ * Prints a caret diagnostic to a string. This stores a freshly-allocated
+ * buffer containing the error message text in output. The caller is responsible for
+ * freeing the buffer. The size of the error message is returned. The error
+ * message itself may not be NULL-terminated and may contain NULL bytes so the
+ * returned size must be used.
+ */
+size_t gumbo_caret_diagnostic_to_string (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length,
+  char** output
+);
+
+/**
+ * Like gumbo_caret_diagnostic_to_string, but prints the text to stdout
+ * instead of writing to a string.
+ */
+void gumbo_print_caret_diagnostic (
+  const GumboError* error,
+  const char* source_text,
+  size_t source_length
+);
+
 #ifdef __cplusplus
 }
 #endif

data/gumbo-parser/src/parser.c

@@ -31,6 +31,7 @@
 #include "replacement.h"
 #include "tokenizer.h"
 #include "tokenizer_states.h"
+#include "token_buffer.h"
 #include "utf8.h"
 #include "util.h"
 #include "vector.h"
@@ -42,7 +43,7 @@ typedef uint8_t TagSet[GUMBO_TAG_LAST + 1];
 
 #define GUMBO_EMPTY_SOURCE_POSITION_INIT { .line = 0, .column = 0, .offset = 0 }
 #define kGumboEmptySourcePosition (const GumboSourcePosition) \
-	GUMBO_EMPTY_SOURCE_POSITION_INIT
+  GUMBO_EMPTY_SOURCE_POSITION_INIT
 
 const GumboOptions kGumboDefaultOptions = {
   .tab_stop = 8,
@@ -59,25 +60,6 @@ const GumboOptions kGumboDefaultOptions = {
 #define STRING(s) {.data = s, .length = sizeof(s) - 1}
 #define TERMINATOR {.data = NULL, .length = 0}
 
-static const GumboStringPiece kPublicIdHtml4_0 =
-  STRING("-//W3C//DTD HTML 4.0//EN");
-static const GumboStringPiece kPublicIdHtml4_01 =
-  STRING("-//W3C//DTD HTML 4.01//EN");
-static const GumboStringPiece kPublicIdXhtml1_0 =
-  STRING("-//W3C//DTD XHTML 1.0 Strict//EN");
-static const GumboStringPiece kPublicIdXhtml1_1 =
-  STRING("-//W3C//DTD XHTML 1.1//EN");
-static const GumboStringPiece kSystemIdRecHtml4_0 =
-  STRING("http://www.w3.org/TR/REC-html40/strict.dtd");
-static const GumboStringPiece kSystemIdHtml4 =
-  STRING("http://www.w3.org/TR/html4/strict.dtd");
-static const GumboStringPiece kSystemIdXhtmlStrict1_1 =
-  STRING("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd");
-static const GumboStringPiece kSystemIdXhtml1_1 =
-  STRING("http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd");
-static const GumboStringPiece kSystemIdLegacyCompat =
-  STRING("about:legacy-compat");
-
 // The doctype arrays have an explicit terminator because we want to pass them
 // to a helper function, and passing them as a pointer discards sizeof
 // information. The SVG arrays are used only by one-off functions, and so loops
@@ -260,6 +242,9 @@ typedef struct GumboInternalParserState {
   // The accumulated text node buffer state.
   TextNodeBufferState _text_node;
 
+  // The accumulated character tokens in tables for error purposes.
+  GumboCharacterTokenBuffer _table_character_tokens;
+
   // The current token.
   GumboToken* _current_token;
 
@@ -365,6 +350,7 @@ static void parser_state_init(GumboParser* parser) {
   parser_state->_foster_parent_insertions = false;
   parser_state->_text_node._type = GUMBO_NODE_WHITESPACE;
   gumbo_string_buffer_init(&parser_state->_text_node._buffer);
+  gumbo_character_token_buffer_init(&parser_state->_table_character_tokens);
   gumbo_vector_init(10, &parser_state->_open_elements);
   gumbo_vector_init(5, &parser_state->_active_formatting_elements);
   gumbo_vector_init(5, &parser_state->_template_insertion_modes);
@@ -463,6 +449,7 @@ static void parser_state_destroy(GumboParser* parser) {
   gumbo_vector_destroy(&state->_open_elements);
   gumbo_vector_destroy(&state->_template_insertion_modes);
   gumbo_string_buffer_destroy(&state->_text_node._buffer);
+  gumbo_character_token_buffer_destroy(&state->_table_character_tokens);
   gumbo_free(state);
 }
 
@@ -573,11 +560,11 @@ static bool tag_in (
 static bool tag_is(const GumboToken* token, bool is_start, GumboTag tag) {
   if (is_start && token->type == GUMBO_TOKEN_START_TAG) {
     return token->v.start_tag.tag == tag;
-  } else if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
+  }
+  if (!is_start && token->type == GUMBO_TOKEN_END_TAG) {
     return token->v.end_tag.tag == tag;
-  } else {
-    return false;
   }
+  return false;
 }
 
 static inline bool tagset_includes (
@@ -738,18 +725,18 @@ static void reset_insertion_mode_appropriately(GumboParser* parser) {
   assert(0);
 }
 
-static GumboError* parser_add_parse_error (
+static void parser_add_parse_error (
   GumboParser* parser,
   const GumboToken* token
 ) {
   gumbo_debug("Adding parse error.\n");
   GumboError* error = gumbo_add_error(parser);
   if (!error) {
-    return NULL;
+    return;
   }
   error->type = GUMBO_ERR_PARSER;
   error->position = token->position;
-  error->original_text = token->original_text.data;
+  error->original_text = token->original_text;
   GumboParserError* extra_data = &error->v.parser;
   extra_data->input_type = token->type;
   extra_data->input_tag = GUMBO_TAG_UNKNOWN;
@@ -772,7 +759,6 @@ static GumboError* parser_add_parse_error (
       &extra_data->tag_stack
     );
   }
-  return error;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#mathml-text-integration-point
@@ -1639,9 +1625,11 @@ static bool has_node_in_scope(const GumboParser* parser, const GumboNode* node)
     const GumboNodeType type = current->type;
     if (current == node) {
       return true;
-    } else if (type != GUMBO_NODE_ELEMENT && type != GUMBO_NODE_TEMPLATE) {
+    }
+    if (type != GUMBO_NODE_ELEMENT && type != GUMBO_NODE_TEMPLATE) {
       continue;
-    } else if (node_tag_in_set(current, &tags)) {
+    }
+    if (node_tag_in_set(current, &tags)) {
       return false;
     }
   }
@@ -1689,8 +1677,8 @@ static bool has_an_element_in_select_scope(const GumboParser* parser, GumboTag t
 // Pass GUMBO_TAG_LAST to not exclude any of them.
 static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
   static const TagSet tags = {
-    TAG(DD), TAG(DT), TAG(LI), TAG(OPTION), TAG(OPTGROUP),
-    TAG(P), TAG(RP), TAG(RB), TAG(RT), TAG(RTC)
+    TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP), TAG(OPTION),
+    TAG(P), TAG(RB), TAG(RP), TAG(RT), TAG(RTC)
   };
   while (
     node_tag_in_set(get_current_node(parser), &tags)
@@ -1704,15 +1692,36 @@ static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
 // https://html.spec.whatwg.org/multipage/parsing.html#closing-elements-that-have-implied-end-tags
 static void generate_all_implied_end_tags_thoroughly(GumboParser* parser) {
   static const TagSet tags = {
-    TAG(CAPTION), TAG(COLGROUP), TAG(DD), TAG(DT), TAG(LI), TAG(OPTION),
-    TAG(OPTGROUP), TAG(P), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY),
-    TAG(TD), TAG(TFOOT), TAG(TH), TAG(HEAD), TAG(TR)
+    TAG(CAPTION), TAG(COLGROUP), TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP),
+    TAG(OPTION), TAG(P), TAG(RB), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY),
+    TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
   };
   while (node_tag_in_set(get_current_node(parser), &tags)) {
     pop_current_node(parser);
   }
 }
 
+// This factors out the clauses in the "in body" insertion mode checking "if
+// there is a node in the stack of open elements that is not" one of a list of
+// elements in which case it's a parse error.
+// This is used in "an end-of-file token", "an end tag whose tag name is
+// 'body'", and "an end tag whose tag name is 'html'".
+static bool stack_contains_nonclosable_element (
+  GumboParser* parser
+) {
+  static const TagSet tags = {
+    TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP), TAG(OPTION), TAG(P), TAG(RB),
+    TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH),
+    TAG(THEAD), TAG(TR), TAG(BODY), TAG(HTML),
+  };
+  GumboVector* open_elements = &parser->_parser_state->_open_elements;
+  for (size_t i = 0; i < open_elements->length; ++i) {
+    if (!node_tag_in_set(open_elements->data[i], &tags))
+      return true;
+  }
+  return false;
+}
+
 // This factors out the clauses relating to "act as if an end tag token with tag
 // name "table" had been seen. Returns true if there's a table element in table
 // scope which was successfully closed, false if not and the token should be
@@ -1756,13 +1765,15 @@ static bool close_table_cell (
 // https://html.spec.whatwg.org/multipage/parsing.html#close-the-cell
 // This holds the logic to determine whether we should close a <td> or a <th>.
 static bool close_current_cell(GumboParser* parser, const GumboToken* token) {
+  GumboTag cell_tag;
   if (has_an_element_in_table_scope(parser, GUMBO_TAG_TD)) {
     assert(!has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
-    return close_table_cell(parser, token, GUMBO_TAG_TD);
+    cell_tag = GUMBO_TAG_TD;
   } else {
     assert(has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
-    return close_table_cell(parser, token, GUMBO_TAG_TH);
+    cell_tag = GUMBO_TAG_TH;
   }
+  return close_table_cell(parser, token, cell_tag);
 }
 
 // This factors out the "act as if an end tag of tag name 'select' had been
@@ -1862,13 +1873,13 @@ static bool maybe_implicitly_close_p_tag (
 
 // Convenience function to encapsulate the logic for closing <li> or <dd>/<dt>
 // tags. Pass true to is_li for handling <li> tags, false for <dd> and <dt>.
-static void maybe_implicitly_close_list_tag (
+static bool maybe_implicitly_close_list_tag (
   GumboParser* parser,
   GumboToken* token,
   bool is_li
 ) {
   GumboParserState* state = parser->_parser_state;
-  state->_frameset_ok = false;
+  set_frameset_not_ok(parser);
   for (int i = state->_open_elements.length; --i >= 0;) {
     const GumboNode* node = state->_open_elements.data[i];
     bool is_list_tag = is_li
@@ -1876,21 +1887,21 @@ static void maybe_implicitly_close_list_tag (
       : node_tag_in_set(node, &dd_dt_tags)
     ;
     if (is_list_tag) {
-      implicitly_close_tags (
+      return implicitly_close_tags (
         parser,
         token,
         node->v.element.tag_namespace,
         node->v.element.tag
       );
-      return;
     }
     if (
       is_special_node(node)
       && !node_tag_in_set(node, &(const TagSet){TAG(ADDRESS), TAG(DIV), TAG(P)})
     ) {
-      return;
+      return true;
     }
   }
+  return true;
 }
 
 static void merge_attributes (
@@ -2009,36 +2020,17 @@ static void adjust_mathml_attributes(GumboToken* token) {
   attr->name = gumbo_strdup("definitionURL");
 }
 
-static bool doctype_matches (
-  const GumboTokenDocType* doctype,
-  const GumboStringPiece* public_id,
-  const GumboStringPiece* system_id,
-  bool allow_missing_system_id
-) {
-  return
-    !strcmp(doctype->public_identifier, public_id->data)
-    && (allow_missing_system_id || doctype->has_system_identifier)
-    && !strcmp(doctype->system_identifier, system_id->data);
-}
-
 static bool maybe_add_doctype_error (
   GumboParser* parser,
   const GumboToken* token
 ) {
   const GumboTokenDocType* doctype = &token->v.doc_type;
-  bool html_doctype = !strcmp(doctype->name, "html");
-  if ((!html_doctype || doctype->has_public_identifier ||
-          (doctype->has_system_identifier &&
-              !strcmp(
-                  doctype->system_identifier, kSystemIdLegacyCompat.data))) &&
-      !(html_doctype && (doctype_matches(doctype, &kPublicIdHtml4_0,
-                             &kSystemIdRecHtml4_0, true) ||
-                            doctype_matches(doctype, &kPublicIdHtml4_01,
-                                &kSystemIdHtml4, true) ||
-                            doctype_matches(doctype, &kPublicIdXhtml1_0,
-                                &kSystemIdXhtmlStrict1_1, false) ||
-                            doctype_matches(doctype, &kPublicIdXhtml1_1,
-                                &kSystemIdXhtml1_1, false)))) {
+  if (
+    strcmp(doctype->name, "html")
+    || doctype->has_public_identifier
+    || (doctype->has_system_identifier
+        && strcmp(doctype->system_identifier, "about:legacy-compat"))
+  ) {
     parser_add_parse_error(parser, token);
     return false;
   }
@@ -2069,6 +2061,8 @@ static void remove_from_parent(GumboNode* node) {
 
 // https://html.spec.whatwg.org/multipage/parsing.html#an-introduction-to-error-handling-and-strange-cases-in-the-parser
 // Also described in the "in body" handling for end formatting tags.
+// Returns true if the algorithm handled the token and false to indicate that
+// it should be handled according to "any other end tag."
 static bool adoption_agency_algorithm (
   GumboParser* parser,
   GumboToken* token,
@@ -2076,7 +2070,7 @@ static bool adoption_agency_algorithm (
 ) {
   GumboParserState* state = parser->_parser_state;
   gumbo_debug("Entering adoption agency algorithm.\n");
-  // Step 1.
+  // Step 2.
   GumboNode* current_node = get_current_node(parser);
   if (
     current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML
@@ -2087,18 +2081,19 @@ static bool adoption_agency_algorithm (
     )
   ) {
     pop_current_node(parser);
-    return false;
+    return true;
   }
-  // Steps 2-4 & 20:
+  // Steps 3-5 & 21:
   for (unsigned int i = 0; i < 8; ++i) {
-    // Step 5.
+    // Step 6.
     GumboNode* formatting_node = NULL;
     int formatting_node_in_open_elements = -1;
     for (int j = state->_active_formatting_elements.length; --j >= 0;) {
       GumboNode* current_node = state->_active_formatting_elements.data[j];
       if (current_node == &kActiveFormattingScopeMarker) {
         gumbo_debug("Broke on scope marker; aborting.\n");
-        // Last scope marker; abort the algorithm.
+        // Last scope marker; abort the algorithm and handle according to "any
+        // other end tag."
         return false;
       }
       if (node_html_tag_is(current_node, subject)) {
@@ -2124,7 +2119,7 @@ static bool adoption_agency_algorithm (
       return false;
     }
 
-    // Step 6
+    // Step 7
     if (formatting_node_in_open_elements == -1) {
       gumbo_debug("Formatting node not on stack of open elements.\n");
       parser_add_parse_error(parser, token);
@@ -2132,17 +2127,17 @@ static bool adoption_agency_algorithm (
         formatting_node,
         &state->_active_formatting_elements
       );
-      return false;
+      return true;
     }
 
-    // Step 7
+    // Step 8
     if (!has_an_element_in_scope(parser, formatting_node->v.element.tag)) {
       parser_add_parse_error(parser, token);
       gumbo_debug("Element not in scope.\n");
-      return false;
+      return true;
     }
 
-    // Step 8
+    // Step 9
     if (formatting_node != get_current_node(parser)) {
       parser_add_parse_error(parser, token);  // But continue onwards.
     }
@@ -2150,7 +2145,7 @@ static bool adoption_agency_algorithm (
     assert(!node_html_tag_is(formatting_node, GUMBO_TAG_HTML));
     assert(!node_html_tag_is(formatting_node, GUMBO_TAG_BODY));
 
-    // Step 9 & 10
+    // Step 10
     GumboNode* furthest_block = NULL;
     for (
       unsigned int j = formatting_node_in_open_elements;
@@ -2160,32 +2155,27 @@ static bool adoption_agency_algorithm (
       assert(j > 0);
       GumboNode* current = state->_open_elements.data[j];
       if (is_special_node(current)) {
-        // Step 9.
         furthest_block = current;
         break;
       }
     }
+    // Step 11.
     if (!furthest_block) {
-      // Step 10.
-      while (get_current_node(parser) != formatting_node) {
-        pop_current_node(parser);
-      }
-      // And the formatting element itself.
-      pop_current_node(parser);
+      while (pop_current_node(parser) != formatting_node)
+        ;
       gumbo_vector_remove (
         formatting_node,
         &state->_active_formatting_elements
       );
-      return false;
+      return true;
     }
     assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
-    assert(furthest_block);
 
-    // Step 11.
+    // Step 12.
     // Elements may be moved and reparented by this algorithm, so
     // common_ancestor is not necessarily the same as formatting_node->parent.
     GumboNode* common_ancestor = state->_open_elements.data [
-      gumbo_vector_index_of(&state->_open_elements, formatting_node) - 1
+      formatting_node_in_open_elements - 1
     ];
     gumbo_debug (
       "Common ancestor tag = %s, furthest block tag = %s.\n",
@@ -2193,24 +2183,24 @@ static bool adoption_agency_algorithm (
       gumbo_normalized_tagname(furthest_block->v.element.tag)
     );
 
-    // Step 12.
+    // Step 13.
     int bookmark = 1 + gumbo_vector_index_of (
       &state->_active_formatting_elements,
       formatting_node
     );
     gumbo_debug("Bookmark at %d.\n", bookmark);
-    // Step 13.
+    // Step 14.
     GumboNode* node = furthest_block;
     GumboNode* last_node = furthest_block;
     // Must be stored explicitly, in case node is removed from the stack of open
-    // elements, to handle step 9.4.
+    // elements, to handle step 14.3.
     int saved_node_index = gumbo_vector_index_of(&state->_open_elements, node);
     assert(saved_node_index > 0);
-    // Step 13.1.
+    // Step 14.1.
     for (int j = 0;;) {
-      // Step 13.2.
+      // Step 14.2.
       ++j;
-      // Step 13.3.
+      // Step 14.3.
       int node_index = gumbo_vector_index_of(&state->_open_elements, node);
       gumbo_debug (
         "Current index: %d, last index: %d.\n",
@@ -2225,16 +2215,16 @@ static bool adoption_agency_algorithm (
       assert((unsigned int) node_index < state->_open_elements.capacity);
       node = state->_open_elements.data[node_index];
       assert(node->parent);
+      // Step 14.4.
       if (node == formatting_node) {
-        // Step 13.4.
         break;
       }
       int formatting_index = gumbo_vector_index_of (
         &state->_active_formatting_elements,
         node
       );
+      // Step 14.5.
       if (j > 3 && formatting_index != -1) {
-        // Step 13.5.
         gumbo_debug("Removing formatting element at %d.\n", formatting_index);
         gumbo_vector_remove_at (
           formatting_index,
@@ -2249,11 +2239,11 @@ static bool adoption_agency_algorithm (
         continue;
       }
       if (formatting_index == -1) {
-        // Step 13.6.
+        // Step 14.6.
         gumbo_vector_remove_at(node_index, &state->_open_elements);
         continue;
       }
-      // Step 13.7.
+      // Step 14.7.
       // "common ancestor as the intended parent" doesn't actually mean insert
       // it into the common ancestor; that happens below.
       node = clone_node(node, GUMBO_INSERTION_ADOPTION_AGENCY_CLONED);
@@ -2261,21 +2251,21 @@ static bool adoption_agency_algorithm (
       state->_active_formatting_elements.data[formatting_index] = node;
       assert(node_index >= 0);
       state->_open_elements.data[node_index] = node;
-      // Step 13.8.
+      // Step 14.8.
       if (last_node == furthest_block) {
         bookmark = formatting_index + 1;
         gumbo_debug("Bookmark moved to %d.\n", bookmark);
         assert((unsigned int) bookmark <= state->_active_formatting_elements.length);
       }
-      // Step 13.9.
+      // Step 14.9.
       last_node->parse_flags |= GUMBO_INSERTION_ADOPTION_AGENCY_MOVED;
       remove_from_parent(last_node);
       append_node(node, last_node);
-      // Step 13.10.
+      // Step 14.10.
       last_node = node;
-    }  // Step 13.11.
+    }  // Step 14.11.
 
-    // Step 14.
+    // Step 15.
     gumbo_debug (
       "Removing %s node from parent ",
       gumbo_normalized_tagname(last_node->v.element.tag)
@@ -2292,14 +2282,14 @@ static bool adoption_agency_algorithm (
     );
     insert_node(last_node, location);
 
-    // Step 15.
+    // Step 16.
     GumboNode* new_formatting_node = clone_node (
       formatting_node,
       GUMBO_INSERTION_ADOPTION_AGENCY_CLONED
     );
     formatting_node->parse_flags |= GUMBO_INSERTION_IMPLICIT_END_TAG;
 
-    // Step 16. Instead of appending nodes one-by-one, we swap the children
+    // Step 17. Instead of appending nodes one-by-one, we swap the children
     // vector of furthest_block with the empty children of new_formatting_node,
     // reducing memory traffic and allocations. We still have to reset their
     // parent pointers, though.
@@ -2313,10 +2303,10 @@ static bool adoption_agency_algorithm (
       child->parent = new_formatting_node;
     }
 
-    // Step 17.
+    // Step 18.
     append_node(furthest_block, new_formatting_node);
 
-    // Step 18.
+    // Step 19.
     // If the formatting node was before the bookmark, it may shift over all
     // indices after it, so we need to explicitly find the index and possibly
     // adjust the bookmark.
@@ -2344,7 +2334,7 @@ static bool adoption_agency_algorithm (
       &state->_active_formatting_elements
     );
 
-    // Step 19.
+    // Step 20.
     gumbo_vector_remove(formatting_node, &state->_open_elements);
     int insert_at = 1 + gumbo_vector_index_of (
       &state->_open_elements,
@@ -2357,7 +2347,7 @@ static bool adoption_agency_algorithm (
       insert_at,
       &state->_open_elements
     );
-  }  // Step 20.
+  }  // Step 21.
   return true;
 }
 
@@ -2406,10 +2396,12 @@ static bool handle_initial(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
     return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     document->has_doctype = true;
     document->name = token->v.doc_type.name;
     document->public_identifier = token->v.doc_type.public_identifier;
@@ -2431,95 +2423,108 @@ static bool handle_before_html(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+  }
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     GumboNode* html_node = insert_element_from_token(parser, token);
     parser->_output->root = html_node;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_END_TAG
     && !tag_in(token, false, &(const TagSet){TAG(HEAD), TAG(BODY), TAG(HTML), TAG(BR)})
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    GumboNode* html_node = insert_element_of_tag_type (
-      parser,
-      GUMBO_TAG_HTML,
-      GUMBO_INSERTION_IMPLIED
-    );
-    assert(html_node);
-    parser->_output->root = html_node;
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
   }
+  GumboNode* html_node = insert_element_of_tag_type (
+    parser,
+    GUMBO_TAG_HTML,
+    GUMBO_INSERTION_IMPLIED
+  );
+  assert(html_node);
+  parser->_output->root = html_node;
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
+  parser->_parser_state->_reprocess_current_token = true;
+  return true;
 }
 
+// Forward declarations because of mutual dependencies.
+static bool handle_token(GumboParser* parser, GumboToken* token);
+static bool handle_in_body(GumboParser* parser, GumboToken* token);
+static bool handle_in_template(GumboParser* parser, GumboToken* token);
+
 // https://html.spec.whatwg.org/multipage/parsing.html#the-before-head-insertion-mode
 static bool handle_before_head(GumboParser* parser, GumboToken* token) {
-  if (token->type == GUMBO_TOKEN_DOCTYPE) {
-    parser_add_parse_error(parser, token);
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
+    return false;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    return handle_in_body(parser, token);
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
     GumboNode* node = insert_element_from_token(parser, token);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
     parser->_parser_state->_head_element = node;
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_END_TAG
-    && !tag_in(token, false, &(const TagSet){TAG(HEAD), TAG(BODY), TAG(HTML), TAG(BR)})
+    && !tag_in(token, kEndTag, &(const TagSet){TAG(HEAD), TAG(BODY), TAG(HTML), TAG(BR)})
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    GumboNode* node = insert_element_of_tag_type (
-      parser,
-      GUMBO_TAG_HEAD,
-      GUMBO_INSERTION_IMPLIED
-    );
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
-    parser->_parser_state->_head_element = node;
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
   }
+  GumboNode* node = insert_element_of_tag_type (
+    parser,
+    GUMBO_TAG_HEAD,
+    GUMBO_INSERTION_IMPLIED
+  );
+  parser->_parser_state->_head_element = node;
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
+  parser->_parser_state->_reprocess_current_token = true;
+  return true;
 }
 
-// Forward declarations because of mutual dependencies.
-static bool handle_token(GumboParser* parser, GumboToken* token);
-static bool handle_in_body(GumboParser* parser, GumboToken* token);
-static bool handle_in_template(GumboParser* parser, GumboToken* token);
-
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inhead
 static bool handle_in_head(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
-    append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(BASE), TAG(BASEFONT), TAG(BGSOUND), TAG(LINK)
     })
@@ -2528,7 +2533,8 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_META)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_META)) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
@@ -2537,42 +2543,50 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     // should specifically look for that string in the document and re-encode it
     // before passing to Gumbo.
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TITLE)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TITLE)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(NOFRAMES), TAG(STYLE)})
   ) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOSCRIPT)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOSCRIPT)) {
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD_NOSCRIPT);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
-    run_generic_parsing_algorithm(parser, token, GUMBO_LEX_SCRIPT);
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
+    run_generic_parsing_algorithm(parser, token, GUMBO_LEX_SCRIPT_DATA);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_HEAD)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_HEAD)) {
     GumboNode* head = pop_current_node(parser);
     UNUSED_IF_NDEBUG(head);
     assert(node_html_tag_is(head, GUMBO_TAG_HEAD));
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet){TAG(BODY), TAG(HTML), TAG(BR)})
   ) {
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     parser->_parser_state->_reprocess_current_token = true;
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)) {
     insert_element_from_token(parser, token);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
-    parser->_parser_state->_frameset_ok = false;
+    set_frameset_not_ok(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TEMPLATE);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
     if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -2590,19 +2604,18 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     pop_template_insertion_mode(parser);
     reset_insertion_mode_appropriately(parser);
     return success;
-  } else if (
+  }
+  if (
     tag_is(token, kStartTag, GUMBO_TAG_HEAD)
     || (token->type == GUMBO_TOKEN_END_TAG)
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    pop_current_node(parser);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
   }
+  pop_current_node(parser);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
+  parser->_parser_state->_reprocess_current_token = true;
   return true;
 }
 
@@ -2611,15 +2624,18 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_NOSCRIPT)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_NOSCRIPT)) {
     const GumboNode* node = pop_current_node(parser);
     assert(node_html_tag_is(node, GUMBO_TAG_NOSCRIPT));
     UNUSED_IF_NDEBUG(node);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_WHITESPACE
     || token->type == GUMBO_TOKEN_COMMENT
     || tag_in (token, kStartTag, &(const TagSet) {
@@ -2628,7 +2644,8 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
     })
   ) {
     return handle_in_head(parser, token);
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(HEAD), TAG(NOSCRIPT)})
     || (
       token->type == GUMBO_TOKEN_END_TAG
@@ -2638,15 +2655,14 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    parser_add_parse_error(parser, token);
-    const GumboNode* node = pop_current_node(parser);
-    assert(node_html_tag_is(node, GUMBO_TAG_NOSCRIPT));
-    UNUSED_IF_NDEBUG(node);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
-    parser->_parser_state->_reprocess_current_token = true;
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  const GumboNode* node = pop_current_node(parser);
+  assert(node_html_tag_is(node, GUMBO_TAG_NOSCRIPT));
+  UNUSED_IF_NDEBUG(node);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
+  parser->_parser_state->_reprocess_current_token = true;
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-head-insertion-mode
@@ -2655,25 +2671,31 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
-    append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     insert_element_from_token(parser, token);
-    state->_frameset_ok = false;
+    set_frameset_not_ok(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_FRAMESET);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(BASE), TAG(BASEFONT), TAG(BGSOUND), TAG(LINK), TAG(META),
       TAG(NOFRAMES), TAG(SCRIPT), TAG(STYLE), TAG(TEMPLATE), TAG(TITLE)
@@ -2685,12 +2707,14 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
     // pending character tokens that should be attached to the root.
     maybe_flush_text_node_buffer(parser);
     gumbo_vector_add(state->_head_element, &state->_open_elements);
-    bool result = handle_in_head(parser, token);
+    handle_in_head(parser, token);
     gumbo_vector_remove(state->_head_element, &state->_open_elements);
-    return result;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
+    return false;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
     return handle_in_head(parser, token);
-  } else if (
+  }
+  if (
     tag_is(token, kStartTag, GUMBO_TAG_HEAD)
     || (
       token->type == GUMBO_TOKEN_END_TAG
@@ -2700,12 +2724,11 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    insert_element_of_tag_type(parser, GUMBO_TAG_BODY, GUMBO_INSERTION_IMPLIED);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    state->_reprocess_current_token = true;
-    return true;
   }
+  insert_element_of_tag_type(parser, GUMBO_TAG_BODY, GUMBO_INSERTION_IMPLIED);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
+  state->_reprocess_current_token = true;
+  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inbody
@@ -2716,11 +2739,13 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+  }
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_CHARACTER
     || token->type == GUMBO_TOKEN_CDATA
   ) {
@@ -2728,14 +2753,17 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     insert_text_token(parser, token);
     set_frameset_not_ok(parser);
     return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     parser_add_parse_error(parser, token);
     if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       ignore_token(parser);
@@ -2745,7 +2773,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     assert(parser->_output->root->type == GUMBO_NODE_ELEMENT);
     merge_attributes(token, parser->_output->root);
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(BASE), TAG(BASEFONT), TAG(BGSOUND), TAG(LINK),
       TAG(META), TAG(NOFRAMES), TAG(SCRIPT), TAG(STYLE), TAG(TEMPLATE),
@@ -2754,7 +2783,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
     return handle_in_head(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     parser_add_parse_error(parser, token);
     if (
       state->_open_elements.length < 2
@@ -2762,12 +2792,13 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       || has_open_element(parser, GUMBO_TAG_TEMPLATE)
     ) {
       ignore_token(parser);
-      return false;
+    } else {
+      set_frameset_not_ok(parser);
+      merge_attributes(token, state->_open_elements.data[1]);
     }
-    state->_frameset_ok = false;
-    merge_attributes(token, state->_open_elements.data[1]);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     parser_add_parse_error(parser, token);
     if (
       state->_open_elements.length < 2
@@ -2808,64 +2839,64 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_FRAMESET);
     return true;
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
-      if (
-        !node_tag_in_set(state->_open_elements.data[i], &(const TagSet) {
-          TAG(DD), TAG(DT), TAG(LI), TAG(P), TAG(TBODY), TAG(TD), TAG(TFOOT),
-          TAG(TH), TAG(THEAD), TAG(TR), TAG(BODY), TAG(HTML)
-        })
-      ) {
-        parser_add_parse_error(parser, token);
-      }
-    }
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     if (get_current_template_insertion_mode(parser) !=
         GUMBO_INSERTION_MODE_INITIAL) {
       return handle_in_template(parser, token);
     }
+    if (stack_contains_nonclosable_element(parser)) {
+      parser_add_parse_error(parser, token);
+      return false;
+    }
     return true;
-  } else if (tag_in(token, kEndTag, &(const TagSet){TAG(BODY), TAG(HTML)})) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_BODY)) {
     if (!has_an_element_in_scope(parser, GUMBO_TAG_BODY)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
     }
     bool success = true;
-    for (unsigned int i = 0; i < state->_open_elements.length; ++i) {
-      if (
-        !node_tag_in_set(state->_open_elements.data[i], &(const TagSet) {
-          TAG(DD), TAG(DT), TAG(LI), TAG(OPTGROUP), TAG(OPTION), TAG(P),
-          TAG(RB), TAG(RP), TAG(RT), TAG(RTC), TAG(TBODY), TAG(TD),
-          TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR), TAG(BODY), TAG(HTML)
-        })
-      ) {
-        parser_add_parse_error(parser, token);
-        success = false;
-        break;
-      }
+    if (stack_contains_nonclosable_element(parser)) {
+      parser_add_parse_error(parser, token);
+      success = false;
     }
+    GumboNode* body = state->_open_elements.data[1];
+    assert(node_html_tag_is(body, GUMBO_TAG_BODY));
+    record_end_of_element(state->_current_token, &body->v.element);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
-    if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
-      parser->_parser_state->_reprocess_current_token = true;
-    } else {
-      GumboNode* body = state->_open_elements.data[1];
-      assert(node_html_tag_is(body, GUMBO_TAG_BODY));
-      record_end_of_element(state->_current_token, &body->v.element);
+    return success;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
+    if (!has_an_element_in_scope(parser, GUMBO_TAG_BODY)) {
+      parser_add_parse_error(parser, token);
+      ignore_token(parser);
+      return false;
     }
+    bool success = true;
+    if (stack_contains_nonclosable_element(parser)) {
+      parser_add_parse_error(parser, token);
+      success = false;
+    }
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
+    parser->_parser_state->_reprocess_current_token = true;
     return success;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(ADDRESS), TAG(ARTICLE), TAG(ASIDE), TAG(BLOCKQUOTE), TAG(CENTER),
       TAG(DETAILS), TAG(DIALOG), TAG(DIR), TAG(DIV), TAG(DL), TAG(FIELDSET),
       TAG(FIGCAPTION), TAG(FIGURE), TAG(FOOTER), TAG(HEADER), TAG(HGROUP),
-      TAG(MENU), TAG(MAIN), TAG(NAV), TAG(OL), TAG(P), TAG(SECTION),
+      TAG(MAIN), TAG(MENU), TAG(NAV), TAG(OL), TAG(P), TAG(SECTION),
       TAG(SUMMARY), TAG(UL)
     })
   ) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     return result;
-  } else if (tag_in(token, kStartTag, &heading_tags)) {
+  }
+  if (tag_in(token, kStartTag, &heading_tags)) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     if (node_tag_in_set(get_current_node(parser), &heading_tags)) {
       parser_add_parse_error(parser, token);
@@ -2874,13 +2905,15 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     }
     insert_element_from_token(parser, token);
     return result;
-  } else if (tag_in(token, kStartTag, &(const TagSet){TAG(PRE), TAG(LISTING)})) {
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(PRE), TAG(LISTING)})) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     state->_ignore_next_linefeed = true;
-    state->_frameset_ok = false;
+    set_frameset_not_ok(parser);
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
     if (
       state->_form_element != NULL
       && !has_open_element(parser, GUMBO_TAG_TEMPLATE)
@@ -2896,38 +2929,42 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       state->_form_element = form_element;
     }
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
-    maybe_implicitly_close_list_tag(parser, token, true);
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
+    bool result = maybe_implicitly_close_list_tag(parser, token, true);
+    result = maybe_implicitly_close_p_tag(parser, token) && result;
     insert_element_from_token(parser, token);
     return result;
-  } else if (tag_in(token, kStartTag, &dd_dt_tags)) {
-    maybe_implicitly_close_list_tag(parser, token, false);
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+  }
+  if (tag_in(token, kStartTag, &dd_dt_tags)) {
+    bool result = maybe_implicitly_close_list_tag(parser, token, false);
+    result = maybe_implicitly_close_p_tag(parser, token) && result;
     insert_element_from_token(parser, token);
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_PLAINTEXT);
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_BUTTON)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_BUTTON)) {
+    bool success = true;
     if (has_an_element_in_scope(parser, GUMBO_TAG_BUTTON)) {
       parser_add_parse_error(parser, token);
-      implicitly_close_tags (
-        parser,
-        token,
-        GUMBO_NAMESPACE_HTML,
-        GUMBO_TAG_BUTTON
-      );
-      state->_reprocess_current_token = true;
-      return false;
+      success = false;
+      // We don't want to use implicitly_close_tags here because it may add an
+      // error and we've already added the only error the standard specifies.
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+      while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_BUTTON))
+        ;
     }
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
-    state->_frameset_ok = false;
-    return true;
-  } else if (
+    set_frameset_not_ok(parser);
+    return success;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(ADDRESS), TAG(ARTICLE), TAG(ASIDE), TAG(BLOCKQUOTE), TAG(BUTTON),
       TAG(CENTER), TAG(DETAILS), TAG(DIALOG), TAG(DIR), TAG(DIV), TAG(DL),
@@ -2942,14 +2979,14 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       ignore_token(parser);
       return false;
     }
-    implicitly_close_tags (
+    return implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       token->v.end_tag.tag
     );
-    return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_FORM)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_FORM)) {
     if (has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       if (!has_an_element_in_scope(parser, GUMBO_TAG_FORM)) {
         parser_add_parse_error(parser, token);
@@ -2960,7 +2997,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       generate_implied_end_tags(parser, GUMBO_TAG_LAST);
       if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FORM)) {
         parser_add_parse_error(parser, token);
-        return false;
+        success = false;
       }
       while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_FORM))
         ;
@@ -2992,7 +3029,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       gumbo_vector_remove_at(index, open_elements);
       return result;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
+    bool success = true;
     if (!has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
       parser_add_parse_error(parser, token);
       // reconstruct_active_formatting_elements(parser);
@@ -3001,16 +3040,16 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
         GUMBO_TAG_P,
         GUMBO_INSERTION_CONVERTED_FROM_END_TAG
       );
-      state->_reprocess_current_token = true;
-      return false;
+      success = false;
     }
     return implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_P
-    );
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_LI)) {
+    ) && success;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_LI)) {
     if (!has_an_element_in_list_scope(parser, GUMBO_TAG_LI)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -3022,8 +3061,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_LI
     );
-  } else if (tag_in(token, kEndTag, &dd_dt_tags)) {
-    assert(token->type == GUMBO_TOKEN_END_TAG);
+  }
+  if (tag_in(token, kEndTag, &dd_dt_tags)) {
     GumboTag token_tag = token->v.end_tag.tag;
     if (!has_an_element_in_scope(parser, token_tag)) {
       parser_add_parse_error(parser, token);
@@ -3036,7 +3075,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       GUMBO_NAMESPACE_HTML,
       token_tag
     );
-  } else if (tag_in(token, kEndTag, &heading_tags)) {
+  }
+  if (tag_in(token, kEndTag, &heading_tags)) {
     if (
       !has_an_element_in_scope_with_tagname(parser, 6, (GumboTag[]) {
         GUMBO_TAG_H1, GUMBO_TAG_H2, GUMBO_TAG_H3, GUMBO_TAG_H4,
@@ -3047,30 +3087,31 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      const GumboNode* current_node = get_current_node(parser);
-      bool success = node_html_tag_is(current_node, token->v.end_tag.tag);
-      if (!success) {
-        // There're children of the heading currently open; close them below and
-        // record a parse error.
-        // TODO(jdtang): Add a way to distinguish this error case from the one
-        // above.
-        parser_add_parse_error(parser, token);
-      }
-      do {
-        current_node = pop_current_node(parser);
-      } while (!node_tag_in_set(current_node, &heading_tags));
-      return success;
     }
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    const GumboNode* current_node = get_current_node(parser);
+    bool success = node_html_tag_is(current_node, token->v.end_tag.tag);
+    if (!success) {
+      // There're children of the heading currently open; close them below and
+      // record a parse error.
+      // TODO(jdtang): Add a way to distinguish this error case from the one
+      // above.
+      parser_add_parse_error(parser, token);
+    }
+    do {
+      current_node = pop_current_node(parser);
+    } while (!node_tag_in_set(current_node, &heading_tags));
+    return success;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
     bool success = true;
     int last_a;
     int has_matching_a = find_last_anchor_index(parser, &last_a);
     if (has_matching_a) {
       assert(has_matching_a == 1);
       parser_add_parse_error(parser, token);
-      adoption_agency_algorithm(parser, token, GUMBO_TAG_A);
+      bool handled = adoption_agency_algorithm(parser, token, GUMBO_TAG_A);
+      assert(handled);
       // The adoption agency algorithm usually removes all instances of <a>
       // from the list of active formatting elements, but in case it doesn't,
       // we're supposed to do this. (The conditions where it might not are
@@ -3087,7 +3128,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     add_formatting_element(parser, insert_element_from_token(parser, token));
     return success;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(B), TAG(BIG), TAG(CODE), TAG(EM), TAG(FONT), TAG(I), TAG(S),
       TAG(SMALL), TAG(STRIKE), TAG(STRONG), TAG(TT), TAG(U)
@@ -3096,27 +3138,33 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     add_formatting_element(parser, insert_element_from_token(parser, token));
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOBR)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOBR)) {
     bool result = true;
     reconstruct_active_formatting_elements(parser);
     if (has_an_element_in_scope(parser, GUMBO_TAG_NOBR)) {
       result = false;
       parser_add_parse_error(parser, token);
-      adoption_agency_algorithm(parser, token, GUMBO_TAG_NOBR);
+      bool handled = adoption_agency_algorithm(parser, token, GUMBO_TAG_NOBR);
+      assert(handled);
       reconstruct_active_formatting_elements(parser);
     }
     insert_element_from_token(parser, token);
     add_formatting_element(parser, get_current_node(parser));
     return result;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(A), TAG(B), TAG(BIG), TAG(CODE), TAG(EM), TAG(FONT), TAG(I),
       TAG(NOBR), TAG(S), TAG(SMALL), TAG(STRIKE), TAG(STRONG), TAG(TT),
       TAG(U)
     })
   ) {
-    return adoption_agency_algorithm(parser, token, token->v.end_tag.tag);
-  } else if (
+    if (!adoption_agency_algorithm(parser, token, token->v.end_tag.tag))
+      goto any_other_end_tag;
+    return true;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})
   ) {
     reconstruct_active_formatting_elements(parser);
@@ -3124,19 +3172,21 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     set_frameset_not_ok(parser);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})
   ) {
     GumboTag token_tag = token->v.end_tag.tag;
-    if (!has_an_element_in_table_scope(parser, token_tag)) {
+    if (!has_an_element_in_scope(parser, token_tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
     }
-    implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
+    bool success = implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
     clear_active_formatting_elements(parser);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
+    return success;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
     if (
       get_document_node(parser)->v.document.doc_type_quirks_mode
         != GUMBO_DOCTYPE_QUIRKS
@@ -3147,74 +3197,88 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     set_frameset_not_ok(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     return true;
-  } else if (
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_BR)) {
+    parser_add_parse_error(parser, token);
+    reconstruct_active_formatting_elements(parser);
+    insert_element_of_tag_type (
+      parser,
+      GUMBO_TAG_BR,
+      GUMBO_INSERTION_CONVERTED_FROM_END_TAG
+    );
+    pop_current_node(parser);
+    acknowledge_self_closing_tag(parser);
+    set_frameset_not_ok(parser);
+    return false;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(AREA), TAG(BR), TAG(EMBED), TAG(IMG), TAG(IMAGE), TAG(KEYGEN),
       TAG(WBR)
     })
   ) {
-    bool success = true;
-    if (tag_is(token, kStartTag, GUMBO_TAG_IMAGE)) {
-      success = false;
+    bool is_image = tag_is(token, kStartTag, GUMBO_TAG_IMAGE);
+    if (is_image) {
       parser_add_parse_error(parser, token);
       token->v.start_tag.tag = GUMBO_TAG_IMG;
     }
     reconstruct_active_formatting_elements(parser);
     GumboNode* node = insert_element_from_token(parser, token);
-    if (tag_is(token, kStartTag, GUMBO_TAG_IMAGE)) {
-      success = false;
-      parser_add_parse_error(parser, token);
-      node->v.element.tag = GUMBO_TAG_IMG;
+    if (is_image)
       node->parse_flags |= GUMBO_INSERTION_FROM_IMAGE;
-    }
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     set_frameset_not_ok(parser);
-    return success;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_INPUT)) {
-    if (!attribute_matches(&token->v.start_tag.attributes, "type", "hidden")) {
-      // Must be before the element is inserted, as that takes ownership of the
-      // token's attribute vector.
-      set_frameset_not_ok(parser);
-    }
+    return !is_image;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_INPUT)) {
     reconstruct_active_formatting_elements(parser);
-    insert_element_from_token(parser, token);
+    GumboNode *input = insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
+    if (!attribute_matches(&input->v.element.attributes, "type", "hidden"))
+      set_frameset_not_ok(parser);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(PARAM), TAG(SOURCE), TAG(TRACK)})
   ) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     set_frameset_not_ok(parser);
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TEXTAREA)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TEXTAREA)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
     parser->_parser_state->_ignore_next_linefeed = true;
     set_frameset_not_ok(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_XMP)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_XMP)) {
     bool result = maybe_implicitly_close_p_tag(parser, token);
     reconstruct_active_formatting_elements(parser);
     set_frameset_not_ok(parser);
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
     return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_IFRAME)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_IFRAME)) {
     set_frameset_not_ok(parser);
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOEMBED)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOEMBED)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     set_frameset_not_ok(parser);
@@ -3231,8 +3295,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_SELECT);
     }
     return true;
-  } else if (
-    tag_in(token, kStartTag, &(const TagSet){TAG(OPTION), TAG(OPTGROUP)})
+  }
+  if (
+    tag_in(token, kStartTag, &(const TagSet){TAG(OPTGROUP), TAG(OPTION)})
   ) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
       pop_current_node(parser);
@@ -3240,40 +3305,34 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     return true;
-  } else if (
-    tag_in(token, kStartTag, &(const TagSet){TAG(RB), TAG(RP), TAG(RT), TAG(RTC)})
-  ) {
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(RB), TAG(RTC)})) {
     bool success = true;
-    GumboTag exception = tag_in(token, kStartTag, &(const TagSet){TAG(RT), TAG(RP)})
-      ? GUMBO_TAG_RTC
-      : GUMBO_TAG_LAST
-    ;
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
-      generate_implied_end_tags(parser, exception);
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY)) {
+        parser_add_parse_error(parser, token);
+        success = false;
+      }
     }
-    if (
-      !node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY)
-      && !(
-        exception == GUMBO_TAG_LAST
-        || node_html_tag_is(get_current_node(parser), GUMBO_TAG_RTC)
-      )
-    ) {
-      parser_add_parse_error(parser, token);
-      success = false;
+    insert_element_from_token(parser, token);
+    return success;
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(RP), TAG(RT)})) {
+    bool success = true;
+    if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
+      generate_implied_end_tags(parser, GUMBO_TAG_RTC);
+      GumboNode* current = get_current_node(parser);
+      if (!node_html_tag_is(current, GUMBO_TAG_RUBY) &&
+          !node_html_tag_is(current, GUMBO_TAG_RTC)) {
+        parser_add_parse_error(parser, token);
+        success = false;
+      }
     }
     insert_element_from_token(parser, token);
     return success;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_BR)) {
-    parser_add_parse_error(parser, token);
-    reconstruct_active_formatting_elements(parser);
-    insert_element_of_tag_type (
-      parser,
-      GUMBO_TAG_BR,
-      GUMBO_INSERTION_CONVERTED_FROM_END_TAG
-    );
-    pop_current_node(parser);
-    return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
     reconstruct_active_formatting_elements(parser);
     adjust_mathml_attributes(token);
     adjust_foreign_attributes(token);
@@ -3283,7 +3342,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       acknowledge_self_closing_tag(parser);
     }
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
     reconstruct_active_formatting_elements(parser);
     adjust_svg_attributes(token);
     adjust_foreign_attributes(token);
@@ -3293,7 +3353,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       acknowledge_self_closing_tag(parser);
     }
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(FRAME), TAG(HEAD),
       TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
@@ -3302,48 +3363,49 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_START_TAG) {
+  }
+  if (token->type == GUMBO_TOKEN_START_TAG) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     return true;
-  } else {
-    assert(token->type == GUMBO_TOKEN_END_TAG);
-    GumboTag end_tag = token->v.end_tag.tag;
-    const char *end_tagname = token->v.end_tag.name;
-    assert(state->_open_elements.length > 0);
-    assert(node_html_tag_is(state->_open_elements.data[0], GUMBO_TAG_HTML));
-    // Walk up the stack of open elements until we find one that either:
-    // a) Matches the tag name we saw
-    // b) Is in the "special" category.
-    // If we see a), implicitly close everything up to and including it. If we
-    // see b), then record a parse error, don't close anything (except the
-    // implied end tags) and ignore the end tag token.
-    for (int i = state->_open_elements.length; --i >= 0;) {
-      const GumboNode* node = state->_open_elements.data[i];
-      if (node_qualified_tagname_is(node, GUMBO_NAMESPACE_HTML, end_tag, end_tagname)) {
-        generate_implied_end_tags(parser, end_tag);
-        // TODO(jdtang): Do I need to add a parse error here?  The condition in
-        // the spec seems like it's the inverse of the loop condition above, and
-        // so would never fire.
-	// sfc: Yes, an error is needed here.
-	// <!DOCTYPE><body><sarcasm><foo></sarcasm> is an example.
-        // foo is the "current node" but sarcasm is node.
-        // XXX: Write a test for this.
-        if (node != get_current_node(parser))
-          parser_add_parse_error(parser, token);
-        while (node != pop_current_node(parser))
-          ;  // Pop everything.
-        return true;
-      } else if (is_special_node(node)) {
+  }
+any_other_end_tag:
+  assert(token->type == GUMBO_TOKEN_END_TAG);
+  GumboTag end_tag = token->v.end_tag.tag;
+  const char *end_tagname = token->v.end_tag.name;
+  assert(state->_open_elements.length > 0);
+  assert(node_html_tag_is(state->_open_elements.data[0], GUMBO_TAG_HTML));
+  // Walk up the stack of open elements until we find one that either:
+  // a) Matches the tag name we saw
+  // b) Is in the "special" category.
+  // If we see a), implicitly close everything up to and including it. If we
+  // see b), then record a parse error, don't close anything (except the
+  // implied end tags) and ignore the end tag token.
+  for (int i = state->_open_elements.length; --i >= 0;) {
+    const GumboNode* node = state->_open_elements.data[i];
+    if (node_qualified_tagname_is(node, GUMBO_NAMESPACE_HTML, end_tag, end_tagname)) {
+      generate_implied_end_tags(parser, end_tag);
+      // TODO(jdtang): Do I need to add a parse error here?  The condition in
+      // the spec seems like it's the inverse of the loop condition above, and
+      // so would never fire.
+      // sfc: Yes, an error is needed here.
+      // <!DOCTYPE><body><sarcasm><foo></sarcasm> is an example.
+      // foo is the "current node" but sarcasm is node.
+      // XXX: Write a test for this.
+      if (node != get_current_node(parser))
         parser_add_parse_error(parser, token);
-        ignore_token(parser);
-        return false;
-      }
+      while (node != pop_current_node(parser))
+        ;  // Pop everything.
+      return true;
+    } else if (is_special_node(node)) {
+      parser_add_parse_error(parser, token);
+      ignore_token(parser);
+      return false;
     }
-    // <html> is in the special category, so we should never get here.
-    assert(0);
-    return false;
   }
+  // <html> is in the special category, so we should never get here.
+  assert(0);
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incdata
@@ -3353,30 +3415,36 @@ static bool handle_text(GumboParser* parser, GumboToken* token) {
     || token->type == GUMBO_TOKEN_WHITESPACE
   ) {
     insert_text_token(parser, token);
-  } else {
-    // We provide only bare-bones script handling that doesn't involve any of
-    // the parser-pause/already-started/script-nesting flags or re-entrant
-    // invocations of the tokenizer. Because the intended usage of this library
-    // is mostly for templating, refactoring, and static-analysis libraries, we
-    // provide the script body as a text-node child of the <script> element.
-    // This behavior doesn't support document.write of partial HTML elements,
-    // but should be adequate for almost all other scripting support.
-    if (token->type == GUMBO_TOKEN_EOF) {
-      parser_add_parse_error(parser, token);
-      parser->_parser_state->_reprocess_current_token = true;
-    }
-    pop_current_node(parser);
-    set_insertion_mode(parser, parser->_parser_state->_original_insertion_mode);
+    return true;
   }
-  return true;
+  // We provide only bare-bones script handling that doesn't involve any of
+  // the parser-pause/already-started/script-nesting flags or re-entrant
+  // invocations of the tokenizer. Because the intended usage of this library
+  // is mostly for templating, refactoring, and static-analysis libraries, we
+  // provide the script body as a text-node child of the <script> element.
+  // This behavior doesn't support document.write of partial HTML elements,
+  // but should be adequate for almost all other scripting support.
+  bool success = true;
+  if (token->type == GUMBO_TOKEN_EOF) {
+    parser_add_parse_error(parser, token);
+    success = false;
+    parser->_parser_state->_reprocess_current_token = true;
+  }
+  pop_current_node(parser);
+  set_insertion_mode(parser, parser->_parser_state->_original_insertion_mode);
+  return success;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intable
 static bool handle_in_table(GumboParser* parser, GumboToken* token) {
   GumboParserState* state = parser->_parser_state;
   if (
-    token->type == GUMBO_TOKEN_CHARACTER
-    || token->type == GUMBO_TOKEN_WHITESPACE
+    (token->type == GUMBO_TOKEN_CHARACTER
+     || token->type == GUMBO_TOKEN_WHITESPACE
+     || token->type == GUMBO_TOKEN_NULL)
+    && node_tag_in_set(get_current_node(parser), &(const TagSet) {
+      TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)
+    })
   ) {
     // The "pending table character tokens" list described in the spec is
     // nothing more than the TextNodeBufferState. We accumulate text tokens as
@@ -3384,71 +3452,87 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     // we set _foster_parent_insertions if there're non-whitespace characters in
     // the buffer.
     assert(state->_text_node._buffer.length == 0);
+    assert(state->_table_character_tokens.length == 0);
     state->_original_insertion_mode = state->_insertion_mode;
     state->_reprocess_current_token = true;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_TEXT);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
-    append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_CAPTION)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_CAPTION)) {
     clear_stack_to_table_context(parser);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_CAPTION);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COLGROUP)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_COLGROUP)) {
     clear_stack_to_table_context(parser);
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
     clear_stack_to_table_context(parser);
     insert_element_of_tag_type (
       parser,
       GUMBO_TAG_COLGROUP,
       GUMBO_INSERTION_IMPLIED
     );
-    parser->_parser_state->_reprocess_current_token = true;
+    state->_reprocess_current_token = true;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
-      TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TD), TAG(TH), TAG(TR)
+      TAG(TBODY), TAG(TFOOT), TAG(THEAD)
     })
   ) {
     clear_stack_to_table_context(parser);
+    insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-    if (tag_in(token, kStartTag, &(const TagSet){TAG(TD), TAG(TH), TAG(TR)})) {
-      insert_element_of_tag_type (
-        parser,
-        GUMBO_TAG_TBODY,
-        GUMBO_INSERTION_IMPLIED
-      );
-      state->_reprocess_current_token = true;
-    } else {
-      insert_element_from_token(parser, token);
-    }
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
+  }
+  if (
+    tag_in(token, kStartTag, &(const TagSet) {
+      TAG(TD), TAG(TH), TAG(TR)
+    })
+  ) {
+    clear_stack_to_table_context(parser);
+    insert_element_of_tag_type (
+      parser,
+      GUMBO_TAG_TBODY,
+      GUMBO_INSERTION_IMPLIED
+    );
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    state->_reprocess_current_token = true;
+    return true;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
     parser_add_parse_error(parser, token);
     if (close_table(parser)) {
-      parser->_parser_state->_reprocess_current_token = true;
+      state->_reprocess_current_token = true;
     } else {
       ignore_token(parser);
     }
     return false;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
     if (!close_table(parser)) {
       parser_add_parse_error(parser, token);
       return false;
     }
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML),
       TAG(TBODY), TAG(TD), TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
@@ -3457,20 +3541,24 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(STYLE), TAG(SCRIPT), TAG(TEMPLATE)})
     || (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE))
   ) {
     return handle_in_head(parser, token);
-  } else if (
+  }
+  if (
     tag_is(token, kStartTag, GUMBO_TAG_INPUT)
     && attribute_matches(&token->v.start_tag.attributes, "type", "hidden")
   ) {
     parser_add_parse_error(parser, token);
     insert_element_from_token(parser, token);
     pop_current_node(parser);
+    acknowledge_self_closing_tag(parser);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
     parser_add_parse_error(parser, token);
     if (state->_form_element || has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       ignore_token(parser);
@@ -3479,15 +3567,16 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     state->_form_element = insert_element_from_token(parser, token);
     pop_current_node(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return handle_in_body(parser, token);
-  } else {
-    parser_add_parse_error(parser, token);
-    state->_foster_parent_insertions = true;
-    bool result = handle_in_body(parser, token);
-    state->_foster_parent_insertions = false;
-    return result;
   }
+  // foster-parenting-start-tag or foster-parenting-end-tag error
+  parser_add_parse_error(parser, token);
+  state->_foster_parent_insertions = true;
+  bool result = handle_in_body(parser, token);
+  state->_foster_parent_insertions = false;
+  return result;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intabletext
@@ -3496,40 +3585,38 @@ static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (
-    token->type == GUMBO_TOKEN_CHARACTER
-    || token->type == GUMBO_TOKEN_WHITESPACE
-  ) {
+  }
+  GumboParserState* state = parser->_parser_state;
+  // Non-whitespace tokens will cause parse errors later.
+  // It's not entirely clear from the spec how this is supposed to work.
+  // https://github.com/whatwg/html/issues/4046
+  if (token->type == GUMBO_TOKEN_WHITESPACE
+      || token->type == GUMBO_TOKEN_CHARACTER) {
     insert_text_token(parser, token);
+    gumbo_character_token_buffer_append(token, &state->_table_character_tokens);
     return true;
-  } else {
-    GumboParserState* state = parser->_parser_state;
-    GumboStringBuffer* buffer = &state->_text_node._buffer;
-    const char* data = buffer->data;
-    // Note that TextNodeBuffer may contain UTF-8 characters, but the
-    // presence of any one byte that is not whitespace means we flip
-    // the flag, so this loop is still valid.
+  }
+
+  GumboCharacterTokenBuffer* buffer = &state->_table_character_tokens;
+  if (state->_text_node._type != GUMBO_NODE_WHITESPACE) {
+    // Each character in buffer is an error. Unfortunately, that means we need
+    // to emit a bunch of errors at the appropriate locations.
     for (size_t i = 0, n = buffer->length; i < n; ++i) {
-      switch (data[i]) {
-      case '\t':
-      case '\n':
-      case '\f':
-      case '\r':
-      case ' ':
-        continue;
-      default:
-        state->_foster_parent_insertions = true;
-        reconstruct_active_formatting_elements(parser);
-        goto loopbreak;
-      }
+      GumboToken tok;
+      gumbo_character_token_buffer_get(buffer, i, &tok);
+      // foster-parenting-character error
+      parser_add_parse_error(parser, &tok);
     }
-    loopbreak:
-    maybe_flush_text_node_buffer(parser);
-    state->_foster_parent_insertions = false;
-    state->_reprocess_current_token = true;
-    state->_insertion_mode = state->_original_insertion_mode;
-    return true;
+    state->_foster_parent_insertions = true;
+    set_frameset_not_ok(parser);
+    reconstruct_active_formatting_elements(parser);
   }
+  maybe_flush_text_node_buffer(parser);
+  gumbo_character_token_buffer_clear(buffer);
+  state->_foster_parent_insertions = false;
+  state->_reprocess_current_token = true;
+  state->_insertion_mode = state->_original_insertion_mode;
+  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incaption
@@ -3539,19 +3626,18 @@ static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      bool result = true;
-      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION)) {
-        parser_add_parse_error(parser, token);
-      }
-      while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION))
-        ;
-      clear_active_formatting_elements(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-      return result;
     }
-  } else if (
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    bool result = node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION);
+    if (!result)
+      parser_add_parse_error(parser, token);
+    while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION))
+      ;
+    clear_active_formatting_elements(parser);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
+    return result;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TD),
       TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
@@ -3563,13 +3649,18 @@ static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
       ignore_token(parser);
       return false;
     }
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    bool result = node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION);
+    if (!result)
+      parser_add_parse_error(parser, token);
     while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_CAPTION))
       ;
     clear_active_formatting_elements(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     parser->_parser_state->_reprocess_current_token = true;
-    return true;
-  } else if (
+    return result;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(COL), TAG(COLGROUP), TAG(HTML), TAG(TBODY), TAG(TD),
       TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
@@ -3578,9 +3669,8 @@ static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    return handle_in_body(parser, token);
   }
+  return handle_in_body(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incolgroup
@@ -3588,21 +3678,26 @@ static bool handle_in_column_group(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
-    append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_COLGROUP)) {
     if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -3611,28 +3706,30 @@ static bool handle_in_column_group(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     return false;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (
+  }
+  if (
     tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
     return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return handle_in_body(parser, token);
-  } else {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
-    }
-    pop_current_node(parser);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    parser->_parser_state->_reprocess_current_token = true;
-    return true;
   }
+  if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return false;
+  }
+  pop_current_node(parser);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
+  parser->_parser_state->_reprocess_current_token = true;
+  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intbody
@@ -3642,14 +3739,16 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
     return true;
-  } else if (tag_in(token, kStartTag, &td_th_tags)) {
+  }
+  if (tag_in(token, kStartTag, &td_th_tags)) {
     parser_add_parse_error(parser, token);
     clear_stack_to_table_body_context(parser);
     insert_element_of_tag_type(parser, GUMBO_TAG_TR, GUMBO_INSERTION_IMPLIED);
-    parser->_parser_state->_reprocess_current_token = true;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
+    parser->_parser_state->_reprocess_current_token = true;
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet){TAG(TBODY), TAG(TFOOT), TAG(THEAD)})
   ) {
     if (!has_an_element_in_table_scope(parser, token->v.end_tag.tag)) {
@@ -3661,7 +3760,8 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT),
       TAG(THEAD)
@@ -3684,18 +3784,18 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     parser->_parser_state->_reprocess_current_token = true;
     return true;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
-      TAG(BODY), TAG(CAPTION), TAG(COL), TAG(TR), TAG(COLGROUP),
-      TAG(HTML), TAG(TD), TAG(TH)
+      TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML), TAG(TD),
+      TAG(TH), TAG(TR)
     })
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    return handle_in_table(parser, token);
   }
+  return handle_in_table(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intr
@@ -3706,18 +3806,19 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_CELL);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_TR)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TR)) {
     if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-      return true;
     }
-  } else if (
+    clear_stack_to_table_row_context(parser);
+    pop_current_node(parser);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    return true;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT),
       TAG(THEAD), TAG(TR)
@@ -3728,31 +3829,32 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-      parser->_parser_state->_reprocess_current_token = true;
-      return true;
     }
-  } else if (
+    clear_stack_to_table_row_context(parser);
+    pop_current_node(parser);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    parser->_parser_state->_reprocess_current_token = true;
+    return true;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {TAG(TBODY), TAG(TFOOT), TAG(THEAD)})
   ) {
-    if (
-      !has_an_element_in_table_scope(parser, token->v.end_tag.tag)
-      || !has_an_element_in_table_scope(parser, GUMBO_TAG_TR)
-    ) {
+    if (!has_an_element_in_table_scope(parser, token->v.end_tag.tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
       return false;
-    } else {
-      clear_stack_to_table_row_context(parser);
-      pop_current_node(parser);
-      set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-      parser->_parser_state->_reprocess_current_token = true;
+    }
+    if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
+      ignore_token(parser);
       return true;
     }
-  } else if (
+    clear_stack_to_table_row_context(parser);
+    pop_current_node(parser);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    parser->_parser_state->_reprocess_current_token = true;
+    return true;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML),
       TAG(TD), TAG(TH)
@@ -3761,9 +3863,8 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else {
-    return handle_in_table(parser, token);
   }
+  return handle_in_table(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intd
@@ -3776,7 +3877,8 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
       return false;
     }
     return close_table_cell(parser, token, token_tag);
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TD),
       TAG(TFOOT), TAG(TH), TAG(THEAD), TAG(TR)
@@ -3794,7 +3896,8 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
     }
     parser->_parser_state->_reprocess_current_token = true;
     return close_current_cell(parser, token);
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML)
     })
@@ -3802,7 +3905,8 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)
     })
@@ -3814,9 +3918,8 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
     }
     parser->_parser_state->_reprocess_current_token = true;
     return close_current_cell(parser, token);
-  } else {
-    return handle_in_body(parser, token);
   }
+  return handle_in_body(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselect
@@ -3825,28 +3928,34 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_CHARACTER
     || token->type == GUMBO_TOKEN_WHITESPACE
   ) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return true;
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
-    append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_OPTION)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_OPTION)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
       pop_current_node(parser);
     }
     insert_element_from_token(parser, token);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_OPTGROUP)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_OPTGROUP)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
       pop_current_node(parser);
     }
@@ -3855,7 +3964,8 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
     }
     insert_element_from_token(parser, token);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
     GumboVector* open_elements = &parser->_parser_state->_open_elements;
     if (
       node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)
@@ -3869,21 +3979,21 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTGROUP)) {
       pop_current_node(parser);
       return true;
-    } else {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_OPTION)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return false;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_OPTION)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
       pop_current_node(parser);
       return true;
-    } else {
-      parser_add_parse_error(parser, token);
-      ignore_token(parser);
-      return false;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_SELECT)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return false;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_SELECT)) {
     if (!has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -3891,14 +4001,16 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
     }
     close_current_select(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     if (has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
       close_current_select(parser);
     }
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {TAG(INPUT), TAG(KEYGEN), TAG(TEXTAREA)})
   ) {
     parser_add_parse_error(parser, token);
@@ -3909,18 +4021,18 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_reprocess_current_token = true;
     }
     return false;
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(SCRIPT), TAG(TEMPLATE)})
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
     return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
-  } else {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
   }
+  if (token->type == GUMBO_TOKEN_EOF)
+    return handle_in_body(parser, token);
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselectintable
@@ -3934,22 +4046,18 @@ static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
     close_current_select(parser);
     parser->_parser_state->_reprocess_current_token = true;
     return false;
-  } else if (tag_in(token, kEndTag, &tags)) {
+  }
+  if (tag_in(token, kEndTag, &tags)) {
     parser_add_parse_error(parser, token);
     if (!has_an_element_in_table_scope(parser, token->v.end_tag.tag)) {
       ignore_token(parser);
       return false;
-    } else {
-      close_current_select(parser);
-      // close_current_select already does the
-      // reset_insertion_mode_appropriately
-      // reset_insertion_mode_appropriately(parser);
-      parser->_parser_state->_reprocess_current_token = true;
-      return false;
     }
-  } else {
-    return handle_in_select(parser, token);
+    close_current_select(parser);
+    parser->_parser_state->_reprocess_current_token = true;
+    return false;
   }
+  return handle_in_select(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intemplate
@@ -3973,7 +4081,8 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
     return handle_in_head(parser, token);
-  } else if (
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT), TAG(THEAD)
     })
@@ -3983,35 +4092,41 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     state->_reprocess_current_token = true;
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
     pop_template_insertion_mode(parser);
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
     state->_reprocess_current_token = true;
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
     pop_template_insertion_mode(parser);
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
     state->_reprocess_current_token = true;
     return true;
-  } else if (tag_in(token, kStartTag, &td_th_tags)) {
+  }
+  if (tag_in(token, kStartTag, &td_th_tags)) {
     pop_template_insertion_mode(parser);
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
     state->_reprocess_current_token = true;
     return true;
-  } else if (token->type == GUMBO_TOKEN_START_TAG) {
+  }
+  if (token->type == GUMBO_TOKEN_START_TAG) {
     pop_template_insertion_mode(parser);
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
     state->_reprocess_current_token = true;
     return true;
-  } else if (token->type == GUMBO_TOKEN_END_TAG) {
+  }
+  if (token->type == GUMBO_TOKEN_END_TAG) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       // Stop parsing.
       return true;
@@ -4024,10 +4139,9 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     reset_insertion_mode_appropriately(parser);
     state->_reprocess_current_token = true;
     return false;
-  } else {
-    assert(0);
-    return false;
   }
+  assert(0 && "unreachable");
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterbody
@@ -4037,16 +4151,22 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
     || tag_is(token, kStartTag, GUMBO_TAG_HTML)
   ) {
     return handle_in_body(parser, token);
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     GumboNode* html_node = parser->_output->root;
     assert(html_node != NULL);
     append_comment_node(parser, html_node, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    return handle_in_body(parser, token);
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
     /* fragment case: ignore the closing HTML token */
     if (is_fragment_parser(parser)) {
       parser_add_parse_error(parser, token);
@@ -4061,14 +4181,14 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
       &html->v.element
     );
     return true;
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return true;
-  } else {
-    parser_add_parse_error(parser, token);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    parser->_parser_state->_reprocess_current_token = true;
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
+  parser->_parser_state->_reprocess_current_token = true;
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inframeset
@@ -4076,19 +4196,24 @@ static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     insert_element_from_token(parser, token);
     return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_FRAMESET)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_FRAMESET)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
@@ -4102,24 +4227,26 @@ static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_FRAMESET);
     }
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAME)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FRAME)) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
     return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
       parser_add_parse_error(parser, token);
       return false;
     }
     return true;
-  } else {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterframeset
@@ -4127,16 +4254,20 @@ static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
     return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+  }
+  if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
     return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
     GumboNode* html = parser->_parser_state->_open_elements.data[0];
     assert(node_html_tag_is(html, GUMBO_TAG_HTML));
     record_end_of_element (
@@ -4145,15 +4276,16 @@ static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
     );
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_FRAMESET);
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
     return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return true;
-  } else {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-body-insertion-mode
@@ -4161,20 +4293,21 @@ static bool handle_after_after_body(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_DOCTYPE
     || token->type == GUMBO_TOKEN_WHITESPACE
     || tag_is(token, kStartTag, GUMBO_TAG_HTML)
   ) {
     return handle_in_body(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return true;
-  } else {
-    parser_add_parse_error(parser, token);
-    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    parser->_parser_state->_reprocess_current_token = true;
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
+  parser->_parser_state->_reprocess_current_token = true;
+  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-frameset-insertion-mode
@@ -4185,21 +4318,23 @@ static bool handle_after_after_frameset (
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
     return true;
-  } else if (
+  }
+  if (
     token->type == GUMBO_TOKEN_DOCTYPE
     || token->type == GUMBO_TOKEN_WHITESPACE
     || tag_is(token, kStartTag, GUMBO_TAG_HTML)
   ) {
     return handle_in_body(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
     return handle_in_head(parser, token);
-  } else {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
   }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
+  return false;
 }
 
 // Function pointers for each insertion mode.
@@ -4306,8 +4441,7 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_reprocess_current_token = true;
       return false;
     }
-
-    assert(token->type == GUMBO_TOKEN_START_TAG);
+    // This is a start tag so the next if's then branch will be taken.
   }
 
   if (token->type == GUMBO_TOKEN_START_TAG) {
@@ -4329,49 +4463,48 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
     return true;
     // </script> tags are handled like any other end tag, putting the script's
     // text into a text node child and closing the current node.
-  } else {
-    assert(token->type == GUMBO_TOKEN_END_TAG);
-    GumboNode* node = get_current_node(parser);
-    GumboTag tag = token->v.end_tag.tag;
-    const char* name = token->v.end_tag.name;
-    assert(node != NULL);
+  }
+  assert(token->type == GUMBO_TOKEN_END_TAG);
+  GumboNode* node = get_current_node(parser);
+  GumboTag tag = token->v.end_tag.tag;
+  const char* name = token->v.end_tag.name;
+  assert(node != NULL);
 
-    bool is_success = true;
-    if (!node_tagname_is(node, tag, name)) {
-      parser_add_parse_error(parser, token);
-      is_success = false;
-    }
-    int i = parser->_parser_state->_open_elements.length;
-    for (--i; i > 0;) {
-      // Here we move up the stack until we find an HTML element (in which
-      // case we do nothing) or we find the element that we're about to
-      // close (in which case we pop everything we've seen until that
-      // point.)
-      gumbo_debug("Foreign %s node at %d.\n", node->v.element.name, i);
-      if (node_tagname_is(node, tag, name)) {
-        gumbo_debug("Matches.\n");
-        while (node != pop_current_node(parser)) {
-          // Pop all the nodes below the current one. Node is guaranteed to
-          // be an element on the stack of open elements (set below), so
-          // this loop is guaranteed to terminate.
-        }
-        return is_success;
-      }
-      --i;
-      node = parser->_parser_state->_open_elements.data[i];
-      if (node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML) {
-        // The loop continues only in foreign namespaces.
-        break;
+  bool is_success = true;
+  if (!node_tagname_is(node, tag, name)) {
+    parser_add_parse_error(parser, token);
+    is_success = false;
+  }
+  int i = parser->_parser_state->_open_elements.length;
+  for (--i; i > 0;) {
+    // Here we move up the stack until we find an HTML element (in which
+    // case we do nothing) or we find the element that we're about to
+    // close (in which case we pop everything we've seen until that
+    // point.)
+    gumbo_debug("Foreign %s node at %d.\n", node->v.element.name, i);
+    if (node_tagname_is(node, tag, name)) {
+      gumbo_debug("Matches.\n");
+      while (node != pop_current_node(parser)) {
+        // Pop all the nodes below the current one. Node is guaranteed to
+        // be an element on the stack of open elements (set below), so
+        // this loop is guaranteed to terminate.
       }
-    }
-    assert(node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML);
-    if (i == 0)
       return is_success;
-    // We can't call handle_token directly because the current node is still in
-    // a foriegn namespace, so it would re-enter this and result in infinite
-    // recursion.
-    return handle_html_content(parser, token) && is_success;
+    }
+    --i;
+    node = parser->_parser_state->_open_elements.data[i];
+    if (node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML) {
+      // The loop continues only in foreign namespaces.
+      break;
+    }
   }
+  assert(node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML);
+  if (i == 0)
+    return is_success;
+  // We can't call handle_token directly because the current node is still in
+  // a foriegn namespace, so it would re-enter this and result in infinite
+  // recursion.
+  return handle_html_content(parser, token) && is_success;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction
@@ -4517,7 +4650,7 @@ static void fragment_parser_init (
         break;
 
       case GUMBO_TAG_SCRIPT:
-        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT);
+        gumbo_tokenizer_set_state(parser, GUMBO_LEX_SCRIPT_DATA);
         break;
 
       case GUMBO_TAG_NOSCRIPT:
@@ -4554,7 +4687,7 @@ static void fragment_parser_init (
   // 11.
   if (ctx_has_form_ancestor
       || (ctx_tag == GUMBO_TAG_FORM
-	  && fragment_namespace == GUMBO_NAMESPACE_HTML)) {
+          && fragment_namespace == GUMBO_NAMESPACE_HTML)) {
     static const GumboNode form_ancestor = {
       .type = GUMBO_NODE_ELEMENT,
       .parent = NULL,
@@ -4619,11 +4752,11 @@ GumboOutput* gumbo_parse_with_options (
     if (state->_reprocess_current_token) {
       state->_reprocess_current_token = false;
     } else {
-      GumboNode* current_node = get_current_node(&parser);
-      gumbo_tokenizer_set_is_current_node_foreign (
+      GumboNode* adjusted_current_node = get_adjusted_current_node(&parser);
+      gumbo_tokenizer_set_is_adjusted_current_node_foreign (
         &parser,
-        current_node &&
-          current_node->v.element.tag_namespace != GUMBO_NAMESPACE_HTML
+        adjusted_current_node &&
+          adjusted_current_node->v.element.tag_namespace != GUMBO_NAMESPACE_HTML
       );
       has_error = !gumbo_lex(&parser, &token) || has_error;
     }
@@ -4649,10 +4782,10 @@ GumboOutput* gumbo_parse_with_options (
         break;
     }
     gumbo_debug (
-      "Handling %s token @%zu:%zu in state %u.\n",
+      "Handling %s token @%lu:%lu in state %u.\n",
       (char*) token_type,
-      token.position.line,
-      token.position.column,
+      (unsigned long)token.position.line,
+      (unsigned long)token.position.column,
       state->_insertion_mode
     );
 
@@ -4671,19 +4804,26 @@ GumboOutput* gumbo_parse_with_options (
     );
 
     if (!state->_reprocess_current_token) {
+      // If we're done with the token, check for unacknowledged self-closing
+      // flags on start tags.
       if (token.type == GUMBO_TOKEN_START_TAG &&
           token.v.start_tag.is_self_closing &&
           !state->_self_closing_flag_acknowledged) {
-        GumboError* error = parser_add_parse_error(&parser, &token);
-        if (error)
-          error->type = GUMBO_ERR_UNACKNOWLEDGED_SELF_CLOSING_TAG;
+        has_error = true;
+        GumboError* error = gumbo_add_error(&parser);
+        if (error) {
+          // This is essentially a tokenizer error that's only caught during
+          // tree construction.
+          error->type = GUMBO_ERR_NON_VOID_HTML_ELEMENT_START_TAG_WITH_TRAILING_SOLIDUS;
+          error->original_text = token.original_text;
+          error->position = token.position;
+        }
       }
+      // Make sure we free the end tag's name since it doesn't get transferred
+      // to a token.
       if (token.type == GUMBO_TOKEN_END_TAG &&
-          token.v.end_tag.is_self_closing) {
-        GumboError* error = parser_add_parse_error(&parser, &token);
-        if (error)
-          error->type = GUMBO_ERR_SELF_CLOSING_END_TAG;
-      }
+          token.v.end_tag.tag == GUMBO_TAG_UNKNOWN)
+        gumbo_free(token.v.end_tag.name);
     }
 
     if (unlikely(state->_open_elements.length > max_tree_depth)) {