From 30740ca4131d1f574718262451b4410207dc8d4e Mon Sep 17 00:00:00 2001 From: Mitya Selivanov Date: Sun, 14 Jul 2024 21:12:37 +0200 Subject: Reworking the build system --- kit/_lib.c | 17 + kit/allocator.c | 199 ++++++++ kit/allocator.h | 50 +++ kit/array_ref.c | 41 ++ kit/array_ref.h | 57 +++ kit/astar.h | 400 +++++++++++++++++ kit/async_function.h | 241 ++++++++++ kit/atomic.h | 219 +++++++++ kit/atomic.win32.c | 234 ++++++++++ kit/bigint.h | 597 ++++++++++++++++++++++++ kit/dynamic_array.c | 81 ++++ kit/dynamic_array.h | 126 ++++++ kit/file.c | 691 ++++++++++++++++++++++++++++ kit/file.h | 134 ++++++ kit/http1.h | 511 +++++++++++++++++++++ kit/input_buffer.c | 360 +++++++++++++++ kit/input_buffer.h | 66 +++ kit/input_stream.c | 103 +++++ kit/input_stream.h | 41 ++ kit/lower_bound.h | 42 ++ kit/math.h | 780 ++++++++++++++++++++++++++++++++ kit/mersenne_twister_64.c | 66 +++ kit/mersenne_twister_64.h | 35 ++ kit/move_back.h | 49 ++ kit/parse.c | 2 + kit/parse.h | 14 + kit/print.c | 2 + kit/print.h | 47 ++ kit/process.h | 71 +++ kit/process.posix.c | 323 +++++++++++++ kit/process.win32.c | 5 + kit/secure_random.c | 45 ++ kit/secure_random.h | 19 + kit/sha256.c | 151 +++++++ kit/sha256.h | 26 ++ kit/shared_memory.h | 48 ++ kit/shared_memory.posix.c | 124 +++++ kit/shared_memory.win32.c | 91 ++++ kit/shared_mutex.h | 176 ++++++++ kit/sockets.h | 107 +++++ kit/status.h | 43 ++ kit/string_builder.h | 112 +++++ kit/string_ref.h | 137 ++++++ kit/test.h | 1096 +++++++++++++++++++++++++++++++++++++++++++++ kit/threads.h | 129 ++++++ kit/threads.posix.c | 271 +++++++++++ kit/threads.win32.c | 342 ++++++++++++++ kit/time.h | 54 +++ kit/types.h | 36 ++ kit/unival.c | 51 +++ kit/unival.h | 86 ++++ kit/utf8.h | 44 ++ kit/xml.c | 483 ++++++++++++++++++++ kit/xml.h | 64 +++ 54 files changed, 9339 insertions(+) create mode 100644 kit/_lib.c create mode 100644 kit/allocator.c create mode 100644 kit/allocator.h create mode 100644 kit/array_ref.c create mode 100644 kit/array_ref.h create mode 100644 kit/astar.h create mode 100644 kit/async_function.h create mode 100644 kit/atomic.h create mode 100644 kit/atomic.win32.c create mode 100644 kit/bigint.h create mode 100644 kit/dynamic_array.c create mode 100644 kit/dynamic_array.h create mode 100644 kit/file.c create mode 100644 kit/file.h create mode 100644 kit/http1.h create mode 100644 kit/input_buffer.c create mode 100644 kit/input_buffer.h create mode 100644 kit/input_stream.c create mode 100644 kit/input_stream.h create mode 100644 kit/lower_bound.h create mode 100644 kit/math.h create mode 100644 kit/mersenne_twister_64.c create mode 100644 kit/mersenne_twister_64.h create mode 100644 kit/move_back.h create mode 100644 kit/parse.c create mode 100644 kit/parse.h create mode 100644 kit/print.c create mode 100644 kit/print.h create mode 100644 kit/process.h create mode 100644 kit/process.posix.c create mode 100644 kit/process.win32.c create mode 100644 kit/secure_random.c create mode 100644 kit/secure_random.h create mode 100644 kit/sha256.c create mode 100644 kit/sha256.h create mode 100644 kit/shared_memory.h create mode 100644 kit/shared_memory.posix.c create mode 100644 kit/shared_memory.win32.c create mode 100644 kit/shared_mutex.h create mode 100644 kit/sockets.h create mode 100644 kit/status.h create mode 100644 kit/string_builder.h create mode 100644 kit/string_ref.h create mode 100644 kit/test.h create mode 100644 kit/threads.h create mode 100644 kit/threads.posix.c create mode 100644 kit/threads.win32.c create mode 100644 kit/time.h create mode 100644 kit/types.h create mode 100644 kit/unival.c create mode 100644 kit/unival.h create mode 100644 kit/utf8.h create mode 100644 kit/xml.c create mode 100644 kit/xml.h (limited to 'kit') diff --git a/kit/_lib.c b/kit/_lib.c new file mode 100644 index 0000000..0f7cc19 --- /dev/null +++ b/kit/_lib.c @@ -0,0 +1,17 @@ +#include "allocator.c" +#include "array_ref.c" +#include "dynamic_array.c" +#include "file.c" +#include "input_buffer.c" +#include "input_stream.c" +#include "mersenne_twister_64.c" +#include "secure_random.c" +#include "sha256.c" +#include "atomic.win32.c" +#include "threads.posix.c" +#include "threads.win32.c" +#include "process.posix.c" +#include "process.win32.c" +#include "shared_memory.posix.c" +#include "shared_memory.win32.c" +#include "xml.c" diff --git a/kit/allocator.c b/kit/allocator.c new file mode 100644 index 0000000..9fd7bad --- /dev/null +++ b/kit/allocator.c @@ -0,0 +1,199 @@ +#include "allocator.h" + +#include +#include + +#ifndef KIT_DISABLE_SYSTEM_MALLOC +# include +#endif + +static void *kit_allocate_default_(i32 request, i64 size, + i64 previous_size, void *pointer) { +#ifndef KIT_DISABLE_SYSTEM_MALLOC + switch (request) { + case KIT_ALLOCATE: + case KIT_ALLOCATE_ZERO: { + assert(size >= 0); + assert(previous_size == 0); + assert(pointer == NULL); + + if (size <= 0) + return NULL; + + void *p = malloc(size); + + if (p != NULL && request == KIT_ALLOCATE_ZERO) + memset(p, 0, size); + + return p; + } + + case KIT_REALLOCATE: + case KIT_REALLOCATE_ZERO: { + assert(size >= 0); + assert(previous_size != 0 || pointer == NULL); + assert(previous_size == 0 || pointer != NULL); + + if (previous_size == 0 && pointer != NULL) + return NULL; + if (previous_size != 0 && pointer == NULL) + return NULL; + if (size == previous_size) + return pointer; + + u8 *p = NULL; + + if (size > 0) { + p = (u8 *) malloc(size); + + if (p != NULL) { + if (size > 0 && previous_size > 0) + memcpy(p, pointer, + size < previous_size ? size : previous_size); + if (request == KIT_REALLOCATE_ZERO && size > previous_size) + memset(p + previous_size, 0, size - previous_size); + } + } + + free(pointer); + + return p; + } + + case KIT_DEALLOCATE: + assert(size == 0); + assert(pointer != NULL); + if (pointer != NULL) + free(pointer); + return NULL; + + case KIT_DEALLOCATE_ALL: + // Do nothing. + // + return NULL; + + default:; + } +#endif + + assert(0); + return NULL; +} + +static void *kit_allocate_from_buffer_(kit_allocator_t *alloc, + i32 request, i64 size, + i64 previous_size, + void *pointer) { + assert(alloc != NULL); + assert(pointer == NULL || pointer < alloc->data); + + if (alloc == NULL) + return NULL; + + switch (request) { + case KIT_ALLOCATE: + case KIT_ALLOCATE_ZERO: { + assert(size >= 0); + assert(previous_size == 0); + assert(pointer == NULL); + + if (size <= 0) + return NULL; + + if (alloc->size < size) + return NULL; + + void *p = alloc->data; + alloc->bytes += size; + alloc->size -= size; + + if (request == KIT_ALLOCATE_ZERO) + memset(p, 0, size); + + return p; + } + + case KIT_REALLOCATE: + case KIT_REALLOCATE_ZERO: { + assert(size >= 0); + assert(previous_size != 0 || pointer == NULL); + assert(previous_size == 0 || pointer != NULL); + + if (size <= 0) + return NULL; + if (size <= previous_size) + return pointer; + if (previous_size == 0 && pointer != NULL) + return NULL; + if (previous_size != 0 && pointer == NULL) + return NULL; + + if ((u8 *) pointer + previous_size == alloc->data) { + if (alloc->size < size - previous_size) + return NULL; + alloc->bytes += size - previous_size; + alloc->size -= size - previous_size; + return pointer; + } + + if (alloc->size < size) + return NULL; + + u8 *p = alloc->bytes; + alloc->bytes += size; + alloc->size -= size; + + if (previous_size > 0) + memcpy(p, pointer, previous_size); + if (request == KIT_REALLOCATE_ZERO) + memset(p + previous_size, 0, size - previous_size); + + return p; + } + + case KIT_DEALLOCATE: + case KIT_DEALLOCATE_ALL: return NULL; + + default:; + } + + assert(0); + return NULL; +} + +#ifndef KIT_ENABLE_CUSTOM_ALLOC_DISPATCH +void *kit_alloc_dispatch(kit_allocator_t *alloc, i32 request, + i64 size, i64 previous_size, void *pointer) { + if (alloc == NULL) + return kit_allocate_default_(request, size, previous_size, + pointer); + + switch (alloc->type) { + case KIT_ALLOC_TYPE_DEFAULT: + return kit_allocate_default_(request, size, previous_size, + pointer); + + case KIT_ALLOC_TYPE_BUFFER: + return kit_allocate_from_buffer_(alloc, request, + // alignment + ((size + 7) / 8) * 8, + previous_size, pointer); + + default:; + } + + return NULL; +} +#endif + +kit_allocator_t kit_alloc_default(void) { + return (kit_allocator_t) { .type = KIT_ALLOC_TYPE_DEFAULT, + .size = 0, + .data = NULL }; +} + +kit_allocator_t kit_alloc_buffer(i64 size, void *buffer) { + return (kit_allocator_t) { .type = KIT_ALLOC_TYPE_BUFFER, + .size = size, + .data = buffer }; +} diff --git a/kit/allocator.h b/kit/allocator.h new file mode 100644 index 0000000..97e453e --- /dev/null +++ b/kit/allocator.h @@ -0,0 +1,50 @@ +#ifndef KIT_ALLOCATOR_H +#define KIT_ALLOCATOR_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + KIT_ALLOC_TYPE_NONE, + KIT_ALLOC_TYPE_DEFAULT, + KIT_ALLOC_TYPE_BUFFER, +}; + +enum { + KIT_ALLOCATE, + KIT_ALLOCATE_ZERO, + KIT_DEALLOCATE, + KIT_REALLOCATE, + KIT_REALLOCATE_ZERO, + KIT_DEALLOCATE_ALL, +}; + +typedef struct { + i32 type; + i64 size; + union { + u8 *bytes; + void *data; + }; +} kit_allocator_t; + +// Application should implement this function if custom allocator +// dispatch is enabled. +// +// See KIT_ENABLE_CUSTOM_ALLOC_DISPATCH macro. +// +void *kit_alloc_dispatch(kit_allocator_t *alloc, i32 request, + i64 size, i64 previous_size, void *pointer); + +kit_allocator_t kit_alloc_default(void); + +kit_allocator_t kit_alloc_buffer(i64 size, void *buffer); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/array_ref.c b/kit/array_ref.c new file mode 100644 index 0000000..a9df2c4 --- /dev/null +++ b/kit/array_ref.c @@ -0,0 +1,41 @@ +#include "array_ref.h" + +#include + +i8 kit_ar_equal_bytes(i64 left_element_size, i64 left_size, + void *left_data, i64 right_element_size, + i64 right_size, void *right_data) { + i64 i; + if (left_element_size != right_element_size) + return 0; + if (left_size != right_size) + return 0; + for (i = 0; i < left_size; i++) + if (memcmp((u8 *) left_data + i * left_element_size, + (u8 *) right_data + i * left_element_size, + left_element_size) != 0) + return 0; + return 1; +} + +i8 kit_ar_compare(i64 left_element_size, i64 left_size, + void *left_data, i64 right_element_size, + i64 right_size, void *right_data, + kit_ar_compare_fn compare) { + i64 i; + if (left_element_size < right_element_size) + return -1; + if (left_element_size > right_element_size) + return 1; + for (i = 0; i < left_size && i < right_size; i++) { + i8 c = compare((u8 *) left_data + i * left_element_size, + (u8 *) right_data + i * left_element_size); + if (c != 0) + return c; + } + if (left_size < right_size) + return -1; + if (left_size > right_size) + return 1; + return 0; +} diff --git a/kit/array_ref.h b/kit/array_ref.h new file mode 100644 index 0000000..3a7244e --- /dev/null +++ b/kit/array_ref.h @@ -0,0 +1,57 @@ +#ifndef KIT_ARRAY_REF_H +#define KIT_ARRAY_REF_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef i8 (*kit_ar_compare_fn)(void *left, void *right); + +i8 kit_ar_equal_bytes(i64 left_element_size, i64 left_size, + void *left_data, i64 right_element_size, + i64 right_size, void *right_data); + +i8 kit_ar_compare(i64 left_element_size, i64 left_size, + void *left_data, i64 right_element_size, + i64 right_size, void *right_data, + kit_ar_compare_fn compare); + +#define KIT_AR(type_) \ + struct { \ + i64 size; \ + type_ *values; \ + } + +#define KIT_AR_WRAP(name_, element_type_, array_) \ + struct { \ + i64 size; \ + element_type_ *values; \ + } name_ = { .size = (sizeof(array_) / sizeof((array_)[0])), \ + .values = (array_) } + +#define KIT_AR_EQUAL(left_, right_) \ + kit_ar_equal_bytes(sizeof((left_).values[0]), (left_).size, \ + (left_).values, sizeof((right_).values[0]), \ + (right_).size, (right_).values) + +#define KIT_AR_COMPARE(left_, right_, compare_) \ + kit_ar_compare(sizeof((left_).values[0]), (left_).size, \ + (left_).values, sizeof((right_).values[0]), \ + (right_).size, (right_).values, \ + (kit_ar_compare_fn) (compare_)) + +#ifdef __cplusplus +} +#endif + +#define ar_compare_fn kit_ar_compare_fn +#define ar_equal_bytes kit_ar_equal_bytes +#define ar_compare kit_ar_compare +#define AR KIT_AR +#define AR_WRAP KIT_AR_WRAP +#define AR_EQUAL KIT_AR_EQUAL +#define AR_COMPARE KIT_AR_COMPARE + +#endif diff --git a/kit/astar.h b/kit/astar.h new file mode 100644 index 0000000..b76ef67 --- /dev/null +++ b/kit/astar.h @@ -0,0 +1,400 @@ +// ================================================================ +// +// A* graph search algorithm +// +// ================================================================ + +// TODO +// - Nearest: save the nearest node when the search is failed or not +// yet finished. +// - Sight: when two nodes are in direct sight of each other, skip +// nodes between them (Theta*). + +#ifndef KIT_ASTAR_H +#define KIT_ASTAR_H + +#include "types.h" +#include "status.h" + +#include +#include +#include + +enum { + ASTAR_PROGRESS = 0, + ASTAR_SUCCESS, + ASTAR_FAIL, + ASTAR_OUT_OF_MEMORY, + ASTAR_INVALID_ARGUMENT, +}; + +typedef struct { + b8 stop; + b8 skip; + i64 neighbor; + i64 distance; +} Astar_Link; + +typedef struct { + i64 id; + i64 previous; + i64 exact_distance; + i64 estimate; +} Astar_Node; + +typedef struct { + i64 capacity; + i64 size; + Astar_Node *values; +} Astar_Set; + +typedef struct { + Astar_Set open; + Astar_Set closed; + void * user_data; + i64 source; + i64 destination; +} Astar_State; + +#ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +static s32 astar_init( + Astar_State *state, + Astar_Set open, + Astar_Set closed, + void * user_data, + i64 source, + i64 destination +) { + assert( + state != NULL && + open.capacity > 0 && + open.values != NULL && + closed.capacity > 0 && + closed.values != NULL + ); + + if (state == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + memset(state, 0, sizeof *state); + + state->source = source; + state->destination = destination; + state->open = open; + state->closed = closed; + state->user_data = user_data; + + if (state->open.capacity <= 0) + return KIT_ERROR_INVALID_ARGUMENT; + + state->open.values[0] = (Astar_Node) { + .id = source, + .previous = -1, + .exact_distance = 0, + .estimate = 0x7fffffffffffffffll, + }; + + state->open.size = 1; + state->closed.size = 0; + + return KIT_OK; +} + +static s32 astar_path(Astar_State *state, i64 *size, i64 *path) { + assert(state != NULL && size != NULL); + + if (state == NULL || size == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + i64 path_size = *size; + + *size = 1; + + i64 id = state->destination; + + while (id != state->source) { + if (*size > state->closed.size) + return KIT_ERROR_INTERNAL; + + i64 index = 0; + for (; index < state->closed.size; index++) + if (state->closed.values[index].id == id) + break; + if (index == state->closed.size) + return KIT_ERROR_INTERNAL; + + if (path != NULL && *size <= path_size) + path[*size - 1] = id; + + id = state->closed.values[index].previous; + ++*size; + } + + if (path != NULL && *size <= path_size) + path[*size - 1] = id; + + if (path != NULL) { + if (*size < path_size) + path_size = *size; + + for (i64 i = 0; i < path_size / 2; ++i) { + i64 z = path[i]; + path[i] = path[path_size - 1 - i]; + path[path_size - 1 - i] = z; + } + } + + return KIT_OK; +} + +#ifdef __cplusplus +} +#endif + +#ifdef __GNUC__ +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#endif + +// ================================================================ +// +// Algorithm template +// +// ================================================================ + +#ifdef ASTAR_TEMPLATE + +#ifndef ASTAR_SUFFIX +# define ASTAR_SUFFIX +#endif + +#ifndef ASTAR_NEIGHBOR +# define ASTAR_NEIGHBOR(user_data_, node_, index_) \ + (Astar_Link) { \ + .stop = 1, \ + } +#endif + +#ifndef ASTAR_HEURISTIC +# define ASTAR_HEURISTIC(user_data_, node_0_, node_2_) \ + 0x7fffffffffffffffll +#endif + +#ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +#define CAT1_(x, y) x##y +#define CAT2_(x, y) CAT1_(x, y) +#define NAME_(x) CAT2_(x, ASTAR_SUFFIX) + +#ifdef __cplusplus +extern "C" { +#endif + +static s32 NAME_(astar_iteration)(Astar_State *state) { + assert(state != NULL); + + if (state == NULL) + return ASTAR_INVALID_ARGUMENT; + + if (state->open.size == 0) + return ASTAR_FAIL; + + if (state->open.values == NULL || state->closed.values == NULL) + return ASTAR_OUT_OF_MEMORY; + + // Find a node in the open set that is closest to the destination + // + Astar_Node nearest_node; + { + i64 index_in_open = 0; + for (i64 i = 1; i < state->open.size; i++) + if (state->open.values[i].estimate < state->open.values[index_in_open].estimate) + index_in_open = i; + nearest_node = state->open.values[index_in_open]; + if (index_in_open != state->open.size - 1) + state->open.values[index_in_open] = state->open.values[state->open.size - 1]; + --state->open.size; + } + + // Check if we reached the destination + // + if (nearest_node.id == state->destination) { + if (state->closed.size + 1 > state->closed.capacity) { + // Restore the state + state->open.values[state->open.size] = nearest_node; + ++state->open.size; + + return ASTAR_OUT_OF_MEMORY; + } + + // Add the nearest node to the closed set + // + state->closed.values[state->closed.size] = nearest_node; + ++state->closed.size; + + // Finish the search + return ASTAR_SUCCESS; + } + + // Enumerate all neighbors + // + for (i64 k = 0;; ++k) { + // Get a link to the next neighbor node + // + (void) state->user_data; + (void) k; + Astar_Link link = ASTAR_NEIGHBOR(state->user_data, nearest_node.id, k); + + // If there is no more neighbors, break the loop + if (link.stop) + break; + // If there is no link, proceed to the next link + if (link.skip) + continue; + + // Calculate distance estimations + // + (void) state->user_data; + (void) state->destination; + + Astar_Node neighbor_node = { + .id = link.neighbor, + .previous = nearest_node.id, + .exact_distance = nearest_node.exact_distance + link.distance, + .estimate = ASTAR_HEURISTIC(state->user_data, link.neighbor, state->destination), + }; + + // Check if we reached the destination + // + if (neighbor_node.id == state->destination) { + if (state->closed.size + 2 > state->closed.capacity) { + // Restore the state + state->open.values[state->open.size] = nearest_node; + ++state->open.size; + + return ASTAR_OUT_OF_MEMORY; + } + + // Add the nearest node to the closed set + // + state->closed.values[state->closed.size] = nearest_node; + ++state->closed.size; + + // Add the neighbor node to the closed set + // + state->closed.values[state->closed.size] = neighbor_node; + ++state->closed.size; + + // Finish the search + return ASTAR_SUCCESS; + } + + // Check if this node is already in the closed set + // + { + i64 index_in_closed = -1; + for (i64 i = 0; i < state->closed.size; ++i) + if (state->closed.values[i].id == neighbor_node.id) { + index_in_closed = i; + break; + } + if (index_in_closed != -1) { + // Check if this node has a better distance + // + if (neighbor_node.exact_distance < state->closed.values[index_in_closed].exact_distance) + // Replace the node + state->closed.values[index_in_closed] = neighbor_node; + + // Skip this node + continue; + } + } + + // Check if this node is already in the open set + // + { + i64 index_in_open = -1; + for (i64 i = 0; i < state->closed.size; ++i) + if (state->open.values[i].id == neighbor_node.id) { + index_in_open = i; + break; + } + if (index_in_open != -1) { + // Check if this node has a better distance + // + if (neighbor_node.exact_distance < state->open.values[index_in_open].exact_distance) + // Replace the node + state->open.values[index_in_open] = neighbor_node; + + // Skip this node + continue; + } + } + + if (state->open.size + 1 > state->open.capacity) { + // Restore the state + state->open.values[state->open.size] = nearest_node; + ++state->open.size; + + return ASTAR_OUT_OF_MEMORY; + } + + // Add this node to the open set + // + state->open.values[state->open.size] = neighbor_node; + ++state->open.size; + } + + // Check if we can add a node to the closed set + // + if (state->closed.size + 1 > state->closed.capacity) { + // Restore the state + state->open.values[state->open.size - 1] = nearest_node; + ++state->open.size; + + return ASTAR_OUT_OF_MEMORY; + } + + // Add the nearest node to the closed set + // + state->closed.values[state->closed.size] = nearest_node; + ++state->closed.size; + + // Continue the search + return ASTAR_PROGRESS; +} + +#ifdef __cplusplus +} +#endif + +#undef NAME_ +#undef CAT1_ +#undef CAT2_ + +#ifdef __GNUC__ +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#undef ASTAR_TEMPLATE +#endif diff --git a/kit/async_function.h b/kit/async_function.h new file mode 100644 index 0000000..5460fd6 --- /dev/null +++ b/kit/async_function.h @@ -0,0 +1,241 @@ +#ifndef KIT_ASYNC_FUNCTION_H +#define KIT_ASYNC_FUNCTION_H + +#include "types.h" + +#include + +#ifdef __GNUC__ +#define KIT_FALLTHROUGH __attribute__((fallthrough)); +#else +#define KIT_FALLTHROUGH +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + i32 _; +} kit_af_void; + +typedef void (*kit_af_state_machine)(void *self_void_); + +#define KIT_AF_STATE_DATA \ + struct { \ + i32 _index; \ + i32 _id; \ + kit_af_state_machine _state_machine; \ + } + +typedef struct { + KIT_AF_STATE_DATA; +} kit_af_type_void; + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +#endif + +#define KIT_AF_INTERNAL(coro_) (*((kit_af_type_void *) (coro_))) + +#ifdef KIT_ENABLE_CUSTOM_ASYNC_FUNCTION_DISPATCH +// Application should implement this function if custom async +// function dispatch is enabled. +// +// See KIT_ENABLE_CUSTOM_ASYNC_FUNCTION_DISPATCH macro. +// +void kit_async_function_dispatch(void *promise); +#else +static void kit_async_function_dispatch(void *promise) { + // Dynamic dispatch by default. + // + KIT_AF_INTERNAL(promise)._state_machine(promise); +} +#endif + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic pop +#endif + +#define KIT_AF_STATE(ret_type_, name_, ...) \ + struct name_##_coro_state_ { \ + KIT_AF_STATE_DATA; \ + ret_type_ return_value; \ + __VA_ARGS__ \ + } + +#define KIT_AF_DECL(name_) void name_(void *self_void_) + +#define KIT_CORO_IMPL(name_) \ + KIT_AF_DECL(name_) { \ + struct name_##_coro_state_ *self = \ + (struct name_##_coro_state_ *) self_void_; \ + switch (self->_index) { \ + case 0:; + +#define KIT_AF_LINE_() __LINE__ + +#define KIT_CORO_END \ + } \ + self->_index = -1; \ + } + +#define KIT_CORO_DECL(ret_type_, name_, ...) \ + KIT_AF_STATE(ret_type_, name_, __VA_ARGS__); \ + KIT_AF_DECL(name_) + +#define KIT_CORO(ret_type_, name_, ...) \ + KIT_AF_STATE(ret_type_, name_, __VA_ARGS__); \ + KIT_CORO_IMPL(name_) + +#define KIT_CORO_DECL_VOID(name_, ...) \ + KIT_CORO_DECL(kit_af_void, name_, __VA_ARGS__) + +#define KIT_CORO_VOID(name_, ...) \ + KIT_CORO(kit_af_void, name_, __VA_ARGS__) + +#define KIT_STATIC_CORO(ret_type_, name_, ...) \ + KIT_AF_STATE(ret_type_, name_, __VA_ARGS__); \ + static KIT_CORO_IMPL(name_) + +#define KIT_STATIC_CORO_VOID(name_, ...) \ + KIT_STATIC_CORO(kit_af_void, name_, __VA_ARGS__) + +#define KIT_AF_EXECUTE(promise_) \ + kit_async_function_dispatch(&(promise_)) + +#define KIT_AF_NEXT(promise_) \ + (kit_async_function_dispatch(&(promise_)), (promise_).return_value) + +#define KIT_AF_YIELD(...) \ + do { \ + self->_index = KIT_AF_LINE_(); \ + self->return_value = __VA_ARGS__; \ + return; \ + case KIT_AF_LINE_():; \ + } while (0) + +#define KIT_AF_YIELD_VOID \ + do { \ + self->_index = KIT_AF_LINE_(); \ + return; \ + case KIT_AF_LINE_():; \ + } while (0) + +#define KIT_AF_RETURN(...) \ + do { \ + self->_index = -1; \ + self->return_value = __VA_ARGS__; \ + return; \ + } while (0) + +#define KIT_AF_RETURN_VOID \ + do { \ + self->_index = -1; \ + return; \ + } while (0) + +#define KIT_AF_AWAIT(promise_) \ + do { \ + KIT_FALLTHROUGH \ + case KIT_AF_LINE_(): \ + if ((promise_)._index != -1) { \ + self->_index = KIT_AF_LINE_(); \ + kit_async_function_dispatch(&(promise_)); \ + } \ + if ((promise_)._index != -1) \ + return; \ + } while (0) + +#define KIT_AF_YIELD_AWAIT(promise_) \ + do { \ + KIT_FALLTHROUGH \ + case KIT_AF_LINE_(): \ + if ((promise_)._index != -1) { \ + self->_index = KIT_AF_LINE_(); \ + kit_async_function_dispatch(&(promise_)); \ + self->return_value = (promise_).return_value; \ + return; \ + } \ + } while (0) + +#define KIT_AF_TYPE(coro_) struct coro_##_coro_state_ + +#define KIT_AF_INITIAL(id_, coro_) \ + ._index = 0, ._id = (id_), ._state_machine = (coro_) + +#define KIT_AF_CREATE(promise_, coro_, ...) \ + KIT_AF_TYPE(coro_) \ + promise_ = { KIT_AF_INITIAL(0, coro_), __VA_ARGS__ } + +#define KIT_AF_CREATE_ID(promise_, id_, ...) \ + KIT_AF_TYPE(coro_) \ + promise_ = { KIT_AF_INITIAL(id_, NULL), __VA_ARGS__ } + +#define KIT_AF_INIT(promise_, coro_, ...) \ + do { \ + KIT_AF_CREATE(kit_af_temp_, coro_, __VA_ARGS__); \ + memcpy(&(promise_), &kit_af_temp_, sizeof kit_af_temp_); \ + } while (0) + +#define KIT_AF_INIT_ID(promise_, id_, ...) \ + do { \ + KIT_AF_CREATE_ID(kit_af_temp_, id_, __VA_ARGS__); \ + memcpy(&(promise_), &kit_af_temp_, sizeof kit_af_temp_); \ + } while (0) + +#define KIT_AF_FINISHED(promise_) ((promise_)._index == -1) + +#define KIT_AF_FINISHED_N(return_, promises_, size_) \ + do { \ + i32 kit_af_index_; \ + (return_) = 1; \ + for (kit_af_index_ = 0; kit_af_index_ < (size_); \ + kit_af_index_++) \ + if (!KIT_AF_FINISHED((promises_)[kit_af_index_])) { \ + (return_) = 0; \ + break; \ + } \ + } while (0) + +#define KIT_AF_FINISHED_ALL(return_, promises_) \ + KIT_AF_FINISHED_N((return_), (promises_), \ + sizeof(promises_) / sizeof((promises_)[0])) + +#ifdef __cplusplus +} +#endif + +#define af_void kit_af_void +#define af_state_machine kit_af_state_machine +#define af_type_void kit_af_type_void +#define AF_STATE_DATA KIT_AF_STATE_DATA +#define AF_STATE KIT_AF_STATE +#define AF_DECL KIT_AF_DECL +#define CORO_IMPL KIT_CORO_IMPL +#define CORO_END KIT_CORO_END +#define CORO_DECL KIT_CORO_DECL +#define CORO KIT_CORO +#define CORO_DECL_VOID KIT_CORO_DECL_VOID +#define STATIC_CORO KIT_STATIC_CORO +#define STATIC_CORO_VOID KIT_STATIC_CORO_VOID +#define CORO_VOID KIT_CORO_VOID +#define AF_EXECUTE KIT_AF_EXECUTE +#define AF_NEXT KIT_AF_NEXT +#define AF_YIELD KIT_AF_YIELD +#define AF_YIELD_VOID KIT_AF_YIELD_VOID +#define AF_RETURN KIT_AF_RETURN +#define AF_RETURN_VOID KIT_AF_RETURN_VOID +#define AF_AWAIT KIT_AF_AWAIT +#define AF_YIELD_AWAIT KIT_AF_YIELD_AWAIT +#define AF_TYPE KIT_AF_TYPE +#define AF_INITIAL KIT_AF_INITIAL +#define AF_CREATE KIT_AF_CREATE +#define AF_INIT KIT_AF_INIT +#define AF_FINISHED KIT_AF_FINISHED +#define AF_FINISHED_N KIT_AF_FINISHED_N +#define AF_FINISHED_ALL KIT_AF_FINISHED_ALL + +#endif diff --git a/kit/atomic.h b/kit/atomic.h new file mode 100644 index 0000000..8ec7bad --- /dev/null +++ b/kit/atomic.h @@ -0,0 +1,219 @@ +#ifndef KIT_ATOMIC_H +#define KIT_ATOMIC_H + +#include "types.h" + +#ifndef _MSC_VER +# include +#else +# include + +# ifdef __cplusplus +extern "C" { +# endif + +# define _Atomic volatile + +enum { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst +}; + +void kit_atomic_store_explicit_8(u8 volatile *var, u8 value, + i32 memory_order); + +void kit_atomic_store_explicit_16(u16 volatile *var, u16 value, + i32 memory_order); + +void kit_atomic_store_explicit_32(u32 volatile *var, u32 value, + i32 memory_order); + +void kit_atomic_store_explicit_64(u64 volatile *var, u64 value, + i32 memory_order); + +u8 kit_atomic_load_explicit_8(u8 volatile *var, i32 memory_order); + +u16 kit_atomic_load_explicit_16(u16 volatile *var, i32 memory_order); + +u32 kit_atomic_load_explicit_32(u32 volatile *var, i32 memory_order); + +u64 kit_atomic_load_explicit_64(u64 volatile *var, i32 memory_order); + +u8 kit_atomic_exchange_explicit_8(u8 volatile *var, u8 value, + i32 memory_order); + +u16 kit_atomic_exchange_explicit_16(u16 volatile *var, u16 value, + i32 memory_order); + +u32 kit_atomic_exchange_explicit_32(u32 volatile *var, u32 value, + i32 memory_order); + +u64 kit_atomic_exchange_explicit_64(u64 volatile *var, u64 value, + i32 memory_order); + +i32 kit_atomic_compare_exchange_explicit_8(u8 volatile *var, + u8 *expected, u8 value, + i32 memory_order_succ_, + i32 memory_order_fail_); + +i32 kit_atomic_compare_exchange_explicit_16(u16 volatile *var, + u16 *expected, u16 value, + i32 memory_order_succ_, + i32 memory_order_fail_); + +i32 kit_atomic_compare_exchange_explicit_32(u32 volatile *var, + u32 *expected, u32 value, + i32 memory_order_succ_, + i32 memory_order_fail_); + +i32 kit_atomic_compare_exchange_explicit_64(u64 volatile *var, + u64 *expected, u64 value, + i32 memory_order_succ_, + i32 memory_order_fail_); + +u8 kit_atomic_fetch_add_explicit_8(u8 volatile *var, u8 value, + i32 memory_order); + +u16 kit_atomic_fetch_add_explicit_16(u16 volatile *var, u16 value, + i32 memory_order); + +u32 kit_atomic_fetch_add_explicit_32(u32 volatile *var, u32 value, + i32 memory_order); + +u64 kit_atomic_fetch_add_explicit_64(u64 volatile *var, u64 value, + i32 memory_order); + +# define atomic_store_explicit(var_, value_, memory_order_) \ + do { \ + assert(sizeof *(var_) == 1 || sizeof *(var_) == 2 || \ + sizeof *(var_) == 4 || sizeof *(var_) == 8); \ + if (sizeof *(var_) == 1) \ + kit_atomic_store_explicit_8((u8 volatile *) (var_), \ + (u8) (value_), (memory_order_)); \ + if (sizeof *(var_) == 2) \ + kit_atomic_store_explicit_16((u16 volatile *) (var_), \ + (u16) (value_), \ + (memory_order_)); \ + if (sizeof *(var_) == 4) \ + kit_atomic_store_explicit_32((u32 volatile *) (var_), \ + (u32) (value_), \ + (memory_order_)); \ + if (sizeof *(var_) == 8) \ + kit_atomic_store_explicit_64((u64 volatile *) (var_), \ + (u64) (value_), \ + (memory_order_)); \ + } while (0) + +# define atomic_load_explicit(var_, memory_order_) \ + (assert(sizeof *(var_) == 1 || sizeof *(var_) == 2 || \ + sizeof *(var_) == 4 || sizeof *(var_) == 8), \ + (sizeof *(var_) == 1 \ + ? kit_atomic_load_explicit_8((u8 volatile *) (var_), \ + (memory_order_)) \ + : sizeof *(var_) == 2 \ + ? kit_atomic_load_explicit_16((u16 volatile *) (var_), \ + (memory_order_)) \ + : sizeof *(var_) == 4 \ + ? kit_atomic_load_explicit_32((u32 volatile *) (var_), \ + (memory_order_)) \ + : kit_atomic_load_explicit_64((u64 volatile *) (var_), \ + (memory_order_)))) + +# define atomic_exchange_explicit(var_, value_, memory_order_) \ + (assert(sizeof *(var_) == 1 || sizeof *(var_) == 2 || \ + sizeof *(var_) == 4 || sizeof *(var_) == 8), \ + (sizeof *(var_) == 1 ? kit_atomic_exchange_explicit_8( \ + (u8 volatile *) (var_), \ + (u8) (value_), (memory_order_)) \ + : sizeof *(var_) == 2 ? kit_atomic_exchange_explicit_16( \ + (u16 volatile *) (var_), \ + (u16) (value_), (memory_order_)) \ + : sizeof *(var_) == 4 \ + ? kit_atomic_exchange_explicit_32((u32 volatile *) (var_), \ + (u32) (value_), \ + (memory_order_)) \ + : kit_atomic_exchange_explicit_64((u64 volatile *) (var_), \ + (u64) (value_), \ + (memory_order_)))) + +# define atomic_compare_exchange_strong_explicit( \ + var_, expected_, value_, memory_order_succ_, \ + memory_order_fail_) \ + (assert(sizeof *(var_) == 1 || sizeof *(var_) == 2 || \ + sizeof *(var_) == 4 || sizeof *(var_) == 8), \ + (sizeof *(var_) == 1 \ + ? kit_atomic_compare_exchange_explicit_8( \ + (u8 volatile *) (var_), (u8 *) (expected_), \ + (u8) (value_), (memory_order_succ_), \ + (memory_order_fail_)) \ + : sizeof *(var_) == 2 \ + ? kit_atomic_compare_exchange_explicit_16( \ + (u16 volatile *) (var_), (u16 *) (expected_), \ + (u16) (value_), (memory_order_succ_), \ + (memory_order_fail_)) \ + : sizeof *(var_) == 4 \ + ? kit_atomic_compare_exchange_explicit_32( \ + (u32 volatile *) (var_), (u32 *) (expected_), \ + (u32) (value_), (memory_order_succ_), \ + (memory_order_fail_)) \ + : kit_atomic_compare_exchange_explicit_64( \ + (u64 volatile *) (var_), (u64 *) (expected_), \ + (u64) (value_), (memory_order_succ_), \ + (memory_order_fail_)))) + +# define atomic_compare_exchange_weak_explicit( \ + var_, expected_, value_, memory_order_succ_, \ + memory_order_fail_) \ + atomic_compare_exchange_strong_explicit(var_, expected_, value_, \ + memory_order_succ_, \ + memory_order_fail_) + +# define atomic_fetch_add_explicit(var_, value_, memory_order_) \ + (assert(sizeof *(var_) == 1 || sizeof *(var_) == 2 || \ + sizeof *(var_) == 4 || sizeof *(var_) == 8), \ + (sizeof *(var_) == 1 ? kit_atomic_fetch_add_explicit_8( \ + (u8 volatile *) (var_), \ + (u8) (value_), (memory_order_)) \ + : sizeof *(var_) == 2 ? kit_atomic_fetch_add_explicit_16( \ + (u16 volatile *) (var_), \ + (u16) (value_), (memory_order_)) \ + : sizeof *(var_) == 4 ? kit_atomic_fetch_add_explicit_32( \ + (u32 volatile *) (var_), \ + (u32) (value_), (memory_order_)) \ + : kit_atomic_fetch_add_explicit_64( \ + (u64 volatile *) (var_), \ + (u64) (value_), (memory_order_)))) + +# define atomic_store(var_, value_) \ + atomic_store(var_, value_, memory_order_seq_cst) + +# define atomic_load(var_) atomic_load(var_, memory_order_seq_cst) + +# define atomic_exchange(var_, value_) \ + atomic_exchange(var_, value_, memory_order_seq_cst) + +# define atomic_compare_exchange_strong(var_, expected_, value_) \ + atomic_compare_exchange_strong_explicit(var_, expected_, value_, \ + memory_order_seq_cst, \ + memory_order_seq_cst) + +# define atomic_compare_exchange_weak(var_, expected_, value_) \ + atomic_compare_exchange_weak_explicit(var_, expected_, value_, \ + memory_order_seq_cst, \ + memory_order_seq_cst) + +# define atomic_fetch_add(var_, value_) \ + atomic_fetch_add(var_, value_, memory_order_seq_cst) + +# ifdef __cplusplus +} +# endif +#endif + +#define ATOMIC KIT_ATOMIC + +#endif diff --git a/kit/atomic.win32.c b/kit/atomic.win32.c new file mode 100644 index 0000000..791f8fe --- /dev/null +++ b/kit/atomic.win32.c @@ -0,0 +1,234 @@ +#include "atomic.h" + +#ifdef _MSC_VER +static_assert(sizeof(char) == 1, "Wrong char size"); +static_assert(sizeof(short) == 2, "Wrong short size"); +static_assert(sizeof(int) == 4, "Wrong int size"); + +# include + +void kit_atomic_store_explicit_8(u8 volatile *var, u8 value, + i32 memory_order) { + char volatile *dst = (char volatile *) var; + char src = (char) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange8(dst, src); + } +} + +void kit_atomic_store_explicit_16(u16 volatile *var, u16 value, + i32 memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange16(dst, src); + } +} + +void kit_atomic_store_explicit_32(u32 volatile *var, u32 value, + i32 memory_order) { + int volatile *dst = (int volatile *) var; + int src = (int) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: _InterlockedExchange(dst, src); + } +} + +void kit_atomic_store_explicit_64(u64 volatile *var, u64 value, + i32 memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + + switch (memory_order) { + case memory_order_relaxed: *dst = src; break; + default: +# ifdef _WIN64 + _InterlockedExchange64(dst, src); +# else + assert(0); + _InterlockedExchange((int volatile *) dst, (int) src); +# endif + } +} + +u8 kit_atomic_load_explicit_8(volatile u8 *var, i32 memory_order) { + char volatile *dst = (char volatile *) var; + + if (memory_order == memory_order_relaxed) + return (u8) *dst; + + return (u8) _InterlockedOr8(dst, 0); +} + +u16 kit_atomic_load_explicit_16(u16 volatile *var, i32 memory_order) { + short volatile *dst = (short volatile *) var; + + if (memory_order == memory_order_relaxed) + return (u16) *dst; + + return (u16) _InterlockedOr16(dst, 0); +} + +u32 kit_atomic_load_explicit_32(u32 volatile *var, i32 memory_order) { + int volatile *dst = (int volatile *) var; + + if (memory_order == memory_order_relaxed) + return (u32) *dst; + + return (u32) _InterlockedOr(dst, 0); +} + +u64 kit_atomic_load_explicit_64(u64 volatile *var, i32 memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + + if (memory_order == memory_order_relaxed) + return (u64) *dst; + +# ifdef _WIN64 + return (u64) _InterlockedOr64(dst, 0); +# else + assert(0); + return (u64) _InterlockedOr((int volatile *) dst, 0); +# endif +} + +u8 kit_atomic_exchange_explicit_8(volatile u8 *var, u8 value, + i32 memory_order) { + char volatile *dst = (char volatile *) var; + char src = (char) value; + + return (u8) _InterlockedExchange8(dst, src); +} + +u16 kit_atomic_exchange_explicit_16(u16 volatile *var, u16 value, + i32 memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + return (u16) _InterlockedExchange16(dst, src); +} + +u32 kit_atomic_exchange_explicit_32(u32 volatile *var, u32 value, + i32 memory_order) { + int volatile *dst = (int volatile *) var; + int src = (int) value; + + return (u32) _InterlockedExchange(dst, src); +} + +u64 kit_atomic_exchange_explicit_64(u64 volatile *var, u64 value, + i32 memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + +# ifdef _WIN64 + return (u64) _InterlockedExchange64(dst, src); +# else + assert(0); + return (u64) _InterlockedExchange((int volatile *) dst, (int) src); +# endif +} + +int kit_atomic_compare_exchange_explicit_8(volatile u8 *var, + u8 *expected, u8 value, + i32 memory_order_succ_, + i32 memory_order_fail_) { + char volatile *dst = (char volatile *) var; + char src = (char) value; + char exp = (char) *expected; + + *expected = (u8) _InterlockedCompareExchange8(dst, src, exp); + + return exp == (char) *expected; +} + +int kit_atomic_compare_exchange_explicit_16(u16 volatile *var, + u16 *expected, u16 value, + i32 memory_order_succ_, + i32 memory_order_fail_) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + short exp = (short) *expected; + + *expected = (u16) _InterlockedCompareExchange16(dst, src, exp); + + return exp == (short) *expected; +} + +int kit_atomic_compare_exchange_explicit_32(u32 volatile *var, + u32 *expected, u32 value, + i32 memory_order_succ_, + i32 memory_order_fail_) { + int volatile *dst = (int volatile *) var; + int src = (int) value; + int exp = (int) *expected; + + *expected = (u32) _InterlockedCompareExchange(dst, src, exp); + + return exp == (int) *expected; +} + +int kit_atomic_compare_exchange_explicit_64(u64 volatile *var, + u64 *expected, u64 value, + i32 memory_order_succ_, + i32 memory_order_fail_) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + __int64 exp = (__int64) *expected; + +# ifdef _WIN64 + *expected = (u64) _InterlockedCompareExchange64(dst, src, exp); +# else + assert(0); + *expected = (u64) _InterlockedCompareExchange((int volatile *) dst, + (int) src, (int) exp); +# endif + + return exp == (__int64) *expected; +} + +u8 kit_atomic_fetch_add_explicit_8(volatile u8 *var, u8 value, + i32 memory_order) { + char volatile *dst = (char volatile *) var; + char src = (char) value; + + return (u8) _InterlockedExchangeAdd8(dst, src); +} + +u16 kit_atomic_fetch_add_explicit_16(u16 volatile *var, u16 value, + i32 memory_order) { + short volatile *dst = (short volatile *) var; + short src = (short) value; + + return (u16) _InterlockedExchangeAdd16(dst, src); +} + +u32 kit_atomic_fetch_add_explicit_32(u32 volatile *var, u32 value, + i32 memory_order) { + int volatile *dst = (int volatile *) var; + int src = (int) value; + + return (u32) _InterlockedExchangeAdd(dst, src); +} + +u64 kit_atomic_fetch_add_explicit_64(u64 volatile *var, u64 value, + i32 memory_order) { + __int64 volatile *dst = (__int64 volatile *) var; + __int64 src = (__int64) value; + +# ifdef _WIN64 + return (u64) _InterlockedExchangeAdd64(dst, src); +# else + assert(0); + return (u64) _InterlockedExchangeAdd((int volatile *) dst, + (int) src); +# endif +} + +#endif diff --git a/kit/bigint.h b/kit/bigint.h new file mode 100644 index 0000000..89610f4 --- /dev/null +++ b/kit/bigint.h @@ -0,0 +1,597 @@ +#ifndef KIT_BIGINT_H +#define KIT_BIGINT_H + +#include "string_ref.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef KIT_BIGINT_SIZE +# define KIT_BIGINT_SIZE 64 +#endif + +typedef struct { + u32 v[KIT_BIGINT_SIZE / 4]; +} kit_bigint_t; + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +static kit_bigint_t kit_bi_u32(u32 x) { + kit_bigint_t z; + memset(&z, 0, sizeof z); + z.v[0] = x; + return z; +} + +static kit_bigint_t kit_bi_u64(u64 x) { + kit_bigint_t z; + memset(&z, 0, sizeof z); + z.v[0] = (u32) (x & 0xffffffff); + z.v[1] = (u32) (x >> 32); + return z; +} + +static kit_bigint_t kit_bi_i32(i32 x) { + kit_bigint_t z; + memset(&z, x < 0 ? -1 : 0, sizeof z); + z.v[0] = x; + return z; +} + +static kit_bigint_t kit_bi_i64(i64 x) { + kit_bigint_t z; + memset(&z, x < 0 ? -1 : 0, sizeof z); + z.v[0] = (u32) (((u64) x) & 0xffffffff); + z.v[1] = (u32) (((u64) x) >> 32); + return z; +} + +static int kit_bi_is_zero(kit_bigint_t x) { + i64 i; + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) + if (x.v[i] != 0) + return 0; + return 1; +} + +static int kit_bi_is_neg(kit_bigint_t x) { + return (x.v[KIT_BIGINT_SIZE / 4 - 1] & 0x80000000) != 0; +} + +static int kit_bi_equal(kit_bigint_t x, kit_bigint_t y) { + return kit_ar_equal_bytes(1, KIT_BIGINT_SIZE, x.v, 1, + KIT_BIGINT_SIZE, y.v); +} + +static int kit_bi_compare(kit_bigint_t x, kit_bigint_t y) { + i64 i; + for (i = KIT_BIGINT_SIZE / 4 - 1; i >= 0; i--) + if (x.v[i] < y.v[i]) + return -1; + else if (x.v[i] > y.v[i]) + return 1; + return 0; +} + +static i64 kit_bi_significant_bit_count(kit_bigint_t x) { + i64 n = KIT_BIGINT_SIZE / 4 - 1; + + while (n > 0 && x.v[n] == 0) n--; + + u32 val = x.v[n]; + + if (val == 0) + return 0; + + i64 bits = (val & 0x80000000u) != 0 ? 32 + : (val & 0x40000000u) != 0 ? 31 + : (val & 0x20000000u) != 0 ? 30 + : (val & 0x10000000u) != 0 ? 29 + : (val & 0x8000000u) != 0 ? 28 + : (val & 0x4000000u) != 0 ? 27 + : (val & 0x2000000u) != 0 ? 26 + : (val & 0x1000000u) != 0 ? 25 + : (val & 0x800000u) != 0 ? 24 + : (val & 0x400000u) != 0 ? 23 + : (val & 0x200000u) != 0 ? 22 + : (val & 0x100000u) != 0 ? 21 + : (val & 0x80000u) != 0 ? 20 + : (val & 0x40000u) != 0 ? 19 + : (val & 0x20000u) != 0 ? 18 + : (val & 0x10000u) != 0 ? 17 + : (val & 0x8000u) != 0 ? 16 + : (val & 0x4000u) != 0 ? 15 + : (val & 0x2000u) != 0 ? 14 + : (val & 0x1000u) != 0 ? 13 + : (val & 0x800u) != 0 ? 12 + : (val & 0x400u) != 0 ? 11 + : (val & 0x200u) != 0 ? 10 + : (val & 0x100u) != 0 ? 9 + : (val & 0x80u) != 0 ? 8 + : (val & 0x40u) != 0 ? 7 + : (val & 0x20u) != 0 ? 6 + : (val & 0x10u) != 0 ? 5 + : (val & 0x08u) != 0 ? 4 + : (val & 0x04u) != 0 ? 3 + : (val & 0x02u) != 0 ? 2 + : 1; + + return n * 32 + bits; +} + +static kit_bigint_t kit_bi_and(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) z.v[i] = x.v[i] & y.v[i]; + + return z; +} + +static kit_bigint_t kit_bi_or(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) z.v[i] = x.v[i] | y.v[i]; + + return z; +} + +static kit_bigint_t kit_bi_xor(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) z.v[i] = x.v[i] ^ y.v[i]; + + return z; +} + +static kit_bigint_t kit_bi_shl_uint(kit_bigint_t x, u32 y) { + kit_bigint_t z; + memset(&z, 0, sizeof z); + + i64 words = (i64) (y / 32); + i64 bits = (i64) (y % 32); + i64 i; + + for (i = words; i < KIT_BIGINT_SIZE / 4; i++) { + z.v[i] |= x.v[i - words] << bits; + if (bits != 0 && i + 1 < KIT_BIGINT_SIZE / 4) + z.v[i + 1] = x.v[i - words] >> (32 - bits); + } + + return z; +} + +static kit_bigint_t kit_bi_shr_uint(kit_bigint_t x, u32 y) { + kit_bigint_t z; + memset(&z, 0, sizeof z); + + i64 words = (i64) (y / 32); + i64 bits = (i64) (y % 32); + i64 i; + + for (i = KIT_BIGINT_SIZE / 4 - words - 1; i >= 0; i--) { + z.v[i] |= x.v[i + words] >> bits; + if (bits != 0 && i > 0) + z.v[i - 1] = x.v[i + words] << (32 - bits); + } + + return z; +} + +static i8 kit_bi_carry(u32 x, u32 y, u8 carry) { + assert(carry == 0 || carry == 1); + return 0xffffffffu - x < y || 0xffffffffu - x - y < carry ? 1 : 0; +} + +/* Increment. + */ +static kit_bigint_t kit_bi_inc(kit_bigint_t x) { + kit_bigint_t z; + u8 carry = 1; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + z.v[i] = x.v[i] + carry; + carry = kit_bi_carry(x.v[i], 0, carry); + } + + return z; +} + +/* Decrement + */ +static kit_bigint_t kit_bi_dec(kit_bigint_t x) { + kit_bigint_t z; + u8 carry = 0; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + z.v[i] = x.v[i] + 0xffffffff + carry; + carry = kit_bi_carry(x.v[i], 0xffffffff, carry); + } + + return z; +} + +/* Addition. + */ +static kit_bigint_t kit_bi_add(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + u8 carry = 0; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + z.v[i] = x.v[i] + y.v[i] + carry; + carry = kit_bi_carry(x.v[i], y.v[i], carry); + } + + return z; +} + +/* Negation. + */ +static kit_bigint_t kit_bi_neg(kit_bigint_t x) { + kit_bigint_t y; + u8 carry = 1; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + y.v[i] = (x.v[i] ^ 0xffffffff) + carry; + carry = kit_bi_carry(x.v[i] ^ 0xffffffff, 0, carry); + } + + return y; +} + +/* Subtraction. + */ +static kit_bigint_t kit_bi_sub(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + u8 carry = 1; + i64 i; + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + z.v[i] = x.v[i] + (y.v[i] ^ 0xffffffff) + carry; + carry = kit_bi_carry(x.v[i], (y.v[i] ^ 0xffffffff), carry); + } + + return z; +} + +static kit_bigint_t kit_bi_mul_u32(kit_bigint_t x, u32 y) { + kit_bigint_t z; + i64 i, k; + + memset(&z, 0, sizeof z); + + if (y != 0) + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + if (x.v[i] == 0) + continue; + + u64 carry = ((u64) x.v[i]) * ((u64) y); + + for (k = i; k < KIT_BIGINT_SIZE / 4 && carry != 0; k++) { + u64 sum = ((u64) z.v[k]) + carry; + z.v[k] = ((u32) (sum & 0xffffffffull)); + carry = sum >> 32; + } + } + + return z; +} + +/* Multiplication. + */ +static kit_bigint_t kit_bi_mul(kit_bigint_t x, kit_bigint_t y) { + kit_bigint_t z; + i64 i, j, k; + + memset(&z, 0, sizeof z); + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + if (x.v[i] == 0) + continue; + + for (j = 0; i + j < KIT_BIGINT_SIZE / 4; j++) { + if (y.v[j] == 0) + continue; + + u64 carry = ((u64) x.v[i]) * ((u64) y.v[j]); + + for (k = i + j; k < KIT_BIGINT_SIZE / 4 && carry != 0; k++) { + u64 sum = ((u64) z.v[k]) + carry; + z.v[k] = ((u32) (sum & 0xffffffffull)); + carry = sum >> 32; + } + } + } + + return z; +} + +typedef struct { + i8 undefined; + kit_bigint_t quotient; + kit_bigint_t remainder; +} kit_bi_division_t; + +/* Unsigned division. + */ +static kit_bi_division_t kit_bi_udiv(kit_bigint_t x, kit_bigint_t y) { + kit_bi_division_t z; + memset(&z, 0, sizeof z); + + i64 y_bits = kit_bi_significant_bit_count(y); + + if (y_bits == 0) { + z.undefined = 1; + return z; + } + + i64 x_bits = kit_bi_significant_bit_count(x); + i64 shift = x_bits - y_bits; + + z.remainder = x; + z.quotient = kit_bi_u32(0); + + y = kit_bi_shl_uint(y, (u32) shift); + + while (shift >= 0) { + if (kit_bi_compare(z.remainder, y) >= 0) { + z.remainder = kit_bi_sub(z.remainder, y); + z.quotient.v[shift / 32] |= (1u << (shift % 32)); + } + + y = kit_bi_shr_uint(y, 1); + shift--; + } + + return z; +} + +/* Signed division. + * + * Remainder is always a non-negative value less than absolute value + * of y. + */ +static kit_bi_division_t kit_bi_div(kit_bigint_t x, kit_bigint_t y) { + int x_neg = kit_bi_is_neg(x); + int y_neg = kit_bi_is_neg(y); + + kit_bigint_t x_abs = x_neg ? kit_bi_neg(x) : x; + kit_bigint_t y_abs = y_neg ? kit_bi_neg(y) : y; + + if (x_neg == y_neg) + return kit_bi_udiv(x_abs, y_abs); + + kit_bi_division_t z = kit_bi_udiv(x_abs, y_abs); + + if (!kit_bi_is_zero(z.remainder) && !y_neg) + z.quotient = kit_bi_dec(kit_bi_neg(z.quotient)); + else + z.quotient = kit_bi_neg(z.quotient); + + return z; +} + +static void kit_bi_serialize(kit_bigint_t in, u8 *out) { + i64 i; + + assert(out != NULL); + + for (i = 0; i < KIT_BIGINT_SIZE / 4; i++) { + out[i * 4] = (u8) (in.v[i] & 0xff); + out[i * 4 + 1] = (u8) ((in.v[i] >> 8) & 0xff); + out[i * 4 + 2] = (u8) ((in.v[i] >> 16) & 0xff); + out[i * 4 + 3] = (u8) ((in.v[i] >> 24) & 0xff); + } +} + +static kit_bigint_t kit_bi_deserialize(u8 *in) { + i64 i; + kit_bigint_t out; + + assert(in != NULL); + + memset(&out, 0, sizeof out); + + for (i = 0; i < KIT_BIGINT_SIZE; i++) + out.v[i / 4] |= ((u32) in[i]) << (8 * (i % 4)); + + return out; +} + +static u8 kit_bin_digit(c8 hex) { + assert(hex == '0' || hex == '1'); + return hex == '1' ? 1 : 0; +} + +static kit_bigint_t kit_bi_from_bin(kit_str_t bin) { + kit_bigint_t z; + i64 i; + + memset(&z, 0, sizeof z); + + for (i = 0; i < bin.size && i / 8 < KIT_BIGINT_SIZE; i++) { + u8 digit = kit_bin_digit(bin.values[bin.size - i - 1]); + z.v[i / 32] |= digit << (i % 32); + } + + return z; +} + +static u8 kit_dec_digit(c8 c) { + assert('c' >= '0' && c <= '9'); + return c >= '0' && c <= '9' ? (u8) (c - '0') : 0; +} + +static kit_bigint_t kit_bi_from_dec(kit_str_t dec) { + kit_bigint_t z = kit_bi_u32(0); + kit_bigint_t factor = kit_bi_u32(1); + i64 i; + + for (i = 0; i < dec.size; i++) { + u32 digit = kit_dec_digit(dec.values[dec.size - i - 1]); + z = kit_bi_add(z, kit_bi_mul_u32(factor, digit)); + factor = kit_bi_mul_u32(factor, 10); + } + + return z; +} + +static u8 kit_hex_digit(c8 hex) { + assert((hex >= '0' && hex <= '9') || (hex >= 'a' && hex <= 'f') || + (hex >= 'A' && hex <= 'F')); + + if (hex >= '0' && hex <= '9') + return hex - '0'; + if (hex >= 'a' && hex <= 'f') + return hex - 'a'; + if (hex >= 'A' && hex <= 'F') + return hex - 'A'; + + return 0; +} + +static kit_bigint_t kit_bi_from_hex(kit_str_t hex) { + kit_bigint_t z; + i64 i; + + memset(&z, 0, sizeof z); + + for (i = 0; i < hex.size && i / 2 < KIT_BIGINT_SIZE; i++) { + u8 digit = kit_hex_digit(hex.values[hex.size - i - 1]); + z.v[i / 8] |= digit << (4 * (i % 8)); + } + + return z; +} + +static u8 KIT_BASE32_DIGITS[256] = { + ['1'] = 0, ['2'] = 1, ['3'] = 2, ['4'] = 3, ['5'] = 4, + ['6'] = 5, ['7'] = 6, ['8'] = 7, ['9'] = 8, ['a'] = 9, + ['b'] = 10, ['c'] = 11, ['d'] = 12, ['e'] = 13, ['f'] = 14, + ['g'] = 15, ['h'] = 16, ['j'] = 17, ['k'] = 18, ['m'] = 19, + ['n'] = 20, ['p'] = 21, ['q'] = 22, ['r'] = 23, ['s'] = 24, + ['t'] = 25, ['u'] = 26, ['v'] = 27, ['w'] = 28, ['x'] = 29, + ['y'] = 30, ['z'] = 31 +}; + +static u8 kit_base32_digit(c8 c) { + assert(c == '1' || KIT_BASE32_DIGITS[(size_t) (u8) c] != 0); + + return KIT_BASE32_DIGITS[(size_t) (u8) c]; +} + +static kit_bigint_t kit_bi_from_base32(kit_str_t base32) { + kit_bigint_t z; + i64 i; + + memset(&z, 0, sizeof z); + + for (i = 0; i < base32.size; i++) { + z = kit_bi_shl_uint(z, 5 * i); + z.v[0] |= kit_base32_digit(base32.values[i]); + } + + return z; +} + +static u8 KIT_BASE58_DIGITS[256] = { + ['1'] = 0, ['2'] = 1, ['3'] = 2, ['4'] = 3, ['5'] = 4, + ['6'] = 5, ['7'] = 6, ['8'] = 7, ['9'] = 8, ['A'] = 9, + ['B'] = 10, ['C'] = 11, ['D'] = 12, ['E'] = 13, ['F'] = 14, + ['G'] = 15, ['H'] = 16, ['J'] = 17, ['K'] = 18, ['L'] = 19, + ['M'] = 20, ['N'] = 21, ['P'] = 22, ['Q'] = 23, ['R'] = 24, + ['S'] = 25, ['T'] = 26, ['U'] = 27, ['V'] = 28, ['W'] = 29, + ['X'] = 30, ['Y'] = 31, ['Z'] = 32, ['a'] = 33, ['b'] = 34, + ['c'] = 35, ['d'] = 36, ['e'] = 37, ['f'] = 38, ['g'] = 39, + ['h'] = 40, ['i'] = 41, ['j'] = 42, ['k'] = 43, ['m'] = 44, + ['n'] = 45, ['o'] = 46, ['p'] = 47, ['q'] = 48, ['r'] = 49, + ['s'] = 50, ['t'] = 51, ['u'] = 52, ['v'] = 53, ['w'] = 54, + ['x'] = 55, ['y'] = 56, ['z'] = 57 +}; + +static u8 kit_base58_digit(c8 c) { + assert(c == '1' || KIT_BASE58_DIGITS[(size_t) (u8) c] != 0); + + return KIT_BASE58_DIGITS[(size_t) (u8) c]; +} + +static kit_bigint_t kit_bi_from_base58(kit_str_t base58) { + kit_bigint_t z = kit_bi_u32(0); + kit_bigint_t factor = kit_bi_u32(1); + i64 i; + + for (i = 0; i < base58.size; i++) { + u32 digit = kit_base58_digit(base58.values[base58.size - i - 1]); + z = kit_bi_add(z, kit_bi_mul_u32(factor, digit)); + factor = kit_bi_mul_u32(factor, 58); + } + + return z; +} + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#define KIT_BIN(static_str_) \ + kit_bi_from_bin(kit_str(sizeof(static_str_) - 1, (static_str_))) + +#define KIT_DEC(static_str_) \ + kit_bi_from_dec(kit_str(sizeof(static_str_) - 1, (static_str_))) + +#define KIT_HEX(static_str_) \ + kit_bi_from_hex(kit_str(sizeof(static_str_) - 1, (static_str_))) + +#define KIT_BASE32(static_str_) \ + kit_bi_from_base32(kit_str(sizeof(static_str_) - 1, (static_str_))) + +#define KIT_BASE58(static_str_) \ + kit_bi_from_base58(kit_str(sizeof(static_str_) - 1, (static_str_))) + +#ifdef __cplusplus +} +#endif + +#define bigint_t kit_bigint_t +#define bi_u32 kit_bi_u32 +#define bi_u64 kit_bi_u64 +#define bi_i32 kit_bi_i32 +#define bi_i64 kit_bi_i64 +#define bi_is_zero kit_bi_is_zero +#define bi_is_neg kit_bi_is_neg +#define bi_equal kit_bi_equal +#define bi_compare kit_bi_compare +#define bi_carry kit_bi_carry +#define bi_inc kit_bi_inc +#define bi_dec kit_bi_dec +#define bi_add kit_bi_add +#define bi_neg kit_bi_neg +#define bi_sub kit_bi_sub +#define bi_mul kit_bi_mul +#define bi_div kit_bi_div +#define bi_serialize kit_bi_serialize +#define bi_deserialize kit_bi_deserialize +#define BIN KIT_BIN +#define DEC KIT_DEC +#define HEX KIT_HEX +#define BASE32 KIT_BASE32 +#define BASE58 KIT_BASE58 + +#endif diff --git a/kit/dynamic_array.c b/kit/dynamic_array.c new file mode 100644 index 0000000..ede817b --- /dev/null +++ b/kit/dynamic_array.c @@ -0,0 +1,81 @@ +#include "dynamic_array.h" + +#include + +void kit_da_init(kit_da_void_t *array, i64 element_size, i64 size, + kit_allocator_t *alloc) { + assert(array != NULL); + assert(element_size > 0); + assert(size >= 0); + + memset(array, 0, sizeof(kit_da_void_t)); + + if (size > 0) + array->values = kit_alloc_dispatch(alloc, KIT_ALLOCATE, + element_size * size, 0, NULL); + + if (array->values != NULL) { + array->capacity = size; + array->size = size; + } + + array->alloc = alloc; +} + +static i64 eval_capacity(i64 current_cap, i64 required_cap) { + if (current_cap == 0) + return required_cap; + i64 cap = current_cap; + while (cap < required_cap) cap *= 2; + return cap; +} + +void kit_da_resize(kit_da_void_t *array, i64 element_size, i64 size) { + assert(array != NULL); + assert(element_size > 0); + assert(size >= 0); + + if (size <= array->capacity) { + array->size = size; + } else { + i64 capacity = eval_capacity(array->capacity, size); + + void *bytes = kit_alloc_dispatch( + array->alloc, KIT_ALLOCATE, element_size * capacity, 0, NULL); + + if (bytes != NULL) { + if (array->size > 0) + memcpy(bytes, array->values, element_size * array->size); + if (array->values != NULL) + kit_alloc_dispatch(array->alloc, KIT_DEALLOCATE, 0, 0, + array->values); + array->capacity = capacity; + array->size = size; + array->values = bytes; + } + } +} + +void kit_da_resize_exact(kit_da_void_t *array, i64 element_size, + i64 capacity) { + assert(array != NULL); + assert(element_size > 0); + assert(capacity >= 0); + + void *bytes = capacity <= 0 + ? NULL + : kit_alloc_dispatch(array->alloc, KIT_ALLOCATE, + element_size * capacity, 0, + NULL); + + if (bytes != NULL || capacity == 0) { + if (array->size > 0 && capacity > 0) + memcpy(bytes, array->values, element_size * array->size); + if (array->values != NULL) + kit_alloc_dispatch(array->alloc, KIT_DEALLOCATE, 0, 0, + array->values); + array->capacity = capacity; + array->size = capacity; + array->values = bytes; + } +} diff --git a/kit/dynamic_array.h b/kit/dynamic_array.h new file mode 100644 index 0000000..571f344 --- /dev/null +++ b/kit/dynamic_array.h @@ -0,0 +1,126 @@ +#ifndef KIT_DYNAMIC_ARRAY_H +#define KIT_DYNAMIC_ARRAY_H + +#include "allocator.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + i64 capacity; + i64 size; + void *values; + kit_allocator_t *alloc; +} kit_da_void_t; + +void kit_da_init(kit_da_void_t *array, i64 element_size, i64 size, + kit_allocator_t *alloc); + +void kit_da_resize(kit_da_void_t *array, i64 element_size, i64 size); + +void kit_da_resize_exact(kit_da_void_t *array, i64 element_size, + i64 size); + +/* Dynamic array type definition. + */ +#define KIT_DA(element_type_) \ + struct { \ + i64 capacity; \ + i64 size; \ + element_type_ *values; \ + kit_allocator_t *alloc; \ + } + +/* Initialize dynamic array. + */ +#define KIT_DA_INIT(array_, size_, alloc_) \ + kit_da_init((kit_da_void_t *) &(array_), \ + sizeof((array_).values[0]), (size_), (alloc_)) + +/* Declare and initialize dynamic array. + */ +#define KIT_DA_CREATE(name_, element_type_, size_) \ + KIT_DA(element_type_) name_; \ + KIT_DA_INIT(name_, (size_), NULL) + +/* Destroy dynamic array. + */ +#define KIT_DA_DESTROY(array_) \ + do { \ + if ((array_).values != NULL) \ + kit_alloc_dispatch((array_).alloc, KIT_DEALLOCATE, 0, \ + (array_).capacity * \ + sizeof((array_).values[0]), \ + (array_).values); \ + memset(&(array_), 0, sizeof(array_)); \ + } while (0) + +/* Resize dynamic array. + */ +#define KIT_DA_RESIZE(array_, size_) \ + kit_da_resize((kit_da_void_t *) &(array_), \ + sizeof((array_).values[0]), size_) + +/* Resize dynamic array with exact capacity. + */ +#define KIT_DA_RESIZE_EXACT(array_, capacity_) \ + kit_da_resize_exact((kit_da_void_t *) &(array_), \ + sizeof((array_).values[0]), capacity_) + +/* Append a value to dynamic array. + */ +#define KIT_DA_APPEND(array_, value_) \ + do { \ + i64 kit_index_back_ = (array_).size; \ + KIT_DA_RESIZE((array_), kit_index_back_ + 1); \ + if (kit_index_back_ < (array_).size) \ + (array_).values[kit_index_back_] = (value_); \ + } while (0) + +/* Insert a value into dynamic array. + */ +#define KIT_DA_INSERT(array_, index_, value_) \ + do { \ + i64 kit_i_; \ + i64 kit_index_back_ = (array_).size; \ + i64 kit_indert_n_ = (index_); \ + KIT_DA_RESIZE((array_), kit_index_back_ + 1); \ + if (kit_index_back_ + 1 == (array_).size) { \ + for (kit_i_ = kit_index_back_; kit_i_ > kit_indert_n_; \ + kit_i_--) \ + (array_).values[kit_i_] = (array_).values[kit_i_ - 1]; \ + (array_).values[kit_indert_n_] = (value_); \ + } \ + } while (0) + +/* Erase a value from dynamic array. + */ +#define KIT_DA_ERASE(array_, index_) \ + do { \ + i64 i_; \ + for (i_ = (index_) + 1; i_ < (array_).size; i_++) \ + (array_).values[i_ - 1] = (array_).values[i_]; \ + KIT_DA_RESIZE((array_), (array_).size - 1); \ + } while (0) + +#ifdef __cplusplus +} +#endif + +#define da_void_t kit_da_void_t +#define da_init kit_da_init +#define da_resize kit_da_resize +#define DA KIT_DA +#define DA_INIT KIT_DA_INIT +#define DA_CREATE KIT_DA_CREATE +#define DA_DESTROY KIT_DA_DESTROY +#define DA_RESIZE KIT_DA_RESIZE +#define DA_RESIZE_EXACT KIT_DA_RESIZE_EXACT +#define DA_APPEND KIT_DA_APPEND +#define DA_INSERT KIT_DA_INSERT +#define DA_ERASE KIT_DA_ERASE + +#endif diff --git a/kit/file.c b/kit/file.c new file mode 100644 index 0000000..3eafc70 --- /dev/null +++ b/kit/file.c @@ -0,0 +1,691 @@ +#include "file.h" + +#include +#include +#include + +enum { PATH_BUF_SIZE = 4096 }; + +#if defined(_WIN32) && !defined(__CYGWIN__) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include +# include +#else +# include +# include +# include +# include +# include +# include +#endif + +#ifdef __APPLE__ +# define st_mtim st_mtimespec +#endif + +#ifndef PATH_MAX +# define PATH_MAX MAX_PATH +#endif + +static i32 is_delim(char c) { + return c == '/' || c == '\\'; +} + +kit_str_builder_t kit_get_env(kit_str_t name, + kit_allocator_t *alloc) { + char *val = getenv(BS(name)); + i64 size = val != NULL ? (i64) strlen(val) : 0; + + str_builder_t result; + DA_INIT(result, size, alloc); + assert(result.size == size); + + if (result.size == size && size > 0) + memcpy(result.values, val, result.size); + else + DA_RESIZE(result, 0); + + return result; +} + +kit_str_builder_t kit_path_norm(kit_str_t path, + kit_allocator_t *alloc) { + str_t parent = SZ(".."); + i64 i, i1, j; + + str_builder_t norm; + DA_INIT(norm, path.size, alloc); + assert(norm.size == path.size); + + if (norm.size != path.size) + return norm; + + memcpy(norm.values, path.values, path.size); + + for (i1 = 0, i = 0; i < path.size; i++) { + if (!is_delim(path.values[i])) + continue; + + str_t s = { .size = i - i1 - 1, .values = path.values + i1 + 1 }; + if (AR_EQUAL(s, parent)) { + i32 have_parent = 0; + i64 i0 = 0; + + for (j = 0; j < i1; j++) { + if (norm.values[j] != '\0') + have_parent = 1; + if (is_delim(norm.values[j])) + i0 = j; + } + + if (have_parent) { + memset(norm.values + i0, '\0', i - i0); + + if (!is_delim(path.values[i0])) + norm.values[i] = '\0'; + } + } + + i1 = i; + } + + i64 size = 0; + + for (i = 0; i < norm.size; i++) { + if (norm.values[i] != '\0') { + if (is_delim(norm.values[i])) + norm.values[size] = KIT_PATH_DELIM_C; + else + norm.values[size] = norm.values[i]; + size++; + } + } + + norm.size = size; + return norm; +} + +kit_str_builder_t kit_path_join(kit_str_t left, kit_str_t right, + kit_allocator_t *alloc) { + i64 left_size = left.size; + i64 right_size = right.size; + char *right_values = right.values; + + if (left_size > 0 && is_delim(left.values[left_size - 1])) + left_size--; + if (right_size > 0 && is_delim(right.values[0])) { + right_size--; + right_values++; + } + + kit_str_builder_t joined; + DA_INIT(joined, left_size + right_size + 1, alloc); + assert(joined.size == left_size + right_size + 1); + + if (joined.size != left_size + right_size + 1) + return joined; + + memcpy(joined.values, left.values, left_size); + joined.values[left_size] = KIT_PATH_DELIM_C; + memcpy(joined.values + left_size + 1, right_values, right_size); + + return joined; +} + +kit_str_builder_t kit_path_user(kit_allocator_t *alloc) { + kit_str_builder_t user = kit_get_env(SZ(KIT_ENV_HOME), alloc); + if (user.size == 0) { + DA_RESIZE(user, 1); + if (user.size == 1) + user.values[0] = '.'; + } + return user; +} + +kit_str_builder_t kit_path_cache(kit_allocator_t *alloc) { + kit_str_builder_t cache, user; + + cache = kit_get_env(SZ("XDG_CACHE_HOME"), alloc); + if (cache.size != 0) + return cache; + DA_DESTROY(cache); + +#if defined(_WIN32) && !defined(__CYGWIN__) + cache = kit_get_env(SZ("TEMP"), alloc); + if (cache.size != 0) + return cache; + DA_DESTROY(cache); +#endif + + user = kit_path_user(alloc); + cache = +#ifdef __APPLE__ + kit_path_join(WRAP_STR(user), SZ("Library" PATH_DELIM "Caches"), + alloc); +#else + kit_path_join(WRAP_STR(user), SZ(".cache"), alloc); +#endif + DA_DESTROY(user); + + return cache; +} + +kit_str_builder_t kit_path_data(kit_allocator_t *alloc) { + kit_str_builder_t data, user; + + data = kit_get_env(SZ("XDG_DATA_HOME"), alloc); + if (data.size != 0) + return data; + DA_DESTROY(data); + +#if defined(_WIN32) && !defined(__CYGWIN__) + data = kit_get_env(SZ("LOCALAPPDATA"), alloc); + if (data.size != 0) + return data; + DA_DESTROY(data); +#endif + + user = kit_path_user(alloc); + data = +#ifdef __APPLE__ + kit_path_join(WRAP_STR(user), SZ("Library"), alloc); +#else + kit_path_join(WRAP_STR(user), SZ(".local" PATH_DELIM "share"), + alloc); +#endif + DA_DESTROY(user); + + return data; +} + +kit_str_t kit_path_index(kit_str_t path, i64 index) { + str_t s = { .size = 0, .values = NULL }; + + i64 i0 = 0; + i64 i = 0; + i64 n = 0; + + for (; i < path.size; i++) { + if (!is_delim(path.values[i])) + continue; + + if (i0 < i) { + if (n++ == index) { + s.values = path.values + i0; + s.size = i - i0; + return s; + } + } + + i0 = i + 1; + } + + if (n == index) { + s.values = path.values + i0; + s.size = i - i0; + } + + return s; +} + +kit_str_t kit_path_take(kit_str_t path, i64 count) { + str_t s = { .size = 0, .values = path.values }; + + i64 i0 = 0; + i64 i = 0; + i64 n = 0; + + for (; i < path.size; i++) { + if (!is_delim(path.values[i])) + continue; + + if (i0 < i) { + if (n++ == count) { + s.size = i; + return s; + } + } + + i0 = i + 1; + } + + if (n == count) + s.size = i; + + return s; +} + +// TODO +// Long path support for Windows +// +static void kit_prepare_path_(char *buf, kit_str_t path) { + assert(path.size == 0 || path.values != NULL); + assert(path.size + 1 < PATH_BUF_SIZE); + + memset(buf, 0, PATH_BUF_SIZE); + if (path.size > 0 && path.size + 1 < PATH_BUF_SIZE) + memcpy(buf, path.values, path.size); +} + +#define PREPARE_PATH_BUF_ \ + char buf[PATH_BUF_SIZE]; \ + kit_prepare_path_(buf, path) + +s32 kit_folder_create(kit_str_t path) { + PREPARE_PATH_BUF_; +#if defined(_WIN32) && !defined(__CYGWIN__) + return CreateDirectoryA(buf, NULL) ? KIT_OK + : KIT_ERROR_MKDIR_FAILED; +#else + return mkdir(buf, 0775) == 0 ? KIT_OK : KIT_ERROR_MKDIR_FAILED; +#endif +} + +s32 kit_folder_create_recursive(kit_str_t path) { + for (i32 i = 0;; i++) { + str_t part = kit_path_take(path, i); + i32 type = kit_path_type(part); + if (type == KIT_PATH_FILE) + return KIT_ERROR_FILE_ALREADY_EXISTS; + if (type == KIT_PATH_NONE) { + s32 s = kit_folder_create(part); + if (s != KIT_OK) + return s; + } + if (part.size == path.size) + break; + } + + return KIT_OK; +} + +s32 kit_file_remove(kit_str_t path) { + PREPARE_PATH_BUF_; +#if defined(_WIN32) && !defined(__CYGWIN__) + return DeleteFileA(buf) ? KIT_OK : KIT_ERROR_UNLINK_FAILED; +#else + return unlink(buf) == 0 ? KIT_OK : KIT_ERROR_UNLINK_FAILED; +#endif +} + +s32 kit_folder_remove(kit_str_t path) { + PREPARE_PATH_BUF_; +#if defined(_WIN32) && !defined(__CYGWIN__) + return RemoveDirectoryA(buf) ? KIT_OK : KIT_ERROR_RMDIR_FAILED; +#else + return rmdir(buf) == 0 ? KIT_OK : KIT_ERROR_RMDIR_FAILED; +#endif +} + +s32 kit_file_remove_recursive(kit_str_t path, + kit_allocator_t *alloc) { + i32 type = kit_path_type(path); + i64 i; + + switch (type) { + case KIT_PATH_FILE: { + s32 s = kit_file_remove(path); + assert(s == KIT_OK); + return s; + } + + case KIT_PATH_FOLDER: { + kit_path_list_t list = kit_folder_enum(path, alloc); + + assert(list.status == KIT_OK); + if (list.status != KIT_OK) { + kit_path_list_destroy(list); + return list.status; + } + + for (i = 0; i < list.files.size; i++) { + str_builder_t full_path = kit_path_join( + path, WRAP_STR(list.files.values[i]), alloc); + s32 s = kit_file_remove_recursive(WRAP_STR(full_path), alloc); + DA_DESTROY(full_path); + assert(s == KIT_OK); + } + + kit_path_list_destroy(list); + + s32 s = kit_folder_remove(path); + assert(s == KIT_OK); + return s; + } + + default:; + } + + return KIT_ERROR_FILE_DOES_NOT_EXIST; +} + +kit_path_type_t kit_path_type(kit_str_t path) { + PREPARE_PATH_BUF_; +#if defined(_WIN32) && !defined(__CYGWIN__) + if (PathFileExistsA(buf)) { + if ((GetFileAttributesA(buf) & FILE_ATTRIBUTE_DIRECTORY) != 0) + return KIT_PATH_FOLDER; + else + return KIT_PATH_FILE; + } +#else + struct stat info; + if (stat(buf, &info) == 0) { + if (S_ISREG(info.st_mode)) + return KIT_PATH_FILE; + if (S_ISDIR(info.st_mode)) + return KIT_PATH_FOLDER; + } +#endif + return KIT_PATH_NONE; +} + +kit_file_info_t kit_file_info(kit_str_t path) { + kit_file_info_t result; + memset(&result, 0, sizeof result); + + PREPARE_PATH_BUF_; + +#if defined(_WIN32) && !defined(__CYGWIN__) + HANDLE f = CreateFileA(buf, GENERIC_READ, FILE_SHARE_READ, NULL, + OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); + if (f != INVALID_HANDLE_VALUE) { + FILETIME ft; + if (GetFileTime(f, NULL, NULL, &ft) != 0) { + i64 nsec100 = (((u64) ft.dwHighDateTime) << 32) | + (u64) ft.dwLowDateTime; + result.time_modified_sec = (i64) (nsec100 / 10000000); + result.time_modified_nsec = (i32) (100 * (nsec100 % 10000000)); + } else { + assert(0); + } + + DWORD high; + DWORD low = GetFileSize(f, &high); + + result.size = (i64) ((((u64) high) << 32) | (u64) low); + result.status = KIT_OK; + + CloseHandle(f); + return result; + } +#else + struct stat info; + if (stat(buf, &info) == 0 && S_ISREG(info.st_mode)) { + result.size = (i64) info.st_size; +# ifndef st_mtime + // No support for nanosecond timestamps. + // + result.time_modified_sec = (i64) info.st_mtime; +# else + result.time_modified_sec = (i64) info.st_mtim.tv_sec; + result.time_modified_nsec = (i32) info.st_mtim.tv_nsec; +# endif + result.status = KIT_OK; + return result; + } +#endif + + result.status = KIT_ERROR_FILE_DOES_NOT_EXIST; + return result; +} + +kit_path_list_t kit_folder_enum(kit_str_t path, + kit_allocator_t *alloc) { + PREPARE_PATH_BUF_; + + kit_path_list_t result = { .status = KIT_OK }; + DA_INIT(result.files, 0, alloc); + +#if defined(_WIN32) && !defined(__CYGWIN__) + if (path.size + 3 >= PATH_BUF_SIZE) { + result.status = KIT_ERROR_PATH_TOO_LONG; + return result; + } + + buf[path.size] = '\\'; + buf[path.size + 1] = '*'; + + WIN32_FIND_DATAA data; + HANDLE find = FindFirstFileA(buf, &data); + + if (find == INVALID_HANDLE_VALUE) + return result; + + do { + if (strcmp(data.cFileName, ".") == 0 || + strcmp(data.cFileName, "..") == 0) + continue; + + i64 n = result.files.size; + DA_RESIZE(result.files, n + 1); + if (result.files.size != n + 1) { + result.status = KIT_ERROR_OUT_OF_MEMORY; + break; + } + + i64 size = (i64) strlen(data.cFileName); + DA_INIT(result.files.values[n], size, alloc); + if (result.files.values[n].size != size) { + DA_RESIZE(result.files, n); + result.status = KIT_ERROR_OUT_OF_MEMORY; + break; + } + + memcpy(result.files.values[n].values, data.cFileName, size); + } while (FindNextFileA(find, &data) != 0); + + FindClose(find); +#else + DIR *directory = opendir(buf); + + if (directory == NULL) + return result; + + for (;;) { + struct dirent *entry = readdir(directory); + + if (entry == NULL) + break; + + if (entry->d_name[0] == '.') + continue; + + i64 n = result.files.size; + DA_RESIZE(result.files, n + 1); + if (result.files.size != n + 1) { + result.status = KIT_ERROR_OUT_OF_MEMORY; + break; + } + + i64 size = (i64) strlen(entry->d_name); + DA_INIT(result.files.values[n], size, alloc); + if (result.files.values[n].size != size) { + DA_RESIZE(result.files, n); + result.status = KIT_ERROR_OUT_OF_MEMORY; + break; + } + + if (size > 0) + memcpy(result.files.values[n].values, entry->d_name, size); + } + + closedir(directory); +#endif + + return result; +} + +void kit_path_list_destroy(kit_path_list_t list) { + i64 i; + for (i = 0; i < list.files.size; i++) + DA_DESTROY(list.files.values[i]); + DA_DESTROY(list.files); +} + +kit_mapped_file_t kit_file_map(kit_str_t path, i64 size, i32 mode) { + assert(size > 0); + assert(path.size > 0); + assert(path.size <= PATH_MAX); + assert(path.values != NULL); + + kit_mapped_file_t mf; + memset(&mf, 0, sizeof mf); + + if (size <= 0) { + mf.status = KIT_ERROR_INVALID_SIZE; + return mf; + } + + if (path.size <= 0) { + mf.status = KIT_ERROR_INVALID_ARGUMENT; + return mf; + } + + if (path.size > PATH_MAX) { + mf.status = KIT_ERROR_PATH_TOO_LONG; + return mf; + } + +#if defined(_WIN32) && !defined(__CYGWIN__) + char buf[MAX_PATH + 1]; + memcpy(buf, path.values, path.size); + buf[path.size] = '\0'; + + HANDLE file = CreateFileA( + buf, GENERIC_READ | GENERIC_WRITE, + mode == FILE_MAP_SHARED ? FILE_SHARE_READ | FILE_SHARE_WRITE + : 0, + NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + + if (file == INVALID_HANDLE_VALUE) { + mf.status = KIT_ERROR_OPEN_FAILED; + return mf; + } + + LONG high = (LONG) (size >> 32); + + if (SetFilePointer(file, (LONG) size, &high, FILE_BEGIN) == + INVALID_SET_FILE_POINTER) { + CloseHandle(file); + assert(0); + mf.status = KIT_ERROR_TRUNCATE_FAILED; + return mf; + } + + if (!SetEndOfFile(file)) { + CloseHandle(file); + assert(0); + mf.status = KIT_ERROR_TRUNCATE_FAILED; + return mf; + } + + HANDLE map = CreateFileMappingA(file, NULL, PAGE_READWRITE, + (DWORD) (size >> 32), (DWORD) size, + NULL); + + if (map == INVALID_HANDLE_VALUE) { + CloseHandle(file); + assert(0); + mf.status = KIT_ERROR_MAP_FAILED; + return mf; + } + + void *p = MapViewOfFile(map, FILE_MAP_ALL_ACCESS, 0, 0, + (SIZE_T) size); + + if (p == NULL) { + CloseHandle(map); + CloseHandle(file); + assert(0); + mf.status = KIT_ERROR_MAP_FAILED; + return mf; + } + + mf.status = KIT_OK; + mf.size = size; + mf.bytes = p; + mf._file = file; + mf._map = map; +#else + char buf[PATH_MAX + 1]; + memcpy(buf, path.values, path.size); + buf[path.size] = '\0'; + + i32 fd = open(buf, O_RDWR | O_CREAT, 0664); + + if (fd == -1) { + mf.status = KIT_ERROR_OPEN_FAILED; + return mf; + } + + if (ftruncate(fd, size) == -1) { + close(fd); + assert(0); + mf.status = KIT_ERROR_TRUNCATE_FAILED; + return mf; + } + + void *p = mmap( + NULL, size, PROT_READ | PROT_WRITE, + mode == KIT_FILE_MAP_SHARED ? MAP_SHARED : MAP_PRIVATE, fd, 0); + + if (p == MAP_FAILED) { + close(fd); + assert(0); + mf.status = KIT_ERROR_MAP_FAILED; + return mf; + } + + mf.status = KIT_OK; + mf.size = size; + mf.bytes = (u8 *) p; + mf._fd = fd; +#endif + + return mf; +} + +s32 kit_file_sync(kit_mapped_file_t *mf) { + assert(mf != NULL); + + if (mf == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + s32 status = KIT_OK; + +#if !defined(_WIN32) || defined(__CYGWIN__) + if (msync(mf->bytes, mf->size, MS_SYNC) != 0) + status |= KIT_ERROR_SYNC_FAILED; +#endif + + return status; +} + +s32 kit_file_unmap(kit_mapped_file_t *mf) { + assert(mf != NULL); + + if (mf == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + s32 status = KIT_OK; + +#if defined(_WIN32) && !defined(__CYGWIN__) + if (!UnmapViewOfFile(mf->bytes)) + status |= KIT_ERROR_UNMAP_FAILED; + if (!CloseHandle(mf->_map) || !CloseHandle(mf->_file)) + status |= KIT_ERROR_CLOSE_FAILED; +#else + if (munmap(mf->bytes, mf->size) != 0) + status |= KIT_ERROR_UNMAP_FAILED; + if (close(mf->_fd) != 0) + status |= KIT_ERROR_CLOSE_FAILED; +#endif + + return status; +} diff --git a/kit/file.h b/kit/file.h new file mode 100644 index 0000000..12f00a2 --- /dev/null +++ b/kit/file.h @@ -0,0 +1,134 @@ +#ifndef KIT_FILE_H +#define KIT_FILE_H + +#include "dynamic_array.h" +#include "string_builder.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) && !defined(__CYGWIN__) +# define KIT_PATH_DELIM_C '\\' +# define KIT_PATH_DELIM "\\" +# define KIT_ENV_HOME "USERPROFILE" +#else +# define KIT_PATH_DELIM_C '/' +# define KIT_PATH_DELIM "/" +# define KIT_ENV_HOME "HOME" +#endif + +typedef enum { + KIT_PATH_NONE, + KIT_PATH_FILE, + KIT_PATH_FOLDER +} kit_path_type_t; + +typedef struct { + s32 status; + + i64 time_modified_sec; + i32 time_modified_nsec; + i64 size; +} kit_file_info_t; + +typedef struct { + s32 status; + KIT_DA(kit_str_builder_t) files; +} kit_path_list_t; + +enum { KIT_FILE_MAP_PRIVATE, KIT_FILE_MAP_SHARED }; + +typedef struct { + s32 status; + i64 size; + u8 *bytes; +#if defined(_WIN32) && !defined(__CYGWIN__) + void *_file; + void *_map; +#else + int _fd; +#endif +} kit_mapped_file_t; + +kit_str_builder_t kit_get_env(kit_str_t name, kit_allocator_t *alloc); + +kit_str_builder_t kit_path_norm(kit_str_t path, + kit_allocator_t *alloc); + +kit_str_builder_t kit_path_join(kit_str_t left, kit_str_t right, + kit_allocator_t *alloc); + +kit_str_builder_t kit_path_user(kit_allocator_t *alloc); + +kit_str_builder_t kit_path_cache(kit_allocator_t *alloc); + +kit_str_builder_t kit_path_data(kit_allocator_t *alloc); + +kit_str_t kit_path_index(kit_str_t path, i64 index); + +kit_str_t kit_path_take(kit_str_t path, i64 count); + +s32 kit_folder_create(kit_str_t path); + +s32 kit_folder_create_recursive(kit_str_t path); + +s32 kit_file_remove(kit_str_t path); + +s32 kit_folder_remove(kit_str_t path); + +s32 kit_file_remove_recursive(kit_str_t path, kit_allocator_t *alloc); + +kit_path_type_t kit_path_type(kit_str_t path); + +kit_file_info_t kit_file_info(kit_str_t path); + +kit_path_list_t kit_folder_enum(kit_str_t path, + kit_allocator_t *alloc); + +void kit_path_list_destroy(kit_path_list_t list); + +kit_mapped_file_t kit_file_map(kit_str_t path, i64 size, i32 mode); +s32 kit_file_sync(kit_mapped_file_t *mf); +s32 kit_file_unmap(kit_mapped_file_t *mf); + +#ifdef __cplusplus +} +#endif + +#define path_type_t kit_path_type_t +#define file_info_t kit_file_info_t +#define path_list_t kit_path_list_t +#define mapped_file_t kit_mapped_file_t +#define get_env kit_get_env +#define path_norm kit_path_norm +#define path_join kit_path_join +#define path_user kit_path_user +#define path_cache kit_path_cache +#define path_data kit_path_data +#define path_index kit_path_index +#define path_take kit_path_take +#define folder_create kit_folder_create +#define folder_create_recursive kit_folder_create_recursive +#define file_remove kit_file_remove +#define folder_remove kit_folder_remove +#define file_remove_recursive kit_file_remove_recursive +#define path_type kit_path_type +#define file_info kit_file_info +#define folder_enum kit_folder_enum +#define path_list_destroy kit_path_list_destroy +#define file_map kit_file_map +#define file_sync kit_file_sync +#define file_unmap kit_file_unmap +#define FILE_MAP_PRIVATE KIT_FILE_MAP_PRIVATE +#define FILE_MAP_SHARED KIT_FILE_MAP_SHARED +#define PATH_DELIM_C KIT_PATH_DELIM_C +#define PATH_DELIM KIT_PATH_DELIM +#define ENV_HOME KIT_ENV_HOME +#define PATH_NONE KIT_PATH_NONE +#define PATH_FILE KIT_PATH_FILE +#define PATH_FOLDER KIT_PATH_FOLDER + +#endif diff --git a/kit/http1.h b/kit/http1.h new file mode 100644 index 0000000..0a58f96 --- /dev/null +++ b/kit/http1.h @@ -0,0 +1,511 @@ +// TODO +// - Error handling +// - HTTPS support + +#ifndef KIT_HTTP1_H +#define KIT_HTTP1_H + +#include "types.h" +#include "string_builder.h" +#include "sockets.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define KIT_HTTP1_NEWLINE "\r\n" +#define KIT_HTTP1_SPACE " " +#define KIT_HTTP1_HEADER_SEPARATOR ": " +#define KIT_HTTP1_BUFFER_SIZE 8192 + +enum { + KIT_HTTP1_OPTIONS, + KIT_HTTP1_GET, + KIT_HTTP1_HEAD, + KIT_HTTP1_POST, + KIT_HTTP1_PUT, + KIT_HTTP1_DELETE, + KIT_HTTP1_TRACE, + KIT_HTTP1_CONNECT, +}; + +typedef struct { + kit_str_t key; + kit_str_t value; +} kit_http1_str_pair_t; + +typedef KIT_DA(kit_http1_str_pair_t) kit_http1_str_map_t; + +typedef struct { + kit_str_t str; + i64 position; +} kit_http1_tok_t; + +typedef struct { + kit_str_t protocol; + kit_str_t host; + kit_str_t port; + kit_str_t address; + kit_str_t query_string; + kit_str_t hash; + kit_http1_str_map_t parameters; +} kit_http1_uri_t; + +typedef struct { + i8 success; + kit_str_builder_t protocol; + kit_str_builder_t response; + kit_str_builder_t response_str; + kit_http1_str_map_t header; + kit_str_builder_t header_str; + kit_str_builder_t body; +} kit_http1_response_t; + +#ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +#endif + +static kit_str_t kit_http1_tok_tail(kit_http1_tok_t *tok) { + assert(tok != NULL); + + if (tok == NULL) + return (kit_str_t) { .size = 0, .values = NULL }; + + i64 previous_position = tok->position; + tok->position = tok->str.size; + + return (kit_str_t) { .size = tok->position - previous_position, + .values = tok->str.values + + previous_position }; +} + +static kit_str_t kit_http1_tok_next(kit_http1_tok_t *tok, + kit_str_t search, + i8 return_tail) { + assert(tok != NULL); + if (tok == NULL) + return (kit_str_t) { .size = 0, .values = NULL }; + + i64 hit = tok->position; + + while (hit + search.size <= tok->str.size) { + kit_str_t s = { .size = search.size, + .values = tok->str.values + hit }; + if (KIT_AR_EQUAL(s, search)) + break; + } + + if (hit + search.size > tok->str.size) { + if (return_tail) + return kit_http1_tok_tail(tok); + else + return (kit_str_t) { .size = 0, .values = NULL }; + } + + i64 previous_position = tok->position; + tok->position = hit + search.size; + + return (kit_str_t) { .size = hit - previous_position, + .values = tok->str.values + + previous_position }; +} + +// TODO +// - Return error status +static void kit_http1_uri_init(kit_http1_uri_t *uri, kit_str_t input, + kit_allocator_t *alloc) { + static const kit_str_t port_80 = { .size = 2, .values = "80" }; + + assert(uri != NULL); + if (uri == NULL) + return; + + memset(uri, 0, sizeof *uri); + + kit_http1_tok_t input_tok = { .str = input, .position = 0 }; + + uri->protocol = kit_http1_tok_next(&input_tok, SZ("://"), 0); + kit_str_t host_port_str = kit_http1_tok_next(&input_tok, SZ("/"), + 0); + + // FIXME + // Handle invalid host port error + assert(host_port_str.size > 0); + if (host_port_str.size == 0) + return; + + kit_http1_tok_t host_port_tok = { .str = host_port_str, + .position = 0 }; + + uri->host = kit_http1_tok_next( + &host_port_tok, + host_port_str.values[0] == '[' ? SZ("]:") : SZ(":"), 1); + + if (uri->host.values[0] == '[') + uri->host = (kit_str_t) { .size = uri->host.size - 1, + .values = uri->host.values + 1 }; + + // TODO + // - HTTPS default port 443 + uri->port = kit_http1_tok_tail(&host_port_tok); + if (uri->port.size == 0) + uri->port = port_80; + + uri->address = kit_http1_tok_next(&input_tok, SZ("?"), 1); + uri->query_string = kit_http1_tok_next(&input_tok, SZ("#"), 1); + + uri->hash = kit_http1_tok_tail(&input_tok); + + KIT_DA_INIT(uri->parameters, 0, alloc); + + kit_http1_tok_t query_tok = { + .str = { .size = uri->query_string.size, + .values = uri->query_string.values }, + .position = 0 + }; + + for (;;) { + kit_str_t key = kit_http1_tok_next(&query_tok, SZ("="), 0); + if (key.size == 0) + break; + kit_str_t value = kit_http1_tok_next(&query_tok, SZ("&"), 1); + + i64 index = uri->parameters.size; + + KIT_DA_RESIZE(uri->parameters, index + 1); + + assert(uri->parameters.size == index + 1); + if (uri->parameters.size != index + 1) + // FIXME + // Handle bad alloc error + break; + + uri->parameters.values[index] = (kit_http1_str_pair_t) { + .key = key, .value = value + }; + } +} + +static void kit_http1_uri_destroy(kit_http1_uri_t *uri) { + assert(uri != NULL); + if (uri == NULL) + return; + + KIT_DA_DESTROY(uri->parameters); + + memset(uri, 0, sizeof *uri); +} + +static kit_str_t kit_http1_method_to_str(i32 method) { + static kit_str_t methods[] = { { .size = 7, .values = "OPTIONS" }, + { .size = 3, .values = "GET" }, + { .size = 4, .values = "HEAD" }, + { .size = 4, .values = "POST" }, + { .size = 3, .values = "PUT" }, + { .size = 6, .values = "DELETE" }, + { .size = 5, .values = "TRACE" }, + { .size = 7, .values = "CONNECT" } }; + + assert(method >= 0 && method < (i32) (sizeof methods / sizeof *methods)); + if (method < 0 || method >= (i32) (sizeof methods / sizeof *methods)) + return (kit_str_t) { .size = 0, .values = NULL }; + + return methods[method]; +} + +// TODO +// - Return error status +static socket_t kit_http1_connect_to_uri(kit_http1_uri_t *uri) { + assert(uri != NULL); + if (uri == NULL) + return INVALID_SOCKET; + + struct addrinfo hints, *result, *rp; + + memset(&hints, 0, sizeof hints); + + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + char host_str[128]; + char port_str[128]; + + assert(uri->host.size < (i64) sizeof host_str); + memcpy(host_str, uri->host.values, uri->host.size); + host_str[uri->host.size] = '\0'; + + assert(uri->port.size < (i64) sizeof port_str); + memcpy(port_str, uri->port.values, uri->port.size); + port_str[uri->port.size] = '\0'; + + i32 getaddrinfo_result = getaddrinfo(host_str, port_str, &hints, + &result); + + if (getaddrinfo_result != 0) + return INVALID_SOCKET; + + socket_t fd = INVALID_SOCKET; + + for (rp = result; rp != NULL; rp = rp->ai_next) { + fd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + + if (fd == INVALID_SOCKET) + continue; + + i32 connect_result = connect(fd, rp->ai_addr, + (socklen_t) rp->ai_addrlen); + + if (connect_result == -1) { + closesocket(fd); + fd = INVALID_SOCKET; + continue; + } + + break; + } + + freeaddrinfo(result); + + return fd; +} + +// TODO +// - Return error status +static kit_str_builder_t kit_http1_buffered_read( + socket_t fd, kit_allocator_t *alloc) { + kit_str_builder_t buf; + KIT_DA_INIT(buf, KIT_HTTP1_BUFFER_SIZE, alloc); + + // FIXME + // Handle bad alloc error + assert(buf.size == KIT_HTTP1_BUFFER_SIZE); + if (buf.size != KIT_HTTP1_BUFFER_SIZE) + return buf; + + i64 offset = 0; + + for (;;) { + i64 chunk = buf.size - offset; + i64 n = recv(fd, buf.values + offset, (socklen_t) chunk, 0); + if (n < chunk) + break; + offset += n; + KIT_DA_RESIZE(buf, offset + KIT_HTTP1_BUFFER_SIZE); + + // FIXME + // Handle bad alloc error + assert(buf.size == offset + KIT_HTTP1_BUFFER_SIZE); + if (buf.size != offset + KIT_HTTP1_BUFFER_SIZE) + break; + } + + return buf; +} + +// TODO +// - Return error status +static kit_http1_response_t kit_http1_request( + i32 method, kit_http1_uri_t *uri, kit_str_t body, + kit_allocator_t *alloc) { + + socket_t fd = kit_http1_connect_to_uri(uri); + + assert(fd != INVALID_SOCKET); + if (fd == INVALID_SOCKET) { + kit_http1_response_t res; + memset(&res, 0, sizeof res); + res.success = 0; + return res; + } + + kit_str_builder_t req; + + // reserve + KIT_DA_INIT(req, 512, alloc); + + assert(req.size == 512); + if (req.size != 512) { + // bad alloc + // + + closesocket(fd); + + kit_http1_response_t res; + memset(&res, 0, sizeof res); + res.success = 0; + return res; + } + + req.size = 0; + + // FIXME + // Handle errors + // + + kit_str_append(&req, kit_http1_method_to_str(method)); + kit_str_append(&req, SZ(" /")); + kit_str_append(&req, uri->address); + kit_str_append(&req, + uri->query_string.size == 0 ? SZ("") : SZ("?")); + kit_str_append(&req, uri->query_string); + kit_str_append(&req, SZ(" HTTP/1.1")); + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + + kit_str_append(&req, SZ("Host: ")); + kit_str_append(&req, uri->host); + kit_str_append(&req, SZ(":")); + kit_str_append(&req, uri->port); + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + + kit_str_append(&req, SZ("Accept: */*")); + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + + kit_str_append( + &req, + SZ("Content-Type: text/plain; version=0.0.4; charset=utf-8")); + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + + // FIXME + // Use our own print instead + char content_length_str[11]; + sprintf(content_length_str, "%lld", body.size); + + kit_str_append(&req, SZ("Content-Length: ")); + kit_str_append(&req, + (kit_str_t) { .size = strlen(content_length_str), + .values = content_length_str }); + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + + kit_str_append(&req, SZ(KIT_HTTP1_NEWLINE)); + kit_str_append(&req, body); + + // Append '\0' at the end + // + { + i64 n = req.size; + KIT_DA_RESIZE(req, n + 1); + + assert(req.size == n + 1); + if (req.size != n + 1) { + KIT_DA_DESTROY(req); + closesocket(fd); + + kit_http1_response_t res; + memset(&res, 0, sizeof res); + res.success = 0; + return res; + } + + req.size = n; + req.values[n] = '\0'; + } + + i64 req_size = req.size; + i64 n = send(fd, req.values, (socklen_t) req.size, 0); + + KIT_DA_DESTROY(req); + + if (n != req_size) { + // send failed + // + + closesocket(fd); + + kit_http1_response_t res; + memset(&res, 0, sizeof res); + res.success = 0; + return res; + } + + kit_str_builder_t buffer = kit_http1_buffered_read(fd, alloc); + + closesocket(fd); + + kit_http1_response_t res; + memset(&res, 0, sizeof res); + res.success = 1; + + kit_http1_tok_t buf_tok = { .str = { .size = buffer.size, + .values = buffer.values }, + .position = 0 }; + + res.protocol = kit_str_build( + kit_http1_tok_next(&buf_tok, SZ(KIT_HTTP1_SPACE), 0), alloc); + res.response = kit_str_build( + kit_http1_tok_next(&buf_tok, SZ(KIT_HTTP1_SPACE), 0), alloc); + res.response_str = kit_str_build( + kit_http1_tok_next(&buf_tok, SZ(KIT_HTTP1_NEWLINE), 0), alloc); + + res.header_str = kit_str_build( + kit_http1_tok_next(&buf_tok, + SZ(KIT_HTTP1_NEWLINE KIT_HTTP1_NEWLINE), 0), + alloc); + + res.body = kit_str_build(kit_http1_tok_tail(&buf_tok), alloc); + + kit_http1_tok_t header_tok = { + .str = (kit_str_t) { .size = res.header_str.size, + .values = res.header_str.values }, + .position = 0 + }; + + KIT_DA_INIT(res.header, 0, alloc); + + for (;;) { + kit_str_t key = kit_http1_tok_next( + &header_tok, SZ(KIT_HTTP1_HEADER_SEPARATOR), 0); + if (key.size == 0) + break; + kit_str_t value = kit_http1_tok_next(&header_tok, + SZ(KIT_HTTP1_NEWLINE), 1); + + i64 index = res.header.size; + + KIT_DA_RESIZE(res.header, index + 1); + + assert(res.header.size == index + 1); + if (res.header.size != index + 1) { + // FIXME + // Handle bad alloc error + res.success = 0; + break; + } + + res.header.values[index] = (kit_http1_str_pair_t) { + .key = key, .value = value + }; + } + + return res; +} + +static void kit_http1_response_destroy( + kit_http1_response_t *response) { + assert(response != NULL); + if (response == NULL) + return; + + KIT_DA_DESTROY(response->protocol); + KIT_DA_DESTROY(response->response); + KIT_DA_DESTROY(response->response_str); + KIT_DA_DESTROY(response->header); + KIT_DA_DESTROY(response->header_str); + KIT_DA_DESTROY(response->body); + + memset(response, 0, sizeof *response); +} + +#ifdef __GNUC__ +# pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/input_buffer.c b/kit/input_buffer.c new file mode 100644 index 0000000..1f3e274 --- /dev/null +++ b/kit/input_buffer.c @@ -0,0 +1,360 @@ +#include "input_buffer.h" + +#include +#include + +enum { KIT_IB_CACHE_SIZE = 256 }; + +static s32 kit_buf_adjust_(kit_input_buffer_t *buf, i64 size) { + assert(buf != NULL); + assert(size >= 0); + + if (buf == NULL) + return KIT_ERROR_INTERNAL; + + i64 offset = buf->data.size; + + if (offset >= size) + return KIT_OK; + + DA_RESIZE(buf->data, size); + if (buf->data.size != size) + return KIT_ERROR_OUT_OF_MEMORY; + + str_t destination = { .size = size - offset, + .values = buf->data.values + offset }; + i64 n = IS_READ(buf->upstream, destination); + + DA_RESIZE(buf->data, offset + n); + if (buf->data.size != offset + n) + return KIT_ERROR_OUT_OF_MEMORY; + + return KIT_OK; +} + +kit_input_buffer_t kit_ib_init(is_handle_t upstream, + kit_allocator_t *alloc) { + kit_input_buffer_t buf; + memset(&buf, 0, sizeof buf); + + buf.upstream = upstream; + DA_INIT(buf.data, 0, alloc); + + return buf; +} + +void kit_ib_destroy(kit_input_buffer_t *buf) { + assert(buf != NULL); + if (buf == NULL) + return; + + DA_DESTROY(buf->data); + memset(buf, 0, sizeof *buf); +} + +kit_ib_token_t kit_ib_token(kit_input_buffer_t *buf) { + return (kit_ib_token_t) { + .status = KIT_OK, .offset = 0, .size = 0, .buffer = buf + }; +} + +kit_str_t kit_ib_str(kit_ib_token_t tok) { + assert(tok.buffer != NULL); + + if (tok.buffer == NULL || tok.buffer->data.values == NULL) + return (str_t) { .size = 0, .values = NULL }; + + return (str_t) { .size = tok.size, + .values = tok.buffer->data.values + tok.offset }; +} + +kit_ib_token_t kit_ib_read(kit_ib_token_t tok, i64 size) { + assert(tok.buffer != NULL); + + kit_ib_token_t next = tok; + + next.offset = tok.offset + tok.size; + next.size = 0; + + if (tok.status != KIT_OK) + return next; + + if (tok.buffer == NULL) { + next.status = KIT_ERROR_INVALID_ARGUMENT; + return next; + } + + s32 s = kit_buf_adjust_(tok.buffer, tok.offset + tok.size + size); + + if (s != KIT_OK) { + next.status = s; + return next; + } + + assert(tok.buffer->data.values != NULL); + + if (tok.buffer->data.values == NULL) { + next.status = KIT_ERROR_INTERNAL; + return next; + } + + next.size = size < tok.buffer->data.size - tok.offset - tok.size + ? size + : tok.buffer->data.size - tok.offset - tok.size; + + return next; +} + +#define IB_CACHE_INIT_(res_) \ + str_builder_t cache_dynamic; \ + memset(&cache_dynamic, 0, sizeof cache_dynamic); \ + char cache_static[KIT_IB_CACHE_SIZE]; \ + \ + do { \ + if (data.size > 0) { \ + if (data.size < KIT_IB_CACHE_SIZE) { \ + memcpy(cache_static, data.values, data.size); \ + data.values = cache_static; \ + } else { \ + DA_INIT(cache_dynamic, data.size, tok.buffer->data.alloc); \ + if (cache_dynamic.size != data.size) { \ + (res_).status |= KIT_ERROR_OUT_OF_MEMORY; \ + return (res_); \ + } \ + memcpy(cache_dynamic.values, data.values, data.size); \ + data.values = cache_dynamic.values; \ + } \ + } \ + } while (0) + +#define IB_CACHE_CLEANUP_() \ + do { \ + if (cache_dynamic.values != NULL) \ + DA_DESTROY(cache_dynamic); \ + } while (0) + +kit_ib_token_t kit_ib_any(kit_ib_token_t tok, str_t data) { + assert(tok.buffer != NULL); + + kit_ib_token_t next = tok; + + next.offset = tok.offset + tok.size; + next.size = 0; + + if (tok.status != KIT_OK) + return next; + + if (tok.buffer == NULL) { + next.status = KIT_ERROR_INVALID_ARGUMENT; + return next; + } + + IB_CACHE_INIT_(next); + + for (;; ++next.size) { + s32 s = kit_buf_adjust_(tok.buffer, + tok.offset + tok.size + next.size + 1); + + if (s != KIT_OK) { + next.status = s; + return next; + } + + assert(tok.buffer->data.values != NULL); + + if (tok.buffer->data.values == NULL) { + next.status = KIT_ERROR_INTERNAL; + return next; + } + + if (tok.offset + tok.size + next.size >= tok.buffer->data.size) + break; + + i8 found = 0; + + for (i64 i = 0; i < data.size; i++) + if (data.values[i] == + tok.buffer->data.values[next.offset + next.size]) { + found = 1; + break; + } + + if (!found) + break; + } + + IB_CACHE_CLEANUP_(); + + return next; +} + +kit_ib_token_t kit_ib_none(kit_ib_token_t tok, str_t data) { + assert(tok.buffer != NULL); + + kit_ib_token_t next = tok; + + next.offset = tok.offset + tok.size; + next.size = 0; + + if (tok.status != KIT_OK) + return next; + + if (tok.buffer == NULL) { + next.status = KIT_ERROR_INVALID_ARGUMENT; + return next; + } + + IB_CACHE_INIT_(next); + + for (;; ++next.size) { + s32 s = kit_buf_adjust_(tok.buffer, + tok.offset + tok.size + next.size + 1); + + if (s != KIT_OK) { + next.status = s; + return next; + } + + assert(tok.buffer->data.values != NULL); + + if (tok.buffer->data.values == NULL) { + next.status = KIT_ERROR_INTERNAL; + return next; + } + + if (tok.offset + tok.size + next.size >= tok.buffer->data.size) + break; + + i8 found = 0; + + for (i64 i = 0; i < data.size; i++) + if (data.values[i] == + tok.buffer->data.values[next.offset + next.size]) { + found = 1; + break; + } + + if (found) + break; + } + + IB_CACHE_CLEANUP_(); + + return next; +} + +kit_ib_token_t kit_ib_exact(kit_ib_token_t tok, str_t data) { + kit_ib_token_t res = tok; + + res.offset = tok.offset + tok.size; + res.size = 0; + + IB_CACHE_INIT_(res); + + res = kit_ib_read(tok, data.size); + if (!AR_EQUAL(kit_ib_str(res), data)) + res.status = KIT_PARSING_FAILED; + + IB_CACHE_CLEANUP_(); + + return res; +} + +kit_ib_token_t kit_ib_until(kit_ib_token_t tok, str_t data) { + assert(tok.buffer != NULL); + + kit_ib_token_t next = tok; + + next.offset = tok.offset + tok.size; + next.size = 0; + + if (tok.status != KIT_OK) + return next; + + if (tok.buffer == NULL) { + next.status = KIT_ERROR_INVALID_ARGUMENT; + return next; + } + + IB_CACHE_INIT_(next); + + for (;; ++next.size) { + s32 s = kit_buf_adjust_(tok.buffer, + tok.offset + tok.size + next.size + 1); + + if (s != KIT_OK) { + next.status = s; + return next; + } + + assert(tok.buffer->data.values != NULL); + + if (tok.buffer->data.values == NULL) { + next.status = KIT_ERROR_INTERNAL; + return next; + } + + if (tok.offset + tok.size + next.size >= tok.buffer->data.size) + break; + + if (next.size + 1 >= data.size && + AR_EQUAL(kit_str(data.size, tok.buffer->data.values + + (next.offset + next.size + 1 - + data.size)), + data)) { + next.size -= data.size - 1; + break; + } + } + + IB_CACHE_CLEANUP_(); + + return next; +} + +kit_ib_token_t kit_ib_while(kit_ib_token_t tok, + kit_ib_read_condition_fn condition, + void *context) { + assert(tok.buffer != NULL); + + kit_ib_token_t next = tok; + + next.offset = tok.offset + tok.size; + next.size = 0; + + if (tok.status != KIT_OK) + return next; + + if (tok.buffer == NULL) { + next.status = KIT_ERROR_INVALID_ARGUMENT; + return next; + } + + for (;; ++next.size) { + s32 s = kit_buf_adjust_(tok.buffer, + tok.offset + tok.size + next.size + 1); + + if (s != KIT_OK) { + next.status = s; + return next; + } + + assert(tok.buffer->data.values != NULL); + + if (tok.buffer->data.values == NULL) { + next.status = KIT_ERROR_INTERNAL; + return next; + } + + if (tok.offset + tok.size + next.size >= tok.buffer->data.size) + break; + + if (condition == NULL || + !condition(kit_str(next.size + 1, + tok.buffer->data.values + next.offset), + context)) + break; + } + + return next; +} diff --git a/kit/input_buffer.h b/kit/input_buffer.h new file mode 100644 index 0000000..2a490c0 --- /dev/null +++ b/kit/input_buffer.h @@ -0,0 +1,66 @@ +#ifndef KIT_INPUT_BUFFER_H +#define KIT_INPUT_BUFFER_H + +#include "string_builder.h" +#include "input_stream.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + kit_is_handle_t upstream; + kit_str_builder_t data; +} kit_input_buffer_t; + +typedef struct { + s32 status; + i64 offset; + i64 size; + kit_input_buffer_t *buffer; +} kit_ib_token_t; + +typedef b8 (*kit_ib_read_condition_fn)(kit_str_t data, void *context); + +kit_input_buffer_t kit_ib_init(kit_is_handle_t upstream, + kit_allocator_t *alloc); + +void kit_ib_destroy(kit_input_buffer_t *buf); + +kit_ib_token_t kit_ib_token(kit_input_buffer_t *buf); + +kit_str_t kit_ib_str(kit_ib_token_t tok); + +kit_ib_token_t kit_ib_read(kit_ib_token_t tok, i64 size); + +kit_ib_token_t kit_ib_any(kit_ib_token_t tok, kit_str_t data); + +kit_ib_token_t kit_ib_none(kit_ib_token_t tok, kit_str_t data); + +kit_ib_token_t kit_ib_exact(kit_ib_token_t tok, kit_str_t data); + +kit_ib_token_t kit_ib_until(kit_ib_token_t tok, kit_str_t data); + +kit_ib_token_t kit_ib_while(kit_ib_token_t buf, + kit_ib_read_condition_fn condition, + void *context); + +#ifdef __cplusplus +} +#endif + +#define input_buffer_t kit_input_buffer_t +#define ib_token_t kit_ib_token_t +#define ib_read_condition_fn kit_ib_read_condition_fn +#define ib_init kit_ib_init +#define ib_destroy kit_ib_destroy +#define ib_token kit_ib_token +#define ib_str kit_ib_str +#define ib_read kit_ib_read +#define ib_any kit_ib_any +#define ib_none kit_ib_none +#define ib_exact kit_ib_exact +#define ib_until kit_ib_until +#define ib_while kit_ib_while + +#endif diff --git a/kit/input_stream.c b/kit/input_stream.c new file mode 100644 index 0000000..369cf64 --- /dev/null +++ b/kit/input_stream.c @@ -0,0 +1,103 @@ +#include "input_stream.h" + +#include + +enum { KIT_INPUT_STREAM_STR, KIT_INPUT_STREAM_FILE }; + +typedef struct { + i64 type; + kit_allocator_t *alloc; +} kit_is_state_basic_t; + +typedef struct { + i64 type; + kit_allocator_t *alloc; + kit_str_t string; +} kit_is_state_str_t; + +typedef struct { + i64 type; + kit_allocator_t *alloc; + FILE *file; +} kit_is_state_file_t; + +static int kit_is_check_type_(void *state, i64 type) { + kit_is_state_basic_t *basic = (kit_is_state_basic_t *) state; + return basic != NULL && basic->type == type; +} + +static i64 kit_read_str_(void *state, kit_str_t destination) { + if (!kit_is_check_type_(state, KIT_INPUT_STREAM_STR)) + return 0; + + kit_is_state_str_t *str = (kit_is_state_str_t *) state; + i64 size = destination.size < str->string.size ? destination.size + : str->string.size; + memcpy(destination.values, str->string.values, size); + str->string.values += size; + str->string.size -= size; + return size; +} + +static i64 kit_read_file_(void *state, kit_str_t destination) { + if (!kit_is_check_type_(state, KIT_INPUT_STREAM_FILE)) + return 0; + + kit_is_state_file_t *f = (kit_is_state_file_t *) state; + + if (f->file == NULL || feof(f->file)) + return 0; + + i64 size = (i64) fread(destination.values, 1, destination.size, + f->file); + + if (size <= 0) + return 0; + + return size; +} + +kit_is_handle_t kit_is_wrap_string(kit_str_t string, + kit_allocator_t *alloc) { + kit_is_handle_t in; + memset(&in, 0, sizeof in); + + kit_is_state_str_t *state = (kit_is_state_str_t *) + kit_alloc_dispatch(alloc, KIT_ALLOCATE, + sizeof(kit_is_state_str_t), 0, NULL); + if (state != NULL) { + memset(state, 0, sizeof *state); + state->type = KIT_INPUT_STREAM_STR; + state->string = string; + state->alloc = alloc; + in.state = state; + in.read = kit_read_str_; + } + return in; +} + +kit_is_handle_t kit_is_wrap_file(FILE *f, kit_allocator_t *alloc) { + kit_is_handle_t in; + memset(&in, 0, sizeof in); + + kit_is_state_file_t *state = (kit_is_state_file_t *) + kit_alloc_dispatch(alloc, KIT_ALLOCATE, + sizeof(kit_is_state_file_t), 0, NULL); + + if (state != NULL) { + memset(state, 0, sizeof *state); + state->type = KIT_INPUT_STREAM_FILE; + state->file = f; + state->alloc = alloc; + in.state = state; + in.read = kit_read_file_; + } + + return in; +} + +void kit_is_destroy(kit_is_handle_t in) { + kit_is_state_basic_t *basic = (kit_is_state_basic_t *) in.state; + if (basic != NULL) + kit_alloc_dispatch(basic->alloc, KIT_DEALLOCATE, 0, 0, in.state); +} diff --git a/kit/input_stream.h b/kit/input_stream.h new file mode 100644 index 0000000..3442ee4 --- /dev/null +++ b/kit/input_stream.h @@ -0,0 +1,41 @@ +#ifndef KIT_INPUT_STREAM_H +#define KIT_INPUT_STREAM_H + +#include "allocator.h" +#include "string_ref.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef i64 (*kit_is_read_fn)(void *state, kit_str_t destination); + +typedef struct { + void *state; + kit_is_read_fn read; +} kit_is_handle_t; + +kit_is_handle_t kit_is_wrap_string(kit_str_t string, + kit_allocator_t *alloc); + +kit_is_handle_t kit_is_wrap_file(FILE *f, kit_allocator_t *alloc); + +void kit_is_destroy(kit_is_handle_t in); + +#define KIT_IS_READ(in, destination) \ + (in).read((in).state, (destination)) + +#ifdef __cplusplus +} +#endif + +#define is_read_fn kit_is_read_fn +#define is_handle_t kit_is_handle_t +#define is_wrap_string kit_is_wrap_string +#define is_wrap_file kit_is_wrap_file +#define is_destroy kit_is_destroy +#define IS_READ KIT_IS_READ + +#endif diff --git a/kit/lower_bound.h b/kit/lower_bound.h new file mode 100644 index 0000000..eb437ed --- /dev/null +++ b/kit/lower_bound.h @@ -0,0 +1,42 @@ +#ifndef KIT_LOWER_BOUND_H +#define KIT_LOWER_BOUND_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define KIT_LOWER_BOUND_INL(return_val, size, ...) \ + do { \ + i64 position_ = 0; \ + i64 count_ = (size); \ + while (count_ > 0) { \ + i64 delta_ = count_ / 2; \ + i64 index_ = position_ + delta_; \ + if (__VA_ARGS__) { \ + position_ += delta_ + 1; \ + count_ -= delta_ + 1; \ + } else \ + count_ = delta_; \ + } \ + (return_val) = position_; \ + } while (0) + +#define KIT_LOWER_BOUND(return_val, array, value, op) \ + KIT_LOWER_BOUND_INL(return_val, (array).size, \ + (op) ((array).values[index_], (value))) + +#define KIT_LOWER_BOUND_REF(return_val, array, value, op) \ + KIT_LOWER_BOUND_INL(return_val, (array).size, \ + (op) ((array).values + index_, (value))) + +#ifdef __cplusplus +} +#endif + +#define LOWER_BOUND_INL KIT_LOWER_BOUND_INL +#define LOWER_BOUND KIT_LOWER_BOUND +#define LOWER_BOUND_REF KIT_LOWER_BOUND_REF + +#endif diff --git a/kit/math.h b/kit/math.h new file mode 100644 index 0000000..d7044f1 --- /dev/null +++ b/kit/math.h @@ -0,0 +1,780 @@ +#ifndef KIT_MATH_H +#define KIT_MATH_H + +#include "types.h" + +#ifndef _USE_MATH_DEFINES +# define _USE_MATH_DEFINES +#endif +#include + +#include +#include + +// TODO +// - Gamma correction. +// - Custom prefixes +// - Unnecesary XYZ scaling. + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +#ifndef M_E +# define M_E 2.71828182845904523536 +#endif + +#ifndef KIT_VEC_TYPE +# define KIT_VEC_TYPE f32 +#endif + +#define KIT_EPSILON .00001 + +#define KIT_COLOR_REF_X 95.047f +#define KIT_COLOR_REF_Y 100.0f +#define KIT_COLOR_REF_Z 108.883f + +typedef KIT_VEC_TYPE vec_t; + +typedef struct { + vec_t v[2]; +} vec2_t; + +typedef struct { + vec_t v[3]; +} vec3_t; + +typedef struct { + vec_t v[4]; +} vec4_t, quat_t; + +typedef struct { + vec_t v[9]; +} mat3_t; + +typedef struct { + vec_t v[16]; +} mat4_t; + +#ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +static vec2_t vec2(vec_t x, vec_t y) { + vec2_t v = { { x, y } }; + return v; +} + +static vec3_t vec3(vec_t x, vec_t y, vec_t z) { + vec3_t v = { { x, y, z } }; + return v; +} + +static vec4_t vec4(vec_t x, vec_t y, vec_t z, vec_t w) { + vec4_t v = { { x, y, z, w } }; + return v; +} + +static mat3_t mat3( // + vec_t _00, vec_t _01, vec_t _02, // + vec_t _10, vec_t _11, vec_t _12, // + vec_t _20, vec_t _21, vec_t _22) { + mat3_t m = { { + _00, _01, _02, // + _10, _11, _12, // + _20, _21, _22 // + } }; + return m; +} + +static mat4_t mat4(vec_t _00, vec_t _01, vec_t _02, vec_t _03, + vec_t _10, vec_t _11, vec_t _12, vec_t _13, + vec_t _20, vec_t _21, vec_t _22, vec_t _23, + vec_t _30, vec_t _31, vec_t _32, vec_t _33) { + mat4_t m = { { + _00, _01, _02, _03, // + _10, _11, _12, _13, // + _20, _21, _22, _23, // + _30, _31, _32, _33 // + } }; + return m; +} + +static mat3_t vec3_to_mat3(vec3_t a, vec3_t b, vec3_t c) { + return mat3(a.v[0], a.v[1], a.v[2], // + b.v[0], b.v[1], b.v[2], // + c.v[0], c.v[1], c.v[2]); +} + +static mat4_t vec4_to_mat4(vec4_t a, vec4_t b, vec4_t c, vec4_t d) { + return mat4(a.v[0], a.v[1], a.v[2], a.v[3], // + b.v[0], b.v[1], b.v[2], b.v[3], // + c.v[0], c.v[1], c.v[2], c.v[3], // + d.v[0], d.v[1], d.v[2], d.v[3]); +} + +static mat4_t mat3_to_mat4(mat3_t a) { + return mat4(a.v[0], a.v[1], a.v[2], 0.f, // + a.v[3], a.v[4], a.v[5], 0.f, // + a.v[6], a.v[7], a.v[8], 0.f, // + 0.f, 0.f, 0.f, 1.f); +} + +static mat3_t mat4_to_mat3(mat4_t a) { + return mat3(a.v[0], a.v[1], a.v[2], // + a.v[4], a.v[5], a.v[6], // + a.v[8], a.v[9], a.v[10]); +} + +static quat_t quat(vec_t x, vec_t y, vec_t z, vec_t w) { + return vec4(x, y, z, w); +} + +static quat_t vec3_to_quat(vec3_t v, vec_t w) { + return quat(v.v[0], v.v[1], v.v[2], w); +} + +static vec3_t vec4_to_vec3(vec4_t a) { + return vec3(a.v[0], a.v[1], a.v[2]); +} + +static vec3_t quat_to_vec3(quat_t a) { + return vec4_to_vec3(a); +} + +static vec_t vec_abs(vec_t x) { + return fabs(x); +} + +static vec_t vec_min(vec_t x, vec_t y) { + return fmin(x, y); +} + +static vec_t vec_max(vec_t x, vec_t y) { + return fmax(x, y); +} + +static vec_t vec_clamp(vec_t x, vec_t x0, vec_t x1) { + return fmax(x0, fmin(x, x1)); +} + +static vec3_t vec3_clamp(vec3_t x, vec3_t x0, vec3_t x1) { + return vec3(vec_clamp(x.v[0], x0.v[0], x1.v[0]), + vec_clamp(x.v[1], x0.v[1], x1.v[1]), + vec_clamp(x.v[2], x0.v[2], x1.v[2])); +} + +static vec_t vec_sqrt(vec_t x) { + return sqrtf(x); +} + +static vec_t vec_pow(vec_t x, vec_t y) { + return powf(x, y); +} + +static vec_t vec_sin(vec_t x) { + return sinf(x); +} + +static vec_t vec_cos(vec_t x) { + return cosf(x); +} + +static vec_t vec_asin(vec_t x) { + return asinf(x); +} + +static vec_t vec_acos(vec_t x) { + return acosf(x); +} + +static vec_t vec_atan(vec_t x) { + return atanf(x); +} + +static vec_t vec_atan2(vec_t y, vec_t x) { + return atan2f(y, x); +} + +static vec3_t vec3_neg(vec3_t a) { + return vec3(-a.v[0], -a.v[1], -a.v[2]); +} + +static vec3_t vec3_add(vec3_t a, vec3_t b) { + return vec3(a.v[0] + b.v[0], a.v[1] + b.v[1], a.v[2] + b.v[2]); +} + +static vec3_t vec3_add3(vec3_t a, vec3_t b, vec3_t c) { + return vec3(a.v[0] + b.v[0] + c.v[0], a.v[1] + b.v[1] + c.v[1], + a.v[2] + b.v[2] + c.v[2]); +} + +static vec3_t vec3_sub(vec3_t a, vec3_t b) { + return vec3(a.v[0] - b.v[0], a.v[1] - b.v[1], a.v[2] - b.v[2]); +} + +static vec3_t vec3_mul(vec3_t v, vec_t x) { + return vec3(v.v[0] * x, v.v[1] * x, v.v[2] * x); +} + +static vec_t vec3_dot(vec3_t a, vec3_t b) { + return a.v[0] * b.v[0] + a.v[1] * b.v[1] + a.v[2] * b.v[2]; +} + +static vec3_t vec3_cross(vec3_t a, vec3_t b) { + return vec3(a.v[1] * b.v[2] - a.v[2] * b.v[1], // + a.v[2] * b.v[0] - a.v[0] * b.v[2], // + a.v[0] * b.v[1] - a.v[1] * b.v[0]); +} + +static vec3_t vec3_normal(vec3_t v) { + vec_t x = v.v[0]; + vec_t y = v.v[1]; + vec_t z = v.v[2]; + + vec_t length_squared = x * x + y * y + z * z; + assert(length_squared >= KIT_EPSILON); + + if (length_squared < KIT_EPSILON) { + vec3_t n = { { 0.f, 0.f, 1.f } }; + return n; + } + + vec_t length = vec_sqrt(length_squared); + vec3_t n = { { x / length, y / length, z / length } }; + + return n; +} + +static vec4_t vec4_neg(vec4_t a) { + return vec4(-a.v[0], -a.v[1], -a.v[2], -a.v[3]); +} + +static vec4_t vec4_add(vec4_t a, vec4_t b) { + return vec4(a.v[0] + b.v[0], a.v[1] + b.v[1], a.v[2] + b.v[2], + a.v[3] + b.v[3]); +} + +static vec4_t vec4_mul(vec4_t v, vec_t x) { + return vec4(v.v[0] * x, v.v[1] * x, v.v[2] * x, v.v[3] * x); +} + +static vec4_t vec4_div(vec4_t v, vec_t x) { + assert(x < KIT_EPSILON); + assert(x > -KIT_EPSILON); + + if (x >= -KIT_EPSILON || x < KIT_EPSILON) + return vec4(0.f, 0.f, 0.f, 0.f); + + return vec4(v.v[0] / x, v.v[1] / x, v.v[2] / x, v.v[3] / x); +} + +static vec_t vec4_dot(vec4_t a, vec4_t b) { + return a.v[0] * b.v[0] + a.v[1] * b.v[1] + a.v[2] * b.v[2] + + a.v[3] * b.v[3]; +} + +static vec4_t vec4_normal(vec4_t v) { + vec_t x = v.v[0]; + vec_t y = v.v[1]; + vec_t z = v.v[2]; + vec_t w = v.v[3]; + + vec_t length_squared = x * x + y * y + z * z + w * w; + assert(length_squared >= KIT_EPSILON); + + if (length_squared < KIT_EPSILON) { + vec4_t n = { { 0.f, 0.f, 0.f, 1.f } }; + return n; + } + + vec_t length = vec_sqrt(length_squared); + vec4_t n = { { x / length, y / length, z / length, w / length } }; + + return n; +} + +static quat_t quat_conjugate(quat_t q) { + return quat(-q.v[0], -q.v[1], -q.v[2], q.v[3]); +} + +static quat_t quat_normal(quat_t q) { + return vec4_normal(q); +} + +static quat_t quat_mul(quat_t left, quat_t right) { + vec_t i0 = left.v[0]; + vec_t j0 = left.v[1]; + vec_t k0 = left.v[2]; + vec_t r0 = left.v[3]; + + vec_t i1 = right.v[0]; + vec_t j1 = right.v[1]; + vec_t k1 = right.v[2]; + vec_t r1 = right.v[3]; + + quat_t q = { { r0 * i1 + i0 * r1 + j0 * k1 - k0 * j1, // + r0 * j1 - i0 * k1 + j0 * r1 + k0 * i1, // + r0 * k1 + i0 * j1 - j0 * i1 + k0 * r1, // + r0 * r1 - i0 * i1 - j0 * j1 - k0 * k1 } }; + + return q; +} + +static quat_t quat_rotation(vec_t angle, vec3_t axis) { + vec_t s = vec_sin(angle / 2.f); + vec_t c = vec_cos(angle / 2.f); + + vec_t x = axis.v[0]; + vec_t y = axis.v[1]; + vec_t z = axis.v[2]; + + quat_t q = { { x * s, y * s, z * s, c } }; + + return q; +} + +static mat3_t mat3_transpose(mat3_t m) { + return mat3(m.v[0], m.v[3], m.v[6], // + m.v[1], m.v[4], m.v[7], // + m.v[2], m.v[5], m.v[8]); +} + +static mat4_t mat4_transpose(mat4_t m) { + return mat4(m.v[0], m.v[4], m.v[8], m.v[12], // + m.v[1], m.v[5], m.v[9], m.v[13], // + m.v[2], m.v[6], m.v[10], m.v[14], // + m.v[3], m.v[7], m.v[11], m.v[15]); +} + +static mat3_t mat3_look_at(vec3_t direction, vec3_t up) { + vec3_t f = vec3_normal(vec3_neg(direction)); + vec3_t s = vec3_normal(vec3_cross(f, up)); + vec3_t u = vec3_cross(s, f); + + return mat3(s.v[0], u.v[0], f.v[0], // + s.v[1], u.v[1], f.v[1], // + s.v[2], u.v[2], f.v[2]); +} + +static vec3_t vec3_rotate(vec3_t v, quat_t rotation) { + vec3_t u = vec3(rotation.v[0], rotation.v[1], rotation.v[2]); + vec_t s = rotation.v[3]; + + return vec3_add3(vec3_mul(u, 2.f * vec3_dot(u, v)), + vec3_mul(v, s * s - vec3_dot(u, u)), + vec3_mul(vec3_cross(u, v), 2.f * s)); +} + +static mat3_t quat_to_mat3(quat_t q) { + vec_t xx = q.v[0] * q.v[0]; + vec_t yy = q.v[1] * q.v[1]; + vec_t zz = q.v[2] * q.v[2]; + vec_t xz = q.v[0] * q.v[2]; + vec_t xy = q.v[0] * q.v[1]; + vec_t yz = q.v[1] * q.v[2]; + vec_t wx = q.v[3] * q.v[0]; + vec_t wy = q.v[3] * q.v[1]; + vec_t wz = q.v[3] * q.v[2]; + + return mat3(1.f - 2.f * (yy + zz), // + 2.f * (xy + wz), // + 2.f * (xz - wy), // + 2.f * (xy - wz), // + 1.f - 2.f * (xx + zz), // + 2.f * (yz + wx), // + 2.f * (xz + wy), // + 2.f * (yz - wx), // + 1.f - 2.f * (xx + yy)); +} + +static quat_t mat3_to_quat(mat3_t m) { + vec_t a = m.v[0] - m.v[4] - m.v[8]; + vec_t b = m.v[4] - m.v[0] - m.v[8]; + vec_t c = m.v[8] - m.v[0] - m.v[4]; + vec_t d = m.v[0] + m.v[4] + m.v[8]; + + int n = 0; + vec_t h = d; + if (a > h) { + h = a; + n = 1; + } + if (b > h) { + h = b; + n = 2; + } + if (c > h) { + h = c; + n = 3; + } + + vec_t s = vec_sqrt(h + 1.f) * .5f; + vec_t k = .25f / s; + + switch (n) { + case 0: + return quat((m.v[5] - m.v[7]) * k, // + (m.v[6] - m.v[2]) * k, // + (m.v[1] - m.v[3]) * k, // + s); + case 1: + return quat(s, // + (m.v[1] + m.v[3]) * k, // + (m.v[6] + m.v[2]) * k, // + (m.v[5] - m.v[7]) * k); + case 2: + return quat((m.v[1] + m.v[3]) * k, // + s, // + (m.v[5] + m.v[7]) * k, // + (m.v[6] - m.v[2]) * k); + case 3: + return quat((m.v[6] + m.v[2]) * k, // + (m.v[5] + m.v[7]) * k, // + s, // + (m.v[1] - m.v[3]) * k); + default:; + } + + assert(0); + return quat(0.f, 0.f, 0.f, 1.f); +} + +static quat_t quat_look_at(vec3_t direction, vec3_t up) { + vec3_t z = vec3_normal(vec3_neg(direction)); + vec3_t right = vec3_cross(up, z); + vec3_t x = vec3_mul( + right, + 1.f / vec_sqrt(vec_max(KIT_EPSILON, vec3_dot(right, right)))); + vec3_t y = vec3_cross(z, x); + + return mat3_to_quat(vec3_to_mat3(x, y, z)); +} + +static mat3_t mat3_mul(mat3_t left, mat3_t right) { + mat3_t m; + memset(&m, 0, sizeof m); + + for (int j = 0; j < 3; j++) + for (int i = 0; i < 3; i++) + for (int k = 0; k < 3; k++) + m.v[j * 3 + i] += left.v[k * 3 + i] * right.v[j * 3 + k]; + + return m; +} + +static mat4_t mat4_mul(mat4_t left, mat4_t right) { + mat4_t m; + memset(&m, 0, sizeof m); + + for (int j = 0; j < 4; j++) + for (int i = 0; i < 4; i++) + for (int k = 0; k < 4; k++) + m.v[j * 4 + i] += left.v[k * 4 + i] * right.v[j * 4 + k]; + + return m; +} + +static mat4_t mat4_move(vec3_t offset) { + vec_t x = offset.v[0]; + vec_t y = offset.v[1]; + vec_t z = offset.v[2]; + + return mat4(1.f, 0.f, 0.f, 0.f, // + 0.f, 1.f, 0.f, 0.f, // + 0.f, 0.f, 1.f, 0.f, // + x, y, z, 1.f); +} + +static mat4_t mat4_scale(vec3_t scale) { + vec_t x = scale.v[0]; + vec_t y = scale.v[1]; + vec_t z = scale.v[2]; + + return mat4(x, 0.f, 0.f, 0.f, // + 0.f, y, 0.f, 0.f, // + 0.f, 0.f, z, 0.f, // + 0.f, 0.f, 0.f, 1.f); +} + +static mat4_t mat4_frustum(vec_t left, vec_t right, vec_t bottom, + vec_t top, vec_t znear, vec_t zfar) { + vec_t t0 = 2.f * znear; + vec_t t1 = right - left; + vec_t t2 = top - bottom; + vec_t t3 = zfar - znear; + + return mat4(t0 / t1, // + 0.f, // + 0.f, // + 0.f, // + 0.f, // + t0 / t2, // + 0.f, // + 0.f, // + (right + left) / t1, // + (top + bottom) / t2, // + (-zfar - znear) / t3, // + -1.f, // + 0.f, // + 0.f, // + (-t0 * zfar) / t3, // + 0.f); +} + +static mat4_t mat4_perspective(vec_t fovy, vec_t aspect_ratio_, + vec_t znear, vec_t zfar) { + vec_t ymax = znear * tanf(fovy); + vec_t xmax = ymax * aspect_ratio_; + + return mat4_frustum(-xmax, xmax, -ymax, ymax, znear, zfar); +} + +static vec_t vec_lerp(vec_t x0, vec_t x1, vec_t t) { + assert(t >= 0.f); + assert(t <= 1.f); + + if (t <= 0.f) + return x0; + if (t >= 1.f) + return x1; + + return x0 + (x1 - x0) * t; +} + +static vec3_t vec3_lerp(vec3_t x0, vec3_t x1, vec_t t) { + return vec3(vec_lerp(x0.v[0], x1.v[0], t), + vec_lerp(x0.v[1], x1.v[1], t), + vec_lerp(x0.v[2], x1.v[2], t)); +} + +static vec4_t vec4_lerp(vec4_t x0, vec4_t x1, vec_t t) { + return vec4( + vec_lerp(x0.v[0], x1.v[0], t), vec_lerp(x0.v[1], x1.v[1], t), + vec_lerp(x0.v[2], x1.v[2], t), vec_lerp(x0.v[3], x1.v[3], t)); +} + +static quat_t quat_slerp(quat_t q0, quat_t q1, vec_t t) { + assert(t >= 0.f); + assert(t <= 1.f); + + if (t <= 0.f) + return q0; + if (t >= 1.f) + return q1; + + quat_t q = q1; + + vec_t cos_theta = vec4_dot(q0, q1); + + if (cos_theta < 0.f) { + q = vec4_neg(q1); + cos_theta = -cos_theta; + } + + if (cos_theta > 1.f - KIT_EPSILON) + return vec4_lerp(q0, q1, t); + + vec_t angle = vec_acos(cos_theta); + + return vec4_div(vec4_add(vec4_mul(q0, vec_sin((1.f - t) * angle)), + vec4_mul(q, vec_sin(t * angle))), + vec_sin(angle)); +} + +static vec3_t rgb_to_xyz(vec3_t rgb) { + // FIXME + // Remove unnecessary x100 scaling. + // + + vec_t red = rgb.v[0]; + vec_t green = rgb.v[1]; + vec_t blue = rgb.v[2]; + + // Gamma correction + // + /* + if (red > 0.04045f) + red = vec_pow(((red + 0.055f) / 1.055f), 2.4f); + else + red = red / 12.92f; + + if (green > 0.04045f) + green = vec_pow(((green + 0.055f) / 1.055f), 2.4f); + else + green = green / 12.92f; + + if (blue > 0.04045f) + blue = vec_pow(((blue + 0.055f) / 1.055f), 2.4f); + else + blue = blue / 12.92f; + */ + + red = red * 100.f; + green = green * 100.f; + blue = blue * 100.f; + + return vec3(red * 0.4124f + green * 0.3576f + blue * 0.1805f, + red * 0.2126f + green * 0.7152f + blue * 0.0722f, + red * 0.0193f + green * 0.1192f + blue * 0.9505f); +} + +static vec3_t xyz_to_rgb(vec3_t xyz) { + // FIXME + // Remove unnecessary x100 scaling. + // + + vec_t x = xyz.v[0] / 100.f; + vec_t y = xyz.v[1] / 100.f; + vec_t z = xyz.v[2] / 100.f; + + vec_t red = x * 3.2406f + (y * -1.5372f) + z * (-0.4986f); + vec_t green = x * (-0.9689f) + y * 1.8758f + z * 0.0415f; + vec_t blue = x * 0.0557f + y * (-0.2040f) + z * 1.0570f; + + // Gamma correction + // + /* + if (red > 0.0031308f) + red = 1.055f * vec_pow(red, (1.0f / 2.4)) - 0.055f; + else + red = 12.92f * red; + + if (green > 0.0031308f) + green = 1.055f * vec_pow(green, (1.0f / 2.4)) - 0.055f; + else + green = 12.92f * green; + + if (blue > 0.0031308f) + blue = 1.055f * vec_pow(blue, (1.0f / 2.4)) - 0.055f; + else + blue = 12.92f * blue; + */ + + return vec3_clamp(vec3(red, green, blue), vec3(0.f, 0.f, 0.f), + vec3(1.f, 1.f, 1.f)); +} + +static vec3_t lab_to_xyz(vec3_t lab) { + // FIXME + // Remove unnecessary x100 scaling. + // + + vec_t lightness = lab.v[0]; + vec_t a = lab.v[1]; + vec_t b = lab.v[2]; + + vec_t y = (lightness + 16.f) / 116.f; + vec_t x = (a / 500.f) + y; + vec_t z = y - (b / 200.f); + + if (vec_pow(y, 3.f) > 0.008856) + y = vec_pow(y, 3.f); + else + y = (y - (16.f / 116.f)) / 7.787f; + + if (vec_pow(x, 3.f) > 0.008856f) + x = vec_pow(x, 3.f); + else + x = (x - (16.f / 116.f)) / 7.787f; + + if (vec_pow(z, 3.f) > 0.008856f) + z = vec_pow(z, 3.f); + else + z = (z - (16.f / 116.f)) / 7.787f; + + return vec3(KIT_COLOR_REF_X * x, KIT_COLOR_REF_Y * y, + KIT_COLOR_REF_Z * z); +} + +static vec3_t xyz_to_lab(vec3_t xyz) { + // FIXME + // Remove unnecessary x100 scaling. + // + + vec_t x = (xyz.v[0] / KIT_COLOR_REF_X); + vec_t y = (xyz.v[1] / KIT_COLOR_REF_Y); + vec_t z = (xyz.v[2] / KIT_COLOR_REF_Z); + + if (x > 0.008856f) + x = vec_pow(x, (1.f / 3.f)); + else + x = (7.787f * x) + (16.f / 116.f); + + if (y > 0.008856f) + y = vec_pow(y, (1.f / 3.f)); + else + y = (7.787f * y) + (16.f / 116.f); + + if (z > 0.008856f) + z = vec_pow(z, (1.f / 3.f)); + else + z = (7.787f * z) + (16.f / 116.f); + + vec_t lightness = (116.f * y) - 16.f; + vec_t a = 500.f * (x - y); + vec_t b = 200.f * (y - z); + + return vec3(lightness, a, b); +} + +static vec3_t lab_to_lch(vec3_t lab) { + vec_t lightness = lab.v[0]; + vec_t a = lab.v[1]; + vec_t b = lab.v[2]; + + vec_t chroma = sqrtf(a * a + b * b); + vec_t hue = a == 0.f ? 0.f : vec_atan(b / a); + + return vec3(lightness, chroma, hue); +} + +static vec3_t lch_to_lab(vec3_t lch) { + vec_t lightness = lch.v[0]; + vec_t chroma = lch.v[1]; + vec_t hue = lch.v[2]; + + vec_t a = chroma * cos(hue); + vec_t b = chroma * sin(hue); + + return vec3(lightness, a, b); +} + +static vec3_t rgb_to_lch(vec3_t rgb) { + vec3_t xyz = rgb_to_xyz(rgb); + vec3_t lab = xyz_to_lab(xyz); + + return lab_to_lch(lab); +} + +static vec3_t lch_to_rgb(vec3_t lch) { + vec3_t lab = lch_to_lab(lch); + vec3_t xyz = lab_to_xyz(lab); + + return xyz_to_rgb(xyz); +} + +static vec4_t rgba_from_lcha(vec_t lightness, vec_t chroma, vec_t hue, + vec_t alpha) { + vec3_t rgb = lch_to_rgb(vec3(lightness, chroma, hue)); + return vec4(rgb.v[0], rgb.v[1], rgb.v[2], alpha); +} + +#ifdef __GNUC__ +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/mersenne_twister_64.c b/kit/mersenne_twister_64.c new file mode 100644 index 0000000..4032dc9 --- /dev/null +++ b/kit/mersenne_twister_64.c @@ -0,0 +1,66 @@ +#include "mersenne_twister_64.h" + +#define MM 156 +#define MATRIX_A 0xb5026f5aa96619e9ull +#define UM 0xffffffff80000000ull +#define LM 0x7fffffffull + +void kit_mt64_init_array(kit_mt64_state_t *state, i64 size, + u64 *seed) { + i64 i; + for (i = 0; i < size && i < KIT_MT64_N; i++) state->mt[i] = seed[i]; + for (state->index = size; state->index < KIT_MT64_N; state->index++) + state->mt[state->index] = (6364136223846793005ull * + (state->mt[state->index - 1] ^ + (state->mt[state->index - 1] >> + 62u)) + + state->index); +} + +void kit_mt64_init(kit_mt64_state_t *state, u64 seed) { + kit_mt64_init_array(state, 1, &seed); +} + +void kit_mt64_rotate(kit_mt64_state_t *state) { + static u64 mag01[2] = { 0ull, MATRIX_A }; + + u64 x; + i32 i; + + for (i = 0; i < KIT_MT64_N - MM; i++) { + x = (state->mt[i] & UM) | (state->mt[i + 1] & LM); + state->mt[i] = state->mt[i + MM] ^ (x >> 1u) ^ + mag01[(i32) (x & 1ull)]; + } + + for (; i < KIT_MT64_N - 1; i++) { + x = (state->mt[i] & UM) | (state->mt[i + 1] & LM); + state->mt[i] = state->mt[i + (MM - KIT_MT64_N)] ^ (x >> 1u) ^ + mag01[(i32) (x & 1ull)]; + } + + x = (state->mt[KIT_MT64_N - 1] & UM) | (state->mt[0] & LM); + state->mt[KIT_MT64_N - 1] = state->mt[MM - 1] ^ (x >> 1u) ^ + mag01[(i32) (x & 1ull)]; + + state->index = 0; +} + +u64 kit_mt64_generate(kit_mt64_state_t *state) { + if (state->index >= KIT_MT64_N) + kit_mt64_rotate(state); + + u64 x = state->mt[state->index++]; + + x ^= (x >> 29u) & 0x5555555555555555ull; + x ^= (x << 17u) & 0x71d67fffeda60000ull; + x ^= (x << 37u) & 0xfff7eee000000000ull; + x ^= (x >> 43u); + + return x; +} + +#undef MM +#undef MATRIX_A +#undef UM +#undef LM diff --git a/kit/mersenne_twister_64.h b/kit/mersenne_twister_64.h new file mode 100644 index 0000000..2709dd7 --- /dev/null +++ b/kit/mersenne_twister_64.h @@ -0,0 +1,35 @@ +#ifndef KIT_MERSENNE_TWISTER_64_H +#define KIT_MERSENNE_TWISTER_64_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + KIT_MT64_N = 312, +}; + +typedef struct { + u64 mt[KIT_MT64_N]; + u64 index; +} kit_mt64_state_t; + +void kit_mt64_init_array(kit_mt64_state_t *state, i64 size, + u64 *seed); +void kit_mt64_init(kit_mt64_state_t *state, u64 seed); +void kit_mt64_rotate(kit_mt64_state_t *state); +u64 kit_mt64_generate(kit_mt64_state_t *state); + +#ifdef __cplusplus +} +#endif + +#define mt64_state_t kit_mt64_state_t +#define mt64_init_array kit_mt64_init_array +#define mt64_init kit_mt64_init +#define mt64_rotate kit_mt64_rotate +#define mt64_generate kit_mt64_generate + +#endif diff --git a/kit/move_back.h b/kit/move_back.h new file mode 100644 index 0000000..1885f5d --- /dev/null +++ b/kit/move_back.h @@ -0,0 +1,49 @@ +#ifndef KIT_MOVE_BACK_H +#define KIT_MOVE_BACK_H + +#include "types.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define KIT_MOVE_BACK_INL(new_size, array, ...) \ + do { \ + i64 index_; \ + i64 end_ = (array).size; \ + u8 temp_[sizeof *(array).values]; \ + for (index_ = 0; index_ < end_;) { \ + if (__VA_ARGS__) { \ + end_--; \ + if (index_ != end_) { \ + memcpy(temp_, (array).values + end_, \ + sizeof *(array).values); \ + (array).values[end_] = (array).values[index_]; \ + memcpy((array).values + index_, temp_, \ + sizeof *(array).values); \ + } \ + } else \ + index_++; \ + } \ + (new_size) = end_; \ + } while (0) + +#define KIT_MOVE_BACK(new_size, array, value, cond) \ + KIT_MOVE_BACK_INL(new_size, array, \ + (cond) ((array).values[index_], (value))) + +#define KIT_MOVE_BACK_REF(new_size, array, value, cond) \ + KIT_MOVE_BACK_INL(new_size, array, \ + (cond) ((array).values + index_, (value))) + +#ifdef __cplusplus +} +#endif + +#define MOVE_BACK_INL KIT_MOVE_BACK_INL +#define MOVE_BACK KIT_MOVE_BACK +#define MOVE_BACK_REF KIT_MOVE_BACK_REF + +#endif diff --git a/kit/parse.c b/kit/parse.c new file mode 100644 index 0000000..042e2d0 --- /dev/null +++ b/kit/parse.c @@ -0,0 +1,2 @@ +#include "parse.h" + diff --git a/kit/parse.h b/kit/parse.h new file mode 100644 index 0000000..efb8156 --- /dev/null +++ b/kit/parse.h @@ -0,0 +1,14 @@ +#ifndef KIT_PARSE_H +#define KIT_PARSE_H + +#include "string_builder.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/print.c b/kit/print.c new file mode 100644 index 0000000..5c98910 --- /dev/null +++ b/kit/print.c @@ -0,0 +1,2 @@ +#include "print.h" + diff --git a/kit/print.h b/kit/print.h new file mode 100644 index 0000000..5a64a20 --- /dev/null +++ b/kit/print.h @@ -0,0 +1,47 @@ +#ifndef KIT_PRINT_H +#define KIT_PRINT_H + +#include "string_builder.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + KIT_PRINT_ALIGN_RIGHT = 1, + KIT_PRINT_UNSIGNED = (1 << 1), + KIT_PRINT_BIN = (1 << 2), + KIT_PRINT_OCT = (1 << 3), + KIT_PRINT_DEC = (1 << 4), + KIT_PRINT_HEX = (1 << 5), + KIT_PRINT_PRECISE = (1 << 6), + KIT_PRINT_UTF8 = (1 << 7), +}; + +s32 kit_print_int(kit_str_builder_t *s, i64 value, i64 width, c8 fill, + u32 flags); + +s32 kit_print_float(kit_str_builder_t *s, f64 value, i64 width, + c8 fill, u32 flags); + +s32 kit_print_esc(kit_str_builder_t *s, kit_str_t value, + c8 escape_char, kit_str_t special_symbols, + u32 flags); + +#ifdef __cplusplus +} +#endif + +#define PRINT_ALIGN_RIGHT KIT_PRINT_ALIGN_RIGHT +#define PRINT_UNSIGNED KIT_PRINT_UNSIGNED +#define PRINT_BIN KIT_PRINT_BIN +#define PRINT_OCT KIT_PRINT_OCT +#define PRINT_DEC KIT_PRINT_DEC +#define PRINT_HEX KIT_PRINT_HEX +#define PRINT_PRECISE KIT_PRINT_PRECISE +#define PRINT_UTF8 KIT_PRINT_UTF8 +#define print_int kit_print_int +#define print_float kit_print_float +#define print_esckit_print_esc + +#endif diff --git a/kit/process.h b/kit/process.h new file mode 100644 index 0000000..8031cc1 --- /dev/null +++ b/kit/process.h @@ -0,0 +1,71 @@ +// TODO +// + +#ifndef KIT_PROCESS_H +#define KIT_PROCESS_H + +#include "types.h" +#include "string_ref.h" + +#if !defined(_WIN32) || defined(__CYGWIN__) +# include +#else +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + KIT_PROCESS_NO_ARGUMENTS = 1, + KIT_PROCESS_NO_ENVIRONMENT = (1 << 1), + KIT_PROCESS_NO_PIPES = (1 << 2), + KIT_PROCESS_FORK = (1 << 3), +}; + +typedef struct { + s32 status; + u8 exit_code; + b8 current_is_forked; +#if !defined(_WIN32) || defined(__CYGWIN__) + b8 _ready; + b8 _running; + pid_t _id; + i32 _stdin; + i32 _stdout; + i32 _stderr; +#else +#endif +} kit_process_t; + +typedef struct { + kit_str_t name; + kit_str_t value; +} kit_process_env_var_t; + +typedef KIT_AR(kit_str_t) kit_process_args_t; +typedef KIT_AR(kit_process_env_var_t) kit_process_env_t; + +typedef struct { + u32 flags; + kit_str_t file_name; + kit_process_args_t command_line; + kit_process_env_t environment; + kit_str_t working_directory; +} kit_process_info_t; + +s32 kit_process_init(kit_process_t *p, kit_process_info_t info); +void kit_process_cleanup(kit_process_t *p); + +i64 kit_process_write_stdin(kit_process_t *p, kit_str_t in_data); +i64 kit_process_read_stdout(kit_process_t *p, kit_str_t out_data); +i64 kit_process_read_stderr(kit_process_t *p, kit_str_t out_data); +s32 kit_process_terminate(kit_process_t *p); +b8 kit_process_alive(kit_process_t *p); +s32 kit_process_wait(kit_process_t *p); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/process.posix.c b/kit/process.posix.c new file mode 100644 index 0000000..d9bec1f --- /dev/null +++ b/kit/process.posix.c @@ -0,0 +1,323 @@ +#include "process.h" + +#if !defined(_WIN32) || defined(__CYGWIN__) +# include "status.h" + +# include +# include +# include +# include + +static char *kit_process_argv_null_[] = { "", NULL }; +static char *kit_process_env_null_[] = { NULL }; + +static char *kit_process_str_(kit_str_t s) { + // FIXME + // + + return BS(s); +} + +static char **kit_init_argv_(kit_process_args_t args, u32 flags) { + // TODO + // + + if ((flags & KIT_PROCESS_NO_ARGUMENTS) != 0) + return kit_process_argv_null_; + + (void) args; + + return NULL; +} + +static char **kit_init_envp_(kit_process_env_t env, u32 flags) { + // TODO + // + + if ((flags & KIT_PROCESS_NO_ENVIRONMENT) != 0) + return kit_process_env_null_; + + (void) env; + + return NULL; +} + +s32 kit_process_init(kit_process_t *p, kit_process_info_t info) { + assert(p != NULL); + assert(info.working_directory.size == 0 || + info.working_directory.values != NULL); + + if (p == NULL || (info.working_directory.size != 0 && + info.working_directory.values == NULL)) + return KIT_ERROR_INVALID_ARGUMENT; + + memset(p, 0, sizeof *p); + + p->_stdin = -1; + p->_stdout = -1; + p->_stderr = -1; + + signal(SIGCHLD, SIG_IGN); + signal(SIGALRM, SIG_IGN); // pipes + + i32 pipe_in[2]; + i32 pipe_out[2]; + i32 pipe_err[2]; + + if ((info.flags & KIT_PROCESS_NO_PIPES) == 0) { + if (pipe(pipe_in) == -1) { + assert(0); + return KIT_ERROR_PIPE_FAILED; + } + + if (pipe(pipe_out) == -1) { + assert(0); + close(pipe_in[0]); + close(pipe_in[1]); + return KIT_ERROR_PIPE_FAILED; + } + + if (pipe(pipe_err) == -1) { + assert(0); + close(pipe_in[0]); + close(pipe_in[1]); + close(pipe_out[0]); + close(pipe_out[1]); + return KIT_ERROR_PIPE_FAILED; + } + + // non-blocking writing for stdout, stderr + if (fcntl(pipe_out[1], F_SETFL, O_NONBLOCK) == -1 || + fcntl(pipe_err[1], F_SETFL, O_NONBLOCK) == -1) { + assert(0); + close(pipe_in[0]); + close(pipe_in[1]); + close(pipe_out[0]); + close(pipe_out[1]); + close(pipe_err[0]); + close(pipe_err[1]); + return KIT_ERROR_PIPE_FAILED; + } + } + + pid_t id = fork(); + + switch (id) { + case -1: return KIT_ERROR_FORK_FAILED; + + case 0: + // Child process + // + + p->status = KIT_OK; + p->current_is_forked = 1; + + if ((info.flags & KIT_PROCESS_NO_PIPES) == 0) { + // Redirect IO + if (dup2(pipe_in[0], STDIN_FILENO) == -1 || + dup2(pipe_out[1], STDOUT_FILENO) == -1 || + dup2(pipe_err[1], STDERR_FILENO) == -1) { + assert(0); + close(pipe_in[0]); + close(pipe_in[1]); + close(pipe_out[0]); + close(pipe_out[1]); + close(pipe_err[0]); + close(pipe_err[1]); + return KIT_ERROR_DUP2_FAILED; + } + + // Close pipes + close(pipe_in[0]); + close(pipe_in[1]); + close(pipe_out[0]); + close(pipe_out[1]); + close(pipe_err[0]); + close(pipe_err[1]); + } + + // Change working directory + if (info.working_directory.size != 0 && + chdir(kit_process_str_(info.working_directory)) == -1) { + assert(0); + return KIT_ERROR_CHDIR_FAILED; + } + + if ((info.flags & KIT_PROCESS_FORK) == 0) { + execve(kit_process_str_(info.file_name), + kit_init_argv_(info.command_line, info.flags), + kit_init_envp_(info.environment, info.flags)); + // Doesn't return on success + + return KIT_ERROR_EXECVE_FAILED; + } + + return KIT_OK; + + default: + // Parent process + // + + p->status = KIT_OK; + p->current_is_forked = 0; + p->_ready = 1; + p->_running = 1; + p->_id = id; + + if ((info.flags & KIT_PROCESS_NO_PIPES) == 0) { + p->_stdin = pipe_in[1]; + p->_stdout = pipe_out[0]; + p->_stderr = pipe_err[0]; + + // Close unused pipes + close(pipe_in[0]); + close(pipe_out[1]); + close(pipe_err[1]); + } + } + + return KIT_OK; +} + +void kit_process_cleanup(kit_process_t *p) { + assert(p != NULL); + assert(p->_ready); + + if (p == NULL || !p->_ready) + return; + + if (p->_stdin != -1) + close(p->_stdin); + if (p->_stdout != -1) + close(p->_stdout); + if (p->_stderr != -1) + close(p->_stderr); + + memset(p, 0, sizeof *p); +} + +i64 kit_process_write_stdin(kit_process_t *p, kit_str_t in_data) { + assert(p != NULL && (in_data.size == 0 || in_data.values != NULL) && + p->_running); + + if (p == NULL || (in_data.size != 0 && in_data.values == NULL)) + return KIT_ERROR_INVALID_ARGUMENT; + if (in_data.size == 0 || !p->_running || p->_stdin == -1) + return 0; + + i64 n = write(p->_stdin, in_data.values, in_data.size); + + assert(n >= 0); + if (n < 0) + return 0; + + return n; +} + +i64 kit_process_read_stdout(kit_process_t *p, kit_str_t out_data) { + assert(p != NULL && + (out_data.size == 0 || out_data.values != NULL) && + p->_ready); + + if (p == NULL || (out_data.size != 0 && out_data.values == NULL)) + return KIT_ERROR_INVALID_ARGUMENT; + if (out_data.size == 0 || !p->_ready || p->_stdout == -1) + return 0; + + i64 n = read(p->_stdout, out_data.values, out_data.size); + + assert(n >= 0); + if (n < 0) + return 0; + + return n; +} + +i64 kit_process_read_stderr(kit_process_t *p, kit_str_t out_data) { + assert(p != NULL && + (out_data.size == 0 || out_data.values != NULL) && + p->_ready); + + if (p == NULL || (out_data.size != 0 && out_data.values == NULL)) + return KIT_ERROR_INVALID_ARGUMENT; + if (out_data.size == 0 || !p->_ready || p->_stderr == -1) + return 0; + + i64 n = read(p->_stderr, out_data.values, out_data.size); + + assert(n >= 0); + if (n < 0) + return 0; + + return n; +} + +s32 kit_process_terminate(kit_process_t *p) { + assert(p != NULL && p->_running); + if (p == NULL || !p->_running) + return KIT_ERROR_INVALID_ARGUMENT; + + if (kill(p->_id, SIGTERM) == -1) + return KIT_ERROR_KILL_FAILED; + + return KIT_OK; +} + +b8 kit_process_alive(kit_process_t *p) { + assert(p != NULL); + if (p == NULL || p->status != KIT_OK) + return 0; + + if (!p->_running) + return 0; + + int status; + + pid_t id = waitpid(p->_id, &status, WNOHANG); + + if (id == -1) { + p->status = KIT_ERROR_WAITPID_FAILED; + return 0; + } + + if (id == 0) + return 1; + + if (WIFEXITED(status)) { + p->exit_code = WEXITSTATUS(status); + p->_running = 0; + return 0; + } + + return 1; +} + +s32 kit_process_wait(kit_process_t *p) { + assert(p != NULL); + if (p == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + if (p->status != KIT_OK) + return p->status; + if (!p->_running) + return KIT_OK; + + for (;;) { + int status; + + pid_t id = waitpid(p->_id, &status, 0); + + if (id == -1) + return KIT_ERROR_WAITPID_FAILED; + + if (WIFEXITED(status)) { + p->exit_code = WEXITSTATUS(status); + p->_running = 0; + break; + } + } + + return KIT_OK; +} + +#endif diff --git a/kit/process.win32.c b/kit/process.win32.c new file mode 100644 index 0000000..ebff7b1 --- /dev/null +++ b/kit/process.win32.c @@ -0,0 +1,5 @@ +#include "process.h" + +#if defined(_WIN32) && !defined(__CYGWIN__) + +#endif diff --git a/kit/secure_random.c b/kit/secure_random.c new file mode 100644 index 0000000..2565f6f --- /dev/null +++ b/kit/secure_random.c @@ -0,0 +1,45 @@ +#include "secure_random.h" + +#include +#include +#include + +#if defined(_WIN32) && !defined(__CYGWIN__) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +# include +# include +#else +# include +#endif + +s32 kit_secure_random(i64 size, void *data) { + assert(size >= 0); + assert(data != NULL); + + if (size <= 0 || data == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + +#if defined(_WIN32) && !defined(__CYGWIN__) + HCRYPTPROV prov = 0; + if (!CryptAcquireContextW(&prov, NULL, NULL, PROV_RSA_FULL, + CRYPT_VERIFYCONTEXT | CRYPT_SILENT) || + !CryptGenRandom(prov, (DWORD) size, (BYTE *) data) || + !CryptReleaseContext(prov, 0)) + return KIT_ERROR_RESOURCE_UNAVAILABLE; +#else + FILE *f = fopen("/dev/urandom", "rb"); + + if (f == NULL) + return KIT_ERROR_RESOURCE_UNAVAILABLE; + + i64 n = (i64) fread(data, 1, size, f); + fclose(f); + + if (n != size) + return KIT_ERROR_RESOURCE_UNAVAILABLE; +#endif + + return KIT_OK; +} diff --git a/kit/secure_random.h b/kit/secure_random.h new file mode 100644 index 0000000..435fe88 --- /dev/null +++ b/kit/secure_random.h @@ -0,0 +1,19 @@ +#ifndef KIT_SECURE_RANDOM_H +#define KIT_SECURE_RANDOM_H + +#include "types.h" +#include "status.h" + +#ifdef __cplusplus +extern "C" { +#endif + +s32 kit_secure_random(i64 size, void *data); + +#ifdef __cplusplus +} +#endif + +#define secure_random kit_secure_random + +#endif diff --git a/kit/sha256.c b/kit/sha256.c new file mode 100644 index 0000000..3abe972 --- /dev/null +++ b/kit/sha256.c @@ -0,0 +1,151 @@ +#include "sha256.h" + +#include +#include + +#define ROTLEFT(a, b) (((a) << (b)) | ((a) >> (32 - (b)))) +#define ROTRIGHT(a, b) (((a) >> (b)) | ((a) << (32 - (b)))) + +#define CH(x, y, z) (((x) & (y)) ^ (~(x) & (z))) +#define MAJ(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) +#define EP0(x) (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22)) +#define EP1(x) (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25)) +#define SIG0(x) (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3)) +#define SIG1(x) (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10)) + +static u32 kit_sha256_k[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, + 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, + 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, + 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, + 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, + 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, + 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, + 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, + 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, + 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +}; + +static void kit_sha256_transform(u32 *state, u8 *data) { + assert(state != NULL); + assert(data != NULL); + + u32 a, b, c, d, e, f, g, h, i, j, t1, t2, m[64]; + + for (i = 0, j = 0; i < 16; ++i, j += 4) + m[i] = ((u32) data[j] << 24) | ((u32) data[j + 1] << 16) | + ((u32) data[j + 2] << 8) | ((u32) data[j + 3]); + for (; i < 64; ++i) + m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16]; + + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + f = state[5]; + g = state[6]; + h = state[7]; + + for (i = 0; i < 64; ++i) { + t1 = h + EP1(e) + CH(e, f, g) + kit_sha256_k[i] + m[i]; + t2 = EP0(a) + MAJ(a, b, c); + h = g; + g = f; + f = e; + e = d + t1; + d = c; + c = b; + b = a; + a = t1 + t2; + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; +} + +kit_sha256_hash_t kit_sha256(i64 in_size, u8 *in_data) { + assert(in_size >= 0); + assert(in_data != NULL); + + u32 state[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, + 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; + + u8 data[64]; + + i64 i; + i64 datalen = 0; + u64 bitlen = 0; + + if (in_data != NULL) + for (i = 0; i < in_size; ++i) { + data[datalen] = in_data[i]; + datalen++; + + if (datalen != 64) + continue; + + kit_sha256_transform(state, data); + bitlen += 512; + datalen = 0; + } + + i = datalen; + + if (datalen < 56) { + data[i++] = 0x80; + while (i < 56) data[i++] = 0x00; + } else { + data[i++] = 0x80; + while (i < 64) data[i++] = 0x00; + + kit_sha256_transform(state, data); + memset(data, 0, 56); + } + + bitlen += datalen * 8; + data[63] = bitlen; + data[62] = bitlen >> 8; + data[61] = bitlen >> 16; + data[60] = bitlen >> 24; + data[59] = bitlen >> 32; + data[58] = bitlen >> 40; + data[57] = bitlen >> 48; + data[56] = bitlen >> 56; + + kit_sha256_transform(state, data); + + kit_sha256_hash_t hash; + memset(&hash, 0, sizeof hash); + + for (i = 0; i < 4; ++i) { + hash.v[i] = (state[0] >> (24 - i * 8)) & 0xff; + hash.v[i + 4] = (state[1] >> (24 - i * 8)) & 0xff; + hash.v[i + 8] = (state[2] >> (24 - i * 8)) & 0xff; + hash.v[i + 12] = (state[3] >> (24 - i * 8)) & 0xff; + hash.v[i + 16] = (state[4] >> (24 - i * 8)) & 0xff; + hash.v[i + 20] = (state[5] >> (24 - i * 8)) & 0xff; + hash.v[i + 24] = (state[6] >> (24 - i * 8)) & 0xff; + hash.v[i + 28] = (state[7] >> (24 - i * 8)) & 0xff; + } + + return hash; +} + +#undef ROTLEFT +#undef ROTRIGHT +#undef CH +#undef MAJ +#undef EP0 +#undef EP1 +#undef SIG0 +#undef SIG1 diff --git a/kit/sha256.h b/kit/sha256.h new file mode 100644 index 0000000..da05385 --- /dev/null +++ b/kit/sha256.h @@ -0,0 +1,26 @@ +#ifndef KIT_SHA256_H +#define KIT_SHA256_H + +#include "types.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { KIT_SHA256_BLOCK_SIZE = 32 }; + +typedef struct { + u8 v[KIT_SHA256_BLOCK_SIZE]; +} kit_sha256_hash_t; + +kit_sha256_hash_t kit_sha256(i64 size, u8 *data); + +#ifdef __cplusplus +} +#endif + +#define SHA256_BLOCK_SIZE KIT_SHA256_BLOCK_SIZE +#define sha256_hash_t kit_sha256_hash_t +#define sha256 kit_sha256 + +#endif diff --git a/kit/shared_memory.h b/kit/shared_memory.h new file mode 100644 index 0000000..a13ccee --- /dev/null +++ b/kit/shared_memory.h @@ -0,0 +1,48 @@ +#ifndef KIT_SHARED_MEMORY_H +#define KIT_SHARED_MEMORY_H + +#include "status.h" +#include "string_ref.h" + +#if !defined(_WIN32) || defined(__CYGWIN__) +# include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + s32 status; + i64 size; + u8 *bytes; +#if defined(_WIN32) && !defined(__CYGWIN__) + void *_handle; +#else + i8 _owned; + char _name[NAME_MAX + 1]; +#endif +} kit_shared_memory_t; + +enum { + KIT_SHARED_MEMORY_OPEN, + KIT_SHARED_MEMORY_CREATE, +}; + +kit_shared_memory_t kit_shared_memory_open(kit_str_t name, i64 size, + i32 mode); +s32 kit_shared_memory_close(kit_shared_memory_t *mem); +s32 kit_shared_memory_clean(kit_str_t name); + +#ifdef __cplusplus +} +#endif + +#define shared_memory_t kit_shared_memory_t +#define shared_memory_clean kit_shared_memory_clean +#define shared_memory_open kit_shared_memory_open +#define shared_memory_close kit_shared_memory_close +#define SHARED_MEMORY_OPEN KIT_SHARED_MEMORY_OPEN +#define SHARED_MEMORY_CREATE KIT_SHARED_MEMORY_CREATE + +#endif diff --git a/kit/shared_memory.posix.c b/kit/shared_memory.posix.c new file mode 100644 index 0000000..fa0db98 --- /dev/null +++ b/kit/shared_memory.posix.c @@ -0,0 +1,124 @@ +#include "shared_memory.h" + +#if !defined(_WIN32) || defined(__CYGWIN__) +# include +# include +# include +# include +# include +# include +# include + +kit_shared_memory_t kit_shared_memory_open(kit_str_t name, i64 size, + i32 mode) { + kit_shared_memory_t mem; + + memset(&mem, 0, sizeof mem); + + assert(size > 0); + assert(name.size > 0); + assert(name.size + 1 <= NAME_MAX); + assert(name.values != NULL); + + if (size <= 0) { + mem.status = KIT_ERROR_INVALID_SIZE; + return mem; + } + + if (name.size <= 0) { + mem.status = KIT_ERROR_INVALID_NAME; + return mem; + } + + if (name.size + 1 > NAME_MAX) { + mem.status = KIT_ERROR_NAME_TOO_LONG; + return mem; + } + + for (i64 i = 0; i < name.size; i++) + if (name.values[i] == '/' || name.values[i] == '\\') { + mem.status = KIT_ERROR_INVALID_NAME; + return mem; + } + + mem._name[0] = '/'; + memcpy(mem._name + 1, name.values, name.size); + mem._name[1 + name.size] = '\0'; + + i32 fd = shm_open(mem._name, + mode == KIT_SHARED_MEMORY_CREATE + ? O_RDWR | O_CREAT | O_EXCL + : O_RDWR, + mode == KIT_SHARED_MEMORY_CREATE ? 0660 : 0); + + if (fd == -1) { + mem.status = KIT_ERROR_OPEN_FAILED; + return mem; + } + + if (mode == KIT_SHARED_MEMORY_CREATE && ftruncate(fd, size) == -1) { + shm_unlink(mem._name); + assert(0); + mem.status = KIT_ERROR_TRUNCATE_FAILED; + return mem; + } + + void *p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, + 0); + + close(fd); + + if (p == MAP_FAILED) { + shm_unlink(mem._name); + mem.status = KIT_ERROR_MAP_FAILED; + return mem; + } + + mem.status = KIT_OK; + mem.size = size; + mem.bytes = (u8 *) p; + mem._owned = (mode == KIT_SHARED_MEMORY_CREATE); + return mem; +} + +s32 kit_shared_memory_close(kit_shared_memory_t *mem) { + assert(mem != NULL); + + if (mem == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + + s32 status = KIT_OK; + + if (munmap(mem->bytes, mem->size) != 0) + status |= KIT_ERROR_UNMAP_FAILED; + if (mem->_owned && shm_unlink(mem->_name) != 0) + status |= KIT_ERROR_UNLINK_FAILED; + + return status; +} + +s32 kit_shared_memory_clean(kit_str_t name) { + assert(name.size > 0); + assert(name.size + 1 <= NAME_MAX); + assert(name.values != NULL); + + if (name.size <= 0) + return KIT_ERROR_INVALID_NAME; + + if (name.size + 1 > NAME_MAX) + return KIT_ERROR_NAME_TOO_LONG; + + for (i64 i = 0; i < name.size; i++) + if (name.values[i] == '/' || name.values[i] == '\\') + return KIT_ERROR_INVALID_NAME; + + char buf[NAME_MAX + 1] = "/"; + memcpy(buf + 1, name.values, name.size); + buf[1 + name.size] = '\0'; + + if (shm_unlink(buf) != 0) + return KIT_ERROR_UNLINK_FAILED; + + return KIT_OK; +} +#endif diff --git a/kit/shared_memory.win32.c b/kit/shared_memory.win32.c new file mode 100644 index 0000000..f1d24d0 --- /dev/null +++ b/kit/shared_memory.win32.c @@ -0,0 +1,91 @@ +#include "shared_memory.h" + +#if defined(_WIN32) && !defined(__CYGWIN__) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include + +kit_shared_memory_t kit_shared_memory_open(kit_str_t name, i64 size, + i32 mode) { + kit_shared_memory_t mem; + memset(&mem, 0, sizeof mem); + + char buf[264] = "Global\\"; + + assert(size > 0); + assert(name.size > 0); + assert(name.size + 8 < (i64) sizeof buf); + assert(name.values != NULL); + + if (name.size <= 0) { + mem.status = KIT_ERROR_INVALID_NAME; + return mem; + } + + if (name.size + 8 >= (i64) sizeof buf) { + mem.status = KIT_ERROR_NAME_TOO_LONG; + return mem; + } + + for (i64 i = 0; i < name.size; i++) + if (name.values[i] == '/' || name.values[i] == '\\') { + mem.status = KIT_ERROR_INVALID_NAME; + return mem; + } + + memcpy(buf + 7, name.values, name.size); + buf[7 + name.size] = '\0'; + + HANDLE h = mode == KIT_SHARED_MEMORY_CREATE + ? CreateFileMappingA( + INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, + (DWORD) (size >> 32), (DWORD) size, buf) + : OpenFileMappingA(FILE_MAP_ALL_ACCESS, 0, buf); + + if (h == INVALID_HANDLE_VALUE) { + mem.status = KIT_ERROR_OPEN_FAILED; + return mem; + } + + void *p = MapViewOfFile(h, FILE_MAP_ALL_ACCESS, 0, 0, + (SIZE_T) size); + + if (p == NULL) { + CloseHandle(h); + mem.status = KIT_ERROR_MAP_FAILED; + return mem; + } + + mem.status = KIT_OK; + mem.size = size; + mem.bytes = (u8 *) p; + mem._handle = h; + return mem; +} + +s32 kit_shared_memory_close(kit_shared_memory_t *mem) { + assert(mem != NULL); + + i32 status = KIT_OK; + + if (!UnmapViewOfFile(mem->bytes)) + status |= KIT_ERROR_UNMAP_FAILED; + if (!CloseHandle(mem->_handle)) + status |= KIT_ERROR_UNLINK_FAILED; + + return status; +} + +s32 kit_shared_memory_clean(kit_str_t name) { + // Do nothing. + // + + (void) name; + + return KIT_OK; +} +#endif diff --git a/kit/shared_mutex.h b/kit/shared_mutex.h new file mode 100644 index 0000000..ad83418 --- /dev/null +++ b/kit/shared_mutex.h @@ -0,0 +1,176 @@ +// Shared mutex can be used in shared memory for interprocess +// synchronization. +// + +#ifndef KIT_SHARED_MUTEX_H +#define KIT_SHARED_MUTEX_H + +#include "atomic.h" +#include "threads.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +enum { + KIT_SHARED_MUTEX_READY = 1, + KIT_SHARED_MUTEX_LOCKED, + KIT_SHARED_MUTEX_WRITER +}; + +typedef union { + struct { + i8 _Atomic state; + i32 readers; + }; + struct { + u8 _pad[16]; + }; +} kit_shared_mutex_t; + +static void kit_shared_mutex_init(kit_shared_mutex_t *m) { + assert(m != NULL); + memset(m, 0, sizeof *m); + + atomic_store_explicit(&m->state, KIT_SHARED_MUTEX_READY, + memory_order_relaxed); +} + +static b8 kit_shared_try_lock(kit_shared_mutex_t *m) { + assert(m != NULL); + + for (;;) { + i8 prev_state = KIT_SHARED_MUTEX_READY; + if (atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_LOCKED, + memory_order_seq_cst, memory_order_seq_cst)) + break; + if (prev_state == KIT_SHARED_MUTEX_WRITER) + return 0; + // FIXME + // Check performance + thrd_yield(); + } + + assert(m->readers >= 0); + ++m->readers; + + i8 prev_state = KIT_SHARED_MUTEX_LOCKED; + if (!atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_READY, + memory_order_seq_cst, memory_order_seq_cst)) + assert(0); + + return 1; +} + +static void kit_shared_lock(kit_shared_mutex_t *m) { + assert(m != NULL); + + while (!kit_shared_try_lock(m)) + // FIXME + // Check performance + thrd_yield(); +} + +static void kit_shared_unlock(kit_shared_mutex_t *m) { + assert(m != NULL); + + for (;;) { + i8 prev_state = KIT_SHARED_MUTEX_READY; + if (atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_LOCKED, + memory_order_seq_cst, memory_order_seq_cst)) + break; + // FIXME + // Check performance + thrd_yield(); + } + + assert(m->readers > 0); + m->readers--; + + i8 prev_state = KIT_SHARED_MUTEX_LOCKED; + if (!atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_READY, + memory_order_seq_cst, memory_order_seq_cst)) + assert(0); +} + +static b8 kit_unique_try_lock(kit_shared_mutex_t *m) { + assert(m != NULL); + + i8 prev_state = KIT_SHARED_MUTEX_READY; + if (!atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_WRITER, + memory_order_seq_cst, memory_order_seq_cst)) + return 0; + + i8 is_locked = (m->readers == 0); + + prev_state = KIT_SHARED_MUTEX_WRITER; + if (!is_locked && + !atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_READY, + memory_order_seq_cst, memory_order_seq_cst)) + assert(0); + + return is_locked; +} + +static void kit_unique_lock(kit_shared_mutex_t *m) { + assert(m != NULL); + + while (!kit_unique_try_lock(m)) + // FIXME + // Check performance + thrd_yield(); +} + +static void kit_unique_unlock(kit_shared_mutex_t *m) { + assert(m != NULL); + + i8 prev_state = KIT_SHARED_MUTEX_WRITER; + if (!atomic_compare_exchange_strong_explicit( + &m->state, &prev_state, KIT_SHARED_MUTEX_READY, + memory_order_seq_cst, memory_order_seq_cst)) + assert(0); +} + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#define shared_mutex_t kit_shared_mutex_t +#define shared_mutex_init kit_shared_mutex_init +#define shared_try_lock kit_shared_try_lock +#define shared_lock kit_shared_lock +#define shared_unlock kit_shared_unlock +#define unique_try_lock kit_unique_try_lock +#define unique_lock kit_unique_lock +#define unique_unlock kit_unique_unlock +#define shared_mutex_init kit_shared_mutex_init +#define shared_try_lock kit_shared_try_lock +#define shared_lock kit_shared_lock +#define shared_unlock kit_shared_unlock +#define unique_try_lock kit_unique_try_lock +#define unique_lock kit_unique_lock +#define unique_unlock kit_unique_unlock + +#endif diff --git a/kit/sockets.h b/kit/sockets.h new file mode 100644 index 0000000..276ecc5 --- /dev/null +++ b/kit/sockets.h @@ -0,0 +1,107 @@ +#ifndef KIT_SOCKETS_H +#define KIT_SOCKETS_H + +#include "types.h" +#include "status.h" + +#ifndef KIT_DISABLE_SYSTEM_SOCKETS +# ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# endif + +# ifdef __cplusplus +extern "C" { +# endif + +# if defined(_WIN32) && !defined(__CYGWIN__) + +# define WIN32_LEAN_AND_MEAN +# include +# include + +# define socket_t SOCKET +# define socklen_t i32 + +static s32 kit_sockets_init(void) { + WSADATA data; + memset(&data, 0, sizeof data); + WORD version = MAKEWORD(2, 2); + return WSAStartup(version, &data) == ERROR_SUCCESS + ? KIT_OK + : KIT_ERROR_SOCKETS_STARTUP_FAILED; +} + +static s32 kit_sockets_cleanup(void) { + WSACleanup(); + return KIT_OK; +} + +static i32 kit_socket_set_blocking(socket_t s) { + u_long flag = 0; + return ioctlsocket(s, FIONBIO, &flag) == 0 + ? KIT_OK + : KIT_ERROR_SOCKET_CONTROL_FAILED; +} + +static i32 kit_socket_set_nonblocking(socket_t s) { + u_long flag = 1; + return ioctlsocket(s, FIONBIO, &flag) == 0 + ? KIT_OK + : KIT_ERROR_SOCKET_CONTROL_FAILED; +} + +# else + +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include + +# define socket_t i32 +# define closesocket close +# define INVALID_SOCKET -1 + +static s32 kit_sockets_init(void) { + signal(SIGPIPE, SIG_IGN); + return KIT_OK; +} + +static s32 kit_sockets_cleanup(void) { + return KIT_OK; +} + +static i32 kit_socket_set_blocking(socket_t s) { + i32 flags = fcntl(s, F_GETFL, 0); + return fcntl(s, F_SETFL, flags & ~O_NONBLOCK) == 0 + ? KIT_OK + : KIT_ERROR_SOCKET_CONTROL_FAILED; +} + +static i32 kit_socket_set_nonblocking(socket_t s) { + i32 flags = fcntl(s, F_GETFL, 0); + return fcntl(s, F_SETFL, flags | O_NONBLOCK) == 0 + ? KIT_OK + : KIT_ERROR_SOCKET_CONTROL_FAILED; +} + +# endif + +# ifdef __cplusplus +} +# endif + +# ifdef __GNUC__ +# pragma GCC diagnostic pop +# endif +#endif + +#endif diff --git a/kit/status.h b/kit/status.h new file mode 100644 index 0000000..88eb5e0 --- /dev/null +++ b/kit/status.h @@ -0,0 +1,43 @@ +#ifndef KIT_STATUS_H +#define KIT_STATUS_H + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +enum { + KIT_OK = 0, + KIT_PARSING_FAILED = 1, + KIT_ERROR_OUT_OF_MEMORY = (1 << 1), + KIT_ERROR_INVALID_ARGUMENT = (1 << 2), + KIT_ERROR_MKDIR_FAILED = (1 << 3), + KIT_ERROR_RMDIR_FAILED = (1 << 4), + KIT_ERROR_UNLINK_FAILED = (1 << 5), + KIT_ERROR_FILE_ALREADY_EXISTS = (1 << 6), + KIT_ERROR_FILE_DOES_NOT_EXIST = (1 << 7), + KIT_ERROR_PATH_TOO_LONG = (1 << 8), + KIT_ERROR_SOCKETS_STARTUP_FAILED = (1 << 9), + KIT_ERROR_SOCKET_CONTROL_FAILED = (1 << 10), + KIT_ERROR_NAME_TOO_LONG = (1 << 11), + KIT_ERROR_INVALID_SIZE = (1 << 12), + KIT_ERROR_INVALID_NAME = (1 << 13), + KIT_ERROR_INVALID_PATH = (1 << 14), + KIT_ERROR_OPEN_FAILED = (1 << 15), + KIT_ERROR_TRUNCATE_FAILED = (1 << 16), + KIT_ERROR_MAP_FAILED = (1 << 17), + KIT_ERROR_UNMAP_FAILED = (1 << 18), + KIT_ERROR_SYNC_FAILED = (1 << 19), + KIT_ERROR_CLOSE_FAILED = (1 << 20), + KIT_ERROR_RESOURCE_UNAVAILABLE = (1 << 21), + KIT_ERROR_FORK_FAILED = (1 << 22), + KIT_ERROR_EXECVE_FAILED = (1 << 23), + KIT_ERROR_WAITPID_FAILED = (1 << 24), + KIT_ERROR_PIPE_FAILED = (1 << 25), + KIT_ERROR_DUP2_FAILED = (1 << 26), + KIT_ERROR_CHDIR_FAILED = (1 << 27), + KIT_ERROR_KILL_FAILED = (1 << 28), + KIT_ERROR_INTERNAL = (1 << 30), + KIT_ERROR_NOT_IMPLEMENTED = -1, +}; + +#endif diff --git a/kit/string_builder.h b/kit/string_builder.h new file mode 100644 index 0000000..23eda65 --- /dev/null +++ b/kit/string_builder.h @@ -0,0 +1,112 @@ +#ifndef KIT_STRING_BUILDER_H +#define KIT_STRING_BUILDER_H + +#include "status.h" +#include "string_ref.h" +#include "dynamic_array.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef KIT_DA(char) kit_str_builder_t; + +#ifdef __GNUC__ +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +static kit_str_builder_t kit_str_build(kit_str_t s, + kit_allocator_t *alloc) { + assert(s.size >= 0 && (s.size == 0 || s.values != NULL)); + kit_str_builder_t builder; + memset(&builder, 0, sizeof builder); + if (s.size < 0 || (s.size != 0 && s.values == NULL)) + return builder; + KIT_DA_INIT(builder, s.size, alloc); + assert(builder.size == s.size); + if (builder.size == s.size) + memcpy(builder.values, s.values, s.size); + return builder; +} + +static kit_str_builder_t kit_substr_build(kit_str_t s, i64 index, + i64 size, + kit_allocator_t *alloc) { + assert(index + size <= s.size); + if (index + size > s.size) { + kit_str_builder_t builder; + memset(&builder, 0, sizeof builder); + return builder; + } + return kit_str_build(kit_str(size, s.values + index), alloc); +} + +static s32 kit_str_append(kit_str_builder_t *a, kit_str_t b) { + assert(a != NULL); + if (a == NULL) + return KIT_ERROR_INVALID_ARGUMENT; + if (b.size <= 0) + return KIT_OK; + i64 n = a->size; + KIT_DA_RESIZE(*a, n + b.size); + if (a->size != n + b.size) + return KIT_ERROR_OUT_OF_MEMORY; + memcpy(a->values + n, b.values, b.size); + return KIT_OK; +} + +static s32 kit_str_insert(kit_str_builder_t *a, i64 index, + kit_str_t b) { + assert(a != NULL && index >= 0 && index <= a->size); + if (a == NULL || index < 0 || index > a->size) + return KIT_ERROR_INVALID_ARGUMENT; + if (b.size <= 0) + return KIT_OK; + i64 n = a->size; + KIT_DA_RESIZE(*a, n + b.size); + if (a->size != n + b.size) + return KIT_ERROR_OUT_OF_MEMORY; + if (index < n) + memmove(a->values + (index + b.size), a->values + index, + n - index); + memcpy(a->values + index, b.values, b.size); + return KIT_OK; +} + +static s32 kit_str_erase(kit_str_builder_t *a, i64 index, i64 size) { + assert(a != NULL && index >= 0 && size >= 0 && + index + size <= a->size); + if (a == NULL || index < 0 || size < 0 || index + size > a->size) + return KIT_ERROR_INVALID_ARGUMENT; + if (size <= 0) + return KIT_OK; + if (index + size < a->size) + memmove(a->values + index, a->values + (index + size), + a->size - index - size); + KIT_DA_RESIZE(*a, a->size - size); + return KIT_OK; +} + +#ifdef __GNUC__ +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#define str_builder_t kit_str_builder_t +#define str_build kit_str_build +#define substr_build kit_substr_build +#define str_append kit_str_append +#define str_insert kit_str_insert +#define str_erase kit_str_erase + +#endif diff --git a/kit/string_ref.h b/kit/string_ref.h new file mode 100644 index 0000000..e7ea809 --- /dev/null +++ b/kit/string_ref.h @@ -0,0 +1,137 @@ +#ifndef KIT_STRING_REF_H +#define KIT_STRING_REF_H + +#include "array_ref.h" + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef KIT_AR(char) kit_str_t; + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +static kit_str_t kit_str(i64 size, char const *static_string) { + kit_str_t s = { .size = size, .values = (char *) static_string }; + return s; +} + +enum { + KIT_STR_NOT_FOUND = -1, +}; + +static i64 kit_str_find(kit_str_t a, kit_str_t b) { + assert(a.size >= 0 && (a.size == 0 || a.values != NULL) && + b.size >= 0 && (b.size == 0 || b.values != NULL)); + if (a.size < 0 || (a.size != 0 && a.values == NULL) || b.size < 0 || + (b.size != 0 && b.values == NULL)) + return -1; + for (i64 index = 0; index + b.size <= a.size; index++) + if (KIT_AR_EQUAL(kit_str(b.size, a.values + index), b)) + return index; + return -1; +} + +static i64 kit_str_find_back(kit_str_t a, kit_str_t b) { + assert(a.size >= 0 && (a.size == 0 || a.values != NULL) && + b.size >= 0 && (b.size == 0 || b.values != NULL)); + if (a.size < 0 || (a.size != 0 && a.values == NULL) || b.size < 0 || + (b.size != 0 && b.values == NULL)) + return -1; + for (i64 index = a.size - b.size; index >= 0; index--) + if (KIT_AR_EQUAL(kit_str(b.size, a.values + index), b)) + return index; + return -1; +} + +static i64 kit_str_find_n(kit_str_t a, kit_str_t b, i64 n) { + assert(a.size >= 0 && (a.size == 0 || a.values != NULL) && + b.size >= 0 && (b.size == 0 || b.values != NULL)); + if (a.size < 0 || (a.size != 0 && a.values == NULL) || b.size < 0 || + (b.size != 0 && b.values == NULL)) + return -1; + i64 count = 0; + for (i64 index = 0; index + b.size <= a.size; index++) + if (KIT_AR_EQUAL(kit_str(b.size, a.values + index), b)) { + if (count == n) + return index; + else + count++; + } + return -1; +} + +static i64 kit_str_find_back_n(kit_str_t a, kit_str_t b, i64 n) { + assert(a.size >= 0 && (a.size == 0 || a.values != NULL) && + b.size >= 0 && (b.size == 0 || b.values != NULL)); + if (a.size < 0 || (a.size != 0 && a.values == NULL) || b.size < 0 || + (b.size != 0 && b.values == NULL)) + return -1; + i64 count = 0; + for (i64 index = a.size - b.size; index >= 0; index--) + if (KIT_AR_EQUAL(kit_str(b.size, a.values + index), b)) { + if (count == n) + return index; + else + count++; + } + return -1; +} + +// Make a barbarian string for C standard library functions. +// Not thread safe. +// Use with caution. +// +static char *kit_make_bs(kit_str_t s) { + static char buf[8][4096]; + static i32 index = 0; + i64 n = s.size; + if (n > 4095) + n = 4095; + if (n > 0) + memcpy(buf[index], s.values, n); + buf[index][n] = '\0'; + char *result = buf[index]; + index = (index + 1) % 8; + return result; +} + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#define KIT_SZ(static_str_) \ + kit_str(sizeof(static_str_) - 1, (static_str_)) + +#define KIT_WRAP_BS(string_) kit_str(strlen(string_), (string_)) + +#define KIT_WRAP_STR(...) \ + kit_str((__VA_ARGS__).size, (__VA_ARGS__).values) + +#ifdef __cplusplus +} +#endif + +#define BS(...) kit_make_bs(KIT_WRAP_STR(__VA_ARGS__)) +#define str_t kit_str_t +#define str kit_str +#define str_find kit_str_find +#define str_find_back kit_str_find_back +#define str_find_n kit_str_find_n +#define str_find_back_n kit_str_find_back_n +#define STR_NOT_FOUND KIT_STR_NOT_FOUND +#define SZ KIT_SZ +#define WRAP_BS KIT_WRAP_BS +#define WRAP_STR KIT_WRAP_STR + +#endif diff --git a/kit/test.h b/kit/test.h new file mode 100644 index 0000000..243111e --- /dev/null +++ b/kit/test.h @@ -0,0 +1,1096 @@ +// ================================================================ +// +// test.h +// https://guattari.tech/git/kit +// +// Header-only unit-testing and microbenchmarks library for C. +// +// +// - Define a unique KIT_TEST_FILE for each file to avoid name +// collisions. +// +// - Define KIT_TEST_IMPLEMENTATION to include the implementation. +// +// +// Optional settings +// +// - KIT_TESTS_SIZE_LIMIT +// - KIT_TEST_ASSERTIONS_LIMIT +// - KIT_BENCHS_SIZE_LIMIT +// - KIT_BENCH_MAX_REPEATS +// - KIT_BENCH_MAX_CYCLES +// - KIT_BENCH_REPEATS_DEFAULT_1 +// - KIT_BENCH_REPEATS_DEFAULT_2 +// +// +// Usage example +// +// // foo.test.c +// #define KIT_TEST_FILE foo // This is required if you want to +// // use multiple test files. +// #include "test.h" +// TEST("foo") { +// REQUIRE(1); +// REQUIRE_EQ(2 + 2, 4); +// } +// +// // main.c +// #define KIT_TEST_IMPLEMENTATION +// #include "test.h" +// int main(int argc, char **argv) { +// return run_tests(argc, argv); +// } +// +// ================================================================ + +#ifndef KIT_TEST_H +#define KIT_TEST_H + +#ifdef __GNUC__ +# pragma GCC diagnostic ignored "-Wunused-value" +# pragma GCC diagnostic ignored "-Wunused-parameter" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#include +#include + +#ifndef KIT_TEST_FILE +# define KIT_TEST_FILE kit_test +#endif + +#ifndef KIT_TESTS_SIZE_LIMIT +# define KIT_TESTS_SIZE_LIMIT 0x1000 +#endif + +#ifndef KIT_TEST_ASSERTIONS_LIMIT +# define KIT_TEST_ASSERTIONS_LIMIT 0x50 +#endif + +#ifndef KIT_BENCHS_SIZE_LIMIT +# define KIT_BENCHS_SIZE_LIMIT 200 +#endif + +#ifndef KIT_BENCH_MAX_REPEATS +# define KIT_BENCH_MAX_REPEATS 4000 +#endif + +#ifndef KIT_BENCH_MAX_CYCLES +# define KIT_BENCH_MAX_CYCLES 40 +#endif + +#ifndef KIT_BENCH_REPEATS_DEFAULT_1 +# define KIT_BENCH_REPEATS_DEFAULT_1 40 +#endif + +#ifndef KIT_BENCH_REPEATS_DEFAULT_2 +# define KIT_BENCH_REPEATS_DEFAULT_2 400 +#endif + +typedef void (*kit_test_report_fn)(int test_index, int line, + int64_t value, int64_t expected); +typedef void (*kit_test_run_fn)( + int kit_test_index_, kit_test_report_fn kit_test_report_fn_); + +typedef struct { + char const *test_name; + char const *test_file; + kit_test_run_fn test_fn; + int assertions; + int line[KIT_TEST_ASSERTIONS_LIMIT]; + int status[KIT_TEST_ASSERTIONS_LIMIT]; + int64_t value[KIT_TEST_ASSERTIONS_LIMIT]; + int64_t expected[KIT_TEST_ASSERTIONS_LIMIT]; + int signal; +} kit_test_case_t; + +typedef struct { + int size; + kit_test_case_t v[KIT_TESTS_SIZE_LIMIT]; +} kit_tests_list_t; + +extern kit_tests_list_t kit_tests_list; + +#define KIT_TEST_CONCAT4_(a, b, c, d) a##b##c##d +#define KIT_TEST_CONCAT3_(a, b, c) KIT_TEST_CONCAT4_(a, b, _, c) + +#ifdef __cplusplus +# define KIT_TEST_ON_START_(f) \ + static void f(void); \ + static int KIT_TEST_CONCAT3_(_kit_test_init_, __LINE__, \ + f) = (f(), 0); \ + static void f(void) +#else +# ifdef _MSC_VER +# pragma section(".CRT$XCU", read) +# define KIT_TEST_ON_START_2_(f, p) \ + static void f(void); \ + __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \ + __pragma(comment(linker, "/include:" p #f "_")) static void f( \ + void) +# ifdef _WIN64 +# define KIT_TEST_ON_START_(f) KIT_TEST_ON_START_2_(f, "") +# else +# define KIT_TEST_ON_START_(f) KIT_TEST_ON_START_2_(f, "_") +# endif +# else +# define KIT_TEST_ON_START_(f) \ + static void f(void) __attribute__((constructor)); \ + static void f(void) +# endif +#endif + +void kit_test_register(char const *name, char const *file, + kit_test_run_fn fn); + +#define KIT_TEST(name) \ + static void KIT_TEST_CONCAT3_(kit_test_run_, __LINE__, \ + KIT_TEST_FILE)(int, \ + kit_test_report_fn); \ + KIT_TEST_ON_START_( \ + KIT_TEST_CONCAT3_(kit_test_case_, __LINE__, KIT_TEST_FILE)) { \ + kit_test_register( \ + name, __FILE__, \ + KIT_TEST_CONCAT3_(kit_test_run_, __LINE__, KIT_TEST_FILE)); \ + } \ + static void KIT_TEST_CONCAT3_(kit_test_run_, __LINE__, \ + KIT_TEST_FILE)( \ + int kit_test_index_, kit_test_report_fn kit_test_report_fn_) + +#define KIT_REQUIRE(...) \ + kit_test_report_fn_(kit_test_index_, __LINE__, (__VA_ARGS__), 1) + +#define KIT_REQUIRE_EQ(...) \ + kit_test_report_fn_(kit_test_index_, __LINE__, __VA_ARGS__) + +int kit_run_tests(int argc, char **argv); + +typedef void (*kit_bench_set_repeats_limit_fn)(int bench_index, + int repeats_limit); +typedef int (*kit_bench_loop_fn)(int bench_index); +typedef void (*kit_bench_begin_fn)(int bench_index); +typedef void (*kit_bench_end_fn)(int bench_index); + +typedef void (*kit_bench_run_fn)( + int kit_bench_index_, + kit_bench_set_repeats_limit_fn kit_bench_set_repeats_limit_, + kit_bench_loop_fn kit_bench_loop_, + kit_bench_begin_fn kit_bench_begin_, + kit_bench_end_fn kit_bench_end_); + +typedef struct { + char const *bench_name; + char const *bench_file; + kit_bench_run_fn bench_fn; + int64_t sec[KIT_BENCH_MAX_REPEATS]; + int32_t nsec[KIT_BENCH_MAX_REPEATS]; + int64_t duration_nsec[KIT_BENCH_MAX_REPEATS]; + int64_t duration_sorted_nsec[KIT_BENCH_MAX_REPEATS]; + int repeats; + int cycles_size; + int cycles[KIT_BENCH_MAX_CYCLES]; + int cycle; + int signal; + int ready; +} kit_benchmark_t; + +typedef struct { + int size; + kit_benchmark_t v[KIT_BENCHS_SIZE_LIMIT]; +} kit_benchs_list_t; + +extern kit_benchs_list_t kit_benchs_list; + +void kit_bench_register(char const *name, char const *file, + kit_bench_run_fn fn); + +#define KIT_BENCHMARK(name) \ + static void KIT_TEST_CONCAT3_(kit_bench_run_, __LINE__, \ + KIT_TEST_FILE)( \ + int, kit_bench_set_repeats_limit_fn, kit_bench_loop_fn, \ + kit_bench_begin_fn, kit_bench_end_fn); \ + KIT_TEST_ON_START_( \ + KIT_TEST_CONCAT3_(kit_benchmark_, __LINE__, KIT_TEST_FILE)) { \ + kit_bench_register( \ + name, __FILE__, \ + KIT_TEST_CONCAT3_(kit_bench_run_, __LINE__, KIT_TEST_FILE)); \ + } \ + static void KIT_TEST_CONCAT3_(kit_bench_run_, __LINE__, \ + KIT_TEST_FILE)( \ + int kit_bench_index_, \ + kit_bench_set_repeats_limit_fn kit_bench_set_repeats_limit_, \ + kit_bench_loop_fn kit_bench_loop_, \ + kit_bench_begin_fn kit_bench_begin_, \ + kit_bench_end_fn kit_bench_end_) + +#define KIT_BENCHMARK_REPEAT(repeats_limit_) \ + kit_bench_set_repeats_limit_(kit_bench_index_, repeats_limit_) + +#define KIT_BENCHMARK_BEGIN \ + while (kit_bench_loop_(kit_bench_index_)) { \ + kit_bench_begin_(kit_bench_index_); \ + { + +#define KIT_BENCHMARK_END \ + } \ + kit_bench_end_(kit_bench_index_); \ + } + +// FIXME +// +#define KIT_DO_NOT_OPTIMIZE(x) \ + do { \ + volatile void *bench_ptr_ = &(x); \ + (void) bench_ptr_; \ + } while (0) + +int kit_run_benchmarks(int argc, char **argv); + +#define TEST KIT_TEST +#define REQUIRE KIT_REQUIRE +#define REQUIRE_EQ KIT_REQUIRE_EQ +#define BENCHMARK KIT_BENCHMARK +#define BENCHMARK_REPEAT KIT_BENCHMARK_REPEAT +#define BENCHMARK_BEGIN KIT_BENCHMARK_BEGIN +#define BENCHMARK_END KIT_BENCHMARK_END +#define DO_NOT_OPTIMIZE KIT_DO_NOT_OPTIMIZE +#define test_register kit_test_register +#define run_tests kit_run_tests +#define bench_register kit_bench_register +#define run_benchmarks kit_run_benchmarks + +#ifdef __cplusplus +} +#endif + +#endif + +// ================================================================ +// +// Implementation +// +// ================================================================ + +#if defined(KIT_TEST_IMPLEMENTATION) && !defined(KIT_TEST_H_IMPL) +#define KIT_TEST_H_IMPL + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef KIT_TIME_H +# define KIT_TIME_H + +# include + +# ifndef TIME_UTC +# define TIME_UTC 1 +# endif + +# ifdef KIT_REQUIRE_TIMESPEC_GET +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +# include + +# define KIT_TIMESPEC_IMPL_UNIX_EPOCH_IN_TICKS \ + 116444736000000000ull +# define KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS 10000000ull + +static int timespec_get(struct timespec *ts, int base) { + if (ts == NULL || base != TIME_UTC) + return 0; + + FILETIME ft; + ULARGE_INTEGER date; + LONGLONG ticks; + + GetSystemTimeAsFileTime(&ft); + date.HighPart = ft.dwHighDateTime; + date.LowPart = ft.dwLowDateTime; + ticks = (LONGLONG) (date.QuadPart - + KIT_TIMESPEC_IMPL_UNIX_EPOCH_IN_TICKS); + ts->tv_sec = ticks / KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS; + ts->tv_nsec = (ticks % KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS) * 100; + + return base; +} +# endif + +#endif + +#include +#include +#include +#include +#include + +enum { + kit_white_, + kit_blue_, + kit_light_, + kit_yellow_, + kit_red_, + kit_green_ +}; + +static char const *kit_color_codes_[] = { "\x1b[38m", "\x1b[34m", + "\x1b[37m", "\x1b[33m", + "\x1b[31m", "\x1b[32m" }; + +static int kit_print_color_(int c) { + return printf("%s", kit_color_codes_[c]); +} + +static int kit_signums_[] = { SIGINT, SIGILL, SIGABRT, + SIGFPE, SIGSEGV, SIGTERM }; + +static char const *kit_signames_[64]; + +static void kit_signames_init_(void) { + memset(kit_signames_, 0, sizeof kit_signames_); + kit_signames_[SIGINT] = "Interactive attention signal"; + kit_signames_[SIGILL] = "Illegal instruction"; + kit_signames_[SIGABRT] = "Abnormal termination"; + kit_signames_[SIGFPE] = "Erroneous arithmetic operation"; + kit_signames_[SIGSEGV] = "Invalid access to storage"; + kit_signames_[SIGTERM] = "Termination request"; +} + +kit_tests_list_t kit_tests_list = { 0 }; + +static void kit_report_(int i, int line, int64_t value, + int64_t expected) { + int n = kit_tests_list.v[i].assertions++; + + if (n >= KIT_TEST_ASSERTIONS_LIMIT) + return; + + kit_tests_list.v[i].line[n] = line; + kit_tests_list.v[i].status[n] = value == expected; + kit_tests_list.v[i].value[n] = value; + kit_tests_list.v[i].expected[n] = expected; +} + +static int64_t ns_to_ms(int64_t ns) { + return (ns + 500000) / 1000000; +} + +static int64_t sec_to_ms(int64_t sec) { + return 1000 * sec; +} + +void kit_test_register(char const *name, char const *file, + kit_test_run_fn fn) { + int n = kit_tests_list.size++; + if (n < KIT_TESTS_SIZE_LIMIT) { + kit_tests_list.v[n].test_fn = fn; + kit_tests_list.v[n].test_name = name; + kit_tests_list.v[n].test_file = file; + kit_tests_list.v[n].assertions = 0; + } +} + +static jmp_buf kit_test_restore_execution; + +static void kit_test_handle_signal(int signum) { + longjmp(kit_test_restore_execution, signum); +} + +static void kit_test_setup_signals() { + for (unsigned i = 0; i < sizeof kit_signums_ / sizeof *kit_signums_; i++) + signal(kit_signums_[i], kit_test_handle_signal); +} + +static int kit_run_test_(volatile int i) { + int signum = setjmp(kit_test_restore_execution); + + if (signum != 0) { + kit_tests_list.v[i].signal = signum; + return 0; + } + + kit_tests_list.v[i].test_fn(i, kit_report_); + return 1; +} + +int kit_run_tests(int argc, char **argv) { + kit_signames_init_(); + + int success_count = 0; + int fail_assertion_count = 0; + int total_assertion_count = 0; + int status = 0; + int quiet = 0; + int no_color = 0; + int line_width = 20; + int carriage_return = 1; + + int i, j; + + char const *specific_test = NULL; + + kit_test_setup_signals(); + + for (i = 0; i < argc; i++) + if (strcmp("--no-term-color", argv[i]) == 0) + no_color = 1; + else if (strcmp("--no-carriage-return", argv[i]) == 0) + carriage_return = 0; + else if (strcmp("--quiet", argv[i]) == 0) + quiet = 1; + else if (strcmp("--match", argv[i]) == 0) + specific_test = argv[++i]; + + quiet && (no_color = 1); + + if (specific_test != NULL) { + no_color || kit_print_color_(kit_light_); + quiet || printf("Run tests matching "); + no_color || kit_print_color_(kit_white_); + quiet || printf("*%s*", specific_test); + no_color || kit_print_color_(kit_light_); + quiet || printf("\n\n"); + } + + char const *file = NULL; + ptrdiff_t file_root = -1; + int tests_total = 0; + + for (i = 0; i < kit_tests_list.size && i < KIT_TESTS_SIZE_LIMIT; + i++) { + if (specific_test != NULL && + strstr(kit_tests_list.v[i].test_name, specific_test) == NULL) + continue; + tests_total++; + int l = 2 + (int) strlen(kit_tests_list.v[i].test_name); + if (line_width < l) + line_width = l; + } + + if (tests_total > 0) { + char const *s = kit_tests_list.v[0].test_file; + + for (j = 1; j < kit_tests_list.size && j < KIT_TESTS_SIZE_LIMIT; + j++) { + if (specific_test != NULL && + strstr(kit_tests_list.v[j].test_name, specific_test) == + NULL) + continue; + if (strcmp(s, kit_tests_list.v[j].test_file) == 0) + continue; + int k = 0; + for (; + s[k] != '\0' && kit_tests_list.v[j].test_file[k] != '\0' && + s[k] == kit_tests_list.v[j].test_file[k]; + k++) { } + if (file_root == -1 || file_root > k) + file_root = k; + } + + if (file_root == -1) { + for (i = 0; s[i] != '\0'; i++) + if (s[i] == '/' || s[i] == '\\') + file_root = i + 1; + } + } + + for (i = 0; i < kit_tests_list.size && i < KIT_TESTS_SIZE_LIMIT; + i++) { + if (specific_test != NULL && + strstr(kit_tests_list.v[i].test_name, specific_test) == NULL) + continue; + if (file == NULL || + strcmp(file, kit_tests_list.v[i].test_file) != 0) { + if (file != NULL) + quiet || printf("\n"); + file = kit_tests_list.v[i].test_file; + no_color || kit_print_color_(kit_blue_); + quiet || printf("* "); + no_color || kit_print_color_(kit_white_); + quiet || printf("%s\n", file + file_root); + } + + !carriage_return || no_color || kit_print_color_(kit_yellow_); + carriage_return || no_color || kit_print_color_(kit_light_); + quiet || printf("` %s ", kit_tests_list.v[i].test_name); + !carriage_return || quiet || printf("\r"); + quiet || fflush(stdout); + + struct timespec begin, end; + timespec_get(&begin, TIME_UTC); + + int test_status = kit_run_test_(i); + + timespec_get(&end, TIME_UTC); + int duration = (int) (ns_to_ms(end.tv_nsec - begin.tv_nsec) + + sec_to_ms(end.tv_sec - begin.tv_sec)); + + for (j = 0; j < kit_tests_list.v[i].assertions && + j < KIT_TEST_ASSERTIONS_LIMIT; + j++) + if (kit_tests_list.v[i].status[j] == 0) { + fail_assertion_count++; + test_status = 0; + } + + if (kit_tests_list.v[i].assertions > KIT_TEST_ASSERTIONS_LIMIT) + test_status = 0; + + total_assertion_count += kit_tests_list.v[i].assertions; + + !carriage_return || no_color || kit_print_color_(kit_light_); + !carriage_return || quiet || + printf("` %s ", kit_tests_list.v[i].test_name); + + int l = (int) strlen(kit_tests_list.v[i].test_name); + quiet || printf("%*c", line_width - l, ' '); + + if (test_status == 0) { + no_color || kit_print_color_(kit_red_); + quiet || printf("FAIL"); + no_color || kit_print_color_(kit_light_); + duration == 0 || quiet || printf(" %d ms", duration); + quiet || printf("\n"); + status = 1; + } else { + no_color || kit_print_color_(kit_green_); + quiet || printf("OK"); + no_color || kit_print_color_(kit_light_); + duration == 0 || quiet || printf(" %d ms", duration); + quiet || printf("\n"); + success_count++; + } + + quiet || fflush(stdout); + } + + no_color || kit_print_color_(kit_white_); + quiet || printf("\n%d of %d tests passed.\n", success_count, + tests_total); + quiet || printf("%d of %d assertions passed.\n\n", + total_assertion_count - fail_assertion_count, + total_assertion_count); + + no_color || kit_print_color_(kit_light_); + + if (!quiet && status != 0) { + int have_kit_report_s = 0; + + for (i = 0; i < kit_tests_list.size && i < KIT_TESTS_SIZE_LIMIT; + i++) { + if (specific_test != NULL && + strstr(kit_tests_list.v[i].test_name, specific_test) == + NULL) + continue; + if (kit_tests_list.v[i].signal != 0) { + int signum = kit_tests_list.v[i].signal; + if (signum >= 0 && + signum < (int) (sizeof kit_signames_ / sizeof *kit_signames_) && + kit_signames_[signum] != NULL) { + no_color || kit_print_color_(kit_light_); + printf("Signal \"%s\" (%d) for \"", kit_signames_[signum], + signum); + no_color || kit_print_color_(kit_white_); + printf("%s", kit_tests_list.v[i].test_name); + no_color || kit_print_color_(kit_light_); + printf("\" in \""); + no_color || kit_print_color_(kit_white_); + + printf("%s", kit_tests_list.v[i].test_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\"!\n"); + } else { + no_color || kit_print_color_(kit_light_); + printf("Unknown signal (%d) for \"", signum); + no_color || kit_print_color_(kit_white_); + printf("%s", kit_tests_list.v[i].test_name); + no_color || kit_print_color_(kit_light_); + printf("\" in \""); + no_color || kit_print_color_(kit_white_); + + printf("%s", kit_tests_list.v[i].test_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\"!\n"); + } + have_kit_report_s = 1; + } + if (kit_tests_list.v[i].assertions > + KIT_TEST_ASSERTIONS_LIMIT) { + no_color || kit_print_color_(kit_light_); + printf("Too many assertions for \""); + no_color || kit_print_color_(kit_white_); + printf("%s", kit_tests_list.v[i].test_name); + no_color || kit_print_color_(kit_light_); + printf("\" in \""); + no_color || kit_print_color_(kit_white_); + + printf("%s", kit_tests_list.v[i].test_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\"!\n"); + have_kit_report_s = 1; + } + } + + have_kit_report_s &&printf("\n"); + } + + if (!quiet && status != 0) { + for (i = 0; i < kit_tests_list.size && i < KIT_TESTS_SIZE_LIMIT; + i++) { + if (specific_test != NULL && + strstr(kit_tests_list.v[i].test_name, specific_test) == + NULL) + continue; + + if (kit_tests_list.v[i].assertions <= KIT_TEST_ASSERTIONS_LIMIT) + for (j = 0; j < kit_tests_list.v[i].assertions; j++) + if (!kit_tests_list.v[i].status[j]) { + no_color || kit_print_color_(kit_light_); + printf("Assertion on line "); + no_color || kit_print_color_(kit_white_); + printf("%d", kit_tests_list.v[i].line[j]); + no_color || kit_print_color_(kit_light_); + printf(" in \""); + no_color || kit_print_color_(kit_white_); + printf("%s", kit_tests_list.v[i].test_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\" failed.\n"); + no_color || kit_print_color_(kit_red_); + printf(" -> "); + no_color || kit_print_color_(kit_light_); + printf("Got wrong value "); + no_color || kit_print_color_(kit_white_); + printf("%10lld", + (long long) kit_tests_list.v[i].value[j]); + no_color || kit_print_color_(kit_light_); + printf(" ("); + no_color || kit_print_color_(kit_white_); + printf("0x%08llx", + (unsigned long long) kit_tests_list.v[i].value[j]); + no_color || kit_print_color_(kit_light_); + printf(")\n"); + no_color || kit_print_color_(kit_green_); + printf(" -> "); + no_color || kit_print_color_(kit_light_); + printf("Expected value "); + no_color || kit_print_color_(kit_white_); + printf("%10lld", + (long long) kit_tests_list.v[i].expected[j]); + no_color || kit_print_color_(kit_light_); + printf(" ("); + no_color || kit_print_color_(kit_white_); + printf( + "0x%08llx", + (unsigned long long) kit_tests_list.v[i].expected[j]); + no_color || kit_print_color_(kit_light_); + printf(")\n\n"); + } + } + } + + if (kit_tests_list.size > KIT_TESTS_SIZE_LIMIT) { + no_color || kit_print_color_(kit_light_); + quiet || printf("Too many tests!\n\n"); + status = 1; + } + + if (status == 0) { + no_color || kit_print_color_(kit_green_); + quiet || printf("OK\n"); + } else { + no_color || kit_print_color_(kit_red_); + quiet || printf("FAILED\n"); + } + + no_color || kit_print_color_(kit_light_); + quiet || printf("\n"); + return status; +} + +kit_benchs_list_t kit_benchs_list = { 0 }; + +static void bench_set_repeats_limit(int i, int repeats_limit) { + if (kit_benchs_list.v[i].ready) + return; + if (kit_benchs_list.v[i].cycles_size >= KIT_BENCH_MAX_CYCLES) + return; + kit_benchs_list.v[i].cycles[kit_benchs_list.v[i].cycles_size] = + repeats_limit; + kit_benchs_list.v[i].cycles_size++; +} + +static int bench_loop(int i) { + if (!kit_benchs_list.v[i].ready) + return 0; + return kit_benchs_list.v[i].repeats < + kit_benchs_list.v[i].cycles[kit_benchs_list.v[i].cycle]; +} + +static void bench_begin(int i) { + int n = kit_benchs_list.v[i].repeats++; + + if (n >= KIT_BENCH_MAX_REPEATS) + return; + + struct timespec tv; + timespec_get(&tv, TIME_UTC); + + kit_benchs_list.v[i].sec[n] = (int64_t) tv.tv_sec; + kit_benchs_list.v[i].nsec[n] = (int64_t) tv.tv_nsec; +} + +static void bench_end(int i) { + int n = kit_benchs_list.v[i].repeats - 1; + + if (n < 0 || n >= KIT_BENCH_MAX_REPEATS) + return; + + struct timespec tv; + timespec_get(&tv, TIME_UTC); + + int64_t sec = ((int64_t) tv.tv_sec) - kit_benchs_list.v[i].sec[n]; + int64_t nsec = ((int64_t) tv.tv_nsec) - + kit_benchs_list.v[i].nsec[n]; + + kit_benchs_list.v[i].duration_nsec[n] = sec * 1000000000 + nsec; +} + +void kit_bench_register(char const *name, char const *file, + kit_bench_run_fn fn) { + int n = kit_benchs_list.size++; + if (n < KIT_BENCHS_SIZE_LIMIT) { + kit_benchmark_t *bench = kit_benchs_list.v + n; + + bench->bench_fn = fn; + bench->bench_name = name; + bench->bench_file = file; + bench->cycles_size = 0; + bench->ready = 0; + } +} + +static void kit_bench_setup_signals() { + for (unsigned i = 0; i < sizeof kit_signums_ / sizeof *kit_signums_; i++) + signal(kit_signums_[i], kit_test_handle_signal); +} + +static int kit_run_bench_(volatile int i) { + int signum = setjmp(kit_test_restore_execution); + + if (signum != 0) { + kit_benchs_list.v[i].signal = signum; + return 0; + } + + kit_benchs_list.v[i].bench_fn(i, bench_set_repeats_limit, + bench_loop, bench_begin, bench_end); + return 1; +} + +static int kit_compare_64_(void const *x_, void const *y_) { + int64_t const *x = (int64_t const *) x_; + int64_t const *y = (int64_t const *) y_; + return *x - *y; +} + +static int kit_compare_32_(void const *x_, void const *y_) { + int const *x = (int const *) x_; + int const *y = (int const *) y_; + return *x - *y; +} + +int kit_run_benchmarks(int argc, char **argv) { + int success_count = 0; + int status = 0; + int no_color = 0; + int line_width = 20; + int carriage_return = 1; + + char const *specific_bench = NULL; + + kit_bench_setup_signals(); + + for (int i = 0; i < argc; i++) + if (strcmp("--no-term-color", argv[i]) == 0) + no_color = 1; + else if (strcmp("--no-carriage-return", argv[i]) == 0) + carriage_return = 0; + else if (strcmp("--match", argv[i]) == 0) + specific_bench = argv[++i]; + + if (specific_bench != NULL) { + no_color || kit_print_color_(kit_light_); + printf("Run benchmarks matching "); + no_color || kit_print_color_(kit_white_); + printf("*%s*", specific_bench); + no_color || kit_print_color_(kit_light_); + printf("\n\n"); + } + + char const *file = NULL; + ptrdiff_t file_root = -1; + int benchs_total = 0; + + for (int i = 0; + i < kit_benchs_list.size && i < KIT_BENCHS_SIZE_LIMIT; i++) { + if (specific_bench != NULL && + strstr(kit_benchs_list.v[i].bench_name, specific_bench) == + NULL) + continue; + benchs_total++; + int l = 2 + (int) strlen(kit_benchs_list.v[i].bench_name); + if (line_width < l) + line_width = l; + } + + if (benchs_total > 0) { + char const *s = kit_benchs_list.v[0].bench_file; + + for (int j = 1; + j < kit_benchs_list.size && j < KIT_BENCHS_SIZE_LIMIT; j++) { + kit_benchmark_t *bench = kit_benchs_list.v + j; + + if (specific_bench != NULL && + strstr(bench->bench_name, specific_bench) == NULL) + continue; + if (strcmp(s, bench->bench_file) == 0) + continue; + int k = 0; + for (; s[k] != '\0' && bench->bench_file[k] != '\0' && + s[k] == bench->bench_file[k]; + k++) { } + if (file_root == -1 || file_root > k) + file_root = k; + } + + if (file_root == -1) { + for (int i = 0; s[i] != '\0'; i++) + if (s[i] == '/' || s[i] == '\\') + file_root = i + 1; + } + } + + no_color || kit_print_color_(kit_blue_); + printf("# "); + no_color || kit_print_color_(kit_light_); + printf("BENCHMARK"); + printf("%*c", line_width - 9, ' '); + no_color || kit_print_color_(kit_green_); + printf(" LOW "); + no_color || kit_print_color_(kit_light_); + printf("|"); + no_color || kit_print_color_(kit_blue_); + printf(" MEDIAN "); + no_color || kit_print_color_(kit_light_); + printf("|"); + no_color || kit_print_color_(kit_yellow_); + printf(" HIGH\n"); + no_color || kit_print_color_(kit_light_); + printf(" (in microseconds)\n\n"); + + /* Prepare cycles. + */ + + for (int i = 0; + i < kit_benchs_list.size && i < KIT_BENCHS_SIZE_LIMIT; i++) { + kit_benchmark_t *bench = kit_benchs_list.v + i; + + if (specific_bench != NULL && + strstr(bench->bench_name, specific_bench) == NULL) + continue; + + kit_run_bench_(i); + + if (bench->cycles_size == 0) { + bench->cycles_size = 2; + bench->cycles[0] = KIT_BENCH_REPEATS_DEFAULT_1; + bench->cycles[1] = KIT_BENCH_REPEATS_DEFAULT_2; + } + + qsort(bench->cycles, bench->cycles_size, sizeof *bench->cycles, + kit_compare_32_); + + kit_benchs_list.v[i].ready = 1; + } + + /* Run cycles. + */ + + for (int cycle = 0; cycle < KIT_BENCH_MAX_CYCLES; cycle++) { + /* Prepare cycle. + */ + + int cycles_done = 1; + + for (int i = 0; + i < kit_benchs_list.size && i < KIT_BENCHS_SIZE_LIMIT; i++) { + kit_benchmark_t *bench = kit_benchs_list.v + i; + + if (specific_bench != NULL && + strstr(bench->bench_name, specific_bench) == NULL) + continue; + if (cycle >= bench->cycles_size) + continue; + + bench->repeats = 0; + bench->cycle = cycle; + cycles_done = 0; + } + + if (cycles_done) + break; + + /* Run benchmarks. + */ + + for (int i = 0; + i < kit_benchs_list.size && i < KIT_BENCHS_SIZE_LIMIT; i++) { + kit_benchmark_t *bench = kit_benchs_list.v + i; + + if (specific_bench != NULL && + strstr(bench->bench_name, specific_bench) == NULL) + continue; + if (cycle >= bench->cycles_size) + continue; + + if (file == NULL || strcmp(file, bench->bench_file) != 0) { + if (file != NULL) + printf("\n"); + file = bench->bench_file; + no_color || kit_print_color_(kit_blue_); + printf("* "); + no_color || kit_print_color_(kit_white_); + printf("%s\n", file + file_root); + } + + !carriage_return || no_color || kit_print_color_(kit_yellow_); + carriage_return || no_color || kit_print_color_(kit_light_); + printf("` %s ", bench->bench_name); + !carriage_return || printf("\r"); + fflush(stdout); + + int bench_status = kit_run_bench_(i); + + if (bench->repeats > KIT_BENCH_MAX_REPEATS) + bench_status = 0; + + !carriage_return || no_color || kit_print_color_(kit_light_); + !carriage_return || printf("` %s ", bench->bench_name); + + int l = (int) strlen(bench->bench_name); + printf("%*c", line_width - l, ' '); + + if (bench->repeats <= 0) { + no_color || kit_print_color_(kit_yellow_); + printf(" 0 runs\n"); + success_count++; + } else if (bench_status == 0) { + no_color || kit_print_color_(kit_red_); + printf(" FAIL\n"); + status = 1; + } else { + int repeats = bench->repeats; + + memcpy(bench->duration_sorted_nsec, bench->duration_nsec, + repeats * sizeof *bench->duration_sorted_nsec); + qsort(bench->duration_sorted_nsec, repeats, + sizeof *bench->duration_sorted_nsec, kit_compare_64_); + + int64_t average = bench->duration_sorted_nsec[repeats / 2]; + int64_t floor = bench->duration_sorted_nsec[repeats / 20]; + int64_t roof = + bench->duration_sorted_nsec[repeats - repeats / 20 - 1]; + + no_color || kit_print_color_(kit_white_); + printf("%-9g", (double) floor * 0.001); + no_color || kit_print_color_(kit_light_); + printf("| "); + no_color || kit_print_color_(kit_white_); + printf("%-9g", (double) average * 0.001); + no_color || kit_print_color_(kit_light_); + printf("| "); + no_color || kit_print_color_(kit_white_); + printf("%-9g", (double) roof * 0.001); + no_color || kit_print_color_(kit_light_); + printf(" %d runs\n", repeats); + success_count++; + } + } + } + + printf("\n"); + + if (status != 0) { + for (int i = 0; + i < kit_benchs_list.size && i < KIT_BENCHS_SIZE_LIMIT; i++) { + kit_benchmark_t *bench = kit_benchs_list.v + i; + + if (specific_bench != NULL && + strstr(bench->bench_name, specific_bench) == NULL) + continue; + if (bench->signal != 0) { + int signum = bench->signal; + if (signum >= 0 && + signum < (int) (sizeof kit_signames_ / sizeof *kit_signames_) && + kit_signames_[signum] != NULL) { + no_color || kit_print_color_(kit_light_); + printf("Signal \"%s\" (%d) for \"", kit_signames_[signum], + signum); + no_color || kit_print_color_(kit_white_); + printf("%s", bench->bench_name); + no_color || kit_print_color_(kit_light_); + printf("\" in \""); + no_color || kit_print_color_(kit_white_); + printf("%s", bench->bench_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\"!.\n"); + } else { + no_color || kit_print_color_(kit_light_); + printf("Unknown signal (%d) for \"", signum); + no_color || kit_print_color_(kit_white_); + printf("%s", bench->bench_name); + no_color || kit_print_color_(kit_light_); + printf("\" in \""); + no_color || kit_print_color_(kit_white_); + printf("%s", bench->bench_file + file_root); + no_color || kit_print_color_(kit_light_); + printf("\"!.\n"); + } + } + } + + printf("\n"); + } + + if (kit_benchs_list.size > KIT_BENCHS_SIZE_LIMIT) { + no_color || kit_print_color_(kit_light_); + printf("Too many benchmarks!\n\n"); + status = 1; + } + + if (status == 0) { + no_color || kit_print_color_(kit_green_); + printf("DONE\n"); + } else { + no_color || kit_print_color_(kit_red_); + printf("DONE WITH ERRORS\n"); + } + + no_color || kit_print_color_(kit_light_); + printf("\n"); + return status; +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/threads.h b/kit/threads.h new file mode 100644 index 0000000..a636e99 --- /dev/null +++ b/kit/threads.h @@ -0,0 +1,129 @@ +#ifndef KIT_THREADS_H +#define KIT_THREADS_H +#ifndef KIT_DISABLE_SYSTEM_THREADS + +# include "time.h" + +# include +# include + +# if !defined(_WIN32) || defined(__CYGWIN__) +# include +# endif + +# if defined(__cplusplus) +# define _Noreturn [[noreturn]] +# elif defined(_MSC_VER) +# define _Noreturn __declspec(noreturn) +# endif + +# ifndef _Thread_local +# if defined(__cplusplus) +// C++11 doesn't need `_Thread_local` keyword or macro +# elif !defined(__STDC_NO_THREADS__) +// threads are optional in C11, _Thread_local present in this +// condition +# elif defined(_MSC_VER) +# define _Thread_local __declspec(thread) +# elif defined(__GNUC__) +# define _Thread_local __thread +# else +// Leave _Thread_local undefined so that use of _Thread_local would +// not promote to a non-thread-local global variable +# endif +# endif + +# if !defined(__cplusplus) +// C11 thread_local() macro C++11 and above already have thread_local +// keyword +# ifndef thread_local +# if _MSC_VER +# define thread_local __declspec(thread) +# else +# define thread_local _Thread_local +# endif +# endif +# endif + +# ifdef __cplusplus +extern "C" { +# endif + +enum { + mtx_plain, + mtx_recursive, + mtx_timed, +}; + +enum { + thrd_success, + thrd_timedout, + thrd_error, + thrd_busy, + thrd_nomem, + thrd_wrong_stack_size +}; + +# if defined(_WIN32) && !defined(__CYGWIN__) +typedef struct { + void *DebugInfo; + long LockCount; + long RecursionCount; + void *OwningThread; + void *LockSemaphore; + uintptr_t SpinCount; +} mtx_t; + +typedef struct { + void *Ptr; +} cnd_t; + +typedef struct { + volatile uintptr_t status; +} once_flag; + +typedef struct { + void *handle; +} thrd_t; + +# else +typedef pthread_mutex_t mtx_t; +typedef pthread_cond_t cnd_t; +typedef pthread_once_t once_flag; +typedef pthread_t thrd_t; +# endif + +typedef int (*thrd_start_t)(void *); + +void mtx_destroy(mtx_t *mtx_); +int mtx_init(mtx_t *mtx_, int); +int mtx_lock(mtx_t *mtx_); +int mtx_timedlock(mtx_t *__restrict mtx_, + struct timespec const *__restrict); +int mtx_trylock(mtx_t *mtx_); +int mtx_unlock(mtx_t *mtx_); +void call_once(once_flag *, void (*)(void)); +int cnd_broadcast(cnd_t *); +void cnd_destroy(cnd_t *); +int cnd_init(cnd_t *); +int cnd_signal(cnd_t *); +int cnd_timedwait(cnd_t *__restrict, mtx_t *__restrict mtx_, + struct timespec const *__restrict); +int cnd_wait(cnd_t *, mtx_t *mtx_); +int thrd_create(thrd_t *, thrd_start_t, void *); +int thrd_create_with_stack(thrd_t *, thrd_start_t, void *, + ptrdiff_t stack_size); +thrd_t thrd_current(void); +int thrd_detach(thrd_t); +int thrd_equal(thrd_t, thrd_t); +_Noreturn void thrd_exit(int); +int thrd_join(thrd_t, int *); +int thrd_sleep(struct timespec const *, struct timespec *); +void thrd_yield(void); + +# ifdef __cplusplus +} +# endif + +#endif +#endif diff --git a/kit/threads.posix.c b/kit/threads.posix.c new file mode 100644 index 0000000..44465a3 --- /dev/null +++ b/kit/threads.posix.c @@ -0,0 +1,271 @@ +#include "threads.h" + +#ifndef KIT_DISABLE_SYSTEM_THREADS +# include "allocator.h" + +# if !defined(_WIN32) || defined(__CYGWIN__) +# include +# include +# include +# include +# include +# include + +# ifndef PTHREAD_STACK_MIN +# define PTHREAD_STACK_MIN 16384 +# endif + +/* +Configuration macro: + + EMULATED_THREADS_USE_NATIVE_TIMEDLOCK + Use pthread_mutex_timedlock() for `mtx_timedlock()' + Otherwise use mtx_trylock() + *busy loop* emulation. +*/ +# if !defined(__CYGWIN__) && !defined(__APPLE__) && \ + !defined(__NetBSD__) +# define EMULATED_THREADS_USE_NATIVE_TIMEDLOCK +# endif + +/* +Implementation limits: + - Conditionally emulation for "mutex with timeout" + (see EMULATED_THREADS_USE_NATIVE_TIMEDLOCK macro) +*/ +typedef struct { + thrd_start_t func; + void *arg; +} impl_thrd_param_t; + +static void *impl_thrd_routine(void *p) { + impl_thrd_param_t pack = *((impl_thrd_param_t *) p); + kit_alloc_dispatch(NULL, KIT_DEALLOCATE, 0, 0, p); + return (void *) (intptr_t) pack.func(pack.arg); +} + +void call_once(once_flag *flag, void (*func)(void)) { + pthread_once(flag, func); +} + +int cnd_broadcast(cnd_t *cond) { + assert(cond != NULL); + return (pthread_cond_broadcast(cond) == 0) ? thrd_success + : thrd_error; +} + +void cnd_destroy(cnd_t *cond) { + assert(cond); + pthread_cond_destroy(cond); +} + +int cnd_init(cnd_t *cond) { + assert(cond != NULL); + return (pthread_cond_init(cond, NULL) == 0) ? thrd_success + : thrd_error; +} + +int cnd_signal(cnd_t *cond) { + assert(cond != NULL); + return (pthread_cond_signal(cond) == 0) ? thrd_success : thrd_error; +} + +int cnd_timedwait(cnd_t *cond, mtx_t *mtx, + struct timespec const *abs_time) { + int rt; + + assert(mtx != NULL); + assert(cond != NULL); + assert(abs_time != NULL); + + rt = pthread_cond_timedwait(cond, mtx, abs_time); + if (rt == ETIMEDOUT) + return thrd_timedout; + return (rt == 0) ? thrd_success : thrd_error; +} + +int cnd_wait(cnd_t *cond, mtx_t *mtx) { + assert(mtx != NULL); + assert(cond != NULL); + return (pthread_cond_wait(cond, mtx) == 0) ? thrd_success + : thrd_error; +} + +void mtx_destroy(mtx_t *mtx) { + assert(mtx != NULL); + pthread_mutex_destroy(mtx); +} + +/* + * XXX: Workaround when building with -O0 and without pthreads link. + * + * In such cases constant folding and dead code elimination won't be + * available, thus the compiler will always add the pthread_mutexattr* + * functions into the binary. As we try to link, we'll fail as the + * symbols are unresolved. + * + * Ideally we'll enable the optimisations locally, yet that does not + * seem to work. + * + * So the alternative workaround is to annotate the symbols as weak. + * Thus the linker will be happy and things don't clash when building + * with -O1 or greater. + */ +# if defined(KIT_HAVE_FUNC_ATTRIBUTE_WEAK) && !defined(__CYGWIN__) +__attribute__((weak)) int pthread_mutexattr_init( + pthread_mutexattr_t *attr); + +__attribute__((weak)) int pthread_mutexattr_settype( + pthread_mutexattr_t *attr, int type); + +__attribute__((weak)) int pthread_mutexattr_destroy( + pthread_mutexattr_t *attr); +# endif + +int mtx_init(mtx_t *mtx, int type) { +# ifdef KIT_HAVE_PTHREAD_MUTEXATTR_SETTYPE + pthread_mutexattr_t attr; +# endif + assert(mtx != NULL); + if (type != mtx_plain && type != mtx_timed && + type != (mtx_plain | mtx_recursive) && + type != (mtx_timed | mtx_recursive)) + return thrd_error; + + if ((type & mtx_recursive) == 0) { + pthread_mutex_init(mtx, NULL); + return thrd_success; + } + +# ifdef KIT_HAVE_PTHREAD_MUTEXATTR_SETTYPE + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(mtx, &attr); + pthread_mutexattr_destroy(&attr); + return thrd_success; +# else + return thrd_error; +# endif +} + +int mtx_lock(mtx_t *mtx) { + assert(mtx != NULL); + return (pthread_mutex_lock(mtx) == 0) ? thrd_success : thrd_error; +} + +int mtx_timedlock(mtx_t *mtx, const struct timespec *ts) { + assert(mtx != NULL); + assert(ts != NULL); + + { +# ifdef EMULATED_THREADS_USE_NATIVE_TIMEDLOCK + int rt; + rt = pthread_mutex_timedlock(mtx, ts); + if (rt == 0) + return thrd_success; + return (rt == ETIMEDOUT) ? thrd_timedout : thrd_error; +# else + time_t expire = time(NULL); + expire += ts->tv_sec; + while (mtx_trylock(mtx) != thrd_success) { + time_t now = time(NULL); + if (expire < now) + return thrd_timedout; + // busy loop! + thrd_yield(); + } + return thrd_success; +# endif + } +} + +int mtx_trylock(mtx_t *mtx) { + assert(mtx != NULL); + return (pthread_mutex_trylock(mtx) == 0) ? thrd_success : thrd_busy; +} + +int mtx_unlock(mtx_t *mtx) { + assert(mtx != NULL); + return (pthread_mutex_unlock(mtx) == 0) ? thrd_success : thrd_error; +} + +int thrd_create_with_stack(thrd_t *thr, thrd_start_t func, void *arg, + ptrdiff_t const require_stack_size) { + impl_thrd_param_t *pack; + assert(thr != NULL); + assert(require_stack_size == 0 || + require_stack_size >= PTHREAD_STACK_MIN); + pthread_attr_t attr; + pthread_attr_t *attr_p = NULL; + if (require_stack_size > 0) { + ptrdiff_t const page_size = (ptrdiff_t) sysconf(_SC_PAGESIZE); + ptrdiff_t const delta = require_stack_size % page_size; + ptrdiff_t const stack_size = delta == 0 ? require_stack_size + : require_stack_size + + page_size - delta; + if (pthread_attr_init(&attr) != 0) + return thrd_nomem; + if (pthread_attr_setstacksize(&attr, (size_t) stack_size) != 0) + return thrd_wrong_stack_size; + attr_p = &attr; + } + + pack = (impl_thrd_param_t *) kit_alloc_dispatch( + NULL, KIT_ALLOCATE, sizeof(impl_thrd_param_t), 0, NULL); + if (!pack) { + if (attr_p) + pthread_attr_destroy(attr_p); + return thrd_nomem; + } + pack->func = func; + pack->arg = arg; + if (pthread_create(thr, attr_p, impl_thrd_routine, pack) != 0) { + kit_alloc_dispatch(NULL, KIT_DEALLOCATE, 0, 0, pack); + if (attr_p) + pthread_attr_destroy(attr_p); + return thrd_error; + } + if (attr_p) + pthread_attr_destroy(attr_p); + return thrd_success; +} + +int thrd_create(thrd_t *thr, thrd_start_t func, void *arg) { + return thrd_create_with_stack(thr, func, arg, 0); +} +thrd_t thrd_current(void) { + return pthread_self(); +} + +int thrd_detach(thrd_t thr) { + return (pthread_detach(thr) == 0) ? thrd_success : thrd_error; +} + +int thrd_equal(thrd_t thr0, thrd_t thr1) { + return pthread_equal(thr0, thr1); +} + +_Noreturn void thrd_exit(int res) { + pthread_exit((void *) (intptr_t) res); +} + +int thrd_join(thrd_t thr, int *res) { + void *code; + if (pthread_join(thr, &code) != 0) + return thrd_error; + if (res) + *res = (int) (intptr_t) code; + return thrd_success; +} + +int thrd_sleep(const struct timespec *time_point, + struct timespec *remaining) { + assert(time_point != NULL); + return nanosleep(time_point, remaining); +} + +void thrd_yield(void) { + sched_yield(); +} + +# endif +#endif diff --git a/kit/threads.win32.c b/kit/threads.win32.c new file mode 100644 index 0000000..ac185f7 --- /dev/null +++ b/kit/threads.win32.c @@ -0,0 +1,342 @@ +#include "threads.h" + +#ifndef KIT_DISABLE_SYSTEM_THREADS +# include "allocator.h" + +# if defined(_WIN32) && !defined(__CYGWIN__) +# include +# include +# include +# include +# include + +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +# ifndef NOMINMAX +# define NOMINMAX +# endif +# include + +/* +Configuration macro: + + EMULATED_THREADS_USE_NATIVE_CALL_ONCE + Use native WindowsAPI one-time initialization function. + (requires WinVista or later) + Otherwise emulate by mtx_trylock() + *busy loop* for WinXP. +*/ + +# if _WIN32_WINNT >= 0x0600 +/* Prefer native WindowsAPI on newer environment. */ +# if !defined(__MINGW32__) +# define EMULATED_THREADS_USE_NATIVE_CALL_ONCE +# endif +# endif + +/* check configuration */ +# if defined(EMULATED_THREADS_USE_NATIVE_CALL_ONCE) && \ + (_WIN32_WINNT < 0x0600) +# error EMULATED_THREADS_USE_NATIVE_CALL_ONCE requires _WIN32_WINNT>=0x0600 +# endif + +static_assert(sizeof(cnd_t) == sizeof(CONDITION_VARIABLE), + "The size of cnd_t must equal to CONDITION_VARIABLE"); +static_assert(sizeof(thrd_t) == sizeof(HANDLE), + "The size of thrd_t must equal to HANDLE"); +static_assert(sizeof(mtx_t) == sizeof(CRITICAL_SECTION), + "The size of mtx_t must equal to CRITICAL_SECTION"); +static_assert(sizeof(once_flag) == sizeof(INIT_ONCE), + "The size of once_flag must equal to INIT_ONCE"); + +/* +Implementation limits: + - Conditionally emulation for "Initialization functions" + (see EMULATED_THREADS_USE_NATIVE_CALL_ONCE macro) + - Emulated `mtx_timelock()' with mtx_trylock() + *busy loop* +*/ + +typedef struct { + thrd_start_t func; + void *arg; + thrd_t thrd; +} impl_thrd_param_t; + +struct thrd_state { + thrd_t thrd; + int handle_need_close; +}; + +static thread_local struct thrd_state impl_current_thread = { 0 }; + +static unsigned __stdcall impl_thrd_routine(void *p) { + impl_thrd_param_t *pack_p = (impl_thrd_param_t *) p; + impl_thrd_param_t pack; + int code; + impl_current_thread.thrd = pack_p->thrd; + impl_current_thread.handle_need_close = 0; + memcpy(&pack, pack_p, sizeof(impl_thrd_param_t)); + kit_alloc_dispatch(NULL, KIT_DEALLOCATE, 0, 0, p); + code = pack.func(pack.arg); + return (unsigned) code; +} + +static time_t impl_timespec2msec(const struct timespec *ts) { + return (ts->tv_sec * 1000U) + (ts->tv_nsec / 1000000L); +} + +static DWORD impl_abs2relmsec(const struct timespec *abs_time) { + const time_t abs_ms = impl_timespec2msec(abs_time); + struct timespec now; + timespec_get(&now, TIME_UTC); + const time_t now_ms = impl_timespec2msec(&now); + const DWORD rel_ms = (abs_ms > now_ms) ? (DWORD) (abs_ms - now_ms) + : 0; + return rel_ms; +} + +# ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE +struct impl_call_once_param { + void (*func)(void); +}; + +static BOOL CALLBACK impl_call_once_callback(PINIT_ONCE InitOnce, + PVOID Parameter, + PVOID *Context) { + struct impl_call_once_param *param = (struct impl_call_once_param *) + Parameter; + (param->func)(); + ((void) InitOnce); + ((void) Context); /* suppress warning */ + return TRUE; +} +# endif /* ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE */ + +void call_once(once_flag *flag, void (*func)(void)) { + assert(flag && func); +# ifdef EMULATED_THREADS_USE_NATIVE_CALL_ONCE + { + struct impl_call_once_param param; + param.func = func; + InitOnceExecuteOnce((PINIT_ONCE) flag, impl_call_once_callback, + (PVOID) ¶m, NULL); + } +# else + if (InterlockedCompareExchangePointer( + (PVOID volatile *) &flag->status, (PVOID) 1, (PVOID) 0) == + 0) { + (func)(); + InterlockedExchangePointer((PVOID volatile *) &flag->status, + (PVOID) 2); + } else { + while (flag->status == 1) { + // busy loop! + thrd_yield(); + } + } +# endif +} + +int cnd_broadcast(cnd_t *cond) { + assert(cond != NULL); + WakeAllConditionVariable((PCONDITION_VARIABLE) cond); + return thrd_success; +} + +void cnd_destroy(cnd_t *cond) { + assert(cond != NULL); + /* do nothing */ + (void) cond; +} + +int cnd_init(cnd_t *cond) { + assert(cond != NULL); + InitializeConditionVariable((PCONDITION_VARIABLE) cond); + return thrd_success; +} + +int cnd_signal(cnd_t *cond) { + assert(cond != NULL); + WakeConditionVariable((PCONDITION_VARIABLE) cond); + return thrd_success; +} + +int cnd_timedwait(cnd_t *cond, mtx_t *mtx, + const struct timespec *abs_time) { + assert(cond != NULL); + assert(mtx != NULL); + assert(abs_time != NULL); + const DWORD timeout = impl_abs2relmsec(abs_time); + if (SleepConditionVariableCS((PCONDITION_VARIABLE) cond, + (PCRITICAL_SECTION) mtx, timeout)) + return thrd_success; + return (GetLastError() == ERROR_TIMEOUT) ? thrd_timedout + : thrd_error; +} + +int cnd_wait(cnd_t *cond, mtx_t *mtx) { + assert(cond != NULL); + assert(mtx != NULL); + SleepConditionVariableCS((PCONDITION_VARIABLE) cond, + (PCRITICAL_SECTION) mtx, INFINITE); + return thrd_success; +} + +void mtx_destroy(mtx_t *mtx) { + assert(mtx); + DeleteCriticalSection((PCRITICAL_SECTION) mtx); +} + +int mtx_init(mtx_t *mtx, int type) { + assert(mtx != NULL); + if (type != mtx_plain && type != mtx_timed && + type != (mtx_plain | mtx_recursive) && + type != (mtx_timed | mtx_recursive)) + return thrd_error; + InitializeCriticalSection((PCRITICAL_SECTION) mtx); + return thrd_success; +} + +int mtx_lock(mtx_t *mtx) { + assert(mtx != NULL); + EnterCriticalSection((PCRITICAL_SECTION) mtx); + return thrd_success; +} + +int mtx_timedlock(mtx_t *mtx, const struct timespec *ts) { + assert(mtx != NULL); + assert(ts != NULL); + while (mtx_trylock(mtx) != thrd_success) { + if (impl_abs2relmsec(ts) == 0) + return thrd_timedout; + /* busy loop! */ + thrd_yield(); + } + return thrd_success; +} + +int mtx_trylock(mtx_t *mtx) { + assert(mtx != NULL); + return TryEnterCriticalSection((PCRITICAL_SECTION) mtx) + ? thrd_success + : thrd_busy; +} + +int mtx_unlock(mtx_t *mtx) { + assert(mtx != NULL); + LeaveCriticalSection((PCRITICAL_SECTION) mtx); + return thrd_success; +} + +int thrd_create_with_stack(thrd_t *thr, thrd_start_t func, void *arg, + ptrdiff_t const stack_size) { + impl_thrd_param_t *pack; + uintptr_t handle; + assert(thr != NULL); + assert(stack_size >= 0 && stack_size < 0x100000000); + + pack = (impl_thrd_param_t *) kit_alloc_dispatch( + NULL, KIT_ALLOCATE, (sizeof(impl_thrd_param_t)), 0, NULL); + if (!pack) + return thrd_nomem; + pack->func = func; + pack->arg = arg; + handle = _beginthreadex(NULL, (unsigned) stack_size, + impl_thrd_routine, pack, CREATE_SUSPENDED, + NULL); + if (handle == 0) { + kit_alloc_dispatch(NULL, KIT_DEALLOCATE, 0, 0, pack); + if (errno == EAGAIN || errno == EACCES) + return thrd_nomem; + return thrd_error; + } + thr->handle = (void *) handle; + pack->thrd = *thr; + ResumeThread((HANDLE) handle); + return thrd_success; +} + +int thrd_create(thrd_t *thr, thrd_start_t func, void *arg) { + return thrd_create_with_stack(thr, func, arg, 0); +} + +thrd_t thrd_current(void) { + /* GetCurrentThread() returns a pseudo-handle, which we need + * to pass to DuplicateHandle(). Only the resulting handle can be + * used from other threads. + * + * Note that neither handle can be compared to the one by + * thread_create. Only the thread IDs - as returned by GetThreadId() + * and GetCurrentThreadId() can be compared directly. + * + * Other potential solutions would be: + * - define thrd_t as a thread Ids, but this would mean we'd need to + * OpenThread for many operations + * - use malloc'ed memory for thrd_t. This would imply using TLS for + * current thread. + * + * Neither is particularly nice. + * + * Life would be much easier if C11 threads had different + * abstractions for threads and thread IDs, just like C++11 threads + * does... + */ + struct thrd_state *state = &impl_current_thread; + if (state->thrd.handle == NULL) { + if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), + GetCurrentProcess(), &(state->thrd.handle), + 0, FALSE, DUPLICATE_SAME_ACCESS)) { + abort(); + } + state->handle_need_close = 1; + } + return state->thrd; +} + +int thrd_detach(thrd_t thr) { + CloseHandle(thr.handle); + return thrd_success; +} + +int thrd_equal(thrd_t thr0, thrd_t thr1) { + return GetThreadId(thr0.handle) == GetThreadId(thr1.handle); +} + +_Noreturn void thrd_exit(int res) { + _endthreadex((unsigned) res); +} + +int thrd_join(thrd_t thr, int *res) { + DWORD w, code; + if (thr.handle == NULL) { + return thrd_error; + } + w = WaitForSingleObject(thr.handle, INFINITE); + if (w != WAIT_OBJECT_0) + return thrd_error; + if (res) { + if (!GetExitCodeThread(thr.handle, &code)) { + CloseHandle(thr.handle); + return thrd_error; + } + *res = (int) code; + } + CloseHandle(thr.handle); + return thrd_success; +} + +int thrd_sleep(const struct timespec *time_point, + struct timespec *remaining) { + (void) remaining; + assert(time_point); + assert(!remaining); /* not implemented */ + Sleep((DWORD) impl_timespec2msec(time_point)); + return 0; +} + +void thrd_yield(void) { + SwitchToThread(); +} + +# endif +#endif diff --git a/kit/time.h b/kit/time.h new file mode 100644 index 0000000..c14f8ff --- /dev/null +++ b/kit/time.h @@ -0,0 +1,54 @@ +#ifndef KIT_TIME_H +#define KIT_TIME_H + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef TIME_UTC +# define TIME_UTC 1 +#endif + +#ifdef KIT_REQUIRE_TIMESPEC_GET +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +# ifndef NOMINMAX +# define NOMINMAX 1 +# endif +# include + +# define KIT_TIMESPEC_IMPL_UNIX_EPOCH_IN_TICKS 116444736000000000ull +# define KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS 10000000ull + +static int timespec_get(struct timespec *ts, int base) { + if (ts == NULL || base != TIME_UTC) + return 0; + + FILETIME ft; + ULARGE_INTEGER date; + LONGLONG ticks; + + GetSystemTimeAsFileTime(&ft); + date.HighPart = ft.dwHighDateTime; + date.LowPart = ft.dwLowDateTime; + ticks = (LONGLONG) (date.QuadPart - + KIT_TIMESPEC_IMPL_UNIX_EPOCH_IN_TICKS); + ts->tv_sec = ticks / KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS; + ts->tv_nsec = (ticks % KIT_TIMESPEC_IMPL_TICKS_PER_SECONDS) * 100; + + return base; +} +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/types.h b/kit/types.h new file mode 100644 index 0000000..bbe8717 --- /dev/null +++ b/kit/types.h @@ -0,0 +1,36 @@ +#ifndef KIT_TYPES_H +#define KIT_TYPES_H + +#ifndef _GNU_SOURCE +# define _GNU_SOURCE +#endif + +// signed integers +// +typedef signed char i8; +typedef signed short i16; +typedef signed int i32; +typedef signed long long i64; + +// unsigned integers +// +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; + +// floats +// +typedef float f32; +typedef double f64; + +// chars +// +typedef char c8; +typedef int c32; + +typedef signed char b8; // 8-bit boolean +typedef signed int b32; // 32-bit boolean +typedef signed int s32; // 32-bit status + +#endif diff --git a/kit/unival.c b/kit/unival.c new file mode 100644 index 0000000..4fed179 --- /dev/null +++ b/kit/unival.c @@ -0,0 +1,51 @@ +#include "unival.h" + +kit_uv_decode_result_t kit_uv_decode(kit_is_handle_t is, + kit_allocator_t *alloc) { + kit_uv_decode_result_t result; + memset(&result, 0, sizeof result); + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +kit_uv_encode_result_t kit_uv_encode(kit_unival_t *value, + kit_allocator_t *alloc, + i32 flags) { + kit_uv_encode_result_t result; + memset(&result, 0, sizeof result); + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +kit_uv_decode_result_t kit_uv_parse(kit_is_handle_t is, + kit_allocator_t *alloc) { + kit_uv_decode_result_t result; + memset(&result, 0, sizeof result); + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +kit_uv_decode_result_t kit_uv_parse_json(kit_is_handle_t is, + kit_allocator_t *alloc) { + kit_uv_decode_result_t result; + memset(&result, 0, sizeof result); + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +kit_uv_print_result_t kit_uv_print(kit_unival_t *value, + kit_allocator_t *alloc, + i32 flags) { + kit_uv_print_result_t result; + memset(&result, 0, sizeof result); + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +void kit_uv_destroy(kit_unival_t *value) { } + diff --git a/kit/unival.h b/kit/unival.h new file mode 100644 index 0000000..e0362b1 --- /dev/null +++ b/kit/unival.h @@ -0,0 +1,86 @@ +#ifndef KIT_UNIVAL_H +#define KIT_UNIVAL_H + +#include "string_builder.h" +#include "input_stream.h" + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + KIT_UV_NONE, + KIT_UV_BOOLEAN, + KIT_UV_INTEGER, + KIT_UV_FLOAT, + KIT_UV_STRING, + KIT_UV_BYTES, + KIT_UV_ARRAY, + KIT_UV_COMPOSITE, +}; + +enum { + KIT_UV_ENCODE_BZIP = 1, + KIT_UV_PRINT_PRETTY = 1, + KIT_UV_PRINT_JSON = 2, +}; + +typedef struct kit_unival_ kit_unival_t; + +typedef KIT_DA(kit_unival_t) kit_da_unival_t; +typedef KIT_DA(u8) kit_uv_bytes_t; + +struct kit_unival_ { + i8 type; + union { + i8 boolean; + i64 integer; + f64 float_; + kit_str_builder_t string; + kit_uv_bytes_t bytes; + kit_da_unival_t array; + struct { + kit_da_unival_t keys; + kit_da_unival_t values; + } composite; + }; +}; + +typedef struct { + s32 status; + kit_unival_t *value; +} kit_uv_decode_result_t; + +kit_uv_decode_result_t kit_uv_decode(kit_is_handle_t is, + kit_allocator_t *alloc); + +typedef struct { + s32 status; + kit_uv_bytes_t value; +} kit_uv_encode_result_t; + +kit_uv_encode_result_t kit_uv_encode(kit_unival_t *value, + kit_allocator_t *alloc, + i32 flags); + +kit_uv_decode_result_t kit_uv_parse(kit_is_handle_t is, + kit_allocator_t *alloc); + +kit_uv_decode_result_t kit_uv_parse_json(kit_is_handle_t is, + kit_allocator_t *alloc); + +typedef struct { + s32 status; + kit_str_builder_t value; +} kit_uv_print_result_t; + +kit_uv_print_result_t kit_uv_print(kit_unival_t *value, + kit_allocator_t *alloc, i32 flags); + +void kit_uv_destroy(kit_unival_t *value); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/utf8.h b/kit/utf8.h new file mode 100644 index 0000000..3dc6822 --- /dev/null +++ b/kit/utf8.h @@ -0,0 +1,44 @@ +#ifndef KIT_UTF8_H +#define KIT_UTF8_H + +#include "string_builder.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-function" +# pragma GCC diagnostic ignored "-Wunknown-pragmas" +# pragma GCC push_options +# pragma GCC optimize("O3") +#endif + +static s32 kit_utf8_count(kit_str_t s, i64 *count) { + return KIT_ERROR_NOT_IMPLEMENTED; +} + +static s32 kit_utf8_offset(kit_str_t s, i64 count, i64 *offset) { + return KIT_ERROR_NOT_IMPLEMENTED; +} + +static s32 kit_utf8_decode(kit_str_t s, i64 offset, i64 *size, + c32 *value) { + return KIT_ERROR_NOT_IMPLEMENTED; +} + +static s32 kit_utf8_encode(kit_str_builder_t *s, c32 value) { + return KIT_ERROR_NOT_IMPLEMENTED; +} + +#if defined(__GNUC__) || defined(__clang__) +# pragma GCC pop_options +# pragma GCC diagnostic pop +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kit/xml.c b/kit/xml.c new file mode 100644 index 0000000..f61bfc1 --- /dev/null +++ b/kit/xml.c @@ -0,0 +1,483 @@ +#include "xml.h" + +#include "input_buffer.h" +#include + +typedef struct { + ib_token_t last; + str_builder_t text; + kit_da_xml_t tags; +} kit_xml_intermediate_t; + +static s32 kit_xml_alloc_and_unescape_(str_builder_t *dst, str_t str, + kit_allocator_t *alloc) { + assert(dst != NULL); + assert(str.size == 0 || str.values != NULL); + + if (dst == NULL) + return KIT_ERROR_INTERNAL; + if (str.size != 0 && str.values == NULL) + return KIT_ERROR_INTERNAL; + + DA_INIT(*dst, str.size, alloc); + + if (dst->size != str.size) + return KIT_ERROR_OUT_OF_MEMORY; + + dst->size = 0; + + for (i64 i = 0; i < str.size; i++) + if (str.values[i] != '&') + dst->values[dst->size++] = str.values[i]; + else { + i64 n = 1; + while (i + n < str.size && str.values[i + n] != ';') + n++; + if (i + n >= str.size) { + DA_DESTROY(*dst); + return KIT_PARSING_FAILED; + } + if (n == 3 && memcmp(str.values + i, "<", 4) == 0) + dst->values[dst->size++] = '<'; + else if (n == 3 && memcmp(str.values + i, ">", 4) == 0) + dst->values[dst->size++] = '>'; + else if (n == 4 && memcmp(str.values + i, "&", 5) == 0) + dst->values[dst->size++] = '&'; + else if (n == 5 && memcmp(str.values + i, """, 6) == 0) + dst->values[dst->size++] = '"'; + else if (n == 5 && memcmp(str.values + i, "'", 6) == 0) + dst->values[dst->size++] = '\''; + else if (n - 2 <= 8 && str.values[i + 1] == '#' && + str.values[i + 2] == 'x') { + // hex encoding + // + + c8 buf[8]; + u64 x = 0; + + memcpy(buf, str.values + (i + 3), n - 2); + + for (i64 k = 0; k < n - 2; k++) { + c8 c = str.values[i + 3 + k]; + x <<= 8; + if (c >= '0' && c <= '9') + x |= (c - '0'); + else if (c >= 'a' && c <= 'f') + x |= 10 + (c - 'a'); + else if (c >= 'A' && c <= 'F') + x |= 10 + (c - 'A'); + else { + x = 0; + break; + } + } + + if (x == 0 || x > 255u) { + // TODO + // UTF-8 encoding + + DA_DESTROY(*dst); + return KIT_PARSING_FAILED; + } + + dst->values[dst->size++] = (c8) x; + } else if (n - 1 <= 20 && str.values[i + 1] == '#') { + // dec encoding + // + + c8 buf[20]; + u64 x = 0; + + memcpy(buf, str.values + (i + 2), n - 2); + + for (i64 k = 0; k < n - 1; k++) { + c8 c = str.values[i + 2 + k]; + x *= 10; + if (c >= '0' && c <= '9') + x += (c - '0'); + else { + x = 0; + break; + } + } + + if (x == 0 || x > 255u) { + // TODO + // UTF-8 encoding + + DA_DESTROY(*dst); + return KIT_PARSING_FAILED; + } + + dst->values[dst->size++] = (c8) x; + } else { + DA_DESTROY(*dst); + return KIT_PARSING_FAILED; + } + i += n; + } + + return KIT_OK; +} + +static ib_token_t kit_xml_parse_text_(ib_token_t begin, + str_builder_t *dst) { + ib_token_t last = ib_until(begin, SZ("<")); + + DA_RESIZE(*dst, last.size); + + assert(dst->size == last.size); + if (dst->size != last.size) + last.status |= KIT_ERROR_OUT_OF_MEMORY; + else if (last.size > 0) + memcpy(dst->values, ib_str(last).values, last.size); + + for (;;) { + ib_token_t comment_open = ib_exact(last, SZ("")); + ib_token_t comment_close = ib_exact(comment_text, SZ("-->")); + ib_token_t next_text = ib_until(comment_close, SZ("<")); + + if (next_text.status == KIT_OK && next_text.size > 0) { + i64 n = dst->size; + DA_RESIZE(*dst, n + next_text.size); + + assert(dst->size == n + next_text.size); + if (dst->size != n + next_text.size) + next_text.status |= KIT_ERROR_OUT_OF_MEMORY; + else + memcpy(dst->values + n, ib_str(next_text).values, + ib_str(next_text).size); + } + + last = next_text; + } + + return last; +} + +static ib_token_t kit_xml_parse_string_(ib_token_t begin, + ib_token_t *value) { + assert(value != NULL); + if (value == NULL) { + begin.status |= KIT_ERROR_INTERNAL; + return begin; + } + + ib_token_t quotes_open = ib_exact(begin, SZ("\"")); + ib_token_t apostr_open = ib_exact(begin, SZ("'")); + + ib_token_t open = quotes_open.status == KIT_OK ? quotes_open + : apostr_open; + + *value = ib_until(open, ib_str(open)); + ib_token_t close = ib_exact(*value, ib_str(open)); + + return close; +} + +static kit_xml_intermediate_t kit_xml_parse_buf_( + ib_token_t begin, kit_allocator_t *alloc) { + kit_xml_intermediate_t res; + memset(&res, 0, sizeof res); + + ib_token_t last, spaces; + memset(&last, 0, sizeof last); + memset(&spaces, 0, sizeof spaces); + + str_builder_t tag_text_string; + str_builder_t tag_tail_string; + DA_INIT(tag_text_string, 0, alloc); + DA_INIT(tag_tail_string, 0, alloc); + + ib_token_t tag_text = kit_xml_parse_text_(begin, &tag_text_string); + last = tag_text; + + DA_INIT(res.tags, 0, alloc); + + for (;;) { + ib_token_t tagend_open = ib_exact(last, SZ("")); + + DA_INIT(tag.properties, 0, alloc); + + last = tag_name; + + for (;;) { + spaces = ib_any(last, SZ(" \t\r\n")); + ib_token_t property = ib_none(spaces, SZ(" \t\r\n=?/>")); + + if (property.status != KIT_OK || property.size == 0) + break; + + spaces = ib_any(property, SZ(" \t\r\n")); + ib_token_t equals = ib_exact(spaces, SZ("=")); + spaces = ib_any(equals, SZ(" \t\r\n")); + + ib_token_t value; + last = kit_xml_parse_string_(spaces, &value); + + if (last.status == KIT_OK) { + i64 n = tag.properties.size; + DA_RESIZE(tag.properties, n + 1); + + assert(tag.properties.size == n + 1); + if (tag.properties.size != n + 1) { + last.status |= KIT_ERROR_OUT_OF_MEMORY; + DA_DESTROY(tag.properties); + } else { + last.status |= kit_xml_alloc_and_unescape_( + &tag.properties.values[n].name, ib_str(property), + alloc); + last.status |= kit_xml_alloc_and_unescape_( + &tag.properties.values[n].value, ib_str(value), alloc); + } + } + } + + if (tag.is_declaration) { + ib_token_t tag_decl_close = ib_exact(spaces, SZ("?>")); + + last = tag_decl_close; + + DA_INIT(tag.text, 0, alloc); + DA_INIT(tag.children, 0, alloc); + } else { + ib_token_t tag_close = ib_exact(spaces, SZ(">")); + ib_token_t tag_close_empty = ib_exact(spaces, SZ("/>")); + + if (tag_close.status == KIT_OK) { + kit_xml_intermediate_t im = kit_xml_parse_buf_(tag_close, + alloc); + + tag.text = im.text; + tag.children = im.tags; + + tagend_open = ib_exact(im.last, SZ("")); + + last = tagend_close; + + } else if (tag_close_empty.status == KIT_OK) { + last = tag_close_empty; + + DA_INIT(tag.text, 0, alloc); + DA_INIT(tag.children, 0, alloc); + } else + last.status |= KIT_PARSING_FAILED; + } + + ib_token_t tag_tail = kit_xml_parse_text_(last, &tag_tail_string); + + last = tag_tail; + + if (last.status == KIT_OK) { + i64 n = res.tags.size; + DA_RESIZE(res.tags, n + 1); + + assert(res.tags.size == n + 1); + if (res.tags.size != n + 1) { + last.status |= KIT_ERROR_OUT_OF_MEMORY; + xml_destroy(&tag); + } else { + last.status |= kit_xml_alloc_and_unescape_( + &tag.tag, ib_str(tag_name), alloc); + last.status |= kit_xml_alloc_and_unescape_( + &tag.tail, WRAP_STR(tag_tail_string), alloc); + + res.tags.values[n] = tag; + } + } else + xml_destroy(&tag); + } + + if (last.status != KIT_OK) { + for (i64 i = 0; i < res.tags.size; i++) + xml_destroy(res.tags.values + i); + DA_DESTROY(res.text); + DA_DESTROY(res.tags); + } else + last.status |= kit_xml_alloc_and_unescape_( + &res.text, WRAP_STR(tag_text_string), alloc); + + DA_DESTROY(tag_text_string); + DA_DESTROY(tag_tail_string); + + res.last = last; + return res; +} + +kit_xml_parse_result_t kit_xml_parse(is_handle_t is, + kit_allocator_t *alloc) { + input_buffer_t ib = ib_init(is, alloc); + kit_xml_intermediate_t im = kit_xml_parse_buf_(ib_token(&ib), + alloc); + + kit_xml_parse_result_t res; + memset(&res, 0, sizeof res); + + res.status = im.last.status; + + if (res.status != KIT_OK) { + ib_destroy(&ib); + return res; + } + + if (im.text.size == 0 && im.tags.size == 1) { + res.xml = im.tags.values[0]; + DA_DESTROY(im.text); + DA_DESTROY(im.tags); + ib_destroy(&ib); + return res; + } + + DA_INIT(res.xml.tag, 0, alloc); + DA_INIT(res.xml.tail, 0, alloc); + DA_INIT(res.xml.properties, 0, alloc); + + res.xml.text = im.text; + res.xml.children = im.tags; + + ib_destroy(&ib); + return res; +} + +kit_xml_text_t kit_xml_print(kit_xml_t *xml, kit_allocator_t *alloc) { + // TODO + // + + assert(xml != NULL); + + xml_text_t result; + memset(&result, 0, sizeof result); + + (void) alloc; + + result.status = KIT_ERROR_NOT_IMPLEMENTED; + return result; +} + +static s32 kit_xml_append_text_(str_builder_t *buf, xml_t *xml) { + assert(buf != NULL); + assert(xml != NULL); + + i64 n = buf->size; + DA_RESIZE(*buf, n + xml->text.size); + + assert(buf->size == n + xml->text.size); + if (buf->size != n + xml->text.size) + return KIT_ERROR_OUT_OF_MEMORY; + + if (xml->text.size > 0) + memcpy(buf->values + n, xml->text.values, xml->text.size); + + for (i64 i = 0; i < xml->children.size; i++) { + s32 s = kit_xml_append_text_(buf, xml->children.values + i); + if (s != KIT_OK) + return s; + + str_t tail = WRAP_STR(xml->children.values[i].tail); + + if (tail.size <= 0) + continue; + + n = buf->size; + DA_RESIZE(*buf, n + tail.size); + + assert(buf->size == n + tail.size); + if (buf->size != n + tail.size) + return KIT_ERROR_OUT_OF_MEMORY; + + if (tail.size > 0) + memcpy(buf->values + n, tail.values, tail.size); + } + + return KIT_OK; +} + +kit_xml_text_t kit_xml_full_text(kit_xml_t *xml, + kit_allocator_t *alloc) { + kit_xml_text_t res; + res.status = KIT_OK; + DA_INIT(res.text, 0, alloc); + + if (xml != NULL) + res.status = kit_xml_append_text_(&res.text, xml); + else + res.status = KIT_ERROR_INVALID_ARGUMENT; + + return res; +} + +b8 kit_xml_has_property(kit_xml_t *xml, kit_str_t name) { + assert(xml != NULL); + if (xml == NULL) + return 0; + + for (i64 i = 0; i < xml->properties.size; i++) + if (AR_EQUAL(xml->properties.values[i].name, name)) + return 1; + + return 0; +} + +str_t kit_xml_property(kit_xml_t *xml, str_t name) { + assert(xml != NULL); + if (xml == NULL) + return str(0, NULL); + + for (i64 i = 0; i < xml->properties.size; i++) + if (AR_EQUAL(xml->properties.values[i].name, name)) + return WRAP_STR(xml->properties.values[i].value); + + assert(0); + return str(0, NULL); +} + +void kit_xml_destroy(kit_xml_t *xml) { + assert(xml != NULL); + if (xml == NULL) + return; + + for (i64 i = 0; i < xml->properties.size; i++) { + DA_DESTROY(xml->properties.values[i].name); + DA_DESTROY(xml->properties.values[i].value); + } + + for (i64 i = 0; i < xml->children.size; i++) + kit_xml_destroy(xml->children.values + i); + + DA_DESTROY(xml->tag); + DA_DESTROY(xml->text); + DA_DESTROY(xml->tail); + + DA_DESTROY(xml->properties); + DA_DESTROY(xml->children); +} diff --git a/kit/xml.h b/kit/xml.h new file mode 100644 index 0000000..a4dd3d1 --- /dev/null +++ b/kit/xml.h @@ -0,0 +1,64 @@ +#ifndef KIT_XML_H +#define KIT_XML_H + +#include "string_builder.h" +#include "input_stream.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct kit_xml_ kit_xml_t; + +typedef struct { + kit_str_builder_t name; + kit_str_builder_t value; +} kit_xml_property_t; + +typedef KIT_DA(kit_xml_property_t) kit_da_xml_property_t; +typedef KIT_DA(kit_xml_t) kit_da_xml_t; + +struct kit_xml_ { + i8 is_declaration; + kit_str_builder_t tag; + kit_str_builder_t text; + kit_str_builder_t tail; + kit_da_xml_property_t properties; + kit_da_xml_t children; +}; + +typedef struct { + s32 status; + kit_xml_t xml; +} kit_xml_parse_result_t; + +typedef struct { + s32 status; + kit_str_builder_t text; +} kit_xml_text_t; + +kit_xml_parse_result_t kit_xml_parse(kit_is_handle_t is, + kit_allocator_t *alloc); +kit_xml_text_t kit_xml_print(kit_xml_t *xml, kit_allocator_t *alloc); +kit_xml_text_t kit_xml_full_text(kit_xml_t *xml, + kit_allocator_t *alloc); +b8 kit_xml_has_property(kit_xml_t *xml, kit_str_t name); +kit_str_t kit_xml_property(kit_xml_t *xml, kit_str_t name); +void kit_xml_destroy(kit_xml_t *xml); + +#ifdef __cplusplus +} +#endif + +#define xml_t kit_xml_t +#define xml_property_t kit_xml_property_t +#define xml_parse_result_t kit_xml_parse_result_t +#define xml_text_t kit_xml_text_t +#define xml_parse kit_xml_parse +#define xml_print kit_xml_print +#define xml_full_text kit_xml_full_text +#define xml_has_property kit_xml_has_property +#define xml_property kit_xml_property +#define xml_destroy kit_xml_destroy + +#endif -- cgit v1.2.3