void EmitCallParameter(MethodInfo patch, Dictionary <string, LocalBuilder> variables, bool allowFirsParamPassthrough, out LocalBuilder tmpObjectVar)
{
tmpObjectVar = null;
var isInstance = original.IsStatic is false;
var originalParameters = original.GetParameters();
var originalParameterNames = originalParameters.Select(p => p.Name).ToArray();
// check for passthrough using first parameter (which must have same type as return type)
var parameters = patch.GetParameters().ToList();
if (allowFirsParamPassthrough && patch.ReturnType != typeof(void) && parameters.Count > 0 && parameters[0].ParameterType == patch.ReturnType)
{
parameters.RemoveRange(0, 1);
}
foreach (var patchParam in parameters)
{
if (patchParam.Name == ORIGINAL_METHOD_PARAM)
{
if (EmitOriginalBaseMethod())
{
continue;
}
emitter.Emit(OpCodes.Ldnull);
continue;
}
if (patchParam.Name == INSTANCE_PARAM)
{
if (original.IsStatic)
{
emitter.Emit(OpCodes.Ldnull);
}
else
{
var instanceIsRef = original.DeclaringType is object && AccessTools.IsStruct(original.DeclaringType);
var parameterIsRef = patchParam.ParameterType.IsByRef;
if (instanceIsRef == parameterIsRef)
{
emitter.Emit(OpCodes.Ldarg_0);
}
if (instanceIsRef && parameterIsRef is false)
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(OpCodes.Ldobj, original.DeclaringType);
}
if (instanceIsRef is false && parameterIsRef)
{
emitter.Emit(OpCodes.Ldarga, 0);
}
}
continue;
}
if (patchParam.Name.StartsWith(INSTANCE_FIELD_PREFIX, StringComparison.Ordinal))
{
var fieldName = patchParam.Name.Substring(INSTANCE_FIELD_PREFIX.Length);
FieldInfo fieldInfo;
if (fieldName.All(char.IsDigit))
{
// field access by index only works for declared fields
fieldInfo = AccessTools.DeclaredField(original.DeclaringType, int.Parse(fieldName));
if (fieldInfo is null)
{
throw new ArgumentException($"No field found at given index in class {original.DeclaringType.FullName}", fieldName);
}
}
else
{
fieldInfo = AccessTools.Field(original.DeclaringType, fieldName);
if (fieldInfo is null)
{
throw new ArgumentException($"No such field defined in class {original.DeclaringType.FullName}", fieldName);
}
}
if (fieldInfo.IsStatic)
{
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld, fieldInfo);
}
else
{
emitter.Emit(OpCodes.Ldarg_0);
emitter.Emit(patchParam.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld, fieldInfo);
}
continue;
}
// state is special too since each patch has its own local var
if (patchParam.Name == STATE_VAR)
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
if (variables.TryGetValue(patch.DeclaringType.FullName, out var stateVar))
{
emitter.Emit(ldlocCode, stateVar);
}
else
{
emitter.Emit(OpCodes.Ldnull);
}
continue;
}
// treat __result var special
if (patchParam.Name == RESULT_VAR)
{
var returnType = AccessTools.GetReturnedType(original);
if (returnType == typeof(void))
{
throw new Exception($"Cannot get result from void method {original.FullDescription()}");
}
var resultType = patchParam.ParameterType;
if (resultType.IsByRef && returnType.IsByRef == false)
{
resultType = resultType.GetElementType();
}
if (resultType.IsAssignableFrom(returnType) is false)
{
throw new Exception($"Cannot assign method return type {returnType.FullName} to {RESULT_VAR} type {resultType.FullName} for method {original.FullDescription()}");
}
var ldlocCode = patchParam.ParameterType.IsByRef && returnType.IsByRef == false ? OpCodes.Ldloca : OpCodes.Ldloc;
if (returnType.IsValueType && patchParam.ParameterType == typeof(object).MakeByRefType())
{
ldlocCode = OpCodes.Ldloc;
}
emitter.Emit(ldlocCode, variables[RESULT_VAR]);
if (returnType.IsValueType)
{
if (patchParam.ParameterType == typeof(object))
{
emitter.Emit(OpCodes.Box, returnType);
}
else if (patchParam.ParameterType == typeof(object).MakeByRefType())
{
emitter.Emit(OpCodes.Box, returnType);
tmpObjectVar = il.DeclareLocal(typeof(object));
emitter.Emit(OpCodes.Stloc, tmpObjectVar);
emitter.Emit(OpCodes.Ldloca, tmpObjectVar);
}
}
continue;
}
// any other declared variables
if (variables.TryGetValue(patchParam.Name, out var localBuilder))
{
var ldlocCode = patchParam.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc;
emitter.Emit(ldlocCode, localBuilder);
continue;
}
int idx;
if (patchParam.Name.StartsWith(PARAM_INDEX_PREFIX, StringComparison.Ordinal))
{
var val = patchParam.Name.Substring(PARAM_INDEX_PREFIX.Length);
if (!int.TryParse(val, out idx))
{
throw new Exception($"Parameter {patchParam.Name} does not contain a valid index");
}
if (idx < 0 || idx >= originalParameters.Length)
{
throw new Exception($"No parameter found at index {idx}");
}
}
else
{
idx = patch.GetArgumentIndex(originalParameterNames, patchParam);
if (idx == -1)
{
var harmonyMethod = HarmonyMethodExtensions.GetMergedFromType(patchParam.ParameterType);
if (harmonyMethod.methodType is null) // MethodType default is Normal
{
harmonyMethod.methodType = MethodType.Normal;
}
var delegateOriginal = harmonyMethod.GetOriginalMethod();
if (delegateOriginal is MethodInfo methodInfo)
{
var delegateConstructor = patchParam.ParameterType.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
if (delegateConstructor is object)
{
var originalType = original.DeclaringType;
if (methodInfo.IsStatic)
{
emitter.Emit(OpCodes.Ldnull);
}
else
{
emitter.Emit(OpCodes.Ldarg_0);
if (originalType.IsValueType)
{
emitter.Emit(OpCodes.Ldobj, originalType);
emitter.Emit(OpCodes.Box, originalType);
}
}
if (methodInfo.IsStatic is false && harmonyMethod.nonVirtualDelegate is false)
{
emitter.Emit(OpCodes.Dup);
emitter.Emit(OpCodes.Ldvirtftn, methodInfo);
}
else
{
emitter.Emit(OpCodes.Ldftn, methodInfo);
}
emitter.Emit(OpCodes.Newobj, delegateConstructor);
continue;
}
}
throw new Exception($"Parameter \"{patchParam.Name}\" not found in method {original.FullDescription()}");
}
}
// original -> patch opcode
// --------------------------------------
// 1 normal -> normal : LDARG
// 2 normal -> ref/out : LDARGA
// 3 ref/out -> normal : LDARG, LDIND_x
// 4 ref/out -> ref/out : LDARG
//
var originalIsNormal = originalParameters[idx].IsOut is false && originalParameters[idx].ParameterType.IsByRef is false;
var patchIsNormal = patchParam.IsOut is false && patchParam.ParameterType.IsByRef is false;
var patchArgIndex = idx + (isInstance ? 1 : 0) + (useStructReturnBuffer ? 1 : 0);
// Case 1 + 4
if (originalIsNormal == patchIsNormal)
{
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
continue;
}
// Case 2
if (originalIsNormal && patchIsNormal is false)
{
emitter.Emit(OpCodes.Ldarga, patchArgIndex);
continue;
}
// Case 3
emitter.Emit(OpCodes.Ldarg, patchArgIndex);
emitter.Emit(LoadIndOpCodeFor(originalParameters[idx].ParameterType));
}
