@herb-tools/node 0.7.4 → 0.8.0

package/extension/libherb/util/hb_string.c

@@ -0,0 +1,85 @@
+#include "../include/util/hb_string.h"
+#include "../include/macros.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+hb_string_T hb_string(const char* null_terminated_c_string) {
+  hb_string_T string;
+
+  string.data = (char*) null_terminated_c_string;
+  string.length = (uint32_t) strlen(null_terminated_c_string);
+
+  return string;
+}
+
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset) {
+  hb_string_T slice;
+  if (string.length < offset) {
+    slice.data = NULL;
+    slice.length = 0;
+
+    return slice;
+  }
+
+  slice.data = string.data + offset;
+  slice.length = string.length - offset;
+
+  return slice;
+}
+
+bool hb_string_equals(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
+  if (a.length != b.length) { return false; }
+
+  return strncasecmp(a.data, b.data, a.length) == 0;
+}
+
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix) {
+  if (hb_string_is_empty(string) || hb_string_is_empty(expected_prefix)) { return false; }
+  if (string.length < expected_prefix.length) { return false; }
+
+  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+}
+
+bool hb_string_is_empty(hb_string_T string) {
+  return string.length == 0;
+}
+
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length) {
+  hb_string_T truncated_string = { .data = string.data, .length = MIN(string.length, max_length) };
+
+  return truncated_string;
+}
+
+hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to) {
+  return hb_string_truncate(hb_string_slice(string, from), to - from);
+}
+
+char* hb_string_to_c_string_using_malloc(hb_string_T string) {
+  size_t string_length_in_bytes = sizeof(char) * (string.length);
+  char* buffer = malloc(string_length_in_bytes + sizeof(char) * 1);
+
+  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+
+  buffer[string_length_in_bytes] = '\0';
+
+  return buffer;
+}
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string) {
+  size_t string_length_in_bytes = sizeof(char) * (string.length);
+  char* buffer = hb_arena_alloc(allocator, string_length_in_bytes + sizeof(char) * 1);
+
+  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+
+  buffer[string_length_in_bytes] = '\0';
+
+  return buffer;
+}

package/extension/libherb/util/hb_string.h

@@ -0,0 +1,29 @@
+#ifndef HERB_STRING_H
+#define HERB_STRING_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "hb_arena.h"
+
+typedef struct HB_STRING_STRUCT {
+  char* data;
+  uint32_t length;
+} hb_string_T;
+
+hb_string_T hb_string(const char* null_terminated_c_string);
+hb_string_T hb_string_slice(hb_string_T string, uint32_t offset);
+bool hb_string_equals(hb_string_T a, hb_string_T b);
+bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b);
+bool hb_string_starts_with(hb_string_T string, hb_string_T expected_prefix);
+bool hb_string_is_empty(hb_string_T string);
+hb_string_T hb_string_truncate(hb_string_T string, uint32_t max_length);
+
+hb_string_T hb_string_range(hb_string_T string, uint32_t from, uint32_t to);
+
+char* hb_string_to_c_string_using_malloc(hb_string_T string);
+
+char* hb_string_to_c_string(hb_arena_T* allocator, hb_string_T string);
+
+#endif

package/extension/libherb/util/hb_system.c

@@ -0,0 +1,30 @@
+#include "../include/util/hb_system.h"
+
+#ifdef __linux__
+#define _GNU_SOURCE
+#endif
+
+#ifdef HB_USE_MALLOC
+#include <stdlib.h>
+#else
+#include <sys/mman.h>
+#endif
+
+void* hb_system_allocate_memory(size_t size) {
+#ifdef HB_USE_MALLOC
+  return malloc(size);
+#else
+  void* memory = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (memory == MAP_FAILED) { return NULL; }
+
+  return memory;
+#endif
+}
+
+void hb_system_free_memory(void* ptr, size_t size) {
+#ifdef HB_USE_MALLOC
+  free(ptr);
+#else
+  munmap(ptr, size);
+#endif
+}

