@herb-tools/node 0.8.10 → 0.9.0

package/extension/libherb/errors.c

@@ -1,5 +1,5 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.10/templates/src/errors.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/errors.c.erb
 
 #include "include/errors.h"
 #include "include/location.h"
@@ -7,7 +7,9 @@
 #include "include/pretty_print.h"
 #include "include/token.h"
 #include "include/util.h"
+#include "include/util/hb_allocator.h"
 #include "include/util/hb_array.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
 #include <stdbool.h>
@@ -28,658 +30,1052 @@ void error_init(ERROR_T* error, const error_type_T type, position_T start, posit
   error->location.end = end;
 }
 
-UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end) {
-  UNEXPECTED_ERROR_T* unexpected_error = malloc(sizeof(UNEXPECTED_ERROR_T));
+UNEXPECTED_ERROR_T* unexpected_error_init(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_ERROR_T* unexpected_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_ERROR_T));
+
+  if (!unexpected_error) { return NULL; }
 
   error_init(&unexpected_error->base, UNEXPECTED_ERROR, start, end);
 
-  const char* message_template = "%s. Expected: `%s`, found: `%s`.";
-
-  size_t message_size = 417;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, description, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_1, expected, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_2[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_2, found, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_2[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      truncated_argument_1,
-      truncated_argument_2
-    );
-
-    unexpected_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    unexpected_error->base.message = herb_strdup("%s. Expected: `%s`, found: `%s`.");
-  }
+  const char* message_template = "%s. Expected: %s, found: %s.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(description, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(expected, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  hb_string_T truncated_argument_2 = hb_string_truncate(found, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_2 = hb_string_to_c_string_using_malloc(truncated_argument_2);
+
+  char message[413];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : "",
+    truncated_c_string_2 ? truncated_c_string_2 : ""
+  );
 
-  unexpected_error->description = herb_strdup(description);
-  unexpected_error->expected = herb_strdup(expected);
-  unexpected_error->found = herb_strdup(found);
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  if (truncated_c_string_2) { free(truncated_c_string_2); }
+  unexpected_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unexpected_error->description = hb_string_copy(description, allocator);
+  unexpected_error->expected = hb_string_copy(expected, allocator);
+  unexpected_error->found = hb_string_copy(found, allocator);
   return unexpected_error;
 }
 
-void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, unexpected_error_init(description, expected, found, start, end));
+void append_unexpected_error(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unexpected_error_init(description, expected, found, start, end, allocator));
 }
 
-UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end) {
-  UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error = malloc(sizeof(UNEXPECTED_TOKEN_ERROR_T));
+UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error = hb_allocator_alloc(allocator, sizeof(UNEXPECTED_TOKEN_ERROR_T));
+
+  if (!unexpected_token_error) { return NULL; }
 
   error_init(&unexpected_token_error->base, UNEXPECTED_TOKEN_ERROR, start, end);
 
-  const char* message_template = "Found `%s` when expecting `%s` at (%u:%u).";
-
-  size_t message_size = 319;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, token_type_to_string(found->type), ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_1, token_type_to_string(expected_type), ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      truncated_argument_1,
-      found->location.start.line,
-      found->location.start.column
-    );
-
-    unexpected_token_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    unexpected_token_error->base.message = herb_strdup("Found `%s` when expecting `%s` at (%u:%u).");
-  }
+  const char* message_template = "Found %s when expecting %s at (%u:%u).";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(token_type_to_friendly_string(found->type), ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(token_type_to_friendly_string(expected_type), ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  char message[315];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : "",
+    found->location.start.line,
+    found->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  unexpected_token_error->base.message = hb_string_copy(hb_string(message), allocator);
 
   unexpected_token_error->expected_type = expected_type;
-  unexpected_token_error->found = token_copy(found);
+  unexpected_token_error->found = token_copy(found, allocator);
   return unexpected_token_error;
 }
 
-void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, unexpected_token_error_init(expected_type, found, start, end));
+void append_unexpected_token_error(token_type_T expected_type, token_T* found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unexpected_token_error_init(expected_type, found, start, end, allocator));
 }
 
-MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end) {
-  MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error = malloc(sizeof(MISSING_OPENING_TAG_ERROR_T));
+MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error_init(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error = hb_allocator_alloc(allocator, sizeof(MISSING_OPENING_TAG_ERROR_T));
+
+  if (!missing_opening_tag_error) { return NULL; }
 
   error_init(&missing_opening_tag_error->base, MISSING_OPENING_TAG_ERROR, start, end);
 
   const char* message_template = "Found closing tag `</%s>` at (%u:%u) without a matching opening tag in the same scope.";
 
-  size_t message_size = 235;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      closing_tag->location.start.line,
-      closing_tag->location.start.column
-    );
-
-    missing_opening_tag_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    missing_opening_tag_error->base.message = herb_strdup("Found closing tag `</%s>` at (%u:%u) without a matching opening tag in the same scope.");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[235];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    closing_tag->location.start.line,
+    closing_tag->location.start.column
+  );
 
-  missing_opening_tag_error->closing_tag = token_copy(closing_tag);
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  missing_opening_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  missing_opening_tag_error->closing_tag = token_copy(closing_tag, allocator);
   return missing_opening_tag_error;
 }
 
-void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, missing_opening_tag_error_init(closing_tag, start, end));
+void append_missing_opening_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, missing_opening_tag_error_init(closing_tag, start, end, allocator));
 }
 
-MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end) {
-  MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error = malloc(sizeof(MISSING_CLOSING_TAG_ERROR_T));
+MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error = hb_allocator_alloc(allocator, sizeof(MISSING_CLOSING_TAG_ERROR_T));
+
+  if (!missing_closing_tag_error) { return NULL; }
 
   error_init(&missing_closing_tag_error->base, MISSING_CLOSING_TAG_ERROR, start, end);
 
   const char* message_template = "Opening tag `<%s>` at (%u:%u) doesn't have a matching closing tag `</%s>` in the same scope.";
 
-  size_t message_size = 369;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_3, opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      opening_tag->location.start.line,
-      opening_tag->location.start.column,
-      truncated_argument_3
-    );
-
-    missing_closing_tag_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    missing_closing_tag_error->base.message = herb_strdup("Opening tag `<%s>` at (%u:%u) doesn't have a matching closing tag `</%s>` in the same scope.");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_3 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_3 = hb_string_to_c_string_using_malloc(truncated_argument_3);
+
+  char message[369];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column,
+    truncated_c_string_3 ? truncated_c_string_3 : ""
+  );
 
-  missing_closing_tag_error->opening_tag = token_copy(opening_tag);
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_3) { free(truncated_c_string_3); }
+  missing_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  missing_closing_tag_error->opening_tag = token_copy(opening_tag, allocator);
   return missing_closing_tag_error;
 }
 
-void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, missing_closing_tag_error_init(opening_tag, start, end));
+void append_missing_closing_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, missing_closing_tag_error_init(opening_tag, start, end, allocator));
 }
 
-TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end) {
-  TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error = malloc(sizeof(TAG_NAMES_MISMATCH_ERROR_T));
+TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error_init(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error = hb_allocator_alloc(allocator, sizeof(TAG_NAMES_MISMATCH_ERROR_T));
+
+  if (!tag_names_mismatch_error) { return NULL; }
 
   error_init(&tag_names_mismatch_error->base, TAG_NAMES_MISMATCH_ERROR, start, end);
 
   const char* message_template = "Opening tag `<%s>` at (%u:%u) closed with `</%s>` at (%u:%u).";
 
-  size_t message_size = 358;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_3, closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      opening_tag->location.start.line,
-      opening_tag->location.start.column,
-      truncated_argument_3,
-      closing_tag->location.start.line,
-      closing_tag->location.start.column
-    );
-
-    tag_names_mismatch_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    tag_names_mismatch_error->base.message = herb_strdup("Opening tag `<%s>` at (%u:%u) closed with `</%s>` at (%u:%u).");
-  }
-
-  tag_names_mismatch_error->opening_tag = token_copy(opening_tag);
-  tag_names_mismatch_error->closing_tag = token_copy(closing_tag);
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_3 = hb_string_truncate(closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_3 = hb_string_to_c_string_using_malloc(truncated_argument_3);
+
+  char message[358];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column,
+    truncated_c_string_3 ? truncated_c_string_3 : "",
+    closing_tag->location.start.line,
+    closing_tag->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_3) { free(truncated_c_string_3); }
+  tag_names_mismatch_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  tag_names_mismatch_error->opening_tag = token_copy(opening_tag, allocator);
+  tag_names_mismatch_error->closing_tag = token_copy(closing_tag, allocator);
   return tag_names_mismatch_error;
 }
 
