#include "wx/utils.h"
#include <wx/intl.h>
+// there are just too many of those...
+#ifdef _MSC_VER
+ #pragma warning(disable:4706) // assignment within conditional expression
+#endif // VC++
+
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#endif
#endif
#include <time.h>
+#ifndef __MWERKS__
#include <sys/types.h>
#include <sys/stat.h>
+#else
+#include <stat.h>
+#include <unistd.h>
+#endif
#ifdef __UNIX__
#include <unistd.h>
#endif
#ifdef __WINDOWS__
-#ifndef __GNUWIN32__
+#if !defined( __GNUWIN32__ ) && !defined( __MWERKS__ ) && !defined(__SALFORDC__)
#include <direct.h>
#include <dos.h>
#endif
#endif
#ifdef __GNUWIN32__
+#ifndef __TWIN32__
#include <sys/unistd.h>
-// #include <sys/stat.h>
-
-#ifndef __MINGW32__
-#include <std.h>
#endif
#define stricmp strcasecmp
#include <dir.h>
#endif
+#ifdef __SALFORDC__
+#include <dir.h>
+#include <unix.h>
+#endif
+
+#include "wx/setup.h"
+#include "wx/log.h"
+
+// No, Cygwin doesn't appear to have fnmatch.h after all.
+#if defined(HAVE_FNMATCH_H)
+#include "fnmatch.h"
+#endif
+
#ifdef __WINDOWS__
#include "windows.h"
#endif
#define _MAXPATHLEN 500
-#if !USE_SHARED_LIBRARY
-IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
+extern char *wxBuffer;
+#ifdef __WXMAC__
+extern char gwxMacFileName[] ;
+extern char gwxMacFileName2[] ;
+extern char gwxMacFileName3[] ;
#endif
-extern char *wxBuffer;
+#if !USE_SHARED_LIBRARIES
+IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
+#endif
void wxPathList::Add (const wxString& path)
{
Add (copystring (token));
while (token)
{
- if ((token = strtok (NULL, PATH_TOKS)) != NULL)
+ if ((token = strtok ((char *) NULL, PATH_TOKS)) != NULL)
Add (wxString(token));
}
}
{
wxString path2((char *) node->Data ());
if (
-#if defined(__WINDOWS__) || defined(__VMS__)
+#if defined(__WINDOWS__) || defined(__VMS__) || defined (__WXMAC__)
// Case INDEPENDENT
path.CompareTo (path2, wxString::ignoreCase) == 0
#else
char buf[_MAXPATHLEN];
strcpy(buf, wxBuffer);
- char *filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (char *)buf;
+ char *filename = (char*) NULL; /* shut up buggy egcs warning */
+ filename = IsAbsolutePath (buf) ? wxFileNameFromPath (buf) : (char *)buf;
for (wxNode * node = First (); node; node = node->Next ())
{
bool
wxFileExists (const wxString& filename)
{
+#ifdef __GNUWIN32__ // (fix a B20 bug)
+ if (GetFileAttributes(filename) == 0xFFFFFFFF)
+ return FALSE;
+ else
+ return TRUE;
+#elif defined(__WXMAC__)
+ struct stat stbuf;
+ strcpy( gwxMacFileName , filename ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ if (gwxMacFileName && stat ((char *)(const char *)gwxMacFileName, &stbuf) == 0)
+ return TRUE;
+ return FALSE ;
+#else
+
+#ifdef __SALFORDC__
+ struct _stat stbuf;
+#else
struct stat stbuf;
+#endif
- if (filename && stat ((char *)(const char *)filename, &stbuf) == 0)
+ if ((filename != "") && stat ((char *)(const char *)filename, &stbuf) == 0)
return TRUE;
return FALSE;
+#endif
}
/* Vadim's alternative implementation
char *wxCopyAbsolutePath(const wxString& filename)
{
if (filename == "")
- return NULL;
+ return (char *) NULL;
if (! IsAbsolutePath(wxExpandPath(wxBuffer, filename))) {
char buf[_MAXPATHLEN];
#endif
{
register char *start = d;
- register braces = (*s == '{' || *s == '(');
+ register int braces = (*s == '{' || *s == '(');
register char *value;
while ((*d++ = *s))
if (braces ? (*s == '}' || *s == ')') : !(isalnum(*s) || *s == '_') )
static char dest[_MAXPATHLEN];
if (filename == "")
- return NULL;
+ return (char *) NULL;
strcpy (dest, WXSTRINGCAST filename);
#ifdef __WXMSW__
#endif
// Handle environment
- char *val = NULL;
- char *tcp = NULL;
- if (envname != NULL && (val = getenv (WXSTRINGCAST envname)) != NULL &&
+ char *val = (char *) NULL;
+ char *tcp = (char *) NULL;
+ if (envname != WXSTRINGCAST NULL && (val = getenv (WXSTRINGCAST envname)) != NULL &&
(tcp = strstr (dest, val)) != NULL)
{
strcpy (wxBuffer, tcp + strlen (val));
strncmp(dest, val, len) == 0)
{
strcpy(wxBuffer, "~");
- if (user && *user)
- strcat(wxBuffer, user);
+ if (user != "")
+ strcat(wxBuffer, (const char*) user);
#ifdef __WXMSW__
// strcat(wxBuffer, "\\");
#else
return wxString(path + 2);
#endif
}
- return wxString("");
+ // Yes, this should return the path, not an empty string, otherwise
+ // we get "thing.txt" -> "".
+ return path1;
}
// Return just the directory, or NULL if no directory
#endif
}
- return NULL;
+ return (char *) NULL;
}
// Return just the directory, or NULL if no directory
// and back again - or we get nasty problems with delimiters.
// Also, convert to lower case, since case is significant in UNIX.
+#ifdef __WXMAC__
+void
+wxMac2UnixFilename (char *s)
+{
+ if (s)
+ {
+ memmove( s+1 , s ,strlen( s ) + 1) ;
+ if ( *s == ':' )
+ *s = '.' ;
+ else
+ *s = '/' ;
+
+ while (*s)
+ {
+ if (*s == ':')
+ *s = '/';
+ else
+ *s = wxToLower (*s); // Case INDEPENDENT
+ s++;
+ }
+ }
+}
+
+void
+wxUnix2MacFilename (char *s)
+{
+ if (s)
+ {
+ if ( *s == '.' )
+ {
+ // relative path , since it goes on with slash which is translated to a :
+ memmove( s , s+1 ,strlen( s ) ) ;
+ }
+ else if ( *s == '/' )
+ {
+ // absolute path -> on mac just start with the drive name
+ memmove( s , s+1 ,strlen( s ) ) ;
+ }
+ else
+ {
+ wxASSERT_MSG( 1 , "unkown path beginning" ) ;
+ }
+ while (*s)
+ {
+ if (*s == '/' || *s == '\\')
+ *s = ':';
+
+ s++ ;
+ }
+ }
+}
+#endif
void
wxDos2UnixFilename (char *s)
{
{
char *outfile = wxGetTempFileName("cat");
- FILE *fp1 = NULL;
- FILE *fp2 = NULL;
- FILE *fp3 = NULL;
+ FILE *fp1 = (FILE *) NULL;
+ FILE *fp2 = (FILE *) NULL;
+ FILE *fp3 = (FILE *) NULL;
// Open the inputs and outputs
+#ifdef __WXMAC__
+ strcpy( gwxMacFileName , file1 ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ strcpy( gwxMacFileName2 , file2) ;
+ wxUnix2MacFilename( gwxMacFileName2 ) ;
+ strcpy( gwxMacFileName3 , outfile) ;
+ wxUnix2MacFilename( gwxMacFileName3 ) ;
+
+ if ((fp1 = fopen (gwxMacFileName, "rb")) == NULL ||
+ (fp2 = fopen (gwxMacFileName2, "rb")) == NULL ||
+ (fp3 = fopen (gwxMacFileName3, "wb")) == NULL)
+#else
if ((fp1 = fopen (WXSTRINGCAST file1, "rb")) == NULL ||
(fp2 = fopen (WXSTRINGCAST file2, "rb")) == NULL ||
(fp3 = fopen (outfile, "wb")) == NULL)
+#endif
{
if (fp1)
fclose (fp1);
FILE *fd2;
int ch;
+#ifdef __WXMAC__
+ strcpy( gwxMacFileName , file1 ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ strcpy( gwxMacFileName2 , file2) ;
+ wxUnix2MacFilename( gwxMacFileName2 ) ;
+
+ if ((fd1 = fopen (gwxMacFileName, "rb")) == NULL)
+ return FALSE;
+ if ((fd2 = fopen (gwxMacFileName2, "wb")) == NULL)
+#else
if ((fd1 = fopen (WXSTRINGCAST file1, "rb")) == NULL)
return FALSE;
if ((fd2 = fopen (WXSTRINGCAST file2, "wb")) == NULL)
+#endif
{
fclose (fd1);
return FALSE;
bool
wxRenameFile (const wxString& file1, const wxString& file2)
{
+#ifdef __WXMAC__
+ strcpy( gwxMacFileName , file1 ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ strcpy( gwxMacFileName2 , file2) ;
+ wxUnix2MacFilename( gwxMacFileName2 ) ;
+
+ if (0 == rename (gwxMacFileName, gwxMacFileName2))
+ return TRUE;
+#else
// Normal system call
if (0 == rename (WXSTRINGCAST file1, WXSTRINGCAST file2))
return TRUE;
+#endif
// Try to copy
if (wxCopyFile(file1, file2)) {
wxRemoveFile(file1);
bool wxRemoveFile(const wxString& file)
{
-#if defined(_MSC_VER) || defined(__BORLANDC__)
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__)
int flag = remove(WXSTRINGCAST file);
+#elif defined( __WXMAC__ )
+ strcpy( gwxMacFileName , file ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ int flag = unlink(gwxMacFileName);
#else
int flag = unlink(WXSTRINGCAST file);
#endif
bool wxMkdir(const wxString& dir)
{
-#ifdef __VMS__
+#if defined(__WXSTUBS__)
+ return FALSE;
+#elif defined(__VMS__)
return FALSE;
+#elif defined( __WXMAC__ )
+ strcpy( gwxMacFileName , dir ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ return (mkdir(gwxMacFileName , 0 ) == 0);
#elif (defined(__GNUWIN32__) && !defined(__MINGW32__)) || !defined(__WXMSW__)
-#if defined(__WIN32__) // Could happen in __WXSTUBS__ mode
- return (mkdir(WXSTRINGCAST dir) == 0);
-#else
return (mkdir (WXSTRINGCAST dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0);
-#endif
#else
return (mkdir(WXSTRINGCAST dir) == 0);
#endif
{
#ifdef __VMS__
return FALSE;
+#elif defined( __WXMAC__ )
+ strcpy( gwxMacFileName , dir ) ;
+ wxUnix2MacFilename( gwxMacFileName ) ;
+ return (rmdir(WXSTRINGCAST gwxMacFileName) == 0);
+#else
+
+#ifdef __SALFORDC__
+ return FALSE; // What to do?
#else
return (rmdir(WXSTRINGCAST dir) == 0);
#endif
+
+#endif
}
#if 0
if ( wxEndsWithPathSeparator(pszPathName) && pszPathName[1] != '\0' )
strPath.Last() = '\0';
+#ifdef __SALFORDC__
+ struct _stat st;
+#else
struct stat st;
- return stat(strPath, &st) == 0 && (st.st_mode & S_IFDIR);
+#endif
+
+ return stat((char*) (const char*) strPath, &st) == 0 && (st.st_mode & S_IFDIR);
}
// Get a temporary filename, opening and closing the file.
#else
static short last_temp = 0; // cache last to speed things a bit
// At most 1000 temp files to a process! We use a ring count.
- char tmp[100];
+ char tmp[100]; // FIXME static buffer
for (short suffix = last_temp + 1; suffix != last_temp; ++suffix %= 1000)
{
return buf;
}
}
- cerr << _("wxWindows: error finding temporary file name.\n");
+ wxLogError( _("wxWindows: error finding temporary file name.\n") );
if (buf) buf[0] = 0;
- return NULL;
+ return (char *) NULL;
#endif
}
// Flags are reserved for future use.
#ifndef __VMS__
-static DIR *wxDirStream = NULL;
-static char *wxFileSpec = NULL;
+static DIR *wxDirStream = (DIR *) NULL;
+static char *wxFileSpec = (char *) NULL;
static int wxFindFileFlags = 0;
#endif
p = ".";
if ((wxDirStream=opendir(p))==NULL)
- return NULL;
+ return (char *) NULL;
/* MATTHEW: [5] wxFindNextFile can do the rest of the work */
return wxFindNextFile();
#endif
// ifndef __VMS__
- return NULL;
+ return (char *) NULL;
}
char *wxFindNextFile(void)
{
#ifndef __VMS__
- static char buf[400];
+ static char buf[400]; // FIXME static buffer
/* MATTHEW: [2] Don't crash if we read too many times */
if (!wxDirStream)
- return NULL;
+ return (char *) NULL;
// Find path only so we can concatenate
// found file onto path
}
}
closedir(wxDirStream);
- wxDirStream = NULL;
+ wxDirStream = (DIR *) NULL;
#endif
// ifndef __VMS__
- return NULL;
+ return (char *) NULL;
}
#elif defined(__WXMSW__)
{
if (!buf)
buf = new char[sz+1];
-#ifdef _MSC_VER
+#ifdef _MSC_VER
if (_getcwd(buf, sz) == NULL) {
#else
if (getcwd(buf, sz) == NULL) {
bool wxSetWorkingDirectory(const wxString& d)
{
-#ifdef __UNIX__
+#if defined( __UNIX__ ) || defined( __WXMAC__ )
return (chdir(d) == 0);
#elif defined(__WINDOWS__)
wxString strFile;
char *pc;
- for ( pc = strtok(szPath, PATH_SEP); pc; pc = strtok(NULL, PATH_SEP) ) {
+ for ( pc = strtok(szPath, PATH_SEP); pc; pc = strtok((char *) NULL, PATH_SEP) ) {
// search for the file in this directory
strFile = pc;
if ( !wxEndsWithPathSeparator(pc) )
const char *pSepDos = strrchr(pszFileName, FILE_SEP_PATH_DOS);
// take the last of the two
- uint nPosUnix = pSepUnix ? pSepUnix - pszFileName : 0;
- uint nPosDos = pSepDos ? pSepDos - pszFileName : 0;
+ size_t nPosUnix = pSepUnix ? pSepUnix - pszFileName : 0;
+ size_t nPosDos = pSepDos ? pSepDos - pszFileName : 0;
if ( nPosDos > nPosUnix )
nPosUnix = nPosDos;
-// uint nLen = Strlen(pszFileName);
+// size_t nLen = Strlen(pszFileName);
if ( pstrPath )
*pstrPath = wxString(pszFileName, nPosUnix);
if ( pDot ) {
- uint nPosDot = pDot - pszFileName;
+ size_t nPosDot = pDot - pszFileName;
if ( pstrName )
*pstrName = wxString(pszFileName + nPosUnix + 1, nPosDot - nPosUnix);
if ( pstrExt )
pstrExt->Empty();
}
}
+
+//------------------------------------------------------------------------
+// wild character routines
+//------------------------------------------------------------------------
+
+bool wxIsWild( const wxString& pattern )
+{
+ wxString tmp = pattern;
+ char *pat = WXSTRINGCAST(tmp);
+ while (*pat) {
+ switch (*pat++) {
+ case '?': case '*': case '[': case '{':
+ return TRUE;
+ case '\\':
+ if (!*pat++)
+ return FALSE;
+ }
+ }
+ return FALSE;
+};
+
+bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
+
+#if defined(HAVE_FNMATCH_H)
+{
+ if(dot_special)
+ return fnmatch(pat.c_str(), text.c_str(), FNM_PERIOD) == 0;
+ else
+ return fnmatch(pat.c_str(), text.c_str(), 0) == 0;
+}
+#else
+
+// #pragma error Broken implementation of wxMatchWild() -- needs fixing!
+
+ /*
+ * WARNING: this code is broken!
+ */
+{
+ wxString tmp1 = pat;
+ char *pattern = WXSTRINGCAST(tmp1);
+ wxString tmp2 = text;
+ char *str = WXSTRINGCAST(tmp2);
+ char c;
+ char *cp;
+ bool done = FALSE, ret_code, ok;
+ // Below is for vi fans
+ const char OB = '{', CB = '}';
+
+ // dot_special means '.' only matches '.'
+ if (dot_special && *str == '.' && *pattern != *str)
+ return FALSE;
+
+ while ((*pattern != '\0') && (!done)
+ && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
+ switch (*pattern) {
+ case '\\':
+ pattern++;
+ if (*pattern != '\0')
+ pattern++;
+ break;
+ case '*':
+ pattern++;
+ ret_code = FALSE;
+ while ((*str!='\0')
+ && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
+ /*loop*/;
+ if (ret_code) {
+ while (*str != '\0')
+ str++;
+ while (*pattern != '\0')
+ pattern++;
+ }
+ break;
+ case '[':
+ pattern++;
+ repeat:
+ if ((*pattern == '\0') || (*pattern == ']')) {
+ done = TRUE;
+ break;
+ }
+ if (*pattern == '\\') {
+ pattern++;
+ if (*pattern == '\0') {
+ done = TRUE;
+ break;
+ }
+ }
+ if (*(pattern + 1) == '-') {
+ c = *pattern;
+ pattern += 2;
+ if (*pattern == ']') {
+ done = TRUE;
+ break;
+ }
+ if (*pattern == '\\') {
+ pattern++;
+ if (*pattern == '\0') {
+ done = TRUE;
+ break;
+ }
+ }
+ if ((*str < c) || (*str > *pattern)) {
+ pattern++;
+ goto repeat;
+ }
+ } else if (*pattern != *str) {
+ pattern++;
+ goto repeat;
+ }
+ pattern++;
+ while ((*pattern != ']') && (*pattern != '\0')) {
+ if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
+ pattern++;
+ pattern++;
+ }
+ if (*pattern != '\0') {
+ pattern++, str++;
+ }
+ break;
+ case '?':
+ pattern++;
+ str++;
+ break;
+ case OB:
+ pattern++;
+ while ((*pattern != CB) && (*pattern != '\0')) {
+ cp = str;
+ ok = TRUE;
+ while (ok && (*cp != '\0') && (*pattern != '\0')
+ && (*pattern != ',') && (*pattern != CB)) {
+ if (*pattern == '\\')
+ pattern++;
+ ok = (*pattern++ == *cp++);
+ }
+ if (*pattern == '\0') {
+ ok = FALSE;
+ done = TRUE;
+ break;
+ } else if (ok) {
+ str = cp;
+ while ((*pattern != CB) && (*pattern != '\0')) {
+ if (*++pattern == '\\') {
+ if (*++pattern == CB)
+ pattern++;
+ }
+ }
+ } else {
+ while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
+ if (*++pattern == '\\') {
+ if (*++pattern == CB || *pattern == ',')
+ pattern++;
+ }
+ }
+ }
+ if (*pattern != '\0')
+ pattern++;
+ }
+ break;
+ default:
+ if (*str == *pattern) {
+ str++, pattern++;
+ } else {
+ done = TRUE;
+ }
+ }
+ }
+ while (*pattern == '*')
+ pattern++;
+ return ((*str == '\0') && (*pattern == '\0'));
+};
+
+#endif
+
+#ifdef _MSC_VER
+ #pragma warning(default:4706) // assignment within conditional expression
+#endif // VC++
projects / wxWidgets.git / blobdiff