package/extension/libherb/util/hb_system.h

@@ -0,0 +1,9 @@
+#ifndef HERB_SYSTEM_H
+#define HERB_SYSTEM_H
+
+#include <stddef.h>
+
+void* hb_system_allocate_memory(size_t size);
+void hb_system_free_memory(void* ptr, size_t size);
+
+#endif

package/extension/libherb/util.c

@@ -1,118 +1,55 @@
 #include "include/util.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
-#include <ctype.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-int is_whitespace(const int character) {
-  return character == ' ' || character == '\t';
+int is_newline(int character) {
+  return character == '\n' || character == '\r';
 }
 
-int is_newline(const int character) {
-  return character == 13 || character == 10;
-}
-
-int count_in_string(const char* string, const char character) {
-  int count = 0;
+hb_string_T escape_newlines(hb_string_T input) {
+  hb_buffer_T buffer;
 
-  while (*string != '\0') {
-    if (*string == character) { count++; }
+  hb_buffer_init(&buffer, input.length);
 
-    string++;
-  }
-
-  return count;
-}
-
-int count_newlines(const char* string) {
-  int count = 0;
-
-  while (*string) {
-    if (*string == '\r') {
-      count++;
-      if (*(string + 1) == '\n') { string++; }
-    } else if (*string == '\n') {
-      count++;
+  for (size_t i = 0; i < input.length; ++i) {
+    switch (input.data[i]) {
+      case '\n': {
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'n');
+      } break;
+      case '\r': {
+        hb_buffer_append_char(&buffer, '\\');
+        hb_buffer_append_char(&buffer, 'r');
+      } break;
+      default: {
+        hb_buffer_append_char(&buffer, input.data[i]);
+      }
     }
-
-    string++;
   }
 
-  return count;
+  return hb_string(buffer.value);
 }
 
-char* replace_char(char* string, const char find, const char replace) {
-  char* original_string = string;
-
-  while (*string != '\0') {
-    if (*string == find) { *string = replace; }
+static hb_string_T wrap_string(hb_string_T input, char character) {
+  hb_buffer_T buffer;
 
-    string++;
-  }
-
-  return original_string;
-}
-
-char* escape_newlines(const char* input) {
-  char* output = calloc(strlen(input) * 2 + 1, sizeof(char));
-  char* orig_output = output;
-
-  while (*input) {
-    if (*input == '\n') {
-      *output++ = '\\';
-      *output++ = 'n';
-    } else if (*input == '\r') {
-      *output++ = '\\';
-      *output++ = 'r';
-    } else {
-      *output++ = *input;
-    }
-
-    input++;
-  }
+  hb_buffer_init(&buffer, input.length + 2);
 
-  *output = '\0';
+  hb_buffer_append_char(&buffer, character);
+  hb_buffer_append_string(&buffer, input);
+  hb_buffer_append_char(&buffer, character);
 
-  return orig_output;
+  return hb_string(buffer.value);
 }
 
-char* wrap_string(const char* input, const char character) {
-  if (input == NULL) { return NULL; }
-
-  const size_t length = strlen(input);
-  char* wrapped = malloc(length + 3);
-
-  if (wrapped == NULL) { return NULL; }
-
-  wrapped[0] = character;
-  strcpy(wrapped + 1, input);
-  wrapped[length + 1] = character;
-  wrapped[length + 2] = '\0';
-
-  return wrapped;
-}
-
-char* quoted_string(const char* input) {
+hb_string_T quoted_string(hb_string_T input) {
   return wrap_string(input, '"');
 }
 
-// Check if a string is blank (NULL, empty, or only contains whitespace)
-bool string_blank(const char* input) {
-  if (input == NULL || input[0] == '\0') { return true; }
-
-  for (const char* p = input; *p != '\0'; p++) {
-    if (!isspace(*p)) { return false; }
-  }
-
-  return true;
-}
-
-// Check if a string is present (not blank)
-bool string_present(const char* input) {
-  return !string_blank(input);
-}
-
 char* herb_strdup(const char* s) {
   size_t len = strlen(s) + 1;
   char* copy = malloc(len);
@@ -121,10 +58,3 @@ char* herb_strdup(const char* s) {
 
   return copy;
 }
-
-char* size_t_to_string(const size_t value) {
-  char* buffer = malloc(21);
-  snprintf(buffer, 21, "%zu", value);
-
-  return buffer;
-}

package/extension/libherb/util.h

@@ -1,25 +1,14 @@
 #ifndef HERB_UTIL_H
 #define HERB_UTIL_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdlib.h>
 
-int is_whitespace(int character);
 int is_newline(int character);
 
-int count_in_string(const char* string, char character);
-int count_newlines(const char* string);
-
-char* replace_char(char* string, char find, char replace);
-char* escape_newlines(const char* input);
-char* quoted_string(const char* input);
-char* wrap_string(const char* input, char character);
-
-bool string_blank(const char* input);
-bool string_present(const char* input);
-
+hb_string_T escape_newlines(hb_string_T input);
+hb_string_T quoted_string(hb_string_T input);
 char* herb_strdup(const char* s);
 
-char* size_t_to_string(size_t value);
-
 #endif

package/extension/libherb/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.7.4"
+#define HERB_VERSION "0.8.0"
 
 #endif

package/extension/libherb/visitor.c

@@ -1,12 +1,12 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /Users/marcoroth/Development/herb-release-0.7.4/templates/src/visitor.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.0/templates/src/visitor.c.erb
 
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/visitor.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data) {
   if (visitor(node, data) && node != NULL) {
@@ -24,8 +24,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_DOCUMENT_NODE_T* document_node = ((const AST_DOCUMENT_NODE_T *) node);
 
       if (document_node->children != NULL) {
-        for (size_t index = 0; index < array_size(document_node->children); index++) {
-          herb_visit_node(array_get(document_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(document_node->children); index++) {
+          herb_visit_node(hb_array_get(document_node->children, index), visitor, data);
         }
       }
 
@@ -35,8 +35,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = ((const AST_HTML_OPEN_TAG_NODE_T *) node);
 
       if (html_open_tag_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_open_tag_node->children); index++) {
-          herb_visit_node(array_get(html_open_tag_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_open_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(html_open_tag_node->children, index), visitor, data);
         }
       }
 
@@ -46,8 +46,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = ((const AST_HTML_CLOSE_TAG_NODE_T *) node);
 
       if (html_close_tag_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_close_tag_node->children); index++) {
-          herb_visit_node(array_get(html_close_tag_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_close_tag_node->children); index++) {
+          herb_visit_node(hb_array_get(html_close_tag_node->children, index), visitor, data);
         }
       }
 
@@ -61,8 +61,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       }
 
       if (html_element_node->body != NULL) {
-        for (size_t index = 0; index < array_size(html_element_node->body); index++) {
-          herb_visit_node(array_get(html_element_node->body, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_element_node->body); index++) {
+          herb_visit_node(hb_array_get(html_element_node->body, index), visitor, data);
         }
       }
 
@@ -76,8 +76,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = ((const AST_HTML_ATTRIBUTE_VALUE_NODE_T *) node);
 
       if (html_attribute_value_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_attribute_value_node->children); index++) {
-          herb_visit_node(array_get(html_attribute_value_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_attribute_value_node->children); index++) {
+          herb_visit_node(hb_array_get(html_attribute_value_node->children, index), visitor, data);
         }
       }
 
@@ -87,8 +87,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = ((const AST_HTML_ATTRIBUTE_NAME_NODE_T *) node);
 
       if (html_attribute_name_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_attribute_name_node->children); index++) {
-          herb_visit_node(array_get(html_attribute_name_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_attribute_name_node->children); index++) {
+          herb_visit_node(hb_array_get(html_attribute_name_node->children, index), visitor, data);
         }
       }
 
@@ -111,8 +111,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_COMMENT_NODE_T* html_comment_node = ((const AST_HTML_COMMENT_NODE_T *) node);
 
       if (html_comment_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_comment_node->children); index++) {
-          herb_visit_node(array_get(html_comment_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_comment_node->children); index++) {
+          herb_visit_node(hb_array_get(html_comment_node->children, index), visitor, data);
         }
       }
 
@@ -122,8 +122,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = ((const AST_HTML_DOCTYPE_NODE_T *) node);
 
       if (html_doctype_node->children != NULL) {
-        for (size_t index = 0; index < array_size(html_doctype_node->children); index++) {
-          herb_visit_node(array_get(html_doctype_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(html_doctype_node->children); index++) {
+          herb_visit_node(hb_array_get(html_doctype_node->children, index), visitor, data);
         }
       }
 
@@ -133,8 +133,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_XML_DECLARATION_NODE_T* xml_declaration_node = ((const AST_XML_DECLARATION_NODE_T *) node);
 
       if (xml_declaration_node->children != NULL) {
-        for (size_t index = 0; index < array_size(xml_declaration_node->children); index++) {
-          herb_visit_node(array_get(xml_declaration_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(xml_declaration_node->children); index++) {
+          herb_visit_node(hb_array_get(xml_declaration_node->children, index), visitor, data);
         }
       }
 
@@ -144,8 +144,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_CDATA_NODE_T* cdata_node = ((const AST_CDATA_NODE_T *) node);
 
       if (cdata_node->children != NULL) {
-        for (size_t index = 0; index < array_size(cdata_node->children); index++) {
-          herb_visit_node(array_get(cdata_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(cdata_node->children); index++) {
+          herb_visit_node(hb_array_get(cdata_node->children, index), visitor, data);
         }
       }
 
@@ -155,8 +155,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ELSE_NODE_T* erb_else_node = ((const AST_ERB_ELSE_NODE_T *) node);
 
       if (erb_else_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_else_node->statements); index++) {
-          herb_visit_node(array_get(erb_else_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_else_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_else_node->statements, index), visitor, data);
         }
       }
 
@@ -166,8 +166,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IF_NODE_T* erb_if_node = ((const AST_ERB_IF_NODE_T *) node);
 
       if (erb_if_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_if_node->statements); index++) {
-          herb_visit_node(array_get(erb_if_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_if_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_if_node->statements, index), visitor, data);
         }
       }
 
@@ -185,8 +185,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BLOCK_NODE_T* erb_block_node = ((const AST_ERB_BLOCK_NODE_T *) node);
 
       if (erb_block_node->body != NULL) {
-        for (size_t index = 0; index < array_size(erb_block_node->body); index++) {
-          herb_visit_node(array_get(erb_block_node->body, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_block_node->body); index++) {
+          herb_visit_node(hb_array_get(erb_block_node->body, index), visitor, data);
         }
       }
 
@@ -200,8 +200,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHEN_NODE_T* erb_when_node = ((const AST_ERB_WHEN_NODE_T *) node);
 
       if (erb_when_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_when_node->statements); index++) {
-          herb_visit_node(array_get(erb_when_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_when_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_when_node->statements, index), visitor, data);
         }
       }
 
@@ -211,14 +211,14 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_NODE_T* erb_case_node = ((const AST_ERB_CASE_NODE_T *) node);
 
       if (erb_case_node->children != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_node->children); index++) {
-          herb_visit_node(array_get(erb_case_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_case_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_node->conditions != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_node->conditions); index++) {
-          herb_visit_node(array_get(erb_case_node->conditions, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_node->conditions); index++) {
+          herb_visit_node(hb_array_get(erb_case_node->conditions, index), visitor, data);
         }
       }
 
@@ -236,14 +236,14 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = ((const AST_ERB_CASE_MATCH_NODE_T *) node);
 
       if (erb_case_match_node->children != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_match_node->children); index++) {
-          herb_visit_node(array_get(erb_case_match_node->children, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->children); index++) {
+          herb_visit_node(hb_array_get(erb_case_match_node->children, index), visitor, data);
         }
       }
 
       if (erb_case_match_node->conditions != NULL) {
-        for (size_t index = 0; index < array_size(erb_case_match_node->conditions); index++) {
-          herb_visit_node(array_get(erb_case_match_node->conditions, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_case_match_node->conditions); index++) {
+          herb_visit_node(hb_array_get(erb_case_match_node->conditions, index), visitor, data);
         }
       }
 
@@ -261,8 +261,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_WHILE_NODE_T* erb_while_node = ((const AST_ERB_WHILE_NODE_T *) node);
 
       if (erb_while_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_while_node->statements); index++) {
-          herb_visit_node(array_get(erb_while_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_while_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_while_node->statements, index), visitor, data);
         }
       }
 
@@ -276,8 +276,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNTIL_NODE_T* erb_until_node = ((const AST_ERB_UNTIL_NODE_T *) node);
 
       if (erb_until_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_until_node->statements); index++) {
-          herb_visit_node(array_get(erb_until_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_until_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_until_node->statements, index), visitor, data);
         }
       }
 
