c/libcdsb
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch '#43-issue' of lirent/libcdsb into develop

Browse Source
This commit is contained in:
Gregory Lirent 2022-08-24 13:10:06 +03:00 committed by Gogs
commit e257d4ba29
46 changed files with 702 additions and 448 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/array.h
View File

@ -1,6 +1,7 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "bits/__generics.h"
#include "vtype.h" #include "vtype.h"
#ifndef LIBCDSB_ARRAY_H #ifndef LIBCDSB_ARRAY_H

20
include/bits/__rbtree.h Normal file
View File

@ -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 */

1
include/bits/memory.h
View File

@ -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 (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_push_many(stack_t* stack, size_t n, ...) Nonnull__(1);
extern void* libcdsb_stack_pop (stack_t* stack) 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_stack_flush (stack_t* stack) Nonnull__(1);
extern void* libcdsb_aalloc (size_t a, size_t n) Warn_unused_result__; extern void* libcdsb_aalloc (size_t a, size_t n) Warn_unused_result__;

1
include/dict.h
View File

@ -1,6 +1,7 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "bits/__generics.h"
#include "vtype.h" #include "vtype.h"
#ifndef LIBCDSB_DICT_H #ifndef LIBCDSB_DICT_H

1
include/list.h
View File

@ -1,6 +1,7 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "bits/__generics.h"
#include "vtype.h" #include "vtype.h"
#ifndef LIBCDSB_LIST_H #ifndef LIBCDSB_LIST_H

6
include/map.h
View File

@ -1,6 +1,8 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "bits/__generics.h"
#include "bits/__rbtree.h"
#include "vtype.h" #include "vtype.h"
#ifndef LIBCDSB_MAP_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_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_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_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 map_remove(x, key) map_pop (x, key, 0, 0)
#define in_map(x, key) (map_get(x, key, 0, 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_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 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_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 */ #endif /* LIBCDSB_MAP_H */

6
include/set.h
View File

@ -1,6 +1,8 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "bits/__generics.h"
#include "bits/__rbtree.h"
#include "vtype.h" #include "vtype.h"
#ifndef LIBCDSB_SET_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_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_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_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 vset_remove(x, value) vset_pop (x, value, 0, 0)
#define in_vset(x, value) (vset_get(x, value, 0, 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_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 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_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 */ #endif /* LIBCDSB_SET_H */

52
src/__internal/include.h
View File

@ -34,7 +34,6 @@
#define abs(v) _Generic((v), ldbl_t: fabsl, dbl_t: fabs, fl_t: fabsf)(v) #define abs(v) _Generic((v), ldbl_t: fabsl, dbl_t: fabs, fl_t: fabsf)(v)
typedef vtype_uint8 u8_t; typedef vtype_uint8 u8_t;
typedef vtype_uint16 u16_t; typedef vtype_uint16 u16_t;
typedef vtype_uint32 u32_t; typedef vtype_uint32 u32_t;
@ -59,12 +58,22 @@ typedef vtype_dict dict_t;
typedef vtype_hash hash_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_builtin_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 int libcdsb_builtin_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 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 aligned_alloc libcdsb_aalloc
#define malloc libcdsb_malloc #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_init libcdsb_stack_init
#define stack_push libcdsb_stack_push #define stack_push libcdsb_stack_push
#define stack_push_many libcdsb_stack_push_many #define stack_push_many libcdsb_stack_push_many
#define stack_insert libcdsb_builtin_stack_insert
#define stack_pop libcdsb_stack_pop #define stack_pop libcdsb_stack_pop
#define stack_reverse libcdsb_stack_reverse
#define stack_flush libcdsb_stack_flush #define stack_flush libcdsb_stack_flush
#define strlen libcdsb_strlen #define strlen libcdsb_strlen
#define strasciilen libcdsb_strasciilen #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_stringify libcdsb_vtype_stringify
#define vtype_name libcdsb_vtype_name #define vtype_name libcdsb_vtype_name
#define vtype_compare libcdsb_vtype_compare_values #define vtype_compare libcdsb_builtin_vtype_compare_values
#define vtype_compare_eq libcdsb_vtype_compare_values_eq #define vtype_compare_eq libcdsb_builtin_vtype_compare_values_eq
#define vtype_hash libcdsb_vtype_hash #define vtype_hash libcdsb_builtin_vtype_hash
#define vtype_size(type) (LIBCDSB_VTYPE_SIZES[type]) #define vtype_size(type) (LIBCDSB_BUILTIN_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))
#endif /* LIBCDSB_SRC_INTERNAL_INCLUDE */ #endif /* LIBCDSB_SRC_INTERNAL_INCLUDE */

26
src/__internal/rbtree.h
View File

@ -15,18 +15,28 @@ typedef struct libcdsb_rbtree_node {
short colored; short colored;
} rbnode_t; } 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_builtin_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 void libcdsb_builtin_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 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) extern stack_t libcdsb_builtin_rbtree_iter_inorder (rbnode_t** root, bool reverse);
#define rbnode_create(v, p, c) ((rbnode_t*)libcdsb_rbtree_node_create(v, p, c, sizeof(rbnode_t))) extern stack_t libcdsb_builtin_rbtree_iter_preorder (rbnode_t** root, bool reverse);
#define rbnode_fixup libcdsb_rbtree_node_fixup extern stack_t libcdsb_builtin_rbtree_iter_postorder (rbnode_t** root, bool reverse);
#define rbnode_delete libcdsb_rbtree_node_delete 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_empty(n) ((n) == rbnode_empty)
#define rbnode_is_root(n) rbnode_is_empty((n)->parent) #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 */ #endif /* LIBCDSB_SRC_INTERNAL_RBTREE_H */

30
src/__internal/vnode.h
View File

