New API Change.

10 files changed, 153 insertions, 153 deletions

diff --git a/stc/carray.h b/stc/carray.h
index a7f15ddd..3106b99a 100644
--- a/stc/carray.h
+++ b/stc/carray.h
@@ -30,7 +30,7 @@
  Multi-dimensional generic array allocated as one block of heap-memory.

  // demo:

 #include <stc/carray.h>

-declare_carray(f, float);

+cdef_carray(f, float);

 

 int main()

 {

@@ -68,8 +68,8 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
 }

 

 

-#define declare_carray_common(D, X, Value, valueDestroy) \

-    typedef struct { Value *item; } carray##D##X##_iter_t; \

+#define cdef_carray_common(D, X, Value, valueDestroy) \

+    typedef struct { Value *get; } carray##D##X##_iter_t; \

 \

     STC_INLINE carray##D##X##_iter_t \

     carray##D##X##_begin(carray##D##X* a) { \

@@ -80,23 +80,23 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
         carray##D##X##_iter_t it = {a->data + carray##D##_size(*a)}; return it; \

     } \

     STC_INLINE void \

-    carray##D##X##_next(carray##D##X##_iter_t* it) {++it->item;} \

+    carray##D##X##_next(carray##D##X##_iter_t* it) {++it->get;} \

 \

     STC_INLINE void \

     carray##D##X##_destroy(carray##D##X* self) { \

         if (self->_xdim & _carray_OWN) { \

             c_foreach_3 (i, carray##D##X, *self) \

-                valueDestroy(i.item); \

+                valueDestroy(i.get); \

             free(self->data); \

         } \

     }

 

-#define declare_carray(...) c_MACRO_OVERLOAD(declare_carray, __VA_ARGS__)

-#define declare_carray_2(X, Value) \

-    declare_carray_3(X, Value, c_default_destroy)

+#define cdef_carray(...) c_MACRO_OVERLOAD(cdef_carray, __VA_ARGS__)

+#define cdef_carray_2(X, Value) \

+    cdef_carray_3(X, Value, c_default_destroy)

 

 

-#define declare_carray_3(X, Value, valueDestroy) \

+#define cdef_carray_3(X, Value, valueDestroy) \

 \

     typedef Value carray1##X##_value_t; \

     typedef carray1##X##_value_t carray2##X##_value_t, carray3##X##_value_t; \

@@ -116,9 +116,9 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
         size_t _xdim, _yxdim, _zdim; \

     } carray3##X; \

 \

-    declare_carray_common(1, X, Value, valueDestroy) \

-    declare_carray_common(2, X, Value, valueDestroy) \

-    declare_carray_common(3, X, Value, valueDestroy) \

+    cdef_carray_common(1, X, Value, valueDestroy) \

+    cdef_carray_common(2, X, Value, valueDestroy) \

+    cdef_carray_common(3, X, Value, valueDestroy) \

 \

     STC_INLINE carray1##X \

     carray1##X##_make(size_t xdim, Value val) { \

