nokogumbo 2.0.0 → 2.0.5

data/gumbo-parser/src/parser.c

@@ -48,6 +48,7 @@ typedef uint8_t TagSet[GUMBO_TAG_LAST + 1];
 const GumboOptions kGumboDefaultOptions = {
   .tab_stop = 8,
   .stop_on_first_error = false,
+  .max_attributes = 400,
   .max_tree_depth = 400,
   .max_errors = -1,
   .fragment_context = NULL,
@@ -336,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);
@@ -608,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,
@@ -633,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);
 }
 
@@ -1675,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(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);
   }
@@ -1741,30 +1754,26 @@ 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));
@@ -1773,7 +1782,7 @@ static bool close_current_cell(GumboParser* parser, const GumboToken* token) {
     assert(has_an_element_in_table_scope(parser, GUMBO_TAG_TH));
     cell_tag = GUMBO_TAG_TH;
   }
-  return close_table_cell(parser, token, cell_tag);
+  close_table_cell(parser, token, cell_tag);
 }
 
 // This factors out the "act as if an end tag of tag name 'select' had been
@@ -1830,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 (
@@ -1845,35 +1854,32 @@ 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>
 // tags. Pass true to is_li for handling <li> tags, false for <dd> and <dt>.
-static bool maybe_implicitly_close_list_tag (
+static void maybe_implicitly_close_list_tag (
   GumboParser* parser,
   GumboToken* token,
   bool is_li
@@ -1887,21 +1893,22 @@ static bool maybe_implicitly_close_list_tag (
       : node_tag_in_set(node, &dd_dt_tags)
     ;
     if (is_list_tag) {
-      return implicitly_close_tags (
+      implicitly_close_tags (
         parser,
         token,
         node->v.element.tag_namespace,
         node->v.element.tag
       );
+      return;
     }
+
     if (
       is_special_node(node)
       && !node_tag_in_set(node, &(const TagSet){TAG(ADDRESS), TAG(DIV), TAG(P)})
     ) {
-      return true;
+      return;
     }
   }
-  return true;
 }
 
 static void merge_attributes (
@@ -2020,7 +2027,7 @@ static void adjust_mathml_attributes(GumboToken* token) {
   attr->name = gumbo_strdup("definitionURL");
 }
 
-static bool maybe_add_doctype_error (
+static void maybe_add_doctype_error (
   GumboParser* parser,
   const GumboToken* token
 ) {
@@ -2032,9 +2039,7 @@ static bool maybe_add_doctype_error (
         && strcmp(doctype->system_identifier, "about:legacy-compat"))
   ) {
     parser_add_parse_error(parser, token);
-    return false;
   }
-  return true;
 }
 
 static void remove_from_parent(GumboNode* node) {
@@ -2059,30 +2064,103 @@ 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.
-// Returns true if the algorithm handled the token and false to indicate that
-// it should be handled according to "any other end tag."
-static bool adoption_agency_algorithm (
-  GumboParser* parser,
-  GumboToken* token,
-  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 true;
+    return;
   }
+
   // Steps 3-5 & 21:
   for (unsigned int i = 0; i < 8; ++i) {
     // Step 6.
@@ -2093,8 +2171,8 @@ static bool adoption_agency_algorithm (
       if (current_node == &kActiveFormattingScopeMarker) {
         gumbo_debug("Broke on scope marker; aborting.\n");
         // Last scope marker; abort the algorithm and handle according to "any
-        // other end tag."
-        return false;
+        // other end tag" (below).
+        break;
       }
       if (node_html_tag_is(current_node, subject)) {
         // Found it.
@@ -2116,7 +2194,8 @@ 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 7
@@ -2127,20 +2206,19 @@ static bool adoption_agency_algorithm (
         formatting_node,
         &state->_active_formatting_elements
       );
-      return true;
+      return;
     }
 
     // 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 true;
+      return;
     }
 
     // Step 9
-    if (formatting_node != get_current_node(parser)) {
+    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));
@@ -2167,7 +2245,7 @@ static bool adoption_agency_algorithm (
         formatting_node,
         &state->_active_formatting_elements
       );
-      return true;
+      return;
     }
     assert(!node_html_tag_is(furthest_block, GUMBO_TAG_HTML));
 
@@ -2348,25 +2426,6 @@ static bool adoption_agency_algorithm (
       &state->_open_elements
     );
   }  // Step 21.
-  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
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-end
@@ -2391,15 +2450,15 @@ 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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     document->has_doctype = true;
@@ -2408,35 +2467,35 @@ static bool handle_initial(GumboParser* parser, GumboToken* token) {
     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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_document_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return true;
+    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;
+    return;
   }
   if (
     token->type == GUMBO_TOKEN_END_TAG
@@ -2444,7 +2503,7 @@ static bool handle_before_html(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   GumboNode* html_node = insert_element_of_tag_type (
     parser,
@@ -2455,37 +2514,37 @@ static bool handle_before_html(GumboParser* parser, GumboToken* token) {
   parser->_output->root = html_node;
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_BEFORE_HEAD);
   parser->_parser_state->_reprocess_current_token = true;
-  return true;
 }
 
 // Forward declarations because of mutual dependencies.
-static bool handle_token(GumboParser* parser, GumboToken* token);
-static bool handle_in_body(GumboParser* parser, GumboToken* token);
-static bool handle_in_template(GumboParser* parser, GumboToken* token);
+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) {
+static void handle_before_head(GumboParser* parser, GumboToken* token) {
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     ignore_token(parser);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    handle_in_body(parser, token);
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HEAD)) {
     GumboNode* node = insert_element_from_token(parser, token);
     parser->_parser_state->_head_element = node;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
-    return true;
+    return;
   }
   if (
     token->type == GUMBO_TOKEN_END_TAG
@@ -2493,7 +2552,7 @@ static bool handle_before_head(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   GumboNode* node = insert_element_of_tag_type (
     parser,
@@ -2503,23 +2562,22 @@ static bool handle_before_head(GumboParser* parser, GumboToken* token) {
   parser->_parser_state->_head_element = node;
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
   parser->_parser_state->_reprocess_current_token = true;
-  return true;
 }
 
 // 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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
     return handle_in_body(parser, token);
@@ -2532,7 +2590,7 @@ 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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_META)) {
     insert_element_from_token(parser, token);
@@ -2542,33 +2600,33 @@ 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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_TITLE)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RCDATA);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet){TAG(NOFRAMES), TAG(STYLE)})
   ) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
-    return true;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_SCRIPT)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_SCRIPT_DATA);
-    return true;
+    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;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet){TAG(BODY), TAG(HTML), TAG(BR)})
@@ -2576,7 +2634,7 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
     parser->_parser_state->_reprocess_current_token = true;
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)) {
     insert_element_from_token(parser, token);
@@ -2584,26 +2642,23 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
     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;
+    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;
+    return;
   }
   if (
     tag_is(token, kStartTag, GUMBO_TAG_HEAD)
@@ -2611,29 +2666,30 @@ static bool handle_in_head(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   pop_current_node(parser);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_HEAD);
   parser->_parser_state->_reprocess_current_token = true;
-  return 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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    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;
+    return;
   }
   if (
     token->type == GUMBO_TOKEN_WHITESPACE
@@ -2643,7 +2699,8 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
       TAG(META), TAG(NOFRAMES), TAG(STYLE)
     })
   ) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet){TAG(HEAD), TAG(NOSCRIPT)})
