@herb-tools/node 0.8.10 → 0.9.0

package/extension/libherb/include/parser.h

@@ -3,6 +3,7 @@
 
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_allocator.h"
 #include "util/hb_array.h"
 
 typedef enum {
@@ -17,17 +18,32 @@ typedef enum { PARSER_STATE_DATA, PARSER_STATE_FOREIGN_CONTENT } parser_state_T;
 
 typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
+  bool analyze;
+  bool strict;
+  bool action_view_helpers;
+  bool prism_program;
+  bool prism_nodes;
+  bool prism_nodes_deep;
 } parser_options_T;
 
+typedef struct MATCH_TAGS_CONTEXT_STRUCT {
+  hb_array_T* errors;
+  const parser_options_T* options;
+  hb_allocator_T* allocator;
+} match_tags_context_T;
+
 extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
 
 typedef struct PARSER_STRUCT {
+  hb_allocator_T* allocator;
   lexer_T* lexer;
   token_T* current_token;
   hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
   parser_options_T options;
+  size_t consecutive_error_count;
+  bool in_recovery_mode;
 } parser_T;
 
 size_t parser_sizeof(void);
@@ -36,10 +52,19 @@ void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
-void herb_parser_match_html_tags_post_analyze(AST_DOCUMENT_NODE_T* document);
+void herb_parser_match_html_tags_post_analyze(
+  AST_DOCUMENT_NODE_T* document,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 void herb_parser_deinit(parser_T* parser);
 
-void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors);
+void match_tags_in_node_array(
+  hb_array_T* nodes,
+  hb_array_T* errors,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 bool match_tags_visitor(const AST_NODE_T* node, void* data);
 
 #endif

package/extension/libherb/include/parser_helpers.h

@@ -13,11 +13,21 @@ void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
 bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(
+void parser_append_unexpected_error_impl(
   parser_T* parser,
+  hb_array_T* errors,
   const char* description,
-  const char* expected,
-  hb_array_T* errors
+  token_type_T first_token,
+  ...
+);
+#define parser_append_unexpected_error(parser, errors, description, ...)                                               \
+  parser_append_unexpected_error_impl(parser, errors, description, __VA_ARGS__, TOKEN_SENTINEL)
+
+void parser_append_unexpected_error_string(
+  parser_T* parser,
+  hb_array_T* errors,
+  const char* description,
+  const char* expected
 );
 void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
@@ -44,6 +54,7 @@ token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
 token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
+  parser_T* parser,
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
   hb_array_T* body,
   hb_array_T* errors
@@ -54,4 +65,9 @@ void parser_handle_mismatched_tags(
   hb_array_T* errors
 );
 
+void parser_synchronize(parser_T* parser, hb_array_T* errors);
+
+bool parser_can_close_ancestor(const parser_T* parser, hb_string_T tag_name);
+size_t parser_find_ancestor_depth(const parser_T* parser, hb_string_T tag_name);
+
 #endif

package/extension/libherb/include/pretty_print.h

@@ -1,12 +1,16 @@
 #ifndef HERB_PRETTY_PRINT_H
 #define HERB_PRETTY_PRINT_H
 
-#include "analyzed_ruby.h"
-#include "ast_nodes.h"
-#include "location.h"
-#include "util/hb_buffer.h"
+#ifdef HERB_EXCLUDE_PRETTYPRINT
+// Pretty print support excluded
+#else
 
-#include <stdbool.h>
+#  include "analyze/analyzed_ruby.h"
+#  include "ast_nodes.h"
+#  include "location.h"
+#  include "util/hb_buffer.h"
+
+#  include <stdbool.h>
 
 void pretty_print_indent(hb_buffer_T* buffer, size_t indent);
 void pretty_print_newline(size_t indent, size_t relative_indent, hb_buffer_T* buffer);
@@ -101,3 +105,4 @@ void pretty_print_errors(
 );
 
 #endif
+#endif

package/extension/libherb/include/prism_context.h

@@ -0,0 +1,45 @@
+#ifndef HERB_PRISM_CONTEXT_H
+#define HERB_PRISM_CONTEXT_H
+
+#include "util/hb_allocator.h"
+#include "util/hb_buffer.h"
+#include <prism.h>
+#include <stdbool.h>
+
+typedef struct {
+  pm_parser_t parser;
+  pm_options_t pm_opts;
+  pm_node_t* root;
+  hb_buffer_T ruby_buf;
+
+  bool has_structural;
+  pm_parser_t structural_parser;
+  pm_options_t structural_pm_opts;
+  pm_node_t* structural_root;
+  hb_buffer_T structural_buf;
+
+  hb_allocator_T* allocator;
+} herb_prism_context_T;
+
+static inline void herb_prism_context_free(herb_prism_context_T* context) {
+  if (!context) { return; }
+
+  if (context->root) { pm_node_destroy(&context->parser, context->root); }
+
+  pm_parser_free(&context->parser);
+  pm_options_free(&context->pm_opts);
+  hb_buffer_free(&context->ruby_buf);
+
+  if (context->has_structural) {
+    if (context->structural_root) { pm_node_destroy(&context->structural_parser, context->structural_root); }
+
+    pm_parser_free(&context->structural_parser);
+    pm_options_free(&context->structural_pm_opts);
+
+    if (context->structural_buf.value) { hb_buffer_free(&context->structural_buf); }
+  }
+
+  hb_allocator_dealloc(context->allocator, context);
+}
+
+#endif

package/extension/libherb/include/prism_helpers.h

@@ -1,31 +1,34 @@
 #ifndef HERB_PRISM_HELPERS_H
 #define HERB_PRISM_HELPERS_H
 
-#include "analyzed_ruby.h"
+#include "analyze/analyzed_ruby.h"
 #include "ast_nodes.h"
 #include "errors.h"
 #include "location.h"
 #include "position.h"
+#include "util/hb_allocator.h"
 
 #include <prism.h>
 
-const char* pm_error_level_to_string(pm_error_level_t level);
+hb_string_T pm_error_level_to_string(pm_error_level_t level);
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error(
   const pm_diagnostic_t* error,
   const AST_NODE_T* node,
   const char* source,
-  pm_parser_t* parser
+  pm_parser_t* parser,
+  hb_allocator_T* allocator
 );
 
 RUBY_PARSE_ERROR_T* ruby_parse_error_from_prism_error_with_positions(
   const pm_diagnostic_t* error,
   position_T start,
-  position_T end
+  position_T end,
+  hb_allocator_T* allocator
 );
 
-location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source);
-location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause);
-location_T* get_then_keyword_location_elsif_wrapped(const char* source);
+location_T* get_then_keyword_location(analyzed_ruby_T* analyzed, const char* source, hb_allocator_T* allocator);
+location_T* get_then_keyword_location_wrapped(const char* source, bool is_in_clause, hb_allocator_T* allocator);
+location_T* get_then_keyword_location_elsif_wrapped(const char* source, hb_allocator_T* allocator);
 
 #endif