-void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end));
-}
-
-QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error_init(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end) {
-  QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error = malloc(sizeof(QUOTES_MISMATCH_ERROR_T));
-
-  error_init(&quotes_mismatch_error->base, QUOTES_MISMATCH_ERROR, start, end);
-
-  const char* message_template = "String opened with %s but closed with %s at (%u:%u).";
-
-  size_t message_size = 329;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, opening_quote->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_1, closing_quote->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      truncated_argument_1,
-      closing_quote->location.start.line,
-      closing_quote->location.start.column
-    );
-
-    quotes_mismatch_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    quotes_mismatch_error->base.message = herb_strdup("String opened with %s but closed with %s at (%u:%u).");
-  }
-
-  quotes_mismatch_error->opening_quote = token_copy(opening_quote);
-  quotes_mismatch_error->closing_quote = token_copy(closing_quote);
-  return quotes_mismatch_error;
+void append_tag_names_mismatch_error(token_T* opening_tag, token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, tag_names_mismatch_error_init(opening_tag, closing_tag, start, end, allocator));
 }
 
-void append_quotes_mismatch_error(token_T* opening_quote, token_T* closing_quote, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, quotes_mismatch_error_init(opening_quote, closing_quote, start, end));
-}
+VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator) {
+  VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error = hb_allocator_alloc(allocator, sizeof(VOID_ELEMENT_CLOSING_TAG_ERROR_T));
 
-VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error_init(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end) {
-  VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error = malloc(sizeof(VOID_ELEMENT_CLOSING_TAG_ERROR_T));
+  if (!void_element_closing_tag_error) { return NULL; }
 
   error_init(&void_element_closing_tag_error->base, VOID_ELEMENT_CLOSING_TAG_ERROR, start, end);
 
   const char* message_template = "`%s` is a void element and should not be used as a closing tag. Use `<%s>` or `<%s />` instead of `</%s>`.";
 
-  size_t message_size = 619;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_1, tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_2[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_2, tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_2[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_3, tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_3[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      truncated_argument_1,
-      truncated_argument_2,
-      truncated_argument_3
-    );
-
-    void_element_closing_tag_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    void_element_closing_tag_error->base.message = herb_strdup("`%s` is a void element and should not be used as a closing tag. Use `<%s>` or `<%s />` instead of `</%s>`.");
-  }
-
-  void_element_closing_tag_error->tag_name = token_copy(tag_name);
-  void_element_closing_tag_error->expected = herb_strdup(expected);
-  void_element_closing_tag_error->found = herb_strdup(found);
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  hb_string_T truncated_argument_2 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_2 = hb_string_to_c_string_using_malloc(truncated_argument_2);
+
+  hb_string_T truncated_argument_3 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_3 = hb_string_to_c_string_using_malloc(truncated_argument_3);
+
+  char message[619];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : "",
+    truncated_c_string_2 ? truncated_c_string_2 : "",
+    truncated_c_string_3 ? truncated_c_string_3 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  if (truncated_c_string_2) { free(truncated_c_string_2); }
+  if (truncated_c_string_3) { free(truncated_c_string_3); }
+  void_element_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  void_element_closing_tag_error->tag_name = token_copy(tag_name, allocator);
+  void_element_closing_tag_error->expected = hb_string_copy(expected, allocator);
+  void_element_closing_tag_error->found = hb_string_copy(found, allocator);
   return void_element_closing_tag_error;
 }
 
-void append_void_element_closing_tag_error(token_T* tag_name, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end));
+void append_void_element_closing_tag_error(token_T* tag_name, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, void_element_closing_tag_error_init(tag_name, expected, found, start, end, allocator));
 }
 
-UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end) {
-  UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error = malloc(sizeof(UNCLOSED_ELEMENT_ERROR_T));
+UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_ELEMENT_ERROR_T));
+
+  if (!unclosed_element_error) { return NULL; }
 
   error_init(&unclosed_element_error->base, UNCLOSED_ELEMENT_ERROR, start, end);
 
   const char* message_template = "Tag `<%s>` opened at (%u:%u) was never closed before the end of document.";
 
-  size_t message_size = 222;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      opening_tag->location.start.line,
-      opening_tag->location.start.column
-    );
-
-    unclosed_element_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    unclosed_element_error->base.message = herb_strdup("Tag `<%s>` opened at (%u:%u) was never closed before the end of document.");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
 
-  unclosed_element_error->opening_tag = token_copy(opening_tag);
+  char message[222];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unclosed_element_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_element_error->opening_tag = token_copy(opening_tag, allocator);
   return unclosed_element_error;
 }
 
-void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, unclosed_element_error_init(opening_tag, start, end));
+void append_unclosed_element_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_element_error_init(opening_tag, start, end, allocator));
 }
 
-RUBY_PARSE_ERROR_T* ruby_parse_error_init(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end) {
-  RUBY_PARSE_ERROR_T* ruby_parse_error = malloc(sizeof(RUBY_PARSE_ERROR_T));
+RUBY_PARSE_ERROR_T* ruby_parse_error_init(hb_string_T error_message, hb_string_T diagnostic_id, hb_string_T level, position_T start, position_T end, hb_allocator_T* allocator) {
+  RUBY_PARSE_ERROR_T* ruby_parse_error = hb_allocator_alloc(allocator, sizeof(RUBY_PARSE_ERROR_T));
+
+  if (!ruby_parse_error) { return NULL; }
 
   error_init(&ruby_parse_error->base, RUBY_PARSE_ERROR, start, end);
 
   const char* message_template = "%s: %s";
 
-  size_t message_size = 263;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, diagnostic_id, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    char truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_1, error_message, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_1[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0,
-      truncated_argument_1
-    );
-
-    ruby_parse_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    ruby_parse_error->base.message = herb_strdup("%s: %s");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(diagnostic_id, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(error_message, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  char message[263];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : ""
+  );
 
-  ruby_parse_error->error_message = herb_strdup(error_message);
-  ruby_parse_error->diagnostic_id = herb_strdup(diagnostic_id);
-  ruby_parse_error->level = herb_strdup(level);
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  ruby_parse_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  ruby_parse_error->error_message = hb_string_copy(error_message, allocator);
+  ruby_parse_error->diagnostic_id = hb_string_copy(diagnostic_id, allocator);
+  ruby_parse_error->level = hb_string_copy(level, allocator);
   return ruby_parse_error;
 }
 
-void append_ruby_parse_error(const char* error_message, const char* diagnostic_id, const char* level, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end));
+void append_ruby_parse_error(hb_string_T error_message, hb_string_T diagnostic_id, hb_string_T level, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, ruby_parse_error_init(error_message, diagnostic_id, level, start, end, allocator));
 }
 
-ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* keyword, position_T start, position_T end) {
-  ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error = malloc(sizeof(ERB_CONTROL_FLOW_SCOPE_ERROR_T));
+ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator) {
+  ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error = hb_allocator_alloc(allocator, sizeof(ERB_CONTROL_FLOW_SCOPE_ERROR_T));
+
+  if (!erb_control_flow_scope_error) { return NULL; }
 
   error_init(&erb_control_flow_scope_error->base, ERB_CONTROL_FLOW_SCOPE_ERROR, start, end);
 
   const char* message_template = "%s appears outside its control flow block. Keep ERB control flow statements together within the same HTML scope (tag, attribute, or content).";
 
-  size_t message_size = 270;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0
-    );
-
-    erb_control_flow_scope_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    erb_control_flow_scope_error->base.message = herb_strdup("%s appears outside its control flow block. Keep ERB control flow statements together within the same HTML scope (tag, attribute, or content).");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[270];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  erb_control_flow_scope_error->base.message = hb_string_copy(hb_string(message), allocator);
 