@@ -2654,7 +2711,7 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   parser_add_parse_error(parser, token);
   const GumboNode* node = pop_current_node(parser);
@@ -2662,38 +2719,38 @@ static bool handle_in_head_noscript(GumboParser* parser, GumboToken* token) {
   UNUSED_IF_NDEBUG(node);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_HEAD);
   parser->_parser_state->_reprocess_current_token = true;
-  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-head-insertion-mode
-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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    handle_in_body(parser, token);
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     insert_element_from_token(parser, token);
     set_frameset_not_ok(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
-    return true;
+    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;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -2709,10 +2766,11 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
     gumbo_vector_add(state->_head_element, &state->_open_elements);
     handle_in_head(parser, token);
     gumbo_vector_remove(state->_head_element, &state->_open_elements);
-    return false;
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (
     tag_is(token, kStartTag, GUMBO_TAG_HEAD)
@@ -2723,27 +2781,26 @@ static bool handle_after_head(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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;
-  return 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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_WHITESPACE) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
-    return true;
+    return;
   }
   if (
     token->type == GUMBO_TOKEN_CHARACTER
@@ -2752,27 +2809,27 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     reconstruct_active_formatting_elements(parser);
     insert_text_token(parser, token);
     set_frameset_not_ok(parser);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -2782,7 +2839,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     })
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_BODY)) {
     parser_add_parse_error(parser, token);
@@ -2796,7 +2854,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       set_frameset_not_ok(parser);
       merge_attributes(token, state->_open_elements.data[1]);
     }
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     parser_add_parse_error(parser, token);
@@ -2806,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];
@@ -2838,50 +2896,43 @@ 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;
+    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;
     }
