From 0364b3d71cb710225a6f22d152a692e0ae865633 Mon Sep 17 00:00:00 2001 From: Tylo Date: Fri, 29 May 2020 09:12:18 +0200 Subject: Refactored. Added cmap_find and cmap_insert pair of functions. Renamed types. --- benchmark.c | 21 +++++++---- demos.c | 6 ++-- stc/clist.h | 47 ++++++++++++------------ stc/cmap.h | 112 +++++++++++++++++++++++++++++++++------------------------- stc/cvector.h | 28 +++++++-------- 5 files changed, 117 insertions(+), 97 deletions(-) diff --git a/benchmark.c b/benchmark.c index 81107a19..d304e711 100644 --- a/benchmark.c +++ b/benchmark.c @@ -1,9 +1,10 @@ -#include +//#include #include #include #include "stc/cstring.h" #include "stc/cmap.h" +#include "stc/crandom.h" #include "others/khash.h" #ifdef __cplusplus #include @@ -14,13 +15,17 @@ // Visual Studio: compile with -TP to force C++: cl -TP -EHsc -O2 benchmark.c declare_CMap(ii, int64_t, int64_t, c_noDestroy, c_lowbias32Hash); -declare_CMap(ix, short, short); // sizeof(CMapEntry_ix) = 6 bytes only! KHASH_MAP_INIT_INT64(ii, uint64_t) const size_t seed = 123; // time(NULL); const double maxLoadFactor = 0.77; -#define RAND(N) ((rand() << ((N) - 15)) ^ rand()) // N=16-30 +#define SEED(s) sfc64_t rng = sfc64_seed(s) +#define RAND(N) (sfc64_rand(&rng) & ((1 << N) - 1)) + +//#define SEED(s) mt19937_t rng = mt19937_seed(s) +//#define RAND(N) (mt19937_rand(&rng) & ((1 << N) - 1)) + #define CMAP_SETUP(tag, Key, Value) CMap_##tag map = cmap_init; \ cmap_##tag##_setMaxLoadFactor(&map, maxLoadFactor) @@ -81,21 +86,22 @@ int rr = RR; { \ M##_SETUP(tag, int64_t, int64_t); \ uint64_t checksum = 0, erased = 0; \ - srand(seed); \ + SEED(seed); \ clock_t difference, before = clock(); \ for (size_t i = 0; i < N1; ++i) { \ checksum += ++ M##_PUT(tag, RAND(rr), i); \ erased += M##_ERASE(tag, RAND(rr)); \ } \ difference = clock() - before; \ - printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, sum: %llu, erase: %llu\n", M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, checksum, erased); \ + printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, sum: %llu, erase: %llu\n", \ + M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, checksum, erased); \ M##_CLEAR(tag); \ } #define MAP_TEST2(M, tag) \ { \ M##_SETUP(tag, int64_t, int64_t); \ - srand(seed); \ + SEED(seed); \ size_t erased = 0; \ clock_t difference, before = clock(); \ for (size_t i = 0; i < N2; ++i) \ @@ -103,7 +109,8 @@ int rr = RR; for (size_t i = 0; i < N2; ++i) \ erased += M##_ERASE(tag, i*17); \ difference = clock() - before; \ - printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, erase %llu\n", M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \ + printf(#M "(" #tag "): sz: %llu, bucks: %llu, time: %.02f, erase %llu\n", \ + M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \ M##_CLEAR(tag); \ } diff --git a/demos.c b/demos.c index c4052eb8..5e7a8dec 100644 --- a/demos.c +++ b/demos.c @@ -100,7 +100,7 @@ void mapdemo1() cmap_ii_put(&nums, 8, 64); cmap_ii_put(&nums, 11, 121); - printf("%d\n", cmap_ii_get(nums, 8)->value); + printf("%d\n", cmap_ii_get(&nums, 8)->value); cmap_ii_destroy(&nums); } @@ -137,10 +137,10 @@ void mapdemo3() cmap_ss_put(&table, "Map", cstring_make("test")); cmap_ss_put(&table, "Make", cstring_make("my")); cmap_ss_put(&table, "Sunny", cstring_make("day")); - printf("remove: Make: %s\n", cmap_ss_get(table, "Make")->value.str); + printf("remove: Make: %s\n", cmap_ss_get(&table, "Make")->value.str); cmap_ss_erase(&table, "Make"); - printf("size %d\n", cmap_size(table)); + printf("size %llu\n", cmap_size(table)); c_foreach (i, cmap_ss, table) printf("key: %s\n", i.item->key.str); cmap_ss_destroy(&table); // frees key and value CStrings, and hash table (CVector). diff --git a/stc/clist.h b/stc/clist.h index 5fdb3b28..eba49d1a 100644 --- a/stc/clist.h +++ b/stc/clist.h @@ -85,18 +85,18 @@ declare_CList_6(tag, CString, cstring_destroy, const char*, cstring_compareRaw, cstring_getRaw) #define declare_CListTypes(tag, Value) \ - c_struct (CListNode_##tag) { \ - CListNode_##tag *next; \ + typedef struct CListNode_##tag { \ + struct CListNode_##tag *next; \ Value value; \ - }; \ + } CListNode_##tag; \ \ - c_struct (CList_##tag) { \ - CListNode_##tag* last; \ - }; \ + typedef struct CList_##tag { \ + CListNode_##tag *last; \ + } CList_##tag; \ \ - c_struct (clist_##tag##_iter_t) { \ + typedef struct { \ CListNode_##tag *item, **_last; \ - } + } CListIter_##tag, clist_##tag##_iter_t #define clist_init {NULL} #define clist_front(list) (list).last->next->value @@ -104,10 +104,9 @@ #define clist_empty(list) ((list).last == NULL) -#define declare_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ +#define declare_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ \ declare_CListTypes(tag, Value); \ - typedef ValueRaw clist_##tag##_raw_t; \ \ STC_API void \ clist_##tag##_destroy(CList_##tag* self); \ @@ -134,13 +133,13 @@ clist_##tag##_spliceAfter(CList_##tag* self, clist_##tag##_iter_t pos, CList_##tag* other); \ \ STC_API clist_##tag##_iter_t \ - clist_##tag##_findBefore(CList_##tag* self, ValueRaw val); \ + clist_##tag##_findBefore(CList_##tag* self, RawValue val); \ \ STC_API Value* \ - clist_##tag##_find(CList_##tag* self, ValueRaw val); \ + clist_##tag##_find(CList_##tag* self, RawValue val); \ \ STC_API clist_##tag##_iter_t \ - clist_##tag##_remove(CList_##tag* self, ValueRaw val); \ + clist_##tag##_remove(CList_##tag* self, RawValue val); \ \ STC_API void \ clist_##tag##_sort(CList_##tag* self); \ @@ -159,15 +158,15 @@ clist_##tag##_iter_t it = {self->last, &self->last}; return it; \ } \ \ - implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ - \ - typedef Value clist_##tag##_value_t + implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ + typedef RawValue CListRawValue_##tag; \ + typedef Value CListValue_##tag /* -------------------------- IMPLEMENTATION ------------------------- */ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ +#define implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ \ STC_API void \ clist_##tag##_destroy(CList_##tag* self) { \ @@ -224,10 +223,10 @@ } \ \ STC_API clist_##tag##_iter_t \ - clist_##tag##_findBefore(CList_##tag* self, ValueRaw val) { \ + clist_##tag##_findBefore(CList_##tag* self, RawValue val) { \ clist_##tag##_iter_t prev = {self->last, &self->last}; \ c_foreach (i, clist_##tag, *self) { \ - ValueRaw r = valueGetRaw(&i.item->value); \ + RawValue r = valueGetRaw(&i.item->value); \ if (valueCompareRaw(&r, &val) == 0) { \ return prev; \ } \ @@ -237,13 +236,13 @@ } \ \ STC_API Value* \ - clist_##tag##_find(CList_##tag* self, ValueRaw val) { \ + clist_##tag##_find(CList_##tag* self, RawValue val) { \ clist_##tag##_iter_t it = clist_##tag##_findBefore(self, val); \ return it.item ? &it.item->next->value : NULL; \ } \ \ STC_API clist_##tag##_iter_t \ - clist_##tag##_remove(CList_##tag* self, ValueRaw val) { \ + clist_##tag##_remove(CList_##tag* self, RawValue val) { \ clist_##tag##_iter_t it = clist_##tag##_findBefore(self, val); \ if (it.item) clist_##tag##_eraseAfter(self, it); \ return it; \ @@ -251,8 +250,8 @@ \ static inline int \ clist_##tag##_sortCmp(const void* x, const void* y) { \ - ValueRaw a = valueGetRaw(&((CListNode_##tag *) x)->value); \ - ValueRaw b = valueGetRaw(&((CListNode_##tag *) y)->value); \ + RawValue a = valueGetRaw(&((CListNode_##tag *) x)->value); \ + RawValue b = valueGetRaw(&((CListNode_##tag *) y)->value); \ return valueCompareRaw(&a, &b); \ } \ STC_API void \ @@ -337,7 +336,7 @@ _clist_mergesort(CListNode__base *list, int (*cmp)(const void*, const void*)) { } #else -#define implement_CList_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) +#define implement_CList_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) #endif #endif diff --git a/stc/cmap.h b/stc/cmap.h index 095b9210..e8a7485b 100644 --- a/stc/cmap.h +++ b/stc/cmap.h @@ -86,22 +86,21 @@ enum {cmapentry_HASH=0x7f, cmapentry_USED=0x80}; /* CMap full: */ #define declare_CMap_10(tag, Key, Value, valueDestroy, keyDestroy, RawKey, \ keyHashRaw, keyEqualsRaw, keyGetRaw, keyInitRaw) \ -\ - struct CMapEntry_##tag { \ - Key key; \ - Value value; \ - }; \ - \ - static inline struct CMapEntry_##tag cmapentry_##tag##_make(Key key, Value value) { \ - struct CMapEntry_##tag e = {key, value}; return e; \ - } \ - static inline void \ - cmapentry_##tag##_destroy(struct CMapEntry_##tag* e) { \ - keyDestroy(&e->key); \ - valueDestroy(&e->value); \ - } \ - typedef struct CMapEntry_##tag CMapEntry_##tag; \ - typedef RawKey cmap_##tag##_rawkey_t; \ +typedef struct CMapEntry_##tag { \ + Key key; \ + Value value; \ +} CMapEntry_##tag; \ + \ +static inline CMapEntry_##tag cmapentry_##tag##_make(Key key, Value value) { \ + CMapEntry_##tag e = {key, value}; return e; \ +} \ +static inline void \ +cmapentry_##tag##_destroy(CMapEntry_##tag* e) { \ + keyDestroy(&e->key); \ + valueDestroy(&e->value); \ +} \ + \ +typedef RawKey CMapRawKey_##tag; \ \ typedef struct CMap_##tag { \ CMapEntry_##tag* _table; \ @@ -111,10 +110,16 @@ typedef struct CMap_##tag { \ uint8_t shrinkLimitPercent; \ } CMap_##tag; \ \ -typedef struct cmap_##tag##_iter_t { \ +typedef struct { \ CMapEntry_##tag *item, *_end; \ uint8_t* _hx; \ -} cmap_##tag##_iter_t; \ +} CMapIter_##tag, cmap_##tag##_iter_t; \ + \ +typedef struct { \ + CMapRawKey_##tag rawKey; \ + size_t index; \ + uint32_t hashx; \ +} CMapBucket_##tag; \ \ STC_API void \ cmap_##tag##_destroy(CMap_##tag* self); \ @@ -129,19 +134,22 @@ STC_API void \ cmap_##tag##_setShrinkLimitFactor(CMap_##tag* self, double limit); \ \ STC_API CMapEntry_##tag* \ -cmap_##tag##_get(CMap_##tag map, cmap_##tag##_rawkey_t rawKey); \ +cmap_##tag##_get(const CMap_##tag* self, CMapRawKey_##tag rawKey); \ \ STC_API CMapEntry_##tag* \ -cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value); \ +cmap_##tag##_put(CMap_##tag* self, CMapRawKey_##tag rawKey, Value value); \ \ STC_API CMapEntry_##tag* \ -cmap_##tag##_insert(CMap_##tag* self, CMapEntry_##tag entry); \ +cmap_##tag##_find(CMap_##tag* self, CMapRawKey_##tag rawKey, CMapBucket_##tag* b); \ + \ +STC_API void \ +cmap_##tag##_insert(CMap_##tag* self, CMapBucket_##tag b, Value value); \ \ STC_API size_t \ cmap_##tag##_reserve(CMap_##tag* self, size_t size); \ \ STC_API bool \ -cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey); \ +cmap_##tag##_erase(CMap_##tag* self, CMapRawKey_##tag rawKey); \ \ STC_API cmap_##tag##_iter_t \ cmap_##tag##_begin(CMap_##tag* map); \ @@ -152,8 +160,8 @@ cmap_##tag##_next(cmap_##tag##_iter_t it); \ implement_CMap_10(tag, Key, Value, valueDestroy, keyDestroy, RawKey, \ keyHashRaw, keyEqualsRaw, keyGetRaw, keyInitRaw) \ \ -typedef Key cmap_##tag##_key_t; \ -typedef Value cmap_##tag##_value_t +typedef Key CMapKey_##tag; \ +typedef Value CMapValue_##tag /* -------------------------- IMPLEMENTATION ------------------------- */ @@ -193,15 +201,15 @@ cmap_##tag##_setShrinkLimitFactor(CMap_##tag* self, double limit) { \ } \ \ static inline size_t \ -cmap_##tag##_bucket(CMap_##tag* self, const cmap_##tag##_rawkey_t* rawKeyPtr, uint32_t* hxPtr) { \ - uint32_t hash = keyHashRaw(rawKeyPtr, sizeof(cmap_##tag##_rawkey_t)); \ +cmap_##tag##_bucket(const CMap_##tag* self, const CMapRawKey_##tag* rawKeyPtr, uint32_t* hxPtr) { \ + uint32_t hash = keyHashRaw(rawKeyPtr, sizeof(CMapRawKey_##tag)); \ uint32_t sx, hx = (hash & cmapentry_HASH) | cmapentry_USED; \ size_t cap = cmap_bucketCount(*self); \ size_t idx = cmap_reduce(hash, cap); \ uint8_t* hashx = self->_hashx; \ while ((sx = hashx[idx])) { \ if (sx == hx) { \ - cmap_##tag##_rawkey_t r = keyGetRaw(&self->_table[idx].key); \ + CMapRawKey_##tag r = keyGetRaw(&self->_table[idx].key); \ if (keyEqualsRaw(&r, rawKeyPtr)) break; \ } \ if (++idx == cap) idx = 0; \ @@ -211,17 +219,21 @@ cmap_##tag##_bucket(CMap_##tag* self, const cmap_##tag##_rawkey_t* rawKeyPtr, ui } \ \ STC_API CMapEntry_##tag* \ -cmap_##tag##_get(CMap_##tag map, cmap_##tag##_rawkey_t rawKey) { \ - if (cmap_size(map) == 0) return NULL; \ +cmap_##tag##_get(const CMap_##tag* self, CMapRawKey_##tag rawKey) { \ + if (cmap_bucketCount(*self) == 0) return NULL; \ uint32_t hx; \ - size_t idx = cmap_##tag##_bucket(&map, &rawKey, &hx); \ - return map._hashx[idx] ? &map._table[idx] : NULL; \ + size_t idx = cmap_##tag##_bucket(self, &rawKey, &hx); \ + return self->_hashx[idx] ? &self->_table[idx] : NULL; \ } \ \ -STC_API CMapEntry_##tag* \ -cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value) { \ +static inline void _cmap_##tag##_reserveExpand(CMap_##tag* self) { \ if (cmap_size(*self) + 1 >= cmap_bucketCount(*self) * self->maxLoadPercent * 0.01) \ cmap_##tag##_reserve(self, (size_t) 7 + (1.6 * cmap_bucketCount(*self))); \ +} \ + \ +STC_API CMapEntry_##tag* \ +cmap_##tag##_put(CMap_##tag* self, CMapRawKey_##tag rawKey, Value value) { \ + _cmap_##tag##_reserveExpand(self); \ uint32_t hx; \ size_t idx = cmap_##tag##_bucket(self, &rawKey, &hx); \ CMapEntry_##tag* e = &self->_table[idx]; \ @@ -237,22 +249,24 @@ cmap_##tag##_put(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey, Value value) { } \ \ STC_API CMapEntry_##tag* \ -cmap_##tag##_insert(CMap_##tag* self, CMapEntry_##tag entry) { \ - if (cmap_size(*self) + 1 >= cmap_bucketCount(*self) * self->maxLoadPercent * 0.01) \ - cmap_##tag##_reserve(self, (size_t) 7 + (1.6 * cmap_bucketCount(*self))); \ - uint32_t hx; \ - cmap_##tag##_rawkey_t r = keyGetRaw(&entry.key); \ - size_t idx = cmap_##tag##_bucket(self, &r, &hx); \ - CMapEntry_##tag* e = &self->_table[idx]; \ - if (self->_hashx[idx]) \ +cmap_##tag##_find(CMap_##tag* self, CMapRawKey_##tag rawKey, CMapBucket_##tag* b) { \ + _cmap_##tag##_reserveExpand(self); \ + b->rawKey = rawKey; \ + b->index = cmap_##tag##_bucket(self, &rawKey, &b->hashx); \ + return self->_hashx[b->index] ? &self->_table[b->index] : NULL; \ +} \ + \ +STC_API void \ +cmap_##tag##_insert(CMap_##tag* self, CMapBucket_##tag b, Value value) { \ + CMapEntry_##tag* e = &self->_table[b.index]; \ + if (self->_hashx[b.index]) \ valueDestroy(&e->value); \ else { \ - e->key = entry.key; \ - self->_hashx[idx] = (uint8_t) hx; \ + e->key = keyInitRaw(b.rawKey); \ + self->_hashx[b.index] = (uint8_t) b.hashx; \ ++self->_size; \ } \ - e->value = entry.value; \ - return e; \ + e->value = value; \ } \ \ static inline void \ @@ -277,7 +291,7 @@ cmap_##tag##_reserve(CMap_##tag* self, size_t size) { \ uint32_t hx; \ for (size_t i = 0; i < oldcap; ++i, ++e) \ if (tmp._hashx[i]) { \ - cmap_##tag##_rawkey_t r = keyGetRaw(&e->key); \ + CMapRawKey_##tag r = keyGetRaw(&e->key); \ size_t idx = cmap_##tag##_bucket(self, &r, &hx); \ slot[idx] = *e, \ hashx[idx] = (uint8_t) hx; \ @@ -288,7 +302,7 @@ cmap_##tag##_reserve(CMap_##tag* self, size_t size) { \ } \ \ STC_API bool \ -cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \ +cmap_##tag##_erase(CMap_##tag* self, CMapRawKey_##tag rawKey) { \ if (cmap_size(*self) == 0) \ return false; \ size_t cap = cmap_bucketCount(*self); \ @@ -298,7 +312,7 @@ cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \ size_t i = cmap_##tag##_bucket(self, &rawKey, &hx), j = i, k; \ CMapEntry_##tag* slot = self->_table; \ uint8_t* hashx = self->_hashx; \ - cmap_##tag##_rawkey_t r; \ + CMapRawKey_##tag r; \ if (! hashx[i]) \ return false; \ do { /* deletion from hash table without tombstone */ \ @@ -306,7 +320,7 @@ cmap_##tag##_erase(CMap_##tag* self, cmap_##tag##_rawkey_t rawKey) { \ if (! hashx[j]) \ break; \ r = keyGetRaw(&slot[j].key); \ - k = cmap_reduce(keyHashRaw(&r, sizeof(cmap_##tag##_rawkey_t)), cap); \ + k = cmap_reduce(keyHashRaw(&r, sizeof(CMapRawKey_##tag)), cap); \ if ((j < i) ^ (k <= i) ^ (k > j)) /* is k outside (i, j]? */ \ slot[i] = slot[j], hashx[i] = hashx[j], i = j; \ } while (true); \ diff --git a/stc/cvector.h b/stc/cvector.h index fe9e2d7d..27caca6a 100644 --- a/stc/cvector.h +++ b/stc/cvector.h @@ -43,8 +43,8 @@ declare_CVector_6(tag, CString, cstring_destroy, const char*, cstring_compareRaw, cstring_getRaw) -#define declare_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ -typedef ValueRaw cvector_##tag##_rawvalue_t; \ +#define declare_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ + \ typedef struct CVector_##tag { \ Value* data; \ } CVector_##tag; \ @@ -82,7 +82,7 @@ STC_API void \ cvector_##tag##_sort(CVector_##tag* self); \ \ STC_API size_t \ -cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue); \ +cvector_##tag##_find(CVector_##tag cv, RawValue rawValue); \ \ static inline void \ cvector_##tag##_swap(CVector_##tag* a, CVector_##tag* b) { \ @@ -90,9 +90,9 @@ cvector_##tag##_swap(CVector_##tag* a, CVector_##tag* b) { \ } \ \ \ -typedef struct cvector_##tag##_iter_t { \ +typedef struct { \ Value *item, *end; \ -} cvector_##tag##_iter_t; \ +} CVectorIter_##tag, cvector_##tag##_iter_t; \ \ STC_API cvector_##tag##_iter_t \ cvector_##tag##_begin(CVector_##tag* vec); \ @@ -103,14 +103,15 @@ cvector_##tag##_next(cvector_##tag##_iter_t it) { \ return it; \ } \ \ -implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ +implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ \ -typedef Value cvector_##tag##_value_t +typedef Value CVectorValue_##tag; \ +typedef RawValue CVectorRawValue_##tag /* -------------------------- IMPLEMENTATION ------------------------- */ #if !defined(STC_HEADER) || defined(STC_IMPLEMENTATION) -#define implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) \ +#define implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) \ \ STC_API void \ cvector_##tag##_destroy(CVector_##tag* self) { \ @@ -169,11 +170,10 @@ cvector_##tag##_erase(CVector_##tag* self, size_t pos, size_t size) { \ } \ \ STC_API size_t \ -cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue) { \ +cvector_##tag##_find(CVector_##tag cv, RawValue rawValue) { \ size_t n = cvector_size(cv); \ - cvector_##tag##_rawvalue_t r; \ for (size_t i = 0; i < n; ++i) { \ - ValueRaw r = valueGetRaw(&cv.data[i]); \ + RawValue r = valueGetRaw(&cv.data[i]); \ if (valueCompareRaw(&r, &rawValue) == 0) return i; \ } \ return (size_t) (-1); /*SIZE_MAX;*/ \ @@ -181,8 +181,8 @@ cvector_##tag##_find(CVector_##tag cv, ValueRaw rawValue) { \ \ STC_API int \ cvector_##tag##_sortCompare(const void* x, const void* y) { \ - ValueRaw rx = valueGetRaw((const Value *) x); \ - ValueRaw ry = valueGetRaw((const Value *) y); \ + RawValue rx = valueGetRaw((const Value *) x); \ + RawValue ry = valueGetRaw((const Value *) y); \ return valueCompareRaw(&rx, &ry); \ } \ STC_EXTERN_IMPORT void qsort(void *base, size_t nitems, size_t size, int (*compar)(const void *, const void*)); \ @@ -200,7 +200,7 @@ cvector_##tag##_begin(CVector_##tag* vec) { \ return it; \ } #else -#define implement_CVector_6(tag, Value, valueDestroy, ValueRaw, valueCompareRaw, valueGetRaw) +#define implement_CVector_6(tag, Value, valueDestroy, RawValue, valueCompareRaw, valueGetRaw) #endif #if defined(_WIN32) && defined(_DLL) -- cgit v1.2.3