Reformatting only.

1 files changed, 214 insertions, 214 deletions

diff --git a/stc/cvec.h b/stc/cvec.h
index 6b879533..90643952 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -45,245 +45,245 @@
 

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

 \

-typedef struct cvec_##X { \

-    Value* data; \

-} cvec_##X; \

-typedef Value cvec_##X##_value_t; \

-typedef RawValue cvec_##X##_rawvalue_t; \

-typedef cvec_##X##_rawvalue_t cvec_##X##_input_t; \

-typedef struct { Value *item; } cvec_##X##_iter_t; \

+    typedef struct cvec_##X { \

+        Value* data; \

+    } cvec_##X; \

+    typedef Value cvec_##X##_value_t; \

+    typedef RawValue cvec_##X##_rawvalue_t; \

+    typedef cvec_##X##_rawvalue_t cvec_##X##_input_t; \

+    typedef struct { Value *item; } cvec_##X##_iter_t; \

 \

-STC_INLINE cvec_##X \

-cvec_##X##_init(void) {cvec_##X v = cvec_ini; return v;} \

-STC_INLINE bool \

-cvec_##X##_empty(cvec_##X v) {return cvec_empty(v);} \

-STC_INLINE size_t \

-cvec_##X##_size(cvec_##X v) {return cvec_size(v);} \

-STC_INLINE size_t \

-cvec_##X##_capacity(cvec_##X v) {return cvec_capacity(v);} \

-STC_INLINE Value \

-cvec_##X##_value_from_raw(RawValue rawValue) {return valueFromRaw(rawValue);} \

-STC_INLINE void \

-cvec_##X##_clear(cvec_##X* self); \

-STC_API void \

-cvec_##X##_destroy(cvec_##X* self); \

-STC_API void \

-cvec_##X##_reserve(cvec_##X* self, size_t cap); \

-STC_API void \

-cvec_##X##_resize(cvec_##X* self, size_t size, Value fill_val); \

-STC_API void \

-cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t in[], size_t size); \

-STC_API void \

-cvec_##X##_push_back(cvec_##X* self, Value value); \

-STC_INLINE void \

-cvec_##X##_emplace_back(cvec_##X* self, RawValue rawValue) { \

-    cvec_##X##_push_back(self, valueFromRaw(rawValue)); \

-} \

-\

-STC_API cvec_##X##_iter_t \

-cvec_##X##_insert_range(cvec_##X* self, cvec_##X##_iter_t pos, cvec_##X##_iter_t first, cvec_##X##_iter_t last); \

+    STC_INLINE cvec_##X \

+    cvec_##X##_init(void) {cvec_##X v = cvec_ini; return v;} \

+    STC_INLINE bool \

+    cvec_##X##_empty(cvec_##X v) {return cvec_empty(v);} \

+    STC_INLINE size_t \

+    cvec_##X##_size(cvec_##X v) {return cvec_size(v);} \

+    STC_INLINE size_t \

+    cvec_##X##_capacity(cvec_##X v) {return cvec_capacity(v);} \

+    STC_INLINE Value \

+    cvec_##X##_value_from_raw(RawValue rawValue) {return valueFromRaw(rawValue);} \

+    STC_INLINE void \

+    cvec_##X##_clear(cvec_##X* self); \

+    STC_API void \

+    cvec_##X##_destroy(cvec_##X* self); \

+    STC_API void \

+    cvec_##X##_reserve(cvec_##X* self, size_t cap); \

+    STC_API void \

+    cvec_##X##_resize(cvec_##X* self, size_t size, Value fill_val); \

+    STC_API void \

+    cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t in[], size_t size); \

+    STC_API void \

+    cvec_##X##_push_back(cvec_##X* self, Value value); \

+    STC_INLINE void \

+    cvec_##X##_emplace_back(cvec_##X* self, RawValue rawValue) { \

+        cvec_##X##_push_back(self, valueFromRaw(rawValue)); \

