Reverted to use self pointers instead of values, as cspan is not a pure view, but can modify its elements.

3 files changed, 68 insertions, 74 deletions

diff --git a/docs/cspan_api.md b/docs/cspan_api.md
index a491185e..2865a1a5 100644
--- a/docs/cspan_api.md
+++ b/docs/cspan_api.md
@@ -21,27 +21,27 @@ using_cspan4(S, ValueType);                 // define span types S, S2, S3, S4 w
 Note that `cspan_make()`, `cmake_from*()`, `cspan_atN()`, `and cspan_subspanN()` require a (safe) cast to its span-type
 on assignment, but not on initialization of a span variable. All functions are type-safe, and arguments are side-effect safe, except for SpanType arg. which must not have side-effects.
 ```c
-SpanType{N}     cspan_make(ValueType* data,  size_t xdim, ...);             // make N-dimensional cspan
-SpanType        cspan_from(STCContainer* cnt);                              // create a 1D cspan from a compatible STC container
-SpanType        cspan_from_array(ValueType array[]);                        // create a 1D cspan from a C array
-SpanType        cspan_from_list(T ValueType, {val0, val1, ...});            // create a 1D cspan from an initializer list
-SpanType&       cspan_literal(T SpanType, {val0, val1, ...});               // create a 1D cspan compound literal from init list 
+SpanType{N}     cspan_make(ValueType* data,  size_t xdim, ...);         // make N-dimensional cspan
+SpanType        cspan_from(STCContainer* cnt);                          // create a 1D cspan from a compatible STC container
+SpanType        cspan_from_array(ValueType array[]);                    // create a 1D cspan from a C array
+SpanType        cspan_from_list(T ValueType, {val0, val1, ...});        // create a 1D cspan from an initializer list
+SpanType&       cspan_literal(T SpanType, {val0, val1, ...});           // create a 1D cspan compound literal from init list 
 
-void            cspan_resize(SpanType{N}* self, size_t xdim, ...);          // change the extent of each dimension
+void            cspan_resize(SpanType{N}* self, size_t xdim, ...);      // change the extent of each dimension
 
-size_t          cspan_size(SpanType{N} spn);                                // return number of elements
-unsigned        cspan_rank(SpanType{N} spn);                                // return number of dimensions
-size_t          cspan_index(SpanType{N} spn, size_t x, ...);                // index of element
+size_t          cspan_size(const SpanType{N}* self);                    // return number of elements
+unsigned        cspan_rank(const SpanType{N}* self);                    // return number of dimensions
+size_t          cspan_index(const SpanType{N}* self, size_t x, ...);    // index of element
                 
-ValueType*      cspan_at(SpanType{N} spn, size_t x, ...);                   // at(): num of args decides input SpanType{N}.
-SpanType        cspan_at2(SpanType2 spn, size_t x);                         // return a 1D subarray cspan.
-SpanType{N}     cspan_at3(SpanType3 spn, size_t x, ...);                    // atN(): N decides input SpanType{N},
-SpanType{N}     cspan_at4(SpanType4 spn, size_t x, ...);                    // and num of args decides returned SpanType{N}.
+ValueType*      cspan_at(SpanType{N}* self, size_t x, ...);             // at(): num of args decides input SpanType{N}.
+SpanType        cspan_at2(SpanType2* self, size_t x);                   // return a 1D subarray cspan.
+SpanType{N}     cspan_at3(SpanType3* self, size_t x, ...);              // atN(): N decides input SpanType,
+SpanType{N}     cspan_at4(SpanType4* self, size_t x, ...);              // and num of args decides returned SpanType{N}.
 
-SpanType        cspan_subspan(SpanType spn, size_t offset, size_t count);   // return a slice of a 1D cspan
-SpanType2       cspan_subspan2(SpanType2 spn, size_t offset, size_t count); // return a slice of a 2D cspan
-SpanType3       cspan_subspan3(SpanType3 spn, size_t offset, size_t count); // return a slice of a 3D cspan
-SpanType4       cspan_subspan4(SpanType4 spn, size_t offset, size_t count); // return a slice of a 4D cspan
+SpanType        cspan_subspan(const SpanType* self, size_t offset, size_t count);  // return a slice of a 1D cspan
+SpanType2       cspan_subspan2(const SpanType2 self, size_t offset, size_t count); // return a slice of a 2D cspan
+SpanType3       cspan_subspan3(const SpanType3 self, size_t offset, size_t count); // return a slice of a 3D cspan
+SpanType4       cspan_subspan4(const SpanType4 self, size_t offset, size_t count); // return a slice of a 4D cspan
 
 SpanType{N}_iter    SpanType_begin(const SpanType{N}* self);
 SpanType{N}_iter    SpanType_end(const SpanType{N}* self);
@@ -73,15 +73,15 @@ int main()
 
         // define "span3[xd][yd][zd]"
         FS3 span3 = cspan_make(vec.data, xd, yd, zd);
-        *cspan_at(span3, 4, 3, 2) = 3.14f;
-        printf("index: %d", (int)cspan_index(span3, 4, 3, 2));
+        *cspan_at(&span3, 4, 3, 2) = 3.14f;
+        printf("index: %d", (int)cspan_index(&span3, 4, 3, 2));
 
-        FS span1 = cspan_at3(span3, 4, 3);
+        FS span1 = cspan_at3(&span3, 4, 3);
         printf("\niterate span1: ");
         c_FOREACH (i, FS, span1)
             printf("%g ", *i.ref);
 
-        FS2 span2 = cspan_at3(span3, 4);
+        FS2 span2 = cspan_at3(&span3, 4);
         printf("\niterate span2: ");
         c_FOREACH (i, FS2, span2)
             printf("%g ", *i.ref);
@@ -90,15 +90,15 @@ int main()
         c_FORRANGE (i, span3.dim[0]) {
             c_FORRANGE (j, span3.dim[1]) {
                 c_FORRANGE (k, span3.dim[2])
-                    printf(" %2g", *cspan_at(span3, i, j, k));
+                    printf(" %2g", *cspan_at(&span3, i, j, k));
                 printf(" |");
             }
             puts("");
         }
 
-        printf("%g\n", *cspan_at(span3, 4, 3, 2));
-        printf("%g\n", *cspan_at(span2, 3, 2));
-        printf("%g\n", *cspan_at(span1, 2));
+        printf("%g\n", *cspan_at(&span3, 4, 3, 2));
+        printf("%g\n", *cspan_at(&span2, 3, 2));
+        printf("%g\n", *cspan_at(&span1, 2));
     }
 }
 ```
