Changed earlier declare_<container>(..) macro to typedef_<container>(..)

7 files changed, 81 insertions, 80 deletions

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

  // demo:

 #include <stc/carray.h>

-c_carray(f, float);

+typedef_carray(f, float);

 

 int main()

 {

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

 

 

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

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

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

 \

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

@@ -91,12 +91,12 @@ STC_INLINE size_t _carray3_size(const size_t* zdim) {
         } \

     }

 

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

-#define c_carray_2(X, Value) \

-    c_carray_3(X, Value, c_default_destroy)

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

+#define typedef_carray_2(X, Value) \

+    typedef_carray_3(X, Value, c_default_destroy)

 

 

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

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

 \

     typedef Value carray1##X##_value_t; \

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

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

     } carray3##X; \

 \

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

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

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

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

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

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

 \

     STC_INLINE carray1##X \

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

diff --git a/stc/clist.h b/stc/clist.h
index 27bdefb4..1fd88310 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -35,7 +35,7 @@
     #include <stdio.h>

     #include <stc/clist.h>

     #include <stc/crandom.h>

-    c_clist(ix, int64_t);

+    typedef_clist(ix, int64_t);

 

     int main() {

         clist_ix list = clist_ini;

@@ -56,19 +56,19 @@
     }

 */

 

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

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

 

-#define c_clist_2(X, Value) \

-                             c_clist_3(X, Value, c_default_destroy)

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

-                             c_clist_4(X, Value, valueDestroy, c_default_compare)

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

-                             c_clist_7(X, Value, valueDestroy, Value, \

+#define typedef_clist_2(X, Value) \

+                             typedef_clist_3(X, Value, c_default_destroy)

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

+                             typedef_clist_4(X, Value, valueDestroy, c_default_compare)

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

+                             typedef_clist_7(X, Value, valueDestroy, Value, \

                                           valueCompare, c_default_to_raw, c_default_from_raw)

-#define c_clist_str()  c_clist_7(str, cstr_t, cstr_destroy, const char*, \

+#define typedef_clist_str()  typedef_clist_7(str, cstr_t, cstr_destroy, const char*, \

                                       cstr_compare_raw, cstr_to_raw, cstr)

 

-#define c_clist_types(X, Value) \

+#define typedef_clist_types(X, Value) \

     typedef Value clist_##X##_value_t; \

 \

     typedef struct clist_##X##_node { \

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

 } while (0)

 

-c_clist_types(void, int);

+typedef_clist_types(void, int);

 STC_API size_t _clist_size(const clist_void* self);

 

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

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

 \

-    c_clist_types(X, Value); \

+    typedef_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

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

 \

diff --git a/stc/cmap.h b/stc/cmap.h
index 5f18bb00..3192be93 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -23,8 +23,8 @@
 /*

 #include <stdio.h>

 #include <stc/cmap.h>

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

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

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

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

 

 int main(void) {

     cset_sx s = cset_ini;

@@ -56,10 +56,9 @@ int main(void) {
 #define cmap_ini                      {NULL, NULL, 0, 0, 0.85f, 0.15f}

 #define cmap_empty(m)                 ((m).size == 0)

 #define cmap_size(m)                  ((size_t) (m).size)

-#define cmap_bucket_count(m)          ((size_t) (m).bucket_count)

 #define cset_ini                      cmap_ini

+#define cset_empty(s)                 cmap_empty(s)

 #define cset_size(s)                  cmap_size(s)

-#define cset_bucket_count(s)          cmap_bucket_count(s)

 

 #define c_try_emplace(self, ctype, key, val) do { \

     ctype##_result_t __r = ctype##_insert_key_(self, key); \

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

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

 

-#define c_cmap(...) \

-    c_MACRO_OVERLOAD(c_cmap, __VA_ARGS__)

+#define typedef_cmap(...) \

+    c_MACRO_OVERLOAD(typedef_cmap, __VA_ARGS__)

 

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

-    c_cmap_4(X, Key, Mapped, c_default_destroy)

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

+    typedef_cmap_4(X, Key, Mapped, c_default_destroy)

 

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

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

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

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

 

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

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

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

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

                  c_default_destroy, Key, c_default_to_raw, c_default_from_raw)

 

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

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

                      keyDestroy, RawKey, keyToRaw, keyFromRaw) \

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

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

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

 

 /* cset: */

-#define c_cset(...) \

-    c_MACRO_OVERLOAD(c_cset, __VA_ARGS__)

+#define typedef_cset(...) \

+    c_MACRO_OVERLOAD(typedef_cset, __VA_ARGS__)

 

-#define c_cset_2(X, Key) \

-    c_cset_4(X, Key, c_default_equals, c_default_hash16)

+#define typedef_cset_2(X, Key) \

+    typedef_cset_4(X, Key, c_default_equals, c_default_hash16)

 

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

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

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

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

 

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

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

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

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

                 Key, c_default_to_raw, c_default_from_raw)

 

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

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

                     RawKey, keyToRaw, keyFromRaw) \

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

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

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

 

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