@@ -291,8 +291,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_FOR_NODE_T* erb_for_node = ((const AST_ERB_FOR_NODE_T *) node);
 
       if (erb_for_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_for_node->statements); index++) {
-          herb_visit_node(array_get(erb_for_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_for_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_for_node->statements, index), visitor, data);
         }
       }
 
@@ -306,8 +306,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_RESCUE_NODE_T* erb_rescue_node = ((const AST_ERB_RESCUE_NODE_T *) node);
 
       if (erb_rescue_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_rescue_node->statements); index++) {
-          herb_visit_node(array_get(erb_rescue_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_rescue_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_rescue_node->statements, index), visitor, data);
         }
       }
 
@@ -321,8 +321,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_ENSURE_NODE_T* erb_ensure_node = ((const AST_ERB_ENSURE_NODE_T *) node);
 
       if (erb_ensure_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_ensure_node->statements); index++) {
-          herb_visit_node(array_get(erb_ensure_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_ensure_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_ensure_node->statements, index), visitor, data);
         }
       }
 
@@ -332,8 +332,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_BEGIN_NODE_T* erb_begin_node = ((const AST_ERB_BEGIN_NODE_T *) node);
 
       if (erb_begin_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_begin_node->statements); index++) {
-          herb_visit_node(array_get(erb_begin_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_begin_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_begin_node->statements, index), visitor, data);
         }
       }
 
