This is an archive of the discontinued LLVM Phabricator instance.

Differential D7834

Remove redundant code from lldb-mi.
ClosedPublic

Authored by abidh on Feb 23 2015, 10:16 AM.

Details

Reviewers
clayborg
ki.stfu
Commits
rG04b1b5dc9d6a: Remove redundant code from lldb-mi.
rLLDB230345: Remove redundant code from lldb-mi.
rL230345: Remove redundant code from lldb-mi.
Summary

After recent changes, some code has become redundant. This revision tries to remove
the un-used code and tidy up the rest.

Following 4 files have been removed. I have updated CMake files and checked that it builds
fine on Linux and Windows. Can somebody update the xcode related file accordingly?

tools/lldb-mi/MICmnStreamStdinLinux.cpp
tools/lldb-mi/MICmnStreamStdinLinux.h
tools/lldb-mi/MICmnStreamStdinWindows.cpp
tools/lldb-mi/MICmnStreamStdinWindows.h

Diff Detail

Event Timeline

abidh updated this revision to Diff 20521.Feb 23 2015, 10:16 AM
abidh retitled this revision from to Remove redundant code from lldb-mi..
abidh updated this object.
abidh edited the test plan for this revision. (Show Details)
abidh added reviewers: clayborg, ki.stfu.
abidh added a subscriber: Unknown Object (MLST).
clayborg accepted this revision.Feb 23 2015, 10:52 AM
clayborg edited edge metadata.

Looks good.

This revision is now accepted and ready to land.Feb 23 2015, 10:52 AM
ki.stfu accepted this revision.Feb 24 2015, 8:11 AM
ki.stfu edited edge metadata.

Looks good. All tests pass on OS X.

tools/lldb-mi/MICmnStreamStdin.cpp
90–92

Can you add extra lines here? :)

}

m_bInitialized = bOk;

return MIstatus::success;
abidh closed this revision.Feb 24 2015, 9:10 AM

Revision Contents

Diff 20521