+    } \

 \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_insert_irange(cvec_##X* self, size_t ipos, Value* pfirst, Value* plast) { \

-    cvec_##X##_iter_t pos = {self->data + ipos}, first = {pfirst}, last = {plast}; \

-    return cvec_##X##_insert_range(self, pos, first, last); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_insert(cvec_##X* self, cvec_##X##_iter_t pos, Value value) { \

-    cvec_##X##_iter_t first = {&value}, last = {&value + 1}; \

-    return cvec_##X##_insert_range(self, pos, first, last); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_insert_ipos(cvec_##X* self, size_t ipos, Value value) { \

-    cvec_##X##_iter_t pos = {self->data + ipos}, first = {&value}, last = {&value + 1}; \

-    return cvec_##X##_insert_range(self, pos, first, last); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_emplace(cvec_##X* self, cvec_##X##_iter_t pos, RawValue rawValue) { \

-    cvec_##X##_insert(self, pos, valueFromRaw(rawValue)); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_emplace_ipos(cvec_##X* self, size_t ipos, RawValue rawValue) { \

-    cvec_##X##_insert_ipos(self, ipos, valueFromRaw(rawValue)); \

-} \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_insert_range(cvec_##X* self, cvec_##X##_iter_t pos, cvec_##X##_iter_t first, cvec_##X##_iter_t last); \

+    \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_insert_irange(cvec_##X* self, size_t ipos, Value* pfirst, Value* plast) { \

+        cvec_##X##_iter_t pos = {self->data + ipos}, first = {pfirst}, last = {plast}; \

+        return cvec_##X##_insert_range(self, pos, first, last); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_insert(cvec_##X* self, cvec_##X##_iter_t pos, Value value) { \

+        cvec_##X##_iter_t first = {&value}, last = {&value + 1}; \

+        return cvec_##X##_insert_range(self, pos, first, last); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_insert_ipos(cvec_##X* self, size_t ipos, Value value) { \

+        cvec_##X##_iter_t pos = {self->data + ipos}, first = {&value}, last = {&value + 1}; \

+        return cvec_##X##_insert_range(self, pos, first, last); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_emplace(cvec_##X* self, cvec_##X##_iter_t pos, RawValue rawValue) { \

+        cvec_##X##_insert(self, pos, valueFromRaw(rawValue)); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_emplace_ipos(cvec_##X* self, size_t ipos, RawValue rawValue) { \

+        cvec_##X##_insert_ipos(self, ipos, valueFromRaw(rawValue)); \

+    } \

 \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_erase_range(cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last); \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_erase_range(cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last); \

 \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_erase(cvec_##X* self, cvec_##X##_iter_t pos) { \

-    cvec_##X##_iter_t next = {pos.item + 1}; \

-    return cvec_##X##_erase_range(self, pos, next); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_erase_ipos(cvec_##X* self, size_t ipos) { \

-    cvec_##X##_iter_t first = {self->data + ipos}, last = {first.item + 1}; \

-    return cvec_##X##_erase_range(self, first, last); \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_erase_irange(cvec_##X* self, size_t ifirst, size_t ilast) { \

-    cvec_##X##_iter_t first = {self->data + ifirst}, last = {self->data + ilast}; \

-    return cvec_##X##_erase_range(self, first, last); \

-} \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_erase(cvec_##X* self, cvec_##X##_iter_t pos) { \

+        cvec_##X##_iter_t next = {pos.item + 1}; \

+        return cvec_##X##_erase_range(self, pos, next); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_erase_ipos(cvec_##X* self, size_t ipos) { \

+        cvec_##X##_iter_t first = {self->data + ipos}, last = {first.item + 1}; \

+        return cvec_##X##_erase_range(self, first, last); \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_erase_irange(cvec_##X* self, size_t ifirst, size_t ilast) { \

+        cvec_##X##_iter_t first = {self->data + ifirst}, last = {self->data + ilast}; \

+        return cvec_##X##_erase_range(self, first, last); \

+    } \

 \

-STC_API void \

-cvec_##X##_sort(cvec_##X* self); \

-STC_API void \

-cvec_##X##_sort_with(cvec_##X* self, int(*cmp)(const Value*, const Value*)); \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_find(const cvec_##X* self, RawValue rawValue); \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_find_in_range(const cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last, RawValue rawValue); \

-STC_API int \

-cvec_##X##_value_compare(const Value* x, const Value* y); \

+    STC_API void \

+    cvec_##X##_sort(cvec_##X* self); \

+    STC_API void \

+    cvec_##X##_sort_with(cvec_##X* self, int(*cmp)(const Value*, const Value*)); \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_find(const cvec_##X* self, RawValue rawValue); \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_find_in_range(const cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last, RawValue rawValue); \

+    STC_API int \

+    cvec_##X##_value_compare(const Value* x, const Value* y); \

 \

-STC_INLINE cvec_##X \

-cvec_##X##_with_size(size_t size, Value null_val) { \

-    cvec_##X x = cvec_ini; \

-    cvec_##X##_resize(&x, size, null_val); \

-    return x; \

-} \