package/extension/libherb/include/prism_serialized.h

@@ -0,0 +1,12 @@
+#ifndef HERB_PRISM_SERIALIZED_H
+#define HERB_PRISM_SERIALIZED_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct {
+  uint8_t* data;
+  size_t length;
+} prism_serialized_T;
+
+#endif

package/extension/libherb/include/token.h

@@ -4,15 +4,27 @@
 #include "lexer_struct.h"
 #include "position.h"
 #include "token_struct.h"
+#include "util/hb_allocator.h"
 #include "util/hb_string.h"
 
+#include <stdarg.h>
+
 token_T* token_init(hb_string_T value, token_type_T type, lexer_T* lexer);
-hb_string_T token_to_string(const token_T* token);
-const char* token_type_to_string(token_type_T type);
+hb_string_T token_to_string(hb_allocator_T* allocator, const token_T* token);
+hb_string_T token_type_to_string(token_type_T type);
+hb_string_T token_type_to_friendly_string(token_type_T type);
+char* token_types_to_friendly_string_va(hb_allocator_T* allocator, token_type_T first_token, ...);
+char* token_types_to_friendly_string_valist(hb_allocator_T* allocator, token_type_T first_token, va_list args);
+
+#define token_types_to_friendly_string(allocator, ...)                                                                 \
+  token_types_to_friendly_string_va(allocator, __VA_ARGS__, TOKEN_SENTINEL)
+
+hb_string_T token_value(const token_T* token);
+int token_type(const token_T* token);
 
-token_T* token_copy(token_T* token);
+token_T* token_copy(token_T* token, hb_allocator_T* allocator);
 
