replace use of strcat() where the string offset is known.
authorCampbell Barton <ideasman42@gmail.com>
Tue, 23 Jul 2013 12:49:30 +0000 (12:49 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 23 Jul 2013 12:49:30 +0000 (12:49 +0000)
also correct bad logic with converting a textblock to 3d-text, bytes-vs-number of chars wasn't handled right.

12 files changed:
source/blender/blenkernel/intern/property.c
source/blender/blenkernel/intern/text.c
source/blender/blenlib/BLI_string_utf8.h
source/blender/blenlib/intern/path_util.c
source/blender/blenlib/intern/string.c
source/blender/blenlib/intern/string_utf8.c
source/blender/blenloader/intern/writefile.c
source/blender/editors/curve/editfont.c
source/blender/imbuf/intern/thumbs.c
source/blender/windowmanager/intern/wm_keymap.c
source/gameengine/BlenderRoutines/BL_KetsjiEmbedStart.cpp
source/gameengine/GamePlayer/ghost/GPG_ghost.cpp

index ec23a7db8a1bfbb981ae70ff2a4d41e551b6c491..73f2a864e32ac296b8e056410ea89da9405be937 100644 (file)
@@ -177,9 +177,9 @@ void BKE_bproperty_unique(bProperty *first, bProperty *prop, int force)
                        i = 0;
 
                        do { /* ensure we have enough chars for the new number in the name */
-                               BLI_snprintf(num, sizeof(num), "%d", i++);
-                               BLI_strncpy(new_name, base_name, sizeof(prop->name) - strlen(num));
-                               strcat(new_name, num);
+                               const size_t num_len = BLI_snprintf(num, sizeof(num), "%d", i++);
+                               BLI_snprintf(new_name, sizeof(prop->name),
+                                            "%.*s%s", (int)(sizeof(prop->name) - num_len), base_name, num);
                        } while (bproperty_get(first, prop, new_name));
 
                        BLI_strncpy(prop->name, new_name, sizeof(prop->name));
index 8d63be5fbd5a9c967050327ba82c24a82cc71aac..0daa9de3ae268100f2e22e12687def4e9639d5c8 100644 (file)
@@ -2359,7 +2359,7 @@ static void txt_delete_line(Text *text, TextLine *line)
 
 static void txt_combine_lines(Text *text, TextLine *linea, TextLine *lineb)
 {
-       char *tmp;
+       char *tmp, *s;
 
        if (!text) return;
        
@@ -2368,8 +2368,10 @@ static void txt_combine_lines(Text *text, TextLine *linea, TextLine *lineb)
 
        tmp = MEM_mallocN(linea->len + lineb->len + 1, "textline_string");
        
-       strcpy(tmp, linea->line);
-       strcat(tmp, lineb->line);
+       s = tmp;
+       s += BLI_strcpy_rlen(s, linea->line);
+       s += BLI_strcpy_rlen(s, lineb->line);
+       (void)s;
 
        make_new_line(linea, tmp);
        
index adef843d2cc18ff439fa5252d9637a7dc06a5bd9..db32190494aa6fdf1141b77b6d4956becbb2f284 100644 (file)
 extern "C" {
 #endif
 
-char        *BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy);
-char        *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy);
-int          BLI_utf8_invalid_byte(const char *str, int length);
-int          BLI_utf8_invalid_strip(char *str, int length);
+#ifdef __GNUC__
+#  define ATTR_NONULL __attribute__((nonnull))
+#  define ATTR_NONULL_FIRST  __attribute__((nonnull(1)))
+#  define ATTR_UNUSED_RESULT __attribute__((warn_unused_result))
+#else
+#  define ATTR_NONULL
+#  define ATTR_NONULL_FIRST
+#  define ATTR_UNUSED_RESULT
+#endif
+
+char        *BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy)  ATTR_NONULL;
+char        *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy)  ATTR_NONULL;
+int          BLI_utf8_invalid_byte(const char *str, int length)  ATTR_NONULL;
+int          BLI_utf8_invalid_strip(char *str, int length)  ATTR_NONULL;
 
