rbs 3.9.4 → 4.1.1

data/src/string.c

@@ -0,0 +1,41 @@
+#include "rbs/string.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+rbs_string_t rbs_string_new(const char *start, const char *end) {
+    return (rbs_string_t) {
+        .start = start,
+        .end = end,
+    };
+}
+
+rbs_string_t rbs_string_strip_whitespace(rbs_string_t *self) {
+    const char *new_start = self->start;
+    while (isspace(*new_start) && new_start < self->end) {
+        new_start++;
+    }
+
+    if (new_start == self->end) { // Handle empty string case
+        return rbs_string_new(new_start, new_start);
+    }
+
+    const char *new_end = self->end - 1;
+    while (isspace(*new_end) && new_start < new_end) {
+        new_end--;
+    }
+
+    return rbs_string_new(new_start, new_end + 1);
+}
+
+size_t rbs_string_len(const rbs_string_t self) {
+    return self.end - self.start;
+}
+
+bool rbs_string_equal(const rbs_string_t lhs, const rbs_string_t rhs) {
+    if (lhs.start == rhs.start && lhs.end == rhs.end) return true;
+    if (rbs_string_len(lhs) != rbs_string_len(rhs)) return false;
+    return strncmp(lhs.start, rhs.start, rbs_string_len(lhs)) == 0;
+}

data/src/util/rbs_allocator.c

