/// <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);
}
