From 900295256d825fc323149cd223c49787f32a3696 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Thu, 20 Jul 2023 15:09:10 +0200
Subject: Moved examples to sub-directories. Added cotask1.c cotask2.c
 examples.

---
 misc/examples/smartpointers/arc_containers.c  | 81 ++++++++++++++++++++++++++
 misc/examples/smartpointers/arc_demo.c        | 62 ++++++++++++++++++++
 misc/examples/smartpointers/arcvec_erase.c    | 50 ++++++++++++++++
 misc/examples/smartpointers/box.c             | 69 ++++++++++++++++++++++
 misc/examples/smartpointers/box2.c            | 82 +++++++++++++++++++++++++++
 misc/examples/smartpointers/music_arc.c       | 67 ++++++++++++++++++++++
 misc/examples/smartpointers/new_sptr.c        | 75 ++++++++++++++++++++++++
 misc/examples/smartpointers/person_arc.c      | 77 +++++++++++++++++++++++++
 misc/examples/smartpointers/rawptr_elements.c | 59 +++++++++++++++++++
 9 files changed, 622 insertions(+)
 create mode 100644 misc/examples/smartpointers/arc_containers.c
 create mode 100644 misc/examples/smartpointers/arc_demo.c
 create mode 100644 misc/examples/smartpointers/arcvec_erase.c
 create mode 100644 misc/examples/smartpointers/box.c
 create mode 100644 misc/examples/smartpointers/box2.c
 create mode 100644 misc/examples/smartpointers/music_arc.c
 create mode 100644 misc/examples/smartpointers/new_sptr.c
 create mode 100644 misc/examples/smartpointers/person_arc.c
 create mode 100644 misc/examples/smartpointers/rawptr_elements.c

(limited to 'misc/examples/smartpointers')

diff --git a/misc/examples/smartpointers/arc_containers.c b/misc/examples/smartpointers/arc_containers.c
new file mode 100644
index 00000000..2fb04c56
--- /dev/null
+++ b/misc/examples/smartpointers/arc_containers.c
@@ -0,0 +1,81 @@
+// Create a stack and a list of shared pointers to maps,
+// and demonstrate sharing and cloning of maps.
+#define i_implement
+#include <stc/cstr.h>
+#include <stc/algo/raii.h>
+#define i_type Map
+#define i_key_str // strings
+#define i_val int
+#define i_keydrop(p) (printf("drop name: %s\n", cstr_str(p)), cstr_drop(p))
+#include <stc/csmap.h>
+
+#define i_type Arc // (atomic) ref. counted type
+#define i_key Map
+#define i_keydrop(p) (printf("drop Arc:\n"), Map_drop(p))
+// no need for atomic ref. count in single thread:
+#define i_opt c_no_atomic
+#include <stc/carc.h>
+
+#define i_type Stack
+#define i_keyboxed Arc // define i_keyboxed for carc/cbox value (not i_key)
+#include <stc/cvec.h>
+
+#define i_type List
+#define i_keyboxed Arc // as above
+#include <stc/clist.h>
+
+int main(void)
+{
+    Stack stack = {0};
+    List list = {0};
+    c_defer(
+        Stack_drop(&stack),
+        List_drop(&list)
+    ){
+        // POPULATE stack with shared pointers to Maps:
+        Map *map;
+        map = Stack_push(&stack, Arc_from(Map_init()))->get;
+        Map_emplace(map, "Joey", 1990);
+        Map_emplace(map, "Mary", 1995);
+        Map_emplace(map, "Joanna", 1992);
+
+        map = Stack_push(&stack, Arc_from(Map_init()))->get;
+        Map_emplace(map, "Rosanna", 2001);
+        Map_emplace(map, "Brad", 1999);
+        Map_emplace(map, "Jack", 1980);
+
+        // POPULATE list:
+        map = List_push_back(&list, Arc_from(Map_init()))->get;
+        Map_emplace(map, "Steve", 1979);
+        Map_emplace(map, "Rick", 1974);
+        Map_emplace(map, "Tracy", 2003);
+
+        // Share two Maps from the stack with the list using emplace (clone the carc):
+        List_push_back(&list, Arc_clone(stack.data[0]));
+        List_push_back(&list, Arc_clone(stack.data[1]));
+
+        // Clone (deep copy) a Map from the stack to the list
+        // List will contain two shared and two unshared maps.
+        map = List_push_back(&list, Arc_from(Map_clone(*stack.data[1].get)))->get;
+
+        // Add one more element to the cloned map:
+        Map_emplace_or_assign(map, "CLONED", 2021);
+
+        // Add one more element to the shared map:
+        Map_emplace_or_assign(stack.data[1].get, "SHARED", 2021);
+
+        puts("STACKS");
+        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)
+                printf(" %s:%d", cstr_str(_.name), *_.year);
+            puts("");
+        }
+    }
+}
diff --git a/misc/examples/smartpointers/arc_demo.c b/misc/examples/smartpointers/arc_demo.c
new file mode 100644
index 00000000..929a48a1
--- /dev/null
+++ b/misc/examples/smartpointers/arc_demo.c
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <string.h>
+
+void int_drop(int* x) {
+    printf("drop: %d\n", *x);
+}
+
+// carc implements its own clone method using reference counting,
+// so 'i_keyclone' is not required to be defined (ignored).
+
+#define i_type Arc          // set type name to be defined (instead of 'carc_int')
+#define i_key int
+#define i_keydrop int_drop  // optional, just to display the elements destroyed
+#define i_cmp_native        // use int comparison (x < y, x == y).
+#include <stc/carc.h>       // Arc
+
+#define i_keyboxed Arc      // note: use i_keyboxed instead of i_key for carc/cbox elements
+#include <stc/csset.h>      // csset_Arc (like: std::set<std::shared_ptr<int>>)
+
+#define i_keyboxed Arc      // note: as above.
+#include <stc/cvec.h>       // cvec_Arc (like: std::vector<std::shared_ptr<int>>)
+
+int main(void)
+{
+    const int years[] = {2021, 2012, 2022, 2015};
+
+    cvec_Arc vec = {0};
+    c_forrange (i, c_arraylen(years)) {
+        cvec_Arc_emplace(&vec, years[i]);
+        // cvec_Arc_push(&vec, Arc_from(years[i])); // alt.
+    }
+
+    cvec_Arc_sort(&vec);
+
+    printf("vec:");
+    c_foreach (i, cvec_Arc, vec)
+        printf(" %d", *i.ref->get);
+    puts("");
+
+    // add odd numbers from vec to set
+    csset_Arc set = {0};
+    c_foreach (i, cvec_Arc, vec)
+        if (*i.ref->get & 1)
+            csset_Arc_insert(&set, Arc_clone(*i.ref)); // copy shared pointer => increments counter.
+
+    // erase the two last elements in vec
+    cvec_Arc_pop_back(&vec);
+    cvec_Arc_pop_back(&vec);
+
+    printf("vec:");
+    c_foreach (i, cvec_Arc, vec) printf(" %d", *i.ref->get);
+
+    printf("\nset:");
+    c_foreach (i, csset_Arc, set) printf(" %d", *i.ref->get);
+
+    Arc p = Arc_clone(vec.data[0]);
+    printf("\n%d is now owned by %ld objects\n", *p.get, *p.use_count);
+
+    Arc_drop(&p);
+    cvec_Arc_drop(&vec);
+    csset_Arc_drop(&set);
+}
diff --git a/misc/examples/smartpointers/arcvec_erase.c b/misc/examples/smartpointers/arcvec_erase.c
new file mode 100644
index 00000000..ba54c1c7
--- /dev/null
+++ b/misc/examples/smartpointers/arcvec_erase.c
@@ -0,0 +1,50 @@
+#include <stdio.h>
+
+void show_drop(int* x) { printf("drop: %d\n", *x); }
+
+#define i_type Arc
+#define i_key int
+#define i_keydrop show_drop
+#define i_cmp_native        // enable sort/search for int type
+#include <stc/carc.h>       // Shared pointer to int
+
+#define i_type Vec
+#define i_keyboxed Arc
+#include <stc/cvec.h>       // Vec: cvec<Arc>
+
+
+int main(void)
+{
+    Vec vec = c_init(Vec, {2012, 1990, 2012, 2019, 2015});
+    
+    // clone the second 2012 and push it back.
+    // note: cloning make sure that vec.data[2] has ref count 2.
+    Vec_push(&vec, Arc_clone(vec.data[2]));
+    
+    printf("vec before erase :");
+    c_foreach (i, Vec, vec)
+        printf(" %d", *i.ref->get);
+
+    printf("\nerase vec.data[2]; or first matching value depending on compare.\n");
+    Vec_iter it;
+    it = Vec_find(&vec, *vec.data[2].get);
+    if (it.ref)
+        Vec_erase_at(&vec, it);
+
+    int year = 2015;
+    it = Vec_find(&vec, year); // Ok as tmp only.
+    if (it.ref)
+        Vec_erase_at(&vec, it);
+
+    printf("vec after erase  :");
+    c_foreach (i, Vec, vec)
+        printf(" %d", *i.ref->get);
+
+    Vec_sort(&vec);
+    printf("\nvec after sort   :");
+    c_foreach (i, Vec, vec)
+        printf(" %d", *i.ref->get);
+    
+    puts("\nDone");
+    Vec_drop(&vec);
+}
diff --git a/misc/examples/smartpointers/box.c b/misc/examples/smartpointers/box.c
new file mode 100644
index 00000000..94d126c0
--- /dev/null
+++ b/misc/examples/smartpointers/box.c
@@ -0,0 +1,69 @@
+/* cbox: heap allocated boxed type */
+#define i_implement
+#include <stc/cstr.h>
+
+typedef struct { cstr name, last; } Person;
+
+Person Person_make(const char* name, const char* last) {
+    return c_LITERAL(Person){.name = cstr_from(name), .last = cstr_from(last)};
+}
+
+uint64_t Person_hash(const Person* a) {
+    return cstr_hash(&a->name) ^ cstr_hash(&a->last);
+}
+
+int Person_cmp(const Person* a, const Person* b) {
+    int c = cstr_cmp(&a->name, &b->name);
+    return c ? c : cstr_cmp(&a->last, &b->last);
+}
+
+Person Person_clone(Person p) {
+    p.name = cstr_clone(p.name);
+    p.last = cstr_clone(p.last);
+    return 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);
+}
+
+#define i_type PBox
+#define i_keyclass Person // "class" binds _cmp, _clone, _drop functions.
+#include <stc/cbox.h>
+
+#define i_type Persons
+#define i_keyboxed PBox // "arcbox" informs that PBox is a smart pointer.
+#include <stc/csset.h>
+
+int main(void)
+{
+    Persons vec = {0};
+    PBox p = PBox_from(Person_make("Laura", "Palmer"));
+    PBox q = PBox_clone(p);
+    cstr_assign(&q.get->name, "Leland");
+
+    printf("orig: %s %s\n", cstr_str(&p.get->name), cstr_str(&p.get->last));
+    printf("copy: %s %s\n", cstr_str(&q.get->name), cstr_str(&q.get->last));
+
+    Persons_emplace(&vec, Person_make("Dale", "Cooper"));
+    Persons_emplace(&vec, Person_make("Audrey", "Home"));
+
+    // NB! Clone/share p and q in the Persons container.
+    Persons_push(&vec, PBox_clone(p));
+    Persons_push(&vec, PBox_clone(q));
+
+    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.
+    Person a = Person_make("Audrey", "Home");
+    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));
+
+    Person_drop(&a);
+    PBox_drop(&p);
+    PBox_drop(&q);
+    Persons_drop(&vec);
+}
diff --git a/misc/examples/smartpointers/box2.c b/misc/examples/smartpointers/box2.c
new file mode 100644
index 00000000..eaab1c47
--- /dev/null
+++ b/misc/examples/smartpointers/box2.c
@@ -0,0 +1,82 @@
+// example: https://doc.rust-lang.org/rust-by-example/std/box.html
+#include <stdio.h>
+
+typedef struct {
+    double x;
+    double y;
+} Point;
+
+// A Rectangle can be specified by where its top left and bottom right
+// corners are in space
+typedef struct {
+    Point top_left;
+    Point bottom_right;
+} Rectangle;
+
+#define i_key Point
+#include <stc/cbox.h> // cbox_Point
+
+#define i_key Rectangle
+#include <stc/cbox.h> // cbox_Rectangle
+
+// Box in box:
+#define i_type BoxBoxPoint
+#define i_keyboxed cbox_Point // NB: use i_keyboxed when value is a cbox or carc!
+#define i_no_cmp
+#include <stc/cbox.h> // BoxBoxPoint
+
+Point origin(void) {
+    return c_LITERAL(Point){ .x=1.0, .y=2.0 };
+}
+
+cbox_Point boxed_origin(void) {
+    // Allocate this point on the heap, and return a pointer to it
+    return cbox_Point_make(c_LITERAL(Point){ .x=1.0, .y=2.0 });
+}
+
+
+int main(void) {
+    // Stack allocated variables
+    Point point = origin();
+    Rectangle rectangle = {
+        .top_left = origin(),
+        .bottom_right = { .x=3.0, .y=-4.0 }
+    };
+
+    // Heap allocated rectangle
+    cbox_Rectangle boxed_rectangle = cbox_Rectangle_make(c_LITERAL(Rectangle){
+        .top_left = origin(),
+        .bottom_right = { .x=3.0, .y=-4.0 }
+    });
+    // The output of functions can be boxed
+    cbox_Point boxed_point = cbox_Point_make(origin());
+
+    // Can use from(raw) and toraw instead:
+    BoxBoxPoint box_in_a_box = BoxBoxPoint_from(origin());
+
+    c_defer(
+        BoxBoxPoint_drop(&box_in_a_box),
+        cbox_Point_drop(&boxed_point),
+        cbox_Rectangle_drop(&boxed_rectangle)
+    ){
+        printf("box_in_a_box: x = %g\n", BoxBoxPoint_toraw(&box_in_a_box).x);
+
+        printf("Point occupies %d bytes on the stack\n",
+                (int)sizeof(point));
+        printf("Rectangle occupies %d bytes on the stack\n",
+                (int)sizeof(rectangle));
+
+        // box size == pointer size
+        printf("Boxed point occupies %d bytes on the stack\n",
+                (int)sizeof(boxed_point));
+        printf("Boxed rectangle occupies %d bytes on the stack\n",
+                (int)sizeof(boxed_rectangle));
+        printf("Boxed box occupies %d bytes on the stack\n",
+                (int)sizeof(box_in_a_box));
+
+        // Copy the data contained in `boxed_point` into `unboxed_point`
+        Point unboxed_point = *boxed_point.get;
+        printf("Unboxed point occupies %d bytes on the stack\n",
+                (int)sizeof(unboxed_point));
+    }
+}
diff --git a/misc/examples/smartpointers/music_arc.c b/misc/examples/smartpointers/music_arc.c
new file mode 100644
index 00000000..16111b0b
--- /dev/null
+++ b/misc/examples/smartpointers/music_arc.c
@@ -0,0 +1,67 @@
+// shared_ptr-examples.cpp
+// based on https://docs.microsoft.com/en-us/cpp/cpp/how-to-create-and-use-shared-ptr-instances?view=msvc-160
+#define i_implement
+#include <stc/cstr.h>
+
+typedef struct
+{
+    cstr artist;
+    cstr title;
+} Song;
+
+int Song_cmp(const Song* x, const Song* y)
+    { return cstr_cmp(&x->title, &y->title); }
+
+Song Song_make(const char* artist, const char* title)
+    { return c_LITERAL(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);
+}
+
+// Define the shared pointer:
+#define i_type SongArc
+#define i_keyclass Song
+#define i_no_hash          // no hash fn for Song, fallback hash pointer to Song.
+#include <stc/carc.h>
+
+// ... and a vector of them
+#define i_type SongVec
+#define i_keyboxed SongArc // use i_keyboxed on carc / cbox (instead of i_key)
+#include <stc/cvec.h>
+
+void example3(void)
+{
+    SongVec vec1 = c_init(SongVec, {
+        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 vec2 = {0};
+    // Share all entries in vec with vec2, except Bob Dylan.
+    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
+    // Emplace calls SongArc_from() on the argument to create the Arc:
+    SongVec_emplace(&vec2, Song_make("Michael Jackson", "Billie Jean"));
+    SongVec_emplace(&vec2, Song_make("Rihanna", "Stay"));
+
+    // We now have two vectors with some shared, some unique entries.
+    c_forlist (i, SongVec, {vec1, vec2}) {
+        puts("VEC:");
+        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);
+    }
+    c_drop(SongVec, &vec1, &vec2);
+}
+
+int main(void)
+{
+    example3();
+}
diff --git a/misc/examples/smartpointers/new_sptr.c b/misc/examples/smartpointers/new_sptr.c
new file mode 100644
index 00000000..3c6fa16c
--- /dev/null
+++ b/misc/examples/smartpointers/new_sptr.c
@@ -0,0 +1,75 @@
+#define i_implement
+#include <stc/cstr.h>
+
+typedef struct { cstr name, last; } Person;
+Person Person_make(const char* name, const char* last);
+Person Person_clone(Person p);
+void Person_drop(Person* p);
+int Person_cmp(const Person* a, const Person* b);
+uint64_t Person_hash(const Person* p);
+
+#define i_type PersonArc
+#define i_keyclass Person // "class" assume _clone, _drop, _cmp, _hash is defined.
+#include <stc/carc.h>
+
+#define i_type IPtr
+#define i_key int
+#define i_keydrop(x) printf("drop: %d\n", *x)
+#define i_cmp_native
+#include <stc/carc.h>
+
+#define i_type IPStack
+#define i_keyboxed IPtr
+#include <stc/cstack.h>
+
+#define i_type PASet
+#define i_keyboxed PersonArc
+#include <stc/cset.h>
+
+
+Person Person_make(const char* name, const char* last) {
+    Person p = {.name = cstr_from(name), .last = cstr_from(last)};
+    return p;
+}
+
+int Person_cmp(const Person* a, const Person* b) {
+    return cstr_cmp(&a->name, &b->name);
+}
+
+uint64_t Person_hash(const Person* p) {
+    return cstr_hash(&p->name);
+}
+
+Person Person_clone(Person p) {
+    p.name = cstr_clone(p.name), p.last = cstr_clone(p.last);
+    return 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);
+}
+
+
+int main(void) {
+    puts("Ex1");
+    PersonArc p = PersonArc_from(Person_make("John", "Smiths"));
+    PersonArc q = PersonArc_clone(p); // share
+    PersonArc r = PersonArc_clone(p);
+    PersonArc 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_drop(PersonArc, &p, &q, &r, &s);
+
+    puts("Ex2");
+    IPStack vec = {0};
+    IPStack_push(&vec, IPtr_from(10));
+    IPStack_push(&vec, IPtr_from(20));
+    IPStack_emplace(&vec, 30); // same as IPStack_push(&vec, IPtr_from(30));
+    IPStack_push(&vec, IPtr_clone(*IPStack_back(&vec)));
+    IPStack_push(&vec, IPtr_clone(*IPStack_front(&vec)));
+
+    c_foreach (i, IPStack, vec)
+        printf(" (%d: refs %ld)", *i.ref->get, *i.ref->use_count);
+    puts("");
+    IPStack_drop(&vec);
+}
diff --git a/misc/examples/smartpointers/person_arc.c b/misc/examples/smartpointers/person_arc.c
new file mode 100644
index 00000000..38c883a7
--- /dev/null
+++ b/misc/examples/smartpointers/person_arc.c
@@ -0,0 +1,77 @@
+/* cbox: heap allocated boxed type */
+#define i_implement
+#include <stc/cstr.h>
+
+typedef struct { cstr name, last; } Person;
+
+Person Person_make(const char* name, const char* last) {
+    Person p = {.name = cstr_from(name), .last = cstr_from(last)};
+    return p;
+}
+
+int Person_cmp(const Person* a, const Person* b) {
+    int c = cstr_cmp(&a->name, &b->name);
+    return c ? c : cstr_cmp(&a->last, &b->last);
+}
+
+uint64_t Person_hash(const Person* a) {
+    return cstr_hash(&a->name) ^ cstr_hash(&a->last);
+}
+
+Person Person_clone(Person p) {
+    p.name = cstr_clone(p.name);
+    p.last = cstr_clone(p.last);
+    return 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);
+}
+
+#define i_type PSPtr
+#define i_keyclass Person // ensure Person_drop
+#define i_cmp Person_cmp   // specify object cmp, instead of ptr cmp for arc.
+#include <stc/carc.h>
+
+#define i_type Persons
+#define i_keyboxed PSPtr // binds PSPtr_cmp, PSPtr_drop...
+#include <stc/cvec.h>
+
+
+int main(void)
+{
+    PSPtr p = PSPtr_from(Person_make("Laura", "Palmer"));
+    PSPtr q = PSPtr_from(Person_clone(*p.get)); // deep copy
+    Persons vec = {0};
+
+    c_defer(
+        PSPtr_drop(&p),
+        PSPtr_drop(&q),
+        Persons_drop(&vec)
+    ){
+        cstr_assign(&q.get->name, "Leland");
+
+        printf("orig: %s %s\n", cstr_str(&p.get->name), cstr_str(&p.get->last));
+        printf("copy: %s %s\n", cstr_str(&q.get->name), cstr_str(&q.get->last));
+
+        // Use Persons_emplace to implicitly call PSPtr_make on the argument.
+        // No need to do: Persons_push(&vec, PSPtr_make(Person_make("Audrey", "Home")));
+        Persons_emplace(&vec, Person_make("Audrey", "Home"));
+        Persons_emplace(&vec, Person_make("Dale", "Cooper"));
+
+        // Clone/share p and q to the vector
+        c_forlist (i, PSPtr, {p, q})
+            Persons_push(&vec, PSPtr_clone(*i.ref));
+
+        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!
+        Person a = Person_make("Audrey", "Home");
+        const PSPtr *v = Persons_get(&vec, a);
+        if (v) printf("found: %s %s\n", cstr_str(&v->get->name), cstr_str(&v->get->last));
+        Person_drop(&a);
+    }
+}
diff --git a/misc/examples/smartpointers/rawptr_elements.c b/misc/examples/smartpointers/rawptr_elements.c
new file mode 100644
index 00000000..694ce12e
--- /dev/null
+++ b/misc/examples/smartpointers/rawptr_elements.c
@@ -0,0 +1,59 @@
+#include <stc/ccommon.h>
+#include <stdio.h>
+#define i_implement
+#include <stc/cstr.h>
+
+// Create cmap of cstr => long*
+#define i_type SIPtrMap
+#define i_key_str
+#define i_val long*
+#define i_valraw long
+#define i_valfrom(raw) c_new(long, raw)
+#define i_valto(x) **x
+#define i_valclone(x) c_new(long, *x)
+#define i_valdrop(x) c_free(*x)
+#include <stc/cmap.h>
+
+// Alternatively, using cbox:
+#define i_type IBox
+#define i_key long
+#include <stc/cbox.h> // unique_ptr<long> alike.
+
+// cmap of cstr => IBox
+#define i_type SIBoxMap
+#define i_key_str
+#define i_valboxed IBox // i_valboxed: use properties from IBox automatically
+#include <stc/cmap.h>
+
+int main(void)
+{
+    // These have the same behaviour, except IBox has a get member:
+    SIPtrMap map1 = {0};
+    SIBoxMap map2 = {0};
+
+    printf("\nMap cstr => long*:\n");
+    SIPtrMap_insert(&map1, cstr_from("Test1"), c_new(long, 1));
+    SIPtrMap_insert(&map1, cstr_from("Test2"), c_new(long, 2));
+    
+    // Emplace implicitly creates cstr from const char* and an owned long* from long!
+    SIPtrMap_emplace(&map1, "Test3", 3);
+    SIPtrMap_emplace(&map1, "Test4", 4);
+
+    c_forpair (name, number, SIPtrMap, map1)
+        printf("%s: %ld\n", cstr_str(_.name), **_.number);
+
+    puts("\nMap cstr => IBox:");
+    SIBoxMap_insert(&map2, cstr_from("Test1"), IBox_make(1));
+    SIBoxMap_insert(&map2, cstr_from("Test2"), IBox_make(2));
+    
+    // Emplace implicitly creates cstr from const char* and IBox from long!
+    SIBoxMap_emplace(&map2, "Test3", 3);
+    SIBoxMap_emplace(&map2, "Test4", 4);
+
+    c_forpair (name, number, SIBoxMap, map2)
+        printf("%s: %ld\n", cstr_str(_.name), *_.number->get);
+    puts("");
+
+    SIPtrMap_drop(&map1);
+    SIBoxMap_drop(&map2);
+}
-- 
cgit v1.2.3


