public BlobReader Skip() { var reader = _reader; while (reader.IsCustomModifier()) reader = new CustomModifierSignature(reader).Skip(); switch (reader.PeekSignatureTypeCode()) { case SignatureTypeCode.ByReference: reader.ReadSignatureTypeCode(); goto default; case SignatureTypeCode.TypedReference: case SignatureTypeCode.Void: reader.ReadSignatureTypeCode(); break; default: reader = new TypeSignature(reader).Skip(); break; } return reader; }
public BlobReader Skip() { BlobReader reader = _reader; reader.ReadSignatureHeader(); int parameterCount = reader.ReadCompressedInteger(); while (reader.IsCustomModifier()) reader = new CustomModifierSignature(reader).Skip(); reader = new TypeSignature(reader).Skip(); for (int i = 0; i < parameterCount; i++) reader = new ParameterSignature(reader).Skip(); return reader; }
private bool IsSameTypeSignature(MetadataReader referenceMetadata, MetadataReader newMetadata, TypeSignature referenceSignature, TypeSignature newSignature) { if (referenceSignature.TypeCode != newSignature.TypeCode) return false; switch (referenceSignature.TypeCode) { case SignatureTypeCode.Boolean: case SignatureTypeCode.Char: case SignatureTypeCode.SByte: case SignatureTypeCode.Byte: case SignatureTypeCode.Int16: case SignatureTypeCode.UInt16: case SignatureTypeCode.Int32: case SignatureTypeCode.UInt32: case SignatureTypeCode.Int64: case SignatureTypeCode.UInt64: case SignatureTypeCode.IntPtr: case SignatureTypeCode.UIntPtr: case SignatureTypeCode.Single: case SignatureTypeCode.Double: return true; case SignatureTypeCode.Object: case SignatureTypeCode.String: return true; case SignatureTypeCode.Array: throw new NotImplementedException(string.Format("{0} is not yet implemented.", referenceSignature.TypeCode)); case SignatureTypeCode.FunctionPointer: throw new NotImplementedException(string.Format("{0} is not yet implemented.", referenceSignature.TypeCode)); case SignatureTypeCode.GenericTypeInstance: if (!IsSameType(referenceMetadata, newMetadata, referenceSignature.TypeHandle, newSignature.TypeHandle)) return false; ImmutableArray<TypeSignature> referenceGenericArguments = referenceSignature.GenericTypeArguments; ImmutableArray<TypeSignature> newGenericArguments = newSignature.GenericTypeArguments; if (referenceGenericArguments.Length != newGenericArguments.Length) return false; for (int i = 0; i < referenceGenericArguments.Length; i++) { if (!IsSameTypeSignature(referenceMetadata, newMetadata, referenceGenericArguments[i], newGenericArguments[i])) return false; } return true; case SignatureTypeCode.GenericMethodParameter: case SignatureTypeCode.GenericTypeParameter: return referenceSignature.GenericParameterIndex == newSignature.GenericParameterIndex; case SignatureTypeCode.TypeHandle: Handle referenceTypeHandle = referenceSignature.TypeHandle; Handle newTypeHandle = newSignature.TypeHandle; return IsSameType(referenceMetadata, newMetadata, referenceTypeHandle, newTypeHandle); case SignatureTypeCode.Pointer: throw new NotImplementedException(string.Format("{0} is not yet implemented.", referenceSignature.TypeCode)); case SignatureTypeCode.SZArray: if (!referenceSignature.CustomModifiers.IsEmpty || !newSignature.CustomModifiers.IsEmpty) throw new NotImplementedException(); return IsSameTypeSignature(referenceMetadata, newMetadata, referenceSignature.ElementType, newSignature.ElementType); default: throw new InvalidOperationException("Invalid signature type code."); } }
private string CompareTypeSignatures(TypeSignature sourceSignature, TypeSignature targetSignature) { if (sourceSignature.TypeCode != targetSignature.TypeCode) return "Type mismatch"; switch (sourceSignature.TypeCode) { case SignatureTypeCode.Boolean: case SignatureTypeCode.Char: case SignatureTypeCode.SByte: case SignatureTypeCode.Byte: case SignatureTypeCode.Int16: case SignatureTypeCode.UInt16: case SignatureTypeCode.Int32: case SignatureTypeCode.UInt32: case SignatureTypeCode.Int64: case SignatureTypeCode.UInt64: case SignatureTypeCode.IntPtr: case SignatureTypeCode.UIntPtr: case SignatureTypeCode.Single: case SignatureTypeCode.Double: return null; case SignatureTypeCode.Object: case SignatureTypeCode.String: return null; case SignatureTypeCode.Array: throw new NotImplementedException(string.Format("{0} is not yet implemented.", sourceSignature.TypeCode)); case SignatureTypeCode.FunctionPointer: throw new NotImplementedException(string.Format("{0} is not yet implemented.", sourceSignature.TypeCode)); case SignatureTypeCode.GenericTypeInstance: if (!IsSameHandle(sourceSignature.TypeHandle, targetSignature.TypeHandle)) return "Unbound generic type does not match."; ImmutableArray<TypeSignature> sourceGenericArguments = sourceSignature.GenericTypeArguments; ImmutableArray<TypeSignature> targetGenericArguments = targetSignature.GenericTypeArguments; if (sourceGenericArguments.Length != targetGenericArguments.Length) return "Generic arity does not match."; for (int i = 0; i < sourceGenericArguments.Length; i++) { string genericParameterResult = CompareTypeSignatures(sourceGenericArguments[i], targetGenericArguments[i]); if (genericParameterResult != null) return string.Format("Generic parameter {0} does not match: {1}", i, genericParameterResult); } return null; case SignatureTypeCode.GenericMethodParameter: case SignatureTypeCode.GenericTypeParameter: if (sourceSignature.GenericParameterIndex != targetSignature.GenericParameterIndex) return "Generic parameter index differs."; return null; case SignatureTypeCode.TypeHandle: throw new NotImplementedException(string.Format("{0} is not yet implemented.", sourceSignature.TypeCode)); //Handle referenceTypeHandle = sourceSignature.TypeHandle; //Handle newTypeHandle = targetSignature.TypeHandle; //return IsSameType(referenceMetadata, newMetadata, referenceTypeHandle, newTypeHandle); case SignatureTypeCode.Pointer: throw new NotImplementedException(string.Format("{0} is not yet implemented.", sourceSignature.TypeCode)); case SignatureTypeCode.SZArray: if (!sourceSignature.CustomModifiers.IsEmpty || !targetSignature.CustomModifiers.IsEmpty) throw new NotImplementedException(); string szArrayResult = CompareTypeSignatures(sourceSignature.ElementType, targetSignature.ElementType); if (szArrayResult != null) szArrayResult = string.Format("SZArray element type mismatch: {0}", szArrayResult); return szArrayResult; default: throw new InvalidOperationException("Invalid signature type code."); } }
public BlobReader Skip() { BlobReader reader = _reader; SignatureTypeCode typeCode = reader.ReadSignatureTypeCode(); switch (typeCode) { case SignatureTypeCode.Boolean: case SignatureTypeCode.Char: case SignatureTypeCode.SByte: case SignatureTypeCode.Byte: case SignatureTypeCode.Int16: case SignatureTypeCode.UInt16: case SignatureTypeCode.Int32: case SignatureTypeCode.UInt32: case SignatureTypeCode.Int64: case SignatureTypeCode.UInt64: case SignatureTypeCode.IntPtr: case SignatureTypeCode.UIntPtr: case SignatureTypeCode.Single: case SignatureTypeCode.Double: break; case SignatureTypeCode.Object: case SignatureTypeCode.String: break; case SignatureTypeCode.Array: reader = new TypeSignature(reader).Skip(); reader = new ArrayShapeSignature(reader).Skip(); break; case SignatureTypeCode.FunctionPointer: throw new NotImplementedException(string.Format("{0} is not yet implemented.", typeCode)); case SignatureTypeCode.GenericTypeInstance: reader.ReadSignatureTypeCode(); reader.ReadTypeHandle(); int argumentCount = reader.ReadCompressedInteger(); for (int i = 0; i < argumentCount; i++) reader = new TypeSignature(reader).Skip(); break; case SignatureTypeCode.GenericMethodParameter: case SignatureTypeCode.GenericTypeParameter: // skip the generic parameter index reader.ReadCompressedInteger(); break; case SignatureTypeCode.TypeHandle: reader.ReadTypeHandle(); break; case SignatureTypeCode.Pointer: while (reader.IsCustomModifier()) reader = new CustomModifierSignature(reader).Skip(); if (reader.PeekSignatureTypeCode() == SignatureTypeCode.Void) reader.ReadSignatureTypeCode(); else reader = new TypeSignature(reader).Skip(); break; case SignatureTypeCode.SZArray: while (reader.IsCustomModifier()) reader = new CustomModifierSignature(reader).Skip(); reader = new TypeSignature(reader).Skip(); break; default: throw new InvalidOperationException("Invalid signature type code."); } return reader; }