static bool IsSupportedName(const UString &name)
{
for (unsigned i = 0; i < ARRAY_SIZE(g_ReservedNames); i++)
{
const char *reservedName = g_ReservedNames[i];
unsigned len = MyStringLen(reservedName);
if (name.Len() < len)
continue;
if (!name.IsPrefixedBy_Ascii_NoCase(reservedName))
continue;
if (i >= g_ReservedWithNum_Index)
{
wchar_t c = name[len];
if (c < L'0' || c > L'9')
continue;
len++;
}
for (;;)
{
wchar_t c = name[len++];
if (c == 0 || c == '.')
return false;
if (c != ' ')
break;
}
}
return true;
}
bool IsDevicePath(CFSTR s) throw()
{
#ifdef UNDER_CE
s = s;
return false;
/*
// actually we don't know the way to open device file in WinCE.
unsigned len = MyStringLen(s);
if (len < 5 || len > 5 || memcmp(s, FTEXT("DSK"), 3 * sizeof(FChar)) != 0)
return false;
if (s[4] != ':')
return false;
// for reading use SG_REQ sg; if (DeviceIoControl(dsk, IOCTL_DISK_READ));
*/
#else
if (!IS_DEVICE_PATH(s))
return false;
unsigned len = MyStringLen(s);
if (len == 6 && s[5] == ':')
return true;
if (len < 18 || len > 22 || memcmp(s + kDevicePathPrefixSize, FTEXT("PhysicalDrive"), 13 * sizeof(FChar)) != 0)
return false;
for (unsigned i = 17; i < len; i++)
if (s[i] < '0' || s[i] > '9')
return false;
return true;
#endif
}
bool ParseSubCharsCommand(int numForms, const CCommandSubCharsSet *forms,
const UString &commandString, CIntVector &indices)
{
indices.Clear();
int numUsedChars = 0;
for(int i = 0; i < numForms; i++)
{
const CCommandSubCharsSet &set = forms[i];
int currentIndex = -1;
int len = MyStringLen(set.Chars);
for(int j = 0; j < len; j++)
{
wchar_t c = set.Chars[j];
int newIndex = commandString.Find(c);
if (newIndex >= 0)
{
if (currentIndex >= 0)
return false;
if (commandString.Find(c, newIndex + 1) >= 0)
return false;
currentIndex = j;
numUsedChars++;
}
}
if(currentIndex == -1 && !set.EmptyAllowed)
return false;
indices.Add(currentIndex);
}
return (numUsedChars == commandString.Length());
}
bool CDoubleZeroStringListW::Add(LPCWSTR s) throw()
{
unsigned len = MyStringLen(s) + 1;
if (len >= Size)
return false;
MyStringCopy(Buf, s);
Buf += len;
Size -= len;
return true;
}
static FString GetLastPart(CFSTR path)
{
int i = MyStringLen(path);
for (; i > 0; i--)
{
FChar c = path[i - 1];
if (c == FCHAR_PATH_SEPARATOR || c == '/')
break;
}
return path + i;
}
static bool CheckNameNum(const UString &name, const wchar_t *reservedName)
{
int len = MyStringLen(reservedName);
if (name.Length() <= len)
return true;
if (name.Left(len).CompareNoCase(reservedName) != 0)
return true;
wchar_t c = name[len];
if (c < L'0' || c > L'9')
return true;
return CheckTail(name, len + 1);
}
BSTR SysAllocString(const OLECHAR *sz)
{
if (sz == 0)
return 0;
UINT strLen = MyStringLen(sz);
UINT len = (strLen + 1) * sizeof(OLECHAR);
void *p = AllocateForBSTR(len + sizeof(UINT));
if (p == 0)
return 0;
*(UINT *)p = strLen;
BSTR bstr = (BSTR)((UINT *)p + 1);
memmove(bstr, sz, len);
return bstr;
}
BSTR SysAllocString(const OLECHAR *sz)
{
if (sz == 0)
return 0;
UINT strLen = MyStringLen(sz);
UINT len = (strLen + 1) * sizeof(OLECHAR);
void *p = AllocateForBSTR(len + sizeof(UINT));
if (p == 0)
return 0;
*(UINT *)p = strLen * sizeof(OLECHAR); // FIXED
void * bstr = (void *)((UINT *)p + 1);
memmove(bstr, sz, len); // sz does not always have "wchar_t" alignment.
return (BSTR)bstr;
}
static void AddTrailingDots(CFSTR oldPath, FString &newPath)
{
int len = MyStringLen(oldPath);
int i;
for (i = len; i > 0 && oldPath[i - 1] == '.'; i--);
if (i == 0 || i == len)
return;
FString oldName = GetLastPart(oldPath);
FString newName = GetLastPart(newPath);
int nonDotsLen = oldName.Length() - (len - i);
if (nonDotsLen == 0 || newName.CompareNoCase(oldName.Left(nonDotsLen)) != 0)
return;
for (; i != len; i++)
newPath += '.';
}
static bool IsSupportedName(const UString &name)
{
for (int i = 0; i < sizeof(g_ReservedNames) / sizeof(g_ReservedNames[0]); i++)
{
const wchar_t *reservedName = g_ReservedNames[i];
int len = MyStringLen(reservedName);
if (name.Length() < len)
continue;
if (name.Left(len).CompareNoCase(reservedName) != 0)
continue;
if (!CheckTail(name, len))
return false;
}
if (!CheckNameNum(name, L"COM"))
return false;
return CheckNameNum(name, L"LPT");
}
CDynLimBuf &CDynLimBuf::operator+=(const char *s) throw()
{
if (_error)
return *this;
unsigned len = MyStringLen(s);
size_t rem = _sizeLimit - _pos;
if (rem < len)
{
len = (unsigned)rem;
_error = true;
}
if (_size - _pos < len)
{
size_t n = _pos + len;
if (n - _size < _size)
{
n = _sizeLimit;
if (n - _size > _size)
n = _size * 2;
}
Byte *newBuf = (Byte *)MyAlloc(n);
if (!newBuf)
{
_error = true;
return *this;
}
memcpy(newBuf, _chars, _pos);
MyFree(_chars);
_chars = newBuf;
_size = n;
}
memcpy(_chars + _pos, s, len);
_pos += len;
return *this;
}
bool GetLongPathBase(LPCWSTR s, UString &res)
{
res.Empty();
int len = MyStringLen(s);
wchar_t c = s[0];
if (len < 1 || c == L'\\' || c == L'.' && (len == 1 || len == 2 && s[1] == L'.'))
return true;
UString curDir;
bool isAbs = false;
if (len > 3)
isAbs = (s[1] == L':' && s[2] == L'\\' && (c >= L'a' && c <= L'z' || c >= L'A' && c <= L'Z'));
if (!isAbs)
{
DWORD needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, curDir.GetBuffer(MAX_PATH + 1));
curDir.ReleaseBuffer();
if (needLength == 0 || needLength > MAX_PATH)
return false;
if (curDir[curDir.Length() - 1] != L'\\')
curDir += L'\\';
}
res = UString(L"\\\\?\\") + curDir + s;
return true;
}
// if string contains switch then function updates switch structures
// out: (string is a switch)
bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
{
int len = s.Length();
if (len == 0)
return false;
int pos = 0;
if (!IsItSwitchChar(s[pos]))
return false;
while(pos < len)
{
if (IsItSwitchChar(s[pos]))
pos++;
const int kNoLen = -1;
int matchedSwitchIndex = 0; // GCC Warning
int maxLen = kNoLen;
for(int switchIndex = 0; switchIndex < _numSwitches; switchIndex++)
{
int switchLen = MyStringLen(switchForms[switchIndex].IDString);
if (switchLen <= maxLen || pos + switchLen > len)
continue;
UString temp = s + pos;
temp = temp.Left(switchLen);
if(temp.CompareNoCase(switchForms[switchIndex].IDString) == 0)
// if(_strnicmp(switchForms[switchIndex].IDString, LPCSTR(s) + pos, switchLen) == 0)
{
matchedSwitchIndex = switchIndex;
maxLen = switchLen;
}
}
if (maxLen == kNoLen)
throw "maxLen == kNoLen";
CSwitchResult &matchedSwitch = _switches[matchedSwitchIndex];
const CSwitchForm &switchForm = switchForms[matchedSwitchIndex];
if ((!switchForm.Multi) && matchedSwitch.ThereIs)
throw "switch must be single";
matchedSwitch.ThereIs = true;
pos += maxLen;
int tailSize = len - pos;
NSwitchType::EEnum type = switchForm.Type;
switch(type)
{
case NSwitchType::kPostMinus:
{
if (tailSize == 0)
matchedSwitch.WithMinus = false;
else
{
matchedSwitch.WithMinus = (s[pos] == kSwitchMinus);
if (matchedSwitch.WithMinus)
pos++;
}
break;
}
case NSwitchType::kPostChar:
{
if (tailSize < switchForm.MinLen)
throw "switch is not full";
UString set = switchForm.PostCharSet;
const int kEmptyCharValue = -1;
if (tailSize == 0)
matchedSwitch.PostCharIndex = kEmptyCharValue;
else
{
int index = set.Find(s[pos]);
if (index < 0)
matchedSwitch.PostCharIndex = kEmptyCharValue;
else
{
matchedSwitch.PostCharIndex = index;
pos++;
}
}
break;
}
case NSwitchType::kLimitedPostString:
case NSwitchType::kUnLimitedPostString:
{
int minLen = switchForm.MinLen;
if (tailSize < minLen)
throw "switch is not full";
if (type == NSwitchType::kUnLimitedPostString)
{
matchedSwitch.PostStrings.Add(s.Mid(pos));
return true;
}
int maxLen = switchForm.MaxLen;
UString stringSwitch = s.Mid(pos, minLen);
pos += minLen;
for(int i = minLen; i < maxLen && pos < len; i++, pos++)
{
wchar_t c = s[pos];
if (IsItSwitchChar(c))
break;
stringSwitch += c;
}
matchedSwitch.PostStrings.Add(stringSwitch);
break;
}
case NSwitchType::kSimple:
break;
}
}
return true;
}
// if (s) contains switch then function updates switch structures
// out: true, if (s) is a switch
bool CParser::ParseString(const UString &s, const CSwitchForm *switchForms)
{
if (s.IsEmpty() || !IsItSwitchChar(s[0]))
return false;
unsigned pos = 1;
unsigned switchIndex = 0;
int maxLen = -1;
for (unsigned i = 0; i < _numSwitches; i++)
{
const char *key = switchForms[i].Key;
unsigned switchLen = MyStringLen(key);
if ((int)switchLen <= maxLen || pos + switchLen > s.Len())
continue;
if (IsString1PrefixedByString2_NoCase((const wchar_t *)s + pos, key))
{
switchIndex = i;
maxLen = switchLen;
}
}
if (maxLen < 0)
{
ErrorMessage = "Unknown switch:";
return false;
}
pos += maxLen;
CSwitchResult &sw = _switches[switchIndex];
const CSwitchForm &form = switchForms[switchIndex];
if (!form.Multi && sw.ThereIs)
{
ErrorMessage = "Multiple instances for switch:";
return false;
}
sw.ThereIs = true;
int rem = s.Len() - pos;
if (rem < form.MinLen)
{
ErrorMessage = "Too short switch:";
return false;
}
sw.WithMinus = false;
sw.PostCharIndex = -1;
switch (form.Type)
{
case NSwitchType::kMinus:
if (rem != 0)
{
sw.WithMinus = (s[pos] == '-');
if (sw.WithMinus)
pos++;
}
break;
case NSwitchType::kChar:
if (rem != 0)
{
wchar_t c = s[pos];
if (c <= 0x7F)
{
sw.PostCharIndex = FindCharPosInString(form.PostCharSet, (char)c);
if (sw.PostCharIndex >= 0)
pos++;
}
}
break;
case NSwitchType::kString:
sw.PostStrings.Add((const wchar_t *)s + pos);
return true;
}
if (pos != s.Len())
{
ErrorMessage = "Too long switch:";
return false;
}
return true;
}