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)); }