-    if (stack_contains_nonclosable_element(parser)) {
+    if (stack_contains_nonclosable_element(parser))
       parser_add_parse_error(parser, token);
-      return false;
-    }
-    return true;
+    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;
+      return;
     }
-    bool success = true;
-    if (stack_contains_nonclosable_element(parser)) {
+    if (stack_contains_nonclosable_element(parser))
       parser_add_parse_error(parser, token);
-      success = false;
-    }
     GumboNode* body = state->_open_elements.data[1];
     assert(node_html_tag_is(body, GUMBO_TAG_BODY));
     record_end_of_element(state->_current_token, &body->v.element);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
-    return success;
+    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 false;
+      return;
     }
-    bool success = true;
-    if (stack_contains_nonclosable_element(parser)) {
+    if (stack_contains_nonclosable_element(parser))
       parser_add_parse_error(parser, token);
-      success = false;
-    }
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_BODY);
     parser->_parser_state->_reprocess_current_token = true;
-    return success;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -2892,26 +2943,25 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       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;
+    return;
   }
   if (tag_in(token, kStartTag, &heading_tags)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    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;
+    return;
   }
   if (tag_in(token, kStartTag, &(const TagSet){TAG(PRE), TAG(LISTING)})) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     state->_ignore_next_linefeed = true;
     set_frameset_not_ok(parser);
-    return result;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_FORM)) {
     if (
@@ -2921,48 +2971,46 @@ 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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_LI)) {
-    bool result = maybe_implicitly_close_list_tag(parser, token, true);
-    result = maybe_implicitly_close_p_tag(parser, token) && result;
+    maybe_implicitly_close_list_tag(parser, token, true);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
-    return result;
+    return;
   }
   if (tag_in(token, kStartTag, &dd_dt_tags)) {
-    bool result = maybe_implicitly_close_list_tag(parser, token, false);
-    result = maybe_implicitly_close_p_tag(parser, token) && result;
+    maybe_implicitly_close_list_tag(parser, token, false);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
-    return result;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_PLAINTEXT)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    maybe_implicitly_close_p_tag(parser, token);
     insert_element_from_token(parser, token);
     gumbo_tokenizer_set_state(parser, GUMBO_LEX_PLAINTEXT);
-    return result;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_BUTTON)) {
-    bool success = true;
     if (has_an_element_in_scope(parser, GUMBO_TAG_BUTTON)) {
       parser_add_parse_error(parser, token);
-      success = false;
       // We don't want to use implicitly_close_tags here because it may add an
       // error and we've already added the only error the standard specifies.
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+      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);
     set_frameset_not_ok(parser);
-    return success;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -2977,7 +3025,7 @@ 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;
     }
     return implicitly_close_tags (
       parser,
@@ -2991,19 +3039,15 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       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);
-        success = 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;
@@ -3011,27 +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;
     }
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_P)) {
-    bool success = true;
     if (!has_an_element_in_button_scope(parser, GUMBO_TAG_P)) {
       parser_add_parse_error(parser, token);
       // reconstruct_active_formatting_elements(parser);
@@ -3040,41 +3081,43 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
         GUMBO_TAG_P,
         GUMBO_INSERTION_CONVERTED_FROM_END_TAG
       );
-      success = false;
     }
