From 6a359e7f4ba77f97e93db57e06d28cd6bf5a332f Mon Sep 17 00:00:00 2001 From: Gregory Lirent Date: Thu, 2 Jun 2022 14:22:19 +0300 Subject: [PATCH] Add base --- src/extra.c | 134 ++++++++++++++++++++++++++ src/vnode.c | 273 ++++++++++++++++++++++++++++++++++++++++++++++++++++ src/vtype.c | 268 +++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 675 insertions(+) create mode 100644 src/extra.c create mode 100644 src/vnode.c create mode 100644 src/vtype.c diff --git a/src/extra.c b/src/extra.c new file mode 100644 index 0000000..4d8ae6a --- /dev/null +++ b/src/extra.c @@ -0,0 +1,134 @@ +/* This software is licensed by the MIT License, see LICENSE file */ +/* Copyright © 2022 Gregory Lirent */ + +#include +#include "../include/extra/cstring.h" +#include "__internal/include.h" +#undef aligned_alloc +#undef malloc +#undef realloc +#undef calloc + +/*#####################################################################################################################*/ + +void* libcdsb_aalloc(size_t a, size_t n) { + void* x; + + if ((x = aligned_alloc(a, n))) + return x; + abort(); +} + + +void* libcdsb_calloc(size_t n, size_t c) { + void* x; + + if ((x = calloc(n, c))) + return x; + abort(); +} + + +void* libcdsb_malloc(size_t n) { + void* x; + + if ((x = malloc(n))) + return x; + abort(); +} + + +void* libcdsb_realloc(void* x, size_t n) { + if ((x = realloc(x, n))) + return x; + abort(); +} + + +/*#####################################################################################################################*/ + + +void* libcdsb_memndup(const void* m, size_t n) { + void* x; + + if ((x = malloc(n))) + return memcpy(x, m, n); + abort(); +} + + +char* libcdsb_strdup(const char* s) { + void* x; + size_t n; + + if ((x = malloc(n = strlen(s) + 1))) + return memcpy(x, s, n); + abort(); +} + + +char* libcdsb_strndup(const char* s, size_t n) { + void* x; + + if ((x = malloc(n + 1))) { + ((char*)memcpy(x, s, n))[n] = 0; + return x; + } + abort(); +} + + +/*#####################################################################################################################*/ + + +size_t libcdsb_strlen(const char* s) { + static const size_t m = (sizeof(size_t) == 8) ? 0x8080808080808080UL : 0x80808080UL; + static const size_t d = (sizeof(size_t) == 8) ? 0x0101010101010101UL : 0x01010101UL; + + const u8_t* p; + const size_t* w; + + p = (void*)s; + + while((uintptr_t)p%sizeof(size_t)) { + if (!*p) return (void*)p - (void*)s; + ++p; + } + + w = (void*)p; + + while (!((*w-d)&(~*w&m))) { ++w; } + + p = (void*)w; + + while (*p) { ++p; } + + return (void*)p - (void*)s; +} + + +size_t libcdsb_strasciilen(const char* s) { + static const size_t m = (sizeof(size_t) == 8) ? 0x8080808080808080UL : 0x80808080UL; + static const size_t d = (sizeof(size_t) == 8) ? 0x0101010101010101UL : 0x01010101UL; + + const u8_t* p; + const size_t* w; + + p = (void*)s; + + while((uintptr_t)p%sizeof(size_t)) { + if (!*p || (*p&0x80)) + return (void*)p - (void*)s; + ++p; + } + + w = (void*)p; + + while (!((*w&m)||((*w-d)&m))) { ++w; } + + p = (void*)w; + + while (*p && !(*p&0x80)) { ++p; } + + return (void*)p - (void*)s; +} diff --git a/src/vnode.c b/src/vnode.c new file mode 100644 index 0000000..f198c93 --- /dev/null +++ b/src/vnode.c @@ -0,0 +1,273 @@ +/* This software is licensed by the MIT License, see LICENSE file */ +/* Copyright © 2022 Gregory Lirent */ + +#include "__internal/assert.h" +#include "__internal/vnode.h" + +/*#####################################################################################################################*/ + + +static vnode_t create_number(vtype xt, const void* v, vtype t) { + var_t _ = { .ptr = 0 }; + + if (t == VTYPE_POINTER) t = (sizeof(void*) == 8) ? VTYPE_UINT64 : VTYPE_UINT32; + if (t == VTYPE_BOOLEAN) t = VTYPE_UINT8; + + if (xt == VTYPE_POINTER) xt = (sizeof(void*) == 8) ? VTYPE_UINT64 : VTYPE_UINT32; + if (xt == VTYPE_BOOLEAN) xt = VTYPE_UINT8; + + switch (xt) { default: default_: abort(); + case VTYPE_INT8: + case VTYPE_UINT8: switch (t) { default: goto default_; + case VTYPE_INT8: + case VTYPE_UINT8: _.u8 = *(u8_t*)v; break; + case VTYPE_INT16: + case VTYPE_UINT16: _.u8 = *(u16_t*)v; break; + case VTYPE_INT32: + case VTYPE_UINT32: _.u8 = *(u32_t*)v; break; + case VTYPE_INT64: + case VTYPE_UINT64: _.u8 = *(u64_t*)v; break; + } + break; + + case VTYPE_INT16: + case VTYPE_UINT16: switch (t) { default: goto default_; + case VTYPE_INT8: + case VTYPE_UINT8: _.u16 = *(u8_t*)v; break; + case VTYPE_INT16: + case VTYPE_UINT16: _.u16 = *(u16_t*)v; break; + case VTYPE_INT32: + case VTYPE_UINT32: _.u16 = *(u32_t*)v; break; + case VTYPE_INT64: + case VTYPE_UINT64: _.u16 = *(u64_t*)v; break; + } + break; + + case VTYPE_INT32: + case VTYPE_UINT32: switch (t) { default: goto default_; + case VTYPE_INT8: + case VTYPE_UINT8: _.u32 = *(u8_t*)v; break; + case VTYPE_INT16: + case VTYPE_UINT16: _.u32 = *(u16_t*)v; break; + case VTYPE_INT32: + case VTYPE_UINT32: _.u32 = *(u32_t*)v; break; + case VTYPE_INT64: + case VTYPE_UINT64: _.u32 = *(u64_t*)v; break; + } + break; + + case VTYPE_INT64: + case VTYPE_UINT64: switch (t) { default: goto default_; + case VTYPE_INT8: + case VTYPE_UINT8: _.u64 = *(u8_t*)v; goto u64_; + case VTYPE_INT16: + case VTYPE_UINT16: _.u64 = *(u16_t*)v; goto u64_; + case VTYPE_INT32: + case VTYPE_UINT32: _.u64 = *(u32_t*)v; goto u64_; + case VTYPE_INT64: + case VTYPE_UINT64: _.u64 = *(u64_t*)v; + u64_: if (!is_x64) _.ptr = memndup(&_.u64, sizeof(_.u64)); + break; + } + break; + + case VTYPE_FLOAT: switch (t) { default: goto default_; + case VTYPE_DOUBLE: _.f = *(dbl_t*)v; goto f_; + case VTYPE_LDOUBLE: _.f = *(ldbl_t*)v; goto f_; + case VTYPE_FLOAT: _.f = *(fl_t*)v; + f_: if (!is_permissible(fl_t)) _.ptr = memndup(&_.f, sizeof(_.f)); + break; + } + break; + + case VTYPE_DOUBLE: switch (t) { default: goto default_; + case VTYPE_FLOAT: _.d = *(fl_t*)v; goto d_; + case VTYPE_LDOUBLE: _.d = *(ldbl_t*)v; goto d_; + case VTYPE_DOUBLE: _.d = *(dbl_t*)v; + d_: if (!is_permissible(dbl_t)) _.ptr = memndup(&_.d, sizeof(_.d)); + break; + } + break; + + case VTYPE_LDOUBLE: switch (t) { default: goto default_; + case VTYPE_FLOAT: _.ld = *(fl_t*)v; goto ld_; + case VTYPE_DOUBLE: _.ld = *(dbl_t*)v; goto ld_; + case VTYPE_LDOUBLE: _.ld = *(ldbl_t*)v; + ld_: if (!is_permissible(ldbl_t)) _.ptr = memndup(&_.ld, sizeof(_.ld)); + break; + } + break; + } + + return _.ptr; +} + + +/*#####################################################################################################################*/ + + +vnode_t hhttpc_vnode_create(const void* v, vtype t) { + var_t _ = { .ptr = 0 }; + + switch (t) { default: abort(); + + case VTYPE_INT8: + case VTYPE_UINT8: _.u8 = *(u8_t*)v; + break; + + case VTYPE_INT16: + case VTYPE_UINT16: _.u16 = *(u16_t*)v; + break; + + case VTYPE_INT32: + case VTYPE_UINT32: _.u32 = *(u32_t*)v; + break; + + case VTYPE_INT64: + case VTYPE_UINT64: + u64_: if (is_x64) _.u64 = *(u64_t*)v; + else _.ptr = memndup(v, sizeof(u64_t)); + break; + + case VTYPE_FLOAT: if (is_permissible(fl_t)) _.ld = *(fl_t*)v; + else _.ptr = memndup(v, sizeof(fl_t)); + break; + + case VTYPE_DOUBLE: if (is_permissible(dbl_t)) _.ld = *(dbl_t*)v; + else _.ptr = memndup(v, sizeof(dbl_t)); + break; + + case VTYPE_LDOUBLE: if (is_permissible(ldbl_t)) _.ld = *(ldbl_t*)v; + else _.ptr = memndup(v, sizeof(ldbl_t)); + break; + + + case VTYPE_BOOLEAN: _.b = *(_Bool*)v; + break; + + case VTYPE_POINTER: _.ptr = *(void**)v; + break; + + case VTYPE_STRING: _.ptr = string_duplicate(v); + break; + + case VTYPE_MAP: _.ptr = map_duplicate(v); + break; + + case VTYPE_ARRAY: _.ptr = array_duplicate(v); + break; + + case VTYPE_LIST: _.ptr = list_duplicate(v); + break; + + case VTYPE_SET: _.ptr = vset_duplicate(v); + break; + } + + return _.ptr; +} + + +/*#####################################################################################################################*/ + + +void* libcdsb_vnode_peek(const vnode_t* x, vtype t) { + switch (t) { default: abort(); + + case VTYPE_FLOAT: if (is_permissible(fl_t)) goto vt_; else goto pt_; + case VTYPE_DOUBLE: if (is_permissible(dbl_t)) goto vt_; else goto pt_; + case VTYPE_LDOUBLE: if (is_permissible(ldbl_t)) goto vt_; else goto pt_; + + case VTYPE_INT64: + case VTYPE_UINT64: if (!is_x64) goto pt_; + + case VTYPE_BOOLEAN: + case VTYPE_POINTER: + case VTYPE_INT8: + case VTYPE_UINT8: + case VTYPE_INT16: + case VTYPE_UINT16: + case VTYPE_INT32: + case VTYPE_UINT32: + vt_: return (void*)x; + + case VTYPE_STRING: + case VTYPE_MAP: + case VTYPE_ARRAY: + case VTYPE_LIST: + case VTYPE_SET: + pt_: return *x; + } +} + + +void libcdsb_vnode_free(vnode_t* x, vtype t) { + + switch (t) { default: abort(); + + case VTYPE_FLOAT: if (is_permissible(fl_t)) goto vt_; else goto pt_; + case VTYPE_DOUBLE: if (is_permissible(dbl_t)) goto vt_; else goto pt_; + case VTYPE_LDOUBLE: if (is_permissible(ldbl_t)) goto vt_; else goto pt_; + + case VTYPE_INT64: + case VTYPE_UINT64: if (!is_x64) goto pt_; + + case VTYPE_BOOLEAN: + case VTYPE_POINTER: + case VTYPE_INT8: + case VTYPE_UINT8: + case VTYPE_INT16: + case VTYPE_UINT16: + case VTYPE_INT32: + case VTYPE_UINT32: + vt_: + break; + + case VTYPE_STRING: string_free(*x); goto pt_; + case VTYPE_MAP: map_free(*x); goto pt_; + case VTYPE_ARRAY: array_free(*x); goto pt_; + case VTYPE_LIST: list_free(*x); goto pt_; + case VTYPE_SET: vset_free(*x); + pt_: free(*x); + break; + } + + *x = 0; +} + + +/*#####################################################################################################################*/ + + +vnode_t libcdsb_vnode_create_target(vtype xt, const void* v, vtype t) { + var_t _ = { .ptr = 0 }; + + if (is_integer(xt)) { + tvalue_assert(t); + return create_number(xt, v, t); + } else if (is_float(xt)) { + tfloat_assert(t); + return create_number(xt, v, t); + } + + type_assert(xt, t); + + switch (xt) { default: abort(); + case VTYPE_STRING: _.ptr = string_duplicate(v); + break; + + case VTYPE_MAP: _.ptr = map_duplicate(v); + break; + + case VTYPE_ARRAY: _.ptr = array_duplicate(v); + break; + + case VTYPE_LIST: _.ptr = list_duplicate(v); + break; + + case VTYPE_SET: _.ptr = vset_duplicate(v); + break; + } + + return _.ptr; +} diff --git a/src/vtype.c b/src/vtype.c new file mode 100644 index 0000000..9d5a605 --- /dev/null +++ b/src/vtype.c @@ -0,0 +1,268 @@ +/* This software is licensed by the MIT License, see LICENSE file */ +/* Copyright © 2022 Gregory Lirent */ + +#include "__internal/include.h" + +#define max_align _Alignof(max_align_t) +#define max_size ((sizeof(ldbl_t) >= 8) ? sizeof(ldbl_t) : 8) + +/*#####################################################################################################################*/ + +ainline(vtype expandu8(u32_t* v)) { + if (is_little_endian) { + *v &= 0x000000ff; + } else { + *v >>= 24; + } + return VTYPE_UINT32; +} + +ainline(vtype expandu16(u32_t* v)) { + if (is_little_endian) { + *v &= 0x0000ffff; + } else { + *v >>= 16; + } + return VTYPE_UINT32; +} + +ainline(vtype expands8(u32_t* v)) { + if (is_big_endian) + *v >>= 24; + *v |= 0xffffff00; + + return VTYPE_INT32; +} + +ainline(vtype expands16(u32_t* v)) { + if (is_big_endian) + *v >>= 16; + *v |= 0xffff0000; + + return VTYPE_INT32; +} + + +/*#####################################################################################################################*/ + + +const size_t LIBCDSB_VTYPE_SIZES[18] = { + sizeof(void*), sizeof(_Bool), + sizeof(u8_t), sizeof(u16_t), sizeof(u32_t), sizeof(u64_t), + sizeof(s8_t), sizeof(s16_t), sizeof(s32_t), sizeof(s64_t), + sizeof(fl_t), sizeof(dbl_t), sizeof(ldbl_t), + sizeof(str_t), sizeof(map_t), sizeof(arr_t), + sizeof(list_t), sizeof(set_t) +}; + + +/*#####################################################################################################################*/ + + +int libcdsb_vtype_compare_values(const void* s0, vtype t0, const void* s1, vtype t1) { + + int c; + size_t _Alignas(max_align) v0[max_size/sizeof(size_t)]; + size_t _Alignas(max_align) v1[max_size/sizeof(size_t)]; + + c = t0 - t1; + + if (t0 >= VTYPE_STRING || t1 >= VTYPE_STRING) { + static int(*compare[5])(const void*,const void*) = { + (void*)string_compare, + (void*) map_compare, + (void*) array_compare, + (void*) list_compare, + (void*) vset_compare + }; + + if (c) return c; + + t0 -= VTYPE_STRING; + return compare[t0](s0, s1); + } + + if (t0 == VTYPE_POINTER) t0 = (sizeof(void*) == 8) ? VTYPE_UINT64 : VTYPE_UINT32; + if (t1 == VTYPE_POINTER) t1 = (sizeof(void*) == 8) ? VTYPE_UINT64 : VTYPE_UINT32; + if (t0 == VTYPE_BOOLEAN) t0 = VTYPE_UINT8; + if (t1 == VTYPE_BOOLEAN) t1 = VTYPE_UINT8; + + if (!c) { + + if (s0 == s1) + return 0; + + if (t0 == VTYPE_LDOUBLE) { + *(ldbl_t*)v0 = *(ldbl_t*)s0 - *(ldbl_t*)s1; + + ldouble_: + if (!*(ldbl_t*)v0) + return 0; + return *(ldbl_t*)v0 < 0 ? -1 : 1; + } else if (t0 == VTYPE_DOUBLE) { + *(ldbl_t*)v0 = *(dbl_t*)s0 - *(dbl_t*)s1; + goto ldouble_; + } else if (t0 == VTYPE_FLOAT) { + *(ldbl_t*)v0 = *(fl_t*)s0 - *(fl_t*)s1; + goto ldouble_; + } + + if (t0 == VTYPE_UINT8) + return *(u8_t*)s0 - *(u8_t*)s1; + if (t0 == VTYPE_UINT16) + return *(u16_t*)s0 - *(u16_t*)s1; + if (t0 == VTYPE_UINT32) + return *(u32_t*)s0 - *(u32_t*)s1; + + return *(u64_t*)s0 - *(u64_t*)s1; + + } else if (t0 >= VTYPE_FLOAT && t1 >= VTYPE_FLOAT) { + if (t0 == VTYPE_FLOAT) { + *(ldbl_t*)v0 = *(fl_t*)s0; + } else if (t0 == VTYPE_DOUBLE) { + *(ldbl_t*)v0 = *(dbl_t*)s0; + } else if (t0 == VTYPE_LDOUBLE) { + *(ldbl_t*)v0 = *(ldbl_t*)s0; + } + + if (t1 == VTYPE_FLOAT) { + *(ldbl_t*)v0 -= *(fl_t*)s1; + } else if (t1 == VTYPE_DOUBLE) { + *(ldbl_t*)v0 -= *(dbl_t*)s1; + } else { + *(ldbl_t*)v0 -= *(ldbl_t*)s1; + } + + goto ldouble_; + } + + memcpy(v0, s0, 8); + memcpy(v1, s1, 8); + + if (t0 <= VTYPE_UINT64 && t1 <= VTYPE_UINT64) { + + if (t0 == VTYPE_UINT8) { + t0 = expandu8((void*)v0); + } else if (t0 == VTYPE_UINT16) { + t0 = expandu16((void*)v0); + } else if (t0 == VTYPE_UINT64 && *(u64_t*)v0 <= UINT32_MAX) { + t0 = VTYPE_UINT32; + } + + if (t1 == VTYPE_UINT8) { + t1 = expandu8((void*)v1); + } else if (t1 == VTYPE_UINT16) { + t1 = expandu16((void*)v1); + } else if (t1 == VTYPE_UINT64 && *(u64_t*)v1 <= UINT32_MAX) { + t0 = VTYPE_UINT32; + } + + unsigned_: c = t0 - t1; + + if (!c) return *(u32_t*)v0 - *(u32_t*)v1; + + } else if (t0 <= VTYPE_INT64 && t1 <= VTYPE_INT64) { + + if (t0 == VTYPE_INT8) { + t0 = (*(u8_t*)v0 <= INT8_MAX) ? expandu8((void*)v0) : expands8((void*)v0); + + } else if (t0 == VTYPE_INT16) { + t0 = (*(u16_t*)v0 <= INT16_MAX) ? expandu16((void*)v0) : expands16((void*)v0); + + } else if (t0 == VTYPE_INT32) { + if (*(u32_t*)v0 <= INT32_MAX) { + t0 = VTYPE_UINT32; + } + } else if (t0 == VTYPE_INT64) { + if (*(u64_t*)v0 <= UINT32_MAX) { + t0 = VTYPE_UINT32; + } else if (*(u64_t*)v0 <= INT64_MAX) { + t0 = VTYPE_UINT64; + } + } + + if (t1 == VTYPE_INT8) { + t1 = (*(u8_t*)v1 <= INT8_MAX) ? expandu8((void*)v1) : expands8((void*)v1); + + } else if (t1 == VTYPE_INT16) { + t1 = (*(u16_t*)v1 <= INT16_MAX) ? expandu16((void*)v1) : expands16((void*)v1); + + } else if (t1 == VTYPE_INT32) { + if (*(u32_t*)v1 <= INT32_MAX) { + t1 = VTYPE_UINT32; + } + } else if (t1 == VTYPE_INT64) { + if (*(u64_t*)v1 <= UINT32_MAX) { + t1 = VTYPE_UINT32; + } else if (*(u64_t*)v1 <= INT64_MAX) { + t1 = VTYPE_UINT64; + } + } + + if (t0 <= VTYPE_UINT64 && t1 <= VTYPE_UINT64) + goto unsigned_; + + if (t0 <= VTYPE_UINT64) return 1; + if (t1 <= VTYPE_UINT64) return -1; + + c = t0 - t1; + + if (!c) return *(u32_t*)v1 - *(u32_t*)v0; + } + + return c; +} + + +/*#####################################################################################################################*/ + + +int libcdsb_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) { + + ldbl_t v[1]; + + if (s0 == s1) + return 0; + + switch (t) { default: abort(); + + case VTYPE_INT8: return *(s8_t*)s0 - *(s8_t*)s1; + case VTYPE_INT16: return *(s16_t*)s0 - *(s16_t*)s1; + case VTYPE_INT32: return *(s32_t*)s0 - *(s32_t*)s1; + case VTYPE_INT64: return *(s64_t*)s0 - *(s64_t*)s1; + + case VTYPE_BOOLEAN: + case VTYPE_UINT8: return *(u8_t*)s0 - *(u8_t*)s1; + + case VTYPE_UINT16: return *(u16_t*)s0 - *(u16_t*)s1; + case VTYPE_UINT32: + u32_: return *(u32_t*)s0 - *(u32_t*)s1; + + case VTYPE_POINTER: if (sizeof(void*) != 8) goto u32_; + case VTYPE_UINT64: return *(u64_t*)s0 - *(u64_t*)s1; + + case VTYPE_LDOUBLE: *(ldbl_t*)v = *(ldbl_t*)s0 - *(ldbl_t*)s1; + + if (!*(ldbl_t*)v) + return 0; + return *(ldbl_t*)v < 0 ? -1 : 1; + + case VTYPE_DOUBLE: *(dbl_t*)v = *(dbl_t*)s0 - *(dbl_t*)s1; + + if (!*(dbl_t*)v) + return 0; + return *(dbl_t*)v < 0 ? -1 : 1; + + case VTYPE_FLOAT: *(fl_t*)v = *(fl_t*)s0 - *(fl_t*)s1; + + if (!*(fl_t*)v) + return 0; + return *(fl_t*)v < 0 ? -1 : 1; + + case VTYPE_STRING: return string_compare(s0, s1); + case VTYPE_ARRAY: return array_compare(s0, s1); + case VTYPE_LIST: return list_compare(s0, s1); + case VTYPE_MAP: return map_compare(s0, s1); + case VTYPE_SET: return vset_compare(s0, s1); + } +}