diff --git a/include/array.h b/include/array.h index 35bfd1f..68b37c3 100644 --- a/include/array.h +++ b/include/array.h @@ -1,6 +1,7 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ +#include "bits/__generics.h" #include "vtype.h" #ifndef LIBCDSB_ARRAY_H diff --git a/include/bits/__rbtree.h b/include/bits/__rbtree.h new file mode 100644 index 0000000..73cf384 --- /dev/null +++ b/include/bits/__rbtree.h @@ -0,0 +1,20 @@ +/* This software is licensed by the MIT License, see LICENSE file */ +/* Copyright © 2022 Gregory Lirent */ + +#ifndef LIBCDSB_BITS_RBTREE_H +#define LIBCDSB_BITS_RBTREE_H + +typedef enum { + RBFOREACH_UNSPECIFIED = 0x00, + RBFOREACH_REVERSE = 0x80, + RBFOREACH_INORDER = 0x01, + RBFOREACH_PREORDER = 0x02, + RBFOREACH_POSTORDER = 0x04, + RBFOREACH_BREADTH_FIRST = 0x08, + RBFOREACH_INORDER_REVERSE = RBFOREACH_INORDER | RBFOREACH_REVERSE, + RBFOREACH_PREORDER_REVERSE = RBFOREACH_PREORDER | RBFOREACH_REVERSE, + RBFOREACH_POSTORDER_REVERSE = RBFOREACH_POSTORDER | RBFOREACH_REVERSE, + RBFOREACH_BREADTH_FIRST_REVERSE = RBFOREACH_BREADTH_FIRST | RBFOREACH_REVERSE +} rbforeach_t; + +#endif /* LIBCDSB_BITS_RBTREE_H */ diff --git a/include/bits/memory.h b/include/bits/memory.h index 5750557..5cc4635 100644 --- a/include/bits/memory.h +++ b/include/bits/memory.h @@ -16,6 +16,7 @@ extern void libcdsb_stack_init (stack_t* stack) Nonnull__(1) extern void libcdsb_stack_push (stack_t* stack, void* value) Nonnull__(1); extern void libcdsb_stack_push_many(stack_t* stack, size_t n, ...) Nonnull__(1); extern void* libcdsb_stack_pop (stack_t* stack) Nonnull__(1); +extern void libcdsb_stack_reverse (stack_t* stack) Nonnull__(1); extern void libcdsb_stack_flush (stack_t* stack) Nonnull__(1); extern void* libcdsb_aalloc (size_t a, size_t n) Warn_unused_result__; diff --git a/include/dict.h b/include/dict.h index 23966e7..1be89a3 100644 --- a/include/dict.h +++ b/include/dict.h @@ -1,6 +1,7 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ +#include "bits/__generics.h" #include "vtype.h" #ifndef LIBCDSB_DICT_H diff --git a/include/list.h b/include/list.h index e617d48..0ebbf47 100644 --- a/include/list.h +++ b/include/list.h @@ -1,6 +1,7 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ +#include "bits/__generics.h" #include "vtype.h" #ifndef LIBCDSB_LIST_H diff --git a/include/map.h b/include/map.h index f04ef43..a3264be 100644 --- a/include/map.h +++ b/include/map.h @@ -1,6 +1,8 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ +#include "bits/__generics.h" +#include "bits/__rbtree.h" #include "vtype.h" #ifndef LIBCDSB_MAP_H @@ -18,7 +20,7 @@ extern void map_init(vtype_map* x, vtype key_type) Nonnull__(1); #define map_get(x, key, data, callback) libcdsb_map_find (x, _LIBCDSB_value_pointer(key), _LIBCDSB_vtypeof(key), data, callback, 0) #define map_update(x, key, value) libcdsb_map_update (x, _LIBCDSB_value_pointer(key), _LIBCDSB_vtypeof(key), _LIBCDSB_value_pointer(value), _LIBCDSB_vtypeof(value)) #define map_inject(x, key, value) libcdsb_map_inject (x, _LIBCDSB_value_pointer(key), _LIBCDSB_vtypeof(key), _LIBCDSB_value_pointer(value), _LIBCDSB_vtypeof(value)) -#define map_foreach(x, data, callback) libcdsb_map_foreach (x, data, callback, 0) +#define map_foreach(x, data, callback) libcdsb_map_foreach (x, data, callback, RBFOREACH_UNSPECIFIED, 0) #define map_remove(x, key) map_pop (x, key, 0, 0) #define in_map(x, key) (map_get(x, key, 0, 0) == 0) @@ -28,6 +30,6 @@ extern void map_init(vtype_map* x, vtype key_type) Nonnull__(1); extern bool libcdsb_map_update (vtype_map* x, const void* key, vtype key_type, const void* value, vtype value_type) Nonnull__(1); extern bool libcdsb_map_inject (vtype_map* x, const void* key, vtype key_type, const void* value, vtype value_type) Nonnull__(1); extern int libcdsb_map_find (vtype_map* x, const void* key, vtype key_type, void* data, map_access_callback, bool cut) Nonnull__(1); -extern int libcdsb_map_foreach(vtype_map* x, void* data, map_access_callback, bool flush) Nonnull__(1,3); +extern int libcdsb_map_foreach(vtype_map* x, void* data, map_access_callback, rbforeach_t, bool flush) Nonnull__(1,3); #endif /* LIBCDSB_MAP_H */ diff --git a/include/set.h b/include/set.h index 67857fa..e9ffa04 100644 --- a/include/set.h +++ b/include/set.h @@ -1,6 +1,8 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ +#include "bits/__generics.h" +#include "bits/__rbtree.h" #include "vtype.h" #ifndef LIBCDSB_SET_H @@ -18,7 +20,7 @@ extern void vset_init(vtype_set* x, vtype type) Nonnull__(1); #define vset_get(x, value, data, callback) libcdsb_vset_find (x, _LIBCDSB_value_pointer(value), _LIBCDSB_vtypeof(value), data, callback, 0) #define vset_push(x, value) libcdsb_vset_insert (x, _LIBCDSB_value_pointer(value), _LIBCDSB_vtypeof(value)) #define vset_attach(x, value) libcdsb_vset_attach (x, _LIBCDSB_value_pointer(value), _LIBCDSB_vtypeof(value)) -#define vset_foreach(x, data, callback) libcdsb_vset_foreach(x, data, callback, 0) +#define vset_foreach(x, data, callback) libcdsb_vset_foreach(x, data, callback, RBFOREACH_UNSPECIFIED, 0) #define vset_remove(x, value) vset_pop (x, value, 0, 0) #define in_vset(x, value) (vset_get(x, value, 0, 0) == 0) @@ -28,6 +30,6 @@ extern void vset_init(vtype_set* x, vtype type) Nonnull__(1); extern bool libcdsb_vset_insert (vtype_set* x, const void* value, vtype type) Nonnull__(1); extern bool libcdsb_vset_attach (vtype_set* x, const void* value, vtype type) Nonnull__(1); extern int libcdsb_vset_find (vtype_set* x, const void* value, vtype type, void* data, vset_access_callback, bool cut) Nonnull__(1); -extern int libcdsb_vset_foreach(vtype_set* x, void* data, vset_access_callback, bool flush) Nonnull__(1,3); +extern int libcdsb_vset_foreach(vtype_set* x, void* data, vset_access_callback, rbforeach_t, bool flush) Nonnull__(1,3); #endif /* LIBCDSB_SET_H */ diff --git a/src/__internal/include.h b/src/__internal/include.h index fb5a610..ab46005 100644 --- a/src/__internal/include.h +++ b/src/__internal/include.h @@ -34,7 +34,6 @@ #define abs(v) _Generic((v), ldbl_t: fabsl, dbl_t: fabs, fl_t: fabsf)(v) - typedef vtype_uint8 u8_t; typedef vtype_uint16 u16_t; typedef vtype_uint32 u32_t; @@ -59,12 +58,22 @@ typedef vtype_dict dict_t; typedef vtype_hash hash_t; -extern const size_t LIBCDSB_VTYPE_SIZES[19]; +extern const size_t LIBCDSB_BUILTIN_VTYPE_SIZES[19]; -extern int libcdsb_vtype_compare_values (const void* s0, vtype t0, const void* s1, vtype t1) pure__ wur__; -extern int libcdsb_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) pure__ wur__; -extern hash_t libcdsb_vtype_hash (const void* value, vtype type) pure__ wur__; +extern int libcdsb_builtin_vtype_compare_values (const void* s0, vtype t0, const void* s1, vtype t1) pure__ wur__; +extern int libcdsb_builtin_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) pure__ wur__; +extern hash_t libcdsb_builtin_vtype_hash (const void* value, vtype type) pure__ wur__; +ainline(stack_t* libcdsb_builtin_stack_insert(stack_t* x, void* v)) { + stack_t* p = x->prev; + + if (!is_null(x->prev = malloc(sizeof(*x)))) { + x->prev->prev = p; + x->prev->value = v; + } else abort(); + + return x->prev; +} #define aligned_alloc libcdsb_aalloc #define malloc libcdsb_malloc @@ -74,7 +83,9 @@ extern hash_t libcdsb_vtype_hash (const void* value, vtype type) #define stack_init libcdsb_stack_init #define stack_push libcdsb_stack_push #define stack_push_many libcdsb_stack_push_many +#define stack_insert libcdsb_builtin_stack_insert #define stack_pop libcdsb_stack_pop +#define stack_reverse libcdsb_stack_reverse #define stack_flush libcdsb_stack_flush #define strlen libcdsb_strlen #define strasciilen libcdsb_strasciilen @@ -84,32 +95,9 @@ extern hash_t libcdsb_vtype_hash (const void* value, vtype type) #define vtype_stringify libcdsb_vtype_stringify #define vtype_name libcdsb_vtype_name -#define vtype_compare libcdsb_vtype_compare_values -#define vtype_compare_eq libcdsb_vtype_compare_values_eq -#define vtype_hash libcdsb_vtype_hash -#define vtype_size(type) (LIBCDSB_VTYPE_SIZES[type]) - - -#define vtypeof(x) (vtype)(_Generic((x),\ - const void**: VTYPE_POINTER, void**: VTYPE_POINTER, const void*: VTYPE_POINTER, void*: VTYPE_POINTER,\ - const char**: VTYPE_STRING, char**: VTYPE_STRING, const char*: VTYPE_STRING, char*: VTYPE_STRING,\ - const str_t*: VTYPE_STRING, str_t*: VTYPE_STRING, str_t: VTYPE_STRING,\ - const arr_t*: VTYPE_ARRAY, arr_t*: VTYPE_ARRAY, arr_t: VTYPE_ARRAY,\ - const list_t*: VTYPE_LIST, list_t*: VTYPE_LIST, list_t: VTYPE_LIST,\ - const map_t*: VTYPE_MAP, map_t*: VTYPE_MAP, map_t: VTYPE_MAP,\ - const set_t*: VTYPE_SET, set_t*: VTYPE_SET, set_t: VTYPE_SET,\ - const dict_t*: VTYPE_DICT, dict_t*: VTYPE_DICT, dict_t: VTYPE_DICT,\ - const vtype_bool*: VTYPE_BOOLEAN, vtype_bool*: VTYPE_BOOLEAN, vtype_bool: VTYPE_BOOLEAN,\ - const vtype_uint8*: VTYPE_UINT8, vtype_uint8*: VTYPE_UINT8, vtype_uint8: VTYPE_UINT8,\ - const vtype_uint16*: VTYPE_UINT16, vtype_uint16*: VTYPE_UINT16, vtype_uint16: VTYPE_UINT16,\ - const vtype_uint32*: VTYPE_UINT32, vtype_uint32*: VTYPE_UINT32, vtype_uint32: VTYPE_UINT32,\ - const vtype_uint64*: VTYPE_UINT64, vtype_uint64*: VTYPE_UINT64, vtype_uint64: VTYPE_UINT64,\ - const vtype_int8*: VTYPE_INT8, vtype_int8*: VTYPE_INT8, vtype_int8: VTYPE_INT8,\ - const vtype_int16*: VTYPE_INT16, vtype_int16*: VTYPE_INT16, vtype_int16: VTYPE_INT16,\ - const vtype_int32*: VTYPE_INT32, vtype_int32*: VTYPE_INT32, vtype_int32: VTYPE_INT32,\ - const vtype_int64*: VTYPE_INT64, vtype_int64*: VTYPE_INT64, vtype_int64: VTYPE_INT64,\ - const vtype_float*: VTYPE_FLOAT, vtype_float*: VTYPE_FLOAT, vtype_float: VTYPE_FLOAT,\ - const vtype_double*: VTYPE_DOUBLE, vtype_double*: VTYPE_DOUBLE, vtype_double: VTYPE_DOUBLE,\ - const vtype_ldouble*: VTYPE_LDOUBLE, vtype_ldouble*: VTYPE_LDOUBLE, vtype_ldouble: VTYPE_LDOUBLE)) +#define vtype_compare libcdsb_builtin_vtype_compare_values +#define vtype_compare_eq libcdsb_builtin_vtype_compare_values_eq +#define vtype_hash libcdsb_builtin_vtype_hash +#define vtype_size(type) (LIBCDSB_BUILTIN_VTYPE_SIZES[type]) #endif /* LIBCDSB_SRC_INTERNAL_INCLUDE */ diff --git a/src/__internal/rbtree.h b/src/__internal/rbtree.h index 93ecb97..3cdde2b 100644 --- a/src/__internal/rbtree.h +++ b/src/__internal/rbtree.h @@ -15,18 +15,28 @@ typedef struct libcdsb_rbtree_node { short colored; } rbnode_t; -extern rbnode_t LIBCDSB_RBTREE_NODE_EMPTY[1]; +extern rbnode_t LIBCDSB_BUILTIN_RBTREE_NODE_EMPTY[1]; -extern void* libcdsb_rbtree_node_create(void* value, rbnode_t* parent, int colored, int size) Nonnull__( 2); -extern void libcdsb_rbtree_node_fixup (rbnode_t** root, rbnode_t* node) Nonnull__(1,2); -extern rbnode_t* libcdsb_rbtree_node_delete(rbnode_t** root, rbnode_t* node) Nonnull__(1,2); +extern void* libcdsb_builtin_rbtree_node_create(void* value, rbnode_t* parent, int colored, int size) Nonnull__( 2); +extern void libcdsb_builtin_rbtree_node_fixup (rbnode_t** root, rbnode_t* node) Nonnull__(1,2); +extern rbnode_t* libcdsb_builtin_rbtree_node_delete(rbnode_t** root, rbnode_t* node) Nonnull__(1,2); -#define rbnode_empty ((rbnode_t*)LIBCDSB_RBTREE_NODE_EMPTY) -#define rbnode_create(v, p, c) ((rbnode_t*)libcdsb_rbtree_node_create(v, p, c, sizeof(rbnode_t))) -#define rbnode_fixup libcdsb_rbtree_node_fixup -#define rbnode_delete libcdsb_rbtree_node_delete +extern stack_t libcdsb_builtin_rbtree_iter_inorder (rbnode_t** root, bool reverse); +extern stack_t libcdsb_builtin_rbtree_iter_preorder (rbnode_t** root, bool reverse); +extern stack_t libcdsb_builtin_rbtree_iter_postorder (rbnode_t** root, bool reverse); +extern stack_t libcdsb_builtin_rbtree_iter_breath_first(rbnode_t** root, bool reverse); + +#define rbnode_empty ((rbnode_t*)LIBCDSB_BUILTIN_RBTREE_NODE_EMPTY) +#define rbnode_create(v, p, c) ((rbnode_t*)libcdsb_builtin_rbtree_node_create(v, p, c, sizeof(rbnode_t))) +#define rbnode_fixup libcdsb_builtin_rbtree_node_fixup +#define rbnode_delete libcdsb_builtin_rbtree_node_delete #define rbnode_is_empty(n) ((n) == rbnode_empty) #define rbnode_is_root(n) rbnode_is_empty((n)->parent) +#define rbiter_inorder libcdsb_builtin_rbtree_iter_inorder +#define rbiter_preorder libcdsb_builtin_rbtree_iter_preorder +#define rbiter_postorder libcdsb_builtin_rbtree_iter_postorder +#define rbiter_breath_first libcdsb_builtin_rbtree_iter_breath_first + #endif /* LIBCDSB_SRC_INTERNAL_RBTREE_H */ diff --git a/src/__internal/vnode.h b/src/__internal/vnode.h index 755730f..06f021d 100644 --- a/src/__internal/vnode.h +++ b/src/__internal/vnode.h @@ -19,15 +19,15 @@ typedef union { typedef void* vnode_t; -extern vnode_t libcdsb_vnode_create (const void* value, vtype type) wur__; -extern vnode_t libcdsb_vnode_create_target(vtype target_type, const void* value, vtype type) wur__; +extern vnode_t libcdsb_builtin_vnode_create (const void* value, vtype type) wur__; +extern vnode_t libcdsb_builtin_vnode_create_target(vtype target_type, const void* value, vtype type) wur__; -extern void libcdsb_vnode_free(vnode_t* x, vtype type) Nonnull__(1); -extern void* libcdsb_vnode_peek(const vnode_t* x, vtype type) pure__ wur__ Nonnull__(1); +extern void libcdsb_builtin_vnode_free(vnode_t* x, vtype type) Nonnull__(1); +extern void* libcdsb_builtin_vnode_peek(const vnode_t* x, vtype type) pure__ wur__ Nonnull__(1); -ainline(void vnode_attach(vnode_t* node, const void* value, vtype type)) { +ainline(void libcdsb_builtin_vnode_attach(vnode_t* node, const void* value, vtype type)) { if (type < VTYPE_STRING) { - *node = libcdsb_vnode_create(value, type); + *node = libcdsb_builtin_vnode_create(value, type); } else if (sizeof(str_t) == sizeof(void*) && type == VTYPE_STRING) { *node = *(char**)value; } else { @@ -36,9 +36,9 @@ ainline(void vnode_attach(vnode_t* node, const void* value, vtype type)) { } } -ainline(void vnode_tattach(vnode_t* node, vtype target_type, const void* value, vtype type)) { +ainline(void libcdsb_builtin_vnode_tattach(vnode_t* node, vtype target_type, const void* value, vtype type)) { if (type < VTYPE_STRING) { - *node = libcdsb_vnode_create_target(target_type, value, type); + *node = libcdsb_builtin_vnode_create_target(target_type, value, type); } else { type_assert(target_type, type); @@ -51,16 +51,18 @@ ainline(void vnode_tattach(vnode_t* node, vtype target_type, const void* value, } } -#define vnode_create libcdsb_vnode_create -#define vnode_tcreate libcdsb_vnode_create_target -#define vnode_peek libcdsb_vnode_peek -#define vnode_free libcdsb_vnode_free +#define vnode_create libcdsb_builtin_vnode_create +#define vnode_tcreate libcdsb_builtin_vnode_create_target +#define vnode_attach libcdsb_builtin_vnode_attach +#define vnode_tattach libcdsb_builtin_vnode_tattach +#define vnode_peek libcdsb_builtin_vnode_peek +#define vnode_free libcdsb_builtin_vnode_free #define vnode_hash(vnode, type) vtype_hash(vnode_peek(vnode, type), type) #define vnode_compare(s0, t0, s1, t1) vtype_compare(vnode_peek(s0, t0), t0, vnode_peek(s1, t1), t1) #define vnode_compare_eq(s0, s1, t) vtype_compare_eq(vnode_peek(s0, t), vnode_peek(s1, t), t) -#define vnode_duplicate(vnode, type) libcdsb_vnode_create(vnode_peek(vnode, type), type) -#define vnode_tduplicate(target_type, vnode, type) libcdsb_vnode_create_target(target_type, vnode_peek(vnode, type), type) +#define vnode_duplicate(vnode, type) vnode_create(vnode_peek(vnode, type), type) +#define vnode_tduplicate(target_type, vnode, type) vnode_tcreate(target_type, vnode_peek(vnode, type), type) #define vnode_stringify(n, t) vtype_stringify(vnode_peek(n, t), t) diff --git a/src/array/sort.c b/src/array/sort.c index 19622c2..64a01f1 100644 --- a/src/array/sort.c +++ b/src/array/sort.c @@ -4,78 +4,42 @@ #include "include.h" #include "../__internal/assert.h" -static_assert(( - VTYPE_UINT8 == 2 && - VTYPE_UINT16 == 3 && - VTYPE_UINT32 == 4 && - VTYPE_UINT64 == 5 && - VTYPE_INT8 == 6 && - VTYPE_INT16 == 7 && - VTYPE_INT32 == 8 && - VTYPE_INT64 == 9 && - VTYPE_FLOAT == 10 && - VTYPE_DOUBLE == 11 && - VTYPE_LDOUBLE == 12 && - VTYPE_STRING == 13 && - VTYPE_MAP == 14 && - VTYPE_ARRAY == 15 && - VTYPE_LIST == 16 && - VTYPE_SET == 17 -), "enum values assertion"); +typedef int (*compare_f)(const void*, const void*); -static int uint8_compare (const u8_t* s0, const u8_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int uint16_compare (const u16_t* s0, const u16_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int uint32_compare (const u32_t* s0, const u32_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int uint64_compare (const u64_t* s0, const u64_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int int8_compare (const s8_t* s0, const s8_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int int16_compare (const s16_t* s0, const s16_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int int32_compare (const s32_t* s0, const s32_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int int64_compare (const s64_t* s0, const s64_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int float_compare (const fl_t* s0, const fl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int double_compare (const dbl_t* s0, const dbl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int ldouble_compare(const ldbl_t* s0, const ldbl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_uint8 (const u8_t* s0, const u8_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_uint16 (const u16_t* s0, const u16_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_uint32 (const u32_t* s0, const u32_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_uint64 (const u64_t* s0, const u64_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_int8 (const s8_t* s0, const s8_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_int16 (const s16_t* s0, const s16_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_int32 (const s32_t* s0, const s32_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_int64 (const s64_t* s0, const s64_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_float (const fl_t* s0, const fl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_double (const dbl_t* s0, const dbl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } +static int libcdsb_builtin_compare_ldouble(const ldbl_t* s0, const ldbl_t* s1) { if (*s0 == *s1) return 0; return *s0 < *s1 ? -1 : 1; } -static int (*COMPARE[16])(const void*, const void*) = { - (void*) uint8_compare, - (void*) uint16_compare, - (void*) uint32_compare, - (void*) uint64_compare, - (void*) int8_compare, - (void*) int16_compare, - (void*) int32_compare, - (void*) int64_compare, - (void*) float_compare, - (void*) double_compare, - (void*) ldouble_compare, - (void*) string_compare, - (void*) map_compare, - (void*) array_compare, - (void*) list_compare, - (void*) vset_compare -}; +static compare_f libcdsb_builtin_get_comparator(vtype t) { + static void* comparators[17] = { libcdsb_builtin_compare_uint8, libcdsb_builtin_compare_uint16, + libcdsb_builtin_compare_uint32, libcdsb_builtin_compare_uint64, + libcdsb_builtin_compare_int8, libcdsb_builtin_compare_int16, + libcdsb_builtin_compare_int32, libcdsb_builtin_compare_int64, + libcdsb_builtin_compare_float, libcdsb_builtin_compare_double, + libcdsb_builtin_compare_ldouble, string_compare, map_compare, + array_compare, list_compare, vset_compare, dict_compare }; - -/*#####################################################################################################################*/ - - -ainline(int get_compare_index(vtype t)) { if (t == VTYPE_POINTER) { if (is_x64) t = VTYPE_UINT64; else t = VTYPE_UINT32; } else if (t == VTYPE_BOOLEAN) t = VTYPE_UINT8; - return t - VTYPE_UINT8; + return comparators[t - VTYPE_UINT8]; } - /*#####################################################################################################################*/ - void array_sort(arr_t* x) { - int i = get_compare_index(x->type); - if (x->size > 1) - qsort(x->mem, x->size, vtype_size(x->type), COMPARE[i]); + qsort(x->mem, x->size, vtype_size(x->type), libcdsb_builtin_get_comparator(x->type)); } void array_reverse(arr_t* x) { diff --git a/src/extra.c b/src/cstring.c similarity index 77% rename from src/extra.c rename to src/cstring.c index 313b1b6..be7d703 100644 --- a/src/extra.c +++ b/src/cstring.c @@ -4,21 +4,21 @@ #include "../modules/libunic/include.h" #include "__internal/include.h" -static _Thread_local int CHAR_BUFFER_POS = 0; -static _Thread_local char CHAR_BUFFER[16][5]; +static _Thread_local int LIBCDSB_BUILTIN_COUNTER = 0; +static _Thread_local char LIBCDSB_BUILTIN_BUFFER[16][5]; const char* libcdsb_char_to_cstring(int c) { char* p; - if (CHAR_BUFFER_POS > 15) - CHAR_BUFFER_POS = 0; + if (LIBCDSB_BUILTIN_COUNTER > 15) + LIBCDSB_BUILTIN_COUNTER = 0; - if (is_null(p = tochar_unicode(CHAR_BUFFER[CHAR_BUFFER_POS], c))) { - CHAR_BUFFER[CHAR_BUFFER_POS][0] = 0; + if (is_null(p = tochar_unicode(LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER], c))) { + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0; } else *p = 0; - return CHAR_BUFFER[CHAR_BUFFER_POS++]; + return LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER++]; } diff --git a/src/dict/compute.c b/src/dict/compute.c index 2750de4..a22d4d6 100644 --- a/src/dict/compute.c +++ b/src/dict/compute.c @@ -3,16 +3,6 @@ #include "include.h" -size_t dict_size(const dict_t* x) { - return x->size; -} - - -size_t dict_capacity(const dict_t* x) { - return x->capacity; -} - - hash_t dict_hash(const dict_t* s) { dnode_t *min, *max; size_t i; diff --git a/src/dict/copy.c b/src/dict/copy.c index a9a6148..5845b7e 100644 --- a/src/dict/copy.c +++ b/src/dict/copy.c @@ -1,10 +1,10 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ -#include "../../include/list.h" +#include "../list/include.h" #include "include.h" -static inline dnode_t* dnode_duplicate(const dnode_t* s, dnode_t* p) { +static inline dnode_t* libcdsb_builtin_duplicate(const dnode_t* s, dnode_t* p) { dnode_t* x = malloc(sizeof(*x)); x->prev = p; @@ -31,7 +31,7 @@ dict_t dict_copy(const dict_t* s) { n = s->nodes[i]; while (!is_null(n)) { - x.nodes[i] = dnode_duplicate(n, x.nodes[i]); + x.nodes[i] = libcdsb_builtin_duplicate(n, x.nodes[i]); n = n->prev; } } @@ -53,7 +53,7 @@ dict_t* dict_duplicate(const dict_t* s) { n = s->nodes[i]; while (!is_null(n)) { - x->nodes[i] = dnode_duplicate(n, x->nodes[i]); + x->nodes[i] = libcdsb_builtin_duplicate(n, x->nodes[i]); n = n->prev; } } @@ -74,17 +74,17 @@ void dict_copy_init(dict_t* x, const dict_t* s) { n = s->nodes[i]; while (!is_null(n)) { - x->nodes[i] = dnode_duplicate(n, x->nodes[i]); + x->nodes[i] = libcdsb_builtin_duplicate(n, x->nodes[i]); n = n->prev; } } } -vtype_list libcdsb_dict_copy_keys(const vtype_dict* s) { - vtype_list x; - dnode_t *c; - size_t i; +list_t libcdsb_dict_copy_keys(const dict_t* s) { + list_t x; + dnode_t *c; + size_t i; i = s->capacity; @@ -94,7 +94,11 @@ vtype_list libcdsb_dict_copy_keys(const vtype_dict* s) { c = s->nodes[i]; while (!is_null(c)) { - libcdsb_list_insert(&x, -1, vnode_peek(&c->key, c->key_type), c->key_type, 1); + + if (is_null(x.first)) { + libcdsb_builtin_init(&x, vnode_duplicate(&c->key, c->key_type), c->key_type); + } else libcdsb_builtin_push(&x, vnode_duplicate(&c->key, c->key_type), c->key_type); + c = c->prev; } } @@ -103,10 +107,10 @@ vtype_list libcdsb_dict_copy_keys(const vtype_dict* s) { } -vtype_list* libcdsb_dict_duplicate_keys(const vtype_dict* s) { - vtype_list* x; - dnode_t *c; - size_t i; +list_t* libcdsb_dict_duplicate_keys(const dict_t* s) { + list_t* x; + dnode_t *c; + size_t i; x = malloc(sizeof(*x)); i = s->capacity; @@ -117,7 +121,9 @@ vtype_list* libcdsb_dict_duplicate_keys(const vtype_dict* s) { c = s->nodes[i]; while (!is_null(c)) { - libcdsb_list_insert(x, -1, vnode_peek(&c->key, c->key_type), c->key_type, 1); + if (is_null(x->first)) { + libcdsb_builtin_init(x, vnode_duplicate(&c->key, c->key_type), c->key_type); + } else libcdsb_builtin_push(x, vnode_duplicate(&c->key, c->key_type), c->key_type); c = c->prev; } } @@ -126,9 +132,9 @@ vtype_list* libcdsb_dict_duplicate_keys(const vtype_dict* s) { } -void libcdsb_dict_init_keys(vtype_list* x, const vtype_dict* s) { - dnode_t *c; - size_t i; +void libcdsb_dict_init_keys(list_t* x, const dict_t* s) { + dnode_t *c; + size_t i; x = malloc(sizeof(*x)); i = s->capacity; @@ -139,7 +145,9 @@ void libcdsb_dict_init_keys(vtype_list* x, const vtype_dict* s) { c = s->nodes[i]; while (!is_null(c)) { - libcdsb_list_insert(x, -1, vnode_peek(&c->key, c->key_type), c->key_type, 1); + if (is_null(x->first)) { + libcdsb_builtin_init(x, vnode_duplicate(&c->key, c->key_type), c->key_type); + } else libcdsb_builtin_push(x, vnode_duplicate(&c->key, c->key_type), c->key_type); c = c->prev; } } diff --git a/src/dict/modify.c b/src/dict/modify.c index 33f6a84..7f34591 100644 --- a/src/dict/modify.c +++ b/src/dict/modify.c @@ -4,7 +4,7 @@ #include "../../include/list.h" #include "include.h" -static void dict_rehash(dict_t* s, size_t capacity) { +static void libcdsb_builtin_rehash(dict_t* s, size_t capacity) { dnode_t **nodes, *c, *n, **p; size_t i; @@ -44,7 +44,7 @@ bool libcdsb_dict_shrink_to_fit(dict_t* s) { if (capacity >= s->capacity) return false; - dict_rehash(s, capacity); + libcdsb_builtin_rehash(s, capacity); return true; } @@ -54,7 +54,7 @@ bool libcdsb_dict_update(dict_t* x, const void* k, vtype kt, const void* v, vtyp dnode_t *c, **p; if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) - dict_rehash(x, x->capacity + CAPACITY_BLOCK); + libcdsb_builtin_rehash(x, x->capacity + CAPACITY_BLOCK); c = *(p = x->nodes + (vtype_hash(k, kt) % x->capacity)); @@ -88,7 +88,7 @@ bool libcdsb_dict_inject(dict_t* x, const void* k, vtype kt, const void* v, vtyp dnode_t *c, **p; if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) - dict_rehash(x, x->capacity + CAPACITY_BLOCK); + libcdsb_builtin_rehash(x, x->capacity + CAPACITY_BLOCK); c = *(p = x->nodes + (vtype_hash(k, kt) % x->capacity)); @@ -123,7 +123,7 @@ bool libcdsb_dict_inject_key(dict_t* x, const void* k, vtype kt, const void* v, dnode_t *c, **p; if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) - dict_rehash(x, x->capacity + CAPACITY_BLOCK); + libcdsb_builtin_rehash(x, x->capacity + CAPACITY_BLOCK); c = *(p = x->nodes + (vtype_hash(k, kt) % x->capacity)); @@ -158,7 +158,7 @@ bool libcdsb_dict_inject_value(dict_t* x, const void* k, vtype kt, const void* v dnode_t *c, **p; if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) - dict_rehash(x, x->capacity + CAPACITY_BLOCK); + libcdsb_builtin_rehash(x, x->capacity + CAPACITY_BLOCK); c = *(p = x->nodes + (vtype_hash(k, kt) % x->capacity)); diff --git a/src/list/access.c b/src/list/access.c index 4232de7..1d6834e 100644 --- a/src/list/access.c +++ b/src/list/access.c @@ -3,7 +3,7 @@ #include "include.h" -static void lnode_cut(list_t* s, lnode_t* cur) { +static void libcdsb_builtin_cut(list_t* s, lnode_t* cur) { vnode_free(&cur->node, cur->type); @@ -45,7 +45,7 @@ int libcdsb_list_get(vtype_list* x, ssize_t i, void* _, list_access_callback cal i = (callback) ? callback(vnode_peek(&c->node, c->type), i, c->type, _) : 0; - if (cut) lnode_cut(x, c); + if (cut) libcdsb_builtin_cut(x, c); return i; } @@ -67,7 +67,7 @@ int libcdsb_list_find(vtype_list* x, const void* v, vtype t, void* _, list_acces if (cmp == 0) { i = (callback) ? callback(vnode_peek(&c->node, c->type), (r)?~i:i, c->type, _) : 0; - if (cut) lnode_cut(x, c); + if (cut) libcdsb_builtin_cut(x, c); return i; } diff --git a/src/list/copy.c b/src/list/copy.c index 3e1fae4..ed6b03d 100644 --- a/src/list/copy.c +++ b/src/list/copy.c @@ -3,33 +3,6 @@ #include "include.h" -static void init_first(list_t* x, vnode_t v, vtype t) { - lnode_t* node = malloc(sizeof(*node)); - - node->next = nullptr; - node->prev = nullptr; - node->node = v; - node->type = t; - - x->first = node; - x->last = node; -} - - -static void push_next(list_t* x, vnode_t v, vtype t) { - lnode_t* node = malloc(sizeof(*node)); - - node->next = nullptr; - node->prev = x->last; - node->node = v; - node->type = t; - - x->last->next = node; - x->last = node; -} - -/*#####################################################################################################################*/ - list_t list_copy(const list_t* s) { list_t x; lnode_t* c; @@ -40,10 +13,10 @@ list_t list_copy(const list_t* s) { if (is_null(c)) return x; - init_first(&x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_init(&x, vnode_duplicate(&c->node, c->type), c->type); while (!is_null(c = c->next)) { - push_next(&x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_push(&x, vnode_duplicate(&c->node, c->type), c->type); } return x; @@ -60,10 +33,10 @@ list_t* list_duplicate(const list_t* s) { if (is_null(c)) return x; - init_first(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_init(x, vnode_duplicate(&c->node, c->type), c->type); while (!is_null(c = c->next)) { - push_next(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_push(x, vnode_duplicate(&c->node, c->type), c->type); } return x; @@ -79,10 +52,10 @@ void list_copy_init(list_t* x, const list_t* s) { if (is_null(c)) return; - init_first(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_init(x, vnode_duplicate(&c->node, c->type), c->type); while (!is_null(c = c->next)) { - push_next(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_push(x, vnode_duplicate(&c->node, c->type), c->type); } } @@ -96,7 +69,7 @@ void list_extend(list_t* x, const list_t* s) { return; if (is_null(x->first)) { - init_first(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_init(x, vnode_duplicate(&c->node, c->type), c->type); c = c->next; if (is_null(c)) @@ -104,7 +77,7 @@ void list_extend(list_t* x, const list_t* s) { } do { - push_next(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_push(x, vnode_duplicate(&c->node, c->type), c->type); } while (!is_null(c = c->next)); } @@ -157,13 +130,13 @@ size_t list_slice(list_t* x, list_t* s, ssize_t i, size_t n, _Bool cut) { else r -= n; if (!cut) { - init_first(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_init(x, vnode_duplicate(&c->node, c->type), c->type); while ((c = c->next) != e) { - push_next(x, vnode_duplicate(&c->node, c->type), c->type); + libcdsb_builtin_push(x, vnode_duplicate(&c->node, c->type), c->type); } - push_next(x, vnode_duplicate(&e->node, e->type), e->type); + libcdsb_builtin_push(x, vnode_duplicate(&e->node, e->type), e->type); } else { if (c->prev) { c->prev->next = e->next; diff --git a/src/list/include.h b/src/list/include.h index 463e872..f10b0a8 100644 --- a/src/list/include.h +++ b/src/list/include.h @@ -20,6 +20,31 @@ typedef struct libcdsb_list_node { vtype type; } lnode_t; + +ainline(void libcdsb_builtin_init(list_t* x, vnode_t v, vtype t)) { + lnode_t* node = malloc(sizeof(*node)); + + node->next = nullptr; + node->prev = nullptr; + node->node = v; + node->type = t; + + x->first = node; + x->last = node; +} + +ainline(void libcdsb_builtin_push(list_t* x, vnode_t v, vtype t)) { + lnode_t* node = malloc(sizeof(*node)); + + node->next = nullptr; + node->prev = x->last; + node->node = v; + node->type = t; + + x->last->next = node; + x->last = node; +} + #define ldir_dir(cur, d) (&((cur)->prev))[(d)>>1] #define ldir_inv(cur, d) (&((cur)->prev))[(d)&1] diff --git a/src/list/sort.c b/src/list/sort.c index 1542072..daeb337 100644 --- a/src/list/sort.c +++ b/src/list/sort.c @@ -3,9 +3,7 @@ #include "include.h" -/*#####################################################################################################################*/ - -static inline void lnode_swap(lnode_t* s0, lnode_t* s1) { +static inline void libcdsb_builtin_swap(lnode_t* s0, lnode_t* s1) { vnode_t v = s0->node; vtype t = s0->type; @@ -16,6 +14,7 @@ static inline void lnode_swap(lnode_t* s0, lnode_t* s1) { s1->type = t; } +/*#####################################################################################################################*/ void list_sort(list_t* x) { stack_t z; @@ -37,12 +36,12 @@ void list_sort(list_t* x) { for (lnode_t* c = l; c != r; c = c->next) { if (lnode_compare(c, r) <= 0) { p = (is_null(p)) ? l : p->next; - lnode_swap(p, c); + libcdsb_builtin_swap(p, c); } } p = (is_null(p)) ? l : p->next; - lnode_swap(p, r); + libcdsb_builtin_swap(p, r); stack_push(&z, r); stack_push(&z, p->next); @@ -58,7 +57,7 @@ void list_reverse(list_t* x) { lnode_t *r = x->last; while (l != r) { - lnode_swap(l, r); + libcdsb_builtin_swap(l, r); if ((r = r->prev) == l) break; l = l->next; diff --git a/src/map/access.c b/src/map/access.c index 83c51fe..d3b62cc 100644 --- a/src/map/access.c +++ b/src/map/access.c @@ -3,6 +3,48 @@ #include "include.h" +static int libcdsb_builtin_foreach(map_t* x, void* data, map_access_callback callback) { + stack_t z, *top, *bot, *cur; + mnode_t* n; + int r = 0; + + memset(&z, 0, sizeof(z)); + + if (rbnode_is_empty(z.value = x->root)) + return 0; + + for (top = bot = &z;;) { + for (cur = bot;;) { + + n = top->value; + + if (!mnode_is_empty(n->left)) cur = stack_insert(cur, n->left); + if (!mnode_is_empty(n->right)) cur = stack_insert(cur, n->right); + + if (!r) { + r = callback(vnode_peek(&n->key, x->type), x->type, vnode_peek(&n->value, n->type), n->type, data); + } else { + stack_flush(&z); + return r; + } + + if (top == bot) { + top = top->prev; + break; + } else top = top->prev; + } + + if (!is_null(top)) { + while (!is_null(bot->prev)) bot = bot->prev; + } else break; + } + + stack_flush(&z); + return r; +} + +/*#####################################################################################################################*/ + int libcdsb_map_find(map_t* x, const void* k, vtype t, void* _, map_access_callback callback, bool cut) { mnode_t* c; void *key; @@ -32,47 +74,41 @@ int libcdsb_map_find(map_t* x, const void* k, vtype t, void* _, map_access_callb } -int libcdsb_map_foreach(map_t* x, void* dt, map_access_callback callback, bool flush) { - stack_t z; - int r; - mnode_t* c; +int libcdsb_map_foreach(map_t* x, void* data, map_access_callback callback, rbforeach_t type, bool flush) { + bool reverse; + stack_t iter; + mnode_t* n; + int r = 0; - stack_init(&z); - stack_push(&z, x->root); + reverse = type&RBFOREACH_REVERSE; - r = 0; + switch (type&(RBFOREACH_INORDER|RBFOREACH_PREORDER|RBFOREACH_POSTORDER|RBFOREACH_BREADTH_FIRST)) { + case RBFOREACH_INORDER: iter = miter_inorder (&x->root, reverse); break; + case RBFOREACH_PREORDER: iter = miter_preorder (&x->root, reverse); break; + case RBFOREACH_POSTORDER: iter = miter_postorder(&x->root, reverse); break; - if (mnode_is_empty(x->root)) - return 0; + default: + case RBFOREACH_BREADTH_FIRST: if (reverse || flush) { + iter = miter_breath_first(&x->root, type&RBFOREACH_REVERSE); + break; + } else return libcdsb_builtin_foreach(x, data, callback); + } - while ((c = stack_pop(&z))) { - if ((r = callback(vnode_peek(&c->key, x->type), x->type, vnode_peek(&c->value, c->type), c->type, dt))) - break; - - if (!mnode_is_empty(c->right)) stack_push(&z, c->right); - if (!mnode_is_empty(c->left)) stack_push(&z, c->left); + while ((n = stack_pop(&iter))) { + if (!r) { + r = callback(vnode_peek(&n->key, x->type), x->type, vnode_peek(&n->value, n->type), n->type, data); + } else if (!flush) { + stack_flush(&iter); + return r; + } if (flush) { - vnode_free(&c->key, x->type); - vnode_free(&c->value, c->type); - free(c); + vnode_free(&n->value, x->type); + free(n); } } - if (flush) { - while (c) { - if (!mnode_is_empty(c->right)) stack_push(&z, c->right); - if (!mnode_is_empty(c->left)) stack_push(&z, c->left); - - vnode_free(&c->key, x->type); - vnode_free(&c->value, c->type); - free(c); - - c = stack_pop(&z); - } - - memset(x, 0, sizeof(*x)); - } else stack_flush(&z); + if (flush) x->root = mnode_empty; return r; } diff --git a/src/map/comparison.c b/src/map/comparison.c index 9590767..a2b74a0 100644 --- a/src/map/comparison.c +++ b/src/map/comparison.c @@ -3,7 +3,7 @@ #include "include.h" -static inline int mnode_compare(const mnode_t* s0, const mnode_t* s1, vtype t) { +static inline int libcdsb_builtin_compare(const mnode_t* s0, const mnode_t* s1, vtype t) { int c = vnode_compare_eq(&s0->key, &s1->key, t); return !c ? vnode_compare(&s0->value, s0->type, &s1->value, s1->type) : c; @@ -35,13 +35,13 @@ int map_compare(const map_t* s0, const map_t* s1) { stack_flush(&z); return mnode_is_empty(c0) ? -1 : 1; } - } else if ((cmp = mnode_compare(c0, c1, s0->type))) { + } else if ((cmp = libcdsb_builtin_compare(c0, c1, s0->type))) { if (c0->left == c1->right) { // == mnode_empty - cmp = mnode_compare(c0->right, c1, s0->type); - if (!cmp) cmp = mnode_compare(c0, c1->left, s0->type); + cmp = libcdsb_builtin_compare(c0->right, c1, s0->type); + if (!cmp) cmp = libcdsb_builtin_compare(c0, c1->left, s0->type); } else if (c0->right == c1->left) { // == mnode_empty - cmp = mnode_compare(c0, c1->right, s0->type); - if (!cmp) cmp = mnode_compare(c0->left, c1, s0->type); + cmp = libcdsb_builtin_compare(c0, c1->right, s0->type); + if (!cmp) cmp = libcdsb_builtin_compare(c0->left, c1, s0->type); } if (cmp) { diff --git a/src/map/compute.c b/src/map/compute.c index 8c03385..75088de 100644 --- a/src/map/compute.c +++ b/src/map/compute.c @@ -3,7 +3,7 @@ #include "include.h" -static inline hash_t mnode_hash(const mnode_t* s, vtype t) { +static inline hash_t libcdsb_builtin_hash(const mnode_t* s, vtype t) { return vnode_hash(&s->key, t) + vnode_hash(&s->value, s->type) + t; } @@ -53,7 +53,7 @@ hash_t map_hash(const map_t* s) { } while (!is_null(c0 = stack_pop(&z))); } - v = mnode_hash(c1, s->type); + v = libcdsb_builtin_hash(c1, s->type); stack_push(&z, s->root->right); if (!mnode_is_empty(c0 = stack_pop(&z))) { @@ -64,7 +64,7 @@ hash_t map_hash(const map_t* s) { } while (!is_null(c0 = stack_pop(&z))); } - v += mnode_hash(c1, s->type); + v += libcdsb_builtin_hash(c1, s->type); return (hash ^ v) + VTYPE_MAP; } diff --git a/src/map/copy.c b/src/map/copy.c index 7fe7ecf..f4fb761 100644 --- a/src/map/copy.c +++ b/src/map/copy.c @@ -3,7 +3,7 @@ #include "include.h" -static inline mnode_t* mnode_duplicate(const mnode_t* s, mnode_t* p, const vtype t) { +static inline mnode_t* libcdsb_builtin_duplicate(const mnode_t* s, mnode_t* p, const vtype t) { mnode_t* x; x = mnode_create(vnode_duplicate(&s->key, t), p, s->colored); @@ -26,7 +26,7 @@ map_t map_copy(const map_t* s) { x.type = s->type; if (!mnode_is_empty(s->root)) { - x.root = mnode_duplicate(s->root, mnode_empty, s->type); + x.root = libcdsb_builtin_duplicate(s->root, mnode_empty, s->type); stack_push(&z, x.root); do { @@ -34,12 +34,12 @@ map_t map_copy(const map_t* s) { mnode_t *p1 = stack_pop(&z); if (!mnode_is_empty(p1->left)) { - p0->left = mnode_duplicate(p1->left, p0, s->type); + p0->left = libcdsb_builtin_duplicate(p1->left, p0, s->type); stack_push_many(&z, 2, p1->left, p0->left); } if (!mnode_is_empty(p1->right)) { - p0->right = mnode_duplicate(p1->right, p0, s->type); + p0->right = libcdsb_builtin_duplicate(p1->right, p0, s->type); stack_push_many(&z, 2, p1->right, p0->right); } @@ -63,7 +63,7 @@ map_t* map_duplicate(const map_t* s) { x->type = s->type; if (!mnode_is_empty(s->root)) { - x->root = mnode_duplicate(s->root, mnode_empty, s->type); + x->root = libcdsb_builtin_duplicate(s->root, mnode_empty, s->type); stack_push(&z, x->root); do { @@ -71,12 +71,12 @@ map_t* map_duplicate(const map_t* s) { mnode_t *p1 = stack_pop(&z); if (!mnode_is_empty(p1->left)) { - p0->left = mnode_duplicate(p1->left, p0, s->type); + p0->left = libcdsb_builtin_duplicate(p1->left, p0, s->type); stack_push_many(&z, 2, p1->left, p0->left); } if (!mnode_is_empty(p1->right)) { - p0->right = mnode_duplicate(p1->right, p0, s->type); + p0->right = libcdsb_builtin_duplicate(p1->right, p0, s->type); stack_push_many(&z, 2, p1->right, p0->right); } @@ -98,7 +98,7 @@ void map_copy_init(map_t* x, const map_t* s) { x->type = s->type; if (!mnode_is_empty(s->root)) { - x->root = mnode_duplicate(s->root, mnode_empty, s->type); + x->root = libcdsb_builtin_duplicate(s->root, mnode_empty, s->type); stack_push(&z, x->root); do { @@ -106,12 +106,12 @@ void map_copy_init(map_t* x, const map_t* s) { mnode_t *p1 = stack_pop(&z); if (!mnode_is_empty(p1->left)) { - p0->left = mnode_duplicate(p1->left, p0, s->type); + p0->left = libcdsb_builtin_duplicate(p1->left, p0, s->type); stack_push_many(&z, 2, p1->left, p0->left); } if (!mnode_is_empty(p1->right)) { - p0->right = mnode_duplicate(p1->right, p0, s->type); + p0->right = libcdsb_builtin_duplicate(p1->right, p0, s->type); stack_push_many(&z, 2, p1->right, p0->right); } diff --git a/src/map/include.h b/src/map/include.h index de5185e..5587d97 100644 --- a/src/map/include.h +++ b/src/map/include.h @@ -27,12 +27,17 @@ static_assert(offsetof(struct libcdsb_rbtree_node, value) == offsetof(struct l static_assert(offsetof(struct libcdsb_set, root) == offsetof(struct libcdsb_map, root), "Implementation assert"); static_assert(offsetof(struct libcdsb_set, type) == offsetof(struct libcdsb_map, type), "Implementation assert"); -#define mnode_empty ((mnode_t*)LIBCDSB_RBTREE_NODE_EMPTY) -#define mnode_create(k, p, c) ((mnode_t*)libcdsb_rbtree_node_create(k, (rbnode_t*)p, c, sizeof(mnode_t))) -#define mnode_fixup(r, n) libcdsb_rbtree_node_fixup((rbnode_t**)(r), (rbnode_t*)(n)) -#define mnode_delete(r, n) (mnode_t*)libcdsb_rbtree_node_delete((rbnode_t**)(r), (rbnode_t*)(n)) +#define mnode_empty ((mnode_t*)rbnode_empty) +#define mnode_create(k, p, c) ((mnode_t*)libcdsb_builtin_rbtree_node_create(k, (rbnode_t*)p, c, sizeof(mnode_t))) +#define mnode_fixup(r, n) libcdsb_builtin_rbtree_node_fixup((rbnode_t**)(r), (rbnode_t*)(n)) +#define mnode_delete(r, n) (mnode_t*)libcdsb_builtin_rbtree_node_delete((rbnode_t**)(r), (rbnode_t*)(n)) #define mnode_is_empty(n) ((n) == mnode_empty) #define mnode_is_root(n) mnode_is_empty((n)->parent) +#define miter_inorder(x, reverse) rbiter_inorder((void*)x, reverse) +#define miter_preorder(x, reverse) rbiter_preorder((void*)x, reverse) +#define miter_postorder(x, reverse) rbiter_postorder((void*)x, reverse) +#define miter_breath_first(x, reverse) rbiter_breath_first((void*)x, reverse) + #endif /* LIBCDSB_SRC_MAP_INCLUDE_H */ diff --git a/src/extra-memory.c b/src/memory.c similarity index 100% rename from src/extra-memory.c rename to src/memory.c diff --git a/src/rbtree.c b/src/rbtree.c index 9c7d328..025ff6d 100644 --- a/src/rbtree.c +++ b/src/rbtree.c @@ -11,19 +11,12 @@ typedef enum libcdsb_rbtree_node_direction { #define rbdir_dir(cur, d) (&((cur)->left))[(d)>>1] #define rbdir_inv(cur, d) (&((cur)->left))[(d)&1] -/*#####################################################################################################################*/ +#define rotate libcdsb_builtin_rotate +#define replace libcdsb_builtin_replace +#define fixup libcdsb_builtin_fixup -rbnode_t LIBCDSB_RBTREE_NODE_EMPTY[1] = {{ - .colored = 0, - .value = 0, - .parent = rbnode_empty, - .left = rbnode_empty, - .right = rbnode_empty -}}; -/*#####################################################################################################################*/ - -static inline void rotate(rbnode_t **x, rbnode_t *c, rbdir_t d) { +static void libcdsb_builtin_rotate(rbnode_t **x, rbnode_t *c, rbdir_t d) { rbnode_t* n = rbdir_inv(c, d); rbdir_inv(c, d) = rbdir_dir(n, d); @@ -41,7 +34,8 @@ static inline void rotate(rbnode_t **x, rbnode_t *c, rbdir_t d) { c->parent = n; } -static inline void replace(rbnode_t** x, rbnode_t* c, rbnode_t* n) { + +static void libcdsb_builtin_replace(rbnode_t** x, rbnode_t* c, rbnode_t* n) { if (!rbnode_is_root(c)) { if (c->parent->left == c) { c->parent->left = n; @@ -51,10 +45,7 @@ static inline void replace(rbnode_t** x, rbnode_t* c, rbnode_t* n) { } -/*#####################################################################################################################*/ - - -static void delete_fixup(rbnode_t** x, rbnode_t* n) { +static void libcdsb_builtin_fixup(rbnode_t** x, rbnode_t* n) { rbdir_t d; rbnode_t *s, *p; @@ -98,8 +89,16 @@ static void delete_fixup(rbnode_t** x, rbnode_t* n) { /*#####################################################################################################################*/ +rbnode_t LIBCDSB_BUILTIN_RBTREE_NODE_EMPTY[1] = {{ + .colored = 0, + .value = 0, + .parent = rbnode_empty, + .left = rbnode_empty, + .right = rbnode_empty +}}; -rbnode_t* libcdsb_rbtree_node_delete(rbnode_t** x, rbnode_t* c) { + +rbnode_t* libcdsb_builtin_rbtree_node_delete(rbnode_t** x, rbnode_t* c) { rbnode_t *n, *t; int s; @@ -135,14 +134,14 @@ rbnode_t* libcdsb_rbtree_node_delete(rbnode_t** x, rbnode_t* c) { t->left = c->left; } - if (!s) delete_fixup(x, n); + if (!s) fixup(x, n); return c; } -void libcdsb_rbtree_node_fixup(rbnode_t** x, rbnode_t* n) { +void libcdsb_builtin_rbtree_node_fixup(rbnode_t** x, rbnode_t* n) { rbdir_t d[2]; rbnode_t *u, *p, *gp; @@ -181,7 +180,7 @@ void libcdsb_rbtree_node_fixup(rbnode_t** x, rbnode_t* n) { } -void* libcdsb_rbtree_node_create(void* v, rbnode_t* p, int c, int n) { +void* libcdsb_builtin_rbtree_node_create(void* v, rbnode_t* p, int c, int n) { rbnode_t* x; x = malloc(n); @@ -194,3 +193,160 @@ void* libcdsb_rbtree_node_create(void* v, rbnode_t* p, int c, int n) { return x; } + + +stack_t libcdsb_builtin_rbtree_iter_inorder(rbnode_t** root, bool reverse) { + rbnode_t *n, hack; + stack_t z, *bot; + + memset(&z, 0, sizeof(z)); + + if (rbnode_is_empty(*root)) + return z; + + hack.right = *root; + n = &hack; + + for (bot = &z;;) { + for (;;) { + if (rbnode_is_empty(n->right)) { + + if (rbnode_is_root(n->parent) || n->parent->left == n) { + n = n->parent; + break; + } else n = n->parent; + + if (rbnode_is_root(n->parent) || n->parent->left == n) { + n = n->parent; + break; + } + + do { + n = n->parent; + } while (n->parent->right == n); + + n = n->parent; + } else { + n = n->right; + + while (!rbnode_is_empty(n->left)) + n = n->left; + + break; + } + + if (rbnode_is_root(n)) { + bot = z.prev; + z = *bot; + + free(bot); + + if (reverse) + stack_reverse(&z); + + return z; + } + } + + bot = stack_insert(bot, n); + } +} + + +stack_t libcdsb_builtin_rbtree_iter_preorder(rbnode_t** root, bool reverse) { + stack_t z, *cur, *next; + rbnode_t *n; + + memset(&z, 0, sizeof(z)); + + if (rbnode_is_empty(*root)) + return z; + + z.value = *root; + cur = &z; + + do { + n = (next = cur)->value; + + if (!rbnode_is_empty(n->left)) next = stack_insert(cur, n->left); + if (!rbnode_is_empty(n->right)) stack_insert(next, n->right); + } while (!is_null(cur = cur->prev)); + + if (reverse) + stack_reverse(&z); + + return z; +} + + +stack_t libcdsb_builtin_rbtree_iter_postorder(rbnode_t** root, bool reverse) { + rbnode_t *p, *n; + stack_t z, *bot; + + bot = &z; + z.prev = 0; + z.value = 0; + + if (rbnode_is_empty(p = *root)) + return z; + + goto mid_; + + do { + if (n->parent->right != n && !rbnode_is_empty(n->parent->right)) { + p = n->parent->right; + do { mid_: + n = p; + p = !rbnode_is_empty(p->left) ? p->left : p->right; + } while (!rbnode_is_empty(p)); + } else n = n->parent; + + bot = stack_insert(bot, n); + } while (!rbnode_is_root(n)); + + bot = z.prev; + z = *bot; + + free(bot); + + if (reverse) + stack_reverse(&z); + + return z; +} + + +stack_t libcdsb_builtin_rbtree_iter_breath_first(rbnode_t** root, bool reverse) { + + stack_t z, *top, *bot, *cur; + rbnode_t* n; + + memset(&z, 0, sizeof(z)); + + if (rbnode_is_empty(z.value = *root)) + return z; + + for (top = bot = &z;;) { + for (cur = bot;;) { + + n = top->value; + + if (!rbnode_is_empty(n->left)) cur = stack_insert(cur, n->left); + if (!rbnode_is_empty(n->right)) cur = stack_insert(cur, n->right); + + if (top == bot) { + top = top->prev; + break; + } else top = top->prev; + } + + if (!is_null(top)) { + while (!is_null(bot->prev)) bot = bot->prev; + } else break; + } + + if (reverse) + stack_reverse(&z); + + return z; +} diff --git a/src/set/access.c b/src/set/access.c index 2f022c1..2e5a4c4 100644 --- a/src/set/access.c +++ b/src/set/access.c @@ -4,6 +4,48 @@ #include "../../include/set.h" #include "../__internal/rbtree.h" +static int libcdsb_builtin_foreach(set_t* x, void* data, vset_access_callback callback) { + stack_t z, *top, *bot, *cur; + rbnode_t* n; + int r = 0; + + memset(&z, 0, sizeof(z)); + + if (rbnode_is_empty(z.value = x->root)) + return 0; + + for (top = bot = &z;;) { + for (cur = bot;;) { + + n = top->value; + + if (!rbnode_is_empty(n->left)) cur = stack_insert(cur, n->left); + if (!rbnode_is_empty(n->right)) cur = stack_insert(cur, n->right); + + if (!r) { + r = callback(vnode_peek(&n->value, x->type), x->type, data); + } else { + stack_flush(&z); + return r; + } + + if (top == bot) { + top = top->prev; + break; + } else top = top->prev; + } + + if (!is_null(top)) { + while (!is_null(bot->prev)) bot = bot->prev; + } else break; + } + + stack_flush(&z); + return r; +} + +/*#####################################################################################################################*/ + int libcdsb_vset_find(vtype_set* x, const void* v, vtype t, void* _, vset_access_callback callback, bool cut) { rbnode_t* c; void *val; @@ -32,46 +74,41 @@ int libcdsb_vset_find(vtype_set* x, const void* v, vtype t, void* _, vset_access } -int libcdsb_vset_foreach(set_t* x, void* data, vset_access_callback callback, bool flush) { - stack_t z; - int r; - rbnode_t* c; +int libcdsb_vset_foreach(set_t* x, void* data, vset_access_callback callback, rbforeach_t type, bool flush) { + bool reverse; + stack_t iter; + rbnode_t* n; + int r = 0; - stack_init(&z); - stack_push(&z, x->root); + reverse = type&RBFOREACH_REVERSE; - r = 0; + switch (type&(RBFOREACH_INORDER|RBFOREACH_PREORDER|RBFOREACH_POSTORDER|RBFOREACH_BREADTH_FIRST)) { + case RBFOREACH_INORDER: iter = rbiter_inorder (&x->root, reverse); break; + case RBFOREACH_PREORDER: iter = rbiter_preorder (&x->root, reverse); break; + case RBFOREACH_POSTORDER: iter = rbiter_postorder(&x->root, reverse); break; + + default: + case RBFOREACH_BREADTH_FIRST: if (reverse || flush) { + iter = rbiter_breath_first(&x->root, type&RBFOREACH_REVERSE); + break; + } else return libcdsb_builtin_foreach(x, data, callback); + } - if (rbnode_is_empty(x->root)) - return 0; - - while ((c = stack_pop(&z))) { - if ((r = callback(vnode_peek(&c->value, x->type), x->type, data))) - break; - - - if (!rbnode_is_empty(c->right)) stack_push(&z, c->right); - if (!rbnode_is_empty(c->left)) stack_push(&z, c->left); + while ((n = stack_pop(&iter))) { + if (!r) { + r = callback(vnode_peek(&n->value, x->type), x->type, data); + } else if (!flush) { + stack_flush(&iter); + return r; + } if (flush) { - vnode_free(&c->value, x->type); - free(c); + vnode_free(&n->value, x->type); + free(n); } } - if (flush) { - while (c) { - if (!rbnode_is_empty(c->right)) stack_push(&z, c->right); - if (!rbnode_is_empty(c->left)) stack_push(&z, c->left); - - vnode_free(&c->value, x->type); - free(c); - - c = stack_pop(&z); - } - - memset(x, 0, sizeof(*x)); - } else stack_flush(&z); + if (flush) x->root = rbnode_empty; return r; } diff --git a/src/set/comparison.c b/src/set/comparison.c index 4a3dabc..fbf2908 100644 --- a/src/set/comparison.c +++ b/src/set/comparison.c @@ -4,7 +4,7 @@ #include "../../include/set.h" #include "../__internal/rbtree.h" -static inline int rbnode_compare(const rbnode_t* s0, const rbnode_t* s1, vtype t) { +static inline int libcdsb_builtin_compare(const rbnode_t* s0, const rbnode_t* s1, vtype t) { return vnode_compare(s0->value, t, s1->value, t); } @@ -34,13 +34,13 @@ int vset_compare(const set_t* s0, const set_t* s1) { stack_flush(&z); return rbnode_is_empty(c0) ? -1 : 1; } - } else if ((cmp = rbnode_compare(c0, c1, s0->type))) { + } else if ((cmp = libcdsb_builtin_compare(c0, c1, s0->type))) { if (c0->left == c1->right) { // == rbnode_empty - cmp = rbnode_compare(c0->right, c1, s0->type); - if (!cmp) cmp = rbnode_compare(c0, c1->left, s0->type); + cmp = libcdsb_builtin_compare(c0->right, c1, s0->type); + if (!cmp) cmp = libcdsb_builtin_compare(c0, c1->left, s0->type); } else if (c0->right == c1->left) { // == rbnode_empty - cmp = rbnode_compare(c0, c1->right, s0->type); - if (!cmp) cmp = rbnode_compare(c0->left, c1, s0->type); + cmp = libcdsb_builtin_compare(c0, c1->right, s0->type); + if (!cmp) cmp = libcdsb_builtin_compare(c0->left, c1, s0->type); } if (cmp) { diff --git a/src/set/compute.c b/src/set/compute.c index 3f3bb78..8cf4b98 100644 --- a/src/set/compute.c +++ b/src/set/compute.c @@ -4,7 +4,7 @@ #include "../../include/set.h" #include "../__internal/rbtree.h" -static inline hash_t rbnode_hash(const rbnode_t* s, vtype t) { +static inline hash_t libcdsb_builtin_hash(const rbnode_t* s, vtype t) { return vnode_hash(&s->value, t); } @@ -54,7 +54,7 @@ hash_t vset_hash(const set_t* s) { } while (!is_null(c0 = stack_pop(&z))); } - v = rbnode_hash(c1, s->type); + v = libcdsb_builtin_hash(c1, s->type); stack_push(&z, s->root->right); if (!rbnode_is_empty(c0 = stack_pop(&z))) { @@ -65,7 +65,7 @@ hash_t vset_hash(const set_t* s) { } while (!is_null(c0 = stack_pop(&z))); } - v += rbnode_hash(c1, s->type); + v += libcdsb_builtin_hash(c1, s->type); return (hash ^ v) + VTYPE_SET; } diff --git a/src/extra-stack.c b/src/stack.c similarity index 62% rename from src/extra-stack.c rename to src/stack.c index 563a177..bdaca67 100644 --- a/src/extra-stack.c +++ b/src/stack.c @@ -27,6 +27,7 @@ void libcdsb_stack_push(stack_t* x, void* value) { x->value = value; } + void libcdsb_stack_push_many(stack_t* x, size_t c, ...) { va_list args; @@ -52,6 +53,7 @@ void libcdsb_stack_push_many(stack_t* x, size_t c, ...) { va_end(args); } + void* libcdsb_stack_pop(stack_t* x) { stack_t* n; @@ -70,14 +72,50 @@ void* libcdsb_stack_pop(stack_t* x) { } -void libcdsb_stack_flush(stack_t* stack) { +void libcdsb_stack_reverse(stack_t* x) { + + stack_t z, *iter, *n, copy; + + + if (x->prev) { + z.prev = 0; + z.value = x->value; + iter = x->prev; + + while (iter->prev) { + n = iter; + iter = n->prev; + + copy.prev = z.prev; + copy.value = z.value; + + z.prev = n; + z.value = n->value; + + n->prev = copy.prev; + n->value = copy.value; + } + + copy.prev = z.prev; + copy.value = z.value; + + x->prev = iter; + x->value = iter->value; + + iter->prev = copy.prev; + iter->value = copy.value; + } +} + + +void libcdsb_stack_flush(stack_t* x) { stack_t* c; - while (stack->prev) { - c = stack->prev; - stack->prev = c->prev; + while (x->prev) { + c = x->prev; + x->prev = c->prev; free(c); } - stack->value = 0; + x->value = 0; } diff --git a/src/string/include.h b/src/string/include.h index 15b1960..3a559e8 100644 --- a/src/string/include.h +++ b/src/string/include.h @@ -8,14 +8,14 @@ #ifndef LIBCDSB_SRC_STRING_INCLUDE_H #define LIBCDSB_SRC_STRING_INCLUDE_H -ainline(char* next_char(char* s)) { +ainline(char* libcdsb_builtin_next_char(char* s)) { int cs = charsize(s); if (cs) return s + cs; return ++s; } -ainline(char* prev_char(char* s)) { +ainline(char* libcdsb_builtin_prev_char(char* s)) { if (*(--s)&0x80) { char* p = s; @@ -29,4 +29,7 @@ ainline(char* prev_char(char* s)) { return s; } +#define next_char libcdsb_builtin_next_char +#define prev_char libcdsb_builtin_prev_char + #endif /* LIBCDSB_SRC_STRING_INCLUDE_H */ diff --git a/src/string/transform.c b/src/string/transform.c index 9ea825d..2fdecf6 100644 --- a/src/string/transform.c +++ b/src/string/transform.c @@ -3,7 +3,7 @@ #include "include.h" -static void string_replace_builtin(str_t* x, char* p, size_t n, const char* v, size_t vn) { +static void libcdsb_builtin_replace(str_t* x, char* p, size_t n, const char* v, size_t vn) { if (n != vn) { size_t l = strlen(x->buffer); @@ -75,7 +75,7 @@ size_t string_to_lower(str_t* x) { es = tochar_unicode(ps, uc1); if (!is_null(es)) { - string_replace_builtin(x, p, e-p, ps, es-ps); + libcdsb_builtin_replace(x, p, e-p, ps, es-ps); ++n; } } @@ -111,7 +111,7 @@ size_t string_to_upper(str_t* x) { es = tochar_unicode(ps, uc1); if (!is_null(es)) { - string_replace_builtin(x, p, e-p, ps, es-ps); + libcdsb_builtin_replace(x, p, e-p, ps, es-ps); ++n; } } @@ -145,7 +145,7 @@ size_t string_capitalize(str_t* x) { es = tochar_unicode(ps, uc1); if (!is_null(es)) { - string_replace_builtin(x, p, e-p, ps, es-ps); + libcdsb_builtin_replace(x, p, e-p, ps, es-ps); ++n; } } @@ -163,7 +163,7 @@ size_t string_capitalize(str_t* x) { es = tochar_unicode(ps, uc1); if (!is_null(es)) { - string_replace_builtin(x, p, e-p, ps, es-ps); + libcdsb_builtin_replace(x, p, e-p, ps, es-ps); ++n; } } diff --git a/src/vtype-extra.c b/src/stringify.c similarity index 72% rename from src/vtype-extra.c rename to src/stringify.c index 8776b10..054ea29 100644 --- a/src/vtype-extra.c +++ b/src/stringify.c @@ -4,8 +4,6 @@ #include #include "__internal/include.h" -/*#####################################################################################################################*/ - #define sh__(a) #a #define s__(a) sh__(a) @@ -19,14 +17,14 @@ double: "%."s__(DBL_DIG)"lg",\ long double: "%."s__(LDBL_DIG)"Lg") -#define stringify(v) sprintf(STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS], fstring(v), (v)) +#define stringify(v) sprintf(LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER], fstring(v), (v)) -static _Thread_local int STRINGIFY_BUFFER_POS = 0; -static _Thread_local char STRINGIFY_BUFFER[16][64]; +static _Thread_local int LIBCDSB_BUILTIN_COUNTER = 0; +static _Thread_local char LIBCDSB_BUILTIN_BUFFER[16][64]; /*#####################################################################################################################*/ -const size_t LIBCDSB_VTYPE_SIZES[19] = { +const size_t LIBCDSB_BUILTIN_VTYPE_SIZES[19] = { 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), @@ -35,7 +33,6 @@ const size_t LIBCDSB_VTYPE_SIZES[19] = { sizeof(list_t), sizeof(set_t), sizeof(dict_t) }; -/*#####################################################################################################################*/ const char* libcdsb_vtype_name(vtype t) { switch (t) { @@ -70,8 +67,8 @@ const char* libcdsb_vtype_stringify(const void* v, vtype t) { if (t == VTYPE_BOOLEAN) return (*(vtype_bool*)v) ? "true" : "false"; if (t == VTYPE_STRING) return *(char**)v; - if (STRINGIFY_BUFFER_POS > 15) - STRINGIFY_BUFFER_POS = 0; + if (LIBCDSB_BUILTIN_COUNTER > 15) + LIBCDSB_BUILTIN_COUNTER = 0; switch (t) { case VTYPE_INT8: stringify(*( s8_t*)v); break; @@ -83,25 +80,25 @@ const char* libcdsb_vtype_stringify(const void* v, vtype t) { case VTYPE_UINT32: stringify(*( u32_t*)v); break; case VTYPE_UINT64: stringify(*( u64_t*)v); break; case VTYPE_FLOAT: if (abs(*(fl_t*)v) <= FLT_EPSILON) { - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00; } else stringify(*(fl_t*)v); break; case VTYPE_DOUBLE: if (abs(*(dbl_t*)v) <= DBL_EPSILON) { - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00; } else stringify(*(dbl_t*)v); break; case VTYPE_LDOUBLE: if (abs(*(ldbl_t*)v) <= LDBL_EPSILON) { - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; - STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30; + LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00; } else stringify(*(ldbl_t*)v); break; - case VTYPE_POINTER: sprintf(STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS], (sizeof(void*) == 8) ? "0x%016lx" : "0x%08x", (uintptr_t)*(void**)v); break; + case VTYPE_POINTER: sprintf(LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER], (sizeof(void*) == 8) ? "0x%016lx" : "0x%08x", (uintptr_t)*(void**)v); break; - default: sprintf(STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS], "<%s>", libcdsb_vtype_name(t)); + default: sprintf(LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER], "<%s>", libcdsb_vtype_name(t)); break; } - return STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS++]; + return LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER++]; } diff --git a/src/vnode.c b/src/vnode.c index 5a30d6e..33babed 100644 --- a/src/vnode.c +++ b/src/vnode.c @@ -5,7 +5,7 @@ #include "__internal/vnode.h" #include "../include/string.h" -static vtype internal_round(u64_t* x, ldbl_t v) { +static vtype libcdsb_builtin_round(u64_t* x, ldbl_t v) { if (v > 0) { *x = (u64_t)(v + 0.5); return VTYPE_UINT64; @@ -15,18 +15,16 @@ static vtype internal_round(u64_t* x, ldbl_t v) { } } -/*#####################################################################################################################*/ - -static vnode_t create_value(vtype xt, const void* v, vtype t) { +static vnode_t libcdsb_builtin_create_value(vtype xt, const void* v, vtype t) { var_t _; if (t == VTYPE_FLOAT) { - t = internal_round(&_.u64, *(fl_t*)v); + t = libcdsb_builtin_round(&_.u64, *(fl_t*)v); } else if (t == VTYPE_DOUBLE) { - t = internal_round(&_.u64, *(dbl_t*)v); + t = libcdsb_builtin_round(&_.u64, *(dbl_t*)v); } else if (t == VTYPE_LDOUBLE) { - t = internal_round(&_.u64, *(ldbl_t*)v); + t = libcdsb_builtin_round(&_.u64, *(ldbl_t*)v); } if (sizeof(void*) == 8) { @@ -85,7 +83,7 @@ static vnode_t create_value(vtype xt, const void* v, vtype t) { } -static vnode_t create_float(vtype xt, const void* v, vtype t) { +static vnode_t libcdsb_builtin_create_float(vtype xt, const void* v, vtype t) { var_t _; if (t == VTYPE_UINT8 || t == VTYPE_BOOLEAN ) { @@ -131,11 +129,9 @@ static vnode_t create_float(vtype xt, const void* v, vtype t) { return _.ptr; } - /*#####################################################################################################################*/ - -vnode_t libcdsb_vnode_create(const void* v, vtype t) { +vnode_t libcdsb_builtin_vnode_create(const void* v, vtype t) { var_t _ = { .ptr = 0 }; switch (t) { default: abort(); @@ -198,10 +194,7 @@ vnode_t libcdsb_vnode_create(const void* v, vtype t) { } -/*#####################################################################################################################*/ - - -void* libcdsb_vnode_peek(const vnode_t* x, vtype t) { +void* libcdsb_builtin_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_; @@ -232,7 +225,7 @@ void* libcdsb_vnode_peek(const vnode_t* x, vtype t) { } -void libcdsb_vnode_free(vnode_t* x, vtype t) { +void libcdsb_builtin_vnode_free(vnode_t* x, vtype t) { switch (t) { default: abort(); @@ -271,18 +264,15 @@ void libcdsb_vnode_free(vnode_t* x, vtype t) { } -/*#####################################################################################################################*/ - - -vnode_t libcdsb_vnode_create_target(vtype xt, const void* v, vtype t) { +vnode_t libcdsb_builtin_vnode_create_target(vtype xt, const void* v, vtype t) { var_t _ = { .ptr = 0 }; if (xt <= VTYPE_LDOUBLE) { if (t >= VTYPE_STRING) t = VTYPE_POINTER; if (xt <= VTYPE_INT64) - return create_value(xt, v, t); - return create_float(xt, v, t); + return libcdsb_builtin_create_value(xt, v, t); + return libcdsb_builtin_create_float(xt, v, t); } else if (t == VTYPE_POINTER && (t = xt) > VTYPE_STRING) { v = *(void**)v; } diff --git a/src/vtype.c b/src/vtype.c index 45663d8..e8389e5 100644 --- a/src/vtype.c +++ b/src/vtype.c @@ -6,7 +6,7 @@ /*#####################################################################################################################*/ -static ldbl_t normalize_value(const void* v, vtype t) { +static ldbl_t libcdsb_builtin_normalize(const void* v, vtype t) { if (t == VTYPE_BOOLEAN || t == VTYPE_UINT8) { return *(u8_t*)v; } else if (t == VTYPE_UINT16) { @@ -30,7 +30,7 @@ static ldbl_t normalize_value(const void* v, vtype t) { } else return abs(*(ldbl_t*)v) <= LDBL_EPSILON ? 0 : *(ldbl_t*)v; } -static hash_t ldouble_hash(ldbl_t s) { +static hash_t libcdsb_builtin_hash_float(ldbl_t s) { hash_t hash; if (sizeof(hash_t) == sizeof(u64_t)) { @@ -61,14 +61,14 @@ static hash_t ldouble_hash(ldbl_t s) { /*#####################################################################################################################*/ -int libcdsb_vtype_compare_values(const void* s0, vtype t0, const void* s1, vtype t1) { - if (t0 == t1) return libcdsb_vtype_compare_values_eq(s0, s1, t0); +int libcdsb_builtin_vtype_compare_values(const void* s0, vtype t0, const void* s1, vtype t1) { + if (t0 == t1) return libcdsb_builtin_vtype_compare_values_eq(s0, s1, t0); if (t0 <= VTYPE_LDOUBLE && t1 <= VTYPE_LDOUBLE) { ldbl_t d0, d1; - d0 = normalize_value(s0, t0); - d1 = normalize_value(s1, t1); + d0 = libcdsb_builtin_normalize(s0, t0); + d1 = libcdsb_builtin_normalize(s1, t1); return (abs(d0 - d1) <= LDBL_EPSILON) ? 0 : (d0 < d1 ? -1 : 1); } @@ -77,7 +77,7 @@ int libcdsb_vtype_compare_values(const void* s0, vtype t0, const void* s1, vtype } -int libcdsb_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) { +int libcdsb_builtin_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) { #define compare(T, s0, s1) *(T*)s0 == *(T*)s1 ? 0 : (*(T*)s0 < *(T*)s1 ? -1 : 1) @@ -117,7 +117,7 @@ int libcdsb_vtype_compare_values_eq(const void* s0, const void* s1, vtype t) { /*#####################################################################################################################*/ -hash_t libcdsb_vtype_hash(const void* v, vtype t) { +hash_t libcdsb_builtin_vtype_hash(const void* v, vtype t) { switch (t) { default: abort(); @@ -147,8 +147,8 @@ hash_t libcdsb_vtype_hash(const void* v, vtype t) { case VTYPE_SET: return vset_hash(v); case VTYPE_DICT: return dict_hash(v); - case VTYPE_FLOAT: return ldouble_hash(*(fl_t*)v); - case VTYPE_DOUBLE: return ldouble_hash(*(dbl_t*)v); - case VTYPE_LDOUBLE: return ldouble_hash(*(ldbl_t*)v); + case VTYPE_FLOAT: return libcdsb_builtin_hash_float(*(fl_t*)v); + case VTYPE_DOUBLE: return libcdsb_builtin_hash_float(*(dbl_t*)v); + case VTYPE_LDOUBLE: return libcdsb_builtin_hash_float(*(ldbl_t*)v); } } diff --git a/tests/Makefile b/tests/Makefile index bb8f5ee..a5297ce 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -51,6 +51,8 @@ tests: $(addprefix $(BUILD_PATH)/global-,$(notdir $(basename $(wildcard ./src/gl ######################################################################################################################## +CFLAGS:=$(CFLAGS) ../modules/libunic/bin/libunic.a + $(BUILD_PATH)/obj/%.o: ./src/%.c | $(BUILD_PATH)/obj/ $(CC) $^ -o $@ $(CFLAGS) @@ -72,7 +74,7 @@ $(BUILD_PATH)/obj/global-%.o: ./src/global/src/%.c | $(BUILD_PATH)/obj/ $(BUILD_PATH)/array-%: ./src/array/%.c $(OBJECTS_ARRAY) | $(BUILD_PATH)/ $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(BUILD_PATH)/string-%: ./src/string/%.c $(OBJECTS_STRING) | $(BUILD_PATH)/ - $(CC) $^ -o $@ ../modules/libunic/bin/libunic.a $(CFLAGS) -g3 -Wall + $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(BUILD_PATH)/list-%: ./src/list/%.c $(OBJECTS_LIST) | $(BUILD_PATH)/ $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(BUILD_PATH)/map-%: ./src/map/%.c $(OBJECTS_MAP) | $(BUILD_PATH)/ @@ -82,7 +84,7 @@ $(BUILD_PATH)/set-%: ./src/set/%.c $(OBJECTS_SET) | $(BUILD_PATH)/ $(BUILD_PATH)/dict-%: ./src/dict/%.c $(OBJECTS_DICT) | $(BUILD_PATH)/ $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(BUILD_PATH)/global-%: ./src/global/%.c $(OBJECTS_GLOBAL) | $(BUILD_PATH)/ - $(CC) $^ ../bin/debug/libcdsb.a ../modules/libunic/bin/libunic.a -o $@ $(CFLAGS) -g3 -Wall + $(CC) $^ ../bin/debug/libcdsb.a -o $@ $(CFLAGS) -g3 -Wall ######################################################################################################################## diff --git a/tests/src/array/plug.h b/tests/src/array/plug.h index 0243a08..dbf0956 100644 --- a/tests/src/array/plug.h +++ b/tests/src/array/plug.h @@ -2,7 +2,7 @@ /* Copyright © 2022 Gregory Lirent */ #include -#include "../../../include/extra/vtype.h" +#include "../../../include/vtype.h" #include "../../../include/array.h" #include "../../include/random.h" diff --git a/tests/src/array/src/plug.c b/tests/src/array/src/plug.c index 0ed9a6b..4c9a95a 100644 --- a/tests/src/array/src/plug.c +++ b/tests/src/array/src/plug.c @@ -2,16 +2,14 @@ /* Copyright © 2022 Gregory Lirent */ #include -#include "../../../../include/extra/vtype.h" +#include "../../../../include/vtype.h" #include "../../../include/random.h" -vtype_string* string_duplicate(const vtype_string* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_dict* dict_duplicate (const vtype_dict* x) { return 0; } -void string_free(vtype_string* x) {} void list_free (vtype_list* x) {} void map_free (vtype_map* x) {} void vset_free (vtype_set* x) {} @@ -29,7 +27,6 @@ hash_t map_hash (const vtype_map* s) { return 0; } hash_t vset_hash (const vtype_set* s) { return 0; } hash_t dict_hash (const vtype_dict* s) { return 0; } -void string_copy_init(vtype_string* x, const vtype_string* s) { memset(x, 0, sizeof(*x)); } void list_copy_init (vtype_list* x, const vtype_list* s) { memset(x, 0, sizeof(*x)); } void map_copy_init (vtype_map* x, const vtype_map* s) { memset(x, 0, sizeof(*x)); } void vset_copy_init (vtype_set* x, const vtype_set* s) { memset(x, 0, sizeof(*x)); } diff --git a/tests/src/array/src/random.c b/tests/src/array/src/random.c index 4dcc8b7..be9de57 100644 --- a/tests/src/array/src/random.c +++ b/tests/src/array/src/random.c @@ -31,7 +31,7 @@ void array_push_random(arr_t* x, _Bool silent, unsigned int hpos) { printf("\e[%dG\e[36mTry to push value to back of the array:\e[m\n", hpos+1); } - r = libcdsb_array_push(x, _.v.value, _.v.type) >= 0; + r = libcdsb_array_insert(x, _.v.value, _.v.type) >= 0; } else { ssize_t i = array_size(x); diff --git a/tests/src/dict/src/plug.c b/tests/src/dict/src/plug.c index bb5545a..24fc959 100644 --- a/tests/src/dict/src/plug.c +++ b/tests/src/dict/src/plug.c @@ -4,13 +4,11 @@ #include "../../../../src/__internal/include.h" #include "../../../include/random.h" -vtype_string* string_duplicate(const vtype_string* x) { return 0; } vtype_array* array_duplicate (const vtype_array* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; } -void string_free(vtype_string* x) {} void array_free (vtype_array* x) {} void list_free (vtype_list* x) {} void map_free (vtype_map* x) {} diff --git a/tests/src/global/plug.h b/tests/src/global/plug.h index b2dce62..97d1eda 100644 --- a/tests/src/global/plug.h +++ b/tests/src/global/plug.h @@ -1,7 +1,7 @@ /* This software is licensed by the MIT License, see LICENSE file */ /* Copyright © 2022 Gregory Lirent */ -#include "../../../include/extra/string.h" +#include "../../../include/string.h" #include "../../../include/array.h" #include "../../../include/list.h" #include "../../../include/set.h" diff --git a/tests/src/global/src/random.c b/tests/src/global/src/random.c index df0de0f..cef5267 100644 --- a/tests/src/global/src/random.c +++ b/tests/src/global/src/random.c @@ -80,30 +80,34 @@ static arr_t random_array(bool embd) { size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); value_t v = (!embd) ? random_value2() : real_random_value(1); - void (*callback)(void*); - - switch (v.type) { - default: callback = nullptr; break; - case VTYPE_STRING: callback = (void*)string_free; break; - case VTYPE_ARRAY: callback = (void*)array_free; break; - case VTYPE_LIST: callback = (void*)list_free; break; - case VTYPE_MAP: callback = (void*)map_free; break; - case VTYPE_SET: callback = (void*)vset_free; break; - case VTYPE_DICT: callback = (void*)dict_free; break; - } - array_init(&x, v.type); while(n--) { - libcdsb_array_push(&x, v.value, v.type); + libcdsb_array_insert(&x, v.value, v.type); - if (callback) callback(v.value); + switch (v.type) { + default: break; + case VTYPE_STRING: string_free((void*)v.value); break; + case VTYPE_ARRAY: array_free((void*)v.value); break; + case VTYPE_LIST: list_free((void*)v.value); break; + case VTYPE_MAP: map_free((void*)v.value); break; + case VTYPE_SET: vset_free((void*)v.value); break; + case VTYPE_DICT: dict_free((void*)v.value); break; + } v = random_value_by_type(v.type, 1); } - if (callback) callback(v.value); + switch (v.type) { + default: break; + case VTYPE_STRING: string_free((void*)v.value); break; + case VTYPE_ARRAY: array_free((void*)v.value); break; + case VTYPE_LIST: list_free((void*)v.value); break; + case VTYPE_MAP: map_free((void*)v.value); break; + case VTYPE_SET: vset_free((void*)v.value); break; + case VTYPE_DICT: dict_free((void*)v.value); break; + } return x; } @@ -113,30 +117,35 @@ static set_t random_set(bool embd) { size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); value_t v = (!embd) ? random_value2() : real_random_value(1); - void (*callback)(void*); - - switch (v.type) { - default: callback = nullptr; break; - case VTYPE_STRING: callback = (void*)string_free; break; - case VTYPE_ARRAY: callback = (void*)array_free; break; - case VTYPE_LIST: callback = (void*)list_free; break; - case VTYPE_MAP: callback = (void*)map_free; break; - case VTYPE_SET: callback = (void*)vset_free; break; - case VTYPE_DICT: callback = (void*)dict_free; break; - } - vset_init(&x, v.type); while(n--) { libcdsb_vset_insert(&x, v.value, v.type); - if (callback) callback(v.value); + switch (v.type) { + default: break; + case VTYPE_STRING: string_free((void*)v.value); break; + case VTYPE_ARRAY: array_free((void*)v.value); break; + case VTYPE_LIST: list_free((void*)v.value); break; + case VTYPE_MAP: map_free((void*)v.value); break; + case VTYPE_SET: vset_free((void*)v.value); break; + case VTYPE_DICT: dict_free((void*)v.value); break; + } v = random_value_by_type(v.type, 1); } - if (callback) callback(v.value); + switch (v.type) { + default: break; + case VTYPE_STRING: string_free((void*)v.value); break; + case VTYPE_ARRAY: array_free((void*)v.value); break; + case VTYPE_LIST: list_free((void*)v.value); break; + case VTYPE_MAP: map_free((void*)v.value); break; + case VTYPE_SET: vset_free((void*)v.value); break; + case VTYPE_DICT: dict_free((void*)v.value); break; + } + return x; } @@ -149,7 +158,7 @@ static list_t random_list(bool embd) { while(n--) { v = (!embd) ? random_value2() : real_random_value(1); - libcdsb_list_update(&x, -1, v.value, v.type, 1); + libcdsb_list_insert(&x, -1, v.value, v.type, 1); switch (v.type) { default: break; @@ -170,18 +179,6 @@ static map_t random_map(bool embd) { size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); value_t k = (!embd) ? random_value2() : real_random_value(1); - void (*callback)(void*); - - switch (k.type) { - default: callback = nullptr; break; - case VTYPE_STRING: callback = (void*)string_free; break; - case VTYPE_ARRAY: callback = (void*)array_free; break; - case VTYPE_LIST: callback = (void*)list_free; break; - case VTYPE_MAP: callback = (void*)map_free; break; - case VTYPE_SET: callback = (void*)vset_free; break; - case VTYPE_DICT: callback = (void*)dict_free; break; - } - map_init(&x, k.type); while(n--) { @@ -189,7 +186,15 @@ static map_t random_map(bool embd) { libcdsb_map_update(&x, k.value, k.type, v.value, v.type); - if (callback) callback(k.value); + switch (k.type) { + default: break; + case VTYPE_STRING: string_free((void*)k.value); break; + case VTYPE_ARRAY: array_free((void*)k.value); break; + case VTYPE_LIST: list_free((void*)k.value); break; + case VTYPE_MAP: map_free((void*)k.value); break; + case VTYPE_SET: vset_free((void*)k.value); break; + case VTYPE_DICT: dict_free((void*)k.value); break; + } switch (v.type) { default: break; @@ -204,7 +209,16 @@ static map_t random_map(bool embd) { k = random_value_by_type(k.type, 1); } - if (callback) callback(k.value); + switch (k.type) { + default: break; + case VTYPE_STRING: string_free((void*)k.value); break; + case VTYPE_ARRAY: array_free((void*)k.value); break; + case VTYPE_LIST: list_free((void*)k.value); break; + case VTYPE_MAP: map_free((void*)k.value); break; + case VTYPE_SET: vset_free((void*)k.value); break; + case VTYPE_DICT: dict_free((void*)k.value); break; + } + return x; } diff --git a/tests/src/list/src/plug.c b/tests/src/list/src/plug.c index 7a32c0e..6c79e8a 100644 --- a/tests/src/list/src/plug.c +++ b/tests/src/list/src/plug.c @@ -4,13 +4,11 @@ #include "../../../../src/__internal/include.h" #include "../../../include/random.h" -vtype_string* string_duplicate(const vtype_string* x) { return 0; } vtype_array* array_duplicate (const vtype_array* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_dict* dict_duplicate (const vtype_dict* x) { return 0; } -void string_free(vtype_string* x) {} void array_free (vtype_array* x) {} void map_free (vtype_map* x) {} void vset_free (vtype_set* x) {} diff --git a/tests/src/list/src/random.c b/tests/src/list/src/random.c index 5a4a1a9..504c5ad 100644 --- a/tests/src/list/src/random.c +++ b/tests/src/list/src/random.c @@ -26,12 +26,12 @@ void list_push_random(list_t* x, _Bool silent, unsigned int hpos) { if (!silent) { printf("\e[%dG\e[36mTry to push value to back of the list:\e[m\n", hpos+1); } - r = libcdsb_list_update(x, -1, v.value, v.type, 1); + r = libcdsb_list_insert(x, -1, v.value, v.type, 1); } else if (random_boolean()) { if (!silent) { printf("\e[%dG\e[36mTry to push value to front of the list:\e[m\n", hpos+1); } - r = libcdsb_list_update(x, -1, v.value, v.type, 1); + r = libcdsb_list_insert(x, -1, v.value, v.type, 1); } else { ssize_t i = list_size(x); i = random_uint64()% (i ? i : 1); @@ -41,7 +41,7 @@ void list_push_random(list_t* x, _Bool silent, unsigned int hpos) { printf("\e[%dG\e[36mTry to change value with index \e[32;1m%ld\e[36m in the list:\e[m\n", hpos+1, i); } - r = libcdsb_list_update(x, i, v.value, v.type, 0); + r = libcdsb_list_insert(x, i, v.value, v.type, 0); } if (!silent) { diff --git a/tests/src/map/src/plug.c b/tests/src/map/src/plug.c index 2462c64..da3cbe2 100644 --- a/tests/src/map/src/plug.c +++ b/tests/src/map/src/plug.c @@ -4,13 +4,11 @@ #include "../../../../src/__internal/include.h" #include "../../../include/random.h" -vtype_string* string_duplicate(const vtype_string* x) { return 0; } vtype_array* array_duplicate (const vtype_array* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_dict* dict_duplicate (const vtype_dict* x) { return 0; } -void string_free(vtype_string* x) {} void array_free (vtype_array* x) {} void list_free (vtype_list* x) {} void vset_free (vtype_set* x) {} diff --git a/tests/src/set/src/plug.c b/tests/src/set/src/plug.c index 6dc338a..86d9620 100644 --- a/tests/src/set/src/plug.c +++ b/tests/src/set/src/plug.c @@ -4,13 +4,11 @@ #include "../../../../src/__internal/include.h" #include "../../../include/random.h" -vtype_string* string_duplicate(const vtype_string* x) { return 0; } vtype_array* array_duplicate (const vtype_array* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_dict* dict_duplicate (const vtype_dict* x) { return 0; } -void string_free(vtype_string* x) {} void array_free (vtype_array* x) {} void list_free (vtype_list* x) {} void map_free (vtype_map* x) {}