From 23ec0fe83e8efbc3a758af4049ce990ee67ea47c Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Mon, 22 Feb 2021 14:23:00 +0100 Subject: Many internal renames. Reverted to specify both _del and _clone parameter when giving _del. --- docs/carray_api.md | 2 +- docs/cdeq_api.md | 6 +++--- docs/clist_api.md | 6 +++--- docs/cmap_api.md | 32 +++++++++++++++----------------- docs/cptr_api.md | 37 +++++++++++++++++++------------------ docs/cset_api.md | 9 +++------ docs/csmap_api.md | 23 ++++++++++------------- docs/csset_api.md | 7 ++----- docs/cvec_api.md | 6 +++--- examples/complex.c | 8 ++++---- examples/csmap_v1.h | 20 ++++++++++---------- examples/inits.c | 2 +- examples/mapmap.c | 2 +- stc/carray.h | 17 +++++++---------- stc/ccommon.h | 13 ++++++------- stc/cdeq.h | 24 ++++++++++++------------ stc/clist.h | 16 ++++++++-------- stc/cmap.h | 42 +++++++++++++++++++++--------------------- stc/cptr.h | 14 +++++++------- stc/csmap.h | 36 ++++++++++++++++++------------------ stc/cvec.h | 22 +++++++++++----------- 21 files changed, 165 insertions(+), 179 deletions(-) diff --git a/docs/carray_api.md b/docs/carray_api.md index e3d35083..90fc3815 100644 --- a/docs/carray_api.md +++ b/docs/carray_api.md @@ -10,7 +10,7 @@ See the c++ class [boost::multi_array](https://www.boost.org/doc/libs/release/li ```c using_carray(X, Value); -using_carray(X, Value, valueDestroy); +using_carray(X, Value, valueDel, valueClone); ``` The macro `using_carray()` must be instantiated in the global scope. `X` and `N` are type tags and will affect the names of all cset types and methods. E.g. declaring `using_carray(my, int);`, `X` should diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md index fd42d295..10a9cd74 100644 --- a/docs/cdeq_api.md +++ b/docs/cdeq_api.md @@ -9,9 +9,9 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque ```c using_cdeq(X, Value); -using_cdeq(X, Value, valueCompareRaw); -using_cdeq(X, Value, valueCompareRaw, valueDestroy); -using_cdeq(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue); +using_cdeq(X, Value, valueCompare); +using_cdeq(X, Value, valueCompare, valueDel, valueClone); +using_cdeq(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue); using_cdeq_str(); ``` diff --git a/docs/clist_api.md b/docs/clist_api.md index f6772aa0..5a8cea31 100644 --- a/docs/clist_api.md +++ b/docs/clist_api.md @@ -18,9 +18,9 @@ See the c++ class [std::forward_list](https://en.cppreference.com/w/cpp/containe ```c using_clist(X, Value); -using_clist(X, Value, valueCompareRaw); -using_clist(X, Value, valueCompareRaw, valueDestroy); -using_clist(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue); +using_clist(X, Value, valueCompare); +using_clist(X, Value, valueCompare, valueDel, valueClone); +using_clist(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue); using_clist_str() ``` diff --git a/docs/cmap_api.md b/docs/cmap_api.md index 614e48c4..11397371 100644 --- a/docs/cmap_api.md +++ b/docs/cmap_api.md @@ -11,21 +11,21 @@ See the c++ class [std::unordered_map](https://en.cppreference.com/w/cpp/contain ```c using_cmap(X, Key, Mapped); using_cmap(X, Key, Mapped, keyEquals, keyHash); -using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDestroy); -using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped); -using_cmap(X, Key, Mapped, keyEqualsRaw, keyHashRaw, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped, - keyDestroy, keyFromRaw, keyToRaw, RawKey); -using_cmap_keydef(X, Key, Mapped, keyEquals, keyHash, keyDestroy); -using_cmap_keydef(X, Key, Mapped, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedClone); +using_cmap(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedFromRaw, mappedToRaw, RawMapped); +using_cmap(X, Key, Mapped, keyEqualsRaw, keyHashRaw, mappedDel, mappedFromRaw, mappedToRaw, RawMapped, + keyDel, keyFromRaw, keyToRaw, RawKey); +using_cmap_keydef(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone); +using_cmap_keydef(X, Key, Mapped, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_cmap_strkey(X, Mapped); // using_cmap(X, cstr, Mapped, ...) -using_cmap_strkey(X, Mapped, mappedDestroy); -using_cmap_strkey(X, Mapped, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped); +using_cmap_strkey(X, Mapped, mappedDel, mappedClone); +using_cmap_strkey(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped); using_cmap_strval(X, Key); // using_cmap(X, Key, cstr, ...) using_cmap_strval(X, Key, keyEquals, keyHash); -using_cmap_strval(X, Key, keyEquals, keyHash, keyDestroy); -using_cmap_strval(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_cmap_strval(X, Key, keyEquals, keyHash, keyDel, keyClone); +using_cmap_strval(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_cmap_str() // using_cmap(str, cstr, cstr, ...) ``` @@ -77,18 +77,16 @@ cmap_X_iter_t cmap_X_begin(cmap_X* self); cmap_X_iter_t cmap_X_end(cmap_X* self); void cmap_X_next(cmap_X_iter_t* it); cmap_X_mapped_t* cmap_X_itval(cmap_X_iter_t it); - -cmap_X_value_t cmap_X_value_clone(cmap_X_value_t val); -void cmap_X_value_del(cmap_X_value_t* val); ``` ``` uint64_t c_default_hash(const void *data, size_t len); uint64_t c_default_hash32(const void* data, size_t len=4); uint64_t c_default_hash64(const void* data, size_t len=8); int c_default_equals(const RawKey* a, const RawKey* b); -void c_default_destruct(Value* val); -Value c_default_fromraw(RawValue raw); -RawValue c_default_toraw(Value* val); +void c_plain_del(Type* val); +Value c_no_clone(Type val); +Value c_plain_fromraw(RawType raw); +RawType c_plain_toraw(Type* val); ``` ## Types @@ -200,7 +198,7 @@ Demonstrate cmap with plain-old-data key type Vec3i and int as mapped type: cmap typedef struct { int x, y, z; } Vec3i; -using_cmap(v3, Vec3i, int, c_memcmp_equals, // compare Vec3i bitwise +using_cmap(v3, Vec3i, int, c_plain_equals, // compare Vec3i bitwise c_default_hash); // hash Vec3i bitwise. int main() diff --git a/docs/cptr_api.md b/docs/cptr_api.md index b924b55c..23cb4d41 100644 --- a/docs/cptr_api.md +++ b/docs/cptr_api.md @@ -11,11 +11,11 @@ The pointed-to elements are automatically destructed and deleted when the contai ```c using_cptr(X, Value); using_cptr(X, Value, valueCompare); -using_cptr(X, Value, valueCompare, valueDestroy); +using_cptr(X, Value, valueCompare, valueDel); using_csptr(X, Value); using_csptr(X, Value, valueCompare); -using_csptr(X, Value, valueCompare, valueDestroy); +using_csptr(X, Value, valueCompare, valueDel); ``` The macro `using_cptr()` must be instantiated in the global scope. `X` is a type tag name and will affect the names of all cptr types and methods. E.g. declaring `using_cptr(my, cvec_my);`, @@ -166,16 +166,15 @@ void Person_del(Person* p) { } // 1. cvec of Person struct; emplace and cloning disabled. -using_cvec(pe, Person, Person_compare, Person_del); +using_cvec(pe, Person, Person_compare, Person_del, c_no_clone); // 2. cvec of raw/owned pointers to Person; emplace and cloning disabled. using_cptr(pe, Person, Person_compare, Person_del); -using_cvec(pp, Person*, cptr_pe_compare, cptr_pe_del); +using_cvec(pp, Person*, cptr_pe_compare, cptr_pe_del, c_no_clone); -// 3. cvec of shared-ptr to Person. +// 3. cvec of shared-ptr to Person - with emplace_back() and cloning cvec ENABLED. using_csptr(pe, Person, Person_compare, Person_del); -// To enable emplace_back() and cloning cvec, add 3 more args: -using_cvec(ps, csptr_pe, csptr_pe_compare, csptr_pe_del, csptr_pe_clone, c_default_toraw, csptr_pe); +using_cvec(ps, csptr_pe, csptr_pe_compare, csptr_pe_del, csptr_pe_clone); const char* names[] = { "Joe", "Jordan", @@ -206,6 +205,7 @@ int main() { // Append a shared copy of vec3.data[0]. Will only be destructed once! cvec_ps_emplace_back(&vec3, vec3.data[0]); + //cvec_ps_push_back(&vec3, csptr_pe_clone(vec3.data[0])); // alternativ puts("\n3. Sorted vec3 of shared-pointer to Person:"); cvec_ps_sort(&vec3); c_foreach (i, cvec_ps, vec3) @@ -214,12 +214,12 @@ int main() { // Share vec3.data[1] with elem1 variable. csptr_pe elem1 = csptr_pe_clone(vec3.data[1]); - puts("\nDestroy vec3:"); - cvec_ps_del(&vec3); // destroy the unique/unshared elements (two) - puts("\nDestroy vec2:"); - cvec_pp_del(&vec2); puts("\nDestroy vec1:"); cvec_pe_del(&vec1); + puts("\nDestroy vec2:"); + cvec_pp_del(&vec2); + puts("\nDestroy vec3:"); + cvec_ps_del(&vec3); puts("\nDestroy elem1:"); csptr_pe_del(&elem1); @@ -227,23 +227,25 @@ int main() { ``` Output: ``` -1. sorted cvec of Person : +1. Sorted vec1 of Person: Annie Aniston Jane Jacobs Joe Jordan -2. sorted cvec of pointer to Person : +2. Sorted vec2 of pointer to Person: Annie Aniston Jane Jacobs Joe Jordan -3. sorted cvec of shared-pointer to Person : +3. Sorted vec3 of shared-pointer to Person: Annie Aniston Jane Jacobs Joe Jordan + Joe Jordan -Destroy vec3: +Destroy vec1: del: Annie +del: Jane del: Joe Destroy vec2: @@ -251,11 +253,10 @@ del: Annie del: Jane del: Joe -Destroy vec1: +Destroy vec3: del: Annie -del: Jane del: Joe -Destroy elem: +Destroy elem1: del: Jane ``` diff --git a/docs/cset_api.md b/docs/cset_api.md index 526a93d7..45df2afb 100644 --- a/docs/cset_api.md +++ b/docs/cset_api.md @@ -8,9 +8,9 @@ A **cset** is an associative container that contains a set of unique objects of ```c using_cset(X, Key); -using_cset(X, Key, keyEqualsRaw, keyHashRaw); -using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy); -using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_cset(X, Key, keyEquals, keyHash); +using_cset(X, Key, keyEquals, keyHash, keyDel, keyClone); +using_cset(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_cset_str(); ``` The macro `using_cset()` must be instantiated in the global scope. `X` is a type tag name and @@ -59,9 +59,6 @@ cset_X_iter_t cset_X_begin(cset_X* self); cset_X_iter_t cset_X_end(cset_X* self); void cset_X_next(cset_X_iter_t* it); cset_X_value_t* cset_X_itval(cset_X_iter_t it); - -cset_X_value_t cset_X_value_clone(cset_X_value_t val); -void cset_X_value_del(cset_X_value_t* val); ``` ## Types diff --git a/docs/csmap_api.md b/docs/csmap_api.md index d404aa79..96087706 100644 --- a/docs/csmap_api.md +++ b/docs/csmap_api.md @@ -10,21 +10,21 @@ See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) fo ```c using_csmap(X, Key, Mapped); using_csmap(X, Key, Mapped, keyCompare); -using_csmap(X, Key, Mapped, keyCompare, mappedDestroy); -using_csmap(X, Key, Mapped, keyCompare, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped); -using_csmap(X, Key, Mapped, keyCompareRaw, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped, - keyDestroy, keyFromRaw, keyToRaw, RawKey); -using_csmap_keydef(X, Key, Mapped, keyCompare, keyDestroy); -using_csmap_keydef(X, Key, Mapped, keyCompareRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_csmap(X, Key, Mapped, keyCompare, mappedDel, mappedClone); +using_csmap(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped); +using_csmap(X, Key, Mapped, keyCompareRaw, mappedDel, mappedFromRaw, mappedToRaw, RawMapped, + keyDel, keyFromRaw, keyToRaw, RawKey); +using_csmap_keydef(X, Key, Mapped, keyCompare, keyDel, keyClone); +using_csmap_keydef(X, Key, Mapped, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_csmap_strkey(X, Mapped); // using_csmap(X, cstr, Mapped, ...) -using_csmap_strkey(X, Mapped, mappedDestroy); -using_csmap_strkey(X, Mapped, mappedDestroy, mappedFromRaw, mappedToRaw, RawMapped); +using_csmap_strkey(X, Mapped, mappedDel, mappedClone); +using_csmap_strkey(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped); using_csmap_strval(X, Key); // using_csmap(X, Key, cstr, ...) using_csmap_strval(X, Key, keyCompare); -using_csmap_strval(X, Key, keyCompare, keyDestroy); -using_csmap_strval(X, Key, keyCompareRaw, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_csmap_strval(X, Key, keyCompare, keyDel, keyClone); +using_csmap_strval(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_csmap_str(); // using_csmap(str, cstr, cstr, ...) ``` @@ -70,9 +70,6 @@ csmap_X_iter_t csmap_X_begin(csmap_X* self); csmap_X_iter_t csmap_X_end(csmap_X* self); void csmap_X_next(csmap_X_iter_t* it); csmap_X_mapped_t* csmap_X_itval(csmap_X_iter_t it); - -csmap_X_value_t csmap_X_value_clone(csmap_X_value_t val); -void csmap_X_value_del(csmap_X_value_t* val); ``` ## Types diff --git a/docs/csset_api.md b/docs/csset_api.md index 7a0085f5..96f7357a 100644 --- a/docs/csset_api.md +++ b/docs/csset_api.md @@ -10,8 +10,8 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo ```c using_csset(X, Key); using_csset(X, Key, keyCompare); -using_csset(X, Key, keyCompare, keyDestroy); -using_csset(X, Key, keyCompare, keyDestroy, keyFromRaw, keyToRaw, RawKey); +using_csset(X, Key, keyCompare, keyDel, keyClone); +using_csset(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey); using_csset_str(); ``` The macro `using_csset()` must be instantiated in the global scope. `X` is a type tag name and @@ -54,9 +54,6 @@ csset_X_iter_t csset_X_begin(csset_X* self); csset_X_iter_t csset_X_end(csset_X* self); void csset_X_next(csset_X_iter_t* it); csset_X_value_t* csset_X_itval(csset_X_iter_t it); - -csset_X_value_t csset_X_value_clone(csset_X_value_t val); -void csset_X_value_del(csset_X_value_t* val); ``` ## Types diff --git a/docs/cvec_api.md b/docs/cvec_api.md index b6aa841f..d3ac1e10 100644 --- a/docs/cvec_api.md +++ b/docs/cvec_api.md @@ -13,9 +13,9 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect ```c using_cvec(X, Value); -using_cvec(X, Value, valueCompareRaw); -using_cvec(X, Value, valueCompareRaw, valueDestroy); -using_cvec(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue); +using_cvec(X, Value, valueCompare); +using_cvec(X, Value, valueCompare, valueDel, valueClone); +using_cvec(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue); using_cvec_str() ``` diff --git a/examples/complex.c b/examples/complex.c index 05d74557..161d0b31 100644 --- a/examples/complex.c +++ b/examples/complex.c @@ -5,10 +5,10 @@ void check_del(float* v) {printf("destroy %g\n", *v);} -using_carray(f, float, check_del); -using_clist(a, carray2f, c_no_compare, carray2f_del); -using_cmap(l, int, clist_a, c_default_equals, c_default_hash, clist_a_del); -using_cmap_strkey(s, cmap_l, cmap_l_del); +using_carray(f, float, check_del, c_plain_fromraw); +using_clist(a, carray2f, c_no_compare, carray2f_del, c_no_clone); +using_cmap(l, int, clist_a, c_default_equals, c_default_hash, clist_a_del, c_no_clone); +using_cmap_strkey(s, cmap_l, cmap_l_del, c_no_clone); int main() { int xdim = 4, ydim = 6; diff --git a/examples/csmap_v1.h b/examples/csmap_v1.h index 11602f83..78e40431 100644 --- a/examples/csmap_v1.h +++ b/examples/csmap_v1.h @@ -50,19 +50,19 @@ int main(void) { using_csmap_4(X, Key, Mapped, c_default_compare) #define using_csmap_4(X, Key, Mapped, keyCompare) \ - using_csmap_6(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw) + using_csmap_6(X, Key, Mapped, keyCompare, c_plain_del, c_plain_fromraw) #define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \ - using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_default_del, c_default_fromraw) + using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_plain_del, c_plain_fromraw) #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, keyDel, keyClone) \ using_csmap_10(X, Key, Mapped, keyCompare, mappedDel, mappedClone, \ - keyDel, keyClone, c_default_toraw, Key) + keyDel, keyClone, c_plain_toraw, Key) #define using_csmap_10(X, Key, Mapped, keyCompareRaw, mappedDel, mappedClone, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CBST(X, csmap, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \ - keyFromRaw, keyToRaw, RawKey, mappedClone, c_default_toraw, Mapped) + keyFromRaw, keyToRaw, RawKey, mappedClone, c_plain_toraw, Mapped) /* csset: */ #define using_csset(...) \ @@ -72,10 +72,10 @@ int main(void) { using_csset_3(X, Key, c_default_compare) #define using_csset_3(X, Key, keyCompare) \ - using_csset_5(X, Key, keyCompare, c_default_del, c_default_fromraw) + using_csset_5(X, Key, keyCompare, c_plain_del, c_plain_fromraw) #define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \ - using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key) + using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key) #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CBST(X, csset, Key, Key, keyCompareRaw, _UNUSED_, keyDel, \ @@ -92,14 +92,14 @@ int main(void) { c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__) #define using_csmap_strkey_2(X, Mapped) \ - _using_CBST_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw) + _using_CBST_strkey(X, csmap, Mapped, c_plain_del, c_plain_fromraw) #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \ _using_CBST_strkey(X, csmap, Mapped, mappedDel, mappedClone) #define _using_CBST_strkey(X, C, Mapped, mappedDel, mappedClone) \ _using_CBST(X, C, cstr_t, Mapped, cstr_compare_raw, mappedDel, cstr_del, \ - cstr_from, cstr_c_str, const char*, mappedClone, c_default_toraw, Mapped) + cstr_from, cstr_c_str, const char*, mappedClone, c_plain_toraw, Mapped) #define using_csmap_strval(...) \ c_MACRO_OVERLOAD(using_csmap_strval, __VA_ARGS__) @@ -108,10 +108,10 @@ int main(void) { using_csmap_strval_3(X, Key, c_default_compare) #define using_csmap_strval_3(X, Key, keyCompare) \ - using_csmap_strval_5(X, Key, keyCompare, c_default_del, c_default_fromraw) + using_csmap_strval_5(X, Key, keyCompare, c_plain_del, c_plain_fromraw) #define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \ - using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_default_toraw, Key) + using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key) #define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CBST(X, csmap, Key, cstr_t, keyCompare, cstr_del, keyDel, \ diff --git a/examples/inits.c b/examples/inits.c index bf209e88..edcb4336 100644 --- a/examples/inits.c +++ b/examples/inits.c @@ -5,7 +5,7 @@ #include #include -using_cmap(id, int, cstr, c_default_equals, c_default_hash, cstr_del); // Map of int -> cstr +using_cmap(id, int, cstr, c_default_equals, c_default_hash, cstr_del, c_no_clone); // Map of int -> cstr using_cmap_strkey(cnt, int); typedef struct {int x, y;} ipair_t; diff --git a/examples/mapmap.c b/examples/mapmap.c index 5a5996f6..c775d870 100644 --- a/examples/mapmap.c +++ b/examples/mapmap.c @@ -4,7 +4,7 @@ #include using_cmap_str(); -using_cmap_strkey(cfg, cmap_str, cmap_str_del); +using_cmap_strkey(cfg, cmap_str, cmap_str_del, c_no_clone); int main(void) { cmap_cfg config = cmap_cfg_init(); diff --git a/stc/carray.h b/stc/carray.h index 3f0983bc..39e1fba8 100644 --- a/stc/carray.h +++ b/stc/carray.h @@ -48,12 +48,9 @@ int main() #define using_carray(...) c_MACRO_OVERLOAD(using_carray, __VA_ARGS__) #define using_carray_2(X, Value) \ - using_carray_4(X, Value, c_default_del, c_default_fromraw) + using_carray_4(X, Value, c_plain_del, c_plain_fromraw) -#define using_carray_3(X, Value, valueDestroy) \ - using_carray_4(X, Value, valueDestroy, c_no_fromraw) - -#define using_carray_4(X, Value, valueDestroy, valueClone) \ +#define using_carray_4(X, Value, valueDel, valueClone) \ \ typedef Value carray1##X##_value_t; \ typedef carray1##X##_value_t carray2##X##_value_t, carray3##X##_value_t; \ @@ -86,9 +83,9 @@ int main() STC_INLINE size_t \ carray3##X##_zdim(carray3##X a) {return _carray_zdim(a);} \ \ - _using_carray_common(1, X, Value, valueDestroy, valueClone) \ - _using_carray_common(2, X, Value, valueDestroy, valueClone) \ - _using_carray_common(3, X, Value, valueDestroy, valueClone) \ + _using_carray_common(1, X, Value, valueDel, valueClone) \ + _using_carray_common(2, X, Value, valueDel, valueClone) \ + _using_carray_common(3, X, Value, valueDel, valueClone) \ \ STC_INLINE carray1##X \ carray1##X##_init(size_t xdim, Value val) { \ @@ -166,7 +163,7 @@ int main() #define _carray_ydim(a) (a)._ydim #define _carray_zdim(a) (a)._zdim -#define _using_carray_common(D, X, Value, valueDestroy, valueClone) \ +#define _using_carray_common(D, X, Value, valueDel, valueClone) \ typedef struct { Value *ref; } carray##D##X##_iter_t; \ \ STC_INLINE carray##D##X##_iter_t \ @@ -184,7 +181,7 @@ int main() carray##D##X##_del(carray##D##X* self) { \ if (self->_xdim & _carray_OWN) { \ c_foreach_3 (i, carray##D##X, *self) \ - valueDestroy(i.ref); \ + valueDel(i.ref); \ c_free(self->data); \ } \ } \ diff --git a/stc/ccommon.h b/stc/ccommon.h index d3ceed52..590609fa 100644 --- a/stc/ccommon.h +++ b/stc/ccommon.h @@ -78,19 +78,18 @@ #define c_swap(T, x, y) do { T __t = x; x = y; y = __t; } while (0) #define c_arraylen(a) (sizeof (a)/sizeof (a)[0]) -#define c_default_compare(x, y) c_less_compare(c_default_less, x, y) +#define c_default_compare(x, y) (c_default_less(y, x) - c_default_less(x, y)) #define c_default_less(x, y) (*(x) < *(y)) -#define c_less_compare(less, x, y) (less(y, x) - less(x, y)) #define c_no_compare(x, y) (assert(!"c_no_compare() called"), 0) #define c_default_equals(x, y) (*(x) == *(y)) -#define c_memcmp_equals(x, y) (memcmp(x, y, sizeof *(x)) == 0) +#define c_plain_equals(x, y) (memcmp(x, y, sizeof *(x)) == 0) -#define c_no_fromraw(x) (assert(!"emplace*() with c_no_fromraw"), x) -#define c_default_fromraw(x) (x) -#define c_default_toraw(ptr) (*(ptr)) +#define c_plain_fromraw(x) (x) +#define c_no_clone(x) (assert(!"emplace*() with c_no_clone"), x) +#define c_plain_toraw(ptr) (*(ptr)) -#define c_default_del(ptr) ((void) (ptr)) +#define c_plain_del(ptr) ((void) (ptr)) /* Generic algorithms */ diff --git a/stc/cdeq.h b/stc/cdeq.h index 0b5ed8d3..a5c743a5 100644 --- a/stc/cdeq.h +++ b/stc/cdeq.h @@ -31,9 +31,9 @@ #define using_cdeq_2(X, Value) \ using_cdeq_3(X, Value, c_default_compare) #define using_cdeq_3(X, Value, valueCompare) \ - using_cdeq_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) -#define using_cdeq_4(X, Value, valueCompare, valueDestroy) \ - using_cdeq_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) + using_cdeq_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value) +#define using_cdeq_5(X, Value, valueCompare, valueDel, valueFromRaw) \ + using_cdeq_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value) #define using_cdeq_str() \ using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) @@ -49,7 +49,7 @@ struct cdeq_rep { size_t size, cap; void* base[]; }; #define cdeq_rep_(self) c_container_of((self)->base, struct cdeq_rep, base) typedef int (*c_cmp_fn)(const void*, const void*); -#define using_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define using_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ typedefs_cdeq(X, Value, RawValue); \ \ STC_API cdeq_##X \ @@ -110,7 +110,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); } \ STC_INLINE void \ cdeq_##X##_pop_back(cdeq_##X* self) { \ - valueDestroy(&self->data[--cdeq_rep_(self)->size]); \ + valueDel(&self->data[--cdeq_rep_(self)->size]); \ } \ \ STC_API void \ @@ -121,7 +121,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); } \ STC_INLINE void \ cdeq_##X##_pop_front(cdeq_##X* self) { \ - valueDestroy(self->data++); \ + valueDel(self->data++); \ --cdeq_rep_(self)->size; \ } \ \ @@ -207,7 +207,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); cdeq_##X##_sort(cdeq_##X* self) { \ cdeq_##X##_sort_range(cdeq_##X##_begin(self), cdeq_##X##_end(self), cdeq_##X##_value_compare); \ } \ - _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ + _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ typedef cdeq_##X cdeq_##X##_t /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -219,7 +219,7 @@ static struct cdeq_rep _cdeq_inits = {0, 0}; static inline double _minf(double x, double y) {return x < y ? x : y;} static inline double _maxf(double x, double y) {return x > y ? x : y;} -#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ \ STC_DEF cdeq_##X \ cdeq_##X##_init(void) { \ @@ -240,7 +240,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;} cdeq_##X##_clear(cdeq_##X* self) { \ struct cdeq_rep* rep = cdeq_rep_(self); if (rep->cap) { \ for (cdeq_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \ - valueDestroy(p); \ + valueDel(p); \ rep->size = 0; \ } \ } \ @@ -278,7 +278,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;} cdeq_##X##_resize(cdeq_##X* self, size_t size, Value null_val) { \ _cdeq_##X##_expand(self, size, false); \ size_t i, n = cdeq_rep_(self)->size; \ - for (i=size; idata + i); \ + for (i=size; idata + i); \ for (i=n; idata[i] = null_val; \ if (self->data) cdeq_rep_(self)->size = size; \ } \ @@ -330,7 +330,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;} intptr_t len = finish - first; \ if (len > 0) { \ cdeq_##X##_value_t* p = first, *end = self->data + cdeq_rep_(self)->size; \ - while (p != finish) valueDestroy(p++); \ + while (p != finish) valueDel(p++); \ if (first == self->data) self->data += len; \ else memmove(first, finish, (end - finish) * sizeof(Value)); \ cdeq_rep_(self)->size -= len; \ @@ -354,7 +354,7 @@ static inline double _maxf(double x, double y) {return x > y ? x : y;} } #else -#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) +#define _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #endif #endif diff --git a/stc/clist.h b/stc/clist.h index 9ee6fb1f..95dee6e7 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -59,9 +59,9 @@ #define using_clist_2(X, Value) \ using_clist_3(X, Value, c_default_compare) #define using_clist_3(X, Value, valueCompare) \ - using_clist_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) -#define using_clist_4(X, Value, valueCompare, valueDestroy) \ - using_clist_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) + using_clist_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value) +#define using_clist_5(X, Value, valueCompare, valueDel, valueFromRaw) \ + using_clist_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value) #define using_clist_str() \ using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) @@ -96,7 +96,7 @@ using_clist_types(void, int); STC_API size_t _clist_size(const clist_void* self); #define _clist_node(X, vp) c_container_of(vp, clist_##X##_node_t, value) -#define using_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define using_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ \ using_clist_types(X, Value); \ typedef RawValue clist_##X##_rawvalue_t; \ @@ -209,13 +209,13 @@ STC_API size_t _clist_size(const clist_void* self); STC_INLINE Value* \ clist_##X##_back(clist_##X* self) {return &self->last->value;} \ \ - _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ + _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ typedef clist_##X clist_##X##_t /* -------------------------- IMPLEMENTATION ------------------------- */ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ \ STC_DEF clist_##X \ clist_##X##_clone(clist_##X list) { \ @@ -292,7 +292,7 @@ STC_API size_t _clist_size(const clist_void* self); node->next = next; \ if (del == next) self->last = node = NULL; \ else if (self->last == del) self->last = node, node = NULL; \ - valueDestroy(&del->value); c_free(del); \ + valueDel(&del->value); c_free(del); \ return node; \ } \ \ @@ -418,7 +418,7 @@ _clist_mergesort(clist_void_node_t *list, int (*cmp)(const void*, const void*)) } #else -#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) +#define _c_implement_clist_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #endif #endif diff --git a/stc/cmap.h b/stc/cmap.h index 43fae80d..203f0263 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -65,17 +65,17 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; #define using_cmap_5(X, Key, Mapped, keyEquals, keyHash) \ using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \ - c_default_del, c_default_fromraw, c_default_toraw, Mapped) + c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped) -#define using_cmap_6(X, Key, Mapped, keyEquals, keyHash, mappedDel) \ +#define using_cmap_7(X, Key, Mapped, keyEquals, keyHash, mappedDel, mappedClone) \ using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \ - mappedDel, c_no_fromraw, c_default_toraw, Mapped) + mappedDel, mappedClone, c_plain_toraw, Mapped) -#define using_cmap_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ - mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ - _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \ +#define using_cmap_9(X, Key, Mapped, keyEquals, keyHash, \ + mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ + _using_CHASH(X, cmap, Key, Mapped, keyEquals, keyHash, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ - c_default_del, c_default_fromraw, c_default_toraw, Key) + c_plain_del, c_plain_fromraw, c_plain_toraw, Key) #define using_cmap_13(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ @@ -85,13 +85,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; keyDel, keyFromRaw, keyToRaw, RawKey) #define using_cmap_keydef(...) c_MACRO_OVERLOAD(using_cmap_keydef, __VA_ARGS__) -#define using_cmap_keydef_6(X, Key, Mapped, keyEquals, keyHash, keyDel) \ +#define using_cmap_keydef_7(X, Key, Mapped, keyEquals, keyHash, keyDel, keyClone) \ using_cmap_keydef_9(X, Key, Mapped, keyEquals, keyHash, \ - keyDel, c_no_fromraw, c_default_toraw, Key) + keyDel, keyClone, c_plain_toraw, Key) #define using_cmap_keydef_9(X, Key, Mapped, keyEqualsRaw, keyHashRaw, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CHASH(X, cmap, Key, Mapped, keyEqualsRaw, keyHashRaw, \ - c_default_del, c_default_fromraw, c_default_toraw, Mapped, \ + c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \ keyDel, keyFromRaw, keyToRaw, RawKey) /* cset: */ @@ -102,10 +102,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; using_cset_4(X, Key, c_default_equals, c_default_hash) #define using_cset_4(X, Key, keyEquals, keyHash) \ - using_cset_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key) + using_cset_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key) -#define using_cset_5(X, Key, keyEquals, keyHash, keyDel) \ - using_cset_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key) +#define using_cset_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \ + using_cset_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key) #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_CHASH(X, cset, Key, Key, keyEqualsRaw, keyHashRaw, \ @@ -124,10 +124,10 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__) #define using_cmap_strkey_2(X, Mapped) \ - _using_CHASH_strkey(X, cmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped) + _using_CHASH_strkey(X, cmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped) -#define using_cmap_strkey_3(X, Mapped, mappedDel) \ - _using_CHASH_strkey(X, cmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped) +#define using_cmap_strkey_4(X, Mapped, mappedDel, mappedClone) \ + _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped) #define using_cmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_CHASH_strkey(X, cmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) @@ -144,13 +144,13 @@ typedef struct {size_t idx; uint32_t hx;} chash_bucket_t; using_cmap_strval_4(X, Key, c_default_equals, c_default_hash) #define using_cmap_strval_4(X, Key, keyEquals, keyHash) \ - using_cmap_strval_8(X, Key, keyEquals, keyHash, c_default_del, c_default_fromraw, c_default_toraw, Key) + using_cmap_strval_8(X, Key, keyEquals, keyHash, c_plain_del, c_plain_fromraw, c_plain_toraw, Key) -#define using_cmap_strval_5(X, Key, keyEquals, keyHash, keyDel) \ - using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, c_no_fromraw, c_default_toraw, Key) +#define using_cmap_strval_6(X, Key, keyEquals, keyHash, keyDel, keyClone) \ + using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_plain_toraw, Key) -#define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyFromRaw, keyToRaw, RawKey) \ - _using_CHASH(X, cmap, Key, cstr_t, keyEquals, keyHash, \ +#define using_cmap_strval_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ + _using_CHASH(X, cmap, Key, cstr_t, keyEqualsRaw, keyHashRaw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) diff --git a/stc/cptr.h b/stc/cptr.h index 61b56123..2614238d 100644 --- a/stc/cptr.h +++ b/stc/cptr.h @@ -45,7 +45,7 @@ int Person_compare(const Person* p, const Person* q) { } using_cptr(pe, Person, Person_compare, Person_del); -using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del); +using_cvec(pe, Person*, cptr_pe_compare, cptr_pe_del, c_no_clone); int main() { cvec_pe vec = cvec_pe_init(); @@ -65,15 +65,15 @@ int main() { using_cptr_3(X, Value, c_default_compare) #define using_cptr_3(X, Value, valueCompare) \ - using_cptr_4(X, Value, valueCompare, c_default_del) + using_cptr_4(X, Value, valueCompare, c_plain_del) -#define using_cptr_4(X, Value, valueCompare, valueDestroy) \ +#define using_cptr_4(X, Value, valueCompare, valueDel) \ typedef Value cptr_##X##_value_t; \ typedef cptr_##X##_value_t *cptr_##X; \ \ STC_INLINE void \ cptr_##X##_del(cptr_##X* self) { \ - valueDestroy(*self); \ + valueDel(*self); \ c_free(*self); \ } \ \ @@ -158,9 +158,9 @@ typedef long atomic_count_t; using_csptr_3(X, Value, c_default_compare) #define using_csptr_3(X, Value, valueCompare) \ - using_csptr_4(X, Value, valueCompare, c_default_del) + using_csptr_4(X, Value, valueCompare, c_plain_del) -#define using_csptr_4(X, Value, valueCompare, valueDestroy) \ +#define using_csptr_4(X, Value, valueCompare, valueDel) \ typedef Value csptr_##X##_value_t; \ typedef struct { csptr_##X##_value_t* get; atomic_count_t* use_count; } csptr_##X; \ \ @@ -185,7 +185,7 @@ typedef long atomic_count_t; csptr_##X##_del(csptr_##X* self) { \ if (self->use_count && atomic_decrement(self->use_count) == 0) { \ c_free(self->use_count); \ - valueDestroy(self->get); \ + valueDel(self->get); \ c_free(self->get); \ } \ } \ diff --git a/stc/csmap.h b/stc/csmap.h index 0f9fcec2..7b6b04bd 100644 --- a/stc/csmap.h +++ b/stc/csmap.h @@ -49,15 +49,15 @@ int main(void) { using_csmap_4(X, Key, Mapped, c_default_compare) #define using_csmap_4(X, Key, Mapped, keyCompare) \ - using_csmap_8(X, Key, Mapped, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Mapped) + using_csmap_8(X, Key, Mapped, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped) -#define using_csmap_5(X, Key, Mapped, keyCompare, mappedDel) \ - using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, c_no_fromraw, c_default_toraw, Mapped) +#define using_csmap_6(X, Key, Mapped, keyCompare, mappedDel, mappedClone) \ + using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedClone, c_plain_toraw, Mapped) #define using_csmap_8(X, Key, Mapped, keyCompare, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ using_csmap_12(X, Key, Mapped, keyCompare, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ - c_default_del, c_default_fromraw, c_default_toraw, Key) + c_plain_del, c_plain_fromraw, c_plain_toraw, Key) #define using_csmap_12(X, Key, Mapped, keyCompareRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ @@ -67,13 +67,13 @@ int main(void) { keyDel, keyFromRaw, keyToRaw, RawKey) #define using_csmap_keydef(...) c_MACRO_OVERLOAD(using_csmap_keydef, __VA_ARGS__) -#define using_csmap_keydef_5(X, Key, Mapped, keyCompare, keyDel) \ +#define using_csmap_keydef_6(X, Key, Mapped, keyCompare, keyDel, keyClone) \ using_csmap_keydef_8(X, Key, Mapped, keyCompare, \ - keyDel, c_no_fromraw, c_default_toraw, Key) + keyDel, keyClone, c_plain_toraw, Key) #define using_csmap_keydef_8(X, Key, Mapped, keyCompareRaw, \ keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_AATREE(X, csmap, Key, Mapped, keyCompareRaw, \ - c_default_del, c_default_fromraw, c_default_toraw, Mapped, \ + c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped, \ keyDel, keyFromRaw, keyToRaw, RawKey) /* csset: */ @@ -84,10 +84,10 @@ int main(void) { using_csset_3(X, Key, c_default_compare) #define using_csset_3(X, Key, keyCompare) \ - using_csset_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key) + using_csset_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key) -#define using_csset_4(X, Key, keyCompare, keyDel) \ - using_csset_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key) +#define using_csset_5(X, Key, keyCompare, keyDel, keyClone) \ + using_csset_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key) #define using_csset_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ _using_AATREE(X, csset, Key, Key, keyCompareRaw, \ @@ -106,10 +106,10 @@ int main(void) { c_MACRO_OVERLOAD(using_csmap_strkey, __VA_ARGS__) #define using_csmap_strkey_2(X, Mapped) \ - _using_AATREE_strkey(X, csmap, Mapped, c_default_del, c_default_fromraw, c_default_toraw, Mapped) + _using_AATREE_strkey(X, csmap, Mapped, c_plain_del, c_plain_fromraw, c_plain_toraw, Mapped) -#define using_csmap_strkey_3(X, Mapped, mappedDel) \ - _using_AATREE_strkey(X, csmap, Mapped, mappedDel, c_no_fromraw, c_default_toraw, Mapped) +#define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \ + _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedClone, c_plain_toraw, Mapped) #define using_csmap_strkey_6(X, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ _using_AATREE_strkey(X, csmap, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) @@ -126,13 +126,13 @@ int main(void) { using_csmap_strval_3(X, Key, c_default_compare) #define using_csmap_strval_3(X, Key, keyCompare) \ - using_csmap_strval_7(X, Key, keyCompare, c_default_del, c_default_fromraw, c_default_toraw, Key) + using_csmap_strval_7(X, Key, keyCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Key) -#define using_csmap_strval_4(X, Key, keyCompare, keyDel) \ - using_csmap_strval_7(X, Key, keyCompare, keyDel, c_no_fromraw, c_default_toraw, Key) +#define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \ + using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_plain_toraw, Key) -#define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \ - _using_AATREE(X, csmap, Key, cstr_t, keyCompare, \ +#define using_csmap_strval_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ + _using_AATREE(X, csmap, Key, cstr_t, keyCompareRaw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) diff --git a/stc/cvec.h b/stc/cvec.h index 14e353be..1fa54d30 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -31,9 +31,9 @@ #define using_cvec_2(X, Value) \ using_cvec_3(X, Value, c_default_compare) #define using_cvec_3(X, Value, valueCompare) \ - using_cvec_7(X, Value, valueCompare, c_default_del, c_default_fromraw, c_default_toraw, Value) -#define using_cvec_4(X, Value, valueCompare, valueDestroy) \ - using_cvec_7(X, Value, valueCompare, valueDestroy, c_no_fromraw, c_default_toraw, Value) + using_cvec_7(X, Value, valueCompare, c_plain_del, c_plain_fromraw, c_plain_toraw, Value) +#define using_cvec_5(X, Value, valueCompare, valueDel, valueFromRaw) \ + using_cvec_7(X, Value, valueCompare, valueDel, valueFromRaw, c_plain_toraw, Value) #define using_cvec_str() \ using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) @@ -49,7 +49,7 @@ struct cvec_rep { size_t size, cap; void* data[]; }; #define cvec_rep_(self) c_container_of((self)->data, struct cvec_rep, data) typedef int (*c_cmp_fn)(const void*, const void*); -#define using_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define using_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ typedefs_cvec(X, Value, RawValue); \ \ STC_API cvec_##X \ @@ -105,7 +105,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); } \ STC_INLINE void \ cvec_##X##_pop_back(cvec_##X* self) { \ - valueDestroy(&self->data[--cvec_rep_(self)->size]); \ + valueDel(&self->data[--cvec_rep_(self)->size]); \ } \ \ STC_API cvec_##X##_iter_t \ @@ -197,7 +197,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); cvec_##X##_sort_range(cvec_##X##_begin(self), cvec_##X##_end(self), cvec_##X##_value_compare); \ } \ \ - _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ + _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ typedef cvec_##X cvec_##X##_t /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -205,7 +205,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) static struct cvec_rep _cvec_inits = {0, 0}; -#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \ +#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \ \ STC_DEF cvec_##X \ cvec_##X##_init(void) { \ @@ -225,7 +225,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; cvec_##X##_clear(cvec_##X* self) { \ struct cvec_rep* rep = cvec_rep_(self); if (rep->cap) { \ for (cvec_##X##_value_t *p = self->data, *q = p + rep->size; p != q; ++p) \ - valueDestroy(p); \ + valueDel(p); \ rep->size = 0; \ } \ } \ @@ -253,7 +253,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; cvec_##X##_reserve(self, len); \ struct cvec_rep* rep = cvec_rep_(self); \ size_t i, n = rep->size; \ - for (i = len; i < n; ++i) valueDestroy(self->data + i); \ + for (i = len; i < n; ++i) valueDel(self->data + i); \ for (i = n; i < len; ++i) self->data[i] = null_val; \ if (rep->cap) rep->size = len; \ } \ @@ -294,7 +294,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; intptr_t len = finish - first; \ if (len > 0) { \ cvec_##X##_value_t* p = first, *end = self->data + cvec_rep_(self)->size; \ - while (p != finish) valueDestroy(p++); \ + while (p != finish) valueDel(p++); \ memmove(first, finish, (end - finish) * sizeof(Value)); \ cvec_rep_(self)->size -= len; \ } \ @@ -332,7 +332,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; } #else -#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) +#define _c_implement_cvec_7(X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #endif #endif -- cgit v1.2.3