internal static List <CodeInstruction> GetInstructions(ILGenerator generator, MethodBase method, int maxTranspilers)
{
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
var originalVariables = MethodPatcher.DeclareLocalVariables(generator, method);
var useStructReturnBuffer = StructReturnBuffer.NeedsFix(method);
var copier = new MethodCopier(method, generator, originalVariables);
copier.SetArgumentShift(useStructReturnBuffer);
var info = Harmony.GetPatchInfo(method);
if (info != null)
{
var sortedTranspilers = PatchFunctions.GetSortedPatchMethods(method, info.Transpilers.ToArray(), false);
for (var i = 0; i < maxTranspilers && i < sortedTranspilers.Count; i++)
{
copier.AddTranspiler(sortedTranspilers[i]);
}
}
return(copier.Finalize(null, null, out var _));
}
internal static List <CodeInstruction> GetInstructions(ILGenerator generator, MethodBase method, int maxTranspilers)
{
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
var originalVariables = MethodPatcher.DeclareLocalVariables(generator, method);
var useStructReturnBuffer = StructReturnBuffer.NeedsFix(method);
var copier = new MethodCopier(method, generator, originalVariables);
copier.SetArgumentShift(useStructReturnBuffer);
var info = Harmony.GetPatchInfo(method);
if (info != null)
{
var sortedTranspilers = PatchFunctions.GetSortedPatchMethods(method, info.Transpilers.ToArray(), false);
for (var i = 0; i < maxTranspilers && i < sortedTranspilers.Count; i++)
{
copier.AddTranspiler(sortedTranspilers[i]);
}
}
var endLabels = new List <Label>();
var emitter = new Emitter(generator, false);
copier.Finalize(emitter, endLabels, out var hasReturnCode);
return(emitter.GetInstructions().OrderBy(pair => pair.Key).Select(pair => pair.Value).ToList());
}
internal MethodInfo CreateReplacement(out Dictionary <int, CodeInstruction> finalInstructions)
{
var originalVariables = DeclareLocalVariables(il, source ?? original);
var privateVars = new Dictionary <string, LocalBuilder>();
LocalBuilder resultVariable = null;
if (idx > 0)
{
resultVariable = DeclareLocalVariable(returnType, true);
privateVars[RESULT_VAR] = resultVariable;
}
Label? skipOriginalLabel = null;
LocalBuilder runOriginalVariable = null;
if (prefixes.Any(fix => PrefixAffectsOriginal(fix)))
{
runOriginalVariable = DeclareLocalVariable(typeof(bool));
emitter.Emit(OpCodes.Ldc_I4_1);
emitter.Emit(OpCodes.Stloc, runOriginalVariable);
skipOriginalLabel = il.DefineLabel();
}
prefixes.Union(postfixes).Union(finalizers).ToList().ForEach(fix =>
{
if (fix.DeclaringType is object && privateVars.ContainsKey(fix.DeclaringType.FullName) is false)
{
fix.GetParameters()
.Where(patchParam => patchParam.Name == STATE_VAR)
.Do(patchParam =>
{
var privateStateVariable = DeclareLocalVariable(patchParam.ParameterType);
privateVars[fix.DeclaringType.FullName] = privateStateVariable;
});
}
});
LocalBuilder finalizedVariable = null;
if (finalizers.Any())
{
finalizedVariable = DeclareLocalVariable(typeof(bool));
privateVars[EXCEPTION_VAR] = DeclareLocalVariable(typeof(Exception));
// begin try
emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginExceptionBlock), out _);
}
AddPrefixes(privateVars, runOriginalVariable);
if (skipOriginalLabel.HasValue)
{
emitter.Emit(OpCodes.Ldloc, runOriginalVariable);
emitter.Emit(OpCodes.Brfalse, skipOriginalLabel.Value);
}
var copier = new MethodCopier(source ?? original, il, originalVariables);
copier.SetArgumentShift(useStructReturnBuffer);
copier.SetDebugging(debug);
foreach (var transpiler in transpilers)
{
copier.AddTranspiler(transpiler);
}
var endLabels = new List <Label>();
_ = copier.Finalize(emitter, endLabels, out var hasReturnCode);
foreach (var label in endLabels)
{
emitter.MarkLabel(label);
}
if (resultVariable is object)
{
emitter.Emit(OpCodes.Stloc, resultVariable);
}
if (skipOriginalLabel.HasValue)
{
emitter.MarkLabel(skipOriginalLabel.Value);
}
_ = AddPostfixes(privateVars, false);
if (resultVariable is object)
{
emitter.Emit(OpCodes.Ldloc, resultVariable);
}
var needsToStorePassthroughResult = AddPostfixes(privateVars, true);
var hasFinalizers = finalizers.Any();
if (hasFinalizers)
{
if (needsToStorePassthroughResult)
{
emitter.Emit(OpCodes.Stloc, resultVariable);
emitter.Emit(OpCodes.Ldloc, resultVariable);
}
_ = AddFinalizers(privateVars, false);
emitter.Emit(OpCodes.Ldc_I4_1);
emitter.Emit(OpCodes.Stloc, finalizedVariable);
var noExceptionLabel1 = il.DefineLabel();
emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
emitter.Emit(OpCodes.Brfalse, noExceptionLabel1);
emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
emitter.Emit(OpCodes.Throw);
emitter.MarkLabel(noExceptionLabel1);
// end try, begin catch
emitter.MarkBlockBefore(new ExceptionBlock(ExceptionBlockType.BeginCatchBlock), out var label);
emitter.Emit(OpCodes.Stloc, privateVars[EXCEPTION_VAR]);
emitter.Emit(OpCodes.Ldloc, finalizedVariable);
var endFinalizerLabel = il.DefineLabel();
emitter.Emit(OpCodes.Brtrue, endFinalizerLabel);
var rethrowPossible = AddFinalizers(privateVars, true);
emitter.MarkLabel(endFinalizerLabel);
var noExceptionLabel2 = il.DefineLabel();
emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
emitter.Emit(OpCodes.Brfalse, noExceptionLabel2);
if (rethrowPossible)
{
emitter.Emit(OpCodes.Rethrow);
}
else
{
emitter.Emit(OpCodes.Ldloc, privateVars[EXCEPTION_VAR]);
emitter.Emit(OpCodes.Throw);
}
emitter.MarkLabel(noExceptionLabel2);
// end catch
emitter.MarkBlockAfter(new ExceptionBlock(ExceptionBlockType.EndExceptionBlock));
if (resultVariable is object)
{
emitter.Emit(OpCodes.Ldloc, resultVariable);
}
}
if (useStructReturnBuffer)
{
var tmpVar = DeclareLocalVariable(returnType);
emitter.Emit(OpCodes.Stloc, tmpVar);
emitter.Emit(original.IsStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);
emitter.Emit(OpCodes.Ldloc, tmpVar);
emitter.Emit(OpCodes.Stobj, returnType); // store result into ref
}
if (hasFinalizers || hasReturnCode)
{
emitter.Emit(OpCodes.Ret);
}
finalInstructions = emitter.GetInstructions();
if (debug)
{
FileLog.LogBuffered("DONE");
FileLog.LogBuffered("");
FileLog.FlushBuffer();
}
return(patch.Generate().Pin());
}