Experimental uppercase macros.

96 files changed, 764 insertions, 700 deletions

diff --git a/README.md b/README.md
index bcfc4b4d..012e3406 100644
--- a/README.md
+++ b/README.md
@@ -77,8 +77,8 @@ Finally, destruction of the lookup key (i.e. string literal) after usage is not
 is convenient in C. The alternative lookup type may also be used for adding entries into containers by using 
 the *emplace*-functions. E.g. `MyCStrVec_emplace_back(&vec, "Hello")`, which further simplifies usage of STC.
 3. the design of iterators: All container can be iterated the same way, and uses the
-same element access syntax. E.g. `c_foreach (it, IntContainer, container) printf(" %d", *it.ref);` will work for
-every type of container defined as `IntContainer` with `int` elements. Also the form `c_foreach (it, IntContainer, it1, it2)`
+same element access syntax. E.g. `c_FOREACH (it, IntContainer, container) printf(" %d", *it.ref);` will work for
+every type of container defined as `IntContainer` with `int` elements. Also the form `c_FOREACH (it, IntContainer, it1, it2)`
 may be used to iterate from `it1` up to `it2`.
 
 Performance
@@ -117,17 +117,17 @@ int main(void) {
 }
 ```
 Below is an alternative way to write this code with STC. It uses three
-macros: `c_auto`, `c_forlist`, and `c_foreach`. These macro not only
+macros: `c_AUTO`, `c_FORLIST`, and `c_FOREACH`. These macro not only
 simplifies the code, but more importantly makes it less prone to errors,
 while maintaining readability:
 ```c
 int main() {
-    c_auto (FVec, vec) // RAII: init + free at one location in the code.
+    c_AUTO (FVec, vec) // RAII: init + free at one location in the code.
     {
-        c_forlist (i, float, {10.f, 20.f, 30.f})   // use array literals.
+        c_FORLIST (i, float, {10.f, 20.f, 30.f})   // use array literals.
             FVec_push(&vec, *i.ref);               // alias for push_back.
 
-        c_foreach (i, FVec, vec)                   // works for all containers.
+        c_FOREACH (i, FVec, vec)                   // works for all containers.
             printf(" %g", *i.ref);
     }
 }
