647 lines
36 KiB
C#
647 lines
36 KiB
C#
using HarmonyLib.Public.Patching;
|
|
using HarmonyLib;
|
|
using KFCommonUtilityLib.Scripts.Attributes;
|
|
using Mono.Cecil;
|
|
using Mono.Cecil.Cil;
|
|
using MonoMod.Cil;
|
|
using MonoMod.Utils;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UniLinq;
|
|
using System.Reflection;
|
|
using KFCommonUtilityLib.Harmony;
|
|
using UnityEngine.Scripting;
|
|
using TypeAttributes = Mono.Cecil.TypeAttributes;
|
|
using MethodAttributes = Mono.Cecil.MethodAttributes;
|
|
using FieldAttributes = Mono.Cecil.FieldAttributes;
|
|
using Mono.Cecil.Rocks;
|
|
|
|
namespace KFCommonUtilityLib
|
|
{
|
|
public interface IModuleContainerFor<out T> where T : class
|
|
{
|
|
T Instance { get; }
|
|
}
|
|
|
|
public class TranspilerTarget
|
|
{
|
|
public TranspilerTarget(Type type_action, MethodInfo mtdinf_original, PatchInfo patchinf_harmony)
|
|
{
|
|
this.type_action = type_action;
|
|
this.mtdinf_original = mtdinf_original;
|
|
this.patchinf_harmony = patchinf_harmony;
|
|
}
|
|
|
|
public Type type_action;
|
|
public MethodInfo mtdinf_original;
|
|
public PatchInfo patchinf_harmony;
|
|
}
|
|
|
|
public class MethodPatchInfo
|
|
{
|
|
public readonly MethodDefinition Method;
|
|
public Instruction PrefixBegin;
|
|
public Instruction PostfixBegin;
|
|
public Instruction PostfixEnd;
|
|
|
|
public MethodPatchInfo(MethodDefinition mtddef, Instruction postfixEnd, Instruction prefixBegin)
|
|
{
|
|
Method = mtddef;
|
|
PostfixEnd = postfixEnd;
|
|
PrefixBegin = prefixBegin;
|
|
}
|
|
}
|
|
|
|
internal struct MethodOverrideInfo
|
|
{
|
|
public MethodInfo mtdinf_target;
|
|
public MethodInfo mtdinf_base;
|
|
public MethodReference mtdref_base;
|
|
public Type prefType;
|
|
|
|
public MethodOverrideInfo(MethodInfo mtdinf_target, MethodInfo mtdinf_base, MethodReference mtddef_base, Type prefType)
|
|
{
|
|
this.mtdinf_target = mtdinf_target;
|
|
this.mtdinf_base = mtdinf_base;
|
|
this.mtdref_base = mtddef_base;
|
|
this.prefType = prefType;
|
|
}
|
|
}
|
|
|
|
public class ModuleManipulator
|
|
{
|
|
public ModuleDefinition module;
|
|
public IModuleProcessor processor;
|
|
public Type targetType;
|
|
public Type baseType;
|
|
public Type[] moduleTypes;
|
|
public Type[][] moduleExtensionTypes;
|
|
public TypeDefinition typedef_newTarget;
|
|
public TypeReference typeref_interface;
|
|
public FieldDefinition[] arr_flddef_modules;
|
|
private static MethodInfo mtdinf = AccessTools.Method(typeof(ModuleManagers), nameof(ModuleManagers.GetModuleExtensions));
|
|
|
|
public ModuleManipulator(AssemblyDefinition workingAssembly, IModuleProcessor processor, Type targetType, Type baseType, params Type[] moduleTypes)
|
|
{
|
|
module = workingAssembly.MainModule;
|
|
this.processor = processor;
|
|
this.targetType = targetType;
|
|
this.baseType = baseType;
|
|
this.moduleTypes = moduleTypes;
|
|
moduleExtensionTypes = moduleTypes.Select(t => (Type[])mtdinf.MakeGenericMethod(t).Invoke(null, null)).ToArray();
|
|
Patch();
|
|
}
|
|
|
|
private void Patch()
|
|
{
|
|
typeref_interface = module.ImportReference(typeof(IModuleContainerFor<>));
|
|
//Create new override type
|
|
TypeReference typeref_target = module.ImportReference(targetType);
|
|
typedef_newTarget = new TypeDefinition(null, ModuleUtils.CreateTypeName(targetType, moduleTypes), TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.Public | TypeAttributes.Sealed, typeref_target);
|
|
typedef_newTarget.CustomAttributes.Add(new CustomAttribute(module.ImportReference(typeof(PreserveAttribute).GetConstructor(Array.Empty<Type>()))));
|
|
module.Types.Add(typedef_newTarget);
|
|
|
|
//Create fields
|
|
arr_flddef_modules = new FieldDefinition[moduleTypes.Length];
|
|
for (int i = 0; i < moduleTypes.Length; i++)
|
|
{
|
|
//Create ItemAction field
|
|
Type type_module = moduleTypes[i];
|
|
MakeContainerFor(typedef_newTarget, type_module, out var flddef_module);
|
|
arr_flddef_modules[i] = flddef_module;
|
|
}
|
|
|
|
//Create ItemAction constructor
|
|
MethodDefinition mtddef_ctor = new MethodDefinition(".ctor", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, module.TypeSystem.Void);
|
|
if (processor == null || !processor.BuildConstructor(this, mtddef_ctor))
|
|
{
|
|
var il = mtddef_ctor.Body.GetILProcessor();
|
|
il.Append(il.Create(OpCodes.Ldarg_0));
|
|
il.Append(il.Create(OpCodes.Call, module.ImportReference(targetType.GetConstructor(Array.Empty<Type>()))));
|
|
il.Append(il.Create(OpCodes.Nop));
|
|
for (int i = 0; i < arr_flddef_modules.Length; i++)
|
|
{
|
|
il.Append(il.Create(OpCodes.Ldarg_0));
|
|
il.Append(il.Create(OpCodes.Newobj, module.ImportReference(moduleTypes[i].GetConstructor(Array.Empty<Type>()))));
|
|
il.Append(il.Create(OpCodes.Stfld, arr_flddef_modules[i]));
|
|
il.Append(il.Create(OpCodes.Nop));
|
|
}
|
|
il.Append(il.Create(OpCodes.Ret));
|
|
}
|
|
typedef_newTarget.Methods.Add(mtddef_ctor);
|
|
|
|
processor?.InitModules(this, targetType, baseType, moduleTypes);
|
|
|
|
//<derived method name, method patch info>
|
|
Dictionary<string, MethodPatchInfo> dict_overrides = new Dictionary<string, MethodPatchInfo>();
|
|
//<derived method name, transpiler stub methods in inheritance order>
|
|
//TODO: USE TREE INSTEAD OF LIST
|
|
Dictionary<string, List<TranspilerTarget>> dict_transpilers = new Dictionary<string, List<TranspilerTarget>>();
|
|
//<derived method name, <module type name, local variable>>
|
|
Dictionary<string, Dictionary<string, VariableDefinition>> dict_all_states = new Dictionary<string, Dictionary<string, VariableDefinition>>();
|
|
|
|
//Get all transpilers
|
|
for (int i = 0; i < moduleTypes.Length; i++)
|
|
{
|
|
Type moduleType = moduleTypes[i];
|
|
const BindingFlags searchFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
|
|
foreach (var mtd in moduleType.GetMethods(searchFlags).Concat(moduleExtensionTypes[i].SelectMany(t => t.GetMethods(searchFlags))))
|
|
{
|
|
var attr = mtd.GetCustomAttribute<MethodTargetTranspilerAttribute>();
|
|
foreach (var hp in mtd.GetCustomAttributes<HarmonyPatch>())
|
|
{
|
|
//make sure the transpiler has a target method to apply, otherwise skip it
|
|
if (attr != null && hp != null && hp.info.declaringType != null)
|
|
{
|
|
var hm = hp.info;
|
|
hm.methodType = hm.methodType ?? MethodType.Normal;
|
|
var mtdinf_target = hm.GetOriginalMethod() as MethodInfo;
|
|
if (mtdinf_target == null || mtdinf_target.IsAbstract || !mtdinf_target.IsVirtual)
|
|
{
|
|
continue;
|
|
}
|
|
string id = hm.GetTargetMethodIdentifier();
|
|
if (!dict_transpilers.TryGetValue(id, out var list))
|
|
{
|
|
dict_transpilers[id] = (list = new List<TranspilerTarget>());
|
|
Type nextType = targetType;
|
|
TranspilerTarget curNode = null;
|
|
var hm_next = hm.Clone();
|
|
while (hm.declaringType.IsAssignableFrom(nextType))
|
|
{
|
|
hm_next.declaringType = nextType;
|
|
var mtdinfo_cur = hm_next.GetOriginalMethod() as MethodInfo;
|
|
if (mtdinfo_cur != null)
|
|
{
|
|
var patchinf_harmony = mtdinfo_cur.ToPatchInfoDontAdd().Copy();
|
|
curNode = new TranspilerTarget(mtdinfo_cur.DeclaringType, mtdinfo_cur, patchinf_harmony);
|
|
list.Add(curNode);
|
|
}
|
|
nextType = nextType.BaseType;
|
|
}
|
|
|
|
if (curNode != null)
|
|
{
|
|
curNode.patchinf_harmony.AddTranspilers(CommonUtilityLibInit.HarmonyInstance.Id, new HarmonyMethod(mtd));
|
|
Log.Out($"Adding transpiler {mtd.FullDescription()}\nCurrent transpilers:\n{string.Join('\n', curNode.patchinf_harmony.transpilers.Select(p => p.PatchMethod.FullDescription()))}");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool childFound = false;
|
|
foreach (var node in ((IEnumerable<TranspilerTarget>)list).Reverse())
|
|
{
|
|
if (node.type_action.Equals(hm.declaringType))
|
|
{
|
|
childFound = true;
|
|
node.patchinf_harmony.AddTranspilers(CommonUtilityLibInit.HarmonyInstance.Id, mtd);
|
|
Log.Out($"Adding transpiler {mtd.FullDescription()}\nCurrent transpilers:\n{string.Join('\n', node.patchinf_harmony.transpilers.Select(p => p.PatchMethod.FullDescription()))}");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!childFound)
|
|
{
|
|
Type nextType = list[list.Count - 1].type_action.BaseType;
|
|
TranspilerTarget curNode = null;
|
|
var hm_next = hm.Clone();
|
|
while (hm.declaringType.IsAssignableFrom(nextType))
|
|
{
|
|
hm_next.declaringType = nextType;
|
|
var mtdinfo_cur = hm_next.GetOriginalMethod() as MethodInfo;
|
|
if (mtdinfo_cur != null)
|
|
{
|
|
var patchinf_harmony = mtdinfo_cur.ToPatchInfoDontAdd().Copy();
|
|
curNode = new TranspilerTarget(mtdinfo_cur.DeclaringType, mtdinfo_cur, patchinf_harmony);
|
|
list.Add(curNode);
|
|
}
|
|
nextType = nextType.BaseType;
|
|
}
|
|
|
|
if (curNode != null)
|
|
{
|
|
curNode.patchinf_harmony.AddTranspilers(CommonUtilityLibInit.HarmonyInstance.Id, new HarmonyMethod(mtd));
|
|
Log.Out($"Adding transpiler {mtd.FullDescription()}\nCurrent transpilers:\n{string.Join('\n', curNode.patchinf_harmony.transpilers.Select(p => p.PatchMethod.FullDescription()))}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//apply transpilers and replace method calls on base methods with patched ones
|
|
Dictionary<string, MethodDefinition> dict_replacers = new Dictionary<string, MethodDefinition>();
|
|
foreach (var pair in dict_transpilers)
|
|
{
|
|
List<TranspilerTarget> list = pair.Value;
|
|
|
|
//the top copy to call in the override method
|
|
MethodDefinition mtddef_override_copy = null;
|
|
MethodReference mtdref_override_base = null;
|
|
for (int i = list.Count - 1; i >= 0; i--)
|
|
{
|
|
TranspilerTarget curNode = list[i];
|
|
MethodPatcher patcher = curNode.mtdinf_original.GetMethodPatcher();
|
|
DynamicMethodDefinition dmd = patcher.CopyOriginal();
|
|
ILContext context = new ILContext(dmd.Definition);
|
|
HarmonyManipulator.Manipulate(curNode.mtdinf_original, curNode.patchinf_harmony, context);
|
|
var mtdref_original = module.ImportReference(curNode.mtdinf_original);
|
|
var mtddef_copy = mtdref_original.Resolve().CloneToModuleAsStatic(context.Body, module.ImportReference(curNode.type_action), module);
|
|
dmd.Dispose();
|
|
context.Dispose();
|
|
if (mtddef_override_copy != null && mtdref_override_base != null)
|
|
{
|
|
//replace calls to the base
|
|
foreach (var ins in mtddef_copy.Body.Instructions)
|
|
{
|
|
if (ins.OpCode == OpCodes.Call && ((MethodReference)ins.Operand).FullName.Equals(mtdref_override_base.FullName))
|
|
{
|
|
Log.Out($"replacing call to {mtdref_override_base.FullName} to {mtddef_override_copy.FullName}");
|
|
ins.Operand = mtddef_override_copy;
|
|
}
|
|
}
|
|
}
|
|
//add patched copy to the class
|
|
typedef_newTarget.Methods.Add(mtddef_copy);
|
|
//the iteration is reversed so make sure we grab the latest method
|
|
mtddef_override_copy = mtddef_copy;
|
|
mtdref_override_base = mtdref_original;
|
|
}
|
|
//create the method override that calls the patched copy
|
|
if (mtddef_override_copy != null && mtdref_override_base != null)
|
|
{
|
|
GetOrCreateOverride(dict_overrides, pair.Key, mtdref_override_base, mtddef_override_copy);
|
|
}
|
|
}
|
|
|
|
//Apply Postfixes first so that Prefixes can jump to the right instruction
|
|
for (int i = 0; i < moduleTypes.Length; i++)
|
|
{
|
|
Type moduleType = moduleTypes[i];
|
|
Dictionary<string, MethodOverrideInfo> dict_targets = GetMethodOverrideTargets<MethodTargetPostfixAttribute>(i);
|
|
string moduleID = ModuleUtils.CreateFieldName(moduleType);
|
|
foreach (var pair in dict_targets)
|
|
{
|
|
MethodDefinition mtddef_root = module.ImportReference(pair.Value.mtdinf_base.GetBaseDefinition()).Resolve();
|
|
MethodDefinition mtddef_target = module.ImportReference(pair.Value.mtdinf_target).Resolve();
|
|
MethodPatchInfo mtdpinf_derived = GetOrCreateOverride(dict_overrides, pair.Key, pair.Value.mtdref_base);
|
|
MethodDefinition mtddef_derived = mtdpinf_derived.Method;
|
|
|
|
if (!dict_all_states.TryGetValue(pair.Key, out var dict_states))
|
|
{
|
|
dict_states = new Dictionary<string, VariableDefinition>();
|
|
dict_all_states.Add(pair.Key, dict_states);
|
|
}
|
|
var list_inst_pars = MatchArguments(mtddef_root, mtdpinf_derived, mtddef_target, i, true, dict_states, moduleID);
|
|
//insert invocation
|
|
var il = mtddef_derived.Body.GetILProcessor();
|
|
foreach (var ins in list_inst_pars)
|
|
{
|
|
il.InsertBefore(mtdpinf_derived.PostfixEnd, ins);
|
|
}
|
|
il.InsertBefore(mtdpinf_derived.PostfixEnd, il.Create(OpCodes.Call, module.ImportReference(mtddef_target)));
|
|
if (mtdpinf_derived.PostfixBegin == null)
|
|
mtdpinf_derived.PostfixBegin = list_inst_pars[0];
|
|
}
|
|
}
|
|
|
|
//Apply Prefixes
|
|
for (int i = moduleTypes.Length - 1; i >= 0; i--)
|
|
{
|
|
Type moduleType = moduleTypes[i];
|
|
Dictionary<string, MethodOverrideInfo> dict_targets = GetMethodOverrideTargets<MethodTargetPrefixAttribute>(i);
|
|
string moduleID = ModuleUtils.CreateFieldName(moduleType);
|
|
foreach (var pair in dict_targets)
|
|
{
|
|
MethodDefinition mtddef_root = module.ImportReference(pair.Value.mtdinf_base.GetBaseDefinition()).Resolve();
|
|
MethodDefinition mtddef_target = module.ImportReference(pair.Value.mtdinf_target).Resolve();
|
|
MethodPatchInfo mtdpinf_derived = GetOrCreateOverride(dict_overrides, pair.Key, pair.Value.mtdref_base);
|
|
MethodDefinition mtddef_derived = mtdpinf_derived.Method;
|
|
dict_all_states.TryGetValue(pair.Key, out var dict_states);
|
|
var list_inst_pars = MatchArguments(mtddef_root, mtdpinf_derived, mtddef_target, i, false, dict_states, moduleID);
|
|
//insert invocation
|
|
var il = mtdpinf_derived.Method.Body.GetILProcessor();
|
|
Instruction ins_insert = mtdpinf_derived.PrefixBegin;
|
|
foreach (var ins in list_inst_pars)
|
|
{
|
|
il.InsertBefore(ins_insert, ins);
|
|
}
|
|
il.InsertBefore(ins_insert, il.Create(OpCodes.Call, module.ImportReference(mtddef_target)));
|
|
il.InsertBefore(ins_insert, il.Create(OpCodes.Brfalse_S, mtdpinf_derived.PostfixBegin ?? mtdpinf_derived.PostfixEnd));
|
|
}
|
|
}
|
|
|
|
foreach (var pair in dict_all_states)
|
|
{
|
|
var dict_states = pair.Value;
|
|
if (dict_states.Count > 0)
|
|
{
|
|
Log.Error($"__state variable count does not match in prefixes and postfixes for {pair.Key}! check following modules:\n" + string.Join("\n", dict_states.Keys));
|
|
throw new Exception();
|
|
}
|
|
}
|
|
|
|
//Add all overrides to new type
|
|
foreach (var mtd in dict_overrides.Values)
|
|
{
|
|
typedef_newTarget.Methods.Add(mtd.Method);
|
|
|
|
//Log.Out($"Add method override to new action: {mtd.Method.Name}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="targetType"></param>
|
|
/// <param name="moduleType"></param>
|
|
/// <param name="module"></param>
|
|
/// <returns></returns>
|
|
private Dictionary<string, MethodOverrideInfo> GetMethodOverrideTargets<T>(int moduleIndex) where T : Attribute, IMethodTarget
|
|
{
|
|
Type moduleType = moduleTypes[moduleIndex];
|
|
Dictionary<string, MethodOverrideInfo> dict_overrides = new Dictionary<string, MethodOverrideInfo>();
|
|
const BindingFlags searchFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
|
|
const BindingFlags extensionFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
|
|
foreach (var mtd in moduleType.GetMethods(searchFlags).Concat(moduleExtensionTypes[moduleIndex].SelectMany(t => t.GetMethods(extensionFlags))))
|
|
{
|
|
if (mtd.GetCustomAttribute<T>() != null)
|
|
{
|
|
foreach (HarmonyPatch hp in mtd.GetCustomAttributes<HarmonyPatch>())
|
|
{
|
|
if (hp != null && (hp.info.declaringType == null || hp.info.declaringType.IsAssignableFrom(targetType)))
|
|
{
|
|
var hm = hp.info;
|
|
hm.methodType = hm.methodType ?? MethodType.Normal;
|
|
var hmclone = hm.Clone();
|
|
hmclone.declaringType = targetType;
|
|
string id = hm.GetTargetMethodIdentifier();
|
|
MethodInfo mtdinf_base = hmclone.GetBaseMethod() as MethodInfo;
|
|
if (mtdinf_base == null || !mtdinf_base.IsVirtual || mtdinf_base.IsFinal)
|
|
{
|
|
Log.Error($"Method not found: {moduleType.FullName} on {hmclone.methodName}\n{hmclone.ToString()}");
|
|
continue;
|
|
}
|
|
|
|
MethodReference mtdref_base = module.ImportReference(mtdinf_base);
|
|
//Find preferred patch
|
|
if (dict_overrides.TryGetValue(id, out var info))
|
|
{
|
|
if (hm.declaringType == null)
|
|
continue;
|
|
//cur action type is sub or same class of cur preferred type
|
|
//cur preferred type is sub class of previous preferred type
|
|
//means cur preferred type is closer to the action type in inheritance hierachy than the previous one
|
|
if (hm.declaringType.IsAssignableFrom(targetType) && (info.prefType == null || hm.declaringType.IsSubclassOf(info.prefType)))
|
|
{
|
|
dict_overrides[id] = new MethodOverrideInfo(mtd, mtdinf_base, mtdref_base, hm.declaringType);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dict_overrides[id] = new MethodOverrideInfo(mtd, mtdinf_base, mtdref_base, hm.declaringType);
|
|
}
|
|
//Log.Out($"Add method override: {id} for {mtdref_base.FullName}/{mtdinf_base.Name}, action type: {itemActionType.Name}");
|
|
}
|
|
else
|
|
{
|
|
//Log.Out($"No override target found or preferred type not match on {mtd.Name}");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return dict_overrides;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get or create override MethodDefinition of mtdref_base.
|
|
/// </summary>
|
|
/// <param name="dict_overrides"></param>
|
|
/// <param name="id"></param>
|
|
/// <param name="mtdref_base"></param>
|
|
/// <param name="module"></param>
|
|
/// <returns></returns>
|
|
private MethodPatchInfo GetOrCreateOverride(Dictionary<string, MethodPatchInfo> dict_overrides, string id, MethodReference mtdref_base, MethodDefinition mtddef_base_override = null)
|
|
{
|
|
//if (mtddef_base.FullName == "CreateModifierData")
|
|
// throw new MethodAccessException($"YOU SHOULD NOT MANUALLY MODIFY CreateModifierData!");
|
|
if (dict_overrides.TryGetValue(id, out var mtdpinf_derived))
|
|
{
|
|
return mtdpinf_derived;
|
|
}
|
|
//when overriding, retain attributes of base but make sure to remove the 'new' keyword which presents if you are overriding the root method
|
|
MethodDefinition mtddef_base = mtdref_base.Resolve();
|
|
MethodDefinition mtddef_derived = new MethodDefinition(mtddef_base.Name, (mtddef_base.Attributes | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.ReuseSlot) & ~MethodAttributes.NewSlot, module.ImportReference(mtddef_base.ReturnType));
|
|
|
|
//Log.Out($"Create method override: {id} for {mtdref_base.FullName}");
|
|
foreach (var par in mtddef_base_override?.Parameters?.Skip(1) ?? mtddef_base.Parameters)
|
|
{
|
|
ParameterDefinition pardef = new ParameterDefinition(par.Name, par.Attributes, module.ImportReference(par.ParameterType));
|
|
if (par.HasConstant)
|
|
pardef.Constant = par.Constant;
|
|
mtddef_derived.Parameters.Add(pardef);
|
|
}
|
|
mtddef_derived.Body.Variables.Clear();
|
|
mtddef_derived.Body.InitLocals = true;
|
|
mtddef_derived.Body.Variables.Add(new VariableDefinition(module.TypeSystem.Boolean));
|
|
bool hasReturnVal = mtddef_derived.ReturnType.MetadataType != MetadataType.Void;
|
|
if (hasReturnVal)
|
|
{
|
|
mtddef_derived.Body.Variables.Add(new VariableDefinition(module.ImportReference(mtddef_base.ReturnType)));
|
|
}
|
|
var il = mtddef_derived.Body.GetILProcessor();
|
|
if (hasReturnVal)
|
|
{
|
|
il.Emit(OpCodes.Ldloca_S, mtddef_derived.Body.Variables[1]);
|
|
il.Emit(OpCodes.Initobj, module.ImportReference(mtddef_derived.ReturnType));
|
|
}
|
|
il.Emit(OpCodes.Ldc_I4_0);
|
|
il.Emit(OpCodes.Stloc_S, mtddef_derived.Body.Variables[0]);
|
|
Instruction prefixBegin = il.Create(OpCodes.Ldc_I4_1);
|
|
il.Append(prefixBegin);
|
|
il.Emit(OpCodes.Stloc_S, mtddef_derived.Body.Variables[0]);
|
|
il.Emit(OpCodes.Ldarg_0);
|
|
for (int i = 0; i < mtddef_derived.Parameters.Count; i++)
|
|
{
|
|
var par = mtddef_derived.Parameters[i];
|
|
il.Emit(par.ParameterType.IsByReference ? OpCodes.Ldarga_S : OpCodes.Ldarg_S, par);
|
|
}
|
|
il.Emit(OpCodes.Call, mtddef_base_override ?? module.ImportReference(mtdref_base));
|
|
if (hasReturnVal)
|
|
{
|
|
il.Emit(OpCodes.Stloc_S, mtddef_derived.Body.Variables[1]);
|
|
il.Emit(OpCodes.Ldloc_S, mtddef_derived.Body.Variables[1]);
|
|
}
|
|
il.Emit(OpCodes.Ret);
|
|
mtdpinf_derived = new MethodPatchInfo(mtddef_derived, mtddef_derived.Body.Instructions[mtddef_derived.Body.Instructions.Count - (hasReturnVal ? 2 : 1)], prefixBegin);
|
|
dict_overrides.Add(id, mtdpinf_derived);
|
|
return mtdpinf_derived;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a List<Instruction> that loads all arguments required to call the method onto stack.
|
|
/// </summary>
|
|
/// <param name="mtddef_root">The root definition of this method.</param>
|
|
/// <param name="mtdpinf_derived">The override method.</param>
|
|
/// <param name="mtddef_target">The patch method to be called.</param>
|
|
/// <param name="flddef_module">The injected module field.</param>
|
|
/// <param name="flddef_data">The injected data field.</param>
|
|
/// <param name="module">The assembly's main module.</param>
|
|
/// <param name="itemActionType">The base ItemAction type.</param>
|
|
/// <returns></returns>
|
|
/// <exception cref="MissingFieldException"></exception>
|
|
/// <exception cref="ArgumentNullException"></exception>
|
|
/// <exception cref="ArgumentException"></exception>
|
|
private List<Instruction> MatchArguments(MethodDefinition mtddef_root, MethodPatchInfo mtdpinf_derived, MethodDefinition mtddef_target, int moduleIndex, bool isPostfix, Dictionary<string, VariableDefinition> dict_states, string moduleID)
|
|
{
|
|
FieldDefinition flddef_module = arr_flddef_modules[moduleIndex];
|
|
var mtddef_derived = mtdpinf_derived.Method;
|
|
var il = mtddef_derived.Body.GetILProcessor();
|
|
//Match parameters
|
|
List<Instruction> list_inst_pars = new List<Instruction>();
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldarg_0));
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldfld, flddef_module));
|
|
foreach (var par in mtddef_target.IsStatic ? mtddef_target.Parameters.Skip(1) : mtddef_target.Parameters)
|
|
{
|
|
if (par.Name.StartsWith("___"))
|
|
{
|
|
//___ means non public fields
|
|
string str_fldname = par.Name.Substring(3);
|
|
FieldDefinition flddef_target = module.ImportReference(targetType.GetField(str_fldname, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)).Resolve();
|
|
if (flddef_target == null)
|
|
throw new MissingFieldException($"Field with name \"{str_fldname}\" not found! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
if (flddef_target.IsStatic)
|
|
{
|
|
list_inst_pars.Add(il.Create((par.ParameterType.IsByReference) ? OpCodes.Ldsflda : OpCodes.Ldsfld, module.ImportReference(flddef_target)));
|
|
}
|
|
else
|
|
{
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldarg_0));
|
|
list_inst_pars.Add(il.Create(par.ParameterType.IsByReference ? OpCodes.Ldflda : OpCodes.Ldfld, module.ImportReference(flddef_target)));
|
|
}
|
|
}
|
|
else if (!MatchSpecialParameters(par, mtddef_target, mtdpinf_derived, moduleIndex, list_inst_pars, il, isPostfix, dict_states, moduleID))
|
|
{
|
|
//match param by name
|
|
int index = -1;
|
|
for (int j = 0; j < mtddef_root.Parameters.Count; j++)
|
|
{
|
|
if (mtddef_root.Parameters[j].Name == par.Name)
|
|
{
|
|
index = mtddef_root.Parameters[j].Index;
|
|
break;
|
|
}
|
|
}
|
|
if (index < 0)
|
|
throw new ArgumentException($"Parameter \"{par.Name}\" not found! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
try
|
|
{
|
|
//Log.Out($"Match Parameter {par.Name} to {mtddef_derived.Parameters[index].Name}/{mtddef_root.Parameters[index].Name} index: {index}");
|
|
|
|
}
|
|
catch (ArgumentOutOfRangeException e)
|
|
{
|
|
Log.Error($"index {index} parameter {par.Name}" +
|
|
$"root pars: {{{string.Join(",", mtddef_root.Parameters.Select(p => p.Name + "/" + p.Index).ToArray())}}}" +
|
|
$"derived pars: {{{string.Join(",", mtddef_derived.Parameters.Select(p => p.Name + "/" + p.Index).ToArray())}}}");
|
|
throw e;
|
|
}
|
|
if (!mtddef_derived.Parameters[index].ParameterType.IsByReference)
|
|
{
|
|
list_inst_pars.Add(il.Create(par.ParameterType.IsByReference ? OpCodes.Ldarga_S : OpCodes.Ldarg_S, mtddef_derived.Parameters[index]));
|
|
}
|
|
else
|
|
{
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldarg_S, mtddef_derived.Parameters[index]));
|
|
if (!par.ParameterType.IsByReference)
|
|
{
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldind_Ref));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return list_inst_pars;
|
|
}
|
|
|
|
private bool MatchSpecialParameters(ParameterDefinition par, MethodDefinition mtddef_target, MethodPatchInfo mtdpinf_derived, int moduleIndex, List<Instruction> list_inst_pars, ILProcessor il, bool isPostfix, Dictionary<string, VariableDefinition> dict_states, string moduleID)
|
|
{
|
|
MethodDefinition mtddef_derived = mtdpinf_derived.Method;
|
|
switch (par.Name)
|
|
{
|
|
//load ItemAction instance
|
|
case "__instance":
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldarg_0));
|
|
break;
|
|
//load return value
|
|
case "__result":
|
|
list_inst_pars.Add(il.Create(par.ParameterType.IsByReference ? OpCodes.Ldloca_S : OpCodes.Ldloc_S, mtddef_derived.Body.Variables[1]));
|
|
break;
|
|
//for postfix only, indicates whether original method is executed
|
|
case "__runOriginal":
|
|
if (par.ParameterType.IsByReference)
|
|
throw new ArgumentException($"__runOriginal is readonly! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldloc_S, mtddef_derived.Body.Variables[0]));
|
|
break;
|
|
case "__state":
|
|
if (dict_states == null)
|
|
{
|
|
throw new ArgumentNullException($"__state is found in prefix but no matching postfix exists! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
}
|
|
if (!isPostfix && !dict_states.TryGetValue(moduleID, out var vardef))
|
|
{
|
|
throw new KeyNotFoundException($"__state is found in prefix but not found in corresponding postfix! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
}
|
|
if (par.IsOut && isPostfix)
|
|
{
|
|
throw new ArgumentException($"__state is marked as out parameter in postfix! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
}
|
|
if (!par.IsOut && !isPostfix)
|
|
{
|
|
throw new ArgumentException($"__state is not marked as out in prefix! Patch method: {mtddef_target.DeclaringType.FullName}.{mtddef_target.Name}");
|
|
}
|
|
if (isPostfix)
|
|
{
|
|
vardef = new VariableDefinition(module.ImportReference(par.ParameterType));
|
|
mtddef_derived.Body.Variables.Add(vardef);
|
|
dict_states.Add(moduleID, vardef);
|
|
var ins = mtddef_derived.Body.Instructions[0];
|
|
il.InsertBefore(ins, il.Create(OpCodes.Ldloca_S, vardef));
|
|
il.InsertBefore(ins, il.Create(OpCodes.Initobj, module.ImportReference(par.ParameterType)));
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldloc_S, vardef));
|
|
}
|
|
else
|
|
{
|
|
vardef = dict_states[moduleID];
|
|
dict_states.Remove(moduleID);
|
|
list_inst_pars.Add(il.Create(OpCodes.Ldloca_S, vardef));
|
|
}
|
|
break;
|
|
default:
|
|
return processor != null ? processor.MatchSpecialArgs(par, mtddef_target, mtdpinf_derived, moduleIndex, list_inst_pars, il) : false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void MakeContainerFor(TypeDefinition typedef_container, Type type_module, out FieldDefinition flddef_module)
|
|
{
|
|
var typeref_module = module.ImportReference(type_module);
|
|
flddef_module = new FieldDefinition(ModuleUtils.CreateFieldName(type_module), FieldAttributes.Public, typeref_module);
|
|
typedef_container.Fields.Add(flddef_module);
|
|
typedef_container.Interfaces.Add(new InterfaceImplementation(typeref_interface.MakeGenericInstanceType(typeref_module)));
|
|
PropertyDefinition propdef_instance = new PropertyDefinition("Instance", Mono.Cecil.PropertyAttributes.None, typeref_module);
|
|
MethodDefinition mtddef_instance_getter = new MethodDefinition("get_Instance", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final, typeref_module);
|
|
mtddef_instance_getter.Overrides.Add(module.ImportReference(AccessTools.Method(typeof(IModuleContainerFor<>).MakeGenericType(type_module), "get_Instance")));
|
|
typedef_container.Methods.Add(mtddef_instance_getter);
|
|
mtddef_instance_getter.Body = new Mono.Cecil.Cil.MethodBody(mtddef_instance_getter);
|
|
var generator = mtddef_instance_getter.Body.GetILProcessor();
|
|
generator.Emit(OpCodes.Ldarg_0);
|
|
generator.Emit(OpCodes.Ldfld, flddef_module);
|
|
generator.Emit(OpCodes.Ret);
|
|
propdef_instance.GetMethod = mtddef_instance_getter;
|
|
typedef_container.Properties.Add(propdef_instance);
|
|
}
|
|
}
|
|
}
|