From dbcc13635402bd466675f4f41e865d02abc6f918 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Fri, 21 Jul 2023 10:49:45 +0200
Subject: NB! Changed some coroutine API for consistency/simplicity: Added full
 task support.

---
 docs/ccommon_api.md                           | 30 ++++++--------
 include/stc/ccommon.h                         |  2 +-
 include/stc/coroutine.h                       | 44 ++++++++++----------
 misc/examples/coroutines/cointerleave.c       |  2 +-
 misc/examples/coroutines/coread.c             |  2 +-
 misc/examples/coroutines/coroutines.c         |  8 ++--
 misc/examples/coroutines/cotasks1.c           |  2 +-
 misc/examples/coroutines/cotasks2.c           |  4 +-
 misc/examples/smartpointers/map_box.c         | 34 +++++++++++++++
 misc/examples/smartpointers/map_ptr.c         | 34 +++++++++++++++
 misc/examples/smartpointers/rawptr_elements.c | 59 ---------------------------
 misc/examples/spans/mdspan.c                  | 12 +++---
 12 files changed, 119 insertions(+), 114 deletions(-)
 create mode 100644 misc/examples/smartpointers/map_box.c
 create mode 100644 misc/examples/smartpointers/map_ptr.c
 delete mode 100644 misc/examples/smartpointers/rawptr_elements.c

(limited to 'misc/examples/smartpointers')

diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md
index 9189d7e8..0752beb5 100644
--- a/docs/ccommon_api.md
+++ b/docs/ccommon_api.md
@@ -374,36 +374,32 @@ cco_routine scope; Use `if-else-if` constructs instead.
 
 |           |  Function / operator                 | Description                             |
 |:----------|:-------------------------------------|:----------------------------------------|
-|           | Function / 'keywords':               |                                         |
-|`cco_result` | Enum `CCO_DONE=0`, `CCO_YIELD`, `CCO_AWAIT` | Recommended return values in coroutines |
-|           | Function / 'keywords':               |                                         |
+|`cco_result` | `CCO_DONE`, `CCO_AWAIT`, `CCO_YIELD` | Default set of return values from coroutines |
 |           | `cco_cleanup:`                       | Label for cleanup position in coroutine |
 | `bool`    | `cco_done(co)`                       | Is coroutine done?                      |
-|           | `cco_routine(co) { }`                | The coroutine scope                     |
+|           | `cco_routine(co) {}`                 | The coroutine scope                     |
 |           | `cco_yield();`                       | Yield/suspend execution (return CCO_YIELD)|
-|           | `cco_yield_v();`                     | Yield/suspend execution (return void)   |
 |           | `cco_yield_v(ret);`                  | Yield/suspend execution (return ret)    |
-|           | `cco_yield_final();`                 | Yield final time, enables cleanup-state |
-|           | `cco_yield_final(ret);`              | Yield a final value (e.g. CCO_ERROR) |
+|           | `cco_yield_final();`                 | Yield final suspend, enter cleanup-state |
+|           | `cco_yield_final(ret);`              | Yield a final value                     |
 |           | `cco_await(condition);`              | Suspend until condition is true (return CCO_AWAIT)|
-|           | `cco_await_v(condition);`            | Suspend until condition is true (return void) |
-|           | `cco_await_v(condition, ret);`       | Suspend until condition is true (return ret)|
-|           | `cco_await_on(cocall);`              | Await on sub-coroutine to finish (return its ret) |
+|           | `cco_call_await(cocall);`            | Await for subcoro to finish (returns its ret value) |
+|           | `cco_call_await(cocall, retbit);`    | Await for subcoro's return to be in (retbit \| CCO_DONE)  |
 |           | `cco_return;`                        | Return from coroutine (inside cco_routine) |
 |           | Task objects:                        |                                         |
 |           | `cco_task_struct(Name, ...);`        | Define a coroutine task struct          |
-|           | `cco_task_await(task, ...);`         | Await for task to finish or optionally yield a value |
+|           | `cco_task_await(task, cco_runtime* rt);`| Await for task to finish             |
+|           | `cco_task_await(task, rt, retbit);`  | Await for task's return to be in (retbit \| CCO_DONE) |
+|`cco_result`| `cco_task_resume(task, rt);`       | Resume suspended task                   |
 |           | Semaphores:                          |                                         | 
 |           | `cco_sem`                            | Semaphore type                          |
 | `cco_sem` | `cco_sem_from(long value)`           | Create semaphore                        |
 |           | `cco_sem_set(sem, long value)`       | Set semaphore value                     |
 |           | `cco_sem_await(sem)`                 | Await for the semaphore count > 0       |
-|           | `cco_sem_await(sem, ret)`            | Await with ret on the semaphore         |
 |           | `cco_sem_release(sem)`               | Signal the semaphore (count += 1)       |
 |           | Timers:                              |                                         | 
 |           | `cco_timer`                          | Timer type                              |
 |           | `cco_timer_await(tm, double sec)`    | Await secs for timer to expire (usec prec.)|
-|           | `cco_timer_await(tm, double sec, ret)`| Await secs for timer with ret value    |
 |           | `cco_timer_start(tm, double sec)`    | Start timer for secs duration           |
 |           | `cco_timer_restart(tm)`              | Restart timer with same duration        |
 | `bool`    | `cco_timer_expired(tm)`              | Return true if timer is expired         |
@@ -412,10 +408,10 @@ cco_routine scope; Use `if-else-if` constructs instead.
 |           | From caller side:                    |                                         | 
 | `void`    | `cco_stop(co)`                       | Next call of coroutine finalizes        |
 | `void`    | `cco_reset(co)`                      | Reset state to initial (for reuse)      |
-| `void`    | `cco_block_on(cocall) { }`           | Run blocking until cocall is finished   |
-| `void`    | `cco_block_on(cocall, int *result) {}`| Run blocking until cocall is finished |
-|           | `cco_task_block_on(task) {}`         | Run blocking until task is finished |
-|           | `cco_task_block_on(task, rt, STACKSZ) {}`| Run blocking until task is finished |
+| `void`    | `cco_call_blocking(cocall) {}`       | Run blocking until cocall is finished   |
+| `void`    | `cco_call_blocking(cocall, int* outres) {}`| Run blocking until cocall is finished |
+|           | `cco_task_blocking(task) {}`         | Run blocking until task is finished |
+|           | `cco_task_blocking(task, rt, STACKSZ) {}`| Run blocking until task is finished |
 |           | Time functions:                      |                                         |
 | `double`  | `cco_time(void)`                     | Return secs with usec prec. since Epoch |
 |           | `cco_sleep(double sec)`              | Sleep for seconds (msec or usec prec.)  |
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 1f9ea80d..316a8ee7 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -69,7 +69,7 @@ typedef long long _llong;
   #define c_new(T, ...)         ((T*)memcpy(malloc(sizeof(T)), ((T[]){__VA_ARGS__}), sizeof(T)))
   #define c_LITERAL(T)          (T)
 #endif
