From fd187edbafff4507f2f173cc2bc2948658334e55 Mon Sep 17 00:00:00 2001 From: Allen Webster Date: Fri, 17 Oct 2025 15:49:52 -0700 Subject: [PATCH] lesson-1 initial commit --- .gitignore | 1 + aritynode.blank.c | 49 + aritynode.c | 359 +++++++ aritynode.h | 92 ++ aritynode.test.c | 57 ++ base.c | 2260 +++++++++++++++++++++++++++++++++++++++++++++ base.h | 634 +++++++++++++ build.bat | 10 + build.sh | 12 + test.c | 25 + 10 files changed, 3499 insertions(+) create mode 100644 .gitignore create mode 100644 aritynode.blank.c create mode 100644 aritynode.c create mode 100644 aritynode.h create mode 100644 aritynode.test.c create mode 100644 base.c create mode 100644 base.h create mode 100644 build.bat create mode 100644 build.sh create mode 100644 test.c diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..07ed706 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +build/* \ No newline at end of file diff --git a/aritynode.blank.c b/aritynode.blank.c new file mode 100644 index 0000000..9d654bd --- /dev/null +++ b/aritynode.blank.c @@ -0,0 +1,49 @@ +//////////////////////////////// +// Functions: Arity Node + +// construction + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_empty(Arena *arena){ + return(0); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_singleton(Arena *arena){ + return(0); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_arrow(Arena *arena, DS_ArityNode *domain, DS_ArityNode *codomain){ + return(0); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_paste(Arena *arena, DS_ArityNode *a, DS_ArityNode *b){ + return(0); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_sum(Arena *arena, ...){ + va_list args; + va_start(args, arena); + va_end(args); + return(0); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_ktuple(Arena *arena, U32 coefficient){ + return(0); +} + +// operations + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_copy(Arena *arena, DS_ArityNode *arity){ + return(0); +} + +MR4TH_SYMBOL B32 +ds_aritynode_equal(DS_ArityNode *a, DS_ArityNode *b){ + return(0); +} diff --git a/aritynode.c b/aritynode.c new file mode 100644 index 0000000..ba43a07 --- /dev/null +++ b/aritynode.c @@ -0,0 +1,359 @@ +//////////////////////////////// +// Functions: Arity Node + +// construction + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_empty(Arena *arena){ + DS_ArityNode *node = push_array(arena, DS_ArityNode, 1); + node->kind = DS_ArityKind_Empty; + return(node); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_singleton(Arena *arena){ + DS_ArityNode *node = push_array(arena, DS_ArityNode, 1); + node->kind = DS_ArityKind_Singleton; + node->coefficient = 1; + return(node); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_arrow(Arena *arena, DS_ArityNode *domain, DS_ArityNode *codomain){ + DS_ArityNode *node = 0; + if (domain->kind == DS_ArityKind_Empty || + codomain->kind == DS_ArityKind_Empty){ + node = codomain; + } + else{ + node = push_array(arena, DS_ArityNode, 1); + node->kind = DS_ArityKind_Arrow; + node->coefficient = 1; + node->arrow.domain = domain; + node->arrow.codomain = codomain; + } + return(node); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_paste(Arena *arena, DS_ArityNode *a, DS_ArityNode *b){ + ArenaTemp scratch = arena_get_scratch(&arena, 1); + DS_ArityNode *node = 0; + + if (a->kind == DS_ArityKind_Empty){ + node = b; + } + else if (b->kind == DS_ArityKind_Empty){ + node = a; + } + else{ + // count parts + U64 max_part_count = 0; + if (a->kind != DS_ArityKind_Tuple){ + max_part_count += 1; + } + else{ + max_part_count += a->tuple.part_count; + } + if (b->kind != DS_ArityKind_Tuple){ + max_part_count += 1; + } + else{ + max_part_count += b->tuple.part_count; + } + + // fill parts + DS_ArityNode **parts = push_array(scratch.arena, DS_ArityNode*, max_part_count); + DS_ArityNode **part_ptr = parts; + + if (a->kind != DS_ArityKind_Tuple){ + *part_ptr = ds_aritynode__part_copy(arena, a); + (*part_ptr)->coefficient = 1; + part_ptr += 1; + } + else{ + for (U64 i = 0; i < a->tuple.part_count; i += 1){ + DS_ArityNode *a_part = a->tuple.parts[i]; + *part_ptr = ds_aritynode__part_copy(arena, a_part); + (*part_ptr)->coefficient = a_part->coefficient; + part_ptr += 1; + } + } + + if (b->kind != DS_ArityKind_Tuple){ + DS_ArityNode *match_pos = ds_aritynode__part_find_match(parts, part_ptr, b); + if (match_pos != 0){ + match_pos->coefficient += 1; + } + else{ + *part_ptr = ds_aritynode__part_copy(arena, b); + (*part_ptr)->coefficient = 1; + part_ptr += 1; + } + } + else{ + for (U64 j = 0; j < b->tuple.part_count; j += 1){ + DS_ArityNode *b_part = b->tuple.parts[j]; + DS_ArityNode *match_pos = ds_aritynode__part_find_match(parts, part_ptr, b_part); + if (match_pos != 0){ + match_pos->coefficient += b_part->coefficient; + } + else{ + *part_ptr = ds_aritynode__part_copy(arena, b_part); + (*part_ptr)->coefficient = b_part->coefficient; + part_ptr += 1; + } + } + } + + // final part count + U64 part_count = (U64)(part_ptr - parts); + + // fill result node + Assert(part_count > 1 || + part_count == 1 && parts[0]->coefficient > 1); + + DS_ArityNode **parts_final = push_array(arena, DS_ArityNode*, part_count); + MemoryCopy(parts_final, parts, sizeof(*parts)*part_count); + + node = push_array(arena, DS_ArityNode, 1); + node->kind = DS_ArityKind_Tuple; + node->coefficient = 1; + node->tuple.parts = parts_final; + node->tuple.part_count = part_count; + } + + arena_release_scratch(&scratch); + + return(node); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_sum(Arena *arena, ...){ + va_list args; + va_start(args, arena); + + va_list args2; + va_copy(args2, args); + + ArenaTemp scratch = arena_get_scratch(&arena, 1); + + // count parts + U64 max_part_count = 0; + for (;;){ + U32 multiplier = va_arg(args, U32); + if (multiplier == 0){ + break; + } + DS_ArityNode *arity = va_arg(args, DS_ArityNode*); + if (arity->kind == DS_ArityKind_Empty){ + // do nothing + } + else if (arity->kind != DS_ArityKind_Tuple){ + max_part_count += 1; + } + else{ + max_part_count += arity->tuple.part_count; + } + } + + // fill parts + DS_ArityNode **parts = push_array(scratch.arena, DS_ArityNode*, max_part_count); + DS_ArityNode **part_ptr = parts; + + for (;;){ + U32 multiplier = va_arg(args2, U32); + if (multiplier == 0){ + break; + } + DS_ArityNode *arity = va_arg(args2, DS_ArityNode*); + + if (arity->kind == DS_ArityKind_Empty){ + // do nothing + } + else if (arity->kind != DS_ArityKind_Tuple){ + DS_ArityNode *match_pos = ds_aritynode__part_find_match(parts, part_ptr, arity); + if (match_pos != 0){ + match_pos->coefficient += multiplier; + } + else{ + *part_ptr = ds_aritynode__part_copy(arena, arity); + (*part_ptr)->coefficient = multiplier; + part_ptr += 1; + } + } + else{ + for (U64 j = 0; j < arity->tuple.part_count; j += 1){ + DS_ArityNode *b_part = arity->tuple.parts[j]; + DS_ArityNode *match_pos = ds_aritynode__part_find_match(parts, part_ptr, b_part); + if (match_pos != 0){ + match_pos->coefficient += multiplier*b_part->coefficient; + } + else{ + *part_ptr = ds_aritynode__part_copy(arena, b_part); + (*part_ptr)->coefficient = multiplier*b_part->coefficient; + part_ptr += 1; + } + } + } + } + + // final part count + U64 part_count = (U64)(part_ptr - parts); + + // fill result node + DS_ArityNode *node = 0; + if (part_count == 0){ + node = ds_aritynode_empty(arena); + } + else if (part_count == 1 && + parts[0]->coefficient == 1){ + node = parts[0]; + } + else{ + DS_ArityNode **parts_final = push_array(arena, DS_ArityNode*, part_count); + MemoryCopy(parts_final, parts, sizeof(*parts)*part_count); + + node = push_array(arena, DS_ArityNode, 1); + node->kind = DS_ArityKind_Tuple; + node->coefficient = 1; + node->tuple.parts = parts_final; + node->tuple.part_count = part_count; + } + + arena_release_scratch(&scratch); + + va_end(args2); + va_end(args); + + return(node); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_ktuple(Arena *arena, U32 coefficient){ + DS_ArityNode *result = 0; + + if (coefficient > 1){ + result = push_array(arena, DS_ArityNode, 1); + DS_ArityNode **parts = push_array(arena, DS_ArityNode*, 1); + DS_ArityNode *singleton = push_array(arena, DS_ArityNode, 1); + + result->kind = DS_ArityKind_Tuple; + result->coefficient = 1; + result->tuple.parts = parts; + result->tuple.part_count = 1; + + parts[0] = singleton; + + singleton->kind = DS_ArityKind_Singleton; + singleton->coefficient = coefficient; + } + else if (coefficient == 1){ + result = ds_aritynode_singleton(arena); + } + else{ + result = ds_aritynode_empty(arena); + } + + return(result); +} + +// operations + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode_copy(Arena *arena, DS_ArityNode *arity){ + DS_ArityNode *result = push_array(arena, DS_ArityNode, 1); + result->kind = arity->kind; + result->coefficient = arity->coefficient; + switch (result->kind){ + case DS_ArityKind_Arrow: + { + result->arrow.domain = ds_aritynode_copy(arena, arity->arrow.domain); + result->arrow.codomain = ds_aritynode_copy(arena, arity->arrow.codomain); + }break; + + case DS_ArityKind_Tuple: + { + U64 part_count = arity->tuple.part_count; + DS_ArityNode **parts = push_array(arena, DS_ArityNode*, part_count); + for (U64 i = 0; i < part_count; i += 1){ + parts[i] = ds_aritynode_copy(arena, arity->tuple.parts[i]); + } + result->tuple.parts = parts; + result->tuple.part_count = part_count; + }break; + } + return(result); +} + +MR4TH_SYMBOL B32 +ds_aritynode_equal(DS_ArityNode *a, DS_ArityNode *b){ + B32 result = 0; + + if (a->kind == b->kind){ + switch (a->kind){ + case DS_ArityKind_Empty: + case DS_ArityKind_Singleton: result = 1; break; + + case DS_ArityKind_Arrow: + { + if (ds_aritynode_equal(a->arrow.domain, b->arrow.domain) && + ds_aritynode_equal(a->arrow.codomain, b->arrow.codomain)){ + result = 1; + } + }break; + + case DS_ArityKind_Tuple: + { + if (a->tuple.part_count == b->tuple.part_count){ + result = 1; + for (U64 i = 0; i < a->tuple.part_count; i += 1){ + DS_ArityNode *a_part = a->tuple.parts[i]; + B32 found_match = 0; + for (U64 j = 0; j < b->tuple.part_count; j += 1){ + DS_ArityNode *b_part = b->tuple.parts[j]; + if (b_part->coefficient == a_part->coefficient && + ds_aritynode_equal(a_part, b_part)){ + found_match = 1; + break; + } + } + if (!found_match){ + result = 0; + break; + } + } + } + }break; + } + } + + return(result); +} + +// helpers + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode__part_copy(Arena *arena, DS_ArityNode *node){ + Assert(node->kind != DS_ArityKind_Tuple); + DS_ArityNode *result = push_array(arena, DS_ArityNode, 1); + result->kind = node->kind; + if (result->kind == DS_ArityKind_Arrow){ + result->arrow.domain = node->arrow.domain; + result->arrow.codomain = node->arrow.codomain; + } + return(result); +} + +MR4TH_SYMBOL DS_ArityNode* +ds_aritynode__part_find_match(DS_ArityNode **parts_first, DS_ArityNode **parts_opl, DS_ArityNode *key){ + DS_ArityNode **part = parts_first; + DS_ArityNode *match = 0; + for (; part < parts_opl; part += 1){ + if (ds_aritynode_equal(*part, key)){ + match = *part; + break; + } + } + return(match); +} diff --git a/aritynode.h b/aritynode.h new file mode 100644 index 0000000..91a345b --- /dev/null +++ b/aritynode.h @@ -0,0 +1,92 @@ +#ifndef ARITYNODE_H +#define ARITYNODE_H + +//////////////////////////////// +// Type: Arity Node + +typedef enum DS_ArityKind{ + DS_ArityKind_Empty = 0, + DS_ArityKind_Singleton = 1, + DS_ArityKind_Arrow = 2, + DS_ArityKind_Tuple = 3, +} DS_ArityKind; + +typedef struct DS_ArityNode{ + DS_ArityKind kind; + U32 coefficient; + union{ + struct{ + struct DS_ArityNode *domain; + struct DS_ArityNode *codomain; + } arrow; + struct{ + struct DS_ArityNode **parts; + U64 part_count; + } tuple; + }; +} DS_ArityNode; + +//////////////////////////////// +// Functions: Arity Node + +// construction + +/* NOTE: +** Construction functions that take in arity node(s) require +** that the arena that allocated the input arity node(s) +** is the same arena that is used in the current call, and +** that the arena has not popped the nodes. +** +** Example of misuse: +** +** GIVEN Arena *a1; Arena *a2; +** WITH (a1 != a2): +** DS_ArityNode *n1 = ds_aritynode_singleton(a1); +** DS_ArityNode *n2 = ds_aritynode_arrow(a2, n1); @bad - changing arenas +** +** Why this matters: +** +** We don't want to have to deep copy every node we ever see as input, +** so construction functions just keep pointers to their inputs, or +** sometimes make shallow copies but still keep the original versions +** of the deeper nodes. Because of the way arenas work, if these +** all exist on one arena, later nodes always point towards earlier +** nodes, and so if a node is still on the arena, so are all of the nodes +** that it depends on. However, if we start crossing arenas, we would +** have to be much more careful not to start generating use-after-free +** issues. +** +** If you think it through and you *know what you're doing* you can +** break this rule, but as a rule of thumb, it usually works best if you +** can put all the nodes that work together into the same arena. +*/ + +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_empty(Arena *arena); +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_singleton(Arena *arena); +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_arrow(Arena *arena, DS_ArityNode *domain, DS_ArityNode *codomain); +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_paste(Arena *arena, DS_ArityNode *a, DS_ArityNode *b); + +/* NOTE: +** ds_aritynode_sum takes the variadic layout: +** (coeff_1:U32, arity_1:DS_ArityNode*, ..., coeff_k:U32, arity_k:DS_ArityNode*, 0) +*/ +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_sum(Arena *arena, ...); + +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_ktuple(Arena *arena, U32 coefficient); + +// operations + +/* NOTE: + ** ds_aritynode_copy is not a "construction function" +** it can deep copy an arity node from one arena to another. +*/ +MR4TH_SYMBOL DS_ArityNode* ds_aritynode_copy(Arena *arena, DS_ArityNode *arity); + +MR4TH_SYMBOL B32 ds_aritynode_equal(DS_ArityNode *a, DS_ArityNode *b); + +// helpers + +MR4TH_SYMBOL DS_ArityNode* ds_aritynode__part_copy(Arena *arena, DS_ArityNode *node); +MR4TH_SYMBOL DS_ArityNode* ds_aritynode__part_find_match(DS_ArityNode **parts_first, DS_ArityNode **parts_opl, DS_ArityNode *key); + +#endif //ARITYNODE_H diff --git a/aritynode.test.c b/aritynode.test.c new file mode 100644 index 0000000..5649701 --- /dev/null +++ b/aritynode.test.c @@ -0,0 +1,57 @@ +//////////////////////////////// +// Arity Node Sanity Test Function + +MR4TH_SYMBOL void +ds_aritynode__test(void){ + ArenaTemp scratch = arena_get_scratch(0, 0); + + DS_ArityNode *a_empty = ds_aritynode_empty(scratch.arena); + DS_ArityNode *a_s1 = ds_aritynode_singleton(scratch.arena); + DS_ArityNode *a_s2 = ds_aritynode_paste(scratch.arena, a_s1, a_s1); + DS_ArityNode *a_s3 = ds_aritynode_paste(scratch.arena, a_s2, a_s1); + DS_ArityNode *a_ar1 = ds_aritynode_arrow(scratch.arena, a_s1, a_s1); + + Assert(ds_aritynode_equal(a_empty, a_empty)); + Assert(ds_aritynode_equal(a_s1, a_s1)); + Assert(ds_aritynode_equal(a_s2, a_s2)); + Assert(ds_aritynode_equal(a_s3, a_s3)); + Assert(ds_aritynode_equal(a_ar1, a_ar1)); + + Assert(!ds_aritynode_equal(a_empty, a_s1)); + Assert(!ds_aritynode_equal(a_s1, a_s2)); + Assert(!ds_aritynode_equal(a_ar1, a_s1)); + + DS_ArityNode *a_s2x = ds_aritynode_sum(scratch.arena, 2, a_s1, 0); + DS_ArityNode *a_s3x = ds_aritynode_sum(scratch.arena, 3, a_s1, 0); + + Assert(ds_aritynode_equal(a_s2, a_s2x)); + Assert(ds_aritynode_equal(a_s3, a_s3x)); + + DS_ArityNode *a_s1_ar1 = ds_aritynode_paste(scratch.arena, a_s1, a_ar1); + DS_ArityNode *a_s2_ar1 = ds_aritynode_paste(scratch.arena, a_s1_ar1, a_s1); + DS_ArityNode *a_s2_ar1_x = ds_aritynode_paste(scratch.arena, a_s2, a_ar1); + + Assert(ds_aritynode_equal(a_s2_ar1, a_s2_ar1_x)); + + DS_ArityNode *a_ar1_2 = ds_aritynode_arrow(scratch.arena, a_s1, a_s2); + DS_ArityNode *a_ar1_3 = ds_aritynode_arrow(scratch.arena, a_s1, a_s3); + DS_ArityNode *a_ar_ar1 = ds_aritynode_arrow(scratch.arena, a_ar1, a_ar1); + DS_ArityNode *a_ar_ar2 = ds_aritynode_arrow(scratch.arena, a_ar1, a_ar1_2); + DS_ArityNode *a_ar_ar3 = ds_aritynode_arrow(scratch.arena, a_ar1, a_ar1_3); + + Assert(!ds_aritynode_equal(a_ar1, a_ar_ar1)); + Assert(!ds_aritynode_equal(a_ar_ar1, a_ar_ar2)); + Assert(!ds_aritynode_equal(a_ar_ar1, a_ar_ar3)); + Assert(!ds_aritynode_equal(a_ar_ar2, a_ar_ar3)); + + DS_ArityNode *a_ar1x = ds_aritynode_sum(scratch.arena, 1, a_ar1, 3, a_empty, 1, a_empty, 0); + + Assert(ds_aritynode_equal(a_ar1, a_ar1x)); + + DS_ArityNode *a_s17 = ds_aritynode_sum(scratch.arena, 17, a_s1, 0); + DS_ArityNode *a_s17x = ds_aritynode_ktuple(scratch.arena, 17); + + Assert(ds_aritynode_equal(a_s17, a_s17x)); + + arena_release_scratch(&scratch); +} diff --git a/base.c b/base.c new file mode 100644 index 0000000..13eb47d --- /dev/null +++ b/base.c @@ -0,0 +1,2260 @@ +//////////////////////////////// +// Memory Configuration + +#define MR4TH_MEM_DEFAULT_RESERVE_SIZE GB(1) +#define MR4TH_MEM_COMMIT_BLOCK_SIZE MB(64) +#define MR4TH_MEM_MAX_ALIGN 64 +#define MR4TH_MEM_SCRATCH_POOL_COUNT 2 + +//////////////////////////////// +// Functions: Arena + +#define MEM_INITIAL_COMMIT KB(4) +#define MEM_INTERNAL_MIN_SIZE AlignUpPow2(sizeof(Arena), MR4TH_MEM_MAX_ALIGN) + +// arena implementation + +MR4TH_SYMBOL Arena* +arena_alloc_reserve(U64 reserve_size, B32 growing){ + Arena *result = 0; + if (reserve_size >= MEM_INITIAL_COMMIT){ + void *memory = os_memory_reserve(reserve_size); + if (os_memory_commit(memory, MEM_INITIAL_COMMIT)){ + result = (Arena*)memory; + result->current = result; + result->prev = 0; + result->alignment = sizeof(void*); + result->growing = growing; + result->base_pos = 0; + result->chunk_cap = reserve_size; + result->chunk_pos = MEM_INTERNAL_MIN_SIZE; + result->chunk_commit_pos = MEM_INITIAL_COMMIT; + } + } + Assert(result != 0); + return(result); +} + +MR4TH_SYMBOL Arena* +arena_alloc(void){ + Arena *result = arena_alloc_reserve(MR4TH_MEM_DEFAULT_RESERVE_SIZE, 1); + return(result); +} + +MR4TH_SYMBOL void +arena_release(Arena *arena){ + Arena *ptr = arena->current; + for (;ptr != 0;){ + Arena *prev = ptr->prev; + os_memory_release(ptr, ptr->chunk_cap); + ptr = prev; + } +} + +MR4TH_SYMBOL void* +arena_push_no_zero(Arena *arena, U64 size){ + void *result = 0; + + Arena *current = arena->current; + + // allocate new chunk if necessary + if (arena->growing){ + U64 next_chunk_pos = AlignUpPow2(current->chunk_pos, arena->alignment); + next_chunk_pos += size; + if (next_chunk_pos > current->chunk_cap){ + U64 new_reserve_size = MR4TH_MEM_DEFAULT_RESERVE_SIZE; + U64 enough_to_fit = size + MEM_INTERNAL_MIN_SIZE; + if (new_reserve_size < enough_to_fit){ + new_reserve_size = AlignUpPow2(enough_to_fit, KB(4)); + } + + void *memory = os_memory_reserve(new_reserve_size); + if (os_memory_commit(memory, MEM_INITIAL_COMMIT)){ + Arena *new_chunk = (Arena*)memory; + new_chunk->prev = current; + new_chunk->base_pos = current->base_pos + current->chunk_cap; + new_chunk->chunk_cap = new_reserve_size; + new_chunk->chunk_pos = MEM_INTERNAL_MIN_SIZE; + new_chunk->chunk_commit_pos = MEM_INITIAL_COMMIT; + current = arena->current = new_chunk; + } + } + } + + { + // if there is room in this chunk's reserve ... + U64 result_pos = AlignUpPow2(current->chunk_pos, arena->alignment); + U64 next_chunk_pos = result_pos + size; + if (next_chunk_pos <= current->chunk_cap){ + + // commit more memory if necessary + if (next_chunk_pos > current->chunk_commit_pos){ + U64 next_commit_pos_aligned = + AlignUpPow2(next_chunk_pos, MR4TH_MEM_COMMIT_BLOCK_SIZE); + U64 next_commit_pos = + ClampTop(next_commit_pos_aligned, current->chunk_cap); + U64 commit_size = next_commit_pos - current->chunk_commit_pos; + if (os_memory_commit((U8*)current + current->chunk_commit_pos, commit_size)){ + current->chunk_commit_pos = next_commit_pos; + } + } + + // if there is room in the commit range, return memory & advance pos + if (next_chunk_pos <= current->chunk_commit_pos){ + result = (U8*)current + result_pos; + current->chunk_pos = next_chunk_pos; + } + } + } + + return(result); +} + +MR4TH_SYMBOL void +arena_pop_to(Arena *arena, U64 pos){ + Arena *current = arena->current; + U64 total_pos = current->base_pos + current->chunk_pos; + if (pos < total_pos){ + // release all chunks that begin after this pos + U64 clamped_total_pos = ClampBot(pos, MEM_INTERNAL_MIN_SIZE); + for (; clamped_total_pos < current->base_pos; ){ + Arena *prev = current->prev; + os_memory_release(current, current->chunk_cap); + current = prev; + } + + // update arena's current + { + arena->current = current; + } + + // update the chunk position of the chunk in + // the chain that contains this position. + { + U64 chunk_pos = clamped_total_pos - current->base_pos; + U64 clamped_chunk_pos = ClampBot(chunk_pos, MEM_INTERNAL_MIN_SIZE); + current->chunk_pos = clamped_chunk_pos; + } + } +} + +MR4TH_SYMBOL U64 +arena_current_pos(Arena *arena){ + Arena *current = arena->current; + U64 result = current->base_pos + current->chunk_pos; + return(result); +} + +MR4TH_SYMBOL void* +arena_push(Arena *arena, U64 size){ + void *result = arena_push_no_zero(arena, size); + MemoryZero(result, size); + return(result); +} + +MR4TH_SYMBOL void +arena_align(Arena *arena, U64 pow2_align){ + Assert(IsPow2OrZero(pow2_align) && pow2_align != 0 && + pow2_align <= MR4TH_MEM_MAX_ALIGN); + Arena *current = arena->current; + U64 p = current->chunk_pos; + U64 p_aligned = AlignUpPow2(p, pow2_align); + U64 z = p_aligned - p; + if (z > 0){ + arena_push(arena, z); + } +} + +MR4TH_SYMBOL void +arena_pop_amount(Arena *arena, U64 amount){ + Arena *current = arena->current; + U64 total_pos = current->base_pos + current->chunk_pos; + if (amount <= total_pos){ + U64 new_pos = total_pos - amount; + arena_pop_to(arena, new_pos); + } +} + +// temp helper functions + +MR4TH_SYMBOL ArenaTemp +arena_begin_temp(Arena *arena){ + U64 pos = arena_current_pos(arena); + ArenaTemp temp = {arena, pos}; + return(temp); +} + +MR4TH_SYMBOL void +arena_end_temp(ArenaTemp *temp){ + arena_pop_to(temp->arena, temp->pos); +} + +// scratch + +MR4TH_SYMBOL MR4TH_THREADVAR +Arena *arena__scratch_pool[MR4TH_MEM_SCRATCH_POOL_COUNT] = {0}; + +MR4TH_SYMBOL ArenaTemp +arena_get_scratch(Arena **conflict_array, U32 count){ + // init on first time + if (arena__scratch_pool[0] == 0){ + Arena **scratch_slot = arena__scratch_pool; + for (U64 i = 0; + i < MR4TH_MEM_SCRATCH_POOL_COUNT; + i += 1, scratch_slot += 1){ + *scratch_slot = arena_alloc(); + } + } + + // get non-conflicting arena + ArenaTemp result = {0}; + Arena **scratch_slot = arena__scratch_pool; + for (U64 i = 0; + i < MR4TH_MEM_SCRATCH_POOL_COUNT; + i += 1, scratch_slot += 1){ + B32 is_non_conflict = 1; + Arena **conflict_ptr = conflict_array; + for (U32 j = 0; j < count; j += 1, conflict_ptr += 1){ + if (*scratch_slot == *conflict_ptr){ + is_non_conflict = 0; + break; + } + } + if (is_non_conflict){ + result = arena_begin_temp(*scratch_slot); + break; + } + } + + return(result); +} + + +//////////////////////////////// +// Functions: Strings + +MR4TH_SYMBOL String8 +str8(U8 *str, U64 size){ + String8 result = {str, size}; + return(result); +} + +MR4TH_SYMBOL String8 +str8_range(U8 *first, U8 *opl){ + String8 result = {first, (U64)(opl - first)}; + return(result); +} + +MR4TH_SYMBOL String8 +str8_cstring(U8 *cstr){ + U8 *ptr = cstr; + for (;*ptr != 0; ptr += 1); + String8 result = str8_range(cstr, ptr); + return(result); +} + +MR4TH_SYMBOL String8 +str8_cstring_capped(U8 *cstr, U8 *opl){ + U8 *ptr = cstr; + for (;ptr < opl && *ptr != 0; ptr += 1); + String8 result = str8_range(cstr, ptr); + return(result); +} + +MR4TH_SYMBOL U32 +u32_from_str8_base10(String8 string){ + U32 result = 0; + + U8 *ptr = string.str; + U8 *opl = string.str + string.size; + for (; ptr < opl; ptr += 1){ + // extract + U8 num = 0xFF; + U8 s = *ptr - '0'; + if (s <= 9){ + num = s; + } + + // bad parse check + if (num >= 10){ + result = 0; + break; + } + + // increment result + result *= 10; + result += num; + } + + return(result); +} + + +//////////////////////////////// +// Functions: Stream + +// stream core implementation + +MR4TH_SYMBOL STREAM* +stream_new(void){ + Arena *arena = arena_alloc(); + STREAM *stream = push_array(arena, STREAM, 1); + stream->arena = arena; + stream->clear_pos = arena_current_pos(arena); + return(stream); +} + +MR4TH_SYMBOL void +stream_release(STREAM *stream){ + stream_clear(stream); +} + +MR4TH_SYMBOL void +stream_clear(STREAM *stream){ + Arena *arena = stream->arena; + U64 clear_pos = stream->clear_pos; + arena_pop_to(arena, clear_pos); + MemoryZeroStruct(stream); + stream->arena = arena; + stream->clear_pos = clear_pos; +} + +MR4TH_SYMBOL void +stream_write(STREAM *stream, String8 data){ + U64 data_pos = 0; + + for (;data_pos < data.size;){ + U64 remaining_size = data.size - data_pos; + + // try to get a node with buffer space from the stream + // (don't return a node with no space!) + STREAM_Node *node = 0; + { + if (stream->buffer_cap > 0){ + node = stream->last_node; + } + if (node != 0 && stream->buffer_cap <= node->size){ + node = 0; + } + } + + // if we didn't get a buffer, try the unused node + if (node == 0){ + if (stream->unused_node != 0){ + node = stream->unused_node; + stream->unused_node = 0; + stream->buffer_cap = node->size; + node->size = 0; + SLLQueuePush(stream->first_node, stream->last_node, node); + } + } + + // if we didn't get a buffer, make one now + if (node == 0){ + U64 alloc_size = sizeof(STREAM_Node) + remaining_size; + alloc_size = ClampBot(STREAM_ALLOC_SIZE, alloc_size); + + node = (STREAM_Node*)push_array_no_zero(stream->arena, U8, alloc_size); + SLLQueuePush(stream->first_node, stream->last_node, node); + node->size = 0; + + stream->buffer_cap = alloc_size - sizeof(STREAM_Node); + } + + // get buffer from the node + U8 *buffer = node->data + node->size; + U64 buffer_size = stream->buffer_cap - node->size; + + // calculate amount to copy + U64 copy_amount = ClampTop(remaining_size, buffer_size); + + // copy memory and increment counters + MemoryCopy(buffer, data.str + data_pos, copy_amount); + node->size += copy_amount; + stream->total_size += copy_amount; + data_pos += copy_amount; + } +} + +MR4TH_SYMBOL U8* +stream_allocate(STREAM *stream, U64 size){ + // try to get a node with buffer space + // (don't return a node with no space) + STREAM_Node *node = 0; + { + if (stream->buffer_cap > 0){ + node = stream->last_node; + } + if (node != 0 && stream->buffer_cap <= node->size){ + node = 0; + } + } + + // if there is a node but it's not big enough... + if (node != 0 && stream->buffer_cap - node->size < size){ + U64 remaining_cap = stream->buffer_cap - node->size; + U64 unused_ptr = IntFromPtr(node->data) + node->size; + U64 unused_opl = IntFromPtr(node->data) + stream->buffer_cap; + U64 unused_ptr_aligned = AlignUpPow2(unused_ptr, sizeof(void*)); + if (unused_opl > unused_ptr_aligned && + unused_opl - unused_ptr_aligned >= sizeof(STREAM_Node) + 32){ + STREAM_Node *unused_node = (STREAM_Node*)PtrFromInt(unused_ptr_aligned); + U64 leftover_buffer_size = unused_opl - unused_ptr_aligned - sizeof(STREAM_Node); + unused_node->size = leftover_buffer_size; + SLLStackPush(stream->unused_node, unused_node); + } + node = 0; + } + + // if we don't have a node then setup a new node with sufficient space. + if (node == 0){ + U64 alloc_size = sizeof(STREAM_Node) + size; + alloc_size = ClampBot(STREAM_ALLOC_SIZE, alloc_size); + + node = (STREAM_Node*)push_array_no_zero(stream->arena, U8, alloc_size); + SLLQueuePush(stream->first_node, stream->last_node, node); + node->size = 0; + + stream->buffer_cap = alloc_size - sizeof(STREAM_Node); + } + + // return the buffer + U8 *result = node->data + node->size; + node->size += size; + stream->total_size += size; + return(result); +} + +MR4TH_SYMBOL U64 +stream_total_size(STREAM *stream){ + return(stream->total_size); +} + +MR4TH_SYMBOL STREAM_Handle* +stream_next_chunk(STREAM *stream, STREAM_Handle *handle, String8 *chunk_out){ + STREAM_Node *node = (STREAM_Node*)handle; + if (node == 0){ + node = stream->first_node; + } + else{ + node = node->next; + } + if (node != 0){ + chunk_out->size = node->size; + chunk_out->str = node->data; + } + else{ + chunk_out->size = 0; + chunk_out->str = 0; + } + return((STREAM_Handle*)node); +} + +// stream helpers + +MR4TH_SYMBOL String8 +stream_read(Arena *arena, STREAM *stream){ + String8 result = {0}; + result.str = push_array(arena, U8, stream->total_size); + result.size = stream->total_size; + + U64 pos = 0; + for (STREAM_Node *node = stream->first_node; + node != 0; + node = node->next){ + MemoryCopy(result.str + pos, node->data, node->size); + pos += node->size; + } + return(result); +} + +MR4TH_SYMBOL void +stream_printfv(STREAM *stream, char *fmt, va_list args){ + // in case we need to try a second time + va_list args2; + va_copy(args2, args); + + // try to get a buffer from the stream + STREAM_Node *node = 0; + U8 *buffer = 0; + U64 buffer_size = 0; + if (stream->buffer_cap > 0){ + node = stream->last_node; + buffer = node->data + node->size; + buffer_size = stream->buffer_cap - node->size; + } + + // try to build the string in the current block + U64 actual_size = 0; + if (buffer_size > 0){ + actual_size = m4_vsnprintf((char*)buffer, buffer_size, fmt, args); + } + else{ + actual_size = m4_vsnprintf(0, 0, fmt, args); + } + + // if first try worked, increment block size + if (actual_size <= buffer_size){ + node->size += actual_size; + stream->total_size += actual_size; + } + + // if first try failed, reset and try again with correct size + else{ + U8 *new_buffer = stream_allocate(stream, actual_size + 1); + U64 final_size = m4_vsnprintf((char*)new_buffer, actual_size + 1, fmt, args2); + Assert(final_size == actual_size); + } + + // end args2 + va_end(args2); +} + +MR4TH_SYMBOL void +stream_printf(STREAM *stream, char *fmt, ...){ + va_list args; + va_start(args, fmt); + stream_printfv(stream, fmt, args); + va_end(args); +} + + +//////////////////////////////// +// Win32 Implementation: Memory Functions + +#if OS_WINDOWS + +MR4TH_SYMBOL void* +os_memory_reserve(U64 size){ + void *result = VirtualAlloc(0, size, MEM_RESERVE, PAGE_READWRITE); + return(result); +} + +MR4TH_SYMBOL B32 +os_memory_commit(void *ptr, U64 size){ + B32 result = (VirtualAlloc(ptr, size, MEM_COMMIT, PAGE_READWRITE) != 0); + return(result); +} + +MR4TH_SYMBOL void +os_memory_decommit(void *ptr, U64 size){ + VirtualFree(ptr, size, MEM_DECOMMIT); +} + +MR4TH_SYMBOL void +os_memory_release(void *ptr, U64 size){ + VirtualFree(ptr, 0, MEM_RELEASE); +} + + +//////////////////////////////// +// Linux Implementation: Memory Functions + +#elif OS_LINUX + +MR4TH_SYMBOL void* +os_memory_reserve(U64 size){ + void *result = mmap(0, size, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); + if (result == MAP_FAILED){ + result = 0; + } + return(result); +} + +MR4TH_SYMBOL B32 +os_memory_commit(void *ptr, U64 size){ + mprotect(ptr, size, PROT_READ|PROT_WRITE); + return(1); +} + +MR4TH_SYMBOL void +os_memory_decommit(void *ptr, U64 size){ + madvise(ptr, size, MADV_DONTNEED); + mprotect(ptr, size, PROT_NONE); +} + +MR4TH_SYMBOL void +os_memory_release(void *ptr, U64 size){ + munmap(ptr, size); +} + + +// OS Implementation Missing +#else +# error not implemented on this OS +#endif + + + +//////////////////////////////////////////////// +//////////////////////////////////////////////// +// stb_sprintf.h STB_SPRINTF_IMPLEMENTATION // +//////////////////////////////////////////////// +//////////////////////////////////////////////// + +#define stbsp__uint32 unsigned int +#define stbsp__int32 signed int + +#ifdef _MSC_VER +#define stbsp__uint64 unsigned __int64 +#define stbsp__int64 signed __int64 +#else +#define stbsp__uint64 unsigned long long +#define stbsp__int64 signed long long +#endif +#define stbsp__uint16 unsigned short + +#ifndef stbsp__uintptr +#if defined(__ppc64__) || defined(__powerpc64__) || defined(__aarch64__) || defined(_M_X64) || defined(__x86_64__) || defined(__x86_64) || defined(__s390x__) +#define stbsp__uintptr stbsp__uint64 +#else +#define stbsp__uintptr stbsp__uint32 +#endif +#endif + +#ifndef STB_SPRINTF_MSVC_MODE // used for MSVC2013 and earlier (MSVC2015 matches GCC) +#if defined(_MSC_VER) && (_MSC_VER < 1900) +#define STB_SPRINTF_MSVC_MODE +#endif +#endif + +#ifdef STB_SPRINTF_NOUNALIGNED // define this before inclusion to force stbsp_sprintf to always use aligned accesses +#define STBSP__UNALIGNED(code) +#else +#define STBSP__UNALIGNED(code) code +#endif + +// internal float utility functions +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits); +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value); +#define STBSP__SPECIAL 0x7000 + +static char stbsp__period = '.'; +static char stbsp__comma = ','; +static struct +{ + short temp; // force next field to be 2-byte aligned + char pair[201]; +} stbsp__digitpair = +{ + 0, + "00010203040506070809101112131415161718192021222324" + "25262728293031323334353637383940414243444546474849" + "50515253545556575859606162636465666768697071727374" + "75767778798081828384858687888990919293949596979899" +}; + +STBSP__PUBLICDEF void STB_SPRINTF_DECORATE(set_separators)(char pcomma, char pperiod) +{ + stbsp__period = pperiod; + stbsp__comma = pcomma; +} + +#define STBSP__LEFTJUST 1 +#define STBSP__LEADINGPLUS 2 +#define STBSP__LEADINGSPACE 4 +#define STBSP__LEADING_0X 8 +#define STBSP__LEADINGZERO 16 +#define STBSP__INTMAX 32 +#define STBSP__TRIPLET_COMMA 64 +#define STBSP__NEGATIVE 128 +#define STBSP__MEMORY_SIZES 256 +#define STBSP__HALFWIDTH 512 + +static void stbsp__lead_sign(stbsp__uint32 fl, char *sign) +{ + sign[0] = 0; + if (fl & STBSP__NEGATIVE) { + sign[0] = 1; + sign[1] = '-'; + } else if (fl & STBSP__LEADINGSPACE) { + sign[0] = 1; + sign[1] = ' '; + } else if (fl & STBSP__LEADINGPLUS) { + sign[0] = 1; + sign[1] = '+'; + } +} + +static STBSP__ASAN stbsp__uint32 stbsp__strlen_limited(char const *s, stbsp__uint32 limit) +{ + char const * sn = s; + + // get up to 4-byte alignment + for (;;) { + if (((stbsp__uintptr)sn & 3) == 0) + break; + + if (!limit || *sn == 0) + return (stbsp__uint32)(sn - s); + + ++sn; + --limit; + } + + // scan over 4 bytes at a time to find terminating 0 + // this will intentionally scan up to 3 bytes past the end of buffers, + // but becase it works 4B aligned, it will never cross page boundaries + // (hence the STBSP__ASAN markup; the over-read here is intentional + // and harmless) + while (limit >= 4) { + stbsp__uint32 v = *(stbsp__uint32 *)sn; + // bit hack to find if there's a 0 byte in there + if ((v - 0x01010101) & (~v) & 0x80808080UL) + break; + + sn += 4; + limit -= 4; + } + + // handle the last few characters to find actual size + while (limit && *sn) { + ++sn; + --limit; + } + + return (stbsp__uint32)(sn - s); +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va) +{ + static char hex[] = "0123456789abcdefxp"; + static char hexu[] = "0123456789ABCDEFXP"; + static char spaces[] = + " " + " " + " " + " "; + char *bf; + char const *f; + int tlen = 0; + + bf = buf; + f = fmt; + for (;;) { + stbsp__int32 fw, pr, tz; + stbsp__uint32 fl; + + // macros for the callback buffer stuff +#define stbsp__chk_cb_bufL(bytes) \ +{ \ +int len = (int)(bf - buf); \ +if ((len + (bytes)) >= STB_SPRINTF_MIN) { \ +tlen += len; \ +if (0 == (bf = buf = callback(buf, user, len))) \ +goto done; \ +} \ +} +#define stbsp__chk_cb_buf(bytes) \ +{ \ +if (callback) { \ +stbsp__chk_cb_bufL(bytes); \ +} \ +} +#define stbsp__flush_cb() \ +{ \ +stbsp__chk_cb_bufL(STB_SPRINTF_MIN - 1); \ +} // flush if there is even one byte in the buffer +#define stbsp__cb_buf_clamp(cl, v) \ +cl = v; \ +if (callback) { \ +int lg = STB_SPRINTF_MIN - (int)(bf - buf); \ +if (cl > lg) \ +cl = lg; \ +} + + // fast copy everything up to the next % (or end of string) + for (;;) { + while (((stbsp__uintptr)f) & 3) { + schk1: + if (f[0] == '%') + goto scandd; + schk2: + if (f[0] == 0) + goto endfmt; + stbsp__chk_cb_buf(1); + *bf++ = f[0]; + ++f; + } + for (;;) { + // Check if the next 4 bytes contain %(0x25) or end of string. + // Using the 'hasless' trick: + // https://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord + stbsp__uint32 v, c; + v = *(stbsp__uint32 *)f; + c = (~v) & 0x80808080; + if (((v ^ 0x25252525) - 0x01010101) & c) + goto schk1; + if ((v - 0x01010101) & c) + goto schk2; + if (callback) + if ((STB_SPRINTF_MIN - (int)(bf - buf)) < 4) + goto schk1; +#ifdef STB_SPRINTF_NOUNALIGNED + if(((stbsp__uintptr)bf) & 3) { + bf[0] = f[0]; + bf[1] = f[1]; + bf[2] = f[2]; + bf[3] = f[3]; + } else +#endif + { + *(stbsp__uint32 *)bf = v; + } + bf += 4; + f += 4; + } + } + scandd: + + ++f; + + // ok, we have a percent, read the modifiers first + fw = 0; + pr = -1; + fl = 0; + tz = 0; + + // flags + for (;;) { + switch (f[0]) { + // if we have left justify + case '-': + fl |= STBSP__LEFTJUST; + ++f; + continue; + // if we have leading plus + case '+': + fl |= STBSP__LEADINGPLUS; + ++f; + continue; + // if we have leading space + case ' ': + fl |= STBSP__LEADINGSPACE; + ++f; + continue; + // if we have leading 0x + case '#': + fl |= STBSP__LEADING_0X; + ++f; + continue; + // if we have thousand commas + case '\'': + fl |= STBSP__TRIPLET_COMMA; + ++f; + continue; + // if we have memory sizes + case '$': + fl |= STBSP__MEMORY_SIZES; + ++f; + continue; + // if we have leading zero + case '0': + fl |= STBSP__LEADINGZERO; + ++f; + goto flags_done; + default: goto flags_done; + } + } + flags_done: + + // get the field width + if (f[0] == '*') { + fw = va_arg(va, stbsp__uint32); + ++f; + } else { + while ((f[0] >= '0') && (f[0] <= '9')) { + fw = fw * 10 + f[0] - '0'; + f++; + } + } + // get the precision + if (f[0] == '.') { + ++f; + if (f[0] == '*') { + pr = va_arg(va, stbsp__uint32); + ++f; + } else { + pr = 0; + while ((f[0] >= '0') && (f[0] <= '9')) { + pr = pr * 10 + f[0] - '0'; + f++; + } + } + } + + // handle integer size overrides + switch (f[0]) { + // are we halfwidth? + case 'h': + fl |= STBSP__HALFWIDTH; + ++f; + if (f[0] == 'h') + ++f; // QUARTERWIDTH + break; + // are we 64-bit (unix style) + case 'l': + fl |= ((sizeof(long) == 8) ? STBSP__INTMAX : 0); + ++f; + if (f[0] == 'l') { + fl |= STBSP__INTMAX; + ++f; + } + break; + // are we 64-bit on intmax? (c99) + case 'j': + fl |= (sizeof(size_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit on size_t or ptrdiff_t? (c99) + case 'z': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + case 't': + fl |= (sizeof(ptrdiff_t) == 8) ? STBSP__INTMAX : 0; + ++f; + break; + // are we 64-bit (msft style) + case 'I': + if ((f[1] == '6') && (f[2] == '4')) { + fl |= STBSP__INTMAX; + f += 3; + } else if ((f[1] == '3') && (f[2] == '2')) { + f += 3; + } else { + fl |= ((sizeof(void *) == 8) ? STBSP__INTMAX : 0); + ++f; + } + break; + default: break; + } + + // handle each replacement + switch (f[0]) { +#define STBSP__NUMSZ 512 // big enough for e308 (with commas) or e-307 + char num[STBSP__NUMSZ]; + char lead[8]; + char tail[8]; + char *s; + char const *h; + stbsp__uint32 l, n, cs; + stbsp__uint64 n64; + double fv; + stbsp__int32 dp; + char const *sn; + + // NOTE(allen): MODIFICATION + // %S prints str (parameter: String8 str) + case 'S': + { + String8 str = va_arg(va, String8); + s = (char*)str.str; + l = (pr >= 0 && pr < str.size) ? pr : (U32)str.size; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + + // NOTE(allen): MODIFICATION + // %N prints n spaces (parameter: int n) + case 'N': + { + // TODO(allen): there's probably a better way to set this + // up so that it doesn't rely on the buffer of spaces - + // perhaps a way to apply the space filling in the left justify path? + l = va_arg(va, int); + l = (sizeof(spaces) - 1 < l) ? (sizeof(spaces) - 1) : l; + l = (pr >= 0 && pr < l) ? pr : l; + s = spaces; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + + case 's': + { + // get the string + s = va_arg(va, char *); + if (s == 0) + s = (char *)"null"; + // get the length, limited to desired precision + // always limit to ~0u chars since our counts are 32b + l = stbsp__strlen_limited(s, (pr >= 0) ? pr : ~0u); + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + // copy the string in + goto scopy; + } + + case 'c': // char + { + // get the character + s = num + STBSP__NUMSZ - 1; + *s = (char)va_arg(va, int); + l = 1; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + + case 'n': // weird write-bytes specifier + { + int *d = va_arg(va, int *); + *d = tlen + (int)(bf - buf); + } break; + + case 'A': // hex float + case 'a': // hex float + { + h = (f[0] == 'A') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_parts((stbsp__int64 *)&n64, &dp, fv)) + fl |= STBSP__NEGATIVE; + + s = num + 64; + + stbsp__lead_sign(fl, lead); + + if (dp == -1023) + dp = (n64) ? -1022 : 0; + else + n64 |= (((stbsp__uint64)1) << 52); + n64 <<= (64 - 56); + if (pr < 15) + n64 += ((((stbsp__uint64)8) << 56) >> (pr * 4)); + // add leading chars + +#ifdef STB_SPRINTF_MSVC_MODE + *s++ = '0'; + *s++ = 'x'; +#else + lead[1 + lead[0]] = '0'; + lead[2 + lead[0]] = 'x'; + lead[0] += 2; +#endif + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + if (pr) + *s++ = stbsp__period; + sn = s; + + // print the bits + n = pr; + if (n > 13) + n = 13; + if (pr > (stbsp__int32)n) + tz = pr - n; + pr = 0; + while (n--) { + *s++ = h[(n64 >> 60) & 15]; + n64 <<= 4; + } + + // print the expo + tail[1] = h[17]; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; + n = (dp >= 1000) ? 6 : ((dp >= 100) ? 5 : ((dp >= 10) ? 4 : 3)); + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + + dp = (int)(s - sn); + l = (int)(s - (num + 64)); + s = num + 64; + cs = 1 + (3 << 24); + goto scopy; + } + + case 'G': // float + case 'g': // float + { + h = (f[0] == 'G') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; + else if (pr == 0) + pr = 1; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, (pr - 1) | 0x80000000)) + fl |= STBSP__NEGATIVE; + + // clamp the precision and delete extra zeros after clamp + n = pr; + if (l > (stbsp__uint32)pr) + l = pr; + while ((l > 1) && (pr) && (sn[l - 1] == '0')) { + --pr; + --l; + } + + // should we use %e + if ((dp <= -4) || (dp > (stbsp__int32)n)) { + if (pr > (stbsp__int32)l) + pr = l - 1; + else if (pr) + --pr; // when using %e, there is one digit before the decimal + goto doexpfromg; + } + // this is the insane action to get the pr to match %g semantics for %f + if (dp > 0) { + pr = (dp < (stbsp__int32)l) ? l - dp : 0; + } else { + pr = -dp + ((pr > (stbsp__int32)l) ? (stbsp__int32) l : pr); + } + goto dofloatfromg; + } + + case 'E': // float + case 'e': // float + { + h = (f[0] == 'E') ? hexu : hex; + fv = va_arg(va, double); + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr | 0x80000000)) + fl |= STBSP__NEGATIVE; + goto doexpfromg; + } + + doexpfromg: + { + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + // handle leading chars + *s++ = sn[0]; + + if (pr) + *s++ = stbsp__period; + + // handle after decimal + if ((l - 1) > (stbsp__uint32)pr) + l = pr + 1; + for (n = 1; n < l; n++) + *s++ = sn[n]; + // trailing zeros + tz = pr - (l - 1); + pr = 0; + // dump expo + tail[1] = h[0xe]; + dp -= 1; + if (dp < 0) { + tail[2] = '-'; + dp = -dp; + } else + tail[2] = '+'; +#ifdef STB_SPRINTF_MSVC_MODE + n = 5; +#else + n = (dp >= 100) ? 5 : 4; +#endif + tail[0] = (char)n; + for (;;) { + tail[n] = '0' + dp % 10; + if (n <= 3) + break; + --n; + dp /= 10; + } + cs = 1 + (3 << 24); // how many tens + goto flt_lead; + } + + case 'f': // float + { + fv = va_arg(va, double); + goto doafloat; + } + + doafloat: + { + // do kilos + if (fl & STBSP__MEMORY_SIZES) { + double divisor = 1024.f; + while (fl < 0x4000000) { + if ((fv < divisor) && (fv > -divisor)) + break; + fv /= divisor; + fl += 0x1000000; + } + } + if (pr == -1) + pr = 6; // default is 6 + // read the double into a string + if (stbsp__real_to_str(&sn, &l, num, &dp, fv, pr)) + fl |= STBSP__NEGATIVE; + } + + dofloatfromg: + { + tail[0] = 0; + stbsp__lead_sign(fl, lead); + if (dp == STBSP__SPECIAL) { + s = (char *)sn; + cs = 0; + pr = 0; + goto scopy; + } + s = num + 64; + + // handle the three decimal varieties + if (dp <= 0) { + stbsp__int32 i; + // handle 0.000*000xxxx + *s++ = '0'; + if (pr) + *s++ = stbsp__period; + n = -dp; + if ((stbsp__int32)n > pr) + n = pr; + i = n; + while (i) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + i -= 4; + } + while (i) { + *s++ = '0'; + --i; + } + if ((stbsp__int32)(l + n) > pr) + l = pr - n; + i = l; + while (i) { + *s++ = *sn++; + --i; + } + tz = pr - (n + l); + cs = 1 + (3 << 24); // how many tens did we write (for commas below) + } else { + cs = (fl & STBSP__TRIPLET_COMMA) ? ((600 - (stbsp__uint32)dp) % 3) : 0; + if ((stbsp__uint32)dp >= l) { + // handle xxxx000*000.0 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= l) + break; + } + } + if (n < (stbsp__uint32)dp) { + n = dp - n; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (n) { + if ((((stbsp__uintptr)s) & 3) == 0) + break; + *s++ = '0'; + --n; + } + while (n >= 4) { + *(stbsp__uint32 *)s = 0x30303030; + s += 4; + n -= 4; + } + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = '0'; + --n; + } + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) { + *s++ = stbsp__period; + tz = pr; + } + } else { + // handle xxxxx.xxxx000*000 + n = 0; + for (;;) { + if ((fl & STBSP__TRIPLET_COMMA) && (++cs == 4)) { + cs = 0; + *s++ = stbsp__comma; + } else { + *s++ = sn[n]; + ++n; + if (n >= (stbsp__uint32)dp) + break; + } + } + cs = (int)(s - (num + 64)) + (3 << 24); // cs is how many tens + if (pr) + *s++ = stbsp__period; + if ((l - dp) > (stbsp__uint32)pr) + l = pr + dp; + while (n < l) { + *s++ = sn[n]; + ++n; + } + tz = pr - (l - dp); + } + } + pr = 0; + + // handle k,m,g,t + if (fl & STBSP__MEMORY_SIZES) { + tail[0] = 0; + { + char idx = 1; + tail[idx] = ' '; + idx++; + tail[idx] = " KMGT"[fl >> 24]; + idx++; + tail[idx] = 'b'; + tail[0] = idx; + } + } + goto flt_lead; + } + + flt_lead: + { + // get the length that we copied + l = (stbsp__uint32)(s - (num + 64)); + s = num + 64; + goto scopy; + } + + case 'B': // upper binary + case 'b': // lower binary + { + h = (f[0] == 'B') ? hexu : hex; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[0xb]; + } + l = (8 << 4) | (1 << 8); + goto radixnum; + } + + case 'o': // octal + { + h = hexu; + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 1; + lead[1] = '0'; + } + l = (3 << 4) | (3 << 8); + goto radixnum; + } + + case 'p': // pointer + { + fl |= (sizeof(void *) == 8) ? STBSP__INTMAX : 0; + pr = sizeof(void *) * 2; + fl &= ~STBSP__LEADINGZERO; // 'p' only prints the pointer with zeros + // fall through - to X + } + + case 'X': // upper hex + case 'x': // lower hex + { + h = (f[0] == 'X') ? hexu : hex; + l = (4 << 4) | (4 << 8); + lead[0] = 0; + if (fl & STBSP__LEADING_0X) { + lead[0] = 2; + lead[1] = '0'; + lead[2] = h[16]; + } + goto radixnum; + } + + radixnum: + { + // get the number + if (fl & STBSP__INTMAX) + n64 = va_arg(va, stbsp__uint64); + else + n64 = va_arg(va, stbsp__uint32); + + s = num + STBSP__NUMSZ; + dp = 0; + // clear tail, and clear leading if value is zero + tail[0] = 0; + if (n64 == 0) { + lead[0] = 0; + if (pr == 0) { + l = 0; + cs = 0; + goto scopy; + } + } + // convert to string + for (;;) { + *--s = h[n64 & ((1 << (l >> 8)) - 1)]; + n64 >>= (l >> 8); + if (!((n64) || ((stbsp__int32)((num + STBSP__NUMSZ) - s) < pr))) + break; + if (fl & STBSP__TRIPLET_COMMA) { + ++l; + if ((l & 15) == ((l >> 4) & 15)) { + l &= ~15; + *--s = stbsp__comma; + } + } + }; + // get the tens and the comma pos + cs = (stbsp__uint32)((num + STBSP__NUMSZ) - s) + ((((l >> 4) & 15)) << 24); + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + // copy it + goto scopy; + } + + case 'u': // unsigned + case 'i': + case 'd': // integer + { + // get the integer and abs it + if (fl & STBSP__INTMAX) { + stbsp__int64 i64 = va_arg(va, stbsp__int64); + n64 = (stbsp__uint64)i64; + if ((f[0] != 'u') && (i64 < 0)) { + n64 = (stbsp__uint64)-i64; + fl |= STBSP__NEGATIVE; + } + } else { + stbsp__int32 i = va_arg(va, stbsp__int32); + n64 = (stbsp__uint32)i; + if ((f[0] != 'u') && (i < 0)) { + n64 = (stbsp__uint32)-i; + fl |= STBSP__NEGATIVE; + } + } + + if (fl & STBSP__MEMORY_SIZES) { + if (n64 < 1024) + pr = 0; + else if (pr == -1) + pr = 1; + fv = (double)(stbsp__int64)n64; + goto doafloat; + } + + // convert to string + s = num + STBSP__NUMSZ; + l = 0; + + for (;;) { + // do in 32-bit chunks (avoid lots of 64-bit divides even with constant denominators) + char *o = s - 8; + if (n64 >= 100000000) { + n = (stbsp__uint32)(n64 % 100000000); + n64 /= 100000000; + } else { + n = (stbsp__uint32)n64; + n64 = 0; + } + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + do { + s -= 2; + *(stbsp__uint16 *)s = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + } while (n); + } + while (n) { + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = (char)(n % 10) + '0'; + n /= 10; + } + } + if (n64 == 0) { + if ((s[0] == '0') && (s != (num + STBSP__NUMSZ))) + ++s; + break; + } + while (s != o) + if ((fl & STBSP__TRIPLET_COMMA) && (l++ == 3)) { + l = 0; + *--s = stbsp__comma; + --o; + } else { + *--s = '0'; + } + } + + tail[0] = 0; + stbsp__lead_sign(fl, lead); + + // get the length that we copied + l = (stbsp__uint32)((num + STBSP__NUMSZ) - s); + if (l == 0) { + *--s = '0'; + l = 1; + } + cs = l + (3 << 24); + if (pr < 0) + pr = 0; + goto scopy; + } + + default: // unknown, just copy code + { + s = num + STBSP__NUMSZ - 1; + *s = f[0]; + l = 1; + fw = fl = 0; + lead[0] = 0; + tail[0] = 0; + pr = 0; + dp = 0; + cs = 0; + goto scopy; + } + + scopy: + // get fw=leading/trailing space, pr=leading zeros + if (pr < (stbsp__int32)l) + pr = l; + n = pr + lead[0] + tail[0] + tz; + if (fw < (stbsp__int32)n) + fw = n; + fw -= n; + pr -= l; + + // handle right justify and leading zeros + if ((fl & STBSP__LEFTJUST) == 0) { + if (fl & STBSP__LEADINGZERO) // if leading zeros, everything is in pr + { + pr = (fw > pr) ? fw : pr; + fw = 0; + } else { + fl &= ~STBSP__TRIPLET_COMMA; // if no leading zeros, then no commas + } + } + + // copy the spaces and/or zeros + if (fw + pr) { + stbsp__int32 i; + stbsp__uint32 c; + + // copy leading spaces (or when doing %8.4d stuff) + if ((fl & STBSP__LEFTJUST) == 0) + while (fw > 0) { + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = ' '; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leader + sn = lead + 1; + while (lead[0]) { + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy leading zeros + c = cs >> 24; + cs &= 0xffffff; + cs = (fl & STBSP__TRIPLET_COMMA) ? ((stbsp__uint32)(c - ((pr + cs) % (c + 1)))) : 0; + while (pr > 0) { + stbsp__cb_buf_clamp(i, pr); + pr -= i; + if ((fl & STBSP__TRIPLET_COMMA) == 0) { + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + } + while (i) { + if ((fl & STBSP__TRIPLET_COMMA) && (cs++ == c)) { + cs = 0; + *bf++ = stbsp__comma; + } else + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + } + + // copy leader if there is still one + sn = lead + 1; + while (lead[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, lead[0]); + lead[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy the string + n = l; + while (n) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, n); + n -= i; + STBSP__UNALIGNED(while (i >= 4) { + *(stbsp__uint32 volatile *)bf = *(stbsp__uint32 volatile *)s; + bf += 4; + s += 4; + i -= 4; + }) + while (i) { + *bf++ = *s++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy trailing zeros + while (tz) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tz); + tz -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = '0'; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x30303030; + bf += 4; + i -= 4; + } + while (i) { + *bf++ = '0'; + --i; + } + stbsp__chk_cb_buf(1); + } + + // copy tail if there is one + sn = tail + 1; + while (tail[0]) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, tail[0]); + tail[0] -= (char)i; + while (i) { + *bf++ = *sn++; + --i; + } + stbsp__chk_cb_buf(1); + } + + // handle the left justify + if (fl & STBSP__LEFTJUST) + if (fw > 0) { + while (fw) { + stbsp__int32 i; + stbsp__cb_buf_clamp(i, fw); + fw -= i; + while (i) { + if ((((stbsp__uintptr)bf) & 3) == 0) + break; + *bf++ = ' '; + --i; + } + while (i >= 4) { + *(stbsp__uint32 *)bf = 0x20202020; + bf += 4; + i -= 4; + } + while (i--) + *bf++ = ' '; + stbsp__chk_cb_buf(1); + } + } + break; + } + ++f; + } + endfmt: + + if (!callback) + *bf = 0; + else + stbsp__flush_cb(); + + done: + return tlen + (int)(bf - buf); +} + +// cleanup +#undef STBSP__LEFTJUST +#undef STBSP__LEADINGPLUS +#undef STBSP__LEADINGSPACE +#undef STBSP__LEADING_0X +#undef STBSP__LEADINGZERO +#undef STBSP__INTMAX +#undef STBSP__TRIPLET_COMMA +#undef STBSP__NEGATIVE +#undef STBSP__METRIC_SUFFIX +#undef STBSP__NUMSZ +#undef stbsp__chk_cb_bufL +#undef stbsp__chk_cb_buf +#undef stbsp__flush_cb +#undef stbsp__cb_buf_clamp + +// ============================================================================ +// wrapper functions + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + result = STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); + va_end(va); + return result; +} + +typedef struct stbsp__context { + char *buf; + int count; + int length; + char tmp[STB_SPRINTF_MIN]; +} stbsp__context; + +static char *stbsp__clamp_callback(const char *buf, void *user, int len) +{ + stbsp__context *c = (stbsp__context *)user; + c->length += len; + + if (len > c->count) + len = c->count; + + if (len) { + if (buf != c->buf) { + const char *s, *se; + char *d; + d = c->buf; + s = buf; + se = buf + len; + do { + *d++ = *s++; + } while (s < se); + } + c->buf += len; + c->count -= len; + } + + if (c->count <= 0) + return c->tmp; + return (c->count >= STB_SPRINTF_MIN) ? c->buf : c->tmp; // go direct into buffer if you can +} + +static char * stbsp__count_clamp_callback( const char * buf, void * user, int len ) +{ + stbsp__context * c = (stbsp__context*)user; + (void) sizeof(buf); + + c->length += len; + return c->tmp; // go direct into buffer if you can +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE( vsnprintf )( char * buf, int count, char const * fmt, va_list va ) +{ + stbsp__context c; + + if ( (count == 0) && !buf ) + { + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__count_clamp_callback, &c, c.tmp, fmt, va ); + } + else + { + int l; + + c.buf = buf; + c.count = count; + c.length = 0; + + STB_SPRINTF_DECORATE( vsprintfcb )( stbsp__clamp_callback, &c, stbsp__clamp_callback(0,&c,0), fmt, va ); + + // zero-terminate + l = (int)( c.buf - buf ); + if ( l >= count ) // should never be greater, only equal (or less) than count + l = count - 1; + buf[l] = 0; + } + + return c.length; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) +{ + int result; + va_list va; + va_start(va, fmt); + + result = STB_SPRINTF_DECORATE(vsnprintf)(buf, count, fmt, va); + va_end(va); + + return result; +} + +STBSP__PUBLICDEF int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va) +{ + return STB_SPRINTF_DECORATE(vsprintfcb)(0, 0, buf, fmt, va); +} + +// ======================================================================= +// low level float utility functions + +// copies d to bits w/ strict aliasing (this compiles to nothing on /Ox) +#define STBSP__COPYFP(dest, src) \ +{ \ +int cn; \ +for (cn = 0; cn < 8; cn++) \ +((char *)&dest)[cn] = ((char *)&src)[cn]; \ +} + +// get float info +static stbsp__int32 stbsp__real_to_parts(stbsp__int64 *bits, stbsp__int32 *expo, double value) +{ + double d; + stbsp__int64 b = 0; + + // load value and round at the frac_digits + d = value; + + STBSP__COPYFP(b, d); + + *bits = b & ((((stbsp__uint64)1) << 52) - 1); + *expo = (stbsp__int32)(((b >> 52) & 2047) - 1023); + + return (stbsp__int32)((stbsp__uint64) b >> 63); +} + +static double const stbsp__bot[23] = { + 1e+000, 1e+001, 1e+002, 1e+003, 1e+004, 1e+005, 1e+006, 1e+007, 1e+008, 1e+009, 1e+010, 1e+011, + 1e+012, 1e+013, 1e+014, 1e+015, 1e+016, 1e+017, 1e+018, 1e+019, 1e+020, 1e+021, 1e+022 +}; +static double const stbsp__negbot[22] = { + 1e-001, 1e-002, 1e-003, 1e-004, 1e-005, 1e-006, 1e-007, 1e-008, 1e-009, 1e-010, 1e-011, + 1e-012, 1e-013, 1e-014, 1e-015, 1e-016, 1e-017, 1e-018, 1e-019, 1e-020, 1e-021, 1e-022 +}; +static double const stbsp__negboterr[22] = { + -5.551115123125783e-018, -2.0816681711721684e-019, -2.0816681711721686e-020, -4.7921736023859299e-021, -8.1803053914031305e-022, 4.5251888174113741e-023, + 4.5251888174113739e-024, -2.0922560830128471e-025, -6.2281591457779853e-026, -3.6432197315497743e-027, 6.0503030718060191e-028, 2.0113352370744385e-029, + -3.0373745563400371e-030, 1.1806906454401013e-032, -7.7705399876661076e-032, 2.0902213275965398e-033, -7.1542424054621921e-034, -7.1542424054621926e-035, + 2.4754073164739869e-036, 5.4846728545790429e-037, 9.2462547772103625e-038, -4.8596774326570872e-039 +}; +static double const stbsp__top[13] = { + 1e+023, 1e+046, 1e+069, 1e+092, 1e+115, 1e+138, 1e+161, 1e+184, 1e+207, 1e+230, 1e+253, 1e+276, 1e+299 +}; +static double const stbsp__negtop[13] = { + 1e-023, 1e-046, 1e-069, 1e-092, 1e-115, 1e-138, 1e-161, 1e-184, 1e-207, 1e-230, 1e-253, 1e-276, 1e-299 +}; +static double const stbsp__toperr[13] = { + 8388608, + 6.8601809640529717e+028, + -7.253143638152921e+052, + -4.3377296974619174e+075, + -1.5559416129466825e+098, + -3.2841562489204913e+121, + -3.7745893248228135e+144, + -1.7356668416969134e+167, + -3.8893577551088374e+190, + -9.9566444326005119e+213, + 6.3641293062232429e+236, + -5.2069140800249813e+259, + -5.2504760255204387e+282 +}; +static double const stbsp__negtoperr[13] = { + 3.9565301985100693e-040, -2.299904345391321e-063, 3.6506201437945798e-086, 1.1875228833981544e-109, + -5.0644902316928607e-132, -6.7156837247865426e-155, -2.812077463003139e-178, -5.7778912386589953e-201, + 7.4997100559334532e-224, -4.6439668915134491e-247, -6.3691100762962136e-270, -9.436808465446358e-293, + 8.0970921678014997e-317 +}; + +#if defined(_MSC_VER) && (_MSC_VER <= 1200) +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000, + 100000000000, + 1000000000000, + 10000000000000, + 100000000000000, + 1000000000000000, + 10000000000000000, + 100000000000000000, + 1000000000000000000, + 10000000000000000000U +}; +#define stbsp__tento19th ((stbsp__uint64)1000000000000000000) +#else +static stbsp__uint64 const stbsp__powten[20] = { + 1, + 10, + 100, + 1000, + 10000, + 100000, + 1000000, + 10000000, + 100000000, + 1000000000, + 10000000000ULL, + 100000000000ULL, + 1000000000000ULL, + 10000000000000ULL, + 100000000000000ULL, + 1000000000000000ULL, + 10000000000000000ULL, + 100000000000000000ULL, + 1000000000000000000ULL, + 10000000000000000000ULL +}; +#define stbsp__tento19th (1000000000000000000ULL) +#endif + +#define stbsp__ddmulthi(oh, ol, xh, yh) \ +{ \ +double ahi = 0, alo, bhi = 0, blo; \ +stbsp__int64 bt; \ +oh = xh * yh; \ +STBSP__COPYFP(bt, xh); \ +bt &= ((~(stbsp__uint64)0) << 27); \ +STBSP__COPYFP(ahi, bt); \ +alo = xh - ahi; \ +STBSP__COPYFP(bt, yh); \ +bt &= ((~(stbsp__uint64)0) << 27); \ +STBSP__COPYFP(bhi, bt); \ +blo = yh - bhi; \ +ol = ((ahi * bhi - oh) + ahi * blo + alo * bhi) + alo * blo; \ +} + +#define stbsp__ddtoS64(ob, xh, xl) \ +{ \ +double ahi = 0, alo, vh, t; \ +ob = (stbsp__int64)xh; \ +vh = (double)ob; \ +ahi = (xh - vh); \ +t = (ahi - xh); \ +alo = (xh - (ahi - t)) - (vh + t); \ +ob += (stbsp__int64)(ahi + alo + xl); \ +} + +#define stbsp__ddrenorm(oh, ol) \ +{ \ +double s; \ +s = oh + ol; \ +ol = ol - (s - oh); \ +oh = s; \ +} + +#define stbsp__ddmultlo(oh, ol, xh, xl, yh, yl) ol = ol + (xh * yl + xl * yh); + +#define stbsp__ddmultlos(oh, ol, xh, yl) ol = ol + (xh * yl); + +static void stbsp__raise_to_power10(double *ohi, double *olo, double d, stbsp__int32 power) // power can be -323 to +350 +{ + double ph, pl; + if ((power >= 0) && (power <= 22)) { + stbsp__ddmulthi(ph, pl, d, stbsp__bot[power]); + } else { + stbsp__int32 e, et, eb; + double p2h, p2l; + + e = power; + if (power < 0) + e = -e; + et = (e * 0x2c9) >> 14; /* %23 */ + if (et > 13) + et = 13; + eb = e - (et * 23); + + ph = d; + pl = 0.0; + if (power < 0) { + if (eb) { + --eb; + stbsp__ddmulthi(ph, pl, d, stbsp__negbot[eb]); + stbsp__ddmultlos(ph, pl, d, stbsp__negboterr[eb]); + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__negtop[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__negtop[et], stbsp__negtoperr[et]); + ph = p2h; + pl = p2l; + } + } else { + if (eb) { + e = eb; + if (eb > 22) + eb = 22; + e -= eb; + stbsp__ddmulthi(ph, pl, d, stbsp__bot[eb]); + if (e) { + stbsp__ddrenorm(ph, pl); + stbsp__ddmulthi(p2h, p2l, ph, stbsp__bot[e]); + stbsp__ddmultlos(p2h, p2l, stbsp__bot[e], pl); + ph = p2h; + pl = p2l; + } + } + if (et) { + stbsp__ddrenorm(ph, pl); + --et; + stbsp__ddmulthi(p2h, p2l, ph, stbsp__top[et]); + stbsp__ddmultlo(p2h, p2l, ph, pl, stbsp__top[et], stbsp__toperr[et]); + ph = p2h; + pl = p2l; + } + } + } + stbsp__ddrenorm(ph, pl); + *ohi = ph; + *olo = pl; +} + +// given a float value, returns the significant bits in bits, and the position of the +// decimal point in decimal_pos. +/-INF and NAN are specified by special values +// returned in the decimal_pos parameter. +// frac_digits is absolute normally, but if you want from first significant digits (got %g and %e), or in 0x80000000 +static stbsp__int32 stbsp__real_to_str(char const **start, stbsp__uint32 *len, char *out, stbsp__int32 *decimal_pos, double value, stbsp__uint32 frac_digits) +{ + double d; + stbsp__int64 bits = 0; + stbsp__int32 expo, e, ng, tens; + + d = value; + STBSP__COPYFP(bits, d); + expo = (stbsp__int32)((bits >> 52) & 2047); + ng = (stbsp__int32)((stbsp__uint64) bits >> 63); + if (ng) + d = -d; + + if (expo == 2047) // is nan or inf? + { + *start = (bits & ((((stbsp__uint64)1) << 52) - 1)) ? "NaN" : "Inf"; + *decimal_pos = STBSP__SPECIAL; + *len = 3; + return ng; + } + + if (expo == 0) // is zero or denormal + { + if (((stbsp__uint64) bits << 1) == 0) // do zero + { + *decimal_pos = 1; + *start = out; + out[0] = '0'; + *len = 1; + return ng; + } + // find the right expo for denormals + { + stbsp__int64 v = ((stbsp__uint64)1) << 51; + while ((bits & v) == 0) { + --expo; + v >>= 1; + } + } + } + + // find the decimal exponent as well as the decimal bits of the value + { + double ph, pl; + + // log10 estimate - very specifically tweaked to hit or undershoot by no more than 1 of log10 of all expos 1..2046 + tens = expo - 1023; + tens = (tens < 0) ? ((tens * 617) / 2048) : (((tens * 1233) / 4096) + 1); + + // move the significant bits into position and stick them into an int + stbsp__raise_to_power10(&ph, &pl, d, 18 - tens); + + // get full as much precision from double-double as possible + stbsp__ddtoS64(bits, ph, pl); + + // check if we undershot + if (((stbsp__uint64)bits) >= stbsp__tento19th) + ++tens; + } + + // now do the rounding in integer land + frac_digits = (frac_digits & 0x80000000) ? ((frac_digits & 0x7ffffff) + 1) : (tens + frac_digits); + if ((frac_digits < 24)) { + stbsp__uint32 dg = 1; + if ((stbsp__uint64)bits >= stbsp__powten[9]) + dg = 10; + while ((stbsp__uint64)bits >= stbsp__powten[dg]) { + ++dg; + if (dg == 20) + goto noround; + } + if (frac_digits < dg) { + stbsp__uint64 r; + // add 0.5 at the right position and round + e = dg - frac_digits; + if ((stbsp__uint32)e >= 24) + goto noround; + r = stbsp__powten[e]; + bits = bits + (r / 2); + if ((stbsp__uint64)bits >= stbsp__powten[dg]) + ++tens; + bits /= r; + } + noround:; + } + + // kill long trailing runs of zeros + if (bits) { + stbsp__uint32 n; + for (;;) { + if (bits <= 0xffffffff) + break; + if (bits % 1000) + goto donez; + bits /= 1000; + } + n = (stbsp__uint32)bits; + while ((n % 1000) == 0) + n /= 1000; + bits = n; + donez:; + } + + // convert to string + out += 64; + e = 0; + for (;;) { + stbsp__uint32 n; + char *o = out - 8; + // do the conversion in chunks of U32s (avoid most 64-bit divides, worth it, constant denomiators be damned) + if (bits >= 100000000) { + n = (stbsp__uint32)(bits % 100000000); + bits /= 100000000; + } else { + n = (stbsp__uint32)bits; + bits = 0; + } + while (n) { + out -= 2; + *(stbsp__uint16 *)out = *(stbsp__uint16 *)&stbsp__digitpair.pair[(n % 100) * 2]; + n /= 100; + e += 2; + } + if (bits == 0) { + if ((e) && (out[0] == '0')) { + ++out; + --e; + } + break; + } + while (out != o) { + *--out = '0'; + ++e; + } + } + + *decimal_pos = tens; + *start = out; + *len = e; + return ng; +} + +#undef stbsp__ddmulthi +#undef stbsp__ddrenorm +#undef stbsp__ddmultlo +#undef stbsp__ddmultlos +#undef STBSP__SPECIAL +#undef STBSP__COPYFP + +// clean up +#undef stbsp__uint16 +#undef stbsp__uint32 +#undef stbsp__int32 +#undef stbsp__uint64 +#undef stbsp__int64 +#undef STBSP__UNALIGNED diff --git a/base.h b/base.h new file mode 100644 index 0000000..b67ae26 --- /dev/null +++ b/base.h @@ -0,0 +1,634 @@ +#ifndef BASE_H +#define BASE_H + +#if !defined(MR4TH_SYMBOL) +# define MR4TH_SYMBOL static +#endif + +// untangle compiler, os, & architecture +#if defined(__clang__) +# define COMPILER_CLANG 1 + +# if defined(_WIN32) +# define OS_WINDOWS 1 +# elif defined(__gnu_linux__) +# define OS_LINUX 1 +# elif defined(__APPLE__) && defined(__MACH__) +# define OS_MAC 1 +# else +# error missing OS detection +# endif + +# if defined(__amd64__) +# define ARCH_X64 1 +// TODO(allen): verify this works on clang +# elif defined(__i386__) +# define ARCH_X86 1 +// TODO(allen): verify this works on clang +# elif defined(__arm__) +# define ARCH_ARM 1 +// TODO(allen): verify this works on clang +# elif defined(__aarch64__) +# define ARCH_ARM64 1 +# else +# error missing ARCH detection +# endif + +#elif defined(_MSC_VER) +# define COMPILER_CL 1 + +# if defined(_WIN32) +# define OS_WINDOWS 1 +# else +# error missing OS detection +# endif + +# if defined(_M_AMD64) +# define ARCH_X64 1 +# elif defined(_M_I86) +# define ARCH_X86 1 +# elif defined(_M_ARM) +# define ARCH_ARM 1 +// TODO(allen): ARM64? +# else +# error missing ARCH detection +# endif + +#elif defined(__GNUC__) +# define COMPILER_GCC 1 + +# if defined(_WIN32) +# define OS_WINDOWS 1 +# elif defined(__gnu_linux__) +# define OS_LINUX 1 +# elif defined(__APPLE__) && defined(__MACH__) +# define OS_MAC 1 +# else +# error missing OS detection +# endif + +# if defined(__amd64__) +# define ARCH_X64 1 +# elif defined(__i386__) +# define ARCH_X86 1 +# elif defined(__arm__) +# define ARCH_ARM 1 +# elif defined(__aarch64__) +# define ARCH_ARM64 1 +# else +# error missing ARCH detection +# endif + +#else +# error no context cracking for this compiler +#endif + +#if !defined(COMPILER_CL) +# define COMPILER_CL 0 +#endif +#if !defined(COMPILER_CLANG) +# define COMPILER_CLANG 0 +#endif +#if !defined(COMPILER_GCC) +# define COMPILER_GCC 0 +#endif +#if !defined(OS_WINDOWS) +# define OS_WINDOWS 0 +#endif +#if !defined(OS_LINUX) +# define OS_LINUX 0 +#endif +#if !defined(OS_MAC) +# define OS_MAC 0 +#endif +#if !defined(ARCH_X64) +# define ARCH_X64 0 +#endif +#if !defined(ARCH_X86) +# define ARCH_X86 0 +#endif +#if !defined(ARCH_ARM) +# define ARCH_ARM 0 +#endif +#if !defined(ARCH_ARM64) +# define ARCH_ARM64 0 +#endif + +#if COMPILER_CL +# define MR4TH_THREADVAR __declspec(thread) +#elif COMPILER_CLANG || COMPILER_GCC +# define MR4TH_THREADVAR __thread +#else +# error MR4TH_THREADVAR not defined for this compiler +#endif + +// setup pointer size macro +#if ARCH_X64 || ARCH_ARM64 +# define ARCH_ADDRSIZE 64 +#else +# define ARCH_ADDRSIZE 32 +#endif + +//////////////////////////////// +// Macros: Assert + +#if !defined(AssertBreak) +# define AssertBreak() (*(volatile int*)0 = 0) +#endif + +#define Assert(c) do{ if (!(c)){ AssertBreak(); } }while(0) + +#define StaticAssert(c,l) typedef U8 Glue(l,__LINE__) [(c)?1:-1] + +//////////////////////////////// +// Macros: Memory + +#include + +#define MemoryZero(p,z) memset((p), 0, (z)) +#define MemoryZeroStruct(p) MemoryZero((p), sizeof(*(p))) +#define MemoryZeroArray(p) MemoryZero((p), sizeof(p)) +#define MemoryZeroTyped(p,c) MemoryZero((p), sizeof(*(p))*(c)) + +#define MemoryMatch(a,b,z) (memcmp((a),(b),(z)) == 0) + +#define MemoryCopy(d,s,z) memmove((d), (s), (z)) +#define MemoryCopyStruct(d,s) MemoryCopy((d),(s),Min(sizeof(*(d)),sizeof(*(s)))) +#define MemoryCopyArray(d,s) MemoryCopy((d),(s),Min(sizeof(s),sizeof(d))) +#define MemoryCopyTyped(d,s,c) MemoryCopy((d),(s),Min(sizeof(*(d)),sizeof(*(s)))*(c)) + +//////////////////////////////// +// Macros: Linked Lists + +#define DLLPushBack_NPZ(f,l,n,next,prev,nil)\ +(((f) == (nil))?\ +((f)=(l)=(n),(n)->next=(n)->prev=(nil)):\ +((n)->prev=(l),(l)->next=(n),(l)=(n),(n)->next=(nil))) + +#define DLLPushBack(f,l,n) DLLPushBack_NPZ(f,l,n,next,prev,0) +#define DLLPushFront(f,l,n) DLLPushBack_NPZ(l,f,n,prev,next,0) + +#define DLLInsert_NPZ(f,l,p,n,next,prev,nil) \ +(((p) != (l))?\ +((n)->next = (p)->next,\ +(n)->prev = (p),\ +(p)->next->prev = (n),\ +(p)->next = (n))\ +:((n)->next = (nil),\ +(n)->prev = (l),\ +(l)->next = (n),\ +(l) = (n))) + +#define DLLInsert(f,l,p,n) DLLInsert_NPZ(f,l,p,n,next,prev,0) + +#define DLLRemove_NPZ(f,l,n,next,prev,nil)\ +((f)==(n)?\ +((f)==(l)?\ +((f)=(l)=(nil)):\ +((f)=(f)->next,(f)->prev=(nil))):\ +(l)==(n)?\ +((l)=(l)->prev,(l)->next=(nil)):\ +((n)->next->prev=(n)->prev,\ +(n)->prev->next=(n)->next)) + +#define DLLRemove(f,l,n) DLLRemove_NPZ(f,l,n,next,prev,0) + +#define SLLQueuePush_NZ(f,l,n,next,nil) (((f)==(nil)?\ +(f)=(l)=(n):\ +((l)->next=(n),(l)=(n))),\ +(n)->next=(nil)) +#define SLLQueuePush(f,l,n) SLLQueuePush_NZ(f,l,n,next,0) + +#define SLLQueuePushFront_NZ(f,l,n,next,nil) ((f)==(nil)?\ +((f)=(l)=(n),(n)->next=(nil)):\ +((n)->next=(f),(f)=(n))) +#define SLLQueuePushFront(f,l,n) SLLQueuePushFront_NZ(f,l,n,next,0) + +#define SLLQueuePop_NZ(f,l,next,nil) ((f)==(l)?\ +(f)=(l)=(nil):\ +((f)=(f)->next)) +#define SLLQueuePop(f,l) SLLQueuePop_NZ(f,l,next,0) + +#define SLLStackPush_N(f,n,next) ((n)->next=(f),(f)=(n)) +#define SLLStackPush(f,n) SLLStackPush_N(f,n,next) + +#define SLLStackPop_NZ(f,next,nil) ((f)==(nil)?(nil):\ +((f)=(f)->next)) +#define SLLStackPop(f) SLLStackPop_NZ(f,next,0) + + +//////////////////////////////// +// Macros: Common Expressions + +#define ArrayCount(a) (sizeof(a)/sizeof(*(a))) + +#define IntFromPtr(p) (UAddr)(p) +#define PtrFromInt(n) (void*)((UAddr)(n)) +#define PtrDif(a,b) ((U8*)(a) - (U8*)(b)) + +#define AlignUpPow2(x,p) (((x) + (p) - 1)&~((p) - 1)) +#define AlignDownPow2(x,p) ((x)&~((p) - 1)) +#define IsPow2OrZero(x) (((x)&((x)-1)) == 0) + +#define Min(a,b) (((a)<(b))?(a):(b)) +#define Max(a,b) (((a)>(b))?(a):(b)) +#define Clamp(a,x,b) (((x)<(a))?(a):\ +((b)<(x))?(b):(x)) +#define ClampTop(a,b) Min(a,b) +#define ClampBot(a,b) Max(a,b) + +#define KB(x) ((U64)(x) << 10) +#define MB(x) ((U64)(x) << 20) +#define GB(x) ((U64)(x) << 30) +#define TB(x) ((U64)(x) << 40llu) + +//////////////////////////////// +// Types: Basic + +#include +#include + +typedef int8_t S8; +typedef int16_t S16; +typedef int32_t S32; +typedef int64_t S64; +typedef uint8_t U8; +typedef uint16_t U16; +typedef uint32_t U32; +typedef uint64_t U64; +typedef S8 B8; +typedef S16 B16; +typedef S32 B32; +typedef S64 B64; +typedef float F32; +typedef double F64; + +#if ARCH_ADDRSIZE == 32 +typedef U32 UAddr; +typedef S32 SAddr; +#elif ARCH_ADDRSIZE == 64 +typedef U64 UAddr; +typedef S64 SAddr; +#else +# error UAddr and SAddr not defined for this architecture +#endif + +typedef void VoidFunc(void); + +//////////////////////////////// +// Types: Arena + +typedef struct Arena{ + struct Arena *current; + struct Arena *prev; + U64 alignment; + B8 growing; + U8 filler[7]; + U64 base_pos; + U64 chunk_cap; + U64 chunk_pos; + U64 chunk_commit_pos; +} Arena; + +typedef struct ArenaTemp{ + Arena *arena; + U64 pos; +} ArenaTemp; + +//////////////////////////////// +// Types: String + +typedef struct String8{ + U8 *str; + U64 size; +} String8; + +//////////////////////////////// +// Types: Stream + +#include + +typedef void STREAM_Handle; + +typedef struct STREAM_Node{ + struct STREAM_Node *next; + U64 size; + U8 data[0]; +} STREAM_Node; + +#define STREAM_NODE_FROM_DATA(d) (STREAM_Node*)((U8*)(d) - sizeof(STREAM_Node)) + +typedef struct STREAM{ + Arena *arena; + U64 clear_pos; + STREAM_Node *first_node; + STREAM_Node *last_node; + U64 buffer_cap; + U64 total_size; + STREAM_Node *unused_node; +} STREAM; + +#define STREAM_ALLOC_SIZE MB(16) + + +//////////////////////////////// +// Functions: Arenas + +// arena core + +MR4TH_SYMBOL Arena* arena_alloc_reserve(U64 reserve_size, B32 growing); +MR4TH_SYMBOL Arena* arena_alloc(void); +MR4TH_SYMBOL void arena_release(Arena *arena); +MR4TH_SYMBOL void* arena_push_no_zero(Arena *arena, U64 size); +MR4TH_SYMBOL void arena_pop_to(Arena *arena, U64 pos); +MR4TH_SYMBOL U64 arena_current_pos(Arena *arena); + +MR4TH_SYMBOL void* arena_push(Arena *arena, U64 size); +MR4TH_SYMBOL void arena_align(Arena *arena, U64 pow2_align); +MR4TH_SYMBOL void arena_pop_amount(Arena *arena, U64 amount); + +#define push_array(a,T,c) (T*)arena_push((a), sizeof(T)*(c)) +#define push_array_no_zero(a,T,c) (T*)arena_push_no_zero((a), sizeof(T)*(c)) +#define push_array_copy(a,T,s,c) \ +(T*)memory_move(push_array_no_zero(a,T,c), (s), sizeof(T)*(c)) + +// arena temp + +MR4TH_SYMBOL ArenaTemp arena_begin_temp(Arena *arena); +MR4TH_SYMBOL void arena_end_temp(ArenaTemp *temp); + +// scratch + +MR4TH_SYMBOL ArenaTemp arena_get_scratch(Arena **conflict_array, U32 count); +#define arena_release_scratch(temp) arena_end_temp(temp) + +//////////////////////////////// +// Functions: Strings + +MR4TH_SYMBOL String8 str8(U8 *str, U64 size); +MR4TH_SYMBOL String8 str8_range(U8 *first, U8 *opl); +MR4TH_SYMBOL String8 str8_cstring(U8 *cstr); +MR4TH_SYMBOL String8 str8_cstring_capped(U8 *cstr, U8 *opl); + +#define str8_lit(s) str8((U8*)(s), sizeof(s) - 1) +#define str8_struct(s) str8((U8*)(s), sizeof(*(s))) +#define str8_array(s) str8((U8*)(s), sizeof(s)) +#define str8_lit_const(s) { (U8*)(s), sizeof(s) - 1 } + +MR4TH_SYMBOL U32 u32_from_str8_base10(String8 string); + +//////////////////////////////// +// Functions: Stream + +// stream core + +MR4TH_SYMBOL STREAM* stream_new(void); +MR4TH_SYMBOL void stream_release(STREAM *stream); + +MR4TH_SYMBOL void stream_clear(STREAM *stream); +MR4TH_SYMBOL void stream_write(STREAM *stream, String8 data); +MR4TH_SYMBOL U8* stream_allocate(STREAM *stream, U64 size); + +MR4TH_SYMBOL U64 stream_total_size(STREAM *stream); +MR4TH_SYMBOL STREAM_Handle* stream_next_chunk(STREAM *stream, STREAM_Handle *handle, String8 *chunk_out); + +// stream helpers + +MR4TH_SYMBOL String8 stream_read(Arena *arena, STREAM *stream); + +MR4TH_SYMBOL void stream_printfv(STREAM *stream, char *fmt, va_list args); +MR4TH_SYMBOL void stream_printf(STREAM *stream, char *fmt, ...); + +MR4TH_SYMBOL void stream_fprint(FILE *file, STREAM *stream); + + + +//////////////////////////////// +// Implementable Functions: Memory Functions + +MR4TH_SYMBOL void* os_memory_reserve(U64 size); +MR4TH_SYMBOL B32 os_memory_commit(void *ptr, U64 size); +MR4TH_SYMBOL void os_memory_decommit(void *ptr, U64 size); +MR4TH_SYMBOL void os_memory_release(void *ptr, U64 size); + + +#if OS_WINDOWS + +//////////////////////////////// +// Win32: Includes + +#include +#include +#include + + +#elif OS_LINUX + + +//////////////////////////////// +// Linux: Includes + +#include + + +// OS Missing +#else +# error not implemented on this OS +#endif + + + +//////////////////////////////////////////////// +//////////////////////////////////////////////// +/// stb_sprintf.h STB_SPRINTF_H_INCLUDE //// +//////////////////////////////////////////////// +//////////////////////////////////////////////// + +#define STB_SPRINTF_DECORATE(name) m4_##name + +/* +Single file sprintf replacement. + +Originally written by Jeff Roberts at RAD Game Tools - 2015/10/20. +Hereby placed in public domain. + +This is a full sprintf replacement that supports everything that +the C runtime sprintfs support, including float/double, 64-bit integers, +hex floats, field parameters (%*.*d stuff), length reads backs, etc. + +Why would you need this if sprintf already exists? Well, first off, +it's *much* faster (see below). It's also much smaller than the CRT +versions code-space-wise. We've also added some simple improvements +that are super handy (commas in thousands, callbacks at buffer full, +for example). Finally, the format strings for MSVC and GCC differ +for 64-bit integers (among other small things), so this lets you use +the same format strings in cross platform code. + +It uses the standard single file trick of being both the header file +and the source itself. If you just include it normally, you just get +the header file function definitions. To get the code, you include +it from a C or C++ file and define STB_SPRINTF_IMPLEMENTATION first. + +It only uses va_args macros from the C runtime to do it's work. It +does cast doubles to S64s and shifts and divides U64s, which does +drag in CRT code on most platforms. + +It compiles to roughly 8K with float support, and 4K without. +As a comparison, when using MSVC static libs, calling sprintf drags +in 16K. + +API: +==== +int stbsp_sprintf( char * buf, char const * fmt, ... ) +int stbsp_snprintf( char * buf, int count, char const * fmt, ... ) + Convert an arg list into a buffer. stbsp_snprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintf( char * buf, char const * fmt, va_list va ) +int stbsp_vsnprintf( char * buf, int count, char const * fmt, va_list va ) + Convert a va_list arg list into a buffer. stbsp_vsnprintf always returns + a zero-terminated string (unlike regular snprintf). + +int stbsp_vsprintfcb( STBSP_SPRINTFCB * callback, void * user, char * buf, char const * fmt, va_list va ) + typedef char * STBSP_SPRINTFCB( char const * buf, void * user, int len ); + Convert into a buffer, calling back every STB_SPRINTF_MIN chars. + Your callback can then copy the chars out, print them or whatever. + This function is actually the workhorse for everything else. + The buffer you pass in must hold at least STB_SPRINTF_MIN characters. + // you return the next buffer to use or 0 to stop converting + +void stbsp_set_separators( char comma, char period ) + Set the comma and period characters to use. + +FLOATS/DOUBLES: +=============== +This code uses a internal float->ascii conversion method that uses +doubles with error correction (double-doubles, for ~105 bits of +precision). This conversion is round-trip perfect - that is, an atof +of the values output here will give you the bit-exact double back. + +One difference is that our insignificant digits will be different than +with MSVC or GCC (but they don't match each other either). We also +don't attempt to find the minimum length matching float (pre-MSVC15 +doesn't either). + +If you don't need float or doubles at all, define STB_SPRINTF_NOFLOAT +and you'll save 4K of code space. +NOTE(allen): MODIFICATION - I've hard coded that this copy *does* use floats + +64-BIT INTS: +============ +This library also supports 64-bit integers and you can use MSVC style or +GCC style indicators (%I64d or %lld). It supports the C99 specifiers +for size_t and ptr_diff_t (%jd %zd) as well. + +EXTRAS: +======= +Like some GCCs, for integers and floats, you can use a ' (single quote) +specifier and commas will be inserted on the thousands: "%'d" on 12345 +would print 12,345. + +For integers and floats, you can use a "$" specifier and the number +will be converted to float and then divided to get kilo, mega, giga or +tera and then printed, so "%$d" 1000 is "1.0 k", "%$.2d" 2536000 is +"2.53 M", etc. For byte values, use two $:s, like "%$$d" to turn +2536000 to "2.42 Mi". If you prefer JEDEC suffixes to SI ones, use three +$:s: "%$$$d" -> "2.42 M". To remove the space between the number and the +suffix, add "_" specifier: "%_$d" -> "2.53M". + +In addition to octal and hexadecimal conversions, you can print +integers in binary: "%b" for 256 would print 100. + +PERFORMANCE vs MSVC 2008 32-/64-bit (GCC is even slower than MSVC): +=================================================================== +"%d" across all 32-bit ints (4.8x/4.0x faster than 32-/64-bit MSVC) +"%24d" across all 32-bit ints (4.5x/4.2x faster) +"%x" across all 32-bit ints (4.5x/3.8x faster) +"%08x" across all 32-bit ints (4.3x/3.8x faster) +"%f" across e-10 to e+10 floats (7.3x/6.0x faster) +"%e" across e-10 to e+10 floats (8.1x/6.0x faster) +"%g" across e-10 to e+10 floats (10.0x/7.1x faster) +"%f" for values near e-300 (7.9x/6.5x faster) +"%f" for values near e+300 (10.0x/9.1x faster) +"%e" for values near e-300 (10.1x/7.0x faster) +"%e" for values near e+300 (9.2x/6.0x faster) +"%.320f" for values near e-300 (12.6x/11.2x faster) +"%a" for random values (8.6x/4.3x faster) +"%I64d" for 64-bits with 32-bit values (4.8x/3.4x faster) +"%I64d" for 64-bits > 32-bit values (4.9x/5.5x faster) +"%s%s%s" for 64 char strings (7.1x/7.3x faster) +"...512 char string..." ( 35.0x/32.5x faster!) +*/ + +#if defined(__clang__) +#if defined(__has_feature) && defined(__has_attribute) +#if __has_feature(address_sanitizer) +#if __has_attribute(__no_sanitize__) +#define STBSP__ASAN __attribute__((__no_sanitize__("address"))) +#elif __has_attribute(__no_sanitize_address__) +#define STBSP__ASAN __attribute__((__no_sanitize_address__)) +#elif __has_attribute(__no_address_safety_analysis__) +#define STBSP__ASAN __attribute__((__no_address_safety_analysis__)) +#endif +#endif +#endif +#elif defined(__GNUC__) && (__GNUC__ >= 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) +#if defined(__SANITIZE_ADDRESS__) && __SANITIZE_ADDRESS__ +#define STBSP__ASAN __attribute__((__no_sanitize_address__)) +#endif +#endif + +#ifndef STBSP__ASAN +#define STBSP__ASAN +#endif + +#ifdef STB_SPRINTF_STATIC +#define STBSP__PUBLICDEC static +#define STBSP__PUBLICDEF static STBSP__ASAN +#else +#ifdef __cplusplus +#define STBSP__PUBLICDEC extern "C" +#define STBSP__PUBLICDEF extern "C" STBSP__ASAN +#else +#define STBSP__PUBLICDEC extern +#define STBSP__PUBLICDEF STBSP__ASAN +#endif +#endif + +#if defined(__has_attribute) +#if __has_attribute(format) +#define STBSP__ATTRIBUTE_FORMAT(fmt,va) __attribute__((format(printf,fmt,va))) +#endif +#endif + +#ifndef STBSP__ATTRIBUTE_FORMAT +#define STBSP__ATTRIBUTE_FORMAT(fmt,va) +#endif + +#ifdef _MSC_VER +#define STBSP__NOTUSED(v) (void)(v) +#else +#define STBSP__NOTUSED(v) (void)sizeof(v) +#endif + +#include // for va_arg(), va_list() +#include // size_t, ptrdiff_t + +#ifndef STB_SPRINTF_MIN +#define STB_SPRINTF_MIN 512 // how many characters per callback +#endif +typedef char *STBSP_SPRINTFCB(const char *buf, void *user, int len); + +#ifndef STB_SPRINTF_DECORATE +#define STB_SPRINTF_DECORATE(name) stbsp_##name // define this before including if you want to change the names +#endif + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintf)(char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsnprintf)(char *buf, int count, char const *fmt, va_list va); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char *buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3); +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(snprintf)(char *buf, int count, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(3,4); + +STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(vsprintfcb)(STBSP_SPRINTFCB *callback, void *user, char *buf, char const *fmt, va_list va); +STBSP__PUBLICDEC void STB_SPRINTF_DECORATE(set_separators)(char comma, char period); + +#endif //BASE_H diff --git a/build.bat b/build.bat new file mode 100644 index 0000000..02eb928 --- /dev/null +++ b/build.bat @@ -0,0 +1,10 @@ +@echo off + +set src=%cd% +set opts=-nologo -Zi -Fetest + +if not exist "build" mkdir build + +pushd build +cl %opts% %src%\test.c +popd diff --git a/build.sh b/build.sh new file mode 100644 index 0000000..b7cf6a0 --- /dev/null +++ b/build.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +src=$PWD +opts=-Wno-switch + +mkdir -p "build" + +cd build +clang $opts $src/test.c --output test +cd .. + + diff --git a/test.c b/test.c new file mode 100644 index 0000000..fb262d1 --- /dev/null +++ b/test.c @@ -0,0 +1,25 @@ +//#define BLANK_MODE "aritynode.blank.c" + + + +#include "base.h" +#include "aritynode.h" +#include "base.c" +#include "aritynode.test.c" + +#ifndef BLANK_MODE +# include "aritynode.c" +#endif + +#ifdef BLANK_MODE +# include BLANK_MODE +#endif + +#include + +int +main(int argc, char **argv){ + ds_aritynode__test(); + fprintf(stdout, "Completed tests without problem\n"); + return(0); +}