-void token_free(token_T* token);
+void token_free(token_T* token, hb_allocator_T* allocator);
 
 bool token_value_empty(const token_T* token);
 

package/extension/libherb/include/token_struct.h

@@ -1,8 +1,11 @@
 #ifndef HERB_TOKEN_STRUCT_H
 #define HERB_TOKEN_STRUCT_H
 
+#include <stdbool.h>
+
 #include "location.h"
 #include "range.h"
+#include "util/hb_string.h"
 
 typedef enum {
   TOKEN_WHITESPACE, // ' '
@@ -21,8 +24,9 @@ typedef enum {
   TOKEN_HTML_TAG_END,         // >
   TOKEN_HTML_TAG_SELF_CLOSE,  // />
 
-  TOKEN_HTML_COMMENT_START, // <!--
-  TOKEN_HTML_COMMENT_END,   // -->
+  TOKEN_HTML_COMMENT_START,       // <!--
+  TOKEN_HTML_COMMENT_END,         // -->
+  TOKEN_HTML_COMMENT_INVALID_END, // --!>
 
   TOKEN_ERB_START,   // <%, <%=, <%%=, <%#, <%-, <%==, <%%
   TOKEN_ERB_CONTENT, // Ruby Code
@@ -48,8 +52,11 @@ typedef enum {
   TOKEN_EOF,
 } token_type_T;
 
+// Sentinel value for variadic functions
+#define TOKEN_SENTINEL 99999999
+
 typedef struct TOKEN_STRUCT {
-  char* value;
+  hb_string_T value;
   range_T range;
   location_T location;
   token_type_T type;

package/extension/libherb/include/utf8.h

@@ -1,12 +1,13 @@
 #ifndef HERB_UTF8_H
 #define HERB_UTF8_H
 
+#include "util/hb_string.h"
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
 
 uint32_t utf8_char_byte_length(unsigned char first_byte);
-uint32_t utf8_sequence_length(const char* str, size_t position, size_t max_length);
+uint32_t utf8_sequence_length(hb_string_T value);
 bool utf8_is_valid_continuation_byte(unsigned char byte);
 
 #endif

package/extension/libherb/include/util/hb_allocator.h

@@ -0,0 +1,78 @@
+#ifndef HERB_ALLOCATOR_H
+#define HERB_ALLOCATOR_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "hb_arena.h"
+
+#ifndef HB_ALLOCATOR_DEFAULT_ARENA_SIZE
+#  define HB_ALLOCATOR_DEFAULT_ARENA_SIZE (1024 * 16)
+#endif
+
+typedef enum {
+  HB_ALLOCATOR_MALLOC,
+  HB_ALLOCATOR_ARENA,
+  HB_ALLOCATOR_TRACKING,
+} hb_allocator_type_T;
+
+typedef struct {
+  void* pointer;
+  size_t size;
+} hb_allocator_tracking_entry_T;
+
+typedef struct {
+  size_t allocation_count;
+  size_t deallocation_count;
+  size_t untracked_deallocation_count;
+  size_t bytes_allocated;
+  size_t bytes_deallocated;
+  hb_allocator_tracking_entry_T* buckets;
+  size_t buckets_capacity;
+  size_t buckets_used;
+  void** untracked_pointers;
+  size_t untracked_pointers_size;
+  size_t untracked_pointers_capacity;
+} hb_allocator_tracking_stats_T;
+
+typedef struct hb_allocator {
+  void* (*alloc)(struct hb_allocator* self, size_t size);
+  void* (*realloc)(struct hb_allocator* self, void* pointer, size_t old_size, size_t new_size);
+  void (*dealloc)(struct hb_allocator* self, void* pointer);
+  char* (*strdup)(struct hb_allocator* self, const char* string);
+  char* (*strndup)(struct hb_allocator* self, const char* string, size_t length);
+  void (*destroy)(struct hb_allocator* self);
+  void* context;
+} hb_allocator_T;
+
+bool hb_allocator_init(hb_allocator_T* allocator, hb_allocator_type_T type);
+bool hb_allocator_init_with_size(hb_allocator_T* allocator, hb_allocator_type_T type, size_t initial_size);
+void hb_allocator_destroy(hb_allocator_T* allocator);
+
+hb_allocator_T hb_allocator_with_malloc(void);
+hb_allocator_T hb_allocator_with_arena(hb_arena_T* arena);
+hb_allocator_T hb_allocator_with_tracking(void);
+
+hb_allocator_tracking_stats_T* hb_allocator_tracking_stats(hb_allocator_T* allocator);
+
+static inline void* hb_allocator_alloc(hb_allocator_T* allocator, size_t size) {
+  return allocator->alloc(allocator, size);
+}
+
+static inline void* hb_allocator_realloc(hb_allocator_T* allocator, void* pointer, size_t old_size, size_t new_size) {
+  return allocator->realloc(allocator, pointer, old_size, new_size);
+}
+
+static inline void hb_allocator_dealloc(hb_allocator_T* allocator, void* pointer) {
+  allocator->dealloc(allocator, pointer);
+}
+
+static inline char* hb_allocator_strdup(hb_allocator_T* allocator, const char* string) {
+  return allocator->strdup(allocator, string);
+}
+
+static inline char* hb_allocator_strndup(hb_allocator_T* allocator, const char* string, size_t length) {
+  return allocator->strndup(allocator, string, length);
+}
+
+#endif

package/extension/libherb/include/util/hb_arena.h

@@ -20,12 +20,17 @@ typedef struct HB_ARENA_STRUCT {
   size_t allocation_count;
 } hb_arena_T;
 
+#define hb_arena_for_each_page(arena) for (hb_arena_page_T* page = (arena)->head; page != NULL; page = page->next)
+
+#define hb_arena_for_each_page_const(arena)                                                                            \
+  for (const hb_arena_page_T* page = (arena)->head; page != NULL; page = page->next)
+
 bool hb_arena_init(hb_arena_T* allocator, size_t initial_size);
 void* hb_arena_alloc(hb_arena_T* allocator, size_t size);
 size_t hb_arena_position(hb_arena_T* allocator);
 size_t hb_arena_capacity(hb_arena_T* allocator);
 void hb_arena_reset(hb_arena_T* allocator);
-void hb_arena_reset_to(hb_arena_T* allocator, size_t new_position);
+void hb_arena_reset_to(hb_arena_T* allocator, size_t target_position);
 void hb_arena_free(hb_arena_T* allocator);
 
 #endif

package/extension/libherb/include/util/hb_arena_debug.h

@@ -3,6 +3,17 @@
 
 #include "hb_arena.h"
 
-void hb_arena_print_stats(const hb_arena_T* allocator);
+typedef struct {
+  size_t pages;
+  size_t total_capacity;
+  size_t total_used;
+  size_t total_available;
+  size_t allocations;
+  size_t fragmentation;
+  size_t default_page_size;
+} hb_arena_stats_T;
+
+hb_arena_stats_T hb_arena_get_stats(const hb_arena_T* arena);
+void hb_arena_print_stats(const hb_arena_T* arena);
 
 #endif

package/extension/libherb/include/util/hb_array.h

@@ -1,21 +1,25 @@
 #ifndef HERB_ARRAY_H
 #define HERB_ARRAY_H
 
+#include <stdbool.h>
 #include <stdlib.h>
 
+struct hb_allocator;
+
 typedef struct HB_ARRAY_STRUCT {
   void** items;
   size_t size;
   size_t capacity;
+  struct hb_allocator* allocator;
 } hb_array_T;
 
-hb_array_T* hb_array_init(size_t capacity);
+hb_array_T* hb_array_init(size_t capacity, struct hb_allocator* allocator);
 
 void* hb_array_get(const hb_array_T* array, size_t index);
 void* hb_array_first(hb_array_T* array);
 void* hb_array_last(hb_array_T* array);
 
-void hb_array_append(hb_array_T* array, void* item);
+bool hb_array_append(hb_array_T* array, void* item);
 void hb_array_set(const hb_array_T* array, size_t index, void* item);
 void hb_array_free(hb_array_T** array);
 void hb_array_remove(hb_array_T* array, size_t index);
@@ -23,7 +27,7 @@ void hb_array_remove(hb_array_T* array, size_t index);
 size_t hb_array_index_of(hb_array_T* array, void* item);
 void hb_array_remove_item(hb_array_T* array, void* item);
 
-void hb_array_push(hb_array_T* array, void* item);
+bool hb_array_push(hb_array_T* array, void* item);
 void* hb_array_pop(hb_array_T* array);
 
 size_t hb_array_capacity(const hb_array_T* array);

package/extension/libherb/include/util/hb_buffer.h

@@ -1,21 +1,21 @@
 #ifndef HERB_BUFFER_H
 #define HERB_BUFFER_H
 
-#include "hb_arena.h"
 #include "hb_string.h"
 
 #include <stdbool.h>
 #include <stdlib.h>
 
+struct hb_allocator;
+
 typedef struct HB_BUFFER_STRUCT {
-  hb_arena_T* allocator;
+  struct hb_allocator* allocator;
   char* value;
   size_t length;
   size_t capacity;
 } hb_buffer_T;
 
-bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
-bool hb_buffer_init_arena(hb_buffer_T* buffer, hb_arena_T* allocator, size_t capacity);
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity, struct hb_allocator* allocator);
 
 void hb_buffer_append(hb_buffer_T* buffer, const char* text);
 void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, size_t length);
@@ -28,9 +28,11 @@ void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source);
 char* hb_buffer_value(const hb_buffer_T* buffer);
 
 size_t hb_buffer_length(const hb_buffer_T* buffer);
