Internal: moved template argument in cdeq, cvec and clist.

7 files changed, 54 insertions, 50 deletions

diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 6ff3bb64..e30967f1 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -9,12 +9,12 @@ See [std::deque](https://en.cppreference.com/w/cpp/container/deque) for correspo
 ```c
 #define using_cdeq(X, Value, valueCompareRaw=c_default_compare,
                              valueDestroy=c_default_del,
-                             RawValue=Value,
                              valueFromRaw=c_default_from_raw,
-                             valueToRaw=c_default_to_raw)
+                             valueToRaw=c_default_to_raw,
+                             RawValue=Value)
 #define using_cdeq_str()
 ```
-The macro `using_cdeq()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
+The macro `using_cdeq()` can be instantiated with 2, 3, 4, 5, or 7 arguments in the global scope.
 Defaults values are given above for args not specified. `X` is a type tag name and
 will affect the names of all cdeq types and methods. E.g. declaring `using_cdeq(my, int);`, `X` should
 be replaced by `my` in all of the following documentation.
diff --git a/docs/clist_api.md b/docs/clist_api.md
index 7fe15c09..10956903 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -11,12 +11,12 @@ is only one pointer, and length of the list is not stored. The method *clist_X_s
 ```c
 #define using_clist(X, Value, valueCompareRaw=c_default_compare,
                               valueDestroy=c_default_del,
-                              RawValue=Value,
                               valueFromRaw=c_default_from_raw,
-                              valueToRaw=c_default_to_raw)
+                              valueToRaw=c_default_to_raw,
+                              RawValue=Value)
 #define using_clist_str()
 ```
-The macro `using_clist()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
+The macro `using_clist()` can be instantiated with 2, 3, 4, 5, or 7 arguments in the global scope.
 Default values are given above for args not specified. `X` is a type tag name and
 will affect the names of all clist types and methods. E.g. declaring `using_clist(my, int);`, `X` should
 be replaced by `my` in all of the following documentation. `using_clist_str()` is a shorthand for
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 435c2a3d..de437853 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -9,12 +9,12 @@ See [std::vector](https://en.cppreference.com/w/cpp/container/vector) for a simi
 ```c
 #define using_cvec(X, Value, valueCompareRaw=c_default_compare,
                              valueDestroy=c_default_del,
-                             RawValue=Value,
                              valueFromRaw=c_default_from_raw,
-                             valueToRaw=c_default_to_raw)
+                             valueToRaw=c_default_to_raw,
+                             RawValue=Value)
 #define using_cvec_str()
 ```
-The macro `using_cvec()` can be instantiated with 2, 3, 4, or 7 arguments in the global scope.
+The macro `using_cvec()` can be instantiated with 2, 3, 4, 5, or 7 arguments in the global scope.
 Defaults values are given above for args not specified. `X` is a type tag name and
 will affect the names of all cvec types and methods. E.g. declaring `using_cvec(my, int);`, `X` should
 be replaced by `my` in all of the following documentation.
diff --git a/stc/cdeq.h b/stc/cdeq.h
index 977456d7..00da9546 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -35,9 +35,11 @@
 #define using_cdeq_3(X, Value, valueCompare) \

                     using_cdeq_4(X, Value, valueCompare, c_default_del)

 #define using_cdeq_4(X, Value, valueCompare, valueDestroy) \

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

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

+#define using_cdeq_5(X, Value, valueCompare, valueDestroy, valueClone) \

+                    using_cdeq_7(X, Value, valueCompare, valueDestroy, valueClone, c_default_to_raw, Value)

 #define using_cdeq_str() \

-                    using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)

+                    using_cdeq_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*)

 

 #define typedefs_cdeq(X, Value, RawValue) \

     typedef Value cdeq_##X##_value_t; \

@@ -48,7 +50,7 @@
         cdeq_##X##_value_t *base, *data; \

     } cdeq_##X

 

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

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

     typedefs_cdeq(X, Value, RawValue); \

 \

     STC_INLINE cdeq_##X \

@@ -199,13 +201,13 @@
     STC_INLINE size_t \

     cdeq_##X##_index(cdeq_##X deq, cdeq_##X##_iter_t it) {return it.ref - deq.data;} \

 \

-    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

+    _c_implement_cdeq_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

     typedef cdeq_##X cdeq_##X##_t

 

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

 

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

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

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

 \

     STC_DEF void \

     cdeq_##X##_push_n(cdeq_##X *self, const cdeq_##X##_input_t arr[], size_t n) { \

