public override void BeginCompiling()
{
var assemblyInfo = ScriptAssemblyToAssemblyInfo(m_Assembly, m_TempOutputDirectory);
var systemReferenceDirectories = MonoLibraryHelpers.GetSystemReferenceDirectories(m_Assembly.CompilerOptions.ApiCompatibilityLevel);
m_ExternalCompiler.BeginCompiling(assemblyInfo, m_Assembly.CompilerOptions.ResponseFiles, SystemInfo.operatingSystemFamily, systemReferenceDirectories);
}
IEnumerable <ResponseFileData> ParseResponseFileData(MonoIsland island)
{
var systemReferenceDirectories = MonoLibraryHelpers.GetSystemReferenceDirectories(island._api_compatibility_level);
Dictionary <string, ResponseFileData> responseFilesData = island._responseFiles.ToDictionary(x => x, x => ScriptCompilerBase.ParseResponseFileFromFile(
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));
}
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));
}
IEnumerable <ScriptCompilerBase.ResponseFileData> ParseResponseFileData(MonoIsland island)
{
var systemReferenceDirectories = CSharpLanguage.GetCSharpCompiler(island._target, true, "Assembly-CSharp") == CSharpCompiler.Microsoft &&
PlayerSettings.GetScriptingBackend(BuildPipeline.GetBuildTargetGroup(island._target)) == ScriptingImplementation.WinRTDotNET && !island._editor
? MicrosoftCSharpCompiler.GetClassLibraries(island._target, island._editor)
: MonoLibraryHelpers.GetSystemReferenceDirectories(island._api_compatibility_level);
Dictionary <string, ScriptCompilerBase.ResponseFileData> responseFilesData = island._responseFiles.ToDictionary(x => x, x => ScriptCompilerBase.ParseResponseFileFromFile(
Path.Combine(_projectDirectory, x),
_projectDirectory,
systemReferenceDirectories
));
Dictionary <string, ScriptCompilerBase.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));
}
protected override string[] GetSystemReferenceDirectories()
{
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(BuildTarget);
if (IsBuildingForDotNetScriptingBackend(buildTargetGroup, m_Island._editor))
{
return(GetClassLibraries(BuildTarget, m_Island._editor).Select(library => Directory.GetParent(library).FullName).Distinct().ToArray());
}
return(MonoLibraryHelpers.GetSystemReferenceDirectories(m_Island._api_compatibility_level));
}
protected override string[] GetSystemReferenceDirectories()
{
var buildTargetGroup = BuildPipeline.GetBuildTargetGroup(BuildTarget);
if (BuildTarget == BuildTarget.WSAPlayer && PlayerSettings.GetScriptingBackend(buildTargetGroup) == ScriptingImplementation.WinRTDotNET)
{
return(GetClassLibraries(BuildTarget).Select(library => Directory.GetParent(library).FullName).Distinct().ToArray());
}
return(MonoLibraryHelpers.GetSystemReferenceDirectories(m_Island._api_compatibility_level));
}
private static MonoIsland CreateMonoIsland(SupportedLanguage language)
{
const string kInputFilePath = "Packages/com.unity.inputsystem/InputSystem";
var outputAssemblyPath = Path.GetTempFileName();
var options = EditorScriptCompilationOptions.BuildingForEditor;
var buildTarget = UnityEditor.EditorUserBuildSettings.activeBuildTarget;
var buildTargetGroup = UnityEditor.EditorUserBuildSettings.activeBuildTargetGroup;
var defines = ieu.GetCompilationDefines(options, buildTargetGroup, buildTarget);
var references = new List <string>();
references.Add(ieu.GetEngineAssemblyPath());
references.Add(ieu.GetEngineCoreModuleAssemblyPath());
references.Add(ieu.GetEditorAssemblyPath());
references.AddRange(ModuleUtils.GetAdditionalReferencesForUserScripts());
#if UNITY_EDITOR_OSX
references.Add(Path.Combine(EditorApplication.applicationContentsPath, "UnityExtensions/Unity/GUISystem/UnityEngine.UI.dll"));
#elif UNITY_EDITOR_WIN
references.Add(Path.Combine(Path.GetDirectoryName(EditorApplication.applicationPath), "Data/UnityExtensions/Unity/GUISystem/UnityEngine.UI.dll"));
#endif
var unityAssemblies = InternalEditorUtility.GetUnityAssemblies(true, buildTargetGroup, buildTarget);
foreach (var asm in unityAssemblies)
{
references.Add(asm.Path);
}
var apiCompatibilityLevel = PlayerSettings.GetApiCompatibilityLevel(EditorUserBuildSettings.activeBuildTargetGroup);
// Hopefully the churn on these mono library helpers is over, this is going to be a bit a pain to
// always chase.
#if UNITY_2018_3_OR_NEWER && !(UNITY_2019_1_OR_NEWER)
var scriptAssembly = new ScriptAssembly
{
Filename = AssetPath.GetFileName(outputAssemblyPath),
Flags = AssemblyFlags.None
};
references.AddRange(MonoLibraryHelpers.GetSystemLibraryReferences(apiCompatibilityLevel, buildTarget, language, true, scriptAssembly));
#elif UNITY_2019_1_OR_NEWER
references.AddRange(MonoLibraryHelpers.GetSystemLibraryReferences(apiCompatibilityLevel, buildTarget, language));
#endif
var sources = new List <string>();
sources.AddRange(Directory.GetFiles(kInputFilePath, "*.cs", SearchOption.AllDirectories));
var island = new MonoIsland(buildTarget, apiCompatibilityLevel, true, sources.ToArray(),
references.ToArray(), defines, outputAssemblyPath);
return(island);
}
public static List <string> GetStaticSearchPaths(BuildTarget buildTarget)
{
var unityAssembliesInternal =
EditorCompilationInterface.Instance.PrecompiledAssemblyProvider.GetUnityAssemblies(true, buildTarget);
var namedBuildTarget = NamedBuildTarget.FromActiveSettings(buildTarget);
var systemReferenceDirectories =
MonoLibraryHelpers.GetSystemReferenceDirectories(
PlayerSettings.GetApiCompatibilityLevel(namedBuildTarget));
var searchPaths = unityAssembliesInternal.Select(x => Path.GetDirectoryName(x.Path))
.Distinct().ToList();
searchPaths.AddRange(systemReferenceDirectories);
return(searchPaths);
}
private string GetCompilerPath(List <string> arguments)
{
string dir = MonoInstallationFinder.GetProfileDirectory("4.5", MonoInstallationFinder.MonoBleedingEdgeInstallation);
var compilerPath = Path.Combine(dir, "mcs.exe");
if (File.Exists(compilerPath))
{
var systemAssemblyDirectory = MonoLibraryHelpers.GetSystemReferenceDirectory(_island._api_compatibility_level);
if (!string.IsNullOrEmpty(systemAssemblyDirectory) && Directory.Exists(systemAssemblyDirectory))
{
arguments.Add("-lib:" + PrepareFileName(systemAssemblyDirectory));
}
return(compilerPath);
}
throw new ApplicationException("Unable to find csharp compiler in " + dir);
}
internal static string[] GetPrecompiledAssemblyPaths(PrecompiledAssemblySources precompiledAssemblySources, PrecompiledAssemblyProviderBase precompiledAssemblyProvider, BuildTargetGroup buildTargetGroup, BuildTarget buildTarget)
{
HashSet <string> assemblyNames = new HashSet <string>();
sc.AssemblyFlags flags = sc.AssemblyFlags.None;
if ((precompiledAssemblySources & PrecompiledAssemblySources.SystemAssembly) != 0)
{
foreach (var a in MonoLibraryHelpers.GetSystemLibraryReferences(ApiCompatibilityLevel.NET_Unity_4_8))
{
assemblyNames.Add(a);
}
}
if ((precompiledAssemblySources & (PrecompiledAssemblySources.UnityEngine | precompiledAssemblySources & PrecompiledAssemblySources.UnityAssembly)) != 0)
{
flags |= sc.AssemblyFlags.UnityModule;
}
if ((precompiledAssemblySources & (PrecompiledAssemblySources.UnityEditor | precompiledAssemblySources & PrecompiledAssemblySources.UnityAssembly)) != 0)
{
flags |= sc.AssemblyFlags.EditorOnly;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UserAssembly) != 0)
{
flags |= sc.AssemblyFlags.UserAssembly;
}
var precompiledAssemblies = precompiledAssemblyProvider.GetPrecompiledAssemblies(
EditorScriptCompilationOptions.BuildingForEditor | EditorScriptCompilationOptions.BuildingWithAsserts,
buildTargetGroup,
buildTarget)
.Concat(precompiledAssemblyProvider.GetUnityAssemblies(true, buildTarget));
foreach (var a in precompiledAssemblies.Where(x => (x.Flags & flags) != 0))
{
assemblyNames.Add(a.Path);
}
return(assemblyNames.ToArray());
}
ScriptCompilerBase.ResponseFileData parseResponseFileData(MonoIsland island, string responseFilePath)
{
var systemReferenceDirectories = CSharpLanguage.GetCSharpCompiler(island._target, true, "Assembly-CSharp") == CSharpCompiler.Microsoft &&
PlayerSettings.GetScriptingBackend(BuildPipeline.GetBuildTargetGroup(island._target)) == ScriptingImplementation.WinRTDotNET
? MicrosoftCSharpCompiler.GetClassLibraries(island._target)
: MonoLibraryHelpers.GetSystemReferenceDirectories(island._api_compatibility_level);
ScriptCompilerBase.ResponseFileData responseFileData = ScriptCompilerBase.ParseResponseFileFromFile(
Path.Combine(_projectDirectory, responseFilePath),
_projectDirectory,
systemReferenceDirectories);
if (responseFileData.Errors.Length > 0)
{
foreach (var error in responseFileData.Errors)
{
UnityEngine.Debug.LogErrorFormat("{0} Parse Error : {1}", responseFilePath, error);
}
}
return(responseFileData);
}
internal static string[] GetPrecompiledAssemblyPaths(EditorCompilation editorCompilation, PrecompiledAssemblySources precompiledAssemblySources)
{
HashSet <string> assemblyNames = new HashSet <string>();
sc.AssemblyFlags flags = sc.AssemblyFlags.None;
if ((precompiledAssemblySources & PrecompiledAssemblySources.SystemAssembly) != 0)
{
var apiCompat = (EditorApplication.scriptingRuntimeVersion == ScriptingRuntimeVersion.Latest) ? ApiCompatibilityLevel.NET_4_6 : ApiCompatibilityLevel.NET_2_0;
foreach (var a in MonoLibraryHelpers.GetSystemLibraryReferences(apiCompat, Scripting.ScriptCompilers.CSharpSupportedLanguage))
{
assemblyNames.Add(a);
}
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEngine) != 0)
{
flags |= sc.AssemblyFlags.UnityModule;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEditor) != 0)
{
flags |= sc.AssemblyFlags.EditorOnly;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UserAssembly) != 0)
{
flags |= sc.AssemblyFlags.UserAssembly;
}
var precompiledAssemblies = editorCompilation.GetAllPrecompiledAssemblies().Concat(EditorCompilationInterface.Instance.GetUnityAssemblies());
foreach (var a in precompiledAssemblies.Where(x => (x.Flags & flags) != 0))
{
assemblyNames.Add(a.Path);
}
return(assemblyNames.ToArray());
}
internal static void AddResponseFileToArguments(List <string> arguments, string responseFileName, ApiCompatibilityLevel apiCompatibilityLevel)
{
var systemReferencesDirectories = MonoLibraryHelpers.GetSystemReferenceDirectories(apiCompatibilityLevel);
var responseFileData = ParseResponseFileFromFile(
responseFileName,
Directory.GetParent(Application.dataPath).FullName,
systemReferencesDirectories);
foreach (var error in responseFileData.Errors)
{
Debug.LogError($"{responseFileName} Parse Error : {error}");
}
arguments.AddRange(responseFileData.Defines.Distinct().Select(define => "/define:" + define));
arguments.AddRange(responseFileData.FullPathReferences.Select(reference =>
"/reference:" + PrepareFileName(reference)));
if (responseFileData.Unsafe)
{
arguments.Add("/unsafe");
}
arguments.AddRange(responseFileData.OtherArguments);
}
internal static string[] GetPrecompiledAssemblyPaths(PrecompiledAssemblySources precompiledAssemblySources, IPrecompiledAssemblyProvider precompiledAssemblyProvider)
{
HashSet <string> assemblyNames = new HashSet <string>();
sc.AssemblyFlags flags = sc.AssemblyFlags.None;
if ((precompiledAssemblySources & PrecompiledAssemblySources.SystemAssembly) != 0)
{
foreach (var a in MonoLibraryHelpers.GetSystemLibraryReferences(ApiCompatibilityLevel.NET_4_6, Scripting.ScriptCompilers.CSharpSupportedLanguage))
{
assemblyNames.Add(a);
}
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEngine) != 0)
{
flags |= sc.AssemblyFlags.UnityModule;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UnityEditor) != 0)
{
flags |= sc.AssemblyFlags.EditorOnly;
}
if ((precompiledAssemblySources & PrecompiledAssemblySources.UserAssembly) != 0)
{
flags |= sc.AssemblyFlags.UserAssembly;
}
var precompiledAssemblies = precompiledAssemblyProvider.GetPrecompiledAssemblies(true, EditorUserBuildSettings.activeBuildTargetGroup, EditorUserBuildSettings.activeBuildTarget).Concat(EditorCompilationInterface.Instance.GetUnityAssemblies());
foreach (var a in precompiledAssemblies.Where(x => (x.Flags & flags) != 0))
{
assemblyNames.Add(a.Path);
}
return(assemblyNames.ToArray());
}
protected override string[] GetSystemReferenceDirectories()
{
return(MonoLibraryHelpers.GetSystemReferenceDirectories(m_Island._api_compatibility_level));
}
public static string[] GetSystemAssemblyDirectories(ApiCompatibilityLevel apiCompatibilityLevel)
{
return(MonoLibraryHelpers.GetSystemReferenceDirectories(apiCompatibilityLevel));
}