ucx: comparison src/string.c

-:96f643d30ff1
+:f1b2146d4805
 #define ptable_w(useheap, ptable, index, src) do {\
 if (!useheap) ((uint8_t*)ptable)[index] = (uint8_t) src;\
 else ((size_t*)ptable)[index] = src;\
 } while (0);
-sstr_t sstrstr(sstr_t string, sstr_t match) {
-if (match.length == 0) {
+const char* ucx_strstr(
-return string;
+const char *str,
-}
+size_t length,
+const char *match,
-/* prepare default return value in case of no match */
+size_t matchlen,
-sstr_t result = sstrn(NULL, 0);
+size_t *newlen)
+{
+*newlen = length;
+if (matchlen == 0) {
+return str;
+}
+const char *result = NULL;
+size_t resultlen = 0;
 /*
 * IMPORTANT:
 * our prefix table contains the prefix length PLUS ONE
 * this is our decision, because we want to use the full range of size_t
 /* static prefix table */
 static uint8_t s_prefix_table[256];
 /* check pattern length and use appropriate prefix table */
 /* if the pattern exceeds static prefix table, allocate on the heap */
-register int useheap = match.length > 255;
+register int useheap = matchlen > 255;
 register void* ptable = useheap ?
-calloc(match.length+1, sizeof(size_t)): s_prefix_table;
+calloc(matchlen+1, sizeof(size_t)): s_prefix_table;
 /* keep counter in registers */
 register size_t i, j;
 /* fill prefix table */
 i = 0; j = 0;
 ptable_w(useheap, ptable, i, j);
-while (i < match.length) {
+while (i < matchlen) {
-while (j >= 1 && match.ptr[j-1] != match.ptr[i]) {
+while (j >= 1 && match[j-1] != match[i]) {
 ptable_r(j, useheap, ptable, j-1);
 }
 i++; j++;
 ptable_w(useheap, ptable, i, j);
 }
 /* search */
 i = 0; j = 1;
-while (i < string.length) {
+while (i < length) {
-while (j >= 1 && string.ptr[i] != match.ptr[j-1]) {
+while (j >= 1 && str[i] != match[j-1]) {
 ptable_r(j, useheap, ptable, j-1);
 }
 i++; j++;
-if (j-1 == match.length) {
+if (j-1 == matchlen) {
-size_t start = i - match.length;
+size_t start = i - matchlen;
-result.ptr = string.ptr + start;
+result = str + start;
-result.length = string.length - start;
+resultlen = length - start;
 break;
 }
 }
 /* if prefix table was allocated on the heap, free it */
 if (ptable != s_prefix_table) {
 free(ptable);
 }
+*newlen = resultlen;
+return result;
+}
+sstr_t ucx_sstrstr(sstr_t string, scstr_t match) {
+sstr_t result;
+size_t reslen;
+const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen);
+if(!resstr) {
+result.ptr = NULL;
+result.length = 0;
+return result;
+}
+size_t pos = resstr - string.ptr;
+result.ptr = string.ptr + pos;
+result.length = reslen;
+return result;
+}
+scstr_t ucx_scstrstr(scstr_t string, scstr_t match) {
+scstr_t result;
+size_t reslen;
+const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen);
+if(!resstr) {
+result.ptr = NULL;
+result.length = 0;
+return result;
+}
+size_t pos = resstr - string.ptr;
+result.ptr = string.ptr + pos;
+result.length = reslen;
 return result;
 }
 #undef ptable_r
 #undef ptable_w
-sstr_t* sstrsplit(sstr_t s, sstr_t d, ssize_t *n) {
+sstr_t* ucx_strsplit(scstr_t s, scstr_t d, ssize_t *n) {
-return sstrsplit_a(ucx_default_allocator(), s, d, n);
+return ucx_strsplit_a(ucx_default_allocator(), s, d, n);
 }
-sstr_t* sstrsplit_a(UcxAllocator *allocator, sstr_t s, sstr_t d, ssize_t *n) {
+sstr_t* ucx_strsplit_a(UcxAllocator *allocator, scstr_t s, scstr_t d, ssize_t *n) {
 if (s.length == 0 || d.length == 0) {
 *n = -1;
 return NULL;
 }
 ssize_t nmax = *n;
 size_t arrlen = 16;
 sstr_t* result = (sstr_t*) alcalloc(allocator, arrlen, sizeof(sstr_t));
 if (result) {
-sstr_t curpos = s;
+scstr_t curpos = s;
 ssize_t j = 1;
 while (1) {
-sstr_t match;
+scstr_t match;
 /* optimize for one byte delimiters */
 if (d.length == 1) {
 match = curpos;
 for (size_t i = 0 ; i < curpos.length ; i++) {
 if (curpos.ptr[i] == *(d.ptr)) {
 break;
 }
 match.length--;
 }
 } else {
-match = sstrstr(curpos, d);
+match = scstrstr(curpos, d);
 }
 if (match.length > 0) {
 /* is this our last try? */
 if (nmax == 0 || j < nmax) {
 /* copy the current string to the array */
-sstr_t item = sstrn(curpos.ptr, match.ptr - curpos.ptr);
+scstr_t item = scstrn(curpos.ptr, match.ptr - curpos.ptr);
 result[j-1] = sstrdup_a(allocator, item);
 size_t processed = item.length + d.length;
 curpos.ptr += processed;
 curpos.length -= processed;
 }
 return result;
 }
-int sstrcmp(sstr_t s1, sstr_t s2) {
+int ucx_str_cmp(scstr_t s1, scstr_t s2) {
 if (s1.length == s2.length) {
 return memcmp(s1.ptr, s2.ptr, s1.length);
 } else if (s1.length > s2.length) {
 return 1;
 } else {
 return -1;
 }
 }
-int sstrcasecmp(sstr_t s1, sstr_t s2) {
+int ucx_str_casecmp(scstr_t s1, scstr_t s2) {
 if (s1.length == s2.length) {
 #ifdef _WIN32
 return _strnicmp(s1.ptr, s2.ptr, s1.length);
 #else
 return strncasecmp(s1.ptr, s2.ptr, s1.length);
 }
 return newstring;
 }
+size_t ucx_strtrim(const char *s, size_t len, size_t *newlen) {
+const char *newptr = s;
+size_t length = len;
+while(length > 0 && isspace(*newptr)) {
+newptr++;
+length--;
+}
+while(length > 0 && isspace(newptr[length-1])) {
+length--;
+}
+*newlen = length;
+return newptr - s;
+}
 sstr_t sstrtrim(sstr_t string) {
-sstr_t newstr = string;
+sstr_t newstr;
+newstr.ptr = string.ptr
-while (newstr.length > 0 && isspace(*newstr.ptr)) {
++ ucx_strtrim(string.ptr, string.length, &newstr.length);
-newstr.ptr++;
+return newstr;
-newstr.length--;
+}
-}
-while (newstr.length > 0 && isspace(newstr.ptr[newstr.length-1])) {
+scstr_t scstrtrim(scstr_t string) {
-newstr.length--;
+scstr_t newstr;
-}
+newstr.ptr = string.ptr
++ ucx_strtrim(string.ptr, string.length, &newstr.length);
 return newstr;
 }
 int ucx_strprefix(scstr_t string, scstr_t prefix) {
 if (string.length == 0) {

Mercurial > hg > ucx / file comparison

comparison: src/string.c

src/string.c