-    return implicitly_close_tags (
+    implicitly_close_tags (
       parser,
       token,
       GUMBO_NAMESPACE_HTML,
       GUMBO_TAG_P
-    ) && success;
+    );
+    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
     );
+    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
     );
+    return;
   }
   if (tag_in(token, kEndTag, &heading_tags)) {
     if (
@@ -3086,12 +3129,11 @@ 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;
+      return;
     }
-    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
+    generate_implied_end_tags(parser, GUMBO_TAG_LAST, NULL);
     const GumboNode* current_node = get_current_node(parser);
-    bool success = node_html_tag_is(current_node, token->v.end_tag.tag);
-    if (!success) {
+    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
@@ -3101,17 +3143,15 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     do {
       current_node = pop_current_node(parser);
     } while (!node_tag_in_set(current_node, &heading_tags));
-    return success;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_A)) {
-    bool success = true;
     int last_a;
     int has_matching_a = find_last_anchor_index(parser, &last_a);
     if (has_matching_a) {
       assert(has_matching_a == 1);
       parser_add_parse_error(parser, token);
-      bool handled = adoption_agency_algorithm(parser, token, GUMBO_TAG_A);
-      assert(handled);
+      (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
@@ -3123,11 +3163,10 @@ 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;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3137,21 +3176,18 @@ 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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_NOBR)) {
-    bool result = true;
     reconstruct_active_formatting_elements(parser);
     if (has_an_element_in_scope(parser, GUMBO_TAG_NOBR)) {
-      result = false;
       parser_add_parse_error(parser, token);
-      bool handled = adoption_agency_algorithm(parser, token, GUMBO_TAG_NOBR);
-      assert(handled);
+      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;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3160,9 +3196,8 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       TAG(U)
     })
   ) {
-    if (!adoption_agency_algorithm(parser, token, token->v.end_tag.tag))
-      goto any_other_end_tag;
-    return true;
+    adoption_agency_algorithm(parser, token);
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})
@@ -3171,7 +3206,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     add_formatting_element(parser, &kActiveFormattingScopeMarker);
     set_frameset_not_ok(parser);
-    return true;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet){TAG(APPLET), TAG(MARQUEE), TAG(OBJECT)})
@@ -3180,11 +3215,11 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     if (!has_an_element_in_scope(parser, token_tag)) {
       parser_add_parse_error(parser, token);
       ignore_token(parser);
-      return false;
+      return;
     }
-    bool success = implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
+    implicitly_close_tags(parser, token, GUMBO_NAMESPACE_HTML, token_tag);
     clear_active_formatting_elements(parser);
-    return success;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
     if (
@@ -3196,7 +3231,7 @@ 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;
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_BR)) {
     parser_add_parse_error(parser, token);
@@ -3209,7 +3244,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     set_frameset_not_ok(parser);
-    return false;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3229,7 +3264,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
     set_frameset_not_ok(parser);
-    return !is_image;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_INPUT)) {
     reconstruct_active_formatting_elements(parser);
@@ -3238,7 +3273,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     acknowledge_self_closing_tag(parser);
     if (!attribute_matches(&input->v.element.attributes, "type", "hidden"))
       set_frameset_not_ok(parser);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet){TAG(PARAM), TAG(SOURCE), TAG(TRACK)})
@@ -3246,37 +3281,37 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HR)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    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;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_XMP)) {
-    bool result = maybe_implicitly_close_p_tag(parser, token);
+    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;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_NOEMBED)) {
     run_generic_parsing_algorithm(parser, token, GUMBO_LEX_RAWTEXT);
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
     reconstruct_active_formatting_elements(parser);
@@ -3294,7 +3329,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     } else {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_SELECT);
     }
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet){TAG(OPTGROUP), TAG(OPTION)})
@@ -3304,33 +3339,28 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
     }
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
-    return true;
+    return;
   }
   if (tag_in(token, kStartTag, &(const TagSet){TAG(RB), TAG(RTC)})) {
-    bool success = true;
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
-      generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-      if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_RUBY)) {
+      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);
-        success = false;
-      }
     }
     insert_element_from_token(parser, token);
