using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using ILUtils.HarmonyXtensions;
using Microsoft.CodeAnalysis;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyCompany("DBJ")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("BepInEx Transpiler Tools")]
[assembly: AssemblyFileVersion("1.0.5.0")]
[assembly: AssemblyInformationalVersion("1.0.5+b9c52bafc41047e18d94bbefe22084e94b3c02dd")]
[assembly: AssemblyProduct("ILUtils")]
[assembly: AssemblyTitle("com.github.decibillyjoel.ILUtils")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/DecibillyJoel/ILUtils")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.5.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
internal static class LCMProjectInfo
{
public const string PROJECT_GUID = "com.github.decibillyjoel.ILUtils";
public const string PROJECT_NAME = "ILUtils";
public const string PROJECT_VERSION = "1.0.5";
}
namespace ILUtils2.Plugin
{
[BepInPlugin("com.github.decibillyjoel.ILUtils", "ILUtils", "1.0.5")]
public class Plugin : BaseUnityPlugin
{
public static readonly string PLUGIN_GUID = "com.github.decibillyjoel.ILUtils";
public static readonly string PLUGIN_NAME = "ILUtils";
public static readonly string PLUGIN_VERSION = "1.0.5";
public static Plugin Instance { get; private set; } = null;
public static void Log(LogLevel level, object data)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
((BaseUnityPlugin)Instance).Logger.Log(level, data);
}
public static void LogFatal(object data)
{
((BaseUnityPlugin)Instance).Logger.LogFatal(data);
}
public static void LogError(object data)
{
((BaseUnityPlugin)Instance).Logger.LogError(data);
}
public static void LogWarning(object data)
{
((BaseUnityPlugin)Instance).Logger.LogWarning(data);
}
public static void LogMessage(object data)
{
((BaseUnityPlugin)Instance).Logger.LogMessage(data);
}
public static void LogInfo(object data)
{
((BaseUnityPlugin)Instance).Logger.LogInfo(data);
}
public static void LogDebug(object data)
{
((BaseUnityPlugin)Instance).Logger.LogDebug(data);
}
private void Awake()
{
Instance = this;
LogInfo("Plugin " + PLUGIN_NAME + " is loaded!");
}
}
}
namespace ILUtils
{
public static class ILPatterns
{
public static int? StackSizeDelta(StackBehaviour stackBehaviour)
{
switch (stackBehaviour)
{
case StackBehaviour.Pop0:
return 0;
case StackBehaviour.Pop1:
return -1;
case StackBehaviour.Pop1_pop1:
return -2;
case StackBehaviour.Popi:
return -1;
case StackBehaviour.Popi_pop1:
return -2;
case StackBehaviour.Popi_popi:
return -2;
case StackBehaviour.Popi_popi8:
return -2;
case StackBehaviour.Popi_popi_popi:
return -3;
case StackBehaviour.Popi_popr4:
return -2;
case StackBehaviour.Popi_popr8:
return -2;
case StackBehaviour.Popref:
return -1;
case StackBehaviour.Popref_pop1:
return -2;
case StackBehaviour.Popref_popi:
return -2;
case StackBehaviour.Popref_popi_popi:
return -3;
case StackBehaviour.Popref_popi_popi8:
return -3;
case StackBehaviour.Popref_popi_popr4:
return -3;
case StackBehaviour.Popref_popi_popr8:
return -3;
case StackBehaviour.Popref_popi_popref:
return -3;
case StackBehaviour.Push0:
return 0;
case StackBehaviour.Push1:
return 1;
case StackBehaviour.Push1_push1:
return 2;
case StackBehaviour.Pushi:
return 1;
case StackBehaviour.Pushi8:
return 1;
case StackBehaviour.Pushr4:
return 1;
case StackBehaviour.Pushr8:
return 1;
case StackBehaviour.Pushref:
return 1;
case StackBehaviour.Popref_popi_pop1:
return -3;
case StackBehaviour.Varpop:
case StackBehaviour.Varpush:
return null;
default:
throw new ArgumentOutOfRangeException(string.Format("[{0}.{1}.{2}] [{3}] is an invalid value", "ILUtils", "ILPatterns", "StackSizeDelta", stackBehaviour));
}
}
public static int? StackSizeDelta(OpCode opCode, object operand)
{
if (opCode == OpCodes.Calli)
{
return null;
}
if (opCode.FlowControl == FlowControl.Call)
{
MethodInfo methodInfo = operand as MethodInfo;
if (methodInfo == null)
{
return null;
}
int num = -methodInfo.GetParameters().Count();
if (opCode != OpCodes.Newobj && methodInfo.CallingConvention.HasFlag(CallingConventions.HasThis) && !methodInfo.CallingConvention.HasFlag(CallingConventions.ExplicitThis))
{
num--;
}
if (opCode == OpCodes.Newobj || methodInfo.ReturnType != typeof(void))
{
num++;
}
return num;
}
int? num2 = StackSizeDelta(opCode.StackBehaviourPush);
int? num3 = StackSizeDelta(opCode.StackBehaviourPop);
if (!num2.HasValue || !num3.HasValue)
{
return null;
}
return num2 + num3;
}
public static int? StackSizeDelta(CodeInstruction code)
{
return StackSizeDelta(code.opcode, code.operand);
}
public static bool EmptiesStack(OpCode opcode)
{
FlowControl flowControl = opcode.FlowControl;
if (flowControl == FlowControl.Branch || (uint)(flowControl - 7) <= 1u)
{
return true;
}
return false;
}
public static bool EmptiesStack(CodeInstruction code)
{
return EmptiesStack(code.opcode);
}
public static Func<CodeInstruction, int, bool> NextEmptyStack(int startSize = 0)
{
return delegate(CodeInstruction code, int index)
{
if (EmptiesStack(code))
{
return true;
}
int num = StackSizeDelta(code) ?? throw new ArgumentException(string.Format("[{0}.{1}.{2}] Encountered uncountable instruction [{3}] {4}", "ILUtils", "ILPatterns", "NextEmptyStack", index, code));
return (startSize += num) == 0;
};
}
}
public class ILStepper
{
public readonly List<CodeInstruction> Instructions;
public int CurrentIndex;
public readonly ILGenerator Generator;
public readonly Dictionary<int, LocalVariableInfo> Locals;
public readonly Dictionary<int, Label> Labels;
public CodeInstruction CurrentInstruction => Instructions[CurrentIndex];
public OpCode CurrentOpCode => CurrentInstruction.opcode;
public object? CurrentOperand => CurrentInstruction.operand;
public ILStepper(IEnumerable<CodeInstruction> codes, ILGenerator generator, MethodBase original, int index = 0)
{
Instructions = codes.ToList();
CurrentIndex = index;
Generator = generator;
Locals = (from code in Instructions
select code.operand as LocalVariableInfo into local
where local != null
select local).Distinct().ToDictionary((LocalVariableInfo local) => local.LocalIndex, (LocalVariableInfo local) => local);
Labels = Instructions.SelectMany((CodeInstruction code) => code.labels).Distinct().ToDictionary((Label label) => label.GetHashCode(), (Label label) => label);
CollectionExtensions.DoIf<LocalVariableInfo>((IEnumerable<LocalVariableInfo>)original.GetMethodBody().LocalVariables, (Func<LocalVariableInfo, bool>)((LocalVariableInfo local) => !Locals.ContainsKey(local.LocalIndex)), (Action<LocalVariableInfo>)delegate(LocalVariableInfo local)
{
Locals.Add(local.LocalIndex, local);
});
Instructions.ForEach(delegate(CodeInstruction code)
{
TrySetLocal(code, code);
});
}
public Label DeclareLabel()
{
Label label = Generator.DefineLabel();
Labels.Add(label.GetHashCode(), label);
return label;
}
public LocalVariableInfo DeclareLocal(Type type, bool pinned = false)
{
LocalVariableInfo localVariableInfo = Generator.DeclareLocal(type, pinned);
Locals.Add(localVariableInfo.LocalIndex, localVariableInfo);
return localVariableInfo;
}
public LocalVariableInfo? TryGetLocal(int localIndex)
{
if (!Locals.TryGetValue(localIndex, out LocalVariableInfo value))
{
return null;
}
return value;
}
public LocalVariableInfo? TryGetLocal(CodeInstruction codeWithLocal)
{
if (!CodeInstructionExtensions.IsLdloc(codeWithLocal, (LocalBuilder)null) && !CodeInstructionExtensions.IsStloc(codeWithLocal, (LocalBuilder)null))
{
return null;
}
return TryGetLocal(codeWithLocal.LocalIndex());
}
public LocalVariableInfo GetLocal(int localIndex, string errorMessage = "No such local variable!")
{
return TryGetLocal(localIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}] | {4}", "ILUtils", "ILStepper", "GetLocal", localIndex, errorMessage));
}
public LocalVariableInfo GetLocal(CodeInstruction codeWithLocal, string errorMessage = "No such local variable!")
{
return TryGetLocal(codeWithLocal) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}] | {4}", "ILUtils", "ILStepper", "GetLocal", codeWithLocal, errorMessage));
}
public LocalVariableInfo? TrySetLocal(CodeInstruction code, LocalVariableInfo local)
{
CodeInstruction val;
if (CodeInstructionExtensions.IsLdloc(code, (LocalBuilder)null))
{
val = CodeInstructionPolyfills.LoadLocal(local, code.opcode == OpCodes.Ldloca || code.opcode == OpCodes.Ldloca_S);
}
else
{
if (!CodeInstructionExtensions.IsStloc(code, (LocalBuilder)null))
{
return null;
}
val = CodeInstructionPolyfills.StoreLocal(local);
}
code.opcode = val.opcode;
code.operand = val.operand;
return local;
}
public LocalVariableInfo? TrySetLocal(CodeInstruction code, int localIndex)
{
LocalVariableInfo localVariableInfo = TryGetLocal(localIndex);
if (localVariableInfo == null)
{
return null;
}
return TrySetLocal(code, localVariableInfo);
}
public LocalVariableInfo? TrySetLocal(CodeInstruction code, CodeInstruction codeWithLocal)
{
LocalVariableInfo localVariableInfo = TryGetLocal(codeWithLocal);
if (localVariableInfo == null)
{
return null;
}
return TrySetLocal(code, localVariableInfo);
}
public LocalVariableInfo SetLocal(CodeInstruction code, LocalVariableInfo local, string errorMessage = "Could not set local!")
{
return TrySetLocal(code, local) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "SetLocal", code, local, errorMessage));
}
public LocalVariableInfo SetLocal(CodeInstruction code, int localIndex, string errorMessage = "Could not set local!")
{
return TrySetLocal(code, localIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "SetLocal", code, localIndex, errorMessage));
}
public LocalVariableInfo SetLocal(CodeInstruction code, CodeInstruction codeWithLocal, string errorMessage = "Could not set local!")
{
return TrySetLocal(code, codeWithLocal) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "SetLocal", code, codeWithLocal, errorMessage));
}
public int? TryFindIL(Func<CodeInstruction, int, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false)
{
index = (index ?? CurrentIndex) + offset + (reverse ? (-1) : 0);
while (index >= 0 && index < Instructions.Count)
{
if (searchCondition(Instructions[index.Value], index.Value))
{
return index;
}
index += ((!reverse) ? 1 : (-1));
}
return null;
}
public int? TryFindIL(Func<CodeInstruction, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false)
{
Func<CodeInstruction, bool> searchCondition2 = searchCondition;
return TryFindIL((CodeInstruction code, int index) => searchCondition2(code), index, offset, reverse);
}
public int FindIL(Func<CodeInstruction, int, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false, string errorMessage = "Not found!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryFindIL(searchCondition, index, offset, reverse) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "FindIL", searchCondition, index, reverse, reverse ? "reverse" : "forward", errorMessage));
}
public int FindIL(Func<CodeInstruction, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false, string errorMessage = "Not found!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryFindIL(searchCondition, index, offset, reverse) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "FindIL", searchCondition, index, reverse, reverse ? "reverse" : "forward", errorMessage));
}
public int? TryGotoIL(Func<CodeInstruction, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false)
{
index = TryFindIL(searchCondition, index, offset, reverse);
CurrentIndex = index ?? CurrentIndex;
return index;
}
public int? TryGotoIL(Func<CodeInstruction, int, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false)
{
index = TryFindIL(searchCondition, index, offset, reverse);
CurrentIndex = index ?? CurrentIndex;
return index;
}
public int GotoIL(Func<CodeInstruction, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false, string errorMessage = "Not found!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return CurrentIndex = TryFindIL(searchCondition, index, offset, reverse) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "GotoIL", searchCondition, index, reverse, reverse ? "reverse" : "forward", errorMessage));
}
public int GotoIL(Func<CodeInstruction, int, bool> searchCondition, int? index = null, int offset = 0, bool reverse = false, string errorMessage = "Not found!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return CurrentIndex = TryFindIL(searchCondition, index, offset, reverse) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "GotoIL", searchCondition, index, reverse, reverse ? "reverse" : "forward", errorMessage));
}
public int? TryFindIndex(int? index = null, int offset = 0, int leftBoundOffset = 0, int rightBoundOffset = 1)
{
index = (index ?? CurrentIndex) + offset;
if (index < leftBoundOffset || index > Instructions.Count - 1 + rightBoundOffset)
{
return null;
}
return index;
}
public int FindIndex(int? index = null, int offset = 0, int leftBoundOffset = 0, int rightBoundOffset = 1, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryFindIndex(index, offset, leftBoundOffset, rightBoundOffset) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3} ({4} + {5}), {6} (0 + {7}), {8} ({9} + {10})] | {11}", "ILUtils", "ILStepper", "FindIndex", index + offset, index, offset, leftBoundOffset, leftBoundOffset, Instructions.Count - 1 + rightBoundOffset, Instructions.Count - 1, rightBoundOffset, errorMessage));
}
public int? TryGotoIndex(int? index = null, int offset = 0, int leftBoundOffset = 0, int rightBoundOffset = 1)
{
index = TryFindIndex(index, offset, leftBoundOffset, rightBoundOffset);
CurrentIndex = index ?? CurrentIndex;
return index;
}
public int GotoIndex(int? index = null, int offset = 0, int leftBoundOffset = 0, int rightBoundOffset = 1, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return CurrentIndex = TryFindIndex(index, offset, leftBoundOffset, rightBoundOffset) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3} ({4} + {5}), {6} (0 + {7}), {8} ({9} + {10})] | {11}", "ILUtils", "ILStepper", "GotoIndex", index + offset, index, offset, leftBoundOffset, leftBoundOffset, Instructions.Count - 1 + rightBoundOffset, Instructions.Count - 1, rightBoundOffset, errorMessage));
}
public List<CodeInstruction>? TryInsertIL(List<CodeInstruction> codeRange, int? index = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true)
{
index = TryFindIndex(index);
if (!index.HasValue)
{
return null;
}
codeRange = ((IEnumerable<CodeInstruction>)codeRange).Select((Func<CodeInstruction, CodeInstruction>)((CodeInstruction code) => new CodeInstruction(code))).ToList();
if (index < Instructions.Count && codeRange.Count > 0)
{
if (pinLabels)
{
CodeInstructionExtensions.MoveLabelsTo(Instructions[index.Value], codeRange[0]);
}
if (pinBlocks)
{
CodeInstructionExtensions.MoveBlocksTo(Instructions[index.Value], codeRange[0]);
}
}
Instructions.InsertRange(index.Value, codeRange);
if (shiftCurrentIndex && CurrentIndex >= index)
{
CurrentIndex += codeRange.Count;
}
return codeRange;
}
public List<CodeInstruction>? TryInsertIL(CodeInstruction? code, int? index = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true)
{
return TryInsertIL((code != null) ? new List<CodeInstruction>(1) { code } : new List<CodeInstruction>(), index, shiftCurrentIndex, pinLabels, pinBlocks);
}
public List<CodeInstruction> InsertIL(List<CodeInstruction> codeRange, int? index = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryInsertIL(codeRange, index, shiftCurrentIndex, pinLabels, pinBlocks) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "InsertIL", codeRange, index, shiftCurrentIndex, shiftCurrentIndex ? "shift current index" : "dont shift current index", errorMessage));
}
public List<CodeInstruction> InsertIL(CodeInstruction? code, int? index = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryInsertIL((code != null) ? new List<CodeInstruction>(1) { code } : new List<CodeInstruction>(), index, shiftCurrentIndex, pinLabels, pinBlocks) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "InsertIL", code, index, shiftCurrentIndex, shiftCurrentIndex ? "shift current index" : "dont shift current index", errorMessage));
}
public List<CodeInstruction>? TryRemoveIL(int? startIndex = null, int? endIndex = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true)
{
startIndex = TryFindIndex(startIndex);
endIndex = TryFindIndex(endIndex);
if (!startIndex.HasValue || !endIndex.HasValue)
{
return null;
}
if (startIndex > endIndex)
{
int? num = endIndex;
endIndex = startIndex;
startIndex = num;
}
if (endIndex >= Instructions.Count)
{
return null;
}
int num2 = endIndex.Value - startIndex.Value;
List<CodeInstruction> range = Instructions.GetRange(startIndex.Value, num2);
Instructions.RemoveRange(startIndex.Value, num2);
if (startIndex < Instructions.Count)
{
range.ForEach(delegate(CodeInstruction code)
{
if (pinLabels)
{
CodeInstructionExtensions.MoveLabelsFrom(Instructions[startIndex.Value], code);
}
if (pinBlocks)
{
CodeInstructionExtensions.MoveBlocksFrom(Instructions[startIndex.Value], code);
}
});
}
if (shiftCurrentIndex && CurrentIndex > startIndex)
{
CurrentIndex = Math.Max(startIndex.Value, CurrentIndex - num2);
}
return range;
}
public List<CodeInstruction> RemoveIL(int? startIndex = null, int? endIndex = null, bool shiftCurrentIndex = true, bool pinLabels = true, bool pinBlocks = true, string errorMessage = "Out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryRemoveIL(startIndex, endIndex, shiftCurrentIndex, pinLabels, pinBlocks) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6})] | {7}", "ILUtils", "ILStepper", "RemoveIL", startIndex, endIndex, shiftCurrentIndex, shiftCurrentIndex ? "shift current index" : "dont shift current index", errorMessage));
}
public List<CodeInstruction>? TryGetIL(int? startIndex = null, int? endIndex = null)
{
startIndex = TryFindIndex(startIndex);
endIndex = TryFindIndex(endIndex);
if (!startIndex.HasValue || !endIndex.HasValue)
{
return null;
}
if (startIndex > endIndex)
{
int? num = endIndex;
endIndex = startIndex;
startIndex = num;
}
if (endIndex >= Instructions.Count)
{
return null;
}
int count = endIndex.Value - startIndex.Value;
return Instructions.GetRange(startIndex.Value, count);
}
public List<CodeInstruction> GetIL(int? startIndex = null, int? endIndex = null, string errorMessage = "Out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryGetIL(startIndex, endIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "GetIL", startIndex, endIndex, errorMessage));
}
public List<Label>? TryMoveAllLabels(List<CodeInstruction> sourceCodeRange, List<CodeInstruction> destinationCodeRange)
{
List<CodeInstruction> destinationCodeRange2 = destinationCodeRange;
if (sourceCodeRange.Count != destinationCodeRange2.Count)
{
return null;
}
return sourceCodeRange.SelectMany(delegate(CodeInstruction sourceCode, int sourceCodeIndex)
{
List<Label> list = CodeInstructionExtensions.ExtractLabels(sourceCode);
destinationCodeRange2[sourceCodeIndex].labels.AddRange(list);
return list;
}).ToList();
}
public List<Label>? TryMoveAllLabels(List<CodeInstruction> sourceCodeRange, CodeInstruction destinationCode)
{
return TryMoveAllLabels(sourceCodeRange, Enumerable.Repeat<CodeInstruction>(destinationCode, sourceCodeRange.Count).ToList());
}
public List<Label> MoveAllLabels(List<CodeInstruction> sourceCodeRange, List<CodeInstruction> destinationCodeRange, string errorMessage = "Source and destination instruction count don't match!")
{
return TryMoveAllLabels(sourceCodeRange, destinationCodeRange) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "MoveAllLabels", sourceCodeRange, destinationCodeRange, errorMessage));
}
public List<Label> MoveAllLabels(List<CodeInstruction> sourceCodeRange, CodeInstruction destinationCode, string errorMessage = "Source and destination instruction count don't match!")
{
return TryMoveAllLabels(sourceCodeRange, Enumerable.Repeat<CodeInstruction>(destinationCode, sourceCodeRange.Count).ToList()) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {{{4}, ...}}] | {5}", "ILUtils", "ILStepper", "MoveAllLabels", sourceCodeRange, destinationCode, errorMessage));
}
public List<Label>? TryShiftAllLabels(int? startIndex = null, int? endIndex = null, int shiftBy = 1)
{
List<CodeInstruction> list = TryGetIL(startIndex, endIndex);
if (list == null)
{
return null;
}
int? startIndex2 = TryFindIndex(startIndex, shiftBy);
int? endIndex2 = TryFindIndex(endIndex, shiftBy);
if (!startIndex2.HasValue || !endIndex2.HasValue)
{
return null;
}
List<CodeInstruction> list2 = TryGetIL(startIndex2, endIndex2);
if (list2 == null)
{
return null;
}
return TryMoveAllLabels(list, list2);
}
public List<Label> ShiftAllLabels(int? startIndex = null, int? endIndex = null, int shiftBy = 1, string errorMessage = "Source and/or destination instructions out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryShiftAllLabels(startIndex, endIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7}), {8} ({9} + {10})] | {11}", "ILUtils", "ILStepper", "ShiftAllLabels", startIndex, endIndex, startIndex + shiftBy, startIndex, shiftBy, endIndex + shiftBy, endIndex, shiftBy, errorMessage));
}
public List<ExceptionBlock>? TryMoveAllBlocks(List<CodeInstruction> sourceCodeRange, List<CodeInstruction> destinationCodeRange)
{
List<CodeInstruction> destinationCodeRange2 = destinationCodeRange;
if (sourceCodeRange.Count != destinationCodeRange2.Count)
{
return null;
}
return sourceCodeRange.SelectMany(delegate(CodeInstruction sourceCode, int sourceCodeIndex)
{
List<ExceptionBlock> list = CodeInstructionExtensions.ExtractBlocks(sourceCode);
destinationCodeRange2[sourceCodeIndex].blocks.AddRange(list);
return list;
}).ToList();
}
public List<ExceptionBlock>? TryMoveAllBlocks(List<CodeInstruction> sourceCodeRange, CodeInstruction destinationCode)
{
return TryMoveAllBlocks(sourceCodeRange, Enumerable.Repeat<CodeInstruction>(destinationCode, sourceCodeRange.Count).ToList());
}
public List<ExceptionBlock> MoveAllBlocks(List<CodeInstruction> sourceCodeRange, List<CodeInstruction> destinationCodeRange, string errorMessage = "Source and destination instruction count don't match!")
{
return TryMoveAllBlocks(sourceCodeRange, destinationCodeRange) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "MoveAllBlocks", sourceCodeRange, destinationCodeRange, errorMessage));
}
public List<ExceptionBlock> MoveAllBlocks(List<CodeInstruction> sourceCodeRange, CodeInstruction destinationCode, string errorMessage = "Source and destination instruction count don't match!")
{
return TryMoveAllBlocks(sourceCodeRange, Enumerable.Repeat<CodeInstruction>(destinationCode, sourceCodeRange.Count).ToList()) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {{{4}, ...}}] | {5}", "ILUtils", "ILStepper", "MoveAllBlocks", sourceCodeRange, destinationCode, errorMessage));
}
public List<ExceptionBlock>? TryShiftAllBlocks(int? startIndex = null, int? endIndex = null, int shiftBy = 1)
{
List<CodeInstruction> list = TryGetIL(startIndex, endIndex);
if (list == null)
{
return null;
}
int? startIndex2 = TryFindIndex(startIndex, shiftBy);
int? endIndex2 = TryFindIndex(endIndex, shiftBy);
if (!startIndex2.HasValue || !endIndex2.HasValue)
{
return null;
}
List<CodeInstruction> list2 = TryGetIL(startIndex2, endIndex2);
if (list2 == null)
{
return null;
}
return TryMoveAllBlocks(list, list2);
}
public List<ExceptionBlock> ShiftAllBlocks(int? startIndex = null, int? endIndex = null, int shiftBy = 1, string errorMessage = "Source and/or destination instructions out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryShiftAllBlocks(startIndex, endIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7}), {8} ({9} + {10})] | {11}", "ILUtils", "ILStepper", "ShiftAllBlocks", startIndex, endIndex, startIndex + shiftBy, startIndex, shiftBy, endIndex + shiftBy, endIndex, shiftBy, errorMessage));
}
public List<Label> ExtractAllLabels(List<CodeInstruction> codeRange)
{
return codeRange.SelectMany((CodeInstruction code) => CodeInstructionExtensions.ExtractLabels(code)).ToList();
}
public List<Label>? TryExtractAllLabels(int? startIndex = null, int? endIndex = null)
{
List<CodeInstruction> list = TryGetIL(startIndex, endIndex);
if (list == null)
{
return null;
}
return ExtractAllLabels(list);
}
public List<Label> ExtractAllLabels(int? startIndex = null, int? endIndex = null, string errorMessage = "Out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
return TryExtractAllLabels(startIndex, endIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "ExtractAllLabels", startIndex, endIndex, errorMessage));
}
public List<Label> ExtractAllBlocks(List<CodeInstruction> codeRange)
{
return codeRange.SelectMany((CodeInstruction code) => CodeInstructionExtensions.ExtractLabels(code)).ToList();
}
public List<Label>? TryExtractAllBlocks(int? startIndex = null, int? endIndex = null)
{
List<CodeInstruction> list = TryGetIL(startIndex, endIndex);
if (list == null)
{
return null;
}
return ExtractAllBlocks(list);
}
public List<Label> ExtractAllBlocks(int? startIndex = null, int? endIndex = null, string errorMessage = "Out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryExtractAllBlocks(startIndex, endIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}] | {5}", "ILUtils", "ILStepper", "ExtractAllBlocks", startIndex, endIndex, errorMessage));
}
public List<CodeInstruction>? TryShiftIL(int? startIndex = null, int? endIndex = null, int shiftBy = 1, bool shiftCurrentIndex = true)
{
startIndex = TryFindIndex(startIndex);
endIndex = TryFindIndex(endIndex);
if (!startIndex.HasValue || !endIndex.HasValue)
{
return null;
}
if (startIndex > endIndex)
{
int? num = endIndex;
endIndex = startIndex;
startIndex = num;
}
if (endIndex >= Instructions.Count)
{
return null;
}
int num2 = endIndex.Value - startIndex.Value;
int? index = TryFindIndex(startIndex, shiftBy, 0, -num2 + 1);
if (!index.HasValue)
{
return null;
}
if (shiftCurrentIndex && CurrentIndex >= startIndex && CurrentIndex < endIndex)
{
CurrentIndex += shiftBy;
shiftCurrentIndex = false;
}
string errorMessage = string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7}), {8} ({9} + {10})] Somehow calculated invalid parameters. This should never happen!", "ILUtils", "ILStepper", "TryShiftIL", startIndex, endIndex, startIndex + shiftBy, startIndex, shiftBy, endIndex + shiftBy, endIndex, shiftBy);
List<CodeInstruction> codeRange = RemoveIL(startIndex, endIndex, shiftCurrentIndex, pinLabels: false, pinBlocks: false, errorMessage);
return InsertIL(codeRange, index, shiftCurrentIndex, pinLabels: false, pinBlocks: false, errorMessage);
}
public List<CodeInstruction> ShiftIL(int? startIndex = null, int? endIndex = null, int shiftBy = 1, bool shiftCurrentIndex = true, string errorMessage = "Source and/or destination instructions out of bounds!")
{
int valueOrDefault = startIndex.GetValueOrDefault();
if (!startIndex.HasValue)
{
valueOrDefault = CurrentIndex;
startIndex = valueOrDefault;
}
valueOrDefault = endIndex.GetValueOrDefault();
if (!endIndex.HasValue)
{
valueOrDefault = CurrentIndex;
endIndex = valueOrDefault;
}
return TryShiftIL(startIndex, endIndex, shiftBy, shiftCurrentIndex) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7}), {8} ({9} + {10})] | {11}", "ILUtils", "ILStepper", "ShiftIL", startIndex, endIndex, startIndex + shiftBy, startIndex, shiftBy, endIndex + shiftBy, endIndex, shiftBy, errorMessage));
}
public List<CodeInstruction>? TryOverwriteIL(List<CodeInstruction> codeRange, int? index = null, bool pinLabels = true, bool pinBlocks = true)
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
List<CodeInstruction> removedIL = TryRemoveIL(index, index + codeRange.Count(), shiftCurrentIndex: false, pinLabels: false, pinBlocks: false);
if (removedIL == null)
{
return null;
}
codeRange = codeRange.Select(delegate(CodeInstruction code, int i)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
code = new CodeInstruction(code);
if (pinLabels)
{
CodeInstructionExtensions.MoveLabelsTo(removedIL[i], code);
}
if (pinBlocks)
{
CodeInstructionExtensions.MoveBlocksTo(removedIL[i], code);
}
return code;
}).ToList();
return TryInsertIL(codeRange, index, shiftCurrentIndex: false, pinLabels: false, pinBlocks: false);
}
public List<CodeInstruction>? TryOverwriteIL(CodeInstruction? code, int? index = null, bool pinLabels = true, bool pinBlocks = true)
{
return TryOverwriteIL((code != null) ? new List<CodeInstruction>(1) { code } : new List<CodeInstruction>(), index, pinLabels, pinBlocks);
}
public List<CodeInstruction> OverwriteIL(List<CodeInstruction> codeRange, int? index = null, bool pinLabels = true, bool pinBlocks = true, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryOverwriteIL(codeRange, index, pinLabels, pinBlocks) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7})] | {8}", "ILUtils", "ILStepper", "OverwriteIL", codeRange, index, index + codeRange.Count(), index, codeRange.Count(), errorMessage));
}
public List<CodeInstruction> OverwriteIL(CodeInstruction? code, int? index = null, bool pinLabels = true, bool pinBlocks = true, string errorMessage = "Out of bounds!")
{
int valueOrDefault = index.GetValueOrDefault();
if (!index.HasValue)
{
valueOrDefault = CurrentIndex;
index = valueOrDefault;
}
return TryOverwriteIL((code != null) ? new List<CodeInstruction>(1) { code } : new List<CodeInstruction>(), index, pinLabels, pinBlocks) ?? throw new Exception(string.Format("[{0}.{1}.{2}] [{3}, {4}, {5} ({6} + {7})] | {8}", "ILUtils", "ILStepper", "OverwriteIL", code, index, index + ((code != null) ? 1 : 0), index, (code != null) ? 1 : 0, errorMessage));
}
}
}
namespace ILUtils.HarmonyXtensions
{
public static class CodeInstructionPolyfills
{
public static readonly OpCode[] ARGUMENTED_LOCAL_INSTRUCTS = new OpCode[6]
{
OpCodes.Ldloc,
OpCodes.Stloc,
OpCodes.Ldloca,
OpCodes.Ldloc_S,
OpCodes.Stloc_S,
OpCodes.Ldloca_S
};
public static readonly OpCode[] LOAD_FIELD_INSTRUCTS = new OpCode[4]
{
OpCodes.Ldfld,
OpCodes.Ldsfld,
OpCodes.Ldflda,
OpCodes.Ldsflda
};
public static readonly OpCode[] STORE_FIELD_INSTRUCTS = new OpCode[2]
{
OpCodes.Stfld,
OpCodes.Stsfld
};
public static bool IsValid(this OpCode code)
{
return code.Size > 0;
}
public static CodeInstruction Call(Type type, string name, Type[]? parameters = null, Type[]? generics = null)
{
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(type, name, parameters, generics) ?? throw new ArgumentException($"No method found for type={type}, name={name}, parameters={GeneralExtensions.Description(parameters)}, generics={GeneralExtensions.Description(generics)}");
return new CodeInstruction(OpCodes.Call, (object)methodInfo);
}
public static bool Calls(this CodeInstruction codeInstruction, Type type, string name, Type[]? parameters = null, Type[]? generics = null)
{
MethodInfo methodInfo = AccessTools.Method(type, name, parameters, generics) ?? throw new ArgumentException($"No method found for type={type}, name={name}, parameters={GeneralExtensions.Description(parameters)}, generics={GeneralExtensions.Description(generics)}");
return CodeInstructionExtensions.Calls(codeInstruction, methodInfo);
}
public static CodeInstruction Call(string typeColonMethodname, Type[]? parameters = null, Type[]? generics = null)
{
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.Method(typeColonMethodname, parameters, generics) ?? throw new ArgumentException("No method found for " + typeColonMethodname + ", parameters=" + GeneralExtensions.Description(parameters) + ", generics=" + GeneralExtensions.Description(generics));
return new CodeInstruction(OpCodes.Call, (object)methodInfo);
}
public static bool Calls(this CodeInstruction codeInstruction, string typeColonMethodname, Type[]? parameters = null, Type[]? generics = null)
{
MethodInfo methodInfo = AccessTools.Method(typeColonMethodname, parameters, generics) ?? throw new ArgumentException("No method found for " + typeColonMethodname + ", parameters=" + GeneralExtensions.Description(parameters) + ", generics=" + GeneralExtensions.Description(generics));
return CodeInstructionExtensions.Calls(codeInstruction, methodInfo);
}
public static CodeInstruction Call(Expression<Action> expression)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo(expression));
}
public static CodeInstruction Call<T>(Expression<Action<T>> expression)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo<T>(expression));
}
public static CodeInstruction Call<T, TResult>(Expression<Func<T, TResult>> expression)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo<T, TResult>(expression));
}
public static CodeInstruction Call(LambdaExpression expression)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)SymbolExtensions.GetMethodInfo(expression));
}
public static CodeInstruction CallClosure<T>(T closure) where T : Delegate
{
return Transpilers.EmitDelegate<T>(closure);
}
public static CodeInstruction CallConstructor(Type type, Type[]? parameters = null, bool searchForStatic = false)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
ConstructorInfo constructorInfo = AccessTools.Constructor(type, parameters, searchForStatic) ?? throw new ArgumentException($"No constructor found for type={type}, parameters={GeneralExtensions.Description(parameters)}, searchForStatic={searchForStatic}");
return new CodeInstruction(OpCodes.Newobj, (object)constructorInfo);
}
public static CodeInstruction LoadField(Type type, string name, bool useAddress = false)
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
FieldInfo fieldInfo = AccessTools.Field(type, name) ?? throw new ArgumentException($"No field found for {type} and {name}");
return new CodeInstruction((!useAddress) ? (fieldInfo.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld) : (fieldInfo.IsStatic ? OpCodes.Ldsflda : OpCodes.Ldflda), (object)fieldInfo);
}
public static CodeInstruction StoreField(Type type, string name)
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
FieldInfo fieldInfo = AccessTools.Field(type, name) ?? throw new ArgumentException($"No field found for {type} and {name}");
return new CodeInstruction(fieldInfo.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld, (object)fieldInfo);
}
public static bool LoadsField(this CodeInstruction codeInstruction, Type type, string name, bool byAddress = false)
{
FieldInfo fieldInfo = AccessTools.DeclaredField(type, name);
if (fieldInfo != null)
{
return CodeInstructionExtensions.LoadsField(codeInstruction, fieldInfo, byAddress);
}
return false;
}
public static bool StoresField(this CodeInstruction codeInstruction, Type type, string name)
{
FieldInfo fieldInfo = AccessTools.DeclaredField(type, name);
if (fieldInfo != null)
{
return CodeInstructionExtensions.StoresField(codeInstruction, fieldInfo);
}
return false;
}
public static int LocalIndex(this CodeInstruction code)
{
if (code.opcode == OpCodes.Ldloc_0 || code.opcode == OpCodes.Stloc_0)
{
return 0;
}
if (code.opcode == OpCodes.Ldloc_1 || code.opcode == OpCodes.Stloc_1)
{
return 1;
}
if (code.opcode == OpCodes.Ldloc_2 || code.opcode == OpCodes.Stloc_2)
{
return 2;
}
if (code.opcode == OpCodes.Ldloc_3 || code.opcode == OpCodes.Stloc_3)
{
return 3;
}
if (ARGUMENTED_LOCAL_INSTRUCTS.Contains(code.opcode))
{
int? num = (code.operand as LocalVariableInfo)?.LocalIndex;
return Convert.ToInt32(num.HasValue ? ((object)num.GetValueOrDefault()) : code.operand);
}
throw new ArgumentException("Instruction is not a load or store", "code");
}
public static CodeInstruction LoadLocal(int index, bool useAddress = false)
{
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Expected O, but got Unknown
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Expected O, but got Unknown
if (useAddress)
{
if (index < 256)
{
return new CodeInstruction(OpCodes.Ldloca_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldloca, (object)index);
}
if (index < 256)
{
return (CodeInstruction)(index switch
{
0 => (object)new CodeInstruction(OpCodes.Ldloc_0, (object)null),
1 => (object)new CodeInstruction(OpCodes.Ldloc_1, (object)null),
2 => (object)new CodeInstruction(OpCodes.Ldloc_2, (object)null),
3 => (object)new CodeInstruction(OpCodes.Ldloc_3, (object)null),
_ => (object)new CodeInstruction(OpCodes.Ldloc_S, (object)Convert.ToByte(index)),
});
}
return new CodeInstruction(OpCodes.Ldloc, (object)index);
}
public static CodeInstruction LoadLocal(LocalVariableInfo local, bool useAddress = false)
{
return LoadLocal(local.LocalIndex, useAddress);
}
public static CodeInstruction StoreLocal(int index)
{
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Expected O, but got Unknown
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Expected O, but got Unknown
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Expected O, but got Unknown
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Expected O, but got Unknown
//IL_0068: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Expected O, but got Unknown
if (index < 256)
{
return (CodeInstruction)(index switch
{
0 => (object)new CodeInstruction(OpCodes.Stloc_0, (object)null),
1 => (object)new CodeInstruction(OpCodes.Stloc_1, (object)null),
2 => (object)new CodeInstruction(OpCodes.Stloc_2, (object)null),
3 => (object)new CodeInstruction(OpCodes.Stloc_3, (object)null),
_ => (object)new CodeInstruction(OpCodes.Stloc_S, (object)Convert.ToByte(index)),
});
}
return new CodeInstruction(OpCodes.Stloc, (object)index);
}
public static CodeInstruction StoreLocal(LocalVariableInfo local)
{
return StoreLocal(local.LocalIndex);
}
public static bool LoadsLocal(this CodeInstruction code, LocalVariableInfo? local = null)
{
if (CodeInstructionExtensions.IsLdloc(code, (LocalBuilder)null))
{
if (local != null)
{
return code.LocalIndex() == local.LocalIndex;
}
return true;
}
return false;
}
public static bool LoadsLocal(this CodeInstruction code, int index)
{
if (CodeInstructionExtensions.IsLdloc(code, (LocalBuilder)null))
{
return code.LocalIndex() == index;
}
return false;
}
public static bool StoresLocal(this CodeInstruction code, LocalVariableInfo? local = null)
{
if (CodeInstructionExtensions.IsStloc(code, (LocalBuilder)null))
{
if (local != null)
{
return code.LocalIndex() == local.LocalIndex;
}
return true;
}
return false;
}
public static bool StoresLocal(this CodeInstruction code, int index)
{
if (CodeInstructionExtensions.IsStloc(code, (LocalBuilder)null))
{
return code.LocalIndex() == index;
}
return false;
}
public static CodeInstruction LoadArgument(int index, bool useAddress = false)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Expected O, but got Unknown
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Expected O, but got Unknown
if (useAddress)
{
if (index >= 256)
{
return new CodeInstruction(OpCodes.Ldarga, (object)index);
}
return new CodeInstruction(OpCodes.Ldarga_S, (object)Convert.ToByte(index));
}
if (index != 0)
{
if (index != 1)
{
if (index != 2)
{
if (index != 3)
{
if (index >= 256)
{
return new CodeInstruction(OpCodes.Ldarg, (object)index);
}
return new CodeInstruction(OpCodes.Ldarg_S, (object)Convert.ToByte(index));
}
return new CodeInstruction(OpCodes.Ldarg_3, (object)null);
}
return new CodeInstruction(OpCodes.Ldarg_2, (object)null);
}
return new CodeInstruction(OpCodes.Ldarg_1, (object)null);
}
return new CodeInstruction(OpCodes.Ldarg_0, (object)null);
}
public static int ArgumentIndex(this CodeInstruction code)
{
if (code.opcode == OpCodes.Ldarg_0)
{
return 0;
}
if (code.opcode == OpCodes.Ldarg_1)
{
return 1;
}
if (code.opcode == OpCodes.Ldarg_2)
{
return 2;
}
if (code.opcode == OpCodes.Ldarg_3)
{
return 3;
}
if (code.opcode == OpCodes.Ldarg_S || code.opcode == OpCodes.Ldarg)
{
return Convert.ToInt32(code.operand);
}
if (code.opcode == OpCodes.Starg_S || code.opcode == OpCodes.Starg)
{
return Convert.ToInt32(code.operand);
}
if (code.opcode == OpCodes.Ldarga_S || code.opcode == OpCodes.Ldarga)
{
return Convert.ToInt32(code.operand);
}
throw new ArgumentException("Instruction is not a load or store", "code");
}
public static CodeInstruction StoreArgument(int index)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
if (index >= 256)
{
return new CodeInstruction(OpCodes.Starg, (object)index);
}
return new CodeInstruction(OpCodes.Starg_S, (object)Convert.ToByte(index));
}
public static bool LoadsString(this CodeInstruction code, string str)
{
if (code.opcode != OpCodes.Ldstr)
{
return false;
}
string text = Convert.ToString(code.operand);
return text == str;
}
public static CodeInstruction LoadConstant(sbyte number)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Expected O, but got Unknown
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Expected O, but got Unknown
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c5: Expected O, but got Unknown
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
return (CodeInstruction)(number switch
{
-1 => (object)new CodeInstruction(OpCodes.Ldc_I4_M1, (object)null),
0 => (object)new CodeInstruction(OpCodes.Ldc_I4_0, (object)null),
1 => (object)new CodeInstruction(OpCodes.Ldc_I4_1, (object)null),
2 => (object)new CodeInstruction(OpCodes.Ldc_I4_2, (object)null),
3 => (object)new CodeInstruction(OpCodes.Ldc_I4_3, (object)null),
4 => (object)new CodeInstruction(OpCodes.Ldc_I4_4, (object)null),
5 => (object)new CodeInstruction(OpCodes.Ldc_I4_5, (object)null),
6 => (object)new CodeInstruction(OpCodes.Ldc_I4_6, (object)null),
7 => (object)new CodeInstruction(OpCodes.Ldc_I4_7, (object)null),
8 => (object)new CodeInstruction(OpCodes.Ldc_I4_8, (object)null),
_ => (object)new CodeInstruction(OpCodes.Ldc_I4_S, (object)number),
});
}
public static CodeInstruction LoadConstant(int number)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Expected O, but got Unknown
if (number >= -128 && number <= 127)
{
return LoadConstant(Convert.ToSByte(number));
}
return new CodeInstruction(OpCodes.Ldc_I4, (object)number);
}
public static CodeInstruction LoadConstant(long number)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Ldc_I8, (object)number);
}
public static CodeInstruction LoadConstant(Enum e)
{
return (CodeInstruction)(e.GetTypeCode() switch
{
TypeCode.Int64 => LoadConstant(Convert.ToInt64(e)),
TypeCode.SByte => LoadConstant(Convert.ToSByte(e)),
_ => LoadConstant(Convert.ToInt32(e)),
});
}
public static CodeInstruction[] LoadLongOptimally(long number)
{
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Expected O, but got Unknown
//IL_003e: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
if (number >= -128)
{
if (number <= 127)
{
return (CodeInstruction[])(object)new CodeInstruction[2]
{
LoadConstant(Convert.ToSByte(number)),
new CodeInstruction(OpCodes.Conv_I8, (object)null)
};
}
if (number <= int.MaxValue)
{
goto IL_0047;
}
}
else if (number >= int.MinValue)
{
goto IL_0047;
}
return (CodeInstruction[])(object)new CodeInstruction[1]
{
new CodeInstruction(OpCodes.Ldc_I8, (object)number)
};
IL_0047:
return (CodeInstruction[])(object)new CodeInstruction[2]
{
LoadConstant(Convert.ToInt32(number)),
new CodeInstruction(OpCodes.Conv_I8, (object)null)
};
}
public static CodeInstruction[] LoadEnumOptimally(Enum e)
{
return e.GetTypeCode() switch
{
TypeCode.Int64 => LoadLongOptimally(Convert.ToInt64(e)),
TypeCode.SByte => (CodeInstruction[])(object)new CodeInstruction[1] { LoadConstant(Convert.ToSByte(e)) },
_ => (CodeInstruction[])(object)new CodeInstruction[1] { LoadConstant(Convert.ToInt32(e)) },
};
}
public static CodeInstruction LoadString(string str)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Ldstr, (object)str);
}
public static CodeInstruction LoadNull()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Ldnull, (object)null);
}
public static bool LoadsNull(this CodeInstruction code)
{
return object.Equals(code.opcode, OpCodes.Ldnull);
}
public static bool LoadsProperty(this CodeInstruction code, PropertyInfo property)
{
return CodeInstructionExtensions.Calls(code, property.GetGetMethod(nonPublic: true));
}
public static bool LoadsProperty(this CodeInstruction code, Type type, string name)
{
PropertyInfo propertyInfo = AccessTools.DeclaredProperty(type, name);
if (propertyInfo != null)
{
return code.LoadsProperty(propertyInfo);
}
return false;
}
public static bool StoresProperty(this CodeInstruction code, PropertyInfo property)
{
return CodeInstructionExtensions.Calls(code, property.GetSetMethod(nonPublic: true));
}
public static bool StoresProperty(this CodeInstruction code, Type type, string name)
{
PropertyInfo propertyInfo = AccessTools.DeclaredProperty(type, name);
if (propertyInfo != null)
{
return code.StoresProperty(propertyInfo);
}
return false;
}
public static CodeInstruction LoadProperty(PropertyInfo property)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)property.GetGetMethod(nonPublic: true));
}
public static CodeInstruction LoadProperty(Type type, string name)
{
PropertyInfo property = AccessTools.Property(type, name) ?? throw new ArgumentException($"No property found for type={type}, name={name}");
return LoadProperty(property);
}
public static CodeInstruction StoreProperty(PropertyInfo property)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
return new CodeInstruction(OpCodes.Call, (object)property.GetSetMethod(nonPublic: true));
}
public static CodeInstruction StoreProperty(Type type, string name)
{
PropertyInfo property = AccessTools.Property(type, name) ?? throw new ArgumentException($"No property found for type={type}, name={name}");
return StoreProperty(property);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
