public static AssemblyMethodData ReadMethod(MethodDefinition method, AssemblyTypeData typeData)
{
if (!method.HasBody)
{
return(null);
}
AssemblyMethodData methodData = new AssemblyMethodData(method.Name, typeData);
var instructions = method.Body.Instructions;
for (int i = 0; i < instructions.Count; i++)
{
if (instructions[i].OpCode == OpCodes.Ldstr)
{
string text = (string)instructions[i].Operand;
if (!TextFinder.TextFinder.IsValidText(text))
{
continue;
}
AssemblyTextEntry textEntry = new AssemblyTextEntry(i, text, null, methodData);
methodData.texts.Add(textEntry);
}
}
if (methodData.texts.Count == 0)
{
return(null);
}
return(methodData);
}
private static AssemblyTypeData ReadType(TypeDefinition type, BaseDataContainer dir)
{
AssemblyTypeData typeData = new AssemblyTypeData(type.FullName, dir);
foreach (var method in type.Methods)
{
AssemblyMethodData methodData = ReadMethod(method, typeData);
if (methodData != null)
{
typeData.methods.Add(methodData);
}
}
foreach (var nestedType in type.NestedTypes)
{
AssemblyTypeData nestedTypeData = ReadType(nestedType, dir);
if (nestedTypeData != null)
{
typeData.nestedTypes.Add(nestedTypeData);
}
}
if (typeData.nestedTypes.Count == 0 && typeData.methods.Count == 0)
{
return(null);
}
return(typeData);
}
private void changeConentDescription(DescriptionMode descriptionMode)
{
componentsDescriptionMode = descriptionMode;
for (int i = 0; i < asmContentTree.Items.Count; i++)
{
TreeViewItem typeItem = asmContentTree.Items[i] as TreeViewItem;
if (typeItem.Header is AssemblyTypeData)
{
AssemblyTypeData type = typeItem.Header as AssemblyTypeData;
type.TypeDescriptionMode = descriptionMode;
typeItem.Header = null;
typeItem.Header = type;
}
for (int j = 0; j < typeItem.Items.Count; j++)
{
TreeViewItem methodItem = typeItem.Items[j] as TreeViewItem;
if (methodItem.Header is AssemblyMethodData)
{
AssemblyMethodData method = methodItem.Header as AssemblyMethodData;
method.MethodDescriptionMode = descriptionMode;
methodItem.Header = null;
methodItem.Header = method;
}
}
}
}
private void LoadAssemblyTypes()
{
assemblyTypes.Clear();
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (var assembly in assemblies)
{
string assemblyName = assembly.GetName().Name;
if (genConfig.AssemblyNames.IndexOf(assemblyName) < 0)
{
continue;
}
foreach (var type in assembly.GetTypes())
{
if (type.IsNotPublic || type.IsInterface || type.IsGenericType || (!type.IsSealed && type.IsAbstract) || (type.IsNested && !type.IsNestedPublic))
{
continue;
}
AssemblyTypeData typeData = new AssemblyTypeData();
typeData.Type = type;
if (!type.IsEnum)
{
typeData.Fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).ToList();
typeData.Fields.Sort((item1, item2) =>
{
return(item1.Name.CompareTo(item2.Name));
});
typeData.Properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).ToList();
typeData.Properties.Sort((item1, item2) =>
{
return(item1.Name.CompareTo(item2.Name));
});
typeData.Methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).ToList();
typeData.Methods.Sort((item1, item2) =>
{
return(item1.Name.CompareTo(item2.Name));
});
}
assemblyTypes.Add(typeData);
}
if (assemblyTypes.Count > 0)
{
assemblyTypes.Sort((item1, item2) =>
{
return(item1.Type.FullName.CompareTo(item2.Type.FullName));
});
}
}
}
public static void OpenUnityGameAssembly(string projName, string path)
{
curModule = ModuleDefinition.ReadModule(path);
projectData = new ProjectData(projName, path);
Console.WriteLine("Path: " + path);
foreach (var type in curModule.Types)
{
Debug.WriteLine("Type: " + type.FullName);
AssemblyTypeData typeData = ReadType(type, projectData);
if (typeData != null)
{
projectData.AddChild(typeData);
}
}
}
private void addTypeContentToTree(AssemblyTypeData type)
{
type.TypeDescriptionMode = componentsDescriptionMode;
if (type.TypeKeyWord == TypeKeyWords.Class)
{
TreeViewItem typeItem = createItem(type);
for (int i = 0; i < type.DeclaredMethods.Length; i++)
{
type.DeclaredMethods[i].MethodDescriptionMode = componentsDescriptionMode;
if (type.DeclaredMethods[i].AccessModifier.HasFlag(MethodAttributes.Public) ||
type.DeclaredMethods[i].AccessModifier.HasFlag(MethodAttributes.Family))
{
TreeViewItem methodItem = createItem(type.DeclaredMethods[i]);
typeItem.Items.Add(methodItem);
}
}
asmContentTree.Items.Add(typeItem);
}
}
