(string methodName, DkmClrCompilationResultFlags flags) AddMethod(TypeSig type, int index, bool isLocal) { var methodName = methodNamePrefix + methodNameIndex++.ToString(); var callConv = CallingConvention.Default; if (sourceMethod.MethodSig.Generic) callConv |= CallingConvention.Generic; var methodSig = new MethodSig(callConv, sourceMethod.MethodSig.GenParamCount); methodSig.RetType = generatedModule.Import(type.RemovePinnedAndModifiers()); if (methodSig.RetType.IsByRef) methodSig.RetType = methodSig.RetType.Next.RemovePinnedAndModifiers(); if (lastMethodSig != null) { foreach (var p in lastMethodSig.Params) methodSig.Params.Add(p); } else { if (sourceMethod.MethodSig.HasThis) methodSig.Params.Add(generatedModule.Import(sourceMethod.DeclaringType).ToTypeSig()); foreach (var p in sourceMethod.MethodSig.Params) methodSig.Params.Add(generatedModule.Import(p)); } const MethodImplAttributes methodImplFlags = MethodImplAttributes.IL | MethodImplAttributes.Managed; const MethodAttributes methodFlags = MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.ReuseSlot; var method = new MethodDefUser(methodName, methodSig, methodImplFlags, methodFlags); getLocalsType.Methods.Add(method); foreach (var gp in sourceMethod.GenericParameters) method.GenericParameters.Add(Clone(gp)); var body = new CilBody(); method.Body = body; body.InitLocals = true; if (sourceMethod.Body is CilBody sourceBody) { foreach (var l in sourceBody.Variables) body.Variables.Add(new Local(generatedModule.Import(l.Type), l.Name)); } body.Instructions.Add(CreateLoadVariable(method, body.Variables, index, isLocal)); if (type.RemovePinnedAndModifiers().GetElementType() == ElementType.ByRef) body.Instructions.Add(LoadIndirect(type.RemovePinnedAndModifiers()?.Next.RemovePinnedAndModifiers())); body.Instructions.Add(Instruction.Create(OpCodes.Ret)); lastMethodSig = methodSig; var flags = DkmClrCompilationResultFlags.None; if (methodSig.RetType.RemovePinnedAndModifiers().GetElementType() == ElementType.Boolean) flags |= DkmClrCompilationResultFlags.BoolResult; return (methodName, flags); }
TypeDef Resolve(TypeSig type) { type = type.RemovePinnedAndModifiers(); if (type is GenericInstSig gis) { type = gis.GenericType; } var tdrs = type as TypeDefOrRefSig; if (tdrs == null) { return(null); } var td = tdrs.TypeDef; if (td != null) { return(td); } var tr = tdrs.TypeRef; if (tr != null) { return(tr.Resolve()); } 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()); }
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)); }
public static CachedOutput Create(TypeSig fieldType, TypePrinterFlags flags) { fieldType = fieldType.RemovePinnedAndModifiers() ?? fieldType; if (fieldType is ByRefSig) { fieldType = fieldType.Next ?? fieldType; } var typeOutput = TypePrinterUtils.Write(new TypeOutput(), fieldType, flags); return(typeOutput.cachedOutput); }
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)); }
static bool DecodeArrayInitializer(TypeSig elementTypeRef, byte[] initialValue, ILExpression[] output) { elementTypeRef = elementTypeRef.RemovePinnedAndModifiers(); TypeCode elementType = TypeAnalysis.GetTypeCode(elementTypeRef); switch (elementType) { case TypeCode.Boolean: case TypeCode.Byte: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)d[i])); case TypeCode.SByte: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)unchecked ((sbyte)d[i]))); case TypeCode.Int16: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToInt16(d, i))); case TypeCode.Char: case TypeCode.UInt16: return(DecodeArrayInitializer(initialValue, output, elementType, (d, i) => (int)BitConverter.ToUInt16(d, i))); case TypeCode.Int32: case TypeCode.UInt32: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt32)); case TypeCode.Int64: case TypeCode.UInt64: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToInt64)); case TypeCode.Single: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToSingle)); case TypeCode.Double: return(DecodeArrayInitializer(initialValue, output, elementType, BitConverter.ToDouble)); case TypeCode.Object: var typeDef = elementTypeRef.ToTypeDefOrRef().ResolveWithinSameModule(); if (typeDef != null && typeDef.IsEnum) { return(DecodeArrayInitializer(typeDef.GetEnumUnderlyingType(), initialValue, output)); } return(false); default: return(false); } }
public static ITypeDefOrRef GetTypeDefOrRef(this TypeSig type) { type = type.RemovePinnedAndModifiers(); if (type.IsGenericInstanceType) { return(((GenericInstSig)type).GenericType.TypeDefOrRef); } else if (type.IsTypeDefOrRef) { return(((TypeDefOrRefSig)type).TypeDefOrRef); } else { return(null); } }
bool WriteRefIfByRef(ITextOutput output, TypeSig typeSig, ParamDef pd) { if (typeSig.RemovePinnedAndModifiers() is ByRefSig) { if (pd != null && (!pd.IsIn && pd.IsOut)) { output.Write("out", TextTokenKind.Keyword); output.WriteSpace(); } else { output.Write("ref", TextTokenKind.Keyword); output.WriteSpace(); } return(true); } return(false); }
bool WriteRefIfByRef(IDecompilerOutput output, TypeSig typeSig, ParamDef pd) { if (typeSig.RemovePinnedAndModifiers() is ByRefSig) { if (pd != null && (!pd.IsIn && pd.IsOut)) { output.Write("out", BoxedTextColor.Keyword); output.Write(" ", BoxedTextColor.Text); } else { output.Write("ref", BoxedTextColor.Keyword); output.Write(" ", BoxedTextColor.Text); } return(true); } return(false); }
/// <summary> /// Gets a type signature color /// </summary> /// <param name="typeSig">Type signature</param> /// <returns></returns> public virtual object GetColor(TypeSig typeSig) { typeSig = typeSig.RemovePinnedAndModifiers(); if (typeSig == null) { return(BoxedTextColor.Text); } if (typeSig is TypeDefOrRefSig tdr) { return(GetColor(tdr.TypeDefOrRef)); } if (typeSig is GenericSig gsig) { return(GetColor(gsig)); } return(BoxedTextColor.Text); }
private 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); }
public static CachedOutput CreateType(CorValue value, TypeSig ts, IList <CorType> typeArgs, IList <CorType> methodArgs, TypePrinterFlags flags) { if (value == null && ts != null) { return(TypePrinterUtils.Write(new TypeOutput(), ts, flags, typeArgs, methodArgs).cachedOutput); } var valueOutput = CreateType(new TypeOutput(), value, flags); if (ts == null || value == null) { return(valueOutput.cachedOutput); } ts = ts.RemovePinnedAndModifiers() ?? ts; if (ts is ByRefSig) { ts = ts.Next ?? ts; } var typeOutput = value.WriteType(new TypeOutput(), ts, typeArgs, methodArgs, flags); return(CreateTypeInternal(valueOutput, typeOutput)); }
/// <summary> /// Gets a type signature color /// </summary> /// <param name="typeSig">Type signature</param> /// <returns></returns> public static object GetColor(TypeSig typeSig) { typeSig = typeSig.RemovePinnedAndModifiers(); if (typeSig == null) { return(BoxedTextColor.Text); } var tdr = typeSig as TypeDefOrRefSig; if (tdr != null) { return(GetColor(tdr.TypeDefOrRef)); } var gsig = typeSig as GenericSig; if (gsig != null) { return(GetColor(gsig)); } return(BoxedTextColor.Text); }
public static TextTokenKind GetTextTokenType(TypeSig ts) { ts = ts.RemovePinnedAndModifiers(); if (ts == null) { return(TextTokenKind.Text); } var tdr = ts as TypeDefOrRefSig; if (tdr != null) { return(GetTextTokenType(tdr.TypeDefOrRef)); } var gsig = ts as GenericSig; if (gsig != null) { return(GetTextTokenType(gsig)); } return(TextTokenKind.Text); }
void AddPushDefaultValue(int count, ref int index, TypeSig pushType) { pushType = pushType.RemovePinned(); switch (count > 10 ? ElementType.End : pushType.RemovePinnedAndModifiers().GetElementType()) { case ElementType.Void: break; case ElementType.Boolean: case ElementType.Char: case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0)); break; case ElementType.I8: case ElementType.U8: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0)); InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_I8)); break; case ElementType.R4: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_R4)); break; case ElementType.R8: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_R8)); break; case ElementType.I: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0)); InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_I)); break; case ElementType.U: case ElementType.Ptr: case ElementType.FnPtr: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldc_I4_0)); InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Conv_U)); break; case ElementType.ValueType: var td = ((ValueTypeSig)pushType).TypeDefOrRef.ResolveTypeDef(); if (td != null && td.IsEnum) { var undType = td.GetEnumUnderlyingType().RemovePinnedAndModifiers(); var et = undType.GetElementType(); if ((ElementType.Boolean <= et && et <= ElementType.R8) || et == ElementType.I || et == ElementType.U) { AddPushDefaultValue(count + 1, ref index, undType); break; } } goto case ElementType.TypedByRef; case ElementType.TypedByRef: case ElementType.Var: case ElementType.MVar: var local = new LocalVM(TypeSigCreatorOptions, new LocalOptions(new Local(pushType))); this.LocalsListVM.Add(local); var newInstr = CreateInstructionVM(Code.Ldloca); newInstr.InstructionOperandVM.OperandListItem = local; InstructionsListVM.Insert(index++, newInstr); newInstr = CreateInstructionVM(Code.Initobj); newInstr.InstructionOperandVM.Other = local.Type.ToTypeDefOrRef(); InstructionsListVM.Insert(index++, newInstr); newInstr = CreateInstructionVM(Code.Ldloc); newInstr.InstructionOperandVM.OperandListItem = local; InstructionsListVM.Insert(index++, newInstr); break; case ElementType.GenericInst: if (((GenericInstSig)pushType).GenericType is ValueTypeSig) { goto case ElementType.TypedByRef; } goto case ElementType.Class; case ElementType.End: case ElementType.String: case ElementType.ByRef: case ElementType.Class: case ElementType.Array: case ElementType.ValueArray: case ElementType.R: case ElementType.Object: case ElementType.SZArray: case ElementType.CModReqd: case ElementType.CModOpt: case ElementType.Internal: case ElementType.Module: case ElementType.Sentinel: case ElementType.Pinned: default: InstructionsListVM.Insert(index++, CreateInstructionVM(Code.Ldnull)); break; } }
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); }
CAArgument CreateCAArgument(TypeSig ownerType, object value) { if (value == null || value is Null) { var t = ownerType.RemovePinnedAndModifiers(); t = t is SZArraySig ? t.Next : t; if (t.RemovePinnedAndModifiers().GetElementType() == ElementType.Object) { return(new CAArgument(module.CorLibTypes.String, null)); } return(new CAArgument(ownerType, null)); } switch (ModelUtils.GetElementType(value.GetType())) { case ElementType.Boolean: return(new CAArgument(module.CorLibTypes.Boolean, value)); case ElementType.Char: return(new CAArgument(module.CorLibTypes.Char, value)); case ElementType.I1: return(new CAArgument(module.CorLibTypes.SByte, value)); case ElementType.U1: return(new CAArgument(module.CorLibTypes.Byte, value)); case ElementType.I2: return(new CAArgument(module.CorLibTypes.Int16, value)); case ElementType.U2: return(new CAArgument(module.CorLibTypes.UInt16, value)); case ElementType.I4: return(new CAArgument(module.CorLibTypes.Int32, value)); case ElementType.U4: return(new CAArgument(module.CorLibTypes.UInt32, value)); case ElementType.I8: return(new CAArgument(module.CorLibTypes.Int64, value)); case ElementType.U8: return(new CAArgument(module.CorLibTypes.UInt64, value)); case ElementType.R4: return(new CAArgument(module.CorLibTypes.Single, value)); case ElementType.R8: return(new CAArgument(module.CorLibTypes.Double, value)); case ElementType.String: return(new CAArgument(module.CorLibTypes.String, new UTF8String((string)value))); } if (value is TypeSig) { return(new CAArgument(new ClassSig(module.CorLibTypes.GetTypeRef("System", "Type")), value)); } if (value is EnumInfo) { var enumInfo = (EnumInfo)value; var enumSig = enumInfo.EnumType.ToTypeSig(); if (!enumInfo.IsArray) { return(new CAArgument(enumSig, enumInfo.Value)); } var res = CreateArray(enumSig, enumInfo.Value); var list = (IList <CAArgument>)res.Value; if (list != null) { for (int i = 0; i < list.Count; i++) { list[i] = new CAArgument(enumSig, list[i].Value); } } return(res); } var valueType = value.GetType(); if (value is IList <bool> ) { return(CreateArray(module.CorLibTypes.Boolean, value)); } if (value is IList <char> ) { return(CreateArray(module.CorLibTypes.Char, value)); } if (value is IList <sbyte> && valueType != typeof(byte[])) { return(CreateArray(module.CorLibTypes.SByte, value)); } if (value is IList <short> && valueType != typeof(ushort[])) { return(CreateArray(module.CorLibTypes.Int16, value)); } if (value is IList <int> && valueType != typeof(uint[])) { return(CreateArray(module.CorLibTypes.Int32, value)); } if (value is IList <long> && valueType != typeof(ulong[])) { return(CreateArray(module.CorLibTypes.Int64, value)); } if (value is IList <byte> && valueType != typeof(sbyte[])) { return(CreateArray(module.CorLibTypes.Byte, value)); } if (value is IList <ushort> && valueType != typeof(short[])) { return(CreateArray(module.CorLibTypes.UInt16, value)); } if (value is IList <uint> && valueType != typeof(int[])) { return(CreateArray(module.CorLibTypes.UInt32, value)); } if (value is IList <ulong> && valueType != typeof(long[])) { return(CreateArray(module.CorLibTypes.UInt64, value)); } if (value is IList <float> ) { return(CreateArray(module.CorLibTypes.Single, value)); } if (value is IList <double> ) { return(CreateArray(module.CorLibTypes.Double, value)); } if (value is IList <string> ) { return(CreateArray(module.CorLibTypes.String, value)); } if (value is IList <TypeSig> ) { return(CreateArray(new ClassSig(module.CorLibTypes.GetTypeRef("System", "Type")), value)); } if (value is IList <object> ) { return(CreateArray(module.CorLibTypes.Object, value)); } Debug.Fail(string.Format("Unknown CA arg: {0}, ownerType: {1}", value, ownerType)); return(new CAArgument()); }
object ConvertFromModel(TypeSig valueType, object value) { var type = valueType.RemovePinnedAndModifiers(); var et = type.GetElementType(); ITypeDefOrRef tdr; TypeDef td; switch (et) { 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: if (ModelUtils.GetElementType(value?.GetType()) == et) { return(value); } break; case ElementType.String: if (value == null) { return(Null <string> .Instance); } else if (value is string) { return(value); } else if (value is UTF8String) { return(((UTF8String)value).String); } break; case ElementType.ValueType: case ElementType.Class: tdr = ((ClassOrValueTypeSig)type).TypeDefOrRef; if (tdr.IsSystemType()) { if (value == null) { return(Null <TypeSig> .Instance); } return(value); } td = tdr.ResolveTypeDef(); if (td != null && !td.IsEnum) { break; } return(new EnumInfo() { EnumType = tdr, Value = value, IsArray = false, }); case ElementType.SZArray: var elemType = type.Next.RemovePinnedAndModifiers(); if (value == null) { switch (elemType.GetElementType()) { case ElementType.Boolean: return(Null <bool[]> .Instance); case ElementType.Char: return(Null <char[]> .Instance); case ElementType.I1: return(Null <sbyte[]> .Instance); case ElementType.U1: return(Null <byte[]> .Instance); case ElementType.I2: return(Null <short[]> .Instance); case ElementType.U2: return(Null <ushort[]> .Instance); case ElementType.I4: return(Null <int[]> .Instance); case ElementType.U4: return(Null <uint[]> .Instance); case ElementType.I8: return(Null <long[]> .Instance); case ElementType.U8: return(Null <ulong[]> .Instance); case ElementType.R4: return(Null <float[]> .Instance); case ElementType.R8: return(Null <double[]> .Instance); case ElementType.String: return(Null <string[]> .Instance); case ElementType.Object: return(Null <object[]> .Instance); case ElementType.ValueType: case ElementType.Class: tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef; if (tdr.IsSystemType()) { return(Null <Type[]> .Instance); } td = tdr.ResolveTypeDef(); if (td != null && !td.IsEnum) { break; } return(EnumInfo.CreateNullArray(tdr)); } break; } var oldList = value as IList <CAArgument>; if (oldList == null) { break; } switch (elemType.GetElementType()) { case ElementType.Boolean: return(ConvertArray <bool>(elemType, oldList)); case ElementType.Char: return(ConvertArray <char>(elemType, oldList)); case ElementType.I1: return(ConvertArray <sbyte>(elemType, oldList)); case ElementType.U1: return(ConvertArray <byte>(elemType, oldList)); case ElementType.I2: return(ConvertArray <short>(elemType, oldList)); case ElementType.U2: return(ConvertArray <ushort>(elemType, oldList)); case ElementType.I4: return(ConvertArray <int>(elemType, oldList)); case ElementType.U4: return(ConvertArray <uint>(elemType, oldList)); case ElementType.I8: return(ConvertArray <long>(elemType, oldList)); case ElementType.U8: return(ConvertArray <ulong>(elemType, oldList)); case ElementType.R4: return(ConvertArray <float>(elemType, oldList)); case ElementType.R8: return(ConvertArray <double>(elemType, oldList)); case ElementType.String: return(ConvertArray <string>(elemType, oldList)); case ElementType.Object: return(ConvertArray <object>(elemType, oldList)); case ElementType.ValueType: case ElementType.Class: tdr = ((ClassOrValueTypeSig)elemType).TypeDefOrRef; if (tdr.IsSystemType()) { return(ConvertArray <TypeSig>(elemType, oldList)); } td = tdr.ResolveTypeDef(); if (td != null && !td.IsEnum) { break; } return(ConvertEnum(elemType, oldList)); } break; default: break; } return(value); }
static bool IsSystemVoid(TypeSig type) { return(type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void); }
static bool IsSystemVoid(TypeSig type) { return type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void; }
bool IsValidType(TypeSig type) { type = type.RemovePinnedAndModifiers(); if (type == null) { return(false); } if (type.ElementType == ElementType.Void) { return(false); } while (type != null) { switch (type.ElementType) { case ElementType.SZArray: case ElementType.Array: case ElementType.GenericInst: case ElementType.Ptr: case ElementType.Class: case ElementType.ValueType: case ElementType.FnPtr: 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.TypedByRef: case ElementType.I: case ElementType.U: case ElementType.String: case ElementType.Object: break; case ElementType.MVar: var gmvar = (GenericMVar)type; if (gmvar.Number >= method.MethodSig.GetGenParamCount()) { return(false); } break; case ElementType.Var: var gvar = (GenericVar)type; var dt = method.DeclaringType; if (dt == null || gvar.Number >= dt.GenericParameters.Count) { return(false); } break; case ElementType.ByRef: case ElementType.CModOpt: case ElementType.CModReqd: case ElementType.Pinned: case ElementType.Sentinel: case ElementType.ValueArray: case ElementType.R: case ElementType.End: case ElementType.Internal: case ElementType.Module: default: return(false); } if (type.Next == null) { break; } type = type.Next; } return(type != null); }
public static TypeDesc TryResolveTypeSig(ExecutionEngine executionEngine, MethodDesc method, TypeSig typeSig) { return(TryResolveTypeSigImpl(executionEngine, method, typeSig.RemovePinnedAndModifiers())); }
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); }
private static bool IsSystemVoid(TypeSig type) => type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void;
static void AppendTypeName(StringBuilder b, TypeSig type) { type = type.RemovePinnedAndModifiers(); if (type is null) { return; } if (type is GenericInstSig giType) { AppendTypeNameWithArguments(b, giType.GenericType is null ? null : giType.GenericType.TypeDefOrRef, giType.GenericArguments); return; } if (type is ArraySigBase arrayType) { AppendTypeName(b, arrayType.Next); b.Append('['); var lowerBounds = arrayType.GetLowerBounds(); var sizes = arrayType.GetSizes(); for (int i = 0; i < arrayType.Rank; i++) { if (i > 0) { b.Append(','); } if (i < lowerBounds.Count && i < sizes.Count) { b.Append(lowerBounds[i]); b.Append(':'); b.Append(sizes[i] + lowerBounds[i] - 1); } } b.Append(']'); return; } if (type is ByRefSig refType) { AppendTypeName(b, refType.Next); b.Append('@'); return; } if (type is PtrSig ptrType) { AppendTypeName(b, ptrType.Next); b.Append('*'); return; } if (type is GenericSig gp) { b.Append('`'); if (gp.IsMethodVar) { b.Append('`'); } b.Append(gp.Number); } else { var typeRef = type.ToTypeDefOrRef(); if (typeRef.DeclaringType is not null) { AppendTypeName(b, typeRef.DeclaringType.ToTypeSig()); b.Append('.'); b.Append(typeRef.Name); } else { FullNameFactory.FullNameSB(type, false, null, null, null, b); } } }
byte[] GetData(TypeSig typeSig, int level) { if (level >= 10) { return(null); } var retType = typeSig.RemovePinnedAndModifiers(); if (retType == null) { return(null); } switch (retType.ElementType) { case ElementType.Void: return(dataVoidReturnType); case ElementType.Boolean: case ElementType.Char: case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: return(dataInt32ReturnType); case ElementType.I8: case ElementType.U8: return(dataInt64ReturnType); case ElementType.R4: return(dataSingleReturnType); case ElementType.R8: return(dataDoubleReturnType); case ElementType.I: return(dataIntPtrReturnType); case ElementType.U: case ElementType.Ptr: case ElementType.FnPtr: return(dataUIntPtrReturnType); case ElementType.ValueType: var td = ((ValueTypeSig)retType).TypeDefOrRef.ResolveTypeDef(); if (td != null && td.IsEnum) { var undType = td.GetEnumUnderlyingType().RemovePinnedAndModifiers(); var et = undType.GetElementType(); if ((ElementType.Boolean <= et && et <= ElementType.R8) || et == ElementType.I || et == ElementType.U) { return(GetData(undType, level + 1)); } } goto case ElementType.TypedByRef; case ElementType.TypedByRef: case ElementType.Var: case ElementType.MVar: // Need ldloca, initobj, ldloc and a local variable return(null); case ElementType.GenericInst: if (((GenericInstSig)retType).GenericType is ValueTypeSig) { goto case ElementType.TypedByRef; } goto case ElementType.Class; case ElementType.End: case ElementType.String: case ElementType.ByRef: case ElementType.Class: case ElementType.Array: case ElementType.ValueArray: case ElementType.R: case ElementType.Object: case ElementType.SZArray: case ElementType.CModReqd: case ElementType.CModOpt: case ElementType.Internal: case ElementType.Module: case ElementType.Sentinel: case ElementType.Pinned: default: return(dataRefTypeReturnType); } }