diff --git a/stc/cbitset.h b/stc/cbitset.h
index 0c5af0e6..b20aedd2 100644
--- a/stc/cbitset.h
+++ b/stc/cbitset.h
@@ -148,7 +148,7 @@ STC_INLINE cbitset_t cbitset_not(cbitset_t s1) {
 

 typedef struct {

     cbitset_t *_bs;

-    size_t item;

+    size_t get;

 } cbitset_iter_t;

 

 STC_INLINE cbitset_iter_t

@@ -160,10 +160,10 @@ cbitset_end(cbitset_t* self) {
     cbitset_iter_t it = {self, self->size}; return it;

 }

 STC_INLINE void

-cbitset_next(cbitset_iter_t* it) {++it->item;}

+cbitset_next(cbitset_iter_t* it) {++it->get;}

 

 STC_INLINE bool cbitset_itval(cbitset_iter_t it) {

-    return cbitset_test(*it._bs, it.item);

+    return cbitset_test(*it._bs, it.get);

 }

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

diff --git a/stc/cdefs.h b/stc/cdefs.h
index dc12b618..df56987e 100644
--- a/stc/cdefs.h
+++ b/stc/cdefs.h
@@ -74,16 +74,16 @@
 #define c_mem_equals(x, y)      (memcmp(x, y, sizeof(*(y))) == 0)

 #define c_default_equals(x, y)  (*(x) == *(y))

 #define c_default_less(x, y)    (*(x) < *(y))

-#define c_compare(less, x, y)   (less(x, y) ? -1 : less(y, x))

-#define c_default_compare(x, y) c_compare(c_default_less, x, y)

+#define c_less_compare(less, x, y) (less(x, y) ? -1 : less(y, x))

+#define c_default_compare(x, y) c_less_compare(c_default_less, x, y)

 #define c_default_destroy(ptr)  ((void) (ptr))

 

 #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.item != it##_end_.item; ctype##_next(&it))

+    for (ctype##_iter_t it = ctype##_begin(&cnt), it##_end_ = ctype##_end(&cnt); it.get != it##_end_.get; ctype##_next(&it))

 #define c_foreach_4(it, ctype, start, finish) \

-    for (ctype##_iter_t it = start, it##_end_ = finish; it.item != it##_end_.item; ctype##_next(&it))

+    for (ctype##_iter_t it = start, it##_end_ = finish; it.get != it##_end_.get; ctype##_next(&it))

 

 #define c_push(self, ctype, ...) do { \

     const ctype##_input_t __arr[] = __VA_ARGS__; \

diff --git a/stc/clist.h b/stc/clist.h
index baba7ed3..827d9096 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -35,7 +35,7 @@
     #include <stdio.h>

     #include <stc/clist.h>

     #include <stc/crandom.h>

-    declare_clist(ix, int64_t);

+    cdef_clist(ix, int64_t);

 

     int main() {

         clist_ix list = clist_ini;

@@ -45,30 +45,30 @@
             clist_ix_push_back(&list, crand_i32(&pcg));

         n = 0;

         c_foreach (i, clist_ix, list)

-            if (++n % 10000 == 0) printf("%8d: %10zd\n", n, i.item->value);

+            if (++n % 10000 == 0) printf("%8d: %10zd\n", n, i.get->value);

         // Sort them...

         clist_ix_sort(&list); // mergesort O(n*log n)

         n = 0;

         puts("sorted");

         c_foreach (i, clist_ix, list)

-            if (++n % 10000 == 0) printf("%8d: %10zd\n", n, i.item->value);

+            if (++n % 10000 == 0) printf("%8d: %10zd\n", n, i.get->value);

         clist_ix_destroy(&list);

     }

 */

 

-#define declare_clist(...)   c_MACRO_OVERLOAD(declare_clist, __VA_ARGS__)

+#define cdef_clist(...)   c_MACRO_OVERLOAD(cdef_clist, __VA_ARGS__)

 

-#define declare_clist_2(X, Value) \

-                             declare_clist_3(X, Value, c_default_destroy)

-#define declare_clist_3(X, Value, valueDestroy) \

-                             declare_clist_4(X, Value, valueDestroy, c_default_compare)

-#define declare_clist_4(X, Value, valueDestroy, valueCompare) \

-                             declare_clist_7(X, Value, valueDestroy, Value, \

+#define cdef_clist_2(X, Value) \

+                             cdef_clist_3(X, Value, c_default_destroy)

+#define cdef_clist_3(X, Value, valueDestroy) \

+                             cdef_clist_4(X, Value, valueDestroy, c_default_compare)

+#define cdef_clist_4(X, Value, valueDestroy, valueCompare) \

+                             cdef_clist_7(X, Value, valueDestroy, Value, \

                                              valueCompare, c_default_to_raw, c_default_from_raw)

-#define declare_clist_str()  declare_clist_7(str, cstr_t, cstr_destroy, const char*, \

-                                             cstr_compare_raw, cstr_to_raw, cstr_make)

+#define cdef_clist_str()  cdef_clist_7(str, cstr_t, cstr_destroy, const char*, \

+                                             cstr_compare_raw, cstr_to_raw, cstr)

 

-#define declare_clist_types(X, Value) \

+#define cdef_clist_types(X, Value) \

     typedef Value clist_##X##_value_t; \

 \

     typedef struct clist_##X##_node { \

@@ -82,7 +82,7 @@
 \

     typedef struct { \

         clist_##X##_node_t* const* _last; \

-        clist_##X##_node_t* item; \

+        clist_##X##_node_t* get; \

         int _state; \

     } clist_##X##_iter_t

 

@@ -97,12 +97,12 @@
         __pos = ctype##_emplace_after(__self, __pos, __arr[__i]); \

 } while (0)

 

-declare_clist_types(void, int);

+cdef_clist_types(void, int);

 STC_API size_t _clist_size(const clist_void* self);

 

-#define declare_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

+#define cdef_clist_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw) \

 \

-    declare_clist_types(X, Value); \

+    cdef_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

     typedef clist_##X##_rawvalue_t clist_##X##_input_t; \

 \

@@ -156,10 +156,10 @@ STC_API size_t _clist_size(const clist_void* self);
     } \

     STC_INLINE void \

     clist_##X##_next(clist_##X##_iter_t* it) { \

-        it->item = ((it->_state += it->item == *it->_last) == 1) ? NULL : it->item->next; \

+        it->get = ((it->_state += it->get == *it->_last) == 1) ? NULL : it->get->next; \

     } \

     STC_INLINE clist_##X##_value_t* \

