Internally renamed ccommon.h macros to uppercase. Lowercase macros are still supported via include/stc/priv/lowcase.h.

16 files changed, 179 insertions, 179 deletions

diff --git a/misc/archived/carr2.h b/misc/archived/carr2.h
index aebaec81..bff8a3b0 100644
--- a/misc/archived/carr2.h
+++ b/misc/archived/carr2.h
@@ -35,7 +35,7 @@
 
 int main() {
     int w = 7, h = 5;
-    c_with (carr2_int image = carr2_int_new_uninit(w, h), carr2_int_drop(&image))
+    c_WITH (carr2_int image = carr2_int_new_uninit(w, h), carr2_int_drop(&image))
     {
         int *dat = carr2_int_data(&image);
         for (int i = 0; i < carr2_int_size(&image); ++i)
@@ -46,7 +46,7 @@ int main() {
                 printf(" %d", image.data[x][y]);
         puts("\n");
 
-        c_foreach (i, carr2_int, image)
+        c_FOREACH (i, carr2_int, image)
             printf(" %d", *i.ref);
         puts("");
     }
@@ -71,7 +71,7 @@ STC_API void       _cx_memb(_copy)(_cx_self *self, const _cx_self* other);
 #endif
 
 STC_INLINE _cx_self _cx_memb(_new_uninit)(size_t xdim, size_t ydim) {
-    return _cx_memb(_with_data)(xdim, ydim, c_alloc_n(_cx_value, xdim*ydim));
+    return _cx_memb(_with_data)(xdim, ydim, c_ALLOC_N(_cx_value, xdim*ydim));
 }
 STC_INLINE size_t _cx_memb(_size)(const _cx_self* self)
     { return self->xdim*self->ydim; }
@@ -104,7 +104,7 @@ STC_INLINE void _cx_memb(_next)(_cx_iter* it)
 #if defined(i_implement)
 
 STC_DEF _cx_self _cx_memb(_with_data)(size_t xdim, size_t ydim, _cx_value* block) {
-    _cx_self _arr = {c_alloc_n(_cx_value*, xdim), xdim, ydim};
+    _cx_self _arr = {c_ALLOC_N(_cx_value*, xdim), xdim, ydim};
     for (size_t x = 0; x < xdim; ++x, block += ydim)
         _arr.data[x] = block;
     return _arr;
@@ -134,7 +134,7 @@ STC_DEF void _cx_memb(_copy)(_cx_self *self, const _cx_self* other) {
 
 STC_DEF _cx_value *_cx_memb(_release)(_cx_self* self) {
     _cx_value *values = self->data[0];
-    c_free(self->data);
+    c_FREE(self->data);
     self->data = NULL;
     return values;
 }
@@ -144,8 +144,8 @@ STC_DEF void _cx_memb(_drop)(_cx_self* self) {
     for (_cx_value* p = self->data[0], *q = p + _cx_memb(_size)(self); p != q; ) {
         --q; i_keydrop(q);
     }
-    c_free(self->data[0]); /* values */
-    c_free(self->data);    /* pointers */
+    c_FREE(self->data[0]); /* values */
+    c_FREE(self->data);    /* pointers */
 }
 
 #endif
diff --git a/misc/archived/carr3.h b/misc/archived/carr3.h
index a0148992..e7e4c01f 100644
--- a/misc/archived/carr3.h
+++ b/misc/archived/carr3.h
@@ -35,7 +35,7 @@
 
 int main() {
     int w = 7, h = 5, d = 3;
-    c_with (carr3_int image = carr3_int_new_uninit(w, h, d), carr3_int_drop(&image))
+    c_WITH (carr3_int image = carr3_int_new_uninit(w, h, d), carr3_int_drop(&image))
     {
         int *dat = carr3_int_data(&image);
         for (int i = 0; i < carr3_int_size(&image); ++i)
@@ -47,7 +47,7 @@ int main() {
                     printf(" %d", image.data[x][y][z]);
         puts("\n");
 
-        c_foreach (i, carr3_int, image)
+        c_FOREACH (i, carr3_int, image)
             printf(" %d", *i.ref);
         puts("");
     }
@@ -73,7 +73,7 @@ STC_API void       _cx_memb(_copy)(_cx_self *self, const _cx_self* other);
 #endif
 
 STC_INLINE _cx_self _cx_memb(_new_uninit)(size_t xdim, size_t ydim, size_t zdim) {
-    return _cx_memb(_with_data)(xdim, ydim, zdim, c_alloc_n(_cx_value, xdim*ydim*zdim));
+    return _cx_memb(_with_data)(xdim, ydim, zdim, c_ALLOC_N(_cx_value, xdim*ydim*zdim));
 }
 
 STC_INLINE size_t _cx_memb(_size)(const _cx_self* self)
@@ -107,7 +107,7 @@ STC_INLINE void _cx_memb(_next)(_cx_iter* it)
 #if defined(i_implement)
 
 STC_DEF _cx_self _cx_memb(_with_data)(size_t xdim, size_t ydim, size_t zdim, _cx_value* block) {
-    _cx_self _arr = {c_alloc_n(_cx_value**, xdim*(ydim + 1)), xdim, ydim, zdim};
+    _cx_self _arr = {c_ALLOC_N(_cx_value**, xdim*(ydim + 1)), xdim, ydim, zdim};
     _cx_value** p = (_cx_value**) &_arr.data[xdim];
     for (size_t x = 0, y; x < xdim; ++x, p += ydim)
         for (y = 0, _arr.data[x] = p; y < ydim; ++y, block += zdim)
@@ -139,7 +139,7 @@ STC_DEF void _cx_memb(_copy)(_cx_self *self, const _cx_self* other) {
 
 STC_DEF _cx_value* _cx_memb(_release)(_cx_self* self) {
     _cx_value *values = self->data[0][0];
-    c_free(self->data);
+    c_FREE(self->data);
     self->data = NULL;
     return values;
 }
@@ -149,8 +149,8 @@ STC_DEF void _cx_memb(_drop)(_cx_self* self) {
     for (_cx_value* p = **self->data, *q = p + _cx_memb(_size)(self);  p != q; ) {
         --q; i_keydrop(q);
     }
-    c_free(self->data[0][0]); /* data */
-    c_free(self->data);       /* pointers */
+    c_FREE(self->data[0][0]); /* data */
+    c_FREE(self->data);       /* pointers */
 }
 
 #endif
diff --git a/misc/archived/csmap.h b/misc/archived/csmap.h
index 4b4e764c..f035ff11 100644
--- a/misc/archived/csmap.h
+++ b/misc/archived/csmap.h
@@ -32,7 +32,7 @@
 #include <stc/csmap.h>
 
 int main(void) {
-    c_with (csmap_sx m = csmap_sx_init(), csmap_sx_drop(&m))
+    c_WITH (csmap_sx m = csmap_sx_init(), csmap_sx_drop(&m))
     {
         csmap_sx_emplace(&m, "Testing one", 1.234);
         csmap_sx_emplace(&m, "Testing two", 12.34);
@@ -43,7 +43,7 @@ int main(void) {
         csmap_sx_emplace_or_assign(&m, "Testing three", 1000.0); // update
         csmap_sx_erase(&m, "Testing two");
 
-        c_foreach (i, csmap_sx, m)
+        c_FOREACH (i, csmap_sx, m)
             printf("map %s: %g\n", cstr_str(&i.ref->first), i.ref->second);
     }
 }
@@ -113,7 +113,7 @@ STC_API void            _cx_memb(_next)(_cx_iter* it);
 
 STC_INLINE bool         _cx_memb(_empty)(_cx_self cx) { return cx.size == 0; }
 STC_INLINE size_t       _cx_memb(_size)(_cx_self cx) { return cx.size; }
-STC_INLINE void         _cx_memb(_swap)(_cx_self* a, _cx_self* b) { c_swap(_cx_self, *a, *b); }
+STC_INLINE void         _cx_memb(_swap)(_cx_self* a, _cx_self* b) { c_SWAP(_cx_self, *a, *b); }
 STC_INLINE _cx_iter     _cx_memb(_find)(const _cx_self* self, i_keyraw rkey)
                             { _cx_iter it; _cx_memb(_find_it)(self, rkey, &it); return it; }
 STC_INLINE bool         _cx_memb(_contains)(const _cx_self* self, i_keyraw rkey)
@@ -354,7 +354,7 @@ _cx_memb(_insert_entry_i_)(_cx_node* tn, const _cx_rawkey* rkey, _cx_result* res
         dir = (c < 0);
         tx = tx->link[dir];
     }
-    tn = c_alloc(_cx_node);
+    tn = c_ALLOC(_cx_node);
     tn->link[0] = tn->link[1] = (_cx_node*)&_csmap_sentinel;
     tn->level = 1;
     res->ref = &tn->value, res->inserted = true;
@@ -401,7 +401,7 @@ _cx_memb(_erase_r_)(_cx_node *tn, const _cx_rawkey* rkey, int *erased) {
         } else { /* unlink node */
             tx = tn;
             tn = tn->link[tn->link[0]->level == 0];
-            c_free(tx);
+            c_FREE(tx);
         }
     }
     if (tn->link[0]->level < tn->level - 1 || tn->link[1]->level < tn->level - 1) {
@@ -461,7 +461,7 @@ static _cx_node*
 _cx_memb(_clone_r_)(_cx_node *tn) {
     if (! tn->level)
         return tn;
-    _cx_node *cn = c_alloc(_cx_node);
+    _cx_node *cn = c_ALLOC(_cx_node);
     cn->level = tn->level;
     cn->value = _cx_memb(_value_clone)(tn->value);
     cn->link[0] = _cx_memb(_clone_r_)(tn->link[0]);
@@ -493,7 +493,7 @@ _cx_memb(_drop_r_)(_cx_node* tn) {
         _cx_memb(_drop_r_)(tn->link[0]);
         _cx_memb(_drop_r_)(tn->link[1]);
         _cx_memb(_value_drop)(&tn->value);
-        c_free(tn);
+        c_FREE(tn);
     }
 }
 
diff --git a/misc/archived/cstr.h b/misc/archived/cstr.h
index 8de6c4b0..45b11d78 100644
--- a/misc/archived/cstr.h
+++ b/misc/archived/cstr.h
@@ -77,7 +77,7 @@ STC_INLINE size_t       cstr_size(const cstr* self) { return _cstr_p(self)->size
 STC_INLINE size_t       cstr_capacity(cstr s) { return _cstr_p(&s)->cap; }
 STC_INLINE bool         cstr_empty(cstr s) { return _cstr_p(&s)->size == 0; }
 STC_INLINE void         cstr_drop(cstr* self)
-                            { if (_cstr_p(self)->cap) c_free(_cstr_p(self)); }
+                            { if (_cstr_p(self)->cap) c_FREE(_cstr_p(self)); }
 STC_INLINE cstr         cstr_clone(cstr s)
                             { return cstr_from_n(s.str, _cstr_p(&s)->size); }
 STC_INLINE void         cstr_clear(cstr* self)
@@ -142,7 +142,7 @@ STC_INLINE char* cstr_append_uninit(cstr *self, size_t n) {
 
 STC_INLINE cstr* cstr_take(cstr* self, cstr s) {
     if (self->str != s.str && _cstr_p(self)->cap)
-        c_free(_cstr_p(self));
+        c_FREE(_cstr_p(self));
     self->str = s.str;
     return self;
 }
@@ -202,7 +202,7 @@ cstr_reserve(cstr* self, const size_t cap) {
     cstr_priv *p = _cstr_p(self);
     const size_t oldcap = p->cap;
     if (cap > oldcap) {
-        p = (cstr_priv*) c_realloc(((oldcap != 0) & (p != &_cstr_nullrep)) ? p : NULL, _cstr_opt_mem(cap));
+        p = (cstr_priv*) c_REALLOC(((oldcap != 0) & (p != &_cstr_nullrep)) ? p : NULL, _cstr_opt_mem(cap));
         if (!p) return NULL;
         self->str = p->chr;
         if (oldcap == 0) self->str[p->size = 0] = '\0';
@@ -222,7 +222,7 @@ cstr_resize(cstr* self, const size_t len, const char fill) {
 STC_DEF cstr
 cstr_from_n(const char* str, const size_t n) {
     if (n == 0) return cstr_NULL;
-    cstr_priv* prv = (cstr_priv*) c_malloc(_cstr_opt_mem(n));
+    cstr_priv* prv = (cstr_priv*) c_MALLOC(_cstr_opt_mem(n));
     cstr s = {(char *) memcpy(prv->chr, str, n)};
     s.str[prv->size = n] = '\0';
     prv->cap = _cstr_opt_cap(n);
@@ -313,11 +313,11 @@ STC_DEF void
 cstr_replace_at_sv(cstr* self, const size_t pos, size_t len, csview repl) {
     const size_t sz = cstr_size(self);
     if (len > sz - pos) len = sz - pos;
-    char buf[256], *xstr = repl.size > 256 ? c_malloc(repl.size) : buf;
+    char buf[256], *xstr = repl.size > 256 ? c_MALLOC(repl.size) : buf;
     memcpy(xstr, repl.str, repl.size);
     _cstr_internal_move(self, pos + len, pos + repl.size);
     memcpy(&self->str[pos], xstr, repl.size);
-    if (repl.size > 256) c_free(xstr);
+    if (repl.size > 256) c_FREE(xstr);
 }
 
 STC_DEF cstr
diff --git a/misc/benchmarks/misc/cbits_benchmark.cpp b/misc/benchmarks/misc/cbits_benchmark.cpp
index dd709db1..114ab963 100644
--- a/misc/benchmarks/misc/cbits_benchmark.cpp
+++ b/misc/benchmarks/misc/cbits_benchmark.cpp
@@ -42,7 +42,7 @@ int main(int argc, char **argv)
     csrandom(seed);
     current_time = get_time_in_ms();
 
-    c_forrange (40 * N)
+    c_FORRANGE (40 * N)
     {
         uint64_t r = crandom();
         bools[r & (N-1)] = r & 1<<29;
@@ -51,7 +51,7 @@ int main(int argc, char **argv)
     difference1 = get_time_in_ms() - current_time;
     current_time = get_time_in_ms();
 
-    c_forrange (100) c_forrange (num, N) 
+    c_FORRANGE (100) c_FORRANGE (num, N) 
     {
         total += bools[num];
     }
@@ -70,7 +70,7 @@ int main(int argc, char **argv)
     current_time = get_time_in_ms();
     bitset<N> bits;
 
-    c_forrange (40 * N)
+    c_FORRANGE (40 * N)
     {
         uint64_t r = crandom();
         bits[r & (N-1)] = r & 1<<29;
@@ -79,7 +79,7 @@ int main(int argc, char **argv)
     difference1 = get_time_in_ms() - current_time;
     current_time = get_time_in_ms();
 
-    c_forrange (100) c_forrange (num, N)
+    c_FORRANGE (100) c_FORRANGE (num, N)
     {
         total += bits[num];
     }   
@@ -96,7 +96,7 @@ int main(int argc, char **argv)
     current_time = get_time_in_ms();
     cbits bits2 = cbits_with_size(N, false);
 
-    c_forrange (40 * N)
+    c_FORRANGE (40 * N)
     {
         uint64_t r = crandom();
         cbits_set_value(&bits2, r & (N-1), r & 1<<29);
@@ -105,7 +105,7 @@ int main(int argc, char **argv)
     difference1 = get_time_in_ms() - current_time;
     current_time = get_time_in_ms();
 
-    c_forrange (100) c_forrange (num, N)
+    c_FORRANGE (100) c_FORRANGE (num, N)
     {
         total += cbits_at(&bits2, num);
     }
diff --git a/misc/benchmarks/misc/string_bench_STC.cpp b/misc/benchmarks/misc/string_bench_STC.cpp
index 39a46d50..e252b449 100644
--- a/misc/benchmarks/misc/string_bench_STC.cpp
+++ b/misc/benchmarks/misc/string_bench_STC.cpp
@@ -98,7 +98,7 @@ void initShortStringVec(cvec_str* vs, cvec_sv* vsv)
     cvec_str_emplace_back(vs, "David");
 */
     size_t num = 0;
-    c_foreach (i, cvec_str, *vs)
+    c_FOREACH (i, cvec_str, *vs)
     {
         cvec_sv_push_back(vsv, cstr_sv(i.ref));
         num += cstr_size(i.ref);
@@ -113,7 +113,7 @@ void initLongStringVec(cvec_str* vs, cvec_sv* vsv)
     cvec_sv_clear(vsv);
     
     *vs = read_file("names.txt");
-    c_foreach (i, cvec_str, *vs) {
+    c_FOREACH (i, cvec_str, *vs) {
         cstr_append_s(i.ref, *i.ref);
         cstr_append_s(i.ref, *i.ref);
         cstr_append_s(i.ref, *i.ref);
@@ -144,7 +144,7 @@ void initLongStringVec(cvec_str* vs, cvec_sv* vsv)
     cvec_str_emplace_back(vs, "David David David David David David");
 */
     size_t num = 0;
-    c_foreach (i, cvec_str, *vs)
+    c_FOREACH (i, cvec_str, *vs)
     {
         cvec_sv_push_back(vsv, cstr_sv(i.ref));
         num += cstr_size(i.ref);
@@ -162,7 +162,7 @@ void initMaps(const cvec_str* vs, csmap_str* mapTrans, csmap_ssv* mapSview,
     cmap_ssv_clear(unordmapSview);
 
     size_t n = 0;
-    c_foreach (i, cvec_str, *vs)
+    c_FOREACH (i, cvec_str, *vs)
     {
         csmap_str_insert(mapTrans, cstr_clone(*i.ref), n);
         csmap_ssv_insert(mapSview, cstr_clone(*i.ref), n);
@@ -243,7 +243,7 @@ void benchmark(
     stopwatch.start("Trans Map with char*");
     for (size_t i = 0; i < MAX_LOOP; ++i)
     {
-        c_foreach (j, cvec_str, *vec_string)
+        c_FOREACH (j, cvec_str, *vec_string)
         {
             const csmap_str_value* v = csmap_str_get(mapTrans, cstr_str(j.ref));
             if (v)
@@ -257,7 +257,7 @@ void benchmark(
     stopwatch.start("Trans Map with string_view");
     for (size_t i = 0; i < MAX_LOOP; ++i)
     {
-        c_foreach (j, cvec_sv, *vec_stringview)
+        c_FOREACH (j, cvec_sv, *vec_stringview)
         {
             const csmap_ssv_value* v = csmap_ssv_get(mapSview, *j.ref);
             if (v)
@@ -271,7 +271,7 @@ void benchmark(
     stopwatch.start("Trans Unord Map with char*");
     for (size_t i = 0; i < MAX_LOOP; ++i)
     {
-        c_foreach (j, cvec_str, *vec_string)
+        c_FOREACH (j, cvec_str, *vec_string)
         {
             const cmap_str_value* v = cmap_str_get(unordmapTrans, cstr_str(j.ref));
             if (v)
@@ -285,7 +285,7 @@ void benchmark(
     stopwatch.start("Trans Unord Map with string_view");
     for (size_t i = 0; i < MAX_LOOP; ++i)
     {
-        c_foreach (j, cvec_sv, *vec_stringview)
+        c_FOREACH (j, cvec_sv, *vec_stringview)
         {
             const cmap_ssv_value* v = cmap_ssv_get(unordmapSview, *j.ref);
             if (v)
diff --git a/misc/benchmarks/picobench/picobench_cmap.cpp b/misc/benchmarks/picobench/picobench_cmap.cpp
index 3ffba5b9..9cc96d46 100644
--- a/misc/benchmarks/picobench/picobench_cmap.cpp
+++ b/misc/benchmarks/picobench/picobench_cmap.cpp
@@ -57,14 +57,14 @@ static void ins_and_erase_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         map[crandom()];
     map.clear();
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         map[crandom()];
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         map.erase(crandom());
     s.set_result(map.size());
 }
@@ -75,14 +75,14 @@ static void ins_and_erase_cmap_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_i_insert(&map, crandom(), 0);
     cmap_i_clear(&map);
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_i_insert(&map, crandom(), 0);
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_i_erase(&map, crandom());
     s.set_result(cmap_i_size(&map));
     cmap_i_drop(&map);
@@ -94,14 +94,14 @@ static void ins_and_erase_cmap_x(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_x_insert(&map, crandom(), 0);
     cmap_x_clear(&map);
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_x_insert(&map, crandom(), 0);
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         cmap_x_erase(&map, crandom());
     s.set_result(cmap_x_size(&map));
     cmap_x_drop(&map);
@@ -127,7 +127,7 @@ static void ins_and_access_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (N1)
+    c_FORRANGE (N1)
         result += ++map[crandom() & mask];
     s.set_result(result);
 }
@@ -140,7 +140,7 @@ static void ins_and_access_cmap_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (N1)
+    c_FORRANGE (N1)
         result += ++cmap_i_insert(&map, crandom() & mask, 0).ref->second;
     s.set_result(result);
     cmap_i_drop(&map);
@@ -174,7 +174,7 @@ static void ins_and_access_s(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(&str[0], str.size());
         map.emplace(str, str);
         randomize(&str[0], str.size());
@@ -192,7 +192,7 @@ static void ins_and_access_cmap_s(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(buf, s.arg());
         //if (s.arg() > 30) { printf("%s\n", buf); exit(0); }
         cmap_str_emplace(&map, buf, buf);
@@ -227,7 +227,7 @@ static void iterate_x(picobench::state& s)
     size_t result = 0;
 
     // measure insert then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         map[crandom()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
@@ -237,7 +237,7 @@ static void iterate_x(picobench::state& s)
     csrandom(seed);
 
     // measure erase then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         map.erase(crandom());
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
@@ -255,9 +255,9 @@ static void iterate_cmap_x(picobench::state& s)
     size_t result = 0;
 
     // measure insert then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         cmap_x_insert_or_assign(&map, crandom(), n);
-        if (!(n & K)) c_foreach (i, cmap_x, map)
+        if (!(n & K)) c_FOREACH (i, cmap_x, map)
             result += i.ref->second;
     }
 
@@ -265,9 +265,9 @@ static void iterate_cmap_x(picobench::state& s)
     csrandom(seed);
 
     // measure erase then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         cmap_x_erase(&map, crandom());
-        if (!(n & K)) c_foreach (i, cmap_x, map)
+        if (!(n & K)) c_FOREACH (i, cmap_x, map)
             result += i.ref->second;
     }
     s.set_result(result);
diff --git a/misc/benchmarks/picobench/picobench_csmap.cpp b/misc/benchmarks/picobench/picobench_csmap.cpp
index 5caab6cc..9ad8f9cd 100644
--- a/misc/benchmarks/picobench/picobench_csmap.cpp
+++ b/misc/benchmarks/picobench/picobench_csmap.cpp
@@ -38,7 +38,7 @@ static void ctor_and_ins_one_i(picobench::state& s)
 {
     size_t result = 0;
     picobench::scope scope(s);
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         MapInt map;
         map[n];
         result += map.size();
@@ -50,7 +50,7 @@ static void ctor_and_ins_one_csmap_i(picobench::state& s)
 {
     size_t result = 0;
     picobench::scope scope(s);
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         csmap_i map = csmap_i_init();
         csmap_i_insert(&map, n, 0);
         result += csmap_i_size(&map);
@@ -73,7 +73,7 @@ static void insert_i(picobench::state& s)
     MapInt map;
     csrandom(seed);
     picobench::scope scope(s);
-    c_forrange (n, s.iterations())
+    c_FORRANGE (n, s.iterations())
         map.emplace(crandom() & 0xfffffff, n);
     s.set_result(map.size());
 }
@@ -83,7 +83,7 @@ static void insert_csmap_i(picobench::state& s)
     csmap_i map = csmap_i_init();
     csrandom(seed);
     picobench::scope scope(s);
-    c_forrange (n, s.iterations())
+    c_FORRANGE (n, s.iterations())
         csmap_i_insert(&map, crandom() & 0xfffffff, n);
     s.set_result(csmap_i_size(&map));
     csmap_i_drop(&map);
@@ -106,17 +106,17 @@ static void ins_and_erase_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (i, s.iterations())
+    c_FORRANGE (i, s.iterations())
         map.emplace(crandom() & mask, i);
     result = map.size();
 
     map.clear();
     csrandom(seed);
-    c_forrange (i, s.iterations())
+    c_FORRANGE (i, s.iterations())
         map[crandom() & mask] = i;
 
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         map.erase(crandom() & mask);
     s.set_result(result);
 }
@@ -129,17 +129,17 @@ static void ins_and_erase_csmap_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (i, s.iterations())
+    c_FORRANGE (i, s.iterations())
         csmap_i_insert(&map, crandom() & mask, i);
     result = csmap_i_size(&map);
 
     csmap_i_clear(&map);
     csrandom(seed);
-    c_forrange (i, s.iterations())
+    c_FORRANGE (i, s.iterations())
         csmap_i_insert_or_assign(&map, crandom() & mask, i);
 
     csrandom(seed);
-    c_forrange (s.iterations())
+    c_FORRANGE (s.iterations())
         csmap_i_erase(&map, crandom() & mask);
     s.set_result(result);
     csmap_i_drop(&map);
@@ -161,7 +161,7 @@ static void ins_and_access_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         result += ++map[crandom() & mask];
         auto it = map.find(crandom() & mask);
         if (it != map.end()) map.erase(it->first);
@@ -177,7 +177,7 @@ static void ins_and_access_csmap_i(picobench::state& s)
     csrandom(seed);
 
     picobench::scope scope(s);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         result += ++csmap_i_insert(&map, crandom() & mask, 0).ref->second;
         const csmap_i_value* val = csmap_i_get(&map, crandom() & mask);
         if (val) csmap_i_erase(&map, val->first);
@@ -208,12 +208,12 @@ static void ins_and_access_s(picobench::state& s)
 
     picobench::scope scope(s);
     csrandom(seed);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(&str[0], str.size());
         map.emplace(str, str);
     }
     csrandom(seed);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(&str[0], str.size());
         result += map.erase(str);
     }
@@ -229,12 +229,12 @@ static void ins_and_access_csmap_s(picobench::state& s)
 
     picobench::scope scope(s);
     csrandom(seed);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(buf, s.arg());
         csmap_str_emplace(&map, buf, buf);
     }
     csrandom(seed);
-    c_forrange (s.iterations()) {
+    c_FORRANGE (s.iterations()) {
         randomize(buf, s.arg());
         result += csmap_str_erase(&map, buf);
         /*csmap_str_iter it = csmap_str_find(&map, buf);
@@ -266,7 +266,7 @@ static void iterate_x(picobench::state& s)
     size_t result = 0;
 
     // measure insert then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         map[crandom()] = n;
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
@@ -276,7 +276,7 @@ static void iterate_x(picobench::state& s)
     csrandom(seed);
 
     // measure erase then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         map.erase(crandom());
         if (!(n & K)) for (auto const& keyVal : map)
             result += keyVal.second;
@@ -294,9 +294,9 @@ static void iterate_csmap_x(picobench::state& s)
     size_t result = 0;
 
     // measure insert then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         csmap_x_insert_or_assign(&map, crandom(), n);
-        if (!(n & K)) c_foreach (i, csmap_x, map)
+        if (!(n & K)) c_FOREACH (i, csmap_x, map)
             result += i.ref->second;
     }
 
@@ -304,9 +304,9 @@ static void iterate_csmap_x(picobench::state& s)
     csrandom(seed);
 
     // measure erase then iterate whole map
-    c_forrange (n, s.iterations()) {
+    c_FORRANGE (n, s.iterations()) {
         csmap_x_erase(&map, crandom());
-        if (!(n & K)) c_foreach (i, csmap_x, map)
+        if (!(n & K)) c_FOREACH (i, csmap_x, map)
             result += i.ref->second;
     }
     s.set_result(result);
diff --git a/misc/benchmarks/plotbench/cdeq_benchmark.cpp b/misc/benchmarks/plotbench/cdeq_benchmark.cpp
index 1259cc07..ed463ee4 100644
--- a/misc/benchmarks/plotbench/cdeq_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cdeq_benchmark.cpp
@@ -29,29 +29,29 @@ Sample test_std_deque() {
         s.test[INSERT].t1 = clock();
         container con;
         csrandom(seed);
-        c_forrange (N/3) con.push_front(crandom() & mask1);
-        c_forrange (N/3) {con.push_back(crandom() & mask1); con.pop_front();}
-        c_forrange (N/3) con.push_back(crandom() & mask1);
+        c_FORRANGE (N/3) con.push_front(crandom() & mask1);
+        c_FORRANGE (N/3) {con.push_back(crandom() & mask1); con.pop_front();}
+        c_FORRANGE (N/3) con.push_back(crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         s.test[ERASE].t1 = clock();
-        c_forrange (con.size()/2) { con.pop_front(); con.pop_back(); }
+        c_FORRANGE (con.size()/2) { con.pop_front(); con.pop_back(); }
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
         csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask2);
+        c_FORRANGE (N) con.push_back(crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         // Iteration - not inherent find - skipping
         //container::iterator it;
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_FORRANGE (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_forrange (i, N) sum += con[i];
+        c_FORRANGE (R) c_FORRANGE (i, N) sum += con[i];
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -73,29 +73,29 @@ Sample test_stc_deque() {
         container con = cdeq_x_init();
         //cdeq_x_reserve(&con, N);
         csrandom(seed);
-        c_forrange (N/3) cdeq_x_push_front(&con, crandom() & mask1);
-        c_forrange (N/3) {cdeq_x_push_back(&con, crandom() & mask1); cdeq_x_pop_front(&con);}
-        c_forrange (N/3) cdeq_x_push_back(&con, crandom() & mask1);
+        c_FORRANGE (N/3) cdeq_x_push_front(&con, crandom() & mask1);
+        c_FORRANGE (N/3) {cdeq_x_push_back(&con, crandom() & mask1); cdeq_x_pop_front(&con);}
+        c_FORRANGE (N/3) cdeq_x_push_back(&con, crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cdeq_x_size(&con);
         s.test[ERASE].t1 = clock();
-        c_forrange (cdeq_x_size(&con)/2) { cdeq_x_pop_front(&con); cdeq_x_pop_back(&con); }
+        c_FORRANGE (cdeq_x_size(&con)/2) { cdeq_x_pop_front(&con); cdeq_x_pop_back(&con); }
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = cdeq_x_size(&con);
         cdeq_x_drop(&con);
      }{
         csrandom(seed);
         container con = cdeq_x_init();
-        c_forrange (N) cdeq_x_push_back(&con, crandom() & mask2);
+        c_FORRANGE (N) cdeq_x_push_back(&con, crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //cdeq_x_iter it, end = cdeq_x_end(&con);
-        //c_forrange (S) if ((it = cdeq_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_FORRANGE (S) if ((it = cdeq_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_forrange (i, N) sum += con.data[i];
+        c_FORRANGE (R) c_FORRANGE (i, N) sum += con.data[i];
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -109,10 +109,10 @@ Sample test_stc_deque() {
 int main(int argc, char* argv[])
 {
     Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];
-    c_forrange (i, SAMPLES) {
+    c_FORRANGE (i, SAMPLES) {
         std_s[i] = test_std_deque();
         stc_s[i] = test_stc_deque();
-        if (i > 0) c_forrange (j, N_TESTS) {
+        if (i > 0) c_FORRANGE (j, N_TESTS) {
             if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];
             if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];
             if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %lld, sample %lld\n", i, j);
@@ -122,17 +122,17 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) { 
+    c_FORRANGE (j, N_TESTS) { 
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
     if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
 }
diff --git a/misc/benchmarks/plotbench/clist_benchmark.cpp b/misc/benchmarks/plotbench/clist_benchmark.cpp
index 04c8e8cd..aac61ebf 100644
--- a/misc/benchmarks/plotbench/clist_benchmark.cpp
+++ b/misc/benchmarks/plotbench/clist_benchmark.cpp
@@ -29,28 +29,28 @@ Sample test_std_forward_list() {
         s.test[INSERT].t1 = clock();
         container con;
         csrandom(seed);
-        c_forrange (N/2) con.push_front(crandom() & mask1);
-        c_forrange (N/2) con.push_front(crandom() & mask1);
+        c_FORRANGE (N/2) con.push_front(crandom() & mask1);
+        c_FORRANGE (N/2) con.push_front(crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = 0;
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.pop_front();
+        c_FORRANGE (N) con.pop_front();
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = 0;
      }{
         container con;
         csrandom(seed);
-        c_forrange (N) con.push_front(crandom() & mask2);
+        c_FORRANGE (N) con.push_front(crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
         // Iteration - not inherent find - skipping
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_FORRANGE (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) for (auto i: con) sum += i;
+        c_FORRANGE (R) for (auto i: con) sum += i;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -71,28 +71,28 @@ Sample test_stc_forward_list() {
         s.test[INSERT].t1 = clock();
         container con = clist_x_init();
         csrandom(seed);
-        c_forrange (N/2) clist_x_push_front(&con, crandom() & mask1);
-        c_forrange (N/2) clist_x_push_back(&con, crandom() & mask1);
+        c_FORRANGE (N/2) clist_x_push_front(&con, crandom() & mask1);
+        c_FORRANGE (N/2) clist_x_push_back(&con, crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = 0;
         s.test[ERASE].t1 = clock();
-        c_forrange (N) clist_x_pop_front(&con);
+        c_FORRANGE (N) clist_x_pop_front(&con);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = 0;
         clist_x_drop(&con);
      }{
         csrandom(seed);
         container con = clist_x_init();
-        c_forrange (N) clist_x_push_front(&con, crandom() & mask2);
+        c_FORRANGE (N) clist_x_push_front(&con, crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //clist_x_iter it, end = clist_x_end(&con);
-        //c_forrange (S) if ((it = clist_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_FORRANGE (S) if ((it = clist_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_foreach (i, clist_x, con) sum += *i.ref;
+        c_FORRANGE (R) c_FOREACH (i, clist_x, con) sum += *i.ref;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -106,10 +106,10 @@ Sample test_stc_forward_list() {
 int main(int argc, char* argv[])
 {
     Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];
-    c_forrange (i, SAMPLES) {
+    c_FORRANGE (i, SAMPLES) {
         std_s[i] = test_std_forward_list();
         stc_s[i] = test_stc_forward_list();
-        if (i > 0) c_forrange (j, N_TESTS) {
+        if (i > 0) c_FORRANGE (j, N_TESTS) {
             if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];
             if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];
             if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %lld, sample %lld\n", i, j);
@@ -119,17 +119,17 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) {
+    c_FORRANGE (j, N_TESTS) {
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
     if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
 }
\ No newline at end of file
diff --git a/misc/benchmarks/plotbench/cmap_benchmark.cpp b/misc/benchmarks/plotbench/cmap_benchmark.cpp
index 7a8f29d2..095b5513 100644
--- a/misc/benchmarks/plotbench/cmap_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cmap_benchmark.cpp
@@ -29,30 +29,30 @@ Sample test_std_unordered_map() {
         csrandom(seed);
         s.test[INSERT].t1 = clock();
         container con;
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
-        c_forrange (i, N/2) con.emplace(i, i);
+        c_FORRANGE (i, N/2) con.emplace(crandom() & mask1, i);
+        c_FORRANGE (i, N/2) con.emplace(i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         csrandom(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.erase(crandom() & mask1);
+        c_FORRANGE (N) con.erase(crandom() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
         csrandom(seed);
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
-        c_forrange (i, N/2) con.emplace(i, i);
+        c_FORRANGE (i, N/2) con.emplace(crandom() & mask1, i);
+        c_FORRANGE (i, N/2) con.emplace(i, i);
         csrandom(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
-        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
+        c_FORRANGE (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) for (auto i: con) sum += i.second;
+        c_FORRANGE (R) for (auto i: con) sum += i.second;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -73,33 +73,33 @@ Sample test_stc_unordered_map() {
         csrandom(seed);
         s.test[INSERT].t1 = clock();
         container con = cmap_x_init();
-        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
-        c_forrange (i, N/2) cmap_x_insert(&con, i, i);
+        c_FORRANGE (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
+        c_FORRANGE (i, N/2) cmap_x_insert(&con, i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cmap_x_size(&con);
         csrandom(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) cmap_x_erase(&con, crandom() & mask1);
+        c_FORRANGE (N) cmap_x_erase(&con, crandom() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = cmap_x_size(&con);
         cmap_x_drop(&con);
      }{
         container con = cmap_x_init();
         csrandom(seed);
-        c_forrange (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
-        c_forrange (i, N/2) cmap_x_insert(&con, i, i);
+        c_FORRANGE (i, N/2) cmap_x_insert(&con, crandom() & mask1, i);
+        c_FORRANGE (i, N/2) cmap_x_insert(&con, i, i);
         csrandom(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         const cmap_x_value* val;
-        c_forrange (N) 
+        c_FORRANGE (N) 
             if ((val = cmap_x_get(&con, crandom() & mask1)))
                 sum += val->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_foreach (i, cmap_x, con) sum += i.ref->second;
+        c_FORRANGE (R) c_FOREACH (i, cmap_x, con) sum += i.ref->second;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -113,10 +113,10 @@ Sample test_stc_unordered_map() {
 int main(int argc, char* argv[])
 {
     Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];
-    c_forrange (i, SAMPLES) {
+    c_FORRANGE (i, SAMPLES) {
         std_s[i] = test_std_unordered_map();
         stc_s[i] = test_stc_unordered_map();
-        if (i > 0) c_forrange (j, N_TESTS) {
+        if (i > 0) c_FORRANGE (j, N_TESTS) {
             if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];
             if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];
             if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %lld, sample %lld\n", i, j);
@@ -126,17 +126,17 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) {
+    c_FORRANGE (j, N_TESTS) {
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
     if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
 }
\ No newline at end of file
diff --git a/misc/benchmarks/plotbench/cpque_benchmark.cpp b/misc/benchmarks/plotbench/cpque_benchmark.cpp
index d6c2eda4..f2a85aee 100644
--- a/misc/benchmarks/plotbench/cpque_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cpque_benchmark.cpp
@@ -20,14 +20,14 @@ void std_test()
     std::priority_queue<float, std::vector<float>, std::greater<float>> pq;
     rng = stc64_new(seed);
     clock_t start = clock();
-    c_forrange (i, N)
+    c_FORRANGE (i, N)
         pq.push((float) stc64_randf(&rng)*100000);
 
     printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
     printf("%g ", pq.top());
 
     start = clock();
-    c_forrange (i, N) {
+    c_FORRANGE (i, N) {
         pq.pop();
     }
 
@@ -44,18 +44,18 @@ void stc_test()
     {
         rng = stc64_new(seed);
         clock_t start = clock();
-        c_forrange (i, N)
+        c_FORRANGE (i, N)
             cpque_f_push(&pq, (float) stc64_randf(&rng)*100000);
 
         printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
         printf("%g ", *cpque_f_top(&pq));
  
-        c_forrange (i, M) {
+        c_FORRANGE (i, M) {
             cpque_f_pop(&pq);
         }
 
         start = clock();
-        c_forrange (i, M, N)
+        c_FORRANGE (i, M, N)
             cpque_f_pop(&pq);
         printf("\npopped PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);
     }
diff --git a/misc/benchmarks/plotbench/csmap_benchmark.cpp b/misc/benchmarks/plotbench/csmap_benchmark.cpp
index 46bd695c..7dec8368 100644
--- a/misc/benchmarks/plotbench/csmap_benchmark.cpp
+++ b/misc/benchmarks/plotbench/csmap_benchmark.cpp
@@ -29,30 +29,30 @@ Sample test_std_map() {
         csrandom(seed);
         s.test[INSERT].t1 = clock();
         container con;
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
-        c_forrange (i, N/2) con.emplace(i, i);
+        c_FORRANGE (i, N/2) con.emplace(crandom() & mask1, i);
+        c_FORRANGE (i, N/2) con.emplace(i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         csrandom(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.erase(crandom() & mask1);
+        c_FORRANGE (N) con.erase(crandom() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
         csrandom(seed);
-        c_forrange (i, N/2) con.emplace(crandom() & mask1, i);
-        c_forrange (i, N/2) con.emplace(i, i);
+        c_FORRANGE (i, N/2) con.emplace(crandom() & mask1, i);
+        c_FORRANGE (i, N/2) con.emplace(i, i);
         csrandom(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         container::iterator it;
-        c_forrange (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
+        c_FORRANGE (N) if ((it = con.find(crandom() & mask1)) != con.end()) sum += it->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) for (auto i: con) sum += i.second;
+        c_FORRANGE (R) for (auto i: con) sum += i.second;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -74,33 +74,33 @@ Sample test_stc_map() {
         csrandom(seed);
         s.test[INSERT].t1 = clock();
         container con = csmap_x_init();
-        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
-        c_forrange (i, N/2) csmap_x_insert(&con, i, i);
+        c_FORRANGE (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
+        c_FORRANGE (i, N/2) csmap_x_insert(&con, i, i);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = csmap_x_size(&con);
         csrandom(seed);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) csmap_x_erase(&con, crandom() & mask1);
+        c_FORRANGE (N) csmap_x_erase(&con, crandom() & mask1);
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = csmap_x_size(&con);
         csmap_x_drop(&con);
      }{
         container con = csmap_x_init();
         csrandom(seed);
-        c_forrange (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
-        c_forrange (i, N/2) csmap_x_insert(&con, i, i);
+        c_FORRANGE (i, N/2) csmap_x_insert(&con, crandom() & mask1, i);
+        c_FORRANGE (i, N/2) csmap_x_insert(&con, i, i);
         csrandom(seed);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         const csmap_x_value* val;
-        c_forrange (N) 
+        c_FORRANGE (N) 
             if ((val = csmap_x_get(&con, crandom() & mask1)))
                 sum += val->second;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_foreach (i, csmap_x, con) sum += i.ref->second;
+        c_FORRANGE (R) c_FOREACH (i, csmap_x, con) sum += i.ref->second;
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -114,10 +114,10 @@ Sample test_stc_map() {
 int main(int argc, char* argv[])
 {
     Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];
-    c_forrange (i, SAMPLES) {
+    c_FORRANGE (i, SAMPLES) {
         std_s[i] = test_std_map();
         stc_s[i] = test_stc_map();
-        if (i > 0) c_forrange (j, N_TESTS) {
+        if (i > 0) c_FORRANGE (j, N_TESTS) {
             if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];
             if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];
             if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %lld, sample %lld\n", i, j);
@@ -127,17 +127,17 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) {
+    c_FORRANGE (j, N_TESTS) {
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
     if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
 }
diff --git a/misc/benchmarks/plotbench/cvec_benchmark.cpp b/misc/benchmarks/plotbench/cvec_benchmark.cpp
index fe7e09fb..466c7ff2 100644
--- a/misc/benchmarks/plotbench/cvec_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cvec_benchmark.cpp
@@ -29,27 +29,27 @@ Sample test_std_vector() {
         s.test[INSERT].t1 = clock();
         container con;
         csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask1);
+        c_FORRANGE (N) con.push_back(crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = con.size();
         s.test[ERASE].t1 = clock();
-        c_forrange (N) con.pop_back();
+        c_FORRANGE (N) con.pop_back();
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = con.size();
      }{
         container con;
         csrandom(seed);
-        c_forrange (N) con.push_back(crandom() & mask2);
+        c_FORRANGE (N) con.push_back(crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //container::iterator it;
         // Iteration - not inherent find - skipping
-        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
+        //c_FORRANGE (S) if ((it = std::find(con.begin(), con.end(), crandom() & mask2)) != con.end()) sum += *it;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_forrange (i, N) sum += con[i];
+        c_FORRANGE (R) c_FORRANGE (i, N) sum += con[i];
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -71,27 +71,27 @@ Sample test_stc_vector() {
         s.test[INSERT].t1 = clock();
         container con = cvec_x_init();
         csrandom(seed);
-        c_forrange (N) cvec_x_push_back(&con, crandom() & mask1);
+        c_FORRANGE (N) cvec_x_push_back(&con, crandom() & mask1);
         s.test[INSERT].t2 = clock();
         s.test[INSERT].sum = cvec_x_size(&con);
         s.test[ERASE].t1 = clock();
-        c_forrange (N) { cvec_x_pop_back(&con); }
+        c_FORRANGE (N) { cvec_x_pop_back(&con); }
         s.test[ERASE].t2 = clock();
         s.test[ERASE].sum = cvec_x_size(&con);
         cvec_x_drop(&con);
      }{
         csrandom(seed);
         container con = cvec_x_init();
-        c_forrange (N) cvec_x_push_back(&con, crandom() & mask2);
+        c_FORRANGE (N) cvec_x_push_back(&con, crandom() & mask2);
         s.test[FIND].t1 = clock();
         size_t sum = 0;
         //cvec_x_iter it, end = cvec_x_end(&con);
-        //c_forrange (S) if ((it = cvec_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
+        //c_FORRANGE (S) if ((it = cvec_x_find(&con, crandom() & mask2)).ref != end.ref) sum += *it.ref;
         s.test[FIND].t2 = clock();
         s.test[FIND].sum = sum;
         s.test[ITER].t1 = clock();
         sum = 0;
-        c_forrange (R) c_forrange (i, N) sum += con.data[i];
+        c_FORRANGE (R) c_FORRANGE (i, N) sum += con.data[i];
         s.test[ITER].t2 = clock();
         s.test[ITER].sum = sum;
         s.test[DESTRUCT].t1 = clock();
@@ -105,10 +105,10 @@ Sample test_stc_vector() {
 int main(int argc, char* argv[])
 {
     Sample std_s[SAMPLES + 1] = {{NULL}}, stc_s[SAMPLES + 1] = {{NULL}};
-    c_forrange (i, SAMPLES) {
+    c_FORRANGE (i, SAMPLES) {
         std_s[i] = test_std_vector();
         stc_s[i] = test_stc_vector();
-        if (i > 0) c_forrange (j, N_TESTS) {
+        if (i > 0) c_FORRANGE (j, N_TESTS) {
             if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];
             if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];
             if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %lld, sample %lld\n", i, j);
@@ -118,17 +118,17 @@ int main(int argc, char* argv[])
     bool header = (argc > 2 && argv[2][0] == '1');
     float std_sum = 0, stc_sum = 0;
 
-    c_forrange (j, N_TESTS) {
+    c_FORRANGE (j, N_TESTS) {
         std_sum += secs(std_s[0].test[j]);
         stc_sum += secs(stc_s[0].test[j]);
     }
     if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);
 
-    c_forrange (j, N_TESTS)
+    c_FORRANGE (j, N_TESTS)
         printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);
     printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);
 }
diff --git a/misc/benchmarks/shootout_hashmaps.cpp b/misc/benchmarks/shootout_hashmaps.cpp
index 78d7bce2..7c5095f6 100644
--- a/misc/benchmarks/shootout_hashmaps.cpp
+++ b/misc/benchmarks/shootout_hashmaps.cpp
@@ -48,7 +48,7 @@ KHASH_MAP_INIT_INT64(ii, IValue)
 #define CMAP_EMPLACE(X, key, val) cmap_##X##_insert(&map, key, val).ref->second
 #define CMAP_ERASE(X, key)        cmap_##X##_erase(&map, key)
 #define CMAP_FIND(X, key)         cmap_##X##_contains(&map, key)
-#define CMAP_FOR(X, i)            c_foreach (i, cmap_##X, map)
+#define CMAP_FOR(X, i)            c_FOREACH (i, cmap_##X, map)
 #define CMAP_ITEM(X, i)           i.ref->second
 #define CMAP_SIZE(X)              cmap_##X##_size(&map)
 #define CMAP_BUCKETS(X)           cmap_##X##_bucket_count(&map)
diff --git a/misc/examples/sidebyside.cpp b/misc/examples/sidebyside.cpp
index ca80664d..11328668 100644
--- a/misc/examples/sidebyside.cpp
+++ b/misc/examples/sidebyside.cpp
@@ -31,7 +31,7 @@ int main() {
         IIMap_insert(&hist, 13, 100).ref->second += 1;
         IIMap_insert(&hist, 12, 100).ref->second += 1;
         
-        c_foreach (i, IIMap, hist)
+        c_FOREACH (i, IIMap, hist)
             printf("%d, %d\n", i.ref->first, i.ref->second);
         puts("");
     }
@@ -50,7 +50,7 @@ int main() {
         c_FORLIST (i, SIMap_raw, {{"burger", 5}, {"pizza", 12}, {"steak", 15}})
             SIMap_emplace(&food, c_PAIR(i.ref));
         
-        c_foreach (i, SIMap, food)
+        c_FOREACH (i, SIMap, food)
             printf("%s, %d\n", cstr_str(&i.ref->first), i.ref->second);
         puts("");
     }