From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/blenlib/intern/string.c | 1349 ++++++++++++++++---------------- 1 file changed, 682 insertions(+), 667 deletions(-) (limited to 'source/blender/blenlib/intern/string.c') diff --git a/source/blender/blenlib/intern/string.c b/source/blender/blenlib/intern/string.c index dfb32e5b76c..01cb635b044 100644 --- a/source/blender/blenlib/intern/string.c +++ b/source/blender/blenlib/intern/string.c @@ -21,7 +21,6 @@ * \ingroup bli */ - #include #include #include @@ -52,11 +51,11 @@ */ char *BLI_strdupn(const char *str, const size_t len) { - char *n = MEM_mallocN(len + 1, "strdup"); - memcpy(n, str, len); - n[len] = '\0'; + char *n = MEM_mallocN(len + 1, "strdup"); + memcpy(n, str, len); + n[len] = '\0'; - return n; + return n; } /** @@ -68,7 +67,7 @@ char *BLI_strdupn(const char *str, const size_t len) */ char *BLI_strdup(const char *str) { - return BLI_strdupn(str, strlen(str)); + return BLI_strdupn(str, strlen(str)); } /** @@ -79,18 +78,19 @@ char *BLI_strdup(const char *str) */ char *BLI_strdupcat(const char *__restrict str1, const char *__restrict str2) { - /* include the NULL terminator of str2 only */ - const size_t str1_len = strlen(str1); - const size_t str2_len = strlen(str2) + 1; - char *str, *s; + /* include the NULL terminator of str2 only */ + const size_t str1_len = strlen(str1); + const size_t str2_len = strlen(str2) + 1; + char *str, *s; - str = MEM_mallocN(str1_len + str2_len, "strdupcat"); - s = str; + str = MEM_mallocN(str1_len + str2_len, "strdupcat"); + s = str; - memcpy(s, str1, str1_len); s += str1_len; - memcpy(s, str2, str2_len); + memcpy(s, str1, str1_len); + s += str1_len; + memcpy(s, str2, str2_len); - return str; + return str; } /** @@ -105,16 +105,16 @@ char *BLI_strdupcat(const char *__restrict str1, const char *__restrict str2) */ char *BLI_strncpy(char *__restrict dst, const char *__restrict src, const size_t maxncpy) { - size_t srclen = BLI_strnlen(src, maxncpy - 1); - BLI_assert(maxncpy != 0); + size_t srclen = BLI_strnlen(src, maxncpy - 1); + BLI_assert(maxncpy != 0); #ifdef DEBUG_STRSIZE - memset(dst, 0xff, sizeof(*dst) * maxncpy); + memset(dst, 0xff, sizeof(*dst) * maxncpy); #endif - memcpy(dst, src, srclen); - dst[srclen] = '\0'; - return dst; + memcpy(dst, src, srclen); + dst[srclen] = '\0'; + return dst; } /** @@ -126,43 +126,46 @@ char *BLI_strncpy(char *__restrict dst, const char *__restrict src, const size_t * \param maxncpy: Maximum number of characters to copy (generally the size of dst) * \retval Returns dst */ -char *BLI_strncpy_ensure_pad(char *__restrict dst, const char *__restrict src, const char pad, size_t maxncpy) +char *BLI_strncpy_ensure_pad(char *__restrict dst, + const char *__restrict src, + const char pad, + size_t maxncpy) { - BLI_assert(maxncpy != 0); + BLI_assert(maxncpy != 0); #ifdef DEBUG_STRSIZE - memset(dst, 0xff, sizeof(*dst) * maxncpy); + memset(dst, 0xff, sizeof(*dst) * maxncpy); #endif - if (src[0] == '\0') { - dst[0] = '\0'; - } - else { - /* Add heading/trailing wildcards if needed. */ - size_t idx = 0; - size_t srclen; - - if (src[idx] != pad) { - dst[idx++] = pad; - maxncpy--; - } - maxncpy--; /* trailing '\0' */ - - srclen = BLI_strnlen(src, maxncpy); - if ((src[srclen - 1] != pad) && (srclen == maxncpy)) { - srclen--; - } - - memcpy(&dst[idx], src, srclen); - idx += srclen; - - if (dst[idx - 1] != pad) { - dst[idx++] = pad; - } - dst[idx] = '\0'; - } - - return dst; + if (src[0] == '\0') { + dst[0] = '\0'; + } + else { + /* Add heading/trailing wildcards if needed. */ + size_t idx = 0; + size_t srclen; + + if (src[idx] != pad) { + dst[idx++] = pad; + maxncpy--; + } + maxncpy--; /* trailing '\0' */ + + srclen = BLI_strnlen(src, maxncpy); + if ((src[srclen - 1] != pad) && (srclen == maxncpy)) { + srclen--; + } + + memcpy(&dst[idx], src, srclen); + idx += srclen; + + if (dst[idx - 1] != pad) { + dst[idx++] = pad; + } + dst[idx] = '\0'; + } + + return dst; } /** @@ -180,70 +183,76 @@ char *BLI_strncpy_ensure_pad(char *__restrict dst, const char *__restrict src, c */ size_t BLI_strncpy_rlen(char *__restrict dst, const char *__restrict src, const size_t maxncpy) { - size_t srclen = BLI_strnlen(src, maxncpy - 1); - BLI_assert(maxncpy != 0); + size_t srclen = BLI_strnlen(src, maxncpy - 1); + BLI_assert(maxncpy != 0); #ifdef DEBUG_STRSIZE - memset(dst, 0xff, sizeof(*dst) * maxncpy); + memset(dst, 0xff, sizeof(*dst) * maxncpy); #endif - memcpy(dst, src, srclen); - dst[srclen] = '\0'; - return srclen; + memcpy(dst, src, srclen); + dst[srclen] = '\0'; + return srclen; } size_t BLI_strcpy_rlen(char *__restrict dst, const char *__restrict src) { - size_t srclen = strlen(src); - memcpy(dst, src, srclen + 1); - return srclen; + size_t srclen = strlen(src); + memcpy(dst, src, srclen + 1); + return srclen; } /** * Portable replacement for `vsnprintf`. */ -size_t BLI_vsnprintf(char *__restrict buffer, size_t maxncpy, const char *__restrict format, va_list arg) +size_t BLI_vsnprintf(char *__restrict buffer, + size_t maxncpy, + const char *__restrict format, + va_list arg) { - size_t n; + size_t n; - BLI_assert(buffer != NULL); - BLI_assert(maxncpy > 0); - BLI_assert(format != NULL); + BLI_assert(buffer != NULL); + BLI_assert(maxncpy > 0); + BLI_assert(format != NULL); - n = (size_t)vsnprintf(buffer, maxncpy, format, arg); + n = (size_t)vsnprintf(buffer, maxncpy, format, arg); - if (n != -1 && n < maxncpy) { - buffer[n] = '\0'; - } - else { - buffer[maxncpy - 1] = '\0'; - } + if (n != -1 && n < maxncpy) { + buffer[n] = '\0'; + } + else { + buffer[maxncpy - 1] = '\0'; + } - return n; + return n; } /** * A version of #BLI_vsnprintf that returns ``strlen(buffer)`` */ -size_t BLI_vsnprintf_rlen(char *__restrict buffer, size_t maxncpy, const char *__restrict format, va_list arg) +size_t BLI_vsnprintf_rlen(char *__restrict buffer, + size_t maxncpy, + const char *__restrict format, + va_list arg) { - size_t n; + size_t n; - BLI_assert(buffer != NULL); - BLI_assert(maxncpy > 0); - BLI_assert(format != NULL); + BLI_assert(buffer != NULL); + BLI_assert(maxncpy > 0); + BLI_assert(format != NULL); - n = (size_t)vsnprintf(buffer, maxncpy, format, arg); + n = (size_t)vsnprintf(buffer, maxncpy, format, arg); - if (n != -1 && n < maxncpy) { - /* pass */ - } - else { - n = maxncpy - 1; - } - buffer[n] = '\0'; + if (n != -1 && n < maxncpy) { + /* pass */ + } + else { + n = maxncpy - 1; + } + buffer[n] = '\0'; - return n; + return n; } /** @@ -251,18 +260,18 @@ size_t BLI_vsnprintf_rlen(char *__restrict buffer, size_t maxncpy, const char *_ */ size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format, ...) { - size_t n; - va_list arg; + size_t n; + va_list arg; #ifdef DEBUG_STRSIZE - memset(dst, 0xff, sizeof(*dst) * maxncpy); + memset(dst, 0xff, sizeof(*dst) * maxncpy); #endif - va_start(arg, format); - n = BLI_vsnprintf(dst, maxncpy, format, arg); - va_end(arg); + va_start(arg, format); + n = BLI_vsnprintf(dst, maxncpy, format, arg); + va_end(arg); - return n; + return n; } /** @@ -270,18 +279,18 @@ size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict */ size_t BLI_snprintf_rlen(char *__restrict dst, size_t maxncpy, const char *__restrict format, ...) { - size_t n; - va_list arg; + size_t n; + va_list arg; #ifdef DEBUG_STRSIZE - memset(dst, 0xff, sizeof(*dst) * maxncpy); + memset(dst, 0xff, sizeof(*dst) * maxncpy); #endif - va_start(arg, format); - n = BLI_vsnprintf_rlen(dst, maxncpy, format, arg); - va_end(arg); + va_start(arg, format); + n = BLI_vsnprintf_rlen(dst, maxncpy, format, arg); + va_end(arg); - return n; + return n; } /** @@ -290,23 +299,22 @@ size_t BLI_snprintf_rlen(char *__restrict dst, size_t maxncpy, const char *__res */ char *BLI_sprintfN(const char *__restrict format, ...) { - DynStr *ds; - va_list arg; - char *n; + DynStr *ds; + va_list arg; + char *n; - va_start(arg, format); + va_start(arg, format); - ds = BLI_dynstr_new(); - BLI_dynstr_vappendf(ds, format, arg); - n = BLI_dynstr_get_cstring(ds); - BLI_dynstr_free(ds); + ds = BLI_dynstr_new(); + BLI_dynstr_vappendf(ds, format, arg); + n = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); - va_end(arg); + va_end(arg); - return n; + return n; } - /* match pythons string escaping, assume double quotes - (") * TODO: should be used to create RNA animation paths. * TODO: support more fancy string escaping. current code is primitive @@ -314,45 +322,45 @@ char *BLI_sprintfN(const char *__restrict format, ...) * which is a useful reference. */ size_t BLI_strescape(char *__restrict dst, const char *__restrict src, const size_t maxncpy) { - size_t len = 0; - - BLI_assert(maxncpy != 0); - - while (len < maxncpy) { - switch (*src) { - case '\0': - goto escape_finish; - case '\\': - case '"': - ATTR_FALLTHROUGH; - - /* less common but should also be support */ - case '\t': - case '\n': - case '\r': - if (len + 1 < maxncpy) { - *dst++ = '\\'; - len++; - } - else { - /* not enough space to escape */ - break; - } - ATTR_FALLTHROUGH; - default: - *dst = *src; - break; - } - dst++; - src++; - len++; - } + size_t len = 0; + + BLI_assert(maxncpy != 0); + + while (len < maxncpy) { + switch (*src) { + case '\0': + goto escape_finish; + case '\\': + case '"': + ATTR_FALLTHROUGH; + + /* less common but should also be support */ + case '\t': + case '\n': + case '\r': + if (len + 1 < maxncpy) { + *dst++ = '\\'; + len++; + } + else { + /* not enough space to escape */ + break; + } + ATTR_FALLTHROUGH; + default: + *dst = *src; + break; + } + dst++; + src++; + len++; + } escape_finish: - *dst = '\0'; + *dst = '\0'; - return len; + return len; } /** @@ -369,32 +377,32 @@ escape_finish: */ char *BLI_str_quoted_substrN(const char *__restrict str, const char *__restrict prefix) { - const char *startMatch, *endMatch; - - /* get the starting point (i.e. where prefix starts, and add prefixLen+1 - * to it to get be after the first " */ - startMatch = strstr(str, prefix); - if (startMatch) { - const size_t prefixLen = strlen(prefix); - startMatch += prefixLen + 1; - /* get the end point (i.e. where the next occurrence of " is after the starting point) */ - - endMatch = startMatch; - while ((endMatch = strchr(endMatch, '"'))) { - if (LIKELY(*(endMatch - 1) != '\\')) { - break; - } - else { - endMatch++; - } - } - - if (endMatch) { - /* return the slice indicated */ - return BLI_strdupn(startMatch, (size_t)(endMatch - startMatch)); - } - } - return BLI_strdupn("", 0); + const char *startMatch, *endMatch; + + /* get the starting point (i.e. where prefix starts, and add prefixLen+1 + * to it to get be after the first " */ + startMatch = strstr(str, prefix); + if (startMatch) { + const size_t prefixLen = strlen(prefix); + startMatch += prefixLen + 1; + /* get the end point (i.e. where the next occurrence of " is after the starting point) */ + + endMatch = startMatch; + while ((endMatch = strchr(endMatch, '"'))) { + if (LIKELY(*(endMatch - 1) != '\\')) { + break; + } + else { + endMatch++; + } + } + + if (endMatch) { + /* return the slice indicated */ + return BLI_strdupn(startMatch, (size_t)(endMatch - startMatch)); + } + } + return BLI_strdupn("", 0); } /** @@ -410,63 +418,65 @@ char *BLI_str_quoted_substrN(const char *__restrict str, const char *__restrict * \param substr_new: The text in the string to find and replace * \retval Returns the duplicated string */ -char *BLI_str_replaceN(const char *__restrict str, const char *__restrict substr_old, const char *__restrict substr_new) +char *BLI_str_replaceN(const char *__restrict str, + const char *__restrict substr_old, + const char *__restrict substr_new) { - DynStr *ds = NULL; - size_t len_old = strlen(substr_old); - const char *match; - - BLI_assert(substr_old[0] != '\0'); - - /* while we can still find a match for the old substring that we're searching for, - * keep dicing and replacing - */ - while ((match = strstr(str, substr_old))) { - /* the assembly buffer only gets created when we actually need to rebuild the string */ - if (ds == NULL) { - ds = BLI_dynstr_new(); - } - - /* if the match position does not match the current position in the string, - * copy the text up to this position and advance the current position in the string - */ - if (str != match) { - /* add the segment of the string from str to match to the buffer, - * then restore the value at match */ - BLI_dynstr_nappend(ds, str, (match - str)); - - /* now our current position should be set on the start of the match */ - str = match; - } - - /* add the replacement text to the accumulation buffer */ - BLI_dynstr_append(ds, substr_new); - - /* advance the current position of the string up to the end of the replaced segment */ - str += len_old; - } - - /* finish off and return a new string that has had all occurrences of */ - if (ds) { - char *str_new; - - /* add what's left of the string to the assembly buffer - * - we've been adjusting str to point at the end of the replaced segments - */ - BLI_dynstr_append(ds, str); - - /* convert to new c-string (MEM_malloc'd), and free the buffer */ - str_new = BLI_dynstr_get_cstring(ds); - BLI_dynstr_free(ds); - - return str_new; - } - else { - /* just create a new copy of the entire string - we avoid going through the assembly buffer - * for what should be a bit more efficiency... - */ - return BLI_strdup(str); - } + DynStr *ds = NULL; + size_t len_old = strlen(substr_old); + const char *match; + + BLI_assert(substr_old[0] != '\0'); + + /* while we can still find a match for the old substring that we're searching for, + * keep dicing and replacing + */ + while ((match = strstr(str, substr_old))) { + /* the assembly buffer only gets created when we actually need to rebuild the string */ + if (ds == NULL) { + ds = BLI_dynstr_new(); + } + + /* if the match position does not match the current position in the string, + * copy the text up to this position and advance the current position in the string + */ + if (str != match) { + /* add the segment of the string from str to match to the buffer, + * then restore the value at match */ + BLI_dynstr_nappend(ds, str, (match - str)); + + /* now our current position should be set on the start of the match */ + str = match; + } + + /* add the replacement text to the accumulation buffer */ + BLI_dynstr_append(ds, substr_new); + + /* advance the current position of the string up to the end of the replaced segment */ + str += len_old; + } + + /* finish off and return a new string that has had all occurrences of */ + if (ds) { + char *str_new; + + /* add what's left of the string to the assembly buffer + * - we've been adjusting str to point at the end of the replaced segments + */ + BLI_dynstr_append(ds, str); + + /* convert to new c-string (MEM_malloc'd), and free the buffer */ + str_new = BLI_dynstr_get_cstring(ds); + BLI_dynstr_free(ds); + + return str_new; + } + else { + /* just create a new copy of the entire string - we avoid going through the assembly buffer + * for what should be a bit more efficiency... + */ + return BLI_strdup(str); + } } /** @@ -478,12 +488,12 @@ char *BLI_str_replaceN(const char *__restrict str, const char *__restrict substr */ void BLI_str_replace_char(char *str, char src, char dst) { - while (*str) { - if (*str == src) { - *str = dst; - } - str++; - } + while (*str) { + if (*str == src) { + *str = dst; + } + str++; + } } /** @@ -493,7 +503,7 @@ void BLI_str_replace_char(char *str, char src, char dst) */ int BLI_strcaseeq(const char *a, const char *b) { - return (BLI_strcasecmp(a, b) == 0); + return (BLI_strcasecmp(a, b) == 0); } /** @@ -501,23 +511,23 @@ int BLI_strcaseeq(const char *a, const char *b) */ char *BLI_strcasestr(const char *s, const char *find) { - register char c, sc; - register size_t len; - - if ((c = *find++) != 0) { - c = tolower(c); - len = strlen(find); - do { - do { - if ((sc = *s++) == 0) { - return (NULL); - } - sc = tolower(sc); - } while (sc != c); - } while (BLI_strncasecmp(s, find, len) != 0); - s--; - } - return ((char *) s); + register char c, sc; + register size_t len; + + if ((c = *find++) != 0) { + c = tolower(c); + len = strlen(find); + do { + do { + if ((sc = *s++) == 0) { + return (NULL); + } + sc = tolower(sc); + } while (sc != c); + } while (BLI_strncasecmp(s, find, len) != 0); + s--; + } + return ((char *)s); } /** @@ -525,195 +535,195 @@ char *BLI_strcasestr(const char *s, const char *find) */ char *BLI_strncasestr(const char *s, const char *find, size_t len) { - register char c, sc; - - if ((c = *find++) != 0) { - c = tolower(c); - if (len > 1) { - do { - do { - if ((sc = *s++) == 0) { - return NULL; - } - sc = tolower(sc); - } while (sc != c); - } while (BLI_strncasecmp(s, find, len - 1) != 0); - } - else { - { - do { - if ((sc = *s++) == 0) { - return NULL; - } - sc = tolower(sc); - } while (sc != c); - } - } - s--; - } - return ((char *)s); + register char c, sc; + + if ((c = *find++) != 0) { + c = tolower(c); + if (len > 1) { + do { + do { + if ((sc = *s++) == 0) { + return NULL; + } + sc = tolower(sc); + } while (sc != c); + } while (BLI_strncasecmp(s, find, len - 1) != 0); + } + else { + { + do { + if ((sc = *s++) == 0) { + return NULL; + } + sc = tolower(sc); + } while (sc != c); + } + } + s--; + } + return ((char *)s); } int BLI_strcasecmp(const char *s1, const char *s2) { - register int i; - register char c1, c2; - - for (i = 0;; i++) { - c1 = tolower(s1[i]); - c2 = tolower(s2[i]); - - if (c1 < c2) { - return -1; - } - else if (c1 > c2) { - return 1; - } - else if (c1 == 0) { - break; - } - } - - return 0; + register int i; + register char c1, c2; + + for (i = 0;; i++) { + c1 = tolower(s1[i]); + c2 = tolower(s2[i]); + + if (c1 < c2) { + return -1; + } + else if (c1 > c2) { + return 1; + } + else if (c1 == 0) { + break; + } + } + + return 0; } int BLI_strncasecmp(const char *s1, const char *s2, size_t len) { - register size_t i; - register char c1, c2; - - for (i = 0; i < len; i++) { - c1 = tolower(s1[i]); - c2 = tolower(s2[i]); - - if (c1 < c2) { - return -1; - } - else if (c1 > c2) { - return 1; - } - else if (c1 == 0) { - break; - } - } - - return 0; + register size_t i; + register char c1, c2; + + for (i = 0; i < len; i++) { + c1 = tolower(s1[i]); + c2 = tolower(s2[i]); + + if (c1 < c2) { + return -1; + } + else if (c1 > c2) { + return 1; + } + else if (c1 == 0) { + break; + } + } + + return 0; } /* compare number on the left size of the string */ static int left_number_strcmp(const char *s1, const char *s2, int *tiebreaker) { - const char *p1 = s1, *p2 = s2; - int numdigit, numzero1, numzero2; - - /* count and skip leading zeros */ - for (numzero1 = 0; *p1 == '0'; numzero1++) { - p1++; - } - for (numzero2 = 0; *p2 == '0'; numzero2++) { - p2++; - } - - /* find number of consecutive digits */ - for (numdigit = 0; ; numdigit++) { - if (isdigit(*(p1 + numdigit)) && isdigit(*(p2 + numdigit))) { - continue; - } - else if (isdigit(*(p1 + numdigit))) { - return 1; /* s2 is bigger */ - } - else if (isdigit(*(p2 + numdigit))) { - return -1; /* s1 is bigger */ - } - else { - break; - } - } - - /* same number of digits, compare size of number */ - if (numdigit > 0) { - int compare = (int)strncmp(p1, p2, (size_t)numdigit); - - if (compare != 0) { - return compare; - } - } - - /* use number of leading zeros as tie breaker if still equal */ - if (*tiebreaker == 0) { - if (numzero1 > numzero2) { - *tiebreaker = 1; - } - else if (numzero1 < numzero2) { - *tiebreaker = -1; - } - } - - return 0; + const char *p1 = s1, *p2 = s2; + int numdigit, numzero1, numzero2; + + /* count and skip leading zeros */ + for (numzero1 = 0; *p1 == '0'; numzero1++) { + p1++; + } + for (numzero2 = 0; *p2 == '0'; numzero2++) { + p2++; + } + + /* find number of consecutive digits */ + for (numdigit = 0;; numdigit++) { + if (isdigit(*(p1 + numdigit)) && isdigit(*(p2 + numdigit))) { + continue; + } + else if (isdigit(*(p1 + numdigit))) { + return 1; /* s2 is bigger */ + } + else if (isdigit(*(p2 + numdigit))) { + return -1; /* s1 is bigger */ + } + else { + break; + } + } + + /* same number of digits, compare size of number */ + if (numdigit > 0) { + int compare = (int)strncmp(p1, p2, (size_t)numdigit); + + if (compare != 0) { + return compare; + } + } + + /* use number of leading zeros as tie breaker if still equal */ + if (*tiebreaker == 0) { + if (numzero1 > numzero2) { + *tiebreaker = 1; + } + else if (numzero1 < numzero2) { + *tiebreaker = -1; + } + } + + return 0; } /* natural string compare, keeping numbers in order */ int BLI_natstrcmp(const char *s1, const char *s2) { - register int d1 = 0, d2 = 0; - register char c1, c2; - int tiebreaker = 0; - - /* if both chars are numeric, to a left_number_strcmp(). - * then increase string deltas as long they are - * numeric, else do a tolower and char compare */ - - while (1) { - c1 = tolower(s1[d1]); - c2 = tolower(s2[d2]); - - if (isdigit(c1) && isdigit(c2)) { - int numcompare = left_number_strcmp(s1 + d1, s2 + d2, &tiebreaker); - - if (numcompare != 0) { - return numcompare; - } - - d1++; - while (isdigit(s1[d1])) { - d1++; - } - d2++; - while (isdigit(s2[d2])) { - d2++; - } - - c1 = tolower(s1[d1]); - c2 = tolower(s2[d2]); - } - - /* first check for '.' so "foo.bar" comes before "foo 1.bar" */ - if (c1 == '.' && c2 != '.') { - return -1; - } - if (c1 != '.' && c2 == '.') { - return 1; - } - else if (c1 < c2) { - return -1; - } - else if (c1 > c2) { - return 1; - } - else if (c1 == 0) { - break; - } - d1++; - d2++; - } - - if (tiebreaker) { - return tiebreaker; - } - - /* we might still have a different string because of lower/upper case, in - * that case fall back to regular string comparison */ - return strcmp(s1, s2); + register int d1 = 0, d2 = 0; + register char c1, c2; + int tiebreaker = 0; + + /* if both chars are numeric, to a left_number_strcmp(). + * then increase string deltas as long they are + * numeric, else do a tolower and char compare */ + + while (1) { + c1 = tolower(s1[d1]); + c2 = tolower(s2[d2]); + + if (isdigit(c1) && isdigit(c2)) { + int numcompare = left_number_strcmp(s1 + d1, s2 + d2, &tiebreaker); + + if (numcompare != 0) { + return numcompare; + } + + d1++; + while (isdigit(s1[d1])) { + d1++; + } + d2++; + while (isdigit(s2[d2])) { + d2++; + } + + c1 = tolower(s1[d1]); + c2 = tolower(s2[d2]); + } + + /* first check for '.' so "foo.bar" comes before "foo 1.bar" */ + if (c1 == '.' && c2 != '.') { + return -1; + } + if (c1 != '.' && c2 == '.') { + return 1; + } + else if (c1 < c2) { + return -1; + } + else if (c1 > c2) { + return 1; + } + else if (c1 == 0) { + break; + } + d1++; + d2++; + } + + if (tiebreaker) { + return tiebreaker; + } + + /* we might still have a different string because of lower/upper case, in + * that case fall back to regular string comparison */ + return strcmp(s1, s2); } /** @@ -722,77 +732,77 @@ int BLI_natstrcmp(const char *s1, const char *s2) */ int BLI_strcmp_ignore_pad(const char *str1, const char *str2, const char pad) { - size_t str1_len, str2_len; - - while (*str1 == pad) { - str1++; - } - while (*str2 == pad) { - str2++; - } - - str1_len = strlen(str1); - str2_len = strlen(str2); - - while (str1_len && (str1[str1_len - 1] == pad)) { - str1_len--; - } - while (str2_len && (str2[str2_len - 1] == pad)) { - str2_len--; - } - - if (str1_len == str2_len) { - return strncmp(str1, str2, str2_len); - } - else if (str1_len > str2_len) { - int ret = strncmp(str1, str2, str2_len); - if (ret == 0) { - ret = 1; - } - return ret; - } - else { - int ret = strncmp(str1, str2, str1_len); - if (ret == 0) { - ret = -1; - } - return ret; - } + size_t str1_len, str2_len; + + while (*str1 == pad) { + str1++; + } + while (*str2 == pad) { + str2++; + } + + str1_len = strlen(str1); + str2_len = strlen(str2); + + while (str1_len && (str1[str1_len - 1] == pad)) { + str1_len--; + } + while (str2_len && (str2[str2_len - 1] == pad)) { + str2_len--; + } + + if (str1_len == str2_len) { + return strncmp(str1, str2, str2_len); + } + else if (str1_len > str2_len) { + int ret = strncmp(str1, str2, str2_len); + if (ret == 0) { + ret = 1; + } + return ret; + } + else { + int ret = strncmp(str1, str2, str1_len); + if (ret == 0) { + ret = -1; + } + return ret; + } } /* determine the length of a fixed-size string */ size_t BLI_strnlen(const char *s, const size_t maxlen) { - size_t len; - - for (len = 0; len < maxlen; len++, s++) { - if (!*s) { - break; - } - } - return len; + size_t len; + + for (len = 0; len < maxlen; len++, s++) { + if (!*s) { + break; + } + } + return len; } void BLI_str_tolower_ascii(char *str, const size_t len) { - size_t i; + size_t i; - for (i = 0; (i < len) && str[i]; i++) { - if (str[i] >= 'A' && str[i] <= 'Z') { - str[i] += 'a' - 'A'; - } - } + for (i = 0; (i < len) && str[i]; i++) { + if (str[i] >= 'A' && str[i] <= 'Z') { + str[i] += 'a' - 'A'; + } + } } void BLI_str_toupper_ascii(char *str, const size_t len) { - size_t i; + size_t i; - for (i = 0; (i < len) && str[i]; i++) { - if (str[i] >= 'a' && str[i] <= 'z') { - str[i] -= 'a' - 'A'; - } - } + for (i = 0; (i < len) && str[i]; i++) { + if (str[i] >= 'a' && str[i] <= 'z') { + str[i] -= 'a' - 'A'; + } + } } /** @@ -800,14 +810,14 @@ void BLI_str_toupper_ascii(char *str, const size_t len) */ void BLI_str_rstrip(char *str) { - for (int i = (int)strlen(str) - 1; i > 0; i--) { - if (isspace(str[i])) { - str[i] = '\0'; - } - else { - break; - } - } + for (int i = (int)strlen(str) - 1; i > 0; i--) { + if (isspace(str[i])) { + str[i] = '\0'; + } + else { + break; + } + } } /** @@ -821,22 +831,22 @@ void BLI_str_rstrip(char *str) */ int BLI_str_rstrip_float_zero(char *str, const char pad) { - char *p = strchr(str, '.'); - int totstrip = 0; - if (p) { - char *end_p; - p++; /* position at first decimal place */ - end_p = p + (strlen(p) - 1); /* position at last character */ - if (end_p > p) { - while (end_p != p && *end_p == '0') { - *end_p = pad; - end_p--; - totstrip++; - } - } - } - - return totstrip; + char *p = strchr(str, '.'); + int totstrip = 0; + if (p) { + char *end_p; + p++; /* position at first decimal place */ + end_p = p + (strlen(p) - 1); /* position at last character */ + if (end_p > p) { + while (end_p != p && *end_p == '0') { + *end_p = pad; + end_p--; + totstrip++; + } + } + } + + return totstrip; } /** @@ -847,17 +857,19 @@ int BLI_str_rstrip_float_zero(char *str, const char pad) * \param str_array_len: The length of the array, or -1 for a NULL-terminated array. * \return The index of str in str_array or -1. */ -int BLI_str_index_in_array_n(const char *__restrict str, const char **__restrict str_array, const int str_array_len) +int BLI_str_index_in_array_n(const char *__restrict str, + const char **__restrict str_array, + const int str_array_len) { - int index; - const char **str_iter = str_array; - - for (index = 0; index < str_array_len; str_iter++, index++) { - if (STREQ(str, *str_iter)) { - return index; - } - } - return -1; + int index; + const char **str_iter = str_array; + + for (index = 0; index < str_array_len; str_iter++, index++) { + if (STREQ(str, *str_iter)) { + return index; + } + } + return -1; } /** @@ -869,31 +881,31 @@ int BLI_str_index_in_array_n(const char *__restrict str, const char **__restrict */ int BLI_str_index_in_array(const char *__restrict str, const char **__restrict str_array) { - int index; - const char **str_iter = str_array; - - for (index = 0; *str_iter; str_iter++, index++) { - if (STREQ(str, *str_iter)) { - return index; - } - } - return -1; + int index; + const char **str_iter = str_array; + + for (index = 0; *str_iter; str_iter++, index++) { + if (STREQ(str, *str_iter)) { + return index; + } + } + return -1; } bool BLI_strn_endswith(const char *__restrict str, const char *__restrict end, size_t slength) { - size_t elength = strlen(end); - - if (elength < slength) { - const char *iter = &str[slength - elength]; - while (*iter) { - if (*iter++ != *end++) { - return false; - } - } - return true; - } - return false; + size_t elength = strlen(end); + + if (elength < slength) { + const char *iter = &str[slength - elength]; + while (*iter) { + if (*iter++ != *end++) { + return false; + } + } + return true; + } + return false; } /** @@ -903,10 +915,10 @@ bool BLI_strn_endswith(const char *__restrict str, const char *__restrict end, s * \param end: The string we look for at the end. * \return If str ends with end. */ -bool BLI_str_endswith(const char *__restrict str, const char * __restrict end) +bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) { - const size_t slength = strlen(str); - return BLI_strn_endswith(str, end, slength); + const size_t slength = strlen(str); + return BLI_strn_endswith(str, end, slength); } /** @@ -920,7 +932,7 @@ bool BLI_str_endswith(const char *__restrict str, const char * __restrict end) */ size_t BLI_str_partition(const char *str, const char delim[], const char **sep, const char **suf) { - return BLI_str_partition_ex(str, NULL, delim, sep, suf, false); + return BLI_str_partition_ex(str, NULL, delim, sep, suf, false); } /** @@ -934,7 +946,7 @@ size_t BLI_str_partition(const char *str, const char delim[], const char **sep, */ size_t BLI_str_rpartition(const char *str, const char delim[], const char **sep, const char **suf) { - return BLI_str_partition_ex(str, NULL, delim, sep, suf, true); + return BLI_str_partition_ex(str, NULL, delim, sep, suf, true); } /** @@ -948,74 +960,78 @@ size_t BLI_str_rpartition(const char *str, const char delim[], const char **sep, * \param from_right: If %true, search from the right of \a str, else, search from its left. * \return The length of the prefix (i.e. *sep - str). */ -size_t BLI_str_partition_ex( - const char *str, const char *end, const char delim[], const char **sep, const char **suf, const bool from_right) +size_t BLI_str_partition_ex(const char *str, + const char *end, + const char delim[], + const char **sep, + const char **suf, + const bool from_right) { - const char *d; - char *(*func)(const char *str, int c) = from_right ? strrchr : strchr; - - BLI_assert(end == NULL || end > str); - - *sep = *suf = NULL; - - for (d = delim; *d != '\0'; ++d) { - const char *tmp; - - if (end) { - if (from_right) { - for (tmp = end - 1; (tmp >= str) && (*tmp != *d); tmp--) { - /* pass */ - } - if (tmp < str) { - tmp = NULL; - } - } - else { - tmp = func(str, *d); - if (tmp >= end) { - tmp = NULL; - } - } - } - else { - tmp = func(str, *d); - } - - if (tmp && (from_right ? (*sep < tmp) : (!*sep || *sep > tmp))) { - *sep = tmp; - } - } - - if (*sep) { - *suf = *sep + 1; - return (size_t)(*sep - str); - } - - return end ? (size_t)(end - str) : strlen(str); + const char *d; + char *(*func)(const char *str, int c) = from_right ? strrchr : strchr; + + BLI_assert(end == NULL || end > str); + + *sep = *suf = NULL; + + for (d = delim; *d != '\0'; ++d) { + const char *tmp; + + if (end) { + if (from_right) { + for (tmp = end - 1; (tmp >= str) && (*tmp != *d); tmp--) { + /* pass */ + } + if (tmp < str) { + tmp = NULL; + } + } + else { + tmp = func(str, *d); + if (tmp >= end) { + tmp = NULL; + } + } + } + else { + tmp = func(str, *d); + } + + if (tmp && (from_right ? (*sep < tmp) : (!*sep || *sep > tmp))) { + *sep = tmp; + } + } + + if (*sep) { + *suf = *sep + 1; + return (size_t)(*sep - str); + } + + return end ? (size_t)(end - str) : strlen(str); } static size_t BLI_str_format_int_grouped_ex(char src[16], char dst[16], int num_len) { - char *p_src = src; - char *p_dst = dst; - - const char separator = ','; - int commas; - - if (*p_src == '-') { - *p_dst++ = *p_src++; - num_len--; - } - - for (commas = 2 - num_len % 3; *p_src; commas = (commas + 1) % 3) { - *p_dst++ = *p_src++; - if (commas == 1) { - *p_dst++ = separator; - } - } - *--p_dst = '\0'; - - return (size_t)(p_dst - dst); + char *p_src = src; + char *p_dst = dst; + + const char separator = ','; + int commas; + + if (*p_src == '-') { + *p_dst++ = *p_src++; + num_len--; + } + + for (commas = 2 - num_len % 3; *p_src; commas = (commas + 1) % 3) { + *p_dst++ = *p_src++; + if (commas == 1) { + *p_dst++ = separator; + } + } + *--p_dst = '\0'; + + return (size_t)(p_dst - dst); } /** @@ -1028,10 +1044,10 @@ static size_t BLI_str_format_int_grouped_ex(char src[16], char dst[16], int num_ */ size_t BLI_str_format_int_grouped(char dst[16], int num) { - char src[16]; - int num_len = sprintf(src, "%d", num); + char src[16]; + int num_len = sprintf(src, "%d", num); - return BLI_str_format_int_grouped_ex(src, dst, num_len); + return BLI_str_format_int_grouped_ex(src, dst, num_len); } /** @@ -1044,12 +1060,12 @@ size_t BLI_str_format_int_grouped(char dst[16], int num) */ size_t BLI_str_format_uint64_grouped(char dst[16], uint64_t num) { - /* NOTE: Buffer to hold maximum unsigned int64, which is 1.8e+19. but - * we also need space for commas and null-terminator. */ - char src[27]; - int num_len = sprintf(src, "%"PRIu64"", num); + /* NOTE: Buffer to hold maximum unsigned int64, which is 1.8e+19. but + * we also need space for commas and null-terminator. */ + char src[27]; + int num_len = sprintf(src, "%" PRIu64 "", num); - return BLI_str_format_int_grouped_ex(src, dst, num_len); + return BLI_str_format_int_grouped_ex(src, dst, num_len); } /** @@ -1063,28 +1079,28 @@ size_t BLI_str_format_uint64_grouped(char dst[16], uint64_t num) */ void BLI_str_format_byte_unit(char dst[15], long long int bytes, const bool base_10) { - double bytes_converted = bytes; - int order = 0; - int decimals; - const int base = base_10 ? 1000 : 1024; - const char *units_base_10[] = {"B", "KB", "MB", "GB", "TB", "PB"}; - const char *units_base_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB"}; - const int tot_units = ARRAY_SIZE(units_base_2); - - BLI_STATIC_ASSERT(ARRAY_SIZE(units_base_2) == ARRAY_SIZE(units_base_10), "array size mismatch"); - - while ((ABS(bytes_converted) >= base) && ((order + 1) < tot_units)) { - bytes_converted /= base; - order++; - } - decimals = MAX2(order - 1, 0); - - /* Format value first, stripping away floating zeroes. */ - const size_t dst_len = 15; - size_t len = BLI_snprintf_rlen(dst, dst_len, "%.*f", decimals, bytes_converted); - len -= (size_t)BLI_str_rstrip_float_zero(dst, '\0'); - dst[len++] = ' '; - BLI_strncpy(dst + len, base_10 ? units_base_10[order] : units_base_2[order], dst_len - len); + double bytes_converted = bytes; + int order = 0; + int decimals; + const int base = base_10 ? 1000 : 1024; + const char *units_base_10[] = {"B", "KB", "MB", "GB", "TB", "PB"}; + const char *units_base_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB"}; + const int tot_units = ARRAY_SIZE(units_base_2); + + BLI_STATIC_ASSERT(ARRAY_SIZE(units_base_2) == ARRAY_SIZE(units_base_10), "array size mismatch"); + + while ((ABS(bytes_converted) >= base) && ((order + 1) < tot_units)) { + bytes_converted /= base; + order++; + } + decimals = MAX2(order - 1, 0); + + /* Format value first, stripping away floating zeroes. */ + const size_t dst_len = 15; + size_t len = BLI_snprintf_rlen(dst, dst_len, "%.*f", decimals, bytes_converted); + len -= (size_t)BLI_str_rstrip_float_zero(dst, '\0'); + dst[len++] = ' '; + BLI_strncpy(dst + len, base_10 ? units_base_10[order] : units_base_2[order], dst_len - len); } /** @@ -1098,37 +1114,36 @@ void BLI_str_format_byte_unit(char dst[15], long long int bytes, const bool base * \return The number of words found in \a str */ int BLI_string_find_split_words( - const char *str, const size_t len, - const char delim, int r_words[][2], int words_max) + const char *str, const size_t len, const char delim, int r_words[][2], int words_max) { - int n = 0, i; - bool charsearch = true; - - /* Skip leading spaces */ - for (i = 0; (i < len) && (str[i] != '\0'); i++) { - if (str[i] != delim) { - break; - } - } - - for (; (i < len) && (str[i] != '\0') && (n < words_max); i++) { - if ((str[i] != delim) && (charsearch == true)) { - r_words[n][0] = i; - charsearch = false; - } - else { - if ((str[i] == delim) && (charsearch == false)) { - r_words[n][1] = i - r_words[n][0]; - n++; - charsearch = true; - } - } - } - - if (charsearch == false) { - r_words[n][1] = i - r_words[n][0]; - n++; - } - - return n; + int n = 0, i; + bool charsearch = true; + + /* Skip leading spaces */ + for (i = 0; (i < len) && (str[i] != '\0'); i++) { + if (str[i] != delim) { + break; + } + } + + for (; (i < len) && (str[i] != '\0') && (n < words_max); i++) { + if ((str[i] != delim) && (charsearch == true)) { + r_words[n][0] = i; + charsearch = false; + } + else { + if ((str[i] == delim) && (charsearch == false)) { + r_words[n][1] = i - r_words[n][0]; + n++; + charsearch = true; + } + } + } + + if (charsearch == false) { + r_words[n][1] = i - r_words[n][0]; + n++; + } + + return n; } -- cgit v1.2.3