herb 0.8.10-arm-linux-gnu → 0.9.1-arm-linux-gnu

data/ext/herb/error_helpers.c

@@ -10,26 +10,90 @@
 #include "../../src/include/errors.h"
 #include "../../src/include/herb.h"
 #include "../../src/include/token.h"
+#include "../../src/include/util/hb_string.h"
 
 VALUE rb_error_from_c_struct(ERROR_T* error);
 
+static VALUE mErrors;
+static VALUE cError;
+static VALUE cUnexpectedError;
+static VALUE cUnexpectedTokenError;
+static VALUE cMissingOpeningTagError;
+static VALUE cMissingClosingTagError;
+static VALUE cTagNamesMismatchError;
+static VALUE cVoidElementClosingTagError;
+static VALUE cUnclosedElementError;
+static VALUE cRubyParseError;
+static VALUE cERBControlFlowScopeError;
+static VALUE cMissingERBEndTagError;
+static VALUE cERBMultipleBlocksInTagError;
+static VALUE cERBCaseWithConditionsError;
+static VALUE cConditionalElementMultipleTagsError;
+static VALUE cConditionalElementConditionMismatchError;
+static VALUE cInvalidCommentClosingTagError;
+static VALUE cOmittedClosingTagError;
+static VALUE cUnclosedOpenTagError;
+static VALUE cUnclosedCloseTagError;
+static VALUE cUnclosedQuoteError;
+static VALUE cMissingAttributeValueError;
+static VALUE cUnclosedERBTagError;
+static VALUE cStrayERBClosingTagError;
+static VALUE cNestedERBTagError;
+static VALUE cRenderAmbiguousLocalsError;
+static VALUE cRenderMissingLocalsError;
+static VALUE cRenderNoArgumentsError;
+static VALUE cRenderConflictingPartialError;
+static VALUE cRenderInvalidAsOptionError;
+static VALUE cRenderObjectAndCollectionError;
+static VALUE cRenderLayoutWithoutBlockError;
+
+void rb_init_error_classes(void) {
+  mErrors = rb_define_module_under(mHerb, "Errors");
+  cError = rb_define_class_under(mErrors, "Error", rb_cObject);
+  cUnexpectedError = rb_define_class_under(mErrors, "UnexpectedError", cError);
+  cUnexpectedTokenError = rb_define_class_under(mErrors, "UnexpectedTokenError", cError);
+  cMissingOpeningTagError = rb_define_class_under(mErrors, "MissingOpeningTagError", cError);
+  cMissingClosingTagError = rb_define_class_under(mErrors, "MissingClosingTagError", cError);
+  cTagNamesMismatchError = rb_define_class_under(mErrors, "TagNamesMismatchError", cError);
+  cVoidElementClosingTagError = rb_define_class_under(mErrors, "VoidElementClosingTagError", cError);
+  cUnclosedElementError = rb_define_class_under(mErrors, "UnclosedElementError", cError);
+  cRubyParseError = rb_define_class_under(mErrors, "RubyParseError", cError);
+  cERBControlFlowScopeError = rb_define_class_under(mErrors, "ERBControlFlowScopeError", cError);
+  cMissingERBEndTagError = rb_define_class_under(mErrors, "MissingERBEndTagError", cError);
+  cERBMultipleBlocksInTagError = rb_define_class_under(mErrors, "ERBMultipleBlocksInTagError", cError);
+  cERBCaseWithConditionsError = rb_define_class_under(mErrors, "ERBCaseWithConditionsError", cError);
+  cConditionalElementMultipleTagsError = rb_define_class_under(mErrors, "ConditionalElementMultipleTagsError", cError);
+  cConditionalElementConditionMismatchError = rb_define_class_under(mErrors, "ConditionalElementConditionMismatchError", cError);
+  cInvalidCommentClosingTagError = rb_define_class_under(mErrors, "InvalidCommentClosingTagError", cError);
+  cOmittedClosingTagError = rb_define_class_under(mErrors, "OmittedClosingTagError", cError);
+  cUnclosedOpenTagError = rb_define_class_under(mErrors, "UnclosedOpenTagError", cError);
+  cUnclosedCloseTagError = rb_define_class_under(mErrors, "UnclosedCloseTagError", cError);
+  cUnclosedQuoteError = rb_define_class_under(mErrors, "UnclosedQuoteError", cError);
+  cMissingAttributeValueError = rb_define_class_under(mErrors, "MissingAttributeValueError", cError);
+  cUnclosedERBTagError = rb_define_class_under(mErrors, "UnclosedERBTagError", cError);
+  cStrayERBClosingTagError = rb_define_class_under(mErrors, "StrayERBClosingTagError", cError);
+  cNestedERBTagError = rb_define_class_under(mErrors, "NestedERBTagError", cError);
+  cRenderAmbiguousLocalsError = rb_define_class_under(mErrors, "RenderAmbiguousLocalsError", cError);
+  cRenderMissingLocalsError = rb_define_class_under(mErrors, "RenderMissingLocalsError", cError);
+  cRenderNoArgumentsError = rb_define_class_under(mErrors, "RenderNoArgumentsError", cError);
+  cRenderConflictingPartialError = rb_define_class_under(mErrors, "RenderConflictingPartialError", cError);
+  cRenderInvalidAsOptionError = rb_define_class_under(mErrors, "RenderInvalidAsOptionError", cError);
+  cRenderObjectAndCollectionError = rb_define_class_under(mErrors, "RenderObjectAndCollectionError", cError);
+  cRenderLayoutWithoutBlockError = rb_define_class_under(mErrors, "RenderLayoutWithoutBlockError", cError);
+}
+
 static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_error) {
   if (unexpected_error == NULL) { return Qnil; }
 
   ERROR_T* error = &unexpected_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE UnexpectedError = rb_define_class_under(Errors, "UnexpectedError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
-  VALUE unexpected_error_description = rb_utf8_str_new_cstr(unexpected_error->description);
-  VALUE unexpected_error_expected = rb_utf8_str_new_cstr(unexpected_error->expected);
-  VALUE unexpected_error_found = rb_utf8_str_new_cstr(unexpected_error->found);
+  VALUE unexpected_error_description = rb_utf8_str_new(unexpected_error->description.data, unexpected_error->description.length);
+  VALUE unexpected_error_expected = rb_utf8_str_new(unexpected_error->expected.data, unexpected_error->expected.length);
+  VALUE unexpected_error_found = rb_utf8_str_new(unexpected_error->found.data, unexpected_error->found.length);
 
   VALUE args[6] = {
     type,
@@ -40,7 +104,7 @@ static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_er
     unexpected_error_found
   };
 
-  return rb_class_new_instance(6, args, UnexpectedError);
+  return rb_class_new_instance(6, args, cUnexpectedError);
 };
 
 static VALUE rb_unexpected_token_error_from_c_struct(UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error) {
@@ -48,16 +112,12 @@ static VALUE rb_unexpected_token_error_from_c_struct(UNEXPECTED_TOKEN_ERROR_T* u
 
   ERROR_T* error = &unexpected_token_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE UnexpectedTokenError = rb_define_class_under(Errors, "UnexpectedTokenError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
-  VALUE unexpected_token_error_expected_type = rb_utf8_str_new_cstr(token_type_to_string(unexpected_token_error->expected_type));
+  hb_string_T _expected_type_string = token_type_to_string(unexpected_token_error->expected_type);
+  VALUE unexpected_token_error_expected_type = rb_utf8_str_new(_expected_type_string.data, _expected_type_string.length);
   VALUE unexpected_token_error_found = rb_token_from_c_struct(unexpected_token_error->found);
 
   VALUE args[5] = {
@@ -68,7 +128,7 @@ static VALUE rb_unexpected_token_error_from_c_struct(UNEXPECTED_TOKEN_ERROR_T* u
     unexpected_token_error_found
   };
 
-  return rb_class_new_instance(5, args, UnexpectedTokenError);
+  return rb_class_new_instance(5, args, cUnexpectedTokenError);
 };
 
 static VALUE rb_missing_opening_tag_error_from_c_struct(MISSING_OPENING_TAG_ERROR_T* missing_opening_tag_error) {
@@ -76,14 +136,9 @@ static VALUE rb_missing_opening_tag_error_from_c_struct(MISSING_OPENING_TAG_ERRO
 
   ERROR_T* error = &missing_opening_tag_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE MissingOpeningTagError = rb_define_class_under(Errors, "MissingOpeningTagError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   VALUE missing_opening_tag_error_closing_tag = rb_token_from_c_struct(missing_opening_tag_error->closing_tag);
 
@@ -94,7 +149,7 @@ static VALUE rb_missing_opening_tag_error_from_c_struct(MISSING_OPENING_TAG_ERRO
     missing_opening_tag_error_closing_tag
   };
 
-  return rb_class_new_instance(4, args, MissingOpeningTagError);
+  return rb_class_new_instance(4, args, cMissingOpeningTagError);
 };
 
 static VALUE rb_missing_closing_tag_error_from_c_struct(MISSING_CLOSING_TAG_ERROR_T* missing_closing_tag_error) {
@@ -102,14 +157,9 @@ static VALUE rb_missing_closing_tag_error_from_c_struct(MISSING_CLOSING_TAG_ERRO
 
   ERROR_T* error = &missing_closing_tag_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE MissingClosingTagError = rb_define_class_under(Errors, "MissingClosingTagError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   VALUE missing_closing_tag_error_opening_tag = rb_token_from_c_struct(missing_closing_tag_error->opening_tag);
 
@@ -120,7 +170,7 @@ static VALUE rb_missing_closing_tag_error_from_c_struct(MISSING_CLOSING_TAG_ERRO
     missing_closing_tag_error_opening_tag
   };
 
-  return rb_class_new_instance(4, args, MissingClosingTagError);
+  return rb_class_new_instance(4, args, cMissingClosingTagError);
 };
 
 static VALUE rb_tag_names_mismatch_error_from_c_struct(TAG_NAMES_MISMATCH_ERROR_T* tag_names_mismatch_error) {
@@ -128,14 +178,9 @@ static VALUE rb_tag_names_mismatch_error_from_c_struct(TAG_NAMES_MISMATCH_ERROR_
 
   ERROR_T* error = &tag_names_mismatch_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE TagNamesMismatchError = rb_define_class_under(Errors, "TagNamesMismatchError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   VALUE tag_names_mismatch_error_opening_tag = rb_token_from_c_struct(tag_names_mismatch_error->opening_tag);
   VALUE tag_names_mismatch_error_closing_tag = rb_token_from_c_struct(tag_names_mismatch_error->closing_tag);
@@ -148,35 +193,7 @@ static VALUE rb_tag_names_mismatch_error_from_c_struct(TAG_NAMES_MISMATCH_ERROR_
     tag_names_mismatch_error_closing_tag
   };
 
-  return rb_class_new_instance(5, args, TagNamesMismatchError);
-};
-
-static VALUE rb_quotes_mismatch_error_from_c_struct(QUOTES_MISMATCH_ERROR_T* quotes_mismatch_error) {
-  if (quotes_mismatch_error == NULL) { return Qnil; }
-
-  ERROR_T* error = &quotes_mismatch_error->base;
-
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE QuotesMismatchError = rb_define_class_under(Errors, "QuotesMismatchError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
-  VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
-
-  VALUE quotes_mismatch_error_opening_quote = rb_token_from_c_struct(quotes_mismatch_error->opening_quote);
-  VALUE quotes_mismatch_error_closing_quote = rb_token_from_c_struct(quotes_mismatch_error->closing_quote);
-
-  VALUE args[5] = {
-    type,
-    location,
-    message,
-    quotes_mismatch_error_opening_quote,
-    quotes_mismatch_error_closing_quote
-  };
-
-  return rb_class_new_instance(5, args, QuotesMismatchError);
+  return rb_class_new_instance(5, args, cTagNamesMismatchError);
 };
 
 static VALUE rb_void_element_closing_tag_error_from_c_struct(VOID_ELEMENT_CLOSING_TAG_ERROR_T* void_element_closing_tag_error) {
@@ -184,18 +201,13 @@ static VALUE rb_void_element_closing_tag_error_from_c_struct(VOID_ELEMENT_CLOSIN
 
   ERROR_T* error = &void_element_closing_tag_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE VoidElementClosingTagError = rb_define_class_under(Errors, "VoidElementClosingTagError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   VALUE void_element_closing_tag_error_tag_name = rb_token_from_c_struct(void_element_closing_tag_error->tag_name);
-  VALUE void_element_closing_tag_error_expected = rb_utf8_str_new_cstr(void_element_closing_tag_error->expected);
-  VALUE void_element_closing_tag_error_found = rb_utf8_str_new_cstr(void_element_closing_tag_error->found);
+  VALUE void_element_closing_tag_error_expected = rb_utf8_str_new(void_element_closing_tag_error->expected.data, void_element_closing_tag_error->expected.length);
+  VALUE void_element_closing_tag_error_found = rb_utf8_str_new(void_element_closing_tag_error->found.data, void_element_closing_tag_error->found.length);
 
   VALUE args[6] = {
     type,
@@ -206,7 +218,7 @@ static VALUE rb_void_element_closing_tag_error_from_c_struct(VOID_ELEMENT_CLOSIN
     void_element_closing_tag_error_found
   };
 
-  return rb_class_new_instance(6, args, VoidElementClosingTagError);
+  return rb_class_new_instance(6, args, cVoidElementClosingTagError);
 };
 
 static VALUE rb_unclosed_element_error_from_c_struct(UNCLOSED_ELEMENT_ERROR_T* unclosed_element_error) {
@@ -214,14 +226,9 @@ static VALUE rb_unclosed_element_error_from_c_struct(UNCLOSED_ELEMENT_ERROR_T* u
 
   ERROR_T* error = &unclosed_element_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE UnclosedElementError = rb_define_class_under(Errors, "UnclosedElementError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
   VALUE unclosed_element_error_opening_tag = rb_token_from_c_struct(unclosed_element_error->opening_tag);
 
@@ -232,7 +239,7 @@ static VALUE rb_unclosed_element_error_from_c_struct(UNCLOSED_ELEMENT_ERROR_T* u
     unclosed_element_error_opening_tag
   };
 
-  return rb_class_new_instance(4, args, UnclosedElementError);
+  return rb_class_new_instance(4, args, cUnclosedElementError);
 };
 
 static VALUE rb_ruby_parse_error_from_c_struct(RUBY_PARSE_ERROR_T* ruby_parse_error) {
@@ -240,18 +247,13 @@ static VALUE rb_ruby_parse_error_from_c_struct(RUBY_PARSE_ERROR_T* ruby_parse_er
 
   ERROR_T* error = &ruby_parse_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE RubyParseError = rb_define_class_under(Errors, "RubyParseError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
-  VALUE ruby_parse_error_error_message = rb_utf8_str_new_cstr(ruby_parse_error->error_message);
-  VALUE ruby_parse_error_diagnostic_id = rb_utf8_str_new_cstr(ruby_parse_error->diagnostic_id);
-  VALUE ruby_parse_error_level = rb_utf8_str_new_cstr(ruby_parse_error->level);
+  VALUE ruby_parse_error_error_message = rb_utf8_str_new(ruby_parse_error->error_message.data, ruby_parse_error->error_message.length);
+  VALUE ruby_parse_error_diagnostic_id = rb_utf8_str_new(ruby_parse_error->diagnostic_id.data, ruby_parse_error->diagnostic_id.length);
+  VALUE ruby_parse_error_level = rb_utf8_str_new(ruby_parse_error->level.data, ruby_parse_error->level.length);
 
   VALUE args[6] = {
     type,
@@ -262,7 +264,7 @@ static VALUE rb_ruby_parse_error_from_c_struct(RUBY_PARSE_ERROR_T* ruby_parse_er
     ruby_parse_error_level
   };
 
-  return rb_class_new_instance(6, args, RubyParseError);
+  return rb_class_new_instance(6, args, cRubyParseError);
 };
 
 static VALUE rb_erb_control_flow_scope_error_from_c_struct(ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error) {
@@ -270,16 +272,11 @@ static VALUE rb_erb_control_flow_scope_error_from_c_struct(ERB_CONTROL_FLOW_SCOP
 
   ERROR_T* error = &erb_control_flow_scope_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE ERBControlFlowScopeError = rb_define_class_under(Errors, "ERBControlFlowScopeError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
-  VALUE erb_control_flow_scope_error_keyword = rb_utf8_str_new_cstr(erb_control_flow_scope_error->keyword);
+  VALUE erb_control_flow_scope_error_keyword = rb_utf8_str_new(erb_control_flow_scope_error->keyword.data, erb_control_flow_scope_error->keyword.length);
 
   VALUE args[4] = {
     type,
@@ -288,33 +285,28 @@ static VALUE rb_erb_control_flow_scope_error_from_c_struct(ERB_CONTROL_FLOW_SCOP
     erb_control_flow_scope_error_keyword
   };
 
-  return rb_class_new_instance(4, args, ERBControlFlowScopeError);
+  return rb_class_new_instance(4, args, cERBControlFlowScopeError);
 };
 
-static VALUE rb_missingerb_end_tag_error_from_c_struct(MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error) {
-  if (missingerb_end_tag_error == NULL) { return Qnil; }
+static VALUE rb_missing_erb_end_tag_error_from_c_struct(MISSING_ERB_END_TAG_ERROR_T* missing_erb_end_tag_error) {
+  if (missing_erb_end_tag_error == NULL) { return Qnil; }
 
-  ERROR_T* error = &missingerb_end_tag_error->base;
+  ERROR_T* error = &missing_erb_end_tag_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE MissingERBEndTagError = rb_define_class_under(Errors, "MissingERBEndTagError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
-  VALUE missingerb_end_tag_error_keyword = rb_utf8_str_new_cstr(missingerb_end_tag_error->keyword);
+  VALUE missing_erb_end_tag_error_keyword = rb_utf8_str_new(missing_erb_end_tag_error->keyword.data, missing_erb_end_tag_error->keyword.length);
 
   VALUE args[4] = {
     type,
     location,
     message,
-    missingerb_end_tag_error_keyword
+    missing_erb_end_tag_error_keyword
   };
 
-  return rb_class_new_instance(4, args, MissingERBEndTagError);
+  return rb_class_new_instance(4, args, cMissingERBEndTagError);
 };
 
 static VALUE rb_erb_multiple_blocks_in_tag_error_from_c_struct(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error) {
@@ -322,14 +314,9 @@ static VALUE rb_erb_multiple_blocks_in_tag_error_from_c_struct(ERB_MULTIPLE_BLOC
 
   ERROR_T* error = &erb_multiple_blocks_in_tag_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE ERBMultipleBlocksInTagError = rb_define_class_under(Errors, "ERBMultipleBlocksInTagError", Error);
-
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
 
 
   VALUE args[3] = {
@@ -338,7 +325,7 @@ static VALUE rb_erb_multiple_blocks_in_tag_error_from_c_struct(ERB_MULTIPLE_BLOC
     message
   };
 
-  return rb_class_new_instance(3, args, ERBMultipleBlocksInTagError);
+  return rb_class_new_instance(3, args, cERBMultipleBlocksInTagError);
 };
 
 static VALUE rb_erb_case_with_conditions_error_from_c_struct(ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error) {
@@ -346,14 +333,233 @@ static VALUE rb_erb_case_with_conditions_error_from_c_struct(ERB_CASE_WITH_CONDI
 
   ERROR_T* error = &erb_case_with_conditions_error->base;
 
-  VALUE Herb = rb_define_module("Herb");
-  VALUE Errors = rb_define_module_under(Herb, "Errors");
-  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
-  VALUE ERBCaseWithConditionsError = rb_define_class_under(Errors, "ERBCaseWithConditionsError", Error);
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cERBCaseWithConditionsError);
+};
+
+static VALUE rb_conditional_element_multiple_tags_error_from_c_struct(CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T* conditional_element_multiple_tags_error) {
+  if (conditional_element_multiple_tags_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &conditional_element_multiple_tags_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE conditional_element_multiple_tags_error_line = ULONG2NUM(conditional_element_multiple_tags_error->line);
+  VALUE conditional_element_multiple_tags_error_column = ULONG2NUM(conditional_element_multiple_tags_error->column);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    conditional_element_multiple_tags_error_line,
+    conditional_element_multiple_tags_error_column
+  };
+
+  return rb_class_new_instance(5, args, cConditionalElementMultipleTagsError);
+};
+
+static VALUE rb_conditional_element_condition_mismatch_error_from_c_struct(CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T* conditional_element_condition_mismatch_error) {
+  if (conditional_element_condition_mismatch_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &conditional_element_condition_mismatch_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE conditional_element_condition_mismatch_error_tag_name = rb_utf8_str_new(conditional_element_condition_mismatch_error->tag_name.data, conditional_element_condition_mismatch_error->tag_name.length);
+  VALUE conditional_element_condition_mismatch_error_open_condition = rb_utf8_str_new(conditional_element_condition_mismatch_error->open_condition.data, conditional_element_condition_mismatch_error->open_condition.length);
+  VALUE conditional_element_condition_mismatch_error_open_line = ULONG2NUM(conditional_element_condition_mismatch_error->open_line);
+  VALUE conditional_element_condition_mismatch_error_open_column = ULONG2NUM(conditional_element_condition_mismatch_error->open_column);
+  VALUE conditional_element_condition_mismatch_error_close_condition = rb_utf8_str_new(conditional_element_condition_mismatch_error->close_condition.data, conditional_element_condition_mismatch_error->close_condition.length);
+  VALUE conditional_element_condition_mismatch_error_close_line = ULONG2NUM(conditional_element_condition_mismatch_error->close_line);
+  VALUE conditional_element_condition_mismatch_error_close_column = ULONG2NUM(conditional_element_condition_mismatch_error->close_column);
+
+  VALUE args[10] = {
+    type,
+    location,
+    message,
+    conditional_element_condition_mismatch_error_tag_name,
+    conditional_element_condition_mismatch_error_open_condition,
+    conditional_element_condition_mismatch_error_open_line,
+    conditional_element_condition_mismatch_error_open_column,
+    conditional_element_condition_mismatch_error_close_condition,
+    conditional_element_condition_mismatch_error_close_line,
+    conditional_element_condition_mismatch_error_close_column
+  };
+
+  return rb_class_new_instance(10, args, cConditionalElementConditionMismatchError);
+};
+
+static VALUE rb_invalid_comment_closing_tag_error_from_c_struct(INVALID_COMMENT_CLOSING_TAG_ERROR_T* invalid_comment_closing_tag_error) {
+  if (invalid_comment_closing_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &invalid_comment_closing_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE invalid_comment_closing_tag_error_closing_tag = rb_token_from_c_struct(invalid_comment_closing_tag_error->closing_tag);
 
-  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    invalid_comment_closing_tag_error_closing_tag
+  };
+
+  return rb_class_new_instance(4, args, cInvalidCommentClosingTagError);
+};
+
+static VALUE rb_omitted_closing_tag_error_from_c_struct(OMITTED_CLOSING_TAG_ERROR_T* omitted_closing_tag_error) {
+  if (omitted_closing_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &omitted_closing_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
   VALUE location = rb_location_from_c_struct(error->location);
-  VALUE message = rb_utf8_str_new_cstr(error->message);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE omitted_closing_tag_error_opening_tag = rb_token_from_c_struct(omitted_closing_tag_error->opening_tag);
+  VALUE omitted_closing_tag_error_insertion_point = rb_position_from_c_struct(omitted_closing_tag_error->insertion_point);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    omitted_closing_tag_error_opening_tag,
+    omitted_closing_tag_error_insertion_point
+  };
+
+  return rb_class_new_instance(5, args, cOmittedClosingTagError);
+};
+
+static VALUE rb_unclosed_open_tag_error_from_c_struct(UNCLOSED_OPEN_TAG_ERROR_T* unclosed_open_tag_error) {
+  if (unclosed_open_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unclosed_open_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE unclosed_open_tag_error_tag_name = rb_token_from_c_struct(unclosed_open_tag_error->tag_name);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    unclosed_open_tag_error_tag_name
+  };
+
+  return rb_class_new_instance(4, args, cUnclosedOpenTagError);
+};
+
+static VALUE rb_unclosed_close_tag_error_from_c_struct(UNCLOSED_CLOSE_TAG_ERROR_T* unclosed_close_tag_error) {
+  if (unclosed_close_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unclosed_close_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE unclosed_close_tag_error_tag_name = rb_token_from_c_struct(unclosed_close_tag_error->tag_name);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    unclosed_close_tag_error_tag_name
+  };
+
+  return rb_class_new_instance(4, args, cUnclosedCloseTagError);
+};
+
+static VALUE rb_unclosed_quote_error_from_c_struct(UNCLOSED_QUOTE_ERROR_T* unclosed_quote_error) {
+  if (unclosed_quote_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unclosed_quote_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE unclosed_quote_error_opening_quote = rb_token_from_c_struct(unclosed_quote_error->opening_quote);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    unclosed_quote_error_opening_quote
+  };
+
+  return rb_class_new_instance(4, args, cUnclosedQuoteError);
+};
+
+static VALUE rb_missing_attribute_value_error_from_c_struct(MISSING_ATTRIBUTE_VALUE_ERROR_T* missing_attribute_value_error) {
+  if (missing_attribute_value_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &missing_attribute_value_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE missing_attribute_value_error_attribute_name = rb_utf8_str_new(missing_attribute_value_error->attribute_name.data, missing_attribute_value_error->attribute_name.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    missing_attribute_value_error_attribute_name
+  };
+
+  return rb_class_new_instance(4, args, cMissingAttributeValueError);
+};
+
+static VALUE rb_unclosed_erb_tag_error_from_c_struct(UNCLOSED_ERB_TAG_ERROR_T* unclosed_erb_tag_error) {
+  if (unclosed_erb_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &unclosed_erb_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE unclosed_erb_tag_error_opening_tag = rb_token_from_c_struct(unclosed_erb_tag_error->opening_tag);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    unclosed_erb_tag_error_opening_tag
+  };
+
+  return rb_class_new_instance(4, args, cUnclosedERBTagError);
+};
+
+static VALUE rb_stray_erb_closing_tag_error_from_c_struct(STRAY_ERB_CLOSING_TAG_ERROR_T* stray_erb_closing_tag_error) {
+  if (stray_erb_closing_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &stray_erb_closing_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
 
 
   VALUE args[3] = {
@@ -362,7 +568,179 @@ static VALUE rb_erb_case_with_conditions_error_from_c_struct(ERB_CASE_WITH_CONDI
     message
   };
 
-  return rb_class_new_instance(3, args, ERBCaseWithConditionsError);
+  return rb_class_new_instance(3, args, cStrayERBClosingTagError);
+};
+
+static VALUE rb_nested_erb_tag_error_from_c_struct(NESTED_ERB_TAG_ERROR_T* nested_erb_tag_error) {
+  if (nested_erb_tag_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &nested_erb_tag_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE nested_erb_tag_error_opening_tag = rb_token_from_c_struct(nested_erb_tag_error->opening_tag);
+  VALUE nested_erb_tag_error_nested_tag_line = ULONG2NUM(nested_erb_tag_error->nested_tag_line);
+  VALUE nested_erb_tag_error_nested_tag_column = ULONG2NUM(nested_erb_tag_error->nested_tag_column);
+
+  VALUE args[6] = {
+    type,
+    location,
+    message,
+    nested_erb_tag_error_opening_tag,
+    nested_erb_tag_error_nested_tag_line,
+    nested_erb_tag_error_nested_tag_column
+  };
+
+  return rb_class_new_instance(6, args, cNestedERBTagError);
+};
+
+static VALUE rb_render_ambiguous_locals_error_from_c_struct(RENDER_AMBIGUOUS_LOCALS_ERROR_T* render_ambiguous_locals_error) {
+  if (render_ambiguous_locals_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_ambiguous_locals_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_ambiguous_locals_error_partial = rb_utf8_str_new(render_ambiguous_locals_error->partial.data, render_ambiguous_locals_error->partial.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_ambiguous_locals_error_partial
+  };
+
+  return rb_class_new_instance(4, args, cRenderAmbiguousLocalsError);
+};
+
+static VALUE rb_render_missing_locals_error_from_c_struct(RENDER_MISSING_LOCALS_ERROR_T* render_missing_locals_error) {
+  if (render_missing_locals_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_missing_locals_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_missing_locals_error_partial = rb_utf8_str_new(render_missing_locals_error->partial.data, render_missing_locals_error->partial.length);
+  VALUE render_missing_locals_error_keywords = rb_utf8_str_new(render_missing_locals_error->keywords.data, render_missing_locals_error->keywords.length);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    render_missing_locals_error_partial,
+    render_missing_locals_error_keywords
+  };
+
+  return rb_class_new_instance(5, args, cRenderMissingLocalsError);
+};
+
+static VALUE rb_render_no_arguments_error_from_c_struct(RENDER_NO_ARGUMENTS_ERROR_T* render_no_arguments_error) {
+  if (render_no_arguments_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_no_arguments_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cRenderNoArgumentsError);
+};
+
+static VALUE rb_render_conflicting_partial_error_from_c_struct(RENDER_CONFLICTING_PARTIAL_ERROR_T* render_conflicting_partial_error) {
+  if (render_conflicting_partial_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_conflicting_partial_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_conflicting_partial_error_positional_partial = rb_utf8_str_new(render_conflicting_partial_error->positional_partial.data, render_conflicting_partial_error->positional_partial.length);
+  VALUE render_conflicting_partial_error_keyword_partial = rb_utf8_str_new(render_conflicting_partial_error->keyword_partial.data, render_conflicting_partial_error->keyword_partial.length);
+
+  VALUE args[5] = {
+    type,
+    location,
+    message,
+    render_conflicting_partial_error_positional_partial,
+    render_conflicting_partial_error_keyword_partial
+  };
+
+  return rb_class_new_instance(5, args, cRenderConflictingPartialError);
+};
+
+static VALUE rb_render_invalid_as_option_error_from_c_struct(RENDER_INVALID_AS_OPTION_ERROR_T* render_invalid_as_option_error) {
+  if (render_invalid_as_option_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_invalid_as_option_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_invalid_as_option_error_as_value = rb_utf8_str_new(render_invalid_as_option_error->as_value.data, render_invalid_as_option_error->as_value.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_invalid_as_option_error_as_value
+  };
+
+  return rb_class_new_instance(4, args, cRenderInvalidAsOptionError);
+};
+
+static VALUE rb_render_object_and_collection_error_from_c_struct(RENDER_OBJECT_AND_COLLECTION_ERROR_T* render_object_and_collection_error) {
+  if (render_object_and_collection_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_object_and_collection_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, cRenderObjectAndCollectionError);
+};
+
+static VALUE rb_render_layout_without_block_error_from_c_struct(RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T* render_layout_without_block_error) {
+  if (render_layout_without_block_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &render_layout_without_block_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE render_layout_without_block_error_layout = rb_utf8_str_new(render_layout_without_block_error->layout.data, render_layout_without_block_error->layout.length);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    render_layout_without_block_error_layout
+  };
+
+  return rb_class_new_instance(4, args, cRenderLayoutWithoutBlockError);
 };
 
 
@@ -375,14 +753,31 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
     case MISSING_OPENING_TAG_ERROR: return rb_missing_opening_tag_error_from_c_struct((MISSING_OPENING_TAG_ERROR_T*) error); break;
     case MISSING_CLOSING_TAG_ERROR: return rb_missing_closing_tag_error_from_c_struct((MISSING_CLOSING_TAG_ERROR_T*) error); break;
     case TAG_NAMES_MISMATCH_ERROR: return rb_tag_names_mismatch_error_from_c_struct((TAG_NAMES_MISMATCH_ERROR_T*) error); break;
-    case QUOTES_MISMATCH_ERROR: return rb_quotes_mismatch_error_from_c_struct((QUOTES_MISMATCH_ERROR_T*) error); break;
     case VOID_ELEMENT_CLOSING_TAG_ERROR: return rb_void_element_closing_tag_error_from_c_struct((VOID_ELEMENT_CLOSING_TAG_ERROR_T*) error); break;
     case UNCLOSED_ELEMENT_ERROR: return rb_unclosed_element_error_from_c_struct((UNCLOSED_ELEMENT_ERROR_T*) error); break;
     case RUBY_PARSE_ERROR: return rb_ruby_parse_error_from_c_struct((RUBY_PARSE_ERROR_T*) error); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return rb_erb_control_flow_scope_error_from_c_struct((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error); break;
-    case MISSINGERB_END_TAG_ERROR: return rb_missingerb_end_tag_error_from_c_struct((MISSINGERB_END_TAG_ERROR_T*) error); break;
+    case MISSING_ERB_END_TAG_ERROR: return rb_missing_erb_end_tag_error_from_c_struct((MISSING_ERB_END_TAG_ERROR_T*) error); break;
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return rb_erb_multiple_blocks_in_tag_error_from_c_struct((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error); break;
     case ERB_CASE_WITH_CONDITIONS_ERROR: return rb_erb_case_with_conditions_error_from_c_struct((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error); break;
+    case CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR: return rb_conditional_element_multiple_tags_error_from_c_struct((CONDITIONAL_ELEMENT_MULTIPLE_TAGS_ERROR_T*) error); break;
+    case CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR: return rb_conditional_element_condition_mismatch_error_from_c_struct((CONDITIONAL_ELEMENT_CONDITION_MISMATCH_ERROR_T*) error); break;
+    case INVALID_COMMENT_CLOSING_TAG_ERROR: return rb_invalid_comment_closing_tag_error_from_c_struct((INVALID_COMMENT_CLOSING_TAG_ERROR_T*) error); break;
+    case OMITTED_CLOSING_TAG_ERROR: return rb_omitted_closing_tag_error_from_c_struct((OMITTED_CLOSING_TAG_ERROR_T*) error); break;
+    case UNCLOSED_OPEN_TAG_ERROR: return rb_unclosed_open_tag_error_from_c_struct((UNCLOSED_OPEN_TAG_ERROR_T*) error); break;
+    case UNCLOSED_CLOSE_TAG_ERROR: return rb_unclosed_close_tag_error_from_c_struct((UNCLOSED_CLOSE_TAG_ERROR_T*) error); break;
+    case UNCLOSED_QUOTE_ERROR: return rb_unclosed_quote_error_from_c_struct((UNCLOSED_QUOTE_ERROR_T*) error); break;
+    case MISSING_ATTRIBUTE_VALUE_ERROR: return rb_missing_attribute_value_error_from_c_struct((MISSING_ATTRIBUTE_VALUE_ERROR_T*) error); break;
+    case UNCLOSED_ERB_TAG_ERROR: return rb_unclosed_erb_tag_error_from_c_struct((UNCLOSED_ERB_TAG_ERROR_T*) error); break;
+    case STRAY_ERB_CLOSING_TAG_ERROR: return rb_stray_erb_closing_tag_error_from_c_struct((STRAY_ERB_CLOSING_TAG_ERROR_T*) error); break;
+    case NESTED_ERB_TAG_ERROR: return rb_nested_erb_tag_error_from_c_struct((NESTED_ERB_TAG_ERROR_T*) error); break;
+    case RENDER_AMBIGUOUS_LOCALS_ERROR: return rb_render_ambiguous_locals_error_from_c_struct((RENDER_AMBIGUOUS_LOCALS_ERROR_T*) error); break;
+    case RENDER_MISSING_LOCALS_ERROR: return rb_render_missing_locals_error_from_c_struct((RENDER_MISSING_LOCALS_ERROR_T*) error); break;
+    case RENDER_NO_ARGUMENTS_ERROR: return rb_render_no_arguments_error_from_c_struct((RENDER_NO_ARGUMENTS_ERROR_T*) error); break;
+    case RENDER_CONFLICTING_PARTIAL_ERROR: return rb_render_conflicting_partial_error_from_c_struct((RENDER_CONFLICTING_PARTIAL_ERROR_T*) error); break;
+    case RENDER_INVALID_AS_OPTION_ERROR: return rb_render_invalid_as_option_error_from_c_struct((RENDER_INVALID_AS_OPTION_ERROR_T*) error); break;
+    case RENDER_OBJECT_AND_COLLECTION_ERROR: return rb_render_object_and_collection_error_from_c_struct((RENDER_OBJECT_AND_COLLECTION_ERROR_T*) error); break;
+    case RENDER_LAYOUT_WITHOUT_BLOCK_ERROR: return rb_render_layout_without_block_error_from_c_struct((RENDER_LAYOUT_WITHOUT_BLOCK_ERROR_T*) error); break;
   }
 
   return Qnil;