-#define c_new_n(T, n)           ((T*)malloc(sizeof(T)*(n)))
+#define c_new_n(T, n)           ((T*)malloc(sizeof(T)*(size_t)(n)))
 #define c_malloc(sz)            malloc(c_i2u(sz))
 #define c_calloc(n, sz)         calloc(c_i2u(n), c_i2u(sz))
 #define c_realloc(p, sz)        realloc(p, c_i2u(sz))
diff --git a/include/stc/coroutine.h b/include/stc/coroutine.h
index f89d20af..42905744 100644
--- a/include/stc/coroutine.h
+++ b/include/stc/coroutine.h
@@ -83,26 +83,27 @@ typedef enum {
         case __LINE__:; \
     } while (0)
 
-#define cco_await(promise) cco_await_v_2(promise, CCO_AWAIT)
-#define cco_await_v(...) c_MACRO_OVERLOAD(cco_await_v, __VA_ARGS__)
-#define cco_await_v_1(promise) cco_await_v_2(promise, )
-#define cco_await_v_2(promise, ret) \
+#define cco_await(promise) cco_await_and_return(promise, CCO_AWAIT)
+#define cco_await_v(promise) cco_await_and_return(promise, )
+#define cco_await_and_return(promise, ret) \
     do { \
         *_state = __LINE__; \
         case __LINE__: if (!(promise)) {return ret; goto _resume;} \
     } while (0)
 
-/* cco_await_on(): assumes coroutine returns a cco_result value (int) */
-#define cco_await_on(corocall) \
+/* cco_call_await(): assumes coroutine returns a cco_result value (int) */
+#define cco_call_await(...) c_MACRO_OVERLOAD(cco_call_await, __VA_ARGS__)
+#define cco_call_await_1(corocall) cco_call_await_2(corocall, CCO_DONE)
+#define cco_call_await_2(corocall, resultbits) \
     do { \
         *_state = __LINE__; \
-        case __LINE__: { int _r = corocall; if (_r != CCO_DONE) {return _r; goto _resume;} } \
+        case __LINE__: { int _r = corocall; if (!(_r & ~(resultbits))) {return _r; goto _resume;} } \
     } while (0)
 
-/* cco_block_on(): assumes coroutine returns a cco_result value (int) */
-#define cco_block_on(...) c_MACRO_OVERLOAD(cco_block_on, __VA_ARGS__)
-#define cco_block_on_1(corocall) while ((corocall) != CCO_DONE)
-#define cco_block_on_2(corocall, result) while ((*(result) = (corocall)) != CCO_DONE)
+/* cco_call_blocking(): assumes coroutine returns a cco_result value (int) */
+#define cco_call_blocking(...) c_MACRO_OVERLOAD(cco_call_blocking, __VA_ARGS__)
+#define cco_call_blocking_1(corocall) while ((corocall) != CCO_DONE)
+#define cco_call_blocking_2(corocall, result) while ((*(result) = (corocall)) != CCO_DONE)
 
 #define cco_cleanup \
     *_state = CCO_STATE_CLEANUP; case CCO_STATE_CLEANUP