-  erb_control_flow_scope_error->keyword = herb_strdup(keyword);
+  erb_control_flow_scope_error->keyword = hb_string_copy(keyword, allocator);
   return erb_control_flow_scope_error;
 }
 
-void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, erb_control_flow_scope_error_init(keyword, start, end));
+void append_erb_control_flow_scope_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, erb_control_flow_scope_error_init(keyword, start, end, allocator));
 }
 
-MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end) {
-  MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error = malloc(sizeof(MISSINGERB_END_TAG_ERROR_T));
+MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error_init(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator) {
+  MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error = hb_allocator_alloc(allocator, sizeof(MISSING_ERB_END_TAG_ERROR_T));
 
-  error_init(&missingerb_end_tag_error->base, MISSINGERB_END_TAG_ERROR, start, end);
+  if (!missing_erb_end_tag_error) { return NULL; }
+
+  error_init(&missing_erb_end_tag_error->base, MISSING_ERB_END_TAG_ERROR, start, end);
 
   const char* message_template = "%s started here but never closed with an end tag. The end tag may be in a different scope.";
 
-  size_t message_size = 219;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    char truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_0, keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_0[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
-
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      truncated_argument_0
-    );
-
-    missingerb_end_tag_error->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    missingerb_end_tag_error->base.message = herb_strdup("%s started here but never closed with an end tag. The end tag may be in a different scope.");
-  }
+  hb_string_T truncated_argument_0 = hb_string_truncate(keyword, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[219];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : ""
+  );
 
-  missingerb_end_tag_error->keyword = herb_strdup(keyword);
-  return missingerb_end_tag_error;
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  missing_erb_end_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  missing_erb_end_tag_error->keyword = hb_string_copy(keyword, allocator);
+  return missing_erb_end_tag_error;
 }
 
-void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, missingerb_end_tag_error_init(keyword, start, end));
+void append_missing_erb_end_tag_error(hb_string_T keyword, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, missing_erb_end_tag_error_init(keyword, start, end, allocator));
 }
 
-ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end) {
-  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error = malloc(sizeof(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T));
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error = hb_allocator_alloc(allocator, sizeof(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T));
+
+  if (!erb_multiple_blocks_in_tag_error) { return NULL; }
 
   error_init(&erb_multiple_blocks_in_tag_error->base, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR, start, end);
 
-  erb_multiple_blocks_in_tag_error->base.message = herb_strdup("Multiple unclosed control flow blocks in a single ERB tag. Split each block into its own ERB tag, or close all blocks within the same tag.");
+  erb_multiple_blocks_in_tag_error->base.message = hb_string_copy(hb_string("Multiple unclosed control flow blocks in a single ERB tag. Split each block into its own ERB tag, or close all blocks within the same tag."), allocator);
 
   return erb_multiple_blocks_in_tag_error;
 }
 
-void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end));
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end, allocator));
 }
 
-ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end) {
-  ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error = malloc(sizeof(ERB_CASE_WITH_CONDITIONS_ERROR_T));
+ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error = hb_allocator_alloc(allocator, sizeof(ERB_CASE_WITH_CONDITIONS_ERROR_T));
+
+  if (!erb_case_with_conditions_error) { return NULL; }
 
   error_init(&erb_case_with_conditions_error->base, ERB_CASE_WITH_CONDITIONS_ERROR, start, end);
 
-  erb_case_with_conditions_error->base.message = herb_strdup("A `case` statement with `when`/`in` in a single ERB tag cannot be formatted. Use separate tags for `case` and its conditions.");
+  erb_case_with_conditions_error->base.message = hb_string_copy(hb_string("A `case` statement with `when`/`in` conditions in a single ERB tag cannot be reliably parsed, compiled, and formatted. Use separate ERB tags for `case` and its conditions (e.g., `<% case x %>` followed by `<% when y %>`)."), allocator);
 
   return erb_case_with_conditions_error;
 }
 
-void append_erb_case_with_conditions_error(position_T start, position_T end, hb_array_T* errors) {
-  hb_array_append(errors, erb_case_with_conditions_error_init(start, end));
+void append_erb_case_with_conditions_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, erb_case_with_conditions_error_init(start, end, allocator));
+}
+
+CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error_init(size_t line, size_t column, position_T start, position_T end, hb_allocator_T* allocator) {
+  CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error = hb_allocator_alloc(allocator, sizeof(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T));
+
+  if (!conditional_element_multiple_tags_error) { return NULL; }
+
+  error_init(&conditional_element_multiple_tags_error->base, CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR, start, end);
+
+  const char* message_template = "Conditional element pattern detected at (%zu:%zu) but the conditional block contains multiple HTML tags. Each conditional element must wrap exactly one opening and one closing tag. Consider nesting the conditionals individually.";
+
+  char message[269];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    line,
+    column
+  );
+
+  conditional_element_multiple_tags_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  conditional_element_multiple_tags_error->line = line;
+  conditional_element_multiple_tags_error->column = column;
+  return conditional_element_multiple_tags_error;
+}
+
+void append_conditional_element_multiple_tags_error(size_t line, size_t column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, conditional_element_multiple_tags_error_init(line, column, start, end, allocator));
+}
+
+CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error_init(hb_string_T tag_name, hb_string_T open_condition, size_t open_line, size_t open_column, hb_string_T close_condition, size_t close_line, size_t close_column, position_T start, position_T end, hb_allocator_T* allocator) {
+  CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error = hb_allocator_alloc(allocator, sizeof(CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T));
+
+  if (!conditional_element_condition_mismatch_error) { return NULL; }
+
+  error_init(&conditional_element_condition_mismatch_error->base, CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR, start, end);
+
+  const char* message_template = "Conditional element `<%s>` has mismatched conditions: opening uses `%s` at (%zu:%zu) but closing uses `%s` at (%zu:%zu). Both conditions must be identical.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_1 = hb_string_truncate(open_condition, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_1 = hb_string_to_c_string_using_malloc(truncated_argument_1);
+
+  hb_string_T truncated_argument_4 = hb_string_truncate(close_condition, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_4 = hb_string_to_c_string_using_malloc(truncated_argument_4);
+
+  char message[620];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    truncated_c_string_1 ? truncated_c_string_1 : "",
+    open_line,
+    open_column,
+    truncated_c_string_4 ? truncated_c_string_4 : "",
+    close_line,
+    close_column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_1) { free(truncated_c_string_1); }
+  if (truncated_c_string_4) { free(truncated_c_string_4); }
+  conditional_element_condition_mismatch_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  conditional_element_condition_mismatch_error->tag_name = hb_string_copy(tag_name, allocator);
+  conditional_element_condition_mismatch_error->open_condition = hb_string_copy(open_condition, allocator);
+  conditional_element_condition_mismatch_error->open_line = open_line;
+  conditional_element_condition_mismatch_error->open_column = open_column;
+  conditional_element_condition_mismatch_error->close_condition = hb_string_copy(close_condition, allocator);
+  conditional_element_condition_mismatch_error->close_line = close_line;
+  conditional_element_condition_mismatch_error->close_column = close_column;
+  return conditional_element_condition_mismatch_error;
+}
+
+void append_conditional_element_condition_mismatch_error(hb_string_T tag_name, hb_string_T open_condition, size_t open_line, size_t open_column, hb_string_T close_condition, size_t close_line, size_t close_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, conditional_element_condition_mismatch_error_init(tag_name, open_condition, open_line, open_column, close_condition, close_line, close_column, start, end, allocator));
+}
+
+INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error_init(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error = hb_allocator_alloc(allocator, sizeof(INVALID_COMMENT_CLOSING_TAG_ERROR_T));
+
+  if (!invalid_comment_closing_tag_error) { return NULL; }
+
+  error_init(&invalid_comment_closing_tag_error->base, INVALID_COMMENT_CLOSING_TAG_ERROR, start, end);
+
+  const char* message_template = "Invalid comment closing tag `%s` at (%u:%u). Use `-->` instead of `--!>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(closing_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[222];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    closing_tag->location.start.line,
+    closing_tag->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  invalid_comment_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  invalid_comment_closing_tag_error->closing_tag = token_copy(closing_tag, allocator);
+  return invalid_comment_closing_tag_error;
+}
+
+void append_invalid_comment_closing_tag_error(token_T* closing_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, invalid_comment_closing_tag_error_init(closing_tag, start, end, allocator));
+}
+
+OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error_init(token_T* opening_tag, position_T insertion_point, position_T start, position_T end, hb_allocator_T* allocator) {
+  OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error = hb_allocator_alloc(allocator, sizeof(OMITTED_CLOSING_TAG_ERROR_T));
+
+  if (!omitted_closing_tag_error) { return NULL; }
+
+  error_init(&omitted_closing_tag_error->base, OMITTED_CLOSING_TAG_ERROR, start, end);
+
+  const char* message_template = "Element `<%s>` at (%u:%u) has its closing tag omitted. While valid HTML, consider adding an explicit `</%s>` closing tag at (%u:%u) for clarity, or set `strict: false` to allow this.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  hb_string_T truncated_argument_3 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_3 = hb_string_to_c_string_using_malloc(truncated_argument_3);
+
+  char message[479];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column,
+    truncated_c_string_3 ? truncated_c_string_3 : "",
+    insertion_point.line,
+    insertion_point.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  if (truncated_c_string_3) { free(truncated_c_string_3); }
+  omitted_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  omitted_closing_tag_error->opening_tag = token_copy(opening_tag, allocator);
+  omitted_closing_tag_error->insertion_point = insertion_point;
+  return omitted_closing_tag_error;
+}
+
+void append_omitted_closing_tag_error(token_T* opening_tag, position_T insertion_point, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, omitted_closing_tag_error_init(opening_tag, insertion_point, start, end, allocator));
+}
+
+UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error_init(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_OPEN_TAG_ERROR_T));
+
+  if (!unclosed_open_tag_error) { return NULL; }
+
+  error_init(&unclosed_open_tag_error->base, UNCLOSED_OPEN_TAG_ERROR, start, end);
+
+  const char* message_template = "Opening tag `<%s>` at (%u:%u) is missing closing `>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[202];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    tag_name->location.start.line,
+    tag_name->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unclosed_open_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_open_tag_error->tag_name = token_copy(tag_name, allocator);
+  return unclosed_open_tag_error;
+}
+
+void append_unclosed_open_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_open_tag_error_init(tag_name, start, end, allocator));
+}
+
+UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error_init(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_CLOSE_TAG_ERROR_T));
+
+  if (!unclosed_close_tag_error) { return NULL; }
+
+  error_init(&unclosed_close_tag_error->base, UNCLOSED_CLOSE_TAG_ERROR, start, end);
+
+  const char* message_template = "Closing tag `</%s>` at (%u:%u) is missing closing `>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(tag_name->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[203];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    tag_name->location.start.line,
+    tag_name->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unclosed_close_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_close_tag_error->tag_name = token_copy(tag_name, allocator);
+  return unclosed_close_tag_error;
+}
+
+void append_unclosed_close_tag_error(token_T* tag_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_close_tag_error_init(tag_name, start, end, allocator));
+}
+
+UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error_init(token_T* opening_quote, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_QUOTE_ERROR_T));
+
+  if (!unclosed_quote_error) { return NULL; }
+
+  error_init(&unclosed_quote_error->base, UNCLOSED_QUOTE_ERROR, start, end);
+
+  const char* message_template = "Attribute value opened with %s at (%u:%u) was never closed.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_quote->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[208];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_quote->location.start.line,
+    opening_quote->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unclosed_quote_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_quote_error->opening_quote = token_copy(opening_quote, allocator);
+  return unclosed_quote_error;
+}
+
+void append_unclosed_quote_error(token_T* opening_quote, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_quote_error_init(opening_quote, start, end, allocator));
 }
 
