/// <summary>
/// Loads the generic interfaces.
/// </summary>
protected void LoadGenericInterfaces()
{
foreach (RuntimeType type in typeSpecs)
{
CilGenericType genericType = type as CilGenericType;
if (genericType != null)
{
genericType.ResolveInterfaces(this);
}
}
}
/// <summary>
/// Gets the open generic.
/// </summary>
/// <param name="baseGenericType">Type of the base generic.</param>
/// <returns></returns>
CilGenericType ITypeSystem.GetOpenGeneric(RuntimeType baseGenericType)
{
foreach (ITypeModule typeModule in typeModules)
{
CilGenericType type = typeModule.GetOpenGeneric(baseGenericType);
if (type != null)
{
return(type);
}
}
return(null);
}
/// <summary>
/// Provides access to the instructions of the method.
/// </summary>
/// <returns>A stream, which represents the IL of the method.</returns>
public Stream GetInstructionStream()
{
ITypeModule module;
CilGenericType genericType = method.DeclaringType as CilGenericType;
if (genericType != null)
{
module = (method.DeclaringType as CilGenericType).BaseGenericType.Module;
}
else
{
module = method.Module;
}
return(module.MetadataModule.GetInstructionStream((long)method.Rva));
}
/// <summary>
/// Gets the open generic.
/// </summary>
/// <param name="baseGenericType">Type of the base generic.</param>
/// <returns></returns>
CilGenericType ITypeModule.GetOpenGeneric(RuntimeType baseGenericType)
{
if (baseGenericType.IsInterface || baseGenericType.IsModule)
{
return(null);
}
if (baseGenericType.GenericParameters.Count == 0)
{
return(null);
}
foreach (RuntimeType type in typeSpecs)
{
CilGenericType genericType = type as CilGenericType;
if (genericType != null)
{
if (genericType.BaseGenericType == baseGenericType)
{
if (genericType.ContainsOpenGenericParameters)
{
bool open = true;
foreach (SigType sigType in genericType.GenericArguments)
{
if (!sigType.IsOpenGenericParameter)
{
open = false;
break;
}
}
if (open)
{
return(genericType);
}
}
}
}
}
return(null);
}
protected void UpdateTree()
{
treeView.BeginUpdate();
treeView.Nodes.Clear();
foreach (ITypeModule module in typeSystem.TypeModules)
{
TreeNode moduleNode = new TreeNode(module.Name);
treeView.Nodes.Add(moduleNode);
foreach (RuntimeType type in module.GetAllTypes())
{
TreeNode typeNode = new TreeNode(FormatRuntimeType(type));
moduleNode.Nodes.Add(typeNode);
if (type.BaseType != null)
{
TreeNode baseTypeNode = new TreeNode("Base Type: " + FormatRuntimeType(type.BaseType));
typeNode.Nodes.Add(baseTypeNode);
}
CilGenericType genericType = type as CilGenericType;
if (genericType != null)
{
if (genericType.BaseGenericType != null)
{
TreeNode genericBaseTypeNode = new TreeNode("Generic Base Type: " + FormatRuntimeType(genericType.BaseGenericType));
typeNode.Nodes.Add(genericBaseTypeNode);
}
}
CilGenericType genericOpenType = typeSystem.GetOpenGeneric(type);
if (genericOpenType != null)
{
TreeNode genericOpenTypeNode = new TreeNode("Open Generic Type: " + FormatRuntimeType(genericOpenType));
typeNode.Nodes.Add(genericOpenTypeNode);
}
if (type.GenericParameters.Count != 0)
{
TreeNode genericParameterNodes = new TreeNode("Generic Parameters");
typeNode.Nodes.Add(genericParameterNodes);
foreach (GenericParameter genericParameter in type.GenericParameters)
{
TreeNode GenericParameterNode = new TreeNode(genericParameter.Name);
genericParameterNodes.Nodes.Add(GenericParameterNode);
}
}
if (type.Interfaces.Count != 0)
{
TreeNode interfacesNodes = new TreeNode("Interfaces");
typeNode.Nodes.Add(interfacesNodes);
foreach (RuntimeType interfaceType in type.Interfaces)
{
TreeNode interfaceNode = new TreeNode(FormatRuntimeType(interfaceType));
interfacesNodes.Nodes.Add(interfaceNode);
}
}
if (type.Fields.Count != 0)
{
TreeNode fieldsNode = new TreeNode("Fields");
if (showSizes.Checked)
{
fieldsNode.Text = fieldsNode.Text + " (Count: " + type.Fields.Count.ToString() + " - Size: " + typeLayout.GetTypeSize(type).ToString() + ")";
}
typeNode.Nodes.Add(fieldsNode);
foreach (RuntimeField field in type.Fields)
{
TreeNode fieldNode = new TreeNode(FormatRuntimeMember(field));
fieldsNode.Nodes.Add(fieldNode);
if (field.IsStaticField)
{
fieldNode.Text = fieldNode.Text + " [Static]";
}
if (showSizes.Checked)
{
fieldNode.Text = fieldNode.Text + " (Size: " + typeLayout.GetFieldSize(field).ToString();
if (!field.IsStaticField)
{
fieldNode.Text = fieldNode.Text + " - Offset: " + typeLayout.GetFieldOffset(field).ToString();
}
fieldNode.Text = fieldNode.Text + ")";
}
}
}
if (type.Methods.Count != 0)
{
TreeNode methodsNode = new TreeNode("Methods");
typeNode.Nodes.Add(methodsNode);
foreach (RuntimeMethod method in type.Methods)
{
TreeNode methodNode = new TreeNode(FormatRuntimeMember(method));
methodsNode.Nodes.Add(methodNode);
if ((method.Attributes & MethodAttributes.Static) == MethodAttributes.Static)
{
methodNode.Text = methodNode.Text + " [Static]";
}
if (method.IsAbstract)
{
methodNode.Text = methodNode.Text + " [Abstract]";
}
}
}
if (typeLayout.GetMethodTable(type) != null)
{
TreeNode methodTableNode = new TreeNode("Method Table");
typeNode.Nodes.Add(methodTableNode);
foreach (RuntimeMethod method in typeLayout.GetMethodTable(type))
{
TreeNode methodNode = new TreeNode(FormatRuntimeMember(method));
methodTableNode.Nodes.Add(methodNode);
}
}
}
}
treeView.EndUpdate();
}
/// <summary>
/// Loads the type specs.
/// </summary>
private void LoadTypeSpecs()
{
Token maxToken = GetMaxTokenValue(TableType.TypeSpec);
foreach (Token token in new Token(TableType.TypeSpec, 1).Upto(maxToken))
{
TypeSpecRow row = metadataProvider.ReadTypeSpecRow(token);
TypeSpecSignature signature = GetTypeSpecSignature(row.SignatureBlobIdx);
GenericInstSigType genericSigType = signature.Type as GenericInstSigType;
if (genericSigType != null)
{
RuntimeType genericType = null;
SigType sigType = genericSigType;
switch (genericSigType.Type)
{
case CilElementType.ValueType:
goto case CilElementType.Class;
case CilElementType.Class:
TypeSigType typeSigType = (TypeSigType)sigType;
genericType = types[typeSigType.Token.RID]; // NOTE: Should this be -1
break;
case CilElementType.GenericInst:
GenericInstSigType genericSigType2 = (GenericInstSigType)sigType;
RuntimeType genericBaseType = null;
if (genericSigType2.BaseType.Token.Table == TableType.TypeDef)
{
genericBaseType = types[genericSigType2.BaseType.Token.RID - 1];
}
else if (genericSigType2.BaseType.Token.Table == TableType.TypeRef)
{
genericBaseType = typeRef[genericSigType2.BaseType.Token.RID - 1];
}
genericType = new CilGenericType(this, genericBaseType, genericSigType, token, this);
break;
default:
throw new NotSupportedException(String.Format(@"LoadTypeSpecs does not support CilElementType.{0}", genericSigType.Type));
}
typeSpecs[token.RID - 1] = genericType;
}
else
{
if (signature.Type is MVarSigType)
{
continue;
}
else if (signature.Type is SZArraySigType)
{
continue;
}
else
{
continue;
}
}
}
}
/// <summary>
/// Loads the interfaces.
/// </summary>
protected void LoadMemberReferences()
{
Token maxToken = GetMaxTokenValue(TableType.MemberRef);
foreach (Token token in new Token(TableType.MemberRef, 1).Upto(maxToken))
{
MemberRefRow row = metadataProvider.ReadMemberRefRow(token);
string name = GetString(row.NameStringIdx);
RuntimeType ownerType = null;
switch (row.Class.Table)
{
case TableType.TypeDef:
ownerType = types[row.Class.RID - 1];
break;
case TableType.TypeRef:
ownerType = typeRef[row.Class.RID - 1];
break;
case TableType.TypeSpec:
ownerType = typeSpecs[row.Class.RID - 1];
break;
default:
throw new NotSupportedException(String.Format(@"LoadMemberReferences() does not support token table {0}", row.Class.Table));
}
if (ownerType == null)
{
throw new InvalidOperationException(String.Format(@"Failed to retrieve owner type for Token {0:x} (Table {1})", row.Class, row.Class.Table));
}
Signature signature = GetMemberRefSignature(row.SignatureBlobIdx);
CilGenericType genericOwnerType = ownerType as CilGenericType;
RuntimeMember runtimeMember = null;
if (signature is FieldSignature)
{
foreach (RuntimeField field in ownerType.Fields)
{
if (field.Name == name)
{
runtimeMember = field;
break;
}
}
}
else
{
MethodSignature methodSignature = signature as MethodSignature;
Debug.Assert(signature is MethodSignature);
if ((genericOwnerType != null) && (genericOwnerType.GenericArguments.Length != 0))
{
methodSignature = new MethodSignature(methodSignature, genericOwnerType.GenericArguments);
}
foreach (RuntimeMethod method in ownerType.Methods)
{
if (method.Name == name)
{
if (method.Signature.Matches(methodSignature))
{
runtimeMember = method;
break;
}
}
}
// Special case: string.get_Chars is same as string.get_Item
if (runtimeMember == null && name == "get_Chars" && ownerType.FullName == "System.String")
{
name = "get_Item";
foreach (RuntimeMethod method in ownerType.Methods)
{
if (method.Name == name)
{
if (method.Signature.Matches(methodSignature))
{
runtimeMember = method;
break;
}
}
}
}
}
if (runtimeMember == null)
{
throw new InvalidOperationException(String.Format(@"Failed to locate field {0}.{1}", ownerType.FullName, name));
}
memberRef[token.RID - 1] = runtimeMember;
}
}
