Add files via upload

3 files changed, 31 insertions, 33 deletions

diff --git a/cmap.h b/cmap.h
index 7f7280d8..c7f7d93c 100644
--- a/cmap.h
+++ b/cmap.h
@@ -26,7 +26,7 @@
 #include "cvector.h"

 

 #define cmap_initializer  {cvector_initializer, 0}

-#define cmap_size(cm)     ((cvector_size_t) (cm)._size)

+#define cmap_size(cm)     ((size_t) (cm)._size)

 #define cmap_capacity(cm) cvector_capacity((cm)._vec)

 

 

@@ -73,7 +73,7 @@ typedef struct CMapEntry_##tag CMapEntry_##tag
  \

 typedef struct CMap_##tag { \

     CVector_map_##tag _vec; \

-    cvector_size_t _size; \

+    size_t _size; \

 } CMap_##tag; \

  \

 typedef struct cmap_##tag##_iter_t { \

@@ -87,7 +87,7 @@ static inline CMap_##tag cmap_##tag##_init(void) { \
  \

 static inline void cmap_##tag##_destroy(CMap_##tag* self) { \

     if (self->_size) { \

-        cvector_size_t cap = _cvector_capacity(self->_vec); \

+        size_t cap = _cvector_capacity(self->_vec); \

         CMapEntry_##tag* p = self->_vec.data, *end = p + cap; \

         for (; p != end; ++p) if (p->_used) cmapentry_##tag##_destroy(p); \

     } \

@@ -102,12 +102,12 @@ static inline void cmap_##tag##_clear(CMap_##tag* self) { \
  \

 static inline void cmap_##tag##_swap(CMap_##tag* a, CMap_##tag* b) { \

     cvector_map_##tag##_swap(&a->_vec, &b->_vec); \

-    _cdef_swap(cvector_size_t, a->_size, b->_size); \

+    _cdef_swap(size_t, a->_size, b->_size); \

 } \

  \

-static inline cvector_size_t _cmap_##tag##_findIndex(CMap_##tag cm, KeyRaw rawKey) { \

-    cvector_size_t cap = cvector_capacity(cm._vec); \

-    cvector_size_t idx = keyHasher(&rawKey, sizeof(Key)) % cap, first = idx; \

+static inline size_t _cmap_##tag##_findIndex(CMap_##tag cm, KeyRaw rawKey) { \

+    size_t cap = cvector_capacity(cm._vec); \

+    size_t idx = keyHasher(&rawKey, sizeof(Key)) % cap, first = idx; \

     FIBONACCI_DECL; \

     while (cm._vec.data[idx]._used && keyCompare(&cm._vec.data[idx].key, &rawKey, sizeof(Key)) != 0) \

         idx = (first + FIBONACCI_NEXT) % cap; \

@@ -116,17 +116,17 @@ static inline cvector_size_t _cmap_##tag##_findIndex(CMap_##tag cm, KeyRaw rawKe
  \

 static inline CMapEntry_##tag* cmap_##tag##_get(CMap_##tag cm, KeyRaw rawKey) { \

     if (cm._size == 0) return NULL; \

-    cvector_size_t idx = _cmap_##tag##_findIndex(cm, rawKey); \

+    size_t idx = _cmap_##tag##_findIndex(cm, rawKey); \

     return cm._vec.data[idx]._used ? &cm._vec.data[idx] : NULL; \

 } \

  \

-static inline cvector_size_t cmap_##tag##_rehash(CMap_##tag* self); /* predeclared */ \

+static inline size_t cmap_##tag##_rehash(CMap_##tag* self); /* predeclared */ \

  \

 static inline CMapEntry_##tag* cmap_##tag##_put(CMap_##tag* self, KeyRaw rawKey, Value value) { \

-    cvector_size_t cap = cvector_capacity(self->_vec); \

+    size_t cap = cvector_capacity(self->_vec); \

     if (self->_size >= cap * 8 / 10) \

         cap = cmap_##tag##_rehash(self); \

-    cvector_size_t idx = _cmap_##tag##_findIndex(*self, rawKey); \

+    size_t idx = _cmap_##tag##_findIndex(*self, rawKey); \

     CMapEntry_##tag* e = &self->_vec.data[idx]; \

     e->value = value; \

     e->changed = e->_used; \

@@ -138,15 +138,15 @@ static inline CMapEntry_##tag* cmap_##tag##_put(CMap_##tag* self, KeyRaw rawKey,
     return e; \

 } \

  \

-static inline cvector_size_t cmap_##tag##_rehash(CMap_##tag* self) { \

+static inline size_t cmap_##tag##_rehash(CMap_##tag* self) { \

     CVector_map_##tag vec = cvector_initializer; \

-    cvector_size_t newcap = 7 + cmap_capacity(*self) * 2; \

