herb 0.7.5 → 0.8.0

data/src/parser.c

@@ -1,8 +1,6 @@
 #include "include/parser.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
@@ -11,49 +9,46 @@
 #include "include/token.h"
 #include "include/token_matchers.h"
 #include "include/util.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
+#include "include/visitor.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors);
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors);
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors);
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors);
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser);
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children);
-static void parser_consume_whitespace(parser_T* parser, array_T* children);
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children);
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children);
 static void parser_skip_erb_content(lexer_T* lexer);
 static bool parser_lookahead_erb_is_attribute(lexer_T* lexer);
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children);
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children);
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children);
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children);
+
+const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false };
 
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
 }
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options) {
-  parser_T* parser = calloc(1, parser_sizeof());
-
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options) {
   parser->lexer = lexer;
   parser->current_token = lexer_next_token(lexer);
-  parser->open_tags_stack = array_init(16);
+  parser->open_tags_stack = hb_array_init(16);
   parser->state = PARSER_STATE_DATA;
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
-
-  if (options) {
-    parser->options = calloc(1, sizeof(parser_options_T));
-    parser->options->track_whitespace = options->track_whitespace;
-  } else {
-    parser->options = NULL;
-  }
-
-  return parser;
+  parser->options = options;
 }
 
 static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 128);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_CDATA_START, errors);
   position_T start = parser->current_token->location.start;
@@ -62,13 +57,13 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
       start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -84,7 +79,7 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
     errors
   );
 
-  buffer_free(&content);
+  free(content.value);
   token_free(tag_opening);
   token_free(tag_closing);
 
@@ -92,19 +87,20 @@ static AST_CDATA_NODE_T* parser_parse_cdata(parser_T* parser) {
 }
 
 static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
   token_T* comment_start = parser_consume_expected(parser, TOKEN_HTML_COMMENT_START, errors);
   position_T start = parser->current_token->location.start;
 
-  buffer_T comment = buffer_new();
+  hb_buffer_T comment;
+  hb_buffer_init(&comment, 512);
 
   while (token_is_none_of(parser, TOKEN_HTML_COMMENT_END, TOKEN_EOF)) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &comment, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -112,7 +108,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&comment, token->value);
+    hb_buffer_append(&comment, token->value);
     token_free(token);
   }
 
@@ -129,7 +125,7 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
     errors
   );
 
-  buffer_free(&comment);
+  free(comment.value);
   token_free(comment_start);
   token_free(comment_end);
 
@@ -137,9 +133,10 @@ static AST_HTML_COMMENT_NODE_T* parser_parse_html_comment(parser_T* parser) {
 }
 
 static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_DOCTYPE, errors);
 
@@ -150,13 +147,13 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       continue;
     }
 
     token_T* token = parser_consume_expected(parser, parser->current_token->type, errors);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -175,15 +172,16 @@ static AST_HTML_DOCTYPE_NODE_T* parser_parse_html_doctype(parser_T* parser) {
 
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return doctype;
 }
 
 static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T content = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T content;
+  hb_buffer_init(&content, 64);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_XML_DECLARATION, errors);
 
@@ -194,7 +192,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -202,7 +200,7 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
@@ -221,15 +219,16 @@ static AST_XML_DECLARATION_NODE_T* parser_parse_xml_declaration(parser_T* parser
 
   token_free(tag_opening);
   token_free(tag_closing);
-  buffer_free(&content);
+  free(content.value);
 
   return xml_declaration;
 }
 
