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

data/templates/rust/src/visitor.rs.erb

@@ -0,0 +1,81 @@
+use crate::nodes::*;
+use crate::union_types::*;
+
+/// Visitor trait for traversing the Herb AST.
+///
+/// Provides a visit/walk separation pattern:
+/// - `visit_*` methods are the entry points for each node type (override these in rules)
+/// - `walk_*` methods traverse child nodes (call these explicitly from `visit_*` overrides)
+///
+/// Default `visit_*` implementations call the corresponding `walk_*` method.
+/// Override `visit_*` to add custom behavior, then call `walk_*` to continue traversal.
+pub trait Visitor {
+  fn visit(&mut self, node: &AnyNode) {
+    match node {
+      <%- nodes.each do |node| -%>
+      AnyNode::<%= node.name %>(n) => self.visit_<%= node.human %>(n),
+      <%- end -%>
+    }
+  }
+
+  fn visit_all(&mut self, nodes: &[AnyNode]) {
+    for node in nodes {
+      self.visit(node);
+    }
+  }
+
+  fn visit_erb_node(&mut self, _node: &dyn ERBNode) {
+    // Default implementation does nothing
+  }
+
+  <%- nodes.each do |node| -%>
+  fn visit_<%= node.human %>(&mut self, node: &<%= node.name %>) {
+    <%- if node.name.start_with?("ERB") -%>
+    self.visit_erb_node(node);
+    <%- end -%>
+    self.walk_<%= node.human %>(node);
+  }
+
+  fn walk_<%= node.human %>(&mut self, node: &<%= node.name %>) {
+    <%- children_fields = node.fields.select { |field|
+      case field
+      when Herb::Template::ArrayField
+        true
+      when Herb::Template::NodeField, Herb::Template::BorrowedNodeField
+        true
+      else
+        false
+      end
+    } -%>
+    <%- if children_fields.any? -%>
+    <%- children_fields.each do |field| -%>
+    <%- case field -%>
+    <%- when Herb::Template::ArrayField -%>
+    self.visit_all(&node.<%= field.name %>);
+    <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
+    <%- if field.specific_kind && field.specific_kind != "Node" -%>
+    if let Some(ref child) = node.<%= field.name %> {
+      self.visit_<%= Herb::Template.underscore(field.specific_kind).downcase %>(child);
+    }
+    <%- elsif field.union_kind -%>
+    if let Some(ref child) = node.<%= field.name %> {
+      match child {
+        <%- field.union_kind.each do |kind| -%>
+        <%= field.union_type_name %>::<%= kind %>(n) => self.visit_<%= Herb::Template.underscore(kind).downcase %>(n),
+        <%- end -%>
+      }
+    }
+    <%- else -%>
+    if let Some(ref child) = node.<%= field.name %> {
+      self.visit(child);
+    }
+    <%- end -%>
+    <%- end -%>
+    <%- end -%>
+    <%- else -%>
+    let _ = node;
+    <%- end -%>
+  }
+
+  <%- end -%>
+}

data/templates/src/{analyze_missing_end.c.erb → analyze/missing_end.c.erb}

@@ -1,5 +1,7 @@
-#include "include/analyze_helpers.h"
-#include "include/errors.h"
+#include "../include/analyze/helpers.h"
+#include "../include/errors.h"
+#include "../include/util/hb_allocator.h"
+#include "../include/util/hb_string.h"
 
 <%-
   nodes_with_end_node = nodes.select do |node|
@@ -7,7 +9,7 @@
   end
 -%>
 