@@ -0,0 +1,171 @@
+/**
+ *  @file rbs_allocator.c
+ *
+ *  A simple arena allocator that can be freed all at once.
+ *
+*  This allocator maintains a linked list of pages, which come in two flavours:
+ *      1. Small allocation pages, which are the same size as the system page size.
+ *      2. Large allocation pages, which are the exact size requested, for sizes greater than the small page size.
+ *
+ *  Small allocations always fit into the unused space at the end of the "head" page. If there isn't enough room, a new
+ *  page is allocated, and the small allocation is placed at its start. This approach wastes that unused slack at the
+ *  end of the previous page, but it means that allocations are instant and never scan the linked list to find a gap.
+ *
+ *  This allocator doesn't support freeing individual allocations. Only the whole arena can be freed at once at the end.
+ */
+
+#include "rbs/util/rbs_allocator.h"
+#include "rbs/util/rbs_assert.h"
+
+#include <stdlib.h>
+#include <string.h> // for memset()
+#include <stdint.h>
+#include <inttypes.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h> // for sysconf()
+#endif
+
+typedef struct rbs_allocator_page {
+    // The previously allocated page, or NULL if this is the first page.
+    struct rbs_allocator_page *next;
+
+    // The size of the payload in bytes.
+    size_t size;
+
+    // The offset of the next available byte.
+    size_t used;
+} rbs_allocator_page_t;
+
+// Normalize a raw page size to a safe value for payload_size subtraction.
+// Falls back to 4096 when the raw value is <= 0 or smaller than the page
+// header struct, preventing underflow in rbs_allocator_init.
+// Internal API, intentionally omitted from the public header.
+size_t rbs_allocator_normalize_page_size(long raw) {
+    if (raw <= 0) return 4096;
+    size_t page_size = (size_t) raw;
+    if (page_size <= sizeof(rbs_allocator_page_t)) return 4096;
+    return page_size;
+}
+
+static size_t get_system_page_size(void) {
+#ifdef _WIN32
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return rbs_allocator_normalize_page_size((long) si.dwPageSize);
+#else
+    return rbs_allocator_normalize_page_size(sysconf(_SC_PAGESIZE));
+#endif
+}
+
+static inline uintptr_t rbs_align_up_uintptr(uintptr_t value, size_t alignment) {
+    // alignment must be a non-zero power of two
+    RBS_ASSERT(alignment != 0 && (alignment & (alignment - 1)) == 0, "alignment must be a non-zero power of two. alignment: %zu", alignment);
+    return (value + (alignment - 1)) & ~(uintptr_t) (alignment - 1);
+}
+
+static rbs_allocator_page_t *rbs_allocator_page_new(size_t payload_size) {
+    const size_t page_header_size = sizeof(rbs_allocator_page_t);
+
+    rbs_allocator_page_t *page = (rbs_allocator_page_t *) malloc(page_header_size + payload_size);
+    page->size = payload_size;
+    page->used = 0;
+
+    return page;
+}
+
+rbs_allocator_t *rbs_allocator_init(void) {
+    rbs_allocator_t *allocator = (rbs_allocator_t *) malloc(sizeof(rbs_allocator_t));
+
+    const size_t system_page_size = get_system_page_size();
+
+    allocator->default_page_payload_size = system_page_size - sizeof(rbs_allocator_page_t);
+
+    allocator->page = rbs_allocator_page_new(allocator->default_page_payload_size);
+    allocator->page->next = NULL;
+
+    return allocator;
+}
+
+void rbs_allocator_free(rbs_allocator_t *allocator) {
+    rbs_allocator_page_t *page = allocator->page;
+    while (page) {
+        rbs_allocator_page_t *next = page->next;
+        free(page);
+        page = next;
+    }
+    free(allocator);
+}
+
+// Allocates `new_size` bytes from `allocator`, aligned to an `alignment`-byte boundary.
+// Copies `old_size` bytes from `ptr` to the new allocation.
+// It always reallocates the memory in new space and thus wastes the old space.
+void *rbs_allocator_realloc_impl(rbs_allocator_t *allocator, void *ptr, size_t old_size, size_t new_size, size_t alignment) {
+    void *p = rbs_allocator_malloc_impl(allocator, new_size, alignment);
+    memcpy(p, ptr, old_size);
+    return p;
+}
+
+// Allocates `size` bytes from `allocator`, aligned to an `alignment`-byte boundary.
+void *rbs_allocator_malloc_impl(rbs_allocator_t *allocator, size_t size, size_t alignment) {
+    if (allocator->default_page_payload_size < size) { // Big allocation, give it its own page.
+        // Add padding to ensure we can align the start pointer within this page
+        rbs_allocator_page_t *new_page = rbs_allocator_page_new(size + (alignment - 1));
+
+        // This simple allocator can only put small allocations into the head page.
+        // Naively prepending this large allocation page to the head of the allocator before the previous head page
+        // would waste the remaining space in the head page.
+        // So instead, we'll splice in the large page *after* the head page.
+        //
+        // +-------+    +-----------+        +-----------+
+        // | arena |    | head page |        | new_page  |
+        // |-------|    |-----------+        |-----------+
+        // | *page |--->|  size     |   +--->|  size     |   +---> ... previous tail
+        // +-------+    |  offset   |   |    |  offset   |   |
+        //              | *next ----+---+    | *next ----+---+
+        //              |    ...    |        |    ...    |
+        //              +-----------+        +-----------+
+        //
+        new_page->next = allocator->page->next;
+        allocator->page->next = new_page;
+
+        uintptr_t base = (uintptr_t) new_page + sizeof(rbs_allocator_page_t);
+        uintptr_t aligned_ptr = rbs_align_up_uintptr(base, alignment);
+        return (void *) aligned_ptr;
+    }
+
+    rbs_allocator_page_t *page = allocator->page;
+    uintptr_t base = (uintptr_t) page + sizeof(rbs_allocator_page_t);
+
+    // Compute aligned offset within the payload
+    size_t used_aligned = (size_t) (rbs_align_up_uintptr(base + page->used, alignment) - base);
+
+    if (used_aligned + size > page->size) {
+        // Not enough space. Allocate a new small page and prepend it to the allocator's linked list.
+        rbs_allocator_page_t *new_page = rbs_allocator_page_new(allocator->default_page_payload_size);
+        new_page->next = allocator->page;
+        allocator->page = new_page;
+        page = new_page;
+        base = (uintptr_t) page + sizeof(rbs_allocator_page_t);
+        used_aligned = (size_t) (rbs_align_up_uintptr(base, alignment) - base); // start of fresh page (usually 0 if header is aligned)
+    }
+
+    uintptr_t pointer = base + used_aligned;
+    page->used = used_aligned + size;
+    return (void *) pointer;
+}
+
+// Note: This will eagerly fill with zeroes, unlike `calloc()` which can map a page in a page to be zeroed lazily.
+//       It's assumed that callers to this function will immediately write to the allocated memory, anyway.
+void *rbs_allocator_calloc_impl(rbs_allocator_t *allocator, size_t count, size_t size, size_t alignment) {
+    void *p = rbs_allocator_malloc_many_impl(allocator, count, size, alignment);
+    memset(p, 0, count * size);
+    return p;
+}
+
+// Similar to `rbs_allocator_malloc_impl()`, but allocates `count` instances of `size` bytes, aligned to an `alignment`-byte boundary.
+void *rbs_allocator_malloc_many_impl(rbs_allocator_t *allocator, size_t count, size_t size, size_t alignment) {
+    return rbs_allocator_malloc_impl(allocator, count * size, alignment);
+}