-static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T* document_errors) {
+static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, hb_array_T* document_errors) {
   position_T start = parser->current_token->location.start;
 
-  buffer_T content = buffer_new();
+  hb_buffer_T content;
+  hb_buffer_init(&content, 2048);
 
   while (token_is_none_of(
     parser,
@@ -241,7 +240,7 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
     TOKEN_EOF
   )) {
     if (token_is(parser, TOKEN_ERROR)) {
-      buffer_free(&content);
+      free(content.value);
 
       token_T* token = parser_consume_expected(parser, TOKEN_ERROR, document_errors);
       append_unexpected_error(
@@ -259,32 +258,31 @@ static AST_HTML_TEXT_NODE_T* parser_parse_text_content(parser_T* parser, array_T
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
-  array_T* errors = array_init(8);
-
-  if (buffer_length(&content) > 0) {
-    AST_HTML_TEXT_NODE_T* text_node =
-      ast_html_text_node_init(buffer_value(&content), start, parser->current_token->location.start, errors);
+  hb_array_T* errors = hb_array_init(8);
 
-    buffer_free(&content);
+  AST_HTML_TEXT_NODE_T* text_node = NULL;
 
-    return text_node;
+  if (hb_buffer_length(&content) > 0) {
+    text_node =
+      ast_html_text_node_init(hb_buffer_value(&content), start, parser->current_token->location.start, errors);
+  } else {
+    text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
   }
 
-  AST_HTML_TEXT_NODE_T* text_node = ast_html_text_node_init("", start, parser->current_token->location.start, errors);
-
-  buffer_free(&content);
+  free(content.value);
 
   return text_node;
 }
 
 static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
-  buffer_T buffer = buffer_new();
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 128);
   position_T start = parser->current_token->location.start;
 
   while (token_is_none_of(
@@ -300,14 +298,14 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
       continue;
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&buffer, token->value);
+    hb_buffer_append(&buffer, token->value);
     token_free(token);
   }
 
@@ -317,8 +315,8 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   position_T node_end = { 0 };
 
   if (children->size > 0) {
-    AST_NODE_T* first_child = array_get(children, 0);
-    AST_NODE_T* last_child = array_get(children, children->size - 1);
+    AST_NODE_T* first_child = hb_array_get(children, 0);
+    AST_NODE_T* last_child = hb_array_get(children, children->size - 1);
 
     node_start = first_child->location.start;
     node_end = last_child->location.end;
@@ -330,17 +328,18 @@ static AST_HTML_ATTRIBUTE_NAME_NODE_T* parser_parse_html_attribute_name(parser_T
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name =
     ast_html_attribute_name_node_init(children, node_start, node_end, errors);
 
-  buffer_free(&buffer);
+  free(buffer.value);
 
   return attribute_name;
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value(
   parser_T* parser,
-  array_T* children,
-  array_T* errors
+  hb_array_T* children,
+  hb_array_T* errors
 ) {
-  buffer_T buffer = buffer_new();
+  hb_buffer_T buffer;
+  hb_buffer_init(&buffer, 512);
   token_T* opening_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
   position_T start = parser->current_token->location.start;
 
@@ -352,7 +351,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
 
       start = parser->current_token->location.start;
 
@@ -366,8 +365,8 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
       if (next_token && next_token->type == TOKEN_QUOTE && opening_quote != NULL
           && strcmp(next_token->value, opening_quote->value) == 0) {
-        buffer_append(&buffer, parser->current_token->value);
-        buffer_append(&buffer, next_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, next_token->value);
 
         token_free(parser->current_token);
         token_free(next_token);
@@ -381,7 +380,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       }
     }
 
-    buffer_append(&buffer, parser->current_token->value);
+    hb_buffer_append(&buffer, parser->current_token->value);
     token_free(parser->current_token);
 
     parser->current_token = lexer_next_token(parser->lexer);
@@ -409,7 +408,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       token_free(parser->current_token);
       parser->current_token = potential_closing;
 
-      buffer_append(&buffer, parser->current_token->value);
+      hb_buffer_append(&buffer, parser->current_token->value);
       token_free(parser->current_token);
       parser->current_token = lexer_next_token(parser->lexer);
 
@@ -421,14 +420,14 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
         if (token_is(parser, TOKEN_ERB_START)) {
           parser_append_literal_node_from_buffer(parser, &buffer, children, start);
 
-          array_append(children, parser_parse_erb_tag(parser));
+          hb_array_append(children, parser_parse_erb_tag(parser));
 
           start = parser->current_token->location.start;
 
           continue;
         }
 
-        buffer_append(&buffer, parser->current_token->value);
+        hb_buffer_append(&buffer, parser->current_token->value);
         token_free(parser->current_token);
 
         parser->current_token = lexer_next_token(parser->lexer);
@@ -442,7 +441,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   parser_append_literal_node_from_buffer(parser, &buffer, children, start);
-  buffer_free(&buffer);
+  free(buffer.value);
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
 
@@ -473,13 +472,13 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 }
 
 static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   // <div id=<%= "home" %>>
   if (token_is(parser, TOKEN_ERB_START)) {
     AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-    array_append(children, erb_node);
+    hb_array_append(children, erb_node);
 
     return ast_html_attribute_value_node_init(
       NULL,
@@ -498,7 +497,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
     AST_LITERAL_NODE_T* literal = ast_literal_node_init_from_token(identifier);
     token_free(identifier);
 
-    array_append(children, literal);
+    hb_array_append(children, literal);
 
     return ast_html_attribute_value_node_init(
       NULL,
@@ -561,12 +560,13 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_html_attribute_value(parser
 static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser) {
   AST_HTML_ATTRIBUTE_NAME_NODE_T* attribute_name = parser_parse_html_attribute_name(parser);
 
-  if (parser->options && parser->options->track_whitespace) {
+  if (parser->options.track_whitespace) {
     bool has_equals = (parser->current_token->type == TOKEN_EQUALS)
                    || lexer_peek_for_token_type_after_whitespace(parser->lexer, TOKEN_EQUALS);
 
     if (has_equals) {
-      buffer_T equals_buffer = buffer_new();
+      hb_buffer_T equals_buffer;
+      hb_buffer_init(&equals_buffer, 256);
       position_T equals_start = { 0 };
       position_T equals_end = { 0 };
       uint32_t range_start = 0;
@@ -582,7 +582,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
           range_start = whitespace->range.from;
         }
 
-        buffer_append(&equals_buffer, whitespace->value);
+        hb_buffer_append(&equals_buffer, whitespace->value);
         token_free(whitespace);
       }
 
@@ -594,14 +594,14 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
         range_start = equals->range.from;
       }
 
-      buffer_append(&equals_buffer, equals->value);
+      hb_buffer_append(&equals_buffer, equals->value);
       equals_end = equals->location.end;
       range_end = equals->range.to;
       token_free(equals);
 
       while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
         token_T* whitespace = parser_advance(parser);
-        buffer_append(&equals_buffer, whitespace->value);
+        hb_buffer_append(&equals_buffer, whitespace->value);
         equals_end = whitespace->location.end;
         range_end = whitespace->range.to;
         token_free(whitespace);
@@ -613,7 +613,7 @@ static AST_HTML_ATTRIBUTE_NODE_T* parser_parse_html_attribute(parser_T* parser)
       equals_with_whitespace->location = (location_T) { .start = equals_start, .end = equals_end };
       equals_with_whitespace->range = (range_T) { .from = range_start, .to = range_end };
 
-      buffer_free(&equals_buffer);
+      free(equals_buffer.value);
 
       AST_HTML_ATTRIBUTE_VALUE_NODE_T* attribute_value = parser_parse_html_attribute_value(parser);
 
@@ -719,12 +719,12 @@ static bool parser_lookahead_erb_is_attribute(lexer_T* lexer) {
   } while (true);
 }
 
-static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_erb_in_open_tag(parser_T* parser, hb_array_T* children) {
   bool is_output_tag = parser->current_token->value && strlen(parser->current_token->value) >= 3
                     && strncmp(parser->current_token->value, "<%=", 3) == 0;
 
   if (!is_output_tag) {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
 
     return;
   }
@@ -738,13 +738,13 @@ static void parser_handle_erb_in_open_tag(parser_T* parser, array_T* children) {
   bool looks_like_attribute = parser_lookahead_erb_is_attribute(&lexer_copy);
 
   if (looks_like_attribute) {
-    array_append(children, parser_parse_html_attribute(parser));
+    hb_array_append(children, parser_parse_html_attribute(parser));
   } else {
-    array_append(children, parser_parse_erb_tag(parser));
+    hb_array_append(children, parser_parse_erb_tag(parser));
   }
 }
 
-static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* children) {
+static void parser_handle_whitespace_in_open_tag(parser_T* parser, hb_array_T* children) {
   token_T* whitespace = parser_consume_if_present(parser, TOKEN_WHITESPACE);
 
   if (whitespace != NULL) {
@@ -758,8 +758,8 @@ static void parser_handle_whitespace_in_open_tag(parser_T* parser, array_T* chil
 }
 
 static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_start = parser_consume_expected(parser, TOKEN_HTML_TAG_START, errors);
   token_T* tag_name = parser_consume_expected(parser, TOKEN_IDENTIFIER, errors);
@@ -771,7 +771,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_IDENTIFIER) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -781,7 +781,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
     }
 
     if (parser->current_token->type == TOKEN_AT) {
-      array_append(children, parser_parse_html_attribute(parser));
+      hb_array_append(children, parser_parse_html_attribute(parser));
       continue;
     }
 
@@ -791,7 +791,7 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER) {
         token_free(next_token);
-        array_append(children, parser_parse_html_attribute(parser));
+        hb_array_append(children, parser_parse_html_attribute(parser));
 
         continue;
       }
@@ -818,8 +818,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
       token_free(tag_start);
       token_free(tag_name);
 
-      array_free(&children);
-      array_free(&errors);
+      hb_array_free(&children);
+      hb_array_free(&errors);
 
       return NULL;
     }
@@ -846,8 +846,8 @@ static AST_HTML_OPEN_TAG_NODE_T* parser_parse_html_open_tag(parser_T* parser) {
 }
 
 static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
-  array_T* children = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* children = hb_array_init(8);
 
   token_T* tag_opening = parser_consume_expected(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
 
@@ -859,21 +859,21 @@ static AST_HTML_CLOSE_TAG_NODE_T* parser_parse_html_close_tag(parser_T* parser)
 
   token_T* tag_closing = parser_consume_expected(parser, TOKEN_HTML_TAG_END, errors);
 
-  if (tag_name != NULL && is_void_element(tag_name->value) && parser_in_svg_context(parser) == false) {
-    char* expected = html_self_closing_tag_string(tag_name->value);
-    char* got = html_closing_tag_string(tag_name->value);
+  if (tag_name != NULL && is_void_element(hb_string(tag_name->value)) && parser_in_svg_context(parser) == false) {
+    hb_string_T expected = html_self_closing_tag_string(hb_string(tag_name->value));
+    hb_string_T got = html_closing_tag_string(hb_string(tag_name->value));
 
     append_void_element_closing_tag_error(
       tag_name,
-      expected,
-      got,
+      expected.data,
+      got.data,
       tag_opening->location.start,
       tag_closing->location.end,
       errors
     );
 
-    free(expected);
-    free(got);
+    free(expected.data);
+    free(got.data);
   }
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = ast_html_close_tag_node_init(
@@ -915,13 +915,13 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
   parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag
 ) {
-  array_T* errors = array_init(8);
-  array_T* body = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
+  hb_array_T* body = hb_array_init(8);
 
   parser_push_open_tag(parser, open_tag->tag_name);
 
-  if (open_tag->tag_name->value && parser_is_foreign_content_tag(open_tag->tag_name->value)) {
-    foreign_content_type_T content_type = parser_get_foreign_content_type(open_tag->tag_name->value);
+  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string(open_tag->tag_name->value))) {
+    foreign_content_type_T content_type = parser_get_foreign_content_type(hb_string(open_tag->tag_name->value));
     parser_enter_foreign_content(parser, content_type);
     parser_parse_foreign_content(parser, body, errors);
   } else {
@@ -932,13 +932,13 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
 
   AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
 
-  if (parser_in_svg_context(parser) == false && is_void_element(close_tag->tag_name->value)) {
-    array_push(body, close_tag);
+  if (parser_in_svg_context(parser) == false && is_void_element(hb_string(close_tag->tag_name->value))) {
+    hb_array_push(body, close_tag);
     parser_parse_in_data_state(parser, body, errors);
     close_tag = parser_parse_html_close_tag(parser);
   }
 
-  bool matches_stack = parser_check_matching_tag(parser, close_tag->tag_name->value);
+  bool matches_stack = parser_check_matching_tag(parser, hb_string(close_tag->tag_name->value));
 
   if (matches_stack) {
     token_T* popped_token = parser_pop_open_tag(parser);
@@ -960,39 +960,28 @@ static AST_HTML_ELEMENT_NODE_T* parser_parse_html_regular_element(
   );
 }
 
-static AST_HTML_ELEMENT_NODE_T* parser_parse_html_element(parser_T* parser) {
+static AST_NODE_T* parser_parse_html_element(parser_T* parser) {
   AST_HTML_OPEN_TAG_NODE_T* open_tag = parser_parse_html_open_tag(parser);
 
   // <tag />
-  if (open_tag->is_void) { return parser_parse_html_self_closing_element(parser, open_tag); }
+  if (open_tag->is_void) { return (AST_NODE_T*) parser_parse_html_self_closing_element(parser, open_tag); }
 
   // <tag>, in void element list, and not in inside an <svg> element
-  if (!open_tag->is_void && is_void_element(open_tag->tag_name->value) && !parser_in_svg_context(parser)) {
-    return parser_parse_html_self_closing_element(parser, open_tag);
+  if (!open_tag->is_void && is_void_element(hb_string(open_tag->tag_name->value)) && !parser_in_svg_context(parser)) {
+    return (AST_NODE_T*) parser_parse_html_self_closing_element(parser, open_tag);
   }
 
-  AST_HTML_ELEMENT_NODE_T* regular_element = parser_parse_html_regular_element(parser, open_tag);
-  if (regular_element != NULL) { return regular_element; }
+  if (open_tag->tag_name->value && parser_is_foreign_content_tag(hb_string(open_tag->tag_name->value))) {
+    AST_HTML_ELEMENT_NODE_T* regular_element = parser_parse_html_regular_element(parser, open_tag);
 
-  array_T* errors = array_init(8);
-
-  parser_append_unexpected_error(parser, "Unknown HTML open tag type", "HTMLOpenTag or HTMLSelfCloseTag", errors);
+    if (regular_element != NULL) { return (AST_NODE_T*) regular_element; }
+  }
 
-  return ast_html_element_node_init(
-    open_tag,
-    open_tag->tag_name,
-    NULL,
-    NULL,
-    false,
-    ELEMENT_SOURCE_HTML,
-    open_tag->base.location.start,
-    open_tag->base.location.end,
-    errors
-  );
+  return (AST_NODE_T*) open_tag;
 }
 
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
-  array_T* errors = array_init(8);
+  hb_array_T* errors = hb_array_init(8);
 
   token_T* opening_tag = parser_consume_expected(parser, TOKEN_ERB_START, errors);
   token_T* content = parser_consume_expected(parser, TOKEN_ERB_CONTENT, errors);
@@ -1017,14 +1006,15 @@ static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser) {
   return erb_node;
 }
 
-static void parser_parse_foreign_content(parser_T* parser, array_T* children, array_T* errors) {
-  buffer_T content = buffer_new();
+static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  hb_buffer_T content;
+  hb_buffer_init(&content, 1024);
   position_T start = parser->current_token->location.start;
-  const char* expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
+  hb_string_T expected_closing_tag = parser_get_foreign_content_closing_tag(parser->foreign_content_type);
 
-  if (expected_closing_tag == NULL) {
+  if (hb_string_is_empty(expected_closing_tag)) {
     parser_exit_foreign_content(parser);
-    buffer_free(&content);
+    free(content.value);
 
     return;
   }
@@ -1034,7 +1024,7 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       parser_append_literal_node_from_buffer(parser, &content, children, start);
 
       AST_ERB_CONTENT_NODE_T* erb_node = parser_parse_erb_tag(parser);
-      array_append(children, erb_node);
+      hb_array_append(children, erb_node);
 
       start = parser->current_token->location.start;
 
@@ -1048,7 +1038,8 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
       bool is_potential_match = false;
 
       if (next_token && next_token->type == TOKEN_IDENTIFIER && next_token->value) {
-        is_potential_match = parser_is_expected_closing_tag_name(next_token->value, parser->foreign_content_type);
+        is_potential_match =
+          parser_is_expected_closing_tag_name(hb_string(next_token->value), parser->foreign_content_type);
       }
 
       lexer_restore_state(parser->lexer, saved_state);
@@ -1059,51 +1050,57 @@ static void parser_parse_foreign_content(parser_T* parser, array_T* children, ar
         parser_append_literal_node_from_buffer(parser, &content, children, start);
         parser_exit_foreign_content(parser);
 
-        buffer_free(&content);
+        free(content.value);
 
         return;
       }
     }
 
     token_T* token = parser_advance(parser);
-    buffer_append(&content, token->value);
+    hb_buffer_append(&content, token->value);
     token_free(token);
   }
 
   parser_append_literal_node_from_buffer(parser, &content, children, start);
   parser_exit_foreign_content(parser);
-  buffer_free(&content);
+  free(content.value);
 }
 
-static void parser_parse_in_data_state(parser_T* parser, array_T* children, array_T* errors) {
-  while (token_is_none_of(parser, TOKEN_HTML_TAG_START_CLOSE, TOKEN_EOF)) {
+static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors) {
+  while (token_is_not(parser, TOKEN_EOF)) {
+
     if (token_is(parser, TOKEN_ERB_START)) {
-      array_append(children, parser_parse_erb_tag(parser));
+      hb_array_append(children, parser_parse_erb_tag(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_DOCTYPE)) {
-      array_append(children, parser_parse_html_doctype(parser));
+      hb_array_append(children, parser_parse_html_doctype(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_XML_DECLARATION)) {
-      array_append(children, parser_parse_xml_declaration(parser));
+      hb_array_append(children, parser_parse_xml_declaration(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_CDATA_START)) {
-      array_append(children, parser_parse_cdata(parser));
+      hb_array_append(children, parser_parse_cdata(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_COMMENT_START)) {
-      array_append(children, parser_parse_html_comment(parser));
+      hb_array_append(children, parser_parse_html_comment(parser));
       continue;
     }
 
     if (token_is(parser, TOKEN_HTML_TAG_START)) {
-      array_append(children, parser_parse_html_element(parser));
+      hb_array_append(children, parser_parse_html_element(parser));
+      continue;
+    }
+
+    if (token_is(parser, TOKEN_HTML_TAG_START_CLOSE)) {
+      hb_array_append(children, parser_parse_html_close_tag(parser));
       continue;
     }
 
@@ -1111,6 +1108,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           parser,
           TOKEN_AMPERSAND,
           TOKEN_AT,
+          TOKEN_BACKSLASH,
           TOKEN_BACKTICK,
           TOKEN_CHARACTER,
           TOKEN_COLON,
@@ -1127,7 +1125,7 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
           TOKEN_UNDERSCORE,
           TOKEN_WHITESPACE
         )) {
-      array_append(children, parser_parse_text_content(parser, errors));
+      hb_array_append(children, parser_parse_text_content(parser, errors));
       continue;
     }
 
@@ -1135,63 +1133,121 @@ static void parser_parse_in_data_state(parser_T* parser, array_T* children, arra
       parser,
       "Unexpected token",
       "TOKEN_ERB_START, TOKEN_HTML_DOCTYPE, TOKEN_HTML_COMMENT_START, TOKEN_IDENTIFIER, TOKEN_WHITESPACE, "
-      "TOKEN_NBSP, TOKEN_AT, or TOKEN_NEWLINE",
+      "TOKEN_NBSP, TOKEN_AT, TOKEN_BACKSLASH, or TOKEN_NEWLINE",
       errors
     );
   }
 }
 
-static void parser_parse_unclosed_html_tags(const parser_T* parser, array_T* errors) {
-  while (array_size(parser->open_tags_stack) > 0) {
-    token_T* unclosed_tag = parser_pop_open_tag(parser);
+static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_string_T tag_name) {
+  int depth = 0;
 
-    append_unclosed_element_error(
-      unclosed_tag,
-      parser->current_token->location.start,
-      parser->current_token->location.end,
-      errors
-    );
+  for (size_t i = start_idx + 1; i < hb_array_size(nodes); i++) {
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
+    if (node == NULL) { continue; }
+
+    if (node->type == AST_HTML_OPEN_TAG_NODE) {
+      AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
-    token_free(unclosed_tag);
+      if (hb_string_equals(hb_string(open->tag_name->value), tag_name)) { depth++; }
+    } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
+      AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+
+      if (hb_string_equals(hb_string(close->tag_name->value), tag_name)) {
+        if (depth == 0) { return i; }
+        depth--;
+      }
+    }
   }
+
+  return (size_t) -1;
 }
 
-static void parser_parse_stray_closing_tags(parser_T* parser, array_T* children, array_T* errors) {
-  while (token_is_not(parser, TOKEN_EOF)) {
-    if (token_is_not(parser, TOKEN_HTML_TAG_START_CLOSE)) {
-      parser_append_unexpected_token_error(parser, TOKEN_HTML_TAG_START_CLOSE, errors);
+static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors);
 
-      token_T* unexpected = parser_advance(parser);
-      token_free(unexpected);
+static hb_array_T* parser_build_elements_from_tags(hb_array_T* nodes, hb_array_T* errors) {
+  hb_array_T* result = hb_array_init(hb_array_size(nodes));
 
-      continue;
-    }
+  for (size_t index = 0; index < hb_array_size(nodes); index++) {
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
+    if (node == NULL) { continue; }
 
-    AST_HTML_CLOSE_TAG_NODE_T* close_tag = parser_parse_html_close_tag(parser);
+    if (node->type == AST_HTML_OPEN_TAG_NODE) {
+      AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
+      hb_string_T tag_name = hb_string(open_tag->tag_name->value);
 
-    if (!is_void_element(close_tag->tag_name->value)) {
-      append_missing_opening_tag_error(
-        close_tag->tag_name,
-        close_tag->base.location.start,
-        close_tag->base.location.end,
-        close_tag->base.errors
-      );
-    }
+      size_t close_index = find_matching_close_tag(nodes, index, tag_name);
+
+      if (close_index == (size_t) -1) {
+        if (hb_array_size(open_tag->base.errors) == 0) {
+          append_missing_closing_tag_error(
+            open_tag->tag_name,
+            open_tag->base.location.start,
+            open_tag->base.location.end,
+            open_tag->base.errors
+          );
+        }
+
+        hb_array_append(result, node);
+      } else {
+        AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) hb_array_get(nodes, close_index);
 
-    array_append(children, close_tag);
+        hb_array_T* body = hb_array_init(close_index - index - 1);
 
-    parser_parse_in_data_state(parser, children, errors);
+        for (size_t j = index + 1; j < close_index; j++) {
+          hb_array_append(body, hb_array_get(nodes, j));
+        }
+
+        hb_array_T* processed_body = parser_build_elements_from_tags(body, errors);
+        hb_array_free(&body);
+
+        hb_array_T* element_errors = hb_array_init(8);
+
+        AST_HTML_ELEMENT_NODE_T* element = ast_html_element_node_init(
+          open_tag,
+          open_tag->tag_name,
+          processed_body,
+          close_tag,
+          false,
+          ELEMENT_SOURCE_HTML,
+          open_tag->base.location.start,
+          close_tag->base.location.end,
+          element_errors
+        );
+
+        hb_array_append(result, element);
+
+        index = close_index;
+      }
+    } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
+      AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+
+      if (!is_void_element(hb_string(close_tag->tag_name->value))) {
+        if (hb_array_size(close_tag->base.errors) == 0) {
+          append_missing_opening_tag_error(
+            close_tag->tag_name,
+            close_tag->base.location.start,
+            close_tag->base.location.end,
+            close_tag->base.errors
+          );
+        }
+      }
+
+      hb_array_append(result, node);
+    } else {
+      hb_array_append(result, node);
+    }
   }
+
+  return result;
 }
 
 static AST_DOCUMENT_NODE_T* parser_parse_document(parser_T* parser) {
-  array_T* children = array_init(8);
-  array_T* errors = array_init(8);
+  hb_array_T* children = hb_array_init(8);
+  hb_array_T* errors = hb_array_init(8);
   position_T start = parser->current_token->location.start;
 
   parser_parse_in_data_state(parser, children, errors);
-  parser_parse_unclosed_html_tags(parser, errors);
-  parser_parse_stray_closing_tags(parser, children, errors);
 
   token_T* eof = parser_consume_expected(parser, TOKEN_EOF, errors);
 
@@ -1206,26 +1262,26 @@ AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser) {
   return parser_parse_document(parser);
 }
 
-static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, array_T* children) {
-  if (parser->options && parser->options->track_whitespace) {
-    array_T* errors = array_init(8);
+static void parser_handle_whitespace(parser_T* parser, token_T* whitespace_token, hb_array_T* children) {
+  if (parser->options.track_whitespace) {
+    hb_array_T* errors = hb_array_init(8);
     AST_WHITESPACE_NODE_T* whitespace_node = ast_whitespace_node_init(
       whitespace_token,
       whitespace_token->location.start,
       whitespace_token->location.end,
       errors
     );
-    array_append(children, whitespace_node);
+    hb_array_append(children, whitespace_node);
   }
 
   token_free(whitespace_token);
 }
 
-static void parser_consume_whitespace(parser_T* parser, array_T* children) {
+static void parser_consume_whitespace(parser_T* parser, hb_array_T* children) {
   while (token_is_any_of(parser, TOKEN_WHITESPACE, TOKEN_NEWLINE)) {
     token_T* whitespace = parser_advance(parser);
 
-    if (parser->options && parser->options->track_whitespace && children != NULL) {
+    if (parser->options.track_whitespace && children != NULL) {
       parser_handle_whitespace(parser, whitespace, children);
     } else {
       token_free(whitespace);
@@ -1233,13 +1289,38 @@ static void parser_consume_whitespace(parser_T* parser, array_T* children) {
   }
 }
 
-void parser_free(parser_T* parser) {
+void herb_parser_deinit(parser_T* parser) {
   if (parser == NULL) { return; }
 
-  if (parser->lexer != NULL) { lexer_free(parser->lexer); }
   if (parser->current_token != NULL) { token_free(parser->current_token); }
-  if (parser->open_tags_stack != NULL) { array_free(&parser->open_tags_stack); }
-  if (parser->options != NULL) { free(parser->options); }
+  if (parser->open_tags_stack != NULL) { hb_array_free(&parser->open_tags_stack); }
+}
+
+void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors) {
+  if (nodes == NULL || hb_array_size(nodes) == 0) { return; }
+
+  hb_array_T* processed = parser_build_elements_from_tags(nodes, errors);
+
+  while (hb_array_size(nodes) > 0) {
+    hb_array_remove(nodes, 0);
+  }
+
+  for (size_t i = 0; i < hb_array_size(processed); i++) {
+    hb_array_append(nodes, hb_array_get(processed, i));
+  }
+
+  hb_array_free(&processed);
+
+  for (size_t i = 0; i < hb_array_size(nodes); i++) {
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
+    if (node == NULL) { continue; }
+
+    herb_visit_node(node, match_tags_visitor, errors);
+  }
+}
+
+void herb_parser_match_html_tags_post_analyze(AST_DOCUMENT_NODE_T* document) {
+  if (document == NULL) { return; }
 
-  free(parser);
+  match_tags_in_node_array(document->children, document->base.errors);
 }