@herb-tools/node 0.7.4 → 0.8.0

package/extension/libherb/util/hb_arena_debug.c

@@ -0,0 +1,237 @@
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../include/util/hb_arena.h"
+
+#define ANSI_COLOR_GREEN "\033[32m"
+#define ANSI_COLOR_YELLOW "\033[33m"
+#define ANSI_COLOR_RED "\033[31m"
+#define ANSI_COLOR_RESET "\033[0m"
+
+#define UTF8_BULLET_OVERHEAD 2
+#define BOX_WIDTH 100
+
+static const char* get_usage_color(double percentage) {
+  if (percentage >= 90.0) {
+    return ANSI_COLOR_RED;
+  } else if (percentage >= 70.0) {
+    return ANSI_COLOR_YELLOW;
+  } else {
+    return ANSI_COLOR_GREEN;
+  }
+}
+
+static void format_bytes(size_t bytes, char* buffer, size_t buffer_size) {
+  if (bytes >= 1024 * 1024) {
+    snprintf(buffer, buffer_size, "%.2f MB", bytes / (1024.0 * 1024.0));
+  } else if (bytes >= 1024) {
+    snprintf(buffer, buffer_size, "%zu KB", bytes / 1024);
+  } else {
+    snprintf(buffer, buffer_size, "%zu B", bytes);
+  }
+}
+
+static void print_progress_bar(size_t used, size_t capacity, int width, const char* color) {
+  int filled = (int) ((double) used / (double) capacity * width);
+
+  printf("%s[", color);
+
+  for (int i = 0; i < width; i++) {
+    if (i < filled) {
+      printf("█");
+    } else {
+      printf("░");
+    }
+  }
+
+  printf("]%s", ANSI_COLOR_RESET);
+}
+
+static void print_box_top(void) {
+  printf("╔");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╗\n");
+}
+
+static void print_box_separator(void) {
+  printf("╠");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╣\n");
+}
+
+static void print_box_bottom(void) {
+  printf("╚");
+  for (int i = 0; i < BOX_WIDTH; i++) {
+    printf("═");
+  }
+  printf("╝\n");
+}
+
+static void print_box_line(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  printf("║%s%*s║\n", line, BOX_WIDTH - length, "");
+}
+
+static void print_box_line_centered(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  int total_padding = BOX_WIDTH - length;
+  int left_padding = total_padding / 2;
+  int right_padding = total_padding - left_padding;
+
+  printf("║%*s%s%*s║\n", left_padding, "", line, right_padding, "");
+}
+
+static void print_box_line_with_bullet(const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  printf("║%s%*s║\n", line, BOX_WIDTH - (length - UTF8_BULLET_OVERHEAD), "");
+}
+
+static void print_box_line_with_bullet_and_color(const char* color, const char* format, ...) {
+  char line[256];
+  va_list args;
+  va_start(args, format);
+  int length = vsnprintf(line, sizeof(line), format, args);
+  va_end(args);
+
+  int visual_length = length - UTF8_BULLET_OVERHEAD - (int) strlen(color) - (int) strlen(ANSI_COLOR_RESET);
+  printf("║%s%*s║\n", line, BOX_WIDTH - visual_length, "");
+}
+
+void hb_arena_print_stats(const hb_arena_T* allocator) {
+  if (allocator->head == NULL) {
+    print_box_top();
+    print_box_line_centered("ARENA MEMORY LAYOUT");
+    print_box_separator();
+    print_box_line("  Arena is empty (not initialized)");
+    print_box_bottom();
+
+    return;
+  }
+
+  size_t num_pages = 0;
+  size_t total_capacity = 0;
+  size_t total_used = 0;
+  size_t fragmentation = 0;
+
+  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_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);
+
+  char capacity_string[32], used_string[32], available_string[32], fragmentation_string[32], default_size_string[32];
+  format_bytes(total_capacity, capacity_string, sizeof(capacity_string));
+  format_bytes(total_used, used_string, sizeof(used_string));
+  format_bytes(total_available, available_string, sizeof(available_string));
+  format_bytes(fragmentation, fragmentation_string, sizeof(fragmentation_string));
+  format_bytes(allocator->default_page_size, default_size_string, sizeof(default_size_string));
+
+  print_box_top();
+  print_box_line_centered("ARENA MEMORY LAYOUT");
+  print_box_separator();
+  print_box_line("  Statistics:");
+
+  print_box_line_with_bullet("    • Pages: %zu", num_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(
+    overall_color,
+    "    • Total Used: %s%s%s",
+    overall_color,
+    used_string,
+    ANSI_COLOR_RESET
+  );
+  print_box_line_with_bullet("    • Total Available: %s", available_string);
+  print_box_line_with_bullet_and_color(
+    overall_color,
+    "    • Usage: %s%.1f%%%s",
+    overall_color,
+    usage_percentage,
+    ANSI_COLOR_RESET
+  );
+  print_box_line_with_bullet("    • Allocations: %zu", allocator->allocation_count);
+  print_box_line_with_bullet("    • Fragmentation: %s", fragmentation_string);
+
+  if (fragmentation > 0) { print_box_line("      (%.1f%% skipped in non-tail pages)", fragmentation_percentage); }
+
+  print_box_separator();
+
+  size_t page_number = 0;
+
+  for (const hb_arena_page_T* page = allocator->head; page != NULL; page = page->next) {
+    double page_usage = (double) page->position / (double) page->capacity * 100.0;
+    const char* page_color = get_usage_color(page_usage);
+
+    char page_capacity_string[32], page_used_string[32];
+    format_bytes(page->capacity, page_capacity_string, sizeof(page_capacity_string));
+    format_bytes(page->position, page_used_string, sizeof(page_used_string));
+
+    if (page == allocator->tail) {
+      char header_line[256];
+      snprintf(header_line, sizeof(header_line), "  Page %zu @ %p ← CURRENT", page_number, (void*) page);
+      int visual_length = (int) strlen(header_line) - 2;
+      printf("║%s%*s║\n", header_line, BOX_WIDTH - visual_length, "");
+    } else {
+      print_box_line("  Page %zu @ %p", page_number, (void*) page);
+    }
+
+    char stats_line[128];
+    int stats_length =
+      snprintf(stats_line, sizeof(stats_line), "%s / %s (%.0f%%)", page_used_string, page_capacity_string, page_usage);
+
+    int bar_width = BOX_WIDTH - 4 - 2 - 2 - stats_length - 1;
+    int bar_with_brackets = bar_width + 2;
+
+    printf("║    ");
+    print_progress_bar(page->position, page->capacity, bar_width, page_color);
+    printf("  %s %*s║\n", stats_line, BOX_WIDTH - 4 - bar_with_brackets - 2 - stats_length - 1, "");
+
+    size_t unused = page->capacity - page->position;
+
+    if (unused > 0) {
+      char unused_string[32];
+      format_bytes(unused, unused_string, sizeof(unused_string));
+
+      if (page == allocator->tail) {
+        print_box_line("    Unused: %s (available for allocations)", unused_string);
+      } else {
+        print_box_line("    Unused: %s", unused_string);
+      }
+    }
+
+    printf("║%*s║\n", BOX_WIDTH, "");
+
+    page_number++;
+  }
+
+  print_box_bottom();
+}

