public Ref <Types> OptionalModifier(Ref <Types> elementType, ClassName className) { var elementRefType = RefToValue(elementType); var modifierType = ClassNameToTypeReference(className); var type = new OptionalModifierType(modifierType, elementRefType); return(ValueToRef(type)); }
void addOptionalModifierType(OptionalModifierType omt) { if (omt == null) { return; } addTypeSpecification(omt); pushMember(omt.ModifierType); }
void doOptionalModifierType(OptionalModifierType optionalModifierType) { if (optionalModifierTypes.ContainsKey(optionalModifierType)) { return; } optionalModifierTypes[optionalModifierType] = true; addOptionalModifierType(optionalModifierType); }
public TypeReference Visit(OptionalModifierType current, IGenericContext gcontext) { var result = new OptionalModifierType(Get(current.ModifierType, gcontext), Get(current.ElementType, gcontext)); if (current.HasGenericParameters) { CopyAndUpdate(result, current, gcontext); } return(result); }
public NetTypeReference Visit(OptionalModifierType type, ResolveData data) { throw new NotImplementedException("OptionalModifierType to NetTypeReference"); }
/// <summary> /// Gets a TypeRef from a TypeReference. /// </summary> /// <param name="type">The TypeReference.</param> /// <returns>The TypeRef.</returns> public static TypeRef GetTypeRefFromType(TypeReference type) { switch (type.MetadataType) { case MetadataType.UInt64: case MetadataType.Int64: return(Int64); case MetadataType.UInt32: case MetadataType.Int32: return(Int32); case MetadataType.UInt16: case MetadataType.Int16: return(Int16); case MetadataType.Byte: case MetadataType.SByte: return(Int8); case MetadataType.Char: return(Int8); case MetadataType.String: return(String); case MetadataType.Boolean: return(Boolean); case MetadataType.Void: return(Void); case MetadataType.Single: return(Float); case MetadataType.Double: return(Double); case MetadataType.IntPtr: case MetadataType.UIntPtr: return(NativeIntType); case MetadataType.Array: ArrayType array = (ArrayType)type; return(LLVM.PointerType(GetTypeRefFromType(array.ElementType), 0)); case MetadataType.Pointer: PointerType ptr = (PointerType)type; return(LLVM.PointerType(GetTypeRefFromType(ptr.ElementType), 0)); case MetadataType.ByReference: ByReferenceType byRef = (ByReferenceType)type; return(LLVM.PointerType(GetTypeRefFromType(byRef.ElementType), 0)); case MetadataType.Pinned: PinnedType pinned = (PinnedType)type; return(GetTypeRefFromType(pinned.ElementType)); case MetadataType.Class: return(LLVM.PointerType(mLookup.GetTypeRef(type), 0)); case MetadataType.ValueType: return(mLookup.GetTypeRef(type)); case MetadataType.GenericInstance: case MetadataType.Var: case MetadataType.Object: return(VoidPtr); case MetadataType.RequiredModifier: RequiredModifierType requiredModifier = (RequiredModifierType)type; return(GetTypeRefFromType(requiredModifier.ElementType)); case MetadataType.OptionalModifier: OptionalModifierType optionalModifier = (OptionalModifierType)type; return(GetTypeRefFromType(optionalModifier.ElementType)); default: throw new InvalidOperationException("Invalid meta data type to get type from: " + type.MetadataType); } }
private static TypeReference ImportType(TypeReference typeRef, ModuleDefinition mod, MethodReference context, Dictionary <MetadataToken, IMemberDefinition> mems) { TypeReference ret = typeRef; if (typeRef is TypeSpecification) { if (typeRef is ArrayType) { ArrayType _spec = typeRef as ArrayType; ret = new ArrayType(ImportType(_spec.ElementType, mod, context, mems)); (ret as ArrayType).Dimensions.Clear(); foreach (var i in _spec.Dimensions) { (ret as ArrayType).Dimensions.Add(i); } } else if (typeRef is GenericInstanceType) { GenericInstanceType _spec = typeRef as GenericInstanceType; ret = new GenericInstanceType(ImportType(_spec.ElementType, mod, context, mems)); foreach (var i in _spec.GenericArguments) { (ret as GenericInstanceType).GenericArguments.Add(ImportType(i, mod, context, mems)); } } else if (typeRef is OptionalModifierType) { ret = new OptionalModifierType( ImportType((typeRef as OptionalModifierType).ModifierType, mod, context, mems), ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else if (typeRef is RequiredModifierType) { ret = new RequiredModifierType( ImportType((typeRef as RequiredModifierType).ModifierType, mod, context, mems), ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else if (typeRef is ByReferenceType) { ret = new ByReferenceType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else if (typeRef is PointerType) { ret = new PointerType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else if (typeRef is PinnedType) { ret = new PinnedType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else if (typeRef is SentinelType) { ret = new SentinelType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems)); } else { throw new NotSupportedException(); } } else if (typeRef is GenericParameter) { if (context == null || (typeRef as GenericParameter).Owner is TypeReference || (typeRef as GenericParameter).Position >= context.GenericParameters.Count) { return(typeRef); } return(context.GenericParameters[(typeRef as GenericParameter).Position]); } else { if (mems != null && mems.ContainsKey(typeRef.MetadataToken)) { ret = mems[typeRef.MetadataToken] as TypeReference; } else if (!(ret is TypeDefinition) && typeRef.Scope.Name != "Confuser.Core.Injections.dll") { ret = mod.Import(ret); } } return(ret); }
private static string GetFriendlyFullOptionalModifierTypeName(this OptionalModifierType self, ILanguage language) { return(String.Concat(self.GetFriendlyFullTypeSpecificationName(language), self.get_Suffix())); }
static bool Match(TypeReference type, TypeReference target) { if (!(target is TypeSpecification)) { return(type.Name == target.Name && type.Namespace == target.Namespace); } if (type.MetadataType != target.MetadataType) { return(false); } TypeSpecification typeSpecA = type as TypeSpecification; TypeSpecification typeSpecB = target as TypeSpecification; switch (type.MetadataType) { case MetadataType.Array: { ArrayType arrA = type as ArrayType, arrB = target as ArrayType; if (arrA.Dimensions.Count != arrB.Dimensions.Count) { return(false); } for (int i = 0; i < arrA.Dimensions.Count; i++) { if (arrA.Dimensions[i].LowerBound != arrB.Dimensions[i].LowerBound || arrA.Dimensions[i].UpperBound != arrB.Dimensions[i].UpperBound) { return(false); } } return(Match(typeSpecA.ElementType, typeSpecB.ElementType)); } case MetadataType.RequiredModifier: { RequiredModifierType modA = type as RequiredModifierType, modB = target as RequiredModifierType; return(Match(modA.ModifierType, modB.ModifierType) && Match(typeSpecA.ElementType, typeSpecB.ElementType)); } case MetadataType.OptionalModifier: { OptionalModifierType modA = type as OptionalModifierType, modB = target as OptionalModifierType; return(Match(modA.ModifierType, modB.ModifierType) && Match(typeSpecA.ElementType, typeSpecB.ElementType)); } case MetadataType.ByReference: case MetadataType.Pinned: case MetadataType.Pointer: return(Match(typeSpecA.ElementType, typeSpecB.ElementType)); case MetadataType.GenericInstance: GenericInstanceType instA = type as GenericInstanceType, instB = target as GenericInstanceType; if (instA.GenericArguments.Count != instB.GenericArguments.Count) { return(false); } for (int i = 0; i < instA.GenericArguments.Count; i++) { if (!Match(instA.GenericArguments[i], instB.GenericArguments[i])) { return(false); } } return(Match(typeSpecA.ElementType, typeSpecB.ElementType)); case MetadataType.FunctionPointer: //not support throw new NotSupportedException(); } return(false); }
/* AGPL */ private static string GetFriendlyFullOptionalModifierTypeName(this OptionalModifierType self, ILanguage language, bool includeNamespace = true) { return(self.GetFriendlyFullTypeSpecificationName(language, includeNamespace) + self.Suffix); }
public static bool AreEqual(TypeReference a, TypeReference b, TypeComparisonMode comparisonMode = 0) { if (object.ReferenceEquals(a, b)) { return(true); } if ((a == null) || (b == null)) { return(false); } MetadataType metadataType = a.MetadataType; MetadataType type2 = b.MetadataType; if ((metadataType == MetadataType.GenericInstance) || (type2 == MetadataType.GenericInstance)) { if (metadataType != type2) { return(false); } return(AreEqual((GenericInstanceType)a, (GenericInstanceType)b, comparisonMode)); } if ((metadataType == MetadataType.Array) || (type2 == MetadataType.Array)) { if (metadataType != type2) { return(false); } ArrayType type3 = (ArrayType)a; ArrayType type4 = (ArrayType)b; if (type3.Rank != type4.Rank) { return(false); } return(AreEqual(type3.ElementType, type4.ElementType, comparisonMode)); } if ((metadataType == MetadataType.Var) || (type2 == MetadataType.Var)) { if (metadataType != type2) { return(false); } return(AreEqual((GenericParameter)a, (GenericParameter)b, TypeComparisonMode.Exact)); } if ((metadataType == MetadataType.MVar) || (type2 == MetadataType.MVar)) { if (metadataType != type2) { return(false); } return(AreEqual((GenericParameter)a, (GenericParameter)b, comparisonMode)); } if ((metadataType == MetadataType.ByReference) || (type2 == MetadataType.ByReference)) { if (metadataType != type2) { return(false); } return(AreEqual(((ByReferenceType)a).ElementType, ((ByReferenceType)b).ElementType, comparisonMode)); } if ((metadataType == MetadataType.Pointer) || (type2 == MetadataType.Pointer)) { if (metadataType != type2) { return(false); } return(AreEqual(((PointerType)a).ElementType, ((PointerType)b).ElementType, comparisonMode)); } if ((metadataType == MetadataType.RequiredModifier) || (type2 == MetadataType.RequiredModifier)) { if (metadataType != type2) { return(false); } RequiredModifierType type5 = (RequiredModifierType)a; RequiredModifierType type6 = (RequiredModifierType)b; return(AreEqual(type5.ModifierType, type6.ModifierType, TypeComparisonMode.Exact) && AreEqual(type5.ElementType, type6.ElementType, comparisonMode)); } if ((metadataType == MetadataType.OptionalModifier) || (type2 == MetadataType.OptionalModifier)) { if (metadataType != type2) { return(false); } OptionalModifierType type7 = (OptionalModifierType)a; OptionalModifierType type8 = (OptionalModifierType)b; return(AreEqual(type7.ModifierType, type8.ModifierType, TypeComparisonMode.Exact) && AreEqual(type7.ElementType, type8.ElementType, comparisonMode)); } if ((metadataType == MetadataType.Pinned) || (type2 == MetadataType.Pinned)) { if (metadataType != type2) { return(false); } return(AreEqual(((PinnedType)a).ElementType, ((PinnedType)b).ElementType, comparisonMode)); } if ((metadataType == MetadataType.Sentinel) || (type2 == MetadataType.Sentinel)) { if (metadataType != type2) { return(false); } return(AreEqual(((SentinelType)a).ElementType, ((SentinelType)b).ElementType, TypeComparisonMode.Exact)); } if (!a.Name.Equals(b.Name) || !a.Namespace.Equals(b.Namespace)) { return(false); } TypeDefinition definition = a.Resolve(); TypeDefinition definition2 = b.Resolve(); return(definition == definition2); }
public static bool IsEqual(Reflector.CodeModel.IType t, TypeReference tr) { if (t is Reflector.CodeModel.ITypeReference) { return(IsEqual((Reflector.CodeModel.ITypeReference)t, tr)); } else if ((t is Reflector.CodeModel.IArrayType) && (tr is ArrayType)) { Reflector.CodeModel.IArrayType t2 = (Reflector.CodeModel.IArrayType)t; ArrayType tr2 = (ArrayType)tr; if ( !(t2.Dimensions.Count == 0 && tr2.Dimensions.Count == 1) && // one dimension (t2.Dimensions.Count != tr2.Dimensions.Count) // two or more dimension ) { return(false); } return(IsEqual(t2.ElementType, tr2.ElementType)); } else if ((t is Reflector.CodeModel.IReferenceType) && (tr is ByReferenceType)) { return(IsEqual(((Reflector.CodeModel.IReferenceType)t).ElementType, ((ByReferenceType)tr).ElementType)); } else if ((t is Reflector.CodeModel.IPointerType) && (tr is PointerType)) { return(IsEqual(((Reflector.CodeModel.IPointerType)t).ElementType, ((PointerType)tr).ElementType)); } else if ((t is Reflector.CodeModel.IOptionalModifier) && (tr is OptionalModifierType)) { Reflector.CodeModel.IOptionalModifier t2 = (Reflector.CodeModel.IOptionalModifier)t; OptionalModifierType tr2 = (OptionalModifierType)tr; return(IsEqual(t2.Modifier, tr2.ModifierType) && IsEqual(t2.ElementType, tr2.ElementType)); } else if ((t is Reflector.CodeModel.IFunctionPointer) && (tr is FunctionPointerType)) { Reflector.CodeModel.IFunctionPointer t2 = (Reflector.CodeModel.IFunctionPointer)t; FunctionPointerType tr2 = (FunctionPointerType)tr; if (t2.Parameters.Count == tr2.Parameters.Count && IsEqual(t2.ReturnType.Type, tr2.ReturnType)) { for (int i = 0; i < t2.Parameters.Count; i++) { if (!IsEqual(t2.Parameters[i].ParameterType, tr2.Parameters[i].ParameterType)) { return(false); } } return(true); } return(false); } else if ((t is Reflector.CodeModel.IRequiredModifier) && (tr is RequiredModifierType)) { Reflector.CodeModel.IRequiredModifier t2 = (Reflector.CodeModel.IRequiredModifier)t; RequiredModifierType tr2 = (RequiredModifierType)tr; return(IsEqual(t2.Modifier, tr2.ModifierType) && IsEqual(t2.ElementType, tr2.ElementType)); } else { string trName = InsUtils.GetOldMemberName(tr); //when tr is GenericParameter, it may be !0 or something, no clue what it is, no luck ... if ("!0" == trName && t.ToString() == "T") { return(true); } return(t.ToString().Equals(trName)); } }
public CodeTypeReference Visit(OptionalModifierType type, object data) { throw new System.NotImplementedException(); }
public TypeReference Resolve(TypeReference typeReference) { GenericParameter genericParameter = typeReference as GenericParameter; if (genericParameter != null) { return(this.Resolve(this.ResolveGenericParameter(genericParameter))); } ArrayType arrayType = typeReference as ArrayType; if (arrayType != null) { return(new ArrayType(this.Resolve(arrayType.ElementType), arrayType.Rank)); } PointerType pointerType = typeReference as PointerType; if (pointerType != null) { return(new PointerType(this.Resolve(pointerType.ElementType))); } ByReferenceType byReferenceType = typeReference as ByReferenceType; if (byReferenceType != null) { return(new ByReferenceType(this.Resolve(byReferenceType.ElementType))); } GenericInstanceType genericInstanceType = typeReference as GenericInstanceType; if (genericInstanceType != null) { GenericInstanceType genericInstanceType2 = new GenericInstanceType(this.Resolve(genericInstanceType.ElementType)); foreach (TypeReference current in genericInstanceType.GenericArguments) { genericInstanceType2.GenericArguments.Add(this.Resolve(current)); } return(genericInstanceType2); } PinnedType pinnedType = typeReference as PinnedType; if (pinnedType != null) { return(new PinnedType(this.Resolve(pinnedType.ElementType))); } RequiredModifierType requiredModifierType = typeReference as RequiredModifierType; if (requiredModifierType != null) { return(this.Resolve(requiredModifierType.ElementType)); } OptionalModifierType optionalModifierType = typeReference as OptionalModifierType; if (optionalModifierType != null) { return(new OptionalModifierType(this.Resolve(optionalModifierType.ModifierType), this.Resolve(optionalModifierType.ElementType))); } SentinelType sentinelType = typeReference as SentinelType; if (sentinelType != null) { return(new SentinelType(this.Resolve(sentinelType.ElementType))); } FunctionPointerType functionPointerType = typeReference as FunctionPointerType; if (functionPointerType != null) { throw new NotSupportedException("Function pointer types are not supported by the SerializationWeaver"); } if (typeReference is TypeSpecification) { throw new NotSupportedException(); } return(typeReference); }
private void GetXmlDocParameterPathRecursive( TypeReference tpType, bool ExplicitMode, StringBuilder CurrPath) { if (tpType == null) { return; } if (tpType.GenericParameters.Count > 0) { CurrPath.Append( tpType.Namespace + ((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : ".") + StripGenericName(tpType.Name)); // list parameters or types bool firstAppend = true; CurrPath.Append("{"); foreach (GenericParameter TempType in tpType.GenericParameters) { if (!firstAppend) { CurrPath.Append(","); } CurrPath.Append(GetXmlDocParameterPath(TempType, ExplicitMode)); firstAppend = false; } CurrPath.Append("}"); } else if (tpType is GenericInstanceType) { GenericInstanceType thisGenericType = tpType as GenericInstanceType; // if nested, scan enclosing type if (tpType.DeclaringType != null) { CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode)); } // determine namespace string strNamespace = string.Empty; if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null) { strNamespace = tpType.Namespace + ((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : "."); } CurrPath.Append(strNamespace + StripGenericName(thisGenericType.Name)); // list parameters or types bool firstAppend = true; CurrPath.Append("{"); foreach (TypeReference tempTypeRef in thisGenericType.GenericArguments) { if (!firstAppend) { CurrPath.Append(","); } CurrPath.Append(GetXmlDocParameterPath(tempTypeRef, ExplicitMode)); firstAppend = false; } CurrPath.Append("}"); } else if (tpType is GenericParameter) { GenericParameter thisGenParam = tpType as GenericParameter; if (ExplicitMode) { // in explicit mode we print parameter name CurrPath.Append(thisGenParam.Name); } else { // in non-explicit mode we print parameter order int paramOrder = 0; // find for (int i = 0; i < thisGenParam.Owner.GenericParameters.Count; i++) { if (thisGenParam.Owner.GenericParameters[i].Name == tpType.Name) { paramOrder = i; break; } } if (thisGenParam.Owner is MethodReference) { CurrPath.Append("``" + paramOrder); } else { CurrPath.Append("`" + paramOrder); } } } else if (tpType is PointerType) { // parameter is pointer type CurrPath.Append(GetXmlDocParameterPath((tpType as PointerType).ElementType, ExplicitMode)); CurrPath.Append("*"); } else if (tpType is ArrayType) { ArrayType thisArrayType = tpType as ArrayType; if (thisArrayType.ElementType != null) { CurrPath.Append(GetXmlDocParameterPath(thisArrayType.ElementType, ExplicitMode)); } int iRank = thisArrayType.Rank; if (iRank == 1) { CurrPath.Append("[]"); } else { bool firstAppend = true; CurrPath.Append("["); for (int i = 0; i < (ExplicitMode ? iRank - 1 : iRank); i++) { // in explicit mode for .NET3.5/VS2008, // there is no separator char "," used for multi-dimensional array, // so there are three cases when comma shall be added: // firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = true; // firstAppend = false; ExplicitMode = false; CanAppendSpecialExplicitChar() = false; // firstAppend = false; ExplicitMode = true; CanAppendSpecialExplicitChar() = false; // below this is stored in decent manner if (!firstAppend && (!ExplicitMode || !CanAppendSpecialExplicitChar())) { CurrPath.Append(","); } CurrPath.Append(((CanAppendSpecialExplicitChar() && ExplicitMode) ? "@" : "0:")); if (thisArrayType.Dimensions[i].UpperBound > 0) { CurrPath.Append(thisArrayType.Dimensions[i].UpperBound.ToString()); } firstAppend = false; } CurrPath.Append("]"); } } else if (tpType is ByReferenceType) { // parameter is passed by reference CurrPath.Append(GetXmlDocParameterPath((tpType as ByReferenceType).ElementType, false)); CurrPath.Append("@"); } else if (tpType is OptionalModifierType) { // parameter has optional modifier OptionalModifierType thisModOpt = tpType as OptionalModifierType; CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ElementType, ExplicitMode)); CurrPath.Append("!"); CurrPath.Append(GetXmlDocParameterPath(thisModOpt.ModifierType, ExplicitMode)); } else if (tpType is RequiredModifierType) { // parameter has required modifier RequiredModifierType thisModReq = tpType as RequiredModifierType; CurrPath.Append(GetXmlDocParameterPath(thisModReq.ElementType, ExplicitMode)); CurrPath.Append("|"); CurrPath.Append(GetXmlDocParameterPath(thisModReq.ModifierType, ExplicitMode)); } else if (tpType is FunctionPointerType) { // type is function pointer FunctionPointerType thisFuncPtr = tpType as FunctionPointerType; string tempString = string.Empty; // return type CurrPath.Append("=FUNC:"); CurrPath.Append(GetXmlDocParameterPath(thisFuncPtr.ReturnType, ExplicitMode)); // method's parameters if (thisFuncPtr.Parameters.Count > 0) { bool firstAppend = true; CurrPath.Append("("); foreach (ParameterDefinition tempParam in thisFuncPtr.Parameters) { if (!firstAppend) { CurrPath.Append(","); } CurrPath.Append(GetXmlDocParameterPath(tempParam.ParameterType, ExplicitMode)); firstAppend = false; } CurrPath.Append(")"); } else { CurrPath.Append("(System.Void)"); } } else if (tpType is PinnedType) { // type is pinned type CurrPath.Append(GetXmlDocParameterPath((tpType as PinnedType).ElementType, ExplicitMode)); CurrPath.Append("^"); } else if (tpType is TypeReference) { // if nested, scan enclosing type if (tpType.DeclaringType != null) { CurrPath.Append(GetXmlDocParameterPath(tpType.DeclaringType, ExplicitMode)); } // determine namespace string strNamespace = string.Empty; if ((tpType.Namespace != null && tpType.Namespace.Length > 0) || tpType.DeclaringType != null) { strNamespace = tpType.Namespace + ((CanAppendSpecialExplicitChar() && ExplicitMode) ? "#" : "."); } // concrete type CurrPath.Append( strNamespace + ((CanAppendSpecialExplicitChar() && ExplicitMode) ? tpType.Name.Replace(".", "#") : tpType.Name)); } }
static bool compareOptionalModifierTypes(Type a, OptionalModifierType b) { return compareTypes(a, b.ElementType); }
protected virtual OptionalModifierType updateOptionalModifierType(OptionalModifierType a) { return(new OptionalModifierType(update(a.ModifierType), update(a.ElementType))); }
protected override StringBuilder AppendOptionalModifierType(StringBuilder buf, OptionalModifierType type, DynamicParserContext context) { if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsLong" && type.ElementType.FullName == "System.Int32") { return(buf.Append("long")); } if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsSignUnspecifiedByte" && type.ElementType.FullName == "System.SByte") { return(buf.Append("char")); } if (type.ModifierType.FullName == "System.Runtime.CompilerServices.IsConst") { buf.Append("const "); _AppendTypeName(buf, type.ElementType, context); return(buf); } _AppendTypeName(buf, type.ElementType, context); buf.Append(" modopt("); _AppendTypeName(buf, type.ModifierType, context); buf.Append(')'); return(buf); }
protected void TypeIdentifier(OptionalModifierType modopt, TypeReferenceContext context, bool includeParens) { Identifier(modopt.ElementType as dynamic, context, includeParens); }
public static int GetHashCodeFor(TypeReference obj) { MetadataType metadataType = obj.MetadataType; switch (metadataType) { case MetadataType.GenericInstance: { GenericInstanceType type2 = (GenericInstanceType)obj; int num = (GetHashCodeFor(type2.ElementType) * 0x1cfaa2db) + 0x1f; for (int i = 0; i < type2.GenericArguments.Count; i++) { num = (num * 0x1cfaa2db) + GetHashCodeFor(type2.GenericArguments[i]); } return(num); } case MetadataType.Array: { ArrayType type3 = (ArrayType)obj; return((GetHashCodeFor(type3.ElementType) * 0x1cfaa2db) + type3.Rank.GetHashCode()); } case MetadataType.Var: case MetadataType.MVar: { GenericParameter parameter = (GenericParameter)obj; int num7 = (int)metadataType; int num5 = (parameter.Position.GetHashCode() * 0x1cfaa2db) + num7.GetHashCode(); TypeReference owner = parameter.Owner as TypeReference; if (owner != null) { return((num5 * 0x1cfaa2db) + GetHashCodeFor(owner)); } MethodReference reference2 = parameter.Owner as MethodReference; if (reference2 == null) { throw new InvalidOperationException("Generic parameter encountered with invalid owner"); } return((num5 * 0x1cfaa2db) + Unity.IL2CPP.Common.MethodReferenceComparer.GetHashCodeFor(reference2)); } case MetadataType.ByReference: { ByReferenceType type4 = (ByReferenceType)obj; return((GetHashCodeFor(type4.ElementType) * 0x1cfaa2db) * 0x25); } case MetadataType.Pointer: { PointerType type5 = (PointerType)obj; return((GetHashCodeFor(type5.ElementType) * 0x1cfaa2db) * 0x29); } case MetadataType.RequiredModifier: { RequiredModifierType type6 = (RequiredModifierType)obj; int num8 = GetHashCodeFor(type6.ElementType) * 0x2b; return((num8 * 0x1cfaa2db) + GetHashCodeFor(type6.ModifierType)); } case MetadataType.OptionalModifier: { OptionalModifierType type7 = (OptionalModifierType)obj; int num9 = GetHashCodeFor(type7.ElementType) * 0x2f; return((num9 * 0x1cfaa2db) + GetHashCodeFor(type7.ModifierType)); } case MetadataType.Pinned: { PinnedType type8 = (PinnedType)obj; return((GetHashCodeFor(type8.ElementType) * 0x1cfaa2db) * 0x35); } case MetadataType.Sentinel: { SentinelType type9 = (SentinelType)obj; return((GetHashCodeFor(type9.ElementType) * 0x1cfaa2db) * 0x3b); } case MetadataType.FunctionPointer: throw new NotImplementedException("We currently don't handle function pointer types."); } return((obj.Namespace.GetHashCode() * 0x1cfaa2db) + obj.FullName.GetHashCode()); }
protected override StringBuilder AppendOptionalModifierType(StringBuilder buf, OptionalModifierType type, DynamicParserContext context) { _AppendTypeName(buf, type.ElementType, context); buf.Append(" modopt("); _AppendTypeName(buf, type.ModifierType, context); buf.Append(')'); return(buf); }
public TypeReference Resolve(TypeReference typeReference) { GenericParameter genericParameter = typeReference as GenericParameter; if (genericParameter != null) { return(this.Resolve(this.ResolveGenericParameter(genericParameter))); } ArrayType type = typeReference as ArrayType; if (type != null) { return(new ArrayType(this.Resolve(type.ElementType), type.Rank)); } PointerType type2 = typeReference as PointerType; if (type2 != null) { return(new PointerType(this.Resolve(type2.ElementType))); } ByReferenceType type3 = typeReference as ByReferenceType; if (type3 != null) { return(new ByReferenceType(this.Resolve(type3.ElementType))); } GenericInstanceType type4 = typeReference as GenericInstanceType; if (type4 != null) { GenericInstanceType type5 = new GenericInstanceType(this.Resolve(type4.ElementType)); foreach (TypeReference reference2 in type4.GenericArguments) { type5.GenericArguments.Add(this.Resolve(reference2)); } return(type5); } PinnedType type6 = typeReference as PinnedType; if (type6 != null) { return(new PinnedType(this.Resolve(type6.ElementType))); } RequiredModifierType type7 = typeReference as RequiredModifierType; if (type7 != null) { return(this.Resolve(type7.ElementType)); } OptionalModifierType type8 = typeReference as OptionalModifierType; if (type8 != null) { return(new OptionalModifierType(this.Resolve(type8.ModifierType), this.Resolve(type8.ElementType))); } SentinelType type9 = typeReference as SentinelType; if (type9 != null) { return(new SentinelType(this.Resolve(type9.ElementType))); } if (typeReference is FunctionPointerType) { throw new NotSupportedException("Function pointer types are not supported by the SerializationWeaver"); } if (typeReference is TypeSpecification) { throw new NotSupportedException(); } return(typeReference); }