@@ -152,7 +153,7 @@ typedef struct cco_runtime {
 #define cco_cast_task(task) \
     ((cco_task *)(task) + 0*sizeof((task)->cco_func(task, (cco_runtime*)0) + ((int*)0 == &(task)->cco_state)))
 
-#define cco_resume(task, rt) \
+#define cco_task_resume(task, rt) \
     (task)->cco_func(task, rt)
 
 #define cco_task_await(...) c_MACRO_OVERLOAD(cco_task_await, __VA_ARGS__)
@@ -164,11 +165,11 @@ typedef struct cco_runtime {
         cco_yield_v(CCO_AWAIT); \
     } while (0)
 
-#define cco_task_block_on(...) c_MACRO_OVERLOAD(cco_task_block_on, __VA_ARGS__)
-#define cco_task_block_on_1(task) cco_task_block_on_3(task, _rt, 16)
-#define cco_task_block_on_3(task, rt, STACKDEPTH) \
+#define cco_task_blocking(...) c_MACRO_OVERLOAD(cco_task_blocking, __VA_ARGS__)
+#define cco_task_blocking_1(task) cco_task_blocking_3(task, _rt, 16)
+#define cco_task_blocking_3(task, rt, STACKDEPTH) \
     for (struct { int result, top; cco_task* stack[STACKDEPTH]; } rt = {.stack={cco_cast_task(task)}}; \
-         (((rt.result = cco_resume(rt.stack[rt.top], (cco_runtime*)&rt)) & ~rt.stack[rt.top]->cco_expect) || --rt.top >= 0); )
+         (((rt.result = cco_task_resume(rt.stack[rt.top], (cco_runtime*)&rt)) & ~rt.stack[rt.top]->cco_expect) || --rt.top >= 0); )
 
 /*
  * Semaphore
@@ -176,12 +177,11 @@ typedef struct cco_runtime {
 
 typedef struct { intptr_t count; } cco_sem;
 
-#define cco_sem_await(sem) cco_sem_await_v_2(sem, CCO_AWAIT)
-#define cco_sem_await_v(...) c_MACRO_OVERLOAD(cco_sem_await_v, __VA_ARGS__)
-#define cco_sem_await_v_1(sem) cco_sem_await_v_2(sem, )
-#define cco_sem_await_v_2(sem, ret) \
+#define cco_sem_await(sem) cco_sem_await_and_return(sem, CCO_AWAIT)
+#define cco_sem_await_v(sem) cco_sem_await_and_return(sem, )
+#define cco_sem_await_and_return(sem, ret) \
     do { \
-        cco_await_v_2((sem)->count > 0, ret); \
+        cco_await_and_return((sem)->count > 0, ret); \
         --(sem)->count; \
     } while (0)
 
@@ -241,7 +241,7 @@ typedef struct { double interval, start; } cco_timer;
 #define cco_timer_await_v_3(tm, sec, ret) \
     do { \
         cco_timer_start(tm, sec); \
-        cco_await_v_2(cco_timer_expired(tm), ret); \
+        cco_await_and_return(cco_timer_expired(tm), ret); \
     } while (0)
 
 static inline void cco_timer_start(cco_timer* tm, double sec) {
diff --git a/misc/examples/coroutines/cointerleave.c b/misc/examples/coroutines/cointerleave.c
index ea0d4dac..f3710ba3 100644
--- a/misc/examples/coroutines/cointerleave.c
+++ b/misc/examples/coroutines/cointerleave.c
@@ -49,7 +49,7 @@ void Use(void)
 
     struct Generator g = {{&a}, {&b}};
 
-    cco_block_on(interleaved(&g)) {
+    cco_call_blocking(interleaved(&g)) {
         printf("%d ", g.value);
     }
     puts("");
diff --git a/misc/examples/coroutines/coread.c b/misc/examples/coroutines/coread.c
index 56248108..ebaaf19d 100644
--- a/misc/examples/coroutines/coread.c
+++ b/misc/examples/coroutines/coread.c
@@ -33,7 +33,7 @@ int main(void)
 {
     struct file_read g = {__FILE__};
     int n = 0;
-    cco_block_on(file_read(&g))
+    cco_call_blocking(file_read(&g))
     {
         printf("%3d %s\n", ++n, cstr_str(&g.line));
         //if (n == 10) cco_stop(&g);
diff --git a/misc/examples/coroutines/coroutines.c b/misc/examples/coroutines/coroutines.c
index de0fcda5..489c3ed6 100644
--- a/misc/examples/coroutines/coroutines.c
+++ b/misc/examples/coroutines/coroutines.c
@@ -84,13 +84,13 @@ struct combined {
 
 int combined(struct combined* g) {
     cco_routine(g) {
-        cco_await_on(prime(&g->prm));
-        cco_await_on(fibonacci(&g->fib));
+        cco_call_await(prime(&g->prm));
+        cco_call_await(fibonacci(&g->fib));
 
         // Reuse the g->prm context and extend the count:
         g->prm.count = 8, g->prm.result += 2;
         cco_reset(&g->prm);
-        cco_await_on(prime(&g->prm));
+        cco_call_await(prime(&g->prm));
 
         cco_cleanup:
         puts("final combined");
@@ -103,7 +103,7 @@ int main(void)
     struct combined c = {.prm={.count=8}, .fib={14}};
     int res;
 
-    cco_block_on(combined(&c), &res) {
+    cco_call_blocking(combined(&c), &res) {
         if (res == CCO_YIELD)
             printf("Prime(%d)=%lld, Fib(%d)=%lld\n", 
                 c.prm.idx, c.prm.result, 
diff --git a/misc/examples/coroutines/cotasks1.c b/misc/examples/coroutines/cotasks1.c
index 27999ccf..e4afbe2b 100644
--- a/misc/examples/coroutines/cotasks1.c
+++ b/misc/examples/coroutines/cotasks1.c
@@ -88,7 +88,7 @@ int main(void)
     struct consume_items consume = {.n=5};
     int count = 0;
 
-    cco_block_on(consume_items(&consume, &produce))
+    cco_call_blocking(consume_items(&consume, &produce))
     {
         ++count;
         //cco_sleep(0.001);
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 9ca69bda..24a9f23f 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -77,7 +77,7 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
         }
         cco_cleanup:
             cco_stop(&c->produce);
-            cco_resume(&c->produce, rt);
+            cco_task_resume(&c->produce, rt);
             puts("done consume");
     }
     return 0;
@@ -92,7 +92,7 @@ int main(void)
     };
     int count = 0;
 
-    cco_task_block_on(&consume)
+    cco_task_blocking(&consume)
     {
         ++count;
         //cco_sleep(0.001);
diff --git a/misc/examples/smartpointers/map_box.c b/misc/examples/smartpointers/map_box.c
new file mode 100644
index 00000000..f651b302
--- /dev/null
+++ b/misc/examples/smartpointers/map_box.c
@@ -0,0 +1,34 @@
+#include <stc/ccommon.h>
+#include <stdio.h>
+#define i_implement
+#include <stc/cstr.h>
+
+#define i_type IBox
+#define i_key long
+#include <stc/cbox.h> // unique_ptr<long> alike.
+
+// cmap of cstr => IBox
+#define i_type Boxmap
+#define i_key_str
+#define i_valboxed IBox // i_valboxed: use properties from IBox automatically
+#include <stc/cmap.h>
+
+
+int main(void)
+{
+    Boxmap map = {0};
+
+    puts("Map cstr => IBox:");
+    Boxmap_insert(&map, cstr_from("Test1"), IBox_make(1));
+    Boxmap_insert(&map, cstr_from("Test2"), IBox_make(2));
+    
+    // Simpler: emplace() implicitly creates cstr from const char* and IBox from long!
+    Boxmap_emplace(&map, "Test3", 3);
+    Boxmap_emplace(&map, "Test4", 4);
+
+    c_forpair (name, number, Boxmap, map)
+        printf("%s: %ld\n", cstr_str(_.name), *_.number->get);
+    puts("");
+
+    Boxmap_drop(&map);
+}
diff --git a/misc/examples/smartpointers/map_ptr.c b/misc/examples/smartpointers/map_ptr.c
new file mode 100644
index 00000000..453322c5
--- /dev/null
+++ b/misc/examples/smartpointers/map_ptr.c
@@ -0,0 +1,34 @@
+#include <stc/ccommon.h>
+#include <stdio.h>
+#define i_implement
+#include <stc/cstr.h>
+
+// cmap of cstr => long*
+#define i_type Ptrmap
+#define i_key_str
+#define i_val long*
+#define i_valraw long
+#define i_valfrom(raw) c_new(long, raw)
+#define i_valto(x) **x
+#define i_valclone(x) c_new(long, *x)
+#define i_valdrop(x) c_free(*x)
+#include <stc/cmap.h>
+
+int main(void)
+{
+    Ptrmap map = {0};
+
+    puts("Map cstr => long*:");
+    Ptrmap_insert(&map, cstr_from("Test1"), c_new(long, 1));
+    Ptrmap_insert(&map, cstr_from("Test2"), c_new(long, 2));
+    
+    // Simple: emplace() implicitly creates cstr from const char* and an owned long* from long!
+    Ptrmap_emplace(&map, "Test3", 3);
+    Ptrmap_emplace(&map, "Test4", 4);
+
+    c_forpair (name, number, Ptrmap, map)
+        printf("%s: %ld\n", cstr_str(_.name), **_.number);
+    puts("");
+
+    Ptrmap_drop(&map);
+}
diff --git a/misc/examples/smartpointers/rawptr_elements.c b/misc/examples/smartpointers/rawptr_elements.c
deleted file mode 100644
index 694ce12e..00000000
--- a/misc/examples/smartpointers/rawptr_elements.c
+++ /dev/null
@@ -1,59 +0,0 @@
-#include <stc/ccommon.h>
-#include <stdio.h>
-#define i_implement
-#include <stc/cstr.h>
-
-// Create cmap of cstr => long*
-#define i_type SIPtrMap
-#define i_key_str
-#define i_val long*
-#define i_valraw long
-#define i_valfrom(raw) c_new(long, raw)
-#define i_valto(x) **x
-#define i_valclone(x) c_new(long, *x)
-#define i_valdrop(x) c_free(*x)
-#include <stc/cmap.h>
-
-// Alternatively, using cbox:
-#define i_type IBox
-#define i_key long
-#include <stc/cbox.h> // unique_ptr<long> alike.
-
-// cmap of cstr => IBox
-#define i_type SIBoxMap
-#define i_key_str
-#define i_valboxed IBox // i_valboxed: use properties from IBox automatically
-#include <stc/cmap.h>
-
-int main(void)
-{
-    // These have the same behaviour, except IBox has a get member:
-    SIPtrMap map1 = {0};
-    SIBoxMap map2 = {0};
-
-    printf("\nMap cstr => long*:\n");
-    SIPtrMap_insert(&map1, cstr_from("Test1"), c_new(long, 1));
-    SIPtrMap_insert(&map1, cstr_from("Test2"), c_new(long, 2));
-    
-    // Emplace implicitly creates cstr from const char* and an owned long* from long!
-    SIPtrMap_emplace(&map1, "Test3", 3);
-    SIPtrMap_emplace(&map1, "Test4", 4);
-
-    c_forpair (name, number, SIPtrMap, map1)
-        printf("%s: %ld\n", cstr_str(_.name), **_.number);
-
-    puts("\nMap cstr => IBox:");
-    SIBoxMap_insert(&map2, cstr_from("Test1"), IBox_make(1));
-    SIBoxMap_insert(&map2, cstr_from("Test2"), IBox_make(2));
-    
-    // Emplace implicitly creates cstr from const char* and IBox from long!
-    SIBoxMap_emplace(&map2, "Test3", 3);
-    SIBoxMap_emplace(&map2, "Test4", 4);
-
-    c_forpair (name, number, SIBoxMap, map2)
-        printf("%s: %ld\n", cstr_str(_.name), *_.number->get);
-    puts("");
-
-    SIPtrMap_drop(&map1);
-    SIBoxMap_drop(&map2);
-}
diff --git a/misc/examples/spans/mdspan.c b/misc/examples/spans/mdspan.c
index 4427299c..db601850 100644
--- a/misc/examples/spans/mdspan.c
+++ b/misc/examples/spans/mdspan.c
@@ -12,17 +12,17 @@ int main(void) {
     DSpan3 ms = cspan_md_order('F', data, nx, ny, nz); // Fortran, not 'C'
 
     int idx = 0;
-    c_forrange (i, ms.shape[0])
-        c_forrange (j, ms.shape[1])
-            c_forrange (k, ms.shape[2]) 
+    for (int i = 0; i < ms.shape[0]; ++i)
+        for (int j = 0; j < ms.shape[1]; ++j)
+            for (int k = 0; k < ms.shape[2]; ++k)
                 *cspan_at(&ms, i, j, k) = ++idx;
 
     cspan_transpose(&ms);
 
     printf(", transposed:\n\n");
-    c_forrange (i, ms.shape[0]) {
-        c_forrange (j, ms.shape[1]) {
-            c_forrange (k, ms.shape[2])
+    for (int i = 0; i < ms.shape[0]; ++i) {
+        for (int j = 0; j < ms.shape[1]; ++j) {
+            for (int k = 0; k < ms.shape[2]; ++k)
                 printf(" %3g", *cspan_at(&ms, i, j, k));
             puts("");
         }
-- 
cgit v1.2.3


From dd87a488eeeffa41a06757dda2220da21337a35e Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Sun, 23 Jul 2023 23:51:02 +0200
Subject: - algo/sort.h: Use plural form of i_key (or i_val) to define default
 name for sort, like: <i_key>s_sort_n(data, n). - Updated some examples.

---
 include/stc/algo/sort.h                 |  2 +-
 misc/examples/coroutines/cotasks2.c     | 35 ++++++++++------------
 misc/examples/coroutines/triples.c      | 51 +++++++++++++++++----------------
 misc/examples/smartpointers/music_arc.c | 12 ++++----
 4 files changed, 49 insertions(+), 51 deletions(-)

(limited to 'misc/examples/smartpointers')

diff --git a/include/stc/algo/sort.h b/include/stc/algo/sort.h
index 06d7395f..86c9b9f1 100644
--- a/include/stc/algo/sort.h
+++ b/include/stc/algo/sort.h
@@ -70,7 +70,7 @@ int main(void) {
   #ifndef i_tag
     #define i_tag i_key
   #endif
-  #define i_type c_PASTE(i_tag, array)
+  #define i_type c_PASTE(i_tag, s)
   typedef i_key i_type;
 #endif
 #ifndef i_at
diff --git a/misc/examples/coroutines/cotasks2.c b/misc/examples/coroutines/cotasks2.c
index 24a9f23f..4fdf98d9 100644
--- a/misc/examples/coroutines/cotasks2.c
+++ b/misc/examples/coroutines/cotasks2.c
@@ -42,18 +42,20 @@ int produce_items(struct produce_items* p, cco_runtime* rt)
 {
     cco_routine (p) {
         p->str = cstr_null;
+        p->next.cco_func = next_value;
         while (true)
         {
-            // await for next CCO_YIELD in next_value()
+            // await for next CCO_YIELD (or CCO_DONE) in next_value
             cco_task_await(&p->next, rt, CCO_YIELD);
             cstr_printf(&p->str, "item %d", p->next.val);
             print_time();
             printf("produced %s\n", cstr_str(&p->str));
             cco_yield();
         }
+
         cco_cleanup:
-            cstr_drop(&p->str);
-            puts("done produce");
+        cstr_drop(&p->str);
+        puts("done produce");
     }
     return 0;
 }
@@ -68,6 +70,8 @@ cco_task_struct (consume_items,
 int consume_items(struct consume_items* c, cco_runtime* rt)
 {
    cco_routine (c) {
+        c->produce.cco_func = produce_items;
+
         for (c->i = 1; c->i <= c->n; ++c->i)
         {
             printf("consume #%d\n", c->i);
@@ -75,10 +79,11 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
             print_time();
             printf("consumed %s\n", cstr_str(&c->produce.str));
         }
+
         cco_cleanup:
-            cco_stop(&c->produce);
-            cco_task_resume(&c->produce, rt);
-            puts("done consume");
+        cco_stop(&c->produce);
+        cco_task_resume(&c->produce, rt);
+        puts("done consume");
     }
     return 0;
 }
@@ -86,18 +91,8 @@ int consume_items(struct consume_items* c, cco_runtime* rt)
 int main(void)
 {
     struct consume_items consume = {
-        .n=5,
-        .cco_func=consume_items,
-        .produce={.cco_func=produce_items, .next={.cco_func=next_value}},
+        .cco_func = consume_items,
+        .n = 5,
     };
-    int count = 0;
-
-    cco_task_blocking(&consume)
-    {
-        ++count;
-        //cco_sleep(0.001);
-        //if (consume.i == 3)
-        //    cco_stop(&consume);
-    }
-    printf("count: %d\n", count);
-}
\ No newline at end of file
+    cco_task_blocking(&consume);
+}
diff --git a/misc/examples/coroutines/triples.c b/misc/examples/coroutines/triples.c
index fe1ca7c3..9fd771ce 100644
--- a/misc/examples/coroutines/triples.c
+++ b/misc/examples/coroutines/triples.c
@@ -3,22 +3,14 @@
 #include <stdio.h>
 #include <stc/coroutine.h>
 
-int gcd(int a, int b) {
-    while (b) {
-        int t = a % b;
-        a = b;
-        b = t;
-    }
-    return a;
-}
-
-void triples_vanilla(int n) {
-    for (int c = 5, i = 0; n; ++c) {
+void triples_vanilla(int max_c) {
+    for (int c = 5, i = 0;; ++c) {
         for (int a = 1; a < c; ++a) {
             for (int b = a + 1; b < c; ++b) {
-                if ((int64_t)a*a + (int64_t)b*b == (int64_t)c*c && gcd(a, b) == 1) {
+                if ((int64_t)a*a + (int64_t)b*b == (int64_t)c*c) {
+                    if (c > max_c)
+                        goto done;
                     printf("%d: {%d, %d, %d}\n", ++i, a, b, c);
-                    if (--n == 0) goto done;
                 }
             }
         }
@@ -27,19 +19,21 @@ void triples_vanilla(int n) {
 }
 
 struct triples {
-    int size, count;
+    int max_c;
     int a, b, c;
     int cco_state;
 };
 
 int triples_coro(struct triples* t) {
     cco_routine(t) {
-        t->count = 0;
-        for (t->c = 5; t->size; ++t->c) {
+        for (t->c = 5;; ++t->c) {
             for (t->a = 1; t->a < t->c; ++t->a) {
                 for (t->b = t->a + 1; t->b < t->c; ++t->b) {
-                    if ((int64_t)t->a*t->a + (int64_t)t->b*t->b == (int64_t)t->c*t->c) {
-                        if (t->count++ == t->size)
+                    if ((int64_t)t->a * t->a +
+                        (int64_t)t->b * t->b ==
+                        (int64_t)t->c * t->c)
+                    {
+                        if (t->c > t->max_c)
                             cco_return;
                         cco_yield();
                     }
@@ -52,20 +46,29 @@ int triples_coro(struct triples* t) {
     return 0;
 }
 
+int gcd(int a, int b) {
+    while (b) {
+        int t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+
 int main(void)
 {
     puts("Vanilla triples:");
-    triples_vanilla(5);
+    triples_vanilla(20);
 
-    puts("\nCoroutine triples:");
-    struct triples t = {.size=INT32_MAX};
+    puts("\nCoroutine triples with GCD = 1:");
+    struct triples t = {.max_c = 100};
     int n = 0;
 
-    while (triples_coro(&t)) {
+    cco_call_blocking(triples_coro(&t)) {
         if (gcd(t.a, t.b) > 1)
             continue;
-        if (t.c < 100)
-            printf("%d: {%d, %d, %d}\n", ++n, t.a, t.b, t.c);
+        if (++n <= 20)
+            printf("%d: {%d, %d, %d}\n", n, t.a, t.b, t.c);
         else
             cco_stop(&t);
     }
diff --git a/misc/examples/smartpointers/music_arc.c b/misc/examples/smartpointers/music_arc.c
index 16111b0b..13d368c3 100644
--- a/misc/examples/smartpointers/music_arc.c
+++ b/misc/examples/smartpointers/music_arc.c
@@ -12,7 +12,7 @@ typedef struct
 int Song_cmp(const Song* x, const Song* y)
     { return cstr_cmp(&x->title, &y->title); }
 
-Song Song_make(const char* artist, const char* title)
+Song Song_init(const char* artist, const char* title)
     { return c_LITERAL(Song){cstr_from(artist), cstr_from(title)}; }
 
 void Song_drop(Song* s) {
@@ -34,9 +34,9 @@ void Song_drop(Song* s) {
 void example3(void)
 {
     SongVec vec1 = c_init(SongVec, {
-        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")
+        Song_init("Bob Dylan", "The Times They Are A Changing"),
+        Song_init("Aretha Franklin", "Bridge Over Troubled Water"),
+        Song_init("Thalia", "Entre El Mar y Una Estrella")
     });
 
     SongVec vec2 = {0};
@@ -47,8 +47,8 @@ void example3(void)
 
     // Add a few more to vec2. We can use emplace when creating new entries
     // Emplace calls SongArc_from() on the argument to create the Arc:
-    SongVec_emplace(&vec2, Song_make("Michael Jackson", "Billie Jean"));
-    SongVec_emplace(&vec2, Song_make("Rihanna", "Stay"));
+    SongVec_emplace(&vec2, Song_init("Michael Jackson", "Billie Jean"));
+    SongVec_emplace(&vec2, Song_init("Rihanna", "Stay"));
 
     // We now have two vectors with some shared, some unique entries.
     c_forlist (i, SongVec, {vec1, vec2}) {
-- 
cgit v1.2.3


From d7fba27af452de2d709767e615fa2e90d6b3a391 Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Wed, 26 Jul 2023 21:23:15 +0200
Subject: Added cmap_emplace_key() / csmap_emplace_key() More docs.

---
 README.md                                    | 29 +++++-----
 docs/algorithm_api.md                        |  4 +-
 docs/cmap_api.md                             |  8 ++-
 docs/csmap_api.md                            |  1 +
 include/stc/algo/filter.h                    |  2 +-
 include/stc/cmap.h                           | 87 +++++++++++++++-------------
 include/stc/csmap.h                          | 30 ++++++----
 include/stc/forward.h                        |  1 +
 misc/examples/smartpointers/arc_containers.c |  1 -
 misc/tests/cspan_test.c                      |  4 +-
 10 files changed, 95 insertions(+), 72 deletions(-)

(limited to 'misc/examples/smartpointers')

diff --git a/README.md b/README.md
index 9b6698e5..d66a7f1c 100644
--- a/README.md
+++ b/README.md
@@ -619,23 +619,24 @@ STC is generally very memory efficient. Memory usage for the different container
 # Version History
 
 ## Version 4.3
-- Some breaking changes.
-- **coroutines**: much improved with some new API and added features.
-- **cspan**: Rewritten to add support for **column-major** order (fortran) multidim spans and transposed views.
-- Removed default comparison for **clist**, **cvec** and **cdeq** (like cstack and cqueue). 
-    - Define `i_cmp_native` to enable built-in i_key types comparisons (<, ==).
-    - Use of `i_keyclass` still expects comparison functions defined. 
-    - Use of `i_keyboxed` compares hosted pointers instead of pointed to values if comparisons not defined.
-- **cstr** and **csview** now uses *shared linking* by default. Implement by either defining `i_implement` or `i_static` before including.
+- Some breaking changes:
+    - **cstr** and **csview** now uses *shared linking* by default. Implement by either defining `i_implement` or `i_static` before including.
+    - Changes in `coroutine.h`: much improved with some new API and added features.
+    - Renamed stc/calgo.h => `<stc/algorithms.h>`
+    - Removed deprecated stc/crandom.h. Use `<stc/crand.h>` with the new API.
+    - Removed default comparison for **clist**, **cvec** and **cdeq**:
+        - Define `i_cmp_native` to enable comparison for built-in i_key types (<, ==).
+        - Use of `i_keyclass` still expects comparison functions to be defined. 
+        - Use of `i_keyboxed` compares hosted pointers instead of pointed to values if comparisons not defined.
+    - Renamed input enum flags for ***cregex***-functions.
+- **cspan**: Changed representation of strides to add **column-major** order (fortran) multidimensional spans and transposed views.
 - All new faster and smaller **cqueue** and **cdeq** implementations, using a circular buffer.
-- Renamed i_extern => `i_import`.
-    - Define `i_import` before `#include <stc/cstr.h>` will also define utf8 case conversions.
+- Renamed i_extern => `i_import` (i_extern deprecated).
+    - Define `i_import` before `#include <stc/cstr.h>` will also define full utf8 case conversions.
     - Define `i_import` before `#include <stc/cregex.h>` will also define cstr + utf8 tables.
-- Renamed c_make() => ***c_init()*** macro for initializing containers with element lists.
-- Renamed input enum flags for ***cregex***-functions.
-- Removed deprecated <stc/crandom.h>. Use `<stc/crand.h>` with the new API.
+- Renamed c_make() => ***c_init()*** macro for initializing containers with element lists. c_make deprecated.
 - Removed deprecated uppercase flow-control macro names.
-- Improved default string hash function.
+- Other smaller additions, bug fixes and improved documentation.
 
 ## Version 4.2
 - New home! And online single headers for https://godbolt.org
diff --git a/docs/algorithm_api.md b/docs/algorithm_api.md
index 490771b5..40ff32d6 100644
--- a/docs/algorithm_api.md
+++ b/docs/algorithm_api.md
@@ -130,7 +130,7 @@ Iterate a container or a crange with chained `&&` filtering.
 
 [ [Run this example](https://godbolt.org/z/n9aYrYPv8) ]
 ```c
-#include <stc/calgo.h>
+#include <stc/algorithm.h>
 #include <stdio.h>
 
 bool isPrime(long long i) {
@@ -309,8 +309,6 @@ The **checkauto** utility described below, ensures that the `c_auto*` macros are
 | `continue`                             | Exit a defer-block without resource leak                  |
 
 ```c
-#include <stc/algo/raii.h> // or <stc/calgo.h>
-...
 // `c_defer` executes the expression(s) when leaving scope.
 //  Note: does not require inclusion of "raii.h".
 cstr s1 = cstr_lit("Hello"), s2 = cstr_lit("world");
diff --git a/docs/cmap_api.md b/docs/cmap_api.md
index 17f27662..4e6da57d 100644
--- a/docs/cmap_api.md
+++ b/docs/cmap_api.md
@@ -71,7 +71,8 @@ cmap_X_result         cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val map
 cmap_X_result         cmap_X_push(cmap_X* self, cmap_X_value entry);                    // similar to insert
 
 cmap_X_result         cmap_X_emplace(cmap_X* self, i_keyraw rkey, i_valraw rmapped);    // no change if rkey in map
-cmap_X_result         cmap_X_emplace_or_assign(cmap_X* self, i_keyraw rkey, i_valraw rmapped); // always update
+cmap_X_result         cmap_X_emplace_or_assign(cmap_X* self, i_keyraw rkey, i_valraw rmapped); // always update mapped
+cmap_X_result         cmap_X_emplace_key(cmap_X* self, i_keyraw rkey);                 // see example 1.
 
 int                   cmap_X_erase(cmap_X* self, i_keyraw rkey);                        // return 0 or 1
 cmap_X_iter           cmap_X_erase_at(cmap_X* self, cmap_X_iter it);                    // return iter after it
@@ -138,6 +139,11 @@ int main(void)
     cmap_str_emplace(&umap, "BLACK", "#000000");
     cmap_str_emplace(&umap, "WHITE", "#FFFFFF");
 
+    // Insert only if "CYAN" is not in the map: create mapped value when needed only.
+    cmap_str_result res = cmap_str_emplace_key(&umap, "CYAN");
+    if (res.inserted)
+        res.ref->second = cstr_from("#00FFFF"); // must assign second if key was inserted.
+
     // Output values by key
     printf("The HEX of color RED is:[%s]\n", cstr_str(cmap_str_at(&umap, "RED")));
     printf("The HEX of color BLACK is:[%s]\n", cstr_str(cmap_str_at(&umap, "BLACK")));
diff --git a/docs/csmap_api.md b/docs/csmap_api.md
index 164b0f8a..d739283b 100644
--- a/docs/csmap_api.md
+++ b/docs/csmap_api.md
@@ -72,6 +72,7 @@ csmap_X_result        csmap_X_push(csmap_X* self, csmap_X_value entry);
 
 csmap_X_result        csmap_X_emplace(csmap_X* self, i_keyraw rkey, i_valraw rmapped);           // no change if rkey in map
 csmap_X_result        csmap_X_emplace_or_assign(csmap_X* self, i_keyraw rkey, i_valraw rmapped); // always update rmapped
+csmap_X_result        csmap_X_emplace_key(csmap_X* self, i_keyraw rkey);    // if key not in map, mapped is left unassigned
 
 int                   csmap_X_erase(csmap_X* self, i_keyraw rkey);
 csmap_X_iter          csmap_X_erase_at(csmap_X* self, csmap_X_iter it);                          // returns iter after it
diff --git a/include/stc/algo/filter.h b/include/stc/algo/filter.h
index 1a62c3e1..320cd50d 100644
--- a/include/stc/algo/filter.h
+++ b/include/stc/algo/filter.h
@@ -24,7 +24,7 @@
 #include <stdio.h>
 #define i_val int
 #include <stc/cstack.h>
-#include <stc/calgo.h>
+#include <stc/algorithm.h>
 
 int main(void)
 {
diff --git a/include/stc/cmap.h b/include/stc/cmap.h
index 513a8b93..2dd8cbe6 100644
--- a/include/stc/cmap.h
+++ b/include/stc/cmap.h
@@ -55,7 +55,6 @@ int main(void) {
 #include <stdlib.h>
 #include <string.h>
 struct chash_slot { uint8_t hashx; };
-typedef struct { intptr_t idx; uint8_t hashx, found; } chash_bucket;
 #endif // CMAP_H_INCLUDED
 
 #ifndef _i_prefix
@@ -94,7 +93,7 @@ STC_API _cx_Self        _cx_MEMB(_clone)(_cx_Self map);
 STC_API void            _cx_MEMB(_drop)(_cx_Self* self);
 STC_API void            _cx_MEMB(_clear)(_cx_Self* self);
 STC_API bool            _cx_MEMB(_reserve)(_cx_Self* self, intptr_t capacity);
-STC_API chash_bucket    _cx_MEMB(_bucket_)(const _cx_Self* self, const _cx_keyraw* rkeyptr);
+STC_API _cx_result      _cx_MEMB(_bucket_)(const _cx_Self* self, const _cx_keyraw* rkeyptr);
 STC_API _cx_result      _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey);
 STC_API void            _cx_MEMB(_erase_entry)(_cx_Self* self, _cx_value* val);
 STC_API float           _cx_MEMB(_max_load_factor)(const _cx_Self* self);
@@ -106,9 +105,9 @@ STC_INLINE bool         _cx_MEMB(_empty)(const _cx_Self* map) { return !map->siz
 STC_INLINE intptr_t     _cx_MEMB(_size)(const _cx_Self* map) { return (intptr_t)map->size; }
 STC_INLINE intptr_t     _cx_MEMB(_bucket_count)(_cx_Self* map) { return map->bucket_count; }
 STC_INLINE bool         _cx_MEMB(_contains)(const _cx_Self* self, _cx_keyraw rkey)
-                            { return self->size && _cx_MEMB(_bucket_)(self, &rkey).found; }
+                            { return self->size && !_cx_MEMB(_bucket_)(self, &rkey).inserted; }
 
-#ifndef _i_isset
+#ifdef _i_ismap
     STC_API _cx_result _cx_MEMB(_insert_or_assign)(_cx_Self* self, i_key key, i_val mapped);
     #if !defined i_no_emplace
         STC_API _cx_result  _cx_MEMB(_emplace_or_assign)(_cx_Self* self, _cx_keyraw rkey, i_valraw rmapped);
@@ -116,14 +115,15 @@ STC_INLINE bool         _cx_MEMB(_contains)(const _cx_Self* self, _cx_keyraw rke
 
     STC_INLINE const _cx_mapped*
     _cx_MEMB(_at)(const _cx_Self* self, _cx_keyraw rkey) {
-        chash_bucket b = _cx_MEMB(_bucket_)(self, &rkey);
-        c_assert(b.found);
-        return &self->data[b.idx].second;
+        _cx_result b = _cx_MEMB(_bucket_)(self, &rkey);
+        c_assert(!b.inserted);
+        return &b.ref->second;
     }
+
     STC_INLINE _cx_mapped*
     _cx_MEMB(_at_mut)(_cx_Self* self, _cx_keyraw rkey)
         { return (_cx_mapped*)_cx_MEMB(_at)(self, rkey); }
-#endif // !_i_isset
+#endif // _i_ismap
 
 #if !defined i_no_clone
 STC_INLINE void _cx_MEMB(_copy)(_cx_Self *self, const _cx_Self* other) {
@@ -151,6 +151,16 @@ _cx_MEMB(_emplace)(_cx_Self* self, _cx_keyraw rkey _i_MAP_ONLY(, i_valraw rmappe
     }
     return _res;
 }
+
+#ifdef _i_ismap
+    STC_INLINE _cx_result
+    _cx_MEMB(_emplace_key)(_cx_Self* self, _cx_keyraw rkey) {
+        _cx_result _res = _cx_MEMB(_insert_entry_)(self, rkey);
+        if (_res.inserted)
+            _res.ref->first = i_keyfrom(rkey);
+        return _res;
+    }
+#endif // _i_ismap
 #endif // !i_no_emplace
 
 STC_INLINE _cx_raw _cx_MEMB(_value_toraw)(const _cx_value* val) {
@@ -215,19 +225,19 @@ STC_INLINE _cx_iter _cx_MEMB(_advance)(_cx_iter it, size_t n) {
 
 STC_INLINE _cx_iter
 _cx_MEMB(_find)(const _cx_Self* self, _cx_keyraw rkey) {
-    chash_bucket b;
-    if (self->size && (b = _cx_MEMB(_bucket_)(self, &rkey)).found)
-        return c_LITERAL(_cx_iter){self->data + b.idx, 
+    _cx_result b;
+    if (self->size && !(b = _cx_MEMB(_bucket_)(self, &rkey)).inserted)
+        return c_LITERAL(_cx_iter){b.ref, 
                                    self->data + self->bucket_count,
-                                   self->slot + b.idx};
+                                   self->slot + (b.ref - self->data)};
     return _cx_MEMB(_end)(self);
 }
 
 STC_INLINE const _cx_value*
 _cx_MEMB(_get)(const _cx_Self* self, _cx_keyraw rkey) {
-    chash_bucket b;
-    if (self->size && (b = _cx_MEMB(_bucket_)(self, &rkey)).found)
-        return self->data + b.idx;
+    _cx_result b;
+    if (self->size && !(b = _cx_MEMB(_bucket_)(self, &rkey)).inserted)
+        return b.ref;
     return NULL;
 }
 
@@ -237,10 +247,10 @@ _cx_MEMB(_get_mut)(_cx_Self* self, _cx_keyraw rkey)
 
 STC_INLINE int
 _cx_MEMB(_erase)(_cx_Self* self, _cx_keyraw rkey) {
-    chash_bucket b = {0};
-    if (self->size && (b = _cx_MEMB(_bucket_)(self, &rkey)).found)
-        _cx_MEMB(_erase_entry)(self, self->data + b.idx);
-    return b.found;
+    _cx_result b;
+    if (self->size && !(b = _cx_MEMB(_bucket_)(self, &rkey)).inserted)
+        { _cx_MEMB(_erase_entry)(self, b.ref); return 1; }
+    return 0;
 }
 
 STC_INLINE _cx_iter
@@ -313,7 +323,7 @@ STC_DEF void _cx_MEMB(_clear)(_cx_Self* self) {
     c_memset(self->slot, 0, c_sizeof(chash_slot)*self->bucket_count);
 }
 
-#ifndef _i_isset
+#ifdef _i_ismap
     STC_DEF _cx_result
     _cx_MEMB(_insert_or_assign)(_cx_Self* self, i_key _key, i_val _mapped) {
         _cx_result _res = _cx_MEMB(_insert_entry_)(self, i_keyto((&_key)));
@@ -340,42 +350,41 @@ STC_DEF void _cx_MEMB(_clear)(_cx_Self* self) {
         return _res;
     }
     #endif // !i_no_emplace
-#endif // !_i_isset
+#endif // _i_ismap
 
-STC_DEF chash_bucket
+STC_DEF _cx_result
 _cx_MEMB(_bucket_)(const _cx_Self* self, const _cx_keyraw* rkeyptr) {
     const uint64_t _hash = i_hash(rkeyptr);
     intptr_t _cap = self->bucket_count;
-    chash_bucket b = {fastrange_2(_hash, _cap), (uint8_t)(_hash | 0x80)};
+    intptr_t _idx = fastrange_2(_hash, _cap);
+    _cx_result b = {NULL, true, (uint8_t)(_hash | 0x80)};
     const chash_slot* s = self->slot;
-    while (s[b.idx].hashx) {
-        if (s[b.idx].hashx == b.hashx) {
-            const _cx_keyraw _raw = i_keyto(_i_keyref(self->data + b.idx));
+    while (s[_idx].hashx) {
+        if (s[_idx].hashx == b.hashx) {
+            const _cx_keyraw _raw = i_keyto(_i_keyref(self->data + _idx));
             if (i_eq((&_raw), rkeyptr)) {
-                b.found = true; 
+                b.inserted = false; 
                 break;
             }
         }
-        if (++b.idx == _cap) b.idx = 0;
+        if (++_idx == _cap) _idx = 0;
     }
+    b.ref = self->data + _idx;
     return b;
 }
 
 STC_DEF _cx_result
 _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey) {
-    _cx_result res = {NULL};
     if (self->size >= (intptr_t)((float)self->bucket_count * (i_max_load_factor)))
         if (!_cx_MEMB(_reserve)(self, (intptr_t)(self->size*3/2 + 2)))
-            return res;
+            return c_LITERAL(_cx_result){NULL};
 
-    chash_bucket b = _cx_MEMB(_bucket_)(self, &rkey);
-    res.ref = &self->data[b.idx];
-    if (!b.found) {
-        self->slot[b.idx].hashx = b.hashx;
-        res.inserted = true;
+    _cx_result b = _cx_MEMB(_bucket_)(self, &rkey);
+    if (b.inserted) {
+        self->slot[b.ref - self->data].hashx = b.hashx;
         ++self->size;
     }
-    return res;
+    return b;
 }
 
 #if !defined i_no_clone
@@ -417,9 +426,9 @@ _cx_MEMB(_reserve)(_cx_Self* self, const intptr_t _newcap) {
         const chash_slot* s = self->slot;
         for (intptr_t i = 0; i < _oldbucks; ++i, ++d) if ((s++)->hashx) {
             _cx_keyraw r = i_keyto(_i_keyref(d));
-            chash_bucket b = _cx_MEMB(_bucket_)(&m, &r);
-            m.slot[b.idx].hashx = b.hashx;
-            m.data[b.idx] = *d; // move
+            _cx_result b = _cx_MEMB(_bucket_)(&m, &r);
+            m.slot[b.ref - m.data].hashx = b.hashx;
+            *b.ref = *d; // move
         }
         c_swap(_cx_Self, self, &m);
     }
diff --git a/include/stc/csmap.h b/include/stc/csmap.h
index f4d33a4d..d2e1d1fc 100644
--- a/include/stc/csmap.h
+++ b/include/stc/csmap.h
@@ -170,19 +170,29 @@ _cx_MEMB(_shrink_to_fit)(_cx_Self *self) {
 }
 #endif // !i_no_clone
 
-#ifndef _i_isset
+STC_API _cx_result _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey);
+
+#ifdef _i_ismap
     STC_API _cx_result _cx_MEMB(_insert_or_assign)(_cx_Self* self, i_key key, i_val mapped);
     #if !defined i_no_emplace
         STC_API _cx_result  _cx_MEMB(_emplace_or_assign)(_cx_Self* self, _cx_keyraw rkey, i_valraw rmapped);
-    #endif
 
+        STC_INLINE _cx_result
+        _cx_MEMB(_emplace_key)(_cx_Self* self, _cx_keyraw rkey) {
+            _cx_result res = _cx_MEMB(_insert_entry_)(self, rkey);
+            if (res.inserted)
+                res.ref->first = i_keyfrom(rkey);
+            return res;
+        }
+    #endif
     STC_INLINE const _cx_mapped*
     _cx_MEMB(_at)(const _cx_Self* self, _cx_keyraw rkey)
         { _cx_iter it; return &_cx_MEMB(_find_it)(self, rkey, &it)->second; }
+
     STC_INLINE _cx_mapped*
     _cx_MEMB(_at_mut)(_cx_Self* self, _cx_keyraw rkey)
         { _cx_iter it; return &_cx_MEMB(_find_it)(self, rkey, &it)->second; }
-#endif // !_i_isset
+#endif // _i_ismap
 
 STC_INLINE _cx_iter
 _cx_MEMB(_end)(const _cx_Self* self) {
@@ -209,8 +219,6 @@ _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
     return true;
 }
 
-static _cx_result _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey);
-
 STC_INLINE _cx_result
 _cx_MEMB(_insert)(_cx_Self* self, i_key _key _i_MAP_ONLY(, i_val _mapped)) {
     _cx_result _res = _cx_MEMB(_insert_entry_)(self, i_keyto((&_key)));
@@ -326,7 +334,7 @@ _cx_MEMB(_new_node_)(_cx_Self* self, int level) {
     return tn;
 }
 
-#ifndef _i_isset
+#ifdef _i_ismap
     STC_DEF _cx_result
     _cx_MEMB(_insert_or_assign)(_cx_Self* self, i_key _key, i_val _mapped) {
         _cx_result _res = _cx_MEMB(_insert_entry_)(self, i_keyto((&_key)));
@@ -353,7 +361,7 @@ _cx_MEMB(_new_node_)(_cx_Self* self, int level) {
         return _res;
     }
     #endif // !i_no_emplace
-#endif // !_i_isset
+#endif // !_i_ismap
 
 STC_DEF _cx_value*
 _cx_MEMB(_find_it)(const _cx_Self* self, _cx_keyraw rkey, _cx_iter* out) {
@@ -407,7 +415,7 @@ _cx_MEMB(_split_)(_cx_node *d, int32_t tn) {
     return tn;
 }
 
-static int32_t
+STC_DEF int32_t
 _cx_MEMB(_insert_entry_i_)(_cx_Self* self, int32_t tn, const _cx_keyraw* rkey, _cx_result* _res) {
     int32_t up[64], tx = tn;
     _cx_node* d = self->nodes;
@@ -439,7 +447,7 @@ _cx_MEMB(_insert_entry_i_)(_cx_Self* self, int32_t tn, const _cx_keyraw* rkey, _
     return up[0];
 }
 
-static _cx_result
+STC_DEF _cx_result
 _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey) {
     _cx_result res = {NULL};
     int32_t tn = _cx_MEMB(_insert_entry_i_)(self, self->root, &rkey, &res);
@@ -448,7 +456,7 @@ _cx_MEMB(_insert_entry_)(_cx_Self* self, _cx_keyraw rkey) {
     return res;
 }
 
-static int32_t
+STC_DEF int32_t
 _cx_MEMB(_erase_r_)(_cx_Self *self, int32_t tn, const _cx_keyraw* rkey, int *erased) {
     _cx_node *d = self->nodes;
     if (tn == 0)
@@ -533,7 +541,7 @@ _cx_MEMB(_erase_range)(_cx_Self* self, _cx_iter it1, _cx_iter it2) {
 }
 
 #if !defined i_no_clone
-static int32_t
+STC_DEF int32_t
 _cx_MEMB(_clone_r_)(_cx_Self* self, _cx_node* src, int32_t sn) {
     if (sn == 0)
         return 0;
diff --git a/include/stc/forward.h b/include/stc/forward.h
index 484a8b63..085205cf 100644
--- a/include/stc/forward.h
+++ b/include/stc/forward.h
@@ -120,6 +120,7 @@ typedef struct chash_slot chash_slot;
     typedef struct { \
         SELF##_value *ref; \
         bool inserted; \
+        uint8_t hashx; \
     } SELF##_result; \
 \
     typedef struct { \
diff --git a/misc/examples/smartpointers/arc_containers.c b/misc/examples/smartpointers/arc_containers.c
index 2fb04c56..6209005d 100644
--- a/misc/examples/smartpointers/arc_containers.c
+++ b/misc/examples/smartpointers/arc_containers.c
@@ -2,7 +2,6 @@
 // and demonstrate sharing and cloning of maps.
 #define i_implement
 #include <stc/cstr.h>
-#include <stc/algo/raii.h>
 #define i_type Map
 #define i_key_str // strings
 #define i_val int
diff --git a/misc/tests/cspan_test.c b/misc/tests/cspan_test.c
index d7ca9b64..ce267b14 100644
--- a/misc/tests/cspan_test.c
+++ b/misc/tests/cspan_test.c
@@ -1,6 +1,5 @@
 #include <stdio.h>
 #include <stc/cspan.h>
-#include <stc/algo/raii.h>
 #include "ctest.h"
 
 using_cspan3(intspan, int);
@@ -48,7 +47,8 @@ CTEST(cspan, slice) {
 #include <stc/cstack.h>
 
 CTEST(cspan, slice2) {
-    c_auto (cstack_int, stack)
+    cstack_int stack = {0};
+    c_defer (cstack_int_drop(&stack))
     {
         c_forrange (i, 10*20*30)
             cstack_int_push(&stack, i);
-- 
cgit v1.2.3


From 078f20f2e378543f078e86f8ad256887378ce92b Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Fri, 28 Jul 2023 11:20:25 +0200
Subject: Improved crand docs and commented out the irrelevant 32-bit variants
 in the benchmark.

---
 docs/crandom_api.md                        | 28 ++++++++++++---------------
 misc/benchmarks/various/prng_bench.cpp     | 31 ++++++++++++++----------------
 misc/examples/smartpointers/arcvec_erase.c |  3 ++-
 3 files changed, 28 insertions(+), 34 deletions(-)

(limited to 'misc/examples/smartpointers')

diff --git a/docs/crandom_api.md b/docs/crandom_api.md
index 88924784..c6491243 100644
--- a/docs/crandom_api.md
+++ b/docs/crandom_api.md
@@ -8,27 +8,23 @@ See [random](https://en.cppreference.com/w/cpp/header/random) for similar c++ fu
 
 ## Description
 
-**crand64** is a novel, very fast PRNG, suited for parallel usage. It features a
-Weyl-sequence as part of its state. It is based on *sfc64*, but has a different output function
-and state size.
+**crand64** is a very fast PRNG, suited for parallel usage. It is based on *sfc64*, but has a
+different output function and state size. It features a Weyl-sequence as part of its state. 
 
-**sfc64** is the fastest among *pcg*, *xoshiro`**`*, and *lehmer*. It is equally fast or faster than
-*sfc64* on most platforms. *wyrand* is faster on platforms with fast 128-bit multiplication, and has
-2^64 period (https://github.com/lemire/SwiftWyhash/issues/10). *wyrand* is not suited for massive
-parallel usage due to its limited minimal period.
+**crand64** is faster or equally fast as *wyrand*, *xoshiro\*\**, *sfc64*, and *romu_trio*
+with both **clang 16.0** and **gcc 13.1** from the [prng_bench.c](../misc/benchmarks/various/prng_bench.cpp)
+on windows 11, Ryzen 7 5700X. (clang does not optimize *xoshiro\*\** and *sfc64* as well as gcc does).
 
-**crand64** does not require multiplication or 128-bit integer operations. It has 320 bit state,
-where 64-bits are constant per prng instance created.
-
-There is no *jump function*, but each odd number Weyl-increment (state[4]) starts a new
+**crand64** has no jump *function*, but each odd number Weyl-increment (state[4]) starts a new
 unique 2^64 *minimum* length period, i.e. virtually unlimitied number of unique threads.
+In contrast, *wyrand* and *sfc64* have only a (total) minimum period of 2^64 (*romu_trio* has
+no guarantees), and may therefore not be suited for massive parallel usage (for purists).
 
-**crand64** passes *PractRand* (tested up to 8TB output), Vigna's Hamming weight test, and simple
-correlation tests, i.e. *n* interleaved streams with only one-bit differences in initial state.
-Also 32-bit and 16-bit versions passes PractRand up to their size limits.
+**crand64** does not require multiplication or 128-bit integer operations. It has 320 bit state,
+where 64-bits are constant per instance.
 
-For more, see the PRNG shootout by Vigna: http://prng.di.unimi.it and a debate between the authors of
-xoshiro and pcg (Vigna/O'Neill) PRNGs: https://www.pcg-random.org/posts/on-vignas-pcg-critique.html
+**crand64** passes *PractRand* (tested up to 8TB output), Vigna's Hamming weight test, and simple
+correlation tests. The 16- and 32-bit variants also passes PractRand up to their size limits.
 
 ## Header file
 
diff --git a/misc/benchmarks/various/prng_bench.cpp b/misc/benchmarks/various/prng_bench.cpp
index 234e3805..cd43ff36 100644
--- a/misc/benchmarks/various/prng_bench.cpp
+++ b/misc/benchmarks/various/prng_bench.cpp
@@ -66,7 +66,7 @@ uint32_t pcg32(uint32_t s[2]) {
 }
 
 
-/* xoshiro128+  */
+/* xo(ro)shiro  */
 
 uint64_t xoroshiro128plus(uint64_t s[2]) {
     const uint64_t s0 = s[0];
@@ -80,9 +80,6 @@ uint64_t xoroshiro128plus(uint64_t s[2]) {
     return result;
 }
 
-
-/* xoshiro256**  */
-
 static inline uint64_t xoshiro256starstar(uint64_t s[4]) {
     const uint64_t result = rotl64(s[1] * 5, 7) * 9;
     const uint64_t t = s[1] << 17;
@@ -95,7 +92,7 @@ static inline uint64_t xoshiro256starstar(uint64_t s[4]) {
     return result;
 }
 
-// wyrand - 2020-12-07
+/* wyrand - 2020-12-07 */
 static inline void _wymum(uint64_t *A, uint64_t *B){
 #if defined(__SIZEOF_INT128__)
     __uint128_t r = *A; r *= *B;
@@ -136,44 +133,44 @@ int main(void)
     for (size_t ti = 0; ti < 2; ti++) {
         init_state(rng.state, 12345123);
         cout << endl << "ROUND " << ti+1 << " ---------" << endl;
-
+/*
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = romu_trio(rng.state);
+            recipient[i] = sfc32((uint32_t *)rng.state);
         end = clock();
-        cout << "romu_trio:\t"
+        cout << "sfc32:\t\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
              << "s: " << recipient[312] << endl;
 
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = wyrand64(rng.state);
+            recipient[i] = stc32((uint32_t *)rng.state);
         end = clock();
-        cout << "wyrand64:\t"
+        cout << "stc32:\t\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
              << "s: " << recipient[312] << endl;
 
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = sfc32((uint32_t *)rng.state);
+            recipient[i] = pcg32((uint32_t *)rng.state);
         end = clock();
-        cout << "sfc32:\t\t"
+        cout << "pcg32:\t\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
              << "s: " << recipient[312] << endl;
-
+*/
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = stc32((uint32_t *)rng.state);
+            recipient[i] = romu_trio(rng.state);
         end = clock();
-        cout << "stc32:\t\t"
+        cout << "romu_trio:\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
              << "s: " << recipient[312] << endl;
 
         beg = clock();
         for (size_t i = 0; i < N; i++)
-            recipient[i] = pcg32((uint32_t *)rng.state);
+            recipient[i] = wyrand64(rng.state);
         end = clock();
-        cout << "pcg32:\t\t"
+        cout << "wyrand64:\t"
              << (float(end - beg) / CLOCKS_PER_SEC)
              << "s: " << recipient[312] << endl;
 
diff --git a/misc/examples/smartpointers/arcvec_erase.c b/misc/examples/smartpointers/arcvec_erase.c
index ba54c1c7..9d757533 100644
--- a/misc/examples/smartpointers/arcvec_erase.c
+++ b/misc/examples/smartpointers/arcvec_erase.c
@@ -19,7 +19,8 @@ int main(void)
     
     // clone the second 2012 and push it back.
     // note: cloning make sure that vec.data[2] has ref count 2.
-    Vec_push(&vec, Arc_clone(vec.data[2]));
+    Vec_push(&vec, Arc_clone(vec.data[2]));  // => share vec.data[2]
+    Vec_emplace(&vec, *vec.data[2].get);     // => deep-copy vec.data[2]
     
     printf("vec before erase :");
     c_foreach (i, Vec, vec)
-- 
cgit v1.2.3


From be5651c9fc3d3ecd2d9d24e6e4763260ef86de41 Mon Sep 17 00:00:00 2001
From: Tyge Løvset <tylo@norceresearch.no>
Date: Thu, 10 Aug 2023 21:17:48 +0200
Subject: Update template.h - also renamed i_cmp_native => i_use_cmp

---
 README.md                                    |  4 +-
 docs/carc_api.md                             |  2 +-
 docs/cbox_api.md                             |  2 +-
 docs/cdeq_api.md                             |  2 +-
 docs/clist_api.md                            |  2 +-
 docs/cvec_api.md                             |  4 +-
 include/stc/carc.h                           | 64 ++++++++++++---------------
 include/stc/cbox.h                           | 65 ++++++++++++----------------
 include/stc/ccommon.h                        |  2 +-
 include/stc/priv/template.h                  | 29 ++++++-------
 include/stc/priv/template2.h                 |  2 +-
 misc/examples/linkedlists/intrusive.c        |  2 +-
 misc/examples/linkedlists/list.c             |  2 +-
 misc/examples/linkedlists/new_list.c         |  2 +-
 misc/examples/mixed/astar.c                  |  1 -
 misc/examples/mixed/complex.c                |  1 -
 misc/examples/mixed/demos.c                  |  3 +-
 misc/examples/smartpointers/arc_containers.c |  4 +-
 misc/examples/smartpointers/arc_demo.c       |  3 +-
 misc/examples/smartpointers/arcvec_erase.c   |  3 +-
 misc/examples/smartpointers/box.c            |  1 +
 misc/examples/smartpointers/box2.c           |  1 -
 misc/examples/smartpointers/music_arc.c      |  4 +-
 misc/examples/smartpointers/new_sptr.c       |  3 +-
 misc/examples/smartpointers/person_arc.c     |  3 +-
 misc/examples/sortedmaps/csmap_insert.c      |  1 -
 misc/examples/sortedmaps/multimap.c          |  1 +
 misc/examples/vectors/lower_bound.c          |  2 +-
 28 files changed, 99 insertions(+), 116 deletions(-)

(limited to 'misc/examples/smartpointers')

diff --git a/README.md b/README.md
index 69c51417..48ccdd6f 100644
--- a/README.md
+++ b/README.md
@@ -251,7 +251,7 @@ struct Point { float x, y; };
 #include <stc/cvec.h>   // cvec_pnt: vector of struct Point
 
 #define i_key int
-#define i_cmp_native    // enable sort/search. Use native `<` and `==` operators
+#define i_use_cmp       // enable sort/search. Use native `<` and `==` operators
 #include <stc/clist.h>  // clist_int: singly linked list
 
 #define i_key int
@@ -658,7 +658,7 @@ STC is generally very memory efficient. Memory usage for the different container
     - Removed deprecated <stc/crandom.h>. Use `<stc/crand.h>` with the new API.
         - Reverted names _unif and _norm back to `_uniform` and `_normal`.
     - Removed default comparison for **clist**, **cvec** and **cdeq**:
-        - Define `i_cmp_native` to enable comparison for built-in i_key types (<, ==).
+        - Define `i_use_cmp` to enable comparison for built-in i_key types (<, ==).
         - Use of `i_keyclass` still expects comparison functions to be defined. 
         - Use of `i_keyboxed` compares stored pointers instead of pointed to values if comparison not defined.
     - Renamed input enum flags for ***cregex***-functions.
diff --git a/docs/carc_api.md b/docs/carc_api.md
index fb79019a..3e394378 100644
--- a/docs/carc_api.md
+++ b/docs/carc_api.md
@@ -25,7 +25,7 @@ See similar c++ class [std::shared_ptr](https://en.cppreference.com/w/cpp/memory
 #define i_cmp <f>          // three-way compareison. REQUIRED IF i_key is a non-integral type
                            // Note that containers of carcs will "inherit" i_cmp
                            // when using carc in containers with i_valboxed MyArc - ie. the i_type.
-#define i_cmp_native       // define instead of i_cmp only when i_key is an integral/native-type.
+#define i_use_cmp          // define instead of i_cmp only when i_key is an integral/native-type.
 #define i_keydrop <f>      // destroy element func - defaults to empty destruct
 #define i_keyclone <f>     // REQUIRED if i_keydrop is defined, unless 'i_opt c_no_clone' is defined.
 
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index 0e6fca64..c683d9ef 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -19,7 +19,7 @@ See similar c++ class [std::unique_ptr](https://en.cppreference.com/w/cpp/memory
 #define i_cmp <f>       // three-way compareison. REQUIRED IF i_key is a non-integral type
                         // Note that containers of carcs will "inherit" i_cmp
                         // when using carc in containers with i_valboxed MyArc - ie. the i_type.
-#define i_cmp_native    // define instead of i_cmp only when i_key is an integral/native-type.
+#define i_use_cmp       // define instead of i_cmp only when i_key is an integral/native-type.
 #define i_keydrop <f>   // destroy element func - defaults to empty destruct
 #define i_keyclone <f>  // REQUIRED if i_keydrop is defined, unless 'i_opt c_no_clone' is defined.
 
diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md
index c544f213..3ce58e78 100644
--- a/docs/cdeq_api.md
+++ b/docs/cdeq_api.md
@@ -13,7 +13,7 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque
 #define i_key <t>      // element type: REQUIRED. Note: i_val* may be specified instead of i_key*.
 #define i_type <t>     // cdeq container type name
 #define i_cmp <f>      // three-way compare of two i_keyraw*.
-#define i_cmp_native   // define instead of i_cmp only when i_key is an integral/native-type.
+#define i_use_cmp      // define instead of i_cmp only when i_key is an integral/native-type.
 #define i_keydrop <f>  // destroy value func - defaults to empty destruct
 #define i_keyclone <f> // REQUIRED IF i_keydrop is defined
 
diff --git a/docs/clist_api.md b/docs/clist_api.md
index d8d614c2..a24d813b 100644
--- a/docs/clist_api.md
+++ b/docs/clist_api.md
@@ -25,7 +25,7 @@ See the c++ class [std::list](https://en.cppreference.com/w/cpp/container/list)
 #define i_key <t>      // element type: REQUIRED. Note: i_val* may be specified instead of i_key*.
 #define i_type <t>     // clist container type name
 #define i_cmp <f>      // three-way compare two i_keyraw*
-#define i_cmp_native   // define instead of i_cmp only when i_key is an integral/native-type.
+#define i_use_cmp      // define instead of i_cmp only when i_key is an integral/native-type.
 #define i_keydrop <f>  // destroy value func - defaults to empty destruct
 #define i_keyclone <f> // REQUIRED IF i_keydrop defined
 
diff --git a/docs/cvec_api.md b/docs/cvec_api.md
index 3f827df6..8997ed51 100644
--- a/docs/cvec_api.md
+++ b/docs/cvec_api.md
@@ -15,7 +15,7 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect
 #define i_type <t>     // container type name
 #define i_key <t>      // element type: REQUIRED. Note: i_val* may be specified instead of i_key*.
 #define i_cmp <f>      // three-way compare two i_keyraw*
-#define i_cmp_native   // define instead of i_cmp only when i_key is an integral/native-type.
+#define i_use_cmp      // define instead of i_cmp only when i_key is an integral/native-type.
 #define i_keydrop <f>  // destroy value func - defaults to empty destruct
 #define i_keyclone <f> // REQUIRED IF i_keydrop defined
 
@@ -224,4 +224,4 @@ int main(void) {
 
     c_drop(UVec, &vec, &vec2); // cleanup
 }
-```
\ No newline at end of file
+```
diff --git a/include/stc/carc.h b/include/stc/carc.h
index 9ba2ddd1..e1dfe14e 100644
--- a/include/stc/carc.h
+++ b/include/stc/carc.h
@@ -176,50 +176,40 @@ STC_INLINE void _cx_MEMB(_assign)(_cx_Self* self, _cx_Self ptr) {
     *self = ptr;
 }
 
-#if defined _i_has_cmp
+#if defined i_use_cmp
     STC_INLINE int _cx_MEMB(_raw_cmp)(const _cx_raw* rx, const _cx_raw* ry)
         { return i_cmp(rx, ry); }
 
-    STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
-        _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
-        return i_cmp((&rx), (&ry));
-    }
-#else
-    STC_INLINE int _cx_MEMB(_raw_cmp)(const _cx_raw* rx, const _cx_raw* ry)
-        { return c_default_cmp(&rx, &ry); }
-
-    STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
-        return c_default_cmp(&self->get, &other->get);
-    }
-#endif
-#if defined _i_has_eq || defined _i_has_cmp
     STC_INLINE bool _cx_MEMB(_raw_eq)(const _cx_raw* rx, const _cx_raw* ry)
         { return i_eq(rx, ry); }
-
-    STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
-        _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
-        return i_eq((&rx), (&ry));
-    }
-#else
-    STC_INLINE bool _cx_MEMB(_raw_eq)(const _cx_raw* rx, const _cx_raw* ry)
-        { return rx == ry; }
-
-    STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
-        return self->get == other->get;
-    }
-#endif
-#if defined i_hash
+    #ifndef i_no_hash
     STC_INLINE uint64_t _cx_MEMB(_raw_hash)(const _cx_raw* rx)
         { return i_hash(rx); }
-
-    STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
-        { _cx_raw rx = i_keyto(self->get); return i_hash(&rx); }
-#else
-    STC_INLINE uint64_t _cx_MEMB(_raw_hash)(const _cx_raw* rx)
-        { return c_default_hash(&rx); }
-
-    STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
-        { return c_default_hash(&self->get); }
+    #endif // i_no_hash
+
+    #if defined i_ptr_cmp
+        STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
+            return c_default_cmp(&self->get, &other->get);
+        }
+        STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
+            return self->get == other->get;
+        }
+        STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
+            { return c_default_hash(&self->get); }
+    #else
+        STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
+            _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
+            return i_cmp((&rx), (&ry));
+        }
+        STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
+            _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
+            return i_eq((&rx), (&ry));
+        }
+        #ifndef i_no_hash
+        STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
+            { _cx_raw rx = i_keyto(self->get); return i_hash(&rx); }
+        #endif // i_no_hash
+    #endif // i_ptr_cmp
 #endif
 
 #undef _i_atomic_inc
