Refactor lldb-mi's prompt

[ki.stfu]

Summary

This patch fixes/cleans code around of (gdb) prompt:

1. Add CMICmnStreamStdout::WritePrompt
2. Clean up CMICmnStreamStdout::TextToStdout (don't lock the m_mutex twice because it will be locked in CMICmnStreamStdout::WritePriv)
3. Remove unused CMICmnStreamStdin::m_bShowPrompt field
4. Refactor CMICmnLLDBDebuggerHandleEvents to use CMICmnStreamStdout::WritePrompt instead of TextToStdout("(gdb)")
5. Refactor CMIDriver to use CMICmnStreamStdout::WritePrompt instead of ` if (bOk && m_rStdin.GetEnablePrompt()) bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt()); `

[abidh]

Looks good apart from one inline comment.

tools/lldb-mi/MICmnStreamStdout.cpp

221

Do we really need this function now? It can be merged in the function below.

[ki.stfu]

tools/lldb-mi/MICmnStreamStdout.cpp

221

Yep. It is used in few places:

$ grep -rn "CMICmnStreamStdout::TextToStdout" tools/lldb-mi/
tools/lldb-mi//MICmdCmdBreak.cpp:572:        bOk = bOk && CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
tools/lldb-mi//MICmdCmdBreak.cpp:712:        bOk = bOk && CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
tools/lldb-mi//MICmdCmdMiscellanous.cpp:485:        CMICmnStreamStdout::TextToStdout(strMsg);
tools/lldb-mi//MICmnLLDBDebuggerHandleEvents.cpp:1741:    return CMICmnStreamStdout::TextToStdout(vrTxt);
tools/lldb-mi//MICmnStreamStdout.cpp:217:CMICmnStreamStdout::TextToStdout(const CMIUtilString &vrTxt)
tools/lldb-mi//MIDriver.cpp:1223:    bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
tools/lldb-mi//MIDriver.cpp:1291:        bOk = CMICmnStreamStdout::TextToStdout(strCommand);

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

if (nStopReason == m_SIGINT || nStopReason == m_SIGSTOP)
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst6(strThreadId);
         const CMICmnMIValueResult miValueResult6("thread-id", miValueConst6);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult6);
         const CMICmnMIValueConst miValueConst7("all");
         const CMICmnMIValueResult miValueResult7("stopped-threads", miValueConst7);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult7);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
     else if (nStopReason == m_SIGSEGV)
     {
         // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGSEGV\",signal-meaning=\"Segmentation
         // fault\",thread-id=\"%d\",frame={%s}"
         const CMICmnMIValueConst miValueConst("signal-received");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
else
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst3(strThreadId);
         const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst4("all");
         const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Asynchronous event handler for LLDB Process stop exception.
 // Type:    Method.
 // Args:    None.
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopException(void)
     const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbThread.GetIndexID()));
     const CMICmnMIValueConst miValueConst3(strThreadId);
     const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3);
     bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
     const CMICmnMIValueConst miValueConst4("all");
     const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4);
     bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
     bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
-    bOk = bOk && TextToStdout("(gdb)");
+    bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form partial MI response in a MI value tuple object.
 // Type:    Method.
 // Args:    vwrMiValueTuple   - (W) MI value tuple object.
if (nFrame == 0)
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", vBrkPt.GetThreadIndex()));
         const CMICmnMIValueConst miValueConst5(strThreadId);
         const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult5);
         const CMICmnMIValueConst miValueConst6("all");
         const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult6);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
         return bOk;
     }
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
 
     // MI print
     // "*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"%d\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\""
     const CMICmnMIValueConst miValueConst("breakpoint-hit");
if (bOk)
         bOk = miOutOfBandRecord.Add(miValueResult8);
     }
     if (bOk)
     {
         const CMICmnMIValueConst miValueConst9("all");
         const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9);
         bOk = miOutOfBandRecord.Add(miValueResult9);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Asynchronous event handler for LLDB Process stop reason trace.
 // Type:    Method.
if (nFrame == 0)
         // MI print "*stopped,reason=\"trace\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("trace");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("all");
         const CMICmnMIValueResult miValueResult2("stopped-threads", miValueConst2);
         bOk = miOutOfBandRecord.Add(miValueResult2);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
         return bOk;
     }
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
 
     // MI print
     // "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[\"%s\"],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\""
 
if (bOk)
         bOk = miOutOfBandRecord.Add(miValueResult8);
     }
     if (bOk)
     {
         const CMICmnMIValueConst miValueConst9("all");
         const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9);
         bOk = miOutOfBandRecord.Add(miValueResult9);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && TextToStdout("(gdb)");
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Asynchronous function update selected thread.
 // Type:    Method.

 //--
 bool
 CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateRunning(void)
 {
     CMICmnMIValueConst miValueConst("all");
     CMICmnMIValueResult miValueResult("thread-id", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Running, miValueResult);
     bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
-    bOk = bOk && TextToStdout("(gdb)");
+    bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Print to stdout "=thread-exited,id=\"%ld\",group-id=\"i1\"",
 //                          "=thread-group-exited,id=\"i1\",exit-code=\"0\""),
 //                          "*stopped,reason=\"exited-normally\"",
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateExited(void)
     }
     if (bOk)
     {
         CMICmnMIValueConst miValueConst4("exited-normally");
         CMICmnMIValueResult miValueResult4("reason", miValueConst4);
         CMICmnMIOutOfBandRecord miOutOfBandRecord3(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult4);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord3);
     }
