From fe30df42ee433a17636b02bc2df45337e96f1ced Mon Sep 17 00:00:00 2001
From: Tyge Løvset <60263450+tylo-work@users.noreply.github.com>
Date: Wed, 4 Mar 2020 22:24:31 +0100
Subject: Refactoring, cleanup.

---
 cmap.h      | 30 ++++++++++++++++++------------
 cmap_test.c | 32 +++++++++++++++++---------------
 cstring.h   | 10 +++++-----
 cvector.h   | 45 ++++++++++++++++++++++-----------------------
 4 files changed, 62 insertions(+), 55 deletions(-)

diff --git a/cmap.h b/cmap.h
index 30a8d82e..3a8b0408 100644
--- a/cmap.h
+++ b/cmap.h
@@ -7,21 +7,22 @@
 #define CMapEntry(tag) CMapEntry_##tag##_t
 #define CMapIter(tag)  CMapIter_##tag##_t
 
-#define cmap_INIT         {cvector_INIT, 0}
+#define cmap_initializer  {cvector_initializer, 0}
 #define cmap_size(cm)     ((cvector_size_t) (cm)._size)
 #define cmap_capacity(cm) cvector_capacity((cm)._vec)
 
 
 // CMapEntry:
-#define declare_CMapEntry_5(tag, Key, Value, keyDestroy, valueDestroy) \
-typedef struct CMapEntry(tag) { Key key; Value value; short untouched, _used; } CMapEntry(tag); \
-typedef struct CMapIter(tag) { CMapEntry(tag) *item, *_end; } CMapIter(tag); \
+#define declare_CMapEntry(tag, Key, Value, keyDestroy, valueDestroy) \
+struct CMapEntry(tag) { Key key; Value value; short untouched, _used; }; \
  \
-static inline void cmapentry_##tag##_destroy(CMapEntry(tag)* p) { \
+static inline void cmapentry_##tag##_destroy(struct CMapEntry(tag)* p) { \
     keyDestroy(&p->key); \
     valueDestroy(&p->value); \
     p->_used = 0; \
-}
+} \
+typedef struct CMapEntry(tag) CMapEntry(tag)
+
 
 // CMap:
 #define declare_CMap(...)  cdef_MACRO_OVERLOAD(declare_CMap, __VA_ARGS__)
@@ -45,7 +46,7 @@ static inline void cmapentry_##tag##_destroy(CMapEntry(tag)* p) { \
 
 // CMap full:
 #define declare_CMap_10(tag, Key, Value, valueDestroy, KeyRaw, keyGetRaw, keyCompare, keyHasher, keyInit, keyDestroy) \
-  declare_CMapEntry_5(tag, Key, Value, keyDestroy, valueDestroy); \
+  declare_CMapEntry(tag, Key, Value, keyDestroy, valueDestroy); \
   declare_CVector_3(_map##tag, CMapEntry(tag), cmapentry_##tag##_destroy); \
  \
 typedef struct CMap(tag) { \
@@ -53,8 +54,12 @@ typedef struct CMap(tag) { \
     cvector_size_t _size; \
 } CMap(tag); \
  \
+typedef struct CMapIter(tag) { \
+    CMapEntry(tag) *item, *_end; \
+} CMapIter(tag); \
+ \
 static inline CMap(tag) cmap_##tag##_init(void) { \
-    CMap(tag) map = cmap_INIT; \
+    CMap(tag) map = cmap_initializer; \
     return map; \
 } \
  \
@@ -68,7 +73,7 @@ static inline void cmap_##tag##_destroy(CMap(tag)* self) { \
 } \
  \
 static inline void cmap_##tag##_clear(CMap(tag)* self) { \
-    CMap(tag) cm = cmap_INIT; \
+    CMap(tag) cm = cmap_initializer; \
     cmap_##tag##_destroy(self); \
     *self = cm; \
 } \
@@ -112,7 +117,7 @@ static inline CMapEntry(tag)* cmap_##tag##_put(CMap(tag)* self, KeyRaw rawKey, V
 } \
  \
 static inline cvector_size_t cmap_##tag##_rehash(CMap(tag)* self) { \
