Reformat code only.

3 files changed, 101 insertions, 163 deletions

diff --git a/stc/cdeq.h b/stc/cdeq.h
index 9f535eb1..5b402981 100644
--- a/stc/cdeq.h
+++ b/stc/cdeq.h
@@ -56,32 +56,42 @@ typedef int (*c_cmp_fn)(const void*, const void*);
 #define _c_using_cdeq(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedefs_cdeq(CX, Value, RawValue); \

 \

-    STC_API CX \

-    CX##_init(void); \

-    STC_INLINE bool \

-    CX##_empty(CX deq) {return !cdeq_rep_(&deq)->size;} \

-    STC_INLINE size_t \

-    CX##_size(CX deq) {return cdeq_rep_(&deq)->size;} \

-    STC_INLINE size_t \

-    CX##_capacity(CX deq) {return cdeq_rep_(&deq)->cap;} \

-    STC_INLINE Value \

-    CX##_value_fromraw(RawValue raw) {return valueFromRaw(raw);} \

-    STC_INLINE Value \

-    CX##_value_clone(Value val) {return valueFromRaw(valueToRaw(&val));} \

-    STC_API void \

-    CX##_clear(CX* self); \

-    STC_API void \

-    CX##_del(CX* self); \

-    STC_API void \

-    CX##_expand_(CX* self, size_t n, bool at_front); \

-    STC_API void \

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

-    STC_INLINE void \

-    CX##_reserve(CX* self, size_t n) { \

-        CX##_expand_(self, (n - cdeq_rep_(self)->size)*0.65, false); \

-    } \

-    STC_INLINE void \

-    CX##_swap(CX* a, CX* b) {c_swap(CX, *a, *b);} \

+    STC_API CX          CX##_init(void); \

+    STC_API CX          CX##_clone(CX deq); \

+    STC_INLINE bool     CX##_empty(CX deq) {return !cdeq_rep_(&deq)->size;} \

+    STC_INLINE size_t   CX##_size(CX deq) {return cdeq_rep_(&deq)->size;} \

+    STC_INLINE size_t   CX##_capacity(CX deq) {return cdeq_rep_(&deq)->cap;} \

+    STC_INLINE Value    CX##_value_fromraw(RawValue raw) \

+                            {return valueFromRaw(raw);} \

+    STC_INLINE Value    CX##_value_clone(Value val) \

+                            {return valueFromRaw(valueToRaw(&val));} \

+    STC_API void        CX##_clear(CX* self); \

+    STC_API void        CX##_del(CX* self); \

+    STC_API void        CX##_expand_(CX* self, size_t n, bool at_front); \

+    STC_API void        CX##_resize(CX* self, size_t size, Value fill_val); \

+    STC_INLINE void     CX##_reserve(CX* self, size_t n) \

+                            {CX##_expand_(self, (n - cdeq_rep_(self)->size)*0.65, false);} \

+    STC_INLINE void     CX##_swap(CX* a, CX* b) {c_swap(CX, *a, *b);} \

+\

+    STC_API void        CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t n); \

+    STC_API void        CX##_push_back(CX* self, Value value); \

+    STC_API void        CX##_push_front(CX* self, Value value); \

+    STC_INLINE void     CX##_emplace_back(CX* self, RawValue raw) \

+                            {CX##_push_back(self, valueFromRaw(raw));} \

+    STC_INLINE void     CX##_emplace_front(CX* self, RawValue raw) \

+                            {CX##_push_front(self, valueFromRaw(raw));} \

+    STC_INLINE void     CX##_pop_back(CX* self) \

+                            {valueDel(&self->data[--cdeq_rep_(self)->size]);} \

+    STC_INLINE void     CX##_pop_front(CX* self) \

+                            {valueDel(self->data++); --cdeq_rep_(self)->size;} \

+    STC_INLINE \

+    CX##_value_t*       CX##_front(const CX* self) {return self->data;} \

+    STC_INLINE \

+    CX##_value_t*       CX##_back(const CX* self) \

+                            {return self->data + cdeq_rep_(self)->size - 1;} \

+    STC_INLINE \

+    CX##_value_t*       CX##_at(const CX* self, size_t i) \

+                            {assert(i < cdeq_rep_(self)->size); return self->data + i;} \

 \

     STC_INLINE CX \

     CX##_with_size(size_t size, Value null_val) { \

@@ -95,8 +105,6 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         CX##_expand_(&x, size, false); \

         return x; \

     } \

-    STC_API CX \

-    CX##_clone(CX deq); \

 \

     STC_INLINE void \

     CX##_shrink_to_fit(CX *self) { \

@@ -104,31 +112,6 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         CX##_del(self); *self = x; \

     } \

 \

-    STC_API void \

-    CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t n); \

-    STC_API void \

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

-    STC_INLINE void \

