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 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 ScriptAssembly[] GetAllScriptAssemblies(BuildFlags buildFlags, EditorScriptCompilationOptions options, PrecompiledAssembly[] unityAssembliesArg, PrecompiledAssembly[] precompiledAssembliesArg)
{
EditorBuildRules.CompilationAssemblies assemblies = new EditorBuildRules.CompilationAssemblies
{
UnityAssemblies = unityAssembliesArg,
PrecompiledAssemblies = precompiledAssembliesArg,
CustomTargetAssemblies = this.customTargetAssemblies,
EditorAssemblyReferences = ModuleUtils.GetAdditionalReferencesForUserScripts()
};
ScriptAssemblySettings settings = this.CreateEditorScriptAssemblySettings(options);
return(EditorBuildRules.GetAllScriptAssemblies(this.allScripts, this.projectDirectory, buildFlags, settings, assemblies));
}
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);
}
private static int FilterAssemblyInFirstpassEditorFolder(string pathName)
{
int num = EditorBuildRules.FilterAssemblyInFirstpassFolder(pathName);
int result;
if (num == -1)
{
result = -1;
}
else
{
result = EditorBuildRules.FilterAssemblyInEditorFolder(pathName);
}
return(result);
}
public static bool IsCSharpFirstPassAssembly(string assemblyName, EditorBuildRules.TargetAssembly[] customTargetAssemblies)
{
bool result;
if (!assemblyName.ToLower().Contains("firstpass"))
{
result = false;
}
else
{
SupportedLanguage cSharpSupportedLanguage = ScriptCompilers.CSharpSupportedLanguage;
IEnumerable <EditorBuildRules.TargetAssembly> source = from a in EditorBuildRules.GetTargetAssemblies(cSharpSupportedLanguage, customTargetAssemblies)
where a.Flags != AssemblyFlags.EditorOnly
select a;
result = source.Any((EditorBuildRules.TargetAssembly a) => a.Filename == assemblyName);
}
return(result);
}
public void SetAllCustomScriptAssemblyJsons(string[] paths)
{
List <CustomScriptAssembly> list = new List <CustomScriptAssembly>();
for (int i = 0; i < paths.Length; i++)
{
string text = paths[i];
try
{
string path = (!Path.IsPathRooted(text)) ? Path.Combine(this.projectDirectory, text) : text;
CustomScriptAssembly loadedCustomScriptAssembly = EditorCompilation.LoadCustomScriptAssemblyFromJson(path);
if (list.Any((CustomScriptAssembly a) => string.Equals(a.Name, loadedCustomScriptAssembly.Name, StringComparison.OrdinalIgnoreCase)))
{
throw new Exception(string.Format("Assembly with name '{0}' is already defined ({1})", loadedCustomScriptAssembly.Name.Length, loadedCustomScriptAssembly.FilePath));
}
if (loadedCustomScriptAssembly.References == null)
{
loadedCustomScriptAssembly.References = new string[0];
}
if (loadedCustomScriptAssembly.References.Length != loadedCustomScriptAssembly.References.Distinct <string>().Count <string>())
{
throw new Exception(string.Format("Duplicate assembly references in {0}", loadedCustomScriptAssembly.FilePath));
}
list.Add(loadedCustomScriptAssembly);
}
catch (Exception ex)
{
throw new Exception(ex.Message + " - '" + text + "'");
}
}
this.customScriptAssemblies = list.ToArray();
try
{
EditorCompilation.CheckCyclicAssemblyReferences(this.customScriptAssemblies);
}
catch (Exception ex2)
{
this.customScriptAssemblies = null;
this.customTargetAssemblies = null;
throw ex2;
}
this.customTargetAssemblies = EditorBuildRules.CreateTargetAssemblies(this.customScriptAssemblies);
}
public EditorCompilation.TargetAssemblyInfo[] GetTargetAssemblies()
{
EditorBuildRules.TargetAssembly[] predefinedTargetAssemblies = EditorBuildRules.GetPredefinedTargetAssemblies();
EditorCompilation.TargetAssemblyInfo[] array = new EditorCompilation.TargetAssemblyInfo[predefinedTargetAssemblies.Length + ((this.customTargetAssemblies == null) ? 0 : this.customTargetAssemblies.Count <EditorBuildRules.TargetAssembly>())];
for (int i = 0; i < predefinedTargetAssemblies.Length; i++)
{
array[i].Name = this.AssemblyFilenameWithSuffix(predefinedTargetAssemblies[i].Filename);
array[i].Flags = predefinedTargetAssemblies[i].Flags;
}
if (this.customTargetAssemblies != null)
{
for (int j = 0; j < this.customTargetAssemblies.Count <EditorBuildRules.TargetAssembly>(); j++)
{
int num = predefinedTargetAssemblies.Length + j;
array[num].Name = this.AssemblyFilenameWithSuffix(this.customTargetAssemblies[j].Filename);
array[num].Flags = this.customTargetAssemblies[j].Flags;
}
}
return(array);
}
private static int FilterAssemblyInFirstpassFolder(string pathName)
{
int num = EditorBuildRules.FilterAssemblyPathBeginsWith(pathName, "/assets/plugins/");
int result;
if (num >= 0)
{
result = num;
}
else
{
num = EditorBuildRules.FilterAssemblyPathBeginsWith(pathName, "/assets/standard assets/");
if (num >= 0)
{
result = num;
}
else
{
num = EditorBuildRules.FilterAssemblyPathBeginsWith(pathName, "/assets/pro standard assets/");
if (num >= 0)
{
result = num;
}
else
{
num = EditorBuildRules.FilterAssemblyPathBeginsWith(pathName, "/assets/iphone standard assets/");
if (num >= 0)
{
result = num;
}
else
{
result = -1;
}
}
}
}
return(result);
}
static EditorBuildRules()
{
EditorBuildRules.predefinedTargetAssemblies = EditorBuildRules.CreatePredefinedTargetAssemblies();
}
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();
}
public EditorBuildRules.TargetAssembly GetTargetAssemblyDetails(string scriptPath)
{
return(EditorBuildRules.GetTargetAssembly(scriptPath, this.projectDirectory, this.customTargetAssemblies));
}
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 bool CompileScripts(ScriptAssemblySettings scriptAssemblySettings, string tempBuildDirectory, BuildFlags buildflags, ref EditorBuildRules.TargetAssembly[] notCompiledTargetAssemblies)
{
this.DeleteUnusedAssemblies();
this.allScripts.RemoveWhere((string path) => !File.Exists(Path.Combine(this.projectDirectory, path)));
this.StopAllCompilation();
if (!Directory.Exists(scriptAssemblySettings.OutputDirectory))
{
Directory.CreateDirectory(scriptAssemblySettings.OutputDirectory);
}
if (!Directory.Exists(tempBuildDirectory))
{
Directory.CreateDirectory(tempBuildDirectory);
}
IEnumerable <string> enumerable = (!this.areAllScriptsDirty) ? this.dirtyScripts.ToArray <string>() : this.allScripts.ToArray <string>();
this.areAllScriptsDirty = false;
this.dirtyScripts.Clear();
bool result;
if (!enumerable.Any <string>() && this.runScriptUpdaterAssemblies.Count == 0)
{
result = false;
}
else
{
EditorBuildRules.CompilationAssemblies assemblies = new EditorBuildRules.CompilationAssemblies
{
UnityAssemblies = this.unityAssemblies,
PrecompiledAssemblies = this.precompiledAssemblies,
CustomTargetAssemblies = this.customTargetAssemblies,
EditorAssemblyReferences = ModuleUtils.GetAdditionalReferencesForUserScripts()
};
EditorBuildRules.GenerateChangedScriptAssembliesArgs generateChangedScriptAssembliesArgs = new EditorBuildRules.GenerateChangedScriptAssembliesArgs
{
AllSourceFiles = this.allScripts,
DirtySourceFiles = enumerable,
ProjectDirectory = this.projectDirectory,
BuildFlags = buildflags,
Settings = scriptAssemblySettings,
Assemblies = assemblies,
RunUpdaterAssemblies = this.runScriptUpdaterAssemblies
};
ScriptAssembly[] array = EditorBuildRules.GenerateChangedScriptAssemblies(generateChangedScriptAssembliesArgs);
notCompiledTargetAssemblies = generateChangedScriptAssembliesArgs.NotCompiledTargetAssemblies.ToArray <EditorBuildRules.TargetAssembly>();
if (!array.Any <ScriptAssembly>())
{
result = false;
}
else
{
this.compilationTask = new CompilationTask(array, tempBuildDirectory, buildflags, SystemInfo.processorCount);
this.compilationTask.OnCompilationStarted += delegate(ScriptAssembly assembly, int phase)
{
Console.WriteLine("- Starting compile {0}", Path.Combine(scriptAssemblySettings.OutputDirectory, assembly.Filename));
};
IEnumerable <MonoIsland> compilingMonoIslands = from i in this.GetAllMonoIslands()
where 0 < i._files.Length
select i;
this.compilationTask.OnCompilationFinished += delegate(ScriptAssembly assembly, List <CompilerMessage> messages)
{
Console.WriteLine("- Finished compile {0}", Path.Combine(scriptAssemblySettings.OutputDirectory, assembly.Filename));
if (this.runScriptUpdaterAssemblies.Contains(assembly.Filename))
{
this.runScriptUpdaterAssemblies.Remove(assembly.Filename);
}
if (!messages.Any((CompilerMessage m) => m.type == CompilerMessageType.Error))
{
string engineAssemblyPath = InternalEditorUtility.GetEngineAssemblyPath();
string unityUNet = EditorApplication.applicationContentsPath + "/UnityExtensions/Unity/Networking/UnityEngine.Networking.dll";
if (!Weaver.WeaveUnetFromEditor(compilingMonoIslands, Path.Combine(tempBuildDirectory, assembly.Filename), Path.Combine(EditorCompilation.EditorTempPath, assembly.Filename), engineAssemblyPath, unityUNet, (buildflags & BuildFlags.BuildingForEditor) != BuildFlags.None))
{
messages.Add(new CompilerMessage
{
message = "UNet Weaver failed",
type = CompilerMessageType.Error,
file = assembly.FullPath,
line = -1,
column = -1
});
this.StopAllCompilation();
}
else
{
EditorCompilation.CopyAssembly(Path.Combine(tempBuildDirectory, assembly.Filename), assembly.FullPath);
}
}
};
this.compilationTask.Poll();
result = true;
}
}
return(result);
}
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)));
}
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));
}
