From 7188a160ac084b65de07c26797fd74e29fd8b0b8 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sat, 6 Mar 2021 10:17:29 +0100 Subject: Cleanups and internal renames. Backported csmap_v1.h in examples to match csmap.h --- docs/csset_api.md | 2 +- examples/csmap_v1.h | 25 ++++++------ stc/cbits.h | 4 +- stc/ccommon.h | 17 ++++---- stc/csmap.h | 51 ++++++++++++------------ stc/cstr.h | 111 ++++++++++++++++++++++++++-------------------------- stc/cvec.h | 46 +++++++++++----------- 7 files changed, 131 insertions(+), 125 deletions(-) diff --git a/docs/csset_api.md b/docs/csset_api.md index 33be5fd3..cc1c23c0 100644 --- a/docs/csset_api.md +++ b/docs/csset_api.md @@ -1,7 +1,7 @@ # STC [csset](../stc/csmap.h): Sorted Set ![Set](pics/sset.jpg) -A **csset** is an associative container that contains a sorted set of unique objects of type *Key*. Sorting is done using the key comparison function *keyCompare*. Search, removal, and insertion operations have logarithmic complexity. **csset** is implemented as a AA-tree. +A **csset** is an associative container that contains a sorted set of unique objects of type *Key*. Sorting is done using the key comparison function *keyCompare*. Search, removal, and insertion operations have logarithmic complexity. **csset** is implemented as an AA-tree. See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) for a functional description. diff --git a/examples/csmap_v1.h b/examples/csmap_v1.h index 1678c76f..b209e25b 100644 --- a/examples/csmap_v1.h +++ b/examples/csmap_v1.h @@ -230,14 +230,6 @@ int main(void) { } \ return res; \ } \ - STC_INLINE C##_##X##_result_t \ - C##_##X##_emplace_or_assign(C##_##X* self, RawKey rkey MAP_ONLY_##C(, RawMapped rmapped)) { \ - C##_##X##_result_t res = C##_##X##_insert_entry_(self, rkey); \ - if (res.second) *KEY_REF_##C(res.first) = keyFromRaw(rkey); \ - MAP_ONLY_##C( else mappedDel(&res.first->second); \ - res.first->second = mappedFromRaw(rmapped); ) \ - return res; \ - } \ STC_INLINE void \ C##_##X##_emplace_n(C##_##X* self, const C##_##X##_rawvalue_t arr[], size_t n) { \ for (size_t i=0; ifirst = key; else keyDel(&key); \ - mappedDel(&res.first->second); res.first->second = mapped; \ - return res; \ + if (res.second) res.first->first = key; \ + else {keyDel(&key); mappedDel(&res.first->second);} \ + res.first->second = mapped; return res; \ + } \ + STC_INLINE C##_##X##_result_t \ + C##_##X##_put(C##_##X* self, Key k, Mapped m) { \ + return C##_##X##_insert_or_assign(self, k, m); \ + } \ + STC_INLINE C##_##X##_result_t \ + C##_##X##_emplace_or_assign(C##_##X* self, RawKey rkey, RawMapped rmapped) { \ + C##_##X##_result_t res = C##_##X##_insert_entry_(self, rkey); \ + if (res.second) res.first->first = keyFromRaw(rkey); \ + else mappedDel(&res.first->second); \ + res.first->second = mappedFromRaw(rmapped); return res; \ } \ STC_INLINE C##_##X##_mapped_t* \ C##_##X##_at(const C##_##X* self, RawKey rkey) { \ diff --git a/stc/cbits.h b/stc/cbits.h index bf62bd39..d3bf4ff4 100644 --- a/stc/cbits.h +++ b/stc/cbits.h @@ -20,8 +20,8 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ -#ifndef CBITSET_H_INCLUDED -#define CBITSET_H_INCLUDED +#ifndef CBITS_H_INCLUDED +#define CBITS_H_INCLUDED /* Similar to boost::dynamic_bitset / std::bitset diff --git a/stc/ccommon.h b/stc/ccommon.h index 46ef6238..29790333 100644 --- a/stc/ccommon.h +++ b/stc/ccommon.h @@ -67,7 +67,7 @@ #define c_new(...) c_MACRO_OVERLOAD(c_new, __VA_ARGS__) #define c_new_1(T) ((T *) c_malloc(sizeof(T))) -#define c_new_2(T, n) ((T *) c_malloc(sizeof(T) * (n))) +#define c_new_2(T, n) ((T *) c_malloc(sizeof(T)*(n))) #ifndef c_malloc #define c_malloc(sz) malloc(sz) #define c_calloc(n, sz) calloc(n, sz) @@ -95,9 +95,11 @@ #define c_foreach(...) c_MACRO_OVERLOAD(c_foreach, __VA_ARGS__) #define c_foreach_3(it, ctype, cnt) \ - for (ctype##_iter_t it = ctype##_begin(&cnt), it##_end_ = ctype##_end(&cnt); it.ref != it##_end_.ref; ctype##_next(&it)) + for (ctype##_iter_t it = ctype##_begin(&cnt), it##_end_ = ctype##_end(&cnt) \ + ; it.ref != it##_end_.ref; ctype##_next(&it)) #define c_foreach_4(it, ctype, start, finish) \ - for (ctype##_iter_t it = start, it##_end_ = finish; it.ref != it##_end_.ref; ctype##_next(&it)) + for (ctype##_iter_t it = start, it##_end_ = finish \ + ; it.ref != it##_end_.ref; ctype##_next(&it)) #define c_forrange(...) c_MACRO_OVERLOAD(c_forrange, __VA_ARGS__) #define c_forrange_1(stop) for (size_t _c_i=0, _c_end_=stop; _c_i < _c_end_; ++_c_i) @@ -105,14 +107,15 @@ #define c_forrange_3(i, type, stop) for (type i=0, i##_end_=stop; i < i##_end_; ++i) #define c_forrange_4(i, type, start, stop) for (type i=start, i##_end_=stop; i < i##_end_; ++i) #define c_forrange_5(i, type, start, stop, step) \ - for (type i=start, i##_inc_=step, i##_end_=(stop) - (0 < i##_inc_); (i <= i##_end_) == (0 < i##_inc_); i += i##_inc_) + for (type i=start, i##_inc_=step, i##_end_=(stop) - (0 < i##_inc_) \ + ; (i <= i##_end_) == (0 < i##_inc_); i += i##_inc_) #define c_withfile(f, open) for (FILE *f = open; f; fclose(f), f = NULL) #define c_withbuffer(b, type, n) c_withbuffer_x(b, type, n, 256) #define c_withbuffer_x(b, type, n, BYTES) \ for (type _c_b[((BYTES) - 1) / sizeof(type) + 1], \ - *b = (n) * sizeof *b > (BYTES) ? c_new_2(type, n) : _c_b; \ - b; b != _c_b ? c_free(b) : (void)0, b = NULL) + *b = (n)*sizeof *b > (BYTES) ? c_new_2(type, n) : _c_b \ + ; b; b != _c_b ? c_free(b) : (void)0, b = NULL) #define c_breakwith continue #define c_init(ctype, c, ...) \ @@ -131,7 +134,7 @@ #if defined(__SIZEOF_INT128__) #define c_umul128(a, b, lo, hi) \ - do { __uint128_t _z = (__uint128_t)(a) * (b); \ + do { __uint128_t _z = (__uint128_t)(a)*(b); \ *(lo) = (uint64_t)_z, *(hi) = _z >> 64; } while(0) #elif defined(_MSC_VER) && defined(_WIN64) #include diff --git a/stc/csmap.h b/stc/csmap.h index 0184f053..a788a8e4 100644 --- a/stc/csmap.h +++ b/stc/csmap.h @@ -147,7 +147,7 @@ int main(void) { #endif struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; -#define csmap_rep_(self) c_container_of((self)->nodes, struct csmap_rep, nodes) +#define _csmap_rep(self) c_container_of((self)->nodes, struct csmap_rep, nodes) #define _using_AATREE(X, C, Key, Mapped, keyCompareRaw, \ mappedDel, mappedFromRaw, mappedToRaw, RawMapped, \ @@ -202,11 +202,11 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; return x; \ } \ STC_INLINE bool \ - C##_##X##_empty(C##_##X tree) {return csmap_rep_(&tree)->size == 0;} \ + C##_##X##_empty(C##_##X tree) {return _csmap_rep(&tree)->size == 0;} \ STC_INLINE size_t \ - C##_##X##_size(C##_##X tree) {return csmap_rep_(&tree)->size;} \ + C##_##X##_size(C##_##X tree) {return _csmap_rep(&tree)->size;} \ STC_INLINE size_t \ - C##_##X##_capacity(C##_##X tree) {return csmap_rep_(&tree)->cap;} \ + C##_##X##_capacity(C##_##X tree) {return _csmap_rep(&tree)->cap;} \ STC_API void \ C##_##X##_del(C##_##X* self); \ STC_INLINE void \ @@ -276,8 +276,9 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; res.first->second = mapped; return res; \ } \ STC_INLINE C##_##X##_result_t \ - C##_##X##_put(C##_##X* self, Key k, Mapped m) \ - {return C##_##X##_insert_or_assign(self, k, m);} \ + C##_##X##_put(C##_##X* self, Key k, Mapped m) { \ + return C##_##X##_insert_or_assign(self, k, m); \ + } \ STC_INLINE C##_##X##_result_t \ C##_##X##_emplace_or_assign(C##_##X* self, RawKey rkey, RawMapped rmapped) { \ C##_##X##_result_t res = C##_##X##_insert_entry_(self, rkey); \ @@ -297,7 +298,7 @@ struct csmap_rep { size_t root, disp, head, size, cap; void* nodes[]; }; \ STC_INLINE C##_##X##_iter_t \ C##_##X##_begin(C##_##X* self) { \ - C##_##X##_iter_t it = {NULL, self->nodes, 0, (C##_##X##_size_t) csmap_rep_(self)->root}; \ + C##_##X##_iter_t it = {NULL, self->nodes, 0, (C##_##X##_size_t) _csmap_rep(self)->root}; \ if (it._tn) C##_##X##_next(&it); \ return it; \ } \ @@ -338,21 +339,21 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; STC_DEF C##_##X##_value_t* \ C##_##X##_front(C##_##X* self) { \ C##_##X##_node_t *d = self->nodes; \ - C##_##X##_size_t tn = (C##_##X##_size_t) csmap_rep_(self)->root; \ + C##_##X##_size_t tn = (C##_##X##_size_t) _csmap_rep(self)->root; \ while (d[tn].link[0]) tn = d[tn].link[0]; \ return &d[tn].value; \ } \ STC_DEF C##_##X##_value_t* \ C##_##X##_back(C##_##X* self) { \ C##_##X##_node_t *d = self->nodes; \ - C##_##X##_size_t tn = (C##_##X##_size_t) csmap_rep_(self)->root; \ + C##_##X##_size_t tn = (C##_##X##_size_t) _csmap_rep(self)->root; \ while (d[tn].link[1]) tn = d[tn].link[1]; \ return &d[tn].value; \ } \ \ STC_DEF void \ C##_##X##_reserve(C##_##X* self, size_t cap) { \ - struct csmap_rep* rep = csmap_rep_(self); \ + struct csmap_rep* rep = _csmap_rep(self); \ C##_##X##_size_t oldcap = rep->cap; \ if (cap > oldcap) { \ rep = (struct csmap_rep*) c_realloc(oldcap ? rep : NULL, \ @@ -366,13 +367,13 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; \ STC_DEF C##_##X##_size_t \ C##_##X##_node_new_(C##_##X* self, int level) { \ - size_t tn; struct csmap_rep *rep = csmap_rep_(self); \ + size_t tn; struct csmap_rep *rep = _csmap_rep(self); \ if (rep->disp) { \ tn = rep->disp; \ rep->disp = self->nodes[tn].link[1]; \ } else { \ if ((tn = rep->head + 1) > rep->cap) C##_##X##_reserve(self, 4 + tn*3/2); \ - ++csmap_rep_(self)->head; /* do after reserve */ \ + ++_csmap_rep(self)->head; /* do after reserve */ \ } \ C##_##X##_node_t* dn = &self->nodes[tn]; \ dn->link[0] = dn->link[1] = 0; dn->level = level; \ @@ -381,7 +382,7 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; \ STC_DEF C##_##X##_value_t* \ C##_##X##_find_it(const C##_##X* self, C##_##X##_rawkey_t rkey, C##_##X##_iter_t* out) { \ - C##_##X##_size_t tn = csmap_rep_(self)->root; \ + C##_##X##_size_t tn = _csmap_rep(self)->root; \ C##_##X##_node_t *d = out->_d = self->nodes; \ out->_top = 0; \ while (tn) { \ @@ -458,9 +459,9 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; STC_DEF C##_##X##_result_t \ C##_##X##_insert_entry_(C##_##X* self, RawKey rkey) { \ C##_##X##_result_t res = {NULL, false}; \ - C##_##X##_size_t tn = C##_##X##insert_entry_i_(self, (C##_##X##_size_t) csmap_rep_(self)->root, &rkey, &res); \ - csmap_rep_(self)->root = tn; \ - csmap_rep_(self)->size += res.second; \ + C##_##X##_size_t tn = C##_##X##insert_entry_i_(self, (C##_##X##_size_t) _csmap_rep(self)->root, &rkey, &res); \ + _csmap_rep(self)->root = tn; \ + _csmap_rep(self)->size += res.second; \ return res; \ } \ \ @@ -505,8 +506,8 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; STC_DEF int \ C##_##X##_erase(C##_##X* self, RawKey rkey) { \ int erased = 0; \ - C##_##X##_size_t root = C##_##X##_erase_r_(self->nodes, (C##_##X##_size_t) csmap_rep_(self)->root, &rkey, &erased); \ - if (erased) {csmap_rep_(self)->root = root; --csmap_rep_(self)->size;} \ + C##_##X##_size_t root = C##_##X##_erase_r_(self->nodes, (C##_##X##_size_t) _csmap_rep(self)->root, &rkey, &erased); \ + if (erased) {_csmap_rep(self)->root = root; --_csmap_rep(self)->size;} \ return erased; \ } \ \ @@ -521,10 +522,10 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; } \ STC_DEF C##_##X \ C##_##X##_clone(C##_##X tree) { \ - C##_##X clone = C##_##X##_with_capacity(csmap_rep_(&tree)->size); \ - C##_##X##_size_t root = C##_##X##_clone_r_(&clone, tree.nodes, (C##_##X##_size_t) csmap_rep_(&tree)->root); \ - csmap_rep_(&clone)->root = root; \ - csmap_rep_(&clone)->size = csmap_rep_(&tree)->size; \ + C##_##X clone = C##_##X##_with_capacity(_csmap_rep(&tree)->size); \ + C##_##X##_size_t root = C##_##X##_clone_r_(&clone, tree.nodes, (C##_##X##_size_t) _csmap_rep(&tree)->root); \ + _csmap_rep(&clone)->root = root; \ + _csmap_rep(&clone)->size = _csmap_rep(&tree)->size; \ return clone; \ } \ \ @@ -538,9 +539,9 @@ static struct csmap_rep _smap_inits = {0, 0, 0, 0}; } \ STC_DEF void \ C##_##X##_del(C##_##X* self) { \ - if (csmap_rep_(self)->root) { \ - C##_##X##_del_r_(self->nodes, (C##_##X##_size_t) csmap_rep_(self)->root); \ - c_free(csmap_rep_(self)); \ + if (_csmap_rep(self)->root) { \ + C##_##X##_del_r_(self->nodes, (C##_##X##_size_t) _csmap_rep(self)->root); \ + c_free(_csmap_rep(self)); \ } \ } diff --git a/stc/cstr.h b/stc/cstr.h index 11951902..b0267ae2 100644 --- a/stc/cstr.h +++ b/stc/cstr.h @@ -35,26 +35,26 @@ typedef struct { char *ref; } cstr_iter_t; typedef char cstr_value_t; #define cstr_npos ((size_t) (-1)) -STC_API cstr_t cstr_from_n(const char* str, size_t len); +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 len); -STC_API cstr_t* cstr_append_n(cstr_t* self, const char* str, size_t len); +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 bool cstr_getdelim(cstr_t *self, int delim, FILE *stream); 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 nlen); -STC_API size_t cstr_ifind_n(cstr_t s, const char* needle, size_t pos, size_t nlen); +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 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); 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) +#define _cstr_rep(self) c_container_of((self)->str, struct cstr_rep, 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, ... */ @@ -69,8 +69,8 @@ cstr_init() { return cstr_inits; } STC_INLINE void cstr_del(cstr_t* self) { - if (cstr_rep_(self)->cap) - c_free(cstr_rep_(self)); + if (_cstr_rep(self)->cap) + c_free(_cstr_rep(self)); } STC_INLINE cstr_t @@ -91,23 +91,23 @@ cstr_from(const char* str) { } STC_INLINE cstr_t cstr_clone(cstr_t s) { - return cstr_from_n(s.str, cstr_rep_(&s)->size); + return cstr_from_n(s.str, _cstr_rep(&s)->size); } STC_INLINE void cstr_clear(cstr_t* self) { - self->str[cstr_rep_(self)->size = 0] = '\0'; + self->str[_cstr_rep(self)->size = 0] = '\0'; } STC_INLINE char* cstr_front(cstr_t* self) {return self->str;} STC_INLINE char* -cstr_back(cstr_t* self) {return self->str + cstr_rep_(self)->size - 1;} +cstr_back(cstr_t* self) {return self->str + _cstr_rep(self)->size - 1;} STC_INLINE cstr_iter_t cstr_begin(cstr_t* self) {cstr_iter_t it = {self->str}; return it;} STC_INLINE cstr_iter_t cstr_end(cstr_t* self) { - cstr_iter_t it = {self->str + cstr_rep_(self)->size}; return it; + 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 char* cstr_itval(cstr_iter_t it) {return it.ref;} @@ -119,8 +119,8 @@ cstr_assign(cstr_t* self, const char* str) { STC_INLINE cstr_t* cstr_take(cstr_t* self, cstr_t s) { - if (self->str != s.str && cstr_rep_(self)->cap) - c_free(cstr_rep_(self)); + if (self->str != s.str && _cstr_rep(self)->cap) + c_free(_cstr_rep(self)); self->str = s.str; return self; } @@ -141,7 +141,7 @@ cstr_push_back(cstr_t* self, char value) { } STC_INLINE void cstr_pop_back(cstr_t* self) { - self->str[ --cstr_rep_(self)->size ] = '\0'; + self->str[ --_cstr_rep(self)->size ] = '\0'; } STC_INLINE void @@ -167,13 +167,13 @@ cstr_getline(cstr_t *self, FILE *stream) { /* readonly */ STC_INLINE size_t -cstr_size(cstr_t s) {return cstr_rep_(&s)->size;} +cstr_size(cstr_t s) {return _cstr_rep(&s)->size;} STC_INLINE size_t -cstr_capacity(cstr_t s) {return cstr_rep_(&s)->cap;} +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;} +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; } +cstr_length(cstr_t s) { return _cstr_rep(&s)->size; } STC_INLINE bool cstr_equals(cstr_t s1, const char* str) { @@ -208,12 +208,12 @@ cstr_ibegins_with(cstr_t s, const char* needle) { STC_INLINE bool cstr_ends_with(cstr_t s, const char* needle) { - size_t n = strlen(needle), sz = cstr_rep_(&s)->size; + 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) { - size_t n = strlen(needle), sz = cstr_rep_(&s)->size; + size_t n = strlen(needle), sz = _cstr_rep(&s)->size; return n <= sz ? c_strncasecmp(s.str + sz - n, needle, n) == 0 : false; } @@ -238,7 +238,7 @@ STC_LIBRARY_ONLY( static struct cstr_rep _cstr_nullrep = {0, 0, {0}}; STC_DEF size_t cstr_reserve(cstr_t* self, size_t cap) { - struct cstr_rep* rep = cstr_rep_(self); + struct cstr_rep* rep = _cstr_rep(self); size_t oldcap = rep->cap; if (cap > oldcap) { rep = (struct cstr_rep*) c_realloc(oldcap ? rep : NULL, _cstr_opt_mem(cap)); @@ -251,19 +251,19 @@ cstr_reserve(cstr_t* self, size_t cap) { STC_DEF void cstr_resize(cstr_t* self, size_t len, char fill) { - size_t n = cstr_rep_(self)->size; + 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'; + if (len | n) self->str[_cstr_rep(self)->size = len] = '\0'; } STC_DEF cstr_t -cstr_from_n(const char* str, size_t len) { - if (len == 0) return cstr_inits; - struct cstr_rep* rep = (struct cstr_rep*) c_malloc(_cstr_opt_mem(len)); - cstr_t s = {(char *) memcpy(rep->str, str, len)}; - s.str[rep->size = len] = '\0'; - rep->cap = _cstr_opt_cap(len); +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)}; + s.str[rep->size = n] = '\0'; + rep->cap = _cstr_opt_cap(n); return s; } @@ -281,7 +281,7 @@ cstr_vfmt(cstr_t* self, const char* fmt, va_list args) { int len = vsnprintf(NULL, (size_t)0, fmt, args); cstr_reserve(self, len); vsprintf(self->str, fmt, args2); - cstr_rep_(self)->size = len; + _cstr_rep(self)->size = len; va_end(args2); } @@ -307,26 +307,26 @@ cstr_from_fmt(const char* fmt, ...) { #endif STC_DEF cstr_t* -cstr_assign_n(cstr_t* self, const char* str, size_t len) { - if (len || cstr_rep_(self)->cap) { - cstr_reserve(self, len); - memmove(self->str, str, len); - self->str[cstr_rep_(self)->size = len] = '\0'; +cstr_assign_n(cstr_t* self, const char* str, size_t n) { + if (n || _cstr_rep(self)->cap) { + cstr_reserve(self, n); + memmove(self->str, str, n); + self->str[_cstr_rep(self)->size = n] = '\0'; } return self; } STC_DEF cstr_t* -cstr_append_n(cstr_t* self, const char* str, size_t len) { - if (len) { - size_t oldlen = cstr_rep_(self)->size, newlen = oldlen + len; - if (newlen > cstr_rep_(self)->cap) { +cstr_append_n(cstr_t* 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) { size_t off = (size_t) (str - self->str); /* handle self append */ cstr_reserve(self, newlen*3/2); if (off <= oldlen) str = self->str + off; } - memcpy(&self->str[oldlen], str, len); - self->str[cstr_rep_(self)->size = newlen] = '\0'; + memcpy(&self->str[oldlen], str, n); + self->str[_cstr_rep(self)->size = newlen] = '\0'; } return self; } @@ -334,11 +334,11 @@ cstr_append_n(cstr_t* self, const char* str, size_t len) { STC_INLINE void _cstr_internal_move(cstr_t* self, size_t pos1, size_t pos2) { if (pos1 == pos2) return; - size_t len = cstr_rep_(self)->size, newlen = len + pos2 - pos1; - if (newlen > cstr_rep_(self)->cap) + size_t len = _cstr_rep(self)->size, newlen = len + pos2 - pos1; + if (newlen > _cstr_rep(self)->cap) cstr_reserve(self, newlen*3/2); memmove(&self->str[pos2], &self->str[pos1], len - pos1); - self->str[cstr_rep_(self)->size = newlen] = '\0'; + self->str[_cstr_rep(self)->size = newlen] = '\0'; } STC_DEF void @@ -352,16 +352,16 @@ 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) { - size_t len = cstr_rep_(self)->size; + size_t len = _cstr_rep(self)->size; if (len) { memmove(&self->str[pos], &self->str[pos + n], len - (pos + n)); - self->str[cstr_rep_(self)->size -= n] = '\0'; + self->str[_cstr_rep(self)->size -= n] = '\0'; } } STC_DEF bool cstr_getdelim(cstr_t *self, int delim, FILE *fp) { - size_t pos = 0, cap = cstr_rep_(self)->cap; + size_t pos = 0, cap = _cstr_rep(self)->cap; int c = fgetc(fp); if (c == EOF) return false; @@ -369,7 +369,7 @@ cstr_getdelim(cstr_t *self, int delim, FILE *fp) { if (pos == cap) cap = cstr_reserve(self, cap*3/2 + 34); if (c == delim || c == EOF) { - self->str[cstr_rep_(self)->size = pos] = '\0'; + self->str[_cstr_rep(self)->size = pos] = '\0'; return true; } self->str[pos++] = (char) c; @@ -383,15 +383,15 @@ cstr_find(cstr_t s, const char* 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 nlen) { - if (pos > cstr_rep_(&s)->size) return cstr_npos; - char* res = c_strnstr(s.str + pos, needle, nlen); +cstr_find_n(cstr_t 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 nlen) { - if (pos > cstr_rep_(&s)->size) return cstr_npos; - char* res = c_strncasestr(s.str + pos, needle, nlen); +cstr_ifind_n(cstr_t 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; } @@ -437,6 +437,5 @@ c_strncasestr(const char* s, const char* needle, size_t nmax) { } } -/* http://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord */ #endif #endif \ No newline at end of file diff --git a/stc/cvec.h b/stc/cvec.h index 69b90d10..b2ecc319 100644 --- a/stc/cvec.h +++ b/stc/cvec.h @@ -46,7 +46,7 @@ } cvec_##X struct cvec_rep { size_t size, cap; void* data[]; }; -#define cvec_rep_(self) c_container_of((self)->data, struct cvec_rep, 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, valueDel, valueFromRaw, valueToRaw, RawValue) \ @@ -55,11 +55,11 @@ typedef int (*c_cmp_fn)(const void*, const void*); STC_API cvec_##X \ cvec_##X##_init(void); \ STC_INLINE size_t \ - cvec_##X##_size(cvec_##X vec) { return cvec_rep_(&vec)->size; } \ + cvec_##X##_size(cvec_##X vec) { return _cvec_rep(&vec)->size; } \ STC_INLINE size_t \ - cvec_##X##_capacity(cvec_##X vec) { return cvec_rep_(&vec)->cap; } \ + cvec_##X##_capacity(cvec_##X vec) { return _cvec_rep(&vec)->cap; } \ STC_INLINE bool \ - cvec_##X##_empty(cvec_##X vec) {return !cvec_rep_(&vec)->size;} \ + cvec_##X##_empty(cvec_##X vec) {return !_cvec_rep(&vec)->size;} \ STC_INLINE Value \ cvec_##X##_value_fromraw(RawValue raw) {return valueFromRaw(raw);} \ STC_INLINE cvec_##X##_value_t \ @@ -105,7 +105,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); } \ STC_INLINE void \ cvec_##X##_pop_back(cvec_##X* self) { \ - valueDel(&self->data[--cvec_rep_(self)->size]); \ + valueDel(&self->data[--_cvec_rep(self)->size]); \ } \ \ STC_API cvec_##X##_iter_t \ @@ -151,10 +151,10 @@ typedef int (*c_cmp_fn)(const void*, const void*); STC_INLINE cvec_##X##_value_t* \ cvec_##X##_front(cvec_##X* self) {return self->data;} \ STC_INLINE cvec_##X##_value_t* \ - cvec_##X##_back(cvec_##X* self) {return self->data + cvec_rep_(self)->size - 1;} \ + cvec_##X##_back(cvec_##X* self) {return self->data + _cvec_rep(self)->size - 1;} \ STC_INLINE cvec_##X##_value_t* \ cvec_##X##_at(cvec_##X* self, size_t i) { \ - assert(i < cvec_rep_(self)->size); \ + assert(i < _cvec_rep(self)->size); \ return self->data + i; \ } \ \ @@ -164,7 +164,7 @@ typedef int (*c_cmp_fn)(const void*, const void*); } \ STC_INLINE cvec_##X##_iter_t \ cvec_##X##_end(const cvec_##X* self) { \ - cvec_##X##_iter_t it = {self->data + cvec_rep_(self)->size}; return it; \ + cvec_##X##_iter_t it = {self->data + _cvec_rep(self)->size}; return it; \ } \ STC_INLINE void \ cvec_##X##_next(cvec_##X##_iter_t* it) {++it->ref;} \ @@ -215,15 +215,15 @@ static struct cvec_rep _cvec_inits = {0, 0}; STC_DEF void \ cvec_##X##_emplace_n(cvec_##X *self, const cvec_##X##_rawvalue_t arr[], size_t n) { \ if (!n) return; \ - cvec_##X##_reserve(self, cvec_rep_(self)->size + n); \ - cvec_##X##_value_t* p = self->data + cvec_rep_(self)->size; \ + cvec_##X##_reserve(self, _cvec_rep(self)->size + n); \ + cvec_##X##_value_t* p = self->data + _cvec_rep(self)->size; \ for (size_t i=0; i < n; ++i) *p++ = valueFromRaw(arr[i]); \ - cvec_rep_(self)->size += n; \ + _cvec_rep(self)->size += n; \ } \ \ STC_DEF void \ cvec_##X##_clear(cvec_##X* self) { \ - struct cvec_rep* rep = cvec_rep_(self); if (rep->cap) { \ + 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) \ valueDel(p); \ rep->size = 0; \ @@ -232,13 +232,13 @@ static struct cvec_rep _cvec_inits = {0, 0}; STC_DEF void \ cvec_##X##_del(cvec_##X* self) { \ cvec_##X##_clear(self); \ - if (cvec_rep_(self)->cap) \ - c_free(cvec_rep_(self)); \ + if (_cvec_rep(self)->cap) \ + c_free(_cvec_rep(self)); \ } \ \ STC_DEF void \ cvec_##X##_reserve(cvec_##X* self, size_t cap) { \ - struct cvec_rep* rep = cvec_rep_(self); \ + struct cvec_rep* rep = _cvec_rep(self); \ size_t len = rep->size, oldcap = rep->cap; \ if (cap > oldcap) { \ rep = (struct cvec_rep*) c_realloc(oldcap ? rep : NULL, \ @@ -251,7 +251,7 @@ static struct cvec_rep _cvec_inits = {0, 0}; STC_DEF void \ cvec_##X##_resize(cvec_##X* self, size_t len, Value null_val) { \ cvec_##X##_reserve(self, len); \ - struct cvec_rep* rep = cvec_rep_(self); \ + struct cvec_rep* rep = _cvec_rep(self); \ size_t i, n = rep->size; \ for (i = len; i < n; ++i) valueDel(self->data + i); \ for (i = n; i < len; ++i) self->data[i] = null_val; \ @@ -260,15 +260,15 @@ static struct cvec_rep _cvec_inits = {0, 0}; \ STC_DEF void \ cvec_##X##_push_back(cvec_##X* self, Value value) { \ - size_t len = cvec_rep_(self)->size; \ + size_t len = _cvec_rep(self)->size; \ if (len == cvec_##X##_capacity(*self)) \ cvec_##X##_reserve(self, 4 + len*1.5); \ - self->data[cvec_rep_(self)->size++] = value; \ + self->data[_cvec_rep(self)->size++] = value; \ } \ \ STC_DEF cvec_##X \ cvec_##X##_clone(cvec_##X vec) { \ - size_t len = cvec_rep_(&vec)->size; \ + size_t len = _cvec_rep(&vec)->size; \ cvec_##X out = cvec_##X##_with_capacity(len); \ cvec_##X##_insert_range_p(&out, out.data, vec.data, vec.data + len); \ return out; \ @@ -276,13 +276,13 @@ static struct cvec_rep _cvec_inits = {0, 0}; \ STC_DEF cvec_##X##_iter_t \ cvec_##X##_insert_range_p(cvec_##X* self, cvec_##X##_value_t* pos, const cvec_##X##_value_t* first, const cvec_##X##_value_t* finish) { \ - size_t len = finish - first, idx = pos - self->data, size = cvec_rep_(self)->size; \ + size_t len = finish - first, idx = pos - self->data, size = _cvec_rep(self)->size; \ cvec_##X##_iter_t it = {pos}; \ if (len == 0) return it; \ if (size + len > cvec_##X##_capacity(*self)) \ cvec_##X##_reserve(self, 4 + (size + len)*1.5), \ it.ref = pos = self->data + idx; \ - cvec_rep_(self)->size += len; \ + _cvec_rep(self)->size += len; \ memmove(pos + len, pos, (size - idx) * sizeof(Value)); \ while (first != finish) \ *pos++ = valueFromRaw(valueToRaw(first++)); \ @@ -293,10 +293,10 @@ static struct cvec_rep _cvec_inits = {0, 0}; cvec_##X##_erase_range_p(cvec_##X* self, cvec_##X##_value_t* first, cvec_##X##_value_t* finish) { \ intptr_t len = finish - first; \ if (len > 0) { \ - cvec_##X##_value_t* p = first, *end = self->data + cvec_rep_(self)->size; \ + cvec_##X##_value_t* p = first, *end = self->data + _cvec_rep(self)->size; \ while (p != finish) valueDel(p++); \ memmove(first, finish, (end - finish) * sizeof(Value)); \ - cvec_rep_(self)->size -= len; \ + _cvec_rep(self)->size -= len; \ } \ cvec_##X##_iter_t it = {first}; return it; \ } \ -- cgit v1.2.3