-void check_erb_node_for_missing_end(const AST_NODE_T* node) {
+void check_erb_node_for_missing_end(const AST_NODE_T* node, hb_allocator_T* allocator) {
   switch (node->type) {
     <%- nodes_with_end_node.each do |node| -%>
     <%- keyword = node.name.gsub(/^ERB/, '').gsub(/Match|Node$/, '').downcase -%>
@@ -15,14 +17,15 @@ void check_erb_node_for_missing_end(const AST_NODE_T* node) {
       const <%= node.struct_type %>* <%= node.human %> = (const <%= node.struct_type %>*) node;
 
       if (<%= node.human %>->end_node == NULL) {
-        append_missingerb_end_tag_error(
+        <%= "append_#{errors.find { |e| e.name == 'MissingERBEndTagError' }.human}" %>(
         <%- if keyword == "block" -%>
-          "ERB block",
+          hb_string("ERB block"),
         <%- else -%>
-          "`<" "%" " <%= keyword %> " "%" ">`",
+          hb_string("`<" "%" " <%= keyword %> " "%" ">`"),
         <%- end -%>
           <%= node.human %>->tag_opening->location.start,
           <%= node.human %>->tag_closing->location.end,
+          allocator,
           node->errors
         );
       }

data/templates/src/{analyze_transform.c.erb → analyze/transform.c.erb}

@@ -1,5 +1,5 @@
-#include "include/analyze.h"
-#include "include/visitor.h"
+#include "../include/analyze/analyze.h"
+#include "../include/visitor.h"
 
 bool transform_erb_nodes(const AST_NODE_T* node, void* data) {
   analyze_ruby_context_T* context = (analyze_ruby_context_T*) data;

data/templates/src/ast_nodes.c.erb

@@ -3,27 +3,31 @@
 
 #include <prism.h>
 
-#include "include/analyzed_ruby.h"
+#include "include/analyze/analyzed_ruby.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.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"
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors", "hb_allocator_T* allocator"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
-  <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
+  <%= node.struct_type %>* <%= node.human %> = hb_allocator_alloc(allocator, sizeof(<%= node.struct_type %>));
 
-  ast_node_init(&<%= node.human %>->base, <%= node.type %>, start_position, end_position, errors);
+  if (!<%= node.human %>) { return NULL; }
+
+  ast_node_init(&<%= node.human %>->base, <%= node.type %>, start_position, end_position, errors, allocator);
 
   <%- node.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::TokenField -%>
-  <%= node.human %>-><%= field.name %> = token_copy(<%= field.name %>);
+  <%= node.human %>-><%= field.name %> = token_copy(<%= field.name %>, allocator);
   <%- when Herb::Template::NodeField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::ArrayField -%>
@@ -35,9 +39,13 @@
   <%- when Herb::Template::PrismNodeField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::StringField -%>
-  <%= node.human %>-><%= field.name %> = herb_strdup(<%= field.name %>);
+  <%= node.human %>-><%= field.name %> = hb_string_copy(<%= field.name %>, allocator);
   <%- when Herb::Template::AnalyzedRubyField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::PrismSerializedField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
+  <%- when Herb::Template::PrismContextField -%>
+  <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::VoidPointerField -%>
   <%= node.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::LocationField -%>
@@ -71,77 +79,77 @@ hb_string_T ast_node_human_type(AST_NODE_T* node) {
   return hb_string("Unknown ast_node_type_T");
 }
 
-void ast_free_base_node(AST_NODE_T* node) {
+void ast_free_base_node(AST_NODE_T* node, hb_allocator_T* allocator) {
   if (node == NULL) { return; }
 
   if (node->errors) {
     for (size_t i = 0; i < hb_array_size(node->errors); i++) {
       ERROR_T* child = hb_array_get(node->errors, i);
-      if (child != NULL) { error_free(child); }
+      if (child != NULL) { error_free(child, allocator); }
     }
 
     hb_array_free(&node->errors);
   }
 
-  free(node);
+  hb_allocator_dealloc(allocator, node);
 }
 
 <%- nodes.each do |node| -%>
-<%- arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join }.join(", ") : "void" -%>
 
-static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %>) {
+static void ast_free_<%= node.human %>(<%= node.struct_type %>* <%= node.human %>, hb_allocator_T* allocator) {
   <%- if node.fields.none? -%>
   /* no <%= node.struct_type %> specific fields to free up */
   <%- end -%>
   <%- node.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::TokenField -%>
-  if (<%= node.human %>-><%= field.name %> != NULL) { token_free(<%= node.human %>-><%= field.name %>); }
+  if (<%= node.human %>-><%= field.name %> != NULL) { token_free(<%= node.human %>-><%= field.name %>, allocator); }
+  <%- when Herb::Template::BorrowedNodeField -%>
+  /* <%= field.name %> is a borrowed reference, not freed here (owned by another field) */
   <%- when Herb::Template::NodeField -%>
-  ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>);
+  ast_node_free((AST_NODE_T*) <%= node.human %>-><%= field.name %>, allocator);
   <%- when Herb::Template::ArrayField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
     for (size_t i = 0; i < hb_array_size(<%= node.human %>-><%= field.name %>); i++) {
       AST_NODE_T* child = hb_array_get(<%= node.human %>-><%= field.name %>, i);
-      if (child) { ast_node_free(child); }
+      if (child) { ast_node_free(child, allocator); }
     }
 
     hb_array_free(&<%= node.human %>-><%= field.name %>);
   }
   <%- when Herb::Template::StringField -%>
-  if (<%= node.human %>-><%= field.name %> != NULL) { free((char*) <%= node.human %>-><%= field.name %>); }
+  if (<%= node.human %>-><%= field.name %>.data != NULL) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>.data); }
   <%- when Herb::Template::PrismNodeField -%>
-  if (<%= node.human %>-><%= field.name %> != NULL) {
-    // The first argument to `pm_node_destroy` is a `pm_parser_t`, but it's currently unused:
-    // See: https://github.com/ruby/ruby/blob/efb2d4363709b36a205791787f6812259027c6e1/prism/templates/src/node.c.erb#L100-L104
-    //
-    pm_node_destroy(NULL, <%= node.human %>-><%= field.name %>);
-  }
+  /* prism_node is a borrowed reference into the prism context, not freed here */
   <%- when Herb::Template::AnalyzedRubyField -%>
   if (<%= node.human %>-><%= field.name %> != NULL) {
     free_analyzed_ruby(<%= node.human %>-><%= field.name %>);
   }
+  <%- when Herb::Template::PrismSerializedField -%>
+  if (<%= node.human %>-><%= field.name %>.data != NULL) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>.data); }
+  <%- when Herb::Template::PrismContextField -%>
+  if (<%= node.human %>-><%= field.name %> != NULL) { herb_prism_context_free(<%= node.human %>-><%= field.name %>); }
   <%- when Herb::Template::VoidPointerField -%>
-  free(<%= node.human %>-><%= field.name %>);
+  if (<%= node.human %>-><%= field.name %> != NULL) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>); }
   <%- when Herb::Template::BooleanField -%>
   <%- when Herb::Template::ElementSourceField -%>
   <%- when Herb::Template::LocationField -%>
