1#ifndef PRISM_INTERNAL_ARENA_H
2#define PRISM_INTERNAL_ARENA_H
44 pm_arena_block_t *current;
47 pm_arena_block_t *large;
67void pm_arena_reserve(
pm_arena_t *arena,
size_t capacity);
74void * pm_arena_alloc_slow(
pm_arena_t *arena,
size_t size);
91pm_arena_alloc(
pm_arena_t *arena,
size_t size,
size_t alignment) {
92 if (arena->current != NULL) {
93 size_t used_aligned = (arena->current->used + alignment - 1) & ~(alignment - 1);
94 size_t needed = used_aligned + size;
96 if (used_aligned >= arena->current->used && needed >= used_aligned && needed <= arena->current->capacity) {
97 arena->current->used = needed;
98 return arena->current->data + used_aligned;
102 return pm_arena_alloc_slow(arena, size);
110void * pm_arena_alloc_aligned(
pm_arena_t *arena,
size_t size,
size_t alignment);
115#define PM_ARENA_ALLOC(arena_, T_) \
116 ((T_ *) pm_arena_alloc(arena_, sizeof(T_), PRISM_ALIGNOF(T_)))
123pm_arena_alloc_array(
pm_arena_t *arena,
size_t count,
size_t size,
size_t alignment) {
124 if (
PRISM_UNLIKELY(count > SIZE_MAX / size)) pm_arena_alloc_overflow();
125 return pm_arena_alloc(arena, count * size, alignment);
131#define PM_ARENA_ALLOC_ARRAY(arena_, T_, count_) \
132 ((T_ *) pm_arena_alloc_array(arena_, count_, sizeof(T_), PRISM_ALIGNOF(T_)))
139pm_arena_zalloc(
pm_arena_t *arena,
size_t size,
size_t alignment) {
140 void *ptr = pm_arena_alloc(arena, size, alignment);
141 memset(ptr, 0, size);
148#define PM_ARENA_ZALLOC(arena_, T_) \
149 ((T_ *) pm_arena_zalloc(arena_, sizeof(T_), PRISM_ALIGNOF(T_)))
156pm_arena_zalloc_array(
pm_arena_t *arena,
size_t count,
size_t size,
size_t alignment) {
157 void *ptr = pm_arena_alloc_array(arena, count, size, alignment);
158 memset(ptr, 0, count * size);
165#define PM_ARENA_ZALLOC_ARRAY(arena_, T_, count_) \
166 ((T_ *) pm_arena_zalloc_array(arena_, count_, sizeof(T_), PRISM_ALIGNOF(T_)))
173pm_arena_memdup(
pm_arena_t *arena,
const void *src,
size_t size,
size_t alignment) {
174 void *dst = pm_arena_alloc(arena, size, alignment);
175 memcpy(dst, src, size);
191pm_arena_realloc(
pm_arena_t *arena,
void *ptr,
size_t new_size,
size_t old_size,
size_t alignment) {
195 result = pm_arena_alloc(arena, new_size, alignment);
197 pm_arena_block_t *block = arena->current;
199 if (block != NULL && (
char *) ptr + old_size == block->data + block->used) {
200 size_t start = block->used - old_size;
202 if (new_size <= block->capacity - start) {
203 block->used = start + new_size;
208 if (new_size <= old_size)
return ptr;
210 result = pm_arena_alloc(arena, new_size, alignment);
211 memcpy(result, ptr, old_size);
220#define PM_ARENA_REALLOC(arena_, ptr_, new_size_, old_size_, T_) \
221 ((T_ *) pm_arena_realloc(arena_, ptr_, new_size_, old_size_, PRISM_ALIGNOF(T_)))
A bump allocator for the prism parser.
#define PRISM_UNLIKELY(x)
The compiler should predicate that this branch will not be taken.
#define PM_FLEX_ARRAY_LENGTH
A macro for helper define a flexible array member.
#define PRISM_FORCE_INLINE
Force a function to be inlined at every call site.
#define PRISM_INLINE
Old Visual Studio versions do not support the inline keyword, so we need to define it to be __inline.
#define PRISM_NORETURN
Mark a function as never returning to its caller, so that the compiler can treat the code after a cal...