-    CVector(_map##tag) vec = cvector_INIT; \
+    CVector(_map##tag) vec = cvector_initializer; \
     cvector_size_t newcap = 7 + cmap_capacity(*self) * 2; \
     cvector__map##tag##_swap(&self->_vec, &vec); \
     cvector__map##tag##_reserve(&self->_vec, newcap); \
@@ -135,7 +140,6 @@ static inline int cmap_##tag##_erase(CMap(tag)* self, KeyRaw rawKey) { \
     return 0; \
 } \
  \
- \
 static inline CMapIter(tag) cmap_##tag##_begin(CMap(tag) map) { \
     CMapIter(tag) null = {NULL, NULL}; \
     if (map._size == 0) return null; \
@@ -154,7 +158,9 @@ static inline CMapIter(tag) cmap_##tag##_end(CMap(tag) map) { \
     CMapEntry(tag)* end = (map._size == 0) ? NULL : map._vec.data + _cvector_capacity(map._vec); \
     CMapIter(tag) iter = {end, end}; \
     return iter; \
-}
+} \
+typedef Key cmap_##tag##_key_t; \
+typedef Value cmap_##tag##_value_t
 
 
 #define FIBONACCI_DECL  cvector_size_t fib1 = 1, fib2 = 2, fibx
diff --git a/cmap_test.c b/cmap_test.c
index 8d33a6ac..0bcbaefa 100644
--- a/cmap_test.c
+++ b/cmap_test.c
@@ -5,7 +5,7 @@
 #include "cstring.h"
 
 
-declare_CVector(cs, CString, cstring_destroy);
+declare_CVector(s, CString, cstring_destroy);
 declare_CMap_STR(ss, CString, cstring_destroy);
 declare_CMap_STR(si, int);
 declare_CMap(id, uint64_t, double);
