public static new ArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new ArrayMarshalDescriptor((NativeType) reader.ReadByte());
uint value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.ParameterIndex = (int)value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.NumberOfElements = (int)value;
return descriptor;
}
public static SecurityAttributeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new SecurityAttributeSignature()
{
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);
}
public static PermissionSetSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PermissionSetSignature()
{
StartOffset = reader.Position
};
var signatureHeader = reader.ReadByte();
if (signatureHeader != '.')
{
throw new ArgumentException("Signature doesn't refer to a valid permission set signature.");
}
uint attributeCount;
if (!reader.TryReadCompressedUInt32(out attributeCount))
{
return(signature);
}
for (int i = 0; i < attributeCount; i++)
{
signature.Attributes.Add(SecurityAttributeSignature.FromReader(header, reader));
}
return(signature);
}
public new static GenericInstanceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(header, reader);
var signature = new GenericInstanceTypeSignature(type)
{
IsValueType = elementType == ElementType.ValueType
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
}
return(signature);
}
public static new MethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof (byte)))
return null;
var signature = new MethodSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
uint genericParameterCount;
if (!reader.TryReadCompressedUInt32(out genericParameterCount))
return signature;
signature.GenericParameterCount = (int)genericParameterCount;
}
uint parameterCount;
if (!reader.TryReadCompressedUInt32(out parameterCount))
return signature;
signature.ReturnType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
}
return signature;
}
public static new ArrayTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
long position = reader.Position;
var signature = new ArrayTypeSignature(TypeSignature.FromReader(header, reader))
{
StartOffset = position
};
uint rank;
if (!reader.TryReadCompressedUInt32(out rank))
return signature;
uint numSizes;
if (!reader.TryReadCompressedUInt32(out numSizes))
return signature;
var sizes = new uint[numSizes];
for (int i = 0; i < numSizes; i++)
{
if (!reader.TryReadCompressedUInt32(out sizes[i]))
return signature;
}
uint numLoBounds;
if (!reader.TryReadCompressedUInt32(out numLoBounds))
return signature;
var loBounds = new uint[numLoBounds];
for (int i = 0; i < numLoBounds; i++)
{
if (!reader.TryReadCompressedUInt32(out loBounds[i]))
return signature;
}
for (int i = 0; i < rank; i++)
{
var dimension = new ArrayDimension();
if (i < numSizes)
dimension.Size = (int)sizes[i];
if (i < numLoBounds)
dimension.LowerBound = (int)loBounds[i];
signature.Dimensions.Add(dimension);
}
return signature;
}
public new static ArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new ArrayMarshalDescriptor((NativeType)reader.ReadByte());
uint value;
if (!reader.TryReadCompressedUInt32(out value))
{
return(descriptor);
}
descriptor.ParameterIndex = (int)value;
if (!reader.TryReadCompressedUInt32(out value))
{
return(descriptor);
}
descriptor.NumberOfElements = (int)value;
return(descriptor);
}
public static GenericParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader, GenericParameterType parameterType)
{
uint index;
if (!reader.TryReadCompressedUInt32(out index))
{
return(null);
}
return(new GenericParameterSignature(parameterType, (int)index));
}
public new static MethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof(byte)))
{
return(null);
}
var signature = new MethodSignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
if (signature.IsGeneric)
{
uint genericParameterCount;
if (!reader.TryReadCompressedUInt32(out genericParameterCount))
{
return(signature);
}
signature.GenericParameterCount = (int)genericParameterCount;
}
uint parameterCount;
if (!reader.TryReadCompressedUInt32(out parameterCount))
{
return(signature);
}
signature.ReturnType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < parameterCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
}
return(signature);
}
/// <summary>
/// Reads a single fixed array marshal descriptor from the provided input stream.
/// </summary>
/// <param name="reader">The input stream.</param>
/// <returns>The descriptor.</returns>
public static FixedArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var result = new FixedArrayMarshalDescriptor();
if (reader.TryReadCompressedUInt32(out uint value))
{
result.Size = (int)value;
if (reader.TryReadCompressedUInt32(out value))
{
result.ArrayElementType = (NativeType)value;
}
}
return(result);
}
/// <summary>
/// Reads a serialized UTF8 string from the steram.
/// </summary>
/// <param name="reader">The reader to use for reading the data.</param>
/// <returns>The string that was read from the stream.</returns>
public static string ReadSerString(this IBinaryStreamReader reader)
{
if (reader.ReadByte() == 0xFF)
{
return(null);
}
reader.Position--;
uint length;
if (!reader.TryReadCompressedUInt32(out length))
{
return(null);
}
return(Encoding.UTF8.GetString(reader.ReadBytes((int)length)));
}
public static new FixedArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new FixedArrayMarshalDescriptor()
{
StartOffset = reader.Position,
};
uint value;
if (!reader.TryReadCompressedUInt32(out value))
return descriptor;
descriptor.NumberOfElements = (int)value;
if (reader.CanRead(sizeof(byte)))
descriptor.ElementType = (NativeType)reader.ReadByte();
return descriptor;
}
public static GenericParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader, GenericParameterType parameterType)
{
long position = reader.Position;
uint index;
if (!reader.TryReadCompressedUInt32(out index))
{
return(null);
}
return(new GenericParameterSignature(parameterType, (int)index)
{
StartOffset = position
});
}
protected static ITypeDefOrRef ReadTypeDefOrRef(MetadataImage image, IBinaryStreamReader reader)
{
var tableStream = image.Header.GetStream <TableStream>();
uint codedIndex;
if (!reader.TryReadCompressedUInt32(out codedIndex))
{
return(null);
}
IMetadataMember type;
image.TryResolveMember(tableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef).DecodeIndex(codedIndex), out type);
return(type as ITypeDefOrRef);
}
public new static FixedArrayMarshalDescriptor FromReader(IBinaryStreamReader reader)
{
var descriptor = new FixedArrayMarshalDescriptor();
uint value;
if (!reader.TryReadCompressedUInt32(out value))
{
return(descriptor);
}
descriptor.NumberOfElements = (int)value;
if (reader.CanRead(sizeof(byte)))
{
descriptor.ElementType = (NativeType)reader.ReadByte();
}
return(descriptor);
}
public static new GenericInstanceMethodSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new GenericInstanceMethodSignature()
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
return signature;
for (int i = 0; i < count; i++)
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
return signature;
}
public static new PropertySignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PropertySignature
{
StartOffset = reader.Position,
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
uint paramCount;
if (!reader.TryReadCompressedUInt32(out paramCount))
return null;
signature.PropertyType = TypeSignature.FromReader(header, reader);
for (int i = 0; i < paramCount; i++)
signature.Parameters.Add(ParameterSignature.FromReader(header, reader));
return signature;
}
public static PermissionSetSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
var signature = new PermissionSetSignature()
{
StartOffset = reader.Position
};
var signatureHeader = reader.ReadByte();
if (signatureHeader != '.')
throw new ArgumentException("Signature doesn't refer to a valid permission set signature.");
uint attributeCount;
if (!reader.TryReadCompressedUInt32(out attributeCount))
return signature;
for (int i = 0; i < attributeCount; i++)
signature.Attributes.Add(SecurityAttributeSignature.FromReader(header, reader));
return signature;
}
public new static GenericInstanceMethodSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new GenericInstanceMethodSignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte()
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
{
return(signature);
}
for (int i = 0; i < count; i++)
{
signature.GenericArguments.Add(TypeSignature.FromReader(image, reader));
}
return(signature);
}
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;
}
public new static PropertySignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
var signature = new PropertySignature
{
Attributes = (CallingConventionAttributes)reader.ReadByte(),
};
uint paramCount;
if (!reader.TryReadCompressedUInt32(out paramCount))
{
return(null);
}
signature.PropertyType = TypeSignature.FromReader(image, reader);
for (int i = 0; i < paramCount; i++)
{
signature.Parameters.Add(ParameterSignature.FromReader(image, reader));
}
return(signature);
}
public static GenericParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader, GenericParameterType parameterType)
{
long position = reader.Position;
uint index;
if (!reader.TryReadCompressedUInt32(out index))
return null;
return new GenericParameterSignature(parameterType, (int) index)
{
StartOffset = position
};
}
protected static ITypeDefOrRef ReadTypeDefOrRef(MetadataHeader header, IBinaryStreamReader reader)
{
var tableStream = header.GetStream<TableStream>();
uint codedIndex;
if (!reader.TryReadCompressedUInt32(out codedIndex))
return null;
MetadataMember type;
tableStream.TryResolveMember(tableStream.GetIndexEncoder(CodedIndex.TypeDefOrRef)
.DecodeIndex(codedIndex), out type);
return type as ITypeDefOrRef;
}
public static new GenericInstanceTypeSignature FromReader(MetadataHeader header, IBinaryStreamReader reader)
{
if (!reader.CanRead(sizeof (byte)))
return null;
long position = reader.Position;
var elementType = (ElementType)reader.ReadByte();
var type = ReadTypeDefOrRef(header, reader);
var signature = new GenericInstanceTypeSignature(type)
{
StartOffset = position,
IsValueType = elementType == ElementType.ValueType
};
uint count;
if (!reader.TryReadCompressedUInt32(out count))
return signature;
for (int i = 0; i < count; i++)
signature.GenericArguments.Add(TypeSignature.FromReader(header, reader));
return signature;
}
public new static ArrayTypeSignature FromReader(MetadataImage image, IBinaryStreamReader reader)
{
long position = reader.Position;
var signature = new ArrayTypeSignature(TypeSignature.FromReader(image, reader));
uint rank;
if (!reader.TryReadCompressedUInt32(out rank))
{
return(signature);
}
uint numSizes;
if (!reader.TryReadCompressedUInt32(out numSizes))
{
return(signature);
}
var sizes = new uint[numSizes];
for (int i = 0; i < numSizes; i++)
{
if (!reader.TryReadCompressedUInt32(out sizes[i]))
{
return(signature);
}
}
uint numLoBounds;
if (!reader.TryReadCompressedUInt32(out numLoBounds))
{
return(signature);
}
var loBounds = new uint[numLoBounds];
for (int i = 0; i < numLoBounds; i++)
{
if (!reader.TryReadCompressedUInt32(out loBounds[i]))
{
return(signature);
}
}
for (int i = 0; i < rank; i++)
{
var dimension = new ArrayDimension();
if (i < numSizes)
{
dimension.Size = (int)sizes[i];
}
if (i < numLoBounds)
{
dimension.LowerBound = (int)loBounds[i];
}
signature.Dimensions.Add(dimension);
}
return(signature);
}
