internal static EditorBuildRules.TargetAssembly GetCustomTargetAssembly(string scriptPath, string projectDirectory, EditorBuildRules.TargetAssembly[] customTargetAssemblies)
{
EditorBuildRules.TargetAssembly result;
if (customTargetAssemblies == null)
{
result = null;
}
else
{
int num = -1;
EditorBuildRules.TargetAssembly targetAssembly = null;
bool flag = Path.IsPathRooted(scriptPath);
string arg = (!flag) ? Path.Combine(projectDirectory, scriptPath).ToLower() : scriptPath.ToLower();
for (int i = 0; i < customTargetAssemblies.Length; i++)
{
EditorBuildRules.TargetAssembly targetAssembly2 = customTargetAssemblies[i];
int num2 = targetAssembly2.PathFilter(arg);
if (num2 > num)
{
targetAssembly = targetAssembly2;
num = num2;
}
}
result = targetAssembly;
}
return(result);
}
public static ScriptAssembly[] GetAllScriptAssemblies(IEnumerable <string> allSourceFiles, string projectDirectory, BuildFlags buildFlags, ScriptAssemblySettings settings, EditorBuildRules.CompilationAssemblies assemblies)
{
ScriptAssembly[] result;
if (allSourceFiles == null || allSourceFiles.Count <string>() == 0)
{
result = new ScriptAssembly[0];
}
else
{
bool flag = (buildFlags & BuildFlags.BuildingForEditor) == BuildFlags.BuildingForEditor;
Dictionary <EditorBuildRules.TargetAssembly, HashSet <string> > dictionary = new Dictionary <EditorBuildRules.TargetAssembly, HashSet <string> >();
foreach (string current in allSourceFiles)
{
EditorBuildRules.TargetAssembly targetAssembly = EditorBuildRules.GetTargetAssembly(current, projectDirectory, assemblies.CustomTargetAssemblies);
if (targetAssembly != null)
{
if (flag || !targetAssembly.EditorOnly)
{
HashSet <string> hashSet;
if (!dictionary.TryGetValue(targetAssembly, out hashSet))
{
hashSet = new HashSet <string>();
dictionary[targetAssembly] = hashSet;
}
hashSet.Add(Path.Combine(projectDirectory, current));
}
}
}
result = EditorBuildRules.ToScriptAssemblies(dictionary, settings, buildFlags, assemblies, null);
}
return(result);
}
public static bool ShouldAddTestRunnerReferences(EditorBuildRules.TargetAssembly targetAssembly)
{
return(!targetAssembly.References.Any(x => x.Filename.Contains(k_EngineTestRunnerAssemblyName) || x.Filename.Contains(k_EditorTestRunnerAssemblyName)) &&
!targetAssembly.Filename.Contains(k_EngineTestRunnerAssemblyName) &&
!targetAssembly.Filename.Contains(k_EditorTestRunnerAssemblyName) &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
internal static EditorBuildRules.TargetAssembly GetPredefinedTargetAssembly(string scriptPath)
{
EditorBuildRules.TargetAssembly result = null;
string a = Path.GetExtension(scriptPath).Substring(1).ToLower();
string arg = "/" + scriptPath.ToLower();
int num = -1;
EditorBuildRules.TargetAssembly[] array = EditorBuildRules.predefinedTargetAssemblies;
for (int i = 0; i < array.Length; i++)
{
EditorBuildRules.TargetAssembly targetAssembly = array[i];
if (!(a != targetAssembly.Language.GetExtensionICanCompile()))
{
Func <string, int> pathFilter = targetAssembly.PathFilter;
int num2;
if (pathFilter == null)
{
num2 = 0;
}
else
{
num2 = pathFilter(arg);
}
if (num2 > num)
{
result = targetAssembly;
num = num2;
}
}
}
return(result);
}
public bool CompileScripts(EditorScriptCompilationOptions definesOptions, BuildTargetGroup platformGroup, BuildTarget platform)
{
ScriptAssemblySettings scriptAssemblySettings = this.CreateScriptAssemblySettings(platformGroup, platform, definesOptions);
BuildFlags buildFlags = BuildFlags.None;
if ((definesOptions & EditorScriptCompilationOptions.BuildingForEditor) == EditorScriptCompilationOptions.BuildingForEditor)
{
buildFlags |= BuildFlags.BuildingForEditor;
}
if ((definesOptions & EditorScriptCompilationOptions.BuildingDevelopmentBuild) == EditorScriptCompilationOptions.BuildingDevelopmentBuild)
{
buildFlags |= BuildFlags.BuildingDevelopmentBuild;
}
EditorBuildRules.TargetAssembly[] array = null;
bool result = this.CompileScripts(scriptAssemblySettings, EditorCompilation.EditorTempPath, buildFlags, ref array);
if (array != null)
{
EditorBuildRules.TargetAssembly[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
EditorBuildRules.TargetAssembly targetAssembly = array2[i];
CustomScriptAssembly customScriptAssembly = this.customScriptAssemblies.Single((CustomScriptAssembly a) => a.Name == Path.GetFileNameWithoutExtension(targetAssembly.Filename));
string text = customScriptAssembly.FilePath;
if (text.StartsWith(this.projectDirectory))
{
text = text.Substring(this.projectDirectory.Length);
}
Debug.LogWarning(string.Format("Script assembly '{0}' has not been compiled. Folder containing assembly definition file '{1}' contains script files for different script languages. Folder must only contain script files for one script language.", targetAssembly.Filename, text));
}
}
return(result);
}
public static bool ShouldAddTestRunnerReferences(EditorBuildRules.TargetAssembly targetAssembly)
{
if (UnityCodeGenHelpers.IsCodeGen(targetAssembly.Filename))
{
return(false);
}
bool referencesTestRunnerAssembly = false;
foreach (var reference in targetAssembly.References)
{
referencesTestRunnerAssembly =
reference.Filename.Equals(k_EditorTestRunnerAssemblyName, StringComparison.Ordinal) ||
reference.Filename.Equals(k_EngineTestRunnerAssemblyName, StringComparison.Ordinal);
if (referencesTestRunnerAssembly)
{
break;
}
}
return(!referencesTestRunnerAssembly &&
!targetAssembly.Filename.Equals(k_EditorTestRunnerAssemblyName, StringComparison.Ordinal) &&
!targetAssembly.Filename.Equals(k_EngineTestRunnerAssemblyName, StringComparison.Ordinal) &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
private HashSet <string> AllDirectReferences(EditorBuildRules.TargetAssembly targetAssembly)
{
HashSet <string> references;
if (m_AssemblyNameReferences.TryGetValue(targetAssembly.Filename, out references))
{
return(references);
}
references = new HashSet <string>();
foreach (var targetAssemblyReference in targetAssembly.References)
{
if (IsCompatibleCached(targetAssemblyReference))
{
references.Add(targetAssemblyReference.Filename);
}
}
foreach (var assemblyPrecompiledReference in targetAssembly.PrecompiledReferences)
{
var fileName = Path.GetFileName(assemblyPrecompiledReference.Path);
references.Add(fileName);
}
m_AssemblyNameReferences.Add(targetAssembly.Filename, references);
return(references);
}
private List <string> FindReferencesRecursive(EditorBuildRules.TargetAssembly targetAssembly,
HashSet <string> searchFor)
{
var result = new List <string>(searchFor.Count);
var allDirectReferences = AllDirectReferences(targetAssembly);
allDirectReferences.IntersectWith(searchFor);
result.AddRange(allDirectReferences);
searchFor.ExceptWith(result);
if (!searchFor.Any())
{
return(result);
}
foreach (var assemblyReference in targetAssembly.References)
{
if (!searchFor.Any())
{
continue;
}
var referenceResult = FindReferencesRecursive(assemblyReference, searchFor);
result.AddRange(referenceResult);
}
return(result);
}
public EditorCompilation.TargetAssemblyInfo GetTargetAssembly(string scriptPath)
{
EditorBuildRules.TargetAssembly targetAssembly = EditorBuildRules.GetTargetAssembly(scriptPath, this.projectDirectory, this.customTargetAssemblies);
EditorCompilation.TargetAssemblyInfo result;
result.Name = this.AssemblyFilenameWithSuffix(targetAssembly.Filename);
result.Flags = targetAssembly.Flags;
return(result);
}
private bool IsCompatibleCached(EditorBuildRules.TargetAssembly targetAssembly)
{
bool isCompatible;
if (m_CompatibleTargetAssemblies.TryGetValue(targetAssembly.Filename, out isCompatible))
{
return(isCompatible);
}
isCompatible = targetAssembly.IsCompatibleFunc(m_AssemblySettings, targetAssembly.Defines ?? new string[0]);
m_CompatibleTargetAssemblies.Add(targetAssembly.Filename, isCompatible);
return(isCompatible);
}
internal static EditorBuildRules.TargetAssembly GetTargetAssembly(string scriptPath, string projectDirectory, EditorBuildRules.TargetAssembly[] customTargetAssemblies)
{
EditorBuildRules.TargetAssembly customTargetAssembly = EditorBuildRules.GetCustomTargetAssembly(scriptPath, projectDirectory, customTargetAssemblies);
EditorBuildRules.TargetAssembly result;
if (customTargetAssembly != null)
{
result = customTargetAssembly;
}
else
{
result = EditorBuildRules.GetPredefinedTargetAssembly(scriptPath);
}
return(result);
}
internal static ScriptAssembly[] ToScriptAssemblies(IDictionary <EditorBuildRules.TargetAssembly, HashSet <string> > targetAssemblies, ScriptAssemblySettings settings, BuildFlags buildFlags, EditorBuildRules.CompilationAssemblies assemblies, HashSet <string> runUpdaterAssemblies)
{
ScriptAssembly[] array = new ScriptAssembly[targetAssemblies.Count];
Dictionary <EditorBuildRules.TargetAssembly, ScriptAssembly> dictionary = new Dictionary <EditorBuildRules.TargetAssembly, ScriptAssembly>();
int num = 0;
bool flag = (buildFlags & BuildFlags.BuildingForEditor) == BuildFlags.BuildingForEditor;
foreach (KeyValuePair <EditorBuildRules.TargetAssembly, HashSet <string> > current in targetAssemblies)
{
EditorBuildRules.TargetAssembly key = current.Key;
HashSet <string> value = current.Value;
ScriptAssembly scriptAssembly = new ScriptAssembly();
array[num] = scriptAssembly;
dictionary[key] = array[num++];
scriptAssembly.BuildTarget = settings.BuildTarget;
if (key.EditorOnly || (flag && settings.ApiCompatibilityLevel == ApiCompatibilityLevel.NET_4_6))
{
scriptAssembly.ApiCompatibilityLevel = ((EditorApplication.scriptingRuntimeVersion != ScriptingRuntimeVersion.Latest) ? ApiCompatibilityLevel.NET_2_0 : ApiCompatibilityLevel.NET_4_6);
}
else
{
scriptAssembly.ApiCompatibilityLevel = settings.ApiCompatibilityLevel;
}
if (!string.IsNullOrEmpty(settings.FilenameSuffix))
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(key.Filename);
string extension = Path.GetExtension(key.Filename);
scriptAssembly.Filename = fileNameWithoutExtension + settings.FilenameSuffix + extension;
}
else
{
scriptAssembly.Filename = key.Filename;
}
if (runUpdaterAssemblies != null && runUpdaterAssemblies.Contains(scriptAssembly.Filename))
{
scriptAssembly.RunUpdater = true;
}
scriptAssembly.OutputDirectory = settings.OutputDirectory;
scriptAssembly.Defines = settings.Defines;
scriptAssembly.Files = value.ToArray <string>();
Array.Sort <string>(scriptAssembly.Files);
}
num = 0;
foreach (KeyValuePair <EditorBuildRules.TargetAssembly, HashSet <string> > current2 in targetAssemblies)
{
EditorBuildRules.AddScriptAssemblyReferences(ref array[num++], current2.Key, settings, buildFlags, assemblies, dictionary, settings.FilenameSuffix);
}
return(array);
}
public static EditorBuildRules.TargetAssembly[] CreateTargetAssemblies(IEnumerable <CustomScriptAssembly> customScriptAssemblies)
{
EditorBuildRules.TargetAssembly[] result;
if (customScriptAssemblies == null)
{
result = null;
}
else
{
List <EditorBuildRules.TargetAssembly> list = new List <EditorBuildRules.TargetAssembly>();
Dictionary <string, EditorBuildRules.TargetAssembly> dictionary = new Dictionary <string, EditorBuildRules.TargetAssembly>();
foreach (CustomScriptAssembly current in customScriptAssemblies)
{
string pathPrefixLowerCase = current.PathPrefix.ToLower();
EditorBuildRules.TargetAssembly targetAssembly = new EditorBuildRules.TargetAssembly(current.Name + ".dll", null, current.AssemblyFlags, EditorBuildRules.TargetAssemblyType.Custom, (string path) => (!path.StartsWith(pathPrefixLowerCase)) ? -1 : pathPrefixLowerCase.Length);
list.Add(targetAssembly);
dictionary[current.Name] = targetAssembly;
}
List <EditorBuildRules.TargetAssembly> .Enumerator enumerator2 = list.GetEnumerator();
foreach (CustomScriptAssembly current2 in customScriptAssemblies)
{
enumerator2.MoveNext();
EditorBuildRules.TargetAssembly current3 = enumerator2.Current;
if (current2.References != null)
{
string[] references = current2.References;
for (int i = 0; i < references.Length; i++)
{
string text = references[i];
EditorBuildRules.TargetAssembly item = null;
if (!dictionary.TryGetValue(text, out item))
{
Debug.LogWarning(string.Format("Could not find reference '{0}' for assembly '{1}'", text, current2.Name));
}
else
{
current3.References.Add(item);
}
}
}
}
result = list.ToArray();
}
return(result);
}
public static bool ShouldAddNunitReferences(EditorBuildRules.TargetAssembly targetAssembly)
{
bool referencesNUnit = false;
if ((targetAssembly.Flags & AssemblyFlags.ExplicitReferences) == AssemblyFlags.ExplicitReferences)
{
foreach (var explicitPrecompiledReference in targetAssembly.ExplicitPrecompiledReferences)
{
referencesNUnit = explicitPrecompiledReference.Equals(NunitAssemblyName, StringComparison.Ordinal);
if (referencesNUnit)
{
break;
}
}
}
return(!referencesNUnit &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
public static bool ShouldAddNunitReferences(EditorBuildRules.TargetAssembly targetAssembly)
{
return(!targetAssembly.PrecompiledReferences.Any(x => AssetPath.GetFileName(x.Path) == k_NunitAssemblyName) &&
(PlayerSettings.playModeTestRunnerEnabled || (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly));
}
public static ScriptAssembly[] GenerateChangedScriptAssemblies(EditorBuildRules.GenerateChangedScriptAssembliesArgs args)
{
bool flag = (args.BuildFlags & BuildFlags.BuildingForEditor) == BuildFlags.BuildingForEditor;
Dictionary <EditorBuildRules.TargetAssembly, HashSet <string> > dictionary = new Dictionary <EditorBuildRules.TargetAssembly, HashSet <string> >();
EditorBuildRules.TargetAssembly[] array = (args.Assemblies.CustomTargetAssemblies != null) ? EditorBuildRules.predefinedTargetAssemblies.Concat(args.Assemblies.CustomTargetAssemblies).ToArray <EditorBuildRules.TargetAssembly>() : EditorBuildRules.predefinedTargetAssemblies;
if (args.RunUpdaterAssemblies != null)
{
using (HashSet <string> .Enumerator enumerator = args.RunUpdaterAssemblies.GetEnumerator())
{
while (enumerator.MoveNext())
{
string assemblyFilename = enumerator.Current;
EditorBuildRules.TargetAssembly key = array.First((EditorBuildRules.TargetAssembly a) => a.FilenameWithSuffix(args.Settings.FilenameSuffix) == assemblyFilename);
dictionary[key] = new HashSet <string>();
}
}
}
foreach (string current in args.DirtySourceFiles)
{
EditorBuildRules.TargetAssembly targetAssembly = EditorBuildRules.GetTargetAssembly(current, args.ProjectDirectory, args.Assemblies.CustomTargetAssemblies);
if (flag || !targetAssembly.EditorOnly)
{
string extensionOfSourceFile = ScriptCompilers.GetExtensionOfSourceFile(current);
SupportedLanguage languageFromExtension = ScriptCompilers.GetLanguageFromExtension(extensionOfSourceFile);
HashSet <string> hashSet;
if (!dictionary.TryGetValue(targetAssembly, out hashSet))
{
hashSet = new HashSet <string>();
dictionary[targetAssembly] = hashSet;
if (targetAssembly.Type == EditorBuildRules.TargetAssemblyType.Custom)
{
targetAssembly.Language = languageFromExtension;
}
}
hashSet.Add(Path.Combine(args.ProjectDirectory, current));
if (languageFromExtension != targetAssembly.Language)
{
args.NotCompiledTargetAssemblies.Add(targetAssembly);
}
}
}
bool flag2 = dictionary.Any((KeyValuePair <EditorBuildRules.TargetAssembly, HashSet <string> > entry) => entry.Key.Type == EditorBuildRules.TargetAssemblyType.Custom);
if (flag2)
{
EditorBuildRules.TargetAssembly[] array2 = EditorBuildRules.predefinedTargetAssemblies;
for (int i = 0; i < array2.Length; i++)
{
EditorBuildRules.TargetAssembly targetAssembly2 = array2[i];
if (flag || !targetAssembly2.EditorOnly)
{
if (!dictionary.ContainsKey(targetAssembly2))
{
dictionary[targetAssembly2] = new HashSet <string>();
}
}
}
}
int num;
do
{
num = 0;
EditorBuildRules.TargetAssembly[] array3 = array;
for (int j = 0; j < array3.Length; j++)
{
EditorBuildRules.TargetAssembly targetAssembly3 = array3[j];
if (flag || !targetAssembly3.EditorOnly)
{
if (!dictionary.ContainsKey(targetAssembly3))
{
foreach (EditorBuildRules.TargetAssembly current2 in targetAssembly3.References)
{
if (dictionary.ContainsKey(current2))
{
dictionary[targetAssembly3] = new HashSet <string>();
num++;
break;
}
}
}
}
}
}while (num > 0);
foreach (string current3 in args.AllSourceFiles)
{
EditorBuildRules.TargetAssembly targetAssembly4 = EditorBuildRules.GetTargetAssembly(current3, args.ProjectDirectory, args.Assemblies.CustomTargetAssemblies);
if (flag || !targetAssembly4.EditorOnly)
{
string extensionOfSourceFile2 = ScriptCompilers.GetExtensionOfSourceFile(current3);
SupportedLanguage languageFromExtension2 = ScriptCompilers.GetLanguageFromExtension(extensionOfSourceFile2);
if (targetAssembly4.Language == null && targetAssembly4.Type == EditorBuildRules.TargetAssemblyType.Custom)
{
targetAssembly4.Language = languageFromExtension2;
}
if (languageFromExtension2 != targetAssembly4.Language)
{
args.NotCompiledTargetAssemblies.Add(targetAssembly4);
}
HashSet <string> hashSet2;
if (dictionary.TryGetValue(targetAssembly4, out hashSet2))
{
hashSet2.Add(Path.Combine(args.ProjectDirectory, current3));
}
}
}
dictionary = (from e in dictionary
where e.Value.Count > 0
select e).ToDictionary((KeyValuePair <EditorBuildRules.TargetAssembly, HashSet <string> > e) => e.Key, (KeyValuePair <EditorBuildRules.TargetAssembly, HashSet <string> > e) => e.Value);
foreach (EditorBuildRules.TargetAssembly current4 in args.NotCompiledTargetAssemblies)
{
dictionary.Remove(current4);
}
return(EditorBuildRules.ToScriptAssemblies(dictionary, args.Settings, args.BuildFlags, args.Assemblies, args.RunUpdaterAssemblies));
}
private static bool IsCompiledAssemblyCompatibleWithTargetAssembly(PrecompiledAssembly compiledAssembly, EditorBuildRules.TargetAssembly targetAssembly, BuildTarget buildTarget, EditorBuildRules.TargetAssembly[] customTargetAssemblies)
{
bool flag = WSAHelpers.UseDotNetCore(targetAssembly.Filename, buildTarget, customTargetAssemblies);
bool result;
if (flag)
{
bool flag2 = (compiledAssembly.Flags & AssemblyFlags.UseForDotNet) == AssemblyFlags.UseForDotNet;
result = flag2;
}
else
{
bool flag3 = (compiledAssembly.Flags & AssemblyFlags.UseForMono) == AssemblyFlags.UseForMono;
result = flag3;
}
return(result);
}
internal static void AddScriptAssemblyReferences(ref ScriptAssembly scriptAssembly, EditorBuildRules.TargetAssembly targetAssembly, ScriptAssemblySettings settings, BuildFlags buildFlags, EditorBuildRules.CompilationAssemblies assemblies, IDictionary <EditorBuildRules.TargetAssembly, ScriptAssembly> targetToScriptAssembly, string filenameSuffix)
{
List <ScriptAssembly> list = new List <ScriptAssembly>();
List <string> list2 = new List <string>();
bool flag = (buildFlags & BuildFlags.BuildingForEditor) == BuildFlags.BuildingForEditor;
bool flag2 = (targetAssembly.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
if (assemblies.UnityAssemblies != null)
{
PrecompiledAssembly[] unityAssemblies = assemblies.UnityAssemblies;
for (int i = 0; i < unityAssemblies.Length; i++)
{
PrecompiledAssembly compiledAssembly = unityAssemblies[i];
if (flag || flag2)
{
if ((compiledAssembly.Flags & AssemblyFlags.UseForMono) != AssemblyFlags.None)
{
list2.Add(compiledAssembly.Path);
}
}
else if ((compiledAssembly.Flags & AssemblyFlags.EditorOnly) != AssemblyFlags.EditorOnly)
{
if (EditorBuildRules.IsCompiledAssemblyCompatibleWithTargetAssembly(compiledAssembly, targetAssembly, settings.BuildTarget, assemblies.CustomTargetAssemblies))
{
list2.Add(compiledAssembly.Path);
}
}
}
}
foreach (EditorBuildRules.TargetAssembly current in targetAssembly.References)
{
ScriptAssembly item;
if (targetToScriptAssembly.TryGetValue(current, out item))
{
list.Add(item);
}
else
{
string text = Path.Combine(settings.OutputDirectory, current.Filename);
if (!string.IsNullOrEmpty(filenameSuffix))
{
text = text.Replace(".dll", filenameSuffix + ".dll");
}
if (File.Exists(text))
{
list2.Add(text);
}
}
}
if (assemblies.CustomTargetAssemblies != null && targetAssembly.Type == EditorBuildRules.TargetAssemblyType.Predefined)
{
EditorBuildRules.TargetAssembly[] customTargetAssemblies = assemblies.CustomTargetAssemblies;
for (int j = 0; j < customTargetAssemblies.Length; j++)
{
EditorBuildRules.TargetAssembly key = customTargetAssemblies[j];
ScriptAssembly item2;
if (targetToScriptAssembly.TryGetValue(key, out item2))
{
list.Add(item2);
}
}
}
if (assemblies.PrecompiledAssemblies != null)
{
PrecompiledAssembly[] precompiledAssemblies = assemblies.PrecompiledAssemblies;
for (int k = 0; k < precompiledAssemblies.Length; k++)
{
PrecompiledAssembly compiledAssembly2 = precompiledAssemblies[k];
bool flag3 = (compiledAssembly2.Flags & AssemblyFlags.EditorOnly) == AssemblyFlags.EditorOnly;
if (!flag3 || flag2)
{
if (EditorBuildRules.IsCompiledAssemblyCompatibleWithTargetAssembly(compiledAssembly2, targetAssembly, settings.BuildTarget, assemblies.CustomTargetAssemblies))
{
list2.Add(compiledAssembly2.Path);
}
}
}
}
if (flag && assemblies.EditorAssemblyReferences != null)
{
list2.AddRange(assemblies.EditorAssemblyReferences);
}
scriptAssembly.ScriptAssemblyReferences = list.ToArray();
scriptAssembly.References = list2.ToArray();
}
internal static EditorBuildRules.TargetAssembly[] CreatePredefinedTargetAssemblies()
{
List <EditorBuildRules.TargetAssembly> list = new List <EditorBuildRules.TargetAssembly>();
List <EditorBuildRules.TargetAssembly> list2 = new List <EditorBuildRules.TargetAssembly>();
List <EditorBuildRules.TargetAssembly> list3 = new List <EditorBuildRules.TargetAssembly>();
List <EditorBuildRules.TargetAssembly> list4 = new List <EditorBuildRules.TargetAssembly>();
List <SupportedLanguage> supportedLanguages = ScriptCompilers.SupportedLanguages;
List <EditorBuildRules.TargetAssembly> list5 = new List <EditorBuildRules.TargetAssembly>();
foreach (SupportedLanguage current in supportedLanguages)
{
string languageName = current.GetLanguageName();
string arg_7B_0 = "Assembly-" + languageName + "-firstpass.dll";
SupportedLanguage arg_7B_1 = current;
AssemblyFlags arg_7B_2 = AssemblyFlags.None;
EditorBuildRules.TargetAssemblyType arg_7B_3 = EditorBuildRules.TargetAssemblyType.Predefined;
if (EditorBuildRules.< > f__mg$cache0 == null)
{
EditorBuildRules.< > f__mg$cache0 = new Func <string, int>(EditorBuildRules.FilterAssemblyInFirstpassFolder);
}
EditorBuildRules.TargetAssembly item = new EditorBuildRules.TargetAssembly(arg_7B_0, arg_7B_1, arg_7B_2, arg_7B_3, EditorBuildRules.< > f__mg$cache0);
EditorBuildRules.TargetAssembly item2 = new EditorBuildRules.TargetAssembly("Assembly-" + languageName + ".dll", current, AssemblyFlags.None, EditorBuildRules.TargetAssemblyType.Predefined);
string arg_D0_0 = "Assembly-" + languageName + "-Editor-firstpass.dll";
SupportedLanguage arg_D0_1 = current;
AssemblyFlags arg_D0_2 = AssemblyFlags.EditorOnly;
EditorBuildRules.TargetAssemblyType arg_D0_3 = EditorBuildRules.TargetAssemblyType.Predefined;
if (EditorBuildRules.< > f__mg$cache1 == null)
{
EditorBuildRules.< > f__mg$cache1 = new Func <string, int>(EditorBuildRules.FilterAssemblyInFirstpassEditorFolder);
}
EditorBuildRules.TargetAssembly item3 = new EditorBuildRules.TargetAssembly(arg_D0_0, arg_D0_1, arg_D0_2, arg_D0_3, EditorBuildRules.< > f__mg$cache1);
string arg_109_0 = "Assembly-" + languageName + "-Editor.dll";
SupportedLanguage arg_109_1 = current;
AssemblyFlags arg_109_2 = AssemblyFlags.EditorOnly;
EditorBuildRules.TargetAssemblyType arg_109_3 = EditorBuildRules.TargetAssemblyType.Predefined;
if (EditorBuildRules.< > f__mg$cache2 == null)
{
EditorBuildRules.< > f__mg$cache2 = new Func <string, int>(EditorBuildRules.FilterAssemblyInEditorFolder);
}
EditorBuildRules.TargetAssembly item4 = new EditorBuildRules.TargetAssembly(arg_109_0, arg_109_1, arg_109_2, arg_109_3, EditorBuildRules.< > f__mg$cache2);
list.Add(item);
list2.Add(item2);
list3.Add(item3);
list4.Add(item4);
list5.Add(item);
list5.Add(item2);
list5.Add(item3);
list5.Add(item4);
}
foreach (EditorBuildRules.TargetAssembly current2 in list2)
{
current2.References.AddRange(list);
}
foreach (EditorBuildRules.TargetAssembly current3 in list3)
{
current3.References.AddRange(list);
}
foreach (EditorBuildRules.TargetAssembly current4 in list4)
{
current4.References.AddRange(list);
current4.References.AddRange(list2);
current4.References.AddRange(list3);
}
return(list5.ToArray());
}
internal CustomScriptAssembly FindCustomScriptAssembly(string scriptPath)
{
EditorBuildRules.TargetAssembly customTargetAssembly = EditorBuildRules.GetCustomTargetAssembly(scriptPath, this.projectDirectory, this.customTargetAssemblies);
return(this.customScriptAssemblies.Single((CustomScriptAssembly a) => a.Name == Path.GetFileNameWithoutExtension(customTargetAssembly.Filename)));
}