llvm-project/lldb/tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

//===-- MICmnLLDBDebugSessionInfo.cpp ---------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

//++
// File:        MICmnLLDBDebugSessionInfo.cpp
//
// Overview:    CMICmnLLDBDebugSessionInfo 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/SBThread.h"
#ifdef _WIN32
#include <io.h> // For the ::_access()
#else
#include <unistd.h> // For the ::access()
#endif              // _WIN32
#include "lldb/API/SBBreakpointLocation.h"

// In-house headers:
#include "MICmnLLDBDebugSessionInfo.h"
#include "MICmnLLDBDebugger.h"
#include "MICmnResources.h"
#include "MICmnMIResultRecord.h"
#include "MICmnMIValueConst.h"
#include "MICmnMIValueList.h"
#include "MICmnMIValueTuple.h"
#include "MICmdData.h"
#include "MICmnLLDBUtilSBValue.h"

//++ ------------------------------------------------------------------------------------
// Details: CMICmnLLDBDebugSessionInfo constructor.
// Type:    Method.
// Args:    None.
// Return:  None.
// Throws:  None.
//--
CMICmnLLDBDebugSessionInfo::CMICmnLLDBDebugSessionInfo(void)
    : m_rLldbDebugger(CMICmnLLDBDebugger::Instance().GetTheDebugger())
    , m_rLlldbListener(CMICmnLLDBDebugger::Instance().GetTheListener())
    , m_nBrkPointCntMax(INT32_MAX)
    , m_currentSelectedThread(LLDB_INVALID_THREAD_ID)
    , m_constStrSharedDataKeyWkDir("Working Directory")
    , m_constStrSharedDataSolibPath("Solib Path")
{
}

//++ ------------------------------------------------------------------------------------
// Details: CMICmnLLDBDebugSessionInfo destructor.
// Type:    Overridable.
// Args:    None.
// Return:  None.
// Throws:  None.
//--
CMICmnLLDBDebugSessionInfo::~CMICmnLLDBDebugSessionInfo(void)
{
    Shutdown();
}

//++ ------------------------------------------------------------------------------------
// Details: Initialize resources for *this object.
// Type:    Method.
// Args:    None.
// Return:  MIstatus::success - Functionality succeeded.
//          MIstatus::failure - Functionality failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::Initialize(void)
{
    m_clientUsageRefCnt++;

    if (m_bInitialized)
        return MIstatus::success;

    m_currentSelectedThread = LLDB_INVALID_THREAD_ID;
    CMICmnLLDBDebugSessionInfoVarObj::VarObjIdResetToZero();

    m_bInitialized = MIstatus::success;

    return m_bInitialized;
}

