C# MethodEntry.GetLocals方法代码示例

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

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

		static void ReadLocalVariables (MethodEntry entry, MethodSymbols symbols)
		{
			foreach (var local in entry.GetLocals ()) {
				if (local.Index < 0 || local.Index >= symbols.Variables.Count) // Mono 2.6 emits wrong local infos for iterators
					continue;

				var variable = symbols.Variables [local.Index];
				variable.Name = local.Name;
			}
		}

        static void ReadLocalVariables(MethodEntry entry, ScopeDebugInformation [] scopes)
        {
            var locals = entry.GetLocals ();

            foreach (var local in locals) {
                var variable = new VariableDebugInformation (local.Index, 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);
            }
        }

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

        public void PrintLocals(MethodEntry method)
        {
            CodeBlockEntry[] blocks = method.GetCodeBlocks () ?? new CodeBlockEntry [0];
            foreach (CodeBlockEntry block in blocks) {
                Message ("  CodeBlock {0}", block);
            }

            LocalVariableEntry[] locals = method.GetLocals () ?? new LocalVariableEntry [0];
            foreach (LocalVariableEntry local in locals) {
                Message ("  Local {0}", local);
            }
        }