@@ -49,7 +49,7 @@ int main()
 {
     int i = 0;
 
-    CMap(si) words = cmap_INIT;
+    CMap(si) words = cmap_initializer;
     printf("read words\n");
     read_words(&words);
 
@@ -63,36 +63,38 @@ int main()
     printf("words size: %d, capacity %d\n", cmap_size(words), cmap_capacity(words));
     cmap_si_clear(&words);
 
-    CVector(cs) strv = cvector_INIT;
+    CVector(s) strv = cvector_initializer;
     CString hello = cstring_make("Hello");
     cstring_assign(&hello, "Awesome");
 
-    cvector_cs_push(&strv, cstring_make("E1"));
-    cvector_cs_push(&strv, cstring_make("E2"));
-    cvector_cs_push(&strv, cstring_make("E3"));
-    CVectorIter(cs) it1; cforeach (it1, cvector_cs, strv) {
-        printf("  %s\n", it1.item->str);
+    cvector_s_push(&strv, cstring_make("E0"));
+    cvector_s_push(&strv, cstring_make("E1"));
+    cvector_s_push(&strv, cstring_make("E2"));
+    printf("  element %d: %s\n", 1, strv.data[1].str);
+    
+    CVectorIter(s) ii; cforeach (ii, cvector_s, strv) {
+        printf("  %s\n", ii.item->str);
     }
     
     for (i = 0; i < cvector_size(strv); ++i) {
         printf("  %s\n", strv.data[i].str);
     }
-    cvector_cs_destroy(&strv);
+    cvector_s_destroy(&strv);
 
-    CMap(ss) smap = cmap_INIT;
+    CMap(ss) smap = cmap_initializer;
     cmap_ss_put(&smap, "KEY1", cstring_make("VAL1"));
     cmap_ss_put(&smap, "KEY2", cstring_make("VAL2"));
-    cmap_ss_put(&smap, "hello", cstring_makeCopy(hello));
+    cmap_ss_put(&smap, "hello", cstring_clone(hello));
     
     cstring_destroy(&hello);
     
-    CMapIter(ss) it2 = cmap_ss_begin(smap), end2 = cmap_ss_end(smap);
-    for (; it2.item != end2.item; it2 = cmap_ss_next(it2)) {
-        printf("  %s: %s\n", it2.item->key.str, it2.item->value.str);
+    CMapIter(ss) kk = cmap_ss_begin(smap), end2 = cmap_ss_end(smap);
+    for (; kk.item != end2.item; kk = cmap_ss_next(kk)) {
+        printf("  %s: %s\n", kk.item->key.str, kk.item->value.str);
     }
     cmap_ss_destroy(&smap);
 
-    CMap(id) mymap = cmap_INIT;
+    CMap(id) mymap = cmap_initializer;
     for (i = 0; i < 600000; ++i)
         cmap_id_put(&mymap, i*i, i);
         
diff --git a/cstring.h b/cstring.h
index efedf1b6..5d8b8035 100644
--- a/cstring.h
+++ b/cstring.h
@@ -18,7 +18,7 @@ typedef struct CString {
 static cstring_size_t _cstring_null_rep[] = {0, 0, 0};
 #define               _cstring_rep(cs)      (((cstring_size_t *) (cs).str) - 2)
 
-#define cstring_INIT          {(char* ) (_cstring_null_rep + 2)}
+#define cstring_initializer   {(char* ) (_cstring_null_rep + 2)}
 #define cstring_size(cs)      ((cstring_size_t) _cstring_rep(cs)[0])
 #define cstring_capacity(cs)  ((cstring_size_t) _cstring_rep(cs)[1])
 
@@ -41,12 +41,12 @@ static inline void cstring_destroy(CString* self) {
 }
 
 static inline CString cstring_init(void) {
-    CString cs = cstring_INIT;
+    CString cs = cstring_initializer;
     return cs;
 }
 
 static inline CString cstring_makeN(const char* str, cstring_size_t len) {
-    CString cs = cstring_INIT;
+    CString cs = cstring_initializer;
     if (len) {
         cstring_reserve(&cs, len);
         memcpy(cs.str, str, len);
@@ -60,12 +60,12 @@ static inline CString cstring_make(const char* str) {
     return cstring_makeN(str, strlen(str));
 }
 
-static inline CString cstring_makeCopy(CString cs) {
+static inline CString cstring_clone(CString cs) {
     return cstring_makeN(cs.str, cstring_size(cs));
 }
 
 static inline void cstring_clear(CString* self) {
-    CString cs = cstring_INIT;
+    CString cs = cstring_initializer;
     cstring_destroy(self);
     *self = cs;
 }
diff --git a/cvector.h b/cvector.h
index 49f06c77..9bb983d5 100644
--- a/cvector.h
+++ b/cvector.h
@@ -25,39 +25,38 @@ static inline cvector_size_t _cvector_safe_capacity(const void* data) {
 }
 
 
-#define CVector(tag) CVector_##tag##_t
-#define CVectorIter(tag) CVectorIter_##tag##_t
+#define CVector(tag)           CVector_##tag##_t
+#define CVectorIter(tag)       CVectorIter_##tag##_t
 
-#define cvector_INIT           {NULL}
+#define cvector_initializer    {NULL}
 #define cvector_size(cv)       _cvector_safe_size((cv).data)
 #define cvector_capacity(cv)   _cvector_safe_capacity((cv).data)
 #define cvector_empty(cv)      (_cvector_safe_size((cv).data) == 0)
 
 #define declare_CVector(...)       cdef_MACRO_OVERLOAD(declare_CVector, __VA_ARGS__)
-#define declare_CVector_2(tag, T)  declare_CVector_3(tag, T, cdef_destroy)
+#define declare_CVector_2(tag, Value)  declare_CVector_3(tag, Value, cdef_destroy)
 #define declare_CVector_STR(tag)   declare_CVector_3(tag, CString, cstring_destroy)
 
 
-#define declare_CVector_3(tag, T, valueDestroy) \
-typedef T cvector_##tag##_value_t; \
+#define declare_CVector_3(tag, Value, valueDestroy) \
 typedef struct CVector(tag) { \
-    T* data; \
+    Value* data; \
 } CVector(tag); \
 typedef struct CVectorIter(tag) { \
-    T* item; \
+    Value* item; \
 } CVectorIter(tag); \
  \
 static inline CVector(tag) cvector_##tag##_init(void) { \
-    CVector(tag) cv = cvector_INIT; \
+    CVector(tag) cv = cvector_initializer; \
     return cv; \
 } \
  \
 static inline void cvector_##tag##_swap(CVector(tag)* a, CVector(tag)* b) { \
-    T* data = a->data; a->data = b->data; b->data = data; \
+    Value* data = a->data; a->data = b->data; b->data = data; \
 } \
  \
 static inline void cvector_##tag##_destroy(CVector(tag)* self) { \
-    T* p = self->data; \
+    Value* p = self->data; \
     cvector_size_t i = 0, n = cvector_size(*self); \
     for (; i < n; ++p, ++i) valueDestroy(p); \
     free(_cvector_alloced(self->data)); \
@@ -66,32 +65,32 @@ static inline void cvector_##tag##_destroy(CVector(tag)* self) { \
 static inline void cvector_##tag##_reserve(CVector(tag)* self, cvector_size_t cap) { \
     if (cap > cvector_capacity(*self)) { \
         cvector_size_t len = cvector_size(*self); \
-        cvector_size_t* rep = (cvector_size_t *) realloc(_cvector_alloced(self->data), 2 * sizeof(cvector_size_t) + cap * sizeof(T)); \
-        self->data = (T *) (rep + 2); \
+        cvector_size_t* rep = (cvector_size_t *) realloc(_cvector_alloced(self->data), 2 * sizeof(cvector_size_t) + cap * sizeof(Value)); \
+        self->data = (Value *) (rep + 2); \
         rep[0] = len; \
         rep[1] = cap; \
     } \
 } \
  \
  \
-static inline CVector(tag) cvector_##tag##_make(const T* data, cvector_size_t len) { \
-    CVector(tag) cv = cvector_INIT; \
+static inline CVector(tag) cvector_##tag##_make(const Value* data, cvector_size_t len) { \
+    CVector(tag) cv = cvector_initializer; \
     if (len) { \
         cvector_##tag##_reserve(&cv, len); \
-        memcpy(cv.data, data, len * sizeof(T)); \
+        memcpy(cv.data, data, len * sizeof(Value)); \
         _cvector_size(cv) = len; \
     } \
     return cv; \
 } \
  \
 static inline void cvector_##tag##_clear(CVector(tag)* self) { \
-    CVector(tag) cv = cvector_INIT; \
+    CVector(tag) cv = cvector_initializer; \
     cvector_##tag##_destroy(self); \
     *self = cv; \
 } \
  \
  \
-static inline void cvector_##tag##_push(CVector(tag)* self, T value) { \
+static inline void cvector_##tag##_push(CVector(tag)* self, Value value) { \
     cvector_size_t newsize = cvector_size(*self) + 1; \
     if (newsize > cvector_capacity(*self)) \
         cvector_##tag##_reserve(self, 7 + newsize * 5 / 3); \
@@ -99,15 +98,15 @@ static inline void cvector_##tag##_push(CVector(tag)* self, T value) { \
     _cvector_size(*self) = newsize; \
 } \
  \
-static inline void cvector_##tag##_insert(CVector(tag)* self, cvector_size_t pos, T value) { \
+static inline void cvector_##tag##_insert(CVector(tag)* self, cvector_size_t pos, Value value) { \
     cvector_##tag##_push(self, value); \
     cvector_size_t len = cvector_size(*self); \
-    memmove(&self->data[pos + 1], &self->data[pos], (len - pos - 1) * sizeof(T)); \
+    memmove(&self->data[pos + 1], &self->data[pos], (len - pos - 1) * sizeof(Value)); \
     self->data[pos] = value; \
 } \
  \
  \
-static inline T cvector_##tag##_back(CVector(tag) cv) { \
+static inline Value cvector_##tag##_back(CVector(tag) cv) { \
     return cv.data[_cvector_size(cv) - 1]; \
 } \
  \
@@ -131,7 +130,7 @@ static inline CVectorIter(tag) cvector_##tag##_next(CVectorIter(tag) iter) { \
 static inline CVectorIter(tag) cvector_##tag##_end(CVector(tag) vec) { \
     CVectorIter(tag) iter = {vec.data + cvector_size(vec)}; \
     return iter; \
-}
-
+} \
+typedef Value cvector_##tag##_value_t
 
 #endif
-- 
cgit v1.2.3