tools/lldb-mi/CMakeLists.txt

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Linesadd_lldb_executable(lldb-mi
MICmnMIValue.cpp MICmnMIValue.cpp
MICmnMIValueConst.cpp MICmnMIValueConst.cpp
MICmnMIValueList.cpp MICmnMIValueList.cpp
MICmnMIValueResult.cpp MICmnMIValueResult.cpp
MICmnMIValueTuple.cpp MICmnMIValueTuple.cpp
MICmnResources.cpp MICmnResources.cpp
MICmnStreamStderr.cpp MICmnStreamStderr.cpp
MICmnStreamStdin.cpp MICmnStreamStdin.cpp
MICmnStreamStdinLinux.cpp
MICmnStreamStdinWindows.cpp
MICmnStreamStdout.cpp MICmnStreamStdout.cpp
MICmnThreadMgrStd.cpp MICmnThreadMgrStd.cpp
MIDriver.cpp MIDriver.cpp
MIDriverBase.cpp MIDriverBase.cpp
MIDriverMain.cpp MIDriverMain.cpp
MIDriverMgr.cpp MIDriverMgr.cpp
MIUtilDateTimeStd.cpp MIUtilDateTimeStd.cpp
MIUtilDebug.cpp MIUtilDebug.cpp
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Linesadd_lldb_executable(lldb-mi
MICmnMIValue.cpp MICmnMIValue.cpp
MICmnMIValueConst.cpp MICmnMIValueConst.cpp
MICmnMIValueList.cpp MICmnMIValueList.cpp
MICmnMIValueResult.cpp MICmnMIValueResult.cpp
MICmnMIValueTuple.cpp MICmnMIValueTuple.cpp
MICmnResources.cpp MICmnResources.cpp
MICmnStreamStderr.cpp MICmnStreamStderr.cpp
MICmnStreamStdin.cpp MICmnStreamStdin.cpp
MICmnStreamStdinLinux.cpp
MICmnStreamStdinWindows.cpp
MICmnStreamStdout.cpp MICmnStreamStdout.cpp
MICmnThreadMgrStd.cpp MICmnThreadMgrStd.cpp
MIDriver.cpp MIDriver.cpp
MIDriverBase.cpp MIDriverBase.cpp
MIDriverMain.cpp MIDriverMain.cpp
MIDriverMgr.cpp MIDriverMgr.cpp
MIUtilDateTimeStd.cpp MIUtilDateTimeStd.cpp
MIUtilDebug.cpp MIUtilDebug.cpp
Show All 26 Lines

tools/lldb-mi/MICmnStreamStdin.h

Show All 31 Lines
// Singleton class using the Visitor pattern. A driver using the interface // Singleton class using the Visitor pattern. A driver using the interface
// provide can receive callbacks when a new line of data is received. // provide can receive callbacks when a new line of data is received.
// Each line is determined by a carriage return. // Each line is determined by a carriage return.
// A singleton class. // A singleton class.
// Gotchas: None. // Gotchas: None.
// Authors: Illya Rudkin 10/02/2014. // Authors: Illya Rudkin 10/02/2014.
// Changes: Factored out OS specific handling of reading stdin - IOR 16/06/2014. // Changes: Factored out OS specific handling of reading stdin - IOR 16/06/2014.
//-- //--
class CMICmnStreamStdin : public CMICmnBase, public CMIUtilThreadActiveObjBase, public MI::ISingleton<CMICmnStreamStdin> class CMICmnStreamStdin : public CMICmnBase, public MI::ISingleton<CMICmnStreamStdin>
{ {
// Give singleton access to private constructors // Give singleton access to private constructors
friend MI::ISingleton<CMICmnStreamStdin>; friend MI::ISingleton<CMICmnStreamStdin>;
// Class:
public:
//++
// Description: Visitor pattern. Driver(s) use this interface to get a callback
// on each new line of data received from stdin.
//--
class IStreamStdin
{
public:
virtual bool ReadLine(const CMIUtilString &vStdInBuffer, bool &vrwbYesExit) = 0;
/* dtor */ virtual ~IStreamStdin(void){};
};
//++
// Description: Specific OS stdin handling implementations are created and used by *this
// class. Seperates out functionality and enables handler to be set
// dynamically depended on the OS detected.
//--
class IOSStdinHandler
{
public:
virtual bool InputAvailable(bool &vwbAvail) = 0;
virtual const MIchar *ReadLine(CMIUtilString &vwErrMsg) = 0;
virtual void InterruptReadLine(void){};
/* dtor */ virtual ~IOSStdinHandler(void){};
};
// Methods: // Methods:
public: public:
bool Initialize(void); bool Initialize(void);
bool Shutdown(void); bool Shutdown(void);
// //
const CMIUtilString &GetPrompt(void) const; const CMIUtilString &GetPrompt(void) const;
bool SetPrompt(const CMIUtilString &vNewPrompt); bool SetPrompt(const CMIUtilString &vNewPrompt);
void SetEnablePrompt(const bool vbYes); void SetEnablePrompt(const bool vbYes);
bool GetEnablePrompt(void) const; bool GetEnablePrompt(void) const;
void SetCtrlCHit(void);
bool SetVisitor(IStreamStdin &vrVisitor);
bool SetOSStdinHandler(IOSStdinHandler &vrHandler);
void OnExitHandler(void);
const MIchar *ReadLine(CMIUtilString &vwErrMsg); const MIchar *ReadLine(CMIUtilString &vwErrMsg);
// Overridden:
public:
// From CMIUtilThreadActiveObjBase
virtual const CMIUtilString &ThreadGetName(void) const;
// Overridden:
protected:
// From CMIUtilThreadActiveObjBase
virtual bool ThreadRun(bool &vrIsAlive);
virtual bool
ThreadFinish(void); // Let this thread clean up after itself
// Methods: // Methods:
private: private:
/* ctor */ CMICmnStreamStdin(void); /* ctor */ CMICmnStreamStdin(void);
/* ctor */ CMICmnStreamStdin(const CMICmnStreamStdin &); /* ctor */ CMICmnStreamStdin(const CMICmnStreamStdin &);
void operator=(const CMICmnStreamStdin &); void operator=(const CMICmnStreamStdin &);
bool MonitorStdin(bool &vrwbYesExit);
bool
InputAvailable(bool &vbAvail); // Bytes are available on stdin
// Overridden: // Overridden:
private: private:
// From CMICmnBase // From CMICmnBase
/* dtor */ virtual ~CMICmnStreamStdin(void); /* dtor */ virtual ~CMICmnStreamStdin(void);
// Attributes: // Attributes:
private: private:
const CMIUtilString m_constStrThisThreadname;
IStreamStdin *m_pVisitor;
CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user CMIUtilString m_strPromptCurrent; // Command line prompt as shown to the user
volatile bool m_bKeyCtrlCHit; // True = User hit Ctrl-C, false = has not yet
bool m_bShowPrompt; // True = Yes prompt is shown/output to the user (stdout), false = no prompt 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 bool m_bRedrawPrompt; // True = Prompt needs to be redrawn
IOSStdinHandler *m_pStdinReadHandler;
static const int m_constBufferSize = 2048; static const int m_constBufferSize = 2048;
MIchar *m_pCmdBuffer; MIchar *m_pCmdBuffer;
}; };

tools/lldb-mi/MICmnStreamStdin.cpp

Show All 18 Lines
// Copyright: None. // Copyright: None.
//-- //--
// In-house headers: // In-house headers:
#include "MICmnStreamStdin.h" #include "MICmnStreamStdin.h"
#include "MICmnStreamStdout.h" #include "MICmnStreamStdout.h"
#include "MICmnResources.h" #include "MICmnResources.h"
#include "MICmnLog.h" #include "MICmnLog.h"
#include "MICmnThreadMgrStd.h"
#include "MIUtilSingletonHelper.h" #include "MIUtilSingletonHelper.h"
#include "MIDriver.h"
#if defined(_MSC_VER)
#include "MIUtilSystemWindows.h"
#include "MICmnStreamStdinWindows.h"
#else
#include "MICmnStreamStdinLinux.h"
#endif // defined( _MSC_VER )
#include <string.h> // For std::strerror() #include <string.h> // For std::strerror()
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdin constructor. // Details: CMICmnStreamStdin constructor.
// Type: Method. // Type: Method.
// Args: None. // Args: None.
// Return: None. // Return: None.
// Throws: None. // Throws: None.
//-- //--
CMICmnStreamStdin::CMICmnStreamStdin(void) CMICmnStreamStdin::CMICmnStreamStdin(void)
: m_constStrThisThreadname("MI stdin thread") : m_strPromptCurrent("(gdb)")
, m_pVisitor(nullptr)
, m_strPromptCurrent("(gdb)")
, m_bKeyCtrlCHit(false)
, m_bShowPrompt(true) , m_bShowPrompt(true)
, m_bRedrawPrompt(true) , m_bRedrawPrompt(true)
, m_pStdinReadHandler(nullptr)
, m_pCmdBuffer(nullptr) , m_pCmdBuffer(nullptr)
{ {
} }
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdin destructor. // Details: CMICmnStreamStdin destructor.
// Type: Overridable. // Type: Overridable.
// Args: None. // Args: None.
Show All 22 Lines if (m_bInitialized)
return MIstatus::success; return MIstatus::success;
bool bOk = MIstatus::success; bool bOk = MIstatus::success;
CMIUtilString errMsg; CMIUtilString errMsg;
// Note initialisation order is important here as some resources depend on previous // Note initialisation order is important here as some resources depend on previous
MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg); MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg); MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
MI::ModuleInit<CMICmnThreadMgrStd>(IDS_MI_INIT_ERR_THREADMGR, bOk, errMsg);
#ifdef _MSC_VER
MI::ModuleInit<CMICmnStreamStdinWindows>(IDS_MI_INIT_ERR_OS_STDIN_HANDLER, bOk, errMsg);
bOk = bOk && SetOSStdinHandler(CMICmnStreamStdinWindows::Instance());
#else
MI::ModuleInit<CMICmnStreamStdinLinux>(IDS_MI_INIT_ERR_OS_STDIN_HANDLER, bOk, errMsg);
bOk = bOk && SetOSStdinHandler(CMICmnStreamStdinLinux::Instance());
#endif // ( _MSC_VER )
// The OS specific stdin stream handler must be set before *this class initialises
if (bOk && m_pStdinReadHandler == nullptr)
{
CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_STREAMSTDIN_OSHANDLER), errMsg.c_str()));
SetErrorDescription(strInitError);
return MIstatus::failure;
}
if (bOk) if (bOk)
m_pCmdBuffer = new MIchar[m_constBufferSize];
// Other resources required
if (bOk)
{ {
m_bKeyCtrlCHit = false; // Reset m_pCmdBuffer = new MIchar[m_constBufferSize];
} }
else
m_bInitialized = bOk;
if (!bOk)
{ {
CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_STREAMSTDIN), errMsg.c_str())); CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_STREAMSTDIN), errMsg.c_str()));
SetErrorDescription(strInitError); SetErrorDescription(strInitError);
return MIstatus::failure; return MIstatus::failure;
} }
m_bInitialized = bOk;
return MIstatus::success; return MIstatus::success;
ki.stfuUnsubmitted
Not Done
ReplyInline Actions