-    clist_##X##_itval(clist_##X##_iter_t it) {return &it.item->value;} \

+    clist_##X##_itval(clist_##X##_iter_t it) {return &it.get->value;} \

 \

     STC_API clist_##X##_iter_t \

     clist_##X##_insert_after(clist_##X* self, clist_##X##_iter_t pos, Value value); \

@@ -171,7 +171,7 @@ STC_API size_t _clist_size(const clist_void* self);
     clist_##X##_erase_after(clist_##X* self, clist_##X##_iter_t pos); \

     STC_INLINE clist_##X##_iter_t \

     clist_##X##_erase_range_after(clist_##X* self, clist_##X##_iter_t pos, clist_##X##_iter_t finish) { \

-        while (pos.item != finish.item) pos = clist_##X##_erase_after(self, pos); \

+        while (pos.get != finish.get) pos = clist_##X##_erase_after(self, pos); \

         return pos; \

     } \

 \

@@ -237,21 +237,21 @@ STC_API size_t _clist_size(const clist_void* self);
 \

     STC_API clist_##X##_iter_t \

     clist_##X##_insert_after(clist_##X* self, clist_##X##_iter_t pos, Value value) { \

-        _clist_insert_after(self, X, pos.item, value); \

-        if (pos.item == self->last && pos._state == 0) self->last = entry; \

-        pos.item = entry; return pos; \

+        _clist_insert_after(self, X, pos.get, value); \

+        if (pos.get == self->last && pos._state == 0) self->last = entry; \

+        pos.get = entry; return pos; \

     } \

     STC_API clist_##X##_iter_t \

     clist_##X##_erase_after(clist_##X* self, clist_##X##_iter_t pos) { \

-        _clist_erase_after(self, X, pos.item, valueDestroy); \

+        _clist_erase_after(self, X, pos.get, valueDestroy); \

         clist_##X##_next(&pos); return pos; \

     } \

 \

     STC_API clist_##X##_iter_t \

     clist_##X##_find_before(const clist_##X* self, clist_##X##_iter_t first, clist_##X##_iter_t finish, RawValue val) { \

         clist_##X##_iter_t i = first; \

