static bool AddNameToCensor(NWildcard::CCensor &wildcardCensor,
const UString &name, bool include, NRecursedType::EEnum type)
{
/*
if(!IsWildCardFilePathLegal(name))
return false;
*/
bool isWildCard = DoesNameContainWildCard(name);
bool recursed = false;
switch (type)
{
case NRecursedType::kWildCardOnlyRecursed:
recursed = isWildCard;
break;
case NRecursedType::kRecursed:
recursed = true;
break;
case NRecursedType::kNonRecursed:
recursed = false;
break;
}
wildcardCensor.AddItem(include, name, recursed);
return true;
}
static HRESULT ExtractGroupCommand(const UStringVector &arcPaths,
bool showDialog, const UString &outFolder, bool testMode)
{
HRESULT result;
MY_TRY_BEGIN
CREATE_CODECS
CExtractOptions eo;
eo.OutputDir = outFolder;
eo.TestMode = testMode;
CExtractCallbackImp *ecs = new CExtractCallbackImp;
CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
ecs->Init();
// eo.CalcCrc = options.CalcCrc;
UStringVector arcPathsSorted;
UStringVector arcFullPathsSorted;
{
NWildcard::CCensor acrCensor;
for (int i = 0; i < arcPaths.Size(); i++)
acrCensor.AddItem(true, arcPaths[i], false);
EnumerateDirItemsAndSort(acrCensor, arcPathsSorted, arcFullPathsSorted);
}
CIntVector formatIndices;
NWildcard::CCensor censor;
censor.AddItem(true, L"*", false);
bool messageWasDisplayed = false;
result = ExtractGUI(codecs, formatIndices, arcPathsSorted, arcFullPathsSorted,
censor.Pairs.Front().Head, eo, showDialog, messageWasDisplayed, ecs, g_HWND);
if (result != S_OK)
{
if (result != E_ABORT && messageWasDisplayed)
return E_FAIL;
throw CSystemException(result);
}
return ecs->IsOK() ? S_OK : E_FAIL;
MY_TRY_FINISH
return result;
}
static void AddNameToCensor(NWildcard::CCensor &censor,
const UString &name, bool include, NRecursedType::EEnum type, bool wildcardMatching)
{
bool recursed = false;
switch (type)
{
case NRecursedType::kWildcardOnlyRecursed:
recursed = DoesNameContainWildcard(name);
break;
case NRecursedType::kRecursed:
recursed = true;
break;
}
censor.AddPreItem(include, name, recursed, wildcardMatching);
}
int Main2(
#ifndef _WIN32
int numArgs, char *args[]
#endif
)
{
#if defined(_WIN32) && !defined(UNDER_CE)
SetFileApisToOEM();
#endif
g_StdOut << kCopyrightString;
UStringVector commandStrings;
#ifdef _WIN32
NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
#else
// GetArguments(numArgs, args, commandStrings);
mySplitCommandLine(numArgs,args,commandStrings);
#endif
#ifdef _WIN32
FString arcPath;
{
FString path;
NDLL::MyGetModuleFileName(path);
if (!MyGetFullPathName(path, arcPath))
{
g_StdOut << "GetFullPathName Error";
return NExitCode::kFatalError;
}
}
#else
// After mySplitCommandLine
showP7zipInfo(&g_StdOut);
UString arcPath = commandStrings.Front();
#endif
commandStrings.Delete(0);
NCommandLineParser::CParser parser(kNumSwitches);
try
{
parser.ParseStrings(kSwitchForms, commandStrings);
}
catch(...)
{
PrintHelpAndExit();
}
if (parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs)
{
PrintHelp();
return 0;
}
const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
int numNonSwitchStrings = nonSwitchStrings.Size();
CArchiveCommand command;
if (numNonSwitchStrings == 0)
command.CommandType = NCommandType::kFullExtract;
else
{
if (numNonSwitchStrings > 1)
PrintHelpAndExit();
if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], command))
PrintHelpAndExit();
}
NRecursedType::EEnum recursedType;
recursedType = command.DefaultRecursedType();
NWildcard::CCensor wildcardCensor;
bool thereAreSwitchIncludeWildcards;
thereAreSwitchIncludeWildcards = false;
AddToCensorFromNonSwitchesStrings(wildcardCensor, nonSwitchStrings, recursedType,
thereAreSwitchIncludeWildcards);
bool yesToAll = parser[NKey::kYes].ThereIs;
// NExtractMode::EEnum extractMode;
// bool isExtractGroupCommand = command.IsFromExtractGroup(extractMode);
bool passwordEnabled = parser[NKey::kPassword].ThereIs;
UString password;
if (passwordEnabled)
password = parser[NKey::kPassword].PostStrings[0];
if (!NFind::DoesFileExist(arcPath))
throw kCantFindSFX;
FString outputDir;
if (parser[NKey::kOutputDir].ThereIs)
{
outputDir = us2fs(parser[NKey::kOutputDir].PostStrings[0]);
NName::NormalizeDirPathPrefix(outputDir);
}
wildcardCensor.AddPathsToCensor(NWildcard::k_RelatPath);
{
UStringVector v1, v2;
v1.Add(fs2us(arcPath));
v2.Add(fs2us(arcPath));
const NWildcard::CCensorNode &wildcardCensorHead =
wildcardCensor.Pairs.Front().Head;
CCodecs *codecs = new CCodecs;
CMyComPtr<
#ifdef EXTERNAL_CODECS
ICompressCodecsInfo
#else
IUnknown
#endif
> compressCodecsInfo = codecs;
{
HRESULT result = codecs->Load();
if (result != S_OK)
throw CSystemException(result);
}
if (command.CommandType != NCommandType::kList)
{
CExtractCallbackConsole *ecs = new CExtractCallbackConsole;
CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
ecs->Init(g_StdStream, &g_StdErr, g_StdStream);
#ifndef _NO_CRYPTO
ecs->PasswordIsDefined = passwordEnabled;
ecs->Password = password;
#endif
/*
COpenCallbackConsole openCallback;
openCallback.Init(g_StdStream, g_StdStream);
#ifndef _NO_CRYPTO
openCallback.PasswordIsDefined = passwordEnabled;
openCallback.Password = password;
#endif
*/
CExtractOptions eo;
eo.StdOutMode = false;
eo.YesToAll = yesToAll;
eo.TestMode = command.CommandType == NCommandType::kTest;
eo.PathMode = NExtract::NPathMode::kFullPaths;
eo.OverwriteMode = yesToAll ?
NExtract::NOverwriteMode::kOverwrite :
NExtract::NOverwriteMode::kAsk;
eo.OutputDir = outputDir;
UString errorMessage;
CDecompressStat stat;
HRESULT result = Extract(
codecs, CObjectVector<COpenType>(), CIntVector(),
v1, v2,
wildcardCensorHead,
eo, ecs, ecs,
// NULL, // hash
errorMessage, stat);
if (!errorMessage.IsEmpty())
{
(*g_StdStream) << endl << "Error: " << errorMessage;;
if (result == S_OK)
result = E_FAIL;
}
if (ecs->NumArcsWithError != 0 || ecs->NumFileErrors != 0)
{
if (ecs->NumArcsWithError != 0)
(*g_StdStream) << endl << "Archive Errors" << endl;
if (ecs->NumFileErrors != 0)
(*g_StdStream) << endl << "Sub items Errors: " << ecs->NumFileErrors << endl;
return NExitCode::kFatalError;
}
if (result != S_OK)
throw CSystemException(result);
}
else
{
throw CSystemException(E_NOTIMPL);
/*
UInt64 numErrors = 0;
UInt64 numWarnings = 0;
HRESULT result = ListArchives(
codecs, CObjectVector<COpenType>(), CIntVector(),
false, // stdInMode
v1, v2,
true, // processAltStreams
false, // showAltStreams
wildcardCensorHead,
true, // enableHeaders
false, // techMode
#ifndef _NO_CRYPTO
passwordEnabled, password,
#endif
numErrors, numWarnings);
if (numErrors > 0)
{
g_StdOut << endl << "Errors: " << numErrors;
return NExitCode::kFatalError;
}
if (result != S_OK)
throw CSystemException(result);
*/
}
}
return 0;
}
int DoExtractArchive(UString archive, UString targetDir, bool overwrite, bool extractPaths, ExtractProgressHandler epc)
{
CCodecs *codecs = new CCodecs;
CMyComPtr<IUnknown> compressCodecsInfo = codecs;
HRESULT result = codecs->Load();
if (result != S_OK)
throw CSystemException(result);
if (codecs->Formats.Size() == 0) throw -1;
CIntVector formatIndices;
if (!codecs->FindFormatForArchiveType(L"7z", formatIndices))
{
throw -1;
}
BOOL bApisAreAnsi = AreFileApisANSI();
#ifdef _WIN32
if (bApisAreAnsi)
SwitchFileAPIEncoding(bApisAreAnsi);
#endif
CExtractCallbackConsole *ecs = new CExtractCallbackConsole();
CMyComPtr<IFolderArchiveExtractCallback> extractCallback = ecs;
ecs->ProgressHandler = epc;
wcsncpy(ecs->destDir, targetDir, MAX_PATH);
ecs->Init();
COpenCallbackConsole openCallback;
CExtractOptions eo;
eo.StdOutMode = false;
eo.PathMode = extractPaths?NExtract::NPathMode::kCurPaths:NExtract::NPathMode::kNoPaths;
eo.TestMode = false;
eo.OverwriteMode = overwrite?NExtract::NOverwriteMode::kOverwrite:NExtract::NOverwriteMode::kSkip;
eo.OutputDir = targetDir;
eo.YesToAll = true;
#ifdef COMPRESS_MT
CObjectVector<CProperty> prp;
eo.Properties = prp;
#endif
UString errorMessage;
CDecompressStat stat;
NWildcard::CCensor wildcardCensor;
wildcardCensor.AddItem(NWildcard::ECensorPathMode::k_FullPath, true, L"*", true, true);
UStringVector ArchivePathsSorted;
UStringVector ArchivePathsFullSorted;
ArchivePathsSorted.Add(archive);
UString fullPath;
NFile::NDir::MyGetFullPathName(archive, fullPath);
ArchivePathsFullSorted.Add(fullPath);
UStringVector v1, v2;
v1.Add(fs2us(archive));
v2.Add(fs2us(archive));
const NWildcard::CCensorNode &wildcardCensorHead =
wildcardCensor.Pairs.Front().Head;
result = Extract(
codecs, CObjectVector<COpenType>(), CIntVector(),
v1, v2,
wildcardCensorHead,
eo, ecs, ecs,
NULL, // hash
errorMessage, stat);
#ifdef _WIN32
if (bApisAreAnsi)
SwitchFileAPIEncoding(!bApisAreAnsi);
#endif
if (!errorMessage.IsEmpty())
{
if (result == S_OK)
result = E_FAIL;
}
if (ecs->NumArchiveErrors != 0 || ecs->NumFileErrors != 0)
{
if (result != S_OK)
throw CSystemException(result);
return NExitCode::kFatalError;
}
if (result != S_OK)
throw CSystemException(result);
return 0;
}
void CArchiveCommandLineParser::Parse2(CArchiveCommandLineOptions &options)
{
const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
int numNonSwitchStrings = nonSwitchStrings.Size();
if (numNonSwitchStrings < kMinNonSwitchWords)
ThrowUserErrorException();
if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], options.Command))
ThrowUserErrorException();
options.TechMode = parser[NKey::kTechMode].ThereIs;
options.CalcCrc = parser[NKey::kCalcCrc].ThereIs;
if (parser[NKey::kCaseSensitive].ThereIs)
g_CaseSensitive = (parser[NKey::kCaseSensitive].PostCharIndex < 0);
NRecursedType::EEnum recursedType;
if (parser[NKey::kRecursed].ThereIs)
recursedType = GetRecursedTypeFromIndex(parser[NKey::kRecursed].PostCharIndex);
else
recursedType = NRecursedType::kNonRecursed;
g_CodePage = FindCharset(parser, NKey::kConsoleCharSet, -1);
UINT codePage = FindCharset(parser, NKey::kListfileCharSet, CP_UTF8);
bool thereAreSwitchIncludes = false;
if (parser[NKey::kInclude].ThereIs)
{
thereAreSwitchIncludes = true;
AddSwitchWildCardsToCensor(options.WildcardCensor,
parser[NKey::kInclude].PostStrings, true, recursedType, codePage);
}
if (parser[NKey::kExclude].ThereIs)
AddSwitchWildCardsToCensor(options.WildcardCensor,
parser[NKey::kExclude].PostStrings, false, recursedType, codePage);
int curCommandIndex = kCommandIndex + 1;
bool thereIsArchiveName = !parser[NKey::kNoArName].ThereIs &&
options.Command.CommandType != NCommandType::kBenchmark &&
options.Command.CommandType != NCommandType::kInfo;
bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;
if (isExtractOrList && options.StdInMode)
thereIsArchiveName = false;
if (thereIsArchiveName)
{
if (curCommandIndex >= numNonSwitchStrings)
ThrowUserErrorException();
options.ArchiveName = nonSwitchStrings[curCommandIndex++];
}
AddToCensorFromNonSwitchesStrings(
curCommandIndex, options.WildcardCensor,
nonSwitchStrings, recursedType, thereAreSwitchIncludes, codePage);
options.YesToAll = parser[NKey::kYes].ThereIs;
#ifndef _NO_CRYPTO
options.PasswordEnabled = parser[NKey::kPassword].ThereIs;
if (options.PasswordEnabled)
options.Password = parser[NKey::kPassword].PostStrings[0];
#endif
options.ShowDialog = parser[NKey::kShowDialog].ThereIs;
if (parser[NKey::kArchiveType].ThereIs)
options.ArcType = parser[NKey::kArchiveType].PostStrings[0];
if (isExtractOrList)
{
if (!options.WildcardCensor.AllAreRelative())
ThrowException("Cannot use absolute pathnames for this command");
NWildcard::CCensor archiveWildcardCensor;
if (parser[NKey::kArInclude].ThereIs)
AddSwitchWildCardsToCensor(archiveWildcardCensor,
parser[NKey::kArInclude].PostStrings, true, NRecursedType::kNonRecursed, codePage);
if (parser[NKey::kArExclude].ThereIs)
AddSwitchWildCardsToCensor(archiveWildcardCensor,
parser[NKey::kArExclude].PostStrings, false, NRecursedType::kNonRecursed, codePage);
if (thereIsArchiveName)
AddNameToCensor(archiveWildcardCensor, options.ArchiveName, true, NRecursedType::kNonRecursed);
#ifdef _WIN32
ConvertToLongNames(archiveWildcardCensor);
#endif
archiveWildcardCensor.ExtendExclude();
if (options.StdInMode)
{
UString arcName = parser[NKey::kStdIn].PostStrings.Front();
options.ArchivePathsSorted.Add(arcName);
options.ArchivePathsFullSorted.Add(arcName);
}
else
{
EnumerateDirItemsAndSort(archiveWildcardCensor,
options.ArchivePathsSorted,
options.ArchivePathsFullSorted);
}
if (isExtractGroupCommand)
{
SetMethodOptions(parser, options.ExtractProperties);
if (options.StdOutMode && options.IsStdOutTerminal && options.IsStdErrTerminal)
throw kSameTerminalError;
if (parser[NKey::kOutputDir].ThereIs)
{
options.OutputDir = parser[NKey::kOutputDir].PostStrings[0];
NFile::NName::NormalizeDirPathPrefix(options.OutputDir);
}
options.OverwriteMode = NExtract::NOverwriteMode::kAskBefore;
if (parser[NKey::kOverwrite].ThereIs)
options.OverwriteMode = k_OverwriteModes[parser[NKey::kOverwrite].PostCharIndex];
else if (options.YesToAll)
options.OverwriteMode = NExtract::NOverwriteMode::kWithoutPrompt;
}
}
else if (options.Command.IsFromUpdateGroup())
{
CUpdateOptions &updateOptions = options.UpdateOptions;
SetAddCommandOptions(options.Command.CommandType, parser, updateOptions);
SetMethodOptions(parser, updateOptions.MethodMode.Properties);
if (parser[NKey::kShareForWrite].ThereIs)
updateOptions.OpenShareForWrite = true;
options.EnablePercents = !parser[NKey::kDisablePercents].ThereIs;
if (options.EnablePercents)
{
if ((options.StdOutMode && !options.IsStdErrTerminal) ||
(!options.StdOutMode && !options.IsStdOutTerminal))
options.EnablePercents = false;
}
updateOptions.EMailMode = parser[NKey::kEmail].ThereIs;
if (updateOptions.EMailMode)
{
updateOptions.EMailAddress = parser[NKey::kEmail].PostStrings.Front();
if (updateOptions.EMailAddress.Length() > 0)
if (updateOptions.EMailAddress[0] == L'.')
{
updateOptions.EMailRemoveAfter = true;
updateOptions.EMailAddress.Delete(0);
}
}
updateOptions.StdOutMode = options.StdOutMode;
updateOptions.StdInMode = options.StdInMode;
if (updateOptions.StdOutMode && updateOptions.EMailMode)
throw "stdout mode and email mode cannot be combined";
if (updateOptions.StdOutMode && options.IsStdOutTerminal)
throw kTerminalOutError;
if (updateOptions.StdInMode)
updateOptions.StdInFileName = parser[NKey::kStdIn].PostStrings.Front();
#ifdef _WIN32
ConvertToLongNames(options.WildcardCensor);
#endif
}
else if (options.Command.CommandType == NCommandType::kBenchmark)
{
options.NumThreads = (UInt32)-1;
options.DictionarySize = (UInt32)-1;
options.NumIterations = 1;
if (curCommandIndex < numNonSwitchStrings)
{
if (!ConvertStringToUInt32(nonSwitchStrings[curCommandIndex++], options.NumIterations))
ThrowUserErrorException();
}
for (int i = 0; i < parser[NKey::kProperty].PostStrings.Size(); i++)
{
UString postString = parser[NKey::kProperty].PostStrings[i];
postString.MakeUpper();
if (postString.Length() < 2)
ThrowUserErrorException();
if (postString[0] == 'D')
{
int pos = 1;
if (postString[pos] == '=')
pos++;
UInt32 logSize;
if (!ConvertStringToUInt32((const wchar_t *)postString + pos, logSize))
ThrowUserErrorException();
if (logSize > 31)
ThrowUserErrorException();
options.DictionarySize = 1 << logSize;
}
else if (postString[0] == 'M' && postString[1] == 'T' )
{
int pos = 2;
if (postString[pos] == '=')
pos++;
if (postString[pos] != 0)
if (!ConvertStringToUInt32((const wchar_t *)postString + pos, options.NumThreads))
ThrowUserErrorException();
}
else if (postString[0] == 'M' && postString[1] == '=' )
{
int pos = 2;
if (postString[pos] != 0)
options.Method = postString.Mid(2);
}
else
ThrowUserErrorException();
}
}
else if (options.Command.CommandType == NCommandType::kInfo)
{
}
else
ThrowUserErrorException();
options.WildcardCensor.ExtendExclude();
}
HRESULT CompressFiles(
const UString &arcPathPrefix,
const UString &arcName,
const UString &arcType,
const UStringVector &names,
bool email, bool showDialog, bool /* waitFinish */)
{
//::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles", (LPCWSTR)L"mooo", MB_OK);
HRESULT result;
MY_TRY_BEGIN
CREATE_CODECS
CUpdateCallbackGUI callback;
callback.Init();
CUpdateOptions uo;
uo.EMailMode = email;
uo.SetAddActionCommand();
CIntVector formatIndices;
if (!codecs->FindFormatForArchiveType(arcType, formatIndices))
{
ErrorLangMessage(IDS_UNSUPPORTED_ARCHIVE_TYPE, 0x0200060D);
return E_FAIL;
}
if (!uo.Init(codecs, formatIndices, arcPathPrefix + arcName))
{
ErrorLangMessage(IDS_UPDATE_NOT_SUPPORTED, 0x02000601);
return E_FAIL;
}
NWildcard::CCensor censor;
for (int i = 0; i < names.Size(); i++)
censor.AddItem(true, names[i], false);
//::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles2", (LPCWSTR)L"mooo", MB_OK);
bool messageWasDisplayed = false;
result = UpdateGUI(codecs, censor, uo, showDialog, messageWasDisplayed, &callback, g_HWND);
//::MessageBoxW(NULL, (LPCWSTR)L"CompressCall2::CompressFiles3", (LPCWSTR)L"mooo", MB_OK);
if (result != S_OK)
{
if (result != E_ABORT && messageWasDisplayed)
return E_FAIL;
throw CSystemException(result);
}
if (callback.FailedFiles.Size() > 0)
{
if (!messageWasDisplayed)
throw CSystemException(E_FAIL);
return E_FAIL;
}
MY_TRY_FINISH
return S_OK;
}
void CArchiveCommandLineParser::Parse2(CArchiveCommandLineOptions &options)
{
const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
int numNonSwitchStrings = nonSwitchStrings.Size();
if(numNonSwitchStrings < kMinNonSwitchWords)
ThrowUserErrorException();
if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], options.Command))
ThrowUserErrorException();
options.TechMode = parser[NKey::kTechMode].ThereIs;
if (parser[NKey::kCaseSensitive].ThereIs)
g_CaseSensitive = (parser[NKey::kCaseSensitive].PostCharIndex < 0);
NRecursedType::EEnum recursedType;
if (parser[NKey::kRecursed].ThereIs)
recursedType = GetRecursedTypeFromIndex(parser[NKey::kRecursed].PostCharIndex);
else
recursedType = NRecursedType::kNonRecursed;
UINT codePage = CP_UTF8;
if (parser[NKey::kCharSet].ThereIs)
{
UString name = parser[NKey::kCharSet].PostStrings.Front();
name.MakeUpper();
int i;
for (i = 0; i < kNumCodePages; i++)
{
const CCodePagePair &pair = g_CodePagePairs[i];
if (name.Compare(pair.Name) == 0)
{
codePage = pair.CodePage;
break;
}
}
if (i >= kNumCodePages)
ThrowUserErrorException();
}
bool thereAreSwitchIncludes = false;
if (parser[NKey::kInclude].ThereIs)
{
thereAreSwitchIncludes = true;
AddSwitchWildCardsToCensor(options.WildcardCensor,
parser[NKey::kInclude].PostStrings, true, recursedType, codePage);
}
if (parser[NKey::kExclude].ThereIs)
AddSwitchWildCardsToCensor(options.WildcardCensor,
parser[NKey::kExclude].PostStrings, false, recursedType, codePage);
int curCommandIndex = kCommandIndex + 1;
bool thereIsArchiveName = !parser[NKey::kNoArName].ThereIs &&
options.Command.CommandType != NCommandType::kBenchmark &&
options.Command.CommandType != NCommandType::kInfo;
if (thereIsArchiveName)
{
if(curCommandIndex >= numNonSwitchStrings)
ThrowUserErrorException();
options.ArchiveName = nonSwitchStrings[curCommandIndex++];
}
AddToCensorFromNonSwitchesStrings(
curCommandIndex, options.WildcardCensor,
nonSwitchStrings, recursedType, thereAreSwitchIncludes, codePage);
options.YesToAll = parser[NKey::kYes].ThereIs;
bool isExtractGroupCommand = options.Command.IsFromExtractGroup();
options.PasswordEnabled = parser[NKey::kPassword].ThereIs;
if(options.PasswordEnabled)
options.Password = parser[NKey::kPassword].PostStrings[0];
options.StdInMode = parser[NKey::kStdIn].ThereIs;
options.ShowDialog = parser[NKey::kShowDialog].ThereIs;
if(isExtractGroupCommand || options.Command.CommandType == NCommandType::kList)
{
if (options.StdInMode)
ThrowException("Reading archives from stdin is not implemented");
if (!options.WildcardCensor.AllAreRelative())
ThrowException("Cannot use absolute pathnames for this command");
NWildcard::CCensor archiveWildcardCensor;
if (parser[NKey::kArInclude].ThereIs)
{
AddSwitchWildCardsToCensor(archiveWildcardCensor,
parser[NKey::kArInclude].PostStrings, true, NRecursedType::kNonRecursed, codePage);
}
if (parser[NKey::kArExclude].ThereIs)
AddSwitchWildCardsToCensor(archiveWildcardCensor,
parser[NKey::kArExclude].PostStrings, false, NRecursedType::kNonRecursed, codePage);
if (thereIsArchiveName)
AddCommandLineWildCardToCensr(archiveWildcardCensor, options.ArchiveName, true, NRecursedType::kNonRecursed);
#ifdef _WIN32
ConvertToLongNames(archiveWildcardCensor);
#endif
archiveWildcardCensor.ExtendExclude();
CObjectVector<CDirItem> dirItems;
{
UStringVector errorPaths;
CRecordVector<DWORD> errorCodes;
HRESULT res = EnumerateItems(archiveWildcardCensor, dirItems, NULL, errorPaths, errorCodes);
if (res != S_OK || errorPaths.Size() > 0)
throw "cannot find archive";
}
UStringVector archivePaths;
int i;
for (i = 0; i < dirItems.Size(); i++)
{
const CDirItem &dirItem = dirItems[i];
if (!dirItem.IsDirectory())
archivePaths.Add(dirItem.FullPath);
}
if (archivePaths.Size() == 0)
throw "there is no such archive";
UStringVector archivePathsFull;
for (i = 0; i < archivePaths.Size(); i++)
{
UString fullPath;
NFile::NDirectory::MyGetFullPathName(archivePaths[i], fullPath);
archivePathsFull.Add(fullPath);
}
CIntVector indices;
SortFileNames(archivePathsFull, indices);
options.ArchivePathsSorted.Reserve(indices.Size());
options.ArchivePathsFullSorted.Reserve(indices.Size());
for (i = 0; i < indices.Size(); i++)
{
options.ArchivePathsSorted.Add(archivePaths[indices[i]]);
options.ArchivePathsFullSorted.Add(archivePathsFull[indices[i]]);
}
if (isExtractGroupCommand)
{
SetMethodOptions(parser, options.ExtractProperties);
if (options.StdOutMode && options.IsStdOutTerminal && options.IsStdErrTerminal)
throw kSameTerminalError;
if(parser[NKey::kOutputDir].ThereIs)
{
options.OutputDir = parser[NKey::kOutputDir].PostStrings[0];
NFile::NName::NormalizeDirPathPrefix(options.OutputDir);
}
options.OverwriteMode = NExtract::NOverwriteMode::kAskBefore;
if(parser[NKey::kOverwrite].ThereIs)
options.OverwriteMode =
k_OverwriteModes[parser[NKey::kOverwrite].PostCharIndex];
else if (options.YesToAll)
options.OverwriteMode = NExtract::NOverwriteMode::kWithoutPrompt;
}
}
else if(options.Command.IsFromUpdateGroup())
{
CUpdateOptions &updateOptions = options.UpdateOptions;
if(parser[NKey::kArchiveType].ThereIs)
options.ArcType = parser[NKey::kArchiveType].PostStrings[0];
SetAddCommandOptions(options.Command.CommandType, parser, updateOptions);
SetMethodOptions(parser, updateOptions.MethodMode.Properties);
if (parser[NKey::kShareForWrite].ThereIs)
updateOptions.OpenShareForWrite = true;
options.EnablePercents = !parser[NKey::kDisablePercents].ThereIs;
if (options.EnablePercents)
{
if ((options.StdOutMode && !options.IsStdErrTerminal) ||
(!options.StdOutMode && !options.IsStdOutTerminal))
options.EnablePercents = false;
}
updateOptions.EMailMode = parser[NKey::kEmail].ThereIs;
if (updateOptions.EMailMode)
{
updateOptions.EMailAddress = parser[NKey::kEmail].PostStrings.Front();
if (updateOptions.EMailAddress.Length() > 0)
if (updateOptions.EMailAddress[0] == L'.')
{
updateOptions.EMailRemoveAfter = true;
updateOptions.EMailAddress.Delete(0);
}
}
updateOptions.StdOutMode = options.StdOutMode;
updateOptions.StdInMode = options.StdInMode;
if (updateOptions.StdOutMode && updateOptions.EMailMode)
throw "stdout mode and email mode cannot be combined";
if (updateOptions.StdOutMode && options.IsStdOutTerminal)
throw kTerminalOutError;
if(updateOptions.StdInMode)
updateOptions.StdInFileName = parser[NKey::kStdIn].PostStrings.Front();
#ifdef _WIN32
ConvertToLongNames(options.WildcardCensor);
#endif
}
else if(options.Command.CommandType == NCommandType::kBenchmark)
{
options.NumThreads = (UInt32)-1;
options.DictionarySize = (UInt32)-1;
options.NumIterations = 1;
if (curCommandIndex < numNonSwitchStrings)
{
if (!ConvertStringToUInt32(nonSwitchStrings[curCommandIndex++], options.NumIterations))
ThrowUserErrorException();
}
for (int i = 0; i < parser[NKey::kProperty].PostStrings.Size(); i++)
{
UString postString = parser[NKey::kProperty].PostStrings[i];
postString.MakeUpper();
if (postString.Length() < 2)
ThrowUserErrorException();
if (postString[0] == 'D')
{
int pos = 1;
if (postString[pos] == '=')
pos++;
UInt32 logSize;
if (!ConvertStringToUInt32((const wchar_t *)postString + pos, logSize))
ThrowUserErrorException();
if (logSize > 31)
ThrowUserErrorException();
options.DictionarySize = 1 << logSize;
}
else if (postString[0] == 'M' && postString[1] == 'T' )
{
int pos = 2;
if (postString[pos] == '=')
pos++;
if (postString[pos] != 0)
if (!ConvertStringToUInt32((const wchar_t *)postString + pos, options.NumThreads))
ThrowUserErrorException();
}
else if (postString[0] == 'M' && postString[1] == '=' )
{
int pos = 2;
if (postString[pos] != 0)
options.Method = postString.Mid(2);
}
else
ThrowUserErrorException();
}
}
else if(options.Command.CommandType == NCommandType::kInfo)
{
}
else
ThrowUserErrorException();
options.WildcardCensor.ExtendExclude();
}