style cleanup / comment formatting for bli/bke/bmesh
[blender.git] / source / blender / blenlib / intern / string.c
index 405f8c6db97c242847fd378051cd3af3e51f56aa..80f1606414ca162c17e0c84eb422415c72a128f6 100644 (file)
@@ -1,10 +1,4 @@
-/* util.c
- *
- * various string, file, list operations.
- *
- *
- * $Id$
- *
+/*
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -19,7 +13,7 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  * 
  */
 
-#include <stdio.h>
+/** \file blender/blenlib/intern/string.c
+ *  \ingroup bli
+ */
+
+
 #include <string.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include "BLI_dynstr.h"
 #include "BLI_string.h"
 
-char *BLI_strdupn(const char *str, int len) {
+char *BLI_strdupn(const char *str, const size_t len)
+{
        char *n= MEM_mallocN(len+1, "strdup");
        memcpy(n, str, len);
        n[len]= '\0';
        
        return n;
 }
-char *BLI_strdup(const char *str) {
+char *BLI_strdup(const char *str)
+{
        return BLI_strdupn(str, strlen(str));
 }
 
-char *BLI_strncpy(char *dst, const char *src, int maxncpy) {
-       int srclen= strlen(src);
-       int cpylen= (srclen>(maxncpy-1))?(maxncpy-1):srclen;
+char *BLI_strdupcat(const char *str1, const char *str2)
+{
+       size_t len;
+       char *n;
+       
+       len= strlen(str1)+strlen(str2);
+       n= MEM_mallocN(len+1, "strdupcat");
+       strcpy(n, str1);
+       strcat(n, str2);
+       
+       return n;
+}
+
+char *BLI_strncpy(char *dst, const char *src, const size_t maxncpy)
+{
+       size_t srclen= strlen(src);
+       size_t cpylen= (srclen>(maxncpy-1))?(maxncpy-1):srclen;
        
        memcpy(dst, src, cpylen);
        dst[cpylen]= '\0';
@@ -64,9 +78,9 @@ char *BLI_strncpy(char *dst, const char *src, int maxncpy) {
        return dst;
 }
 
-int BLI_snprintf(char *buffer, size_t count, const char *format, ...)
+size_t BLI_snprintf(char *buffer, size_t count, const char *format, ...)
 {
-       int n;
+       size_t n;
        va_list arg;
 
        va_start(arg, format);
@@ -74,7 +88,8 @@ int BLI_snprintf(char *buffer, size_t count, const char *format, ...)
        
        if (n != -1 && n < count) {
                buffer[n] = '\0';
-       } else {
+       }
+       else {
                buffer[count-1] = '\0';
        }
        
@@ -100,6 +115,51 @@ char *BLI_sprintfN(const char *format, ...)
        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
+ *    this basically is an ascii version of PyUnicode_EncodeUnicodeEscape()
+ *    which is a useful reference. */
+size_t BLI_strescape(char *dst, const char *src, const size_t maxlen)
+{
+       size_t len= 0;
+       while(len < maxlen) {
+               switch(*src) {
+                       case '\0':
+                               goto escape_finish;
+                       case '\\':
+                       case '"':
+
+                               /* less common but should also be support */
+                       case '\t':
+                       case '\n':
+                       case '\r':
+                               if(len + 1 <  maxlen) {
+                                       *dst++ = '\\';
+                                       len++;
+                               }
+                               else {
+                                       /* not enough space to escape */
+                                       break;
+                               }
+                               /* intentionally pass through */
+                       default:
+                               *dst = *src;
+               }
+               dst++;
+               src++;
+               len++;
+       }
+
+escape_finish:
+
+       *dst= '\0';
+
+       return len;
+}
+
+
 /* Makes a copy of the text within the "" that appear after some text 'blahblah'
  * i.e. for string 'pose["apples"]' with prefix 'pose[', it should grab "apples"
  * 
@@ -111,7 +171,7 @@ char *BLI_sprintfN(const char *format, ...)
  */
 char *BLI_getQuotedStr (const char *str, const char *prefix)
 {
-       int prefixLen = strlen(prefix);
+       size_t prefixLen = strlen(prefix);
        char *startMatch, *endMatch;
        
        /* get the starting point (i.e. where prefix starts, and add prefixLen+1 to it to get be after the first " */
@@ -121,18 +181,18 @@ char *BLI_getQuotedStr (const char *str, const char *prefix)
        endMatch= strchr(startMatch, '"'); // "  NOTE: this comment here is just so that my text editor still shows the functions ok...
        
        /* return the slice indicated */
-       return BLI_strdupn(startMatch, (int)(endMatch-startMatch));
+       return BLI_strdupn(startMatch, (size_t)(endMatch-startMatch));
 }
 
-/* Replaces all occurances of oldText with newText in str, returning a new string that doesn't 
- * contain the 'replaced' occurances.
+/* Replaces all occurrences of oldText with newText in str, returning a new string that doesn't 
+ * contain the 'replaced' occurrences.
  */
 // A rather wasteful string-replacement utility, though this shall do for now...
 // Feel free to replace this with an even safe + nicer alternative 
 char *BLI_replacestr(char *str, const char *oldText, const char *newText)
 {
        DynStr *ds= NULL;
-       int lenOld= strlen(oldText);
+       size_t lenOld= strlen(oldText);
        char *match;
        
        /* sanity checks */
@@ -171,7 +231,7 @@ char *BLI_replacestr(char *str, const char *oldText, const char *newText)
                str += lenOld;
        }
        
-       /* finish off and return a new string that has had all occurances of */
+       /* finish off and return a new string that has had all occurrences of */
        if (ds) {
                char *newStr;
                
@@ -195,11 +255,6 @@ char *BLI_replacestr(char *str, const char *oldText, const char *newText)
        }
 } 
 
-int BLI_streq(const char *a, const char *b) 
-{
-       return (strcmp(a, b)==0);
-}
-
 int BLI_strcaseeq(const char *a, const char *b) 
 {
        return (BLI_strcasecmp(a, b)==0);
@@ -208,10 +263,10 @@ int BLI_strcaseeq(const char *a, const char *b)
 /* strcasestr not available in MSVC */
 char *BLI_strcasestr(const char *s, const char *find)
 {
-    register char c, sc;
-    register size_t len;
+       register char c, sc;
+       register size_t len;
        
-    if ((c = *find++) != 0) {
+       if ((c = *find++) != 0) {
                c= tolower(c);
                len = strlen(find);
                do {
@@ -222,12 +277,13 @@ char *BLI_strcasestr(const char *s, const char *find)
                        } while (sc != c);
                } while (BLI_strncasecmp(s, find, len) != 0);
                s--;
-    }
-    return ((char *) s);
+       }
+       return ((char *) s);
 }
 
 
-int BLI_strcasecmp(const char *s1, const char *s2) {
+int BLI_strcasecmp(const char *s1, const char *s2)
+{
        int i;
 
        for (i=0; ; i++) {
@@ -246,10 +302,11 @@ int BLI_strcasecmp(const char *s1, const char *s2) {
        return 0;
 }
 
-int BLI_strncasecmp(const char *s1, const char *s2, int n) {
+int BLI_strncasecmp(const char *s1, const char *s2, size_t len)
+{
        int i;
 
-       for (i=0; i<n; i++) {
+       for (i=0; i<len; i++) {
                char c1 = tolower(s1[i]);
                char c2 = tolower(s2[i]);
 
@@ -269,11 +326,11 @@ int BLI_strncasecmp(const char *s1, const char *s2, int n) {
 int BLI_natstrcmp(const char *s1, const char *s2)
 {
        int d1= 0, d2= 0;
-       
+
        /* if both chars are numeric, to a strtol().
-          then increase string deltas as long they are 
-          numeric, else do a tolower and char compare */
-       
+        * then increase string deltas as long they are 
+        * numeric, else do a tolower and char compare */
+
        while(1) {
                char c1 = tolower(s1[d1]);
                char c2 = tolower(s2[d2]);
@@ -299,8 +356,13 @@ int BLI_natstrcmp(const char *s1, const char *s2)
                        c1 = tolower(s1[d1]);
                        c2 = tolower(s2[d2]);
                }
-               
-               if (c1<c2) {
+       
+               /* 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;
@@ -329,3 +391,29 @@ void BLI_timestr(double _time, char *str)
        
        str[11]=0;
 }
+
+/* determine the length of a fixed-size string */
+size_t BLI_strnlen(const char *str, size_t maxlen)
+{
+       const char *end = memchr(str, '\0', maxlen);
+       return end ? (size_t) (end - str) : maxlen;
+}
+
+void BLI_ascii_strtolower(char *str, int len)
+{
+       int i;
+
+       for(i=0; i<len; i++)
+               if(str[i] >= 'A' && str[i] <= 'Z')
+                       str[i] += 'a' - 'A';
+}
+
+void BLI_ascii_strtoupper(char *str, int len)
+{
+       int i;
+
+       for(i=0; i<len; i++)
+               if(str[i] >= 'a' && str[i] <= 'z')
+                       str[i] -= 'a' - 'A';
+}
+