Added Debugger::GetAsync{Output/Error}Stream, and use it to print parse errors when we go to run a breakpoint condition.

llvm-svn: 132517

lldb/include/lldb/Core/Debugger.h

@@ -321,6 +321,12 @@ public:
         return m_error_file;
     }
 
+    lldb::StreamSP
+    GetAsyncOutputStream ();
+    
+    lldb::StreamSP
+    GetAsyncErrorStream ();
+    
     CommandInterpreter &
     GetCommandInterpreter ()
     {

lldb/source/Breakpoint/BreakpointLocation.cpp

@@ -16,6 +16,7 @@
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Breakpoint/BreakpointID.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlan.h"
@@ -219,9 +220,6 @@ BreakpointLocation::ShouldStop (StoppointCallbackContext *context)
     if (m_hit_count <= GetIgnoreCount())
         return false;
 
-    // Next in order of importance is the condition.  See if it is true:
-    StreamString errors;
-
     // We only run synchronous callbacks in ShouldStop:
     context->is_synchronous = true;
     should_stop = InvokeCallback (context);
@@ -230,29 +228,40 @@ BreakpointLocation::ShouldStop (StoppointCallbackContext *context)
     
     if (should_stop)
     {
+        // We need to make sure the user sees any parse errors in their condition, so we'll hook the
+        // constructor errors up to the debugger's Async I/O.
+        
+        StreamString errors;
         ThreadPlanSP condition_plan_sp(GetThreadPlanToTestCondition(context->exe_ctx, errors));
-        log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
-        if (log && errors.GetSize() > 0)
+        
+        if (condition_plan_sp == NULL)
         {
-            log->Printf("Error evaluating condition: \"%s\".\n", errors.GetData());
+            if (log)
+                log->Printf("Error evaluating condition: \"%s\"\n", errors.GetData());
+                
+            Debugger &debugger = context->exe_ctx.target->GetDebugger();
+            StreamSP error_sp = debugger.GetAsyncErrorStream ();
+            error_sp->PutCString ("Error parsing breakpoint condition:\n");
+            error_sp->PutCString (errors.GetData());
+            error_sp->EOL();                       
+            error_sp->Flush();
+
         }
-        else if (condition_plan_sp != NULL)
+        else
         {
+            // Queue our condition, then continue so that we can run it.
             context->exe_ctx.thread->QueueThreadPlan(condition_plan_sp, false);
-            return false;
+            should_stop = false;
         }
     }
     
-    if (should_stop)
+    if (log)
     {
-        log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
-        if (log)
-        {
-            StreamString s;
-            GetDescription (&s, lldb::eDescriptionLevelVerbose);
-            log->Printf ("Hit breakpoint location: %s\n", s.GetData());
-        }
+        StreamString s;
+        GetDescription (&s, lldb::eDescriptionLevelVerbose);
+        log->Printf ("Hit breakpoint location: %s, %s.\n", s.GetData(), should_stop ? "stopping" : "continuing");
     }
+    
     return should_stop;
 }
 

lldb/source/Commands/CommandObjectBreakpointCommand.cpp

@@ -803,10 +803,8 @@ CommandObjectBreakpointCommand::BreakpointOptionsCallbackFunction
             // Rig up the results secondary output stream to the debugger's, so the output will come out synchronously
             // if the debugger is set up that way.
                 
-            StreamSP output_stream (new StreamAsynchronousIO (debugger.GetCommandInterpreter(),
-                                                              CommandInterpreter::eBroadcastBitAsynchronousOutputData));
-            StreamSP error_stream (new StreamAsynchronousIO (debugger.GetCommandInterpreter(),
-                                                             CommandInterpreter::eBroadcastBitAsynchronousErrorData));
+            StreamSP output_stream (debugger.GetAsyncOutputStream());
+            StreamSP error_stream (debugger.GetAsyncErrorStream());
             result.SetImmediateOutputStream (output_stream);
             result.SetImmediateErrorStream (error_stream);
     

lldb/source/Core/Debugger.cpp

@@ -13,6 +13,7 @@
 #include "lldb/Core/InputReader.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/State.h"
+#include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/Terminal.h"
@@ -600,6 +601,20 @@ Debugger::ActivateInputReader (const InputReaderSP &reader_sp)
     }
 }
 
+StreamSP
+Debugger::GetAsyncOutputStream ()
+{
+    return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
+                                               CommandInterpreter::eBroadcastBitAsynchronousOutputData));
+}
+
+StreamSP
+Debugger::GetAsyncErrorStream ()
+{
+    return StreamSP (new StreamAsynchronousIO (GetCommandInterpreter(),
+                                               CommandInterpreter::eBroadcastBitAsynchronousErrorData));
+}    
+
 DebuggerSP
 Debugger::FindDebuggerWithID (lldb::user_id_t id)
 {

lldb/source/Target/Target.cpp

@@ -1199,12 +1199,8 @@ Target::RunStopHooks ()
     if (num_exe_ctx == 0)
         return;
     
-    StreamSP output_stream (new StreamAsynchronousIO (m_debugger.GetCommandInterpreter(),
-                                                      CommandInterpreter::eBroadcastBitAsynchronousOutputData));
-    StreamSP error_stream (new StreamAsynchronousIO (m_debugger.GetCommandInterpreter(),
-                                                     CommandInterpreter::eBroadcastBitAsynchronousErrorData));
-    result.SetImmediateOutputStream (output_stream);
-    result.SetImmediateErrorStream (error_stream);
+    result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream());
+    result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream());
     
     bool keep_going = true;
     bool hooks_ran = false;