| //===-- 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) |
| { |
| // The MI Driver's log updating may have been switched off switch back on to say all is ok. |
| CMICmnLog::Instance().SetEnabled(true); |
| #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 |
| { |
| // The MI Driver's log updating may have been switched off switch back on to say there has been problem. |
| rAppLog.SetEnabled(true); |
| 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 |
| // --noLog |
| // --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 bHaveArgNoLog = 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("--noLog")) |
| { |
| bHaveArgNoLog = true; |
| } |
| if ((0 == strArg.compare("--help")) || (0 == strArg.compare("-h"))) |
| { |
| bHaveArgHelp = true; |
| } |
| } |
| } |
| |
| if (bHaveArgNoLog) |
| { |
| CMICmnLog::Instance().SetEnabled(false); |
| } |
| |
| // 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_NO_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; |
| } |
