// 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 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 static PropertySignature ReadSig(ModuleReader module, ByteReader br, IGenericContext context) { byte flags = br.ReadByte(); if ((flags & PROPERTY) == 0) { throw new BadImageFormatException(); } CallingConventions callingConvention = CallingConventions.Standard; if ((flags & HASTHIS) != 0) { callingConvention |= CallingConventions.HasThis; } if ((flags & EXPLICITTHIS) != 0) { callingConvention |= CallingConventions.ExplicitThis; } Type returnType; Type[] parameterTypes; int paramCount = br.ReadCompressedUInt(); CustomModifiers[] mods = null; PackedCustomModifiers.Pack(ref mods, 0, CustomModifiers.Read(module, br, context), paramCount + 1); returnType = ReadRetType(module, br, context); parameterTypes = new Type[paramCount]; for (int i = 0; i < parameterTypes.Length; i++) { PackedCustomModifiers.Pack(ref mods, i + 1, CustomModifiers.Read(module, br, context), paramCount + 1); parameterTypes[i] = ReadParam(module, br, context); } return(new PropertySignature(callingConvention, returnType, parameterTypes, PackedCustomModifiers.Wrap(mods))); }
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.ReadCompressedUInt(); context = new UnboundGenericMethodContext(context); } int paramCount = br.ReadCompressedUInt(); CustomModifiers[] modifiers = null; PackedCustomModifiers.Pack(ref modifiers, 0, CustomModifiers.Read(module, br, context), paramCount + 1); returnType = ReadRetType(module, br, context); parameterTypes = new Type[paramCount]; 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; } PackedCustomModifiers.Pack(ref modifiers, i + 1, CustomModifiers.Read(module, br, context), paramCount + 1); parameterTypes[i] = ReadParam(module, br, context); } return(new MethodSignature(returnType, parameterTypes, PackedCustomModifiers.Wrap(modifiers), callingConvention, genericParamCount)); }
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)); }
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)); } }
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.ReadCompressedUInt(); Type[] args = new Type[genArgCount]; CustomModifiers[] mods = 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 cm = CustomModifiers.Read(module, br, context); if (!cm.IsEmpty) { if (mods == null) { mods = new CustomModifiers[genArgCount]; } mods[i] = cm; } args[i] = ReadType(module, br, context); } return(GenericTypeInstance.Make(type, args, mods)); }
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) 5; // 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.ReadCompressedUInt(); CustomModifiers[] customModifiers = null; PackedCustomModifiers.Pack(ref customModifiers, 0, CustomModifiers.Read(module, br, context), paramCount + 1); 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; } PackedCustomModifiers.Pack(ref customModifiers, i + 1, CustomModifiers.Read(module, br, context), paramCount + 1); curr.Add(ReadParam(module, br, context)); } return(new __StandAloneMethodSig(unmanaged, unmanagedCallingConvention, callingConvention, returnType, parameterTypes.ToArray(), optionalParameterTypes.ToArray(), PackedCustomModifiers.Wrap(customModifiers))); }
// 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(); } }