static bool IsSystemVoid(TypeSig type) {
return type.RemovePinnedAndModifiers().GetElementType() == ElementType.Void;
}
public static bool HasModifierOrPinned(this TypeSig signature)
{
return(signature is ModifierSig || signature is PinnedSig);
}
(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 != null)
{
foreach (var l in sourceMethod.Body.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);
}
void WriteValue(TypeSig argType, CAArgument value) {
if (argType == null || value.Type == null) {
helper.Error("Argument type is null");
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
var arrayType = argType as SZArraySig;
if (arrayType != null) {
var argsArray = value.Value as IList<CAArgument>;
if (argsArray == null && value.Value != null)
helper.Error("Value is not null or an array");
WriteArrayValue(arrayType, argsArray);
}
else
WriteElem(argType, value);
recursionCounter.Decrement();
}
static TypeDef GetEnumTypeDef(TypeSig type) {
if (type == null)
return null;
var td = GetTypeDef(type);
if (td == null)
return null;
if (!td.IsEnum)
return null;
return td;
}
MethodDecl(
Identifier idName,
TypeSig tRetType,
ParamVarDecl[] arParams,
BlockStatement stmtBody,
Modifiers mods
)
{
//m_strName = idName.Text;
m_idName = idName;
m_tRetType = tRetType;
m_mods = mods;
if (m_mods.IsAbstract && !m_mods.IsOverride)
m_mods.SetVirtual();
m_arParams = (arParams != null) ? arParams : new ParamVarDecl[0];
m_stmtBody = stmtBody;
Debug.Assert(m_idName != null);
Debug.Assert((m_stmtBody != null) ^ mods.IsAbstract);
Debug.Assert(m_arParams != null);
// @todo - this is wrong
m_filerange = idName.Location;
}
/// <summary>
/// Write a <see cref="TypeSig"/> signature
/// </summary>
/// <param name="helper">Helper</param>
/// <param name="typeSig">The type</param>
/// <returns>The signature as a byte array</returns>
public static byte[] Write(ISignatureWriterHelper helper, TypeSig typeSig) {
using (var writer = new SignatureWriter(helper)) {
writer.Write(typeSig);
return writer.GetResult();
}
}
public static bool ContainsAnonymousType(this TypeSig type)
{
return(type.ContainsAnonymousType(0));
}
private static void SetupSignatureReferences(INameService service, ICollection <ModuleDefMD> modules, ModuleDef module, TypeSig typeSig)
{
var asTypeRef = typeSig.TryGetTypeRef();
if (asTypeRef != null)
{
SetupTypeReference(service, modules, module, asTypeRef);
}
}
public InstructionPushPopInfo(int pops, TypeSig pushType)
{
this.PopCount = pops;
this.Pushes = true;
this.PushType = pushType;
}
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;
}
}
public InstructionPushPopInfo(int pops)
{
this.PopCount = pops;
this.Pushes = false;
this.PushType = null;
}
public static CachedOutput CreateConstant(TypeSig type, object c, TypePrinterFlags flags)
{
return(TypePrinterUtils.WriteConstant(new TypeOutput(), type, c, flags).cachedOutput);
}
public static ITypeDefOrRef GetElementType(this TypeSig signature)
{
return(signature.GetNonNestedTypeRefScope());
}
public FieldDecl(
Identifier idName,
TypeSig tType,
Modifiers mods,
Exp exp // optional, may be null
)
{
m_stName = idName.Text;
m_tType = tType;
m_mods = mods;
m_expInit = exp;
Debug.Assert(m_tType != null);
//m_filerange = FileRange.Merge(tType.Location, idName.Location);
}
static bool CheckClass(TypeSig type, string fullName)
{
return(type != null && (type.ElementType == ElementType.Object || type.FullName == fullName));
}
public PropertyDecl(
Identifier idName, TypeSig tType,
ParamVarDecl param, // optional param, may be null
BlockStatement stmtGet, bool fHasGet,
BlockStatement stmtSet, bool fHasSet,
Modifiers mods
)
{
m_stmtGet = stmtGet;
m_stmtSet = stmtSet;
m_idName = idName;
m_tType = tType;
Debug.Assert(idName != null);
Debug.Assert(tType != null);
Debug.Assert(fHasGet || fHasSet);
m_mods = mods;
//m_expParam = expParam;
// Spoof bodies. Note that we just pass the attributes (static, virtual)
// right to the new methods. Also, if we're abstract, the XXXStmt will be null
// and the methods will just deal with that too.
if (fHasGet)
{
Debug.Assert(mods.IsAbstract ^ (stmtGet != null));
// T get_XXX();
Identifier idName2 = new Identifier("get_"+Name.Text, m_idName.Location);
m_declGet = new MethodDecl(
idName2,
m_tType,
(param == null) ?
new ParamVarDecl[0] :
new ParamVarDecl[] { param },
GetStmt,
mods
);
}
if (fHasSet)
{
Debug.Assert(mods.IsAbstract ^ (stmtSet != null));
// void set_XXX(T value);
Identifier idP1 = new Identifier("value", new FileRange());
ParamVarDecl T = new ParamVarDecl(idP1, (NonRefTypeSig) m_tType, EArgFlow.cIn);
ParamVarDecl [] p = (param == null) ?
new ParamVarDecl[] { T } :
new ParamVarDecl[] { param, T };
Identifier idName2 = new Identifier("set_"+Name.Text, m_idName.Location);
AST.TypeSig tVoid = new SimpleTypeSig(new SimpleObjExp(new Identifier("void", new FileRange())));
//AST.TypeSig tVoid = new ResolvedTypeSig(typeof(void), s);
m_declSet = new MethodDecl(idName2, tVoid,p, SetStmt, mods);
}
}
static bool IsStringType(TypeSig type)
{
return(type != null && (type.ElementType == ElementType.Object || type.ElementType == ElementType.String));
}
public VarDecl(Identifier idName, TypeSig tType)
{
m_tType = tType;
m_stName = idName.Text;
//m_filerange = FileRange.Merge(tType.Location, idName.Location);
}
IList <MethodSig> PossibleMethodSigs(ITypeDefOrRef declaringType, MethodSig sig, MethodData data)
{
// Setup generic types
IList <TypeSig> typeGenerics = new List <TypeSig>(), methodGenerics = new List <TypeSig>();
// Add all declaring spec generic types
TypeSpec declaringSpec = declaringType as TypeSpec;
if (declaringSpec != null)
{
var genericInstSig = declaringSpec.TryGetGenericInstSig();
foreach (var garg in genericInstSig.GenericArguments)
{
typeGenerics.Add(garg);
}
}
// Add all method generic types
if (data.HasGenericArguments)
{
foreach (var operand in data.GenericArguments)
{
var gtype = this.ResolveType_NoLock(operand.Position);
methodGenerics.Add(gtype.ToTypeSig());
}
}
// Todo: Combinations factoring in the possibility that return type might match
// a generic type
TypeSig returnType = ResolveType(data.ReturnType);
IList <TypeSig> returnTypes = GenericUtils.PossibleTypeSigs(returnType, typeGenerics, methodGenerics);
TypeSig[] paramTypes = new TypeSig[data.Parameters.Length];
for (Int32 i = 0; i < paramTypes.Length; i++)
{
paramTypes[i] = ResolveType(data.Parameters[i]);
}
UInt32 genericTypeCount = (UInt32)data.GenericArguments.Length;
IList <MethodSig> signatures = new List <MethodSig>();
var paramCombos = GenericUtils.CreateGenericParameterCombinations(paramTypes, typeGenerics, methodGenerics);
foreach (var rType in returnTypes)
{
foreach (var combo in paramCombos)
{
var paramCombo = combo.ToArray();
MethodSig methodSig;
if (genericTypeCount == 0)
{
if (data.IsStatic)
{
methodSig = MethodSig.CreateStatic(rType, paramCombo);
}
else
{
methodSig = MethodSig.CreateInstance(rType, paramCombo);
}
}
else
{
if (data.IsStatic)
{
methodSig = MethodSig.CreateStaticGeneric(genericTypeCount, rType, paramCombo);
}
else
{
methodSig = MethodSig.CreateInstanceGeneric(genericTypeCount, rType, paramCombo);
}
}
signatures.Add(methodSig);
}
}
return(signatures);
}
TypeSig FixTypeSig(TypeSig type) {
return SubstituteGenericParameter(type.RemoveModifiers()).RemoveModifiers();
}
static bool Equals(TypeSig ts1, TypeSig ts2)
{
return(new TypeComparer().Equals(ts1, ts2));
}
/// <summary>
/// Write a value
/// </summary>
/// <param name="argType">The ctor arg type, field type, or property type</param>
/// <param name="value">The value to write</param>
void WriteElem(TypeSig argType, CAArgument value) {
if (argType == null) {
helper.Error("Arg type is null");
argType = value.Type;
if (argType == null)
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
TypeSig underlyingType;
ITypeDefOrRef tdr;
switch (argType.ElementType) {
case ElementType.Boolean:
if (!VerifyTypeAndValue(value, ElementType.Boolean))
writer.Write(ToUInt64(value.Value) != 0);
else
writer.Write((bool)value.Value);
break;
case ElementType.Char:
if (!VerifyTypeAndValue(value, ElementType.Char))
writer.Write((ushort)ToUInt64(value.Value));
else
writer.Write((ushort)(char)value.Value);
break;
case ElementType.I1:
if (!VerifyTypeAndValue(value, ElementType.I1))
writer.Write((sbyte)ToUInt64(value.Value));
else
writer.Write((sbyte)value.Value);
break;
case ElementType.U1:
if (!VerifyTypeAndValue(value, ElementType.U1))
writer.Write((byte)ToUInt64(value.Value));
else
writer.Write((byte)value.Value);
break;
case ElementType.I2:
if (!VerifyTypeAndValue(value, ElementType.I2))
writer.Write((short)ToUInt64(value.Value));
else
writer.Write((short)value.Value);
break;
case ElementType.U2:
if (!VerifyTypeAndValue(value, ElementType.U2))
writer.Write((ushort)ToUInt64(value.Value));
else
writer.Write((ushort)value.Value);
break;
case ElementType.I4:
if (!VerifyTypeAndValue(value, ElementType.I4))
writer.Write((int)ToUInt64(value.Value));
else
writer.Write((int)value.Value);
break;
case ElementType.U4:
if (!VerifyTypeAndValue(value, ElementType.U4))
writer.Write((uint)ToUInt64(value.Value));
else
writer.Write((uint)value.Value);
break;
case ElementType.I8:
if (!VerifyTypeAndValue(value, ElementType.I8))
writer.Write((long)ToUInt64(value.Value));
else
writer.Write((long)value.Value);
break;
case ElementType.U8:
if (!VerifyTypeAndValue(value, ElementType.U8))
writer.Write(ToUInt64(value.Value));
else
writer.Write((ulong)value.Value);
break;
case ElementType.R4:
if (!VerifyTypeAndValue(value, ElementType.R4))
writer.Write((float)ToDouble(value.Value));
else
writer.Write((float)value.Value);
break;
case ElementType.R8:
if (!VerifyTypeAndValue(value, ElementType.R8))
writer.Write(ToDouble(value.Value));
else
writer.Write((double)value.Value);
break;
case ElementType.String:
if (VerifyTypeAndValue(value, ElementType.String, typeof(UTF8String)))
WriteUTF8String((UTF8String)value.Value);
else if (VerifyTypeAndValue(value, ElementType.String, typeof(string)))
WriteUTF8String((string)value.Value);
else
WriteUTF8String(UTF8String.Empty);
break;
case ElementType.ValueType:
tdr = ((TypeDefOrRefSig)argType).TypeDefOrRef;
underlyingType = GetEnumUnderlyingType(argType);
if (underlyingType != null)
WriteElem(underlyingType, value);
else if (tdr is TypeRef && TryWriteEnumUnderlyingTypeValue(value.Value)) {
// No error. Assume it's an enum that couldn't be resolved.
}
else
helper.Error("Custom attribute value is not an enum");
break;
case ElementType.Class:
tdr = ((TypeDefOrRefSig)argType).TypeDefOrRef;
if (CheckCorLibType(argType, "Type")) {
if (CheckCorLibType(value.Type, "Type")) {
var ts = value.Value as TypeSig;
if (ts != null)
WriteType(ts);
else {
helper.Error("CA value is not a type");
WriteUTF8String(UTF8String.Empty);
}
}
else {
helper.Error("CA value type is not System.Type");
WriteUTF8String(UTF8String.Empty);
}
break;
}
else if (tdr is TypeRef && TryWriteEnumUnderlyingTypeValue(value.Value)) {
// No error. Assume it's an enum that couldn't be resolved.
break;
}
goto default;
case ElementType.SZArray:
WriteValue(argType, value);
break;
case ElementType.Object:
WriteFieldOrPropType(value.Type);
WriteElem(value.Type, value);
break;
case ElementType.End:
case ElementType.Void:
case ElementType.Ptr:
case ElementType.ByRef:
case ElementType.Var:
case ElementType.Array:
case ElementType.GenericInst:
case ElementType.TypedByRef:
case ElementType.ValueArray:
case ElementType.I:
case ElementType.U:
case ElementType.R:
case ElementType.FnPtr:
case ElementType.MVar:
case ElementType.CModReqd:
case ElementType.CModOpt:
case ElementType.Internal:
case ElementType.Module:
case ElementType.Sentinel:
case ElementType.Pinned:
default:
helper.Error("Invalid or unsupported element type in custom attribute");
break;
}
recursionCounter.Decrement();
}
/// <summary>
/// Gets the types to push onto the stack from an instruction. Should
/// be run before popping.
/// </summary>
/// <param name="instr">Instruction</param>
/// <param name="state">Current stack state</param>
/// <returns>Types to push</returns>
IList <TypeSig> PushTypes(Instruction instr, Stack <TypeSig> state)
{
var module = this.Method.Module;
var list = new List <TypeSig>();
switch (instr.OpCode.StackBehaviourPush)
{
case StackBehaviour.Push0:
default:
break;
case StackBehaviour.Push1:
TypeSig type;
if ((type = this.LdargType(instr)) != null ||
(type = this.LdlocType(instr)) != null ||
(type = this.MathType(instr, state)) != null)
{
list.Add(type);
}
else if (instr.OpCode.Code == Code.Ldfld || instr.OpCode.Code == Code.Ldsfld)
{
list.Add((instr.Operand as IField).FieldSig.Type);
}
else
{
throw new Exception(String.Format("Unknown type pushed by Push1 instruction: {0}", instr));
}
break;
case StackBehaviour.Push1_push1:
// Only Dup has Push1_Push1 behaviour
if (instr.OpCode.Code == Code.Dup)
{
// Assumes value hasn't yet been popped: Will need to make sure that
// this method is run before popping
list.Add(state.Peek());
list.Add(state.Peek());
}
break;
case StackBehaviour.Pushi:
list.Add(module.CorLibTypes.Int32);
break;
case StackBehaviour.Pushi8:
list.Add(module.CorLibTypes.Int64);
break;
case StackBehaviour.Pushr4:
list.Add(module.CorLibTypes.Single);
break;
case StackBehaviour.Pushr8:
list.Add(module.CorLibTypes.Double);
break;
case StackBehaviour.Pushref:
if (instr.OpCode.Code == Code.Ldstr)
{
list.Add(module.CorLibTypes.String);
}
else if (instr.OpCode.Code == Code.Ldind_Ref)
{
list.Add(state.Peek().Next);
}
else if (instr.OpCode.Code == Code.Newobj)
{
var method = (instr.Operand as IMethod).ResolveMethodDefThrow();
if (instr.OpCode.Code == Code.Newobj)
{
list.Add(method.DeclaringType.ToTypeSig());
}
}
else
{
list.Add(module.CorLibTypes.Object); // Object by default
}
break;
case StackBehaviour.Varpush:
if (instr.Operand is IMethod)
{
TypeSig returnType = (instr.Operand as IMethod).ResolveMethodDefThrow().ReturnType;
if (returnType != null && !returnType.FullName.Equals("System.Void"))
{
list.Add(returnType);
}
}
break;
}
return(list);
}
void WriteFieldOrPropType(TypeSig type) {
type = type.RemoveModifiers();
if (type == null) {
helper.Error("Field/property type is null");
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
return;
}
ITypeDefOrRef tdr;
switch (type.ElementType) {
case ElementType.Boolean: writer.Write((byte)SerializationType.Boolean); break;
case ElementType.Char: writer.Write((byte)SerializationType.Char); break;
case ElementType.I1: writer.Write((byte)SerializationType.I1); break;
case ElementType.U1: writer.Write((byte)SerializationType.U1); break;
case ElementType.I2: writer.Write((byte)SerializationType.I2); break;
case ElementType.U2: writer.Write((byte)SerializationType.U2); break;
case ElementType.I4: writer.Write((byte)SerializationType.I4); break;
case ElementType.U4: writer.Write((byte)SerializationType.U4); break;
case ElementType.I8: writer.Write((byte)SerializationType.I8); break;
case ElementType.U8: writer.Write((byte)SerializationType.U8); break;
case ElementType.R4: writer.Write((byte)SerializationType.R4); break;
case ElementType.R8: writer.Write((byte)SerializationType.R8); break;
case ElementType.String: writer.Write((byte)SerializationType.String); break;
case ElementType.Object: writer.Write((byte)SerializationType.TaggedObject); break;
case ElementType.SZArray:
writer.Write((byte)SerializationType.SZArray);
WriteFieldOrPropType(type.Next);
break;
case ElementType.Class:
tdr = ((TypeDefOrRefSig)type).TypeDefOrRef;
if (CheckCorLibType(type, "Type"))
writer.Write((byte)SerializationType.Type);
else if (tdr is TypeRef) {
// Could be an enum TypeRef that couldn't be resolved, so the code
// assumed it's a class and created a ClassSig.
writer.Write((byte)SerializationType.Enum);
WriteType(tdr);
}
else
goto default;
break;
case ElementType.ValueType:
tdr = ((TypeDefOrRefSig)type).TypeDefOrRef;
var enumType = GetEnumTypeDef(type);
// If TypeRef => assume it's an enum that couldn't be resolved
if (enumType != null || tdr is TypeRef) {
writer.Write((byte)SerializationType.Enum);
WriteType(tdr);
}
else {
helper.Error("Custom attribute type doesn't seem to be an enum.");
writer.Write((byte)SerializationType.Enum);
WriteType(tdr);
}
break;
default:
helper.Error("Invalid type");
writer.Write((byte)0xFF);
break;
}
recursionCounter.Decrement();
}
void InitializeFrom(CAArgument arg, TypeSig storageType)
{
StorageType = storageType;
ConstantTypeVM.Value = ConvertFromModel(arg.Type, arg.Value);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="name">Name of constant</param>
/// <param name="type">Type of constant</param>
/// <param name="value">Constant value</param>
public MethodDebugConstant(string name, TypeSig type, object value)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Type = type ?? throw new ArgumentNullException(nameof(type));
Value = value;
}
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);
}
Instruction LoadIndirect(TypeSig type)
{
switch (type.GetElementType())
{
case ElementType.Boolean: return(Instruction.Create(OpCodes.Ldind_I1));
case ElementType.Char: return(Instruction.Create(OpCodes.Ldind_U2));
case ElementType.I1: return(Instruction.Create(OpCodes.Ldind_I1));
case ElementType.U1: return(Instruction.Create(OpCodes.Ldind_U1));
case ElementType.I2: return(Instruction.Create(OpCodes.Ldind_I2));
case ElementType.U2: return(Instruction.Create(OpCodes.Ldind_U2));
case ElementType.I4: return(Instruction.Create(OpCodes.Ldind_I4));
case ElementType.U4: return(Instruction.Create(OpCodes.Ldind_U4));
case ElementType.I8: return(Instruction.Create(OpCodes.Ldind_I8));
case ElementType.U8: return(Instruction.Create(OpCodes.Ldind_I8));
case ElementType.R4: return(Instruction.Create(OpCodes.Ldind_R4));
case ElementType.R8: return(Instruction.Create(OpCodes.Ldind_R8));
case ElementType.String: return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.I: return(Instruction.Create(OpCodes.Ldind_I));
case ElementType.U: return(Instruction.Create(OpCodes.Ldind_I));
case ElementType.ValueType: return(Instruction.Create(OpCodes.Ldobj, generatedModule.Import(type).ToTypeDefOrRef()));
case ElementType.Class: return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.Array: return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.Object: return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.SZArray: return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.Ptr: return(Instruction.Create(OpCodes.Ldind_I));
case ElementType.FnPtr: return(Instruction.Create(OpCodes.Ldind_I));
case ElementType.Var: return(Instruction.Create(OpCodes.Ldobj, generatedModule.Import(type).ToTypeDefOrRef()));
case ElementType.MVar: return(Instruction.Create(OpCodes.Ldobj, generatedModule.Import(type).ToTypeDefOrRef()));
case ElementType.TypedByRef: return(Instruction.Create(OpCodes.Ldobj, generatedModule.Import(type).ToTypeDefOrRef()));
case ElementType.GenericInst:
var gis = type as GenericInstSig;
if (gis.GenericType.IsValueTypeSig)
{
return(Instruction.Create(OpCodes.Ldobj, generatedModule.Import(type).ToTypeDefOrRef()));
}
return(Instruction.Create(OpCodes.Ldind_Ref));
case ElementType.End:
case ElementType.Void:
case ElementType.ByRef:
case ElementType.ValueArray:
case ElementType.R:
case ElementType.CModReqd:
case ElementType.CModOpt:
case ElementType.Internal:
case ElementType.Module:
case ElementType.Sentinel:
case ElementType.Pinned:
default:
return(Instruction.Create(OpCodes.Nop));
}
}
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 enumInfo)
{
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());
}
IList<TypeSig> GetLocals() {
var localsSig = new TypeSig[cilBody.Variables.Count];
for (int i = 0; i < cilBody.Variables.Count; i++)
localsSig[i] = cilBody.Variables[i].Type;
return localsSig;
}
public CAArgumentVM(ModuleDef ownerModule, CAArgument arg, TypeSigCreatorOptions options, TypeSig storageType)
{
module = options.OwnerModule;
originalArg = arg.Clone();
ConstantTypeVM = new DnlibDialogs.ConstantTypeVM(ownerModule, null, ConstantTypes, true, true, options);
ConstantTypeVM.PropertyChanged += ConstantTypeVM_PropertyChanged;
InitializeFrom(arg, storageType);
modified = false;
}
// Name & type can't be null.
// Must have at least Get or Set be non-null
public PropertyDecl(
Identifier idName, TypeSig tType,
BlockStatement stmtGet, bool fHasGet,
BlockStatement stmtSet, bool fHasSet,
Modifiers mods
) :
this(
idName, tType,
null,
stmtGet, fHasGet,
stmtSet, fHasSet,
mods)
{
}
public Instructions Emit(OpCode opCode, TypeSig value)
{
return(Insert(Instruction.Create(opCode, value.ToTypeDefOrRef())));
}
MethodDecl(
Identifier idName,
TypeSig tRetType,
ParamVarDecl[] arParams
)
{
//m_strName = idName.Text;
m_idName = idName;
m_tRetType = tRetType;
m_mods = new Modifiers();
m_mods.SetAbstract();
m_mods.SetVirtual();
m_mods.SetPublic();
m_arParams = (arParams != null) ? arParams : new ParamVarDecl[0];
m_stmtBody = null;
Debug.Assert(m_idName != null);
Debug.Assert(m_arParams != null);
// @todo - this is wrong
m_filerange = idName.Location;
}
public static void WriteTo(this TypeSig type, ITextOutput writer, ILNameSyntax syntax = ILNameSyntax.Signature)
{
type.WriteTo(writer, syntax, 0);
}
// For overloaded operators
// No modifiers needed since op overloading must be public & static.
// Have a special constructor so that we can set the IsOp flag and
// get a safe string name.
public MethodDecl(
BinaryExp.BinaryOp op,
TypeSig tRetType,
ParamVarDecl[] arParams,
BlockStatement stmtBody
)
{
m_fIsOpOverload = true;
string strName = GetOpOverloadedName(op);
m_idName = new Identifier(strName, tRetType.Location);
m_tRetType = tRetType;
m_arParams = (arParams != null) ? arParams : new ParamVarDecl[0];
m_stmtBody = stmtBody;
//m_mods = new Modifiers(Modifiers.EFlags.Public | Modifiers.EFlags.Static);
m_mods = new Modifiers();
m_mods.SetPublic();
m_mods.SetStatic();
Debug.Assert(m_idName != null);
Debug.Assert(m_stmtBody != null);
Debug.Assert(m_arParams != null);
}
public static void WriteTo(this TypeSig type, ITextOutput writer, ILNameSyntax syntax, int depth)
{
if (depth++ > MAX_CONVERTTYPE_DEPTH)
{
return;
}
ILNameSyntax syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature;
if (type is PinnedSig)
{
((PinnedSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.WriteSpace();
writer.Write("pinned", TextTokenType.Keyword);
}
else if (type is ArraySig)
{
ArraySig at = (ArraySig)type;
at.Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('[', TextTokenType.Operator);
for (int i = 0; i < at.Rank; i++)
{
if (i != 0)
{
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
int? lower = i < at.LowerBounds.Count ? at.LowerBounds[i] : (int?)null;
uint?size = i < at.Sizes.Count ? at.Sizes[i] : (uint?)null;
if (lower != null)
{
writer.Write(lower.ToString(), TextTokenType.Number);
if (size != null)
{
writer.Write("..", TextTokenType.Operator);
writer.Write((lower.Value + (int)size.Value - 1).ToString(), TextTokenType.Number);
}
else
{
writer.Write("...", TextTokenType.Operator);
}
}
}
writer.Write(']', TextTokenType.Operator);
}
else if (type is SZArraySig)
{
SZArraySig at = (SZArraySig)type;
at.Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write("[]", TextTokenType.Operator);
}
else if (type is GenericSig)
{
if (((GenericSig)type).IsMethodVar)
{
writer.Write("!!", TextTokenType.Operator);
}
else
{
writer.Write("!", TextTokenType.Operator);
}
string typeName = type.TypeName;
if (string.IsNullOrEmpty(typeName) || typeName[0] == '!' || syntax == ILNameSyntax.SignatureNoNamedTypeParameters)
{
writer.Write(((GenericSig)type).Number.ToString(), TextTokenType.Number);
}
else
{
writer.Write(Escape(typeName), TextTokenHelper.GetTextTokenType(type));
}
}
else if (type is ByRefSig)
{
((ByRefSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('&', TextTokenType.Operator);
}
else if (type is PtrSig)
{
((PtrSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('*', TextTokenType.Operator);
}
else if (type is GenericInstSig)
{
((GenericInstSig)type).GenericType.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('<', TextTokenType.Operator);
var arguments = ((GenericInstSig)type).GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
if (i > 0)
{
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
arguments[i].WriteTo(writer, syntaxForElementTypes, depth);
}
writer.Write('>', TextTokenType.Operator);
}
else if (type is CModOptSig)
{
((ModifierSig)type).Next.WriteTo(writer, syntax, depth);
writer.WriteSpace();
writer.Write("modopt", TextTokenType.Keyword);
writer.Write('(', TextTokenType.Operator);
((ModifierSig)type).Modifier.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write(')', TextTokenType.Operator);
writer.WriteSpace();
}
else if (type is CModReqdSig)
{
((ModifierSig)type).Next.WriteTo(writer, syntax, depth);
writer.WriteSpace();
writer.Write("modreq", TextTokenType.Keyword);
writer.Write('(', TextTokenType.Operator);
((ModifierSig)type).Modifier.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write(')', TextTokenType.Operator);
writer.WriteSpace();
}
else if (type is TypeDefOrRefSig)
{
WriteTo(((TypeDefOrRefSig)type).TypeDefOrRef, writer, syntax, depth);
}
else if (type is FnPtrSig)
{
WriteTo(type.ToTypeDefOrRef(), writer, syntax, depth);
}
//TODO: SentinelSig
}
public LocalVarDecl(Identifier idName, TypeSig tType) : base(idName, tType)
{
m_symbol = new LocalVarExpEntry();
}
public static void WriteTo(this ITypeDefOrRef type, ITextOutput writer, ILNameSyntax syntax, int depth)
{
if (depth++ > MAX_CONVERTTYPE_DEPTH || type == null)
{
return;
}
var ts = type as TypeSpec;
if (ts != null && !(ts.TypeSig is FnPtrSig))
{
WriteTo(((TypeSpec)type).TypeSig, writer, syntax, depth);
return;
}
string typeFullName = type.FullName;
string typeName = type.Name.String;
if (ts != null)
{
var fnPtrSig = ts.TypeSig as FnPtrSig;
typeFullName = DnlibExtensions.GetFnPtrFullName(fnPtrSig);
typeName = DnlibExtensions.GetFnPtrName(fnPtrSig);
}
TypeSig typeSig = null;
string name = type.DefinitionAssembly.IsCorLib() ? PrimitiveTypeName(typeFullName, type.Module, out typeSig) : null;
if (syntax == ILNameSyntax.ShortTypeName)
{
if (name != null)
{
WriteKeyword(writer, name, typeSig.ToTypeDefOrRef());
}
else
{
writer.WriteReference(Escape(typeName), type, TextTokenHelper.GetTextTokenType(type));
}
}
else if ((syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) && name != null)
{
WriteKeyword(writer, name, typeSig.ToTypeDefOrRef());
}
else
{
if (syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters)
{
writer.Write(DnlibExtensions.IsValueType(type) ? "valuetype" : "class", TextTokenType.Keyword);
writer.WriteSpace();
}
if (type.DeclaringType != null)
{
type.DeclaringType.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write('/', TextTokenType.Operator);
writer.WriteReference(Escape(typeName), type, TextTokenHelper.GetTextTokenType(type));
}
else
{
if (!(type is TypeDef) && type.Scope != null && !(type is TypeSpec))
{
writer.Write('[', TextTokenType.Operator);
writer.Write(Escape(type.Scope.GetScopeName()), TextTokenType.ILModule);
writer.Write(']', TextTokenType.Operator);
}
if (ts != null || MustEscape(typeFullName))
{
writer.WriteReference(Escape(typeFullName), type, TextTokenHelper.GetTextTokenType(type));
}
else
{
WriteNamespace(writer, type.Namespace);
if (!string.IsNullOrEmpty(type.Namespace))
{
writer.Write('.', TextTokenType.Operator);
}
writer.WriteReference(IdentifierEscaper.Escape(type.Name), type, TextTokenHelper.GetTextTokenType(type));
}
}
}
}
void Write(TypeSig typeSig) {
const ElementType DEFAULT_ELEMENT_TYPE = ElementType.Boolean;
if (typeSig == null) {
helper.Error("TypeSig is null");
writer.Write((byte)DEFAULT_ELEMENT_TYPE);
return;
}
if (!recursionCounter.Increment()) {
helper.Error("Infinite recursion");
writer.Write((byte)DEFAULT_ELEMENT_TYPE);
return;
}
uint count;
switch (typeSig.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.TypedByRef:
case ElementType.I:
case ElementType.U:
case ElementType.Object:
case ElementType.Sentinel:
writer.Write((byte)typeSig.ElementType);
break;
case ElementType.Ptr:
case ElementType.ByRef:
case ElementType.SZArray:
case ElementType.Pinned:
writer.Write((byte)typeSig.ElementType);
Write(typeSig.Next);
break;
case ElementType.ValueType:
case ElementType.Class:
writer.Write((byte)typeSig.ElementType);
Write(((TypeDefOrRefSig)typeSig).TypeDefOrRef);
break;
case ElementType.Var:
case ElementType.MVar:
writer.Write((byte)typeSig.ElementType);
WriteCompressedUInt32(((GenericSig)typeSig).Number);
break;
case ElementType.Array:
writer.Write((byte)typeSig.ElementType);
var ary = (ArraySig)typeSig;
Write(ary.Next);
WriteCompressedUInt32(ary.Rank);
if (ary.Rank == 0)
break;
count = WriteCompressedUInt32((uint)ary.Sizes.Count);
for (uint i = 0; i < count; i++)
WriteCompressedUInt32(ary.Sizes[(int)i]);
count = WriteCompressedUInt32((uint)ary.LowerBounds.Count);
for (uint i = 0; i < count; i++)
WriteCompressedInt32(ary.LowerBounds[(int)i]);
break;
case ElementType.GenericInst:
writer.Write((byte)typeSig.ElementType);
var gis = (GenericInstSig)typeSig;
Write(gis.GenericType);
count = WriteCompressedUInt32((uint)gis.GenericArguments.Count);
for (uint i = 0; i < count; i++)
Write(gis.GenericArguments[(int)i]);
break;
case ElementType.ValueArray:
writer.Write((byte)typeSig.ElementType);
Write(typeSig.Next);
WriteCompressedUInt32((typeSig as ValueArraySig).Size);
break;
case ElementType.FnPtr:
writer.Write((byte)typeSig.ElementType);
Write((typeSig as FnPtrSig).Signature);
break;
case ElementType.CModReqd:
case ElementType.CModOpt:
writer.Write((byte)typeSig.ElementType);
Write((typeSig as ModifierSig).Modifier);
Write(typeSig.Next);
break;
case ElementType.Module:
writer.Write((byte)typeSig.ElementType);
WriteCompressedUInt32((typeSig as ModuleSig).Index);
Write(typeSig.Next);
break;
case ElementType.End:
case ElementType.R:
case ElementType.Internal:
default:
helper.Error("Unknown or unsupported element type");
writer.Write((byte)DEFAULT_ELEMENT_TYPE);
break;
}
recursionCounter.Decrement();
}
public static string PrimitiveTypeName(string fullName, ModuleDef module, out TypeSig typeSig)
{
var corLibTypes = module == null ? null : module.CorLibTypes;
typeSig = null;
switch (fullName)
{
case "System.SByte":
if (corLibTypes != null)
{
typeSig = corLibTypes.SByte;
}
return("int8");
case "System.Int16":
if (corLibTypes != null)
{
typeSig = corLibTypes.Int16;
}
return("int16");
case "System.Int32":
if (corLibTypes != null)
{
typeSig = corLibTypes.Int32;
}
return("int32");
case "System.Int64":
if (corLibTypes != null)
{
typeSig = corLibTypes.Int64;
}
return("int64");
case "System.Byte":
if (corLibTypes != null)
{
typeSig = corLibTypes.Byte;
}
return("uint8");
case "System.UInt16":
if (corLibTypes != null)
{
typeSig = corLibTypes.UInt16;
}
return("uint16");
case "System.UInt32":
if (corLibTypes != null)
{
typeSig = corLibTypes.UInt32;
}
return("uint32");
case "System.UInt64":
if (corLibTypes != null)
{
typeSig = corLibTypes.UInt64;
}
return("uint64");
case "System.Single":
if (corLibTypes != null)
{
typeSig = corLibTypes.Single;
}
return("float32");
case "System.Double":
if (corLibTypes != null)
{
typeSig = corLibTypes.Double;
}
return("float64");
case "System.Void":
if (corLibTypes != null)
{
typeSig = corLibTypes.Void;
}
return("void");
case "System.Boolean":
if (corLibTypes != null)
{
typeSig = corLibTypes.Boolean;
}
return("bool");
case "System.String":
if (corLibTypes != null)
{
typeSig = corLibTypes.String;
}
return("string");
case "System.Char":
if (corLibTypes != null)
{
typeSig = corLibTypes.Char;
}
return("char");
case "System.Object":
if (corLibTypes != null)
{
typeSig = corLibTypes.Object;
}
return("object");
case "System.IntPtr":
if (corLibTypes != null)
{
typeSig = corLibTypes.IntPtr;
}
return("native int");
case "System.UIntPtr":
if (corLibTypes != null)
{
typeSig = corLibTypes.UIntPtr;
}
return("native unsigned int");
case "System.TypedReference":
if (corLibTypes != null)
{
typeSig = corLibTypes.TypedReference;
}
return("typedref");
default:
return(null);
}
}
TypeSig SubstituteGenericParameter(TypeSig type) {
if (genericArguments == null)
return type;
return genericArguments.Resolve(type);
}
public T Write <T>(T output, TypeSig type, TypePrinterFlags flags) where T : ITypeOutput
{
new TypePrinter(output, flags).Write(type, TypeParameters.ToArray());
return(output);
}
static bool VerifyType(TypeSig type, ElementType etype) {
type = type.RemoveModifiers();
// Assume it's an enum if it's a ValueType
return type != null && (etype == type.ElementType || type.ElementType == ElementType.ValueType);
}
public string ToString(TypeSig type, TypePrinterFlags flags)
{
return(Write(new StringBuilderTypeOutput(), type, flags).ToString());
}
/// <summary>
/// Gets the enum's underlying type
/// </summary>
/// <param name="type">An enum type</param>
/// <returns>The underlying type or <c>null</c> if we couldn't resolve the type ref</returns>
static TypeSig GetEnumUnderlyingType(TypeSig type) {
var td = GetEnumTypeDef(type);
if (td == null)
return null;
return td.GetEnumUnderlyingType().RemoveModifiers();
}
public string ToString(TypeSig type)
{
return(ToString(type, TypePrinterFlags.Default));
}
/// <summary>
/// Converts <paramref name="type"/> to a <see cref="TypeDef"/>, possibly resolving
/// a <see cref="TypeRef"/>
/// </summary>
/// <param name="type">The type</param>
/// <returns>A <see cref="TypeDef"/> or <c>null</c> if we couldn't resolve the
/// <see cref="TypeRef"/> or if <paramref name="type"/> is a type spec</returns>
static TypeDef GetTypeDef(TypeSig type) {
var tdr = type as TypeDefOrRefSig;
if (tdr != null) {
var td = tdr.TypeDef;
if (td != null)
return td;
var tr = tdr.TypeRef;
if (tr != null)
return tr.Resolve();
}
return null;
}
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);
}
static bool CheckCorLibType(TypeSig ts, string name) {
var tdrs = ts as TypeDefOrRefSig;
if (tdrs == null)
return false;
return CheckCorLibType(tdrs.TypeDefOrRef, name);
}
/// <summary> /// Indicates whether the given <see cref="TypeSig" /> belongs to given module /// </summary> /// <param name="typeSig">The type sig.</param> /// <param name="module">The module.</param> /// <returns></returns> public static bool BelongsTo(this TypeSig typeSig, ModuleDefMD2 module) => BelongsTo(typeSig.Scope as AssemblyRef, module);
