herb 0.7.4-x86-linux-gnu → 0.7.5-x86-linux-gnu

data/src/parser_helpers.c

@@ -99,8 +99,8 @@ void parser_append_unexpected_error(parser_T* parser, const char* description, c
     description,
     expected,
     token_type_to_string(token->type),
-    token->location->start,
-    token->location->end,
+    token->location.start,
+    token->location.end,
     errors
   );
 
@@ -111,8 +111,8 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
   append_unexpected_token_error(
     expected_type,
     parser->current_token,
-    parser->current_token->location->start,
-    parser->current_token->location->end,
+    parser->current_token->location.start,
+    parser->current_token->location.end,
     errors
   );
 }
@@ -121,12 +121,12 @@ void parser_append_literal_node_from_buffer(
   const parser_T* parser,
   buffer_T* buffer,
   array_T* children,
-  position_T* start
+  position_T start
 ) {
   if (buffer_length(buffer) == 0) { return; }
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location->start, NULL);
+    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location.start, NULL);
 
   if (children != NULL) { array_append(children, literal); }
   buffer_clear(buffer);
@@ -149,7 +149,7 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
   if (token == NULL) {
     token = parser_advance(parser);
 
-    append_unexpected_token_error(expected_type, token, token->location->start, token->location->end, array);
+    append_unexpected_token_error(expected_type, token, token->location.start, token->location.end, array);
   }
 
   return token;
@@ -162,8 +162,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
-    open_tag->tag_name->location->start,
-    open_tag->tag_name->location->end,
+    open_tag->tag_name->location.start,
+    open_tag->tag_name->location.end,
     errors
   );
 
@@ -174,8 +174,8 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
     NULL,
     false,
     ELEMENT_SOURCE_HTML,
-    open_tag->base.location->start,
-    open_tag->base.location->end,
+    open_tag->base.location.start,
+    open_tag->base.location.end,
     errors
   );
 }
@@ -192,15 +192,15 @@ void parser_handle_mismatched_tags(
     append_tag_names_mismatch_error(
       expected_tag,
       actual_tag,
-      actual_tag->location->start,
-      actual_tag->location->end,
+      actual_tag->location.start,
+      actual_tag->location.end,
       errors
     );
   } else {
     append_missing_opening_tag_error(
       close_tag->tag_name,
-      close_tag->tag_name->location->start,
-      close_tag->tag_name->location->end,
+      close_tag->tag_name->location.start,
+      close_tag->tag_name->location.end,
       errors
     );
   }

data/src/pretty_print.c

@@ -158,16 +158,16 @@ void pretty_print_errors(
   }
 }
 
