in Public/Src/App/Bxl/Args.cs [176:1585]
public bool TryParse(string[] args, PathTable pathTable, out ICommandLineConfiguration arguments)
{
try
{
var cl = new CommandLineUtilities(args);
// Setting engine configuration has to be done before the creation of configuration.
SetEngineConfigurationVersionIfSpecified(cl);
var configuration = new Utilities.Configuration.Mutable.CommandLineConfiguration();
var startupConfiguration = configuration.Startup;
var engineConfiguration = configuration.Engine;
var layoutConfiguration = configuration.Layout;
var sandboxConfiguration = configuration.Sandbox;
var schedulingConfiguration = configuration.Schedule;
var cacheConfiguration = configuration.Cache;
var loggingConfiguration = configuration.Logging;
var exportConfiguration = configuration.Export;
var experimentalConfiguration = configuration.Experiment;
var distributionConfiguration = configuration.Distribution;
var frontEndConfiguration = configuration.FrontEnd;
var ideConfiguration = configuration.Ide;
var resolverDefaults = configuration.ResolverDefaults;
loggingConfiguration.InvocationExpandedCommandLineArguments = cl.ExpandedArguments.ToArray();
bool unsafeUnexpectedFileAccessesAreErrorsSet = false;
bool failPipOnFileAccessErrorSet = false;
bool? enableProfileRedirect = null;
ContentHashingUtilities.SetDefaultHashType();
// Notes
//
// * Handlers must be in alphabetical order according to their long forms.
//
// * Boolean options must be listed three times (once naked, once with a + suffix, and once with a - suffix);
// Use CreateBoolOption or CreateBoolOptionWithValue helper functions to not repeat yourself.
//
// * Options with a short form are listed twice (once in the long form, followed by the short form once);
// Use the option2 helper function to not repeat yourself.
m_handlers =
new[]
{
OptionHandlerFactory.CreateOption(
"abTesting",
opt => CommandLineUtilities.ParsePropertyOption(opt, startupConfiguration.ABTestingArgs)),
OptionHandlerFactory.CreateOption2(
"additionalConfigFile",
"ac",
opt => ParsePathOption(opt, pathTable, startupConfiguration.AdditionalConfigFiles)),
OptionHandlerFactory.CreateOption(
"adminRequiredProcessExecutionMode",
opt => sandboxConfiguration.AdminRequiredProcessExecutionMode = CommandLineUtilities.ParseEnumOption<AdminRequiredProcessExecutionMode>(opt)),
OptionHandlerFactory.CreateBoolOption(
"allowFetchingCachedGraphFromContentCache",
sign => cacheConfiguration.AllowFetchingCachedGraphFromContentCache = sign),
OptionHandlerFactory.CreateBoolOption(
"allowInternalDetoursErrorNotificationFile",
sign => sandboxConfiguration.AllowInternalDetoursErrorNotificationFile = sign),
OptionHandlerFactory.CreateBoolOption(
"allowMissingSpecs",
opt => frontEndConfiguration.AllowMissingSpecs = opt),
OptionHandlerFactory.CreateBoolOption(
"analyzeDependencyViolations",
opt => { /* DEPRECATED -- DO NOTHING */ }),
OptionHandlerFactory.CreateOption(
"augmentingPathSetCommonalityFactor",
opt => cacheConfiguration.AugmentWeakFingerprintRequiredPathCommonalityFactor = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateBoolOption(
"breakOnUnexpectedFileAccess",
opt => sandboxConfiguration.BreakOnUnexpectedFileAccess = opt),
OptionHandlerFactory.CreateOption(
"buildLockPolling",
opt => engineConfiguration.BuildLockPollingIntervalSec = CommandLineUtilities.ParseInt32Option(opt, 15, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"buildManifestVerifyFileContentOnHashComputation",
opt => engineConfiguration.VerifyFileContentOnBuildManifestHashComputation = opt),
OptionHandlerFactory.CreateOption(
"buildWaitTimeout",
opt => engineConfiguration.BuildLockWaitTimeoutMins = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"cacheConfigFilePath",
opt => cacheConfiguration.CacheConfigFile = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption2(
"cacheDirectory",
"cd",
opt => layoutConfiguration.CacheDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"cacheGraph",
opt => cacheConfiguration.CacheGraph = opt),
OptionHandlerFactory.CreateBoolOptionWithValue(
"cacheMiss",
(opt, sign) => ParseCacheMissAnalysisOption(opt, sign, loggingConfiguration, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"cacheMissBatch",
sign => loggingConfiguration.CacheMissBatch = sign),
OptionHandlerFactory.CreateOption(
"cacheMissDiffFormat",
opt => CommandLineUtilities.ParseEnumOption<CacheMissDiffFormat>(opt)),
OptionHandlerFactory.CreateBoolOption(
"cacheOnly",
opt => schedulingConfiguration.CacheOnly = opt),
OptionHandlerFactory.CreateOption(
"cacheSessionName",
opt => cacheConfiguration.CacheSessionName = CommandLineUtilities.ParseStringOption(opt)),
OptionHandlerFactory.CreateBoolOption(
"cacheSpecs",
sign => cacheConfiguration.CacheSpecs = sign ? SpecCachingOption.Enabled : SpecCachingOption.Disabled),
OptionHandlerFactory.CreateBoolOption(
"canonicalizeFilterOutputs",
sign => schedulingConfiguration.CanonicalizeFilterOutputs = sign),
OptionHandlerFactory.CreateBoolOption(
"checkDetoursMessageCount",
sign => sandboxConfiguration.CheckDetoursMessageCount = sign),
OptionHandlerFactory.CreateBoolOption(
"cleanOnly",
sign => engineConfiguration.CleanOnly = sign),
OptionHandlerFactory.CreateBoolOption(
"cleanTempDirectories",
sign => engineConfiguration.CleanTempDirectories = sign),
OptionHandlerFactory.CreateBoolOption(
"color",
sign => loggingConfiguration.Color = sign),
OptionHandlerFactory.CreateBoolOption(
"compressGraphFiles",
sign => engineConfiguration.CompressGraphFiles = sign),
OptionHandlerFactory.CreateOption2(
"config",
"c",
opt =>
{
startupConfiguration.ConfigFile = CommandLineUtilities.ParsePathOption(opt, pathTable);
}),
OptionHandlerFactory.CreateOption2(
"consoleVerbosity",
"cv",
opt => loggingConfiguration.ConsoleVerbosity = CommandLineUtilities.ParseEnumOption<VerbosityLevel>(opt)),
OptionHandlerFactory.CreateBoolOption(
"converge",
sign => engineConfiguration.Converge = sign),
OptionHandlerFactory.CreateOption(
"criticalCommitUtilizationPercentage",
opt => schedulingConfiguration.CriticalCommitUtilizationPercentage = CommandLineUtilities.ParseInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"customLog",
opt => ParseCustomLogOption(opt, pathTable, loggingConfiguration.CustomLog)),
OptionHandlerFactory.CreateBoolOption(
"debuggerBreakOnExit",
opt => frontEndConfiguration.DebuggerBreakOnExit = opt),
OptionHandlerFactory.CreateOption(
"debuggerPort",
opt => frontEndConfiguration.DebuggerPort = CommandLineUtilities.ParseInt32Option(opt, 1024, 65535)),
OptionHandlerFactory.CreateBoolOption(
"debugScript",
opt => frontEndConfiguration.DebugScript = opt),
OptionHandlerFactory.CreateOption(
"delayCacheLookupMin",
opt => schedulingConfiguration.DelayedCacheLookupMinMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"delayCacheLookupMax",
opt => schedulingConfiguration.DelayedCacheLookupMaxMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 100)),
OptionHandlerFactory.CreateBoolOption(
"scriptShowSlowest",
opt => frontEndConfiguration.ShowSlowestElementsStatistics = opt),
OptionHandlerFactory.CreateBoolOption(
"scriptShowLargest",
opt => frontEndConfiguration.ShowLargestFilesStatistics = opt),
OptionHandlerFactory.CreateOption(
"debug_LoadGraph",
opt => HandleLoadGraphOption(opt, pathTable, cacheConfiguration)),
OptionHandlerFactory.CreateBoolOption(
"determinismProbe",
sign => cacheConfiguration.DeterminismProbe = sign),
OptionHandlerFactory.CreateOption2(
"diagnostic",
"diag",
opt => loggingConfiguration.Diagnostic |= CommandLineUtilities.ParseEnumOption<DiagnosticLevels>(opt)),
OptionHandlerFactory.CreateBoolOption(
"dumpFailedPips",
opt => loggingConfiguration.DumpFailedPips = opt),
OptionHandlerFactory.CreateOption(
"dumpFailedPipsLogLimit",
opt => loggingConfiguration.DumpFailedPipsLogLimit = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"dumpFailedPipsWithDynamicData",
opt => loggingConfiguration.DumpFailedPipsWithDynamicData = opt),
OptionHandlerFactory.CreateBoolOption(
"earlyWorkerRelease",
sign => distributionConfiguration.EarlyWorkerRelease = sign),
OptionHandlerFactory.CreateOption(
"earlyWorkerReleaseMultiplier",
opt =>
distributionConfiguration.EarlyWorkerReleaseMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 5)),
OptionHandlerFactory.CreateBoolOption(
"enforceAccessPoliciesOnDirectoryCreation",
sign => sandboxConfiguration.EnforceAccessPoliciesOnDirectoryCreation = sign),
OptionHandlerFactory.CreateBoolOption(
"emitSpotlightIndexingWarning",
sign => layoutConfiguration.EmitSpotlightIndexingWarning = sign),
OptionHandlerFactory.CreateBoolOption(
"disableConHostSharing",
sign => engineConfiguration.DisableConHostSharing = sign),
OptionHandlerFactory.CreateBoolOption(
"disableLoggedPathTranslation",
opt => loggingConfiguration.DisableLoggedPathTranslation = opt),
OptionHandlerFactory.CreateBoolOption(
"disableProcessRetryOnResourceExhaustion",
sign => schedulingConfiguration.DisableProcessRetryOnResourceExhaustion = sign),
// TODO: This is a temporary flag. Remove it once we no longer need it.
OptionHandlerFactory.CreateBoolOption(
"disableCompositeOpaqueFilters",
sign => schedulingConfiguration.DisableCompositeOpaqueFilters = sign),
OptionHandlerFactory.CreateBoolOption(
"disableIsObsoleteCheckDuringConversion",
sign => frontEndConfiguration.DisableIsObsoleteCheckDuringConversion = sign),
OptionHandlerFactory.CreateOption2(
"distributedBuildRole",
"dbr",
opt =>
{
// TODO: Ideally we'd automatically turn on distributionConfiguration.ValidateDistribution whenever
// distribution is enabled. This probably won't work with WDG right now though, so it is not on by default
distributionConfiguration.BuildRole = CommandLineUtilities.ParseEnumOption<DistributedBuildRoles>(opt);
}),
OptionHandlerFactory.CreateOption2(
"distributedBuildServicePort",
"dbsp",
opt =>
distributionConfiguration.BuildServicePort = (ushort)CommandLineUtilities.ParseInt32Option(opt, 1, ushort.MaxValue)),
OptionHandlerFactory.CreateOption2(
"distributedBuildWorker",
"dbw",
opt => ParseServiceLocation(opt, distributionConfiguration.BuildWorkers)),
OptionHandlerFactory.CreateBoolOption(
"elideMinimalGraphEnumerationAbsentPathProbes",
sign => cacheConfiguration.ElideMinimalGraphEnumerationAbsentPathProbes = sign),
OptionHandlerFactory.CreateBoolOption(
"enableAsyncLogging",
sign => loggingConfiguration.EnableAsyncLogging = sign),
OptionHandlerFactory.CreateBoolOption(
"enableEmptyingWorkingSet",
sign => schedulingConfiguration.EnableEmptyingWorkingSet = sign),
OptionHandlerFactory.CreateBoolOption(
"enableHistoricCommitMemoryProjection",
sign => schedulingConfiguration.EnableHistoricCommitMemoryProjection = sign),
OptionHandlerFactory.CreateOption(
"hashType",
option =>
{
var hashType = option.Value.FindHashTypeByName();
ContentHashingUtilities.SetDefaultHashType(hashType);
cacheConfiguration.UseDedupStore = hashType.IsValidDedup();
}),
OptionHandlerFactory.CreateBoolOption(
"enableGrpc",
sign =>
{
// Noop for legacy command line compatibility
}),
OptionHandlerFactory.CreateBoolOption(
"enableIncrementalFrontEnd",
sign => frontEndConfiguration.EnableIncrementalFrontEnd = sign),
OptionHandlerFactory.CreateBoolOptionWithValue(
"enableLazyOutputs",
(opt, sign) => HandleLazyOutputMaterializationOption(opt, sign, schedulingConfiguration)),
OptionHandlerFactory.CreateBoolOption(
"enableLessAggresiveMemoryProjection",
sign => schedulingConfiguration.EnableLessAggresiveMemoryProjection = sign),
OptionHandlerFactory.CreateBoolOption(
"enableProcessRemoting",
sign => schedulingConfiguration.EnableProcessRemoting = sign),
OptionHandlerFactory.CreateBoolOption(
"enableSetupCostWhenChoosingWorker",
sign => schedulingConfiguration.EnableSetupCostWhenChoosingWorker = sign),
OptionHandlerFactory.CreateOption(
"engineCacheDirectory",
opt => layoutConfiguration.EngineCacheDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"ensureTempDirectoriesExistenceBeforePipExecution",
sign => sandboxConfiguration.EnsureTempDirectoriesExistenceBeforePipExecution = sign),
OptionHandlerFactory.CreateOption(
"environment",
opt => loggingConfiguration.Environment = CommandLineUtilities.ParseEnumOption<ExecutionEnvironment>(opt)),
OptionHandlerFactory.CreateBoolOption(
"exitOnNewGraph",
sign => engineConfiguration.ExitOnNewGraph = sign),
OptionHandlerFactory.CreateOption2(
"experiment",
"exp",
opt => HandleExperimentalOption(
opt,
experimentalConfiguration,
engineConfiguration,
schedulingConfiguration,
sandboxConfiguration,
loggingConfiguration,
ideConfiguration,
frontEndConfiguration)),
OptionHandlerFactory.CreateOption(
"exportGraph",
opt =>
{
throw CommandLineUtilities.Error("The /exportGraph option has been deprecated. Use bxlanalyzer.exe /mode:ExportGraph");
}),
OptionHandlerFactory.CreateBoolOption(
"failPipOnFileAccessError",
sign =>
{
loggingConfiguration.FailPipOnFileAccessError = sign;
if (!sign)
{
failPipOnFileAccessErrorSet = true;
}
}),
OptionHandlerFactory.CreateBoolOption(
"fancyConsole",
sign => loggingConfiguration.FancyConsole = sign),
OptionHandlerFactory.CreateOption(
"fancyConsoleMaxStatusPips",
opt => loggingConfiguration.FancyConsoleMaxStatusPips = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"fileChangeTrackerInitializationMode",
opt => engineConfiguration.FileChangeTrackerInitializationMode = CommandLineUtilities.ParseEnumOption<FileChangeTrackerInitializationMode>(opt)),
OptionHandlerFactory.CreateOption(
"fileChangeTrackingExclusionRoot",
opt => cacheConfiguration.FileChangeTrackingExclusionRoots.Add(CommandLineUtilities.ParsePathOption(opt, pathTable))),
OptionHandlerFactory.CreateOption(
"fileChangeTrackingInclusionRoot",
opt => cacheConfiguration.FileChangeTrackingInclusionRoots.Add(CommandLineUtilities.ParsePathOption(opt, pathTable))),
OptionHandlerFactory.CreateOption(
"fileContentTableEntryTimeToLive",
opt => cacheConfiguration.FileContentTableEntryTimeToLive = (ushort)CommandLineUtilities.ParseInt32Option(opt, 1, short.MaxValue)),
OptionHandlerFactory.CreateOption(
"fileContentTableFile",
opt => layoutConfiguration.FileContentTableFile = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"fileContentTablePathMappingMode",
opt => { /* Do nothing Office still passes this flag. */ }),
OptionHandlerFactory.CreateOption(
"fileSystemMode",
opt => sandboxConfiguration.FileSystemMode = CommandLineUtilities.ParseEnumOption<FileSystemMode>(opt)),
OptionHandlerFactory.CreateOption2(
"fileVerbosity",
"fv",
opt => loggingConfiguration.FileVerbosity = CommandLineUtilities.ParseEnumOption<VerbosityLevel>(opt)),
OptionHandlerFactory.CreateOption2(
"filter",
"f",
opt => configuration.Filter = CommandLineUtilities.ParseStringOptionalOption(opt)),
OptionHandlerFactory.CreateBoolOption(
"fingerprintStoreBulkLoad",
sign => loggingConfiguration.FingerprintStoreBulkLoad = sign),
OptionHandlerFactory.CreateOption(
"fingerprintStoreMaxEntryAgeMinutes",
opt => loggingConfiguration.FingerprintStoreMaxEntryAgeMinutes = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"fireForgetMaterializeOutput",
sign => distributionConfiguration.FireForgetMaterializeOutput = sign),
OptionHandlerFactory.CreateBoolOption(
"flushPageCacheToFileSystemOnStoringOutputsToCache",
sign => sandboxConfiguration.FlushPageCacheToFileSystemOnStoringOutputsToCache = sign),
OptionHandlerFactory.CreateBoolOption(
"forceGenerateNuGetSpecs",
sign => frontEndConfiguration.ForceGenerateNuGetSpecs = sign),
OptionHandlerFactory.CreateBoolOption(
"forcePopulatePackageCache",
sign => frontEndConfiguration.ForcePopulatePackageCache = sign),
OptionHandlerFactory.CreateBoolOption(
"forceUseEngineInfoFromCache",
sign => schedulingConfiguration.ForceUseEngineInfoFromCache = sign),
OptionHandlerFactory.CreateOption(
"generateCgManifestForNugets",
opt => frontEndConfiguration.GenerateCgManifestForNugets = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"hardExitOnErrorInDetours",
sign => sandboxConfiguration.HardExitOnErrorInDetours = sign),
#if PLATFORM_OSX
OptionHandlerFactory.CreateOption(
"numberOfKextConnections", // TODO: deprecate and remove
opt =>
{
Console.WriteLine("*** WARNING: deprecated switch /numberOfKextConnections; don't use it as it has no effect any longer");
}),
OptionHandlerFactory.CreateOption(
"reportQueueSizeMb", // TODO: deprecate and remove
opt =>
{
Console.WriteLine("*** WARNING: deprecated switch /reportQueueSizeMb; please use /kextReportQueueSizeMb instead");
sandboxConfiguration.KextReportQueueSizeMb = CommandLineUtilities.ParseUInt32Option(opt, 16, 2048);
}),
OptionHandlerFactory.CreateBoolOption(
"kextEnableReportBatching",
sign => sandboxConfiguration.KextEnableReportBatching = sign),
OptionHandlerFactory.CreateBoolOption(
"measureProcessCpuTimes",
sign => sandboxConfiguration.MeasureProcessCpuTimes = sign),
OptionHandlerFactory.CreateOption(
"kextNumberOfConnections",
opt =>
{
Console.WriteLine("*** WARNING: deprecated switch /kextNumberOfKextConnections; don't use it as it has no effect any longer");
}),
OptionHandlerFactory.CreateOption(
"kextReportQueueSizeMb",
opt => sandboxConfiguration.KextReportQueueSizeMb = CommandLineUtilities.ParseUInt32Option(opt, 16, 2048)),
OptionHandlerFactory.CreateOption(
"kextThrottleCpuUsageBlockThresholdPercent",
opt => sandboxConfiguration.KextThrottleCpuUsageBlockThresholdPercent = CommandLineUtilities.ParseUInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"kextThrottleCpuUsageWakeupThresholdPercent",
opt => sandboxConfiguration.KextThrottleCpuUsageWakeupThresholdPercent = CommandLineUtilities.ParseUInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"kextThrottleMinAvailableRamMB",
opt => sandboxConfiguration.KextThrottleMinAvailableRamMB = CommandLineUtilities.ParseUInt32Option(opt, 0, uint.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxMemoryPressureLevel",
opt => schedulingConfiguration.MaximumAllowedMemoryPressureLevel = CommandLineUtilities.ParseEnumOption<PressureLevel>(opt)),
#endif
OptionHandlerFactory.CreateOption2(
"help",
"?",
opt =>
{
configuration.Help = ParseHelpOption(opt);
}),
OptionHandlerFactory.CreateBoolOption(
"inCloudBuild",
sign => configuration.InCloudBuild = sign),
OptionHandlerFactory.CreateBoolOption(
"incremental",
sign => cacheConfiguration.Incremental = sign),
OptionHandlerFactory.CreateBoolOption(
"incrementalScheduling",
sign => schedulingConfiguration.IncrementalScheduling = sign),
OptionHandlerFactory.CreateBoolOption(
"inferNonExistenceBasedOnParentPathInRealFileSystem",
sign => schedulingConfiguration.InferNonExistenceBasedOnParentPathInRealFileSystem = sign),
OptionHandlerFactory.CreateOption(
"injectCacheMisses",
opt => HandleArtificialCacheMissOption(opt, cacheConfiguration)),
OptionHandlerFactory.CreateOption(
"inputChanges",
opt => schedulingConfiguration.InputChanges = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"interactive",
sign => configuration.Interactive = sign),
OptionHandlerFactory.CreateBoolOption(
"historicMetadataCache",
sign => cacheConfiguration.HistoricMetadataCache = sign),
OptionHandlerFactory.CreateBoolOption(
"launchDebugger",
sign => configuration.LaunchDebugger = sign),
OptionHandlerFactory.CreateBoolOption(
"logCachedPipOutputs",
sign => loggingConfiguration.LogCachedPipOutputs = sign),
OptionHandlerFactory.CreateBoolOption(
"logCounters",
sign => loggingConfiguration.LogCounters = sign),
OptionHandlerFactory.CreateBoolOption(
"logDeterminismProbe",
sign => cacheConfiguration.DisableDeterminismProbeLogging = !sign),
OptionHandlerFactory.CreateBoolOption(
"logExecution",
sign => loggingConfiguration.LogExecution = sign),
OptionHandlerFactory.CreateBoolOption(
"logFileAccessTables",
sign => sandboxConfiguration.LogFileAccessTables = sign),
OptionHandlerFactory.CreateBoolOption(
"logMemory",
sign => loggingConfiguration.LogMemory = sign),
OptionHandlerFactory.CreateBoolOption(
"logObservedFileAccesses",
sign => sandboxConfiguration.LogObservedFileAccesses = sign),
OptionHandlerFactory.CreateOption(
"logOutput",
opt => sandboxConfiguration.OutputReportingMode = CommandLineUtilities.ParseEnumOption<OutputReportingMode>(opt)),
OptionHandlerFactory.CreateBoolOption(
"logPackedExecution",
sign => loggingConfiguration.LogPackedExecution = sign),
OptionHandlerFactory.CreateBoolOption(
"logPipStaticFingerprintTexts",
sign => schedulingConfiguration.LogPipStaticFingerprintTexts = sign),
OptionHandlerFactory.CreateOption(
"logPrefix",
opt => loggingConfiguration.LogPrefix = ParseLogPrefix(opt)),
OptionHandlerFactory.CreateBoolOption(
"logProcessData",
sign => sandboxConfiguration.LogProcessData = sign),
OptionHandlerFactory.CreateBoolOption(
"logProcessDetouringStatus",
sign => sandboxConfiguration.LogProcessDetouringStatus = sign),
OptionHandlerFactory.CreateBoolOption(
"logProcesses",
sign => sandboxConfiguration.LogProcesses = sign),
OptionHandlerFactory.CreateOption(
"logsDirectory",
opt => loggingConfiguration.LogsDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"logStats",
sign => loggingConfiguration.LogStats = sign),
OptionHandlerFactory.CreateBoolOption(
"logStatus",
sign => loggingConfiguration.LogStatus = sign),
OptionHandlerFactory.CreateOption(
"logsToRetain",
opt => loggingConfiguration.LogsToRetain = CommandLineUtilities.ParseInt32Option(opt, 1, 1000)),
OptionHandlerFactory.CreateBoolOption(
"logTracer",
sign => loggingConfiguration.LogTracer = sign),
OptionHandlerFactory.CreateBoolOption(
"lowPriority",
sign => schedulingConfiguration.LowPriority = sign),
OptionHandlerFactory.CreateOption(
"manageMemoryMode",
opt => schedulingConfiguration.ManageMemoryMode = CommandLineUtilities.ParseEnumOption<ManageMemoryMode>(opt)),
OptionHandlerFactory.CreateBoolOption(
"maskUntrackedAccesses",
sign => sandboxConfiguration.MaskUntrackedAccesses = sign),
OptionHandlerFactory.CreateOption(
"masterCpuMultiplier",
opt =>
schedulingConfiguration.OrchestratorCpuMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateOption(
"masterCacheLookupMultiplier",
opt =>
schedulingConfiguration.OrchestratorCacheLookupMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateOption(
"maxCacheLookup",
opt => schedulingConfiguration.MaxCacheLookup = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxChooseWorkerCacheLookup",
opt => schedulingConfiguration.MaxChooseWorkerCacheLookup = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxChooseWorkerCpu",
opt => schedulingConfiguration.MaxChooseWorkerCpu = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption2(
"maxFrontEndConcurrency",
"mF",
opt => frontEndConfiguration.MaxFrontEndConcurrency = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"enableEvaluationThrottling",
sign => frontEndConfiguration.EnableEvaluationThrottling = sign),
OptionHandlerFactory.CreateOption(
"maxRestoreNugetConcurrency",
opt => frontEndConfiguration.MaxRestoreNugetConcurrency = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxIO",
opt => schedulingConfiguration.MaxIO = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxIOMultiplier",
opt =>
schedulingConfiguration.MaxIO =
(int)Math.Max(1, Environment.ProcessorCount * CommandLineUtilities.ParseDoubleOption(opt, 0, int.MaxValue))),
OptionHandlerFactory.CreateOption(
"maxLightProc",
opt => schedulingConfiguration.MaxLightProcesses = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxNumPipTelemetryBatches",
opt => loggingConfiguration.MaxNumPipTelemetryBatches = CommandLineUtilities.ParseInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"maxMaterialize",
opt => schedulingConfiguration.MaxMaterialize = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxProc",
opt => schedulingConfiguration.MaxProcesses = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxProcMultiplier",
opt =>
schedulingConfiguration.MaxProcesses =
(int)Math.Max(1, Environment.ProcessorCount * CommandLineUtilities.ParseDoubleOption(opt, 0, int.MaxValue))),
OptionHandlerFactory.CreateOption(
"maxCommitUtilizationPercentage",
opt => schedulingConfiguration.MaximumCommitUtilizationPercentage = CommandLineUtilities.ParseInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"maxRamUtilizationPercentage",
opt => schedulingConfiguration.MaximumRamUtilizationPercentage = CommandLineUtilities.ParseInt32Option(opt, 0, 100)),
OptionHandlerFactory.CreateOption(
"maxRelativeOutputDirectoryLength",
opt => engineConfiguration.MaxRelativeOutputDirectoryLength = CommandLineUtilities.ParseInt32Option(opt, 49, 260)),
OptionHandlerFactory.CreateOption(
"maxRetriesDueToLowMemory",
opt => schedulingConfiguration.MaxRetriesDueToLowMemory = CommandLineUtilities.ParseInt32Option(opt, 0, Int32.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxRetriesDueToRetryableFailures",
opt => schedulingConfiguration.MaxRetriesDueToRetryableFailures = CommandLineUtilities.ParseInt32Option(opt, 0, Int32.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxSealDirs",
opt => schedulingConfiguration.MaxSealDirs = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxTypeCheckingConcurrency",
opt => frontEndConfiguration.MaxTypeCheckingConcurrency = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"maxWorkersPerModule",
opt => schedulingConfiguration.MaxWorkersPerModule = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"minAvailableRamMb",
opt => schedulingConfiguration.MinimumTotalAvailableRamMb = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"minCacheContentReplica",
opt => cacheConfiguration.MinimumReplicaCountForStrongGuarantee = (byte)CommandLineUtilities.ParseInt32Option(opt, 0, 32)),
OptionHandlerFactory.CreateOption(
"minimumDiskSpaceForPipsGb",
opt => schedulingConfiguration.MinimumDiskSpaceForPipsGb = CommandLineUtilities.ParseInt32Option(opt, 0, Int32.MaxValue)),
OptionHandlerFactory.CreateOption(
"minWorkers",
opt => distributionConfiguration.MinimumWorkers = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"minWorkersWarn",
opt => distributionConfiguration.LowWorkersWarningThreshold = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"moduleAffinityLoadFactor",
opt => schedulingConfiguration.ModuleAffinityLoadFactor = CommandLineUtilities.ParseDoubleOption(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"noLog",
opt => ParseInt32ListOption(opt, loggingConfiguration.NoLog)),
OptionHandlerFactory.CreateOption(
"noExecutionLog",
opt => ParseInt32ListOption(opt, loggingConfiguration.NoExecutionLog)),
OptionHandlerFactory.CreateOption(
"noLogo",
opt => configuration.NoLogo = true),
OptionHandlerFactory.CreateBoolOption(
"normalizeReadTimestamps",
sign => sandboxConfiguration.NormalizeReadTimestamps = sign),
OptionHandlerFactory.CreateOption(
"noWarn",
opt => ParseInt32ListOption(opt, loggingConfiguration.NoWarnings)),
OptionHandlerFactory.CreateOption(
"numRemoteAgentLeases",
opt => schedulingConfiguration.NumOfRemoteAgentLeases = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"numRetryFailedPipsOnAnotherWorker",
opt => distributionConfiguration.NumRetryFailedPipsOnAnotherWorker = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption2(
"objectDirectory",
"o",
opt => layoutConfiguration.ObjectDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption2(
"optimizeConsoleOutputForAzureDevOps",
"ado",
sign => loggingConfiguration.OptimizeConsoleOutputForAzureDevOps = sign),
OptionHandlerFactory.CreateBoolOption(
"adoProgressLogging",
sign => loggingConfiguration.OptimizeProgressUpdatingForAzureDevOps = sign),
OptionHandlerFactory.CreateBoolOption(
"adoTaskLogging",
sign => loggingConfiguration.OptimizeVsoAnnotationsForAzureDevOps = sign),
OptionHandlerFactory.CreateOption(
"orchestratorCpuMultiplier",
opt =>
schedulingConfiguration.OrchestratorCpuMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateOption(
"orchestratorCacheLookupMultiplier",
opt =>
schedulingConfiguration.OrchestratorCacheLookupMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateOption(
"outputFileExtensionsForSequentialScanHandleOnHashing",
opt => schedulingConfiguration.OutputFileExtensionsForSequentialScanHandleOnHashing.AddRange(CommandLineUtilities.ParseRepeatingPathAtomOption(opt, pathTable.StringTable, ";"))),
OptionHandlerFactory.CreateOption(
"outputMaterializationExclusionRoot",
opt => schedulingConfiguration.OutputMaterializationExclusionRoots.Add(CommandLineUtilities.ParsePathOption(opt, pathTable))),
OptionHandlerFactory.CreateOption2(
"parameter",
"p",
opt => CommandLineUtilities.ParsePropertyOption(opt, startupConfiguration.Properties)),
OptionHandlerFactory.CreateOption(
"pathSetThreshold",
opt => cacheConfiguration.AugmentWeakFingerprintPathSetThreshold = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"pathSetAugmentationMonitoring",
opt => cacheConfiguration.MonitorAugmentedPathSets = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"phase",
opt => engineConfiguration.Phase = CommandLineUtilities.ParseEnumOption<EnginePhases>(opt)),
OptionHandlerFactory.CreateBoolOption(
"pinCachedOutputs",
sign => schedulingConfiguration.PinCachedOutputs = sign),
OptionHandlerFactory.CreateOption(
"pipDefaultTimeout",
opt =>
sandboxConfiguration.DefaultTimeout =
CommandLineUtilities.ParseInt32Option(opt, 1, (int)Process.MaxTimeout.TotalMilliseconds)),
OptionHandlerFactory.CreateOption(
"pipDefaultWarningTimeout",
opt =>
sandboxConfiguration.DefaultWarningTimeout =
CommandLineUtilities.ParseInt32Option(opt, 1, (int)Process.MaxTimeout.TotalMilliseconds)),
OptionHandlerFactory.CreateOption(
"pipTimeoutMultiplier",
opt => sandboxConfiguration.TimeoutMultiplier = (int)CommandLineUtilities.ParseDoubleOption(opt, 0.000001, 1000000)),
OptionHandlerFactory.CreateOption(
"pipWarningTimeoutMultiplier",
opt =>
sandboxConfiguration.WarningTimeoutMultiplier = (int)CommandLineUtilities.ParseDoubleOption(opt, 0.000001, 1000000)),
OptionHandlerFactory.CreateOption(
"posixDeleteMode",
opt => FileUtilities.PosixDeleteMode = CommandLineUtilities.ParseEnumOption<PosixDeleteMode>(opt)),
OptionHandlerFactory.CreateOption(
"printFile2FileDependencies",
opt => frontEndConfiguration.FileToFileReportDestination = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"processCanRunRemoteTags",
opt => schedulingConfiguration.ProcessCanRunRemoteTags.AddRange(CommandLineUtilities.ParseRepeatingOption(opt, ";", s => s.Trim()))),
OptionHandlerFactory.CreateOption(
"processMustRunLocalTags",
opt => schedulingConfiguration.ProcessMustRunLocalTags.AddRange(CommandLineUtilities.ParseRepeatingOption(opt, ";", s => s.Trim()))),
OptionHandlerFactory.CreateOption(
"processRetries",
opt => schedulingConfiguration.ProcessRetries = CommandLineUtilities.ParseInt32Option(opt, 0, int.MaxValue)),
OptionHandlerFactory.CreateOption(
"profileReportDestination",
opt => frontEndConfiguration.ProfileReportDestination = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"profileScript",
opt => frontEndConfiguration.ProfileScript = opt),
OptionHandlerFactory.CreateOption(
"property",
opt => CommandLineUtilities.ParsePropertyOption(opt, startupConfiguration.Properties)),
OptionHandlerFactory.CreateOption2(
"qualifier",
"q",
opt => ParseStringOption(opt, startupConfiguration.QualifierIdentifiers)),
OptionHandlerFactory.CreateBoolOption(
"redirectUserProfile",
opt => enableProfileRedirect = opt),
OptionHandlerFactory.CreateOption(
"redirectedUserProfileJunctionRoot",
opt => layoutConfiguration.RedirectedUserProfileJunctionRoot = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"relatedActivityId",
opt => loggingConfiguration.RelatedActivityId = CommandLineUtilities.ParseStringOption(opt)),
OptionHandlerFactory.CreateOption(
"remoteExecutionServiceUri",
opt => schedulingConfiguration.RemoteExecutionServiceUri = CommandLineUtilities.ParseStringOption(opt)),
OptionHandlerFactory.CreateBoolOptionWithValue(
"remoteTelemetry",
(opt, sign) =>
loggingConfiguration.RemoteTelemetry =
CommandLineUtilities.ParseBoolEnumOption(opt, sign, RemoteTelemetry.EnabledAndNotify, RemoteTelemetry.Disabled),
isEnabled: () => loggingConfiguration.RemoteTelemetry.HasValue && loggingConfiguration.RemoteTelemetry.Value != RemoteTelemetry.Disabled),
OptionHandlerFactory.CreateOption(
"remotingThresholdMultiplier",
opt => schedulingConfiguration.RemotingThresholdMultiplier = CommandLineUtilities.ParseDoubleOption(opt, 0, double.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"replaceExistingFileOnMaterialization",
sign => cacheConfiguration.ReplaceExistingFileOnMaterialization = sign),
OptionHandlerFactory.CreateBoolOption(
"replayWarnings",
sign => loggingConfiguration.ReplayWarnings = sign),
OptionHandlerFactory.CreateOption(
"replicaRefreshProbability",
opt => cacheConfiguration.StrongContentGuaranteeRefreshProbability = CommandLineUtilities.ParseDoubleOption(opt, 0, 1)),
OptionHandlerFactory.CreateBoolOption(
"replicateOutputsToWorkers",
sign => distributionConfiguration.ReplicateOutputsToWorkers = sign),
OptionHandlerFactory.CreateBoolOption(
"respectWeakFingerprintForNugetUpToDateCheck",
sign => frontEndConfiguration.RespectWeakFingerprintForNugetUpToDateCheck = sign),
OptionHandlerFactory.CreateBoolOption(
"reuseEngineState",
sign => engineConfiguration.ReuseEngineState = sign),
OptionHandlerFactory.CreateBoolOption(
"reuseOutputsOnDisk",
sign => schedulingConfiguration.ReuseOutputsOnDisk = sign),
OptionHandlerFactory.CreateOption2(
"rootMap",
"rm",
opt => ParseKeyValueOption(opt, pathTable, engineConfiguration.RootMap)),
OptionHandlerFactory.CreateBoolOptionWithValue(
"runInSubst",
(opt, sign) => configuration.RunInSubst = sign),
OptionHandlerFactory.CreateOption(
"sandboxKind",
opt =>
{
var parsedOption = CommandLineUtilities.ParseEnumOption<SandboxKind>(opt);
#if PLATFORM_OSX
var isEndpointSecurityOrHybridSandboxKind = (parsedOption == SandboxKind.MacOsEndpointSecurity || parsedOption == SandboxKind.MacOsHybrid);
if (isEndpointSecurityOrHybridSandboxKind && !OperatingSystemHelper.IsMacWithoutKernelExtensionSupport)
{
parsedOption = SandboxKind.MacOsKext;
}
#endif
sandboxConfiguration.UnsafeSandboxConfigurationMutable.SandboxKind = parsedOption;
if ((parsedOption.ToString().StartsWith("Win") && OperatingSystemHelper.IsUnixOS) ||
(parsedOption.ToString().StartsWith("Mac") && !OperatingSystemHelper.IsUnixOS))
{
var osName = OperatingSystemHelper.IsUnixOS ? "Unix-based" : "Windows";
throw CommandLineUtilities.Error(Strings.Args_SandboxKind_WrongPlatform, parsedOption, osName);
}
}),
OptionHandlerFactory.CreateBoolOption(
"SaveFingerprintStoreToLogs",
sign => loggingConfiguration.SaveFingerprintStoreToLogs = sign),
OptionHandlerFactory.CreateBoolOption(
"scanChangeJournal",
sign => engineConfiguration.ScanChangeJournal = sign),
OptionHandlerFactory.CreateOption(
"scanChangeJournalTimeLimitInSec",
opt => engineConfiguration.ScanChangeJournalTimeLimitInSec = CommandLineUtilities.ParseInt32Option(opt, -1, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"scheduleMetaPips",
sign => schedulingConfiguration.ScheduleMetaPips = sign),
OptionHandlerFactory.CreateOption2(
"scriptFile",
"s",
opt =>
{
throw CommandLineUtilities.Error(Strings.Args_ScriptFile_Deprecated, CommandLineUtilities.ParseStringOption(opt));
}),
OptionHandlerFactory.CreateBoolOption(
"scrub",
sign => engineConfiguration.Scrub = sign),
OptionHandlerFactory.CreateOption(
"scrubDirectory",
opt => engineConfiguration.ScrubDirectories.Add(CommandLineUtilities.ParsePathOption(opt, pathTable))),
OptionHandlerFactory.CreateBoolOptionWithValue(
"server",
(opt, sign) =>
configuration.Server = CommandLineUtilities.ParseBoolEnumOption(opt, sign, ServerMode.Enabled, ServerMode.Disabled),
isEnabled: (() => configuration.Server != ServerMode.Disabled)),
OptionHandlerFactory.CreateOption(
"serverDeploymentDir",
opt => configuration.ServerDeploymentDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"serverMaxIdleTimeInMinutes",
opt =>
configuration.ServerMaxIdleTimeInMinutes = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"skipHashSourceFile",
sign =>
schedulingConfiguration.SkipHashSourceFile = sign),
OptionHandlerFactory.CreateOption(
"snap",
opt => exportConfiguration.SnapshotFile = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"snapshotMode",
opt => exportConfiguration.SnapshotMode = CommandLineUtilities.ParseEnumOption<SnapshotMode>(opt)),
OptionHandlerFactory.CreateOption(
"solutionName",
opt =>
ideConfiguration.SolutionName = PathAtom.Create(pathTable.StringTable, CommandLineUtilities.ParseStringOption(opt))),
OptionHandlerFactory.CreateOption(
"statusFrequencyMs",
opt => loggingConfiguration.StatusFrequencyMs = CommandLineUtilities.ParseInt32Option(opt, 1, 60000)),
OptionHandlerFactory.CreateBoolOption(
"stopOnFirstError",
sign =>
{
schedulingConfiguration.StopOnFirstError = sign;
frontEndConfiguration.CancelEvaluationOnFirstFailure = sign;
}),
// TODO:not used. Deprecate
OptionHandlerFactory.CreateOption2(
"storageRoot",
"sr",
opt => layoutConfiguration.OutputDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOptionWithValue(
"storeFingerprints",
(opt, sign) =>
HandleStoreFingerprintsOption(
opt,
sign,
loggingConfiguration)),
OptionHandlerFactory.CreateBoolOption(
"storeOutputsToCache",
sign => schedulingConfiguration.StoreOutputsToCache = sign),
OptionHandlerFactory.CreateOption(
"substSource",
opt => loggingConfiguration.SubstSource = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"substTarget",
opt => loggingConfiguration.SubstTarget = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateOption(
"telemetryTagPrefix",
opt => schedulingConfiguration.TelemetryTagPrefix = CommandLineUtilities.ParseStringOption(opt)),
OptionHandlerFactory.CreateOption(
"tempDirectory",
opt => layoutConfiguration.TempDirectory = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"temporary_PreserveOutputsForIncrementalTool",
sign =>
sandboxConfiguration.PreserveOutputsForIncrementalTool = sign),
OptionHandlerFactory.CreateBoolOption(
"stopDirtyOnSucceedFastPips",
sign =>
schedulingConfiguration.StopDirtyOnSucceedFastPips = sign),
OptionHandlerFactory.CreateBoolOption(
"enableMemoryMappedBasedFileHashing",
sign => {
#if NET_COREAPP
if (sign)
{
ContentHashingUtilities.EnableMemoryMappedBasedFileHashing();
}
else
{
ContentHashingUtilities.DisableMemoryMappedBasedFileHashing();
}
#endif // NET_COREAPP
// if it's not NET_COREAPP - do nothing
}),
OptionHandlerFactory.CreateOption(
"traceInfo",
opt => CommandLineUtilities.ParsePropertyOption(opt, loggingConfiguration.TraceInfo)),
OptionHandlerFactory.CreateBoolOption(
"trackBuildsInUserFolder",
opt => engineConfiguration.TrackBuildsInUserFolder = opt),
OptionHandlerFactory.CreateBoolOption(
"trackGvfsProjections",
opt => engineConfiguration.TrackGvfsProjections = opt),
OptionHandlerFactory.CreateBoolOption(
"trackMethodInvocations",
opt => frontEndConfiguration.TrackMethodInvocations = opt),
OptionHandlerFactory.CreateOption(
"translateDirectory",
opt => ParseTranslateDirectoriesOption(pathTable, opt, engineConfiguration.DirectoriesToTranslate)),
OptionHandlerFactory.CreateOption(
"enforceFullReparsePointsUnderPath",
opt => sandboxConfiguration.DirectoriesToEnableFullReparsePointParsing.Add(CommandLineUtilities.ParsePathOption(opt, pathTable))),
OptionHandlerFactory.CreateBoolOption(
"treatAbsentDirectoryAsExistentUnderOpaque",
sign => schedulingConfiguration.TreatAbsentDirectoryAsExistentUnderOpaque = sign),
OptionHandlerFactory.CreateBoolOption(
"treatDirectoryAsAbsentFileOnHashingInputContent",
sign => schedulingConfiguration.TreatDirectoryAsAbsentFileOnHashingInputContent = sign),
OptionHandlerFactory.CreateBoolOption(
"typeCheck",
sign => { /* Do nothing Office still passes this flag even though it is deprecated. */ }),
// <Begin unsafe arguments>
// Unsafe options should follow the pattern that enabling them (i.e. "/unsafe_option" or "/unsafe_option+") should lead to an unsafe configuration
// Unsafe options must pass the optional parameter isUnsafe as true
// IMPORTANT: If an unsafe option is added here, there should also be a new warning logging function added.
// The logging function should be added to the unsafeOptionLoggers dictionary in LogAndValidateConfiguration()
OptionHandlerFactory.CreateBoolOption(
"unsafe_AllowCopySymlink",
sign => schedulingConfiguration.AllowCopySymlink = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_AllowDuplicateTemporaryDirectory",
sign => engineConfiguration.AllowDuplicateTemporaryDirectory = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_DisableCycleDetection",
sign => frontEndConfiguration.DisableCycleDetection = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_DisableDetours",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.SandboxKind = sign ? SandboxKind.None : SandboxKind.Default,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_DisableGraphPostValidation",
sign => schedulingConfiguration.UnsafeDisableGraphPostValidation = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_DisableSharedOpaqueEmptyDirectoryScrubbing",
sign => schedulingConfiguration.UnsafeDisableSharedOpaqueEmptyDirectoryScrubbing = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_ExistingDirectoryProbesAsEnumerations",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.ExistingDirectoryProbesAsEnumerations = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOptionWithValue(
"unsafe_ForceSkipDeps",
(opt, sign) => HandleForceSkipDependenciesOption(opt, sign, schedulingConfiguration),
isUnsafe: true),
OptionHandlerFactory.CreateOption(
"unsafe_GlobalPassthroughEnvVars",
opt => sandboxConfiguration.GlobalUnsafePassthroughEnvironmentVariables.AddRange(CommandLineUtilities.ParseRepeatingOption(opt, ";", v => v ))),
OptionHandlerFactory.CreateOption(
"unsafe_GlobalUntrackedScopes",
opt => sandboxConfiguration.GlobalUnsafeUntrackedScopes.AddRange(CommandLineUtilities.ParseRepeatingPathOption(opt, pathTable, ";"))),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreCreateProcessReport",
sign =>
{
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreCreateProcessReport = sign;
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreGetFinalPathNameByHandle",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreGetFinalPathNameByHandle = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreNonCreateFileReparsePoints",
sign =>
{
if (sign && OperatingSystemHelper.IsUnixOS)
{
throw CommandLineUtilities.Error("/unsafe_IgnoreReparsePoints not allowed on non-Windows OS");
}
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreNonCreateFileReparsePoints = sign;
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreNonExistentProbes", sign =>
{
// Error if it is set. Noop when unset for legacy command line compatibility. Make sure Office
// is no longer setting this before removing it.
if (sign)
{
throw CommandLineUtilities.Error("/unsafe_IgnoreNonExistentProbes is deprecated.");
}
},
inactive: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreNtCreateFile",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.MonitorNtCreateFile = !sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnorePreserveOutputsPrivatization",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnorePreserveOutputsPrivatization = !sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreProducingSymlinks",
sign => { /* DO NOTHING - Flag deprecated */},
isUnsafe: false,
inactive: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreReparsePoints",
sign =>
{
if (sign && OperatingSystemHelper.IsUnixOS)
{
throw CommandLineUtilities.Error("/unsafe_IgnoreReparsePoints not allowed on non-Windows OS");
}
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreReparsePoints = sign;
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreFullReparsePointResolving",
sign =>
{
if (sign && OperatingSystemHelper.IsUnixOS)
{
throw CommandLineUtilities.Error("/unsafe_IgnoreFullReparsePointResolving not allowed on non-Windows OS");
}
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreFullReparsePointResolving = sign;
sandboxConfiguration.UnsafeSandboxConfigurationMutable.EnableFullReparsePointResolving = !sign;
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnorePreloadedDlls",
sign =>
{
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnorePreloadedDlls = sign;
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOptionWithValue(
"unsafe_IgnoreDynamicWritesOnAbsentProbes",
(opt, sign) =>
{
var value = CommandLineUtilities.ParseBoolEnumOption(opt, sign,
trueValue: DynamicWriteOnAbsentProbePolicy.IgnoreAll,
falseValue: DynamicWriteOnAbsentProbePolicy.IgnoreNothing);
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreDynamicWritesOnAbsentProbes = value;
},
isUnsafe: true,
isEnabled: () => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreDynamicWritesOnAbsentProbes != DynamicWriteOnAbsentProbePolicy.IgnoreNothing),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreSetFileInformationByHandle",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreSetFileInformationByHandle = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreUndeclaredAccessesUnderSharedOpaques",
sign =>
sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreUndeclaredAccessesUnderSharedOpaques = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreValidateExistingFileAccessesForOutputs",
sign => { /* Do nothing Office and WDG are still passing this flag even though it is deprecated. */ }),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreZwCreateOpenQueryFamily",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.MonitorZwCreateOpenQueryFile = !sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreZwOtherFileInformation",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreZwOtherFileInformation = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_IgnoreZwRenameFileInformation",
sign => sandboxConfiguration.UnsafeSandboxConfigurationMutable.IgnoreZwRenameFileInformation = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_MonitorFileAccesses",
sign =>
sandboxConfiguration.UnsafeSandboxConfigurationMutable.MonitorFileAccesses = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_OptimizedAstConversion",
sign =>
frontEndConfiguration.UnsafeOptimizedAstConversion = sign,
isUnsafe: true),
OptionHandlerFactory.CreateBoolOptionWithValue(
"unsafe_PreserveOutputs",
(opt, sign) =>
sandboxConfiguration.UnsafeSandboxConfigurationMutable.PreserveOutputs =
CommandLineUtilities.ParseBoolEnumOption(opt, sign, PreserveOutputsMode.Enabled, PreserveOutputsMode.Disabled),
isUnsafe: true,
isEnabled: (() => sandboxConfiguration.UnsafeSandboxConfiguration.PreserveOutputs != PreserveOutputsMode.Disabled)),
OptionHandlerFactory.CreateOption(
"unsafe_PreserveOutputsTrustLevel",
(opt) => sandboxConfiguration.UnsafeSandboxConfigurationMutable.PreserveOutputsTrustLevel =
CommandLineUtilities.ParseInt32Option(opt, (int)PreserveOutputsTrustValue.Lowest, int.MaxValue),
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_ProbeDirectorySymlinkAsDirectory",
sign =>
{
sandboxConfiguration.UnsafeSandboxConfigurationMutable.ProbeDirectorySymlinkAsDirectory = sign;
},
isUnsafe: true),
// TODO: Remove this!
OptionHandlerFactory.CreateBoolOption(
"unsafe_SourceFileCanBeInsideOutputDirectory",
sign => { /* DEPRECATED -- DO NOTHING */ },
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_UnexpectedFileAccessesAreErrors",
sign =>
{
sandboxConfiguration.UnsafeSandboxConfigurationMutable.UnexpectedFileAccessesAreErrors = sign;
if (sign)
{
unsafeUnexpectedFileAccessesAreErrorsSet = true;
}
},
isUnsafe: true),
OptionHandlerFactory.CreateBoolOption(
"unsafe_SkipFlaggingSharedOpaqueOutputs",
sign => { sandboxConfiguration.UnsafeSandboxConfigurationMutable.SkipFlaggingSharedOpaqueOutputs = sign; },
isUnsafe: true),
// </ end unsafe options>
OptionHandlerFactory.CreateBoolOption(
"updateFileContentTableByScanningChangeJournal",
sign => schedulingConfiguration.UpdateFileContentTableByScanningChangeJournal = sign),
OptionHandlerFactory.CreateBoolOption(
"useCustomPipDescriptionOnConsole",
sign => loggingConfiguration.UseCustomPipDescriptionOnConsole = sign),
OptionHandlerFactory.CreateBoolOption(
"useExtraThreadToDrainNtClose",
sign => sandboxConfiguration.UseExtraThreadToDrainNtClose = sign),
OptionHandlerFactory.CreateBoolOption(
"useFileContentTable",
sign => engineConfiguration.UseFileContentTable = sign),
OptionHandlerFactory.CreateBoolOption(
"useFixedApiServerMoniker",
sign => schedulingConfiguration.UseFixedApiServerMoniker = sign),
OptionHandlerFactory.CreateBoolOption(
"useHardlinks",
sign => engineConfiguration.UseHardlinks = sign),
OptionHandlerFactory.CreateBoolOption(
"useHistoricalCpuUsageInfo",
sign => schedulingConfiguration.UseHistoricalCpuUsageInfo = sign),
OptionHandlerFactory.CreateBoolOption(
"useHistoricalRamUsageInfo",
sign => schedulingConfiguration.UseHistoricalRamUsageInfo = sign),
OptionHandlerFactory.CreateOption(
"useJournalForProbesMode",
opt => { /* Do nothing Office is still passing this flag even though it is deprecated. */ }),
OptionHandlerFactory.CreateBoolOption(
"useLargeNtClosePreallocatedList",
sign => sandboxConfiguration.UseLargeNtClosePreallocatedList = sign),
OptionHandlerFactory.CreateBoolOption(
"useLocalOnlyCache",
sign => cacheConfiguration.UseLocalOnly = sign),
OptionHandlerFactory.CreateBoolOption(
"usePackagesFromFileSystem",
sign => frontEndConfiguration.UsePackagesFromFileSystem = sign),
OptionHandlerFactory.CreateBoolOption(
"usePartialEvaluation",
sign => frontEndConfiguration.UsePartialEvaluation = sign),
OptionHandlerFactory.CreateOption(
"validateCgManifestForNugets",
opt => frontEndConfiguration.ValidateCgManifestForNugets = CommandLineUtilities.ParsePathOption(opt, pathTable)),
OptionHandlerFactory.CreateBoolOption(
"validateDistribution",
sign => distributionConfiguration.ValidateDistribution = sign),
OptionHandlerFactory.CreateBoolOption(
"validateExistingFileAccessesForOutputs",
sign => { /* Do nothing Office and WDG are still passing this flag even though it is deprecated. */ }),
OptionHandlerFactory.CreateBoolOption(
"verifyCacheLookupPin",
sign => schedulingConfiguration.VerifyCacheLookupPin = sign),
OptionHandlerFactory.CreateBoolOption(
"verifySourceFilesOnWorkers",
opt => distributionConfiguration.VerifySourceFilesOnWorkers = opt),
OptionHandlerFactory.CreateBoolOption(
"virtualizeUnknownPips",
sign => cacheConfiguration.VirtualizeUnknownPips = sign),
OptionHandlerFactory.CreateOption(
"vfsCasRoot",
opt => cacheConfiguration.VfsCasRoot = CommandLineUtilities.ParsePathOption(opt, pathTable)),
/* The viewer is currently broken. Leaving the code around so we can dust it off at some point. AB#1609082
OptionHandlerFactory.CreateOption(
"viewer",
opt => configuration.Viewer = CommandLineUtilities.ParseEnumOption<ViewerMode>(opt)),*/
OptionHandlerFactory.CreateOption(
"vmConcurrencyLimit",
opt => sandboxConfiguration.VmConcurrencyLimit = CommandLineUtilities.ParseInt32Option(opt, 1, int.MaxValue)),
OptionHandlerFactory.CreateBoolOption(
"vs",
sign => ideConfiguration.IsEnabled = sign),
OptionHandlerFactory.CreateBoolOption(
"vsNew", // temporary undocumented option for enabling new VS solution generation
sign => ideConfiguration.IsNewEnabled = sign),
OptionHandlerFactory.CreateBoolOption(
"vsOutputSrc",
sign => ideConfiguration.CanWriteToSrc = sign),
OptionHandlerFactory.CreateOption2(
"vsTF",
"vsTargetFramework",
opt => ParseStringOption(opt, ideConfiguration.TargetFrameworks)),
OptionHandlerFactory.CreateBoolOptionWithValue(
"warnAsError",
(opt, sign) =>
{
ParseInt32ListOption(opt, sign ? loggingConfiguration.WarningsAsErrors : loggingConfiguration.WarningsNotAsErrors);
// /warnAsError may be specified globally for all warnings, in which case it won't have any messages.
// In that case make sure the TreatWarningsAsErrors flag is set correctly
if (sign && loggingConfiguration.WarningsAsErrors.Count == 0)
{
loggingConfiguration.TreatWarningsAsErrors = true;
}
else if (!sign && loggingConfiguration.WarningsNotAsErrors.Count == 0)
{
loggingConfiguration.TreatWarningsAsErrors = false;
}
}
),
OptionHandlerFactory.CreateBoolOption(
"enablePlugins",
sign => schedulingConfiguration.EnablePlugin = sign),
OptionHandlerFactory.CreateOption(
"pluginPaths",
opt => schedulingConfiguration.PluginLocations.AddRange(CommandLineUtilities.ParseRepeatingPathOption(opt, pathTable, ";"))),
/////////// ATTENTION
// When you insert new options, maintain the alphabetical order as much as possible, at least
// according to the long names of the options. For details, please read the constraints specified as notes
// at the top of this statement code.
}.SelectMany(x => x)
.OrderBy(opt => opt.OptionName, StringComparer.OrdinalIgnoreCase)
.ToArray();
#if DEBUG
// Check that the table of m_handlers is properly sorted according to the options' long names.
for (int i = 1; i < m_handlers.Length; i++)
{
Contract.Assert(
string.Compare(m_handlers[i - 1].OptionName, m_handlers[i].OptionName, StringComparison.OrdinalIgnoreCase) <= 0,
"Option m_handlers must be sorted. Entry " + i + " = " + m_handlers[i].OptionName);
}
#endif
// Unsafe options that do not follow the correct enabled-is-unsafe configuration pattern.
// These are options for which /unsafe_option- results in an unsafe mode.
// This list should not grow! It exists to retroactively handle flags in use that we cannot change.
var specialCaseUnsafeOptions =
new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{
"unsafe_MonitorFileAccesses-",
"unsafe_UnexpectedFileAccessesAreErrors-",
};
// Iterate through each argument, looking each argument up in the table.
IterateArgs(cl, configuration, specialCaseUnsafeOptions);
AddABTestingArgs(pathTable, configuration, specialCaseUnsafeOptions);
foreach (string arg in cl.Arguments)
{
startupConfiguration.ImplicitFilters.Add(arg);
}
// We require a config file for non-server mode builds and if the user does not pass /setupJournal argument
if (configuration.Help == HelpLevel.None && Environment.GetEnvironmentVariable(Program.BuildXlAppServerConfigVariable) == null && !startupConfiguration.ConfigFile.IsValid)
{
throw CommandLineUtilities.Error(Strings.Args_Args_NoConfigGiven);
}
// If incompatible flags were specified (/unsafe_UnexpectedFileAccessesAreErrors- and /failPipOnFileAccessError- ) fail.
if (failPipOnFileAccessErrorSet && unsafeUnexpectedFileAccessesAreErrorsSet)
{
throw CommandLineUtilities.Error(Strings.Args_FileAccessAsErrors_FailPipFlags);
}
if (schedulingConfiguration.DelayedCacheLookupMinMultiplier.HasValue ^ schedulingConfiguration.DelayedCacheLookupMaxMultiplier.HasValue)
{
throw CommandLineUtilities.Error("Both /delayCacheLookupMin and /delayCacheLookupMax must be specified.");
}
if (schedulingConfiguration.DelayedCacheLookupMinMultiplier.HasValue
&& schedulingConfiguration.DelayedCacheLookupMinMultiplier.Value > schedulingConfiguration.DelayedCacheLookupMaxMultiplier.Value)
{
throw CommandLineUtilities.Error("Both /delayCacheLookupMin cannot be bigger than /delayCacheLookupMax.");
}
// Validate logging configuration.
ValidateLoggingConfiguration(loggingConfiguration);
// FileSystemMode can be dynamic based on what build mode is being used
if (sandboxConfiguration.FileSystemMode == FileSystemMode.Unset)
{
// DScript is essentially always a partial graph. So use the minimal pip graph so the
// per-pip filesystem view is consistent build over build regardless of what's being built
sandboxConfiguration.FileSystemMode = FileSystemMode.RealAndMinimalPipGraph;
}
// Some behavior should be forced a particular way when run in CloudBuild. In general this list should
// be kept relatively small in favor of configuration of default at a CloudBuild workflow layer, since
// settings here are expensive to change and trump external behavior.
if (configuration.InCloudBuild())
{
configuration.Server = ServerMode.Disabled;
if (!loggingConfiguration.RemoteTelemetry.HasValue)
{
loggingConfiguration.RemoteTelemetry = RemoteTelemetry.EnabledAndNotify;
}
cacheConfiguration.CacheGraph = true;
// Forcefully disable incremental scheduling in CB.
schedulingConfiguration.IncrementalScheduling = false;
// if not explicitly disabled, enable user profile redirect and force the location
if (!enableProfileRedirect.HasValue || enableProfileRedirect.Value)
{
layoutConfiguration.RedirectedUserProfileJunctionRoot = AbsolutePath.Create(pathTable, RedirectedUserProfileLocationInCloudBuild);
enableProfileRedirect = true;
}
}
if (!OperatingSystemHelper.IsUnixOS)
{
// if /enableProfileRedirect was set, RedirectedUserProfileJunctionRoot must have been set as well
// (either explicitly via /redirectedUserProfilePath argument or implicitly via /inCloudBuild flag)
if (enableProfileRedirect.HasValue && enableProfileRedirect.Value && !layoutConfiguration.RedirectedUserProfileJunctionRoot.IsValid)
{
throw CommandLineUtilities.Error(Strings.Args_ProfileRedirectEnabled_NoPathProvided);
}
if (!enableProfileRedirect.HasValue || enableProfileRedirect.HasValue && !enableProfileRedirect.Value)
{
layoutConfiguration.RedirectedUserProfileJunctionRoot = AbsolutePath.Invalid;
}
}
else
{
// profile redirection only happens on Windows
layoutConfiguration.RedirectedUserProfileJunctionRoot = AbsolutePath.Invalid;
}
if (OperatingSystemHelper.IsUnixOS)
{
// TODO: Non Windows OS doesn't support admin-required process external execution mode.
if (sandboxConfiguration.AdminRequiredProcessExecutionMode != AdminRequiredProcessExecutionMode.Internal)
{
throw CommandLineUtilities.Error(Strings.Args_AdminRequiredProcessExecutionMode_NotSupportedOnNonWindows, sandboxConfiguration.AdminRequiredProcessExecutionMode.ToString());
}
}
// Disable reuseEngineState (enabled by default) in case of /server- or /cacheGraph- (even if /reuseEngineState+ is passed)
if (configuration.Server == ServerMode.Disabled || !cacheConfiguration.CacheGraph)
{
engineConfiguration.ReuseEngineState = false;
}
if (ideConfiguration.IsEnabled)
{
// Disable incrementalScheduling if the /vs is passed. IDE generator needs to catch all scheduled nodes and should not ignore the skipped ones due to the incremental scheduling
schedulingConfiguration.IncrementalScheduling = false;
}
// Disable any options that may prevent cache convergence
if (engineConfiguration.Converge)
{
schedulingConfiguration.IncrementalScheduling = false;
}
// Disable any option that may interfere with determinism validation
if (cacheConfiguration.DeterminismProbe)
{
schedulingConfiguration.IncrementalScheduling = false;
}
arguments = configuration;
return true;
}
catch (Exception ex)
{
// TODO: The IToolParameterValue interface doesn't fit BuildXL well since it makes the command line
// argument code report errors. That should really be a responsibility of the hosting application. We
// can get by as-is for now since in server mode the client application always parses the command line
// and the server can reasonably assume there won't be command line errors by the time it is invoked.
m_console.WriteOutputLine(MessageLevel.Error, ex.GetLogEventMessage());
m_console.WriteOutputLine(MessageLevel.Error, string.Empty);
m_console.WriteOutputLine(MessageLevel.Error, Environment.CommandLine);
arguments = null;
return false;
}
}