-    return success;
+    return;
   }
   if (tag_in(token, kStartTag, &(const TagSet){TAG(RP), TAG(RT)})) {
-    bool success = true;
     if (has_an_element_in_scope(parser, GUMBO_TAG_RUBY)) {
-      generate_implied_end_tags(parser, GUMBO_TAG_RTC);
+      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);
-        success = false;
       }
     }
     insert_element_from_token(parser, token);
-    return success;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_MATH)) {
     reconstruct_active_formatting_elements(parser);
@@ -3341,7 +3371,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
       acknowledge_self_closing_tag(parser);
     }
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_SVG)) {
     reconstruct_active_formatting_elements(parser);
@@ -3352,7 +3382,7 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
       acknowledge_self_closing_tag(parser);
     }
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3362,60 +3392,24 @@ static bool handle_in_body(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (token->type == GUMBO_TOKEN_START_TAG) {
     reconstruct_active_formatting_elements(parser);
     insert_element_from_token(parser, token);
-    return true;
-  }
-any_other_end_tag:
-  assert(token->type == GUMBO_TOKEN_END_TAG);
-  GumboTag end_tag = token->v.end_tag.tag;
-  const char *end_tagname = token->v.end_tag.name;
-  assert(state->_open_elements.length > 0);
-  assert(node_html_tag_is(state->_open_elements.data[0], GUMBO_TAG_HTML));
-  // Walk up the stack of open elements until we find one that either:
-  // a) Matches the tag name we saw
-  // b) Is in the "special" category.
-  // If we see a), implicitly close everything up to and including it. If we
-  // see b), then record a parse error, don't close anything (except the
-  // implied end tags) and ignore the end tag token.
-  for (int i = state->_open_elements.length; --i >= 0;) {
-    const GumboNode* node = state->_open_elements.data[i];
-    if (node_qualified_tagname_is(node, GUMBO_NAMESPACE_HTML, end_tag, end_tagname)) {
-      generate_implied_end_tags(parser, end_tag);
-      // TODO(jdtang): Do I need to add a parse error here?  The condition in
-      // the spec seems like it's the inverse of the loop condition above, and
-      // so would never fire.
-      // sfc: Yes, an error is needed here.
-      // <!DOCTYPE><body><sarcasm><foo></sarcasm> is an example.
-      // foo is the "current node" but sarcasm is node.
-      // XXX: Write a test for this.
-      if (node != get_current_node(parser))
-        parser_add_parse_error(parser, token);
-      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;
-    }
+    return;
   }
-  // <html> is in the special category, so we should never get here.
-  assert(0);
-  return false;
+  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);
-    return true;
+    return;
   }
   // We provide only bare-bones script handling that doesn't involve any of
   // the parser-pause/already-started/script-nesting flags or re-entrant
@@ -3424,19 +3418,16 @@ static bool handle_text(GumboParser* parser, GumboToken* token) {
   // provide the script body as a text-node child of the <script> element.
   // This behavior doesn't support document.write of partial HTML elements,
   // but should be adequate for almost all other scripting support.
-  bool success = true;
   if (token->type == GUMBO_TOKEN_EOF) {
     parser_add_parse_error(parser, token);
-    success = false;
     parser->_parser_state->_reprocess_current_token = true;
   }
   pop_current_node(parser);
   set_insertion_mode(parser, parser->_parser_state->_original_insertion_mode);
-  return success;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intable
-static bool handle_in_table(GumboParser* parser, GumboToken* token) {
+static void handle_in_table(GumboParser* parser, GumboToken* token) {
   GumboParserState* state = parser->_parser_state;
   if (
     (token->type == GUMBO_TOKEN_CHARACTER
@@ -3456,29 +3447,29 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     state->_original_insertion_mode = state->_insertion_mode;
     state->_reprocess_current_token = true;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_TEXT);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_COL)) {
     clear_stack_to_table_context(parser);
@@ -3489,7 +3480,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     );
     state->_reprocess_current_token = true;
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_COLUMN_GROUP);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3499,7 +3490,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     clear_stack_to_table_context(parser);
     insert_element_from_token(parser, token);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3514,7 +3505,7 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     );
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
     state->_reprocess_current_token = true;
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_TABLE)) {
     parser_add_parse_error(parser, token);
@@ -3523,14 +3514,14 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     } else {
       ignore_token(parser);
     }