diff --git a/include/stc/cbox.h b/include/stc/cbox.h
index 25d41b92..b799c24c 100644
--- a/include/stc/cbox.h
+++ b/include/stc/cbox.h
@@ -159,50 +159,41 @@ STC_INLINE void _cx_MEMB(_assign)(_cx_Self* self, _cx_Self* moved) {
     moved->get = NULL;
 }
 
-#if defined _i_has_cmp
+#if defined i_use_cmp
     STC_INLINE int _cx_MEMB(_raw_cmp)(const _cx_raw* rx, const _cx_raw* ry)
         { return i_cmp(rx, ry); }
 
-    STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
-        _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
-        return i_cmp((&rx), (&ry));
-    }
-#else
-    STC_INLINE int _cx_MEMB(_raw_cmp)(const _cx_raw* rx, const _cx_raw* ry)
-        { return c_default_cmp(&rx, &ry); }
-
-    STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
-        return c_default_cmp(&self->get, &other->get);
-    }
-#endif
-#if defined _i_has_eq || defined _i_has_cmp
     STC_INLINE bool _cx_MEMB(_raw_eq)(const _cx_raw* rx, const _cx_raw* ry)
         { return i_eq(rx, ry); }
-
-    STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
-        _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
-        return i_eq((&rx), (&ry));
-    }
-#else
-    STC_INLINE bool _cx_MEMB(_raw_eq)(const _cx_raw* rx, const _cx_raw* ry)
-        { return rx == ry; }
-
-    STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
-        return self->get == other->get;
-    }
-#endif
-#if defined i_hash
+    #ifndef i_no_hash
     STC_INLINE uint64_t _cx_MEMB(_raw_hash)(const _cx_raw* rx)
         { return i_hash(rx); }
