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

1 files changed, 38 insertions, 44 deletions

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; }