nokogumbo 2.0.0.pre.alpha → 2.0.4

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

@@ -706,6 +706,15 @@ typedef struct GumboInternalOptions {
    */
   bool stop_on_first_error;
 
+  /**
+   * Maximum allowed number of attributes per element. If this limit is
+   * exceeded, the parser will return early with a partial document and
+   * the returned `GumboOutput` will have its `status` field set to
+   * `GUMBO_STATUS_TOO_MANY_ATTRIBUTES`. Set to `-1` to disable the limit.
+   * Default: `400`.
+   */
+  int max_attributes;
+
   /**
    * Maximum allowed depth for the parse tree. If this limit is exceeded,
    * the parser will return early with a partial document and the returned
@@ -796,6 +805,16 @@ typedef enum {
    */
   GUMBO_STATUS_TREE_TOO_DEEP,
 
+  /**
+   * Indicates that the maximum number of attributes per element
+   * (`GumboOptions::max_attributes`) was reached during parsing. The
+   * resulting tree will be a partial document, with no further nodes
+   * created after the point where the limit was reached. The partial
+   * document may be useful for constructing an error message but
+   * typically shouldn't be used for other purposes.
+   */
+  GUMBO_STATUS_TOO_MANY_ATTRIBUTES,
+
   // Currently unused
   GUMBO_STATUS_OUT_OF_MEMORY,
 } GumboOutputStatus;
@@ -817,13 +836,17 @@ 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;
 