-
-    STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
-        { _cx_raw rx = i_keyto(self->get); return i_hash(&rx); }
-#else
-    STC_INLINE uint64_t _cx_MEMB(_raw_hash)(const _cx_raw* rx)
-        { return c_default_hash(&rx); }
-
-    STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
-        { return c_default_hash(&self->get); }
+    #endif // i_no_hash
+
+    #if defined i_ptr_cmp
+        STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
+            return c_default_cmp(&self->get, &other->get);
+        }
+        STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
+            return self->get == other->get;
+        }
+        STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
+            { return c_default_hash(&self->get); }
+    #else
+        STC_INLINE int _cx_MEMB(_cmp)(const _cx_Self* self, const _cx_Self* other) {
+            _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
+            return i_cmp((&rx), (&ry));
+        }
+        STC_INLINE bool _cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
+            _cx_raw rx = i_keyto(self->get), ry = i_keyto(other->get);
+            return i_eq((&rx), (&ry));
+        }
+        #ifndef i_no_hash
+        STC_INLINE uint64_t _cx_MEMB(_hash)(const _cx_Self* self)
+            { _cx_raw rx = i_keyto(self->get); return i_hash(&rx); }
+        #endif // i_no_hash
+    #endif // i_ptr_cmp
 #endif