-const char* error_type_to_string(ERROR_T* error) {
+MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error_init(hb_string_T attribute_name, position_T start, position_T end, hb_allocator_T* allocator) {
+  MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error = hb_allocator_alloc(allocator, sizeof(MISSING_ATTRIBUTE_VALUE_ERROR_T));
+
+  if (!missing_attribute_value_error) { return NULL; }
+
+  error_init(&missing_attribute_value_error->base, MISSING_ATTRIBUTE_VALUE_ERROR, start, end);
+
+  const char* message_template = "Attribute `%s` at (%u:%u) is missing a value after the equals sign.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(attribute_name, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[216];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    start.line,
+    start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  missing_attribute_value_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  missing_attribute_value_error->attribute_name = hb_string_copy(attribute_name, allocator);
+  return missing_attribute_value_error;
+}
+
+void append_missing_attribute_value_error(hb_string_T attribute_name, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, missing_attribute_value_error_init(attribute_name, start, end, allocator));
+}
+
+UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error_init(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator) {
+  UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error = hb_allocator_alloc(allocator, sizeof(UNCLOSED_ERB_TAG_ERROR_T));
+
+  if (!unclosed_erb_tag_error) { return NULL; }
+
+  error_init(&unclosed_erb_tag_error->base, UNCLOSED_ERB_TAG_ERROR, start, end);
+
+  const char* message_template = "ERB tag `%s` at (%u:%u) is missing closing `%%>`.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[198];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  unclosed_erb_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  unclosed_erb_tag_error->opening_tag = token_copy(opening_tag, allocator);
+  return unclosed_erb_tag_error;
+}
+
+void append_unclosed_erb_tag_error(token_T* opening_tag, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, unclosed_erb_tag_error_init(opening_tag, start, end, allocator));
+}
+
+STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error_init(position_T start, position_T end, hb_allocator_T* allocator) {
+  STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error = hb_allocator_alloc(allocator, sizeof(STRAY_ERB_CLOSING_TAG_ERROR_T));
+
+  if (!stray_erb_closing_tag_error) { return NULL; }
+
+  error_init(&stray_erb_closing_tag_error->base, STRAY_ERB_CLOSING_TAG_ERROR, start, end);
+
+  const char* message_template = "Stray `%%>` found at (%u:%u). This closing delimiter is not part of an ERB tag and will be treated as plain text. If you want a literal `%%>`, use the HTML entities `&percnt;&gt;` instead.";
+
+  char message[209];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    start.line,
+    start.column
+  );
+
+  stray_erb_closing_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  return stray_erb_closing_tag_error;
+}
+
+void append_stray_erb_closing_tag_error(position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, stray_erb_closing_tag_error_init(start, end, allocator));
+}
+
+NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error_init(token_T* opening_tag, size_t nested_tag_line, size_t nested_tag_column, position_T start, position_T end, hb_allocator_T* allocator) {
+  NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error = hb_allocator_alloc(allocator, sizeof(NESTED_ERB_TAG_ERROR_T));
+
+  if (!nested_erb_tag_error) { return NULL; }
+
+  error_init(&nested_erb_tag_error->base, NESTED_ERB_TAG_ERROR, start, end);
+
+  const char* message_template = "ERB tag `%s` at (%u:%u) was terminated by nested `<%%` tag at (%zu:%zu). Nesting `<%%` tags is not supported.";
+
+  hb_string_T truncated_argument_0 = hb_string_truncate(opening_tag->value, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_0 = hb_string_to_c_string_using_malloc(truncated_argument_0);
+
+  char message[298];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    truncated_c_string_0 ? truncated_c_string_0 : "",
+    opening_tag->location.start.line,
+    opening_tag->location.start.column,
+    nested_tag_line,
+    nested_tag_column
+  );
+
+  if (truncated_c_string_0) { free(truncated_c_string_0); }
+  nested_erb_tag_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  nested_erb_tag_error->opening_tag = token_copy(opening_tag, allocator);
+  nested_erb_tag_error->nested_tag_line = nested_tag_line;
+  nested_erb_tag_error->nested_tag_column = nested_tag_column;
+  return nested_erb_tag_error;
+}
+
+void append_nested_erb_tag_error(token_T* opening_tag, size_t nested_tag_line, size_t nested_tag_column, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, nested_erb_tag_error_init(opening_tag, nested_tag_line, nested_tag_column, start, end, allocator));
+}
+
+hb_string_T error_type_to_string(ERROR_T* error) {
   switch (error->type) {
-    case UNEXPECTED_ERROR: return "UNEXPECTED_ERROR";
-    case UNEXPECTED_TOKEN_ERROR: return "UNEXPECTED_TOKEN_ERROR";
-    case MISSING_OPENING_TAG_ERROR: return "MISSING_OPENING_TAG_ERROR";
-    case MISSING_CLOSING_TAG_ERROR: return "MISSING_CLOSING_TAG_ERROR";
-    case TAG_NAMES_MISMATCH_ERROR: return "TAG_NAMES_MISMATCH_ERROR";
-    case QUOTES_MISMATCH_ERROR: return "QUOTES_MISMATCH_ERROR";
-    case VOID_ELEMENT_CLOSING_TAG_ERROR: return "VOID_ELEMENT_CLOSING_TAG_ERROR";
-    case UNCLOSED_ELEMENT_ERROR: return "UNCLOSED_ELEMENT_ERROR";
-    case RUBY_PARSE_ERROR: return "RUBY_PARSE_ERROR";
-    case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERB_CONTROL_FLOW_SCOPE_ERROR";
-    case MISSINGERB_END_TAG_ERROR: return "MISSINGERB_END_TAG_ERROR";
-    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR";
-    case ERB_CASE_WITH_CONDITIONS_ERROR: return "ERB_CASE_WITH_CONDITIONS_ERROR";
+    case UNEXPECTED_ERROR: return hb_string("UNEXPECTED_ERROR");
+    case UNEXPECTED_TOKEN_ERROR: return hb_string("UNEXPECTED_TOKEN_ERROR");
+    case MISSING_OPENING_TAG_ERROR: return hb_string("MISSING_OPENING_TAG_ERROR");
+    case MISSING_CLOSING_TAG_ERROR: return hb_string("MISSING_CLOSING_TAG_ERROR");
+    case TAG_NAMES_MISMATCH_ERROR: return hb_string("TAG_NAMES_MISMATCH_ERROR");
+    case VOID_ELEMENT_CLOSING_TAG_ERROR: return hb_string("VOID_ELEMENT_CLOSING_TAG_ERROR");
+    case UNCLOSED_ELEMENT_ERROR: return hb_string("UNCLOSED_ELEMENT_ERROR");
+    case RUBY_PARSE_ERROR: return hb_string("RUBY_PARSE_ERROR");
+    case ERB_CONTROL_FLOW_SCOPE_ERROR: return hb_string("ERB_CONTROL_FLOW_SCOPE_ERROR");
+    case MISSING_ERB_END_TAG_ERROR: return hb_string("MISSING_ERB_END_TAG_ERROR");
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return hb_string("ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR");
+    case ERB_CASE_WITH_CONDITIONS_ERROR: return hb_string("ERB_CASE_WITH_CONDITIONS_ERROR");
+    case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: return hb_string("CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR");
+    case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: return hb_string("CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR");
+    case INVALID_COMMENT_CLOSING_TAG_ERROR: return hb_string("INVALID_COMMENT_CLOSING_TAG_ERROR");
+    case OMITTED_CLOSING_TAG_ERROR: return hb_string("OMITTED_CLOSING_TAG_ERROR");
+    case UNCLOSED_OPEN_TAG_ERROR: return hb_string("UNCLOSED_OPEN_TAG_ERROR");
+    case UNCLOSED_CLOSE_TAG_ERROR: return hb_string("UNCLOSED_CLOSE_TAG_ERROR");
+    case UNCLOSED_QUOTE_ERROR: return hb_string("UNCLOSED_QUOTE_ERROR");
+    case MISSING_ATTRIBUTE_VALUE_ERROR: return hb_string("MISSING_ATTRIBUTE_VALUE_ERROR");
+    case UNCLOSED_ERB_TAG_ERROR: return hb_string("UNCLOSED_ERB_TAG_ERROR");
+    case STRAY_ERB_CLOSING_TAG_ERROR: return hb_string("STRAY_ERB_CLOSING_TAG_ERROR");
+    case NESTED_ERB_TAG_ERROR: return hb_string("NESTED_ERB_TAG_ERROR");
   }
 
-  return "Unknown error_type_T";
+  return hb_string("Unknown error_type_T");
 }
 
