/// <summary>
/// Gets the next <see cref="TypeDef"/> or <c>null</c> if there are no more left.
/// The cache is updated with the returned <see cref="TypeDef"/> before the method
/// returns.
/// </summary>
/// <returns>The next <see cref="TypeDef"/> or <c>null</c> if none</returns>
TypeDef GetNextTypeDefCache()
{
var type = GetNextTypeDef();
if (type == null)
{
return(null);
}
// Only insert it if another type with the exact same sig/name isn't already
// in the cache. This should only happen with some obfuscated assemblies.
if (!typeRefCache.ContainsKey(type))
{
typeRefCache[type] = type;
}
string fn;
sb.Length = 0;
if (!normalNameCache.ContainsKey(fn = FullNameCreator.FullName(type, false, null, sb)))
{
normalNameCache[fn] = type;
}
sb.Length = 0;
if (!reflectionNameCache.ContainsKey(fn = FullNameCreator.FullName(type, true, null, sb)))
{
reflectionNameCache[fn] = type;
}
return(type);
}
public static string GetFnPtrFullName(FnPtrSig sig)
{
if (sig == null)
{
return(string.Empty);
}
var methodSig = sig.MethodSig;
if (methodSig == null)
{
return(GetFnPtrName(sig));
}
var sb = new StringBuilder();
sb.Append("method ");
FullNameCreator.FullNameSB(methodSig.RetType, false, null, null, null, sb);
sb.Append(" *(");
PrintArgs(sb, methodSig.Params, true);
if (methodSig.ParamsAfterSentinel != null)
{
if (methodSig.Params.Count > 0)
{
sb.Append(",");
}
sb.Append("...,");
PrintArgs(sb, methodSig.ParamsAfterSentinel, false);
}
sb.Append(")");
return(sb.ToString());
}
static TypeDef FindTypeName(ModuleDef module, string name, StringComparer comparer)
{
var sb = new StringBuilder();
return(module.GetTypes().FirstOrDefault(a => {
sb.Clear();
string s1, s2;
if (comparer.Equals(s1 = FullNameCreator.Name(a, false, sb), name))
{
return true;
}
sb.Clear();
if (comparer.Equals(s2 = FullNameCreator.Name(a, true, sb), name))
{
return true;
}
sb.Clear();
if (comparer.Equals(CleanTypeName(s1), name))
{
return true;
}
sb.Clear();
return comparer.Equals(CleanTypeName(s2), name);
}));
}
StringBuilder GetName(IType type)
{
this.transform.stringBuilder.Clear();
if (type == null)
{
return(this.transform.stringBuilder);
}
return(FullNameCreator.NameSB(type, false, this.transform.stringBuilder));
}
void WriteType(IType type)
{
if (type == null)
{
helper.Error("Type is null");
WriteUTF8String(UTF8String.Empty);
}
else
{
WriteUTF8String(FullNameCreator.AssemblyQualifiedName(type, helper));
}
}
static void PrintArgs(StringBuilder sb, IList <TypeSig> args, bool isFirst)
{
foreach (var arg in args)
{
if (!isFirst)
{
sb.Append(",");
}
isFirst = false;
FullNameCreator.FullNameSB(arg, false, null, null, null, sb);
}
}
string GetNameByType(TypeSig type)
{
type = type.RemoveModifiers();
GenericInstSig git = type as GenericInstSig;
if (git != null && git.GenericType != null && git.GenericArguments.Count == 1 && git.GenericType.TypeDefOrRef.Compare(systemString, nullableString))
{
type = ((GenericInstSig)type).GenericArguments[0];
}
string name;
if (type == null)
{
return(string.Empty);
}
if (type.IsSingleOrMultiDimensionalArray)
{
name = "array";
}
else if (type.IsPointer || type.IsByRef)
{
name = "ptr";
}
else
{
stringBuilder.Clear();
if (FullNameCreator.NameSB(type, false, stringBuilder).EndsWith("Exception"))
{
name = "ex";
}
else
{
stringBuilder.Clear();
if (!typeNameToVariableNameDict.TryGetValue(FullNameCreator.FullName(type, false, null, null, null, stringBuilder), out name))
{
stringBuilder.Clear();
name = FullNameCreator.Name(type, false, stringBuilder);
// remove the 'I' for interfaces
if (name.Length >= 3 && name[0] == 'I' && char.IsUpper(name[1]) && char.IsLower(name[2]))
{
name = name.Substring(1);
}
name = CleanUpVariableName(name);
}
}
}
return(name);
}
public static string CreateDisplayName(IMethod method, bool fullName = false)
{
var sb = new StringBuilder();
if (fullName)
{
sb.AppendFormat("{0}.", CreateDisplayName(method.DeclaringType, true));
}
if (method.MethodSig == null)
{
sb.Append(method.Name ?? "<<<NULL>>>");
}
else
{
if (!UTF8String.IsNullOrEmpty(method.Name))
{
sb.Append(method.Name);
}
if (method.MethodSig.Generic)
{
sb.Append('<');
uint genParamCount = method.MethodSig.GenParamCount;
for (uint i = 0; i < genParamCount; i++)
{
if (i != 0)
{
sb.Append(", ");
}
sb.Append(FullNameCreator.Name(new GenericMVar(i, method as MethodDef), false));
}
sb.Append('>');
}
sb.Append('(');
int count = PrintMethodArgList(sb, method.MethodSig.Params, false, false);
PrintMethodArgList(sb, method.MethodSig.ParamsAfterSentinel, count > 0, true);
if (method.Name == ".ctor" || method.Name == ".cctor")
{
sb.Append(")");
}
else
{
sb.Append(") : ");
sb.Append(CreateDisplayName(method.MethodSig.RetType));
}
}
return(sb.ToString());
}
TypeDef FindSlowNormal(string fullName)
{
InitializeTypeEnumerator();
while (true)
{
var type = GetNextTypeDef();
if (type == null)
{
return(type);
}
sb.Length = 0;
if (FullNameCreator.FullName(type, false, null, sb) == fullName)
{
return(type);
}
}
}
public static string GetName(this IType type, StringBuilder sb)
{
var td = type as TypeDef;
if (td != null)
{
return(td.Name);
}
var tr = type as TypeRef;
if (tr != null)
{
return(tr.Name);
}
sb.Length = 0;
return(FullNameCreator.Name(type, false, sb));
}
static int AppendTypeNameWithArguments(StringBuilder b, ITypeDefOrRef type, IList <TypeSig> genericArguments)
{
if (type == null)
{
return(0);
}
int outerTypeParameterCount = 0;
if (type.DeclaringType != null)
{
ITypeDefOrRef declType = type.DeclaringType;
outerTypeParameterCount = AppendTypeNameWithArguments(b, declType, genericArguments);
b.Append('.');
}
else
{
int len = b.Length;
FullNameCreator.NamespaceSB(type, true, b);
if (len != b.Length)
{
b.Append('.');
}
}
int localTypeParameterCount = 0;
b.Append(SplitTypeParameterCountFromReflectionName(type.Name, out localTypeParameterCount));
if (localTypeParameterCount > 0)
{
int totalTypeParameterCount = outerTypeParameterCount + localTypeParameterCount;
b.Append('{');
for (int i = outerTypeParameterCount; i < totalTypeParameterCount && i < genericArguments.Count; i++)
{
if (i > outerTypeParameterCount)
{
b.Append(',');
}
AppendTypeName(b, genericArguments[i]);
}
b.Append('}');
}
return(outerTypeParameterCount + localTypeParameterCount);
}
public static string GetMethodSigFullName(MethodSig methodSig)
{
if (methodSig == null)
{
return(string.Empty);
}
var sb = new StringBuilder();
sb.Append(FullNameCreator.FullName(methodSig.RetType, false));
sb.Append("(");
PrintArgs(sb, methodSig.Params, true);
if (methodSig.ParamsAfterSentinel != null)
{
if (methodSig.Params.Count > 0)
{
sb.Append(",");
}
sb.Append("...,");
PrintArgs(sb, methodSig.ParamsAfterSentinel, false);
}
sb.Append(")");
return(sb.ToString());
}
TypeDef FindCacheNormal(string fullName)
{
TypeDef cachedType;
if (normalNameCache.TryGetValue(fullName, out cachedType))
{
return(cachedType);
}
// Build the cache lazily
while (true)
{
cachedType = GetNextTypeDefCache();
if (cachedType == null)
{
return(cachedType);
}
sb.Length = 0;
if (FullNameCreator.FullName(cachedType, false, null, sb) == fullName)
{
return(cachedType);
}
}
}
public override string ToString() => FullNameCreator.MethodFullName("", Name, MethodSig);
public static string CreateDisplayName(IType type, bool fullName = false)
{
var sb = new StringBuilder();
if (type is ExportedType)
{
if (fullName)
{
sb.Append(FullNameCreator.FullName((ExportedType)type, true));
}
else
{
sb.Append(FullNameCreator.Name((ExportedType)type, true));
}
return(sb.ToString());
}
if (type is TypeSpec)
{
type = ((TypeSpec)type).TypeSig;
}
if (type is TypeSig)
{
if (type is TypeDefOrRefSig)
{
type = ((TypeDefOrRefSig)type).TypeDefOrRef;
}
else
{
CreateDisplayName(sb, new RecursionCounter(), (TypeSig)type, fullName);
return(sb.ToString());
}
}
if (type is TypeRef)
{
if (fullName)
{
sb.Append(FullNameCreator.FullName((TypeRef)type, true));
}
else
{
sb.Append(FullNameCreator.Name((TypeRef)type, true));
}
}
else if (type is TypeDef)
{
var typeDef = (TypeDef)type;
if (fullName)
{
sb.Append(FullNameCreator.FullName(typeDef, true));
}
else
{
sb.Append(FullNameCreator.Name(typeDef, true));
}
if (typeDef.HasGenericParameters)
{
sb.Append('<');
uint genParamCount = (uint)typeDef.GenericParameters.Count;
for (uint i = 0; i < genParamCount; i++)
{
if (i != 0)
{
sb.Append(", ");
}
sb.Append(FullNameCreator.Name(new GenericVar(i, typeDef), false));
}
sb.Append('>');
}
}
else
{
throw new NotSupportedException();
}
return(sb.ToString());
}
public override string ToString()
{
return(FullNameCreator.MethodFullName(InterfaceType == null ? "" : FullNameCreator.FullName(InterfaceType, false), Name, MethodSig));
}
/// <inheritdoc/>
public override string ToString()
{
return(FullNameCreator.PropertySigFullName(this));
}
/// <inheritdoc/>
public override string ToString()
{
return(FullNameCreator.MethodSigFullName(this));
}
/// <inheritdoc/>
public override string ToString()
{
return(FullNameCreator.FullName(type == null ? null : type, false));
}
/// <summary>
/// Add an instruction's operand to <paramref name="sb"/>
/// </summary>
/// <param name="sb">Place result here</param>
/// <param name="instr">The instruction</param>
/// <param name="extra">A string that will be added before the operand, if there's
/// an operand.</param>
public static void AddOperandString(StringBuilder sb, Instruction instr, string extra)
{
var op = instr.Operand;
switch (instr.OpCode.OperandType)
{
case OperandType.InlineBrTarget:
case OperandType.ShortInlineBrTarget:
sb.Append(extra);
AddInstructionTarget(sb, op as Instruction);
break;
case OperandType.InlineField:
case OperandType.InlineMethod:
case OperandType.InlineTok:
case OperandType.InlineType:
sb.Append(extra);
if (op is IFullName)
{
sb.Append((op as IFullName).FullName);
}
else if (op != null)
{
sb.Append(op.ToString());
}
else
{
sb.Append("null");
}
break;
case OperandType.InlineI:
case OperandType.InlineI8:
case OperandType.InlineR:
case OperandType.ShortInlineI:
case OperandType.ShortInlineR:
sb.Append(string.Format("{0}{1}", extra, op));
break;
case OperandType.InlineSig:
sb.Append(extra);
sb.Append(FullNameCreator.MethodFullName(null, (UTF8String)null, op as MethodSig));
break;
case OperandType.InlineString:
sb.Append(extra);
EscapeString(sb, op as string, true);
break;
case OperandType.InlineSwitch:
var targets = op as IList <Instruction>;
if (targets == null)
{
sb.Append("null");
}
else
{
sb.Append('(');
for (int i = 0; i < targets.Count; i++)
{
if (i != 0)
{
sb.Append(',');
}
AddInstructionTarget(sb, targets.Get(i, null));
}
sb.Append(')');
}
break;
case OperandType.InlineVar:
case OperandType.ShortInlineVar:
sb.Append(extra);
if (op == null)
{
sb.Append("null");
}
else
{
sb.Append(op.ToString());
}
break;
case OperandType.InlineNone:
case OperandType.InlinePhi:
default:
break;
}
}
private byte[] Write(MarshalType marshalType)
{
if (marshalType == null)
{
return(null);
}
var type = marshalType.NativeType;
if (type != NativeType.RawBlob)
{
if ((uint)type > byte.MaxValue)
{
helper.Error("Invalid MarshalType.NativeType");
}
writer.Write((byte)type);
}
bool canWrite = true;
switch (type)
{
case NativeType.FixedSysString:
var fixedSysString = (FixedSysStringMarshalType)marshalType;
if (fixedSysString.IsSizeValid)
{
WriteCompressedUInt32((uint)fixedSysString.Size);
}
break;
case NativeType.SafeArray:
var safeArray = (SafeArrayMarshalType)marshalType;
if (UpdateCanWrite(safeArray.IsVariantTypeValid, "VariantType", ref canWrite))
{
WriteCompressedUInt32((uint)safeArray.VariantType);
}
if (UpdateCanWrite(safeArray.IsUserDefinedSubTypeValid, "UserDefinedSubType", ref canWrite))
{
Write(safeArray.UserDefinedSubType.AssemblyQualifiedName);
}
break;
case NativeType.FixedArray:
var fixedArray = (FixedArrayMarshalType)marshalType;
if (UpdateCanWrite(fixedArray.IsSizeValid, "Size", ref canWrite))
{
WriteCompressedUInt32((uint)fixedArray.Size);
}
if (UpdateCanWrite(fixedArray.IsElementTypeValid, "ElementType", ref canWrite))
{
WriteCompressedUInt32((uint)fixedArray.ElementType);
}
break;
case NativeType.Array:
var array = (ArrayMarshalType)marshalType;
if (UpdateCanWrite(array.IsElementTypeValid, "ElementType", ref canWrite))
{
WriteCompressedUInt32((uint)array.ElementType);
}
if (UpdateCanWrite(array.IsParamNumberValid, "ParamNumber", ref canWrite))
{
WriteCompressedUInt32((uint)array.ParamNumber);
}
if (UpdateCanWrite(array.IsSizeValid, "Size", ref canWrite))
{
WriteCompressedUInt32((uint)array.Size);
}
if (UpdateCanWrite(array.IsFlagsValid, "Flags", ref canWrite))
{
WriteCompressedUInt32((uint)array.Flags);
}
break;
case NativeType.CustomMarshaler:
var custMarshaler = (CustomMarshalType)marshalType;
Write(custMarshaler.Guid);
Write(custMarshaler.NativeTypeName);
var cm = custMarshaler.CustomMarshaler;
var cmName = cm == null ? string.Empty : FullNameCreator.AssemblyQualifiedName(cm, this);
Write(cmName);
Write(custMarshaler.Cookie);
break;
case NativeType.IUnknown:
case NativeType.IDispatch:
case NativeType.IntF:
var iface = (InterfaceMarshalType)marshalType;
if (iface.IsIidParamIndexValid)
{
WriteCompressedUInt32((uint)iface.IidParamIndex);
}
break;
case NativeType.RawBlob:
var data = ((RawMarshalType)marshalType).Data;
if (data != null)
{
writer.Write(data);
}
break;
default:
break;
}
writer.Flush();
return(outStream.ToArray());
}
public override string ToString()
{
return(FullNameCreator.MethodFullName("", Name, MethodSig));
}
static void AppendTypeName(StringBuilder b, TypeSig type)
{
if (type == null)
{
return;
}
if (type is GenericInstSig giType)
{
AppendTypeNameWithArguments(b, giType.GenericType == 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 != null)
{
AppendTypeName(b, typeRef.DeclaringType.ToTypeSig());
b.Append('.');
b.Append(typeRef.Name);
}
else
{
FullNameCreator.FullNameSB(type, false, null, null, null, b);
}
}
}
bool IFullNameCreatorHelper.MustUseAssemblyName(IType type)
{
return(FullNameCreator.MustUseAssemblyName(module, type));
}