-        for (clist_##X##_next(&i); i.item != finish.item; clist_##X##_next(&i)) { \

-            RawValue r = valueToRaw(&i.item->value); \

+        for (clist_##X##_next(&i); i.get != finish.get; clist_##X##_next(&i)) { \

+            RawValue r = valueToRaw(&i.get->value); \

             if (valueCompareRaw(&r, &val) == 0) return first; \

             first = i; \

         } \

@@ -261,7 +261,7 @@ STC_API size_t _clist_size(const clist_void* self);
     STC_API clist_##X##_iter_t \

     clist_##X##_find(const clist_##X* self, RawValue val) { \

         clist_##X##_iter_t it = clist_##X##_find_before(self, clist_##X##_before_begin(self), clist_##X##_end(self), val); \

-        if (it.item != clist_##X##_end(self).item) clist_##X##_next(&it); \

+        if (it.get != clist_##X##_end(self).get) clist_##X##_next(&it); \

         return it; \

     } \

 \

@@ -269,7 +269,7 @@ STC_API size_t _clist_size(const clist_void* self);
     clist_##X##_remove(clist_##X* self, RawValue val) { \

         size_t n = 0; \

         clist_##X##_iter_t it = clist_##X##_before_begin(self), end = clist_##X##_end(self); \

-        while ((it = clist_##X##_find_before(self, it, clist_##X##_end(self), val)).item != clist_##X##_end(self).item) \

+        while ((it = clist_##X##_find_before(self, it, clist_##X##_end(self), val)).get != clist_##X##_end(self).get) \

             clist_##X##_erase_after(self, it), ++n; \

         return n; \

     } \

@@ -307,13 +307,13 @@ STC_API size_t _clist_size(const clist_void* self);
 

 STC_API void

 _clist_splice_after(clist_void* self, clist_void_iter_t pos, clist_void* other) {

-    if (!pos.item)

+    if (!pos.get)

         self->last = other->last;

     else if (other->last) {

-        clist_void_node_t *next = pos.item->next;

-        pos.item->next = other->last->next;

+        clist_void_node_t *next = pos.get->next;

+        pos.get->next = other->last->next;

         other->last->next = next;

-        if (pos.item == self->last && pos._state == 0) self->last = other->last;

+        if (pos.get == self->last && pos._state == 0) self->last = other->last;

     }

     other->last = NULL;

 }

diff --git a/stc/cmap.h b/stc/cmap.h
index d049cb2b..3cc227cf 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -23,15 +23,15 @@
 /*

 #include <stdio.h>

 #include <stc/cmap.h>

-declare_cset(sx, int);       // Set of int

-declare_cmap(mx, int, char); // Map of int -> char

+cdef_cset(sx, int);       // Set of int

+cdef_cmap(mx, int, char); // Map of int -> char

 

 int main(void) {

     cset_sx s = cset_ini;

     cset_sx_insert(&s, 5);

     cset_sx_insert(&s, 8);

     c_foreach (i, cset_sx, s)

-        printf("set %d\n", i.item->value);

+        printf("set %d\n", i.get->value);

     cset_sx_destroy(&s);

 

     cmap_mx m = cmap_ini;

@@ -43,7 +43,7 @@ int main(void) {
     cmap_mx_put(&m, 5, 'd'); // update

     cmap_mx_erase(&m, 8);

     c_foreach (i, cmap_mx, m)

-        printf("map %d: %c\n", i.item->first, i.item->second);

+        printf("map %d: %c\n", i.get->first, i.get->second);

     cmap_mx_destroy(&m);

 }*/

 #ifndef CMAP__H__

@@ -77,73 +77,73 @@ int main(void) {
 enum {chash_HASH = 0x7f, chash_USED = 0x80};

 typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;

 

-#define declare_cmap(...) \

-    c_MACRO_OVERLOAD(declare_cmap, __VA_ARGS__)

+#define cdef_cmap(...) \

+    c_MACRO_OVERLOAD(cdef_cmap, __VA_ARGS__)

 

-#define declare_cmap_3(X, Key, Mapped) \

-    declare_cmap_4(X, Key, Mapped, c_default_destroy)

+#define cdef_cmap_3(X, Key, Mapped) \

+    cdef_cmap_4(X, Key, Mapped, c_default_destroy)

 

-#define declare_cmap_4(X, Key, Mapped, valueDestroy) \

-    declare_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16)

+#define cdef_cmap_4(X, Key, Mapped, valueDestroy) \

+    cdef_cmap_6(X, Key, Mapped, valueDestroy, c_default_equals, c_default_hash16)

 

-#define declare_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \

-    declare_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \

+#define cdef_cmap_6(X, Key, Mapped, valueDestroy, keyEquals, keyHash) \

+    cdef_cmap_10(X, Key, Mapped, valueDestroy, keyEquals, keyHash, \

                        c_default_destroy, Key, c_default_to_raw, c_default_from_raw)

 

-#define declare_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define cdef_cmap_10(X, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyToRaw, keyFromRaw) \

-    declare_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

-                     keyDestroy, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw)

+    _declare_CHASH(X, cmap, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+                      keyDestroy, RawKey, keyToRaw, keyFromRaw, Mapped, c_default_from_raw)

 

 /* cset: */

-#define declare_cset(...) \

-    c_MACRO_OVERLOAD(declare_cset, __VA_ARGS__)

+#define cdef_cset(...) \

+    c_MACRO_OVERLOAD(cdef_cset, __VA_ARGS__)

 

-#define declare_cset_2(X, Key) \

-    declare_cset_4(X, Key, c_default_equals, c_default_hash16)

+#define cdef_cset_2(X, Key) \

+    cdef_cset_4(X, Key, c_default_equals, c_default_hash16)

 

-#define declare_cset_4(X, Key, keyEquals, keyHash) \

-    declare_cset_5(X, Key, keyEquals, keyHash, c_default_destroy)

+#define cdef_cset_4(X, Key, keyEquals, keyHash) \

+    cdef_cset_5(X, Key, keyEquals, keyHash, c_default_destroy)

 

-#define declare_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \

-    declare_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \

+#define cdef_cset_5(X, Key, keyEquals, keyHash, keyDestroy) \

+    cdef_cset_8(X, Key, keyEquals, keyHash, keyDestroy, \

                       Key, c_default_to_raw, c_default_from_raw)

 

-#define declare_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \

+#define cdef_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDestroy, \

                           RawKey, keyToRaw, keyFromRaw) \

-    declare_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \

+    _declare_CHASH(X, cset, Key, Key, void, keyEqualsRaw, keyHashRaw, \

                      keyDestroy, RawKey, keyToRaw, keyFromRaw, void, c_default_from_raw)

 

 /* cset_str, cmap_str, cmap_strkey, cmap_strval: */

-#define declare_cset_str() \

-    declare_CHASH_strkey(str, cset, cstr_t, void)

+#define cdef_cset_str() \

+    _declare_CHASH_strkey(str, cset, cstr_t, void)

 

-#define declare_cmap_str() \

-    declare_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \

-                       cstr_destroy, const char*, cstr_to_raw, cstr_make, const char*, cstr_make)

+#define cdef_cmap_str() \

+    _declare_CHASH(str, cmap, cstr_t, cstr_t, cstr_destroy, cstr_equals_raw, cstr_hash_raw, \

+                       cstr_destroy, const char*, cstr_to_raw, cstr, const char*, cstr)

 

-#define declare_cmap_strkey(...) \

-    c_MACRO_OVERLOAD(declare_cmap_strkey, __VA_ARGS__)

+#define cdef_cmap_strkey(...) \

+    c_MACRO_OVERLOAD(cdef_cmap_strkey, __VA_ARGS__)

 

-#define declare_cmap_strkey_2(X, Mapped) \

-    declare_CHASH_strkey(X, cmap, Mapped, c_default_destroy)

+#define cdef_cmap_strkey_2(X, Mapped) \

+    _declare_CHASH_strkey(X, cmap, Mapped, c_default_destroy)

 

-#define declare_cmap_strkey_3(X, Mapped, ValueDestroy) \

-    declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

+#define cdef_cmap_strkey_3(X, Mapped, ValueDestroy) \

+    _declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

 

-#define declare_cmap_strval(...) \

-    c_MACRO_OVERLOAD(declare_cmap_strval, __VA_ARGS__)

+#define cdef_cmap_strval(...) \

+    c_MACRO_OVERLOAD(cdef_cmap_strval, __VA_ARGS__)

 

-#define declare_cmap_strval_2(X, Key) \

-    declare_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

+#define cdef_cmap_strval_2(X, Key) \

+    cdef_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

 

-#define declare_cmap_strval_4(X, Key, keyEquals, keyHash) \

-    declare_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \

-                       c_default_destroy, Key, c_default_to_raw, c_default_from_raw, const char*, cstr_make)

+#define cdef_cmap_strval_4(X, Key, keyEquals, keyHash) \

+    _declare_CHASH(X, cmap, Key, cstr_t, cstr_destroy, keyEquals, keyHash, \

+                       c_default_destroy, Key, c_default_to_raw, c_default_from_raw, const char*, cstr)

 

-#define declare_CHASH_strkey(X, ctype, Mapped, valueDestroy) \

-    declare_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \

-                       cstr_destroy, const char*, cstr_to_raw, cstr_make, Mapped, c_default_from_raw)

