]> git.saurik.com Git - wxWidgets.git/blob - src/common/file.cpp
Warning fixes found under hardest mode of OpenWatcom. Seems clean in Borland, MinGW...
[wxWidgets.git] / src / common / file.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: file.cpp
3 // Purpose: wxFile - encapsulates low-level "file descriptor"
4 // wxTempFile
5 // Author: Vadim Zeitlin
6 // Modified by:
7 // Created: 29/01/98
8 // RCS-ID: $Id$
9 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ----------------------------------------------------------------------------
14 // headers
15 // ----------------------------------------------------------------------------
16
17 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
18 #pragma implementation "file.h"
19 #endif
20
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
23
24 #ifdef __BORLANDC__
25 #pragma hdrstop
26 #endif
27
28 #if wxUSE_FILE
29
30 // standard
31 #if defined(__WXMSW__) && !defined(__GNUWIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
32
33 #ifndef __SALFORDC__
34 #define WIN32_LEAN_AND_MEAN
35 #define NOSERVICE
36 #define NOIME
37 #define NOATOM
38 #define NOGDI
39 #define NOGDICAPMASKS
40 #define NOMETAFILE
41 #define NOMINMAX
42 #define NOMSG
43 #define NOOPENFILE
44 #define NORASTEROPS
45 #define NOSCROLL
46 #define NOSOUND
47 #define NOSYSMETRICS
48 #define NOTEXTMETRIC
49 #define NOWH
50 #define NOCOMM
51 #define NOKANJI
52 #define NOCRYPT
53 #define NOMCX
54 #endif
55
56 #elif defined(__WXMSW__) && defined(__WXWINCE__)
57 #include "wx/msw/missing.h"
58 #elif (defined(__OS2__))
59 #include <io.h>
60 #elif (defined(__UNIX__) || defined(__GNUWIN32__))
61 #include <unistd.h>
62 #include <time.h>
63 #include <sys/stat.h>
64 #ifdef __GNUWIN32__
65 #include "wx/msw/wrapwin.h"
66 #endif
67 #elif defined(__DOS__)
68 #if defined(__WATCOMC__)
69 #include <io.h>
70 #elif defined(__DJGPP__)
71 #include <io.h>
72 #include <unistd.h>
73 #include <stdio.h>
74 #else
75 #error "Please specify the header with file functions declarations."
76 #endif
77 #elif (defined(__WXSTUBS__))
78 // Have to ifdef this for different environments
79 #include <io.h>
80 #elif (defined(__WXMAC__))
81 #if __MSL__ < 0x6000
82 int access( const char *path, int mode ) { return 0 ; }
83 #else
84 int _access( const char *path, int mode ) { return 0 ; }
85 #endif
86 char* mktemp( char * path ) { return path ;}
87 #include <stat.h>
88 #include <unistd.h>
89 #else
90 #error "Please specify the header with file functions declarations."
91 #endif //Win/UNIX
92
93 #include <stdio.h> // SEEK_xxx constants
94
95 // Windows compilers don't have these constants
96 #ifndef W_OK
97 enum
98 {
99 F_OK = 0, // test for existence
100 X_OK = 1, // execute permission
101 W_OK = 2, // write
102 R_OK = 4 // read
103 };
104 #endif // W_OK
105
106 // there is no distinction between text and binary files under Unix, so define
107 // O_BINARY as 0 if the system headers don't do it already
108 #if defined(__UNIX__) && !defined(O_BINARY)
109 #define O_BINARY (0)
110 #endif //__UNIX__
111
112 #ifdef __SALFORDC__
113 #include <unix.h>
114 #endif
115
116 #ifndef MAX_PATH
117 #define MAX_PATH 512
118 #endif
119
120 // some broken compilers don't have 3rd argument in open() and creat()
121 #ifdef __SALFORDC__
122 #define ACCESS(access)
123 #define stat _stat
124 #else // normal compiler
125 #define ACCESS(access) , (access)
126 #endif // Salford C
127
128 // wxWidgets
129 #ifndef WX_PRECOMP
130 #include "wx/string.h"
131 #include "wx/intl.h"
132 #include "wx/log.h"
133 #endif // !WX_PRECOMP
134
135 #include "wx/filename.h"
136 #include "wx/file.h"
137 #include "wx/filefn.h"
138
139 #ifdef __WXMSW__
140 #include "wx/msw/mslu.h"
141 #endif
142
143 #ifdef __WXWINCE__
144 #include "wx/msw/private.h"
145 #endif
146
147 // ============================================================================
148 // implementation of wxFile
149 // ============================================================================
150
151 // ----------------------------------------------------------------------------
152 // static functions
153 // ----------------------------------------------------------------------------
154
155 bool wxFile::Exists(const wxChar *name)
156 {
157 return wxFileExists(name);
158 }
159
160 bool wxFile::Access(const wxChar *name, OpenMode mode)
161 {
162 int how;
163
164 switch ( mode )
165 {
166 default:
167 wxFAIL_MSG(wxT("bad wxFile::Access mode parameter."));
168 // fall through
169
170 case read:
171 how = R_OK;
172 break;
173
174 case write:
175 how = W_OK;
176 break;
177
178 case read_write:
179 how = R_OK | W_OK;
180 break;
181 }
182
183 return wxAccess(name, how) == 0;
184 }
185
186 // ----------------------------------------------------------------------------
187 // opening/closing
188 // ----------------------------------------------------------------------------
189
190 // ctors
191 wxFile::wxFile(const wxChar *szFileName, OpenMode mode)
192 {
193 m_fd = fd_invalid;
194 m_error = false;
195
196 Open(szFileName, mode);
197 }
198
199 // create the file, fail if it already exists and bOverwrite
200 bool wxFile::Create(const wxChar *szFileName, bool bOverwrite, int accessMode)
201 {
202 // if bOverwrite we create a new file or truncate the existing one,
203 // otherwise we only create the new file and fail if it already exists
204 #if defined(__WXMAC__) && !defined(__UNIX__) && !wxUSE_UNICODE
205 // Dominic Mazzoni [dmazzoni+@cs.cmu.edu] reports that open is still broken on the mac, so we replace
206 // int fd = open( szFileName , O_CREAT | (bOverwrite ? O_TRUNC : O_EXCL), access);
207 int fd = creat( szFileName , accessMode);
208 #else
209 int fd = wxOpen( szFileName,
210 O_BINARY | O_WRONLY | O_CREAT |
211 (bOverwrite ? O_TRUNC : O_EXCL)
212 ACCESS(accessMode) );
213 #endif
214 if ( fd == -1 )
215 {
216 wxLogSysError(_("can't create file '%s'"), szFileName);
217 return false;
218 }
219 else
220 {
221 Attach(fd);
222 return true;
223 }
224 }
225
226 // open the file
227 bool wxFile::Open(const wxChar *szFileName, OpenMode mode, int accessMode)
228 {
229 int flags = O_BINARY;
230
231 switch ( mode )
232 {
233 case read:
234 flags |= O_RDONLY;
235 break;
236
237 case write_append:
238 if ( wxFile::Exists(szFileName) )
239 {
240 flags |= O_WRONLY | O_APPEND;
241 break;
242 }
243 //else: fall through as write_append is the same as write if the
244 // file doesn't exist
245
246 case write:
247 flags |= O_WRONLY | O_CREAT | O_TRUNC;
248 break;
249
250 case write_excl:
251 flags |= O_WRONLY | O_CREAT | O_EXCL;
252 break;
253
254 case read_write:
255 flags |= O_RDWR;
256 break;
257 }
258
259 #ifdef __WINDOWS__
260 // only read/write bits for "all" are supported by this function under
261 // Windows, and VC++ 8 returns EINVAL if any other bits are used in
262 // accessMode, so clear them as they have at best no effect anyhow
263 accessMode &= wxS_IRUSR | wxS_IWUSR;
264 #endif // __WINDOWS__
265
266 int fd = wxOpen( szFileName, flags ACCESS(accessMode));
267
268 if ( fd == -1 )
269 {
270 wxLogSysError(_("can't open file '%s'"), szFileName);
271 return false;
272 }
273 else {
274 Attach(fd);
275 return true;
276 }
277 }
278
279 // close
280 bool wxFile::Close()
281 {
282 if ( IsOpened() ) {
283 if (wxClose(m_fd) == -1)
284 {
285 wxLogSysError(_("can't close file descriptor %d"), m_fd);
286 m_fd = fd_invalid;
287 return false;
288 }
289 else
290 m_fd = fd_invalid;
291 }
292
293 return true;
294 }
295
296 // ----------------------------------------------------------------------------
297 // read/write
298 // ----------------------------------------------------------------------------
299
300 // read
301 size_t wxFile::Read(void *pBuf, size_t nCount)
302 {
303 wxCHECK( (pBuf != NULL) && IsOpened(), 0 );
304
305 int iRc = wxRead(m_fd, pBuf, nCount);
306
307 if ( iRc == -1 ) {
308 wxLogSysError(_("can't read from file descriptor %d"), m_fd);
309 return (size_t)wxInvalidOffset;
310 }
311 else
312 return (size_t)iRc;
313 }
314
315 // write
316 size_t wxFile::Write(const void *pBuf, size_t nCount)
317 {
318 wxCHECK( (pBuf != NULL) && IsOpened(), 0 );
319
320 int iRc = wxWrite(m_fd, pBuf, nCount);
321
322 if ( iRc == -1 ) {
323 wxLogSysError(_("can't write to file descriptor %d"), m_fd);
324 m_error = true;
325 return 0;
326 }
327 else
328 return iRc;
329 }
330
331 // flush
332 bool wxFile::Flush()
333 {
334 if ( IsOpened() ) {
335 #if defined(__VISUALC__) || wxHAVE_FSYNC
336 if ( wxFsync(m_fd) == -1 )
337 {
338 wxLogSysError(_("can't flush file descriptor %d"), m_fd);
339 return false;
340 }
341 #else // no fsync
342 // just do nothing
343 #endif // fsync
344 }
345
346 return true;
347 }
348
349 // ----------------------------------------------------------------------------
350 // seek
351 // ----------------------------------------------------------------------------
352
353 // seek
354 wxFileOffset wxFile::Seek(wxFileOffset ofs, wxSeekMode mode)
355 {
356 wxASSERT( IsOpened() );
357
358 int origin;
359 switch ( mode ) {
360 default:
361 wxFAIL_MSG(_("unknown seek origin"));
362
363 case wxFromStart:
364 origin = SEEK_SET;
365 break;
366
367 case wxFromCurrent:
368 origin = SEEK_CUR;
369 break;
370
371 case wxFromEnd:
372 origin = SEEK_END;
373 break;
374 }
375
376 if (ofs == wxInvalidOffset)
377 {
378 wxLogSysError(_("can't seek on file descriptor %d, large files support is not enabled."), m_fd);
379 return wxInvalidOffset;
380 }
381 wxFileOffset iRc = wxSeek(m_fd, ofs, origin);
382 if ( iRc == -1 ) {
383 wxLogSysError(_("can't seek on file descriptor %d"), m_fd);
384 return wxInvalidOffset;
385 }
386 else
387 return iRc;
388 }
389
390 // get current wxFileOffset
391 wxFileOffset wxFile::Tell() const
392 {
393 wxASSERT( IsOpened() );
394
395 wxFileOffset iRc = wxTell(m_fd);
396 if ( iRc == -1 ) {
397 wxLogSysError(_("can't get seek position on file descriptor %d"), m_fd);
398 return wxInvalidOffset;
399 }
400 else
401 return iRc;
402 }
403
404 // get current file length
405 wxFileOffset wxFile::Length() const
406 {
407 wxASSERT( IsOpened() );
408
409 wxFileOffset iRc = Tell();
410 if ( iRc != -1 ) {
411 // @ have to use const_cast :-(
412 wxFileOffset iLen = ((wxFile *)this)->SeekEnd();
413 if ( iLen != -1 ) {
414 // restore old position
415 if ( ((wxFile *)this)->Seek(iRc) == -1 ) {
416 // error
417 iLen = -1;
418 }
419 }
420
421 iRc = iLen;
422 }
423
424 if ( iRc == -1 ) {
425 wxLogSysError(_("can't find length of file on file descriptor %d"), m_fd);
426 return wxInvalidOffset;
427 }
428 else
429 return iRc;
430 }
431
432 // is end of file reached?
433 bool wxFile::Eof() const
434 {
435 wxASSERT( IsOpened() );
436
437 int iRc;
438
439 #if defined(__DOS__) || defined(__UNIX__) || defined(__GNUWIN32__) || defined( __MWERKS__ ) || defined(__SALFORDC__)
440 // @@ this doesn't work, of course, on unseekable file descriptors
441 wxFileOffset ofsCur = Tell(),
442 ofsMax = Length();
443 if ( ofsCur == wxInvalidOffset || ofsMax == wxInvalidOffset )
444 iRc = -1;
445 else
446 iRc = ofsCur == ofsMax;
447 #else // Windows and "native" compiler
448 iRc = wxEof(m_fd);
449 #endif // Windows/Unix
450
451 switch ( iRc ) {
452 case 1:
453 break;
454
455 case 0:
456 return false;
457
458 case -1:
459 wxLogSysError(_("can't determine if the end of file is reached on descriptor %d"), m_fd);
460 break;
461
462 default:
463 wxFAIL_MSG(_("invalid eof() return value."));
464 }
465
466 return true;
467 }
468
469 // ============================================================================
470 // implementation of wxTempFile
471 // ============================================================================
472
473 // ----------------------------------------------------------------------------
474 // construction
475 // ----------------------------------------------------------------------------
476
477 wxTempFile::wxTempFile(const wxString& strName)
478 {
479 Open(strName);
480 }
481
482 bool wxTempFile::Open(const wxString& strName)
483 {
484 // we must have an absolute filename because otherwise CreateTempFileName()
485 // would create the temp file in $TMP (i.e. the system standard location
486 // for the temp files) which might be on another volume/drive/mount and
487 // wxRename()ing it later to m_strName from Commit() would then fail
488 //
489 // with the absolute filename, the temp file is created in the same
490 // directory as this one which ensures that wxRename() may work later
491 wxFileName fn(strName);
492 if ( !fn.IsAbsolute() )
493 {
494 fn.Normalize(wxPATH_NORM_ABSOLUTE);
495 }
496
497 m_strName = fn.GetFullPath();
498
499 m_strTemp = wxFileName::CreateTempFileName(m_strName, &m_file);
500
501 if ( m_strTemp.empty() )
502 {
503 // CreateTempFileName() failed
504 return false;
505 }
506
507 #ifdef __UNIX__
508 // the temp file should have the same permissions as the original one
509 mode_t mode;
510
511 wxStructStat st;
512 if ( stat( (const char*) m_strName.fn_str(), &st) == 0 )
513 {
514 mode = st.st_mode;
515 }
516 else
517 {
518 // file probably didn't exist, just give it the default mode _using_
519 // user's umask (new files creation should respect umask)
520 mode_t mask = umask(0777);
521 mode = 0666 & ~mask;
522 umask(mask);
523 }
524
525 if ( chmod( (const char*) m_strTemp.fn_str(), mode) == -1 )
526 {
527 #ifndef __OS2__
528 wxLogSysError(_("Failed to set temporary file permissions"));
529 #endif
530 }
531 #endif // Unix
532
533 return true;
534 }
535
536 // ----------------------------------------------------------------------------
537 // destruction
538 // ----------------------------------------------------------------------------
539
540 wxTempFile::~wxTempFile()
541 {
542 if ( IsOpened() )
543 Discard();
544 }
545
546 bool wxTempFile::Commit()
547 {
548 m_file.Close();
549
550 if ( wxFile::Exists(m_strName) && wxRemove(m_strName) != 0 ) {
551 wxLogSysError(_("can't remove file '%s'"), m_strName.c_str());
552 return false;
553 }
554
555 if ( !wxRenameFile(m_strTemp, m_strName) ) {
556 wxLogSysError(_("can't commit changes to file '%s'"), m_strName.c_str());
557 return false;
558 }
559
560 return true;
561 }
562
563 void wxTempFile::Discard()
564 {
565 m_file.Close();
566 if ( wxRemove(m_strTemp) != 0 )
567 wxLogSysError(_("can't remove temporary file '%s'"), m_strTemp.c_str());
568 }
569
570 #endif // wxUSE_FILE
571