data/src/util/rbs_assert.c

@@ -0,0 +1,19 @@
+#include "rbs/util/rbs_assert.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+void rbs_assert_impl(bool condition, const char *fmt, ...) {
+    if (condition) {
+        return;
+    }
+
+    va_list args;
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+    fprintf(stderr, "\n");
+    exit(EXIT_FAILURE);
+}

data/src/util/rbs_buffer.c

@@ -0,0 +1,54 @@
+#include "rbs/util/rbs_buffer.h"
+#include "rbs/util/rbs_assert.h"
+
+bool rbs_buffer_init(rbs_allocator_t *allocator, rbs_buffer_t *buffer) {
+    size_t capacity = RBS_BUFFER_DEFAULT_CAPACITY;
+
+    buffer->length = 0;
+    buffer->capacity = capacity;
+
+    buffer->value = rbs_allocator_calloc(allocator, capacity, char);
+    return buffer->value != NULL;
+}
+
+char *rbs_buffer_value(const rbs_buffer_t *buffer) {
+    return buffer->value;
+}
+
+size_t rbs_buffer_length(const rbs_buffer_t *buffer) {
+    return buffer->length;
+}
+
+void rbs_buffer_append_string(rbs_allocator_t *allocator, rbs_buffer_t *buffer, const char *source, size_t length) {
+    size_t next_length = buffer->length + length;
+
+    if (next_length > buffer->capacity) {
+        size_t old_capacity = buffer->capacity;
+
+        RBS_ASSERT(old_capacity != 0, "Precondition: capacity must be at least 1. Got %zu", old_capacity);
+
+        size_t new_capacity = buffer->capacity * 2;
+
+        while (next_length > new_capacity) {
+            new_capacity *= 2;
+        }
+
+        char *new_value = rbs_allocator_realloc(allocator, buffer->value, old_capacity, new_capacity, char);
+        RBS_ASSERT(new_value != NULL, "Failed to append to buffer. Old capacity: %zu, new capacity: %zu", old_capacity, new_capacity);
+
+        buffer->value = new_value;
+        buffer->capacity = new_capacity;
+    }
+
+    size_t cursor = buffer->length;
+    buffer->length = next_length;
+    memcpy(buffer->value + cursor, source, length);
+}
+
+void rbs_buffer_append_cstr(rbs_allocator_t *allocator, rbs_buffer_t *buffer, const char *value) {
+    rbs_buffer_append_string(allocator, buffer, value, strlen(value));
+}
+
+rbs_string_t rbs_buffer_to_string(rbs_buffer_t *buffer) {
+    return rbs_string_new(buffer->value, buffer->value + buffer->length);
+}

data/src/util/rbs_constant_pool.c

@@ -1,75 +1,5 @@
 #include "rbs/util/rbs_constant_pool.h"