-void pretty_print_location(location_T* location, buffer_T* buffer) {
+void pretty_print_location(location_T location, buffer_T* buffer) {
   buffer_append(buffer, "(location: (");
   char location_string[128];
   sprintf(
     location_string,
-    "%zu,%zu)-(%zu,%zu",
-    (location->start && location->start->line) ? location->start->line : 0,
-    (location->start && location->start->column) ? location->start->column : 0,
-    (location->end && location->end->line) ? location->end->line : 0,
-    (location->end && location->end->column) ? location->end->column : 0
+    "%u,%u)-(%u,%u",
+    location.start.line,
+    location.start.column,
+    location.end.line,
+    location.end.column
   );
   buffer_append(buffer, location_string);
   buffer_append(buffer, "))");
@@ -188,12 +188,7 @@ void pretty_print_position_property(
 
     char position_string[128];
 
-    sprintf(
-      position_string,
-      "%zu:%zu",
-      (position->line) ? position->line : 0,
-      (position->column) ? position->column : 0
-    );
+    sprintf(position_string, "%u:%u", (position->line) ? position->line : 0, (position->column) ? position->column : 0);
 
     buffer_append(buffer, position_string);
     buffer_append(buffer, ")");

data/src/prism_helpers.c

@@ -16,15 +16,15 @@ const char* pm_error_level_to_string(pm_error_level_t level) {
   }
 }
 
-position_T* position_from_source_with_offset(const char* source, size_t offset) {
-  position_T* position = position_init(1, 0);
+position_T position_from_source_with_offset(const char* source, size_t offset) {
+  position_T position = { .line = 1, .column = 0 };
 
   for (size_t i = 0; i < offset; i++) {
     if (is_newline(source[i])) {
-      position->line++;
-      position->column = 0;
+      position.line++;
+      position.column = 0;
     } else {
-      position->column++;
+      position.column++;
     }
   }
 
@@ -40,8 +40,8 @@ RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   size_t start_offset = (size_t) (error->location.start - parser->start);
   size_t end_offset = (size_t) (error->location.end - parser->start);
 
-  position_T* start = position_from_source_with_offset(source, start_offset);
-  position_T* end = position_from_source_with_offset(source, end_offset);
+  position_T start = position_from_source_with_offset(source, start_offset);
+  position_T end = position_from_source_with_offset(source, end_offset);
 
   return ruby_parse_error_init(
     error->message,

data/src/range.c

@@ -1,38 +1,5 @@
 #include "include/range.h"
 
-size_t range_sizeof(void) {
-  return sizeof(range_T);
-}
-
-range_T* range_init(const size_t from, const size_t to) {
-  range_T* range = calloc(1, range_sizeof());
-
-  range->from = from;
-  range->to = to;
-
-  return range;
-}
-
-size_t range_from(const range_T* range) {
-  return range->from;
-}
-
-size_t range_to(const range_T* range) {
-  return range->to;
-}
-
-size_t range_length(range_T* range) {
-  return range_to(range) - range_from(range);
-}
-
-range_T* range_copy(range_T* range) {
-  if (!range) { return NULL; }
-
-  return range_init(range_from(range), range_to(range));
-}
-
-void range_free(range_T* range) {
-  if (range == NULL) { return; }
-
-  free(range);
+uint32_t range_length(range_T range) {
+  return range.to - range.from;
 }

data/src/token.c

@@ -2,6 +2,7 @@
 #include "include/json.h"
 #include "include/lexer.h"
 #include "include/position.h"
+#include "include/range.h"
 #include "include/token_struct.h"
 #include "include/util.h"
 
@@ -28,10 +29,15 @@ token_T* token_init(const char* value, const token_type_T type, lexer_T* lexer)
   }
 
   token->type = type;
-  token->range = range_init(lexer->previous_position, lexer->current_position);
-
-  token->location =
-    location_from(lexer->previous_line, lexer->previous_column, lexer->current_line, lexer->current_column);
+  token->range = (range_T) { .from = lexer->previous_position, .to = lexer->current_position };
+
+  location_from(
+    &token->location,
+    lexer->previous_line,
+    lexer->previous_column,
+    lexer->current_line,
+    lexer->current_column
+  );
 
   lexer->previous_line = lexer->current_line;
   lexer->previous_column = lexer->current_column;
@@ -84,7 +90,7 @@ const char* token_type_to_string(const token_type_T type) {
 
 char* token_to_string(const token_T* token) {
   const char* type_string = token_type_to_string(token->type);
-  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%d, %d] start=(%d:%d) end=(%d:%d)>";
+  const char* template = "#<Herb::Token type=\"%s\" value=\"%s\" range=[%u, %u] start=(%u:%u) end=(%u:%u)>";
 
   char* string = calloc(strlen(type_string) + strlen(template) + strlen(token->value) + 16, sizeof(char));
   char* escaped;
@@ -100,12 +106,12 @@ char* token_to_string(const token_T* token) {
     template,
     type_string,
     escaped,
-    token->range->from,
-    token->range->to,
-    token->location->start->line,
-    token->location->start->column,
-    token->location->end->line,
-    token->location->end->column
+    token->range.from,
+    token->range.to,
+    token->location.start.line,
+    token->location.start.column,
+    token->location.end.line,
+    token->location.end.column
   );
 
   free(escaped);
@@ -122,24 +128,24 @@ char* token_to_json(const token_T* token) {
 
   buffer_T range = buffer_new();
   json_start_array(&json, "range");
-  json_add_size_t(&range, NULL, token->range->from);
-  json_add_size_t(&range, NULL, token->range->to);
+  json_add_size_t(&range, NULL, token->range.from);
+  json_add_size_t(&range, NULL, token->range.to);
   buffer_concat(&json, &range);
   buffer_free(&range);
   json_end_array(&json);
 
   buffer_T start = buffer_new();
   json_start_object(&json, "start");
-  json_add_size_t(&start, "line", token->location->start->line);
-  json_add_size_t(&start, "column", token->location->start->column);
+  json_add_size_t(&start, "line", token->location.start.line);
+  json_add_size_t(&start, "column", token->location.start.column);
   buffer_concat(&json, &start);
   buffer_free(&start);
   json_end_object(&json);
 
   buffer_T end = buffer_new();
   json_start_object(&json, "end");
-  json_add_size_t(&end, "line", token->location->end->line);
-  json_add_size_t(&end, "column", token->location->end->column);
+  json_add_size_t(&end, "line", token->location.end.line);
+  json_add_size_t(&end, "column", token->location.end.column);
   buffer_concat(&json, &end);
   buffer_free(&end);
   json_end_object(&json);
@@ -157,14 +163,6 @@ int token_type(const token_T* token) {
   return token->type;
 }
 
-position_T* token_start_position(token_T* token) {
-  return token->location->start;
-}
-
-position_T* token_end_position(token_T* token) {
-  return token->location->end;
-}
-
 token_T* token_copy(token_T* token) {
   if (!token) { return NULL; }
 
@@ -184,8 +182,8 @@ token_T* token_copy(token_T* token) {
   }
 
   new_token->type = token->type;
-  new_token->range = range_copy(token->range);
-  new_token->location = location_copy(token->location);
+  new_token->range = token->range;
+  new_token->location = token->location;
 
   return new_token;
 }
@@ -194,8 +192,6 @@ void token_free(token_T* token) {
   if (!token) { return; }
 
   if (token->value != NULL) { free(token->value); }
-  if (token->range != NULL) { range_free(token->range); }
-  if (token->location != NULL) { location_free(token->location); }
 
   free(token);
 }

data/templates/javascript/packages/core/src/visitor.ts.erb

@@ -1,11 +1,27 @@
 import {
   Node,
+  ERBNode,
   <%- nodes.each do |node| -%>
   <%= node.name %>,
   <%- end -%>
 } from "./nodes.js"
 
-export class Visitor {
+/**
+ * Interface that enforces all node visit methods are implemented
+ * This ensures that any class implementing IVisitor must have a visit method for every node type
+ */
+export interface IVisitor {
+  visit(node: Node | null | undefined): void
+  visitAll(nodes: (Node | null | undefined)[]): void
+  visitChildNodes(node: Node): void
+  <%- nodes.each do |node| -%>
+  visit<%= node.name %>(node: <%= node.name %>): void
+  <%- end -%>
+  visitNode(node: Node): void
+  visitERBNode(node: ERBNode): void
+}
+
+export class Visitor implements IVisitor {
   visit(node: Node | null | undefined): void {
     if (!node) return
 
@@ -20,8 +36,20 @@ export class Visitor {
     node.compactChildNodes().forEach(node => node.accept(this))
   }
 
+  visitNode(_node: Node): void {
+    // Default implementation does nothing
+  }
+
+  visitERBNode(_node: ERBNode): void {
+    // Default implementation does nothing
+  }
+
   <%- nodes.each do |node| -%>
   visit<%= node.name %>(node: <%= node.name %>): void {
+    this.visitNode(node)
+    <%- if node.name.start_with?("ERB") -%>
+    this.visitERBNode(node)
+    <%- end -%>
     this.visitChildNodes(node)
   }
 

data/templates/src/ast_nodes.c.erb

@@ -13,7 +13,7 @@
 
 <%- 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", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
 
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>) {
   <%= node.struct_type %>* <%= node.human %> = malloc(sizeof(<%= node.struct_type %>));
@@ -81,8 +81,6 @@ void ast_free_base_node(AST_NODE_T* node) {
     array_free(&node->errors);
   }
 
-  if (node->location) { location_free(node->location); }
-
   free(node);
 }
 

data/templates/src/errors.c.erb

@@ -17,15 +17,16 @@ size_t error_sizeof(void) {
   return sizeof(struct ERROR_STRUCT);
 }
 
-void error_init(ERROR_T* error, const error_type_T type, position_T* start, position_T* end) {
+void error_init(ERROR_T* error, const error_type_T type, position_T start, position_T end) {
   if (!error) { return; }
 
   error->type = type;
-  error->location = location_init(position_copy(start), position_copy(end));
+  error->location.start = start;
+  error->location.end = end;
 }
 <%- 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"] -%>
 
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>) {
   <%= error.struct_type %>* <%= error.human %> = malloc(sizeof(<%= error.struct_type %>));
@@ -72,7 +73,7 @@ void error_init(ERROR_T* error, const error_type_T type, position_T* start, posi
   <%- error.fields.each do |field| -%>
   <%- case field -%>
   <%- when Herb::Template::PositionField -%>
-  <%= error.human %>-><%= field.name %> = position_copy(<%= field.name %>);
+  <%= error.human %>-><%= field.name %> = <%= field.name %>;
   <%- when Herb::Template::TokenField -%>
   <%= error.human %>-><%= field.name %> = token_copy(<%= field.name %>);
   <%- when Herb::Template::TokenTypeField -%>
@@ -116,7 +117,6 @@ const char* error_human_type(ERROR_T* error) {
 void error_free_base_error(ERROR_T* error) {
   if (error == NULL) { return; }
 
-  if (error->location != NULL) { location_free(error->location); }
   if (error->message != NULL) { free(error->message); }
 
   free(error);
@@ -130,8 +130,6 @@ static void error_free_<%= error.human %>(<%= error.struct_type %>* <%= error.hu
   <%- end -%>
   <%- error.fields.each do |field| -%>
   <%- case field -%>
-  <%- when Herb::Template::PositionField -%>
-  if (<%= error.human %>-><%= field.name %> != NULL) { position_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenField -%>
   if (<%= error.human %>-><%= field.name %> != NULL) { token_free(<%= error.human %>-><%= field.name %>); }
   <%- when Herb::Template::TokenTypeField -%>

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

@@ -20,7 +20,7 @@ typedef enum {
 
 typedef struct AST_NODE_STRUCT {
   ast_node_type_T type;
-  location_T* location;
+  location_T location;
   // maybe a range too?
   array_T* errors;
 } AST_NODE_T;
@@ -36,7 +36,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", "array_T* errors"] -%>
+<%- arguments = node_arguments + ["position_T start_position", "position_T end_position", "array_T* errors"] -%>
 <%= node.struct_type %>* ast_<%= node.human %>_init(<%= arguments.join(", ") %>);
 <%- end -%>
 

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

@@ -16,7 +16,7 @@ typedef enum {
 
 typedef struct ERROR_STRUCT {
   error_type_T type;
-  location_T* location;
+  location_T location;
   char* message;
 } ERROR_T;
 
@@ -31,12 +31,12 @@ typedef struct {
 
 <%- 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"] -%>
 <%= error.struct_type %>* <%= error.human %>_init(<%= arguments.join(", ") %>);
 void append_<%= error.human %>(<%= (arguments << "array_T* errors").join(", ") %>);
 <%- end -%>
 
-void error_init(ERROR_T* error, error_type_T type, position_T* start, position_T* end);
+void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 
 size_t error_sizeof(void);
 error_type_T error_type(ERROR_T* error);

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.7.5
 platform: x86-linux-gnu
 authors:
 - Marco Roth
 bindir: exe
 cert_chain: []
-date: 2025-09-26 00:00:00.000000000 Z
+date: 2025-10-06 00:00:00.000000000 Z
 dependencies: []
 description: Powerful and seamless HTML-aware ERB parsing and tooling.
 email:
@@ -167,7 +167,6 @@ files:
 - src/memory.c
 - src/parser.c
 - src/parser_helpers.c
-- src/position.c
 - src/pretty_print.c
 - src/prism_helpers.c
 - src/range.c

data/src/position.c

@@ -1,33 +0,0 @@
-#include "include/position.h"
-#include "include/memory.h"
-
-size_t position_sizeof(void) {
-  return sizeof(position_T);
-}
-
-position_T* position_init(const size_t line, const size_t column) {
-  position_T* position = safe_malloc(position_sizeof());
-
-  position->line = line;
-  position->column = column;
-
-  return position;
-}
-
-size_t position_line(const position_T* position) {
-  return position->line;
-}
-
-size_t position_column(const position_T* position) {
-  return position->column;
-}
-
-position_T* position_copy(position_T* position) {
-  if (position == NULL) { return NULL; }
-
-  return position_init(position_line(position), position_column(position));
-}
-
-void position_free(position_T* position) {
-  free(position);
-}