//++ ------------------------------------------------------------------------------------
// Details: Release resources for *this object.
// Type:    Method.
// Args:    None.
// Return:  MIstatus::success - Functionality succeeded.
//          MIstatus::failure - Functionality failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::Shutdown(void)
{
    if (--m_clientUsageRefCnt > 0)
        return MIstatus::success;

    if (!m_bInitialized)
        return MIstatus::success;

    bool bOk = MIstatus::success;
    CMIUtilString errMsg;

    // Tidy up
    bOk = SharedDataDestroy();
    if (!bOk)
    {
        errMsg = CMIUtilString::Format(MIRSRC(IDS_DBGSESSION_ERR_SHARED_DATA_RELEASE));
        errMsg += "\n";
    }
    m_vecActiveThreadId.clear();
    CMICmnLLDBDebugSessionInfoVarObj::VarObjClear();

    m_bInitialized = false;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Command instances can create and share data between other instances of commands.
//          Data can also be assigned by a command and retrieved by LLDB event handler.
//          This function takes down those resources build up over the use of the commands.
//          This function should be called when the creation and running of command has
//          stopped i.e. application shutdown.
// Type:    Method.
// Args:    None.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::SharedDataDestroy(void)
{
    m_mapIdToSessionData.Clear();
    m_vecVarObj.clear();
    m_mapBrkPtIdToBrkPtInfo.clear();

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Record information about a LLDB break point so that is can be recalled in other
//          commands or LLDB event handling functions.
// Type:    Method.
// Args:    vBrkPtId        - (R) LLDB break point ID.
//          vrBrkPtInfo     - (R) Break point information object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::RecordBrkPtInfo(const MIuint vnBrkPtId, const SBrkPtInfo &vrBrkPtInfo)
{
    MapPairBrkPtIdToBrkPtInfo_t pr(vnBrkPtId, vrBrkPtInfo);
    m_mapBrkPtIdToBrkPtInfo.insert(pr);

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Retrieve information about a LLDB break point previous recorded either by
//          commands or LLDB event handling functions.
// Type:    Method.
// Args:    vBrkPtId        - (R) LLDB break point ID.
//          vrwBrkPtInfo    - (W) Break point information object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::RecordBrkPtInfoGet(const MIuint vnBrkPtId, SBrkPtInfo &vrwBrkPtInfo) const
{
    const MapBrkPtIdToBrkPtInfo_t::const_iterator it = m_mapBrkPtIdToBrkPtInfo.find(vnBrkPtId);
    if (it != m_mapBrkPtIdToBrkPtInfo.end())
    {
        vrwBrkPtInfo = (*it).second;
        return MIstatus::success;
    }

    return MIstatus::failure;
}

//++ ------------------------------------------------------------------------------------
// Details: Delete information about a specific LLDB break point object. This function
//          should be called when a LLDB break point is deleted.
// Type:    Method.
// Args:    vBrkPtId        - (R) LLDB break point ID.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::RecordBrkPtInfoDelete(const MIuint vnBrkPtId)
{
    const MapBrkPtIdToBrkPtInfo_t::const_iterator it = m_mapBrkPtIdToBrkPtInfo.find(vnBrkPtId);
    if (it != m_mapBrkPtIdToBrkPtInfo.end())
    {
        m_mapBrkPtIdToBrkPtInfo.erase(it);
        return MIstatus::success;
    }

    return MIstatus::failure;
}

//++ ------------------------------------------------------------------------------------
// Details: Retrieve the specified thread's frame information.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vThreadIdx      - (R) Thread index.
//          vwrThreadFrames - (W) Frame data.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetThreadFrames(const SMICmdData &vCmdData, const MIuint vThreadIdx, CMIUtilString &vwrThreadFrames)
{
    lldb::SBThread thread = m_lldbProcess.GetThreadByIndexID(vThreadIdx);
    const uint32_t nFrames = thread.GetNumFrames();
    if (nFrames == 0)
    {
        // MI print "frame={}"
        CMICmnMIValueTuple miValueTuple;
        CMICmnMIValueResult miValueResult("frame", miValueTuple);
        vwrThreadFrames = miValueResult.GetString();
        return MIstatus::success;
    }

    // MI print
    // "frame={level=\"%d\",addr=\"0x%08llx\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},frame={level=\"%d\",addr=\"0x%08llx\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},
    // ..."
    CMIUtilString strListCommaSeperated;
    for (MIuint nLevel = 0; nLevel < nFrames; nLevel++)
    {
        lldb::SBFrame frame = thread.GetFrameAtIndex(nLevel);
        lldb::addr_t pc = 0;
        CMIUtilString fnName;
        CMIUtilString fileName;
        CMIUtilString path;
        MIuint nLine = 0;
        if (!GetFrameInfo(frame, pc, fnName, fileName, path, nLine))
            return MIstatus::failure;

        // Function args
        CMICmnMIValueList miValueList(true);
        const MIuint maskVarTypes = eVariableType_Arguments;
        if (!MIResponseFormVariableInfo(frame, maskVarTypes, miValueList))
            return MIstatus::failure;

        const MIchar *pUnknown = "??";
        if (fnName != pUnknown)
        {
            std::replace(fnName.begin(), fnName.end(), ')', ' ');
            std::replace(fnName.begin(), fnName.end(), '(', ' ');
            std::replace(fnName.begin(), fnName.end(), '\'', ' ');
        }

        CMICmnMIValueTuple miValueTuple;
        const CMIUtilString strLevel(CMIUtilString::Format("%d", nLevel));
        const CMICmnMIValueConst miValueConst(strLevel);
        const CMICmnMIValueResult miValueResult("level", miValueConst);
        miValueTuple.Add(miValueResult);
        if (!MIResponseFormFrameInfo2(pc, miValueList.GetString(), fnName, fileName, path, nLine, miValueTuple))
            return MIstatus::failure;

        const CMICmnMIValueResult miValueResult2("frame", miValueTuple);
        if (nLevel != 0)
            strListCommaSeperated += ",";
        strListCommaSeperated += miValueResult2.GetString();
    }

    vwrThreadFrames = strListCommaSeperated;

    return MIstatus::success;
}

// Todo: Refactor maybe to so only one function with this name, but not just yet
//++ ------------------------------------------------------------------------------------
// Details: Retrieve the specified thread's frame information.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vThreadIdx      - (R) Thread index.
//          vwrThreadFrames - (W) Frame data.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetThreadFrames2(const SMICmdData &vCmdData, const MIuint vThreadIdx, CMIUtilString &vwrThreadFrames)
{
    lldb::SBThread thread = m_lldbProcess.GetThreadByIndexID(vThreadIdx);
    const uint32_t nFrames = thread.GetNumFrames();
    if (nFrames == 0)
    {
        // MI print "frame={}"
        CMICmnMIValueTuple miValueTuple;
        CMICmnMIValueResult miValueResult("frame", miValueTuple);
        vwrThreadFrames = miValueResult.GetString();
        return MIstatus::success;
    }

    // MI print
    // "frame={level=\"%d\",addr=\"0x%08llx\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},frame={level=\"%d\",addr=\"0x%08llx\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},
    // ..."
    CMIUtilString strListCommaSeperated;
    for (MIuint nLevel = 0; nLevel < nFrames; nLevel++)
    {
        lldb::SBFrame frame = thread.GetFrameAtIndex(nLevel);
        lldb::addr_t pc = 0;
        CMIUtilString fnName;
        CMIUtilString fileName;
        CMIUtilString path;
        MIuint nLine = 0;
        if (!GetFrameInfo(frame, pc, fnName, fileName, path, nLine))
            return MIstatus::failure;

        // Function args
        CMICmnMIValueList miValueList(true);
        const MIuint maskVarTypes = eVariableType_Arguments;
        if (!MIResponseFormVariableInfo2(frame, maskVarTypes, miValueList))
            return MIstatus::failure;

        const MIchar *pUnknown = "??";
        if (fnName != pUnknown)
        {
            std::replace(fnName.begin(), fnName.end(), ')', ' ');
            std::replace(fnName.begin(), fnName.end(), '(', ' ');
            std::replace(fnName.begin(), fnName.end(), '\'', ' ');
        }

        CMICmnMIValueTuple miValueTuple;
        const CMIUtilString strLevel(CMIUtilString::Format("%d", nLevel));
        const CMICmnMIValueConst miValueConst(strLevel);
        const CMICmnMIValueResult miValueResult("level", miValueConst);
        miValueTuple.Add(miValueResult);
        if (!MIResponseFormFrameInfo2(pc, miValueList.GetString(), fnName, fileName, path, nLine, miValueTuple))
            return MIstatus::failure;

        const CMICmnMIValueResult miValueResult2("frame", miValueTuple);
        if (nLevel != 0)
            strListCommaSeperated += ",";
        strListCommaSeperated += miValueResult2.GetString();
    }

    vwrThreadFrames = strListCommaSeperated;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Return the resolved file's path for the given file.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vPath           - (R) Original path.
//          vwrResolvedPath - (W) Resolved path.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::ResolvePath(const SMICmdData &vCmdData, const CMIUtilString &vPath, CMIUtilString &vwrResolvedPath)
{
    // ToDo: Verify this code as it does not work as vPath is always empty

    CMIUtilString strResolvedPath;
    if (!SharedDataRetrieve<CMIUtilString>(m_constStrSharedDataKeyWkDir, strResolvedPath))
    {
        vwrResolvedPath = "";
        SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_SHARED_DATA_NOT_FOUND), vCmdData.strMiCmd.c_str(),
                                                  m_constStrSharedDataKeyWkDir.c_str()));
        return MIstatus::failure;
    }

    vwrResolvedPath = vPath;

    return ResolvePath(strResolvedPath, vwrResolvedPath);
}

//++ ------------------------------------------------------------------------------------
// Details: Return the resolved file's path for the given file.
// Type:    Method.
// Args:    vstrUnknown     - (R)   String assigned to path when resolved path is empty.
//          vwrResolvedPath - (RW)  The original path overwritten with resolved path.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::ResolvePath(const CMIUtilString &vstrUnknown, CMIUtilString &vwrResolvedPath)
{
    if (vwrResolvedPath.size() < 1)
    {
        vwrResolvedPath = vstrUnknown;
        return MIstatus::success;
    }

    bool bOk = MIstatus::success;

    CMIUtilString::VecString_t vecPathFolders;
    const MIuint nSplits = vwrResolvedPath.Split("/", vecPathFolders);
    MIunused(nSplits);
    MIuint nFoldersBack = 1; // 1 is just the file (last element of vector)
    while (bOk && (vecPathFolders.size() >= nFoldersBack))
    {
        CMIUtilString strTestPath;
        MIuint nFoldersToAdd = nFoldersBack;
        while (nFoldersToAdd > 0)
        {
            strTestPath += "/";
            strTestPath += vecPathFolders[vecPathFolders.size() - nFoldersToAdd];
            nFoldersToAdd--;
        }
        bool bYesAccessible = false;
        bOk = AccessPath(strTestPath, bYesAccessible);
        if (bYesAccessible)
        {
            vwrResolvedPath = strTestPath;
            return MIstatus::success;
        }
        else
            nFoldersBack++;
    }

    // No files exist in the union of working directory and debuginfo path
    // Simply use the debuginfo path and let the IDE handle it.

    return bOk;
}

//++ ------------------------------------------------------------------------------------
// Details: Determine the given file path exists or not.
// Type:    Method.
// Args:    vPath               - (R) File name path.
//          vwbYesAccessible    - (W) True - file exists, false = does not exist.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::AccessPath(const CMIUtilString &vPath, bool &vwbYesAccessible)
{
#ifdef _WIN32
    vwbYesAccessible = (::_access(vPath.c_str(), 0) == 0);
#else
    vwbYesAccessible = (::access(vPath.c_str(), 0) == 0);
#endif // _WIN32

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vrThread        - (R) LLDB thread object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
                                                     CMICmnMIValueTuple &vwrMIValueTuple)
{
    lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);

    CMIUtilString strFrames;
    if (!GetThreadFrames(vCmdData, rThread.GetIndexID(), strFrames))
        return MIstatus::failure;

    const bool bSuspended = rThread.IsSuspended();
    const lldb::StopReason eReason = rThread.GetStopReason();
    const bool bValidReason = !((eReason == lldb::eStopReasonNone) || (eReason == lldb::eStopReasonInvalid));
    const CMIUtilString strState((bSuspended || bValidReason) ? "stopped" : "running");

    // Add "id"
    const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
    const CMICmnMIValueConst miValueConst1(strId);
    const CMICmnMIValueResult miValueResult1("id", miValueConst1);
    if (!vwrMIValueTuple.Add(miValueResult1))
        return MIstatus::failure;

    // Add "target-id"
    const MIchar *pThreadName = rThread.GetName();
    const MIuint len = (pThreadName != nullptr) ? CMIUtilString(pThreadName).length() : 0;
    const bool bHaveName = ((pThreadName != nullptr) && (len > 0) && (len < 32) &&
                            CMIUtilString::IsAllValidAlphaAndNumeric(*pThreadName)); // 32 is arbitary number
    const MIchar *pThrdFmt = bHaveName ? "%s" : "Thread %d";
    CMIUtilString strThread;
    if (bHaveName)
        strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
    else
        strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
    const CMICmnMIValueConst miValueConst2(strThread);
    const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
    if (!vwrMIValueTuple.Add(miValueResult2))
        return MIstatus::failure;

    // Add "frame"
    const CMICmnMIValueConst miValueConst3(strFrames, true);
    if (!vwrMIValueTuple.Add(miValueConst3, false))
        return MIstatus::failure;

    // Add "state"
    const CMICmnMIValueConst miValueConst4(strState);
    const CMICmnMIValueResult miValueResult4("state", miValueConst4);
    if (!vwrMIValueTuple.Add(miValueResult4))
        return MIstatus::failure;

    return MIstatus::success;
}