-
-/**
- * Initialize a list of constant ids.
- */
-void
-rbs_constant_id_list_init(rbs_constant_id_list_t *list) {
-    list->ids = NULL;
-    list->size = 0;
-    list->capacity = 0;
-}
-
-/**
- * Initialize a list of constant ids with a given capacity.
- */
-void
-rbs_constant_id_list_init_capacity(rbs_constant_id_list_t *list, size_t capacity) {
-    list->ids = calloc(capacity, sizeof(rbs_constant_id_t));
-    if (list->ids == NULL) abort();
-
-    list->size = 0;
-    list->capacity = capacity;
-}
-
-/**
- * Append a constant id to a list of constant ids. Returns false if any
- * potential reallocations fail.
- */
-bool
-rbs_constant_id_list_append(rbs_constant_id_list_t *list, rbs_constant_id_t id) {
-    if (list->size >= list->capacity) {
-        list->capacity = list->capacity == 0 ? 8 : list->capacity * 2;
-        list->ids = (rbs_constant_id_t *) realloc(list->ids, sizeof(rbs_constant_id_t) * list->capacity);
-        if (list->ids == NULL) return false;
-    }
-
-    list->ids[list->size++] = id;
-    return true;
-}
-
-/**
- * Insert a constant id into a list of constant ids at the specified index.
- */
-void
-rbs_constant_id_list_insert(rbs_constant_id_list_t *list, size_t index, rbs_constant_id_t id) {
-    assert(index < list->capacity);
-    assert(list->ids[index] == RBS_CONSTANT_ID_UNSET);
-
-    list->ids[index] = id;
-    list->size++;
-}
-
-/**
- * Checks if the current constant id list includes the given constant id.
- */
-bool
-rbs_constant_id_list_includes(rbs_constant_id_list_t *list, rbs_constant_id_t id) {
-    for (size_t index = 0; index < list->size; index++) {
-        if (list->ids[index] == id) return true;
-    }
-    return false;
-}
-
-/**
- * Free the memory associated with a list of constant ids.
- */
-void
-rbs_constant_id_list_free(rbs_constant_id_list_t *list) {
-    if (list->ids != NULL) {
-        free(list->ids);
-    }
-}
+#include "rbs/util/rbs_assert.h"
 
 /**
  * A relatively simple hash function (djb2) that is used to hash strings. We are
@@ -107,19 +37,16 @@ next_power_of_two(uint32_t v) {
     return v;
 }
 
-#ifndef NDEBUG
-static bool
-is_power_of_two(uint32_t size) {
+RBS_ATTRIBUTE_UNUSED static bool is_power_of_two(uint32_t size) {
     return (size & (size - 1)) == 0;
 }
-#endif
 
 /**
  * Resize a constant pool to a given capacity.
  */
 static inline bool
 rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
-    assert(is_power_of_two(pool->capacity));
+    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
 
     uint32_t next_capacity = pool->capacity * 2;
     if (next_capacity < pool->capacity) return false;
@@ -130,8 +57,8 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
     void *next = calloc(next_capacity, element_size);
     if (next == NULL) return false;
 
