Пример #1
0
        /// <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);
        }
Пример #2
0
        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());
        }
Пример #3
0
        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));
     }
 }
Пример #6
0
 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);
     }
 }
Пример #7
0
        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);
        }
Пример #8
0
        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());
        }
Пример #9
0
 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);
         }
     }
 }
Пример #10
0
        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));
        }
Пример #11
0
        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);
        }
Пример #12
0
        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());
        }
Пример #13
0
        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);
                }
            }
        }
Пример #14
0
 public override string ToString() => FullNameCreator.MethodFullName("", Name, MethodSig);
Пример #15
0
        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());
        }
Пример #16
0
 public override string ToString()
 {
     return(FullNameCreator.MethodFullName(InterfaceType == null ? "" : FullNameCreator.FullName(InterfaceType, false), Name, MethodSig));
 }
Пример #17
0
 /// <inheritdoc/>
 public override string ToString()
 {
     return(FullNameCreator.PropertySigFullName(this));
 }
Пример #18
0
 /// <inheritdoc/>
 public override string ToString()
 {
     return(FullNameCreator.MethodSigFullName(this));
 }
Пример #19
0
 /// <inheritdoc/>
 public override string ToString()
 {
     return(FullNameCreator.FullName(type == null ? null : type, false));
 }
Пример #20
0
        /// <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;
            }
        }
Пример #21
0
        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());
        }
Пример #22
0
 public override string ToString()
 {
     return(FullNameCreator.MethodFullName("", Name, MethodSig));
 }
Пример #23
0
 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);
         }
     }
 }
Пример #24
0
 bool IFullNameCreatorHelper.MustUseAssemblyName(IType type)
 {
     return(FullNameCreator.MustUseAssemblyName(module, type));
 }