Cleanups and internal renames. Backported csmap_v1.h in examples to match csmap.h

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; i<n; ++i) SET_ONLY_##C( C##_##X##_emplace(self, arr[i]); ) \

@@ -256,9 +248,20 @@ int main(void) {
         STC_INLINE C##_##X##_result_t \

         C##_##X##_insert_or_assign(C##_##X* self, Key key, Mapped mapped) { \

             C##_##X##_result_t res = C##_##X##_insert_entry_(self, keyToRaw(&key)); \

-            if (res.second) res.first->first = 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 <intrin.h>

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; \

     } \