From 47b5b5ce53ed4607bf557e2b53a1286bc8041e94 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Wed, 16 Sep 2020 09:59:18 +0200 Subject: Changed earlier declare_(..) macro to typedef_(..) --- README.md | 40 ++++----- examples/README.md | 4 +- examples/advanced.c | 4 +- examples/benchmark.c | 240 ++++++++++++++++++++++++------------------------- examples/birthday.c | 6 +- examples/complex.c | 8 +- examples/demos.c | 16 ++-- examples/ex_gaussian.c | 4 +- examples/heap.c | 4 +- examples/inits.c | 12 +-- examples/list.c | 2 +- examples/mapmap.c | 4 +- examples/phonebook.c | 2 +- examples/priority.c | 4 +- examples/queue.c | 4 +- examples/stack.c | 8 +- examples/words.c | 6 +- stc/carray.h | 18 ++-- stc/clist.h | 26 +++--- stc/cmap.h | 79 ++++++++-------- stc/cpqueue.h | 6 +- stc/cqueue.h | 6 +- stc/cstack.h | 6 +- stc/cvec.h | 20 ++--- 24 files changed, 265 insertions(+), 264 deletions(-) diff --git a/README.md b/README.md index 07ef79ff..d347b64b 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ The usage of the containers is vert similar to the C++ standard containers, so i All containers mentioned above, except cstr_t and cbitset_t are generic and typesafe (similar to templates in C++). No casting is used. A simple example: ``` #include -c_cvec(i, int); +typedef_cvec(i, int); int main(void) { cvec_i vec = cvec_ini; @@ -55,10 +55,10 @@ Because it is headers only, files can simply be included in your program. The fu #include #include "Vec3.h" -c_cmap(ii, int, int); -c_cset(ix, int64_t); -c_cvec(i, int); -c_clist(v3, Vec3); +typedef_cmap(ii, int, int); +typedef_cset(ix, int64_t); +typedef_cvec(i, int); +typedef_clist(v3, Vec3); ... ``` Performance @@ -118,7 +118,7 @@ cmap discussion You can customize the destroy-, hash- and equals- function. **cmap/cset** also supports a few other arguments in the declare-statement that allows to define a convertion from a raw/literal type to the key-type specified. This is very useful when e.g. having cstr as key, as it enables the usage of string literals as key in *put() and find()* functions, instead of requering a constructed cstr. Without it, the code would become: ``` -c_cmap(si, cstr_t, int); // don't do this. +typedef_cmap(si, cstr_t, int); // don't do this. ... cmap_si_put(&map, cstr("mykey"), 12); ``` @@ -129,12 +129,12 @@ int x = cmap_si_find(&map, lookup)->value; cstr_destroy(&lookup); ``` To avoid this, use -- *c_cmap_strkey(tag, valuetype)* -- *c_cmap_strval(tag, keytype)* -- *c_cmap_str()* // cstr_t -> cstr_t -- *c_cset_str()* // cstr_t set +- *typedef_cmap_strkey(tag, valuetype)* +- *typedef_cmap_strval(tag, keytype)* +- *typedef_cmap_str()* // cstr_t -> cstr_t +- *typedef_cset_str()* // cstr_t set ``` -c_cmap_strkey(si, int); +typedef_cmap_strkey(si, int); ... cmap_si map = cmap_ini; cmap_si_put(&map, "mykey", 12); // constructs a cstr_t key from the const char* internally. @@ -142,9 +142,9 @@ int x = cmap_si_find(&map, "mykey")->value; // no allocation of string key happe cmap_si_destroy(&map); ``` An alternative is to use *char* * as key type, but then you must manage allcoated memory of the hash char* keys yourself. -Note that this predefined customization is also available for **cvec** and **clist**. See *c_cvec_str()*, *c_clist_str()*. +Note that this predefined customization is also available for **cvec** and **clist**. See *typedef_cvec_str()*, *typedef_clist_str()*. -To customize your own cmap type to work like cmap_str, you may want to look at **examples/advanced.c**. It demonstrates how to use a custom struct as a hash map key, using the optional parameters to c_cmap(). +To customize your own cmap type to work like cmap_str, you may want to look at **examples/advanced.c**. It demonstrates how to use a custom struct as a hash map key, using the optional parameters to typedef_cmap(). Example usages -------------- @@ -181,7 +181,7 @@ int main() { **cvec** of *int64_t*. ``` #include -c_cvec(ix, int64_t); // ix is just an example type tag name. +typedef_cvec(ix, int64_t); // ix is just an example type tag name. int main() { cvec_ix bignums = cvec_ini; // use cvec_ix_init() if initializing after declaration. @@ -200,7 +200,7 @@ int main() { ``` #include #include -c_cvec_str(); +typedef_cvec_str(); int main() { cvec_str names = cvec_ini; @@ -220,7 +220,7 @@ int main() { ``` #include #include -c_cmap(ii, int, int); +typedef_cmap(ii, int, int); int main() { cmap_ii nums = cmap_ini; @@ -235,7 +235,7 @@ int main() { ``` #include #include -c_cset_str(); // cstr set. See the discussion above. +typedef_cset_str(); // cstr set. See the discussion above. int main() { cset_str words = cset_ini; @@ -254,7 +254,7 @@ int main() { ``` #include #include -c_cmap_str(); +typedef_cmap_str(); int main() { cmap_str table = cmap_ini; @@ -276,7 +276,7 @@ int main() { #include #include #include -c_clist(fx, double); +typedef_clist(fx, double); int main() { clist_fx list = clist_ini; @@ -313,7 +313,7 @@ int main() { ``` #include #include -c_carray(f, float); +typedef_carray(f, float); int main() { diff --git a/examples/README.md b/examples/README.md index d12cc522..8820f5cf 100644 --- a/examples/README.md +++ b/examples/README.md @@ -51,9 +51,9 @@ static inline Viking viking_fromVw(VikingVw vw) { // note: parameter is by value Viking vk = {cstr(vw.name), cstr(vw.country)}; return vk; } ``` -With this in place, we use the full c_cmap() macro to define {Viking -> int} hash map type: +With this in place, we use the full typedef_cmap() macro to define {Viking -> int} hash map type: ``` -c_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, +typedef_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, viking_destroy, VikingVw, viking_toVw, viking_fromVw); ``` cmap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test. cmap_vk_destroy() will free all memory allocated for Viking keys and the hash table values. diff --git a/examples/advanced.c b/examples/advanced.c index 0570ce55..2c736e2d 100644 --- a/examples/advanced.c +++ b/examples/advanced.c @@ -50,8 +50,8 @@ Viking viking_fromVw(VikingVw vw) { Viking vk = {cstr(vw.name), cstr(vw.country)}; return vk; } -// Using the full c_cmap() macro to define [Viking -> int] hash map type: -c_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, +// Using the full typedef_cmap() macro to define [Viking -> int] hash map type: +typedef_cmap(vk, Viking, int, c_default_destroy, vikingvw_equals, vikingvw_hash, viking_destroy, VikingVw, viking_toVw, viking_fromVw); // cmap_vk uses vikingvw_hash() for hash value calculations, and vikingvw_equals() for equality test. diff --git a/examples/benchmark.c b/examples/benchmark.c index 0a492d3d..969cf3cc 100644 --- a/examples/benchmark.c +++ b/examples/benchmark.c @@ -22,7 +22,7 @@ static inline uint32_t fibonacci_hash(const void* data, size_t len) { } // cmap and khash template expansion -c_cmap(ii, int64_t, int64_t, c_default_destroy, c_default_equals, fibonacci_hash); +typedef_cmap(ii, int64_t, int64_t, c_default_destroy, c_default_equals, fibonacci_hash); KHASH_MAP_INIT_INT64(ii, int64_t) @@ -34,100 +34,100 @@ crand_rng64_t rng; #define RAND(N) (crand_i64(&rng) & ((1 << N) - 1)) -#define CMAP_SETUP(tt, Key, Value) cmap_##tt map = cmap_ini \ - ; cmap_##tt##_set_load_factors(&map, max_load_factor, 0.0) -#define CMAP_PUT(tt, key, val) cmap_##tt##_put(&map, key, val).first->second -#define CMAP_EMPLACE(tt, key, val) cmap_##tt##_emplace(&map, key, val) -#define CMAP_ERASE(tt, key) cmap_##tt##_erase(&map, key) -#define CMAP_FIND(tt, key) (cmap_##tt##_find(map, key) != NULL) -#define CMAP_FOR(tt, i) c_foreach (i, cmap_##tt, map) -#define CMAP_ITEM(tt, i) i.get->second -#define CMAP_SIZE(tt) cmap_size(map) -#define CMAP_BUCKETS(tt) cmap_bucket_count(map) -#define CMAP_CLEAR(tt) cmap_##tt##_clear(&map) -#define CMAP_DTOR(tt) cmap_##tt##_destroy(&map) - -#define KMAP_SETUP(tt, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret -#define KMAP_PUT(tt, key, val) (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki])) -#define KMAP_EMPLACE(tt, key, val) (ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val) : val) -#define KMAP_ERASE(tt, key) ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0) -#define KMAP_FIND(tt, key) (kh_get(ii, map, key) != kh_end(map)) -#define KMAP_SIZE(tt) kh_size(map) -#define KMAP_BUCKETS(tt) kh_n_buckets(map) -#define KMAP_CLEAR(tt) kh_clear(ii, map) -#define KMAP_DTOR(tt) kh_destroy(ii, map) - -#define UMAP_SETUP(tt, Key, Value) std::unordered_map map; map.max_load_factor(max_load_factor) -#define UMAP_PUT(tt, key, val) (map[key] = val) -#define UMAP_EMPLACE(tt, key, val) map.emplace(key, val) -#define UMAP_FIND(tt, key) (map.find(key) != map.end()) -#define UMAP_ERASE(tt, key) map.erase(key) -#define UMAP_FOR(tt, i) for (auto i: map) -#define UMAP_ITEM(tt, i) i.second -#define UMAP_SIZE(tt) map.size() -#define UMAP_BUCKETS(tt) map.bucket_count() -#define UMAP_CLEAR(tt) map.clear() -#define UMAP_DTOR(tt) destroy_me(map) - -#define BMAP_SETUP(tt, Key, Value) ska::bytell_hash_map map; map.max_load_factor(max_load_factor) -#define BMAP_PUT(tt, key, val) UMAP_PUT(tt, key, val) -#define BMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val) -#define BMAP_FIND(tt, key) UMAP_FIND(tt, key) -#define BMAP_ERASE(tt, key) UMAP_ERASE(tt, key) -#define BMAP_FOR(tt, i) UMAP_FOR(tt, i) -#define BMAP_ITEM(tt, i) UMAP_ITEM(tt, i) -#define BMAP_SIZE(tt) UMAP_SIZE(tt) -#define BMAP_BUCKETS(tt) UMAP_BUCKETS(tt) -#define BMAP_CLEAR(tt) UMAP_CLEAR(tt) -#define BMAP_DTOR(tt) UMAP_DTOR(tt) - -#define FMAP_SETUP(tt, Key, Value) ska::flat_hash_map map; map.max_load_factor(max_load_factor) -#define FMAP_PUT(tt, key, val) UMAP_PUT(tt, key, val) -#define FMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val) -#define FMAP_FIND(tt, key) UMAP_FIND(tt, key) -#define FMAP_ERASE(tt, key) UMAP_ERASE(tt, key) -#define FMAP_FOR(tt, i) UMAP_FOR(tt, i) -#define FMAP_ITEM(tt, i) UMAP_ITEM(tt, i) -#define FMAP_SIZE(tt) UMAP_SIZE(tt) -#define FMAP_BUCKETS(tt) UMAP_BUCKETS(tt) -#define FMAP_CLEAR(tt) UMAP_CLEAR(tt) -#define FMAP_DTOR(tt) UMAP_DTOR(tt) - -#define HMAP_SETUP(tt, Key, Value) tsl::hopscotch_map map; map.max_load_factor(max_load_factor) -#define HMAP_PUT(tt, key, val) UMAP_PUT(tt, key, val) -#define HMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val) -#define HMAP_FIND(tt, key) UMAP_FIND(tt, key) -#define HMAP_ERASE(tt, key) UMAP_ERASE(tt, key) -#define HMAP_FOR(tt, i) UMAP_FOR(tt, i) -#define HMAP_ITEM(tt, i) UMAP_ITEM(tt, i) -#define HMAP_SIZE(tt) UMAP_SIZE(tt) -#define HMAP_BUCKETS(tt) UMAP_BUCKETS(tt) -#define HMAP_CLEAR(tt) UMAP_CLEAR(tt) -#define HMAP_DTOR(tt) UMAP_DTOR(tt) - -#define RMAP_SETUP(tt, Key, Value) robin_hood::unordered_map map -#define RMAP_PUT(tt, key, val) UMAP_PUT(tt, key, val) -#define RMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val) -#define RMAP_FIND(tt, key) UMAP_FIND(tt, key) -#define RMAP_ERASE(tt, key) UMAP_ERASE(tt, key) -#define RMAP_FOR(tt, i) UMAP_FOR(tt, i) -#define RMAP_ITEM(tt, i) UMAP_ITEM(tt, i) -#define RMAP_SIZE(tt) UMAP_SIZE(tt) -#define RMAP_BUCKETS(tt) map.mask() -#define RMAP_CLEAR(tt) UMAP_CLEAR(tt) -#define RMAP_DTOR(tt) UMAP_DTOR(tt) - -#define SMAP_SETUP(tt, Key, Value) spp::sparse_hash_map map; map.max_load_factor(max_load_factor) -#define SMAP_PUT(tt, key, val) UMAP_PUT(tt, key, val) -#define SMAP_EMPLACE(tt, key, val) UMAP_EMPLACE(tt, key, val) -#define SMAP_FIND(tt, key) UMAP_FIND(tt, key) -#define SMAP_ERASE(tt, key) UMAP_ERASE(tt, key) -#define SMAP_FOR(tt, i) UMAP_FOR(tt, i) -#define SMAP_ITEM(tt, i) UMAP_ITEM(tt, i) -#define SMAP_SIZE(tt) UMAP_SIZE(tt) -#define SMAP_BUCKETS(tt) UMAP_BUCKETS(tt) -#define SMAP_CLEAR(tt) UMAP_CLEAR(tt) -#define SMAP_DTOR(tt) UMAP_DTOR(tt) +#define CMAP_SETUP(X, Key, Value) cmap_##X map = cmap_ini \ + ; cmap_##X##_set_load_factors(&map, max_load_factor, 0.0) +#define CMAP_PUT(X, key, val) cmap_##X##_put(&map, key, val).first->second +#define CMAP_EMPLACE(X, key, val) cmap_##X##_emplace(&map, key, val) +#define CMAP_ERASE(X, key) cmap_##X##_erase(&map, key) +#define CMAP_FIND(X, key) (cmap_##X##_find(map, key) != NULL) +#define CMAP_FOR(X, i) c_foreach (i, cmap_##X, map) +#define CMAP_ITEM(X, i) i.get->second +#define CMAP_SIZE(X) cmap_size(map) +#define CMAP_BUCKETS(X) cmap_##X##_bucket_count(map) +#define CMAP_CLEAR(X) cmap_##X##_clear(&map) +#define CMAP_DTOR(X) cmap_##X##_destroy(&map) + +#define KMAP_SETUP(X, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret +#define KMAP_PUT(X, key, val) (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki])) +#define KMAP_EMPLACE(X, key, val) (ki = kh_put(ii, map, key, &ret), ret ? (map->vals[ki] = val) : val) +#define KMAP_ERASE(X, key) ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0) +#define KMAP_FIND(X, key) (kh_get(ii, map, key) != kh_end(map)) +#define KMAP_SIZE(X) kh_size(map) +#define KMAP_BUCKETS(X) kh_n_buckets(map) +#define KMAP_CLEAR(X) kh_clear(ii, map) +#define KMAP_DTOR(X) kh_destroy(ii, map) + +#define UMAP_SETUP(X, Key, Value) std::unordered_map map; map.max_load_factor(max_load_factor) +#define UMAP_PUT(X, key, val) (map[key] = val) +#define UMAP_EMPLACE(X, key, val) map.emplace(key, val) +#define UMAP_FIND(X, key) (map.find(key) != map.end()) +#define UMAP_ERASE(X, key) map.erase(key) +#define UMAP_FOR(X, i) for (auto i: map) +#define UMAP_ITEM(X, i) i.second +#define UMAP_SIZE(X) map.size() +#define UMAP_BUCKETS(X) map.bucket_count() +#define UMAP_CLEAR(X) map.clear() +#define UMAP_DTOR(X) destroy_me(map) + +#define BMAP_SETUP(X, Key, Value) ska::bytell_hash_map map; map.max_load_factor(max_load_factor) +#define BMAP_PUT(X, key, val) UMAP_PUT(X, key, val) +#define BMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val) +#define BMAP_FIND(X, key) UMAP_FIND(X, key) +#define BMAP_ERASE(X, key) UMAP_ERASE(X, key) +#define BMAP_FOR(X, i) UMAP_FOR(X, i) +#define BMAP_ITEM(X, i) UMAP_ITEM(X, i) +#define BMAP_SIZE(X) UMAP_SIZE(X) +#define BMAP_BUCKETS(X) UMAP_BUCKETS(X) +#define BMAP_CLEAR(X) UMAP_CLEAR(X) +#define BMAP_DTOR(X) UMAP_DTOR(X) + +#define FMAP_SETUP(X, Key, Value) ska::flat_hash_map map; map.max_load_factor(max_load_factor) +#define FMAP_PUT(X, key, val) UMAP_PUT(X, key, val) +#define FMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val) +#define FMAP_FIND(X, key) UMAP_FIND(X, key) +#define FMAP_ERASE(X, key) UMAP_ERASE(X, key) +#define FMAP_FOR(X, i) UMAP_FOR(X, i) +#define FMAP_ITEM(X, i) UMAP_ITEM(X, i) +#define FMAP_SIZE(X) UMAP_SIZE(X) +#define FMAP_BUCKETS(X) UMAP_BUCKETS(X) +#define FMAP_CLEAR(X) UMAP_CLEAR(X) +#define FMAP_DTOR(X) UMAP_DTOR(X) + +#define HMAP_SETUP(X, Key, Value) tsl::hopscotch_map map; map.max_load_factor(max_load_factor) +#define HMAP_PUT(X, key, val) UMAP_PUT(X, key, val) +#define HMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val) +#define HMAP_FIND(X, key) UMAP_FIND(X, key) +#define HMAP_ERASE(X, key) UMAP_ERASE(X, key) +#define HMAP_FOR(X, i) UMAP_FOR(X, i) +#define HMAP_ITEM(X, i) UMAP_ITEM(X, i) +#define HMAP_SIZE(X) UMAP_SIZE(X) +#define HMAP_BUCKETS(X) UMAP_BUCKETS(X) +#define HMAP_CLEAR(X) UMAP_CLEAR(X) +#define HMAP_DTOR(X) UMAP_DTOR(X) + +#define RMAP_SETUP(X, Key, Value) robin_hood::unordered_map map +#define RMAP_PUT(X, key, val) UMAP_PUT(X, key, val) +#define RMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val) +#define RMAP_FIND(X, key) UMAP_FIND(X, key) +#define RMAP_ERASE(X, key) UMAP_ERASE(X, key) +#define RMAP_FOR(X, i) UMAP_FOR(X, i) +#define RMAP_ITEM(X, i) UMAP_ITEM(X, i) +#define RMAP_SIZE(X) UMAP_SIZE(X) +#define RMAP_BUCKETS(X) map.mask() +#define RMAP_CLEAR(X) UMAP_CLEAR(X) +#define RMAP_DTOR(X) UMAP_DTOR(X) + +#define SMAP_SETUP(X, Key, Value) spp::sparse_hash_map map; map.max_load_factor(max_load_factor) +#define SMAP_PUT(X, key, val) UMAP_PUT(X, key, val) +#define SMAP_EMPLACE(X, key, val) UMAP_EMPLACE(X, key, val) +#define SMAP_FIND(X, key) UMAP_FIND(X, key) +#define SMAP_ERASE(X, key) UMAP_ERASE(X, key) +#define SMAP_FOR(X, i) UMAP_FOR(X, i) +#define SMAP_ITEM(X, i) UMAP_ITEM(X, i) +#define SMAP_SIZE(X) UMAP_SIZE(X) +#define SMAP_BUCKETS(X) UMAP_BUCKETS(X) +#define SMAP_CLEAR(X) UMAP_CLEAR(X) +#define SMAP_DTOR(X) UMAP_DTOR(X) enum { FAC = 3, @@ -140,68 +140,68 @@ enum { int rr = RR; -#define MAP_TEST1(M, tt) \ +#define MAP_TEST1(M, X) \ { \ - M##_SETUP(tt, int64_t, int64_t); \ + M##_SETUP(X, int64_t, int64_t); \ uint64_t checksum = 0, erased = 0; \ SEED(seed); \ clock_t difference, before = clock(); \ for (size_t i = 0; i < N1; ++i) { \ - checksum += ++ M##_PUT(tt, RAND(rr), i); \ - erased += M##_ERASE(tt, RAND(rr)); \ + checksum += ++ M##_PUT(X, RAND(rr), i); \ + erased += M##_ERASE(X, RAND(rr)); \ } \ difference = clock() - before; \ printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, sum: %zu, erased %zu\n", \ - (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, checksum, erased); \ - M##_CLEAR(tt); \ + (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, checksum, erased); \ + M##_CLEAR(X); \ } -#define MAP_TEST2(M, tt) \ +#define MAP_TEST2(M, X) \ { \ - M##_SETUP(tt, int64_t, int64_t); \ + M##_SETUP(X, int64_t, int64_t); \ size_t erased = 0; \ clock_t difference, before = clock(); \ for (size_t i = 0; i < N2; ++i) \ - M##_PUT(tt, i, i); \ + M##_PUT(X, i, i); \ for (size_t i = 0; i < N2; ++i) \ - erased += M##_ERASE(tt, i); \ + erased += M##_ERASE(X, i); \ difference = clock() - before; \ printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \ - (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, erased); \ - M##_CLEAR(tt); \ + (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, erased); \ + M##_CLEAR(X); \ } -#define MAP_TEST3(M, tt) \ +#define MAP_TEST3(M, X) \ { \ - M##_SETUP(tt, int64_t, int64_t); \ + M##_SETUP(X, int64_t, int64_t); \ size_t erased = 0; \ clock_t difference, before = clock(); \ SEED(seed); \ for (size_t i = 0; i < N3; ++i) \ - M##_PUT(tt, RAND(rr), i); \ + M##_PUT(X, RAND(rr), i); \ SEED(seed); \ for (size_t i = 0; i < N3; ++i) \ - erased += M##_ERASE(tt, RAND(rr)); \ + erased += M##_ERASE(X, RAND(rr)); \ difference = clock() - before; \ printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \ - (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, erased); \ - M##_CLEAR(tt); \ + (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, erased); \ + M##_CLEAR(X); \ } -#define MAP_TEST4(M, tt) \ +#define MAP_TEST4(M, X) \ { \ - M##_SETUP(tt, int64_t, int64_t); \ + M##_SETUP(X, int64_t, int64_t); \ size_t sum = 0; \ SEED(seed); \ for (size_t i = 0; i < N4; ++i) \ - M##_PUT(tt, RAND(rr), i); \ + M##_PUT(X, RAND(rr), i); \ clock_t difference, before = clock(); \ - for (int k=0; k<5; k++) M##_FOR (tt, i) \ - sum += M##_ITEM(tt, i); \ + for (int k=0; k<5; k++) M##_FOR (X, i) \ + sum += M##_ITEM(X, i); \ difference = clock() - before; \ printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, sum %zu\n", \ - (size_t) M##_SIZE(tt), (size_t) M##_BUCKETS(tt), (float) difference / CLOCKS_PER_SEC, sum); \ - M##_CLEAR(tt); \ + (size_t) M##_SIZE(X), (size_t) M##_BUCKETS(X), (float) difference / CLOCKS_PER_SEC, sum); \ + M##_CLEAR(X); \ } diff --git a/examples/birthday.c b/examples/birthday.c index 1cd57066..e085e25c 100644 --- a/examples/birthday.c +++ b/examples/birthday.c @@ -7,7 +7,7 @@ #include #include -c_cmap(ic, uint64_t, uint8_t); +typedef_cmap(ic, uint64_t, uint8_t); const static uint64_t seed = 1234; const static uint64_t N = 1ull << 27; @@ -29,8 +29,8 @@ void repeats(void) } -c_cmap(x, uint32_t, uint64_t); -c_cvec(x, uint64_t); +typedef_cmap(x, uint32_t, uint64_t); +typedef_cvec(x, uint64_t); void distribution(void) { diff --git a/examples/complex.c b/examples/complex.c index aa746b90..e0bc5200 100644 --- a/examples/complex.c +++ b/examples/complex.c @@ -5,10 +5,10 @@ void check_destroy(float* v) {printf("destroy %g\n", *v);} -c_carray(f, float, check_destroy); // normally omit the last argument - float type need no destroy. -c_clist(y, carray2f, carray2f_destroy, c_no_compare); -c_cmap(g, int, clist_y, clist_y_destroy); -c_cmap_strkey(s, cmap_g, cmap_g_destroy); +typedef_carray(f, float, check_destroy); // normally omit the last argument - float type need no destroy. +typedef_clist(y, carray2f, carray2f_destroy, c_no_compare); +typedef_cmap(g, int, clist_y, clist_y_destroy); +typedef_cmap_strkey(s, cmap_g, cmap_g_destroy); int main() { int xdim = 4, ydim = 6; diff --git a/examples/demos.c b/examples/demos.c index 0247945d..634e4dde 100644 --- a/examples/demos.c +++ b/examples/demos.c @@ -34,7 +34,7 @@ void stringdemo1() } -c_cvec(ix, int64_t); // ix is just an example tag name. +typedef_cvec(ix, int64_t); // ix is just an example tag name. void vectordemo1() { @@ -55,7 +55,7 @@ void vectordemo1() -c_cvec_str(); +typedef_cvec_str(); void vectordemo2() { @@ -73,7 +73,7 @@ void vectordemo2() cvec_str_destroy(&names); } -c_clist(ix, int); +typedef_clist(ix, int); void listdemo1() { @@ -100,7 +100,7 @@ void listdemo1() clist_ix_destroy(&nums); } -c_cset(i, int); +typedef_cset(i, int); void setdemo1() { @@ -115,7 +115,7 @@ void setdemo1() } -c_cmap(ii, int, int); +typedef_cmap(ii, int, int); void mapdemo1() { @@ -128,7 +128,7 @@ void mapdemo1() } -c_cmap_strkey(si, int); // Shorthand macro for the general c_cmap expansion. +typedef_cmap_strkey(si, int); // Shorthand macro for the general typedef_cmap expansion. void mapdemo2() { @@ -150,7 +150,7 @@ void mapdemo2() } -c_cmap_str(); +typedef_cmap_str(); void mapdemo3() { @@ -172,7 +172,7 @@ void mapdemo3() } -c_carray(f, float); +typedef_carray(f, float); void arraydemo1() { diff --git a/examples/ex_gaussian.c b/examples/ex_gaussian.c index 559512ce..3c3a05bf 100644 --- a/examples/ex_gaussian.c +++ b/examples/ex_gaussian.c @@ -7,14 +7,14 @@ #include // Declare int -> int hashmap. Uses typetag 'i' for ints. -c_cmap(i, int, size_t); +typedef_cmap(i, int, size_t); // Declare int vector with map entries that can be sorted by map keys. static int compare(cmap_i_entry_t *a, cmap_i_entry_t *b) { return c_default_compare(&a->first, &b->first); } // Vector: typetag 'e' for (map) entry -c_cvec(e, cmap_i_entry_t, c_default_destroy, compare); +typedef_cvec(e, cmap_i_entry_t, c_default_destroy, compare); int main() { diff --git a/examples/heap.c b/examples/heap.c index 99806c17..18ba247c 100644 --- a/examples/heap.c +++ b/examples/heap.c @@ -4,8 +4,8 @@ #include #include -c_cvec(f, float); -c_cpqueue(f, cvec_f, >); +typedef_cvec(f, float); +typedef_cpqueue(f, cvec_f, >); int main() { diff --git a/examples/inits.c b/examples/inits.c index 6540290a..4d07cb02 100644 --- a/examples/inits.c +++ b/examples/inits.c @@ -5,19 +5,19 @@ #include #include -c_cmap(id, int, cstr_t, cstr_destroy); // Map of int -> cstr_t -c_cmap_strkey(cnt, int); +typedef_cmap(id, int, cstr_t, cstr_destroy); // Map of int -> cstr_t +typedef_cmap_strkey(cnt, int); typedef struct {int x, y;} ipair_t; inline static int ipair_compare(const ipair_t* a, const ipair_t* b) { int c = c_default_compare(&a->x, &b->x); return c != 0 ? c : c_default_compare(&a->y, &b->y); } -c_cvec(ip, ipair_t, c_default_destroy, ipair_compare); -c_clist(ip, ipair_t, c_default_destroy, ipair_compare); +typedef_cvec(ip, ipair_t, c_default_destroy, ipair_compare); +typedef_clist(ip, ipair_t, c_default_destroy, ipair_compare); -c_cvec(f, float); -c_cpqueue(f, cvec_f, >); +typedef_cvec(f, float); +typedef_cpqueue(f, cvec_f, >); int main(void) { diff --git a/examples/list.c b/examples/list.c index a0a3b456..55e6c419 100644 --- a/examples/list.c +++ b/examples/list.c @@ -2,7 +2,7 @@ #include #include #include -c_clist(fx, double); +typedef_clist(fx, double); int main() { int k, n = 100000; diff --git a/examples/mapmap.c b/examples/mapmap.c index 50806e3d..f40d6be5 100644 --- a/examples/mapmap.c +++ b/examples/mapmap.c @@ -3,8 +3,8 @@ #include #include -c_cmap_str(); -c_cmap_strkey(cfg, cmap_str, cmap_str_destroy); +typedef_cmap_str(); +typedef_cmap_strkey(cfg, cmap_str, cmap_str_destroy); int main(void) { cmap_cfg config = cmap_ini; diff --git a/examples/phonebook.c b/examples/phonebook.c index 5395d774..66b54e33 100644 --- a/examples/phonebook.c +++ b/examples/phonebook.c @@ -25,7 +25,7 @@ #include #include -c_cmap_str(); +typedef_cmap_str(); void print_phone_book(cmap_str phone_book) { diff --git a/examples/priority.c b/examples/priority.c index 1a8eff78..d35ec4c7 100644 --- a/examples/priority.c +++ b/examples/priority.c @@ -6,8 +6,8 @@ #include #include -c_cvec(i, int64_t); -c_cpqueue(i, cvec_i, >); // min-heap (increasing values) +typedef_cvec(i, int64_t); +typedef_cpqueue(i, cvec_i, >); // min-heap (increasing values) int main() { size_t N = 10000000; diff --git a/examples/queue.c b/examples/queue.c index addecaa6..330e79fe 100644 --- a/examples/queue.c +++ b/examples/queue.c @@ -2,8 +2,8 @@ #include #include -c_clist(i, int); -c_cqueue(i, clist_i); // min-heap (increasing values) +typedef_clist(i, int); +typedef_cqueue(i, clist_i); // min-heap (increasing values) int main() { int n = 10000000; diff --git a/examples/stack.c b/examples/stack.c index ba7de082..c51c420c 100644 --- a/examples/stack.c +++ b/examples/stack.c @@ -3,10 +3,10 @@ #include #include -c_cvec(i, int); -c_cvec(c, char); -c_cstack(i, cvec_i); -c_cstack(c, cvec_c); +typedef_cvec(i, int); +typedef_cvec(c, char); +typedef_cstack(i, cvec_i); +typedef_cstack(c, cvec_c); int main() { cstack_i stack = cstack_i_init(); diff --git a/examples/words.c b/examples/words.c index fe738d0d..70a4878f 100644 --- a/examples/words.c +++ b/examples/words.c @@ -4,9 +4,9 @@ #include #include -c_cvec_str(); -c_clist_str(); -c_cmap_strkey(si, int); +typedef_cvec_str(); +typedef_clist_str(); +typedef_cmap_strkey(si, int); int main1() diff --git a/stc/carray.h b/stc/carray.h index e2f404eb..b7557f59 100644 --- a/stc/carray.h +++ b/stc/carray.h @@ -30,7 +30,7 @@ Multi-dimensional generic array allocated as one block of heap-memory. // demo: #include -c_carray(f, float); +typedef_carray(f, float); int main() { @@ -68,7 +68,7 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) { } -#define c_carray_common(D, X, Value, valueDestroy) \ +#define typedef_carray_common(D, X, Value, valueDestroy) \ typedef struct { Value *get; } carray##D##X##_iter_t; \ \ STC_INLINE carray##D##X##_iter_t \ @@ -91,12 +91,12 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) { } \ } -#define c_carray(...) c_MACRO_OVERLOAD(c_carray, __VA_ARGS__) -#define c_carray_2(X, Value) \ - c_carray_3(X, Value, c_default_destroy) +#define typedef_carray(...) c_MACRO_OVERLOAD(typedef_carray, __VA_ARGS__) +#define typedef_carray_2(X, Value) \ + typedef_carray_3(X, Value, c_default_destroy) -#define c_carray_3(X, Value, valueDestroy) \ +#define typedef_carray_3(X, Value, valueDestroy) \ \ typedef Value carray1##X##_value_t; \ typedef carray1##X##_value_t carray2##X##_value_t, carray3##X##_value_t; \ @@ -116,9 +116,9 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) { size_t _xdim, _yxdim, _zdim; \ } carray3##X; \ \ - c_carray_common(1, X, Value, valueDestroy) \ - c_carray_common(2, X, Value, valueDestroy) \ - c_carray_common(3, X, Value, valueDestroy) \ + typedef_carray_common(1, X, Value, valueDestroy) \ + typedef_carray_common(2, X, Value, valueDestroy) \ + typedef_carray_common(3, X, Value, valueDestroy) \ \ STC_INLINE carray1##X \ carray1##X##_make(size_t xdim, Value val) { \ diff --git a/stc/clist.h b/stc/clist.h index 27bdefb4..1fd88310 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -35,7 +35,7 @@ #include #include #include - c_clist(ix, int64_t); + typedef_clist(ix, int64_t); int main() { clist_ix list = clist_ini; @@ -56,19 +56,19 @@ } */ -#define c_clist(...) c_MACRO_OVERLOAD(c_clist, __VA_ARGS__) +#define typedef_clist(...) c_MACRO_OVERLOAD(typedef_clist, __VA_ARGS__) -#define c_clist_2(X, Value) \ - c_clist_3(X, Value, c_default_destroy) -#define c_clist_3(X, Value, valueDestroy) \ - c_clist_4(X, Value, valueDestroy, c_default_compare) -#define c_clist_4(X, Value, valueDestroy, valueCompare) \ - c_clist_7(X, Value, valueDestroy, Value, \ +#define typedef_clist_2(X, Value) \ + typedef_clist_3(X, Value, c_default_destroy) +#define typedef_clist_3(X, Value, valueDestroy) \ + typedef_clist_4(X, Value, valueDestroy, c_default_compare) +#define typedef_clist_4(X, Value, valueDestroy, valueCompare) \ + typedef_clist_7(X, Value, valueDestroy, Value, \ valueCompare, c_default_to_raw, c_default_from_raw) -#define c_clist_str() c_clist_7(str, cstr_t, cstr_destroy, const char*, \ +#define typedef_clist_str() typedef_clist_7(str, cstr_t, cstr_destroy, const char*, \ cstr_compare_raw, cstr_to_raw, cstr) -#define c_clist_types(X, Value) \ +#define typedef_clist_types(X, Value) \ typedef Value clist_##X##_value_t; \ \ typedef struct clist_##X##_node { \ @@ -97,12 +97,12 @@ __pos = ctype##_emplace_after(__self, __pos, __arr[__i]); \ } while (0) -c_clist_types(void, int); +typedef_clist_types(void, int); STC_API size_t _clist_size(const clist_void* self); -#define c_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \ +#define typedef_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \ \ - c_clist_types(X, Value); \ + typedef_clist_types(X, Value); \ typedef RawValue clist_##X##_rawvalue_t; \ typedef clist_##X##_rawvalue_t clist_##X##_input_t; \ \ diff --git a/stc/cmap.h b/stc/cmap.h index 5f18bb00..3192be93 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -23,8 +23,8 @@ /* #include #include -c_cset(sx, int); // Set of int -c_cmap(mx, int, char); // Map of int -> char +typedef_cset(sx, int); // Set of int +typedef_cmap(mx, int, char); // Map of int -> char int main(void) { cset_sx s = cset_ini; @@ -56,10 +56,9 @@ int main(void) { #define cmap_ini {NULL, NULL, 0, 0, 0.85f, 0.15f} #define cmap_empty(m) ((m).size == 0) #define cmap_size(m) ((size_t) (m).size) -#define cmap_bucket_count(m) ((size_t) (m).bucket_count) #define cset_ini cmap_ini +#define cset_empty(s) cmap_empty(s) #define cset_size(s) cmap_size(s) -#define cset_bucket_count(s) cmap_bucket_count(s) #define c_try_emplace(self, ctype, key, val) do { \ ctype##_result_t __r = ctype##_insert_key_(self, key); \ @@ -77,72 +76,72 @@ int main(void) { enum {chash_HASH = 0x7f, chash_USED = 0x80}; typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; -#define c_cmap(...) \ - c_MACRO_OVERLOAD(c_cmap, __VA_ARGS__) +#define typedef_cmap(...) \ + c_MACRO_OVERLOAD(typedef_cmap, __VA_ARGS__) -#define c_cmap_3(X, Key, Mapped) \ - c_cmap_4(X, Key, Mapped, c_default_destroy) +#define typedef_cmap_3(X, Key, Mapped) \ + typedef_cmap_4(X, Key, Mapped, c_default_destroy) -#define c_cmap_4(X, Key, Mapped, valueDestroy) \ - c_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16) +#define typedef_cmap_4(X, Key, Mapped, valueDestroy) \ + typedef_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16) -#define c_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \ - c_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \ +#define typedef_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \ + typedef_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \ c_default_destroy, Key, c_default_to_raw, c_default_from_raw) -#define c_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ +#define typedef_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ keyDestroy, RawKey, keyToRaw, keyFromRaw) \ - _c_declare_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ + _c_typedef_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ keyDestroy, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw) /* cset: */ -#define c_cset(...) \ - c_MACRO_OVERLOAD(c_cset, __VA_ARGS__) +#define typedef_cset(...) \ + c_MACRO_OVERLOAD(typedef_cset, __VA_ARGS__) -#define c_cset_2(X, Key) \ - c_cset_4(X, Key, c_default_equals, c_default_hash16) +#define typedef_cset_2(X, Key) \ + typedef_cset_4(X, Key, c_default_equals, c_default_hash16) -#define c_cset_4(X, Key, keyEquals, keyHash) \ - c_cset_5(X, Key, keyEquals, keyHash, c_default_destroy) +#define typedef_cset_4(X, Key, keyEquals, keyHash) \ + typedef_cset_5(X, Key, keyEquals, keyHash, c_default_destroy) -#define c_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \ - c_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \ +#define typedef_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \ + typedef_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \ Key, c_default_to_raw, c_default_from_raw) -#define c_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \ +#define typedef_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \ RawKey, keyToRaw, keyFromRaw) \ - _c_declare_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \ + _c_typedef_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \ keyDestroy, RawKey, keyToRaw, keyFromRaw, void, c_default_from_raw) /* cset_str, cmap_str, cmap_strkey, cmap_strval: */ -#define c_cset_str() \ +#define typedef_cset_str() \ _c_declare_CHASH_strkey(str, cset, cstr_t, void) -#define c_cmap_str() \ - _c_declare_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \ +#define typedef_cmap_str() \ + _c_typedef_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \ cstr_destroy, const char*, cstr_to_raw, cstr, const char*, cstr) -#define c_cmap_strkey(...) \ - c_MACRO_OVERLOAD(c_cmap_strkey, __VA_ARGS__) +#define typedef_cmap_strkey(...) \ + c_MACRO_OVERLOAD(typedef_cmap_strkey, __VA_ARGS__) -#define c_cmap_strkey_2(X, Mapped) \ +#define typedef_cmap_strkey_2(X, Mapped) \ _c_declare_CHASH_strkey(X, cmap, Mapped, c_default_destroy) -#define c_cmap_strkey_3(X, Mapped, ValueDestroy) \ +#define typedef_cmap_strkey_3(X, Mapped, ValueDestroy) \ _c_declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy) -#define c_cmap_strval(...) \ - c_MACRO_OVERLOAD(c_cmap_strval, __VA_ARGS__) +#define typedef_cmap_strval(...) \ + c_MACRO_OVERLOAD(typedef_cmap_strval, __VA_ARGS__) -#define c_cmap_strval_2(X, Key) \ - c_cmap_strval_4(X, Key, c_default_equals, c_default_hash16) +#define typedef_cmap_strval_2(X, Key) \ + typedef_cmap_strval_4(X, Key, c_default_equals, c_default_hash16) -#define c_cmap_strval_4(X, Key, keyEquals, keyHash) \ - _c_declare_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \ +#define typedef_cmap_strval_4(X, Key, keyEquals, keyHash) \ + _c_typedef_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \ c_default_destroy, Key, c_default_to_raw, c_default_from_raw, const char*, cstr) #define _c_declare_CHASH_strkey(X, ctype, Mapped, valueDestroy) \ - _c_declare_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \ + _c_typedef_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \ cstr_destroy, const char*, cstr_to_raw, cstr, Mapped, c_default_from_raw) #define CSET_ONLY_cset(...) __VA_ARGS__ @@ -153,7 +152,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; #define KEY_NAME_cmap first /* CHASH full: use 'void' for Mapped if ctype is cset */ -#define _c_declare_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ +#define _c_typedef_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \ keyDestroy, RawKey, keyToRaw, keyFromRaw, RawVal, valueFromRaw) \ typedef Key ctype##_##X##_key_t; \ typedef Mapped ctype##_##X##_mapped_t; \ @@ -201,6 +200,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t; STC_INLINE size_t \ ctype##_##X##_size(ctype##_##X m) {return (size_t) m.size;} \ STC_INLINE size_t \ + ctype##_##X##_bucket_count(ctype##_##X m) {return (size_t) m.bucket_count;} \ + STC_INLINE size_t \ ctype##_##X##_capacity(ctype##_##X m) {return (size_t) (m.bucket_count * m.max_load_factor);} \ STC_INLINE void \ ctype##_##X##_swap(ctype##_##X* a, ctype##_##X* b) {c_swap(ctype##_##X, *a, *b);} \ diff --git a/stc/cpqueue.h b/stc/cpqueue.h index e65c67e0..7b2a02ad 100644 --- a/stc/cpqueue.h +++ b/stc/cpqueue.h @@ -25,8 +25,8 @@ #include #include - c_cvec(f, float); - c_cpqueue(f, cvec_f, >); // min-heap (increasing values) + typedef_cvec(f, float); + typedef_cpqueue(f, cvec_f, >); // min-heap (increasing values) int main() { crand_rng32_t gen = crand_rng32_init(1234); @@ -50,7 +50,7 @@ #include "cvec.h" -#define c_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \ +#define typedef_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \ \ typedef struct ctype cpqueue_##X; \ typedef ctype##_value_t cpqueue_##X##_value_t; \ diff --git a/stc/cqueue.h b/stc/cqueue.h index c4e095d8..3962f3d8 100644 --- a/stc/cqueue.h +++ b/stc/cqueue.h @@ -25,8 +25,8 @@ #include #include - c_clist(i, int); - c_cqueue(i, clist_i); // min-heap (increasing values) + typedef_clist(i, int); + typedef_cqueue(i, clist_i); // min-heap (increasing values) int main() { int n = 10000000; @@ -58,7 +58,7 @@ #include "clist.h" -#define c_cqueue(X, ctype) \ +#define typedef_cqueue(X, ctype) \ \ typedef struct ctype cqueue_##X; \ typedef ctype##_value_t cqueue_##X##_value_t; \ diff --git a/stc/cstack.h b/stc/cstack.h index 97e7a0e2..f6a5777e 100644 --- a/stc/cstack.h +++ b/stc/cstack.h @@ -26,8 +26,8 @@ #include #include - c_cvec(i, int); - c_cstack(i, cvec_i); + typedef_cvec(i, int); + typedef_cstack(i, cvec_i); int main() { cstack_i stack = cstack_i_init(); @@ -47,7 +47,7 @@ #include "cvec.h" -#define c_cstack(X, ctype) \ +#define typedef_cstack(X, ctype) \ \ typedef struct ctype cstack_##X; \ typedef ctype##_value_t cstack_##X##_value_t; \ diff --git a/stc/cvec.h b/stc/cvec.h index f3ab9325..0b664c9c 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -32,18 +32,18 @@ #define cvec_capacity(v) _cvec_safe_capacity((v).data) #define cvec_empty(v) (cvec_size(v) == 0) -#define c_cvec(...) c_MACRO_OVERLOAD(c_cvec, __VA_ARGS__) -#define c_cvec_2(X, Value) \ - c_cvec_3(X, Value, c_default_destroy) -#define c_cvec_3(X, Value, valueDestroy) \ - c_cvec_4(X, Value, valueDestroy, c_default_compare) -#define c_cvec_4(X, Value, valueDestroy, valueCompare) \ - c_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw) -#define c_cvec_str() \ - c_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr) +#define typedef_cvec(...) c_MACRO_OVERLOAD(typedef_cvec, __VA_ARGS__) +#define typedef_cvec_2(X, Value) \ + typedef_cvec_3(X, Value, c_default_destroy) +#define typedef_cvec_3(X, Value, valueDestroy) \ + typedef_cvec_4(X, Value, valueDestroy, c_default_compare) +#define typedef_cvec_4(X, Value, valueDestroy, valueCompare) \ + typedef_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw) +#define typedef_cvec_str() \ + typedef_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr) -#define c_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \ +#define typedef_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \ \ typedef struct cvec_##X { \ Value* data; \ -- cgit v1.2.3