+    size_t newcap = 7 + cmap_capacity(*self) * 2; \

     cvector_map_##tag##_swap(&self->_vec, &vec); \

     cvector_map_##tag##_reserve(&self->_vec, newcap); \

     self->_size = 0; \

     memset(self->_vec.data, 0, sizeof(CMapEntry_##tag) * newcap); \

     CMapEntry_##tag* p = vec.data; \

-    cvector_size_t i, oldcap = cvector_capacity(vec); \

+    size_t i, oldcap = cvector_capacity(vec); \

     for (i = 0; i < oldcap; ++i, ++p) \

         if (p->_used) cmap_##tag##_put(self, keyGetRaw(p->key), p->value); \

     return newcap; \

@@ -185,7 +185,7 @@ typedef Key cmap_##tag##_key_t; \
 typedef Value cmap_##tag##_value_t

 

 

-#define FIBONACCI_DECL  cvector_size_t fib1 = 1, fib2 = 2, fibx

+#define FIBONACCI_DECL  size_t fib1 = 1, fib2 = 2, fibx

 #define FIBONACCI_NEXT  (fibx = fib1 + fib2, fib1 = fib2, fib2 = fibx)

 

 #endif

diff --git a/cmap_test.c b/cmap_test.c
index 7c5e1fad..18d8bdaa 100644
--- a/cmap_test.c
+++ b/cmap_test.c
@@ -83,7 +83,7 @@ int main()
     num = cmap_si_get(words, "funny");

     if (num) printf("%s: %d\n", num->key.str, num->value);

 

-    printf("words size: %d, capacity %d\n", cmap_size(words), cmap_capacity(words));

+    printf("words size: %zd, capacity %zd\n", cmap_size(words), cmap_capacity(words));

     cmap_si_clear(&words);

 

     CVector_s strv = cvector_initializer;

diff --git a/cvector.h b/cvector.h
index 59861407..6feb2905 100644
--- a/cvector.h
+++ b/cvector.h
@@ -31,19 +31,17 @@
 

 #include "cdef.h"

 

-typedef uint32_t cvector_size_t;

+#define _cvector_size(cv) ((size_t *)(cv).data)[-2]

+#define _cvector_capacity(cv) ((size_t *)(cv).data)[-1]

 

-#define _cvector_size(cv) ((cvector_size_t *)(cv).data)[-2]

-#define _cvector_capacity(cv) ((cvector_size_t *)(cv).data)[-1]

-

-static inline cvector_size_t* _cvector_alloced(void* data) {

-    return data ? ((cvector_size_t *) data) - 2 : NULL;

+static inline size_t* _cvector_alloced(void* data) {

+    return data ? ((size_t *) data) - 2 : NULL;

 }

-static inline cvector_size_t _cvector_safe_size(const void* data) {

-    return data ? ((const cvector_size_t *) data)[-2] : 0;

+static inline size_t _cvector_safe_size(const void* data) {

+    return data ? ((const size_t *) data)[-2] : 0;

 }

-static inline cvector_size_t _cvector_safe_capacity(const void* data) {

-    return data ? ((const cvector_size_t *) data)[-1] : 0;

+static inline size_t _cvector_safe_capacity(const void* data) {

+    return data ? ((const size_t *) data)[-1] : 0;

 }

 

 

@@ -76,15 +74,15 @@ static inline void cvector_##tag##_swap(CVector_##tag* a, CVector_##tag* b) { \
  \

 static inline void cvector_##tag##_destroy(CVector_##tag* self) { \

     Value* p = self->data; \

-    cvector_size_t i = 0, n = cvector_size(*self); \

+    size_t i = 0, n = cvector_size(*self); \

     for (; i < n; ++p, ++i) valueDestroy(p); \

     free(_cvector_alloced(self->data)); \

 } \

  \

-static inline void cvector_##tag##_reserve(CVector_##tag* self, cvector_size_t cap) { \

+static inline void cvector_##tag##_reserve(CVector_##tag* self, 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(Value)); \

+        size_t len = cvector_size(*self); \

+        size_t* rep = (size_t *) realloc(_cvector_alloced(self->data), 2 * sizeof(size_t) + cap * sizeof(Value)); \

         self->data = (Value *) (rep + 2); \

         rep[0] = len; \

         rep[1] = cap; \

@@ -99,16 +97,16 @@ static inline void cvector_##tag##_clear(CVector_##tag* self) { \
  \

  \

 static inline void cvector_##tag##_push(CVector_##tag* self, Value value) { \

-    cvector_size_t newsize = cvector_size(*self) + 1; \

+    size_t newsize = cvector_size(*self) + 1; \

     if (newsize > cvector_capacity(*self)) \

         cvector_##tag##_reserve(self, 7 + newsize * 5 / 3); \

     self->data[cvector_size(*self)] = value; \

     _cvector_size(*self) = newsize; \

 } \

  \

-static inline void cvector_##tag##_insert(CVector_##tag* self, cvector_size_t pos, Value value) { \

+static inline void cvector_##tag##_insert(CVector_##tag* self, size_t pos, Value value) { \

     cvector_##tag##_push(self, value); \

-    cvector_size_t len = cvector_size(*self); \

+    size_t len = cvector_size(*self); \

     memmove(&self->data[pos + 1], &self->data[pos], (len - pos - 1) * sizeof(Value)); \

     self->data[pos] = value; \

 } \