#endif
#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 <dirent.h>
#endif
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
#ifndef __GNUWIN32__
#include <direct.h>
#include <dos.h>
#ifdef __GNUWIN32__
#include <sys/unistd.h>
-// #include <sys/stat.h>
-
-#ifndef __MINGW32__
-#include <std.h>
-#endif
-
#define stricmp strcasecmp
#endif
#include <dir.h>
#endif
-#ifdef __WXMSW__
+#include "wx/setup.h"
+#ifdef HAVE_FNMATCH_H
+#include "fnmatch.h"
+#endif
+
+#ifdef __WINDOWS__
#include "windows.h"
#endif
#define _MAXPATHLEN 500
-#if !USE_SHARED_LIBRARY
+extern char *wxBuffer;
+
+#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxPathList, wxStringList)
#endif
-extern char *wxBuffer;
-
void wxPathList::Add (const wxString& path)
{
wxStringList::Add ((char *)(const char *)path);
void wxPathList::AddEnvList (const wxString& envVariable)
{
static const char PATH_TOKS[] =
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
" ;"; // Don't seperate with colon in DOS (used for drive)
#else
" :;";
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(__WXMSW__) || defined(__VMS__)
+#if defined(__WINDOWS__) || defined(__VMS__)
// Case INDEPENDENT
path.CompareTo (path2, wxString::ignoreCase) == 0
#else
if (ch != '\\' && ch != '/')
strcat (wxBuffer, "/");
strcat (wxBuffer, filename);
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
Unix2DosFilename (wxBuffer);
#endif
if (wxFileExists (wxBuffer))
lastCh = buf[len-1];
if (lastCh != '/' && lastCh != '\\')
{
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
strcat(buf, "\\");
#else
strcat(buf, "/");
bool
wxFileExists (const wxString& filename)
{
+#ifdef __GNUWIN32__ // (fix a B20 bug)
+ if (GetFileAttributes(filename) == 0xFFFFFFFF)
+ return FALSE;
+ else
+ return TRUE;
+#else
struct stat stbuf;
if (filename && stat ((char *)(const char *)filename, &stbuf) == 0)
return TRUE;
return FALSE;
+#endif
}
/* Vadim's alternative implementation
#ifdef __VMS__
|| (filename[0] == '[' && filename[1] != '.')
#endif
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
/* MSDOS */
|| filename[0] == '\\' || (isalpha (filename[0]) && filename[1] == ':')
#endif
}
}
+void wxStripExtension(wxString& buffer)
+{
+ size_t len = buffer.Length();
+ size_t i = len-1;
+ while (i > 0)
+ {
+ if (buffer.GetChar(i) == '.')
+ {
+ buffer = buffer.Left(i);
+ break;
+ }
+ i --;
+ }
+}
+
// Destructive removal of /./ and /../ stuff
char *wxRealPath (char *path)
{
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));
#endif
}
- return NULL;
+ return (char *) NULL;
}
// Return just the directory, or NULL if no directory
}
void
+#ifdef __WXMSW__
wxUnix2DosFilename (char *s)
+#else
+wxUnix2DosFilename (char *WXUNUSED(s))
+#endif
{
// Yes, I really mean this to happen under DOS only! JACS
#ifdef __WXMSW__
{
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
if ((fp1 = fopen (WXSTRINGCAST file1, "rb")) == NULL ||
(fp2 = fopen (WXSTRINGCAST file2, "rb")) == NULL ||
bool wxMkdir(const wxString& dir)
{
-#ifdef __VMS__
+#if defined(__WXSTUBS__)
+ return FALSE;
+#elif defined(__VMS__)
return FALSE;
#elif (defined(__GNUWIN32__) && !defined(__MINGW32__)) || !defined(__WXMSW__)
return (mkdir (WXSTRINGCAST dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) == 0);
// Get a temporary filename, opening and closing the file.
char *wxGetTempFileName(const wxString& prefix, char *buf)
{
-#ifdef __WXMSW__
+#ifdef __WINDOWS__
#ifndef __WIN32__
char tmp[144];
#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";
+ cerr << _("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__)
{
#ifdef __UNIX__
return (chdir(d) == 0);
-#elif defined(__WXMSW__)
+#elif defined(__WINDOWS__)
#ifdef __WIN32__
return (bool)(SetCurrentDirectory(d) != 0);
{
// we assume that it's not empty
wxCHECK_MSG( !IsEmpty(pszFile), FALSE,
- "empty file name in wxFindFileInPath");
+ _("empty file name in wxFindFileInPath"));
// skip path separator in the beginning of the file name if present
if ( wxIsPathSeparator(*pszFile) )
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) )
return pc != NULL; // if true => we breaked from the loop
}
+void WXDLLEXPORT wxSplitPath(const char *pszFileName,
+ wxString *pstrPath,
+ wxString *pstrName,
+ wxString *pstrExt)
+{
+ wxCHECK_RET( pszFileName, _("NULL file name in wxSplitPath") );
+
+ const char *pDot = strrchr(pszFileName, FILE_SEP_EXT);
+ const char *pSepUnix = strrchr(pszFileName, FILE_SEP_PATH_UNIX);
+ const char *pSepDos = strrchr(pszFileName, FILE_SEP_PATH_DOS);
+
+ // take the last of the two
+ size_t nPosUnix = pSepUnix ? pSepUnix - pszFileName : 0;
+ size_t nPosDos = pSepDos ? pSepDos - pszFileName : 0;
+ if ( nPosDos > nPosUnix )
+ nPosUnix = nPosDos;
+// size_t nLen = Strlen(pszFileName);
+
+ if ( pstrPath )
+ *pstrPath = wxString(pszFileName, nPosUnix);
+ if ( pDot ) {
+ size_t nPosDot = pDot - pszFileName;
+ if ( pstrName )
+ *pstrName = wxString(pszFileName + nPosUnix + 1, nPosDot - nPosUnix);
+ if ( pstrExt )
+ *pstrExt = wxString(pszFileName + nPosDot + 1);
+ }
+ else {
+ if ( pstrName )
+ *pstrName = wxString(pszFileName + nPosUnix + 1);
+ 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 )
+#ifdef 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