Refactoring, cleanup.

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