1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/filefn.cpp
3 // Purpose: File- and directory-related functions
4 // Author: Julian Smart
7 // Copyright: (c) 1998 Julian Smart
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 // ============================================================================
13 // ============================================================================
15 // ----------------------------------------------------------------------------
17 // ----------------------------------------------------------------------------
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
26 #include "wx/filefn.h"
35 #include "wx/dynarray.h"
37 #include "wx/filename.h"
40 #include "wx/tokenzr.h"
42 // there are just too many of those...
44 #pragma warning(disable:4706) // assignment within conditional expression
51 #if !wxONLY_WATCOM_EARLIER_THAN(1,4)
52 #if !(defined(_MSC_VER) && (_MSC_VER > 800))
57 #if defined(__WXMAC__)
58 #include "wx/osx/private.h" // includes mac headers
62 #include "wx/msw/private.h"
63 #include "wx/msw/missing.h"
64 #include "wx/msw/mslu.h"
66 // sys/cygwin.h is needed for cygwin_conv_to_full_win32_path()
67 // and for cygwin_conv_path()
69 // note that it must be included after <windows.h>
72 #include <sys/cygwin.h>
73 #include <cygwin/version.h>
75 #endif // __GNUWIN32__
77 // io.h is needed for _get_osfhandle()
78 // Already included by filefn.h for many Windows compilers
79 #if defined __CYGWIN__
88 // TODO: Borland probably has _wgetcwd as well?
93 // ----------------------------------------------------------------------------
95 // ----------------------------------------------------------------------------
98 #define _MAXPATHLEN 1024
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 #if WXWIN_COMPATIBILITY_2_8
106 static wxChar wxFileFunctionsBuffer
[4*_MAXPATHLEN
];
109 #if defined(__VISAGECPP__) && __IBMCPP__ >= 400
111 // VisualAge C++ V4.0 cannot have any external linkage const decs
112 // in headers included by more than one primary source
114 const int wxInvalidOffset
= -1;
117 // ============================================================================
119 // ============================================================================
121 // ----------------------------------------------------------------------------
122 // wrappers around standard POSIX functions
123 // ----------------------------------------------------------------------------
125 #if wxUSE_UNICODE && defined __BORLANDC__ \
126 && __BORLANDC__ >= 0x550 && __BORLANDC__ <= 0x551
128 // BCC 5.5 and 5.5.1 have a bug in _wopen where files are created read only
129 // regardless of the mode parameter. This hack works around the problem by
130 // setting the mode with _wchmod.
132 int wxCRT_OpenW(const wchar_t *pathname
, int flags
, mode_t mode
)
136 // we only want to fix the mode when the file is actually created, so
137 // when creating first try doing it O_EXCL so we can tell if the file
138 // was already there.
139 if ((flags
& O_CREAT
) && !(flags
& O_EXCL
) && (mode
& wxS_IWUSR
) != 0)
142 int fd
= _wopen(pathname
, flags
| moreflags
, mode
);
144 // the file was actually created and needs fixing
145 if (fd
!= -1 && (flags
& O_CREAT
) != 0 && (mode
& wxS_IWUSR
) != 0)
148 _wchmod(pathname
, mode
);
149 fd
= _wopen(pathname
, flags
& ~(O_EXCL
| O_CREAT
));
151 // the open failed, but it may have been because the added O_EXCL stopped
152 // the opening of an existing file, so try again without.
153 else if (fd
== -1 && moreflags
!= 0)
155 fd
= _wopen(pathname
, flags
& ~O_CREAT
);
163 // ----------------------------------------------------------------------------
165 // ----------------------------------------------------------------------------
167 bool wxPathList::Add(const wxString
& path
)
169 // add a path separator to force wxFileName to interpret it always as a directory
170 // (i.e. if we are called with '/home/user' we want to consider it a folder and
171 // not, as wxFileName would consider, a filename).
172 wxFileName
fn(path
+ wxFileName::GetPathSeparator());
174 // add only normalized relative/absolute paths
175 // NB: we won't do wxPATH_NORM_DOTS in order to avoid problems when trying to
176 // normalize paths which starts with ".." (which can be normalized only if
177 // we use also wxPATH_NORM_ABSOLUTE - which we don't want to use).
178 if (!fn
.Normalize(wxPATH_NORM_TILDE
|wxPATH_NORM_LONG
|wxPATH_NORM_ENV_VARS
))
181 wxString toadd
= fn
.GetPath();
182 if (Index(toadd
) == wxNOT_FOUND
)
183 wxArrayString::Add(toadd
); // do not add duplicates
188 void wxPathList::Add(const wxArrayString
&arr
)
190 for (size_t j
=0; j
< arr
.GetCount(); j
++)
194 // Add paths e.g. from the PATH environment variable
195 void wxPathList::AddEnvList (const wxString
& WXUNUSED_IN_WINCE(envVariable
))
197 // No environment variables on WinCE
200 // The space has been removed from the tokenizers, otherwise a
201 // path such as "C:\Program Files" would be split into 2 paths:
202 // "C:\Program" and "Files"; this is true for both Windows and Unix.
204 static const wxChar PATH_TOKS
[] =
205 #if defined(__WINDOWS__) || defined(__OS2__)
206 wxT(";"); // Don't separate with colon in DOS (used for drive)
212 if ( wxGetEnv(envVariable
, &val
) )
214 // split into an array of string the value of the env var
215 wxArrayString arr
= wxStringTokenize(val
, PATH_TOKS
);
216 WX_APPEND_ARRAY(*this, arr
);
218 #endif // !__WXWINCE__
221 // Given a full filename (with path), ensure that that file can
222 // be accessed again USING FILENAME ONLY by adding the path
223 // to the list if not already there.
224 bool wxPathList::EnsureFileAccessible (const wxString
& path
)
226 return Add(wxPathOnly(path
));
229 #if WXWIN_COMPATIBILITY_2_6
230 bool wxPathList::Member (const wxString
& path
) const
232 return Index(path
) != wxNOT_FOUND
;
236 wxString
wxPathList::FindValidPath (const wxString
& file
) const
238 // normalize the given string as it could be a path + a filename
239 // and not only a filename
243 // NB: normalize without making absolute otherwise calling this function with
244 // e.g. "b/c.txt" would result in removing the directory 'b' and the for loop
245 // below would only add to the paths of this list the 'c.txt' part when doing
246 // the existence checks...
247 // NB: we don't use wxPATH_NORM_DOTS here, too (see wxPathList::Add for more info)
248 if (!fn
.Normalize(wxPATH_NORM_TILDE
|wxPATH_NORM_LONG
|wxPATH_NORM_ENV_VARS
))
249 return wxEmptyString
;
251 wxASSERT_MSG(!fn
.IsDir(), wxT("Cannot search for directories; only for files"));
253 strend
= fn
.GetFullName(); // search for the file name and ignore the path part
255 strend
= fn
.GetFullPath();
257 for (size_t i
=0; i
<GetCount(); i
++)
259 wxString strstart
= Item(i
);
260 if (!strstart
.IsEmpty() && strstart
.Last() != wxFileName::GetPathSeparator())
261 strstart
+= wxFileName::GetPathSeparator();
263 if (wxFileExists(strstart
+ strend
))
264 return strstart
+ strend
; // Found!
267 return wxEmptyString
; // Not found
270 wxString
wxPathList::FindAbsoluteValidPath (const wxString
& file
) const
272 wxString f
= FindValidPath(file
);
273 if ( f
.empty() || wxIsAbsolutePath(f
) )
276 wxString buf
= ::wxGetCwd();
278 if ( !wxEndsWithPathSeparator(buf
) )
280 buf
+= wxFILE_SEP_PATH
;
287 // ----------------------------------------------------------------------------
288 // miscellaneous global functions
289 // ----------------------------------------------------------------------------
291 #if WXWIN_COMPATIBILITY_2_8
292 static inline wxChar
* MYcopystring(const wxString
& s
)
294 wxChar
* copy
= new wxChar
[s
.length() + 1];
295 return wxStrcpy(copy
, s
.c_str());
298 template<typename CharType
>
299 static inline CharType
* MYcopystring(const CharType
* s
)
301 CharType
* copy
= new CharType
[wxStrlen(s
) + 1];
302 return wxStrcpy(copy
, s
);
308 wxFileExists (const wxString
& filename
)
310 return wxFileName::FileExists(filename
);
314 wxIsAbsolutePath (const wxString
& filename
)
316 if (!filename
.empty())
318 // Unix like or Windows
319 if (filename
[0] == wxT('/'))
322 if ((filename
[0] == wxT('[') && filename
[1] != wxT('.')))
325 #if defined(__WINDOWS__) || defined(__OS2__)
327 if (filename
[0] == wxT('\\') || (wxIsalpha (filename
[0]) && filename
[1] == wxT(':')))
334 #if WXWIN_COMPATIBILITY_2_8
336 * Strip off any extension (dot something) from end of file,
337 * IF one exists. Inserts zero into buffer.
342 static void wxDoStripExtension(T
*buffer
)
344 int len
= wxStrlen(buffer
);
348 if (buffer
[i
] == wxT('.'))
357 void wxStripExtension(char *buffer
) { wxDoStripExtension(buffer
); }
358 void wxStripExtension(wchar_t *buffer
) { wxDoStripExtension(buffer
); }
360 void wxStripExtension(wxString
& buffer
)
362 buffer
= wxFileName::StripExtension(buffer
);
365 // Destructive removal of /./ and /../ stuff
366 template<typename CharType
>
367 static CharType
*wxDoRealPath (CharType
*path
)
369 static const CharType SEP
= wxFILE_SEP_PATH
;
371 wxUnix2DosFilename(path
);
373 if (path
[0] && path
[1]) {
374 /* MATTHEW: special case "/./x" */
376 if (path
[2] == SEP
&& path
[1] == wxT('.'))
384 if (p
[1] == wxT('.') && p
[2] == wxT('.') && (p
[3] == SEP
|| p
[3] == wxT('\0')))
387 for (q
= p
- 1; q
>= path
&& *q
!= SEP
; q
--)
392 if (q
[0] == SEP
&& (q
[1] != wxT('.') || q
[2] != wxT('.') || q
[3] != SEP
)
393 && (q
- 1 <= path
|| q
[-1] != SEP
))
396 if (path
[0] == wxT('\0'))
401 #if defined(__WINDOWS__) || defined(__OS2__)
402 /* Check that path[2] is NULL! */
403 else if (path
[1] == wxT(':') && !path
[2])
412 else if (p
[1] == wxT('.') && (p
[2] == SEP
|| p
[2] == wxT('\0')))
420 char *wxRealPath(char *path
)
422 return wxDoRealPath(path
);
425 wchar_t *wxRealPath(wchar_t *path
)
427 return wxDoRealPath(path
);
430 wxString
wxRealPath(const wxString
& path
)
432 wxChar
*buf1
=MYcopystring(path
);
433 wxChar
*buf2
=wxRealPath(buf1
);
441 wxChar
*wxCopyAbsolutePath(const wxString
& filename
)
443 if (filename
.empty())
446 if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer
, filename
)))
448 wxString buf
= ::wxGetCwd();
449 wxChar ch
= buf
.Last();
451 if (ch
!= wxT('\\') && ch
!= wxT('/'))
457 buf
<< wxFileFunctionsBuffer
;
458 buf
= wxRealPath( buf
);
459 return MYcopystring( buf
);
461 return MYcopystring( wxFileFunctionsBuffer
);
467 ~user/ => user's home dir
468 If the environment variable a = "foo" and b = "bar" then:
485 /* input name in name, pathname output to buf. */
487 template<typename CharType
>
488 static CharType
*wxDoExpandPath(CharType
*buf
, const wxString
& name
)
490 register CharType
*d
, *s
, *nm
;
491 CharType lnm
[_MAXPATHLEN
];
494 // Some compilers don't like this line.
495 // const CharType trimchars[] = wxT("\n \t");
497 CharType trimchars
[4];
498 trimchars
[0] = wxT('\n');
499 trimchars
[1] = wxT(' ');
500 trimchars
[2] = wxT('\t');
503 static const CharType SEP
= wxFILE_SEP_PATH
;
505 //wxUnix2DosFilename(path);
511 nm
= ::MYcopystring(static_cast<const CharType
*>(name
.c_str())); // Make a scratch copy
512 CharType
*nm_tmp
= nm
;
514 /* Skip leading whitespace and cr */
515 while (wxStrchr(trimchars
, *nm
) != NULL
)
517 /* And strip off trailing whitespace and cr */
518 s
= nm
+ (q
= wxStrlen(nm
)) - 1;
519 while (q
-- && wxStrchr(trimchars
, *s
) != NULL
)
527 q
= nm
[0] == wxT('\\') && nm
[1] == wxT('~');
530 /* Expand inline environment variables */
548 while ((*d
++ = *s
) != 0) {
550 if (*s
== wxT('\\')) {
551 if ((*(d
- 1) = *++s
)!=0) {
559 // No env variables on WinCE
562 if (*s
++ == wxT('$') && (*s
== wxT('{') || *s
== wxT(')')))
564 if (*s
++ == wxT('$'))
567 register CharType
*start
= d
;
568 register int braces
= (*s
== wxT('{') || *s
== wxT('('));
569 register CharType
*value
;
570 while ((*d
++ = *s
) != 0)
571 if (braces
? (*s
== wxT('}') || *s
== wxT(')')) : !(wxIsalnum(*s
) || *s
== wxT('_')) )
576 value
= wxGetenv(braces
? start
+ 1 : start
);
578 for ((d
= start
- 1); (*d
++ = *value
++) != 0;)
592 /* Expand ~ and ~user */
595 if (nm
[0] == wxT('~') && !q
)
598 if (nm
[1] == SEP
|| nm
[1] == 0)
600 homepath
= wxGetUserHome(wxEmptyString
);
601 if (!homepath
.empty()) {
602 s
= (CharType
*)(const CharType
*)homepath
.c_str();
607 { /* ~user/filename */
608 register CharType
*nnm
;
609 for (s
= nm
; *s
&& *s
!= SEP
; s
++)
613 int was_sep
; /* MATTHEW: Was there a separator, or NULL? */
614 was_sep
= (*s
== SEP
);
615 nnm
= *s
? s
+ 1 : s
;
617 homepath
= wxGetUserHome(wxString(nm
+ 1));
618 if (homepath
.empty())
620 if (was_sep
) /* replace only if it was there: */
627 s
= (CharType
*)(const CharType
*)homepath
.c_str();
633 if (s
&& *s
) { /* MATTHEW: s could be NULL if user '~' didn't exist */
635 while (wxT('\0') != (*d
++ = *s
++))
638 if (d
- 1 > buf
&& *(d
- 2) != SEP
)
642 while ((*d
++ = *s
++) != 0)
646 delete[] nm_tmp
; // clean up alloc
647 /* Now clean up the buffer */
648 return wxRealPath(buf
);
651 char *wxExpandPath(char *buf
, const wxString
& name
)
653 return wxDoExpandPath(buf
, name
);
656 wchar_t *wxExpandPath(wchar_t *buf
, const wxString
& name
)
658 return wxDoExpandPath(buf
, name
);
662 /* Contract Paths to be build upon an environment variable
665 example: "/usr/openwin/lib", OPENWINHOME --> ${OPENWINHOME}/lib
667 The call wxExpandPath can convert these back!
670 wxContractPath (const wxString
& filename
,
671 const wxString
& WXUNUSED_IN_WINCE(envname
),
672 const wxString
& user
)
674 static wxChar dest
[_MAXPATHLEN
];
676 if (filename
.empty())
679 wxStrcpy (dest
, filename
);
681 wxUnix2DosFilename(dest
);
684 // Handle environment
688 if (!envname
.empty() && !(val
= wxGetenv (envname
)).empty() &&
689 (tcp
= wxStrstr (dest
, val
)) != NULL
)
691 wxStrcpy (wxFileFunctionsBuffer
, tcp
+ val
.length());
694 wxStrcpy (tcp
, envname
);
695 wxStrcat (tcp
, wxT("}"));
696 wxStrcat (tcp
, wxFileFunctionsBuffer
);
700 // Handle User's home (ignore root homes!)
701 val
= wxGetUserHome (user
);
705 const size_t len
= val
.length();
709 if (wxStrncmp(dest
, val
, len
) == 0)
711 wxStrcpy(wxFileFunctionsBuffer
, wxT("~"));
713 wxStrcat(wxFileFunctionsBuffer
, user
);
714 wxStrcat(wxFileFunctionsBuffer
, dest
+ len
);
715 wxStrcpy (dest
, wxFileFunctionsBuffer
);
721 #endif // #if WXWIN_COMPATIBILITY_2_8
723 // Return just the filename, not the path (basename)
724 wxChar
*wxFileNameFromPath (wxChar
*path
)
727 wxString n
= wxFileNameFromPath(p
);
729 return path
+ p
.length() - n
.length();
732 wxString
wxFileNameFromPath (const wxString
& path
)
734 return wxFileName(path
).GetFullName();
737 // Return just the directory, or NULL if no directory
739 wxPathOnly (wxChar
*path
)
743 static wxChar buf
[_MAXPATHLEN
];
745 int l
= wxStrlen(path
);
747 if ( i
>= _MAXPATHLEN
)
751 wxStrcpy (buf
, path
);
753 // Search backward for a backward or forward slash
756 // Unix like or Windows
757 if (path
[i
] == wxT('/') || path
[i
] == wxT('\\'))
763 if (path
[i
] == wxT(']'))
772 #if defined(__WINDOWS__) || defined(__OS2__)
773 // Try Drive specifier
774 if (wxIsalpha (buf
[0]) && buf
[1] == wxT(':'))
776 // A:junk --> A:. (since A:.\junk Not A:\junk)
786 // Return just the directory, or NULL if no directory
787 wxString
wxPathOnly (const wxString
& path
)
791 wxChar buf
[_MAXPATHLEN
];
793 int l
= path
.length();
796 if ( i
>= _MAXPATHLEN
)
802 // Search backward for a backward or forward slash
805 // Unix like or Windows
806 if (path
[i
] == wxT('/') || path
[i
] == wxT('\\'))
808 // Don't return an empty string
812 return wxString(buf
);
815 if (path
[i
] == wxT(']'))
818 return wxString(buf
);
824 #if defined(__WINDOWS__) || defined(__OS2__)
825 // Try Drive specifier
826 if (wxIsalpha (buf
[0]) && buf
[1] == wxT(':'))
828 // A:junk --> A:. (since A:.\junk Not A:\junk)
831 return wxString(buf
);
835 return wxEmptyString
;
838 // Utility for converting delimiters in DOS filenames to UNIX style
839 // and back again - or we get nasty problems with delimiters.
840 // Also, convert to lower case, since case is significant in UNIX.
842 #if defined(__WXMAC__) && !defined(__WXOSX_IPHONE__)
844 #define kDefaultPathStyle kCFURLPOSIXPathStyle
846 wxString
wxMacFSRefToPath( const FSRef
*fsRef
, CFStringRef additionalPathComponent
)
849 fullURLRef
= CFURLCreateFromFSRef(NULL
, fsRef
);
850 if ( fullURLRef
== NULL
)
851 return wxEmptyString
;
853 if ( additionalPathComponent
)
855 CFURLRef parentURLRef
= fullURLRef
;
856 fullURLRef
= CFURLCreateCopyAppendingPathComponent(NULL
, parentURLRef
,
857 additionalPathComponent
,false);
858 CFRelease( parentURLRef
) ;
860 wxCFStringRef
cfString( CFURLCopyFileSystemPath(fullURLRef
, kDefaultPathStyle
));
861 CFRelease( fullURLRef
) ;
863 return wxCFStringRef::AsStringWithNormalizationFormC(cfString
);
866 OSStatus
wxMacPathToFSRef( const wxString
&path
, FSRef
*fsRef
)
868 OSStatus err
= noErr
;
869 CFMutableStringRef cfMutableString
= CFStringCreateMutableCopy(NULL
, 0, wxCFStringRef(path
));
870 CFStringNormalize(cfMutableString
,kCFStringNormalizationFormD
);
871 CFURLRef url
= CFURLCreateWithFileSystemPath(kCFAllocatorDefault
, cfMutableString
, kDefaultPathStyle
, false);
872 CFRelease( cfMutableString
);
875 if ( CFURLGetFSRef(url
, fsRef
) == false )
886 wxString
wxMacHFSUniStrToString( ConstHFSUniStr255Param uniname
)
888 wxCFStringRef
cfname( CFStringCreateWithCharacters( kCFAllocatorDefault
,
891 return wxCFStringRef::AsStringWithNormalizationFormC(cfname
);
896 wxString
wxMacFSSpec2MacFilename( const FSSpec
*spec
)
899 if ( FSpMakeFSRef( spec
, &fsRef
) == noErr
)
901 return wxMacFSRefToPath( &fsRef
) ;
903 return wxEmptyString
;
906 void wxMacFilename2FSSpec( const wxString
& path
, FSSpec
*spec
)
908 OSStatus err
= noErr
;
910 wxMacPathToFSRef( path
, &fsRef
);
911 err
= FSGetCatalogInfo(&fsRef
, kFSCatInfoNone
, NULL
, NULL
, spec
, NULL
);
919 #if WXWIN_COMPATIBILITY_2_8
922 static void wxDoDos2UnixFilename(T
*s
)
931 *s
= wxTolower(*s
); // Case INDEPENDENT
937 void wxDos2UnixFilename(char *s
) { wxDoDos2UnixFilename(s
); }
938 void wxDos2UnixFilename(wchar_t *s
) { wxDoDos2UnixFilename(s
); }
942 #if defined(__WINDOWS__) || defined(__OS2__)
943 wxDoUnix2DosFilename(T
*s
)
945 wxDoUnix2DosFilename(T
*WXUNUSED(s
) )
948 // Yes, I really mean this to happen under DOS only! JACS
949 #if defined(__WINDOWS__) || defined(__OS2__)
960 void wxUnix2DosFilename(char *s
) { wxDoUnix2DosFilename(s
); }
961 void wxUnix2DosFilename(wchar_t *s
) { wxDoUnix2DosFilename(s
); }
963 #endif // #if WXWIN_COMPATIBILITY_2_8
965 // Concatenate two files to form third
967 wxConcatFiles (const wxString
& file1
, const wxString
& file2
, const wxString
& file3
)
971 wxFile
in1(file1
), in2(file2
);
972 wxTempFile
out(file3
);
974 if ( !in1
.IsOpened() || !in2
.IsOpened() || !out
.IsOpened() )
978 unsigned char buf
[1024];
980 for( int i
=0; i
<2; i
++)
982 wxFile
*in
= i
==0 ? &in1
: &in2
;
984 if ( (ofs
= in
->Read(buf
,WXSIZEOF(buf
))) == wxInvalidOffset
) return false;
986 if ( !out
.Write(buf
,ofs
) )
988 } while ( ofs
== (ssize_t
)WXSIZEOF(buf
) );
1003 // helper of generic implementation of wxCopyFile()
1004 #if !(defined(__WIN32__) || defined(__OS2__)) && wxUSE_FILE
1007 wxDoCopyFile(wxFile
& fileIn
,
1008 const wxStructStat
& fbuf
,
1009 const wxString
& filenameDst
,
1012 // reset the umask as we want to create the file with exactly the same
1013 // permissions as the original one
1016 // create file2 with the same permissions than file1 and open it for
1020 if ( !fileOut
.Create(filenameDst
, overwrite
, fbuf
.st_mode
& 0777) )
1023 // copy contents of file1 to file2
1027 ssize_t count
= fileIn
.Read(buf
, WXSIZEOF(buf
));
1028 if ( count
== wxInvalidOffset
)
1035 if ( fileOut
.Write(buf
, count
) < (size_t)count
)
1039 // we can expect fileIn to be closed successfully, but we should ensure
1040 // that fileOut was closed as some write errors (disk full) might not be
1041 // detected before doing this
1042 return fileIn
.Close() && fileOut
.Close();
1045 #endif // generic implementation of wxCopyFile
1049 wxCopyFile (const wxString
& file1
, const wxString
& file2
, bool overwrite
)
1051 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
1052 // CopyFile() copies file attributes and modification time too, so use it
1053 // instead of our code if available
1055 // NB: 3rd parameter is bFailIfExists i.e. the inverse of overwrite
1056 if ( !::CopyFile(file1
.t_str(), file2
.t_str(), !overwrite
) )
1058 wxLogSysError(_("Failed to copy the file '%s' to '%s'"),
1059 file1
.c_str(), file2
.c_str());
1063 #elif defined(__OS2__)
1064 if ( ::DosCopy(file1
.c_str(), file2
.c_str(), overwrite
? DCPY_EXISTING
: 0) != 0 )
1066 #elif wxUSE_FILE // !Win32
1069 // get permissions of file1
1070 if ( wxStat( file1
, &fbuf
) != 0 )
1072 // the file probably doesn't exist or we haven't the rights to read
1074 wxLogSysError(_("Impossible to get permissions for file '%s'"),
1079 // open file1 for reading
1080 wxFile
fileIn(file1
, wxFile::read
);
1081 if ( !fileIn
.IsOpened() )
1084 // remove file2, if it exists. This is needed for creating
1085 // file2 with the correct permissions in the next step
1086 if ( wxFileExists(file2
) && (!overwrite
|| !wxRemoveFile(file2
)))
1088 wxLogSysError(_("Impossible to overwrite the file '%s'"),
1093 wxDoCopyFile(fileIn
, fbuf
, file2
, overwrite
);
1095 #if defined(__WXMAC__) || defined(__WXCOCOA__)
1096 // copy the resource fork of the file too if it's present
1097 wxString pathRsrcOut
;
1101 // suppress error messages from this block as resource forks don't have
1105 // it's not enough to check for file existence: it always does on HFS
1106 // but is empty for files without resources
1107 if ( fileRsrcIn
.Open(file1
+ wxT("/..namedfork/rsrc")) &&
1108 fileRsrcIn
.Length() > 0 )
1110 // we must be using HFS or another filesystem with resource fork
1111 // support, suppose that destination file system also is HFS[-like]
1112 pathRsrcOut
= file2
+ wxT("/..namedfork/rsrc");
1114 else // check if we have resource fork in separate file (non-HFS case)
1116 wxFileName
fnRsrc(file1
);
1117 fnRsrc
.SetName(wxT("._") + fnRsrc
.GetName());
1120 if ( fileRsrcIn
.Open( fnRsrc
.GetFullPath() ) )
1123 fnRsrc
.SetName(wxT("._") + fnRsrc
.GetName());
1125 pathRsrcOut
= fnRsrc
.GetFullPath();
1130 if ( !pathRsrcOut
.empty() )
1132 if ( !wxDoCopyFile(fileRsrcIn
, fbuf
, pathRsrcOut
, overwrite
) )
1135 #endif // wxMac || wxCocoa
1137 #if !defined(__VISAGECPP__) && !defined(__WXMAC__) || defined(__UNIX__)
1138 // no chmod in VA. Should be some permission API for HPFS386 partitions
1140 if ( chmod(file2
.fn_str(), fbuf
.st_mode
) != 0 )
1142 wxLogSysError(_("Impossible to set permissions for the file '%s'"),
1146 #endif // OS/2 || Mac
1148 #else // !Win32 && ! wxUSE_FILE
1150 // impossible to simulate with wxWidgets API
1153 wxUnusedVar(overwrite
);
1156 #endif // __WINDOWS__ && __WIN32__
1162 wxRenameFile(const wxString
& file1
, const wxString
& file2
, bool overwrite
)
1164 if ( !overwrite
&& wxFileExists(file2
) )
1168 _("Failed to rename the file '%s' to '%s' because the destination file already exists."),
1169 file1
.c_str(), file2
.c_str()
1175 #if !defined(__WXWINCE__)
1176 // Normal system call
1177 if ( wxRename (file1
, file2
) == 0 )
1182 if (wxCopyFile(file1
, file2
, overwrite
)) {
1183 wxRemoveFile(file1
);
1187 wxLogSysError(_("File '%s' couldn't be renamed '%s'"), file1
, file2
);
1191 bool wxRemoveFile(const wxString
& file
)
1193 #if defined(__VISUALC__) \
1194 || defined(__BORLANDC__) \
1195 || defined(__WATCOMC__) \
1196 || defined(__DMC__) \
1197 || defined(__GNUWIN32__)
1198 int res
= wxRemove(file
);
1199 #elif defined(__WXMAC__)
1200 int res
= unlink(file
.fn_str());
1202 int res
= unlink(file
.fn_str());
1206 wxLogSysError(_("File '%s' couldn't be removed"), file
);
1211 bool wxMkdir(const wxString
& dir
, int perm
)
1213 #if defined(__WXMAC__) && !defined(__UNIX__)
1214 if ( mkdir(dir
.fn_str(), 0) != 0 )
1216 // assume mkdir() has 2 args on non Windows-OS/2 platforms and on Windows too
1217 // for the GNU compiler
1218 #elif (!(defined(__WINDOWS__) || defined(__OS2__) || defined(__DOS__))) || \
1219 (defined(__GNUWIN32__) && !defined(__MINGW32__)) || \
1220 defined(__WINE__) || defined(__WXMICROWIN__)
1221 const wxChar
*dirname
= dir
.c_str();
1224 if ( mkdir(wxFNCONV(dirname
)) != 0 )
1226 if ( mkdir(wxFNCONV(dirname
), perm
) != 0 )
1228 #elif defined(__OS2__)
1230 if (::DosCreateDir(dir
.c_str(), NULL
) != 0) // enhance for EAB's??
1231 #elif defined(__DOS__)
1232 const wxChar
*dirname
= dir
.c_str();
1233 #if defined(__WATCOMC__)
1235 if ( wxMkDir(wxFNSTRINGCAST
wxFNCONV(dirname
)) != 0 )
1236 #elif defined(__DJGPP__)
1237 if ( mkdir(wxFNCONV(dirname
), perm
) != 0 )
1239 #error "Unsupported DOS compiler!"
1241 #else // !MSW, !DOS and !OS/2 VAC++
1244 if ( CreateDirectory(dir
.fn_str(), NULL
) == 0 )
1246 if ( wxMkDir(dir
.fn_str()) != 0 )
1250 wxLogSysError(_("Directory '%s' couldn't be created"), dir
);
1257 bool wxRmdir(const wxString
& dir
, int WXUNUSED(flags
))
1259 #if defined(__VMS__)
1260 return false; //to be changed since rmdir exists in VMS7.x
1262 #if defined(__OS2__)
1263 if ( ::DosDeleteDir(dir
.c_str()) != 0 )
1264 #elif defined(__WXWINCE__)
1265 if ( RemoveDirectory(dir
.fn_str()) == 0 )
1267 if ( wxRmDir(dir
.fn_str()) != 0 )
1270 wxLogSysError(_("Directory '%s' couldn't be deleted"), dir
);
1278 // does the path exists? (may have or not '/' or '\\' at the end)
1279 bool wxDirExists(const wxString
& pathName
)
1281 return wxFileName::DirExists(pathName
);
1284 #if WXWIN_COMPATIBILITY_2_8
1286 // Get a temporary filename, opening and closing the file.
1287 wxChar
*wxGetTempFileName(const wxString
& prefix
, wxChar
*buf
)
1290 if ( !wxGetTempFileName(prefix
, filename
) )
1294 wxStrcpy(buf
, filename
);
1296 buf
= MYcopystring(filename
);
1301 bool wxGetTempFileName(const wxString
& prefix
, wxString
& buf
)
1304 buf
= wxFileName::CreateTempFileName(prefix
);
1306 return !buf
.empty();
1307 #else // !wxUSE_FILE
1308 wxUnusedVar(prefix
);
1312 #endif // wxUSE_FILE/!wxUSE_FILE
1315 #endif // #if WXWIN_COMPATIBILITY_2_8
1317 // Get first file name matching given wild card.
1319 static wxDir
*gs_dir
= NULL
;
1320 static wxString gs_dirPath
;
1322 wxString
wxFindFirstFile(const wxString
& spec
, int flags
)
1324 wxFileName::SplitPath(spec
, &gs_dirPath
, NULL
, NULL
);
1325 if ( gs_dirPath
.empty() )
1326 gs_dirPath
= wxT(".");
1327 if ( !wxEndsWithPathSeparator(gs_dirPath
) )
1328 gs_dirPath
<< wxFILE_SEP_PATH
;
1330 delete gs_dir
; // can be NULL, this is ok
1331 gs_dir
= new wxDir(gs_dirPath
);
1333 if ( !gs_dir
->IsOpened() )
1335 wxLogSysError(_("Cannot enumerate files '%s'"), spec
);
1336 return wxEmptyString
;
1342 case wxDIR
: dirFlags
= wxDIR_DIRS
; break;
1343 case wxFILE
: dirFlags
= wxDIR_FILES
; break;
1344 default: dirFlags
= wxDIR_DIRS
| wxDIR_FILES
; break;
1348 gs_dir
->GetFirst(&result
, wxFileNameFromPath(spec
), dirFlags
);
1349 if ( result
.empty() )
1355 return gs_dirPath
+ result
;
1358 wxString
wxFindNextFile()
1360 wxCHECK_MSG( gs_dir
, "", "You must call wxFindFirstFile before!" );
1363 if ( !gs_dir
->GetNext(&result
) || result
.empty() )
1369 return gs_dirPath
+ result
;
1373 // Get current working directory.
1374 // If buf is NULL, allocates space using new, else copies into buf.
1375 // wxGetWorkingDirectory() is obsolete, use wxGetCwd()
1376 // wxDoGetCwd() is their common core to be moved
1377 // to wxGetCwd() once wxGetWorkingDirectory() will be removed.
1378 // Do not expose wxDoGetCwd in headers!
1380 wxChar
*wxDoGetCwd(wxChar
*buf
, int sz
)
1382 #if defined(__WXWINCE__)
1384 if(buf
&& sz
>0) buf
[0] = wxT('\0');
1389 buf
= new wxChar
[sz
+ 1];
1394 // for the compilers which have Unicode version of _getcwd(), call it
1395 // directly, for the others call the ANSI version and do the translation
1398 #else // wxUSE_UNICODE
1399 bool needsANSI
= true;
1401 #if !defined(HAVE_WGETCWD) || wxUSE_UNICODE_MSLU
1402 char cbuf
[_MAXPATHLEN
];
1406 #if wxUSE_UNICODE_MSLU
1407 if ( wxGetOsVersion() != wxOS_WINDOWS_9X
)
1409 char *cbuf
= NULL
; // never really used because needsANSI will always be false
1412 ok
= _wgetcwd(buf
, sz
) != NULL
;
1418 #endif // wxUSE_UNICODE
1420 #if defined(_MSC_VER) || defined(__MINGW32__)
1421 ok
= _getcwd(cbuf
, sz
) != NULL
;
1422 #elif defined(__OS2__)
1424 ULONG ulDriveNum
= 0;
1425 ULONG ulDriveMap
= 0;
1426 rc
= ::DosQueryCurrentDisk(&ulDriveNum
, &ulDriveMap
);
1431 rc
= ::DosQueryCurrentDir( 0 // current drive
1435 cbuf
[0] = char('A' + (ulDriveNum
- 1));
1440 #else // !Win32/VC++ !Mac !OS2
1441 ok
= getcwd(cbuf
, sz
) != NULL
;
1445 // finally convert the result to Unicode if needed
1446 wxConvFile
.MB2WC(buf
, cbuf
, sz
);
1447 #endif // wxUSE_UNICODE
1452 wxLogSysError(_("Failed to get the working directory"));
1454 // VZ: the old code used to return "." on error which didn't make any
1455 // sense at all to me - empty string is a better error indicator
1456 // (NULL might be even better but I'm afraid this could lead to
1457 // problems with the old code assuming the return is never NULL)
1460 else // ok, but we might need to massage the path into the right format
1463 // VS: DJGPP is a strange mix of DOS and UNIX API and returns paths
1464 // with / deliminers. We don't like that.
1465 for (wxChar
*ch
= buf
; *ch
; ch
++)
1467 if (*ch
== wxT('/'))
1472 // MBN: we hope that in the case the user is compiling a GTK+/Motif app,
1473 // he needs Unix as opposed to Win32 pathnames
1474 #if defined( __CYGWIN__ ) && defined( __WINDOWS__ )
1475 // another example of DOS/Unix mix (Cygwin)
1476 wxString pathUnix
= buf
;
1478 #if CYGWIN_VERSION_DLL_MAJOR >= 1007
1479 cygwin_conv_path(CCP_POSIX_TO_WIN_W
, pathUnix
.mb_str(wxConvFile
), buf
, sz
);
1481 char bufA
[_MAXPATHLEN
];
1482 cygwin_conv_to_full_win32_path(pathUnix
.mb_str(wxConvFile
), bufA
);
1483 wxConvFile
.MB2WC(buf
, bufA
, sz
);
1486 #if CYGWIN_VERSION_DLL_MAJOR >= 1007
1487 cygwin_conv_path(CCP_POSIX_TO_WIN_A
, pathUnix
, buf
, sz
);
1489 cygwin_conv_to_full_win32_path(pathUnix
, buf
);
1491 #endif // wxUSE_UNICODE
1492 #endif // __CYGWIN__
1505 #if WXWIN_COMPATIBILITY_2_6
1506 wxChar
*wxGetWorkingDirectory(wxChar
*buf
, int sz
)
1508 return wxDoGetCwd(buf
,sz
);
1510 #endif // WXWIN_COMPATIBILITY_2_6
1515 wxDoGetCwd(wxStringBuffer(str
, _MAXPATHLEN
), _MAXPATHLEN
);
1519 bool wxSetWorkingDirectory(const wxString
& d
)
1521 bool success
= false;
1522 #if defined(__OS2__)
1525 ::DosSetDefaultDisk(wxToupper(d
[0]) - wxT('A') + 1);
1526 // do not call DosSetCurrentDir when just changing drive,
1527 // since it requires e.g. "d:." instead of "d:"!
1528 if (d
.length() == 2)
1531 success
= (::DosSetCurrentDir(d
.c_str()) == 0);
1532 #elif defined(__UNIX__) || defined(__WXMAC__) || defined(__DOS__)
1533 success
= (chdir(wxFNSTRINGCAST d
.fn_str()) == 0);
1534 #elif defined(__WINDOWS__)
1538 // No equivalent in WinCE
1541 success
= (SetCurrentDirectory(d
.t_str()) != 0);
1544 // Must change drive, too.
1545 bool isDriveSpec
= ((strlen(d
) > 1) && (d
[1] == ':'));
1548 wxChar firstChar
= d
[0];
1552 firstChar
= firstChar
- 32;
1554 // To a drive number
1555 unsigned int driveNo
= firstChar
- 64;
1558 unsigned int noDrives
;
1559 _dos_setdrive(driveNo
, &noDrives
);
1562 success
= (chdir(WXSTRINGCAST d
) == 0);
1568 wxLogSysError(_("Could not set current working directory"));
1573 // Get the OS directory if appropriate (such as the Windows directory).
1574 // On non-Windows platform, probably just return the empty string.
1575 wxString
wxGetOSDirectory()
1578 return wxString(wxT("\\Windows"));
1579 #elif defined(__WINDOWS__) && !defined(__WXMICROWIN__)
1580 wxChar buf
[MAX_PATH
];
1581 if ( !GetWindowsDirectory(buf
, MAX_PATH
) )
1583 wxLogLastError(wxS("GetWindowsDirectory"));
1586 return wxString(buf
);
1587 #elif defined(__WXMAC__) && wxOSX_USE_CARBON
1588 return wxMacFindFolderNoSeparator(kOnSystemDisk
, 'macs', false);
1590 return wxEmptyString
;
1594 bool wxEndsWithPathSeparator(const wxString
& filename
)
1596 return !filename
.empty() && wxIsPathSeparator(filename
.Last());
1599 // find a file in a list of directories, returns false if not found
1600 bool wxFindFileInPath(wxString
*pStr
, const wxString
& szPath
, const wxString
& szFile
)
1602 // we assume that it's not empty
1603 wxCHECK_MSG( !szFile
.empty(), false,
1604 wxT("empty file name in wxFindFileInPath"));
1606 // skip path separator in the beginning of the file name if present
1608 if ( wxIsPathSeparator(szFile
[0u]) )
1609 szFile2
= szFile
.Mid(1);
1613 wxStringTokenizer
tkn(szPath
, wxPATH_SEP
);
1615 while ( tkn
.HasMoreTokens() )
1617 wxString strFile
= tkn
.GetNextToken();
1618 if ( !wxEndsWithPathSeparator(strFile
) )
1619 strFile
+= wxFILE_SEP_PATH
;
1622 if ( wxFileExists(strFile
) )
1632 #if WXWIN_COMPATIBILITY_2_8
1633 void WXDLLIMPEXP_BASE
wxSplitPath(const wxString
& fileName
,
1638 wxFileName::SplitPath(fileName
, pstrPath
, pstrName
, pstrExt
);
1640 #endif // #if WXWIN_COMPATIBILITY_2_8
1644 time_t WXDLLIMPEXP_BASE
wxFileModificationTime(const wxString
& filename
)
1647 if ( !wxFileName(filename
).GetTimes(NULL
, &mtime
, NULL
) )
1650 return mtime
.GetTicks();
1653 #endif // wxUSE_DATETIME
1656 // Parses the filterStr, returning the number of filters.
1657 // Returns 0 if none or if there's a problem.
1658 // filterStr is in the form: "All files (*.*)|*.*|JPEG Files (*.jpeg)|*.jpeg"
1660 int WXDLLIMPEXP_BASE
wxParseCommonDialogsFilter(const wxString
& filterStr
,
1661 wxArrayString
& descriptions
,
1662 wxArrayString
& filters
)
1664 descriptions
.Clear();
1667 wxString
str(filterStr
);
1669 wxString description
, filter
;
1671 while( pos
!= wxNOT_FOUND
)
1673 pos
= str
.Find(wxT('|'));
1674 if ( pos
== wxNOT_FOUND
)
1676 // if there are no '|'s at all in the string just take the entire
1677 // string as filter and make description empty for later autocompletion
1678 if ( filters
.IsEmpty() )
1680 descriptions
.Add(wxEmptyString
);
1681 filters
.Add(filterStr
);
1685 wxFAIL_MSG( wxT("missing '|' in the wildcard string!") );
1691 description
= str
.Left(pos
);
1692 str
= str
.Mid(pos
+ 1);
1693 pos
= str
.Find(wxT('|'));
1694 if ( pos
== wxNOT_FOUND
)
1700 filter
= str
.Left(pos
);
1701 str
= str
.Mid(pos
+ 1);
1704 descriptions
.Add(description
);
1705 filters
.Add(filter
);
1708 #if defined(__WXMOTIF__)
1709 // split it so there is one wildcard per entry
1710 for( size_t i
= 0 ; i
< descriptions
.GetCount() ; i
++ )
1712 pos
= filters
[i
].Find(wxT(';'));
1713 if (pos
!= wxNOT_FOUND
)
1715 // first split only filters
1716 descriptions
.Insert(descriptions
[i
],i
+1);
1717 filters
.Insert(filters
[i
].Mid(pos
+1),i
+1);
1718 filters
[i
]=filters
[i
].Left(pos
);
1720 // autoreplace new filter in description with pattern:
1721 // C/C++ Files(*.cpp;*.c;*.h)|*.cpp;*.c;*.h
1722 // cause split into:
1723 // C/C++ Files(*.cpp)|*.cpp
1724 // C/C++ Files(*.c;*.h)|*.c;*.h
1725 // and next iteration cause another split into:
1726 // C/C++ Files(*.cpp)|*.cpp
1727 // C/C++ Files(*.c)|*.c
1728 // C/C++ Files(*.h)|*.h
1729 for ( size_t k
=i
;k
<i
+2;k
++ )
1731 pos
= descriptions
[k
].Find(filters
[k
]);
1732 if (pos
!= wxNOT_FOUND
)
1734 wxString before
= descriptions
[k
].Left(pos
);
1735 wxString after
= descriptions
[k
].Mid(pos
+filters
[k
].Len());
1736 pos
= before
.Find(wxT('('),true);
1737 if (pos
>before
.Find(wxT(')'),true))
1739 before
= before
.Left(pos
+1);
1740 before
<< filters
[k
];
1741 pos
= after
.Find(wxT(')'));
1742 int pos1
= after
.Find(wxT('('));
1743 if (pos
!= wxNOT_FOUND
&& (pos
<pos1
|| pos1
==wxNOT_FOUND
))
1745 before
<< after
.Mid(pos
);
1746 descriptions
[k
] = before
;
1756 for( size_t j
= 0 ; j
< descriptions
.GetCount() ; j
++ )
1758 if ( descriptions
[j
].empty() && !filters
[j
].empty() )
1760 descriptions
[j
].Printf(_("Files (%s)"), filters
[j
].c_str());
1764 return filters
.GetCount();
1767 #if defined(__WINDOWS__) && !(defined(__UNIX__) || defined(__OS2__))
1768 static bool wxCheckWin32Permission(const wxString
& path
, DWORD access
)
1770 // quoting the MSDN: "To obtain a handle to a directory, call the
1771 // CreateFile function with the FILE_FLAG_BACKUP_SEMANTICS flag", but this
1772 // doesn't work under Win9x/ME but then it's not needed there anyhow
1773 const DWORD dwAttr
= ::GetFileAttributes(path
.t_str());
1774 if ( dwAttr
== INVALID_FILE_ATTRIBUTES
)
1776 // file probably doesn't exist at all
1780 if ( wxGetOsVersion() == wxOS_WINDOWS_9X
)
1782 // FAT directories always allow all access, even if they have the
1783 // readonly flag set, and FAT files can only be read-only
1784 return (dwAttr
& FILE_ATTRIBUTE_DIRECTORY
) ||
1785 (access
!= GENERIC_WRITE
||
1786 !(dwAttr
& FILE_ATTRIBUTE_READONLY
));
1789 HANDLE h
= ::CreateFile
1793 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
1796 dwAttr
& FILE_ATTRIBUTE_DIRECTORY
1797 ? FILE_FLAG_BACKUP_SEMANTICS
1801 if ( h
!= INVALID_HANDLE_VALUE
)
1804 return h
!= INVALID_HANDLE_VALUE
;
1806 #endif // __WINDOWS__
1808 bool wxIsWritable(const wxString
&path
)
1810 #if defined( __UNIX__ ) || defined(__OS2__)
1811 // access() will take in count also symbolic links
1812 return wxAccess(path
.c_str(), W_OK
) == 0;
1813 #elif defined( __WINDOWS__ )
1814 return wxCheckWin32Permission(path
, GENERIC_WRITE
);
1822 bool wxIsReadable(const wxString
&path
)
1824 #if defined( __UNIX__ ) || defined(__OS2__)
1825 // access() will take in count also symbolic links
1826 return wxAccess(path
.c_str(), R_OK
) == 0;
1827 #elif defined( __WINDOWS__ )
1828 return wxCheckWin32Permission(path
, GENERIC_READ
);
1836 bool wxIsExecutable(const wxString
&path
)
1838 #if defined( __UNIX__ ) || defined(__OS2__)
1839 // access() will take in count also symbolic links
1840 return wxAccess(path
.c_str(), X_OK
) == 0;
1841 #elif defined( __WINDOWS__ )
1842 return wxCheckWin32Permission(path
, GENERIC_EXECUTE
);
1850 // Return the type of an open file
1852 // Some file types on some platforms seem seekable but in fact are not.
1853 // The main use of this function is to allow such cases to be detected
1854 // (IsSeekable() is implemented as wxGetFileKind() == wxFILE_KIND_DISK).
1856 // This is important for the archive streams, which benefit greatly from
1857 // being able to seek on a stream, but which will produce corrupt archives
1858 // if they unknowingly seek on a non-seekable stream.
1860 // wxFILE_KIND_DISK is a good catch all return value, since other values
1861 // disable features of the archive streams. Some other value must be returned
1862 // for a file type that appears seekable but isn't.
1865 // * Pipes on Windows
1866 // * Files on VMS with a record format other than StreamLF
1868 wxFileKind
wxGetFileKind(int fd
)
1870 #if defined __WINDOWS__ && !defined __WXWINCE__ && defined wxGetOSFHandle
1871 switch (::GetFileType(wxGetOSFHandle(fd
)) & ~FILE_TYPE_REMOTE
)
1873 case FILE_TYPE_CHAR
:
1874 return wxFILE_KIND_TERMINAL
;
1875 case FILE_TYPE_DISK
:
1876 return wxFILE_KIND_DISK
;
1877 case FILE_TYPE_PIPE
:
1878 return wxFILE_KIND_PIPE
;
1881 return wxFILE_KIND_UNKNOWN
;
1883 #elif defined(__UNIX__)
1885 return wxFILE_KIND_TERMINAL
;
1890 if (S_ISFIFO(st
.st_mode
))
1891 return wxFILE_KIND_PIPE
;
1892 if (!S_ISREG(st
.st_mode
))
1893 return wxFILE_KIND_UNKNOWN
;
1895 #if defined(__VMS__)
1896 if (st
.st_fab_rfm
!= FAB$C_STMLF
)
1897 return wxFILE_KIND_UNKNOWN
;
1900 return wxFILE_KIND_DISK
;
1903 #define wxFILEKIND_STUB
1905 return wxFILE_KIND_DISK
;
1909 wxFileKind
wxGetFileKind(FILE *fp
)
1911 // Note: The watcom rtl dll doesn't have fileno (the static lib does).
1912 // Should be fixed in version 1.4.
1913 #if defined(wxFILEKIND_STUB) || wxONLY_WATCOM_EARLIER_THAN(1,4)
1915 return wxFILE_KIND_DISK
;
1916 #elif defined(__WINDOWS__) && !defined(__CYGWIN__) && !defined(__WATCOMC__) && !defined(__WINE__)
1917 return fp
? wxGetFileKind(_fileno(fp
)) : wxFILE_KIND_UNKNOWN
;
1919 return fp
? wxGetFileKind(fileno(fp
)) : wxFILE_KIND_UNKNOWN
;
1924 //------------------------------------------------------------------------
1925 // wild character routines
1926 //------------------------------------------------------------------------
1928 bool wxIsWild( const wxString
& pattern
)
1930 for ( wxString::const_iterator p
= pattern
.begin(); p
!= pattern
.end(); ++p
)
1932 switch ( (*p
).GetValue() )
1941 if ( ++p
== pattern
.end() )
1949 * Written By Douglas A. Lewis <dalewis@cs.Buffalo.EDU>
1951 * The match procedure is public domain code (from ircII's reg.c)
1952 * but modified to suit our tastes (RN: No "%" syntax I guess)
1955 bool wxMatchWild( const wxString
& pat
, const wxString
& text
, bool dot_special
)
1959 /* Match if both are empty. */
1963 const wxChar
*m
= pat
.c_str(),
1971 if (dot_special
&& (*n
== wxT('.')))
1973 /* Never match so that hidden Unix files
1974 * are never found. */
1987 else if (*m
== wxT('?'))
1995 if (*m
== wxT('\\'))
1998 /* Quoting "nothing" is a bad thing */
2005 * If we are out of both strings or we just
2006 * saw a wildcard, then we can say we have a
2017 * We could check for *n == NULL at this point, but
2018 * since it's more common to have a character there,
2019 * check to see if they match first (m and n) and
2020 * then if they don't match, THEN we can check for
2036 * If there are no more characters in the
2037 * string, but we still need to find another
2038 * character (*m != NULL), then it will be
2039 * impossible to match it
2058 #pragma warning(default:4706) // assignment within conditional expression