-    CX##_emplace_back(CX* self, RawValue raw) { \

-        CX##_push_back(self, valueFromRaw(raw)); \

-    } \

-    STC_INLINE void \

-    CX##_pop_back(CX* self) { \

-        valueDel(&self->data[--cdeq_rep_(self)->size]); \

-    } \

-\

-    STC_API void \

-    CX##_push_front(CX* self, Value value); \

-    STC_INLINE void \

-    CX##_emplace_front(CX* self, RawValue raw) { \

-        CX##_push_front(self, valueFromRaw(raw)); \

-    } \

-    STC_INLINE void \

-    CX##_pop_front(CX* self) { \

-        valueDel(self->data++); \

-        --cdeq_rep_(self)->size; \

-    } \

-\

     STC_API CX##_iter_t \

     CX##_insert_range_p(CX* self, CX##_value_t* pos, const CX##_value_t* pfirst, const CX##_value_t* pfinish); \

 \

@@ -169,16 +152,6 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         return CX##_erase_range_p(self, self->data + idx, self->data + idx + n); \

     } \

 \

-    STC_INLINE CX##_value_t* \

-    CX##_front(const CX* self) {return self->data;} \

-    STC_INLINE CX##_value_t* \

-    CX##_back(const CX* self) {return self->data + cdeq_rep_(self)->size - 1;} \

-    STC_INLINE CX##_value_t* \

-    CX##_at(const CX* self, size_t i) { \

-        assert(i < cdeq_rep_(self)->size); \

-        return self->data + i; \

-    } \

-\

     STC_INLINE CX##_iter_t \

     CX##_begin(const CX* self) { \

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

diff --git a/stc/clist.h b/stc/clist.h
index 5a972304..5ec3024a 100644
--- a/stc/clist.h
+++ b/stc/clist.h
@@ -97,46 +97,48 @@ STC_API size_t _clist_size(const clist_VOID* self);
     _c_using_clist_types(CX, Value); \

     typedef RawValue CX##_rawvalue_t; \

 \

-    STC_INLINE CX \

-    CX##_init(void) {CX lst = {NULL}; return lst;} \

-    STC_INLINE bool \

-    CX##_empty(CX lst) {return lst.last == NULL;} \

-    STC_INLINE size_t \

-    CX##_count(CX lst) {return _clist_size((const clist_VOID*) &lst);} \

-    STC_INLINE Value \

-    CX##_value_fromraw(RawValue raw) {return valueFromRaw(raw);} \

-    STC_INLINE CX##_value_t \

-    CX##_value_clone(CX##_value_t val) {return valueFromRaw(valueToRaw(&val));} \

+    STC_INLINE CX       CX##_init(void) {CX lst = {NULL}; return lst;} \

+    STC_INLINE bool     CX##_empty(CX lst) {return lst.last == NULL;} \

+    STC_INLINE size_t   CX##_count(CX lst) \

+                            {return _clist_size((const clist_VOID*) &lst);} \

+    STC_API void        CX##_del(CX* self); \

+    STC_API CX          CX##_clone(CX list); \

+    STC_INLINE void     CX##_clear(CX* self) {CX##_del(self);} \

+    STC_INLINE Value    CX##_value_clone(Value val) \

+                            {return valueFromRaw(valueToRaw(&val));} \

+    STC_INLINE Value    CX##_value_fromraw(RawValue raw) \

+                            {return valueFromRaw(raw);} \

 \

-    STC_API void \

-    CX##_del(CX* self); \

-    STC_API CX \

-    CX##_clone(CX list); \

-    STC_INLINE void \

-    CX##_clear(CX* self) {CX##_del(self);} \

+    STC_API void        CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t size); \

+    STC_API void        CX##_push_back(CX* self, Value value); \

+    STC_API void        CX##_push_front(CX* self, Value value); \

+    STC_INLINE void     CX##_emplace_back(CX* self, RawValue raw) \

+                            {CX##_push_back(self, valueFromRaw(raw));} \

+    STC_INLINE void     CX##_emplace_front(CX* self, RawValue raw) \

+                            {CX##_push_front(self, valueFromRaw(raw));} \

 \

-    STC_API void \

-    CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t size); \

-    STC_API void \

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

-    STC_INLINE void \

-    CX##_emplace_back(CX* self, RawValue raw) { \

-        CX##_push_back(self, valueFromRaw(raw)); \

-    } \

-    STC_API void \

-    CX##_push_front(CX* self, Value value); \

-    STC_INLINE void \

-    CX##_emplace_front(CX* self, RawValue raw) { \

-        CX##_push_front(self, valueFromRaw(raw)); \

-    } \

+    STC_API CX##_node_t* CX##_erase_after_(CX* self, CX##_node_t* node); \