-    return false;
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_TABLE)) {
     if (!close_table(parser)) {
       parser_add_parse_error(parser, token);
-      return false;
+      return;
     }
-    return true;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3540,13 +3531,14 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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);
+    handle_in_head(parser, token);
+    return;
   }
   if (
     tag_is(token, kStartTag, GUMBO_TAG_INPUT)
@@ -3556,35 +3548,35 @@ static bool handle_in_table(GumboParser* parser, GumboToken* token) {
     insert_element_from_token(parser, token);
     pop_current_node(parser);
     acknowledge_self_closing_tag(parser);
-    return false;
+    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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
+    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;
-  bool result = handle_in_body(parser, token);
+  handle_in_body(parser, token);
   state->_foster_parent_insertions = false;
-  return result;
 }
 
 // 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;
+    return;
   }
   GumboParserState* state = parser->_parser_state;
   // Non-whitespace tokens will cause parse errors later.
@@ -3594,7 +3586,7 @@ static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
       || token->type == GUMBO_TOKEN_CHARACTER) {
     insert_text_token(parser, token);
     gumbo_character_token_buffer_append(token, &state->_table_character_tokens);
-    return true;
+    return;
   }
 
   GumboCharacterTokenBuffer* buffer = &state->_table_character_tokens;
@@ -3616,26 +3608,24 @@ static bool handle_in_table_text(GumboParser* parser, GumboToken* token) {
   state->_foster_parent_insertions = false;
   state->_reprocess_current_token = true;
   state->_insertion_mode = state->_original_insertion_mode;
-  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-incaption
-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;
+      return;
     }
-    generate_implied_end_tags(parser, GUMBO_TAG_LAST);
-    bool result = node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION);
-    if (!result)
+    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 result;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3647,18 +3637,17 @@ 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);
-    bool result = node_html_tag_is(get_current_node(parser), GUMBO_TAG_CAPTION);
-    if (!result)
+    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 result;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3668,77 +3657,79 @@ static bool handle_in_caption(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
-  return handle_in_body(parser, token);
+  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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    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;
+    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;
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_COL)) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (
     tag_is(token, kStartTag, GUMBO_TAG_TEMPLATE)
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return handle_in_body(parser, token);
+    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 false;
+    return;
   }
   pop_current_node(parser);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
   parser->_parser_state->_reprocess_current_token = true;
-  return true;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-intbody
-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;
+    return;
   }
   if (tag_in(token, kStartTag, &td_th_tags)) {
     parser_add_parse_error(parser, token);
@@ -3746,7 +3737,7 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
     insert_element_of_tag_type(parser, GUMBO_TAG_TR, GUMBO_INSERTION_IMPLIED);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_ROW);
     parser->_parser_state->_reprocess_current_token = true;
-    return false;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet){TAG(TBODY), TAG(TFOOT), TAG(THEAD)})
@@ -3754,12 +3745,12 @@ static bool handle_in_table_body(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;
     }
     clear_stack_to_table_body_context(parser);
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3777,13 +3768,13 @@ 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;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3793,30 +3784,30 @@ static bool handle_in_table_body(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
-  return handle_in_table(parser, token);
+  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;
+    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;
+      return;
     }
     clear_stack_to_table_row_context(parser);
     pop_current_node(parser);
     set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_TABLE_BODY);