@ -19,15 +19,15 @@ typedef union {
typedef void* vnode_t; typedef void* vnode_t;
extern vnode_t libcdsb_vnode_create (const void* value, vtype type) wur__; extern vnode_t libcdsb_builtin_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_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_builtin_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_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) { 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) { } else if (sizeof(str_t) == sizeof(void*) && type == VTYPE_STRING) {
*node = *(char**)value; *node = *(char**)value;
} else { } 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) { if (type < VTYPE_STRING) {
*node = libcdsb_vnode_create_target(target_type, value, type); *node = libcdsb_builtin_vnode_create_target(target_type, value, type);
} else { } else {
type_assert(target_type, type); 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_create libcdsb_builtin_vnode_create
#define vnode_tcreate libcdsb_vnode_create_target #define vnode_tcreate libcdsb_builtin_vnode_create_target
#define vnode_peek libcdsb_vnode_peek #define vnode_attach libcdsb_builtin_vnode_attach
#define vnode_free libcdsb_vnode_free #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_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(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_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_duplicate(vnode, type) 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_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) #define vnode_stringify(n, t) vtype_stringify(vnode_peek(n, t), t)

80
src/array/sort.c
View File

@ -4,78 +4,42 @@
#include "include.h" #include "include.h"
#include "../__internal/assert.h" #include "../__internal/assert.h"
static_assert(( typedef int (*compare_f)(const void*, const void*);
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");
static int uint8_compare (const u8_t* s0, const u8_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 uint16_compare (const u16_t* s0, const u16_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 uint32_compare (const u32_t* s0, const u32_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 uint64_compare (const u64_t* s0, const u64_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 int8_compare (const s8_t* s0, const s8_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 int16_compare (const s16_t* s0, const s16_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 int32_compare (const s32_t* s0, const s32_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 int64_compare (const s64_t* s0, const s64_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 float_compare (const fl_t* s0, const fl_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 double_compare (const dbl_t* s0, const dbl_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 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_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*) = { static compare_f libcdsb_builtin_get_comparator(vtype t) {
(void*) uint8_compare, static void* comparators[17] = { libcdsb_builtin_compare_uint8, libcdsb_builtin_compare_uint16,
(void*) uint16_compare, libcdsb_builtin_compare_uint32, libcdsb_builtin_compare_uint64,
(void*) uint32_compare, libcdsb_builtin_compare_int8, libcdsb_builtin_compare_int16,
(void*) uint64_compare, libcdsb_builtin_compare_int32, libcdsb_builtin_compare_int64,
(void*) int8_compare, libcdsb_builtin_compare_float, libcdsb_builtin_compare_double,
(void*) int16_compare, libcdsb_builtin_compare_ldouble, string_compare, map_compare,
(void*) int32_compare, array_compare, list_compare, vset_compare, dict_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
};
/*#####################################################################################################################*/
ainline(int get_compare_index(vtype t)) {
if (t == VTYPE_POINTER) { if (t == VTYPE_POINTER) {
if (is_x64) t = VTYPE_UINT64; if (is_x64) t = VTYPE_UINT64;
else t = VTYPE_UINT32; else t = VTYPE_UINT32;
} else if (t == VTYPE_BOOLEAN) t = VTYPE_UINT8; } else if (t == VTYPE_BOOLEAN) t = VTYPE_UINT8;
return t - VTYPE_UINT8; return comparators[t - VTYPE_UINT8];
} }
/*#####################################################################################################################*/ /*#####################################################################################################################*/
void array_sort(arr_t* x) { void array_sort(arr_t* x) {
int i = get_compare_index(x->type);
if (x->size > 1) 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) { void array_reverse(arr_t* x) {

14
src/extra.c → src/cstring.c
View File

@ -4,21 +4,21 @@
#include "../modules/libunic/include.h" #include "../modules/libunic/include.h"
#include "__internal/include.h" #include "__internal/include.h"
static _Thread_local int CHAR_BUFFER_POS = 0; static _Thread_local int LIBCDSB_BUILTIN_COUNTER = 0;
static _Thread_local char CHAR_BUFFER[16][5]; static _Thread_local char LIBCDSB_BUILTIN_BUFFER[16][5];
const char* libcdsb_char_to_cstring(int c) { const char* libcdsb_char_to_cstring(int c) {
char* p; char* p;
if (CHAR_BUFFER_POS > 15) if (LIBCDSB_BUILTIN_COUNTER > 15)
CHAR_BUFFER_POS = 0; LIBCDSB_BUILTIN_COUNTER = 0;
if (is_null(p = tochar_unicode(CHAR_BUFFER[CHAR_BUFFER_POS], c))) { if (is_null(p = tochar_unicode(LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER], c))) {
CHAR_BUFFER[CHAR_BUFFER_POS][0] = 0; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0;
} else *p = 0; } else *p = 0;
return CHAR_BUFFER[CHAR_BUFFER_POS++]; return LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER++];
} }

10
src/dict/compute.c
View File

@ -3,16 +3,6 @@
#include "include.h" #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) { hash_t dict_hash(const dict_t* s) {
dnode_t *min, *max; dnode_t *min, *max;
size_t i; size_t i;

46
src/dict/copy.c
View File

@ -1,10 +1,10 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "../../include/list.h" #include "../list/include.h"
#include "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)); dnode_t* x = malloc(sizeof(*x));
x->prev = p; x->prev = p;
@ -31,7 +31,7 @@ dict_t dict_copy(const dict_t* s) {
n = s->nodes[i]; n = s->nodes[i];
while (!is_null(n)) { 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; n = n->prev;
} }
} }
@ -53,7 +53,7 @@ dict_t* dict_duplicate(const dict_t* s) {
n = s->nodes[i]; n = s->nodes[i];
while (!is_null(n)) { 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; n = n->prev;
} }
} }
@ -74,17 +74,17 @@ void dict_copy_init(dict_t* x, const dict_t* s) {
n = s->nodes[i]; n = s->nodes[i];
while (!is_null(n)) { 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; n = n->prev;
} }
} }
} }
vtype_list libcdsb_dict_copy_keys(const vtype_dict* s) { list_t libcdsb_dict_copy_keys(const dict_t* s) {
vtype_list x; list_t x;
dnode_t *c; dnode_t *c;
size_t i; size_t i;
i = s->capacity; i = s->capacity;
@ -94,7 +94,11 @@ vtype_list libcdsb_dict_copy_keys(const vtype_dict* s) {
c = s->nodes[i]; c = s->nodes[i];
while (!is_null(c)) { 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; 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) { list_t* libcdsb_dict_duplicate_keys(const dict_t* s) {
vtype_list* x; list_t* x;
dnode_t *c; dnode_t *c;
size_t i; size_t i;
x = malloc(sizeof(*x)); x = malloc(sizeof(*x));
i = s->capacity; i = s->capacity;
@ -117,7 +121,9 @@ vtype_list* libcdsb_dict_duplicate_keys(const vtype_dict* s) {
c = s->nodes[i]; c = s->nodes[i];
while (!is_null(c)) { 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; 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) { void libcdsb_dict_init_keys(list_t* x, const dict_t* s) {
dnode_t *c; dnode_t *c;
size_t i; size_t i;
x = malloc(sizeof(*x)); x = malloc(sizeof(*x));
i = s->capacity; i = s->capacity;
@ -139,7 +145,9 @@ void libcdsb_dict_init_keys(vtype_list* x, const vtype_dict* s) {
c = s->nodes[i]; c = s->nodes[i];
while (!is_null(c)) { 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; c = c->prev;
} }
} }

12
src/dict/modify.c
View File

@ -4,7 +4,7 @@
#include "../../include/list.h" #include "../../include/list.h"
#include "include.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; dnode_t **nodes, *c, *n, **p;
size_t i; size_t i;
@ -44,7 +44,7 @@ bool libcdsb_dict_shrink_to_fit(dict_t* s) {
if (capacity >= s->capacity) if (capacity >= s->capacity)
return false; return false;
dict_rehash(s, capacity); libcdsb_builtin_rehash(s, capacity);
return true; 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; dnode_t *c, **p;
if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) 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)); 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; dnode_t *c, **p;
if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) 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)); 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; dnode_t *c, **p;
if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) 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)); 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; dnode_t *c, **p;
if (!x->capacity || (double)x->size / x->capacity > REBUILD_POINT_MAX) 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)); c = *(p = x->nodes + (vtype_hash(k, kt) % x->capacity));

6
src/list/access.c
View File

@ -3,7 +3,7 @@
#include "include.h" #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); 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; 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; return i;
} }
@ -67,7 +67,7 @@ int libcdsb_list_find(vtype_list* x, const void* v, vtype t, void* _, list_acces
if (cmp == 0) { if (cmp == 0) {
i = (callback) ? callback(vnode_peek(&c->node, c->type), (r)?~i:i, c->type, _) : 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; return i;
} }

49
src/list/copy.c
View File

@ -3,33 +3,6 @@
#include "include.h" #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 list_copy(const list_t* s) {
list_t x; list_t x;
lnode_t* c; lnode_t* c;
@ -40,10 +13,10 @@ list_t list_copy(const list_t* s) {
if (is_null(c)) if (is_null(c))
return x; 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)) { 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; return x;
@ -60,10 +33,10 @@ list_t* list_duplicate(const list_t* s) {
if (is_null(c)) if (is_null(c))
return x; 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)) { 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; return x;
@ -79,10 +52,10 @@ void list_copy_init(list_t* x, const list_t* s) {
if (is_null(c)) if (is_null(c))
return; 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)) { 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; return;
if (is_null(x->first)) { 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; c = c->next;
if (is_null(c)) if (is_null(c))
@ -104,7 +77,7 @@ void list_extend(list_t* x, const list_t* s) {
} }
do { 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)); } 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; else r -= n;
if (!cut) { 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) { 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 { } else {
if (c->prev) { if (c->prev) {
c->prev->next = e->next; c->prev->next = e->next;

25
src/list/include.h
View File

@ -20,6 +20,31 @@ typedef struct libcdsb_list_node {
vtype type; vtype type;
} lnode_t; } 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_dir(cur, d) (&((cur)->prev))[(d)>>1]
#define ldir_inv(cur, d) (&((cur)->prev))[(d)&1] #define ldir_inv(cur, d) (&((cur)->prev))[(d)&1]

11
src/list/sort.c
View File

@ -3,9 +3,7 @@
#include "include.h" #include "include.h"
/*#####################################################################################################################*/ static inline void libcdsb_builtin_swap(lnode_t* s0, lnode_t* s1) {
static inline void lnode_swap(lnode_t* s0, lnode_t* s1) {
vnode_t v = s0->node; vnode_t v = s0->node;
vtype t = s0->type; vtype t = s0->type;
@ -16,6 +14,7 @@ static inline void lnode_swap(lnode_t* s0, lnode_t* s1) {
s1->type = t; s1->type = t;
} }
/*#####################################################################################################################*/
void list_sort(list_t* x) { void list_sort(list_t* x) {
stack_t z; stack_t z;
@ -37,12 +36,12 @@ void list_sort(list_t* x) {
for (lnode_t* c = l; c != r; c = c->next) { for (lnode_t* c = l; c != r; c = c->next) {
if (lnode_compare(c, r) <= 0) { if (lnode_compare(c, r) <= 0) {
p = (is_null(p)) ? l : p->next; p = (is_null(p)) ? l : p->next;
lnode_swap(p, c); libcdsb_builtin_swap(p, c);
} }
} }
p = (is_null(p)) ? l : p->next; p = (is_null(p)) ? l : p->next;
lnode_swap(p, r); libcdsb_builtin_swap(p, r);
stack_push(&z, r); stack_push(&z, r);
stack_push(&z, p->next); stack_push(&z, p->next);
@ -58,7 +57,7 @@ void list_reverse(list_t* x) {
lnode_t *r = x->last; lnode_t *r = x->last;
while (l != r) { while (l != r) {
lnode_swap(l, r); libcdsb_builtin_swap(l, r);
if ((r = r->prev) == l) if ((r = r->prev) == l)
break; break;
l = l->next; l = l->next;

100
src/map/access.c
View File

@ -3,6 +3,48 @@
#include "include.h" #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) { int libcdsb_map_find(map_t* x, const void* k, vtype t, void* _, map_access_callback callback, bool cut) {
mnode_t* c; mnode_t* c;
void *key; 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) { int libcdsb_map_foreach(map_t* x, void* data, map_access_callback callback, rbforeach_t type, bool flush) {
stack_t z; bool reverse;
int r; stack_t iter;
mnode_t* c; mnode_t* n;
int r = 0;
stack_init(&z); reverse = type&RBFOREACH_REVERSE;
stack_push(&z, x->root);
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)) default:
return 0; 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))) { while ((n = stack_pop(&iter))) {
if ((r = callback(vnode_peek(&c->key, x->type), x->type, vnode_peek(&c->value, c->type), c->type, dt))) if (!r) {
break; r = callback(vnode_peek(&n->key, x->type), x->type, vnode_peek(&n->value, n->type), n->type, data);
} else if (!flush) {
if (!mnode_is_empty(c->right)) stack_push(&z, c->right); stack_flush(&iter);
if (!mnode_is_empty(c->left)) stack_push(&z, c->left); return r;
}
if (flush) { if (flush) {
vnode_free(&c->key, x->type); vnode_free(&n->value, x->type);
vnode_free(&c->value, c->type); free(n);
free(c);
} }
} }
if (flush) { if (flush) x->root = mnode_empty;
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);
return r; return r;
} }

12
src/map/comparison.c
View File

@ -3,7 +3,7 @@
#include "include.h" #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); int c = vnode_compare_eq(&s0->key, &s1->key, t);
return !c ? vnode_compare(&s0->value, s0->type, &s1->value, s1->type) : c; 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); stack_flush(&z);
return mnode_is_empty(c0) ? -1 : 1; 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 if (c0->left == c1->right) { // == mnode_empty
cmp = mnode_compare(c0->right, c1, s0->type); cmp = libcdsb_builtin_compare(c0->right, c1, s0->type);
if (!cmp) cmp = mnode_compare(c0, c1->left, s0->type); if (!cmp) cmp = libcdsb_builtin_compare(c0, c1->left, s0->type);
} else if (c0->right == c1->left) { // == mnode_empty } else if (c0->right == c1->left) { // == mnode_empty
cmp = mnode_compare(c0, c1->right, s0->type); cmp = libcdsb_builtin_compare(c0, c1->right, s0->type);
if (!cmp) cmp = mnode_compare(c0->left, c1, s0->type); if (!cmp) cmp = libcdsb_builtin_compare(c0->left, c1, s0->type);
} }
if (cmp) { if (cmp) {

6
src/map/compute.c
View File

@ -3,7 +3,7 @@
#include "include.h" #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; 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))); } 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); stack_push(&z, s->root->right);
if (!mnode_is_empty(c0 = stack_pop(&z))) { 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))); } 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; return (hash ^ v) + VTYPE_MAP;
} }

