C# MethodEntry.GetLineNumberTable方法代码示例

		void ReadLineNumbers (MethodEntry entry, IDictionary instructions)
		{
			LineNumberTable lnt = entry.GetLineNumberTable ();
			foreach (LineNumberEntry line in lnt.LineNumbers) {
				Instruction instr = instructions [line.Offset] as Instruction;
				if (instr == null)
					continue;

				Document doc = GetDocument (entry.CompileUnit.SourceFile);
				instr.SequencePoint = new SequencePoint (doc);
				instr.SequencePoint.StartLine = line.Row;
				instr.SequencePoint.EndLine = line.Row;
			}
		}

		private void ReadLineNumbers(MethodEntry entry, InstructionMapper mapper)
		{
			Document document = null;
			LineNumberTable table = entry.GetLineNumberTable();
			LineNumberEntry[] lineNumbers = table.LineNumbers;
			for (int i = 0; i < lineNumbers.Length; i++)
			{
				LineNumberEntry line = lineNumbers[i];
				Instruction instruction = mapper(line.Offset);
				if (instruction != null)
				{
					if (document == null)
					{
						document = this.GetDocument(entry.CompileUnit.SourceFile);
					}
					instruction.SequencePoint = new SequencePoint(document)
					{
						StartLine = line.Row,
						EndLine = line.Row
					};
				}
			}
		}

		void ReadLineNumbers (MethodEntry entry, InstructionMapper mapper)
		{
			Document document = null;
			var table = entry.GetLineNumberTable ();

			foreach (var line in table.LineNumbers) {
				var instruction = mapper (line.Offset);
				if (instruction == null)
					continue;

				if (document == null)
					document = GetDocument (entry.CompileUnit.SourceFile);

				instruction.SequencePoint = new SequencePoint (document) {
					StartLine = line.Row,
					EndLine = line.Row,
				};
			}
		}

	private void ProcessMethod (MethodDefinition monoMethod, MethodEntry entry, ClassCoverageItem klass, string methodName, string cov_info)
