AString Flags64ToString(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt64 flag = (UInt64)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
{
if (!s.IsEmpty())
s += ' ';
s += p.Name;
}
}
flags &= ~flag;
}
if (flags != 0)
{
if (!s.IsEmpty())
s += ' ';
{
char sz[32];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt64ToHex(flags, sz + 2);
s += sz;
}
}
return s;
}
AString FlagsToString(const char **names, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
UInt32 flag = (UInt32)1 << i;
if ((flags & flag) != 0)
{
const char *name = names[i];
if (name != 0 && name[0] != 0)
{
if (!s.IsEmpty())
s += ' ';
s += name;
flags &= ~flag;
}
}
}
if (flags != 0)
{
if (!s.IsEmpty())
s += ' ';
s += GetHex(flags);
}
return s;
}
AString GetOpenArcErrorMessage(UInt32 errorFlags)
{
AString s;
for (unsigned i = 0; i < ARRAY_SIZE(k_ErrorFlagsMessages); i++)
{
UInt32 f = (1 << i);
if ((errorFlags & f) == 0)
continue;
const char *m = k_ErrorFlagsMessages[i];
if (!s.IsEmpty())
s += '\n';
s += m;
errorFlags &= ~f;
}
if (errorFlags != 0)
{
char sz[16];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt32ToHex(errorFlags, sz + 2);
if (!s.IsEmpty())
s += '\n';
s += sz;
}
return s;
}
AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt32 flag = (UInt32)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
{
if (!s.IsEmpty())
s += ' ';
s += p.Name;
}
}
flags &= ~flag;
}
if (flags != 0)
{
if (!s.IsEmpty())
s += ' ';
s += GetHex(flags);
}
return s;
}
STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
{
COM_TRY_BEGIN
NCOM::CPropVariant prop;
if (_stream)
{
const CVolumeDescriptor &vol = _archive.VolDescs[_archive.MainVolDescIndex];
switch (propID)
{
case kpidComment:
{
AString s;
ADD_STRING("System", SystemId);
ADD_STRING("Volume", VolumeId);
ADD_STRING("VolumeSet", VolumeSetId);
ADD_STRING("Publisher", PublisherId);
ADD_STRING("Preparer", DataPreparerId);
ADD_STRING("Application", ApplicationId);
ADD_STRING("Copyright", CopyrightFileId);
ADD_STRING("Abstract", AbstractFileId);
ADD_STRING("Bib", BibFileId);
prop = s;
break;
}
case kpidCTime: { FILETIME utc; if (vol.CTime.GetFileTime(utc)) prop = utc; break; }
case kpidMTime: { FILETIME utc; if (vol.MTime.GetFileTime(utc)) prop = utc; break; }
}
}
switch (propID)
{
case kpidPhySize: prop = _archive.PhySize; break;
case kpidErrorFlags:
{
UInt32 v = 0;
if (!_archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
if (_archive.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
if (_archive.HeadersError) v |= kpv_ErrorFlags_HeadersError;
prop = v;
break;
}
case kpidError:
{
AString s;
if (_archive.IncorrectBigEndian)
AddErrorMessage(s, "Incorrect big-endian headers");
if (_archive.SelfLinkedDirs)
AddErrorMessage(s, "Self-linked directory");
if (_archive.TooDeepDirs)
AddErrorMessage(s, "Too deep directory levels");
if (!s.IsEmpty())
prop = s;
break;
}
}
prop.Detach(value);
return S_OK;
COM_TRY_END
}
// DependOnNode
//------------------------------------------------------------------------------
/*static*/ bool LinkerNode::DependOnNode( NodeGraph & nodeGraph,
const BFFIterator & iter,
const Function * function,
const AString & nodeName,
Dependencies & nodes )
{
// silently ignore empty nodes
if ( nodeName.IsEmpty() )
{
return true;
}
Node * node = nodeGraph.FindNode( nodeName );
// does it exist?
if ( node != nullptr )
{
// process it
return DependOnNode( iter, function, node, nodes );
}
// node not found - create a new FileNode, assuming we are
// linking against an externally built library
node = nodeGraph.CreateFileNode( nodeName );
nodes.Append( Dependency( node ) );
return true;
}
static bool ReadDataString(LPCWSTR fileName, LPCSTR startID,
LPCSTR endID, AString &stringResult)
{
stringResult.Empty();
NFile::NIO::CInFile inFile;
if (!inFile.Open(fileName))
return false;
const int kBufferSize = (1 << 12);
Byte buffer[kBufferSize];
int signatureStartSize = lstrlenA(startID);
int signatureEndSize = lstrlenA(endID);
UInt32 numBytesPrev = 0;
bool writeMode = false;
UInt64 posTotal = 0;
for (;;)
{
if (posTotal > (1 << 20))
return (stringResult.IsEmpty());
UInt32 numReadBytes = kBufferSize - numBytesPrev;
UInt32 processedSize;
if (!inFile.Read(buffer + numBytesPrev, numReadBytes, processedSize))
return false;
if (processedSize == 0)
return true;
UInt32 numBytesInBuffer = numBytesPrev + processedSize;
UInt32 pos = 0;
for (;;)
{
if (writeMode)
{
if (pos > numBytesInBuffer - signatureEndSize)
break;
if (memcmp(buffer + pos, endID, signatureEndSize) == 0)
return true;
char b = buffer[pos];
if (b == 0)
return false;
stringResult += b;
pos++;
}
else
{
if (pos > numBytesInBuffer - signatureStartSize)
break;
if (memcmp(buffer + pos, startID, signatureStartSize) == 0)
{
writeMode = true;
pos += signatureStartSize;
}
else
pos++;
}
}
numBytesPrev = numBytesInBuffer - pos;
posTotal += pos;
memmove(buffer, buffer + pos, numBytesPrev);
}
}
UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
{
if (!srcString.IsEmpty())
{
UString resultString;
const char * path = &srcString[0];
CFStringRef cfpath = CFStringCreateWithCString(NULL,path,kCFStringEncodingUTF8);
if (cfpath)
{
CFMutableStringRef cfpath2 = CFStringCreateMutableCopy(NULL,0,cfpath);
CFRelease(cfpath);
CFStringNormalize(cfpath2,kCFStringNormalizationFormC);
size_t n = CFStringGetLength(cfpath2);
for(size_t i = 0 ; i< n ;i++) {
UniChar uc = CFStringGetCharacterAtIndex(cfpath2,i);
resultString += (wchar_t)uc; // FIXME
}
CFRelease(cfpath2);
return resultString;
}
}
UString resultString;
for (int i = 0; i < srcString.Len(); i++)
resultString += wchar_t(srcString[i] & 255);
return resultString;
}
NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream)
{
(*outStream) << kFirstQuestionMessage;
for (;;)
{
(*outStream) << kHelpQuestionMessage;
outStream->Flush();
AString scannedString = g_StdIn.ScanStringUntilNewLine();
scannedString.Trim();
if (!scannedString.IsEmpty())
switch(
::MyCharUpper(
#ifdef UNDER_CE
(wchar_t)
#endif
scannedString[0]))
{
case kYes:
return NUserAnswerMode::kYes;
case kNo:
return NUserAnswerMode::kNo;
case kYesAll:
return NUserAnswerMode::kYesAll;
case kNoAll:
return NUserAnswerMode::kNoAll;
case kAutoRenameAll:
return NUserAnswerMode::kAutoRenameAll;
case kQuit:
return NUserAnswerMode::kQuit;
}
}
}
// AStringAssignment
//------------------------------------------------------------------------------
void TestAString::AStringAssignment() const
{
AString str;
str = "test";
TEST_ASSERT( str.GetLength() == 4 );
TEST_ASSERT( str.GetReserved() >= 4 );
TEST_ASSERT( str.IsEmpty() == false );
TEST_ASSERT( str.MemoryMustBeFreed() == true );
AString str2;
str2 = str;
TEST_ASSERT( str2.GetLength() == 4 );
TEST_ASSERT( str2.GetReserved() >= 4 );
TEST_ASSERT( str2.IsEmpty() == false );
TEST_ASSERT( str2.MemoryMustBeFreed() == true );
const char * testData = "hellozzzzzzzzz";
AString str3;
str3.Assign( testData, testData + 5 );
TEST_ASSERT( str3.GetLength() == 5 );
TEST_ASSERT( str3.GetReserved() >= 5 );
TEST_ASSERT( str3.IsEmpty() == false );
TEST_ASSERT( str3.MemoryMustBeFreed() == true );
// assign empty
{
AString dst;
dst.Assign( AString::GetEmpty() );
}
{
AString dst;
dst.Assign( AString::GetEmpty().Get(), AString::GetEmpty().Get() );
}
}
void MultiByteToUnicodeString2(UString &dest, const AString &src, UINT /* codePage */)
{
dest.Empty();
if (src.IsEmpty())
return;
size_t limit = ((size_t)src.Len() + 1) * 2;
wchar_t *d = dest.GetBuf((unsigned)limit);
size_t len = mbstowcs(d, src, limit);
if (len != (size_t)-1)
{
dest.ReleaseBuf_SetEnd((unsigned)len);
return;
}
{
unsigned i;
const char *s = (const char *)src;
for (i = 0;;)
{
Byte c = (Byte)s[i];
if (c == 0)
break;
d[i++] = (wchar_t)c;
}
d[i] = 0;
dest.ReleaseBuf_SetLen(i);
}
}
// CreateTempFile
//------------------------------------------------------------------------------
/*static*/ bool WorkerThread::CreateTempFile( const AString & tmpFileName,
FileStream & file )
{
ASSERT( tmpFileName.IsEmpty() == false );
ASSERT( PathUtils::IsFullPath( tmpFileName ) );
return file.Open( tmpFileName.Get(), FileStream::WRITE_ONLY );
}
NUserAnswerMode::EEnum ScanUserYesNoAllQuit(CStdOutStream *outStream)
{
if (outStream)
*outStream << kFirstQuestionMessage;
for (;;)
{
if (outStream)
{
*outStream << kHelpQuestionMessage;
outStream->Flush();
}
AString scannedString = g_StdIn.ScanStringUntilNewLine();
scannedString.Trim();
if (!scannedString.IsEmpty())
switch (::MyCharLower_Ascii(scannedString[0]))
{
case kYes: return NUserAnswerMode::kYes;
case kNo: return NUserAnswerMode::kNo;
case kYesAll: return NUserAnswerMode::kYesAll;
case kNoAll: return NUserAnswerMode::kNoAll;
case kAutoRenameAll: return NUserAnswerMode::kAutoRenameAll;
case kQuit: return NUserAnswerMode::kQuit;
}
}
}
// WritePGItem
//------------------------------------------------------------------------------
void VSProjectGenerator::WritePGItem( const char * xmlTag, const AString & value )
{
if ( value.IsEmpty() )
{
return;
}
Write( " <%s>%s</%s>\n", xmlTag, value.Get(), xmlTag );
}
static void AddSpaceAndString(AString &res, const AString &newString)
{
if (!newString.IsEmpty())
{
res.Add_Space_if_NotEmpty();
res += newString;
}
}
REGISTER_TESTS_END
// AStringConstructors
//------------------------------------------------------------------------------
void TestAString::AStringConstructors() const
{
{
// AString with no arguments
AString empty;
TEST_ASSERT( empty.GetLength() == 0 );
TEST_ASSERT( empty.GetReserved() == 0 );
TEST_ASSERT( empty.IsEmpty() == true );
TEST_ASSERT( empty.MemoryMustBeFreed() == false );
}
{
// AString with reserve capacity argument
AString empty( 16 );
TEST_ASSERT( empty.GetLength() == 0 );
TEST_ASSERT( empty.GetReserved() == 16 );
TEST_ASSERT( empty.IsEmpty() == true );
TEST_ASSERT( empty.MemoryMustBeFreed() == true );
}
{
// AString from char *
AString fromCharStar( "hello" );
TEST_ASSERT( fromCharStar.GetLength() == 5 );
TEST_ASSERT( fromCharStar.GetReserved() >= 5 );
TEST_ASSERT( fromCharStar.IsEmpty() == false );
TEST_ASSERT( fromCharStar.MemoryMustBeFreed() == true );
// AString from AString
AString fromAString( fromCharStar );
TEST_ASSERT( fromAString.GetLength() == 5 );
TEST_ASSERT( fromAString.GetReserved() >= 5 );
TEST_ASSERT( fromAString.IsEmpty() == false );
TEST_ASSERT( fromAString.MemoryMustBeFreed() == true );
}
{
const char * hello = "hellohellohello";
AString fromCharStarPair( hello, hello + 5 );
TEST_ASSERT( fromCharStarPair.GetLength() == 5 );
TEST_ASSERT( fromCharStarPair.GetReserved() >= 5 );
TEST_ASSERT( fromCharStarPair.IsEmpty() == false );
TEST_ASSERT( fromCharStarPair.MemoryMustBeFreed() == true );
}
}
AString GetName() const
{
AString dirName = GetDirName();
const char kDirSeparator = CHAR_PATH_SEPARATOR; // '\\';
// check kDirSeparator in Linux
dirName.Replace((char)(unsigned char)0xFF, kDirSeparator);
if (!dirName.IsEmpty() && dirName.Back() != kDirSeparator)
dirName += kDirSeparator;
return dirName + GetFileName();
}
/** ****************************************************************************************
* Clears all data stored, resets all values.
******************************************************************************************/
void Clear()
{
ALIB_ASSERT( Value == 0 );
ALIB_ASSERT( Path.IsEmpty() );
for ( auto child : Childs )
delete child;
Childs.clear();
}
static AString SectFlagsToString(UInt32 flags)
{
AString res = TypeToString(g_SectTypes, ARRAY_SIZE(g_SectTypes), flags & SECT_TYPE_MASK);
AString s = FlagsToString(g_Flags, ARRAY_SIZE(g_Flags), flags & SECT_ATTR_MASK);
if (!s.IsEmpty())
{
res += ' ';
res += s;
}
return res;
}
bool HasTailSlash(const AString &name, UINT codePage)
{
if (name.IsEmpty())
return false;
LPCSTR prev =
#ifdef _WIN32
CharPrevExA((WORD)codePage, name, &name[name.Length()], 0);
#else
(LPCSTR)(name) + (name.Length() - 1);
#endif
return (*prev == '/');
}
static AString SectFlagsToString(UInt32 flags)
{
AString res = TypeToString(g_SectTypes, sizeof(g_SectTypes) / sizeof(g_SectTypes[0]),
flags & MACH_SECT_TYPE_MASK);
AString s = FlagsToString(g_Flags, sizeof(g_Flags) / sizeof(g_Flags[0]),
flags & MACH_SECT_ATTR_MASK);
if (!s.IsEmpty())
{
res += ' ';
res += s;
}
return res;
}
AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
if (p.Value == value)
s = p.Name;
}
if (s.IsEmpty())
s = GetHex(value);
return s;
}
void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
if (p.Value == value)
s = p.Name;
}
if (s.IsEmpty())
s = GetHex(value);
StringToProp(s, prop);
}
UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
{
UString resultString;
if (!srcString.IsEmpty())
{
int numChars = MultiByteToWideChar(codePage, 0, srcString,
srcString.Length(), resultString.GetBuffer(srcString.Length()),
srcString.Length() + 1);
if (numChars == 0)
throw 282228;
resultString.ReleaseBuffer(numChars);
}
return resultString;
}
static void AddPropertyString(InfoPanelLine *lines, int &numItems, PROPID propID, const wchar_t *name,
const NCOM::CPropVariant &prop)
{
if (prop.vt != VT_EMPTY)
{
AString val = PropToString2(prop, propID);
if (!val.IsEmpty())
{
InfoPanelLine &item = lines[numItems++];
COPY_STR_LIMITED(item.Text, GetNameOfProp2(propID, name));
COPY_STR_LIMITED(item.Data, val);
}
}
}
static void SplitString(const AString &srcString, AStringVector &destStrings)
{
destStrings.Clear();
AString string;
int len = srcString.Length();
if (len == 0)
return;
for (int i = 0; i < len; i++)
{
char c = srcString[i];
if (c == '\n')
{
if (!string.IsEmpty())
{
destStrings.Add(string);
string.Empty();
}
}
else
string += c;
}
if (!string.IsEmpty())
destStrings.Add(string);
}
UString MultiByteToUnicodeString(const AString &srcString, UINT codePage)
{
if ((global_use_utf16_conversion) && (!srcString.IsEmpty()))
{
UString resultString;
bool bret = ConvertUTF8ToUnicode(srcString,resultString);
if (bret) return resultString;
}
UString resultString;
for (int i = 0; i < srcString.Len(); i++)
resultString += wchar_t(srcString[i] & 255);
return resultString;
}
IMP_IInArchive_Props
IMP_IInArchive_ArcProps
#define PARSE_NUM(_num_, _dest_) \
{ const char *end; _dest_ = ConvertStringToUInt32(p, &end); \
if ((unsigned)(end - p) != _num_) return 0; p += _num_ + 1; }
static bool ParseUInt64(const CXmlItem &item, const char *name, UInt64 &res)
{
const AString s = item.GetSubStringForTag(name);
if (s.IsEmpty())
return false;
const char *end;
res = ConvertStringToUInt64(s, &end);
return *end == 0;
}
bool HasTailSlash(const AString &name, UINT
#if defined(_WIN32) && !defined(UNDER_CE)
codePage
#endif
)
{
if (name.IsEmpty())
return false;
LPCSTR prev =
#if defined(_WIN32) && !defined(UNDER_CE)
CharPrevExA((WORD)codePage, name, &name[name.Len()], 0);
#else
(LPCSTR)(name) + (name.Len() - 1);
#endif
return (*prev == '/');
}
bool HasTailSlash(const AString &name, UINT codePage)
{
if (name.IsEmpty())
return false;
LPCSTR prev =
#if defined(_WIN32) && !defined(UNDER_CE)
#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
(LPCSTR)(name) + (name.Length() - 1);
#else
CharPrevExA((WORD)codePage, name, &name[name.Length()], 0);
#endif
#else
(LPCSTR)(name) + (name.Length() - 1);
#endif
return (*prev == '/');
}