/// <summary>
/// Initializes a new instance of the <see cref="CilGenericType"/> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="baseGenericType">Type of the base generic.</param>
/// <param name="genericTypeInstanceSignature">The generic type instance signature.</param>
/// <param name="token">The token.</param>
/// <param name="typeModule">The type module.</param>
public CilGenericType(ITypeModule module, RuntimeType baseGenericType, GenericInstSigType genericTypeInstanceSignature, Token token, ITypeModule typeModule) :
base(module, token, baseGenericType.BaseType)
{
Debug.Assert(baseGenericType is CilRuntimeType);
this.signature = genericTypeInstanceSignature;
this.baseGenericType = baseGenericType as CilRuntimeType;
base.Attributes = baseGenericType.Attributes;
base.Namespace = baseGenericType.Namespace;
if (this.baseGenericType.IsNested)
{
// TODO: find generic type
;
}
// TODO: if this is a nested types, add enclosing type(s) into genericArguments first
this.genericArguments = signature.GenericArguments;
base.Name = GetName(typeModule);
ResolveMethods();
ResolveFields();
this.containsOpenGenericArguments = CheckContainsOpenGenericParameters();
}
private void LoadType(Token token, IList <TypeInfo> typeInfos)
{
TypeInfo info = typeInfos[(int)token.RID - 1];
if (types[token.RID - 1] != null)
{
return;
}
if (info.TypeDefRow.Extends.RID != 0)
{
if (info.TypeDefRow.Extends.Table == TableType.TypeDef)
{
LoadType(info.TypeDefRow.Extends, typeInfos);
}
else if (info.TypeDefRow.Extends.Table != TableType.TypeRef)
{
throw new ArgumentException(@"unexpected token type.", @"extends");
}
}
RuntimeType baseType = GetType(info.TypeDefRow.Extends);
RuntimeType enclosingType = (info.NestedClass == token) ? types[info.EnclosingClass.RID - 1] : null;
// Create and populate the runtime type
CilRuntimeType type = new CilRuntimeType(
this,
GetString(info.TypeDefRow.TypeNameIdx),
GetString(info.TypeDefRow.TypeNamespaceIdx),
info.PackingSize,
info.Size,
token,
baseType,
enclosingType,
info.TypeDefRow.Flags,
info.TypeDefRow.Extends
);
LoadMethods(type, info.TypeDefRow.MethodList, info.MaxMethod);
LoadFields(type, info.TypeDefRow.FieldList, info.MaxField);
types[token.RID - 1] = type;
}
/// <summary>
/// Loads all types From the given metadata module.
/// </summary>
/// <param name="module">The metadata module to load the types From.</param>
/// <param name="moduleOffsets">The offsets into the metadata arrays, of the current module.</param>
private void LoadTypes(IMetadataModule module, ModuleOffsets moduleOffsets)
{
TokenTypes maxTypeDef, maxField, maxMethod, maxLayout, tokenLayout = TokenTypes.ClassLayout + 1;
TypeDefRow typeDefRow, nextTypeDefRow = new TypeDefRow();
ClassLayoutRow layoutRow = new ClassLayoutRow();
IMetadataProvider md = module.Metadata;
int size = 0x0, packing = 0;
int typeOffset = moduleOffsets.TypeOffset;
int methodOffset = moduleOffsets.MethodOffset;
int fieldOffset = moduleOffsets.FieldOffset;
RuntimeType rt;
maxTypeDef = md.GetMaxTokenValue(TokenTypes.TypeDef);
maxLayout = md.GetMaxTokenValue(TokenTypes.ClassLayout);
if (TokenTypes.ClassLayout < maxLayout)
{
md.Read(tokenLayout, out layoutRow);
}
TokenTypes token = TokenTypes.TypeDef + 2;
md.Read(token, out typeDefRow);
do
{
/*
* string name;
* md.Read(typeDefRow.TypeNameIdx, out name);
* Debug.WriteLine(name);
*/
if (token < maxTypeDef)
{
md.Read(token + 1, out nextTypeDefRow);
maxField = nextTypeDefRow.FieldList;
maxMethod = nextTypeDefRow.MethodList;
}
else
{
maxMethod = md.GetMaxTokenValue(TokenTypes.MethodDef) + 1;
maxField = md.GetMaxTokenValue(TokenTypes.Field) + 1;
}
// Is this our layout info?
if ((layoutRow.ParentTypeDefIdx + 1) == token)
{
size = layoutRow.ClassSize;
packing = layoutRow.PackingSize;
tokenLayout++;
if (tokenLayout <= maxLayout)
{
md.Read(tokenLayout, out layoutRow);
}
}
// Create and populate the runtime type
rt = new CilRuntimeType(token, module, ref typeDefRow, maxField, maxMethod, packing, size);
LoadMethods(module, rt, typeDefRow.MethodList, maxMethod, ref methodOffset);
LoadFields(module, rt, typeDefRow.FieldList, maxField, ref fieldOffset);
_types[typeOffset++] = rt;
if (rtCallTypeAttribute == null)
{
if (rt.Name == "InternalCallTypeAttribute" && rt.Namespace == "Mosa.Runtime.Vm")
{
rtCallTypeAttribute = rt;
}
}
packing = size = 0;
typeDefRow = nextTypeDefRow;
}while (token++ < maxTypeDef);
}