-STC_INLINE cvec_##X \

-cvec_##X##_with_capacity(size_t size) { \

-    cvec_##X x = cvec_ini; \

-    cvec_##X##_reserve(&x, size); \

-    return x; \

-} \

-STC_INLINE void \

-cvec_##X##_pop_back(cvec_##X* self) { \

-    valueDestroy(&self->data[--_cvec_size(self)]); \

-} \

-STC_INLINE Value* \

-cvec_##X##_front(cvec_##X* self) {return self->data;} \

-STC_INLINE Value* \

-cvec_##X##_back(cvec_##X* self) {return self->data + _cvec_size(self) - 1;} \

-STC_INLINE Value* \

-cvec_##X##_at(cvec_##X* self, size_t i) {return self->data + i;} \

-STC_INLINE void \

-cvec_##X##_swap(cvec_##X* a, cvec_##X* b) { \

-    c_swap(Value*, a->data, b->data); \

-} \

-STC_INLINE void \

-cvec_##X##_sort(cvec_##X* self) { \

-    qsort(self->data, cvec_size(*self), sizeof(Value), (_cvec_cmp) cvec_##X##_value_compare); \

-} \

-STC_INLINE void \

-cvec_##X##_sort_with(cvec_##X* self, int(*cmp)(const Value*, const Value*)) { \

-    qsort(self->data, cvec_size(*self), sizeof(Value), (_cvec_cmp) cmp); \

-} \

+    STC_INLINE cvec_##X \

+    cvec_##X##_with_size(size_t size, Value null_val) { \

+        cvec_##X x = cvec_ini; \

+        cvec_##X##_resize(&x, size, null_val); \

+        return x; \

+    } \

+    STC_INLINE cvec_##X \

+    cvec_##X##_with_capacity(size_t size) { \

+        cvec_##X x = cvec_ini; \

+        cvec_##X##_reserve(&x, size); \

+        return x; \

+    } \

+    STC_INLINE void \

+    cvec_##X##_pop_back(cvec_##X* self) { \

+        valueDestroy(&self->data[--_cvec_size(self)]); \

+    } \

+    STC_INLINE Value* \

+    cvec_##X##_front(cvec_##X* self) {return self->data;} \

+    STC_INLINE Value* \

+    cvec_##X##_back(cvec_##X* self) {return self->data + _cvec_size(self) - 1;} \

+    STC_INLINE Value* \

+    cvec_##X##_at(cvec_##X* self, size_t i) {return self->data + i;} \

+    STC_INLINE void \

+    cvec_##X##_swap(cvec_##X* a, cvec_##X* b) { \

+        c_swap(Value*, a->data, b->data); \

+    } \

+    STC_INLINE void \

+    cvec_##X##_sort(cvec_##X* self) { \

+        qsort(self->data, cvec_size(*self), sizeof(Value), (_cvec_cmp) cvec_##X##_value_compare); \

+    } \

+    STC_INLINE void \

+    cvec_##X##_sort_with(cvec_##X* self, int(*cmp)(const Value*, const Value*)) { \

+        qsort(self->data, cvec_size(*self), sizeof(Value), (_cvec_cmp) cmp); \

+    } \

 \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_begin(const cvec_##X* self) { \

-    cvec_##X##_iter_t it = {self->data}; return it; \

-} \

-STC_INLINE cvec_##X##_iter_t \

-cvec_##X##_end(const cvec_##X* self) { \

-    cvec_##X##_iter_t it = {self->data + cvec_size(*self)}; return it; \

-} \

-STC_INLINE void \

-cvec_##X##_next(cvec_##X##_iter_t* it) {++it->item;} \

-STC_INLINE cvec_##X##_value_t* \

-cvec_##X##_itval(cvec_##X##_iter_t it) {return it.item;} \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_begin(const cvec_##X* self) { \

+        cvec_##X##_iter_t it = {self->data}; return it; \

+    } \

+    STC_INLINE cvec_##X##_iter_t \

+    cvec_##X##_end(const cvec_##X* self) { \

+        cvec_##X##_iter_t it = {self->data + cvec_size(*self)}; return it; \