+    STC_INLINE void     CX##_pop_front(CX* self) {CX##_erase_after_(self, self->last);} \

 \

-    STC_API CX##_node_t* \

-    CX##_erase_after_(CX* self, CX##_node_t* node); \

+    STC_API void        CX##_splice(CX* self, CX##_iter_t pos, CX* other); \

+    STC_API CX          CX##_split(CX* self, CX##_iter_t pos1, CX##_iter_t pos2); \

 \

-    STC_INLINE void \

-    CX##_pop_front(CX* self) { \

-        CX##_erase_after_(self, self->last); \

+    STC_API CX##_iter_t CX##_insert(CX* self, CX##_iter_t pos, Value value); \

+    STC_API CX##_iter_t CX##_erase_at(CX* self, CX##_iter_t pos); \

+    STC_API CX##_iter_t CX##_erase_range(CX* self, CX##_iter_t pos, CX##_iter_t finish); \

+\

+    STC_API size_t      CX##_remove(CX* self, RawValue val); \

+    STC_API void        CX##_sort(CX* self); \

+    STC_API CX##_iter_t CX##_find_in_range(const CX* self, CX##_iter_t first, CX##_iter_t finish, RawValue val); \

+\

+    STC_INLINE Value*   CX##_front(const CX* self) {return &self->last->next->value;} \

+    STC_INLINE Value*   CX##_back(const CX* self) {return &self->last->value;} \

+\

+    STC_INLINE CX##_iter_t \

+    CX##_emplace(CX* self, CX##_iter_t pos, RawValue raw) { \

+        return CX##_insert(self, pos, valueFromRaw(raw)); \

     } \

+\

     STC_INLINE CX##_iter_t \

     CX##_begin(const CX* self) { \

         CX##_value_t* head = self->last ? &self->last->next->value : NULL; \

@@ -156,22 +158,6 @@ STC_API size_t _clist_size(const clist_VOID* self);
         while (n-- && it.ref) CX##_next(&it); \

         return it; \

     } \

-    \

-    STC_API CX##_iter_t \

-    CX##_insert(CX* self, CX##_iter_t pos, Value value); \

-    STC_INLINE CX##_iter_t \

-    CX##_emplace(CX* self, CX##_iter_t pos, RawValue raw) { \

-        return CX##_insert(self, pos, valueFromRaw(raw)); \

-    } \

-    STC_API CX##_iter_t \

-    CX##_erase_at(CX* self, CX##_iter_t pos); \

-    STC_API CX##_iter_t \

-    CX##_erase_range(CX* self, CX##_iter_t pos, CX##_iter_t finish); \

-\

-    STC_API void \

-    CX##_splice(CX* self, CX##_iter_t pos, CX* other); \

-    STC_API CX \

-    CX##_split(CX* self, CX##_iter_t pos1, CX##_iter_t pos2); \

 \

     STC_INLINE void \

     CX##_splice_range(CX* self, CX##_iter_t pos, \

@@ -180,21 +166,10 @@ STC_API size_t _clist_size(const clist_VOID* self);
         CX##_splice(self, pos, &tmp); \

     } \

 \

-    STC_API size_t \

-    CX##_remove(CX* self, RawValue val); \

-    STC_API void \

-    CX##_sort(CX* self); \

-    STC_API CX##_iter_t \

-    CX##_find_in_range(const CX* self, CX##_iter_t first, CX##_iter_t finish, RawValue val); \

-\

     STC_INLINE CX##_iter_t \

     CX##_find(const CX* self, RawValue val) { \

         return CX##_find_in_range(self, CX##_begin(self), CX##_end(self), val); \

     } \

-    STC_INLINE Value* \

-    CX##_front(const CX* self) {return &self->last->next->value;} \

-    STC_INLINE Value* \

