herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/src/buffer.c

@@ -1,232 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "include/buffer.h"
-#include "include/macros.h"
-#include "include/memory.h"
-#include "include/util.h"
-
-bool buffer_init(buffer_T* buffer) {
-  buffer->capacity = 1024;
-  buffer->length = 0;
-  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
-
-  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;
-}
-
-buffer_T buffer_new(void) {
-  buffer_T buffer;
-  buffer_init(&buffer);
-  return buffer;
-}
-
-char* buffer_value(const buffer_T* buffer) {
-  return buffer->value;
-}
-
-size_t buffer_length(const buffer_T* buffer) {
-  return buffer->length;
-}
-
-size_t buffer_capacity(const buffer_T* buffer) {
-  return buffer->capacity;
-}
-
-size_t buffer_sizeof(void) {
-  return sizeof(buffer_T);
-}
-
-/**
- * Increases the capacity of the buffer if needed to accommodate additional content.
- * This function only handles memory allocation and does not modify the buffer content
- * or null termination.
- *
- * @param buffer The buffer to increase capacity for
- * @param additional_capacity The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
-  if (additional_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  const size_t new_capacity = buffer->capacity + additional_capacity;
-
-  return buffer_resize(buffer, new_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
- */
-bool buffer_resize(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 = nullable_safe_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 by doubling its current capacity.
- * This function is a convenience function that calls buffer_increase_capacity
- * with a factor of 2.
- *
- * @param buffer The buffer to expand capacity for
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_expand_capacity(buffer_T* buffer) {
-  return buffer_resize(buffer, buffer->capacity * 2);
-}
-
-/**
- * Expands the capacity of the buffer if needed to accommodate additional content.
- * This function is a convenience function that calls buffer_has_capacity and
- * 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
- */
-bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
-  if (buffer_has_capacity(buffer, required_length)) { return true; }
-
-  return buffer_resize(buffer, buffer->capacity + (required_length * 2));
-}
-
-/**
- * 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 buffer_append_with_length instead.
- *
- * @param buffer The buffer to append to
- * @param text A null-terminated string to append
- * @return void
- */
-void buffer_append(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!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 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 buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
-  if (!buffer || !text || length == 0) { return; }
-  if (!buffer_expand_if_needed(buffer, length)) { return; }
-
-  memcpy(buffer->value + buffer->length, text, length);
-
-  buffer->length += length;
-  buffer->value[buffer->length] = '\0';
-}
-
-void buffer_append_char(buffer_T* buffer, const char character) {
-  static char string[2];
-
-  string[0] = character;
-  string[1] = '\0';
-
-  buffer_append(buffer, string);
-}
-
-void buffer_append_repeated(buffer_T* buffer, const char character, size_t length) {
-  if (length == 0) { return; }
-
-  char* spaces = malloc(length + 1);
-  if (!spaces) { return; }
-
-  memset(spaces, character, length);
-  spaces[length] = '\0';
-
-  buffer_append(buffer, spaces);
-
-  free(spaces);
-}
-
-void buffer_append_whitespace(buffer_T* buffer, const size_t length) {
-  buffer_append_repeated(buffer, ' ', length);
-}
-
-void buffer_prepend(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!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 buffer_concat(buffer_T* destination, buffer_T* source) {
-  if (source->length == 0) { return; }
-  if (!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';
-}
-
-bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
-  return (buffer->length + required_length <= buffer->capacity);
-}
-
-void buffer_clear(buffer_T* buffer) {
-  buffer->length = 0;
-  buffer->value[0] = '\0';
-}
-
-void buffer_free(buffer_T* buffer) {
-  if (!buffer) { return; }
-
-  if (buffer->value != NULL) { free(buffer->value); }
-
-  buffer->value = NULL;
-  buffer->length = buffer->capacity = 0;
-}

data/src/include/array.h

@@ -1,33 +0,0 @@
-#ifndef HERB_ARRAY_H
-#define HERB_ARRAY_H
-
-#include <stdlib.h>
-
-typedef struct ARRAY_STRUCT {
-  void** items;
-  size_t size;
-  size_t capacity;
-} array_T;
-
-array_T* array_init(size_t capacity);
-
-void* array_get(const array_T* array, size_t index);
-void* array_first(array_T* array);
-void* array_last(array_T* array);
-
-void array_append(array_T* array, void* item);
-void array_set(const array_T* array, size_t index, void* item);
-void array_free(array_T** array);
-void array_remove(array_T* array, size_t index);
-
-size_t array_index_of(array_T* array, void* item);
-void array_remove_item(array_T* array, void* item);
-
-void array_push(array_T* array, void* item);
-void* array_pop(array_T* array);
-
-size_t array_capacity(const array_T* array);
-size_t array_size(const array_T* array);
-size_t array_sizeof(void);
-
-#endif

data/src/include/buffer.h

@@ -1,39 +0,0 @@
-#ifndef HERB_BUFFER_H
-#define HERB_BUFFER_H
-
-#include <stdbool.h>
-#include <stdlib.h>
-
-typedef struct BUFFER_STRUCT {
-  char* value;
-  size_t length;
-  size_t capacity;
-} buffer_T;
-
-bool buffer_init(buffer_T* buffer);
-buffer_T buffer_new(void);
-
-bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
-bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_expand_capacity(buffer_T* buffer);
-bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
-bool buffer_resize(buffer_T* buffer, size_t new_capacity);
-
-void buffer_append(buffer_T* buffer, const char* text);
-void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);
-void buffer_append_char(buffer_T* buffer, char character);
-void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
-void buffer_append_whitespace(buffer_T* buffer, size_t length);
-void buffer_prepend(buffer_T* buffer, const char* text);
-void buffer_concat(buffer_T* destination, buffer_T* source);
-
-char* buffer_value(const buffer_T* buffer);
-
-size_t buffer_length(const buffer_T* buffer);
-size_t buffer_capacity(const buffer_T* buffer);
-size_t buffer_sizeof(void);
-
-void buffer_clear(buffer_T* buffer);
-void buffer_free(buffer_T* buffer);
-
-#endif

