private static CallingConventionSignature ReadSignature(
ModuleDefinition module,
IBinaryStreamReader reader,
RecursionProtection protection)
{
byte flag = reader.ReadByte();
reader.FileOffset--;
switch ((CallingConventionAttributes)flag & SignatureTypeMask)
{
case CallingConventionAttributes.Default:
case CallingConventionAttributes.C:
case CallingConventionAttributes.ExplicitThis:
case CallingConventionAttributes.FastCall:
case CallingConventionAttributes.StdCall:
case CallingConventionAttributes.ThisCall:
case CallingConventionAttributes.VarArg:
return(MethodSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Property:
return(PropertySignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Local:
return(LocalVariablesSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.GenericInstance:
return(GenericInstanceMethodSignature.FromReader(module, reader, protection));
case CallingConventionAttributes.Field:
return(FieldSignature.FromReader(module, reader, protection));
}
throw new NotSupportedException();
}
/// <summary>
/// Reads a single local variables signature from the provided input stream.
/// </summary>
/// <param name="parentModule">The module containing the signature.</param>
/// <param name="reader">The input stream.</param>
/// <param name="protection">The object responsible for detecting infinite recursion.</param>
/// <returns>The signature.</returns>
public static LocalVariablesSignature FromReader(ModuleDefinition parentModule, IBinaryStreamReader reader, RecursionProtection protection)
{
var result = new LocalVariablesSignature();
result.Attributes = (CallingConventionAttributes)reader.ReadByte();
if (!reader.TryReadCompressedUInt32(out uint count))
{
return(result);
}
for (int i = 0; i < count; i++)
{
result.VariableTypes.Add(TypeSignature.FromReader(parentModule, reader, protection));
}
return(result);
}
/// <inheritdoc />
public bool Equals(CallingConventionSignature x, CallingConventionSignature y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (ReferenceEquals(x, null) || ReferenceEquals(y, null))
{
return(false);
}
return(x switch
{
LocalVariablesSignature localVarSig => Equals(localVarSig, y as LocalVariablesSignature),
FieldSignature fieldSig => Equals(fieldSig, y as FieldSignature),
MethodSignature methodSig => Equals(methodSig, y as MethodSignature),
PropertySignature propertySig => Equals(propertySig, y as PropertySignature),
_ => false
});