+#define _declare_CHASH_strkey(X, ctype, Mapped, valueDestroy) \

+    _declare_CHASH(X, ctype, cstr_t, Mapped, valueDestroy, cstr_equals_raw, cstr_hash_raw, \

+                       cstr_destroy, const char*, cstr_to_raw, cstr, Mapped, c_default_from_raw)

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

 #define CSET_ONLY_cmap(...)

@@ -153,7 +153,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define CMAP_ARGS_cmap(x, y) x, y

 

 /* CHASH full: use 'void' for Mapped if ctype is cset */

-#define declare_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define _declare_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                          keyDestroy, RawKey, keyToRaw, keyFromRaw, RawVal, valueFromRaw) \

     typedef Key ctype##_##X##_key_t; \

     typedef Mapped ctype##_##X##_mapped_t; \

@@ -191,7 +191,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     } ctype##_##X; \

 \

     typedef struct { \

-        ctype##_##X##_value_t *item; \

+        ctype##_##X##_value_t *get; \

         uint8_t* _hx; \

     } ctype##_##X##_iter_t; \

 \

@@ -268,7 +268,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_INLINE ctype##_##X##_iter_t \

     ctype##_##X##_begin(ctype##_##X* self) { \

         ctype##_##X##_iter_t it = {self->table, self->_hashx}; \

-        if (it._hx) while (*it._hx == 0) ++it.item, ++it._hx; \

+        if (it._hx) while (*it._hx == 0) ++it.get, ++it._hx; \

         return it; \

     } \

     STC_INLINE ctype##_##X##_iter_t \

@@ -277,13 +277,13 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     } \

     STC_INLINE void \

     ctype##_##X##_next(ctype##_##X##_iter_t* it) { \

-        while ((++it->item, *++it->_hx == 0)) ; \

+        while ((++it->get, *++it->_hx == 0)) ; \

     } \

     CMAP_ONLY_##ctype( STC_INLINE ctype##_##X##_mapped_t* \

-    ctype##_##X##_itval(ctype##_##X##_iter_t it) {return &it.item->value;} ) \

+    ctype##_##X##_itval(ctype##_##X##_iter_t it) {return &it.get->value;} ) \

 \

     STC_API void \

-    ctype##_##X##_erase_entry(ctype##_##X* self, ctype##_##X##_value_t* item); \