-    bOk = bOk && TextToStdout("(gdb)");
+    bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Drain all stdout so we don't see any output come after we print our prompts.
 //          The process has stuff waiting for stdout; get it and write it out to the
 //          appropriate place.
while (it != rSessionInfo.m_vecActiveThreadId.end())
             // Remove current thread from cache and get next
             it = rSessionInfo.m_vecActiveThreadId.erase(it);
         }
         else
             // Next
             ++it;
     }
 
-    return TextToStdout("(gdb)");
+    return CMICmnStreamStdout::WritePrompt();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Take a fully formed MI result record and send to the stdout stream.
 //          Also output to the MI Log file.
 // Type:    Method.
 // Args:    vrMiResultRecord  - (R) MI result record object.
 // Return:  MIstatus::success - Functionality succeeded.

tools/lldb-mi/MICmnStreamStdin.h

class CMICmnStreamStdin : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdin>
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnStreamStdin(void);
 
     // Attributes:
   private:
     CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user
     bool m_bShowPrompt;               // True = Yes prompt is shown/output to the user (stdout), false = no prompt
-    bool m_bRedrawPrompt;             // True = Prompt needs to be redrawn
     static const int m_constBufferSize = 2048;
     MIchar *m_pCmdBuffer;
 };

tools/lldb-mi/MICmnStreamStdin.cpp

 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnStreamStdin::CMICmnStreamStdin(void)
     : m_strPromptCurrent("(gdb)")
     , m_bShowPrompt(true)
-    , m_bRedrawPrompt(true)
     , m_pCmdBuffer(nullptr)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmnStreamStdin destructor.
 // Type:    Overridable.
 // Args:    None.

tools/lldb-mi/MICmnStreamStdout.h

 //--
 class CMICmnStreamStdout : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdout>
 {
     friend class MI::ISingleton<CMICmnStreamStdout>;
 
     // Statics:
   public:
     static bool TextToStdout(const CMIUtilString &vrTxt);
+    static bool WritePrompt(void);
 
     // Methods:
   public:
     bool Initialize(void);
     bool Shutdown(void);
     //
     bool Lock(void);
     bool Unlock(void);

tools/lldb-mi/MICmnStreamStdout.cpp

 // Args:    vrTxt   - (R) Text.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmnStreamStdout::TextToStdout(const CMIUtilString &vrTxt)
 {
-    const bool bLock = CMICmnStreamStdout::Instance().Lock();
-    const bool bOk = bLock && CMICmnStreamStdout::Instance().WriteMIResponse(vrTxt);
-    bLock &&CMICmnStreamStdout::Instance().Unlock();
+    const bool bSendToLog = true;
+    return CMICmnStreamStdout::Instance().WriteMIResponse(vrTxt, bSendToLog);
+}
 
-    return bOk;
+//++ ------------------------------------------------------------------------------------
+// Details: Write prompt to stdout if it's enabled.
+// Type:    Static method.
+// Args:    None.
+// Return:  MIstatus::success - Function succeeded.
+//          MIstatus::failure - Function failed.
+// Throws:  None.
+//--
+bool
+CMICmnStreamStdout::WritePrompt(void)
+{
+    const CMICmnStreamStdin &rStdinMan = CMICmnStreamStdin::Instance();
+    if (rStdinMan.GetEnablePrompt())
+        return TextToStdout(rStdinMan.GetPrompt());
+    return MIstatus::success;
 }

tools/lldb-mi/MIDriver.cpp

while (bOk && !m_bExitApp)
                 {
                     // Lock Mutex before processing commands so that we don't disturb an event
                     // being processed
                     CMIUtilThreadLock lock(CMICmnLLDBDebugSessionInfo::Instance().GetSessionMutex());
                     bOk = InterpretCommand(lineText);
                 }
 
                 // Draw prompt if desired
-                if (bOk && m_rStdin.GetEnablePrompt())
-                    bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
+                bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
                 // Wait while the handler thread handles incoming events
                 CMICmnLLDBDebugger::Instance().WaitForHandleEvent();
             }
         }
     }
 
     // Signal that the application is shutting down

 // Args:    None.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::InitClientIDEEclipse(void) const
 {
-    return CMICmnStreamStdout::TextToStdout("(gdb)");
+    return CMICmnStreamStdout::WritePrompt();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Ask *this driver whether it found an executable in the MI Driver's list of
 //          arguments which to open and debug. If so instigate commands to set up a debug
 //          session for that executable.
 // Type:    Method.
 // Args:    None.

 // Throws:  None.
 //--
 bool
 CMIDriver::LocalDebugSessionStartupExecuteCommands(void)
 {
     const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.AddSlashes().c_str()));
     bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
     bOk = bOk && InterpretCommand(strCmd);
-    if (bOk && m_rStdin.GetEnablePrompt())
-        bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
+    bOk = bOk && CMICmnStreamStdout::WritePrompt();
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Set the MI Driver into "its debugging an executable passed as an argument"
 //          mode as against running via a client like Eclipse.
 // Type:    Method.
 // Args:    None.
while (!m_bExitApp && std::getline(ifsStartScript, strCommand))
         // Execute if no error
         if (bOk)
         {
             CMIUtilThreadLock lock(rSessionInfo.GetSessionMutex());
             bOk = InterpretCommand(strCommand);
         }
 
         // Draw the prompt after command will be executed (if enabled)
-        if (bOk && m_rStdin.GetEnablePrompt())
-            bOk = m_rStdOut.WriteMIResponse(m_rStdin.GetPrompt());
+        bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
         // Exit if there is an error
         if (!bOk)
         {
             const bool bForceExit = true;
             SetExitApplicationFlag(bForceExit);
             break;
         }