projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
add support for resources forks in wxCopyFile() (modified patch 1620336)
[wxWidgets.git] / src / common / filefn.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/filefn.cpp
3 // Purpose: File- and directory-related functions
4 // Author: Julian Smart
5 // Modified by:
6 // Created: 29/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) 1998 Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #include "wx/filefn.h"
28
29 #ifndef WX_PRECOMP
30 #include "wx/intl.h"
31 #include "wx/log.h"
32 #include "wx/utils.h"
33 #endif
34
35 #include "wx/file.h"
36 #include "wx/filename.h"
37 #include "wx/dir.h"
38
39 #include "wx/tokenzr.h"
40
41 // there are just too many of those...
42 #ifdef __VISUALC__
43 #pragma warning(disable:4706) // assignment within conditional expression
44 #endif // VC++
45
46 #include <ctype.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
51 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
52 #include <errno.h>
53 #endif
54 #endif
55
56 #if defined(__WXMAC__)
57 #include "wx/mac/private.h" // includes mac headers
58 #endif
59
60 #ifdef __WINDOWS__
61 #include "wx/msw/private.h"
62 #include "wx/msw/mslu.h"
63
64 // sys/cygwin.h is needed for cygwin_conv_to_full_win32_path()
65 //
66 // note that it must be included after <windows.h>
67 #ifdef __GNUWIN32__
68 #ifdef __CYGWIN__
69 #include <sys/cygwin.h>
70 #endif
71 #endif // __GNUWIN32__
72
73 // io.h is needed for _get_osfhandle()
74 // Already included by filefn.h for many Windows compilers
75 #if defined __MWERKS__ || defined __CYGWIN__
76 #include <io.h>
77 #endif
78 #endif // __WINDOWS__
79
80 #if defined(__VMS__)
81 #include <fab.h>
82 #endif
83
84 // TODO: Borland probably has _wgetcwd as well?
85 #ifdef _MSC_VER
86 #define HAVE_WGETCWD
87 #endif
88
89 // ----------------------------------------------------------------------------
90 // constants
91 // ----------------------------------------------------------------------------
92
93 #ifndef _MAXPATHLEN
94 #define _MAXPATHLEN 1024
95 #endif
96
97 #ifdef __WXMAC__
98 # include "MoreFilesX.h"
99 #endif
100
101 // ----------------------------------------------------------------------------
102 // private globals
103 // ----------------------------------------------------------------------------
104
105 // MT-FIXME: get rid of this horror and all code using it
106 static wxChar wxFileFunctionsBuffer[4*_MAXPATHLEN];
107
108 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
109 //
110 // VisualAge C++ V4.0 cannot have any external linkage const decs
111 // in headers included by more than one primary source
112 //
113 const int wxInvalidOffset = -1;
114 #endif
115
116 // ----------------------------------------------------------------------------
117 // macros
118 // ----------------------------------------------------------------------------
119
120 // translate the filenames before passing them to OS functions
121 #define OS_FILENAME(s) (s.fn_str())
122
123 // ============================================================================
124 // implementation
125 // ============================================================================
126
127 // ----------------------------------------------------------------------------
128 // wrappers around standard POSIX functions
129 // ----------------------------------------------------------------------------
130
131 #ifdef wxNEED_WX_UNISTD_H
132
133 WXDLLEXPORT int wxStat( const wxChar *file_name, wxStructStat *buf )
134 {
135 return stat( wxConvFile.cWX2MB( file_name ), buf );
136 }
137
138 WXDLLEXPORT int wxLstat( const wxChar *file_name, wxStructStat *buf )
139 {
140 return lstat( wxConvFile.cWX2MB( file_name ), buf );
141 }
142
143 WXDLLEXPORT int wxAccess( const wxChar *pathname, int mode )
144 {
145 return access( wxConvFile.cWX2MB( pathname ), mode );
146 }
147
148 WXDLLEXPORT int wxOpen( const wxChar *pathname, int flags, mode_t mode )
149 {
150 return open( wxConvFile.cWX2MB( pathname ), flags, mode );
151 }
152
153 #endif // wxNEED_WX_UNISTD_H
154
155 #if wxUSE_UNICODE && defined __BORLANDC__ \
156 && __BORLANDC__ >= 0x550 && __BORLANDC__ <= 0x551
157
158 // BCC 5.5 and 5.5.1 have a bug in _wopen where files are created read only
159 // regardless of the mode parameter. This hack works around the problem by
160 // setting the mode with _wchmod.
161 //
162 int wxOpen(const wchar_t *pathname, int flags, mode_t mode)
163 {
164 int moreflags = 0;
165
166 // we only want to fix the mode when the file is actually created, so
167 // when creating first try doing it O_EXCL so we can tell if the file
168 // was already there.
169 if ((flags & O_CREAT) && !(flags & O_EXCL) && (mode & wxS_IWUSR) != 0)
170 moreflags = O_EXCL;
171
172 int fd = _wopen(pathname, flags | moreflags, mode);
173
174 // the file was actually created and needs fixing
175 if (fd != -1 && (flags & O_CREAT) != 0 && (mode & wxS_IWUSR) != 0)
176 {
177 close(fd);
178 _wchmod(pathname, mode);
179 fd = _wopen(pathname, flags & ~(O_EXCL | O_CREAT));
180 }
181 // the open failed, but it may have been because the added O_EXCL stopped
182 // the opening of an existing file, so try again without.
183 else if (fd == -1 && moreflags != 0)
184 {
185 fd = _wopen(pathname, flags & ~O_CREAT);
186 }
187
188 return fd;
189 }
190
191 #endif
192
193 // ----------------------------------------------------------------------------
194 // wxPathList
195 // ----------------------------------------------------------------------------
196
197 bool wxPathList::Add(const wxString& path)
198 {
199 // add a path separator to force wxFileName to interpret it always as a directory
200 // (i.e. if we are called with '/home/user' we want to consider it a folder and
201 // not, as wxFileName would consider, a filename).
202 wxFileName fn(path + wxFileName::GetPathSeparator());
203
204 // add only normalized relative/absolute paths
205 // NB: we won't do wxPATH_NORM_DOTS in order to avoid problems when trying to
206 // normalize paths which starts with ".." (which can be normalized only if
207 // we use also wxPATH_NORM_ABSOLUTE - which we don't want to use).
208 if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
209 return false;
210
211 wxString toadd = fn.GetPath();
212 if (Index(toadd) == wxNOT_FOUND)
213 wxArrayString::Add(toadd); // do not add duplicates
214
215 return true;
216 }
217
218 void wxPathList::Add(const wxArrayString &arr)
219 {
220 for (size_t j=0; j < arr.GetCount(); j++)
221 Add(arr[j]);
222 }
223
224 // Add paths e.g. from the PATH environment variable
225 void wxPathList::AddEnvList (const wxString& WXUNUSED_IN_WINCE(envVariable))
226 {
227 // No environment variables on WinCE
228 #ifndef __WXWINCE__
229
230 // The space has been removed from the tokenizers, otherwise a
231 // path such as "C:\Program Files" would be split into 2 paths:
232 // "C:\Program" and "Files"; this is true for both Windows and Unix.
233
234 static const wxChar PATH_TOKS[] =
235 #if defined(__WINDOWS__) || defined(__OS2__)
236 wxT(";"); // Don't separate with colon in DOS (used for drive)
237 #else
238 wxT(":;");
239 #endif
240
241 wxString val;
242 if ( wxGetEnv(envVariable, &val) )
243 {
244 // split into an array of string the value of the env var
245 wxArrayString arr = wxStringTokenize(val, PATH_TOKS);
246 WX_APPEND_ARRAY(*this, arr);
247 }
248 #endif // !__WXWINCE__
249 }
250
251 // Given a full filename (with path), ensure that that file can
252 // be accessed again USING FILENAME ONLY by adding the path
253 // to the list if not already there.
254 bool wxPathList::EnsureFileAccessible (const wxString& path)
255 {
256 return Add(wxPathOnly(path));
257 }
258
259 #if WXWIN_COMPATIBILITY_2_6
260 bool wxPathList::Member (const wxString& path) const
261 {
262 return Index(path) != wxNOT_FOUND;
263 }
264 #endif
265
266 wxString wxPathList::FindValidPath (const wxString& file) const
267 {
268 // normalize the given string as it could be a path + a filename
269 // and not only a filename
270 wxFileName fn(file);
271 wxString strend;
272
273 // NB: normalize without making absolute otherwise calling this function with
274 // e.g. "b/c.txt" would result in removing the directory 'b' and the for loop
275 // below would only add to the paths of this list the 'c.txt' part when doing
276 // the existence checks...
277 // NB: we don't use wxPATH_NORM_DOTS here, too (see wxPathList::Add for more info)
278 if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
279 return wxEmptyString;
280
281 wxASSERT_MSG(!fn.IsDir(), wxT("Cannot search for directories; only for files"));
282 if (fn.IsAbsolute())
283 strend = fn.GetFullName(); // search for the file name and ignore the path part
284 else
285 strend = fn.GetFullPath();
286
287 for (size_t i=0; i<GetCount(); i++)
288 {
289 wxString strstart = Item(i);
290 if (!strstart.IsEmpty() && strstart.Last() != wxFileName::GetPathSeparator())
291 strstart += wxFileName::GetPathSeparator();
292
293 if (wxFileExists(strstart + strend))
294 return strstart + strend; // Found!
295 }
296
297 return wxEmptyString; // Not found
298 }
299
300 wxString wxPathList::FindAbsoluteValidPath (const wxString& file) const
301 {
302 wxString f = FindValidPath(file);
303 if ( f.empty() || wxIsAbsolutePath(f) )
304 return f;
305
306 wxString buf = ::wxGetCwd();
307
308 if ( !wxEndsWithPathSeparator(buf) )
309 {
310 buf += wxFILE_SEP_PATH;
311 }
312 buf += f;
313
314 return buf;
315 }
316
317 // ----------------------------------------------------------------------------
318 // miscellaneous global functions (TOFIX!)
319 // ----------------------------------------------------------------------------
320
321 static inline wxChar* MYcopystring(const wxString& s)
322 {
323 wxChar* copy = new wxChar[s.length() + 1];
324 return wxStrcpy(copy, s.c_str());
325 }
326
327 static inline wxChar* MYcopystring(const wxChar* s)
328 {
329 wxChar* copy = new wxChar[wxStrlen(s) + 1];
330 return wxStrcpy(copy, s);
331 }
332
333
334 bool
335 wxFileExists (const wxString& filename)
336 {
337 #if defined(__WXPALMOS__)
338 return false;
339 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
340 // we must use GetFileAttributes() instead of the ANSI C functions because
341 // it can cope with network (UNC) paths unlike them
342 DWORD ret = ::GetFileAttributes(filename);
343
344 return (ret != (DWORD)-1) && !(ret & FILE_ATTRIBUTE_DIRECTORY);
345 #else // !__WIN32__
346 #ifndef S_ISREG
347 #define S_ISREG(mode) ((mode) & S_IFREG)
348 #endif
349 wxStructStat st;
350 #ifndef wxNEED_WX_UNISTD_H
351 return (wxStat( filename.fn_str() , &st) == 0 && S_ISREG(st.st_mode))
352 #ifdef __OS2__
353 || (errno == EACCES) // if access is denied something with that name
354 // exists and is opened in exclusive mode.
355 #endif
356 ;
357 #else
358 return wxStat( filename , &st) == 0 && S_ISREG(st.st_mode);
359 #endif
360 #endif // __WIN32__/!__WIN32__
361 }
362
363 bool
364 wxIsAbsolutePath (const wxString& filename)
365 {
366 if (!filename.empty())
367 {
368 #if defined(__WXMAC__) && !defined(__DARWIN__)
369 // Classic or Carbon CodeWarrior like
370 // Carbon with Apple DevTools is Unix like
371
372 // This seems wrong to me, but there is no fix. since
373 // "MacOS:MyText.txt" is absolute whereas "MyDir:MyText.txt"
374 // is not. Or maybe ":MyDir:MyText.txt" has to be used? RR.
375 if (filename.Find(':') != wxNOT_FOUND && filename[0] != ':')
376 return true ;
377 #else
378 // Unix like or Windows
379 if (filename[0] == wxT('/'))
380 return true;
381 #endif
382 #ifdef __VMS__
383 if ((filename[0] == wxT('[') && filename[1] != wxT('.')))
384 return true;
385 #endif
386 #if defined(__WINDOWS__) || defined(__OS2__)
387 // MSDOS like
388 if (filename[0] == wxT('\\') || (wxIsalpha (filename[0]) && filename[1] == wxT(':')))
389 return true;
390 #endif
391 }
392 return false ;
393 }
394
395 /*
396 * Strip off any extension (dot something) from end of file,
397 * IF one exists. Inserts zero into buffer.
398 *
399 */
400
401 void wxStripExtension(wxChar *buffer)
402 {
403 int len = wxStrlen(buffer);
404 int i = len-1;
405 while (i > 0)
406 {
407 if (buffer[i] == wxT('.'))
408 {
409 buffer[i] = 0;
410 break;
411 }
412 i --;
413 }
414 }
415
416 void wxStripExtension(wxString& buffer)
417 {
418 //RN: Be careful about the handling the case where
419 //buffer.length() == 0
420 for(size_t i = buffer.length() - 1; i != wxString::npos; --i)
421 {
422 if (buffer.GetChar(i) == wxT('.'))
423 {
424 buffer = buffer.Left(i);
425 break;
426 }
427 }
428 }
429
430 // Destructive removal of /./ and /../ stuff
431 wxChar *wxRealPath (wxChar *path)
432 {
433 #ifdef __WXMSW__
434 static const wxChar SEP = wxT('\\');
435 wxUnix2DosFilename(path);
436 #else
437 static const wxChar SEP = wxT('/');
438 #endif
439 if (path[0] && path[1]) {
440 /* MATTHEW: special case "/./x" */
441 wxChar *p;
442 if (path[2] == SEP && path[1] == wxT('.'))
443 p = &path[0];
444 else
445 p = &path[2];
446 for (; *p; p++)
447 {
448 if (*p == SEP)
449 {
450 if (p[1] == wxT('.') && p[2] == wxT('.') && (p[3] == SEP || p[3] == wxT('\0')))
451 {
452 wxChar *q;
453 for (q = p - 1; q >= path && *q != SEP; q--)
454 {
455 // Empty
456 }
457
458 if (q[0] == SEP && (q[1] != wxT('.') || q[2] != wxT('.') || q[3] != SEP)
459 && (q - 1 <= path || q[-1] != SEP))
460 {
461 wxStrcpy (q, p + 3);
462 if (path[0] == wxT('\0'))
463 {
464 path[0] = SEP;
465 path[1] = wxT('\0');
466 }
467 #if defined(__WXMSW__) || defined(__OS2__)
468 /* Check that path[2] is NULL! */
469 else if (path[1] == wxT(':') && !path[2])
470 {
471 path[2] = SEP;
472 path[3] = wxT('\0');
473 }
474 #endif
475 p = q - 1;
476 }
477 }
478 else if (p[1] == wxT('.') && (p[2] == SEP || p[2] == wxT('\0')))
479 wxStrcpy (p, p + 2);
480 }
481 }
482 }
483 return path;
484 }
485
486 wxString wxRealPath(const wxString& path)
487 {
488 wxChar *buf1=MYcopystring(path);
489 wxChar *buf2=wxRealPath(buf1);
490 wxString buf(buf2);
491 delete [] buf1;
492 return buf;
493 }
494
495
496 // Must be destroyed
497 wxChar *wxCopyAbsolutePath(const wxString& filename)
498 {
499 if (filename.empty())
500 return (wxChar *) NULL;
501
502 if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename)))
503 {
504 wxString buf = ::wxGetCwd();
505 wxChar ch = buf.Last();
506 #ifdef __WXMSW__
507 if (ch != wxT('\\') && ch != wxT('/'))
508 buf << wxT("\\");
509 #else
510 if (ch != wxT('/'))
511 buf << wxT("/");
512 #endif
513 buf << wxFileFunctionsBuffer;
514 buf = wxRealPath( buf );
515 return MYcopystring( buf );
516 }
517 return MYcopystring( wxFileFunctionsBuffer );
518 }
519
520 /*-
521 Handles:
522 ~/ => home dir
523 ~user/ => user's home dir
524 If the environment variable a = "foo" and b = "bar" then:
525 Unix:
526 $a => foo
527 $a$b => foobar
528 $a.c => foo.c
529 xxx$a => xxxfoo
530 ${a}! => foo!
531 $(b)! => bar!
532 \$a => \$a
533 MSDOS:
534 $a ==> $a
535 $(a) ==> foo
536 $(a)$b ==> foo$b
537 $(a)$(b)==> foobar
538 test.$$ ==> test.$$
539 */
540
541 /* input name in name, pathname output to buf. */
542
543 wxChar *wxExpandPath(wxChar *buf, const wxChar *name)
544 {
545 register wxChar *d, *s, *nm;
546 wxChar lnm[_MAXPATHLEN];
547 int q;
548
549 // Some compilers don't like this line.
550 // const wxChar trimchars[] = wxT("\n \t");
551
552 wxChar trimchars[4];
553 trimchars[0] = wxT('\n');
554 trimchars[1] = wxT(' ');
555 trimchars[2] = wxT('\t');
556 trimchars[3] = 0;
557
558 #ifdef __WXMSW__
559 const wxChar SEP = wxT('\\');
560 #else
561 const wxChar SEP = wxT('/');
562 #endif
563 buf[0] = wxT('\0');
564 if (name == NULL || *name == wxT('\0'))
565 return buf;
566 nm = MYcopystring(name); // Make a scratch copy
567 wxChar *nm_tmp = nm;
568
569 /* Skip leading whitespace and cr */
570 while (wxStrchr((wxChar *)trimchars, *nm) != NULL)
571 nm++;
572 /* And strip off trailing whitespace and cr */
573 s = nm + (q = wxStrlen(nm)) - 1;
574 while (q-- && wxStrchr((wxChar *)trimchars, *s) != NULL)
575 *s = wxT('\0');
576
577 s = nm;
578 d = lnm;
579 #ifdef __WXMSW__
580 q = FALSE;
581 #else
582 q = nm[0] == wxT('\\') && nm[1] == wxT('~');
583 #endif
584
585 /* Expand inline environment variables */
586 #ifdef __VISAGECPP__
587 while (*d)
588 {
589 *d++ = *s;
590 if(*s == wxT('\\'))
591 {
592 *(d - 1) = *++s;
593 if (*d)
594 {
595 s++;
596 continue;
597 }
598 else
599 break;
600 }
601 else
602 #else
603 while ((*d++ = *s) != 0) {
604 # ifndef __WXMSW__
605 if (*s == wxT('\\')) {
606 if ((*(d - 1) = *++s)!=0) {
607 s++;
608 continue;
609 } else
610 break;
611 } else
612 # endif
613 #endif
614 // No env variables on WinCE
615 #ifndef __WXWINCE__
616 #ifdef __WXMSW__
617 if (*s++ == wxT('$') && (*s == wxT('{') || *s == wxT(')')))
618 #else
619 if (*s++ == wxT('$'))
620 #endif
621 {
622 register wxChar *start = d;
623 register int braces = (*s == wxT('{') || *s == wxT('('));
624 register wxChar *value;
625 while ((*d++ = *s) != 0)
626 if (braces ? (*s == wxT('}') || *s == wxT(')')) : !(wxIsalnum(*s) || *s == wxT('_')) )
627 break;
628 else
629 s++;
630 *--d = 0;
631 value = wxGetenv(braces ? start + 1 : start);
632 if (value) {
633 for ((d = start - 1); (*d++ = *value++) != 0;)
634 {
635 // Empty
636 }
637
638 d--;
639 if (braces && *s)
640 s++;
641 }
642 }
643 #endif
644 // __WXWINCE__
645 }
646
647 /* Expand ~ and ~user */
648 nm = lnm;
649 if (nm[0] == wxT('~') && !q)
650 {
651 /* prefix ~ */
652 if (nm[1] == SEP || nm[1] == 0)
653 { /* ~/filename */
654 // FIXME: wxGetUserHome could return temporary storage in Unicode mode
655 if ((s = WXSTRINGCAST wxGetUserHome(wxEmptyString)) != NULL) {
656 if (*++nm)
657 nm++;
658 }
659 } else
660 { /* ~user/filename */
661 register wxChar *nnm;
662 register wxChar *home;
663 for (s = nm; *s && *s != SEP; s++)
664 {
665 // Empty
666 }
667 int was_sep; /* MATTHEW: Was there a separator, or NULL? */
668 was_sep = (*s == SEP);
669 nnm = *s ? s + 1 : s;
670 *s = 0;
671 // FIXME: wxGetUserHome could return temporary storage in Unicode mode
672 if ((home = WXSTRINGCAST wxGetUserHome(wxString(nm + 1))) == NULL)
673 {
674 if (was_sep) /* replace only if it was there: */
675 *s = SEP;
676 s = NULL;
677 }
678 else
679 {
680 nm = nnm;
681 s = home;
682 }
683 }
684 }
685
686 d = buf;
687 if (s && *s) { /* MATTHEW: s could be NULL if user '~' didn't exist */
688 /* Copy home dir */
689 while (wxT('\0') != (*d++ = *s++))
690 /* loop */;
691 // Handle root home
692 if (d - 1 > buf && *(d - 2) != SEP)
693 *(d - 1) = SEP;
694 }
695 s = nm;
696 while ((*d++ = *s++) != 0)
697 {
698 // Empty
699 }
700 delete[] nm_tmp; // clean up alloc
701 /* Now clean up the buffer */
702 return wxRealPath(buf);
703 }
704
705 /* Contract Paths to be build upon an environment variable
706 component:
707
708 example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib
709
710 The call wxExpandPath can convert these back!
711 */
712 wxChar *
713 wxContractPath (const wxString& filename,
714 const wxString& WXUNUSED_IN_WINCE(envname),
715 const wxString& user)
716 {
717 static wxChar dest[_MAXPATHLEN];
718
719 if (filename.empty())
720 return (wxChar *) NULL;
721
722 wxStrcpy (dest, WXSTRINGCAST filename);
723 #ifdef __WXMSW__
724 wxUnix2DosFilename(dest);
725 #endif
726
727 // Handle environment
728 const wxChar *val;
729 #ifndef __WXWINCE__
730 wxChar *tcp;
731 if (!envname.empty() && (val = wxGetenv (WXSTRINGCAST envname)) != NULL &&
732 (tcp = wxStrstr (dest, val)) != NULL)
733 {
734 wxStrcpy (wxFileFunctionsBuffer, tcp + wxStrlen (val));
735 *tcp++ = wxT('$');
736 *tcp++ = wxT('{');
737 wxStrcpy (tcp, WXSTRINGCAST envname);
738 wxStrcat (tcp, wxT("}"));
739 wxStrcat (tcp, wxFileFunctionsBuffer);
740 }
741 #endif
742
743 // Handle User's home (ignore root homes!)
744 val = wxGetUserHome (user);
745 if (!val)
746 return dest;
747
748 const size_t len = wxStrlen(val);
749 if (len <= 2)
750 return dest;
751
752 if (wxStrncmp(dest, val, len) == 0)
753 {
754 wxStrcpy(wxFileFunctionsBuffer, wxT("~"));
755 if (!user.empty())
756 wxStrcat(wxFileFunctionsBuffer, (const wxChar*) user);
757 wxStrcat(wxFileFunctionsBuffer, dest + len);
758 wxStrcpy (dest, wxFileFunctionsBuffer);
759 }
760
761 return dest;
762 }
763
764 // Return just the filename, not the path (basename)
765 wxChar *wxFileNameFromPath (wxChar *path)
766 {
767 wxString p = path;
768 wxString n = wxFileNameFromPath(p);
769
770 return path + p.length() - n.length();
771 }
772
773 wxString wxFileNameFromPath (const wxString& path)
774 {
775 wxString name, ext;
776 wxFileName::SplitPath(path, NULL, &name, &ext);
777
778 wxString fullname = name;
779 if ( !ext.empty() )
780 {
781 fullname << wxFILE_SEP_EXT << ext;
782 }
783
784 return fullname;
785 }
786
787 // Return just the directory, or NULL if no directory
788 wxChar *
789 wxPathOnly (wxChar *path)
790 {
791 if (path && *path)
792 {
793 static wxChar buf[_MAXPATHLEN];
794
795 // Local copy
796 wxStrcpy (buf, path);
797
798 int l = wxStrlen(path);
799 int i = l - 1;
800
801 // Search backward for a backward or forward slash
802 while (i > -1)
803 {
804 #if defined(__WXMAC__) && !defined(__DARWIN__)
805 // Classic or Carbon CodeWarrior like
806 // Carbon with Apple DevTools is Unix like
807 if (path[i] == wxT(':') )
808 {
809 buf[i] = 0;
810 return buf;
811 }
812 #else
813 // Unix like or Windows
814 if (path[i] == wxT('/') || path[i] == wxT('\\'))
815 {
816 buf[i] = 0;
817 return buf;
818 }
819 #endif
820 #ifdef __VMS__
821 if (path[i] == wxT(']'))
822 {
823 buf[i+1] = 0;
824 return buf;
825 }
826 #endif
827 i --;
828 }
829
830 #if defined(__WXMSW__) || defined(__OS2__)
831 // Try Drive specifier
832 if (wxIsalpha (buf[0]) && buf[1] == wxT(':'))
833 {
834 // A:junk --> A:. (since A:.\junk Not A:\junk)
835 buf[2] = wxT('.');
836 buf[3] = wxT('\0');
837 return buf;
838 }
839 #endif
840 }
841 return (wxChar *) NULL;
842 }
843
844 // Return just the directory, or NULL if no directory
845 wxString wxPathOnly (const wxString& path)
846 {
847 if (!path.empty())
848 {
849 wxChar buf[_MAXPATHLEN];
850
851 // Local copy
852 wxStrcpy (buf, WXSTRINGCAST path);
853
854 int l = path.length();
855 int i = l - 1;
856
857 // Search backward for a backward or forward slash
858 while (i > -1)
859 {
860 #if defined(__WXMAC__) && !defined(__DARWIN__)
861 // Classic or Carbon CodeWarrior like
862 // Carbon with Apple DevTools is Unix like
863 if (path[i] == wxT(':') )
864 {
865 buf[i] = 0;
866 return wxString(buf);
867 }
868 #else
869 // Unix like or Windows
870 if (path[i] == wxT('/') || path[i] == wxT('\\'))
871 {
872 // Don't return an empty string
873 if (i == 0)
874 i ++;
875 buf[i] = 0;
876 return wxString(buf);
877 }
878 #endif
879 #ifdef __VMS__
880 if (path[i] == wxT(']'))
881 {
882 buf[i+1] = 0;
883 return wxString(buf);
884 }
885 #endif
886 i --;
887 }
888
889 #if defined(__WXMSW__) || defined(__OS2__)
890 // Try Drive specifier
891 if (wxIsalpha (buf[0]) && buf[1] == wxT(':'))
892 {
893 // A:junk --> A:. (since A:.\junk Not A:\junk)
894 buf[2] = wxT('.');
895 buf[3] = wxT('\0');
896 return wxString(buf);
897 }
898 #endif
899 }
900 return wxEmptyString;
901 }
902
903 // Utility for converting delimiters in DOS filenames to UNIX style
904 // and back again - or we get nasty problems with delimiters.
905 // Also, convert to lower case, since case is significant in UNIX.
906
907 #if defined(__WXMAC__)
908
909 #if TARGET_API_MAC_OSX
910 #define kDefaultPathStyle kCFURLPOSIXPathStyle
911 #else
912 #define kDefaultPathStyle kCFURLHFSPathStyle
913 #endif
914
915 wxString wxMacFSRefToPath( const FSRef *fsRef , CFStringRef additionalPathComponent )
916 {
917 CFURLRef fullURLRef;
918 fullURLRef = CFURLCreateFromFSRef(NULL, fsRef);
919 if ( additionalPathComponent )
920 {
921 CFURLRef parentURLRef = fullURLRef ;
922 fullURLRef = CFURLCreateCopyAppendingPathComponent(NULL, parentURLRef,
923 additionalPathComponent,false);
924 CFRelease( parentURLRef ) ;
925 }
926 CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, kDefaultPathStyle);
927 CFRelease( fullURLRef ) ;
928 CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString);
929 CFRelease( cfString );
930 CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
931 return wxMacCFStringHolder(cfMutableString).AsString();
932 }
933
934 OSStatus wxMacPathToFSRef( const wxString&path , FSRef *fsRef )
935 {
936 OSStatus err = noErr ;
937 CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, wxMacCFStringHolder(path));
938 CFStringNormalize(cfMutableString,kCFStringNormalizationFormD);
939 CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfMutableString , kDefaultPathStyle, false);
940 CFRelease( cfMutableString );
941 if ( NULL != url )
942 {
943 if ( CFURLGetFSRef(url, fsRef) == false )
944 err = fnfErr ;
945 CFRelease( url ) ;
946 }
947 else
948 {
949 err = fnfErr ;
950 }
951 return err ;
952 }
953
954 wxString wxMacHFSUniStrToString( ConstHFSUniStr255Param uniname )
955 {
956 CFStringRef cfname = CFStringCreateWithCharacters( kCFAllocatorDefault,
957 uniname->unicode,
958 uniname->length );
959 CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfname);
960 CFRelease( cfname );
961 CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
962 return wxMacCFStringHolder(cfMutableString).AsString() ;
963 }
964
965 #ifndef __LP64__
966
967 wxString wxMacFSSpec2MacFilename( const FSSpec *spec )
968 {
969 FSRef fsRef ;
970 if ( FSpMakeFSRef( spec , &fsRef) == noErr )
971 {
972 return wxMacFSRefToPath( &fsRef ) ;
973 }
974 return wxEmptyString ;
975 }
976
977 void wxMacFilename2FSSpec( const wxString& path , FSSpec *spec )
978 {
979 OSStatus err = noErr ;
980 FSRef fsRef ;
981 wxMacPathToFSRef( path , &fsRef ) ;
982 err = FSRefMakeFSSpec( &fsRef , spec ) ;
983 }
984 #endif
985
986 #endif // __WXMAC__
987
988 void
989 wxDos2UnixFilename (wxChar *s)
990 {
991 if (s)
992 while (*s)
993 {
994 if (*s == _T('\\'))
995 *s = _T('/');
996 #ifdef __WXMSW__
997 else
998 *s = (wxChar)wxTolower (*s); // Case INDEPENDENT
999 #endif
1000 s++;
1001 }
1002 }
1003
1004 void
1005 #if defined(__WXMSW__) || defined(__OS2__)
1006 wxUnix2DosFilename (wxChar *s)
1007 #else
1008 wxUnix2DosFilename (wxChar *WXUNUSED(s) )
1009 #endif
1010 {
1011 // Yes, I really mean this to happen under DOS only! JACS
1012 #if defined(__WXMSW__) || defined(__OS2__)
1013 if (s)
1014 while (*s)
1015 {
1016 if (*s == wxT('/'))
1017 *s = wxT('\\');
1018 s++;
1019 }
1020 #endif
1021 }
1022
1023 // Concatenate two files to form third
1024 bool
1025 wxConcatFiles (const wxString& file1, const wxString& file2, const wxString& file3)
1026 {
1027 #if wxUSE_FILE
1028
1029 wxFile in1(file1), in2(file2);
1030 wxTempFile out(file3);
1031
1032 if ( !in1.IsOpened() || !in2.IsOpened() || !out.IsOpened() )
1033 return false;
1034
1035 ssize_t ofs;
1036 unsigned char buf[1024];
1037
1038 for( int i=0; i<2; i++)
1039 {
1040 wxFile *in = i==0 ? &in1 : &in2;
1041 do{
1042 if ( (ofs = in->Read(buf,WXSIZEOF(buf))) == wxInvalidOffset ) return false;
1043 if ( ofs > 0 )
1044 if ( !out.Write(buf,ofs) )
1045 return false;
1046 } while ( ofs == (ssize_t)WXSIZEOF(buf) );
1047 }
1048
1049 return out.Commit();
1050
1051 #else
1052
1053 wxUnusedVar(file1);
1054 wxUnusedVar(file2);
1055 wxUnusedVar(file3);
1056 return false;
1057
1058 #endif
1059 }
1060
1061 // helper of generic implementation of wxCopyFile()
1062 #if !(defined(__WIN32__) || defined(__OS2__) || defined(__PALMOS__)) && \
1063 wxUSE_FILE
1064
1065 static bool
1066 wxDoCopyFile(wxFile& fileIn,
1067 const wxStructStat& fbuf,
1068 const wxString& filenameDst,
1069 bool overwrite)
1070 {
1071 // reset the umask as we want to create the file with exactly the same
1072 // permissions as the original one
1073 wxCHANGE_UMASK(0);
1074
1075 // create file2 with the same permissions than file1 and open it for
1076 // writing
1077
1078 wxFile fileOut;
1079 if ( !fileOut.Create(filenameDst, overwrite, fbuf.st_mode & 0777) )
1080 return false;
1081
1082 // copy contents of file1 to file2
1083 char buf[4096];
1084 for ( ;; )
1085 {
1086 ssize_t count = fileIn.Read(buf, WXSIZEOF(buf));
1087 if ( count == wxInvalidOffset )
1088 return false;
1089
1090 // end of file?
1091 if ( !count )
1092 break;
1093
1094 if ( fileOut.Write(buf, count) < (size_t)count )
1095 return false;
1096 }
1097
1098 // we can expect fileIn to be closed successfully, but we should ensure
1099 // that fileOut was closed as some write errors (disk full) might not be
1100 // detected before doing this
1101 return fileIn.Close() && fileOut.Close();
1102 }
1103
1104 #endif // generic implementation of wxCopyFile
1105
1106 // Copy files
1107 bool
1108 wxCopyFile (const wxString& file1, const wxString& file2, bool overwrite)
1109 {
1110 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1111 // CopyFile() copies file attributes and modification time too, so use it
1112 // instead of our code if available
1113 //
1114 // NB: 3rd parameter is bFailIfExists i.e. the inverse of overwrite
1115 if ( !::CopyFile(file1, file2, !overwrite) )
1116 {
1117 wxLogSysError(_("Failed to copy the file '%s' to '%s'"),
1118 file1.c_str(), file2.c_str());
1119
1120 return false;
1121 }
1122 #elif defined(__OS2__)
1123 if ( ::DosCopy(file1.c_str(), file2.c_str(), overwrite ? DCPY_EXISTING : 0) != 0 )
1124 return false;
1125 #elif defined(__PALMOS__)
1126 // TODO with http://www.palmos.com/dev/support/docs/protein_books/Memory_Databases_Files/
1127 return false;
1128 #elif wxUSE_FILE // !Win32
1129
1130 wxStructStat fbuf;
1131 // get permissions of file1
1132 if ( wxStat( file1.c_str(), &fbuf) != 0 )
1133 {
1134 // the file probably doesn't exist or we haven't the rights to read
1135 // from it anyhow
1136 wxLogSysError(_("Impossible to get permissions for file '%s'"),
1137 file1.c_str());
1138 return false;
1139 }
1140
1141 // open file1 for reading
1142 wxFile fileIn(file1, wxFile::read);
1143 if ( !fileIn.IsOpened() )
1144 return false;
1145
1146 // remove file2, if it exists. This is needed for creating
1147 // file2 with the correct permissions in the next step
1148 if ( wxFileExists(file2) && (!overwrite || !wxRemoveFile(file2)))
1149 {
1150 wxLogSysError(_("Impossible to overwrite the file '%s'"),
1151 file2.c_str());
1152 return false;
1153 }
1154
1155 wxDoCopyFile(fileIn, fbuf, file2, overwrite);
1156
1157 #if defined(__WXMAC__) || defined(__WXCOCOA__)
1158 // copy the resource fork of the file too if it's present
1159 wxString pathRsrcOut;
1160 wxFile fileRsrcIn;
1161
1162 {
1163 // suppress error messages from this block as resource forks don't have
1164 // to exist
1165 wxLogNull noLog;
1166
1167 // it's not enough to check for file existence: it always does on HFS
1168 // but is empty for files without resources
1169 if ( fileRsrcIn.Open(file1 + wxT("/..namedfork/rsrc")) &&
1170 fileRsrcIn.Length() > 0 )
1171 {
1172 // we must be using HFS or another filesystem with resource fork
1173 // support, suppose that destination file system also is HFS[-like]
1174 pathRsrcOut = file2 + wxT("/..namedfork/rsrc");
1175 }
1176 else // check if we have resource fork in separate file (non-HFS case)
1177 {
1178 wxFileName fnRsrc(file1);
1179 fnRsrc.SetName(wxT("._") + fnRsrc.GetName());
1180
1181 fileRsrcIn.Close();
1182 if ( fileRsrcIn.Open( fnRsrc.GetFullPath() ) )
1183 {
1184 fnRsrc = file2;
1185 fnRsrc.SetName(wxT("._") + fnRsrc.GetName());
1186
1187 pathRsrcOut = fnRsrc.GetFullPath();
1188 }
1189 }
1190 }
1191
1192 if ( !pathRsrcOut.empty() )
1193 {
1194 if ( !wxDoCopyFile(fileRsrcIn, fbuf, pathRsrcOut, overwrite) )
1195 return false;
1196 }
1197 #endif // wxMac || wxCocoa
1198
1199 #if !defined(__VISAGECPP__) && !defined(__WXMAC__) || defined(__UNIX__)
1200 // no chmod in VA. Should be some permission API for HPFS386 partitions
1201 // however
1202 if ( chmod(OS_FILENAME(file2), fbuf.st_mode) != 0 )
1203 {
1204 wxLogSysError(_("Impossible to set permissions for the file '%s'"),
1205 file2.c_str());
1206 return false;
1207 }
1208 #endif // OS/2 || Mac
1209
1210 #else // !Win32 && ! wxUSE_FILE
1211
1212 // impossible to simulate with wxWidgets API
1213 wxUnusedVar(file1);
1214 wxUnusedVar(file2);
1215 wxUnusedVar(overwrite);
1216 return false;
1217
1218 #endif // __WXMSW__ && __WIN32__
1219
1220 return true;
1221 }
1222
1223 bool
1224 wxRenameFile(const wxString& file1, const wxString& file2, bool overwrite)
1225 {
1226 if ( !overwrite && wxFileExists(file2) )
1227 {
1228 wxLogSysError
1229 (
1230 _("Failed to rename the file '%s' to '%s' because the destination file already exists."),
1231 file1.c_str(), file2.c_str()
1232 );
1233
1234 return false;
1235 }
1236
1237 #if !defined(__WXWINCE__) && !defined(__WXPALMOS__)
1238 // Normal system call
1239 if ( wxRename (file1, file2) == 0 )
1240 return true;
1241 #endif
1242
1243 // Try to copy
1244 if (wxCopyFile(file1, file2, overwrite)) {
1245 wxRemoveFile(file1);
1246 return true;
1247 }
1248 // Give up
1249 return false;
1250 }
1251
1252 bool wxRemoveFile(const wxString& file)
1253 {
1254 #if defined(__VISUALC__) \
1255 || defined(__BORLANDC__) \
1256 || defined(__WATCOMC__) \
1257 || defined(__DMC__) \
1258 || defined(__GNUWIN32__) \
1259 || (defined(__MWERKS__) && defined(__MSL__))
1260 int res = wxRemove(file);
1261 #elif defined(__WXMAC__)
1262 int res = unlink(wxFNCONV(file));
1263 #elif defined(__WXPALMOS__)
1264 int res = 1;
1265 // TODO with VFSFileDelete()
1266 #else
1267 int res = unlink(OS_FILENAME(file));
1268 #endif
1269
1270 return res == 0;
1271 }
1272
1273 bool wxMkdir(const wxString& dir, int perm)
1274 {
1275 #if defined(__WXPALMOS__)
1276 return false;
1277 #elif defined(__WXMAC__) && !defined(__UNIX__)
1278 return (mkdir( wxFNCONV(dir) , 0 ) == 0);
1279 #else // !Mac
1280 const wxChar *dirname = dir.c_str();
1281
1282 // assume mkdir() has 2 args on non Windows-OS/2 platforms and on Windows too
1283 // for the GNU compiler
1284 #if (!(defined(__WXMSW__) || defined(__OS2__) || defined(__DOS__))) || (defined(__GNUWIN32__) && !defined(__MINGW32__)) || defined(__WINE__) || defined(__WXMICROWIN__)
1285 #if defined(MSVCRT)
1286 wxUnusedVar(perm);
1287 if ( mkdir(wxFNCONV(dirname)) != 0 )
1288 #else
1289 if ( mkdir(wxFNCONV(dirname), perm) != 0 )
1290 #endif
1291 #elif defined(__OS2__)
1292 wxUnusedVar(perm);
1293 if (::DosCreateDir((PSZ)dirname, NULL) != 0) // enhance for EAB's??
1294 #elif defined(__DOS__)
1295 #if defined(__WATCOMC__)
1296 (void)perm;
1297 if ( wxMkDir(wxFNSTRINGCAST wxFNCONV(dirname)) != 0 )
1298 #elif defined(__DJGPP__)
1299 if ( mkdir(wxFNCONV(dirname), perm) != 0 )
1300 #else
1301 #error "Unsupported DOS compiler!"
1302 #endif
1303 #else // !MSW, !DOS and !OS/2 VAC++
1304 wxUnusedVar(perm);
1305 #ifdef __WXWINCE__
1306 if ( !CreateDirectory(dirname, NULL) )
1307 #else
1308 if ( wxMkDir(dir.fn_str()) != 0 )
1309 #endif
1310 #endif // !MSW/MSW
1311 {
1312 wxLogSysError(_("Directory '%s' couldn't be created"), dirname);
1313
1314 return false;
1315 }
1316
1317 return true;
1318 #endif // Mac/!Mac
1319 }
1320
1321 bool wxRmdir(const wxString& dir, int WXUNUSED(flags))
1322 {
1323 #if defined(__VMS__)
1324 return false; //to be changed since rmdir exists in VMS7.x
1325 #elif defined(__OS2__)
1326 return (::DosDeleteDir(dir.c_str()) == 0);
1327 #elif defined(__WXWINCE__)
1328 return (RemoveDirectory(dir) != 0);
1329 #elif defined(__WXPALMOS__)
1330 // TODO with VFSFileRename()
1331 return false;
1332 #else
1333 return (wxRmDir(OS_FILENAME(dir)) == 0);
1334 #endif
1335 }
1336
1337 // does the path exists? (may have or not '/' or '\\' at the end)
1338 bool wxDirExists(const wxString& pathName)
1339 {
1340 wxString strPath(pathName);
1341
1342 #if defined(__WINDOWS__) || defined(__OS2__)
1343 // Windows fails to find directory named "c:\dir\" even if "c:\dir" exists,
1344 // so remove all trailing backslashes from the path - but don't do this for
1345 // the paths "d:\" (which are different from "d:") nor for just "\"
1346 while ( wxEndsWithPathSeparator(strPath) )
1347 {
1348 size_t len = strPath.length();
1349 if ( len == 1 || (len == 3 && strPath[len - 2] == _T(':')) )
1350 break;
1351
1352 strPath.Truncate(len - 1);
1353 }
1354 #endif // __WINDOWS__
1355
1356 #ifdef __OS2__
1357 // OS/2 can't handle "d:", it wants either "d:\" or "d:."
1358 if (strPath.length() == 2 && strPath[1u] == _T(':'))
1359 strPath << _T('.');
1360 #endif
1361
1362 #if defined(__WXPALMOS__)
1363 return false;
1364 #elif defined(__WIN32__) && !defined(__WXMICROWIN__)
1365 // stat() can't cope with network paths
1366 DWORD ret = ::GetFileAttributes(strPath);
1367
1368 return (ret != (DWORD)-1) && (ret & FILE_ATTRIBUTE_DIRECTORY);
1369 #elif defined(__OS2__)
1370 FILESTATUS3 Info = {{0}};
1371 APIRET rc = ::DosQueryPathInfo((PSZ)(WXSTRINGCAST strPath), FIL_STANDARD,
1372 (void*) &Info, sizeof(FILESTATUS3));
1373
1374 return ((rc == NO_ERROR) && (Info.attrFile & FILE_DIRECTORY)) ||
1375 (rc == ERROR_SHARING_VIOLATION);
1376 // If we got a sharing violation, there must be something with this name.
1377 #else // !__WIN32__
1378
1379 wxStructStat st;
1380 #ifndef __VISAGECPP__
1381 return wxStat(strPath.c_str(), &st) == 0 && ((st.st_mode & S_IFMT) == S_IFDIR);
1382 #else
1383 // S_IFMT not supported in VA compilers.. st_mode is a 2byte value only
1384 return wxStat(strPath.c_str(), &st) == 0 && (st.st_mode == S_IFDIR);
1385 #endif
1386
1387 #endif // __WIN32__/!__WIN32__
1388 }
1389
1390 // Get a temporary filename, opening and closing the file.
1391 wxChar *wxGetTempFileName(const wxString& prefix, wxChar *buf)
1392 {
1393 wxString filename;
1394 if ( !wxGetTempFileName(prefix, filename) )
1395 return NULL;
1396
1397 if ( buf )
1398 wxStrcpy(buf, filename);
1399 else
1400 buf = MYcopystring(filename);
1401
1402 return buf;
1403 }
1404
1405 bool wxGetTempFileName(const wxString& prefix, wxString& buf)
1406 {
1407 #if wxUSE_FILE
1408 buf = wxFileName::CreateTempFileName(prefix);
1409
1410 return !buf.empty();
1411 #else // !wxUSE_FILE
1412 wxUnusedVar(prefix);
1413 wxUnusedVar(buf);
1414
1415 return false;
1416 #endif // wxUSE_FILE/!wxUSE_FILE
1417 }
1418
1419 // Get first file name matching given wild card.
1420
1421 static wxDir *gs_dir = NULL;
1422 static wxString gs_dirPath;
1423
1424 wxString wxFindFirstFile(const wxChar *spec, int flags)
1425 {
1426 wxSplitPath(spec, &gs_dirPath, NULL, NULL);
1427 if ( gs_dirPath.empty() )
1428 gs_dirPath = wxT(".");
1429 if ( !wxEndsWithPathSeparator(gs_dirPath ) )
1430 gs_dirPath << wxFILE_SEP_PATH;
1431
1432 if (gs_dir)
1433 delete gs_dir;
1434 gs_dir = new wxDir(gs_dirPath);
1435
1436 if ( !gs_dir->IsOpened() )
1437 {
1438 wxLogSysError(_("Can not enumerate files '%s'"), spec);
1439 return wxEmptyString;
1440 }
1441
1442 int dirFlags;
1443 switch (flags)
1444 {
1445 case wxDIR: dirFlags = wxDIR_DIRS; break;
1446 case wxFILE: dirFlags = wxDIR_FILES; break;
1447 default: dirFlags = wxDIR_DIRS | wxDIR_FILES; break;
1448 }
1449
1450 wxString result;
1451 gs_dir->GetFirst(&result, wxFileNameFromPath(wxString(spec)), dirFlags);
1452 if ( result.empty() )
1453 {
1454 wxDELETE(gs_dir);
1455 return result;
1456 }
1457
1458 return gs_dirPath + result;
1459 }
1460
1461 wxString wxFindNextFile()
1462 {
1463 wxASSERT_MSG( gs_dir, wxT("You must call wxFindFirstFile before!") );
1464
1465 wxString result;
1466 gs_dir->GetNext(&result);
1467
1468 if ( result.empty() )
1469 {
1470 wxDELETE(gs_dir);
1471 return result;
1472 }
1473
1474 return gs_dirPath + result;
1475 }
1476
1477
1478 // Get current working directory.
1479 // If buf is NULL, allocates space using new, else copies into buf.
1480 // wxGetWorkingDirectory() is obsolete, use wxGetCwd()
1481 // wxDoGetCwd() is their common core to be moved
1482 // to wxGetCwd() once wxGetWorkingDirectory() will be removed.
1483 // Do not expose wxDoGetCwd in headers!
1484
1485 wxChar *wxDoGetCwd(wxChar *buf, int sz)
1486 {
1487 #if defined(__WXPALMOS__)
1488 // TODO
1489 if(buf && sz>0) buf[0] = _T('\0');
1490 return buf;
1491 #elif defined(__WXWINCE__)
1492 // TODO
1493 if(buf && sz>0) buf[0] = _T('\0');
1494 return buf;
1495 #else
1496 if ( !buf )
1497 {
1498 buf = new wxChar[sz + 1];
1499 }
1500
1501 bool ok wxDUMMY_INITIALIZE(false);
1502
1503 // for the compilers which have Unicode version of _getcwd(), call it
1504 // directly, for the others call the ANSI version and do the translation
1505 #if !wxUSE_UNICODE
1506 #define cbuf buf
1507 #else // wxUSE_UNICODE
1508 bool needsANSI = true;
1509
1510 #if !defined(HAVE_WGETCWD) || wxUSE_UNICODE_MSLU
1511 char cbuf[_MAXPATHLEN];
1512 #endif
1513
1514 #ifdef HAVE_WGETCWD
1515 #if wxUSE_UNICODE_MSLU
1516 if ( wxGetOsVersion() != wxOS_WINDOWS_9X )
1517 #else
1518 char *cbuf = NULL; // never really used because needsANSI will always be false
1519 #endif
1520 {
1521 ok = _wgetcwd(buf, sz) != NULL;
1522 needsANSI = false;
1523 }
1524 #endif
1525
1526 if ( needsANSI )
1527 #endif // wxUSE_UNICODE
1528 {
1529 #if defined(_MSC_VER) || defined(__MINGW32__)
1530 ok = _getcwd(cbuf, sz) != NULL;
1531 #elif defined(__WXMAC__) && !defined(__DARWIN__)
1532 char lbuf[1024] ;
1533 if ( getcwd( lbuf , sizeof( lbuf ) ) )
1534 {
1535 wxString res( lbuf , *wxConvCurrent ) ;
1536 wxStrcpy( buf , res ) ;
1537 ok = true;
1538 }
1539 else
1540 ok = false ;
1541 #elif defined(__OS2__)
1542 APIRET rc;
1543 ULONG ulDriveNum = 0;
1544 ULONG ulDriveMap = 0;
1545 rc = ::DosQueryCurrentDisk(&ulDriveNum, &ulDriveMap);
1546 ok = rc == 0;
1547 if (ok)
1548 {
1549 sz -= 3;
1550 rc = ::DosQueryCurrentDir( 0 // current drive
1551 ,cbuf + 3
1552 ,(PULONG)&sz
1553 );
1554 cbuf[0] = char('A' + (ulDriveNum - 1));
1555 cbuf[1] = ':';
1556 cbuf[2] = '\\';
1557 ok = rc == 0;
1558 }
1559 #else // !Win32/VC++ !Mac !OS2
1560 ok = getcwd(cbuf, sz) != NULL;
1561 #endif // platform
1562
1563 #if wxUSE_UNICODE && !(defined(__WXMAC__) && !defined(__DARWIN__))
1564 // finally convert the result to Unicode if needed
1565 wxConvFile.MB2WC(buf, cbuf, sz);
1566 #endif // wxUSE_UNICODE
1567 }
1568
1569 if ( !ok )
1570 {
1571 wxLogSysError(_("Failed to get the working directory"));
1572
1573 // VZ: the old code used to return "." on error which didn't make any
1574 // sense at all to me - empty string is a better error indicator
1575 // (NULL might be even better but I'm afraid this could lead to
1576 // problems with the old code assuming the return is never NULL)
1577 buf[0] = _T('\0');
1578 }
1579 else // ok, but we might need to massage the path into the right format
1580 {
1581 #ifdef __DJGPP__
1582 // VS: DJGPP is a strange mix of DOS and UNIX API and returns paths
1583 // with / deliminers. We don't like that.
1584 for (wxChar *ch = buf; *ch; ch++)
1585 {
1586 if (*ch == wxT('/'))
1587 *ch = wxT('\\');
1588 }
1589 #endif // __DJGPP__
1590
1591 // MBN: we hope that in the case the user is compiling a GTK+/Motif app,
1592 // he needs Unix as opposed to Win32 pathnames
1593 #if defined( __CYGWIN__ ) && defined( __WINDOWS__ )
1594 // another example of DOS/Unix mix (Cygwin)
1595 wxString pathUnix = buf;
1596 #if wxUSE_UNICODE
1597 char bufA[_MAXPATHLEN];
1598 cygwin_conv_to_full_win32_path(pathUnix.mb_str(wxConvFile), bufA);
1599 wxConvFile.MB2WC(buf, bufA, sz);
1600 #else
1601 cygwin_conv_to_full_win32_path(pathUnix, buf);
1602 #endif // wxUSE_UNICODE
1603 #endif // __CYGWIN__
1604 }
1605
1606 return buf;
1607
1608 #if !wxUSE_UNICODE
1609 #undef cbuf
1610 #endif
1611
1612 #endif
1613 // __WXWINCE__
1614 }
1615
1616 #if WXWIN_COMPATIBILITY_2_6
1617 wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
1618 {
1619 return wxDoGetCwd(buf,sz);
1620 }
1621 #endif // WXWIN_COMPATIBILITY_2_6
1622
1623 wxString wxGetCwd()
1624 {
1625 wxString str;
1626 wxDoGetCwd(wxStringBuffer(str, _MAXPATHLEN), _MAXPATHLEN);
1627 return str;
1628 }
1629
1630 bool wxSetWorkingDirectory(const wxString& d)
1631 {
1632 #if defined(__OS2__)
1633 if (d[1] == ':')
1634 {
1635 ::DosSetDefaultDisk(1 + wxToupper(d[0]) - _T('A'));
1636 // do not call DosSetCurrentDir when just changing drive,
1637 // since it requires e.g. "d:." instead of "d:"!
1638 if (d.length() == 2)
1639 return true;
1640 }
1641 return (::DosSetCurrentDir(d.c_str()) == 0);
1642 #elif defined(__UNIX__) || defined(__WXMAC__) || defined(__DOS__)
1643 return (chdir(wxFNSTRINGCAST d.fn_str()) == 0);
1644 #elif defined(__WINDOWS__)
1645
1646 #ifdef __WIN32__
1647 #ifdef __WXWINCE__
1648 // No equivalent in WinCE
1649 wxUnusedVar(d);
1650 return false;
1651 #else
1652 return (bool)(SetCurrentDirectory(d) != 0);
1653 #endif
1654 #else
1655 // Must change drive, too.
1656 bool isDriveSpec = ((strlen(d) > 1) && (d[1] == ':'));
1657 if (isDriveSpec)
1658 {
1659 wxChar firstChar = d[0];
1660
1661 // To upper case
1662 if (firstChar > 90)
1663 firstChar = firstChar - 32;
1664
1665 // To a drive number
1666 unsigned int driveNo = firstChar - 64;
1667 if (driveNo > 0)
1668 {
1669 unsigned int noDrives;
1670 _dos_setdrive(driveNo, &noDrives);
1671 }
1672 }
1673 bool success = (chdir(WXSTRINGCAST d) == 0);
1674
1675 return success;
1676 #endif
1677
1678 #endif
1679 }
1680
1681 // Get the OS directory if appropriate (such as the Windows directory).
1682 // On non-Windows platform, probably just return the empty string.
1683 wxString wxGetOSDirectory()
1684 {
1685 #ifdef __WXWINCE__
1686 return wxString(wxT("\\Windows"));
1687 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
1688 wxChar buf[256];
1689 GetWindowsDirectory(buf, 256);
1690 return wxString(buf);
1691 #elif defined(__WXMAC__)
1692 return wxMacFindFolder(kOnSystemDisk, 'macs', false);
1693 #else
1694 return wxEmptyString;
1695 #endif
1696 }
1697
1698 bool wxEndsWithPathSeparator(const wxChar *pszFileName)
1699 {
1700 size_t len = wxStrlen(pszFileName);
1701
1702 return len && wxIsPathSeparator(pszFileName[len - 1]);
1703 }
1704
1705 // find a file in a list of directories, returns false if not found
1706 bool wxFindFileInPath(wxString *pStr, const wxChar *pszPath, const wxChar *pszFile)
1707 {
1708 // we assume that it's not empty
1709 wxCHECK_MSG( !wxIsEmpty(pszFile), false,
1710 _T("empty file name in wxFindFileInPath"));
1711
1712 // skip path separator in the beginning of the file name if present
1713 if ( wxIsPathSeparator(*pszFile) )
1714 pszFile++;
1715
1716 // copy the path (strtok will modify it)
1717 wxChar *szPath = new wxChar[wxStrlen(pszPath) + 1];
1718 wxStrcpy(szPath, pszPath);
1719
1720 wxString strFile;
1721 wxChar *pc, *save_ptr;
1722 for ( pc = wxStrtok(szPath, wxPATH_SEP, &save_ptr);
1723 pc != NULL;
1724 pc = wxStrtok((wxChar *) NULL, wxPATH_SEP, &save_ptr) )
1725 {
1726 // search for the file in this directory
1727 strFile = pc;
1728 if ( !wxEndsWithPathSeparator(pc) )
1729 strFile += wxFILE_SEP_PATH;
1730 strFile += pszFile;
1731
1732 if ( wxFileExists(strFile) ) {
1733 *pStr = strFile;
1734 break;
1735 }
1736 }
1737
1738 // suppress warning about unused variable save_ptr when wxStrtok() is a
1739 // macro which throws away its third argument
1740 save_ptr = pc;
1741
1742 delete [] szPath;
1743
1744 return pc != NULL; // if true => we breaked from the loop
1745 }
1746
1747 void WXDLLEXPORT wxSplitPath(const wxChar *pszFileName,
1748 wxString *pstrPath,
1749 wxString *pstrName,
1750 wxString *pstrExt)
1751 {
1752 // it can be empty, but it shouldn't be NULL
1753 wxCHECK_RET( pszFileName, wxT("NULL file name in wxSplitPath") );
1754
1755 wxFileName::SplitPath(pszFileName, pstrPath, pstrName, pstrExt);
1756 }
1757
1758 #if wxUSE_DATETIME
1759
1760 time_t WXDLLEXPORT wxFileModificationTime(const wxString& filename)
1761 {
1762 wxDateTime mtime;
1763 if ( !wxFileName(filename).GetTimes(NULL, &mtime, NULL) )
1764 return (time_t)-1;
1765
1766 return mtime.GetTicks();
1767 }
1768
1769 #endif // wxUSE_DATETIME
1770
1771
1772 // Parses the filterStr, returning the number of filters.
1773 // Returns 0 if none or if there's a problem.
1774 // filterStr is in the form: "All files (*.*)|*.*|JPEG Files (*.jpeg)|*.jpeg"
1775
1776 int WXDLLEXPORT wxParseCommonDialogsFilter(const wxString& filterStr,
1777 wxArrayString& descriptions,
1778 wxArrayString& filters)
1779 {
1780 descriptions.Clear();
1781 filters.Clear();
1782
1783 wxString str(filterStr);
1784
1785 wxString description, filter;
1786 int pos = 0;
1787 while( pos != wxNOT_FOUND )
1788 {
1789 pos = str.Find(wxT('|'));
1790 if ( pos == wxNOT_FOUND )
1791 {
1792 // if there are no '|'s at all in the string just take the entire
1793 // string as filter and make description empty for later autocompletion
1794 if ( filters.IsEmpty() )
1795 {
1796 descriptions.Add(wxEmptyString);
1797 filters.Add(filterStr);
1798 }
1799 else
1800 {
1801 wxFAIL_MSG( _T("missing '|' in the wildcard string!") );
1802 }
1803
1804 break;
1805 }
1806
1807 description = str.Left(pos);
1808 str = str.Mid(pos + 1);
1809 pos = str.Find(wxT('|'));
1810 if ( pos == wxNOT_FOUND )
1811 {
1812 filter = str;
1813 }
1814 else
1815 {
1816 filter = str.Left(pos);
1817 str = str.Mid(pos + 1);
1818 }
1819
1820 descriptions.Add(description);
1821 filters.Add(filter);
1822 }
1823
1824 #if defined(__WXMOTIF__)
1825 // split it so there is one wildcard per entry
1826 for( size_t i = 0 ; i < descriptions.GetCount() ; i++ )
1827 {
1828 pos = filters[i].Find(wxT(';'));
1829 if (pos != wxNOT_FOUND)
1830 {
1831 // first split only filters
1832 descriptions.Insert(descriptions[i],i+1);
1833 filters.Insert(filters[i].Mid(pos+1),i+1);
1834 filters[i]=filters[i].Left(pos);
1835
1836 // autoreplace new filter in description with pattern:
1837 // C/C++ Files(*.cpp;*.c;*.h)|*.cpp;*.c;*.h
1838 // cause split into:
1839 // C/C++ Files(*.cpp)|*.cpp
1840 // C/C++ Files(*.c;*.h)|*.c;*.h
1841 // and next iteration cause another split into:
1842 // C/C++ Files(*.cpp)|*.cpp
1843 // C/C++ Files(*.c)|*.c
1844 // C/C++ Files(*.h)|*.h
1845 for ( size_t k=i;k<i+2;k++ )
1846 {
1847 pos = descriptions[k].Find(filters[k]);
1848 if (pos != wxNOT_FOUND)
1849 {
1850 wxString before = descriptions[k].Left(pos);
1851 wxString after = descriptions[k].Mid(pos+filters[k].Len());
1852 pos = before.Find(_T('('),true);
1853 if (pos>before.Find(_T(')'),true))
1854 {
1855 before = before.Left(pos+1);
1856 before << filters[k];
1857 pos = after.Find(_T(')'));
1858 int pos1 = after.Find(_T('('));
1859 if (pos != wxNOT_FOUND && (pos<pos1 || pos1==wxNOT_FOUND))
1860 {
1861 before << after.Mid(pos);
1862 descriptions[k] = before;
1863 }
1864 }
1865 }
1866 }
1867 }
1868 }
1869 #endif
1870
1871 // autocompletion
1872 for( size_t j = 0 ; j < descriptions.GetCount() ; j++ )
1873 {
1874 if ( descriptions[j].empty() && !filters[j].empty() )
1875 {
1876 descriptions[j].Printf(_("Files (%s)"), filters[j].c_str());
1877 }
1878 }
1879
1880 return filters.GetCount();
1881 }
1882
1883 #if defined(__WINDOWS__) && !(defined(__UNIX__) || defined(__OS2__))
1884 static bool wxCheckWin32Permission(const wxString& path, DWORD access)
1885 {
1886 // quoting the MSDN: "To obtain a handle to a directory, call the
1887 // CreateFile function with the FILE_FLAG_BACKUP_SEMANTICS flag", but this
1888 // doesn't work under Win9x/ME but then it's not needed there anyhow
1889 bool isdir = wxDirExists(path);
1890 if ( isdir && wxGetOsVersion() == wxOS_WINDOWS_9X )
1891 {
1892 // FAT directories always allow all access, even if they have the
1893 // readonly flag set
1894 return true;
1895 }
1896
1897 HANDLE h = ::CreateFile
1898 (
1899 path.c_str(),
1900 access,
1901 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1902 NULL,
1903 OPEN_EXISTING,
1904 isdir ? FILE_FLAG_BACKUP_SEMANTICS : 0,
1905 NULL
1906 );
1907 if ( h != INVALID_HANDLE_VALUE )
1908 CloseHandle(h);
1909
1910 return h != INVALID_HANDLE_VALUE;
1911 }
1912 #endif // __WINDOWS__
1913
1914 bool wxIsWritable(const wxString &path)
1915 {
1916 #if defined( __UNIX__ ) || defined(__OS2__)
1917 // access() will take in count also symbolic links
1918 return access(wxConvFile.cWX2MB(path), W_OK) == 0;
1919 #elif defined( __WINDOWS__ )
1920 return wxCheckWin32Permission(path, GENERIC_WRITE);
1921 #else
1922 wxUnusedVar(path);
1923 // TODO
1924 return false;
1925 #endif
1926 }
1927
1928 bool wxIsReadable(const wxString &path)
1929 {
1930 #if defined( __UNIX__ ) || defined(__OS2__)
1931 // access() will take in count also symbolic links
1932 return access(wxConvFile.cWX2MB(path), R_OK) == 0;
1933 #elif defined( __WINDOWS__ )
1934 return wxCheckWin32Permission(path, GENERIC_READ);
1935 #else
1936 wxUnusedVar(path);
1937 // TODO
1938 return false;
1939 #endif
1940 }
1941
1942 bool wxIsExecutable(const wxString &path)
1943 {
1944 #if defined( __UNIX__ ) || defined(__OS2__)
1945 // access() will take in count also symbolic links
1946 return access(wxConvFile.cWX2MB(path), X_OK) == 0;
1947 #elif defined( __WINDOWS__ )
1948 return wxCheckWin32Permission(path, GENERIC_EXECUTE);
1949 #else
1950 wxUnusedVar(path);
1951 // TODO
1952 return false;
1953 #endif
1954 }
1955
1956 // Return the type of an open file
1957 //
1958 // Some file types on some platforms seem seekable but in fact are not.
1959 // The main use of this function is to allow such cases to be detected
1960 // (IsSeekable() is implemented as wxGetFileKind() == wxFILE_KIND_DISK).
1961 //
1962 // This is important for the archive streams, which benefit greatly from
1963 // being able to seek on a stream, but which will produce corrupt archives
1964 // if they unknowingly seek on a non-seekable stream.
1965 //
1966 // wxFILE_KIND_DISK is a good catch all return value, since other values
1967 // disable features of the archive streams. Some other value must be returned
1968 // for a file type that appears seekable but isn't.
1969 //
1970 // Known examples:
1971 // * Pipes on Windows
1972 // * Files on VMS with a record format other than StreamLF
1973 //
1974 wxFileKind wxGetFileKind(int fd)
1975 {
1976 #if defined __WXMSW__ && !defined __WXWINCE__ && defined wxGetOSFHandle
1977 switch (::GetFileType(wxGetOSFHandle(fd)) & ~FILE_TYPE_REMOTE)
1978 {
1979 case FILE_TYPE_CHAR:
1980 return wxFILE_KIND_TERMINAL;
1981 case FILE_TYPE_DISK:
1982 return wxFILE_KIND_DISK;
1983 case FILE_TYPE_PIPE:
1984 return wxFILE_KIND_PIPE;
1985 }
1986
1987 return wxFILE_KIND_UNKNOWN;
1988
1989 #elif defined(__UNIX__)
1990 if (isatty(fd))
1991 return wxFILE_KIND_TERMINAL;
1992
1993 struct stat st;
1994 fstat(fd, &st);
1995
1996 if (S_ISFIFO(st.st_mode))
1997 return wxFILE_KIND_PIPE;
1998 if (!S_ISREG(st.st_mode))
1999 return wxFILE_KIND_UNKNOWN;
2000
2001 #if defined(__VMS__)
2002 if (st.st_fab_rfm != FAB$C_STMLF)
2003 return wxFILE_KIND_UNKNOWN;
2004 #endif
2005
2006 return wxFILE_KIND_DISK;
2007
2008 #else
2009 #define wxFILEKIND_STUB
2010 (void)fd;
2011 return wxFILE_KIND_DISK;
2012 #endif
2013 }
2014
2015 wxFileKind wxGetFileKind(FILE *fp)
2016 {
2017 // Note: The watcom rtl dll doesn't have fileno (the static lib does).
2018 // Should be fixed in version 1.4.
2019 #if defined(wxFILEKIND_STUB) || wxONLY_WATCOM_EARLIER_THAN(1,4)
2020 (void)fp;
2021 return wxFILE_KIND_DISK;
2022 #elif defined(__WINDOWS__) && !defined(__CYGWIN__) && !defined(__WATCOMC__) && !defined(__WINE__)
2023 return fp ? wxGetFileKind(_fileno(fp)) : wxFILE_KIND_UNKNOWN;
2024 #else
2025 return fp ? wxGetFileKind(fileno(fp)) : wxFILE_KIND_UNKNOWN;
2026 #endif
2027 }
2028
2029
2030 //------------------------------------------------------------------------
2031 // wild character routines
2032 //------------------------------------------------------------------------
2033
2034 bool wxIsWild( const wxString& pattern )
2035 {
2036 wxString tmp = pattern;
2037 wxChar *pat = WXSTRINGCAST(tmp);
2038 while (*pat)
2039 {
2040 switch (*pat++)
2041 {
2042 case wxT('?'): case wxT('*'): case wxT('['): case wxT('{'):
2043 return true;
2044 case wxT('\\'):
2045 if (!*pat++)
2046 return false;
2047 }
2048 }
2049 return false;
2050 }
2051
2052 /*
2053 * Written By Douglas A. Lewis <dalewis@cs.Buffalo.EDU>
2054 *
2055 * The match procedure is public domain code (from ircII's reg.c)
2056 * but modified to suit our tastes (RN: No "%" syntax I guess)
2057 */
2058
2059 bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
2060 {
2061 if (text.empty())
2062 {
2063 /* Match if both are empty. */
2064 return pat.empty();
2065 }
2066
2067 const wxChar *m = pat.c_str(),
2068 *n = text.c_str(),
2069 *ma = NULL,
2070 *na = NULL;
2071 int just = 0,
2072 acount = 0,
2073 count = 0;
2074
2075 if (dot_special && (*n == wxT('.')))
2076 {
2077 /* Never match so that hidden Unix files
2078 * are never found. */
2079 return false;
2080 }
2081
2082 for (;;)
2083 {
2084 if (*m == wxT('*'))
2085 {
2086 ma = ++m;
2087 na = n;
2088 just = 1;
2089 acount = count;
2090 }
2091 else if (*m == wxT('?'))
2092 {
2093 m++;
2094 if (!*n++)
2095 return false;
2096 }
2097 else
2098 {
2099 if (*m == wxT('\\'))
2100 {
2101 m++;
2102 /* Quoting "nothing" is a bad thing */
2103 if (!*m)
2104 return false;
2105 }
2106 if (!*m)
2107 {
2108 /*
2109 * If we are out of both strings or we just
2110 * saw a wildcard, then we can say we have a
2111 * match
2112 */
2113 if (!*n)
2114 return true;
2115 if (just)
2116 return true;
2117 just = 0;
2118 goto not_matched;
2119 }
2120 /*
2121 * We could check for *n == NULL at this point, but
2122 * since it's more common to have a character there,
2123 * check to see if they match first (m and n) and
2124 * then if they don't match, THEN we can check for
2125 * the NULL of n
2126 */
2127 just = 0;
2128 if (*m == *n)
2129 {
2130 m++;
2131 count++;
2132 n++;
2133 }
2134 else
2135 {
2136
2137 not_matched:
2138
2139 /*
2140 * If there are no more characters in the
2141 * string, but we still need to find another
2142 * character (*m != NULL), then it will be
2143 * impossible to match it
2144 */
2145 if (!*n)
2146 return false;
2147
2148 if (ma)
2149 {
2150 m = ma;
2151 n = ++na;
2152 count = acount;
2153 }
2154 else
2155 return false;
2156 }
2157 }
2158 }
2159 }
2160
2161 #ifdef __VISUALC__
2162 #pragma warning(default:4706) // assignment within conditional expression
2163 #endif // VC++
wxWidgets (Impactor)