-    return true;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3828,13 +3819,13 @@ 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;
+      return;
     }
     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 (
     tag_in(token, kEndTag, &(const TagSet) {TAG(TBODY), TAG(TFOOT), TAG(THEAD)})
@@ -3842,17 +3833,17 @@ static bool handle_in_row(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;
     }
     if (!has_an_element_in_table_scope(parser, GUMBO_TAG_TR)) {
       ignore_token(parser);
-      return true;
+      return;
     }
     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 (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3862,21 +3853,22 @@ static bool handle_in_row(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
-  return handle_in_table(parser, token);
+  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);
+    close_table_cell(parser, token, token_tag);
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -3892,10 +3884,11 @@ 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);
+    close_current_cell(parser, token);
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3904,7 +3897,7 @@ static bool handle_in_cell(GumboParser* parser, GumboToken* token) {
   ) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (
     tag_in(token, kEndTag, &(const TagSet) {
@@ -3914,46 +3907,48 @@ 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);
+    close_current_cell(parser, token);
+    return;
   }
-  return handle_in_body(parser, token);
+  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;
+    return;
   }
   if (
     token->type == GUMBO_TOKEN_CHARACTER
     || token->type == GUMBO_TOKEN_WHITESPACE
   ) {
     insert_text_token(parser, token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_OPTGROUP)) {
     if (node_html_tag_is(get_current_node(parser), GUMBO_TAG_OPTION)) {
@@ -3963,7 +3958,7 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
       pop_current_node(parser);
     }
     insert_element_from_token(parser, token);
-    return true;
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_OPTGROUP)) {
     GumboVector* open_elements = &parser->_parser_state->_open_elements;
@@ -3978,29 +3973,29 @@ 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;
+      return;
     }
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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;
+      return;
     }
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_SELECT)) {
     parser_add_parse_error(parser, token);
@@ -4008,7 +4003,7 @@ static bool handle_in_select(GumboParser* parser, GumboToken* token) {
     if (has_an_element_in_select_scope(parser, GUMBO_TAG_SELECT)) {
       close_current_select(parser);
     }
-    return false;
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {TAG(INPUT), TAG(KEYGEN), TAG(TEXTAREA)})
@@ -4020,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;
+    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);
+    handle_in_head(parser, token);
+    return;
+  }
+  if (token->type == GUMBO_TOKEN_EOF) {
+    handle_in_body(parser, token);
+    return;
   }
-  if (token->type == GUMBO_TOKEN_EOF)
-    return handle_in_body(parser, token);
   parser_add_parse_error(parser, token);
   ignore_token(parser);
-  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inselectintable
-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)
@@ -4045,23 +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;
+    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;
+      return;
     }
     close_current_select(parser);
     parser->_parser_state->_reprocess_current_token = true;
-    return false;
+    return;
   }
-  return handle_in_select(parser, token);
+  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:
@@ -4069,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;
   }
@@ -4080,7 +4078,8 @@ static bool handle_in_template(GumboParser* parser, GumboToken* token) {
     })
     || tag_is(token, kEndTag, GUMBO_TAG_TEMPLATE)
   ) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (
     tag_in(token, kStartTag, &(const TagSet) {
@@ -4091,45 +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;
+    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;
+    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;
+    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;
+    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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_END_TAG) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    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))
@@ -4138,40 +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;
+    return;
   }
   assert(0 && "unreachable");
-  return false;
 }
 
 // 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);
+    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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    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];
@@ -4180,44 +4180,44 @@ static bool handle_after_body(GumboParser* parser, GumboToken* token) {
       parser->_parser_state->_current_token,
       &html->v.element
     );
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return true;
+    return;
   }
   parser_add_parse_error(parser, token);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
   parser->_parser_state->_reprocess_current_token = true;