// Todo: Refactor maybe to so only one function with this name, but not just yet
//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vrThread        - (R) LLDB thread object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo3(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
                                                      CMICmnMIValueTuple &vwrMIValueTuple)
{
    lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);

    CMIUtilString strFrames;
    if (!GetThreadFrames2(vCmdData, rThread.GetIndexID(), strFrames))
        return MIstatus::failure;

    const bool bSuspended = rThread.IsSuspended();
    const lldb::StopReason eReason = rThread.GetStopReason();
    const bool bValidReason = !((eReason == lldb::eStopReasonNone) || (eReason == lldb::eStopReasonInvalid));
    const CMIUtilString strState((bSuspended || bValidReason) ? "stopped" : "running");

    // Add "id"
    const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
    const CMICmnMIValueConst miValueConst1(strId);
    const CMICmnMIValueResult miValueResult1("id", miValueConst1);
    if (!vwrMIValueTuple.Add(miValueResult1))
        return MIstatus::failure;

    // Add "target-id"
    const MIchar *pThreadName = rThread.GetName();
    const MIuint len = (pThreadName != nullptr) ? CMIUtilString(pThreadName).length() : 0;
    const bool bHaveName = ((pThreadName != nullptr) && (len > 0) && (len < 32) &&
                            CMIUtilString::IsAllValidAlphaAndNumeric(*pThreadName)); // 32 is arbitary number
    const MIchar *pThrdFmt = bHaveName ? "%s" : "Thread %d";
    CMIUtilString strThread;
    if (bHaveName)
        strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
    else
        strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
    const CMICmnMIValueConst miValueConst2(strThread);
    const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
    if (!vwrMIValueTuple.Add(miValueResult2))
        return MIstatus::failure;

    // Add "frame"
    const CMICmnMIValueConst miValueConst3(strFrames, true);
    if (!vwrMIValueTuple.Add(miValueConst3, false))
        return MIstatus::failure;

    // Add "state"
    const CMICmnMIValueConst miValueConst4(strState);
    const CMICmnMIValueResult miValueResult4("state", miValueConst4);
    if (!vwrMIValueTuple.Add(miValueResult4))
        return MIstatus::failure;

    return MIstatus::success;
}