-int          BLI_str_utf8_size(const char *p); /* warning, can return -1 on bad chars */
-int          BLI_str_utf8_size_safe(const char *p);
+int          BLI_str_utf8_size(const char *p)  ATTR_NONULL; /* warning, can return -1 on bad chars */
+int          BLI_str_utf8_size_safe(const char *p)  ATTR_NONULL;
 /* copied from glib */
-unsigned int BLI_str_utf8_as_unicode(const char *p);
-unsigned int BLI_str_utf8_as_unicode_and_size(const char *__restrict p, size_t *__restrict index);
-unsigned int BLI_str_utf8_as_unicode_and_size_safe(const char *__restrict p, size_t *__restrict index);
-unsigned int BLI_str_utf8_as_unicode_step(const char *__restrict p, size_t *__restrict index);
+unsigned int BLI_str_utf8_as_unicode(const char *p)  ATTR_NONULL;
+unsigned int BLI_str_utf8_as_unicode_and_size(const char *__restrict p, size_t *__restrict index)  ATTR_NONULL;
+unsigned int BLI_str_utf8_as_unicode_and_size_safe(const char *__restrict p, size_t *__restrict index)  ATTR_NONULL;
+unsigned int BLI_str_utf8_as_unicode_step(const char *__restrict p, size_t *__restrict index)  ATTR_NONULL;
 size_t       BLI_str_utf8_from_unicode(unsigned int c, char *outbuf);
 
-char        *BLI_str_find_prev_char_utf8(const char *str, const char *p);
-char        *BLI_str_find_next_char_utf8(const char *p, const char *end);
-char        *BLI_str_prev_char_utf8(const char *p);
+char        *BLI_str_find_prev_char_utf8(const char *str, const char *p)  ATTR_NONULL;
+char        *BLI_str_find_next_char_utf8(const char *p, const char *end)  ATTR_NONULL_FIRST;
+char        *BLI_str_prev_char_utf8(const char *p)  ATTR_NONULL;
 
 /* wchar_t functions, copied from blenders own font.c originally */
-size_t       BLI_wstrlen_utf8(const wchar_t *src);
-size_t       BLI_strlen_utf8_ex(const char *strc, int *r_len_bytes);
-size_t       BLI_strlen_utf8(const char *strc);
-size_t       BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, int *r_len_bytes);
-size_t       BLI_strnlen_utf8(const char *strc, const size_t maxlen);
-size_t       BLI_strncpy_wchar_as_utf8(char *__restrict dst, const wchar_t *__restrict src, const size_t maxcpy);
-size_t       BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst, const char *__restrict src, const size_t maxcpy);
+size_t       BLI_wstrlen_utf8(const wchar_t *src)  ATTR_NONULL;
+size_t       BLI_strlen_utf8_ex(const char *strc, size_t *r_len_bytes)  ATTR_NONULL;
+size_t       BLI_strlen_utf8(const char *strc)  ATTR_NONULL;
+size_t       BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, size_t *r_len_bytes)  ATTR_NONULL;
+size_t       BLI_strnlen_utf8(const char *strc, const size_t maxlen)  ATTR_NONULL;
+size_t       BLI_strncpy_wchar_as_utf8(char *__restrict dst, const wchar_t *__restrict src, const size_t maxcpy)  ATTR_NONULL;
+size_t       BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst, const char *__restrict src, const size_t maxcpy)  ATTR_NONULL;
 
 /* count columns that character/string occupies, based on wcwidth.c */
 int          BLI_wcwidth(wchar_t ucs);