@@ -334,7 +336,7 @@
     }

 

 #else

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

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

 #endif

 

 #if defined(_WIN32) && defined(_DLL)

diff --git a/stc/clist.h b/stc/clist.h
index a7ac9b0b..b12e3c90 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -56,16 +56,16 @@
 #include <stdlib.h>

 

 #define using_clist(...)   c_MACRO_OVERLOAD(using_clist, __VA_ARGS__)

-

 #define using_clist_2(X, Value) \

-                             using_clist_3(X, Value, c_default_compare)

+                    using_clist_3(X, Value, c_default_compare)

 #define using_clist_3(X, Value, valueCompare) \

-                             using_clist_4(X, Value, valueCompare, c_default_del)

+                    using_clist_4(X, Value, valueCompare, c_default_del)

 #define using_clist_4(X, Value, valueCompare, valueDestroy) \

-                             using_clist_7(X, Value, valueCompare, valueDestroy, \

-                                              Value, c_default_from_raw, c_default_to_raw)

-#define using_clist_str()    using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, \

-                                              const char*, cstr_from, cstr_to_raw)

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

+#define using_clist_5(X, Value, valueCompare, valueDestroy, valueClone) \

+                    using_clist_7(X, Value, valueCompare, valueDestroy, valueClone, c_default_to_raw, Value)

+#define using_clist_str() \

+                    using_clist_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*)

 

 #define using_clist_types(X, Value) \

     typedef Value clist_##X##_value_t; \

@@ -100,7 +100,7 @@ using_clist_types(void, int);
 STC_API size_t _clist_size(const clist_void* self);

 #define _clist_node(X, vp) c_container_of(vp, clist_##X##_node_t, value)

 

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

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

 \

     using_clist_types(X, Value); \

     typedef RawValue clist_##X##_rawvalue_t; \

@@ -206,13 +206,13 @@ STC_API size_t _clist_size(const clist_void* self);
     STC_INLINE Value* \

     clist_##X##_back(clist_##X* self) {return &self->last->value;} \

 \

-    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

+    _c_implement_clist_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

     typedef clist_##X clist_##X##_t

 

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

 

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

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

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

 \

     STC_DEF clist_##X \

     clist_##X##_clone(clist_##X list) { \

@@ -404,7 +404,7 @@ _clist_mergesort(clist_void_node_t *list, int (*cmp)(const void*, const void*))
 }

 

 #else

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

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

 #endif

 

 #endif

diff --git a/stc/cmap.h b/stc/cmap.h
index d6304e0e..4cad04f3 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -84,13 +84,13 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cmap_10(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

                         keyDel, RawKey, keyFromRaw, keyToRaw) \

-    _c_typedef_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

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

+    _using_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

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

 

 #define using_cmap_12(X, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

                         keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

-    _c_typedef_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                        keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw)

+    _using_CHASH(X, cmap, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                    keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw)

 

 /* cset: */

 #define using_cset(...) \

@@ -108,25 +108,25 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 

 #define using_cset_8(X, Key, keyEqualsRaw, keyHashRaw, keyDel, \

                     RawKey, keyFromRaw, keyToRaw) \

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

-                        keyDel, RawKey, keyFromRaw, keyToRaw, void, c_default_from_raw)

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

+                    keyDel, RawKey, keyFromRaw, keyToRaw, void, c_default_from_raw)

 

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

 #define using_cset_str() \

-    _c_declare_CHASH_strkey(str, cset, cstr_t, void)

+    _using_CHASH_strkey(str, cset, cstr_t, void)

 

 #define using_cmap_str() \

-    _c_typedef_CHASH(str, cmap, cstr_t, cstr_t, cstr_del, cstr_equals_raw, cstr_hash_raw, \

-                          cstr_del, const char*, cstr_from, cstr_to_raw, const char*, cstr_from)

+    _using_CHASH(str, cmap, cstr_t, cstr_t, cstr_del, cstr_equals_raw, cstr_hash_raw, \

+                      cstr_del, const char*, cstr_from, cstr_to_raw, const char*, cstr_from)

 

 #define using_cmap_strkey(...) \

     c_MACRO_OVERLOAD(using_cmap_strkey, __VA_ARGS__)

 

 #define using_cmap_strkey_2(X, Mapped) \