@@ -190,12 +190,12 @@ int Point_cmp(const struct Point* a, const struct Point* b) {
 
 int main(void) {
     /* define six containers with automatic call of init and drop (destruction after scope exit) */
-    c_auto (cset_int, set)
-    c_auto (cvec_pnt, vec)
-    c_auto (cdeq_int, deq)
-    c_auto (clist_int, lst)
-    c_auto (cstack_int, stk)
-    c_auto (csmap_int, map)
+    c_AUTO (cset_int, set)
+    c_AUTO (cvec_pnt, vec)
+    c_AUTO (cdeq_int, deq)
+    c_AUTO (clist_int, lst)
+    c_AUTO (cstack_int, stk)
+    c_AUTO (csmap_int, map)
     {
         int nums[4] = {10, 20, 30, 40};
         struct Point pts[4] = { {10, 1}, {20, 2}, {30, 3}, {40, 4} };
@@ -228,12 +228,12 @@ int main(void) {
         csmap_int_erase_at(&map, i5);
 
         printf("After erasing elements found:");
-        printf("\n set:"); c_foreach (i, cset_int, set) printf(" %d", *i.ref);
-        printf("\n vec:"); c_foreach (i, cvec_pnt, vec) printf(" (%g, %g)", i.ref->x, i.ref->y);
-        printf("\n deq:"); c_foreach (i, cdeq_int, deq) printf(" %d", *i.ref);
-        printf("\n lst:"); c_foreach (i, clist_int, lst) printf(" %d", *i.ref);
-        printf("\n stk:"); c_foreach (i, cstack_int, stk) printf(" %d", *i.ref);
-        printf("\n map:"); c_foreach (i, csmap_int, map) printf(" [%d: %d]", i.ref->first,
+        printf("\n set:"); c_FOREACH (i, cset_int, set) printf(" %d", *i.ref);
+        printf("\n vec:"); c_FOREACH (i, cvec_pnt, vec) printf(" (%g, %g)", i.ref->x, i.ref->y);
+        printf("\n deq:"); c_FOREACH (i, cdeq_int, deq) printf(" %d", *i.ref);
+        printf("\n lst:"); c_FOREACH (i, clist_int, lst) printf(" %d", *i.ref);
+        printf("\n stk:"); c_FOREACH (i, cstack_int, stk) printf(" %d", *i.ref);
+        printf("\n map:"); c_FOREACH (i, csmap_int, map) printf(" [%d: %d]", i.ref->first,
                                                                              i.ref->second);
     }
 }
@@ -370,8 +370,8 @@ and non-emplace methods:
 #define i_val_str       // special macro to enable container of cstr
 #include <stc/cvec.h>   // vector of string (cstr)
 ...
-c_auto (cvec_str, vec)  // declare and call cvec_str_init() and defer cvec_str_drop(&vec)
-c_autodrop (cstr, s, cstr_lit("a string literal"))  // like c_auto without auto default init.
+c_AUTO (cvec_str, vec)  // declare and call cvec_str_init() and defer cvec_str_drop(&vec)
+c_AUTODROP (cstr, s, cstr_lit("a string literal"))  // like c_AUTO without auto default init.
 {
     const char* hello = "Hello";
     cvec_str_push_back(&vec, cstr_from(hello);    // construct and add string from const char*
@@ -467,16 +467,16 @@ Memory efficiency
 
 ## API changes summary V4.0
 - Added **cregex** with documentation - powerful regular expressions.
-- Added: `c_forfilter`: container iteration with "piped" filtering using && operator. 4 built-in filters.
-- Added: `c_forwhile`: *c_foreach* container iteration with extra predicate.
-- Added: **crange**: number generator type, which can be iterated (e.g. with *c_forfilter*).
+- Added: `c_FORFILTER`: container iteration with "piped" filtering using && operator. 4 built-in filters.
+- Added: `c_FORWHILE`: *c_FOREACH* container iteration with extra predicate.
+- Added: **crange**: number generator type, which can be iterated (e.g. with *c_FORFILTER*).
 - Added back **coption** - command line argument parsing.
 - New + renamed loop iteration/scope macros:
-    - `c_forlist`: macro replacing `c_forarray` and `c_apply`. Iterate a compound literal list.
-    - `c_forrange`: macro replacing `c_forrange`. Iterate a `long long` type number sequence.
-    - `c_with`: macro renamed from `c_autovar`. Like Python's **with** statement.
-    - `c_scope`: macro renamed from `c_autoscope`.
-    - `c_defer`: macro renamed from `c_autodefer`. Resembles Go's and Zig's **defer**.
+    - `c_FORLIST`: macro replacing `c_forarray` and `c_apply`. Iterate a compound literal list.
+    - `c_FORRANGE`: macro replacing `c_FORRANGE`. Iterate a `long long` type number sequence.
+    - `c_WITH`: macro renamed from `c_autovar`. Like Python's **with** statement.
+    - `c_SCOPE`: macro renamed from `c_autoscope`.
+    - `c_DEFER`: macro renamed from `c_autodefer`. Resembles Go's and Zig's **defer**.
 - Updated **cstr**, now always takes self as pointer, like all containers except csview.
 - Updated **cvec**, **cdeq**, changed `*_range*` function names.
 
@@ -524,8 +524,8 @@ Memory efficiency
 - Renamed: *c_default_fromraw()* to `c_default_from()`.
 - Changed: the [**c_apply**](docs/ccommon_api.md) macros API.
 - Replaced: *csview_first_token()* and *csview_next_token()* with one function: `csview_token()`.
-- Added: **checkauto** tool for checking that c-source files uses `c_auto*` macros correctly.
+- Added: **checkauto** tool for checking that c-source files uses `c_AUTO*` macros correctly.
 - Added: general `i_keyclass` / `i_valclass` template parameters which auto-binds template functions.
 - Added: `i_opt` template parameter: compile-time options: `c_no_cmp`, `c_no_clone`, `c_no_atomic`, `c_is_forward`; may be combined with `|`
 - Added: [**cbox**](docs/cbox_api.md) type: smart pointer, similar to [Rust Box](https://doc.rust-lang.org/rust-by-example/std/box.html) and [std::unique_ptr](https://en.cppreference.com/w/cpp/memory/unique_ptr).
-- Added: [**c_forpair**](docs/ccommon_api.md) macro: for-loop with "structured binding"
+- Added: [**c_FORPAIR**](docs/ccommon_api.md) macro: for-loop with "structured binding"
diff --git a/docs/carc_api.md b/docs/carc_api.md
index 15e2c452..657d7257 100644
--- a/docs/carc_api.md
+++ b/docs/carc_api.md
@@ -98,24 +98,24 @@ bool        carc_X_value_eq(const i_val* x, const i_val* y);
 
 int main()
 {
-    c_auto (Stack, s1, s2) // RAII
+    c_AUTO (Stack, s1, s2) // RAII
     {
         // POPULATE s1 with shared pointers to Map:
         Map *map;
 
         map = Stack_push(&s1, Arc_make(Map_init()))->get; // push empty map to s1.
-        c_forlist (i, Map_raw, { {"Joey", 1990}, {"Mary", 1995}, {"Joanna", 1992} }) {
+        c_FORLIST (i, Map_raw, { {"Joey", 1990}, {"Mary", 1995}, {"Joanna", 1992} }) {
             Map_emplace(map, c_PAIR(i.ref)); // populate it.
         }
 
         map = Stack_push(&s1, Arc_make(Map_init()))->get;
-        c_forlist (i, Map_raw, { {"Rosanna", 2001}, {"Brad", 1999}, {"Jack", 1980} }) {
+        c_FORLIST (i, Map_raw, { {"Rosanna", 2001}, {"Brad", 1999}, {"Jack", 1980} }) {
             Map_emplace(map, c_PAIR(i.ref));
         }
 
         // POPULATE s2:
         map = Stack_push(&s2, Arc_make(Map_init()))->get;
-        c_forlist (i, Map_raw, { {"Steve", 1979}, {"Rick", 1974}, {"Tracy", 2003} }) {
+        c_FORLIST (i, Map_raw, { {"Steve", 1979}, {"Rick", 1974}, {"Tracy", 2003} }) {
             Map_emplace(map, c_PAIR(i.ref));
         }
         
@@ -134,15 +134,15 @@ int main()
         Map_emplace_or_assign(s1.data[1].get, "Shared", 2022);
 
         puts("S1");
-        c_foreach (i, Stack, s1) {
-            c_forpair (name, year, Map, *i.ref->get)
+        c_FOREACH (i, Stack, s1) {
+            c_FORPAIR (name, year, Map, *i.ref->get)
                 printf("  %s:%d", cstr_str(_.name), *_.year);
             puts("");
         }
 
         puts("S2");
-        c_foreach (i, Stack, s2) {
-            c_forpair (name, year, Map, *i.ref->get)
+        c_FOREACH (i, Stack, s2) {
+            c_FORPAIR (name, year, Map, *i.ref->get)
                 printf("  %s:%d", cstr_str(_.name), *_.year);
             puts("");
         }
diff --git a/docs/carray_api.md b/docs/carray_api.md
index fb2c6a89..cd4e0e45 100644
--- a/docs/carray_api.md
+++ b/docs/carray_api.md
@@ -90,7 +90,7 @@ int main()
     // Ex1
     int xd = 30, yd = 20, zd = 10;
     // define arr3[30][20][10], initialized with zeros.
-    c_autodrop (carr3_f, arr3, carr3_f_with_size(xd, yd, zd, 0.0f)) {
+    c_AUTODROP (carr3_f, arr3, carr3_f_with_size(xd, yd, zd, 0.0f)) {
         arr3.data[5][4][3] = 3.14f;
 
         float *arr1 = arr3.data[5][4];
@@ -103,9 +103,9 @@ int main()
 
     // Ex2
     int w = 256, h = 128;
-    c_with (carr2_i image = carr2_i_new_uninit(w, h), carr2_i_drop(&image)) {
+    c_WITH (carr2_i image = carr2_i_new_uninit(w, h), carr2_i_drop(&image)) {
         int n = 0;
-        c_foreach (i, carr2_i, image) {
+        c_FOREACH (i, carr2_i, image) {
             uint32_t t = n++ % 256;
             *i.ref = t | t << 8 | t << 16 | 255;
         }
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index b3314433..5f936b1c 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -92,18 +92,18 @@ void int_drop(int* x) {
 
 int main()
 {
-    c_auto (IVec, vec)  // declare and init vec, call drop at scope exit
-    c_auto (ISet, set)  // similar
+    c_AUTO (IVec, vec)  // declare and init vec, call drop at scope exit
+    c_AUTO (ISet, set)  // similar
     {
-        c_forlist (i, int, {2021, 2012, 2022, 2015})
+        c_FORLIST (i, int, {2021, 2012, 2022, 2015})
             IVec_emplace(&vec, *i.ref); // same as: IVec_push(&vec, IBox_from(*i.ref));
 
         printf("vec:");
-        c_foreach (i, IVec, vec)
+        c_FOREACH (i, IVec, vec)
             printf(" %d", *i.ref->get);
 
         // add odd numbers from vec to set
-        c_foreach (i, IVec, vec)
+        c_FOREACH (i, IVec, vec)
             if (*i.ref->get & 1)
                 ISet_insert(&set, IBox_clone(*i.ref));
 
@@ -112,11 +112,11 @@ int main()
         IVec_pop(&vec);
 
         printf("\nvec:");
-        c_foreach (i, IVec, vec)
+        c_FOREACH (i, IVec, vec)
             printf(" %d", *i.ref->get);
 
         printf("\nset:");
-        c_foreach (i, ISet, set)
+        c_FOREACH (i, ISet, set)
             printf(" %d", *i.ref->get);
     }
 }
diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 2c6db85f..a9961002 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -3,27 +3,27 @@
 The following macros are recommended to use, and they safe/have no side-effects.
 
 ## Scope macros (RAII)
-### c_auto, c_autodrop, c_with, c_scope, c_defer
+### c_AUTO, c_AUTODROP, c_WITH, c_SCOPE, c_DEFER
 General ***defer*** mechanics for resource acquisition. These macros allows you to specify the
 freeing of the resources at the point where the acquisition takes place.
-The **checkauto** utility described below, ensures that the `c_auto*` macros are used correctly.
+The **checkauto** utility described below, ensures that the `c_AUTO*` macros are used correctly.
 
 | Usage                                  | Description                                               |
 |:---------------------------------------|:----------------------------------------------------------|
-| `c_with (Type var=init, drop)`         | Declare `var`. Defer `drop...` to end of scope            |
-| `c_with (Type var=init, pred, drop)`   | Adds a predicate in order to exit early if init failed    |
-| `c_auto (Type, var1,...,var4)`         | `c_with (Type var1=Type_init(), Type_drop(&var1))` ...    |
-| `c_autodrop (Type, var, init...)`      | Like `c_with (Type var=init..., Type_drop(&var))`         |
-| `c_scope (init, drop)`                 | Execute `init` and defer `drop` to end of scope           |
-| `c_defer (drop...)`                    | Defer `drop...` to end of scope                           |
+| `c_WITH (Type var=init, drop)`         | Declare `var`. Defer `drop...` to end of scope            |
+| `c_WITH (Type var=init, pred, drop)`   | Adds a predicate in order to exit early if init failed    |
+| `c_AUTO (Type, var1,...,var4)`         | `c_WITH (Type var1=Type_init(), Type_drop(&var1))` ...    |
+| `c_AUTODROP (Type, var, init...)`      | Like `c_WITH (Type var=init..., Type_drop(&var))`         |
+| `c_SCOPE (init, drop)`                 | Execute `init` and defer `drop` to end of scope           |
+| `c_DEFER (drop...)`                    | Defer `drop...` to end of scope                           |
 | `continue`                             | Exit a block above without memory leaks                   |
 
-For multiple variables, use either multiple **c_with** in sequence, or declare variable outside
-scope and use **c_scope**. For convenience, **c_auto** support up to 4 variables.
+For multiple variables, use either multiple **c_WITH** in sequence, or declare variable outside
+scope and use **c_SCOPE**. For convenience, **c_AUTO** support up to 4 variables.
 ```c
-// `c_with` is similar to python `with`: it declares and can drop a variable after going out of scope.
-c_with (uint8_t* buf = malloc(BUF_SIZE), free(buf))
-c_with (FILE* fp = fopen(fname, "rb"), fclose(fp))
+// `c_WITH` is similar to python `with`: it declares and can drop a variable after going out of scope.
+c_WITH (uint8_t* buf = malloc(BUF_SIZE), free(buf))
+c_WITH (FILE* fp = fopen(fname, "rb"), fclose(fp))
 {
     int n = 0;
     if (fp && buf) {
@@ -32,14 +32,14 @@ c_with (FILE* fp = fopen(fname, "rb"), fclose(fp))
     }
 }
 
-c_with (cstr str = cstr_lit("Hello"), cstr_drop(&str))
+c_WITH (cstr str = cstr_lit("Hello"), cstr_drop(&str))
 {
     cstr_append(&str, " world");
     printf("%s\n", cstr_str(&str));
 }
 
-// `c_auto` automatically initialize and destruct up to 4 variables, like `c_with`.
-c_auto (cstr, s1, s2)
+// `c_AUTO` automatically initialize and destruct up to 4 variables, like `c_WITH`.
+c_AUTO (cstr, s1, s2)
 {
     cstr_append(&s1, "Hello");
     cstr_append(&s1, " world");
@@ -50,22 +50,22 @@ c_auto (cstr, s1, s2)
     printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
 }
 
-c_autodrop (cstr, str, cstr_lit("Hello"))
+c_AUTODROP (cstr, str, cstr_lit("Hello"))
 {
     cstr_append(&str, " world");
     printf("%s\n", cstr_str(&str));
 }
 
-// `c_scope` is like `c_with` but works with an already declared variable.
+// `c_SCOPE` is like `c_WITH` but works with an already declared variable.
 static pthread_mutex_t mut;
-c_scope (pthread_mutex_lock(&mut), pthread_mutex_unlock(&mut))
+c_SCOPE (pthread_mutex_lock(&mut), pthread_mutex_unlock(&mut))
 {
     /* Do syncronized work. */
 }
 
-// `c_defer` executes the expressions when leaving scope.
+// `c_DEFER` executes the expressions when leaving scope.
 cstr s1 = cstr_lit("Hello"), s2 = cstr_lit("world");
-c_defer (cstr_drop(&s1), cstr_drop(&s2))
+c_DEFER (cstr_drop(&s1), cstr_drop(&s2))
 {
     printf("%s %s\n", cstr_str(&s1), cstr_str(&s2));
 }
@@ -83,8 +83,8 @@ cvec_str readFile(const char* name)
 {
     cvec_str vec = cvec_str_init(); // returned
 
-    c_with (FILE* fp = fopen(name, "r"), fclose(fp))
-        c_with (cstr line = cstr_NULL, cstr_drop(&line))
+    c_WITH (FILE* fp = fopen(name, "r"), fclose(fp))
+        c_WITH (cstr line = cstr_NULL, cstr_drop(&line))
             while (cstr_getline(&line, fp))
                 cvec_str_emplace_back(&vec, cstr_str(&line));
     return vec;
@@ -92,30 +92,30 @@ cvec_str readFile(const char* name)
 
 int main()
 {
-    c_with (cvec_str x = readFile(__FILE__), cvec_str_drop(&x))
-        c_foreach (i, cvec_str, x)
+    c_WITH (cvec_str x = readFile(__FILE__), cvec_str_drop(&x))
+        c_FOREACH (i, cvec_str, x)
             printf("%s\n", cstr_str(i.ref));
 }
 ```
 
 ### The **checkauto** utility program (for RAII)
-The **checkauto** program will check the source code for any misuses of the `c_auto*` macros which
-may lead to resource leakages. The `c_auto*`- macros are implemented as one-time executed **for-loops**,
+The **checkauto** program will check the source code for any misuses of the `c_AUTO*` macros which
+may lead to resource leakages. The `c_AUTO*`- macros are implemented as one-time executed **for-loops**,
 so any `return` or `break` appearing within such a block will lead to resource leaks, as it will disable
 the cleanup/drop method to be called. A `break` may originally be intended to break a loop or switch
-outside the `c_auto` scope.
+outside the `c_AUTO` scope.
 
-NOTE: One must always make sure to unwind temporary allocated resources before a `return` in C. However, by using `c_auto*`-macros,
+NOTE: One must always make sure to unwind temporary allocated resources before a `return` in C. However, by using `c_AUTO*`-macros,
 - it is much easier to automatically detect misplaced return/break between resource acquisition and destruction.
 - it prevents forgetting to call the destructor at the end.
 
 The **checkauto** utility will report any misusages. The following example shows how to correctly break/return
-from a `c_auto` scope: 
+from a `c_AUTO` scope: 
 ```c
     int flag = 0;
     for (int i = 0; i<n; ++i) {
-        c_auto (cstr, text)
-        c_auto (List, list)
+        c_AUTO (cstr, text)
+        c_AUTO (List, list)
         {
             for (int j = 0; j<m; ++j) {
                 List_push_back(&list, i*j);
@@ -124,23 +124,23 @@ from a `c_auto` scope:
             }
             // WRONG:
             if (cond2())
-                break;      // checkauto ERROR! break inside c_auto.
+                break;      // checkauto ERROR! break inside c_AUTO.
 
             if (cond3())
-                return -1;  // checkauto ERROR! return inside c_auto
+                return -1;  // checkauto ERROR! return inside c_AUTO
             
             // CORRECT:
             if (cond2()) {
                 flag = 1;   // flag to break outer for-loop
-                continue;   // cleanup and leave c_auto block
+                continue;   // cleanup and leave c_AUTO block
             }
             if (cond3()) {
                 flag = -1;  // return -1
-                continue;   // cleanup and leave c_auto block
+                continue;   // cleanup and leave c_AUTO block
             }
             ...
         }
-        // do the return/break outside of c_auto
+        // do the return/break outside of c_AUTO
         if (flag < 0) return flag;
         else if (flag > 0) break;
         ...
@@ -148,33 +148,33 @@ from a `c_auto` scope:
 ```
 ## Loop abstraction macros
 
-### c_forlist
+### c_FORLIST
 Iterate compound literal array elements. Additional to `i.ref`, you can access `i.data`, `i.size`, and `i.index` of the input list/element.
 ```c
 // apply multiple push_backs
-c_forlist (i, int, {1, 2, 3})
+c_FORLIST (i, int, {1, 2, 3})
     cvec_i_push_back(&vec, *i.ref);
 
 // insert in existing map
-c_forlist (i, cmap_ii_raw, { {4, 5}, {6, 7} })
+c_FORLIST (i, cmap_ii_raw, { {4, 5}, {6, 7} })
     cmap_ii_insert(&map, i.ref->first, i.ref->second);
 
 // string literals pushed to a stack of cstr:
-c_forlist (i, const char*, {"Hello", "crazy", "world"})
+c_FORLIST (i, const char*, {"Hello", "crazy", "world"})
     cstack_str_emplace(&stk, *i.ref);
 
 // reverse the list:
-c_forlist (i, int, {1, 2, 3})
+c_FORLIST (i, int, {1, 2, 3})
     cvec_i_push_back(&vec, i.data[i.size - 1 - i.index]);
 ```
 
-### c_foreach, c_forpair
+### c_FOREACH, c_FORPAIR
 
 | Usage                                    | Description                     |
 |:-----------------------------------------|:--------------------------------|
-| `c_foreach (it, ctype, container)`       | Iteratate all elements          |
-| `c_foreach (it, ctype, it1, it2)`        | Iterate the range [it1, it2)    |
-| `c_forpair (key, val, ctype, container)` | Iterate with structured binding |
+| `c_FOREACH (it, ctype, container)`       | Iteratate all elements          |
+| `c_FOREACH (it, ctype, it1, it2)`        | Iterate the range [it1, it2)    |
+| `c_FORPAIR (key, val, ctype, container)` | Iterate with structured binding |
 
 ```c
 #define i_key int
@@ -182,59 +182,59 @@ c_forlist (i, int, {1, 2, 3})
 #define i_tag ii
 #include <stc/csmap.h>
 ...
-c_forlist (i, csmap_ii_raw, { {23,1}, {3,2}, {7,3}, {5,4}, {12,5} })
+c_FORLIST (i, csmap_ii_raw, { {23,1}, {3,2}, {7,3}, {5,4}, {12,5} })
     csmap_ii_insert(&map, i.ref->first, i.ref->second);
 
-c_foreach (i, csmap_ii, map)
+c_FOREACH (i, csmap_ii, map)
     printf(" %d", i.ref->first);
 // 3 5 7 12 23
 
 csmap_ii_iter it = csmap_ii_find(&map, 7);
-c_foreach (i, csmap_ii, it, csmap_ii_end(&map))
+c_FOREACH (i, csmap_ii, it, csmap_ii_end(&map))
     printf(" %d", i.ref->first);
 // 7 12 23
 
-c_forpair (id, count, csmap_ii, map)
+c_FORPAIR (id, count, csmap_ii, map)
     printf(" (%d %d)", *_.id, *_.count);
 // (3 2) (5 4) (7 3) (12 5) (23 1)
 ```
 
-### c_forrange
+### c_FORRANGE
 Abstraction for iterating sequence of numbers. Like python's **for** *i* **in** *range()* loop.
 
 | Usage                                       | Python equivalent                    |
 |:--------------------------------------------|:-------------------------------------|
-| `c_forrange (stop)`                          | `for _ in range(stop):`              |
-| `c_forrange (i, stop) // i type = long long` | `for i in range(stop):`              |
-| `c_forrange (i, start, stop)`                | `for i in range(start, stop):`       |
-| `c_forrange (i, start, stop, step)`          | `for i in range(start, stop, step):` |
+| `c_FORRANGE (stop)`                          | `for _ in range(stop):`              |
+| `c_FORRANGE (i, stop) // i type = long long` | `for i in range(stop):`              |
+| `c_FORRANGE (i, start, stop)`                | `for i in range(start, stop):`       |
+| `c_FORRANGE (i, start, stop, step)`          | `for i in range(start, stop, step):` |
 
 ```c
-c_forrange (5) printf("x");
+c_FORRANGE (5) printf("x");
 // xxxxx
-c_forrange (i, 5) printf(" %lld", i);
+c_FORRANGE (i, 5) printf(" %lld", i);
 // 0 1 2 3 4
-c_forrange (i, -3, 3) printf(" %lld", i);
+c_FORRANGE (i, -3, 3) printf(" %lld", i);
 // -3 -2 -1 0 1 2
-c_forrange (i, 30, 0, -5) printf(" %lld", i);
+c_FORRANGE (i, 30, 0, -5) printf(" %lld", i);
 // 30 25 20 15 10 5
 ```
 
-### c_forwhile, c_forfilter
+### c_FORWHILE, c_FORFILTER
 Iterate containers with stop-criteria and chained range filtering.
 
 | Usage                                               | Description                            |
 |:----------------------------------------------------|:---------------------------------------|
-| `c_forwhile (it, ctype, start, pred)`               | Iterate until pred is false            |
-| `c_forfilter (it, ctype, container, filter)`        | Filter out items in chain with &&      |
-| `c_forfilter (it, ctype, container, filter, pred)`  | Filter and iterate until pred is false |
+| `c_FORWHILE (it, ctype, start, pred)`               | Iterate until pred is false            |
+| `c_FORFILTER (it, ctype, container, filter)`        | Filter out items in chain with &&      |
+| `c_FORFILTER (it, ctype, container, filter, pred)`  | Filter and iterate until pred is false |
 
 | Built-in filter                   | Description                          |
 |:----------------------------------|:-------------------------------------|
-| `c_flt_skip(it, numItems)`        | Skip numItems                        |
-| `c_flt_take(it, numItems)`        | Take numItems                        |
-| `c_flt_skipwhile(it, predicate)`  | Skip items until predicate is false  |
-| `c_flt_takewhile(it, predicate)`  | Take items until predicate is false  |
+| `c_FLT_SKIP(it, numItems)`        | Skip numItems                        |
+| `c_FLT_TAKE(it, numItems)`        | Take numItems                        |
+| `c_FLT_SKIPWHILE(it, predicate)`  | Skip items until predicate is false  |
+| `c_FLT_TAKEWHILE(it, predicate)`  | Take items until predicate is false  |
 
 `it.index` holds the index of the source item, and `it.count` the current number of items taken.
 ```c
@@ -250,14 +250,14 @@ bool isPrime(int i) {
 #define isOdd(i) ((i) & 1)
 
 int main() {
-    c_auto (IVec, vec) {
-        c_forrange (i, 1000) IVec_push(&vec, 1000000 + i);
+    c_AUTO (IVec, vec) {
+        c_FORRANGE (i, 1000) IVec_push(&vec, 1000000 + i);
 
-        c_forfilter (i, IVec, vec,
+        c_FORFILTER (i, IVec, vec,
                         isOdd(*i.ref)
-                     && c_flt_skip(i, 100) // built-in
+                     && c_FLT_SKIP(i, 100) // built-in
                      && isPrime(*i.ref)
-                      , c_flt_take(i, 10)) { // breaks loop on false.
+                      , c_FLT_TAKE(i, 10)) { // breaks loop on false.
             printf(" %d", *i.ref);  
         }
         puts("");
@@ -265,7 +265,7 @@ int main() {
 }
 // Out: 1000211 1000213 1000231 1000249 1000253 1000273 1000289 1000291 1000303 1000313 
 ```
-Note that `c_flt_take()` is given as an optional argument, which makes the loop stop when it becomes false (for efficiency). Chaining it after `isPrime()` instead will give same result, but the full input is processed.
+Note that `c_FLT_TAKE()` is given as an optional argument, which makes the loop stop when it becomes false (for efficiency). Chaining it after `isPrime()` instead will give same result, but the full input is processed.
 
 ### crange
 **crange** is a number sequence generator type. The **crange_value** type is `long long`. Below, *start*, *stop*, *step* are type *crange_value*:
@@ -281,57 +281,57 @@ void        crange_next(crange_iter* it);
 // 1. All primes less than 32:
 crange r1 = crange_make(3, 32, 2);
 printf("2"); // first prime
-c_forfilter (i, crange, r1 
+c_FORFILTER (i, crange, r1 
               , isPrime(*i.ref))
     printf(" %lld", *i.ref);
 // 2 3 5 7 11 13 17 19 23 29 31
 
 // 2. The 11 first primes:
 printf("2");
-c_forfilter (i, crange, crange_literal(3, crange_MAX, 2) 
+c_FORFILTER (i, crange, crange_literal(3, crange_MAX, 2) 
               , isPrime(*i.ref)
-              , c_flt_take(10))
+              , c_FLT_TAKE(10))
     printf(" %lld", *i.ref);
 // 2 3 5 7 11 13 17 19 23 29 31
 ```
-### c_find_if, c_find_in, c_erase_if
+### c_FIND_IF, c_find_in, c_ERASE_IF
 Find or erase linearily in containers using a predicate
 ```c
 // Search vec for first value > 2:
 cvec_i_iter i;
-c_find_if(i, cvec_i, vec, *i.ref > 2);
+c_FIND_IF(i, cvec_i, vec, *i.ref > 2);
 if (i.ref) printf("%d\n", *i.ref);
 
 // Search map for a string containing "hello" and erase it:
 cmap_str_iter it, it1 = ..., it2 = ...;
-c_find_if(it, csmap_str, it1, it2, cstr_contains(it.ref, "hello"));
+c_FIND_IF(it, csmap_str, it1, it2, cstr_contains(it.ref, "hello"));
 if (it.ref) cmap_str_erase_at(&map, it);
 
 // Erase all strings containing "hello":
 // Note 1: iter i need not be declared.
 // Note 2: variables index and count can be accessed in predicate.
-c_erase_if(i, csmap_str, map, cstr_contains(i.ref, "hello"));
+c_ERASE_IF(i, csmap_str, map, cstr_contains(i.ref, "hello"));
 ```
 
-### c_new, c_alloc, c_alloc_n, c_drop
+### c_NEW, c_ALLOC, c_ALLOC_N, c_DROP
 
 | Usage                          | Meaning                                 |
 |:-------------------------------|:----------------------------------------|
-| `c_new (type, value)`          | Move value to a new object on the heap  |
-| `c_alloc (type)`               | `(type *) c_malloc(sizeof(type))`       |
-| `c_alloc_n (type, N)`          | `(type *) c_malloc((N)*sizeof(type))`   |
-| `c_drop (ctype, &c1, ..., &cN)` | `ctype_drop(&c1); ... ctype_drop(&cN)` |
+| `c_NEW (type, value)`          | Move value to a new object on the heap  |
+| `c_ALLOC (type)`               | `(type *) c_MALLOC(sizeof(type))`       |
+| `c_ALLOC_N (type, N)`          | `(type *) c_MALLOC((N)*sizeof(type))`   |
+| `c_DROP (ctype, &c1, ..., &cN)` | `ctype_drop(&c1); ... ctype_drop(&cN)` |
 
 ```c
 struct Pnt { double x, y, z; };
-struct Pnt *pnt = c_new (struct Pnt, {1.2, 3.4, 5.6});
-c_free(pnt);
+struct Pnt *pnt = c_NEW (struct Pnt, {1.2, 3.4, 5.6});
+c_FREE(pnt);
 
-int* array = c_alloc_n (int, 100);
-c_free(array);
+int* array = c_ALLOC_N (int, 100);
+c_FREE(array);
 
 cstr a = cstr_lit("Hello"), b = cstr_lit("World");
-c_drop(cstr, &a, &b);
+c_DROP(cstr, &a, &b);
 ```
 
 ### General predefined template parameter functions
@@ -347,9 +347,9 @@ bool        crawstr_eq(const crawstr* x, const crawstr* y);
 uint64_t    crawstr_hash(const crawstr* x);
 ```
 
-### c_malloc, c_calloc, c_realloc, c_free
+### c_MALLOC, c_CALLOC, c_REALLOC, c_FREE
 Memory allocator for the entire library. Macros can be overloaded by the user.
 
-### c_swap, c_arraylen
+### c_swap, c_ARRAYLEN
 - **c_swap(type, x, y)**: Simple macro for swapping internals of two objects.
-- **c_arraylen(array)**: Return number of elements in an array, e.g. `int array[] = {1, 2, 3, 4};`
+- **c_ARRAYLEN(array)**: Return number of elements in an array, e.g. `int array[] = {1, 2, 3, 4};`
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index 7ce4c7f1..e39a9d5d 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -110,14 +110,14 @@ cdeq_X_value        cdeq_X_value_clone(cdeq_X_value val);
 int main() {
     cdeq_i q = cdeq_i_init();
     cdeq_i_push_front(&q, 10);
-    c_foreach (i, cdeq_i, q)
+    c_FOREACH (i, cdeq_i, q)
         printf(" %d", *i.ref);
     puts("");
 
-    c_forlist (i, int, {1, 4, 5, 22, 33, 2})
+    c_FORLIST (i, int, {1, 4, 5, 22, 33, 2})
         cdeq_i_push_back(&q, *i.ref)
 
-    c_foreach (i, cdeq_i, q)
+    c_FOREACH (i, cdeq_i, q)
         printf(" %d", *i.ref);
     puts("");
 
@@ -126,7 +126,7 @@ int main() {
     cdeq_i_push_back(&q, 11);
     cdeq_i_push_front(&q, 8);
 
-    c_foreach (i, cdeq_i, q)
+    c_FOREACH (i, cdeq_i, q)
         printf(" %d", *i.ref);
     puts("");
     cdeq_i_drop(&q);
diff --git a/docs/clist_api.md b/docs/clist_api.md
index aae72224..9745fcdb 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -119,22 +119,22 @@ Interleave *push_front()* / *push_back()* then *sort()*:
 int main() {
     DList list = DList_init();
 
-    c_forlist (i, double, {10., 20., 30., 40., 50., 60., 70., 80., 90.})
+    c_FORLIST (i, double, {10., 20., 30., 40., 50., 60., 70., 80., 90.})
         DList_push_back(&list, *i.ref);
 
-    c_forrange (i, 1, 10) {
+    c_FORRANGE (i, 1, 10) {
         if (i & 1) DList_push_front(&list, (double) i);
         else       DList_push_back(&list, (double) i);
     }
 
     printf("initial: ");
-    c_foreach (i, DList, list)
+    c_FOREACH (i, DList, list)
         printf(" %g", *i.ref);
 
     DList_sort(&list); // mergesort O(n*log n)
 
     printf("\nsorted: ");
-    c_foreach (i, DList, list)
+    c_FOREACH (i, DList, list)
         printf(" %g", *i.ref);
 
     DList_drop(&list);
@@ -160,7 +160,7 @@ int main ()
 {
     clist_i L = clist_i_init();
 
-    c_forlist (i, int, {10, 20, 30, 40, 50})
+    c_FORLIST (i, int, {10, 20, 30, 40, 50})
         clist_i_push_back(&L, *i.ref);
                                                 // 10 20 30 40 50
     clist_i_iter it = clist_i_begin(&L);        // ^
@@ -172,7 +172,7 @@ int main ()
     it = clist_i_erase_range(&L, it, end);      // 10 30
                                                 //       ^
     printf("mylist contains:");
-    c_foreach (x, clist_i, L)
+    c_FOREACH (x, clist_i, L)
         printf(" %d", *x.ref);
     puts("");
 
@@ -195,11 +195,11 @@ Splice `[30, 40]` from *L2* into *L1* before `3`:
 #include <stdio.h>
 
 int main() {
-    c_auto (clist_i, L1, L2)
+    c_AUTO (clist_i, L1, L2)
     {
-        c_forlist (i, int, {1, 2, 3, 4, 5})
+        c_FORLIST (i, int, {1, 2, 3, 4, 5})
             clist_i_push_back(&L1, *i.ref);
-        c_forlist (i, int, {10, 20, 30, 40, 50})
+        c_FORLIST (i, int, {10, 20, 30, 40, 50})
             clist_i_push_back(&L2, *i.ref);
 
         clist_i_iter i = clist_i_advance(clist_i_begin(&L1), 2);
@@ -207,9 +207,9 @@ int main() {
 
         clist_i_splice_range(&L1, i, &L2, j1, j2);
 
-        c_foreach (i, clist_i, L1)
+        c_FOREACH (i, clist_i, L1)
             printf(" %d", *i.ref); puts("");
-        c_foreach (i, clist_i, L2)
+        c_FOREACH (i, clist_i, L2)
             printf(" %d", *i.ref); puts("");
     }
 }
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 520d9046..3946196b 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -127,16 +127,16 @@ bool                  c_memcmp_eq(const i_keyraw* a, const i_keyraw* b);       /
 int main()
 {
     // Create an unordered_map of three strings (that map to strings)
-    c_auto (cmap_str, u)
+    c_AUTO (cmap_str, u)
     {
-        c_forlist (i, cmap_str_raw, {
+        c_FORLIST (i, cmap_str_raw, {
             {"RED", "#FF0000"},
             {"GREEN", "#00FF00"},
             {"BLUE", "#0000FF"}
         }) cmap_str_emplace(&u, c_PAIR(i.ref));
 
         // Iterate and print keys and values of unordered map
-        c_foreach (n, cmap_str, u) {
+        c_FOREACH (n, cmap_str, u) {
             printf("Key:[%s] Value:[%s]\n", cstr_str(&n.ref->first), cstr_str(&n.ref->second));
         }
 
@@ -173,9 +173,9 @@ int main()
 {
     uint32_t col = 0xcc7744ff;
 
-    c_auto (cmap_id, idnames)
+    c_AUTO (cmap_id, idnames)
     {
-        c_forlist (i, cmap_id_raw, { {100, "Red"}, {110, "Blue"} })
+        c_FORLIST (i, cmap_id_raw, { {100, "Red"}, {110, "Blue"} })
             cmap_id_emplace(&idnames, c_PAIR(i.ref));
 
         // replace existing mapped value:
@@ -187,7 +187,7 @@ int main()
         // emplace/insert does nothing if key already exist:
         cmap_id_emplace(&idnames, 100, "Green");
 
-        c_foreach (i, cmap_id, idnames)
+        c_FOREACH (i, cmap_id, idnames)
             printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
     }
 }
@@ -214,14 +214,14 @@ typedef struct { int x, y, z; } Vec3i;
 int main()
 {
     // Define map with defered destruct
-    c_with (cmap_vi vecs = cmap_vi_init(), cmap_vi_drop(&vecs))
+    c_WITH (cmap_vi vecs = cmap_vi_init(), cmap_vi_drop(&vecs))
     {
         cmap_vi_insert(&vecs, (Vec3i){100,   0,   0}, 1);
         cmap_vi_insert(&vecs, (Vec3i){  0, 100,   0}, 2);
         cmap_vi_insert(&vecs, (Vec3i){  0,   0, 100}, 3);
         cmap_vi_insert(&vecs, (Vec3i){100, 100, 100}, 4);
 
-        c_forpair (vec, num, cmap_vi, vecs)
+        c_FORPAIR (vec, num, cmap_vi, vecs)
             printf("{ %3d, %3d, %3d }: %d\n", _.vec->x, _.vec->y, _.vec->z, *_.num);
     }
 }
@@ -247,14 +247,14 @@ typedef struct { int x, y, z; } Vec3i;
 
 int main()
 {
-    c_auto (cmap_iv, vecs) // shorthand for c_with with _init(), _drop().
+    c_AUTO (cmap_iv, vecs) // shorthand for c_WITH with _init(), _drop().
     {
         cmap_iv_insert(&vecs, 1, (Vec3i){100,   0,   0});
         cmap_iv_insert(&vecs, 2, (Vec3i){  0, 100,   0});
         cmap_iv_insert(&vecs, 3, (Vec3i){  0,   0, 100});
         cmap_iv_insert(&vecs, 4, (Vec3i){100, 100, 100});
 
-        c_forpair (num, vec, cmap_iv, vecs)
+        c_FORPAIR (num, vec, cmap_iv, vecs)
             printf("%d: { %3d, %3d, %3d }\n", *_.num, _.vec->x, _.vec->y, _.vec->z);
     }
 }
@@ -314,20 +314,20 @@ static inline void Viking_drop(Viking* vk) {
 int main()
 {
     // Use a HashMap to store the vikings' health points.
-    c_auto (Vikings, vikings) // uses Vikings_init(), Vikings_drop()
+    c_AUTO (Vikings, vikings) // uses Vikings_init(), Vikings_drop()
     {
         Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Norway")}, 25);
         Vikings_insert(&vikings, (Viking){cstr_lit("Olaf"), cstr_lit("Denmark")}, 24);
         Vikings_insert(&vikings, (Viking){cstr_lit("Harald"), cstr_lit("Iceland")}, 12);
         Vikings_insert(&vikings, (Viking){cstr_lit("Einar"), cstr_lit("Denmark")}, 21);
         
-        c_auto (Viking, lookup) {
+        c_AUTO (Viking, lookup) {
             lookup = (Viking){cstr_lit("Einar"), cstr_lit("Norway")};
             printf("Lookup: Einar of Norway has %d hp\n\n", *Vikings_at(&vikings, lookup));
         }
 
         // Print the status of the vikings.
-        c_forpair (vik, hp, Vikings, vikings) {
+        c_FORPAIR (vik, hp, Vikings, vikings) {
             printf("%s of %s has %d hp\n", cstr_str(&_.vik->name), cstr_str(&_.vik->country), *_.hp);
         }
     }
@@ -354,7 +354,7 @@ typedef struct Viking {
 } Viking;
 
 static inline void Viking_drop(Viking* v) {
-    c_drop(cstr, &v->name, &v->country);
+    c_DROP(cstr, &v->name, &v->country);
 }
 
 // Define Viking raw struct with cmp, hash, and convertion functions between Viking and RViking structs:
@@ -397,7 +397,7 @@ static inline RViking Viking_toraw(const Viking* vp) {
 
 int main()
 {
-    c_auto (Vikings, vikings)
+    c_AUTO (Vikings, vikings)
     {
         Vikings_emplace(&vikings, (RViking){"Einar", "Norway"}, 20);
         Vikings_emplace(&vikings, (RViking){"Olaf", "Denmark"}, 24);
@@ -407,7 +407,7 @@ int main()
         Vikings_value *v = Vikings_get_mut(&vikings, (RViking){"Einar", "Norway"});
         if (v) v->second += 3; // add 3 hp points to Einar
 
-        c_forpair (vk, hp, Vikings, vikings) {
+        c_FORPAIR (vk, hp, Vikings, vikings) {
             printf("%s of %s has %d hp\n", cstr_str(&_.vk->name), cstr_str(&_.vk->country), *_.hp);
         }
     }
diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index a68e3392..790b902c 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -76,19 +76,19 @@ int main()
     stc64_uniform_t dist = stc64_uniform_new(0, N * 10);
 
     // Declare heap, with defered drop()
-    c_auto (cpque_i, heap)
+    c_AUTO (cpque_i, heap)
     {
         // Push ten million random numbers to priority queue.
-        c_forrange (N)
+        c_FORRANGE (N)
             cpque_i_push(&heap, stc64_uniform(&rng, &dist));
 
         // Add some negative ones.
         int nums[] = {-231, -32, -873, -4, -343};
-        c_forrange (i, c_arraylen(nums)) 
+        c_FORRANGE (i, c_ARRAYLEN(nums)) 
             cpque_i_push(&heap, nums[i]);
 
         // Extract and display the fifty smallest.
-        c_forrange (50) {
+        c_FORRANGE (50) {
             printf("%" PRId64 " ", *cpque_i_top(&heap));
             cpque_i_pop(&heap);
         }
diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md
index 89ca7d5c..977fa855 100644
--- a/docs/cqueue_api.md
+++ b/docs/cqueue_api.md
@@ -70,13 +70,13 @@ int main() {
     cqueue_i Q = cqueue_i_init();
 
     // push() and pop() a few.
-    c_forrange (i, 20)
+    c_FORRANGE (i, 20)
         cqueue_i_push(&Q, i);
 
-    c_forrange (5)
+    c_FORRANGE (5)
         cqueue_i_pop(&Q);
 
-    c_foreach (i, cqueue_i, Q)
+    c_FOREACH (i, cqueue_i, Q)
         printf(" %d", *i.ref);
 
     cqueue_i_drop(&Q);
diff --git a/docs/crandom_api.md b/docs/crandom_api.md
index 3e6ae8f0..bd3bf848 100644
--- a/docs/crandom_api.md
+++ b/docs/crandom_api.md
@@ -94,14 +94,14 @@ int main()
 
     // Create histogram map
     csmap_i mhist = csmap_i_init();
-    c_forrange (N) {
+    c_FORRANGE (N) {
         int index = (int) round( stc64_normalf(&rng, &dist) );
         csmap_i_emplace(&mhist, index, 0).ref->second += 1;
     }
 
     // Print the gaussian bar chart
     cstr bar = cstr_init();
-    c_foreach (i, csmap_i, mhist) {
+    c_FOREACH (i, csmap_i, mhist) {
         size_t n = (size_t) (i.ref->second * StdDev * Scale * 2.5 / N);
         if (n > 0) {
             cstr_resize(&bar, n, '*');
diff --git a/docs/cregex_api.md b/docs/cregex_api.md
index ce218721..1b3c03d6 100644
--- a/docs/cregex_api.md
+++ b/docs/cregex_api.md
@@ -129,19 +129,19 @@ if (cregex_find_pattern(pattern, input, match, CREG_DEFAULT))
 To compile, use: `gcc first_match.c src/cregex.c src/utf8code.c`.
 In order to use a callback function in the replace call, see `examples/regex_replace.c`.
 
-### Iterate through regex matches, *c_formatch*
+### Iterate through regex matches, *c_FORMATCH*
 
 To iterate multiple matches in an input string, you may use
 ```c
 csview match[5] = {0};
 while (cregex_find(&re, input, match, CREG_M_NEXT) == CREG_OK)
-    c_forrange (k, cregex_captures(&re))
+    c_FORRANGE (k, cregex_captures(&re))
         printf("submatch %lld: %.*s\n", k, c_ARGSV(match[k]));
 ```
 There is also a safe macro which simplifies this:
 ```c
-c_formatch (it, &re, input)
-    c_forrange (k, cregex_captures(&re))
+c_FORMATCH (it, &re, input)
+    c_FORRANGE (k, cregex_captures(&re))
         printf("submatch %lld: %.*s\n", k, c_ARGSV(it.match[k]));
 ```
 
diff --git a/docs/cset_api.md b/docs/cset_api.md
index 266895be..43cbdead 100644
--- a/docs/cset_api.md
+++ b/docs/cset_api.md
@@ -87,15 +87,15 @@ cset_X_value        cset_X_value_clone(cset_X_value val);
 
 int main ()
 {
-    c_auto (cset_str, fifth)
+    c_AUTO (cset_str, fifth)
     {
-        c_auto (cset_str, first, second)
-        c_auto (cset_str, third, fourth)
+        c_AUTO (cset_str, first, second)
+        c_AUTO (cset_str, third, fourth)
         {
-            c_forlist (i, const char*, {"red", "green", "blue"})
+            c_FORLIST (i, const char*, {"red", "green", "blue"})
                 cset_str_emplace(&second, *i.ref);
 
-            c_forlist (i, const char*, {"orange", "pink", "yellow"})
+            c_FORLIST (i, const char*, {"orange", "pink", "yellow"})
                 cset_str_emplace(&third, *i.ref);
 
             cset_str_emplace(&fourth, "potatoes");
@@ -103,14 +103,14 @@ int main ()
             cset_str_emplace(&fourth, "flour");
 
             fifth = cset_str_clone(second);
-            c_foreach (i, cset_str, third)
+            c_FOREACH (i, cset_str, third)
                 cset_str_emplace(&fifth, cstr_str(i.ref));
 
-            c_foreach (i, cset_str, fourth)
+            c_FOREACH (i, cset_str, fourth)
                 cset_str_emplace(&fifth, cstr_str(i.ref));
         }
         printf("fifth contains:\n\n");
-        c_foreach (i, cset_str, fifth)
+        c_FOREACH (i, cset_str, fifth)
             printf("%s\n", cstr_str(i.ref));
     }
 }
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index bb0253c7..394d3451 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -112,16 +112,16 @@ csmap_X_raw           csmap_X_value_toraw(csmap_X_value* pval);
 int main()
 {
     // Create a sorted map of three strings (maps to string)
-    c_auto (csmap_str, colors) // RAII
+    c_AUTO (csmap_str, colors) // RAII
     {
-        c_forlist (i, csmap_str_raw, {
+        c_FORLIST (i, csmap_str_raw, {
             {"RED", "#FF0000"},
             {"GREEN", "#00FF00"},
             {"BLUE", "#0000FF"}
         }) csmap_str_emplace(&colors, c_PAIR(i.ref));
 
         // Iterate and print keys and values of sorted map
-        c_foreach (i, csmap_str, colors) {
+        c_FOREACH (i, csmap_str, colors) {
             printf("Key:[%s] Value:[%s]\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
         }
 
@@ -158,9 +158,9 @@ int main()
 {
     uint32_t col = 0xcc7744ff;
     csmap_id idnames = csmap_id_init();
-    c_defer (csmap_id_drop(&idnames)) 
+    c_DEFER (csmap_id_drop(&idnames)) 
     {
-        c_forlist (i, csmap_id_raw, { {100, "Red"}, {110, "Blue"} })
+        c_FORLIST (i, csmap_id_raw, { {100, "Red"}, {110, "Blue"} })
             csmap_id_emplace(&idnames, c_PAIR(i.ref));
 
         // put replaces existing mapped value:
@@ -172,7 +172,7 @@ int main()
         // emplace adds only when key does not exist:
         csmap_id_emplace(&idnames, 100, "Green");
 
-        c_foreach (i, csmap_id, idnames)
+        c_FOREACH (i, csmap_id, idnames)
             printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
     }
 }
@@ -205,14 +205,14 @@ static int Vec3i_cmp(const Vec3i* a, const Vec3i* b) {
 
 int main()
 {
-    c_auto (csmap_vi, vecs)
+    c_AUTO (csmap_vi, vecs)
     {
       csmap_vi_insert(&vecs, (Vec3i){100, 0, 0}, 1);
       csmap_vi_insert(&vecs, (Vec3i){0, 100, 0}, 2);
       csmap_vi_insert(&vecs, (Vec3i){0, 0, 100}, 3);
       csmap_vi_insert(&vecs, (Vec3i){100, 100, 100}, 4);
 
-      c_foreach (i, csmap_vi, vecs)
+      c_FOREACH (i, csmap_vi, vecs)
           printf("{ %3d, %3d, %3d }: %d\n", i.ref->first.x, i.ref->first.y, i.ref->first.z, i.ref->second);
     }
 }
@@ -238,15 +238,15 @@ typedef struct { int x, y, z; } Vec3i;
 
 int main()
 {
-    // equivalent to: c_auto (csmap_iv, vecs)
-    c_with (csmap_iv vecs = csmap_iv_init(), csmap_iv_drop(&vecs))
+    // equivalent to: c_AUTO (csmap_iv, vecs)
+    c_WITH (csmap_iv vecs = csmap_iv_init(), csmap_iv_drop(&vecs))
     {
         csmap_iv_insert(&vecs, 1, (Vec3i){100, 0, 0});
         csmap_iv_insert(&vecs, 2, (Vec3i){0, 100, 0});
         csmap_iv_insert(&vecs, 3, (Vec3i){0, 0, 100});
         csmap_iv_insert(&vecs, 4, (Vec3i){100, 100, 100});
 
-        c_foreach (i, csmap_iv, vecs)
+        c_FOREACH (i, csmap_iv, vecs)
             printf("%d: { %3d, %3d, %3d }\n", i.ref->first, i.ref->second.x, i.ref->second.y, i.ref->second.z);
     }
 }
diff --git a/docs/csset_api.md b/docs/csset_api.md
index 6b2bdfdf..5b833af5 100644
--- a/docs/csset_api.md
+++ b/docs/csset_api.md
@@ -84,29 +84,27 @@ csset_X_value        csset_X_value_clone(csset_X_value val);
 
 int main ()
 {
-c_auto (csset_str, fifth)
+    c_AUTO (csset_str, first, second, third)
+    c_AUTO (csset_str, fourth, fifth)
     {
-        c_auto (csset_str, first, second)
-        c_auto (csset_str, third, fourth)
-        {
-            c_forlist (i, const char*, {"red", "green", "blue"})
-                csset_str_emplace(&second, *i.ref);
-
-            c_forlist (i, const char*, {"orange", "pink", "yellow"})
-                csset_str_emplace(&third, *i.ref);
-
-            csset_str_emplace(&fourth, "potatoes");
-            csset_str_emplace(&fourth, "milk");
-            csset_str_emplace(&fourth, "flour");
-
-            fifth = csset_str_clone(second);
-            c_foreach (i, csset_str, third)
-                csset_str_emplace(&fifth, cstr_str(i.ref));
-            c_foreach (i, csset_str, fourth)
-                csset_str_emplace(&fifth, cstr_str(i.ref));
-        }
+        c_FORLIST (i, const char*, {"red", "green", "blue"})
+            csset_str_emplace(&second, *i.ref);
+
+        c_FORLIST (i, const char*, {"orange", "pink", "yellow"})
+            csset_str_emplace(&third, *i.ref);
+
+        csset_str_emplace(&fourth, "potatoes");
+        csset_str_emplace(&fourth, "milk");
+        csset_str_emplace(&fourth, "flour");
+
+        fifth = csset_str_clone(second);
+        c_FOREACH (i, csset_str, third)
+            csset_str_emplace(&fifth, cstr_str(i.ref));
+        c_FOREACH (i, csset_str, fourth)
+            csset_str_emplace(&fifth, cstr_str(i.ref));
+
         printf("fifth contains:\n\n");
-        c_foreach (i, csset_str, fifth)
+        c_FOREACH (i, csset_str, fifth)
             printf("%s\n", cstr_str(i.ref));
     }
 }
diff --git a/docs/cstr_api.md b/docs/cstr_api.md
index 0f9589d9..3857633a 100644
--- a/docs/cstr_api.md
+++ b/docs/cstr_api.md
@@ -160,30 +160,30 @@ char*        cstrnstrn(const char* str, const char* search, size_t slen, size_t
 #include <stc/cstr.h>
 
 int main() {
-    cstr s0 = cstr_lit("Initialization without using strlen().");
-    printf("%s\nLength: %" c_ZU "\n\n", cstr_str(&s0), cstr_size(&s0));
+    c_AUTO (cstr, s0, s1, full_path) {
+        s0 = cstr_lit("Initialization without using strlen().");
+        printf("%s\nLength: %" c_ZU "\n\n", cstr_str(&s0), cstr_size(&s0));
 
-    cstr s1 = cstr_lit("one-nine-three-seven-five.");
-    printf("%s\n", cstr_str(&s1));
+        s1 = cstr_lit("one-nine-three-seven-five.");
+        printf("%s\n", cstr_str(&s1));
 
-    cstr_insert(&s1, 3, "-two");
-    printf("%s\n", cstr_str(&s1));
+        cstr_insert(&s1, 3, "-two");
+        printf("%s\n", cstr_str(&s1));
 
-    cstr_erase(&s1, 7, 5); // -nine
-    printf("%s\n", cstr_str(&s1));
+        cstr_erase(&s1, 7, 5); // -nine
+        printf("%s\n", cstr_str(&s1));
 
-    cstr_replace(&s1, "seven", "four", 1);
-    printf("%s\n", cstr_str(&s1));
+        cstr_replace(&s1, "seven", "four", 1);
+        printf("%s\n", cstr_str(&s1));
 
-    // reassign:
-    cstr_assign(&s1, "one two three four five six seven");
-    cstr_append(&s1, " eight");
-    printf("append: %s\n", cstr_str(&s1));
+        // reassign:
+        cstr_assign(&s1, "one two three four five six seven");
+        cstr_append(&s1, " eight");
+        printf("append: %s\n", cstr_str(&s1));
 
-    cstr full_path = cstr_from_fmt("%s/%s.%s", "directory", "filename", "ext");
-    printf("%s\n", cstr_str(&full_path));
-
-    c_drop(cstr, &s0, &s1, &full_path);
+        full_path = cstr_from_fmt("%s/%s.%s", "directory", "filename", "ext");
+        printf("%s\n", cstr_str(&full_path));
+    }
 }
 ```
 Output:
diff --git a/docs/csview_api.md b/docs/csview_api.md
index 4851152a..05348745 100644
--- a/docs/csview_api.md
+++ b/docs/csview_api.md
@@ -83,11 +83,11 @@ csview          cstr_u8_substr(const cstr* self, size_t bytepos, size_t u8len);
 csview          cstr_slice(const cstr* self, size_t p1, size_t p2);
 csview          cstr_slice_ex(const cstr* s, intptr_t p, intptr_t q);    // negative p or q count from end
 ```
-#### Iterate tokens with *c_fortoken*, *c_fortoken_sv*
+#### Iterate tokens with *c_FORTOKEN*, *c_FORTOKEN_SV*
 
 To iterate tokens in an input string separated by a string:
 ```c
-c_fortoken (i, "hello, one, two, three", ", ")
+c_FORTOKEN (i, "hello, one, two, three", ", ")
     printf("token: %.*s\n", c_ARGSV(i.token));
 ```
 
@@ -135,7 +135,7 @@ int main ()
     cstr s3 = cstr_from_sv(cstr_substr(&s1, 0, 6));     // "Apples"
     printf("%s %s\n", cstr_str(&s2), cstr_str(&s3));
 
-    c_drop(cstr, &str1, &s1, &s2, &s3);
+    c_DROP(cstr, &str1, &s1, &s2, &s3);
 }
 ```
 Output:
@@ -151,12 +151,12 @@ red Apples
 
 int main()
 {
-    c_auto (cstr, s1) {
+    c_AUTO (cstr, s1) {
         s1 = cstr_lit("hell😀 w😀rld");
         cstr_u8_replace(&s1, cstr_find(&s1, "😀rld"), 1, c_SV("ø"));
         printf("%s\n", cstr_str(&s1));
 
-        c_foreach (i, cstr, s1)
+        c_FOREACH (i, cstr, s1)
             printf("%.*s,", c_ARGSV(i.u8.chr));
     }
 }
@@ -176,7 +176,7 @@ and does not depend on null-terminated strings. *string_split()* function return
 
 void print_split(csview input, const char* sep)
 {
-    c_fortoken_sv (i, input, sep)
+    c_FORTOKEN_SV (i, input, sep)
         printf("[%.*s]\n", c_ARGSV(i.token));
 }
 
@@ -188,7 +188,7 @@ cstack_str string_split(csview input, const char* sep)
 {
     cstack_str out = cstack_str_init();
     
-    c_fortoken_sv (i, input, sep)
+    c_FORTOKEN_SV (i, input, sep)
         cstack_str_push(&out, cstr_from_sv(i.token));
 
     return out;
@@ -201,8 +201,8 @@ int main()
     print_split(c_SV("This has no matching separator"), "xx");
     puts("");
 
-    c_with (cstack_str s = string_split(c_SV("Split,this,,string,now,"), ","), cstack_str_drop(&s))
-        c_foreach (i, cstack_str, s)
+    c_WITH (cstack_str s = string_split(c_SV("Split,this,,string,now,"), ","), cstack_str_drop(&s))
+        c_FOREACH (i, cstack_str, s)
             printf("[%s]\n", cstr_str(i.ref));
 }
 ```
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 9b2614af..23722275 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -120,18 +120,18 @@ cvec_X_value        cvec_X_value_clone(cvec_X_value val);
 int main()
 {
     // Create a vector containing integers
-    c_auto (cvec_int, vec)
+    c_AUTO (cvec_int, vec)
     {
         // Add two integers to vector
         cvec_int_push(&vec, 25);
         cvec_int_push(&vec, 13);
 
         // Append a set of numbers
-        c_forlist (i, int, {7, 5, 16, 8})
+        c_FORLIST (i, int, {7, 5, 16, 8})
             cvec_int_push(&vec, *i.ref);
 
         printf("initial:");
-        c_foreach (k, cvec_int, vec) {
+        c_FOREACH (k, cvec_int, vec) {
             printf(" %d", *k.ref);
         }
 
@@ -139,7 +139,7 @@ int main()
         cvec_int_sort(&vec);
 
         printf("\nsorted:");
-        c_foreach (k, cvec_int, vec) {
+        c_FOREACH (k, cvec_int, vec) {
             printf(" %d", *k.ref);
         }
     }
@@ -171,7 +171,7 @@ int main() {
 
     printf("%s\n", cstr_str(&names.data[1])); // Access second element
 
-    c_foreach (i, cvec_str, names)
+    c_FOREACH (i, cvec_str, names)
         printf("item: %s\n", cstr_str(i.ref));
 
     cvec_str_drop(&names);
@@ -220,9 +220,9 @@ int main(void) {
 
     UVec vec2 = UVec_clone(vec);
 
-    c_foreach (i, UVec, vec2)
+    c_FOREACH (i, UVec, vec2)
         printf("%s: %d\n", cstr_str(&i.ref->name), i.ref->id);
 
-    c_drop(UVec, &vec, &vec2); // cleanup
+    c_DROP(UVec, &vec, &vec2); // cleanup
 }
 ```
\ No newline at end of file
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index af6b52a5..95c35915 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -29,6 +29,7 @@
 #include <stdbool.h>
 #include <string.h>
 #include <assert.h>
+#include "priv/allcaps.h"
 
 #if SIZE_MAX == UINT32_MAX
   #define c_ZU PRIu32
diff --git a/include/stc/priv/allcaps.h b/include/stc/priv/allcaps.h
new file mode 100644
index 00000000..1e2460b5
--- /dev/null
+++ b/include/stc/priv/allcaps.h
@@ -0,0 +1,56 @@
+/* MIT License
+ *
+ * Copyright (c) 2022 Tyge Løvset, NORCE, www.norceresearch.no
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#define c_ALLOC c_alloc
+#define c_ALLOC_N c_alloc_n
+#define c_NEW c_new
+#define c_MALLOC c_malloc
+#define c_CALLOC c_calloc
+#define c_REALLOC c_realloc
+#define c_FREE c_free
+#define c_DELETE c_delete
+#define c_SWAP c_swap
+#define c_CONTAINER_OF c_container_of
+#define c_STATIC_ASSERT c_static_assert
+#define c_ARRAYLEN c_arraylen
+#define c_OPTION c_option
+#define c_FORLIST c_forlist
+#define c_FORRANGE c_forrange
+#define c_FOREACH c_foreach
+#define c_FORWHILE c_forwhile
+#define c_FORPAIR c_forpair
+#define c_FORFILTER c_forfilter
+#define c_FORMATCH c_formatch
+#define c_FORTOKEN c_fortoken
+#define c_FORTOKEN_SV c_fortoken_sv
+#define c_AUTO c_auto
+#define c_AUTODROP c_autodrop
+#define c_WITH c_with
+#define c_SCOPE c_scope
+#define c_DEFER c_defer
+#define c_DROP c_drop
+#define c_FIND_IF c_find_if
+#define c_ERASE_IF c_erase_if
+#define c_FLT_TAKE c_flt_take
+#define c_FLT_SKIP c_flt_skip
+#define c_FLT_SKIPWHILE c_flt_skipwhile
+#define c_FLT_TAKEWHILE c_flt_takewhile
diff --git a/include/stc/views.h b/include/stc/views.h
index 8f7a0d78..ea5f4536 100644
--- a/include/stc/views.h
+++ b/include/stc/views.h
@@ -63,8 +63,8 @@ int main()
 
 #include <stc/ccommon.h>
 
-#ifndef c_FLT_STACK
-  #define c_FLT_STACK 14 /* 22, 30, .. */
+#ifndef c_NFILTERS
+  #define c_NFILTERS 14 /* 22, 30, .. */
 #endif
 #define c_flt_take(i, n) (++(i).s1[(i).s1top++] <= (n))
 #define c_flt_skip(i, n) (++(i).s1[(i).s1top++] > (n))
@@ -78,8 +78,8 @@ int main()
     c_forfilter_s(i, C, C##_begin(&cnt), filter) if (!(cond)) break; else
 #define c_forfilter_s(i, C, start, filter) \
     for (struct {C##_iter it; C##_value *ref; \
-                 uint32_t s1[c_FLT_STACK], index, count; \
-                 bool s2[c_FLT_STACK]; uint8_t s1top, s2top;} \
+                 uint32_t s1[c_NFILTERS], index, count; \
+                 bool s2[c_NFILTERS]; uint8_t s1top, s2top;} \
          i = {.it=start, .ref=i.it.ref}; i.it.ref \
          ; C##_next(&i.it), i.ref = i.it.ref, ++i.index, i.s1top=0, i.s2top=0) \
       if (!((filter) && ++i.count)) ; else
diff --git a/misc/benchmarks/misc/rust_cmap.c b/misc/benchmarks/misc/rust_cmap.c
index 83b7dd19..18635c35 100644
--- a/misc/benchmarks/misc/rust_cmap.c
+++ b/misc/benchmarks/misc/rust_cmap.c
@@ -24,7 +24,7 @@ uint64_t romu_trio(uint64_t s[3]) {
 
 int main()
 {
-    c_auto (cmap_u64, m) {
+    c_AUTO (cmap_u64, m) {
         const size_t n = 50000000, 
                      mask = (1 << 25) - 1,
                      ms = CLOCKS_PER_SEC/1000; 
@@ -33,7 +33,7 @@ int main()
 
         uint64_t rng[3] = {1872361123, 123879177, 87739234}, sum;
         clock_t now = clock();
-        c_forrange (n) {
+        c_FORRANGE (n) {
             uint64_t key = romu_trio(rng) & mask;
             cmap_u64_insert(&m, key, 0).ref->second += 1;
         }
@@ -41,17 +41,17 @@ int main()
 
         now = clock();
         sum = 0;
-        c_forrange (key, mask + 1) { sum += cmap_u64_contains(&m, key); }
+        c_FORRANGE (key, mask + 1) { sum += cmap_u64_contains(&m, key); }
         printf("lookup  : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
 
         now = clock();
         sum = 0;
-        c_foreach (i, cmap_u64, m) { sum += i.ref->second; }
+        c_FOREACH (i, cmap_u64, m) { sum += i.ref->second; }
         printf("iterate : %" c_ZU "ms  \tsum  : %" c_ZU "\n", (clock() - now)/ms, sum);
 
         uint64_t rng2[3] = {1872361123, 123879177, 87739234};
         now = clock();
-        c_forrange (n) {
+        c_FORRANGE (n) {
             uint64_t key = romu_trio(rng2) & mask;
             cmap_u64_erase(&m, key);
         }
diff --git a/misc/benchmarks/misc/string_bench_STC.cpp b/misc/benchmarks/misc/string_bench_STC.cpp
index ae8e4c38..39a46d50 100644
--- a/misc/benchmarks/misc/string_bench_STC.cpp
+++ b/misc/benchmarks/misc/string_bench_STC.cpp
@@ -37,8 +37,8 @@
 cvec_str read_file(const char* name)
 {
     cvec_str data = cvec_str_init();
-    c_auto (cstr, line)
-    c_with (FILE* f = fopen(name, "r"), fclose(f))
+    c_AUTO (cstr, line)
+    c_WITH (FILE* f = fopen(name, "r"), fclose(f))
         while (cstr_getline(&line, f))
             cvec_str_emplace_back(&data, cstr_str(&line));
     return data;
@@ -185,12 +185,12 @@ const size_t MAX_LOOP = 2000;
 
 int main()
 {
-    c_auto (cvec_str, vec_string)
-    c_auto (cvec_sv, vec_stringview)
-    c_auto (csmap_str, mapTrans)
-    c_auto (csmap_ssv, mapSview)
-    c_auto (cmap_str, unordmapTrans)
-    c_auto (cmap_ssv, unordmapSview)
+    c_AUTO (cvec_str, vec_string)
+    c_AUTO (cvec_sv, vec_stringview)
+    c_AUTO (csmap_str, mapTrans)
+    c_AUTO (csmap_ssv, mapSview)
+    c_AUTO (cmap_str, unordmapTrans)
+    c_AUTO (cmap_ssv, unordmapSview)
     {
         std::cout << "Short String Benchmark" << std::endl;
         std::cout << "======================" << std::endl;
diff --git a/misc/benchmarks/misc/string_bench_STD.cpp b/misc/benchmarks/misc/string_bench_STD.cpp
index 8bb87937..68065923 100644
--- a/misc/benchmarks/misc/string_bench_STD.cpp
+++ b/misc/benchmarks/misc/string_bench_STD.cpp
@@ -16,8 +16,8 @@
 std::vector<std::string> read_file(const char* name)
 {
     std::vector<std::string> data;
-    c_auto (cstr, line)
-    c_with (FILE* f = fopen(name, "r"), fclose(f))
+    c_AUTO (cstr, line)
+    c_WITH (FILE* f = fopen(name, "r"), fclose(f))
         while (cstr_getline(&line, f))
             data.emplace_back(cstr_str(&line));
     return data;
diff --git a/misc/benchmarks/plotbench/cpque_benchmark.cpp b/misc/benchmarks/plotbench/cpque_benchmark.cpp
index a729c09f..d6c2eda4 100644
--- a/misc/benchmarks/plotbench/cpque_benchmark.cpp
+++ b/misc/benchmarks/plotbench/cpque_benchmark.cpp
@@ -40,7 +40,7 @@ void stc_test()
     stc64_t rng;
     int N = 10000000, M = 10;
 
-    c_auto (cpque_f, pq)
+    c_AUTO (cpque_f, pq)
     {
         rng = stc64_new(seed);
         clock_t start = clock();
diff --git a/misc/examples/arc_containers.c b/misc/examples/arc_containers.c
index b577f2c8..026f9eb5 100644
--- a/misc/examples/arc_containers.c
+++ b/misc/examples/arc_containers.c
@@ -27,8 +27,8 @@
 
 int main()
 {
-    c_auto (Stack, stack)
-    c_auto (List, list)
+    c_AUTO (Stack, stack)
+    c_AUTO (List, list)
     {
         // POPULATE stack with shared pointers to Maps:
         Map *map;
@@ -64,14 +64,14 @@ int main()
 
 
         puts("STACKS");
-        c_foreach (i, Stack, stack) {
-            c_forpair (name, year, Map, *i.ref->get)
+        c_FOREACH (i, Stack, stack) {
+            c_FORPAIR (name, year, Map, *i.ref->get)
                 printf(" %s:%d", cstr_str(_.name), *_.year);
             puts("");
         }
         puts("LIST");
-        c_foreach (i, List, list) {
-            c_forpair (name, year, Map, *i.ref->get)
+        c_FOREACH (i, List, list) {
+            c_FORPAIR (name, year, Map, *i.ref->get)
                 printf(" %s:%d", cstr_str(_.name), *_.year);
             puts("");
         }
diff --git a/misc/examples/arc_demo.c b/misc/examples/arc_demo.c
index 087f90ac..f1cf3fda 100644
--- a/misc/examples/arc_demo.c
+++ b/misc/examples/arc_demo.c
@@ -21,19 +21,19 @@ void int_drop(int* x) {
 
 int main()
 {
-    c_auto (cvec_Arc, vec)   // declare and init vec, call cvec_Arc_drop() at scope exit
-    c_auto (csset_Arc, set)  // declare and init set, call csset_Arc_drop() at scope exit
+    c_AUTO (cvec_Arc, vec)   // declare and init vec, call cvec_Arc_drop() at scope exit
+    c_AUTO (csset_Arc, set)  // declare and init set, call csset_Arc_drop() at scope exit
     {
         const int years[] = {2021, 2012, 2022, 2015};
-        c_forrange (i, c_arraylen(years))
+        c_FORRANGE (i, c_ARRAYLEN(years))
             cvec_Arc_push(&vec, Arc_from(years[i]));
 
         printf("vec:");
-        c_foreach (i, cvec_Arc, vec) printf(" %d", *i.ref->get);
+        c_FOREACH (i, cvec_Arc, vec) printf(" %d", *i.ref->get);
         puts("");
 
         // add odd numbers from vec to set
-        c_foreach (i, cvec_Arc, vec)
+        c_FOREACH (i, cvec_Arc, vec)
             if (*i.ref->get & 1)
                 csset_Arc_insert(&set, Arc_clone(*i.ref)); // copy shared pointer => increments counter.
 
@@ -42,12 +42,12 @@ int main()
         cvec_Arc_pop_back(&vec);
 
         printf("vec:");
-        c_foreach (i, cvec_Arc, vec) printf(" %d", *i.ref->get);
+        c_FOREACH (i, cvec_Arc, vec) printf(" %d", *i.ref->get);
 
         printf("\nset:");
-        c_foreach (i, csset_Arc, set) printf(" %d", *i.ref->get);
+        c_FOREACH (i, csset_Arc, set) printf(" %d", *i.ref->get);
 
-        c_with (Arc p = Arc_clone(vec.data[0]), Arc_drop(&p)) {
+        c_WITH (Arc p = Arc_clone(vec.data[0]), Arc_drop(&p)) {
             printf("\n%d is now owned by %ld objects\n", *p.get, *p.use_count);
         }
 
diff --git a/misc/examples/arcvec_erase.c b/misc/examples/arcvec_erase.c
index c70d59d9..eb54084a 100644
--- a/misc/examples/arcvec_erase.c
+++ b/misc/examples/arcvec_erase.c
@@ -15,9 +15,9 @@ void show_drop(int* x) { printf("drop: %d\n", *x); }
 
 int main()
 {
-    c_auto (Vec, vec)
+    c_AUTO (Vec, vec)
     {
-        c_forlist (i, int, {2012, 1990, 2012, 2019, 2015})
+        c_FORLIST (i, int, {2012, 1990, 2012, 2019, 2015})
             Vec_emplace(&vec, *i.ref);
         
         // clone the second 2012 and push it back.
@@ -25,7 +25,7 @@ int main()
         Vec_push(&vec, Arc_clone(vec.data[2]));
         
         printf("vec before erase :");
-        c_foreach (i, Vec, vec)
+        c_FOREACH (i, Vec, vec)
             printf(" %d", *i.ref->get);
 
         printf("\nerase vec.data[2]; or first matching value depending on compare.\n");
@@ -40,12 +40,12 @@ int main()
             Vec_erase_at(&vec, it);
 
         printf("vec after erase  :");
-        c_foreach (i, Vec, vec)
+        c_FOREACH (i, Vec, vec)
             printf(" %d", *i.ref->get);
 
         Vec_sort(&vec);
         printf("\nvec after sort   :");
-        c_foreach (i, Vec, vec)
+        c_FOREACH (i, Vec, vec)
             printf(" %d", *i.ref->get);
         
         puts("\nDone");
diff --git a/misc/examples/astar.c b/misc/examples/astar.c
index d4a821f9..e308eb78 100644
--- a/misc/examples/astar.c
+++ b/misc/examples/astar.c
@@ -80,9 +80,9 @@ astar(cstr* maze, int width)
 {
     cdeq_point path = cdeq_point_init();
 
-    c_auto (cpque_point, front)
-    c_auto (csmap_pstep, from)
-    c_auto (csmap_pcost, costs)
+    c_AUTO (cpque_point, front)
+    c_AUTO (csmap_pstep, from)
+    c_AUTO (csmap_pcost, costs)
     {
         point start = point_from(maze, "@", width);
         point goal = point_from(maze, "!", width);
@@ -99,7 +99,7 @@ astar(cstr* maze, int width)
                 { -1,  0, 0, width }, /* ~ ~ ~ ~ ~ ~ ~ */  { 1,  0, 0, width },
                 { -1, -1, 0, width }, { 0, -1, 0, width }, { 1, -1, 0, width },
             };
-            for (size_t i = 0; i < c_arraylen(deltas); i++)
+            for (size_t i = 0; i < c_ARRAYLEN(deltas); i++)
             {
                 point delta = deltas[i];
                 point next = point_init(current.x + delta.x, current.y + delta.y, width);
@@ -131,7 +131,7 @@ astar(cstr* maze, int width)
 int
 main(void)
 {
-    c_with (cstr maze = cstr_lit(
+    c_WITH (cstr maze = cstr_lit(
         "#########################################################################\n"
         "#   #               #               #           #                   #   #\n"
         "#   #   #########   #   #####   #########   #####   #####   #####   # ! #\n"
@@ -157,9 +157,9 @@ main(void)
         "#########################################################################\n"), cstr_drop(&maze))
     {
         int width = cstr_find(&maze, "\n") + 1;
-        c_with (cdeq_point path = astar(&maze, width), cdeq_point_drop(&path))
+        c_WITH (cdeq_point path = astar(&maze, width), cdeq_point_drop(&path))
         {
-            c_foreach (it, cdeq_point, path) cstr_data(&maze)[point_index(it.ref)] = 'x';
+            c_FOREACH (it, cdeq_point, path) cstr_data(&maze)[point_index(it.ref)] = 'x';
             printf("%s", cstr_str(&maze));
         }
     }
diff --git a/misc/examples/birthday.c b/misc/examples/birthday.c
index 48b8ceaa..be7f0457 100644
--- a/misc/examples/birthday.c
+++ b/misc/examples/birthday.c
@@ -18,10 +18,10 @@ static void test_repeats(void)
 
     printf("birthday paradox: value range: 2^%d, testing repeats of 2^%d values\n", BITS, BITS_TEST);
     stc64_t rng = stc64_new(seed);
-    c_auto (cmap_ic, m)
+    c_AUTO (cmap_ic, m)
     {
         cmap_ic_reserve(&m, N);
-        c_forrange (i, N) {
+        c_FORRANGE (i, N) {
             uint64_t k = stc64_rand(&rng) & mask;
             int v = cmap_ic_insert(&m, k, 0).ref->second += 1;
             if (v > 1) printf("repeated value %" PRIu64 " (%d) at 2^%d\n",
@@ -42,17 +42,17 @@ void test_distribution(void)
     stc64_t rng = stc64_new(seed);
     const size_t N = 1ull << BITS ;
 
-    c_auto (cmap_x, map) {
-        c_forrange (N) {
+    c_AUTO (cmap_x, map) {
+        c_FORRANGE (N) {
             uint64_t k = stc64_rand(&rng);
             cmap_x_insert(&map, k & 0xf, 0).ref->second += 1;
         }
 
         uint64_t sum = 0;
-        c_foreach (i, cmap_x, map) sum += i.ref->second;
+        c_FOREACH (i, cmap_x, map) sum += i.ref->second;
         sum /= map.size;
 
-        c_foreach (i, cmap_x, map) {
+        c_FOREACH (i, cmap_x, map) {
             printf("%4" PRIu32 ": %" PRIu64 " - %" PRIu64 ": %11.8f\n",
                    i.ref->first, i.ref->second, sum,
                    (1 - (double)i.ref->second / sum));
diff --git a/misc/examples/bits.c b/misc/examples/bits.c
index 82fd65ec..c50eac6e 100644
--- a/misc/examples/bits.c
+++ b/misc/examples/bits.c
@@ -3,7 +3,7 @@
 
 int main() 
 {
-    c_with (cbits set = cbits_with_size(23, true), cbits_drop(&set)) {
+    c_WITH (cbits set = cbits_with_size(23, true), cbits_drop(&set)) {
         printf("count %" c_ZU ", %" c_ZU "\n", cbits_count(&set), cbits_size(&set));
         cbits s1 = cbits_from("1110100110111");
         char buf[256];
@@ -16,7 +16,7 @@ int main()
         printf(" str: %s\n", cbits_to_str(&set, buf, 0, 255));
 
         printf("%4" c_ZU ": ", cbits_size(&set));
-        c_forrange (i, cbits_size(&set))
+        c_FORRANGE (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
         puts("");
 
@@ -26,34 +26,34 @@ int main()
         cbits_resize(&set, 102, true);
         cbits_set_value(&set, 99, false);
         printf("%4" c_ZU ": ", cbits_size(&set));
-        c_forrange (i, cbits_size(&set))
+        c_FORRANGE (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
 
         puts("\nIterate:");
         printf("%4" c_ZU ": ", cbits_size(&set));
-        c_forrange (i, cbits_size(&set))
+        c_FORRANGE (i, cbits_size(&set))
             printf("%d", cbits_test(&set, i));
         puts("");
 
-        c_with (cbits s2 = cbits_clone(set), cbits_drop(&s2)) {
+        c_WITH (cbits s2 = cbits_clone(set), cbits_drop(&s2)) {
             cbits_flip_all(&s2);
             cbits_set(&s2, 16);
             cbits_set(&s2, 17);
             cbits_set(&s2, 18);
             printf(" new: ");
-            c_forrange (i, cbits_size(&s2))
+            c_FORRANGE (i, cbits_size(&s2))
                 printf("%d", cbits_test(&s2, i));
             puts("");
 
             printf(" xor: ");
             cbits_xor(&set, &s2);
-            c_forrange (i, cbits_size(&set))
+            c_FORRANGE (i, cbits_size(&set))
                 printf("%d", cbits_test(&set, i));
             puts("");
 
             cbits_set_all(&set, false);
             printf("%4" c_ZU ": ", cbits_size(&set));
-            c_forrange (i, cbits_size(&set))
+            c_FORRANGE (i, cbits_size(&set))
                 printf("%d", cbits_test(&set, i));
             puts("");
         }
diff --git a/misc/examples/bits2.c b/misc/examples/bits2.c
index 59e0b337..502e7268 100644
--- a/misc/examples/bits2.c
+++ b/misc/examples/bits2.c
@@ -23,19 +23,19 @@ int main()
     Bits_reset(&s2, 66);
     Bits_reset(&s2, 67);
     printf(" s2: ");
-    c_forrange (i, Bits_size(&s2))
+    c_FORRANGE (i, Bits_size(&s2))
         printf("%d", Bits_test(&s2, i));
     puts("");
 
     printf("xor: ");
     Bits_xor(&s1, &s2);
-    c_forrange (i, Bits_size(&s1))
+    c_FORRANGE (i, Bits_size(&s1))
         printf("%d", Bits_test(&s1, i));
     puts("");
 
     printf("all: ");
     Bits_set_pattern(&s1, 0x3333333333333333);
-    c_forrange (i, Bits_size(&s1))
+    c_FORRANGE (i, Bits_size(&s1))
         printf("%d", Bits_test(&s1, i));
     puts("");
 }
diff --git a/misc/examples/books.c b/misc/examples/books.c
index b6067d81..96c7ff6e 100644
--- a/misc/examples/books.c
+++ b/misc/examples/books.c
@@ -8,7 +8,7 @@
 // would be `HashMap<String, String>` in this example).
 int main()
 {
-    c_auto (cmap_str, book_reviews)
+    c_AUTO (cmap_str, book_reviews)
     {
         // Review some books.
         cmap_str_emplace(&book_reviews,
@@ -41,7 +41,7 @@ int main()
 
         // Look up the values associated with some keys.
         const char* to_find[] = {"Pride and Prejudice", "Alice's Adventure in Wonderland"};
-        c_forrange (i, c_arraylen(to_find)) {
+        c_FORRANGE (i, c_ARRAYLEN(to_find)) {
             const cmap_str_value* b = cmap_str_get(&book_reviews, to_find[i]);
             if (b)
                 printf("%s: %s\n", cstr_str(&b->first), cstr_str(&b->second));
@@ -53,7 +53,7 @@ int main()
         printf("Review for Jane: %s\n", cstr_str(cmap_str_at(&book_reviews, "Pride and Prejudice")));
 
         // Iterate over everything.
-        c_forpair (book, review, cmap_str, book_reviews) {
+        c_FORPAIR (book, review, cmap_str, book_reviews) {
             printf("%s: \"%s\"\n", cstr_str(_.book), cstr_str(_.review));
         }
     }
diff --git a/misc/examples/box.c b/misc/examples/box.c
index da13501f..446a7603 100644
--- a/misc/examples/box.c
+++ b/misc/examples/box.c
@@ -24,7 +24,7 @@ Person Person_clone(Person p) {
 
 void Person_drop(Person* p) {
     printf("drop: %s %s\n", cstr_str(&p->name), cstr_str(&p->last));
-    c_drop(cstr, &p->name, &p->last);
+    c_DROP(cstr, &p->name, &p->last);
 }
 
 #define i_type PBox
@@ -37,8 +37,8 @@ void Person_drop(Person* p) {
 
 int main()
 {
-    c_auto (Persons, vec)
-    c_auto (PBox, p, q)
+    c_AUTO (Persons, vec)
+    c_AUTO (PBox, p, q)
     {
         p = PBox_from(Person_make("Laura", "Palmer"));
         q = PBox_clone(p);
@@ -54,12 +54,12 @@ int main()
         Persons_push(&vec, PBox_clone(p));
         Persons_push(&vec, PBox_clone(q));
 
-        c_foreach (i, Persons, vec)
+        c_FOREACH (i, Persons, vec)
             printf("%s %s\n", cstr_str(&i.ref->get->name), cstr_str(&i.ref->get->last));
         puts("");
 
         // Look-up Audrey! Create a temporary Person for lookup.
-        c_with (Person a = Person_make("Audrey", "Home"), Person_drop(&a)) {
+        c_WITH (Person a = Person_make("Audrey", "Home"), Person_drop(&a)) {
             const PBox *v = Persons_get(&vec, a); // lookup
             if (v) printf("found: %s %s\n", cstr_str(&v->get->name), cstr_str(&v->get->last));
         }
diff --git a/misc/examples/box2.c b/misc/examples/box2.c
index b9628eeb..6281f800 100644
--- a/misc/examples/box2.c
+++ b/misc/examples/box2.c
@@ -51,9 +51,9 @@ int main(void) {
     };
 
     // Declare auto-deleted box objects
-    c_auto (cbox_Rectangle, boxed_rectangle)
-    c_auto (cbox_Point, boxed_point)
-    c_auto (cbox_BoxPoint, box_in_a_box, boxbox2)
+    c_AUTO (cbox_Rectangle, boxed_rectangle)
+    c_AUTO (cbox_Point, boxed_point)
+    c_AUTO (cbox_BoxPoint, box_in_a_box, boxbox2)
     {
         // Heap allocated rectangle
         boxed_rectangle = cbox_Rectangle_make((Rectangle){
diff --git a/misc/examples/city.c b/misc/examples/city.c
index 8557c6cf..7f355bdf 100644
--- a/misc/examples/city.c
+++ b/misc/examples/city.c
@@ -44,16 +44,16 @@ City City_clone(City c) {
 
 void City_drop(City* c) {
     printf("drop %s\n", cstr_str(&c->name));
-    c_drop(cstr, &c->name, &c->country);
+    c_DROP(cstr, &c->name, &c->country);
 }
 
 
 int main(void)
 {
-    c_auto (Cities, cities, copy)
-    c_auto (CityMap, map)
+    c_AUTO (Cities, cities, copy)
+    c_AUTO (CityMap, map)
     {
-        c_forlist (i, City, {
+        c_FORLIST (i, City, {
             {cstr_lit("New York"), cstr_lit("US"), 4.3f, 23.2f, 9000000},
             {cstr_lit("Paris"), cstr_lit("France"), 4.3f, 23.2f, 9000000},
             {cstr_lit("Berlin"), cstr_lit("Germany"), 4.3f, 23.2f, 9000000},
@@ -63,7 +63,7 @@ int main(void)
         Cities_sort(&cities);
 
         printf("Vec:\n");
-        c_foreach (c, Cities, cities)
+        c_FOREACH (c, Cities, cities)
             printf("city:%s, %d, use:%ld\n", cstr_str(&c.ref->get->name),
                                              c.ref->get->population,
                                              CityArc_use_count(c.ref));
@@ -71,19 +71,19 @@ int main(void)
         copy = Cities_clone(cities); // share each element!
 
         int k = 0, id[] = {8, 4, 3, 9, 2, 5};
-        c_foreach (i, Cities, cities)
+        c_FOREACH (i, Cities, cities)
             CityMap_insert(&map, id[k++], CityArc_clone(*i.ref));
 
         Cities_pop(&cities);
         Cities_pop(&cities);
 
         printf("Vec:\n");
-        c_foreach (c, Cities, cities)
+        c_FOREACH (c, Cities, cities)
             printf("city:%s, %d, use:%ld\n", cstr_str(&c.ref->get->name),
                                              c.ref->get->population,
                                              CityArc_use_count(c.ref));
         printf("\nMap:\n");
-        c_forpair (id, city, CityMap, map)
+        c_FORPAIR (id, city, CityMap, map)
             printf("id:%d, city:%s, %d, use:%ld\n", *_.id, cstr_str(&_.city->get->name),
                                                      _.city->get->population, CityArc_use_count(_.city));
         puts("");
diff --git a/misc/examples/complex.c b/misc/examples/complex.c
index dd2f951a..6fed1d4d 100644
--- a/misc/examples/complex.c
+++ b/misc/examples/complex.c
@@ -31,7 +31,7 @@
 
 int main()
 {
-    c_auto (MapMap, mmap)
+    c_AUTO (MapMap, mmap)
     {
         FloatStack stack = FloatStack_with_size(10, 0);
 
diff --git a/misc/examples/convert.c b/misc/examples/convert.c
index 18be3c81..f2324268 100644
--- a/misc/examples/convert.c
+++ b/misc/examples/convert.c
@@ -13,38 +13,38 @@
 
 int main()
 {
-    c_auto (cmap_str, map, mclone)
-    c_auto (cvec_str, keys, values)
-    c_auto (clist_str, list)
+    c_AUTO (cmap_str, map, mclone)
+    c_AUTO (cvec_str, keys, values)
+    c_AUTO (clist_str, list)
     {
-        c_forlist (i, cmap_str_raw, {
+        c_FORLIST (i, cmap_str_raw, {
             {"green", "#00ff00"},
             {"blue", "#0000ff"},
             {"yellow", "#ffff00"},
         }) cmap_str_emplace(&map, c_PAIR(i.ref));
 
         puts("MAP:");
-        c_foreach (i, cmap_str, map)
+        c_FOREACH (i, cmap_str, map)
             printf("  %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
 
         puts("\nCLONE MAP:");
         mclone = cmap_str_clone(map);
-        c_foreach (i, cmap_str, mclone)
+        c_FOREACH (i, cmap_str, mclone)
             printf("  %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
 
         puts("\nCOPY MAP TO VECS:");
-        c_foreach (i, cmap_str, mclone) {
+        c_FOREACH (i, cmap_str, mclone) {
             cvec_str_emplace_back(&keys, cstr_str(&i.ref->first));
             cvec_str_emplace_back(&values, cstr_str(&i.ref->second));
         }
-        c_forrange (i, cvec_str_size(&keys))
+        c_FORRANGE (i, cvec_str_size(&keys))
             printf("  %s: %s\n", cstr_str(keys.data + i), cstr_str(values.data + i));
 
         puts("\nCOPY VEC TO LIST:");
-        c_foreach (i, cvec_str, keys)
+        c_FOREACH (i, cvec_str, keys)
             clist_str_emplace_back(&list, cstr_str(i.ref));
 
-        c_foreach (i, clist_str, list)
+        c_FOREACH (i, clist_str, list)
             printf("  %s\n", cstr_str(i.ref));
     }
 }
diff --git a/misc/examples/cpque.c b/misc/examples/cpque.c
index 7254b0f7..47080038 100644
--- a/misc/examples/cpque.c
+++ b/misc/examples/cpque.c
@@ -24,12 +24,12 @@ struct {
 #define i_type ipque
 #define i_val int
 #define i_opt c_is_forward // needed to avoid re-type-define container type
-#define i_less_functor(self, x, y) c_container_of(self, IPQueue, Q)->less(x, y) // <== This.
+#define i_less_functor(self, x, y) c_CONTAINER_OF(self, IPQueue, Q)->less(x, y) // <== This.
 #include <stc/cpque.h>
 
 #define print(name, q, n) do { \
     printf("%s: \t", name); \
-    c_forrange (i, n) printf("%d ", q[i]); \
+    c_FORRANGE (i, n) printf("%d ", q[i]); \
     puts(""); \
 } while(0)
 
@@ -50,22 +50,22 @@ static bool int_lambda(const int* x, const int* y) { return (*x ^ 1) < (*y ^ 1);
 
 int main()
 {
-    const int data[] = {1,8,5,6,3,4,0,9,7,2}, n = c_arraylen(data);
+    const int data[] = {1,8,5,6,3,4,0,9,7,2}, n = c_ARRAYLEN(data);
     print("data", data, n);
 
-    c_autodrop (IPQueue, q1, {ipque_init(), int_less})   // Max priority queue
-    c_autodrop (IPQueue, minq1, {ipque_init(), int_greater}) // Min priority queue
-    c_autodrop (IPQueue, q5, {ipque_init(), int_lambda}) // Using lambda to compare elements.
+    c_AUTODROP (IPQueue, q1, {ipque_init(), int_less})   // Max priority queue
+    c_AUTODROP (IPQueue, minq1, {ipque_init(), int_greater}) // Min priority queue
+    c_AUTODROP (IPQueue, q5, {ipque_init(), int_lambda}) // Using lambda to compare elements.
     {
-        c_forrange (i, n)
+        c_FORRANGE (i, n)
             ipque_push(&q1.Q, data[i]);
         print_queue("q1", q1);
 
-        c_forrange (i, n)
+        c_FORRANGE (i, n)
             ipque_push(&minq1.Q, data[i]);
         print_queue("minq1", minq1);
 
-        c_forrange (i, n)
+        c_FORRANGE (i, n)
             ipque_push(&q5.Q, data[i]);
         print_queue("q5", q5);
     }
diff --git a/misc/examples/csmap_erase.c b/misc/examples/csmap_erase.c
index 48d8ceef..bef00a17 100644
--- a/misc/examples/csmap_erase.c
+++ b/misc/examples/csmap_erase.c
@@ -10,14 +10,14 @@
 
 void printmap(mymap m)
 {
-    c_foreach (elem, mymap, m)
+    c_FOREACH (elem, mymap, m)
         printf(" [%d, %s]", elem.ref->first, cstr_str(&elem.ref->second));
     printf("\nsize() == %" c_ZU "\n\n", mymap_size(&m));
 }
 
 int main()
 {
-    c_auto (mymap, m1)
+    c_AUTO (mymap, m1)
     {
         // Fill in some data to test with, one at a time
         mymap_insert(&m1, 1, cstr_lit("A"));
@@ -34,10 +34,10 @@ int main()
         printmap(m1);
     }
 
-    c_auto (mymap, m2)
+    c_AUTO (mymap, m2)
     {
         // Fill in some data to test with, one at a time
-        c_forlist (i, mymap_raw, {
+        c_FORLIST (i, mymap_raw, {
             {10, "Bob"},
             {11, "Rob"},
             {12, "Robert"},
@@ -51,7 +51,7 @@ int main()
         mymap_iter it2 = mymap_find(&m2, mymap_back(&m2)->first);
 
         puts("to remove:");
-        c_foreach (i, mymap, it1, it2)
+        c_FOREACH (i, mymap, it1, it2)
             printf(" [%d, %s]", i.ref->first, cstr_str(&i.ref->second));
         puts("");
         // The 2nd member function removes elements
@@ -61,7 +61,7 @@ int main()
         printmap(m2);
     }
 
-    c_auto (mymap, m3)
+    c_AUTO (mymap, m3)
     {
         // Fill in some data to test with, one at a time, using emplace
         mymap_emplace(&m3, 1, "red");
diff --git a/misc/examples/csmap_find.c b/misc/examples/csmap_find.c
index 3c507476..a61a47be 100644
--- a/misc/examples/csmap_find.c
+++ b/misc/examples/csmap_find.c
@@ -20,7 +20,7 @@ void print_elem(csmap_istr_raw p) {
     void print_collection_##CX(const CX* t) { \
         printf("%" c_ZU " elements: ", CX##_size(t)); \
     \
-        c_foreach (p, CX, *t) { \
+        c_FOREACH (p, CX, *t) { \
             print_elem(CX##_value_toraw(p.ref)); \
         } \
         puts(""); \
@@ -42,10 +42,10 @@ void findit(csmap_istr c, csmap_istr_key val)
 
 int main()
 {
-    c_auto (csmap_istr, m1)
-    c_auto (cvec_istr, v)
+    c_AUTO (csmap_istr, m1)
+    c_AUTO (cvec_istr, v)
     {
-        c_forlist (i, csmap_istr_raw, {{40, "Zr"}, {45, "Rh"}})
+        c_FORLIST (i, csmap_istr_raw, {{40, "Zr"}, {45, "Rh"}})
             csmap_istr_emplace(&m1, c_PAIR(i.ref));
 
         puts("The starting map m1 is (key, value):");
@@ -62,7 +62,7 @@ int main()
         puts("Inserting the following vector data into m1:");
         print_collection_cvec_istr(&v);
 
-        c_foreach (i, cvec_istr, cvec_istr_begin(&v), cvec_istr_end(&v))
+        c_FOREACH (i, cvec_istr, cvec_istr_begin(&v), cvec_istr_end(&v))
             csmap_istr_emplace(&m1, c_PAIR(i.ref));
 
         puts("The modified map m1 is (key, value):");
diff --git a/misc/examples/csmap_insert.c b/misc/examples/csmap_insert.c
index 8f777fc6..b1b0a5be 100644
--- a/misc/examples/csmap_insert.c
+++ b/misc/examples/csmap_insert.c
@@ -19,13 +19,13 @@
 #include <stc/cvec.h>
 
 void print_ii(csmap_ii map) {
-    c_foreach (e, csmap_ii, map)
+    c_FOREACH (e, csmap_ii, map)
         printf("(%d, %d) ", e.ref->first, e.ref->second);
     puts("");
 }
 
 void print_istr(csmap_istr map) {
-    c_foreach (e, csmap_istr, map)
+    c_FOREACH (e, csmap_istr, map)
         printf("(%d, %s) ", e.ref->first, cstr_str(&e.ref->second));
     puts("");
 }
@@ -33,7 +33,7 @@ void print_istr(csmap_istr map) {
 int main()
 {
     // insert single values
-    c_auto (csmap_ii, m1) {
+    c_AUTO (csmap_ii, m1) {
         csmap_ii_insert(&m1, 1, 10);
         csmap_ii_insert(&m1, 2, 20);
 
@@ -60,8 +60,8 @@ int main()
     }
 
     // The templatized version inserting a jumbled range
-    c_auto (csmap_ii, m2)
-    c_auto (cvec_ii, v) {
+    c_AUTO (csmap_ii, m2)
+    c_AUTO (cvec_ii, v) {
         typedef cvec_ii_value ipair;
         cvec_ii_push(&v, (ipair){43, 294});
         cvec_ii_push(&v, (ipair){41, 262});
@@ -70,21 +70,21 @@ int main()
         cvec_ii_push(&v, (ipair){44, 311});
 
         puts("Inserting the following vector data into m2:");
-        c_foreach (e, cvec_ii, v)
+        c_FOREACH (e, cvec_ii, v)
             printf("(%d, %d) ", e.ref->first, e.ref->second);
         puts("");
 
-        c_foreach (e, cvec_ii, v) 
+        c_FOREACH (e, cvec_ii, v) 
             csmap_ii_insert_or_assign(&m2, e.ref->first, e.ref->second);
 
         puts("The modified key and mapped values of m2 are:");
-        c_foreach (e, csmap_ii, m2)
+        c_FOREACH (e, csmap_ii, m2)
             printf("(%d, %d) ", e.ref->first, e.ref->second);
         puts("\n");
     }
 
     // The templatized versions move-constructing elements
-    c_auto (csmap_istr, m3) {
+    c_AUTO (csmap_istr, m3) {
         csmap_istr_value ip1 = {475, cstr_lit("blue")}, ip2 = {510, cstr_lit("green")};
 
         // single element
@@ -99,9 +99,9 @@ int main()
         puts("");
     }
 
-    c_auto (csmap_ii, m4) {
+    c_AUTO (csmap_ii, m4) {
         // Insert the elements from an initializer_list
-        c_forlist (i, csmap_ii_raw, {{ 4, 44 }, { 2, 22 }, { 3, 33 },
+        c_FORLIST (i, csmap_ii_raw, {{ 4, 44 }, { 2, 22 }, { 3, 33 },
                                      { 1, 11 }, { 5, 55 }})
             csmap_ii_insert(&m4, c_PAIR(i.ref));
 
diff --git a/misc/examples/csset_erase.c b/misc/examples/csset_erase.c
index 33eb2163..c281c626 100644
--- a/misc/examples/csset_erase.c
+++ b/misc/examples/csset_erase.c
@@ -5,12 +5,12 @@
 
 int main()
 {
-    c_auto (csset_int, set)
+    c_AUTO (csset_int, set)
     {
-        c_forlist (i, int, {30, 20, 80, 40, 60, 90, 10, 70, 50})
+        c_FORLIST (i, int, {30, 20, 80, 40, 60, 90, 10, 70, 50})
             csset_int_insert(&set, *i.ref);
 
-        c_foreach (k, csset_int, set)
+        c_FOREACH (k, csset_int, set)
             printf(" %d", *k.ref);
         puts("");
 
@@ -19,7 +19,7 @@ int main()
         printf("Show values >= %d:\n", val);
         it = csset_int_lower_bound(&set, val);
 
-        c_foreach (k, csset_int, it, csset_int_end(&set)) 
+        c_FOREACH (k, csset_int, it, csset_int_end(&set)) 
             printf(" %d", *k.ref);
         puts("");
 
@@ -27,7 +27,7 @@ int main()
         while (it.ref != csset_int_end(&set).ref)
             it = csset_int_erase_at(&set, it);
 
-        c_foreach (k, csset_int, set)
+        c_FOREACH (k, csset_int, set)
             printf(" %d", *k.ref);
         puts("");
 
@@ -36,7 +36,7 @@ int main()
         it = csset_int_lower_bound(&set, val);
         csset_int_erase_range(&set, csset_int_begin(&set), it);
 
-        c_foreach (k, csset_int, set)
+        c_FOREACH (k, csset_int, set)
             printf(" %d", *k.ref);
         puts("");
     }
diff --git a/misc/examples/cstr_match.c b/misc/examples/cstr_match.c
index 286ba505..116e5dd4 100644
--- a/misc/examples/cstr_match.c
+++ b/misc/examples/cstr_match.c
@@ -4,7 +4,7 @@
 
 int main()
 {
-    c_with (cstr ss = cstr_lit("The quick brown fox jumps over the lazy dog.JPG"), cstr_drop(&ss)) {
+    c_WITH (cstr ss = cstr_lit("The quick brown fox jumps over the lazy dog.JPG"), cstr_drop(&ss)) {
         size_t pos = cstr_find_at(&ss, 0, "brown");
         printf("%" c_ZU " [%s]\n", pos, pos == c_NPOS ? "<NULL>" : cstr_str(&ss) + pos);
         printf("equals: %d\n", cstr_equals(&ss, "The quick brown fox jumps over the lazy dog.JPG"));
diff --git a/misc/examples/demos.c b/misc/examples/demos.c
index fc3771cb..b077aa73 100644
--- a/misc/examples/demos.c
+++ b/misc/examples/demos.c
@@ -3,7 +3,7 @@
 void stringdemo1()
 {
     printf("\nSTRINGDEMO1\n");
-    c_with (cstr cs = cstr_lit("one-nine-three-seven-five"), cstr_drop(&cs))
+    c_WITH (cstr cs = cstr_lit("one-nine-three-seven-five"), cstr_drop(&cs))
     {
         printf("%s.\n", cstr_str(&cs));
 
@@ -35,7 +35,7 @@ void stringdemo1()
 void vectordemo1()
 {
     printf("\nVECTORDEMO1\n");
-    c_with (cvec_ix bignums = cvec_ix_with_capacity(100), cvec_ix_drop(&bignums))
+    c_WITH (cvec_ix bignums = cvec_ix_with_capacity(100), cvec_ix_drop(&bignums))
     {
         cvec_ix_reserve(&bignums, 100);
         for (size_t i = 10; i <= 100; i += 10)
@@ -59,7 +59,7 @@ void vectordemo1()
 void vectordemo2()
 {
     printf("\nVECTORDEMO2\n");
-    c_auto (cvec_str, names) {
+    c_AUTO (cvec_str, names) {
         cvec_str_emplace_back(&names, "Mary");
         cvec_str_emplace_back(&names, "Joe");
         cvec_str_emplace_back(&names, "Chris");
@@ -67,7 +67,7 @@ void vectordemo2()
         printf("names[1]: %s\n", cstr_str(&names.data[1]));
 
         cvec_str_sort(&names);                     // Sort the array
-        c_foreach (i, cvec_str, names)
+        c_FOREACH (i, cvec_str, names)
             printf("sorted: %s\n", cstr_str(i.ref));
     }
 }
@@ -80,7 +80,7 @@ void vectordemo2()
 void listdemo1()
 {
     printf("\nLISTDEMO1\n");
-    c_auto (clist_ix, nums, nums2)
+    c_AUTO (clist_ix, nums, nums2)
     {
         for (int i = 0; i < 10; ++i)
             clist_ix_push_back(&nums, i);
@@ -89,7 +89,7 @@ void listdemo1()
 
         /* splice nums2 to front of nums */
         clist_ix_splice(&nums, clist_ix_begin(&nums), &nums2);
-        c_foreach (i, clist_ix, nums)
+        c_FOREACH (i, clist_ix, nums)
             printf("spliced: %d\n", *i.ref);
         puts("");
 
@@ -101,7 +101,7 @@ void listdemo1()
         clist_ix_push_back(&nums, -99);
         clist_ix_sort(&nums);
 
-        c_foreach (i, clist_ix, nums)
+        c_FOREACH (i, clist_ix, nums)
             printf("sorted: %d\n", *i.ref);
     }
 }
@@ -117,7 +117,7 @@ void setdemo1()
     cset_i_insert(&nums, 8);
     cset_i_insert(&nums, 11);
 
-    c_foreach (i, cset_i, nums)
+    c_FOREACH (i, cset_i, nums)
         printf("set: %d\n", *i.ref);
     cset_i_drop(&nums);
 }
@@ -145,7 +145,7 @@ void mapdemo1()
 void mapdemo2()
 {
     printf("\nMAPDEMO2\n");
-    c_auto (cmap_si, nums)
+    c_AUTO (cmap_si, nums)
     {
         cmap_si_emplace_or_assign(&nums, "Hello", 64);
         cmap_si_emplace_or_assign(&nums, "Groovy", 121);
@@ -156,7 +156,7 @@ void mapdemo2()
             printf("long: %s: %d\n", cstr_str(&i.ref->first), i.ref->second);
 
         // or rather use the short form:
-        c_foreach (i, cmap_si, nums)
+        c_FOREACH (i, cmap_si, nums)
             printf("short: %s: %d\n", cstr_str(&i.ref->first), i.ref->second);
     }
 }
@@ -173,14 +173,14 @@ void mapdemo3()
     cmap_str_emplace(&table, "Make", "my");
     cmap_str_emplace(&table, "Sunny", "day");
     cmap_str_iter it = cmap_str_find(&table, "Make");
-    c_foreach (i, cmap_str, table)
+    c_FOREACH (i, cmap_str, table)
         printf("entry: %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
     printf("size %" c_ZU ": remove: Make: %s\n", cmap_str_size(&table), cstr_str(&it.ref->second));
     //cmap_str_erase(&table, "Make");
     cmap_str_erase_at(&table, it);
 
     printf("size %" c_ZU "\n", cmap_str_size(&table));
-    c_foreach (i, cmap_str, table)
+    c_FOREACH (i, cmap_str, table)
         printf("entry: %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
     cmap_str_drop(&table); // frees key and value cstrs, and hash table.
 }
@@ -192,7 +192,7 @@ void mapdemo3()
 void arraydemo1()
 {
     printf("\nARRAYDEMO1\n");
-    c_with (carr3_f arr3 = carr3_f_with_size(30, 20, 10, 0.0f), 
+    c_WITH (carr3_f arr3 = carr3_f_with_size(30, 20, 10, 0.0f), 
                            carr3_f_drop(&arr3))
     {
         arr3.data[5][4][3] = 10.2f;
@@ -207,7 +207,7 @@ void arraydemo1()
         printf("%g\n", arr3.data[5][4][3]); // = 10.2
 
         float x = 0.0;
-        c_foreach (i, carr3_f, arr3)
+        c_FOREACH (i, carr3_f, arr3)
             *i.ref = ++x;
         printf("%g\n", arr3.data[29][19][9]); // = 6000
     }
diff --git a/misc/examples/forfilter.c b/misc/examples/forfilter.c
index ba4dce7f..32154904 100644
--- a/misc/examples/forfilter.c
+++ b/misc/examples/forfilter.c
@@ -20,23 +20,23 @@
 
 void demo1(void)
 {
-    c_auto (IVec, vec) {
-        c_forlist (i, int, {0, 1, 2, 3, 4, 5, 80, 6, 7, 80, 8, 9, 80, 10, 11, 12, 13, 14, 15, 80, 16, 17})
+    c_AUTO (IVec, vec) {
+        c_FORLIST (i, int, {0, 1, 2, 3, 4, 5, 80, 6, 7, 80, 8, 9, 80, 10, 11, 12, 13, 14, 15, 80, 16, 17})
             IVec_push(&vec, *i.ref);
 
         puts("demo1:");
-        c_forfilter (i, IVec, vec, flt_skipValue(i, 80))
+        c_FORFILTER (i, IVec, vec, flt_skipValue(i, 80))
             printf(" %d", *i.ref);
         puts("");
 
         int res, sum = 0;
-        c_forfilter (i, IVec, vec
-                      , c_flt_skipwhile(i, *i.ref != 80)
-                     && c_flt_skip(i, 1)
-                     && c_flt_skipwhile(i, *i.ref != 80)
+        c_FORFILTER (i, IVec, vec
+                      , c_FLT_SKIPWHILE(i, *i.ref != 80)
+                     && c_FLT_SKIP(i, 1)
+                     && c_FLT_SKIPWHILE(i, *i.ref != 80)
                      &&   flt_isEven(i)
                      &&   flt_skipValue(i, 80)
-                      , c_flt_take(i, 5) // short-circuit
+                      , c_FLT_TAKE(i, 5) // short-circuit
         ){
             sum += res = flt_square(i);
             printf(" %d", res);
@@ -60,15 +60,15 @@ fn main() {
 
 void demo2(void)
 {
-    c_auto (IVec, vector) {
+    c_AUTO (IVec, vector) {
         puts("demo2:");
 
-        c_forfilter (x, crange, crange_literal(INT64_MAX)
-                      , c_flt_skipwhile(x, *x.ref != 11)
+        c_FORFILTER (x, crange, crange_literal(INT64_MAX)
+                      , c_FLT_SKIPWHILE(x, *x.ref != 11)
                      && *x.ref % 2 != 0
-                      , c_flt_take(x, 5))
+                      , c_FLT_TAKE(x, 5))
             IVec_push(&vector, *x.ref * *x.ref);
-        c_foreach (x, IVec, vector) printf(" %d", *x.ref);
+        c_FOREACH (x, IVec, vector) printf(" %d", *x.ref);
         puts("");
     }
 }
@@ -88,17 +88,17 @@ fn main() {
 */
 void demo3(void)
 {
-    c_auto (SVec, words, words_containing_i) {
+    c_AUTO (SVec, words, words_containing_i) {
         const char* sentence = "This is a sentence in C99.";
-        c_fortoken (w, sentence, " ")
+        c_FORTOKEN (w, sentence, " ")
             SVec_push(&words, *w.ref);
 
-        c_forfilter (w, SVec, words, 
+        c_FORFILTER (w, SVec, words, 
                      csview_contains(*w.ref, "i"))
             SVec_push(&words_containing_i, *w.ref);
 
         puts("demo3:");
-        c_foreach (w, SVec, words_containing_i)
+        c_FOREACH (w, SVec, words_containing_i)
             printf(" %.*s", c_ARGSV(*w.ref));
         puts("");
     }
@@ -107,8 +107,8 @@ void demo3(void)
 void demo4(void)
 {
     csview s = c_SV("ab123cReAghNGnΩoEp"); // Ω = multi-byte
-    c_auto (cstr, out) {
-        c_forfilter (i, csview, s, utf8_isupper(utf8_peek(i.ref))) {
+    c_AUTO (cstr, out) {
+        c_FORFILTER (i, csview, s, utf8_isupper(utf8_peek(i.ref))) {
             char chr[4];
             utf8_encode(chr, utf8_tolower(utf8_peek(i.ref)));
             cstr_push(&out, chr);
@@ -124,12 +124,12 @@ void demo5(void)
     #define flt_mid_decade(i) ((*i.ref % 10) != 0)
     puts("demo5:");
     crange r1 = crange_make(1963, INT32_MAX);
-    c_forfilter (i, crange, r1
-                  , c_flt_skip(i,15)
-                 && c_flt_skipwhile(i, flt_mid_decade(i))
-                 && c_flt_skip(i,30)
+    c_FORFILTER (i, crange, r1
+                  , c_FLT_SKIP(i,15)
+                 && c_FLT_SKIPWHILE(i, flt_mid_decade(i))
+                 && c_FLT_SKIP(i,30)
                  &&   flt_even(i)
-                  , c_flt_take(i,10))
+                  , c_FLT_TAKE(i,10))
         printf(" %lld", *i.ref);
     puts("");
 }
diff --git a/misc/examples/forloops.c b/misc/examples/forloops.c
index 2654f095..95a955a3 100644
--- a/misc/examples/forloops.c
+++ b/misc/examples/forloops.c
@@ -13,67 +13,67 @@
 

 int main()

 {

-    puts("c_forrange:");

-    c_forrange (30) printf(" xx");

+    puts("c_FORRANGE:");

+    c_FORRANGE (30) printf(" xx");

     puts("");

 

-    c_forrange (i, 30) printf(" %lld", i);

+    c_FORRANGE (i, 30) printf(" %lld", i);

     puts("");

 

-    c_forrange (i, 30, 60) printf(" %lld", i);

+    c_FORRANGE (i, 30, 60) printf(" %lld", i);

     puts("");

 

-    c_forrange (i, 30, 90, 2) printf(" %lld", i);

+    c_FORRANGE (i, 30, 90, 2) printf(" %lld", i);

 

 

     puts("\n\nc_forlist:");

-    c_forlist (i, int, {12, 23, 453, 65, 676})

+    c_FORLIST (i, int, {12, 23, 453, 65, 676})

         printf(" %d", *i.ref);

     puts("");

 

-    c_forlist (i, const char*, {"12", "23", "453", "65", "676"})

+    c_FORLIST (i, const char*, {"12", "23", "453", "65", "676"})

         printf(" %s", *i.ref);

     puts("");

 

-    c_forlist (i, const char*, {"12", "23", "453", "65", "676"})

+    c_FORLIST (i, const char*, {"12", "23", "453", "65", "676"})

         printf(" %s", i.data[i.size - 1 - i.index]);

 

 

-    c_auto (IVec, vec) 

-    c_auto (IMap, map)

+    c_AUTO (IVec, vec) 

+    c_AUTO (IMap, map)

     {

-        c_forlist (i, int, {12, 23, 453, 65, 113, 215, 676, 34, 67, 20, 27, 66, 189, 45, 280, 199})

+        c_FORLIST (i, int, {12, 23, 453, 65, 113, 215, 676, 34, 67, 20, 27, 66, 189, 45, 280, 199})

             IVec_push(&vec, *i.ref);

 

-        c_forlist (i, IMap_value, {{12, 23}, {453, 65}, {676, 123}, {34, 67}})

+        c_FORLIST (i, IMap_value, {{12, 23}, {453, 65}, {676, 123}, {34, 67}})

             IMap_push(&map, *i.ref);

 

         puts("\n\nc_foreach:");

-        c_foreach (i, IVec, vec)

+        c_FOREACH (i, IVec, vec)

             printf(" %d", *i.ref);

         puts("");

 

-        c_foreach (i, IMap, map)

+        c_FOREACH (i, IMap, map)

             printf(" (%d %d)", i.ref->first, i.ref->second);

 

         puts("\n\nc_forpair:");

-        c_forpair (key, val, IMap, map)

+        c_FORPAIR (key, val, IMap, map)

             printf(" (%d %d)", *_.key, *_.val);

 

         puts("\n\nc_forwhile:");

-        c_forwhile (i, IVec, IVec_begin(&vec), i.index < 3)

+        c_FORWHILE (i, IVec, IVec_begin(&vec), i.index < 3)

             printf(" %d", *i.ref);

 

         #define isOdd(i) (*i.ref & 1)

 

         puts("\n\nc_forfilter:");

-        c_forfilter (i, IVec, vec

-                      , c_flt_skipwhile(i, *i.ref != 65)

-                     && c_flt_takewhile(i, *i.ref != 280)

-                     && c_flt_skipwhile(i, isOdd(i))

+        c_FORFILTER (i, IVec, vec

+                      , c_FLT_SKIPWHILE(i, *i.ref != 65)

+                     && c_FLT_TAKEWHILE(i, *i.ref != 280)

+                     && c_FLT_SKIPWHILE(i, isOdd(i))

                      && isOdd(i)

-                     && c_flt_skip(i, 2)

-                      , c_flt_take(i, 1))

+                     && c_FLT_SKIP(i, 2)

+                      , c_FLT_TAKE(i, 1))

             printf(" %d", *i.ref);

         puts("");

         // 189

diff --git a/misc/examples/gauss1.c b/misc/examples/gauss1.c
index 675ff338..519a7895 100644
--- a/misc/examples/gauss1.c
+++ b/misc/examples/gauss1.c
@@ -29,27 +29,27 @@ int main()
     stc64_normalf_t dist = stc64_normalf_new(Mean, StdDev);
 
     // Create and init histogram vec and map with defered destructors:
-    c_auto (cvec_ii, histvec)
-    c_auto (cmap_ii, histmap)
+    c_AUTO (cvec_ii, histvec)
+    c_AUTO (cmap_ii, histmap)
     {
-        c_forrange (N) {
-            int index = (int) round( stc64_normalf(&rng, &dist) );
+        c_FORRANGE (N) {
+            int index = (int)round( stc64_normalf(&rng, &dist) );
             cmap_ii_insert(&histmap, index, 0).ref->second += 1;
         }
 
         // Transfer map to vec and sort it by map keys.
-        c_foreach (i, cmap_ii, histmap)
+        c_FOREACH (i, cmap_ii, histmap)
             cvec_ii_push(&histvec, (cmap_ii_value){i.ref->first, i.ref->second});
 
         cvec_ii_sort(&histvec);
 
         // Print the gaussian bar chart
-        c_auto (cstr, bar)
-        c_foreach (i, cvec_ii, histvec) {
-            size_t n = (size_t) (i.ref->second * StdDev * Scale * 2.5 / (float)N);
+        c_FOREACH (i, cvec_ii, histvec) {
+            int n = (int)(i.ref->second * StdDev * Scale * 2.5 / N);
             if (n > 0) {
-                cstr_resize(&bar, n, '*');
-                printf("%4d %s\n", i.ref->first, cstr_str(&bar));
+                printf("%4d ", i.ref->first);
+                c_FORRANGE (n) printf("*");
+                puts("");
             }
         }
     }
diff --git a/misc/examples/gauss2.c b/misc/examples/gauss2.c
index 2e07c5a5..c2ed2e00 100644
--- a/misc/examples/gauss2.c
+++ b/misc/examples/gauss2.c
@@ -23,16 +23,16 @@ int main()
     stc64_normalf_t dist = stc64_normalf_new(Mean, StdDev);
 
     // Create and init histogram map with defered destruct
-    c_auto (csmap_int, mhist)
+    c_AUTO (csmap_int, mhist)
     {
-        c_forrange (N) {
+        c_FORRANGE (N) {
             int index = (int) round( stc64_normalf(&rng, &dist) );
             csmap_int_insert(&mhist, index, 0).ref->second += 1;
         }
 
         // Print the gaussian bar chart
-        c_auto (cstr, bar)
-        c_forpair (index, count, csmap_int, mhist) {
+        c_AUTO (cstr, bar)
+        c_FORPAIR (index, count, csmap_int, mhist) {
             size_t n = (size_t) (*_.count * StdDev * Scale * 2.5 / (float)N);
             if (n > 0) {
                 cstr_resize(&bar, n, '*');
diff --git a/misc/examples/hashmap.c b/misc/examples/hashmap.c
index f59ed824..bc4f2566 100644
--- a/misc/examples/hashmap.c
+++ b/misc/examples/hashmap.c
@@ -17,7 +17,7 @@ const char* call(const char* number) {
 }
 
 int main(void) {
-    c_auto (cmap_str, contacts)
+    c_AUTO (cmap_str, contacts)
     {
         cmap_str_emplace(&contacts, "Daniel", "798-1364");
         cmap_str_emplace(&contacts, "Ashley", "645-7689");
@@ -40,7 +40,7 @@ int main(void) {
         cmap_str_erase(&contacts, "Ashley");
 
         puts("");
-        c_forpair (contact, number, cmap_str, contacts) {
+        c_FORPAIR (contact, number, cmap_str, contacts) {
             printf("Calling %s: %s\n", cstr_str(_.contact), call(cstr_str(_.number)));
         }
         puts("");
diff --git a/misc/examples/inits.c b/misc/examples/inits.c
index 021a3e0a..459a0ec1 100644
--- a/misc/examples/inits.c
+++ b/misc/examples/inits.c
@@ -36,11 +36,11 @@ int main(void)
 {
     // CVEC FLOAT / PRIORITY QUEUE
 
-    c_auto (cpque_f, floats) {
+    c_AUTO (cpque_f, floats) {
         const float nums[] = {4.0f, 2.0f, 5.0f, 3.0f, 1.0f};
 
         // PRIORITY QUEUE
-        c_forrange (i, c_arraylen(nums))
+        c_FORRANGE (i, c_ARRAYLEN(nums))
             cpque_f_push(&floats, nums[i]);
 
         puts("\npop and show high priorites first:");
@@ -54,20 +54,20 @@ int main(void)
     // CMAP ID
 
     int year = 2020;
-    c_auto (cmap_id, idnames) {
+    c_AUTO (cmap_id, idnames) {
         cmap_id_emplace(&idnames, 100, "Hello");
         cmap_id_insert(&idnames, 110, cstr_lit("World"));
         cmap_id_insert(&idnames, 120, cstr_from_fmt("Howdy, -%d-", year));
 
-        c_foreach (i, cmap_id, idnames)
+        c_FOREACH (i, cmap_id, idnames)
             printf("%d: %s\n", i.ref->first, cstr_str(&i.ref->second));
         puts("");
     }
 
     // CMAP CNT
 
-    c_auto (cmap_cnt, countries) {
-        c_forlist (i, cmap_cnt_raw, {
+    c_AUTO (cmap_cnt, countries) {
+        c_FORLIST (i, cmap_cnt_raw, {
             {"Norway", 100},
             {"Denmark", 50},
             {"Iceland", 10},
@@ -83,33 +83,33 @@ int main(void)
         cmap_cnt_emplace(&countries, "Norway", 0).ref->second += 20;
         cmap_cnt_emplace(&countries, "Finland", 0).ref->second += 20;
 
-        c_forpair (country, health, cmap_cnt, countries)
+        c_FORPAIR (country, health, cmap_cnt, countries)
             printf("%s: %d\n", cstr_str(_.country), *_.health);
         puts("");
     }
 
     // CVEC PAIR
 
-    c_auto (cvec_ip, pairs1) {
-        c_forlist (i, ipair_t, {{5, 6}, {3, 4}, {1, 2}, {7, 8}})
+    c_AUTO (cvec_ip, pairs1) {
+        c_FORLIST (i, ipair_t, {{5, 6}, {3, 4}, {1, 2}, {7, 8}})
             cvec_ip_push_back(&pairs1, *i.ref);
 
         cvec_ip_sort(&pairs1);
 
-        c_foreach (i, cvec_ip, pairs1)
+        c_FOREACH (i, cvec_ip, pairs1)
             printf("(%d %d) ", i.ref->x, i.ref->y);
         puts("");
     }
 
     // CLIST PAIR
 
-    c_auto (clist_ip, pairs2) {
-        c_forlist (i, ipair_t, {{5, 6}, {3, 4}, {1, 2}, {7, 8}})
+    c_AUTO (clist_ip, pairs2) {
+        c_FORLIST (i, ipair_t, {{5, 6}, {3, 4}, {1, 2}, {7, 8}})
             clist_ip_push_back(&pairs2, *i.ref);
 
         clist_ip_sort(&pairs2);
 
-        c_foreach (i, clist_ip, pairs2)
+        c_FOREACH (i, clist_ip, pairs2)
             printf("(%d %d) ", i.ref->x, i.ref->y);
         puts("");
     }
diff --git a/misc/examples/intrusive.c b/misc/examples/intrusive.c
index acf4416d..4135317e 100644
--- a/misc/examples/intrusive.c
+++ b/misc/examples/intrusive.c
@@ -1,4 +1,4 @@
-// Example of intrusive list by using the node API and typesafe c_container_of().
+// Example of intrusive list by using the node API and typesafe c_CONTAINER_OF().
 
 #include <stdio.h> 
 
@@ -14,39 +14,39 @@
 
 int main()
 {
-    c_auto (List2, list2)
+    c_AUTO (List2, list2)
     {
         List1 list1 = List1_init(); // should not be destroyed, list2 will destroy shared nodes.
 
-        c_forlist (i, int, {6, 9, 3, 1, 7, 4, 5, 2, 8})
+        c_FORLIST (i, int, {6, 9, 3, 1, 7, 4, 5, 2, 8})
             List2_push_back(&list2, (List1_node){NULL, *i.ref});
 
-        c_foreach (i, List2, list2)
-            List1_push_node_back(&list1, c_container_of(&i.ref->value, List1_node, value));
+        c_FOREACH (i, List2, list2)
+            List1_push_node_back(&list1, c_CONTAINER_OF(&i.ref->value, List1_node, value));
 
         printf("list1:");
-        c_foreach (i, List1, list1) printf(" %d", *i.ref);
+        c_FOREACH (i, List1, list1) printf(" %d", *i.ref);
         printf("\nlist2:");
-        c_foreach (i, List2, list2) printf(" %d", i.ref->value);
+        c_FOREACH (i, List2, list2) printf(" %d", i.ref->value);
 
         printf("\nsort list1");
         List1_sort(&list1);
 
         printf("\nlist1:");
-        c_foreach (i, List1, list1) printf(" %d", *i.ref);
+        c_FOREACH (i, List1, list1) printf(" %d", *i.ref);
         printf("\nlist2:");
-        c_foreach (i, List2, list2) printf(" %d", i.ref->value);
+        c_FOREACH (i, List2, list2) printf(" %d", i.ref->value);
 
         printf("\nremove 5 from both lists in O(1) time");
         List1_iter it1 = List1_find(&list1, 5);
         if (it1.ref) {
             List1_unlink_node_after(&list1, it1.prev);
-            free(List2_unlink_node_after(&list2, c_container_of(it1.prev, List2_node, value)));
+            free(List2_unlink_node_after(&list2, c_CONTAINER_OF(it1.prev, List2_node, value)));
         }
         printf("\nlist1:");
-        c_foreach (i, List1, list1) printf(" %d", *i.ref);
+        c_FOREACH (i, List1, list1) printf(" %d", *i.ref);
         printf("\nlist2:");
-        c_foreach (i, List2, list2) printf(" %d", i.ref->value);
+        c_FOREACH (i, List2, list2) printf(" %d", i.ref->value);
         puts("");
     }
 }
diff --git a/misc/examples/list.c b/misc/examples/list.c
index a538d93c..4aacfe38 100644
--- a/misc/examples/list.c
+++ b/misc/examples/list.c
@@ -12,37 +12,37 @@
 int main() {
     const int n = 2000000;
 
-    c_auto (clist_fx, list)
+    c_AUTO (clist_fx, list)
     {
         stc64_t rng = stc64_new(1234);
         stc64_uniformf_t dist = stc64_uniformf_new(100.0f, n);
         int m = 0;
-        c_forrange (n)
+        c_FORRANGE (n)
             clist_fx_push_back(&list, stc64_uniformf(&rng, &dist)), ++m;
         double sum = 0.0;
         printf("sumarize %d:\n", m);
-        c_foreach (i, clist_fx, list)
+        c_FOREACH (i, clist_fx, list)
             sum += *i.ref;
         printf("sum %f\n\n", sum);
 
-        c_forwhile (i, clist_fx, clist_fx_begin(&list), i.index < 10)
+        c_FORWHILE (i, clist_fx, clist_fx_begin(&list), i.index < 10)
             printf("%8d: %10f\n", (int)i.index, *i.ref);
 
         puts("sort");
         clist_fx_sort(&list); // mergesort O(n*log n)
         puts("sorted");
 
-        c_forwhile (i, clist_fx, clist_fx_begin(&list), i.index < 10)
+        c_FORWHILE (i, clist_fx, clist_fx_begin(&list), i.index < 10)
             printf("%8d: %10f\n", (int)i.index, *i.ref);
         puts("");
 
         clist_fx_clear(&list);
-        c_forlist (i, int, {10, 20, 30, 40, 30, 50})
+        c_FORLIST (i, int, {10, 20, 30, 40, 30, 50})
             clist_fx_push_back(&list, *i.ref);
 
         const double* v = clist_fx_get(&list, 30);
         printf("found: %f\n", *v);
-        c_foreach (i, clist_fx, list) printf(" %g", *i.ref);
+        c_FOREACH (i, clist_fx, list) printf(" %g", *i.ref);
         puts("");
 
         clist_fx_remove(&list, 30);
@@ -51,10 +51,10 @@ int main() {
         clist_fx_push_front(&list, 1964);
         clist_fx_iter it = clist_fx_begin(&list);
         printf("Full: ");
-        c_foreach (i, clist_fx, list)
+        c_FOREACH (i, clist_fx, list)
             printf(" %g", *i.ref);
         printf("\nSubs: ");
-        c_foreach (i, clist_fx, clist_fx_advance(it, 4), clist_fx_end(&list))
+        c_FOREACH (i, clist_fx, clist_fx_advance(it, 4), clist_fx_end(&list))
             printf(" %g", *i.ref);
         puts("");
     }
diff --git a/misc/examples/list_erase.c b/misc/examples/list_erase.c
index c1a2aa97..18ad0d16 100644
--- a/misc/examples/list_erase.c
+++ b/misc/examples/list_erase.c
@@ -7,12 +7,12 @@
 
 int main ()
 {
-    c_with (IList L = IList_init(), IList_drop(&L))
+    c_WITH (IList L = IList_init(), IList_drop(&L))
     {
-        c_forlist (i, int, {10, 20, 30, 40, 50})
+        c_FORLIST (i, int, {10, 20, 30, 40, 50})
             IList_push(&L, *i.ref);
 
-        c_foreach (x, IList, L)
+        c_FOREACH (x, IList, L)
             printf("%d ", *x.ref);
         puts("");
                                               // 10 20 30 40 50
@@ -25,7 +25,7 @@ int main ()
         it = IList_erase_range(&L, it, end);  // 10 30
                                               //       ^
         printf("list contains:");
-        c_foreach (x, IList, L)
+        c_FOREACH (x, IList, L)
             printf(" %d", *x.ref);
         puts("");
     }
diff --git a/misc/examples/list_splice.c b/misc/examples/list_splice.c
index f7bac0d6..8a5dae76 100644
--- a/misc/examples/list_splice.c
+++ b/misc/examples/list_splice.c
@@ -8,7 +8,7 @@
 void print_ilist(const char* s, clist_i list)
 {
     printf("%s", s);
-    c_foreach (i, clist_i, list) {
+    c_FOREACH (i, clist_i, list) {
         printf(" %d", *i.ref);
     }
     puts("");
@@ -16,12 +16,12 @@ void print_ilist(const char* s, clist_i list)
 
 int main ()
 {
-    c_auto (clist_i, list1, list2)
+    c_AUTO (clist_i, list1, list2)
     {
-        c_forlist (i, int, {1, 2, 3, 4, 5})
+        c_FORLIST (i, int, {1, 2, 3, 4, 5})
             clist_i_push_back(&list1, *i.ref);
 
-        c_forlist (i, int, {10, 20, 30, 40, 50})
+        c_FORLIST (i, int, {10, 20, 30, 40, 50})
             clist_i_push_back(&list2, *i.ref);
 
         print_ilist("list1:", list1);
diff --git a/misc/examples/lower_bound.c b/misc/examples/lower_bound.c
index 2477bc14..2b6f3cc6 100644
--- a/misc/examples/lower_bound.c
+++ b/misc/examples/lower_bound.c
@@ -9,11 +9,11 @@
 int main()
 {
     // TEST SORTED VECTOR
-    c_auto (cvec_int, vec)
+    c_AUTO (cvec_int, vec)
     {
         int key, *res;
 
-        c_forlist (i, int, {40, 600, 1, 7000, 2, 500, 30})
+        c_FORLIST (i, int, {40, 600, 1, 7000, 2, 500, 30})
             cvec_int_push(&vec, *i.ref);
 
         cvec_int_sort(&vec);
@@ -36,11 +36,11 @@ int main()
     }
 
     // TEST SORTED SET
-    c_auto (csset_int, set)
+    c_AUTO (csset_int, set)
     {
         int key, *res;
 
-        c_forlist (i, int, {40, 600, 1, 7000, 2, 500, 30})
+        c_FORLIST (i, int, {40, 600, 1, 7000, 2, 500, 30})
             csset_int_push(&set, *i.ref);
 
         key = 500;
diff --git a/misc/examples/mapmap.c b/misc/examples/mapmap.c
index 488cc539..c361233b 100644
--- a/misc/examples/mapmap.c
+++ b/misc/examples/mapmap.c
@@ -30,7 +30,7 @@ void add(Departments* deps, const char* name, const char* email, const char* dep
 int contains(Departments* map, const char* name)
 {
     int count = 0;
-    c_foreach (i, Departments, *map)
+    c_FOREACH (i, Departments, *map)
         if (People_contains(&i.ref->second, name))
             ++count;
     return count;
@@ -38,7 +38,7 @@ int contains(Departments* map, const char* name)
 
 int main(void)
 {
-    c_auto (Departments, map)
+    c_AUTO (Departments, map)
     {
         add(&map, "Anna Kendro", "[email protected]", "Support");
         add(&map, "Terry Dane", "[email protected]", "Development");
@@ -54,8 +54,8 @@ int main(void)
         add(&map, "Dennis Kay", "[email protected]", "Marketing");
         add(&map, "Anne Dickens", "[email protected]", "Development");
 
-        c_foreach (i, Departments, map)
-            c_forpair (name, email, People, i.ref->second)
+        c_FOREACH (i, Departments, map)
+            c_FORPAIR (name, email, People, i.ref->second)
                 printf("%s: %s - %s\n", cstr_str(&i.ref->first), cstr_str(_.name), cstr_str(_.email));
         puts("");
 
diff --git a/misc/examples/mmap.c b/misc/examples/mmap.c
index 3934cf26..ada30b98 100644
--- a/misc/examples/mmap.c
+++ b/misc/examples/mmap.c
@@ -18,8 +18,8 @@
 void print(const char* lbl, const Multimap mmap)
 {
     printf("%s ", lbl);
-    c_foreach (e, Multimap, mmap) {
-        c_foreach (s, clist_str, e.ref->second)
+    c_FOREACH (e, Multimap, mmap) {
+        c_FOREACH (s, clist_str, e.ref->second)
             printf("{%d,%s} ", e.ref->first, cstr_str(s.ref));
     }
     puts("");
@@ -33,12 +33,12 @@ void insert(Multimap* mmap, int key, const char* str)
 
 int main()
 {
-    c_auto (Multimap, mmap)
+    c_AUTO (Multimap, mmap)
     {
         typedef struct {int a; const char* b;} pair;
 
         // list-initialize
-        c_forlist (i, pair, {{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}})
+        c_FORLIST (i, pair, {{2, "foo"}, {2, "bar"}, {3, "baz"}, {1, "abc"}, {5, "def"}})
             insert(&mmap, i.ref->a, i.ref->b);
         print("#1", mmap);
 
@@ -54,7 +54,7 @@ int main()
         print("#4", mmap);
 
         // insert using initialization_list
-        c_forlist (i, pair, {{5, "one"}, {5, "two"}})
+        c_FORLIST (i, pair, {{5, "one"}, {5, "two"}})
             insert(&mmap, i.ref->a, i.ref->b);
         print("#5", mmap);
 
@@ -65,7 +65,7 @@ int main()
         
 
         Multimap_clear(&mmap);
-        c_forlist (i, pair, {{1, "ä"}, {2, "ё"}, {2, "ö"}, {3, "ü"}})
+        c_FORLIST (i, pair, {{1, "ä"}, {2, "ё"}, {2, "ö"}, {3, "ü"}})
             insert(&mmap, i.ref->a, i.ref->b);
         print("#6", mmap);
     }
diff --git a/misc/examples/multimap.c b/misc/examples/multimap.c
index e72bdce3..8797c24e 100644
--- a/misc/examples/multimap.c
+++ b/misc/examples/multimap.c
@@ -60,17 +60,17 @@ OlympicLocation OlympicLocation_clone(OlympicLocation loc) {
     return loc;
 }
 void OlympicLocation_drop(OlympicLocation* self) {
-    c_drop(cstr, &self->city, &self->date);
+    c_DROP(cstr, &self->city, &self->date);
 }
 
 int main()
 {
     // Define the multimap with destructor defered to when block is completed.
-    c_auto (csmap_OL, multimap)
+    c_AUTO (csmap_OL, multimap)
     {
         const clist_OL empty = clist_OL_init();
 
-        for (size_t i = 0; i < c_arraylen(ol_data); ++i)
+        for (size_t i = 0; i < c_ARRAYLEN(ol_data); ++i)
         {
             struct OlympicsData* d = &ol_data[i];
             OlympicLocation loc = {.year = d->year,
@@ -82,14 +82,14 @@ int main()
             clist_OL_push_back(list, loc);
         }
         // Sort locations by year for each country.
-        c_foreach (country, csmap_OL, multimap)
+        c_FOREACH (country, csmap_OL, multimap)
             clist_OL_sort(&country.ref->second);
 
         // Print the multimap:
-        c_foreach (country, csmap_OL, multimap)
+        c_FOREACH (country, csmap_OL, multimap)
         {
             // Loop the locations for a country sorted by year
-            c_foreach (loc, clist_OL, country.ref->second)
+            c_FOREACH (loc, clist_OL, country.ref->second)
                 printf("%s: %d, %s, %s\n", cstr_str(&country.ref->first),
                                                      loc.ref->year,
                                            cstr_str(&loc.ref->city),
diff --git a/misc/examples/music_arc.c b/misc/examples/music_arc.c
index 162c4c2f..9896c591 100644
--- a/misc/examples/music_arc.c
+++ b/misc/examples/music_arc.c
@@ -2,21 +2,21 @@
 // based on https://docs.microsoft.com/en-us/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-160
 #include <stc/cstr.h>
 
-struct Song
+typedef struct
 {
     cstr artist;
     cstr title;
-} typedef Song;
+} Song;
 
 int Song_cmp(const Song* x, const Song* y)
     { return cstr_cmp(&x->title, &y->title); }
 
-Song Song_from(const char* artist, const char* title)
+Song Song_make(const char* artist, const char* title)
     { return (Song){cstr_from(artist), cstr_from(title)}; }
 
 void Song_drop(Song* s) {
     printf("drop: %s\n", cstr_str(&s->title));
-    c_drop(cstr, &s->artist, &s->title);
+    c_DROP(cstr, &s->artist, &s->title);
 }
 
 // Define the reference counted type
@@ -32,29 +32,29 @@ void Song_drop(Song* s) {
 
 void example3()
 {
-    c_auto (SongVec, vec1, vec2)
+    c_AUTO (SongVec, vec1, vec2)
     {
-        c_forlist (i, Song, {
-            Song_from("Bob Dylan", "The Times They Are A Changing"),
-            Song_from("Aretha Franklin", "Bridge Over Troubled Water"),
-            Song_from("Thalia", "Entre El Mar y Una Estrella")
+        c_FORLIST (i, Song, {
+            Song_make("Bob Dylan", "The Times They Are A Changing"),
+            Song_make("Aretha Franklin", "Bridge Over Troubled Water"),
+            Song_make("Thalia", "Entre El Mar y Una Estrella")
         }) SongVec_emplace(&vec1, *i.ref);
 
         // Share all entries in vec with vec2, except Bob Dylan.
-        c_foreach (s, SongVec, vec1)
+        c_FOREACH (s, SongVec, vec1)
             if (!cstr_equals(&s.ref->get->artist, "Bob Dylan"))
                 SongVec_push(&vec2, SongArc_clone(*s.ref));
 
         // Add a few more to vec2. We can use emplace when creating new entries
-        SongVec_emplace(&vec2, Song_from("Michael Jackson", "Billie Jean"));
-        SongVec_emplace(&vec2, Song_from("Rihanna", "Stay"));
+        SongVec_emplace(&vec2, Song_make("Michael Jackson", "Billie Jean"));
+        SongVec_emplace(&vec2, Song_make("Rihanna", "Stay"));
         // If we use push, we would need to construct the Arc explicitly (as in c++, make_shared):
-        // SongVec_push(&vec2, SongArc_from(Song_from("Rihanna", "Stay")));
+        // SongVec_push(&vec2, SongArc_from(Song_make("Rihanna", "Stay")));
 
         // We now have two vectors with some shared, some unique entries.
-        c_forlist (i, SongVec, {vec1, vec2}) {
+        c_FORLIST (i, SongVec, {vec1, vec2}) {
             puts("VEC:");
-            c_foreach (s, SongVec, *i.ref)
+            c_FOREACH (s, SongVec, *i.ref)
                 printf("  %s - %s, REFS: %ld\n", cstr_str(&s.ref->get->artist),
                                                  cstr_str(&s.ref->get->title),
                                                  *s.ref->use_count);
diff --git a/misc/examples/new_arr.c b/misc/examples/new_arr.c
index 871cfae0..7170d14a 100644
--- a/misc/examples/new_arr.c
+++ b/misc/examples/new_arr.c
@@ -13,7 +13,7 @@ int main()
 {
     int w = 7, h = 5, d = 3;
 
-    c_with (carr2_int volume = carr2_int_new_uninit(w, h), carr2_int_drop(&volume))
+    c_WITH (carr2_int volume = carr2_int_new_uninit(w, h), carr2_int_drop(&volume))
     {
         int *dat = carr2_int_data(&volume);
         for (size_t i = 0; i < carr2_int_size(&volume); ++i)
@@ -24,12 +24,12 @@ int main()
                 printf(" %d", volume.data[x][y]);
         puts("");
 
-        c_foreach (i, carr2_int, volume)
+        c_FOREACH (i, carr2_int, volume)
             printf(" %d", *i.ref);
         puts("\n");
     }
 
-    c_with (carr3_int volume = carr3_int_new_uninit(w, h, d), carr3_int_drop(&volume))
+    c_WITH (carr3_int volume = carr3_int_new_uninit(w, h, d), carr3_int_drop(&volume))
     {
         int *dat = carr3_int_data(&volume);
         for (size_t i = 0; i < carr3_int_size(&volume); ++i)
@@ -41,17 +41,17 @@ int main()
                     printf(" %d", volume.data[x][y][z]);
         puts("");
 
-        c_foreach (i, carr3_int, volume)
+        c_FOREACH (i, carr3_int, volume)
             printf(" %d", *i.ref);
         puts("");
     }
 
-    c_with (carr2_str text2d = carr2_str_with_size(h, d, cstr_NULL), carr2_str_drop(&text2d))
+    c_WITH (carr2_str text2d = carr2_str_with_size(h, d, cstr_NULL), carr2_str_drop(&text2d))
     {
         cstr_assign(&text2d.data[2][1], "hello");
         cstr_assign(&text2d.data[4][0], "world");
 
-        c_foreach (i, carr2_str, text2d)
+        c_FOREACH (i, carr2_str, text2d)
             printf("line: %s\n", cstr_str(i.ref));
     }
 }
diff --git a/misc/examples/new_deq.c b/misc/examples/new_deq.c
index 39149140..df9142e7 100644
--- a/misc/examples/new_deq.c
+++ b/misc/examples/new_deq.c
@@ -36,25 +36,25 @@ int point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (cdeq_i32, vec)
+    c_AUTO (cdeq_i32, vec)
     {
         cdeq_i32_push_back(&vec, 123);
     }
-    c_auto (cdeq_float, fvec)
+    c_AUTO (cdeq_float, fvec)
     {
         cdeq_float_push_back(&fvec, 123.3f);
     }
-    c_auto (cdeq_pnt, pvec)
+    c_AUTO (cdeq_pnt, pvec)
     {
         cdeq_pnt_push_back(&pvec, (Point){42, 14});
         cdeq_pnt_push_back(&pvec, (Point){32, 94});
         cdeq_pnt_push_front(&pvec, (Point){62, 81});
         cdeq_pnt_sort(&pvec);
-        c_foreach (i, cdeq_pnt, pvec)
+        c_FOREACH (i, cdeq_pnt, pvec)
             printf(" (%d %d)", i.ref->x, i.ref->y);
         puts("");
     }
-    c_auto (cdeq_str, svec)
+    c_AUTO (cdeq_str, svec)
     {
         cdeq_str_emplace_back(&svec, "Hello, friend");
     }
diff --git a/misc/examples/new_list.c b/misc/examples/new_list.c
index 6dbe80b4..c5d90ad1 100644
--- a/misc/examples/new_list.c
+++ b/misc/examples/new_list.c
@@ -35,27 +35,27 @@ int point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (clist_i32, lst)
+    c_AUTO (clist_i32, lst)
         clist_i32_push_back(&lst, 123);
 
-    c_auto (clist_pnt, plst) {
-        c_forlist (i, Point, {{42, 14}, {32, 94}, {62, 81}})
+    c_AUTO (clist_pnt, plst) {
+        c_FORLIST (i, Point, {{42, 14}, {32, 94}, {62, 81}})
             clist_pnt_push_back(&plst, *i.ref);
 
         clist_pnt_sort(&plst);
 
-        c_foreach (i, clist_pnt, plst)
+        c_FOREACH (i, clist_pnt, plst)
             printf(" (%d %d)", i.ref->x, i.ref->y);
         puts("");
     }
 
-    c_auto (clist_float, flst) {
-        c_forlist (i, float, {123.3f, 321.2f, -32.2f, 78.2f})
+    c_AUTO (clist_float, flst) {
+        c_FORLIST (i, float, {123.3f, 321.2f, -32.2f, 78.2f})
             clist_float_push_back(&flst, *i.ref);
         
-        c_foreach (i, clist_float, flst) printf(" %g", *i.ref);
+        c_FOREACH (i, clist_float, flst) printf(" %g", *i.ref);
     }
 
-    c_auto (clist_str, slst)
+    c_AUTO (clist_str, slst)
         clist_str_emplace_back(&slst, "Hello, friend");
 }
diff --git a/misc/examples/new_map.c b/misc/examples/new_map.c
index f43d4217..72705eb2 100644
--- a/misc/examples/new_map.c
+++ b/misc/examples/new_map.c
@@ -42,32 +42,32 @@ int point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (cmap_int, map)
-    c_auto (cmap_pnt, pmap)
-    c_auto (cmap_str, smap)
-    c_auto (cset_str, sset)
+    c_AUTO (cmap_int, map)
+    c_AUTO (cmap_pnt, pmap)
+    c_AUTO (cmap_str, smap)
+    c_AUTO (cset_str, sset)
     {
         cmap_int_insert(&map, 123, 321);
 
-        c_forlist (i, cmap_pnt_raw, {{{42, 14}, 1}, {{32, 94}, 2}, {{62, 81}, 3}})
+        c_FORLIST (i, cmap_pnt_raw, {{{42, 14}, 1}, {{32, 94}, 2}, {{62, 81}, 3}})
             cmap_pnt_insert(&pmap, c_PAIR(i.ref));
 
-        c_foreach (i, cmap_pnt, pmap)
+        c_FOREACH (i, cmap_pnt, pmap)
             printf(" (%d, %d: %d)", i.ref->first.x, i.ref->first.y, i.ref->second);
         puts("");
 
-        c_forlist (i, cmap_str_raw, {
+        c_FORLIST (i, cmap_str_raw, {
             {"Hello, friend", "long time no see"},
             {"So long, friend", "see you around"},
         }) cmap_str_emplace(&smap, c_PAIR(i.ref));
 
-        c_forlist (i, const char*, {
+        c_FORLIST (i, const char*, {
             "Hello, friend",
             "Nice to see you again",
             "So long, friend",
         }) cset_str_emplace(&sset, *i.ref);
 
-        c_foreach (i, cset_str, sset)
+        c_FOREACH (i, cset_str, sset)
             printf(" %s\n", cstr_str(i.ref));
     }
 }
diff --git a/misc/examples/new_pque.c b/misc/examples/new_pque.c
index 2bb1d729..d127b592 100644
--- a/misc/examples/new_pque.c
+++ b/misc/examples/new_pque.c
@@ -20,16 +20,16 @@ int Point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (cstack_int, istk)
+    c_AUTO (cstack_int, istk)
     {
         cstack_int_push(&istk, 123);
         cstack_int_push(&istk, 321);
         // print
-        c_foreach (i, cstack_int, istk)
+        c_FOREACH (i, cstack_int, istk)
             printf(" %d", *i.ref);
         puts("");
     }
-    c_auto (cpque_pnt, pque)
+    c_AUTO (cpque_pnt, pque)
     {
         cpque_pnt_push(&pque, (Point){23, 80});
         cpque_pnt_push(&pque, (Point){12, 32});
@@ -43,7 +43,7 @@ int main()
         }
         puts("");
     }
-    c_auto (cpque_int, ique)
+    c_AUTO (cpque_int, ique)
     {
         cpque_int_push(&ique, 123);
         cpque_int_push(&ique, 321);
diff --git a/misc/examples/new_queue.c b/misc/examples/new_queue.c
index bc7a95c9..c72c94a0 100644
--- a/misc/examples/new_queue.c
+++ b/misc/examples/new_queue.c
@@ -25,15 +25,15 @@ int main() {
     stc64_t rng = stc64_new(time(NULL));
     stc64_uniform_t dist = stc64_uniform_new(0, n);
 
-    c_auto (IQ, Q)
+    c_AUTO (IQ, Q)
     {
         // Push eight million random numbers onto the queue.
-        c_forrange (n)
+        c_FORRANGE (n)
             IQ_push(&Q, stc64_uniform(&rng, &dist));
 
         // Push or pop on the queue 50 million times
         printf("befor: size %" c_ZU ", capacity %" c_ZU "\n", IQ_size(&Q), IQ_capacity(&Q));
-        c_forrange (n) {
+        c_FORRANGE (n) {
             int r = stc64_uniform(&rng, &dist);
             if (r & 3)
                 IQ_push(&Q, r);
diff --git a/misc/examples/new_smap.c b/misc/examples/new_smap.c
index c77aa185..8b1df828 100644
--- a/misc/examples/new_smap.c
+++ b/misc/examples/new_smap.c
@@ -42,34 +42,34 @@ int point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (csmap_int, imap) {
+    c_AUTO (csmap_int, imap) {
         csmap_int_insert(&imap, 123, 321);
     }
 
-    c_auto (PMap, pmap) {
-        c_forlist (i, PMap_value, {
+    c_AUTO (PMap, pmap) {
+        c_FORLIST (i, PMap_value, {
             {{42, 14}, 1},
             {{32, 94}, 2},
             {{62, 81}, 3},
         }) PMap_insert(&pmap, c_PAIR(i.ref));
 
-        c_forpair (p, i, PMap, pmap)
+        c_FORPAIR (p, i, PMap, pmap)
             printf(" (%d,%d: %d)", _.p->x, _.p->y, *_.i);
         puts("");
     }
 
-    c_auto (SMap, smap) {
-        c_forlist (i, SMap_raw, {
+    c_AUTO (SMap, smap) {
+        c_FORLIST (i, SMap_raw, {
             {"Hello, friend", "this is the mapped value"},
             {"The brown fox", "jumped"},
             {"This is the time", "for all good things"},
         }) SMap_emplace(&smap, c_PAIR(i.ref));
 
-        c_forpair (i, j, SMap, smap)
+        c_FORPAIR (i, j, SMap, smap)
             printf(" (%s: %s)\n", cstr_str(_.i), cstr_str(_.j));
     }
 
-    c_auto (SSet, sset) {
+    c_AUTO (SSet, sset) {
         SSet_emplace(&sset, "Hello, friend");
         SSet_emplace(&sset, "Goodbye, foe");
         printf("Found? %s\n", SSet_contains(&sset, "Hello, friend") ? "true" : "false");
diff --git a/misc/examples/new_sptr.c b/misc/examples/new_sptr.c
index 2c6b28d6..90ce30b2 100644
--- a/misc/examples/new_sptr.c
+++ b/misc/examples/new_sptr.c
@@ -42,12 +42,12 @@ Person Person_clone(Person p) {
 }
 void Person_drop(Person* p) {
     printf("drop: %s %s\n", cstr_str(&p->name), cstr_str(&p->last));
-    c_drop(cstr, &p->name, &p->last);
+    c_DROP(cstr, &p->name, &p->last);
 }
 
 
 int main(void) {
-    c_auto (PersonArc, p, q, r, s)
+    c_AUTO (PersonArc, p, q, r, s)
     {
         puts("Ex1");
         p = PersonArc_from(Person_make("John", "Smiths"));
@@ -56,7 +56,7 @@ int main(void) {
         s = PersonArc_from(Person_clone(*p.get)); // deep copy
         printf("%s %s: refs %ld\n", cstr_str(&p.get->name), cstr_str(&p.get->last), *p.use_count);
     }
-    c_auto (IPStack, vec)
+    c_AUTO (IPStack, vec)
     {
         puts("Ex2");
         IPStack_push(&vec, IPtr_from(10));
@@ -65,7 +65,7 @@ int main(void) {
         IPStack_push(&vec, IPtr_clone(*IPStack_back(&vec)));
         IPStack_push(&vec, IPtr_clone(*IPStack_front(&vec)));
 
-        c_foreach (i, IPStack, vec)
+        c_FOREACH (i, IPStack, vec)
             printf(" (%d: refs %ld)", *i.ref->get, *i.ref->use_count);
         puts("");
     }
diff --git a/misc/examples/new_vec.c b/misc/examples/new_vec.c
index 84e4c7b2..f18bf368 100644
--- a/misc/examples/new_vec.c
+++ b/misc/examples/new_vec.c
@@ -36,10 +36,10 @@ int point_cmp(const Point* a, const Point* b) {
 
 int main()
 {
-    c_auto (cvec_i32, vec)
-    c_auto (cvec_float, fvec)
-    c_auto (cvec_pnt, pvec)
-    c_auto (cvec_str, svec)
+    c_AUTO (cvec_i32, vec)
+    c_AUTO (cvec_float, fvec)
+    c_AUTO (cvec_pnt, pvec)
+    c_AUTO (cvec_str, svec)
     {
         cvec_i32_push(&vec, 123);
         cvec_float_push(&fvec, 123.3f);
@@ -49,7 +49,7 @@ int main()
         cvec_pnt_push(&pvec, (Point){62, 81});
         cvec_pnt_push(&pvec, (Point){32, 91});
         cvec_pnt_sort(&pvec);
-        c_foreach (i, cvec_pnt, pvec)
+        c_FOREACH (i, cvec_pnt, pvec)
             printf(" (%d %d)", i.ref->x, i.ref->y);
         puts("");
 
diff --git a/misc/examples/person_arc.c b/misc/examples/person_arc.c
index a7bf2a6f..f782c9da 100644
--- a/misc/examples/person_arc.c
+++ b/misc/examples/person_arc.c
@@ -24,7 +24,7 @@ Person Person_clone(Person p) {
 
 void Person_drop(Person* p) {
     printf("drop: %s %s\n", cstr_str(&p->name), cstr_str(&p->last));
-    c_drop(cstr, &p->name, &p->last);
+    c_DROP(cstr, &p->name, &p->last);
 }
 
 #define i_type PSPtr
@@ -39,8 +39,8 @@ void Person_drop(Person* p) {
 
 int main()
 {
-    c_auto (Persons, vec)
-    c_auto (PSPtr, p, q)
+    c_AUTO (Persons, vec)
+    c_AUTO (PSPtr, p, q)
     {
         p = PSPtr_from(Person_make("Laura", "Palmer"));
 
@@ -57,15 +57,15 @@ int main()
         Persons_emplace(&vec, Person_make("Dale", "Cooper"));
 
         // Clone/share p and q to the vector
-        c_forlist (i, PSPtr, {p, q})
+        c_FORLIST (i, PSPtr, {p, q})
             Persons_push(&vec, PSPtr_clone(*i.ref));
 
-        c_foreach (i, Persons, vec)
+        c_FOREACH (i, Persons, vec)
             printf("%s %s\n", cstr_str(&i.ref->get->name), cstr_str(&i.ref->get->last));
         puts("");
 
         // Look-up Audrey!
-        c_with (Person a = Person_make("Audrey", "Home"), Person_drop(&a)) {
+        c_WITH (Person a = Person_make("Audrey", "Home"), Person_drop(&a)) {
             const PSPtr *v = Persons_get(&vec, a);
             if (v) printf("found: %s %s\n", cstr_str(&v->get->name), cstr_str(&v->get->last));
         }
diff --git a/misc/examples/phonebook.c b/misc/examples/phonebook.c
index be068409..d0bc5b3a 100644
--- a/misc/examples/phonebook.c
+++ b/misc/examples/phonebook.c
@@ -32,23 +32,23 @@
 
 void print_phone_book(cmap_str phone_book)
 {
-    c_foreach (i, cmap_str, phone_book)
+    c_FOREACH (i, cmap_str, phone_book)
         printf("%s\t- %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second));
 }
 
 int main(int argc, char **argv)
 {
-    c_auto (cset_str, names) {
-        c_forlist (i, const char*, {"Hello", "Cool", "True"})
+    c_AUTO (cset_str, names) {
+        c_FORLIST (i, const char*, {"Hello", "Cool", "True"})
             cset_str_emplace(&names, *i.ref);
         
-        c_foreach (i, cset_str, names)
+        c_FOREACH (i, cset_str, names)
             printf("%s ", cstr_str(i.ref));
         puts("");
     }
 
-    c_auto (cmap_str, phone_book) {
-        c_forlist (i, cmap_str_raw, {
+    c_AUTO (cmap_str, phone_book) {
+        c_FORLIST (i, cmap_str_raw, {
             {"Lilia Friedman", "(892) 670-4739"},
             {"Tariq Beltran", "(489) 600-7575"},
             {"Laiba Juarez", "(303) 885-5692"},
diff --git a/misc/examples/prime.c b/misc/examples/prime.c
index 287fb69b..41d637b8 100644
--- a/misc/examples/prime.c
+++ b/misc/examples/prime.c
@@ -28,7 +28,7 @@ int main(void)
     printf("computing prime numbers up to %" c_ZU "\n", n);
 
     clock_t t1 = clock();
-    c_with (cbits primes = sieveOfEratosthenes(n + 1), cbits_drop(&primes)) {
+    c_WITH (cbits primes = sieveOfEratosthenes(n + 1), cbits_drop(&primes)) {
         puts("done");
         size_t np = cbits_count(&primes);
         clock_t t2 = clock();
@@ -36,14 +36,14 @@ int main(void)
         printf("number of primes: %" c_ZU ", time: %f\n", np, (t2 - t1) / (float)CLOCKS_PER_SEC);
         puts("Show all the primes in the range [2, 1000):");
         printf("2");
-        c_forrange (i, 3, 1000, 2)
+        c_FORRANGE (i, 3, 1000, 2)
             if (cbits_test(&primes, i>>1)) printf(" %lld", i);
         puts("");
 
         puts("Show the last 50 primes using a temporary crange generator:");
-        c_forfilter (i, crange, crange_literal(n - 1, 0, -2)
+        c_FORFILTER (i, crange, crange_literal(n - 1, 0, -2)
                       , cbits_test(&primes, *i.ref>>1)
-                      , c_flt_take(i, 50)) {
+                      , c_FLT_TAKE(i, 50)) {
             printf("%lld ", *i.ref);
             if (i.count % 10 == 0) puts("");
         }
diff --git a/misc/examples/priority.c b/misc/examples/priority.c
index f6e63205..22da6f60 100644
--- a/misc/examples/priority.c
+++ b/misc/examples/priority.c
@@ -12,22 +12,22 @@ int main() {
     size_t N = 10000000;
     stc64_t rng = stc64_new(time(NULL));
     stc64_uniform_t dist = stc64_uniform_new(0, N * 10);
-    c_auto (cpque_i, heap)
+    c_AUTO (cpque_i, heap)
     {
         // Push ten million random numbers to priority queue
         printf("Push %" c_ZU " numbers\n", N);
-        c_forrange (N)
+        c_FORRANGE (N)
             cpque_i_push(&heap, stc64_uniform(&rng, &dist));
 
         // push some negative numbers too.
-        c_forlist (i, int, {-231, -32, -873, -4, -343})
+        c_FORLIST (i, int, {-231, -32, -873, -4, -343})
             cpque_i_push(&heap, *i.ref);
 
-        c_forrange (N)
+        c_FORRANGE (N)
             cpque_i_push(&heap, stc64_uniform(&rng, &dist));
 
         puts("Extract the hundred smallest.");
-        c_forrange (100) {
+        c_FORRANGE (100) {
             printf("%" PRId64 " ", *cpque_i_top(&heap));
             cpque_i_pop(&heap);
         }
diff --git a/misc/examples/queue.c b/misc/examples/queue.c
index f39c4b8b..1d325fc6 100644
--- a/misc/examples/queue.c
+++ b/misc/examples/queue.c
@@ -11,15 +11,15 @@ int main() {
     stc64_t rng = stc64_new(1234);
     dist = stc64_uniform_new(0, n);
 
-    c_auto (cqueue_i, queue)
+    c_AUTO (cqueue_i, queue)
     {
         // Push ten million random numbers onto the queue.
-        c_forrange (n)
+        c_FORRANGE (n)
             cqueue_i_push(&queue, stc64_uniform(&rng, &dist));
 
         // Push or pop on the queue ten million times
         printf("%d\n", n);
-        c_forrange (n) { // forrange uses initial n only.
+        c_FORRANGE (n) { // forrange uses initial n only.
             int r = stc64_uniform(&rng, &dist);
             if (r & 1)
                 ++n, cqueue_i_push(&queue, r);
diff --git a/misc/examples/random.c b/misc/examples/random.c
index fe64290d..82214924 100644
--- a/misc/examples/random.c
+++ b/misc/examples/random.c
@@ -14,7 +14,7 @@ int main()
     printf("Compare speed of full and unbiased ranged random numbers...\n");
     sum = 0;
     before = clock();
-    c_forrange (N)  {
+    c_FORRANGE (N)  {
         sum += (uint32_t)stc64_rand(&rng);
     }
     diff = clock() - before;
@@ -25,7 +25,7 @@ int main()
     rng = stc64_new(seed);
     sum = 0;
     before = clock();
-    c_forrange (N)  {
+    c_FORRANGE (N)  {
         sum += stc64_uniform(&rng, &dist1); // unbiased
     }
     diff = clock() - before;
@@ -35,7 +35,7 @@ int main()
     sum = 0;
     rng = stc64_new(seed);
     before = clock();
-    c_forrange (N)  {
+    c_FORRANGE (N)  {
         sum += stc64_rand(&rng) % (range + 1); // biased
     }
     diff = clock() - before;
diff --git a/misc/examples/rawptr_elements.c b/misc/examples/rawptr_elements.c
index 4b3d2056..05910c77 100644
--- a/misc/examples/rawptr_elements.c
+++ b/misc/examples/rawptr_elements.c
@@ -10,10 +10,10 @@ typedef int64_t inttype;
 #define i_key_str
 #define i_val inttype*
 #define i_valraw inttype
-#define i_valfrom(raw) c_new(inttype, raw)
+#define i_valfrom(raw) c_NEW(inttype, raw)
 #define i_valto(x) **x
-#define i_valclone(x) c_new(inttype, *x)
-#define i_valdrop(x) c_free(*x)
+#define i_valclone(x) c_NEW(inttype, *x)
+#define i_valdrop(x) c_FREE(*x)
 #include <stc/cmap.h>
 
 // With cbox:
@@ -28,12 +28,12 @@ typedef int64_t inttype;
 
 int main()
 {
-    c_auto (SIPtrMap, map, m1)
-    c_auto (SIBoxMap, m2)
+    c_AUTO (SIPtrMap, map, m1)
+    c_AUTO (SIBoxMap, m2)
     {
         printf("\nMap with pointer elements:\n");
-        SIPtrMap_insert(&map, cstr_from("testing"), c_new(inttype, 1));
-        SIPtrMap_insert(&map, cstr_from("done"), c_new(inttype, 2));
+        SIPtrMap_insert(&map, cstr_from("testing"), c_NEW(inttype, 1));
+        SIPtrMap_insert(&map, cstr_from("done"), c_NEW(inttype, 2));
 
         // Emplace: implicit key, val construction:
         SIPtrMap_emplace(&map, "hello", 3);
@@ -41,14 +41,14 @@ int main()
 
         m1 = SIPtrMap_clone(map);
 
-        c_forpair (name, number, SIPtrMap, m1)
+        c_FORPAIR (name, number, SIPtrMap, m1)
             printf("%s: %" PRId64 "\n", cstr_str(_.name), **_.number);
 
 
         puts("\nIBox map:");
         SIBoxMap_insert(&m2, cstr_from("Hello"), IBox_make(123));
         SIBoxMap_emplace(&m2, "World", 999);
-        c_forpair (name, number, SIBoxMap, m2)
+        c_FORPAIR (name, number, SIBoxMap, m2)
             printf("%s: %d\n", cstr_str(_.name), *_.number->get);
         puts("");
     }
diff --git a/misc/examples/read.c b/misc/examples/read.c
index 4efdcfeb..ee5dd377 100644
--- a/misc/examples/read.c
+++ b/misc/examples/read.c
@@ -6,8 +6,8 @@
 cvec_str read_file(const char* name)
 {
     cvec_str vec = cvec_str_init();
-    c_with (FILE* f = fopen(name, "r"), fclose(f))
-        c_with (cstr line = cstr_NULL, cstr_drop(&line))
+    c_WITH (FILE* f = fopen(name, "r"), fclose(f))
+        c_WITH (cstr line = cstr_NULL, cstr_drop(&line))
             while (cstr_getline(&line, f))
                 cvec_str_push(&vec, cstr_clone(line));
     return vec;
@@ -16,8 +16,8 @@ cvec_str read_file(const char* name)
 int main()
 {
     int n = 0;
-    c_with (cvec_str vec = read_file(__FILE__), cvec_str_drop(&vec))
-        c_foreach (i, cvec_str, vec)
+    c_WITH (cvec_str vec = read_file(__FILE__), cvec_str_drop(&vec))
+        c_FOREACH (i, cvec_str, vec)
             printf("%5d: %s\n", ++n, cstr_str(i.ref));
 
     if (errno)
diff --git a/misc/examples/regex1.c b/misc/examples/regex1.c
index 7a22220d..9552db62 100644
--- a/misc/examples/regex1.c
+++ b/misc/examples/regex1.c
@@ -7,8 +7,8 @@ int main(int argc, char* argv[])
         printf("Usage: regex1 -i\n");
         return 0;
     }
-    c_auto (cstr, input)
-    c_auto (cregex, float_expr)
+    c_AUTO (cstr, input)
+    c_AUTO (cregex, float_expr)
     {
         int res = cregex_compile(&float_expr, "^[+-]?[0-9]+((\\.[0-9]*)?|\\.[0-9]+)$", CREG_DEFAULT);
         // Until "q" is given, ask for another number
diff --git a/misc/examples/regex2.c b/misc/examples/regex2.c
index dbf6aae4..55f8cfc2 100644
--- a/misc/examples/regex2.c
+++ b/misc/examples/regex2.c
@@ -13,8 +13,8 @@ int main()
         {"!((abc|123)+)!", "!123abcabc!"}
     };
 
-    c_auto (cregex, re)
-    c_forrange (i, c_arraylen(s))
+    c_AUTO (cregex, re)
+    c_FORRANGE (i, c_ARRAYLEN(s))
     {
         int res = cregex_compile(&re, s[i].pattern, CREG_DEFAULT);
         if (res < 0) {
@@ -23,8 +23,8 @@ int main()
         }
         printf("input: %s\n", s[i].input);
 
-        c_formatch (j, &re, s[i].input) {
-            c_forrange (k, cregex_captures(&re))
+        c_FORMATCH (j, &re, s[i].input) {
+            c_FORRANGE (k, cregex_captures(&re))
                 printf("  submatch %lld: %.*s\n", k, c_ARGSV(j.match[k]));
             puts("");
         }
diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c
index 376b002e..b6bd6521 100644
--- a/misc/examples/regex_match.c
+++ b/misc/examples/regex_match.c
@@ -12,19 +12,19 @@ int main()
                       " Boltzmann const: 1.38064852E-23, is very small."
                       " Bohrradius is 5.29177210903e-11, and Avogadros number is 6.02214076e23.";
 
-    c_auto (cregex, re)
-    c_auto (cstack_float, vec)
-    c_auto (cstr, nums)
+    c_AUTO (cregex, re)
+    c_AUTO (cstack_float, vec)
+    c_AUTO (cstr, nums)
     {
         const char* pattern = "[+-]?([0-9]*\\.)?\\d+([Ee][+-]?\\d+)?";
         int res = cregex_compile(&re, pattern, CREG_DEFAULT);
         printf("%d: %s\n", res, pattern);
 
         // extract and convert all numbers in str to floats
-        c_formatch (i, &re, str)
+        c_FORMATCH (i, &re, str)
             cstack_float_push(&vec, atof(i.match[0].str));
 
-        c_foreach (i, cstack_float, vec)
+        c_FOREACH (i, cstack_float, vec)
             printf("  %g\n", *i.ref);
 
         // extracts the numbers only to a comma separated string.
diff --git a/misc/examples/regex_replace.c b/misc/examples/regex_replace.c
index e296dfd8..d621c0db 100644
--- a/misc/examples/regex_replace.c
+++ b/misc/examples/regex_replace.c
@@ -17,7 +17,7 @@ int main()
     const char* pattern = "\\b(\\d\\d\\d\\d)-(1[0-2]|0[1-9])-(3[01]|[12][0-9]|0[1-9])\\b";
     const char* input = "start date: 2015-12-31, end date: 2022-02-28";
 
-    c_auto (cstr, str)
+    c_AUTO (cstr, str)
     {
         printf("INPUT: %s\n", input);
 
@@ -34,9 +34,9 @@ int main()
         printf("brack: %s\n", cstr_str(&str));
 
         /* Shows how to compile RE separately */
-        c_with (cregex re = cregex_from(pattern, CREG_DEFAULT), cregex_drop(&re)) {
+        c_WITH (cregex re = cregex_from(pattern, CREG_DEFAULT), cregex_drop(&re)) {
             if (cregex_captures(&re) == 0)
-                continue; /* break c_with */
+                continue; /* break c_WITH */
             /* European date format. */
             cstr_take(&str, cregex_replace(&re, input, "$3.$2.$1"));
             printf("euros: %s\n", cstr_str(&str));
diff --git a/misc/examples/replace.c b/misc/examples/replace.c
index 15cf3bae..ca305ecd 100644
--- a/misc/examples/replace.c
+++ b/misc/examples/replace.c
@@ -11,7 +11,7 @@ int main ()
     // Ustring positions:                                      0123456789*123456789*12345
     cstr s = cstr_from(base);                              // "this is a test string."
     cstr m = cstr_clone(s);
-    c_defer (cstr_drop(&s), cstr_drop(&m)) {
+    c_DEFER (cstr_drop(&s), cstr_drop(&m)) {
         cstr_append(&m, cstr_str(&m));
         cstr_append(&m, cstr_str(&m));
         printf("%s\n", cstr_str(&m));
diff --git a/misc/examples/shape.c b/misc/examples/shape.c
index a17208ef..4f7903da 100644
--- a/misc/examples/shape.c
+++ b/misc/examples/shape.c
@@ -38,7 +38,7 @@ void Shape_delete(Shape* shape)
 {
     if (shape) {
         shape->api->drop(shape);
-        c_free(shape);
+        c_FREE(shape);
     }
 }
 
@@ -111,7 +111,7 @@ static void Polygon_draw(const Shape* shape)
 {
     const Polygon* self = c_dyn_cast(Polygon, shape);
     printf("Polygon  :");
-    c_foreach (i, PointVec, self->points)
+    c_FOREACH (i, PointVec, self->points)
         printf(" (%g,%g)", i.ref->x, i.ref->y);
     puts("");
 }
@@ -137,23 +137,23 @@ void testShape(const Shape* shape)
 
 int main(void)
 {
-    c_auto (Shapes, shapes)
+    c_AUTO (Shapes, shapes)
     {
-        Triangle* tri1 = c_new(Triangle, Triangle_from((Point){5, 7}, (Point){12, 7}, (Point){12, 20}));
-        Polygon* pol1 = c_new(Polygon, Polygon_init());
-        Polygon* pol2 = c_new(Polygon, Polygon_init());
+        Triangle* tri1 = c_NEW(Triangle, Triangle_from((Point){5, 7}, (Point){12, 7}, (Point){12, 20}));
+        Polygon* pol1 = c_NEW(Polygon, Polygon_init());
+        Polygon* pol2 = c_NEW(Polygon, Polygon_init());
 
-        c_forlist (i, Point, {{50, 72}, {123, 73}, {127, 201}, {828, 333}})
+        c_FORLIST (i, Point, {{50, 72}, {123, 73}, {127, 201}, {828, 333}})
             Polygon_addPoint(pol1, *i.ref);
 
-        c_forlist (i, Point, {{5, 7}, {12, 7}, {12, 20}, {82, 33}, {17, 56}})
+        c_FORLIST (i, Point, {{5, 7}, {12, 7}, {12, 20}, {82, 33}, {17, 56}})
             Polygon_addPoint(pol2, *i.ref);
         
         Shapes_push(&shapes, &tri1->shape);
         Shapes_push(&shapes, &pol1->shape);
         Shapes_push(&shapes, &pol2->shape);
 
-        c_foreach (i, Shapes, shapes)
+        c_FOREACH (i, Shapes, shapes)
             testShape(*i.ref);
     }
 }
diff --git a/misc/examples/sidebyside.cpp b/misc/examples/sidebyside.cpp
index 80c934a4..ca80664d 100644
--- a/misc/examples/sidebyside.cpp
+++ b/misc/examples/sidebyside.cpp
@@ -25,7 +25,7 @@ int main() {
         std::cout << std::endl;
     }
     
-    c_auto (IIMap, hist)
+    c_AUTO (IIMap, hist)
     {
         IIMap_insert(&hist, 12, 100).ref->second += 1;
         IIMap_insert(&hist, 13, 100).ref->second += 1;
@@ -45,9 +45,9 @@ int main() {
         std::cout << std::endl;
     }
 
-    c_auto (SIMap, food)
+    c_AUTO (SIMap, food)
     {
-        c_forlist (i, SIMap_raw, {{"burger", 5}, {"pizza", 12}, {"steak", 15}})
+        c_FORLIST (i, SIMap_raw, {{"burger", 5}, {"pizza", 12}, {"steak", 15}})
             SIMap_emplace(&food, c_PAIR(i.ref));
         
         c_foreach (i, SIMap, food)
diff --git a/misc/examples/sorted_map.c b/misc/examples/sorted_map.c
index c4a05c76..47509edb 100644
--- a/misc/examples/sorted_map.c
+++ b/misc/examples/sorted_map.c
@@ -9,7 +9,7 @@ int main()
 { 
   
     // empty map containers
-    c_auto (csmap_int, gquiz1, gquiz2)
+    c_AUTO (csmap_int, gquiz1, gquiz2)
     { 
         // insert elements in random order 
         csmap_int_insert(&gquiz1, 2, 30); 
@@ -22,17 +22,17 @@ int main()
       
         // printing map gquiz1 
         printf("\nThe map gquiz1 is :\n\tKEY\tELEMENT\n"); 
-        c_foreach (itr, csmap_int, gquiz1)
+        c_FOREACH (itr, csmap_int, gquiz1)
             printf("\t%d\t%d\n", itr.ref->first, itr.ref->second);
         printf("\n");
       
         // assigning the elements from gquiz1 to gquiz2 
-        c_foreach (i, csmap_int, gquiz1) 
+        c_FOREACH (i, csmap_int, gquiz1) 
             csmap_int_insert(&gquiz2, i.ref->first, i.ref->second);
       
         // print all elements of the map gquiz2 
         printf("\nThe map gquiz2 is :\n\tKEY\tELEMENT\n"); 
-        c_foreach (itr, csmap_int, gquiz2)
+        c_FOREACH (itr, csmap_int, gquiz2)
             printf("\t%d\t%d\n", itr.ref->first, itr.ref->second);
         printf("\n");
       
@@ -41,7 +41,7 @@ int main()
         printf("\tKEY\tELEMENT\n");
         csmap_int_erase_range(&gquiz2, csmap_int_begin(&gquiz2), 
                                        csmap_int_find(&gquiz2, 3)); 
-        c_foreach (itr, csmap_int, gquiz2)
+        c_FOREACH (itr, csmap_int, gquiz2)
             printf("\t%d\t%d\n", itr.ref->first, itr.ref->second);
         printf("\n");
       
@@ -49,7 +49,7 @@ int main()
         int num = csmap_int_erase(&gquiz2, 4); 
         printf("\ngquiz2.erase(4) : %d removed\n", num); 
         printf("\tKEY\tELEMENT\n");
-        c_foreach (itr, csmap_int, gquiz2)
+        c_FOREACH (itr, csmap_int, gquiz2)
             printf("\t%d\t%d\n", itr.ref->first, itr.ref->second);
         printf("\n");
 
diff --git a/misc/examples/splitstr.c b/misc/examples/splitstr.c
index a3c12a3a..70d1935e 100644
--- a/misc/examples/splitstr.c
+++ b/misc/examples/splitstr.c
@@ -5,15 +5,15 @@
 
 int main()
 {
-    puts("Split with c_fortoken (csview):");
+    puts("Split with c_FORTOKEN (csview):");
 
-    c_fortoken (i, "Hello World C99!", " ")
+    c_FORTOKEN (i, "Hello World C99!", " ")
         printf("'%.*s'\n", c_ARGSV(i.token));
 
 
-    puts("\nSplit with c_formatch (regex):");
+    puts("\nSplit with c_FORMATCH (regex):");
 
-    c_with (cregex re = cregex_from("[^ ]+", CREG_DEFAULT), cregex_drop(&re))
-        c_formatch (i, &re, "  Hello   World      C99! ")
+    c_WITH (cregex re = cregex_from("[^ ]+", CREG_DEFAULT), cregex_drop(&re))
+        c_FORMATCH (i, &re, "  Hello   World      C99! ")
             printf("'%.*s'\n", c_ARGSV(i.match[0]));
 }
diff --git a/misc/examples/sso_map.c b/misc/examples/sso_map.c
index cc5e16a1..3627d101 100644
--- a/misc/examples/sso_map.c
+++ b/misc/examples/sso_map.c
@@ -5,11 +5,11 @@
 
 int main()
 {
-    c_auto (cmap_str, m) {
+    c_AUTO (cmap_str, m) {
         cmap_str_emplace(&m, "Test short", "This is a short string.");
         cmap_str_emplace(&m, "Test long ", "This is a longer string.");
 
-        c_forpair (k, v, cmap_str, m)
+        c_FORPAIR (k, v, cmap_str, m)
             printf("%s: '%s' Len=%" c_ZU ", Is long: %s\n", 
                    cstr_str(_.k), cstr_str(_.v), cstr_size(_.v),
                    cstr_is_long(_.v)?"true":"false");
diff --git a/misc/examples/sso_substr.c b/misc/examples/sso_substr.c
index be372a8d..8e7450ba 100644
--- a/misc/examples/sso_substr.c
+++ b/misc/examples/sso_substr.c
@@ -16,5 +16,5 @@ int main ()
     cstr s3 = cstr_from_sv(cstr_substr_ex(&str, 0, 6));    // "apples"
     printf("%s %s: %d, %d\n", cstr_str(&s2), cstr_str(&s3), 
                               cstr_is_long(&str), cstr_is_long(&s2));
-    c_drop (cstr, &str, &s2, &s3);
+    c_DROP (cstr, &str, &s2, &s3);
 }
diff --git a/misc/examples/stack.c b/misc/examples/stack.c
index a6a4a492..370577b9 100644
--- a/misc/examples/stack.c
+++ b/misc/examples/stack.c
@@ -11,18 +11,18 @@
 #include <stc/cstack.h>
 
 int main() {
-    c_auto (cstack_i, stack)
-    c_auto (cstack_c, chars)
+    c_AUTO (cstack_i, stack)
+    c_AUTO (cstack_c, chars)
     {
-        c_forrange (i, 101)
+        c_FORRANGE (i, 101)
             cstack_i_push(&stack, i*i);
 
         printf("%d\n", *cstack_i_top(&stack));
 
-        c_forrange (i, 90)
+        c_FORRANGE (i, 90)
             cstack_i_pop(&stack);
 
-        c_foreach (i, cstack_i, stack)
+        c_FOREACH (i, cstack_i, stack)
             printf(" %d", *i.ref);
         puts("");
         printf("top: %d\n", *cstack_i_top(&stack));
diff --git a/misc/examples/sview_split.c b/misc/examples/sview_split.c
index d22fccd1..5658924e 100644
--- a/misc/examples/sview_split.c
+++ b/misc/examples/sview_split.c
@@ -13,7 +13,7 @@ int  main()
 
     printf("%.*s, %.*s, %.*s\n", c_ARGSV(year), c_ARGSV(month), c_ARGSV(day));
 
-    c_auto (cstr, y, m, d) {
+    c_AUTO (cstr, y, m, d) {
         y = cstr_from_sv(year), m = cstr_from_sv(month), d = cstr_from_sv(day);
         printf("%s, %s, %s\n", cstr_str(&y), cstr_str(&m), cstr_str(&d));
     }
diff --git a/misc/examples/unordered_set.c b/misc/examples/unordered_set.c
index a0b639da..509f97e1 100644
--- a/misc/examples/unordered_set.c
+++ b/misc/examples/unordered_set.c
@@ -7,7 +7,7 @@
 int main()
 {
     // declaring set for storing string data-type
-    c_auto (cset_str, stringSet)
+    c_AUTO (cset_str, stringSet)
     {
         // inserting various string, same string will be stored
         // once in set
@@ -36,7 +36,7 @@ int main()
         // now iterating over whole set and printing its
         // content
         printf("All elements :\n");
-        c_foreach (itr, cset_str, stringSet)
+        c_FOREACH (itr, cset_str, stringSet)
             printf("%s\n", cstr_str(itr.ref));
     }
 }
diff --git a/misc/examples/utf8replace_c.c b/misc/examples/utf8replace_c.c
index 22a5c990..74b765dc 100644
--- a/misc/examples/utf8replace_c.c
+++ b/misc/examples/utf8replace_c.c
@@ -3,7 +3,7 @@
 #include <stc/csview.h>
 
 int main() {
-    c_auto (cstr, hello, upper) {
+    c_AUTO (cstr, hello, upper) {
         hello = cstr_lit("hell😀 w😀rld");
         printf("%s\n", cstr_str(&hello));
 
@@ -16,7 +16,7 @@ int main() {
 
         upper = cstr_toupper_sv(cstr_sv(&hello));
 
-        c_foreach (c, cstr, hello)
+        c_FOREACH (c, cstr, hello)
             printf("%.*s,", c_ARGSV(c.u8.chr));
         puts("");
     }
diff --git a/misc/examples/vikings.c b/misc/examples/vikings.c
index 26a74757..c65a9caa 100644
--- a/misc/examples/vikings.c
+++ b/misc/examples/vikings.c
@@ -50,7 +50,7 @@ static inline RViking Viking_toraw(const Viking* vp) {
 
 int main()
 {
-    c_auto (Vikings, vikings) {
+    c_AUTO (Vikings, vikings) {
         Vikings_emplace(&vikings, (RViking){"Einar", "Norway"}, 20);
         Vikings_emplace(&vikings, (RViking){"Olaf", "Denmark"}, 24);
         Vikings_emplace(&vikings, (RViking){"Harald", "Iceland"}, 12);
@@ -59,7 +59,7 @@ int main()
         Vikings_value* v = Vikings_get_mut(&vikings, (RViking){"Einar", "Norway"});
         v->second += 3; // add 3 hp points to Einar
 
-        c_forpair (vk, hp, Vikings, vikings) {
+        c_FORPAIR (vk, hp, Vikings, vikings) {
             printf("%s of %s has %d hp\n", cstr_str(&_.vk->name), cstr_str(&_.vk->country), *_.hp);
         }
     }
diff --git a/misc/examples/words.c b/misc/examples/words.c
index 097447aa..b945092f 100644
--- a/misc/examples/words.c
+++ b/misc/examples/words.c
@@ -10,19 +10,19 @@
 
 int main1()
 {
-    c_auto (cvec_str, words)
-    c_auto (cmap_str, word_map)
+    c_AUTO (cvec_str, words)
+    c_AUTO (cmap_str, word_map)
     {
-        c_forlist (i, const char*, {
+        c_FORLIST (i, const char*, {
             "this", "sentence", "is", "not", "a", "sentence",
             "this", "sentence", "is", "a", "hoax"
         }) cvec_str_emplace_back(&words, *i.ref);
 
-        c_foreach (w, cvec_str, words) {
+        c_FOREACH (w, cvec_str, words) {
             cmap_str_emplace(&word_map, cstr_str(w.ref), 0).ref->second += 1;
         }
 
-        c_foreach (i, cmap_str, word_map) {
+        c_FOREACH (i, cmap_str, word_map) {
             printf("%d occurrences of word '%s'\n",
                    i.ref->second, cstr_str(&i.ref->first));
         }
diff --git a/misc/tests/cregex_test.c b/misc/tests/cregex_test.c
index b9642159..cd812aa2 100644
--- a/misc/tests/cregex_test.c
+++ b/misc/tests/cregex_test.c
@@ -49,7 +49,7 @@ END_TEST
 
 START_TEST(compile_match_quantifiers)
 {
-    c_auto (cregex, re) {
+    c_AUTO (cregex, re) {
         re = cregex_from("ä+", 0);
         EXPECT_EQ(re.error, 0);
 
@@ -64,7 +64,7 @@ START_TEST(compile_match_quantifiers)
 
         EXPECT_FALSE(cregex_find("bbb", &re, &match, 0));
     }
-    c_auto (cregex, re) {
+    c_AUTO (cregex, re) {
         re = cregex_from("bä*", 0);
         EXPECT_EQ(re.error, 0);
 
@@ -99,7 +99,7 @@ END_TEST
 
 START_TEST(compile_match_class_simple)
 {
-    c_auto (cregex, re1, re2, re3)
+    c_AUTO (cregex, re1, re2, re3)
     {
         re1 = cregex_from("\\s", 0);
         EXPECT_EQ(re1.error, 0);
@@ -125,7 +125,7 @@ END_TEST
 
 START_TEST(compile_match_or)
 {
-    c_auto (cregex, re, re2)
+    c_AUTO (cregex, re, re2)
     {
         re = cregex_from("as|df", 0);
         EXPECT_EQ(re.error, 0);
@@ -190,7 +190,7 @@ END_TEST
 
 START_TEST(search_all)
 {
-    c_auto (cregex, re)
+    c_AUTO (cregex, re)
     {
         re = cregex_from("ab", 0);
         csview m = {0};
@@ -210,7 +210,7 @@ END_TEST
 
 START_TEST(captures_len)
 {
-    c_auto (cregex, re) {
+    c_AUTO (cregex, re) {
        cregex re = cregex_from("(ab(cd))(ef)", 0);
        EXPECT_EQ(cregex_captures(&re), 3);
     }
@@ -219,7 +219,7 @@ END_TEST
 
 START_TEST(captures_cap)
 {
-    c_auto (cregex, re) {
+    c_AUTO (cregex, re) {
         re = cregex_from("(ab)((cd)+)", 0);
         EXPECT_EQ(cregex_captures(&re), 3);
 
diff --git a/src/checkauto.l b/src/checkauto.l
index 541bbf3f..c42d97cf 100644
--- a/src/checkauto.l
+++ b/src/checkauto.l
@@ -36,6 +36,15 @@ c_forpair       |
 c_forrange      |
 c_forfilter     |
 c_forwhile      |
+c_formatch      |
+c_fortoken      |
+c_FOREACH       |
+c_FORPAIR       |
+c_FORRANGE      |
+c_FORFILTER     |
+c_FORWHILE      |
+c_FORMATCH      |
+c_FORTOKEN      |
 for             |
 while           |
 switch          { block_type |= LOOP; state = BRACES; }