/**
Do a case insensitive find for the pattern.
\param text The text to match an ignore pattern against.
\return Returns true if the directory should be ignored, false otherwise.
**/
static int _fileglob_MatchIgnoreFilePattern(fileglob* self, const char* text) {
fileglob_StringNode* node;
for (node = self->ignoreFilePatternsHead; node; node = node->next) {
if (fileglob_WildMatch(node->buffer, text, 0))
return 1;
}
return 0;
}
/**
Match an exclusive pattern.
\param text The text to match an exclusive pattern against.
\return Returns true if the directory should be ignored, false otherwise.
**/
int _fileglob_MatchExclusiveDirectoryPattern(fileglob* self, const char* text) {
fileglob_StringNode* node;
for (node = self->exclusiveDirectoryPatternsHead; node; node = node->next) {
if (fileglob_WildMatch(node->buffer, text, 0))
return 1;
}
return 0;
}
static int FileFindNextMatch(struct FileFindInfo* info) {
while ((info->dp = readdir(info->dirp)) != NULL) {
if (fileglob_WildMatch(info->wildcard, info->dp->d_name, 0)) {
strcpy(info->pathEnd, info->dp->d_name);
stat(info->path, &info->attr);
if ((info->attr.st_mode & S_IFDIR) != 0) {
if (strcmp(info->dp->d_name, ".") == 0 || strcmp(info->dp->d_name, "..") == 0)
continue;
}
*info->pathEnd = 0;
return 1;
}
}
closedir(info->dirp);
info->dirp = NULL;
return 0;
}
int _fileglob_GlobHelper(fileglob* self, const char* inPattern) {
fileglob_Context* context = self->context;
int hasWildcard;
int found;
Setup:
if (!context) {
context = (fileglob_Context*)self->allocFunction(self->userData, NULL, sizeof(fileglob_Context));
context->prev = self->context;
#if defined(WIN32)
context->handle = INVALID_HANDLE_VALUE;
#else
context->dirp = NULL;
context->hasattr = 0;
context->statted = 0;
#endif
context->pattern = NULL;
context->iterNode = NULL;
context->directoryListHead = context->directoryListTail = 0;
context->basePathLastSlashPos = 0;
buffer_initwithalloc(&context->patternBuf, self->allocFunction, self->userData);
buffer_addstring(&context->patternBuf, inPattern, strlen(inPattern) + 1);
buffer_initwithalloc(&context->basePath, self->allocFunction, self->userData);
buffer_initwithalloc(&context->matchPattern, self->allocFunction, self->userData);
self->context = context;
if (context->prev == NULL)
return 1;
}
DoRecursion:
found = 1;
if (!context->pattern) {
char* pattern;
context->basePathEndPos = context->basePathLastSlashPos = 0;
context->recurseAtPos = (size_t)-1;
// Split the path into base path and pattern to match against.
hasWildcard = 0;
for (pattern = buffer_ptr(&context->patternBuf); *pattern != '\0'; ++pattern) {
char ch = *pattern;
// Is it a '?' ?
if (ch == '?')
hasWildcard = 1;
// Is it a '*' ?
else if (ch == '*') {
hasWildcard = 1;
// Is there a '**'?
if (pattern[1] == '*') {
// If we're just starting the pattern or the characters immediately
// preceding the pattern are a drive letter ':' or a directory path
// '/', then set up the internals for later recursion.
if (pattern == buffer_ptr(&context->patternBuf) || pattern[-1] == '/' || pattern[-1] == ':') {
char ch2 = pattern[2];
if (ch2 == '/') {
context->recurseAtPos = pattern - buffer_ptr(&context->patternBuf);
memcpy(pattern, pattern + 3, strlen(pattern) - 2);
buffer_deltapos(&context->patternBuf, -3);
} else if (ch2 == '\0') {
context->recurseAtPos = pattern - buffer_ptr(&context->patternBuf);
*pattern = '\0';
}
}
}
}
// Is there a '/' or ':' in the pattern at this location?
if (ch == '/' || ch == ':') {
if (hasWildcard)
break;
else {
if (pattern[1])
context->basePathLastSlashPos = pattern - buffer_ptr(&context->patternBuf) + 1;
context->basePathEndPos = pattern - buffer_ptr(&context->patternBuf) + 1;
}
}
}
context->pattern = pattern;
// Copy the directory down.
context->basePathLen = context->basePathEndPos;
buffer_reset(&context->basePath);
buffer_addstring(&context->basePath, buffer_ptr(&context->patternBuf), context->basePathLen);
buffer_addchar(&context->basePath, 0);
if (context->iterNode) {
context->matchFiles = *context->pattern == 0;
goto NextDirectory;
}
}
#if defined(WIN32)
if (context->handle == INVALID_HANDLE_VALUE) {
#else
if (!context->dirp && !context->statted) {
#endif
size_t matchLen;
// Did we make it to the end of the pattern? If so, we should match files,
// since there were no slashes encountered.
context->matchFiles = *context->pattern == 0;
// Copy the wildcard matching string.
matchLen = (context->pattern - buffer_ptr(&context->patternBuf)) - context->basePathLen;
buffer_reset(&context->matchPattern);
buffer_addstring(&context->matchPattern, buffer_ptr(&context->patternBuf) + context->basePathLen, matchLen + 1);
buffer_deltapos(&context->matchPattern, -1);
if (*buffer_posptr(&context->matchPattern) == '/') {
buffer_deltapos(&context->matchPattern, 1);
buffer_addchar(&context->matchPattern, 0);
}
#if defined(WIN32)
// Do the file search with *.* in the directory specified in basePattern.
buffer_setpos(&context->basePath, context->basePathEndPos);
buffer_addstring(&context->basePath, "*.*", 4);
// Start the find.
context->handle = FindFirstFile(buffer_ptr(&context->basePath), &context->fd);
if (context->handle == INVALID_HANDLE_VALUE) {
found = 0;
}
#else
// Start the find.
buffer_setpos(&context->basePath, context->basePathEndPos);
buffer_addchar(&context->basePath, 0);
context->dirp = opendir(buffer_ptr(&context->basePath)[0] ? buffer_ptr(&context->basePath) : ".");
if (!context->dirp) {
found = 0;
} else {
context->dp = readdir(context->dirp);
found = context->dp != NULL;
}
#endif
// Clear out the *.* so we can use the original basePattern string.
buffer_setpos(&context->basePath, context->basePathEndPos);
buffer_putchar(&context->basePath, 0);
} else {
goto NextFile;
}
// Any files found?
#if defined(WIN32)
if (context->handle != INVALID_HANDLE_VALUE) {
#else
if (context->dirp) {
#endif
for (;;) {
#if defined(WIN32)
char* filename = context->fd.cFileName;
#else
char* filename = context->dp->d_name;
context->hasattr = 0;
#endif
// Is the file a directory?
#if defined(WIN32)
if (context->fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
#else
if (context->dp->d_type == DT_DIR) {
#endif
// Knock out "." or ".."
int ignore = filename[0] == '.' &&
(filename[1] == 0 ||
(filename[1] == '.' && filename[2] == 0));
// Should this file be ignored?
int matches = 0;
if (!ignore) {
size_t len = strlen(filename);
filename[len] = '/';
filename[len + 1] = '\0';
matches = fileglob_WildMatch(buffer_ptr(&context->matchPattern), filename, 0);
}
// Do a wildcard match.
if (!ignore && matches) {
// It matched. Let's see if the file should be ignored.
// See if this is a directory to ignore.
ignore = _fileglob_MatchIgnoreDirectoryPattern(self, filename);
// Should this file be ignored?
if (!ignore) {
_fileglob_list_append(self, &context->directoryListHead, &context->directoryListTail, filename);
// Is this pattern exclusive?
if (self->exclusiveDirectoryPatternsHead) {
if (_fileglob_MatchExclusiveDirectoryPattern(self, filename))
break;
} else {
if ((!context->matchFiles && context->pattern[0] == '/' && context->pattern[1] == 0)
|| (self->filesAndFolders))
break;
}
}
}
} else {
// Do a wildcard match.
if (fileglob_WildMatch(buffer_ptr(&context->matchPattern), filename, 0)) {
// It matched. Let's see if the file should be ignored.
int ignore = _fileglob_MatchIgnoreFilePattern(self, filename);
// Is this pattern exclusive?
if (!ignore && self->exclusiveFilePatternsHead) {
ignore = !_fileglob_MatchExclusiveFilePattern(self, filename);
}
// Should this file be ignored?
if (!ignore) {
if (context->matchFiles)
break;
}
}
}
NextFile:
// Look up the next file.
#if defined(WIN32)
found = FindNextFile(context->handle, &context->fd) == TRUE;
#else
if (context->dirp) {
context->dp = readdir(context->dirp);
found = context->dp != NULL;
} else {
found = 0;
}
#endif
if (!found)
break;
}
if (!found) {
// Close down the file find handle.
#if defined(WIN32)
FindClose(context->handle);
context->handle = INVALID_HANDLE_VALUE;
#else
if (context->dirp) {
closedir(context->dirp);
context->dirp = NULL;
}
#endif
context->iterNode = context->directoryListHead;
}
}
// Iterate the file list and either recurse or add the file as a found
// file.
if (!context->matchFiles) {
if (found) {
return 1;
}
NextDirectory:
if (context->iterNode) {
// Need more directories.
SplicePath(&self->combinedName, buffer_ptr(&context->basePath), context->iterNode->buffer);
buffer_deltapos(&self->combinedName, -2);
buffer_addstring(&self->combinedName, context->pattern, strlen(context->pattern) + 1);
context->iterNode = context->iterNode->next;
context = NULL;
inPattern = buffer_ptr(&self->combinedName);
goto Setup;
}
} else {
if (found)
return 1;
}
// Do we need to recurse?
if (context->recurseAtPos == (size_t)-1) {
_fileglob_FreeContextLevel(self);
context = self->context;
if (!context)
return 0;
goto NextDirectory;
}
buffer_reset(&context->matchPattern);
buffer_setpos(&context->patternBuf, context->recurseAtPos);
buffer_addstring(&context->matchPattern, buffer_posptr(&context->patternBuf), strlen(buffer_posptr(&context->patternBuf)));
buffer_addstring(&context->patternBuf, "*/**/", 5);
buffer_addstring(&context->patternBuf, buffer_ptr(&context->matchPattern), buffer_pos(&context->matchPattern) + 1);
inPattern = buffer_ptr(&context->patternBuf);
context->pattern = NULL;
if (context->matchFiles) {
context->iterNode = context->directoryListHead;
} else {
_fileglob_list_clear(self, &context->directoryListHead, &context->directoryListTail);
}
goto DoRecursion;
}
/**
Adds a pattern to the file glob database of exclusive patterns. If any
exclusive patterns are registered, the ignore database is completely
ignored. Only patterns matching the exclusive patterns will be
candidates for matching.
\param name The exclusive pattern.
**/
void fileglob_AddExclusivePattern(fileglob* self, const char* pattern) {
fileglob_StringNode* node;
if (pattern[strlen(pattern) - 1] == '/') {
for (node = self->exclusiveDirectoryPatternsHead; node; node = node->next) {
#if defined(_WIN32)
if (stricmp(node->buffer, pattern) == 0) {
#else
if (strcasecmp(node->buffer, pattern) == 0) {
#endif
return;
}
}
_fileglob_list_append(self, &self->exclusiveDirectoryPatternsHead, &self->exclusiveDirectoryPatternsTail, pattern);
} else {
for (node = self->exclusiveFilePatternsHead; node; node = node->next) {
#if defined(_WIN32)
if (stricmp(node->buffer, pattern) == 0) {
#else
if (strcasecmp(node->buffer, pattern) == 0) {
#endif
return;
}
}
_fileglob_list_append(self, &self->exclusiveFilePatternsHead, &self->exclusiveFilePatternsTail, pattern);
}
}
/**
Adds a pattern to ignore to the file glob database. If a pattern of
the given name is found, its contents will not be considered for further
matching. The result is as if the pattern did not exist for the search
in the first place.
\param name The pattern to ignore.
**/
void fileglob_AddIgnorePattern(fileglob* self, const char* pattern) {
fileglob_StringNode* node;
if (pattern[strlen(pattern) - 1] == '/') {
for (node = self->ignoreDirectoryPatternsHead; node; node = node->next) {
#if defined(_WIN32)
if (stricmp(node->buffer, pattern) == 0) {
#else
if (strcasecmp(node->buffer, pattern) == 0) {
#endif
return;
}
}
_fileglob_list_append(self, &self->ignoreDirectoryPatternsHead, &self->ignoreDirectoryPatternsTail, pattern);
} else {
for (node = self->ignoreFilePatternsHead; node; node = node->next) {
#if defined(_WIN32)
if (stricmp(node->buffer, pattern) == 0) {
#else
if (strcasecmp(node->buffer, pattern) == 0) {
#endif
return;
}
}
_fileglob_list_append(self, &self->ignoreFilePatternsHead, &self->ignoreFilePatternsTail, pattern);
}
}
/**
Match an exclusive pattern.
\param text The text to match an exclusive pattern against.
\return Returns true if the directory should be ignored, false otherwise.
**/
static int _fileglob_MatchExclusiveDirectoryPattern(fileglob* self, const char* text) {
fileglob_StringNode* node;
for (node = self->exclusiveDirectoryPatternsHead; node; node = node->next) {
if (fileglob_WildMatch(node->buffer, text, 0, 1))
return 1;
}
return 0;
}
/**
\author Jack Handy
Borrowed from http://www.codeproject.com/string/wildcmp.asp.
Modified by Joshua Jensen.
**/
int fileglob_WildMatch(const char* pattern, const char *string, int caseSensitive, int recursive) {
const char* mp = 0;
const char* cp = 0;
if (caseSensitive) {
if (recursive) {
topa:
// Handle all the letters of the pattern and the string.
while (*string != 0 && *pattern != '*') {
if (*pattern != '?') {
if (toupper(*pattern) != toupper(*string))
return 0;
}
pattern++;
string++;
}
while (*string != 0) {
if (*pattern == '*') {
// It's a match if the wildcard is at the end.
++pattern;
if (*pattern == '*') {
if (pattern[1] == '/')
pattern += 2;
while (*string != 0) {
while (*string != 0) {
if (*string == '/') {
++string;
break;
}
++string;
}
if (fileglob_WildMatch(pattern, string, caseSensitive, 1)) {
return 1;
}
}
}
mp = pattern;
cp = string + 1;
} else {
if (*string == '/') {
if (*pattern != '/') {
return 0;
} else {
pattern++;
string++;
if (*pattern == 0 && *string != 0) {
return 0;
}
goto topa;
}
}
if (toupper(*pattern) == toupper(*string) || *pattern == '?') {
pattern++;
string++;
} else {
pattern = mp;
string = cp++;
}
}
}
} else {
// Handle all the letters of the pattern and the string.
while (*string != 0 && *pattern != '*') {
if (*pattern != '?') {
if (*pattern != *string)
return 0;
}
pattern++;
string++;
}
while (*string != 0) {
if (*pattern == '*') {
// It's a match if the wildcard is at the end.
if (*++pattern == 0) {
return 1;
}
mp = pattern;
cp = string + 1;
} else {
if (*pattern == *string || *pattern == '?') {
pattern++;
string++;
} else {
pattern = mp;
string = cp++;
}
}
}
}
} else {
if (recursive) {
topb:
// Handle all the letters of the pattern and the string.
while (*string != 0 && *pattern != '*') {
if (*pattern != '?') {
if (toupper(*pattern) != toupper(*string))
return 0;
}
pattern++;
string++;
}
while (*string != 0) {
if (*pattern == '*') {
// It's a match if the wildcard is at the end.
++pattern;
if (*pattern == '*') {
if (pattern[1] == '/')
pattern += 2;
while (*string != 0) {
if (fileglob_WildMatch(pattern, string, caseSensitive, 1)) {
return 1;
}
while (*string != 0) {
if (*string == '/') {
++string;
break;
}
++string;
}
}
}
mp = pattern;
cp = string + 1;
} else {
if (*string == '/') {
if (*pattern != '/') {
return 0;
} else {
pattern++;
string++;
if (*pattern == 0 && *string != 0) {
return 0;
}
goto topb;
}
}
if (toupper(*pattern) == toupper(*string) || *pattern == '?') {
pattern++;
string++;
} else {
pattern = mp;
string = cp++;
}
}
}
} else {
// Handle all the letters of the pattern and the string.
while (*string != 0 && *pattern != '*') {
if (*pattern != '?') {
if (toupper(*pattern) != toupper(*string))
return 0;
}
pattern++;
string++;
}
while (*string != 0) {
if (*pattern == '*') {
// It's a match if the wildcard is at the end.
if (*++pattern == 0) {
return 1;
}
mp = pattern;
cp = string + 1;
} else {
if (toupper(*pattern) == toupper(*string) || *pattern == '?') {
pattern++;
string++;
} else {
pattern = mp;
string = cp++;
}
}
}
}
}
while (*pattern == '*')
pattern++;
return !*pattern && !*string;
}