-const char* error_human_type(ERROR_T* error) {
+hb_string_T error_human_type(ERROR_T* error) {
   switch (error->type) {
-    case UNEXPECTED_ERROR: return "UnexpectedError";
-    case UNEXPECTED_TOKEN_ERROR: return "UnexpectedTokenError";
-    case MISSING_OPENING_TAG_ERROR: return "MissingOpeningTagError";
-    case MISSING_CLOSING_TAG_ERROR: return "MissingClosingTagError";
-    case TAG_NAMES_MISMATCH_ERROR: return "TagNamesMismatchError";
-    case QUOTES_MISMATCH_ERROR: return "QuotesMismatchError";
-    case VOID_ELEMENT_CLOSING_TAG_ERROR: return "VoidElementClosingTagError";
-    case UNCLOSED_ELEMENT_ERROR: return "UnclosedElementError";
-    case RUBY_PARSE_ERROR: return "RubyParseError";
-    case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERBControlFlowScopeError";
-    case MISSINGERB_END_TAG_ERROR: return "MissingERBEndTagError";
-    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERBMultipleBlocksInTagError";
-    case ERB_CASE_WITH_CONDITIONS_ERROR: return "ERBCaseWithConditionsError";
+    case UNEXPECTED_ERROR: return hb_string("UnexpectedError");
+    case UNEXPECTED_TOKEN_ERROR: return hb_string("UnexpectedTokenError");
+    case MISSING_OPENING_TAG_ERROR: return hb_string("MissingOpeningTagError");
+    case MISSING_CLOSING_TAG_ERROR: return hb_string("MissingClosingTagError");
+    case TAG_NAMES_MISMATCH_ERROR: return hb_string("TagNamesMismatchError");
+    case VOID_ELEMENT_CLOSING_TAG_ERROR: return hb_string("VoidElementClosingTagError");
+    case UNCLOSED_ELEMENT_ERROR: return hb_string("UnclosedElementError");
+    case RUBY_PARSE_ERROR: return hb_string("RubyParseError");
+    case ERB_CONTROL_FLOW_SCOPE_ERROR: return hb_string("ERBControlFlowScopeError");
+    case MISSING_ERB_END_TAG_ERROR: return hb_string("MissingERBEndTagError");
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return hb_string("ERBMultipleBlocksInTagError");
+    case ERB_CASE_WITH_CONDITIONS_ERROR: return hb_string("ERBCaseWithConditionsError");
+    case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: return hb_string("ConditionalElementMultipleTagsError");
+    case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: return hb_string("ConditionalElementConditionMismatchError");
+    case INVALID_COMMENT_CLOSING_TAG_ERROR: return hb_string("InvalidCommentClosingTagError");
+    case OMITTED_CLOSING_TAG_ERROR: return hb_string("OmittedClosingTagError");
+    case UNCLOSED_OPEN_TAG_ERROR: return hb_string("UnclosedOpenTagError");
+    case UNCLOSED_CLOSE_TAG_ERROR: return hb_string("UnclosedCloseTagError");
+    case UNCLOSED_QUOTE_ERROR: return hb_string("UnclosedQuoteError");
+    case MISSING_ATTRIBUTE_VALUE_ERROR: return hb_string("MissingAttributeValueError");
+    case UNCLOSED_ERB_TAG_ERROR: return hb_string("UnclosedERBTagError");
+    case STRAY_ERB_CLOSING_TAG_ERROR: return hb_string("StrayERBClosingTagError");
+    case NESTED_ERB_TAG_ERROR: return hb_string("NestedERBTagError");
   }
 
-  return "Unknown error_type_T";
+  return hb_string("Unknown error_type_T");
 }
 
-void error_free_base_error(ERROR_T* error) {
+void error_free_base_error(ERROR_T* error, hb_allocator_T* allocator) {
   if (error == NULL) { return; }
 
-  if (error->message != NULL) { free(error->message); }
+  if (!hb_string_is_null(error->message)) { hb_allocator_dealloc(allocator, error->message.data); }
 
-  free(error);
+  hb_allocator_dealloc(allocator, error);
 }
 
-static void error_free_unexpected_error(UNEXPECTED_ERROR_T* unexpected_error) {
-  if (unexpected_error->description != NULL) { free((char*) unexpected_error->description); }
-  if (unexpected_error->expected != NULL) { free((char*) unexpected_error->expected); }
-  if (unexpected_error->found != NULL) { free((char*) unexpected_error->found); }
+static void error_free_unexpected_error(UNEXPECTED_ERROR_T* unexpected_error, hb_allocator_T* allocator) {
+  if (unexpected_error->description.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->description.data); }
+  if (unexpected_error->expected.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->expected.data); }
+  if (unexpected_error->found.data != NULL) { hb_allocator_dealloc(allocator, unexpected_error->found.data); }
 
-  error_free_base_error(&unexpected_error->base);
+  error_free_base_error(&unexpected_error->base, allocator);
 }
 
-static void error_free_unexpected_token_error(UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error) {
+static void error_free_unexpected_token_error(UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error, hb_allocator_T* allocator) {
   // token_type_T is part of struct
-  if (unexpected_token_error->found != NULL) { token_free(unexpected_token_error->found); }
+  if (unexpected_token_error->found != NULL) { token_free(unexpected_token_error->found, allocator); }
 
-  error_free_base_error(&unexpected_token_error->base);
+  error_free_base_error(&unexpected_token_error->base, allocator);
 }
 
-static void error_free_missing_opening_tag_error(MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error) {
-  if (missing_opening_tag_error->closing_tag != NULL) { token_free(missing_opening_tag_error->closing_tag); }
+static void error_free_missing_opening_tag_error(MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error, hb_allocator_T* allocator) {
+  if (missing_opening_tag_error->closing_tag != NULL) { token_free(missing_opening_tag_error->closing_tag, allocator); }
 
-  error_free_base_error(&missing_opening_tag_error->base);
+  error_free_base_error(&missing_opening_tag_error->base, allocator);
 }
 
-static void error_free_missing_closing_tag_error(MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error) {
-  if (missing_closing_tag_error->opening_tag != NULL) { token_free(missing_closing_tag_error->opening_tag); }
+static void error_free_missing_closing_tag_error(MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error, hb_allocator_T* allocator) {
+  if (missing_closing_tag_error->opening_tag != NULL) { token_free(missing_closing_tag_error->opening_tag, allocator); }
 
-  error_free_base_error(&missing_closing_tag_error->base);
+  error_free_base_error(&missing_closing_tag_error->base, allocator);
 }
 
-static void error_free_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error) {
-  if (tag_names_mismatch_error->opening_tag != NULL) { token_free(tag_names_mismatch_error->opening_tag); }
-  if (tag_names_mismatch_error->closing_tag != NULL) { token_free(tag_names_mismatch_error->closing_tag); }
+static void error_free_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error, hb_allocator_T* allocator) {
+  if (tag_names_mismatch_error->opening_tag != NULL) { token_free(tag_names_mismatch_error->opening_tag, allocator); }
+  if (tag_names_mismatch_error->closing_tag != NULL) { token_free(tag_names_mismatch_error->closing_tag, allocator); }
 
-  error_free_base_error(&tag_names_mismatch_error->base);
+  error_free_base_error(&tag_names_mismatch_error->base, allocator);
 }
 
-static void error_free_quotes_mismatch_error(QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error) {
-  if (quotes_mismatch_error->opening_quote != NULL) { token_free(quotes_mismatch_error->opening_quote); }
-  if (quotes_mismatch_error->closing_quote != NULL) { token_free(quotes_mismatch_error->closing_quote); }
+static void error_free_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error, hb_allocator_T* allocator) {
+  if (void_element_closing_tag_error->tag_name != NULL) { token_free(void_element_closing_tag_error->tag_name, allocator); }
+  if (void_element_closing_tag_error->expected.data != NULL) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->expected.data); }
+  if (void_element_closing_tag_error->found.data != NULL) { hb_allocator_dealloc(allocator, void_element_closing_tag_error->found.data); }
 
-  error_free_base_error(&quotes_mismatch_error->base);
+  error_free_base_error(&void_element_closing_tag_error->base, allocator);
 }
 
-static void error_free_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error) {
-  if (void_element_closing_tag_error->tag_name != NULL) { token_free(void_element_closing_tag_error->tag_name); }
-  if (void_element_closing_tag_error->expected != NULL) { free((char*) void_element_closing_tag_error->expected); }
-  if (void_element_closing_tag_error->found != NULL) { free((char*) void_element_closing_tag_error->found); }
+static void error_free_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error, hb_allocator_T* allocator) {
+  if (unclosed_element_error->opening_tag != NULL) { token_free(unclosed_element_error->opening_tag, allocator); }
 
-  error_free_base_error(&void_element_closing_tag_error->base);
+  error_free_base_error(&unclosed_element_error->base, allocator);
 }
 