#endif
	{
		if (entry == null)
			// Compiler generated, abstract method etc.
			return;

		LineNumberEntry[] lines = entry.GetLineNumberTable ().LineNumbers;

		if (lines.Length == 0)
			return;

		int start_line = lines [0].Row;
		int end_line = lines [lines.Length - 1].Row;

		MethodCoverageItem method 
			= new MethodCoverageItem (klass, methodName);

		method.startLine = start_line;
		method.endLine = end_line;
#if USE_REFLECTION
		method.filtered = IsFiltered ("[" + monoMethod.DeclaringType.Assembly + "]" + monoMethod.DeclaringType + "::" + monoMethod.Name);
#else
		method.filtered = IsFiltered ("[" + monoMethod.DeclaringType.Module.Name + "]" + monoMethod.DeclaringType + "::" + monoMethod.Name);
#endif
		klass.methodsByMethod [monoMethod] = method;


		if (klass.sourceFile == null) {
			string sourceFile = entry.CompileUnit.SourceFile.FileName;

			SourceFileCoverageData source = (SourceFileCoverageData)sources [sourceFile];
			if (source == null) {
				source = new SourceFileCoverageData (sourceFile);
				sources [sourceFile] = source;
			}
			klass.sourceFile = source;
		}
			
		computeMethodCoverage (method, lines, cov_info);
	}

        void ReadLineNumbers(MethodEntry entry, MethodDebugInformation info)
        {
            var table = entry.GetLineNumberTable ();

            info.sequence_points = new Collection<SequencePoint> (table.LineNumbers.Length);

            for (var i = 0; i < table.LineNumbers.Length; i++) {
                var line = table.LineNumbers [i];
                if (i > 0 && table.LineNumbers [i - 1].Offset == line.Offset)
                    continue;

                info.sequence_points.Add (LineToSequencePoint (line));
            }
        }

            public MonoMethodSource(MonoSymbolFile file, SourceFile source_file,
						 C.MethodEntry method, Cecil.MethodDefinition mdef,
						 MonoClassType klass, MonoFunctionType function)
            {
                this.file = file;
                this.source_file = source_file;
                this.method = method;
                this.mdef = mdef;
                this.function = function;
                this.klass = klass;

                full_name = method.GetRealName ();
                if (full_name == null)
                    full_name = MonoSymbolFile.GetMethodName (mdef);

                C.LineNumberEntry start, end;
                C.LineNumberTable lnt = method.GetLineNumberTable ();
                if (lnt.GetMethodBounds (out start, out end))
                    start_row = start.Row; end_row = end.Row;
            }

        protected void CheckMethod(MethodEntry method)
        {
            Cecil.MethodDefinition mdef = (Cecil.MethodDefinition) Assembly.MainModule.LookupByToken (
                Cecil.Metadata.TokenType.Method, method.Token & 0xffffff);
            if ((mdef == null) || (mdef.Body == null))
                throw new MonoSymbolFileException ("Method {0} (token {1:x}) not found in assembly.",
                                   method.Index, method.Token);

            string name = String.Format ("{0} ({1})", method.Index, GetMethodName (mdef));
            Debug ("[Method {0} - {1} - {2}]", method.Index, method.CompileUnit.SourceFile.FileName,
                   GetMethodName (mdef));

            LineNumberTable lnt = method.GetLineNumberTable ();
            if (lnt == null)
                throw new MonoSymbolFileException ("Cannot get LNT from method {0}.", name);

            if (lnt.LineNumbers == null)
                throw new MonoSymbolFileException ("Cannot get LNT from method {0}.", name);
            LineNumberEntry start, end;
            if (lnt.GetMethodBounds (out start, out end))
                Debug ("  Bounds: {0} {1}", start, end);
            foreach (LineNumberEntry line in lnt.LineNumbers)
                Debug ("    Line: {0}", line);

            CodeBlockEntry[] blocks = method.GetCodeBlocks () ?? new CodeBlockEntry [0];
            foreach (CodeBlockEntry block in blocks) {
                if ((block.Parent >= 0) && (block.Parent >= blocks.Length))
                    throw new MonoSymbolFileException (
                        "Code block {0} in method {1} has invalid parent index {2} (valid is 0..{3}).",
                        block, name, block.Parent, blocks.Length);
            }

            LocalVariableEntry[] locals = method.GetLocals () ?? new LocalVariableEntry [0];
            foreach (LocalVariableEntry local in locals) {
                if ((local.BlockIndex < 0) || ((local.BlockIndex > 0) && (local.BlockIndex > blocks.Length)))
                    throw new MonoSymbolFileException (
                        "Local variable {0} in method {1} has invalid block index {2} (valid is 0..{3}).",
                        local, name, local.BlockIndex, blocks.Length);

                Debug ("  Local: {0}", local);
            }

            int num_locals = mdef.Body.Variables.Count;

            ScopeVariable[] scope_vars = method.GetScopeVariables () ?? new ScopeVariable [0];
            foreach (ScopeVariable var in scope_vars) {
                Debug ("  Scope var: {0}", var);
                if ((mdef.IsStatic) && (var.Index < 0))
                    throw new MonoSymbolFileException (
                        "Method {0} has invalid scope variable {1} (referencing `this' in static method).",
                        name, var);
                if ((var.Index >= 0) && (var.Index >= num_locals))
                    throw new MonoSymbolFileException (
                        "Method {0} has invalid scope variable {1} (index out of bounds: {2} / {3}).",
                        name, var, var.Index, num_locals);
                if ((var.Scope > 0) && (File.GetAnonymousScope (var.Scope) == null))
                    throw new MonoSymbolFileException (
                        "Method {0} has invalid scope variable {1} (can't find scope {2}).",
                        name, var, var.Scope);
            }
        }