public void CollectReferences(string path, bool collectMethods, float progressValue, bool ignoreSystemDlls)
{
this._progressValue = progressValue;
this._assemblyDefinitions = new HashSet <AssemblyDefinition>();
string[] array = (!Directory.Exists(path)) ? new string[0] : Directory.GetFiles(path);
DefaultAssemblyResolver assemblyResolver = AssemblyReferenceChecker.AssemblyResolverFor(path);
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i];
if (!(Path.GetExtension(text) != ".dll"))
{
string arg_74_0 = text;
ReaderParameters readerParameters = new ReaderParameters();
readerParameters.set_AssemblyResolver(assemblyResolver);
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(arg_74_0, readerParameters);
if (!ignoreSystemDlls || !AssemblyReferenceChecker.IsIgnoredSystemDll(assemblyDefinition.get_Name().get_Name()))
{
this._assemblyFileNames.Add(Path.GetFileName(text));
this._assemblyDefinitions.Add(assemblyDefinition);
}
}
}
AssemblyDefinition[] array3 = this._assemblyDefinitions.ToArray <AssemblyDefinition>();
this._referencedTypes = MonoAOTRegistration.BuildReferencedTypeList(array3);
if (collectMethods)
{
this.CollectReferencedAndDefinedMethods(array3);
}
}
private void CollectReferencesFromRootsRecursive(string dir, IEnumerable <string> roots, bool ignoreSystemDlls)
{
DefaultAssemblyResolver assemblyResolver = AssemblyReferenceChecker.AssemblyResolverFor(dir);
foreach (string current in roots)
{
string fileName = Path.Combine(dir, current);
if (!this._assemblyFileNames.Contains(current))
{
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(fileName, new ReaderParameters
{
AssemblyResolver = assemblyResolver
});
if (!ignoreSystemDlls || !AssemblyReferenceChecker.IsIgnoredSystemDll(assemblyDefinition.Name.Name))
{
this._assemblyFileNames.Add(current);
this._assemblyDefinitions.Add(assemblyDefinition);
foreach (AssemblyNameReference current2 in assemblyDefinition.MainModule.AssemblyReferences)
{
string text = current2.Name + ".dll";
if (!this._assemblyFileNames.Contains(text))
{
this.CollectReferencesFromRootsRecursive(dir, new string[]
{
text
}, ignoreSystemDlls);
}
}
}
}
}
}
public void CollectReferences(string path, bool withMethods, float progressValue, bool ignoreSystemDlls)
{
this.assemblyDefinitions = new HashSet <AssemblyDefinition>();
string[] array = (!Directory.Exists(path)) ? new string[0] : Directory.GetFiles(path);
string[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
string text = array2[i];
if (!(Path.GetExtension(text) != ".dll"))
{
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(text);
if (!ignoreSystemDlls || !AssemblyReferenceChecker.IsIgnoredSystemDll(assemblyDefinition.Name.Name))
{
this.assemblyFileNames.Add(Path.GetFileName(text));
this.assemblyDefinitions.Add(assemblyDefinition);
}
}
}
AssemblyDefinition[] array3 = this.assemblyDefinitions.ToArray <AssemblyDefinition>();
this.referencedTypes = MonoAOTRegistration.BuildReferencedTypeList(array3);
if (withMethods)
{
this.CollectReferencedMethods(array3, this.referencedMethods, this.definedMethods, progressValue);
}
}
private void CollectReferencedAndDefinedMethods(IEnumerable <AssemblyDefinition> assemblyDefinitions)
{
foreach (AssemblyDefinition current in assemblyDefinitions)
{
bool isSystem = AssemblyReferenceChecker.IsIgnoredSystemDll(current.Name.Name);
foreach (TypeDefinition current2 in current.MainModule.Types)
{
this.CollectReferencedAndDefinedMethods(current2, isSystem);
}
}
}
private static HashSet <string> CollectManagedTypeReferencesFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo)
{
HashSet <string> set = new HashSet <string>();
AssemblyReferenceChecker checker = new AssemblyReferenceChecker();
bool collectMethods = false;
bool ignoreSystemDlls = false;
checker.CollectReferencesFromRoots(directory, rootAssemblies, collectMethods, 0f, ignoreSystemDlls);
string[] assemblyFileNames = checker.GetAssemblyFileNames();
AssemblyDefinition[] assemblyDefinitions = checker.GetAssemblyDefinitions();
foreach (AssemblyDefinition definition in assemblyDefinitions)
{
foreach (TypeDefinition definition2 in definition.MainModule.Types)
{
if (definition2.Namespace.StartsWith("UnityEngine") && (((definition2.Fields.Count > 0) || (definition2.Methods.Count > 0)) || (definition2.Properties.Count > 0)))
{
string name = definition2.Name;
set.Add(name);
if ((strippingInfo != null) && !AssemblyReferenceChecker.IsIgnoredSystemDll(definition.Name.Name))
{
strippingInfo.RegisterDependency(name, "Required by Scripts");
}
}
}
}
AssemblyDefinition definition3 = null;
for (int i = 0; i < assemblyFileNames.Length; i++)
{
if (assemblyFileNames[i] == "UnityEngine.dll")
{
definition3 = assemblyDefinitions[i];
}
}
foreach (AssemblyDefinition definition4 in assemblyDefinitions)
{
if (definition4 != definition3)
{
foreach (TypeReference reference in definition4.MainModule.GetTypeReferences())
{
if (reference.Namespace.StartsWith("UnityEngine"))
{
string item = reference.Name;
set.Add(item);
if ((strippingInfo != null) && !AssemblyReferenceChecker.IsIgnoredSystemDll(definition4.Name.Name))
{
strippingInfo.RegisterDependency(item, "Required by Scripts");
}
}
}
}
}
return(set);
}
public string WhoReferencesClass(string klass, bool ignoreSystemDlls)
{
foreach (AssemblyDefinition current in this.assemblyDefinitions)
{
if (!ignoreSystemDlls || !AssemblyReferenceChecker.IsIgnoredSystemDll(current.Name.Name))
{
AssemblyDefinition[] assemblies = new AssemblyDefinition[]
{
current
};
HashSet <string> source = MonoAOTRegistration.BuildReferencedTypeList(assemblies);
if (source.Any((string item) => item.StartsWith(klass)))
{
return(current.Name.Name);
}
}
}
return(null);
}
private void CollectReferencesFromRootsRecursive(string dir, IEnumerable <string> roots, bool ignoreSystemDlls)
{
DefaultAssemblyResolver assemblyResolver = AssemblyReferenceChecker.AssemblyResolverFor(dir);
foreach (string current in roots)
{
string text = Path.Combine(dir, current);
if (!this._assemblyFileNames.Contains(current))
{
string arg_4D_0 = text;
ReaderParameters readerParameters = new ReaderParameters();
readerParameters.set_AssemblyResolver(assemblyResolver);
AssemblyDefinition assemblyDefinition = AssemblyDefinition.ReadAssembly(arg_4D_0, readerParameters);
if (!ignoreSystemDlls || !AssemblyReferenceChecker.IsIgnoredSystemDll(assemblyDefinition.get_Name().get_Name()))
{
this._assemblyFileNames.Add(current);
this._assemblyDefinitions.Add(assemblyDefinition);
using (Collection <AssemblyNameReference> .Enumerator enumerator2 = assemblyDefinition.get_MainModule().get_AssemblyReferences().GetEnumerator())
{
while (enumerator2.MoveNext())
{
AssemblyNameReference current2 = enumerator2.get_Current();
string text2 = current2.get_Name() + ".dll";
if (!this._assemblyFileNames.Contains(text2))
{
this.CollectReferencesFromRootsRecursive(dir, new string[]
{
text2
}, ignoreSystemDlls);
}
}
}
}
}
}
}
// Collects all types from managed assemblies.
// Follows assembly references from given root assemblies.
// Assemblies should be already stripped.
private static HashSet <string> CollectManagedTypeReferencesFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo)
{
if (AssemblyStripper.UseUnityLinkerEngineModuleStripping)
{
throw new NotSupportedException("Don't want to rely on this method when UnityLinker EMS is used");
}
HashSet <string> foundTypes = new HashSet <string>();
AssemblyReferenceChecker checker = new AssemblyReferenceChecker();
bool collectMethods = false;
bool ignoreSystemDlls = false;
checker.CollectReferencesFromRoots(directory, rootAssemblies, collectMethods, 0.0f, ignoreSystemDlls);
{
string[] fileNames = checker.GetAssemblyFileNames();
AssemblyDefinition[] assemblies = checker.GetAssemblyDefinitions();
foreach (AssemblyDefinition definition in assemblies)
{
foreach (TypeDefinition typeDefinition in definition.MainModule.Types)
{
if (typeDefinition.Namespace.StartsWith("UnityEngine"))
{
// Skip blank types
if (typeDefinition.Fields.Count > 0 || typeDefinition.Methods.Count > 0 || typeDefinition.Properties.Count > 0)
{
string className = typeDefinition.Name;
foundTypes.Add(className);
if (strippingInfo != null)
{
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(definition))
{
strippingInfo.RegisterDependency(className, StrippingInfo.RequiredByScripts);
}
}
}
}
}
}
AssemblyDefinition unityEngineAssemblyDefinition = null;
AssemblyDefinition unityEngineUIAssemblyDefinition = null;
for (int i = 0; i < fileNames.Length; i++)
{
if (fileNames[i] == "UnityEngine.dll")
{
unityEngineAssemblyDefinition = assemblies[i];
}
// UnityEngine.UI references UnityEngine.Collider, which causes the inclusion of Physics and Physics2D modules if
// UnityEngine.UI is referenced. UnityEngine.UI code is designed to only actually access Colliders if these modules
// are used, so don't include references from UnityEngine.UI here.
if (fileNames[i] == "Unity.ugui.dll")
{
unityEngineUIAssemblyDefinition = assemblies[i];
}
}
foreach (AssemblyDefinition definition in assemblies)
{
if (definition != unityEngineAssemblyDefinition && definition != unityEngineUIAssemblyDefinition)
{
foreach (TypeReference typeReference in definition.MainModule.GetTypeReferences())
{
if (typeReference.Namespace.StartsWith("UnityEngine"))
{
string className = typeReference.Name;
foundTypes.Add(className);
if (strippingInfo != null)
{
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(definition))
{
strippingInfo.RegisterDependency(className, StrippingInfo.RequiredByScripts);
}
}
}
}
}
}
}
return(foundTypes);
}
private static HashSet <string> CollectManagedTypeReferencesFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo)
{
HashSet <string> hashSet = new HashSet <string>();
AssemblyReferenceChecker assemblyReferenceChecker = new AssemblyReferenceChecker();
bool collectMethods = false;
bool ignoreSystemDlls = false;
assemblyReferenceChecker.CollectReferencesFromRoots(directory, rootAssemblies, collectMethods, 0f, ignoreSystemDlls);
string[] assemblyFileNames = assemblyReferenceChecker.GetAssemblyFileNames();
AssemblyDefinition[] assemblyDefinitions = assemblyReferenceChecker.GetAssemblyDefinitions();
AssemblyDefinition[] array = assemblyDefinitions;
for (int i = 0; i < array.Length; i++)
{
AssemblyDefinition assemblyDefinition = array[i];
foreach (TypeDefinition current in assemblyDefinition.MainModule.Types)
{
if (current.Namespace.StartsWith("UnityEngine"))
{
if (current.Fields.Count > 0 || current.Methods.Count > 0 || current.Properties.Count > 0)
{
string name = current.Name;
hashSet.Add(name);
if (strippingInfo != null)
{
string name2 = assemblyDefinition.Name.Name;
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(name2))
{
strippingInfo.RegisterDependency(name, "Required by Scripts");
}
}
}
}
}
}
AssemblyDefinition assemblyDefinition2 = null;
AssemblyDefinition assemblyDefinition3 = null;
for (int j = 0; j < assemblyFileNames.Length; j++)
{
if (assemblyFileNames[j] == "UnityEngine.dll")
{
assemblyDefinition2 = assemblyDefinitions[j];
}
if (assemblyFileNames[j] == "UnityEngine.UI.dll")
{
assemblyDefinition3 = assemblyDefinitions[j];
}
}
AssemblyDefinition[] array2 = assemblyDefinitions;
for (int k = 0; k < array2.Length; k++)
{
AssemblyDefinition assemblyDefinition4 = array2[k];
if (assemblyDefinition4 != assemblyDefinition2 && assemblyDefinition4 != assemblyDefinition3)
{
foreach (TypeReference current2 in assemblyDefinition4.MainModule.GetTypeReferences())
{
if (current2.Namespace.StartsWith("UnityEngine"))
{
string name3 = current2.Name;
hashSet.Add(name3);
if (strippingInfo != null)
{
string name4 = assemblyDefinition4.Name.Name;
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(name4))
{
strippingInfo.RegisterDependency(name3, "Required by Scripts");
}
}
}
}
}
}
return(hashSet);
}
private static HashSet <string> CollectManagedTypeReferencesFromRoots(string directory, string[] rootAssemblies, StrippingInfo strippingInfo)
{
HashSet <string> hashSet = new HashSet <string>();
AssemblyReferenceChecker assemblyReferenceChecker = new AssemblyReferenceChecker();
bool collectMethods = false;
bool ignoreSystemDlls = false;
assemblyReferenceChecker.CollectReferencesFromRoots(directory, rootAssemblies, collectMethods, 0f, ignoreSystemDlls);
string[] assemblyFileNames = assemblyReferenceChecker.GetAssemblyFileNames();
AssemblyDefinition[] assemblyDefinitions = assemblyReferenceChecker.GetAssemblyDefinitions();
AssemblyDefinition[] array = assemblyDefinitions;
for (int i = 0; i < array.Length; i++)
{
AssemblyDefinition assemblyDefinition = array[i];
using (Collection <TypeDefinition> .Enumerator enumerator = assemblyDefinition.get_MainModule().get_Types().GetEnumerator())
{
while (enumerator.MoveNext())
{
TypeDefinition current = enumerator.get_Current();
if (current.get_Namespace().StartsWith("UnityEngine"))
{
if (current.get_Fields().get_Count() > 0 || current.get_Methods().get_Count() > 0 || current.get_Properties().get_Count() > 0)
{
string name = current.get_Name();
hashSet.Add(name);
if (strippingInfo != null)
{
string name2 = assemblyDefinition.get_Name().get_Name();
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(name2))
{
strippingInfo.RegisterDependency(name, "Required by Scripts");
}
}
}
}
}
}
}
AssemblyDefinition assemblyDefinition2 = null;
for (int j = 0; j < assemblyFileNames.Length; j++)
{
if (assemblyFileNames[j] == "UnityEngine.dll")
{
assemblyDefinition2 = assemblyDefinitions[j];
}
}
AssemblyDefinition[] array2 = assemblyDefinitions;
for (int k = 0; k < array2.Length; k++)
{
AssemblyDefinition assemblyDefinition3 = array2[k];
if (assemblyDefinition3 != assemblyDefinition2)
{
foreach (TypeReference current2 in assemblyDefinition3.get_MainModule().GetTypeReferences())
{
if (current2.get_Namespace().StartsWith("UnityEngine"))
{
string name3 = current2.get_Name();
hashSet.Add(name3);
if (strippingInfo != null)
{
string name4 = assemblyDefinition3.get_Name().get_Name();
if (!AssemblyReferenceChecker.IsIgnoredSystemDll(name4))
{
strippingInfo.RegisterDependency(name3, "Required by Scripts");
}
}
}
}
}
}
return(hashSet);
}