+  /**
+   * True if the parser encounted an error.
+   *
+   * This can be true and `errors` an empty `GumboVector` if the `max_errors`
+   * option was set to 0.
+   */
+  bool document_error;
+
   /**
    * A status code indicating whether parsing finished successfully or was
    * stopped mid-document due to exceptional circumstances.
@@ -866,6 +889,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,11 +43,12 @@ 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,
   .stop_on_first_error = false,
+  .max_attributes = 400,
   .max_tree_depth = 400,
   .max_errors = -1,
   .fragment_context = NULL,
@@ -59,25 +61,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 +243,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;
 
@@ -351,6 +337,7 @@ static void output_init(GumboParser* parser) {
   GumboOutput* output = gumbo_alloc(sizeof(GumboOutput));
   output->root = NULL;
   output->document = new_document_node();
+  output->document_error = false;
   output->status = GUMBO_STATUS_OK;
   parser->_output = output;
   gumbo_init_errors(parser);
@@ -365,6 +352,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 +451,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 +562,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 (
@@ -621,6 +610,14 @@ static bool node_qualified_tagname_is (
   return !gumbo_ascii_strcasecmp(element_name, name);
 }
 
+static bool node_html_tagname_is (
+  const GumboNode* node,
+  GumboTag tag,
+  const char *name
+) {
+  return node_qualified_tagname_is(node, GUMBO_NAMESPACE_HTML, tag, name);
+}
+
 static bool node_tagname_is (
   const GumboNode* node,
   GumboTag tag,
@@ -646,7 +643,6 @@ static bool node_qualified_tag_is (
 
 // Like node_tag_in, but for the single-tag case in the HTML namespace
 static bool node_html_tag_is(const GumboNode* node, GumboTag tag) {
-  assert(tag != GUMBO_TAG_UNKNOWN);
   return node_qualified_tag_is(node, GUMBO_NAMESPACE_HTML, tag);
 }
 
@@ -738,18 +734,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 +768,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 +1634,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;
     }
   }
@@ -1687,14 +1684,18 @@ static bool has_an_element_in_select_scope(const GumboParser* parser, GumboTag t
 // https://html.spec.whatwg.org/multipage/parsing.html#generate-implied-end-tags
 // "exception" is the "element to exclude from the process" listed in the spec.
 // Pass GUMBO_TAG_LAST to not exclude any of them.
-static void generate_implied_end_tags(GumboParser* parser, GumboTag exception) {
+static void generate_implied_end_tags (
+  GumboParser* parser,
+  GumboTag exception,
+  const char* exception_name
+) {
   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)
-    && !node_html_tag_is(get_current_node(parser), exception)
+    && !node_html_tagname_is(get_current_node(parser), exception, exception_name)
   ) {
     pop_current_node(parser);
   }
@@ -1704,15 +1705,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
@@ -1732,37 +1754,35 @@ static bool close_table(GumboParser* parser) {
 
 // This factors out the clauses relating to "act as if an end tag token with tag
 // name `cell_tag` had been seen".
-static bool close_table_cell (
+static void close_table_cell (
   GumboParser* parser,
   const GumboToken* token,
   GumboTag cell_tag
 ) {
-  bool result = true;
-  generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+  generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
   const GumboNode* node = get_current_node(parser);
-  if (!node_html_tag_is(node, cell_tag)) {
+  if (!node_html_tag_is(node, cell_tag))
     parser_add_parse_error(parser, token);
-    result = false;
-  }
   do {
     node = pop_current_node(parser);
   } while (!node_html_tag_is(node, cell_tag));
 
   clear_active_formatting_elements(parser);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
-  return result;
 }
 
 // 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) {
+static void 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;
   }
+  close_table_cell(parser, token, cell_tag);
 }
 
 // This factors out the "act as if an end tag of tag name 'select' had been
@@ -1819,14 +1839,14 @@ static bool is_special_node(const GumboNode* node) {
 // specified qualified name. If the elements closed are in the set handled by
 // generate_implied_end_tags, this is normal operation and this function returns
 // true. Otherwise, a parse error is recorded and this function returns false.
-static bool implicitly_close_tags (
+static void implicitly_close_tags (
   GumboParser* parser,
   GumboToken* token,
   GumboNamespaceEnum target_ns,
   GumboTag target
 ) {
-  bool result = true;
-  generate_implied_end_tags(parser, target);
+  assert(target != GUMBO_TAG_UNKNOWN);
+  generate_implied_end_tags(parser, target, NULL);
   if (!node_qualified_tag_is(get_current_node(parser), target_ns, target)) {
     parser_add_parse_error(parser, token);
     while (
@@ -1834,30 +1854,27 @@ static bool implicitly_close_tags (
     ) {
       pop_current_node(parser);
     }
-    result = false;
   }
   assert(node_qualified_tag_is(get_current_node(parser), target_ns, target));
   pop_current_node(parser);
-  return result;
 }
 
 // If the stack of open elements has a <p> tag in button scope, this acts as if
 // a </p> tag was encountered, implicitly closing tags. Returns false if a
 // parse error occurs. This is a convenience function because this particular
 // clause appears several times in the spec.
-static bool maybe_implicitly_close_p_tag (
+static void maybe_implicitly_close_p_tag (
   GumboParser* parser,
   GumboToken* token
 ) {
   if (has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
-    return implicitly_close_tags (
+    implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_P
     );
   }
-  return true;
 }
 
 // Convenience function to encapsulate the logic for closing <li> or <dd>/<dt>
@@ -1868,7 +1885,7 @@ static void maybe_implicitly_close_list_tag (
   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
@@ -1884,6 +1901,7 @@ static void maybe_implicitly_close_list_tag (
       );
       return;
     }
+
     if (
       is_special_node(node)
       && !node_tag_in_set(node, &(const TagSet){TAG(ADDRESS), TAG(DIV), TAG(P)})
@@ -2009,40 +2027,19 @@ 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 (
+static void 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;
   }
-  return true;
 }
 
 static void remove_from_parent(GumboNode* node) {
@@ -2067,39 +2064,115 @@ static void remove_from_parent(GumboNode* node) {
   }
 }
 
+// This is here to clean up memory when the spec says "Ignore current token."
+static void ignore_token(GumboParser* parser) {
+  GumboToken* token = parser->_parser_state->_current_token;
+  // Ownership of the token's internal buffers are normally transferred to the
+  // element, but if no element is emitted (as happens in non-verbatim-mode
+  // when a token is ignored), we need to free it here to prevent a memory
+  // leak.
+  gumbo_token_destroy(token);
+#ifndef NDEBUG
+  if (token->type == GUMBO_TOKEN_START_TAG) {
+    // Mark this sentinel so the assertion in the main loop knows it's been
+    // destroyed.
+    token->v.start_tag.attributes = kGumboEmptyVector;
+    token->v.start_tag.name = NULL;
+  }
+#endif
+}
+
+// The token is usually an end tag; however, the adoption agency algorithm may
+// invoke this for an 'a' or 'nobr' start tag.
+// Returns false if there was an error.
+static void in_body_any_other_end_tag(GumboParser* parser, GumboToken* token)
+{
+  GumboParserState* state = parser->_parser_state;
+  GumboTag tag;
+  const char* tagname;
+
+  if (token->type == GUMBO_TOKEN_END_TAG) {
+    tag = token->v.end_tag.tag;
+    tagname = token->v.end_tag.name;
+  } else {
+    assert(token->type == GUMBO_TOKEN_START_TAG);
+    tag = token->v.start_tag.tag;
+    tagname = token->v.start_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, tag, tagname)) {
+      generate_implied_end_tags(parser, tag, tagname);
+      // <!DOCTYPE><body><sarcasm><foo></sarcasm> is an example of an error.
+      // 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;
+    } else if (is_special_node(node)) {
+      parser_add_parse_error(parser, token);
+      ignore_token(parser);
+      return;
+    }
+  }
+  // <html> is in the special category, so we should never get here.
+  assert(0 && "unreachable");
+}
+
 // 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.
-static bool adoption_agency_algorithm (
-  GumboParser* parser,
-  GumboToken* token,
-  GumboTag subject
-) {
+// Returns false if there was an error.
+static void adoption_agency_algorithm(GumboParser* parser, GumboToken* token)
+{
   GumboParserState* state = parser->_parser_state;
   gumbo_debug("Entering adoption agency algorithm.\n");
   // Step 1.
+  GumboTag subject;
+  if (token->type == GUMBO_TOKEN_START_TAG) {
+    subject = token->v.start_tag.tag;
+  } else {
+    assert(token->type == GUMBO_TOKEN_END_TAG);
+    subject = token->v.end_tag.tag;
+  }
+  assert(subject != GUMBO_TAG_UNKNOWN);
+
+  // Step 2.
   GumboNode* current_node = get_current_node(parser);
   if (
-    current_node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML
-    && current_node->v.element.tag == subject
+    node_html_tag_is(current_node, subject)
     && -1 == gumbo_vector_index_of (
       &state->_active_formatting_elements,
       current_node
     )
   ) {
     pop_current_node(parser);
-    return false;
+    return;
   }
-  // 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.
-        return false;
+        // Last scope marker; abort the algorithm and handle according to "any
+        // other end tag" (below).
+        break;
       }
       if (node_html_tag_is(current_node, subject)) {
         // Found it.
@@ -2121,10 +2194,11 @@ static bool adoption_agency_algorithm (
       // "any other end tag" clause (which may potentially add a parse error,
       // but not always).
       gumbo_debug("No active formatting elements; aborting.\n");
-      return false;
+      in_body_any_other_end_tag(parser, token);
+      return;
     }
 
-    // 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,25 +2206,24 @@ static bool adoption_agency_algorithm (
         formatting_node,
         &state->_active_formatting_elements
       );
-      return false;
+      return;
     }
 
-    // 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;
     }
 
-    // Step 8
-    if (formatting_node != get_current_node(parser)) {
+    // Step 9
+    if (formatting_node != get_current_node(parser))
       parser_add_parse_error(parser, token);  // But continue onwards.
-    }
     assert(formatting_node);
     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 +2233,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;
     }
     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 +2261,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 +2293,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 +2317,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 +2329,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 +2360,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 +2381,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 +2412,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,26 +2425,7 @@ static bool adoption_agency_algorithm (
       insert_at,
       &state->_open_elements
     );
-  }  // Step 20.
-  return true;
-}
-
-// This is here to clean up memory when the spec says "Ignore current token."
-static void ignore_token(GumboParser* parser) {
-  GumboToken* token = parser->_parser_state->_current_token;
-  // Ownership of the token's internal buffers are normally transferred to the
-  // element, but if no element is emitted (as happens in non-verbatim-mode
-  // when a token is ignored), we need to free it here to prevent a memory
-  // leak.
-  gumbo_token_destroy(token);
-#ifndef NDEBUG
-  if (token->type == GUMBO_TOKEN_START_TAG) {
-    // Mark this sentinel so the assertion in the main loop knows it's been
-    // destroyed.
-    token->v.start_tag.attributes = kGumboEmptyVector;
-    token->v.start_tag.name = NULL;
-  }
-#endif
+  }  // Step 21.
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-end
@@ -2401,125 +2450,139 @@ static void finish_parsing(GumboParser* parser) {
     ;  // Pop them all.
 }
 
-static bool handle_initial(GumboParser* parser, GumboToken* token) {
+static void handle_initial(GumboParser* parser, GumboToken* token) {
   GumboDocument* document = &get_document_node(parser)->v.document;
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    return;
+  }
+  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;
     document->system_identifier = token->v.doc_type.system_identifier;
     document->doc_type_quirks_mode = compute_quirks_mode(&token->v.doc_type);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
-    return maybe_add_doctype_error(parser, token);
+    maybe_add_doctype_error(parser, token);
+    return;
   }
   parser_add_parse_error(parser, token);
   document->doc_type_quirks_mode = GUMBO_DOCTYPE_QUIRKS;
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HTML);
   parser->_parser_state->_reprocess_current_token = true;
-  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-before-html-insertion-mode
-static bool handle_before_html(GumboParser* parser, GumboToken* token) {
+static void handle_before_html(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    return;
+  }
+  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 (
+    return;
+  }
+  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;
+    return;
   }
+  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;
 }
 
+// Forward declarations because of mutual dependencies.
+static void handle_token(GumboParser* parser, GumboToken* token);
+static void handle_in_body(GumboParser* parser, GumboToken* token);
+static void 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);
+static void handle_before_head(GumboParser* parser, GumboToken* token) {
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return false;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+    return;
+  }
+  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;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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;
-    return true;
-  } else if (
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
+    return;
+  }
+  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;
+    return;
   }
+  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;
 }
 
-// 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) {
+static void 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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)
     })
@@ -2527,8 +2590,9 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     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_META)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_META)) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
@@ -2536,90 +2600,98 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     // spec doesn't apply. If clients want to handle meta-tag re-encoding, they
     // 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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TITLE)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
-    return true;
-  } else if (
+    return;
+  }
+  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)) {
+    return;
+  }
+  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);
-    return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_HEAD)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
+    run_generic_parsing_algorithm(parser, token, GUMBO_LEX_SCRIPT_DATA);
+    return;
+  }
+  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 (
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     generate_all_implied_end_tags_thoroughly(parser);
-    bool success = true;
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_TEMPLATE)) {
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_TEMPLATE))
       parser_add_parse_error(parser, token);
-      success = false;
-    }
     while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE))
       ;
     clear_active_formatting_elements(parser);
     pop_template_insertion_mode(parser);
     reset_insertion_mode_appropriately(parser);
-    return success;
-  } else if (
+    return;
+  }
+  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;
+    return;
   }
-  return true;
+  pop_current_node(parser);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
+  parser->_parser_state->_reprocess_current_token = true;
+  return;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inheadnoscript
-static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
+static void 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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_NOSCRIPT)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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 (
+    return;
+  }
+  if (
     token->type == GUMBO_TOKEN_WHITESPACE
     || token->type == GUMBO_TOKEN_COMMENT
     || tag_in (token, kStartTag, &(const TagSet) {
@@ -2627,8 +2699,10 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
       TAG(META), TAG(NOFRAMES), TAG(STYLE)
     })
   ) {
-    return handle_in_head(parser, token);
-  } else if (
+    handle_in_head(parser, token);
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(HEAD), TAG(NOSCRIPT)})
     || (
       token->type == GUMBO_TOKEN_END_TAG
@@ -2637,43 +2711,48 @@ 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;
+    return;
   }
+  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;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-head-insertion-mode
-static bool handle_after_head(GumboParser* parser, GumboToken* token) {
+static void handle_after_head(GumboParser* parser, GumboToken* token) {
   GumboParserState* state = parser->_parser_state;
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     insert_text_token(parser, token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return;
+  }
+  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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  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 (
+    return;
+  }
+  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 +2764,15 @@ 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 handle_in_head(parser, token);
-  } else if (
+    return;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
+    handle_in_head(parser, token);
+    return;
+  }
+  if (
     tag_is(token, kStartTag, GUMBO_TAG_HEAD)
     || (
       token->type == GUMBO_TOKEN_END_TAG
@@ -2699,53 +2781,57 @@ 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;
+    return;
   }
+  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;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inbody
-static bool handle_in_body(GumboParser* parser, GumboToken* token) {
+static void handle_in_body(GumboParser* parser, GumboToken* token) {
   GumboParserState* state = parser->_parser_state;
   assert(state->_open_elements.length > 0);
   if (token->type == GUMBO_TOKEN_NULL) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (token->type == GUMBO_TOKEN_WHITESPACE) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_WHITESPACE) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
-    return true;
-  } else if (
+    return;
+  }
+  if (
     token->type == GUMBO_TOKEN_CHARACTER
     || token->type == GUMBO_TOKEN_CDATA
   ) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
     set_frameset_not_ok(parser);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     assert(parser->_output->root != NULL);
     assert(parser->_output->root->type == GUMBO_NODE_ELEMENT);
     merge_attributes(token, parser->_output->root);
-    return false;
-  } else if (
+    return;
+  }
+  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),
@@ -2753,8 +2839,10 @@ 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)) {
+    handle_in_head(parser, token);
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     parser_add_parse_error(parser, token);
     if (
       state->_open_elements.length < 2
@@ -2762,12 +2850,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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     parser_add_parse_error(parser, token);
     if (
       state->_open_elements.length < 2
@@ -2775,7 +2864,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       || !state->_frameset_ok
     ) {
       ignore_token(parser);
-      return false;
+      return;
     }
     // Save the body node for later removal.
     GumboNode* body_node = state->_open_elements.data[1];
@@ -2807,80 +2896,74 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     // Insert the <frameset>, and switch the insertion mode.
     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);
-      }
-    }
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     if (get_current_template_insertion_mode(parser) !=
         GUMBO_INSERTION_MODE_INITIAL) {
-      return handle_in_template(parser, token);
+      handle_in_template(parser, token);
+      return;
     }
-    return true;
-  } else if (tag_in(token, kEndTag, &(const TagSet){TAG(BODY), TAG(HTML)})) {
+    if (stack_contains_nonclosable_element(parser))
+      parser_add_parse_error(parser, token);
+    return;
+  }
+  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;
-      }
+      return;
     }
+    if (stack_contains_nonclosable_element(parser))
+      parser_add_parse_error(parser, token);
+    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;
+  }
+  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;
     }
-    return success;
-  } else if (
+    if (stack_contains_nonclosable_element(parser))
+      parser_add_parse_error(parser, token);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
+    parser->_parser_state->_reprocess_current_token = true;
+    return;
+  }
+  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);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
-    return result;
-  } else if (tag_in(token, kStartTag, &heading_tags)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    return;
+  }
+  if (tag_in(token, kStartTag, &heading_tags)) {
+    maybe_implicitly_close_p_tag(parser, token);
     if (node_tag_in_set(get_current_node(parser), &heading_tags)) {
       parser_add_parse_error(parser, token);
       pop_current_node(parser);
-      result = false;
     }
     insert_element_from_token(parser, token);
-    return result;
-  } else if (tag_in(token, kStartTag, &(const TagSet){TAG(PRE), TAG(LISTING)})) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    return;
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(PRE), TAG(LISTING)})) {
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     state->_ignore_next_linefeed = true;
-    state->_frameset_ok = false;
-    return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
+    set_frameset_not_ok(parser);
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
     if (
       state->_form_element != NULL
       && !has_open_element(parser, GUMBO_TAG_TEMPLATE)
@@ -2888,46 +2971,48 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       gumbo_debug("Ignoring nested form.\n");
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    maybe_implicitly_close_p_tag(parser, token);
     GumboNode* form_element = insert_element_from_token(parser, token);
     if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       state->_form_element = form_element;
     }
-    return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
+    return;
+  }
+  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);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
-    return result;
-  } else if (tag_in(token, kStartTag, &dd_dt_tags)) {
+    return;
+  }
+  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);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
-    return result;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
+    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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_BUTTON)) {
     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;
+      // 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, NULL);
+      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;
+  }
+  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),
@@ -2940,33 +3025,29 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     if (!has_an_element_in_scope(parser, tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
-    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);
         ignore_token(parser);
-        return false;
+        return;
       }
-      bool success = true;
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FORM)) {
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_FORM))
         parser_add_parse_error(parser, token);
-        return false;
-      }
       while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_FORM))
         ;
-      return success;
+      return;
     } else {
-      bool result = true;
       GumboNode* node = state->_form_element;
       assert(!node || node->type == GUMBO_NODE_ELEMENT);
       state->_form_element = NULL;
@@ -2974,25 +3055,24 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
         gumbo_debug("Closing an unopened form.\n");
         parser_add_parse_error(parser, token);
         ignore_token(parser);
-        return false;
+        return;
       }
       // This differs from implicitly_close_tags because we remove *only* the
       // <form> element; other nodes are left in scope.
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      if (get_current_node(parser) != node) {
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+      if (get_current_node(parser) != node)
         parser_add_parse_error(parser, token);
-        result = false;
-      } else {
+      else
         record_end_of_element(token, &node->v.element);
-      }
 
       GumboVector* open_elements = &state->_open_elements;
       int index = gumbo_vector_index_of(open_elements, node);
       assert(index >= 0);
       gumbo_vector_remove_at(index, open_elements);
-      return result;
+      return;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
     if (!has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
       parser_add_parse_error(parser, token);
       // reconstruct_active_formatting_elements(parser);
@@ -3001,42 +3081,45 @@ 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;
     }
-    return implicitly_close_tags (
+    implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_P
     );
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_LI)) {
+    return;
+  }
+  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);
-      return false;
+      return;
     }
-    return implicitly_close_tags (
+    implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_LI
     );
-  } else if (tag_in(token, kEndTag, &dd_dt_tags)) {
-    assert(token->type == GUMBO_TOKEN_END_TAG);
+    return;
+  }
+  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);
       ignore_token(parser);
-      return false;
+      return;
     }
-    return implicitly_close_tags (
+    implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       token_tag
     );
-  } else if (tag_in(token, kEndTag, &heading_tags)) {
+    return;
+  }
+  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,
@@ -3046,31 +3129,29 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       // No heading open; ignore the token entirely.
       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;
+      return;
+    }
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+    const GumboNode* current_node = get_current_node(parser);
+    if (!node_html_tag_is(current_node, token->v.end_tag.tag)) {
+      // 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);
     }
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
-    bool success = true;
+    do {
+      current_node = pop_current_node(parser);
+    } while (!node_tag_in_set(current_node, &heading_tags));
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
     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);
+      (void)adoption_agency_algorithm(parser, token);
       // 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
@@ -3082,12 +3163,12 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
         );
         gumbo_vector_remove(last_element, &state->_open_elements);
       }
-      success = false;
     }
     reconstruct_active_formatting_elements(parser);
     add_formatting_element(parser, insert_element_from_token(parser, token));
-    return success;
-  } else if (
+    return;
+  }
+  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)
@@ -3095,48 +3176,52 @@ 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)) {
-    bool result = true;
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOBR)) {
     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);
+      adoption_agency_algorithm(parser, token);
       reconstruct_active_formatting_elements(parser);
     }
     insert_element_from_token(parser, token);
     add_formatting_element(parser, get_current_node(parser));
-    return result;
-  } else if (
+    return;
+  }
+  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 (
+    adoption_agency_algorithm(parser, token);
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})
   ) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     set_frameset_not_ok(parser);
-    return true;
-  } else if (
+    return;
+  }
+  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;
+      return;
     }
     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;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
     if (
       get_document_node(parser)->v.document.doc_type_quirks_mode
         != GUMBO_DOCTYPE_QUIRKS
@@ -3146,75 +3231,89 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     set_frameset_not_ok(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    return true;
-  } else if (
-    tag_in(token, kStartTag, &(const TagSet) {
+    return;
+  }
+  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;
+  }
+  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;
+  }
+  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);
-    return true;
-  } else if (
+    if (!attribute_matches(&input->v.element.attributes, "type", "hidden"))
+      set_frameset_not_ok(parser);
+    return;
+  }
+  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)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
+    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)) {
+    return;
+  }
+  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)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_XMP)) {
+    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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
     set_frameset_not_ok(parser);
@@ -3230,50 +3329,40 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     } else {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_SELECT);
     }
-    return true;
-  } else if (
-    tag_in(token, kStartTag, &(const TagSet){TAG(OPTION), TAG(OPTGROUP)})
+    return;
+  }
+  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);
     }
     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)})
-  ) {
-    bool success = true;
-    GumboTag exception = tag_in(token, kStartTag, &(const TagSet){TAG(RT), TAG(RP)})
-      ? GUMBO_TAG_RTC
-      : GUMBO_TAG_LAST
-    ;
+    return;
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(RB), TAG(RTC)})) {
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
-      generate_implied_end_tags(parser, exception);
+      generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY))
+        parser_add_parse_error(parser, token);
     }
-    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;
+  }
+  if (tag_in(token, kStartTag, &(const TagSet){TAG(RP), TAG(RT)})) {
+    if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
+      generate_implied_end_tags(parser, GUMBO_TAG_RTC, NULL);
+      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);
+      }
     }
     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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
     reconstruct_active_formatting_elements(parser);
     adjust_mathml_attributes(token);
     adjust_foreign_attributes(token);
@@ -3282,8 +3371,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
       acknowledge_self_closing_tag(parser);
     }
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
     reconstruct_active_formatting_elements(parser);
     adjust_svg_attributes(token);
     adjust_foreign_attributes(token);
@@ -3292,8 +3382,9 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
       acknowledge_self_closing_tag(parser);
     }
-    return true;
-  } else if (
+    return;
+  }
+  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)
@@ -3301,82 +3392,50 @@ 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) {
+    return;
+  }
+  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)) {
-        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;
+    return;
   }
+  in_body_any_other_end_tag(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incdata
-static bool handle_text(GumboParser* parser, GumboToken* token) {
+static void handle_text(GumboParser* parser, GumboToken* token) {
   if (
     token->type == GUMBO_TOKEN_CHARACTER
     || 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;
   }
-  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.
+  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);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intable
-static bool handle_in_table(GumboParser* parser, GumboToken* token) {
+static void 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 +3443,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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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 (
+    return;
+  }
+  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)) {
+    return;
+  }
+  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;
+  }
+  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)) {
+    return;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
     if (!close_table(parser)) {
       parser_add_parse_error(parser, token);
-      return false;
+      return;
     }
-    return true;
-  } else if (
+    return;
+  }
+  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)
@@ -3456,102 +3531,103 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (
+    return;
+  }
+  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 (
+    handle_in_head(parser, token);
+    return;
+  }
+  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);
-    return false;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
+    acknowledge_self_closing_tag(parser);
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     state->_form_element = insert_element_from_token(parser, token);
     pop_current_node(parser);
-    return false;
-  } else 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;
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    handle_in_body(parser, token);
+    return;
   }
+  // foster-parenting-start-tag or foster-parenting-end-tag error
+  parser_add_parse_error(parser, token);
+  state->_foster_parent_insertions = true;
+  handle_in_body(parser, token);
+  state->_foster_parent_insertions = false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intabletext
-static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
+static void handle_in_table_text(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_NULL) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (
-    token->type == GUMBO_TOKEN_CHARACTER
-    || token->type == GUMBO_TOKEN_WHITESPACE
-  ) {
+    return;
+  }
+  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);
-    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.
+    gumbo_character_token_buffer_append(token, &state->_table_character_tokens);
+    return;
+  }
+
+  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;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incaption
-static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
+static void handle_in_caption(GumboParser* parser, GumboToken* token) {
   if (tag_is(token, kEndTag, GUMBO_TAG_CAPTION)) {
     if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
       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;
+      return;
     }
-  } else if (
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+    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;
+  }
+  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)
@@ -3561,15 +3637,19 @@ static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
     if (!has_an_element_in_table_scope(parser, GUMBO_TAG_CAPTION)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
+    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);
     parser->_parser_state->_reprocess_current_token = true;
-    return true;
-  } else if (
+    return;
+  }
+  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)
@@ -3577,91 +3657,102 @@ 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
-static bool handle_in_column_group(GumboParser* parser, GumboToken* token) {
+static void 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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return;
+  }
+  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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    return false;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
+    return;
+  }
+  if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (
+    return;
+  }
+  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) {
-    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;
+    handle_in_head(parser, token);
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    handle_in_body(parser, token);
+    return;
   }
+  if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_COLGROUP)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return;
+  }
+  pop_current_node(parser);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
+  parser->_parser_state->_reprocess_current_token = true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intbody
-static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
+static void handle_in_table_body(GumboParser* parser, GumboToken* token) {
   if (tag_is(token, kStartTag, GUMBO_TAG_TR)) {
     clear_stack_to_table_body_context(parser);
     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)) {
+    return;
+  }
+  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);
-    return false;
-  } else if (
+    parser->_parser_state->_reprocess_current_token = true;
+    return;
+  }
+  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)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
     clear_stack_to_table_body_context(parser);
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    return true;
-  } else if (
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT),
       TAG(THEAD)
@@ -3677,47 +3768,48 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
     ) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
     clear_stack_to_table_body_context(parser);
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     parser->_parser_state->_reprocess_current_token = true;
-    return true;
-  } else if (
+    return;
+  }
+  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
-static bool handle_in_row(GumboParser* parser, GumboToken* token) {
+static void handle_in_row(GumboParser* parser, GumboToken* token) {
   if (tag_in(token, kStartTag, &td_th_tags)) {
     clear_stack_to_table_row_context(parser);
     insert_element_from_token(parser, 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)) {
+    return;
+  }
+  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;
+      return;
     }
-  } else if (
+    clear_stack_to_table_row_context(parser);
+    pop_current_node(parser);
+    set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT),
       TAG(THEAD), TAG(TR)
@@ -3727,32 +3819,33 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
     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);
-      parser->_parser_state->_reprocess_current_token = true;
-      return true;
+      return;
     }
-  } 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;
+  }
+  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;
-      return true;
+      return;
+    }
+    if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
+      ignore_token(parser);
+      return;
     }
-  } 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;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML),
       TAG(TD), TAG(TH)
@@ -3760,23 +3853,24 @@ 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
-static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
+static void handle_in_cell(GumboParser* parser, GumboToken* token) {
   if (tag_in(token, kEndTag, &td_th_tags)) {
     GumboTag token_tag = token->v.end_tag.tag;
     if (!has_an_element_in_table_scope(parser, token_tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
-    return close_table_cell(parser, token, token_tag);
-  } else if (
+    close_table_cell(parser, token, token_tag);
+    return;
+  }
+  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)
@@ -3790,19 +3884,22 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
       gumbo_debug("Bailing out because there's no <td> or <th> in scope.\n");
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
     parser->_parser_state->_reprocess_current_token = true;
-    return close_current_cell(parser, token);
-  } else if (
+    close_current_cell(parser, token);
+    return;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(BODY), TAG(CAPTION), TAG(COL), TAG(COLGROUP), TAG(HTML)
     })
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (
+    return;
+  }
+  if (
     tag_in(token, kEndTag, &(const TagSet) {
       TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD), TAG(TR)
     })
@@ -3810,43 +3907,50 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
     if (!has_an_element_in_table_scope(parser, token->v.end_tag.tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
     parser->_parser_state->_reprocess_current_token = true;
-    return close_current_cell(parser, token);
-  } else {
-    return handle_in_body(parser, token);
+    close_current_cell(parser, token);
+    return;
   }
+  handle_in_body(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselect
-static bool handle_in_select(GumboParser* parser, GumboToken* token) {
+static void handle_in_select(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_NULL) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
-  } else if (
+    return;
+  }
+  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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
+    append_comment_node(parser, get_current_node(parser), token);
+    return;
+  }
+  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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_OPTION)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_OPTGROUP)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
       pop_current_node(parser);
     }
@@ -3854,8 +3958,9 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
     }
     insert_element_from_token(parser, token);
-    return true;
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
+    return;
+  }
+  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)
@@ -3868,37 +3973,39 @@ 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;
+      return;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_OPTION)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return;
+  }
+  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;
+      return;
     }
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_SELECT)) {
+    parser_add_parse_error(parser, token);
+    ignore_token(parser);
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     close_current_select(parser);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
+    return;
+  }
+  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 (
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {TAG(INPUT), TAG(KEYGEN), TAG(TEXTAREA)})
   ) {
     parser_add_parse_error(parser, token);
@@ -3908,23 +4015,25 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       close_current_select(parser);
       parser->_parser_state->_reprocess_current_token = true;
     }
-    return false;
-  } else if (
+    return;
+  }
+  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;
+    handle_in_head(parser, token);
+    return;
   }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    handle_in_body(parser, token);
+    return;
+  }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselectintable
-static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
+static void handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
   static const TagSet tags = {
     TAG(CAPTION), TAG(TABLE), TAG(TBODY), TAG(TFOOT), TAG(THEAD),
     TAG(TR), TAG(TD), TAG(TH)
@@ -3933,27 +4042,23 @@ static bool handle_in_select_in_table(GumboParser* parser, GumboToken* token) {
     parser_add_parse_error(parser, token);
     close_current_select(parser);
     parser->_parser_state->_reprocess_current_token = true;
-    return false;
-  } else if (tag_in(token, kEndTag, &tags)) {
+    return;
+  }
+  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;
+      return;
     }
-  } else {
-    return handle_in_select(parser, token);
+    close_current_select(parser);
+    parser->_parser_state->_reprocess_current_token = true;
+    return;
   }
+  handle_in_select(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intemplate
-static bool handle_in_template(GumboParser* parser, GumboToken* token) {
+static void handle_in_template(GumboParser* parser, GumboToken* token) {
   GumboParserState* state = parser->_parser_state;
   switch (token->type) {
     case GUMBO_TOKEN_WHITESPACE:
@@ -3961,7 +4066,8 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     case GUMBO_TOKEN_COMMENT:
     case GUMBO_TOKEN_NULL:
     case GUMBO_TOKEN_DOCTYPE:
-      return handle_in_body(parser, token);
+      handle_in_body(parser, token);
+      return;
     default:
       break;
   }
@@ -3972,8 +4078,10 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     })
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
-    return handle_in_head(parser, token);
-  } else if (
+    handle_in_head(parser, token);
+    return;
+  }
+  if (
     tag_in(token, kStartTag, &(const TagSet) {
       TAG(CAPTION), TAG(COLGROUP), TAG(TBODY), TAG(TFOOT), TAG(THEAD)
     })
@@ -3982,39 +4090,45 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     push_template_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
     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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  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) {
+    return;
+  }
+  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) {
+    return;
+  }
+  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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
     if (!has_open_element(parser, GUMBO_TAG_TEMPLATE)) {
       // Stop parsing.
-      return true;
+      return;
     }
     parser_add_parse_error(parser, token);
     while (!node_html_tag_is(pop_current_node(parser), GUMBO_TAG_TEMPLATE))
@@ -4023,35 +4137,41 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     pop_template_insertion_mode(parser);
     reset_insertion_mode_appropriately(parser);
     state->_reprocess_current_token = true;
-    return false;
-  } else {
-    assert(0);
-    return false;
+    return;
   }
+  assert(0 && "unreachable");
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterbody
-static bool handle_after_body(GumboParser* parser, GumboToken* token) {
+static void handle_after_body(GumboParser* parser, GumboToken* token) {
   if (
     token->type == GUMBO_TOKEN_WHITESPACE
     || tag_is(token, kStartTag, GUMBO_TAG_HTML)
   ) {
-    return handle_in_body(parser, token);
-  } else if (token->type == GUMBO_TOKEN_COMMENT) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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) {
+    return;
+  }
+  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)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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);
       ignore_token(parser);
-      return false;
+      return;
     }
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_BODY);
     GumboNode* html = parser->_parser_state->_open_elements.data[0];
@@ -4060,39 +4180,44 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_current_token,
       &html->v.element
     );
-    return true;
-  } else 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;
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    return;
   }
+  parser_add_parse_error(parser, token);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
+  parser->_parser_state->_reprocess_current_token = true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inframeset
-static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
+static void 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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    return;
+  }
+  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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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)) {
+    return;
+  }
+  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);
-      return false;
+      return;
     }
     pop_current_node(parser);
     if (
@@ -4101,42 +4226,47 @@ 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)) {
+    return;
+  }
+  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)) {
-    return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+    handle_in_head(parser, token);
+    return;
+  }
+  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;
+    return;
   }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterframeset
-static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
+static void 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) {
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
-  } else if (token->type == GUMBO_TOKEN_DOCTYPE) {
+    return;
+  }
+  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)) {
-    return handle_in_body(parser, token);
-  } else if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
+    handle_in_body(parser, token);
+    return;
+  }
+  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 (
@@ -4144,67 +4274,71 @@ static bool handle_after_frameset(GumboParser* parser, GumboToken* token) {
       &html->v.element
     );
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_AFTER_FRAMESET);
-    return true;
-  } else if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
     return handle_in_head(parser, token);
-  } else if (token->type == GUMBO_TOKEN_EOF) {
-    return true;
-  } else {
-    parser_add_parse_error(parser, token);
-    ignore_token(parser);
-    return false;
   }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    return;
+  }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-body-insertion-mode
-static bool handle_after_after_body(GumboParser* parser, GumboToken* token) {
+static void 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 (
+    return;
+  }
+  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) {
-    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;
+    handle_in_body(parser, token);
+    return;
   }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    return;
+  }
+  parser_add_parse_error(parser, token);
+  set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
+  parser->_parser_state->_reprocess_current_token = true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-frameset-insertion-mode
-static bool handle_after_after_frameset (
+static void handle_after_after_frameset (
   GumboParser* parser,
   GumboToken* token
 ) {
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
-    return true;
-  } else if (
+    return;
+  }
+  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) {
-    return true;
-  } else 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;
+    handle_in_body(parser, token);
+    return;
   }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    return;
+  }
+  if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
+    handle_in_head(parser, token);
+    return;
+  }
+  parser_add_parse_error(parser, token);
+  ignore_token(parser);
 }
 
 // Function pointers for each insertion mode.
 // Keep in sync with insertion_mode.h.
-typedef bool (*TokenHandler)(GumboParser* parser, GumboToken* token);
+typedef void (*TokenHandler)(GumboParser* parser, GumboToken* token);
 static const TokenHandler kTokenHandlers[] = {
   handle_initial,
   handle_before_html,
@@ -4231,36 +4365,36 @@ static const TokenHandler kTokenHandlers[] = {
   handle_after_after_frameset
 };
 
-static bool handle_html_content(GumboParser* parser, GumboToken* token) {
+static void handle_html_content(GumboParser* parser, GumboToken* token) {
   const GumboInsertionMode mode = parser->_parser_state->_insertion_mode;
   const TokenHandler handler = kTokenHandlers[mode];
-  return handler(parser, token);
+  handler(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inforeign
-static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
+static void handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
   gumbo_debug("Handling foreign content");
   switch (token->type) {
     case GUMBO_TOKEN_NULL:
       parser_add_parse_error(parser, token);
       token->v.character = kUtf8ReplacementChar;
       insert_text_token(parser, token);
-      return false;
+      return;
     case GUMBO_TOKEN_WHITESPACE:
       insert_text_token(parser, token);
-      return true;
+      return;
     case GUMBO_TOKEN_CDATA:
     case GUMBO_TOKEN_CHARACTER:
       insert_text_token(parser, token);
       set_frameset_not_ok(parser);
-      return true;
+      return;
     case GUMBO_TOKEN_COMMENT:
       append_comment_node(parser, get_current_node(parser), token);
-      return true;
+      return;
     case GUMBO_TOKEN_DOCTYPE:
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     default:
       // Fall through to the if-statements below.
       break;
@@ -4304,10 +4438,9 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
         )
       );
       parser->_parser_state->_reprocess_current_token = true;
-      return false;
+      return;
     }
-
-    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) {
@@ -4326,63 +4459,59 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
       acknowledge_self_closing_tag(parser);
     }
-    return true;
+    return;
     // </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;
+  if (!node_tagname_is(node, tag, name))
+    parser_add_parse_error(parser, token);
+  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;
+    }
+    --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;
   }
+  assert(node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML);
+  if (i == 0)
+    return;
+  // 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.
+  handle_html_content(parser, token);
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction
-static bool handle_token(GumboParser* parser, GumboToken* token) {
+static void handle_token(GumboParser* parser, GumboToken* token) {
   if (
     parser->_parser_state->_ignore_next_linefeed
     && token->type == GUMBO_TOKEN_WHITESPACE && token->v.character == '\n'
   ) {
     parser->_parser_state->_ignore_next_linefeed = false;
     ignore_token(parser);
-    return true;
+    return;
   }
   // This needs to be reset both here and in the conditional above to catch both
   // the case where the next token is not whitespace (so we don't ignore
@@ -4424,9 +4553,9 @@ static bool handle_token(GumboParser* parser, GumboToken* token) {
               token->type == GUMBO_TOKEN_NULL ||
               token->type == GUMBO_TOKEN_WHITESPACE)) ||
       token->type == GUMBO_TOKEN_EOF) {
-    return handle_html_content(parser, token);
+    handle_html_content(parser, token);
   } else {
-    return handle_in_foreign_content(parser, token);
+    handle_in_foreign_content(parser, token);
   }
 }
 
@@ -4517,7 +4646,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 +4683,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,
@@ -4613,19 +4742,18 @@ GumboOutput* gumbo_parse_with_options (
 
   const unsigned int max_tree_depth = options->max_tree_depth;
   GumboToken token;
-  bool has_error = false;
 
   do {
     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;
+      gumbo_lex(&parser, &token);
     }
 
     const char* token_type = "text";
@@ -4649,17 +4777,17 @@ 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
     );
 
     state->_current_token = &token;
     state->_self_closing_flag_acknowledged = false;
 
-    has_error = !handle_token(&parser, &token) || has_error;
+    handle_token(&parser, &token);
 
     // Check for memory leaks when ownership is transferred from start tag
     // tokens to nodes.
@@ -4671,19 +4799,25 @@ 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;
+        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)) {
@@ -4697,7 +4831,7 @@ GumboOutput* gumbo_parse_with_options (
 
   } while (
     (token.type != GUMBO_TOKEN_EOF || state->_reprocess_current_token)
-    && !(options->stop_on_first_error && has_error)
+    && !(options->stop_on_first_error && parser._output->document_error)
   );
 
   finish_parsing(&parser);
@@ -4725,6 +4859,8 @@ const char* gumbo_status_to_string(GumboOutputStatus status) {
       return "OK";
     case GUMBO_STATUS_OUT_OF_MEMORY:
       return "System allocator returned NULL during parsing";
+    case GUMBO_STATUS_TOO_MANY_ATTRIBUTES:
+      return "Attributes per element limit exceeded";
     case GUMBO_STATUS_TREE_TOO_DEEP:
       return "Document tree depth limit exceeded";
     default: