* cleaning up warnings (mostly windows). A collection of other warning fixes too...
[blender.git] / source / blender / blenlib / intern / fileops.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include <string.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33
34 #include <sys/types.h>
35 #include <sys/stat.h>
36 #include <fcntl.h>
37
38 #include <errno.h>
39
40 #include "zlib.h"
41
42 #ifdef WIN32
43 #include <io.h>
44 #include "BLI_winstuff.h"
45 #else
46 #include <unistd.h> // for read close
47 #include <sys/param.h>
48 #endif
49
50
51 #include "BLI_blenlib.h"
52 #include "BLI_storage.h"
53 #include "BLI_fileops.h"
54 #include "BLI_callbacks.h"
55
56 #include "BKE_utildefines.h"
57
58 #include "BLO_sys_types.h" // for intptr_t support
59
60 /* implementations: */
61 char *first_slash(char *string) {
62         char *ffslash, *fbslash;
63         
64         ffslash= strchr(string, '/');   
65         fbslash= strchr(string, '\\');
66         
67         if (!ffslash) return fbslash;
68         else if (!fbslash) return ffslash;
69         
70         if ((intptr_t)ffslash < (intptr_t)fbslash) return ffslash;
71         else return fbslash;
72 }
73
74 char *BLI_last_slash(const char *string) {
75         char *lfslash, *lbslash;
76         
77         lfslash= strrchr(string, '/');  
78         lbslash= strrchr(string, '\\');
79
80         if (!lfslash) return lbslash; 
81         else if (!lbslash) return lfslash;
82         
83         if ((intptr_t)lfslash < (intptr_t)lbslash) return lbslash;
84         else return lfslash;
85 }
86
87 /* adds a slash if there isnt one there alredy */
88 int BLI_add_slash(char *string) {
89         int len = strlen(string);
90 #ifdef WIN32
91         if (len==0 || string[len-1]!='\\') {
92                 string[len] = '\\';
93                 string[len+1] = '\0';
94                 return len+1;
95         }
96 #else
97         if (len==0 || string[len-1]!='/') {
98                 string[len] = '/';
99                 string[len+1] = '\0';
100                 return len+1;
101         }
102 #endif
103         return len;
104 }
105
106 /* removes a slash if there is one */
107 void BLI_del_slash(char *string) {
108         int len = strlen(string);
109         while (len) {
110 #ifdef WIN32
111                 if (string[len-1]=='\\') {
112 #else
113                 if (string[len-1]=='/') {
114 #endif
115                         string[len-1] = '\0';
116                         len--;
117                 } else {
118                         break;
119                 }
120         }
121 }
122
123 /* gzip the file in from and write it to "to". 
124  return -1 if zlib fails, -2 if the originating file does not exist
125  note: will remove the "from" file
126   */
127 int BLI_gzip(char *from, char *to) {
128         char buffer[10240];
129         int file;
130         int readsize = 0;
131         
132         gzFile gzfile = gzopen(to,"wb"); 
133         if (NULL == gzfile) return -1;
134         
135         file = open(from,O_BINARY|O_RDONLY);
136         
137         if ( -1 == file )       return -2;
138
139         while ( 1 )
140         {
141                 readsize = read(file, buffer, 10240);
142                 
143                 if (readsize <= 0) break;
144                 
145                 gzwrite(gzfile,buffer,readsize);
146         }
147         
148         gzclose(gzfile);
149         close(file);
150         
151         remove(from);
152
153         return 0;
154 }
155
156 /* return 1 when file can be written */
157 int BLI_is_writable(char *filename)
158 {
159         int file;
160         
161         /* first try to open without creating */
162         file = open(filename, O_BINARY | O_RDWR, 0666);
163         
164         if (file < 0) {
165                 /* now try to open and create. a test without actually
166                  * creating a file would be nice, but how? */
167                 file = open(filename, O_BINARY | O_RDWR | O_CREAT, 0666);
168                 
169                 if(file < 0) {
170                         return 0;
171                 }
172                 else {
173                         /* success, delete the file we create */
174                         close(file);
175                         BLI_delete(filename, 0, 0);
176                         return 1;
177                 }
178         }
179         else {
180                 close(file);
181                 return 1;
182         }
183 }
184
185 int BLI_touch(const char *file)
186 {
187    FILE *f = fopen(file,"r+b");
188    if (f != NULL) {
189                 char c = getc(f);
190                 rewind(f);
191                 putc(c,f);
192         } else {
193            f = fopen(file,"wb");
194         }
195         if (f) {
196                 fclose(f);
197                 return 1;
198         }
199         return 0;
200 }
201
202 #ifdef WIN32
203
204 static char str[MAXPATHLEN+12];
205
206 int BLI_delete(char *file, int dir, int recursive) {
207         int err;
208
209         if (recursive) {
210                 callLocalErrorCallBack("Recursive delete is unsupported on Windows");
211                 err= 1;
212         } else if (dir) {
213                 err= !RemoveDirectory(file);
214                 if (err) printf ("Unable to remove directory");
215         } else {
216                 err= !DeleteFile(file);
217                 if (err) callLocalErrorCallBack("Unable to delete file");
218         }
219
220         return err;
221 }
222
223 int BLI_move(char *file, char *to) {
224         int err;
225
226         // windows doesn't support moveing to a directory
227         // it has to be 'mv filename filename' and not
228         // 'mv filename destdir'
229
230         strcpy(str, to);
231         // points 'to' to a directory ?
232         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
233                 if (BLI_last_slash(file) != NULL) {
234                         strcat(str, BLI_last_slash(file) + 1);
235                 }
236         }
237
238         err= !MoveFile(file, str);
239         if (err) {
240                 callLocalErrorCallBack("Unable to move file");
241                 printf(" Move from '%s' to '%s' failed\n", file, str);
242         }
243
244         return err;
245 }
246
247
248 int BLI_copy_fileops(char *file, char *to) {
249         int err;
250
251         // windows doesn't support copying to a directory
252         // it has to be 'cp filename filename' and not
253         // 'cp filename destdir'
254
255         strcpy(str, to);
256         // points 'to' to a directory ?
257         if (BLI_last_slash(str) == (str + strlen(str) - 1)) {
258                 if (BLI_last_slash(file) != NULL) {
259                         strcat(str, BLI_last_slash(file) + 1);
260                 }
261         }
262
263         err= !CopyFile(file,str,FALSE);
264         
265         if (err) {
266                 callLocalErrorCallBack("Unable to copy file!");
267                 printf(" Copy from '%s' to '%s' failed\n", file, str);
268         }
269
270         return err;
271 }
272
273 int BLI_link(char *file, char *to) {
274         callLocalErrorCallBack("Linking files is unsupported on Windows");
275         
276         return 1;
277 }
278
279 int BLI_exists(char *file) {
280         return (GetFileAttributes(file) != 0xFFFFFFFF);
281 }
282
283 void BLI_recurdir_fileops(char *dirname) {
284         char *lslash;
285         char tmp[MAXPATHLEN];
286         
287         // First remove possible slash at the end of the dirname.
288         // This routine otherwise tries to create
289         // blah1/blah2/ (with slash) after creating
290         // blah1/blah2 (without slash)
291
292         strcpy(tmp, dirname);
293         lslash= BLI_last_slash(tmp);
294
295         if (lslash == tmp + strlen(tmp) - 1) {
296                 *lslash = 0;
297         }
298         
299         if (BLI_exists(tmp)) return;
300                 
301         lslash= BLI_last_slash(tmp);
302         if (lslash) {
303                         /* Split about the last slash and recurse */    
304                 *lslash = 0;
305                 BLI_recurdir_fileops(tmp);
306         }
307         
308         if(dirname[0]) /* patch, this recursive loop tries to create a nameless directory */
309                 if (!CreateDirectory(dirname, NULL))
310                         callLocalErrorCallBack("Unable to create directory\n");
311 }
312
313 int BLI_rename(char *from, char *to) {
314         if (!BLI_exists(from)) return 0;
315
316         /* make sure the filenames are different (case insensitive) before removing */
317         if (BLI_exists(to) && BLI_strcasecmp(from, to))
318                 if(BLI_delete(to, 0, 0)) return 1;
319
320         return rename(from, to);
321 }
322
323 #else /* The sane UNIX world */
324
325 /*
326  * but the sane UNIX world is tied to the interface, and the system
327  * timer, and... We implement a callback mechanism. The system will
328  * have to initialise the callback before the functions will work!
329  * */
330 static char str[MAXPATHLEN+12];
331
332 int BLI_delete(char *file, int dir, int recursive) 
333 {
334         if(strchr(file, '"')) {
335                 printf("Error: not deleted file %s because of quote!\n", file);
336         }
337         else {
338                 if (recursive) {
339                         sprintf(str, "/bin/rm -rf \"%s\"", file);
340                         return system(str);
341                 }
342                 else if (dir) {
343                         sprintf(str, "/bin/rmdir \"%s\"", file);
344                         return system(str);
345                 }
346                 else {
347                         return remove(file); //sprintf(str, "/bin/rm -f \"%s\"", file);
348                 }
349         }
350         return -1;
351 }
352
353 int BLI_move(char *file, char *to) {
354         sprintf(str, "/bin/mv -f \"%s\" \"%s\"", file, to);
355
356         return system(str);
357 }
358
359 int BLI_copy_fileops(char *file, char *to) {
360         sprintf(str, "/bin/cp -rf \"%s\" \"%s\"", file, to);
361
362         return system(str);
363 }
364
365 int BLI_link(char *file, char *to) {
366         sprintf(str, "/bin/ln -f \"%s\" \"%s\"", file, to);
367         
368         return system(str);
369 }
370
371 int BLI_exists(char *file) {
372         return BLI_exist(file);
373 }
374
375 void BLI_recurdir_fileops(char *dirname) {
376         char *lslash;
377         char tmp[MAXPATHLEN];
378                 
379         if (BLI_exists(dirname)) return;
380
381         strcpy(tmp, dirname);
382                 
383         lslash= BLI_last_slash(tmp);
384         if (lslash) {
385                         /* Split about the last slash and recurse */    
386                 *lslash = 0;
387                 BLI_recurdir_fileops(tmp);
388         }
389
390         mkdir(dirname, 0777);
391 }
392
393 int BLI_rename(char *from, char *to) {
394         if (!BLI_exists(from)) return 0;
395         
396         if (BLI_exists(to))     if(BLI_delete(to, 0, 0)) return 1;
397
398         return rename(from, to);
399 }
400
401 #endif