20
src/map/copy.c
View File

@ -3,7 +3,7 @@
#include "include.h" #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; mnode_t* x;
x = mnode_create(vnode_duplicate(&s->key, t), p, s->colored); 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; x.type = s->type;
if (!mnode_is_empty(s->root)) { 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); stack_push(&z, x.root);
do { do {
@ -34,12 +34,12 @@ map_t map_copy(const map_t* s) {
mnode_t *p1 = stack_pop(&z); mnode_t *p1 = stack_pop(&z);
if (!mnode_is_empty(p1->left)) { 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); stack_push_many(&z, 2, p1->left, p0->left);
} }
if (!mnode_is_empty(p1->right)) { 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); 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; x->type = s->type;
if (!mnode_is_empty(s->root)) { 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); stack_push(&z, x->root);
do { do {
@ -71,12 +71,12 @@ map_t* map_duplicate(const map_t* s) {
mnode_t *p1 = stack_pop(&z); mnode_t *p1 = stack_pop(&z);
if (!mnode_is_empty(p1->left)) { 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); stack_push_many(&z, 2, p1->left, p0->left);
} }
if (!mnode_is_empty(p1->right)) { 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); 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; x->type = s->type;
if (!mnode_is_empty(s->root)) { 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); stack_push(&z, x->root);
do { do {
@ -106,12 +106,12 @@ void map_copy_init(map_t* x, const map_t* s) {
mnode_t *p1 = stack_pop(&z); mnode_t *p1 = stack_pop(&z);
if (!mnode_is_empty(p1->left)) { 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); stack_push_many(&z, 2, p1->left, p0->left);
} }
if (!mnode_is_empty(p1->right)) { 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); stack_push_many(&z, 2, p1->right, p0->right);
} }

13
src/map/include.h
View File

@ -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, root) == offsetof(struct libcdsb_map, root), "Implementation assert");
static_assert(offsetof(struct libcdsb_set, type) == offsetof(struct libcdsb_map, type), "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_empty ((mnode_t*)rbnode_empty)
#define mnode_create(k, p, c) ((mnode_t*)libcdsb_rbtree_node_create(k, (rbnode_t*)p, c, sizeof(mnode_t))) #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_rbtree_node_fixup((rbnode_t**)(r), (rbnode_t*)(n)) #define mnode_fixup(r, n) libcdsb_builtin_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_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_empty(n) ((n) == mnode_empty)
#define mnode_is_root(n) mnode_is_empty((n)->parent) #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 */ #endif /* LIBCDSB_SRC_MAP_INCLUDE_H */

0
src/extra-memory.c → src/memory.c
View File

196
src/rbtree.c
View File

@ -11,19 +11,12 @@ typedef enum libcdsb_rbtree_node_direction {
#define rbdir_dir(cur, d) (&((cur)->left))[(d)>>1] #define rbdir_dir(cur, d) (&((cur)->left))[(d)>>1]
#define rbdir_inv(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 void libcdsb_builtin_rotate(rbnode_t **x, rbnode_t *c, rbdir_t d) {
static inline void rotate(rbnode_t **x, rbnode_t *c, rbdir_t d) {
rbnode_t* n = rbdir_inv(c, d); rbnode_t* n = rbdir_inv(c, d);
rbdir_inv(c, d) = rbdir_dir(n, 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; 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 (!rbnode_is_root(c)) {
if (c->parent->left == c) { if (c->parent->left == c) {
c->parent->left = n; c->parent->left = n;
@ -51,10 +45,7 @@ static inline void replace(rbnode_t** x, rbnode_t* c, rbnode_t* n) {
} }
/*#####################################################################################################################*/ static void libcdsb_builtin_fixup(rbnode_t** x, rbnode_t* n) {
static void delete_fixup(rbnode_t** x, rbnode_t* n) {
rbdir_t d; rbdir_t d;
rbnode_t *s, *p; 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; rbnode_t *n, *t;
int s; int s;
@ -135,14 +134,14 @@ rbnode_t* libcdsb_rbtree_node_delete(rbnode_t** x, rbnode_t* c) {
t->left = c->left; t->left = c->left;
} }
if (!s) delete_fixup(x, n); if (!s) fixup(x, n);
return c; 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]; rbdir_t d[2];
rbnode_t *u, *p, *gp; 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; rbnode_t* x;
x = malloc(n); x = malloc(n);
@ -194,3 +193,160 @@ void* libcdsb_rbtree_node_create(void* v, rbnode_t* p, int c, int n) {
return x; 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;
}

101
src/set/access.c
View File

@ -4,6 +4,48 @@
#include "../../include/set.h" #include "../../include/set.h"
#include "../__internal/rbtree.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) { int libcdsb_vset_find(vtype_set* x, const void* v, vtype t, void* _, vset_access_callback callback, bool cut) {
rbnode_t* c; rbnode_t* c;
void *val; 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) { int libcdsb_vset_foreach(set_t* x, void* data, vset_access_callback callback, rbforeach_t type, bool flush) {
stack_t z; bool reverse;
int r; stack_t iter;
rbnode_t* c; rbnode_t* n;
int r = 0;
stack_init(&z); reverse = type&RBFOREACH_REVERSE;
stack_push(&z, x->root);
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)) while ((n = stack_pop(&iter))) {
return 0; if (!r) {
r = callback(vnode_peek(&n->value, x->type), x->type, data);
while ((c = stack_pop(&z))) { } else if (!flush) {
if ((r = callback(vnode_peek(&c->value, x->type), x->type, data))) stack_flush(&iter);
break; return r;
}
if (!rbnode_is_empty(c->right)) stack_push(&z, c->right);
if (!rbnode_is_empty(c->left)) stack_push(&z, c->left);
if (flush) { if (flush) {
vnode_free(&c->value, x->type); vnode_free(&n->value, x->type);
free(c); free(n);
} }
} }
if (flush) { if (flush) x->root = rbnode_empty;
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);
return r; return r;
} }

12
src/set/comparison.c
View File

@ -4,7 +4,7 @@
#include "../../include/set.h" #include "../../include/set.h"
#include "../__internal/rbtree.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); 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); stack_flush(&z);
return rbnode_is_empty(c0) ? -1 : 1; 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 if (c0->left == c1->right) { // == rbnode_empty
cmp = rbnode_compare(c0->right, c1, s0->type); cmp = libcdsb_builtin_compare(c0->right, c1, s0->type);
if (!cmp) cmp = rbnode_compare(c0, c1->left, s0->type); if (!cmp) cmp = libcdsb_builtin_compare(c0, c1->left, s0->type);
} else if (c0->right == c1->left) { // == rbnode_empty } else if (c0->right == c1->left) { // == rbnode_empty
cmp = rbnode_compare(c0, c1->right, s0->type); cmp = libcdsb_builtin_compare(c0, c1->right, s0->type);
if (!cmp) cmp = rbnode_compare(c0->left, c1, s0->type); if (!cmp) cmp = libcdsb_builtin_compare(c0->left, c1, s0->type);
} }
if (cmp) { if (cmp) {

6
src/set/compute.c
View File

@ -4,7 +4,7 @@
#include "../../include/set.h" #include "../../include/set.h"
#include "../__internal/rbtree.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); 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))); } 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); stack_push(&z, s->root->right);
if (!rbnode_is_empty(c0 = stack_pop(&z))) { 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))); } 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; return (hash ^ v) + VTYPE_SET;
} }

