Remove more code
This commit is contained in:
de4dot
parent
4fc663ce8c
commit
62519e0f6e
|
|
@ -479,14 +479,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.typeHashCode(typeRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as TypeReferenceKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareTypes(typeRef, other.typeRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -506,14 +506,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.typeReferenceHashCodeSameVersion(typeRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as TypeReferenceSameVersionKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareTypeReferenceSameVersion(typeRef, other.typeRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -549,14 +549,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.fieldReferenceHashCode(fieldRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as FieldReferenceKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareFieldReference(fieldRef, other.fieldRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -576,14 +576,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.propertyReferenceHashCode(propRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as PropertyReferenceKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.comparePropertyReference(propRef, other.propRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -603,14 +603,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.eventReferenceHashCode(eventRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as EventReferenceKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareEventReference(eventRef, other.eventRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -630,14 +630,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.methodReferenceHashCode(methodRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as MethodReferenceKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareMethodReference(methodRef, other.methodRef);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -657,16 +657,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.fieldReferenceHashCode(fieldRef) +
|
||||
MemberReferenceHelper.typeHashCode(fieldRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as FieldReferenceAndDeclaringTypeKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareFieldReference(fieldRef, other.fieldRef) &&
|
||||
MemberReferenceHelper.compareTypes(fieldRef.DeclaringType, other.fieldRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -686,16 +684,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.propertyReferenceHashCode(propRef) +
|
||||
MemberReferenceHelper.typeHashCode(propRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as PropertyReferenceAndDeclaringTypeKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.comparePropertyReference(propRef, other.propRef) &&
|
||||
MemberReferenceHelper.compareTypes(propRef.DeclaringType, other.propRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -715,16 +711,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.eventReferenceHashCode(eventRef) +
|
||||
MemberReferenceHelper.typeHashCode(eventRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as EventReferenceAndDeclaringTypeKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareEventReference(eventRef, other.eventRef) &&
|
||||
MemberReferenceHelper.compareTypes(eventRef.DeclaringType, other.eventRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -744,16 +738,14 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
public override int GetHashCode() {
|
||||
return MemberReferenceHelper.methodReferenceHashCode(methodRef) +
|
||||
MemberReferenceHelper.typeHashCode(methodRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override bool Equals(object obj) {
|
||||
var other = obj as MethodReferenceAndDeclaringTypeKey;
|
||||
if (other == null)
|
||||
return false;
|
||||
return MemberReferenceHelper.compareMethodReference(methodRef, other.methodRef) &&
|
||||
MemberReferenceHelper.compareTypes(methodRef.DeclaringType, other.methodRef.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public override string ToString() {
|
||||
|
|
@ -763,60 +755,7 @@ namespace de4dot.blocks.OLD_REMOVE {
|
|||
}
|
||||
|
||||
namespace de4dot.blocks {
|
||||
public enum CecilType {
|
||||
ArrayType,
|
||||
ByReferenceType,
|
||||
EventDefinition,
|
||||
FieldDefinition,
|
||||
FieldReference,
|
||||
FunctionPointerType,
|
||||
GenericInstanceMethod,
|
||||
GenericInstanceType,
|
||||
GenericParameter,
|
||||
MethodDefinition,
|
||||
MethodReference,
|
||||
OptionalModifierType,
|
||||
PinnedType,
|
||||
PointerType,
|
||||
PropertyDefinition,
|
||||
RequiredModifierType,
|
||||
SentinelType,
|
||||
TypeDefinition,
|
||||
TypeReference,
|
||||
}
|
||||
|
||||
public static class MemberReferenceHelper {
|
||||
static Dictionary<Type, CecilType> typeToCecilTypeDict = new Dictionary<Type, CecilType>();
|
||||
static MemberReferenceHelper() {
|
||||
typeToCecilTypeDict[typeof(ArrayType)] = CecilType.ArrayType;
|
||||
typeToCecilTypeDict[typeof(ByReferenceType)] = CecilType.ByReferenceType;
|
||||
typeToCecilTypeDict[typeof(EventDefinition)] = CecilType.EventDefinition;
|
||||
typeToCecilTypeDict[typeof(FieldDefinition)] = CecilType.FieldDefinition;
|
||||
typeToCecilTypeDict[typeof(FieldReference)] = CecilType.FieldReference;
|
||||
typeToCecilTypeDict[typeof(FunctionPointerType)] = CecilType.FunctionPointerType;
|
||||
typeToCecilTypeDict[typeof(GenericInstanceMethod)] = CecilType.GenericInstanceMethod;
|
||||
typeToCecilTypeDict[typeof(GenericInstanceType)] = CecilType.GenericInstanceType;
|
||||
typeToCecilTypeDict[typeof(GenericParameter)] = CecilType.GenericParameter;
|
||||
typeToCecilTypeDict[typeof(MethodDefinition)] = CecilType.MethodDefinition;
|
||||
typeToCecilTypeDict[typeof(MethodReference)] = CecilType.MethodReference;
|
||||
typeToCecilTypeDict[typeof(OptionalModifierType)] = CecilType.OptionalModifierType;
|
||||
typeToCecilTypeDict[typeof(PinnedType)] = CecilType.PinnedType;
|
||||
typeToCecilTypeDict[typeof(PointerType)] = CecilType.PointerType;
|
||||
typeToCecilTypeDict[typeof(PropertyDefinition)] = CecilType.PropertyDefinition;
|
||||
typeToCecilTypeDict[typeof(RequiredModifierType)] = CecilType.RequiredModifierType;
|
||||
typeToCecilTypeDict[typeof(SentinelType)] = CecilType.SentinelType;
|
||||
typeToCecilTypeDict[typeof(TypeDefinition)] = CecilType.TypeDefinition;
|
||||
typeToCecilTypeDict[typeof(TypeReference)] = CecilType.TypeReference;
|
||||
}
|
||||
|
||||
public static CecilType getMemberReferenceType(MemberReference memberReference) {
|
||||
CecilType cecilType;
|
||||
var type = memberReference.GetType();
|
||||
if (typeToCecilTypeDict.TryGetValue(type, out cecilType))
|
||||
return cecilType;
|
||||
throw new ApplicationException(string.Format("Unknown MemberReference type: {0}", type));
|
||||
}
|
||||
|
||||
public static bool verifyType(TypeReference typeReference, string assembly, string type) {
|
||||
return verifyType(typeReference, assembly, type, "");
|
||||
}
|
||||
|
|
@ -902,511 +841,20 @@ namespace de4dot.blocks {
|
|||
return getCanonicalizedScopeAndVersion(a).GetHashCode();
|
||||
}
|
||||
|
||||
public static bool compareEventReference(EventReference a, EventReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
return a.Name == b.Name &&
|
||||
compareTypes(a.EventType, b.EventType);
|
||||
}
|
||||
|
||||
public static int eventReferenceHashCode(EventReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
res += a.Name.GetHashCode();
|
||||
res += typeHashCode(a.EventType);
|
||||
return res;
|
||||
}
|
||||
|
||||
public static bool compareFieldReferenceAndDeclaringType(FieldReference a, FieldReference b) {
|
||||
if (!compareFieldReference(a, b))
|
||||
return false;
|
||||
if (a == null)
|
||||
return true;
|
||||
return compareTypes(a.DeclaringType, b.DeclaringType);
|
||||
}
|
||||
|
||||
public static bool compareFieldReference(FieldReference a, FieldReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
return a.Name == b.Name &&
|
||||
compareTypes(a.FieldType, b.FieldType);
|
||||
}
|
||||
|
||||
public static int fieldReferenceHashCode(FieldReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
res += a.Name.GetHashCode();
|
||||
res += typeHashCode(a.FieldType);
|
||||
return res;
|
||||
public static bool compareMethodReference(MethodReference a, MethodReference b) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static bool compareMethodReferenceAndDeclaringType(MethodReference a, MethodReference b) {
|
||||
if (!compareMethodReference(a, b))
|
||||
return false;
|
||||
if (a == null)
|
||||
return true;
|
||||
return compareTypes(a.DeclaringType, b.DeclaringType);
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static bool compareMethodReferenceSignature(MethodReference a, MethodReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
if (a.HasThis != b.HasThis || a.ExplicitThis != b.ExplicitThis)
|
||||
return false;
|
||||
if (a.CallingConvention != b.CallingConvention)
|
||||
return false;
|
||||
if (!compareTypes(a.MethodReturnType.ReturnType, b.MethodReturnType.ReturnType))
|
||||
return false;
|
||||
if (a.HasParameters != b.HasParameters)
|
||||
return false;
|
||||
if (a.HasParameters) {
|
||||
if (a.Parameters.Count != b.Parameters.Count)
|
||||
return false;
|
||||
for (int i = 0; i < a.Parameters.Count; i++) {
|
||||
if (!compareTypes(a.Parameters[i].ParameterType, b.Parameters[i].ParameterType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if (a.HasGenericParameters != b.HasGenericParameters)
|
||||
return false;
|
||||
if (a.HasGenericParameters && a.GenericParameters.Count != b.GenericParameters.Count)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
public static int methodReferenceSignatureHashCode(MethodReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
|
||||
res += a.HasThis.GetHashCode();
|
||||
res += a.ExplicitThis.GetHashCode();
|
||||
res += a.CallingConvention.GetHashCode();
|
||||
res += typeHashCode(a.MethodReturnType.ReturnType);
|
||||
res += a.HasParameters.GetHashCode();
|
||||
if (a.HasParameters) {
|
||||
res += a.Parameters.Count.GetHashCode();
|
||||
foreach (var param in a.Parameters)
|
||||
res += typeHashCode(param.ParameterType);
|
||||
}
|
||||
res += a.HasGenericParameters.GetHashCode();
|
||||
if (a.HasGenericParameters)
|
||||
res += a.GenericParameters.Count.GetHashCode();
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
public static bool compareMethodReference(MethodReference a, MethodReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
|
||||
if (a.Name != b.Name)
|
||||
return false;
|
||||
return compareMethodReferenceSignature(a, b);
|
||||
}
|
||||
|
||||
public static int methodReferenceAndDeclaringTypeHashCode(MethodReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return methodReferenceHashCode(a) + typeReferenceHashCode(a.DeclaringType);
|
||||
}
|
||||
|
||||
public static int methodReferenceHashCode(MethodReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
|
||||
res += a.Name.GetHashCode();
|
||||
res += methodReferenceSignatureHashCode(a);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
public static bool comparePropertyReference(PropertyReference a, PropertyReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
if ((a.Parameters == null && b.Parameters != null) || (a.Parameters != null && b.Parameters == null))
|
||||
return false;
|
||||
if (a.Parameters != null) {
|
||||
if (a.Parameters.Count != b.Parameters.Count)
|
||||
return false;
|
||||
for (int i = 0; i < a.Parameters.Count; i++) {
|
||||
if (!compareTypes(a.Parameters[i].ParameterType, b.Parameters[i].ParameterType))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return a.Name == b.Name &&
|
||||
compareTypes(a.PropertyType, b.PropertyType);
|
||||
}
|
||||
|
||||
public static int propertyReferenceHashCode(PropertyReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
|
||||
if (a.Parameters != null) {
|
||||
res += a.Parameters.Count.GetHashCode();
|
||||
foreach (var param in a.Parameters)
|
||||
res += typeHashCode(param.ParameterType);
|
||||
}
|
||||
|
||||
res += a.Name.GetHashCode();
|
||||
res += typeHashCode(a.PropertyType);
|
||||
return res;
|
||||
public static bool compareFieldReference(FieldReference a, FieldReference b) {
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public static bool compareTypes(TypeReference a, TypeReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
|
||||
var atype = a.GetType();
|
||||
var btype = b.GetType();
|
||||
if (atype != btype) {
|
||||
if ((atype == typeof(TypeReference) || atype == typeof(TypeDefinition)) &&
|
||||
(btype == typeof(TypeReference) || btype == typeof(TypeDefinition)))
|
||||
return compareTypeReferences(a, b);
|
||||
return false;
|
||||
}
|
||||
|
||||
var type = getMemberReferenceType(a);
|
||||
switch (type) {
|
||||
case CecilType.ArrayType:
|
||||
return compareArrayTypes((ArrayType)a, (ArrayType)b);
|
||||
case CecilType.ByReferenceType:
|
||||
return compareByReferenceTypes((ByReferenceType)a, (ByReferenceType)b);
|
||||
case CecilType.FunctionPointerType:
|
||||
return compareFunctionPointerTypes((FunctionPointerType)a, (FunctionPointerType)b);
|
||||
case CecilType.GenericInstanceType:
|
||||
return compareGenericInstanceTypes((GenericInstanceType)a, (GenericInstanceType)b);
|
||||
case CecilType.GenericParameter:
|
||||
return compareGenericParameters((GenericParameter)a, (GenericParameter)b);
|
||||
case CecilType.OptionalModifierType:
|
||||
return compareOptionalModifierTypes((OptionalModifierType)a, (OptionalModifierType)b);
|
||||
case CecilType.PinnedType:
|
||||
return comparePinnedTypes((PinnedType)a, (PinnedType)b);
|
||||
case CecilType.PointerType:
|
||||
return comparePointerTypes((PointerType)a, (PointerType)b);
|
||||
case CecilType.RequiredModifierType:
|
||||
return compareRequiredModifierTypes((RequiredModifierType)a, (RequiredModifierType)b);
|
||||
case CecilType.SentinelType:
|
||||
return compareSentinelTypes((SentinelType)a, (SentinelType)b);
|
||||
case CecilType.TypeDefinition:
|
||||
return compareTypeDefinitions((TypeDefinition)a, (TypeDefinition)b);
|
||||
case CecilType.TypeReference:
|
||||
return compareTypeReferences((TypeReference)a, (TypeReference)b);
|
||||
default:
|
||||
throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
|
||||
}
|
||||
}
|
||||
|
||||
public static int typeHashCode(TypeReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
|
||||
var type = getMemberReferenceType(a);
|
||||
switch (type) {
|
||||
case CecilType.ArrayType:
|
||||
return arrayTypeHashCode((ArrayType)a);
|
||||
case CecilType.ByReferenceType:
|
||||
return byReferenceTypeHashCode((ByReferenceType)a);
|
||||
case CecilType.FunctionPointerType:
|
||||
return functionPointerTypeHashCode((FunctionPointerType)a);
|
||||
case CecilType.GenericInstanceType:
|
||||
return genericInstanceTypeHashCode((GenericInstanceType)a);
|
||||
case CecilType.GenericParameter:
|
||||
return genericParameterHashCode((GenericParameter)a);
|
||||
case CecilType.OptionalModifierType:
|
||||
return optionalModifierTypeHashCode((OptionalModifierType)a);
|
||||
case CecilType.PinnedType:
|
||||
return pinnedTypeHashCode((PinnedType)a);
|
||||
case CecilType.PointerType:
|
||||
return pointerTypeHashCode((PointerType)a);
|
||||
case CecilType.RequiredModifierType:
|
||||
return requiredModifierTypeHashCode((RequiredModifierType)a);
|
||||
case CecilType.SentinelType:
|
||||
return sentinelTypeHashCode((SentinelType)a);
|
||||
case CecilType.TypeDefinition:
|
||||
return typeDefinitionHashCode((TypeDefinition)a);
|
||||
case CecilType.TypeReference:
|
||||
return typeReferenceHashCode((TypeReference)a);
|
||||
default:
|
||||
throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
|
||||
}
|
||||
}
|
||||
|
||||
static bool compareArrayTypes(ArrayType a, ArrayType b) {
|
||||
if (a.Rank != b.Rank || a.IsVector != b.IsVector)
|
||||
return false;
|
||||
if (!a.IsVector) {
|
||||
for (int i = 0; i < a.Dimensions.Count; i++) {
|
||||
if (!compareArrayDimensions(a.Dimensions[i], b.Dimensions[i]))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int arrayTypeHashCode(ArrayType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
|
||||
res += a.Rank.GetHashCode();
|
||||
res += a.IsVector.GetHashCode();
|
||||
if (!a.IsVector) {
|
||||
foreach (var dim in a.Dimensions)
|
||||
res += arrayDimensionHashCode(dim);
|
||||
}
|
||||
res += typeSpecificationHashCode(a);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static bool compareArrayDimensions(ArrayDimension a, ArrayDimension b) {
|
||||
return a.LowerBound == b.LowerBound && a.UpperBound == b.UpperBound;
|
||||
}
|
||||
|
||||
static int arrayDimensionHashCode(ArrayDimension a) {
|
||||
return a.LowerBound.GetHashCode() + a.UpperBound.GetHashCode();
|
||||
}
|
||||
|
||||
static bool compareGenericInstanceTypes(GenericInstanceType a, GenericInstanceType b) {
|
||||
if (a.HasGenericArguments != b.HasGenericArguments)
|
||||
return false;
|
||||
if (a.HasGenericArguments) {
|
||||
if (a.GenericArguments.Count != b.GenericArguments.Count)
|
||||
return false;
|
||||
for (int i = 0; i < a.GenericArguments.Count; i++) {
|
||||
if (!compareTypes(a.GenericArguments[i], b.GenericArguments[i]))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int genericInstanceTypeHashCode(GenericInstanceType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
int res = 0;
|
||||
|
||||
res += a.HasGenericArguments.GetHashCode();
|
||||
if (a.HasGenericArguments) {
|
||||
res += a.GenericArguments.Count.GetHashCode();
|
||||
foreach (var arg in a.GenericArguments)
|
||||
res += typeHashCode(arg);
|
||||
}
|
||||
res += typeSpecificationHashCode(a);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static bool comparePointerTypes(PointerType a, PointerType b) {
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int pointerTypeHashCode(PointerType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareByReferenceTypes(ByReferenceType a, ByReferenceType b) {
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int byReferenceTypeHashCode(ByReferenceType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool comparePinnedTypes(PinnedType a, PinnedType b) {
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int pinnedTypeHashCode(PinnedType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareFunctionPointerTypes(FunctionPointerType a, FunctionPointerType b) {
|
||||
return compareMethodReference(a.function, b.function) &&
|
||||
compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int functionPointerTypeHashCode(FunctionPointerType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return methodReferenceHashCode(a.function) + typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareOptionalModifierTypes(OptionalModifierType a, OptionalModifierType b) {
|
||||
return compareTypes(a.ModifierType, b.ModifierType) &&
|
||||
compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int optionalModifierTypeHashCode(OptionalModifierType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeHashCode(a.ModifierType) + typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareRequiredModifierTypes(RequiredModifierType a, RequiredModifierType b) {
|
||||
return compareTypes(a.ModifierType, b.ModifierType) &&
|
||||
compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int requiredModifierTypeHashCode(RequiredModifierType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeHashCode(a.ModifierType) + typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareSentinelTypes(SentinelType a, SentinelType b) {
|
||||
return compareTypeSpecifications(a, b);
|
||||
}
|
||||
|
||||
static int sentinelTypeHashCode(SentinelType a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeSpecificationHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareTypeSpecifications(TypeSpecification a, TypeSpecification b) {
|
||||
// It overrides everything of importance in TypeReference. The only thing to check
|
||||
// is the ElementType.
|
||||
return compareTypes(a.ElementType, b.ElementType);
|
||||
}
|
||||
|
||||
static int typeSpecificationHashCode(TypeSpecification a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeHashCode(a.ElementType);
|
||||
}
|
||||
|
||||
static bool compareTypeDefinitions(TypeDefinition a, TypeDefinition b) {
|
||||
return compareTypeReferences(a, b);
|
||||
}
|
||||
|
||||
static int typeDefinitionHashCode(TypeDefinition a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return typeReferenceHashCode(a);
|
||||
}
|
||||
|
||||
static bool compareGenericParameters(GenericParameter a, GenericParameter b) {
|
||||
return a.Position == b.Position &&
|
||||
compareGenericParameterProvider(a.Owner, b.Owner);
|
||||
}
|
||||
|
||||
static int genericParameterHashCode(GenericParameter a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
return a.Position.GetHashCode() + genericParameterProviderHashCode(a.Owner);
|
||||
}
|
||||
|
||||
// a and b must be either exactly a TypeReference or exactly a TypeDefinition
|
||||
static bool compareTypeReferences(TypeReference a, TypeReference b) {
|
||||
if ((a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition)) ||
|
||||
(b.GetType() != typeof(TypeReference) && b.GetType() != typeof(TypeDefinition)))
|
||||
throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
|
||||
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
|
||||
return a.Name == b.Name &&
|
||||
a.Namespace == b.Namespace &&
|
||||
compareTypes(a.DeclaringType, b.DeclaringType) &&
|
||||
compareScope(a.Scope, b.Scope);
|
||||
}
|
||||
|
||||
// a must be exactly a TypeReference or a TypeDefinition
|
||||
static int typeReferenceHashCode(TypeReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
|
||||
if (a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition))
|
||||
throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
|
||||
|
||||
int res = 0;
|
||||
|
||||
res += a.Name.GetHashCode();
|
||||
res += a.Namespace.GetHashCode();
|
||||
res += typeHashCode(a.DeclaringType);
|
||||
res += scopeHashCode(a.Scope);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
public static bool compareTypeReferenceSameVersion(TypeReference a, TypeReference b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
|
||||
if ((a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition)) ||
|
||||
(b.GetType() != typeof(TypeReference) && b.GetType() != typeof(TypeDefinition)))
|
||||
throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
|
||||
|
||||
return a.Name == b.Name &&
|
||||
a.Namespace == b.Namespace &&
|
||||
compareTypeReferenceSameVersion(a.DeclaringType, b.DeclaringType) &&
|
||||
compareScopeSameVersion(a.Scope, b.Scope);
|
||||
}
|
||||
|
||||
public static int typeReferenceHashCodeSameVersion(TypeReference a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
|
||||
if (a.GetType() != typeof(TypeReference) && a.GetType() != typeof(TypeDefinition))
|
||||
throw new ApplicationException("arg must be exactly of type TypeReference or TypeDefinition");
|
||||
|
||||
int res = 0;
|
||||
|
||||
res += a.Name.GetHashCode();
|
||||
res += a.Namespace.GetHashCode();
|
||||
res += typeReferenceHashCodeSameVersion(a.DeclaringType);
|
||||
res += scopeHashCodeSameVersion(a.Scope);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
static bool compareGenericParameterProvider(IGenericParameterProvider a, IGenericParameterProvider b) {
|
||||
if (ReferenceEquals(a, b))
|
||||
return true;
|
||||
if (a == null || b == null)
|
||||
return false;
|
||||
if (a is TypeReference && b is TypeReference)
|
||||
return compareTypes((TypeReference)a, (TypeReference)b);
|
||||
if (a is MethodReference && b is MethodReference)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
static int genericParameterProviderHashCode(IGenericParameterProvider a) {
|
||||
if (a == null)
|
||||
return 0;
|
||||
if (a is TypeReference)
|
||||
return typeHashCode((TypeReference)a);
|
||||
if (a is MethodReference)
|
||||
return 0;
|
||||
throw new ApplicationException(string.Format("Unknown IGenericParameterProvider type {0}", a.GetType()));
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -26,35 +26,7 @@ namespace de4dot.blocks {
|
|||
if (a == null)
|
||||
return null;
|
||||
|
||||
var type = MemberReferenceHelper.getMemberReferenceType(a);
|
||||
switch (type) {
|
||||
case CecilType.ArrayType:
|
||||
return updateArrayType((ArrayType)a);
|
||||
case CecilType.ByReferenceType:
|
||||
return updateByReferenceType((ByReferenceType)a);
|
||||
case CecilType.FunctionPointerType:
|
||||
return updateFunctionPointerType((FunctionPointerType)a);
|
||||
case CecilType.GenericInstanceType:
|
||||
return updateGenericInstanceType((GenericInstanceType)a);
|
||||
case CecilType.GenericParameter:
|
||||
return updateGenericParameter((GenericParameter)a);
|
||||
case CecilType.OptionalModifierType:
|
||||
return updateOptionalModifierType((OptionalModifierType)a);
|
||||
case CecilType.PinnedType:
|
||||
return updatePinnedType((PinnedType)a);
|
||||
case CecilType.PointerType:
|
||||
return updatePointerType((PointerType)a);
|
||||
case CecilType.RequiredModifierType:
|
||||
return updateRequiredModifierType((RequiredModifierType)a);
|
||||
case CecilType.SentinelType:
|
||||
return updateSentinelType((SentinelType)a);
|
||||
case CecilType.TypeDefinition:
|
||||
return updateTypeDefinition((TypeDefinition)a);
|
||||
case CecilType.TypeReference:
|
||||
return updateTypeReference((TypeReference)a);
|
||||
default:
|
||||
throw new ApplicationException(string.Format("Unknown cecil type {0}", type));
|
||||
}
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
protected virtual ArrayType updateArrayType(ArrayType a) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user