//---------------------------------------------------------------------------
intptr_t TInteractiveCustomCommand::PatternLen(const UnicodeString & Command, intptr_t Index)
{
intptr_t Len = 0;
switch (Command[Index + 1])
{
case L'?':
{
const wchar_t * Ptr = Command.c_str() + Index - 1;
const wchar_t * PatternEnd = wcschr(Ptr + 1, L'!');
if (PatternEnd == nullptr)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNTERMINATED, Command[Index + 1], Index));
}
Len = PatternEnd - Ptr + 1;
}
break;
case L'`':
{
const wchar_t * Ptr = Command.c_str() + Index - 1;
const wchar_t * PatternEnd = wcschr(Ptr + 2, L'`');
if (PatternEnd == nullptr)
{
throw Exception(FMTLOAD(CUSTOM_COMMAND_UNTERMINATED, Command[Index + 1], Index));
}
Len = PatternEnd - Ptr + 1;
}
break;
default:
Len = FChildCustomCommand->PatternLen(Command, Index);
break;
}
return Len;
}
BOOST_FIXTURE_TEST_CASE(test14, base_fixture_t)
{
{
UnicodeString str = ::StringReplace(L"AA", L"A", L"B", TReplaceFlags() << rfReplaceAll);
BOOST_CHECK_EQUAL(W2MB(str.c_str()).c_str(), "BB");
}
{
UnicodeString str = ::AnsiReplaceStr(L"AA", L"A", L"B");
BOOST_CHECK_EQUAL(W2MB(str.c_str()).c_str(), "BB");
}
{
UnicodeString str = L"ABC";
BOOST_CHECK_EQUAL(::Pos(str, L"DEF"), 0);
BOOST_CHECK_EQUAL(::Pos(str, L"AB"), 1);
BOOST_CHECK_EQUAL(::Pos(str, L"BC"), 2);
BOOST_CHECK_EQUAL(::AnsiPos(str, 'D'), 0);
BOOST_CHECK_EQUAL(::AnsiPos(str, 'A'), 1);
BOOST_CHECK_EQUAL(::AnsiPos(str, 'B'), 2);
}
{
UnicodeString str = ::LowerCase(L"AA");
BOOST_CHECK_EQUAL(W2MB(str.c_str()).c_str(), "aa");
}
{
UnicodeString str = ::UpperCase(L"aa");
BOOST_CHECK_EQUAL(W2MB(str.c_str()).c_str(), "AA");
}
{
UnicodeString str = ::Trim(L" aa ");
BOOST_CHECK_EQUAL(W2MB(str.c_str()).c_str(), "aa");
}
}
UnicodeString TStrings::GetTextStr() const
{
UnicodeString Result;
intptr_t Count = GetCount();
intptr_t Size = 0;
UnicodeString LB = sLineBreak;
for (intptr_t I = 0; I < Count; I++)
{
Size += GetString(I).Length() + LB.Length();
}
Result.SetLength(Size);
wchar_t * P = const_cast<wchar_t *>(Result.c_str());
for (intptr_t I = 0; I < Count; I++)
{
UnicodeString S = GetString(I);
intptr_t L = S.Length() * sizeof(wchar_t);
if (L != 0)
{
memmove(P, S.c_str(), L);
P += S.Length();
}
L = LB.Length() * sizeof(wchar_t);
if (L != 0)
{
memmove(P, LB.c_str(), L);
P += LB.Length();
}
}
return Result;
}
void TStrings::SetTextStr(const UnicodeString & Text)
{
BeginUpdate();
SCOPE_EXIT
{
EndUpdate();
};
{
Clear();
const wchar_t * P = Text.c_str();
if (P != nullptr)
{
while (*P != 0x00)
{
const wchar_t * Start = P;
while (!((*P == 0x00) || (*P == 0x0A) || (*P == 0x0D)))
{
P++;
}
UnicodeString S;
S.SetLength(P - Start);
memmove(const_cast<wchar_t *>(S.c_str()), Start, (P - Start) * sizeof(wchar_t));
Add(S);
if (*P == 0x0D) { P++; }
if (*P == 0x0A) { P++; }
}
}
}
}
bool TRegistry::OpenKey(const UnicodeString & Key, bool CanCreate)
{
bool Result = false;
UnicodeString S = Key;
bool Relative = Classes::IsRelative(S);
// if (!Relative) S.erase(0, 1); // Delete(S, 1, 1);
HKEY TempKey = 0;
if (!CanCreate || S.IsEmpty())
{
Result = RegOpenKeyEx(GetBaseKey(Relative), S.c_str(), 0,
FAccess, &TempKey) == ERROR_SUCCESS;
}
else
{
Result = RegCreateKeyEx(GetBaseKey(Relative), S.c_str(), 0, nullptr,
REG_OPTION_NON_VOLATILE, FAccess, nullptr, &TempKey, nullptr) == ERROR_SUCCESS;
}
if (Result)
{
if ((GetCurrentKey() != 0) && Relative)
{
S = FCurrentPath + L'\\' + S;
}
ChangeKey(TempKey, S);
}
return Result;
}
UnicodeString Format(const wchar_t * Format, va_list Args)
{
UnicodeString Result;
if (Format && *Format)
{
intptr_t Len = _vscwprintf(Format, Args);
Result.SetLength(Len + 1);
// vswprintf(Buf, Len + 1, Format, args);
vswprintf(const_cast<wchar_t *>(Result.c_str()), Len + 1, Format, Args);
}
return Result.c_str();
}
BOOST_FIXTURE_TEST_CASE(test21, base_fixture_t)
{
BOOST_TEST_MESSAGE("RAND_MAX = " << RAND_MAX);
for (int i = 0; i < 10; i++)
{
BOOST_TEST_MESSAGE("rand() = " << rand());
BOOST_TEST_MESSAGE("random(256) = " << random(256));
}
UnicodeString enc = ::EncryptPassword(L"1234ABC", L"234556");
BOOST_TEST_MESSAGE("enc = " << W2MB(enc.c_str()).c_str());
UnicodeString dec = ::DecryptPassword(enc, L"234556");
BOOST_TEST_MESSAGE("dec = " << W2MB(dec.c_str()).c_str());
BOOST_CHECK(dec == L"1234ABC");
}
UnicodeString ItemsFormatString(const UnicodeString & SingleItemFormat,
const UnicodeString & MultiItemsFormat, intptr_t Count, const UnicodeString & FirstItem)
{
UnicodeString Result;
if (Count == 1)
{
Result = FORMAT(SingleItemFormat.c_str(), FirstItem.c_str());
}
else
{
Result = FORMAT(MultiItemsFormat.c_str(), Count);
}
return Result;
}
UnicodeString ExpandFileName(const UnicodeString & FileName)
{
UnicodeString Result;
UnicodeString Buf(MAX_PATH, 0);
intptr_t Size = GetFullPathNameW(FileName.c_str(), static_cast<DWORD>(Buf.Length() - 1),
reinterpret_cast<LPWSTR>(const_cast<wchar_t *>(Buf.c_str())), nullptr);
if (Size > Buf.Length())
{
Buf.SetLength(Size);
Size = ::GetFullPathNameW(FileName.c_str(), static_cast<DWORD>(Buf.Length() - 1),
reinterpret_cast<LPWSTR>(const_cast<wchar_t *>(Buf.c_str())), nullptr);
}
return UnicodeString(Buf.c_str(), Size);
}
//---------------------------------------------------------------------------
void __fastcall TMediaDlgBox::GridSetEditText(TObject *Sender, int ACol,
int ARow, const UnicodeString Value)
{
double d;
if( Grid->EditorMode == TRUE ) return;
if( ARow ){
ARow--;
switch(ACol){
case 1: // DIE（導）
if( Calc(d, AnsiString(Value).c_str()) == TRUE){
lenv.rel[ARow] = d;
GridNewLine(ARow);
}
break;
case 2: // COND（誘電）
if( Calc(d, AnsiString(Value).c_str()) == TRUE){
lenv.cond[ARow] = d/1000.0;
GridNewLine(ARow);
}
break;
case 3: // XorR(m)
if( *Value.c_str() ){
if( Calc(d, AnsiString(Value).c_str()) == TRUE){
lenv.intval[ARow] = d;
GridNewLine(ARow);
}
}
else if( ARow >= (lenv.mmax - 1) ){
lenv.intval[ARow] = NULLV;
GridNewLine(ARow);
}
break;
case 4: // H(m)
if( *Value.c_str() ){
if( Calc(d, AnsiString(Value).c_str()) == TRUE){
lenv.height[ARow] = d;
GridNewLine(ARow);
}
}
else if( ARow >= (lenv.mmax - 1) ){
lenv.height[ARow] = NULLV;
GridNewLine(ARow);
}
break;
}
}
}
static void tokenize(const UnicodeString & str, rde::vector<UnicodeString> & tokens,
const UnicodeString & delimiters = L" ", const bool trimEmpty = false)
{
intptr_t lastPos = 0;
while (true)
{
intptr_t pos = str.FindFirstOf(delimiters.c_str(), lastPos);
if (pos == NPOS)
{
pos = str.Length();
if (pos != lastPos || !trimEmpty)
{
tokens.push_back(
UnicodeString(str.data() + lastPos, pos - lastPos));
}
break;
}
else
{
if (pos != lastPos || !trimEmpty)
{
tokens.push_back(
UnicodeString(str.data() + lastPos, pos - lastPos));
}
}
lastPos = pos + 1;
}
}
BOOST_FIXTURE_TEST_CASE(test19, base_fixture_t)
{
UnicodeString ProgramsFolder;
::SpecialFolderLocation(CSIDL_PROGRAM_FILES, ProgramsFolder);
BOOST_TEST_MESSAGE("ProgramsFolder = " << W2MB(ProgramsFolder.c_str()).c_str());
BOOST_CHECK(ProgramsFolder.Length() > 0);
}
bool __fastcall TVersionInfo::QueryValue(const UnicodeString& SubBlock, LPVOID& Buffer,
unsigned int& BufferLength) const
{
assert(FFileVersionInfoData != NULL);
return VerQueryValue(FFileVersionInfoData, SubBlock.c_str(), &Buffer, &BufferLength);
}
//---------------------------------------------------------------------
void TCopyParamList::ValidateName(const UnicodeString & Name)
{
if (Name.LastDelimiter(FInvalidChars) > 0)
{
throw Exception(FMTLOAD(ITEM_NAME_INVALID, Name.c_str(), FInvalidChars.c_str()));
}
}
//---------------------------------------------------------------------------
static bool __fastcall GetResource(
const UnicodeString ResName, void *& Content, unsigned long & Size)
{
HRSRC Resource = FindResourceEx(HInstance, RT_RCDATA, ResName.c_str(),
MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL));
bool Result = (Resource != NULL);
if (Result)
{
Size = SizeofResource(HInstance, Resource);
if (!Size)
{
throw Exception(FORMAT(L"Cannot get size of resource %s", (ResName)));
}
Content = LoadResource(HInstance, Resource);
if (!Content)
{
throw Exception(FORMAT(L"Cannot read resource %s", (ResName)));
}
Content = LockResource(Content);
if (!Content)
{
throw Exception(FORMAT(L"Cannot lock resource %s", (ResName)));
}
}
return Result;
}
UnicodeString UpperCase(const UnicodeString & Str)
{
std::wstring Result(Str.c_str(), Str.Length());
// Result.SetLength(Str.Length());
std::transform(Result.begin(), Result.end(), Result.begin(), ::toupper);
return Result;
}
UnicodeString ExpandEnvVars(const UnicodeString & Str)
{
wchar_t buf[MAX_PATH];
intptr_t size = ExpandEnvironmentStringsW(Str.c_str(), buf, static_cast<DWORD>(MAX_PATH - 1));
UnicodeString Result = UnicodeString(buf, size - 1);
return Result;
}
bool TOptions::SwitchValue(const UnicodeString & Switch, bool Default, bool DefaultOnNonExistence)
{
bool Result = false;
int64_t IntValue = 0;
UnicodeString Value;
if (!FindSwitch(Switch, Value))
{
Result = DefaultOnNonExistence;
}
else if (Value.IsEmpty())
{
Result = Default;
}
else if (::SameText(Value, L"on"))
{
Result = true;
}
else if (::SameText(Value, L"off"))
{
Result = false;
}
else if (::TryStrToInt(Value, IntValue))
{
Result = (IntValue != 0);
}
else
{
throw Exception(FMTLOAD(URL_OPTION_BOOL_VALUE_ERROR, Value.c_str()));
}
return Result;
}
void TCopyParamList::ValidateName(const UnicodeString & Name)
{
if (Name.LastDelimiter(CONST_INVALID_CHARS) > 0)
{
throw Exception(FMTLOAD(ITEM_NAME_INVALID, Name.c_str(), CONST_INVALID_CHARS));
}
}
UnicodeString Format(const wchar_t * Format, ...)
{
va_list Args;
va_start(Args, Format);
UnicodeString Result = ::Format(Format, Args);
va_end(Args);
return Result.c_str();
}
void DoTraceFmt(const wchar_t * SourceFile, const wchar_t * Func,
uintptr_t Line, const wchar_t * AFormat, va_list Args)
{
DebugAssert(IsTracing);
UnicodeString Message = FormatV(AFormat, Args);
DoTrace(SourceFile, Func, Line, Message.c_str());
}
bool TRegistryStorage::Copy(TRegistryStorage * Storage)
{
TRegistry * Registry = Storage->FRegistry;
bool Result = true;
std::unique_ptr<TStrings> Names(new TStringList());
try__finally
{
rde::vector<uint8_t> Buffer(1024);
Registry->GetValueNames(Names.get());
intptr_t Index = 0;
while ((Index < Names->GetCount()) && Result)
{
UnicodeString Name = MungeStr(Names->GetString(Index), GetForceAnsi());
DWORD Size = static_cast<DWORD>(Buffer.size());
DWORD Type;
int RegResult = 0;
do
{
RegResult = ::RegQueryValueEx(Registry->GetCurrentKey(), Name.c_str(), nullptr,
&Type, &Buffer[0], &Size);
if (RegResult == ERROR_MORE_DATA)
{
Buffer.resize(Size);
}
}
while (RegResult == ERROR_MORE_DATA);
Result = (RegResult == ERROR_SUCCESS);
if (Result)
{
RegResult = ::RegSetValueEx(FRegistry->GetCurrentKey(), Name.c_str(), 0, Type,
&Buffer[0], Size);
Result = (RegResult == ERROR_SUCCESS);
}
++Index;
}
}
__finally
{
/*
delete Names;
*/
};
return Result;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
FILE * OpenFile(const UnicodeString & LogFileName, TSessionData * SessionData, bool Append, UnicodeString & NewFileName)
{
FILE * Result;
UnicodeString ANewFileName = StripPathQuotes(GetExpandedLogFileName(LogFileName, SessionData));
// Result = _wfopen(ANewFileName.c_str(), (Append ? L"a" : L"w"));
Result = _fsopen(W2MB(ANewFileName.c_str()).c_str(),
Append ? "a" : "w", SH_DENYWR); // _SH_DENYNO); //
if (Result != nullptr)
{
setvbuf(Result, nullptr, _IONBF, BUFSIZ);
NewFileName = ANewFileName;
}
else
{
throw Exception(FMTLOAD(LOG_OPENERROR, ANewFileName.c_str()));
}
return Result;
}
HKEY TRegistry::GetKey(const UnicodeString & Key)
{
UnicodeString S = Key;
bool Relative = Classes::IsRelative(S);
// if not Relative then Delete(S, 1, 1);
HKEY Result = 0;
RegOpenKeyEx(GetBaseKey(Relative), S.c_str(), 0, FAccess, &Result);
return Result;
}
//---------------------------------------------------------------------------
UnicodeString __fastcall TConfiguration::BannerHash(const UnicodeString & Banner)
{
RawByteString Result;
Result.SetLength(16);
md5checksum(
reinterpret_cast<const char*>(Banner.c_str()), Banner.Length() * sizeof(wchar_t),
(unsigned char*)Result.c_str());
return BytesToHex(Result);
}
UnicodeString TConfiguration::BannerHash(const UnicodeString & Banner) const
{
RawByteString Result;
Result.SetLength(16);
md5checksum(
reinterpret_cast<const char *>(Banner.c_str()), static_cast<int>(Banner.Length() * sizeof(wchar_t)),
reinterpret_cast<uint8_t *>(const_cast<char *>(Result.c_str())));
return BytesToHex(Result);
}
uintptr_t GetSpeedLimit(const UnicodeString & Text)
{
uintptr_t Speed = 0;
if (!TryGetSpeedLimit(Text, Speed))
{
throw Exception(FMTLOAD(SPEED_INVALID, Text.c_str()));
}
return Speed;
}
//---------------------------------------------------------------------------
void __fastcall OpenBrowser(UnicodeString URL)
{
UnicodeString HomePageUrl = LoadStr(HOMEPAGE_URL);
if (SameText(URL.SubString(1, HomePageUrl.Length()), HomePageUrl))
{
URL = CampaignUrl(URL);
}
ShellExecute(Application->Handle, L"open", URL.c_str(), NULL, NULL, SW_SHOWNORMAL);
}
bool TRegistry::GetDataInfo(const UnicodeString & ValueName, TRegDataInfo & Value) const
{
DWORD DataType;
ClearStruct(Value);
bool Result = (RegQueryValueEx(GetCurrentKey(), ValueName.c_str(), nullptr, &DataType, nullptr,
&Value.DataSize) == ERROR_SUCCESS);
Value.RegData = DataTypeToRegData(DataType);
return Result;
}
UnicodeString GetPersonalFolder()
{
UnicodeString Result;
SpecialFolderLocation(CSIDL_PERSONAL, Result);
if (IsWine())
{
UnicodeString WineHostHome;
int Len = ::GetEnvironmentVariable(L"WINE_HOST_HOME", nullptr, 0);
if (Len > 0)
{
WineHostHome.SetLength(Len - 1);
::GetEnvironmentVariable(L"WINE_HOST_HOME", const_cast<LPWSTR>(WineHostHome.c_str()), Len);
}
if (!WineHostHome.IsEmpty())
{
UnicodeString WineHome = L"Z:" + core::ToUnixPath(WineHostHome);
if (::DirectoryExists(WineHome))
{
Result = WineHome;
}
}
else
{
// Should we use WinAPI GetUserName() instead?
UnicodeString UserName;
int Len = ::GetEnvironmentVariable(L"USERNAME", nullptr, 0);
if (Len > 0)
{
UserName.SetLength(Len - 1);
::GetEnvironmentVariable(L"USERNAME", const_cast<LPWSTR>(UserName.c_str()), Len);
}
if (!UserName.IsEmpty())
{
UnicodeString WineHome = L"Z:\\home\\" + UserName;
if (::DirectoryExists(WineHome))
{
Result = WineHome;
}
}
}
}
return Result;
}