// Todo: Refactor maybe to so only one function with this name, but not just yet
//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vCmdData        - (R) A command's information.
//          vrThread        - (R) LLDB thread object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo2(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
                                                      CMICmnMIValueTuple &vwrMIValueTuple)
{
    lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);

    const bool bSuspended = rThread.IsSuspended();
    const lldb::StopReason eReason = rThread.GetStopReason();
    const bool bValidReason = !((eReason == lldb::eStopReasonNone) || (eReason == lldb::eStopReasonInvalid));
    const CMIUtilString strState((bSuspended || bValidReason) ? "stopped" : "running");

    // Add "id"
    const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
    const CMICmnMIValueConst miValueConst1(strId);
    const CMICmnMIValueResult miValueResult1("id", miValueConst1);
    if (!vwrMIValueTuple.Add(miValueResult1))
        return MIstatus::failure;

    // Add "target-id"
    const MIchar *pThreadName = rThread.GetName();
    const MIuint len = (pThreadName != nullptr) ? CMIUtilString(pThreadName).length() : 0;
    const bool bHaveName = ((pThreadName != nullptr) && (len > 0) && (len < 32) &&
                            CMIUtilString::IsAllValidAlphaAndNumeric(*pThreadName)); // 32 is arbitary number
    const MIchar *pThrdFmt = bHaveName ? "%s" : "Thread %d";
    CMIUtilString strThread;
    if (bHaveName)
        strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
    else
        strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
    const CMICmnMIValueConst miValueConst2(strThread);
    const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
    if (!vwrMIValueTuple.Add(miValueResult2))
        return MIstatus::failure;

    // Add "state"
    const CMICmnMIValueConst miValueConst4(strState);
    const CMICmnMIValueResult miValueResult4("state", miValueConst4);
    if (!vwrMIValueTuple.Add(miValueResult4))
        return MIstatus::failure;

    return MIstatus::success;
}

// Todo: Refactor maybe to so only one function with this name, but not just yet
//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrFrame         - (R)   LLDB thread object.
//          vMaskVarTypes   - (R)   Construed according to VariableType_e.
//          vwrMIValueList  - (W)   MI value list object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo2(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                                        CMICmnMIValueList &vwrMiValueList)
{
    bool bOk = MIstatus::success;
    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);

    const bool bArg = (vMaskVarTypes & eVariableType_Arguments);
    const bool bLocals = (vMaskVarTypes & eVariableType_Locals);
    const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
    const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
    lldb::SBValueList listArg = rFrame.GetVariables(bArg, bLocals, bStatics, bInScopeOnly);
    const MIuint nArgs = listArg.GetSize();
    for (MIuint i = 0; bOk && (i < nArgs); i++)
    {
        lldb::SBValue value = listArg.GetValueAtIndex(i);
        const CMICmnLLDBUtilSBValue utilValue(value);
        const CMICmnMIValueConst miValueConst(utilValue.GetName());
        const CMICmnMIValueResult miValueResult("name", miValueConst);
        CMICmnMIValueTuple miValueTuple(miValueResult);
        const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
        const CMICmnMIValueResult miValueResult2("value", miValueConst2);
        miValueTuple.Add(miValueResult2);
        bOk = vwrMiValueList.Add(miValueTuple);
    }

    return bOk;
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrFrame         - (R)   LLDB thread object.
//          vMaskVarTypes   - (R)   Construed according to VariableType_e.
//          vwrMIValueList  - (W)   MI value list object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                                       CMICmnMIValueList &vwrMiValueList)
{
    bool bOk = MIstatus::success;
    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);

    const bool bArg = (vMaskVarTypes & eVariableType_Arguments);
    const bool bLocals = (vMaskVarTypes & eVariableType_Locals);
    const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
    const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
    const MIuint nMaxRecusiveDepth = 10;
    MIuint nCurrentRecursiveDepth = 0;
    lldb::SBValueList listArg = rFrame.GetVariables(bArg, bLocals, bStatics, bInScopeOnly);
    const MIuint nArgs = listArg.GetSize();
    for (MIuint i = 0; bOk && (i < nArgs); i++)
    {
        lldb::SBValue value = listArg.GetValueAtIndex(i);
        bOk = GetVariableInfo(nMaxRecusiveDepth, value, false, vwrMiValueList, nCurrentRecursiveDepth);
    }

    return bOk;
}

// *** Do not refactor this function to be one function with same name as it can break more than
// *** than one stack type command
//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrFrame         - (R)   LLDB thread object.
//          vMaskVarTypes   - (R)   Construed according to VariableType_e.
//          vwrMIValueList  - (W)   MI value list object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormVariableInfo3(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                                        CMICmnMIValueList &vwrMiValueList)
{
    bool bOk = MIstatus::success;
    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);

    const bool bArg = (vMaskVarTypes & eVariableType_Arguments);
    const bool bLocals = (vMaskVarTypes & eVariableType_Locals);
    const bool bStatics = (vMaskVarTypes & eVariableType_Statics);
    const bool bInScopeOnly = (vMaskVarTypes & eVariableType_InScope);
    const MIuint nMaxRecusiveDepth = 10;
    MIuint nCurrentRecursiveDepth = 0;
    lldb::SBValueList listArg = rFrame.GetVariables(bArg, bLocals, bStatics, bInScopeOnly);
    const MIuint nArgs = listArg.GetSize();
    for (MIuint i = 0; bOk && (i < nArgs); i++)
    {
        lldb::SBValue value = listArg.GetValueAtIndex(i);
        bOk = GetVariableInfo2(nMaxRecusiveDepth, value, false, vwrMiValueList, nCurrentRecursiveDepth);
    }

    return bOk;
}

