return null;
}
- public bool __TryReadTypeName(out string ns, out string name)
+ [Obsolete("Use Constructor.DeclaringType instead.")]
+ internal bool __TryReadTypeName(out string ns, out string name)
{
- if (lazyConstructor == null)
- {
- ModuleReader mod = module as ModuleReader;
- if (mod != null)
- {
- // Note that we only need to manually handle the MemberRef case here,
- // because a MethodDef will result in a lazy MethodInfo object being returned
- // when the constructor is resolved, so we can safely do that without
- // triggering an assembly load.
- int methodToken = mod.CustomAttribute.records[index].Type;
- if ((methodToken >> 24) == MemberRefTable.Index)
- {
- int methodIndex = (methodToken & 0xFFFFFF) - 1;
- int typeToken = mod.MemberRef.records[methodIndex].Class;
- if ((typeToken >> 24) == TypeRefTable.Index)
- {
- int typeIndex = (typeToken & 0xFFFFFF) - 1;
- if ((mod.TypeRef.records[typeIndex].ResolutionScope >> 24) == TypeRefTable.Index)
- {
- // nested types can't be represented using only a namespace and name,
- // so we fail
- ns = null;
- name = null;
- return false;
- }
- int typeNameSpace = mod.TypeRef.records[typeIndex].TypeNameSpace;
- ns = typeNameSpace == 0 ? null : mod.GetString(typeNameSpace);
- name = mod.GetString(mod.TypeRef.records[typeIndex].TypeName);
- return true;
- }
- }
- }
- }
if (Constructor.DeclaringType.IsNested)
{
ns = null;
return true;
}
+ // for use by mcs
+ internal byte[] __GetBlob()
+ {
+ return ((ModuleReader)module).GetBlobCopy(module.CustomAttribute.records[index].Value);
+ }
+
public ConstructorInfo Constructor
{
get
return methodBuilder.GetILGenerator(streamSize);
}
+ public void __ReleaseILGenerator()
+ {
+ methodBuilder.__ReleaseILGenerator();
+ }
+
public override CallingConventions CallingConvention
{
get { return methodBuilder.CallingConvention; }
private readonly FieldBuilder fieldBuilder;
internal EnumBuilder(TypeBuilder typeBuilder, FieldBuilder fieldBuilder)
+ : base(typeBuilder)
{
this.typeBuilder = typeBuilder;
this.fieldBuilder = fieldBuilder;
get { return typeBuilder.FullName; }
}
- public override Type UnderlyingSystemType
- {
- get { return typeBuilder.UnderlyingSystemType; }
- }
-
public override Type BaseType
{
get { return typeBuilder.BaseType; }
/*
- Copyright (C) 2008-2010 Jeroen Frijters
+ Copyright (C) 2008-2011 Jeroen Frijters
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
{
private readonly TypeBuilder typeBuilder;
private readonly string name;
- private readonly int nameIndex;
private readonly int pseudoToken;
+ private int nameIndex;
private int signature;
private Type returnType;
private Type[] parameterTypes;
private MethodAttributes attributes;
private MethodImplAttributes implFlags;
private ILGenerator ilgen;
- private int rva;
+ private int rva = -1;
private readonly CallingConventions callingConvention;
private List<ParameterBuilder> parameters;
private GenericTypeParameterBuilder[] gtpb;
this.typeBuilder = typeBuilder;
this.name = name;
this.pseudoToken = typeBuilder.ModuleBuilder.AllocPseudoToken();
- // because all the MethodBuilders constitute a virtual MethodDef table, we cannot allocate the string during WriteMethodDefRecord,
- // since by then the metadata has already been frozen
- this.nameIndex = typeBuilder.ModuleBuilder.Strings.Add(name);
this.attributes = attributes;
if ((attributes & MethodAttributes.Static) == 0)
{
public ILGenerator GetILGenerator(int streamSize)
{
+ if (rva != -1)
+ {
+ throw new InvalidOperationException();
+ }
if (ilgen == null)
{
ilgen = new ILGenerator(typeBuilder.ModuleBuilder, streamSize);
return ilgen;
}
+ public void __ReleaseILGenerator()
+ {
+ if (ilgen != null)
+ {
+ if (this.ModuleBuilder.symbolWriter != null)
+ {
+ this.ModuleBuilder.symbolWriter.OpenMethod(new SymbolToken(-pseudoToken | 0x06000000));
+ }
+ rva = ilgen.WriteBody(initLocals);
+ if (this.ModuleBuilder.symbolWriter != null)
+ {
+ this.ModuleBuilder.symbolWriter.CloseMethod();
+ }
+ ilgen = null;
+ }
+ }
+
public void SetCustomAttribute(ConstructorInfo con, byte[] binaryAttribute)
{
SetCustomAttribute(new CustomAttributeBuilder(con, binaryAttribute));
const short BestFitOff = 0x0020;
const short CharMapErrorOn = 0x1000;
const short CharMapErrorOff = 0x2000;
- int name = this.nameIndex;
short flags = CharSetNotSpec | CallConvWinapi;
if (bestFitMapping.HasValue)
{
break;
}
}
- if (entryName != null)
- {
- name = this.ModuleBuilder.Strings.Add(entryName);
- }
if (exactSpelling.HasValue && exactSpelling.Value)
{
flags |= NoMangle;
ImplMapTable.Record rec = new ImplMapTable.Record();
rec.MappingFlags = flags;
rec.MemberForwarded = pseudoToken;
- rec.ImportName = name;
+ rec.ImportName = this.ModuleBuilder.Strings.Add(entryName ?? name);
rec.ImportScope = this.ModuleBuilder.ModuleRef.FindOrAddRecord(dllName == null ? 0 : this.ModuleBuilder.Strings.Add(dllName));
this.ModuleBuilder.ImplMap.AddRecord(rec);
}
internal void Bake()
{
+ this.nameIndex = this.ModuleBuilder.Strings.Add(name);
this.signature = this.ModuleBuilder.GetSignatureBlobIndex(this.MethodSignature);
- if (ilgen != null)
- {
- if (this.ModuleBuilder.symbolWriter != null)
- {
- this.ModuleBuilder.symbolWriter.OpenMethod(new SymbolToken(-pseudoToken | 0x06000000));
- }
- rva = ilgen.WriteBody(initLocals);
- if (this.ModuleBuilder.symbolWriter != null)
- {
- this.ModuleBuilder.symbolWriter.CloseMethod();
- }
- ilgen = null;
- }
- else
- {
- rva = -1;
- }
+ __ReleaseILGenerator();
if (declarativeSecurity != null)
{
get { return DeclaringType.Namespace; }
}
- public override Type UnderlyingSystemType
- {
- get { return this; }
- }
-
public override string Name
{
get { return name; }
sealed class BakedType : Type
{
- private readonly TypeBuilder typeBuilder;
-
internal BakedType(TypeBuilder typeBuilder)
+ : base(typeBuilder)
{
- this.typeBuilder = typeBuilder;
}
public override string AssemblyQualifiedName
{
- get { return typeBuilder.AssemblyQualifiedName; }
+ get { return underlyingType.AssemblyQualifiedName; }
}
public override Type BaseType
{
- get { return typeBuilder.BaseType; }
+ get { return underlyingType.BaseType; }
}
public override string __Name
{
- get { return typeBuilder.__Name; }
+ get { return underlyingType.__Name; }
}
public override string __Namespace
{
- get { return typeBuilder.__Namespace; }
+ get { return underlyingType.__Namespace; }
}
public override string Name
{
// we need to escape here, because TypeBuilder.Name does not escape
- get { return TypeNameParser.Escape(typeBuilder.__Name); }
+ get { return TypeNameParser.Escape(underlyingType.__Name); }
}
public override string FullName
public override TypeAttributes Attributes
{
- get { return typeBuilder.Attributes; }
+ get { return underlyingType.Attributes; }
}
public override Type[] __GetDeclaredInterfaces()
{
- return typeBuilder.__GetDeclaredInterfaces();
+ return underlyingType.__GetDeclaredInterfaces();
}
public override MethodBase[] __GetDeclaredMethods()
{
- return typeBuilder.__GetDeclaredMethods();
+ return underlyingType.__GetDeclaredMethods();
}
public override __MethodImplMap __GetMethodImplMap()
{
- return typeBuilder.__GetMethodImplMap();
+ return underlyingType.__GetMethodImplMap();
}
public override FieldInfo[] __GetDeclaredFields()
{
- return typeBuilder.__GetDeclaredFields();
+ return underlyingType.__GetDeclaredFields();
}
public override EventInfo[] __GetDeclaredEvents()
{
- return typeBuilder.__GetDeclaredEvents();
+ return underlyingType.__GetDeclaredEvents();
}
public override PropertyInfo[] __GetDeclaredProperties()
{
- return typeBuilder.__GetDeclaredProperties();
+ return underlyingType.__GetDeclaredProperties();
}
public override Type[] __GetDeclaredTypes()
{
- return typeBuilder.__GetDeclaredTypes();
+ return underlyingType.__GetDeclaredTypes();
}
public override Type DeclaringType
{
- get { return typeBuilder.DeclaringType; }
+ get { return underlyingType.DeclaringType; }
}
public override StructLayoutAttribute StructLayoutAttribute
{
- get { return typeBuilder.StructLayoutAttribute; }
- }
-
- public override Type UnderlyingSystemType
- {
- // Type.Equals/GetHashCode relies on this
- get { return typeBuilder; }
+ get { return underlyingType.StructLayoutAttribute; }
}
public override Type[] GetGenericArguments()
{
- return typeBuilder.GetGenericArguments();
+ return underlyingType.GetGenericArguments();
}
internal override Type GetGenericTypeArgument(int index)
{
- return typeBuilder.GetGenericTypeArgument(index);
+ return underlyingType.GetGenericTypeArgument(index);
}
public override Type[][] __GetGenericArgumentsOptionalCustomModifiers()
{
- return typeBuilder.__GetGenericArgumentsOptionalCustomModifiers();
+ return underlyingType.__GetGenericArgumentsOptionalCustomModifiers();
}
public override Type[][] __GetGenericArgumentsRequiredCustomModifiers()
{
- return typeBuilder.__GetGenericArgumentsRequiredCustomModifiers();
+ return underlyingType.__GetGenericArgumentsRequiredCustomModifiers();
}
public override bool IsGenericType
{
- get { return typeBuilder.IsGenericType; }
+ get { return underlyingType.IsGenericType; }
}
public override bool IsGenericTypeDefinition
{
- get { return typeBuilder.IsGenericTypeDefinition; }
+ get { return underlyingType.IsGenericTypeDefinition; }
}
public override bool ContainsGenericParameters
{
- get { return typeBuilder.ContainsGenericParameters; }
+ get { return underlyingType.ContainsGenericParameters; }
}
public override int MetadataToken
{
- get { return typeBuilder.MetadataToken; }
+ get { return underlyingType.MetadataToken; }
}
public override Module Module
{
- get { return typeBuilder.Module; }
+ get { return underlyingType.Module; }
}
internal override int GetModuleBuilderToken()
{
- return typeBuilder.GetModuleBuilderToken();
+ return underlyingType.GetModuleBuilderToken();
}
}
}
get { return callingConvention; }
}
+ internal int GenericParameterCount
+ {
+ get { return genericParamCount; }
+ }
+
private sealed class Binder : IGenericBinder
{
private readonly Type declaringType;
-/*
+/*
Copyright (C) 2011 Jeroen Frijters
This software is provided 'as-is', without any express or implied
*/
using System;
-using System.Text;
using System.Collections.Generic;
using System.Runtime.InteropServices;
private readonly Type declaringType;
private readonly string name;
private readonly MethodSignature signature;
+ private MethodInfo forwarder;
internal MissingMethod(Type declaringType, string name, MethodSignature signature)
{
this.signature = signature;
}
+ private MethodInfo Forwarder
+ {
+ get
+ {
+ MethodInfo method = TryGetForwarder();
+ if (method == null)
+ {
+ throw new MissingMemberException(this);
+ }
+ return method;
+ }
+ }
+
+ private MethodInfo TryGetForwarder()
+ {
+ if (forwarder == null && !declaringType.__IsMissing)
+ {
+ MethodBase mb = declaringType.FindMethod(name, signature);
+ ConstructorInfo ci = mb as ConstructorInfo;
+ if (ci != null)
+ {
+ forwarder = ci.GetMethodInfo();
+ }
+ else
+ {
+ forwarder = (MethodInfo)mb;
+ }
+ }
+ return forwarder;
+ }
+
public override bool __IsMissing
{
- get { return true; }
+ get { return TryGetForwarder() == null; }
}
public override Type ReturnType
internal override int ParameterCount
{
- get { throw new MissingMemberException(this); }
+ get { return signature.GetParameterCount(); }
}
private sealed class ParameterInfoImpl : ParameterInfo
this.index = index;
}
+ private ParameterInfo Forwarder
+ {
+ get { return index == -1 ? method.Forwarder.ReturnParameter : method.Forwarder.GetParameters()[index]; }
+ }
+
public override string Name
{
- get { throw new MissingMemberException(method); }
+ get { return Forwarder.Name; }
}
public override Type ParameterType
public override ParameterAttributes Attributes
{
- get { throw new MissingMemberException(method); }
+ get { return Forwarder.Attributes; }
}
public override int Position
public override object RawDefaultValue
{
- get { throw new MissingMemberException(method); }
+ get { return Forwarder.RawDefaultValue; }
}
public override Type[] GetOptionalCustomModifiers()
public override int MetadataToken
{
- get { throw new MissingMemberException(method); }
+ get { return Forwarder.MetadataToken; }
}
internal override Module Module
{
get { return method.Module; }
}
+
+ internal override IList<CustomAttributeData> GetCustomAttributesData(Type attributeType)
+ {
+ return Forwarder.GetCustomAttributesData(attributeType);
+ }
+
+ public override string ToString()
+ {
+ return Forwarder.ToString();
+ }
}
public override ParameterInfo[] GetParameters()
{
- ParameterInfoImpl[] parameters = new ParameterInfoImpl[signature.GetParameterCount()];
+ ParameterInfo[] parameters = new ParameterInfo[signature.GetParameterCount()];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new ParameterInfoImpl(this, i);
public override MethodAttributes Attributes
{
- get { throw new MissingMemberException(this); }
+ get { return Forwarder.Attributes; }
}
public override MethodImplAttributes GetMethodImplementationFlags()
{
- throw new MissingMemberException(this);
+ return Forwarder.GetMethodImplementationFlags();
}
public override MethodBody GetMethodBody()
{
- throw new MissingMemberException(this);
+ return Forwarder.GetMethodBody();
}
public override CallingConventions CallingConvention
internal override int ImportTo(IKVM.Reflection.Emit.ModuleBuilder module)
{
- throw new MissingMemberException(this);
+ return Forwarder.ImportTo(module);
}
public override string Name
{
return declaringType.GetHashCode() ^ name.GetHashCode() ^ signature.GetHashCode();
}
+
+ internal override MethodBase BindTypeParameters(Type type)
+ {
+ return Forwarder.BindTypeParameters(type);
+ }
+
+ public override bool ContainsGenericParameters
+ {
+ get { return Forwarder.ContainsGenericParameters; }
+ }
+
+ internal override IList<CustomAttributeData> GetCustomAttributesData(Type attributeType)
+ {
+ return Forwarder.GetCustomAttributesData(attributeType);
+ }
+
+ public override Type[] GetGenericArguments()
+ {
+ return Forwarder.GetGenericArguments();
+ }
+
+ internal override Type GetGenericMethodArgument(int index)
+ {
+ return Forwarder.GetGenericMethodArgument(index);
+ }
+
+ internal override int GetGenericMethodArgumentCount()
+ {
+ return Forwarder.GetGenericMethodArgumentCount();
+ }
+
+ public override MethodInfo GetGenericMethodDefinition()
+ {
+ return Forwarder.GetGenericMethodDefinition();
+ }
+
+ internal override MethodInfo GetMethodOnTypeDefinition()
+ {
+ return Forwarder.GetMethodOnTypeDefinition();
+ }
+
+ internal override bool HasThis
+ {
+ get { return Forwarder.HasThis; }
+ }
+
+ public override bool IsGenericMethod
+ {
+ get { return IsGenericMethodDefinition; }
+ }
+
+ public override bool IsGenericMethodDefinition
+ {
+ get { return signature.GenericParameterCount != 0; }
+ }
+
+ public override MethodInfo MakeGenericMethod(params Type[] typeArguments)
+ {
+ return Forwarder.MakeGenericMethod(typeArguments);
+ }
+
+ public override int MetadataToken
+ {
+ get { return Forwarder.MetadataToken; }
+ }
}
}
get { return TypeAttributes.Public; }
}
- public sealed override Type UnderlyingSystemType
- {
- get { return this; }
- }
-
public sealed override string FullName
{
get { return null; }
/*
- Copyright (C) 2009 Jeroen Frijters
+ Copyright (C) 2009-2011 Jeroen Frijters
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
{
sealed class MetadataReader : MetadataRW
{
- private readonly BinaryReader br;
+ private readonly Stream stream;
+ private const int bufferLength = 2048;
+ private readonly byte[] buffer = new byte[bufferLength];
+ private int pos = bufferLength;
- internal MetadataReader(ModuleReader module, BinaryReader br, byte heapSizes)
+ internal MetadataReader(ModuleReader module, Stream stream, byte heapSizes)
: base(module, (heapSizes & 0x01) != 0, (heapSizes & 0x02) != 0, (heapSizes & 0x04) != 0)
{
- this.br = br;
+ this.stream = stream;
}
- internal short ReadInt16()
+ private void FillBuffer(int needed)
{
- return br.ReadInt16();
+ int count = bufferLength - pos;
+ if (count != 0)
+ {
+ // move remaining bytes to the front of the buffer
+ Buffer.BlockCopy(buffer, pos, buffer, 0, count);
+ }
+ pos = 0;
+
+ while (count < needed)
+ {
+ int len = stream.Read(buffer, count, bufferLength - count);
+ if (len == 0)
+ {
+ throw new BadImageFormatException();
+ }
+ count += len;
+ }
+
+ if (count != bufferLength)
+ {
+ // we didn't fill the buffer completely, so have to restore the invariant
+ // that all data from pos up until the end of the buffer is valid
+ Buffer.BlockCopy(buffer, 0, buffer, bufferLength - count, count);
+ pos = bufferLength - count;
+ }
}
internal ushort ReadUInt16()
{
- return br.ReadUInt16();
+ return (ushort)ReadInt16();
}
- internal int ReadInt32()
+ internal short ReadInt16()
{
- return br.ReadInt32();
+ if (pos > bufferLength - 2)
+ {
+ FillBuffer(2);
+ }
+ byte b1 = buffer[pos++];
+ byte b2 = buffer[pos++];
+ return (short)(b1 | (b2 << 8));
}
- internal int ReadStringIndex()
+ internal int ReadInt32()
{
- if (bigStrings)
- {
- return br.ReadInt32();
- }
- else
+ if (pos > bufferLength - 4)
{
- return br.ReadUInt16();
+ FillBuffer(4);
}
+ byte b1 = buffer[pos++];
+ byte b2 = buffer[pos++];
+ byte b3 = buffer[pos++];
+ byte b4 = buffer[pos++];
+ return b1 | (b2 << 8) | (b3 << 16) | (b4 << 24);
}
- internal int ReadGuidIndex()
+ private int ReadIndex(bool big)
{
- if (bigGuids)
+ if (big)
{
- return br.ReadInt32();
+ return ReadInt32();
}
else
{
- return br.ReadUInt16();
+ return ReadUInt16();
}
}
+ internal int ReadStringIndex()
+ {
+ return ReadIndex(bigStrings);
+ }
+
+ internal int ReadGuidIndex()
+ {
+ return ReadIndex(bigGuids);
+ }
+
internal int ReadBlobIndex()
{
- if (bigBlobs)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigBlobs);
}
internal int ReadResolutionScope()
{
- int codedIndex;
- if (bigResolutionScope)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigResolutionScope);
switch (codedIndex & 3)
{
case 0:
internal int ReadTypeDefOrRef()
{
- int codedIndex;
- if (bigTypeDefOrRef)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigTypeDefOrRef);
switch (codedIndex & 3)
{
case 0:
internal int ReadMemberRefParent()
{
- int codedIndex;
- if (bigMemberRefParent)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigMemberRefParent);
switch (codedIndex & 7)
{
case 0:
internal int ReadHasCustomAttribute()
{
- int codedIndex;
- if (bigHasCustomAttribute)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigHasCustomAttribute);
switch (codedIndex & 31)
{
case 0:
internal int ReadCustomAttributeType()
{
- int codedIndex;
- if (bigCustomAttributeType)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigCustomAttributeType);
switch (codedIndex & 7)
{
case 2:
internal int ReadMethodDefOrRef()
{
- int codedIndex;
- if (bigMethodDefOrRef)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigMethodDefOrRef);
switch (codedIndex & 1)
{
case 0:
internal int ReadHasConstant()
{
- int codedIndex;
- if (bigHasConstant)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigHasConstant);
switch (codedIndex & 3)
{
case 0:
internal int ReadHasSemantics()
{
- int codedIndex;
- if (bigHasSemantics)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigHasSemantics);
switch (codedIndex & 1)
{
case 0:
internal int ReadHasFieldMarshal()
{
- int codedIndex;
- if (bigHasFieldMarshal)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigHasFieldMarshal);
switch (codedIndex & 1)
{
case 0:
internal int ReadHasDeclSecurity()
{
- int codedIndex;
- if (bigHasDeclSecurity)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigHasDeclSecurity);
switch (codedIndex & 3)
{
case 0:
internal int ReadTypeOrMethodDef()
{
- int codedIndex;
- if (bigTypeOrMethodDef)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigTypeOrMethodDef);
switch (codedIndex & 1)
{
case 0:
internal int ReadMemberForwarded()
{
- int codedIndex;
- if (bigMemberForwarded)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigMemberForwarded);
switch (codedIndex & 1)
{
case 0:
internal int ReadImplementation()
{
- int codedIndex;
- if (bigImplementation)
- {
- codedIndex = br.ReadInt32();
- }
- else
- {
- codedIndex = br.ReadUInt16();
- }
+ int codedIndex = ReadIndex(bigImplementation);
switch (codedIndex & 3)
{
case 0:
}
}
- private int ReadToken(int table, bool big)
- {
- int rid;
- if (big)
- {
- rid = br.ReadInt32();
- }
- else
- {
- rid = br.ReadUInt16();
- }
- return rid | (table << 24);
- }
-
internal int ReadField()
{
- if (bigField)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigField);
}
internal int ReadMethodDef()
{
- if (bigMethodDef)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigMethodDef);
}
internal int ReadParam()
{
- if (bigParam)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigParam);
}
internal int ReadProperty()
{
- if (bigProperty)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigProperty);
}
internal int ReadEvent()
{
- if (bigEvent)
- {
- return br.ReadInt32();
- }
- else
- {
- return br.ReadUInt16();
- }
+ return ReadIndex(bigEvent);
}
internal int ReadTypeDef()
{
- return ReadToken(TypeDefTable.Index, bigTypeDef);
+ return ReadIndex(bigTypeDef) | (TypeDefTable.Index << 24);
}
internal int ReadGenericParam()
{
- return ReadToken(GenericParamTable.Index, bigGenericParam);
+ return ReadIndex(bigGenericParam) | (GenericParamTable.Index << 24);
}
internal int ReadModuleRef()
{
- return ReadToken(ModuleRefTable.Index, bigModuleRef);
+ return ReadIndex(bigModuleRef) | (ModuleRefTable.Index << 24);
}
}
}
tables[i].RowCount = 0;
}
}
- MetadataReader mr = new MetadataReader(this, br, HeapSizes);
+ MetadataReader mr = new MetadataReader(this, br.BaseStream, HeapSizes);
for (int i = 0; i < 64; i++)
{
if ((Valid & (1UL << i)) != 0)
}
type = type.BaseType;
} while (type != null);
- throw new MissingMethodException(org.ToString(), name);
+ return universe.GetMissingMethodOrThrow(org, name, methodSig);
}
}
get { return GetFullName(); }
}
- public override Type UnderlyingSystemType
- {
- get { return this; }
- }
-
public override int MetadataToken
{
get { return (TypeDefTable.Index << 24) + index + 1; }
{
bb.Write(ELEMENT_TYPE_VOID);
}
+ else if (type == u.System_Int32)
+ {
+ bb.Write(ELEMENT_TYPE_I4);
+ }
else if (type == u.System_Boolean)
{
bb.Write(ELEMENT_TYPE_BOOLEAN);
}
+ else if (type == u.System_String)
+ {
+ bb.Write(ELEMENT_TYPE_STRING);
+ }
else if (type == u.System_Char)
{
bb.Write(ELEMENT_TYPE_CHAR);
{
bb.Write(ELEMENT_TYPE_U2);
}
- else if (type == u.System_Int32)
- {
- bb.Write(ELEMENT_TYPE_I4);
- }
else if (type == u.System_UInt32)
{
bb.Write(ELEMENT_TYPE_U4);
{
bb.Write(ELEMENT_TYPE_R8);
}
- else if (type == u.System_String)
- {
- bb.Write(ELEMENT_TYPE_STRING);
- }
else if (type == u.System_IntPtr)
{
bb.Write(ELEMENT_TYPE_I);
public abstract class Type : MemberInfo, IGenericContext, IGenericBinder
{
public static readonly Type[] EmptyTypes = Empty<Type>.Array;
+ protected readonly Type underlyingType;
// prevent subclassing by outsiders
internal Type()
{
+ this.underlyingType = this;
+ }
+
+ internal Type(Type underlyingType)
+ {
+ this.underlyingType = underlyingType;
}
public static Binder DefaultBinder
get { return null; }
}
- public virtual Type UnderlyingSystemType
+ public Type UnderlyingSystemType
{
- get { return this; }
+ get { return underlyingType; }
}
public override Type DeclaringType
throw new InvalidOperationException();
}
+ public static bool operator ==(Type t1, Type t2)
+ {
+ // Casting to object results in smaller code than calling ReferenceEquals and makes
+ // this method more likely to be inlined.
+ // On CLR v2 x86, microbenchmarks show this to be faster than calling ReferenceEquals.
+ return (object)t1 == (object)t2
+ || ((object)t1 != null && (object)t2 != null && (object)t1.underlyingType == (object)t2.underlyingType);
+ }
+
+ public static bool operator !=(Type t1, Type t2)
+ {
+ return !(t1 == t2);
+ }
+
public bool Equals(Type type)
{
- return !ReferenceEquals(type, null) && ReferenceEquals(type.UnderlyingSystemType, this.UnderlyingSystemType);
+ return this == type;
}
public override bool Equals(object obj)
get { return type.Namespace; }
}
- public override Type UnderlyingSystemType
- {
- get { return this; }
- }
-
public override string Name
{
get { return type.Name; }
private readonly Dictionary<string, Assembly> assembliesByName = new Dictionary<string, Assembly>();
private readonly Dictionary<System.Type, Type> importedTypes = new Dictionary<System.Type, Type>();
private Dictionary<ScopedTypeName, Type> missingTypes;
- private bool resolveMissingTypes;
+ private bool resolveMissingMembers;
private Type typeof_System_Object;
private Type typeof_System_ValueType;
private Type typeof_System_Enum;
return asm;
}
- public void EnableMissingTypeResolution()
+ public void EnableMissingMemberResolution()
{
- resolveMissingTypes = true;
+ resolveMissingMembers = true;
}
private struct ScopedTypeName : IEquatable<ScopedTypeName>
internal Type GetMissingTypeOrThrow(Module module, Type declaringType, TypeName typeName)
{
- if (resolveMissingTypes || module.Assembly.__IsMissing)
+ if (resolveMissingMembers || module.Assembly.__IsMissing)
{
if (missingTypes == null)
{
}
throw new TypeLoadException(String.Format("Type '{0}' not found in assembly '{1}'", fullName, module.Assembly.FullName));
}
+
+ internal MethodBase GetMissingMethodOrThrow(Type declaringType, string name, MethodSignature signature)
+ {
+ if (resolveMissingMembers)
+ {
+ MethodInfo method = new MissingMethod(declaringType, name, signature);
+ if (name == ".ctor")
+ {
+ return new ConstructorInfoImpl(method);
+ }
+ return method;
+ }
+ throw new MissingMethodException(declaringType.ToString(), name);
+ }
}
}
internal void Write(short value)
{
- buffer[0] = (byte)value;
- buffer[1] = (byte)(value >> 8);
- stream.Write(buffer, 0, 2);
+ stream.WriteByte((byte)value);
+ stream.WriteByte((byte)(value >> 8));
}
internal void Write(uint value)
{
this.importer = importer;
domain = new Universe ();
- domain.EnableMissingTypeResolution ();
+ domain.EnableMissingMemberResolution ();
domain.AssemblyResolve += AssemblyReferenceResolver;
loaded_names = new List<Tuple<AssemblyName, string, Assembly>> ();
projects / mono.git / commitdiff