ucx: comparison src/string.c

-:5dfce68057ce
+:fcb149ee60ff
 return strncasecmp(string.ptr + string.length - suffix.length,
 suffix.ptr, suffix.length) == 0;
 #endif
 }
-#ifndef CX_STRREPLACE_INDEX_BUFFER_SIZE
-#define CX_STRREPLACE_INDEX_BUFFER_SIZE 64
-#endif
-struct cx_strreplace_ibuf {
-size_t *buf;
-struct cx_strreplace_ibuf *next;
-unsigned int len;
-};
-static void cx_strrepl_free_ibuf(struct cx_strreplace_ibuf *buf) {
-// remember, the first data is on the stack!
-buf = buf->next;
-while (buf) {
-struct cx_strreplace_ibuf *next = buf->next;
-free(buf->buf);
-free(buf);
-buf = next;
-}
-}
 cxmutstr cx_strreplacen_a(
 const CxAllocator *allocator,
 cxstring str,
 cxstring search,
 cxstring replacement,
 size_t replmax
 ) {
+// special cases
-if (search.length == 0 || search.length > str.length || replmax == 0)
+if (search.length == 0 || search.length > str.length || replmax == 0) {
 return cx_strdup_a(allocator, str);
+}
-// Compute expected buffer length
-size_t ibufmax = str.length / search.length;
+size_t in_len = str.length;
-size_t ibuflen = replmax < ibufmax ? replmax : ibufmax;
+size_t search_len = search.length;
-if (ibuflen > CX_STRREPLACE_INDEX_BUFFER_SIZE) {
+size_t repl_len = replacement.length;
-ibuflen = CX_STRREPLACE_INDEX_BUFFER_SIZE;
-}
+// first run, count the occurrences
+// and remember where the first is
-// First index buffer can be on the stack
+size_t occurrences = 1;
-struct cx_strreplace_ibuf ibuf, *curbuf = &ibuf;
+cxstring first = cx_strstr(str, search);
-size_t ibuf_sbo[CX_STRREPLACE_INDEX_BUFFER_SIZE];
+if (first.length == 0) {
-ibuf.buf = ibuf_sbo;
+// special case, no replacements
-ibuf.next = NULL;
+return cx_strdup_a(allocator, str);
-ibuf.len = 0;
+}
+cxstring tmp = cx_strsubs(first, search_len);
-// Search occurrences
+while (occurrences < replmax &&
-cxstring searchstr = str;
+(tmp = cx_strstr(tmp, search)).length > 0) {
-size_t found = 0;
+occurrences++;
-do {
+tmp = cx_strsubs(tmp, search_len);
-cxstring match = cx_strstr(searchstr, search);
+}
-if (match.length > 0) {
-// Allocate next buffer in chain, if required
+// calculate necessary memory
-if (curbuf->len == ibuflen) {
+signed long long diff_len = (signed long long) repl_len - search_len;
-struct cx_strreplace_ibuf *nextbuf =
+size_t out_len = in_len + diff_len * occurrences;
-calloc(1, sizeof(struct cx_strreplace_ibuf));
+cxmutstr out = {
-if (!nextbuf) {
+cxMalloc(allocator, out_len + 1),
-cx_strrepl_free_ibuf(&ibuf);
+out_len
-return cx_mutstrn(NULL, 0);
+};
-}
+if (out.ptr == NULL) return out;
-nextbuf->buf = calloc(ibuflen, sizeof(size_t));
-if (!nextbuf->buf) {
+// second run: perform the replacements
-free(nextbuf);
+// but start where we found the first occurrence
-cx_strrepl_free_ibuf(&ibuf);
+const char *inp = str.ptr;
-return cx_mutstrn(NULL, 0);
+tmp = first;
-}
+char *outp = out.ptr;
-curbuf->next = nextbuf;
+while (occurrences-- > 0 && (tmp = cx_strstr(tmp, search)).length > 0) {
-curbuf = nextbuf;
+size_t copylen = tmp.ptr - inp;
-}
+memcpy(outp, inp, copylen);
+outp += copylen;
-// Record match index
+memcpy(outp, replacement.ptr, repl_len);
-found++;
+outp += repl_len;
-size_t idx = match.ptr - str.ptr;
+inp += copylen + search_len;
-curbuf->buf[curbuf->len++] = idx;
+tmp = cx_strsubs(tmp, search_len);
-searchstr.ptr = match.ptr + search.length;
+}
-searchstr.length = str.length - idx - search.length;
-} else {
+// add the remaining string
-break;
+size_t copylen = in_len - (inp - str.ptr);
-}
+memcpy(outp, inp, copylen);
-} while (searchstr.length > 0 && found < replmax);
+out.ptr[out_len] = '\0';
-// Allocate result string
+return out;
-cxmutstr result;
-{
-long long adjlen = (long long) replacement.length - (long long) search.length;
-size_t rcount = 0;
-curbuf = &ibuf;
-do {
-rcount += curbuf->len;
-curbuf = curbuf->next;
-} while (curbuf);
-result.length = str.length + rcount * adjlen;
-result.ptr = cxMalloc(allocator, result.length + 1);
-if (!result.ptr) {
-cx_strrepl_free_ibuf(&ibuf);
-return cx_mutstrn(NULL, 0);
-}
-}
-// Build result string
-curbuf = &ibuf;
-size_t srcidx = 0;
-char *destptr = result.ptr;
-do {
-for (size_t i = 0; i < curbuf->len; i++) {
-// Copy source part up to next match
-size_t idx = curbuf->buf[i];
-size_t srclen = idx - srcidx;
-if (srclen > 0) {
-memcpy(destptr, str.ptr + srcidx, srclen);
-destptr += srclen;
-srcidx += srclen;
-}
-// Copy the replacement and skip the source pattern
-srcidx += search.length;
-memcpy(destptr, replacement.ptr, replacement.length);
-destptr += replacement.length;
-}
-curbuf = curbuf->next;
-} while (curbuf);
-memcpy(destptr, str.ptr + srcidx, str.length - srcidx);
-// Result is guaranteed to be zero-terminated
-result.ptr[result.length] = '\0';
-// Free index buffer
-cx_strrepl_free_ibuf(&ibuf);
-return result;
 }
 CxStrtokCtx cx_strtok_(
 cxstring str,
 cxstring delim,

Mercurial > hg > ucx / file comparison

comparison: src/string.c

src/string.c