List <IMethod> GetMethods(TypeDef declaringType, BabelMethodreference babelMethodRef)
{
var methods = new List <IMethod>();
var gis = babelMethodRef.DeclaringType as GenericInstSig;
var gim = babelMethodRef.GenericArguments;
foreach (var method in declaringType.Methods)
{
if (CompareMethod(GenericArgsSubstitutor.Create(method, gis, gim), babelMethodRef))
{
if (!babelMethodRef.IsGenericMethod)
{
methods.Add(memberRefConverter.Convert(method));
}
else
{
var gim2 = new GenericInstMethodSig(babelMethodRef.GenericArguments);
var ms = module.UpdateRowId(new MethodSpecUser(memberRefConverter.Convert(method), gim2));
methods.Add(ms);
}
}
}
return(methods);
}
GenericInstMethodSig ResolveGenericArgs(GenericInstMethodSig sig)
{
var gsig = new GenericInstMethodSig();
UpdateSigList(gsig.GenericArguments, sig.GenericArguments);
return(gsig);
}
private void RemapGenericInstMethodSig(GenericInstMethodSig genericInstMethodSig)
{
for (var i = 0; i < genericInstMethodSig.GenericArguments.Count; i++)
{
genericInstMethodSig.GenericArguments[i] = RemapReference(genericInstMethodSig.GenericArguments[i]);
}
}
void Add(GenericInstMethodSig sig)
{
if (sig is null)
{
return;
}
Add(sig.GenericArguments);
}
void add(GenericInstMethodSig sig)
{
if (sig == null)
{
return;
}
add(sig.GenericArguments);
}
public static GenericInstMethodSig create(GenericInstMethodSig sig, IList <TypeSig> genericArgs)
{
if (sig == null || genericArgs == null || genericArgs.Count == 0)
{
return(sig);
}
return(new GenericArgsSubstitutor(genericArgs).create(sig));
}
public static GenericInstMethodSig create(GenericInstMethodSig sig, GenericInstSig git)
{
if (git == null)
{
return(sig);
}
return(create(sig, git.GenericArguments));
}
void Add(GenericInstMethodSig gsig)
{
if (gsig == null)
{
return;
}
Add(gsig.ExtraData);
Add(gsig.GenericArguments);
}
void Write(BinaryWriter writer, GenericInstMethodSig sig)
{
writer.Write((byte)ObjectType.GenericInstMethodSig);
writer.Write((byte)(sig == null ? 0 : sig.GetCallingConvention()));
foreach (var ga in sig.GetGenericArguments())
{
Write(writer, ga);
}
}
GenericInstMethodSig create(GenericInstMethodSig sig)
{
var newSig = new GenericInstMethodSig();
for (int i = 0; i < sig.GenericArguments.Count; i++)
{
newSig.GenericArguments.Add(create2(sig.GenericArguments[i]));
}
return(updated ? newSig : sig);
}
GenericInstMethodSig ResolveInst(GenericInstMethodSig sig, GenericArguments genericArgs)
{
var newSig = sig.Clone();
for (int i = 0; i < newSig.GenericArguments.Count; i++)
{
newSig.GenericArguments[i] = genericArgs.ResolveType(newSig.GenericArguments[i]);
}
return(newSig);
}
void Hash(GenericInstMethodSig sig)
{
if (sig == null)
{
return;
}
hasher.Hash((byte)sig.GetCallingConvention());
foreach (var ga in sig.GetGenericArguments())
{
Hash(ga);
}
}
/// <summary>
/// Reads a <see cref="GenericInstMethodSig"/>
/// </summary>
/// <param name="callingConvention">First byte of signature</param>
/// <returns>A new <see cref="GenericInstMethodSig"/> instance</returns>
GenericInstMethodSig ReadGenericInstMethod(CallingConvention callingConvention)
{
if (!reader.TryReadCompressedUInt32(out uint count))
{
return(null);
}
var sig = new GenericInstMethodSig(callingConvention, count);
var args = sig.GenericArguments;
for (uint i = 0; i < count; i++)
{
args.Add(ReadType());
}
return(sig);
}
bool ContainsGenericParameterInternal(GenericInstMethodSig gim)
{
if (gim == null)
{
return(false);
}
if (!recursionCounter.Increment())
{
return(false);
}
bool res = ContainsGenericParameter(gim.GenericArguments);
recursionCounter.Decrement();
return(res);
}
private void Write(GenericInstMethodSig sig)
{
if (sig == null)
{
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment())
{
helper.Error("Infinite recursion");
return;
}
writer.Write((byte)sig.GetCallingConvention());
var count = WriteCompressedUInt32((uint)sig.GenericArguments.Count);
for (uint i = 0; i < count; i++)
{
Write(sig.GenericArguments[(int)i]);
}
recursionCounter.Decrement();
}
/// <summary> /// Checks whether <paramref name="gim"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="gim">Generic method signature</param> /// <returns><c>true</c> if <paramref name="gim"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(GenericInstMethodSig gim) => new TypeHelper().ContainsGenericParameterInternal(gim);
internal GenericInstMethodSig CreateGenericMethodSig(ScannedMethod from, TypeService srv, GenericInstMethodSig original = null)
{
var types = new List <TypeSig>(TrueTypes.Count);
foreach (var trueType in TrueTypes)
{
if (trueType.IsGenericMethodParameter)
{
Debug.Assert(original != null, $"{nameof(original)} != null");
var number = ((GenericSig)trueType).Number;
Debug.Assert(number < original.GenericArguments.Count,
$"{nameof(number)} < {nameof(original)}.GenericArguments.Count");
var originalArgument = original.GenericArguments[(int)number];
types.Add(originalArgument);
}
else if (from?.IsScambled == true)
{
types.Add(from.ConvertToGenericIfAvalible(trueType));
}
else if (trueType.ToTypeDefOrRef() is TypeDef def)
{
// I am sure there are cleaner and better ways to do this.
var item = srv.GetItem(def);
types.Add(item?.IsScambled == true ? item.CreateGenericTypeSig(null) : trueType);
}
else
{
types.Add(trueType);
}
}
return(new GenericInstMethodSig(types));
}
void Write(GenericInstMethodSig sig) {
if (sig == null) {
helper.Error("sig is null");
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
writer.Write((byte)sig.GetCallingConvention());
uint count = WriteCompressedUInt32((uint)sig.GenericArguments.Count);
for (uint i = 0; i < count; i++)
Write(sig.GenericArguments[(int)i]);
recursionCounter.Decrement();
}
internal static async Task <int> Execute(ModuleDefMD targetModule)
{
/*
* {IL_0046: ldarg.0}
* {IL_0047: ldarg.0}
* {IL_0048: call UnityEngine.GameObject UnityEngine.Component::get_gameObject()}
* {IL_004D: callvirt TrainerManager UnityEngine.GameObject::AddComponent<TrainerManager>()}
* {IL_0052: stfld TrainerManager GameManager::trainerManager}
* {IL_0057: ret}
*/
var gameManagerTypeDef = targetModule.Find("GameManager", true);
var trainerManagerTypeDef = targetModule.Find("TrainerManager", true);
var trainerManagerFieldDef = InjectionHelpers.AddField(targetModule, "GameManager", "trainerManager", trainerManagerTypeDef.ToTypeSig(), FieldAttributes.Private);
if (trainerManagerFieldDef == null)
{
return(await Task.FromResult(1));
}
var gameManagerStartMethodDef = gameManagerTypeDef.FindMethod("Start");
var unityEngine = targetModule.GetAssemblyRef(new UTF8String("UnityEngine"));
var unityEngineComponentTypeRefUser = new TypeRefUser(targetModule, new UTF8String("UnityEngine"), new UTF8String("Component"), unityEngine);
var unityEngineGameObjectTypeRefUser = new TypeRefUser(targetModule, new UTF8String("UnityEngine"), new UTF8String("GameObject"), unityEngine);
var gameObjectTypeSig = unityEngineGameObjectTypeRefUser.ToTypeSig();
var getGameObjectMethodSig = MethodSig.CreateInstance(gameObjectTypeSig);
var gameManagerStartMethodSig = MethodSig.CreateInstanceGeneric(1, new GenericMVar(0, gameManagerStartMethodDef));
// {UnityEngine.GameObject UnityEngine.Component::get_gameObject()}
var getGameObjectMethodRefUser = new MemberRefUser(targetModule, new UTF8String("get_gameObject"), getGameObjectMethodSig, unityEngineComponentTypeRefUser);
// {TrainerManager UnityEngine.GameObject::AddComponent<TrainerManager>()}
var addComponentMethodRefUser = new MemberRefUser(targetModule, new UTF8String("AddComponent"), gameManagerStartMethodSig, unityEngineGameObjectTypeRefUser);
var trainerManagerGenericInstMethodSig = new GenericInstMethodSig(trainerManagerTypeDef.ToTypeSig());
var addComponentMethodSpecUser = new MethodSpecUser(addComponentMethodRefUser, trainerManagerGenericInstMethodSig);
var trainerManagerDefinitionMethodInstructions = new List <Instruction>
{
new Instruction(OpCodes.Ldarg_0),
new Instruction(OpCodes.Ldarg_0),
new Instruction(OpCodes.Call, getGameObjectMethodRefUser),
new Instruction(OpCodes.Callvirt, addComponentMethodSpecUser),
new Instruction(OpCodes.Stfld, trainerManagerFieldDef),
new Instruction(OpCodes.Ret),
};
var retInstruction = gameManagerStartMethodDef.Body.Instructions.LastOrDefault();
if (retInstruction != null && retInstruction.OpCode == OpCodes.Ret)
{
gameManagerStartMethodDef.Body.Instructions.Remove(retInstruction);
}
foreach (var instruction in trainerManagerDefinitionMethodInstructions)
{
gameManagerStartMethodDef.Body.Instructions.Add(instruction);
}
return(await Task.FromResult(0));
}
