yeptris 0.6.18.2-arm-linux-eabihf

data/vendor/libyeptris/src/yeptris/memory/allocator.c

@@ -0,0 +1,20 @@
+/* allocator.c — the system default. */
+
+#include <stdlib.h>
+
+#include "allocator.h"
+
+static void* yep_sys_alloc(void* ctx, size_t size) {
+    (void)ctx;
+    return malloc(size);
+}
+
+static void yep_sys_free(void* ctx, void* ptr) {
+    (void)ctx;
+    free(ptr);
+}
+
+const yep_allocator* yep_system_allocator(void) {
+    static const yep_allocator sys = {yep_sys_alloc, yep_sys_free, NULL};
+    return &sys;
+}

data/vendor/libyeptris/src/yeptris/memory/allocator.h

@@ -0,0 +1,43 @@
+/* allocator.h — the single indirection point for system memory.
+ *
+ * Every consumer (pool, arena, document) takes a yep_allocator explicitly;
+ * yep_system_allocator() is the default. No process-global override —
+ * injection is just passing a different allocator (TODO.impl/19 tests
+ * count and fail allocations this way).
+ *
+ * Memory law: nothing outside memory/ calls malloc/free directly.
+ */
+#ifndef YEP_ALLOCATOR_H
+#define YEP_ALLOCATOR_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* (*yep_alloc_fn)(void* ctx, size_t size);
+typedef void (*yep_free_fn)(void* ctx, void* ptr);
+
+typedef struct yep_allocator {
+    yep_alloc_fn alloc; /* returns NULL on failure; size > 0 */
+    yep_free_fn free;   /* accepts NULL */
+    void* ctx;
+} yep_allocator;
+
+/* The system allocator (malloc/free). Valid forever. */
+const yep_allocator* yep_system_allocator(void);
+
+static inline void* yep_alloc(const yep_allocator* a, size_t size) {
+    return a->alloc(a->ctx, size);
+}
+
+static inline void yep_free(const yep_allocator* a, void* ptr) {
+    a->free(a->ctx, ptr);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_ALLOCATOR_H */

data/vendor/libyeptris/src/yeptris/memory/arena.c

@@ -0,0 +1,134 @@
+/* arena.c — hint-sized contiguous arena with doubling growth. */
+
+#include <stdint.h>
+
+#include "arena.h"
+
+#define YEP_ARENA_DEFAULT_BLOCK (16u * 1024u)
+
+typedef struct yep_arena_block {
+    struct yep_arena_block* next;
+    size_t size;
+    size_t used;
+} yep_arena_block;
+
+struct yep_arena {
+    const yep_allocator* sys;
+    yep_arena_block* head; /* newest block; next pointers run newest → oldest */
+    size_t last_block_size;
+    yep_arena_stats stats;
+};
+
+static size_t yep_round_up(size_t n, size_t align) {
+    return (n + align - 1) & ~(align - 1);
+}
+
+static int yep_align_ok(size_t align) {
+    return align != 0 && (align & (align - 1)) == 0;
+}
+
+static size_t yep_initial_capacity(const yep_sizing_hints* hints) {
+    size_t cap = YEP_ARENA_DEFAULT_BLOCK;
+    if (hints != NULL) {
+        size_t derived = hints->min_capacity + hints->newline_count * 48 +
+                         (hints->colon_count + hints->quote_count) * 8;
+        if (derived > cap) {
+            cap = derived;
+        }
+    }
+    return cap;
+}
+
+static yep_arena_block* yep_arena_block_new(const yep_allocator* sys, size_t payload,
+                                            size_t* sys_allocs) {
+    yep_arena_block* b = yep_alloc(sys, sizeof(yep_arena_block) + payload);
+    if (b == NULL) {
+        return NULL;
+    }
+    b->next = NULL;
+    b->size = payload;
+    b->used = 0;
+    (*sys_allocs)++;
+    return b;
+}
+
+yep_arena* yep_arena_create(const yep_allocator* sys, const yep_sizing_hints* hints) {
+    if (sys == NULL) {
+        return NULL;
+    }
+
+    yep_arena* a = yep_alloc(sys, sizeof(yep_arena));
+    if (a == NULL) {
+        return NULL;
+    }
+    a->sys = sys;
+    a->head = NULL;
+    a->last_block_size = 0;
+    a->stats.blocks = 0;
+    a->stats.capacity = 0;
+    a->stats.used = 0;
+    a->stats.sys_allocs = 1; /* this struct */
+
+    size_t cap = yep_initial_capacity(hints);
+    a->head = yep_arena_block_new(sys, cap, &a->stats.sys_allocs);
+    if (a->head == NULL) {
+        yep_free(sys, a);
+        return NULL;
+    }
+    a->last_block_size = cap;
+    a->stats.blocks = 1;
+    a->stats.capacity = cap;
+    return a;
+}
+
+void* yep_arena_alloc(yep_arena* arena, size_t size, size_t align) {
+    if (arena == NULL || size == 0 || !yep_align_ok(align)) {
+        return NULL;
+    }
+
+    yep_arena_block* b = arena->head;
+    uintptr_t base = (uintptr_t)b + sizeof(yep_arena_block);
+    uintptr_t start = yep_round_up(base + b->used, align);
+
+    if (start + size > base + b->size) {
+        /* Amortized doubling: each new block is at least twice the last,
+         * unless the request itself is larger. */
+        size_t payload = arena->last_block_size * 2;
+        if (payload < size + align + sizeof(yep_arena_block)) {
+            payload = size + align + sizeof(yep_arena_block);
+        }
+        b = yep_arena_block_new(arena->sys, payload, &arena->stats.sys_allocs);
+        if (b == NULL) {
+            return NULL;
+        }
+        b->next = arena->head; /* newest at head; tail keeps destroy order */
+        arena->head = b;
+        arena->last_block_size = payload;
+        arena->stats.blocks++;
+        arena->stats.capacity += payload;
+        base = (uintptr_t)b + sizeof(yep_arena_block);
+        start = yep_round_up(base, align);
+    }
+
+    b->used = start + size - base;
+    arena->stats.used += size;
+    return (void*)start;
+}
+
+void yep_arena_destroy(yep_arena* arena) {
+    if (arena == NULL) {
+        return;
+    }
+    yep_arena_block* b = arena->head;
+    while (b != NULL) {
+        yep_arena_block* next = b->next;
+        yep_free(arena->sys, b);
+        b = next;
+    }
+    yep_free(arena->sys, arena);
+}
+
+yep_arena_stats yep_arena_get_stats(const yep_arena* arena) {
+    yep_arena_stats zero = {0, 0, 0, 0};
+    return arena ? arena->stats : zero;
+}

data/vendor/libyeptris/src/yeptris/memory/arena.h

@@ -0,0 +1,52 @@
+/* arena.h — the contiguous per-document arena (libleptris TODO 183
+ * pattern): an initial block sized from scan-derived hints so a typical
+ * document needs no further system allocations, plus amortized-doubling
+ * growth for underestimated inputs. All document-reachable memory lives
+ * here or in a pool; yeptris_document_free frees the arena and the world.
+ */
+#ifndef YEP_ARENA_H
+#define YEP_ARENA_H
+
+#include <stddef.h>
+
+#include "allocator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Content-derived sizing hints. Counts come from the scan layer's fused
+ * SIMD counters (TODO.impl/06). The multipliers are heuristic placeholders
+ * until 06 wires measured densities; they only affect the initial block
+ * size, never correctness. */
+typedef struct yep_sizing_hints {
+    size_t min_capacity;  /* explicit floor */
+    size_t newline_count; /* '\n' occurrences in the input */
+    size_t colon_count;   /* ':' occurrences */
+    size_t quote_count;   /* '"' occurrences */
+} yep_sizing_hints;
+
+typedef struct yep_arena_stats {
+    size_t blocks;
+    size_t capacity;   /* total payload bytes across blocks */
+    size_t used;       /* bytes handed out (excludes alignment loss) */
+    size_t sys_allocs; /* system allocation count (the 0-after-reserve gate) */
+} yep_arena_stats;
+
+typedef struct yep_arena yep_arena;
+
+/* hints may be NULL (16 KiB default). */
+yep_arena* yep_arena_create(const yep_allocator* sys, const yep_sizing_hints* hints);
+void yep_arena_destroy(yep_arena* arena);
+
+/* Allocates size bytes with power-of-two alignment. Returns NULL on
+ * allocation failure or absurd align. */
+void* yep_arena_alloc(yep_arena* arena, size_t size, size_t align);
+
+yep_arena_stats yep_arena_get_stats(const yep_arena* arena);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_ARENA_H */

data/vendor/libyeptris/src/yeptris/memory/pool.c

@@ -0,0 +1,122 @@
+/* pool.c — bump pool implementation. */
+
+#include <stdint.h>
+
+#include "pool.h"
+
+#define YEP_POOL_DEFAULT_BLOCK (4u * 1024u)
+#define YEP_POOL_MIN_BLOCK 256u
+
+typedef struct yep_block {
+    struct yep_block* next;
+    size_t size; /* payload bytes (excludes the header) */
+    size_t used;
+} yep_block;
+
+struct yep_pool {
+    const yep_allocator* sys;
+    yep_block* head;
+    size_t block_size;
+    size_t blocks;
+};
+
+static size_t yep_round_up(size_t n, size_t align) {
+    return (n + align - 1) & ~(align - 1);
+}
+
+static int yep_align_ok(size_t align) {
+    return align != 0 && (align & (align - 1)) == 0;
+}
+
+static yep_block* yep_block_new(const yep_allocator* sys, size_t payload) {
+    yep_block* b = yep_alloc(sys, sizeof(yep_block) + payload);
+    if (b == NULL) {
+        return NULL;
+    }
+    b->next = NULL;
+    b->size = payload;
+    b->used = 0;
+    return b;
+}
+
+void* yep_pool_alloc(yep_pool* pool, size_t size, size_t align) {
+    if (pool == NULL || size == 0 || !yep_align_ok(align)) {
+        return NULL;
+    }
+
+    yep_block* b = pool->head;
+    if (b == NULL) { /* the lazy first block (#157) */
+        b = yep_block_new(pool->sys, pool->block_size);
+        if (b == NULL) {
+            return NULL;
+        }
+        b->next = NULL;
+        pool->head = b;
+        pool->blocks = 1;
+    }
+    uintptr_t base = (uintptr_t)b + sizeof(yep_block);
+    uintptr_t start = yep_round_up(base + b->used, align);
+
+    if (start + size > base + b->size) {
+        /* Dedicated-or-default new block, sized so the aligned request
+         * always fits (malloc returns at least 16-byte-aligned memory, so
+         * the correction is < align). */
+        size_t payload = pool->block_size;
+        if (payload < size + align + sizeof(yep_block)) {
+            payload = size + align + sizeof(yep_block);
+        }
+        b = yep_block_new(pool->sys, payload);
+        if (b == NULL) {
+            return NULL;
+        }
+        b->next = pool->head;
+        pool->head = b;
+        pool->blocks++;
+        base = (uintptr_t)b + sizeof(yep_block);
+        start = yep_round_up(base, align);
+    }
+
+    b->used = start + size - base;
+    return (void*)start;
+}
+
+yep_pool* yep_pool_create(const yep_allocator* sys, size_t block_size) {
+    if (sys == NULL) {
+        return NULL;
+    }
+    if (block_size == 0) {
+        block_size = YEP_POOL_DEFAULT_BLOCK;
+    }
+    if (block_size < YEP_POOL_MIN_BLOCK) {
+        block_size = YEP_POOL_MIN_BLOCK;
+    }
+
+    yep_pool* p = yep_alloc(sys, sizeof(yep_pool));
+    if (p == NULL) {
+        return NULL;
+    }
+    p->sys = sys;
+    p->block_size = block_size;
+    /* #157: the first block is lazy — one fewer eager allocation per
+     * document; pool_alloc materializes it on first use */
+    p->head = NULL;
+    p->blocks = 0;
+    return p;
+}
+
+void yep_pool_destroy(yep_pool* pool) {
+    if (pool == NULL) {
+        return;
+    }
+    yep_block* b = pool->head;
+    while (b != NULL) {
+        yep_block* next = b->next;
+        yep_free(pool->sys, b);
+        b = next;
+    }
+    yep_free(pool->sys, pool);
+}
+
+size_t yep_pool_block_count(const yep_pool* pool) {
+    return pool ? pool->blocks : 0;
+}

data/vendor/libyeptris/src/yeptris/memory/pool.h

@@ -0,0 +1,36 @@
+/* pool.h — O(1) bump pool for small, same-lifetime objects.
+ *
+ * Allocation is pointer-bump within the current block; oversized requests
+ * get a dedicated block. Destruction frees every block in one walk. The
+ * pool never frees individual objects (arena-of-record semantics for
+ * transient same-lifetime work, e.g. per-parse scratch).
+ */
+#ifndef YEP_POOL_H
+#define YEP_POOL_H
+
+#include <stddef.h>
+
+#include "allocator.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct yep_pool yep_pool;
+
+/* block_size 0 selects the 4 KiB default; rounded up to at least 256 B. */
+yep_pool* yep_pool_create(const yep_allocator* sys, size_t block_size);
+void yep_pool_destroy(yep_pool* pool);
+
+/* Bump-allocates size bytes with power-of-two alignment. Returns NULL on
+ * allocation failure or absurd align. */
+void* yep_pool_alloc(yep_pool* pool, size_t size, size_t align);
+
+/* Number of blocks allocated so far (observability for tests + ledger). */
+size_t yep_pool_block_count(const yep_pool* pool);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* YEP_POOL_H */