Can you add extra lines here? :)

}

m_bInitialized = bOk;

return MIstatus::success;
ki.stfu: Can you add extra lines here? :) ``` } m_bInitialized = bOk; return MIstatus…
} }
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: Release resources for *this Stdin stream. // Details: Release resources for *this Stdin stream.
// Type: Method. // Type: Method.
// Args: None. // Args: None.
// Return: MIstatus::success - Functional succeeded. // Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed. // MIstatus::failure - Functional failed.
Show All 16 LinesCMICmnStreamStdin::Shutdown(void)
{ {
delete[] m_pCmdBuffer; delete[] m_pCmdBuffer;
m_pCmdBuffer = nullptr; m_pCmdBuffer = nullptr;
} }
bool bOk = MIstatus::success; bool bOk = MIstatus::success;
CMIUtilString errMsg; CMIUtilString errMsg;
m_pVisitor = nullptr;
m_bKeyCtrlCHit = false;
// Note shutdown order is important here
#ifndef _MSC_VER
MI::ModuleShutdown<CMICmnStreamStdinLinux>(IDS_MI_SHTDWN_ERR_OS_STDIN_HANDLER, bOk, errMsg);
#else
MI::ModuleShutdown<CMICmnStreamStdinWindows>(IDS_MI_SHTDWN_ERR_OS_STDIN_HANDLER, bOk, errMsg);
#endif // ( _MSC_VER )
MI::ModuleShutdown<CMICmnThreadMgrStd>(IDS_MI_SHTDWN_ERR_THREADMGR, bOk, errMsg);
MI::ModuleShutdown<CMICmnResources>(IDE_MI_SHTDWN_ERR_RESOURCES, bOk, errMsg); MI::ModuleShutdown<CMICmnResources>(IDE_MI_SHTDWN_ERR_RESOURCES, bOk, errMsg);
MI::ModuleShutdown<CMICmnLog>(IDS_MI_SHTDWN_ERR_LOG, bOk, errMsg); MI::ModuleShutdown<CMICmnLog>(IDS_MI_SHTDWN_ERR_LOG, bOk, errMsg);
if (!bOk) if (!bOk)
{ {
SetErrorDescriptionn(MIRSRC(IDE_MI_SHTDWN_ERR_STREAMSTDIN), errMsg.c_str()); SetErrorDescriptionn(MIRSRC(IDE_MI_SHTDWN_ERR_STREAMSTDIN), errMsg.c_str());
} }
Show All 32 Lines
//-- //--
const CMIUtilString & const CMIUtilString &
CMICmnStreamStdin::GetPrompt(void) const CMICmnStreamStdin::GetPrompt(void) const
{ {
return m_strPromptCurrent; return m_strPromptCurrent;
} }
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: Wait on input from stream Stdin. On each line of input received it is
// validated and providing there are no errors on the stream or the input
// buffer is not exceeded the data is passed to the visitor.
// Type: Method.
// Args: vrVisitor - (W) A client deriver callback.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::SetVisitor(IStreamStdin &vrVisitor)
{
m_pVisitor = &vrVisitor;
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Set whether to display optional command line prompt. The prompt is output to // Details: Set whether to display optional command line prompt. The prompt is output to
// stdout. Disable it when this may interfere with the client reading stdout as // stdout. Disable it when this may interfere with the client reading stdout as
// input and it tries to interpret the prompt text to. // input and it tries to interpret the prompt text to.
// Type: Method. // Type: Method.
// Args: vbYes - (R) True = Yes prompt is shown/output to the user (stdout), false = no prompt. // Args: vbYes - (R) True = Yes prompt is shown/output to the user (stdout), false = no prompt.
// Return: MIstatus::success - Functional succeeded. // Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed. // MIstatus::failure - Functional failed.
// Throws: None. // Throws: None.
Show All 15 Lines
//-- //--
bool bool
CMICmnStreamStdin::GetEnablePrompt(void) const CMICmnStreamStdin::GetEnablePrompt(void) const
{ {
return m_bShowPrompt; return m_bShowPrompt;
} }
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: Determine if stdin has any characters present in its buffer.
// Type: Method.
// Args: vwbAvail - (W) True = There is chars available, false = nothing there.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::InputAvailable(bool &vwbAvail)
{
return m_pStdinReadHandler->InputAvailable(vwbAvail);
}
//++ ------------------------------------------------------------------------------------
// Details: The monitoring on new line data calls back to the visitor object registered
// with *this stdin monitoring. The monitoring to stops when the visitor returns
// true for bYesExit flag. Errors output to log file.
// This function runs in the thread "MI stdin monitor".
// Type: Method.
// vrwbYesAlive - (W) False = yes exit stdin monitoring, true = continue monitor.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::MonitorStdin(bool &vrwbYesAlive)
{
if (m_bShowPrompt)
{
CMICmnStreamStdout &rStdoutMan = CMICmnStreamStdout::Instance();
rStdoutMan.WriteMIResponse(m_strPromptCurrent.c_str());
m_bRedrawPrompt = false;
}
// CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
if (m_bKeyCtrlCHit)
{
CMIDriver &rMIDriver = CMIDriver::Instance();
rMIDriver.SetExitApplicationFlag(false);
if (rMIDriver.GetExitApplicationFlag())
{
vrwbYesAlive = false;
return MIstatus::success;
}
// Reset - the MI Driver received SIGINT during a running debug programm session
m_bKeyCtrlCHit = false;
}
#if MICONFIG_POLL_FOR_STD_IN
bool bAvail = true;
// Check if there is stdin available
if (InputAvailable(bAvail))
{
// Early exit when there is no input
if (!bAvail)
return MIstatus::success;
}
else
{
vrwbYesAlive = false;
CMIDriver::Instance().SetExitApplicationFlag(true);
return MIstatus::failure;
}
#endif // MICONFIG_POLL_FOR_STD_IN
// Read a line from std input
CMIUtilString stdinErrMsg;
const MIchar *pText = ReadLine(stdinErrMsg);
// Did something go wrong
const bool bHaveError(!stdinErrMsg.empty());
if ((pText == nullptr) || bHaveError)
{
if (bHaveError)
{
CMICmnStreamStdout::Instance().Write(stdinErrMsg);
}
return MIstatus::failure;
}
// We have text so send it off to the visitor
bool bOk = MIstatus::success;
if (m_pVisitor != nullptr)
{
bool bYesExit = false;
bOk = m_pVisitor->ReadLine(CMIUtilString(pText), bYesExit);
m_bRedrawPrompt = true;
vrwbYesAlive = !bYesExit;
}
return bOk;
}
//++ ------------------------------------------------------------------------------------
// Details: Wait on new line of data from stdin stream (completed by '\n' or '\r'). // Details: Wait on new line of data from stdin stream (completed by '\n' or '\r').
// Type: Method. // Type: Method.
// Args: vwErrMsg - (W) Empty string ok or error description. // Args: vwErrMsg - (W) Empty string ok or error description.
// Return: MIchar * - text buffer pointer or NULL on failure. // Return: MIchar * - text buffer pointer or NULL on failure.
// Throws: None. // Throws: None.
//-- //--
const MIchar * const MIchar *
CMICmnStreamStdin::ReadLine(CMIUtilString &vwErrMsg) CMICmnStreamStdin::ReadLine(CMIUtilString &vwErrMsg)
Show All 16 Lines for (MIchar *pI = m_pCmdBuffer; *pI != '\0'; pI++)
{ {
*pI = '\0'; *pI = '\0';
break; break;
} }
} }
return pText; return pText;
} }
//++ ------------------------------------------------------------------------------------
// Details: Inform *this stream that the user hit Control-C key to exit.
// The function is normally called by the SIGINT signal in sigint_handler() to
// simulate kill app from the client.
// This function is called by a Kernel thread.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
void
CMICmnStreamStdin::SetCtrlCHit(void)
{
CMIUtilThreadLock lock(m_mutex);
m_bKeyCtrlCHit = true;
}
//++ ------------------------------------------------------------------------------------
// Details: The main worker method for this thread.
// Type: Overridden.
// Args: vrbIsAlive - (W) True = *this thread is working, false = thread has exited.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::ThreadRun(bool &vrbIsAlive)
{
return MonitorStdin(vrbIsAlive);
}
//++ ------------------------------------------------------------------------------------
// Details: Let this thread clean up after itself.
// Type: Overridden.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::ThreadFinish(void)
{
// Do nothing - override to implement
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Retrieve *this thread object's name.
// Type: Overridden.
// Args: None.
// Return: CMIUtilString & - Text.
// Throws: None.
//--
const CMIUtilString &
CMICmnStreamStdin::ThreadGetName(void) const
{
return m_constStrThisThreadname;
}
//++ ------------------------------------------------------------------------------------
// Details: Mandatory set the OS specific stream stdin handler. *this class utilises the
// handler to read data from the stdin stream and put into a queue for the
// driver to read when able.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdin::SetOSStdinHandler(IOSStdinHandler &vrHandler)
{
m_pStdinReadHandler = &vrHandler;
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Do some actions before exiting.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
void
CMICmnStreamStdin::OnExitHandler(void)
{
m_pStdinReadHandler->InterruptReadLine();
}

tools/lldb-mi/MICmnStreamStdinLinux.h

  • This file was deleted.
//===-- MICmnStreamStdinWindows.h --------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MIUtilStreamStdin.h
//
// Overview: CMICmnStreamStdinLinux interface.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
#pragma once
// In-house headers:
#include "MICmnBase.h"
#include "MICmnStreamStdin.h"
#include "MIUtilSingletonBase.h"
//++ ============================================================================
// Details: MI common code class. Specific OS stdin handling implementation.
// CMICmnStreamStdin instance is set with stdin handler before using the
// the stream. An instance of this class must be set up and ready to give
// to the CMICmnStreamStdin before it initialises other CMICmnStreamStdin
// will give an error.
// Gotchas: None.
// Authors: Illya Rudkin 16/06/2014.
// Changes: None.
//--
class CMICmnStreamStdinLinux : public CMICmnBase, public CMICmnStreamStdin::IOSStdinHandler, public MI::ISingleton<CMICmnStreamStdinLinux>
{
// Give singleton access to private constructors
friend MI::ISingleton<CMICmnStreamStdinLinux>;
// Methods:
public:
bool Initialize(void);
bool Shutdown(void);
// Overridden:
public:
// From CMICmnStreamStdin::IOSpecificReadStreamStdin
virtual bool InputAvailable(bool &vwbAvail);
virtual const MIchar *ReadLine(CMIUtilString &vwErrMsg);
virtual void InterruptReadLine(void);
// Methods:
private:
/* ctor */ CMICmnStreamStdinLinux(void);
/* ctor */ CMICmnStreamStdinLinux(const CMICmnStreamStdin &);
void operator=(const CMICmnStreamStdin &);
// Overridden:
private:
// From CMICmnBase
/* dtor */ virtual ~CMICmnStreamStdinLinux(void);
// Attributes:
private:
const MIuint m_constBufferSize;
FILE *m_pStdin;
MIchar *m_pCmdBuffer;
bool m_waitForInput;
};

tools/lldb-mi/MICmnStreamStdinLinux.cpp

  • This file was deleted.
//===-- MICmnStreamStdinLinux.cpp --------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MIUtilStreamStdin.cpp
//
// Overview: CMICmnStreamStdinLinux implementation.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
// Third Party Headers:
#ifndef _WIN32
#include <sys/select.h>
#include <unistd.h> // For STDIN_FILENO
#endif
#include <string.h> // For std::strerror()
// In-house headers:
#include "MICmnStreamStdinLinux.h"
#include "MICmnLog.h"
#include "MICmnResources.h"
#include "MIUtilSingletonHelper.h"
//++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdinLinux constructor.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
CMICmnStreamStdinLinux::CMICmnStreamStdinLinux(void)
: m_constBufferSize(1024)
, m_pStdin(nullptr)
, m_pCmdBuffer(nullptr)
, m_waitForInput(true)
{
}
//++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdinLinux destructor.
// Type: Overridable.
// Args: None.
// Return: None.
// Throws: None.
//--
CMICmnStreamStdinLinux::~CMICmnStreamStdinLinux(void)
{
Shutdown();
}
//++ ------------------------------------------------------------------------------------
// Details: Initialize resources for *this Stdin stream.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinLinux::Initialize(void)
{
if (m_bInitialized)
return MIstatus::success;
bool bOk = MIstatus::success;
CMIUtilString errMsg;
// Note initialisation order is important here as some resources depend on previous
MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
// Other resources required
if (bOk)
{
m_pCmdBuffer = new MIchar[m_constBufferSize];
m_pStdin = stdin;
}
// Clear error indicators for std input
::clearerr(stdin);
m_bInitialized = bOk;
if (!bOk)
{
CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_OS_STDIN_HANDLER), errMsg.c_str()));
SetErrorDescription(strInitError);
return MIstatus::failure;
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Release resources for *this Stdin stream.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinLinux::Shutdown(void)
{
if (!m_bInitialized)
return MIstatus::success;
m_bInitialized = false;
ClrErrorDescription();
bool bOk = MIstatus::success;
CMIUtilString errMsg;
// Tidy up
if (m_pCmdBuffer != nullptr)
{
delete[] m_pCmdBuffer;
m_pCmdBuffer = nullptr;
}
m_pStdin = nullptr;
// Note shutdown order is important here
MI::ModuleShutdown<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
MI::ModuleShutdown<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
if (!bOk)
{
SetErrorDescriptionn(MIRSRC(IDS_MI_SHTDWN_ERR_OS_STDIN_HANDLER), errMsg.c_str());
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Determine if stdin has any characters present in its buffer.
// Type: Method.
// Args: vwbAvail - (W) True = There is chars available, false = nothing there.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinLinux::InputAvailable(bool &vwbAvail)
{
#ifndef _WIN32
// Wait for the input using select API. Timeout is used so that we get an
// opportunity to check if m_waitForInput has been set to false by other thread.
fd_set setOfStdin;
struct timeval tv;
while (m_waitForInput)
{
FD_ZERO(&setOfStdin);
FD_SET(STDIN_FILENO, &setOfStdin);
tv.tv_sec = 1;
tv.tv_usec = 0;
int ret = ::select(STDIN_FILENO + 1, &setOfStdin, nullptr, nullptr, &tv);
if (ret == 0) // Timeout. Loop back if m_waitForInput is true
continue;
else if (ret == -1) // Error condition. Return
{
vwbAvail = false;
return MIstatus::failure;
}
else // Have some valid input
{
vwbAvail = true;
return MIstatus::success;
}
}
#endif
return MIstatus::failure;
}
//++ ------------------------------------------------------------------------------------
// Details: Wait on new line of data from stdin stream (completed by '\n' or '\r').
// Type: Method.
// Args: vwErrMsg - (W) Empty string ok or error description.
// Return: MIchar * - text buffer pointer or NULL on failure.
// Throws: None.
//--
const MIchar *
CMICmnStreamStdinLinux::ReadLine(CMIUtilString &vwErrMsg)
{
vwErrMsg.clear();
// Read user input
const MIchar *pText = ::fgets(&m_pCmdBuffer[0], m_constBufferSize, stdin);
if (pText == nullptr)
{
if (::ferror(m_pStdin) != 0)
vwErrMsg = ::strerror(errno);
return nullptr;
}
// Strip off new line characters
for (MIchar *pI = m_pCmdBuffer; *pI != '\0'; pI++)
{
if ((*pI == '\n') || (*pI == '\r'))
{
*pI = '\0';
break;
}
}
return pText;
}
//++ ------------------------------------------------------------------------------------
// Details: Interrupt current and prevent new ReadLine operations.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
void
CMICmnStreamStdinLinux::InterruptReadLine(void)
{
m_waitForInput = false;
}

tools/lldb-mi/MICmnStreamStdinWindows.h

  • This file was deleted.
//===-- MICmnStreamStdinWindows.h -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MIUtilStreamStdin.h
//
// Overview: CMICmnStreamStdinWindows interface.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
#pragma once
// In-house headers:
#include "MICmnBase.h"
#include "MICmnStreamStdin.h"
#include "MIUtilSingletonBase.h"
//++ ============================================================================
// Details: MI common code class. Specific OS stdin handling implementation.
// CMICmnStreamStdin instance is set with stdin handler before using the
// the stream. An instance of this class must be set up and ready to give
// to the CMICmnStreamStdin before it initialises other CMICmnStreamStdin
// will give an error.
// Gotchas: None.
// Authors: Illya Rudkin 16/06/2014.
// Changes: None.
//--
class CMICmnStreamStdinWindows : public CMICmnBase,
public CMICmnStreamStdin::IOSStdinHandler,
public MI::ISingleton<CMICmnStreamStdinWindows>
{
// Give singleton access to private constructors
friend MI::ISingleton<CMICmnStreamStdinWindows>;
// Methods:
public:
bool Initialize(void);
bool Shutdown(void);
// Overridden:
public:
// From CMICmnStreamStdin::IOSpecificReadStreamStdin
virtual bool InputAvailable(bool &vwbAvail);
virtual const MIchar *ReadLine(CMIUtilString &vwErrMsg);
// Methods:
private:
/* ctor */ CMICmnStreamStdinWindows(void);
/* ctor */ CMICmnStreamStdinWindows(const CMICmnStreamStdinWindows &);
void operator=(const CMICmnStreamStdinWindows &);
//
bool InputAvailableConsoleWin(bool &vwbAvail);
bool InputAvailableApplication(bool &vwbAvail);
// Overridden:
private:
// From CMICmnBase
/* dtor */ virtual ~CMICmnStreamStdinWindows(void);
// Attributes:
private:
const MIuint m_constBufferSize;
FILE *m_pStdin;
MIchar *m_pCmdBuffer;
MIchar *m_pStdinBuffer; // Custom buffer to store std input
MIuint m_nBytesToBeRead; // Checks that ::fgets() is holding on to data while ::PeekNamedPipe() returns nothing which causes a problem
bool m_bRunningInConsoleWin; // True = The application is being run in a Windows command line prompt window, false = by other means
};

tools/lldb-mi/MICmnStreamStdinWindows.cpp

  • This file was deleted.
//===-- MICmnStreamStdinWindows.cpp -----------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MIUtilStreamStdin.cpp
//
// Overview: CMICmnStreamStdinWindows implementation.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
// Third Party Headers:
#if defined(_MSC_VER)
#include <stdio.h>
#include <Windows.h>
#include <io.h>
#include <conio.h>
#endif // defined( _MSC_VER )
#include <string.h>
// In-house headers:
#include "MICmnStreamStdinWindows.h"
#include "MICmnLog.h"
#include "MICmnResources.h"
#include "MIUtilSystemWindows.h"
#include "MIUtilSingletonHelper.h"
//++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdinWindows constructor.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
CMICmnStreamStdinWindows::CMICmnStreamStdinWindows(void)
: m_constBufferSize(1024)
, m_pStdin(nullptr)
, m_pCmdBuffer(nullptr)
, m_pStdinBuffer(nullptr)
, m_nBytesToBeRead(0)
, m_bRunningInConsoleWin(false)
{
}
//++ ------------------------------------------------------------------------------------
// Details: CMICmnStreamStdinWindows destructor.
// Type: Overridable.
// Args: None.
// Return: None.
// Throws: None.
//--
CMICmnStreamStdinWindows::~CMICmnStreamStdinWindows(void)
{
Shutdown();
}
//++ ------------------------------------------------------------------------------------
// Details: Initialize resources for *this Stdin stream.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinWindows::Initialize(void)
{
if (m_bInitialized)
return MIstatus::success;
bool bOk = MIstatus::success;
CMIUtilString errMsg;
// Note initialisation order is important here as some resources depend on previous
MI::ModuleInit<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
MI::ModuleInit<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
// Other resources required
if (bOk)
{
m_pCmdBuffer = new MIchar[m_constBufferSize];
m_pStdin = stdin;
#if MICONFIG_CREATE_OWN_STDIN_BUFFER
// Give stdinput a user defined buffer
m_pStdinBuffer = new char[1024];
::setbuf(stdin, m_pStdinBuffer);
#endif // MICONFIG_CREATE_OWN_STDIN_BUFFER
// Clear error indicators for std input
::clearerr(stdin);
#if defined(_MSC_VER)
m_bRunningInConsoleWin = ::_isatty(::fileno(stdin));
#endif // #if defined( _MSC_VER )
}
m_bInitialized = bOk;
if (!bOk)
{
CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_OS_STDIN_HANDLER), errMsg.c_str()));
SetErrorDescription(strInitError);
return MIstatus::failure;
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Release resources for *this Stdin stream.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinWindows::Shutdown(void)
{
if (!m_bInitialized)
return MIstatus::success;
m_bInitialized = false;
ClrErrorDescription();
bool bOk = MIstatus::success;
CMIUtilString errMsg;
// Tidy up
if (m_pCmdBuffer != nullptr)
{
delete[] m_pCmdBuffer;
m_pCmdBuffer = nullptr;
}
m_pStdin = nullptr;
#if MICONFIG_CREATE_OWN_STDIN_BUFFER
if (m_pStdinBuffer)
delete[] m_pStdinBuffer;
m_pStdinBuffer = nullptr;
#endif // MICONFIG_CREATE_OWN_STDIN_BUFFER
// Note shutdown order is important here
MI::ModuleShutdown<CMICmnResources>(IDS_MI_INIT_ERR_RESOURCES, bOk, errMsg);
MI::ModuleShutdown<CMICmnLog>(IDS_MI_INIT_ERR_LOG, bOk, errMsg);
if (!bOk)
{
SetErrorDescriptionn(MIRSRC(IDS_MI_SHTDWN_ERR_OS_STDIN_HANDLER), errMsg.c_str());
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Determine if stdin has any characters present in its buffer.
// Type: Method.
// Args: vwbAvail - (W) True = There is chars available, false = nothing there.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinWindows::InputAvailable(bool &vwbAvail)
{
return m_bRunningInConsoleWin ? InputAvailableConsoleWin(vwbAvail) : InputAvailableApplication(vwbAvail);
}
//++ ------------------------------------------------------------------------------------
// Details: Determine if stdin has any characters present in its buffer. If running in a
// terminal use _kbhit().
// Type: Method.
// Args: vwbAvail - (W) True = There is chars available, false = nothing there.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinWindows::InputAvailableConsoleWin(bool &vwbAvail)
{
#if defined(_MSC_VER)
if (m_nBytesToBeRead == 0)
{
// Get a windows handle to std input stream
HANDLE handle = ::GetStdHandle(STD_INPUT_HANDLE);
DWORD nBytesWaiting = ::_kbhit();
// Save the number of bytes to be read so that we can check if input is available to be read
m_nBytesToBeRead = nBytesWaiting;
// Return state of whether bytes are waiting or not
vwbAvail = (nBytesWaiting > 0);
}
#endif // #if defined( _MSC_VER )
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Determine if stdin has any characters present in its buffer.
// Type: Method.
// Args: vwbAvail - (W) True = There is chars available, false = nothing there.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMICmnStreamStdinWindows::InputAvailableApplication(bool &vwbAvail)
{
#if defined(_MSC_VER)
if (m_nBytesToBeRead == 0)
{
// Get a windows handle to std input stream
HANDLE handle = ::GetStdHandle(STD_INPUT_HANDLE);
DWORD nBytesWaiting = 0;
// Ask how many bytes are available
if (::PeekNamedPipe(handle, nullptr, 0, nullptr, &nBytesWaiting, nullptr) == FALSE)
{
// This can occur when the client i.e. Eclipse closes the stdin stream 'cause it deems its work is finished
// for that debug session. May be we should be handling SIGKILL somehow?
const CMIUtilString osErrMsg(CMIUtilSystemWindows().GetOSLastError().StripCRAll());
SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_STDIN_ERR_CHKING_BYTE_AVAILABLE), osErrMsg.c_str()));
return MIstatus::failure;
}
// Save the number of bytes to be read so that we can check if input is available to be read
m_nBytesToBeRead = nBytesWaiting;
// Return state of whether bytes are waiting or not
vwbAvail = (nBytesWaiting > 0);
}
#endif // #if defined( _MSC_VER )
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Wait on new line of data from stdin stream (completed by '\n' or '\r').
// Type: Method.
// Args: vwErrMsg - (W) Empty string ok or error description.
// Return: MIchar * - text buffer pointer or NULL on failure.
// Throws: None.
//--
const MIchar *
CMICmnStreamStdinWindows::ReadLine(CMIUtilString &vwErrMsg)
{
vwErrMsg.clear();
// Read user input
const MIchar *pText = ::fgets(&m_pCmdBuffer[0], m_constBufferSize, stdin);
if (pText == nullptr)
{
if (::ferror(m_pStdin) != 0)
vwErrMsg = ::strerror(errno);
return nullptr;
}
// Subtract the number of bytes read so that we can check if input is available to be read
m_nBytesToBeRead = m_nBytesToBeRead - ::strlen(pText);
// Strip off new line characters
for (MIchar *pI = m_pCmdBuffer; *pI != '\0'; pI++)
{
if ((*pI == '\n') || (*pI == '\r'))
{
*pI = '\0';
break;
}
}
return pText;
}

tools/lldb-mi/MIDriver.cpp

Show First 20 Lines • Show All 949 Lines • ▼ Show 20 Lines
//-- //--
void void
CMIDriver::SetExitApplicationFlag(const bool vbForceExit) CMIDriver::SetExitApplicationFlag(const bool vbForceExit)
{ {
if (vbForceExit) if (vbForceExit)
{ {
CMIUtilThreadLock lock(m_threadMutex); CMIUtilThreadLock lock(m_threadMutex);
m_bExitApp = true; m_bExitApp = true;
m_rStdin.OnExitHandler();
return; return;
} }
// CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM // CODETAG_DEBUG_SESSION_RUNNING_PROG_RECEIVED_SIGINT_PAUSE_PROGRAM
// Did we receive a SIGINT from the client during a running debug program, if // Did we receive a SIGINT from the client during a running debug program, if
// so then SIGINT is not to be taken as meaning kill the MI driver application // so then SIGINT is not to be taken as meaning kill the MI driver application
// but halt the inferior program being debugged instead // but halt the inferior program being debugged instead
if (m_eCurrentDriverState == eDriverState_RunningDebugging) if (m_eCurrentDriverState == eDriverState_RunningDebugging)
{ {
InterpretCommand("-exec-interrupt"); InterpretCommand("-exec-interrupt");
return; return;
} }
m_bExitApp = true; m_bExitApp = true;
m_rStdin.OnExitHandler();
} }
//++ ------------------------------------------------------------------------------------ //++ ------------------------------------------------------------------------------------
// Details: Get the MI Driver's exit exit application flag. // Details: Get the MI Driver's exit exit application flag.
// This is related to the running state of the MI driver. // This is related to the running state of the MI driver.
// Type: Method. // Type: Method.
// Args: None. // Args: None.
// Return: bool - True = MI Driver is shutting down, false = MI driver is running. // Return: bool - True = MI Driver is shutting down, false = MI driver is running.
▲ Show 20 Lines • Show All 243 Lines • Show Last 20 Lines
tools/lldb-mi/MICmnStreamStdinLinux.cpp