public TypeDefinition(string @namespace, string name, TypeAttributes attributes, TypeReference baseType, uint fieldList, uint methodList)
: base(new MetaDataRow((uint)attributes, 0U, 0U, 0U, fieldList, methodList))
{
this._namespace = @namespace;
this._name = name;
this._baseType = baseType;
}
public virtual TypeDefinition ResolveType(TypeReference typeRef)
{
LWin32 targetAssembly = null;
typeRef = typeRef.GetElementType();
if (typeRef.IsNested)
{
var declaringType = ResolveType(typeRef.DeclaringType);
foreach (var nestedClass in declaringType.NestedClasses)
{
if (nestedClass.Class != null && TypeRefsAreEqual(nestedClass.Class, typeRef))
{
return nestedClass.Class;
}
}
}
else
{
if (typeRef.ResolutionScope is AssemblyDefinition)
{
targetAssembly = typeRef.ResolutionScope.NETHeader.ParentAssembly;
}
else if (typeRef.ResolutionScope is AssemblyReference)
{
targetAssembly = AssemblyResolver.Resolve(typeRef.ResolutionScope as AssemblyReference);
}
if (targetAssembly == null)
{
return null;
}
var typesTable = targetAssembly.NETHeader.TablesHeap.GetTable(MetaDataTableType.TypeDef);
foreach (TypeDefinition member in typesTable.Members)
{
if (TypeRefsAreEqual(member, typeRef))
{
return member;
}
}
}
return null;
}
public override void ClearCache()
{
_owner = null;
_constraint = null;
}
public VariableDefinition(string name, int index, TypeReference type)
{
Index = index;
VariableType = type;
Name = name;
}
public GenericInstanceType(TypeReference typeRef)
: base(typeRef)
{
}
public ByReferenceType(TypeReference typeRef)
: base(typeRef)
{
}
public ArrayType(TypeReference typeRef, int rank, ArrayDimension[] dimensions)
: base(typeRef)
{
Rank = rank;
Dimensions = dimensions;
}
public CustomModifierType(TypeReference modifierType, TypeReference baseType, bool isRequired)
: base(baseType)
{
ModifierType = modifierType;
IsRequired = isRequired;
}
public FieldReference(string name, TypeReference declaringType, uint signature)
: base(new MetaDataRow(0U, 0U, signature))
{
this._name = name;
this._declaringType = declaringType;
}
public override void LoadCache()
{
_addmethod = AddMethod;
_removemethod = RemoveMethod;
_name = Name;
_eventType = EventType;
}
public EventDefinition(string name, EventAttributes attributes, TypeReference eventType)
: base(new MetaDataRow((ushort)attributes, 0U, 0U))
{
this._name = name;
this._eventType = eventType;
}
public override void ClearCache()
{
_addmethod = null;
_removemethod = null;
_name = null;
_eventType = null;
}
public override void LoadCache()
{
base.LoadCache();
_methodRange = MemberRange.CreateRange<MethodDefinition>(this, 5, NETHeader.TablesHeap.GetTable(MetaDataTableType.Method, false));
_methodRange.LoadCache();
_fieldRange = MemberRange.CreateRange<FieldDefinition>(this, 4, NETHeader.TablesHeap.GetTable(MetaDataTableType.Field, false));
_fieldRange.LoadCache();
_propertyMap = PropertyMap;
_eventMap = EventMap;
_nestedClasses = NestedClasses;
_interfaces = Interfaces;
_decltype = DeclaringType as TypeDefinition;
_genericparams = GenericParameters;
_baseType = BaseType;
}
public bool IsBasedOn(TypeReference typeRef)
{
return BaseType != null && BaseType.FullName == typeRef.FullName;
}
public TypeReference[] ReadGenericArguments()
{
uint number = NETGlobals.ReadCompressedUInt32(this);
var genericArguments = new TypeReference[number];
for (int i = 0; i < number; i++)
genericArguments[i] = ReadTypeReference();
return genericArguments;
}
public override void ClearCache()
{
_customAttributes = null;
_declaringType = null;
_pinvokeimpl = null;
}
public object ReadCustomAttributeArgumentElement(TypeReference paramType)
{
if (paramType._elementType == ElementType.None)
{
// TODO: convert string to type ref:
if (paramType.FullName == "System.Type")
return ReadUtf8String();
var resolvedTypeDef = paramType.Resolve();
if (resolvedTypeDef != null)
{
var enumType = resolvedTypeDef.GetEnumType();
if (enumType != null)
return ReadCustomAttributeArgumentElement(enumType);
}
return null;
}
else
{
if (paramType._elementType == ElementType.String)
return ReadUtf8String();
return ReadPrimitiveValue(paramType._elementType);
}
}
public override void LoadCache()
{
_pinvokeimpl = PInvokeImplementation;
_customAttributes = CustomAttributes;
_declaringType = DeclaringType;
}
public ArrayType(TypeReference typeRef)
: this(typeRef, 0, null)
{
}
public InterfaceImplementation(TypeDefinition @class, TypeReference @interface)
: base(new MetaDataRow(@class.TableIndex, 0U))
{
this._class = @class;
this._interface = @interface;
}
protected virtual bool TypeRefsAreEqual(TypeReference reference1, TypeReference reference2)
{
if (reference1 == null || reference2 == null)
return false;
if ((reference1.Name != reference2.Name) || (reference1.Namespace != reference2.Namespace))
return false;
if (reference1.HasGenericParameters != reference2.HasGenericParameters)
return false;
if (reference1.HasGenericParameters && reference2.HasGenericParameters)
{
if (reference1.GenericParameters.Length != reference2.GenericParameters.Length)
return false;
//for (int i = 0; i < reference1.GenericParameters.Length; i++)
//{
// if (!GenericParamsAreEqual(reference1.GenericParameters[i], reference2.GenericParameters[i]))
// return false;
//}
}
return true;
}
public override void ClearCache()
{
_class = null;
_interface = null;
}
public PointerType(TypeReference typeRef)
: base(typeRef)
{
}
public override void LoadCache()
{
_class = Class;
_interface = Interface;
}
public VariableDefinition(int index, TypeReference type)
{
Index = index;
VariableType = type;
Name = "";
}
public PinnedType(TypeReference typeRef)
: base(typeRef)
{
}
public GenericParamConstraint(GenericParameter owner, TypeReference constraint)
: base(new MetaDataRow(owner.TableIndex, 0U))
{
this._owner = owner;
this._constraint = constraint;
}
public object ReadCustomAttributeArgumentValue(TypeReference paramType)
{
if (!paramType.IsArray || !(paramType as ArrayType).IsVector)
return ReadCustomAttributeArgumentElement(paramType);
// throw new NotImplementedException("Array constructor values are not supported yet.");
ushort elementcount = this.ReadUInt16();
object[] elements = new object[elementcount];
for (int i = 0; i < elementcount; i++)
elements[i] = ReadCustomAttributeArgumentElement((paramType as ArrayType).OriginalType);
return elements;
}
public override void LoadCache()
{
_owner = Owner;
_constraint = Constraint;
}
public override void ClearCache()
{
base.ClearCache();
_methodRange = null;
_fieldRange = null;
_propertyMap = null;
_eventMap = null;
_nestedClasses = null;
_interfaces = null;
_decltype = null;
_genericparams = null;
_baseType = null;
}
