Code Cleanup: style and redundant casts
[blender.git] / source / blender / blenlib / intern / string.c
index 906a3095f91c610135968d62c91b80ad6dbbcf62..6b738fab45e281a167ec5873918fd33fe755d76c 100644 (file)
 
 #include "BLI_utildefines.h"
 
+#ifdef __GNUC__
+#  pragma GCC diagnostic error "-Wsign-conversion"
+#endif
+
+// #define DEBUG_STRSIZE
+
 /**
  * Duplicates the first \a len bytes of cstring \a str
  * into a newly mallocN'd string and returns it. \a str
@@ -81,15 +87,18 @@ char *BLI_strdup(const char *str)
  */
 char *BLI_strdupcat(const char *__restrict str1, const char *__restrict str2)
 {
-       size_t len;
-       char *n;
-       
-       len = strlen(str1) + strlen(str2);
-       n = MEM_mallocN(len + 1, "strdupcat");
-       strcpy(n, str1);
-       strcat(n, 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;
        
-       return n;
+       str = MEM_mallocN(str1_len + str2_len, "strdupcat");
+       s = str;
+
+       memcpy(s, str1, str1_len); s += str1_len;
+       memcpy(s, str2, str2_len);
+
+       return str;
 }
 
 /**
@@ -107,6 +116,10 @@ char *BLI_strncpy(char *__restrict dst, const char *__restrict src, const size_t
        size_t srclen = BLI_strnlen(src, maxncpy - 1);
        BLI_assert(maxncpy != 0);
 
+#ifdef DEBUG_STRSIZE
+       memset(dst, 0xff, sizeof(*dst) * maxncpy);
+#endif
+
        memcpy(dst, src, srclen);
        dst[srclen] = '\0';
        return dst;
@@ -130,29 +143,40 @@ size_t BLI_strncpy_rlen(char *__restrict dst, const char *__restrict src, const
        size_t srclen = BLI_strnlen(src, maxncpy - 1);
        BLI_assert(maxncpy != 0);
 
+#ifdef DEBUG_STRSIZE
+       memset(dst, 0xff, sizeof(*dst) * maxncpy);
+#endif
+
        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;
+}
+
 /**
  * Portable replacement for #vsnprintf
  */
-size_t BLI_vsnprintf(char *__restrict buffer, size_t count, 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;
 
        BLI_assert(buffer != NULL);
-       BLI_assert(count > 0);
+       BLI_assert(maxncpy > 0);
        BLI_assert(format != NULL);
 
-       n = vsnprintf(buffer, count, format, arg);
+       n = (size_t)vsnprintf(buffer, maxncpy, format, arg);
 
-       if (n != -1 && n < count) {
+       if (n != -1 && n < maxncpy) {
                buffer[n] = '\0';
        }
        else {
-               buffer[count - 1] = '\0';
+               buffer[maxncpy - 1] = '\0';
        }
 
        return n;
@@ -161,13 +185,17 @@ size_t BLI_vsnprintf(char *__restrict buffer, size_t count, const char *__restri
 /**
  * Portable replacement for #snprintf
  */
-size_t BLI_snprintf(char *__restrict buffer, size_t count, const char *__restrict format, ...)
+size_t BLI_snprintf(char *__restrict dst, size_t maxncpy, const char *__restrict format, ...)
 {
        size_t n;
        va_list arg;
 
+#ifdef DEBUG_STRSIZE
+       memset(dst, 0xff, sizeof(*dst) * maxncpy);
+#endif
+
        va_start(arg, format);
-       n = BLI_vsnprintf(buffer, count, format, arg);
+       n = BLI_vsnprintf(dst, maxncpy, format, arg);
        va_end(arg);
 
        return n;
@@ -215,6 +243,7 @@ size_t BLI_strescape(char *__restrict dst, const char *__restrict src, const siz
                                goto escape_finish;
                        case '\\':
                        case '"':
+                               /* fall-through */
 
                        /* less common but should also be support */
                        case '\t':
@@ -228,9 +257,10 @@ size_t BLI_strescape(char *__restrict dst, const char *__restrict src, const siz
                                        /* not enough space to escape */
                                        break;
                                }
-                       /* intentionally pass through */
+                               /* fall-through */
                        default:
                                *dst = *src;
+                               break;
                }
                dst++;
                src++;
@@ -275,34 +305,30 @@ char *BLI_str_quoted_substrN(const char *__restrict str, const char *__restrict
 }
 
 /**
+ * string with all instances of substr_old replaced with substr_new,
  * Returns a copy of the cstring \a str into a newly mallocN'd
- * string with all instances of oldText replaced with newText,
  * and returns it.
  *
  * \note A rather wasteful string-replacement utility, though this shall do for now...
  * Feel free to replace this with an even safe + nicer alternative
  *
- * \param str The string to replace occurrences of oldText in
- * \param oldText The text in the string to find and replace
- * \param newText The text in the string to find and replace
+ * \param str The string to replace occurrences of substr_old in
+ * \param substr_old The text in the string to find and replace
+ * \param substr_new The text in the string to find and replace
  * \retval Returns the duplicated string
  */
-char *BLI_replacestr(char *__restrict str, const char *__restrict oldText, const char *__restrict newText)
+char *BLI_replacestrN(const char *__restrict str, const char *__restrict substr_old, const char *__restrict substr_new)
 {
        DynStr *ds = NULL;
-       size_t lenOld = strlen(oldText);
-       char *match;
-       
-       /* sanity checks */
-       if ((str == NULL) || (str[0] == 0))
-               return NULL;
-       else if ((oldText == NULL) || (newText == NULL) || (oldText[0] == 0))
-               return BLI_strdup(str);
-       
+       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, oldText)) ) {
+       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();
@@ -311,39 +337,35 @@ char *BLI_replacestr(char *__restrict str, const char *__restrict oldText, const
                 * copy the text up to this position and advance the current position in the string
                 */
                if (str != match) {
-                       /* replace the token at the 'match' position with \0 so that the copied string will be ok,
-                        * add the segment of the string from str to match to the buffer, then restore the value at match
+                       /* add the segment of the string from str to match to the buffer, then restore the value at match
                         */
-                       match[0] = 0;
-                       BLI_dynstr_append(ds, str);
-                       match[0] = oldText[0];
+                       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, newText);
+               BLI_dynstr_append(ds, substr_new);
                
                /* advance the current position of the string up to the end of the replaced segment */
-               str += lenOld;
+               str += len_old;
        }
        
        /* finish off and return a new string that has had all occurrences of */
        if (ds) {
-               char *newStr;
+               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
+                * - we've been adjusting str to point at the end of the replaced segments
                 */
-               if (str != NULL)
-                       BLI_dynstr_append(ds, str);
+               BLI_dynstr_append(ds, str);
                
                /* convert to new c-string (MEM_malloc'd), and free the buffer */
-               newStr = BLI_dynstr_get_cstring(ds);
+               str_new = BLI_dynstr_get_cstring(ds);
                BLI_dynstr_free(ds);
                
-               return newStr;
+               return str_new;
        }
        else {
                /* just create a new copy of the entire string - we avoid going through the assembly buffer 
@@ -433,13 +455,57 @@ int BLI_strncasecmp(const char *s1, const char *s2, size_t len)
        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 && (*p1 == '0'); numzero1++)
+               p1++;
+       for (numzero2 = 0; *p2 && (*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 strtol().
+       /* 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 */
 
@@ -447,23 +513,17 @@ int BLI_natstrcmp(const char *s1, const char *s2)
                c1 = tolower(s1[d1]);
                c2 = tolower(s2[d2]);
                
-               if (isdigit(c1) && isdigit(c2) ) {
-                       int val1, val2;
-                       
-                       val1 = (int)strtol(s1 + d1, (char **)NULL, 10);
-                       val2 = (int)strtol(s2 + d2, (char **)NULL, 10);
+               if (isdigit(c1) && isdigit(c2)) {
+                       int numcompare = left_number_strcmp(s1 + d1, s2 + d2, &tiebreaker);
                        
-                       if (val1 < val2) {
-                               return -1;
-                       }
-                       else if (val1 > val2) {
-                               return 1;
-                       }
+                       if (numcompare != 0)
+                               return numcompare;
+
                        d1++;
-                       while (isdigit(s1[d1]) )
+                       while (isdigit(s1[d1]))
                                d1++;
                        d2++;
-                       while (isdigit(s2[d2]) )
+                       while (isdigit(s2[d2]))
                                d2++;
                        
                        c1 = tolower(s1[d1]);
@@ -487,29 +547,27 @@ int BLI_natstrcmp(const char *s1, const char *s2)
                d1++;
                d2++;
        }
-       return 0;
+       return tiebreaker;
 }
 
-void BLI_timestr(double _time, char *str)
+void BLI_timestr(double _time, char *str, size_t maxlen)
 {
        /* format 00:00:00.00 (hr:min:sec) string has to be 12 long */
        int  hr = ( (int)  _time) / (60 * 60);
        int min = (((int)  _time) / 60 ) % 60;
-       int sec = ( (int) (_time)) % 60;
+       int sec = ( (int)  _time) % 60;
        int hun = ( (int) (_time   * 100.0)) % 100;
-       
+
        if (hr) {
-               sprintf(str, "%.2d:%.2d:%.2d.%.2d", hr, min, sec, hun);
+               BLI_snprintf(str, maxlen, "%.2d:%.2d:%.2d.%.2d", hr, min, sec, hun);
        }
        else {
-               sprintf(str, "%.2d:%.2d.%.2d", min, sec, hun);
+               BLI_snprintf(str, maxlen, "%.2d:%.2d.%.2d", min, sec, hun);
        }
-       
-       str[11] = 0;
 }
 
 /* determine the length of a fixed-size string */
-size_t BLI_strnlen(const char *s, size_t maxlen)
+size_t BLI_strnlen(const char *s, const size_t maxlen)
 {
        size_t len;
 
@@ -524,7 +582,7 @@ void BLI_ascii_strtolower(char *str, const size_t len)
 {
        size_t i;
 
-       for (i = 0; i < len; i++)
+       for (i = 0; (i < len) && str[i]; i++)
                if (str[i] >= 'A' && str[i] <= 'Z')
                        str[i] += 'a' - 'A';
 }
@@ -533,7 +591,7 @@ void BLI_ascii_strtoupper(char *str, const size_t len)
 {
        size_t i;
 
-       for (i = 0; i < len; i++)
+       for (i = 0; (i < len) && str[i]; i++)
                if (str[i] >= 'a' && str[i] <= 'z')
                        str[i] -= 'a' - 'A';
 }
@@ -544,7 +602,7 @@ void BLI_ascii_strtoupper(char *str, const size_t len)
  *   2.0010 -> 2.001
  *
  * \param str
- * \param len
+ * \param pad
  * \return The number of zeto's stripped.
  */
 int BLI_str_rstrip_float_zero(char *str, const char pad)