Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removed unused glob.inc file

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@46348 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
2007-06-07 04:46:03 +00:00
parent c0a66d9237
commit cacd819d0e
2 changed files with 0 additions and 368 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
distrib/msw/copy_src.bat
View File

@@ -109,7 +109,6 @@ cd ..
cd common
md \wxmsw_dist\wxMSW\src\common
copy glob.inc \wxmsw_dist\wxMSW\src\common
copy lexer.l \wxmsw_dist\wxMSW\src\common
copy parser.y \wxmsw_dist\wxMSW\src\common
copy *.c \wxmsw_dist\wxMSW\src\common

367
src/common/glob.inc
View File

@@ -1,367 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: glob.inc
// Purpose: File and other globbing (included by utils.cpp)
// Author: Karsten Ballueder
// Modified by:
// Created: 20/5/1998
// RCS-ID: $Id$
// Copyright: (c) Karsten Ballueder
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// This file includes:
// wxIsWild(const char *pattern)
// wxMatchWild(const char *pattern, const char *str, bool dot_special)
//
//---------------------------------------------------------------------------------
#ifndef UNIX_GLOB
# ifdef wx_x
# define UNIX_GLOB 1
# else
# define UNIX_GLOB 0
# endif
#endif
#if UNIX_GLOB
# ifdef wx_msw
# error "Can't use Unix file globbing under Windows!"
# endif
#endif
/*************************************************************************
*
* wxIsWild checks whether the pattern contains wildcards, and
* returns TRUE if it does, and FALSE if it does not (or if the
* pattern is NULL -- i.e. no string).
*
* The argument is:
*
* 1) pattern - a character string
*/
bool
wxIsWild (const char *pattern)
{
while (*pattern)
{
switch (*pattern++)
{
case '?':
case '*':
#if UNIX_GLOB
case '[':
case '{': /* } */
#endif
return TRUE;
#if UNIX_GLOB
case '\\':
if (!*pattern++)
return FALSE;
#endif
} /* switch() */
} /* while() */
return FALSE;
}
#if UNIX_GLOB
// Unix Glob()
//
// Pattern Function
// -----------------------------------------------------
// '*' = match 0 or more occurances of anything
// "[abc]" = match anyof "abc" (ranges supported)
// "{xx,yy,zz}" = match anyof "xx", "yy", or "zz"
// '?' = match any character
//
// '\' is used to "escape" special characters
// Recursive
bool
wxMatchWild (const char *pattern, const char *str, bool dot_special)
{
char c;
const char *cp;
bool done = FALSE, ret_code, ok;
// Below is for vi fans
const char OB = '{', CB = '}';
#if 0
if (strcmp(pattern, "*.*") == 0)
pattern = "*"; // Hack for MS-DOS compat.
#endif
// 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))));
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++;
} // while()
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++);
} // while()
if (*pattern == '\0')
{
ok = FALSE;
done = TRUE;
break;
}
else if (ok)
{
str = cp;
while ((*pattern != CB) && (*pattern != '\0'))
{
if (*++pattern == '\\')
{
if (*++pattern == CB)
pattern++;
}
} // while()
}
else
{
while (*pattern != CB && *pattern != ',' && *pattern != '\0')
{
if (*++pattern == '\\')
{
if (*++pattern == CB || *pattern == ',')
pattern++;
}
} // while()
}
if (*pattern != '\0')
pattern++;
} // while()
break;
default:
if (*str == *pattern)
{
str++, pattern++;
}
else
{
done = TRUE;
}
} // switch()
} // while()
while (*pattern == '*')
pattern++;
return ((*str == '\0') && (*pattern == '\0'));
}
#else /* MS-DOS/Windows glob() */
/*************************************************************************
*
* wxMatchWild matches the given pattern string against
* a text string, and returns TRUE if it matches, FALSE otherwise.
*
* A match means that the entire text string is used up in the matching.
* The pattern can contain the following wildcards.
*
* * -- matches any sequence of characters
* ? -- matches one character
*
* If one or other or both of the string arguments to wxMatchWild function is
* NULL (i.e. there isn't a string), then the function returns FALSE.
*
*/
static bool wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j);
// @@@@ dotSpecial is ignored by MS-DOS
bool
wxMatchWild (const char *pattern, const char *text, bool /* dotSpecial */ )
{
if (pattern == NULL || text == NULL || *pattern == '\0' || *text == '\0')
return FALSE;
return wxPatternMatch (pattern, text, 0, 0);
}
/*************************************************************************
*
* wxPatternMatch does the work for wxMatchWild. wxPatternMatch matches
* the given pattern string against a text string, and returns TRUE if
* it matches, FALSE otherwise. It is assumed that the string arguments
* to wxPatternMatch exist.
*
* A match means that the entire text string is used up in the matching.
* The pattern can contain the following wildcards.
*
* * -- matches any sequence of characters
* ? -- matches one character
*
* wxPatternMatch works by going down the pattern trying to match the
* the same index character in the pattern and string arrays, and stops
* when the end of the pattern or text string is reached. However, if a
* '*' wildcard is met, the algorithm checks to see whether the remaining
* pattern (after the wildcard) matches the rest of the text (i.e. the
* wxPatternMatch function is called recursively).
*/
// Recursive
static bool
wxPatternMatch (const char *pattern, const char *text, size_t i, size_t j)
{
size_t pattern_length = strlen (pattern);
size_t text_length = strlen (text);
bool match = FALSE;
#ifdef wx_msw
// MS-DOS file system is case INDEPENDENT
# define EQU(x,y) (wxToLower(x) == wxToLower(y))
#else
# define EQU(x,y) ((x) == (y))
#endif
while (j < pattern_length && i < text_length)
{
if (EQU(text[i], pattern[j]) || pattern[j] == '?')
{
match = TRUE;
i++, j++;
}
else if (pattern[j] == '*')
{
// If pattern ends in '*'
if (++j == pattern_length)
{
match = TRUE;
i = text_length;
}
else
{
match = FALSE;
// after wildcard check to see whether rest of pattern matches
// up with rest of text
while (i < text_length && match != TRUE)
{
match = wxPatternMatch (pattern, text, i, j);
i++;
}
// text index is decremented so that it points to where
// the text string starts to match the rest of the pattern
i--;
}
}
else if (! EQU(text[i], pattern[j]))
{
j = pattern_length;
match = FALSE;
}
}
if (j == pattern_length && i == text_length && match == TRUE)
{
return TRUE;
}
else
// special case where pattern and text are the same except that pattern
// also only has '*' wildcards on the end
if (i == text_length && pattern[j] == '*' && match == TRUE)
{
for (; j < pattern_length; j++)
{
if (pattern[j] != '*')
return FALSE;
}
return TRUE;
}
else
{
return FALSE;
}
}
#endif /* UNIX_GLOB */
//-----------------------------------------------------------------------------