コード例 #1
0
 private void WriteCustomAttributes(CilMethodDefinition methodDefinition)
 {
     foreach (var attribute in methodDefinition.CustomAttributes)
     {
         attribute.Accept(this);
     }
 }
コード例 #2
0
        private void WritePropertyOrEventAccessor(CilMethodDefinition accessor)
        {
            int           i = 0;
            StringBuilder genericParameters = new StringBuilder();

            foreach (var genericParameter in accessor.GenericParameters)
            {
                if (i == 0)
                {
                    genericParameters.Append('<');
                }
                genericParameters.Append(genericParameter);
                genericParameters.Append(',');
                i++;
            }

            if (i > 0)
            {
                genericParameters.Length -= 1; //Delete trailing ,
                genericParameters.Append('>');
            }

            if (accessor.Signature.Header.IsInstance)
            {
                _writer.Write("instance ");
            }
            _writer.Write(string.Format("{0} {1}::{2}{3}{4}", accessor.Signature.ReturnType, accessor.DeclaringType.FullName, accessor.Name, genericParameters.ToString(), CilDecoder.DecodeSignatureParamerTypes(accessor.Signature)));
            _writer.WriteLine();
        }
コード例 #3
0
        private void WriteLocals(CilMethodDefinition methodDefinition)
        {
            WriteIndentation();
            _writer.Write(".locals");

            if (methodDefinition.LocalVariablesInitialized)
            {
                _writer.Write(" init");
            }

            int i      = 0;
            var locals = methodDefinition.Locals;

            _writer.Write('(');
            foreach (var local in locals)
            {
                if (i > 0)
                {
                    WriteIndentation();
                    _writer.Write(string.Format("{0,13}", ""));
                }
                _writer.Write(string.Format("[{0}] ", i));
                local.Accept(this);
                if (i < locals.Length - 1)
                {
                    _writer.WriteLine(',');
                }
                i++;
            }
            _writer.WriteLine(')');
        }
コード例 #4
0
 private void WriteMethodDefinition(CilMethodDefinition methodDefinition)
 {
     WriteIndentation();
     _writer.Write(".method ");
     if (_options.ShowBytes)
     {
         _writer.Write(string.Format("/* {0:X8} */ ", methodDefinition.Token));
     }
     _writer.WriteLine(methodDefinition.GetDecodedSignature());
     WriteIndentation();
     _writer.WriteLine('{');
 }
コード例 #5
0
 private static string GetVariableName(OpCode opCode, int token, CilMethodDefinition methodDefinition)
 {
     if (HasArgument(opCode))
     {
         if (methodDefinition.Signature.Header.IsInstance)
         {
             token--; //the first parameter is "this".
         }
         return(methodDefinition.GetParameter(token).Name);
     }
     return(methodDefinition.GetLocal(token).Name);
 }
コード例 #6
0
        private int WriteMethodBody(CilMethodDefinition methodDefinition, IReadOnlyList <CilExceptionRegion> exceptionRegions, ref int instructionIndex, int ilOffset, int regionIndex, out int nextRegionIndex)
        {
            int lastRegionIndex = regionIndex - 1;
            var instructions    = methodDefinition.Instructions;

            for (; instructionIndex < instructions.Length; instructionIndex++)
            {
                var instruction = instructions[instructionIndex];
                if (EndFilterRegion(exceptionRegions, lastRegionIndex, ilOffset))
                {
                    Unindent();
                    WriteIndentation();
                    _writer.WriteLine("} // end filter");
                    WriteIndentation();
                    _writer.WriteLine("{ // handler");
                    Indent();
                }

                if (StartRegion(exceptionRegions, regionIndex, ilOffset))
                {
                    var region = exceptionRegions[regionIndex];
                    WriteIndentation();
                    _writer.WriteLine(region.ToString(methodDefinition.Provider));
                    WriteIndentation();
                    _writer.WriteLine('{');
                    Indent();
                    ilOffset = WriteMethodBody(methodDefinition, exceptionRegions, ref instructionIndex, ilOffset, regionIndex + 1, out regionIndex);
                    Unindent();
                    WriteIndentation();
                    _writer.Write('}');
                    _writer.WriteLine(string.Format(" // end {0}", (region.Kind == HandlerKind.Try ? ".try" : "handler")));
                }

                else
                {
                    WriteIndentation();
                    _writer.Write(string.Format("IL_{0:x4}:", ilOffset));
                    _writer.Write(_indent);
                    instruction.Accept(this);
                    ilOffset += instruction.Size;
                }

                if (EndRegion(exceptionRegions, lastRegionIndex, ilOffset))
                {
                    break;
                }
            }

            nextRegionIndex = regionIndex;
            return(ilOffset);
        }
