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); }