48
src/extra-stack.c → src/stack.c
View File

@ -27,6 +27,7 @@ void libcdsb_stack_push(stack_t* x, void* value) {
x->value = value; x->value = value;
} }
void libcdsb_stack_push_many(stack_t* x, size_t c, ...) { void libcdsb_stack_push_many(stack_t* x, size_t c, ...) {
va_list args; va_list args;
@ -52,6 +53,7 @@ void libcdsb_stack_push_many(stack_t* x, size_t c, ...) {
va_end(args); va_end(args);
} }
void* libcdsb_stack_pop(stack_t* x) { void* libcdsb_stack_pop(stack_t* x) {
stack_t* n; 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; stack_t* c;
while (stack->prev) { while (x->prev) {
c = stack->prev; c = x->prev;
stack->prev = c->prev; x->prev = c->prev;
free(c); free(c);
} }
stack->value = 0; x->value = 0;
} }

7
src/string/include.h
View File

@ -8,14 +8,14 @@
#ifndef LIBCDSB_SRC_STRING_INCLUDE_H #ifndef LIBCDSB_SRC_STRING_INCLUDE_H
#define 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); int cs = charsize(s);
if (cs) return s + cs; if (cs) return s + cs;
return ++s; return ++s;
} }
ainline(char* prev_char(char* s)) { ainline(char* libcdsb_builtin_prev_char(char* s)) {
if (*(--s)&0x80) { if (*(--s)&0x80) {
char* p = s; char* p = s;
@ -29,4 +29,7 @@ ainline(char* prev_char(char* s)) {
return s; return s;
} }
#define next_char libcdsb_builtin_next_char
#define prev_char libcdsb_builtin_prev_char
#endif /* LIBCDSB_SRC_STRING_INCLUDE_H */ #endif /* LIBCDSB_SRC_STRING_INCLUDE_H */

10
src/string/transform.c
View File

@ -3,7 +3,7 @@
#include "include.h" #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) { if (n != vn) {
size_t l = strlen(x->buffer); size_t l = strlen(x->buffer);
@ -75,7 +75,7 @@ size_t string_to_lower(str_t* x) {
es = tochar_unicode(ps, uc1); es = tochar_unicode(ps, uc1);
if (!is_null(es)) { 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; ++n;
} }
} }
@ -111,7 +111,7 @@ size_t string_to_upper(str_t* x) {
es = tochar_unicode(ps, uc1); es = tochar_unicode(ps, uc1);
if (!is_null(es)) { 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; ++n;
} }
} }
@ -145,7 +145,7 @@ size_t string_capitalize(str_t* x) {
es = tochar_unicode(ps, uc1); es = tochar_unicode(ps, uc1);
if (!is_null(es)) { 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; ++n;
} }
} }
@ -163,7 +163,7 @@ size_t string_capitalize(str_t* x) {
es = tochar_unicode(ps, uc1); es = tochar_unicode(ps, uc1);
if (!is_null(es)) { 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; ++n;
} }
} }

