MethodSignature <TType> DecodeSignature <TType>(ISignatureTypeProvider <TType> provider, SignatureDecoderOptions options = SignatureDecoderOptions.None)
{
var decoder = new SignatureDecoder <TType>(provider, _reader, options);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeMethodSignature(ref blobReader));
}
internal ImmutableArray <TType> DecodeSignature <TType>(ISignatureTypeProvider <TType> provider)
{
var decoder = new Ecma335.SignatureDecoder <TType>(provider, _reader);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeMethodSpecificationSignature(ref blobReader));
}
// Decodes a type with custom modifiers starting with the first modifier type that is required iff isRequired is passed,\
// followed by an optional sequence of additional modifiers (<SignaureTypeCode.Required|OptionalModifier> <type>) and
// terminated by the unmodified type.
private static TType DecodeModifiedType <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider, bool isRequired)
{
TType type = DecodeTypeHandle(ref blobReader, provider, null);
var modifier = new CustomModifier <TType>(type, isRequired);
ImmutableArray <CustomModifier <TType> > modifiers;
int typeCode = blobReader.ReadCompressedInteger();
isRequired = typeCode == (int)SignatureTypeCode.RequiredModifier;
if (!isRequired && typeCode != (int)SignatureTypeCode.OptionalModifier)
{
// common case: 1 modifier.
modifiers = ImmutableArray.Create(modifier);
}
else
{
// uncommon case: multiple modifiers.
var builder = ImmutableArray.CreateBuilder <CustomModifier <TType> >();
builder.Add(modifier);
do
{
type = DecodeTypeHandle(ref blobReader, provider, null);
modifier = new CustomModifier <TType>(type, isRequired);
builder.Add(modifier);
typeCode = blobReader.ReadCompressedInteger();
isRequired = typeCode == (int)SignatureTypeCode.RequiredModifier;
} while (isRequired || typeCode == (int)SignatureTypeCode.OptionalModifier);
modifiers = builder.ToImmutable();
}
TType unmodifiedType = DecodeType(ref blobReader, typeCode, provider);
return(provider.GetModifiedType(unmodifiedType, modifiers));
}
public ImmutableArray <TType> DecodeSignature <TType, TGenericContext>(ISignatureTypeProvider <TType, TGenericContext> provider, TGenericContext genericContext)
{
var decoder = new Ecma335.SignatureDecoder <TType, TGenericContext>(provider, _reader, genericContext);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeMethodSpecificationSignature(ref blobReader));
}
internal TType DecodeSignature <TType>(ISignatureTypeProvider <TType> provider)
{
var decoder = new SignatureDecoder <TType>(provider, _reader);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeType(ref blobReader));
}
public TType DecodeSignature <TType>(ISignatureTypeProvider <TType> provider)
{
var decoder = new SignatureDecoder <TType>(provider, _reader);
var blob = _reader.GetBlobReader(Signature);
return(decoder.DecodeFieldSignature(ref blob));
}
// Decodes a generalized (non-SZ/vector) array type represented by the element type followed by
// its rank and optional sizes and lower bounds.
private static TType DecodeArrayType <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
TType elementType = DecodeType(ref blobReader, provider);
int rank = blobReader.ReadCompressedInteger();
var sizes = ImmutableArray <int> .Empty;
var lowerBounds = ImmutableArray <int> .Empty;
int sizesCount = blobReader.ReadCompressedInteger();
if (sizesCount > 0)
{
var array = new int[sizesCount];
for (int i = 0; i < sizesCount; i++)
{
array[i] = blobReader.ReadCompressedInteger();
}
sizes = ImmutableArray.Create(array);
}
int lowerBoundsCount = blobReader.ReadCompressedInteger();
if (lowerBoundsCount > 0)
{
var array = new int[lowerBoundsCount];
for (int i = 0; i < lowerBoundsCount; i++)
{
array[i] = blobReader.ReadCompressedSignedInteger();
}
lowerBounds = ImmutableArray.Create(array);
}
var arrayShape = new ArrayShape(rank, sizes, lowerBounds);
return(provider.GetArrayType(elementType, arrayShape));
}
public MethodSignature <TType> DecodeMethodSignature <TType>(ISignatureTypeProvider <TType> provider)
{
var decoder = new SignatureDecoder <TType>(provider, _reader);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeMethodSignature(ref blobReader));
}
public ImmutableArray <TType> DecodeLocalSignature <TType>(ISignatureTypeProvider <TType> provider)
{
var decoder = new SignatureDecoder <TType>(provider, _reader);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeLocalSignature(ref blobReader));
}
public MethodSignature <TType> DecodeSignature <TType, TGenericContext>(ISignatureTypeProvider <TType, TGenericContext> provider, TGenericContext genericContext)
{
var decoder = new SignatureDecoder <TType, TGenericContext>(provider, _reader, genericContext);
var blobReader = _reader.GetBlobReader(Signature);
return(decoder.DecodeMethodSignature(ref blobReader));
}
public sealed override string ToString()
{
string disposedString = Loader.GetDisposedString();
if (disposedString != null)
{
return(disposedString);
}
StringBuilder sb = new StringBuilder();
ISignatureTypeProvider <string, TypeContext> typeProvider = EcmaSignatureTypeProviderForToString.Instance;
MethodSignature <string> sig = PropertyDefinition.DecodeSignature(typeProvider, TypeContext);
sb.Append(sig.ReturnType);
sb.Append(' ');
sb.Append(Name);
if (sig.ParameterTypes.Length != 0)
{
sb.Append('[');
for (int i = 0; i < sig.ParameterTypes.Length; i++)
{
if (i != 0)
{
sb.Append(',');
}
sb.Append(sig.ParameterTypes[i]);
}
sb.Append(']');
}
return(sb.ToString());
}
/// <summary>
/// Decodes a field signature.
/// </summary>
/// <returns>The decoded field type.</returns>
public static TType DecodeFieldSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Field)
{
throw new BadImageFormatException();
}
return(DecodeType(ref blobReader, provider));
}
/// <summary>
/// Creates a new SignatureDecoder.
/// </summary>
/// <param name="provider">The provider used to obtain type symbols as the signature is decoded.</param>
/// <param name="metadataReader">
/// The metadata reader from which the signature was obtained. It may be null if the given provider allows it.
/// </param>
public SignatureDecoder(
ISignatureTypeProvider <TType> provider,
MetadataReader metadataReader = null)
{
if (provider == null)
{
Throw.ArgumentNull(nameof(provider));
}
_metadataReaderOpt = metadataReader;
_provider = provider;
}
/// <summary>
/// Creates a new SignatureDecoder.
/// </summary>
/// <param name="provider">The provider used to obtain type symbols as the signature is decoded.</param>
/// <param name="metadataReader">
/// The metadata reader from which the signature was obtained. It may be null if the given provider allows it.
/// However, if <see cref="SignatureDecoderOptions.DifferentiateClassAndValueTypes"/> is specified, it should
/// be non-null to evaluate WinRT projections from class to value type or vice-versa correctly.
/// </param>
/// <param name="options">Set of optional decoder features to enable.</param>
public SignatureDecoder(
ISignatureTypeProvider <TType> provider,
MetadataReader metadataReader = null,
SignatureDecoderOptions options = SignatureDecoderOptions.None)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_metadataReaderOpt = metadataReader;
_provider = provider;
_options = options;
}
/// <summary>
/// Creates a new SignatureDecoder.
/// </summary>
/// <param name="provider">The provider used to obtain type symbols as the signature is decoded.</param>
/// <param name="metadataReader">
/// The metadata reader from which the signature was obtained. It may be null if the given provider allows it.
/// </param>
/// <param name="genericContext">
/// Additional context needed to resolve generic parameters.
/// </param>
public SignatureDecoder(
ISignatureTypeProvider <TType, TGenericContext> provider,
MetadataReader metadataReader,
TGenericContext genericContext)
{
if (provider == null)
{
Throw.ArgumentNull(nameof(provider));
}
_metadataReaderOpt = metadataReader;
_provider = provider;
_genericContext = genericContext;
}
/// <summary>
/// Decodes a type definition, reference or specification to its representation as TType.
/// </summary>
/// <param name="handle">A type definition, reference, or specification handle.</param>
/// <param name="provider">The type provider.</param>
/// <param name="isValueType">Is the type a class or a value type. Null signifies that the current type signature does not have the prefix</param>
/// <exception cref="System.BadImageFormatException">The handle does not represent a valid type reference, definition, or specification.</exception>
public static TType DecodeType <TType>(Handle handle, ISignatureTypeProvider <TType> provider, bool?isValueType)
{
switch (handle.Kind)
{
case HandleKind.TypeReference:
return(provider.GetTypeFromReference((TypeReferenceHandle)handle, isValueType));
case HandleKind.TypeDefinition:
return(provider.GetTypeFromDefinition((TypeDefinitionHandle)handle, isValueType));
case HandleKind.TypeSpecification:
return(DecodeTypeSpecification((TypeSpecificationHandle)handle, provider));
default:
throw new BadImageFormatException();
}
}
/// <summary>
/// Decodes a local variable signature blob and advances the reader past the signature.
/// </summary>
/// <param name="blobReader">The blob reader.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The local variable types.</returns>
/// <exception cref="System.BadImageFormatException">The local variable signature is invalid.</exception>
public static ImmutableArray <TType> DecodeLocalSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.LocalVariables)
{
throw new BadImageFormatException();
}
return(DecodeTypes(ref blobReader, provider));
}
/// <summary>
/// Decodes a local variable signature blob.
/// </summary>
/// <param name="handle">The local variable signature handle.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The local variable types.</returns>
/// <exception cref="System.BadImageFormatException">The local variable signature is invalid.</exception>
public static ImmutableArray <TType> DecodeLocalSignature <TType>(StandaloneSignatureHandle handle, ISignatureTypeProvider <TType> provider)
{
BlobHandle blobHandle = provider.Reader.GetStandaloneSignature(handle).Signature;
BlobReader blobReader = provider.Reader.GetBlobReader(blobHandle);
return(DecodeLocalSignature(ref blobReader, provider));
}
/// <summary>
/// Decodes a field signature.
/// </summary>
/// <param name="handle">The field signature handle.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded field type.</returns>
/// <exception cref="System.BadImageFormatException">The field signature is invalid.</exception>
public static TType DecodeFieldSignature <TType>(BlobHandle handle, ISignatureTypeProvider <TType> provider)
{
BlobReader blobReader = provider.Reader.GetBlobReader(handle);
return(DecodeFieldSignature(ref blobReader, provider));
}
// Decodes a generic type instantiation encoded as the generic type followed by the types used to instantiate it.
private static TType DecodeGenericTypeInstance <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
TType genericType = DecodeType(ref blobReader, provider);
ImmutableArray <TType> types = DecodeTypes(ref blobReader, provider);
return(provider.GetGenericInstance(genericType, types));
}
/// <summary>
/// Decodes a method specification signature blob.
/// </summary>
/// <param name="handle">The handle to the method specification signature blob. See <see cref="MethodSpecification.Signature"/>.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The types used to instantiate a generic method via a method specification.</returns>
/// <exception cref="System.BadImageFormatException">The method specification signature is invalid.</exception>
public static ImmutableArray <TType> DecodeMethodSpecificationSignature <TType>(BlobHandle handle, ISignatureTypeProvider <TType> provider)
{
BlobReader blobReader = provider.Reader.GetBlobReader(handle);
return(DecodeMethodSpecificationSignature(ref blobReader, provider));
}
/// <summary>
/// Decodes a type from within a signature from a BlobReader positioned immediately past the given SignatureTypeCode.
/// </summary>
/// <param name="blobReader">The blob reader.</param>
/// <param name="typeCode">The SignatureTypeCode that immediately preceded the reader's current position.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded type.</returns>
/// <exception cref="System.BadImageFormatException">The reader was not positioned at a valud signature type.</exception>
private static TType DecodeType <TType>(ref BlobReader blobReader, int typeCode, ISignatureTypeProvider <TType> provider)
{
TType elementType;
int index;
if (typeCode > byte.MaxValue)
{
typeCode = (int)SignatureTypeCode.Invalid;
}
switch (typeCode)
{
case (int)SignatureTypeCode.Boolean:
case (int)SignatureTypeCode.Char:
case (int)SignatureTypeCode.SByte:
case (int)SignatureTypeCode.Byte:
case (int)SignatureTypeCode.Int16:
case (int)SignatureTypeCode.UInt16:
case (int)SignatureTypeCode.Int32:
case (int)SignatureTypeCode.UInt32:
case (int)SignatureTypeCode.Int64:
case (int)SignatureTypeCode.UInt64:
case (int)SignatureTypeCode.Single:
case (int)SignatureTypeCode.Double:
case (int)SignatureTypeCode.IntPtr:
case (int)SignatureTypeCode.UIntPtr:
case (int)SignatureTypeCode.Object:
case (int)SignatureTypeCode.String:
case (int)SignatureTypeCode.Void:
case (int)SignatureTypeCode.TypedReference:
return(provider.GetPrimitiveType((PrimitiveTypeCode)typeCode));
case (int)SignatureTypeCode.Pointer:
elementType = DecodeType(ref blobReader, provider);
return(provider.GetPointerType(elementType));
case (int)SignatureTypeCode.ByReference:
elementType = DecodeType(ref blobReader, provider);
return(provider.GetByReferenceType(elementType));
case (int)SignatureTypeCode.Pinned:
elementType = DecodeType(ref blobReader, provider);
return(provider.GetPinnedType(elementType));
case (int)SignatureTypeCode.SZArray:
elementType = DecodeType(ref blobReader, provider);
return(provider.GetSZArrayType(elementType));
case (int)SignatureTypeCode.FunctionPointer:
MethodSignature <TType> methodSignature = DecodeMethodSignature(ref blobReader, provider);
return(provider.GetFunctionPointerType(methodSignature));
case (int)SignatureTypeCode.Array:
return(DecodeArrayType(ref blobReader, provider));
case (int)SignatureTypeCode.RequiredModifier:
return(DecodeModifiedType(ref blobReader, provider, isRequired: true));
case (int)SignatureTypeCode.OptionalModifier:
return(DecodeModifiedType(ref blobReader, provider, isRequired: false));
case (int)SignatureTypeCode.GenericTypeInstance:
return(DecodeGenericTypeInstance(ref blobReader, provider));
case (int)SignatureTypeCode.GenericTypeParameter:
index = blobReader.ReadCompressedInteger();
return(provider.GetGenericTypeParameter(index));
case (int)SignatureTypeCode.GenericMethodParameter:
index = blobReader.ReadCompressedInteger();
return(provider.GetGenericMethodParameter(index));
case 0x11: //(int)CorElementType.ELEMENT_TYPE_CLASS
return(DecodeTypeHandle(ref blobReader, provider, false));
case 0x12: //(int)CorElementType.ELEMENT_TYPE_VALUETYPE:
return(DecodeTypeHandle(ref blobReader, provider, true));
default:
throw new BadImageFormatException();
}
}
/// <summary>
/// Decodes a method signature blob.
/// </summary>
/// <param name="blobReader">BlobReader positioned at a method signature.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded method signature.</returns>
/// <exception cref="System.BadImageFormatException">The method signature is invalid.</exception>
private static MethodSignature <TType> DecodeMethodSignature <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
SignatureHeader header = blobReader.ReadSignatureHeader();
if (header.Kind != SignatureKind.Method && header.Kind != SignatureKind.Property)
{
throw new BadImageFormatException();
}
int genericParameterCount = 0;
if (header.IsGeneric)
{
genericParameterCount = blobReader.ReadCompressedInteger();
}
int parameterCount = blobReader.ReadCompressedInteger();
TType returnType = DecodeType(ref blobReader, provider);
if (parameterCount == 0)
{
return(new MethodSignature <TType>(header, returnType, 0, genericParameterCount, ImmutableArray <TType> .Empty));
}
var parameterTypes = new TType[parameterCount];
SignatureTypeCode typeCode;
int parameterIndex;
for (parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
{
var reader = blobReader;
typeCode = reader.ReadSignatureTypeCode();
if (typeCode == SignatureTypeCode.Sentinel)
{
break;
}
parameterTypes[parameterIndex] = DecodeType(ref blobReader, provider);
}
int requiredParameterCount = parameterIndex;
for (; parameterIndex < parameterCount; parameterIndex++)
{
parameterTypes[parameterIndex] = DecodeType(ref blobReader, provider);
}
return(new MethodSignature <TType>(header, returnType, requiredParameterCount, genericParameterCount, ImmutableArray.Create(parameterTypes)));
}
// Decodes a type definition, reference, or specification from the type handle at the given blob reader's current position.
private static TType DecodeTypeHandle <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider, bool?isValueType)
{
Handle handle = blobReader.ReadTypeHandle();
return(DecodeType(handle, provider, isValueType));
}
protected EcmaWrappedTypeProvider(EcmaModule module)
{
_module = module;
_typeProvider = module;
}
/// <summary>
/// Creates a new SignatureDecoder.
/// </summary>
/// <param name="provider">The provider used to obtain type symbols as the signature is decoded.</param>
/// <param name="metadataReader">
/// The metadata reader from which the signature was obtained. It may be null if the given provider allows it.
/// </param>
/// <param name="genericContext">
/// Additional context needed to resolve generic parameters.
/// </param>
public SignatureDecoder(
ISignatureTypeProvider <TType, TGenericContext> provider !!,
/// <summary>
/// Decodes a type from within a signature from a BlobReader positioned at its leading SignatureTypeCode.
/// </summary>
/// <param name="blobReader">The blob reader.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded type.</returns>
/// <exception cref="System.BadImageFormatException">The reader was not positioned at a valid signature type.</exception>
public static TType DecodeType <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
return(DecodeType(ref blobReader, blobReader.ReadCompressedInteger(), provider));
}
/// <summary>
/// Decodes a type specification.
/// </summary>
/// <param name="handle">The type specification handle.</param>
/// <param name="provider">The type provider.</param>
/// <returns>The decoded type.</returns>
/// <exception cref="System.BadImageFormatException">The type specification has an invalid signature.</exception>
private static TType DecodeTypeSpecification <TType>(TypeSpecificationHandle handle, ISignatureTypeProvider <TType> provider)
{
BlobHandle blobHandle = provider.Reader.GetTypeSpecification(handle).Signature;
BlobReader blobReader = provider.Reader.GetBlobReader(blobHandle);
return(DecodeType(ref blobReader, provider));
}
// Decodes a list of types preceded by their count as a compressed integer.
private static ImmutableArray <TType> DecodeTypes <TType>(ref BlobReader blobReader, ISignatureTypeProvider <TType> provider)
{
int count = blobReader.ReadCompressedInteger();
if (count == 0)
{
return(ImmutableArray <TType> .Empty);
}
var types = new TType[count];
for (int i = 0; i < count; i++)
{
types[i] = DecodeType(ref blobReader, provider);
}
return(ImmutableArray.Create(types));
}