-int          BLI_wcswidth(const wchar_t *pwcs, size_t n);
-int          BLI_str_utf8_char_width(const char *p); /* warning, can return -1 on bad chars */
-int          BLI_str_utf8_char_width_safe(const char *p);
+int          BLI_wcswidth(const wchar_t *pwcs, size_t n)  ATTR_NONULL;
+int          BLI_str_utf8_char_width(const char *p)  ATTR_NONULL; /* warning, can return -1 on bad chars */
+int          BLI_str_utf8_char_width_safe(const char *p)  ATTR_NONULL;
 
 #define      BLI_UTF8_MAX 6        /* mem */
 #define      BLI_UTF8_WIDTH_MAX 2  /* columns */
 #define      BLI_UTF8_ERR ((unsigned int)-1)
 
+#undef ATTR_NONULL
+#undef ATTR_NONULL_FIRST
+#undef ATTR_UNUSED_RESULT
+
 #ifdef __cplusplus
 }
 #endif
index c5205ed5d1885c64bdabf393bea0bb735f5c0d46..762c4845943fac46596620e1584ca9093e67984b 100644 (file)
@@ -695,8 +695,10 @@ bool BLI_path_frame(char *path, int frame, int digits)
 
        if (stringframe_chars(path, &ch_sta, &ch_end)) { /* warning, ch_end is the last # +1 */
                char tmp[FILE_MAX];
-               sprintf(tmp, "%.*s%.*d%s", ch_sta, path, ch_end - ch_sta, frame, path + ch_end);
-               strcpy(path, tmp);
+               BLI_snprintf(tmp, sizeof(tmp),
+                            "%.*s%.*d%s",
+                            ch_sta, path, ch_end - ch_sta, frame, path + ch_end);
+               BLI_strncpy(path, tmp, FILE_MAX);
                return true;
        }
        return false;
index cb0d4ae307d1a5ea775ef7a88032c20cbbe1a272..3de57ccb54f313d9d591f4425b30b813cf878aaf 100644 (file)
@@ -87,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;
 }
 
 /**
index d435ed8f6e7730c7ce1000d0eb86bd76ef65483f..225b3c5538f7d37123447e2579dbaa63c03cc224 100644 (file)
@@ -260,7 +260,7 @@ size_t BLI_wstrlen_utf8(const wchar_t *src)
        return len;
 }
 
-size_t BLI_strlen_utf8_ex(const char *strc, int *r_len_bytes)
+size_t BLI_strlen_utf8_ex(const char *strc, size_t *r_len_bytes)
 {
        size_t len;
        const char *strc_orig = strc;
@@ -268,7 +268,7 @@ size_t BLI_strlen_utf8_ex(const char *strc, int *r_len_bytes)
        for (len = 0; *strc; len++)
                strc += BLI_str_utf8_size_safe(strc);
 
-       *r_len_bytes = (strc - strc_orig);
+       *r_len_bytes = (size_t)(strc - strc_orig);
        return len;
 }
 
@@ -282,7 +282,7 @@ size_t BLI_strlen_utf8(const char *strc)
        return len;
 }
 
-size_t BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, int *r_len_bytes)
+size_t BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, size_t *r_len_bytes)
 {
        size_t len;
        const char *strc_orig = strc;
@@ -292,7 +292,7 @@ size_t BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, int *r_len_byt
                strc += BLI_str_utf8_size_safe(strc);
        }
 
-       *r_len_bytes = (strc - strc_orig);
+       *r_len_bytes = (size_t)(strc - strc_orig);
        return len;
 }
 
index dd4361be1ff704ce64b64e5797fda502181d7756..e170107713c7836f964fd1ec4f6a4a5f08fef573 100644 (file)
@@ -1660,8 +1660,8 @@ static void write_curves(WriteData *wd, ListBase *idbase)
                        
                        if (cu->vfont) {
                                /* TODO, sort out 'cu->len', in editmode its character, object mode its bytes */