data/src/include/json.h

@@ -1,28 +0,0 @@
-#ifndef HERB_JSON_H
-#define HERB_JSON_H
-
-#include "buffer.h"
-
-void json_start_root_object(buffer_T* json);
-void json_start_root_array(buffer_T* json);
-
-void json_escape_string(buffer_T* json, const char* string);
-
-void json_add_string(buffer_T* json, const char* key, const char* value);
-void json_add_int(buffer_T* json, const char* key, int value);
-void json_add_size_t(buffer_T* json, const char* key, size_t value);
-void json_add_double(buffer_T* json, const char* key, double value);
-void json_add_bool(buffer_T* json, const char* key, int value);
-
-void json_add_raw_string(buffer_T* json, const char* string);
-
-void json_start_object(buffer_T* json, const char* key);
-void json_end_object(buffer_T* json);
-
-void json_start_array(buffer_T* json, const char* key);
-void json_end_array(buffer_T* json);
-
-void json_double_to_string(double value, char* buffer);
-void json_int_to_string(int value, char* buffer);
-
-#endif

data/src/include/memory.h

@@ -1,12 +0,0 @@
-#ifndef HERB_MEMORY_H
-#define HERB_MEMORY_H
-
-#include <stddef.h>
-
-void* safe_malloc(size_t size);
-void* safe_realloc(void* pointer, size_t new_size);
-
-void* nullable_safe_malloc(size_t size);
-void* nullable_safe_realloc(void* pointer, size_t new_size);
-
-#endif

data/src/json.c