-    _c_declare_CHASH_strkey(X, cmap, Mapped, c_default_del)

+    _using_CHASH_strkey(X, cmap, Mapped, c_default_del)

 

 #define using_cmap_strkey_3(X, Mapped, ValueDestroy) \

-    _c_declare_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

+    _using_CHASH_strkey(X, cmap, Mapped, ValueDestroy)

 

 #define using_cmap_strval(...) \

     c_MACRO_OVERLOAD(using_cmap_strval, __VA_ARGS__)

@@ -139,13 +139,13 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
                            c_default_del, Key, c_default_from_raw, c_default_to_raw)

 

 #define using_cmap_strval_8(X, Key, keyEquals, keyHash, keyDel, RawKey, keyFromRaw, keyToRaw) \

-    _c_typedef_CHASH(X, cmap, Key, cstr_t, cstr_del, keyEquals, keyHash, \

-                        keyDel, RawKey, keyFromRaw, keyToRaw, const char*, cstr_from)

+    _using_CHASH(X, cmap, Key, cstr_t, cstr_del, keyEquals, keyHash, \

+                    keyDel, RawKey, keyFromRaw, keyToRaw, const char*, cstr_from)

 

 

-#define _c_declare_CHASH_strkey(X, ctype, Mapped, mappedDel) \

-    _c_typedef_CHASH(X, ctype, cstr_t, Mapped, mappedDel, cstr_equals_raw, cstr_hash_raw, \

-                        cstr_del, const char*, cstr_from, cstr_to_raw, Mapped, c_default_from_raw)

+#define _using_CHASH_strkey(X, ctype, Mapped, mappedDel) \

+    _using_CHASH(X, ctype, cstr_t, Mapped, mappedDel, cstr_equals_raw, cstr_hash_raw, \

+                    cstr_del, const char*, cstr_from, cstr_to_raw, Mapped, c_default_from_raw)

 

 #define CSET_ONLY_cset(...) __VA_ARGS__

 #define CSET_ONLY_cmap(...)

@@ -155,8 +155,8 @@ typedef struct {size_t idx; uint32_t hx;} cmap_bucket_t, cset_bucket_t;
 #define KEY_REF_cmap(e)     (e)->first

 

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

-#define _c_typedef_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

-                            keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

+#define _using_CHASH(X, ctype, Key, Mapped, mappedDel, keyEqualsRaw, keyHashRaw, \

+                        keyDel, RawKey, keyFromRaw, keyToRaw, RawMapped, mappedFromRaw) \

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

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

     typedef RawKey ctype##_##X##_rawkey_t; \

diff --git a/stc/cvec.h b/stc/cvec.h
index 9404cc36..39b92d8e 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -35,9 +35,11 @@
 #define using_cvec_3(X, Value, valueCompare) \

                     using_cvec_4(X, Value, valueCompare, c_default_del)

 #define using_cvec_4(X, Value, valueCompare, valueDestroy) \

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

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

+#define using_cvec_5(X, Value, valueCompare, valueDestroy, valueClone) \

+                    using_cvec_7(X, Value, valueCompare, valueDestroy, valueClone, c_default_to_raw, Value)

 #define using_cvec_str() \

-                    using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, const char*, cstr_from, cstr_to_raw)

+                    using_cvec_7(str, cstr_t, cstr_compare_raw, cstr_del, cstr_from, cstr_to_raw, const char*)

 

 #define typedefs_cvec(X, Value, RawValue) \

     typedef Value cvec_##X##_value_t; \

@@ -48,7 +50,7 @@
         cvec_##X##_value_t* data; \

     } cvec_##X

 

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

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

     typedefs_cvec(X, Value, RawValue); \

 \

     STC_INLINE cvec_##X \

@@ -188,13 +190,13 @@
     STC_INLINE size_t \

     cvec_##X##_index(cvec_##X vec, cvec_##X##_iter_t it) {return it.ref - vec.data;} \

 \

-    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, RawValue, valueFromRaw, valueToRaw) \

+    _c_implement_cvec_7(X, Value, valueCompareRaw, valueDestroy, valueFromRaw, valueToRaw, RawValue) \

     typedef cvec_##X cvec_##X##_t

 

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

 

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

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

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

 \

     STC_DEF void \

     cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t arr[], size_t n) { \

@@ -301,7 +303,7 @@
     }

 

 #else

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

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

 #endif

 

 #if defined(_WIN32) && defined(_DLL)