-  if (<%= node.human %>-><%= field.name %> != NULL) { free(<%= node.human %>-><%= field.name %>); }
+  if (<%= node.human %>-><%= field.name %> != NULL) { hb_allocator_dealloc(allocator, <%= node.human %>-><%= field.name %>); }
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
   <%- end -%>
 
-  ast_free_base_node(&<%= node.human %>->base);
+  ast_free_base_node(&<%= node.human %>->base, allocator);
 }
 <%- end -%>
 
-void ast_node_free(AST_NODE_T* node) {
+void ast_node_free(AST_NODE_T* node, hb_allocator_T* allocator) {
   if (!node) { return; }
 
   switch (node->type) {
     <%- nodes.each do |node| -%>
-    case <%= node.type %>: ast_free_<%= node.human %>((<%= node.struct_type %>*) node); break;
+    case <%= node.type %>: ast_free_<%= node.human %>((<%= node.struct_type %>*) node, allocator); break;
     <%- end -%>
   }
 }

data/templates/src/ast_pretty_print.c.erb

@@ -1,4 +1,8 @@
-#include "include/analyze_helpers.h"
+#ifdef HERB_EXCLUDE_PRETTYPRINT
+  // Pretty print support excluded
+#else
+
+#include "include/analyze/helpers.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
@@ -40,12 +44,17 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       <%- when Herb::Template::BooleanField -%>
       pretty_print_boolean_property(hb_string("<%= field.name %>"), <%= node.human %>-><%= field.name %>, indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::ElementSourceField -%>
-      pretty_print_string_property(element_source_to_string(<%= node.human %>-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+      pretty_print_string_property(<%= node.human %>-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::StringField -%>
-      pretty_print_string_property(hb_string(<%= node.human %>-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+      pretty_print_string_property(<%= node.human %>-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
       <%- when Herb::Template::PrismNodeField -%>
-      pretty_print_string_property(hb_string("<%= field.name %>"), hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
-      <%- when Herb::Template::NodeField -%>
+      if (<%= node.human %>-><%= field.name %>.node != NULL) {
+        pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+        hb_buffer_append(buffer, " (pm_node_t*)\n");
+      }
+      <%- when Herb::Template::PrismContextField -%>
+      /* prism_context is internal state, not pretty printed */
+      <%- when Herb::Template::NodeField, Herb::Template::BorrowedNodeField -%>
 
       pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
 
@@ -101,6 +110,14 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
         hb_buffer_append(buffer, " ∅\n");
       }
 
+      <%- when Herb::Template::PrismSerializedField -%>
+      if (<%= node.human %>-><%= field.name %>.data != NULL && <%= node.human %>-><%= field.name %>.length > 0) {
+        pretty_print_label(hb_string("<%= field.name %>"), indent, relative_indent, <%= last %>, buffer);
+        char <%= field.name %>_size_string[64];
+        sprintf(<%= field.name %>_size_string, " (%zu bytes)\n", <%= node.human %>-><%= field.name %>.length);
+        hb_buffer_append(buffer, <%= field.name %>_size_string);
+      }
+
       <%- else -%>
       <%= field.inspect %>
       <%- end -%>
@@ -110,3 +127,5 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
     <%- end -%>
   }
 }
+
+#endif

data/templates/src/errors.c.erb

@@ -4,7 +4,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>
@@ -26,48 +28,47 @@ void error_init(ERROR_T* error, const error_type_T type, position_T start, posit
 }
 <%- errors.each do |error| -%>
 <%- error_arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = error_arguments + ["position_T start", "position_T end"] -%>
+<%- arguments = error_arguments + ["position_T start", "position_T end", "hb_allocator_T* allocator"] -%>
 
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
-  <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
+  <%= error.struct_type %>* <%= error.human %> = hb_allocator_alloc(allocator, sizeof(<%= error.struct_type %>));
+
+  if (!<%= error.human %>) { return NULL; }
 
   error_init(&<%= error.human %>->base, <%= error.type %>, start, end);
 
   <%- if error.message_arguments.any? -%>
   const char* message_template = "<%= error.message_template %>";
 
-  size_t message_size = <%= Herb::Template::PrintfMessageTemplate.estimate_buffer_size(error.message_template) %>;
-  char* message = (char*) malloc(message_size);
-
-  if (message) {
-    <%- error.message_arguments.each_with_index do |argument, i| -%>
-    <%- if error.message_template.scan(/%[sdulfz]/)[i] == "%s" -%>
-    char truncated_argument_<%= i %>[ERROR_MESSAGES_TRUNCATED_LENGTH + 1];
-    strncpy(truncated_argument_<%= i %>, <%= argument %>, ERROR_MESSAGES_TRUNCATED_LENGTH);
-    truncated_argument_<%= i %>[ERROR_MESSAGES_TRUNCATED_LENGTH] = '\0';
+  <%- error.message_arguments.each_with_index do |argument, i| -%>
+  <%- if error.message_template.scan(/%(?:zu|llu|lf|ld|[sdulf])/)[i] == "%s" -%>
+  hb_string_T truncated_argument_<%= i %> = hb_string_truncate(<%= argument %>, ERROR_MESSAGES_TRUNCATED_LENGTH);
+  char* truncated_c_string_<%= i %> = hb_string_to_c_string_using_malloc(truncated_argument_<%= i %>);
 
+  <%- end -%>
+  <%- end -%>
+  char message[<%= Herb::Template::PrintfMessageTemplate.estimate_buffer_size(error.message_template) %>];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    <%- error.message_arguments.each_with_index do |argument, index| -%>
+    <%- if error.message_template.scan(/%(?:zu|llu|lf|ld|[sdulf])/)[index] == "%s" -%>
+    truncated_c_string_<%= index %> ? truncated_c_string_<%= index %> : ""<% if index != error.message_arguments.length - 1 %>,<% end %>
+    <%- else -%>
+    <%= argument %><% if index != error.message_arguments.length - 1 %>,<% end %>
     <%- end -%>
     <%- end -%>
-    snprintf(
-      message,
-      message_size,
-      message_template,
-      <%- error.message_arguments.each_with_index do |argument, index| -%>
-      <%- if error.message_template.scan(/%[sdulfz]/)[index] == "%s" -%>
-      truncated_argument_<%= index %><% if index != error.message_arguments.length - 1 %>,<% end %>
-      <%- else -%>
-      <%= argument %><% if index != error.message_arguments.length - 1 %>,<% end %>
-      <%- end -%>
-      <%- end -%>
-    );
-
-    <%= error.human %>->base.message = herb_strdup(message);
-    free(message);
-  } else {
-    <%= error.human %>->base.message = herb_strdup("<%= error.message_template %>");
-  }
+  );
+
+  <%- error.message_arguments.each_with_index do |argument, i| -%>
+  <%- if error.message_template.scan(/%(?:zu|llu|lf|ld|[sdulf])/)[i] == "%s" -%>
+  if (truncated_c_string_<%= i %>) { free(truncated_c_string_<%= i %>); }
+  <%- end -%>
+  <%- end -%>
+  <%= error.human %>->base.message = hb_string_copy(hb_string(message), allocator);
   <%- else -%>
-  <%= error.human %>->base.message = herb_strdup("<%= error.message_template %>");
+  <%= error.human %>->base.message = hb_string_copy(hb_string("<%= error.message_template %>"), allocator);
   <%- end -%>
 
   <%- error.fields.each do |field| -%>
@@ -75,13 +76,13 @@ void error_init(ERROR_T* error, const error_type_T type, position_T start, posit
   <%- when Herb::Template::PositionField -%>
   <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::TokenField -%>
-  <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>, allocator);
   <%- when Herb::Template::TokenTypeField -%>
   <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::SizeTField -%>
   <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::StringField -%>
-  <%= error.human %>-><%= field.name %> = herb_strdup(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = hb_string_copy(<%= field.name %>, allocator);
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
@@ -94,69 +95,72 @@ void append_<%= error.human %>(<%= (arguments + ["hb_array_T* errors"]).join(",
 }
 <%- end -%>
 
-const char* error_type_to_string(ERROR_T* error) {
+hb_string_T error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     <%- errors.each do |error| -%>
-    case <%= error.type %>: return "<%= error.type %>";
+    case <%= error.type %>: return hb_string("<%= error.type %>");
     <%- end -%>
   }
 
-  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) {
     <%- errors.each do |error| -%>
-    case <%= error.type %>: return "<%= error.name %>";
+    case <%= error.type %>: return hb_string("<%= error.name %>");
     <%- end -%>
   }
 
-  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);
 }
 <%- errors.each do |error| -%>
-<%- arguments = error.fields.any? ? error.fields.map { |field| [field.c_type, " ", field.name].join }.join(", ") : "void" -%>
 
-static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.human %>) {
+static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.human %>, hb_allocator_T* allocator) {
   <%- if error.fields.none? -%>
   /* no <%= error.struct_type %> specific fields to free up */
   <%- end -%>
   <%- error.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::TokenField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
+  if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>, allocator); }
   <%- when Herb::Template::TokenTypeField -%>
   // token_type_T is part of struct
   <%- when Herb::Template::SizeTField -%>
   // size_t is part of struct
+  <%- when Herb::Template::PositionField -%>
+  // position_T is part of struct
   <%- when Herb::Template::StringField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { free((char*) <%= error.human %>-><%= field.name %>); }
+  if (<%= error.human %>-><%= field.name %>.data != NULL) { hb_allocator_dealloc(allocator, <%= error.human %>-><%= field.name %>.data); }
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
   <%- end -%>
 
-  error_free_base_error(&<%= error.human %>->base);
+  error_free_base_error(&<%= error.human %>->base, allocator);
 }
 <%- end -%>
 
-void error_free(ERROR_T* error) {
+void error_free(ERROR_T* error, hb_allocator_T* allocator) {
   if (!error) { return; }
 
   switch (error->type) {
     <%- errors.each do |error| -%>
-    case <%= error.type %>: error_free_<%= error.human %>((<%= error.struct_type %>*) error); break;
+    case <%= error.type %>: error_free_<%= error.human %>((<%= error.struct_type %>*) error, allocator); break;
     <%- end -%>
   }
 }
 
+#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
@@ -206,25 +210,25 @@ static void error_pretty_print_<%= error.human %>(<%= error.struct_type %>* erro
   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, <%= error.fields.none? %>, buffer);
+  pretty_print_quoted_property(hb_string("message"), error->base.message, indent, relative_indent, <%= error.fields.none? %>, buffer);
   <%- error.fields.each_with_index do |field, index| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  pretty_print_position_property(hb_string(error-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_position_property(&error-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::TokenField -%>
   pretty_print_token_property(error-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::TokenTypeField -%>
-  pretty_print_property(hb_string(token_type_to_string(error-><%= field.name %>)), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_property(token_type_to_string(error-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::SizeTField -%>
-  pretty_print_size_t_property(hb_string(error-><%= field.name %>), hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_size_t_property(error-><%= field.name %>, hb_string("<%= field.name %>"), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- when Herb::Template::StringField -%>
-  pretty_print_quoted_property(hb_string("<%= field.name %>"), hb_string(error-><%= field.name %>), indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
+  pretty_print_quoted_property(hb_string("<%= field.name %>"), error-><%= field.name %>, indent, relative_indent, <%= error.fields.length - 1 == index %>, buffer);
   <%- else -%>
   <%= field.inspect %>
   <%- end -%>
@@ -241,3 +245,5 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     <%- end -%>
   }
 }
+
+#endif

data/templates/src/include/ast_nodes.h.erb

@@ -4,11 +4,15 @@
 #include <stdbool.h>
 #include <prism.h>
 
-#include "analyzed_ruby.h"
+#include "analyze/analyzed_ruby.h"
 #include "element_source.h"
+#include "herb_prism_node.h"
+#include "prism_context.h"
+#include "prism_serialized.h"
 #include "location.h"
 #include "position.h"
 #include "token_struct.h"
+#include "util/hb_allocator.h"
 #include "util/hb_array.h"
 #include "util/hb_buffer.h"
 #include "util/hb_string.h"
@@ -37,7 +41,7 @@ typedef struct <%= node.struct_name %> {
 
 <%- nodes.each do |node| -%>
 <%- node_arguments = node.fields.any? ? node.fields.map { |field| [field.c_type, " ", field.name].join } : [] -%>
-<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "hb_array_T* errors", "hb_allocator_T* allocator"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 

data/templates/src/include/ast_pretty_print.h.erb

@@ -1,6 +1,10 @@
 #ifndef HERB_AST_PRETTY_PRINT_H
 #define HERB_AST_PRETTY_PRINT_H
 
+#ifdef HERB_EXCLUDE_PRETTYPRINT
+  // Pretty print support excluded
+#else
+
 #include "ast_nodes.h"
 #include "util/hb_buffer.h"
 
@@ -12,3 +16,4 @@ void ast_pretty_print_node(
 );
 
 #endif
+#endif