@@ -359,8 +359,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_UNLESS_NODE_T* erb_unless_node = ((const AST_ERB_UNLESS_NODE_T *) node);
 
       if (erb_unless_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_unless_node->statements); index++) {
-          herb_visit_node(array_get(erb_unless_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_unless_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_unless_node->statements, index), visitor, data);
         }
       }
 
@@ -378,8 +378,8 @@ void herb_visit_child_nodes(const AST_NODE_T *node, bool (*visitor)(const AST_NO
       const AST_ERB_IN_NODE_T* erb_in_node = ((const AST_ERB_IN_NODE_T *) node);
 
       if (erb_in_node->statements != NULL) {
-        for (size_t index = 0; index < array_size(erb_in_node->statements); index++) {
-          herb_visit_node(array_get(erb_in_node->statements, index), visitor, data);
+        for (size_t index = 0; index < hb_array_size(erb_in_node->statements); index++) {
+          herb_visit_node(hb_array_get(erb_in_node->statements, index), visitor, data);
         }
       }
 

package/extension/libherb/visitor.h

@@ -1,9 +1,9 @@
 #ifndef HERB_VISITOR_H
 #define HERB_VISITOR_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "ast_nodes.h"
+#include "util/hb_array.h"
 
 void herb_visit_node(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T*, void*), void* data);
 void herb_visit_child_nodes(const AST_NODE_T* node, bool (*visitor)(const AST_NODE_T* node, void* data), void* data);