-static void error_free_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error) {
-  if (unclosed_element_error->opening_tag != NULL) { token_free(unclosed_element_error->opening_tag); }
+static void error_free_ruby_parse_error(RUBY_PARSE_ERROR_T* ruby_parse_error, hb_allocator_T* allocator) {
+  if (ruby_parse_error->error_message.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->error_message.data); }
+  if (ruby_parse_error->diagnostic_id.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->diagnostic_id.data); }
+  if (ruby_parse_error->level.data != NULL) { hb_allocator_dealloc(allocator, ruby_parse_error->level.data); }
 
-  error_free_base_error(&unclosed_element_error->base);
+  error_free_base_error(&ruby_parse_error->base, allocator);
 }
 
-static void error_free_ruby_parse_error(RUBY_PARSE_ERROR_T* ruby_parse_error) {
-  if (ruby_parse_error->error_message != NULL) { free((char*) ruby_parse_error->error_message); }
-  if (ruby_parse_error->diagnostic_id != NULL) { free((char*) ruby_parse_error->diagnostic_id); }
-  if (ruby_parse_error->level != NULL) { free((char*) ruby_parse_error->level); }
+static void error_free_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error, hb_allocator_T* allocator) {
+  if (erb_control_flow_scope_error->keyword.data != NULL) { hb_allocator_dealloc(allocator, erb_control_flow_scope_error->keyword.data); }
 
-  error_free_base_error(&ruby_parse_error->base);
+  error_free_base_error(&erb_control_flow_scope_error->base, allocator);
 }
 
-static void error_free_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error) {
-  if (erb_control_flow_scope_error->keyword != NULL) { free((char*) erb_control_flow_scope_error->keyword); }
+static void error_free_missing_erb_end_tag_error(MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error, hb_allocator_T* allocator) {
+  if (missing_erb_end_tag_error->keyword.data != NULL) { hb_allocator_dealloc(allocator, missing_erb_end_tag_error->keyword.data); }
 
-  error_free_base_error(&erb_control_flow_scope_error->base);
+  error_free_base_error(&missing_erb_end_tag_error->base, allocator);
 }
 
-static void error_free_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error) {
-  if (missingerb_end_tag_error->keyword != NULL) { free((char*) missingerb_end_tag_error->keyword); }
+static void error_free_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error, hb_allocator_T* allocator) {
+  /* no ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T specific fields to free up */
 
-  error_free_base_error(&missingerb_end_tag_error->base);
+  error_free_base_error(&erb_multiple_blocks_in_tag_error->base, allocator);
 }
 
-static void error_free_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error) {
-  /* no ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T specific fields to free up */
+static void error_free_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error, hb_allocator_T* allocator) {
+  /* no ERB_CASE_WITH_CONDITIONS_ERROR_T specific fields to free up */
 
-  error_free_base_error(&erb_multiple_blocks_in_tag_error->base);
+  error_free_base_error(&erb_case_with_conditions_error->base, allocator);
 }
 