// *** Do not refactor this function to be one function with same name as it can break more than
// *** than one stack type command
//++ ------------------------------------------------------------------------------------
// Details: Extract the value's name and value or recurse into child value object.
// Type:    Method.
// Args:    vnMaxDepth      - (R)  The max recursive depth for this function.
//          vrValue         - (R)  LLDB value object.
//          vbIsChildValue  - (R)  True = Value object is a child of a higher Value object,
//                          -      False =  Value object not a child.
//          vwrMIValueList  - (W)  MI value list object.
//          vnDepth         - (RW) The current recursive depth of this function.
//          // Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
                                            CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth)
{
    // *** Update GetVariableInfo2() with any code changes here ***

    // Check recursive depth
    if (vrwnDepth >= vnMaxDepth)
        return MIstatus::success;

    bool bOk = MIstatus::success;
    lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
    const CMICmnLLDBUtilSBValue utilValue(vrValue, true);
    CMICmnMIValueTuple miValueTuple;
    const MIchar *pName = rValue.GetName();
    MIunused(pName);
    const bool bIsPointerType = rValue.GetType().IsPointerType();
    const MIuint nChildren = rValue.GetNumChildren();
    if (nChildren == 0)
    {
        if (vbIsChildValue)
        {
            if (utilValue.IsCharType())
            {
                // For char types and try to form text string
                const CMICmnMIValueConst miValueConst(utilValue.GetValue().c_str(), true);
                miValueTuple.Add(miValueConst, true);
            }
            else
            {
                // For composite types
                const CMICmnMIValueConst miValueConst(
                    CMIUtilString::Format("%s = %s", utilValue.GetName().c_str(), utilValue.GetValue().c_str()), true);
                miValueTuple.Add(miValueConst, true);
            }
            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
        }
        else
        {
            // Basic types
            const CMICmnMIValueConst miValueConst(utilValue.GetName());
            const CMICmnMIValueResult miValueResult("name", miValueConst);
            miValueTuple.Add(miValueResult);
            const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
            const CMICmnMIValueResult miValueResult2("value", miValueConst2);
            miValueTuple.Add(miValueResult2);
            return vwrMiValueList.Add(miValueTuple);
        }
    }
    else if (bIsPointerType && utilValue.IsChildCharType())
    {
        // Append string text to the parent value information
        const CMICmnMIValueConst miValueConst(utilValue.GetName());
        const CMICmnMIValueResult miValueResult("name", miValueConst);
        miValueTuple.Add(miValueResult);

        const CMIUtilString &rText(utilValue.GetChildValueCString());
        if (rText.empty())
        {
            const CMICmnMIValueConst miValueConst(utilValue.GetValue());
            const CMICmnMIValueResult miValueResult("value", miValueConst);
            miValueTuple.Add(miValueResult);
        }
        else
        {
            if (utilValue.IsValueUnknown())
            {
                const CMICmnMIValueConst miValueConst(rText);
                const CMICmnMIValueResult miValueResult("value", miValueConst);
                miValueTuple.Add(miValueResult);
            }
            else
            {
                // Note code that has const in will not show the text suffix to the string pointer
                // i.e. const char * pMyStr = "blah"; ==> "0x00007000"" <-- Eclipse shows this
                // but        char * pMyStr = "blah"; ==> "0x00007000" "blah"" <-- Eclipse shows this
                const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%s %s", utilValue.GetValue().c_str(), rText.c_str()));
                const CMICmnMIValueResult miValueResult("value", miValueConst);
                miValueTuple.Add(miValueResult);
            }
        }
        return vwrMiValueList.Add(miValueTuple);
    }
    else if (bIsPointerType)
    {
        if (vbIsChildValue)
        {
            // For composite types
            const CMICmnMIValueConst miValueConst(
                CMIUtilString::Format("%s = %s", utilValue.GetName().c_str(), utilValue.GetValue().c_str()), true);
            miValueTuple.Add(miValueConst, true);
            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
        }
        else
        {
            // Basic types
            const CMICmnMIValueConst miValueConst(utilValue.GetName());
            const CMICmnMIValueResult miValueResult("name", miValueConst);
            miValueTuple.Add(miValueResult);
            const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
            const CMICmnMIValueResult miValueResult2("value", miValueConst2);
            miValueTuple.Add(miValueResult2);
            return vwrMiValueList.Add(miValueTuple);
        }
    }
    else
    {
        // Build parent child composite types
        CMICmnMIValueList miValueList(true);
        for (MIuint i = 0; bOk && (i < nChildren); i++)
        {
            lldb::SBValue member = rValue.GetChildAtIndex(i);
            bOk = GetVariableInfo(vnMaxDepth, member, true, miValueList, ++vrwnDepth);
        }
        const CMICmnMIValueConst miValueConst(utilValue.GetName());
        const CMICmnMIValueResult miValueResult("name", miValueConst);
        miValueTuple.Add(miValueResult);
        const CMICmnMIValueConst miValueConst2(CMIUtilString::Format("{%s}", miValueList.ExtractContentNoBrackets().c_str()));
        const CMICmnMIValueResult miValueResult2("value", miValueConst2);
        miValueTuple.Add(miValueResult2);
        return vwrMiValueList.Add(miValueTuple);
    }
}

