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.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));
}
}
}
}
/// <summary>
/// Takes a Flame type and converts it to a Cecil type reference.
/// For this to work, <paramref name="type"/> cannot reference
/// non-Cecil types.
/// </summary>
/// <param name="type">
/// The type to convert to a type reference.
/// </param>
/// <returns>
/// A type reference.
/// </returns>
public static Mono.Cecil.TypeReference ImportReference(
this Mono.Cecil.ModuleDefinition module,
IType type)
{
if (type is ClrTypeDefinition)
{
var typeRef = ((ClrTypeDefinition)type).Definition;
// The module can be null for testing purposes.
return(module == null ? typeRef : module.ImportReference(typeRef));
}
else if (type is ClrGenericParameter)
{
// There's no need to "import" generic parameters: they can only be
// used in the same place where they are defined.
return(((ClrGenericParameter)type).Definition);
}
else if (type is PointerType)
{
var pointerType = (PointerType)type;
var elemType = pointerType.ElementType;
var elemTypeRef = module.ImportReference(elemType);
if (pointerType.Kind == PointerKind.Reference)
{
return(new Mono.Cecil.ByReferenceType(elemTypeRef));
}
else if (pointerType.Kind == PointerKind.Box)
{
if (elemType.IsReferenceType())
{
var def = module.ImportReference(elemTypeRef);
return(module == null ? def : module.ImportReference(def));
}
else
{
return(module.ImportReference(module.TypeSystem.Object));
}
}
else
{
return(new Mono.Cecil.PointerType(elemTypeRef));
}
}
IType elementType;
if (ClrArrayType.TryGetArrayElementType(type, out elementType))
{
// Handle arrays.
int rank;
ClrArrayType.TryGetArrayRank(type, out rank);
return(new Mono.Cecil.ArrayType(module.ImportReference(elementType), rank));
}
else if (type is TypeSpecialization)
{
// Handle generics.
var instance = new Mono.Cecil.GenericInstanceType(
module.ImportReference(
type.GetRecursiveGenericDeclaration()));
foreach (var item in type.GetRecursiveGenericArguments())
{
instance.GenericArguments.Add(module.ImportReference(item));
}
return(instance);
}
else
{
throw new NotSupportedException($"Cannot import ill-understood type '{type.FullName}'.");
}
}
