std::vector<std::string> folder_wildcard (const std::string& directory, const std::string& wild, bool subdirs, bool files)
{
std::string dir = directory.empty() ? std::string(".") : directory;
std::vector<std::string> results;
#ifdef _WIN32
std::string wildcard = create_filespec(dir, wild);
long handle = -1;
_finddata_t fileinfo;
for (bool OK = (handle = _findfirst((char*)wildcard.c_str(), &fileinfo)) != -1; OK; OK = (_findnext(handle, &fileinfo)==0))
{
std::string strentry = fileinfo.name;
if (strentry.compare(".")!=0 && strentry.compare("..")!=0)
if ((subdirs && (fileinfo.attrib & _A_SUBDIR)) || (files && !(fileinfo.attrib & _A_SUBDIR)))
results.push_back(strentry);
}
_findclose(handle);
#else
DIR* d = opendir(dir.c_str());
if (d)
{
for (dirent* entry = readdir(d); entry; entry = readdir(d))
{
std::string strentry = entry->d_name;
if (strentry.compare(".")!=0 && strentry.compare("..")!=0)
{
std::string subpath = create_filespec(dir, strentry);
if (((subdirs && is_folder(subpath)) || (files && is_file(subpath))) && (match_wildcard(wild, strentry)))
results.push_back(strentry);
}
}
closedir(d);
}
#endif
return results;
}
void INI::delete_pattern(const chowstring & group, const chowstring & item,
const chowstring & value)
{
SectionMap::iterator it1;
OptionMap::iterator it2;
for (it1 = data->begin(); it1 != data->end(); ++it1) {
if (!match_wildcard(group, (*it1).first))
continue;
OptionMap & option_map = (*it1).second;
it2 = option_map.begin();
while (it2 != option_map.end()) {
if (!match_wildcard(item, (*it2).first) ||
!match_wildcard(value, (*it2).second)) {
++it2;
continue;
}
option_map.erase(it2++);
}
}
save_auto();
}
void INI::search(const chowstring & group, const chowstring & item,
const chowstring & value)
{
search_results.clear();
search_time = frame->loop_count;
SectionMap::const_iterator it1;
OptionMap::const_iterator it2;
for (it1 = data->begin(); it1 != data->end(); ++it1) {
if (!match_wildcard(group, (*it1).first))
continue;
for (it2 = (*it1).second.begin(); it2 != (*it1).second.end();
++it2) {
if (!match_wildcard(item, (*it2).first))
continue;
if (!match_wildcard(value, (*it2).second))
continue;
search_results.push_back(
std::pair<chowstring, chowstring>(
(*it1).first,
(*it2).first
));
}
}
}
Status GetPathnames(const PIVFS& fs, const VfsPath& path, const wchar_t* filter, VfsPaths& pathnames)
{
std::vector<CFileInfo> files;
RETURN_STATUS_IF_ERR(fs->GetDirectoryEntries(path, &files, 0));
pathnames.clear();
pathnames.reserve(files.size());
for(size_t i = 0; i < files.size(); i++)
{
if(match_wildcard(files[i].Name().string().c_str(), filter))
pathnames.push_back(path / files[i].Name());
}
return INFO::OK;
}
int glob__match(char *local, char *s, char *format, t_list **results)
{
#ifdef DEBUG
// printf("local = %s, s = %s, format = %s\n", local, s, format);
#endif
if (!*s && !*format)
return (1);
else if (*format == '/')
glob__open_directory(local, format + 1, 2, results);
else if (*s == *format)
return (glob__match(local, s + 1, format + 1, results));
else if (*format == '*')
return (match_wildcard(local, s, format, results));
else if (*format == '?')
return (glob__match(local, s + 1, format + 1, results));
else if (*format == '[')
return (match_bracket(local, s, format, results));
return (0);
}
/*
** Determines whether the directory entry's name matches the glob
** pattern.
*/
bool operator()(const directory_entry& ent)
const noexcept
{
#ifndef NDEBUG
assert(m_pat.length() > 0);
#endif
// Offset into pattern that we are matching.
auto i = 0u;
// Offset into the file name.
auto j = 0u;
auto s = ent.name();
do switch(m_pat[i]) {
default: if (m_pat[i++] != s[j++]) return false; continue;
case '*': ++i; return match_wildcard(s, i, j);
case '?': ++i; ++j; continue;
case '[': ++i; if (!match_group(s, i, j)) return false; continue;
case '\\': ++i; if (m_pat[i++] != s[j++]) return false; continue;
} while (i != m_pat.length() && j != s.length());
return (i == m_pat.length() || m_pat[i] == '*') && j == s.length();
}
Status ForEachFile(const PIVFS& fs, const VfsPath& startPath, FileCallback cb, uintptr_t cbData, const wchar_t* pattern, size_t flags)
{
// (declare here to avoid reallocations)
CFileInfos files;
DirectoryNames subdirectoryNames;
// (a FIFO queue is more efficient than recursion because it uses less
// stack space and avoids seeks due to breadth-first traversal.)
std::queue<VfsPath> pendingDirectories;
pendingDirectories.push(startPath/"");
while(!pendingDirectories.empty())
{
const VfsPath& path = pendingDirectories.front();
RETURN_STATUS_IF_ERR(fs->GetDirectoryEntries(path, &files, &subdirectoryNames));
for(size_t i = 0; i < files.size(); i++)
{
const CFileInfo fileInfo = files[i];
if(!match_wildcard(fileInfo.Name().string().c_str(), pattern))
continue;
const VfsPath pathname(path / fileInfo.Name()); // (CFileInfo only stores the name)
RETURN_STATUS_IF_ERR(cb(pathname, fileInfo, cbData));
}
if(!(flags & DIR_RECURSIVE))
break;
for(size_t i = 0; i < subdirectoryNames.size(); i++)
pendingDirectories.push(path / subdirectoryNames[i]/"");
pendingDirectories.pop();
}
return INFO::OK;
}
FOR_EACH_CONST(i, items) {
if (i.second && match_wildcard(i.first, name)) return i.second;
}
url
complete (url base, url u, string filter, bool flag) {
// cout << "complete " << base << " |||| " << u << LF;
if (!is_rooted(u)) {
if (is_none (base)) return base;
if (is_none (u)) return u;
if ((!is_root (base)) && (!is_rooted_name (base))) {
failed_error << "base= " << base << LF;
FAILED ("invalid base url");
}
}
if (is_name (u) || (is_concat (u) && is_root (u[1]) && is_name (u[2]))) {
url comp= base * u;
if (is_rooted (comp, "default") || is_rooted (comp, "file")) {
if (is_of_type (comp, filter)) return reroot (u, "default");
return url_none ();
}
if (is_rooted_web (comp) || is_rooted_tmfs (comp) || is_ramdisc (comp)) {
if (is_of_type (comp, filter)) return u;
return url_none ();
}
failed_error << "base= " << base << LF;
failed_error << "u= " << u << LF;
ASSERT (is_rooted (comp), "unrooted url");
FAILED ("bad protocol in url");
}
if (is_root (u)) {
// FIXME: test filter flags here
return u;
}
if (is_concat (u) && is_wildcard (u[1], 0) && is_wildcard (u[2], 1)) {
// FIXME: ret= ret | ... is unefficient (quadratic) in main loop
if (!(is_rooted (base, "default") || is_rooted (base, "file"))) {
failed_error << "base= " << base << LF;
FAILED ("wildcards only implemented for files");
}
url ret= url_none ();
bool error_flag;
array<string> dir= read_directory (base, error_flag);
int i, n= N(dir);
for (i=0; i<n; i++) {
if ((!is_none (ret)) && flag) return ret;
if ((dir[i] == ".") || (dir[i] == "..")) continue;
if (starts (dir[i], "http://") || starts (dir[i], "ftp://"))
if (is_directory (base * dir[i])) continue;
ret= ret | (dir[i] * complete (base * dir[i], u, filter, flag));
if (match_wildcard (dir[i], u[2][1]->t->label))
ret= ret | complete (base, dir[i], filter, flag);
}
return ret;
}
if (is_concat (u)) {
url sub= complete (base, u[1], "", false);
// "" should often be faster than the more correct "d" here
return complete (base, sub, u[2], filter, flag);
}
if (is_or (u)) {
url res1= complete (base, u[1], filter, flag);
if ((!is_none (res1)) && flag) return res1;
return res1 | complete (base, u[2], filter, flag);
}
if (is_wildcard (u)) {
// FIXME: ret= ret | ... is unefficient (quadratic) in main loop
if (!(is_rooted (base, "default") || is_rooted (base, "file"))) {
failed_error << "base= " << base << LF;
FAILED ("wildcards only implemented for files");
}
url ret= url_none ();
if (is_wildcard (u, 0) && is_of_type (base, filter)) ret= url_here ();
bool error_flag;
array<string> dir= read_directory (base, error_flag);
int i, n= N(dir);
for (i=0; i<n; i++) {
if ((!is_none (ret)) && flag) return ret;
if ((dir[i] == ".") || (dir[i] == "..")) continue;
if (starts (dir[i], "http://") || starts (dir[i], "ftp://"))
if (is_directory (base * dir[i])) continue;
if (is_wildcard (u, 0))
ret= ret | (dir[i] * complete (base * dir[i], u, filter, flag));
else if (match_wildcard (dir[i], u[1]->t->label))
ret= ret | complete (base, dir[i], filter, flag);
}
return ret;
}
failed_error << "url= " << u << LF;
FAILED ("bad url");
return u;
}