herb 0.8.10-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/src/parser_helpers.c

@@ -1,20 +1,18 @@
 #include "include/parser_helpers.h"
-#include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
-#include "include/html_util.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
-#include "include/token_matchers.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
 
+#include <stdarg.h>
 #include <stdio.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
-  token_T* copy = token_copy(tag_name);
+  token_T* copy = token_copy(tag_name, parser->allocator);
   hb_array_push(parser->open_tags_stack, copy);
 }
 
@@ -22,9 +20,9 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
   token_T* top_token = hb_array_last(parser->open_tags_stack);
-  if (top_token == NULL || top_token->value == NULL) { return false; };
+  if (top_token == NULL || hb_string_is_empty(top_token->value)) { return false; };
 
-  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(top_token->value, tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -47,9 +45,8 @@ bool parser_in_svg_context(const parser_T* parser) {
   for (size_t i = 0; i < stack_size; i++) {
     token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
-    if (tag && tag->value) {
-      hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
+    if (tag && !hb_string_is_empty(tag->value)) {
+      if (hb_string_equals_case_insensitive(tag->value, hb_string("svg"))) { return true; }
     }
   }
 
@@ -75,7 +72,7 @@ hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type)
   switch (type) {
     case FOREIGN_CONTENT_SCRIPT: return hb_string("script");
     case FOREIGN_CONTENT_STYLE: return hb_string("style");
-    default: return hb_string("");
+    default: return HB_STRING_EMPTY;
   }
 }
 
@@ -93,24 +90,53 @@ void parser_exit_foreign_content(parser_T* parser) {
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
 }
 
-void parser_append_unexpected_error(
+void parser_append_unexpected_error_impl(
   parser_T* parser,
+  hb_array_T* errors,
   const char* description,
-  const char* expected,
-  hb_array_T* errors
+  token_type_T first_token,
+  ...
+) {
+  token_T* token = parser_advance(parser);
+
+  va_list args;
+  va_start(args, first_token);
+  char* expected = token_types_to_friendly_string_valist(parser->allocator, first_token, args);
+  va_end(args);
+
+  append_unexpected_error(
+    hb_string(description),
+    hb_string(expected),
+    token_type_to_friendly_string(token->type),
+    token->location.start,
+    token->location.end,
+    parser->allocator,
+    errors
+  );
+
+  hb_allocator_dealloc(parser->allocator, expected);
+  token_free(token, parser->allocator);
+}
+
+void parser_append_unexpected_error_string(
+  parser_T* parser,
+  hb_array_T* errors,
+  const char* description,
+  const char* expected
 ) {
   token_T* token = parser_advance(parser);
 
   append_unexpected_error(
-    description,
-    expected,
-    token_type_to_string(token->type),
+    hb_string(description),
+    hb_string(expected),
+    token_type_to_friendly_string(token->type),
     token->location.start,
     token->location.end,
+    parser->allocator,
     errors
   );
 
-  token_free(token);
+  token_free(token, parser->allocator);
 }
 
 void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors) {
@@ -119,6 +145,7 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
     parser->current_token,
     parser->current_token->location.start,
     parser->current_token->location.end,
+    parser->allocator,
     errors
   );
 }
@@ -129,13 +156,17 @@ void parser_append_literal_node_from_buffer(
   hb_array_T* children,
   position_T start
 ) {
-  if (hb_buffer_length(buffer) == 0) { return; }
+  if (buffer->length == 0) { return; }
+
+  hb_string_T content = { .data = buffer->value, .length = (uint32_t) buffer->length };
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(hb_buffer_value(buffer), start, parser->current_token->location.start, NULL);
+    ast_literal_node_init(content, start, parser->current_token->location.start, NULL, parser->allocator);
 
   if (children != NULL) { hb_array_append(children, literal); }
-  hb_buffer_clear(buffer);
+
+  hb_buffer_free(buffer);
+  hb_buffer_init(buffer, 128, parser->allocator);
 }
 
 token_T* parser_advance(parser_T* parser) {
@@ -155,13 +186,21 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
   if (token == NULL) {
     token = parser_advance(parser);
 
-    append_unexpected_token_error(expected_type, token, token->location.start, token->location.end, array);
+    append_unexpected_token_error(
+      expected_type,
+      token,
+      token->location.start,
+      token->location.end,
+      parser->allocator,
+      array
+    );
   }
 
   return token;
 }
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
   hb_array_T* body,
   hb_array_T* errors
@@ -170,11 +209,12 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     open_tag->tag_name,
     open_tag->tag_name->location.start,
     open_tag->tag_name->location.end,