// *** Do not refactor this function to be one function with same name as it can break more than
// *** than one stack type command
//++ ------------------------------------------------------------------------------------
// Details: Extract the value's name and value or recurse into child value object.
// Type:    Method.
// Args:    vnMaxDepth      - (R)  The max recursive depth for this function.
//          vrValue         - (R)  LLDB value object.
//          vbIsChildValue  - (R)  True = Value object is a child of a higher Value object,
//                          -      False =  Value object not a child.
//          vwrMIValueList  - (W)  MI value list object.
//          vnDepth         - (RW) The current recursive depth of this function.
//          // Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetVariableInfo2(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
                                             CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth)
{
    // *** Update GetVariableInfo() with any code changes here ***

    // Check recursive depth
    if (vrwnDepth >= vnMaxDepth)
        return MIstatus::success;

    bool bOk = MIstatus::success;
    lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
    const CMICmnLLDBUtilSBValue utilValue(vrValue, true);
    CMICmnMIValueTuple miValueTuple;
    const MIchar *pName = rValue.GetName();
    MIunused(pName);
    const MIuint nChildren = rValue.GetNumChildren();
    if (nChildren == 0)
    {
        if (vbIsChildValue && utilValue.IsCharType())
        {
            // For char types and try to form text string
            const CMICmnMIValueConst miValueConst(utilValue.GetValue().c_str(), true);
            miValueTuple.Add(miValueConst, true);
            return vwrMiValueList.Add(CMICmnMIValueConst(miValueTuple.ExtractContentNoBrackets(), true));
        }
        else
        {
            // Basic types
            const CMICmnMIValueConst miValueConst(utilValue.GetName());
            const CMICmnMIValueResult miValueResult("name", miValueConst);
            miValueTuple.Add(miValueResult);
            const CMICmnMIValueConst miValueConst2(utilValue.GetValue());
            const CMICmnMIValueResult miValueResult2("value", miValueConst2);
            miValueTuple.Add(miValueResult2);
            return vwrMiValueList.Add(miValueTuple);
        }
    }
    else if (utilValue.IsChildCharType())
    {
        // Append string text to the parent value information
        const CMICmnMIValueConst miValueConst(utilValue.GetName());
        const CMICmnMIValueResult miValueResult("name", miValueConst);
        miValueTuple.Add(miValueResult);

        const CMIUtilString &rText(utilValue.GetChildValueCString());
        if (rText.empty())
        {
            const CMICmnMIValueConst miValueConst(utilValue.GetValue());
            const CMICmnMIValueResult miValueResult("value", miValueConst);
            miValueTuple.Add(miValueResult);
        }
        else
        {
            if (utilValue.IsValueUnknown())
            {
                const CMICmnMIValueConst miValueConst(rText);
                const CMICmnMIValueResult miValueResult("value", miValueConst);
                miValueTuple.Add(miValueResult);
            }
            else
            {
                // Note code that has const in will not show the text suffix to the string pointer
                // i.e. const char * pMyStr = "blah"; ==> "0x00007000"" <-- Eclipse shows this
                // but        char * pMyStr = "blah"; ==> "0x00007000" "blah"" <-- Eclipse shows this
                const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%s %s", utilValue.GetValue().c_str(), rText.c_str()));
                const CMICmnMIValueResult miValueResult("value", miValueConst);
                miValueTuple.Add(miValueResult);
            }
        }
        return vwrMiValueList.Add(miValueTuple);
    }
    else
    {
        // Build parent child composite types
        CMICmnMIValueList miValueList(true);
        for (MIuint i = 0; bOk && (i < nChildren); i++)
        {
            lldb::SBValue member = rValue.GetChildAtIndex(i);
            bOk = GetVariableInfo(vnMaxDepth, member, true, miValueList, ++vrwnDepth);
        }
        const CMICmnMIValueConst miValueConst(utilValue.GetName());
        const CMICmnMIValueResult miValueResult("name", miValueConst);
        miValueTuple.Add(miValueResult);
        const CMICmnMIValueConst miValueConst2(CMIUtilString::Format("{%s}", miValueList.ExtractContentNoBrackets().c_str()));
        const CMICmnMIValueResult miValueResult2("value", miValueConst2);
        miValueTuple.Add(miValueResult2);
        return vwrMiValueList.Add(miValueTuple);
    }
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrThread        - (R) LLDB thread object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormFrameInfo(const lldb::SBThread &vrThread, const MIuint vnLevel,
                                                    CMICmnMIValueTuple &vwrMiValueTuple)
{
    lldb::SBThread &rThread = const_cast<lldb::SBThread &>(vrThread);

    lldb::SBFrame frame = rThread.GetFrameAtIndex(vnLevel);
    lldb::addr_t pc = 0;
    CMIUtilString fnName;
    CMIUtilString fileName;
    CMIUtilString path;
    MIuint nLine = 0;
    if (!GetFrameInfo(frame, pc, fnName, fileName, path, nLine))
        return MIstatus::failure;

    // MI print "{level=\"0\",addr=\"0x%08llx\",func=\"%s\",file=\"%s\",fullname=\"%s\",line=\"%d\"}"
    const CMIUtilString strLevel(CMIUtilString::Format("%d", vnLevel));
    const CMICmnMIValueConst miValueConst(strLevel);
    const CMICmnMIValueResult miValueResult("level", miValueConst);
    CMICmnMIValueTuple miValueTuple(miValueResult);
    if (!MIResponseFormFrameInfo(pc, fnName, fileName, path, nLine, miValueTuple))
        return MIstatus::failure;

    vwrMiValueTuple = miValueTuple;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Retrieve the frame information from LLDB frame object.
// Type:    Method.
// Args:    vrFrame         - (R) LLDB thread object.
//          vPc             - (W) Address number.
//          vFnName         - (W) Function name.
//          vFileName       - (W) File name text.
//          vPath           - (W) Full file name and path text.
//          vnLine          - (W) File line number.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetFrameInfo(const lldb::SBFrame &vrFrame, lldb::addr_t &vwPc, CMIUtilString &vwFnName,
                                         CMIUtilString &vwFileName, CMIUtilString &vwPath, MIuint &vwnLine)
{
    lldb::SBFrame &rFrame = const_cast<lldb::SBFrame &>(vrFrame);

    static char pBuffer[MAX_PATH];
    const MIuint nBytes = rFrame.GetLineEntry().GetFileSpec().GetPath(&pBuffer[0], sizeof(pBuffer));
    MIunused(nBytes);
    CMIUtilString strResolvedPath(&pBuffer[0]);
    const MIchar *pUnkwn = "??";
    if (!ResolvePath(pUnkwn, strResolvedPath))
        return MIstatus::failure;
    vwPath = strResolvedPath;

    vwPc = rFrame.GetPC();

    const MIchar *pFnName = rFrame.GetFunctionName();
    vwFnName = (pFnName != nullptr) ? pFnName : pUnkwn;

    const MIchar *pFileName = rFrame.GetLineEntry().GetFileSpec().GetFilename();
    vwFileName = (pFileName != nullptr) ? pFileName : pUnkwn;

    vwnLine = rFrame.GetLineEntry().GetLine();

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vPc             - (R) Address number.
//          vFnName         - (R) Function name.
//          vFileName       - (R) File name text.
//          vPath           - (R) Full file name and path text.
//          vnLine          - (R) File line number.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormFrameInfo(const lldb::addr_t vPc, const CMIUtilString &vFnName, const CMIUtilString &vFileName,
                                                    const CMIUtilString &vPath, const MIuint vnLine, CMICmnMIValueTuple &vwrMiValueTuple)
{
    const CMIUtilString strAddr(CMIUtilString::Format("0x%08llx", vPc));
    const CMICmnMIValueConst miValueConst2(strAddr);
    const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
    if (!vwrMiValueTuple.Add(miValueResult2))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst3(vFnName);
    const CMICmnMIValueResult miValueResult3("func", miValueConst3);
    if (!vwrMiValueTuple.Add(miValueResult3))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst5(vFileName);
    const CMICmnMIValueResult miValueResult5("file", miValueConst5);
    if (!vwrMiValueTuple.Add(miValueResult5))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst6(vPath);
    const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
    if (!vwrMiValueTuple.Add(miValueResult6))
        return MIstatus::failure;
    const CMIUtilString strLine(CMIUtilString::Format("%d", vnLine));
    const CMICmnMIValueConst miValueConst7(strLine);
    const CMICmnMIValueResult miValueResult7("line", miValueConst7);
    if (!vwrMiValueTuple.Add(miValueResult7))
        return MIstatus::failure;

    return MIstatus::success;
}

// Todo: Refactor maybe to so only one function with this name, but not just yet
//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vPc             - (R) Address number.
//          vArgInfo        - (R) Args information in MI response form.
//          vFnName         - (R) Function name.
//          vFileName       - (R) File name text.
//          vPath           - (R) Full file name and path text.
//          vnLine          - (R) File line number.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormFrameInfo2(const lldb::addr_t vPc, const CMIUtilString &vArgInfo, const CMIUtilString &vFnName,
                                                     const CMIUtilString &vFileName, const CMIUtilString &vPath, const MIuint vnLine,
                                                     CMICmnMIValueTuple &vwrMiValueTuple)
{
    const CMIUtilString strAddr(CMIUtilString::Format("0x%08llx", vPc));
    const CMICmnMIValueConst miValueConst2(strAddr);
    const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
    if (!vwrMiValueTuple.Add(miValueResult2))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst3(vFnName);
    const CMICmnMIValueResult miValueResult3("func", miValueConst3);
    if (!vwrMiValueTuple.Add(miValueResult3))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst4(vArgInfo, true);
    const CMICmnMIValueResult miValueResult4("args", miValueConst4);
    if (!vwrMiValueTuple.Add(miValueResult4))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst5(vFileName);
    const CMICmnMIValueResult miValueResult5("file", miValueConst5);
    if (!vwrMiValueTuple.Add(miValueResult5))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst6(vPath);
    const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
    if (!vwrMiValueTuple.Add(miValueResult6))
        return MIstatus::failure;
    const CMIUtilString strLine(CMIUtilString::Format("%d", vnLine));
    const CMICmnMIValueConst miValueConst7(strLine);
    const CMICmnMIValueResult miValueResult7("line", miValueConst7);
    if (!vwrMiValueTuple.Add(miValueResult7))
        return MIstatus::failure;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrBrkPtInfo     - (R) Break point information object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple)
{
    const CMIUtilString strAddr(CMIUtilString::Format("0x%08llx", vrBrkPtInfo.m_pc));
    const CMICmnMIValueConst miValueConst2(strAddr);
    const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
    if (!vwrMiValueTuple.Add(miValueResult2))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_fnName);
    const CMICmnMIValueResult miValueResult3("func", miValueConst3);
    if (!vwrMiValueTuple.Add(miValueResult3))
        return MIstatus::failure;
    const CMICmnMIValueConst miValueConst5(vrBrkPtInfo.m_fileName);
    const CMICmnMIValueResult miValueResult5("file", miValueConst5);
    if (!vwrMiValueTuple.Add(miValueResult5))
        return MIstatus::failure;
    const CMIUtilString strN5 = CMIUtilString::Format("%s/%s", vrBrkPtInfo.m_path.c_str(), vrBrkPtInfo.m_fileName.c_str());
    const CMICmnMIValueConst miValueConst6(strN5);
    const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
    if (!vwrMiValueTuple.Add(miValueResult6))
        return MIstatus::failure;
    const CMIUtilString strLine(CMIUtilString::Format("%d", vrBrkPtInfo.m_nLine));
    const CMICmnMIValueConst miValueConst7(strLine);
    const CMICmnMIValueResult miValueResult7("line", miValueConst7);
    if (!vwrMiValueTuple.Add(miValueResult7))
        return MIstatus::failure;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Form MI partial response by appending more MI value type objects to the
