// Show debug dialog void OnDebuggerStop(object sender, DebuggerStopEventArgs e) { var ui = new UI.DebuggerDialog(e); // viewer writer? var writer = FarUI.Writer as TranscriptOutputWriter; // no? if console writer and transcript then use transcript if (writer == null && FarUI.Writer is ConsoleOutputWriter && Transcript != null) { writer = Transcript; } // add View handler if (writer != null) { ui.OnView = delegate { // ensure file if (writer.FileName == null) { writer.Write(string.Empty); } // view file Zoo.StartExternalViewer(writer.FileName); }; } e.ResumeAction = ui.Show(); }
async void DebugService_DebuggerStopped(object sender, DebuggerStopEventArgs e) { // Flush pending output before sending the event await this.outputDebouncer.Flush(); // Provide the reason for why the debugger has stopped script execution. // See https://github.com/Microsoft/vscode/issues/3648 // The reason is displayed in the breakpoints viewlet. Some recommended reasons are: // "step", "breakpoint", "function breakpoint", "exception" and "pause". // We don't support exception breakpoints and for "pause", we can't distinguish // between stepping and the user pressing the pause/break button in the debug toolbar. string debuggerStoppedReason = "step"; if (e.Breakpoints.Count > 0) { debuggerStoppedReason = e.Breakpoints[0] is CommandBreakpoint ? "function breakpoint" : "breakpoint"; } await this.SendEvent( StoppedEvent.Type, new StoppedEventBody { Source = new Source { Path = e.InvocationInfo.ScriptName, }, Line = e.InvocationInfo.ScriptLineNumber, Column = e.InvocationInfo.OffsetInLine, ThreadId = 1, // TODO: Change this based on context Reason = debuggerStoppedReason }); }
private void OnDebugStopped(object sender, DebuggerStopEventArgs e) { var lineNumber = e.InvocationInfo.ScriptLineNumber - 2; // Notify the UI DebuggerStopped?.Invoke(this, new DebugEventArgs(lineNumber, _editorSession.DebugService.GetStackFrames())); }
void Debugger_DebuggerStop(object sender, DebuggerStopEventArgs e) { Log.InfoFormat("Debugger stopped"); if (CurrentExecutingNode == null) { return; } RefreshScopedVariables(); RefreshCallStack(); if (e.Breakpoints.Count == 0 || !ProcessLineBreakpoints(e)) { if (DebuggerPaused != null) { var scriptLocation = new ScriptLocation(); scriptLocation.File = e.InvocationInfo.ScriptName; scriptLocation.Line = e.InvocationInfo.ScriptLineNumber; scriptLocation.Column = 0; DebuggerPaused(this, new EventArgs <ScriptLocation>(scriptLocation)); } } Log.Debug("Waiting for debuggee to resume."); //Wait for the user to step, continue or stop _pausedEvent.WaitOne(); Log.DebugFormat("Debuggee resume action is {0}", _resumeAction); e.ResumeAction = _resumeAction; }
private bool ProcessLineBreakpoints(DebuggerStopEventArgs e) { Log.InfoFormat("Process Line Breapoints"); var lbp = e.Breakpoints[0] as LineBreakpoint; if (lbp != null) { var bp = _breakpoints.FirstOrDefault( m => m.Column == lbp.Column && lbp.Line == m.Line && lbp.Script.Equals(m.File, StringComparison.InvariantCultureIgnoreCase)); if (bp != null) { if (BreakpointHit != null) { Log.InfoFormat("Breakpoint @ {0} {1} {2} was hit.", bp.File, bp.Line, bp.Column); BreakpointHit(this, new EventArgs <ScriptBreakpoint>(bp)); return(true); } } } return(false); }
private void HandleDebuggerStopEvent(object sender, DebuggerStopEventArgs args) { Debugger debugger = sender as Debugger; DebuggerResumeAction?resumeAction = null; if (!ShowHelpMessage) { UserIOImpl.PrintMessage("Entering debug mode. Type 'h' to get help.\n"); ShowHelpMessage = true; } CheckVariables(debugger); PrintCurrentCode(args); while (resumeAction == null) { if (CommandCount > 0) { resumeAction = RunDebuggerCommand(debugger, Command)?.ResumeAction; CommandCount--; } else { string commandLine = UserIOImpl.GetInput("PowerShellRunBox>> "); string[] commandArgs = commandLine.Split(' '); if (commandArgs.Length <= 0) { continue; } if (commandArgs[0] == "s") { Command = commandArgs[0]; if (commandArgs.Length > 1) { CommandCount = Convert.ToInt32(commandArgs[1]); } } else { Command = commandLine; } resumeAction = RunDebuggerCommand(debugger, Command)?.ResumeAction; } } // DebuggerStopEventArgs.ResumeAction: // - Continue Continue execution until next breakpoint is hit. // - StepInto Step into function. // - StepOut Step out of function. // - StepOver Step over function. // - Stop Stop debugging. args.ResumeAction = resumeAction.Value; }
private async void OnDebuggerStop(object sender, DebuggerStopEventArgs e) { // Get call stack and variables. await this.FetchStackFramesAndVariables(); // Notify the host that the debugger is stopped if (this.DebuggerStopped != null) { this.DebuggerStopped(sender, e); } }
private async void OnDebuggerStop(object sender, DebuggerStopEventArgs e) { var lineNumber = e.InvocationInfo.ScriptLineNumber - 2; // Create a waitable task so that we can continue when the user has chosen the appropriate action. _pipelineThreadId = Thread.CurrentThread.ManagedThreadId; _debuggerExecutionTask = new TaskCompletionSource <DebuggerResumeAction>(); // Create a pipeline execution task _pipelineExecutionTask = new TaskCompletionSource <IPipelineExecutionRequest>(); // Get call stack and variables. await FetchStackFramesAndVariables(); // Notify the UI DebuggerStopped?.Invoke(this, new DebugEventArgs(lineNumber, GetStackFrames())); while (true) { var taskIdx = Task.WaitAny( _debuggerExecutionTask.Task, _pipelineExecutionTask.Task); if (taskIdx == 0) { // Set the resume action to what the user choose try { e.ResumeAction = _debuggerExecutionTask.Task.Result; } catch (TaskCanceledException) { } catch (AggregateException) { } break; } else if (taskIdx == 1) { try { var executionRequest = _pipelineExecutionTask.Task.Result; _pipelineExecutionTask = new TaskCompletionSource <IPipelineExecutionRequest>(); executionRequest.Execute().Wait(_cancellationTokenSource.Token); _pipelineResultTask.SetResult(executionRequest); } catch (TaskCanceledException) { } catch (AggregateException) { } } } _debuggerExecutionTask = null; }
private void WriteDebuggerBanner(DebuggerStopEventArgs eventArgs) { // TODO: What do we display when we don't know why we stopped? if (eventArgs.Breakpoints.Count > 0) { // The breakpoint classes have nice ToString output so use that this.WriteOutput( Environment.NewLine + $"Hit {eventArgs.Breakpoints[0].ToString()}\n", true, OutputType.Normal, ConsoleColor.Blue); } }
public async Task AssertDebuggerStopped( string scriptPath, int lineNumber = -1) { SynchronizationContext syncContext = SynchronizationContext.Current; DebuggerStopEventArgs eventArgs = await this.debuggerStoppedQueue.DequeueAsync(); Assert.Equal(scriptPath, eventArgs.InvocationInfo.ScriptName); if (lineNumber > -1) { Assert.Equal(lineNumber, eventArgs.InvocationInfo.ScriptLineNumber); } }
public async Task AssertDebuggerStopped( string scriptPath, int lineNumber = -1) { DebuggerStopEventArgs eventArgs = await this.debuggerStoppedQueue.DequeueAsync(); // TODO #22 - Need to re-enable these Asserts once we figure // out how to make them work correctly //Assert.Equal(scriptPath, eventArgs.InvocationInfo.ScriptName); if (lineNumber > -1) { //Assert.Equal(lineNumber, eventArgs.InvocationInfo.ScriptLineNumber); } }
/// <summary> /// Helper method to write debugger stop messages. /// </summary> /// <param name="args">DebuggerStopEventArgs for current debugger stop</param> private void WriteDebuggerStopMessages(DebuggerStopEventArgs args) { // Write debugger stop information in yellow. ConsoleColor saveFGColor = Console.ForegroundColor; Console.ForegroundColor = ConsoleColor.Yellow; // Show help message only once. if (!_showHelpMessage) { Console.WriteLine("Entering debug mode. Type 'h' to get help."); Console.WriteLine(); _showHelpMessage = true; } // Break point summary message. string breakPointMsg = String.Format(System.Globalization.CultureInfo.InvariantCulture, "Breakpoints: Enabled {0}, Disabled {1}", (_breakPoints.Values.Where <Breakpoint>((bp) => { return(bp.Enabled); })).Count(), (_breakPoints.Values.Where <Breakpoint>((bp) => { return(!bp.Enabled); })).Count()); Console.WriteLine(breakPointMsg); Console.WriteLine(); // Breakpoint stop information. Writes all breakpoints that // pertain to this debugger execution stop point. if (args.Breakpoints.Count > 0) { Console.WriteLine("Debugger hit breakpoint on:"); foreach (var breakPoint in args.Breakpoints) { Console.WriteLine(breakPoint.ToString()); } Console.WriteLine(); } // Script position stop information. // This writes the InvocationInfo position message if // there is one. if (args.InvocationInfo != null) { Console.WriteLine(args.InvocationInfo.PositionMessage); Console.WriteLine(); } Console.ForegroundColor = saveFGColor; }
// Method to handle the Debugger DebuggerStop event. // The debugger will remain in debugger stop mode until this event // handler returns, at which time DebuggerStopEventArgs.ResumeAction should // be set to indicate how the debugger should proceed (Continue, StepInto, // StepOut, StepOver, Stop). // This handler should run a REPL (Read Evaluate Print Loop) to allow user // to investigate the state of script execution, by processing user commands // with the Debugger.ProcessCommand method. If a user command releases the // debugger then the DebuggerStopEventArgs.ResumeAction is set and this // handler returns. private void HandleDebuggerStopEvent(object sender, DebuggerStopEventArgs args) { Debugger debugger = sender as Debugger; DebuggerResumeAction?resumeAction = null; // Display messages pertaining to this debugger stop. WriteDebuggerStopMessages(args); // Simple REPL (Read Evaluate Print Loop) to process // Debugger commands. while (resumeAction == null) { // Write debug prompt. Console.Write("[DBG] PS >> "); string command = Console.ReadLine(); Console.WriteLine(); // Stream output from command processing to console. var output = new PSDataCollection <PSObject>(); output.DataAdded += (dSender, dArgs) => { foreach (var item in output.ReadAll()) { Console.WriteLine(item); } }; // Process command. // The Debugger.ProcesCommand method will parse and handle debugger specific // commands such as 'h' (help), 'list', 'stepover', etc. If the command is // not specific to the debugger then it will be evaluated as a PowerShell // command or script. The returned DebuggerCommandResults object will indicate // whether the command was evaluated by the debugger and if the debugger should // be released with a specific resume action. PSCommand psCommand = new PSCommand(); psCommand.AddScript(command).AddCommand("Out-String").AddParameter("Stream", true); DebuggerCommandResults results = debugger.ProcessCommand(psCommand, output); if (results.ResumeAction != null) { resumeAction = results.ResumeAction; } } // Return from event handler with user resume action. args.ResumeAction = resumeAction.Value; }
async void DebugService_DebuggerStopped(object sender, DebuggerStopEventArgs e) { // Flush pending output before sending the event await this.outputDebouncer.Flush(); await this.SendEvent( StoppedEvent.Type, new StoppedEventBody { Source = new Source { Path = e.InvocationInfo.ScriptName, }, Line = e.InvocationInfo.ScriptLineNumber, Column = e.InvocationInfo.OffsetInLine, ThreadId = 1, // TODO: Change this based on context Reason = "breakpoint" // TODO: Change this based on context }); }
void DebugService_DebuggerStopped(object sender, DebuggerStopEventArgs e) { // Push the write operation to the correct thread this.messageLoopSyncContext.Post( async(obj) => { await this.messageWriter.WriteEvent( StoppedEvent.Type, new StoppedEventBody { Source = new Source { Path = e.InvocationInfo.ScriptName, }, Line = e.InvocationInfo.ScriptLineNumber, Column = e.InvocationInfo.OffsetInLine, ThreadId = 1, // TODO: Change this based on context Reason = "breakpoint" // TODO: Change this based on context }); }, null); }
/// <summary> /// Creates a new instance of the DebuggerStoppedEventArgs class. /// </summary> /// <param name="originalEvent">The original DebuggerStopEventArgs instance from which this instance is based.</param> /// <param name="runspaceDetails">The RunspaceDetails of the runspace which raised this event.</param> /// <param name="localScriptPath">The local path of the remote script being debugged.</param> public DebuggerStoppedEventArgs( DebuggerStopEventArgs originalEvent, RunspaceDetails runspaceDetails, string localScriptPath) { Validate.IsNotNull(nameof(originalEvent), originalEvent); Validate.IsNotNull(nameof(runspaceDetails), runspaceDetails); if (!string.IsNullOrEmpty(localScriptPath)) { this.ScriptPath = localScriptPath; this.RemoteScriptPath = originalEvent.InvocationInfo.ScriptName; } else { this.ScriptPath = originalEvent.InvocationInfo.ScriptName; } this.OriginalEvent = originalEvent; this.RunspaceDetails = runspaceDetails; }
/// <summary> /// Creates a new instance of the DebuggerStoppedEventArgs class. /// </summary> /// <param name="originalEvent">The original DebuggerStopEventArgs instance from which this instance is based.</param> /// <param name="runspaceInfo">The RunspaceDetails of the runspace which raised this event.</param> /// <param name="localScriptPath">The local path of the remote script being debugged.</param> public DebuggerStoppedEventArgs( DebuggerStopEventArgs originalEvent, IRunspaceInfo runspaceInfo, string localScriptPath) { Validate.IsNotNull(nameof(originalEvent), originalEvent); Validate.IsNotNull(nameof(runspaceInfo), runspaceInfo); if (!string.IsNullOrEmpty(localScriptPath)) { ScriptPath = localScriptPath; RemoteScriptPath = originalEvent.InvocationInfo.ScriptName; } else { ScriptPath = originalEvent.InvocationInfo.ScriptName; } OriginalEvent = originalEvent; RunspaceInfo = runspaceInfo; }
/// <summary> /// Helper method to write debugger stop messages. /// </summary> /// <param name="args">DebuggerStopEventArgs for current debugger stop</param> private void PrintCurrentCode(DebuggerStopEventArgs args) { if (args.InvocationInfo == null) { return; } Token[] tokens; ParseError[] parseErrors; ScriptBlockAst sciptBlockAst = Parser.ParseInput( args.InvocationInfo.Line, out tokens, out parseErrors); UserIOImpl.PrintCode("--------------------------------------------------------------------------------------------------------------\n"); if (!string.IsNullOrEmpty(args.InvocationInfo.ScriptName)) { ReadFile(args.InvocationInfo.ScriptName); UserIOImpl.PrintCode(String.Format("* File {0}:\n", args.InvocationInfo.ScriptName)); UserIOImpl.PrintCode(GetFileLine(args.InvocationInfo.ScriptName, args.InvocationInfo.ScriptLineNumber - 1) + "\n", args.InvocationInfo.ScriptLineNumber - 1); } foreach (StatementAst statementAst in sciptBlockAst.EndBlock.Statements) { PrintAST(statementAst, args.InvocationInfo.OffsetInLine); } if (!string.IsNullOrEmpty(args.InvocationInfo.ScriptName)) { UserIOImpl.PrintCode(GetFileLine(args.InvocationInfo.ScriptName, args.InvocationInfo.ScriptLineNumber + 1) + "\n", args.InvocationInfo.ScriptLineNumber + 1); } UserIOImpl.PrintCode("\n--------------------------------------------------------------------------------------------------------------\n\n"); }
async void debugService_DebuggerStopped(object sender, DebuggerStopEventArgs e) { await this.debuggerStoppedQueue.EnqueueAsync(e); }
/// <summary> /// PS debugger stopped event handler /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void Debugger_DebuggerStop(object sender, DebuggerStopEventArgs e) { ServiceCommon.Log("Debugger stopped ..."); DebugScenario currScenario = GetDebugScenario(); if (_installedPowerShellVersion < RequiredPowerShellVersionForRemoteSessionDebugging) { RefreshScopedVariable(); RefreshCallStack(); } else { RefreshScopedVariable40(); RefreshCallStack40(); } ServiceCommon.LogCallbackEvent("Callback to client, and wait for debuggee to resume"); if (e.Breakpoints.Count > 0) { LineBreakpoint bp = (LineBreakpoint)e.Breakpoints[0]; if (_callback != null) { string file = bp.Script; if (currScenario != DebugScenario.Local && _mapRemoteToLocal.ContainsKey(bp.Script)) { file = _mapRemoteToLocal[bp.Script]; } // breakpoint is always hit for this case _callback.DebuggerStopped(new DebuggerStoppedEventArgs(file, bp.Line, bp.Column, true, false)); } } else { if (_callback != null) { string file; int lineNum, column; switch (currScenario) { case DebugScenario.LocalAttach: file = e.InvocationInfo.ScriptName; lineNum = e.InvocationInfo.ScriptLineNumber; column = e.InvocationInfo.OffsetInLine; // the stop which occurs after attaching is not associated with a breakpoint and should result in the process' script being opened _callback.DebuggerStopped(new DebuggerStoppedEventArgs(file, lineNum, column, false, true)); break; case DebugScenario.RemoteAttach: // copy the remote file over to host machine file = OpenRemoteAttachedFile(e.InvocationInfo.ScriptName); lineNum = e.InvocationInfo.ScriptLineNumber; column = e.InvocationInfo.OffsetInLine; // the stop which occurs after attaching is not associated with a breakpoint and should result in the remote process' script being opened _callback.DebuggerStopped(new DebuggerStoppedEventArgs(file, lineNum, column, false, true)); _needToCopyRemoteScript = false; break; default: _callback.DebuggerStopped(new DebuggerStoppedEventArgs()); break; } } } bool resumed = false; while (!resumed) { _pausedEvent.WaitOne(); try { currScenario = GetDebugScenario(); if (!string.IsNullOrEmpty(_debuggingCommand)) { if (currScenario == DebugScenario.Local) { // local debugging var output = new Collection <PSObject>(); using (var pipeline = (_runspace.CreateNestedPipeline())) { pipeline.Commands.AddScript(_debuggingCommand); pipeline.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); output = pipeline.Invoke(); } ProcessDebuggingCommandResults(output); } else { // remote session and local attach debugging ProcessRemoteDebuggingCommandResults(ExecuteDebuggingCommand()); } } else { ServiceCommon.Log(string.Format("Debuggee resume action is {0}", _resumeAction)); e.ResumeAction = _resumeAction; resumed = true; // debugger resumed executing } } catch (Exception ex) { NotifyOutputString(ex.Message); } // Notify the debugging command execution call that debugging command was complete. _debugCommandEvent.Set(); } }
public void SetDebuggerStopped(DebuggerStopEventArgs args) { IsStopped = true; LastStopEventArgs = args; }
public DebuggerDialog(DebuggerStopEventArgs e) { _InvocationInfo = e.InvocationInfo; int maxLine = 0; string[] lines = null; if (!string.IsNullOrEmpty(e.InvocationInfo.ScriptName) && File.Exists(e.InvocationInfo.ScriptName)) { try { lines = File.ReadAllLines(e.InvocationInfo.ScriptName, Encoding.Default); foreach (string s in lines) { if (s.Length > maxLine) { maxLine = s.Length; } } } catch (IOException) { } } int dw = Math.Max(Math.Min(Far.Api.UI.WindowSize.X - 7, maxLine + 12), 73); int dh = 22; string title; int h1; if (e.Breakpoints.Count > 0) { title = "DEBUG: Hit breakpoint(s)"; h1 = e.Breakpoints.Count + 2; } else { title = "DEBUG: Step"; h1 = 2; } _Dialog = Far.Api.CreateDialog(-1, -1, dw, dh); _Dialog.HelpTopic = Far.Api.GetHelpTopic("DebuggerDialog"); _Dialog.AddBox(3, 1, dw - 4, dh - 2, title); _List1 = _Dialog.AddListBox(4, 2, dw - 5, h1 + 1, null); _List1.Disabled = true; _List1.NoBox = true; _List1.NoClose = true; _List1.NoFocus = true; if (e.Breakpoints.Count > 0) { foreach (Breakpoint bp in e.Breakpoints) { CommandBreakpoint bpc = bp as CommandBreakpoint; if (bpc != null && Kit.Equals(bpc.Command, Commands.AssertFarCommand.MyName)) { A.InvokeCode("Remove-PSBreakpoint -Breakpoint $args[0]", bpc); } } } foreach (string s in e.InvocationInfo.PositionMessage.Trim().Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)) { _List1.Add(s); } _Dialog.AddText(0, -_List1.Rect.Height, 0, null).Separator = 1; _List2 = _Dialog.AddListBox(4, _List1.Rect.Bottom + 2, dw - 5, dh - 5, null); _List2.NoBox = true; _List2.NoClose = true; if (lines != null) { foreach (string s in lines) { _List2.Add(s); } int i = e.InvocationInfo.ScriptLineNumber - 1; _List2.Items[i].Checked = true; } _Dialog.AddText(0, -_List2.Rect.Height, 0, null).Separator = 1; _Step = _Dialog.AddButton(0, -1, BtnStep); _Step.CenterGroup = true; _Over = _Dialog.AddButton(0, 0, BtnOver); _Over.CenterGroup = true; _Out = _Dialog.AddButton(0, 0, BtnOut); _Out.CenterGroup = true; _Console = _Dialog.AddButton(0, 0, BtnInteractive); _Console.CenterGroup = true; _Console.NoBrackets = true; _Edit = _Dialog.AddButton(0, 0, BtnEdit); _Edit.CenterGroup = true; _Edit.NoBrackets = true; // to be completed on show _View = _Dialog.AddButton(0, 0, BtnView); _View.CenterGroup = true; _View.NoBrackets = true; _View.NoClose = true; _Goto = _Dialog.AddButton(0, 0, BtnLine); _Goto.CenterGroup = true; _Goto.NoBrackets = true; _Goto.NoClose = true; _Goto.ButtonClicked += OnGoto; _Quit = _Dialog.AddButton(0, 0, BtnQuit); _Quit.CenterGroup = true; _Quit.NoBrackets = true; _Dialog.Initialized += OnInitialized; }
internal async void OnDebuggerStopAsync(object sender, DebuggerStopEventArgs e) { bool noScriptName = false; string localScriptPath = e.InvocationInfo.ScriptName; // If there's no ScriptName, get the "list" of the current source if (this.remoteFileManager != null && string.IsNullOrEmpty(localScriptPath)) { // Get the current script listing and create the buffer PSCommand command = new PSCommand(); command.AddScript($"list 1 {int.MaxValue}"); IEnumerable <PSObject> scriptListingLines = await this.powerShellContext.ExecuteCommandAsync <PSObject>( command, false, false).ConfigureAwait(false); if (scriptListingLines != null) { int linePrefixLength = 0; string scriptListing = string.Join( Environment.NewLine, scriptListingLines .Select(o => DebugService.TrimScriptListingLine(o, ref linePrefixLength)) .Where(s => s != null)); this.temporaryScriptListingPath = this.remoteFileManager.CreateTemporaryFile( $"[{this.powerShellContext.CurrentRunspace.SessionDetails.ComputerName}] {TemporaryScriptFileName}", scriptListing, this.powerShellContext.CurrentRunspace); localScriptPath = this.temporaryScriptListingPath ?? StackFrameDetails.NoFileScriptPath; noScriptName = localScriptPath != null; } else { this.logger.LogWarning($"Could not load script context"); } } // Get call stack and variables. await this.FetchStackFramesAndVariablesAsync( noScriptName?localScriptPath : null).ConfigureAwait(false); // If this is a remote connection and the debugger stopped at a line // in a script file, get the file contents if (this.powerShellContext.CurrentRunspace.Location == RunspaceLocation.Remote && this.remoteFileManager != null && !noScriptName) { localScriptPath = await this.remoteFileManager.FetchRemoteFileAsync( e.InvocationInfo.ScriptName, powerShellContext.CurrentRunspace).ConfigureAwait(false); } if (this.stackFrameDetails.Length > 0) { // Augment the top stack frame with details from the stop event if (this.invocationTypeScriptPositionProperty .GetValue(e.InvocationInfo) is IScriptExtent scriptExtent) { this.stackFrameDetails[0].StartLineNumber = scriptExtent.StartLineNumber; this.stackFrameDetails[0].EndLineNumber = scriptExtent.EndLineNumber; this.stackFrameDetails[0].StartColumnNumber = scriptExtent.StartColumnNumber; this.stackFrameDetails[0].EndColumnNumber = scriptExtent.EndColumnNumber; } } this.CurrentDebuggerStoppedEventArgs = new DebuggerStoppedEventArgs( e, this.powerShellContext.CurrentRunspace, localScriptPath); // Notify the host that the debugger is stopped this.DebuggerStopped?.Invoke( sender, this.CurrentDebuggerStoppedEventArgs); }
private void HandleDebuggerStop(object sender, DebuggerStopEventArgs e) { this.RaiseDebuggerStopEvent(e); }
/// <summary> /// Creates a new instance of the DebuggerStoppedEventArgs class. /// </summary> /// <param name="originalEvent">The original DebuggerStopEventArgs instance from which this instance is based.</param> /// <param name="runspaceInfo">The RunspaceDetails of the runspace which raised this event.</param> public DebuggerStoppedEventArgs( DebuggerStopEventArgs originalEvent, IRunspaceInfo runspaceInfo) : this(originalEvent, runspaceInfo, null) { }
private void OnDebuggerStop(object sender, DebuggerStopEventArgs e) { Logger.Write(LogLevel.Verbose, "Debugger stopped execution."); // Set the task so a result can be set this.debuggerStoppedTask = new TaskCompletionSource <DebuggerResumeAction>(); // Save the pipeline thread ID and create the pipeline execution task this.pipelineThreadId = Thread.CurrentThread.ManagedThreadId; this.pipelineExecutionTask = new TaskCompletionSource <IPipelineExecutionRequest>(); // Update the session state this.OnSessionStateChanged( this, new SessionStateChangedEventArgs( PowerShellContextState.Ready, PowerShellExecutionResult.Stopped, null)); // Write out the debugger prompt // TODO: Eventually re-enable this and put it behind a setting, #133 //this.WritePromptWithNestedPipeline(); // Raise the event for the debugger service if (this.DebuggerStop != null) { this.DebuggerStop(sender, e); } Logger.Write(LogLevel.Verbose, "Starting pipeline thread message loop..."); while (true) { int taskIndex = Task.WaitAny( this.debuggerStoppedTask.Task, this.pipelineExecutionTask.Task); if (taskIndex == 0) { // Write a new output line before continuing // TODO: Re-enable this with fix for #133 //this.WriteOutput("", true); e.ResumeAction = this.debuggerStoppedTask.Task.Result; Logger.Write(LogLevel.Verbose, "Received debugger resume action " + e.ResumeAction.ToString()); break; } else if (taskIndex == 1) { Logger.Write(LogLevel.Verbose, "Received pipeline thread execution request."); IPipelineExecutionRequest executionRequest = this.pipelineExecutionTask.Task.Result; this.pipelineExecutionTask = new TaskCompletionSource <IPipelineExecutionRequest>(); executionRequest.Execute().Wait(); Logger.Write(LogLevel.Verbose, "Pipeline thread execution completed."); this.pipelineResultTask.SetResult(executionRequest); } else { // TODO: How to handle this? } } // Clear the task so that it won't be used again this.debuggerStoppedTask = null; }
private void Debugger_DebuggerStop(object sender, DebuggerStopEventArgs e) { //Console.WriteLine(e); }
void debugService_DebuggerStopped(object sender, DebuggerStopEventArgs e) { this.debuggerStoppedQueue.Enqueue(e); }
private void DebuggerOnDebuggerStop(object sender, DebuggerStopEventArgs args) { Debugger debugger = sender as Debugger; DebuggerResumeAction?resumeAction = null; DebuggingInBreakpoint = true; try { if ( ((ScriptingHostUserInterface)host.UI).CheckSessionCanDoInteractiveAction( nameof(DebuggerOnDebuggerStop), false)) { var output = new PSDataCollection <PSObject>(); output.DataAdded += (dSender, dArgs) => { foreach (var item in output.ReadAll()) { host.UI.WriteLine(item.ToString()); } }; var message = Message.Parse(this, "ise:breakpointhit"); //var position = args.InvocationInfo.DisplayScriptPosition; IScriptExtent position; try { position = args.InvocationInfo.GetType() .GetProperty("ScriptPosition", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetProperty) .GetValue(args.InvocationInfo) as IScriptExtent; } catch (Exception) { position = args.InvocationInfo.DisplayScriptPosition; } if (position != null) { message.Arguments.Add("Line", (position.StartLineNumber - 1).ToString()); message.Arguments.Add("Column", (position.StartColumnNumber - 1).ToString()); message.Arguments.Add("EndLine", (position.EndLineNumber - 1).ToString()); message.Arguments.Add("EndColumn", (position.EndColumnNumber - 1).ToString()); } else { message.Arguments.Add("Line", (args.InvocationInfo.ScriptLineNumber - 1).ToString()); message.Arguments.Add("Column", (args.InvocationInfo.OffsetInLine - 1).ToString()); message.Arguments.Add("EndLine", (args.InvocationInfo.ScriptLineNumber).ToString()); message.Arguments.Add("EndColumn", (0).ToString()); } message.Arguments.Add("HitCount", args.Breakpoints.Count > 0 ? args.Breakpoints[0].HitCount.ToString() : "1"); SendUiMessage(message); while (resumeAction == null && !abortRequested) { if (ImmediateCommand is string commandString) { PowerShellLog.Info($"Executing a debug command in ScriptSession '{Key}'."); PowerShellLog.Debug(commandString); DebuggerCommandResults results = null; try { var psCommand = new PSCommand(); var scriptCommand = new Command(commandString, true) { MergeUnclaimedPreviousCommandResults = PipelineResultTypes.Warning }; psCommand.AddCommand(scriptCommand) .AddCommand(OutDefaultCommand); results = debugger?.ProcessCommand(psCommand, output); ImmediateResults = output; LogErrors(null, output.ToList()); } catch (Exception ex) { PowerShellLog.Error("Error while executing Debugging command.", ex); ImmediateCommand = null; host.UI.WriteErrorLine(GetExceptionString(ex, ExceptionStringFormat.Default)); } if (results?.ResumeAction != null) { resumeAction = results.ResumeAction; } ImmediateCommand = null; } else { Thread.Sleep(20); } } args.ResumeAction = resumeAction ?? DebuggerResumeAction.Continue; } } finally { DebuggingInBreakpoint = false; } }
/// <summary> /// Creates a new instance of the DebuggerStoppedEventArgs class. /// </summary> /// <param name="originalEvent">The original DebuggerStopEventArgs instance from which this instance is based.</param> /// <param name="runspaceDetails">The RunspaceDetails of the runspace which raised this event.</param> public DebuggerStoppedEventArgs( DebuggerStopEventArgs originalEvent, RunspaceDetails runspaceDetails) : this(originalEvent, runspaceDetails, null) { }