internal TypeDefImpl(ModuleReader module, int index)
{
this.module = module;
this.index = index;
this.typeName = module.GetString(module.TypeDef.records[index].TypeName);
this.typeNamespace = module.GetString(module.TypeDef.records[index].TypeNamespace);
}
internal AssemblyReader(string location, ModuleReader manifestModule)
: base(manifestModule.universe)
{
this.location = location;
this.manifestModule = manifestModule;
externalModules = new Module[manifestModule.File.records.Length];
}
internal ResourceModule(ModuleReader manifest, int index, string location)
: base(manifest.universe)
{
this.manifest = manifest;
this.index = index;
this.location = location;
}
internal static FieldSignature ReadSig(ModuleReader module, ByteReader br, IGenericContext context)
{
if (br.ReadByte() != FIELD)
{
throw new BadImageFormatException();
}
CustomModifiers mods = CustomModifiers.Read(module, br, context);
Type fieldType = ReadType(module, br, context);
return new FieldSignature(fieldType, mods);
}
internal ExceptionHandlingClause(ModuleReader module, int flags, int tryOffset, int tryLength, int handlerOffset, int handlerLength, int classTokenOrfilterOffset, IGenericContext context)
{
this.flags = flags;
this.tryOffset = tryOffset;
this.tryLength = tryLength;
this.handlerOffset = handlerOffset;
this.handlerLength = handlerLength;
this.catchType = flags == (int)ExceptionHandlingClauseOptions.Clause && classTokenOrfilterOffset != 0 ? module.ResolveType(classTokenOrfilterOffset, context) : null;
this.filterOffset = flags == (int)ExceptionHandlingClauseOptions.Filter ? classTokenOrfilterOffset : 0;
}
internal Type GetType(ModuleReader module, TypeName typeName)
{
if (type == null)
{
Assembly asm = module.ResolveAssemblyRef(assemblyRef);
type = asm.ResolveType(typeName);
if (type == null)
{
throw new TypeLoadException(typeName.ToString());
}
}
return(type);
}
private Module LoadModule(int index, byte[] rawModule, string location)
{
if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
{
return(externalModules[index] = new ResourceModule(manifestModule, index, location));
}
else
{
if (rawModule == null)
{
rawModule = File.ReadAllBytes(location);
}
return(externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location));
}
}
private Module LoadModule(int index, byte[] rawModule, string name)
{
string location = name == null ? null : Path.Combine(Path.GetDirectoryName(this.location), name);
if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
{
return(externalModules[index] = new ResourceModule(manifestModule, index, location));
}
else
{
if (rawModule == null)
{
try
{
rawModule = File.ReadAllBytes(location);
}
catch (FileNotFoundException)
{
if (resolvers != null)
{
ResolveEventArgs arg = new ResolveEventArgs(name, this);
foreach (ModuleResolveEventHandler resolver in resolvers)
{
Module module = resolver(this, arg);
if (module != null)
{
return(module);
}
}
}
if (universe.MissingMemberResolution)
{
return(externalModules[index] = new MissingModule(this, index));
}
throw;
}
}
return(externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location, false));
}
}
private static Type ReadGenericInst(ModuleReader module, ByteReader br, IGenericContext context)
{
Type type;
switch (br.ReadByte())
{
case ELEMENT_TYPE_CLASS:
type = ReadTypeDefOrRefEncoded(module, br, context).MarkNotValueType();
break;
case ELEMENT_TYPE_VALUETYPE:
type = ReadTypeDefOrRefEncoded(module, br, context).MarkValueType();
break;
default:
throw new BadImageFormatException();
}
if (!type.__IsMissing && !type.IsGenericTypeDefinition)
{
throw new BadImageFormatException();
}
int genArgCount = br.ReadCompressedInt();
Type[] args = new Type[genArgCount];
Type[][] reqmod = null;
Type[][] optmod = null;
for (int i = 0; i < genArgCount; i++)
{
// LAMESPEC the Type production (23.2.12) doesn't include CustomMod* for genericinst, but C++ uses it, the verifier allows it and ildasm also supports it
CustomModifiers mods = ReadCustomModifiers(module, br, context);
if (mods.required != null || mods.optional != null)
{
if (reqmod == null)
{
reqmod = new Type[genArgCount][];
optmod = new Type[genArgCount][];
}
reqmod[i] = mods.required;
optmod[i] = mods.optional;
}
args[i] = ReadType(module, br, context);
}
return GenericTypeInstance.Make(type, args, reqmod, optmod);
}
internal MetadataReader(ModuleReader module, BinaryReader br, byte heapSizes)
: base(module, (heapSizes & 0x01) != 0, (heapSizes & 0x02) != 0, (heapSizes & 0x04) != 0)
{
this.br = br;
}
private static Type ReadTypeOrVoid(ModuleReader module, ByteReader br, IGenericContext context)
{
if (br.PeekByte() == ELEMENT_TYPE_VOID)
{
br.ReadByte();
return module.universe.System_Void;
}
else
{
return ReadType(module, br, context);
}
}
internal GenericTypeParameter(ModuleReader module, int index)
{
this.module = module;
this.index = index;
}
internal static MethodSignature ReadSig(ModuleReader module, ByteReader br, IGenericContext context)
{
CallingConventions callingConvention;
int genericParamCount;
Type returnType;
Type[] parameterTypes;
byte flags = br.ReadByte();
switch (flags & 7)
{
case DEFAULT:
callingConvention = CallingConventions.Standard;
break;
case VARARG:
callingConvention = CallingConventions.VarArgs;
break;
default:
throw new BadImageFormatException();
}
if ((flags & HASTHIS) != 0)
{
callingConvention |= CallingConventions.HasThis;
}
if ((flags & EXPLICITTHIS) != 0)
{
callingConvention |= CallingConventions.ExplicitThis;
}
genericParamCount = 0;
if ((flags & GENERIC) != 0)
{
genericParamCount = br.ReadCompressedInt();
context = new UnboundGenericMethodContext(context);
}
int paramCount = br.ReadCompressedInt();
Type[][][] modifiers = null;
Type[] optionalCustomModifiers;
Type[] requiredCustomModifiers;
ReadCustomModifiers(module, br, context, out requiredCustomModifiers, out optionalCustomModifiers);
returnType = ReadRetType(module, br, context);
parameterTypes = new Type[paramCount];
PackedCustomModifiers.SetModifiers(ref modifiers, 0, 0, optionalCustomModifiers, paramCount + 1);
PackedCustomModifiers.SetModifiers(ref modifiers, 0, 1, requiredCustomModifiers, paramCount + 1);
for (int i = 0; i < parameterTypes.Length; i++)
{
if ((callingConvention & CallingConventions.VarArgs) != 0 && br.PeekByte() == SENTINEL)
{
Array.Resize(ref parameterTypes, i);
if (modifiers != null)
{
Array.Resize(ref modifiers, i + 1);
}
break;
}
ReadCustomModifiers(module, br, context, out requiredCustomModifiers, out optionalCustomModifiers);
PackedCustomModifiers.SetModifiers(ref modifiers, i + 1, 0, optionalCustomModifiers, paramCount + 1);
PackedCustomModifiers.SetModifiers(ref modifiers, i + 1, 1, requiredCustomModifiers, paramCount + 1);
parameterTypes[i] = ReadParam(module, br, context);
}
return new MethodSignature(returnType, parameterTypes, modifiers, callingConvention, genericParamCount);
}
internal MetadataReader(ModuleReader module, Stream stream, byte heapSizes)
: base(module, (heapSizes & 0x01) != 0, (heapSizes & 0x02) != 0, (heapSizes & 0x04) != 0)
{
this.stream = stream;
}
internal Type GetType(ModuleReader module)
{
return(type ?? (type = module.ResolveExportedType(index)));
}
private static Type ReadTypeOrByRef(ModuleReader module, ByteReader br, IGenericContext context)
{
if (br.PeekByte() == ELEMENT_TYPE_BYREF)
{
br.ReadByte();
// LAMESPEC it is allowed (by C++/CLI, ilasm and peverify) to have custom modifiers after the BYREF
// (which makes sense, as it is analogous to pointers)
CustomModifiers mods = CustomModifiers.Read(module, br, context);
// C++/CLI generates void& local variables, so we need to use ReadTypeOrVoid here
return ReadTypeOrVoid(module, br, context).__MakeByRefType(mods);
}
else
{
return ReadType(module, br, context);
}
}
internal static Type ReadTypeDefOrRefEncoded(ModuleReader module, ByteReader br, IGenericContext context)
{
int encoded = br.ReadCompressedUInt();
switch (encoded & 3)
{
case 0:
return module.ResolveType((TypeDefTable.Index << 24) + (encoded >> 2), null, null);
case 1:
return module.ResolveType((TypeRefTable.Index << 24) + (encoded >> 2), null, null);
case 2:
return module.ResolveType((TypeSpecTable.Index << 24) + (encoded >> 2), context);
default:
throw new BadImageFormatException();
}
}
// this reads just the optional parameter types, from a MethodRefSig
internal static Type[] ReadOptionalParameterTypes(ModuleReader module, ByteReader br)
{
br.ReadByte();
int paramCount = br.ReadCompressedInt();
SkipCustomModifiers(br);
ReadRetType(module, br, null);
for (int i = 0; i < paramCount; i++)
{
if (br.PeekByte() == SENTINEL)
{
br.ReadByte();
Type[] types = new Type[paramCount - i];
for (int j = 0; j < types.Length; j++)
{
SkipCustomModifiers(br);
types[j] = ReadType(module, br, null);
}
return types;
}
SkipCustomModifiers(br);
ReadType(module, br, null);
}
return Type.EmptyTypes;
}
// see ECMA 335 CLI spec June 2006 section 23.2.12 for this production
protected static Type ReadType(ModuleReader module, ByteReader br, IGenericContext context)
{
CustomModifiers mods;
switch (br.ReadByte())
{
case ELEMENT_TYPE_CLASS:
return ReadTypeDefOrRefEncoded(module, br, context).MarkNotValueType();
case ELEMENT_TYPE_VALUETYPE:
return ReadTypeDefOrRefEncoded(module, br, context).MarkValueType();
case ELEMENT_TYPE_BOOLEAN:
return module.universe.System_Boolean;
case ELEMENT_TYPE_CHAR:
return module.universe.System_Char;
case ELEMENT_TYPE_I1:
return module.universe.System_SByte;
case ELEMENT_TYPE_U1:
return module.universe.System_Byte;
case ELEMENT_TYPE_I2:
return module.universe.System_Int16;
case ELEMENT_TYPE_U2:
return module.universe.System_UInt16;
case ELEMENT_TYPE_I4:
return module.universe.System_Int32;
case ELEMENT_TYPE_U4:
return module.universe.System_UInt32;
case ELEMENT_TYPE_I8:
return module.universe.System_Int64;
case ELEMENT_TYPE_U8:
return module.universe.System_UInt64;
case ELEMENT_TYPE_R4:
return module.universe.System_Single;
case ELEMENT_TYPE_R8:
return module.universe.System_Double;
case ELEMENT_TYPE_I:
return module.universe.System_IntPtr;
case ELEMENT_TYPE_U:
return module.universe.System_UIntPtr;
case ELEMENT_TYPE_STRING:
return module.universe.System_String;
case ELEMENT_TYPE_OBJECT:
return module.universe.System_Object;
case ELEMENT_TYPE_VAR:
return context.GetGenericTypeArgument(br.ReadCompressedUInt());
case ELEMENT_TYPE_MVAR:
return context.GetGenericMethodArgument(br.ReadCompressedUInt());
case ELEMENT_TYPE_GENERICINST:
return ReadGenericInst(module, br, context);
case ELEMENT_TYPE_SZARRAY:
mods = CustomModifiers.Read(module, br, context);
return ReadType(module, br, context).__MakeArrayType(mods);
case ELEMENT_TYPE_ARRAY:
mods = CustomModifiers.Read(module, br, context);
return ReadType(module, br, context).__MakeArrayType(br.ReadCompressedUInt(), ReadArraySizes(br), ReadArrayBounds(br), mods);
case ELEMENT_TYPE_PTR:
mods = CustomModifiers.Read(module, br, context);
return ReadTypeOrVoid(module, br, context).__MakePointerType(mods);
case ELEMENT_TYPE_FNPTR:
return ReadFunctionPointer(module, br, context);
default:
throw new BadImageFormatException();
}
}
protected static void ReadCustomModifiers(ModuleReader module, ByteReader br, IGenericContext context, out Type[] requiredCustomModifiers, out Type[] optionalCustomModifiers)
{
byte b = br.PeekByte();
if (IsCustomModifier(b))
{
List<Type> required = new List<Type>();
List<Type> optional = new List<Type>();
while (IsCustomModifier(b))
{
br.ReadByte();
Type type = ReadTypeDefOrRefEncoded(module, br, context);
if (b == ELEMENT_TYPE_CMOD_REQD)
{
required.Add(type);
}
else
{
optional.Add(type);
}
b = br.PeekByte();
}
requiredCustomModifiers = required.ToArray();
optionalCustomModifiers = optional.ToArray();
}
else
{
requiredCustomModifiers = null;
optionalCustomModifiers = null;
}
}
private static CustomModifiers ReadCustomModifiers(ModuleReader module, ByteReader br, IGenericContext context)
{
CustomModifiers mods = new CustomModifiers();
byte b = br.PeekByte();
if (IsCustomModifier(b))
{
List<Type> required = new List<Type>();
List<Type> optional = new List<Type>();
while (IsCustomModifier(b))
{
bool req = br.ReadByte() == ELEMENT_TYPE_CMOD_REQD;
Type type = ReadTypeDefOrRefEncoded(module, br, context);
(req ? required : optional).Add(type);
b = br.PeekByte();
}
mods.required = required.ToArray();
mods.optional = optional.ToArray();
}
return mods;
}
private static Type ReadFunctionPointer(ModuleReader module, ByteReader br, IGenericContext context)
{
// TODO like .NET we return System.IntPtr here, but ideally we should fire an event in Universe that
// the user can hook to provide a custom type (or we simply should build in full support for function pointer types)
MethodSignature.ReadStandAloneMethodSig(module, br, context);
return module.universe.System_IntPtr;
}
internal ManifestResourceInfo(ModuleReader module, int index)
{
this.module = module;
this.index = index;
}
internal RawModule(ModuleReader module)
{
this.module = module;
}
internal static void ReadLocalVarSig(ModuleReader module, ByteReader br, IGenericContext context, List<LocalVariableInfo> list)
{
if (br.Length < 2 || br.ReadByte() != LOCAL_SIG)
{
throw new BadImageFormatException("Invalid local variable signature");
}
int count = br.ReadCompressedUInt();
for (int i = 0; i < count; i++)
{
if (br.PeekByte() == ELEMENT_TYPE_TYPEDBYREF)
{
br.ReadByte();
list.Add(new LocalVariableInfo(i, module.universe.System_TypedReference, false, new CustomModifiers()));
}
else
{
CustomModifiers mods1 = CustomModifiers.Read(module, br, context);
bool pinned = false;
if (br.PeekByte() == ELEMENT_TYPE_PINNED)
{
br.ReadByte();
pinned = true;
}
CustomModifiers mods2 = CustomModifiers.Read(module, br, context);
Type type = ReadTypeOrByRef(module, br, context);
list.Add(new LocalVariableInfo(i, type, pinned, CustomModifiers.Combine(mods1, mods2)));
}
}
}
internal MethodDefImpl(ModuleReader module, TypeDefImpl declaringType, int index)
{
this.module = module;
this.index = index;
this.declaringType = declaringType;
}
protected static Type ReadParam(ModuleReader module, ByteReader br, IGenericContext context)
{
switch (br.PeekByte())
{
case ELEMENT_TYPE_TYPEDBYREF:
br.ReadByte();
return module.universe.System_TypedReference;
default:
return ReadTypeOrByRef(module, br, context);
}
}
internal RawModule(ModuleReader module)
{
this.module = module;
this.isManifestModule = module.Assembly != null;
}
// this reads just the optional parameter types, from a MethodRefSig
internal static Type[] ReadOptionalParameterTypes(ModuleReader module, ByteReader br, IGenericContext context, out CustomModifiers[] customModifiers)
{
br.ReadByte();
int paramCount = br.ReadCompressedUInt();
CustomModifiers.Skip(br);
ReadRetType(module, br, context);
for (int i = 0; i < paramCount; i++)
{
if (br.PeekByte() == SENTINEL)
{
br.ReadByte();
Type[] types = new Type[paramCount - i];
customModifiers = new CustomModifiers[types.Length];
for (int j = 0; j < types.Length; j++)
{
customModifiers[j] = CustomModifiers.Read(module, br, context);
types[j] = ReadType(module, br, context);
}
return types;
}
CustomModifiers.Skip(br);
ReadType(module, br, context);
}
customModifiers = Empty<CustomModifiers>.Array;
return Type.EmptyTypes;
}
internal GenericTypeParameter(ModuleReader module, int index, byte sigElementType)
: base(sigElementType)
{
this.module = module;
this.index = index;
}
private Module LoadModule(int index, byte[] rawModule, string location)
{
if ((manifestModule.File.records[index].Flags & ContainsNoMetaData) != 0)
{
return externalModules[index] = new ResourceModule(manifestModule, index, location);
}
else
{
if (rawModule == null)
{
rawModule = File.ReadAllBytes(location);
}
return externalModules[index] = new ModuleReader(this, manifestModule.universe, new MemoryStream(rawModule), location);
}
}
internal Type GetType(ModuleReader module)
{
return type ?? (type = module.ResolveExportedType(index));
}
public static AssemblyName GetAssemblyName(string path)
{
try
{
path = Path.GetFullPath(path);
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
ModuleReader module = new ModuleReader(null, null, fs, path, false);
if (module.Assembly == null)
{
throw new BadImageFormatException("Module does not contain a manifest");
}
return module.Assembly.GetName();
}
}
catch (IOException x)
{
throw new FileNotFoundException(x.Message, x);
}
catch (UnauthorizedAccessException x)
{
throw new FileNotFoundException(x.Message, x);
}
}
private static Type ReadFunctionPointer(ModuleReader module, ByteReader br, IGenericContext context)
{
__StandAloneMethodSig sig = MethodSignature.ReadStandAloneMethodSig(module, br, context);
if (module.universe.EnableFunctionPointers)
{
return FunctionPointerType.Make(module.universe, sig);
}
else
{
// by default, like .NET we return System.IntPtr here
return module.universe.System_IntPtr;
}
}
internal static __StandAloneMethodSig ReadStandAloneMethodSig(ModuleReader module, ByteReader br, IGenericContext context)
{
CallingConventions callingConvention = 0;
System.Runtime.InteropServices.CallingConvention unmanagedCallingConvention = 0;
bool unmanaged;
byte flags = br.ReadByte();
switch (flags & 7)
{
case DEFAULT:
callingConvention = CallingConventions.Standard;
unmanaged = false;
break;
case 0x01: // C
unmanagedCallingConvention = System.Runtime.InteropServices.CallingConvention.Cdecl;
unmanaged = true;
break;
case 0x02: // STDCALL
unmanagedCallingConvention = System.Runtime.InteropServices.CallingConvention.StdCall;
unmanaged = true;
break;
case 0x03: // THISCALL
unmanagedCallingConvention = System.Runtime.InteropServices.CallingConvention.ThisCall;
unmanaged = true;
break;
case 0x04: // FASTCALL
unmanagedCallingConvention = System.Runtime.InteropServices.CallingConvention.FastCall;
unmanaged = true;
break;
case VARARG:
callingConvention = CallingConventions.VarArgs;
unmanaged = false;
break;
default:
throw new BadImageFormatException();
}
if ((flags & HASTHIS) != 0)
{
callingConvention |= CallingConventions.HasThis;
}
if ((flags & EXPLICITTHIS) != 0)
{
callingConvention |= CallingConventions.ExplicitThis;
}
if ((flags & GENERIC) != 0)
{
throw new BadImageFormatException();
}
int paramCount = br.ReadCompressedInt();
SkipCustomModifiers(br);
Type returnType = ReadRetType(module, br, context);
List<Type> parameterTypes = new List<Type>();
List<Type> optionalParameterTypes = new List<Type>();
List<Type> curr = parameterTypes;
for (int i = 0; i < paramCount; i++)
{
if (br.PeekByte() == SENTINEL)
{
br.ReadByte();
curr = optionalParameterTypes;
}
SkipCustomModifiers(br);
curr.Add(ReadParam(module, br, context));
}
return new __StandAloneMethodSig(unmanaged, unmanagedCallingConvention, callingConvention, returnType, parameterTypes.ToArray(), optionalParameterTypes.ToArray());
}
internal static Type[] ReadMethodSpec(ModuleReader module, ByteReader br, IGenericContext context)
{
if (br.ReadByte() != GENERICINST)
{
throw new BadImageFormatException();
}
Type[] args = new Type[br.ReadCompressedUInt()];
for (int i = 0; i < args.Length; i++)
{
CustomModifiers.Skip(br);
args[i] = ReadType(module, br, context);
}
return args;
}
internal PropertyInfoImpl(ModuleReader module, Type declaringType, int index)
{
this.module = module;
this.declaringType = declaringType;
this.index = index;
}
internal EventInfoImpl(ModuleReader module, Type declaringType, int index)
{
this.module = module;
this.declaringType = declaringType;
this.index = index;
}
internal FieldDefImpl(ModuleReader module, TypeDefImpl declaringType, int index)
{
this.module = module;
this.declaringType = declaringType;
this.index = index;
}
internal static Type ReadTypeSpec(ModuleReader module, ByteReader br, IGenericContext context)
{
// LAMESPEC a TypeSpec can contain custom modifiers (C++/CLI generates "newarr (TypeSpec with custom modifiers)")
CustomModifiers.Skip(br);
// LAMESPEC anything can be adorned by (useless) custom modifiers
// also, VAR and MVAR are also used in TypeSpec (contrary to what the spec says)
return ReadType(module, br, context);
}