//          tuple type object past in.
// Type:    Method.
// Args:    vrBrkPtInfo     - (R) Break point information object.
//          vwrMIValueTuple - (W) MI value tuple object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple)
{
    // MI print "=breakpoint-modified,bkpt={number=\"%d\",type=\"breakpoint\",disp=\"%s\",enabled=\"%c\",addr=\"0x%08x\",
    // func=\"%s\",file=\"%s\",fullname=\"%s/%s\",line=\"%d\",times=\"%d\",original-location=\"%s\"}"

    // "number="
    const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_id));
    const CMICmnMIValueResult miValueResult("number", miValueConst);
    CMICmnMIValueTuple miValueTuple(miValueResult);
    // "type="
    const CMICmnMIValueConst miValueConst2(vrBrkPtInfo.m_strType);
    const CMICmnMIValueResult miValueResult2("type", miValueConst2);
    bool bOk = miValueTuple.Add(miValueResult2);
    // "disp="
    const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_bDisp ? "del" : "keep");
    const CMICmnMIValueResult miValueResult3("disp", miValueConst3);
    bOk = bOk && miValueTuple.Add(miValueResult3);
    // "enabled="
    const CMICmnMIValueConst miValueConst4(vrBrkPtInfo.m_bEnabled ? "y" : "n");
    const CMICmnMIValueResult miValueResult4("enabled", miValueConst4);
    bOk = bOk && miValueTuple.Add(miValueResult4);
    // "addr="
    // "func="
    // "file="
    // "fullname="
    // "line="
    bOk = bOk && MIResponseFormBrkPtFrameInfo(vrBrkPtInfo, miValueTuple);
    // "pending="
    if (vrBrkPtInfo.m_bPending)
    {
        const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOrigLoc);
        const CMICmnMIValueList miValueList(miValueConst);
        const CMICmnMIValueResult miValueResult("pending", miValueList);
        bOk = bOk && miValueTuple.Add(miValueResult);
    }
    if (vrBrkPtInfo.m_bHaveArgOptionThreadGrp)
    {
        const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOptThrdGrp);
        const CMICmnMIValueList miValueList(miValueConst);
        const CMICmnMIValueResult miValueResult("thread-groups", miValueList);
        bOk = bOk && miValueTuple.Add(miValueResult);
    }
    // "times="
    const CMICmnMIValueConst miValueConstB(CMIUtilString::Format("%d", vrBrkPtInfo.m_nTimes));
    const CMICmnMIValueResult miValueResultB("times", miValueConstB);
    bOk = bOk && miValueTuple.Add(miValueResultB);
    // "thread="
    if (vrBrkPtInfo.m_bBrkPtThreadId)
    {
        const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_nBrkPtThreadId));
        const CMICmnMIValueResult miValueResult("thread", miValueConst);
        bOk = bOk && miValueTuple.Add(miValueResult);
    }
    // "cond="
    if (vrBrkPtInfo.m_bCondition)
    {
        const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strCondition);
        const CMICmnMIValueResult miValueResult("cond", miValueConst);
        bOk = bOk && miValueTuple.Add(miValueResult);
    }
    // "ignore="
    if (vrBrkPtInfo.m_nIgnore != 0)
    {
        const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_nIgnore));
        const CMICmnMIValueResult miValueResult("ignore", miValueConst);
        bOk = bOk && miValueTuple.Add(miValueResult);
    }
    // "original-location="
    const CMICmnMIValueConst miValueConstC(vrBrkPtInfo.m_strOrigLoc);
    const CMICmnMIValueResult miValueResultC("original-location", miValueConstC);
    bOk = bOk && miValueTuple.Add(miValueResultC);

    vwrMiValueTuple = miValueTuple;

    return MIstatus::success;
}