+
 #include "priv/template2.h"
 #undef _i_cbox
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index 2528b94f..b37ad1da 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -117,7 +117,7 @@ typedef long long _llong;
 #define c_no_clone              (1<<2)
 #define c_no_emplace            (1<<3)
 #define c_no_cmp                (1<<4)
-#define c_native_cmp            (1<<5)
+#define c_use_cmp               (1<<5)
 #define c_no_hash               (1<<6)
 /* Function macros and others */
 
diff --git a/include/stc/priv/template.h b/include/stc/priv/template.h
index 49b4d8da..fae9093e 100644
--- a/include/stc/priv/template.h
+++ b/include/stc/priv/template.h
@@ -102,8 +102,8 @@
 #if c_option(c_no_emplace)
   #define i_no_emplace
 #endif
-#if c_option(c_native_cmp)
-  #define i_cmp_native
+#if c_option(c_use_cmp) || defined _i_ismap || defined _i_isset || defined _i_ispque
+  #define i_use_cmp
 #endif
 #if c_option(c_no_clone) || defined _i_carc
   #define i_no_clone
@@ -127,7 +127,7 @@
 #elif defined i_keyboxed
   #define i_keyclass i_keyboxed
   #define i_rawclass c_PASTE(i_keyboxed, _raw)
-  #ifndef i_no_cmp
+  #if !defined i_no_cmp && defined i_use_cmp
     #define i_eq c_PASTE(i_keyboxed, _raw_eq)
   #endif
 #endif
@@ -138,7 +138,7 @@
   #define i_rawclass i_key
 #endif
 
-#ifdef i_keyclass
+#if defined i_keyclass
   #define i_key i_keyclass
   #ifndef i_keyclone
     #define i_keyclone c_PASTE(i_key, _clone)
@@ -154,8 +154,8 @@
   #endif
 #endif
 
-#ifdef i_rawclass
-  #if !(defined i_cmp || defined i_no_cmp)
+#if defined i_rawclass && defined i_use_cmp
+  #if !(defined i_cmp || defined i_less || defined i_no_cmp)
     #define i_cmp c_PASTE(i_keyraw, _cmp)
   #endif
   #if !(defined i_hash || defined i_no_hash || defined i_no_cmp)
@@ -171,26 +171,29 @@
   #endif
 #endif
 
-#ifndef i_no_cmp
-  #if defined i_cmp || defined i_less || defined i_cmp_native
+#if !defined i_no_cmp
+  #if defined i_cmp || defined i_less || defined i_use_cmp
     #define _i_has_cmp
   #endif
-  #if defined i_eq || defined i_cmp_native
+  #if defined i_eq || defined i_use_cmp
     #define _i_has_eq
   #endif
 #endif
+#if !(defined i_hash || defined i_no_hash || defined i_no_cmp)
+  #define i_hash c_default_hash
+#endif
 
 #if !defined i_key
   #error "No i_key or i_val defined"
 #elif defined i_keyraw ^ defined i_keyto
   #error "Both i_keyraw/i_valraw and i_keyto/i_valto must be defined, if any"
 #elif !defined i_no_clone && (defined i_keyclone ^ defined i_keydrop)
-  #error "Both i_keyclone/i_valclone and i_keydrop/i_valdrop must be defined, if any"
+  #error "Both i_keyclone/i_valclone and i_keydrop/i_valdrop must be defined, if any (unless i_no_clone defined)."
 #elif defined i_from || defined i_drop
   #error "i_from / i_drop not supported. Define i_keyfrom/i_valfrom and/or i_keydrop/i_valdrop instead"
 #elif defined i_keyraw && defined _i_ishash && !(defined i_hash && (defined _i_has_cmp || defined i_eq))
   #error "For cmap/cset, both i_hash and i_eq (or i_less or i_cmp) must be defined when i_keyraw is defined."
-#elif defined i_keyraw && (defined _i_ismap || defined _i_isset || defined _i_ispque) && !defined _i_has_cmp
+#elif defined i_keyraw && defined i_use_cmp && !defined _i_has_cmp
   #error "For csmap/csset/cpque, i_cmp or i_less must be defined when i_keyraw is defined."
 #endif
 
@@ -234,10 +237,6 @@
   #endif
 #endif
 
-#if !defined i_hash && (!(defined _i_cbox || defined _i_carc) || defined i_cmp_native)
-  #define i_hash c_default_hash
-#endif
-
 #if defined _i_ismap // ---- process cmap/csmap value i_val, ... ----
 
 #ifdef i_val_str
diff --git a/include/stc/priv/template2.h b/include/stc/priv/template2.h
index 351defde..1e0d4a2e 100644
--- a/include/stc/priv/template2.h
+++ b/include/stc/priv/template2.h
@@ -67,7 +67,7 @@
 #undef i_realloc
 #undef i_free
 
-#undef i_cmp_native
+#undef i_use_cmp
 #undef i_no_cmp
 #undef i_no_hash
 #undef i_no_clone
diff --git a/misc/examples/linkedlists/intrusive.c b/misc/examples/linkedlists/intrusive.c
index c7402d09..edb072c7 100644
--- a/misc/examples/linkedlists/intrusive.c
+++ b/misc/examples/linkedlists/intrusive.c
@@ -4,7 +4,7 @@
 
 #define i_type List
 #define i_key int
