From 5aa48d538569463ffeda976d21f79edc5f276be4 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Thu, 19 Jan 2023 19:27:07 +0100 Subject: Add a from_n() method to containers (and put_n() to maps), to support new initialization. --- docs/cspan_api.md | 2 -- 1 file changed, 2 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 2865a1a5..8cabd97e 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -24,8 +24,6 @@ on assignment, but not on initialization of a span variable. All functions are t 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 -- cgit v1.2.3 From e97d06f95a65edd4fdee53555398f7b636a72ab5 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 20 Jan 2023 19:50:52 +0100 Subject: Renamed cspan_at2 .. at4 to cspan_subdim2 .. Improved cspan docs. --- docs/cspan_api.md | 93 +++++++++++++++++++++++++----------------------- include/stc/cspan.h | 16 ++++----- misc/examples/multidim.c | 2 +- 3 files changed, 58 insertions(+), 53 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 8cabd97e..d6caff4e 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -10,78 +10,83 @@ See the c++ classes [std::span](https://en.cppreference.com/w/cpp/container/span ```c #include -using_cspan(SpanType, ValueType, Rank); // define SpanType with ValueType elements. - // Rank is number of dimensions (max 4) +using_cspan(SpanType, ValueType, Rank); // define SpanType with ValueType elements. + // Rank is number of dimensions (max 4) // Shorthands: -using_cspan2(S, ValueType); // define span types S, S2 with ranks 1, 2. -using_cspan3(S, ValueType); // define span types S, S2, S3 with ranks 1, 2, 3. -using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. +using_cspan2(S, ValueType); // define span types S, S2 with ranks 1, 2. +using_cspan3(S, ValueType); // define span types S, S2, S3 with ranks 1, 2, 3. +using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. ``` ## Methods 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 +SpanTypeN 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 -void cspan_resize(SpanType{N}* self, size_t xdim, ...); // change the extent of each dimension +void cspan_resize(SpanTypeN* self, size_t xdim, ...); // change the extent of each dimension -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 +size_t cspan_size(const SpanTypeN* self); // return number of elements +unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions +size_t cspan_index(const SpanTypeN* self, size_t x, ...); // index of element -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(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); -void SpanType_next(SpanType{N}_iter* it); +ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): num of args decides input SpanTypeN. +ValueType* cspan_front(SpanTypeN* self); +ValueType* cspan_back(SpanTypeN* self); + +SpanType cspan_subdim2(SpanType2* self, size_t x); // return a cspan from a 2D SpanType. +SpanTypeN cspan_subdim3(SpanType3* self, size_t x, ...); // subdimN(): N decides input SpanType, +SpanTypeN cspan_subdim4(SpanType4* self, size_t x, ...); // and num of args decides returned SpanTypeN. + + // return a subspan of same rank: +SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); +SpanType2 cspan_subspan2(const SpanType2 self, size_t offset, size_t count); +SpanType3 cspan_subspan3(const SpanType3 self, size_t offset, size_t count); +SpanType4 cspan_subspan4(const SpanType4 self, size_t offset, size_t count); + +SpanTypeN_iter SpanType_begin(const SpanTypeN* self); +SpanTypeN_iter SpanType_end(const SpanTypeN* self); +void SpanType_next(SpanTypeN_iter* it); ``` ## Types -| Type name | Type definition | Used to represent... | -|:--------------------|:-----------------------------------------------|:---------------------| -| SpanType{N} | `struct { ValueType *data; uint32_t dim[N]; }` | SpanType with rank N | -| SpanType{N}`_value` | `ValueType` | The ValueType | -| SpanType{N}`_iter` | `struct { ValueType *ref; ... }` | Iterator type | +| Type name | Type definition | Used to represent... | +|:------------------|:-----------------------------------------------|:---------------------| +| SpanTypeN | `struct { ValueType *data; uint32_t dim[N]; }` | SpanType with rank N | +| SpanTypeN`_value` | `ValueType` | The ValueType | +| SpanTypeN`_iter` | `struct { ValueType *ref; ... }` | Iterator type | ## Example ```c #include +#include #define i_val float #include -#include -using_cspan3(FS, float); // Shorthand to define span types FS, FS2, and FS3. +using_cspan3(Span, float); // Shorthand to define span types Span, Span2, and Span3. int main() { int xd = 6, yd = 4, zd = 3; - c_AUTO (cstack_float, vec) { + c_AUTO (cstack_float, vec) + { c_FORRANGE (i, xd*yd*zd) cstack_float_push(&vec, i); // define "span3[xd][yd][zd]" - FS3 span3 = cspan_make(vec.data, xd, yd, zd); - *cspan_at(&span3, 4, 3, 2) = 3.14f; + Span3 span3 = cspan_make(vec.data, xd, yd, zd); + *cspan_at(&span3, 4, 3, 2) = 3.14159f; printf("index: %d", (int)cspan_index(&span3, 4, 3, 2)); - FS span1 = cspan_at3(&span3, 4, 3); + Span span1 = cspan_subdim3(&span3, 4, 3); printf("\niterate span1: "); - c_FOREACH (i, FS, span1) + c_FOREACH (i, Span, span1) printf("%g ", *i.ref); - FS2 span2 = cspan_at3(&span3, 4); + Span2 span2 = cspan_subdim3(&span3, 4); printf("\niterate span2: "); - c_FOREACH (i, FS2, span2) + c_FOREACH (i, Span2, span2) printf("%g ", *i.ref); puts("\niterate span3 by dimensions:"); @@ -103,16 +108,16 @@ int main() Output: ``` index: 59 -iterate span1: 57 58 3.14 -iterate span2: 48 49 50 51 52 53 54 55 56 57 58 3.14 +iterate span1: 57 58 3.14159 +iterate span2: 48 49 50 51 52 53 54 55 56 57 58 3.14159 iterate span3 by dimensions: - 0 1 2 | 3 4 5 | 6 7 8 | 9 10 11 | + 0 1 2 | 3 4 5 | 6 7 8 | 9 10 11 | 12 13 14 | 15 16 17 | 18 19 20 | 21 22 23 | 24 25 26 | 27 28 29 | 30 31 32 | 33 34 35 | 36 37 38 | 39 40 41 | 42 43 44 | 45 46 47 | - 48 49 50 | 51 52 53 | 54 55 56 | 57 58 3.14 | + 48 49 50 | 51 52 53 | 54 55 56 | 57 58 3.14159 | 60 61 62 | 63 64 65 | 66 67 68 | 69 70 71 | -3.14 -3.14 -3.14 +3.14159 +3.14159 +3.14159 ``` diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 88e10b07..96439c64 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -120,19 +120,19 @@ int demo2() { #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(self, x) \ +#define cspan_subdim4(...) c_MACRO_OVERLOAD(cspan_subdim4, __VA_ARGS__) +#define cspan_subdim3(...) c_MACRO_OVERLOAD(cspan_subdim3, __VA_ARGS__) +#define cspan_subdim2(self, x) \ {.data=cspan_at(self, x, 0), .dim={(self)->dim[1]}} -#define cspan_at32(self, x) \ +#define cspan_subdim32(self, x) \ {.data=cspan_at(self, x, 0, 0), .dim={(self)->dim[1], (self)->dim[2]}} -#define cspan_at33(self, x, y) \ +#define cspan_subdim33(self, x, y) \ {.data=cspan_at(self, x, y, 0), .dim={(self)->dim[2]}} -#define cspan_at42(self, x) \ +#define cspan_subdim42(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) \ +#define cspan_subdim43(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) \ +#define cspan_subdim44(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) diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index 945741b1..e882d62a 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -36,7 +36,7 @@ int main() puts(""); // or iterate a subspan... - ispan2 sub = cspan_at3(&ms3, 1); + ispan2 sub = cspan_subdim3(&ms3, 1); printf("sub: "); c_FOREACH (i, ispan2, sub) printf(" %d", *i.ref); -- cgit v1.2.3 From af4c2d6d2f3353364632701ef8208a9dcbe18623 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Wed, 25 Jan 2023 08:37:23 +0100 Subject: Reverted cspan_subdim*() to cspan_at*(). Added cspan_flatten() constructor. --- docs/cspan_api.md | 11 ++++++----- include/stc/cspan.h | 19 +++++++++++-------- misc/examples/multidim.c | 2 +- 3 files changed, 18 insertions(+), 14 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index d6caff4e..ce9236c3 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -25,6 +25,7 @@ SpanTypeN cspan_make(ValueType* data, size_t xdim, ...); // make 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_flatten(SpanTypeN* span); // create a 1D cspan from a multidim span void cspan_resize(SpanTypeN* self, size_t xdim, ...); // change the extent of each dimension size_t cspan_size(const SpanTypeN* self); // return number of elements @@ -35,9 +36,9 @@ ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); -SpanType cspan_subdim2(SpanType2* self, size_t x); // return a cspan from a 2D SpanType. -SpanTypeN cspan_subdim3(SpanType3* self, size_t x, ...); // subdimN(): N decides input SpanType, -SpanTypeN cspan_subdim4(SpanType4* self, size_t x, ...); // and num of args decides returned SpanTypeN. +SpanType cspan_at2(SpanType2* self, size_t x); // return a cspan from a 2D SpanType. +SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // atN(): N decides input SpanType, +SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // and num of args decides returned SpanTypeN. // return a subspan of same rank: SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); @@ -79,12 +80,12 @@ int main() *cspan_at(&span3, 4, 3, 2) = 3.14159f; printf("index: %d", (int)cspan_index(&span3, 4, 3, 2)); - Span span1 = cspan_subdim3(&span3, 4, 3); + Span span1 = cspan_at3(&span3, 4, 3); printf("\niterate span1: "); c_FOREACH (i, Span, span1) printf("%g ", *i.ref); - Span2 span2 = cspan_subdim3(&span3, 4); + Span2 span2 = cspan_at3(&span3, 4); printf("\niterate span2: "); c_FOREACH (i, Span2, span2) printf("%g ", *i.ref); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 5ba408a8..2b600a2a 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -94,6 +94,9 @@ int demo2() { #define cspan_init(SpanType, ...) \ {.data=(SpanType##_value[])__VA_ARGS__, .dim={sizeof((SpanType##_value[])__VA_ARGS__)/sizeof(SpanType##_value)}} +#define cspan_flatten(span) \ + {.data=(span)->data, .dim={(uint32_t)cspan_size(span)}} + /* create a cspan from a cvec, cstack, cdeq, cqueue, or cpque (heap) */ #define cspan_from(container) \ {.data=(container)->data, .dim={(uint32_t)(container)->_len}} @@ -124,19 +127,19 @@ int demo2() { #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_subdim4(...) c_MACRO_OVERLOAD(cspan_subdim4, __VA_ARGS__) -#define cspan_subdim3(...) c_MACRO_OVERLOAD(cspan_subdim3, __VA_ARGS__) -#define cspan_subdim2(self, x) \ +#define cspan_at4(...) c_MACRO_OVERLOAD(cspan_at4, __VA_ARGS__) +#define cspan_at3(...) c_MACRO_OVERLOAD(cspan_at3, __VA_ARGS__) +#define cspan_at2(self, x) \ {.data=cspan_at(self, x, 0), .dim={(self)->dim[1]}} -#define cspan_subdim3_2(self, x) \ +#define cspan_at3_2(self, x) \ {.data=cspan_at(self, x, 0, 0), .dim={(self)->dim[1], (self)->dim[2]}} -#define cspan_subdim3_3(self, x, y) \ +#define cspan_at3_3(self, x, y) \ {.data=cspan_at(self, x, y, 0), .dim={(self)->dim[2]}} -#define cspan_subdim4_2(self, x) \ +#define cspan_at4_2(self, x) \ {.data=cspan_at(self, x, 0, 0, 0), .dim={(self)->dim[1], (self)->dim[2], (self)->dim[3]}} -#define cspan_subdim4_3(self, x, y) \ +#define cspan_at4_3(self, x, y) \ {.data=cspan_at(self, x, y, 0, 0), .dim={(self)->dim[2], (self)->dim[3]}} -#define cspan_subdim4_4(self, x, y, z) \ +#define cspan_at4_4(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) diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index 69f818cc..3eef1497 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -31,7 +31,7 @@ int main() puts(""); // or iterate a subspan... - ispan2 sub = cspan_subdim3(&ms3, 1); + ispan2 sub = cspan_at3(&ms3, 1); printf("sub: "); c_FOREACH (i, ispan2, sub) printf(" %d", *i.ref); -- cgit v1.2.3 From 68fd366ceaa919293d348ce15c2596d485160cec Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Wed, 25 Jan 2023 20:18:02 +0100 Subject: Updates on cspan ++. --- docs/cspan_api.md | 21 ++-- include/stc/cspan.h | 8 +- misc/examples/forfilter.c | 8 +- misc/examples/gauss1.c | 2 +- misc/examples/multidim.c | 4 +- misc/examples/prime.c | 3 +- misc/examples/printspan.c | 2 +- misc/examples/shape.c | 12 +-- src/utf8code.c | 243 ++++++++++++++++++++++++---------------------- 9 files changed, 156 insertions(+), 147 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index ce9236c3..6da2acca 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -18,27 +18,28 @@ using_cspan3(S, ValueType); // define span types S, S2, S3 with rank using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. ``` ## Methods -Note that `cspan_make()`, `cmake_from*()`, `cspan_atN()`, `and cspan_subspanN()` require a (safe) cast to its span-type +Note that `cspan_multidim()`, `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 -SpanTypeN 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_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values +SpanTypeN cspan_multidim(ValueType* data, size_t xdim, ...); // create a multi-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_flatten(SpanTypeN* span); // create a 1D cspan from a multidim span +SpanType cspan_flatten(SpanTypeN* span); // create a 1d cspan from a multidim span void cspan_resize(SpanTypeN* self, size_t xdim, ...); // change the extent of each dimension size_t cspan_size(const SpanTypeN* self); // return number of elements unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions size_t cspan_index(const SpanTypeN* self, size_t x, ...); // index of element -ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): num of args decides input SpanTypeN. +ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): num of args specifies rank of input span. ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); -SpanType cspan_at2(SpanType2* self, size_t x); // return a cspan from a 2D SpanType. -SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // atN(): N decides input SpanType, -SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // and num of args decides returned SpanTypeN. +SpanType cspan_at2(SpanType2* self, size_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // return a 1 or 2d subspan from a 3d span. +SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. // return a subspan of same rank: SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); @@ -76,7 +77,7 @@ int main() cstack_float_push(&vec, i); // define "span3[xd][yd][zd]" - Span3 span3 = cspan_make(vec.data, xd, yd, zd); + Span3 span3 = cspan_multidim(vec.data, xd, yd, zd); *cspan_at(&span3, 4, 3, 2) = 3.14159f; printf("index: %d", (int)cspan_index(&span3, 4, 3, 2)); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 2b600a2a..5b0358e2 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -30,7 +30,7 @@ using_cspan(Intspan, int, 1); int demo1() { float raw[4*5]; - Span2f ms = cspan_make(raw, 4, 5); + Span2f ms = cspan_multidim(raw, 4, 5); for (size_t i=0; isecond * StdDev * Scale * 2.5 / N); + int n = (int)(i.ref->second * StdDev * Scale * 2.5 / (double)N); if (n > 0) { printf("%4d ", i.ref->first); c_FORRANGE (n) printf("*"); diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index 3eef1497..8a5492dc 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -15,9 +15,9 @@ int main() // View data as contiguous memory representing 12 ints ispan ms1 = cspan_from(&v); // View data as contiguous memory representing 2 rows of 6 ints each - ispan2 ms2 = cspan_make(v.data, 2, 6); + ispan2 ms2 = cspan_multidim(v.data, 2, 6); // View the same data as a 3D array 2 x 3 x 2 - ispan3 ms3 = cspan_make(v.data, 2, 3, 2); + ispan3 ms3 = cspan_multidim(v.data, 2, 3, 2); // write data using 2D view for (unsigned i=0; i != ms2.dim[0]; i++) diff --git a/misc/examples/prime.c b/misc/examples/prime.c index 4a6b0f68..5c8d65d3 100644 --- a/misc/examples/prime.c +++ b/misc/examples/prime.c @@ -43,7 +43,8 @@ int main(void) puts(""); puts("Show the last 50 primes using a temporary crange generator:"); - c_FORFILTER (i, crange, crange_literal(n - 1, 0, -2) + crange R = crange_make(n - 1, 0, -2); + c_FORFILTER (i, crange, R , cbits_test(&primes, *i.ref>>1) , c_flt_take(i, 50)) { printf("%lld ", *i.ref); diff --git a/misc/examples/printspan.c b/misc/examples/printspan.c index 227fd2ed..82b54367 100644 --- a/misc/examples/printspan.c +++ b/misc/examples/printspan.c @@ -27,7 +27,7 @@ int main() c_AUTO (cdeq_int, deq) c_AUTO (cset_str, set) { - intspan sp1 = cspan_init(intspan, {1, 2}); + intspan sp1 = cspan_make(intspan, {1, 2}); printMe( sp1 ); printMe( c_make(intspan, {1, 2, 3}) ); diff --git a/misc/examples/shape.c b/misc/examples/shape.c index ed0c3fe1..75a5e174 100644 --- a/misc/examples/shape.c +++ b/misc/examples/shape.c @@ -50,12 +50,12 @@ typedef struct { Point p[3]; } Triangle; -static struct ShapeAPI Triangle_api; +extern struct ShapeAPI Triangle_api; Triangle Triangle_from(Point a, Point b, Point c) { - Triangle t = {{.api=&Triangle_api}, .p={a, b, c}}; + Triangle t = {.shape={.api=&Triangle_api}, .p={a, b, c}}; return t; } @@ -68,7 +68,7 @@ static void Triangle_draw(const Shape* shape) self->p[2].x, self->p[2].y); } -static struct ShapeAPI Triangle_api = { +struct ShapeAPI Triangle_api = { .drop = Shape_drop, .draw = Triangle_draw, }; @@ -85,12 +85,12 @@ typedef struct { PointVec points; } Polygon; -static struct ShapeAPI Polygon_api; +extern struct ShapeAPI Polygon_api; Polygon Polygon_init(void) { - Polygon p = {{.api=&Polygon_api}, .points=PointVec_init()}; + Polygon p = {.shape={.api=&Polygon_api}, .points=PointVec_init()}; return p; } @@ -116,7 +116,7 @@ static void Polygon_draw(const Shape* shape) puts(""); } -static struct ShapeAPI Polygon_api = { +struct ShapeAPI Polygon_api = { .drop = Polygon_drop, .draw = Polygon_draw, }; diff --git a/src/utf8code.c b/src/utf8code.c index ecf79880..3ad47941 100644 --- a/src/utf8code.c +++ b/src/utf8code.c @@ -122,13 +122,18 @@ typedef struct { int nr16; } UGroup; -static const UGroup unicode_groups[U8G_SIZE]; +#ifndef __cplusplus +static +#else +extern +#endif +const UGroup _utf8_unicode_groups[U8G_SIZE]; bool utf8_isgroup(int group, uint32_t c) { - for (int j=0; j Date: Sat, 28 Jan 2023 14:43:42 +0100 Subject: Added flat iteration over a sliced cspan. --- docs/cspan_api.md | 5 ++++- include/stc/cspan.h | 35 +++++++++++++++++++++--------- misc/examples/multidim.c | 55 ++++++++++++++++++++++++++---------------------- 3 files changed, 59 insertions(+), 36 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 6da2acca..c0b86239 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -38,9 +38,12 @@ ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); SpanType cspan_at2(SpanType2* self, size_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // return a 1 or 2d subspan from a 3d span. +SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // return a 1d or 2d subspan from a 3d span. SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. +void cspan_slice(SpanTypeN* self, uint32_t xslice[2], ...); // slice multidim span into a md subspan. +uint32_t[2] c_SLICE(a, b) // use to specify a:b xslice, ... b is optional. + // return a subspan of same rank: SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); SpanType2 cspan_subspan2(const SpanType2 self, size_t offset, size_t count); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index a4573b07..68a06541 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -62,27 +62,28 @@ int demo2() { #define using_cspan(Self, T, RANK) \ typedef T Self##_value; typedef T Self##_raw; \ - typedef struct { Self##_value *ref, *end; } Self##_iter; \ typedef struct { \ Self##_value *data; \ uint32_t dim[RANK]; \ cspan_idx##RANK stride; \ } Self; \ + typedef struct { Self##_value *ref; uint32_t pos[RANK]; const Self *_s; } Self##_iter; \ \ STC_INLINE Self Self##_from_n(Self##_raw* raw, const size_t n) { \ return (Self){.data=raw, .dim={(uint32_t)n}}; \ } \ STC_INLINE Self##_iter Self##_begin(const Self* self) { \ - size_t n = cspan_size(self); \ - Self##_iter it = {n ? self->data : NULL, self->data + n}; \ + Self##_iter it = {.ref=self->data, .pos={0}, ._s=self}; \ return it; \ } \ STC_INLINE Self##_iter Self##_end(const Self* self) { \ - Self##_iter it = {NULL, self->data + cspan_size(self)}; \ + Self##_iter it = {.ref=NULL}; \ return it; \ } \ - STC_INLINE void Self##_next(Self##_iter* it) \ - { if (++it->ref == it->end) it->ref = NULL; } \ + STC_INLINE void Self##_next(Self##_iter* it) { \ + it->ref += _cspan_next_##RANK(RANK, it->pos, it->_s->dim, it->_s->stride.d); \ + if (it->pos[0] == it->_s->dim[0]) it->ref = NULL; \ + } \ struct stc_nostruct #define using_cspan2(Self, T) using_cspan(Self, T, 1); using_cspan(Self##2, T, 2) @@ -100,9 +101,6 @@ typedef struct { uint32_t d[4]; } cspan_idx4; #define cspan_make(SpanType, ...) \ {.data=(SpanType##_value[])__VA_ARGS__, .dim={sizeof((SpanType##_value[])__VA_ARGS__)/sizeof(SpanType##_value)}} -#define cspan_flatten(span) \ - {.data=(span)->data, .dim={(uint32_t)cspan_size(span)}} - /* create a cspan from a cvec, cstack, cdeq, cqueue, or cpque (heap) */ #define cspan_from(container) \ {.data=(container)->data, .dim={(uint32_t)(container)->_len}} @@ -153,8 +151,9 @@ typedef struct { uint32_t d[4]; } cspan_idx4; {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}} // cspan_slice: +// e.g.: cspan_slice(&ms3, c_SLICE(1,3), c_SLICE(0), c_SLICE(1,4)); -#define c_SLICE(...) ((const uint32_t[2]){__VA_ARGS__}) +#define c_SLICE(...) ((const uint32_t[2]){__VA_ARGS__})z #define cspan_slice(self, ...) \ ((void)((self)->data += c_PASTE(_cspan_slice, c_NUMARGS(__VA_ARGS__))((self)->dim, (self)->stride, __VA_ARGS__))) @@ -183,6 +182,22 @@ STC_INLINE size_t _cspan_size(const uint32_t dim[], unsigned rank) { return sz; } +#define _cspan_next_1(r, pos, d, s) (++pos[0], 1) +#define _cspan_next_3 _cspan_next_2 +#define _cspan_next_4 _cspan_next_2 + +static size_t _cspan_next_2(int rank, uint32_t pos[], const uint32_t dim[], const uint32_t stride[]) { + size_t off = 1, rs = 1; + ++pos[rank - 1]; + while (--rank && pos[rank] == dim[rank]) { + pos[rank] = 0, ++pos[rank - 1]; + const size_t ds = rs*dim[rank]; + rs *= stride[rank]; + off += rs - ds; + } + return off; +} + STC_INLINE size_t _cspan_slice2(uint32_t dim[2], const cspan_idx2 stri, const uint32_t x[2], const uint32_t y[2]) { const uint32_t x1 = x[1] ? x[1] : dim[0], y1 = y[1] ? y[1] : dim[1]; const size_t ret = _cspan_i2(dim, stri, x[0], y[0]); diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index d69a04fb..f3d9e865 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -16,49 +16,54 @@ int main() ispan ms1 = cspan_from(&v); // View the same data as a 3D array 2 x 3 x 4 - ispan3 ms3 = cspan_multidim(v.data, 2, 2, 6); + ispan3 ms3 = cspan_multidim(v.data, 2, 3, 4); - // View data as contiguous memory representing 2 rows of 6 ints each - ispan2 ms2 = cspan_at3(&ms3, 0); - ms2.data = cspan_at(&ms2, 1, 1); - ms2.dim[0] = 2; - ms2.dim[1] = 3; - for (unsigned i=0; i != ms2.dim[0]; i++) { - for (unsigned j=0; j != ms2.dim[1]; j++) - printf(" %2d", *cspan_at(&ms2, i, j)); + puts("ms3:"); + for (unsigned i=0; i != ms3.dim[0]; i++) { + for (unsigned j=0; j != ms3.dim[1]; j++) { + for (unsigned k=0; k != ms3.dim[2]; k++) { + printf(" %2d", *cspan_at(&ms3, i, j, k)); + } + puts(""); + } + puts(""); + } + puts("ss3 = ms3[:, 1:3, 1:3]"); + ispan3 ss3 = ms3; + cspan_slice(&ss3, c_SLICE(0), c_SLICE(1,3), c_SLICE(1,3)); + + for (unsigned i=0; i != ss3.dim[0]; i++) { + for (unsigned j=0; j != ss3.dim[1]; j++) { + for (unsigned k=0; k != ss3.dim[2]; k++) { + printf(" %2d", *cspan_at(&ss3, i, j, k)); + } + puts(""); + } puts(""); } - ms2 = (ispan2)cspan_at3(&ms3, 0); + puts("Iterate ss3 flat:"); + c_FOREACH (i, ispan3, ss3) + printf(" %d", *i.ref); + puts(""); + + ispan2 ms2 = cspan_at3(&ms3, 0); // 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; - // print all items using 1D view - printf("all: "); + puts("\nview data as 1D view:"); for (unsigned i=0; i != cspan_size(&ms1); i++) printf(" %d", *cspan_at(&ms1, i)); puts(""); - // or iterate a subspan... + puts("iterate subspan ms3[1]:"); ispan2 sub = cspan_at3(&ms3, 1); - printf("sub: "); c_FOREACH (i, ispan2, sub) printf(" %d", *i.ref); puts(""); - // read back using 3D view - for (unsigned i=0; i != ms3.dim[0]; i++) - { - printf("slice @ i = %u\n", i); - 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)); - puts(""); - } - } cstack_int_drop(&v); } -- cgit v1.2.3 From a344b43728ff40a2e1ee25f2f1b592f33432aee7 Mon Sep 17 00:00:00 2001 From: Tyge Lovset Date: Sat, 28 Jan 2023 22:07:28 +0100 Subject: Generalized cspan_slice(), and improved usage/ergonomics. --- docs/cspan_api.md | 3 +-- include/stc/cspan.h | 52 ++++++++++++++++++------------------------------ misc/examples/multidim.c | 2 +- 3 files changed, 21 insertions(+), 36 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index c0b86239..32ef49c4 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -41,8 +41,7 @@ SpanType cspan_at2(SpanType2* self, size_t x); // retur SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // return a 1d or 2d subspan from a 3d span. SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. -void cspan_slice(SpanTypeN* self, uint32_t xslice[2], ...); // slice multidim span into a md subspan. -uint32_t[2] c_SLICE(a, b) // use to specify a:b xslice, ... b is optional. +void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice multidim span into a md subspan. // return a subspan of same rank: SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 41ad8c8b..19dd74d4 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -151,12 +151,13 @@ typedef struct { uint32_t d[4]; } cspan_idx4; {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}} // cspan_slice: -// e.g.: cspan_slice(&ms3, c_SLICE(1,3), c_SLICE(0), c_SLICE(1,4)); - -#define c_SLICE(...) ((const uint32_t[2]){__VA_ARGS__}) +// e.g.: cspan_slice(&ms3, {1,3}, {0}, {1,4}); #define cspan_slice(self, ...) \ - ((void)((self)->data += c_PASTE(_cspan_slice, c_NUMARGS(__VA_ARGS__))((self)->dim, (self)->stride, __VA_ARGS__))) + ((void)((self)->data += _cspan_slice(cspan_rank(self), (self)->dim, (self)->stride.d, \ + (const uint32_t[][2]){__VA_ARGS__}) + \ + c_static_assert(cspan_rank(self) == \ + sizeof((const uint32_t[][2]){__VA_ARGS__})/8))) // FUNCTIONS @@ -198,35 +199,20 @@ static inline size_t _cspan_next_2(int rank, uint32_t pos[], const uint32_t dim[ return off; } -STC_INLINE size_t _cspan_slice2(uint32_t dim[2], const cspan_idx2 stri, const uint32_t x[2], const uint32_t y[2]) { - const uint32_t x1 = x[1] ? x[1] : dim[0], y1 = y[1] ? y[1] : dim[1]; - const size_t ret = _cspan_i2(dim, stri, x[0], y[0]); - - c_ASSERT(x1 <= dim[0] && y1 <= dim[1]); - dim[0] = x1 - x[0], dim[1] = y1 - y[0]; - return ret; -} - -STC_INLINE size_t _cspan_slice3(uint32_t dim[3], const cspan_idx3 stri, const uint32_t x[2], const uint32_t y[2], - const uint32_t z[2]) { - const uint32_t x1 = x[1] ? x[1] : dim[0], y1 = y[1] ? y[1] : dim[1], z1 = z[1] ? z[1] : dim[2]; - const size_t ret = stri.d[2]*(stri.d[1]*x[0] + y[0]) + z[0]; - - c_ASSERT(x1 <= dim[0] && y1 <= dim[1] && z1 <= dim[2]); - dim[0] = x1 - x[0], dim[1] = y1 - y[0], dim[2] = z1 - z[0]; - return ret; -} - -STC_INLINE size_t _cspan_slice4(uint32_t dim[4], const cspan_idx4 stri, const uint32_t x[2], const uint32_t y[2], - const uint32_t z[2], const uint32_t w[2]) { - const uint32_t x1 = x[1] ? x[1] : dim[0], y1 = y[1] ? y[1] : dim[1]; - const uint32_t z1 = z[1] ? z[1] : dim[2], w1 = w[1] ? w[1] : dim[3]; - const size_t ret = stri.d[3]*(stri.d[2]*(stri.d[1]*x[0] + y[0]) + z[0]) + w[0]; - - c_ASSERT(x1 <= dim[0] && y1 <= dim[1] && z1 <= dim[2] && w1 <= dim[3]); - dim[0] = x1 - x[0], dim[1] = y1 - y[0]; - dim[2] = z1 - z[0], dim[3] = w1 - w[0]; - return ret; +STC_INLINE size_t _cspan_slice(int rank, uint32_t dim[], const uint32_t stri[], const uint32_t a[][2]) { + uint32_t t = a[0][1] ? a[0][1] : dim[0]; + c_ASSERT(t <= dim[0]); + dim[0] = t - a[0][0]; + + size_t off = a[0][0]; + for (int i = 1; i < rank; ++i) { + off *= stri[i]; + off += a[i][0]; + t = a[i][1] ? a[i][1] : dim[i]; + c_ASSERT(t <= dim[i]); + dim[i] = t - a[i][0]; + } + return off; } #endif diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index f3d9e865..e25d727e 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -30,7 +30,7 @@ int main() } puts("ss3 = ms3[:, 1:3, 1:3]"); ispan3 ss3 = ms3; - cspan_slice(&ss3, c_SLICE(0), c_SLICE(1,3), c_SLICE(1,3)); + cspan_slice(&ss3, {0}, {1,3}, {1,3}); for (unsigned i=0; i != ss3.dim[0]; i++) { for (unsigned j=0; j != ss3.dim[1]; j++) { -- cgit v1.2.3 From 209bf743e0c1253a4bc81d2ffb6897f657a84c8a Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sun, 29 Jan 2023 17:24:33 +0100 Subject: Some method renaming in cspan: cspan_multidim() ctor => cspan_md(). cspan_atN() => cspan_submdN(). cstr_replace_ex() merged as overload of cstr_replace(). --- docs/cspan_api.md | 110 ++++++++++++++++++++++++++++++++++---------- docs/cstr_api.md | 5 +- include/stc/cspan.h | 24 +++++----- include/stc/cstr.h | 6 +-- include/stc/priv/altnames.h | 12 ----- misc/examples/demos.c | 2 +- misc/examples/multidim.c | 6 +-- misc/tests/cspan_test.c | 39 ++++++++++++++-- 8 files changed, 141 insertions(+), 63 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 32ef49c4..c4cb7c16 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -1,9 +1,8 @@ # STC [cspan](../include/stc/cspan.h): Multi-dimensional Array View ![Array](pics/array.jpg) -The **cspan** is templated non-owning multi-dimensional view of an array. - -See the c++ classes [std::span](https://en.cppreference.com/w/cpp/container/span) and +The **cspan** is templated non-owning multi-dimensional view of an array. See the c++ classes +[std::span](https://en.cppreference.com/w/cpp/container/span) and [std::mdspan](https://en.cppreference.com/w/cpp/container/mdspan) for similar functionality. ## Header file and declaration @@ -18,17 +17,14 @@ using_cspan3(S, ValueType); // define span types S, S2, S3 with rank using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. ``` ## Methods -Note that `cspan_multidim()`, `cmake_from*()`, `cspan_atN()`, `and cspan_subspanN()` require a (safe) cast to its span-type +Note that `cspan_md()`, `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 +SpanTypeN cspan_md(ValueType* data, size_t xdim, ...); // create a multi-dimensional cspan SpanType cspan_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values -SpanTypeN cspan_multidim(ValueType* data, size_t xdim, ...); // create a multi-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_flatten(SpanTypeN* span); // create a 1d cspan from a multidim span -void cspan_resize(SpanTypeN* self, size_t xdim, ...); // change the extent of each dimension - size_t cspan_size(const SpanTypeN* self); // return number of elements unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions size_t cspan_index(const SpanTypeN* self, size_t x, ...); // index of element @@ -37,13 +33,15 @@ ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); -SpanType cspan_at2(SpanType2* self, size_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_at3(SpanType3* self, size_t x, ...); // return a 1d or 2d subspan from a 3d span. -SpanTypeN cspan_at4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. + // return a subspan of lower rank: +SpanType cspan_submd2(SpanType2* self, size_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_submd3(SpanType3* self, size_t x, ...); // return a 1d or 2d subspan from a 3d span. +SpanTypeN cspan_submd4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. + // return a sliced span of same rank: void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice multidim span into a md subspan. - // return a subspan of same rank: + // return a subspan of same rank. Like e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); SpanType2 cspan_subspan2(const SpanType2 self, size_t offset, size_t count); SpanType3 cspan_subspan3(const SpanType3 self, size_t offset, size_t count); @@ -61,9 +59,73 @@ void SpanType_next(SpanTypeN_iter* it); | SpanTypeN`_value` | `ValueType` | The ValueType | | SpanTypeN`_iter` | `struct { ValueType *ref; ... }` | Iterator type | -## Example +## Example 1 + +The *cspan_slice()* function is similar to pythons numpy multi-dimensional arrays slicing, e.g.: +```py +import numpy as np +ms3 = np.array((1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24), int) + +ms3 = np.reshape(ms3, (2, 3, 4)) +ss3 = ms3[:, 1:3, 2:] +ss2 = ss3[1] + +for i in range(ss2.shape[0]): + for j in range(ss2.shape[1]): + print(" {}".format(ss2[i, j]), end='') +print('') + +for i in ss2.flat: + print(" {}".format(i), end='') +# 19 20 23 24 +# 19 20 23 24 +``` +... can be done in C with STC: +```c +#include +#include +using_cspan3(myspan, int); // define myspan, myspan2, myspan3. + +int main() { + int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}; + + myspan3 ms3 = cspan_md(arr, 2, 3, 4), ss3 = ms3; + cspan_slice(&ss3, {0}, {1,3}, {2,}); + myspan2 ss2 = cspan_submd3(&ss3, 1); + + c_FORRANGE (i, ss2.dim[0]) + c_FORRANGE (j, ss2.dim[1]) + fmt_print(" {}", *cspan_at(&ss2, i, j)); + puts(""); + + c_FOREACH (i, myspan2, ss2) + fmt_print(" {}", *i.ref); +} +``` +... or (mostly) in C++23: +```c++ +#include +#include +#include + +int main() { + int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}; + + std::mdspan ms3(arr, 2, 3, 4); + auto ss3 = std::submdspan(ms3, std::full_extent, std::tuple{1,3}, std::tuple{2,4}); + auto ss2 = std::submdspan(ss3, 1, std::full_extent, std::full_extent); + + for (std::size_t i = 0; i < ss2.extent(0); ++i) + for (std::size_t j = 0; j < ss2.extent(1); ++j) + std::print(" {}", ss2[i, j]); + std::println(); + + // mdspan can't printed as a flat array, afaik. +} +``` +## Example 2 ```c -#include +#include #include #define i_val float #include @@ -79,33 +141,33 @@ int main() cstack_float_push(&vec, i); // define "span3[xd][yd][zd]" - Span3 span3 = cspan_multidim(vec.data, xd, yd, zd); + Span3 span3 = cspan_md(vec.data, xd, yd, zd); *cspan_at(&span3, 4, 3, 2) = 3.14159f; - printf("index: %d", (int)cspan_index(&span3, 4, 3, 2)); + fmt_print("index: {}", cspan_index(&span3, 4, 3, 2)); - Span span1 = cspan_at3(&span3, 4, 3); + Span span1 = cspan_submd3(&span3, 4, 3); printf("\niterate span1: "); c_FOREACH (i, Span, span1) - printf("%g ", *i.ref); + fmt_print("{} ", *i.ref); - Span2 span2 = cspan_at3(&span3, 4); + Span2 span2 = cspan_submd3(&span3, 4); printf("\niterate span2: "); c_FOREACH (i, Span2, span2) - printf("%g ", *i.ref); + fmt_print("{} ", *i.ref); puts("\niterate span3 by dimensions:"); 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)); + fmt_printf(" {:2}", *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)); + fmt_println("{}", *cspan_at(&span3, 4, 3, 2)); + fmt_println("{}", *cspan_at(&span2, 3, 2)); + fmt_println("{}", *cspan_at(&span1, 2)); } } ``` diff --git a/docs/cstr_api.md b/docs/cstr_api.md index 4f895549..48999654 100644 --- a/docs/cstr_api.md +++ b/docs/cstr_api.md @@ -68,8 +68,7 @@ void cstr_insert_s(cstr* self, size_t pos, cstr ins); void cstr_erase(cstr* self, size_t pos, size_t len); // erase len bytes from pos -void cstr_replace(cstr* self, const char* search, const char* repl); -void cstr_replace_ex(cstr* self, const char* search, const char* repl, unsigned count); +void cstr_replace(cstr* self, const char* search, const char* repl, unsigned count = MAX_INT); cstr cstr_replace_sv(csview in, csview search, csview repl, unsigned count); void cstr_replace_at(cstr* self, size_t pos, size_t len, const char* repl); // replace at a position void cstr_replace_at_sv(cstr* self, size_t pos, size_t len, const csview repl); @@ -174,7 +173,7 @@ int main() { cstr_erase(&s1, 7, 5); // -nine printf("%s\n", cstr_str(&s1)); - cstr_replace_ex(&s1, "seven", "four", 1); + cstr_replace(&s1, "seven", "four", 1); printf("%s\n", cstr_str(&s1)); // reassign: diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 19dd74d4..7886c9f6 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -30,7 +30,7 @@ using_cspan(Intspan, int, 1); int demo1() { float raw[4*5]; - Span2f ms = cspan_multidim(raw, 4, 5); + Span2f ms = cspan_md(raw, 4, 5); for (size_t i=0; idata) #define cspan_back(self) ((self)->data + cspan_size(self) - 1) -// cspan_subspan: +// cspan_subspanN: #define cspan_subspan(self, offset, count) \ {.data=cspan_at(self, offset), .dim={count}} @@ -130,24 +130,24 @@ typedef struct { uint32_t d[4]; } cspan_idx4; {.data=cspan_at(self, offset, 0, 0, 0), .dim={count, (self)->dim[1], (self)->dim[2], (self)->dim[3]}, \ .stride={(self)->stride}} -// cspan_atN: +// cspan_submdN: -#define cspan_at4(...) c_MACRO_OVERLOAD(cspan_at4, __VA_ARGS__) -#define cspan_at3(...) c_MACRO_OVERLOAD(cspan_at3, __VA_ARGS__) -#define cspan_at2(self, x) \ +#define cspan_submd4(...) c_MACRO_OVERLOAD(cspan_submd4, __VA_ARGS__) +#define cspan_submd3(...) c_MACRO_OVERLOAD(cspan_submd3, __VA_ARGS__) +#define cspan_submd2(self, x) \ {.data=cspan_at(self, x, 0), .dim={(self)->dim[1]}} -#define cspan_at3_2(self, x) \ +#define cspan_submd3_2(self, x) \ {.data=cspan_at(self, x, 0, 0), .dim={(self)->dim[1], (self)->dim[2]}, \ .stride={.d={0, (self)->stride.d[2]}}} -#define cspan_at3_3(self, x, y) \ +#define cspan_submd3_3(self, x, y) \ {.data=cspan_at(self, x, y, 0), .dim={(self)->dim[2]}} -#define cspan_at4_2(self, x) \ +#define cspan_submd4_2(self, x) \ {.data=cspan_at(self, x, 0, 0, 0), .dim={(self)->dim[1], (self)->dim[2], (self)->dim[3]}, \ .stride={.d={0, (self)->stride.d[2], (self)->stride.d[3]}}} -#define cspan_at4_3(self, x, y) \ +#define cspan_submd4_3(self, x, y) \ {.data=cspan_at(self, x, y, 0, 0), .dim={(self)->dim[2], (self)->dim[3]}, \ .stride={.d={0, (self)->stride.d[3]}}} -#define cspan_at4_4(self, x, y, z) \ +#define cspan_submd4_4(self, x, y, z) \ {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}} // cspan_slice: diff --git a/include/stc/cstr.h b/include/stc/cstr.h index 04091968..071e40e8 100644 --- a/include/stc/cstr.h +++ b/include/stc/cstr.h @@ -373,12 +373,12 @@ STC_INLINE char* cstr_append_s(cstr* self, cstr s) { return cstr_append_n(self, sv.str, sv.size); } -STC_INLINE void cstr_replace_ex(cstr* self, const char* search, const char* repl, unsigned count) { +#define cstr_replace(...) c_MACRO_OVERLOAD(cstr_replace, __VA_ARGS__) +#define cstr_replace_3(self, search, repl) cstr_replace_4(self, search, repl, ~0U) +STC_INLINE void cstr_replace_4(cstr* self, const char* search, const char* repl, unsigned count) { cstr_take(self, cstr_replace_sv(cstr_sv(self), c_SV(search, strlen(search)), c_SV(repl, strlen(repl)), count)); } -STC_INLINE void cstr_replace(cstr* self, const char* search, const char* repl) - { cstr_replace_ex(self, search, repl, ~0U); } STC_INLINE void cstr_replace_at_sv(cstr* self, size_t pos, size_t len, const csview repl) { char* d = _cstr_internal_move(self, pos + len, pos + repl.size); diff --git a/include/stc/priv/altnames.h b/include/stc/priv/altnames.h index 7f58384c..695d3ebc 100644 --- a/include/stc/priv/altnames.h +++ b/include/stc/priv/altnames.h @@ -42,15 +42,3 @@ #define c_scope c_SCOPE #define c_defer c_DEFER #define c_sv c_SV - -#define c_DROP c_drop -#define c_DELETE c_delete -#define c_SWAP c_swap -#define c_FIND_IF c_find_if -#define c_ERASE_IF c_erase_if -#define c_FLT_TAKE c_flt_take -#define c_FLT_SKIP c_flt_skip -#define c_FLT_SKIPWHILE c_flt_skipwhile -#define c_FLT_TAKEWHILE c_flt_takewhile -#define c_CONTAINER_OF c_container_of -#define c_STATIC_ASSERT c_static_assert diff --git a/misc/examples/demos.c b/misc/examples/demos.c index 4455b840..c92f95b2 100644 --- a/misc/examples/demos.c +++ b/misc/examples/demos.c @@ -13,7 +13,7 @@ void stringdemo1() cstr_erase(&cs, 7, 5); // -nine printf("%s.\n", cstr_str(&cs)); - cstr_replace_ex(&cs, "seven", "four", 1); + cstr_replace(&cs, "seven", "four", 1); printf("%s.\n", cstr_str(&cs)); cstr_take(&cs, cstr_from_fmt("%s *** %s", cstr_str(&cs), cstr_str(&cs))); diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index e25d727e..b7ee46fb 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -16,7 +16,7 @@ int main() ispan ms1 = cspan_from(&v); // View the same data as a 3D array 2 x 3 x 4 - ispan3 ms3 = cspan_multidim(v.data, 2, 3, 4); + ispan3 ms3 = cspan_md(v.data, 2, 3, 4); puts("ms3:"); for (unsigned i=0; i != ms3.dim[0]; i++) { @@ -47,7 +47,7 @@ int main() printf(" %d", *i.ref); puts(""); - ispan2 ms2 = cspan_at3(&ms3, 0); + ispan2 ms2 = cspan_submd3(&ms3, 0); // write data using 2D view for (unsigned i=0; i != ms2.dim[0]; i++) @@ -60,7 +60,7 @@ int main() puts(""); puts("iterate subspan ms3[1]:"); - ispan2 sub = cspan_at3(&ms3, 1); + ispan2 sub = cspan_submd3(&ms3, 1); c_FOREACH (i, ispan2, sub) printf(" %d", *i.ref); puts(""); diff --git a/misc/tests/cspan_test.c b/misc/tests/cspan_test.c index 6b85af00..32634795 100644 --- a/misc/tests/cspan_test.c +++ b/misc/tests/cspan_test.c @@ -7,12 +7,12 @@ using_cspan3(intspan, int); CTEST(cspan, subdim) { int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - intspan3 m = cspan_multidim(array, 2, 2, 3); + intspan3 m = cspan_md(array, 2, 2, 3); for (size_t i = 0; i < m.dim[0]; ++i) { - intspan2 sub_i = cspan_at3(&m, i); + intspan2 sub_i = cspan_submd3(&m, i); for (size_t j = 0; j < m.dim[1]; ++j) { - intspan sub_i_j = cspan_at2(&sub_i, j); + intspan sub_i_j = cspan_submd2(&sub_i, j); for (size_t k = 0; k < m.dim[2]; ++k) { ASSERT_EQ(*cspan_at(&sub_i_j, k), *cspan_at(&m, i, j, k)); } @@ -22,7 +22,7 @@ CTEST(cspan, subdim) { CTEST(cspan, slice) { int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - intspan2 m1 = cspan_multidim(array, 3, 4); + intspan2 m1 = cspan_md(array, 3, 4); size_t sum1 = 0; for (size_t i = 0; i < m1.dim[0]; ++i) { @@ -32,7 +32,7 @@ CTEST(cspan, slice) { } intspan2 m2 = m1; - cspan_slice(&m2, c_SLICE(0), c_SLICE(2,4)); + cspan_slice(&m2, {0}, {2,4}); size_t sum2 = 0; for (size_t i = 0; i < m2.dim[0]; ++i) { @@ -43,3 +43,32 @@ CTEST(cspan, slice) { ASSERT_EQ(78, sum1); ASSERT_EQ(45, sum2); } + +#define i_val int +#include + +CTEST(cspan, slice2) { + c_AUTO (cstack_int, stack) + { + c_FORRANGE (i, 10*20*30) + cstack_int_push(&stack, i); + + intspan3 ms3 = cspan_md(stack.data, 10, 20, 30); + cspan_slice(&ms3, {1,4}, {3,7}, {20,24}); + + size_t sum = 0; + for (size_t i = 0; i < ms3.dim[0]; ++i) { + for (size_t j = 0; j < ms3.dim[1]; ++j) { + for (size_t k = 0; k < ms3.dim[2]; ++k) { + sum += *cspan_at(&ms3, i, j, k); + } + } + } + ASSERT_EQ(65112, sum); + + sum = 0; + c_FOREACH (i, intspan3, ms3) + sum += *i.ref; + ASSERT_EQ(65112, sum); + } +} -- cgit v1.2.3 From 6ce6ef3307e52db5813d3c8d6a2cba52df06daf8 Mon Sep 17 00:00:00 2001 From: Tyge Lovset Date: Wed, 1 Feb 2023 08:38:45 +0100 Subject: Massive update from unsigned sizes and indices to signed. --- README.md | 2 +- docs/cbits_api.md | 46 ++++++++++++++++---------------- docs/ccommon_api.md | 2 +- docs/cdeq_api.md | 20 +++++++------- docs/clist_api.md | 4 +-- docs/cmap_api.md | 16 +++++------ docs/cpque_api.md | 12 ++++----- docs/cqueue_api.md | 2 +- docs/crandom_api.md | 4 +-- docs/cset_api.md | 12 ++++----- docs/csmap_api.md | 8 +++--- docs/cspan_api.md | 22 +++++++-------- docs/csset_api.md | 8 +++--- docs/cstack_api.md | 16 +++++------ docs/cstr_api.md | 62 +++++++++++++++++++++---------------------- docs/csview_api.md | 40 ++++++++++++++-------------- docs/cvec_api.md | 28 +++++++++---------- include/stc/algo/csort.h | 4 +-- include/stc/ccommon.h | 9 +++---- include/stc/cdeq.h | 2 +- include/stc/cmap.h | 48 ++++++++++++++++----------------- include/stc/cpque.h | 2 +- include/stc/crandom.h | 2 +- include/stc/cregex.h | 14 +++++----- include/stc/csmap.h | 16 +++++------ include/stc/cstack.h | 2 +- include/stc/cstr.h | 2 +- include/stc/cvec.h | 2 +- include/stc/forward.h | 14 +++++----- include/stc/priv/template.h | 2 +- include/stc/utf8.h | 4 +-- misc/archived/cstr.h | 4 +-- misc/examples/astar.c | 4 +-- misc/examples/birthday.c | 6 ++--- misc/examples/bits.c | 12 ++++----- misc/examples/bits2.c | 4 +-- misc/examples/books.c | 2 +- misc/examples/complex.c | 2 +- misc/examples/csmap_erase.c | 6 ++--- misc/examples/csmap_find.c | 2 +- misc/examples/cstr_match.c | 6 ++--- misc/examples/demos.c | 4 +-- misc/examples/forfilter.c | 2 +- misc/examples/gauss1.c | 2 +- misc/examples/gauss2.c | 4 +-- misc/examples/make.sh | 2 +- misc/examples/new_queue.c | 10 +++---- misc/examples/prime.c | 18 ++++++------- misc/examples/priority.c | 6 ++--- misc/examples/queue.c | 6 ++--- misc/examples/random.c | 18 ++++++------- misc/examples/regex_match.c | 3 ++- misc/examples/sort.c | 8 +++--- misc/examples/sso_map.c | 2 +- misc/examples/sso_substr.c | 2 +- misc/examples/utf8replace_c.c | 7 ++--- src/cregex.c | 60 ++++++++++++++++++++--------------------- src/utf8code.c | 4 +-- 58 files changed, 313 insertions(+), 320 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/README.md b/README.md index 2ba88048..a4b3c76e 100644 --- a/README.md +++ b/README.md @@ -112,7 +112,7 @@ int main(void) FVec_push_back(&vec, 20.f); FVec_push_back(&vec, 30.f); - for (size_t i = 0; i < FVec_size(vec); ++i) + for (intptr_t i = 0; i < FVec_size(vec); ++i) printf(" %g", vec.data[i]); FVec_drop(&vec); // cleanup memory diff --git a/docs/cbits_api.md b/docs/cbits_api.md index b21611df..726fb68b 100644 --- a/docs/cbits_api.md +++ b/docs/cbits_api.md @@ -21,34 +21,34 @@ All cbits definitions and prototypes are available by including a single header ```c cbits cbits_init(void); cbits cbits_from(const char* str); -cbits cbits_with_size(size_t size, bool value); // size must be <= N if N is defined -cbits cbits_with_pattern(size_t size, uint64_t pattern); +cbits cbits_with_size(intptr_t size, bool value); // size must be <= N if N is defined +cbits cbits_with_pattern(intptr_t size, uint64_t pattern); cbits cbits_clone(cbits other); void cbits_clear(cbits* self); cbits* cbits_copy(cbits* self, const cbits* other); -void cbits_resize(cbits* self, size_t size, bool value); // only if i_len is not defined +void cbits_resize(cbits* self, intptr_t size, bool value); // only if i_len is not defined void cbits_drop(cbits* self); cbits* cbits_take(cbits* self, const cbits* other); // give other to self cbits cbits_move(cbits* self); // transfer self to caller -size_t cbits_size(const cbits* self); -size_t cbits_count(const cbits* self); // count number of bits set +intptr_t cbits_size(const cbits* self); +intptr_t cbits_count(const cbits* self); // count number of bits set -bool cbits_test(const cbits* self, size_t i); -bool cbits_at(const cbits* self, size_t i); // same as cbits_test() +bool cbits_test(const cbits* self, intptr_t i); +bool cbits_at(const cbits* self, intptr_t i); // same as cbits_test() bool cbits_subset_of(const cbits* self, const cbits* other); // is set a subset of other? bool cbits_disjoint(const cbits* self, const cbits* other); // no common bits -char* cbits_to_str(const cbits* self, char* str, size_t start, size_t stop); +char* cbits_to_str(const cbits* self, char* str, intptr_t start, intptr_t stop); -void cbits_set(cbits* self, size_t i); -void cbits_reset(cbits* self, size_t i); -void cbits_set_value(cbits* self, size_t i, bool value); +void cbits_set(cbits* self, intptr_t i); +void cbits_reset(cbits* self, intptr_t i); +void cbits_set_value(cbits* self, intptr_t i, bool value); void cbits_set_all(cbits* self, bool value); void cbits_set_pattern(cbits* self, uint64_t pattern); void cbits_flip_all(cbits* self); -void cbits_flip(cbits* self, size_t i); +void cbits_flip(cbits* self, intptr_t i); void cbits_intersect(cbits* self, const cbits* other); void cbits_union(cbits* self, const cbits* other); @@ -70,19 +70,19 @@ void cbits_xor(cbits* self, const cbits* other); // set #include #include -cbits sieveOfEratosthenes(size_t n) +cbits sieveOfEratosthenes(intptr_t n) { cbits bits = cbits_with_size(n>>1, true); - size_t q = (size_t) sqrt(n); + intptr_t q = (intptr_t) sqrt(n); - for (size_t i = 3; i <= q; i += 2) { - for (size_t j = i; j < n; j += 2) { + for (intptr_t i = 3; i <= q; i += 2) { + for (intptr_t j = i; j < n; j += 2) { if (cbits_test(&bits, j>>1)) { i = j; break; } } - for (size_t j = i*i; j < n; j += i*2) + for (intptr_t j = i*i; j < n; j += i*2) cbits_reset(&bits, j>>1); } return bits; @@ -90,19 +90,19 @@ cbits sieveOfEratosthenes(size_t n) int main(void) { - size_t n = 100000000; - printf("computing prime numbers up to %" c_ZU "\n", n); + intptr_t n = 100000000; + printf("computing prime numbers up to %" c_ZI "\n", n); clock_t t1 = clock(); cbits primes = sieveOfEratosthenes(n + 1); - size_t nprimes = cbits_count(&primes); + intptr_t nprimes = cbits_count(&primes); clock_t t2 = clock(); - printf("number of primes: %" c_ZU ", time: %f\n", nprimes, (float)(t2 - t1)/CLOCKS_PER_SEC); + printf("number of primes: %" c_ZI ", time: %f\n", nprimes, (float)(t2 - t1)/CLOCKS_PER_SEC); printf(" 2"); - for (size_t i = 3; i < 1000; i += 2) - if (cbits_test(&primes, i>>1)) printf(" %" c_ZU, i); + for (intptr_t i = 3; i < 1000; i += 2) + if (cbits_test(&primes, i>>1)) printf(" %" c_ZI, i); puts(""); cbits_drop(&primes); diff --git a/docs/ccommon_api.md b/docs/ccommon_api.md index 18edbeba..43f747ab 100644 --- a/docs/ccommon_api.md +++ b/docs/ccommon_api.md @@ -361,5 +361,5 @@ Memory allocator for the entire library. Macros can be overridden by the user. - **c_ARRAYLEN(array)**: Return number of elements in an array. array must not be a pointer! ```c int array[] = {1, 2, 3, 4}; -size_t n = c_ARRAYLEN(array); +intptr_t n = c_ARRAYLEN(array); ``` diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md index 584d382f..44a75fc2 100644 --- a/docs/cdeq_api.md +++ b/docs/cdeq_api.md @@ -27,21 +27,21 @@ See the c++ class [std::deque](https://en.cppreference.com/w/cpp/container/deque ```c cdeq_X cdeq_X_init(void); -cdeq_X cdeq_X_with_capacity(size_t size); +cdeq_X cdeq_X_with_capacity(intptr_t size); cdeq_X cdeq_X_clone(cdeq_X deq); void cdeq_X_clear(cdeq_X* self); void cdeq_X_copy(cdeq_X* self, const cdeq_X* other); cdeq_X_iter cdeq_X_copy_range(cdeq_X* self, i_val* pos, const i_val* p1, const i_val* p2); -bool cdeq_X_reserve(cdeq_X* self, size_t cap); +bool cdeq_X_reserve(cdeq_X* self, intptr_t cap); void cdeq_X_shrink_to_fit(cdeq_X* self); void cdeq_X_drop(cdeq_X* self); // destructor bool cdeq_X_empty(const cdeq_X* self); -size_t cdeq_X_size(const cdeq_X* self); -size_t cdeq_X_capacity(const cdeq_X* self); +intptr_t cdeq_X_size(const cdeq_X* self); +intptr_t cdeq_X_capacity(const cdeq_X* self); -const cdeq_X_value* cdeq_X_at(const cdeq_X* self, size_t idx); +const cdeq_X_value* cdeq_X_at(const cdeq_X* self, intptr_t idx); const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw); // return NULL if not found cdeq_X_value* cdeq_X_get_mut(cdeq_X* self, i_valraw raw); // mutable get cdeq_X_iter cdeq_X_find(const cdeq_X* self, i_valraw raw); @@ -60,18 +60,18 @@ cdeq_X_value* cdeq_X_emplace_back(cdeq_X* self, i_valraw raw); cdeq_X_value* cdeq_X_emplace(cdeq_X* self, i_valraw raw); // alias for emplace_back() void cdeq_X_pop_back(cdeq_X* self); -cdeq_X_iter cdeq_X_insert(cdeq_X* self, size_t idx, i_val value); // move value -cdeq_X_iter cdeq_X_insert_n(cdeq_X* self, size_t idx, const i_val[] arr, size_t n); // move arr values +cdeq_X_iter cdeq_X_insert(cdeq_X* self, intptr_t idx, i_val value); // move value +cdeq_X_iter cdeq_X_insert_n(cdeq_X* self, intptr_t idx, const i_val[] arr, intptr_t n); // move arr values cdeq_X_iter cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value); // move value cdeq_X_iter cdeq_X_insert_range(cdeq_X* self, i_val* pos, const i_val* p1, const i_val* p2); -cdeq_X_iter cdeq_X_emplace_n(cdeq_X* self, size_t idx, const i_valraw[] arr, size_t n); // clone values +cdeq_X_iter cdeq_X_emplace_n(cdeq_X* self, intptr_t idx, const i_valraw[] arr, intptr_t n); // clone values cdeq_X_iter cdeq_X_emplace_at(cdeq_X* self, cdeq_X_iter it, i_valraw raw); cdeq_X_iter cdeq_X_emplace_range(cdeq_X* self, i_val* pos, const i_valraw* p1, const i_valraw* p2); -cdeq_X_iter cdeq_X_erase_n(cdeq_X* self, size_t idx, size_t n); +cdeq_X_iter cdeq_X_erase_n(cdeq_X* self, intptr_t idx, intptr_t n); cdeq_X_iter cdeq_X_erase_at(cdeq_X* self, cdeq_X_iter it); cdeq_X_iter cdeq_X_erase_range(cdeq_X* self, cdeq_X_iter it1, cdeq_X_iter it2); cdeq_X_iter cdeq_X_erase_range_p(cdeq_X* self, i_val* p1, i_val* p2); @@ -83,7 +83,7 @@ void cdeq_X_sort_range(cdeq_X_iter i1, cdeq_X_iter i2, cdeq_X_iter cdeq_X_begin(const cdeq_X* self); cdeq_X_iter cdeq_X_end(const cdeq_X* self); void cdeq_X_next(cdeq_X_iter* it); -cdeq_X_iter cdeq_X_advance(cdeq_X_iter it, intptr_t n); +cdeq_X_iter cdeq_X_advance(cdeq_X_iter it, size_t n); cdeq_X_raw cdeq_X_value_toraw(cdeq_X_value* pval); cdeq_X_value cdeq_X_value_clone(cdeq_X_value val); diff --git a/docs/clist_api.md b/docs/clist_api.md index e97d7b5d..13c27308 100644 --- a/docs/clist_api.md +++ b/docs/clist_api.md @@ -48,7 +48,7 @@ void clist_X_copy(clist_X* self, const clist_X* other); void clist_X_drop(clist_X* self); // destructor bool clist_X_empty(const clist_X* list); -size_t clist_X_count(const clist_X* list); // size() in O(n) time +intptr_t clist_X_count(const clist_X* list); // size() in O(n) time clist_X_value* clist_X_back(const clist_X* self); clist_X_value* clist_X_front(const clist_X* self); @@ -67,7 +67,7 @@ clist_X_iter clist_X_emplace_at(clist_X* self, clist_X_iter it, i_valraw void clist_X_pop_front(clist_X* self); clist_X_iter clist_X_erase_at(clist_X* self, clist_X_iter it); // return iter after it clist_X_iter clist_X_erase_range(clist_X* self, clist_X_iter it1, clist_X_iter it2); -size_t clist_X_remove(clist_X* self, i_valraw raw); // removes all matches +intptr_t clist_X_remove(clist_X* self, i_valraw raw); // removes all matches clist_X clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2); // split off [i1, i2) clist_X_iter clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other); // return updated valid it diff --git a/docs/cmap_api.md b/docs/cmap_api.md index 3848e67e..7b8fbb8f 100644 --- a/docs/cmap_api.md +++ b/docs/cmap_api.md @@ -48,20 +48,20 @@ See the c++ class [std::unordered_map](https://en.cppreference.com/w/cpp/contain ```c cmap_X cmap_X_init(void); -cmap_X cmap_X_with_capacity(size_t cap); +cmap_X cmap_X_with_capacity(intptr_t cap); cmap_X cmap_X_clone(cmap_x map); void cmap_X_clear(cmap_X* self); void cmap_X_copy(cmap_X* self, const cmap_X* other); -float cmap_X_max_load_factor(const cmap_X* self); // default: 0.85f -bool cmap_X_reserve(cmap_X* self, size_t size); +float cmap_X_max_load_factor(const cmap_X* self); // default: 0.85f +bool cmap_X_reserve(cmap_X* self, intptr_t size); void cmap_X_shrink_to_fit(cmap_X* self); void cmap_X_drop(cmap_X* self); // destructor -size_t cmap_X_size(const cmap_X* self); -size_t cmap_X_capacity(const cmap_X* self); // buckets * max_load_factor +intptr_t cmap_X_size(const cmap_X* self); +intptr_t cmap_X_capacity(const cmap_X* self); // buckets * max_load_factor bool cmap_X_empty(const cmap_X* self ); -size_t cmap_X_bucket_count(const cmap_X* self); // num. of allocated buckets +intptr_t cmap_X_bucket_count(const cmap_X* self); // num. of allocated buckets const cmap_X_mapped* cmap_X_at(const cmap_X* self, i_keyraw rkey); // rkey must be in map cmap_X_mapped* cmap_X_at_mut(cmap_X* self, i_keyraw rkey); // mutable at @@ -77,7 +77,7 @@ cmap_X_result cmap_X_push(cmap_X* self, cmap_X_value entry); 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 rmapped -size_t cmap_X_erase(cmap_X* self, i_keyraw rkey); // return 0 or 1 +intptr_t 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 void cmap_X_erase_entry(cmap_X* self, cmap_X_value* entry); @@ -93,7 +93,7 @@ Helpers: ```c uint64_t c_default_hash(const X *obj); // macro, calls cfasthash(obj, sizeof *obj) uint64_t cstrhash(const char *str); // string hash funcion, uses strlen() -uint64_t cfasthash(const void *data, size_t len); // base hash function +uint64_t cfasthash(const void *data, intptr_t len); // base hash function // equalto template parameter functions: bool c_default_eq(const i_keyraw* a, const i_keyraw* b); // *a == *b diff --git a/docs/cpque_api.md b/docs/cpque_api.md index 392d3149..48a5b29e 100644 --- a/docs/cpque_api.md +++ b/docs/cpque_api.md @@ -28,17 +28,17 @@ See the c++ class [std::priority_queue](https://en.cppreference.com/w/cpp/contai ```c cpque_X cpque_X_init(void); // create empty pri-queue. -cpque_X cpque_X_with_capacity(size_t cap); -cpque_X cpque_X_with_size(size_t size, i_val null); +cpque_X cpque_X_with_capacity(intptr_t cap); +cpque_X cpque_X_with_size(intptr_t size, i_val null); cpque_X cpque_X_clone(cpque_X pq); void cpque_X_clear(cpque_X* self); -bool cpque_X_reserve(cpque_X* self, size_t n); +bool cpque_X_reserve(cpque_X* self, intptr_t n); void cpque_X_shrink_to_fit(cpque_X* self); void cpque_X_copy(cpque_X* self, const cpque_X* other); void cpque_X_drop(cpque_X* self); // destructor -size_t cpque_X_size(const cpque_X* self); +intptr_t cpque_X_size(const cpque_X* self); bool cpque_X_empty(const cpque_X* self); i_val* cpque_X_top(const cpque_X* self); @@ -47,7 +47,7 @@ void cpque_X_push(cpque_X* self, i_val value); void cpque_X_emplace(cpque_X* self, i_valraw raw); // converts from raw void cpque_X_pop(cpque_X* self); -void cpque_X_erase_at(cpque_X* self, size_t idx); +void cpque_X_erase_at(cpque_X* self, intptr_t idx); i_val cpque_X_value_clone(i_val value); ``` @@ -71,7 +71,7 @@ i_val cpque_X_value_clone(i_val value); int main() { - size_t N = 10000000; + intptr_t N = 10000000; stc64_t rng = stc64_new(1234); stc64_uniform_t dist = stc64_uniform_new(0, N * 10); diff --git a/docs/cqueue_api.md b/docs/cqueue_api.md index 977fa855..212cdabe 100644 --- a/docs/cqueue_api.md +++ b/docs/cqueue_api.md @@ -32,7 +32,7 @@ void cqueue_X_clear(cqueue_X* self); void cqueue_X_copy(cqueue_X* self, const cqueue_X* other); void cqueue_X_drop(cqueue_X* self); // destructor -size_t cqueue_X_size(const cqueue_X* self); +intptr_t cqueue_X_size(const cqueue_X* self); bool cqueue_X_empty(const cqueue_X* self); cqueue_X_value* cqueue_X_front(const cqueue_X* self); cqueue_X_value* cqueue_X_back(const cqueue_X* self); diff --git a/docs/crandom_api.md b/docs/crandom_api.md index bd3bf848..7dced0eb 100644 --- a/docs/crandom_api.md +++ b/docs/crandom_api.md @@ -76,7 +76,7 @@ double stc64_normalf(stc64_t* rng, stc64_normalf_t* dist); // Declare int -> int sorted map. Uses typetag 'i' for ints. #define i_key int -#define i_val size_t +#define i_val intptr_t #define i_tag i #include @@ -102,7 +102,7 @@ int main() // Print the gaussian bar chart cstr bar = cstr_init(); c_FOREACH (i, csmap_i, mhist) { - size_t n = (size_t) (i.ref->second * StdDev * Scale * 2.5 / N); + int n = (int)(i.ref->second * StdDev * Scale * 2.5 / N); if (n > 0) { cstr_resize(&bar, n, '*'); printf("%4d %s\n", i.ref->first, cstr_str(&bar)); diff --git a/docs/cset_api.md b/docs/cset_api.md index e1d08a87..2e80a49b 100644 --- a/docs/cset_api.md +++ b/docs/cset_api.md @@ -30,20 +30,20 @@ A **cset** is an associative container that contains a set of unique objects of ```c cset_X cset_X_init(void); -cset_X cset_X_with_capacity(size_t cap); +cset_X cset_X_with_capacity(intptr_t cap); cset_X cset_X_clone(cset_x set); void cset_X_clear(cset_X* self); void cset_X_copy(cset_X* self, const cset_X* other); float cset_X_max_load_factor(const cset_X* self); // default: 0.85 -bool cset_X_reserve(cset_X* self, size_t size); +bool cset_X_reserve(cset_X* self, intptr_t size); void cset_X_shrink_to_fit(cset_X* self); void cset_X_drop(cset_X* self); // destructor -size_t cset_X_size(const cset_X* self); // num. of allocated buckets -size_t cset_X_capacity(const cset_X* self); // buckets * max_load_factor +intptr_t cset_X_size(const cset_X* self); // num. of allocated buckets +intptr_t cset_X_capacity(const cset_X* self); // buckets * max_load_factor bool cset_X_empty(const cset_X* self); -size_t cset_X_bucket_count(const cset_X* self); +intptr_t cset_X_bucket_count(const cset_X* self); bool cset_X_contains(const cset_X* self, i_keyraw rkey); const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey); // return NULL if not found @@ -54,7 +54,7 @@ cset_X_result cset_X_insert(cset_X* self, i_key key); cset_X_result cset_X_push(cset_X* self, i_key key); // alias for insert. cset_X_result cset_X_emplace(cset_X* self, i_keyraw rkey); -size_t cset_X_erase(cset_X* self, i_keyraw rkey); // return 0 or 1 +intptr_t cset_X_erase(cset_X* self, i_keyraw rkey); // return 0 or 1 cset_X_iter cset_X_erase_at(cset_X* self, cset_X_iter it); // return iter after it void cset_X_erase_entry(cset_X* self, cset_X_value* entry); diff --git a/docs/csmap_api.md b/docs/csmap_api.md index 687a6cab..d0a57bdb 100644 --- a/docs/csmap_api.md +++ b/docs/csmap_api.md @@ -42,8 +42,8 @@ See the c++ class [std::map](https://en.cppreference.com/w/cpp/container/map) fo ```c csmap_X csmap_X_init(void); -csset_X csmap_X_with_capacity(size_t cap); -bool csmap_X_reserve(csmap_X* self, size_t cap); +csset_X csmap_X_with_capacity(intptr_t cap); +bool csmap_X_reserve(csmap_X* self, intptr_t cap); void csmap_X_shrink_to_fit(csmap_X* self); csmap_X csmap_X_clone(csmap_x map); @@ -51,7 +51,7 @@ void csmap_X_clear(csmap_X* self); void csmap_X_copy(csmap_X* self, const csmap_X* other); void csmap_X_drop(csmap_X* self); // destructor -size_t csmap_X_size(const csmap_X* self); +intptr_t csmap_X_size(const csmap_X* self); bool csmap_X_empty(const csmap_X* self); bool csmap_X_capacity(const csmap_X* self); @@ -74,7 +74,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 -size_t csmap_X_erase(csmap_X* self, i_keyraw rkey); +intptr_t 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 csmap_X_iter csmap_X_erase_range(csmap_X* self, csmap_X_iter it1, csmap_X_iter it2); // returns updated it2 diff --git a/docs/cspan_api.md b/docs/cspan_api.md index c4cb7c16..8f6f695f 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -20,32 +20,32 @@ using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with Note that `cspan_md()`, `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 -SpanTypeN cspan_md(ValueType* data, size_t xdim, ...); // create a multi-dimensional cspan +SpanTypeN cspan_md(ValueType* data, intptr_t xdim, ...); // create a multi-dimensional cspan SpanType cspan_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values 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 -size_t cspan_size(const SpanTypeN* self); // return number of elements +intptr_t cspan_size(const SpanTypeN* self); // return number of elements unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions -size_t cspan_index(const SpanTypeN* self, size_t x, ...); // index of element +intptr_t cspan_index(const SpanTypeN* self, intptr_t x, ...); // index of element -ValueType* cspan_at(SpanTypeN* self, size_t x, ...); // at(): num of args specifies rank of input span. +ValueType* cspan_at(SpanTypeN* self, intptr_t x, ...); // at(): num of args specifies rank of input span. ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); // return a subspan of lower rank: -SpanType cspan_submd2(SpanType2* self, size_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_submd3(SpanType3* self, size_t x, ...); // return a 1d or 2d subspan from a 3d span. -SpanTypeN cspan_submd4(SpanType4* self, size_t x, ...); // number of args determines rank of output span. +SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. +SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. // return a sliced span of same rank: void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice multidim span into a md subspan. // return a subspan of same rank. Like e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); -SpanType cspan_subspan(const SpanType* self, size_t offset, size_t count); -SpanType2 cspan_subspan2(const SpanType2 self, size_t offset, size_t count); -SpanType3 cspan_subspan3(const SpanType3 self, size_t offset, size_t count); -SpanType4 cspan_subspan4(const SpanType4 self, size_t offset, size_t count); +SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); +SpanType2 cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count); +SpanType3 cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count); +SpanType4 cspan_subspan4(const SpanType4 self, intptr_t offset, intptr_t count); SpanTypeN_iter SpanType_begin(const SpanTypeN* self); SpanTypeN_iter SpanType_end(const SpanTypeN* self); diff --git a/docs/csset_api.md b/docs/csset_api.md index 6276f486..7e068909 100644 --- a/docs/csset_api.md +++ b/docs/csset_api.md @@ -28,8 +28,8 @@ See the c++ class [std::set](https://en.cppreference.com/w/cpp/container/set) fo ```c csset_X csset_X_init(void); -csset_X csset_X_with_capacity(size_t cap); -bool csset_X_reserve(csset_X* self, size_t cap); +csset_X csset_X_with_capacity(intptr_t cap); +bool csset_X_reserve(csset_X* self, intptr_t cap); void csset_X_shrink_to_fit(csset_X* self); csset_X csset_X_clone(csset_x set); @@ -37,7 +37,7 @@ void csset_X_clear(csset_X* self); void csset_X_copy(csset_X* self, const csset_X* other); void csset_X_drop(csset_X* self); // destructor -size_t csset_X_size(const csset_X* self); +intptr_t csset_X_size(const csset_X* self); bool csset_X_empty(const csset_X* self); const csset_X_value* csset_X_get(const csset_X* self, i_keyraw rkey); // const get @@ -51,7 +51,7 @@ csset_X_result csset_X_insert(csset_X* self, i_key key); csset_X_result csset_X_push(csset_X* self, i_key key); // alias for insert() csset_X_result csset_X_emplace(csset_X* self, i_keyraw rkey); -size_t csset_X_erase(csset_X* self, i_keyraw rkey); +intptr_t csset_X_erase(csset_X* self, i_keyraw rkey); csset_X_iter csset_X_erase_at(csset_X* self, csset_X_iter it); // return iter after it csset_X_iter csset_X_erase_range(csset_X* self, csset_X_iter it1, csset_X_iter it2); // return updated it2 diff --git a/docs/cstack_api.md b/docs/cstack_api.md index e8423385..b1371f4e 100644 --- a/docs/cstack_api.md +++ b/docs/cstack_api.md @@ -26,24 +26,24 @@ See the c++ class [std::stack](https://en.cppreference.com/w/cpp/container/stack ```c cstack_X cstack_X_init(void); -cstack_X cstack_X_with_capacity(size_t cap); -cstack_X cstack_X_with_size(size_t size, i_val fill); +cstack_X cstack_X_with_capacity(intptr_t cap); +cstack_X cstack_X_with_size(intptr_t size, i_val fill); cstack_X cstack_X_clone(cstack_X st); void cstack_X_clear(cstack_X* self); -bool cstack_X_reserve(cstack_X* self, size_t n); +bool cstack_X_reserve(cstack_X* self, intptr_t n); void cstack_X_shrink_to_fit(cstack_X* self); -i_val* cstack_X_append_uninit(cstack_X* self, size_t n); +i_val* cstack_X_append_uninit(cstack_X* self, intptr_t n); void cstack_X_copy(cstack_X* self, const cstack_X* other); void cstack_X_drop(cstack_X* self); // destructor -size_t cstack_X_size(const cstack_X* self); -size_t cstack_X_capacity(const cstack_X* self); +intptr_t cstack_X_size(const cstack_X* self); +intptr_t cstack_X_capacity(const cstack_X* self); bool cstack_X_empty(const cstack_X* self); i_val* cstack_X_top(const cstack_X* self); -const i_val* cstack_X_at(const cstack_X* self, size_t idx); -i_val* cstack_X_at_mut(cstack_X* self, size_t idx); +const i_val* cstack_X_at(const cstack_X* self, intptr_t idx); +i_val* cstack_X_at_mut(cstack_X* self, intptr_t idx); i_val* cstack_X_push(cstack_X* self, i_val value); i_val* cstack_X_emplace(cstack_X* self, i_valraw raw); diff --git a/docs/cstr_api.md b/docs/cstr_api.md index 48999654..6bf5c723 100644 --- a/docs/cstr_api.md +++ b/docs/cstr_api.md @@ -21,10 +21,10 @@ All cstr definitions and prototypes are available by including a single header f cstr cstr_init(void); // constructor; same as cstr_NULL. cstr cstr_lit(const char literal_only[]); // cstr from literal; no strlen() call. cstr cstr_from(const char* str); // constructor using strlen() -cstr cstr_from_n(const char* str, size_t n); // constructor with n first bytes of str +cstr cstr_from_n(const char* str, intptr_t n); // constructor with n first bytes of str cstr cstr_from_sv(csview sv); // construct cstr from csview -cstr cstr_with_capacity(size_t cap); -cstr cstr_with_size(size_t len, char fill); // repeat fill len times +cstr cstr_with_capacity(intptr_t cap); +cstr cstr_with_size(intptr_t len, char fill); // repeat fill len times cstr cstr_from_fmt(const char* fmt, ...); // printf() formatting cstr cstr_clone(cstr s); @@ -37,49 +37,49 @@ char* cstr_data(cstr* self); // cast to csview cstr_sv(const cstr* self); // cast to string view cstr_buf cstr_buffer(cstr* self); // cast to mutable buffer (with capacity) -size_t cstr_size(const cstr* self); -size_t cstr_capacity(const cstr* self); +intptr_t cstr_size(const cstr* self); +intptr_t cstr_capacity(const cstr* self); bool cstr_empty(const cstr* self); -char* cstr_reserve(cstr* self, size_t capacity); // return pointer to buffer -void cstr_resize(cstr* self, size_t len, char fill); +char* cstr_reserve(cstr* self, intptr_t capacity); // return pointer to buffer +void cstr_resize(cstr* self, intptr_t len, char fill); void cstr_shrink_to_fit(cstr* self); void cstr_clear(cstr* self); char* cstr_assign(cstr* self, const char* str); -char* cstr_assign_n(cstr* self, const char* str, size_t n); // assign n first bytes of str +char* cstr_assign_n(cstr* self, const char* str, intptr_t n); // assign n first bytes of str char* cstr_assign_sv(cstr* self, csview sv); char* cstr_copy(cstr* self, cstr s); // copy-assign a cstr int cstr_printf(cstr* self, const char* fmt, ...); // source and target must not overlap. char* cstr_append(cstr* self, const char* str); -char* cstr_append_n(cstr* self, const char* str, size_t n); // append n first bytes of str +char* cstr_append_n(cstr* self, const char* str, intptr_t n); // append n first bytes of str char* cstr_append_sv(cstr* self, csview str); char* cstr_append_s(cstr* self, cstr str); int cstr_append_fmt(cstr* self, const char* fmt, ...); // printf() formatting -char* cstr_append_uninit(cstr* self, size_t len); // return ptr to start of uninited data +char* cstr_append_uninit(cstr* self, intptr_t len); // return ptr to start of uninited data void cstr_push(cstr* self, const char* chr); // append one utf8 char void cstr_pop(cstr* self); // pop one utf8 char -void cstr_insert(cstr* self, size_t pos, const char* ins); -void cstr_insert_sv(cstr* self, size_t pos, csview ins); -void cstr_insert_s(cstr* self, size_t pos, cstr ins); +void cstr_insert(cstr* self, intptr_t pos, const char* ins); +void cstr_insert_sv(cstr* self, intptr_t pos, csview ins); +void cstr_insert_s(cstr* self, intptr_t pos, cstr ins); -void cstr_erase(cstr* self, size_t pos, size_t len); // erase len bytes from pos +void cstr_erase(cstr* self, intptr_t pos, intptr_t len); // erase len bytes from pos void cstr_replace(cstr* self, const char* search, const char* repl, unsigned count = MAX_INT); cstr cstr_replace_sv(csview in, csview search, csview repl, unsigned count); -void cstr_replace_at(cstr* self, size_t pos, size_t len, const char* repl); // replace at a position -void cstr_replace_at_sv(cstr* self, size_t pos, size_t len, const csview repl); -void cstr_replace_at_s(cstr* self, size_t pos, size_t len, cstr repl); +void cstr_replace_at(cstr* self, intptr_t pos, intptr_t len, const char* repl); // replace at a position +void cstr_replace_at_sv(cstr* self, intptr_t pos, intptr_t len, const csview repl); +void cstr_replace_at_s(cstr* self, intptr_t pos, intptr_t len, cstr repl); bool cstr_equals(const cstr* self, const char* str); bool cstr_equals_sv(const cstr* self, csview sv); bool cstr_equals_s(const cstr* self, cstr s); -size_t cstr_find(const cstr* self, const char* search); -size_t cstr_find_at(const cstr* self, size_t pos, const char* search); // search from pos +intptr_t cstr_find(const cstr* self, const char* search); +intptr_t cstr_find_at(const cstr* self, intptr_t pos, const char* search); // search from pos bool cstr_contains(const cstr* self, const char* search); bool cstr_starts_with(const cstr* self, const char* str); @@ -96,13 +96,13 @@ bool cstr_getdelim(cstr *self, int delim, FILE *stream); // does no #### UTF8 methods ```c -size_t cstr_u8_size(const cstr* self); // number of utf8 codepoints -size_t cstr_u8_size_n(const cstr self, size_t nbytes); // utf8 size within n bytes -size_t cstr_u8_to_pos(const cstr* self, size_t u8idx); // byte pos offset at utf8 codepoint index -const char* cstr_u8_at(const cstr* self, size_t u8idx); // char* position at utf8 codepoint index -csview cstr_u8_chr(const cstr* self, size_t u8idx); // get utf8 character as a csview -void cstr_u8_replace_at(cstr* self, size_t bytepos, size_t u8len, csview repl); // replace u8len utf8 chars -void cstr_u8_erase(cstr* self, size_t bytepos, size_t u8len); // erase u8len codepoints from pos +intptr_t cstr_u8_size(const cstr* self); // number of utf8 codepoints +intptr_t cstr_u8_size_n(const cstr self, intptr_t nbytes); // utf8 size within n bytes +intptr_t cstr_u8_to_pos(const cstr* self, intptr_t u8idx); // byte pos offset at utf8 codepoint index +const char* cstr_u8_at(const cstr* self, intptr_t u8idx); // char* position at utf8 codepoint index +csview cstr_u8_chr(const cstr* self, intptr_t u8idx); // get utf8 character as a csview +void cstr_u8_replace_at(cstr* self, intptr_t bytepos, intptr_t u8len, csview repl); // replace u8len utf8 chars +void cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len); // erase u8len codepoints from pos // iterate utf8 codepoints cstr_iter cstr_begin(const cstr* self); @@ -128,7 +128,7 @@ bool cstr_istarts_with(const cstr* self, const char* str); bool cstr_iends_with(const cstr* self, const char* str); // " ``` -Note that all methods with arguments `(..., const char* str, size_t n)`, `n` must be within the range of `str` length. +Note that all methods with arguments `(..., const char* str, intptr_t n)`, `n` must be within the range of `str` length. #### Helper methods: ```c @@ -136,7 +136,7 @@ int cstr_cmp(const cstr* s1, const cstr* s2); bool cstr_eq(const cstr* s1, const cstr* s2); bool cstr_hash(const cstr* self); -char* cstrnstrn(const char* str, const char* search, size_t slen, size_t nlen); +char* cstrnstrn(const char* str, const char* search, intptr_t slen, intptr_t nlen); ``` ## Types @@ -145,8 +145,8 @@ char* cstrnstrn(const char* str, const char* search, size_t slen, size_t |:----------------|:-------------------------------------------|:---------------------| | `cstr` | `struct { ... }` | The string type | | `cstr_value` | `char` | String element type | -| `csview` | `struct { const char *str; size_t size; }` | String view type | -| `cstr_buf` | `struct { char *data; size_t size, cap; }` | String buffer type | +| `csview` | `struct { const char *str; intptr_t size; }` | String view type | +| `cstr_buf` | `struct { char *data; intptr_t size, cap; }` | String buffer type | ## Constants and macros @@ -162,7 +162,7 @@ char* cstrnstrn(const char* str, const char* search, size_t slen, size_t int main() { c_AUTO (cstr, s0, s1, full_path) { s0 = cstr_lit("Initialization without using strlen()."); - printf("%s\nLength: %" c_ZU "\n\n", cstr_str(&s0), cstr_size(&s0)); + printf("%s\nLength: %" c_ZI "\n\n", cstr_str(&s0), cstr_size(&s0)); s1 = cstr_lit("one-nine-three-seven-five."); printf("%s\n", cstr_str(&s1)); diff --git a/docs/csview_api.md b/docs/csview_api.md index 4085a708..8064e4fd 100644 --- a/docs/csview_api.md +++ b/docs/csview_api.md @@ -27,31 +27,31 @@ All csview definitions and prototypes are available by including a single header ```c csview c_SV(const char literal_only[]); // construct from literal, no strlen() -csview c_SV(const char* str, size_t n); // construct from str and length n +csview c_SV(const char* str, intptr_t n); // construct from str and length n csview csview_lit(const char literal_only[]); // alias for c_SV(lit) csview csview_from(const char* str); // construct from const char* -csview csview_from_n(const char* str, size_t n); // alias for c_SV(str, n) +csview csview_from_n(const char* str, intptr_t n); // alias for c_SV(str, n) -size_t csview_size(csview sv); +intptr_t csview_size(csview sv); bool csview_empty(csview sv); void csview_clear(csview* self); bool csview_equals(csview sv, csview sv2); -size_t csview_find(csview sv, const char* str); -size_t csview_find_sv(csview sv, csview find); +intptr_t csview_find(csview sv, const char* str); +intptr_t csview_find_sv(csview sv, csview find); bool csview_contains(csview sv, const char* str); bool csview_starts_with(csview sv, const char* str); bool csview_ends_with(csview sv, const char* str); -csview csview_substr_ex(csview sv, intptr_t pos, size_t n); // negative pos count from end +csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n); // negative pos count from end csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2); // negative p1, p2 count from end -csview csview_token(csview sv, const char* sep, size_t* start); // *start > sv.size after last token +csview csview_token(csview sv, const char* sep, intptr_t* start); // *start > sv.size after last token ``` #### UTF8 methods ```c -size_t csview_u8_size(csview sv); -csview csview_u8_substr(csview sv, size_t bytepos, size_t u8len); +intptr_t csview_u8_size(csview sv); +csview csview_u8_substr(csview sv, intptr_t bytepos, intptr_t u8len); bool csview_valid_utf8(csview sv); // requires linking with src/utf8code.c csview_iter csview_begin(const csview* self); @@ -60,14 +60,14 @@ void csview_next(csview_iter* it); // utf8 csview_iter csview_advance(csview_iter it, intptr_t n); // from utf8.h -size_t utf8_size(const char *s); -size_t utf8_size_n(const char *s, size_t nbytes); // number of UTF8 codepoints within n bytes -const char* utf8_at(const char *s, size_t index); // from UTF8 index to char* position -size_t utf8_pos(const char* s, size_t index); // from UTF8 index to byte index position +intptr_t utf8_size(const char *s); +intptr_t utf8_size_n(const char *s, intptr_t nbytes); // number of UTF8 codepoints within n bytes +const char* utf8_at(const char *s, intptr_t index); // from UTF8 index to char* position +intptr_t utf8_pos(const char* s, intptr_t index); // from UTF8 index to byte index position unsigned utf8_chr_size(const char* s); // UTF8 character size: 1-4 // implemented in src/utf8code.c: bool utf8_valid(const char* s); -bool utf8_valid_n(const char* s, size_t nbytes); +bool utf8_valid_n(const char* s, intptr_t nbytes); uint32_t utf8_decode(utf8_decode_t *d, uint8_t byte); // decode next byte to utf8, return state. unsigned utf8_encode(char *out, uint32_t codepoint); // encode unicode cp into out buffer uint32_t utf8_peek(const char* s); // codepoint value of character at s @@ -76,11 +76,11 @@ uint32_t utf8_peek_off(const char* s, int offset); // code #### Extended cstr methods ```c -csview cstr_substr(const cstr* self, size_t pos, size_t n); -csview cstr_substr_ex(const cstr* s, intptr_t pos, size_t n); // negative pos count from end -csview cstr_u8_substr(const cstr* self, size_t bytepos, size_t u8len); +csview cstr_substr(const cstr* self, intptr_t pos, intptr_t n); +csview cstr_substr_ex(const cstr* s, intptr_t pos, intptr_t n); // negative pos count from end +csview cstr_u8_substr(const cstr* self, intptr_t bytepos, intptr_t u8len); -csview cstr_slice(const cstr* self, size_t p1, size_t p2); +csview cstr_slice(const cstr* self, intptr_t p1, intptr_t p2); csview cstr_slice_ex(const cstr* s, intptr_t p, intptr_t q); // negative p or q count from end ``` #### Iterate tokens with *c_FORTOKEN*, *c_FORTOKEN_SV* @@ -103,7 +103,7 @@ uint64_t csview_hash(const csview* x); | Type name | Type definition | Used to represent... | |:----------------|:-------------------------------------------|:-------------------------| -| `csview` | `struct { const char *str; size_t size; }` | The string view type | +| `csview` | `struct { const char *str; intptr_t size; }` | The string view type | | `csview_value` | `char` | The string element type | | `csview_iter` | `struct { csview_value *ref; }` | UTF8 iterator | @@ -125,7 +125,7 @@ int main () // (quoting Alfred N. Whitehead) csview sv1 = cstr_substr(&str1, 3, 5); // "think" - size_t pos = cstr_find(&str1, "live"); // position of "live" in str1 + intptr_t pos = cstr_find(&str1, "live"); // position of "live" in str1 csview sv2 = cstr_substr(&str1, pos, 4); // get "live" csview sv3 = cstr_slice(&str1, -8, -1); // get "details" printf("%.*s %.*s %.*s\n", diff --git a/docs/cvec_api.md b/docs/cvec_api.md index 08c404af..d67e80fd 100644 --- a/docs/cvec_api.md +++ b/docs/cvec_api.md @@ -31,26 +31,26 @@ See the c++ class [std::vector](https://en.cppreference.com/w/cpp/container/vect ```c cvec_X cvec_X_init(void); -cvec_X cvec_X_with_size(size_t size, i_val null); -cvec_X cvec_X_with_capacity(size_t size); +cvec_X cvec_X_with_size(intptr_t size, i_val null); +cvec_X cvec_X_with_capacity(intptr_t size); cvec_X cvec_X_clone(cvec_X vec); void cvec_X_clear(cvec_X* self); void cvec_X_copy(cvec_X* self, const cvec_X* other); cvec_X_iter cvec_X_copy_range(cvec_X* self, i_val* pos, const i_val* p1, const i_val* p2); -bool cvec_X_reserve(cvec_X* self, size_t cap); -bool cvec_X_resize(cvec_X* self, size_t size, i_val null); -cvec_X_iter cvec_X_insert_uninit(cvec_X* self, i_val* pos, size_t n); // return pos iter +bool cvec_X_reserve(cvec_X* self, intptr_t cap); +bool cvec_X_resize(cvec_X* self, intptr_t size, i_val null); +cvec_X_iter cvec_X_insert_uninit(cvec_X* self, i_val* pos, intptr_t n); // return pos iter void cvec_X_shrink_to_fit(cvec_X* self); void cvec_X_drop(cvec_X* self); // destructor bool cvec_X_empty(const cvec_X* self); -size_t cvec_X_size(const cvec_X* self); -size_t cvec_X_capacity(const cvec_X* self); +intptr_t cvec_X_size(const cvec_X* self); +intptr_t cvec_X_capacity(const cvec_X* self); -const cvec_X_value* cvec_X_at(const cvec_X* self, size_t idx); +const cvec_X_value* cvec_X_at(const cvec_X* self, intptr_t idx); const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw); // return NULL if not found -cvec_X_value* cvec_X_at_mut(cvec_X* self, size_t idx); +cvec_X_value* cvec_X_at_mut(cvec_X* self, intptr_t idx); cvec_X_value* cvec_X_get_mut(cvec_X* self, i_valraw raw); // find mutable value, return value ptr cvec_X_iter cvec_X_find(const cvec_X* self, i_valraw raw); cvec_X_iter cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw); // return cvec_X_end() if not found @@ -71,18 +71,18 @@ cvec_X_value* cvec_X_emplace_back(cvec_X* self, i_valraw raw); void cvec_X_pop(cvec_X* self); void cvec_X_pop_back(cvec_X* self); // alias for pop -cvec_X_iter cvec_X_insert(cvec_X* self, size_t idx, i_val value); // move value -cvec_X_iter cvec_X_insert_n(cvec_X* self, size_t idx, const i_val[] arr, size_t n); // move n values +cvec_X_iter cvec_X_insert(cvec_X* self, intptr_t idx, i_val value); // move value +cvec_X_iter cvec_X_insert_n(cvec_X* self, intptr_t idx, const i_val[] arr, intptr_t n); // move n values cvec_X_iter cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value); // move value cvec_X_iter cvec_X_insert_range(cvec_X* self, i_val* pos, const i_val* p1, const i_val* p2); -cvec_X_iter cvec_X_emplace_n(cvec_X* self, size_t idx, const i_valraw[] arr, size_t n); // clone values +cvec_X_iter cvec_X_emplace_n(cvec_X* self, intptr_t idx, const i_valraw[] arr, intptr_t n); // clone values cvec_X_iter cvec_X_emplace_at(cvec_X* self, cvec_X_iter it, i_valraw raw); cvec_X_iter cvec_X_emplace_range(cvec_X* self, i_val* pos, const i_valraw* p1, const i_valraw* p2); -cvec_X_iter cvec_X_erase_n(cvec_X* self, size_t idx, size_t n); +cvec_X_iter cvec_X_erase_n(cvec_X* self, intptr_t idx, intptr_t n); cvec_X_iter cvec_X_erase_at(cvec_X* self, cvec_X_iter it); cvec_X_iter cvec_X_erase_range(cvec_X* self, cvec_X_iter it1, cvec_X_iter it2); cvec_X_iter cvec_X_erase_range_p(cvec_X* self, i_val* p1, i_val* p2); @@ -94,7 +94,7 @@ void cvec_X_sort_range(cvec_X_iter i1, cvec_X_iter i2, cvec_X_iter cvec_X_begin(const cvec_X* self); cvec_X_iter cvec_X_end(const cvec_X* self); void cvec_X_next(cvec_X_iter* iter); -cvec_X_iter cvec_X_advance(cvec_X_iter it, intptr_t n); +cvec_X_iter cvec_X_advance(cvec_X_iter it, size_t n); cvec_X_raw cvec_X_value_toraw(cvec_X_value* pval); cvec_X_value cvec_X_value_clone(cvec_X_value val); diff --git a/include/stc/algo/csort.h b/include/stc/algo/csort.h index 9c9bcd5b..c8c41257 100644 --- a/include/stc/algo/csort.h +++ b/include/stc/algo/csort.h @@ -99,7 +99,7 @@ static inline void c_PASTE(cqsort_, i_tag)(i_val arr[], intptr_t lo, intptr_t hi } } -static inline void c_PASTE(csort_, i_tag)(i_val arr[], size_t n) - { c_PASTE(cqsort_, i_tag)(arr, 0, (intptr_t)n - 1); } +static inline void c_PASTE(csort_, i_tag)(i_val arr[], intptr_t n) + { c_PASTE(cqsort_, i_tag)(arr, 0, n - 1); } #include diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h index f0d157e3..30184407 100644 --- a/include/stc/ccommon.h +++ b/include/stc/ccommon.h @@ -32,13 +32,10 @@ #include "priv/altnames.h" #define c_NPOS INTPTR_MAX -#if SIZE_MAX == UINT32_MAX - #define c_ZU PRIu32 -#elif SIZE_MAX == UINT64_MAX - #define c_ZU PRIu64 -#endif +#define c_ZI PRIiPTR +#define c_ZU PRIuPTR #if defined STC_NDEBUG || defined NDEBUG - #define c_ASSERT(expr) (void)(expr) + #define c_ASSERT(expr) (void)(0) #else #define c_ASSERT(expr) assert(expr) #endif diff --git a/include/stc/cdeq.h b/include/stc/cdeq.h index 44c5e8d5..56c0e867 100644 --- a/include/stc/cdeq.h +++ b/include/stc/cdeq.h @@ -110,7 +110,7 @@ STC_INLINE _cx_iter _cx_memb(_end)(const _cx_self* self) STC_INLINE void _cx_memb(_next)(_cx_iter* it) { if (++it->ref == it->end) it->ref = NULL; } -STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, intptr_t n) +STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, size_t n) { if ((it.ref += n) >= it.end) it.ref = NULL; return it; } #if !defined _i_queue diff --git a/include/stc/cmap.h b/include/stc/cmap.h index f9cd6986..f90d9a4a 100644 --- a/include/stc/cmap.h +++ b/include/stc/cmap.h @@ -53,7 +53,7 @@ int main(void) { #include "forward.h" #include #include -typedef struct { size_t idx; uint8_t hx; } chash_bucket_t; +typedef struct { intptr_t idx; uint8_t hx; } chash_bucket_t; #endif // CMAP_H_INCLUDED #ifndef _i_prefix @@ -96,13 +96,13 @@ typedef _i_SET_ONLY( i_keyraw ) i_valraw second; } ) _cx_raw; -STC_API _cx_self _cx_memb(_with_capacity)(size_t cap); +STC_API _cx_self _cx_memb(_with_capacity)(intptr_t cap); #if !defined i_no_clone STC_API _cx_self _cx_memb(_clone)(_cx_self map); #endif 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, size_t capacity); +STC_API bool _cx_memb(_reserve)(_cx_self* self, intptr_t capacity); STC_API chash_bucket_t _cx_memb(_bucket_)(const _cx_self* self, const _cx_rawkey* rkeyptr); STC_API _cx_result _cx_memb(_insert_entry_)(_cx_self* self, _cx_rawkey rkey); STC_API void _cx_memb(_erase_entry)(_cx_self* self, _cx_value* val); @@ -111,10 +111,10 @@ STC_INLINE _cx_self _cx_memb(_init)(void) { return c_LITERAL(_cx_self){0}; } STC_INLINE void _cx_memb(_shrink_to_fit)(_cx_self* self) { _cx_memb(_reserve)(self, self->size); } STC_INLINE float _cx_memb(_max_load_factor)(const _cx_self* self) { return (float)(i_max_load_factor); } STC_INLINE bool _cx_memb(_empty)(const _cx_self* map) { return !map->size; } -STC_INLINE size_t _cx_memb(_size)(const _cx_self* map) { return map->size; } -STC_INLINE size_t _cx_memb(_bucket_count)(_cx_self* map) { return map->bucket_count; } -STC_INLINE size_t _cx_memb(_capacity)(const _cx_self* map) - { return (size_t)((float)map->bucket_count * (i_max_load_factor)); } +STC_INLINE intptr_t _cx_memb(_size)(const _cx_self* map) { return map->size; } +STC_INLINE intptr_t _cx_memb(_bucket_count)(_cx_self* map) { return map->bucket_count; } +STC_INLINE intptr_t _cx_memb(_capacity)(const _cx_self* map) + { return (intptr_t)((float)map->bucket_count * (i_max_load_factor)); } STC_INLINE bool _cx_memb(_contains)(const _cx_self* self, _cx_rawkey rkey) { return self->size && self->_hashx[_cx_memb(_bucket_)(self, &rkey).idx]; } @@ -195,7 +195,7 @@ _cx_memb(_push)(_cx_self* self, _cx_value _val) { return _res; } -STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, size_t n) { +STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, intptr_t n) { while (n--) #if defined _i_isset && defined i_no_emplace _cx_memb(_insert)(self, *raw++); @@ -208,7 +208,7 @@ STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, size_t n) { #endif } -STC_INLINE _cx_self _cx_memb(_from_n)(const _cx_raw* raw, size_t n) +STC_INLINE _cx_self _cx_memb(_from_n)(const _cx_raw* raw, intptr_t n) { _cx_self cx = {0}; _cx_memb(_put_n)(&cx, raw, n); return cx; } STC_INLINE _cx_iter _cx_memb(_begin)(const _cx_self* self) { @@ -238,7 +238,7 @@ _cx_memb(_advance)(_cx_iter it, size_t n) { STC_INLINE _cx_iter _cx_memb(_find)(const _cx_self* self, _cx_rawkey rkey) { - size_t idx; + intptr_t idx; if (self->size && self->_hashx[idx = _cx_memb(_bucket_)(self, &rkey).idx]) return c_LITERAL(_cx_iter){self->table + idx, self->table + self->bucket_count, @@ -248,7 +248,7 @@ _cx_memb(_find)(const _cx_self* self, _cx_rawkey rkey) { STC_INLINE const _cx_value* _cx_memb(_get)(const _cx_self* self, _cx_rawkey rkey) { - size_t idx; + intptr_t idx; if (self->size && self->_hashx[idx = _cx_memb(_bucket_)(self, &rkey).idx]) return self->table + idx; return NULL; @@ -258,12 +258,12 @@ STC_INLINE _cx_value* _cx_memb(_get_mut)(_cx_self* self, _cx_rawkey rkey) { return (_cx_value*)_cx_memb(_get)(self, rkey); } -STC_INLINE size_t +STC_INLINE intptr_t _cx_memb(_erase)(_cx_self* self, _cx_rawkey rkey) { if (self->size == 0) return 0; chash_bucket_t b = _cx_memb(_bucket_)(self, &rkey); - return self->_hashx[b.idx] ? _cx_memb(_erase_entry)(self, self->table + b.idx), 1U : 0U; + return self->_hashx[b.idx] ? _cx_memb(_erase_entry)(self, self->table + b.idx), 1 : 0; } STC_INLINE _cx_iter @@ -278,11 +278,11 @@ _cx_memb(_erase_at)(_cx_self* self, _cx_iter it) { #if defined(i_implement) #ifndef CMAP_H_INCLUDED -STC_INLINE size_t fastrange_1(uint64_t x, uint64_t n) - { return (size_t)((uint32_t)x*n >> 32); } // n < 2^32 +STC_INLINE intptr_t fastrange_1(uint64_t x, uint64_t n) + { return (intptr_t)((uint32_t)x*n >> 32); } // n < 2^32 -STC_INLINE size_t fastrange_2(uint64_t x, uint64_t n) - { return x & (n - 1); } // n power of 2. +STC_INLINE intptr_t fastrange_2(uint64_t x, uint64_t n) + { return (intptr_t)(x & (n - 1)); } // n power of 2. STC_INLINE uint64_t next_power_of_2(uint64_t n) { n--; @@ -294,7 +294,7 @@ STC_INLINE uint64_t next_power_of_2(uint64_t n) { #endif // CMAP_H_INCLUDED STC_DEF _cx_self -_cx_memb(_with_capacity)(const size_t cap) { +_cx_memb(_with_capacity)(const intptr_t cap) { _cx_self h = {0}; _cx_memb(_reserve)(&h, cap); return h; @@ -319,7 +319,7 @@ STC_DEF void _cx_memb(_drop)(_cx_self* self) { STC_DEF void _cx_memb(_clear)(_cx_self* self) { _cx_memb(_wipe_)(self); self->size = 0; - memset(self->_hashx, 0, self->bucket_count); + c_memset(self->_hashx, 0, self->bucket_count); } #ifndef _i_isset @@ -355,7 +355,7 @@ STC_DEF chash_bucket_t _cx_memb(_bucket_)(const _cx_self* self, const _cx_rawkey* rkeyptr) { const uint64_t _hash = i_hash_functor(self, rkeyptr); i_size _cap = self->bucket_count; - chash_bucket_t b = {c_PASTE(fastrange_,_i_expandby)(_hash, _cap), (uint8_t)(_hash | 0x80)}; + chash_bucket_t b = {c_PASTE(fastrange_,_i_expandby)(_hash, (uint64_t)_cap), (uint8_t)(_hash | 0x80)}; const uint8_t* _hx = self->_hashx; while (_hx[b.idx]) { if (_hx[b.idx] == b.hx) { @@ -390,7 +390,7 @@ STC_DEF _cx_self _cx_memb(_clone)(_cx_self m) { if (m.table) { _cx_value *t = c_ALLOC_N(_cx_value, m.bucket_count), *dst = t, *m_end = m.table + m.bucket_count; - uint8_t *h = (uint8_t *)memcpy(c_malloc(m.bucket_count + 1), m._hashx, m.bucket_count + 1); + uint8_t *h = (uint8_t *)c_memcpy(c_malloc(m.bucket_count + 1), m._hashx, m.bucket_count + 1); if (!(t && h)) { c_free(t), c_free(h), t = 0, h = 0, m.bucket_count = 0; } else @@ -404,7 +404,7 @@ _cx_memb(_clone)(_cx_self m) { #endif STC_DEF bool -_cx_memb(_reserve)(_cx_self* self, const size_t _newcap) { +_cx_memb(_reserve)(_cx_self* self, const intptr_t _newcap) { const i_size _oldbuckets = self->bucket_count; if (_newcap != self->size && _newcap <= _oldbuckets) return true; @@ -424,7 +424,7 @@ _cx_memb(_reserve)(_cx_self* self, const size_t _newcap) { m._hashx[_nbuckets] = 0xff; const _cx_value* e = self->table; const uint8_t* h = self->_hashx; - for (size_t i = 0; i < _oldbuckets; ++i, ++e) if (*h++) { + for (i_size i = 0; i < _oldbuckets; ++i, ++e) if (*h++) { _cx_rawkey r = i_keyto(_i_keyref(e)); chash_bucket_t b = _cx_memb(_bucket_)(&m, &r); m.table[b.idx] = *e; @@ -450,7 +450,7 @@ _cx_memb(_erase_entry)(_cx_self* self, _cx_value* _val) { if (! _hashx[j]) break; const _cx_rawkey _raw = i_keyto(_i_keyref(_slot + j)); - k = (i_size)c_PASTE(fastrange_,_i_expandby)(i_hash_functor(self, (&_raw)), _cap); + k = (i_size)c_PASTE(fastrange_,_i_expandby)(i_hash_functor(self, (&_raw)), (uint64_t)_cap); if ((j < i) ^ (k <= i) ^ (k > j)) /* is k outside (i, j]? */ _slot[i] = _slot[j], _hashx[i] = _hashx[j], i = j; } diff --git a/include/stc/cpque.h b/include/stc/cpque.h index 21130864..55df70ef 100644 --- a/include/stc/cpque.h +++ b/include/stc/cpque.h @@ -55,7 +55,7 @@ STC_INLINE _cx_self _cx_memb(_from_n)(const _cx_raw* raw, intptr_t n) STC_INLINE bool _cx_memb(_reserve)(_cx_self* self, const intptr_t cap) { if (cap != self->_len && cap <= self->_cap) return true; - _cx_value *d = (_cx_value *)c_realloc(self->data, cap*sizeof *d); + _cx_value *d = (_cx_value *)c_realloc(self->data, cap*c_sizeof *d); return d ? (self->data = d, self->_cap = cap, true) : false; } diff --git a/include/stc/crandom.h b/include/stc/crandom.h index 5641d788..32e541ff 100644 --- a/include/stc/crandom.h +++ b/include/stc/crandom.h @@ -46,7 +46,7 @@ int main() { typedef struct stc64 { uint64_t state[5]; } stc64_t; typedef struct stc64_uniform { int64_t lower; uint64_t range, threshold; } stc64_uniform_t; typedef struct stc64_uniformf { double lower, range; } stc64_uniformf_t; -typedef struct stc64_normalf { double mean, stddev, next; unsigned has_next; } stc64_normalf_t; +typedef struct stc64_normalf { double mean, stddev, next; int has_next; } stc64_normalf_t; /* PRNG stc64. * Very fast PRNG suited for parallel usage with Weyl-sequence parameter. diff --git a/include/stc/cregex.h b/include/stc/cregex.h index c41fbb67..564fe157 100644 --- a/include/stc/cregex.h +++ b/include/stc/cregex.h @@ -105,7 +105,7 @@ STC_INLINE cregex cregex_from_2(const char* pattern, int cflags) { } /* number of capture groups in a regex pattern including full the match capture, 0 if regex is invalid */ -unsigned cregex_captures(const cregex* re); +int cregex_captures(const cregex* re); /* return CREG_OK, CREG_NOMATCH or CREG_MATCHERROR. */ #define cregex_find(...) c_MACRO_OVERLOAD(cregex_find, __VA_ARGS__) @@ -132,17 +132,17 @@ STC_INLINE bool cregex_is_match(const cregex* re, const char* input) /* replace csview input with replace using regular expression pattern */ #define cregex_replace_sv(...) c_MACRO_OVERLOAD(cregex_replace_sv, __VA_ARGS__) #define cregex_replace_sv_3(pattern, input, replace) \ - cregex_replace_sv_4(pattern, input, replace, ~0U) + cregex_replace_sv_4(pattern, input, replace, INT32_MAX) #define cregex_replace_sv_4(pattern, input, replace, count) \ cregex_replace_sv_6(pattern, input, replace, count, NULL, CREG_DEFAULT) -cstr cregex_replace_sv_6(const cregex* re, csview input, const char* replace, unsigned count, +cstr cregex_replace_sv_6(const cregex* re, csview input, const char* replace, int count, bool (*mfun)(int i, csview match, cstr* mstr), int rflags); /* replace input with replace using regular expression */ #define cregex_replace(...) c_MACRO_OVERLOAD(cregex_replace, __VA_ARGS__) -#define cregex_replace_3(re, input, replace) cregex_replace_4(re, input, replace, ~0U) +#define cregex_replace_3(re, input, replace) cregex_replace_4(re, input, replace, INT32_MAX) -STC_INLINE cstr cregex_replace_4(const cregex* re, const char* input, const char* replace, unsigned count) { +STC_INLINE cstr cregex_replace_4(const cregex* re, const char* input, const char* replace, int count) { csview sv = {input, c_strlen(input)}; return cregex_replace_sv_4(re, sv, replace, count); } @@ -150,10 +150,10 @@ STC_INLINE cstr cregex_replace_4(const cregex* re, const char* input, const char /* replace + compile RE pattern, and extra arguments */ #define cregex_replace_pattern(...) c_MACRO_OVERLOAD(cregex_replace_pattern, __VA_ARGS__) #define cregex_replace_pattern_3(pattern, input, replace) \ - cregex_replace_pattern_4(pattern, input, replace, ~0U) + cregex_replace_pattern_4(pattern, input, replace, INT32_MAX) #define cregex_replace_pattern_4(pattern, input, replace, count) \ cregex_replace_pattern_6(pattern, input, replace, count, NULL, CREG_DEFAULT) -cstr cregex_replace_pattern_6(const char* pattern, const char* input, const char* replace, unsigned count, +cstr cregex_replace_pattern_6(const char* pattern, const char* input, const char* replace, int count, bool (*mfun)(int i, csview match, cstr* mstr), int crflags); /* destroy regex */ diff --git a/include/stc/csmap.h b/include/stc/csmap.h index b92d25d8..de948618 100644 --- a/include/stc/csmap.h +++ b/include/stc/csmap.h @@ -107,7 +107,7 @@ STC_API _cx_self _cx_memb(_init)(void); STC_API _cx_result _cx_memb(_insert)(_cx_self* self, i_key key _i_MAP_ONLY(, i_val mapped)); STC_API _cx_result _cx_memb(_push)(_cx_self* self, _cx_value _val); STC_API void _cx_memb(_drop)(_cx_self* self); -STC_API bool _cx_memb(_reserve)(_cx_self* self, size_t cap); +STC_API bool _cx_memb(_reserve)(_cx_self* self, intptr_t cap); STC_API _cx_value* _cx_memb(_find_it)(const _cx_self* self, _cx_rawkey rkey, _cx_iter* out); STC_API _cx_iter _cx_memb(_lower_bound)(const _cx_self* self, _cx_rawkey rkey); STC_API _cx_value* _cx_memb(_front)(const _cx_self* self); @@ -118,8 +118,8 @@ STC_API _cx_iter _cx_memb(_erase_range)(_cx_self* self, _cx_iter it1, _cx STC_API void _cx_memb(_next)(_cx_iter* it); STC_INLINE bool _cx_memb(_empty)(const _cx_self* cx) { return cx->size == 0; } -STC_INLINE size_t _cx_memb(_size)(const _cx_self* cx) { return cx->size; } -STC_INLINE size_t _cx_memb(_capacity)(const _cx_self* cx) { return cx->cap; } +STC_INLINE intptr_t _cx_memb(_size)(const _cx_self* cx) { return cx->size; } +STC_INLINE intptr_t _cx_memb(_capacity)(const _cx_self* cx) { return cx->cap; } STC_INLINE _cx_iter _cx_memb(_find)(const _cx_self* self, _cx_rawkey rkey) { _cx_iter it; _cx_memb(_find_it)(self, rkey, &it); return it; } STC_INLINE bool _cx_memb(_contains)(const _cx_self* self, _cx_rawkey rkey) @@ -130,7 +130,7 @@ STC_INLINE _cx_value* _cx_memb(_get_mut)(_cx_self* self, _cx_rawkey rkey) { _cx_iter it; return _cx_memb(_find_it)(self, rkey, &it); } STC_INLINE _cx_self -_cx_memb(_with_capacity)(const size_t cap) { +_cx_memb(_with_capacity)(const intptr_t cap) { _cx_self tree = _cx_memb(_init)(); _cx_memb(_reserve)(&tree, cap); return tree; @@ -225,10 +225,10 @@ _cx_memb(_init)(void) { } STC_DEF bool -_cx_memb(_reserve)(_cx_self* self, const size_t cap) { +_cx_memb(_reserve)(_cx_self* self, const intptr_t cap) { if (cap <= self->cap) return false; - _cx_node* nodes = (_cx_node*)c_realloc(self->nodes, (cap + 1)*sizeof(_cx_node)); + _cx_node* nodes = (_cx_node*)c_realloc(self->nodes, (cap + 1)*c_sizeof(_cx_node)); if (!nodes) return false; nodes[0] = c_LITERAL(_cx_node){{0, 0}, 0}; @@ -294,7 +294,7 @@ _cx_memb(_push)(_cx_self* self, _cx_value _val) { return _res; } -STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, size_t n) { +STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, intptr_t n) { while (n--) #if defined _i_isset && defined i_no_emplace _cx_memb(_insert)(self, *raw++); @@ -307,7 +307,7 @@ STC_INLINE void _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, size_t n) { #endif } -STC_INLINE _cx_self _cx_memb(_from_n)(const _cx_raw* raw, size_t n) +STC_INLINE _cx_self _cx_memb(_from_n)(const _cx_raw* raw, intptr_t n) { _cx_self cx = {0}; _cx_memb(_put_n)(&cx, raw, n); return cx; } #ifndef _i_isset diff --git a/include/stc/cstack.h b/include/stc/cstack.h index 97d5256c..dd4686e9 100644 --- a/include/stc/cstack.h +++ b/include/stc/cstack.h @@ -185,7 +185,7 @@ STC_INLINE _cx_iter _cx_memb(_end)(const _cx_self* self) STC_INLINE void _cx_memb(_next)(_cx_iter* it) { if (++it->ref == it->end) it->ref = NULL; } -STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, intptr_t n) +STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, size_t n) { if ((it.ref += n) >= it.end) it.ref = NULL ; return it; } #include "priv/template.h" diff --git a/include/stc/cstr.h b/include/stc/cstr.h index f965487c..2966db81 100644 --- a/include/stc/cstr.h +++ b/include/stc/cstr.h @@ -374,7 +374,7 @@ STC_INLINE char* cstr_append_s(cstr* self, cstr s) { } #define cstr_replace(...) c_MACRO_OVERLOAD(cstr_replace, __VA_ARGS__) -#define cstr_replace_3(self, search, repl) cstr_replace_4(self, search, repl, ~0U) +#define cstr_replace_3(self, search, repl) cstr_replace_4(self, search, repl, INT32_MAX) STC_INLINE void cstr_replace_4(cstr* self, const char* search, const char* repl, int32_t count) { cstr_take(self, cstr_replace_sv(cstr_sv(self), c_SV(search, c_strlen(search)), c_SV(repl, c_strlen(repl)), count)); diff --git a/include/stc/cvec.h b/include/stc/cvec.h index 11d145e6..06664b4d 100644 --- a/include/stc/cvec.h +++ b/include/stc/cvec.h @@ -208,7 +208,7 @@ STC_INLINE _cx_iter _cx_memb(_end)(const _cx_self* self) STC_INLINE void _cx_memb(_next)(_cx_iter* it) { if (++it->ref == it->end) it->ref = NULL; } -STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, intptr_t n) +STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, size_t n) { if ((it.ref += n) >= it.end) it.ref = NULL; return it; } STC_INLINE intptr_t _cx_memb(_index)(const _cx_self* self, _cx_iter it) diff --git a/include/stc/forward.h b/include/stc/forward.h index dfb43a9f..594c76fa 100644 --- a/include/stc/forward.h +++ b/include/stc/forward.h @@ -26,17 +26,15 @@ #include #define forward_carc(CX, VAL) _c_carc_types(CX, VAL) -#define forward_carr2(CX, VAL) _c_carr2_types(CX, VAL) -#define forward_carr3(CX, VAL) _c_carr3_types(CX, VAL) #define forward_cbox(CX, VAL) _c_cbox_types(CX, VAL) #define forward_cdeq(CX, VAL) _c_cdeq_types(CX, VAL) #define forward_clist(CX, VAL) _c_clist_types(CX, VAL) -#define forward_cmap(CX, KEY, VAL) _c_chash_types(CX, KEY, VAL, uint32_t, c_true, c_false) -#define forward_cmap_huge(CX, KEY, VAL) _c_chash_types(CX, KEY, VAL, size_t, c_true, c_false) -#define forward_cset(CX, KEY) _c_chash_types(CX, cset, KEY, KEY, uint32_t, c_false, c_true) -#define forward_cset_huge(CX, KEY) _c_chash_types(CX, cset, KEY, KEY, size_t, c_false, c_true) -#define forward_csmap(CX, KEY, VAL) _c_aatree_types(CX, KEY, VAL, uint32_t, c_true, c_false) -#define forward_csset(CX, KEY) _c_aatree_types(CX, KEY, KEY, uint32_t, c_false, c_true) +#define forward_cmap(CX, KEY, VAL) _c_chash_types(CX, KEY, VAL, int32_t, c_true, c_false) +#define forward_cmap_huge(CX, KEY, VAL) _c_chash_types(CX, KEY, VAL, intptr_t, c_true, c_false) +#define forward_cset(CX, KEY) _c_chash_types(CX, cset, KEY, KEY, int32_t, c_false, c_true) +#define forward_cset_huge(CX, KEY) _c_chash_types(CX, cset, KEY, KEY, intptr_t, c_false, c_true) +#define forward_csmap(CX, KEY, VAL) _c_aatree_types(CX, KEY, VAL, int32_t, c_true, c_false) +#define forward_csset(CX, KEY) _c_aatree_types(CX, KEY, KEY, int32_t, c_false, c_true) #define forward_cstack(CX, VAL) _c_cstack_types(CX, VAL) #define forward_cpque(CX, VAL) _c_cpque_types(CX, VAL) #define forward_cqueue(CX, VAL) _c_cdeq_types(CX, VAL) diff --git a/include/stc/priv/template.h b/include/stc/priv/template.h index 9634fe2c..4aa54bcc 100644 --- a/include/stc/priv/template.h +++ b/include/stc/priv/template.h @@ -47,7 +47,7 @@ #ifdef i_size #define _i_expandby 2 #else - #define i_size uint32_t + #define i_size int32_t #define _i_expandby 1 #endif diff --git a/include/stc/utf8.h b/include/stc/utf8.h index ce50af87..da738fc6 100644 --- a/include/stc/utf8.h +++ b/include/stc/utf8.h @@ -25,7 +25,7 @@ extern bool utf8_iscased(uint32_t c); extern bool utf8_isword(uint32_t c); extern bool utf8_valid_n(const char* s, intptr_t nbytes); extern int utf8_icmp_sv(csview s1, csview s2); -extern unsigned utf8_encode(char *out, uint32_t c); +extern int utf8_encode(char *out, uint32_t c); extern uint32_t utf8_peek_off(const char *s, int offset); STC_INLINE bool utf8_isupper(uint32_t c) @@ -45,7 +45,7 @@ STC_INLINE bool utf8_isblank(uint32_t c) { } STC_INLINE bool utf8_isspace(uint32_t c) { - if (c < 128) return isspace(c) != 0; + if (c < 128) return isspace((int)c) != 0; return ((c == 8232) | (c == 8233)) || utf8_isgroup(U8G_Zs, c); } diff --git a/misc/archived/cstr.h b/misc/archived/cstr.h index 9111fe6d..17baf52c 100644 --- a/misc/archived/cstr.h +++ b/misc/archived/cstr.h @@ -56,7 +56,7 @@ STC_API void cstr_resize(cstr* self, size_t len, char fill); STC_API cstr* cstr_assign_n(cstr* self, const char* str, size_t n); STC_API int cstr_printf(cstr* self, const char* fmt, ...); STC_API cstr* cstr_append_n(cstr* self, const char* str, size_t n); -STC_API cstr cstr_replace_sv(csview str, csview find, csview repl, unsigned count); +STC_API cstr cstr_replace_sv(csview str, csview find, csview repl, int count); STC_DEF void cstr_replace_at_sv(cstr* self, const size_t pos, size_t len, csview repl); STC_API void cstr_erase(cstr* self, size_t pos, size_t n); STC_API size_t cstr_find(const cstr* self, const char* needle); @@ -182,7 +182,7 @@ STC_INLINE uint64_t cstr_hash(const cstr *self) { return cfasthash(self->str, _cstr_p(self)->size); } -STC_INLINE void cstr_replace_ex(cstr* self, const char* find, const char* repl, unsigned count) { +STC_INLINE void cstr_replace_ex(cstr* self, const char* find, const char* repl, int count) { cstr_take(self, cstr_replace_sv(cstr_sv(self), c_SV(find, strlen(find)), c_SV(repl, strlen(repl)), count)); } diff --git a/misc/examples/astar.c b/misc/examples/astar.c index 828de8ce..ddc9de3a 100644 --- a/misc/examples/astar.c +++ b/misc/examples/astar.c @@ -37,7 +37,7 @@ point_equal(const point* a, const point* b) point point_from(const cstr* maze, const char* c, int width) { - int index = cstr_find(maze, c); + int index = (int)cstr_find(maze, c); return point_init(index % width, index / width, width); } @@ -156,7 +156,7 @@ main(void) "# # # # # # #\n" "#########################################################################\n"), cstr_drop(&maze)) { - int width = cstr_find(&maze, "\n") + 1; + int width = (int)cstr_find(&maze, "\n") + 1; c_WITH (cdeq_point path = astar(&maze, width), cdeq_point_drop(&path)) { c_FOREACH (it, cdeq_point, path) diff --git a/misc/examples/birthday.c b/misc/examples/birthday.c index be7f0457..fb887cd7 100644 --- a/misc/examples/birthday.c +++ b/misc/examples/birthday.c @@ -50,19 +50,19 @@ void test_distribution(void) uint64_t sum = 0; c_FOREACH (i, cmap_x, map) sum += i.ref->second; - sum /= map.size; + sum /= (uint64_t)map.size; c_FOREACH (i, cmap_x, map) { printf("%4" PRIu32 ": %" PRIu64 " - %" PRIu64 ": %11.8f\n", i.ref->first, i.ref->second, sum, - (1 - (double)i.ref->second / sum)); + (1.0 - (double)i.ref->second / (double)sum)); } } } int main() { - seed = time(NULL); + seed = (uint64_t)time(NULL); test_distribution(); test_repeats(); } diff --git a/misc/examples/bits.c b/misc/examples/bits.c index c50eac6e..03b74881 100644 --- a/misc/examples/bits.c +++ b/misc/examples/bits.c @@ -4,18 +4,18 @@ int main() { c_WITH (cbits set = cbits_with_size(23, true), cbits_drop(&set)) { - printf("count %" c_ZU ", %" c_ZU "\n", cbits_count(&set), cbits_size(&set)); + printf("count %" c_ZI ", %" c_ZI "\n", cbits_count(&set), cbits_size(&set)); cbits s1 = cbits_from("1110100110111"); char buf[256]; cbits_to_str(&s1, buf, 0, 255); - printf("buf: %s: %" c_ZU "\n", buf, cbits_count(&s1)); + printf("buf: %s: %" c_ZI "\n", buf, cbits_count(&s1)); cbits_drop(&s1); cbits_reset(&set, 9); cbits_resize(&set, 43, false); printf(" str: %s\n", cbits_to_str(&set, buf, 0, 255)); - printf("%4" c_ZU ": ", cbits_size(&set)); + printf("%4" c_ZI ": ", cbits_size(&set)); c_FORRANGE (i, cbits_size(&set)) printf("%d", cbits_test(&set, i)); puts(""); @@ -25,12 +25,12 @@ int main() cbits_resize(&set, 93, false); cbits_resize(&set, 102, true); cbits_set_value(&set, 99, false); - printf("%4" c_ZU ": ", cbits_size(&set)); + printf("%4" c_ZI ": ", cbits_size(&set)); c_FORRANGE (i, cbits_size(&set)) printf("%d", cbits_test(&set, i)); puts("\nIterate:"); - printf("%4" c_ZU ": ", cbits_size(&set)); + printf("%4" c_ZI ": ", cbits_size(&set)); c_FORRANGE (i, cbits_size(&set)) printf("%d", cbits_test(&set, i)); puts(""); @@ -52,7 +52,7 @@ int main() puts(""); cbits_set_all(&set, false); - printf("%4" c_ZU ": ", cbits_size(&set)); + printf("%4" c_ZI ": ", cbits_size(&set)); c_FORRANGE (i, cbits_size(&set)) printf("%d", cbits_test(&set, i)); puts(""); diff --git a/misc/examples/bits2.c b/misc/examples/bits2.c index 502e7268..9b1d1af7 100644 --- a/misc/examples/bits2.c +++ b/misc/examples/bits2.c @@ -9,10 +9,10 @@ int main() { Bits s1 = Bits_from("1110100110111"); - printf("size %" c_ZU "\n", Bits_size(&s1)); + printf("size %" c_ZI "\n", Bits_size(&s1)); char buf[256]; Bits_to_str(&s1, buf, 0, 256); - printf("buf: %s: count=%" c_ZU "\n", buf, Bits_count(&s1)); + printf("buf: %s: count=%" c_ZI "\n", buf, Bits_count(&s1)); Bits_reset(&s1, 8); printf(" s1: %s\n", Bits_to_str(&s1, buf, 0, 256)); diff --git a/misc/examples/books.c b/misc/examples/books.c index 96c7ff6e..4695941a 100644 --- a/misc/examples/books.c +++ b/misc/examples/books.c @@ -32,7 +32,7 @@ int main() // When collections store owned values (String), they can still be // queried using references (&str). if (cmap_str_contains(&book_reviews, "Les Misérables")) { - printf("We've got %" c_ZU " reviews, but Les Misérables ain't one.", + printf("We've got %" c_ZI " reviews, but Les Misérables ain't one.", cmap_str_size(&book_reviews)); } diff --git a/misc/examples/complex.c b/misc/examples/complex.c index 6fed1d4d..5c212554 100644 --- a/misc/examples/complex.c +++ b/misc/examples/complex.c @@ -37,7 +37,7 @@ int main() // Put in some data in the structures stack.data[3] = 3.1415927f; - printf("stack size: %" c_ZU "\n", FloatStack_size(&stack)); + printf("stack size: %" c_ZI "\n", FloatStack_size(&stack)); StackList list = StackList_init(); StackList_push_back(&list, stack); diff --git a/misc/examples/csmap_erase.c b/misc/examples/csmap_erase.c index bef00a17..a41a1ad1 100644 --- a/misc/examples/csmap_erase.c +++ b/misc/examples/csmap_erase.c @@ -12,7 +12,7 @@ void printmap(mymap m) { c_FOREACH (elem, mymap, m) printf(" [%d, %s]", elem.ref->first, cstr_str(&elem.ref->second)); - printf("\nsize() == %" c_ZU "\n\n", mymap_size(&m)); + printf("\nsize() == %" c_ZI "\n\n", mymap_size(&m)); } int main() @@ -75,9 +75,9 @@ int main() puts("Starting data of map m3 is:"); printmap(m3); // The 3rd member function removes elements with a given Key - size_t count = mymap_erase(&m3, 2); + int count = mymap_erase(&m3, 2); // The 3rd member function also returns the number of elements removed - printf("The number of elements removed from m3 is: %" c_ZU "\n", count); + printf("The number of elements removed from m3 is: %d\n", count); puts("After the element with a key of 2 is deleted, the map m3 is:"); printmap(m3); } diff --git a/misc/examples/csmap_find.c b/misc/examples/csmap_find.c index a61a47be..201c94e9 100644 --- a/misc/examples/csmap_find.c +++ b/misc/examples/csmap_find.c @@ -18,7 +18,7 @@ void print_elem(csmap_istr_raw p) { #define using_print_collection(CX) \ void print_collection_##CX(const CX* t) { \ - printf("%" c_ZU " elements: ", CX##_size(t)); \ + printf("%" c_ZI " elements: ", CX##_size(t)); \ \ c_FOREACH (p, CX, *t) { \ print_elem(CX##_value_toraw(p.ref)); \ diff --git a/misc/examples/cstr_match.c b/misc/examples/cstr_match.c index 116e5dd4..bfb0df6b 100644 --- a/misc/examples/cstr_match.c +++ b/misc/examples/cstr_match.c @@ -5,8 +5,8 @@ int main() { c_WITH (cstr ss = cstr_lit("The quick brown fox jumps over the lazy dog.JPG"), cstr_drop(&ss)) { - size_t pos = cstr_find_at(&ss, 0, "brown"); - printf("%" c_ZU " [%s]\n", pos, pos == c_NPOS ? "" : cstr_str(&ss) + pos); + intptr_t pos = cstr_find_at(&ss, 0, "brown"); + printf("%" c_ZI " [%s]\n", pos, pos == c_NPOS ? "" : cstr_str(&ss) + pos); printf("equals: %d\n", cstr_equals(&ss, "The quick brown fox jumps over the lazy dog.JPG")); printf("contains: %d\n", cstr_contains(&ss, "umps ove")); printf("starts_with: %d\n", cstr_starts_with(&ss, "The quick brown")); @@ -16,7 +16,7 @@ int main() cstr s1 = cstr_lit("hell😀 w😀rl🐨"); csview ch1 = cstr_u8_chr(&s1, 7); csview ch2 = cstr_u8_chr(&s1, 10); - printf("%s\nsize: %" c_ZU ", %" c_ZU "\n", cstr_str(&s1), cstr_u8_size(&s1), cstr_size(&s1)); + printf("%s\nsize: %" c_ZI ", %" c_ZI "\n", cstr_str(&s1), cstr_u8_size(&s1), cstr_size(&s1)); printf("ch1: %.*s\n", c_ARGSV(ch1)); printf("ch2: %.*s\n", c_ARGSV(ch2)); } diff --git a/misc/examples/demos.c b/misc/examples/demos.c index 898c24cf..7070d860 100644 --- a/misc/examples/demos.c +++ b/misc/examples/demos.c @@ -175,11 +175,11 @@ void mapdemo3() cmap_str_iter it = cmap_str_find(&table, "Make"); c_FOREACH (i, cmap_str, table) printf("entry: %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second)); - printf("size %" c_ZU ": remove: Make: %s\n", cmap_str_size(&table), cstr_str(&it.ref->second)); + printf("size %" c_ZI ": remove: Make: %s\n", cmap_str_size(&table), cstr_str(&it.ref->second)); //cmap_str_erase(&table, "Make"); cmap_str_erase_at(&table, it); - printf("size %" c_ZU "\n", cmap_str_size(&table)); + printf("size %" c_ZI "\n", cmap_str_size(&table)); c_FOREACH (i, cmap_str, table) printf("entry: %s: %s\n", cstr_str(&i.ref->first), cstr_str(&i.ref->second)); cmap_str_drop(&table); // frees key and value cstrs, and hash table. diff --git a/misc/examples/forfilter.c b/misc/examples/forfilter.c index fdc013a3..1c64c9e0 100644 --- a/misc/examples/forfilter.c +++ b/misc/examples/forfilter.c @@ -69,7 +69,7 @@ void demo2(void) , c_flt_skipwhile(x, *x.ref != 11) && *x.ref % 2 != 0 , c_flt_take(x, 5)) - IVec_push(&vector, *x.ref * *x.ref); + IVec_push(&vector, (int)(*x.ref * *x.ref)); c_FOREACH (x, IVec, vector) printf(" %d", *x.ref); puts(""); diff --git a/misc/examples/gauss1.c b/misc/examples/gauss1.c index db103945..6b06b4e8 100644 --- a/misc/examples/gauss1.c +++ b/misc/examples/gauss1.c @@ -24,7 +24,7 @@ int main() printf("Demo of gaussian / normal distribution of %d random samples\n", N); // Setup random engine with normal distribution. - uint64_t seed = time(NULL); + uint64_t seed = (uint64_t)time(NULL); stc64_t rng = stc64_new(seed); stc64_normalf_t dist = stc64_normalf_new(Mean, StdDev); diff --git a/misc/examples/gauss2.c b/misc/examples/gauss2.c index c2ed2e00..c627fc91 100644 --- a/misc/examples/gauss2.c +++ b/misc/examples/gauss2.c @@ -18,7 +18,7 @@ int main() printf("Demo of gaussian / normal distribution of %d random samples\n", N); // Setup random engine with normal distribution. - uint64_t seed = time(NULL); + uint64_t seed = (uint64_t)time(NULL); stc64_t rng = stc64_new(seed); stc64_normalf_t dist = stc64_normalf_new(Mean, StdDev); @@ -33,7 +33,7 @@ int main() // Print the gaussian bar chart c_AUTO (cstr, bar) c_FORPAIR (index, count, csmap_int, mhist) { - size_t n = (size_t) (*_.count * StdDev * Scale * 2.5 / (float)N); + int n = (int)((float)*_.count * StdDev * Scale * 2.5f / (float)N); if (n > 0) { cstr_resize(&bar, n, '*'); printf("%4d %s\n", *_.index, cstr_str(&bar)); diff --git a/misc/examples/make.sh b/misc/examples/make.sh index bd1392fc..0c4760a6 100755 --- a/misc/examples/make.sh +++ b/misc/examples/make.sh @@ -7,7 +7,7 @@ if [ "$(uname)" = 'Linux' ]; then fi #cc=gcc; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall $sanitize" -cc=gcc; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -Wsign-compare -Wwrite-strings" # -Wconversion +cc=gcc; cflags="-s -O2 -std=c99 -Wconversion -Wpedantic -Wall -Wsign-compare -Wwrite-strings" # -Wconversion #cc=tcc; cflags="-Wall -std=c99" #cc=clang; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -Wsign-compare -Wwrite-strings" #cc=clang; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -DSTC_CSTR_V1 -DSTC_CSMAP_V1" diff --git a/misc/examples/new_queue.c b/misc/examples/new_queue.c index 828387b5..5c25a229 100644 --- a/misc/examples/new_queue.c +++ b/misc/examples/new_queue.c @@ -22,25 +22,25 @@ int point_cmp(const Point* a, const Point* b) { int main() { int n = 50000000; - stc64_t rng = stc64_new(time(NULL)); + stc64_t rng = stc64_new((uint64_t)time(NULL)); stc64_uniform_t dist = stc64_uniform_new(0, n); c_AUTO (IQ, Q) { // Push 50'000'000 random numbers onto the queue. c_FORRANGE (n) - IQ_push(&Q, stc64_uniform(&rng, &dist)); + IQ_push(&Q, (int)stc64_uniform(&rng, &dist)); // Push or pop on the queue 50 million times - printf("befor: size %" c_ZU ", capacity %" c_ZU "\n", IQ_size(&Q), IQ_capacity(&Q)); + printf("befor: size %" c_ZI ", capacity %" c_ZI "\n", IQ_size(&Q), IQ_capacity(&Q)); c_FORRANGE (n) { - int r = stc64_uniform(&rng, &dist); + int r = (int)stc64_uniform(&rng, &dist); if (r & 3) IQ_push(&Q, r); else IQ_pop(&Q); } - printf("after: size %" c_ZU ", capacity %" c_ZU "\n", IQ_size(&Q), IQ_capacity(&Q)); + printf("after: size %" c_ZI ", capacity %" c_ZI "\n", IQ_size(&Q), IQ_capacity(&Q)); } } diff --git a/misc/examples/prime.c b/misc/examples/prime.c index 5c8d65d3..11c1f1c7 100644 --- a/misc/examples/prime.c +++ b/misc/examples/prime.c @@ -6,19 +6,19 @@ #include -cbits sieveOfEratosthenes(size_t n) +cbits sieveOfEratosthenes(intptr_t n) { cbits bits = cbits_with_size(n/2 + 1, true); - size_t q = (size_t) sqrt((double) n) + 1; - for (size_t i = 3; i < q; i += 2) { - size_t j = i; + intptr_t q = (intptr_t)sqrt((double) n) + 1; + for (intptr_t i = 3; i < q; i += 2) { + intptr_t j = i; for (; j < n; j += 2) { if (cbits_test(&bits, j>>1)) { i = j; break; } } - for (size_t j = i*i; j < n; j += i*2) + for (intptr_t j = i*i; j < n; j += i*2) cbits_reset(&bits, j>>1); } return bits; @@ -26,16 +26,16 @@ cbits sieveOfEratosthenes(size_t n) int main(void) { - size_t n = 1000000000; - printf("computing prime numbers up to %" c_ZU "\n", n); + intptr_t n = 1000000000; + printf("computing prime numbers up to %" c_ZI "\n", n); clock_t t1 = clock(); c_WITH (cbits primes = sieveOfEratosthenes(n + 1), cbits_drop(&primes)) { puts("done"); - size_t np = cbits_count(&primes); + intptr_t np = cbits_count(&primes); clock_t t2 = clock(); - printf("number of primes: %" c_ZU ", time: %f\n", np, (t2 - t1) / (float)CLOCKS_PER_SEC); + printf("number of primes: %" c_ZI ", time: %f\n", np, (float)(t2 - t1) / (float)CLOCKS_PER_SEC); puts("Show all the primes in the range [2, 1000):"); printf("2"); c_FORRANGE (i, 3, 1000, 2) diff --git a/misc/examples/priority.c b/misc/examples/priority.c index 22da6f60..f39c0634 100644 --- a/misc/examples/priority.c +++ b/misc/examples/priority.c @@ -9,13 +9,13 @@ #include int main() { - size_t N = 10000000; - stc64_t rng = stc64_new(time(NULL)); + intptr_t N = 10000000; + stc64_t rng = stc64_new((uint64_t)time(NULL)); stc64_uniform_t dist = stc64_uniform_new(0, N * 10); c_AUTO (cpque_i, heap) { // Push ten million random numbers to priority queue - printf("Push %" c_ZU " numbers\n", N); + printf("Push %" c_ZI " numbers\n", N); c_FORRANGE (N) cpque_i_push(&heap, stc64_uniform(&rng, &dist)); diff --git a/misc/examples/queue.c b/misc/examples/queue.c index 1d325fc6..ee537b58 100644 --- a/misc/examples/queue.c +++ b/misc/examples/queue.c @@ -15,17 +15,17 @@ int main() { { // Push ten million random numbers onto the queue. c_FORRANGE (n) - cqueue_i_push(&queue, stc64_uniform(&rng, &dist)); + cqueue_i_push(&queue, (int)stc64_uniform(&rng, &dist)); // Push or pop on the queue ten million times printf("%d\n", n); c_FORRANGE (n) { // forrange uses initial n only. - int r = stc64_uniform(&rng, &dist); + int r = (int)stc64_uniform(&rng, &dist); if (r & 1) ++n, cqueue_i_push(&queue, r); else --n, cqueue_i_pop(&queue); } - printf("%d, %" c_ZU "\n", n, cqueue_i_size(&queue)); + printf("%d, %" c_ZI "\n", n, cqueue_i_size(&queue)); } } diff --git a/misc/examples/random.c b/misc/examples/random.c index 82214924..fc4576dd 100644 --- a/misc/examples/random.c +++ b/misc/examples/random.c @@ -5,10 +5,10 @@ int main() { const size_t N = 1000000000; - const uint64_t seed = time(NULL), range = 1000000; + const uint64_t seed = (uint64_t)time(NULL), range = 1000000; stc64_t rng = stc64_new(seed); - uint64_t sum; + int64_t sum; clock_t diff, before; printf("Compare speed of full and unbiased ranged random numbers...\n"); @@ -18,8 +18,8 @@ int main() sum += (uint32_t)stc64_rand(&rng); } diff = clock() - before; - printf("full range\t\t: %f secs, %" c_ZU ", avg: %f\n", - (float)diff / CLOCKS_PER_SEC, N, (double)sum / N); + printf("full range\t\t: %f secs, %" c_ZI ", avg: %f\n", + (float)diff / CLOCKS_PER_SEC, N, (float)sum / (float)N); stc64_uniform_t dist1 = stc64_uniform_new(0, range); rng = stc64_new(seed); @@ -29,17 +29,17 @@ int main() sum += stc64_uniform(&rng, &dist1); // unbiased } diff = clock() - before; - printf("unbiased 0-%" PRIu64 "\t: %f secs, %" c_ZU ", avg: %f\n", - range, (float)diff/CLOCKS_PER_SEC, N, (double)sum / N); + printf("unbiased 0-%" PRIu64 "\t: %f secs, %" c_ZI ", avg: %f\n", + range, (float)diff/CLOCKS_PER_SEC, N, (float)sum / (float)N); sum = 0; rng = stc64_new(seed); before = clock(); c_FORRANGE (N) { - sum += stc64_rand(&rng) % (range + 1); // biased + sum += (int64_t)(stc64_rand(&rng) % (range + 1)); // biased } diff = clock() - before; - printf("biased 0-%" PRIu64 " \t: %f secs, %" c_ZU ", avg: %f\n", - range, (float)diff / CLOCKS_PER_SEC, N, (double)sum / N); + printf("biased 0-%" PRIu64 " \t: %f secs, %" c_ZI ", avg: %f\n", + range, (float)diff / CLOCKS_PER_SEC, N, (float)sum / (float)N); } diff --git a/misc/examples/regex_match.c b/misc/examples/regex_match.c index 93b83651..b7d6ed3a 100644 --- a/misc/examples/regex_match.c +++ b/misc/examples/regex_match.c @@ -1,6 +1,7 @@ #define i_extern #include #include + #define i_val float #include @@ -22,7 +23,7 @@ int main() // extract and convert all numbers in str to floats c_FORMATCH (i, &re, str) - cstack_float_push(&vec, atof(i.match[0].str)); + cstack_float_push(&vec, (float)atof(i.match[0].str)); c_FOREACH (i, cstack_float, vec) printf(" %g\n", *i.ref); diff --git a/misc/examples/sort.c b/misc/examples/sort.c index de94cede..65077143 100644 --- a/misc/examples/sort.c +++ b/misc/examples/sort.c @@ -14,7 +14,7 @@ #define fmt_Elem "%lld" -int testsort(csort_elm_value *a, size_t size, const char *desc) { +int testsort(csort_elm_value *a, long size, const char *desc) { clock_t t = clock(); #ifdef __cplusplus printf("std::sort: "); @@ -26,13 +26,13 @@ int testsort(csort_elm_value *a, size_t size, const char *desc) { t = clock() - t; printf("%s: %d elements sorted in %.2f ms\n", - desc, (int)size, t*1000.0/CLOCKS_PER_SEC); + desc, (int)size, (float)t*1000.0f/CLOCKS_PER_SEC); return 0; } int main(int argc, char *argv[]) { - size_t i, size = argc > 1 ? strtoull(argv[1], NULL, 0) : 10000000; - csort_elm_value *a = (csort_elm_value*)malloc(sizeof(*a) * size); + long i, size = argc > 1 ? strtol(argv[1], NULL, 0) : 10000000; + csort_elm_value *a = (csort_elm_value*)c_malloc(c_sizeof(*a) * size); if (a == NULL) return -1; for (i = 0; i < size; i++) diff --git a/misc/examples/sso_map.c b/misc/examples/sso_map.c index f88e5f79..0841a316 100644 --- a/misc/examples/sso_map.c +++ b/misc/examples/sso_map.c @@ -10,7 +10,7 @@ int main() cmap_str_emplace(&m, "Test long ", "This is a longer string"); c_FORPAIR (k, v, cmap_str, m) - printf("%s: '%s' Len=%" c_ZU ", Is long: %s\n", + printf("%s: '%s' Len=%" c_ZI ", Is long: %s\n", cstr_str(_.k), cstr_str(_.v), cstr_size(_.v), cstr_is_long(_.v) ? "true" : "false"); } diff --git a/misc/examples/sso_substr.c b/misc/examples/sso_substr.c index be372a8d..7e858ec4 100644 --- a/misc/examples/sso_substr.c +++ b/misc/examples/sso_substr.c @@ -6,7 +6,7 @@ int main () { cstr str = cstr_lit("We think in generalities, but we live in details."); csview sv1 = cstr_substr_ex(&str, 3, 5); // "think" - size_t pos = cstr_find(&str, "live"); // position of "live" + intptr_t pos = cstr_find(&str, "live"); // position of "live" csview sv2 = cstr_substr_ex(&str, pos, 4); // "live" csview sv3 = cstr_slice_ex(&str, -8, -1); // "details" printf("%.*s, %.*s, %.*s\n", c_ARGSV(sv1), c_ARGSV(sv2), c_ARGSV(sv3)); diff --git a/misc/examples/utf8replace_c.c b/misc/examples/utf8replace_c.c index 2d8d1921..3f98a2a6 100644 --- a/misc/examples/utf8replace_c.c +++ b/misc/examples/utf8replace_c.c @@ -16,11 +16,8 @@ int main() { c_FOREACH (c, cstr, hello) printf("%.*s,", c_ARGSV(c.u8.chr)); - //csview sv = c_SV("If you find the time, you will find the winner"); - //str = cstr_replace_sv(sv, c_SV("find"), c_SV("match"), 0); - - str = cstr_lit("If you find the time, you will find the winner"); - cstr_replace(&str, "find", "match"); + str = cstr_lit("scooby, dooby doo"); + cstr_replace(&str, "oo", "00"); printf("\n%s\n", cstr_str(&str)); } } diff --git a/src/cregex.c b/src/cregex.c index 1876e860..c17e1967 100644 --- a/src/cregex.c +++ b/src/cregex.c @@ -78,7 +78,7 @@ typedef struct _Reprog { _Reinst *startinst; /* start pc */ _Reflags flags; - unsigned nsubids; + int nsubids; _Reclass cclass[_NCLASS]; /* .data */ _Reinst firstinst[]; /* .text : originally 5 elements? */ } _Reprog; @@ -246,13 +246,13 @@ utfruneicase(const char *s, _Rune c) * save a new match in mp */ static void -_renewmatch(_Resub *mp, unsigned ms, _Resublist *sp, unsigned nsubids) +_renewmatch(_Resub *mp, int ms, _Resublist *sp, int nsubids) { if (mp==NULL || ms==0) return; if (mp[0].str == NULL || sp->m[0].str < mp[0].str || (sp->m[0].str == mp[0].str && sp->m[0].size > mp[0].size)) { - for (unsigned i=0; im[i]; } } @@ -265,7 +265,7 @@ _renewmatch(_Resub *mp, unsigned ms, _Resublist *sp, unsigned nsubids) static _Relist* _renewthread(_Relist *lp, /* _relist to add to */ _Reinst *ip, /* instruction to add */ - unsigned ms, + int ms, _Resublist *sep) /* pointers to subexpressions */ { _Relist *p; @@ -297,7 +297,7 @@ _renewthread(_Relist *lp, /* _relist to add to */ static _Relist* _renewemptythread(_Relist *lp, /* _relist to add to */ _Reinst *ip, /* instruction to add */ - unsigned ms, + int ms, const char *sp) /* pointers to subexpressions */ { _Relist *p; @@ -895,7 +895,7 @@ _regcomp1(_Reprog *progp, _Parser *par, const char *s, int cflags) pp->startinst = par->andp->first; pp = _optimize(par, pp); - pp->nsubids = (unsigned)par->cursubid; + pp->nsubids = par->cursubid; out: if (par->error) { c_free(pp); @@ -910,20 +910,20 @@ _runematch(_Rune s, _Rune r) { int inv = 0, n; switch (s) { - case ASC_D: inv = 1; case ASC_d: return inv ^ (isdigit(r) != 0); - case ASC_S: inv = 1; case ASC_s: return inv ^ (isspace(r) != 0); - case ASC_W: inv = 1; case ASC_w: return inv ^ ((isalnum(r) != 0) | (r == '_')); - case ASC_AL: inv = 1; case ASC_al: return inv ^ (isalpha(r) != 0); - case ASC_AN: inv = 1; case ASC_an: return inv ^ (isalnum(r) != 0); + case ASC_D: inv = 1; case ASC_d: return inv ^ (isdigit((int)r) != 0); + case ASC_S: inv = 1; case ASC_s: return inv ^ (isspace((int)r) != 0); + case ASC_W: inv = 1; case ASC_w: return inv ^ ((isalnum((int)r) != 0) | (r == '_')); + case ASC_AL: inv = 1; case ASC_al: return inv ^ (isalpha((int)r) != 0); + case ASC_AN: inv = 1; case ASC_an: return inv ^ (isalnum((int)r) != 0); case ASC_AS: return (r >= 128); case ASC_as: return (r < 128); case ASC_BL: inv = 1; case ASC_bl: return inv ^ ((r == ' ') | (r == '\t')); - case ASC_CT: inv = 1; case ASC_ct: return inv ^ (iscntrl(r) != 0); - case ASC_GR: inv = 1; case ASC_gr: return inv ^ (isgraph(r) != 0); - case ASC_PR: inv = 1; case ASC_pr: return inv ^ (isprint(r) != 0); - case ASC_PU: inv = 1; case ASC_pu: return inv ^ (ispunct(r) != 0); - case ASC_LO: inv = 1; case ASC_lo: return inv ^ (islower(r) != 0); - case ASC_UP: inv = 1; case ASC_up: return inv ^ (isupper(r) != 0); - case ASC_XD: inv = 1; case ASC_xd: return inv ^ (isxdigit(r) != 0); + case ASC_CT: inv = 1; case ASC_ct: return inv ^ (iscntrl((int)r) != 0); + case ASC_GR: inv = 1; case ASC_gr: return inv ^ (isgraph((int)r) != 0); + case ASC_PR: inv = 1; case ASC_pr: return inv ^ (isprint((int)r) != 0); + case ASC_PU: inv = 1; case ASC_pu: return inv ^ (ispunct((int)r) != 0); + case ASC_LO: inv = 1; case ASC_lo: return inv ^ (islower((int)r) != 0); + case ASC_UP: inv = 1; case ASC_up: return inv ^ (isupper((int)r) != 0); + case ASC_XD: inv = 1; case ASC_xd: return inv ^ (isxdigit((int)r) != 0); case UTF_AN: inv = 1; case UTF_an: return inv ^ utf8_isalnum(r); case UTF_BL: inv = 1; case UTF_bl: return inv ^ utf8_isblank(r); case UTF_SP: inv = 1; case UTF_sp: return inv ^ utf8_isspace(r); @@ -966,7 +966,7 @@ static int _regexec1(const _Reprog *progp, /* program to run */ const char *bol, /* string to run machine on */ _Resub *mp, /* subexpression elements */ - unsigned ms, /* number of elements at mp */ + int ms, /* number of elements at mp */ _Reljunk *j, int mflags ) @@ -979,7 +979,7 @@ _regexec1(const _Reprog *progp, /* program to run */ const char *s, *p; _Rune r, *rp, *ep; int n, checkstart, match = 0; - unsigned i; + int i; bool icase = progp->flags.icase; checkstart = j->starttype; @@ -1123,7 +1123,7 @@ static int _regexec2(const _Reprog *progp, /* program to run */ const char *bol, /* string to run machine on */ _Resub *mp, /* subexpression elements */ - unsigned ms, /* number of elements at mp */ + int ms, /* number of elements at mp */ _Reljunk *j, int mflags ) @@ -1149,7 +1149,7 @@ _regexec2(const _Reprog *progp, /* program to run */ static int _regexec(const _Reprog *progp, /* program to run */ const char *bol, /* string to run machine on */ - unsigned ms, /* number of elements at mp */ + int ms, /* number of elements at mp */ _Resub mp[], /* subexpression elements */ int mflags) { @@ -1195,7 +1195,7 @@ _regexec(const _Reprog *progp, /* program to run */ static void -_build_subst(const char* replace, unsigned nmatch, const csview match[], +_build_subst(const char* replace, int nmatch, const csview match[], bool (*mfun)(int, csview, cstr*), cstr* subst) { cstr_buf buf = cstr_buffer(subst); intptr_t len = 0, cap = buf.cap; @@ -1216,7 +1216,7 @@ _build_subst(const char* replace, unsigned nmatch, const csview match[], csview m = mfun && mfun(g, match[g], &mstr) ? cstr_sv(&mstr) : match[g]; if (len + m.size > cap) dst = cstr_reserve(subst, cap = cap*3/2 + m.size); - for (unsigned i = 0; i < m.size; ++i) + for (int i = 0; i < (int)m.size; ++i) dst[len++] = m.str[i]; } ++replace; @@ -1244,9 +1244,9 @@ cregex_compile_3(cregex *self, const char* pattern, int cflags) { return self->error = par.error; } -unsigned +int cregex_captures(const cregex* self) { - return self->prog ? 1U + self->prog->nsubids : 0U; + return self->prog ? 1 + self->prog->nsubids : 0; } int @@ -1271,13 +1271,13 @@ cregex_find_pattern_4(const char* pattern, const char* input, } cstr -cregex_replace_sv_6(const cregex* re, csview input, const char* replace, unsigned count, +cregex_replace_sv_6(const cregex* re, csview input, const char* replace, int count, bool (*mfun)(int, csview, cstr*), int rflags) { cstr out = cstr_NULL; cstr subst = cstr_NULL; csview match[CREG_MAX_CAPTURES]; - unsigned nmatch = cregex_captures(re); - if (!count) count = ~0U; + int nmatch = cregex_captures(re); + if (!count) count = INT32_MAX; bool copy = !(rflags & CREG_R_STRIP); while (count-- && cregex_find_sv(re, input, match) == CREG_OK) { @@ -1294,7 +1294,7 @@ cregex_replace_sv_6(const cregex* re, csview input, const char* replace, unsigne } cstr -cregex_replace_pattern_6(const char* pattern, const char* input, const char* replace, unsigned count, +cregex_replace_pattern_6(const char* pattern, const char* input, const char* replace, int count, bool (*mfun)(int, csview, cstr*), int crflags) { cregex re = cregex_init(); if (cregex_compile(&re, pattern, crflags) != CREG_OK) diff --git a/src/utf8code.c b/src/utf8code.c index 351ddab5..a892f5fd 100644 --- a/src/utf8code.c +++ b/src/utf8code.c @@ -20,7 +20,7 @@ const uint8_t utf8_dtab[] = { 12,36,12,12,12,12,12,12,12,12,12,12, }; -unsigned utf8_encode(char *out, uint32_t c) +int utf8_encode(char *out, uint32_t c) { if (c < 0x80U) { out[0] = (char) c; @@ -143,7 +143,7 @@ bool utf8_isalpha(uint32_t c) { static int16_t groups[] = {U8G_Latin, U8G_Nl, U8G_Greek, U8G_Cyrillic, U8G_Han, U8G_Devanagari, U8G_Arabic}; if (c < 128) return isalpha((int)c) != 0; - for (unsigned j=0; j < c_ARRAYLEN(groups); ++j) + for (int j=0; j < c_ARRAYLEN(groups); ++j) if (utf8_isgroup(groups[j], c)) return true; return false; -- cgit v1.2.3 From a8998a52082f86a71bf152c5baa9ebc005871142 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Wed, 1 Feb 2023 10:12:22 +0100 Subject: Update docs formatting and README.md --- README.md | 8 +- docs/cbits_api.md | 16 ++-- docs/cbox_api.md | 8 +- docs/cdeq_api.md | 16 ++-- docs/clist_api.md | 26 +++---- docs/cmap_api.md | 40 +++++----- docs/crandom_api.md | 22 +++--- docs/cregex_api.md | 32 ++++---- docs/cset_api.md | 18 ++--- docs/cspan_api.md | 43 +++++------ docs/cstr_api.md | 208 ++++++++++++++++++++++++++-------------------------- docs/csview_api.md | 40 +++++----- docs/cvec_api.md | 24 +++--- 13 files changed, 253 insertions(+), 248 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/README.md b/README.md index a4b3c76e..38304ad9 100644 --- a/README.md +++ b/README.md @@ -3,9 +3,13 @@ STC - Smart Template Containers for C ===================================== -News: Version 4.1 Beta (Dec 2022) +News: Version 4.1 RC (Feb 2023) ------------------------------------------------ -- Major change is uppercase macros in ccommon.h. Lowercase macros are [still supported](include/stc/priv/altnames.h). +Major changes: +- Signed sizes and indices for all containers (no more mixing unsigned/signed bugs). +- A new exciting **cspan** single/multi-dimensional array view. +- Updates on cregex with several new unicode character classes. +- Uppercase flow-control macros (ccommon.h). Lowercase macros are [still supported](include/stc/priv/altnames.h). - [See detailed changes for version 4](#version-4). Introduction diff --git a/docs/cbits_api.md b/docs/cbits_api.md index 726fb68b..f3967739 100644 --- a/docs/cbits_api.md +++ b/docs/cbits_api.md @@ -21,25 +21,25 @@ All cbits definitions and prototypes are available by including a single header ```c cbits cbits_init(void); cbits cbits_from(const char* str); -cbits cbits_with_size(intptr_t size, bool value); // size must be <= N if N is defined +cbits cbits_with_size(intptr_t size, bool value); // size must be <= N if N is defined cbits cbits_with_pattern(intptr_t size, uint64_t pattern); cbits cbits_clone(cbits other); void cbits_clear(cbits* self); cbits* cbits_copy(cbits* self, const cbits* other); -void cbits_resize(cbits* self, intptr_t size, bool value); // only if i_len is not defined +void cbits_resize(cbits* self, intptr_t size, bool value); // only if i_len is not defined void cbits_drop(cbits* self); -cbits* cbits_take(cbits* self, const cbits* other); // give other to self -cbits cbits_move(cbits* self); // transfer self to caller +cbits* cbits_take(cbits* self, const cbits* other); // give other to self +cbits cbits_move(cbits* self); // transfer self to caller intptr_t cbits_size(const cbits* self); -intptr_t cbits_count(const cbits* self); // count number of bits set +intptr_t cbits_count(const cbits* self); // count number of bits set bool cbits_test(const cbits* self, intptr_t i); -bool cbits_at(const cbits* self, intptr_t i); // same as cbits_test() +bool cbits_at(const cbits* self, intptr_t i); // same as cbits_test() bool cbits_subset_of(const cbits* self, const cbits* other); // is set a subset of other? -bool cbits_disjoint(const cbits* self, const cbits* other); // no common bits +bool cbits_disjoint(const cbits* self, const cbits* other); // no common bits char* cbits_to_str(const cbits* self, char* str, intptr_t start, intptr_t stop); void cbits_set(cbits* self, intptr_t i); @@ -52,7 +52,7 @@ void cbits_flip(cbits* self, intptr_t i); void cbits_intersect(cbits* self, const cbits* other); void cbits_union(cbits* self, const cbits* other); -void cbits_xor(cbits* self, const cbits* other); // set of disjoint bits +void cbits_xor(cbits* self, const cbits* other); // set of disjoint bits ``` ## Types diff --git a/docs/cbox_api.md b/docs/cbox_api.md index 8906f154..4430b9f8 100644 --- a/docs/cbox_api.md +++ b/docs/cbox_api.md @@ -48,10 +48,10 @@ void cbox_X_drop(cbox_X* self); // destruct the co void cbox_X_reset(cbox_X* self); void cbox_X_reset_to(cbox_X* self, i_val* p); // assign new cbox from ptr. Takes ownership of p. -uint64_t cbox_X_hash(const cbox_X* x); // hash value -int cbox_X_cmp(const cbox_X* x, const cbox_X* y); // compares pointer addresses if no `i_cmp` is specified. - // is defined. Otherwise uses 'i_cmp' or default cmp. -bool cbox_X_eq(const cbox_X* x, const cbox_X* y); // cbox_X_cmp() == 0 +uint64_t cbox_X_hash(const cbox_X* x); // hash value +int cbox_X_cmp(const cbox_X* x, const cbox_X* y); // compares pointer addresses if no `i_cmp` is specified. + // is defined. Otherwise uses 'i_cmp' or default cmp. +bool cbox_X_eq(const cbox_X* x, const cbox_X* y); // cbox_X_cmp() == 0 // functions on pointed to objects. diff --git a/docs/cdeq_api.md b/docs/cdeq_api.md index 44a75fc2..716a608c 100644 --- a/docs/cdeq_api.md +++ b/docs/cdeq_api.md @@ -35,17 +35,17 @@ void cdeq_X_copy(cdeq_X* self, const cdeq_X* other); cdeq_X_iter cdeq_X_copy_range(cdeq_X* self, i_val* pos, const i_val* p1, const i_val* p2); bool cdeq_X_reserve(cdeq_X* self, intptr_t cap); void cdeq_X_shrink_to_fit(cdeq_X* self); -void cdeq_X_drop(cdeq_X* self); // destructor +void cdeq_X_drop(cdeq_X* self); // destructor bool cdeq_X_empty(const cdeq_X* self); intptr_t cdeq_X_size(const cdeq_X* self); intptr_t cdeq_X_capacity(const cdeq_X* self); const cdeq_X_value* cdeq_X_at(const cdeq_X* self, intptr_t idx); -const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw); // return NULL if not found -cdeq_X_value* cdeq_X_get_mut(cdeq_X* self, i_valraw raw); // mutable get +const cdeq_X_value* cdeq_X_get(const cdeq_X* self, i_valraw raw); // return NULL if not found +cdeq_X_value* cdeq_X_get_mut(cdeq_X* self, i_valraw raw); // mutable get cdeq_X_iter cdeq_X_find(const cdeq_X* self, i_valraw raw); -cdeq_X_iter cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw); // return cvec_X_end() if not found +cdeq_X_iter cdeq_X_find_in(cdeq_X_iter i1, cdeq_X_iter i2, i_valraw raw); // return cvec_X_end() if not found cdeq_X_value* cdeq_X_front(const cdeq_X* self); cdeq_X_value* cdeq_X_back(const cdeq_X* self); @@ -55,14 +55,14 @@ cdeq_X_value* cdeq_X_emplace_front(cdeq_X* self, i_valraw raw); void cdeq_X_pop_front(cdeq_X* self); cdeq_X_value* cdeq_X_push_back(cdeq_X* self, i_val value); -cdeq_X_value* cdeq_X_push(cdeq_X* self, i_val value); // alias for push_back() +cdeq_X_value* cdeq_X_push(cdeq_X* self, i_val value); // alias for push_back() cdeq_X_value* cdeq_X_emplace_back(cdeq_X* self, i_valraw raw); -cdeq_X_value* cdeq_X_emplace(cdeq_X* self, i_valraw raw); // alias for emplace_back() +cdeq_X_value* cdeq_X_emplace(cdeq_X* self, i_valraw raw); // alias for emplace_back() void cdeq_X_pop_back(cdeq_X* self); -cdeq_X_iter cdeq_X_insert(cdeq_X* self, intptr_t idx, i_val value); // move value +cdeq_X_iter cdeq_X_insert(cdeq_X* self, intptr_t idx, i_val value); // move value cdeq_X_iter cdeq_X_insert_n(cdeq_X* self, intptr_t idx, const i_val[] arr, intptr_t n); // move arr values -cdeq_X_iter cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value); // move value +cdeq_X_iter cdeq_X_insert_at(cdeq_X* self, cdeq_X_iter it, i_val value); // move value cdeq_X_iter cdeq_X_insert_range(cdeq_X* self, i_val* pos, const i_val* p1, const i_val* p2); diff --git a/docs/clist_api.md b/docs/clist_api.md index 13c27308..29bfd5ff 100644 --- a/docs/clist_api.md +++ b/docs/clist_api.md @@ -45,33 +45,33 @@ clist_X clist_X_clone(clist_X list); void clist_X_clear(clist_X* self); void clist_X_copy(clist_X* self, const clist_X* other); -void clist_X_drop(clist_X* self); // destructor +void clist_X_drop(clist_X* self); // destructor bool clist_X_empty(const clist_X* list); -intptr_t clist_X_count(const clist_X* list); // size() in O(n) time +intptr_t clist_X_count(const clist_X* list); // size() in O(n) time clist_X_value* clist_X_back(const clist_X* self); clist_X_value* clist_X_front(const clist_X* self); -void clist_X_push_back(clist_X* self, i_val value); // note: no pop_back() +void clist_X_push_back(clist_X* self, i_val value); // note: no pop_back() void clist_X_push_front(clist_X* self, i_val value); -void clist_X_push(clist_X* self, i_val value); // alias for push_back() +void clist_X_push(clist_X* self, i_val value); // alias for push_back() void clist_X_emplace_back(clist_X* self, i_valraw raw); void clist_X_emplace_front(clist_X* self, i_valraw raw); -void clist_X_emplace(clist_X* self, i_valraw raw); // alias for emplace_back() +void clist_X_emplace(clist_X* self, i_valraw raw); // alias for emplace_back() -clist_X_iter clist_X_insert_at(clist_X* self, clist_X_iter it, i_val value); // return iter to new elem +clist_X_iter clist_X_insert_at(clist_X* self, clist_X_iter it, i_val value); // return iter to new elem clist_X_iter clist_X_emplace_at(clist_X* self, clist_X_iter it, i_valraw raw); void clist_X_pop_front(clist_X* self); -clist_X_iter clist_X_erase_at(clist_X* self, clist_X_iter it); // return iter after it +clist_X_iter clist_X_erase_at(clist_X* self, clist_X_iter it); // return iter after it clist_X_iter clist_X_erase_range(clist_X* self, clist_X_iter it1, clist_X_iter it2); -intptr_t clist_X_remove(clist_X* self, i_valraw raw); // removes all matches +intptr_t clist_X_remove(clist_X* self, i_valraw raw); // removes all matches -clist_X clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2); // split off [i1, i2) -clist_X_iter clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other); // return updated valid it -clist_X_iter clist_X_splice_range(clist_X* self, clist_X_iter it, // return updated valid it +clist_X clist_X_split_off(clist_X* self, clist_X_iter i1, clist_X_iter i2); // split off [i1, i2) +clist_X_iter clist_X_splice(clist_X* self, clist_X_iter it, clist_X* other); // return updated valid it +clist_X_iter clist_X_splice_range(clist_X* self, clist_X_iter it, // return updated valid it clist_X* other, clist_X_iter it1, clist_X_iter it2); clist_X_iter clist_X_find(const clist_X* self, i_valraw raw); @@ -83,10 +83,10 @@ void clist_X_sort(clist_X* self); void clist_X_reverse(clist_X* self); // Node API -clist_X_node* clist_X_get_node(clist_X_value* val); // get the enclosing node +clist_X_node* clist_X_get_node(clist_X_value* val); // get the enclosing node clist_X_value* clist_X_push_node_back(clist_X* self, clist_X_node* node); clist_X_value* clist_X_insert_node_after(clist_X* self, clist_X_node* ref, clist_X_node* node); -clist_X_node* clist_X_unlink_node_after(clist_X* self, clist_X_node* ref); // return the unlinked node +clist_X_node* clist_X_unlink_node_after(clist_X* self, clist_X_node* ref); // return the unlinked node void clist_X_erase_node_after(clist_X* self, clist_X_node* node); clist_X_iter clist_X_begin(const clist_X* self); diff --git a/docs/cmap_api.md b/docs/cmap_api.md index 7b8fbb8f..8e5a53d9 100644 --- a/docs/cmap_api.md +++ b/docs/cmap_api.md @@ -53,32 +53,32 @@ cmap_X cmap_X_clone(cmap_x map); void cmap_X_clear(cmap_X* self); void cmap_X_copy(cmap_X* self, const cmap_X* other); -float cmap_X_max_load_factor(const cmap_X* self); // default: 0.85f +float cmap_X_max_load_factor(const cmap_X* self); // default: 0.85f bool cmap_X_reserve(cmap_X* self, intptr_t size); void cmap_X_shrink_to_fit(cmap_X* self); -void cmap_X_drop(cmap_X* self); // destructor +void cmap_X_drop(cmap_X* self); // destructor intptr_t cmap_X_size(const cmap_X* self); -intptr_t cmap_X_capacity(const cmap_X* self); // buckets * max_load_factor +intptr_t cmap_X_capacity(const cmap_X* self); // buckets * max_load_factor bool cmap_X_empty(const cmap_X* self ); -intptr_t cmap_X_bucket_count(const cmap_X* self); // num. of allocated buckets +intptr_t cmap_X_bucket_count(const cmap_X* self); // num. of allocated buckets -const cmap_X_mapped* cmap_X_at(const cmap_X* self, i_keyraw rkey); // rkey must be in map -cmap_X_mapped* cmap_X_at_mut(cmap_X* self, i_keyraw rkey); // mutable at -const cmap_X_value* cmap_X_get(const cmap_X* self, i_keyraw rkey); // const get -cmap_X_value* cmap_X_get_mut(cmap_X* self, i_keyraw rkey); // mutable get +const cmap_X_mapped* cmap_X_at(const cmap_X* self, i_keyraw rkey); // rkey must be in map +cmap_X_mapped* cmap_X_at_mut(cmap_X* self, i_keyraw rkey); // mutable at +const cmap_X_value* cmap_X_get(const cmap_X* self, i_keyraw rkey); // const get +cmap_X_value* cmap_X_get_mut(cmap_X* self, i_keyraw rkey); // mutable get bool cmap_X_contains(const cmap_X* self, i_keyraw rkey); -cmap_X_iter cmap_X_find(const cmap_X* self, i_keyraw rkey); // find element +cmap_X_iter cmap_X_find(const cmap_X* self, i_keyraw rkey); // find element -cmap_X_result cmap_X_insert(cmap_X* self, i_key key, i_val mapped); // no change if key in map -cmap_X_result cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped); // always update mapped -cmap_X_result cmap_X_push(cmap_X* self, cmap_X_value entry); // similar to insert +cmap_X_result cmap_X_insert(cmap_X* self, i_key key, i_val mapped); // no change if key in map +cmap_X_result cmap_X_insert_or_assign(cmap_X* self, i_key key, i_val mapped); // always update mapped +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(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 rmapped -intptr_t 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 +intptr_t 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 void cmap_X_erase_entry(cmap_X* self, cmap_X_value* entry); cmap_X_iter cmap_X_begin(const cmap_X* self); @@ -91,13 +91,13 @@ cmap_X_raw cmap_X_value_toraw(cmap_X_value* pval); ``` Helpers: ```c -uint64_t c_default_hash(const X *obj); // macro, calls cfasthash(obj, sizeof *obj) -uint64_t cstrhash(const char *str); // string hash funcion, uses strlen() -uint64_t cfasthash(const void *data, intptr_t len); // base hash function +uint64_t c_default_hash(const X *obj); // macro, calls cfasthash(obj, sizeof *obj) +uint64_t cstrhash(const char *str); // string hash funcion, uses strlen() +uint64_t cfasthash(const void *data, intptr_t len); // base hash function // equalto template parameter functions: -bool c_default_eq(const i_keyraw* a, const i_keyraw* b); // *a == *b -bool c_memcmp_eq(const i_keyraw* a, const i_keyraw* b); // !memcmp(a, b, sizeof *a) +bool c_default_eq(const i_keyraw* a, const i_keyraw* b); // *a == *b +bool c_memcmp_eq(const i_keyraw* a, const i_keyraw* b); // !memcmp(a, b, sizeof *a) ``` ## Types diff --git a/docs/crandom_api.md b/docs/crandom_api.md index 7dced0eb..391c485f 100644 --- a/docs/crandom_api.md +++ b/docs/crandom_api.md @@ -41,22 +41,22 @@ All crandom definitions and prototypes are available by including a single heade ## Methods ```c -void csrandom(uint64_t seed); // seed global stc64 prng -uint64_t crandom(void); // global stc64_rand(rng) -double crandomf(void); // global stc64_randf(rng) +void csrandom(uint64_t seed); // seed global stc64 prng +uint64_t crandom(void); // global stc64_rand(rng) +double crandomf(void); // global stc64_randf(rng) -stc64_t stc64_new(uint64_t seed); // stc64_init(s) is deprecated -stc64_t stc64_with_seq(uint64_t seed, uint64_t seq); // with unique stream +stc64_t stc64_new(uint64_t seed); // stc64_init(s) is deprecated +stc64_t stc64_with_seq(uint64_t seed, uint64_t seq); // with unique stream -uint64_t stc64_rand(stc64_t* rng); // range [0, 2^64 - 1] -double stc64_randf(stc64_t* rng); // range [0.0, 1.0) +uint64_t stc64_rand(stc64_t* rng); // range [0, 2^64 - 1] +double stc64_randf(stc64_t* rng); // range [0.0, 1.0) -stc64_uniform_t stc64_uniform_new(int64_t low, int64_t high); // uniform-distribution -int64_t stc64_uniform(stc64_t* rng, stc64_uniform_t* dist); // range [low, high] +stc64_uniform_t stc64_uniform_new(int64_t low, int64_t high); // uniform-distribution +int64_t stc64_uniform(stc64_t* rng, stc64_uniform_t* dist); // range [low, high] stc64_uniformf_t stc64_uniformf_new(double lowf, double highf); -double stc64_uniformf(stc64_t* rng, stc64_uniformf_t* dist); // range [lowf, highf) +double stc64_uniformf(stc64_t* rng, stc64_uniformf_t* dist); // range [lowf, highf) -stc64_normalf_t stc64_normalf_new(double mean, double stddev); // normal-distribution +stc64_normalf_t stc64_normalf_new(double mean, double stddev); // normal-distribution double stc64_normalf(stc64_t* rng, stc64_normalf_t* dist); ``` ## Types diff --git a/docs/cregex_api.md b/docs/cregex_api.md index 3d4392b0..e74040d8 100644 --- a/docs/cregex_api.md +++ b/docs/cregex_api.md @@ -24,35 +24,35 @@ enum { cregex cregex_init(void); cregex cregex_from(const char* pattern, int cflags = CREG_DEFAULT); - /* return CREG_OK, or negative error code on failure */ + // return CREG_OK, or negative error code on failure int cregex_compile(cregex *self, const char* pattern, int cflags = CREG_DEFAULT); - /* num. of capture groups in regex. 0 if RE is invalid. First group is the full match */ + // num. of capture groups in regex. 0 if RE is invalid. First group is the full match int cregex_captures(const cregex* self); - /* return CREG_OK, CREG_NOMATCH, or CREG_MATCHERROR */ + // return CREG_OK, CREG_NOMATCH, or CREG_MATCHERROR int cregex_find(const cregex* re, const char* input, csview match[], int mflags = CREG_DEFAULT); - /* Search inside input string-view only */ + // Search inside input string-view only int cregex_find_sv(const cregex* re, csview input, csview match[]); - /* All-in-one search (compile + find + drop) */ + // All-in-one search (compile + find + drop) int cregex_find_pattern(const char* pattern, const char* input, csview match[], int cmflags = CREG_DEFAULT); - /* Check if there are matches in input */ + // Check if there are matches in input bool cregex_is_match(const cregex* re, const char* input); - /* Replace all matches in input */ -cstr cregex_replace(const cregex* re, const char* input, const char* replace, count = MAX_INT); - /* Replace count matches in input string-view. Optionally transform replacement with mfun. */ -cstr cregex_replace_sv(const cregex* re, csview input, const char* replace, unsigned count = MAX_INT); -cstr cregex_replace_sv(const cregex* re, csview input, const char* replace, unsigned count, + // Replace all matches in input +cstr cregex_replace(const cregex* re, const char* input, const char* replace, int count = INT_MAX); + // Replace count matches in input string-view. Optionally transform replacement with mfun. +cstr cregex_replace_sv(const cregex* re, csview input, const char* replace, int count = INT_MAX); +cstr cregex_replace_sv(const cregex* re, csview input, const char* replace, int count, bool(*mfun)(int capgrp, csview match, cstr* mstr), int rflags); - /* All-in-one replacement (compile + find/replace + drop) */ -cstr cregex_replace_pattern(const char* pattern, const char* input, const char* replace, count = MAX_INT); -cstr cregex_replace_pattern(const char* pattern, const char* input, const char* replace, unsigned count, + // All-in-one replacement (compile + find/replace + drop) +cstr cregex_replace_pattern(const char* pattern, const char* input, const char* replace, int count = INT_MAX); +cstr cregex_replace_pattern(const char* pattern, const char* input, const char* replace, int count, bool(*mfun)(int capgrp, csview match, cstr* mstr), int rflags); - -void cregex_drop(cregex* self); /* destroy */ + // destroy +void cregex_drop(cregex* self); ``` ### Error codes diff --git a/docs/cset_api.md b/docs/cset_api.md index 2e80a49b..ef4df63b 100644 --- a/docs/cset_api.md +++ b/docs/cset_api.md @@ -35,27 +35,27 @@ cset_X cset_X_clone(cset_x set); void cset_X_clear(cset_X* self); void cset_X_copy(cset_X* self, const cset_X* other); -float cset_X_max_load_factor(const cset_X* self); // default: 0.85 +float cset_X_max_load_factor(const cset_X* self); // default: 0.85 bool cset_X_reserve(cset_X* self, intptr_t size); void cset_X_shrink_to_fit(cset_X* self); -void cset_X_drop(cset_X* self); // destructor +void cset_X_drop(cset_X* self); // destructor -intptr_t cset_X_size(const cset_X* self); // num. of allocated buckets -intptr_t cset_X_capacity(const cset_X* self); // buckets * max_load_factor +intptr_t cset_X_size(const cset_X* self); // num. of allocated buckets +intptr_t cset_X_capacity(const cset_X* self); // buckets * max_load_factor bool cset_X_empty(const cset_X* self); intptr_t cset_X_bucket_count(const cset_X* self); bool cset_X_contains(const cset_X* self, i_keyraw rkey); -const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey); // return NULL if not found -cset_X_value* cset_X_get_mut(cset_X* self, i_keyraw rkey); // mutable get +const cset_X_value* cset_X_get(const cset_X* self, i_keyraw rkey); // return NULL if not found +cset_X_value* cset_X_get_mut(cset_X* self, i_keyraw rkey); // mutable get cset_X_iter cset_X_find(const cset_X* self, i_keyraw rkey); cset_X_result cset_X_insert(cset_X* self, i_key key); -cset_X_result cset_X_push(cset_X* self, i_key key); // alias for insert. +cset_X_result cset_X_push(cset_X* self, i_key key); // alias for insert. cset_X_result cset_X_emplace(cset_X* self, i_keyraw rkey); -intptr_t cset_X_erase(cset_X* self, i_keyraw rkey); // return 0 or 1 -cset_X_iter cset_X_erase_at(cset_X* self, cset_X_iter it); // return iter after it +intptr_t cset_X_erase(cset_X* self, i_keyraw rkey); // return 0 or 1 +cset_X_iter cset_X_erase_at(cset_X* self, cset_X_iter it); // return iter after it void cset_X_erase_entry(cset_X* self, cset_X_value* entry); cset_X_iter cset_X_begin(const cset_X* self); diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 8f6f695f..70587f3e 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -9,43 +9,44 @@ The **cspan** is templated non-owning multi-dimensional view of an array. See th ```c #include -using_cspan(SpanType, ValueType, Rank); // define SpanType with ValueType elements. - // Rank is number of dimensions (max 4) +using_cspan(SpanType, ValueType); // define a 1-d SpanType with ValueType elements. +using_cspan(SpanTypeN, ValueType, Rank); // define multi-dimensional span with Rank. + // Rank is number of dimensions (max 5) // Shorthands: -using_cspan2(S, ValueType); // define span types S, S2 with ranks 1, 2. -using_cspan3(S, ValueType); // define span types S, S2, S3 with ranks 1, 2, 3. -using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. +using_cspan2(S, ValueType); // define span types S, S2 with ranks 1, 2. +using_cspan3(S, ValueType); // define span types S, S2, S3 with ranks 1, 2, 3. +using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. +using_cspan5(S, ValueType); // define span types S, S2, .., S5 with ranks 1, 2, 3, 4, 5. ``` ## Methods Note that `cspan_md()`, `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 -SpanTypeN cspan_md(ValueType* data, intptr_t xdim, ...); // create a multi-dimensional cspan -SpanType cspan_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values -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 - -intptr_t cspan_size(const SpanTypeN* self); // return number of elements -unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions -intptr_t cspan_index(const SpanTypeN* self, intptr_t x, ...); // index of element +SpanTypeN cspan_md(ValueType* data, intptr_t xdim, ...); // create a multi-dimensional cspan +SpanType cspan_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values +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 + +intptr_t cspan_size(const SpanTypeN* self); // return number of elements +unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions +intptr_t cspan_index(const SpanTypeN* self, intptr_t x, ..); // index of element -ValueType* cspan_at(SpanTypeN* self, intptr_t x, ...); // at(): num of args specifies rank of input span. +ValueType* cspan_at(SpanTypeN* self, intptr_t x, ...); // at(): num of args specifies rank of input span. ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); // return a subspan of lower rank: -SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. -SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. +SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. +SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. +SpanTypeN cspan_submd5(SpanType5* self, intptr_t x, ...); - // return a sliced span of same rank: -void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice multidim span into a md subspan. +void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice a span to make it a subspan of same rank - // return a subspan of same rank. Like e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); + // return a subspan of same rank. Similar to e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); SpanType2 cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count); SpanType3 cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count); -SpanType4 cspan_subspan4(const SpanType4 self, intptr_t offset, intptr_t count); SpanTypeN_iter SpanType_begin(const SpanTypeN* self); SpanTypeN_iter SpanType_end(const SpanTypeN* self); diff --git a/docs/cstr_api.md b/docs/cstr_api.md index 6bf5c723..37316d4d 100644 --- a/docs/cstr_api.md +++ b/docs/cstr_api.md @@ -18,114 +18,114 @@ All cstr definitions and prototypes are available by including a single header f ## Methods ```c -cstr cstr_init(void); // constructor; same as cstr_NULL. -cstr cstr_lit(const char literal_only[]); // cstr from literal; no strlen() call. -cstr cstr_from(const char* str); // constructor using strlen() -cstr cstr_from_n(const char* str, intptr_t n); // constructor with n first bytes of str -cstr cstr_from_sv(csview sv); // construct cstr from csview -cstr cstr_with_capacity(intptr_t cap); -cstr cstr_with_size(intptr_t len, char fill); // repeat fill len times -cstr cstr_from_fmt(const char* fmt, ...); // printf() formatting -cstr cstr_clone(cstr s); - -cstr* cstr_take(cstr* self, cstr s); // take ownership of s, i.e. don't drop s. -cstr cstr_move(cstr* self); // move string to caller, leave self empty -void cstr_drop(cstr* self); // destructor - -const char* cstr_str(const cstr* self); // cast to const char* -char* cstr_data(cstr* self); // cast to mutable char* -csview cstr_sv(const cstr* self); // cast to string view -cstr_buf cstr_buffer(cstr* self); // cast to mutable buffer (with capacity) - -intptr_t cstr_size(const cstr* self); -intptr_t cstr_capacity(const cstr* self); -bool cstr_empty(const cstr* self); - -char* cstr_reserve(cstr* self, intptr_t capacity); // return pointer to buffer -void cstr_resize(cstr* self, intptr_t len, char fill); -void cstr_shrink_to_fit(cstr* self); -void cstr_clear(cstr* self); - -char* cstr_assign(cstr* self, const char* str); -char* cstr_assign_n(cstr* self, const char* str, intptr_t n); // assign n first bytes of str -char* cstr_assign_sv(cstr* self, csview sv); -char* cstr_copy(cstr* self, cstr s); // copy-assign a cstr -int cstr_printf(cstr* self, const char* fmt, ...); // source and target must not overlap. - -char* cstr_append(cstr* self, const char* str); -char* cstr_append_n(cstr* self, const char* str, intptr_t n); // append n first bytes of str -char* cstr_append_sv(cstr* self, csview str); -char* cstr_append_s(cstr* self, cstr str); -int cstr_append_fmt(cstr* self, const char* fmt, ...); // printf() formatting -char* cstr_append_uninit(cstr* self, intptr_t len); // return ptr to start of uninited data - -void cstr_push(cstr* self, const char* chr); // append one utf8 char -void cstr_pop(cstr* self); // pop one utf8 char - -void cstr_insert(cstr* self, intptr_t pos, const char* ins); -void cstr_insert_sv(cstr* self, intptr_t pos, csview ins); -void cstr_insert_s(cstr* self, intptr_t pos, cstr ins); - -void cstr_erase(cstr* self, intptr_t pos, intptr_t len); // erase len bytes from pos - -void cstr_replace(cstr* self, const char* search, const char* repl, unsigned count = MAX_INT); -cstr cstr_replace_sv(csview in, csview search, csview repl, unsigned count); -void cstr_replace_at(cstr* self, intptr_t pos, intptr_t len, const char* repl); // replace at a position -void cstr_replace_at_sv(cstr* self, intptr_t pos, intptr_t len, const csview repl); -void cstr_replace_at_s(cstr* self, intptr_t pos, intptr_t len, cstr repl); - -bool cstr_equals(const cstr* self, const char* str); -bool cstr_equals_sv(const cstr* self, csview sv); -bool cstr_equals_s(const cstr* self, cstr s); - -intptr_t cstr_find(const cstr* self, const char* search); -intptr_t cstr_find_at(const cstr* self, intptr_t pos, const char* search); // search from pos -bool cstr_contains(const cstr* self, const char* search); - -bool cstr_starts_with(const cstr* self, const char* str); -bool cstr_starts_with_sv(const cstr* self, csview sv); -bool cstr_starts_with_s(const cstr* self, cstr s); - -bool cstr_ends_with(const cstr* self, const char* str); -bool cstr_ends_with_sv(const cstr* self, csview sv); -bool cstr_ends_with_s(const cstr* self, cstr s); - -bool cstr_getline(cstr *self, FILE *stream); // cstr_getdelim(self, '\n', stream) -bool cstr_getdelim(cstr *self, int delim, FILE *stream); // does not append delim to result +cstr cstr_init(void); // constructor; same as cstr_NULL. +cstr cstr_lit(const char literal_only[]); // cstr from literal; no strlen() call. +cstr cstr_from(const char* str); // constructor using strlen() +cstr cstr_from_n(const char* str, intptr_t n); // constructor with n first bytes of str +cstr cstr_from_sv(csview sv); // construct cstr from csview +cstr cstr_with_capacity(intptr_t cap); +cstr cstr_with_size(intptr_t len, char fill); // repeat fill len times +cstr cstr_from_fmt(const char* fmt, ...); // printf() formatting +cstr cstr_clone(cstr s); + +cstr* cstr_take(cstr* self, cstr s); // take ownership of s, i.e. don't drop s. +cstr cstr_move(cstr* self); // move string to caller, leave self empty +void cstr_drop(cstr* self); // destructor + +const char* cstr_str(const cstr* self); // cast to const char* +char* cstr_data(cstr* self); // cast to mutable char* +csview cstr_sv(const cstr* self); // cast to string view +cstr_buf cstr_buffer(cstr* self); // cast to mutable buffer (with capacity) + +intptr_t cstr_size(const cstr* self); +intptr_t cstr_capacity(const cstr* self); +bool cstr_empty(const cstr* self); + +char* cstr_reserve(cstr* self, intptr_t capacity); // return pointer to buffer +void cstr_resize(cstr* self, intptr_t len, char fill); +void cstr_shrink_to_fit(cstr* self); +void cstr_clear(cstr* self); + +char* cstr_assign(cstr* self, const char* str); +char* cstr_assign_n(cstr* self, const char* str, intptr_t n); // assign n first bytes of str +char* cstr_assign_sv(cstr* self, csview sv); +char* cstr_copy(cstr* self, cstr s); // copy-assign a cstr +int cstr_printf(cstr* self, const char* fmt, ...); // source and target must not overlap. + +char* cstr_append(cstr* self, const char* str); +char* cstr_append_n(cstr* self, const char* str, intptr_t n); // append n first bytes of str +char* cstr_append_sv(cstr* self, csview str); +char* cstr_append_s(cstr* self, cstr str); +int cstr_append_fmt(cstr* self, const char* fmt, ...); // printf() formatting +char* cstr_append_uninit(cstr* self, intptr_t len); // return ptr to start of uninited data + +void cstr_push(cstr* self, const char* chr); // append one utf8 char +void cstr_pop(cstr* self); // pop one utf8 char + +void cstr_insert(cstr* self, intptr_t pos, const char* ins); +void cstr_insert_sv(cstr* self, intptr_t pos, csview ins); +void cstr_insert_s(cstr* self, intptr_t pos, cstr ins); + +void cstr_erase(cstr* self, intptr_t pos, intptr_t len); // erase len bytes from pos + +void cstr_replace(cstr* self, const char* search, const char* repl, unsigned count = MAX_INT); +cstr cstr_replace_sv(csview in, csview search, csview repl, unsigned count); +void cstr_replace_at(cstr* self, intptr_t pos, intptr_t len, const char* repl); // replace at a pos +void cstr_replace_at_sv(cstr* self, intptr_t pos, intptr_t len, const csview repl); +void cstr_replace_at_s(cstr* self, intptr_t pos, intptr_t len, cstr repl); + +bool cstr_equals(const cstr* self, const char* str); +bool cstr_equals_sv(const cstr* self, csview sv); +bool cstr_equals_s(const cstr* self, cstr s); + +intptr_t cstr_find(const cstr* self, const char* search); +intptr_t cstr_find_at(const cstr* self, intptr_t pos, const char* search); // search from pos +bool cstr_contains(const cstr* self, const char* search); + +bool cstr_starts_with(const cstr* self, const char* str); +bool cstr_starts_with_sv(const cstr* self, csview sv); +bool cstr_starts_with_s(const cstr* self, cstr s); + +bool cstr_ends_with(const cstr* self, const char* str); +bool cstr_ends_with_sv(const cstr* self, csview sv); +bool cstr_ends_with_s(const cstr* self, cstr s); + +bool cstr_getline(cstr *self, FILE *stream); // cstr_getdelim(self, '\n', stream) +bool cstr_getdelim(cstr *self, int delim, FILE *stream); // does not append delim to result ``` #### UTF8 methods ```c -intptr_t cstr_u8_size(const cstr* self); // number of utf8 codepoints -intptr_t cstr_u8_size_n(const cstr self, intptr_t nbytes); // utf8 size within n bytes -intptr_t cstr_u8_to_pos(const cstr* self, intptr_t u8idx); // byte pos offset at utf8 codepoint index -const char* cstr_u8_at(const cstr* self, intptr_t u8idx); // char* position at utf8 codepoint index -csview cstr_u8_chr(const cstr* self, intptr_t u8idx); // get utf8 character as a csview -void cstr_u8_replace_at(cstr* self, intptr_t bytepos, intptr_t u8len, csview repl); // replace u8len utf8 chars -void cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len); // erase u8len codepoints from pos +intptr_t cstr_u8_size(const cstr* self); // number of utf8 codepoints +intptr_t cstr_u8_size_n(const cstr self, intptr_t nbytes); // utf8 size within n bytes +intptr_t cstr_u8_to_pos(const cstr* self, intptr_t u8idx); // byte pos offset at utf8 codepoint index +const char* cstr_u8_at(const cstr* self, intptr_t u8idx); // char* position at utf8 codepoint index +csview cstr_u8_chr(const cstr* self, intptr_t u8idx); // get utf8 character as a csview +void cstr_u8_replace_at(cstr* self, intptr_t bytepos, intptr_t u8len, csview repl); // replace u8len utf8 chars +void cstr_u8_erase(cstr* self, intptr_t bytepos, intptr_t u8len); // erase u8len codepoints from pos // iterate utf8 codepoints -cstr_iter cstr_begin(const cstr* self); -cstr_iter cstr_end(const cstr* self); -void cstr_next(cstr_iter* it); -cstr_iter cstr_advance(cstr_iter it, intptr_t n); +cstr_iter cstr_begin(const cstr* self); +cstr_iter cstr_end(const cstr* self); +void cstr_next(cstr_iter* it); +cstr_iter cstr_advance(cstr_iter it, intptr_t n); // utf8 functions requires linking with src/utf8code.c symbols: -bool cstr_valid_utf8(const cstr* self); // check if str is valid utf8 -cstr cstr_casefold_sv(csview sv); // returns new casefolded utf8 cstr - -cstr cstr_tolower(const char* str); // returns new lowercase utf8 cstr -cstr cstr_tolower_sv(csview sv); // returns new lowercase utf8 cstr -void cstr_lowercase(cstr* self); // transform cstr to lowercase utf8 - -cstr cstr_toupper(const char* str); // returns new uppercase utf8 cstr -cstr cstr_toupper_sv(csview sv); // returns new uppercase utf8 cstr -void cstr_uppercase(cstr* self); // transform cstr to uppercase utf8 - -int cstr_icmp(const cstr* s1, const cstr* s2); // utf8 case-insensitive comparison -bool cstr_iequals(const cstr* self, const char* str); // " -bool cstr_istarts_with(const cstr* self, const char* str); // " -bool cstr_iends_with(const cstr* self, const char* str); // " +bool cstr_valid_utf8(const cstr* self); // check if str is valid utf8 +cstr cstr_casefold_sv(csview sv); // returns new casefolded utf8 cstr + +cstr cstr_tolower(const char* str); // returns new lowercase utf8 cstr +cstr cstr_tolower_sv(csview sv); // returns new lowercase utf8 cstr +void cstr_lowercase(cstr* self); // transform cstr to lowercase utf8 + +cstr cstr_toupper(const char* str); // returns new uppercase utf8 cstr +cstr cstr_toupper_sv(csview sv); // returns new uppercase utf8 cstr +void cstr_uppercase(cstr* self); // transform cstr to uppercase utf8 + +int cstr_icmp(const cstr* s1, const cstr* s2); // utf8 case-insensitive comparison +bool cstr_iequals(const cstr* self, const char* str); // " +bool cstr_istarts_with(const cstr* self, const char* str); // " +bool cstr_iends_with(const cstr* self, const char* str); // " ``` Note that all methods with arguments `(..., const char* str, intptr_t n)`, `n` must be within the range of `str` length. @@ -141,10 +141,10 @@ char* cstrnstrn(const char* str, const char* search, intptr_t slen, intpt ## Types -| Type name | Type definition | Used to represent... | -|:----------------|:-------------------------------------------|:---------------------| -| `cstr` | `struct { ... }` | The string type | -| `cstr_value` | `char` | String element type | +| Type name | Type definition | Used to represent... | +|:----------------|:---------------------------------------------|:---------------------| +| `cstr` | `struct { ... }` | The string type | +| `cstr_value` | `char` | String element type | | `csview` | `struct { const char *str; intptr_t size; }` | String view type | | `cstr_buf` | `struct { char *data; intptr_t size, cap; }` | String buffer type | diff --git a/docs/csview_api.md b/docs/csview_api.md index 8064e4fd..3971c6a6 100644 --- a/docs/csview_api.md +++ b/docs/csview_api.md @@ -26,11 +26,11 @@ All csview definitions and prototypes are available by including a single header ## Methods ```c -csview c_SV(const char literal_only[]); // construct from literal, no strlen() -csview c_SV(const char* str, intptr_t n); // construct from str and length n -csview csview_lit(const char literal_only[]); // alias for c_SV(lit) -csview csview_from(const char* str); // construct from const char* -csview csview_from_n(const char* str, intptr_t n); // alias for c_SV(str, n) +csview c_SV(const char literal_only[]); // construct from literal, no strlen() +csview c_SV(const char* str, intptr_t n); // construct from str and length n +csview csview_lit(const char literal_only[]); // alias for c_SV(lit) +csview csview_from(const char* str); // construct from const char* +csview csview_from_n(const char* str, intptr_t n); // alias for c_SV(str, n) intptr_t csview_size(csview sv); bool csview_empty(csview sv); @@ -43,8 +43,8 @@ bool csview_contains(csview sv, const char* str); bool csview_starts_with(csview sv, const char* str); bool csview_ends_with(csview sv, const char* str); -csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n); // negative pos count from end -csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2); // negative p1, p2 count from end +csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n); // negative pos count from end +csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2); // negative p1, p2 count from end csview csview_token(csview sv, const char* sep, intptr_t* start); // *start > sv.size after last token ``` @@ -52,32 +52,32 @@ csview csview_token(csview sv, const char* sep, intptr_t* start); // *s ```c intptr_t csview_u8_size(csview sv); csview csview_u8_substr(csview sv, intptr_t bytepos, intptr_t u8len); -bool csview_valid_utf8(csview sv); // requires linking with src/utf8code.c +bool csview_valid_utf8(csview sv); // requires linking with src/utf8code.c csview_iter csview_begin(const csview* self); csview_iter csview_end(const csview* self); -void csview_next(csview_iter* it); // utf8 codepoint step, not byte! +void csview_next(csview_iter* it); // utf8 codepoint step, not byte! csview_iter csview_advance(csview_iter it, intptr_t n); -// from utf8.h + // from utf8.h intptr_t utf8_size(const char *s); -intptr_t utf8_size_n(const char *s, intptr_t nbytes); // number of UTF8 codepoints within n bytes -const char* utf8_at(const char *s, intptr_t index); // from UTF8 index to char* position -intptr_t utf8_pos(const char* s, intptr_t index); // from UTF8 index to byte index position -unsigned utf8_chr_size(const char* s); // UTF8 character size: 1-4 -// implemented in src/utf8code.c: +intptr_t utf8_size_n(const char *s, intptr_t nbytes); // number of UTF8 codepoints within n bytes +const char* utf8_at(const char *s, intptr_t index); // from UTF8 index to char* position +intptr_t utf8_pos(const char* s, intptr_t index); // from UTF8 index to byte index position +unsigned utf8_chr_size(const char* s); // UTF8 character size: 1-4 + // implemented in src/utf8code.c: bool utf8_valid(const char* s); bool utf8_valid_n(const char* s, intptr_t nbytes); -uint32_t utf8_decode(utf8_decode_t *d, uint8_t byte); // decode next byte to utf8, return state. -unsigned utf8_encode(char *out, uint32_t codepoint); // encode unicode cp into out buffer -uint32_t utf8_peek(const char* s); // codepoint value of character at s -uint32_t utf8_peek_off(const char* s, int offset); // codepoint value at utf8 pos (may be negative) +uint32_t utf8_decode(utf8_decode_t *d, uint8_t byte); // decode next byte to utf8, return state. +unsigned utf8_encode(char *out, uint32_t codepoint); // encode unicode cp into out buffer +uint32_t utf8_peek(const char* s); // codepoint value of character at s +uint32_t utf8_peek_off(const char* s, int offset); // codepoint value at utf8 pos (may be negative) ``` #### Extended cstr methods ```c csview cstr_substr(const cstr* self, intptr_t pos, intptr_t n); -csview cstr_substr_ex(const cstr* s, intptr_t pos, intptr_t n); // negative pos count from end +csview cstr_substr_ex(const cstr* s, intptr_t pos, intptr_t n); // negative pos count from end csview cstr_u8_substr(const cstr* self, intptr_t bytepos, intptr_t u8len); csview cstr_slice(const cstr* self, intptr_t p1, intptr_t p2); diff --git a/docs/cvec_api.md b/docs/cvec_api.md index d67e80fd..057caa7c 100644 --- a/docs/cvec_api.md +++ b/docs/cvec_api.md @@ -40,23 +40,23 @@ void cvec_X_copy(cvec_X* self, const cvec_X* other); cvec_X_iter cvec_X_copy_range(cvec_X* self, i_val* pos, const i_val* p1, const i_val* p2); bool cvec_X_reserve(cvec_X* self, intptr_t cap); bool cvec_X_resize(cvec_X* self, intptr_t size, i_val null); -cvec_X_iter cvec_X_insert_uninit(cvec_X* self, i_val* pos, intptr_t n); // return pos iter +cvec_X_iter cvec_X_insert_uninit(cvec_X* self, i_val* pos, intptr_t n); // return pos iter void cvec_X_shrink_to_fit(cvec_X* self); -void cvec_X_drop(cvec_X* self); // destructor +void cvec_X_drop(cvec_X* self); // destructor bool cvec_X_empty(const cvec_X* self); intptr_t cvec_X_size(const cvec_X* self); intptr_t cvec_X_capacity(const cvec_X* self); const cvec_X_value* cvec_X_at(const cvec_X* self, intptr_t idx); -const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw); // return NULL if not found +const cvec_X_value* cvec_X_get(const cvec_X* self, i_valraw raw); // return NULL if not found cvec_X_value* cvec_X_at_mut(cvec_X* self, intptr_t idx); -cvec_X_value* cvec_X_get_mut(cvec_X* self, i_valraw raw); // find mutable value, return value ptr +cvec_X_value* cvec_X_get_mut(cvec_X* self, i_valraw raw); // find mutable value, return value ptr cvec_X_iter cvec_X_find(const cvec_X* self, i_valraw raw); -cvec_X_iter cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw); // return cvec_X_end() if not found +cvec_X_iter cvec_X_find_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw); // return cvec_X_end() if not found // On sorted vectors: -cvec_X_iter cvec_X_binary_search(const cvec_X* self, i_valraw raw); // at elem == raw, else end -cvec_X_iter cvec_X_lower_bound(const cvec_X* self, i_valraw raw); // at first elem >= raw, else end +cvec_X_iter cvec_X_binary_search(const cvec_X* self, i_valraw raw); // at elem == raw, else end +cvec_X_iter cvec_X_lower_bound(const cvec_X* self, i_valraw raw); // at first elem >= raw, else end cvec_X_iter cvec_X_binary_search_in(cvec_X_iter i1, cvec_X_iter i2, i_valraw raw, cvec_X_iter* lower_bound); @@ -65,15 +65,15 @@ cvec_X_value* cvec_X_back(const cvec_X* self); cvec_X_value* cvec_X_push(cvec_X* self, i_val value); cvec_X_value* cvec_X_emplace(cvec_X* self, i_valraw raw); -cvec_X_value* cvec_X_push_back(cvec_X* self, i_val value); // alias for push -cvec_X_value* cvec_X_emplace_back(cvec_X* self, i_valraw raw); // alias for emplace +cvec_X_value* cvec_X_push_back(cvec_X* self, i_val value); // alias for push +cvec_X_value* cvec_X_emplace_back(cvec_X* self, i_valraw raw); // alias for emplace void cvec_X_pop(cvec_X* self); -void cvec_X_pop_back(cvec_X* self); // alias for pop +void cvec_X_pop_back(cvec_X* self); // alias for pop -cvec_X_iter cvec_X_insert(cvec_X* self, intptr_t idx, i_val value); // move value +cvec_X_iter cvec_X_insert(cvec_X* self, intptr_t idx, i_val value); // move value cvec_X_iter cvec_X_insert_n(cvec_X* self, intptr_t idx, const i_val[] arr, intptr_t n); // move n values -cvec_X_iter cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value); // move value +cvec_X_iter cvec_X_insert_at(cvec_X* self, cvec_X_iter it, i_val value); // move value cvec_X_iter cvec_X_insert_range(cvec_X* self, i_val* pos, const i_val* p1, const i_val* p2); -- cgit v1.2.3 From dc2c5fa4f1b319988c622f6172926652cabfd1aa Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 3 Feb 2023 20:08:03 +0100 Subject: Feature completed cspan. --- docs/cspan_api.md | 17 +++---- include/stc/cspan.h | 120 +++++++++++++++-------------------------------- misc/examples/multidim.c | 3 +- misc/tests/cspan_test.c | 8 ++-- 4 files changed, 52 insertions(+), 96 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 70587f3e..e8c53965 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -35,18 +35,19 @@ ValueType* cspan_at(SpanTypeN* self, intptr_t x, ...); // at(): num ValueType* cspan_front(SpanTypeN* self); ValueType* cspan_back(SpanTypeN* self); + // general slicing: create a subspan. can do the same as submd() and subspan(). +SpanTypeN cspan_slice(T SpanTypeN, SpanTypeM* parent, {x0,x1}, {y0,y1}, ...); // {v} reduces rank. {v,-1} slice to end. + // return a subspan of lower rank: -SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. -SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. +SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. +SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. SpanTypeN cspan_submd5(SpanType5* self, intptr_t x, ...); -void cspan_slice(SpanTypeN* self, {x0,x1}, {y0,y1},...); // slice a span to make it a subspan of same rank - // return a subspan of same rank. Similar to e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); -SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); -SpanType2 cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count); -SpanType3 cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count); +SpanType cspan_subspan(SpanType* self, intptr_t offset, intptr_t count); +SpanType2 cspan_subspan2(SpanType2 self, intptr_t offset, intptr_t count); +SpanType3 cspan_subspan3(SpanType3 self, intptr_t offset, intptr_t count); SpanTypeN_iter SpanType_begin(const SpanTypeN* self); SpanTypeN_iter SpanType_end(const SpanTypeN* self); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 78c92520..94415df7 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -74,10 +74,10 @@ int demo2() { STC_INLINE Self Self##_from_n(Self##_raw* raw, const intptr_t n) { \ return (Self){.data=raw, .dim={(int32_t)n}}; \ } \ - STC_INLINE Self Self##_subslice_(Self##_value* v, const int32_t dim[], const int32_t stri[], \ + STC_INLINE Self Self##_slice_(Self##_value* v, const int32_t dim[], const int32_t stri[], \ const int rank, const int32_t a[][2]) { \ Self s = {.data=v}; int outrank; \ - s.data += _cspan_subslice(s.dim, s.stride.d, &outrank, dim, stri, rank, a); \ + s.data += _cspan_slice(s.dim, s.stride.d, &outrank, dim, stri, rank, a); \ c_ASSERT(outrank == RANK); \ return s; \ } \ @@ -90,7 +90,7 @@ int demo2() { return it; \ } \ STC_INLINE void Self##_next(Self##_iter* it) { \ - it->ref += _cspan_next_##RANK(RANK, it->pos, it->_s->dim, it->_s->stride.d); \ + it->ref += _cspan_next##RANK(RANK, it->pos, it->_s->dim, it->_s->stride.d); \ if (it->pos[0] == it->_s->dim[0]) it->ref = NULL; \ } \ struct stc_nostruct @@ -104,8 +104,7 @@ typedef struct { int32_t d[3]; } cspan_idx3; typedef struct { int32_t d[4]; } cspan_idx4; typedef struct { int32_t d[5]; } cspan_idx5; typedef struct { int32_t d[6]; } cspan_idx6; -#define c_END -1 -#define c_ALL 0,c_END +#define c_ALL 0,-1 #define cspan_md(array, ...) \ {.data=array, .dim={__VA_ARGS__}, .stride={.d={__VA_ARGS__}}} @@ -114,10 +113,10 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_make(SpanType, ...) \ {.data=(SpanType##_value[])__VA_ARGS__, .dim={sizeof((SpanType##_value[])__VA_ARGS__)/sizeof(SpanType##_value)}} -#define cspan_subslice(OutSpan, parent, ...) \ - OutSpan##_subslice_((parent)->data, (parent)->dim, (parent)->stride.d, cspan_rank(parent) + \ - c_static_assert(cspan_rank(parent) == sizeof((int32_t[][2]){__VA_ARGS__})/sizeof(int32_t[2])), \ - (const int32_t[][2]){__VA_ARGS__}) +#define cspan_slice(OutSpan, parent, ...) \ + OutSpan##_slice_((parent)->data, (parent)->dim, (parent)->stride.d, cspan_rank(parent) + \ + c_static_assert(cspan_rank(parent) == sizeof((int32_t[][2]){__VA_ARGS__})/sizeof(int32_t[2])), \ + (const int32_t[][2]){__VA_ARGS__}) /* create a cspan from a cvec, cstack, cdeq, cqueue, or cpque (heap) */ #define cspan_from(container) \ @@ -129,29 +128,33 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_size(self) _cspan_size((self)->dim, cspan_rank(self)) #define cspan_rank(self) c_ARRAYLEN((self)->dim) -#define cspan_idx(self, ...) \ - c_PASTE(_cspan_i, c_NUMARGS(__VA_ARGS__))((self)->dim, (self)->stride, __VA_ARGS__) - -#define cspan_index(self, ...) \ - (_cspan_index(c_NUMARGS(__VA_ARGS__), (self)->dim, (self)->stride.d, (int32_t[]){__VA_ARGS__}) + \ +#define cspan_index(self, ...) c_PASTE(cspan_idx_, c_NUMARGS(__VA_ARGS__))(self, __VA_ARGS__) +#define cspan_idx_1 cspan_idx_4 +#define cspan_idx_2 cspan_idx_4 +#define cspan_idx_3 cspan_idx_4 +#define cspan_idx_4(self, ...) \ + c_PASTE(_cspan_idx, c_NUMARGS(__VA_ARGS__))((self)->dim, (self)->stride, __VA_ARGS__) +#define cspan_idx_5(self, ...) \ + (_cspan_idxN(c_NUMARGS(__VA_ARGS__), (self)->dim, (self)->stride.d, (int32_t[]){__VA_ARGS__}) + \ c_static_assert(cspan_rank(self) == c_NUMARGS(__VA_ARGS__))) +#define cspan_idx_6 cspan_idx_5 #define cspan_at(self, ...) ((self)->data + cspan_index(self, __VA_ARGS__)) -#define cspan_item(self, ...) ((self)->data + cspan_idx(self, __VA_ARGS__)) // same as cspan_at(), only for rank <= 5 #define cspan_front(self) ((self)->data) #define cspan_back(self) ((self)->data + cspan_size(self) - 1) -// cspan_subspanN. for N > 3, use cspan_slice(&ms4, {offset, offset + count}, {0}, {0}, {0}); - +// cspan_subspanN. (N<5) Optimized, but same as e.g. cspan_slice(Span2, &ms4, {offset, offset + count}, {c_ALL}, {c_ALL}); #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]}, .stride={(self)->stride}} #define cspan_subspan3(self, offset, count) \ {.data=cspan_at(self, offset, 0, 0), .dim={count, (self)->dim[1], (self)->dim[2]}, .stride={(self)->stride}} +#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]}, \ + .stride={(self)->stride}} // cspan_submdN: return reduced rank - #define cspan_submd4(...) c_MACRO_OVERLOAD(cspan_submd4, __VA_ARGS__) #define cspan_submd3(...) c_MACRO_OVERLOAD(cspan_submd3, __VA_ARGS__) #define cspan_submd2(self, x) \ @@ -169,50 +172,24 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_submd4_4(self, x, y, z) \ {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}} -#define cspan_submd5_2(self, x) \ - {.data=cspan_at(self, x, 0, 0, 0, 0), .dim={(self)->dim[1], (self)->dim[2], (self)->dim[3], (self)->dim[4]}, \ - .stride={.d={0, (self)->stride.d[2], (self)->stride.d[3], (self)->stride.d[4]}}} -#define cspan_submd5_3(self, x, y) \ - {.data=cspan_at(self, x, y, 0, 0, 0), .dim={(self)->dim[2], (self)->dim[3], (self)->dim[4]}, \ - .stride={.d={0, (self)->stride.d[3], (self)->stride.d[4]}}} -#define cspan_submd5_4(self, x, y, z) \ - {.data=cspan_at(self, x, y, z, 0, 0), .dim={(self)->dim[3], (self)->dim[4]}, .stride={.d={0, (self)->stride.d[4]}}} -#define cspan_submd5_5(self, x, y, z, w) \ - {.data=cspan_at(self, x, y, z, w, 0), .dim={(self)->dim[4]}} - -// cspan_slice: -// e.g.: cspan_slice(&ms3, {1,3}, {0,-1}, {1,4}); - -#define cspan_slice(self, ...) \ - ((void)((self)->data += _cspan_slice((self)->dim, (self)->stride.d, \ - cspan_rank(self), (const int32_t[][2]){__VA_ARGS__}) + \ - c_static_assert(cspan_rank(self) == \ - sizeof((const int32_t[][2]){__VA_ARGS__})/sizeof(int32_t[2])))) - // FUNCTIONS -STC_INLINE intptr_t _cspan_i1(const int32_t dim[1], const cspan_idx1 stri, int32_t x) +STC_INLINE intptr_t _cspan_idx1(const int32_t dim[1], const cspan_idx1 stri, int32_t x) { c_ASSERT(c_LTu(x, dim[0])); return x; } -STC_INLINE intptr_t _cspan_i2(const int32_t dim[2], const cspan_idx2 stri, int32_t x, int32_t y) +STC_INLINE intptr_t _cspan_idx2(const int32_t dim[2], const cspan_idx2 stri, int32_t x, int32_t y) { c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1])); return (intptr_t)stri.d[1]*x + y; } -STC_INLINE intptr_t _cspan_i3(const int32_t dim[3], const cspan_idx3 stri, int32_t x, int32_t y, int32_t z) { +STC_INLINE intptr_t _cspan_idx3(const int32_t dim[3], const cspan_idx3 stri, int32_t x, int32_t y, int32_t z) { c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1]) && c_LTu(z, dim[2])); return (intptr_t)stri.d[2]*(stri.d[1]*x + y) + z; } -STC_INLINE intptr_t _cspan_i4(const int32_t dim[4], const cspan_idx4 stri, int32_t x, int32_t y, - int32_t z, int32_t w) { +STC_INLINE intptr_t _cspan_idx4(const int32_t dim[4], const cspan_idx4 stri, int32_t x, int32_t y, + int32_t z, int32_t w) { c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1]) && c_LTu(z, dim[2]) && c_LTu(w, dim[3])); return (intptr_t)stri.d[3]*(stri.d[2]*(stri.d[1]*x + y) + z) + w; } -STC_INLINE intptr_t _cspan_i5(const int32_t dim[4], const cspan_idx4 stri, int32_t x, int32_t y, int32_t z, - int32_t w, int32_t v) { - c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1]) && c_LTu(z, dim[2]) && c_LTu(w, dim[3]) && c_LTu(v, dim[4])); - return (intptr_t)stri.d[4]*(stri.d[3]*(stri.d[2]*(stri.d[1]*x + y) + z) + w) + v; -} - -STC_INLINE intptr_t _cspan_index(int rank, const int32_t dim[], const int32_t stri[], const int32_t a[]) { +STC_INLINE intptr_t _cspan_idxN(int rank, const int32_t dim[], const int32_t stri[], const int32_t a[]) { intptr_t off = a[0]; bool ok = c_LTu(a[0], dim[0]); for (int i = 1; i < rank; ++i) { @@ -230,12 +207,13 @@ STC_INLINE intptr_t _cspan_size(const int32_t dim[], int rank) { return sz; } -#define _cspan_next_1(r, pos, d, s) (++pos[0], 1) -#define _cspan_next_3 _cspan_next_2 -#define _cspan_next_4 _cspan_next_2 -#define _cspan_next_5 _cspan_next_2 +#define _cspan_next1(r, pos, d, s) (++pos[0], 1) +#define _cspan_next3 _cspan_next2 +#define _cspan_next4 _cspan_next2 +#define _cspan_next5 _cspan_next2 +#define _cspan_next6 _cspan_next2 -STC_INLINE intptr_t _cspan_next_2(int rank, int32_t pos[], const int32_t dim[], const int32_t stride[]) { +STC_INLINE intptr_t _cspan_next2(int rank, int32_t pos[], const int32_t dim[], const int32_t stride[]) { intptr_t off = 1, rs = 1; ++pos[rank - 1]; while (--rank && pos[rank] == dim[rank]) { @@ -247,30 +225,10 @@ STC_INLINE intptr_t _cspan_next_2(int rank, int32_t pos[], const int32_t dim[], return off; } -STC_INLINE intptr_t _cspan_slice(int32_t dim[], const int32_t stri[], const int rank, const int32_t a[][2]) { - intptr_t off = 0; - bool ok = true; - for (int i = 0; i < rank; ++i) { - off *= stri[i]; - off += a[i][0]; - int32_t t; - switch (a[i][1]) { - case 0: t = a[i][0] + 1; break; - case -1: t = dim[i]; break; - default: t = a[i][1]; - } - dim[i] = t - a[i][0]; - ok &= c_LTu(0, dim[i]); - } - c_ASSERT(ok); - return off; -} - -STC_INLINE intptr_t _cspan_subslice(int32_t odim[], int32_t ostri[], int* orank, - const int32_t dim[], const int32_t stri[], - int rank, const int32_t a[][2]) { - intptr_t off = a[0][0]; - intptr_t s = 1; +STC_INLINE intptr_t _cspan_slice(int32_t odim[], int32_t ostri[], int* orank, + const int32_t dim[], const int32_t stri[], + int rank, const int32_t a[][2]) { + intptr_t off = 0, s = 1; int i = 0, j = 0, ok = true; for (; i < rank; ++i) { off *= stri[i]; @@ -283,11 +241,11 @@ STC_INLINE intptr_t _cspan_subslice(int32_t odim[], int32_t ostri[], int* orank, } odim[j] = t - a[i][0]; ostri[j] = s*stri[i]; + ok &= c_LTu(0, odim[j]) & !c_LTu(dim[i], t); s = 1; ++j; - ok &= c_LTu(0, odim[i]) & !c_LTu(dim[i], t); } *orank = j; - c_ASSERT(ok); /* input indices ok */ + c_ASSERT(ok); return off; } #endif diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index 49b24172..49d7fbc4 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -5,7 +5,6 @@ #include using_cspan3(ispan, int); -#define c_ALL 0,-1 int main() { @@ -32,7 +31,7 @@ int main() puts("ss3 = ms3[:, 1:3, 1:3]"); ispan3 ss3 = ms3; //cspan_slice(&ss3, {c_ALL}, {1,3}, {1,3}); - ss3 = cspan_subslice(ispan3, &ms3, {c_ALL}, {1,3}, {1,3}); + ss3 = cspan_slice(ispan3, &ms3, {c_ALL}, {1,3}, {1,3}); for (int i=0; i != ss3.dim[0]; i++) { for (int j=0; j != ss3.dim[1]; j++) { diff --git a/misc/tests/cspan_test.c b/misc/tests/cspan_test.c index cd6a1271..044ce629 100644 --- a/misc/tests/cspan_test.c +++ b/misc/tests/cspan_test.c @@ -31,8 +31,7 @@ CTEST(cspan, slice) { } } - intspan2 m2 = m1; - cspan_slice(&m2, {c_ALL}, {2,4}); + intspan2 m2 = cspan_slice(intspan2, &m1, {c_ALL}, {2,4}); size_t sum2 = 0; for (size_t i = 0; i < m2.dim[0]; ++i) { @@ -54,7 +53,7 @@ CTEST(cspan, slice2) { cstack_int_push(&stack, i); intspan3 ms3 = cspan_md(stack.data, 10, 20, 30); - cspan_slice(&ms3, {1,4}, {3,7}, {20,24}); + ms3 = cspan_slice(intspan3, &ms3, {1,4}, {3,7}, {20,24}); size_t sum = 0; for (size_t i = 0; i < ms3.dim[0]; ++i) { @@ -98,8 +97,7 @@ CTEST_SETUP(cspan_cube) { c_FORRANGE (i, 0, ms3.dim[0], TSIZE) { c_FORRANGE (j, 0, ms3.dim[1], TSIZE) { c_FORRANGE (k, 0, ms3.dim[2], TSIZE) { - intspan3 tile = ms3; - cspan_slice(&tile, {i, i + TSIZE}, {j, j + TSIZE}, {k, k + TSIZE}); + intspan3 tile = cspan_slice(intspan3, &ms3, {i, i + TSIZE}, {j, j + TSIZE}, {k, k + TSIZE}); Tiles_push(&_self->tiles, tile); } } -- cgit v1.2.3 From cd806510c7c77c0618af58bd804e36f2bad6d219 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 3 Feb 2023 22:08:54 +0100 Subject: More cspan docs fixes. --- docs/cspan_api.md | 65 ++++++++++++++++++++++++++++------------------------- include/stc/cspan.h | 3 ++- 2 files changed, 37 insertions(+), 31 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index e8c53965..8321b1e5 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -31,23 +31,24 @@ intptr_t cspan_size(const SpanTypeN* self); // return nu unsigned cspan_rank(const SpanTypeN* self); // return number of dimensions intptr_t cspan_index(const SpanTypeN* self, intptr_t x, ..); // index of element -ValueType* cspan_at(SpanTypeN* self, intptr_t x, ...); // at(): num of args specifies rank of input span. -ValueType* cspan_front(SpanTypeN* self); -ValueType* cspan_back(SpanTypeN* self); +ValueType* cspan_at(const SpanTypeN* self, intptr_t x, ...); // at(): num of args specifies rank of input span. +ValueType* cspan_front(const SpanTypeN* self); +ValueType* cspan_back(const SpanTypeN* self); - // general slicing: create a subspan. can do the same as submd() and subspan(). -SpanTypeN cspan_slice(T SpanTypeN, SpanTypeM* parent, {x0,x1}, {y0,y1}, ...); // {v} reduces rank. {v,-1} slice to end. + // general slicing to create a subspan. + // {ind} reduces rank. {ind,c_END} slice to end. {c_ALL} take the full extent. +SpanTypeN cspan_slice(T SpanTypeN, const SpanTypeM* parent, {x0,x1}, {y0,y1}, ...); - // return a subspan of lower rank: -SpanType cspan_submd2(SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. -SpanTypeN cspan_submd3(SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. -SpanTypeN cspan_submd4(SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. -SpanTypeN cspan_submd5(SpanType5* self, intptr_t x, ...); + // create a subspan of lower rank. Like e.g. cspan_slice(Span2, &ms3, {x}, {c_ALL}, {c_ALL}); +SpanType cspan_submd2(const SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. +SpanTypeN cspan_submd3(const SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. +SpanTypeN cspan_submd4(const SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. +SpanTypeN cspan_submd5(const SpanType5* self, intptr_t x, ...); - // return a subspan of same rank. Similar to e.g. cspan_slice(&ms3, {offset, offset+count}, {0}, {0}); -SpanType cspan_subspan(SpanType* self, intptr_t offset, intptr_t count); -SpanType2 cspan_subspan2(SpanType2 self, intptr_t offset, intptr_t count); -SpanType3 cspan_subspan3(SpanType3 self, intptr_t offset, intptr_t count); + // create a subspan of same rank. Like e.g. cspan_slice(Span3, &ms3, {off, off+count}, {c_ALL}, {c_ALL}); +SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); +SpanType2 cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count); +SpanType3 cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count); SpanTypeN_iter SpanType_begin(const SpanTypeN* self); SpanTypeN_iter SpanType_end(const SpanTypeN* self); @@ -59,30 +60,34 @@ void SpanType_next(SpanTypeN_iter* it); |:------------------|:-----------------------------------------------|:---------------------| | SpanTypeN | `struct { ValueType *data; uint32_t dim[N]; }` | SpanType with rank N | | SpanTypeN`_value` | `ValueType` | The ValueType | -| SpanTypeN`_iter` | `struct { ValueType *ref; ... }` | Iterator type | +| `c_ALL` | `0,-1` | Full extent | +| `c_END` | `-1` | End of extent | ## Example 1 The *cspan_slice()* function is similar to pythons numpy multi-dimensional arrays slicing, e.g.: ```py import numpy as np -ms3 = np.array((1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24), int) -ms3 = np.reshape(ms3, (2, 3, 4)) -ss3 = ms3[:, 1:3, 2:] -ss2 = ss3[1] +if __name__ == '__main__': + ms3 = np.array((1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24), int) -for i in range(ss2.shape[0]): - for j in range(ss2.shape[1]): - print(" {}".format(ss2[i, j]), end='') -print('') + ms3 = np.reshape(ms3, (2, 3, 4)) + ss3 = ms3[:, 1:3, 2:] + ss2 = ss3[1] + + for i in range(ss2.shape[0]): + for j in range(ss2.shape[1]): + print(" {}".format(ss2[i, j]), end='') + print('') + + for i in ss2.flat: + print(" {}".format(i), end='') -for i in ss2.flat: - print(" {}".format(i), end='') # 19 20 23 24 # 19 20 23 24 ``` -... can be done in C with STC: +... can be done in C with cspan: ```c #include #include @@ -91,8 +96,8 @@ using_cspan3(myspan, int); // define myspan, myspan2, myspan3. int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24}; - myspan3 ms3 = cspan_md(arr, 2, 3, 4), ss3 = ms3; - cspan_slice(&ss3, {0}, {1,3}, {2,}); + myspan3 ms3 = cspan_md(arr, 2, 3, 4); + myspan3 ss3 = cspan_slice(myspan3, &ms3, {c_ALL}, {1,3}, {2,c_END}); myspan2 ss2 = cspan_submd3(&ss3, 1); c_FORRANGE (i, ss2.dim[0]) @@ -104,7 +109,7 @@ int main() { fmt_print(" {}", *i.ref); } ``` -... or (mostly) in C++23: +... and (almost) in C++23: ```c++ #include #include @@ -122,7 +127,7 @@ int main() { std::print(" {}", ss2[i, j]); std::println(); - // mdspan can't printed as a flat array, afaik. + // std::mdspan can't be iterated as a flat container! } ``` ## Example 2 diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 94415df7..315465db 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -104,7 +104,8 @@ typedef struct { int32_t d[3]; } cspan_idx3; typedef struct { int32_t d[4]; } cspan_idx4; typedef struct { int32_t d[5]; } cspan_idx5; typedef struct { int32_t d[6]; } cspan_idx6; -#define c_ALL 0,-1 +#define c_END -1 +#define c_ALL 0,c_END #define cspan_md(array, ...) \ {.data=array, .dim={__VA_ARGS__}, .stride={.d={__VA_ARGS__}}} -- cgit v1.2.3 From 2f370b34484e63359f9fd2850b72d3d1d8dfc32a Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Fri, 3 Feb 2023 22:37:59 +0100 Subject: Renamed dim to shape in cspan. Not 100% sure it will survive. --- docs/cspan_api.md | 12 +++---- include/stc/cspan.h | 94 ++++++++++++++++++++++++------------------------ misc/examples/multidim.c | 16 ++++----- misc/tests/cspan_test.c | 26 +++++++------- 4 files changed, 74 insertions(+), 74 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 8321b1e5..66a7b01b 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -58,7 +58,7 @@ void SpanType_next(SpanTypeN_iter* it); | Type name | Type definition | Used to represent... | |:------------------|:-----------------------------------------------|:---------------------| -| SpanTypeN | `struct { ValueType *data; uint32_t dim[N]; }` | SpanType with rank N | +| SpanTypeN | `struct { ValueType *data; uint32_t shape[N]; }` | SpanType with rank N | | SpanTypeN`_value` | `ValueType` | The ValueType | | `c_ALL` | `0,-1` | Full extent | | `c_END` | `-1` | End of extent | @@ -100,8 +100,8 @@ int main() { myspan3 ss3 = cspan_slice(myspan3, &ms3, {c_ALL}, {1,3}, {2,c_END}); myspan2 ss2 = cspan_submd3(&ss3, 1); - c_FORRANGE (i, ss2.dim[0]) - c_FORRANGE (j, ss2.dim[1]) + c_FORRANGE (i, ss2.shape[0]) + c_FORRANGE (j, ss2.shape[1]) fmt_print(" {}", *cspan_at(&ss2, i, j)); puts(""); @@ -163,9 +163,9 @@ int main() fmt_print("{} ", *i.ref); puts("\niterate span3 by dimensions:"); - c_FORRANGE (i, span3.dim[0]) { - c_FORRANGE (j, span3.dim[1]) { - c_FORRANGE (k, span3.dim[2]) + c_FORRANGE (i, span3.shape[0]) { + c_FORRANGE (j, span3.shape[1]) { + c_FORRANGE (k, span3.shape[2]) fmt_printf(" {:2}", *cspan_at(&span3, i, j, k)); printf(" |"); } diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 315465db..3ddc9742 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -32,8 +32,8 @@ int demo1() { float raw[4*5]; Span2f ms = cspan_md(raw, 4, 5); - for (int i=0; iref += _cspan_next##RANK(RANK, it->pos, it->_s->dim, it->_s->stride.d); \ - if (it->pos[0] == it->_s->dim[0]) it->ref = NULL; \ + it->ref += _cspan_next##RANK(RANK, it->pos, it->_s->shape, it->_s->stride.d); \ + if (it->pos[0] == it->_s->shape[0]) it->ref = NULL; \ } \ struct stc_nostruct @@ -108,35 +108,35 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define c_ALL 0,c_END #define cspan_md(array, ...) \ - {.data=array, .dim={__VA_ARGS__}, .stride={.d={__VA_ARGS__}}} + {.data=array, .shape={__VA_ARGS__}, .stride={.d={__VA_ARGS__}}} /* For static initialization, use cspan_make(). c_make() for non-static only. */ #define cspan_make(SpanType, ...) \ - {.data=(SpanType##_value[])__VA_ARGS__, .dim={sizeof((SpanType##_value[])__VA_ARGS__)/sizeof(SpanType##_value)}} + {.data=(SpanType##_value[])__VA_ARGS__, .shape={sizeof((SpanType##_value[])__VA_ARGS__)/sizeof(SpanType##_value)}} #define cspan_slice(OutSpan, parent, ...) \ - OutSpan##_slice_((parent)->data, (parent)->dim, (parent)->stride.d, cspan_rank(parent) + \ + OutSpan##_slice_((parent)->data, (parent)->shape, (parent)->stride.d, cspan_rank(parent) + \ c_static_assert(cspan_rank(parent) == sizeof((int32_t[][2]){__VA_ARGS__})/sizeof(int32_t[2])), \ (const int32_t[][2]){__VA_ARGS__}) /* create a cspan from a cvec, cstack, cdeq, cqueue, or cpque (heap) */ #define cspan_from(container) \ - {.data=(container)->data, .dim={(int32_t)(container)->_len}} + {.data=(container)->data, .shape={(int32_t)(container)->_len}} #define cspan_from_array(array) \ - {.data=(array) + c_static_assert(sizeof(array) != sizeof(void*)), .dim={c_ARRAYLEN(array)}} + {.data=(array) + c_static_assert(sizeof(array) != sizeof(void*)), .shape={c_ARRAYLEN(array)}} -#define cspan_size(self) _cspan_size((self)->dim, cspan_rank(self)) -#define cspan_rank(self) c_ARRAYLEN((self)->dim) +#define cspan_size(self) _cspan_size((self)->shape, cspan_rank(self)) +#define cspan_rank(self) c_ARRAYLEN((self)->shape) #define cspan_index(self, ...) c_PASTE(cspan_idx_, c_NUMARGS(__VA_ARGS__))(self, __VA_ARGS__) #define cspan_idx_1 cspan_idx_4 #define cspan_idx_2 cspan_idx_4 #define cspan_idx_3 cspan_idx_4 #define cspan_idx_4(self, ...) \ - c_PASTE(_cspan_idx, c_NUMARGS(__VA_ARGS__))((self)->dim, (self)->stride, __VA_ARGS__) + c_PASTE(_cspan_idx, c_NUMARGS(__VA_ARGS__))((self)->shape, (self)->stride, __VA_ARGS__) #define cspan_idx_5(self, ...) \ - (_cspan_idxN(c_NUMARGS(__VA_ARGS__), (self)->dim, (self)->stride.d, (int32_t[]){__VA_ARGS__}) + \ + (_cspan_idxN(c_NUMARGS(__VA_ARGS__), (self)->shape, (self)->stride.d, (int32_t[]){__VA_ARGS__}) + \ c_static_assert(cspan_rank(self) == c_NUMARGS(__VA_ARGS__))) #define cspan_idx_6 cspan_idx_5 @@ -146,65 +146,65 @@ typedef struct { int32_t d[6]; } cspan_idx6; // cspan_subspanN. (N<5) Optimized, but same as e.g. cspan_slice(Span2, &ms4, {offset, offset + count}, {c_ALL}, {c_ALL}); #define cspan_subspan(self, offset, count) \ - {.data=cspan_at(self, offset), .dim={count}} + {.data=cspan_at(self, offset), .shape={count}} #define cspan_subspan2(self, offset, count) \ - {.data=cspan_at(self, offset, 0), .dim={count, (self)->dim[1]}, .stride={(self)->stride}} + {.data=cspan_at(self, offset, 0), .shape={count, (self)->shape[1]}, .stride={(self)->stride}} #define cspan_subspan3(self, offset, count) \ - {.data=cspan_at(self, offset, 0, 0), .dim={count, (self)->dim[1], (self)->dim[2]}, .stride={(self)->stride}} + {.data=cspan_at(self, offset, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2]}, .stride={(self)->stride}} #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]}, \ + {.data=cspan_at(self, offset, 0, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2], (self)->shape[3]}, \ .stride={(self)->stride}} // cspan_submdN: return reduced rank #define cspan_submd4(...) c_MACRO_OVERLOAD(cspan_submd4, __VA_ARGS__) #define cspan_submd3(...) c_MACRO_OVERLOAD(cspan_submd3, __VA_ARGS__) #define cspan_submd2(self, x) \ - {.data=cspan_at(self, x, 0), .dim={(self)->dim[1]}} + {.data=cspan_at(self, x, 0), .shape={(self)->shape[1]}} #define cspan_submd3_2(self, x) \ - {.data=cspan_at(self, x, 0, 0), .dim={(self)->dim[1], (self)->dim[2]}, \ + {.data=cspan_at(self, x, 0, 0), .shape={(self)->shape[1], (self)->shape[2]}, \ .stride={.d={0, (self)->stride.d[2]}}} #define cspan_submd3_3(self, x, y) \ - {.data=cspan_at(self, x, y, 0), .dim={(self)->dim[2]}} + {.data=cspan_at(self, x, y, 0), .shape={(self)->shape[2]}} #define cspan_submd4_2(self, x) \ - {.data=cspan_at(self, x, 0, 0, 0), .dim={(self)->dim[1], (self)->dim[2], (self)->dim[3]}, \ + {.data=cspan_at(self, x, 0, 0, 0), .shape={(self)->shape[1], (self)->shape[2], (self)->shape[3]}, \ .stride={.d={0, (self)->stride.d[2], (self)->stride.d[3]}}} #define cspan_submd4_3(self, x, y) \ - {.data=cspan_at(self, x, y, 0, 0), .dim={(self)->dim[2], (self)->dim[3]}, .stride={.d={0, (self)->stride.d[3]}}} + {.data=cspan_at(self, x, y, 0, 0), .shape={(self)->shape[2], (self)->shape[3]}, .stride={.d={0, (self)->stride.d[3]}}} #define cspan_submd4_4(self, x, y, z) \ - {.data=cspan_at(self, x, y, z, 0), .dim={(self)->dim[3]}} + {.data=cspan_at(self, x, y, z, 0), .shape={(self)->shape[3]}} // FUNCTIONS -STC_INLINE intptr_t _cspan_idx1(const int32_t dim[1], const cspan_idx1 stri, int32_t x) - { c_ASSERT(c_LTu(x, dim[0])); return x; } +STC_INLINE intptr_t _cspan_idx1(const int32_t shape[1], const cspan_idx1 stri, int32_t x) + { c_ASSERT(c_LTu(x, shape[0])); return x; } -STC_INLINE intptr_t _cspan_idx2(const int32_t dim[2], const cspan_idx2 stri, int32_t x, int32_t y) - { c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1])); return (intptr_t)stri.d[1]*x + y; } +STC_INLINE intptr_t _cspan_idx2(const int32_t shape[2], const cspan_idx2 stri, int32_t x, int32_t y) + { c_ASSERT(c_LTu(x, shape[0]) && c_LTu(y, shape[1])); return (intptr_t)stri.d[1]*x + y; } -STC_INLINE intptr_t _cspan_idx3(const int32_t dim[3], const cspan_idx3 stri, int32_t x, int32_t y, int32_t z) { - c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1]) && c_LTu(z, dim[2])); +STC_INLINE intptr_t _cspan_idx3(const int32_t shape[3], const cspan_idx3 stri, int32_t x, int32_t y, int32_t z) { + c_ASSERT(c_LTu(x, shape[0]) && c_LTu(y, shape[1]) && c_LTu(z, shape[2])); return (intptr_t)stri.d[2]*(stri.d[1]*x + y) + z; } -STC_INLINE intptr_t _cspan_idx4(const int32_t dim[4], const cspan_idx4 stri, int32_t x, int32_t y, +STC_INLINE intptr_t _cspan_idx4(const int32_t shape[4], const cspan_idx4 stri, int32_t x, int32_t y, int32_t z, int32_t w) { - c_ASSERT(c_LTu(x, dim[0]) && c_LTu(y, dim[1]) && c_LTu(z, dim[2]) && c_LTu(w, dim[3])); + c_ASSERT(c_LTu(x, shape[0]) && c_LTu(y, shape[1]) && c_LTu(z, shape[2]) && c_LTu(w, shape[3])); return (intptr_t)stri.d[3]*(stri.d[2]*(stri.d[1]*x + y) + z) + w; } -STC_INLINE intptr_t _cspan_idxN(int rank, const int32_t dim[], const int32_t stri[], const int32_t a[]) { +STC_INLINE intptr_t _cspan_idxN(int rank, const int32_t shape[], const int32_t stri[], const int32_t a[]) { intptr_t off = a[0]; - bool ok = c_LTu(a[0], dim[0]); + bool ok = c_LTu(a[0], shape[0]); for (int i = 1; i < rank; ++i) { off *= stri[i]; off += a[i]; - ok &= c_LTu(a[i], dim[i]); + ok &= c_LTu(a[i], shape[i]); } c_ASSERT(ok); return off; } -STC_INLINE intptr_t _cspan_size(const int32_t dim[], int rank) { - intptr_t sz = dim[0]; - while (rank-- > 1) sz *= dim[rank]; +STC_INLINE intptr_t _cspan_size(const int32_t shape[], int rank) { + intptr_t sz = shape[0]; + while (rank-- > 1) sz *= shape[rank]; return sz; } @@ -214,12 +214,12 @@ STC_INLINE intptr_t _cspan_size(const int32_t dim[], int rank) { #define _cspan_next5 _cspan_next2 #define _cspan_next6 _cspan_next2 -STC_INLINE intptr_t _cspan_next2(int rank, int32_t pos[], const int32_t dim[], const int32_t stride[]) { +STC_INLINE intptr_t _cspan_next2(int rank, int32_t pos[], const int32_t shape[], const int32_t stride[]) { intptr_t off = 1, rs = 1; ++pos[rank - 1]; - while (--rank && pos[rank] == dim[rank]) { + while (--rank && pos[rank] == shape[rank]) { pos[rank] = 0, ++pos[rank - 1]; - const intptr_t ds = rs*dim[rank]; + const intptr_t ds = rs*shape[rank]; rs *= stride[rank]; off += rs - ds; } @@ -227,7 +227,7 @@ STC_INLINE intptr_t _cspan_next2(int rank, int32_t pos[], const int32_t dim[], c } STC_INLINE intptr_t _cspan_slice(int32_t odim[], int32_t ostri[], int* orank, - const int32_t dim[], const int32_t stri[], + const int32_t shape[], const int32_t stri[], int rank, const int32_t a[][2]) { intptr_t off = 0, s = 1; int i = 0, j = 0, ok = true; @@ -237,12 +237,12 @@ STC_INLINE intptr_t _cspan_slice(int32_t odim[], int32_t ostri[], int* orank, int32_t t; switch (a[i][1]) { case 0: s *= stri[i]; continue; - case -1: t = dim[i]; break; + case -1: t = shape[i]; break; default: t = a[i][1]; break; } odim[j] = t - a[i][0]; ostri[j] = s*stri[i]; - ok &= c_LTu(0, odim[j]) & !c_LTu(dim[i], t); + ok &= c_LTu(0, odim[j]) & !c_LTu(shape[i], t); s = 1; ++j; } *orank = j; diff --git a/misc/examples/multidim.c b/misc/examples/multidim.c index 49d7fbc4..e61959ca 100644 --- a/misc/examples/multidim.c +++ b/misc/examples/multidim.c @@ -19,9 +19,9 @@ int main() ispan3 ms3 = cspan_md(v.data, 2, 3, 4); puts("ms3:"); - for (int i=0; i != ms3.dim[0]; i++) { - for (int j=0; j != ms3.dim[1]; j++) { - for (int k=0; k != ms3.dim[2]; k++) { + for (int i=0; i != ms3.shape[0]; i++) { + for (int j=0; j != ms3.shape[1]; j++) { + for (int k=0; k != ms3.shape[2]; k++) { printf(" %2d", *cspan_at(&ms3, i, j, k)); } puts(""); @@ -33,9 +33,9 @@ int main() //cspan_slice(&ss3, {c_ALL}, {1,3}, {1,3}); ss3 = cspan_slice(ispan3, &ms3, {c_ALL}, {1,3}, {1,3}); - for (int i=0; i != ss3.dim[0]; i++) { - for (int j=0; j != ss3.dim[1]; j++) { - for (int k=0; k != ss3.dim[2]; k++) { + for (int i=0; i != ss3.shape[0]; i++) { + for (int j=0; j != ss3.shape[1]; j++) { + for (int k=0; k != ss3.shape[2]; k++) { printf(" %2d", *cspan_at(&ss3, i, j, k)); } puts(""); @@ -51,8 +51,8 @@ int main() ispan2 ms2 = cspan_submd3(&ms3, 0); // write data using 2D view - for (int i=0; i != ms2.dim[0]; i++) - for (int j=0; j != ms2.dim[1]; j++) + for (int i=0; i != ms2.shape[0]; i++) + for (int j=0; j != ms2.shape[1]; j++) *cspan_at(&ms2, i, j) = i*1000 + j; puts("\nview data as 1D view:"); diff --git a/misc/tests/cspan_test.c b/misc/tests/cspan_test.c index 044ce629..9e33467c 100644 --- a/misc/tests/cspan_test.c +++ b/misc/tests/cspan_test.c @@ -9,11 +9,11 @@ CTEST(cspan, subdim) { int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; intspan3 m = cspan_md(array, 2, 2, 3); - for (size_t i = 0; i < m.dim[0]; ++i) { + for (size_t i = 0; i < m.shape[0]; ++i) { intspan2 sub_i = cspan_submd3(&m, i); - for (size_t j = 0; j < m.dim[1]; ++j) { + for (size_t j = 0; j < m.shape[1]; ++j) { intspan sub_i_j = cspan_submd2(&sub_i, j); - for (size_t k = 0; k < m.dim[2]; ++k) { + for (size_t k = 0; k < m.shape[2]; ++k) { ASSERT_EQ(*cspan_at(&sub_i_j, k), *cspan_at(&m, i, j, k)); } } @@ -25,8 +25,8 @@ CTEST(cspan, slice) { intspan2 m1 = cspan_md(array, 3, 4); size_t sum1 = 0; - for (size_t i = 0; i < m1.dim[0]; ++i) { - for (size_t j = 0; j < m1.dim[1]; ++j) { + for (size_t i = 0; i < m1.shape[0]; ++i) { + for (size_t j = 0; j < m1.shape[1]; ++j) { sum1 += *cspan_at(&m1, i, j); } } @@ -34,8 +34,8 @@ CTEST(cspan, slice) { intspan2 m2 = cspan_slice(intspan2, &m1, {c_ALL}, {2,4}); size_t sum2 = 0; - for (size_t i = 0; i < m2.dim[0]; ++i) { - for (size_t j = 0; j < m2.dim[1]; ++j) { + for (size_t i = 0; i < m2.shape[0]; ++i) { + for (size_t j = 0; j < m2.shape[1]; ++j) { sum2 += *cspan_at(&m2, i, j); } } @@ -56,9 +56,9 @@ CTEST(cspan, slice2) { ms3 = cspan_slice(intspan3, &ms3, {1,4}, {3,7}, {20,24}); size_t sum = 0; - for (size_t i = 0; i < ms3.dim[0]; ++i) { - for (size_t j = 0; j < ms3.dim[1]; ++j) { - for (size_t k = 0; k < ms3.dim[2]; ++k) { + for (size_t i = 0; i < ms3.shape[0]; ++i) { + for (size_t j = 0; j < ms3.shape[1]; ++j) { + for (size_t k = 0; k < ms3.shape[2]; ++k) { sum += *cspan_at(&ms3, i, j, k); } } @@ -94,9 +94,9 @@ CTEST_SETUP(cspan_cube) { intspan3 ms3 = cspan_md(_self->stack.data, CUBE, CUBE, CUBE); - c_FORRANGE (i, 0, ms3.dim[0], TSIZE) { - c_FORRANGE (j, 0, ms3.dim[1], TSIZE) { - c_FORRANGE (k, 0, ms3.dim[2], TSIZE) { + c_FORRANGE (i, 0, ms3.shape[0], TSIZE) { + c_FORRANGE (j, 0, ms3.shape[1], TSIZE) { + c_FORRANGE (k, 0, ms3.shape[2], TSIZE) { intspan3 tile = cspan_slice(intspan3, &ms3, {i, i + TSIZE}, {j, j + TSIZE}, {k, k + TSIZE}); Tiles_push(&_self->tiles, tile); } -- cgit v1.2.3 From 51961138b16fbebacd76ce465fb979830d0f9701 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sat, 4 Feb 2023 00:14:45 +0100 Subject: Minor docs update. --- docs/cspan_api.md | 6 ++---- include/stc/cspan.h | 7 ++----- 2 files changed, 4 insertions(+), 9 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 66a7b01b..616b090e 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -16,7 +16,6 @@ using_cspan(SpanTypeN, ValueType, Rank); // define multi-dimensional span with R using_cspan2(S, ValueType); // define span types S, S2 with ranks 1, 2. using_cspan3(S, ValueType); // define span types S, S2, S3 with ranks 1, 2, 3. using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. -using_cspan5(S, ValueType); // define span types S, S2, .., S5 with ranks 1, 2, 3, 4, 5. ``` ## Methods Note that `cspan_md()`, `cmake_from*()`, `cspan_atN()`, `and cspan_subspanN()` require a (safe) cast to its span-type @@ -35,15 +34,14 @@ ValueType* cspan_at(const SpanTypeN* self, intptr_t x, ...); // at(): num ValueType* cspan_front(const SpanTypeN* self); ValueType* cspan_back(const SpanTypeN* self); - // general slicing to create a subspan. - // {ind} reduces rank. {ind,c_END} slice to end. {c_ALL} take the full extent. + // general index slicing to create a subspan. + // {x} reduces rank. {x,c_END} slice to end. {c_ALL} take the full extent. SpanTypeN cspan_slice(T SpanTypeN, const SpanTypeM* parent, {x0,x1}, {y0,y1}, ...); // create a subspan of lower rank. Like e.g. cspan_slice(Span2, &ms3, {x}, {c_ALL}, {c_ALL}); SpanType cspan_submd2(const SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. SpanTypeN cspan_submd3(const SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. SpanTypeN cspan_submd4(const SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. -SpanTypeN cspan_submd5(const SpanType5* self, intptr_t x, ...); // create a subspan of same rank. Like e.g. cspan_slice(Span3, &ms3, {off, off+count}, {c_ALL}, {c_ALL}); SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 3ddc9742..bee67863 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -134,10 +134,10 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_idx_2 cspan_idx_4 #define cspan_idx_3 cspan_idx_4 #define cspan_idx_4(self, ...) \ - c_PASTE(_cspan_idx, c_NUMARGS(__VA_ARGS__))((self)->shape, (self)->stride, __VA_ARGS__) + c_PASTE(_cspan_idx, c_NUMARGS(__VA_ARGS__))((self)->shape, (self)->stride, __VA_ARGS__) // small/fast #define cspan_idx_5(self, ...) \ (_cspan_idxN(c_NUMARGS(__VA_ARGS__), (self)->shape, (self)->stride.d, (int32_t[]){__VA_ARGS__}) + \ - c_static_assert(cspan_rank(self) == c_NUMARGS(__VA_ARGS__))) + c_static_assert(cspan_rank(self) == c_NUMARGS(__VA_ARGS__))) // general #define cspan_idx_6 cspan_idx_5 #define cspan_at(self, ...) ((self)->data + cspan_index(self, __VA_ARGS__)) @@ -151,9 +151,6 @@ typedef struct { int32_t d[6]; } cspan_idx6; {.data=cspan_at(self, offset, 0), .shape={count, (self)->shape[1]}, .stride={(self)->stride}} #define cspan_subspan3(self, offset, count) \ {.data=cspan_at(self, offset, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2]}, .stride={(self)->stride}} -#define cspan_subspan4(self, offset, count) \ - {.data=cspan_at(self, offset, 0, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2], (self)->shape[3]}, \ - .stride={(self)->stride}} // cspan_submdN: return reduced rank #define cspan_submd4(...) c_MACRO_OVERLOAD(cspan_submd4, __VA_ARGS__) -- cgit v1.2.3 From 626b893b4d9e048c27571bfa28352914f2cd2bbc Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sat, 4 Feb 2023 16:40:39 +0100 Subject: More cspan docs updates. --- README.md | 11 +++--- docs/cspan_api.md | 107 +++++++++++++++++++++++++++------------------------- include/stc/cspan.h | 8 ++-- 3 files changed, 66 insertions(+), 60 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/README.md b/README.md index 63308051..a9d177e1 100644 --- a/README.md +++ b/README.md @@ -3,21 +3,22 @@ STC - Smart Template Containers for C ===================================== -News: Version 4.1 RC (Feb 2023) +News: Version 4.1 RC2 (Feb 2023) ------------------------------------------------ Major changes: - Signed sizes and indices for all containers (no more mixing unsigned/signed bugs). -- A new exciting [**cspan**](docs/cspan_api.md) single/multi-dimensional array view. +- A new exciting [**cspan**](docs/cspan_api.md) single/multi-dimensional array view (with numpy-like slicing). - Updates on cregex with several new unicode character classes. - Uppercase flow-control macros (ccommon.h). Lowercase macros are [still supported](include/stc/priv/altnames.h). +- Some API changes in cregex and cstr. - [See detailed changes for version 4](#version-4). Introduction ------------ STC is a *modern*, *templated*, *user-friendly*, *type-safe*, *very fast* and *compact* container library for C99. -The API is fairly similar to c++ STL, but a bit more uniform across the containers and takes -inspiration from Rust and Python as well. It is an advantage to know how these containers work in other languages, like -Java, C# or C++, but it's not required. +The API has similarities with c++ STL, but is more uniform across the containers and takes inspiration from Rust +and Python as well. It is an advantage to know how these containers work in other languages, like Java, C# or C++, +but it's not required. This library allows you to manage both trivial to very complex data in a wide variety of containers without the need for boilerplate code. You may specify element-cloning, -comparison, -destruction and diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 616b090e..650260a2 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -38,12 +38,12 @@ ValueType* cspan_back(const SpanTypeN* self); // {x} reduces rank. {x,c_END} slice to end. {c_ALL} take the full extent. SpanTypeN cspan_slice(T SpanTypeN, const SpanTypeM* parent, {x0,x1}, {y0,y1}, ...); - // create a subspan of lower rank. Like e.g. cspan_slice(Span2, &ms3, {x}, {c_ALL}, {c_ALL}); + // create a subspan of lower rank. Like e.g. cspan_slice(Span2, &ms4, {x}, {y}, {c_ALL}, {c_ALL}); SpanType cspan_submd2(const SpanType2* self, intptr_t x); // return a 1d subspan from a 2d span. SpanTypeN cspan_submd3(const SpanType3* self, intptr_t x, ...); // return a 1d or 2d subspan from a 3d span. SpanTypeN cspan_submd4(const SpanType4* self, intptr_t x, ...); // number of args determines rank of output span. - // create a subspan of same rank. Like e.g. cspan_slice(Span3, &ms3, {off, off+count}, {c_ALL}, {c_ALL}); + // create a subspan of same rank. Like e.g. cspan_slice(Span3, &ms3, {off,off+count}, {c_ALL}, {c_ALL}); SpanType cspan_subspan(const SpanType* self, intptr_t offset, intptr_t count); SpanType2 cspan_subspan2(const SpanType2 self, intptr_t offset, intptr_t count); SpanType3 cspan_subspan3(const SpanType3 self, intptr_t offset, intptr_t count); @@ -132,63 +132,68 @@ int main() { ```c #include #include -#define i_val float -#include -using_cspan3(Span, float); // Shorthand to define span types Span, Span2, and Span3. +using_cspan3(Span, int); // Shorthand to define Span, Span2, and Span3 int main() { - int xd = 6, yd = 4, zd = 3; - c_AUTO (cstack_float, vec) - { - c_FORRANGE (i, xd*yd*zd) - cstack_float_push(&vec, i); - - // define "span3[xd][yd][zd]" - Span3 span3 = cspan_md(vec.data, xd, yd, zd); - *cspan_at(&span3, 4, 3, 2) = 3.14159f; - fmt_print("index: {}", cspan_index(&span3, 4, 3, 2)); - - Span span1 = cspan_submd3(&span3, 4, 3); - printf("\niterate span1: "); - c_FOREACH (i, Span, span1) - fmt_print("{} ", *i.ref); - - Span2 span2 = cspan_submd3(&span3, 4); - printf("\niterate span2: "); - c_FOREACH (i, Span2, span2) - fmt_print("{} ", *i.ref); - - puts("\niterate span3 by dimensions:"); - c_FORRANGE (i, span3.shape[0]) { - c_FORRANGE (j, span3.shape[1]) { - c_FORRANGE (k, span3.shape[2]) - fmt_printf(" {:2}", *cspan_at(&span3, i, j, k)); - printf(" |"); - } - puts(""); - } + // c_make() can create any STC container/span from an initializer list: + Span span = c_make(Span, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, + 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24}); + // create a 3d cspan: + Span3 span3 = cspan_md(span.data, 2, 4, 3); + + // reduce rank: (i.e. span3[1]) + Span2 span2 = cspan_submd3(&span3, 1); - fmt_println("{}", *cspan_at(&span3, 4, 3, 2)); - fmt_println("{}", *cspan_at(&span2, 3, 2)); - fmt_println("{}", *cspan_at(&span1, 2)); + puts("\niterate span2 flat:"); + c_FOREACH (i, Span2, span2) + fmt_print(" {}", *i.ref); + puts(""); + + // slice without reducing rank: + Span3 ss3 = cspan_slice(Span3, &span3, {c_ALL}, {3,4}, {c_ALL}); + + puts("\niterate ss3 by dimensions:"); + c_FORRANGE (i, ss3.shape[0]) { + c_FORRANGE (j, ss3.shape[1]) { + c_FORRANGE (k, ss3.shape[2]) + fmt_print(" {:2}", *cspan_at(&ss3, i, j, k)); + fmt_print(" |"); + } + puts(""); } + // slice and reduce rank: + Span2 ss2 = cspan_slice(Span2, &span3, {c_ALL}, {3}, {c_ALL}); + + puts("\niterate ss2 by dimensions:"); + c_FORRANGE (i, ss2.shape[0]) { + c_FORRANGE (j, ss2.shape[1]) { + fmt_print(" {:2}", *cspan_at(&ss2, i, j)); + fmt_print(" |"); + } + puts(""); + } + + puts("\niterate ss2 flat:"); + c_FOREACH (i, Span2, ss2) + fmt_print(" {:2}", *i.ref); + puts(""); } ``` Output: ``` -index: 59 -iterate span1: 57 58 3.14159 -iterate span2: 48 49 50 51 52 53 54 55 56 57 58 3.14159 -iterate span3 by dimensions: - 0 1 2 | 3 4 5 | 6 7 8 | 9 10 11 | - 12 13 14 | 15 16 17 | 18 19 20 | 21 22 23 | - 24 25 26 | 27 28 29 | 30 31 32 | 33 34 35 | - 36 37 38 | 39 40 41 | 42 43 44 | 45 46 47 | - 48 49 50 | 51 52 53 | 54 55 56 | 57 58 3.14159 | - 60 61 62 | 63 64 65 | 66 67 68 | 69 70 71 | -3.14159 -3.14159 -3.14159 +iterate span2 flat: + 13 14 15 16 17 18 19 20 21 22 23 24 + +iterate ss3 by dimensions: + 10 11 12 | + 22 23 24 | + +iterate ss2 by dimensions: + 10 | 11 | 12 | + 22 | 23 | 24 | + +iterate ss2 flat: + 10 11 12 22 23 24 ``` diff --git a/include/stc/cspan.h b/include/stc/cspan.h index 30046898..68a13522 100644 --- a/include/stc/cspan.h +++ b/include/stc/cspan.h @@ -105,7 +105,7 @@ typedef struct { int32_t d[4]; } cspan_idx4; typedef struct { int32_t d[5]; } cspan_idx5; typedef struct { int32_t d[6]; } cspan_idx6; #define c_END -1 -#define c_ALL 0,c_END +#define c_ALL 0,-1 #define cspan_md(array, ...) \ {.data=array, .shape={__VA_ARGS__}, .stride={.d={__VA_ARGS__}}} @@ -144,7 +144,7 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_front(self) ((self)->data) #define cspan_back(self) ((self)->data + cspan_size(self) - 1) -// cspan_subspanN. (N<5) Optimized, but same as e.g. cspan_slice(Span2, &ms4, {offset, offset + count}, {c_ALL}, {c_ALL}); +// cspan_subspanN. (N<4) Optimized, same as e.g. cspan_slice(Span3, &ms3, {off,off+count}, {c_ALL}, {c_ALL}); #define cspan_subspan(self, offset, count) \ {.data=cspan_at(self, offset), .shape={count}} #define cspan_subspan2(self, offset, count) \ @@ -152,7 +152,7 @@ typedef struct { int32_t d[6]; } cspan_idx6; #define cspan_subspan3(self, offset, count) \ {.data=cspan_at(self, offset, 0, 0), .shape={count, (self)->shape[1], (self)->shape[2]}, .stride={(self)->stride}} -// cspan_submdN: return reduced rank +// cspan_submdN: reduce rank (N<5) Optimized, same as e.g. cspan_slice(Span2, &ms4, {x}, {y}, {c_ALL}, {c_ALL}); #define cspan_submd4(...) c_MACRO_OVERLOAD(cspan_submd4, __VA_ARGS__) #define cspan_submd3(...) c_MACRO_OVERLOAD(cspan_submd3, __VA_ARGS__) #define cspan_submd2(self, x) \ @@ -233,7 +233,7 @@ STC_INLINE intptr_t _cspan_slice(int32_t odim[], int32_t ostri[], int* orank, off *= stri[i]; off += a[i][0]; switch (a[i][1]) { - case 0: s *= stri[i]; continue; + case 0: s *= stri[i]; ok &= c_LTu(a[i][0], shape[i]); continue; case -1: t = shape[i]; break; default: t = a[i][1]; break; } -- cgit v1.2.3 From d2ff84c53aa9bd3857fdf22dcf7cd9398a4780be Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sat, 4 Feb 2023 23:24:54 +0100 Subject: Fix in ccommon.h to make MSVC work again (without -std:c11) + small adjustments. --- docs/cspan_api.md | 4 ++-- include/stc/cbits.h | 4 ++-- include/stc/ccommon.h | 2 +- misc/examples/make.sh | 12 ++++++------ misc/tests/ctest.h | 12 ++++++++---- 5 files changed, 19 insertions(+), 15 deletions(-) (limited to 'docs/cspan_api.md') diff --git a/docs/cspan_api.md b/docs/cspan_api.md index 650260a2..d0463b0a 100644 --- a/docs/cspan_api.md +++ b/docs/cspan_api.md @@ -18,8 +18,7 @@ using_cspan3(S, ValueType); // define span types S, S2, S3 with ran using_cspan4(S, ValueType); // define span types S, S2, S3, S4 with ranks 1, 2, 3, 4. ``` ## Methods -Note that `cspan_md()`, `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. +All functions are type-safe, and index arguments are side-effect safe. ```c SpanTypeN cspan_md(ValueType* data, intptr_t xdim, ...); // create a multi-dimensional cspan SpanType cspan_make(T SpanType, {v1, v2, ...}); // make a 1d-dimensional cspan from values @@ -129,6 +128,7 @@ int main() { } ``` ## Example 2 +Slicing cspan without and with reducing the rank (like numpy array slicing): ```c #include #include diff --git a/include/stc/cbits.h b/include/stc/cbits.h index 9f0afc9c..577ecb13 100644 --- a/include/stc/cbits.h +++ b/include/stc/cbits.h @@ -60,10 +60,10 @@ int main() { #define _cbits_bytes(n) (_cbits_words(n) * c_sizeof(uint64_t)) #if defined(__GNUC__) || defined(__clang__) - STC_INLINE int cpopcount64(uint64_t x) {return (int)__builtin_popcountll(x);} + STC_INLINE int cpopcount64(uint64_t x) {return __builtin_popcountll(x);} #elif defined(_MSC_VER) && defined(_WIN64) #include - STC_INLINE int cpopcount64(uint64_t x) {return __popcnt64(x);} + STC_INLINE int cpopcount64(uint64_t x) {return (int)__popcnt64(x);} #else STC_INLINE int cpopcount64(uint64_t x) { /* http://en.wikipedia.org/wiki/Hamming_weight */ x -= (x >> 1) & 0x5555555555555555; diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h index 30184407..b8ea6316 100644 --- a/include/stc/ccommon.h +++ b/include/stc/ccommon.h @@ -52,7 +52,7 @@ /* Macro overloading feature support based on: https://rextester.com/ONP80107 */ #define c_MACRO_OVERLOAD(name, ...) \ - c_PASTE(name##_, c_NUMARGS(__VA_ARGS__))(__VA_ARGS__) + c_PASTE(c_CONCAT(name,_), c_NUMARGS(__VA_ARGS__))(__VA_ARGS__) #define c_CONCAT(a, b) a ## b #define c_PASTE(a, b) c_CONCAT(a, b) #define c_EXPAND(...) __VA_ARGS__ diff --git a/misc/examples/make.sh b/misc/examples/make.sh index 0c4760a6..19a53880 100755 --- a/misc/examples/make.sh +++ b/misc/examples/make.sh @@ -6,14 +6,14 @@ if [ "$(uname)" = 'Linux' ]; then oflag='-o ' fi +cc=gcc; cflags="-s -O2 -std=c99 -Wconversion -Wpedantic -Wall -Wsign-compare -Wwrite-strings" #cc=gcc; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall $sanitize" -cc=gcc; cflags="-s -O2 -std=c99 -Wconversion -Wpedantic -Wall -Wsign-compare -Wwrite-strings" # -Wconversion #cc=tcc; cflags="-Wall -std=c99" #cc=clang; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -Wsign-compare -Wwrite-strings" #cc=clang; cflags="-s -O2 -std=c99 -Werror -Wfatal-errors -Wpedantic -Wall -DSTC_CSTR_V1 -DSTC_CSMAP_V1" #cc=gcc; cflags="-x c++ -s -O2 -Wall -std=c++20" #cc=g++; cflags="-x c++ -s -O2 -Wall" -#cc=cl; cflags="-O2 -nologo -W2 -MD" +#cc=cl; cflags="-O2 -nologo -W3 -MD" #cc=cl; cflags="-nologo -TP" #cc=cl; cflags="-nologo -std:c11" @@ -40,13 +40,13 @@ fi if [ $run = 0 ] ; then for i in *.c ; do - echo $comp -I../include $i $clibs $oflag$(basename $i .c).exe - $comp -I../include $i $clibs $oflag$(basename $i .c).exe + echo $comp -I../../include $i $clibs $oflag$(basename $i .c).exe + $comp -I../../include $i $clibs $oflag$(basename $i .c).exe done else for i in *.c ; do - echo $comp -I../include $i $clibs - $comp -I../include $i $clibs + echo $comp -I../../include $i $clibs + $comp -I../../include $i $clibs if [ -f $(basename -s .c $i).exe ]; then ./$(basename -s .c $i).exe; fi if [ -f ./a.exe ]; then ./a.exe; fi if [ -f ./a.out ]; then ./a.out; fi diff --git a/misc/tests/ctest.h b/misc/tests/ctest.h index 4d42216c..373cda0e 100644 --- a/misc/tests/ctest.h +++ b/misc/tests/ctest.h @@ -93,8 +93,10 @@ struct ctest { #ifdef __APPLE__ #define CTEST_IMPL_SECTION __attribute__ ((used, section ("__DATA, .ctest"), aligned(1))) -#else +#elif !defined _MSC_VER #define CTEST_IMPL_SECTION __attribute__ ((used, section (".ctest"), aligned(1))) +#else +#define CTEST_IMPL_SECTION #endif #define CTEST_IMPL_STRUCT(sname, tname, tskip, tdata, tsetup, tteardown) \ @@ -445,7 +447,7 @@ static void sighandler(int signum) const char msg_nocolor[] = "[SIGSEGV: Segmentation fault]\n"; const char* msg = color_output ? msg_color : msg_nocolor; - intptr_t n = write(STDOUT_FILENO, msg, (unsigned int)strlen(msg)); + intptr_t n = write(1, msg, (unsigned int)strlen(msg)); (void)n; /* "Unregister" the signal handler and send the signal back to the process * so it can terminate as expected */ @@ -457,8 +459,10 @@ static void sighandler(int signum) #endif int ctest_main(int argc, const char *argv[]); - -__attribute__((no_sanitize_address)) int ctest_main(int argc, const char *argv[]) +#ifdef __GNUC__ +__attribute__((no_sanitize_address)) +#endif +int ctest_main(int argc, const char *argv[]) { static int total = 0; static int num_ok = 0; -- cgit v1.2.3