void SyncProject(Compilation.Assembly assembly,
Dictionary <string, string> allAssetsProjectParts,
IEnumerable <ResponseFileData> responseFilesData,
List <Compilation.Assembly> allProjectAssemblies)
{
SyncProjectFileIfNotChanged(ProjectFile(assembly), ProjectText(assembly, ModeForCurrentExternalEditor(), allAssetsProjectParts, responseFilesData, allProjectAssemblies));
}
IEnumerable <ResponseFileData> ParseResponseFileData(Compilation.Assembly assembly)
{
var systemReferenceDirectories = MonoLibraryHelpers.GetSystemReferenceDirectories(assembly.compilerOptions.ApiCompatibilityLevel);
Dictionary <string, ResponseFileData> responseFilesData = assembly.compilerOptions.ResponseFiles.ToDictionary(x => x, x => m_assemblyNameProvider.ParseResponseFile(
x,
_projectDirectory,
systemReferenceDirectories
));
Dictionary <string, ResponseFileData> responseFilesWithErrors = responseFilesData.Where(x => x.Value.Errors.Any())
.ToDictionary(x => x.Key, x => x.Value);
if (responseFilesWithErrors.Any())
{
foreach (var error in responseFilesWithErrors)
{
foreach (var valueError in error.Value.Errors)
{
UnityEngine.Debug.LogErrorFormat("{0} Parse Error : {1}", error.Key, valueError);
}
}
}
return(responseFilesData.Select(x => x.Value));
}
private static void DumpAssembly(Compilation.Assembly assembly)
{
Console.WriteLine("{0} ({1})", assembly.outputPath, assembly.compilerOptions.ApiCompatibilityLevel);
Console.WriteLine("Files: ");
Console.WriteLine(string.Join("\n", assembly.sourceFiles));
Console.WriteLine("References: ");
Console.WriteLine(string.Join("\n", assembly.allReferences));
Console.WriteLine("");
}
private string ProjectHeader(
Compilation.Assembly assembly,
IEnumerable <ResponseFileData> responseFilesData)
{
string targetframeworkversion = "v4.7.1";
string targetLanguageVersion = "latest";
string toolsversion = "4.0";
string productversion = "10.0.20506";
string baseDirectory = ".";
string cscToolPath = "$(CscToolPath)";
cscToolPath = Paths.Combine(EditorApplication.applicationContentsPath, "Tools", "RoslynScripts");
cscToolPath = Paths.UnifyDirectorySeparator(cscToolPath);
string cscToolExe = Application.platform == RuntimePlatform.WindowsEditor ? "unity_csc.bat" : "unity_csc.sh";
var arguments = new object[]
{
toolsversion,
productversion,
ProjectGuid(assembly.name),
_settings.EngineAssemblyPath,
_settings.EditorAssemblyPath,
string.Join(";", assembly.defines.Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
Path.GetFileNameWithoutExtension(assembly.outputPath),
m_assemblyNameProvider.GetCompileOutputPath(assembly.name),
m_assemblyNameProvider.ProjectGenerationRootNamespace,
targetframeworkversion,
targetLanguageVersion,
baseDirectory,
assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
cscToolPath,
cscToolExe,
};
try
{
ScriptingLanguage language = ScriptingLanguageFor(assembly);
return(string.Format(_settings.GetProjectHeaderTemplate(language), arguments));
}
catch (Exception)
{
throw new System.NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + arguments.Length);
}
}
public string ProjectFile(Compilation.Assembly assembly)
{
ScriptingLanguage language = ScriptingLanguageFor(assembly);
return(Path.Combine(_projectDirectory, string.Format("{0}{1}", assembly.name, ProjectExtensions[language])));
}
string ProjectText(Compilation.Assembly assembly,
Mode mode,
Dictionary <string, string> allAssetsProjectParts,
IEnumerable <ResponseFileData> responseFilesData,
List <Compilation.Assembly> allProjectAssemblies)
{
var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
var references = new List <string>();
var projectReferences = new List <Match>();
foreach (string file in assembly.sourceFiles)
{
if (!ShouldFileBePartOfSolution(file))
{
continue;
}
var extension = Path.GetExtension(file).ToLower();
var fullFile = EscapedRelativePathFor(file);
if (".dll" != extension)
{
var tagName = "Compile";
projectBuilder.Append(" <").Append(tagName).Append(" Include=\"").Append(fullFile).Append("\" />").Append(WindowsNewline);
}
else
{
references.Add(fullFile);
}
}
string additionalAssetsForProject;
// Append additional non-script files that should be included in project generation.
if (allAssetsProjectParts.TryGetValue(assembly.name, out additionalAssetsForProject))
{
projectBuilder.Append(additionalAssetsForProject);
}
var allAdditionalReferenceFilenames = new List <string>();
var assemblyRefs = references.Union(assembly.allReferences);
foreach (string reference in assemblyRefs)
{
if (reference.EndsWith("/UnityEditor.dll", StringComparison.Ordinal) ||
reference.EndsWith("/UnityEngine.dll", StringComparison.Ordinal) ||
reference.EndsWith("\\UnityEditor.dll", StringComparison.Ordinal) ||
reference.EndsWith("\\UnityEngine.dll", StringComparison.Ordinal))
{
continue;
}
var match = scriptReferenceExpression.Match(reference);
if (match.Success)
{
var language = ScriptCompilers.GetLanguageFromExtension(GetExtensionOfSourceFiles(assembly.sourceFiles));
var targetLanguage = (ScriptingLanguage)Enum.Parse(typeof(ScriptingLanguage), language.GetLanguageName(), true);
if (mode == Mode.UnityScriptAsUnityProj || ScriptingLanguage.CSharp == targetLanguage)
{
// Add a reference to a project except if it's a reference to a script assembly
// that we are not generating a project for. This will be the case for assemblies
// coming from .assembly.json files in non-internalized packages.
var dllName = match.Groups["dllname"].Value;
if (allProjectAssemblies.Any(i => Path.GetFileName(i.outputPath) == dllName))
{
projectReferences.Add(match);
continue;
}
}
}
string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(_projectDirectory, reference);
AppendReference(fullReference, projectBuilder);
}
var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences);
foreach (var reference in responseRefs)
{
AppendReference(reference, projectBuilder);
}
if (0 < projectReferences.Count)
{
string referencedProject;
projectBuilder.AppendLine(" </ItemGroup>");
projectBuilder.AppendLine(" <ItemGroup>");
foreach (Match reference in projectReferences)
{
var targetAssembly = EditorCompilationInterface.Instance.GetTargetAssemblyDetails(reference.Groups["dllname"].Value);
ScriptingLanguage targetLanguage = ScriptingLanguage.None;
if (targetAssembly != null)
{
targetLanguage = (ScriptingLanguage)Enum.Parse(typeof(ScriptingLanguage), targetAssembly.Language.GetLanguageName(), true);
}
referencedProject = reference.Groups["project"].Value;
projectBuilder.Append(" <ProjectReference Include=\"").Append(referencedProject).Append(GetProjectExtension(targetLanguage)).Append("\">").Append(WindowsNewline);
projectBuilder.Append(" <Project>{").Append(ProjectGuid(Path.Combine("Temp", reference.Groups["project"].Value + ".dll"))).Append("}</Project>").Append(WindowsNewline);
projectBuilder.Append(" <Name>").Append(referencedProject).Append("</Name>").Append(WindowsNewline);
projectBuilder.AppendLine(" </ProjectReference>");
}
}
projectBuilder.Append(ProjectFooter(assembly));
return(projectBuilder.ToString());
}
public bool ProjectExists(Compilation.Assembly assembly)
{
return(m_fileIOProvider.Exists(ProjectFile(assembly)));
}
private static ScriptingLanguage ScriptingLanguageFor(Compilation.Assembly assembly)
{
return(ScriptingLanguageFor(GetExtensionOfSourceFiles(assembly.sourceFiles)));
}
string ProjectText(Compilation.Assembly assembly,
Mode mode,
Dictionary <string, string> allAssetsProjectParts,
IEnumerable <ResponseFileData> responseFilesData,
List <Compilation.Assembly> allProjectAssemblies)
{
var projectBuilder = new StringBuilder(ProjectHeader(assembly, responseFilesData));
var references = new List <string>();
foreach (string file in assembly.sourceFiles)
{
if (!ShouldFileBePartOfSolution(file))
{
continue;
}
var extension = Path.GetExtension(file).ToLower();
var fullFile = EscapedRelativePathFor(file);
if (".dll" != extension)
{
projectBuilder.Append(" <Compile Include=\"").Append(fullFile).Append("\" />").Append(Environment.NewLine);
}
else
{
references.Add(fullFile);
}
}
// Append additional non-script files that should be included in project generation.
string additionalAssetsForProject;
if (allAssetsProjectParts.TryGetValue(assembly.name, out additionalAssetsForProject))
{
projectBuilder.Append(additionalAssetsForProject);
}
var responseRefs = responseFilesData.SelectMany(x => x.FullPathReferences.Select(r => r));
var internalAssemblyReferences = assembly.assemblyReferences
.Where(i => !i.sourceFiles.Any(ShouldFileBePartOfSolution)).Select(i => i.outputPath);
var allReferences =
assembly.compiledAssemblyReferences
.Union(responseRefs)
.Union(references)
.Union(internalAssemblyReferences);
foreach (var reference in allReferences)
{
string fullReference = Path.IsPathRooted(reference) ? reference : Path.Combine(_projectDirectory, reference);
AppendReference(fullReference, projectBuilder);
}
if (0 < assembly.assemblyReferences.Length)
{
projectBuilder.Append(" </ItemGroup>").Append(Environment.NewLine);
projectBuilder.Append(" <ItemGroup>").Append(Environment.NewLine);
foreach (Assembly reference in assembly.assemblyReferences.Where(i => i.sourceFiles.Any(ShouldFileBePartOfSolution)))
{
var referencedProject = reference.outputPath;
projectBuilder.Append(" <ProjectReference Include=\"").Append(reference.name).Append(".csproj").Append("\">").Append(Environment.NewLine);
projectBuilder.Append(" <Project>{").Append(ProjectGuid(reference.name)).Append("}</Project>").Append(Environment.NewLine);
projectBuilder.Append(" <Name>").Append(reference.name).Append("</Name>").Append(Environment.NewLine);
projectBuilder.Append(" <ReferenceOutputAssembly>false</ReferenceOutputAssembly>").Append(Environment.NewLine);
projectBuilder.Append(" </ProjectReference>").Append(Environment.NewLine);
}
}
projectBuilder.Append(ProjectFooter());
return(projectBuilder.ToString());
}
private string ProjectHeader(
Compilation.Assembly assembly,
IEnumerable <ResponseFileData> responseFilesData)
{
string targetframeworkversion = "v3.5";
string targetLanguageVersion = "4";
string toolsversion = "4.0";
string productversion = "10.0.20506";
string baseDirectory = ".";
string cscToolPath = "$(CscToolPath)";
string cscToolExe = "$(CscToolExe)";
ScriptingLanguage language = ScriptingLanguageFor(assembly);
if (PlayerSettingsEditor.IsLatestApiCompatibility(assembly.compilerOptions.ApiCompatibilityLevel))
{
targetframeworkversion = "v4.7.1";
targetLanguageVersion = "latest";
cscToolPath = Paths.Combine(EditorApplication.applicationContentsPath, "Tools", "RoslynScripts");
if (Application.platform == RuntimePlatform.WindowsEditor)
{
cscToolExe = "unity_csc.bat";
}
else
{
cscToolExe = "unity_csc.sh";
}
cscToolPath = Paths.UnifyDirectorySeparator(cscToolPath);
}
else if (_settings.VisualStudioVersion == 9)
{
toolsversion = "3.5";
productversion = "9.0.21022";
}
var arguments = new object[]
{
toolsversion,
productversion,
ProjectGuid(assembly.name),
_settings.EngineAssemblyPath,
_settings.EditorAssemblyPath,
string.Join(";", new[] { "DEBUG", "TRACE" }.Concat(assembly.defines).Concat(responseFilesData.SelectMany(x => x.Defines)).Distinct().ToArray()),
MSBuildNamespaceUri,
assembly.name,
EditorSettings.projectGenerationRootNamespace,
targetframeworkversion,
targetLanguageVersion,
baseDirectory,
assembly.compilerOptions.AllowUnsafeCode | responseFilesData.Any(x => x.Unsafe),
cscToolPath,
cscToolExe,
};
try
{
return(string.Format(_settings.GetProjectHeaderTemplate(language), arguments));
}
catch (Exception)
{
throw new System.NotSupportedException("Failed creating c# project because the c# project header did not have the correct amount of arguments, which is " + arguments.Length);
}
}