+    ctype##_##X##_erase_entry(ctype##_##X* self, ctype##_##X##_value_t* get); \

     STC_INLINE size_t \

     ctype##_##X##_erase(ctype##_##X* self, RawKey rawKey) { \

         if (self->size == 0) return 0; \

@@ -292,20 +292,20 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     } \

     STC_INLINE ctype##_##X##_iter_t \

     ctype##_##X##_erase_at(ctype##_##X* self, ctype##_##X##_iter_t pos) { \

-        ctype##_##X##_erase_entry(self, pos.item); \

+        ctype##_##X##_erase_entry(self, pos.get); \

         ctype##_##X##_next(&pos); return pos; \

     } \

 \

     STC_API uint32_t c_default_hash16(const void *data, size_t len); \

     STC_API uint32_t c_default_hash32(const void* data, size_t len); \

 \

-    implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+    _implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                          keyDestroy, RawKey, keyToRaw, keyFromRaw, RawVal, valueFromRaw)

 

 /* -------------------------- IMPLEMENTATION ------------------------- */

 

 #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION)

-#define implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define _implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyToRaw, keyFromRaw, RawVal, valueFromRaw) \

     STC_API ctype##_##X \

     ctype##_##X##_with_capacity(size_t cap) { \

@@ -410,8 +410,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     } \

 \

     STC_API void \

-    ctype##_##X##_erase_entry(ctype##_##X* self, ctype##_##X##_value_t* item) { \

-        size_t i = chash_entry_index(*self, item), j = i, k, cap = self->bucket_count; \

+    ctype##_##X##_erase_entry(ctype##_##X* self, ctype##_##X##_value_t* get) { \

+        size_t i = chash_entry_index(*self, get), j = i, k, cap = self->bucket_count; \

         ctype##_##X##_value_t* slot = self->table; \

         uint8_t* hashx = self->_hashx; \

         ctype##_##X##_entry_destroy(&slot[i]); \

@@ -446,7 +446,7 @@ STC_API uint32_t c_default_hash32(const void* data, size_t len) {
 }

 

 #else

-#define implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

+#define _implement_CHASH(X, ctype, Key, Mapped, valueDestroy, keyEqualsRaw, keyHashRaw, \

                              keyDestroy, RawKey, keyToRaw, keyFromRaw)

 #endif

 

diff --git a/stc/cpqueue.h b/stc/cpqueue.h
index 47612e2c..d5f5a9e6 100644
--- a/stc/cpqueue.h
+++ b/stc/cpqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cpqueue.h>

-    declare_cvec(f, float);

-    declare_cpqueue(f, cvec_f, >); // min-heap (increasing values)

+    cdef_cvec(f, float);

