summaryrefslogtreecommitdiffhomepage
path: root/include
diff options
context:
space:
mode:
Diffstat (limited to 'include')
-rw-r--r--include/stc/alt/cstr.h47
-rw-r--r--include/stc/cstr.h106
2 files changed, 77 insertions, 76 deletions
diff --git a/include/stc/alt/cstr.h b/include/stc/alt/cstr.h
index c669c620..a2233432 100644
--- a/include/stc/alt/cstr.h
+++ b/include/stc/alt/cstr.h
@@ -56,8 +56,8 @@ 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_DEF void cstr_replace_at_sv(cstr* self, const size_t pos, size_t len, csview repl);
STC_API void cstr_erase_n(cstr* self, size_t pos, size_t n);
-STC_API size_t cstr_find(cstr s, const char* needle);
-STC_API size_t cstr_find_at(cstr s, size_t pos, const char* needle);
+STC_API size_t cstr_find(const cstr* self, const char* needle);
+STC_API size_t cstr_find_at(const cstr* self, size_t pos, const char* needle);
STC_API bool cstr_getdelim(cstr *self, int delim, FILE *stream);
STC_INLINE cstr cstr_init() { return cstr_null; }
@@ -70,7 +70,7 @@ STC_INLINE csview cstr_sv(const cstr* self)
STC_INLINE cstr cstr_from(const char* str)
{ return cstr_from_n(str, strlen(str)); }
STC_INLINE char* cstr_data(cstr* self) { return self->str; }
-STC_INLINE size_t cstr_size(cstr s) { return _cstr_p(&s)->size; }
+STC_INLINE size_t cstr_size(const cstr* self) { return _cstr_p(self)->size; }
STC_INLINE size_t cstr_capacity(cstr s) { return _cstr_p(&s)->cap; }
STC_INLINE bool cstr_empty(cstr s) { return _cstr_p(&s)->size == 0; }
STC_INLINE void cstr_drop(cstr* self)
@@ -106,12 +106,12 @@ STC_INLINE void cstr_erase(cstr* self, const size_t pos)
STC_INLINE char* cstr_front(cstr* self) { return self->str; }
STC_INLINE char* cstr_back(cstr* self)
{ return self->str + _cstr_p(self)->size - 1; }
-STC_INLINE bool cstr_equals(cstr s, const char* str)
- { return strcmp(s.str, str) == 0; }
-STC_INLINE bool cstr_equals_s(cstr s1, cstr s2)
- { return strcmp(s1.str, s2.str) == 0; }
-STC_INLINE bool cstr_contains(cstr s, const char* needle)
- { return strstr(s.str, needle) != NULL; }
+STC_INLINE bool cstr_equals(const cstr* self, const char* str)
+ { return strcmp(self->str, str) == 0; }
+STC_INLINE bool cstr_equals_s(const cstr* self, cstr s)
+ { return strcmp(self->str, s.str) == 0; }
+STC_INLINE bool cstr_contains(const cstr* self, const char* needle)
+ { return strstr(self->str, needle) != NULL; }
STC_INLINE bool cstr_getline(cstr *self, FILE *stream)
{ return cstr_getdelim(self, '\n', stream); }
@@ -133,7 +133,7 @@ STC_INLINE cstr cstr_with_size(const size_t len, const char fill) {
}
STC_INLINE char* cstr_append_uninit(cstr *self, size_t n) {
- size_t len = cstr_size(*self); char* d;
+ size_t len = cstr_size(self); char* d;
if (!(d = cstr_reserve(self, len + n))) return NULL;
_cstr_p(self)->size += n;
return d + len;
@@ -152,14 +152,15 @@ STC_INLINE cstr cstr_move(cstr* self) {
return tmp;
}
-STC_INLINE bool cstr_starts_with(cstr s, const char* sub) {
- while (*sub && *s.str == *sub) ++s.str, ++sub;
+STC_INLINE bool cstr_starts_with(const cstr* self, const char* sub) {
+ const char* p = self->str;
+ while (*sub && *p == *sub) ++p, ++sub;
return *sub == 0;
}
-STC_INLINE bool cstr_ends_with(cstr s, const char* sub) {
- const size_t n = strlen(sub), sz = _cstr_p(&s)->size;
- return n <= sz && !memcmp(s.str + sz - n, sub, n);
+STC_INLINE bool cstr_ends_with(const cstr* self, const char* sub) {
+ const size_t n = strlen(sub), sz = _cstr_p(self)->size;
+ return n <= sz && !memcmp(self->str + sz - n, sub, n);
}
STC_INLINE int c_strncasecmp(const char* s1, const char* s2, size_t nmax) {
@@ -309,7 +310,7 @@ STC_INLINE void _cstr_internal_move(cstr* self, const size_t pos1, const size_t
STC_DEF void
cstr_replace_at_sv(cstr* self, const size_t pos, size_t len, csview repl) {
- const size_t sz = cstr_size(*self);
+ const size_t sz = cstr_size(self);
if (len > sz - pos) len = sz - pos;
c_autobuf (xstr, char, repl.size) {
memcpy(xstr, repl.str, repl.size);
@@ -366,16 +367,16 @@ cstr_getdelim(cstr *self, const int delim, FILE *fp) {
}
STC_DEF size_t
-cstr_find(cstr s, const char* needle) {
- char* res = strstr(s.str, needle);
- return res ? res - s.str : cstr_npos;
+cstr_find(const cstr* self, const char* needle) {
+ char* res = strstr(self->str, needle);
+ return res ? res - self->str : cstr_npos;
}
STC_DEF size_t
-cstr_find_at(cstr s, const size_t pos, const char* needle) {
- if (pos > _cstr_p(&s)->size) return cstr_npos;
- char* res = strstr(s.str + pos, needle);
- return res ? res - s.str : cstr_npos;
+cstr_find_at(const cstr* self, const size_t pos, const char* needle) {
+ if (pos > _cstr_p(self)->size) return cstr_npos;
+ char* res = strstr(self->str + pos, needle);
+ return res ? res - self->str : cstr_npos;
}
#endif
diff --git a/include/stc/cstr.h b/include/stc/cstr.h
index 7af54c58..0728b110 100644
--- a/include/stc/cstr.h
+++ b/include/stc/cstr.h
@@ -80,7 +80,7 @@ STC_API char* _cstr_internal_move(cstr* self, size_t pos1, size_t pos2);
STC_API char* cstr_reserve(cstr* self, size_t cap);
STC_API void cstr_shrink_to_fit(cstr* self);
STC_API void cstr_resize(cstr* self, size_t size, char value);
-STC_API size_t cstr_find_at(cstr s, size_t pos, const char* search);
+STC_API size_t cstr_find_at(const cstr* self, size_t pos, const char* search);
STC_API char* cstr_assign_n(cstr* self, const char* str, size_t len);
STC_API char* cstr_append_n(cstr* self, const char* str, size_t len);
STC_API bool cstr_getdelim(cstr *self, int delim, FILE *fp);
@@ -161,14 +161,14 @@ STC_INLINE char* cstr_data(cstr* self)
STC_INLINE const char* cstr_str(const cstr* self)
{ return SSO_CALL(self, data(self)); }
-STC_INLINE bool cstr_empty(cstr s)
- { return s.sml.last == cstr_s_cap; }
+STC_INLINE bool cstr_empty(const cstr* self)
+ { return self->sml.last == cstr_s_cap; }
-STC_INLINE size_t cstr_size(cstr s)
- { return SSO_CALL(&s, size(&s)); }
+STC_INLINE size_t cstr_size(const cstr* self)
+ { return SSO_CALL(self, size(self)); }
-STC_INLINE size_t cstr_capacity(cstr s)
- { return cstr_is_long(&s) ? cstr_l_cap(&s) : cstr_s_cap; }
+STC_INLINE size_t cstr_capacity(const cstr* self)
+ { return cstr_is_long(self) ? cstr_l_cap(self) : cstr_s_cap; }
// utf8 methods defined in/depending on src/utf8code.c:
@@ -200,11 +200,11 @@ STC_INLINE bool cstr_valid_utf8(const cstr* self)
// other utf8
-STC_INLINE size_t cstr_u8_size(cstr s)
- { return utf8_size(cstr_str(&s)); }
+STC_INLINE size_t cstr_u8_size(const cstr* self)
+ { return utf8_size(cstr_str(self)); }
-STC_INLINE size_t cstr_u8_size_n(cstr s, size_t nbytes)
- { return utf8_size_n(cstr_str(&s), nbytes); }
+STC_INLINE size_t cstr_u8_size_n(const cstr* self, size_t nbytes)
+ { return utf8_size_n(cstr_str(self), nbytes); }
STC_INLINE size_t cstr_u8_to_pos(const cstr* self, size_t u8idx)
{ return utf8_pos(cstr_str(self), u8idx); }
@@ -242,7 +242,7 @@ STC_INLINE void cstr_clear(cstr* self)
{ _cstr_set_size(self, 0); }
STC_INLINE char* cstr_append_uninit(cstr *self, size_t len) {
- size_t sz = cstr_size(*self);
+ size_t sz = cstr_size(self);
char* d = cstr_reserve(self, sz + len);
if (!d) return NULL;
_cstr_set_size(self, sz + len);
@@ -261,75 +261,75 @@ STC_INLINE bool cstr_eq(const cstr* s1, const cstr* s2) {
}
-STC_INLINE bool cstr_equals(cstr s1, const char* str)
- { return !strcmp(cstr_str(&s1), str); }
+STC_INLINE bool cstr_equals(const cstr* self, const char* str)
+ { return !strcmp(cstr_str(self), str); }
-STC_INLINE bool cstr_equals_sv(cstr s, csview sv)
- { return sv.size == cstr_size(s) && !memcmp(cstr_str(&s), sv.str, sv.size); }
+STC_INLINE bool cstr_equals_sv(const cstr* self, csview sv)
+ { return sv.size == cstr_size(self) && !memcmp(cstr_str(self), sv.str, sv.size); }
-STC_INLINE bool cstr_equals_s(cstr s1, cstr s2)
- { return !cstr_cmp(&s1, &s2); }
+STC_INLINE bool cstr_equals_s(const cstr* self, cstr s)
+ { return !cstr_cmp(self, &s); }
-STC_INLINE bool cstr_iequals(cstr s1, const char* str)
- { return !utf8_icmp(cstr_str(&s1), str); }
+STC_INLINE bool cstr_iequals(const cstr* self, const char* str)
+ { return !utf8_icmp(cstr_str(self), str); }
-STC_INLINE size_t cstr_find(cstr s, const char* search) {
- const char *str = cstr_str(&s), *res = strstr((char*)str, search);
+STC_INLINE size_t cstr_find(const cstr* self, const char* search) {
+ const char *str = cstr_str(self), *res = strstr((char*)str, search);
return res ? res - str : cstr_npos;
}
-STC_API size_t cstr_find_sv(cstr s, csview search);
+STC_API size_t cstr_find_sv(const cstr* self, csview search);
-STC_INLINE size_t cstr_find_s(cstr s, cstr search)
- { return cstr_find(s, cstr_str(&search)); }
+STC_INLINE size_t cstr_find_s(const cstr* self, cstr search)
+ { return cstr_find(self, cstr_str(&search)); }
-STC_INLINE bool cstr_contains(cstr s, const char* search)
- { return strstr(cstr_data(&s), search) != NULL; }
+STC_INLINE bool cstr_contains(const cstr* self, const char* search)
+ { return strstr((char*)cstr_str(self), search) != NULL; }
-STC_INLINE bool cstr_contains_sv(cstr s, csview search)
- { return cstr_find_sv(s, search) != cstr_npos; }
+STC_INLINE bool cstr_contains_sv(const cstr* self, csview search)
+ { return cstr_find_sv(self, search) != cstr_npos; }
-STC_INLINE bool cstr_contains_s(cstr s, cstr search)
- { return strstr(cstr_data(&s), cstr_str(&search)) != NULL; }
+STC_INLINE bool cstr_contains_s(const cstr* self, cstr search)
+ { return strstr((char*)cstr_str(self), cstr_str(&search)) != NULL; }
-STC_INLINE bool cstr_starts_with_sv(cstr s, csview sub) {
- if (sub.size > cstr_size(s)) return false;
- return !memcmp(cstr_str(&s), sub.str, sub.size);
+STC_INLINE bool cstr_starts_with_sv(const cstr* self, csview sub) {
+ if (sub.size > cstr_size(self)) return false;
+ return !memcmp(cstr_str(self), sub.str, sub.size);
}
-STC_INLINE bool cstr_starts_with(cstr s, const char* sub) {
- const char* str = cstr_str(&s);
+STC_INLINE bool cstr_starts_with(const cstr* self, const char* sub) {
+ const char* str = cstr_str(self);
while (*sub && *str == *sub) ++str, ++sub;
return !*sub;
}
-STC_INLINE bool cstr_starts_with_s(cstr s, cstr sub)
- { return cstr_starts_with_sv(s, cstr_sv(&sub)); }
+STC_INLINE bool cstr_starts_with_s(const cstr* self, cstr sub)
+ { return cstr_starts_with_sv(self, cstr_sv(&sub)); }
-STC_INLINE bool cstr_istarts_with(cstr s, const char* sub) {
- csview sv = cstr_sv(&s);
+STC_INLINE bool cstr_istarts_with(const cstr* self, const char* sub) {
+ csview sv = cstr_sv(self);
size_t len = strlen(sub);
return len <= sv.size && !utf8_icmp_sv(sv, c_sv(sub, len));
}
-STC_INLINE bool cstr_ends_with_sv(cstr s, csview sub) {
- csview sv = cstr_sv(&s);
+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 !memcmp(sv.str + sv.size - sub.size, sub.str, sub.size);
}
-STC_INLINE bool cstr_ends_with_s(cstr s, cstr sub)
- { return cstr_ends_with_sv(s, cstr_sv(&sub)); }
+STC_INLINE bool cstr_ends_with_s(const cstr* self, cstr sub)
+ { return cstr_ends_with_sv(self, cstr_sv(&sub)); }
-STC_INLINE bool cstr_ends_with(cstr s, const char* sub)
- { return cstr_ends_with_sv(s, c_sv(sub, strlen(sub))); }
+STC_INLINE bool cstr_ends_with(const cstr* self, const char* sub)
+ { return cstr_ends_with_sv(self, c_sv(sub, strlen(sub))); }
-STC_INLINE bool cstr_iends_with(cstr s, const char* sub) {
- csview sv = cstr_sv(&s);
+STC_INLINE bool cstr_iends_with(const cstr* self, const char* sub) {
+ csview sv = cstr_sv(self);
size_t n = strlen(sub);
return n <= sv.size && !utf8_icmp(sv.str + sv.size - n, sub);
}
@@ -402,9 +402,9 @@ STC_DEF uint64_t cstr_hash(const cstr *self) {
return c_fasthash(sv.str, sv.size);
}
-STC_DEF size_t cstr_find_sv(cstr s, csview search) {
- char* res = c_strnstrn(cstr_str(&s), search.str, cstr_size(s), search.size);
- return res ? res - cstr_str(&s) : cstr_npos;
+STC_DEF size_t cstr_find_sv(const cstr* self, csview search) {
+ char* res = c_strnstrn(cstr_str(self), search.str, cstr_size(self), search.size);
+ return res ? res - cstr_str(self) : cstr_npos;
}
STC_DEF char* _cstr_internal_move(cstr* self, const size_t pos1, const size_t pos2) {
@@ -474,8 +474,8 @@ STC_DEF void cstr_resize(cstr* self, const size_t size, const char value) {
_cstr_set_size(self, size);
}
-STC_DEF size_t cstr_find_at(cstr s, const size_t pos, const char* search) {
- csview sv = cstr_sv(&s);
+STC_DEF size_t cstr_find_at(const cstr* self, const size_t pos, const char* search) {
+ csview sv = cstr_sv(self);
if (pos > sv.size) return cstr_npos;
const char* res = strstr((char*)sv.str + pos, search);
return res ? res - sv.str : cstr_npos;
generated by cgit v1.2.3 (git 2.39.1) at 2026-04-19 00:47:43 +0000