+bool hb_buffer_is_empty(const hb_buffer_T* buffer);
 size_t hb_buffer_capacity(const hb_buffer_T* buffer);
 size_t hb_buffer_sizeof(void);
 
+void hb_buffer_free(hb_buffer_T* buffer);
 void hb_buffer_clear(hb_buffer_T* buffer);
 
 #endif

package/extension/libherb/include/util/hb_foreach.h

@@ -0,0 +1,79 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.9.0/templates/src/include/util/hb_foreach.h.erb
+
+#ifndef HB_FOREACH_H
+#define HB_FOREACH_H
+
+#define HB_ARG64(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,_19,_20,_21,_22,_23,_24,_25,_26,_27,_28,_29,_30,_31,_32,_33,_34,_35,_36,_37,_38,_39,_40,_41,_42,_43,_44,_45,_46,_47,_48,_49,_50,_51,_52,_53,_54,_55,_56,_57,_58,_59,_60,_61,_62,_63,_64,count,...) count
+#define HB_NARGS(...) HB_ARG64(__VA_ARGS__,64,63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40,39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1)
+
+#define HB_FOR_EACH_1(macro, head) macro(head)
+#define HB_FOR_EACH_2(macro, head, ...) macro(head), HB_FOR_EACH_1(macro, __VA_ARGS__)
+#define HB_FOR_EACH_3(macro, head, ...) macro(head), HB_FOR_EACH_2(macro, __VA_ARGS__)
+#define HB_FOR_EACH_4(macro, head, ...) macro(head), HB_FOR_EACH_3(macro, __VA_ARGS__)
+#define HB_FOR_EACH_5(macro, head, ...) macro(head), HB_FOR_EACH_4(macro, __VA_ARGS__)
+#define HB_FOR_EACH_6(macro, head, ...) macro(head), HB_FOR_EACH_5(macro, __VA_ARGS__)
+#define HB_FOR_EACH_7(macro, head, ...) macro(head), HB_FOR_EACH_6(macro, __VA_ARGS__)
+#define HB_FOR_EACH_8(macro, head, ...) macro(head), HB_FOR_EACH_7(macro, __VA_ARGS__)
+#define HB_FOR_EACH_9(macro, head, ...) macro(head), HB_FOR_EACH_8(macro, __VA_ARGS__)
+#define HB_FOR_EACH_10(macro, head, ...) macro(head), HB_FOR_EACH_9(macro, __VA_ARGS__)
+#define HB_FOR_EACH_11(macro, head, ...) macro(head), HB_FOR_EACH_10(macro, __VA_ARGS__)
+#define HB_FOR_EACH_12(macro, head, ...) macro(head), HB_FOR_EACH_11(macro, __VA_ARGS__)
+#define HB_FOR_EACH_13(macro, head, ...) macro(head), HB_FOR_EACH_12(macro, __VA_ARGS__)
+#define HB_FOR_EACH_14(macro, head, ...) macro(head), HB_FOR_EACH_13(macro, __VA_ARGS__)
+#define HB_FOR_EACH_15(macro, head, ...) macro(head), HB_FOR_EACH_14(macro, __VA_ARGS__)
+#define HB_FOR_EACH_16(macro, head, ...) macro(head), HB_FOR_EACH_15(macro, __VA_ARGS__)
+#define HB_FOR_EACH_17(macro, head, ...) macro(head), HB_FOR_EACH_16(macro, __VA_ARGS__)
+#define HB_FOR_EACH_18(macro, head, ...) macro(head), HB_FOR_EACH_17(macro, __VA_ARGS__)
+#define HB_FOR_EACH_19(macro, head, ...) macro(head), HB_FOR_EACH_18(macro, __VA_ARGS__)
+#define HB_FOR_EACH_20(macro, head, ...) macro(head), HB_FOR_EACH_19(macro, __VA_ARGS__)
+#define HB_FOR_EACH_21(macro, head, ...) macro(head), HB_FOR_EACH_20(macro, __VA_ARGS__)
+#define HB_FOR_EACH_22(macro, head, ...) macro(head), HB_FOR_EACH_21(macro, __VA_ARGS__)
+#define HB_FOR_EACH_23(macro, head, ...) macro(head), HB_FOR_EACH_22(macro, __VA_ARGS__)
+#define HB_FOR_EACH_24(macro, head, ...) macro(head), HB_FOR_EACH_23(macro, __VA_ARGS__)
+#define HB_FOR_EACH_25(macro, head, ...) macro(head), HB_FOR_EACH_24(macro, __VA_ARGS__)
+#define HB_FOR_EACH_26(macro, head, ...) macro(head), HB_FOR_EACH_25(macro, __VA_ARGS__)
+#define HB_FOR_EACH_27(macro, head, ...) macro(head), HB_FOR_EACH_26(macro, __VA_ARGS__)
+#define HB_FOR_EACH_28(macro, head, ...) macro(head), HB_FOR_EACH_27(macro, __VA_ARGS__)
+#define HB_FOR_EACH_29(macro, head, ...) macro(head), HB_FOR_EACH_28(macro, __VA_ARGS__)
+#define HB_FOR_EACH_30(macro, head, ...) macro(head), HB_FOR_EACH_29(macro, __VA_ARGS__)
+#define HB_FOR_EACH_31(macro, head, ...) macro(head), HB_FOR_EACH_30(macro, __VA_ARGS__)
+#define HB_FOR_EACH_32(macro, head, ...) macro(head), HB_FOR_EACH_31(macro, __VA_ARGS__)
+#define HB_FOR_EACH_33(macro, head, ...) macro(head), HB_FOR_EACH_32(macro, __VA_ARGS__)
+#define HB_FOR_EACH_34(macro, head, ...) macro(head), HB_FOR_EACH_33(macro, __VA_ARGS__)
+#define HB_FOR_EACH_35(macro, head, ...) macro(head), HB_FOR_EACH_34(macro, __VA_ARGS__)
+#define HB_FOR_EACH_36(macro, head, ...) macro(head), HB_FOR_EACH_35(macro, __VA_ARGS__)
+#define HB_FOR_EACH_37(macro, head, ...) macro(head), HB_FOR_EACH_36(macro, __VA_ARGS__)
+#define HB_FOR_EACH_38(macro, head, ...) macro(head), HB_FOR_EACH_37(macro, __VA_ARGS__)
+#define HB_FOR_EACH_39(macro, head, ...) macro(head), HB_FOR_EACH_38(macro, __VA_ARGS__)
+#define HB_FOR_EACH_40(macro, head, ...) macro(head), HB_FOR_EACH_39(macro, __VA_ARGS__)
+#define HB_FOR_EACH_41(macro, head, ...) macro(head), HB_FOR_EACH_40(macro, __VA_ARGS__)
+#define HB_FOR_EACH_42(macro, head, ...) macro(head), HB_FOR_EACH_41(macro, __VA_ARGS__)
+#define HB_FOR_EACH_43(macro, head, ...) macro(head), HB_FOR_EACH_42(macro, __VA_ARGS__)
+#define HB_FOR_EACH_44(macro, head, ...) macro(head), HB_FOR_EACH_43(macro, __VA_ARGS__)
+#define HB_FOR_EACH_45(macro, head, ...) macro(head), HB_FOR_EACH_44(macro, __VA_ARGS__)
+#define HB_FOR_EACH_46(macro, head, ...) macro(head), HB_FOR_EACH_45(macro, __VA_ARGS__)
+#define HB_FOR_EACH_47(macro, head, ...) macro(head), HB_FOR_EACH_46(macro, __VA_ARGS__)
+#define HB_FOR_EACH_48(macro, head, ...) macro(head), HB_FOR_EACH_47(macro, __VA_ARGS__)
+#define HB_FOR_EACH_49(macro, head, ...) macro(head), HB_FOR_EACH_48(macro, __VA_ARGS__)
+#define HB_FOR_EACH_50(macro, head, ...) macro(head), HB_FOR_EACH_49(macro, __VA_ARGS__)
+#define HB_FOR_EACH_51(macro, head, ...) macro(head), HB_FOR_EACH_50(macro, __VA_ARGS__)
+#define HB_FOR_EACH_52(macro, head, ...) macro(head), HB_FOR_EACH_51(macro, __VA_ARGS__)
+#define HB_FOR_EACH_53(macro, head, ...) macro(head), HB_FOR_EACH_52(macro, __VA_ARGS__)
+#define HB_FOR_EACH_54(macro, head, ...) macro(head), HB_FOR_EACH_53(macro, __VA_ARGS__)
+#define HB_FOR_EACH_55(macro, head, ...) macro(head), HB_FOR_EACH_54(macro, __VA_ARGS__)
+#define HB_FOR_EACH_56(macro, head, ...) macro(head), HB_FOR_EACH_55(macro, __VA_ARGS__)
+#define HB_FOR_EACH_57(macro, head, ...) macro(head), HB_FOR_EACH_56(macro, __VA_ARGS__)
+#define HB_FOR_EACH_58(macro, head, ...) macro(head), HB_FOR_EACH_57(macro, __VA_ARGS__)
+#define HB_FOR_EACH_59(macro, head, ...) macro(head), HB_FOR_EACH_58(macro, __VA_ARGS__)
+#define HB_FOR_EACH_60(macro, head, ...) macro(head), HB_FOR_EACH_59(macro, __VA_ARGS__)
+#define HB_FOR_EACH_61(macro, head, ...) macro(head), HB_FOR_EACH_60(macro, __VA_ARGS__)
+#define HB_FOR_EACH_62(macro, head, ...) macro(head), HB_FOR_EACH_61(macro, __VA_ARGS__)
+#define HB_FOR_EACH_63(macro, head, ...) macro(head), HB_FOR_EACH_62(macro, __VA_ARGS__)
+#define HB_FOR_EACH_64(macro, head, ...) macro(head), HB_FOR_EACH_63(macro, __VA_ARGS__)
+
+#define HB_CONCAT(left, right) left ## right
+#define HB_FOR_EACH_N(count) HB_CONCAT(HB_FOR_EACH_, count)
+#define HB_FOR_EACH(macro, ...) HB_FOR_EACH_N(HB_NARGS(__VA_ARGS__))(macro, __VA_ARGS__)
+
+#endif