diff --git a/include/stc/cspan.h b/include/stc/cspan.h
index d91a3460..af76ea63 100644
--- a/include/stc/cspan.h
+++ b/include/stc/cspan.h
@@ -1,4 +1,5 @@
-/* MIT License
+/*
+ MIT License
  *
  * Copyright (c) 2023 Tyge Løvset
  *
@@ -33,9 +34,9 @@ int demo1() {
     
     for (size_t i=0; i<ms.dim[0]; i++)
         for (size_t j=0; j<ms.dim[1]; j++)
-            *cspan_at(ms, i, j) = i*1000 + j;
+            *cspan_at(&ms, i, j) = i*1000 + j;
 
-    printf("%f\n", *cspan_at(ms, 3, 4));
+    printf("%f\n", *cspan_at(&ms, 3, 4));
 }
 
 int demo2() {
@@ -66,11 +67,11 @@ int demo2() {
     typedef struct { Self##_value *data; uint32_t dim[RANK]; } Self; \
     \
     STC_INLINE Self##_iter Self##_begin(const Self* self) { \
-        Self##_iter it = {self->data, self->data + cspan_size(*self)}; \
+        Self##_iter it = {self->data, self->data + cspan_size(self)}; \
         return it; \
     } \
     STC_INLINE Self##_iter Self##_end(const Self* self) { \
-        Self##_iter it = {NULL, self->data + cspan_size(*self)}; \
+        Self##_iter it = {NULL, self->data + cspan_size(self)}; \
         return it; \
     } \
     STC_INLINE void Self##_next(Self##_iter* it) \
@@ -81,7 +82,7 @@ int demo2() {
 #define using_cspan3(Self, T) using_cspan2(Self, T); using_cspan(Self##3, T, 3)
 #define using_cspan4(Self, T) using_cspan3(Self, T); using_cspan(Self##4, T, 4)
 
-#define cspan_rank_ok(spn, rank) c_STATIC_ASSERT(cspan_rank(spn) == rank)
+#define cspan_rank_ok(self, rank) c_STATIC_ASSERT(cspan_rank(self) == rank)
 
 #define cspan_make(array, ...) \
     {.data=array, .dim={__VA_ARGS__}}
@@ -99,50 +100,43 @@ int demo2() {
 #define cspan_literal(SpanType, ...) \
     (c_INIT(SpanType)cspan_from_list(SpanType##_value, __VA_ARGS__))
 
-#define cspan_size(spn) _cspan_size((spn).dim, cspan_rank(spn))
-#define cspan_rank(spn) c_ARRAYLEN((spn).dim)
-#define cspan_index(spn, ...) \
-    c_PASTE(_cspan_i, c_NUMARGS(__VA_ARGS__))((spn).dim, __VA_ARGS__) + \
-                                              cspan_rank_ok(spn, c_NUMARGS(__VA_ARGS__))
+#define cspan_size(self) _cspan_size((self)->dim, cspan_rank(self))
+#define cspan_rank(self) c_ARRAYLEN((self)->dim)
+#define cspan_index(self, ...) \
+    c_PASTE(_cspan_i, c_NUMARGS(__VA_ARGS__))((self)->dim, __VA_ARGS__) + \
+                                              cspan_rank_ok(self, c_NUMARGS(__VA_ARGS__))
 
 #define cspan_resize(self, ...) \
     (void)memcpy((self)->dim, (uint32_t[]){__VA_ARGS__}, \
-                 sizeof((self)->dim) + cspan_rank_ok(*(self), c_NUMARGS(__VA_ARGS__)))
-
-#define cspan_at(spn, ...) ((spn).data + cspan_index(spn, __VA_ARGS__))
-#define cspan_front(spn) ((spn).data)
-#define cspan_back(spn) ((spn).data + cspan_size(spn) - 1)
-
-#define cspan_subspan(spn, offset, count) \
-    {.data=cspan_at(spn, offset), .dim={count}}
-#define cspan_subspan2(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0), .dim={count, (spn).dim[1]}}
-#define cspan_subspan3(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0, 0), .dim={count, (spn).dim[1], (spn).dim[2]}}
-#define cspan_subspan4(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0, 0, 0), .dim={count, (spn).dim[1], (spn).dim[2], (spn).dim[3]}}
-
-#define cspan_subspan2(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0), .dim={count, (spn).dim[1]}}
-#define cspan_subspan3(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0, 0), .dim={count, (spn).dim[1], (spn).dim[2]}}
-#define cspan_subspan4(spn, offset, count) \
-    {.data=cspan_at(spn, offset, 0, 0, 0), .dim={count, (spn).dim[1], (spn).dim[2], (spn).dim[3]}}
+                 sizeof((self)->dim) + cspan_rank_ok(self, c_NUMARGS(__VA_ARGS__)))
+
+#define cspan_at(self, ...) ((self)->data + cspan_index(self, __VA_ARGS__))
+#define cspan_front(self) ((self)->data)
+#define cspan_back(self) ((self)->data + cspan_size(self) - 1)
+
+#define cspan_subspan(self, offset, count) \
+    {.data=cspan_at(self, offset), .dim={count}}
+#define cspan_subspan2(self, offset, count) \
+    {.data=cspan_at(self, offset, 0), .dim={count, (self)->dim[1]}}
+#define cspan_subspan3(self, offset, count) \
+    {.data=cspan_at(self, offset, 0, 0), .dim={count, (self)->dim[1], (self)->dim[2]}}
+#define cspan_subspan4(self, offset, count) \
+    {.data=cspan_at(self, offset, 0, 0, 0), .dim={count, (self)->dim[1], (self)->dim[2], (self)->dim[3]}}
 
 #define cspan_at4(...) c_MACRO_OVERLOAD(cspan_at4, __VA_ARGS__)
 #define cspan_at3(...) c_MACRO_OVERLOAD(cspan_at3, __VA_ARGS__)
-#define cspan_at2(spn, x) \
-    {.data=cspan_at(spn, x, 0), .dim={(spn).dim[1]}}
-#define cspan_at32(spn, x) \
-    {.data=cspan_at(spn, x, 0, 0), .dim={(spn).dim[1], (spn).dim[2]}}
-#define cspan_at33(spn, x, y) \
-    {.data=cspan_at(spn, x, y, 0), .dim={(spn).dim[2]}}
-#define cspan_at42(spn, x) \
-    {.data=cspan_at(spn, x, 0, 0, 0), .dim={(spn).dim[1], (spn).dim[2], (spn).dim[3]}}
-#define cspan_at43(spn, x, y) \
-    {.data=cspan_at(spn, x, y, 0, 0), .dim={(spn).dim[2], (spn).dim[3]}}
-#define cspan_at44(spn, x, y, z) \
-    {.data=cspan_at(spn, x, y, z, 0), .dim={(spn).dim[3]}}
+#define cspan_at2(self, x) \
+    {.data=cspan_at(self, x, 0), .dim={(self)->dim[1]}}
+#define cspan_at32(self, x) \
+    {.data=cspan_at(self, x, 0, 0), .dim={(self)->dim[1], (self)->dim[2]}}
+#define cspan_at33(self, x, y) \
+    {.data=cspan_at(self, x, y, 0), .dim={(self)->dim[2]}}
+#define cspan_at42(self, x) \
+    {.data=cspan_at(self, x, 0, 0, 0), .dim={(self)->dim[1], (self)->dim[2], (self)->dim[3]}}
+#define cspan_at43(self, x, y) \
+    {.data=cspan_at(self, x, y, 0, 0), .dim={(self)->dim[2], (self)->dim[3]}}
+#define cspan_at44(self, x, y, z) \
+    {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}}
 
 STC_INLINE size_t _cspan_i1(const uint32_t dim[1], uint32_t x)
     { c_ASSERT(x < dim[0]); return x; }
diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c
index 11418e15..945741b1 100644
--- a/misc/examples/multidim.c
+++ b/misc/examples/multidim.c
@@ -27,16 +27,16 @@ int main()
   // write data using 2D view
   for (unsigned i=0; i != ms2.dim[0]; i++)
     for (unsigned j=0; j != ms2.dim[1]; j++)
-      *cspan_at(ms2, i, j) = i*1000 + j;
+      *cspan_at(&ms2, i, j) = i*1000 + j;
 
   // print all items using 1D view
   printf("all: ");
-  for (unsigned i=0; i != cspan_size(ms1); i++)
-    printf(" %d", *cspan_at(ms1, i));
+  for (unsigned i=0; i != cspan_size(&ms1); i++)
+    printf(" %d", *cspan_at(&ms1, i));
   puts("");
 
   // or iterate a subspan...
-  ispan2 sub = cspan_at3(ms3, 1);
+  ispan2 sub = cspan_at3(&ms3, 1);
   printf("sub: ");
   c_FOREACH (i, ispan2, sub)
     printf(" %d", *i.ref);
@@ -49,7 +49,7 @@ int main()
     for (unsigned j=0; j != ms3.dim[1]; j++)
     {
       for (unsigned k=0; k != ms3.dim[2]; k++)
-        printf("%d ", *cspan_at(ms3, i, j, k));
+        printf("%d ", *cspan_at(&ms3, i, j, k));
       puts("");
     }
   }