-    CX##_back(const CX* self) {return &self->last->value;} \

 \

     _c_implement_clist(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedef CX CX##_t

diff --git a/stc/cvec.h b/stc/cvec.h
index 5177ad9c..a23dcb54 100644
--- a/stc/cvec.h
+++ b/stc/cvec.h
@@ -56,28 +56,25 @@ typedef int (*c_cmp_fn)(const void*, const void*);
 #define _c_using_cvec(CX, Value, valueCompareRaw, valueDel, valueFromRaw, valueToRaw, RawValue) \

     typedefs_cvec(CX, Value, RawValue); \

 \

-    STC_API CX \

-    CX##_init(void); \

-    STC_INLINE size_t \

-    CX##_size(CX vec) { return _cvec_rep(&vec)->size; } \

-    STC_INLINE size_t \

-    CX##_capacity(CX vec) { return _cvec_rep(&vec)->cap; } \

-    STC_INLINE bool \

-    CX##_empty(CX vec) {return !_cvec_rep(&vec)->size;} \

-    STC_INLINE Value \

-    CX##_value_fromraw(RawValue raw) {return valueFromRaw(raw);} \

-    STC_INLINE CX##_value_t \

-    CX##_value_clone(CX##_value_t val) {return valueFromRaw(valueToRaw(&val));} \

-    STC_INLINE void \

-    CX##_clear(CX* self); \

-    STC_API void \

-    CX##_del(CX* self); \

-    STC_API void \

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

-    STC_API void \

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

-    STC_INLINE void \

-    CX##_swap(CX* a, CX* b) {c_swap(CX, *a, *b);} \

+    STC_API CX          CX##_init(void); \

+    STC_API CX          CX##_clone(CX vec); \

+    STC_INLINE size_t   CX##_size(CX vec) { return _cvec_rep(&vec)->size; } \

+    STC_INLINE size_t   CX##_capacity(CX vec) { return _cvec_rep(&vec)->cap; } \

+    STC_INLINE bool     CX##_empty(CX vec) {return !_cvec_rep(&vec)->size;} \

+    STC_INLINE Value    CX##_value_fromraw(RawValue raw) {return valueFromRaw(raw);} \

+    STC_API int         CX##_value_compare(const CX##_value_t* x, const CX##_value_t* y); \

+    STC_INLINE void     CX##_clear(CX* self); \

+    STC_API void        CX##_del(CX* self); \

+    STC_API void        CX##_reserve(CX* self, size_t cap); \

+    STC_API void        CX##_resize(CX* self, size_t size, Value fill_val); \

+    STC_INLINE void     CX##_swap(CX* a, CX* b) {c_swap(CX, *a, *b);} \

+\

+    STC_API void        CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t size); \

+    STC_API void        CX##_push_back(CX* self, Value value); \

+    STC_INLINE void     CX##_emplace_back(CX* self, RawValue raw) \

+                            {CX##_push_back(self, valueFromRaw(raw));} \

+    STC_INLINE void     CX##_pop_back(CX* self) \

+                            {valueDel(&self->data[--_cvec_rep(self)->size]);} \

 \

     STC_INLINE CX \

     CX##_with_size(size_t size, Value null_val) { \

@@ -85,31 +82,23 @@ typedef int (*c_cmp_fn)(const void*, const void*);
         CX##_resize(&x, size, null_val); \

         return x; \

     } \

+\

     STC_INLINE CX \

     CX##_with_capacity(size_t size) { \

         CX x = CX##_init(); \

         CX##_reserve(&x, size); \

         return x; \

     } \

-    STC_API CX \

-    CX##_clone(CX vec); \

 \

     STC_INLINE void \

     CX##_shrink_to_fit(CX *self) { \

         CX x = CX##_clone(*self); \

         CX##_del(self); *self = x; \

     } \

-    STC_API void \

-    CX##_emplace_n(CX *self, const CX##_rawvalue_t arr[], size_t size); \

-    STC_API void \

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

-    STC_INLINE void \

-    CX##_emplace_back(CX* self, RawValue raw) { \

-        CX##_push_back(self, valueFromRaw(raw)); \

-    } \

-    STC_INLINE void \

-    CX##_pop_back(CX* self) { \

-        valueDel(&self->data[--_cvec_rep(self)->size]); \

+\

+    STC_INLINE CX##_value_t \

+    CX##_value_clone(CX##_value_t val) { \

+        return valueFromRaw(valueToRaw(&val)); \

     } \

 \

     STC_API CX##_iter_t \

@@ -156,6 +145,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     CX##_front(const CX* self) {return self->data;} \

     STC_INLINE CX##_value_t* \

     CX##_back(const CX* self) {return self->data + _cvec_rep(self)->size - 1;} \

+\

     STC_INLINE CX##_value_t* \

      CX##_at(const CX* self, size_t i) { \

         assert(i < _cvec_rep(self)->size); \

@@ -181,8 +171,7 @@ typedef int (*c_cmp_fn)(const void*, const void*);
     CX##_find(const CX* self, RawValue raw) { \

         return CX##_find_in_range(CX##_begin(self), CX##_end(self), raw); \

     } \

-    STC_API int \

-    CX##_value_compare(const CX##_value_t* x, const CX##_value_t* y); \

+\

     STC_API CX##_iter_t \

     CX##_bsearch_in_range(CX##_iter_t i1, CX##_iter_t i2, RawValue raw); \

     STC_INLINE CX##_iter_t \

@@ -211,7 +200,8 @@ static struct cvec_rep _cvec_inits = {0, 0};
 \

     STC_DEF CX \

     CX##_init(void) { \

-        CX vec = {(CX##_value_t *) _cvec_inits.data}; return vec; \

+        CX vec = {(CX##_value_t *) _cvec_inits.data}; \

+        return vec; \

     } \

 \

     STC_DEF void \