-  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inframeset
-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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    handle_in_body(parser, token);
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_FRAMESET)) {
     insert_element_from_token(parser, token);
-    return true;
+    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 (
@@ -4226,46 +4226,45 @@ static bool handle_in_frameset(GumboParser* parser, GumboToken* token) {
     ) {
       set_insertion_mode(parser, GUMBO_INSERTION_MODE_AFTER_FRAMESET);
     }
-    return true;
+    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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML)) {
+    if (!node_html_tag_is(get_current_node(parser), GUMBO_TAG_HTML))
       parser_add_parse_error(parser, token);
-      return false;
-    }
-    return true;
+    return;
   }
   parser_add_parse_error(parser, token);
   ignore_token(parser);
-  return false;
 }
 
 // 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;
+    return;
   }
   if (token->type == GUMBO_TOKEN_COMMENT) {
     append_comment_node(parser, get_current_node(parser), token);
-    return true;
+    return;
   }
   if (token->type == GUMBO_TOKEN_DOCTYPE) {
     parser_add_parse_error(parser, token);
     ignore_token(parser);
-    return false;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_HTML)) {
-    return handle_in_body(parser, token);
+    handle_in_body(parser, token);
+    return;
   }
   if (tag_is(token, kEndTag, GUMBO_TAG_HTML)) {
     GumboNode* html = parser->_parser_state->_open_elements.data[0];
@@ -4275,71 +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;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
     return handle_in_head(parser, token);
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return true;
+    return;
   }
   parser_add_parse_error(parser, token);
   ignore_token(parser);
-  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-body-insertion-mode
-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;
+    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);
+    handle_in_body(parser, token);
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return true;
+    return;
   }
   parser_add_parse_error(parser, token);
   set_insertion_mode(parser, GUMBO_INSERTION_MODE_IN_BODY);
   parser->_parser_state->_reprocess_current_token = true;
-  return false;
 }
 
 // https://html.spec.whatwg.org/multipage/parsing.html#the-after-after-frameset-insertion-mode
-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;
+    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);
+    handle_in_body(parser, token);
+    return;
   }
   if (token->type == GUMBO_TOKEN_EOF) {
-    return true;
+    return;
   }
   if (tag_is(token, kStartTag, GUMBO_TAG_NOFRAMES)) {
-    return handle_in_head(parser, token);
+    handle_in_head(parser, token);
+    return;
   }
   parser_add_parse_error(parser, token);
   ignore_token(parser);
-  return false;
 }
 
 // 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,
@@ -4366,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;
@@ -4439,7 +4438,7 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
         )
       );
       parser->_parser_state->_reprocess_current_token = true;
-      return false;
+      return;
     }
     // This is a start tag so the next if's then branch will be taken.
   }
@@ -4460,7 +4459,7 @@ 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.
   }
@@ -4470,11 +4469,8 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
   const char* name = token->v.end_tag.name;
   assert(node != NULL);
 
-  bool is_success = true;
-  if (!node_tagname_is(node, tag, name)) {
+  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
@@ -4489,7 +4485,7 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
         // be an element on the stack of open elements (set below), so
         // this loop is guaranteed to terminate.
       }
-      return is_success;
+      return;
     }
     --i;
     node = parser->_parser_state->_open_elements.data[i];
@@ -4500,22 +4496,22 @@ static bool handle_in_foreign_content(GumboParser* parser, GumboToken* token) {
   }
   assert(node->v.element.tag_namespace == GUMBO_NAMESPACE_HTML);
   if (i == 0)
-    return is_success;
+    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.
-  return handle_html_content(parser, token) && is_success;
+  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
@@ -4557,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);
   }
 }
 
@@ -4746,7 +4742,6 @@ 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) {
@@ -4758,7 +4753,7 @@ GumboOutput* gumbo_parse_with_options (
         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";
@@ -4792,7 +4787,7 @@ GumboOutput* gumbo_parse_with_options (
     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.
@@ -4809,7 +4804,6 @@ GumboOutput* gumbo_parse_with_options (
       if (token.type == GUMBO_TOKEN_START_TAG &&
           token.v.start_tag.is_self_closing &&
           !state->_self_closing_flag_acknowledged) {
-        has_error = true;
         GumboError* error = gumbo_add_error(&parser);
         if (error) {
           // This is essentially a tokenizer error that's only caught during
@@ -4837,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);
@@ -4865,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: