pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/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/vendor/bundle/ruby/3.4.0/gems/rbs-4.2.0/src/util/rbs_constant_pool.c

@@ -0,0 +1,268 @@
+#include "rbs/util/rbs_constant_pool.h"
+#include "rbs/util/rbs_assert.h"
+
+/**
+ * A relatively simple hash function (djb2) that is used to hash strings. We are
+ * optimizing here for simplicity and speed.
+ */
+static inline uint32_t
+rbs_constant_pool_hash(const uint8_t *start, size_t length) {
+    // This is a prime number used as the initial value for the hash function.
+    uint32_t value = 5381;
+
+    for (size_t index = 0; index < length; index++) {
+        value = ((value << 5) + value) + start[index];
+    }
+
+    return value;
+}
+
+/**
+ * https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
+ */
+static uint32_t
+next_power_of_two(uint32_t v) {
+    // Avoid underflow in subtraction on next line.
+    if (v == 0) {
+        // 1 is the nearest power of 2 to 0 (2^0)
+        return 1;
+    }
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    v++;
+    return v;
+}
+
+RBS_ATTRIBUTE_UNUSED static bool is_power_of_two(uint32_t size) {
+    return (size & (size - 1)) == 0;
+}
+
+/**
+ * Resize a constant pool to a given capacity.
+ */
+static inline bool
+rbs_constant_pool_resize(rbs_constant_pool_t *pool) {
+    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;
+
+    const uint32_t mask = next_capacity - 1;
+    const size_t element_size = sizeof(rbs_constant_pool_bucket_t) + sizeof(rbs_constant_t);
+
+    void *next = calloc(next_capacity, element_size);
+    if (next == NULL) return false;
+
+    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.
+    for (uint32_t index = 0; index < pool->capacity; index++) {
+        rbs_constant_pool_bucket_t *bucket = &pool->buckets[index];
+
+        // If an id is set on this constant, then we know we have content here.
+        // In this case we need to insert it into the next constant pool.
+        if (bucket->id != RBS_CONSTANT_ID_UNSET) {
+            uint32_t next_index = bucket->hash & mask;
+
+            // This implements linear scanning to find the next available slot
+            // in case this index is already taken. We don't need to bother
+            // comparing the values since we know that the hash is unique.
+            while (next_buckets[next_index].id != RBS_CONSTANT_ID_UNSET) {
+                next_index = (next_index + 1) & mask;
+            }
+
+            // Here we copy over the entire bucket, which includes the id so
+            // that they are consistent between resizes.
+            next_buckets[next_index] = *bucket;
+        }
+    }
+
+    // The constants are stable with respect to hash table resizes.
+    memcpy(next_constants, pool->constants, pool->size * sizeof(rbs_constant_t));
+
+    // pool->constants and pool->buckets are allocated out of the same chunk
+    // of memory, with the buckets coming first.
+    free(pool->buckets);
+    pool->constants = next_constants;
+    pool->buckets = next_buckets;
+    pool->capacity = next_capacity;
+    return true;
+}
+
+/**
+ * Initialize a new constant pool with a given 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;
+
+    capacity = next_power_of_two(capacity);
+    const size_t element_size = sizeof(rbs_constant_pool_bucket_t) + sizeof(rbs_constant_t);
+    void *memory = calloc(capacity, element_size);
+    if (memory == NULL) return false;
+
+    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;
+}
+
+/**
+ * Return a pointer to the constant indicated by the given constant id.
+ */
+rbs_constant_t *
+rbs_constant_pool_id_to_constant(const rbs_constant_pool_t *pool, rbs_constant_id_t constant_id) {
+    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];
+}
+
+/**
+ * Find a constant in a constant pool. Returns the id of the constant, or 0 if
+ * the constant is not found.
+ */
+rbs_constant_id_t
+rbs_constant_pool_find(const rbs_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    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);
+    uint32_t index = hash & mask;
+    rbs_constant_pool_bucket_t *bucket;
+
+    while (bucket = &pool->buckets[index], bucket->id != RBS_CONSTANT_ID_UNSET) {
+        rbs_constant_t *constant = &pool->constants[bucket->id - 1];
+        if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
+            return bucket->id;
+        }
+
+        index = (index + 1) & mask;
+    }
+
+    return RBS_CONSTANT_ID_UNSET;
+}
+
+/**
+ * Insert a constant into a constant pool and return its index in the pool.
+ */
+static inline rbs_constant_id_t
+rbs_constant_pool_insert(rbs_constant_pool_t *pool, const uint8_t *start, size_t length, rbs_constant_pool_bucket_type_t type) {
+    if (pool->size >= (pool->capacity / 4 * 3)) {
+        if (!rbs_constant_pool_resize(pool)) return RBS_CONSTANT_ID_UNSET;
+    }
+
+    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);
+    uint32_t index = hash & mask;
+    rbs_constant_pool_bucket_t *bucket;
+
+    while (bucket = &pool->buckets[index], bucket->id != RBS_CONSTANT_ID_UNSET) {
+        // If there is a collision, then we need to check if the content is the
+        // same as the content we are trying to insert. If it is, then we can
+        // return the id of the existing constant.
+        rbs_constant_t *constant = &pool->constants[bucket->id - 1];
+
+        if ((constant->length == length) && memcmp(constant->start, start, length) == 0) {
+            // Since we have found a match, we need to check if this is
+            // attempting to insert a shared or an owned constant. We want to
+            // prefer shared constants since they don't require allocations.
+            if (type == RBS_CONSTANT_POOL_BUCKET_OWNED) {
+                // If we're attempting to insert an owned constant and we have
+                // an existing constant, then either way we don't want the given
+                // memory. Either it's duplicated with the existing constant or
+                // it's not necessary because we have a shared version.
+                free((void *) start);
+            } else if (bucket->type == RBS_CONSTANT_POOL_BUCKET_OWNED) {
+                // If we're attempting to insert a shared constant and the
+                // existing constant is owned, then we can free the owned
+                // constant and replace it with the shared constant.
+                free((void *) constant->start);
+                constant->start = start;
+                bucket->type = (unsigned int) (RBS_CONSTANT_POOL_BUCKET_DEFAULT & 0x3);
+            }
+
+            return bucket->id;
+        }
+
+        index = (index + 1) & mask;
+    }
+
+    // IDs are allocated starting at 1, since the value 0 denotes a non-existent
+    // constant.
+    uint32_t id = ++pool->size;
+    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),
+        .type = (unsigned int) (type & 0x3),
+        .hash = hash
+    };
+
+    pool->constants[id - 1] = (rbs_constant_t) {
+        .start = start,
+        .length = length,
+    };
+
+    return id;
+}
+
+/**
+ * Insert a constant into a constant pool. Returns the id of the constant, or
+ * RBS_CONSTANT_ID_UNSET if any potential calls to resize fail.
+ */
+rbs_constant_id_t
+rbs_constant_pool_insert_shared(rbs_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    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
+ * potential calls to resize fail.
+ */
+rbs_constant_id_t
+rbs_constant_pool_insert_owned(rbs_constant_pool_t *pool, uint8_t *start, size_t length) {
+    return rbs_constant_pool_insert(pool, start, length, RBS_CONSTANT_POOL_BUCKET_OWNED);
+}
+
+/**
+ * Insert a constant into a constant pool from memory that is constant. Returns
+ * the id of the constant, or RBS_CONSTANT_ID_UNSET if any potential calls to
+ * resize fail.
+ */
+rbs_constant_id_t
+rbs_constant_pool_insert_constant(rbs_constant_pool_t *pool, const uint8_t *start, size_t length) {
+    return rbs_constant_pool_insert(pool, start, length, RBS_CONSTANT_POOL_BUCKET_CONSTANT);
+}
+
+/**
+ * Free the memory associated with a constant 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++) {
+        rbs_constant_pool_bucket_t *bucket = &pool->buckets[index];
+
+        // If an id is set on this constant, then we know we have content here.
+        if (bucket->id != RBS_CONSTANT_ID_UNSET && bucket->type == RBS_CONSTANT_POOL_BUCKET_OWNED) {
+            rbs_constant_t *constant = &pool->constants[bucket->id - 1];
+            free((void *) constant->start);
+        }
+    }
+
+    free(pool->buckets);
+}