+    cdef_cpqueue(f, cvec_f, >); // min-heap (increasing values)

 

     int main() {

         crand_rng32_t gen = crand_rng32_init(1234);

@@ -50,7 +50,7 @@
 

 #include "cvec.h"

 

-#define declare_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \

+#define cdef_cpqueue(X, ctype, cmpOpr) /* cmpOpr: < or > */ \

 \

     typedef struct ctype cpqueue_##X; \

     typedef ctype##_value_t cpqueue_##X##_value_t; \

diff --git a/stc/cqueue.h b/stc/cqueue.h
index 8e6d7096..dfdab1cd 100644
--- a/stc/cqueue.h
+++ b/stc/cqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cqueue.h>

-    declare_clist(i, int);

-    declare_cqueue(i, clist_i); // min-heap (increasing values)

+    cdef_clist(i, int);

+    cdef_cqueue(i, clist_i); // min-heap (increasing values)

 

     int main() {

         int n = 10000000;

@@ -58,7 +58,7 @@
 

 #include "clist.h"

 

-#define declare_cqueue(X, ctype) \

+#define cdef_cqueue(X, ctype) \

 \

     typedef struct ctype cqueue_##X; \

     typedef ctype##_value_t cqueue_##X##_value_t; \

diff --git a/stc/cstack.h b/stc/cstack.h
index 8f124930..65ccc45f 100644
--- a/stc/cstack.h
+++ b/stc/cstack.h
@@ -26,8 +26,8 @@
     #include <stc/cstack.h>

     #include <stdio.h>

 

-    declare_cvec(i, int);

-    declare_cstack(i, cvec_i);

+    cdef_cvec(i, int);

+    cdef_cstack(i, cvec_i);

 

     int main() {

         cstack_i stack = cstack_i_init();

@@ -47,7 +47,7 @@
 

 #include "cvec.h"

 

-#define declare_cstack(X, ctype) \

+#define cdef_cstack(X, ctype) \

 \

     typedef struct ctype cstack_##X; \

     typedef ctype##_value_t cstack_##X##_value_t; \

diff --git a/stc/cstr.h b/stc/cstr.h
index bd447a59..351e1beb 100644
--- a/stc/cstr.h
+++ b/stc/cstr.h
@@ -30,7 +30,7 @@
 #include "cdefs.h"

 

 typedef struct cstr { char* str; } cstr_t;

-typedef struct { char *item; } cstr_iter_t;

+typedef struct { char *get; } cstr_iter_t;

 typedef char cstr_value_t;

 

 static size_t _cstr_nullrep[] = {0, 0, 0};

@@ -42,7 +42,7 @@ static  cstr_t cstr_ini =  {(char* ) &_cstr_nullrep[2]};
 #define cstr_npos          ((size_t) (-1))

 

 STC_API cstr_t

-cstr_make_n(const char* str, size_t len);

+cstr_n(const char* str, size_t len);

 STC_API cstr_t

 cstr_from(const char* fmt, ...);

 STC_API void

@@ -89,13 +89,13 @@ cstr_with_size(size_t len, char fill) {
     return s;

 }

 STC_INLINE cstr_t

-cstr_make(const char* str) {

-    return cstr_make_n(str, strlen(str));

+cstr(const char* str) {

+    return cstr_n(str, strlen(str));

 }

 

 STC_INLINE cstr_t

 cstr_clone(cstr_t s) {

-    return cstr_make_n(s.str, cstr_size(s));

+    return cstr_n(s.str, cstr_size(s));

 }

 

 STC_INLINE void

@@ -114,8 +114,8 @@ STC_INLINE cstr_iter_t
 cstr_end(cstr_t* self) {

     cstr_iter_t it = {self->str + cstr_size(*self)}; return it;

 }

-STC_INLINE void cstr_next(cstr_iter_t* it) { ++it->item; }

-STC_INLINE char* cstr_itval(cstr_iter_t it) {return it.item;}

+STC_INLINE void cstr_next(cstr_iter_t* it) { ++it->get; }

+STC_INLINE char* cstr_itval(cstr_iter_t it) {return it.get;}

 

 STC_INLINE cstr_t*

 cstr_assign(cstr_t* self, const char* str) {

@@ -228,7 +228,7 @@ cstr_resize(cstr_t* self, size_t len, char fill) {
 }

 

 STC_API cstr_t

-cstr_make_n(const char* str, size_t len) {

+cstr_n(const char* str, size_t len) {

     if (len == 0) return cstr_ini;

     size_t *rep = (size_t *) malloc(_cstr_mem(len));

     cstr_t s = {(char *) memcpy(rep + 2, str, len)};

diff --git a/stc/cvec.h b/stc/cvec.h
index 98c970f0..1adb3cca 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -32,18 +32,18 @@
 #define cvec_capacity(v)   _cvec_safe_capacity((v).data)

 #define cvec_empty(v)      (cvec_size(v) == 0)

 

-#define declare_cvec(...)   c_MACRO_OVERLOAD(declare_cvec, __VA_ARGS__)

-#define declare_cvec_2(X, Value) \

-                            declare_cvec_3(X, Value, c_default_destroy)

-#define declare_cvec_3(X, Value, valueDestroy) \

-                            declare_cvec_4(X, Value, valueDestroy, c_default_compare)

-#define declare_cvec_4(X, Value, valueDestroy, valueCompare) \

-                            declare_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw)

-#define declare_cvec_str() \

-                            declare_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr_make)

+#define cdef_cvec(...)   c_MACRO_OVERLOAD(cdef_cvec, __VA_ARGS__)

+#define cdef_cvec_2(X, Value) \

+                            cdef_cvec_3(X, Value, c_default_destroy)

+#define cdef_cvec_3(X, Value, valueDestroy) \

+                            cdef_cvec_4(X, Value, valueDestroy, c_default_compare)

+#define cdef_cvec_4(X, Value, valueDestroy, valueCompare) \

+                            cdef_cvec_7(X, Value, valueDestroy, valueCompare, Value, c_default_to_raw, c_default_from_raw)

+#define cdef_cvec_str() \

+                            cdef_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr)

 

 

-#define declare_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \

+#define cdef_cvec_7(X, Value, valueDestroy, valueCompareRaw, RawValue, valueToRaw, valueFromRaw) \

 \

     typedef struct cvec_##X { \

         Value* data; \

@@ -51,7 +51,7 @@
     typedef Value cvec_##X##_value_t; \

     typedef RawValue cvec_##X##_rawvalue_t; \

     typedef cvec_##X##_rawvalue_t cvec_##X##_input_t; \

-    typedef struct { Value *item; } cvec_##X##_iter_t; \

+    typedef struct { Value *get; } cvec_##X##_iter_t; \

 \

     STC_INLINE cvec_##X \

     cvec_##X##_init(void) {cvec_##X v = cvec_ini; return v;} \

@@ -132,12 +132,12 @@
 \

     STC_INLINE cvec_##X##_iter_t \

     cvec_##X##_erase_at(cvec_##X* self, cvec_##X##_iter_t pos) { \

-        cvec_##X##_iter_t next = {pos.item + 1}; \

+        cvec_##X##_iter_t next = {pos.get + 1}; \

         return cvec_##X##_erase_range(self, pos, next); \

     } \

     STC_INLINE cvec_##X##_iter_t \

     cvec_##X##_erase_at_idx(cvec_##X* self, size_t idx) { \

-        cvec_##X##_iter_t first = {self->data + idx}, finish = {first.item + 1}; \

+        cvec_##X##_iter_t first = {self->data + idx}, finish = {first.get + 1}; \

         return cvec_##X##_erase_range(self, first, finish); \

     } \

     STC_INLINE cvec_##X##_iter_t \

@@ -181,11 +181,11 @@
         cvec_##X##_iter_t it = {self->data + cvec_size(*self)}; return it; \

     } \

     STC_INLINE void \

-    cvec_##X##_next(cvec_##X##_iter_t* it) {++it->item;} \

+    cvec_##X##_next(cvec_##X##_iter_t* it) {++it->get;} \

     STC_INLINE cvec_##X##_value_t* \

-    cvec_##X##_itval(cvec_##X##_iter_t it) {return it.item;} \

+    cvec_##X##_itval(cvec_##X##_iter_t it) {return it.get;} \

     STC_INLINE size_t \

-    cvec_##X##_idx(cvec_##X v, cvec_##X##_iter_t it) {return it.item - v.data;} \

+    cvec_##X##_idx(cvec_##X v, cvec_##X##_iter_t it) {return it.get - v.data;} \

 \

     implement_cvec_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw)

 