//++ ------------------------------------------------------------------------------------
// Details: Retrieve breakpoint information and write into the given breakpoint information
//          object. Note not all possible information is retrieved and so the information
//          object may need to be filled in with more information after calling this
//          function. Mainly breakpoint location information of information that is
//          unlikely to change.
// Type:    Method.
// Args:    vBrkPt      - (R) LLDB break point object.
//          vrBrkPtInfo - (W) Break point information object.
// Return:  MIstatus::success - Functional succeeded.
//          MIstatus::failure - Functional failed.
// Throws:  None.
//--
bool
CMICmnLLDBDebugSessionInfo::GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt, SBrkPtInfo &vrwBrkPtInfo) const
{
    lldb::SBBreakpoint &rBrkPt = const_cast<lldb::SBBreakpoint &>(vBrkPt);
    lldb::SBBreakpointLocation brkPtLoc = rBrkPt.GetLocationAtIndex(0);
    lldb::SBAddress brkPtAddr = brkPtLoc.GetAddress();
    lldb::SBSymbolContext symbolCntxt = brkPtAddr.GetSymbolContext(lldb::eSymbolContextEverything);
    const MIchar *pUnkwn = "??";
    lldb::SBModule rModule = symbolCntxt.GetModule();
    const MIchar *pModule = rModule.IsValid() ? rModule.GetFileSpec().GetFilename() : pUnkwn;
    MIunused(pModule);
    const MIchar *pFile = pUnkwn;
    const MIchar *pFn = pUnkwn;
    const MIchar *pFilePath = pUnkwn;
    size_t nLine = 0;
    const size_t nAddr = brkPtAddr.GetLoadAddress(m_lldbTarget);

    lldb::SBCompileUnit rCmplUnit = symbolCntxt.GetCompileUnit();
    if (rCmplUnit.IsValid())
    {
        lldb::SBFileSpec rFileSpec = rCmplUnit.GetFileSpec();
        pFile = rFileSpec.GetFilename();
        pFilePath = rFileSpec.GetDirectory();
        lldb::SBFunction rFn = symbolCntxt.GetFunction();
        if (rFn.IsValid())
            pFn = rFn.GetName();
        lldb::SBLineEntry rLnEntry = symbolCntxt.GetLineEntry();
        if (rLnEntry.GetLine() > 0)
            nLine = rLnEntry.GetLine();
    }

    vrwBrkPtInfo.m_id = vBrkPt.GetID();
    vrwBrkPtInfo.m_strType = "breakpoint";
    vrwBrkPtInfo.m_pc = nAddr;
    vrwBrkPtInfo.m_fnName = pFn;
    vrwBrkPtInfo.m_fileName = pFile;
    vrwBrkPtInfo.m_path = pFilePath;
    vrwBrkPtInfo.m_nLine = nLine;
    vrwBrkPtInfo.m_nTimes = vBrkPt.GetHitCount();

    return MIstatus::success;
}