-#define i_cmp_native
+#define i_use_cmp
 #include <stc/clist.h>
 
 void printList(List list) {
diff --git a/misc/examples/linkedlists/list.c b/misc/examples/linkedlists/list.c
index 518cc09b..e83dc6b2 100644
--- a/misc/examples/linkedlists/list.c
+++ b/misc/examples/linkedlists/list.c
@@ -5,7 +5,7 @@
 
 #define i_type DList
 #define i_key double
-#define i_cmp_native
+#define i_use_cmp
 #include <stc/clist.h>
 
 int main(void) {
diff --git a/misc/examples/linkedlists/new_list.c b/misc/examples/linkedlists/new_list.c
index 2112bf1f..7518929a 100644
--- a/misc/examples/linkedlists/new_list.c
+++ b/misc/examples/linkedlists/new_list.c
@@ -27,7 +27,7 @@ int point_cmp(const Point* a, const Point* b) {
 #include <stc/clist.h>
 
 #define i_key float
-#define i_cmp_native               // use < and == operators for comparison 
+#define i_use_cmp               // use < and == operators for comparison 
 #include <stc/clist.h>
 
 void MyStruct_drop(MyStruct* s);
diff --git a/misc/examples/mixed/astar.c b/misc/examples/mixed/astar.c
index 590b7952..d15a9ed7 100644
--- a/misc/examples/mixed/astar.c
+++ b/misc/examples/mixed/astar.c
@@ -61,7 +61,6 @@ point_key_cmp(const point* a, const point* b)
 #include <stc/cpque.h>
 
 #define i_key point
-#define i_opt c_no_cmp
 #include <stc/cdeq.h>
 
 #define i_key point
diff --git a/misc/examples/mixed/complex.c b/misc/examples/mixed/complex.c
index 4eb1574b..9fcbc417 100644
--- a/misc/examples/mixed/complex.c
+++ b/misc/examples/mixed/complex.c
@@ -14,7 +14,6 @@
 
 #define i_type StackList
 #define i_keyclass FloatStack  // "class" picks up _clone, _drop, _cmp
-#define i_opt c_no_cmp         // exclude FloatStack_cmp(): not defined
 #include <stc/clist.h>
 
 #define i_type ListMap
diff --git a/misc/examples/mixed/demos.c b/misc/examples/mixed/demos.c
index 7f5091fd..43c9a7ae 100644
--- a/misc/examples/mixed/demos.c
+++ b/misc/examples/mixed/demos.c
@@ -53,6 +53,7 @@ void vectordemo1(void)
 }
 
 #define i_key_str
+#define i_use_cmp
 #include <stc/cvec.h>
 
 void vectordemo2(void)
@@ -74,7 +75,7 @@ void vectordemo2(void)
 
 #define i_key int
 #define i_tag ix
-#define i_cmp_native
+#define i_use_cmp
 #include <stc/clist.h>
 
 void listdemo1(void)
diff --git a/misc/examples/smartpointers/arc_containers.c b/misc/examples/smartpointers/arc_containers.c
index 6209005d..c2bff56f 100644
--- a/misc/examples/smartpointers/arc_containers.c
+++ b/misc/examples/smartpointers/arc_containers.c
@@ -12,11 +12,11 @@
 #define i_key Map
 #define i_keydrop(p) (printf("drop Arc:\n"), Map_drop(p))
 // no need for atomic ref. count in single thread:
-#define i_opt c_no_atomic
+#define i_opt c_no_atomic|c_no_cmp
 #include <stc/carc.h>
 
 #define i_type Stack
-#define i_keyboxed Arc // define i_keyboxed for carc/cbox value (not i_key)
+#define i_keyboxed Arc // use i_keyboxed for carc/cbox key
 #include <stc/cvec.h>
 
 #define i_type List
diff --git a/misc/examples/smartpointers/arc_demo.c b/misc/examples/smartpointers/arc_demo.c
index 929a48a1..a66d84b0 100644
--- a/misc/examples/smartpointers/arc_demo.c
+++ b/misc/examples/smartpointers/arc_demo.c
@@ -11,13 +11,14 @@ void int_drop(int* x) {
 #define i_type Arc          // set type name to be defined (instead of 'carc_int')
 #define i_key int
 #define i_keydrop int_drop  // optional, just to display the elements destroyed
-#define i_cmp_native        // use int comparison (x < y, x == y).
+#define i_use_cmp           // use int comparison (x < y, x == y).
 #include <stc/carc.h>       // Arc
 
 #define i_keyboxed Arc      // note: use i_keyboxed instead of i_key for carc/cbox elements
 #include <stc/csset.h>      // csset_Arc (like: std::set<std::shared_ptr<int>>)
 
 #define i_keyboxed Arc      // note: as above.
+#define i_use_cmp
 #include <stc/cvec.h>       // cvec_Arc (like: std::vector<std::shared_ptr<int>>)
 
 int main(void)
diff --git a/misc/examples/smartpointers/arcvec_erase.c b/misc/examples/smartpointers/arcvec_erase.c
index 9d757533..0526b6a0 100644
--- a/misc/examples/smartpointers/arcvec_erase.c
+++ b/misc/examples/smartpointers/arcvec_erase.c
@@ -5,11 +5,12 @@ void show_drop(int* x) { printf("drop: %d\n", *x); }
 #define i_type Arc
 #define i_key int
 #define i_keydrop show_drop
-#define i_cmp_native        // enable sort/search for int type
+#define i_use_cmp           // enable sort/search for int type
 #include <stc/carc.h>       // Shared pointer to int
 
 #define i_type Vec
 #define i_keyboxed Arc
+#define i_use_cmp
 #include <stc/cvec.h>       // Vec: cvec<Arc>
 
 
diff --git a/misc/examples/smartpointers/box.c b/misc/examples/smartpointers/box.c
index 94d126c0..5c8018d4 100644
--- a/misc/examples/smartpointers/box.c
+++ b/misc/examples/smartpointers/box.c
@@ -30,6 +30,7 @@ void Person_drop(Person* p) {
 
 #define i_type PBox
 #define i_keyclass Person // "class" binds _cmp, _clone, _drop functions.
+#define i_use_cmp
 #include <stc/cbox.h>
 
 #define i_type Persons
diff --git a/misc/examples/smartpointers/box2.c b/misc/examples/smartpointers/box2.c
index eaab1c47..9b782c74 100644
--- a/misc/examples/smartpointers/box2.c
+++ b/misc/examples/smartpointers/box2.c
@@ -22,7 +22,6 @@ typedef struct {
 // Box in box:
 #define i_type BoxBoxPoint
 #define i_keyboxed cbox_Point // NB: use i_keyboxed when value is a cbox or carc!
-#define i_no_cmp
 #include <stc/cbox.h> // BoxBoxPoint
 
 Point origin(void) {
diff --git a/misc/examples/smartpointers/music_arc.c b/misc/examples/smartpointers/music_arc.c
index 13d368c3..e9ebbbfe 100644
--- a/misc/examples/smartpointers/music_arc.c
+++ b/misc/examples/smartpointers/music_arc.c
@@ -23,7 +23,7 @@ void Song_drop(Song* s) {
 // Define the shared pointer:
 #define i_type SongArc
 #define i_keyclass Song
-#define i_no_hash          // no hash fn for Song, fallback hash pointer to Song.
+#define i_opt c_use_cmp|c_no_hash
 #include <stc/carc.h>
 
 // ... and a vector of them
@@ -64,4 +64,4 @@ void example3(void)
 int main(void)
 {
     example3();
-}
+}
\ No newline at end of file
diff --git a/misc/examples/smartpointers/new_sptr.c b/misc/examples/smartpointers/new_sptr.c
index 3c6fa16c..50e28ae2 100644
--- a/misc/examples/smartpointers/new_sptr.c
+++ b/misc/examples/smartpointers/new_sptr.c
@@ -10,12 +10,13 @@ uint64_t Person_hash(const Person* p);
 
 #define i_type PersonArc
 #define i_keyclass Person // "class" assume _clone, _drop, _cmp, _hash is defined.
+#define i_use_cmp
 #include <stc/carc.h>
 
 #define i_type IPtr
 #define i_key int
 #define i_keydrop(x) printf("drop: %d\n", *x)
-#define i_cmp_native
+#define i_use_cmp
 #include <stc/carc.h>
 
 #define i_type IPStack
diff --git a/misc/examples/smartpointers/person_arc.c b/misc/examples/smartpointers/person_arc.c
index 38c883a7..11040cd2 100644
--- a/misc/examples/smartpointers/person_arc.c
+++ b/misc/examples/smartpointers/person_arc.c
@@ -31,11 +31,12 @@ void Person_drop(Person* p) {
 
 #define i_type PSPtr
 #define i_keyclass Person // ensure Person_drop
-#define i_cmp Person_cmp   // specify object cmp, instead of ptr cmp for arc.
+#define i_use_cmp
 #include <stc/carc.h>
 
 #define i_type Persons
 #define i_keyboxed PSPtr // binds PSPtr_cmp, PSPtr_drop...
+#define i_use_cmp
 #include <stc/cvec.h>
 
 
diff --git a/misc/examples/sortedmaps/csmap_insert.c b/misc/examples/sortedmaps/csmap_insert.c
index c9f02891..04b8ddc6 100644
--- a/misc/examples/sortedmaps/csmap_insert.c
+++ b/misc/examples/sortedmaps/csmap_insert.c
@@ -13,7 +13,6 @@
 #include <stc/csmap.h>
 
 #define i_key csmap_ii_raw
-#define i_opt c_no_cmp
 #define i_tag ii
 #include <stc/cvec.h>
 
diff --git a/misc/examples/sortedmaps/multimap.c b/misc/examples/sortedmaps/multimap.c
index 1068a5dc..a4490f91 100644
--- a/misc/examples/sortedmaps/multimap.c
+++ b/misc/examples/sortedmaps/multimap.c
@@ -41,6 +41,7 @@ void OlympicLoc_drop(OlympicLoc* self);
 
 // Create a clist<OlympicLoc>, can be sorted by year.
 #define i_keyclass OlympicLoc // binds _cmp, _clone and _drop.
+#define i_use_cmp
 #define i_tag OL
 #include <stc/clist.h>
 
diff --git a/misc/examples/vectors/lower_bound.c b/misc/examples/vectors/lower_bound.c
index bea828f2..09cf2008 100644
--- a/misc/examples/vectors/lower_bound.c
+++ b/misc/examples/vectors/lower_bound.c
@@ -1,7 +1,7 @@
 #include <stdio.h>
 
 #define i_key int
-#define i_cmp_native
+#define i_use_cmp
 #include <stc/cvec.h>
 
 #define i_key int
-- 
cgit v1.2.3


From 31ba4b2a36dee10b7e5d58561a2c0291cff6faeb Mon Sep 17 00:00:00 2001
From: tylov <tylo@norceresearch.no>
Date: Fri, 11 Aug 2023 22:43:59 +0200
Subject: Finalized converting to i_use_cmp  (vs i_no_cmp)

---
 README.md                                    | 10 ++++------
 docs/cbox_api.md                             |  2 +-
 include/stc/carc.h                           |  9 ++++++---
 include/stc/ccommon.h                        |  3 +--
 misc/examples/smartpointers/arc_containers.c |  2 +-
 5 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'misc/examples/smartpointers')

diff --git a/README.md b/README.md
index fbdbd9fc..722d2559 100644
--- a/README.md
+++ b/README.md
@@ -215,7 +215,6 @@ Let's make a vector of vectors, which can be cloned. All of its element vectors
 
 #define i_type Vec2D
 #define i_keyclass Vec  // Use i_keyclass instead i_key when element type has "members" _clone(), _drop() and _cmp().
-#define i_opt c_no_cmp  // Disable cmp (search/sort) for Vec2D because Vec_cmp() does not exist.
 #include <stc/cvec.h>
 
 int main(void)
@@ -370,14 +369,14 @@ The list of template parameters:
 
 - `i_key` *Type* - Element key type. **[required]**. Note: `i_val` *may* be used instead for non-maps (not recommended).
 - `i_val` *Type* - Element value type. **[required for]** cmap/csmap as the mapped value type.
-- `i_cmp` *Func* - Three-way comparison of two *i_keyraw*\* or *i_valraw*\* - **[required for]** non-integral *i_keyraw* elements unless *i_opt* is defined with *c_no_cmp*.
+- `i_cmp` *Func* - Three-way comparison of two *i_keyraw*\* or *i_valraw*\* - **[required for]** non-integral *i_keyraw* elements.
 - `i_hash` *Func* - Hash function taking *i_keyraw*\* - defaults to *c_default_hash*. **[required for]** ***cmap/cset*** with non-POD *i_keyraw* elements.
 - `i_eq` *Func* - Equality comparison of two *i_keyraw*\* - defaults to *!i_cmp*. Companion with *i_hash*.
 
 Properties:
 - `i_tag` *Name* - Container type name tag. Defaults to *i_key* name.
 - `i_type` *Name* - Full container type name. Alternative to *i_tag*.
-- `i_opt` *Flags* - Boolean properties: may combine *c_no_cmp*, *c_no_clone*, *c_no_atomic*, *c_is_forward*, *c_static*, *c_header* with the *|* separator.
+- `i_opt` *Flags* - Boolean properties: may combine *c_no_clone*, *c_no_atomic*, *c_is_forward*, *c_static*, *c_header* with the *|* separator.
 
 Key:
 - `i_keydrop` *Func* - Destroy map/set key func - defaults to empty destructor.
@@ -398,7 +397,7 @@ Specials: Meta-template parameters. Use instead of `i_key` / `i_val`.
 If `i_keyraw` is defined, it sets `i_keyto` = *Type_toraw()* and `i_keyfrom` = *Type_from()*.
 Only functions required by the container type is required to be defined. E.g.:
     - *Type_hash()* and *Type_eq()* are only required by **cmap**, **cset** and smart pointers.
-    - *Type_cmp()* is not used by **cstack** and **cmap/cset**, or if *#define i_opt c_no_cmp* is specified.
+    - *Type_cmp()* is not used by **cstack** and **cmap/cset**.
     - *Type_clone()* is not used if *#define i_opt c_no_clone* is specified.
 - `i_key_str` - Sets `i_keyclass` = *cstr*, `i_tag` = *str*, and `i_keyraw` = *const char*\*. Defines both type convertion 
 `i_keyfrom`, `i_keyto`, and sets `i_cmp`, `i_eq`, `i_hash` functions with *const char\*\** as argument.
@@ -409,7 +408,6 @@ NB: Do not use when defining carc/cbox types themselves.
 - `i_valclass` *Type*, `i_val_str`, `i_val_ssv`, `i_valboxed` - Similar rules as for ***key***.
 
 **Notes**:
-- Instead of defining `i_cmp`, you may define *i_opt c_no_cmp* to disable *searching and sorting* functions.
 - Instead of defining `i_*clone`, you may define *i_opt c_no_clone* to disable *clone* functionality.
 - For `i_keyclass`, if *i_keyraw* is defined along with it, *i_keyfrom* may also be defined to enable the *emplace*-functions. NB: the signature for ***cmp***, ***eq***, and ***hash*** uses *i_keyraw* as input.
 
@@ -764,6 +762,6 @@ Major changes:
 - 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: 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: `i_opt` template parameter: compile-time options: `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/algorithm_api.md) macro: for-loop with "structured binding"
diff --git a/docs/cbox_api.md b/docs/cbox_api.md
index c683d9ef..7d25aed8 100644
--- a/docs/cbox_api.md
+++ b/docs/cbox_api.md
@@ -34,7 +34,7 @@ See similar c++ class [std::unique_ptr](https://en.cppreference.com/w/cpp/memory
 #include <stc/cbox.h>    
 ```
 `X` should be replaced by the value of `i_tag` in all of the following documentation.
-Define `i_opt` with `c_no_cmp` if comparison between i_key's is not needed/available. Will then
+Unless `c_use_cmp` is defined, comparison between i_key's is not needed/available. Will then
 compare the pointer addresses when used. Additionally, `c_no_clone` or `i_is_fwd` may be defined.
 
 ## Methods
diff --git a/include/stc/carc.h b/include/stc/carc.h
index e987f453..1b1c22eb 100644
--- a/include/stc/carc.h
+++ b/include/stc/carc.h
@@ -43,7 +43,6 @@ void Person_drop(Person* p) {
 
 #define i_type ArcPers
 #define i_valclass Person    // clone, drop, cmp, hash
-#define i_opt c_no_cmp|c_no_hash  // exclude cmp, hash
 #include <stc/carc.h>
 
 int main(void) {
@@ -86,7 +85,10 @@ int main(void) {
 #include "priv/template.h"
 typedef i_keyraw _cx_raw;
 
-#if !c_option(c_no_atomic)
+#if c_option(c_no_atomic)
+  #define i_no_atomic
+#endif
+#if !defined i_no_atomic
   #define _i_atomic_inc(v)          c_atomic_inc(v)
   #define _i_atomic_dec_and_test(v) c_atomic_dec_and_test(v)
 #else
@@ -213,7 +215,8 @@ STC_INLINE void _cx_MEMB(_assign)(_cx_Self* self, _cx_Self ptr) {
         { return c_default_hash(&self->get); }
 #endif // i_use_cmp
 
+#include "priv/template2.h"
+#undef i_no_atomic
 #undef _i_atomic_inc
 #undef _i_atomic_dec_and_test
-#include "priv/template2.h"
 #undef _i_carc
diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index b37ad1da..45fa01c6 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -116,9 +116,8 @@ typedef long long _llong;
 #define c_no_atomic             (1<<1)
 #define c_no_clone              (1<<2)
 #define c_no_emplace            (1<<3)
-#define c_no_cmp                (1<<4)
+#define c_no_hash               (1<<4)
 #define c_use_cmp               (1<<5)
-#define c_no_hash               (1<<6)
 /* Function macros and others */
 
 #define c_litstrlen(literal) (c_sizeof("" literal) - 1)
diff --git a/misc/examples/smartpointers/arc_containers.c b/misc/examples/smartpointers/arc_containers.c
index c2bff56f..79211d2b 100644
--- a/misc/examples/smartpointers/arc_containers.c
+++ b/misc/examples/smartpointers/arc_containers.c
@@ -12,7 +12,7 @@
 #define i_key Map
 #define i_keydrop(p) (printf("drop Arc:\n"), Map_drop(p))
 // no need for atomic ref. count in single thread:
-#define i_opt c_no_atomic|c_no_cmp
+#define i_opt c_no_atomic
 #include <stc/carc.h>
 
 #define i_type Stack
-- 
cgit v1.2.3