+    } \

+    STC_INLINE void \

+    cvec_##X##_next(cvec_##X##_iter_t* it) {++it->item;} \

+    STC_INLINE cvec_##X##_value_t* \

+    cvec_##X##_itval(cvec_##X##_iter_t it) {return it.item;} \

 \

-implement_cvec_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw)

+    implement_cvec_7(X, Value, valueDestroy, RawValue, valueCompareRaw, valueToRaw, valueFromRaw)

 

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

 

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

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

 \

-STC_API void \

-cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t in[], size_t size) { \

-    cvec_##X##_reserve(self, cvec_size(*self) + size); \

-    _cvec_size(self) += size; \

-    for (size_t i=0; i<size; ++i) self->data[i] = valueFromRaw(in[i]); \

-} \

+    STC_API void \

+    cvec_##X##_push_n(cvec_##X *self, const cvec_##X##_input_t in[], size_t size) { \

+        cvec_##X##_reserve(self, cvec_size(*self) + size); \

+        _cvec_size(self) += size; \

+        for (size_t i=0; i<size; ++i) self->data[i] = valueFromRaw(in[i]); \

+    } \

 \

-STC_API void \

-cvec_##X##_clear(cvec_##X* self) { \

-    Value* p = self->data; if (p) { \

-        for (Value* q = p + _cvec_size(self); p != q; ++p) valueDestroy(p); \

-        _cvec_size(self) = 0; \

+    STC_API void \

+    cvec_##X##_clear(cvec_##X* self) { \

+        Value* p = self->data; if (p) { \

+            for (Value* q = p + _cvec_size(self); p != q; ++p) valueDestroy(p); \

+            _cvec_size(self) = 0; \

+        } \

+    } \

+    STC_API void \

+    cvec_##X##_destroy(cvec_##X* self) { \

+        cvec_##X##_clear(self); \

+        if (self->data) free(_cvec_alloced(self->data)); \

     } \

-} \

-STC_API void \

-cvec_##X##_destroy(cvec_##X* self) { \

-    cvec_##X##_clear(self); \

-    if (self->data) free(_cvec_alloced(self->data)); \

-} \

 \

-STC_API void \

-cvec_##X##_reserve(cvec_##X* self, size_t cap) { \

-    size_t len = cvec_size(*self); \

-    if (cap >= len) { \

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

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

-        rep[0] = len; \

-        rep[1] = cap; \

+    STC_API void \

+    cvec_##X##_reserve(cvec_##X* self, size_t cap) { \

+        size_t len = cvec_size(*self); \

+        if (cap >= len) { \

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

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

+            rep[0] = len; \

+            rep[1] = cap; \

+        } \

+    } \

+    STC_API void \

+    cvec_##X##_resize(cvec_##X* self, size_t size, Value null_val) { \

+        cvec_##X##_reserve(self, size); \

+        for (size_t i=cvec_size(*self); i<size; ++i) self->data[i] = null_val; \

+        if (self->data) _cvec_size(self) = size; \

     } \

-} \

-STC_API void \

-cvec_##X##_resize(cvec_##X* self, size_t size, Value null_val) { \

-    cvec_##X##_reserve(self, size); \

-    for (size_t i=cvec_size(*self); i<size; ++i) self->data[i] = null_val; \

-    if (self->data) _cvec_size(self) = size; \

-} \

 \

-STC_API void \

-cvec_##X##_push_back(cvec_##X* self, Value value) { \

-    size_t len = cvec_size(*self); \

-    if (len == cvec_capacity(*self)) \

-        cvec_##X##_reserve(self, 4 + len * 3 / 2); \

-    self->data[_cvec_size(self)++] = value; \

-} \

+    STC_API void \

+    cvec_##X##_push_back(cvec_##X* self, Value value) { \

+        size_t len = cvec_size(*self); \

+        if (len == cvec_capacity(*self)) \

+            cvec_##X##_reserve(self, 4 + len * 3 / 2); \

+        self->data[_cvec_size(self)++] = value; \

