From f68e2c08549c2959b6d17c2a07d24001388b0301 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 30 Apr 2021 13:57:24 +0200 Subject: Internal only: Removed cstr_t and cbits_t: only use cstr and cbits. Finished backporting of csmap_v1.h --- benchmarks/others/clist_v1.h | 2 +- benchmarks/others/csmap_v1.h | 54 ++++++++++++--- docs/ccommon_api.md | 2 +- examples/bits.c | 2 +- stc/cbits.h | 98 +++++++++++++------------- stc/cdeq.h | 2 +- stc/clist.h | 2 +- stc/cmap.h | 6 +- stc/cset.h | 2 +- stc/csmap.h | 6 +- stc/csset.h | 2 +- stc/cstr.h | 160 +++++++++++++++++++++---------------------- stc/cvec.h | 2 +- 13 files changed, 187 insertions(+), 153 deletions(-) diff --git a/benchmarks/others/clist_v1.h b/benchmarks/others/clist_v1.h index c2fd7164..0887d5b3 100644 --- a/benchmarks/others/clist_v1.h +++ b/benchmarks/others/clist_v1.h @@ -69,7 +69,7 @@ _c_using_clist(clist_##X, Value, valueCompare, valueDel, valueFromRaw, valueToRaw, RawValue) #define using_clist_str() \ - _c_using_clist(clist_str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) + _c_using_clist(clist_str, cstr, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) #define _c_using_clist_types(CX, Value) \ diff --git a/benchmarks/others/csmap_v1.h b/benchmarks/others/csmap_v1.h index 1164d509..1d65b516 100644 --- a/benchmarks/others/csmap_v1.h +++ b/benchmarks/others/csmap_v1.h @@ -75,9 +75,9 @@ int main(void) { /* csset_str, csmap_str, csmap_strkey, csmap_strval: */ #define using_csset_str() \ - _c_using_aatree_strkey(str, csset_, cstr_t, @@, @@) + _c_using_aatree_strkey(str, csset_, cstr, @@, @@) #define using_csmap_str() \ - _c_using_aatree(csmap_str, csmap_, cstr_t, cstr_t, cstr_compare_raw, cstr_del, cstr_del, \ + _c_using_aatree(csmap_str, csmap_, cstr, cstr, cstr_compare_raw, cstr_del, cstr_del, \ cstr_from, cstr_c_str, const char*, cstr_from, cstr_c_str, const char*) @@ -88,7 +88,7 @@ int main(void) { #define using_csmap_strkey_4(X, Mapped, mappedDel, mappedClone) \ _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedClone) #define _c_using_aatree_strkey(X, C, Mapped, mappedDel, mappedClone) \ - _c_using_aatree(C##X, C, cstr_t, Mapped, cstr_compare_raw, mappedDel, cstr_del, \ + _c_using_aatree(C##X, C, cstr, Mapped, cstr_compare_raw, mappedDel, cstr_del, \ cstr_from, cstr_c_str, const char*, mappedClone, c_trivial_toraw, Mapped) @@ -101,7 +101,7 @@ int main(void) { #define using_csmap_strval_5(X, Key, keyCompare, keyDel, keyClone) \ using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key) #define using_csmap_strval_7(X, Key, keyCompare, keyDel, keyFromRaw, keyToRaw, RawKey) \ - _c_using_aatree(csmap_##X, csmap_, Key, cstr_t, keyCompare, cstr_del, keyDel, \ + _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompare, cstr_del, keyDel, \ keyFromRaw, keyToRaw, RawKey, cstr_from, cstr_c_str, const char*) #define SET_ONLY_csset_(...) __VA_ARGS__ @@ -156,6 +156,9 @@ int main(void) { \ STC_API CX CX##_init(void); \ STC_API CX##_value_t* CX##_find_it(const CX* self, RawKey rkey, CX##_iter_t* out); \ + STC_API CX##_iter_t CX##_lower_bound(const CX* self, RawKey rkey); \ + STC_API CX##_iter_t CX##_erase_at(CX* self, CX##_iter_t it); \ + STC_API CX##_iter_t CX##_erase_range(CX* self, CX##_iter_t it1, CX##_iter_t it2); \ STC_API CX##_node_t* CX##_erase_r_(CX##_node_t *tn, const CX##_rawkey_t* rkey, int *erased); \ STC_API void CX##_del_r_(CX##_node_t* tn); \ STC_API CX##_node_t* CX##_clone_r_(CX##_node_t *tn); \ @@ -167,7 +170,7 @@ int main(void) { STC_INLINE void CX##_del(CX* self) {CX##_del_r_(self->root);} \ STC_INLINE void CX##_clear(CX* self) {CX##_del(self); *self = CX##_init();} \ STC_INLINE void CX##_swap(CX* a, CX* b) {c_swap(CX, *a, *b);} \ - STC_INLINE CX CX##_clone(CX t) {CX c = {CX##_clone_r_(t.root), t.size}; return c;} \ + STC_INLINE CX CX##_clone(CX m) {CX c = {CX##_clone_r_(m.root), m.size}; return c;} \ STC_INLINE CX##_iter_t CX##_find(const CX* self, RawKey rkey) \ {CX##_iter_t it; CX##_find_it(self, rkey, &it); return it;} \ STC_INLINE bool CX##_contains(const CX* self, RawKey rkey) \ @@ -270,11 +273,6 @@ int main(void) { self->root = CX##_erase_r_(self->root, &rkey, &erased); \ self->size -= erased; return erased; \ } \ -\ - STC_INLINE size_t \ - CX##_erase_at(CX* self, CX##_iter_t it) { \ - return CX##_erase(self, keyToRaw(KEY_REF_##C(it.ref))); \ - } \ \ _c_implement_aatree(CX, C, Key, Mapped, keyCompareRaw, mappedDel, keyDel, \ keyFromRaw, keyToRaw, RawKey, mappedFromRaw, mappedToRaw, RawMapped) \ @@ -303,6 +301,18 @@ int main(void) { } \ return (out->ref = NULL); \ } \ +\ + STC_DEF CX##_iter_t \ + CX##_lower_bound(const CX* self, RawKey rkey) { \ + CX##_iter_t it; \ + CX##_find_it(self, rkey, &it); \ + if (!it.ref && it._top) { \ + CX##_node_t *tn = it._st[--it._top]; \ + it._tn = tn->link[1]; \ + it.ref = &tn->value; \ + } \ + return it; \ + } \ \ STC_DEF void \ CX##_next(CX##_iter_t *it) { \ @@ -373,6 +383,30 @@ int main(void) { self->size += res.inserted; \ return res; \ } \ +\ + STC_DEF CX##_iter_t \ + CX##_erase_at(CX* self, CX##_iter_t it) { \ + CX##_rawkey_t raw = keyToRaw(KEY_REF_##C(it.ref)), nxt; \ + CX##_next(&it); \ + if (it.ref) nxt = keyToRaw(KEY_REF_##C(it.ref)); \ + CX##_erase(self, raw); \ + if (it.ref) CX##_find_it(self, nxt, &it); \ + return it; \ + } \ +\ + STC_DEF CX##_iter_t \ + CX##_erase_range(CX* self, CX##_iter_t it1, CX##_iter_t it2) { \ + if (!it2.ref) { while (it1.ref) it1 = CX##_erase_at(self, it1); \ + return it1; } \ + CX##_key_t k1 = *KEY_REF_##C(it1.ref), k2 = *KEY_REF_##C(it2.ref); \ + CX##_rawkey_t r1 = keyToRaw(&k1); \ + for (;;) { \ + if (memcmp(&k1, &k2, sizeof k1) == 0) return it1; \ + CX##_next(&it1); k1 = *KEY_REF_##C(it1.ref); \ + CX##_erase(self, r1); \ + CX##_find_it(self, (r1 = keyToRaw(&k1)), &it1); \ + } \ + } \ \ STC_DEF CX##_node_t* \ CX##_erase_r_(CX##_node_t *tn, const CX##_rawkey_t* rkey, int *erased) { \ diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md index cabd2711..ec546dd6 100644 --- a/docs/ccommon_api.md +++ b/docs/ccommon_api.md @@ -71,7 +71,7 @@ cvec_str readFile(const char* name) { // Next line declares, opens, and closes the FILE* c_withfile (fp, fopen(name, "r")) { - cstr_t line = cstr_init(); + cstr line = cstr_init(); while (cstr_getline(&line, fp)) cvec_str_emplace_back(&vec, line.str); cstr_del(&line); diff --git a/examples/bits.c b/examples/bits.c index c8b037a2..e7b843fb 100644 --- a/examples/bits.c +++ b/examples/bits.c @@ -34,7 +34,7 @@ int main() { printf("%d", cbits_test(set, i)); puts(""); - cbits_t s2 = cbits_clone(set); + cbits s2 = cbits_clone(set); cbits_flip_all(&s2); cbits_set(&s2, 16); cbits_set(&s2, 17); diff --git a/stc/cbits.h b/stc/cbits.h index 0da46f11..4c708a7d 100644 --- a/stc/cbits.h +++ b/stc/cbits.h @@ -30,7 +30,7 @@ Similar to boost::dynamic_bitset / std::bitset #include "cbits.h" int main() { - cbits_t bset = cbits_with_size(23, true); + cbits bset = cbits_with_size(23, true); cbits_reset(&bset, 9); cbits_resize(&bset, 43, false); @@ -55,89 +55,89 @@ int main() { #include #include "ccommon.h" -typedef struct cbits { +typedef struct { uint64_t *at64; size_t size; -} cbits, cbits_t; - -STC_API cbits_t cbits_with_size(size_t size, bool value); -STC_API cbits_t cbits_with_values(size_t size, uint64_t pattern); -STC_API cbits_t cbits_from_str(const char* str); -STC_API char* cbits_to_str(cbits_t set, char* str, size_t start, intptr_t stop); -STC_API cbits_t cbits_clone(cbits_t other); -STC_API void cbits_resize(cbits_t* self, size_t size, bool value); -STC_API cbits_t* cbits_assign(cbits_t* self, cbits_t other); -STC_API size_t cbits_count(cbits_t set); -STC_API bool cbits_subset_of(cbits_t set, cbits_t other); -STC_API bool cbits_disjoint(cbits_t set, cbits_t other); - -STC_INLINE cbits_t cbits_init() { cbits_t set = {NULL, 0}; return set; } -STC_INLINE void cbits_clear(cbits_t* self) { self->size = 0; } -STC_INLINE void cbits_del(cbits_t* self) { c_free(self->at64); } -STC_INLINE size_t cbits_size(cbits_t set) { return set.size; } - -STC_INLINE cbits_t* cbits_take(cbits_t* self, cbits_t other) { +} cbits; + +STC_API cbits cbits_with_size(size_t size, bool value); +STC_API cbits cbits_with_values(size_t size, uint64_t pattern); +STC_API cbits cbits_from_str(const char* str); +STC_API char* cbits_to_str(cbits set, char* str, size_t start, intptr_t stop); +STC_API cbits cbits_clone(cbits other); +STC_API void cbits_resize(cbits* self, size_t size, bool value); +STC_API cbits* cbits_assign(cbits* self, cbits other); +STC_API size_t cbits_count(cbits set); +STC_API bool cbits_subset_of(cbits set, cbits other); +STC_API bool cbits_disjoint(cbits set, cbits other); + +STC_INLINE cbits cbits_init() { cbits set = {NULL, 0}; return set; } +STC_INLINE void cbits_clear(cbits* self) { self->size = 0; } +STC_INLINE void cbits_del(cbits* self) { c_free(self->at64); } +STC_INLINE size_t cbits_size(cbits set) { return set.size; } + +STC_INLINE cbits* cbits_take(cbits* self, cbits other) { if (self->at64 != other.at64) {cbits_del(self); *self = other;} return self; } -STC_INLINE cbits_t cbits_move(cbits_t* self) { - cbits_t tmp = *self; self->at64 = NULL, self->size = 0; +STC_INLINE cbits cbits_move(cbits* self) { + cbits tmp = *self; self->at64 = NULL, self->size = 0; return tmp; } -STC_INLINE bool cbits_test(cbits_t set, size_t i) { +STC_INLINE bool cbits_test(cbits set, size_t i) { return (set.at64[i >> 6] & (1ull << (i & 63))) != 0; } -STC_INLINE bool cbits_at(cbits_t set, size_t i) { +STC_INLINE bool cbits_at(cbits set, size_t i) { return (set.at64[i >> 6] & (1ull << (i & 63))) != 0; } -STC_INLINE void cbits_set(cbits_t *self, size_t i) { +STC_INLINE void cbits_set(cbits *self, size_t i) { self->at64[i >> 6] |= 1ull << (i & 63); } -STC_INLINE void cbits_reset(cbits_t *self, size_t i) { +STC_INLINE void cbits_reset(cbits *self, size_t i) { self->at64[i >> 6] &= ~(1ull << (i & 63)); } -STC_INLINE void cbits_set_value(cbits_t *self, size_t i, bool value) { +STC_INLINE void cbits_set_value(cbits *self, size_t i, bool value) { self->at64[i >> 6] ^= (-(uint64_t)value ^ self->at64[i >> 6]) & 1ull << (i & 63); } -STC_INLINE void cbits_flip(cbits_t *self, size_t i) { +STC_INLINE void cbits_flip(cbits *self, size_t i) { self->at64[i >> 6] ^= 1ull << (i & 63); } -STC_INLINE void cbits_set_all(cbits_t *self, bool value) { +STC_INLINE void cbits_set_all(cbits *self, bool value) { memset(self->at64, -(int)value, ((self->size + 63) >> 6) * 8); } -STC_INLINE void cbits_set_values(cbits_t *self, uint64_t pattern) { +STC_INLINE void cbits_set_values(cbits *self, uint64_t pattern) { size_t n = (self->size + 63) >> 6; for (size_t i=0; iat64[i] = pattern; } -STC_INLINE void cbits_flip_all(cbits_t *self) { +STC_INLINE void cbits_flip_all(cbits *self) { size_t n = (self->size + 63) >> 6; for (size_t i=0; iat64[i] ^= ~0ull; } /* Intersection */ -STC_INLINE void cbits_intersect(cbits_t *self, cbits_t other) { +STC_INLINE void cbits_intersect(cbits *self, cbits other) { assert(self->size == other.size); size_t n = (self->size + 63) >> 6; for (size_t i=0; iat64[i] &= other.at64[i]; } /* Union */ -STC_INLINE void cbits_union(cbits_t *self, cbits_t other) { +STC_INLINE void cbits_union(cbits *self, cbits other) { assert(self->size == other.size); size_t n = (self->size + 63) >> 6; for (size_t i=0; iat64[i] |= other.at64[i]; } /* Exclusive disjunction */ -STC_INLINE void cbits_xor(cbits_t *self, cbits_t other) { +STC_INLINE void cbits_xor(cbits *self, cbits other) { assert(self->size == other.size); size_t n = (self->size + 63) >> 6; for (size_t i=0; iat64[i] ^= other.at64[i]; @@ -159,14 +159,14 @@ STC_INLINE void cbits_xor(cbits_t *self, cbits_t other) { #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -STC_DEF cbits_t* cbits_assign(cbits_t* self, cbits_t other) { +STC_DEF cbits* cbits_assign(cbits* self, cbits other) { if (self->at64 == other.at64) return self; if (self->size != other.size) return cbits_take(self, cbits_clone(other)); memcpy(self->at64, other.at64, ((other.size + 63) >> 6)*8); return self; } -STC_DEF void cbits_resize(cbits_t* self, size_t size, bool value) { +STC_DEF void cbits_resize(cbits* self, size_t size, bool value) { size_t new_n = (size + 63) >> 6, osize = self->size, old_n = (osize + 63) >> 6; self->at64 = (uint64_t *) c_realloc(self->at64, new_n * 8); self->size = size; @@ -179,33 +179,33 @@ STC_DEF void cbits_resize(cbits_t* self, size_t size, bool value) { } } -STC_DEF cbits_t cbits_with_size(size_t size, bool value) { - cbits_t set = {(uint64_t *) c_malloc(((size + 63) >> 6) * 8), size}; +STC_DEF cbits cbits_with_size(size_t size, bool value) { + cbits set = {(uint64_t *) c_malloc(((size + 63) >> 6) * 8), size}; cbits_set_all(&set, value); return set; } -STC_DEF cbits_t cbits_with_values(size_t size, uint64_t pattern) { - cbits_t set = {(uint64_t *) c_malloc(((size + 63) >> 6) * 8), size}; +STC_DEF cbits cbits_with_values(size_t size, uint64_t pattern) { + cbits set = {(uint64_t *) c_malloc(((size + 63) >> 6) * 8), size}; cbits_set_values(&set, pattern); return set; } -STC_DEF cbits_t cbits_from_str(const char* str) { +STC_DEF cbits cbits_from_str(const char* str) { const char* p = str; while (*p) ++p; - cbits_t set = cbits_with_size(p - str, false); + cbits set = cbits_with_size(p - str, false); for (size_t i=0; i> 6) * 8; - cbits_t set = {(uint64_t *) memcpy(c_malloc(bytes), other.at64, bytes), other.size}; + cbits set = {(uint64_t *) memcpy(c_malloc(bytes), other.at64, bytes), other.size}; return set; } -STC_DEF size_t cbits_count(cbits_t s) { +STC_DEF size_t cbits_count(cbits s) { size_t count = 0, n = s.size >> 6; for (size_t i = 0; i < n; ++i) count += cpopcount64(s.at64[i]); if (s.size & 63) count += cpopcount64(s.at64[n] & ((1ull << (s.size & 63)) - 1)); @@ -222,8 +222,8 @@ STC_DEF size_t cbits_count(cbits_t s) { uint64_t i = n, m = (1ull << (s.size & 63)) - 1; \ return ((s.at64[i] OPR other.at64[i]) & m) == (x & m) -STC_DEF bool cbits_subset_of(cbits_t s, cbits_t other) { _cbits_SETOP(|, s.at64[i]); } -STC_DEF bool cbits_disjoint(cbits_t s, cbits_t other) { _cbits_SETOP(&, 0); } +STC_DEF bool cbits_subset_of(cbits s, cbits other) { _cbits_SETOP(|, s.at64[i]); } +STC_DEF bool cbits_disjoint(cbits s, cbits other) { _cbits_SETOP(&, 0); } #endif #endif diff --git a/stc/cdeq.h b/stc/cdeq.h index b122248a..f4ed7159 100644 --- a/stc/cdeq.h +++ b/stc/cdeq.h @@ -41,7 +41,7 @@ _c_using_cdeq(cdeq_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #define using_cdeq_str() \ - _c_using_cdeq(cdeq_str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) + _c_using_cdeq(cdeq_str, cstr, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) struct cdeq_rep { size_t size, cap; void* base[]; }; diff --git a/stc/clist.h b/stc/clist.h index dbdac503..d44636a8 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -69,7 +69,7 @@ _c_using_clist(clist_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #define using_clist_str() \ - _c_using_clist(clist_str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) + _c_using_clist(clist_str, cstr, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) #define _c_using_clist_types(CX, Value) \ diff --git a/stc/cmap.h b/stc/cmap.h index 4994ce7f..daefb9e9 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -90,7 +90,7 @@ int main(void) { keyDel, keyFromRaw, keyToRaw, RawKey) #define using_cmap_str() \ - _c_using_chash(cmap_str, cmap_, cstr_t, cstr_t, cstr_equals_raw, cstr_hash_raw, \ + _c_using_chash(cmap_str, cmap_, cstr, cstr, cstr_equals_raw, cstr_hash_raw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ cstr_del, cstr_from, cstr_c_str, const char*) @@ -107,7 +107,7 @@ int main(void) { _c_using_chash_strkey(X, cmap_, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) #define _c_using_chash_strkey(X, C, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ - _c_using_chash(C##X, C, cstr_t, Mapped, cstr_equals_raw, cstr_hash_raw, \ + _c_using_chash(C##X, C, cstr, Mapped, cstr_equals_raw, cstr_hash_raw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ cstr_del, cstr_from, cstr_c_str, const char*) @@ -124,7 +124,7 @@ int main(void) { using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, keyClone, c_trivial_toraw, Key) #define using_cmap_strval_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ - _c_using_chash(cmap_##X, cmap_, Key, cstr_t, keyEqualsRaw, keyHashRaw, \ + _c_using_chash(cmap_##X, cmap_, Key, cstr, keyEqualsRaw, keyHashRaw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) diff --git a/stc/cset.h b/stc/cset.h index cae23b80..f8ccc511 100644 --- a/stc/cset.h +++ b/stc/cset.h @@ -62,7 +62,7 @@ int main(void) { /* cset_str: */ #define using_cset_str() \ - _c_using_chash_strkey(str, cset_, cstr_t, @@, @@, @@, void) + _c_using_chash_strkey(str, cset_, cstr, @@, @@, @@, void) #define SET_ONLY_cset_(...) __VA_ARGS__ #define MAP_ONLY_cset_(...) diff --git a/stc/csmap.h b/stc/csmap.h index fc1e37a5..6fe35118 100644 --- a/stc/csmap.h +++ b/stc/csmap.h @@ -85,7 +85,7 @@ int main(void) { keyDel, keyFromRaw, keyToRaw, RawKey) #define using_csmap_str() \ - _c_using_aatree(csmap_str, csmap_, cstr_t, cstr_t, cstr_compare_raw, \ + _c_using_aatree(csmap_str, csmap_, cstr, cstr, cstr_compare_raw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ cstr_del, cstr_from, cstr_c_str, const char*) @@ -102,7 +102,7 @@ int main(void) { _c_using_aatree_strkey(X, csmap_, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) #define _c_using_aatree_strkey(X, C, Mapped, mappedDel, mappedFromRaw, mappedToRaw, RawMapped) \ - _c_using_aatree(C##X, C, cstr_t, Mapped, cstr_compare_raw, \ + _c_using_aatree(C##X, C, cstr, Mapped, cstr_compare_raw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ cstr_del, cstr_from, cstr_c_str, const char*) @@ -119,7 +119,7 @@ int main(void) { using_csmap_strval_7(X, Key, keyCompare, keyDel, keyClone, c_trivial_toraw, Key) #define using_csmap_strval_7(X, Key, keyCompareRaw, keyDel, keyFromRaw, keyToRaw, RawKey) \ - _c_using_aatree(csmap_##X, csmap_, Key, cstr_t, keyCompareRaw, \ + _c_using_aatree(csmap_##X, csmap_, Key, cstr, keyCompareRaw, \ cstr_del, cstr_from, cstr_c_str, const char*, \ keyDel, keyFromRaw, keyToRaw, RawKey) diff --git a/stc/csset.h b/stc/csset.h index 7d02b055..48ad6656 100644 --- a/stc/csset.h +++ b/stc/csset.h @@ -62,7 +62,7 @@ int main(void) { @@, @@, @@, void, keyDel, keyFromRaw, keyToRaw, RawKey) #define using_csset_str() \ - _c_using_aatree_strkey(str, csset_, cstr_t, @@, @@, @@, void) + _c_using_aatree_strkey(str, csset_, cstr, @@, @@, @@, void) #define SET_ONLY_csset_(...) __VA_ARGS__ #define MAP_ONLY_csset_(...) diff --git a/stc/cstr.h b/stc/cstr.h index 44d79c72..2bdcf3a0 100644 --- a/stc/cstr.h +++ b/stc/cstr.h @@ -30,138 +30,138 @@ #include /* vsnprintf */ #include -typedef struct { char* str; } cstr, cstr_t; +typedef struct { char* str; } cstr; typedef struct { char *ref; } cstr_iter_t; typedef char cstr_value_t; #define cstr_npos ((size_t) (-1)) struct cstr_rep { size_t size, cap; char str[sizeof(size_t)]; }; #define _cstr_rep(self) c_container_of((self)->str, struct cstr_rep, str) -STC_LIBRARY_ONLY( extern const cstr_t cstr_inits; ) +STC_LIBRARY_ONLY( extern const cstr cstr_inits; ) STC_STATIC_ONLY( static struct cstr_rep _cstr_nullrep = {0, 0, {0}}; - static const cstr_t cstr_inits = {_cstr_nullrep.str}; ) + static const cstr cstr_inits = {_cstr_nullrep.str}; ) /* optimal memory: based on malloc_usable_size() sequence: 24, 40, 56, ... */ #define _cstr_opt_mem(cap) ((((offsetof(struct cstr_rep, str) + (cap) + 8)>>4)<<4) + 8) /* optimal string capacity: 7, 23, 39, ... */ #define _cstr_opt_cap(cap) (_cstr_opt_mem(cap) - offsetof(struct cstr_rep, str) - 1) -STC_API cstr_t cstr_from_n(const char* str, size_t n); -STC_API cstr_t cstr_from_fmt(const char* fmt, ...); -STC_API void cstr_fmt(cstr_t* self, const char* fmt, ...); -STC_API size_t cstr_reserve(cstr_t* self, size_t cap); -STC_API void cstr_resize(cstr_t* self, size_t len, char fill); -STC_API cstr_t* cstr_assign_n(cstr_t* self, const char* str, size_t n); -STC_API cstr_t* cstr_append_n(cstr_t* self, const char* str, size_t n); -STC_API void cstr_replace_n(cstr_t* self, size_t pos, size_t len, const char* str, size_t n); -STC_API void cstr_erase_n(cstr_t* self, size_t pos, size_t n); -STC_API size_t cstr_find(cstr_t s, const char* needle); -STC_API size_t cstr_find_n(cstr_t s, const char* needle, size_t pos, size_t n); -STC_API size_t cstr_ifind_n(cstr_t s, const char* needle, size_t pos, size_t n); -STC_API bool cstr_getdelim(cstr_t *self, int delim, FILE *stream); +STC_API cstr cstr_from_n(const char* str, size_t n); +STC_API cstr cstr_from_fmt(const char* fmt, ...); +STC_API void cstr_fmt(cstr* self, const char* fmt, ...); +STC_API size_t cstr_reserve(cstr* self, size_t cap); +STC_API void cstr_resize(cstr* self, size_t len, char fill); +STC_API cstr* cstr_assign_n(cstr* self, const char* str, size_t n); +STC_API cstr* cstr_append_n(cstr* self, const char* str, size_t n); +STC_API void cstr_replace_n(cstr* self, size_t pos, size_t len, const char* str, size_t n); +STC_API void cstr_erase_n(cstr* self, size_t pos, size_t n); +STC_API size_t cstr_find(cstr s, const char* needle); +STC_API size_t cstr_find_n(cstr s, const char* needle, size_t pos, size_t n); +STC_API size_t cstr_ifind_n(cstr s, const char* needle, size_t pos, size_t n); +STC_API bool cstr_getdelim(cstr *self, int delim, FILE *stream); STC_API int c_strncasecmp(const char* s1, const char* s2, size_t n); STC_API char* c_strnstr(const char* s, const char* needle, size_t nmax); STC_API char* c_strncasestr(const char* s, const char* needle, size_t nmax); -STC_INLINE cstr_t cstr_init() { return cstr_inits; } -STC_INLINE size_t cstr_size(cstr_t s) { return _cstr_rep(&s)->size; } -STC_INLINE size_t cstr_capacity(cstr_t s) { return _cstr_rep(&s)->cap; } -STC_INLINE size_t cstr_empty(cstr_t s) { return _cstr_rep(&s)->size == 0; } -STC_INLINE size_t cstr_length(cstr_t s) { return _cstr_rep(&s)->size; } -STC_INLINE void cstr_del(cstr_t* self) +STC_INLINE cstr cstr_init() { return cstr_inits; } +STC_INLINE size_t cstr_size(cstr s) { return _cstr_rep(&s)->size; } +STC_INLINE size_t cstr_capacity(cstr s) { return _cstr_rep(&s)->cap; } +STC_INLINE size_t cstr_empty(cstr s) { return _cstr_rep(&s)->size == 0; } +STC_INLINE size_t cstr_length(cstr s) { return _cstr_rep(&s)->size; } +STC_INLINE void cstr_del(cstr* self) { if (_cstr_rep(self)->cap) c_free(_cstr_rep(self)); } -STC_INLINE cstr_t cstr_from(const char* str) +STC_INLINE cstr cstr_from(const char* str) { return cstr_from_n(str, strlen(str)); } -STC_INLINE cstr_t cstr_clone(cstr_t s) +STC_INLINE cstr cstr_clone(cstr s) { return cstr_from_n(s.str, _cstr_rep(&s)->size); } -STC_INLINE void cstr_clear(cstr_t* self) +STC_INLINE void cstr_clear(cstr* self) { self->str[_cstr_rep(self)->size = 0] = '\0'; } -STC_INLINE cstr_t* cstr_assign(cstr_t* self, const char* str) +STC_INLINE cstr* cstr_assign(cstr* self, const char* str) { return cstr_assign_n(self, str, strlen(str)); } -STC_INLINE cstr_t* cstr_assign_s(cstr_t* self, cstr s) +STC_INLINE cstr* cstr_assign_s(cstr* self, cstr s) { return cstr_assign_n(self, s.str, _cstr_rep(&s)->size); } -STC_INLINE cstr_t* cstr_append(cstr_t* self, const char* str) +STC_INLINE cstr* cstr_append(cstr* self, const char* str) { return cstr_append_n(self, str, strlen(str)); } -STC_INLINE cstr_t* cstr_append_s(cstr_t* self, cstr s) +STC_INLINE cstr* cstr_append_s(cstr* self, cstr s) { return cstr_append_n(self, s.str, _cstr_rep(&s)->size); } -STC_INLINE void cstr_push_back(cstr_t* self, char value) +STC_INLINE void cstr_push_back(cstr* self, char value) { cstr_append_n(self, &value, 1); } -STC_INLINE void cstr_pop_back(cstr_t* self) +STC_INLINE void cstr_pop_back(cstr* self) { self->str[ --_cstr_rep(self)->size ] = '\0'; } -STC_INLINE void cstr_insert_n(cstr_t* self, size_t pos, const char* str, size_t n) +STC_INLINE void cstr_insert_n(cstr* self, size_t pos, const char* str, size_t n) { cstr_replace_n(self, pos, 0, str, n); } -STC_INLINE void cstr_insert(cstr_t* self, size_t pos, const char* str) +STC_INLINE void cstr_insert(cstr* self, size_t pos, const char* str) { cstr_replace_n(self, pos, 0, str, strlen(str)); } -STC_INLINE void cstr_insert_s(cstr_t* self, size_t pos, cstr s) +STC_INLINE void cstr_insert_s(cstr* self, size_t pos, cstr s) { cstr_replace_n(self, pos, 0, s.str, _cstr_rep(&s)->size); } -STC_INLINE void cstr_replace(cstr_t* self, size_t pos, size_t len, const char* str) +STC_INLINE void cstr_replace(cstr* self, size_t pos, size_t len, const char* str) { cstr_replace_n(self, pos, len, str, strlen(str)); } -STC_INLINE void cstr_replace_s(cstr_t* self, size_t pos, size_t len, cstr s) +STC_INLINE void cstr_replace_s(cstr* self, size_t pos, size_t len, cstr s) { cstr_replace_n(self, pos, len, s.str, _cstr_rep(&s)->size); } -STC_INLINE void cstr_erase(cstr_t* self, size_t pos) +STC_INLINE void cstr_erase(cstr* self, size_t pos) { cstr_erase_n(self, pos, 1); } -STC_INLINE char* cstr_front(cstr_t* self) { return self->str; } -STC_INLINE char* cstr_back(cstr_t* self) +STC_INLINE char* cstr_front(cstr* self) { return self->str; } +STC_INLINE char* cstr_back(cstr* self) { return self->str + _cstr_rep(self)->size - 1; } -STC_INLINE cstr_iter_t cstr_begin(cstr_t* self) +STC_INLINE cstr_iter_t cstr_begin(cstr* self) { cstr_iter_t it = {self->str}; return it; } -STC_INLINE cstr_iter_t cstr_end(cstr_t* self) +STC_INLINE cstr_iter_t cstr_end(cstr* self) { cstr_iter_t it = {self->str + _cstr_rep(self)->size}; return it; } STC_INLINE void cstr_next(cstr_iter_t* it) {++it->ref; } -STC_INLINE bool cstr_equals(cstr_t s1, const char* str) +STC_INLINE bool cstr_equals(cstr s1, const char* str) { return strcmp(s1.str, str) == 0; } -STC_INLINE bool cstr_equals_s(cstr_t s1, cstr_t s2) +STC_INLINE bool cstr_equals_s(cstr s1, cstr s2) { return strcmp(s1.str, s2.str) == 0; } -STC_INLINE bool cstr_iequals(cstr_t s1, const char* str) +STC_INLINE bool cstr_iequals(cstr s1, const char* str) { return c_strncasecmp(s1.str, str, cstr_npos) == 0; } -STC_INLINE bool cstr_contains(cstr_t s, const char* needle) +STC_INLINE bool cstr_contains(cstr s, const char* needle) { return strstr(s.str, needle) != NULL; } -STC_INLINE bool cstr_icontains(cstr_t s, const char* needle) +STC_INLINE bool cstr_icontains(cstr s, const char* needle) { return c_strncasestr(s.str, needle, cstr_npos) != NULL; } -STC_INLINE bool cstr_begins_with(cstr_t s, const char* needle) +STC_INLINE bool cstr_begins_with(cstr s, const char* needle) { return strncmp(s.str, needle, strlen(needle)) == 0; } -STC_INLINE bool cstr_ibegins_with(cstr_t s, const char* needle) +STC_INLINE bool cstr_ibegins_with(cstr s, const char* needle) { return c_strncasecmp(s.str, needle, strlen(needle)) == 0; } -STC_INLINE bool cstr_getline(cstr_t *self, FILE *stream) +STC_INLINE bool cstr_getline(cstr *self, FILE *stream) { return cstr_getdelim(self, '\n', stream); } -STC_INLINE cstr_t +STC_INLINE cstr cstr_with_capacity(size_t cap) { - cstr_t s = cstr_inits; + cstr s = cstr_inits; cstr_reserve(&s, cap); return s; } -STC_INLINE cstr_t +STC_INLINE cstr cstr_with_size(size_t len, char fill) { - cstr_t s = cstr_inits; + cstr s = cstr_inits; cstr_resize(&s, len, fill); return s; } -STC_INLINE cstr_t* -cstr_take(cstr_t* self, cstr_t s) { +STC_INLINE cstr* +cstr_take(cstr* self, cstr s) { if (self->str != s.str && _cstr_rep(self)->cap) c_free(_cstr_rep(self)); self->str = s.str; return self; } -STC_INLINE cstr_t -cstr_move(cstr_t* self) { - cstr_t tmp = *self; +STC_INLINE cstr +cstr_move(cstr* self) { + cstr tmp = *self; *self = cstr_inits; return tmp; } STC_INLINE bool -cstr_ends_with(cstr_t s, const char* needle) { +cstr_ends_with(cstr s, const char* needle) { size_t n = strlen(needle), sz = _cstr_rep(&s)->size; return n <= sz ? memcmp(s.str + sz - n, needle, n) == 0 : false; } STC_INLINE bool -cstr_iends_with(cstr_t s, const char* needle) { +cstr_iends_with(cstr s, const char* needle) { size_t n = strlen(needle), sz = _cstr_rep(&s)->size; return n <= sz ? c_strncasecmp(s.str + sz - n, needle, n) == 0 : false; } @@ -183,10 +183,10 @@ cstr_iends_with(cstr_t s, const char* needle) { #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) STC_LIBRARY_ONLY( static struct cstr_rep _cstr_nullrep = {0, 0, {0}}; - const cstr_t cstr_inits = {_cstr_nullrep.str}; ) + const cstr cstr_inits = {_cstr_nullrep.str}; ) STC_DEF size_t -cstr_reserve(cstr_t* self, size_t cap) { +cstr_reserve(cstr* self, size_t cap) { struct cstr_rep* rep = _cstr_rep(self); size_t oldcap = rep->cap; if (cap > oldcap) { @@ -199,18 +199,18 @@ cstr_reserve(cstr_t* self, size_t cap) { } STC_DEF void -cstr_resize(cstr_t* self, size_t len, char fill) { +cstr_resize(cstr* self, size_t len, char fill) { size_t n = _cstr_rep(self)->size; cstr_reserve(self, len); if (len > n) memset(self->str + n, fill, len - n); if (len | n) self->str[_cstr_rep(self)->size = len] = '\0'; } -STC_DEF cstr_t +STC_DEF cstr cstr_from_n(const char* str, size_t n) { if (n == 0) return cstr_inits; struct cstr_rep* rep = (struct cstr_rep*) c_malloc(_cstr_opt_mem(n)); - cstr_t s = {(char *) memcpy(rep->str, str, n)}; + cstr s = {(char *) memcpy(rep->str, str, n)}; s.str[rep->size = n] = '\0'; rep->cap = _cstr_opt_cap(n); return s; @@ -225,7 +225,7 @@ cstr_from_n(const char* str, size_t n) { #endif /// STC_DEF void -cstr_vfmt(cstr_t* self, const char* fmt, va_list args) { +cstr_vfmt(cstr* self, const char* fmt, va_list args) { va_list args2; va_copy(args2, args); int len = vsnprintf(NULL, (size_t)0, fmt, args); @@ -242,23 +242,23 @@ cstr_vfmt(cstr_t* self, const char* fmt, va_list args) { #endif STC_DEF void -cstr_fmt(cstr_t* self, const char* fmt, ...) { +cstr_fmt(cstr* self, const char* fmt, ...) { va_list args; va_start(args, fmt); cstr_vfmt(self, fmt, args); va_end(args); } -STC_DEF cstr_t +STC_DEF cstr cstr_from_fmt(const char* fmt, ...) { - cstr_t ret = cstr_inits; + cstr ret = cstr_inits; va_list args; va_start(args, fmt); cstr_vfmt(&ret, fmt, args); va_end(args); return ret; } -STC_DEF cstr_t* -cstr_assign_n(cstr_t* self, const char* str, size_t n) { +STC_DEF cstr* +cstr_assign_n(cstr* self, const char* str, size_t n) { if (n || _cstr_rep(self)->cap) { cstr_reserve(self, n); memmove(self->str, str, n); @@ -267,8 +267,8 @@ cstr_assign_n(cstr_t* self, const char* str, size_t n) { return self; } -STC_DEF cstr_t* -cstr_append_n(cstr_t* self, const char* str, size_t n) { +STC_DEF cstr* +cstr_append_n(cstr* self, const char* str, size_t n) { if (n) { size_t oldlen = _cstr_rep(self)->size, newlen = oldlen + n; if (newlen > _cstr_rep(self)->cap) { @@ -282,7 +282,7 @@ cstr_append_n(cstr_t* self, const char* str, size_t n) { return self; } -STC_INLINE void _cstr_internal_move(cstr_t* self, size_t pos1, size_t pos2) { +STC_INLINE void _cstr_internal_move(cstr* self, size_t pos1, size_t pos2) { if (pos1 == pos2) return; size_t len = _cstr_rep(self)->size, newlen = len + pos2 - pos1; @@ -293,7 +293,7 @@ STC_INLINE void _cstr_internal_move(cstr_t* self, size_t pos1, size_t pos2) { } STC_DEF void -cstr_replace_n(cstr_t* self, size_t pos, size_t len, const char* str, size_t n) { +cstr_replace_n(cstr* self, size_t pos, size_t len, const char* str, size_t n) { c_withbuffer (xstr, char, n) { memcpy(xstr, str, n); _cstr_internal_move(self, pos + len, pos + n); @@ -302,7 +302,7 @@ cstr_replace_n(cstr_t* self, size_t pos, size_t len, const char* str, size_t n) } STC_DEF void -cstr_erase_n(cstr_t* self, size_t pos, size_t n) { +cstr_erase_n(cstr* self, size_t pos, size_t n) { size_t len = _cstr_rep(self)->size; if (len) { memmove(&self->str[pos], &self->str[pos + n], len - (pos + n)); @@ -311,7 +311,7 @@ cstr_erase_n(cstr_t* self, size_t pos, size_t n) { } STC_DEF bool -cstr_getdelim(cstr_t *self, int delim, FILE *fp) { +cstr_getdelim(cstr *self, int delim, FILE *fp) { size_t pos = 0, cap = _cstr_rep(self)->cap; int c = fgetc(fp); if (c == EOF) @@ -329,20 +329,20 @@ cstr_getdelim(cstr_t *self, int delim, FILE *fp) { } STC_DEF size_t -cstr_find(cstr_t s, const char* needle) { +cstr_find(cstr s, const char* needle) { char* res = strstr(s.str, needle); return res ? res - s.str : cstr_npos; } STC_DEF size_t -cstr_find_n(cstr_t s, const char* needle, size_t pos, size_t n) { +cstr_find_n(cstr s, const char* needle, size_t pos, size_t n) { if (pos > _cstr_rep(&s)->size) return cstr_npos; char* res = c_strnstr(s.str + pos, needle, n); return res ? res - s.str : cstr_npos; } STC_DEF size_t -cstr_ifind_n(cstr_t s, const char* needle, size_t pos, size_t n) { +cstr_ifind_n(cstr s, const char* needle, size_t pos, size_t n) { if (pos > _cstr_rep(&s)->size) return cstr_npos; char* res = c_strncasestr(s.str + pos, needle, n); return res ? res - s.str : cstr_npos; diff --git a/stc/cvec.h b/stc/cvec.h index 5102d6e8..c6ca392a 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -41,7 +41,7 @@ _c_using_cvec(cvec_##X, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) #define using_cvec_str() \ - _c_using_cvec(cvec_str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) + _c_using_cvec(cvec_str, cstr, cstr_compare_raw, cstr_del, cstr_from, cstr_c_str, const char*) struct cvec_rep { size_t size, cap; void* data[]; }; -- cgit v1.2.3