-#define c_cset_str() \

+#define typedef_cset_str() \

     _c_declare_CHASH_strkey(str, cset, cstr_t, void)

 

-#define c_cmap_str() \

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

+#define typedef_cmap_str() \

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

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

 

-#define c_cmap_strkey(...) \

-    c_MACRO_OVERLOAD(c_cmap_strkey, __VA_ARGS__)

+#define typedef_cmap_strkey(...) \

+    c_MACRO_OVERLOAD(typedef_cmap_strkey, __VA_ARGS__)

 

-#define c_cmap_strkey_2(X, Mapped) \

+#define typedef_cmap_strkey_2(X, Mapped) \

     _c_declare_CHASH_strkey(X, cmap, Mapped, c_default_destroy)

 

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

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

     _c_declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

 

-#define c_cmap_strval(...) \

-    c_MACRO_OVERLOAD(c_cmap_strval, __VA_ARGS__)

+#define typedef_cmap_strval(...) \

+    c_MACRO_OVERLOAD(typedef_cmap_strval, __VA_ARGS__)

 

-#define c_cmap_strval_2(X, Key) \

-    c_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

+#define typedef_cmap_strval_2(X, Key) \

+    typedef_cmap_strval_4(X, Key, c_default_equals, c_default_hash16)

 

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

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

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

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

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

 

 #define _c_declare_CHASH_strkey(X, ctype, Mapped, valueDestroy) \

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

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

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

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

@@ -153,7 +152,7 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define KEY_NAME_cmap       first

 

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

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

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

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

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

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

@@ -201,6 +200,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
     STC_INLINE size_t \

     ctype##_##X##_size(ctype##_##X m) {return (size_t) m.size;} \

     STC_INLINE size_t \

+    ctype##_##X##_bucket_count(ctype##_##X m) {return (size_t) m.bucket_count;} \

+    STC_INLINE size_t \

     ctype##_##X##_capacity(ctype##_##X m) {return (size_t) (m.bucket_count * m.max_load_factor);} \

     STC_INLINE void \

     ctype##_##X##_swap(ctype##_##X* a, ctype##_##X* b) {c_swap(ctype##_##X, *a, *b);} \

diff --git a/stc/cpqueue.h b/stc/cpqueue.h
index e65c67e0..7b2a02ad 100644
--- a/stc/cpqueue.h
+++ b/stc/cpqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cpqueue.h>

-    c_cvec(f, float);

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

+    typedef_cvec(f, float);

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

 

     int main() {

         crand_rng32_t gen = crand_rng32_init(1234);

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

 #include "cvec.h"

 

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

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

 \

     typedef struct ctype cpqueue_##X; \

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

diff --git a/stc/cqueue.h b/stc/cqueue.h
index c4e095d8..3962f3d8 100644
--- a/stc/cqueue.h
+++ b/stc/cqueue.h
@@ -25,8 +25,8 @@
 

     #include <stc/crandom.h>

     #include <stc/cqueue.h>

-    c_clist(i, int);

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

+    typedef_clist(i, int);

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

 

     int main() {

         int n = 10000000;

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

 #include "clist.h"

 

-#define c_cqueue(X, ctype) \

+#define typedef_cqueue(X, ctype) \

 \

     typedef struct ctype cqueue_##X; \

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

diff --git a/stc/cstack.h b/stc/cstack.h
index 97e7a0e2..f6a5777e 100644
--- a/stc/cstack.h
+++ b/stc/cstack.h
@@ -26,8 +26,8 @@
     #include <stc/cstack.h>

     #include <stdio.h>

 

-    c_cvec(i, int);

-    c_cstack(i, cvec_i);

+    typedef_cvec(i, int);

+    typedef_cstack(i, cvec_i);

 

     int main() {

         cstack_i stack = cstack_i_init();

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

 #include "cvec.h"

 

-#define c_cstack(X, ctype) \

+#define typedef_cstack(X, ctype) \

 \

     typedef struct ctype cstack_##X; \

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

diff --git a/stc/cvec.h b/stc/cvec.h
index f3ab9325..0b664c9c 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -32,18 +32,18 @@
 #define cvec_capacity(v)   _cvec_safe_capacity((v).data)

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

 

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

-#define c_cvec_2(X, Value) \

-                    c_cvec_3(X, Value, c_default_destroy)

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

-                    c_cvec_4(X, Value, valueDestroy, c_default_compare)

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

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

-#define c_cvec_str() \

-                    c_cvec_7(str, cstr_t, cstr_destroy, cstr_compare_raw, const char*, cstr_to_raw, cstr)

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

+#define typedef_cvec_2(X, Value) \

+                    typedef_cvec_3(X, Value, c_default_destroy)

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

+                    typedef_cvec_4(X, Value, valueDestroy, c_default_compare)

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

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

+#define typedef_cvec_str() \

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

 

 

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

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

 \

     typedef struct cvec_##X { \

         Value* data; \