/////////////////////////////////////////////////////////////////////////////
-// Name: filefn.cpp
+// Name: src/common/filefn.cpp
// Purpose: File- and directory-related functions
// Author: Julian Smart
// Modified by:
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
-#include "wx/defs.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
-#include "wx/utils.h"
-#include "wx/intl.h"
-#include "wx/file.h" // This does include filefn.h
+#include "wx/filefn.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/intl.h"
+ #include "wx/log.h"
+ #include "wx/utils.h"
+#endif
+
+#include "wx/file.h"
#include "wx/filename.h"
#include "wx/dir.h"
+#include "wx/tokenzr.h"
+
// there are just too many of those...
#ifdef __VISUALC__
#pragma warning(disable:4706) // assignment within conditional expression
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#if !defined(__WATCOMC__)
+#if !wxONLY_WATCOM_EARLIER_THAN(1,4)
#if !(defined(_MSC_VER) && (_MSC_VER > 800))
#include <errno.h>
#endif
#include "wx/mac/private.h" // includes mac headers
#endif
-#include "wx/log.h"
-
#ifdef __WINDOWS__
#include "wx/msw/private.h"
#include "wx/msw/mslu.h"
// macros
// ----------------------------------------------------------------------------
-// we need to translate Mac filenames before passing them to OS functions
+// translate the filenames before passing them to OS functions
#define OS_FILENAME(s) (s.fn_str())
// ============================================================================
// implementation
// ============================================================================
+// ----------------------------------------------------------------------------
+// wrappers around standard POSIX functions
+// ----------------------------------------------------------------------------
+
#ifdef wxNEED_WX_UNISTD_H
WXDLLEXPORT int wxStat( const wxChar *file_name, wxStructStat *buf )
return stat( wxConvFile.cWX2MB( file_name ), buf );
}
+WXDLLEXPORT int wxLstat( const wxChar *file_name, wxStructStat *buf )
+{
+ return lstat( wxConvFile.cWX2MB( file_name ), buf );
+}
+
WXDLLEXPORT int wxAccess( const wxChar *pathname, int mode )
{
return access( wxConvFile.cWX2MB( pathname ), mode );
return open( wxConvFile.cWX2MB( pathname ), flags, mode );
}
+#endif // wxNEED_WX_UNISTD_H
+
+#if wxUSE_UNICODE && defined __BORLANDC__ \
+ && __BORLANDC__ >= 0x550 && __BORLANDC__ <= 0x551
+
+// BCC 5.5 and 5.5.1 have a bug in _wopen where files are created read only
+// regardless of the mode parameter. This hack works around the problem by
+// setting the mode with _wchmod.
+//
+int wxOpen(const wchar_t *pathname, int flags, mode_t mode)
+{
+ int moreflags = 0;
+
+ // we only want to fix the mode when the file is actually created, so
+ // when creating first try doing it O_EXCL so we can tell if the file
+ // was already there.
+ if ((flags & O_CREAT) && !(flags & O_EXCL) && (mode & wxS_IWUSR) != 0)
+ moreflags = O_EXCL;
+
+ int fd = _wopen(pathname, flags | moreflags, mode);
+
+ // the file was actually created and needs fixing
+ if (fd != -1 && (flags & O_CREAT) != 0 && (mode & wxS_IWUSR) != 0)
+ {
+ close(fd);
+ _wchmod(pathname, mode);
+ fd = _wopen(pathname, flags & ~(O_EXCL | O_CREAT));
+ }
+ // the open failed, but it may have been because the added O_EXCL stopped
+ // the opening of an existing file, so try again without.
+ else if (fd == -1 && moreflags != 0)
+ {
+ fd = _wopen(pathname, flags & ~O_CREAT);
+ }
+
+ return fd;
+}
+
#endif
- // wxNEED_WX_UNISTD_H
// ----------------------------------------------------------------------------
// wxPathList
// ----------------------------------------------------------------------------
-// IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
-
-static inline wxChar* MYcopystring(const wxString& s)
+bool wxPathList::Add(const wxString& path)
{
- wxChar* copy = new wxChar[s.length() + 1];
- return wxStrcpy(copy, s.c_str());
-}
+ // add a path separator to force wxFileName to interpret it always as a directory
+ // (i.e. if we are called with '/home/user' we want to consider it a folder and
+ // not, as wxFileName would consider, a filename).
+ wxFileName fn(path + wxFileName::GetPathSeparator());
+
+ // add only normalized relative/absolute paths
+ // NB: we won't do wxPATH_NORM_DOTS in order to avoid problems when trying to
+ // normalize paths which starts with ".." (which can be normalized only if
+ // we use also wxPATH_NORM_ABSOLUTE - which we don't want to use).
+ if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
+ return false;
-static inline wxChar* MYcopystring(const wxChar* s)
-{
- wxChar* copy = new wxChar[wxStrlen(s) + 1];
- return wxStrcpy(copy, s);
+ wxString toadd = fn.GetPath();
+ if (Index(toadd) == wxNOT_FOUND)
+ wxArrayString::Add(toadd); // do not add duplicates
+
+ return true;
}
-void wxPathList::Add (const wxString& path)
+void wxPathList::Add(const wxArrayString &arr)
{
- wxStringList::Add (WXSTRINGCAST path);
+ for (size_t j=0; j < arr.GetCount(); j++)
+ Add(arr[j]);
}
// Add paths e.g. from the PATH environment variable
{
// No environment variables on WinCE
#ifndef __WXWINCE__
+
+ // The space has been removed from the tokenizers, otherwise a
+ // path such as "C:\Program Files" would be split into 2 paths:
+ // "C:\Program" and "Files"; this is true for both Windows and Unix.
+
static const wxChar PATH_TOKS[] =
#if defined(__WINDOWS__) || defined(__OS2__)
- /*
- The space has been removed from the tokenizers, otherwise a
- path such as "C:\Program Files" would be split into 2 paths:
- "C:\Program" and "Files"
- */
-// wxT(" ;"); // Don't separate with colon in DOS (used for drive)
wxT(";"); // Don't separate with colon in DOS (used for drive)
#else
- wxT(" :;");
+ wxT(":;");
#endif
- wxString val ;
- if (wxGetEnv (WXSTRINGCAST envVariable, &val))
+ wxString val;
+ if ( wxGetEnv(envVariable, &val) )
{
- wxChar *s = MYcopystring (val);
- wxChar *save_ptr, *token = wxStrtok (s, PATH_TOKS, &save_ptr);
-
- if (token)
- {
- Add(token);
- while (token)
- {
- if ( (token = wxStrtok ((wxChar *) NULL, PATH_TOKS, &save_ptr))
- != NULL )
- {
- Add(token);
- }
- }
- }
-
- // suppress warning about unused variable save_ptr when wxStrtok() is a
- // macro which throws away its third argument
- save_ptr = token;
-
- delete [] s;
+ // split into an array of string the value of the env var
+ wxArrayString arr = wxStringTokenize(val, PATH_TOKS);
+ WX_APPEND_ARRAY(*this, arr);
}
#endif // !__WXWINCE__
}
// Given a full filename (with path), ensure that that file can
// be accessed again USING FILENAME ONLY by adding the path
// to the list if not already there.
-void wxPathList::EnsureFileAccessible (const wxString& path)
+bool wxPathList::EnsureFileAccessible (const wxString& path)
{
- wxString path_only(wxPathOnly(path));
- if ( !path_only.empty() )
- {
- if ( !Member(path_only) )
- Add(path_only);
- }
+ return Add(wxPathOnly(path));
}
-bool wxPathList::Member (const wxString& path)
+#if WXWIN_COMPATIBILITY_2_6
+bool wxPathList::Member (const wxString& path) const
{
- for (wxStringList::compatibility_iterator node = GetFirst(); node; node = node->GetNext())
- {
- wxString path2( node->GetData() );
- if (
-#if defined(__WINDOWS__) || defined(__OS2__) || defined(__VMS__) || defined(__WXMAC__)
- // Case INDEPENDENT
- path.CompareTo (path2, wxString::ignoreCase) == 0
-#else
- // Case sensitive File System
- path.CompareTo (path2) == 0
-#endif
- )
- return true;
- }
- return false;
+ return Index(path) != wxNOT_FOUND;
}
+#endif
-wxString wxPathList::FindValidPath (const wxString& file)
+wxString wxPathList::FindValidPath (const wxString& file) const
{
- if (wxFileExists (wxExpandPath(wxFileFunctionsBuffer, file)))
- return wxString(wxFileFunctionsBuffer);
-
- wxChar buf[_MAXPATHLEN];
- wxStrcpy(buf, wxFileFunctionsBuffer);
+ // normalize the given string as it could be a path + a filename
+ // and not only a filename
+ wxFileName fn(file);
+ wxString strend;
+
+ // NB: normalize without making absolute otherwise calling this function with
+ // e.g. "b/c.txt" would result in removing the directory 'b' and the for loop
+ // below would only add to the paths of this list the 'c.txt' part when doing
+ // the existence checks...
+ // NB: we don't use wxPATH_NORM_DOTS here, too (see wxPathList::Add for more info)
+ if (!fn.Normalize(wxPATH_NORM_TILDE|wxPATH_NORM_LONG|wxPATH_NORM_ENV_VARS))
+ return wxEmptyString;
- wxChar *filename = wxIsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (wxChar *)buf;
+ wxASSERT_MSG(!fn.IsDir(), wxT("Cannot search for directories; only for files"));
+ if (fn.IsAbsolute())
+ strend = fn.GetFullName(); // search for the file name and ignore the path part
+ else
+ strend = fn.GetFullPath();
- for (wxStringList::compatibility_iterator node = GetFirst(); node; node = node->GetNext())
+ for (size_t i=0; i<GetCount(); i++)
{
- const wxChar *path = node->GetData();
- wxStrcpy (wxFileFunctionsBuffer, path);
- wxChar ch = wxFileFunctionsBuffer[wxStrlen(wxFileFunctionsBuffer)-1];
- if (ch != wxT('\\') && ch != wxT('/'))
- wxStrcat (wxFileFunctionsBuffer, wxT("/"));
- wxStrcat (wxFileFunctionsBuffer, filename);
-#ifdef __WINDOWS__
- wxUnix2DosFilename (wxFileFunctionsBuffer);
-#endif
- if (wxFileExists (wxFileFunctionsBuffer))
- {
- return wxString(wxFileFunctionsBuffer); // Found!
- }
- } // for()
+ wxString strstart = Item(i);
+ if (!strstart.IsEmpty() && strstart.Last() != wxFileName::GetPathSeparator())
+ strstart += wxFileName::GetPathSeparator();
+
+ if (wxFileExists(strstart + strend))
+ return strstart + strend; // Found!
+ }
- return wxEmptyString; // Not found
+ return wxEmptyString; // Not found
}
-wxString wxPathList::FindAbsoluteValidPath (const wxString& file)
+wxString wxPathList::FindAbsoluteValidPath (const wxString& file) const
{
wxString f = FindValidPath(file);
if ( f.empty() || wxIsAbsolutePath(f) )
return f;
- wxString buf;
- wxGetWorkingDirectory(wxStringBuffer(buf, _MAXPATHLEN), _MAXPATHLEN);
+ wxString buf = ::wxGetCwd();
if ( !wxEndsWithPathSeparator(buf) )
{
return buf;
}
+// ----------------------------------------------------------------------------
+// miscellaneous global functions (TOFIX!)
+// ----------------------------------------------------------------------------
+
+static inline wxChar* MYcopystring(const wxString& s)
+{
+ wxChar* copy = new wxChar[s.length() + 1];
+ return wxStrcpy(copy, s.c_str());
+}
+
+static inline wxChar* MYcopystring(const wxChar* s)
+{
+ wxChar* copy = new wxChar[wxStrlen(s) + 1];
+ return wxStrcpy(copy, s);
+}
+
+
bool
wxFileExists (const wxString& filename)
{
return (ret != (DWORD)-1) && !(ret & FILE_ATTRIBUTE_DIRECTORY);
#else // !__WIN32__
+ #ifndef S_ISREG
+ #define S_ISREG(mode) ((mode) & S_IFREG)
+ #endif
wxStructStat st;
#ifndef wxNEED_WX_UNISTD_H
- return wxStat( filename.fn_str() , &st) == 0 && (st.st_mode & S_IFREG);
+ return (wxStat( filename.fn_str() , &st) == 0 && S_ISREG(st.st_mode))
+#ifdef __OS2__
+ || (errno == EACCES) // if access is denied something with that name
+ // exists and is opened in exclusive mode.
+#endif
+ ;
#else
- return wxStat( filename , &st) == 0 && (st.st_mode & S_IFREG);
+ return wxStat( filename , &st) == 0 && S_ISREG(st.st_mode);
#endif
#endif // __WIN32__/!__WIN32__
}
void wxStripExtension(wxString& buffer)
{
//RN: Be careful about the handling the case where
- //buffer.Length() == 0
- for(size_t i = buffer.Length() - 1; i != wxString::npos; --i)
+ //buffer.length() == 0
+ for(size_t i = buffer.length() - 1; i != wxString::npos; --i)
{
if (buffer.GetChar(i) == wxT('.'))
{
return path;
}
+wxString wxRealPath(const wxString& path)
+{
+ wxChar *buf1=MYcopystring(path);
+ wxChar *buf2=wxRealPath(buf1);
+ wxString buf(buf2);
+ delete [] buf1;
+ return buf;
+}
+
+
// Must be destroyed
wxChar *wxCopyAbsolutePath(const wxString& filename)
{
- if (filename.empty())
- return (wxChar *) NULL;
+ if (filename.empty())
+ return (wxChar *) NULL;
- if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename))) {
- wxChar buf[_MAXPATHLEN];
- buf[0] = wxT('\0');
- wxGetWorkingDirectory(buf, WXSIZEOF(buf));
- wxChar ch = buf[wxStrlen(buf) - 1];
+ if (! wxIsAbsolutePath(wxExpandPath(wxFileFunctionsBuffer, filename)))
+ {
+ wxString buf = ::wxGetCwd();
+ wxChar ch = buf.Last();
#ifdef __WXMSW__
- if (ch != wxT('\\') && ch != wxT('/'))
- wxStrcat(buf, wxT("\\"));
+ if (ch != wxT('\\') && ch != wxT('/'))
+ buf << wxT("\\");
#else
- if (ch != wxT('/'))
- wxStrcat(buf, wxT("/"));
+ if (ch != wxT('/'))
+ buf << wxT("/");
#endif
- wxStrcat(buf, wxFileFunctionsBuffer);
- return MYcopystring( wxRealPath(buf) );
- }
- return MYcopystring( wxFileFunctionsBuffer );
+ buf << wxFileFunctionsBuffer;
+ buf = wxRealPath( buf );
+ return MYcopystring( buf );
+ }
+ return MYcopystring( wxFileFunctionsBuffer );
}
/*-
// Local copy
wxStrcpy (buf, WXSTRINGCAST path);
- int l = path.Length();
+ int l = path.length();
int i = l - 1;
// Search backward for a backward or forward slash
}
CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, kDefaultPathStyle);
CFRelease( fullURLRef ) ;
- return wxMacCFStringHolder(cfString).AsString(wxLocale::GetSystemEncoding());
+ CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString);
+ CFRelease( cfString );
+ CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
+ return wxMacCFStringHolder(cfMutableString).AsString();
}
OSStatus wxMacPathToFSRef( const wxString&path , FSRef *fsRef )
{
OSStatus err = noErr ;
- CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, wxMacCFStringHolder(path ,wxLocale::GetSystemEncoding() ) , kDefaultPathStyle, false);
+ CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, wxMacCFStringHolder(path));
+ CFStringNormalize(cfMutableString,kCFStringNormalizationFormD);
+ CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault, cfMutableString , kDefaultPathStyle, false);
+ CFRelease( cfMutableString );
if ( NULL != url )
{
if ( CFURLGetFSRef(url, fsRef) == false )
CFStringRef cfname = CFStringCreateWithCharacters( kCFAllocatorDefault,
uniname->unicode,
uniname->length );
- return wxMacCFStringHolder(cfname).AsString() ;
+ CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfname);
+ CFRelease( cfname );
+ CFStringNormalize(cfMutableString,kCFStringNormalizationFormC);
+ return wxMacCFStringHolder(cfMutableString).AsString() ;
}
+#ifndef __LP64__
+
wxString wxMacFSSpec2MacFilename( const FSSpec *spec )
{
FSRef fsRef ;
wxMacPathToFSRef( path , &fsRef ) ;
err = FSRefMakeFSSpec( &fsRef , spec ) ;
}
+#endif
#endif // __WXMAC__
}
bool
-wxRenameFile (const wxString& file1, const wxString& file2)
+wxRenameFile(const wxString& file1, const wxString& file2, bool overwrite)
{
+ if ( !overwrite && wxFileExists(file2) )
+ {
+ wxLogSysError
+ (
+ _("Failed to rename the file '%s' to '%s' because the destination file already exists."),
+ file1.c_str(), file2.c_str()
+ );
+
+ return false;
+ }
+
#if !defined(__WXWINCE__) && !defined(__WXPALMOS__)
// Normal system call
if ( wxRename (file1, file2) == 0 )
#endif
// Try to copy
- if (wxCopyFile(file1, file2)) {
+ if (wxCopyFile(file1, file2, overwrite)) {
wxRemoveFile(file1);
return true;
}
#elif defined(__OS2__)
return (::DosDeleteDir((PSZ)dir.c_str()) == 0);
#elif defined(__WXWINCE__)
- return (CreateDirectory(dir, NULL) != 0);
+ return (RemoveDirectory(dir) != 0);
#elif defined(__WXPALMOS__)
// TODO with VFSFileRename()
return false;
#if defined(__WINDOWS__) || defined(__OS2__)
// Windows fails to find directory named "c:\dir\" even if "c:\dir" exists,
// so remove all trailing backslashes from the path - but don't do this for
- // the pathes "d:\" (which are different from "d:") nor for just "\"
+ // the paths "d:\" (which are different from "d:") nor for just "\"
while ( wxEndsWithPathSeparator(strPath) )
{
size_t len = strPath.length();
return (ret != (DWORD)-1) && (ret & FILE_ATTRIBUTE_DIRECTORY);
#elif defined(__OS2__)
- return (bool)(::DosSetCurrentDir((PSZ)(WXSTRINGCAST strPath)));
+ FILESTATUS3 Info = {{0}};
+ APIRET rc = ::DosQueryPathInfo((PSZ)(WXSTRINGCAST strPath), FIL_STANDARD,
+ (void*) &Info, sizeof(FILESTATUS3));
+
+ return ((rc == NO_ERROR) && (Info.attrFile & FILE_DIRECTORY)) ||
+ (rc == ERROR_SHARING_VIOLATION);
+ // If we got a sharing violation, there must be something with this name.
#else // !__WIN32__
wxStructStat st;
// Get a temporary filename, opening and closing the file.
wxChar *wxGetTempFileName(const wxString& prefix, wxChar *buf)
{
-#if wxUSE_FILE
- wxString filename = wxFileName::CreateTempFileName(prefix);
- if ( filename.empty() )
+ wxString filename;
+ if ( !wxGetTempFileName(prefix, filename) )
return NULL;
if ( buf )
buf = MYcopystring(filename);
return buf;
-#else
- wxUnusedVar(prefix);
- wxUnusedVar(buf);
- // wxFileName::CreateTempFileName needs wxFile class enabled
- return NULL;
-#endif
}
bool wxGetTempFileName(const wxString& prefix, wxString& buf)
{
- buf = wxGetTempFileName(prefix);
+#if wxUSE_FILE
+ buf = wxFileName::CreateTempFileName(prefix);
return !buf.empty();
+#else // !wxUSE_FILE
+ wxUnusedVar(prefix);
+ wxUnusedVar(buf);
+
+ return false;
+#endif // wxUSE_FILE/!wxUSE_FILE
}
// Get first file name matching given wild card.
// Get current working directory.
-// If buf is NULL, allocates space using new, else
-// copies into buf.
-wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
+// If buf is NULL, allocates space using new, else copies into buf.
+// wxGetWorkingDirectory() is obsolete, use wxGetCwd()
+// wxDoGetCwd() is their common core to be moved
+// to wxGetCwd() once wxGetWorkingDirectory() will be removed.
+// Do not expose wxDoGetCwd in headers!
+
+wxChar *wxDoGetCwd(wxChar *buf, int sz)
{
#if defined(__WXPALMOS__)
- // TODO ?
- return NULL;
+ // TODO
+ if(buf && sz>0) buf[0] = _T('\0');
+ return buf;
#elif defined(__WXWINCE__)
// TODO
- wxUnusedVar(buf);
- wxUnusedVar(sz);
- return NULL;
+ if(buf && sz>0) buf[0] = _T('\0');
+ return buf;
#else
if ( !buf )
{
#ifdef HAVE_WGETCWD
#if wxUSE_UNICODE_MSLU
- if ( wxGetOsVersion() != wxWIN95 )
+ if ( wxGetOsVersion() != wxOS_WINDOWS_9X )
#else
char *cbuf = NULL; // never really used because needsANSI will always be false
#endif
// __WXWINCE__
}
-wxString wxGetCwd()
+#if WXWIN_COMPATIBILITY_2_6
+wxChar *wxGetWorkingDirectory(wxChar *buf, int sz)
{
- wxChar *buffer = new wxChar[_MAXPATHLEN];
- wxGetWorkingDirectory(buffer, _MAXPATHLEN);
- wxString str( buffer );
- delete [] buffer;
+ return wxDoGetCwd(buf,sz);
+}
+#endif // WXWIN_COMPATIBILITY_2_6
+wxString wxGetCwd()
+{
+ wxString str;
+ wxDoGetCwd(wxStringBuffer(str, _MAXPATHLEN), _MAXPATHLEN);
return str;
}
wxFileName::SplitPath(pszFileName, pstrPath, pstrName, pstrExt);
}
+#if wxUSE_DATETIME
+
time_t WXDLLEXPORT wxFileModificationTime(const wxString& filename)
{
-#if defined(__WXPALMOS__)
- return 0;
-#elif defined(__WXWINCE__)
- FILETIME ftLastWrite;
- AutoHANDLE hFile(::CreateFile(filename, GENERIC_READ, FILE_SHARE_READ,
- NULL, 0, FILE_ATTRIBUTE_NORMAL, 0));
+ wxDateTime mtime;
+ if ( !wxFileName(filename).GetTimes(NULL, &mtime, NULL) )
+ return (time_t)-1;
- if ( !hFile.IsOk() )
- return 0;
-
- if ( !::GetFileTime(hFile, NULL, NULL, &ftLastWrite) )
- return 0;
-
- // sure we want to translate to local time here?
- FILETIME ftLocal;
- if ( !::FileTimeToLocalFileTime(&ftLastWrite, &ftLocal) )
- {
- wxLogLastError(_T("FileTimeToLocalFileTime"));
- }
-
- // FILETIME is a counted in 100-ns since 1601-01-01, convert it to
- // number of seconds since 1970-01-01
- ULARGE_INTEGER uli;
- uli.LowPart = ftLocal.dwLowDateTime;
- uli.HighPart = ftLocal.dwHighDateTime;
-
- ULONGLONG ull = uli.QuadPart;
- ull /= wxULL(10000000); // number of 100ns intervals in 1s
- ull -= wxULL(11644473600); // 1970-01-01 - 1601-01-01 in seconds
-
- return wx_static_cast(time_t, ull);
-#else
- wxStructStat buf;
- if ( wxStat( filename, &buf) != 0 )
- return 0;
-
- return buf.st_mtime;
-#endif
+ return mtime.GetTicks();
}
+#endif // wxUSE_DATETIME
+
// Parses the filterStr, returning the number of filters.
// Returns 0 if none or if there's a problem.
return filters.GetCount();
}
+#if defined(__WINDOWS__) && !(defined(__UNIX__) || defined(__OS2__))
+static bool wxCheckWin32Permission(const wxString& path, DWORD access)
+{
+ // quoting the MSDN: "To obtain a handle to a directory, call the
+ // CreateFile function with the FILE_FLAG_BACKUP_SEMANTICS flag", but this
+ // doesn't work under Win9x/ME but then it's not needed there anyhow
+ bool isdir = wxDirExists(path);
+ if ( isdir && wxGetOsVersion() == wxOS_WINDOWS_9X )
+ {
+ // FAT directories always allow all access, even if they have the
+ // readonly flag set
+ return true;
+ }
+
+ HANDLE h = ::CreateFile
+ (
+ path.c_str(),
+ access,
+ FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+ NULL,
+ OPEN_EXISTING,
+ isdir ? FILE_FLAG_BACKUP_SEMANTICS : 0,
+ NULL
+ );
+ if ( h != INVALID_HANDLE_VALUE )
+ CloseHandle(h);
+
+ return h != INVALID_HANDLE_VALUE;
+}
+#endif // __WINDOWS__
+
+bool wxIsWritable(const wxString &path)
+{
+#if defined( __UNIX__ ) || defined(__OS2__)
+ // access() will take in count also symbolic links
+ return access(wxConvFile.cWX2MB(path), W_OK) == 0;
+#elif defined( __WINDOWS__ )
+ return wxCheckWin32Permission(path, GENERIC_WRITE);
+#else
+ wxUnusedVar(path);
+ // TODO
+ return false;
+#endif
+}
+
+bool wxIsReadable(const wxString &path)
+{
+#if defined( __UNIX__ ) || defined(__OS2__)
+ // access() will take in count also symbolic links
+ return access(wxConvFile.cWX2MB(path), R_OK) == 0;
+#elif defined( __WINDOWS__ )
+ return wxCheckWin32Permission(path, GENERIC_READ);
+#else
+ wxUnusedVar(path);
+ // TODO
+ return false;
+#endif
+}
+
+bool wxIsExecutable(const wxString &path)
+{
+#if defined( __UNIX__ ) || defined(__OS2__)
+ // access() will take in count also symbolic links
+ return access(wxConvFile.cWX2MB(path), X_OK) == 0;
+#elif defined( __WINDOWS__ )
+ return wxCheckWin32Permission(path, GENERIC_EXECUTE);
+#else
+ wxUnusedVar(path);
+ // TODO
+ return false;
+#endif
+}
+
+// Return the type of an open file
+//
+// Some file types on some platforms seem seekable but in fact are not.
+// The main use of this function is to allow such cases to be detected
+// (IsSeekable() is implemented as wxGetFileKind() == wxFILE_KIND_DISK).
+//
+// This is important for the archive streams, which benefit greatly from
+// being able to seek on a stream, but which will produce corrupt archives
+// if they unknowingly seek on a non-seekable stream.
+//
+// wxFILE_KIND_DISK is a good catch all return value, since other values
+// disable features of the archive streams. Some other value must be returned
+// for a file type that appears seekable but isn't.
+//
+// Known examples:
+// * Pipes on Windows
+// * Files on VMS with a record format other than StreamLF
+//
+wxFileKind wxGetFileKind(int fd)
+{
+#if defined __WXMSW__ && !defined __WXWINCE__ && defined wxGetOSFHandle
+ switch (::GetFileType(wxGetOSFHandle(fd)) & ~FILE_TYPE_REMOTE)
+ {
+ case FILE_TYPE_CHAR:
+ return wxFILE_KIND_TERMINAL;
+ case FILE_TYPE_DISK:
+ return wxFILE_KIND_DISK;
+ case FILE_TYPE_PIPE:
+ return wxFILE_KIND_PIPE;
+ }
+
+ return wxFILE_KIND_UNKNOWN;
+
+#elif defined(__UNIX__)
+ if (isatty(fd))
+ return wxFILE_KIND_TERMINAL;
+
+ struct stat st;
+ fstat(fd, &st);
+
+ if (S_ISFIFO(st.st_mode))
+ return wxFILE_KIND_PIPE;
+ if (!S_ISREG(st.st_mode))
+ return wxFILE_KIND_UNKNOWN;
+
+ #if defined(__VMS__)
+ if (st.st_fab_rfm != FAB$C_STMLF)
+ return wxFILE_KIND_UNKNOWN;
+ #endif
+
+ return wxFILE_KIND_DISK;
+
+#else
+ #define wxFILEKIND_STUB
+ (void)fd;
+ return wxFILE_KIND_DISK;
+#endif
+}
+
+wxFileKind wxGetFileKind(FILE *fp)
+{
+ // Note: The watcom rtl dll doesn't have fileno (the static lib does).
+ // Should be fixed in version 1.4.
+#if defined(wxFILEKIND_STUB) || wxONLY_WATCOM_EARLIER_THAN(1,4)
+ (void)fp;
+ return wxFILE_KIND_DISK;
+#elif defined(__WINDOWS__) && !defined(__CYGWIN__) && !defined(__WATCOMC__) && !defined(__WINE__)
+ return fp ? wxGetFileKind(_fileno(fp)) : wxFILE_KIND_UNKNOWN;
+#else
+ return fp ? wxGetFileKind(fileno(fp)) : wxFILE_KIND_UNKNOWN;
+#endif
+}
+
//------------------------------------------------------------------------
// wild character routines
* Written By Douglas A. Lewis <dalewis@cs.Buffalo.EDU>
*
* The match procedure is public domain code (from ircII's reg.c)
+* but modified to suit our tastes (RN: No "%" syntax I guess)
*/
bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
const wxChar *m = pat.c_str(),
*n = text.c_str(),
*ma = NULL,
- *na = NULL,
- *mp = NULL,
- *np = NULL;
+ *na = NULL;
int just = 0,
- pcount = 0,
acount = 0,
count = 0;
ma = ++m;
na = n;
just = 1;
- mp = NULL;
acount = count;
}
else if (*m == wxT('?'))
if (*m == *n)
{
m++;
- if (*n == wxT(' '))
- mp = NULL;
count++;
n++;
}
*/
if (!*n)
return false;
- if (mp)
- {
- m = mp;
- if (*np == wxT(' '))
- {
- mp = NULL;
- goto check_percent;
- }
- n = ++np;
- count = pcount;
- }
- else
- check_percent:
if (ma)
{
}
}
-// Return the type of an open file
-//
-// Some file types on some platforms seem seekable but in fact are not.
-// The main use of this function is to allow such cases to be detected
-// (IsSeekable() is implemented as wxGetFileKind() == wxFILE_KIND_DISK).
-//
-// This is important for the archive streams, which benefit greatly from
-// being able to seek on a stream, but which will produce corrupt archives
-// if they unknowingly seek on a non-seekable stream.
-//
-// wxFILE_KIND_DISK is a good catch all return value, since other values
-// disable features of the archive streams. Some other value must be returned
-// for a file type that appears seekable but isn't.
-//
-// Known examples:
-// * Pipes on Windows
-// * Files on VMS with a record format other than StreamLF
-//
-wxFileKind wxGetFileKind(int fd)
-{
-#if defined __WXMSW__ && !defined __WXWINCE__ && defined wxGetOSFHandle
- switch (::GetFileType(wxGetOSFHandle(fd)) & ~FILE_TYPE_REMOTE)
- {
- case FILE_TYPE_CHAR:
- return wxFILE_KIND_TERMINAL;
- case FILE_TYPE_DISK:
- return wxFILE_KIND_DISK;
- case FILE_TYPE_PIPE:
- return wxFILE_KIND_PIPE;
- }
-
- return wxFILE_KIND_UNKNOWN;
-
-#elif defined(__UNIX__)
- if (isatty(fd))
- return wxFILE_KIND_TERMINAL;
-
- struct stat st;
- fstat(fd, &st);
-
- if (S_ISFIFO(st.st_mode))
- return wxFILE_KIND_PIPE;
- if (!S_ISREG(st.st_mode))
- return wxFILE_KIND_UNKNOWN;
-
- #if defined(__VMS__)
- if (st.st_fab_rfm != FAB$C_STMLF)
- return wxFILE_KIND_UNKNOWN;
- #endif
-
- return wxFILE_KIND_DISK;
-
-#else
- #define wxFILEKIND_STUB
- (void)fd;
- return wxFILE_KIND_DISK;
-#endif
-}
-
-wxFileKind wxGetFileKind(FILE *fp)
-{
- // Note: The watcom rtl dll doesn't have fileno (the static lib does).
- // Should be fixed in version 1.4.
-#if defined(wxFILEKIND_STUB) || \
- (defined(__WATCOMC__) && __WATCOMC__ <= 1230 && defined(__SW_BR))
- (void)fp;
- return wxFILE_KIND_DISK;
-#else
- return fp ? wxGetFileKind(fileno(fp)) : wxFILE_KIND_UNKNOWN;
-#endif
-}
-
#ifdef __VISUALC__
#pragma warning(default:4706) // assignment within conditional expression
#endif // VC++
projects / wxWidgets.git / blobdiff