コード例 #7
0
        public void Visit(CilMethodDefinition methodDefinition)
        {
            WriteMethodDefinition(methodDefinition);
            Indent();
            WriteMethodHeader(methodDefinition);
            int ilOffset         = 0;
            int instructionIndex = 0;
            int lastRegionIndex  = 0;

            if (methodDefinition.RelativeVirtualAddress != 0)
            {
                WriteMethodBody(methodDefinition, methodDefinition.ExceptionRegions, ref instructionIndex, ilOffset, lastRegionIndex, out lastRegionIndex);
            }
            Unindent();
            WriteIndentation();
            _writer.Write('}');
            _writer.WriteLine(string.Format(" // end of method {0}", methodDefinition.Name));
            _writer.WriteLine();
        }
コード例 #8
0
        private void WriteMethodHeader(CilMethodDefinition methodDefinition)
        {
            WriteCustomAttributes(methodDefinition);
            if (methodDefinition.RelativeVirtualAddress == 0)
            {
                return;
            }

            foreach (var parameter in methodDefinition.GetOptionalParameters())
            {
                WriteIndentation();
                _writer.Write(".param ");
                _writer.WriteLine(string.Format("[{0}] = {1}", parameter.SequenceNumber, parameter.DefaultValue.GetValueString()));
            }

            if (methodDefinition.IsImplementation)
            {
                WriteOverridenMethod(methodDefinition);
            }

            if (methodDefinition.IsEntryPoint)
            {
                WriteIndentation();
                _writer.WriteLine(".entrypoint");
            }

            WriteIndentation();
            _writer.WriteLine(string.Format("// code size {0,8} (0x{0:x})", methodDefinition.Size));
            WriteIndentation();
            _writer.WriteLine(string.Format(".maxstack {0,2}", methodDefinition.MaxStack));

            if (methodDefinition.HasLocals)
            {
                WriteLocals(methodDefinition);
            }
        }
コード例 #9
0
        private void WriteOverridenMethod(CilMethodDefinition methodDefinition)
        {
            WriteIndentation();
            _writer.Write(".override ");
            int token = methodDefinition.MethodDeclarationToken;

            if (CilDecoder.IsMemberReference(token))
            {
                _writer.Write("method ");
                _writer.Write(CilDecoder.SolveMethodName(methodDefinition._readers.MdReader, token, methodDefinition.Provider));
                if (_options.ShowBytes)
                {
                    _writer.Write(string.Format(" /* {0:X8} */", token));
                }
                _writer.WriteLine();
                return;
            }
            _writer.Write(CilDecoder.DecodeOverridenMethodName(methodDefinition._readers.MdReader, token, methodDefinition.Provider));
            if (_options.ShowBytes)
            {
                _writer.Write(string.Format(" /* {0:X8} */", token));
            }
            _writer.WriteLine();
        }
コード例 #10
0
ファイル: CilDecoder.cs プロジェクト: TerabyteX/corefxlab
 public static IEnumerable<CilInstruction> DecodeMethodBody(CilMethodDefinition methodDefinition)
 {
     return DecodeMethodBody(methodDefinition.IlReader, methodDefinition._readers.MdReader, methodDefinition.Provider, methodDefinition);
 }
コード例 #11
0
ファイル: CilDecoder.cs プロジェクト: TerabyteX/corefxlab
 private static string GetVariableName(OpCode opCode, int token, CilMethodDefinition methodDefinition)
 {
     if (HasArgument(opCode))
     {
         if (methodDefinition.Signature.Header.IsInstance)
         {
             token--; //the first parameter is "this".
         }
         return methodDefinition.GetParameter(token).Name;
     }
     return methodDefinition.GetLocal(token).Name;
     
 }
コード例 #12
0
 public void Visit(CilMethodDefinition methodDefinition)
 {
     WriteMethodDefinition(methodDefinition);
     Indent();
     WriteMethodHeader(methodDefinition);
     int ilOffset = 0;
     int instructionIndex = 0;
     int lastRegionIndex = 0;
     if (methodDefinition.RelativeVirtualAddress != 0)
         WriteMethodBody(methodDefinition, methodDefinition.ExceptionRegions, ref instructionIndex, ilOffset, lastRegionIndex, out lastRegionIndex);
     Unindent();
     WriteIndentation();
     _writer.Write('}');
     _writer.WriteLine(string.Format(" // end of method {0}", methodDefinition.Name));
     _writer.WriteLine();
 }
