/// <summary>
/// Reads a single custom marshal descriptor from the provided input stream.
/// </summary>
/// <param name="parentModule">The module defining the descriptor.</param>
/// <param name="reader">The input stream.</param>
/// <returns>The descriptor.</returns>
public new static CustomMarshalDescriptor FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
string guid = reader.ReadSerString();
string nativeTypeName = reader.ReadSerString();
string marshalTypeName = reader.ReadSerString();
string cookie = reader.ReadSerString();
return(new CustomMarshalDescriptor(guid, nativeTypeName,
marshalTypeName is null ? null : TypeNameParser.Parse(parentModule, marshalTypeName), cookie));
}
public new static CustomMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new CustomMarshalDescriptor();
Guid guid;
Guid.TryParse(reader.ReadSerString(), out guid);
descriptor.Guid = guid;
descriptor.UnmanagedType = reader.ReadSerString();
descriptor.ManagedType = reader.ReadSerString();
descriptor.Cookie = reader.ReadSerString();
return(descriptor);
}
/// <summary>
/// Reads a single security attribute at the current position of the provided stream reader.
/// </summary>
/// <param name="image">The image the signature resides in.</param>
/// <param name="reader">The reader to use.</param>
/// <returns>The read attribute.</returns>
public static SecurityAttributeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new SecurityAttributeSignature
{
TypeName = reader.ReadSerString(),
};
reader.ReadCompressedUInt32();
if (!reader.TryReadCompressedUInt32(out uint argumentCount))
{
return(signature);
}
if (argumentCount == 0)
{
return(signature);
}
for (int i = 0; i < argumentCount; i++)
{
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(image, reader));
}
return(signature);
}
public static new CustomMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new CustomMarshalDescriptor()
{
StartOffset = reader.Position
};
Guid guid;
Guid.TryParse(reader.ReadSerString(), out guid);
descriptor.Guid = guid;
descriptor.UnmanagedType = reader.ReadSerString();
descriptor.ManagedType = reader.ReadSerString();
descriptor.Cookie = reader.ReadSerString();
return descriptor;
}
/// <summary>
/// Reads a single named argument from the input stream.
/// </summary>
/// <param name="parentModule">The module the argument is residing in.</param>
/// <param name="reader">The input stream.</param>
/// <returns>The argument.</returns>
public static CustomAttributeNamedArgument FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
var result = new CustomAttributeNamedArgument
{
MemberType = (CustomAttributeArgumentMemberType)reader.ReadByte(),
ArgumentType = TypeSignature.ReadFieldOrPropType(parentModule, reader),
MemberName = reader.ReadSerString(),
};
result.Argument = CustomAttributeArgument.FromReader(parentModule, result.ArgumentType, reader);
return(result);
}
public static CustomAttributeNamedArgument FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new CustomAttributeNamedArgument
{
StartOffset = reader.Position,
ArgumentMemberType =
(reader.CanRead(sizeof (byte))
? (CustomAttributeArgumentMemberType)reader.ReadByte()
: CustomAttributeArgumentMemberType.Field),
ArgumentType = TypeSignature.ReadFieldOrPropType(header, reader),
MemberName = reader.ReadSerString(),
};
signature.Argument = CustomAttributeArgument.FromReader(header, signature.ArgumentType, reader);
return signature;
}
public static TypeSignature ReadFieldOrPropType(MetadataHeader header, IBinaryStreamReader reader)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Boxed:
return header.TypeSystem.Object;
case ElementType.SzArray:
return new SzArrayTypeSignature(ReadFieldOrPropType(header, reader));
case ElementType.Enum:
return FromAssemblyQualifiedName(header, reader.ReadSerString());
default:
return MsCorLibTypeSignature.FromElementType(header, elementType);
}
}
public static CustomAttributeNamedArgument FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new CustomAttributeNamedArgument
{
ArgumentMemberType =
(reader.CanRead(sizeof(byte))
? (CustomAttributeArgumentMemberType)reader.ReadByte()
: CustomAttributeArgumentMemberType.Field),
ArgumentType = TypeSignature.ReadFieldOrPropType(image, reader),
MemberName = reader.ReadSerString(),
};
signature.Argument = CustomAttributeArgument.FromReader(image, signature.ArgumentType, reader);
return(signature);
}
public static TypeSignature ReadFieldOrPropType(MetadataHeader header, IBinaryStreamReader reader)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Boxed:
return(header.TypeSystem.Object);
case ElementType.SzArray:
return(new SzArrayTypeSignature(ReadFieldOrPropType(header, reader)));
case ElementType.Enum:
return(FromAssemblyQualifiedName(header, reader.ReadSerString()));
default:
return(MsCorLibTypeSignature.FromElementType(header, elementType));
}
}
public static SecurityAttributeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new SecurityAttributeSignature()
{
StartOffset = reader.Position,
TypeName = reader.ReadSerString(),
};
reader.ReadCompressedUInt32();
uint argumentCount;
if (!reader.TryReadCompressedUInt32(out argumentCount))
return signature;
if (argumentCount == 0)
return signature;
for (int i = 0; i < argumentCount; i++)
signature.NamedArguments.Add(CustomAttributeNamedArgument.FromReader(header, reader));
return signature;
}
internal static TypeSignature ReadFieldOrPropType(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
var elementType = (ElementType)reader.ReadByte();
switch (elementType)
{
case ElementType.Boxed:
return(parentModule.CorLibTypeFactory.Object);
case ElementType.SzArray:
return(new SzArrayTypeSignature(ReadFieldOrPropType(parentModule, reader)));
case ElementType.Enum:
return(TypeNameParser.Parse(parentModule, reader.ReadSerString()));
case ElementType.Type:
return(new TypeDefOrRefSignature(new TypeReference(parentModule,
parentModule.CorLibTypeFactory.CorLibScope, "System", "Type")));
default:
return(parentModule.CorLibTypeFactory.FromElementType(elementType));
}
}
/// <summary>
/// Reads a single safe array marshal descriptor from the provided input stream.
/// </summary>
/// <param name="parentModule">The module defining the descriptor.</param>
/// <param name="reader">The input stream.</param>
/// <returns>The descriptor.</returns>
public new static SafeArrayMarshalDescriptor FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
if (!reader.TryReadCompressedUInt32(out uint type))
{
return(new SafeArrayMarshalDescriptor(SafeArrayVariantType.NotSet));
}
var variantType = (SafeArrayVariantType)type & SafeArrayVariantType.TypeMask;
var flags = (SafeArrayTypeFlags)type & ~SafeArrayTypeFlags.Mask;
var result = new SafeArrayMarshalDescriptor(variantType, flags);
if (reader.CanRead(1))
{
string typeName = reader.ReadSerString();
if (typeName != null)
{
result.UserDefinedSubType = TypeNameParser.Parse(parentModule, typeName);
}
}
return(result);
}
/// <summary>
/// Reads a single security attribute from the provided input blob stream.
/// </summary>
/// <param name="parentModule">The module that the security attribute resides in.</param>
/// <param name="reader">The input blob stream.</param>
/// <returns>The security attribute.</returns>
public static SecurityAttribute FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader)
{
var type = TypeNameParser.Parse(parentModule, reader.ReadSerString());
var result = new SecurityAttribute(type);
if (!reader.TryReadCompressedUInt32(out uint size))
{
return(result);
}
if (!reader.TryReadCompressedUInt32(out uint namedArgumentCount))
{
return(result);
}
for (int i = 0; i < namedArgumentCount; i++)
{
var argument = CustomAttributeNamedArgument.FromReader(parentModule, reader);
result.NamedArguments.Add(argument);
}
return(result);
}
private static object ReadValue(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
switch (typeSignature.ElementType)
{
case ElementType.Boolean:
return(reader.ReadByte() == 1);
case ElementType.Char:
return((char)reader.ReadUInt16());
case ElementType.R4:
return(reader.ReadSingle());
case ElementType.R8:
return(reader.ReadDouble());
case ElementType.I1:
return(reader.ReadSByte());
case ElementType.I2:
return(reader.ReadInt16());
case ElementType.I4:
return(reader.ReadInt32());
case ElementType.I8:
return(reader.ReadInt64());
case ElementType.U1:
return(reader.ReadByte());
case ElementType.U2:
return(reader.ReadUInt16());
case ElementType.U4:
return(reader.ReadUInt32());
case ElementType.U8:
return(reader.ReadUInt64());
case ElementType.String:
return(reader.ReadSerString());
case ElementType.Object:
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
var enumTypeDef = header.MetadataResolver.ResolveType(typeSignature);
if (enumTypeDef == null)
{
throw new MemberResolutionException(typeSignature);
}
if (enumTypeDef.IsEnum)
{
return(ReadValue(header, enumTypeDef.GetEnumUnderlyingType(), reader));
}
break;
}
if (typeSignature.IsTypeOf("System", "Type"))
{
return(reader.ReadSerString());
}
throw new NotSupportedException("Unsupported element type " + typeSignature.ElementType);
}
private static object ReadValue(ModuleDefinition parentModule, TypeSignature valueType, IBinaryStreamReader reader)
{
switch (valueType.ElementType)
{
case ElementType.Boolean:
return(reader.ReadByte() == 1);
case ElementType.Char:
return((char)reader.ReadUInt16());
case ElementType.R4:
return(reader.ReadSingle());
case ElementType.R8:
return(reader.ReadDouble());
case ElementType.I1:
return(reader.ReadSByte());
case ElementType.I2:
return(reader.ReadInt16());
case ElementType.I4:
return(reader.ReadInt32());
case ElementType.I8:
return(reader.ReadInt64());
case ElementType.U1:
return(reader.ReadByte());
case ElementType.U2:
return(reader.ReadUInt16());
case ElementType.U4:
return(reader.ReadUInt32());
case ElementType.U8:
return(reader.ReadUInt64());
case ElementType.String:
return(reader.ReadSerString());
case ElementType.Object:
return(ReadValue(parentModule, TypeSignature.ReadFieldOrPropType(parentModule, reader), reader));
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
var enumTypeDef = parentModule.MetadataResolver.ResolveType(valueType);
if (enumTypeDef != null && enumTypeDef.IsEnum)
{
return(ReadValue(parentModule, enumTypeDef.GetEnumUnderlyingType(), reader));
}
break;
}
if (valueType.IsTypeOf("System", "Type"))
{
return(TypeNameParser.Parse(parentModule, reader.ReadSerString()));
}
throw new NotSupportedException($"Unsupported element type {valueType.ElementType}.");
}
private static object ReadValue(MetadataHeader header, TypeSignature typeSignature, IBinaryStreamReader reader)
{
switch (typeSignature.ElementType)
{
case ElementType.Boolean:
return reader.ReadByte() == 1;
case ElementType.Char:
return (char)reader.ReadUInt16();
case ElementType.R4:
return reader.ReadSingle();
case ElementType.R8:
return reader.ReadDouble();
case ElementType.I1:
return reader.ReadSByte();
case ElementType.I2:
return reader.ReadInt16();
case ElementType.I4:
return reader.ReadInt32();
case ElementType.I8:
return reader.ReadInt64();
case ElementType.U1:
return reader.ReadByte();
case ElementType.U2:
return reader.ReadUInt16();
case ElementType.U4:
return reader.ReadUInt32();
case ElementType.U8:
return reader.ReadUInt64();
case ElementType.String:
return reader.ReadSerString();
case ElementType.Object:
return ReadValue(header, TypeSignature.ReadFieldOrPropType(header, reader), reader);
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
var enumTypeDef = header.MetadataResolver.ResolveType(typeSignature);
if (enumTypeDef == null)
throw new MemberResolutionException(typeSignature);
if (enumTypeDef.IsEnum)
return ReadValue(header, enumTypeDef.GetEnumUnderlyingType(), reader);
break;
}
if (typeSignature.IsTypeOf("System", "Type"))
return TypeSignature.FromAssemblyQualifiedName(header, reader.ReadSerString());
throw new NotSupportedException("Unsupported element type " + typeSignature.ElementType);
}
public void ReadValue(TypeSignature valueType)
{
if (valueType.IsTypeOf("System", "Type"))
{
Elements.Add(TypeNameParser.Parse(_parentModule, _reader.ReadSerString()));
return;
}
switch (valueType.ElementType)
{
case ElementType.Boolean:
Elements.Add(_reader.ReadByte() == 1);
break;
case ElementType.Char:
Elements.Add((char)_reader.ReadUInt16());
break;
case ElementType.R4:
Elements.Add(_reader.ReadSingle());
break;
case ElementType.R8:
Elements.Add(_reader.ReadDouble());
break;
case ElementType.I1:
Elements.Add(_reader.ReadSByte());
break;
case ElementType.I2:
Elements.Add(_reader.ReadInt16());
break;
case ElementType.I4:
Elements.Add(_reader.ReadInt32());
break;
case ElementType.I8:
Elements.Add(_reader.ReadInt64());
break;
case ElementType.U1:
Elements.Add(_reader.ReadByte());
break;
case ElementType.U2:
Elements.Add(_reader.ReadUInt16());
break;
case ElementType.U4:
Elements.Add(_reader.ReadUInt32());
break;
case ElementType.U8:
Elements.Add(_reader.ReadUInt64());
break;
case ElementType.String:
Elements.Add(_reader.ReadSerString());
break;
case ElementType.Object:
var reader = new CustomAttributeArgumentReader(_parentModule, _reader);
var type = TypeSignature.ReadFieldOrPropType(_parentModule, _reader);
reader.ReadValue(type);
Elements.Add(new BoxedArgument(type, type.ElementType == ElementType.SzArray
? reader.Elements.ToArray()
: reader.Elements[0]));
break;
case ElementType.SzArray:
var arrayElementType = ((SzArrayTypeSignature)valueType).BaseType;
uint elementCount = _reader.CanRead(sizeof(uint)) ? _reader.ReadUInt32() : uint.MaxValue;
IsNullArray = elementCount == uint.MaxValue;
if (!IsNullArray)
{
for (uint i = 0; i < elementCount; i++)
{
ReadValue(arrayElementType);
}
}
break;
case ElementType.Class:
case ElementType.Enum:
case ElementType.ValueType:
// Value is an enum, resolve it and get underlying type.
// If that fails, most enums are int32s, assume that is the case in an attempt to recover.
var enumTypeDef = _parentModule.MetadataResolver.ResolveType(valueType);
TypeSignature underlyingType;
if (enumTypeDef is null)
{
underlyingType = _parentModule.CorLibTypeFactory.Int32;
}
else if (enumTypeDef.IsEnum)
{
underlyingType = enumTypeDef.GetEnumUnderlyingType() ?? _parentModule.CorLibTypeFactory.Int32;
}
else
{
throw new NotSupportedException($"Type {valueType} is not an enum.");
}
ReadValue(underlyingType);
break;
default:
throw new NotSupportedException($"Unsupported element type {valueType.ElementType}.");
}
}
