public MethodParamList(ICLRSharp_Environment env, Mono.Cecil.GenericInstanceMethod method) { { // foreach(var p in method.GenericArguments) var __enumerator4 = (method.GenericArguments).GetEnumerator(); while (__enumerator4.MoveNext()) { var p = __enumerator4.Current; { string paramname = p.FullName; if (p.IsGenericParameter) { var typegen = method.DeclaringType as Mono.Cecil.GenericInstanceType; if (p.Name[0] == '!') { int index = int.Parse(p.Name.Substring(1)); paramname = typegen.GenericArguments[index].FullName; } } var type = env.GetType(paramname); if (type.IsEnum()) { type = env.GetType(type.TypeForSystem); } this.Add(type); } } } }
/// <summary> /// Takes a Flame method and converts it to a Cecil method reference. /// For this to work, <paramref name="field"/> cannot reference /// non-Cecil types or methods. /// </summary> /// <param name="field"> /// The method to convert to a method reference. /// </param> /// <returns> /// A method reference. /// </returns> public static Mono.Cecil.MethodReference ImportReference( this Mono.Cecil.ModuleDefinition module, IMethod method) { if (method is ClrMethodDefinition) { var def = ((ClrMethodDefinition)method).Definition; return(module == null ? def : module.ImportReference(def)); } else if (method is IndirectMethodSpecialization) { var specialization = (IndirectMethodSpecialization)method; return(CloneMethodWithDeclaringType( module.ImportReference(specialization.Declaration), module.ImportReference(specialization.ParentType))); } else if (method is DirectMethodSpecialization) { var specialization = (DirectMethodSpecialization)method; var genInst = new Mono.Cecil.GenericInstanceMethod( module.ImportReference(specialization.Declaration)); foreach (var item in specialization.GenericArguments) { genInst.GenericArguments.Add(module.ImportReference(item)); } return(genInst); } else { throw new NotSupportedException($"Cannot import ill-understood method '{method.FullName}'."); } }
IMethod GetMethod(object token) { Mono.Cecil.ModuleDefinition module = null; string methodname = null; string typename = null; MethodParamList genlist = null; MethodParamList list = null; if (token is Mono.Cecil.MethodReference) { Mono.Cecil.MethodReference _ref = (token as Mono.Cecil.MethodReference); module = _ref.Module; methodname = _ref.Name; typename = _ref.DeclaringType.FullName; list = new MethodParamList(environment, _ref); if (_ref.IsGenericInstance) { Mono.Cecil.GenericInstanceMethod gmethod = _ref as Mono.Cecil.GenericInstanceMethod; genlist = new MethodParamList(environment, gmethod); } } else if (token is Mono.Cecil.MethodDefinition) { Mono.Cecil.MethodDefinition _def = token as Mono.Cecil.MethodDefinition; module = _def.Module; methodname = _def.Name; typename = _def.DeclaringType.FullName; list = new MethodParamList(environment, _def); if (_def.IsGenericInstance) { throw new NotImplementedException(); //Mono.Cecil.GenericInstanceMethod gmethod = _def as Mono.Cecil.GenericInstanceMethod; //genlist = new MethodParamList(environment, gmethod); } } else { throw new NotImplementedException(); } var typesys = GetType(typename, module); if (typesys == null) { throw new Exception("type can't find:" + typename); } IMethod _method = null; if (genlist != null) { _method = typesys.GetMethodT(methodname, genlist, list); } else { _method = typesys.GetMethod(methodname, list); } return(_method); }
public MethodParamList(ICLRSharp_Environment env, Mono.Cecil.MethodReference method) { if (method.HasParameters) { Mono.Cecil.GenericInstanceType _typegen = null; _typegen = method.DeclaringType as Mono.Cecil.GenericInstanceType; Mono.Cecil.GenericInstanceMethod gm = method as Mono.Cecil.GenericInstanceMethod; MethodParamList _methodgen = null; if (gm != null) { _methodgen = new MethodParamList(env, gm); } foreach (var p in method.Parameters) { string paramname = p.ParameterType.FullName; if (p.ParameterType.IsGenericParameter) { if (p.ParameterType.Name.Contains("!!")) { int index = int.Parse(p.ParameterType.Name.Substring(2)); paramname = _methodgen[index].FullName; } else if (p.ParameterType.Name.Contains("!")) { int index = int.Parse(p.ParameterType.Name.Substring(1)); paramname = _typegen.GenericArguments[index].FullName; } } if (paramname.Contains("!!")) { //string typename = param.ParameterType.FullName; for (int i = 0; i < _methodgen.Count; i++) { string pp = "!!" + i.ToString(); paramname = paramname.Replace(pp, _methodgen[i].FullName); } //this.Add(GetTType(env, p, _methodgen)); } if (paramname.Contains("!"))//函数有T { var gens = (method.DeclaringType as Mono.Cecil.GenericInstanceType).GenericArguments; for (int i = 0; i < gens.Count; i++) { string pp = "!" + i.ToString(); paramname = paramname.Replace(pp, gens[i].FullName); } } //else { this.Add(env.GetType(paramname)); } } } }
public MethodParamList(ICLRSharp_Environment env, Mono.Cecil.GenericInstanceMethod method) { foreach (var p in method.GenericArguments) { string paramname = p.FullName; if (p.IsGenericParameter) { var typegen = method.DeclaringType as Mono.Cecil.GenericInstanceType; if (p.Name[0] == '!') { int index = int.Parse(p.Name.Substring(1)); paramname = typegen.GenericArguments[index].FullName; } } this.Add(env.GetType(paramname)); } }
public MethodParamList(ICLRSharp_Environment env, Mono.Cecil.MethodReference method) { if (method.HasParameters) { Mono.Cecil.GenericInstanceType _typegen = null; _typegen = method.DeclaringType as Mono.Cecil.GenericInstanceType; Mono.Cecil.GenericInstanceMethod gm = method as Mono.Cecil.GenericInstanceMethod; MethodParamList _methodgen = null; if (gm != null) { _methodgen = new MethodParamList(env, gm); } foreach (var p in method.Parameters) { string paramname = p.ParameterType.FullName; if (p.ParameterType.IsGenericParameter) { if (p.ParameterType.Name.Contains("!!")) { int index = int.Parse(p.ParameterType.Name.Substring(2)); paramname = _methodgen[index].FullName; } else if (p.ParameterType.Name.Contains("!")) { int index = int.Parse(p.ParameterType.Name.Substring(1)); paramname = _typegen.GenericArguments[index].FullName; } } if (paramname.Contains("!!")) { this.Add(GetTType(env, p, method, _methodgen)); } else { this.Add(env.GetType(paramname, method.Module)); } } } }
public IMethod GetMethod(object token) { IMethod __method = null; if (methodCache.TryGetValue(token.GetHashCode(), out __method)) { return(__method); } Mono.Cecil.ModuleDefinition module = null; string methodname = null; string typename = null; MethodParamList genlist = null; MethodParamList list = null; if (token is Mono.Cecil.MethodReference) { Mono.Cecil.MethodReference _ref = (token as Mono.Cecil.MethodReference); module = _ref.Module; methodname = _ref.Name; typename = _ref.DeclaringType.FullName; list = new MethodParamList(environment, _ref); if (_ref.IsGenericInstance) { Mono.Cecil.GenericInstanceMethod gmethod = _ref as Mono.Cecil.GenericInstanceMethod; genlist = new MethodParamList(environment, gmethod); } } else if (token is Mono.Cecil.MethodDefinition) { Mono.Cecil.MethodDefinition _def = token as Mono.Cecil.MethodDefinition; module = _def.Module; methodname = _def.Name; typename = _def.DeclaringType.FullName; list = new MethodParamList(environment, _def); if (_def.IsGenericInstance) { throw new NotImplementedException(); //Mono.Cecil.GenericInstanceMethod gmethod = _def as Mono.Cecil.GenericInstanceMethod; //genlist = new MethodParamList(environment, gmethod); } } else { throw new NotImplementedException(); } var typesys = GetType(typename); if (typesys == null) { typename = typename.Replace("0...", ""); typesys = GetType(typename); } if (typesys == null) { throw new Exception("type can't find:" + typename); } IMethod _method = null; if (genlist != null) { _method = typesys.GetMethodT(methodname, genlist, list); } else { _method = typesys.GetMethod(methodname, list); } methodCache[token.GetHashCode()] = _method; return(_method); }