2nd try to please Jekyll...

tylov · tylov · commit 01f2a20efeef · 2025-01-10T16:02:44.000+01:00
diff --git a/README.md b/README.md
@@ -295,6 +295,7 @@ int main(void)
 This example uses four different container types:
 
 [ [Run this code](https://godbolt.org/z/n1z16bdTr) ]
+<!--{%raw%}-->
 ```c++
 #include <stdio.h>
 
@@ -329,8 +330,8 @@ int main(void)
     ){
         enum{N = 5};
         int nums[N] = {10, 20, 30, 40, 50};
-        struct Point pts[N] = { {10, 1}, {20, 2}, {30, 3}, {40, 4}, {50, 5}};
-        int pairs[N][2] = { {20, 2}, {10, 1}, {30, 3}, {40, 4}, {50, 5}};
+        struct Point pts[N] = {{10, 1}, {20, 2}, {30, 3}, {40, 4}, {50, 5}};
+        int pairs[N][2] = {{20, 2}, {10, 1}, {30, 3}, {40, 4}, {50, 5}};
 
         // Add some elements to each container
         for (int i = 0; i < N; ++i) {
@@ -375,7 +376,7 @@ int main(void)
     }
 }
 ```
-
+<!--{%endraw%}-->
 Output
 ```
 Found: 20, (20, 2), 20, [20: 2]
diff --git a/docs/algorithm_api.md b/docs/algorithm_api.md
@@ -22,12 +22,12 @@ descriptive and reduces chances of making mistakes. It is generally easier to re
 | `c_foreach_reverse (it, ctype, it1, it2)`| Iteratate range [it1, it2) elements in reverse. |
 | `c_foreach_n (it, ctype, container, n)`| Iteratate `n` first elements. Index variable is `{it}_index`. |
 | `c_foreach_kv (key, val, ctype, container)` | Iterate maps with "structured binding" |
-
+<!--{%raw%}-->
 ```c++
 #define i_type IMap, int, int
 #include "stc/smap.h"
 // ...
-IMap map = c_make(IMap, { {23,1}, {3,2}, {7,3}, {5,4}, {12,5}});
+IMap map = c_make(IMap, {{23,1}, {3,2}, {7,3}, {5,4}, {12,5}});
 
 c_foreach (i, IMap, map)
     printf(" %d", i.ref->first);
@@ -52,25 +52,28 @@ c_foreach_n (i, IMap, map, 3)
 c_foreach_kv (id, count, IMap, map)
     printf(" (%d %d)", *id, *count);
 ```
+<!--{%endraw%}-->
 </details>
 <details>
 <summary><b>c_foritems</b> - Literal list iteration</summary>
 
 ### c_foritems
 Iterate compound literal array elements. In addition to `i.ref`, you can access `i.index` and `i.size`.
+<!--{%raw%}-->
 ```c++
 // apply multiple push_backs
 c_foritems (i, int, {4, 5, 6, 7})
     list_i_push_back(&lst, *i.ref);
 
 // insert in existing map
-c_foritems (i, hmap_ii_value, { {4, 5}, {6, 7}})
+c_foritems (i, hmap_ii_value, {{4, 5}, {6, 7}})
     hmap_ii_insert(&map, i.ref->first, i.ref->second);
 
 // string literals pushed to a stack of cstr elements:
 c_foritems (i, const char*, {"Hello", "crazy", "world"})
     stack_cstr_emplace(&stk, *i.ref);
 ```
+<!--{%endraw%}-->
 </details>
 
 ## Integer range loops
@@ -405,6 +408,7 @@ These work on any container. *c_make()* may also be used for **cspan** views.
 - **c_drop** - drop (destroy) multiple containers of the same type
 
 [ [Run this code](https://godbolt.org/z/K9Y5EMGxM) ]
+<!--{%raw%}-->
 ```c++
 #include <stdio.h>
 #define i_type Vec, int
@@ -424,10 +428,10 @@ c_func (split_map,(Map map), ->, struct {Vec keys, values;}) {
 
 int main(void) {
     Vec vec = c_make(Vec, {1, 2, 3, 4, 5, 6});
-    Map map = c_make(Map, { {1, 2}, {3, 4}, {5, 6}});
+    Map map = c_make(Map, {{1, 2}, {3, 4}, {5, 6}});
 
     c_push(Vec, &vec, {7, 8, 9, 10, 11, 12});
-    c_push(Map, &map, { {7, 8}, {9, 10}, {11, 12}});
+    c_push(Map, &map, {{7, 8}, {9, 10}, {11, 12}});
 
     c_foreach (i, Vec, vec)
         printf("%d ", *i.ref);
@@ -447,6 +451,7 @@ int main(void) {
     c_drop(Map, &map);
 }
 ```
+<!--{%endraw%}-->
 </details>
 <details>
 <summary><b>c_find, c_copy, c_erase</b> - Container operations with custom predicate</summary>
@@ -474,6 +479,7 @@ Copy linearily in containers using a predicate. `value` is a pointer to each ele
 Erase linearily in containers using a predicate. `value` is a pointer to each element in predicate.
 - `c_erase_if(CntType, cnt_ptr, pred)`. Use with **list**, **hmap**, **hset**, **smap**, and **sset**.
 - `c_eraseremove_if(CntType, cnt_ptr, pred)`. Use with **stack**, **vec**, **deque**, and **queue** only.
+<!--{%raw%}-->
 ```c++
 #include <stdio.h>
 #include "stc/cstr.h"
@@ -521,7 +527,7 @@ int main(void)
     puts("");
 
     // Search a sorted map from it1, for the first string containing "hello" and erase it:
-    Map map = c_make(Map, { {"yes",1}, {"no",2}, {"say hello from me",3}, {"goodbye",4}});
+    Map map = c_make(Map, {{"yes",1}, {"no",2}, {"say hello from me",3}, {"goodbye",4}});
     Map_iter res, it1 = Map_begin(&map);
 
     c_find_if(Map, it1, Map_end(&map), &res, cstr_contains(&value->first, "hello"));
@@ -536,6 +542,7 @@ int main(void)
     Map_drop(&map);
 }
 ```
+<!--{%endraw%}-->
 </details>
 <details>
 <summary><b>c_all_of, c_any_of, c_none_of</b> - Boolean container operations</summary>
diff --git a/docs/arc_api.md b/docs/arc_api.md
@@ -90,6 +90,7 @@ bool            arc_X_value_eq(const i_key* x, const i_key* y);
 ## Example
 
 [ [Run this code](https://godbolt.org/z/bjrf47qbv) ]
+<!--{%raw%}-->
 ```c++
 // Create two stacks with arcs to maps.
 // Demonstrate sharing and cloning of maps.
@@ -117,15 +118,15 @@ int main(void)
 
     // POPULATE s1 with shared pointers to Map:
     map = Stack_push(&s1, Arc_from(Map_init()))->get; // push empty map to s1.
-    c_push(Map, map, { {"Joey", 1990}, {"Mary", 1995},
+    c_push(Map, map, {{"Joey", 1990}, {"Mary", 1995},
                       {"Mary", 1996}, {"Joanna", 1992}});
 
     map = Stack_emplace(&s1, Map_init())->get; // emplace will make the Arc
-    c_push(Map, map, { {"Rosanna", 2001}, {"Brad", 1999}, {"Jack", 1980}});
+    c_push(Map, map, {{"Rosanna", 2001}, {"Brad", 1999}, {"Jack", 1980}});
 
     // POPULATE s2:
     map = Stack_emplace(&s2, Map_init())->get;
-    c_push(Map, map, { {"Steve", 1979}, {"Rick", 1974}, {"Tracy", 2003}});
+    c_push(Map, map, {{"Steve", 1979}, {"Rick", 1974}, {"Tracy", 2003}});
 
 
     // Share Arc 1 from s1 with s2 by cloning(=sharing):
@@ -142,3 +143,4 @@ int main(void)
     c_drop(Stack, &s1, &s2);
 }
 ```
+<!--{%endraw%}-->
diff --git a/docs/coroutine_api.md b/docs/coroutine_api.md
@@ -330,6 +330,7 @@ current task. Because the "call-tree" is fixed, the coroutine frames to be calle
 which is very fast.
 
 [ [Run this code](https://godbolt.org/z/z1WWPhsan) ]
+<!--{%raw%}-->
 ```c++
 #include <stdio.h>
 #include "stc/coroutine.h"
@@ -410,17 +411,18 @@ int start(cco_task* self, cco_runtime* rt) {
 int main(void)
 {
     Subtasks env = {
-        { {taskA}, 42},
-        { {taskB}, 3.1415},
-        { {taskC}, 1.2f, 3.4f},
+        {{taskA}, 42},
+        {{taskB}, 3.1415},
+        {{taskC}, 1.2f, 3.4f},
     };
-    cco_task task = { {start}};
+    cco_task task = {{start}};
 
     int count = 0;
     cco_run_task(&task, &env) { ++count; }
     printf("resumes: %d\n", count);
 }
 ```
+<!--{%endraw%}-->
 </details>
 
 #### Stackful coroutines allocated on the heap
@@ -435,6 +437,7 @@ call/await:
 <summary>Implementation of stackful coroutines</summary>
 
 [ [Run this code](https://godbolt.org/z/TbWYsbaaq) ]
+<!--{%raw%}-->
 ```c++
 #include <stdio.h>
 #include "stc/coroutine.h"
@@ -471,7 +474,7 @@ int taskC(struct TaskC* self, cco_runtime* rt) {
 int taskB(struct TaskB* self, cco_runtime* rt) {
     cco_routine (self) {
         printf("TaskB start: %g\n", self->d);
-        cco_await_task(c_new(struct TaskC, { {taskC}, 1.2f, 3.4f}), rt);
+        cco_await_task(c_new(struct TaskC, {{taskC}, 1.2f, 3.4f}), rt);
         puts("TaskB work");
         ((Result *)rt->env)->value += self->d;
 
@@ -485,7 +488,7 @@ int taskB(struct TaskB* self, cco_runtime* rt) {
 int taskA(struct TaskA* self, cco_runtime* rt) {
     cco_routine (self) {
         printf("TaskA start: %d\n", self->a);
-        cco_await_task(c_new(struct TaskB, { {taskB}, 3.1415}), rt);
+        cco_await_task(c_new(struct TaskB, {{taskB}, 3.1415}), rt);
         puts("TaskA work");
         ((Result *)rt->env)->value += self->a; // final return value;
 
@@ -505,7 +508,7 @@ int taskA(struct TaskA* self, cco_runtime* rt) {
 int start(cco_task* self, cco_runtime* rt) {
     cco_routine (self) {
         puts("start");
-        cco_await_task(c_new(struct TaskA, { {taskA}, 42}), rt);
+        cco_await_task(c_new(struct TaskA, {{taskA}, 42}), rt);
 
         cco_finally:
         puts("done");
@@ -516,7 +519,7 @@ int start(cco_task* self, cco_runtime* rt) {
 
 int main(void)
 {
-    cco_task* task = c_new(cco_task, { {start}});
+    cco_task* task = c_new(cco_task, {{start}});
 
     int count = 0;
     Result result = {0};
@@ -526,6 +529,7 @@ int main(void)
     printf("resumes: %d\n", count);
 }
 ```
+<!--{%endraw%}-->
 </details>
 
 ----
diff --git a/docs/hmap_api.md b/docs/hmap_api.md
@@ -286,6 +286,7 @@ In this example we use keyraw feature to make it simpler to use and avoids the c
 entirely when doing lookup.
 
 [ [Run this code](https://godbolt.org/z/Yx1Ybhxqv) ]
+<!--{%raw%}-->
 ```c++
 #include "stc/cstr.h"
 
@@ -340,9 +341,9 @@ Viking_raw Viking_toraw(const Viking* vp) {
 int main(void)
 {
     Vikings vikings = c_make(Vikings, {
-        { {"Einar", "Norway"}, 25},
-        { {"Olaf", "Denmark"}, 24},
-        { {"Harald", "Iceland"}, 12},
+        {{"Einar", "Norway"}, 25},
+        {{"Olaf", "Denmark"}, 24},
+        {{"Harald", "Iceland"}, 12},
     });
 
     // Now lookup is using Viking_raw, not Viking:
@@ -355,3 +356,4 @@ int main(void)
     Vikings_drop(&vikings);
 }
 ```
+<!--{%endraw%}-->
diff --git a/docs/smap_api.md b/docs/smap_api.md
@@ -192,6 +192,7 @@ int main(void)
 This example uses a smap with cstr as mapped value. Note the `i_valpro` usage.
 
 [ [Run this code](https://godbolt.org/z/M397fG7fM) ]
+<!--{%raw%}-->
 ```c++
 #include "stc/cstr.h"
 
@@ -203,7 +204,7 @@ This example uses a smap with cstr as mapped value. Note the `i_valpro` usage.
 int main(void)
 {
     uint32_t col = 0xcc7744ff;
-    IdMap idnames = c_make(IdMap, { {100, "Red"}, {110, "Blue"}});
+    IdMap idnames = c_make(IdMap, {{100, "Red"}, {110, "Blue"}});
 
     // Assign/overwrite an existing mapped value with a const char*
     IdMap_emplace_or_assign(&idnames, 110, "White");
@@ -220,6 +221,7 @@ int main(void)
     IdMap_drop(&idnames);
 }
 ```
+<!--{%endraw%}-->
 
 ### Example 4
 Demonstrate smap with plain-old-data key type Vec3i and int as mapped type: smap<Vec3i, int>.