-                               int len_bytes;
-                               int len_chars = BLI_strlen_utf8_ex(cu->str, &len_bytes);
+                               size_t len_bytes;
+                               size_t len_chars = BLI_strlen_utf8_ex(cu->str, &len_bytes);
 
                                writedata(wd, DATA, len_bytes + 1, cu->str);
                                writestruct(wd, DATA, "CharInfo", len_chars + 1, cu->strinfo);
index db4e4dc85009c6ffc3f00005145d32dd065420e4..b9759e16f20a2481dc513329920ab8e8852fff8b 100644 (file)
@@ -446,7 +446,9 @@ static void txt_add_object(bContext *C, TextLine *firstline, int totline, float
        Object *obedit;
        Base *base;
        struct TextLine *tmp;
-       int nchars = 0, a;
+       int nchars = 0, nbytes = 0;
+       char *s;
+       int a;
        float rot[3] = {0.f, 0.f, 0.f};
        
        obedit = BKE_object_add(bmain, scene, OB_FONT);
@@ -463,26 +465,38 @@ static void txt_add_object(bContext *C, TextLine *firstline, int totline, float
        cu->vfont = BKE_vfont_builtin_get();
        cu->vfont->id.us++;
 
-       for (tmp = firstline, a = 0; cu->len < MAXTEXT && a < totline; tmp = tmp->next, a++)
-               nchars += strlen(tmp->line) + 1;
+       for (tmp = firstline, a = 0; nbytes < MAXTEXT && a < totline; tmp = tmp->next, a++) {
+               size_t nchars_line, nbytes_line;
+               nchars_line = BLI_strlen_utf8_ex(tmp->line, &nbytes_line);
+               nchars += nchars_line + 1;
+               nbytes += nbytes_line + 1;
+       }
 
        if (cu->str) MEM_freeN(cu->str);
        if (cu->strinfo) MEM_freeN(cu->strinfo);
 
-       cu->str = MEM_callocN(nchars + 4, "str");
+       cu->str = MEM_mallocN(nbytes + 4, "str");
        cu->strinfo = MEM_callocN((nchars + 4) * sizeof(CharInfo), "strinfo");
 
-       cu->str[0] = '\0';
        cu->len = 0;
        cu->pos = 0;
-       
+
+       s = cu->str;
+       *s = '\0';
+
        for (tmp = firstline, a = 0; cu->len < MAXTEXT && a < totline; tmp = tmp->next, a++) {
-               strcat(cu->str, tmp->line);
-               cu->len += strlen(tmp->line);
+               size_t nbytes_line;
+
+               nbytes_line = BLI_strcpy_rlen(s, tmp->line);
+
+               s += nbytes_line;
+               cu->len += nbytes_line;
 
                if (tmp->next) {
-                       strcat(cu->str, "\n");
-                       cu->len++;
+                       nbytes_line = BLI_strcpy_rlen(s, "\n");
+
+                       s += nbytes_line;
+                       cu->len += nbytes_line;
                }
 
                cu->pos = cu->len;
index 59b78109aaf8039ed6f8e9c3f29fce8ff9d088f3..2e43e46f946a036736369bc0299b83aa1ded0f15 100644 (file)
 
 static int get_thumb_dir(char *dir, ThumbSize size)
 {
+       char *s = dir;
 #ifdef WIN32
        wchar_t dir_16[MAX_PATH];
        /* yes, applications shouldn't store data there, but so does GIMP :)*/
        SHGetSpecialFolderPathW(0, dir_16, CSIDL_PROFILE, 0);
        conv_utf_16_to_8(dir_16, dir, FILE_MAX);
-
-
+       s += strlen(dir);
 #else
        const char *home = getenv("HOME");
+       const char *subdir;
        if (!home) return 0;
-       BLI_strncpy(dir, home, FILE_MAX);
+       s += BLI_strncpy_rlen(s, home, FILE_MAX);
 #endif
        switch (size) {
                case THB_NORMAL:
-                       strcat(dir, "/.thumbnails/normal/");
+                       subdir = "/.thumbnails/normal/";
                        break;
                case THB_LARGE:
-                       strcat(dir, "/.thumbnails/large/");
+                       subdir = "/.thumbnails/large/";
                        break;
                case THB_FAIL:
-                       strcat(dir, "/.thumbnails/fail/blender/");
+                       subdir = "/.thumbnails/fail/blender/";
                        break;
                default:
                        return 0; /* unknown size */
        }
+
+       s += BLI_strncpy_rlen(s, subdir, FILE_MAX - (s - dir));
+       (void)s;
+
        return 1;
 }
 
index 13230f48a15db909219dbc4b88b49fb0ace703e3..ff805579b447728346dfa2085178f3aa4aad8467 100644 (file)
@@ -795,6 +795,7 @@ const char *WM_key_event_string(short type)
 int WM_keymap_item_to_string(wmKeyMapItem *kmi, char *str, const int len)
 {
        char buf[128];
+       char *p = buf;
 
        buf[0] = 0;
 
@@ -803,28 +804,28 @@ int WM_keymap_item_to_string(wmKeyMapItem *kmi, char *str, const int len)
            kmi->alt == KM_ANY &&
            kmi->oskey == KM_ANY)
        {
-               strcat(buf, "Any ");
+               p += BLI_strcpy_rlen(p, "Any ");
        }
        else {
                if (kmi->shift)
-                       strcat(buf, "Shift ");
+                       p += BLI_strcpy_rlen(p, "Shift ");
 
                if (kmi->ctrl)
-                       strcat(buf, "Ctrl ");
+                       p += BLI_strcpy_rlen(p, "Ctrl ");
 
                if (kmi->alt)
-                       strcat(buf, "Alt ");
+                       p += BLI_strcpy_rlen(p, "Alt ");
 
                if (kmi->oskey)
-                       strcat(buf, "Cmd ");
+                       p += BLI_strcpy_rlen(p, "Cmd ");
        }
                
        if (kmi->keymodifier) {
-               strcat(buf, WM_key_event_string(kmi->keymodifier));
-               strcat(buf, " ");
+               p += BLI_strcpy_rlen(p, WM_key_event_string(kmi->keymodifier));
+               p += BLI_strcpy_rlen(p, " ");
        }
 
-       strcat(buf, WM_key_event_string(kmi->type));
+       p += BLI_strcpy_rlen(p, WM_key_event_string(kmi->type));
        return BLI_strncpy_rlen(str, buf, len);
 }
 
index dbb7cbc18168766827141cd3360cf81be90a0ebe..bb4c3fd2cbc087f1eb76f79ed0a248d907f09efc 100644 (file)
@@ -384,9 +384,8 @@ extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *c
                        if (!bfd)
                        {
                                // just add "//" in front of it
-                               char temppath[242];
-                               strcpy(temppath, "//");
-                               strcat(temppath, basedpath);
+                               char temppath[FILE_MAX] = "//";
+                               BLI_strncpy(temppath + 2, basedpath, FILE_MAX - 2);
                                
                                BLI_path_abs(temppath, pathname);
                                bfd = load_game_data(temppath);
index f1edb71f4fedf5ca904712c87a062aeab47f45b2..817a4d8efac2e7dafc2757f18c42cd4f724d0c93 100644 (file)
@@ -813,9 +813,8 @@ int main(int argc, char** argv)
 
                                                if (!bfd) {
                                                        // just add "//" in front of it
-                                                       char temppath[242];
-                                                       strcpy(temppath, "//");
-                                                       strcat(temppath, basedpath);
+                                                       char temppath[FILE_MAX] = "//";
+                                                       BLI_strncpy(temppath + 2, basedpath, FILE_MAX - 2);
 
                                                        BLI_path_abs(temppath, pathname);
                                                        bfd = load_game_data(temppath);