Renamed "internal" csview member .str => .buf, as it is not null terminated like crawstr .str member.

5 files changed, 56 insertions, 56 deletions

diff --git a/include/stc/ccommon.h b/include/stc/ccommon.h
index e33e657a..5c5e87e6 100644
--- a/include/stc/ccommon.h
+++ b/include/stc/ccommon.h
@@ -133,7 +133,7 @@ typedef const char* ccharptr;
 #define c_sv(...) c_MACRO_OVERLOAD(c_sv, __VA_ARGS__)
 #define c_sv_1(literal) c_sv_2(literal, c_litstrlen(literal))
 #define c_sv_2(str, n) (c_LITERAL(csview){str, n})
-#define c_SV(sv) (int)(sv).size, (sv).str // printf("%.*s\n", c_SV(sv));
+#define c_SV(sv) (int)(sv).size, (sv).buf // printf("%.*s\n", c_SV(sv));
 
 #define c_rs(literal) c_rs_2(literal, c_litstrlen(literal))
 #define c_rs_2(str, n) (c_LITERAL(crawstr){str, n})
diff --git a/include/stc/cregex.h b/include/stc/cregex.h
index bce94b04..c8ad6dbe 100644
--- a/include/stc/cregex.h
+++ b/include/stc/cregex.h
@@ -121,7 +121,7 @@ int cregex_find_4(const cregex* re, const char* input, csview match[], int mflag
 STC_INLINE int cregex_find_sv(const cregex* re, csview input, csview match[]) {
     csview *mp = NULL;
     if (match) { match[0] = input; mp = match; }
-    return cregex_find(re, input.str, mp, CREG_STARTEND);
+    return cregex_find(re, input.buf, mp, CREG_STARTEND);
 }
 
 /* match + compile RE pattern */
diff --git a/include/stc/cstr.h b/include/stc/cstr.h
index bc147469..eeb65c39 100644
--- a/include/stc/cstr.h
+++ b/include/stc/cstr.h
@@ -98,7 +98,7 @@ STC_INLINE csview cstr_sv(const cstr* s) {
                            : c_sv_2(s->sml.data, cstr_s_size(s));
 }
 STC_INLINE crawstr cstr_rs(const cstr* s)
-    { csview sv = cstr_sv(s); return c_rs_2(sv.str, sv.size); }
+    { csview sv = cstr_sv(s); return c_rs_2(sv.buf, sv.size); }
 
 STC_INLINE cstr cstr_init(void)
     { return cstr_null; }
@@ -113,7 +113,7 @@ STC_INLINE cstr cstr_from(const char* str)
     { return cstr_from_n(str, c_strlen(str)); }
 
 STC_INLINE cstr cstr_from_sv(csview sv)
-    { return cstr_from_n(sv.str, sv.size); }
+    { return cstr_from_n(sv.buf, sv.size); }
 
 STC_INLINE cstr cstr_from_rs(crawstr rs)
     { return cstr_from_n(rs.str, rs.size); }
@@ -145,7 +145,7 @@ STC_INLINE cstr cstr_move(cstr* self) {
 
 STC_INLINE cstr cstr_clone(cstr s) {
     csview sv = cstr_sv(&s);
-    return cstr_from_n(sv.str, sv.size);
+    return cstr_from_n(sv.buf, sv.size);
 }
 
 STC_INLINE void cstr_drop(cstr* self) {
@@ -201,8 +201,8 @@ STC_INLINE const char* cstr_u8_at(const cstr* self, intptr_t u8idx)
 STC_INLINE csview cstr_u8_chr(const cstr* self, intptr_t u8idx) {
     const char* str = cstr_str(self);
     csview sv;
-    sv.str = utf8_at(str, u8idx);
-    sv.size = utf8_chr_size(sv.str);
+    sv.buf = utf8_at(str, u8idx);
+    sv.size = utf8_chr_size(sv.buf);
     return sv;
 }
 
@@ -211,7 +211,7 @@ STC_INLINE csview cstr_u8_chr(const cstr* self, intptr_t u8idx) {
 STC_INLINE cstr_iter cstr_begin(const cstr* self) { 
     csview sv = cstr_sv(self);
     if (!sv.size) return c_LITERAL(cstr_iter){.ref = NULL};
-    return c_LITERAL(cstr_iter){.u8 = {{sv.str, utf8_chr_size(sv.str)}}};
+    return c_LITERAL(cstr_iter){.u8 = {{sv.buf, utf8_chr_size(sv.buf)}}};
 }
 STC_INLINE cstr_iter cstr_end(const cstr* self) {
     (void)self; return c_LITERAL(cstr_iter){NULL};
@@ -242,7 +242,7 @@ STC_INLINE int cstr_icmp(const cstr* s1, const cstr* s2)
 
 STC_INLINE bool cstr_eq(const cstr* s1, const cstr* s2) {
     csview x = cstr_sv(s1), y = cstr_sv(s2);
-    return x.size == y.size && !c_memcmp(x.str, y.str, x.size);
+    return x.size == y.size && !c_memcmp(x.buf, y.buf, x.size);
 }
 
 
@@ -250,7 +250,7 @@ STC_INLINE bool cstr_equals(const cstr* self, const char* str)
     { return !strcmp(cstr_str(self), str); }
 
 STC_INLINE bool cstr_equals_sv(const cstr* self, csview sv)
-    { return sv.size == cstr_size(self) && !c_memcmp(cstr_str(self), sv.str, sv.size); }
+    { return sv.size == cstr_size(self) && !c_memcmp(cstr_str(self), sv.buf, sv.size); }
 
 STC_INLINE bool cstr_equals_s(const cstr* self, cstr s)
     { return !cstr_cmp(self, &s); }
@@ -280,7 +280,7 @@ STC_INLINE bool cstr_contains_s(const cstr* self, cstr search)
 
 STC_INLINE bool cstr_starts_with_sv(const cstr* self, csview sub) {
     if (sub.size > cstr_size(self)) return false;
-    return !c_memcmp(cstr_str(self), sub.str, sub.size);
+    return !c_memcmp(cstr_str(self), sub.buf, sub.size);
 }
 
 STC_INLINE bool cstr_starts_with(const cstr* self, const char* sub) {
@@ -302,7 +302,7 @@ STC_INLINE bool cstr_istarts_with(const cstr* self, const char* sub) {
 STC_INLINE bool cstr_ends_with_sv(const cstr* self, csview sub) {
     csview sv = cstr_sv(self);
     if (sub.size > sv.size) return false;
-    return !c_memcmp(sv.str + sv.size - sub.size, sub.str, sub.size);
+    return !c_memcmp(sv.buf + sv.size - sub.size, sub.buf, sub.size);
 }
 
 STC_INLINE bool cstr_ends_with_s(const cstr* self, cstr sub)
@@ -314,7 +314,7 @@ STC_INLINE bool cstr_ends_with(const cstr* self, const char* sub)
 STC_INLINE bool cstr_iends_with(const cstr* self, const char* sub) {
     csview sv = cstr_sv(self); 
     intptr_t n = c_strlen(sub);
-    return n <= sv.size && !utf8_icmp(sv.str + sv.size - n, sub);
+    return n <= sv.size && !utf8_icmp(sv.buf + sv.size - n, sub);
 }
 
 
@@ -322,11 +322,11 @@ STC_INLINE char* cstr_assign(cstr* self, const char* str)
     { return cstr_assign_n(self, str, c_strlen(str)); }
 
 STC_INLINE char* cstr_assign_sv(cstr* self, csview sv)
-    { return cstr_assign_n(self, sv.str, sv.size); }
+    { return cstr_assign_n(self, sv.buf, sv.size); }
 
 STC_INLINE char* cstr_copy(cstr* self, cstr s) {
     csview sv = cstr_sv(&s);
-    return cstr_assign_n(self, sv.str, sv.size);
+    return cstr_assign_n(self, sv.buf, sv.size);
 }
 
 
@@ -335,16 +335,16 @@ STC_INLINE char* cstr_push(cstr* self, const char* chr)
 
 STC_INLINE void cstr_pop(cstr* self) {
     csview sv = cstr_sv(self);
-    const char* s = sv.str + sv.size;
+    const char* s = sv.buf + sv.size;
     while ((*--s & 0xC0) == 0x80) ;
-    _cstr_set_size(self, (s - sv.str));
+    _cstr_set_size(self, (s - sv.buf));
 }
 
 STC_INLINE char* cstr_append(cstr* self, const char* str)
     { return cstr_append_n(self, str, c_strlen(str)); }
 
 STC_INLINE char* cstr_append_sv(cstr* self, csview sv)
-    { return cstr_append_n(self, sv.str, sv.size); }
+    { return cstr_append_n(self, sv.buf, sv.size); }
 
 STC_INLINE char* cstr_append_s(cstr* self, cstr s)
     { return cstr_append_sv(self, cstr_sv(&s)); }
@@ -358,7 +358,7 @@ STC_INLINE void cstr_replace_4(cstr* self, const char* search, const char* repl,
 
 STC_INLINE void cstr_replace_at_sv(cstr* self, intptr_t pos, intptr_t len, const csview repl) {
     char* d = _cstr_internal_move(self, pos + len, pos + repl.size);
-    c_memcpy(d + pos, repl.str, repl.size);
+    c_memcpy(d + pos, repl.buf, repl.size);
 }
 
 STC_INLINE void cstr_replace_at(cstr* self, intptr_t pos, intptr_t len, const char* repl)
@@ -400,12 +400,12 @@ fn_tocase[] = {{tolower, utf8_casefold},
 static cstr cstr_tocase(csview sv, int k) {
     cstr out = cstr_init();
     char *buf = cstr_reserve(&out, sv.size*3/2);
-    const char *end = sv.str + sv.size;
+    const char *end = sv.buf + sv.size;
     uint32_t cp; intptr_t sz = 0;
     utf8_decode_t d = {.state=0};
 
-    while (sv.str < end) {
-        do { utf8_decode(&d, (uint8_t)*sv.str++); } while (d.state);
+    while (sv.buf < end) {
+        do { utf8_decode(&d, (uint8_t)*sv.buf++); } while (d.state);
         if (d.codep < 128)
             buf[sz++] = (char)fn_tocase[k].conv_asc((int)d.codep);
         else {
@@ -450,13 +450,13 @@ bool cstr_valid_utf8(const cstr* self)
 
 STC_DEF uint64_t cstr_hash(const cstr *self) {
     csview sv = cstr_sv(self);
-    return cfasthash(sv.str, sv.size);
+    return cfasthash(sv.buf, sv.size);
 }
 
 STC_DEF intptr_t cstr_find_sv(const cstr* self, csview search) {
     csview sv = cstr_sv(self);
-    char* res = cstrnstrn(sv.str, search.str, sv.size, search.size);
-    return res ? (res - sv.str) : c_NPOS;
+    char* res = cstrnstrn(sv.buf, search.buf, sv.size, search.size);
+    return res ? (res - sv.buf) : c_NPOS;
 }
 
 STC_DEF char* _cstr_internal_move(cstr* self, const intptr_t pos1, const intptr_t pos2) {
@@ -532,8 +532,8 @@ STC_DEF char* cstr_resize(cstr* self, const intptr_t size, const char value) {
 STC_DEF intptr_t cstr_find_at(const cstr* self, const intptr_t pos, const char* search) {
     csview sv = cstr_sv(self);
     if (pos > sv.size) return c_NPOS;
-    const char* res = strstr((char*)sv.str + pos, search);
-    return res ? (res - sv.str) : c_NPOS;
+    const char* res = strstr((char*)sv.buf + pos, search);
+    return res ? (res - sv.buf) : c_NPOS;
 }
 
 STC_DEF char* cstr_assign_n(cstr* self, const char* str, const intptr_t len) {
@@ -588,13 +588,13 @@ STC_DEF cstr cstr_replace_sv(csview in, csview search, csview repl, int32_t coun
     intptr_t from = 0; char* res;
     if (!count) count = INT32_MAX;
     if (search.size)
-        while (count-- && (res = cstrnstrn(in.str + from, search.str, in.size - from, search.size))) {
-            const intptr_t pos = (res - in.str);
-            cstr_append_n(&out, in.str + from, pos - from);
-            cstr_append_n(&out, repl.str, repl.size);
+        while (count-- && (res = cstrnstrn(in.buf + from, search.buf, in.size - from, search.size))) {
+            const intptr_t pos = (res - in.buf);
+            cstr_append_n(&out, in.buf + from, pos - from);
+            cstr_append_n(&out, repl.buf, repl.size);
             from = pos + search.size;
         }
-    cstr_append_n(&out, in.str + from, in.size - from);
+    cstr_append_n(&out, in.buf + from, in.size - from);
     return out;
 }
 
diff --git a/include/stc/csview.h b/include/stc/csview.h
index 2a051ddd..5aba6926 100644
--- a/include/stc/csview.h
+++ b/include/stc/csview.h
@@ -46,7 +46,7 @@ STC_INLINE intptr_t csview_size(csview sv) { return sv.size; }
 STC_INLINE bool     csview_empty(csview sv) { return sv.size == 0; }
 
 STC_INLINE bool csview_equals_sv(csview sv1, csview sv2)
-    { return sv1.size == sv2.size && !c_memcmp(sv1.str, sv2.str, sv1.size); }
+    { return sv1.size == sv2.size && !c_memcmp(sv1.buf, sv2.buf, sv1.size); }
 
 STC_INLINE bool csview_equals(csview sv, const char* str)
     { return csview_equals_sv(sv, c_sv_2(str, c_strlen(str))); }
@@ -59,34 +59,34 @@ STC_INLINE bool csview_contains(csview sv, const char* str)
 
 STC_INLINE bool csview_starts_with(csview sv, const char* str) {
     intptr_t n = c_strlen(str);
-    return n > sv.size ? false : !c_memcmp(sv.str, str, n);
+    return n > sv.size ? false : !c_memcmp(sv.buf, str, n);
 }
 
 STC_INLINE bool csview_ends_with(csview sv, const char* str) {
     intptr_t n = c_strlen(str);
-    return n > sv.size ? false : !c_memcmp(sv.str + sv.size - n, str, n);
+    return n > sv.size ? false : !c_memcmp(sv.buf + sv.size - n, str, n);
 }
 
 STC_INLINE csview csview_substr(csview sv, intptr_t pos, intptr_t n) {
     if (pos + n > sv.size) n = sv.size - pos;
-    sv.str += pos, sv.size = n;
+    sv.buf += pos, sv.size = n;
     return sv;
 }
 
 STC_INLINE csview csview_slice(csview sv, intptr_t p1, intptr_t p2) {
     if (p2 > sv.size) p2 = sv.size;
-    sv.str += p1, sv.size = p2 > p1 ? p2 - p1 : 0;
+    sv.buf += p1, sv.size = p2 > p1 ? p2 - p1 : 0;
     return sv;
 }
 
 /* utf8 iterator */
 STC_INLINE csview_iter csview_begin(const csview* self) { 
     if (!self->size) return c_LITERAL(csview_iter){NULL};
-    return c_LITERAL(csview_iter){.u8 = {{self->str, utf8_chr_size(self->str)},
-                                          self->str + self->size}};
+    return c_LITERAL(csview_iter){.u8 = {{self->buf, utf8_chr_size(self->buf)},
+                                          self->buf + self->size}};
 }
 STC_INLINE csview_iter csview_end(const csview* self) {
-    return c_LITERAL(csview_iter){.u8 = {{NULL}, self->str + self->size}};
+    return c_LITERAL(csview_iter){.u8 = {{NULL}, self->buf + self->size}};
 }
 STC_INLINE void csview_next(csview_iter* it) {
     it->ref += it->u8.chr.size;
@@ -96,21 +96,21 @@ STC_INLINE void csview_next(csview_iter* it) {
 
 /* utf8 */
 STC_INLINE intptr_t csview_u8_size(csview sv)
-    { return utf8_size_n(sv.str, sv.size); }
+    { return utf8_size_n(sv.buf, sv.size); }
 
 STC_INLINE csview csview_u8_substr(csview sv, intptr_t bytepos, intptr_t u8len) {
-    sv.str += bytepos;
-    sv.size = utf8_pos(sv.str, u8len);
+    sv.buf += bytepos;
+    sv.size = utf8_pos(sv.buf, u8len);
     return sv;
 }
 
 STC_INLINE bool csview_valid_utf8(csview sv) // depends on src/utf8code.c
-    { return utf8_valid_n(sv.str, sv.size); }
+    { return utf8_valid_n(sv.buf, sv.size); }
 
 #define c_fortoken_sv(it, inputsv, sep) \
     for (struct { csview _inp, token, *ref; const char *_sep; intptr_t pos; } \
           it = {._inp=inputsv, .token=it._inp, .ref=&it.token, ._sep=sep} \
-        ; it.pos <= it._inp.size && (it.token = csview_token(it._inp, it._sep, &it.pos)).str ; )
+        ; it.pos <= it._inp.size && (it.token = csview_token(it._inp, it._sep, &it.pos)).buf ; )
 
 #define c_fortoken(it, input, sep) \
     c_fortoken_sv(it, csview_from(input), sep)
@@ -119,7 +119,7 @@ STC_INLINE bool csview_valid_utf8(csview sv) // depends on src/utf8code.c
 
 STC_INLINE int csview_cmp(const csview* x, const csview* y) {
     intptr_t n = x->size < y->size ? x->size : y->size;
-    int c = c_memcmp(x->str, y->str, n);
+    int c = c_memcmp(x->buf, y->buf, n);
     return c ? c : (int)(x->size - y->size);
 }
 
@@ -127,7 +127,7 @@ STC_INLINE int csview_icmp(const csview* x, const csview* y)
     { return utf8_icmp_sv(*x, *y); }
 
 STC_INLINE bool csview_eq(const csview* x, const csview* y)
-    { return x->size == y->size && !c_memcmp(x->str, y->str, x->size); }
+    { return x->size == y->size && !c_memcmp(x->buf, y->buf, x->size); }
 
 #endif // CSVIEW_H_INCLUDED
 
@@ -165,12 +165,12 @@ STC_DEF csview_iter csview_advance(csview_iter it, intptr_t pos) {
 }
 
 STC_DEF intptr_t csview_find_sv(csview sv, csview search) {
-    char* res = cstrnstrn(sv.str, search.str, sv.size, search.size);
-    return res ? (res - sv.str) : c_NPOS;
+    char* res = cstrnstrn(sv.buf, search.buf, sv.size, search.size);
+    return res ? (res - sv.buf) : c_NPOS;
 }
 
 STC_DEF uint64_t csview_hash(const csview *self)
-    { return cfasthash(self->str, self->size); }
+    { return cfasthash(self->buf, self->size); }
 
 STC_DEF csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
     if (pos < 0) { 
@@ -179,7 +179,7 @@ STC_DEF csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
     }
     if (pos > sv.size) pos = sv.size;
     if (pos + n > sv.size) n = sv.size - pos;
-    sv.str += pos, sv.size = n;
+    sv.buf += pos, sv.size = n;
     return sv;
 }
 
@@ -190,15 +190,15 @@ STC_DEF csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2) {
     }
     if (p2 < 0) p2 += sv.size;
     if (p2 > sv.size) p2 = sv.size;
-    sv.str += p1, sv.size = (p2 > p1 ? p2 - p1 : 0);
+    sv.buf += p1, sv.size = (p2 > p1 ? p2 - p1 : 0);
     return sv;
 }
 
 STC_DEF csview csview_token(csview sv, const char* sep, intptr_t* start) {
     intptr_t sep_size = c_strlen(sep);
-    csview slice = {sv.str + *start, sv.size - *start};
-    const char* res = cstrnstrn(slice.str, sep, slice.size, sep_size);
-    csview tok = {slice.str, res ? (res - slice.str) : slice.size};
+    csview slice = {sv.buf + *start, sv.size - *start};
+    const char* res = cstrnstrn(slice.buf, sep, slice.size, sep_size);
+    csview tok = {slice.buf, res ? (res - slice.buf) : slice.size};
     *start += tok.size + sep_size;
     return tok;
 }
diff --git a/include/stc/forward.h b/include/stc/forward.h
index 839be012..9f7a0063 100644
--- a/include/stc/forward.h
+++ b/include/stc/forward.h
@@ -42,7 +42,7 @@
 // csview : non-null terminated string view
 typedef const char csview_value;
 typedef struct csview { 
-    csview_value* str; 
+    csview_value* buf; 
     intptr_t size;
 } csview;