@herb-tools/node 0.8.9 → 0.9.0

package/extension/libherb/util/hb_arena_debug.c

@@ -3,6 +3,7 @@
 #include <string.h>
 
 #include "../include/util/hb_arena.h"
+#include "../include/util/hb_arena_debug.h"
 
 #define ANSI_COLOR_GREEN "\033[32m"
 #define ANSI_COLOR_YELLOW "\033[33m"
@@ -117,6 +118,29 @@ static void print_box_line_with_bullet_and_color(const char* color, const char*
   printf("║%s%*s║\n", line, BOX_WIDTH - visual_length, "");
 }
 
+hb_arena_stats_T hb_arena_get_stats(const hb_arena_T* arena) {
+  hb_arena_stats_T stats = { 0 };
+
+  if (arena->head == NULL) { return stats; }
+
+  stats.default_page_size = arena->default_page_size;
+  stats.allocations = arena->allocation_count;
+
+  hb_arena_for_each_page_const(arena) {
+    stats.pages++;
+    stats.total_capacity += page->capacity;
+    stats.total_used += page->position;
+
+    if (page != arena->tail && page->position < page->capacity) {
+      stats.fragmentation += (page->capacity - page->position);
+    }
+  }
+
+  stats.total_available = stats.total_capacity - stats.total_used;
+
+  return stats;
+}
+
 void hb_arena_print_stats(const hb_arena_T* allocator) {
   if (allocator->head == NULL) {
     print_box_top();
@@ -128,22 +152,13 @@ void hb_arena_print_stats(const hb_arena_T* allocator) {
     return;
   }
 
-  size_t num_pages = 0;
-  size_t total_capacity = 0;
-  size_t total_used = 0;
-  size_t fragmentation = 0;
+  hb_arena_stats_T stats = hb_arena_get_stats(allocator);
 
-  for (const hb_arena_page_T* page = allocator->head; page != NULL; page = page->next) {
-    num_pages++;
-    total_capacity += page->capacity;
-    total_used += page->position;
-
-    if (page != allocator->tail && page->position < page->capacity) {
-      fragmentation += (page->capacity - page->position);
-    }
-  }
+  size_t total_capacity = stats.total_capacity;
+  size_t total_used = stats.total_used;
+  size_t total_available = stats.total_available;
+  size_t fragmentation = stats.fragmentation;
 
-  size_t total_available = total_capacity - total_used;
   double usage_percentage = (double) total_used / (double) total_capacity * 100.0;
   double fragmentation_percentage = (double) fragmentation / (double) total_capacity * 100.0;
   const char* overall_color = get_usage_color(usage_percentage);
@@ -160,7 +175,7 @@ void hb_arena_print_stats(const hb_arena_T* allocator) {
   print_box_separator();
   print_box_line("  Statistics:");
 
-  print_box_line_with_bullet("    • Pages: %zu", num_pages);
+  print_box_line_with_bullet("    • Pages: %zu", stats.pages);
   print_box_line_with_bullet("    • Default Page Size: %s", default_size_string);
   print_box_line_with_bullet("    • Total Capacity: %s", capacity_string);
   print_box_line_with_bullet_and_color(
@@ -178,7 +193,7 @@ void hb_arena_print_stats(const hb_arena_T* allocator) {
     usage_percentage,
     ANSI_COLOR_RESET
   );
-  print_box_line_with_bullet("    • Allocations: %zu", allocator->allocation_count);
+  print_box_line_with_bullet("    • Allocations: %zu", stats.allocations);
   print_box_line_with_bullet("    • Fragmentation: %s", fragmentation_string);
 
   if (fragmentation > 0) { print_box_line("      (%.1f%% skipped in non-tail pages)", fragmentation_percentage); }
@@ -187,7 +202,7 @@ void hb_arena_print_stats(const hb_arena_T* allocator) {
 
   size_t page_number = 0;
 
-  for (const hb_arena_page_T* page = allocator->head; page != NULL; page = page->next) {
+  hb_arena_for_each_page_const(allocator) {
     double page_usage = (double) page->position / (double) page->capacity * 100.0;
     const char* page_color = get_usage_color(page_usage);
 

package/extension/libherb/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/util/hb_array.c

@@ -2,28 +2,39 @@
 #include <stdio.h>
 
 #include "../include/macros.h"
+#include "../include/util/hb_allocator.h"
 #include "../include/util/hb_array.h"
 
 size_t hb_array_sizeof(void) {
   return sizeof(hb_array_T);
 }
 
-hb_array_T* hb_array_init(const size_t capacity) {
-  hb_array_T* array = malloc(hb_array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity, hb_allocator_T* allocator) {
+  hb_array_T* array = hb_allocator_alloc(allocator, hb_array_sizeof());
+
+  if (!array) { return NULL; }
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = malloc(capacity * sizeof(void*));
+  array->allocator = allocator;
+
+  if (capacity == 0) {
+    array->items = NULL;
+  } else {
+    array->items = hb_allocator_alloc(allocator, capacity * sizeof(void*));
 
-  if (!array->items) {
-    free(array);
-    return NULL;
+    if (!array->items) {
+      hb_allocator_dealloc(allocator, array);
+      return NULL;
+    }
   }
 
   return array;
 }
 
-void hb_array_append(hb_array_T* array, void* item) {
+bool hb_array_append(hb_array_T* array, void* item) {
+  if (!array) { return false; }
+
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -40,20 +51,23 @@ void hb_array_append(hb_array_T* array, void* item) {
 
     if (new_capacity > SIZE_MAX / sizeof(void*)) {
       fprintf(stderr, "Error: Array allocation would exceed system limits.\n");
-      return;
+      return false;
     }
 
+    size_t old_size_bytes = array->capacity * sizeof(void*);
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = realloc(array->items, new_size_bytes);
+    void** new_items = hb_allocator_realloc(array->allocator, array->items, old_size_bytes, new_size_bytes);
 
-    if (unlikely(new_items == NULL)) { return; }
+    if (unlikely(new_items == NULL)) { return false; }
 
-    array->items = (void**) new_items;
+    array->items = new_items;
     array->capacity = new_capacity;
   }
 
   array->items[array->size] = item;
   array->size++;
+
+  return true;
 }
 
 void* hb_array_get(const hb_array_T* array, const size_t index) {
@@ -103,8 +117,8 @@ void hb_array_remove_item(hb_array_T* array, void* item) {
 }
 
 // Alias for hb_array_append
-void hb_array_push(hb_array_T* array, void* item) {
-  hb_array_append(array, item);
+bool hb_array_push(hb_array_T* array, void* item) {
+  return hb_array_append(array, item);
 }
 
 void* hb_array_pop(hb_array_T* array) {
@@ -130,8 +144,9 @@ size_t hb_array_capacity(const hb_array_T* array) {
 void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
-  free((*array)->items);
-  free(*array);
+  hb_allocator_T* allocator = (*array)->allocator;
+  hb_allocator_dealloc(allocator, (*array)->items);
+  hb_allocator_dealloc(allocator, *array);
 
   *array = NULL;
 }

package/extension/libherb/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/util/hb_buffer.c

@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "../include/macros.h"
-#include "../include/util.h"
+#include "../include/util/hb_allocator.h"
 #include "../include/util/hb_buffer.h"
 
 static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
@@ -22,14 +22,8 @@ static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
     fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
     exit(1);
   }
-  char* new_value = NULL;
 
-  if (buffer->allocator == NULL) {
-    new_value = realloc(buffer->value, new_capacity + 1);
-  } else {
-    new_value = hb_arena_alloc(buffer->allocator, new_capacity + 1);
-    memcpy(new_value, buffer->value, buffer->capacity + 1);
-  }
+  char* new_value = hb_allocator_realloc(buffer->allocator, buffer->value, buffer->capacity + 1, new_capacity + 1);
 
   if (unlikely(new_value == NULL)) {
     fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
@@ -66,11 +60,11 @@ static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t require
   return hb_buffer_resize(buffer, new_capacity);
 }
 
-bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
-  buffer->allocator = NULL;
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity, struct hb_allocator* allocator) {
+  buffer->allocator = allocator;
   buffer->capacity = capacity;
   buffer->length = 0;
-  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
+  buffer->value = hb_allocator_alloc(allocator, sizeof(char) * (buffer->capacity + 1));
 
   if (!buffer->value) {
     fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
@@ -83,16 +77,6 @@ bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
   return true;
 }
 
-bool hb_buffer_init_arena(hb_buffer_T* buffer, hb_arena_T* allocator, size_t capacity) {
-  buffer->allocator = allocator;
-  buffer->capacity = capacity;
-  buffer->length = 0;
-  buffer->value = hb_arena_alloc(allocator, sizeof(char) * (buffer->capacity + 1));
-  buffer->value[0] = '\0';
-
-  return true;
-}
-
 char* hb_buffer_value(const hb_buffer_T* buffer) {
   return buffer->value;
 }
@@ -101,6 +85,10 @@ size_t hb_buffer_length(const hb_buffer_T* buffer) {
   return buffer->length;
 }
 
+bool hb_buffer_is_empty(const hb_buffer_T* buffer) {
+  return buffer->length == 0;
+}
+
 size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
   return buffer->capacity;
 }
@@ -205,6 +193,14 @@ void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
   destination->value[destination->length] = '\0';
 }
 
+void hb_buffer_free(hb_buffer_T* buffer) {
+  if (!buffer) { return; }
+  hb_allocator_dealloc(buffer->allocator, buffer->value);
+  buffer->value = NULL;
+  buffer->length = 0;
+  buffer->capacity = 0;
+}
+
 void hb_buffer_clear(hb_buffer_T* buffer) {
   buffer->length = 0;
   buffer->value[0] = '\0';

package/extension/libherb/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/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/util/hb_narray.c

@@ -4,25 +4,40 @@
 #include <stdbool.h>
 #include <string.h>
 
-void hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity) {
+bool hb_narray_init(hb_narray_T* array, size_t item_size, size_t initial_capacity, hb_allocator_T* allocator) {
   assert(initial_capacity != 0);
 
+  array->allocator = allocator;
   array->item_size = item_size;
   array->capacity = initial_capacity;
   array->size = 0;
-  array->items = malloc(array->capacity * array->item_size);
+  array->items = hb_allocator_alloc(array->allocator, array->capacity * array->item_size);
+
+  if (!array->items) { return false; }
+
+  return true;
 }
 
-void hb_narray_append(hb_narray_T* array, void* item) {
+bool hb_narray_append(hb_narray_T* array, void* item) {
   if (array->size + 1 > array->capacity) {
-    array->capacity *= 2;
-    void* new_buffer = realloc(array->items, array->capacity * array->item_size);
-    assert(new_buffer != NULL);
+    size_t new_capacity = array->capacity * 2;
+    void* new_buffer = hb_allocator_realloc(
+      array->allocator,
+      array->items,
+      array->capacity * array->item_size,
+      new_capacity * array->item_size
+    );
+
+    if (!new_buffer) { return false; }
+
     array->items = new_buffer;
+    array->capacity = new_capacity;
   }
 
   memcpy(array->items + (array->size * array->item_size), item, array->item_size);
   array->size += 1;
+
+  return true;
 }
 
 static inline uint8_t* hb_narray_memory_position(const hb_narray_T* array, size_t index) {
@@ -71,7 +86,7 @@ void hb_narray_deinit(hb_narray_T* array) {
   array->item_size = 0;
   array->capacity = 0;
   array->size = 0;
-  free(array->items);
+  hb_allocator_dealloc(array->allocator, array->items);
 }
 
 size_t hb_narray_size(const hb_narray_T* array) {

package/extension/libherb/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);
 

package/extension/libherb/util/hb_string.c

@@ -1,11 +1,14 @@
 #include "../include/util/hb_string.h"
 #include "../include/macros.h"
+#include "../include/util.h"
 
 #include <stdlib.h>
 #include <string.h>
 #include <strings.h>
 
-hb_string_T hb_string(const char* null_terminated_c_string) {
+hb_string_T hb_string_from_c_string(const char* null_terminated_c_string) {
+  if (null_terminated_c_string == NULL) { return HB_STRING_NULL; }
+
   hb_string_T string;
 
   string.data = (char*) null_terminated_c_string;
@@ -14,61 +17,72 @@ hb_string_T hb_string(const char* 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;
+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 slice;
+  return truncated_string;
 }
 
-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;
+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);
 }
 
-bool hb_string_equals_case_insensitive(hb_string_T a, hb_string_T b) {
-  if (a.length != b.length) { return false; }
+hb_string_T hb_string_trim_start(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return string; }
 
-  return strncasecmp(a.data, b.data, a.length) == 0;
+  uint32_t offset = 0;
+  while (offset < string.length && is_whitespace(string.data[offset])) {
+    offset++;
+  }
+
+  return hb_string_slice(string, offset);
 }
 
-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; }
+hb_string_T hb_string_trim_end(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return string; }
+
+  uint32_t length = string.length;
+  while (length > 0 && is_whitespace(string.data[length - 1])) {
+    length--;
+  }
 
-  return strncmp(string.data, expected_prefix.data, expected_prefix.length) == 0;
+  return hb_string_truncate(string, length);
 }
 
-bool hb_string_is_empty(hb_string_T string) {
-  return string.length == 0;
+hb_string_T hb_string_trim(hb_string_T string) {
+  return hb_string_trim_end(hb_string_trim_start(string));
 }
 
-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) };
+bool hb_string_is_blank(hb_string_T string) {
+  if (hb_string_is_empty(string)) { return true; }
 
-  return truncated_string;
+  for (uint32_t i = 0; i < string.length; i++) {
+    if (!is_whitespace(string.data[i])) { return false; }
+  }
+
+  return true;
 }
 
-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);
+hb_string_T hb_string_copy(hb_string_T string, hb_allocator_T* allocator) {
+  if (hb_string_is_null(string)) { return HB_STRING_NULL; }
+  if (hb_string_is_empty(string)) { return HB_STRING_EMPTY; }
+
+  char* copy = hb_allocator_strndup(allocator, string.data, string.length);
+
+  return (hb_string_T) { .data = copy, .length = string.length };
 }
 
 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_null(string)) { return NULL; }
 
-  if (!hb_string_is_empty(string)) { memcpy(buffer, string.data, string_length_in_bytes); }
+  size_t length = string.length;
+  char* buffer = malloc(length + 1);
 
-  buffer[string_length_in_bytes] = '\0';
+  if (!buffer) { return NULL; }
+
+  if (length > 0) { memcpy(buffer, string.data, length); }
+
+  buffer[length] = '\0';
 
   return buffer;
 }