maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/tools/lldb-mi/MIDriverMgr.cpp

781 lines
26 KiB
C++
Raw Blame History

//===-- MIDriverMgr.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//++
// File: MIDriverMgr.cpp
//
// Overview: CMIDriverMgr implementation.
//
// Environment: Compilers: Visual C++ 12.
// gcc (Ubuntu/Linaro 4.8.1-10ubuntu9) 4.8.1
// Libraries: See MIReadmetxt.
//
// Copyright: None.
//--
// Third Party Headers:
#include "lldb/API/SBError.h"
// In-house headers:
#include "MIDriverMgr.h"
#include "MICmnResources.h"
#include "MICmnLog.h"
#include "MICmnLogMediumFile.h"
#include "MIDriver.h"
#include "MIUtilTermios.h"
#include "MICmnStreamStdout.h"
#include "MIUtilSingletonHelper.h"
//++ ------------------------------------------------------------------------------------
// Details: CMIDriverMgr constructor.
// Type: Method.
// Args: None.
// Return: None.
// Throws: None.
//--
CMIDriverMgr::CMIDriverMgr(void)
: m_pDriverCurrent(nullptr)
, m_bInMi2Mode(false)
{
}
//++ ------------------------------------------------------------------------------------
// Details: CMIDriverMgr destructor.
// Type: Overridden.
// Args: None.
// Return: None.
// Throws: None.
//--
CMIDriverMgr::~CMIDriverMgr(void)
{
Shutdown();
}
//++ ------------------------------------------------------------------------------------
// Details: Initialize *this manager.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::Initialize(void)
{
m_clientUsageRefCnt++;
ClrErrorDescription();
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);
if (bOk)
{
MIUtilTermios::StdinTermiosSet();
}
m_bInitialized = bOk;
if (!bOk)
{
CMIUtilString strInitError(CMIUtilString::Format(MIRSRC(IDS_MI_INIT_ERR_DRIVERMGR), errMsg.c_str()));
SetErrorDescription(strInitError);
return MIstatus::failure;
}
return bOk;
}
//++ ------------------------------------------------------------------------------------
// Details: Unbind detach or release resources used by this server in general common
// functionality shared between versions of any server interfaces implemented.
// Type: Method.
// Args: vbAppExitOk - (R) True = No problems, false = App exiting with problems (investigate!).
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::Shutdown(void)
{
// Do not want a ref counter because this function needs to be called how ever this
// application stops running
// if( --m_clientUsageRefCnt > 0 )
// return MIstatus::success;
bool vbAppExitOk = true;
ClrErrorDescription();
if (!m_bInitialized)
return MIstatus::success;
if (vbAppExitOk)
{
#if _DEBUG
CMICmnStreamStdout::Instance().Write(MIRSRC(IDE_MI_APP_EXIT_OK)); // Both stdout and Log
#else
CMICmnLog::WriteLog(MIRSRC(IDE_MI_APP_EXIT_OK)); // Just to the Log
#endif // _DEBUG
}
else
{
CMICmnLog &rAppLog = CMICmnLog::Instance();
if (rAppLog.GetEnabled())
{
const CMIUtilString msg(
CMIUtilString::Format(MIRSRC(IDE_MI_APP_EXIT_WITH_PROBLEM), CMICmnLogMediumFile::Instance().GetFileName().c_str()));
CMICmnStreamStdout::Instance().Write(msg);
}
else
{
const CMIUtilString msg(
CMIUtilString::Format(MIRSRC(IDE_MI_APP_EXIT_WITH_PROBLEM_NO_LOG), CMICmnLogMediumFile::Instance().GetFileName().c_str()));
CMICmnStreamStdout::Instance().Write(msg);
}
}
m_bInitialized = false;
bool bOk = MIstatus::success;
CMIUtilString errMsg;
// Tidy up
UnregisterDriverAll();
MIUtilTermios::StdinTermiosReset();
// Note shutdown order is important here
MI::ModuleShutdown<CMICmnResources>(IDE_MI_SHTDWN_ERR_RESOURCES, bOk, errMsg);
MI::ModuleShutdown<CMICmnLog>(IDS_MI_SHTDWN_ERR_LOG, bOk, errMsg);
if (!bOk)
{
SetErrorDescriptionn(MIRSRC(IDS_MI_SHTDWN_ERR_DRIVERMGR), errMsg.c_str());
}
return bOk;
}
//++ ------------------------------------------------------------------------------------
// Details: Unregister all the Driver registered with *this manager. The manager also
// deletes
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::UnregisterDriverAll(void)
{
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.begin();
while (it != m_mapDriverIdToDriver.end())
{
IDriver *pDriver = (*it).second;
pDriver->DoShutdown();
// Next
++it;
}
m_mapDriverIdToDriver.clear();
m_pDriverCurrent = NULL;
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Register a driver with *this Driver Manager. Call SetUseThisDriverToDoWork()
// inform the manager which driver is the one to the work. The manager calls
// the driver's init function which must be successful in order to complete the
// registration.
// Type: Method.
// Args: vrDriver - (R) The driver to register.
// vrDriverID - (R) The driver's ID to lookup by.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::RegisterDriver(const IDriver &vrDriver, const CMIUtilString &vrDriverID)
{
if (HaveDriverAlready(vrDriver))
return MIstatus::success;
IDriver *pDriver = const_cast<IDriver *>(&vrDriver);
if (!pDriver->SetId(vrDriverID))
return MIstatus::failure;
if (!pDriver->DoInitialize())
{
SetErrorDescriptionn(MIRSRC(IDS_DRIVERMGR_DRIVER_ERR_INIT), pDriver->GetName().c_str(), vrDriverID.c_str(),
pDriver->GetError().c_str());
return MIstatus::failure;
}
MapPairDriverIdToDriver_t pr(vrDriverID, pDriver);
m_mapDriverIdToDriver.insert(pr);
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Query the Driver Manager to see if *this manager has the driver already
// registered.
// Type: Method.
// Args: vrDriver - (R) The driver to query.
// Return: True - registered.
// False - not registered.
// Throws: None.
//--
bool
CMIDriverMgr::HaveDriverAlready(const IDriver &vrDriver) const
{
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.begin();
while (it != m_mapDriverIdToDriver.end())
{
const IDriver *pDrvr = (*it).second;
if (pDrvr == &vrDriver)
return true;
// Next
++it;
}
return false;
}
//++ ------------------------------------------------------------------------------------
// Details: Unregister a driver from the Driver Manager. Call the SetUseThisDriverToDoWork()
// function to define another driver to do work if the one being unregistered did
// the work previously.
// Type: Method.
// Args: vrDriver - (R) The driver to unregister.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::UnregisterDriver(const IDriver &vrDriver)
{
const IDriver *pDrvr = nullptr;
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.begin();
while (it != m_mapDriverIdToDriver.end())
{
pDrvr = (*it).second;
if (pDrvr == &vrDriver)
break;
// Next
++it;
}
m_mapDriverIdToDriver.erase(it);
if (m_pDriverCurrent == pDrvr)
m_pDriverCurrent = nullptr;
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Specify the driver to do work. The Driver Manager drives this driver. Any
// previous driver doing work is not called anymore (so be sure the previous
// driver is in a tidy state before stopping it working).
// Type: Method.
// Args: vrADriver - (R) A lldb::SBBroadcaster/IDriver derived object.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::SetUseThisDriverToDoWork(const IDriver &vrADriver)
{
m_pDriverCurrent = const_cast<IDriver *>(&vrADriver);
const CMIUtilString msg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_SAY_DRIVER_USING), m_pDriverCurrent->GetName().c_str()));
m_pLog->Write(msg, CMICmnLog::eLogVerbosity_Log);
m_bInMi2Mode = m_pDriverCurrent->GetDriverIsGDBMICompatibleDriver();
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Ask *this manager which driver is currently doing the work.
// Type: Method.
// Args: None.
// Return: IDriver * - Pointer to a driver, NULL if there is no current working driver.
// Throws: None.
//--
CMIDriverMgr::IDriver *
CMIDriverMgr::GetUseThisDriverToDoWork(void) const
{
return m_pDriverCurrent;
}
//++ ------------------------------------------------------------------------------------
// Details: Call this function puts *this driver to work.
// Type: Method.
// Args: None.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::DriverMainLoop(void)
{
if (m_pDriverCurrent != nullptr)
{
if (!m_pDriverCurrent->DoMainLoop())
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_MAINLOOP), m_pDriverCurrent->GetError().c_str()));
CMICmnStreamStdout::Instance().Write(errMsg, true);
return MIstatus::failure;
}
}
else
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
return MIstatus::failure;
}
return MIstatus::success;
}
//++ ------------------------------------------------------------------------------------
// Details: Call *this driver to resize the console window.
// Type: Method.
// Args: vWindowSizeWsCol - (R) New window column size.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
void
CMIDriverMgr::DriverResizeWindow(const uint32_t vWindowSizeWsCol)
{
if (m_pDriverCurrent != nullptr)
return m_pDriverCurrent->DoResizeWindow(vWindowSizeWsCol);
else
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
}
}
//++ ------------------------------------------------------------------------------------
// Details: Get the current driver to validate executable command line arguments.
// Type: Method.
// Args: argc - (R) An integer that contains the count of arguments that follow in
// argv. The argc parameter is always greater than or equal to 1.
// argv - (R) An array of null-terminated strings representing command-line
// arguments entered by the user of the program. By convention,
// argv[0] is the command with which the program is invoked.
// vpStdOut - (R) Point to a standard output stream.
// vwbExiting - (W) True = *this want to exit, false = continue to work.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Throws: None.
//--
bool
CMIDriverMgr::DriverParseArgs(const int argc, const char *argv[], FILE *vpStdOut, bool &vwbExiting)
{
if (m_pDriverCurrent == nullptr)
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
return MIstatus::failure;
}
const lldb::SBError error(m_pDriverCurrent->DoParseArgs(argc, argv, vpStdOut, vwbExiting));
bool bOk = !error.Fail();
if (!bOk)
{
CMIUtilString errMsg;
const MIchar *pErrorCstr = error.GetCString();
if (pErrorCstr != nullptr)
errMsg = CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_PARSE_ARGS), m_pDriverCurrent->GetName().c_str(), pErrorCstr);
else
errMsg = CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_PARSE_ARGS_UNKNOWN), m_pDriverCurrent->GetName().c_str());
bOk = CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return bOk;
}
//++ ------------------------------------------------------------------------------------
// Details: Retrieve the current driver's last error condition.
// Type: Method.
// Args: None.
// Return: CMIUtilString - Text description.
// Throws: None.
//--
CMIUtilString
CMIDriverMgr::DriverGetError(void) const
{
if (m_pDriverCurrent != nullptr)
return m_pDriverCurrent->GetError();
else
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return CMIUtilString();
}
//++ ------------------------------------------------------------------------------------
// Details: Retrieve the current driver's name.
// Type: Method.
// Args: None.
// Return: CMIUtilString - Driver name.
// Empty string = no current working driver specified.
// Throws: None.
//--
CMIUtilString
CMIDriverMgr::DriverGetName(void) const
{
if (m_pDriverCurrent != nullptr)
return m_pDriverCurrent->GetName();
else
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return CMIUtilString();
}
//++ ------------------------------------------------------------------------------------
// Details: Retrieve the current driver's debugger object.
// Type: Method.
// Args: None.
// Return: lldb::SBDebugger * - Ptr to driver's debugger object.
// - NULL = no current working driver specified.
// Throws: None.
//--
lldb::SBDebugger *
CMIDriverMgr::DriverGetTheDebugger(void)
{
lldb::SBDebugger *pDebugger = nullptr;
if (m_pDriverCurrent != nullptr)
pDebugger = &m_pDriverCurrent->GetTheDebugger();
else
{
const CMIUtilString errMsg(CMIUtilString::Format(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET)));
CMICmnStreamStdout::Instance().Write(errMsg, true);
}
return pDebugger;
}
//++ ------------------------------------------------------------------------------------
// Details: Check the arguments given on the command line. The main purpose of this
// function is to check for the presence of the --interpreter option. Having
// this option present tells *this manager to set the CMIDriver to do work. If
// not use the LLDB driver. The following are options that are only handled by
// the CMIDriverMgr are:
// --help or -h
// --interpreter
// --version
// --versionLong
// --log
// --executable
// The above arguments are not handled by any driver object except for --executable.
// The options --interpreter and --executable in code act very similar. The
// --executable is necessary to differentiate whither the MI Driver is being using
// by a client i.e. Eclipse or from the command line. Eclipse issues the option
// --interpreter and also passes additional arguments which can be interpreted as an
// executable if called from the command line. Using --executable tells the MI
// Driver is being called the command line and that the executable argument is indeed
// a specified executable an so actions commands to set up the executable for a
// debug session. Using --interpreter on the commnd line does not action additional
// commands to initialise a debug session and so be able to launch the process.
// Type: Method.
// Args: argc - (R) An integer that contains the count of arguments that follow in
// argv. The argc parameter is always greater than or equal to 1.
// argv - (R) An array of null-terminated strings representing command-line
// arguments entered by the user of the program. By convention,
// argv[0] is the command with which the program is invoked.
// vwbExiting - (W) True = *this want to exit, Reasons: help, invalid arg(s),
// version information only.
// False = Continue to work, start debugger i.e. Command
// interpreter.
// Return: lldb::SBError - LLDB current error status.
// Throws: None.
//--
bool
CMIDriverMgr::ParseArgs(const int argc, const char *argv[], bool &vwbExiting)
{
bool bOk = MIstatus::success;
vwbExiting = false;
// Print MI application path to the Log file
const CMIUtilString appPath(CMIUtilString::Format(MIRSRC(IDS_MI_APP_FILEPATHNAME), argv[0]));
bOk = m_pLog->Write(appPath, CMICmnLog::eLogVerbosity_Log);
// Print application arguments to the Log file
const bool bHaveArgs(argc >= 2);
CMIUtilString strArgs(MIRSRC(IDS_MI_APP_ARGS));
if (!bHaveArgs)
{
strArgs += MIRSRC(IDS_WORD_NONE);
bOk = bOk && m_pLog->Write(strArgs, CMICmnLog::eLogVerbosity_Log);
}
else
{
for (MIint i = 1; i < argc; i++)
{
strArgs += CMIUtilString::Format("%d:'%s' ", i, argv[i]);
}
bOk = bOk && m_pLog->Write(strArgs, CMICmnLog::eLogVerbosity_Log);
}
// Look for the command line options
bool bHaveArgInterpret = false;
bool bHaveArgVersion = false;
bool bHaveArgVersionLong = false;
bool bHaveArgLog = false;
bool bHaveArgHelp = false;
// Hardcode the use of the MI driver
#if MICONFIG_DEFAULT_TO_MI_DRIVER
bHaveArgInterpret = true;
#endif // MICONFIG_DEFAULT_TO_MI_DRIVER
if (bHaveArgs)
{
// CODETAG_MIDRIVE_CMD_LINE_ARG_HANDLING
for (MIint i = 1; i < argc; i++)
{
// *** Add args to help in GetHelpOnCmdLineArgOptions() ***
const CMIUtilString strArg(argv[i]);
// Argument "--executable" is also check for in CMIDriver::ParseArgs()
if ((0 == strArg.compare("--interpreter")) || // Given by the client such as Eclipse
(0 == strArg.compare("--executable"))) // Used to specify that there is executable argument also on the command line
{ // See fn description.
bHaveArgInterpret = true;
}
if (0 == strArg.compare("--version"))
{
bHaveArgVersion = true;
}
if (0 == strArg.compare("--versionLong"))
{
bHaveArgVersionLong = true;
}
if (0 == strArg.compare("--log"))
{
bHaveArgLog = true;
}
if ((0 == strArg.compare("--help")) || (0 == strArg.compare("-h")))
{
bHaveArgHelp = true;
}
}
}
if (bHaveArgLog)
{
CMICmnLog::Instance().SetEnabled(true);
}
// Todo: Remove this output when MI is finished. It is temporary to persuade Ecllipse plugin to work.
// Eclipse reads this literally and will not work unless it gets this exact version text.
// Handle --version option (ignore the --interpreter option if present)
if (bHaveArgVersion)
{
vwbExiting = true;
bOk = bOk && CMICmnStreamStdout::Instance().WriteMIResponse(MIRSRC(IDE_MI_VERSION_GDB));
return bOk;
}
// Todo: Make this the --version when the the above --version version is removed
// Handle --versionlong option (ignore the --interpreter option if present)
if (bHaveArgVersionLong)
{
vwbExiting = true;
bOk = bOk && CMICmnStreamStdout::Instance().WriteMIResponse(GetAppVersion());
return bOk;
}
// Both '--help' and '--intepreter' means give help for MI only. Without
// '--interpreter' help the LLDB driver is working and so help is for that.
if (bHaveArgHelp && bHaveArgInterpret)
{
vwbExiting = true;
bOk = bOk && CMICmnStreamStdout::Instance().WriteMIResponse(GetHelpOnCmdLineArgOptions());
return bOk;
}
// This makes the assumption that there is at least one MI compatible
// driver registered and one LLDB driver registerd and the CMIDriver
// is the first one found.
// ToDo: Implement a better solution that handle any order, any number
// of drivers. Or this 'feature' may be removed if deemed not required.
IDriver *pLldbDriver = GetFirstNonMIDriver();
IDriver *pMi2Driver = GetFirstMIDriver();
if (bHaveArgInterpret && (pMi2Driver != nullptr))
bOk = bOk && SetUseThisDriverToDoWork(*pMi2Driver);
else if (pLldbDriver != nullptr)
bOk = bOk && SetUseThisDriverToDoWork(*pLldbDriver);
else
{
if (bOk)
{
vwbExiting = true;
const CMIUtilString msg(MIRSRC(IDS_DRIVER_ERR_NON_REGISTERED));
bOk = bOk && CMICmnStreamStdout::Instance().WriteMIResponse(msg);
}
}
return bOk;
}
//++ ------------------------------------------------------------------------------------
// Details: Return formatted application version and name information.
// Type: Method.
// Args: None.
// Return: CMIUtilString - Text data.
// Throws: None.
//--
CMIUtilString
CMIDriverMgr::GetAppVersion(void) const
{
const CMIUtilString strProj(MIRSRC(IDS_PROJNAME));
const CMIUtilString strVsn(CMIDriver::Instance().GetVersionDescription());
const CMIUtilString strGdb(MIRSRC(IDE_MI_VERSION_GDB));
const CMIUtilString strVrsnInfo(CMIUtilString::Format("%s\n%s\n%s", strProj.c_str(), strVsn.c_str(), strGdb.c_str()));
return strVrsnInfo;
}
//++ ------------------------------------------------------------------------------------
// Details: Return formatted help information on all the MI command line options.
// Type: Method.
// Args: None.
// Return: CMIUtilString - Text data.
// Throws: None.
//--
CMIUtilString
CMIDriverMgr::GetHelpOnCmdLineArgOptions(void) const
{
const CMIUtilString pHelp[] = {
MIRSRC(IDE_MI_APP_DESCRIPTION),
MIRSRC(IDE_MI_APP_INFORMATION),
MIRSRC(IDE_MI_APP_ARG_USAGE),
MIRSRC(IDE_MI_APP_ARG_HELP),
MIRSRC(IDE_MI_APP_ARG_VERSION),
MIRSRC(IDE_MI_APP_ARG_VERSION_LONG),
MIRSRC(IDE_MI_APP_ARG_INTERPRETER),
MIRSRC(IDE_MI_APP_ARG_EXECUTEABLE),
CMIUtilString::Format(MIRSRC(IDE_MI_APP_ARG_APP_LOG), CMICmnLogMediumFile::Instance().GetFileName().c_str()),
MIRSRC(IDE_MI_APP_ARG_EXECUTABLE),
MIRSRC(IDS_CMD_QUIT_HELP),
MIRSRC(IDE_MI_APP_ARG_EXAMPLE)};
const MIuint nHelpItems = sizeof pHelp / sizeof pHelp[0];
CMIUtilString strHelp;
for (MIuint i = 0; i < nHelpItems; i++)
{
strHelp += pHelp[i];
strHelp += "\n\n";
}
return strHelp;
}
//++ ------------------------------------------------------------------------------------
// Details: Search the registered drivers and return the first driver which says it is
// GDB/MI compatible i.e. the CMIDriver class.
// Type: Method.
// Args: None.
// Return: IDriver * - Ptr to driver, NULL = no driver found.
// Throws: None.
//--
CMIDriverMgr::IDriver *
CMIDriverMgr::GetFirstMIDriver(void) const
{
IDriver *pDriver = nullptr;
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.begin();
while (it != m_mapDriverIdToDriver.end())
{
const CMIUtilString &rDrvId = (*it).first;
MIunused(rDrvId);
IDriver *pDvr = (*it).second;
if (pDvr->GetDriverIsGDBMICompatibleDriver())
{
pDriver = pDvr;
break;
}
// Next
++it;
}
return pDriver;
}
//++ ------------------------------------------------------------------------------------
// Details: Search the registered drivers and return the first driver which says it is
// not GDB/MI compatible i.e. the LLDB Driver class.
// Type: Method.
// Args: None.
// Return: IDriver * - Ptr to driver, NULL = no driver found.
// Throws: None.
//--
CMIDriverMgr::IDriver *
CMIDriverMgr::GetFirstNonMIDriver(void) const
{
IDriver *pDriver = nullptr;
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.begin();
while (it != m_mapDriverIdToDriver.end())
{
const CMIUtilString &rDrvId = (*it).first;
MIunused(rDrvId);
IDriver *pDvr = (*it).second;
if (!pDvr->GetDriverIsGDBMICompatibleDriver())
{
pDriver = pDvr;
break;
}
// Next
++it;
}
return pDriver;
}
//++ ------------------------------------------------------------------------------------
// Details: Search the registered drivers and return driver with the specified ID.
// Type: Method.
// Args: vrDriverId - (R) ID of a driver.
// Return: IDriver * - Ptr to driver, NULL = no driver found.
// Throws: None.
//--
CMIDriverMgr::IDriver *
CMIDriverMgr::GetDriver(const CMIUtilString &vrDriverId) const
{
MapDriverIdToDriver_t::const_iterator it = m_mapDriverIdToDriver.find(vrDriverId);
if (it == m_mapDriverIdToDriver.end())
return nullptr;
IDriver *pDriver = (*it).second;
return pDriver;
}
Reference in New Issue View Git Blame Copy Permalink