ResolveMember() public method

public ResolveMember ( int metadataToken ) : MemberInfo
metadataToken int
return MemberInfo
Esempio n. 1
0
        public static MemberInfo ResolveMember(Module module, int metadataToken)
        {
            Assumes.NotNull(module);
            Assumes.IsTrue(metadataToken != 0);

            return module.ResolveMember(metadataToken);
        }
Esempio n. 2
0
        /// <summary>
        /// Constructs the array of ILInstructions according to the IL byte code.
        /// </summary>
        /// <param name="module"></param>
        private void ConstructInstructions(Module module)
        {
            byte[] il = this.il;
            int position = 0;
            instructions = new List<ILInstruction>();
            while (position < il.Length)
            {
                ILInstruction instruction = new ILInstruction();

                // get the operation code of the current instruction
                OpCode code = OpCodes.Nop;
                ushort value = il[position++];
                if (value != 0xfe)
                {
                    code = Globals.singleByteOpCodes[(int)value];
                }
                else
                {
                    value = il[position++];
                    code = Globals.multiByteOpCodes[(int)value];
                    value = (ushort)(value | 0xfe00);
                }
                instruction.Code = code;
                instruction.Offset = position - 1;
                int metadataToken = 0;
                // get the operand of the current operation
                switch (code.OperandType)
                {
                    case OperandType.InlineBrTarget:
                        metadataToken = ReadInt32(il, ref position);
                        metadataToken += position;
                        instruction.Operand = metadataToken;
                        break;

                    // patched from comments on CP -hwd
                    case OperandType.InlineField:
                        metadataToken = ReadInt32(il, ref position);
                        if (mi is ConstructorInfo)
                        {
                            instruction.Operand = module.ResolveField(metadataToken,
                                mi.DeclaringType.GetGenericArguments(), null);
                        }
                        else
                        {
                            instruction.Operand = module.ResolveField(metadataToken,
                                mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                        }
                        break;

                    // patched from comments on CP -hwd
                    case OperandType.InlineMethod:
                        metadataToken = ReadInt32(il, ref position);
                        try
                        {
                            if (mi is ConstructorInfo)
                            {
                                instruction.Operand = module.ResolveMethod(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), null);
                            }
                            else
                            {
                                instruction.Operand = module.ResolveMethod(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                            }
                        }
                        catch
                        {
                            if (mi is ConstructorInfo)
                            {
                                instruction.Operand = module.ResolveMember(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), null);
                            }
                            else
                            {
                                instruction.Operand = module.ResolveMember(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                            }
                        }
                        break;

                    case OperandType.InlineSig:
                        metadataToken = ReadInt32(il, ref position);
                        instruction.Operand = module.ResolveSignature(metadataToken);
                        break;

                    // patched from comments on CP -hwd
                    case OperandType.InlineTok:
                        metadataToken = ReadInt32(il, ref position);
                        //try
                        //{
                            if (mi is ConstructorInfo)
                            {
                                instruction.Operand = module.ResolveType(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), null);
                            }
                            else
                            {
                                instruction.Operand = module.ResolveType(metadataToken,
                                    mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                            }
                        //}
                        //catch
                        //{
                        //    int i = 1;

                        //}
                        break;

                    // patched from comments on CP -hwd
                    case OperandType.InlineType:
                        metadataToken = ReadInt32(il, ref position);
                        if (this.mi is MethodInfo)
                        {
                            instruction.Operand = module.ResolveType(metadataToken,
                            this.mi.DeclaringType.GetGenericArguments(), this.mi.GetGenericArguments());
                        }
                        else if (mi is ConstructorInfo)
                        {
                            instruction.Operand = module.ResolveType(metadataToken,
                               this.mi.DeclaringType.GetGenericArguments(), null);
                        }
                        else
                        {
                            instruction.Operand = module.ResolveType(metadataToken);
                        }
                        break;

                    case OperandType.InlineI:
                        {
                            instruction.Operand = ReadInt32(il, ref position);
                            break;
                        }
                    case OperandType.InlineI8:
                        {
                            instruction.Operand = ReadInt64(il, ref position);
                            break;
                        }
                    case OperandType.InlineNone:
                        {
                            instruction.Operand = null;
                            break;
                        }
                    case OperandType.InlineR:
                        {
                            instruction.Operand = ReadDouble(il, ref position);
                            break;
                        }
                    case OperandType.InlineString:
                        {
                            metadataToken = ReadInt32(il, ref position);
                            instruction.Operand = module.ResolveString(metadataToken);
                            break;
                        }
                    case OperandType.InlineSwitch:
                        {
                            int count = ReadInt32(il, ref position);
                            int[] casesAddresses = new int[count];
                            for (int i = 0; i < count; i++)
                            {
                                casesAddresses[i] = ReadInt32(il, ref position);
                            }
                            int[] cases = new int[count];
                            for (int i = 0; i < count; i++)
                            {
                                cases[i] = position + casesAddresses[i];
                            }
                            break;
                        }
                    case OperandType.InlineVar:
                        {
                            instruction.Operand = ReadUInt16(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineBrTarget:
                        {
                            instruction.Operand = ReadSByte(il, ref position) + position;
                            break;
                        }
                    case OperandType.ShortInlineI:
                        {
                            instruction.Operand = ReadSByte(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineR:
                        {
                            instruction.Operand = ReadSingle(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineVar:
                        {
                            instruction.Operand = ReadByte(il, ref position);
                            break;
                        }
                    default:
                        {
                            throw new Exception("Unknown operand type.");
                        }
                }
                instructions.Add(instruction);
            }
        }
        /// <summary>
        /// Constructs the array of ILInstructions according to the IL byte code.
        /// </summary>
        /// <param name="module"></param>
        private void ConstructInstructions(Module module)
        {
            byte[] il = this.il;
            int position = 0;
            instructions = new List<ILInstruction>();
            while (position < il.Length)
            {
                ILInstruction instruction = new ILInstruction();

                // get the operation code of the current instruction
                OpCode code = OpCodes.Nop;
                ushort value = il[position++];
                if (value != 0xfe)
                {
                    code = Globals.singleByteOpCodes[(int)value];
                }
                else
                {
                    value = il[position++];
                    code = Globals.multiByteOpCodes[(int)value];
                    value = (ushort)(value | 0xfe00);
                }
                instruction.Code = code;
                instruction.Offset = position - 1;
                int metadataToken = 0;
                // get the operand of the current operation
                switch (code.OperandType)
                {
                    case OperandType.InlineBrTarget:
                        metadataToken = ReadInt32(il, ref position);
                        metadataToken += position;
                        instruction.Operand = metadataToken;
                        break;
                    case OperandType.InlineField:
                        metadataToken = ReadInt32(il, ref position);
                        instruction.Operand = module.ResolveField(metadataToken);
                        break;
                    case OperandType.InlineMethod:
                        metadataToken = ReadInt32(il, ref position);
                        try
                        {
                            instruction.Operand = module.ResolveMethod(metadataToken);
                        }
                        catch
                        {
                            try
                            {
                                instruction.Operand = module.ResolveMember(metadataToken);
                            }
                            catch (Exception)
                            {
                                //Try generic method
                                try
                                {
                                    instruction.Operand = module.ResolveMethod(metadataToken, mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                                }
                                catch (Exception)
                                {

                                    //Try generic member
                                    try
                                    {
                                        instruction.Operand = module.ResolveMember(metadataToken, mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
                                    }
                                    catch (Exception)
                                    {
                                        throw;
                                    }
                                }

                            }
                        }
                        break;
                    case OperandType.InlineSig:
                        metadataToken = ReadInt32(il, ref position);
                        instruction.Operand = module.ResolveSignature(metadataToken);
                        break;
                    case OperandType.InlineTok:
                        metadataToken = ReadInt32(il, ref position);
                        try
                        {
                            instruction.Operand = module.ResolveType(metadataToken);
                        }
                        catch
                        {

                        }
                        // SSS : see what to do here
                        break;
                     case OperandType.InlineType:
                        metadataToken = ReadInt32(il, ref position);
                        // now we call the ResolveType always using the generic attributes type in order
                        // to support decompilation of generic methods and classes

                        // thanks to the guys from code project who commented on this missing feature
                        try
                        {
                            instruction.Operand = module.ResolveType(metadataToken);
                        }
                        catch (Exception)
                        {
                            instruction.Operand = module.ResolveType(metadataToken, this.mi.DeclaringType.GetGenericArguments(), this.mi.GetGenericArguments());
                        }
                        break;
                    case OperandType.InlineI:
                        {
                            instruction.Operand = ReadInt32(il, ref position);
                            break;
                        }
                    case OperandType.InlineI8:
                        {
                            instruction.Operand = ReadInt64(il, ref position);
                            break;
                        }
                    case OperandType.InlineNone:
                        {
                            instruction.Operand = null;
                            break;
                        }
                    case OperandType.InlineR:
                        {
                            instruction.Operand = ReadDouble(il, ref position);
                            break;
                        }
                    case OperandType.InlineString:
                        {
                            metadataToken = ReadInt32(il, ref position);
                            instruction.Operand = module.ResolveString(metadataToken);
                            break;
                        }
                    case OperandType.InlineSwitch:
                        {
                            int count = ReadInt32(il, ref position);
                            int[] casesAddresses = new int[count];
                            for (int i = 0; i < count; i++)
                            {
                                casesAddresses[i] = ReadInt32(il, ref position);
                            }
                            int[] cases = new int[count];
                            for (int i = 0; i < count; i++)
                            {
                                cases[i] = position + casesAddresses[i];
                            }
                            break;
                        }
                    case OperandType.InlineVar:
                        {
                            instruction.Operand = ReadUInt16(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineBrTarget:
                        {
                            instruction.Operand = ReadSByte(il, ref position) + position;
                            break;
                        }
                    case OperandType.ShortInlineI:
                        {
                            instruction.Operand = ReadSByte(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineR:
                        {
                            instruction.Operand = ReadSingle(il, ref position);
                            break;
                        }
                    case OperandType.ShortInlineVar:
                        {
                            instruction.Operand = ReadByte(il, ref position);
                            break;
                        }
                    default:
                        {
                            throw new Exception("Unknown operand type.");
                        }
                }
                instructions.Add(instruction);
            }
        }
Esempio n. 4
0
        void CopyOpcode(byte[] Bytes, ref int i, ILGenerator Gen, Module Origin, List<int> ExceptionTrinkets, Dictionary<int, Label[]> LabelOrigins)
        {
            OpCode Code = GetOpcode(Bytes, ref i);

            // These are emitted by exception handling copier if an exception
            // block is imminent. If not, copy them as usual.
            if(Code == OpCodes.Leave && ExceptionTrinkets.Contains(i + 5))
            {
                i += 4;
                return;
            }
            else if(Code == OpCodes.Leave_S && ExceptionTrinkets.Contains(i + 2))
            {
                // This is a rather tricky one. See the comment preceding the call to MineLabels above.
                i++;
                return;
            }
            else if(Code == OpCodes.Endfinally && ExceptionTrinkets.Contains(i+1)) return;

            switch(Code.OperandType)
            {
                // If no argument, then re-emit the opcode
                case OperandType.InlineNone:
                {
                    Gen.Emit(Code);
                    break;
                }

                // If argument is a method, re-emit the method reference
                case OperandType.InlineMethod:
                {
                    int Token = BitHelper.ReadInteger(Bytes, ref i);
                    MethodBase Base = Origin.ResolveMethod(Token);

                    if(Base is MethodInfo)
                        Gen.Emit(Code, GrabMethod(Base as MethodInfo));
                    else if(Base is ConstructorInfo)
                        Gen.Emit(Code, GrabConstructor(Base as ConstructorInfo));
                    else throw new InvalidOperationException("Inline method is neither method nor constructor.");

                    break;
                }

                // Argument is a field reference
                case OperandType.InlineField:
                {
                    int Token = BitHelper.ReadInteger(Bytes, ref i);
                    FieldInfo Field = Origin.ResolveField(Token);
                    Gen.Emit(Code, GrabField(Field));
                    break;
                }

                // Argument is a type reference
                case OperandType.InlineType:
                {
                    int Token = BitHelper.ReadInteger(Bytes, ref i);
                    Type Ref = Origin.ResolveType(Token);
                    Gen.Emit(Code, GrabType(Ref));
                    break;
                }

                // Argument is an inline string
                case OperandType.InlineString:
                {
                    int Token = BitHelper.ReadInteger(Bytes, ref i);
                    string Copy = Origin.ResolveString(Token);
                    Gen.Emit(Code, Copy);
                    break;
                }

                // Argument is a metadata token
                case OperandType.InlineTok:
                {
                    int Token = BitHelper.ReadInteger(Bytes, ref i);
                    MemberInfo Info = Origin.ResolveMember(Token);

                    if(Info.MemberType == MemberTypes.Field)
                    {
                        if(Code != OpCodes.Ldtoken || !TryReplaceBackingField(Bytes, i, Gen, Origin))
                            Gen.Emit(Code, GrabField(Info as FieldInfo));
                    }
                    else if(Info.MemberType == MemberTypes.Method)
                        Gen.Emit(Code, GrabMethod(Info as MethodInfo));
                    else if(Info.MemberType == MemberTypes.TypeInfo || Info.MemberType == MemberTypes.NestedType)
                        Gen.Emit(Code, GrabType(Info as Type));
                    else throw new InvalidOperationException("Inline token is neither field, nor method, nor type");

                    break;
                }

                // Argument is a switch map
                case OperandType.InlineSwitch:
                {
                    if(!LabelOrigins.ContainsKey(i))
                        throw new Exception("No switchmap found for RVA "+i.ToString("X"));

                    Label[] Labels = LabelOrigins[i];
                    i += 4 + Labels.Length*4;
                    Gen.Emit(Code, Labels);

                    break;
                }

                // Argument is a single-byte branch target
                case OperandType.ShortInlineBrTarget:
                {
                    if(!LabelOrigins.ContainsKey(i))
                        throw new Exception("No label origin found for RVA "+i.ToString("X"));

                    Gen.Emit(Code, LabelOrigins[i][0]);
                    i++;

                    break;
                }

                // Argument is a byte
                case OperandType.ShortInlineI:
                case OperandType.ShortInlineVar:
                {
                    Gen.Emit(Code, Bytes[++i]);
                    break;
                }

                // Argument is a short
                case OperandType.InlineVar:
                {
                    Gen.Emit(Code, BitHelper.ReadShort(Bytes, ref i));
                    break;
                }

                case OperandType.InlineBrTarget:
                {
                    if(!LabelOrigins.ContainsKey(i))
                        throw new Exception("No label origin found for RVA "+i.ToString("X"));

                    Gen.Emit(Code, LabelOrigins[i][0]);
                    i += 4;

                    break;
                }

                // Argument is a 32-bit integer
                case OperandType.InlineI:
                case OperandType.ShortInlineR: // This is actually a 32-bit float, but we don't care
                {
                    Gen.Emit(Code, BitHelper.ReadInteger(Bytes, ref i));
                    break;
                }

                // Argument is a 64-bit integer
                case OperandType.InlineI8:
                {
                    Gen.Emit(Code, BitHelper.ReadLong(Bytes, ref i));
                    break;
                }

                // Argument is a 64-bit float
                case OperandType.InlineR:
                {
                    Gen.Emit(Code, BitHelper.ReadDouble(Bytes, ref i));
                    break;
                }

                // If ever we run across OpCodes.Calli this'll probably happen
                default:
                    throw new InvalidOperationException("The method copier ran across an unknown opcode.");
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Resolves all MetadataTokens present in <see cref="cgm"/> using the <see cref="manifestModule"/>
        /// </summary>
        /// <param name="cgm"></param>
        /// <param name="manifestModule"></param>
        /// <param name="memberInfoCache">
        /// Optional cache dictionary for use when this is being called within a loop, helps performance.
        /// </param>
        /// <param name="ignoreAssemblyFullNames">
        /// Optional list of fully-qualified assembly names whose members should NOT be added (e.g. mscorlib).
        /// </param>
        /// <param name="maxErrors">The max number of exceptions to be incurred before abandoning.</param>
        /// <returns>Count of errors encountered, will range from 0 to <see cref="maxErrors"/></returns>
        public static int ResolveCgMemberMetadataTokens(CgMember cgm, Module manifestModule,
            Dictionary<int, MemberInfo> memberInfoCache, string[] ignoreAssemblyFullNames, int maxErrors = 5)
        {
            if (cgm == null)
                return maxErrors;
            if (manifestModule == null)
                return maxErrors;

            var errorCount = 0;
            //for each method, get all invoked metadata tokens
            foreach (var metadataToken in cgm.opCodeCallsAndCallvirtsMetadatTokens)
            {
                try
                {
                    MemberInfo runtimeMem = null;
                    //resolve invoked metadata token to a member type
                    if (memberInfoCache != null && memberInfoCache.ContainsKey(metadataToken))
                    {
                        runtimeMem = memberInfoCache[metadataToken];
                    }
                    else
                    {
                        runtimeMem = manifestModule.ResolveMember(metadataToken);
                    }
                    if (runtimeMem == null)
                        continue;
                    var declaringType = runtimeMem.DeclaringType;
                    var declaringTypeAsmName = declaringType?.AssemblyQualifiedName;

                    if (string.IsNullOrWhiteSpace(declaringTypeAsmName))
                        continue;

                    if (ignoreAssemblyFullNames != null && ignoreAssemblyFullNames.Any(declaringTypeAsmName.EndsWith))
                        continue;

                    //add to cache for performance
                    if (memberInfoCache != null && !memberInfoCache.ContainsKey(metadataToken))
                        memberInfoCache.Add(metadataToken, runtimeMem);

                    var runtimeMi = runtimeMem as MethodInfo;
                    if (runtimeMi != null)
                    {
                        var ncgm = GetAsCgMember(runtimeMi, false);
                        if (ncgm == null)
                            continue;
                        ncgm.MetadataToken = metadataToken;
                        ncgm.DeclaringTypeAsmName = declaringTypeAsmName;

                        cgm.OpCodeCallAndCallvirts.Add(ncgm);
                        continue;
                    }

                    var runtimePi = runtimeMem as PropertyInfo;
                    if (runtimePi != null)
                    {
                        var ncgm = GetAsCgMember(runtimePi, false, null);
                        if (ncgm == null)
                            continue;

                        ncgm.MetadataToken = metadataToken;
                        ncgm.DeclaringTypeAsmName = declaringTypeAsmName;
                        cgm.OpCodeCallAndCallvirts.Add(ncgm);
                        continue;
                    }

                    var runtimeFi = runtimeMem as FieldInfo;
                    if (runtimeFi == null)
                        continue;

                    var fiCgm = GetAsCgMember(runtimeFi, false, null);
                    if (fiCgm == null)
                        continue;
                    fiCgm.MetadataToken = metadataToken;
                    fiCgm.DeclaringTypeAsmName = declaringTypeAsmName;
                    cgm.OpCodeCallAndCallvirts.Add(fiCgm);
                }
                catch
                {
                    errorCount += 1;
                    if (errorCount > maxErrors)
                        break;
                }
            }
            return errorCount;
        }
Esempio n. 6
0
        private static int _ReadOperand(MethodBase This, OpCode code, int position, byte[] il, Module module, ILInstruction instruction)
        {
            int metadataToken;

            switch (code.OperandType)
            {
            case OperandType.InlineBrTarget: {
                metadataToken       = ReadInt32(il, ref position);
                metadataToken      += position;
                instruction.Operand = metadataToken;
                break;
            }

            case OperandType.InlineField: {
                metadataToken       = ReadInt32(il, ref position);
                instruction.Operand = module.ResolveField(metadataToken);
                break;
            }

            case OperandType.InlineMethod: {
                metadataToken = ReadInt32(il, ref position);
                try {
                    instruction.Operand = module.ResolveMethod(metadataToken);
                } catch {
                    instruction.Operand = module.ResolveMember(metadataToken);
                }
                break;
            }

            case OperandType.InlineSig: {
                metadataToken       = ReadInt32(il, ref position);
                instruction.Operand = module.ResolveSignature(metadataToken);
                break;
            }

            case OperandType.InlineTok: {
                metadataToken = ReadInt32(il, ref position);
                try {
                    instruction.Operand = module.ResolveType(metadataToken);
                } catch { }
                // SSS : see what to do here
                break;
            }

            case OperandType.InlineType: {
                metadataToken = ReadInt32(il, ref position);
                // now we call the ResolveType always using the generic attributes type in order
                // to support decompilation of generic methods and classes

                // thanks to the guys from code project who commented on this missing feature

                instruction.Operand = module.ResolveType(metadataToken, This.DeclaringType.GetGenericArguments(), This.GetGenericArguments());
                break;
            }

            case OperandType.InlineI: {
                instruction.Operand = ReadInt32(il, ref position);
                break;
            }

            case OperandType.InlineI8: {
                instruction.Operand = ReadInt64(il, ref position);
                break;
            }

            case OperandType.InlineNone: {
                instruction.Operand = null;
                break;
            }

            case OperandType.InlineR: {
                instruction.Operand = ReadDouble(il, ref position);
                break;
            }

            case OperandType.InlineString: {
                metadataToken       = ReadInt32(il, ref position);
                instruction.Operand = module.ResolveString(metadataToken);
                break;
            }

            case OperandType.InlineSwitch: {
                var count          = ReadInt32(il, ref position);
                var casesAddresses = new int[count];
                for (var i = 0; i < count; i++)
                {
                    casesAddresses[i] = ReadInt32(il, ref position);
                }

                var cases = new int[count];
                for (var i = 0; i < count; i++)
                {
                    cases[i] = position + casesAddresses[i];
                }

                break;
            }

            case OperandType.InlineVar: {
                instruction.Operand = ReadUInt16(il, ref position);
                break;
            }

            case OperandType.ShortInlineBrTarget: {
                instruction.Operand = ReadSByte(il, ref position) + position;
                break;
            }

            case OperandType.ShortInlineI: {
                if (instruction.Code == OpCodes.Ldc_I4_S)
                {
                    instruction.Operand = ReadSByte(il, ref position);
                }
                else
                {
                    instruction.Operand = ReadByte(il, ref position);
                }
                break;
            }

            case OperandType.ShortInlineR: {
                instruction.Operand = ReadSingle(il, ref position);
                break;
            }

            case OperandType.ShortInlineVar: {
                instruction.Operand = ReadByte(il, ref position);
                break;
            }

            default: {
                throw new Exception("Unknown operand type.");
            }
            }
            return(position);
        }
Esempio n. 7
0
        private object ReadOperand(OpCode code, Module module, ref long localVariableIndex)
        {
            object operand = null;
            
            switch (code.OperandType)
            {
                case OperandType.InlineNone:
                    break;
                case OperandType.InlineSwitch:
                    int length = stream.ReadInt32();
                    int[] branches = new int[length];
                    int[] offsets = new int[length];
                    for (int i = 0; i < length; i++)
                    {
                        offsets[i] = stream.ReadInt32();
                    }
                    for (int i = 0; i < length; i++)
                    {
                        branches[i] = (int)stream.BaseStream.Position + offsets[i];
                    }

                    operand = (object) branches; // Just forget to save readed offsets
                    break;
                case OperandType.ShortInlineBrTarget:
                    if (code.FlowControl != FlowControl.Branch && code.FlowControl != FlowControl.Cond_Branch)
                    {
                        operand = stream.ReadSByte();
                    }
                    else
                    {
                        operand = stream.ReadSByte() + stream.BaseStream.Position;
                    }
                    break;
                case OperandType.InlineBrTarget:
                    operand = stream.ReadInt32()+ stream.BaseStream.Position;;
                    break;
                case OperandType.ShortInlineI:
                    if (code == OpCodes.Ldc_I4_S)
                        operand = (sbyte)stream.ReadByte();
                    else
                        operand = stream.ReadByte();
                    break;
                case OperandType.InlineI:
                    operand = stream.ReadInt32();
                    break;
                case OperandType.ShortInlineR:
                    operand = stream.ReadSingle();
                    break;
                case OperandType.InlineR:
                    operand = stream.ReadDouble();
                    break;
                case OperandType.InlineI8:
                    operand = stream.ReadInt64();
                    break;
                case OperandType.InlineSig:
                    operand = module.ResolveSignature(stream.ReadInt32());
                    break;
                case OperandType.InlineString:
                    operand = module.ResolveString(stream.ReadInt32());
                    break;
                case OperandType.InlineTok:
                case OperandType.InlineType:
                case OperandType.InlineMethod:
                case OperandType.InlineField:
                    operand = module.ResolveMember(stream.ReadInt32(), typeArgs, methodArgs);
                    break;
                case OperandType.ShortInlineVar:
                    {
                        int index = stream.ReadByte();
                        operand = GetVariable(code, index);
                        localVariableIndex = index;
                    }
                    break;
                case OperandType.InlineVar:
                    {
                        int index = stream.ReadUInt16();
                        operand = GetVariable(code, index);
                        localVariableIndex = index;
                    }
                    break;
                default:
                    throw new NotSupportedException();
            }

            return operand;
        }
Esempio n. 8
0
        /// <summary>
        /// Resolves the <see cref="tokenId"/>to a <see cref="MemberInfo"/> using
        /// the <see cref="manifestModule"/>
        /// </summary>
        /// <param name="manifestModule"></param>
        /// <param name="tokenId"></param>
        /// <param name="mi"></param>
        /// <param name="msgOut">Inteneded for debug trace from the Console.</param>
        /// <returns></returns>
        internal bool TryResolveRtMemberInfo(Module manifestModule, MetadataTokenId tokenId, out MemberInfo mi, StringBuilder msgOut)
        {
            mi = null;

            if (manifestModule == null)
                return false;
            try
            {
                mi = manifestModule.ResolveMember(tokenId.Id);
            }
            catch (SystemException)//does not resolve the token
            {
                if (msgOut != null)
                    msgOut.Append(", Message: 'manifest module could not resolve id'");
                return false;
            }
            return mi != null;
        }
Esempio n. 9
0
 private IMemberReference FindMemberRef(uint metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
 {
     return(AssemblyManager.FindMember(_netModule.ResolveMember((int)metadataToken, genericTypeArguments, genericMethodArguments)));
 }