static bool AddScope(Collection<ScopeDebugInformation> scopes, ScopeDebugInformation scope) { foreach (var sub_scope in scopes) { if (sub_scope.HasScopes && AddScope (sub_scope.Scopes, scope)) return true; if (scope.Start.Offset >= sub_scope.Start.Offset && scope.End.Offset <= sub_scope.End.Offset) { sub_scope.Scopes.Add (scope); return true; } } return false; }
private void ReadScope(ScopeDebugInformation scope) { InstructionOffset instructionOffset = scope.Start; Instruction instruction = GetInstruction(instructionOffset.Offset); if (instruction != null) { scope.Start = new InstructionOffset(instruction); } instructionOffset = scope.End; Instruction instruction2 = GetInstruction(instructionOffset.Offset); InstructionOffset end; if (instruction2 == null) { instructionOffset = default(InstructionOffset); end = instructionOffset; } else { end = new InstructionOffset(instruction2); } scope.End = end; if (!scope.variables.IsNullOrEmpty()) { for (int i = 0; i < scope.variables.Count; i++) { VariableDebugInformation variableDebugInformation = scope.variables[i]; VariableDefinition variable = GetVariable(variableDebugInformation.Index); if (variable != null) { variableDebugInformation.index = new VariableIndex(variable); } } } if (!scope.scopes.IsNullOrEmpty()) { ReadScopes(scope.scopes); } }
void ReadScope(ScopeDebugInformation scope) { scope.Start = new InstructionOffset(GetInstruction(scope.Start.Offset)); var end_instruction = GetInstruction(scope.End.Offset); scope.End = end_instruction == null ? new InstructionOffset() : new InstructionOffset(end_instruction); if (!scope.variables.IsNullOrEmpty()) { for (int i = 0; i < scope.variables.Count; i++) { var variable = scope.variables [i]; variable.index = new VariableIndex(GetVariable(variable.Index)); } } if (!scope.scopes.IsNullOrEmpty()) { ReadScopes(scope.scopes); } }
void ReadScope(ScopeDebugInformation scope) { var start_instruction = GetInstruction (scope.Start.Offset); if (start_instruction != null) scope.Start = new InstructionOffset (start_instruction); var end_instruction = GetInstruction (scope.End.Offset); if (end_instruction != null) scope.End = new InstructionOffset (end_instruction); if (!scope.variables.IsNullOrEmpty ()) { for (int i = 0; i < scope.variables.Count; i++) { var variable_info = scope.variables [i]; var variable = GetVariable (variable_info.Index); if (variable != null) variable_info.index = new VariableIndex (variable); } } if (!scope.scopes.IsNullOrEmpty ()) ReadScopes (scope.scopes); }
static ScopeDebugInformation ReadScopeAndLocals(PdbScope scope, MethodDebugInformation info) { var parent = new ScopeDebugInformation (); parent.Start = new InstructionOffset ((int) scope.offset); parent.End = new InstructionOffset ((int) (scope.offset + scope.length)); if (!scope.slots.IsNullOrEmpty()) { parent.variables = new Collection<VariableDebugInformation> (scope.slots.Length); foreach (PdbSlot slot in scope.slots) { if (slot.flags == 1) // parameter names continue; var index = (int) slot.slot; var variable = new VariableDebugInformation (index, slot.name); if (slot.flags == 4) variable.IsDebuggerHidden = true; parent.variables.Add (variable); } } if (!scope.constants.IsNullOrEmpty ()) { parent.constants = new Collection<ConstantDebugInformation> (scope.constants.Length); foreach (var constant in scope.constants) { parent.constants.Add (new ConstantDebugInformation ( constant.name, (TypeReference) info.method.Module.LookupToken ((int) constant.token), constant.value)); } } parent.scopes = ReadScopeAndLocals (scope.scopes, info); return parent; }
void DefineScope(ScopeDebugInformation scope, MethodDebugInformation info) { var start_offset = scope.Start.Offset; var end_offset = scope.End.IsEndOfMethod ? info.code_size : scope.End.Offset; writer.OpenScope (start_offset); var sym_token = new SymbolToken (info.local_var_token.ToInt32 ()); if (!scope.variables.IsNullOrEmpty ()) { for (int i = 0; i < scope.variables.Count; i++) { var variable = scope.variables [i]; CreateLocalVariable (variable, sym_token, start_offset, end_offset); } } if (!scope.scopes.IsNullOrEmpty ()) { for (int i = 0; i < scope.scopes.Count; i++) DefineScope (scope.scopes [i], info); } writer.CloseScope (end_offset); }
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); } }
static ScopeDebugInformation[] ReadScopes(MethodEntry entry, MethodDebugInformation info) { var blocks = entry.GetCodeBlocks (); var scopes = new ScopeDebugInformation [blocks.Length + 1]; info.scope = scopes [0] = new ScopeDebugInformation { Start = new InstructionOffset (0), End = new InstructionOffset (info.code_size), }; foreach (var block in blocks) { if (block.BlockType != CodeBlockEntry.Type.Lexical && block.BlockType != CodeBlockEntry.Type.CompilerGenerated) continue; var scope = new ScopeDebugInformation (); scope.Start = new InstructionOffset (block.StartOffset); scope.End = new InstructionOffset (block.EndOffset); scopes [block.Index + 1] = scope; if (!AddScope (info.scope.Scopes, scope)) info.scope.Scopes.Add (scope); } return scopes; }
void WriteScopeVariables(ScopeDebugInformation scope) { if (!scope.HasVariables) return; foreach (var variable in scope.variables) if (!string.IsNullOrEmpty (variable.Name)) writer.DefineLocalVariable (variable.Index, variable.Name); }
void WriteScope(ScopeDebugInformation scope, MethodDebugInformation info) { writer.OpenScope (scope.Start.Offset); WriteScopeVariables (scope); if (scope.HasScopes) WriteScopes (scope.Scopes, info); writer.CloseScope (scope.End.IsEndOfMethod ? info.code_size : scope.End.Offset); }
void WriteRootScope(ScopeDebugInformation scope, MethodDebugInformation info) { WriteScopeVariables (scope); if (scope.HasScopes) WriteScopes (scope.Scopes, info); }