/// <summary> /// Gets the complete list of locations to locate references. /// </summary> /// <param name="args">Command line arguments.</param> /// <returns>List of directories.</returns> private static IEnumerable <string> FixedReferencePaths(Microsoft.CodeAnalysis.CommandLineArguments args) { // See https://msdn.microsoft.com/en-us/library/s5bac5fx.aspx // on how csc resolves references. Basically, // 1) Current working directory. This is the directory from which the compiler is invoked. // 2) The common language runtime system directory. // 3) Directories specified by / lib. // 4) Directories specified by the LIB environment variable. if (args.BaseDirectory is not null) { yield return(args.BaseDirectory); } foreach (var r in args.ReferencePaths) { yield return(r); } var lib = System.Environment.GetEnvironmentVariable("LIB"); if (lib is not null) { yield return(lib); } }
private void SetArgumentsCore(string commandLine, CommandLineArguments commandLineArguments) { lock (_gate) { _lastParsedCompilerOptions = commandLine; _lastParsedCommandLineArguments = commandLineArguments; } }
/// <summary> /// Creates new parse options from parsed command line arguments (with overridden default DocumentationMode). /// It is expected that derived types which need to add more specific options will fetch the base options and override those options. /// </summary> protected virtual ParseOptions CreateParseOptions(CommandLineArguments commandLineArguments) { Contract.ThrowIfNull(commandLineArguments); // Override the default documentation mode. var documentationMode = commandLineArguments.DocumentationPath != null ? DocumentationMode.Diagnose : DocumentationMode.Parse; return commandLineArguments.ParseOptions.WithDocumentationMode(documentationMode); }
private void PostSetOptions(CommandLineArguments commandLineArguments) { // Invoke SetOutputPathAndRelatedData to update the project obj output path. if (commandLineArguments.OutputFileName != null && commandLineArguments.OutputDirectory != null) { var objOutputPath = PathUtilities.CombinePathsUnchecked(commandLineArguments.OutputDirectory, commandLineArguments.OutputFileName); SetObjOutputPathAndRelatedData(objOutputPath); } }
private void PostSetCommandLineArguments(CommandLineArguments commandLineArguments) { // Invoke SetOutputPathAndRelatedData to update the project tracker bin path for this project, if required. if (commandLineArguments.OutputFileName != null && commandLineArguments.OutputDirectory != null) { var newOutputPath = PathUtilities.CombinePathsUnchecked(commandLineArguments.OutputDirectory, commandLineArguments.OutputFileName); SetOutputPathAndRelatedData(newOutputPath, hasSameBinAndObjOutputPaths: true); } }
/// <summary> /// Resets the last parsed command line and updates options with the same command line. /// </summary> /// <remarks> /// Use this method when options can go stale due to side effects, even though the command line is identical. /// For example, changes to contents of a ruleset file needs to force update the options for the same command line. /// </remarks> protected CommandLineArguments ResetArgumentsAndUpdateOptions() { // Clear last parsed command line. var savedLastParsedCompilerOptions = _lastParsedCompilerOptions; _lastParsedCompilerOptions = null; _lastParsedCommandLineArguments = null; // Now set arguments and update options with the saved command line. return SetArgumentsAndUpdateOptions(savedLastParsedCompilerOptions); }
/// <summary> /// If the command line has changed from the last parsed command line, then it parses it and sets new command line arguments. /// </summary> /// <param name="commandlineForOptions"></param> /// <returns></returns> protected CommandLineArguments SetArguments(string commandlineForOptions) { if (!string.Equals(_lastParsedCompilerOptions, commandlineForOptions, StringComparison.OrdinalIgnoreCase)) { // Command line options have changed, so update options with new parsed CommandLineArguments. var splitArguments = CommandLineParser.SplitCommandLineIntoArguments(commandlineForOptions, removeHashComments: false); _lastParsedCommandLineArguments = CommandLineParserService?.Parse(splitArguments, this.ContainingDirectoryPathOpt, isInteractive: false, sdkDirectory: null); _lastParsedCompilerOptions = commandlineForOptions; } return _lastParsedCommandLineArguments; }
IProjectContext IProjectContextFactory.CreateProjectContext( string languageName, string projectDisplayName, string projectFilePath, Guid projectGuid, string projectTypeGuid, IVsHierarchy hierarchy, CommandLineArguments commandLineArguments) { Contract.ThrowIfNull(hierarchy); Func<ProjectId, IVsReportExternalErrors> getExternalErrorReporter = id => GetExternalErrorReporter(id, languageName); return new CPSProject(commandLineArguments, _projectTracker, getExternalErrorReporter, projectDisplayName, projectFilePath, projectGuid, projectTypeGuid, hierarchy, languageName, _serviceProvider, _visualStudioWorkspace, _hostDiagnosticUpdateSource); }
/// <summary> /// Construct tasks for resolving references (possibly in parallel). /// /// The resolved references will be added (thread-safely) to the supplied /// list <paramref name="ret"/>. /// </summary> static IEnumerable <Action> ResolveReferences(Microsoft.CodeAnalysis.CommandLineArguments args, Analyser analyser, CanonicalPathCache canonicalPathCache, BlockingCollection <MetadataReference> ret) { var referencePaths = new Lazy <string[]>(() => FixedReferencePaths(args).ToArray()); return(args.MetadataReferences.Select <CommandLineReference, Action>(clref => () => { if (Path.IsPathRooted(clref.Reference)) { if (File.Exists(clref.Reference)) { var reference = MakeReference(clref, canonicalPathCache.GetCanonicalPath(clref.Reference)); ret.Add(reference); } else { lock (analyser) { analyser.Logger.Log(Severity.Error, " Reference '{0}' does not exist", clref.Reference); ++analyser.CompilationErrors; } } } else { bool referenceFound = false; { foreach (var composed in referencePaths.Value. Select(path => Path.Combine(path, clref.Reference)). Where(path => File.Exists(path)). Select(path => canonicalPathCache.GetCanonicalPath(path))) { referenceFound = true; var reference = MakeReference(clref, composed); ret.Add(reference); break; } if (!referenceFound) { lock (analyser) { analyser.Logger.Log(Severity.Error, " Unable to resolve reference '{0}'", clref.Reference); ++analyser.CompilationErrors; } } } } })); }
int ICompilerOptionsHostObject.SetCompilerOptions(string compilerOptions, out bool supported) { if (!string.Equals(_lastParsedCompilerOptions, compilerOptions)) { var splitArguments = CommandLineParser.SplitCommandLineIntoArguments(compilerOptions, removeHashComments: false); _lastParsedCommandLineArguments = ParseCommandLineArguments(splitArguments); _lastParsedCompilerOptions = compilerOptions; UpdateOptions(); } supported = true; return VSConstants.S_OK; }
/// <summary> /// Creates new compilation options from parsed command line arguments, with additional workspace specific options appended. /// It is expected that derived types which need to add more specific options will fetch the base options and override those options. /// </summary> protected virtual CompilationOptions CreateCompilationOptions(CommandLineArguments commandLineArguments, ParseOptions newParseOptions) { Contract.ThrowIfNull(commandLineArguments); // Get options from command line arguments. var options = commandLineArguments.CompilationOptions; // Now set the default workspace options (these are not set by the command line parser). string projectDirectory = this.ContainingDirectoryPathOpt; // TODO: #r support, should it include bin path? var referenceSearchPaths = ImmutableArray<string>.Empty; // TODO: #load support var sourceSearchPaths = ImmutableArray<string>.Empty; MetadataReferenceResolver referenceResolver; if (Workspace != null) { referenceResolver = new WorkspaceMetadataFileReferenceResolver( Workspace.CurrentSolution.Services.MetadataService, new RelativePathResolver(referenceSearchPaths, projectDirectory)); } else { // can only happen in tests referenceResolver = null; } // Explicitly disable concurrent build. options = options.WithConcurrentBuild(concurrent: false); // Set default resolvers. options = options.WithMetadataReferenceResolver(referenceResolver) .WithXmlReferenceResolver(new XmlFileResolver(projectDirectory)) .WithSourceReferenceResolver(new SourceFileResolver(sourceSearchPaths, projectDirectory)) .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default) .WithStrongNameProvider(new DesktopStrongNameProvider(GetStrongNameKeyPaths())); return options; }
public CPSProject( CommandLineArguments commandLineArguments, VisualStudioProjectTracker projectTracker, Func<ProjectId, IVsReportExternalErrors> reportExternalErrorCreatorOpt, string projectDisplayName, string projectFilePath, Guid projectGuid, string projectTypeGuid, IVsHierarchy hierarchy, string language, IServiceProvider serviceProvider, VisualStudioWorkspaceImpl visualStudioWorkspaceOpt, HostDiagnosticUpdateSource hostDiagnosticUpdateSourceOpt) : base(projectTracker, reportExternalErrorCreatorOpt, projectDisplayName, projectFilePath, projectGuid, projectTypeGuid, hierarchy, language, serviceProvider, visualStudioWorkspaceOpt, hostDiagnosticUpdateSourceOpt) { // Set the initial options from the command line before we add the project to the project tracker. SetCommandLineArguments(commandLineArguments); projectTracker.AddProject(this); }
// internal for testing internal static Stream GetWin32ResourcesInternal(CommonMessageProvider messageProvider, CommandLineArguments arguments, Compilation compilation, out IEnumerable<DiagnosticInfo> errors) { List<DiagnosticInfo> errorList = new List<DiagnosticInfo>(); errors = errorList; if (arguments.Win32ResourceFile != null) { return OpenStream(messageProvider, arguments.Win32ResourceFile, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Resource, errorList); } using (Stream manifestStream = OpenManifestStream(messageProvider, compilation.Options.OutputKind, arguments, errorList)) { using (Stream iconStream = OpenStream(messageProvider, arguments.Win32Icon, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Icon, errorList)) { try { return compilation.CreateDefaultWin32Resources(true, arguments.NoWin32Manifest, manifestStream, iconStream); } catch (ResourceException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } catch (OverflowException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } } } return null; }
protected Stream GetWin32Resources(CommandLineArguments arguments, Compilation compilation, out IEnumerable<DiagnosticInfo> errors) { return GetWin32ResourcesInternal(MessageProvider, arguments, compilation, out errors); }
// internal for testing purposes only. internal static CPSProject CreateCPSProject(VisualStudioProjectTracker projectTracker, IServiceProvider serviceProvider, IVsHierarchy hierarchy, string projectDisplayName, string projectFilePath, string language, Guid projectGuid, string projectTypeGuid, CommandLineArguments commandLineArguments) { return new CPSProject(commandLineArguments, projectTracker, reportExternalErrorCreatorOpt: null, hierarchy: hierarchy, language: language, serviceProvider: serviceProvider, visualStudioWorkspaceOpt: null, hostDiagnosticUpdateSourceOpt: null, projectDisplayName: projectDisplayName, projectFilePath: projectFilePath, projectGuid: projectGuid, projectTypeGuid: projectTypeGuid); }
/// <summary> /// The string returned from this function represents the inputs to the compiler which impact determinism. It is /// meant to be inline with the specification here: /// /// - https://github.com/dotnet/roslyn/blob/master/docs/compilers/Deterministic%20Inputs.md /// /// Issue #8193 tracks filling this out to the full specification. /// /// https://github.com/dotnet/roslyn/issues/8193 /// </summary> private static string CreateDeterminismKey(CommandLineArguments args, string[] rawArgs, string baseDirectory, CommandLineParser parser) { List<Diagnostic> diagnostics = new List<Diagnostic>(); List<string> flattenedArgs = new List<string>(); parser.FlattenArgs(rawArgs, diagnostics, flattenedArgs, null, baseDirectory); var builder = new StringBuilder(); var name = !string.IsNullOrEmpty(args.OutputFileName) ? Path.GetFileNameWithoutExtension(Path.GetFileName(args.OutputFileName)) : $"no-output-name-{Guid.NewGuid().ToString()}"; builder.AppendLine($"{name}"); builder.AppendLine($"Command Line:"); foreach (var current in flattenedArgs) { builder.AppendLine($"\t{current}"); } builder.AppendLine("Source Files:"); var hash = new MD5CryptoServiceProvider(); foreach (var sourceFile in args.SourceFiles) { var sourceFileName = Path.GetFileName(sourceFile.Path); string hashValue; try { var bytes = PortableShim.File.ReadAllBytes(sourceFile.Path); var hashBytes = hash.ComputeHash(bytes); var data = BitConverter.ToString(hashBytes); hashValue = data.Replace("-", ""); } catch (Exception ex) { hashValue = $"Could not compute {ex.Message}"; } builder.AppendLine($"\t{sourceFileName} - {hashValue}"); } return builder.ToString(); }
private static void EmitDeterminismKey(CommandLineArguments args, string[] rawArgs, string baseDirectory, CommandLineParser parser) { var key = CreateDeterminismKey(args, rawArgs, baseDirectory, parser); var filePath = Path.Combine(args.OutputDirectory, args.OutputFileName + ".key"); using (var stream = PortableShim.File.Create(filePath)) { var bytes = Encoding.UTF8.GetBytes(key); stream.Write(bytes, 0, bytes.Length); } }
public void SetCommandLineArguments(CommandLineArguments commandLineArguments) { SetArgumentsAndUpdateOptions(commandLineArguments); // If outputPath has changed, then invoke SetOutputPathAndRelatedData to update the project tracker bin path for this project. if (commandLineArguments.OutputFileName != null && commandLineArguments.OutputDirectory != null) { var newOutputPath = PathUtilities.CombinePathsUnchecked(commandLineArguments.OutputDirectory, commandLineArguments.OutputFileName); SetOutputPathAndRelatedData(newOutputPath, hasSameBinAndObjOutputPaths: true); } }
private static FileStream OpenManifestStream(CommonMessageProvider messageProvider, OutputKind outputKind, CommandLineArguments arguments, List <DiagnosticInfo> errorList) { return(outputKind.IsNetModule() ? null : OpenStream(messageProvider, arguments.Win32Manifest, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Manifest, errorList)); }
protected Stream GetWin32Resources(CommandLineArguments arguments, Compilation compilation, out IEnumerable <DiagnosticInfo> errors) { return(GetWin32ResourcesInternal(MessageProvider, arguments, compilation, out errors)); }
// internal for testing internal static Stream GetWin32ResourcesInternal(CommonMessageProvider messageProvider, CommandLineArguments arguments, Compilation compilation, out IEnumerable <DiagnosticInfo> errors) { List <DiagnosticInfo> errorList = new List <DiagnosticInfo>(); errors = errorList; if (arguments.Win32ResourceFile != null) { return(OpenStream(messageProvider, arguments.Win32ResourceFile, arguments.BaseDirectory, messageProvider.GetFieldOrProperty <int>("ERR_CantOpenWin32Resource"), errorList)); } using (Stream manifestStream = OpenManifestStream(messageProvider, compilation.Options.OutputKind, arguments, errorList)) { using (Stream iconStream = OpenStream(messageProvider, arguments.Win32Icon, arguments.BaseDirectory, messageProvider.GetFieldOrProperty <int>("ERR_CantOpenWin32Icon"), errorList)) { try { return(compilation.CreateDefaultWin32Resources(true, arguments.NoWin32Manifest, manifestStream, iconStream)); } catch (Exception ex) when(ex.GetType().FullName == "Microsoft.CodeAnalysis.ResourceException") { errorList.Add(ReflDiagnosticInfo.ctor(messageProvider, messageProvider.GetFieldOrProperty <int>("ERR_ErrorBuildingWin32Resource"), new[] { ex.Message })); } catch (OverflowException ex) { errorList.Add(ReflDiagnosticInfo.ctor(messageProvider, messageProvider.GetFieldOrProperty <int>("ERR_ErrorBuildingWin32Resource"), new[] { ex.Message })); } } } return(null); }
protected override ParseOptions CreateParseOptions(CommandLineArguments commandLineArguments) { // Get the base parse options and override the defaults with the options from state. var options = (CSharpParseOptions)base.CreateParseOptions(commandLineArguments); var symbols = GetStringOption(CompilerOptions.OPTID_CCSYMBOLS, defaultValue: "").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); DocumentationMode documentationMode = DocumentationMode.Parse; if (GetStringOption(CompilerOptions.OPTID_XML_DOCFILE, defaultValue: null) != null) { documentationMode = DocumentationMode.Diagnose; } var languageVersion = CompilationOptionsConversion.GetLanguageVersion(GetStringOption(CompilerOptions.OPTID_COMPATIBILITY, defaultValue: "")) ?? CSharpParseOptions.Default.LanguageVersion; return options.WithKind(SourceCodeKind.Regular) .WithLanguageVersion(languageVersion) .WithPreprocessorSymbols(symbols.AsImmutable()) .WithDocumentationMode(documentationMode); }
private static Stream OpenManifestStream(CommonMessageProvider messageProvider, OutputKind outputKind, CommandLineArguments arguments, List <DiagnosticInfo> errorList) { return(outputKind == OutputKind.NetModule ? null : OpenStream(messageProvider, arguments.Win32Manifest, arguments.BaseDirectory, messageProvider.GetFieldOrProperty <int>("ERR_CantOpenWin32Manifest"), errorList)); }
private static Stream OpenManifestStream(CommonMessageProvider messageProvider, OutputKind outputKind, CommandLineArguments arguments, List<DiagnosticInfo> errorList) { return outputKind.IsNetModule() ? null : OpenStream(messageProvider, arguments.Win32Manifest, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Manifest, errorList); }
// internal for testing internal static Stream GetWin32ResourcesInternal(CommonMessageProvider messageProvider, CommandLineArguments arguments, Compilation compilation, out IEnumerable <DiagnosticInfo> errors) { List <DiagnosticInfo> errorList = new List <DiagnosticInfo>(); errors = errorList; if (arguments.Win32ResourceFile != null) { return(OpenStream(messageProvider, arguments.Win32ResourceFile, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Resource, errorList)); } using (Stream manifestStream = OpenManifestStream(messageProvider, compilation.Options.OutputKind, arguments, errorList)) { using (Stream iconStream = OpenStream(messageProvider, arguments.Win32Icon, arguments.BaseDirectory, messageProvider.ERR_CantOpenWin32Icon, errorList)) { try { return(compilation.CreateDefaultWin32Resources(true, arguments.NoWin32Manifest, manifestStream, iconStream)); } catch (ResourceException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } catch (OverflowException ex) { errorList.Add(new DiagnosticInfo(messageProvider, messageProvider.ERR_ErrorBuildingWin32Resource, ex.Message)); } } } return(null); }
/// <summary> /// Sets the given command line arguments to be the last parsed command line arguments. /// </summary> protected void SetArguments(CommandLineArguments commandLineArguments) { _lastParsedCommandLineArguments = commandLineArguments; }
private static IReadOnlySet<string> GetEmbedddedSourcePaths(CommandLineArguments arguments) { if (arguments.EmbeddedFiles.IsEmpty) { return SpecializedCollections.EmptyReadOnlySet<string>(); } // Note that we require an exact match between source and embedded file paths (case-sensitive // and without normalization). If two files are the same but spelled differently, they will // be handled as separate files, meaning the embedding pass will read the content a second // time. This can also lead to more than one document entry in the PDB for the same document // if the PDB document de-duping policy in emit (normalize + case-sensitive in C#, // normalize + case-insensitive in VB) is not enough to converge them. var set = new HashSet<string>(arguments.EmbeddedFiles.Select(f => f.Path)); set.IntersectWith(arguments.SourceFiles.Select(f => f.Path)); return SpecializedCollections.StronglyTypedReadOnlySet(set); }
protected override CompilationOptions CreateCompilationOptions(CommandLineArguments commandLineArguments, ParseOptions newParseOptions) { // Get the base options from command line arguments + common workspace defaults. var options = (CSharpCompilationOptions)base.CreateCompilationOptions(commandLineArguments, newParseOptions); // Now override these with the options from our state. IDictionary<string, ReportDiagnostic> ruleSetSpecificDiagnosticOptions = null; // Get options from the ruleset file, if any, first. That way project-specific // options can override them. ReportDiagnostic? ruleSetGeneralDiagnosticOption = null; if (this.RuleSetFile != null) { ruleSetGeneralDiagnosticOption = this.RuleSetFile.GetGeneralDiagnosticOption(); ruleSetSpecificDiagnosticOptions = new Dictionary<string, ReportDiagnostic>(this.RuleSetFile.GetSpecificDiagnosticOptions()); } else { ruleSetSpecificDiagnosticOptions = new Dictionary<string, ReportDiagnostic>(); } UpdateRuleSetError(this.RuleSetFile); ReportDiagnostic generalDiagnosticOption; var warningsAreErrors = GetNullableBooleanOption(CompilerOptions.OPTID_WARNINGSAREERRORS); if (warningsAreErrors.HasValue) { generalDiagnosticOption = warningsAreErrors.Value ? ReportDiagnostic.Error : ReportDiagnostic.Default; } else if (ruleSetGeneralDiagnosticOption.HasValue) { generalDiagnosticOption = ruleSetGeneralDiagnosticOption.Value; } else { generalDiagnosticOption = ReportDiagnostic.Default; } // Start with the rule set options IDictionary<string, ReportDiagnostic> diagnosticOptions = new Dictionary<string, ReportDiagnostic>(ruleSetSpecificDiagnosticOptions); // Update the specific options based on the general settings if (warningsAreErrors.HasValue && warningsAreErrors.Value == true) { foreach (var pair in ruleSetSpecificDiagnosticOptions) { if (pair.Value == ReportDiagnostic.Warn) { diagnosticOptions[pair.Key] = ReportDiagnostic.Error; } } } // Update the specific options based on the specific settings foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_WARNASERRORLIST)) { diagnosticOptions[diagnosticID] = ReportDiagnostic.Error; } foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_WARNNOTASERRORLIST)) { ReportDiagnostic ruleSetOption; if (ruleSetSpecificDiagnosticOptions.TryGetValue(diagnosticID, out ruleSetOption)) { diagnosticOptions[diagnosticID] = ruleSetOption; } else { diagnosticOptions[diagnosticID] = ReportDiagnostic.Default; } } foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_NOWARNLIST)) { diagnosticOptions[diagnosticID] = ReportDiagnostic.Suppress; } Platform platform; if (!Enum.TryParse(GetStringOption(CompilerOptions.OPTID_PLATFORM, ""), ignoreCase: true, result: out platform)) { platform = Platform.AnyCpu; } int warningLevel; if (!int.TryParse(GetStringOption(CompilerOptions.OPTID_WARNINGLEVEL, defaultValue: ""), out warningLevel)) { warningLevel = 4; } // TODO: appConfigPath: GetFilePathOption(CompilerOptions.OPTID_FUSIONCONFIG), bug #869604 return options.WithAllowUnsafe(GetBooleanOption(CompilerOptions.OPTID_UNSAFE)) .WithOverflowChecks(GetBooleanOption(CompilerOptions.OPTID_CHECKED)) .WithCryptoKeyContainer(GetStringOption(CompilerOptions.OPTID_KEYNAME, defaultValue: null)) .WithCryptoKeyFile(GetFilePathRelativeOption(CompilerOptions.OPTID_KEYFILE)) .WithDelaySign(GetNullableBooleanOption(CompilerOptions.OPTID_DELAYSIGN)) .WithGeneralDiagnosticOption(generalDiagnosticOption) .WithMainTypeName(_mainTypeName) .WithModuleName(GetStringOption(CompilerOptions.OPTID_MODULEASSEMBLY, defaultValue: null)) .WithOptimizationLevel(GetBooleanOption(CompilerOptions.OPTID_OPTIMIZATIONS) ? OptimizationLevel.Release : OptimizationLevel.Debug) .WithOutputKind(_outputKind) .WithPlatform(platform) .WithSpecificDiagnosticOptions(diagnosticOptions) .WithWarningLevel(warningLevel); }
/// <summary> /// Sets the given command line arguments to be the last parsed command line arguments and /// creates and sets new options using these command line arguments. /// </summary> protected void SetArgumentsAndUpdateOptions(CommandLineArguments commandLineArguments) { SetArguments(commandLineArguments); UpdateOptions(); }