-    rbs_constant_pool_bucket_t *next_buckets = next;
-    rbs_constant_t *next_constants = (void *)(((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
+    rbs_constant_pool_bucket_t *next_buckets = (rbs_constant_pool_bucket_t *) next;
+    rbs_constant_t *next_constants = (rbs_constant_t *) (((char *) next) + next_capacity * sizeof(rbs_constant_pool_bucket_t));
 
     // For each bucket in the current constant pool, find the index in the
     // next constant pool, and insert it.
@@ -168,15 +95,10 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
     return true;
 }
 
-// This storage is initialized by `Init_rbs_extension()` in `main.c`.
-static rbs_constant_pool_t RBS_GLOBAL_CONSTANT_POOL_STORAGE = { 0 };
-rbs_constant_pool_t *RBS_GLOBAL_CONSTANT_POOL = &RBS_GLOBAL_CONSTANT_POOL_STORAGE;
-
 /**
  * Initialize a new constant pool with a given capacity.
  */
-bool
-rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
+bool rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
     const uint32_t maximum = (~((uint32_t) 0));
     if (capacity >= ((maximum / 2) + 1)) return false;
 
@@ -185,8 +107,8 @@ rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
     void *memory = calloc(capacity, element_size);
     if (memory == NULL) return false;
 
-    pool->buckets = memory;
-    pool->constants = (void *)(((char *)memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
+    pool->buckets = (rbs_constant_pool_bucket_t *) memory;
+    pool->constants = (rbs_constant_t *) (((char *) memory) + capacity * sizeof(rbs_constant_pool_bucket_t));
     pool->size = 0;
     pool->capacity = capacity;
     return true;
@@ -197,7 +119,7 @@ rbs_constant_pool_init(rbs_constant_pool_t *pool, uint32_t capacity) {
  */
 rbs_constant_t *
 rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id) {
-    assert(constant_id != RBS_CONSTANT_ID_UNSET && constant_id <= pool->size);
+    RBS_ASSERT(constant_id != RBS_CONSTANT_ID_UNSET && constant_id <= pool->size, "constant_id is not valid. Got %i, pool->size: %i", constant_id, pool->size);
     return &pool->constants[constant_id - 1];
 }
 
@@ -207,7 +129,7 @@ rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_i
  */
 rbs_constant_id_t
 rbs_constant_pool_find(const rbs_constant_pool_t *pool, const uint8_t *start, size_t length) {
-    assert(is_power_of_two(pool->capacity));
+    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
     const uint32_t mask = pool->capacity - 1;
 
     uint32_t hash = rbs_constant_pool_hash(start, length);
@@ -235,7 +157,7 @@ rbs_constant_pool_insert(rbs_constant_pool_t *pool, const uint8_t *start, size_t
         if (!rbs_constant_pool_resize(pool)) return RBS_CONSTANT_ID_UNSET;
     }
 
-    assert(is_power_of_two(pool->capacity));
+    RBS_ASSERT(is_power_of_two(pool->capacity), "pool->capacity is not a power of two. Got %i", pool->capacity);
     const uint32_t mask = pool->capacity - 1;
 
     uint32_t hash = rbs_constant_pool_hash(start, length);
@@ -276,7 +198,7 @@ rbs_constant_pool_insert(rbs_constant_pool_t *pool, const uint8_t *start, size_t
     // IDs are allocated starting at 1, since the value 0 denotes a non-existent
     // constant.
     uint32_t id = ++pool->size;
-    assert(pool->size < ((uint32_t) (1 << 30)));
+    RBS_ASSERT(pool->size < ((uint32_t) (1 << 30)), "pool->size is too large. Got %i", pool->size);
 
     *bucket = (rbs_constant_pool_bucket_t) {
         .id = (unsigned int) (id & 0x3fffffff),
@@ -301,6 +223,11 @@ rbs_constant_pool_insert_shared(rbs_constant_pool_t *pool, const uint8_t *start,
     return rbs_constant_pool_insert(pool, start, length, RBS_CONSTANT_POOL_BUCKET_DEFAULT);
 }
 
+rbs_constant_id_t
+rbs_constant_pool_insert_shared_with_encoding(rbs_constant_pool_t *pool, const uint8_t *start, size_t length, const rbs_encoding_t *encoding) {
+    return rbs_constant_pool_insert_shared(pool, start, length);
+}
+
 /**
  * Insert a constant into a constant pool from memory that is now owned by the
  * constant pool. Returns the id of the constant, or RBS_CONSTANT_ID_UNSET if any
@@ -324,8 +251,7 @@ rbs_constant_pool_insert_constant(rbs_constant_pool_t *pool, const uint8_t *star
 /**
  * Free the memory associated with a constant pool.
  */
-void
-rbs_constant_pool_free(rbs_constant_pool_t *pool) {
+void rbs_constant_pool_free(rbs_constant_pool_t *pool) {
     // For each constant in the current constant pool, free the contents if the
     // contents are owned.
     for (uint32_t index = 0; index < pool->capacity; index++) {