+    parser->allocator,
     errors
   );
 
   return ast_html_element_node_init(
-    open_tag,
+    (AST_NODE_T*) open_tag,
     open_tag->tag_name,
     body,
     NULL,
@@ -182,7 +222,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     ELEMENT_SOURCE_HTML,
     open_tag->base.location.start,
     open_tag->base.location.end,
-    errors
+    errors,
+    parser->allocator
   );
 }
 
@@ -200,6 +241,7 @@ void parser_handle_mismatched_tags(
       actual_tag,
       actual_tag->location.start,
       actual_tag->location.end,
+      parser->allocator,
       errors
     );
   } else {
@@ -207,6 +249,7 @@ void parser_handle_mismatched_tags(
       close_tag->tag_name,
       close_tag->tag_name->location.start,
       close_tag->tag_name->location.end,
+      parser->allocator,
       errors
     );
   }
@@ -219,3 +262,47 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }
+
+void parser_synchronize(parser_T* parser, hb_array_T* errors) {
+  (void) errors;
+
+  while (parser->current_token->type != TOKEN_EOF) {
+    token_type_T type = parser->current_token->type;
+
+    if (type == TOKEN_HTML_TAG_START || type == TOKEN_HTML_TAG_START_CLOSE || type == TOKEN_ERB_START
+        || type == TOKEN_HTML_COMMENT_START || type == TOKEN_HTML_DOCTYPE) {
+      return;
+    }
+
+    token_T* skipped = parser_advance(parser);
+    token_free(skipped, parser->allocator);
+  }
+}
+
+bool parser_can_close_ancestor(const parser_T* parser, hb_string_T tag_name) {
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
+
+  for (size_t i = stack_size; i > 0; i--) {
+    token_T* open = hb_array_get(parser->open_tags_stack, i - 1);
+
+    if (open && !hb_string_is_empty(open->value) && hb_string_equals_case_insensitive(open->value, tag_name)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+size_t parser_find_ancestor_depth(const parser_T* parser, hb_string_T tag_name) {
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
+
+  for (size_t i = stack_size; i > 0; i--) {
+    token_T* open = hb_array_get(parser->open_tags_stack, i - 1);
+
+    if (open && !hb_string_is_empty(open->value) && hb_string_equals_case_insensitive(open->value, tag_name)) {
+      return stack_size - i;
+    }
+  }
+
+  return (size_t) -1;
+}

data/src/parser_match_tags.c

@@ -7,118 +7,161 @@
 #include "include/visitor.h"
 
 bool match_tags_visitor(const AST_NODE_T* node, void* data) {
-  hb_array_T* errors = (hb_array_T*) data;
+  match_tags_context_T* context = (match_tags_context_T*) data;
 
   if (node == NULL) { return false; }
 
   switch (node->type) {
 
+
     case AST_DOCUMENT_NODE: {
       const AST_DOCUMENT_NODE_T* document_node = (const AST_DOCUMENT_NODE_T*) node;
 
       if (document_node->children != NULL) {
-        match_tags_in_node_array(document_node->children, errors);
+        match_tags_in_node_array(document_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
 
+
+
     case AST_HTML_OPEN_TAG_NODE: {
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (const AST_HTML_OPEN_TAG_NODE_T*) node;
 
       if (html_open_tag_node->children != NULL) {
-        match_tags_in_node_array(html_open_tag_node->children, errors);
+        match_tags_in_node_array(html_open_tag_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
+
+
     case AST_HTML_CLOSE_TAG_NODE: {
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (const AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       if (html_close_tag_node->children != NULL) {
-        match_tags_in_node_array(html_close_tag_node->children, errors);
+        match_tags_in_node_array(html_close_tag_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
+
+
+
+
     case AST_HTML_ELEMENT_NODE: {
       const AST_HTML_ELEMENT_NODE_T* html_element_node = (const AST_HTML_ELEMENT_NODE_T*) node;
 
       if (html_element_node->body != NULL) {
-        match_tags_in_node_array(html_element_node->body, errors);
+        match_tags_in_node_array(html_element_node->body, context->errors, context->options, context->allocator);
       }
       if (html_element_node->open_tag != NULL) {
-        herb_visit_node((AST_NODE_T*) html_element_node->open_tag, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_element_node->open_tag, match_tags_visitor, context);
       }
       if (html_element_node->close_tag != NULL) {
-        herb_visit_node((AST_NODE_T*) html_element_node->close_tag, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_element_node->close_tag, match_tags_visitor, context);
       }
     } break;
 
 
+
+    case AST_HTML_CONDITIONAL_ELEMENT_NODE: {
+      const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* html_conditional_element_node = (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) node;
+
+      if (html_conditional_element_node->body != NULL) {
+        match_tags_in_node_array(html_conditional_element_node->body, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
     case AST_HTML_ATTRIBUTE_VALUE_NODE: {
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (const AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
 
       if (html_attribute_value_node->children != NULL) {
-        match_tags_in_node_array(html_attribute_value_node->children, errors);
+        match_tags_in_node_array(html_attribute_value_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_ATTRIBUTE_NAME_NODE: {
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (const AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
 
       if (html_attribute_name_node->children != NULL) {
-        match_tags_in_node_array(html_attribute_name_node->children, errors);
+        match_tags_in_node_array(html_attribute_name_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_ATTRIBUTE_NODE: {
       const AST_HTML_ATTRIBUTE_NODE_T* html_attribute_node = (const AST_HTML_ATTRIBUTE_NODE_T*) node;
 
       if (html_attribute_node->name != NULL) {
-        herb_visit_node((AST_NODE_T*) html_attribute_node->name, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_attribute_node->name, match_tags_visitor, context);
       }
       if (html_attribute_node->value != NULL) {
-        herb_visit_node((AST_NODE_T*) html_attribute_node->value, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) html_attribute_node->value, match_tags_visitor, context);
       }
     } break;
 
 
 
+
+
+
+
+    case AST_ERB_OPEN_TAG_NODE: {
+      const AST_ERB_OPEN_TAG_NODE_T* erb_open_tag_node = (const AST_ERB_OPEN_TAG_NODE_T*) node;
+
+      if (erb_open_tag_node->children != NULL) {
+        match_tags_in_node_array(erb_open_tag_node->children, context->errors, context->options, context->allocator);
+      }
+    } break;
+
+
+
+
+
     case AST_HTML_COMMENT_NODE: {
       const AST_HTML_COMMENT_NODE_T* html_comment_node = (const AST_HTML_COMMENT_NODE_T*) node;
 
       if (html_comment_node->children != NULL) {
-        match_tags_in_node_array(html_comment_node->children, errors);
+        match_tags_in_node_array(html_comment_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_HTML_DOCTYPE_NODE: {
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) node;
 
       if (html_doctype_node->children != NULL) {
-        match_tags_in_node_array(html_doctype_node->children, errors);
+        match_tags_in_node_array(html_doctype_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_XML_DECLARATION_NODE: {
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) node;
 
       if (xml_declaration_node->children != NULL) {
-        match_tags_in_node_array(xml_declaration_node->children, errors);
+        match_tags_in_node_array(xml_declaration_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_CDATA_NODE: {
       const AST_CDATA_NODE_T* cdata_node = (const AST_CDATA_NODE_T*) node;
 
       if (cdata_node->children != NULL) {
-        match_tags_in_node_array(cdata_node->children, errors);
+        match_tags_in_node_array(cdata_node->children, context->errors, context->options, context->allocator);
       }
     } break;
 
@@ -126,186 +169,204 @@ bool match_tags_visitor(const AST_NODE_T* node, void* data) {
 
 
 
+
+
+
+
     case AST_ERB_ELSE_NODE: {
       const AST_ERB_ELSE_NODE_T* erb_else_node = (const AST_ERB_ELSE_NODE_T*) node;
 
       if (erb_else_node->statements != NULL) {
-        match_tags_in_node_array(erb_else_node->statements, errors);
+        match_tags_in_node_array(erb_else_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_IF_NODE: {
       const AST_ERB_IF_NODE_T* erb_if_node = (const AST_ERB_IF_NODE_T*) node;
 
       if (erb_if_node->statements != NULL) {
-        match_tags_in_node_array(erb_if_node->statements, errors);
+        match_tags_in_node_array(erb_if_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_if_node->subsequent != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_if_node->subsequent, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_if_node->subsequent, match_tags_visitor, context);
       }
       if (erb_if_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_if_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_if_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_BLOCK_NODE: {
       const AST_ERB_BLOCK_NODE_T* erb_block_node = (const AST_ERB_BLOCK_NODE_T*) node;
 
       if (erb_block_node->body != NULL) {
-        match_tags_in_node_array(erb_block_node->body, errors);
+        match_tags_in_node_array(erb_block_node->body, context->errors, context->options, context->allocator);
       }
       if (erb_block_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_WHEN_NODE: {
       const AST_ERB_WHEN_NODE_T* erb_when_node = (const AST_ERB_WHEN_NODE_T*) node;
 
       if (erb_when_node->statements != NULL) {
-        match_tags_in_node_array(erb_when_node->statements, errors);
+        match_tags_in_node_array(erb_when_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_CASE_NODE: {
       const AST_ERB_CASE_NODE_T* erb_case_node = (const AST_ERB_CASE_NODE_T*) node;
 
       if (erb_case_node->children != NULL) {
-        match_tags_in_node_array(erb_case_node->children, errors);
+        match_tags_in_node_array(erb_case_node->children, context->errors, context->options, context->allocator);
       }
       if (erb_case_node->conditions != NULL) {
-        match_tags_in_node_array(erb_case_node->conditions, errors);
+        match_tags_in_node_array(erb_case_node->conditions, context->errors, context->options, context->allocator);
       }
       if (erb_case_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_node->else_clause, match_tags_visitor, context);
       }
       if (erb_case_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_CASE_MATCH_NODE: {
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) node;
 
       if (erb_case_match_node->children != NULL) {
-        match_tags_in_node_array(erb_case_match_node->children, errors);
+        match_tags_in_node_array(erb_case_match_node->children, context->errors, context->options, context->allocator);
       }
       if (erb_case_match_node->conditions != NULL) {
-        match_tags_in_node_array(erb_case_match_node->conditions, errors);
+        match_tags_in_node_array(erb_case_match_node->conditions, context->errors, context->options, context->allocator);
       }
       if (erb_case_match_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_match_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->else_clause, match_tags_visitor, context);
       }
       if (erb_case_match_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_case_match_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_WHILE_NODE: {
       const AST_ERB_WHILE_NODE_T* erb_while_node = (const AST_ERB_WHILE_NODE_T*) node;
 
       if (erb_while_node->statements != NULL) {
-        match_tags_in_node_array(erb_while_node->statements, errors);
+        match_tags_in_node_array(erb_while_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_while_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_while_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_while_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_UNTIL_NODE: {
       const AST_ERB_UNTIL_NODE_T* erb_until_node = (const AST_ERB_UNTIL_NODE_T*) node;
 
       if (erb_until_node->statements != NULL) {
-        match_tags_in_node_array(erb_until_node->statements, errors);
+        match_tags_in_node_array(erb_until_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_until_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_until_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_until_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_FOR_NODE: {
       const AST_ERB_FOR_NODE_T* erb_for_node = (const AST_ERB_FOR_NODE_T*) node;
 
       if (erb_for_node->statements != NULL) {
-        match_tags_in_node_array(erb_for_node->statements, errors);
+        match_tags_in_node_array(erb_for_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_for_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_for_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_for_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_RESCUE_NODE: {
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) node;
 
       if (erb_rescue_node->statements != NULL) {
-        match_tags_in_node_array(erb_rescue_node->statements, errors);
+        match_tags_in_node_array(erb_rescue_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_rescue_node->subsequent != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_rescue_node->subsequent, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_rescue_node->subsequent, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_ENSURE_NODE: {
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) node;
 
       if (erb_ensure_node->statements != NULL) {
-        match_tags_in_node_array(erb_ensure_node->statements, errors);
+        match_tags_in_node_array(erb_ensure_node->statements, context->errors, context->options, context->allocator);
       }
     } break;
 
 
+
     case AST_ERB_BEGIN_NODE: {
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) node;
 
       if (erb_begin_node->statements != NULL) {
-        match_tags_in_node_array(erb_begin_node->statements, errors);
+        match_tags_in_node_array(erb_begin_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_begin_node->rescue_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->rescue_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->rescue_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->else_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->ensure_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->ensure_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->ensure_clause, match_tags_visitor, context);
       }
       if (erb_begin_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_begin_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_begin_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
+
     case AST_ERB_UNLESS_NODE: {
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) node;
 
       if (erb_unless_node->statements != NULL) {
-        match_tags_in_node_array(erb_unless_node->statements, errors);
+        match_tags_in_node_array(erb_unless_node->statements, context->errors, context->options, context->allocator);
       }
       if (erb_unless_node->else_clause != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_unless_node->else_clause, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_unless_node->else_clause, match_tags_visitor, context);
       }
       if (erb_unless_node->end_node != NULL) {
-        herb_visit_node((AST_NODE_T*) erb_unless_node->end_node, match_tags_visitor, errors);
+        herb_visit_node((AST_NODE_T*) erb_unless_node->end_node, match_tags_visitor, context);
       }
     } break;
 
 
 
+
+
     case AST_ERB_IN_NODE: {
       const AST_ERB_IN_NODE_T* erb_in_node = (const AST_ERB_IN_NODE_T*) node;
 
       if (erb_in_node->statements != NULL) {
-        match_tags_in_node_array(erb_in_node->statements, errors);
+        match_tags_in_node_array(erb_in_node->statements, context->errors, context->options, context->allocator);
       }
     } break;