herb 0.7.5 → 0.8.0

data/src/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;
+}

data/src/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;
+}

data/src/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
+}

data/src/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;
-}