Reverted csubstr => csview. Sorry about that!

Added crawstr to become the null-terminated string view.

1 files changed, 127 insertions, 32 deletions

diff --git a/include/stc/csview.h b/include/stc/csview.h
index 367258e4..2a051ddd 100644
--- a/include/stc/csview.h
+++ b/include/stc/csview.h
@@ -20,33 +20,39 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+#define i_header // external linkage by default. override with i_static.
 #define _i_inc_utf8
 #include "utf8.h"
 
 #ifndef CSVIEW_H_INCLUDED
 #define CSVIEW_H_INCLUDED
 
-#define             csview_init() c_sv("")
+#define             csview_init() c_sv_1("")
 #define             csview_drop(p) c_default_drop(p)
 #define             csview_clone(sv) c_default_clone(sv)
+#define             csview_from_n(str, n) c_sv_2(str, n)
+
+STC_API csview_iter csview_advance(csview_iter it, intptr_t pos);
+STC_API intptr_t    csview_find_sv(csview sv, csview search);
+STC_API uint64_t    csview_hash(const csview *self);
+STC_API csview      csview_slice_ex(csview sv, intptr_t p1, intptr_t p2);
+STC_API csview      csview_substr_ex(csview sv, intptr_t pos, intptr_t n);
+STC_API csview      csview_token(csview sv, const char* sep, intptr_t* start);
 
 STC_INLINE csview   csview_from(const char* str)
-                        { return c_sv_2(str, c_strlen(str)); }
+    { return c_LITERAL(csview){str, c_strlen(str)}; }
 STC_INLINE void     csview_clear(csview* self) { *self = csview_init(); }
-STC_INLINE csubstr  csview_ss(csview sv) { return c_ss_2(sv.str, sv.size); }
-
 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(csview sv, const char* str) { 
-    intptr_t n = c_strlen(str); 
-    return sv.size == n && !c_memcmp(sv.str, str, n);
-}
+STC_INLINE bool csview_equals_sv(csview sv1, csview sv2)
+    { return sv1.size == sv2.size && !c_memcmp(sv1.str, sv2.str, sv1.size); }
 
-STC_INLINE intptr_t csview_find(csview sv, const char* search) {
-    char* res = cstrnstrn(sv.str, search, sv.size, c_strlen(search));
-    return res ? (res - sv.str) : c_NPOS;
-}
+STC_INLINE bool csview_equals(csview sv, const char* str)
+    { return csview_equals_sv(sv, c_sv_2(str, c_strlen(str))); }
+
+STC_INLINE intptr_t csview_find(csview sv, const char* str)
+    { return csview_find_sv(sv, c_sv_2(str, c_strlen(str))); }
 
 STC_INLINE bool csview_contains(csview sv, const char* str)
     { return csview_find(sv, str) != c_NPOS; }
@@ -61,40 +67,55 @@ STC_INLINE bool csview_ends_with(csview sv, const char* str) {
     return n > sv.size ? false : !c_memcmp(sv.str + 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;
+    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;
+    return sv;
+}
+
 /* utf8 iterator */
 STC_INLINE csview_iter csview_begin(const csview* self) { 
-    if (!self->size) return c_LITERAL(csview_iter){.ref = NULL};
-    return c_LITERAL(csview_iter){.u8 = {{self->str, utf8_chr_size(self->str)}}};
+    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}};
 }
 STC_INLINE csview_iter csview_end(const csview* self) {
-    (void)self; return c_LITERAL(csview_iter){.ref = NULL};
+    return c_LITERAL(csview_iter){.u8 = {{NULL}, self->str + self->size}};
 }
 STC_INLINE void csview_next(csview_iter* it) {
     it->ref += it->u8.chr.size;
     it->u8.chr.size = utf8_chr_size(it->ref);
-    if (!*it->ref) it->ref = NULL;
-}
-STC_INLINE csview_iter csview_advance(csview_iter it, intptr_t pos) {
-    int inc = -1;
-    if (pos > 0) pos = -pos, inc = 1;
-    while (pos && *it.ref) pos += (*(it.ref += inc) & 0xC0) != 0x80;
-    it.u8.chr.size = utf8_chr_size(it.ref);
-    if (!*it.ref) it.ref = NULL;
-    return it;
+    if (it->ref == it->u8.end) it->ref = NULL;
 }
 
