/// <summary> /// Get the base TypeSig. /// </summary> /// <param name="typeSig">TypeSig</param> /// <param name="modifiers">Modifiers to set</param> /// <returns>Base TypeSig</returns> public static TypeSig ToBaseSig(TypeSig typeSig, out Stack<String> modifiers) { modifiers = new Stack<String>(); // While a non-leaf sig while (typeSig.Next != null) { if (typeSig.IsSZArray) { modifiers.Push("[]"); typeSig = typeSig.Next; } else if (typeSig.IsPointer) { modifiers.Push("*"); typeSig = typeSig.Next; } else if (typeSig.IsByRef) { modifiers.Push("&"); typeSig = typeSig.Next; } //else if (typeSig.IsArray) //{ //} else return null; } return typeSig; }
public static int GetInformationAmount(TypeSig type) { type = GetEnumUnderlyingType(type) ?? type; if (type == null) return 0; switch (type.ElementType) { case ElementType.Void: return 0; case ElementType.Boolean: return 1; case ElementType.I1: case ElementType.U1: return 8; case ElementType.Char: case ElementType.I2: case ElementType.U2: return 16; case ElementType.I4: case ElementType.U4: case ElementType.R4: return 32; case ElementType.I8: case ElementType.U8: case ElementType.R8: return 64; case ElementType.I: case ElementType.U: return NativeInt; default: return 100; // we consider structs/objects to have more information than any primitives } }
public static TypeSig create(TypeSig type, IList<TypeSig> genericArgs, IList<TypeSig> genericMethodArgs) { if (type == null || ((genericArgs == null || genericArgs.Count == 0) && (genericMethodArgs == null || genericMethodArgs.Count == 0))) return type; return new GenericArgsSubstitutor(genericArgs, genericMethodArgs).create(type); }
public static string ValueToString(object value, TypeSig storageType) { var t = storageType.RemovePinnedAndModifiers(); bool addCast = t.GetElementType() == ElementType.Object; if (t is SZArraySig) addCast = t.Next.RemovePinnedAndModifiers().GetElementType() == ElementType.Object; return ValueToString(value, addCast); }
bool IsFnPtrSig(TypeSig sig) { while (sig != null) { if (sig is FnPtrSig) return true; sig = sig.Next; } return false; }
public static TypeDef CreateDelegate(this DNContext context, string @namespace, string name, TypeSig returnType, out MethodDef invoke, params TypeSig[] parameters) { var cResolver = context.Resolver; var typeSys = context.PrimaryAssembly.ManifestModule.CorLibTypes; var delegateType = new TypeDefUser(@namespace, name, cResolver.ReferenceOf(typeof(MulticastDelegate))); delegateType.Attributes = TypeAttributes.Public | TypeAttributes.AutoClass | TypeAttributes.Sealed; var ctor = new MethodDefUser(".ctor", MethodSig.CreateInstance(typeSys.Void, typeSys.Object, typeSys.IntPtr), MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); ctor.ImplAttributes |= MethodImplAttributes.Runtime; // param 0 is 'this' ctor.Parameters[1].CreateParamDef(); ctor.Parameters[1].ParamDef.Name = "object"; ctor.Parameters[2].CreateParamDef(); ctor.Parameters[2].ParamDef.Name = "method"; delegateType.Methods.Add(ctor); invoke = new MethodDefUser("Invoke", MethodSig.CreateInstance(returnType, parameters), MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual); invoke.ImplAttributes |= MethodImplAttributes.Runtime; for (int i = 1; i <= parameters.Length; i++) { invoke.Parameters[i].CreateParamDef(); invoke.Parameters[i].ParamDef.Name = "arg" + (i - 1); } delegateType.Methods.Add(invoke); var beginInvoke = new MethodDefUser("BeginInvoke", MethodSig.CreateInstance(cResolver.ReferenceOf(typeof(IAsyncResult)).ToTypeSig(), parameters.Concat(new[] { cResolver.ReferenceOf(typeof(AsyncCallback)).ToTypeSig(), typeSys.Object }).ToArray()), MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual); beginInvoke.ImplAttributes |= MethodImplAttributes.Runtime; for (int i = 0; i < parameters.Length; i++) { beginInvoke.Parameters[i + 1].CreateParamDef(); beginInvoke.Parameters[i + 1].ParamDef.Name = "arg" + i; } beginInvoke.Parameters[beginInvoke.Parameters.Count - 2].CreateParamDef(); beginInvoke.Parameters[beginInvoke.Parameters.Count - 2].ParamDef.Name = "callback"; beginInvoke.Parameters[beginInvoke.Parameters.Count - 1].CreateParamDef(); beginInvoke.Parameters[beginInvoke.Parameters.Count - 1].ParamDef.Name = "object" ; delegateType.Methods.Add(beginInvoke); var endInvoke = new MethodDefUser("EndInvoke", MethodSig.CreateInstance(typeSys.Void, cResolver.ReferenceOf(typeof(IAsyncResult)).ToTypeSig()), MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual); endInvoke.ImplAttributes |= MethodImplAttributes.Runtime; endInvoke.Parameters[1].CreateParamDef(); endInvoke.Parameters[1].ParamDef.Name = "result"; delegateType.Methods.Add(endInvoke); context.PrimaryAssembly.ManifestModule.Types.Add(delegateType); return delegateType; }
private void AddTypeSigReference(TypeSig typeSig, INameReference<IDnlibDef> reference) { foreach (ITypeDefOrRef type in typeSig.FindTypeRefs()) { TypeDef typeDef = type.ResolveTypeDefThrow(); if (context.Modules.Contains((ModuleDefMD)typeDef.Module)) { service.ReduceRenameMode(typeDef, RenameMode.Letters); service.AddReference(typeDef, reference); } } }
bool ReplaceGenericArg(ref TypeSig typeSig) { if (genericArguments == null) return false; TypeSig newTypeSig = genericArguments.Resolve(typeSig); if (newTypeSig != typeSig) { typeSig = newTypeSig; return true; } return false; }
public CorFieldInfo(CorType ownerType, uint token, string name, TypeSig fieldType, FieldAttributes attrs, object constant, CorElementType constantType, DebuggerBrowsableState? debuggerBrowsableState, bool compilerGeneratedAttribute) { this.OwnerType = ownerType; this.Token = token; this.Name = name; this.FieldType = fieldType; this.Attributes = attrs; this.Constant = constant; this.ConstantType = constantType; this.DebuggerBrowsableState = debuggerBrowsableState; this.CompilerGeneratedAttribute = compilerGeneratedAttribute; }
private static TypeSig ReferenceType(TypeSig type, ModuleDef module) { if (type == null) return null; if (type.IsSZArray) { var szar = type.ToSZArraySig(); var eleType = ReferenceType(szar.Next, module); if (eleType == null) return null; return new SZArraySig(eleType); } if (type.IsArray) { var ar = type.ToArraySig(); var eleType = ReferenceType(ar.Next, module); if (eleType == null) return null; return new ArraySig(eleType, ar.Rank, ar.Sizes, ar.LowerBounds); } if (type.IsGenericInstanceType) { var g = type.ToGenericInstSig(); var gtype = FindType(g.GenericType.FullName, module); ClassOrValueTypeSig ngt; if (gtype == null) ngt = g.GenericType; else ngt = gtype.TryGetClassOrValueTypeSig(); TypeSig[] genericArgs = new TypeSig[g.GenericArguments.Count]; for (int i = 0; i < g.GenericArguments.Count; ++i) { var subArg = ReferenceType(g.GenericArguments[i], module); if (subArg != null) genericArgs[i] = subArg; else genericArgs[i] = g.GenericArguments[i]; } return new GenericInstSig(ngt, genericArgs); } var targetType = FindType(type.FullName, module); if (targetType == null) return null; return targetType.ToTypeSig(); }
/// <summary> /// Gets the underlying type, if the specified type is an enum. /// Otherwise, returns null. /// </summary> public static TypeSig GetEnumUnderlyingType(TypeSig enumType) { // unfortunately we cannot rely on enumType.IsValueType here - it's not set when the instruction operand is a typeref (as opposed to a typespec) if (enumType != null && !IsArrayPointerOrReference(enumType)) { // value type might be an enum TypeDef typeDef = enumType.Resolve(); if (typeDef != null && typeDef.IsEnum) { return typeDef.GetEnumUnderlyingType().RemovePinnedAndModifiers(); } } return null; }
public TypeSig[] Create(TypeSigCreatorOptions options, int? count, TypeSig[] typeSigs) { var data = new CreateTypeSigArrayVM(options, count); if (typeSigs != null) data.TypeSigCollection.AddRange(typeSigs); var win = new CreateTypeSigArrayDlg(); win.DataContext = data; win.Owner = ownerWindow ?? Application.Current.MainWindow; if (win.ShowDialog() != true) return null; return data.TypeSigArray; }
/// <summary> /// Resolves the type signature with the specified generic arguments. /// </summary> /// <param name="typeSig">The type signature.</param> /// <param name="typeGenArgs">The type generic arguments.</param> /// <returns>Resolved type signature.</returns> /// <exception cref="System.ArgumentException">No generic arguments to resolve.</exception> public static TypeSig Resolve(TypeSig typeSig, IList<TypeSig> typeGenArgs) { if (typeGenArgs == null) throw new ArgumentException("No generic arguments to resolve."); var resolver = new GenericArgumentResolver(); resolver.genericArguments = new GenericArguments(); resolver.recursionCounter = new RecursionCounter(); if (typeGenArgs != null) resolver.genericArguments.PushTypeArgs(typeGenArgs); return resolver.ResolveGenericArgs(typeSig); }
public TypeSig Create(TypeSigCreatorOptions options, TypeSig typeSig, out bool canceled) { var data = new TypeSigCreatorVM(options, typeSig); data.TypeSig = typeSig; var win = new TypeSigCreatorDlg(); win.DataContext = data; win.Owner = ownerWindow ?? MainWindow.Instance; if (win.ShowDialog() != true) { canceled = true; return null; } canceled = false; return data.TypeSig; }
public TypeSigCreatorVM(TypeSigCreatorOptions options, TypeSig defaultTypeSig = null) { this.options = options.Clone(); this.defaultTypeSig = defaultTypeSig; this.arrayRank = new UInt32VM(2, a => { }); this.arraySizes = new UInt32ListDataFieldVM(a => { }) { Min = ModelUtils.COMPRESSED_UINT32_MIN, Max = ModelUtils.COMPRESSED_UINT32_MAX, }; this.arrayLowerBounds = new Int32ListDataFieldVM(a => { }) { Min = ModelUtils.COMPRESSED_INT32_MIN, Max = ModelUtils.COMPRESSED_INT32_MAX, }; this.genericVariableNumber = new UInt32VM(0, a => { }); Reinitialize(); }
/// <summary> /// Apply a series of modifiers ("[]", "*", "&") to a base TypeSig. /// </summary> /// <param name="baseSig">Base TypeSig</param> /// <param name="modifiers">Modifier strings</param> /// <returns>TypeSig</returns> public static TypeSig FromBaseSig(TypeSig baseSig, Stack<String> modifiers) { String mod; while (modifiers.Count > 0) { mod = modifiers.Pop(); switch (mod) { case "[]": baseSig = new SZArraySig(baseSig); break; case "*": baseSig = new PtrSig(baseSig); break; case "&": baseSig = new ByRefSig(baseSig); break; default: throw new Exception(String.Format("Unknown modifier: {0}", mod)); } } return baseSig; }
public static object GetDefaultValue(TypeSig type, bool classValueTypeIsEnum = false) { var t = type.RemovePinnedAndModifiers(); switch (t.GetElementType()) { case ElementType.Boolean:return false; case ElementType.Char: return (char)0; case ElementType.I1: return (sbyte)0; case ElementType.U1: return (byte)0; case ElementType.I2: return (short)0; case ElementType.U2: return (ushort)0; case ElementType.I4: return (int)0; case ElementType.U4: return (uint)0; case ElementType.I8: return (long)0; case ElementType.U8: return (ulong)0; case ElementType.R4: return (float)0; case ElementType.R8: return (double)0; case ElementType.Class: case ElementType.ValueType: var tdr = ((ClassOrValueTypeSig)t).TypeDefOrRef; if (tdr.IsSystemType()) break; var td = tdr.ResolveTypeDef(); if (td == null) { if (classValueTypeIsEnum) return (int)0; break; } if (!td.IsEnum) break; switch (td.GetEnumUnderlyingType().RemovePinnedAndModifiers().GetElementType()) { case ElementType.Boolean:return false; case ElementType.Char: return (char)0; case ElementType.I1: return (sbyte)0; case ElementType.U1: return (byte)0; case ElementType.I2: return (short)0; case ElementType.U2: return (ushort)0; case ElementType.I4: return (int)0; case ElementType.U4: return (uint)0; case ElementType.I8: return (long)0; case ElementType.U8: return (ulong)0; case ElementType.R4: return (float)0; case ElementType.R8: return (double)0; } break; } return null; }
public string create(TypeSig typeRef) { typeRef = typeRef.RemovePinnedAndModifiers(); if (typeRef == null) return unknownNameCreator.create(); var gis = typeRef as GenericInstSig; if (gis != null) { if (gis.FullName == "System.Nullable`1" && gis.GenericArguments.Count == 1 && gis.GenericArguments[0] != null) { typeRef = gis.GenericArguments[0]; } } string prefix = getPrefix(typeRef); var elementType = typeRef.ScopeType; if (elementType == null && isFnPtrSig(typeRef)) return fnPtrNameCreator.create(); if (isGenericParam(elementType)) return genericParamNameCreator.create(); NameCreator nc; var typeFullName = typeRef.FullName; if (typeNames.TryGetValue(typeFullName, out nc)) return nc.create(); var fullName = elementType == null ? typeRef.FullName : elementType.FullName; string shortName; var dict = prefix == "" ? fullNameToShortName : fullNameToShortNamePrefix; if (!dict.TryGetValue(fullName, out shortName)) { fullName = fullName.Replace('/', '.'); int index = fullName.LastIndexOf('.'); shortName = index > 0 ? fullName.Substring(index + 1) : fullName; index = shortName.LastIndexOf('`'); if (index > 0) shortName = shortName.Substring(0, index); } return addTypeName(typeFullName, shortName, prefix).create(); }
/// <summary> /// Relocates the <see cref="TypeSig"/>. /// </summary> /// <param name="typeSig">The type sig.</param> /// <returns>A new type if it was relocated, null otherwise</returns> /// <exception cref="InvalidOperationException">If signature is of unknown type.</exception> public virtual TypeSig TryRelocateTypeSig(TypeSig typeSig) { if (typeSig == null) return null; if (typeSig is CorLibTypeSig) return null; if (typeSig is GenericInstSig) return TryRelocateGeneric((GenericInstSig)typeSig); if (typeSig is PtrSig) return null; if (typeSig is ByRefSig) return TryRelocateByRef((ByRefSig)typeSig); if (typeSig is ArraySig) return TryRelocateArray((ArraySig)typeSig); if (typeSig is SZArraySig) return TryRelocateSZArray((SZArraySig)typeSig); if (typeSig is GenericVar) return null; // TODO constraints if (typeSig is GenericMVar) return null; // TODO constraints if (typeSig is ValueTypeSig || typeSig is ClassSig) { var typeRef = typeSig.TryGetTypeRef(); if (typeRef != null) return TryRelocateTypeRef(typeRef); var typeDefOrRef = TryRelocateTypeDefOrRef(typeSig.ToTypeDefOrRef()); return typeDefOrRef?.ToTypeSig(); } throw new InvalidOperationException(); }
/// <summary> /// Gets the <see cref="TypeSig.IsValueType"/> value or <c>false</c> if /// <paramref name="self"/> is <c>null</c> /// </summary> /// <param name="self">this</param> /// <returns></returns> public static bool GetIsValueType(this TypeSig self) { return(self == null ? false : self.IsValueType); }
/// <summary> /// Gets the <see cref="TypeSig.IsPrimitive"/> value or <c>false</c> if /// <paramref name="self"/> is <c>null</c> /// </summary> /// <param name="self">this</param> /// <returns></returns> public static bool GetIsPrimitive(this TypeSig self) { return(self == null ? false : self.IsPrimitive); }
/// <summary> /// Constructor /// </summary> /// <param name="modifier">Modifier type</param> /// <param name="nextSig">The next element type</param> protected ModifierSig(ITypeDefOrRef modifier, TypeSig nextSig) : base(nextSig) { this.modifier = modifier; }
/// <summary> /// Gets the next field or <c>null</c> /// </summary> /// <param name="self">this</param> /// <returns></returns> public static TypeSig GetNext(this TypeSig self) { return(self == null ? null : self.Next); }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">The next element type</param> public PinnedSig(TypeSig nextSig) : base(nextSig) { }
public static TypeDef GetType(ModuleDef module, TypeSig type) { type = type.RemovePinnedAndModifiers(); var tdr = type as TypeDefOrRefSig; if (tdr == null) return null; return GetType(module, tdr.TypeDefOrRef); }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">The next element type</param> public ByRefSig(TypeSig nextSig) : base(nextSig) { }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">The next element type</param> public SZArraySig(TypeSig nextSig) : base(nextSig) { }
/// <summary> /// Returns the full name of a <see cref="TypeSig"/> /// </summary> /// <param name="typeSig">The type sig</param> /// <param name="isReflection">Set if output should be compatible with reflection</param> /// <param name="helper">Helps print the name</param> /// <param name="typeGenArgs">Type generic args or <c>null</c> if none</param> /// <param name="methodGenArgs">Method generic args or <c>null</c> if none</param> /// <returns>The full name</returns> public static string FullName(TypeSig typeSig, bool isReflection, IFullNameCreatorHelper helper, IList<TypeSig> typeGenArgs, IList<TypeSig> methodGenArgs) { var fnc = new FullNameCreator(isReflection, helper); if (typeGenArgs != null || methodGenArgs != null) fnc.genericArguments = new GenericArguments(); if (typeGenArgs != null) fnc.genericArguments.PushTypeArgs(typeGenArgs); if (methodGenArgs != null) fnc.genericArguments.PushMethodArgs(methodGenArgs); fnc.CreateFullName(typeSig); return fnc.Result; }
/// <summary> /// Constructor /// </summary> /// <param name="arrayType">Array type</param> public ArraySig(TypeSig arrayType) : base(arrayType) { this.sizes = ThreadSafeListCreator.Create <uint>(); this.lowerBounds = ThreadSafeListCreator.Create <int>(); }
/// <summary> /// Returns a <see cref="TypeDefOrRefSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="TypeDefOrRefSig"/> or <c>null</c> if it's not a /// <see cref="TypeDefOrRefSig"/></returns> public static TypeDefOrRefSig ToTypeDefOrRefSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as TypeDefOrRefSig); }
/// <summary> /// Constructor /// </summary> /// <param name="index">Index</param> /// <param name="nextSig">The next element type</param> public ModuleSig(uint index, TypeSig nextSig) : base(nextSig) { this.index = index; }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">The next element type</param> /// <param name="size">Size of the array</param> public ValueArraySig(TypeSig nextSig, uint size) : base(nextSig) { this.size = size; }
/// <summary> /// Gets the element type /// </summary> /// <param name="a">this</param> /// <returns>The element type</returns> public static ElementType GetElementType(this TypeSig a) { return(a == null ? ElementType.End : a.ElementType); }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">The next element type</param> public PtrSig(TypeSig nextSig) : base(nextSig) { }
/// <summary> /// Constructor /// </summary> /// <param name="typeSig">A type sig</param> public TypeSpecUser(TypeSig typeSig) { this.typeSig = typeSig; this.extraData = null; this.typeSigAndExtraData_isInitialized = true; }
/// <summary> /// Constructor /// </summary> /// <param name="arrayType">Array type</param> /// <param name="rank">Array rank</param> /// <param name="sizes">Sizes list. <c>This instance will be the owner of this list.</c></param> /// <param name="lowerBounds">Lower bounds list. <c>This instance will be the owner of this list.</c></param> public ArraySig(TypeSig arrayType, int rank, IEnumerable <uint> sizes, IEnumerable <int> lowerBounds) : this(arrayType, (uint)rank, sizes, lowerBounds) { }
/// <summary> /// Constructor /// </summary> /// <param name="nextSig">Next sig</param> protected NonLeafSig(TypeSig nextSig) { this.nextSig = nextSig; }
/// <inheritdoc/> public CModOptSig(ITypeDefOrRef modifier, TypeSig nextSig) : base(modifier, nextSig) { }
private bool ContainsGenericParameterInternal(TypeSig type) { if (type == null) { return(false); } if (!recursionCounter.Increment()) { return(false); } bool res; switch (type.ElementType) { case ElementType.Void: case ElementType.Boolean: case ElementType.Char: case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: case ElementType.I8: case ElementType.U8: case ElementType.R4: case ElementType.R8: case ElementType.String: case ElementType.ValueType: case ElementType.Class: case ElementType.TypedByRef: case ElementType.I: case ElementType.U: case ElementType.Object: res = ContainsGenericParameterInternal((type as TypeDefOrRefSig).TypeDefOrRef); break; case ElementType.Var: case ElementType.MVar: res = true; break; case ElementType.FnPtr: res = ContainsGenericParameterInternal((type as FnPtrSig).Signature); break; case ElementType.GenericInst: var gi = (GenericInstSig)type; res = ContainsGenericParameterInternal(gi.GenericType) || ContainsGenericParameter(gi.GenericArguments); break; case ElementType.Ptr: case ElementType.ByRef: case ElementType.Array: case ElementType.SZArray: case ElementType.Pinned: case ElementType.ValueArray: case ElementType.Module: res = ContainsGenericParameterInternal((type as NonLeafSig).Next); break; case ElementType.CModReqd: case ElementType.CModOpt: res = ContainsGenericParameterInternal((type as ModifierSig).Modifier) || ContainsGenericParameterInternal((type as NonLeafSig).Next); break; case ElementType.End: case ElementType.R: case ElementType.Internal: case ElementType.Sentinel: default: res = false; break; } recursionCounter.Decrement(); return(res); }
object ReadValue(SerializationType etype, TypeSig argType, out TypeSig realArgType) { if (!recursionCounter.Increment()) { throw new CABlobParserException("Too much recursion"); } object result; switch (etype) { case SerializationType.Boolean: realArgType = module.CorLibTypes.Boolean; result = reader.ReadByte() != 0; break; case SerializationType.Char: realArgType = module.CorLibTypes.Char; result = (char)reader.ReadUInt16(); break; case SerializationType.I1: realArgType = module.CorLibTypes.SByte; result = reader.ReadSByte(); break; case SerializationType.U1: realArgType = module.CorLibTypes.Byte; result = reader.ReadByte(); break; case SerializationType.I2: realArgType = module.CorLibTypes.Int16; result = reader.ReadInt16(); break; case SerializationType.U2: realArgType = module.CorLibTypes.UInt16; result = reader.ReadUInt16(); break; case SerializationType.I4: realArgType = module.CorLibTypes.Int32; result = reader.ReadInt32(); break; case SerializationType.U4: realArgType = module.CorLibTypes.UInt32; result = reader.ReadUInt32(); break; case SerializationType.I8: realArgType = module.CorLibTypes.Int64; result = reader.ReadInt64(); break; case SerializationType.U8: realArgType = module.CorLibTypes.UInt64; result = reader.ReadUInt64(); break; case SerializationType.R4: realArgType = module.CorLibTypes.Single; result = reader.ReadSingle(); break; case SerializationType.R8: realArgType = module.CorLibTypes.Double; result = reader.ReadDouble(); break; case SerializationType.String: realArgType = module.CorLibTypes.String; result = ReadUTF8String(); break; // It's ET.ValueType if it's eg. a ctor enum arg type case (SerializationType)ElementType.ValueType: if (argType == null) { throw new CABlobParserException("Invalid element type"); } realArgType = argType; result = ReadEnumValue(GetEnumUnderlyingType(argType)); break; // It's ET.Object if it's a ctor object arg type case (SerializationType)ElementType.Object: case SerializationType.TaggedObject: realArgType = ReadFieldOrPropType(); var arraySig = realArgType as SZArraySig; if (arraySig != null) { result = ReadArrayArgument(arraySig); } else { TypeSig tmpType; result = ReadValue((SerializationType)realArgType.ElementType, realArgType, out tmpType); } break; // It's ET.Class if it's eg. a ctor System.Type arg type case (SerializationType)ElementType.Class: var tdr = argType as TypeDefOrRefSig; if (tdr != null && tdr.DefinitionAssembly.IsCorLib() && tdr.Namespace == "System") { if (tdr.TypeName == "Type") { result = ReadValue(SerializationType.Type, tdr, out realArgType); break; } if (tdr.TypeName == "String") { result = ReadValue(SerializationType.String, tdr, out realArgType); break; } if (tdr.TypeName == "Object") { result = ReadValue(SerializationType.TaggedObject, tdr, out realArgType); break; } } // Assume it's an enum that couldn't be resolved realArgType = argType; result = ReadEnumValue(null); break; case SerializationType.Type: realArgType = argType; result = ReadType(true); break; case SerializationType.Enum: realArgType = ReadType(false); result = ReadEnumValue(GetEnumUnderlyingType(realArgType)); break; default: throw new CABlobParserException("Invalid element type"); } recursionCounter.Decrement(); return(result); }
/// <summary> /// Constructor /// </summary> /// <param name="arrayType">Array type</param> protected ArraySigBase(TypeSig arrayType) : base(arrayType) { }
/// <summary> /// Constructor /// </summary> /// <param name="arrayType">Array type</param> /// <param name="rank">Array rank</param> public ArraySig(TypeSig arrayType, int rank) : this(arrayType, (uint)rank) { }
/// <summary> /// Returns the assembly qualified full name of a <see cref="TypeSig"/> /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <param name="helper">Helps print the name</param> /// <returns>The assembly qualified full name</returns> public static string AssemblyQualifiedName(TypeSig typeSig, IFullNameCreatorHelper helper) { var fnc = new FullNameCreator(true, helper); fnc.CreateAssemblyQualifiedName(typeSig); return fnc.Result; }
/// <summary> /// Constructor /// </summary> /// <param name="genericType">The generic type</param> /// <param name="genArg1">Generic argument #1</param> /// <param name="genArg2">Generic argument #2</param> /// <param name="genArg3">Generic argument #3</param> public GenericInstSig(ClassOrValueTypeSig genericType, TypeSig genArg1, TypeSig genArg2, TypeSig genArg3) { this.genericType = genericType; this.genericArgs = ThreadSafeListCreator.Create <TypeSig>(genArg1, genArg2, genArg3); }
/// <summary> /// Gets the scope /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <returns>The <see cref="IScope"/> or <c>null</c> if none found</returns> public static IScope Scope(TypeSig typeSig) { return new FullNameCreator().GetScope(typeSig); }
/// <summary> /// Returns the owner module. The type was created from metadata in this module. /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <returns>A <see cref="ModuleDef"/> or <c>null</c> if none found</returns> public static ModuleDef OwnerModule(TypeSig typeSig) { return new FullNameCreator().GetOwnerModule(typeSig); }
/// <summary> /// Returns a <see cref="ValueTypeSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="ValueTypeSig"/> or <c>null</c> if it's not a /// <see cref="ValueTypeSig"/></returns> public static ValueTypeSig ToValueTypeSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as ValueTypeSig); }
TypeSig FixTypeSig(TypeSig type) { return(SubstituteGenericParameter(type.RemoveModifiers()).RemoveModifiers()); }
/// <summary> /// Returns the assembly qualified full name of a <see cref="TypeSig"/> /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <returns>The assembly qualified full name</returns> public static string AssemblyQualifiedName(TypeSig typeSig) { return AssemblyQualifiedName(typeSig, null); }
/// <summary> /// Returns a <see cref="ClassSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="ClassSig"/> or <c>null</c> if it's not a /// <see cref="ClassSig"/></returns> public static ClassSig ToClassSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as ClassSig); }
/// <summary> /// Returns the assembly where this type is defined /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <returns>A <see cref="IAssembly"/> or <c>null</c> if none found</returns> public static IAssembly DefinitionAssembly(TypeSig typeSig) { return new FullNameCreator().GetDefinitionAssembly(typeSig); }
/// <summary> /// Returns a <see cref="GenericMVar"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="GenericMVar"/> or <c>null</c> if it's not a /// <see cref="GenericMVar"/></returns> public static GenericMVar ToGenericMVar(this TypeSig type) { return(type.RemovePinnedAndModifiers() as GenericMVar); }
/// <summary> /// Gets the scope type /// </summary> /// <param name="typeSig">The <c>TypeSig</c></param> /// <returns>The scope type or <c>null</c> if none found</returns> public static ITypeDefOrRef ScopeType(TypeSig typeSig) { return new FullNameCreator().GetScopeType(typeSig); }
/// <summary> /// Returns a <see cref="GenericInstSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="GenericInstSig"/> or <c>null</c> if it's not a /// <see cref="GenericInstSig"/></returns> public static GenericInstSig ToGenericInstSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as GenericInstSig); }
bool GetClassSize(TypeDef declaringType, TypeSig ts, int ptrSize, out uint size) { size = 0; ts = ts.RemovePinnedAndModifiers(); if (ts == null) return false; int size2 = ts.ElementType.GetPrimitiveSize(ptrSize); if (size2 >= 0) { size = (uint)size2; return true; } var tdrs = ts as TypeDefOrRefSig; if (tdrs == null) return false; var td = tdrs.TypeDef; if (td != null) return TypeDef.GetClassSize(td, out size); var tr = tdrs.TypeRef; if (tr != null) return TypeDef.GetClassSize(tr.Resolve(), out size); return false; }
/// <summary> /// Returns a <see cref="PtrSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="PtrSig"/> or <c>null</c> if it's not a /// <see cref="PtrSig"/></returns> public static PtrSig ToPtrSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as PtrSig); }
static ConstantType GetConstantType(TypeSig type, out ITypeDefOrRef enumType) { enumType = null; var t = type.RemovePinnedAndModifiers(); switch (t.GetElementType()) { case ElementType.Boolean: return ConstantType.Boolean; case ElementType.Char: return ConstantType.Char; case ElementType.I1: return ConstantType.SByte; case ElementType.U1: return ConstantType.Byte; case ElementType.I2: return ConstantType.Int16; case ElementType.U2: return ConstantType.UInt16; case ElementType.I4: return ConstantType.Int32; case ElementType.U4: return ConstantType.UInt32; case ElementType.I8: return ConstantType.Int64; case ElementType.U8: return ConstantType.UInt64; case ElementType.R4: return ConstantType.Single; case ElementType.R8: return ConstantType.Double; case ElementType.String: return ConstantType.String; case ElementType.Object: return ConstantType.Object; case ElementType.ValueType: case ElementType.Class: var tdr = ((ClassOrValueTypeSig)t).TypeDefOrRef; if (tdr.IsSystemType()) return ConstantType.Type; enumType = tdr; return ConstantType.Enum; case ElementType.SZArray: var elemType = t.Next.RemovePinnedAndModifiers(); switch (elemType.GetElementType()) { case ElementType.Boolean: return ConstantType.BooleanArray; case ElementType.Char: return ConstantType.CharArray; case ElementType.I1: return ConstantType.SByteArray; case ElementType.U1: return ConstantType.ByteArray; case ElementType.I2: return ConstantType.Int16Array; case ElementType.U2: return ConstantType.UInt16Array; case ElementType.I4: return ConstantType.Int32Array; case ElementType.U4: return ConstantType.UInt32Array; case ElementType.I8: return ConstantType.Int64Array; case ElementType.U8: return ConstantType.UInt64Array; case ElementType.R4: return ConstantType.SingleArray; case ElementType.R8: return ConstantType.DoubleArray; case ElementType.String: return ConstantType.StringArray; case ElementType.Object: return ConstantType.ObjectArray; case ElementType.ValueType: case ElementType.Class: tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef; if (tdr.IsSystemType()) return ConstantType.TypeArray; enumType = tdr; return ConstantType.EnumArray; } break; } Debug.Fail(string.Format("Unsupported CA named type: {0}", type)); return ConstantType.Object; }
/// <summary> /// Returns a <see cref="ByRefSig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="ByRefSig"/> or <c>null</c> if it's not a /// <see cref="ByRefSig"/></returns> public static ByRefSig ToByRefSig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as ByRefSig); }
public static TypeSig GetGenericArgument(GenericInstSig typeOwner, MethodSpec methodOwner, TypeSig type) { var typeArgs = typeOwner == null ? null : typeOwner.GenericArguments; var genMethodArgs = methodOwner == null || methodOwner.GenericInstMethodSig == null ? null : methodOwner.GenericInstMethodSig.GenericArguments; return GenericArgsSubstitutor.Create(type, typeArgs, genMethodArgs); }
/// <summary> /// Returns a <see cref="SZArraySig"/> /// </summary> /// <param name="type">The type</param> /// <returns>A <see cref="SZArraySig"/> or <c>null</c> if it's not a /// <see cref="SZArraySig"/></returns> public static SZArraySig ToSZArraySig(this TypeSig type) { return(type.RemovePinnedAndModifiers() as SZArraySig); }