patch [#34103] use boolean in path functions and add comments.
[blender.git] / source / blender / blenlib / intern / path_util.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  * various string, file, list operations.
28  */
29
30 /** \file blender/blenlib/intern/path_util.c
31  *  \ingroup bli
32  */
33
34
35 #include <ctype.h>
36 #include <string.h>
37 #include <stdlib.h>
38 #include <assert.h>
39
40 #include "MEM_guardedalloc.h"
41
42 #include "DNA_listBase.h"
43
44 #include "BLI_utildefines.h"
45 #include "BLI_fileops.h"
46 #include "BLI_path_util.h"
47 #include "BLI_string.h"
48 #include "BLI_string_utf8.h"
49
50 #include "../blenkernel/BKE_blender.h"  /* BLENDER_VERSION, bad level include (no function call) */
51
52 #include "GHOST_Path-api.h"
53
54 #if defined WIN32 && !defined _LIBC  || defined __sun
55 #  include "BLI_fnmatch.h" /* use fnmatch included in blenlib */
56 #else
57 #  ifndef _GNU_SOURCE
58 #    define _GNU_SOURCE
59 #  endif
60 #  include <fnmatch.h>
61 #endif
62
63 #ifdef WIN32
64 #include "utf_winfunc.h"
65 #  include <io.h>
66 #  ifdef _WIN32_IE
67 #    undef _WIN32_IE
68 #  endif
69 #  define _WIN32_IE 0x0501
70 #  include <windows.h>
71 #  include <shlobj.h>
72 #  include "BLI_winstuff.h"
73 #else /* non windows */
74 #  ifdef WITH_BINRELOC
75 #    include "binreloc.h"
76 #  endif
77 #endif /* WIN32 */
78
79 /* local */
80 #define UNIQUE_NAME_MAX 128
81
82 static char bprogname[FILE_MAX];    /* path to program executable */
83 static char bprogdir[FILE_MAX];     /* path in which executable is located */
84 static char btempdir[FILE_MAX];     /* temporary directory */
85
86 static int add_win32_extension(char *name);
87 static char *blender_version_decimal(const int ver);
88
89 /* implementation */
90
91 /**
92  * Looks for a sequence of decimal digits in string, preceding any filename extension,
93  * returning the integer value if found, or 0 if not.
94  *
95  * \param string  String to scan.
96  * \param head  Optional area to return copy of part of string prior to digits, or before dot if no digits.
97  * \param tail  Optional area to return copy of part of string following digits, or from dot if no digits.
98  * \param numlen  Optional to return number of digits found.
99  */
100 int BLI_stringdec(const char *string, char *head, char *tail, unsigned short *numlen)
101 {
102         unsigned short nums = 0, nume = 0;
103         short i;
104         bool found_digit = false;
105         const char * const lslash = BLI_last_slash(string);
106         const unsigned short string_len = strlen(string);
107         const unsigned short lslash_len = lslash != NULL ? (int)(lslash - string) : 0;
108         unsigned short name_end = string_len;
109
110         while (name_end > lslash_len && string[--name_end] != '.') {} /* name ends at dot if present */
111         if (name_end == lslash_len && string[name_end] != '.') name_end = string_len;
112
113         for (i = name_end - 1; i >= lslash_len; i--) {
114                 if (isdigit(string[i])) {
115                         if (found_digit) {
116                                 nums = i;
117                         }
118                         else {
119                                 nume = i;
120                                 nums = i;
121                                 found_digit = true;
122                         }
123                 }
124                 else {
125                         if (found_digit) break;
126                 }
127         }
128         if (found_digit) {
129                 if (tail) strcpy(tail, &string[nume + 1]);
130                 if (head) {
131                         strcpy(head, string);
132                         head[nums] = 0;
133                 }
134                 if (numlen) *numlen = nume - nums + 1;
135                 return ((int)atoi(&(string[nums])));
136         }
137         if (tail) strcpy(tail, string + name_end);
138         if (head) {
139                 strncpy(head, string, name_end);
140                 head[name_end] = '\0';
141         }
142         if (numlen) *numlen = 0;
143         return 0;
144 }
145
146
147 /**
148  * Returns in area pointed to by string a string of the form "<head><pic><tail>", where pic
149  * is formatted as numlen digits with leading zeroes.
150  */
151 void BLI_stringenc(char *string, const char *head, const char *tail, unsigned short numlen, int pic)
152 {
153         char fmtstr[16] = "";
154         if (pic < 0) pic = 0;
155         sprintf(fmtstr, "%%s%%.%dd%%s", numlen);
156         sprintf(string, fmtstr, head, pic, tail);
157 }
158
159 /**
160  * Looks for a numeric suffix preceded by delim character on the end of
161  * name, puts preceding part into *left and value of suffix into *nr.
162  * Returns the length of *left.
163  *
164  * Foo.001 -> "Foo", 1
165  * Returns the length of "Foo"
166  *
167  * \param left  Where to return copy of part preceding delim
168  * \param nr  Where to return value of numeric suffix
169  * \param name  String to split
170  * \param delim  Delimiter character
171  */
172 int BLI_split_name_num(char *left, int *nr, const char *name, const char delim)
173 {
174         int a;
175
176         *nr = 0;
177         a = strlen(name);
178         memcpy(left, name, (a + 1) * sizeof(char));
179
180         if (a > 1 && name[a - 1] == delim) return a;
181         
182         while (a--) {
183                 if (name[a] == delim) {
184                         left[a] = 0;
185                         *nr = atol(name + a + 1);
186                         /* casting down to an int, can overflow for large numbers */
187                         if (*nr < 0)
188                                 *nr = 0;
189                         return a;
190                 }
191                 /* non-numeric suffix--give up */
192                 if (isdigit(name[a]) == 0) break;
193                 
194                 left[a] = 0;
195         }
196
197         for (a = 0; name[a]; a++)
198                 left[a] = name[a];
199
200         return a;
201 }
202
203 /**
204  * Looks for a string of digits within name (using BLI_stringdec) and adjusts it by add.
205  */
206 void BLI_newname(char *name, int add)
207 {
208         char head[UNIQUE_NAME_MAX], tail[UNIQUE_NAME_MAX];
209         int pic;
210         unsigned short digits;
211         
212         pic = BLI_stringdec(name, head, tail, &digits);
213         
214         /* are we going from 100 -> 99 or from 10 -> 9 */
215         if (add < 0 && digits < 4 && digits > 0) {
216                 int i, exp;
217                 exp = 1;
218                 for (i = digits; i > 1; i--) exp *= 10;
219                 if (pic >= exp && (pic + add) < exp) digits--;
220         }
221         
222         pic += add;
223         
224         if (digits == 4 && pic < 0) pic = 0;
225         BLI_stringenc(name, head, tail, digits, pic);
226 }
227
228 /**
229  * Ensures name is unique (according to criteria specified by caller in unique_check callback),
230  * incrementing its numeric suffix as necessary. Returns true if name had to be adjusted.
231  *
232  * \param unique_check  Return true iff name is not unique
233  * \param arg  Additional arg to unique_check--meaning is up to caller
234  * \param defname  To initialize name if latter is empty
235  * \param delim  Delimits numeric suffix in name
236  * \param name  Name to be ensured unique
237  * \param name_len  Maximum length of name area
238  * \return true if there if the name was changed
239  */
240 bool BLI_uniquename_cb(bool (*unique_check)(void * arg, const char *name),
241                        void *arg, const char *defname, char delim, char *name, short name_len)
242 {
243         if (name[0] == '\0') {
244                 BLI_strncpy(name, defname, name_len);
245         }
246
247         if (unique_check(arg, name)) {
248                 char numstr[16];
249                 char tempname[UNIQUE_NAME_MAX];
250                 char left[UNIQUE_NAME_MAX];
251                 int number;
252                 int len = BLI_split_name_num(left, &number, name, delim);
253                 do {
254                         const int numlen = BLI_snprintf(numstr, sizeof(numstr), "%c%03d", delim, ++number);
255
256                         /* highly unlikely the string only has enough room for the number
257                          * but support anyway */
258                         if ((len == 0) || (numlen >= name_len)) {
259                                 /* number is know not to be utf-8 */
260                                 BLI_strncpy(tempname, numstr, name_len);
261                         }
262                         else {
263                                 char *tempname_buf;
264                                 tempname[0] = '\0';
265                                 tempname_buf = BLI_strncat_utf8(tempname, left, name_len - numlen);
266                                 memcpy(tempname_buf, numstr, numlen + 1);
267                         }
268                 } while (unique_check(arg, tempname));
269
270                 BLI_strncpy(name, tempname, name_len);
271                 
272                 return true;
273         }
274         
275         return false;
276 }
277
278 /* little helper macro for BLI_uniquename */
279 #ifndef GIVE_STRADDR
280         #define GIVE_STRADDR(data, offset) ( ((char *)data) + offset)
281 #endif
282
283 /* Generic function to set a unique name. It is only designed to be used in situations
284  * where the name is part of the struct, and also that the name is at most UNIQUE_NAME_MAX chars long.
285  * 
286  * For places where this is used, see constraint.c for example...
287  *
288  *  name_offs: should be calculated using offsetof(structname, membername) macro from stddef.h
289  *  len: maximum length of string (to prevent overflows, etc.)
290  *  defname: the name that should be used by default if none is specified already
291  *  delim: the character which acts as a delimiter between parts of the name
292  */
293 static bool uniquename_find_dupe(ListBase *list, void *vlink, const char *name, short name_offs)
294 {
295         Link *link;
296
297         for (link = list->first; link; link = link->next) {
298                 if (link != vlink) {
299                         if (!strcmp(GIVE_STRADDR(link, name_offs), name)) {
300                                 return true;
301                         }
302                 }
303         }
304
305         return false;
306 }
307
308 static bool uniquename_unique_check(void *arg, const char *name)
309 {
310         struct {ListBase *lb; void *vlink; short name_offs; } *data = arg;
311         return uniquename_find_dupe(data->lb, data->vlink, name, data->name_offs);
312 }
313
314 /**
315  * Ensures that the specified block has a unique name within the containing list,
316  * incrementing its numeric suffix as necessary.
317  *
318  * \param list  List containing the block
319  * \param vlink  The block to check the name for
320  * \param defname  To initialize block name if latter is empty
321  * \param delim  Delimits numeric suffix in name
322  * \param name_offs  Offset of name within block structure
323  * \param name_len  Maximum length of name area
324  */
325 void BLI_uniquename(ListBase *list, void *vlink, const char *defname, char delim, short name_offs, short name_len)
326 {
327         struct {ListBase *lb; void *vlink; short name_offs; } data;
328         data.lb = list;
329         data.vlink = vlink;
330         data.name_offs = name_offs;
331
332         assert((name_len > 1) && (name_len <= UNIQUE_NAME_MAX));
333
334         /* See if we are given an empty string */
335         if (ELEM(NULL, vlink, defname))
336                 return;
337
338         BLI_uniquename_cb(uniquename_unique_check, &data, defname, delim, GIVE_STRADDR(vlink, name_offs), name_len);
339 }
340
341
342
343 /* ******************** string encoding ***************** */
344
345 /* This is quite an ugly function... its purpose is to
346  * take the dir name, make it absolute, and clean it up, replacing
347  * excess file entry stuff (like /tmp/../tmp/../)
348  * note that dir isn't protected for max string names... 
349  * 
350  * If relbase is NULL then its ignored
351  */
352
353 void BLI_cleanup_path(const char *relabase, char *dir)
354 {
355         ptrdiff_t a;
356         char *start, *eind;
357         if (relabase) {
358                 BLI_path_abs(dir, relabase);
359         }
360         else {
361                 if (dir[0] == '/' && dir[1] == '/') {
362                         if (dir[2] == '\0') {
363                                 return; /* path is "//" - cant clean it */
364                         }
365                         dir = dir + 2; /* skip the first // */
366                 }
367         }
368         
369         /* Note
370          *   memmove(start, eind, strlen(eind) + 1);
371          * is the same as
372          *   strcpy( start, eind ); 
373          * except strcpy should not be used because there is overlap,
374          * so use memmove's slightly more obscure syntax - Campbell
375          */
376         
377 #ifdef WIN32
378         
379         /* Note, this should really be moved to the file selector,
380          * since this function is used in many areas */
381         if (strcmp(dir, ".") == 0) {  /* happens for example in FILE_MAIN */
382                 get_default_root(dir);
383                 return;
384         }
385
386         while ( (start = strstr(dir, "\\..\\")) ) {
387                 eind = start + strlen("\\..\\") - 1;
388                 a = start - dir - 1;
389                 while (a > 0) {
390                         if (dir[a] == '\\') break;
391                         a--;
392                 }
393                 if (a < 0) {
394                         break;
395                 }
396                 else {
397                         memmove(dir + a, eind, strlen(eind) + 1);
398                 }
399         }
400
401         while ( (start = strstr(dir, "\\.\\")) ) {
402                 eind = start + strlen("\\.\\") - 1;
403                 memmove(start, eind, strlen(eind) + 1);
404         }
405
406         while ( (start = strstr(dir, "\\\\")) ) {
407                 eind = start + strlen("\\\\") - 1;
408                 memmove(start, eind, strlen(eind) + 1);
409         }
410 #else
411         if (dir[0] == '.') {  /* happens, for example in FILE_MAIN */
412                 dir[0] = '/';
413                 dir[1] = 0;
414                 return;
415         }
416
417         /* support for odd paths: eg /../home/me --> /home/me
418          * this is a valid path in blender but we cant handle this the usual way below
419          * simply strip this prefix then evaluate the path as usual. pythons os.path.normpath() does this */
420         while ((strncmp(dir, "/../", 4) == 0)) {
421                 memmove(dir, dir + 4, strlen(dir + 4) + 1);
422         }
423
424         while ( (start = strstr(dir, "/../")) ) {
425                 eind = start + (4 - 1) /* strlen("/../") - 1 */;
426                 a = start - dir - 1;
427                 while (a > 0) {
428                         if (dir[a] == '/') break;
429                         a--;
430                 }
431                 if (a < 0) {
432                         break;
433                 }
434                 else {
435                         memmove(dir + a, eind, strlen(eind) + 1);
436                 }
437         }
438
439         while ( (start = strstr(dir, "/./")) ) {
440                 eind = start + (3 - 1) /* strlen("/./") - 1 */;
441                 memmove(start, eind, strlen(eind) + 1);
442         }
443
444         while ( (start = strstr(dir, "//")) ) {
445                 eind = start + (2 - 1) /* strlen("//") - 1 */;
446                 memmove(start, eind, strlen(eind) + 1);
447         }
448 #endif
449 }
450
451 void BLI_cleanup_dir(const char *relabase, char *dir)
452 {
453         BLI_cleanup_path(relabase, dir);
454         BLI_add_slash(dir);
455
456 }
457
458 void BLI_cleanup_file(const char *relabase, char *dir)
459 {
460         BLI_cleanup_path(relabase, dir);
461         BLI_del_slash(dir);
462 }
463
464 /**
465  * Does path begin with the special "//" prefix that Blender uses to indicate
466  * a path relative to the .blend file.
467  */
468 bool BLI_path_is_rel(const char *path)
469 {
470         return path[0] == '/' && path[1] == '/';
471 }
472
473 void BLI_path_rel(char *file, const char *relfile)
474 {
475         const char *lslash;
476         char temp[FILE_MAX];
477         char res[FILE_MAX];
478         
479         /* if file is already relative, bail out */
480         if (BLI_path_is_rel(file)) {
481                 return;
482         }
483         
484         /* also bail out if relative path is not set */
485         if (relfile[0] == '\0') {
486                 return;
487         }
488
489 #ifdef WIN32
490         if (BLI_strnlen(relfile, 3) > 2 && relfile[1] != ':') {
491                 char *ptemp;
492                 /* fix missing volume name in relative base,
493                  * can happen with old recent-files.txt files */
494                 get_default_root(temp);
495                 ptemp = &temp[2];
496                 if (relfile[0] != '\\' && relfile[0] != '/') {
497                         ptemp++;
498                 }
499                 BLI_strncpy(ptemp, relfile, FILE_MAX - 3);
500         }
501         else {
502                 BLI_strncpy(temp, relfile, FILE_MAX);
503         }
504
505         if (BLI_strnlen(file, 3) > 2) {
506                 if (temp[1] == ':' && file[1] == ':' && temp[0] != file[0])
507                         return;
508         }
509 #else
510         BLI_strncpy(temp, relfile, FILE_MAX);
511 #endif
512
513         BLI_char_switch(temp, '\\', '/');
514         BLI_char_switch(file, '\\', '/');
515         
516         /* remove /./ which confuse the following slash counting... */
517         BLI_cleanup_path(NULL, file);
518         BLI_cleanup_path(NULL, temp);
519         
520         /* the last slash in the file indicates where the path part ends */
521         lslash = BLI_last_slash(temp);
522
523         if (lslash) {
524                 /* find the prefix of the filename that is equal for both filenames.
525                  * This is replaced by the two slashes at the beginning */
526                 char *p = temp;
527                 char *q = file;
528
529 #ifdef WIN32
530                 while (tolower(*p) == tolower(*q))
531 #else
532                 while (*p == *q)
533 #endif
534                 {
535                         p++;
536                         q++;
537
538                         /* don't search beyond the end of the string
539                          * in the rare case they match */
540                         if ((*p == '\0') || (*q == '\0')) {
541                                 break;
542                         }
543                 }
544
545                 /* we might have passed the slash when the beginning of a dir matches 
546                  * so we rewind. Only check on the actual filename
547                  */
548                 if (*q != '/') {
549                         while ( (q >= file) && (*q != '/') ) { --q; --p; }
550                 }
551                 else if (*p != '/') {
552                         while ( (p >= temp) && (*p != '/') ) { --p; --q; }
553                 }
554                 
555                 strcpy(res, "//");
556
557                 /* p now points to the slash that is at the beginning of the part
558                  * where the path is different from the relative path. 
559                  * We count the number of directories we need to go up in the
560                  * hierarchy to arrive at the common 'prefix' of the path
561                  */
562                 while (p && p < lslash) {
563                         if (*p == '/') 
564                                 strcat(res, "../");
565                         p++;
566                 }
567
568                 strcat(res, q + 1); /* don't copy the slash at the beginning */
569                 
570 #ifdef  WIN32
571                 BLI_char_switch(res + 2, '/', '\\');
572 #endif
573                 strcpy(file, res);
574         }
575 }
576
577 /**
578  * Cleans path and makes sure it ends with a slash, and returns true iff
579  * it has more than one other path separator in it.
580  */
581 bool BLI_has_parent(char *path)
582 {
583         int len;
584         int slashes = 0;
585         BLI_clean(path);
586         len = BLI_add_slash(path) - 1;
587
588         while (len >= 0) {
589                 if ((path[len] == '\\') || (path[len] == '/'))
590                         slashes++;
591                 len--;
592         }
593         return slashes > 1;
594 }
595
596 /**
597  * Replaces path with the path of its parent directory, returning true iff
598  * it was able to find a parent directory within the pathname.
599  */
600 bool BLI_parent_dir(char *path)
601 {
602         static char parent_dir[] = {'.', '.', SEP, '\0'}; /* "../" or "..\\" */
603         char tmp[FILE_MAX + 4];
604         BLI_strncpy(tmp, path, sizeof(tmp) - 4);
605         BLI_add_slash(tmp);
606         strcat(tmp, parent_dir);
607         BLI_cleanup_dir(NULL, tmp); /* does all the work of normalizing the path for us */
608
609         if (!BLI_testextensie(tmp, parent_dir)) {
610                 BLI_strncpy(path, tmp, sizeof(tmp));
611                 return true;
612         }
613         else {
614                 return false;
615         }
616 }
617
618 /**
619  * Looks for a sequence of "#" characters in the last slash-separated component of *path,
620  * returning the indexes of the first and one past the last character in the sequence in
621  * *char_start and *char_end respectively. Returns true iff such a sequence was found.
622  */
623 static bool stringframe_chars(const char *path, int *char_start, int *char_end)
624 {
625         int ch_sta, ch_end, i;
626         /* Insert current frame: file### -> file001 */
627         ch_sta = ch_end = 0;
628         for (i = 0; path[i] != '\0'; i++) {
629                 if (path[i] == '\\' || path[i] == '/') {
630                         ch_end = 0; /* this is a directory name, don't use any hashes we found */
631                 }
632                 else if (path[i] == '#') {
633                         ch_sta = i;
634                         ch_end = ch_sta + 1;
635                         while (path[ch_end] == '#') {
636                                 ch_end++;
637                         }
638                         i = ch_end - 1; /* keep searching */
639                         
640                         /* don't break, there may be a slash after this that invalidates the previous #'s */
641                 }
642         }
643
644         if (ch_end) {
645                 *char_start = ch_sta;
646                 *char_end = ch_end;
647                 return true;
648         }
649         else {
650                 *char_start = -1;
651                 *char_end = -1;
652                 return false;
653         }
654 }
655
656 /**
657  * Ensure *path contains at least one "#" character in its last slash-separated
658  * component, appending one digits long if not.
659  */
660 static void ensure_digits(char *path, int digits)
661 {
662         char *file = (char *)BLI_last_slash(path);
663
664         if (file == NULL)
665                 file = path;
666
667         if (strrchr(file, '#') == NULL) {
668                 int len = strlen(file);
669
670                 while (digits--) {
671                         file[len++] = '#';
672                 }
673                 file[len] = '\0';
674         }
675 }
676
677 int BLI_path_frame(char *path, int frame, int digits)
678 {
679         int ch_sta, ch_end;
680
681         if (digits)
682                 ensure_digits(path, digits);
683
684         if (stringframe_chars(path, &ch_sta, &ch_end)) { /* warning, ch_end is the last # +1 */
685                 char tmp[FILE_MAX];
686                 sprintf(tmp, "%.*s%.*d%s", ch_sta, path, ch_end - ch_sta, frame, path + ch_end);
687                 strcpy(path, tmp);
688                 return 1;
689         }
690         return 0;
691 }
692
693 int BLI_path_frame_range(char *path, int sta, int end, int digits)
694 {
695         int ch_sta, ch_end;
696
697         if (digits)
698                 ensure_digits(path, digits);
699
700         if (stringframe_chars(path, &ch_sta, &ch_end)) { /* warning, ch_end is the last # +1 */
701                 char tmp[FILE_MAX];
702                 BLI_snprintf(tmp, sizeof(tmp),
703                              "%.*s%.*d-%.*d%s",
704                              ch_sta, path, ch_end - ch_sta, sta, ch_end - ch_sta, end, path + ch_end);
705                 BLI_strncpy(path, tmp, FILE_MAX);
706                 return 1;
707         }
708         return 0;
709 }
710
711 /**
712  * If path begins with "//", strips that and replaces it with basepath directory. Also converts
713  * a drive-letter prefix to something more sensible if this is a non-drive-letter-based system.
714  * Returns true iff "//" prefix expansion was done.
715  */
716 bool BLI_path_abs(char *path, const char *basepath)
717 {
718         const bool wasrelative = BLI_path_is_rel(path);
719         char tmp[FILE_MAX];
720         char base[FILE_MAX];
721 #ifdef WIN32
722         char vol[3] = {'\0', '\0', '\0'};
723
724         BLI_strncpy(vol, path, 3);
725         /* we are checking here if we have an absolute path that is not in the current
726          * blend file as a lib main - we are basically checking for the case that a 
727          * UNIX root '/' is passed.
728          */
729         if (!wasrelative && (vol[1] != ':' && (vol[0] == '\0' || vol[0] == '/' || vol[0] == '\\'))) {
730                 char *p = path;
731                 get_default_root(tmp);
732                 // get rid of the slashes at the beginning of the path
733                 while (*p == '\\' || *p == '/') {
734                         p++;
735                 }
736                 strcat(tmp, p);
737         }
738         else {
739                 BLI_strncpy(tmp, path, FILE_MAX);
740         }
741 #else
742         BLI_strncpy(tmp, path, sizeof(tmp));
743         
744         /* Check for loading a windows path on a posix system
745          * in this case, there is no use in trying C:/ since it 
746          * will never exist on a unix os.
747          * 
748          * Add a / prefix and lowercase the driveletter, remove the :
749          * C:\foo.JPG -> /c/foo.JPG */
750         
751         if (isalpha(tmp[0]) && tmp[1] == ':' && (tmp[2] == '\\' || tmp[2] == '/') ) {
752                 tmp[1] = tolower(tmp[0]); /* replace ':' with driveletter */
753                 tmp[0] = '/'; 
754                 /* '\' the slash will be converted later */
755         }
756         
757 #endif
758
759         BLI_strncpy(base, basepath, sizeof(base));
760
761         /* file component is ignored, so don't bother with the trailing slash */
762         BLI_cleanup_path(NULL, base);
763         
764         /* push slashes into unix mode - strings entering this part are
765          * potentially messed up: having both back- and forward slashes.
766          * Here we push into one conform direction, and at the end we
767          * push them into the system specific dir. This ensures uniformity
768          * of paths and solving some problems (and prevent potential future
769          * ones) -jesterKing. */
770         BLI_char_switch(tmp, '\\', '/');
771         BLI_char_switch(base, '\\', '/');
772
773         /* Paths starting with // will get the blend file as their base,
774          * this isn't standard in any os but is used in blender all over the place */
775         if (wasrelative) {
776                 const char * const lslash = BLI_last_slash(base);
777                 if (lslash) {
778                         const int baselen = (int) (lslash - base) + 1;  /* length up to and including last "/" */
779                         /* use path for temp storage here, we copy back over it right away */
780                         BLI_strncpy(path, tmp + 2, FILE_MAX);  /* strip "//" */
781                         
782                         memcpy(tmp, base, baselen);  /* prefix with base up to last "/" */
783                         BLI_strncpy(tmp + baselen, path, sizeof(tmp) - baselen);  /* append path after "//" */
784                         BLI_strncpy(path, tmp, FILE_MAX);  /* return as result */
785                 }
786                 else {
787                         /* base doesn't seem to be a directory--ignore it and just strip "//" prefix on path */
788                         BLI_strncpy(path, tmp + 2, FILE_MAX);
789                 }
790         }
791         else {
792                 /* base ignored */
793                 BLI_strncpy(path, tmp, FILE_MAX);
794         }
795
796         BLI_cleanup_path(NULL, path);
797
798 #ifdef WIN32
799         /* skip first two chars, which in case of
800          * absolute path will be drive:/blabla and
801          * in case of relpath //blabla/. So relpath
802          * // will be retained, rest will be nice and
803          * shiny win32 backward slashes :) -jesterKing
804          */
805         BLI_char_switch(path + 2, '/', '\\');
806 #endif
807         
808         return wasrelative;
809 }
810
811
812 /*
813  * Should only be done with command line paths.
814  * this is NOT something blenders internal paths support like the // prefix
815  */
816 int BLI_path_cwd(char *path)
817 {
818         int wasrelative = 1;
819         int filelen = strlen(path);
820         
821 #ifdef WIN32
822         if (filelen >= 3 && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
823                 wasrelative = 0;
824 #else
825         if (filelen >= 2 && path[0] == '/')
826                 wasrelative = 0;
827 #endif
828         
829         if (wasrelative == 1) {
830                 char cwd[FILE_MAX] = "";
831                 BLI_current_working_dir(cwd, sizeof(cwd)); /* in case the full path to the blend isn't used */
832                 
833                 if (cwd[0] == '\0') {
834                         printf("Could not get the current working directory - $PWD for an unknown reason.\n");
835                 }
836                 else {
837                         /* uses the blend path relative to cwd important for loading relative linked files.
838                          *
839                          * cwd should contain c:\ etc on win32 so the relbase can be NULL
840                          * relbase being NULL also prevents // being misunderstood as relative to the current
841                          * blend file which isn't a feature we want to use in this case since were dealing
842                          * with a path from the command line, rather than from inside Blender */
843
844                         char origpath[FILE_MAX];
845                         BLI_strncpy(origpath, path, FILE_MAX);
846                         
847                         BLI_make_file_string(NULL, path, cwd, origpath); 
848                 }
849         }
850         
851         return wasrelative;
852 }
853
854
855 /* 'di's filename component is moved into 'fi', di is made a dir path */
856 void BLI_splitdirstring(char *di, char *fi)
857 {
858         char *lslash = (char *)BLI_last_slash(di);
859
860         if (lslash) {
861                 BLI_strncpy(fi, lslash + 1, FILE_MAXFILE);
862                 *(lslash + 1) = 0;
863         }
864         else {
865                 BLI_strncpy(fi, di, FILE_MAXFILE);
866                 di[0] = 0;
867         }
868 }
869
870 void BLI_getlastdir(const char *dir, char *last, const size_t maxlen)
871 {
872         const char *s = dir;
873         const char *lslash = NULL;
874         const char *prevslash = NULL;
875         while (*s) {
876                 if ((*s == '\\') || (*s == '/')) {
877                         prevslash = lslash;
878                         lslash = s;
879                 }
880                 s++;
881         }
882         if (prevslash) {
883                 BLI_strncpy(last, prevslash + 1, maxlen);
884         }
885         else {
886                 BLI_strncpy(last, dir, maxlen);
887         }
888 }
889
890 /* This is now only used to really get the user's default document folder */
891 /* On Windows I chose the 'Users/<MyUserName>/Documents' since it's used
892  * as default location to save documents */
893 const char *BLI_getDefaultDocumentFolder(void)
894 {
895 #ifndef WIN32
896         const char *xdg_documents_dir = getenv("XDG_DOCUMENTS_DIR");
897
898         if (xdg_documents_dir)
899                 return xdg_documents_dir;
900
901         return getenv("HOME");
902 #else /* Windows */
903         static char documentfolder[MAXPATHLEN];
904         HRESULT hResult;
905
906         /* Check for %HOME% env var */
907         if (uput_getenv("HOME", documentfolder, MAXPATHLEN)) {
908                 if (BLI_is_dir(documentfolder)) return documentfolder;
909         }
910                                 
911         /* add user profile support for WIN 2K / NT.
912          * This is %APPDATA%, which translates to either
913          * %USERPROFILE%\Application Data or since Vista
914          * to %USERPROFILE%\AppData\Roaming
915          */
916         hResult = SHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, documentfolder);
917                 
918         if (hResult == S_OK) {
919                 if (BLI_is_dir(documentfolder)) return documentfolder;
920         }
921                 
922         return NULL;
923 #endif /* WIN32 */
924 }
925
926 /* NEW stuff, to be cleaned up when fully migrated */
927 /* ************************************************************* */
928 /* ************************************************************* */
929
930 // #define PATH_DEBUG
931
932 static char *blender_version_decimal(const int ver)
933 {
934         static char version_str[5];
935         sprintf(version_str, "%d.%02d", ver / 100, ver % 100);
936         return version_str;
937 }
938
939 static int test_path(char *targetpath, const char *path_base, const char *path_sep, const char *folder_name)
940 {
941         char tmppath[FILE_MAX];
942         
943         if (path_sep) BLI_join_dirfile(tmppath, sizeof(tmppath), path_base, path_sep);
944         else BLI_strncpy(tmppath, path_base, sizeof(tmppath));
945
946         /* rare cases folder_name is omitted (when looking for ~/.blender/2.xx dir only) */
947         if (folder_name)
948                 BLI_make_file_string("/", targetpath, tmppath, folder_name);
949         else
950                 BLI_strncpy(targetpath, tmppath, sizeof(tmppath));
951
952         if (BLI_is_dir(targetpath)) {
953 #ifdef PATH_DEBUG
954                 printf("\t%s found: %s\n", __func__, targetpath);
955 #endif
956                 return 1;
957         }
958         else {
959 #ifdef PATH_DEBUG
960                 printf("\t%s missing: %s\n", __func__, targetpath);
961 #endif
962                 //targetpath[0] = '\0';
963                 return 0;
964         }
965 }
966
967 static int test_env_path(char *path, const char *envvar)
968 {
969         const char *env = envvar ? getenv(envvar) : NULL;
970         if (!env) return 0;
971         
972         if (BLI_is_dir(env)) {
973                 BLI_strncpy(path, env, FILE_MAX);
974 #ifdef PATH_DEBUG
975                 printf("\t%s env %s found: %s\n", __func__, envvar, env);
976 #endif
977                 return 1;
978         }
979         else {
980                 path[0] = '\0';
981 #ifdef PATH_DEBUG
982                 printf("\t%s env %s missing: %s\n", __func__, envvar, env);
983 #endif
984                 return 0;
985         }
986 }
987
988 static int get_path_local(char *targetpath, const char *folder_name, const char *subfolder_name, const int ver)
989 {
990         char relfolder[FILE_MAX];
991         
992 #ifdef PATH_DEBUG
993         printf("%s...\n", __func__);
994 #endif
995
996         if (folder_name) {
997                 if (subfolder_name) {
998                         BLI_join_dirfile(relfolder, sizeof(relfolder), folder_name, subfolder_name);
999                 }
1000                 else {
1001                         BLI_strncpy(relfolder, folder_name, sizeof(relfolder));
1002                 }
1003         }
1004         else {
1005                 relfolder[0] = '\0';
1006         }
1007
1008         /* try EXECUTABLE_DIR/2.5x/folder_name - new default directory for local blender installed files */
1009         if (test_path(targetpath, bprogdir, blender_version_decimal(ver), relfolder))
1010                 return 1;
1011
1012         return 0;
1013 }
1014
1015 static int is_portable_install(void)
1016 {
1017         /* detect portable install by the existance of config folder */
1018         const int ver = BLENDER_VERSION;
1019         char path[FILE_MAX];
1020
1021         return get_path_local(path, "config", NULL, ver);
1022 }
1023
1024 static int get_path_user(char *targetpath, const char *folder_name, const char *subfolder_name, const char *envvar, const int ver)
1025 {
1026         char user_path[FILE_MAX];
1027         const char *user_base_path;
1028
1029         /* for portable install, user path is always local */
1030         if (is_portable_install())
1031                 return get_path_local(targetpath, folder_name, subfolder_name, ver);
1032         
1033         user_path[0] = '\0';
1034
1035         if (test_env_path(user_path, envvar)) {
1036                 if (subfolder_name) {
1037                         return test_path(targetpath, user_path, NULL, subfolder_name);
1038                 }
1039                 else {
1040                         BLI_strncpy(targetpath, user_path, FILE_MAX);
1041                         return 1;
1042                 }
1043         }
1044
1045         user_base_path = (const char *)GHOST_getUserDir(ver, blender_version_decimal(ver));
1046         if (user_base_path)
1047                 BLI_strncpy(user_path, user_base_path, FILE_MAX);
1048
1049         if (!user_path[0])
1050                 return 0;
1051         
1052 #ifdef PATH_DEBUG
1053         printf("%s: %s\n", __func__, user_path);
1054 #endif
1055         
1056         if (subfolder_name) {
1057                 /* try $HOME/folder_name/subfolder_name */
1058                 return test_path(targetpath, user_path, folder_name, subfolder_name);
1059         }
1060         else {
1061                 /* try $HOME/folder_name */
1062                 return test_path(targetpath, user_path, NULL, folder_name);
1063         }
1064 }
1065
1066 static int get_path_system(char *targetpath, const char *folder_name, const char *subfolder_name, const char *envvar, const int ver)
1067 {
1068         char system_path[FILE_MAX];
1069         const char *system_base_path;
1070
1071
1072         /* first allow developer only overrides to the system path
1073          * these are only used when running blender from source */
1074         char cwd[FILE_MAX];
1075         char relfolder[FILE_MAX];
1076
1077         if (folder_name) {
1078                 if (subfolder_name) {
1079                         BLI_join_dirfile(relfolder, sizeof(relfolder), folder_name, subfolder_name);
1080                 }
1081                 else {
1082                         BLI_strncpy(relfolder, folder_name, sizeof(relfolder));
1083                 }
1084         }
1085         else {
1086                 relfolder[0] = '\0';
1087         }
1088
1089         /* try CWD/release/folder_name */
1090         if (BLI_current_working_dir(cwd, sizeof(cwd))) {
1091                 if (test_path(targetpath, cwd, "release", relfolder)) {
1092                         return 1;
1093                 }
1094         }
1095
1096         /* try EXECUTABLE_DIR/release/folder_name */
1097         if (test_path(targetpath, bprogdir, "release", relfolder))
1098                 return 1;
1099         /* end developer overrides */
1100
1101
1102
1103         system_path[0] = '\0';
1104
1105         if (test_env_path(system_path, envvar)) {
1106                 if (subfolder_name) {
1107                         return test_path(targetpath, system_path, NULL, subfolder_name);
1108                 }
1109                 else {
1110                         BLI_strncpy(targetpath, system_path, FILE_MAX);
1111                         return 1;
1112                 }
1113         }
1114
1115         system_base_path = (const char *)GHOST_getSystemDir(ver, blender_version_decimal(ver));
1116         if (system_base_path)
1117                 BLI_strncpy(system_path, system_base_path, FILE_MAX);
1118         
1119         if (!system_path[0])
1120                 return 0;
1121         
1122 #ifdef PATH_DEBUG
1123         printf("%s: %s\n", __func__, system_path);
1124 #endif
1125         
1126         if (subfolder_name) {
1127                 /* try $BLENDERPATH/folder_name/subfolder_name */
1128                 return test_path(targetpath, system_path, folder_name, subfolder_name);
1129         }
1130         else {
1131                 /* try $BLENDERPATH/folder_name */
1132                 return test_path(targetpath, system_path, NULL, folder_name);
1133         }
1134 }
1135
1136 /* get a folder out of the 'folder_id' presets for paths */
1137 /* returns the path if found, NULL string if not */
1138 char *BLI_get_folder(int folder_id, const char *subfolder)
1139 {
1140         const int ver = BLENDER_VERSION;
1141         static char path[FILE_MAX] = "";
1142         
1143         switch (folder_id) {
1144                 case BLENDER_DATAFILES:     /* general case */
1145                         if (get_path_user(path, "datafiles", subfolder, "BLENDER_USER_DATAFILES", ver)) break;
1146                         if (get_path_local(path, "datafiles", subfolder, ver)) break;
1147                         if (get_path_system(path, "datafiles", subfolder, "BLENDER_SYSTEM_DATAFILES", ver)) break;
1148                         return NULL;
1149                         
1150                 case BLENDER_USER_DATAFILES:
1151                         if (get_path_user(path, "datafiles", subfolder, "BLENDER_USER_DATAFILES", ver)) break;
1152                         return NULL;
1153                         
1154                 case BLENDER_SYSTEM_DATAFILES:
1155                         if (get_path_local(path, "datafiles", subfolder, ver)) break;
1156                         if (get_path_system(path, "datafiles", subfolder, "BLENDER_SYSTEM_DATAFILES", ver)) break;
1157                         return NULL;
1158                         
1159                 case BLENDER_USER_AUTOSAVE:
1160                         if (get_path_user(path, "autosave", subfolder, "BLENDER_USER_DATAFILES", ver)) break;
1161                         return NULL;
1162
1163                 case BLENDER_USER_CONFIG:
1164                         if (get_path_user(path, "config", subfolder, "BLENDER_USER_CONFIG", ver)) break;
1165                         return NULL;
1166                         
1167                 case BLENDER_USER_SCRIPTS:
1168                         if (get_path_user(path, "scripts", subfolder, "BLENDER_USER_SCRIPTS", ver)) break;
1169                         return NULL;
1170                         
1171                 case BLENDER_SYSTEM_SCRIPTS:
1172                         if (get_path_local(path, "scripts", subfolder, ver)) break;
1173                         if (get_path_system(path, "scripts", subfolder, "BLENDER_SYSTEM_SCRIPTS", ver)) break;
1174                         return NULL;
1175                         
1176                 case BLENDER_SYSTEM_PYTHON:
1177                         if (get_path_local(path, "python", subfolder, ver)) break;
1178                         if (get_path_system(path, "python", subfolder, "BLENDER_SYSTEM_PYTHON", ver)) break;
1179                         return NULL;
1180         }
1181         
1182         return path;
1183 }
1184
1185 char *BLI_get_user_folder_notest(int folder_id, const char *subfolder)
1186 {
1187         const int ver = BLENDER_VERSION;
1188         static char path[FILE_MAX] = "";
1189
1190         switch (folder_id) {
1191                 case BLENDER_USER_DATAFILES:
1192                         get_path_user(path, "datafiles", subfolder, "BLENDER_USER_DATAFILES", ver);
1193                         break;
1194                 case BLENDER_USER_CONFIG:
1195                         get_path_user(path, "config", subfolder, "BLENDER_USER_CONFIG", ver);
1196                         break;
1197                 case BLENDER_USER_AUTOSAVE:
1198                         get_path_user(path, "autosave", subfolder, "BLENDER_USER_AUTOSAVE", ver);
1199                         break;
1200                 case BLENDER_USER_SCRIPTS:
1201                         get_path_user(path, "scripts", subfolder, "BLENDER_USER_SCRIPTS", ver);
1202                         break;
1203         }
1204         if ('\0' == path[0]) {
1205                 return NULL;
1206         }
1207         return path;
1208 }
1209
1210 char *BLI_get_folder_create(int folder_id, const char *subfolder)
1211 {
1212         char *path;
1213
1214         /* only for user folders */
1215         if (!ELEM4(folder_id, BLENDER_USER_DATAFILES, BLENDER_USER_CONFIG, BLENDER_USER_SCRIPTS, BLENDER_USER_AUTOSAVE))
1216                 return NULL;
1217         
1218         path = BLI_get_folder(folder_id, subfolder);
1219         
1220         if (!path) {
1221                 path = BLI_get_user_folder_notest(folder_id, subfolder);
1222                 if (path) BLI_dir_create_recursive(path);
1223         }
1224         
1225         return path;
1226 }
1227
1228 char *BLI_get_folder_version(const int id, const int ver, const bool do_check)
1229 {
1230         static char path[FILE_MAX] = "";
1231         int ok;
1232         switch (id) {
1233                 case BLENDER_RESOURCE_PATH_USER:
1234                         ok = get_path_user(path, NULL, NULL, NULL, ver);
1235                         break;
1236                 case BLENDER_RESOURCE_PATH_LOCAL:
1237                         ok = get_path_local(path, NULL, NULL, ver);
1238                         break;
1239                 case BLENDER_RESOURCE_PATH_SYSTEM:
1240                         ok = get_path_system(path, NULL, NULL, NULL, ver);
1241                         break;
1242                 default:
1243                         path[0] = '\0'; /* in case do_check is false */
1244                         ok = FALSE;
1245                         BLI_assert(!"incorrect ID");
1246         }
1247
1248         if ((ok == FALSE) && do_check) {
1249                 return NULL;
1250         }
1251
1252         return path;
1253 }
1254
1255 /* End new stuff */
1256 /* ************************************************************* */
1257 /* ************************************************************* */
1258
1259
1260
1261 #ifdef PATH_DEBUG
1262 #  undef PATH_DEBUG
1263 #endif
1264
1265 void BLI_setenv(const char *env, const char *val)
1266 {
1267         /* free windows */
1268 #if (defined(WIN32) || defined(WIN64)) && defined(FREE_WINDOWS)
1269         char *envstr = MEM_mallocN(sizeof(char) * (strlen(env) + strlen(val) + 2), "envstr"); /* one for = another for \0 */
1270
1271         sprintf(envstr, "%s=%s", env, val);
1272         putenv(envstr);
1273         MEM_freeN(envstr);
1274
1275         /* non-free windows */
1276 #elif (defined(WIN32) || defined(WIN64)) /* not free windows */
1277         uputenv(env, val);
1278
1279
1280 #else
1281         /* linux/osx/bsd */
1282         setenv(env, val, 1);
1283 #endif
1284 }
1285
1286
1287 /**
1288  * Only set an env var if already not there.
1289  * Like Unix setenv(env, val, 0);
1290  */
1291 void BLI_setenv_if_new(const char *env, const char *val)
1292 {
1293         if (getenv(env) == NULL)
1294                 BLI_setenv(env, val);
1295 }
1296
1297
1298 void BLI_clean(char *path)
1299 {
1300 #ifdef WIN32
1301         if (path && BLI_strnlen(path, 3) > 2) {
1302                 BLI_char_switch(path + 2, '/', '\\');
1303         }
1304 #else
1305         BLI_char_switch(path, '\\', '/');
1306 #endif
1307 }
1308
1309 void BLI_char_switch(char *string, char from, char to) 
1310 {
1311         while (*string != 0) {
1312                 if (*string == from) *string = to;
1313                 string++;
1314         }
1315 }
1316
1317 void BLI_make_exist(char *dir)
1318 {
1319         int a;
1320
1321         BLI_char_switch(dir, ALTSEP, SEP);
1322
1323         a = strlen(dir);
1324
1325         while (BLI_is_dir(dir) == 0) {
1326                 a--;
1327                 while (dir[a] != SEP) {
1328                         a--;
1329                         if (a <= 0) break;
1330                 }
1331                 if (a >= 0) {
1332                         dir[a + 1] = '\0';
1333                 }
1334                 else {
1335 #ifdef WIN32
1336                         get_default_root(dir);
1337 #else
1338                         strcpy(dir, "/");
1339 #endif
1340                         break;
1341                 }
1342         }
1343 }
1344
1345 void BLI_make_existing_file(const char *name)
1346 {
1347         char di[FILE_MAX], fi[FILE_MAXFILE];
1348
1349         BLI_strncpy(di, name, sizeof(di));
1350         BLI_splitdirstring(di, fi);
1351         
1352         /* test exist */
1353         if (BLI_exists(di) == 0) {
1354                 BLI_dir_create_recursive(di);
1355         }
1356 }
1357
1358
1359 void BLI_make_file_string(const char *relabase, char *string,  const char *dir, const char *file)
1360 {
1361         int sl;
1362
1363         if (string) {
1364                 /* ensure this is always set even if dir/file are NULL */
1365                 string[0] = '\0';
1366
1367                 if (ELEM(NULL, dir, file)) {
1368                         return; /* We don't want any NULLs */
1369                 }
1370         }
1371         else {
1372                 return; /* string is NULL, probably shouldnt happen but return anyway */
1373         }
1374
1375
1376         /* we first push all slashes into unix mode, just to make sure we don't get
1377          * any mess with slashes later on. -jesterKing */
1378         /* constant strings can be passed for those parameters - don't change them - elubie */
1379 #if 0
1380         BLI_char_switch(relabase, '\\', '/');
1381         BLI_char_switch(dir, '\\', '/');
1382         BLI_char_switch(file, '\\', '/');
1383 #endif
1384
1385         /* Resolve relative references */
1386         if (relabase && dir[0] == '/' && dir[1] == '/') {
1387                 char *lslash;
1388                 
1389                 /* Get the file name, chop everything past the last slash (ie. the filename) */
1390                 strcpy(string, relabase);
1391                 
1392                 lslash = (char *)BLI_last_slash(string);
1393                 if (lslash) *(lslash + 1) = 0;
1394
1395                 dir += 2; /* Skip over the relative reference */
1396         }
1397 #ifdef WIN32
1398         else {
1399                 if (BLI_strnlen(dir, 3) >= 2 && dir[1] == ':') {
1400                         BLI_strncpy(string, dir, 3);
1401                         dir += 2;
1402                 }
1403                 else { /* no drive specified */
1404                            /* first option: get the drive from the relabase if it has one */
1405                         if (relabase && strlen(relabase) >= 2 && relabase[1] == ':') {
1406                                 BLI_strncpy(string, relabase, 3);
1407                                 string[2] = '\\';
1408                                 string[3] = '\0';
1409                         }
1410                         else { /* we're out of luck here, guessing the first valid drive, usually c:\ */
1411                                 get_default_root(string);
1412                         }
1413                         
1414                         /* ignore leading slashes */
1415                         while (*dir == '/' || *dir == '\\') dir++;
1416                 }
1417         }
1418 #endif
1419
1420         strcat(string, dir);
1421
1422         /* Make sure string ends in one (and only one) slash */
1423         /* first trim all slashes from the end of the string */
1424         sl = strlen(string);
1425         while (sl > 0 && (string[sl - 1] == '/' || string[sl - 1] == '\\') ) {
1426                 string[sl - 1] = '\0';
1427                 sl--;
1428         }
1429         /* since we've now removed all slashes, put back one slash at the end. */
1430         strcat(string, "/");
1431         
1432         while (*file && (*file == '/' || *file == '\\')) /* Trim slashes from the front of file */
1433                 file++;
1434                 
1435         strcat(string, file);
1436         
1437         /* Push all slashes to the system preferred direction */
1438         BLI_clean(string);
1439 }
1440
1441 /* does str end with ext. */
1442 bool BLI_testextensie(const char *str, const char *ext)
1443 {
1444         const size_t a = strlen(str);
1445         const size_t b = strlen(ext);
1446         return !(a == 0 || b == 0 || b >= a) && (BLI_strcasecmp(ext, str + a - b) == 0);
1447 }
1448
1449 /* does str end with any of the suffixes in *ext_array. */
1450 bool BLI_testextensie_array(const char *str, const char **ext_array)
1451 {
1452         int i = 0;
1453         while (ext_array[i]) {
1454                 if (BLI_testextensie(str, ext_array[i])) {
1455                         return true;
1456                 }
1457
1458                 i++;
1459         }
1460         return false;
1461 }
1462
1463 /* semicolon separated wildcards, eg:
1464  *  '*.zip;*.py;*.exe' */
1465 bool BLI_testextensie_glob(const char *str, const char *ext_fnmatch)
1466 {
1467         const char *ext_step = ext_fnmatch;
1468         char pattern[16];
1469
1470         while (ext_step[0]) {
1471                 char *ext_next;
1472                 int len_ext;
1473
1474                 if ((ext_next = strchr(ext_step, ';'))) {
1475                         len_ext = (int)(ext_next - ext_step) + 1;
1476                 }
1477                 else {
1478                         len_ext = sizeof(pattern);
1479                 }
1480
1481                 BLI_strncpy(pattern, ext_step, len_ext);
1482
1483                 if (fnmatch(pattern, str, FNM_CASEFOLD) == 0) {
1484                         return true;
1485                 }
1486                 ext_step += len_ext;
1487         }
1488
1489         return false;
1490 }
1491
1492
1493 int BLI_replace_extension(char *path, size_t maxlen, const char *ext)
1494 {
1495         size_t path_len = strlen(path);
1496         size_t ext_len = strlen(ext);
1497         ssize_t a;
1498
1499         for (a = path_len - 1; a >= 0; a--) {
1500                 if (ELEM3(path[a], '.', '/', '\\')) {
1501                         break;
1502                 }
1503         }
1504
1505         if ((a < 0) || (path[a] != '.')) {
1506                 a = path_len;
1507         }
1508
1509         if (a + ext_len >= maxlen)
1510                 return 0;
1511
1512         memcpy(path + a, ext, ext_len + 1);
1513         return 1;
1514 }
1515
1516 /* strip's trailing '.'s and adds the extension only when needed */
1517 int BLI_ensure_extension(char *path, size_t maxlen, const char *ext)
1518 {
1519         size_t path_len = strlen(path);
1520         size_t ext_len = strlen(ext);
1521         ssize_t a;
1522
1523         /* first check the extension is alread there */
1524         if (    (ext_len <= path_len) &&
1525                 (strcmp(path + (path_len - ext_len), ext) == 0))
1526         {
1527                 return 1;
1528         }
1529
1530         for (a = path_len - 1; a >= 0; a--) {
1531                 if (path[a] == '.') {
1532                         path[a] = '\0';
1533                 }
1534                 else {
1535                         break;
1536                 }
1537         }
1538         a++;
1539
1540         if (a + ext_len >= maxlen)
1541                 return 0;
1542
1543         memcpy(path + a, ext, ext_len + 1);
1544         return 1;
1545 }
1546
1547 /* Converts "/foo/bar.txt" to "/foo/" and "bar.txt"
1548  * - wont change 'string'
1549  * - wont create any directories
1550  * - dosnt use CWD, or deal with relative paths.
1551  * - Only fill's in *dir and *file when they are non NULL
1552  * */
1553 void BLI_split_dirfile(const char *string, char *dir, char *file, const size_t dirlen, const size_t filelen)
1554 {
1555         const char *lslash_str = BLI_last_slash(string);
1556         size_t lslash = lslash_str ? (size_t)(lslash_str - string) + 1 : 0;
1557
1558         if (dir) {
1559                 if (lslash) {
1560                         BLI_strncpy(dir, string, MIN2(dirlen, lslash + 1)); /* +1 to include the slash and the last char */
1561                 }
1562                 else {
1563                         dir[0] = '\0';
1564                 }
1565         }
1566         
1567         if (file) {
1568                 BLI_strncpy(file, string + lslash, filelen);
1569         }
1570 }
1571
1572 void BLI_split_dir_part(const char *string, char *dir, const size_t dirlen)
1573 {
1574         BLI_split_dirfile(string, dir, NULL, dirlen, 0);
1575 }
1576
1577 void BLI_split_file_part(const char *string, char *file, const size_t filelen)
1578 {
1579         BLI_split_dirfile(string, NULL, file, 0, filelen);
1580 }
1581
1582 /* simple appending of filename to dir, does not check for valid path! */
1583 void BLI_join_dirfile(char *dst, const size_t maxlen, const char *dir, const char *file)
1584 {
1585         size_t dirlen = BLI_strnlen(dir, maxlen);
1586
1587         if (dst != dir) {
1588                 if (dirlen == maxlen) {
1589                         memcpy(dst, dir, dirlen);
1590                         dst[dirlen - 1] = '\0';
1591                         return; /* dir fills the path */
1592                 }
1593                 else {
1594                         memcpy(dst, dir, dirlen + 1);
1595                 }
1596         }
1597
1598         if (dirlen + 1 >= maxlen) {
1599                 return; /* fills the path */
1600         }
1601
1602         /* inline BLI_add_slash */
1603         if ((dirlen > 0) && (dst[dirlen - 1] != SEP)) {
1604                 dst[dirlen++] = SEP;
1605                 dst[dirlen] = '\0';
1606         }
1607
1608         if (dirlen >= maxlen) {
1609                 return; /* fills the path */
1610         }
1611
1612         if (file == NULL) {
1613                 return;
1614         }
1615
1616         BLI_strncpy(dst + dirlen, file, maxlen - dirlen);
1617 }
1618
1619 /* like pythons os.path.basename( ) */
1620 const char *BLI_path_basename(const char *path)
1621 {
1622         const char * const filename = BLI_last_slash(path);
1623         return filename ? filename + 1 : path;
1624 }
1625
1626 /**
1627  * Produce image export path.
1628  * 
1629  * Returns:
1630  * 0        if image filename is empty or if destination path
1631  *          matches image path (i.e. both are the same file).
1632  * 2        if source is identical to destination.
1633  * 1        if rebase was successful
1634  * -------------------------------------------------------------
1635  * Hint: Trailing slash in dest_dir is optional.
1636  *
1637  * Logic:
1638  *
1639  * - if an image is "below" current .blend file directory:
1640  *   rebuild the same dir structure in dest_dir
1641  *
1642  *   Example: 
1643  *   src : //textures/foo/bar.png
1644  *   dest: [dest_dir]/textures/foo/bar.png.
1645  *
1646  * - if an image is not "below" current .blend file directory,
1647  *   disregard it's path and copy it into the destination  
1648  *   directory.
1649  *
1650  *   Example:
1651  *   src : //../foo/bar.png becomes
1652  *   dest: [dest_dir]/bar.png.
1653  *
1654  * This logic ensures that all image paths are relative and
1655  * that a user gets his images in one place. It'll also provide
1656  * consistent behavior across exporters.
1657  * IMPORTANT NOTE: If base_dir contains an empty string, then
1658  * this function returns wrong results!
1659  * XXX: test on empty base_dir and return an error ?
1660  */
1661 int BLI_rebase_path(char *abs, size_t abs_len, char *rel, size_t rel_len, const char *base_dir, const char *src_dir, const char *dest_dir)
1662 {
1663         char path[FILE_MAX];
1664         char dir[FILE_MAX];
1665         char base[FILE_MAX];
1666         char blend_dir[FILE_MAX];   /* directory, where current .blend file resides */
1667         char dest_path[FILE_MAX];
1668         char rel_dir[FILE_MAX];
1669         int len;
1670
1671         if (abs)
1672                 abs[0] = 0;
1673
1674         if (rel)
1675                 rel[0] = 0;
1676
1677         BLI_split_dir_part(base_dir, blend_dir, sizeof(blend_dir));
1678
1679         if (src_dir[0] == '\0')
1680                 return BLI_REBASE_NO_SRCDIR;
1681
1682         BLI_strncpy(path, src_dir, sizeof(path));
1683
1684         /* expand "//" in filename and get absolute path */
1685         BLI_path_abs(path, base_dir);
1686
1687         /* get the directory part */
1688         BLI_split_dirfile(path, dir, base, sizeof(dir), sizeof(base));
1689
1690         len = strlen(blend_dir);
1691
1692         rel_dir[0] = 0;
1693
1694         /* if image is "below" current .blend file directory */
1695         if (!BLI_path_ncmp(path, blend_dir, len)) {
1696
1697                 /* if image is _in_ current .blend file directory */
1698                 if (BLI_path_cmp(dir, blend_dir) == 0) {
1699                         BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, base);
1700                 }
1701                 /* "below" */
1702                 else {
1703                         /* rel = image_path_dir - blend_dir */
1704                         BLI_strncpy(rel_dir, dir + len, sizeof(rel_dir));
1705
1706                         BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, rel_dir);
1707                         BLI_join_dirfile(dest_path, sizeof(dest_path), dest_path, base);
1708                 }
1709
1710         }
1711         /* image is out of current directory */
1712         else {
1713                 BLI_join_dirfile(dest_path, sizeof(dest_path), dest_dir, base);
1714         }
1715
1716         if (abs)
1717                 BLI_strncpy(abs, dest_path, abs_len);
1718
1719         if (rel) {
1720                 strncat(rel, rel_dir, rel_len);
1721                 strncat(rel, base, rel_len);
1722         }
1723
1724         /* return 2 if (src == dest) */
1725         if (BLI_path_cmp(path, dest_path) == 0) {
1726                 // if (G.debug & G_DEBUG) printf("%s and %s are the same file\n", path, dest_path);
1727                 return BLI_REBASE_IDENTITY;
1728         }
1729
1730         return BLI_REBASE_OK;
1731 }
1732
1733 /**
1734  * Returns pointer to the leftmost path separator in string. Not actually used anywhere.
1735  */
1736 const char *BLI_first_slash(const char *string)
1737 {
1738         char * const ffslash = strchr(string, '/');
1739         char * const fbslash = strchr(string, '\\');
1740         
1741         if (!ffslash) return fbslash;
1742         else if (!fbslash) return ffslash;
1743         
1744         if ((intptr_t)ffslash < (intptr_t)fbslash) return ffslash;
1745         else return fbslash;
1746 }
1747
1748 /**
1749  * Returns pointer to the rightmost path separator in string.
1750  */
1751 const char *BLI_last_slash(const char *string)
1752 {
1753         const char * const lfslash = strrchr(string, '/');
1754         const char * const lbslash = strrchr(string, '\\');
1755
1756         if (!lfslash) return lbslash; 
1757         else if (!lbslash) return lfslash;
1758         
1759         if ((intptr_t)lfslash < (intptr_t)lbslash) return lbslash;
1760         else return lfslash;
1761 }
1762
1763 /**
1764  * Appends a slash to string if there isn't one there already.
1765  * Returns the new length of the string.
1766  */
1767 int BLI_add_slash(char *string)
1768 {
1769         int len = strlen(string);
1770         if (len == 0 || string[len - 1] != SEP) {
1771                 string[len] = SEP;
1772                 string[len + 1] = '\0';
1773                 return len + 1;
1774         }
1775         return len;
1776 }
1777
1778 /**
1779  * Removes the last slash and everything after it to the end of string, if there is one.
1780  */
1781 void BLI_del_slash(char *string)
1782 {
1783         int len = strlen(string);
1784         while (len) {
1785                 if (string[len - 1] == SEP) {
1786                         string[len - 1] = '\0';
1787                         len--;
1788                 }
1789                 else {
1790                         break;
1791                 }
1792         }
1793 }
1794
1795 static int add_win32_extension(char *name)
1796 {
1797         int retval = 0;
1798         int type;
1799
1800         type = BLI_exists(name);
1801         if ((type == 0) || S_ISDIR(type)) {
1802 #ifdef _WIN32
1803                 char filename[FILE_MAX];
1804                 char ext[FILE_MAX];
1805                 const char *extensions = getenv("PATHEXT");
1806                 if (extensions) {
1807                         char *temp;
1808                         do {
1809                                 strcpy(filename, name);
1810                                 temp = strstr(extensions, ";");
1811                                 if (temp) {
1812                                         strncpy(ext, extensions, temp - extensions);
1813                                         ext[temp - extensions] = 0;
1814                                         extensions = temp + 1;
1815                                         strcat(filename, ext);
1816                                 }
1817                                 else {
1818                                         strcat(filename, extensions);
1819                                 }
1820
1821                                 type = BLI_exists(filename);
1822                                 if (type && (!S_ISDIR(type))) {
1823                                         retval = 1;
1824                                         strcpy(name, filename);
1825                                         break;
1826                                 }
1827                         } while (temp);
1828                 }
1829 #endif
1830         }
1831         else {
1832                 retval = 1;
1833         }
1834
1835         return (retval);
1836 }
1837
1838 /**
1839  * Checks if name is a fully qualified filename to an executable.
1840  * If not it searches $PATH for the file. On Windows it also
1841  * adds the correct extension (.com .exe etc) from
1842  * $PATHEXT if necessary. Also on Windows it translates
1843  * the name to its 8.3 version to prevent problems with
1844  * spaces and stuff. Final result is returned in fullname.
1845  *
1846  * \param fullname The full path and full name of the executable
1847  * (must be FILE_MAX minimum)
1848  * \param name The name of the executable (usually argv[0]) to be checked
1849  */
1850 static void bli_where_am_i(char *fullname, const size_t maxlen, const char *name)
1851 {
1852         char filename[FILE_MAX];
1853         const char *path = NULL, *temp;
1854
1855 #ifdef _WIN32
1856         const char *separator = ";";
1857 #else
1858         const char *separator = ":";
1859 #endif
1860
1861         
1862 #ifdef WITH_BINRELOC
1863         /* linux uses binreloc since argv[0] is not reliable, call br_init( NULL ) first */
1864         path = br_find_exe(NULL);
1865         if (path) {
1866                 BLI_strncpy(fullname, path, maxlen);
1867                 free((void *)path);
1868                 return;
1869         }
1870 #endif
1871
1872 #ifdef _WIN32
1873         wchar_t *fullname_16 = MEM_mallocN(maxlen * sizeof(wchar_t), "ProgramPath");
1874         if (GetModuleFileNameW(0, fullname_16, maxlen)) {
1875                 conv_utf_16_to_8(fullname_16, fullname, maxlen);
1876                 if (!BLI_exists(fullname)) {
1877                         printf("path can't be found: \"%.*s\"\n", maxlen, fullname);
1878                         MessageBox(NULL, "path contains invalid characters or is too long (see console)", "Error", MB_OK);
1879                 }
1880                 MEM_freeN(fullname_16);
1881                 return;
1882         }
1883
1884         MEM_freeN(fullname_16);
1885 #endif
1886
1887         /* unix and non linux */
1888         if (name && name[0]) {
1889
1890                 BLI_strncpy(fullname, name, maxlen);
1891                 if (name[0] == '.') {
1892                         char wdir[FILE_MAX] = "";
1893                         BLI_current_working_dir(wdir, sizeof(wdir));     /* backup cwd to restore after */
1894
1895                         // not needed but avoids annoying /./ in name
1896                         if (name[1] == SEP)
1897                                 BLI_join_dirfile(fullname, maxlen, wdir, name + 2);
1898                         else
1899                                 BLI_join_dirfile(fullname, maxlen, wdir, name);
1900
1901                         add_win32_extension(fullname); /* XXX, doesnt respect length */
1902                 }
1903                 else if (BLI_last_slash(name)) {
1904                         // full path
1905                         BLI_strncpy(fullname, name, maxlen);
1906                         add_win32_extension(fullname);
1907                 }
1908                 else {
1909                         // search for binary in $PATH
1910                         path = getenv("PATH");
1911                         if (path) {
1912                                 do {
1913                                         temp = strstr(path, separator);
1914                                         if (temp) {
1915                                                 strncpy(filename, path, temp - path);
1916                                                 filename[temp - path] = 0;
1917                                                 path = temp + 1;
1918                                         }
1919                                         else {
1920                                                 strncpy(filename, path, sizeof(filename));
1921                                         }
1922                                         BLI_join_dirfile(fullname, maxlen, fullname, name);
1923                                         if (add_win32_extension(filename)) {
1924                                                 BLI_strncpy(fullname, filename, maxlen);
1925                                                 break;
1926                                         }
1927                                 } while (temp);
1928                         }
1929                 }
1930 #if defined(DEBUG)
1931                 if (strcmp(name, fullname)) {
1932                         printf("guessing '%s' == '%s'\n", name, fullname);
1933                 }
1934 #endif
1935         }
1936 }
1937
1938 void BLI_init_program_path(const char *argv0)
1939 {
1940         bli_where_am_i(bprogname, sizeof(bprogname), argv0);
1941         BLI_split_dir_part(bprogname, bprogdir, sizeof(bprogdir));
1942 }
1943
1944 const char *BLI_program_path(void)
1945 {
1946         return bprogname;
1947 }
1948
1949 const char *BLI_program_dir(void)
1950 {
1951         return bprogdir;
1952 }
1953
1954 /**
1955  * Gets the temp directory when blender first runs.
1956  * If the default path is not found, use try $TEMP
1957  * 
1958  * Also make sure the temp dir has a trailing slash
1959  *
1960  * \param fullname The full path to the temp directory
1961  * \param maxlen The size of the fullname buffer
1962  * \param userdir Directory specified in user preferences 
1963  */
1964 static void BLI_where_is_temp(char *fullname, const size_t maxlen, char *userdir)
1965 {
1966         fullname[0] = '\0';
1967         
1968         if (userdir && BLI_is_dir(userdir)) {
1969                 BLI_strncpy(fullname, userdir, maxlen);
1970         }
1971         
1972         
1973 #ifdef WIN32
1974         if (fullname[0] == '\0') {
1975                 const char *tmp = getenv("TEMP"); /* Windows */
1976                 if (tmp && BLI_is_dir(tmp)) {
1977                         BLI_strncpy(fullname, tmp, maxlen);
1978                 }
1979         }
1980 #else
1981         /* Other OS's - Try TMP and TMPDIR */
1982         if (fullname[0] == '\0') {
1983                 const char *tmp = getenv("TMP");
1984                 if (tmp && BLI_is_dir(tmp)) {
1985                         BLI_strncpy(fullname, tmp, maxlen);
1986                 }
1987         }
1988         
1989         if (fullname[0] == '\0') {
1990                 const char *tmp = getenv("TMPDIR");
1991                 if (tmp && BLI_is_dir(tmp)) {
1992                         BLI_strncpy(fullname, tmp, maxlen);
1993                 }
1994         }
1995 #endif
1996         
1997         if (fullname[0] == '\0') {
1998                 BLI_strncpy(fullname, "/tmp/", maxlen);
1999         }
2000         else {
2001                 /* add a trailing slash if needed */
2002                 BLI_add_slash(fullname);
2003 #ifdef WIN32
2004                 if (userdir && userdir != fullname) {
2005                         BLI_strncpy(userdir, fullname, maxlen); /* also set user pref to show %TEMP%. /tmp/ is just plain confusing for Windows users. */
2006                 }
2007 #endif
2008         }
2009 }
2010
2011 void BLI_init_temporary_dir(char *userdir)
2012 {
2013         BLI_where_is_temp(btempdir, FILE_MAX, userdir);
2014 }
2015
2016 const char *BLI_temporary_dir(void)
2017 {
2018         return btempdir;
2019 }
2020
2021 void BLI_system_temporary_dir(char *dir)
2022 {
2023         BLI_where_is_temp(dir, FILE_MAX, NULL);
2024 }
2025
2026 #ifdef WITH_ICONV
2027
2028 void BLI_string_to_utf8(char *original, char *utf_8, const char *code)
2029 {
2030         size_t inbytesleft = strlen(original);
2031         size_t outbytesleft = 512;
2032         size_t rv = 0;
2033         iconv_t cd;
2034         
2035         if (NULL == code) {
2036                 code = locale_charset();
2037         }
2038         cd = iconv_open("UTF-8", code);
2039
2040         if (cd == (iconv_t)(-1)) {
2041                 printf("iconv_open Error");
2042                 *utf_8 = '\0';
2043                 return;
2044         }
2045         rv = iconv(cd, &original, &inbytesleft, &utf_8, &outbytesleft);
2046         if (rv == (size_t) -1) {
2047                 printf("iconv Error\n");
2048                 return;
2049         }
2050         *utf_8 = '\0';
2051         iconv_close(cd);
2052 }
2053 #endif // WITH_ICONV