/// <summary>Gets the return type of a method or constructor</summary>
/// <param name="methodOrConstructor">The method or constructor</param>
/// <returns>The return type of the method</returns>
///
public static Type GetReturnedType(MethodBase methodOrConstructor)
{
if (methodOrConstructor == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.GetReturnedType: methodOrConstructor is null");
}
return(null);
}
var constructor = methodOrConstructor as ConstructorInfo;
if (constructor != null)
{
return(typeof(void));
}
return(((MethodInfo)methodOrConstructor).ReturnType);
}
/// <summary>Gets the reflection information for a field</summary>
/// <param name="type">The class where the field is declared</param>
/// <param name="idx">The zero-based index of the field inside the class definition</param>
/// <returns>A FieldInfo or null when type is null or when the field cannot be found</returns>
///
public static FieldInfo DeclaredField(Type type, int idx)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.DeclaredField: type is null");
}
return(null);
}
var field = GetDeclaredFields(type).ElementAtOrDefault(idx);
if (field == null && HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.DeclaredField: Could not find field for type " + type + " and idx " + idx);
}
return(field);
}
/// <summary>Gets default value for a specific type</summary>
/// <param name="type">The type</param>
/// <returns>The default value</returns>
///
public static object GetDefaultValue(Type type)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.GetDefaultValue: type is null");
}
return(null);
}
if (type == typeof(void))
{
return(null);
}
if (type.IsValueType)
{
return(Activator.CreateInstance(type));
}
return(null);
}
/// <summary>Given a type, returns the first property matching a predicate</summary>
/// <param name="type">The type to start searching at</param>
/// <param name="predicate">The predicate to search with</param>
/// <returns>The PropertyInfo or null if type/predicate is null or if a type with that name cannot be found</returns>
///
public static PropertyInfo FirstProperty(Type type, Func <PropertyInfo, bool> predicate)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstProperty: type is null");
}
return(null);
}
if (predicate == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstProperty: predicate is null");
}
return(null);
}
return(type.GetProperties(allDeclared).FirstOrDefault(property => predicate(property)));
}
/// <summary>Given a type, returns the first constructor matching a predicate</summary>
/// <param name="type">The type to start searching at</param>
/// <param name="predicate">The predicate to search with</param>
/// <returns>The ConstructorInfo or null if type/predicate is null or if a type with that name cannot be found</returns>
///
public static ConstructorInfo FirstConstructor(Type type, Func <ConstructorInfo, bool> predicate)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstConstructor: type is null");
}
return(null);
}
if (predicate == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstConstructor: predicate is null");
}
return(null);
}
return(type.GetConstructors(allDeclared).FirstOrDefault(constructor => predicate(constructor)));
}
/// <summary>Given a type, returns the first method matching a predicate</summary>
/// <param name="type">The type to start searching at</param>
/// <param name="predicate">The predicate to search with</param>
/// <returns>The MethodInfo or null if type/predicate is null or if a type with that name cannot be found</returns>
///
public static MethodInfo FirstMethod(Type type, Func <MethodInfo, bool> predicate)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstMethod: type is null");
}
return(null);
}
if (predicate == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstMethod: predicate is null");
}
return(null);
}
return(type.GetMethods(allDeclared).FirstOrDefault(method => predicate(method)));
}
/// <summary>Given a type, returns the first inner type matching a recursive search with a predicate</summary>
/// <param name="type">The type to start searching at</param>
/// <param name="predicate">The predicate to search with</param>
/// <returns>The inner type or null if type/predicate is null or if a type with that name cannot be found</returns>
///
public static Type FirstInner(Type type, Func <Type, bool> predicate)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstInner: type is null");
}
return(null);
}
if (predicate == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.FirstInner: predicate is null");
}
return(null);
}
return(type.GetNestedTypes(all).FirstOrDefault(subType => predicate(subType)));
}
/// <summary>Given a type, returns the first inner type matching a recursive search by name</summary>
/// <param name="type">The type to start searching at</param>
/// <param name="name">The name of the inner type (case sensitive)</param>
/// <returns>The inner type or null if type/name is null or if a type with that name cannot be found</returns>
///
public static Type Inner(Type type, string name)
{
if (type == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.Inner: type is null");
}
return(null);
}
if (name == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.Inner: name is null");
}
return(null);
}
return(FindIncludingBaseTypes(type, t => t.GetNestedType(name, all)));
}
/// <summary>Gets the reflection information for a method by searching the type and all its super types</summary>
/// <param name="typeColonMethodname">The full name (Namespace.Type1.Type2:MethodName) of the type where the method is declared</param>
/// <param name="parameters">Optional parameters to target a specific overload of the method</param>
/// <param name="generics">Optional list of types that define the generic version of the method</param>
/// <returns>A MethodInfo or null when type/name is null or when the method cannot be found</returns>
///
public static MethodInfo Method(string typeColonMethodname, Type[] parameters = null, Type[] generics = null)
{
if (typeColonMethodname == null)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.Method: typeColonMethodname is null");
}
return(null);
}
var parts = typeColonMethodname.Split(':');
if (parts.Length != 2)
{
throw new ArgumentException("Method must be specified as 'Namespace.Type1.Type2:MethodName", nameof(typeColonMethodname));
}
var type = TypeByName(parts[0]);
return(DeclaredMethod(type, parts[1], parameters, generics));
}
/// <summary>Gets a type by name. Prefers a full name with namespace but falls back to the first type matching the name otherwise</summary>
/// <param name="name">The name</param>
/// <returns>A Type</returns>
///
public static Type TypeByName(string name)
{
var type = Type.GetType(name, false);
if (type == null)
{
type = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(x => x.GetTypes())
.FirstOrDefault(x => x.FullName == name);
}
if (type == null)
{
type = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(x => x.GetTypes())
.FirstOrDefault(x => x.Name == name);
}
if (type == null && HarmonyInstance.DEBUG)
{
FileLog.Log("AccessTools.TypeByName: Could not find type named " + name);
}
return(type);
}
/// <summary>Creates patched method.</summary>
/// <exception cref="ArgumentNullException">Thrown when one or more required arguments are null.</exception>
/// <exception cref="Exception"> Thrown when an exception error condition occurs.</exception>
/// <param name="original"> The original method.</param>
/// <param name="harmonyInstanceID">Identifier for the harmony instance.</param>
/// <param name="prefixes"> The prefix methods.</param>
/// <param name="postfixes"> The postfix methods.</param>
/// <param name="transpilers"> The transpiler methods.</param>
/// <returns>A new dynamic method.</returns>
///
public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original), "Original method is null. Did you specify it correctly?");
}
try
{
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
// for debugging
AssemblyBuilder assemblyBuilder = null;
TypeBuilder typeBuilder = null;
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
il = DynamicTools.CreateSaveableMethod(original, "_Patch" + idx, out assemblyBuilder, out typeBuilder);
}
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
var copier = new MethodCopier(original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
var endBlocks = new List <ExceptionBlock>();
copier.Finalize(endLabels, endBlocks);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
foreach (var block in endBlocks)
{
Emitter.MarkBlockAfter(il, block);
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, skipOriginalLabel);
}
AddPostfixes(il, original, postfixes, privateVars, false);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
AddPostfixes(il, original, postfixes, privateVars, true);
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
// for debugging
if (DEBUG_METHOD_GENERATION_BY_DLL_CREATION)
{
DynamicTools.SaveMethod(assemblyBuilder, typeBuilder);
return(null);
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
catch (Exception ex)
{
var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription();
if (HarmonyInstance.DEBUG)
{
FileLog.Log("Exception: " + exceptionString);
}
throw new Exception(exceptionString, ex);
}
finally
{
if (HarmonyInstance.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <TranspilerImpl> transpilers, PatchFlags flags)
{
if (HarmonyInstance.DEBUG)
{
FileLog.Log("PATCHING " + original.DeclaringType + " " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var afterOriginal1 = il.DefineLabel();
var afterOriginal2 = il.DefineLabel();
bool canHaveJump = false;
if (flags.HasFlag(PatchFlags.PF_Detour) == false)
{
canHaveJump = AddPrefixes(il, original, prefixes, privateVars, afterOriginal2);
if (flags.HasFlag(PatchFlags.PF_NoOrigin) == false)
{
var copier = new MethodCopier(original, patch, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
copier.Emit(afterOriginal1);
Emitter.MarkLabel(il, afterOriginal1);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
}
}
if (canHaveJump)
{
Emitter.MarkLabel(il, afterOriginal2);
}
if (AddPostfixes(il, original, postfixes, privateVars))
{
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.Log("DONE");
FileLog.Log("");
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, string harmonyInstanceID, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <MethodInfo> transpilers)
{
Memory.MarkForNoInlining(original);
if (original == null)
{
throw new ArgumentNullException(nameof(original), "Original method is null. Did you specify it correctly?");
}
try
{
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("### Patch " + original.DeclaringType + ", " + original);
FileLog.FlushBuffer();
}
var idx = prefixes.Count() + postfixes.Count();
var firstArgIsReturnBuffer = NativeThisPointer.NeedsNativeThisPointerFix(original);
var returnType = AccessTools.GetReturnedType(original);
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
if (patch == null)
{
return(null);
}
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DynamicTools.DeclareLocalVariable(il, returnType);
privateVars[RESULT_VAR] = resultVariable;
}
prefixes.Union(postfixes).ToList().ForEach(fix =>
{
if (privateVars.ContainsKey(fix.DeclaringType.FullName) == false)
{
fix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[fix.DeclaringType.FullName] = privateStateVariable;
});
}
});
if (firstArgIsReturnBuffer)
{
Emitter.Emit(il, original.IsStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);
}
var skipOriginalLabel = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, skipOriginalLabel);
var copier = new MethodCopier(original, il, originalVariables);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
var endBlocks = new List <ExceptionBlock>();
copier.Finalize(endLabels, endBlocks);
foreach (var label in endLabels)
{
Emitter.MarkLabel(il, label);
}
foreach (var block in endBlocks)
{
Emitter.MarkBlockAfter(il, block);
}
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, skipOriginalLabel);
}
AddPostfixes(il, original, postfixes, privateVars, false);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
AddPostfixes(il, original, postfixes, privateVars, true);
if (firstArgIsReturnBuffer)
{
Emitter.Emit(il, OpCodes.Stobj, returnType);
}
Emitter.Emit(il, OpCodes.Ret);
if (HarmonyInstance.DEBUG)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
catch (Exception ex)
{
var exceptionString = "Exception from HarmonyInstance \"" + harmonyInstanceID + "\" patching " + original.FullDescription();
if (HarmonyInstance.DEBUG)
{
FileLog.Log("Exception: " + exceptionString);
}
throw new Exception(exceptionString, ex);
}
finally
{
if (HarmonyInstance.DEBUG)
{
FileLog.FlushBuffer();
}
}
}
public static DynamicMethod CreatePatchedMethod(MethodBase original, List <MethodInfo> prefixes, List <MethodInfo> postfixes, List <ICodeProcessor> processors)
{
if (MethodCopier.DEBUG_OPCODES)
{
FileLog.Log("PATCHING " + original.DeclaringType + " " + original);
}
var idx = prefixes.Count() + postfixes.Count();
var patch = DynamicTools.CreateDynamicMethod(original, "_Patch" + idx);
var il = patch.GetILGenerator();
var originalVariables = DynamicTools.DeclareLocalVariables(original, il);
var resultVariable = DynamicTools.DeclareLocalVariable(il, AccessTools.GetReturnedType(original));
var privateVars = new Dictionary <string, LocalBuilder>();
privateVars[RESULT_VAR] = resultVariable;
prefixes.ForEach(prefix =>
{
prefix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DynamicTools.DeclareLocalVariable(il, patchParam.ParameterType);
privateVars[prefix.DeclaringType.FullName] = privateStateVariable;
});
});
var afterOriginal1 = il.DefineLabel();
var afterOriginal2 = il.DefineLabel();
var canHaveJump = AddPrefixes(il, original, prefixes, privateVars, afterOriginal2);
var copier = new MethodCopier(original, patch, originalVariables);
foreach (var processor in processors)
{
copier.AddReplacement(processor);
}
copier.AddReplacement(new RetToBrAfterProcessor(afterOriginal1));
copier.Emit();
Emitter.MarkLabel(il, afterOriginal1);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Stloc, resultVariable);
}
if (canHaveJump)
{
Emitter.MarkLabel(il, afterOriginal2);
}
AddPostfixes(il, original, postfixes, privateVars);
if (resultVariable != null)
{
Emitter.Emit(il, OpCodes.Ldloc, resultVariable);
}
Emitter.Emit(il, OpCodes.Ret);
if (MethodCopier.DEBUG_OPCODES)
{
FileLog.Log("DONE");
FileLog.Log("");
}
DynamicTools.PrepareDynamicMethod(patch);
return(patch);
}
