C# SymbolWriter.MethodEntry类代码示例

		void ReadLocalVariables (MethodEntry entry, MethodBody body)
		{
			LocalVariableEntry[] locals = entry.GetLocals ();
			foreach (LocalVariableEntry loc in locals) {
				VariableDefinition var = body.Variables [loc.Index];
				var.Name = loc.Name;

				Scope scope = m_scopes [loc.BlockIndex] as Scope;
				if (scope == null)
					continue;
				scope.Variables.Add (var);
			}
		}

		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;
			}
		}

		internal MethodEntry(MonoSymbolFile file, CompileUnitEntry comp_unit, int token, ScopeVariable[] scope_vars, LocalVariableEntry[] locals, LineNumberEntry[] lines, CodeBlockEntry[] code_blocks, string real_name, MethodEntry.Flags flags, int namespace_id)
		{
			this.SymbolFile = file;
			this.real_name = real_name;
			this.locals = locals;
			this.code_blocks = code_blocks;
			this.scope_vars = scope_vars;
			this.flags = flags;
			this.index = -1;
			this.Token = token;
			this.CompileUnitIndex = comp_unit.Index;
			this.CompileUnit = comp_unit;
			this.NamespaceID = namespace_id;
			this.CheckLineNumberTable(lines);
			this.lnt = new LineNumberTable(file, lines);
			file.NumLineNumbers += lines.Length;
			int num_locals = (locals != null) ? locals.Length : 0;
			if (num_locals <= 32)
			{
				for (int i = 0; i < num_locals; i++)
				{
					string nm = locals[i].Name;
					for (int j = i + 1; j < num_locals; j++)
					{
						if (locals[j].Name == nm)
						{
							flags |= MethodEntry.Flags.LocalNamesAmbiguous;
							goto IL_108;
						}
					}
				}
				IL_108:;
			}
			else
			{
				Dictionary<string, LocalVariableEntry> local_names = new Dictionary<string, LocalVariableEntry>();
				for (int k = 0; k < locals.Length; k++)
				{
					LocalVariableEntry local = locals[k];
					if (local_names.ContainsKey(local.Name))
					{
						flags |= MethodEntry.Flags.LocalNamesAmbiguous;
						break;
					}
					local_names.Add(local.Name, local);
				}
			}
		}

		static void ReadLocalVariables (MethodEntry entry, MethodBody body, Scope [] scopes)
		{
			var locals = entry.GetLocals ();
			foreach (var local in locals) {
				var variable = body.Variables [local.Index];
				variable.Name = local.Name;

				var index = local.BlockIndex;
				if (index < 0 || index >= scopes.Length)
					continue;

				var scope = scopes [index];
				if (scope == null)
					continue;

				scope.Variables.Add (variable);
			}
		}

		private static void ReadLocalVariables(MethodEntry entry, MethodBody body, Scope[] scopes)
		{
			LocalVariableEntry[] locals = entry.GetLocals();
			LocalVariableEntry[] array = locals;
			for (int i = 0; i < array.Length; i++)
			{
				LocalVariableEntry local = array[i];
				VariableDefinition variable = body.Variables[local.Index];
				variable.Name = local.Name;
				int index = local.BlockIndex;
				if (index >= 0 && index < scopes.Length)
				{
					Scope scope = scopes[index];
					if (scope != null)
					{
						scope.Variables.Add(variable);
					}
				}
			}
		}

		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, MethodSymbols symbols)
		{
			var table = entry.GetLineNumberTable ();
			var lines = table.LineNumbers;

			var instructions = symbols.instructions = new Collection<InstructionSymbol> (lines.Length);

			for (int i = 0; i < lines.Length; i++) {
				var line = lines [i];

				instructions.Add (new InstructionSymbol (line.Offset, new SequencePoint (GetDocument (entry.CompileUnit.SourceFile)) {
					StartLine = line.Row,
					EndLine = line.Row,
				}));
			}
		}

		public void DefineMethod (MonoSymbolFile file, int token)
		{
			MethodEntry entry = new MethodEntry (
				file, _comp_unit.Entry, token, ScopeVariables,
				Locals, method_lines.ToArray (), Blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);

			file.AddMethod (entry);
		}

	private void ProcessMethod (MethodBase monoMethod, MethodEntry entry, ClassCoverageItem klass, string methodName, string cov_info)

		void read_methods ()
		{
			lock (this) {
				if (method_token_hash != null)
					return;

				method_token_hash = new Dictionary<int, MethodEntry> ();
				method_list = new List<MethodEntry> ();

				long old_pos = reader.BaseStream.Position;
				reader.BaseStream.Position = ot.MethodTableOffset;

				for (int i = 0; i < MethodCount; i++) {
					MethodEntry entry = new MethodEntry (this, reader, i + 1);
					method_token_hash.Add (entry.Token, entry);
					method_list.Add (entry);
				}

				reader.BaseStream.Position = old_pos;
			}
		}

		internal void AddMethod (MethodEntry entry)
		{
			methods.Add (entry);
		}

            public MonoMethod(MonoSymbolFile file, MethodSource source, int domain,
					   C.MethodEntry method, Cecil.MethodDefinition mdef)
                : base(source.Name, file.ImageFile, file.Module)
            {
                this.file = file;
                this.source = source;
                this.domain = domain;
                this.method = method;
                this.mdef = mdef;

                foreach (Cecil.CustomAttribute cattr in mdef.CustomAttributes) {
                    string cname = cattr.Constructor.DeclaringType.FullName;
                    if ((cname == "System.Diagnostics.DebuggerHiddenAttribute") ||
                        (cname == "System.Runtime.CompilerServices.CompilerGeneratedAttribute"))
                        is_compiler_generated = true;
                }
            }

		public void DefineMethod(MonoSymbolFile file)
		{
			LineNumberEntry[] lines = new LineNumberEntry[this.method_lines_pos];
			Array.Copy(this.method_lines, lines, this.method_lines_pos);
			MethodEntry entry = new MethodEntry(file, this._comp_unit.Entry, this._method.Token, this.ScopeVariables, this.Locals, lines, this.Blocks, this.RealMethodName, (MethodEntry.Flags)0, this._ns_id);
			file.AddMethod(entry);
		}

		public void DefineMethod (MonoSymbolFile file, int token)
		{
			var blocks = Blocks;

			//
			// When index is provided by user it can be inserted in
			// any order but mdb format does not store its value. It
			// uses store order instead as the index.
			//
			Array.Sort (blocks, (x, y) => x.Index.CompareTo (y.Index));

			var entry = new MethodEntry (
				file, _comp_unit.Entry, token, ScopeVariables,
				Locals, method_lines.ToArray (), blocks, null, MethodEntry.Flags.ColumnsInfoIncluded, ns_id);

			file.AddMethod (entry);
		}

		void ReadScopes (MethodEntry entry, MethodBody body, IDictionary instructions)
		{
			CodeBlockEntry[] blocks = entry.GetCodeBlocks ();
			foreach (CodeBlockEntry cbe in blocks) {
				if (cbe.BlockType != CodeBlockEntry.Type.Lexical)
					continue;

				Scope s = new Scope ();
				s.Start = GetInstruction (body, instructions, cbe.StartOffset);
				s.End = GetInstruction(body, instructions, cbe.EndOffset);
				m_scopes [entry.Index] = s;

				if (!AddScope (body, s))
					body.Scopes.Add (s);
			}
		}