コード例 #13
0
 internal static IEnumerable <string> DecodeGenericParameters(MethodDefinition methodDefinition, CilMethodDefinition method)
 {
     foreach (var handle in methodDefinition.GetGenericParameters())
     {
         var parameter = method._readers.MdReader.GetGenericParameter(handle);
         yield return(method._readers.MdReader.GetString(parameter.Name));
     }
 }
コード例 #14
0
        private static IEnumerable <CilInstruction> DecodeMethodBody(BlobReader ilReader, MetadataReader metadataReader, CilTypeProvider provider, CilMethodDefinition methodDefinition)
        {
            ilReader.Reset();
            int            intOperand;
            ushort         shortOperand;
            int            ilOffset    = 0;
            CilInstruction instruction = null;

            while (ilReader.Offset < ilReader.Length)
            {
                OpCode opCode;
                int    expectedSize;
                byte   _byte = ilReader.ReadByte();

                /*If the byte read is 0xfe it means is a two byte instruction,
                 * so since it is going to read the second byte to get the actual
                 * instruction it has to check that the offset is still less than the length.*/
                if (_byte == 0xfe && ilReader.Offset < ilReader.Length)
                {
                    opCode       = CilDecoderHelpers.Instance.twoByteOpCodes[ilReader.ReadByte()];
                    expectedSize = 2;
                }
                else
                {
                    opCode       = CilDecoderHelpers.Instance.oneByteOpCodes[_byte];
                    expectedSize = 1;
                }
                switch (opCode.OperandType)
                {
                //The instruction size is the expected size (1 or 2 depending if it is a one or two byte instruction) + the size of the operand.
                case OperandType.InlineField:
                    intOperand = ilReader.ReadInt32();
                    string fieldInfo = GetFieldInformation(metadataReader, intOperand, provider);
                    instruction = new CilStringInstruction(opCode, fieldInfo, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.InlineString:
                    intOperand = ilReader.ReadInt32();
                    bool   isPrintable;
                    string str = GetArgumentString(metadataReader, intOperand, out isPrintable);
                    instruction = new CilStringInstruction(opCode, str, intOperand, expectedSize + (int)CilInstructionSize.Int32, isPrintable);
                    break;

                case OperandType.InlineMethod:
                    intOperand = ilReader.ReadInt32();
                    string methodCall = SolveMethodName(metadataReader, intOperand, provider);
                    instruction = new CilStringInstruction(opCode, methodCall, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.InlineType:
                    intOperand = ilReader.ReadInt32();
                    string type = GetTypeInformation(metadataReader, intOperand, provider);
                    instruction = new CilStringInstruction(opCode, type, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.InlineTok:
                    intOperand = ilReader.ReadInt32();
                    string tokenType = GetInlineTokenType(metadataReader, intOperand, provider);
                    instruction = new CilStringInstruction(opCode, tokenType, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.InlineI:
                    instruction = new CilInt32Instruction(opCode, ilReader.ReadInt32(), -1, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.InlineI8:
                    instruction = new CilInt64Instruction(opCode, ilReader.ReadInt64(), -1, expectedSize + (int)CilInstructionSize.Int64);
                    break;

                case OperandType.InlineR:
                    instruction = new CilDoubleInstruction(opCode, ilReader.ReadDouble(), -1, expectedSize + (int)CilInstructionSize.Double);
                    break;

                case OperandType.InlineSwitch:
                    instruction = CreateSwitchInstruction(ref ilReader, expectedSize, ilOffset, opCode);
                    break;

                case OperandType.ShortInlineBrTarget:
                    instruction = new CilInt16BranchInstruction(opCode, ilReader.ReadSByte(), ilOffset, expectedSize + (int)CilInstructionSize.Byte);
                    break;

                case OperandType.InlineBrTarget:
                    instruction = new CilBranchInstruction(opCode, ilReader.ReadInt32(), ilOffset, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                case OperandType.ShortInlineI:
                    instruction = new CilByteInstruction(opCode, ilReader.ReadByte(), -1, expectedSize + (int)CilInstructionSize.Byte);
                    break;

                case OperandType.ShortInlineR:
                    instruction = new CilSingleInstruction(opCode, ilReader.ReadSingle(), -1, expectedSize + (int)CilInstructionSize.Single);
                    break;

                case OperandType.InlineNone:
                    instruction = new CilInstructionWithNoValue(opCode, expectedSize);
                    break;

                case OperandType.ShortInlineVar:
                    byte token = ilReader.ReadByte();
                    instruction = new CilInt16VariableInstruction(opCode, GetVariableName(opCode, token, methodDefinition), token, expectedSize + (int)CilInstructionSize.Byte);
                    break;

                case OperandType.InlineVar:
                    shortOperand = ilReader.ReadUInt16();
                    instruction  = new CilVariableInstruction(opCode, GetVariableName(opCode, shortOperand, methodDefinition), shortOperand, expectedSize + (int)CilInstructionSize.Int16);
                    break;

                case OperandType.InlineSig:
                    intOperand  = ilReader.ReadInt32();
                    instruction = new CilStringInstruction(opCode, GetSignature(metadataReader, intOperand, provider), intOperand, expectedSize + (int)CilInstructionSize.Int32);
                    break;

                default:
                    break;
                }
                ilOffset += instruction.Size;
                yield return(instruction);
            }
        }
コード例 #15
0
 public static IEnumerable <CilInstruction> DecodeMethodBody(CilMethodDefinition methodDefinition)
 {
     return(DecodeMethodBody(methodDefinition.IlReader, methodDefinition._readers.MdReader, methodDefinition.Provider, methodDefinition));
 }
コード例 #16
0
ファイル: CilDecoder.cs プロジェクト: TerabyteX/corefxlab
 internal static IEnumerable<string> DecodeGenericParameters(MethodDefinition methodDefinition, CilMethodDefinition method)
 {
     int count = method.Signature.GenericParameterCount;
     foreach (var handle in methodDefinition.GetGenericParameters())
     {
         var parameter = method._readers.MdReader.GetGenericParameter(handle);
         yield return method._readers.MdReader.GetString(parameter.Name);
     }
 }
コード例 #17
0
 private void WriteCustomAttributes(CilMethodDefinition methodDefinition)
 {
     foreach (var attribute in methodDefinition.CustomAttributes)
     {
         attribute.Accept(this);
     }
 }
コード例 #18
0
 private void WriteOverridenMethod(CilMethodDefinition methodDefinition)
 {
     WriteIndentation();
     _writer.Write(".override ");
     int token = methodDefinition.MethodDeclarationToken;
     if (CilDecoder.IsMemberReference(token))
     {
         _writer.Write("method ");
         _writer.Write(CilDecoder.SolveMethodName(methodDefinition._readers.MdReader, token, methodDefinition.Provider));
         if (_options.ShowBytes)
             _writer.Write(string.Format(" /* {0:X8} */", token));
         _writer.WriteLine();
         return;
     }
     _writer.Write(CilDecoder.DecodeOverridenMethodName(methodDefinition._readers.MdReader, token, methodDefinition.Provider));
     if (_options.ShowBytes)
         _writer.Write(string.Format(" /* {0:X8} */", token));
     _writer.WriteLine();
 }
コード例 #19
0
        private void WriteLocals(CilMethodDefinition methodDefinition)
        {
            WriteIndentation();
            _writer.Write(".locals");

            if (methodDefinition.LocalVariablesInitialized)
            {
                _writer.Write(" init");
            }

            int i = 0;
            var locals = methodDefinition.Locals;
            _writer.Write('(');
            foreach (var local in locals)
            {
                if (i > 0)
                {
                    WriteIndentation();
                    _writer.Write(string.Format("{0,13}", ""));
                }
                _writer.Write(string.Format("[{0}] ", i));
                local.Accept(this);
                if (i < locals.Length - 1)
                {
                    _writer.WriteLine(',');
                }
                i++;
            }
            _writer.WriteLine(')');
        }
コード例 #20
0
        private void WriteMethodHeader(CilMethodDefinition methodDefinition)
        {
            WriteCustomAttributes(methodDefinition);
            if (methodDefinition.RelativeVirtualAddress == 0)
            {
                return;
            }
            
            foreach(var parameter in methodDefinition.GetOptionalParameters())
            {
                WriteIndentation();
                _writer.Write(".param ");
                _writer.WriteLine(string.Format("[{0}] = {1}", parameter.SequenceNumber, parameter.DefaultValue.GetValueString()));
            }

            if (methodDefinition.IsImplementation)
            {
                WriteOverridenMethod(methodDefinition);
            }

            if (methodDefinition.IsEntryPoint)
            {
                WriteIndentation();
                _writer.WriteLine(".entrypoint");
            }

            WriteIndentation();
            _writer.WriteLine(string.Format("// code size {0,8} (0x{0:x})", methodDefinition.Size));
            WriteIndentation();
            _writer.WriteLine(string.Format(".maxstack {0,2}", methodDefinition.MaxStack));

            if (methodDefinition.HasLocals)
            {
                WriteLocals(methodDefinition);
            }
        }
コード例 #21
0
 private void WriteMethodDefinition(CilMethodDefinition methodDefinition)
 {
     WriteIndentation();
     _writer.Write(".method ");
     if (_options.ShowBytes)
         _writer.Write(string.Format("/* {0:X8} */ ", methodDefinition.Token));
     _writer.WriteLine(methodDefinition.GetDecodedSignature());
     WriteIndentation();
     _writer.WriteLine('{');
 }
コード例 #22
0
        private int WriteMethodBody(CilMethodDefinition methodDefinition, IReadOnlyList<CilExceptionRegion> exceptionRegions, ref int instructionIndex, int ilOffset, int regionIndex, out int nextRegionIndex)
        {
            int lastRegionIndex = regionIndex - 1;
            var instructions = methodDefinition.Instructions;
            for (; instructionIndex < instructions.Length; instructionIndex++)
            {
                var instruction = instructions[instructionIndex];
                if (EndFilterRegion(exceptionRegions, lastRegionIndex, ilOffset))
                {
                    Unindent();
                    WriteIndentation();
                    _writer.WriteLine("} // end filter");
                    WriteIndentation();
                    _writer.WriteLine("{ // handler");
                    Indent();
                }

                if (StartRegion(exceptionRegions, regionIndex, ilOffset))
                {
                    var region = exceptionRegions[regionIndex];
                    WriteIndentation();
                    _writer.WriteLine(region.ToString(methodDefinition.Provider));
                    WriteIndentation();
                    _writer.WriteLine('{');
                    Indent();
                    ilOffset = WriteMethodBody(methodDefinition, exceptionRegions, ref instructionIndex, ilOffset, regionIndex + 1, out regionIndex);
                    Unindent();
                    WriteIndentation();
                    _writer.Write('}');
                    _writer.WriteLine(string.Format(" // end {0}", (region.Kind == HandlerKind.Try ? ".try" : "handler")));
                }

                else
                {
                    WriteIndentation();
                    _writer.Write(string.Format("IL_{0:x4}:", ilOffset));
                    _writer.Write(_indent);
                    instruction.Accept(this);
                    ilOffset += instruction.Size;
                }

                if (EndRegion(exceptionRegions, lastRegionIndex, ilOffset))
                {
                    break;
                }
            }

            nextRegionIndex = regionIndex;
            return ilOffset;
        }
コード例 #23
0
ファイル: CilDecoder.cs プロジェクト: TerabyteX/corefxlab
 private static IEnumerable<CilInstruction> DecodeMethodBody(BlobReader ilReader, MetadataReader metadataReader, CilTypeProvider provider, CilMethodDefinition methodDefinition)
 {
     ilReader.Reset();
     int intOperand;
     ushort shortOperand;
     int ilOffset = 0;
     CilInstruction instruction = null;
     while (ilReader.Offset < ilReader.Length)
     {
         OpCode opCode;
         int expectedSize;
         byte _byte = ilReader.ReadByte();
         /*If the byte read is 0xfe it means is a two byte instruction, 
         so since it is going to read the second byte to get the actual
         instruction it has to check that the offset is still less than the length.*/
         if (_byte == 0xfe && ilReader.Offset < ilReader.Length)
         {
             opCode = CilDecoderHelpers.Instance.twoByteOpCodes[ilReader.ReadByte()];
             expectedSize = 2;
         }
         else
         {
             opCode = CilDecoderHelpers.Instance.oneByteOpCodes[_byte];
             expectedSize = 1;
         }
         switch (opCode.OperandType)
         {
             //The instruction size is the expected size (1 or 2 depending if it is a one or two byte instruction) + the size of the operand.
             case OperandType.InlineField:
                 intOperand = ilReader.ReadInt32();
                 string fieldInfo = GetFieldInformation(metadataReader, intOperand, provider);
                 instruction = new CilStringInstruction(opCode, fieldInfo, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.InlineString:
                 intOperand = ilReader.ReadInt32();
                 bool isPrintable;
                 string str = GetArgumentString(metadataReader, intOperand, out isPrintable);
                 instruction = new CilStringInstruction(opCode, str, intOperand, expectedSize + (int)CilInstructionSize.Int32, isPrintable);
                 break;
             case OperandType.InlineMethod:
                 intOperand = ilReader.ReadInt32();
                 string methodCall = SolveMethodName(metadataReader, intOperand, provider);
                 instruction = new CilStringInstruction(opCode, methodCall, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.InlineType:
                 intOperand = ilReader.ReadInt32();
                 string type = GetTypeInformation(metadataReader, intOperand, provider);
                 instruction = new CilStringInstruction(opCode, type, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.InlineTok:
                 intOperand = ilReader.ReadInt32();
                 string tokenType = GetInlineTokenType(metadataReader, intOperand, provider);
                 instruction = new CilStringInstruction(opCode, tokenType, intOperand, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.InlineI:
                 instruction = new CilInt32Instruction(opCode, ilReader.ReadInt32(), -1, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.InlineI8:
                 instruction = new CilInt64Instruction(opCode, ilReader.ReadInt64(), -1, expectedSize + (int)CilInstructionSize.Int64);
                 break;
             case OperandType.InlineR:
                 instruction = new CilDoubleInstruction(opCode, ilReader.ReadDouble(), -1, expectedSize + (int)CilInstructionSize.Double);
                 break;
             case OperandType.InlineSwitch:
                 instruction = CreateSwitchInstruction(ref ilReader, expectedSize, ilOffset, opCode);
                 break;
             case OperandType.ShortInlineBrTarget:
                 instruction = new CilInt16BranchInstruction(opCode, ilReader.ReadSByte(), ilOffset, expectedSize + (int)CilInstructionSize.Byte);
                 break;
             case OperandType.InlineBrTarget:
                 instruction = new CilBranchInstruction(opCode, ilReader.ReadInt32(), ilOffset, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             case OperandType.ShortInlineI:
                 instruction = new CilByteInstruction(opCode, ilReader.ReadByte(), -1, expectedSize + (int)CilInstructionSize.Byte);
                 break;
             case OperandType.ShortInlineR:
                 instruction = new CilSingleInstruction(opCode, ilReader.ReadSingle(), -1, expectedSize + (int)CilInstructionSize.Single);
                 break;
             case OperandType.InlineNone:
                 instruction = new CilInstructionWithNoValue(opCode, expectedSize);
                 break;
             case OperandType.ShortInlineVar:
                 byte token = ilReader.ReadByte();
                 instruction = new CilInt16VariableInstruction(opCode, GetVariableName(opCode, token, methodDefinition), token, expectedSize + (int)CilInstructionSize.Byte);
                 break;
             case OperandType.InlineVar:
                 shortOperand = ilReader.ReadUInt16();
                 instruction = new CilVariableInstruction(opCode, GetVariableName(opCode, shortOperand, methodDefinition), shortOperand, expectedSize + (int)CilInstructionSize.Int16);
                 break;
             case OperandType.InlineSig:
                 intOperand = ilReader.ReadInt32();
                 instruction = new CilStringInstruction(opCode, GetSignature(metadataReader, intOperand, provider), intOperand, expectedSize + (int)CilInstructionSize.Int32);
                 break;
             default:
                 break;
         }
         ilOffset += instruction.Size;
         yield return instruction;
     }
 }
コード例 #24
0
        private void WritePropertyOrEventAccessor(CilMethodDefinition accessor)
        {
            int i = 0;
            StringBuilder genericParameters = new StringBuilder();
            foreach (var genericParameter in accessor.GenericParameters)
            {
                if (i == 0)
                {
                    genericParameters.Append('<');
                }
                genericParameters.Append(genericParameter);
                genericParameters.Append(',');
                i++;
            }

            if (i > 0)
            {
                genericParameters.Length -= 1; //Delete trailing ,
                genericParameters.Append('>');
            }

            if (accessor.Signature.Header.IsInstance)
            {
                _writer.Write("instance ");
            }
            _writer.Write(string.Format("{0} {1}::{2}{3}{4}", accessor.Signature.ReturnType, accessor.DeclaringType.FullName, accessor.Name, genericParameters.ToString(), CilDecoder.DecodeSignatureParamerTypes(accessor.Signature)));
            _writer.WriteLine();
        }
コード例 #25
0
 public MethodNode(CilMethodDefinition methodDef)
 {
     _methodDef = methodDef;
 }