// Common/Wildcard.cpp
#include "StdAfx.h"
#include "Wildcard.h"
bool g_CaseSensitive =
#ifdef _WIN32
false;
#else
true;
#endif
bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2)
{
if (g_CaseSensitive)
{
for (;;)
{
wchar_t c2 = *s2++; if (c2 == 0) return true;
wchar_t c1 = *s1++;
if (MyCharUpper(c1) !=
MyCharUpper(c2))
return false;
}
}
for (;;)
{
wchar_t c2 = *s2++; if (c2 == 0) return true;
wchar_t c1 = *s1++; if (c1 != c2) return false;
}
}
int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW
{
if (g_CaseSensitive)
return wcscmp(s1, s2);
return MyStringCompareNoCase(s1, s2);
}
#ifndef USE_UNICODE_FSTRING
int CompareFileNames(const char *s1, const char *s2)
{
if (g_CaseSensitive)
return wcscmp(fs2us(s1), fs2us(s2));
return MyStringCompareNoCase(fs2us(s1), fs2us(s2));
}
#endif
// -----------------------------------------
// this function compares name with mask
// ? - any char
// * - any char or empty
static bool EnhancedMaskTest(const wchar_t *mask, const wchar_t *name)
{
for (;;)
{
wchar_t m = *mask;
wchar_t c = *name;
if (m == 0)
return (c == 0);
if (m == '*')
{
if (EnhancedMaskTest(mask + 1, name))
return true;
if (c == 0)
return false;
}
else
{
if (m == '?')
{
if (c == 0)
return false;
}
else if (m != c)
if (g_CaseSensitive || MyCharUpper(m) != MyCharUpper(c))
return false;
mask++;
}
name++;
}
}
// --------------------------------------------------
// Splits path to strings
void SplitPathToParts(const UString &path, UStringVector &pathParts)
{
pathParts.Clear();
unsigned len = path.Len();
if (len == 0)
return;
UString name;
unsigned prev = 0;
for (unsigned i = 0; i < len; i++)
if (IsCharDirLimiter(path[i]))
{
name.SetFrom(path.Ptr(prev), i - prev);
pathParts.Add(name);
prev = i + 1;
}
name.SetFrom(path.Ptr(prev), len - prev);
pathParts.Add(name);
}
void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name)
{
const wchar_t *start = path;
const wchar_t *p = start + path.Len();
for (; p != start; p--)
if (IsCharDirLimiter(*(p - 1)))
break;
dirPrefix.SetFrom(path, (unsigned)(p - start));
name = p;
}
void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name)
{
const wchar_t *start = path;
const wchar_t *p = start + path.Len();
if (p != start)
{
if (IsCharDirLimiter(*(p - 1)))
p--;
for (; p != start; p--)
if (IsCharDirLimiter(*(p - 1)))
break;
}
dirPrefix.SetFrom(path, (unsigned)(p - start));
name = p;
}
UString ExtractDirPrefixFromPath(const UString &path)
{
const wchar_t *start = path;
const wchar_t *p = start + path.Len();
for (; p != start; p--)
if (IsCharDirLimiter(*(p - 1)))
break;
return path.Left((unsigned)(p - start));
}
UString ExtractFileNameFromPath(const UString &path)
{
const wchar_t *start = path;
const wchar_t *p = start + path.Len();
for (; p != start; p--)
if (IsCharDirLimiter(*(p - 1)))
break;
return p;
}
bool DoesWildcardMatchName(const UString &mask, const UString &name)
{
return EnhancedMaskTest(mask, name);
}
bool DoesNameContainWildcard(const UString &path)
{
for (unsigned i = 0; i < path.Len(); i++)
{
wchar_t c = path[i];
if (c == '*' || c == '?')
return true;
}
return false;
}
// ----------------------------------------------------------'
// NWildcard
namespace NWildcard {
#ifdef _WIN32
bool IsDriveColonName(const wchar_t *s)
{
wchar_t c = s[0];
return c != 0 && s[1] == ':' && s[2] == 0 && (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z');
}
#endif
/*
M = MaskParts.Size();
N = TestNameParts.Size();
File Dir
ForFile rec M<=N [N-M, N) -
!ForDir nonrec M=N [0, M) -
ForDir rec M<N [0, M) ... [N-M-1, N-1) same as ForBoth-File
!ForFile nonrec [0, M) same as ForBoth-File
ForFile rec m<=N [0, M) ... [N-M, N) same as ForBoth-File
ForDir nonrec [0, M) same as ForBoth-File
*/
bool CItem::AreAllAllowed() const
{
return ForFile && ForDir && WildcardMatching && PathParts.Size() == 1 && PathParts.Front() == L"*";
}
bool CItem::CheckPath(const UStringVector &pathParts, bool isFile) const
{
if (!isFile && !ForDir)
return false;
int delta = (int)pathParts.Size() - (int)PathParts.Size();
if (delta < 0)
return false;
int start = 0;
int finish = 0;
if (isFile)
{
if (!ForDir)
{
if (Recursive)
start = delta;
else if (delta !=0)
return false;
}
if (!ForFile && delta == 0)
return false;
}
if (Recursive)
{
finish = delta;
if (isFile && !ForFile)
finish = delta - 1;
}
for (int d = start; d <= finish; d++)
{
unsigned i;
for (i = 0; i < PathParts.Size(); i++)
{
if (WildcardMatching)
{
if (!DoesWildcardMatchName(PathParts[i], pathParts[i + d]))
break;
}
else
{
if (CompareFileNames(PathParts[i], pathParts[i + d]) != 0)
break;
}
}
if (i == PathParts.Size())
return true;
}
return false;
}
bool CCensorNode::AreAllAllowed() const
{
if (!Name.IsEmpty() ||
!SubNodes.IsEmpty() ||
!ExcludeItems.IsEmpty() ||
IncludeItems.Size() != 1)
return false;
return IncludeItems.Front().AreAllAllowed();
}
int CCensorNode::FindSubNode(const UString &name) const
{
FOR_VECTOR (i, SubNodes)
if (CompareFileNames(SubNodes[i].Name, name) == 0)
return i;
return -1;
}
void CCensorNode::AddItemSimple(bool include, CItem &item)
{
if (include)
IncludeItems.Add(item);
else
ExcludeItems.Add(item);
}
void CCensorNode::AddItem(bool include, CItem &item)
{
if (item.PathParts.Size() <= 1)
{
if (item.PathParts.Size() != 0 && item.WildcardMatching)
{
if (!DoesNameContainWildcard(item.PathParts.Front()))
item.WildcardMatching = false;
}
AddItemSimple(include, item);
return;
}
const UString &front = item.PathParts.Front();
// We can't ignore wildcard, since we don't allow wildcard in SubNodes[].Name
// if (item.Wildcard)
if (DoesNameContainWildcard(front))
{
AddItemSimple(include, item);
return;
}
int index = FindSubNode(front);
if (index < 0)
index = SubNodes.Add(CCensorNode(front, this));
item.PathParts.Delete(0);
SubNodes[index].AddItem(include, item);
}
void CCensorNode::AddItem(bool include, const UString &path, bool recursive, bool forFile, bool forDir, bool wildcardMatching)
{
CItem item;
SplitPathToParts(path, item.PathParts);
item.Recursive = recursive;
item.ForFile = forFile;
item.ForDir = forDir;
item.WildcardMatching = wildcardMatching;
AddItem(include, item);
}
bool CCensorNode::NeedCheckSubDirs() const
{
FOR_VECTOR (i, IncludeItems)
{
const CItem &item = IncludeItems[i];
if (item.Recursive || item.PathParts.Size() > 1)
return true;
}
return false;
}
bool CCensorNode::AreThereIncludeItems() const
{
if (IncludeItems.Size() > 0)
return true;
FOR_VECTOR (i, SubNodes)
if (SubNodes[i].AreThereIncludeItems())
return true;
return false;
}
bool CCensorNode::CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const
{
const CObjectVector<CItem> &items = include ? IncludeItems : ExcludeItems;
FOR_VECTOR (i, items)
if (items[i].CheckPath(pathParts, isFile))
return true;
return false;
}
bool CCensorNode::CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const
{
if (CheckPathCurrent(false, pathParts, isFile))
{
include = false;
return true;
}
include = true;
bool finded = CheckPathCurrent(true, pathParts, isFile);
if (pathParts.Size() <= 1)
return finded;
int index = FindSubNode(pathParts.Front());
if (index >= 0)
{
UStringVector pathParts2 = pathParts;
pathParts2.Delete(0);
if (SubNodes[index].CheckPathVect(pathParts2, isFile, include))
return true;
}
return finded;
}
bool CCensorNode::CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const
{
UStringVector pathParts;
SplitPathToParts(path, pathParts);
if (CheckPathVect(pathParts, isFile, include))
{
if (!include || !isAltStream)
return true;
}
if (isAltStream && !pathParts.IsEmpty())
{
UString &back = pathParts.Back();
int pos = back.Find(L':');
if (pos > 0)
{
back.DeleteFrom(pos);
return CheckPathVect(pathParts, isFile, include);
}
}
return false;
}
bool CCensorNode::CheckPath(bool isAltStream, const UString &path, bool isFile) const
{
bool include;
if (CheckPath2(isAltStream, path, isFile, include))
return include;
return false;
}
bool CCensorNode::CheckPathToRoot(bool include, UStringVector &pathParts, bool isFile) const
{
if (CheckPathCurrent(include, pathParts, isFile))
return true;
if (Parent == 0)
return false;
pathParts.Insert(0, Name);
return Parent->CheckPathToRoot(include, pathParts, isFile);
}
/*
bool CCensorNode::CheckPathToRoot(bool include, const UString &path, bool isFile) const
{
UStringVector pathParts;
SplitPathToParts(path, pathParts);
return CheckPathToRoot(include, pathParts, isFile);
}
*/
void CCensorNode::AddItem2(bool include, const UString &path, bool recursive, bool wildcardMatching)
{
if (path.IsEmpty())
return;
bool forFile = true;
bool forFolder = true;
UString path2 = path;
if (IsCharDirLimiter(path.Back()))
{
path2.DeleteBack();
forFile = false;
}
AddItem(include, path2, recursive, forFile, forFolder, wildcardMatching);
}
void CCensorNode::ExtendExclude(const CCensorNode &fromNodes)
{
ExcludeItems += fromNodes.ExcludeItems;
FOR_VECTOR (i, fromNodes.SubNodes)
{
const CCensorNode &node = fromNodes.SubNodes[i];
int subNodeIndex = FindSubNode(node.Name);
if (subNodeIndex < 0)
subNodeIndex = SubNodes.Add(CCensorNode(node.Name, this));
SubNodes[subNodeIndex].ExtendExclude(node);
}
}
int CCensor::FindPrefix(const UString &prefix) const
{
FOR_VECTOR (i, Pairs)
if (CompareFileNames(Pairs[i].Prefix, prefix) == 0)
return i;
return -1;
}
void CCensor::AddItem(ECensorPathMode pathMode, bool include, const UString &path, bool recursive, bool wildcardMatching)
{
UStringVector pathParts;
if (path.IsEmpty())
throw "Empty file path";
SplitPathToParts(path, pathParts);
bool forFile = true;
if (pathParts.Back().IsEmpty())
{
forFile = false;
pathParts.DeleteBack();
}
UString prefix;
if (pathMode != k_AbsPath)
{
const UString &front = pathParts.Front();
bool isAbs = false;
if (front.IsEmpty())
isAbs = true;
else
{
#ifdef _WIN32
if (IsDriveColonName(front))
isAbs = true;
else
#endif
FOR_VECTOR (i, pathParts)
{
const UString &part = pathParts[i];
if (part == L".." || part == L".")
{
isAbs = true;
break;
}
}
}
unsigned numAbsParts = 0;
if (isAbs)
if (pathParts.Size() > 1)
numAbsParts = pathParts.Size() - 1;
else
numAbsParts = 1;
#ifdef _WIN32
// \\?\ case
if (numAbsParts >= 3)
{
if (pathParts[0].IsEmpty() &&
pathParts[1].IsEmpty() &&
pathParts[2] == L"?")
{
prefix =
WSTRING_PATH_SEPARATOR
WSTRING_PATH_SEPARATOR L"?"
WSTRING_PATH_SEPARATOR;
numAbsParts -= 3;
pathParts.DeleteFrontal(3);
}
}
#endif
if (numAbsParts > 1 && pathMode == k_FullPath)
numAbsParts = 1;
// We can't ignore wildcard, since we don't allow wildcard in SubNodes[].Name
// if (wildcardMatching)
for (unsigned i = 0; i < numAbsParts; i++)
{
{
const UString &front = pathParts.Front();
if (DoesNameContainWildcard(front))
break;
prefix += front;
prefix += WCHAR_PATH_SEPARATOR;
}
pathParts.Delete(0);
}
}
int index = FindPrefix(prefix);
if (index < 0)
index = Pairs.Add(CPair(prefix));
CItem item;
item.PathParts = pathParts;
item.ForDir = true;
item.ForFile = forFile;
item.Recursive = recursive;
item.WildcardMatching = wildcardMatching;
Pairs[index].Head.AddItem(include, item);
}
bool CCensor::CheckPath(bool isAltStream, const UString &path, bool isFile) const
{
bool finded = false;
FOR_VECTOR (i, Pairs)
{
bool include;
if (Pairs[i].Head.CheckPath2(isAltStream, path, isFile, include))
{
if (!include)
return false;
finded = true;
}
}
return finded;
}
void CCensor::ExtendExclude()
{
unsigned i;
for (i = 0; i < Pairs.Size(); i++)
if (Pairs[i].Prefix.IsEmpty())
break;
if (i == Pairs.Size())
return;
unsigned index = i;
for (i = 0; i < Pairs.Size(); i++)
if (index != i)
Pairs[i].Head.ExtendExclude(Pairs[index].Head);
}
void CCensor::AddPathsToCensor(ECensorPathMode censorPathMode)
{
FOR_VECTOR(i, CensorPaths)
{
const CCensorPath &cp = CensorPaths[i];
AddItem(censorPathMode, cp.Include, cp.Path, cp.Recursive, cp.WildcardMatching);
}
CensorPaths.Clear();
}
void CCensor::AddPreItem(bool include, const UString &path, bool recursive, bool wildcardMatching)
{
CCensorPath &cp = CensorPaths.AddNew();
cp.Path = path;
cp.Include = include;
cp.Recursive = recursive;
cp.WildcardMatching = wildcardMatching;
}
}