//===-- 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),
      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);
}