package/extension/libherb/util/hb_arena_debug.h

@@ -0,0 +1,8 @@
+#ifndef HERB_ARENA_DEBUG_H
+#define HERB_ARENA_DEBUG_H
+
+#include "hb_arena.h"
+
+void hb_arena_print_stats(const hb_arena_T* allocator);
+
+#endif

package/extension/libherb/{array.c → util/hb_array.c}

@@ -1,20 +1,19 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "include/array.h"
-#include "include/macros.h"
-#include "include/memory.h"
+#include "../include/macros.h"
+#include "../include/util/hb_array.h"
 
-size_t array_sizeof(void) {
-  return sizeof(array_T);
+size_t hb_array_sizeof(void) {
+  return sizeof(hb_array_T);
 }
 
-array_T* array_init(const size_t capacity) {
-  array_T* array = safe_malloc(array_sizeof());
+hb_array_T* hb_array_init(const size_t capacity) {
+  hb_array_T* array = malloc(hb_array_sizeof());
 
   array->size = 0;
   array->capacity = capacity;
-  array->items = nullable_safe_malloc(sizeof(void*) * capacity);
+  array->items = malloc(capacity * sizeof(void*));
 
   if (!array->items) {
     free(array);
@@ -24,7 +23,7 @@ array_T* array_init(const size_t capacity) {
   return array;
 }
 
-void array_append(array_T* array, void* item) {
+void hb_array_append(hb_array_T* array, void* item) {
   if (array->size >= array->capacity) {
     size_t new_capacity;
 
@@ -45,7 +44,7 @@ void array_append(array_T* array, void* item) {
     }
 
     size_t new_size_bytes = new_capacity * sizeof(void*);
-    void* new_items = safe_realloc(array->items, new_size_bytes);
+    void* new_items = realloc(array->items, new_size_bytes);
 
     if (unlikely(new_items == NULL)) { return; }
 
@@ -57,29 +56,29 @@ void array_append(array_T* array, void* item) {
   array->size++;
 }
 
-void* array_get(const array_T* array, const size_t index) {
+void* hb_array_get(const hb_array_T* array, const size_t index) {
   if (index >= array->size) { return NULL; }
 
   return array->items[index];
 }
 
-void* array_first(array_T* array) {
+void* hb_array_first(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[0];
 }
 
-void* array_last(array_T* array) {
+void* hb_array_last(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
   return array->items[array->size - 1];
 }
 
-void array_set(const array_T* array, const size_t index, void* item) {
+void hb_array_set(const hb_array_T* array, const size_t index, void* item) {
   if (index >= array->size) { return; }
 
   array->items[index] = item;
 }
 
-void array_remove(array_T* array, const size_t index) {
+void hb_array_remove(hb_array_T* array, const size_t index) {
   if (index >= array->size) { return; }
 
   for (size_t i = index; i < array->size - 1; i++) {
@@ -89,7 +88,7 @@ void array_remove(array_T* array, const size_t index) {
   array->size--;
 }
 
-size_t array_index_of(array_T* array, void* item) {
+size_t hb_array_index_of(hb_array_T* array, void* item) {
   for (size_t i = 0; i < array->size; i++) {
     if (array->items[i] == item) { return i; }
   }
@@ -97,37 +96,37 @@ size_t array_index_of(array_T* array, void* item) {
   return SIZE_MAX;
 }
 
-void array_remove_item(array_T* array, void* item) {
-  size_t index = array_index_of(array, item);
+void hb_array_remove_item(hb_array_T* array, void* item) {
+  size_t index = hb_array_index_of(array, item);
 
-  if (index != SIZE_MAX) { array_remove(array, index); }
+  if (index != SIZE_MAX) { hb_array_remove(array, index); }
 }
 
-// Alias for array_append
-void array_push(array_T* array, void* item) {
-  array_append(array, item);
+// Alias for hb_array_append
+void hb_array_push(hb_array_T* array, void* item) {
+  hb_array_append(array, item);
 }
 
-void* array_pop(array_T* array) {
+void* hb_array_pop(hb_array_T* array) {
   if (!array || array->size == 0) { return NULL; }
 
-  void* last_item = array_last(array);
+  void* last_item = hb_array_last(array);
   array->size--;
 
   return last_item;
 }
 
-size_t array_size(const array_T* array) {
+size_t hb_array_size(const hb_array_T* array) {
   if (array == NULL) { return 0; }
 
   return array->size;
 }
 
-size_t array_capacity(const array_T* array) {
+size_t hb_array_capacity(const hb_array_T* array) {
   return array->capacity;
 }
 
-void array_free(array_T** array) {
+void hb_array_free(hb_array_T** array) {
   if (!array || !*array) { return; }
 
   free((*array)->items);

package/extension/libherb/util/hb_array.h

@@ -0,0 +1,33 @@
+#ifndef HERB_ARRAY_H
+#define HERB_ARRAY_H
+
+#include <stdlib.h>
+
+typedef struct HB_ARRAY_STRUCT {
+  void** items;
+  size_t size;
+  size_t capacity;
+} hb_array_T;
+
+hb_array_T* hb_array_init(size_t capacity);
+
+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);
+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);
+
+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);
+void* hb_array_pop(hb_array_T* array);
+
+size_t hb_array_capacity(const hb_array_T* array);
+size_t hb_array_size(const hb_array_T* array);
+size_t hb_array_sizeof(void);
+
+#endif

package/extension/libherb/util/hb_buffer.c

@@ -0,0 +1,203 @@
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../include/macros.h"
+#include "../include/util.h"
+#include "../include/util/hb_buffer.h"
+
+static bool hb_buffer_has_capacity(hb_buffer_T* buffer, const size_t required_length) {
+  return (buffer->length + required_length <= buffer->capacity);
+}
+
+/**
+ * Resizes the capacity of the buffer to the specified new capacity.
+ *
+ * @param buffer The buffer to resize
+ * @param new_capacity The new capacity to resize the buffer to
+ * @return true if capacity was resized, false if reallocation failed
+ */
+static bool hb_buffer_resize(hb_buffer_T* buffer, const size_t new_capacity) {
+  if (new_capacity + 1 >= SIZE_MAX) {
+    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
+    exit(1);
+  }
+
+  char* new_value = realloc(buffer->value, new_capacity + 1);
+
+  if (unlikely(new_value == NULL)) {
+    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
+    exit(1);
+  }
+
+  buffer->value = new_value;
+  buffer->capacity = new_capacity;
+
+  return true;
+}
+
+/**
+ * Expands the capacity of the buffer if needed to accommodate additional content.
+ * This function is a convenience function that calls hb_buffer_has_capacity and
+ * hb_buffer_expand_capacity.
+ *
+ * @param buffer The buffer to expand capacity for
+ * @param required_length The additional length needed beyond current buffer capacity
+ * @return true if capacity was increased, false if reallocation failed
+ */
+static bool hb_buffer_expand_if_needed(hb_buffer_T* buffer, const size_t required_length) {
+  if (hb_buffer_has_capacity(buffer, required_length)) { return true; }
+
+  bool should_double_capacity = required_length < buffer->capacity;
+  size_t new_capacity = 0;
+
+  if (should_double_capacity) {
+    new_capacity = buffer->capacity * 2;
+  } else {
+    new_capacity = buffer->capacity + (required_length * 2);
+  }
+
+  return hb_buffer_resize(buffer, new_capacity);
+}
+
+bool hb_buffer_init(hb_buffer_T* buffer, const size_t capacity) {
+  buffer->capacity = capacity;
+  buffer->length = 0;
+  buffer->value = malloc(sizeof(char) * (buffer->capacity + 1));
+
+  if (!buffer->value) {
+    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
+
+    return false;
+  }
+
+  buffer->value[0] = '\0';
+
+  return true;
+}
+
+char* hb_buffer_value(const hb_buffer_T* buffer) {
+  return buffer->value;
+}
+
+size_t hb_buffer_length(const hb_buffer_T* buffer) {
+  return buffer->length;
+}
+
+size_t hb_buffer_capacity(const hb_buffer_T* buffer) {
+  return buffer->capacity;
+}
+
+size_t hb_buffer_sizeof(void) {
+  return sizeof(hb_buffer_T);
+}
+
+/**
+ * Appends a null-terminated string to the buffer.
+ * @note This function requires that 'text' is a properly null-terminated string.
+ * When reading data from files or other non-string sources, ensure the data is
+ * null-terminated before calling this function, or use hb_buffer_append_with_length instead.
+ *
+ * @param buffer The buffer to append to
+ * @param text A null-terminated string to append
+ * @return void
+ */
+void hb_buffer_append(hb_buffer_T* buffer, const char* text) {
+  if (!buffer || !text) { return; }
+  if (text[0] == '\0') { return; }
+
+  size_t text_length = strlen(text);
+
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
+
+  memcpy(buffer->value + buffer->length, text, text_length);
+  buffer->length += text_length;
+  buffer->value[buffer->length] = '\0';
+}
+
+/**
+ * Appends a string of specified length to the buffer.
+ * Unlike hb_buffer_append(), this function does not require the text to be
+ * null-terminated as it uses the provided length instead of strlen().
+ * This is particularly useful when working with data from files, network
+ * buffers, or other non-null-terminated sources.
+ *
+ * @param buffer The buffer to append to
+ * @param text The text to append (doesn't need to be null-terminated)
+ * @param length The number of bytes to append from text
+ * @return void
+ */
+void hb_buffer_append_with_length(hb_buffer_T* buffer, const char* text, const size_t length) {
+  if (!buffer || !text || length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
+
+  memcpy(buffer->value + buffer->length, text, length);
+
+  buffer->length += length;
+  buffer->value[buffer->length] = '\0';
+}
+
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string) {
+  if (!hb_string_is_empty(string)) { hb_buffer_append_with_length(buffer, string.data, string.length); }
+}
+
+void hb_buffer_append_char(hb_buffer_T* buffer, const char character) {
+  char string[2];
+
+  string[0] = character;
+  string[1] = '\0';
+
+  hb_buffer_append(buffer, string);
+}
+
+static void hb_buffer_append_repeated(hb_buffer_T* buffer, const char character, size_t length) {
+  if (!buffer || length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(buffer, length)) { return; }
+
+  memset(buffer->value + buffer->length, character, length);
+
+  buffer->length += length;
+  buffer->value[buffer->length] = '\0';
+}
+
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, const size_t length) {
+  hb_buffer_append_repeated(buffer, ' ', length);
+}
+
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text) {
+  if (!buffer || !text) { return; }
+  if (text[0] == '\0') { return; }
+
+  size_t text_length = strlen(text);
+
+  if (!hb_buffer_expand_if_needed(buffer, text_length)) { return; }
+
+  memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
+  memcpy(buffer->value, text, text_length);
+
+  buffer->length += text_length;
+}
+
+void hb_buffer_concat(hb_buffer_T* destination, hb_buffer_T* source) {
+  if (source->length == 0) { return; }
+  if (!hb_buffer_expand_if_needed(destination, source->length)) { return; }
+
+  memcpy(destination->value + destination->length, source->value, source->length);
+
+  destination->length += source->length;
+  destination->value[destination->length] = '\0';
+}
+
+void hb_buffer_clear(hb_buffer_T* buffer) {
+  buffer->length = 0;
+  buffer->value[0] = '\0';
+}
+
+void hb_buffer_free(hb_buffer_T** buffer) {
+  if (!buffer || !*buffer) { return; }
+
+  if ((*buffer)->value != NULL) { free((*buffer)->value); }
+
+  free(*buffer);
+  *buffer = NULL;
+}

package/extension/libherb/util/hb_buffer.h

@@ -0,0 +1,34 @@
+#ifndef HERB_BUFFER_H
+#define HERB_BUFFER_H
+
+#include "hb_string.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+
+typedef struct HB_BUFFER_STRUCT {
+  char* value;
+  size_t length;
+  size_t capacity;
+} hb_buffer_T;
+
+bool hb_buffer_init(hb_buffer_T* buffer, size_t capacity);
+
+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);
+void hb_buffer_append_string(hb_buffer_T* buffer, hb_string_T string);
+void hb_buffer_append_char(hb_buffer_T* buffer, char character);
+void hb_buffer_append_whitespace(hb_buffer_T* buffer, size_t length);
+void hb_buffer_prepend(hb_buffer_T* buffer, const char* text);
+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);
+size_t hb_buffer_capacity(const hb_buffer_T* buffer);
+size_t hb_buffer_sizeof(void);
+
+void hb_buffer_clear(hb_buffer_T* buffer);
+void hb_buffer_free(hb_buffer_T** buffer);
+
+#endif