package/extension/libherb/include/util/hb_narray.h

@@ -1,26 +1,30 @@
 #ifndef HERB_NARRAY_H
 #define HERB_NARRAY_H
 
+#include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <stdbool.h>
+
+#include "hb_allocator.h"
 
 typedef struct HB_NARRAY_STRUCT {
+  hb_allocator_T* allocator;
   uint8_t* items;
   size_t item_size;
   size_t size;
   size_t capacity;
 } hb_narray_T;
 
-void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity);
-#define hb_narray_pointer_init(array, initial_capacity) (hb_narray_init(array, sizeof(void*), initial_capacity))
+bool hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity, hb_allocator_T* allocator);
+#define hb_narray_pointer_init(array, initial_capacity, allocator)                                                     \
+  (hb_narray_init(array, sizeof(void*), initial_capacity, allocator))
 
 void* hb_narray_get(const hb_narray_T* array, size_t index);
 void* hb_narray_first(hb_narray_T* array);
 void* hb_narray_last(hb_narray_T* array);
 size_t hb_narray_size(const hb_narray_T* array);
 
-void hb_narray_append(hb_narray_T* array, void* item);
+bool hb_narray_append(hb_narray_T* array, void* item);
 void hb_narray_remove(hb_narray_T* array, size_t index);
 void hb_narray_deinit(hb_narray_T* array);