Lines Matching defs:options

853 static void ParseUpdateCommandString(CUpdateOptions &options,

864       if (options.UpdateArchiveItself)

866         options.UpdateArchiveItself = false;

867         options.Commands.Delete(0);

879         if (options.UpdateArchiveItself)

880           options.Commands[0].ActionSet = actionSet;

892         options.Commands.Add(uc);

905     CUpdateOptions &options)

920   options.UpdateArchiveItself = true;

922   options.Commands.Clear();

925   options.Commands.Add(updateMainCommand);

927     ParseUpdateCommandString(options, parser[NKey::kUpdate].PostStrings,

933       NDir::MyGetTempPath(options.WorkingDir);

935       options.WorkingDir = us2fs(postString);

937   options.SfxMode = parser[NKey::kSfx].ThereIs;

938   if (options.SfxMode)

939     options.SfxModule = us2fs(parser[NKey::kSfx].PostStrings[0]);

951       options.VolumesSizes.Add(size);

994     CArcCmdLineOptions &options)

1000   options.IsInTerminal = MY_IS_TERMINAL(stdin);

1001   options.IsStdOutTerminal = MY_IS_TERMINAL(stdout);

1002   options.IsStdErrTerminal = MY_IS_TERMINAL(stderr);

1004   options.HelpMode = parser[NKey::kHelp1].ThereIs || parser[NKey::kHelp2].ThereIs  || parser[NKey::kHelp3].ThereIs;

1006   options.StdInMode = parser[NKey::kStdIn].ThereIs;

1007   options.StdOutMode = parser[NKey::kStdOut].ThereIs;

1008   options.EnableHeaders = !parser[NKey::kDisableHeaders].ThereIs;

1012     options.ListFields = GetAnsiString(s);

1014   options.TechMode = parser[NKey::kTechMode].ThereIs;

1015   options.ShowTime = parser[NKey::kShowTime].ThereIs;

1018       || options.StdOutMode

1019       || !options.IsStdOutTerminal)

1020     options.Number_for_Percents = k_OutStream_disabled;

1022   if (options.StdOutMode)

1023     options.Number_for_Out = k_OutStream_disabled;

1025   SetStreamMode(parser[NKey::kOutStream], options.Number_for_Out);

1026   SetStreamMode(parser[NKey::kErrStream], options.Number_for_Errors);

1027   SetStreamMode(parser[NKey::kPercentStream], options.Number_for_Percents);

1033       options.LogLevel = 1;

1039       options.LogLevel = (unsigned)v;

1045     options.CaseSensitive =

1047     options.CaseSensitive_Change = true;

1055   // options.LargePages = false;

1221 void CArcCmdLineParser::Parse2(CArcCmdLineOptions &options)

1228   if (!ParseArchiveCommand(nonSwitchStrings[kCommandIndex], options.Command))

1232     options.HashMethods = parser[NKey::kHash].PostStrings;

1241       if (!options.HashOptions.ParseFlagCharOption(c, true))

1245         options.HashOptions.HashFilePath = s.Ptr(i);

1253     options.ExtractOptions.HashDir = parser[NKey::kHashDir].PostStrings[0];

1257     options.ExtractOptions.ElimDup.Def = true;

1258     options.ExtractOptions.ElimDup.Val = !parser[NKey::kElimDup].WithMinus;

1301   options.ConsoleCodePage = FindCharset(parser, NKey::kConsoleCharSet, true, -1);

