/// <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); }