style cleanup / comment formatting for bli/bke/bmesh
[blender.git] / source / blender / blenlib / intern / string.c
index 76193ba9a136a314c94ee4309ec838d8b23b4fa1..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
  * 
  */
 
+/** \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_strdupcat(const char *str1, const char *str2)
 {
-       int len;
+       size_t len;
        char *n;
        
        len= strlen(str1)+strlen(str2);
@@ -66,9 +67,10 @@ char *BLI_strdupcat(const char *str1, const char *str2)
        return n;
 }
 
-char *BLI_strncpy(char *dst, const char *src, int maxncpy) {
-       int srclen= strlen(src);
-       int cpylen= (srclen>(maxncpy-1))?(maxncpy-1):srclen;
+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';
@@ -76,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);
@@ -86,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';
        }
        
@@ -112,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"
  * 
@@ -123,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 " */
@@ -133,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 */
@@ -183,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;
                
@@ -207,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);
@@ -239,7 +282,8 @@ char *BLI_strcasestr(const char *s, const char *find)
 }
 
 
-int BLI_strcasecmp(const char *s1, const char *s2) {
+int BLI_strcasecmp(const char *s1, const char *s2)
+{
        int i;
 
        for (i=0; ; i++) {
@@ -258,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]);
 
@@ -281,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]);
@@ -311,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;
@@ -349,113 +399,21 @@ size_t BLI_strnlen(const char *str, size_t maxlen)
        return end ? (size_t) (end - str) : maxlen;
 }
 
-/* from libswish3, originally called u8_isvalid(),
- * modified to return the index of the bad character (byte index not utf).
- * http://svn.swish-e.org/libswish3/trunk/src/libswish3/utf8.c r3044 - campbell */
-
-/* based on the valid_utf8 routine from the PCRE library by Philip Hazel
-
-   length is in bytes, since without knowing whether the string is valid
-   it's hard to know how many characters there are! */
-
-static const char trailingBytesForUTF8[256] = {
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-       1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
-       2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5
-};
-
-int BLI_utf8_invalid_byte(const char *str, int length)
+void BLI_ascii_strtolower(char *str, int len)
 {
-    const unsigned char *p, *pend = (unsigned char*)str + length;
-    unsigned char c;
-    int ab;
-
-    for (p = (unsigned char*)str; p < pend; p++) {
-        c = *p;
-        if (c < 128)
-            continue;
-        if ((c & 0xc0) != 0xc0)
-            goto utf8_error;
-        ab = trailingBytesForUTF8[c];
-        if (length < ab)
-            goto utf8_error;
-        length -= ab;
-
-        p++;
-        /* Check top bits in the second byte */
-        if ((*p & 0xc0) != 0x80)
-            goto utf8_error;
-
-        /* Check for overlong sequences for each different length */
-        switch (ab) {
-            /* Check for xx00 000x */
-        case 1:
-            if ((c & 0x3e) == 0) goto utf8_error;
-            continue;   /* We know there aren't any more bytes to check */
-
-            /* Check for 1110 0000, xx0x xxxx */
-        case 2:
-            if (c == 0xe0 && (*p & 0x20) == 0) goto utf8_error;
-            break;
-
-            /* Check for 1111 0000, xx00 xxxx */
-        case 3:
-            if (c == 0xf0 && (*p & 0x30) == 0) goto utf8_error;
-            break;
-
-            /* Check for 1111 1000, xx00 0xxx */
-        case 4:
-            if (c == 0xf8 && (*p & 0x38) == 0) goto utf8_error;
-            break;
-
-            /* Check for leading 0xfe or 0xff,
-               and then for 1111 1100, xx00 00xx */
-        case 5:
-            if (c == 0xfe || c == 0xff ||
-                (c == 0xfc && (*p & 0x3c) == 0)) goto utf8_error;
-            break;
-        }
-
-        /* Check for valid bytes after the 2nd, if any; all must start 10 */
-        while (--ab > 0) {
-            if ((*(p+1) & 0xc0) != 0x80) goto utf8_error;
-                       p++; /* do this after so we get usable offset - campbell */
-        }
-    }
-
-    return -1;
-
-utf8_error:
-
-       return (int)((char *)p - (char *)str) - 1;
+       int i;
+
+       for(i=0; i<len; i++)
+               if(str[i] >= 'A' && str[i] <= 'Z')
+                       str[i] += 'a' - 'A';
 }
 
-int BLI_utf8_invalid_strip(char *str, int length)
+void BLI_ascii_strtoupper(char *str, int len)
 {
-       int bad_char, tot= 0;
-
-       while((bad_char= BLI_utf8_invalid_byte(str, length)) != -1) {
-               str += bad_char;
-               length -= bad_char;
-
-               if(length == 0) {
-                       /* last character bad, strip it */
-                       *str= '\0';
-                       tot++;
-                       break;
-               }
-               else {
-                       /* strip, keep looking */
-                       memmove(str, str + 1, length);
-                       tot++;
-               }
-       }
+       int i;
 
-       return tot;
+       for(i=0; i<len; i++)
+               if(str[i] >= 'a' && str[i] <= 'z')
+                       str[i] -= 'a' - 'A';
 }