@@ -1,205 +0,0 @@
-#include "include/json.h"
-#include "include/buffer.h"
-
-void json_escape_string(buffer_T* json, const char* string) {
-  if (!string) {
-    buffer_append(json, "null");
-    return;
-  }
-
-  buffer_append(json, "\"");
-
-  while (*string) {
-    switch (*string) {
-      case '\"': buffer_append(json, "\\\""); break;
-      case '\\': buffer_append(json, "\\\\"); break;
-      case '\n': buffer_append(json, "\\n"); break;
-      case '\t': buffer_append(json, "\\t"); break;
-      default: buffer_append_char(json, *string); break;
-    }
-    string++;
-  }
-
-  buffer_append(json, "\"");
-}
-
-void json_int_to_string(const int value, char* buffer) {
-  char string[20]; // Enough to hold all possible int values
-  int i = 0;
-
-  // Handle negative numbers
-  unsigned int abs_value = (unsigned int) abs(value);
-
-  do {
-    string[i++] = (char) ((abs_value % 10) + '0');
-    abs_value /= 10;
-  } while (abs_value > 0);
-
-  if (value < 0) { string[i++] = '-'; }
-
-  int j = 0;
-
-  while (i > 0) {
-    buffer[j++] = string[--i];
-  }
-
-  buffer[j] = '\0';
-}
-
-void json_double_to_string(const double value, char* buffer) {
-  const int int_part = (int) value;
-  const double frac_part = value - (double) int_part;
-  const int frac_as_int = (int) (frac_part * 100); // Keep 2 decimal places
-
-  char int_buffer[20];
-  char frac_buffer[5];
-
-  json_int_to_string(int_part, int_buffer);
-  json_int_to_string(frac_as_int < 0 ? -frac_as_int : frac_as_int, frac_buffer);
-
-  char* pointer = buffer;
-  for (const char* source = int_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer++ = '.';
-
-  for (const char* source = frac_buffer; *source != '\0'; ++source) {
-    *pointer++ = *source;
-  }
-
-  *pointer = '\0';
-}
-
-void json_add_string(buffer_T* json, const char* key, const char* value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  json_escape_string(json, value);
-}
-
-void json_add_double(buffer_T* json, const char* key, const double value) {
-  if (!json) { return; }
-
-  char number[32];
-  json_double_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-}
-
-void json_add_int(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  char number[20];
-  json_int_to_string(value, number);
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_size_t(buffer_T* json, const char* key, size_t value) {
-  if (!json) { return; }
-
-  char number[32];
-  char temp[32];
-  int i = 0;
-
-  do {
-    temp[i++] = (char) ((value % 10) + '0');
-    value /= 10;
-  } while (value > 0);
-
-  int j = 0;
-  while (i > 0) {
-    number[j++] = temp[--i];
-  }
-  number[j] = '\0';
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, number);
-  if (json->length == 1) { buffer_append(json, " "); }
-}
-
-void json_add_bool(buffer_T* json, const char* key, const int value) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, value ? "true" : "false");
-}
-
-void json_add_raw_string(buffer_T* json, const char* string) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  buffer_append(json, string);
-}
-
-void json_start_root_object(buffer_T* json) {
-  if (json) { buffer_append(json, "{"); }
-}
-
-void json_start_object(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-
-  if (key) {
-    json_escape_string(json, key);
-    buffer_append(json, ": ");
-  }
-
-  buffer_append(json, "{");
-}
-
-void json_end_object(buffer_T* json) {
-  if (json) { buffer_append(json, "}"); }
-}
-
-void json_start_root_array(buffer_T* json) {
-  if (json) { buffer_append(json, "["); }
-}
-
-void json_start_array(buffer_T* json, const char* key) {
-  if (!json) { return; }
-
-  if (json->length > 1) { buffer_append(json, ", "); }
-  json_escape_string(json, key);
-  buffer_append(json, ": [");
-}
-
-void json_end_array(buffer_T* json) {
-  if (json) { buffer_append(json, "]"); }
-}

data/src/memory.c

@@ -1,53 +0,0 @@
-#include "memory.h"
-
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-static void* safe_malloc_internal(const size_t size, const bool fail_fast) {
-  if (size == 0) { return NULL; }
-
-  void* pointer = malloc(size);
-
-  if (!pointer) {
-    fprintf(stderr, "Error: Failed to allocate %zu bytes.\n", size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return pointer;
-}
-
-static void* safe_realloc_internal(void* pointer, const size_t new_size, const bool fail_fast) {
-  if (new_size == 0) { return NULL; }
-
-  if (!pointer) { return safe_malloc_internal(new_size, fail_fast); }
-
-  void* new_pointer = realloc(pointer, new_size);
-
-  if (!new_pointer) {
-    fprintf(stderr, "Error: Memory reallocation failed (size: %zu bytes).\n", new_size);
-    fflush(stderr);
-    if (fail_fast) { exit(1); }
-    return NULL;
-  }
-
-  return new_pointer;
-}
-
-void* safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, true);
-}
-
-void* nullable_safe_malloc(const size_t size) {
-  return safe_malloc_internal(size, false);
-}
-
-void* safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, true);
-}
-
-void* nullable_safe_realloc(void* pointer, const size_t new_size) {
-  return safe_realloc_internal(pointer, new_size, false);
-}

data/src/position.c

@@ -1,33 +0,0 @@
-#include "include/position.h"
-#include "include/memory.h"
-
-size_t position_sizeof(void) {
-  return sizeof(position_T);
-}
-
-position_T* position_init(const size_t line, const size_t column) {
-  position_T* position = safe_malloc(position_sizeof());
-
-  position->line = line;
-  position->column = column;
-
-  return position;
-}
-
-size_t position_line(const position_T* position) {
-  return position->line;
-}
-
-size_t position_column(const position_T* position) {
-  return position->column;
-}
-
-position_T* position_copy(position_T* position) {
-  if (position == NULL) { return NULL; }
-
-  return position_init(position_line(position), position_column(position));
-}
-
-void position_free(position_T* position) {
-  free(position);
-}