/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="reader">The reader.</param>
protected override void ParseSignature(SignatureReader reader)
{
if (reader.ReadByte() != 0x0A)
{
throw new InvalidOperationException(@"Invalid signature.");
}
int genArgCount = reader.ReadCompressedInt32();
types = new SigType[genArgCount];
for (int i = 0; i < genArgCount; i++)
{
types[i] = SigType.ParseTypeSignature(reader);
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="index">The index.</param>
protected override void ParseSignature(byte[] buffer, ref int index)
{
if (0x0A != buffer[index])
{
throw new InvalidOperationException(@"Invalid signature.");
}
index++;
int genArgCount = Utilities.ReadCompressedInt32(buffer, ref index);
_types = new SigType[genArgCount];
for (int i = 0; i < genArgCount; i++)
{
_types[i] = SigType.ParseTypeSignature(buffer, ref index);
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="reader">The reader.</param>
protected sealed override void ParseSignature(SignatureReader reader)
{
byte value = reader.ReadByte();
// Check for instance signature
if (HAS_THIS == (value & HAS_THIS))
{
hasThis = true;
}
if (HAS_EXPLICIT_THIS == (value & HAS_EXPLICIT_THIS))
{
hasExplicitThis = true;
}
if (GENERIC == (value & GENERIC))
{
methodCallingConvention = MethodCallingConvention.Generic;
genericParameterCount = reader.ReadCompressedInt32();
}
else if (VARARG == (value & VARARG))
{
methodCallingConvention = MethodCallingConvention.VarArg;
}
else if ((value & 0x1F) != 0x00)
{
throw new InvalidOperationException(@"Invalid method definition signature.");
}
// Number of parameters
int paramCount = reader.ReadCompressedInt32();
parameters = new SigType[paramCount];
// Read the return type
returnType = SigType.ParseTypeSignature(reader);
// Read all parameters
for (int i = 0; i < paramCount; i++)
{
parameters[i] = SigType.ParseTypeSignature(reader);
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="index">The index.</param>
protected override void ParseSignature(byte[] buffer, ref int index)
{
// Check signature identifier
if (buffer[index++] != 0x07)
{
throw new ArgumentException(@"Token doesn't represent a local variable signature.", @"token");
}
// Retrieve the number of locals
int count = Utilities.ReadCompressedInt32(buffer, ref index);
if (0 != count)
{
_types = new SigType[count];
for (int i = 0; i < count; i++)
{
_types[i] = SigType.ParseTypeSignature(buffer, ref index);
}
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="index">The index.</param>
protected sealed override void ParseSignature(byte[] buffer, ref int index)
{
// Check for instance signature
if (HAS_THIS == (buffer[index] & HAS_THIS))
{
_hasThis = true;
}
if (HAS_EXPLICIT_THIS == (buffer[index] & HAS_EXPLICIT_THIS))
{
_hasExplicitThis = true;
}
if (GENERIC == (buffer[index] & GENERIC))
{
_callingConvention = CallingConvention.Generic;
_genericParameterCount = Utilities.ReadCompressedInt32(buffer, ref index);
}
else if (VARARG == (buffer[index] & VARARG))
{
_callingConvention = CallingConvention.Vararg;
}
else if (0x00 != (buffer[index] & 0x1F))
{
throw new InvalidOperationException(@"Invalid method definition signature.");
}
index++;
// Number of parameters
int paramCount = Utilities.ReadCompressedInt32(buffer, ref index);
_parameters = new SigType[paramCount];
// Read the return type
_returnType = SigType.ParseTypeSignature(buffer, ref index);
// Read all parameters
for (int i = 0; i < paramCount; i++)
{
_parameters[i] = SigType.ParseTypeSignature(buffer, ref index);
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="reader">The reader.</param>
protected override void ParseSignature(SignatureReader reader)
{
type = SigType.ParseTypeSignature(reader);
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="buffer">The buffer.</param>
/// <param name="index">The index.</param>
protected override void ParseSignature(byte[] buffer, ref int index)
{
_type = SigType.ParseTypeSignature(buffer, ref index);
}