33
src/vtype-extra.c → src/stringify.c
View File

@ -4,8 +4,6 @@
#include <stdio.h> #include <stdio.h>
#include "__internal/include.h" #include "__internal/include.h"
/*#####################################################################################################################*/
#define sh__(a) #a #define sh__(a) #a
#define s__(a) sh__(a) #define s__(a) sh__(a)
@ -19,14 +17,14 @@
double: "%."s__(DBL_DIG)"lg",\ double: "%."s__(DBL_DIG)"lg",\
long double: "%."s__(LDBL_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 int LIBCDSB_BUILTIN_COUNTER = 0;
static _Thread_local char STRINGIFY_BUFFER[16][64]; 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(void*), sizeof(bool),
sizeof(u8_t), sizeof(u16_t), sizeof(u32_t), sizeof(u64_t), 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(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) sizeof(list_t), sizeof(set_t), sizeof(dict_t)
}; };
/*#####################################################################################################################*/
const char* libcdsb_vtype_name(vtype t) { const char* libcdsb_vtype_name(vtype t) {
switch (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_BOOLEAN) return (*(vtype_bool*)v) ? "true" : "false";
if (t == VTYPE_STRING) return *(char**)v; if (t == VTYPE_STRING) return *(char**)v;
if (STRINGIFY_BUFFER_POS > 15) if (LIBCDSB_BUILTIN_COUNTER > 15)
STRINGIFY_BUFFER_POS = 0; LIBCDSB_BUILTIN_COUNTER = 0;
switch (t) { switch (t) {
case VTYPE_INT8: stringify(*( s8_t*)v); break; 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_UINT32: stringify(*( u32_t*)v); break;
case VTYPE_UINT64: stringify(*( u64_t*)v); break; case VTYPE_UINT64: stringify(*( u64_t*)v); break;
case VTYPE_FLOAT: if (abs(*(fl_t*)v) <= FLT_EPSILON) { case VTYPE_FLOAT: if (abs(*(fl_t*)v) <= FLT_EPSILON) {
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30;
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00;
} else stringify(*(fl_t*)v); } else stringify(*(fl_t*)v);
break; break;
case VTYPE_DOUBLE: if (abs(*(dbl_t*)v) <= DBL_EPSILON) { case VTYPE_DOUBLE: if (abs(*(dbl_t*)v) <= DBL_EPSILON) {
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30;
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00;
} else stringify(*(dbl_t*)v); } else stringify(*(dbl_t*)v);
break; break;
case VTYPE_LDOUBLE: if (abs(*(ldbl_t*)v) <= LDBL_EPSILON) { case VTYPE_LDOUBLE: if (abs(*(ldbl_t*)v) <= LDBL_EPSILON) {
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][0] = 0x30; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][0] = 0x30;
STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS][1] = 0x00; LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER][1] = 0x00;
} else stringify(*(ldbl_t*)v); } else stringify(*(ldbl_t*)v);
break; 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; break;
} }
return STRINGIFY_BUFFER[STRINGIFY_BUFFER_POS++]; return LIBCDSB_BUILTIN_BUFFER[LIBCDSB_BUILTIN_COUNTER++];
} }

