protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string baseDirectory, string additionalReferencePaths, string tempPath)
: base(parser, responseFile, args, baseDirectory, additionalReferencePaths, tempPath)
{
Debug.Assert(responseFile == null || Path.IsPathRooted(responseFile));
_responseFile = responseFile;
_diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string baseDirectory, string additionalReferencePaths, string tempPath)
: base(parser, responseFile, args, baseDirectory, additionalReferencePaths, tempPath)
{
Debug.Assert(responseFile == null || Path.IsPathRooted(responseFile));
_responseFile = responseFile;
_diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
}
public static CSharpParseOptions FromVsValues(IList <string> options)
{
var parser = new CSharpCommandLineParser();
var diags = new List <Diagnostic>();
parser.ResetXSharpCommandlineOptions();
var defines = new List <string>();
var definesUpper = new List <string>();
foreach (var opt in options)
{
string name, value;
var pos = opt.IndexOf(":");
if (pos > 0)
{
name = opt.Substring(0, pos);
value = opt.Substring(pos + 1);
}
else
{
name = opt;
value = "";
}
if (name == "d")
{
var defs = value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
defines.AddRange(defs);
foreach (var d in defs)
{
definesUpper.Add(d.ToUpper());
}
}
else
{
parser.ParseXSharpArgument(ref name, ref value, "", diags);
}
}
var xopts = parser.XSharpSpecificCompilationOptions;
var result = new CSharpParseOptions().WithXSharpSpecificOptions(xopts);
result.PreprocessorSymbols = defines;
result.PreprocessorSymbolsUpper = definesUpper;
return(result);
}
protected CSharpCompiler(
CSharpCommandLineParser parser,
string?responseFile,
string[] args,
BuildPaths buildPaths,
string?additionalReferenceDirectories,
IAnalyzerAssemblyLoader assemblyLoader
)
: base(
parser,
responseFile,
args,
buildPaths,
additionalReferenceDirectories,
assemblyLoader
)
{
_diagnosticFormatter = new CommandLineDiagnosticFormatter(
buildPaths.WorkingDirectory,
Arguments.PrintFullPaths,
Arguments.ShouldIncludeErrorEndLocation
);
_tempDirectory = buildPaths.TempDirectory;
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectory, string additionalReferenceDirectories)
: base(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectory, additionalReferenceDirectories)
{
_diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader)
: base(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories, analyzerLoader)
{
_diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string clientDirectory, string baseDirectory, string sdkDirectoryOpt, string additionalReferenceDirectories, IAnalyzerAssemblyLoader analyzerLoader)
: base(parser, responseFile, args, clientDirectory, baseDirectory, sdkDirectoryOpt, additionalReferenceDirectories, analyzerLoader)
{
_diagnosticFormatter = ReflCommandLineDiagnosticFormatter.ctor(baseDirectory, Arguments.PrintFullPaths, ReflCSharpCommandLineArguments.get_ShouldIncludeErrorEndLocation(Arguments));
}
public bool SetDefineConstants(string defineConstants)
{
if (!string.IsNullOrEmpty(defineConstants))
{
IEnumerable <Diagnostic> diagnostics;
this.ParseOptions = this.ParseOptions.WithPreprocessorSymbols(CSharpCommandLineParser.ParseConditionalCompilationSymbols(defineConstants, out diagnostics));
return(true);
}
return(false);
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, string baseDirectory, string additionalReferencePaths)
: base(parser, responseFile, args, baseDirectory, additionalReferencePaths)
{
this.diagnosticFormatter = new CommandLineDiagnosticFormatter(baseDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
}
public HostBuildData Create(HostBuildOptions options)
{
var parseOptions = new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6, documentationMode: DocumentationMode.Parse);
var compilationOptions = new CSharpCompilationOptions(
OutputKind.ConsoleApplication,
xmlReferenceResolver: new XmlFileResolver(options.ProjectDirectory),
sourceReferenceResolver: new SourceFileResolver(ImmutableArray <string> .Empty, options.ProjectDirectory),
metadataReferenceResolver: new AssemblyReferenceResolver(
new MetadataFileReferenceResolver(ImmutableArray <string> .Empty, options.ProjectDirectory),
MetadataFileReferenceProvider.Default),
strongNameProvider: new DesktopStrongNameProvider(ImmutableArray.Create(options.ProjectDirectory, options.OutputDirectory)),
assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default);
var warnings = new List <KeyValuePair <string, ReportDiagnostic> >(options.Warnings);
if (options.OutputKind.HasValue)
{
var kind = options.OutputKind.Value;
compilationOptions = compilationOptions.WithOutputKind(kind);
if (compilationOptions.Platform == Platform.AnyCpu32BitPreferred &&
(kind == OutputKind.DynamicallyLinkedLibrary || kind == OutputKind.NetModule || kind == OutputKind.WindowsRuntimeMetadata))
{
compilationOptions = compilationOptions.WithPlatform(Platform.AnyCpu);
}
}
if (!string.IsNullOrEmpty(options.DefineConstants))
{
IEnumerable <Diagnostic> diagnostics;
parseOptions = parseOptions.WithPreprocessorSymbols(CSharpCommandLineParser.ParseConditionalCompilationSymbols(options.DefineConstants, out diagnostics));
}
if (options.DocumentationFile != null)
{
parseOptions = parseOptions.WithDocumentationMode(!string.IsNullOrEmpty(options.DocumentationFile) ? DocumentationMode.Diagnose : DocumentationMode.Parse);
}
if (options.LanguageVersion != null)
{
var languageVersion = CompilationOptionsConversion.GetLanguageVersion(options.LanguageVersion);
if (languageVersion.HasValue)
{
parseOptions = parseOptions.WithLanguageVersion(languageVersion.Value);
}
}
if (!string.IsNullOrEmpty(options.PlatformWith32BitPreference))
{
Platform platform;
if (Enum.TryParse <Platform>(options.PlatformWith32BitPreference, true, out platform))
{
if (platform == Platform.AnyCpu &&
compilationOptions.OutputKind != OutputKind.DynamicallyLinkedLibrary &&
compilationOptions.OutputKind != OutputKind.NetModule &&
compilationOptions.OutputKind != OutputKind.WindowsRuntimeMetadata)
{
platform = Platform.AnyCpu32BitPreferred;
}
compilationOptions = compilationOptions.WithPlatform(platform);
}
}
if (options.AllowUnsafeBlocks.HasValue)
{
compilationOptions = compilationOptions.WithAllowUnsafe(options.AllowUnsafeBlocks.Value);
}
if (options.CheckForOverflowUnderflow.HasValue)
{
compilationOptions = compilationOptions.WithOverflowChecks(options.CheckForOverflowUnderflow.Value);
}
if (options.DelaySign != null)
{
bool delaySignExplicitlySet = options.DelaySign.Item1;
bool delaySign = options.DelaySign.Item2;
compilationOptions = compilationOptions.WithDelaySign(delaySignExplicitlySet ? delaySign : (bool?)null);
}
if (!string.IsNullOrEmpty(options.ApplicationConfiguration))
{
var appConfigPath = FileUtilities.ResolveRelativePath(options.ApplicationConfiguration, options.ProjectDirectory);
try
{
using (var appConfigStream = PortableShim.FileStream.Create(appConfigPath, PortableShim.FileMode.Open, PortableShim.FileAccess.Read))
{
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.LoadFromXml(appConfigStream));
}
}
catch (Exception)
{
}
}
if (!string.IsNullOrEmpty(options.KeyContainer))
{
compilationOptions = compilationOptions.WithCryptoKeyContainer(options.KeyContainer);
}
if (!string.IsNullOrEmpty(options.KeyFile))
{
var fullPath = FileUtilities.ResolveRelativePath(options.KeyFile, options.ProjectDirectory);
compilationOptions = compilationOptions.WithCryptoKeyFile(fullPath);
}
if (!string.IsNullOrEmpty(options.MainEntryPoint))
{
compilationOptions = compilationOptions.WithMainTypeName(options.MainEntryPoint);
}
if (!string.IsNullOrEmpty(options.ModuleAssemblyName))
{
compilationOptions = compilationOptions.WithModuleName(options.ModuleAssemblyName);
}
if (options.Optimize.HasValue)
{
compilationOptions = compilationOptions.WithOptimizationLevel(options.Optimize.Value ? OptimizationLevel.Release : OptimizationLevel.Debug);
}
if (!string.IsNullOrEmpty(options.Platform))
{
Platform plat;
if (Enum.TryParse <Platform>(options.Platform, ignoreCase: true, result: out plat))
{
compilationOptions = compilationOptions.WithPlatform(plat);
}
}
// Get options from the ruleset file, if any.
if (!string.IsNullOrEmpty(options.RuleSetFile))
{
var fullPath = FileUtilities.ResolveRelativePath(options.RuleSetFile, options.ProjectDirectory);
Dictionary <string, ReportDiagnostic> specificDiagnosticOptions;
var generalDiagnosticOption = RuleSet.GetDiagnosticOptionsFromRulesetFile(fullPath, out specificDiagnosticOptions);
compilationOptions = compilationOptions.WithGeneralDiagnosticOption(generalDiagnosticOption);
warnings.AddRange(specificDiagnosticOptions);
}
if (options.WarningsAsErrors.HasValue)
{
compilationOptions = compilationOptions.WithGeneralDiagnosticOption(options.WarningsAsErrors.Value ? ReportDiagnostic.Error : ReportDiagnostic.Default);
}
if (options.WarningLevel.HasValue)
{
compilationOptions = compilationOptions.WithWarningLevel(options.WarningLevel.Value);
}
compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(warnings);
return(new HostBuildData(
parseOptions,
compilationOptions));
}
protected CSharpCompiler(CSharpCommandLineParser parser, string responseFile, string[] args, BuildPaths buildPaths, string additionalReferenceDirectories, IAnalyzerAssemblyLoader assemblyLoader)
: base(parser, responseFile, args, buildPaths, additionalReferenceDirectories, assemblyLoader)
{
_diagnosticFormatter = new CommandLineDiagnosticFormatter(buildPaths.WorkingDirectory, Arguments.PrintFullPaths, Arguments.ShouldIncludeErrorEndLocation);
_tempDirectory = buildPaths.TempDirectory;
}