-/* utf8 size */
+/* utf8 */
 STC_INLINE intptr_t csview_u8_size(csview sv)
     { return utf8_size_n(sv.str, sv.size); }
 
-/* utf8 validation: depends on src/utf8code.c */
-STC_INLINE bool csview_valid_utf8(csview sv)
+STC_INLINE csview csview_u8_substr(csview sv, intptr_t bytepos, intptr_t u8len) {
+    sv.str += bytepos;
+    sv.size = utf8_pos(sv.str, u8len);
+    return sv;
+}
+
+STC_INLINE bool csview_valid_utf8(csview sv) // depends on src/utf8code.c
     { return utf8_valid_n(sv.str, sv.size); }
 
-/* utf8 ignore case cmp: depends on src/utf8code.c */
-STC_INLINE int csview_icmp(const csview* x, const csview* y)
-    { return utf8_icmp_ss(c_ss_2(x->str, x->size), c_ss_2(y->str, y->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 ; )
 
+#define c_fortoken(it, input, sep) \
+    c_fortoken_sv(it, csview_from(input), sep)
+
+/* ---- Container helper functions ---- */
 
 STC_INLINE int csview_cmp(const csview* x, const csview* y) {
     intptr_t n = x->size < y->size ? x->size : y->size;
@@ -102,13 +123,87 @@ STC_INLINE int csview_cmp(const csview* x, const csview* y) {
     return c ? c : (int)(x->size - y->size);
 }
 
+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); }
 
-STC_INLINE uint64_t csview_hash(const csview *self)
+#endif // CSVIEW_H_INCLUDED
+
+/* csview interaction with cstr: */
+#ifdef CSTR_H_INCLUDED
+
+STC_INLINE csview cstr_substr(const cstr* self, intptr_t pos, intptr_t n)
+    { return csview_substr(cstr_sv(self), pos, n); }
+
+STC_INLINE csview cstr_slice(const cstr* self, intptr_t p1, intptr_t p2)
+    { return csview_slice(cstr_sv(self), p1, p2); }
+
+STC_INLINE csview cstr_substr_ex(const cstr* self, intptr_t pos, intptr_t n)
+    { return csview_substr_ex(cstr_sv(self), pos, n); }
+
+STC_INLINE csview cstr_slice_ex(const cstr* self, intptr_t p1, intptr_t p2)
+    { return csview_slice_ex(cstr_sv(self), p1, p2); }
+
+STC_INLINE csview cstr_u8_substr(const cstr* self , intptr_t bytepos, intptr_t u8len)
+    { return csview_u8_substr(cstr_sv(self), bytepos, u8len); }
+#endif
+
+/* -------------------------- IMPLEMENTATION ------------------------- */
+#if defined i_implement || defined i_static
+#ifndef CSVIEW_C_INCLUDED
+#define CSVIEW_C_INCLUDED
+
+STC_DEF csview_iter csview_advance(csview_iter it, intptr_t pos) {
+    int inc = -1;
+    if (pos > 0) pos = -pos, inc = 1;
+    while (pos && it.ref != it.u8.end) pos += (*(it.ref += inc) & 0xC0) != 0x80;
+    it.u8.chr.size = utf8_chr_size(it.ref);
+    if (it.ref == it.u8.end) it.ref = NULL;
+    return it;
+}
+
+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;
+}
+
+STC_DEF uint64_t csview_hash(const csview *self)
     { return cfasthash(self->str, self->size); }
 
-#endif // CSVIEW_H_INCLUDED
+STC_DEF csview csview_substr_ex(csview sv, intptr_t pos, intptr_t n) {
+    if (pos < 0) { 
+        pos += sv.size;
+        if (pos < 0) pos = 0;
+    }
+    if (pos > sv.size) pos = sv.size;
+    if (pos + n > sv.size) n = sv.size - pos;
+    sv.str += pos, sv.size = n;
+    return sv;
+}
+
+STC_DEF csview csview_slice_ex(csview sv, intptr_t p1, intptr_t p2) {
+    if (p1 < 0) { 
+        p1 += sv.size;
+        if (p1 < 0) p1 = 0;
+    }
+    if (p2 < 0) p2 += sv.size;
+    if (p2 > sv.size) p2 = sv.size;
+    sv.str += 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};
+    *start += tok.size + sep_size;
+    return tok;
+}
+#endif // CSVIEW_C_INCLUDED
+#endif // i_implement
 #undef i_static
 #undef i_header
 #undef i_implement