+    } \

 \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_insert_range(cvec_##X* self, cvec_##X##_iter_t pos, cvec_##X##_iter_t first, cvec_##X##_iter_t last) { \

-    enum {max_buf = c_max_alloca / sizeof(Value) + 1}; Value buf[max_buf]; \

-    size_t len = last.item - first.item, ipos = pos.item - self->data, size = cvec_size(*self); \

-    Value* xbuf = (Value *) memcpy(len > max_buf ? c_new_n(Value, len) : buf, first.item, len); \

-    if (size + len > cvec_capacity(*self)) \

-        cvec_##X##_reserve(self, 4 + (size + len) * 3 / 2); \

-    pos.item = self->data + ipos; \

-    memmove(pos.item + len, pos.item, (size - ipos) * sizeof(Value)); \

-    memcpy(pos.item, xbuf, len * sizeof(Value)); \

-    _cvec_size(self) += len; \

-    if (len > max_buf) free(xbuf); \

-    return pos; \

-} \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_insert_range(cvec_##X* self, cvec_##X##_iter_t pos, cvec_##X##_iter_t first, cvec_##X##_iter_t last) { \

+        enum {max_buf = c_max_alloca / sizeof(Value) + 1}; Value buf[max_buf]; \

+        size_t len = last.item - first.item, ipos = pos.item - self->data, size = cvec_size(*self); \

+        Value* xbuf = (Value *) memcpy(len > max_buf ? c_new_n(Value, len) : buf, first.item, len); \

+        if (size + len > cvec_capacity(*self)) \

+            cvec_##X##_reserve(self, 4 + (size + len) * 3 / 2); \

+        pos.item = self->data + ipos; \

+        memmove(pos.item + len, pos.item, (size - ipos) * sizeof(Value)); \

+        memcpy(pos.item, xbuf, len * sizeof(Value)); \

+        _cvec_size(self) += len; \

+        if (len > max_buf) free(xbuf); \

+        return pos; \

+    } \

 \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_erase_range(cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last) { \

-    intptr_t len = last.item - first.item; \

-    if (len > 0) { \

-        Value* p = first.item, *end = p + _cvec_size(self); \

-        while (p != last.item) valueDestroy(p++); \

-        memmove(first.item, last.item, (end - last.item) * sizeof(Value)); \

-        _cvec_size(self) -= len; \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_erase_range(cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last) { \

+        intptr_t len = last.item - first.item; \

+        if (len > 0) { \

+            Value* p = first.item, *end = p + _cvec_size(self); \

+            while (p != last.item) valueDestroy(p++); \

+            memmove(first.item, last.item, (end - last.item) * sizeof(Value)); \

+            _cvec_size(self) -= len; \

+        } \

+        return first; \

     } \

-    return first; \

-} \

 \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_find_in_range(const cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last, RawValue rawValue) { \

-    for (; first.item != last.item; cvec_##X##_next(&first)) { \

-        RawValue r = valueToRaw(first.item); \

-        if (valueCompareRaw(&r, &rawValue) == 0) return first; \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_find_in_range(const cvec_##X* self, cvec_##X##_iter_t first, cvec_##X##_iter_t last, RawValue rawValue) { \

+        for (; first.item != last.item; cvec_##X##_next(&first)) { \

+            RawValue r = valueToRaw(first.item); \

+            if (valueCompareRaw(&r, &rawValue) == 0) return first; \

+        } \

+        return cvec_##X##_end(self); \

+    } \

+    STC_API cvec_##X##_iter_t \

+    cvec_##X##_find(const cvec_##X* self, RawValue rawValue) { \

+        return cvec_##X##_find_in_range(self, cvec_##X##_begin(self), cvec_##X##_end(self), rawValue); \

     } \

-    return cvec_##X##_end(self); \

-} \

-STC_API cvec_##X##_iter_t \

-cvec_##X##_find(const cvec_##X* self, RawValue rawValue) { \

-    return cvec_##X##_find_in_range(self, cvec_##X##_begin(self), cvec_##X##_end(self), rawValue); \

-} \

 \

-STC_API int \

-cvec_##X##_value_compare(const Value* x, const Value* y) { \

-    RawValue rx = valueToRaw(x); \

-    RawValue ry = valueToRaw(y); \

-    return valueCompareRaw(&rx, &ry); \

-} \

-typedef int cvec_##taq##_dud

+    STC_API int \

+    cvec_##X##_value_compare(const Value* x, const Value* y) { \

+        RawValue rx = valueToRaw(x); \

+        RawValue ry = valueToRaw(y); \

+        return valueCompareRaw(&rx, &ry); \

+    } \

+    typedef int cvec_##taq##_dud

 

 #else

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