forked from OSchip/llvm-project
752 lines
25 KiB
C++
752 lines
25 KiB
C++
//===-- MIDriverMgr.cpp -----------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Third Party Headers:
|
|
#include "lldb/API/SBError.h"
|
|
|
|
// In-house headers:
|
|
#include "MICmnLog.h"
|
|
#include "MICmnLogMediumFile.h"
|
|
#include "MICmnResources.h"
|
|
#include "MICmnStreamStdout.h"
|
|
#include "MIDriver.h"
|
|
#include "MIDriverMgr.h"
|
|
#include "MIUtilSingletonHelper.h"
|
|
|
|
//++
|
|
//------------------------------------------------------------------------------------
|
|
// Details: CMIDriverMgr constructor.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
CMIDriverMgr::CMIDriverMgr() : m_pDriverCurrent(nullptr), m_bInMi2Mode(false) {}
|
|
|
|
//++
|
|
//------------------------------------------------------------------------------------
|
|
// Details: CMIDriverMgr destructor.
|
|
// Type: Overridden.
|
|
// Args: None.
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
CMIDriverMgr::~CMIDriverMgr() { Shutdown(); }
|
|
|
|
//++
|
|
//------------------------------------------------------------------------------------
|
|
// Details: Initialize *this manager.
|
|
// Type: Method.
|
|
// Args: None.
|
|
// Return: MIstatus::success - Functional succeeded.
|
|
// MIstatus::failure - Functional failed.
|
|
// Throws: None.
|
|
//--
|
|
bool CMIDriverMgr::Initialize() {
|
|
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);
|
|
|
|
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() {
|
|
// 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;
|
|
|
|
ClrErrorDescription();
|
|
|
|
if (!m_bInitialized)
|
|
return MIstatus::success;
|
|
|
|
m_bInitialized = false;
|
|
|
|
bool bOk = MIstatus::success;
|
|
CMIUtilString errMsg;
|
|
|
|
// Tidy up
|
|
UnregisterDriverAll();
|
|
|
|
// 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() {
|
|
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() 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() {
|
|
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(MIRSRC(IDS_DRIVER_ERR_CURRENT_NOT_SET));
|
|
CMICmnStreamStdout::Instance().Write(errMsg, true);
|
|
return MIstatus::failure;
|
|
}
|
|
|
|
return MIstatus::success;
|
|
}
|
|
|
|
//++
|
|
//------------------------------------------------------------------------------------
|
|
// 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(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 char *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() const {
|
|
if (m_pDriverCurrent != nullptr)
|
|
return m_pDriverCurrent->GetError();
|
|
else {
|
|
const CMIUtilString errMsg(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() const {
|
|
if (m_pDriverCurrent != nullptr)
|
|
return m_pDriverCurrent->GetName();
|
|
else {
|
|
const CMIUtilString errMsg(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() {
|
|
lldb::SBDebugger *pDebugger = nullptr;
|
|
if (m_pDriverCurrent != nullptr)
|
|
pDebugger = &m_pDriverCurrent->GetTheDebugger();
|
|
else {
|
|
const CMIUtilString errMsg(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
|
|
// --log-dir
|
|
// 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 command line does not
|
|
// action additional
|
|
// commands to initialise a debug session and so be able to launch the
|
|
// process. The directory
|
|
// where the log file is created is specified using --log-dir.
|
|
// 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 bHaveArgLogDir = false;
|
|
bool bHaveArgHelp = false;
|
|
CMIUtilString strLogDir;
|
|
|
|
bHaveArgInterpret = true;
|
|
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(0, 10, "--log-dir=")) {
|
|
strLogDir = strArg.substr(10, CMIUtilString::npos);
|
|
bHaveArgLogDir = true;
|
|
}
|
|
if ((0 == strArg.compare("--help")) || (0 == strArg.compare("-h"))) {
|
|
bHaveArgHelp = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bHaveArgLog) {
|
|
CMICmnLog::Instance().SetEnabled(true);
|
|
}
|
|
|
|
if (bHaveArgLogDir) {
|
|
bOk = bOk && CMICmnLogMediumFile::Instance().SetDirectory(strLogDir);
|
|
}
|
|
|
|
// Todo: Remove this output when MI is finished. It is temporary to persuade
|
|
// Eclipse 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 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 '--interpreter' 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 registered 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() 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() 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_SOURCE),
|
|
MIRSRC(IDE_MI_APP_ARG_EXECUTEABLE),
|
|
MIRSRC(IDE_MI_APP_ARG_SYNCHRONOUS),
|
|
CMIUtilString::Format(
|
|
MIRSRC(IDE_MI_APP_ARG_APP_LOG),
|
|
CMICmnLogMediumFile::Instance().GetFileName().c_str()),
|
|
MIRSRC(IDE_MI_APP_ARG_APP_LOG_DIR), 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() 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() 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;
|
|
}
|
|
|
|
//++
|
|
//------------------------------------------------------------------------------------
|
|
// Details: Gets called when lldb-mi gets a signal. Passed signal to current
|
|
// driver.
|
|
//
|
|
// Type: Method.
|
|
// Args: signal that was delivered
|
|
// Return: None.
|
|
// Throws: None.
|
|
//--
|
|
void CMIDriverMgr::DeliverSignal(int signal) {
|
|
if (m_pDriverCurrent != nullptr)
|
|
m_pDriverCurrent->DeliverSignal(signal);
|
|
}
|