rbs 3.9.2 → 4.0.0.dev.1

data/src/string.c

@@ -0,0 +1,89 @@
+#include "rbs/string.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+
+unsigned int rbs_utf8_string_to_codepoint(const rbs_string_t string) {
+    unsigned int codepoint = 0;
+    int remaining_bytes = 0;
+
+    const char *s = string.start;
+    const char *end = string.end;
+
+    if (s >= end) return 0;  // End of string
+
+    if ((*s & 0x80) == 0) {
+        // Single byte character (0xxxxxxx)
+        return *s;
+    } else if ((*s & 0xE0) == 0xC0) {
+        // Two byte character (110xxxxx 10xxxxxx)
+        codepoint = *s & 0x1F;
+        remaining_bytes = 1;
+    } else if ((*s & 0xF0) == 0xE0) {
+        // Three byte character (1110xxxx 10xxxxxx 10xxxxxx)
+        codepoint = *s & 0x0F;
+        remaining_bytes = 2;
+    } else if ((*s & 0xF8) == 0xF0) {
+        // Four byte character (11110xxx 10xxxxxx 10xxxxxx 10xxxxxx)
+        codepoint = *s & 0x07;
+        remaining_bytes = 3;
+    } else {
+        // Invalid UTF-8 sequence
+        return 0xFFFD;  // Unicode replacement character
+    }
+
+    s++;
+    while (remaining_bytes > 0 && s < end) {
+        if ((*s & 0xC0) != 0x80) {
+            // Invalid continuation byte
+            return 0xFFFD;
+        }
+        codepoint = (codepoint << 6) | (*s & 0x3F);
+        s++;
+        remaining_bytes--;
+    }
+
+    if (remaining_bytes > 0) {
+        // Incomplete sequence
+        return 0xFFFD;
+    }
+
+    return codepoint;
+}
+
+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,149 @@
+/**
+ *  @file rbs_allocator.c
+ *
+ *  A simple arena allocator that can be freed all at once.
+ *
+ *  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>
+    #include <sys/types.h>
+    #include <sys/mman.h>
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun)
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+
+struct rbs_allocator {
+    uintptr_t heap_ptr;
+    uintptr_t size;
+};
+
+static size_t get_system_page_size(void) {
+#ifdef _WIN32
+    SYSTEM_INFO si;
+    GetSystemInfo(&si);
+    return si.dwPageSize;
+#else
+    long sz = sysconf(_SC_PAGESIZE);
+    if (sz == -1) return 4096; // Fallback to the common 4KB page size
+    return (size_t) sz;
+#endif
+}
+
+static void *map_memory(size_t size) {
+#ifdef _WIN32
+    LPVOID result = VirtualAlloc(NULL, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+    rbs_assert(result != NULL, "VirtualAlloc failed");
+#else
+    void *result = mmap(NULL, size, PROT_READ | PROT_WRITE,
+                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    rbs_assert(result != MAP_FAILED, "mmap failed");
+#endif
+    return result;
+}
+
+static void destroy_memory(void *memory, size_t size) {
+#ifdef _WIN32
+    VirtualFree(memory, 0, MEM_RELEASE);
+#else
+    munmap(memory, size);
+#endif
+}
+
+static void guard_page(void *memory, size_t page_size) {
+#ifdef _WIN32
+    DWORD old_protect_;
+    BOOL result = VirtualProtect(memory, page_size, PAGE_NOACCESS, &old_protect_);
+    rbs_assert(result != 0, "VirtualProtect failed");
+#else
+    int result = mprotect(memory, page_size, PROT_NONE);
+    rbs_assert(result == 0, "mprotect failed");
+#endif
+}
+
+static size_t rbs_allocator_default_mem(void) {
+    size_t kib = 1024;
+    size_t mib = kib * 1024;
+    size_t gib = mib * 1024;
+    return 4 * gib;
+}
+
+static inline bool is_power_of_two(uintptr_t value) {
+    return value > 0 && (value & (value - 1)) == 0;
+}
+
+// Align `val' to nearest multiple of `alignment'.
+static uintptr_t align(uintptr_t size, uintptr_t alignment) {
+    rbs_assert(is_power_of_two(alignment), "alignment is not a power of two");
+    return (size + alignment - 1) & ~(alignment - 1);
+}
+
+rbs_allocator_t *rbs_allocator_init(void) {
+    size_t size = rbs_allocator_default_mem();
+    size_t page_size = get_system_page_size();
+    size = align(size, page_size);
+    void *mem = map_memory(size + page_size);
+    // Guard page; remove range checks in alloc fast path and hard fail if we
+    // consume all memory
+    void *last_page = (char *) mem + size;
+    guard_page(last_page, page_size);
+    uintptr_t start = (uintptr_t) mem;
+    rbs_allocator_t header = (rbs_allocator_t) {
+      .heap_ptr = start + sizeof header,
+      .size = size + page_size,
+    };
+    memcpy(mem, &header, sizeof header);
+    return (rbs_allocator_t *) mem;
+}
+
+void rbs_allocator_free(rbs_allocator_t *allocator) {
+    destroy_memory((void *) allocator, allocator->size);
+}
+
+// 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) {
+    rbs_assert(size % alignment == 0, "size must be a multiple of the alignment. size: %zu, alignment: %zu", size, alignment);
+    uintptr_t aligned = align(allocator->heap_ptr, alignment);
+    allocator->heap_ptr = aligned + size;
+    return (void *) aligned;
+}
+
+// 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);
+#if defined(__linux__)
+    // mmap with MAP_ANONYMOUS gives zero-filled pages.
+#else
+    memset(p, 0, count * size);
+#endif
+    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(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) {
+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;
@@ -169,7 +96,7 @@ rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
 }
 
 // This storage is initialized by `Init_rbs_extension()` in `main.c`.
-static rbs_constant_pool_t RBS_GLOBAL_CONSTANT_POOL_STORAGE = { 0 };
+static rbs_constant_pool_t RBS_GLOBAL_CONSTANT_POOL_STORAGE = {};
 rbs_constant_pool_t *RBS_GLOBAL_CONSTANT_POOL = &RBS_GLOBAL_CONSTANT_POOL_STORAGE;
 
 /**
@@ -197,7 +124,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 +134,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 +162,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 +203,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 +228,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