-static void error_free_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error) {
-  /* no ERB_CASE_WITH_CONDITIONS_ERROR_T specific fields to free up */
+static void error_free_conditional_element_multiple_tags_error(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error, hb_allocator_T* allocator) {
+  // size_t is part of struct
+  // size_t is part of struct
+
+  error_free_base_error(&conditional_element_multiple_tags_error->base, allocator);
+}
+
+static void error_free_conditional_element_condition_mismatch_error(CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error, hb_allocator_T* allocator) {
+  if (conditional_element_condition_mismatch_error->tag_name.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->tag_name.data); }
+  if (conditional_element_condition_mismatch_error->open_condition.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->open_condition.data); }
+  // size_t is part of struct
+  // size_t is part of struct
+  if (conditional_element_condition_mismatch_error->close_condition.data != NULL) { hb_allocator_dealloc(allocator, conditional_element_condition_mismatch_error->close_condition.data); }
+  // size_t is part of struct
+  // size_t is part of struct
+
+  error_free_base_error(&conditional_element_condition_mismatch_error->base, allocator);
+}
+
+static void error_free_invalid_comment_closing_tag_error(INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error, hb_allocator_T* allocator) {
+  if (invalid_comment_closing_tag_error->closing_tag != NULL) { token_free(invalid_comment_closing_tag_error->closing_tag, allocator); }
+
+  error_free_base_error(&invalid_comment_closing_tag_error->base, allocator);
+}
+
+static void error_free_omitted_closing_tag_error(OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error, hb_allocator_T* allocator) {
+  if (omitted_closing_tag_error->opening_tag != NULL) { token_free(omitted_closing_tag_error->opening_tag, allocator); }
+  // position_T is part of struct
+
+  error_free_base_error(&omitted_closing_tag_error->base, allocator);
+}
+
+static void error_free_unclosed_open_tag_error(UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error, hb_allocator_T* allocator) {
+  if (unclosed_open_tag_error->tag_name != NULL) { token_free(unclosed_open_tag_error->tag_name, allocator); }
+
+  error_free_base_error(&unclosed_open_tag_error->base, allocator);
+}
+
+static void error_free_unclosed_close_tag_error(UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error, hb_allocator_T* allocator) {
+  if (unclosed_close_tag_error->tag_name != NULL) { token_free(unclosed_close_tag_error->tag_name, allocator); }
+
+  error_free_base_error(&unclosed_close_tag_error->base, allocator);
+}
+
+static void error_free_unclosed_quote_error(UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error, hb_allocator_T* allocator) {
+  if (unclosed_quote_error->opening_quote != NULL) { token_free(unclosed_quote_error->opening_quote, allocator); }
+
+  error_free_base_error(&unclosed_quote_error->base, allocator);
+}
+
+static void error_free_missing_attribute_value_error(MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error, hb_allocator_T* allocator) {
+  if (missing_attribute_value_error->attribute_name.data != NULL) { hb_allocator_dealloc(allocator, missing_attribute_value_error->attribute_name.data); }
+
+  error_free_base_error(&missing_attribute_value_error->base, allocator);
+}
+
+static void error_free_unclosed_erb_tag_error(UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error, hb_allocator_T* allocator) {
+  if (unclosed_erb_tag_error->opening_tag != NULL) { token_free(unclosed_erb_tag_error->opening_tag, allocator); }
+
+  error_free_base_error(&unclosed_erb_tag_error->base, allocator);
+}
+
+static void error_free_stray_erb_closing_tag_error(STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error, hb_allocator_T* allocator) {
+  /* no STRAY_ERB_CLOSING_TAG_ERROR_T specific fields to free up */
+
+  error_free_base_error(&stray_erb_closing_tag_error->base, allocator);
+}
+
+static void error_free_nested_erb_tag_error(NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error, hb_allocator_T* allocator) {
+  if (nested_erb_tag_error->opening_tag != NULL) { token_free(nested_erb_tag_error->opening_tag, allocator); }
+  // size_t is part of struct
+  // size_t is part of struct
 
-  error_free_base_error(&erb_case_with_conditions_error->base);
+  error_free_base_error(&nested_erb_tag_error->base, allocator);
 }
 
-void error_free(ERROR_T* error) {
+void error_free(ERROR_T* error, hb_allocator_T* allocator) {
   if (!error) { return; }
 
   switch (error->type) {
-    case UNEXPECTED_ERROR: error_free_unexpected_error((UNEXPECTED_ERROR_T*) error); break;
-    case UNEXPECTED_TOKEN_ERROR: error_free_unexpected_token_error((UNEXPECTED_TOKEN_ERROR_T*) error); break;
-    case MISSING_OPENING_TAG_ERROR: error_free_missing_opening_tag_error((MISSING_OPENING_TAG_ERROR_T*) error); break;
-    case MISSING_CLOSING_TAG_ERROR: error_free_missing_closing_tag_error((MISSING_CLOSING_TAG_ERROR_T*) error); break;
-    case TAG_NAMES_MISMATCH_ERROR: error_free_tag_names_mismatch_error((TAG_NAMES_MISMATCH_ERROR_T*) error); break;
-    case QUOTES_MISMATCH_ERROR: error_free_quotes_mismatch_error((QUOTES_MISMATCH_ERROR_T*) error); break;
-    case VOID_ELEMENT_CLOSING_TAG_ERROR: error_free_void_element_closing_tag_error((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error); break;
-    case UNCLOSED_ELEMENT_ERROR: error_free_unclosed_element_error((UNCLOSED_ELEMENT_ERROR_T*) error); break;
-    case RUBY_PARSE_ERROR: error_free_ruby_parse_error((RUBY_PARSE_ERROR_T*) error); break;
-    case ERB_CONTROL_FLOW_SCOPE_ERROR: error_free_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error); break;
-    case MISSINGERB_END_TAG_ERROR: error_free_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error); break;
-    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_free_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error); break;
-    case ERB_CASE_WITH_CONDITIONS_ERROR: error_free_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error); break;
+    case UNEXPECTED_ERROR: error_free_unexpected_error((UNEXPECTED_ERROR_T*) error, allocator); break;
+    case UNEXPECTED_TOKEN_ERROR: error_free_unexpected_token_error((UNEXPECTED_TOKEN_ERROR_T*) error, allocator); break;
+    case MISSING_OPENING_TAG_ERROR: error_free_missing_opening_tag_error((MISSING_OPENING_TAG_ERROR_T*) error, allocator); break;
+    case MISSING_CLOSING_TAG_ERROR: error_free_missing_closing_tag_error((MISSING_CLOSING_TAG_ERROR_T*) error, allocator); break;
+    case TAG_NAMES_MISMATCH_ERROR: error_free_tag_names_mismatch_error((TAG_NAMES_MISMATCH_ERROR_T*) error, allocator); break;
+    case VOID_ELEMENT_CLOSING_TAG_ERROR: error_free_void_element_closing_tag_error((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error, allocator); break;
+    case UNCLOSED_ELEMENT_ERROR: error_free_unclosed_element_error((UNCLOSED_ELEMENT_ERROR_T*) error, allocator); break;
+    case RUBY_PARSE_ERROR: error_free_ruby_parse_error((RUBY_PARSE_ERROR_T*) error, allocator); break;
+    case ERB_CONTROL_FLOW_SCOPE_ERROR: error_free_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error, allocator); break;
+    case MISSING_ERB_END_TAG_ERROR: error_free_missing_erb_end_tag_error((MISSING_ERB_END_TAG_ERROR_T*) error, allocator); break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_free_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, allocator); break;
+    case ERB_CASE_WITH_CONDITIONS_ERROR: error_free_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error, allocator); break;
+    case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: error_free_conditional_element_multiple_tags_error((CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T*) error, allocator); break;
+    case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: error_free_conditional_element_condition_mismatch_error((CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T*) error, allocator); break;
+    case INVALID_COMMENT_CLOSING_TAG_ERROR: error_free_invalid_comment_closing_tag_error((INVALID_COMMENT_CLOSING_TAG_ERROR_T*) error, allocator); break;
+    case OMITTED_CLOSING_TAG_ERROR: error_free_omitted_closing_tag_error((OMITTED_CLOSING_TAG_ERROR_T*) error, allocator); break;
+    case UNCLOSED_OPEN_TAG_ERROR: error_free_unclosed_open_tag_error((UNCLOSED_OPEN_TAG_ERROR_T*) error, allocator); break;
+    case UNCLOSED_CLOSE_TAG_ERROR: error_free_unclosed_close_tag_error((UNCLOSED_CLOSE_TAG_ERROR_T*) error, allocator); break;
+    case UNCLOSED_QUOTE_ERROR: error_free_unclosed_quote_error((UNCLOSED_QUOTE_ERROR_T*) error, allocator); break;
+    case MISSING_ATTRIBUTE_VALUE_ERROR: error_free_missing_attribute_value_error((MISSING_ATTRIBUTE_VALUE_ERROR_T*) error, allocator); break;
+    case UNCLOSED_ERB_TAG_ERROR: error_free_unclosed_erb_tag_error((UNCLOSED_ERB_TAG_ERROR_T*) error, allocator); break;
+    case STRAY_ERB_CLOSING_TAG_ERROR: error_free_stray_erb_closing_tag_error((STRAY_ERB_CLOSING_TAG_ERROR_T*) error, allocator); break;
+    case NESTED_ERB_TAG_ERROR: error_free_nested_erb_tag_error((NESTED_ERB_TAG_ERROR_T*) error, allocator); break;
   }
 }
 
