public void ProcessBacktraceForStackFrames() { // Arrange const int commandId = 3; const int fromFrame = 0; const int toFrame = 7; var resultFactoryMock = new Mock <IEvaluationResultFactory>(); resultFactoryMock.Setup(factory => factory.Create(It.IsAny <INodeVariable>())) .Returns(() => new NodeEvaluationResult(0, null, null, null, null, null, NodeExpressionType.None, null)); var backtraceCommand = new BacktraceCommand(commandId, resultFactoryMock.Object, fromFrame, toFrame); JObject backtraceMessage = SerializationTestData.GetBacktraceResponse(); // Act backtraceCommand.ProcessResponse(backtraceMessage); // Assert Assert.AreEqual(7, backtraceCommand.StackFrames.Count); NodeStackFrame firstFrame = backtraceCommand.StackFrames[0]; Assert.AreEqual(NodeVariableType.AnonymousFunction, firstFrame.FunctionName); Assert.AreEqual(@"C:\Users\Tester\documents\visual studio 2012\Projects\NodejsApp1\NodejsApp1\server.js", firstFrame.FileName); Assert.AreEqual(22, firstFrame.Line); Assert.AreEqual(0, firstFrame.Column); Assert.AreEqual(15, firstFrame.Locals.Count); Assert.AreEqual(5, firstFrame.Parameters.Count); Assert.IsNotNull(backtraceCommand.Modules); Assert.AreEqual(3, backtraceCommand.Modules.Count); resultFactoryMock.Verify(factory => factory.Create(It.IsAny <INodeVariable>()), Times.Exactly(51)); }
public NodeBacktraceVariable(NodeStackFrame stackFrame, JToken parameter) { Utilities.ArgumentNotNull("stackFrame", stackFrame); Utilities.ArgumentNotNull("parameter", parameter); var value = parameter["value"]; this.Id = (int)value["ref"]; this.Parent = null; this.StackFrame = stackFrame; this.Name = (string)parameter["name"] ?? NodeVariableType.AnonymousVariable; this.TypeName = (string)value["type"]; this.Value = (string)value["value"]; this.Class = (string)value["className"]; try { this.Text = (string)value["text"]; } catch (ArgumentException) { this.Text = string.Empty; } this.Attributes = NodePropertyAttributes.None; this.Type = NodePropertyType.Normal; }
public void ProcessEvaluateResponseWithReferenceError() { // Arrange const int commandId = 3; var resultFactoryMock = new Mock <IEvaluationResultFactory>(); resultFactoryMock.Setup(factory => factory.Create(It.IsAny <INodeVariable>())); const string expression = "hello"; var stackFrame = new NodeStackFrame(0); var evaluateCommand = new EvaluateCommand(commandId, resultFactoryMock.Object, expression, stackFrame); Exception exception = null; // Act try { evaluateCommand.ProcessResponse(SerializationTestData.GetEvaluateResponseWithReferenceError()); } catch (Exception e) { exception = e; } // Assert Assert.IsNotNull(exception); Assert.IsInstanceOfType(exception, typeof(DebuggerCommandException)); Assert.AreEqual("ReferenceError: hello is not defined", exception.Message); Assert.IsNull(evaluateCommand.Result); resultFactoryMock.Verify(factory => factory.Create(It.IsAny <INodeVariable>()), Times.Never); }
private AD7MemoryAddress(AD7Engine engine, NodeStackFrame frame, string fileName, int line, int column) { _engine = engine; _frame = frame; _fileName = fileName; _line = line; _column = column; }
/// <summary> /// Returns information about the given stack frame for the given process and thread ID. /// If the process, thread, or frame are unknown the null is returned. /// New in 1.5. /// </summary> public static IDebugDocumentContext2 GetCodeMappingDocument(int processId, int threadId, int frame) { if (frame >= 0) { foreach (WeakReference engineRef in Engines) { var engine = engineRef.Target as AD7Engine; if (engine != null) { if (engine._process.Id == processId) { NodeThread thread = engine._threads.Item1; if (thread.Id == threadId) { IList <NodeStackFrame> frames = thread.Frames; if (frame < frames.Count) { NodeStackFrame curFrame = thread.Frames[frame]; return(null); } } } } } } return(null); }
public override void ProcessResponse(JObject response) { base.ProcessResponse(response); var body = response["body"]; this.CallstackDepth = (int)body["totalFrames"]; // Collect frames only if required if (this._depthOnly) { this.Modules = new Dictionary <int, NodeModule>(); this.StackFrames = new List <NodeStackFrame>(); return; } // Extract scripts (if not provided) this.Modules = GetModules((JArray)response["refs"]); // Extract frames var frames = (JArray)body["frames"] ?? new JArray(); this.StackFrames = new List <NodeStackFrame>(frames.Count); foreach (var frame in frames) { // Create stack frame var functionName = GetFunctionName(frame); var moduleId = (int?)frame["func"]["scriptId"]; NodeModule module; if (!moduleId.HasValue || !this.Modules.TryGetValue(moduleId.Value, out module)) { module = this._unknownModule; } var line = (int?)frame["line"] ?? 0; var column = (int?)frame["column"] ?? 0; var frameId = (int?)frame["index"] ?? 0; var stackFrame = new NodeStackFrame(frameId) { Column = column, FunctionName = functionName, Line = line, Module = module }; // Locals var variables = (JArray)frame["locals"] ?? new JArray(); stackFrame.Locals = GetVariables(stackFrame, variables); // Arguments variables = (JArray)frame["arguments"] ?? new JArray(); stackFrame.Parameters = GetVariables(stackFrame, variables); this.StackFrames.Add(stackFrame); } }
public override void Execute(object[] arguments) { if (arguments.Length != 1) { throw new ArgumentOutOfRangeException("arguments"); } var debugger = arguments[0] as IDebuggerManager; if (debugger == null) { string message = string.Format("Invalid arguments: {0}", arguments); throw new ArgumentException(message, "arguments"); } // Extract scripts var references = (JArray) _message["refs"]; Dictionary<int, NodeScript> scripts = GetScripts(references); Scripts = scripts.Values.ToList(); // Extract frames var frames = (JArray) _message["body"]["frames"]; if (frames == null) { StackFrames = new List<NodeStackFrame>(); return; } var stackFrames = new List<NodeStackFrame>(frames.Count); for (int i = 0; i < frames.Count; i++) { JToken frame = frames[i]; // Create stack frame string name = GetFrameName(frame); var scriptId = (int) frame["func"]["scriptId"]; NodeScript script = scripts[scriptId]; int line = (int) frame["line"] + 1; var stackFrameId = (int) frame["index"]; var stackFrame = new NodeStackFrame(debugger, name, script.Filename, line, line, line, stackFrameId); // Locals var variables = (JArray) frame["locals"]; List<NodeEvaluationResult> locals = GetVariables(variables, debugger, stackFrame); // Parameters variables = (JArray) frame["arguments"]; List<NodeEvaluationResult> parameters = GetVariables(variables, debugger, stackFrame); stackFrame.Locals = locals; stackFrame.Parameters = parameters; stackFrames.Add(stackFrame); } StackFrames = stackFrames; }
public AD7StackFrame(AD7Engine engine, AD7Thread thread, NodeStackFrame threadContext) { _engine = engine; _thread = thread; _stackFrame = threadContext; _parameters = threadContext.Parameters.ToArray(); _locals = threadContext.Locals.ToArray(); }
/// <summary> /// Handles backtrace response message. /// </summary> /// <param name="thread">Thread.</param> /// <param name="message">Message.</param> /// <returns>Array of stack frames.</returns> public void ProcessBacktrace(NodeThread thread, Dictionary<int, NodeModule> modules, JsonValue message, Action<NodeStackFrame[]> successHandler) { Utilities.ArgumentNotNull("thread", thread); Utilities.ArgumentNotNull("message", message); // Extract scripts (if not provided) if (modules == null) { JsonArray refs = message.GetArray("refs"); modules = GetScripts(thread.Process, refs); } // Extract frames JsonValue body = message["body"]; JsonArray frames = body.GetArray("frames"); if (frames == null) { if (successHandler != null) { successHandler(new NodeStackFrame[] { }); } return; } var stackFrames = new List<NodeStackFrame>(frames.Count); for (int i = 0; i < frames.Count; i++) { JsonValue frame = frames[i]; // Create stack frame string name = GetFrameName(frame); var moduleId = frame["func"].GetValue<int>("scriptId"); NodeModule module; if (!modules.TryGetValue(moduleId, out module)) { module = _unknownModule; } int line = frame.GetValue<int>("line") + 1; var stackFrameId = frame.GetValue<int>("index"); var stackFrame = new NodeStackFrame(thread, module, name, line, line, line, stackFrameId); // Locals JsonArray variables = frame.GetArray("locals"); List<NodeEvaluationResult> locals = GetVariables(stackFrame, variables); // Arguments variables = frame.GetArray("arguments"); List<NodeEvaluationResult> parameters = GetVariables(stackFrame, variables); stackFrame.Locals = locals; stackFrame.Parameters = parameters; stackFrames.Add(stackFrame); } if (successHandler != null) { successHandler(stackFrames.ToArray()); } }
/// <summary> /// Handles evaluate response message. /// </summary> /// <param name="stackFrame">Stack frame.</param> /// <param name="expression">Expression.</param> /// <param name="message">Message.</param> /// <returns>Evaluation result.</returns> public NodeEvaluationResult ProcessEvaluate(NodeStackFrame stackFrame, string expression, JsonValue message) { Utilities.ArgumentNotNull("stackFrame", stackFrame); Utilities.ArgumentNotNull("expression", expression); Utilities.ArgumentNotNull("message", message); JsonValue body = message["body"]; var variableProvider = new NodeEvaluationVariable(stackFrame, expression, body); return(_evaluationResultFactory.Create(variableProvider)); }
private List <NodeEvaluationResult> GetVariables(NodeStackFrame stackFrame, JsonArray variables) { var results = new List <NodeEvaluationResult>(variables.Count); for (int i = 0; i < variables.Count; i++) { var variableProvider = new NodeBacktraceVariable(stackFrame, variables[i]); NodeEvaluationResult result = _evaluationResultFactory.Create(variableProvider); results.Add(result); } return(results.ToList()); }
public NodeSetValueVariable(NodeStackFrame stackFrame, string name, JToken message) { Id = (int)message["body"]["newValue"]["handle"]; StackFrame = stackFrame; Parent = null; Name = name; TypeName = (string)message["body"]["newValue"]["type"]; Value = (string)message["body"]["newValue"]["value"]; Class = (string)message["body"]["newValue"]["className"]; Text = (string)message["body"]["newValue"]["text"]; Attributes = NodePropertyAttributes.None; Type = NodePropertyType.Normal; }
public NodeSetValueVariable(NodeStackFrame stackFrame, string name, JToken message) { this.Id = (int)message["body"]["newValue"]["handle"]; this.StackFrame = stackFrame; this.Parent = null; this.Name = name; this.TypeName = (string)message["body"]["newValue"]["type"]; this.Value = (string)message["body"]["newValue"]["value"]; this.Class = (string)message["body"]["newValue"]["className"]; this.Text = (string)message["body"]["newValue"]["text"]; this.Attributes = NodePropertyAttributes.None; this.Type = NodePropertyType.Normal; }
public BacktraceVariableProvider(JToken parameter, IDebuggerManager debugger, NodeStackFrame stackFrame) { Id = (int) parameter["value"]["ref"]; Debugger = debugger; StackFrame = stackFrame; Parent = null; Name = (string) parameter["name"] ?? AnonymousVariable; TypeName = (string) parameter["value"]["type"]; Value = (string) parameter["value"]["value"]; Class = (string) parameter["value"]["className"]; Text = (string) parameter["value"]["text"]; Attributes = PropertyAttribute.None; Type = PropertyType.Normal; }
public EvaluateVariableProvider(JObject message, IDebuggerManager debugger, NodeStackFrame stackFrame, string name) { Id = (int) message["body"]["handle"]; Debugger = debugger; StackFrame = stackFrame; Parent = null; Name = name; TypeName = (string) message["body"]["type"]; Value = (string) message["body"]["value"]; Class = (string) message["body"]["className"]; Text = (string) message["body"]["text"]; Attributes = PropertyAttribute.None; Type = PropertyType.Normal; }
public EvaluateCommand(int id, IEvaluationResultFactory resultFactory, string expression, NodeStackFrame stackFrame = null) : base(id, "evaluate") { _resultFactory = resultFactory; _expression = expression; _stackFrame = stackFrame; _arguments = new Dictionary<string, object> { { "expression", _expression }, { "frame", _stackFrame != null ? _stackFrame.FrameId : 0 }, { "global", false }, { "disable_break", true }, { "maxStringLength", -1 } }; }
public BacktraceVariableProvider(JToken parameter, IDebuggerManager debugger, NodeStackFrame stackFrame) { Id = (int)parameter["value"]["ref"]; Debugger = debugger; StackFrame = stackFrame; Parent = null; Name = (string)parameter["name"] ?? AnonymousVariable; TypeName = (string)parameter["value"]["type"]; Value = (string)parameter["value"]["value"]; Class = (string)parameter["value"]["className"]; Text = (string)parameter["value"]["text"]; Attributes = PropertyAttribute.None; Type = PropertyType.Normal; }
public NewValueVariableProvider(JObject message, IDebuggerManager debugger, NodeStackFrame stackFrame, string name) { Id = (int)message["body"]["newValue"]["handle"]; Debugger = debugger; StackFrame = stackFrame; Parent = null; Name = name; TypeName = (string)message["body"]["newValue"]["type"]; Value = (string)message["body"]["newValue"]["value"]; Class = (string)message["body"]["newValue"]["className"]; Text = (string)message["body"]["newValue"]["text"]; Attributes = PropertyAttribute.None; Type = PropertyType.Normal; }
public NodeEvaluationVariable(NodeStackFrame stackFrame, string name, JToken message) { Utilities.ArgumentNotNull("name", name); Utilities.ArgumentNotNull("message", message); Id = (int)message["handle"]; Parent = null; StackFrame = stackFrame; Name = name; TypeName = (string)message["type"]; Value = (string)message["value"]; Class = (string)message["className"]; Text = (string)message["text"]; Attributes = NodePropertyAttributes.None; Type = NodePropertyType.Normal; }
public EvaluateCommand(int id, IEvaluationResultFactory resultFactory, int variableId, NodeStackFrame stackFrame = null) : base(id, "evaluate") { _resultFactory = resultFactory; _expression = "variable"; _stackFrame = stackFrame; _arguments = new Dictionary<string, object> { { "expression", _expression + ".toString()" }, { "frame", _stackFrame != null ? _stackFrame.FrameId : 0 }, { "global", false }, { "disable_break", true }, { "additional_context", new[] { new { name = _expression, handle = variableId } } }, { "maxStringLength", -1 } }; }
public EvaluateCommand(int id, IEvaluationResultFactory resultFactory, string expression, NodeStackFrame stackFrame = null) : base(id, "evaluate") { this._resultFactory = resultFactory; this._expression = expression; this._stackFrame = stackFrame; this._arguments = new Dictionary <string, object> { { "expression", _expression }, { "frame", _stackFrame != null ? _stackFrame.FrameId : 0 }, { "global", false }, { "disable_break", true }, { "maxStringLength", -1 } }; }
public SetVariableValueCommand(int id, IEvaluationResultFactory resultFactory, NodeStackFrame stackFrame, string name, int handle) : base(id, "setVariableValue") { Utilities.ArgumentNotNull("resultFactory", resultFactory); Utilities.ArgumentNotNull("stackFrame", stackFrame); Utilities.ArgumentNotNullOrEmpty("name", name); _resultFactory = resultFactory; _stackFrame = stackFrame; _name = name; _arguments = new Dictionary<string, object> { { "name", name }, { "newValue", new { handle } }, { "scope", new { frameNumber = stackFrame.FrameId, number = 0 } } }; }
public NodeEvaluationVariable(NodeStackFrame stackFrame, string name, JToken message) { Utilities.ArgumentNotNull("name", name); Utilities.ArgumentNotNull("message", message); this.Id = (int)message["handle"]; this.Parent = null; this.StackFrame = stackFrame; this.Name = name; this.TypeName = (string)message["type"]; this.Value = (string)message["value"]; this.Class = (string)message["className"]; this.Text = (string)message["text"]; this.Attributes = NodePropertyAttributes.None; this.Type = NodePropertyType.Normal; }
public EvaluateCommand(int id, IEvaluationResultFactory resultFactory, int variableId, NodeStackFrame stackFrame = null) : base(id, "evaluate") { this._resultFactory = resultFactory; this._expression = "variable"; this._stackFrame = stackFrame; this._arguments = new Dictionary <string, object> { { "expression", _expression + ".toString()" }, { "frame", _stackFrame != null ? _stackFrame.FrameId : 0 }, { "global", false }, { "disable_break", true }, { "additional_context", new[] { new { name = _expression, handle = variableId } } }, { "maxStringLength", -1 } }; }
public SetVariableValueCommand(int id, IEvaluationResultFactory resultFactory, NodeStackFrame stackFrame, string name, int handle) : base(id, "setVariableValue") { Utilities.ArgumentNotNull(nameof(resultFactory), resultFactory); Utilities.ArgumentNotNull(nameof(stackFrame), stackFrame); Utilities.ArgumentNotNullOrEmpty(nameof(name), name); this._resultFactory = resultFactory; this._stackFrame = stackFrame; this._name = name; this._arguments = new Dictionary <string, object> { { "name", name }, { "newValue", new { handle } }, { "scope", new { frameNumber = stackFrame.FrameId, number = 0 } } }; }
public void CreateBacktraceVariableWithNullJson() { // Arrange var stackFrame = new NodeStackFrame(0); Exception exception = null; NodeBacktraceVariable result = null; // Act try { result = new NodeBacktraceVariable(stackFrame, null); } catch (Exception e) { exception = e; } // Assert Assert.IsNull(result); Assert.IsNotNull(exception); Assert.IsInstanceOfType(exception, typeof(ArgumentNullException)); }
public void CreateSetVariableValueCommand() { // Arrange const int commandId = 3; const int frameId = 1; var resultFactoryMock = new Mock <IEvaluationResultFactory>(); var stackFrame = new NodeStackFrame(frameId); const string variableName = "port"; const int handle = 40; // Act var setVariableValueCommand = new SetVariableValueCommand(commandId, resultFactoryMock.Object, stackFrame, variableName, handle); // Assert Assert.AreEqual(commandId, setVariableValueCommand.Id); Assert.AreEqual( string.Format("{{\"command\":\"setVariableValue\",\"seq\":{0},\"type\":\"request\",\"arguments\":{{\"name\":\"{1}\",\"newValue\":{{\"handle\":{2}}},\"scope\":{{\"frameNumber\":{3},\"number\":0}}}}}}", commandId, variableName, handle, frameId), setVariableValueCommand.ToString()); }
public NodeBacktraceVariable(NodeStackFrame stackFrame, JToken parameter) { Utilities.ArgumentNotNull("stackFrame", stackFrame); Utilities.ArgumentNotNull("parameter", parameter); JToken value = parameter["value"]; Id = (int)value["ref"]; Parent = null; StackFrame = stackFrame; Name = (string)parameter["name"] ?? NodeVariableType.AnonymousVariable; TypeName = (string)value["type"]; Value = (string)value["value"]; Class = (string)value["className"]; try { Text = (string)value["text"]; } catch (ArgumentException) { Text = String.Empty; } Attributes = NodePropertyAttributes.None; Type = NodePropertyType.Normal; }
public void ProcessEvaluateResponse() { // Arrange const int commandId = 3; var resultFactoryMock = new Mock <IEvaluationResultFactory>(); resultFactoryMock.Setup(factory => factory.Create(It.IsAny <INodeVariable>())) .Returns(() => new NodeEvaluationResult(0, null, null, null, null, null, NodeExpressionType.None, null)); const string expression = "expression"; var stackFrame = new NodeStackFrame(0); var evaluateCommand = new EvaluateCommand(commandId, resultFactoryMock.Object, expression, stackFrame); // Act evaluateCommand.ProcessResponse(SerializationTestData.GetEvaluateResponse()); // Assert Assert.AreEqual(commandId, evaluateCommand.Id); Assert.IsNotNull(evaluateCommand.Result); resultFactoryMock.Verify(factory => factory.Create(It.IsAny <INodeVariable>()), Times.Once); }
public void CreateBacktraceVariableWithNullName() { // Arrange JObject json = SerializationTestData.GetBacktraceJsonObjectWithNullName(); var stackFrame = new NodeStackFrame(0); // Act var result = new NodeBacktraceVariable(stackFrame, json); // Assert Assert.IsNotNull(result); Assert.AreEqual(NodePropertyAttributes.None, result.Attributes); Assert.IsNull(result.Class); Assert.AreEqual(21, result.Id); Assert.AreEqual(NodeVariableType.AnonymousVariable, result.Name); Assert.IsNull(result.Parent); Assert.AreEqual(stackFrame, result.StackFrame); Assert.IsNull(result.Text); Assert.AreEqual(NodePropertyType.Normal, result.Type); Assert.AreEqual("boolean", result.TypeName); }
public void ProcessSetVariableValueResponse() { // Arrange const int commandId = 3; var resultFactoryMock = new Mock <IEvaluationResultFactory>(); resultFactoryMock.Setup(factory => factory.Create(It.IsAny <INodeVariable>())) .Returns(() => new NodeEvaluationResult(0, null, null, null, null, null, NodeExpressionType.None, null)); var stackFrame = new NodeStackFrame(0); const string variableName = "port"; const int handle = 40; var setVariableValueCommand = new SetVariableValueCommand(commandId, resultFactoryMock.Object, stackFrame, variableName, handle); // Act setVariableValueCommand.ProcessResponse(SerializationTestData.GetSetVariableValueResponse()); // Assert Assert.AreEqual(commandId, setVariableValueCommand.Id); Assert.IsNotNull(setVariableValueCommand.Result); resultFactoryMock.Verify(factory => factory.Create(It.IsAny <INodeVariable>()), Times.Once); }
public void CreateEvaluationVariable() { // Arrange JObject json = SerializationTestData.GetEvaluationJsonObject(); var stackFrame = new NodeStackFrame(0); const string name = "name"; // Act var result = new NodeEvaluationVariable(stackFrame, name, json); // Assert Assert.IsNotNull(result); Assert.AreEqual(NodePropertyAttributes.None, result.Attributes); Assert.IsNull(result.Class); Assert.AreEqual(16, result.Id); Assert.AreEqual(name, result.Name); Assert.IsNull(result.Parent); Assert.AreEqual(stackFrame, result.StackFrame); Assert.AreEqual("<tag>Value</tag>", result.Text); Assert.AreEqual(NodePropertyType.Normal, result.Type); Assert.AreEqual("string", result.TypeName); Assert.AreEqual("<tag>Value</tag>", result.Value); }
public void CreateSetVariableValue() { // Arrange JObject json = SerializationTestData.GetSetVariableValueResponse(); const int frameId = 3; var stackFrame = new NodeStackFrame(frameId); const string name = "name"; // Act var result = new NodeSetValueVariable(stackFrame, name, json); // Assert Assert.IsNotNull(result); Assert.AreEqual(NodePropertyAttributes.None, result.Attributes); Assert.IsNull(result.Class); Assert.AreEqual(44, result.Id); Assert.AreEqual(name, result.Name); Assert.IsNull(result.Parent); Assert.AreEqual(stackFrame, result.StackFrame); Assert.AreEqual("55", result.Text); Assert.AreEqual(NodePropertyType.Normal, result.Type); Assert.AreEqual("number", result.TypeName); Assert.AreEqual("55", result.Value); }
/// <summary> /// Handles evaluate response message. /// </summary> /// <param name="stackFrame">Stack frame.</param> /// <param name="expression">Expression.</param> /// <param name="message">Message.</param> /// <returns>Evaluation result.</returns> public NodeEvaluationResult ProcessEvaluate(NodeStackFrame stackFrame, string expression, JsonValue message) { Utilities.ArgumentNotNull("stackFrame", stackFrame); Utilities.ArgumentNotNull("expression", expression); Utilities.ArgumentNotNull("message", message); JsonValue body = message["body"]; var variableProvider = new NodeEvaluationVariable(stackFrame, expression, body); return _evaluationResultFactory.Create(variableProvider); }
private List<NodeEvaluationResult> GetVariables(NodeStackFrame stackFrame, JsonArray variables) { var results = new List<NodeEvaluationResult>(variables.Count); for (int i = 0; i < variables.Count; i++) { var variableProvider = new NodeBacktraceVariable(stackFrame, variables[i]); NodeEvaluationResult result = _evaluationResultFactory.Create(variableProvider); results.Add(result); } return results.ToList(); }
/// <summary> /// Gets a collection of descentants for a variable. /// </summary> /// <param name="variable">Variable.</param> /// <param name="stackFrame">Stack frame.</param> /// <returns>Collection of descendants.</returns> public async Task<IList<NodeEvaluationResult>> GetChildrenAsync(NodeEvaluationResult variable, NodeStackFrame stackFrame) { IResponseMessage response = await _client.SendMessage("lookup", new { handles = new[] {variable.Id}, includeSource = false }, variable).ConfigureAwait(false); var lookupMessage = response as LookupMessage; if (lookupMessage == null || !lookupMessage.IsSuccessful) { string message = string.Format("Invalid lookup response: {0}", response); throw new InvalidOperationException(message); } IsRunning = response.IsRunning; return lookupMessage.Children; }
/// <summary> /// Handles backtrace response message. /// </summary> /// <param name="thread">Thread.</param> /// <param name="message">Message.</param> /// <returns>Array of stack frames.</returns> public void ProcessBacktrace(NodeThread thread, Dictionary <int, NodeModule> modules, JsonValue message, Action <NodeStackFrame[]> successHandler) { Utilities.ArgumentNotNull("thread", thread); Utilities.ArgumentNotNull("message", message); // Extract scripts (if not provided) if (modules == null) { JsonArray refs = message.GetArray("refs"); modules = GetScripts(thread.Process, refs); } // Extract frames JsonValue body = message["body"]; JsonArray frames = body.GetArray("frames"); if (frames == null) { if (successHandler != null) { successHandler(new NodeStackFrame[] { }); } return; } var stackFrames = new List <NodeStackFrame>(frames.Count); for (int i = 0; i < frames.Count; i++) { JsonValue frame = frames[i]; // Create stack frame string name = GetFrameName(frame); var moduleId = frame["func"].GetValue <int>("scriptId"); NodeModule module; if (!modules.TryGetValue(moduleId, out module)) { module = _unknownModule; } int line = frame.GetValue <int>("line") + 1; var stackFrameId = frame.GetValue <int>("index"); var stackFrame = new NodeStackFrame(thread, module, name, line, line, line, stackFrameId); // Locals JsonArray variables = frame.GetArray("locals"); List <NodeEvaluationResult> locals = GetVariables(stackFrame, variables); // Arguments variables = frame.GetArray("arguments"); List <NodeEvaluationResult> parameters = GetVariables(stackFrame, variables); stackFrame.Locals = locals; stackFrame.Parameters = parameters; stackFrames.Add(stackFrame); } if (successHandler != null) { successHandler(stackFrames.ToArray()); } }
public AD7StackFrame(AD7Engine engine, AD7Thread thread, NodeStackFrame stackFrame) { this._engine = engine; this._thread = thread; this._stackFrame = stackFrame; }
private List <NodeEvaluationResult> GetVariables(NodeStackFrame stackFrame, IEnumerable <JToken> variables) { return(variables.Select(t => new NodeBacktraceVariable(stackFrame, t)) .Select(variableProvider => this._resultFactory.Create(variableProvider)).ToList()); }
public AD7MemoryAddress(AD7Engine engine, NodeStackFrame frame) : this(engine, frame, null, frame.Line, frame.Column) { }
private List<NodeEvaluationResult> GetVariables(NodeStackFrame stackFrame, IEnumerable<JToken> variables) { return variables.Select(t => new NodeBacktraceVariable(stackFrame, t)) .Select(variableProvider => _resultFactory.Create(variableProvider)).ToList(); }
public override void ProcessResponse(JObject response) { base.ProcessResponse(response); JToken body = response["body"]; CallstackDepth = (int)body["totalFrames"]; // Collect frames only if required if (_depthOnly) { Modules = new Dictionary<int, NodeModule>(); StackFrames = new List<NodeStackFrame>(); return; } // Extract scripts (if not provided) Modules = GetModules((JArray)response["refs"]); // Extract frames JArray frames = (JArray)body["frames"] ?? new JArray(); StackFrames = new List<NodeStackFrame>(frames.Count); foreach (JToken frame in frames) { // Create stack frame string functionName = GetFunctionName(frame); var moduleId = (int?)frame["func"]["scriptId"]; NodeModule module; if (!moduleId.HasValue || !Modules.TryGetValue(moduleId.Value, out module)) { module = _unknownModule; } int line = (int?)frame["line"] ?? 0; int column = (int?)frame["column"] ?? 0; int frameId = (int?)frame["index"] ?? 0; var stackFrame = new NodeStackFrame(frameId) { Column = column, FunctionName = functionName, Line = line, Module = module }; // Locals JArray variables = (JArray)frame["locals"] ?? new JArray(); stackFrame.Locals = GetVariables(stackFrame, variables); // Arguments variables = (JArray)frame["arguments"] ?? new JArray(); stackFrame.Parameters = GetVariables(stackFrame, variables); StackFrames.Add(stackFrame); } }
private static List <NodeEvaluationResult> GetVariables(JArray variables, IDebuggerManager debugger, NodeStackFrame stackFrame) { var results = new List <NodeEvaluationResult>(variables.Count); for (int j = 0; j < variables.Count; j++) { JToken variable = variables[j]; var variableProvider = new BacktraceVariableProvider(variable, debugger, stackFrame); NodeEvaluationResult result = NodeMessageFactory.CreateVariable(variableProvider); results.Add(result); } return(results); }
public override void Execute(object[] arguments) { if (arguments.Length != 1) { throw new ArgumentOutOfRangeException("arguments"); } var debugger = arguments[0] as IDebuggerManager; if (debugger == null) { string message = string.Format("Invalid arguments: {0}", arguments); throw new ArgumentException(message, "arguments"); } // Extract scripts var references = (JArray)_message["refs"]; Dictionary <int, NodeScript> scripts = GetScripts(references); Scripts = scripts.Values.ToList(); // Extract frames var frames = (JArray)_message["body"]["frames"]; if (frames == null) { StackFrames = new List <NodeStackFrame>(); return; } var stackFrames = new List <NodeStackFrame>(frames.Count); for (int i = 0; i < frames.Count; i++) { JToken frame = frames[i]; // Create stack frame string name = GetFrameName(frame); var scriptId = (int)frame["func"]["scriptId"]; NodeScript script = scripts[scriptId]; int line = (int)frame["line"] + 1; var stackFrameId = (int)frame["index"]; var stackFrame = new NodeStackFrame(debugger, name, script.Filename, line, line, line, stackFrameId); // Locals var variables = (JArray)frame["locals"]; List <NodeEvaluationResult> locals = GetVariables(variables, debugger, stackFrame); // Parameters variables = (JArray)frame["arguments"]; List <NodeEvaluationResult> parameters = GetVariables(variables, debugger, stackFrame); stackFrame.Locals = locals; stackFrame.Parameters = parameters; stackFrames.Add(stackFrame); } StackFrames = stackFrames; }
public AD7StackFrame(AD7Engine engine, AD7Thread thread, NodeStackFrame stackFrame) { _engine = engine; _thread = thread; _stackFrame = stackFrame; }
public async Task<NodeEvaluationResult> EvaluateExpressionAsync(string expression, NodeStackFrame stackFrame) { IResponseMessage response = await _client.SendMessage("evaluate", new { expression, frame = stackFrame.Id }, this, stackFrame, expression).ConfigureAwait(false); var evaluateMessage = response as EvaluateMessage; if (evaluateMessage == null || !evaluateMessage.IsSuccessful) { return null; } IsRunning = response.IsRunning; return evaluateMessage.Result; }
private static List<NodeEvaluationResult> GetVariables(JArray variables, IDebuggerManager debugger, NodeStackFrame stackFrame) { var results = new List<NodeEvaluationResult>(variables.Count); for (int j = 0; j < variables.Count; j++) { JToken variable = variables[j]; var variableProvider = new BacktraceVariableProvider(variable, debugger, stackFrame); NodeEvaluationResult result = NodeMessageFactory.CreateVariable(variableProvider); results.Add(result); } return results; }