1311     AddSwitchWildcardsToCensor(options.Censor,

1318     AddSwitchWildcardsToCensor(options.Censor,

1324       options.Command.CommandType != NCommandType::kBenchmark &&

1325       options.Command.CommandType != NCommandType::kInfo &&

1326       options.Command.CommandType != NCommandType::kHash;

1328   const bool isExtractGroupCommand = options.Command.IsFromExtractGroup();

1329   const bool isExtractOrList = isExtractGroupCommand || options.Command.CommandType == NCommandType::kList;

1330   const bool isRename = options.Command.CommandType == NCommandType::kRename;

1332   if ((isExtractOrList || isRename) && options.StdInMode)

1336     options.UpdateOptions.ArcNameMode = ParseArcNameMode(parser[NKey::kArcNameMode].PostCharIndex);

1342     options.ArchiveName = nonSwitchStrings[curCommandIndex++];

1343     if (options.ArchiveName.IsEmpty())

1346     // options.ArchiveName.Replace(L'/', WCHAR_PATH_SEPARATOR);

1351   AddToCensorFromNonSwitchesStrings(isRename ? &options.UpdateOptions.RenamePairs : NULL,

1352       curCommandIndex, options.Censor,

1357   options.YesToAll = parser[NKey::kYes].ThereIs;

1361   options.PasswordEnabled = parser[NKey::kPassword].ThereIs;

1362   if (options.PasswordEnabled)

1363     options.Password = parser[NKey::kPassword].PostStrings[0];

1366   options.ShowDialog = parser[NKey::kShowDialog].ThereIs;

1369     options.ArcType = parser[NKey::kArchiveType].PostStrings[0];

1371   options.ExcludedArcTypes = parser[NKey::kExcludedArcType].PostStrings;

1373   SetMethodOptions(parser, options.Properties);

1375   if (parser[NKey::kNtSecurity].ThereIs) options.NtSecurity.SetTrueTrue();

1377   SetBoolPair(parser, NKey::kAltStreams, options.AltStreams);

1378   SetBoolPair(parser, NKey::kHardLinks, options.HardLinks);

1379   SetBoolPair(parser, NKey::kSymLinks, options.SymLinks);

1381   SetBoolPair(parser, NKey::kStoreOwnerId, options.StoreOwnerId);

1382   SetBoolPair(parser, NKey::kStoreOwnerName, options.StoreOwnerName);

1389   bool supportSymLink = options.SymLinks.Val;

1391   if (!options.SymLinks.Def)

1410     CExtractOptionsBase &eo = options.ExtractOptions;

1412     eo.ExcludeDirItems = options.Censor.ExcludeDirItems;

1413     eo.ExcludeFileItems = options.Censor.ExcludeFileItems;

1417       nt.NtSecurity = options.NtSecurity;

1419       nt.AltStreams = options.AltStreams;

1420       if (!options.AltStreams.Def)

1423       nt.HardLinks = options.HardLinks;

1424       if (!options.HardLinks.Def)

1427       nt.SymLinks = options.SymLinks;

1428       if (!options.SymLinks.Def)

1436       nt.ExtractOwner = options.StoreOwnerId.Val; // StoreOwnerName

1458     options.Censor.AddPathsToCensor(NWildcard::k_AbsPath);

1459     options.Censor.ExtendExclude();

1462     if (!options.Censor.AllAreRelative())

1465     NWildcard::CCensor &arcCensor = options.arcCensor;

1487       AddNameToCensor(arcCensor, nopArc, options.ArchiveName);

1498     if (options.StdInMode)

1499       options.ArcName_for_StdInMode = parser[NKey::kStdIn].PostStrings.Front();

1503       if (options.StdOutMode)

1506                   options.Number_for_Percents == k_OutStream_stdout

1507             // || options.Number_for_Out      == k_OutStream_stdout

1508             // || options.Number_for_Errors   == k_OutStream_stdout

1511               (options.IsStdOutTerminal && options.IsStdErrTerminal)

1514                       options.Number_for_Percents != k_OutStream_disabled

1515                 // || options.Number_for_Out      != k_OutStream_disabled

1516                 // || options.Number_for_Errors   != k_OutStream_disabled

1538       else if (options.YesToAll)

1545     eo.PathMode = options.Command.GetPathMode();

1557   else if (options.Command.IsFromUpdateGroup())

1562     CUpdateOptions &updateOptions = options.UpdateOptions;

1564     SetAddCommandOptions(options.Command.CommandType, parser, updateOptions);

1566     updateOptions.MethodMode.Properties = options.Properties;

1577     updateOptions.AltStreams = options.AltStreams;

1578     updateOptions.NtSecurity = options.NtSecurity;

1579     updateOptions.HardLinks = options.HardLinks;

1580     updateOptions.SymLinks = options.SymLinks;

1582     updateOptions.StoreOwnerId = options.StoreOwnerId;

1583     updateOptions.StoreOwnerName = options.StoreOwnerName;

1597     updateOptions.StdOutMode = options.StdOutMode;

1598     updateOptions.StdInMode = options.StdInMode;

1608       if (options.IsStdOutTerminal)

1611       if (options.Number_for_Percents == k_OutStream_stdout

1612           || options.Number_for_Out == k_OutStream_stdout

1613           || options.Number_for_Errors == k_OutStream_stdout)

1620     if (options.Command.CommandType == NCommandType::kRename)

1624   else if (options.Command.CommandType == NCommandType::kBenchmark)

1626     options.NumIterations = 1;

1627     options.NumIterations_Defined = false;

1630       if (!StringToUInt32(nonSwitchStrings[curCommandIndex], options.NumIterations))

1633       options.NumIterations_Defined = true;

1636   else if (options.Command.CommandType == NCommandType::kHash)

1638     options.Censor.AddPathsToCensor(censorPathMode);

1639     options.Censor.ExtendExclude();

1641     CHashOptions &hashOptions = options.HashOptions;

1643     hashOptions.Methods = options.HashMethods;

1644     // hashOptions.HashFilePath = options.HashFilePath;

1649     hashOptions.StdInMode = options.StdInMode;

1650     hashOptions.AltStreamsMode = options.AltStreams.Val;

1651     hashOptions.SymLinks = options.SymLinks;

1653   else if (options.Command.CommandType == NCommandType::kInfo)