public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFileInfo projectFileInfo, CSharpCompilationOptions existingCompilationOptions)
{
var compilationOptions = existingCompilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default)
.WithSpecificDiagnosticOptions(projectFileInfo.GetDiagnosticOptions())
.WithOverflowChecks(projectFileInfo.CheckForOverflowUnderflow);
if (projectFileInfo.AllowUnsafeCode != compilationOptions.AllowUnsafe)
{
compilationOptions = compilationOptions.WithAllowUnsafe(projectFileInfo.AllowUnsafeCode);
}
compilationOptions = projectFileInfo.TreatWarningsAsErrors ?
compilationOptions.WithGeneralDiagnosticOption(ReportDiagnostic.Error) : compilationOptions.WithGeneralDiagnosticOption(ReportDiagnostic.Default);
if (projectFileInfo.NullableContextOptions != compilationOptions.NullableContextOptions)
{
compilationOptions = compilationOptions.WithNullableContextOptions(projectFileInfo.NullableContextOptions);
}
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
compilationOptions = compilationOptions.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
compilationOptions = compilationOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(compilationOptions);
}
public CSharpCompilation Create()
{
var paths = AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES").ToString().Split(';');
var references = _assemblies
.Select(x => x.Location)
.Concat(paths)
.Distinct()
.Select(x => MetadataReference.CreateFromFile(x))
.ToArray();
var options = new CSharpCompilationOptions
(
outputKind: OutputKind.DynamicallyLinkedLibrary,
platform: Platform.AnyCpu,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: false
);
options = options.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
var compilation = CSharpCompilation.Create
(
assemblyName: Guid.NewGuid().ToString(),
options: options,
references: references,
syntaxTrees: new SyntaxTree[] { }
);
return(compilation);
}
public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFileInfo projectFileInfo)
{
var result = new CSharpCompilationOptions(projectFileInfo.OutputKind);
result = result.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafeCode)
{
result = result.WithAllowUnsafe(true);
}
result = result.WithSpecificDiagnosticOptions(CompilationOptionsHelper.GetDefaultSuppressedDiagnosticOptions(projectFileInfo.SuppressedDiagnosticIds));
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
result = result.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
result = result.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(result);
}
private CSharpCompilationOptions CreateDefaultCompilationOptions()
{
var options = new CSharpCompilationOptions
(
outputKind: OutputKind.DynamicallyLinkedLibrary,
platform: Platform.AnyCpu,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: false
);
options = options.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
return(options);
}
CSharpCompilation IResolveReference.GetReferenceResolvedCompilation(CodeGenConfig2 config)
{
string path = Path.GetDirectoryName(config.Project);
string projFilePath = config.Project;
string name = Path.GetFileNameWithoutExtension(projFilePath);
CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
CSharpCompilation compilation = CSharpCompilation.Create(name);
compilation = compilation.WithOptions(compilationOptions);
return(compilation);
}
public async Task <Assembly> Compile(string code)
{
await Init();
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(code, new CSharpParseOptions(LanguageVersion.Latest));
foreach (var diagnostic in syntaxTree.GetDiagnostics())
{
CompileLog.Add(diagnostic.ToString());
}
if (syntaxTree.GetDiagnostics().Any(i => i.Severity == DiagnosticSeverity.Error))
{
CompileLog.Add("Parse SyntaxTree Error!");
return(null);
}
CompileLog.Add("Parse SyntaxTree Success");
//https://stackoverflow.com/questions/35711461/how-to-get-roslyn-to-compile-when-referenced-assemblies-have-references-to-both
var op = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
op = op.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
CSharpCompilation compilation = CSharpCompilation.Create("WasmRoslyn.Demo", new[] { syntaxTree },
references, op);
using (MemoryStream stream = new MemoryStream())
{
EmitResult result = compilation.Emit(stream);
foreach (var diagnostic in result.Diagnostics)
{
CompileLog.Add(diagnostic.ToString());
}
if (!result.Success)
{
CompileLog.Add("Compilation error");
return(null);
}
CompileLog.Add("Compilation success!");
Assembly assemby = AppDomain.CurrentDomain.Load(stream.ToArray());
return(assemby);
}
}
private static CSharpCompilationOptions CreateCompilationOptions(ProjectFileInfo projectFileInfo)
{
var result = new CSharpCompilationOptions(projectFileInfo.OutputKind);
result = result.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafeCode)
{
result = result.WithAllowUnsafe(true);
}
var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic>(projectFileInfo.SuppressedDiagnosticIds.Count)
{
// Ensure that specific warnings about assembly references are always suppressed.
{ "CS1701", ReportDiagnostic.Suppress },
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
};
if (projectFileInfo.SuppressedDiagnosticIds.Any())
{
foreach (var id in projectFileInfo.SuppressedDiagnosticIds)
{
if (!specificDiagnosticOptions.ContainsKey(id))
{
specificDiagnosticOptions.Add(id, ReportDiagnostic.Suppress);
}
}
}
result = result.WithSpecificDiagnosticOptions(specificDiagnosticOptions);
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
result = result.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
result = result.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(result);
}
public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFileInfo projectFileInfo)
{
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafeCode)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true).WithGeneralDiagnosticOption(ReportDiagnostic.Error);
}
if (projectFileInfo.TreatWarningsAsErrors)
{
compilationOptions = compilationOptions.WithGeneralDiagnosticOption(ReportDiagnostic.Error);
}
if (projectFileInfo.NullableContextOptions != compilationOptions.NullableContextOptions)
{
compilationOptions = compilationOptions.WithNullableContextOptions(projectFileInfo.NullableContextOptions);
}
compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(CompilationOptionsHelper.GetDefaultSuppressedDiagnosticOptions(projectFileInfo.SuppressedDiagnosticIds));
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.Directory, projectFileInfo.AssemblyOriginatorKeyFile);
compilationOptions = compilationOptions.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (!string.IsNullOrWhiteSpace(projectFileInfo.DocumentationFile))
{
compilationOptions = compilationOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
}
return(compilationOptions);
}
public void Initalize(IConfiguration configuration)
{
_options = new MSBuildOptions();
OptionsServices.ReadProperties(_options, configuration);
var solutionFilePath = _env.SolutionFilePath;
if (string.IsNullOrEmpty(solutionFilePath))
{
var solutions = Directory.GetFiles(_env.Path, "*.sln");
var result = SolutionPicker.ChooseSolution(_env.Path, solutions);
if (result.Message != null)
{
_logger.LogInformation(result.Message);
}
if (result.Solution == null)
{
return;
}
solutionFilePath = result.Solution;
}
SolutionFile solutionFile = null;
_context.SolutionPath = solutionFilePath;
using (var stream = File.OpenRead(solutionFilePath))
{
using (var reader = new StreamReader(stream))
{
solutionFile = SolutionFile.Parse(reader);
}
}
_logger.LogInformation($"Detecting projects in '{solutionFilePath}'.");
foreach (var block in solutionFile.ProjectBlocks)
{
if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid))
{
if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid)
{
_logger.LogWarning("Skipped unsupported project type '{0}'", block.ProjectPath);
continue;
}
}
if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid))
{
continue;
}
var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar))));
_logger.LogInformation($"Loading project from '{projectFilePath}'.");
var projectFileInfo = CreateProject(projectFilePath);
if (projectFileInfo == null)
{
continue;
}
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
#if DNX451
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
#endif
if (projectFileInfo.AllowUnsafe)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true);
}
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name),
VersionStamp.Create(),
projectFileInfo.Name,
projectFileInfo.AssemblyName,
LanguageNames.CSharp,
projectFileInfo.ProjectFilePath,
compilationOptions: compilationOptions);
_workspace.AddProject(projectInfo);
projectFileInfo.WorkspaceId = projectInfo.Id;
_context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo;
_context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id;
_watcher.Watch(projectFilePath, OnProjectChanged);
}
foreach (var projectFileInfo in _context.Projects.Values)
{
UpdateProject(projectFileInfo);
}
}
public void Initalize(IConfiguration configuration)
{
_options = new MSBuildOptions();
OptionsServices.ReadProperties(_options, configuration);
var solutionFilePath = _env.SolutionFilePath;
if (string.IsNullOrEmpty(solutionFilePath))
{
var solutions = Directory.GetFiles(_env.Path, "*.sln");
var result = SolutionPicker.ChooseSolution(_env.Path, solutions);
if (result.Message != null)
{
_logger.LogInformation(result.Message);
}
if (result.Solution == null)
{
return;
}
solutionFilePath = result.Solution;
}
SolutionFile solutionFile = null;
_context.SolutionPath = solutionFilePath;
using (var stream = File.OpenRead(solutionFilePath))
{
using (var reader = new StreamReader(stream))
{
solutionFile = SolutionFile.Parse(reader);
}
}
_logger.LogInformation($"Detecting projects in '{solutionFilePath}'.");
foreach (var block in solutionFile.ProjectBlocks)
{
if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid))
{
if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid)
{
_logger.LogWarning("Skipped unsupported project type '{0}'", block.ProjectPath);
continue;
}
}
if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid))
{
continue;
}
var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar))));
_logger.LogInformation($"Loading project from '{projectFilePath}'.");
var projectFileInfo = CreateProject(projectFilePath);
if (projectFileInfo == null)
{
continue;
}
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
#if DNX451
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
#endif
if (projectFileInfo.AllowUnsafe)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true);
}
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name),
VersionStamp.Create(),
projectFileInfo.Name,
projectFileInfo.AssemblyName,
LanguageNames.CSharp,
projectFileInfo.ProjectFilePath,
compilationOptions: compilationOptions);
_workspace.AddProject(projectInfo);
projectFileInfo.WorkspaceId = projectInfo.Id;
_context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo;
_context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id;
_watcher.Watch(projectFilePath, OnProjectChanged);
}
foreach (var projectFileInfo in _context.Projects.Values)
{
UpdateProject(projectFileInfo);
}
}
private static (string outputFile, CSharpCompilationOptions compilationOptions, CSharpParseOptions parseOptions) ParseArguments(IEnumerable <string> args)
{
var arguments = new Dictionary <string, string>();
var compilationOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
string outputFile = "";
var specificDiagnosticOptions = new Dictionary <string, ReportDiagnostic>()
{
// Ensure that specific warnings about assembly references are always suppressed.
{ "CS1701", ReportDiagnostic.Suppress },
{ "CS1702", ReportDiagnostic.Suppress },
{ "CS1705", ReportDiagnostic.Suppress }
};
compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(specificDiagnosticOptions);
var parseOptions = new CSharpParseOptions();
foreach (var arg in args)
{
var argParts = arg.Split(':');
var argument = argParts[0].Replace("+", "").Replace("/", "");
var value = "";
if (argParts.Count() > 1)
{
value = argParts[1];
}
switch (argument)
{
case "target":
compilationOptions = compilationOptions.WithOutputKind(ParseTarget(value));
break;
case "unsafe":
compilationOptions = compilationOptions.WithAllowUnsafe(true);
break;
case "nowarn":
var warnings = value.Split(',');
if (warnings.Count() > 0)
{
compilationOptions = compilationOptions.WithSpecificDiagnosticOptions(warnings.Select(s => new KeyValuePair <string, ReportDiagnostic>(!s.StartsWith("CS") ? $"CS{s}" : s, ReportDiagnostic.Suppress)));
}
break;
case "define":
var defines = value.Split(';');
if (defines.Count() > 0)
{
parseOptions = parseOptions.WithPreprocessorSymbols(defines);
}
break;
case "optimize":
compilationOptions = compilationOptions.WithOptimizationLevel(OptimizationLevel.Release);
break;
case "platform":
compilationOptions = compilationOptions.WithPlatform(ParsePlatform(value));
break;
case "out":
outputFile = value;
break;
}
}
return(outputFile, compilationOptions, parseOptions);
}
/// <summary>
/// This method attempts to load the build script at the given location,
/// compile return the exported AbstractBuildTask from it. The script
/// file must inherit from AbstractBuildTask.
/// </summary>
/// <param name="taskScriptPath">
/// The path to the build script to run.
/// </param>
/// <returns>
/// In the event of successful discovery, read and compilation of the
/// script at the given path, a list of all exported AbstractBuildTasks
/// from the compiled assembly is returned.
/// </returns>
private static List <AbstractBuildTask> LoadTaskFromScript(string taskScriptPath)
{
WriteTitleToConsole("Loading & Parsing Build Script");
// Exhaustively verify that the file exists, is readable and is not
// an empty file.
Debug.Assert(!string.IsNullOrEmpty(taskScriptPath) && !string.IsNullOrWhiteSpace(taskScriptPath), "Build task script path is null, empty or whitespace.");
if (string.IsNullOrEmpty(taskScriptPath) || string.IsNullOrWhiteSpace(taskScriptPath))
{
throw new ArgumentException("Build task script path is null, empty or whitespace.", nameof(taskScriptPath));
}
Debug.Assert(File.Exists(taskScriptPath), "Build task script path points to non-existent file.");
if (!File.Exists(taskScriptPath))
{
throw new ArgumentException("Build task script path points to non-existent file.");
}
Console.WriteLine(string.Format("Reading all text from file {0}", taskScriptPath));
var scriptContents = File.ReadAllText(taskScriptPath);
Debug.Assert(!string.IsNullOrEmpty(scriptContents) && !string.IsNullOrWhiteSpace(scriptContents), "Build task script contents are null, empty or whitespace.");
if (string.IsNullOrEmpty(scriptContents) || string.IsNullOrWhiteSpace(scriptContents))
{
throw new ArgumentException("Build task script contents are null, empty or whitespace.", nameof(taskScriptPath));
}
// Setup syntax parse options for C#.
CSharpParseOptions parseOptions = CSharpParseOptions.Default;
parseOptions = parseOptions.WithLanguageVersion(LanguageVersion.CSharp6);
parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.None);
parseOptions = parseOptions.WithKind(SourceCodeKind.Regular);
// Parse text into syntax tree.
SyntaxTree jobSyntaxTree = CSharpSyntaxTree.ParseText(scriptContents, parseOptions);
// Generate a random file name for the assembly we're about to produce.
string generatedAssemblyName = Path.GetRandomFileName();
// Get the directory of a core assembly. We need this directory to
// build out our platform specific reference to mscorlib. mscorlib
// and the private mscorlib must be supplied as references for
// compilation to succeed. Of these two assemblies, only the private
// mscorlib is discovered via enumerataing assemblies referenced by
// this executing binary.
var dd = typeof(Enumerable).GetTypeInfo().Assembly.Location;
var coreDir = Directory.GetParent(dd);
HashSet <string> allRefs = new HashSet <string>();
List <MetadataReference> references = new List <MetadataReference>
{
// Here we get the path to the mscorlib and private mscorlib
// libraries that are required for compilation to succeed.
MetadataReference.CreateFromFile(coreDir.FullName + Path.DirectorySeparatorChar + "mscorlib.dll"),
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)
};
// Enumerate all assemblies referenced by this executing assembly
// and provide them as references to the build script we're about to
// compile.
var referencedAssemblies = RecursivelyGetReferencedAssemblies(Assembly.GetEntryAssembly());
foreach (var referencedAssembly in referencedAssemblies)
{
var mref = MetadataReference.CreateFromFile(referencedAssembly.Location);
if (referencedAssembly.FullName.Contains("System.Runtime.Extension"))
{
// Have to do this to avoid collisions with duplicate type
// definitions between private mscorlib and this assembly.
// XXX TODO - Needs to be solved in a better way?
mref = mref.WithAliases(new List <string>(new[] { "CorPrivate" }));
}
if (!allRefs.Contains(mref.Display))
{
references.Add(mref);
allRefs.Add(mref.Display);
}
/* For debugging, to try to list explicit platform compat. Flaky.
* try
* {
* var customAttributes = loadedAssembly.GetCustomAttributes();
* var attribute = customAttributes.OfType<TargetFrameworkAttribute>().First();
*
* Console.WriteLine(attribute.FrameworkName);
* Console.WriteLine(attribute.FrameworkDisplayName);
* }
* catch{}
*/
}
// Initialize compilation arguments for the build script we're about
// to compile.
var op = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
op = op.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
op = op.WithGeneralDiagnosticOption(ReportDiagnostic.Warn);
// Initialize the compilation with our options, references and the
// already parsed syntax tree of the build script.
CSharpCompilation compilation = CSharpCompilation.Create(
generatedAssemblyName,
syntaxTrees: new[] { jobSyntaxTree },
references: references,
options: op);
// Compile and emit new assembly into memory.
var ms = new MemoryStream();
EmitResult result = compilation.Emit(ms);
if (result.Success)
{
// Store the in-memory assembly until this program exits.
GeneratedAssemblies.Add(ms);
// Get an Assembly structure from the data in memory.
ms.Seek(0, SeekOrigin.Begin);
AssemblyLoadContext loadCtx = AssemblyLoadContext.Default;
Assembly assembly = loadCtx.LoadFromStream(ms);
// Enumerate types exported from the assembly. Presently not used.
var exportedTypes = assembly.ExportedTypes;
foreach (var xp in exportedTypes)
{
Console.WriteLine(string.Format("Build script exports type: {0}", xp.Name));
}
// Filter exported types so we only pull types extending from AbstractBuildTask.
var filteredExports = exportedTypes.Where(x => x.Name != typeof(AbstractBuildTask).Name);
Console.WriteLine(string.Format("Number of exported build objects: {0}", filteredExports.Count()));
// Ensure that we have at least one exported build task.
Debug.Assert(filteredExports.Count() > 0, "Script either does not export any AbstractBuildTask objects. Build scripts should export one or more AbstractBuildTask objects.");
if (filteredExports.Count() <= 0)
{
throw new ArgumentException("Script either does not export any AbstractBuildTask objects. Build scripts should export one or more AbstractBuildTask objects.", nameof(taskScriptPath));
}
var filteredExportsList = filteredExports.ToList();
List <AbstractBuildTask> buildTasks = new List <AbstractBuildTask>();
foreach (var entry in filteredExportsList)
{
AbstractBuildTask typedExport = (AbstractBuildTask)Activator.CreateInstance(entry, new[] { taskScriptPath.ConvertToHostOsPath() });
buildTasks.Add(typedExport);
}
return(buildTasks);
}
else
{
ms.Dispose();
Console.WriteLine(string.Format("Failed to compile build script: {0}.", taskScriptPath));
IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic =>
diagnostic.IsWarningAsError ||
diagnostic.Severity == DiagnosticSeverity.Error);
foreach (Diagnostic diagnostic in failures)
{
Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage());
}
CleanExit(ExitCodes.ScriptCompilationFailure);
}
Console.WriteLine("null");
return(null);
}
public static ExitCode Process(string srcFile, string outputDir, string rootNs, IList <string> macros, IList <string> undefMacros, IDictionary <string, string> _refByNames, IDictionary <string, string> _refByPaths, string systemDllPath, bool outputResult, bool parallel)
{
if (string.IsNullOrEmpty(outputDir))
{
outputDir = "../rewrite";
}
List <string> preprocessors = new List <string>(macros);
preprocessors.Add("__LUA__");
string exepath = System.AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
string path = Path.GetDirectoryName(srcFile);
string name = Path.GetFileNameWithoutExtension(srcFile);
string ext = Path.GetExtension(srcFile);
string logDir = Path.Combine(path, "log");
if (!Directory.Exists(logDir))
{
Directory.CreateDirectory(logDir);
}
if (!Path.IsPathRooted(outputDir))
{
outputDir = Path.Combine(path, outputDir);
outputDir = Path.GetFullPath(outputDir);
}
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
List <string> files = new List <string>();
Dictionary <string, string> refByNames = new Dictionary <string, string>(_refByNames);
Dictionary <string, string> refByPaths = new Dictionary <string, string>(_refByPaths);
if (ext == ".csproj")
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(srcFile);
var nodes = SelectNodes(xmlDoc, "ItemGroup", "Reference");
foreach (XmlElement node in nodes)
{
var aliasesNode = SelectSingleNode(node, "Aliases");
var pathNode = SelectSingleNode(node, "HintPath");
if (null != pathNode && !refByPaths.ContainsKey(pathNode.InnerText))
{
if (null != aliasesNode)
{
refByPaths.Add(pathNode.InnerText, aliasesNode.InnerText);
}
else
{
refByPaths.Add(pathNode.InnerText, "global");
}
}
else
{
string val = node.GetAttribute("Include");
if (!string.IsNullOrEmpty(val) && !refByNames.ContainsKey(val))
{
if (null != aliasesNode)
{
refByNames.Add(val, aliasesNode.InnerText);
}
else
{
refByNames.Add(val, "global");
}
}
}
}
string prjOutputDir = "bin/Debug/";
nodes = SelectNodes(xmlDoc, "PropertyGroup");
foreach (XmlElement node in nodes)
{
string condition = node.GetAttribute("Condition");
var defNode = SelectSingleNode(node, "DefineConstants");
var pathNode = SelectSingleNode(node, "OutputPath");
if (null != defNode && null != pathNode)
{
string text = defNode.InnerText.Trim();
if (condition.IndexOf("Debug") > 0 || condition.IndexOf("Release") < 0 && (text == "DEBUG" || text.IndexOf(";DEBUG;") > 0 || text.StartsWith("DEBUG;") || text.EndsWith(";DEBUG")))
{
preprocessors.AddRange(text.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
prjOutputDir = pathNode.InnerText.Trim();
break;
}
}
}
nodes = SelectNodes(xmlDoc, "ItemGroup", "ProjectReference");
foreach (XmlElement node in nodes)
{
string val = node.GetAttribute("Include");
string prjFile = Path.Combine(path, val.Trim());
var nameNode = SelectSingleNode(node, "Name");
if (null != prjFile && null != nameNode)
{
string prjName = nameNode.InnerText.Trim();
string prjOutputFile = ParseProjectOutputFile(prjFile, prjName);
string fileName = Path.Combine(prjOutputDir, prjOutputFile);
if (!refByPaths.ContainsKey(fileName))
{
refByPaths.Add(fileName, "global");
}
}
}
nodes = SelectNodes(xmlDoc, "ItemGroup", "Compile");
foreach (XmlElement node in nodes)
{
string val = node.GetAttribute("Include");
if (!string.IsNullOrEmpty(val) && val.EndsWith(".cs") && !files.Contains(val))
{
files.Add(val);
}
}
}
else
{
files.Add(srcFile);
}
foreach (string m in undefMacros)
{
preprocessors.Remove(m);
}
bool haveError = false;
Dictionary <string, SyntaxTree> trees = new Dictionary <string, SyntaxTree>();
using (StreamWriter sw = new StreamWriter(Path.Combine(logDir, "SyntaxError.log"))) {
using (StreamWriter sw2 = new StreamWriter(Path.Combine(logDir, "SyntaxWarning.log"))) {
Action <string> handler = (file) => {
string filePath = Path.Combine(path, file);
string fileName = Path.GetFileNameWithoutExtension(filePath);
CSharpParseOptions options = new CSharpParseOptions();
options = options.WithPreprocessorSymbols(preprocessors);
options = options.WithFeatures(new Dictionary <string, string> {
{ "IOperation", "true" }
});
SyntaxTree tree = CSharpSyntaxTree.ParseText(File.ReadAllText(filePath), options, filePath);
lock (trees) {
trees.Add(file, tree);
}
var diags = tree.GetDiagnostics();
bool firstError = true;
bool firstWarning = true;
foreach (var diag in diags)
{
if (diag.Severity == DiagnosticSeverity.Error)
{
if (firstError)
{
LockWriteLine(sw, "============<<<Syntax Error:{0}>>>============", fileName);
firstError = false;
}
string msg = diag.ToString();
LockWriteLine(sw, "{0}", msg);
haveError = true;
}
else
{
if (firstWarning)
{
LockWriteLine(sw2, "============<<<Syntax Warning:{0}>>>============", fileName);
firstWarning = false;
}
string msg = diag.ToString();
LockWriteLine(sw2, "{0}", msg);
}
}
};
if (parallel)
{
Parallel.ForEach(files, handler);
}
else
{
foreach (var file in files)
{
handler(file);
}
}
sw2.Close();
}
sw.Close();
}
if (haveError)
{
Console.WriteLine("{0}", File.ReadAllText(Path.Combine(logDir, "SyntaxError.log")));
return(ExitCode.SyntaxError);
}
//确保常用的Assembly被引用
if (!refByNames.ContainsKey("mscorlib"))
{
refByNames.Add("mscorlib", "global");
}
if (!refByNames.ContainsKey("System"))
{
refByNames.Add("System", "global");
}
if (!refByNames.ContainsKey("System.Core"))
{
refByNames.Add("System.Core", "global");
}
List <MetadataReference> refs = new List <MetadataReference>();
if (string.IsNullOrEmpty(systemDllPath))
{
if (ext == ".cs")
{
refs.Add(MetadataReference.CreateFromFile(typeof(Queue <>).Assembly.Location));
refs.Add(MetadataReference.CreateFromFile(typeof(HashSet <>).Assembly.Location));
}
foreach (var pair in refByNames)
{
#pragma warning disable 618
Assembly assembly = Assembly.LoadWithPartialName(pair.Key);
#pragma warning restore 618
if (null != assembly)
{
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
refs.Add(MetadataReference.CreateFromFile(assembly.Location, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
}
}
else
{
foreach (var pair in refByNames)
{
string file = Path.Combine(systemDllPath, pair.Key) + ".dll";
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
refs.Add(MetadataReference.CreateFromFile(file, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
}
foreach (var pair in refByPaths)
{
string fullPath = Path.Combine(path, pair.Key);
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
refs.Add(MetadataReference.CreateFromFile(fullPath, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
bool haveSemanticError = false;
StringBuilder errorBuilder = new StringBuilder();
StringBuilder sb = new StringBuilder();
CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
CSharpCompilation compilation = CSharpCompilation.Create(name);
compilation = compilation.WithOptions(compilationOptions);
compilation = compilation.AddReferences(refs.ToArray());
compilation = compilation.AddSyntaxTrees(trees.Values);
SymbolTable.Instance.Init(compilation, rootNs, exepath);
using (StreamWriter sw = new StreamWriter(Path.Combine(logDir, "SemanticError.log"))) {
using (StreamWriter sw2 = new StreamWriter(Path.Combine(logDir, "SemanticWarning.log"))) {
foreach (var pair in trees)
{
var fileName = Path.Combine(path, pair.Key);
var filePath = Path.Combine(outputDir, pair.Key);
var dir = Path.GetDirectoryName(filePath);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
SyntaxTree tree = pair.Value;
var model = compilation.GetSemanticModel(tree, true);
var diags = model.GetDiagnostics();
bool firstError = true;
bool firstWarning = true;
foreach (var diag in diags)
{
if (diag.Severity == DiagnosticSeverity.Error)
{
if (firstError)
{
LockWriteLine(sw, "============<<<Semantic Error:{0}>>>============", fileName);
firstError = false;
}
string msg = diag.ToString();
LockWriteLine(sw, "{0}", msg);
haveSemanticError = true;
}
else
{
if (firstWarning)
{
LockWriteLine(sw2, "============<<<Semantic Warning:{0}>>>============", fileName);
firstWarning = false;
}
string msg = diag.ToString();
LockWriteLine(sw2, "{0}", msg);
}
}
Logger.Instance.ClearLog();
Cs2LuaRewriter rewriter = new Cs2LuaRewriter(rootNs, model);
var newRoot = rewriter.Visit(tree.GetRoot()) as CSharpSyntaxNode;
string txt = newRoot.ToFullString();
sb.AppendLine(txt);
File.WriteAllText(filePath, txt);
if (Logger.Instance.HaveError)
{
errorBuilder.AppendLine(Logger.Instance.ErrorLog);
}
}
}
}
File.WriteAllText(Path.Combine(logDir, "Cs2LuaError.log"), errorBuilder.ToString());
using (var sw = new StreamWriter(Path.Combine(logDir, "IllegalGenericOrExtensions.txt"))) {
sw.WriteLine("IllegalGenericTypes:");
foreach (var type in SymbolTable.Instance.IllegalGenericTypes)
{
sw.WriteLine("\t{0}", type);
}
sw.WriteLine("IllegalGenericMethods:");
foreach (var method in SymbolTable.Instance.IllegalGenericMethods)
{
sw.WriteLine("\t{0}", method);
}
sw.WriteLine("IllegalParameterGenericTypes:");
foreach (var type in SymbolTable.Instance.IllegalParameterGenericTypes)
{
sw.WriteLine("\t{0}", type);
}
sw.WriteLine("IllegalExtensions:");
foreach (var type in SymbolTable.Instance.IllegalExtensions)
{
sw.WriteLine("\t{0}", type);
}
sw.WriteLine("IllegalConvertions:");
foreach (var pair in SymbolTable.Instance.IllegalConvertions)
{
foreach (var type in pair.Value)
{
sw.WriteLine("\t{0}=>{1}", pair.Key, type);
}
}
sw.WriteLine();
sw.WriteLine("AccessMemberOfIllegalGenericTypes:");
foreach (var type in SymbolTable.Instance.AccessMemberOfIllegalGenericTypes)
{
sw.WriteLine("\t{0}", type);
}
}
if (outputResult)
{
Console.Write(sb.ToString());
}
if (haveSemanticError)
{
return(ExitCode.SemanticError);
}
return(ExitCode.Success);
}
CSharpCompilation IResolveReference.GetReferenceResolvedCompilation(CodeGenConfig config)
{
string path = Path.GetDirectoryName(config.Project);
string projFilePath = config.Project;
string name = Path.GetFileNameWithoutExtension(projFilePath);
string systemDllPath = config.SystemDllPath;
List <string> preprocessors = new List <string>();
preprocessors.Add("__LUA__");
//存储引用refs
List <MetadataReference> refs = new List <MetadataReference>();
List <string> files = new List <string>();
Dictionary <string, string> refByNames = new Dictionary <string, string>();
Dictionary <string, string> refByPaths = new Dictionary <string, string>();
//从csproj文件中解析XML获取引用
if (projFilePath.EndsWith(".csproj"))
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(projFilePath);
//查找ItemGroup下的Reference节点
var nodes = SelectNodes(xmlDoc, "ItemGroup", "Reference");
foreach (XmlElement node in nodes)
{
var aliasesNode = SelectSingleNode(node, "Aliases");
var pathNode = SelectSingleNode(node, "HintPath");
if (null != pathNode && !refByPaths.ContainsKey(pathNode.InnerText))
{
if (null != aliasesNode)
{
refByPaths.Add(pathNode.InnerText, aliasesNode.InnerText);
}
else
{
refByPaths.Add(pathNode.InnerText, "global");
}
}
else
{
string val = node.GetAttribute("Include");
if (!string.IsNullOrEmpty(val) && !refByNames.ContainsKey(val))
{
if (null != aliasesNode)
{
refByNames.Add(val, aliasesNode.InnerText);
}
else
{
refByNames.Add(val, "global");
}
}
}
}
string prjOutputDir = "bin/Debug/";
nodes = SelectNodes(xmlDoc, "PropertyGroup");
foreach (XmlElement node in nodes)
{
string condition = node.GetAttribute("Condition");
var defNode = SelectSingleNode(node, "DefineConstants");
var pathNode = SelectSingleNode(node, "OutputPath");
if (null != defNode && null != pathNode)
{
string text = defNode.InnerText.Trim();
if (condition.IndexOf("Debug") > 0 || condition.IndexOf("Release") < 0 && (text == "DEBUG" || text.IndexOf(";DEBUG;") > 0 || text.StartsWith("DEBUG;") || text.EndsWith(";DEBUG")))
{
preprocessors.AddRange(text.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries));
prjOutputDir = pathNode.InnerText.Trim();
break;
}
}
}
//查找ItemGroup下的ProjectReference节点
nodes = SelectNodes(xmlDoc, "ItemGroup", "ProjectReference");
foreach (XmlElement node in nodes)
{
string val = node.GetAttribute("Include");
string prjFile = Path.Combine(path, val.Trim());
var nameNode = SelectSingleNode(node, "Name");
if (null != prjFile && null != nameNode)
{
string prjName = nameNode.InnerText.Trim();
string prjOutputFile = ParseProjectOutputFile(prjFile, prjName);
string fileName = Path.Combine(prjOutputDir, prjOutputFile);
if (!refByPaths.ContainsKey(fileName))
{
refByPaths.Add(fileName, "global");
}
}
}
nodes = SelectNodes(xmlDoc, "ItemGroup", "Compile");
foreach (XmlElement node in nodes)
{
string val = node.GetAttribute("Include");
if (!string.IsNullOrEmpty(val) && val.EndsWith(".cs") && !files.Contains(val))
{
files.Add(val);
}
}
//确保常用的Assembly被引用
if (!refByNames.ContainsKey("mscorlib"))
{
refByNames.Add("mscorlib", "global");
}
if (!refByNames.ContainsKey("System"))
{
refByNames.Add("System", "global");
}
if (!refByNames.ContainsKey("System.Core"))
{
refByNames.Add("System.Core", "global");
}
if (string.IsNullOrEmpty(systemDllPath))//默认
{
//用反射添加具体的类名引用
foreach (var pair in refByNames)
{
#pragma warning disable 618
Assembly assembly = Assembly.LoadWithPartialName(pair.Key);
#pragma warning restore 618
if (null != assembly)
{
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
Console.WriteLine(pair.Key);
refs.Add(MetadataReference.CreateFromFile(assembly.Location, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
}
}
//需配置SystemDLLPath
else
{
foreach (var pair in refByNames)
{
string file = Path.Combine(systemDllPath, pair.Key) + ".dll";
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
refs.Add(MetadataReference.CreateFromFile(file, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
}
//从文件路径添加DLL引用
foreach (var pair in refByPaths)
{
string fullPath = Path.Combine(path, pair.Key);
var arr = System.Collections.Immutable.ImmutableArray.Create(pair.Value);
Console.WriteLine(fullPath);
if (!File.Exists(fullPath))
{
Console.WriteLine(fullPath + "is not exsit!");
continue;
}
refs.Add(MetadataReference.CreateFromFile(fullPath, new MetadataReferenceProperties(MetadataImageKind.Assembly, arr)));
}
//手动构造Complation对象
CSharpCompilationOptions compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
CSharpCompilation compilation = CSharpCompilation.Create(name);
compilation = compilation.WithOptions(compilationOptions);
//手动添加Reference
compilation = compilation.AddReferences(refs.ToArray());
//手动添加SyntaxTree
foreach (string itemFile in files)
{
string filePath = Path.Combine(path, itemFile);
string fileName = Path.GetFileNameWithoutExtension(filePath);
if (!File.Exists(filePath))
{
Console.WriteLine(filePath + "is not exsit!");
continue;
}
CSharpParseOptions options = new CSharpParseOptions();
options = options.WithPreprocessorSymbols(preprocessors);
options = options.WithFeatures(new Dictionary <string, string> {
{ "IOperation", "true" }
});
SyntaxTree tree = CSharpSyntaxTree.ParseText(File.ReadAllText(filePath), options, filePath);
compilation = compilation.AddSyntaxTrees(tree);
}
return(compilation);
}
return(null);
}
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);
}
public void Initalize(IConfiguration configuration)
{
_options = new MSBuildOptions();
ConfigurationBinder.Bind(configuration, _options);
if (_options.WaitForDebugger)
{
Console.WriteLine($"Attach to process {System.Diagnostics.Process.GetCurrentProcess().Id}");
while (!System.Diagnostics.Debugger.IsAttached)
{
System.Threading.Thread.Sleep(100);
}
}
var solutionFilePath = _env.SolutionFilePath;
if (string.IsNullOrEmpty(solutionFilePath))
{
var solutions = Directory.GetFiles(_env.Path, "*.sln");
var result = SolutionPicker.ChooseSolution(_env.Path, solutions);
if (result.Message != null)
{
_logger.LogInformation(result.Message);
}
if (result.Solution == null)
{
return;
}
solutionFilePath = result.Solution;
}
SolutionFile solutionFile = null;
_context.SolutionPath = solutionFilePath;
using (var stream = File.OpenRead(solutionFilePath))
{
using (var reader = new StreamReader(stream))
{
solutionFile = SolutionFile.Parse(reader);
}
}
_logger.LogInformation($"Detecting projects in '{solutionFilePath}'.");
foreach (var block in solutionFile.ProjectBlocks)
{
if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid))
{
if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid)
{
_logger.LogWarning("Skipped unsupported project type '{0}'", block.ProjectPath);
continue;
}
}
if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid))
{
continue;
}
var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar))));
_logger.LogInformation($"Loading project from '{projectFilePath}'.");
var projectFileInfo = CreateProject(projectFilePath);
if (projectFileInfo == null)
{
continue;
}
var compilationOptions = new CSharpCompilationOptions(projectFileInfo.OutputKind);
compilationOptions = compilationOptions.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
if (projectFileInfo.AllowUnsafe)
{
compilationOptions = compilationOptions.WithAllowUnsafe(true);
}
if (projectFileInfo.SignAssembly && !string.IsNullOrEmpty(projectFileInfo.AssemblyOriginatorKeyFile))
{
var keyFile = Path.Combine(projectFileInfo.ProjectDirectory, projectFileInfo.AssemblyOriginatorKeyFile);
compilationOptions = compilationOptions.WithStrongNameProvider(new DesktopStrongNameProvider())
.WithCryptoKeyFile(keyFile);
}
if (projectFileInfo.GenerateXmlDocumentation)
{
compilationOptions = compilationOptions.WithXmlReferenceResolver(XmlFileResolver.Default);
}
var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name),
VersionStamp.Create(),
projectFileInfo.Name,
projectFileInfo.AssemblyName,
LanguageNames.CSharp,
projectFileInfo.ProjectFilePath,
compilationOptions: compilationOptions);
_workspace.AddProject(projectInfo);
projectFileInfo.WorkspaceId = projectInfo.Id;
_context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo;
_context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id;
_watcher.Watch(projectFilePath, OnProjectChanged);
}
foreach (var projectFileInfo in _context.Projects.Values)
{
UpdateProject(projectFileInfo);
}
}
/// <summary>
/// Compiles an embedded resource into an executable and writes it to disk in the same
/// directory as the executing assembly.
/// </summary>
/// <param name="sourceResourcePath">
/// The relative resource path, as it must be formatted for a pack URI.
/// </param>
/// <param name="absOutputPath">
/// The absolute path
/// </param>
private string CompileExe(string sourceResourcePath, string absOutputPath)
{
m_logger.Info("Compiling internal service: {0} to output {1}.", sourceResourcePath, absOutputPath);
string scriptContents = string.Empty;
using (var resourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(sourceResourcePath))
{
using (TextReader tsr = new StreamReader(resourceStream))
{
scriptContents = tsr.ReadToEnd();
}
}
if (scriptContents == null || scriptContents.Length == 0)
{
m_logger.Warn("When compiling internal service {0}, failed to load source code.", sourceResourcePath);
return(string.Empty);
}
// The sentinel service is special. It's the only that's going to watch us.
// So, we need to code our process name into its source before compilation.
if (sourceResourcePath.IndexOf("Sentinel", StringComparison.OrdinalIgnoreCase) != -1)
{
scriptContents = scriptContents.Replace("TARGET_APPLICATION_NAME", Process.GetCurrentProcess().ProcessName);
}
HashSet <string> allRefs = new HashSet <string>();
var dd = typeof(Enumerable).GetTypeInfo().Assembly.Location;
var coreDir = Directory.GetParent(dd);
List <MetadataReference> references = new List <MetadataReference>
{
// Here we get the path to the mscorlib and private mscorlib
// libraries that are required for compilation to succeed.
//MetadataReference.CreateFromFile(coreDir.FullName + Path.DirectorySeparatorChar + "mscorlib.dll"),
MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location)
};
var referencedAssemblies = RecursivelyGetReferencedAssemblies(Assembly.GetEntryAssembly());
foreach (var referencedAssembly in referencedAssemblies)
{
var mref = MetadataReference.CreateFromFile(referencedAssembly.Location);
if (referencedAssembly.FullName.Contains("System.Runtime.Extension"))
{
// Have to do this to avoid collisions with duplicate type
// definitions between private mscorlib and this assembly.
// XXX TODO - Needs to be solved in a better way?
mref = mref.WithAliases(new List <string>(new[] { "CorPrivate" }));
}
if (!allRefs.Contains(mref.Display))
{
references.Add(mref);
allRefs.Add(mref.Display);
}
}
// Setup syntax parse options for C#.
CSharpParseOptions parseOptions = CSharpParseOptions.Default;
parseOptions = parseOptions.WithLanguageVersion(LanguageVersion.CSharp6);
parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.None);
parseOptions = parseOptions.WithKind(SourceCodeKind.Regular);
// Parse text into syntax tree.
SyntaxTree jobSyntaxTree = CSharpSyntaxTree.ParseText(scriptContents, parseOptions);
// Initialize compilation arguments for the build script we're about
// to compile.
var op = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
op = op.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
op = op.WithGeneralDiagnosticOption(ReportDiagnostic.Warn);
// Initialize the compilation with our options, references and the
// already parsed syntax tree of the build script.
CSharpCompilation compilation = CSharpCompilation.Create(
Path.GetFileNameWithoutExtension(absOutputPath),
syntaxTrees: new[] { jobSyntaxTree },
references: references,
options: op);
// Compile and emit new assembly into memory.
using (var ms = new MemoryStream())
{
EmitResult result = compilation.Emit(ms);
if (result.Success)
{
File.WriteAllBytes(absOutputPath, ms.ToArray());
m_logger.Info("Generated service assembly {0} for service {1}.", absOutputPath, Path.GetFileNameWithoutExtension(absOutputPath));
return(absOutputPath);
}
else
{
// Compilation failed.
m_logger.Error("Failed to generate service assembly for service {0}.", Path.GetFileNameWithoutExtension(absOutputPath));
foreach (var diag in result.Diagnostics)
{
m_logger.Error(diag.GetMessage());
}
}
}
return(string.Empty);
}
public static void Compile()
{
var testTree = CSharpSyntaxTree.ParseText(@"
using System;
using ExternalLibrary;
namespace test{
public class Power
{
public void power(int number)
{
new ExternalClass().Print(number * number);
}
}
}");
var options = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, allowUnsafe: true);
options = options.WithAssemblyIdentityComparer(AssemblyIdentityComparer.Default);
var references = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(Assembly.Load("netstandard, Version=2.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51").Location),
MetadataReference.CreateFromFile(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "ExternalLibrary.dll"))
};
if (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") is string trustedAssemblies)
{
Console.WriteLine(trustedAssemblies);
references.AddRange(
trustedAssemblies.Split(Path.PathSeparator).Select(path =>
MetadataReference.CreateFromFile(path))
);
}
var compilation = CSharpCompilation.Create("DummyAssembly", options: options, references: references)
.AddSyntaxTrees(testTree);
using (var stream = new MemoryStream())
{
var compilationResult = compilation.Emit(stream);
if (!compilationResult.Success)
{
Console.WriteLine(string.Join("\n", compilationResult.Diagnostics.Select(d => d.GetMessage())));
}
else
{
stream.Seek(0, SeekOrigin.Begin);
var assembly = Assembly.Load(stream.ToArray());
var type = assembly.GetType("test.Power");
var power = Activator.CreateInstance(type);
type.InvokeMember("power", BindingFlags.Default | BindingFlags.InvokeMethod, null, power, new object[] { 2 });
}
}
}