@@ -242,13 +242,13 @@
     STC_API cvec_##X##_iter_t \

     cvec_##X##_insert_range(cvec_##X* self, cvec_##X##_iter_t pos, cvec_##X##_iter_t first, cvec_##X##_iter_t finish) { \

         enum {max_buf = c_max_alloca / sizeof(Value) + 1}; Value buf[max_buf]; \

-        size_t len = finish.item - first.item, idx = pos.item - self->data, size = cvec_size(*self); \

-        Value* xbuf = (Value *) memcpy(len > max_buf ? c_new_n(Value, len) : buf, first.item, len * sizeof(Value)); \

+        size_t len = finish.get - first.get, idx = pos.get - self->data, size = cvec_size(*self); \

+        Value* xbuf = (Value *) memcpy(len > max_buf ? c_new_n(Value, len) : buf, first.get, len * sizeof(Value)); \

         if (size + len > cvec_capacity(*self)) \

             cvec_##X##_reserve(self, 4 + (size + len) * 3 / 2); \

-        pos.item = self->data + idx; \

-        memmove(pos.item + len, pos.item, (size - idx) * sizeof(Value)); \

-        memcpy(pos.item, xbuf, len * sizeof(Value)); \

+        pos.get = self->data + idx; \

+        memmove(pos.get + len, pos.get, (size - idx) * sizeof(Value)); \

+        memcpy(pos.get, xbuf, len * sizeof(Value)); \

         _cvec_size(self) += len; \

         if (len > max_buf) free(xbuf); \

         return pos; \

@@ -256,11 +256,11 @@
 \

     STC_API cvec_##X##_iter_t \

     cvec_##X##_erase_range(cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t finish) { \

-        intptr_t len = finish.item - first.item; \

+        intptr_t len = finish.get - first.get; \

         if (len > 0) { \

-            Value* p = first.item, *end = p + _cvec_size(self); \

-            while (p != finish.item) valueDestroy(p++); \

-            memmove(first.item, finish.item, (end - finish.item) * sizeof(Value)); \

+            Value* p = first.get, *end = p + _cvec_size(self); \

+            while (p != finish.get) valueDestroy(p++); \

+            memmove(first.get, finish.get, (end - finish.get) * sizeof(Value)); \

             _cvec_size(self) -= len; \

         } \

         return first; \

@@ -268,8 +268,8 @@
 \

     STC_API cvec_##X##_iter_t \

     cvec_##X##_find_in_range(const cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t finish, RawValue rawValue) { \

-        for (; first.item != finish.item; cvec_##X##_next(&first)) { \

-            RawValue r = valueToRaw(first.item); \

+        for (; first.get != finish.get; cvec_##X##_next(&first)) { \

+            RawValue r = valueToRaw(first.get); \

             if (valueCompareRaw(&r, &rawValue) == 0) return first; \

         } \

         return cvec_##X##_end(self); \