34
src/vnode.c
View File

@ -5,7 +5,7 @@
#include "__internal/vnode.h" #include "__internal/vnode.h"
#include "../include/string.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) { if (v > 0) {
*x = (u64_t)(v + 0.5); *x = (u64_t)(v + 0.5);
return VTYPE_UINT64; return VTYPE_UINT64;
@ -15,18 +15,16 @@ static vtype internal_round(u64_t* x, ldbl_t v) {
} }
} }
/*#####################################################################################################################*/
static vnode_t libcdsb_builtin_create_value(vtype xt, const void* v, vtype t) {
static vnode_t create_value(vtype xt, const void* v, vtype t) {
var_t _; var_t _;
if (t == VTYPE_FLOAT) { if (t == VTYPE_FLOAT) {
t = internal_round(&_.u64, *(fl_t*)v); t = libcdsb_builtin_round(&_.u64, *(fl_t*)v);
} else if (t == VTYPE_DOUBLE) { } 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) { } else if (t == VTYPE_LDOUBLE) {
t = internal_round(&_.u64, *(ldbl_t*)v); t = libcdsb_builtin_round(&_.u64, *(ldbl_t*)v);
} }
if (sizeof(void*) == 8) { 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 _; var_t _;
if (t == VTYPE_UINT8 || t == VTYPE_BOOLEAN ) { 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; return _.ptr;
} }
/*#####################################################################################################################*/ /*#####################################################################################################################*/
vnode_t libcdsb_builtin_vnode_create(const void* v, vtype t) {
vnode_t libcdsb_vnode_create(const void* v, vtype t) {
var_t _ = { .ptr = 0 }; var_t _ = { .ptr = 0 };
switch (t) { default: abort(); switch (t) { default: abort();
@ -198,10 +194,7 @@ vnode_t libcdsb_vnode_create(const void* v, vtype t) {
} }
/*#####################################################################################################################*/ void* libcdsb_builtin_vnode_peek(const vnode_t* x, vtype t) {
void* libcdsb_vnode_peek(const vnode_t* x, vtype t) {
switch (t) { default: abort(); switch (t) { default: abort();
case VTYPE_FLOAT: if (is_permissible(fl_t)) goto vt_; else goto pt_; 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(); switch (t) { default: abort();
@ -271,18 +264,15 @@ void libcdsb_vnode_free(vnode_t* x, vtype t) {
} }
/*#####################################################################################################################*/ vnode_t libcdsb_builtin_vnode_create_target(vtype xt, const void* v, vtype t) {
vnode_t libcdsb_vnode_create_target(vtype xt, const void* v, vtype t) {
var_t _ = { .ptr = 0 }; var_t _ = { .ptr = 0 };
if (xt <= VTYPE_LDOUBLE) { if (xt <= VTYPE_LDOUBLE) {
if (t >= VTYPE_STRING) t = VTYPE_POINTER; if (t >= VTYPE_STRING) t = VTYPE_POINTER;
if (xt <= VTYPE_INT64) if (xt <= VTYPE_INT64)
return create_value(xt, v, t); return libcdsb_builtin_create_value(xt, v, t);
return create_float(xt, v, t); return libcdsb_builtin_create_float(xt, v, t);
} else if (t == VTYPE_POINTER && (t = xt) > VTYPE_STRING) { } else if (t == VTYPE_POINTER && (t = xt) > VTYPE_STRING) {
v = *(void**)v; v = *(void**)v;
} }

22
src/vtype.c
View File

@ -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) { if (t == VTYPE_BOOLEAN || t == VTYPE_UINT8) {
return *(u8_t*)v; return *(u8_t*)v;
} else if (t == VTYPE_UINT16) { } 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; } 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; hash_t hash;
if (sizeof(hash_t) == sizeof(u64_t)) { 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) { int libcdsb_builtin_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); if (t0 == t1) return libcdsb_builtin_vtype_compare_values_eq(s0, s1, t0);
if (t0 <= VTYPE_LDOUBLE && t1 <= VTYPE_LDOUBLE) { if (t0 <= VTYPE_LDOUBLE && t1 <= VTYPE_LDOUBLE) {
ldbl_t d0, d1; ldbl_t d0, d1;
d0 = normalize_value(s0, t0); d0 = libcdsb_builtin_normalize(s0, t0);
d1 = normalize_value(s1, t1); d1 = libcdsb_builtin_normalize(s1, t1);
return (abs(d0 - d1) <= LDBL_EPSILON) ? 0 : (d0 < d1 ? -1 : 1); 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) #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(); 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_SET: return vset_hash(v);
case VTYPE_DICT: return dict_hash(v); case VTYPE_DICT: return dict_hash(v);
case VTYPE_FLOAT: return ldouble_hash(*(fl_t*)v); case VTYPE_FLOAT: return libcdsb_builtin_hash_float(*(fl_t*)v);
case VTYPE_DOUBLE: return ldouble_hash(*(dbl_t*)v); case VTYPE_DOUBLE: return libcdsb_builtin_hash_float(*(dbl_t*)v);
case VTYPE_LDOUBLE: return ldouble_hash(*(ldbl_t*)v); case VTYPE_LDOUBLE: return libcdsb_builtin_hash_float(*(ldbl_t*)v);
} }
} }

6
tests/Makefile
View File

@ -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/ $(BUILD_PATH)/obj/%.o: ./src/%.c | $(BUILD_PATH)/obj/
$(CC) $^ -o $@ $(CFLAGS) $(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)/ $(BUILD_PATH)/array-%: ./src/array/%.c $(OBJECTS_ARRAY) | $(BUILD_PATH)/
$(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall
$(BUILD_PATH)/string-%: ./src/string/%.c $(OBJECTS_STRING) | $(BUILD_PATH)/ $(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)/ $(BUILD_PATH)/list-%: ./src/list/%.c $(OBJECTS_LIST) | $(BUILD_PATH)/
$(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall
$(BUILD_PATH)/map-%: ./src/map/%.c $(OBJECTS_MAP) | $(BUILD_PATH)/ $(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)/ $(BUILD_PATH)/dict-%: ./src/dict/%.c $(OBJECTS_DICT) | $(BUILD_PATH)/
$(CC) $^ -o $@ $(CFLAGS) -g3 -Wall $(CC) $^ -o $@ $(CFLAGS) -g3 -Wall
$(BUILD_PATH)/global-%: ./src/global/%.c $(OBJECTS_GLOBAL) | $(BUILD_PATH)/ $(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
######################################################################################################################## ########################################################################################################################

2
tests/src/array/plug.h
View File

@ -2,7 +2,7 @@
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include <string.h> #include <string.h>
#include "../../../include/extra/vtype.h" #include "../../../include/vtype.h"
#include "../../../include/array.h" #include "../../../include/array.h"
#include "../../include/random.h" #include "../../include/random.h"

5
tests/src/array/src/plug.c
View File

@ -2,16 +2,14 @@
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include <string.h> #include <string.h>
#include "../../../../include/extra/vtype.h" #include "../../../../include/vtype.h"
#include "../../../include/random.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_list* list_duplicate (const vtype_list* x) { return 0; }
vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; }
vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; }
vtype_dict* dict_duplicate (const vtype_dict* 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 list_free (vtype_list* x) {}
void map_free (vtype_map* x) {} void map_free (vtype_map* x) {}
void vset_free (vtype_set* 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 vset_hash (const vtype_set* s) { return 0; }
hash_t dict_hash (const vtype_dict* 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 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 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)); } void vset_copy_init (vtype_set* x, const vtype_set* s) { memset(x, 0, sizeof(*x)); }

2
tests/src/array/src/random.c
View File

@ -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); 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 { } else {
ssize_t i = array_size(x); ssize_t i = array_size(x);

2
tests/src/dict/src/plug.c
View File

@ -4,13 +4,11 @@
#include "../../../../src/__internal/include.h" #include "../../../../src/__internal/include.h"
#include "../../../include/random.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_array* array_duplicate (const vtype_array* x) { return 0; }
vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; }
vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; }
vtype_set* vset_duplicate (const vtype_set* 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 array_free (vtype_array* x) {}
void list_free (vtype_list* x) {} void list_free (vtype_list* x) {}
void map_free (vtype_map* x) {} void map_free (vtype_map* x) {}

2
tests/src/global/plug.h
View File

@ -1,7 +1,7 @@
/* This software is licensed by the MIT License, see LICENSE file */ /* This software is licensed by the MIT License, see LICENSE file */
/* Copyright © 2022 Gregory Lirent */ /* Copyright © 2022 Gregory Lirent */
#include "../../../include/extra/string.h" #include "../../../include/string.h"
#include "../../../include/array.h" #include "../../../include/array.h"
#include "../../../include/list.h" #include "../../../include/list.h"
#include "../../../include/set.h" #include "../../../include/set.h"

102
tests/src/global/src/random.c
View File

@ -80,30 +80,34 @@ static arr_t random_array(bool embd) {
size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100);
value_t v = (!embd) ? random_value2() : real_random_value(1); 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); array_init(&x, v.type);
while(n--) { 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); 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; return x;
} }
@ -113,30 +117,35 @@ static set_t random_set(bool embd) {
size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100);
value_t v = (!embd) ? random_value2() : real_random_value(1); 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); vset_init(&x, v.type);
while(n--) { while(n--) {
libcdsb_vset_insert(&x, v.value, v.type); 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); 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; return x;
} }
@ -149,7 +158,7 @@ static list_t random_list(bool embd) {
while(n--) { while(n--) {
v = (!embd) ? random_value2() : real_random_value(1); 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) { switch (v.type) {
default: break; default: break;
@ -170,18 +179,6 @@ static map_t random_map(bool embd) {
size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100); size_t n = random_uint16()%((!embd)?MAX_ELEMENTS:100);
value_t k = (!embd) ? random_value2() : real_random_value(1); 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); map_init(&x, k.type);
while(n--) { 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); 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) { switch (v.type) {
default: break; default: break;
@ -204,7 +209,16 @@ static map_t random_map(bool embd) {
k = random_value_by_type(k.type, 1); 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; return x;
} }

2
tests/src/list/src/plug.c
View File

@ -4,13 +4,11 @@
#include "../../../../src/__internal/include.h" #include "../../../../src/__internal/include.h"
#include "../../../include/random.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_array* array_duplicate (const vtype_array* x) { return 0; }
vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; }
vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; }
vtype_dict* dict_duplicate (const vtype_dict* 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 array_free (vtype_array* x) {}
void map_free (vtype_map* x) {} void map_free (vtype_map* x) {}
void vset_free (vtype_set* x) {} void vset_free (vtype_set* x) {}

6
tests/src/list/src/random.c
View File

@ -26,12 +26,12 @@ void list_push_random(list_t* x, _Bool silent, unsigned int hpos) {
if (!silent) { if (!silent) {
printf("\e[%dG\e[36mTry to push value to back of the list:\e[m\n", hpos+1); 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()) { } else if (random_boolean()) {
if (!silent) { if (!silent) {
printf("\e[%dG\e[36mTry to push value to front of the list:\e[m\n", hpos+1); 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 { } else {
ssize_t i = list_size(x); ssize_t i = list_size(x);
i = random_uint64()% (i ? i : 1); 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); 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) { if (!silent) {

2
tests/src/map/src/plug.c
View File

@ -4,13 +4,11 @@
#include "../../../../src/__internal/include.h" #include "../../../../src/__internal/include.h"
#include "../../../include/random.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_array* array_duplicate (const vtype_array* x) { return 0; }
vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; }
vtype_set* vset_duplicate (const vtype_set* x) { return 0; } vtype_set* vset_duplicate (const vtype_set* x) { return 0; }
vtype_dict* dict_duplicate (const vtype_dict* 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 array_free (vtype_array* x) {}
void list_free (vtype_list* x) {} void list_free (vtype_list* x) {}
void vset_free (vtype_set* x) {} void vset_free (vtype_set* x) {}

2
tests/src/set/src/plug.c
View File

@ -4,13 +4,11 @@
#include "../../../../src/__internal/include.h" #include "../../../../src/__internal/include.h"
#include "../../../include/random.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_array* array_duplicate (const vtype_array* x) { return 0; }
vtype_list* list_duplicate (const vtype_list* x) { return 0; } vtype_list* list_duplicate (const vtype_list* x) { return 0; }
vtype_map* map_duplicate (const vtype_map* x) { return 0; } vtype_map* map_duplicate (const vtype_map* x) { return 0; }
vtype_dict* dict_duplicate (const vtype_dict* 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 array_free (vtype_array* x) {}
void list_free (vtype_list* x) {} void list_free (vtype_list* x) {}
void map_free (vtype_map* x) {} void map_free (vtype_map* x) {}