+#ifndef HERB_EXCLUDE_PRETTYPRINT
+
 void error_pretty_print_array(
   const char* name, hb_array_T* array, const size_t indent, const size_t relative_indent, const bool last_property,
   hb_buffer_T* buffer
@@ -728,30 +1124,30 @@ static void error_pretty_print_unexpected_error(UNEXPECTED_ERROR_T* error, const
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("description"), hb_string(error->description), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("expected"), hb_string(error->expected), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("found"), hb_string(error->found), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("description"), error->description, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("expected"), error->expected, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("found"), error->found, indent, relative_indent, true, buffer);
 }
 
 static void error_pretty_print_unexpected_token_error(UNEXPECTED_TOKEN_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_property(hb_string(token_type_to_string(error->expected_type)), hb_string("expected_type"), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_property(token_type_to_string(error->expected_type), hb_string("expected_type"), indent, relative_indent, false, buffer);
   pretty_print_token_property(error->found, hb_string("found"), indent, relative_indent, true, buffer);
 }
 
@@ -759,13 +1155,13 @@ static void error_pretty_print_missing_opening_tag_error(MISSING_OPENING_TAG_ERR
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
   pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
 }
 
@@ -773,13 +1169,13 @@ static void error_pretty_print_missing_closing_tag_error(MISSING_CLOSING_TAG_ERR
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
   pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
 }
 
@@ -787,130 +1183,278 @@ static void error_pretty_print_tag_names_mismatch_error(TAG_NAMES_MISMATCH_ERROR
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
   pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, false, buffer);
   pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_quotes_mismatch_error(QUOTES_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_quote, hb_string("opening_quote"), indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->closing_quote, hb_string("closing_quote"), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("expected"), error->expected, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("found"), error->found, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_void_element_closing_tag_error(VOID_ELEMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("expected"), hb_string(error->expected), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("found"), hb_string(error->found), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_unclosed_element_error(UNCLOSED_ELEMENT_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_ruby_parse_error(RUBY_PARSE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("error_message"), error->error_message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("diagnostic_id"), error->diagnostic_id, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("level"), error->level, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_ruby_parse_error(RUBY_PARSE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("error_message"), hb_string(error->error_message), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("diagnostic_id"), hb_string(error->diagnostic_id), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("level"), hb_string(error->level), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("keyword"), error->keyword, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_erb_control_flow_scope_error(ERB_CONTROL_FLOW_SCOPE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_missing_erb_end_tag_error(MISSING_ERB_END_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("keyword"), error->keyword, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, false, buffer);
-  pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
 }
 
-static void error_pretty_print_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+static void error_pretty_print_conditional_element_multiple_tags_error(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
   hb_buffer_append(buffer, "@ ");
-  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
   hb_buffer_append(buffer, " ");
 
   pretty_print_location(error->base.location, buffer);
   hb_buffer_append(buffer, "\n");
 
-  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, true, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->line, hb_string("line"), indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->column, hb_string("column"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_conditional_element_condition_mismatch_error(CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("tag_name"), error->tag_name, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("open_condition"), error->open_condition, indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->open_line, hb_string("open_line"), indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->open_column, hb_string("open_column"), indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("close_condition"), error->close_condition, indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->close_line, hb_string("close_line"), indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->close_column, hb_string("close_column"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_invalid_comment_closing_tag_error(INVALID_COMMENT_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->closing_tag, hb_string("closing_tag"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_omitted_closing_tag_error(OMITTED_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, false, buffer);
+  pretty_print_position_property(&error->insertion_point, hb_string("insertion_point"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unclosed_open_tag_error(UNCLOSED_OPEN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unclosed_close_tag_error(UNCLOSED_CLOSE_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->tag_name, hb_string("tag_name"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unclosed_quote_error(UNCLOSED_QUOTE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_quote, hb_string("opening_quote"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_missing_attribute_value_error(MISSING_ATTRIBUTE_VALUE_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_quoted_property(hb_string("attribute_name"), error->attribute_name, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_unclosed_erb_tag_error(UNCLOSED_ERB_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_stray_erb_closing_tag_error(STRAY_ERB_CLOSING_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, true, buffer);
+}
+
+static void error_pretty_print_nested_erb_tag_error(NESTED_ERB_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append_string(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_token_property(error->opening_tag, hb_string("opening_tag"), indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->nested_tag_line, hb_string("nested_tag_line"), indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->nested_tag_column, hb_string("nested_tag_column"), indent, relative_indent, true, buffer);
 }
 
 void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
@@ -922,13 +1466,25 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case MISSING_OPENING_TAG_ERROR: error_pretty_print_missing_opening_tag_error((MISSING_OPENING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case MISSING_CLOSING_TAG_ERROR: error_pretty_print_missing_closing_tag_error((MISSING_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case TAG_NAMES_MISMATCH_ERROR: error_pretty_print_tag_names_mismatch_error((TAG_NAMES_MISMATCH_ERROR_T*) error, indent, relative_indent, buffer); break;
-    case QUOTES_MISMATCH_ERROR: error_pretty_print_quotes_mismatch_error((QUOTES_MISMATCH_ERROR_T*) error, indent, relative_indent, buffer); break;
     case VOID_ELEMENT_CLOSING_TAG_ERROR: error_pretty_print_void_element_closing_tag_error((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case UNCLOSED_ELEMENT_ERROR: error_pretty_print_unclosed_element_error((UNCLOSED_ELEMENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     case RUBY_PARSE_ERROR: error_pretty_print_ruby_parse_error((RUBY_PARSE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: error_pretty_print_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error, indent, relative_indent, buffer); break;
-    case MISSINGERB_END_TAG_ERROR: error_pretty_print_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case MISSING_ERB_END_TAG_ERROR: error_pretty_print_missing_erb_end_tag_error((MISSING_ERB_END_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_pretty_print_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_CASE_WITH_CONDITIONS_ERROR: error_pretty_print_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: error_pretty_print_conditional_element_multiple_tags_error((CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: error_pretty_print_conditional_element_condition_mismatch_error((CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case INVALID_COMMENT_CLOSING_TAG_ERROR: error_pretty_print_invalid_comment_closing_tag_error((INVALID_COMMENT_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case OMITTED_CLOSING_TAG_ERROR: error_pretty_print_omitted_closing_tag_error((OMITTED_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNCLOSED_OPEN_TAG_ERROR: error_pretty_print_unclosed_open_tag_error((UNCLOSED_OPEN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNCLOSED_CLOSE_TAG_ERROR: error_pretty_print_unclosed_close_tag_error((UNCLOSED_CLOSE_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNCLOSED_QUOTE_ERROR: error_pretty_print_unclosed_quote_error((UNCLOSED_QUOTE_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case MISSING_ATTRIBUTE_VALUE_ERROR: error_pretty_print_missing_attribute_value_error((MISSING_ATTRIBUTE_VALUE_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case UNCLOSED_ERB_TAG_ERROR: error_pretty_print_unclosed_erb_tag_error((UNCLOSED_ERB_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case STRAY_ERB_CLOSING_TAG_ERROR: error_pretty_print_stray_erb_closing_tag_error((STRAY_ERB_CLOSING_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case NESTED_ERB_TAG_ERROR: error_pretty_print_nested_erb_tag_error((NESTED_ERB_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }
+
+#endif