Fix -stack-list-locals and -stack-list-arguments (MI)

[ki.stfu]

Summary

These changes include:

• Add eVariableInfoFormat argument for MIResponseFormVariableInfo{,2,3} and GetVariableInfo{,2} functions
• Fix -stack-list-locals and -stack-list-arguments: they ingored print-values
• Enable MiStackTestCase tests for -stack-list-xxx commands

All test pass on OS X.

[abidh]

Looks good to me. Although you can also handle --no-values, --all-values and --simple-values. I committed one patch yesterday that was using those for -var-list-children. I think eclipse uses those options instead of using --print-value.
Please note that I am working on a patch that touches the same area. It will be good if you can apply it quickly so that I can rebase my work to the latest.

[ki.stfu]

In D7462#119705, @abidh wrote:

Looks good to me. Although you can also handle --no-values, --all-values and --simple-values. I committed one patch yesterday that was using those for -var-list-children. I think eclipse uses those options instead of using --print-value.
Please note that I am working on a patch that touches the same area. It will be good if you can apply it quickly so that I can rebase my work to the latest.

I'll try to do it now.

[ki.stfu]

Update patch:

• Add --no-values/--all-values/--simple-values options
• Improve MiStackTestCase tests

[ki.stfu]

In D7462#119709, @ki.stfu wrote:

In D7462#119705, @abidh wrote:

Looks good to me. Although you can also handle --no-values, --all-values and --simple-values. I committed one patch yesterday that was using those for -var-list-children. I think eclipse uses those options instead of using --print-value.
Please note that I am working on a patch that touches the same area. It will be good if you can apply it quickly so that I can rebase my work to the latest.

I'll try to do it now.

I have done it. I gonna commit this patch today if there are no objections

[clayborg]

lgtm

lldb/trunk/test/tools/lldb-mi/TestMiStack.py

 """
 Test that the lldb-mi driver works with -stack-xxx commands
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("-stack-list-locals doesn't work properly")
     def test_lldbmi_stackargs(self):
         """Test that 'lldb-mi --interpreter' can shows arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-        # Test arguments
-        self.runCmd("-stack-list-arguments 0") #FIXME: --no-values doesn't work
+        # Test -stack-list-arguments: use 0 or --no-values
+        self.runCmd("-stack-list-arguments 0")
         self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[name=\"argc\",name=\"argv\"\]}")
+        self.runCmd("-stack-list-arguments --no-values")
+        self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[name=\"argc\",name=\"argv\"\]}")
+
+        # Test -stack-list-arguments: use 1 or --all-values
         self.runCmd("-stack-list-arguments 1")
         self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}")
+        self.runCmd("-stack-list-arguments --all-values")
+        self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}")
+
+        # Test -stack-list-arguments: use 2 or --simple-values
+        self.runCmd("-stack-list-arguments 2")
+        self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}")
+        self.runCmd("-stack-list-arguments --simple-values")
+        self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("-stack-list-locals doesn't work properly")
     def test_lldbmi_locals(self):
         """Test that 'lldb-mi --interpreter' can shows local variables."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         line = line_number('main.c', '//BP_localstest')
         self.runCmd("-break-insert --file main.c:%d" % line)
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-        # Test locals
-        self.runCmd("-stack-list-locals 0") #FIXME: --no-values doesn't work
+        # Test -stack-list-locals: use 0 or --no-values
+        self.runCmd("-stack-list-locals 0")
         self.expect("\^done,locals=\[name=\"a\",name=\"b\"\]")
+        self.runCmd("-stack-list-locals --no-values")
+        self.expect("\^done,locals=\[name=\"a\",name=\"b\"\]")
+
+        # Test -stack-list-locals: use 1 or --all-values
         self.runCmd("-stack-list-locals 1")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
+        self.runCmd("-stack-list-locals --all-values")
+        self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
+
+        # Test -stack-list-locals: use 2 or --simple-values
+        self.runCmd("-stack-list-locals 2")
+        self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
+        self.runCmd("-stack-list-locals --simple-values")
+        self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     def test_lldbmi_stackdepth(self):
         """Test that 'lldb-mi --interpreter' can shows depth of the stack."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/tools/lldb-mi/MICmdCmdStack.h

public:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmdCmdStackListArguments(void);
 
     // Attributes:
   private:
     bool m_bThreadInvalid; // True = yes invalid thread, false = thread object valid
     CMICmnMIValueList m_miValueList;
     const CMIUtilString m_constStrArgThread;      // Not specified in MI spec but Eclipse gives this option
-    const CMIUtilString m_constStrArgPrintValues; // Not handled by *this command
+    const CMIUtilString m_constStrArgPrintValues;
+    const CMIUtilString m_constStrArgNoValues;
+    const CMIUtilString m_constStrArgAllValues;
+    const CMIUtilString m_constStrArgSimpleValues;
 };
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "stack-list-locals".
 // Gotchas: None.
 // Authors: Illya Rudkin 24/03/2014.
 // Changes: None.
public:
     /* dtor */ virtual ~CMICmdCmdStackListLocals(void);
 
     // Attributes:
   private:
     bool m_bThreadInvalid; // True = yes invalid thread, false = thread object valid
     CMICmnMIValueList m_miValueList;
     const CMIUtilString m_constStrArgThread;      // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgFrame;       // Not specified in MI spec but Eclipse gives this option
-    const CMIUtilString m_constStrArgPrintValues; // Not handled by *this command
+    const CMIUtilString m_constStrArgPrintValues;
+    const CMIUtilString m_constStrArgNoValues;
+    const CMIUtilString m_constStrArgAllValues;
+    const CMIUtilString m_constStrArgSimpleValues;
 };

lldb/trunk/tools/lldb-mi/MICmdCmdStack.cpp

 // Return:  None.
 // Throws:  None.
 //--
 CMICmdCmdStackListArguments::CMICmdCmdStackListArguments(void)
     : m_bThreadInvalid(false)
     , m_miValueList(true)
     , m_constStrArgThread("thread")
     , m_constStrArgPrintValues("print-values")
+    , m_constStrArgNoValues("no-values")
+    , m_constStrArgAllValues("all-values")
+    , m_constStrArgSimpleValues("simple-values")
 {
     // Command factory matches this name with that received from the stdin stream
     m_strMiCmd = "stack-list-arguments";
 
     // Required by the CMICmdFactory when registering *this command
     m_pSelfCreatorFn = &CMICmdCmdStackListArguments::CreateSelf;
 }
 

 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListArguments::ParseArgs(void)
 {
     bool bOk =
         m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, true, false)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgNoValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgAllValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgSimpleValues, false, true)));
     return (bOk && ParseValidateCmdOptions());
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListArguments::Execute(void)
 {
     CMICMDBASE_GETOPTION(pArgThread, OptionLong, m_constStrArgThread);
     CMICMDBASE_GETOPTION(pArgPrintValues, Number, m_constStrArgPrintValues);
+    CMICMDBASE_GETOPTION(pArgNoValues, OptionLong, m_constStrArgNoValues);
+    CMICMDBASE_GETOPTION(pArgAllValues, OptionLong, m_constStrArgAllValues);
+    CMICMDBASE_GETOPTION(pArgSimpleValues, OptionLong, m_constStrArgSimpleValues);
 
     // Retrieve the --thread option's thread ID (only 1)
     MIuint64 nThreadId = UINT64_MAX;
     if (pArgThread->GetFound())
     {
         if (!pArgThread->GetExpectedOption<CMICmdArgValNumber, MIuint64>(nThreadId))
         {
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND), m_cmdData.strMiCmd.c_str(), m_constStrArgThread.c_str()));
             return MIstatus::failure;
         }
     }
 
+    CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e eVarInfoFormat;
+    if (pArgPrintValues->GetFound())
+    {
+        const MIuint nPrintValues = pArgPrintValues->GetValue();
+        if (nPrintValues >= CMICmnLLDBDebugSessionInfo::kNumVariableInfoFormats)
+        {
+            SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PRINT_VALUES), m_cmdData.strMiCmd.c_str()));
+            return MIstatus::failure;
+        }
+        eVarInfoFormat = static_cast<CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e>(nPrintValues);
+    }
+    else if (pArgNoValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_NoValues;
+    else if (pArgAllValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues;
+    else if (pArgSimpleValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues;
+    else
+    {
+        SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PRINT_VALUES), m_cmdData.strMiCmd.c_str()));
+        return MIstatus::failure;
+    }
+
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBThread thread = (nThreadId != UINT64_MAX) ? sbProcess.GetThreadByIndexID(nThreadId) : sbProcess.GetSelectedThread();
     m_bThreadInvalid = !thread.IsValid();
     if (m_bThreadInvalid)
         return MIstatus::success;
 
     const lldb::StopReason eStopReason = thread.GetStopReason();
     if ((eStopReason == lldb::eStopReasonNone) || (eStopReason == lldb::eStopReasonInvalid))
     {
         m_bThreadInvalid = true;
         return MIstatus::success;
     }
 
     const MIuint nFrames = thread.GetNumFrames();
     for (MIuint i = 0; i < nFrames; i++)
     {
         lldb::SBFrame frame = thread.GetFrameAtIndex(i);
         CMICmnMIValueList miValueList(true);
         const MIuint maskVarTypes = CMICmnLLDBDebugSessionInfo::eVariableType_Arguments;
-        if (!rSessionInfo.MIResponseFormVariableInfo3(frame, maskVarTypes, miValueList))
+        if (!rSessionInfo.MIResponseFormVariableInfo3(frame, maskVarTypes, eVarInfoFormat, miValueList))
             return MIstatus::failure;
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", i));
         const CMICmnMIValueResult miValueResult("level", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueResult miValueResult2("args", miValueList);
         miValueTuple.Add(miValueResult2);
         const CMICmnMIValueResult miValueResult3("frame", miValueTuple);
         m_miValueList.Add(miValueResult3);

 // Throws:  None.
 //--
 CMICmdCmdStackListLocals::CMICmdCmdStackListLocals(void)
     : m_bThreadInvalid(false)
     , m_miValueList(true)
     , m_constStrArgThread("thread")
     , m_constStrArgFrame("frame")
     , m_constStrArgPrintValues("print-values")
+    , m_constStrArgNoValues("no-values")
+    , m_constStrArgAllValues("all-values")
+    , m_constStrArgSimpleValues("simple-values")
 {
     // Command factory matches this name with that received from the stdin stream
     m_strMiCmd = "stack-list-locals";
 
     // Required by the CMICmdFactory when registering *this command
     m_pSelfCreatorFn = &CMICmdCmdStackListLocals::CreateSelf;
 }
 

 //--
 bool
 CMICmdCmdStackListLocals::ParseArgs(void)
 {
     bool bOk =
         m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
     bOk = bOk &&
           m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, true, false)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgNoValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgAllValues, false, true)));
+    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgSimpleValues, false, true)));
     return (bOk && ParseValidateCmdOptions());
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListLocals::Execute(void)
 {
     CMICMDBASE_GETOPTION(pArgThread, OptionLong, m_constStrArgThread);
     CMICMDBASE_GETOPTION(pArgFrame, OptionLong, m_constStrArgFrame);
+    CMICMDBASE_GETOPTION(pArgPrintValues, Number, m_constStrArgPrintValues);
+    CMICMDBASE_GETOPTION(pArgNoValues, OptionLong, m_constStrArgNoValues);
+    CMICMDBASE_GETOPTION(pArgAllValues, OptionLong, m_constStrArgAllValues);
+    CMICMDBASE_GETOPTION(pArgSimpleValues, OptionLong, m_constStrArgSimpleValues);
 
     // Retrieve the --thread option's thread ID (only 1)
     MIuint64 nThreadId = UINT64_MAX;
     if (pArgThread->GetFound())
     {
         if (!pArgThread->GetExpectedOption<CMICmdArgValNumber, MIuint64>(nThreadId))
         {
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND), m_cmdData.strMiCmd.c_str(), m_constStrArgThread.c_str()));
             return MIstatus::failure;
         }
     }
+
     MIuint64 nFrame = UINT64_MAX;
     if (pArgFrame->GetFound())
     {
         if (!pArgFrame->GetExpectedOption<CMICmdArgValNumber, MIuint64>(nFrame))
         {
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND), m_cmdData.strMiCmd.c_str(), m_constStrArgFrame.c_str()));
             return MIstatus::failure;
         }
     }
 
+    CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e eVarInfoFormat;
+    if (pArgPrintValues->GetFound())
+    {
+        const MIuint nPrintValues = pArgPrintValues->GetValue();
+        if (nPrintValues >= CMICmnLLDBDebugSessionInfo::kNumVariableInfoFormats)
+        {
+            SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PRINT_VALUES), m_cmdData.strMiCmd.c_str()));
+            return MIstatus::failure;
+        }
+        eVarInfoFormat = static_cast<CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e>(nPrintValues);
+    }
+    else if (pArgNoValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_NoValues;
+    else if (pArgAllValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues;
+    else if (pArgSimpleValues->GetFound())
+        eVarInfoFormat = CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues;
+    else
+    {
+        SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_PRINT_VALUES), m_cmdData.strMiCmd.c_str()));
+        return MIstatus::failure;
+    }
+
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBThread thread = (nThreadId != UINT64_MAX) ? sbProcess.GetThreadByIndexID(nThreadId) : sbProcess.GetSelectedThread();
     m_bThreadInvalid = !thread.IsValid();
     if (m_bThreadInvalid)
         return MIstatus::success;
 
     const lldb::StopReason eStopReason = thread.GetStopReason();
     if ((eStopReason == lldb::eStopReasonNone) || (eStopReason == lldb::eStopReasonInvalid))
     {
         m_bThreadInvalid = true;
         return MIstatus::success;
     }
 
-    const MIuint nFrames = thread.GetNumFrames();
-    MIunused(nFrames);
     lldb::SBFrame frame = (nFrame != UINT64_MAX) ? thread.GetFrameAtIndex(nFrame) : thread.GetSelectedFrame();
+
     CMICmnMIValueList miValueList(true);
     const MIuint maskVarTypes = CMICmnLLDBDebugSessionInfo::eVariableType_Locals;
-    if (!rSessionInfo.MIResponseFormVariableInfo(frame, maskVarTypes, miValueList))
+    if (!rSessionInfo.MIResponseFormVariableInfo(frame, maskVarTypes, eVarInfoFormat, miValueList))
         return MIstatus::failure;
 
     m_miValueList = miValueList;
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugSessionInfo.h

public:
     enum VariableType_e
     {
         eVariableType_InScope   = (1u << 0), // In scope only.
         eVariableType_Statics   = (1u << 1), // Statics.
         eVariableType_Locals    = (1u << 2), // Locals.
         eVariableType_Arguments = (1u << 3)  // Arguments.
     };
 
+    //++ ===================================================================
+    // Details: Determine the information that should be shown by using MIResponseFormVariableInfo family functions.
+    //--
+    enum VariableInfoFormat_e
+    {
+        eVariableInfoFormat_NoValues,
+        eVariableInfoFormat_AllValues,
+        eVariableInfoFormat_SimpleValues,
+        kNumVariableInfoFormats
+    };
+
     // Typedefs:
   public:
     typedef std::vector<uint32_t> VecActiveThreadId_t;
 
     // Methods:
   public:
     bool Initialize(void);
     bool Shutdown(void);
public:
     bool MIResponseFormFrameInfo(const lldb::addr_t vPc, const CMIUtilString &vFnName, const CMIUtilString &vFileName,
                                  const CMIUtilString &vPath, const MIuint vnLine, CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormFrameInfo2(const lldb::addr_t vPc, const CMIUtilString &vArgInfo, const CMIUtilString &vFnName,
                                   const CMIUtilString &vFileName, const CMIUtilString &vPath, const MIuint vnLine,
                                   CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormThreadInfo2(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormThreadInfo3(const SMICmdData &vCmdData, const lldb::SBThread &vrThread, CMICmnMIValueTuple &vwrMIValueTuple);
-    bool MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList &vwrMiValueList);
-    bool MIResponseFormVariableInfo2(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList &vwrMiValueList);
-    bool MIResponseFormVariableInfo3(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes, CMICmnMIValueList &vwrMiValueList);
+    bool MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
+                                    const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
+    bool MIResponseFormVariableInfo2(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
+                                     const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
+    bool MIResponseFormVariableInfo3(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
+                                     const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList);
     bool MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormBrkPtInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfo(const MIuint vnBrkPtId, const SBrkPtInfo &vrBrkPtInfo);
     bool RecordBrkPtInfoGet(const MIuint vnBrkPtId, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfoDelete(const MIuint vnBrkPtId);
     CMIUtilThreadMutex& GetSessionMutex() { return m_sessionMutex;}
     lldb::SBDebugger &GetDebugger() const;
private:
 
     // Methods:
   private:
     /* ctor */ CMICmnLLDBDebugSessionInfo(void);
     /* ctor */ CMICmnLLDBDebugSessionInfo(const CMICmnLLDBDebugSessionInfo &);
     void operator=(const CMICmnLLDBDebugSessionInfo &);
     //
     bool GetVariableInfo(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                         CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
+                         const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
     bool GetVariableInfo2(const MIuint vnMaxDepth, const lldb::SBValue &vrValue, const bool vbIsChildValue,
-                          CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
+                          const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList, MIuint &vrwnDepth);
 
     // Overridden:
   private:
     // From CMICmnBase
     /* dtor */ virtual ~CMICmnLLDBDebugSessionInfo(void);
 
     // Attributes:
   private:

lldb/trunk/tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

for (MIuint nLevel = 0; nLevel < nFrames; nLevel++)
         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))
+        if (!MIResponseFormVariableInfo(frame, maskVarTypes, eVariableInfoFormat_AllValues, 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(), '\'', ' ');
for (MIuint nLevel = 0; nLevel < nFrames; nLevel++)
         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))
+        if (!MIResponseFormVariableInfo2(frame, maskVarTypes, eVariableInfoFormat_AllValues, 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(), '\'', ' ');

 
 // 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.
+//          veVarInfoFormat - (R)   The type of variable info that should be shown.
 //          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)
+                                                        const VariableInfoFormat_e veVarInfoFormat, 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);

 }
 
 //++ ------------------------------------------------------------------------------------
 // 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.
+//          veVarInfoFormat - (R)   The type of variable info that should be shown.
 //          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)
+                                                       const VariableInfoFormat_e veVarInfoFormat, 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);
+        bOk = GetVariableInfo(nMaxRecusiveDepth, value, false, veVarInfoFormat, 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.
+//          veVarInfoFormat - (R)   The type of variable info that should be shown.
 //          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)
+                                                        const VariableInfoFormat_e veVarInfoFormat, 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);
+        bOk = GetVariableInfo2(nMaxRecusiveDepth, value, false, veVarInfoFormat, 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.
+//          veVarInfoFormat - (R)  The type of variable info that should be shown.
 //          vwrMIValueList  - (W)  MI value list object.
 //          vnDepth         - (RW) The current recursive depth of this function.
-//          // Return:  MIstatus::success - Functional succeeded.
+// 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)
+                                            const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
+                                            MIuint &vrwnDepth)
 {
     // *** Update GetVariableInfo2() with any code changes here ***
 
     // Check recursive depth
     if (vrwnDepth >= vnMaxDepth)
         return MIstatus::success;
 
     bool bOk = MIstatus::success;
if (nChildren == 0)
                     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
+            switch (veVarInfoFormat)
+            {
+                case eVariableInfoFormat_NoValues:
+                {
+                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                    const CMICmnMIValueResult miValueResult("name", miValueConst);
+                    return vwrMiValueList.Add(miValueResult);
+                }
+                case eVariableInfoFormat_AllValues:
+                case eVariableInfoFormat_SimpleValues:
+                {
                     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);
+                    break;
+                }
+                default:
+                    break;
+            }
             return vwrMiValueList.Add(miValueTuple);
         }
     }
     else if (bIsPointerType && utilValue.IsChildCharType())
     {
+        switch (veVarInfoFormat)
+        {
+            case eVariableInfoFormat_NoValues:
+            {
+                const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                const CMICmnMIValueResult miValueResult("name", miValueConst);
+                return vwrMiValueList.Add(miValueResult);
+            }
+            case eVariableInfoFormat_AllValues:
+            case eVariableInfoFormat_SimpleValues:
+            {
                 // 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);
                     }
                 }
+                break;
+            }
+            default:
+                break;
+        }
         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
+            switch (veVarInfoFormat)
+            {
+                case eVariableInfoFormat_NoValues:
+                {
+                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                    const CMICmnMIValueResult miValueResult("name", miValueConst);
+                    return vwrMiValueList.Add(miValueResult);
+                }
+                case eVariableInfoFormat_AllValues:
+                case eVariableInfoFormat_SimpleValues:
+                {
                     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);
+                    break;
+                }
+                default:
+                    break;
+            }
             return vwrMiValueList.Add(miValueTuple);
         }
     }
     else
     {
+        switch (veVarInfoFormat)
+        {
+            case eVariableInfoFormat_NoValues:
+            {
+                const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                const CMICmnMIValueResult miValueResult("name", miValueConst);
+                return vwrMiValueList.Add(miValueResult);
+            }
+            case eVariableInfoFormat_AllValues:
+            case eVariableInfoFormat_SimpleValues:
+            {
                 // 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);
+                    bOk = GetVariableInfo(vnMaxDepth, member, true, veVarInfoFormat, 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);
+                break;
+            }
+            default:
+                break;
+        }
         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.
+//          veVarInfoFormat - (R)  The type of variable info that should be shown.
 //          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)
+                                             const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
+                                             MIuint &vrwnDepth)
 {
     // *** Update GetVariableInfo() with any code changes here ***
 
     // Check recursive depth
     if (vrwnDepth >= vnMaxDepth)
         return MIstatus::success;
 
     bool bOk = MIstatus::success;
if (nChildren == 0)
             // 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
+            switch (veVarInfoFormat)
+            {
+                case eVariableInfoFormat_NoValues:
+                {
+                    const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                    const CMICmnMIValueResult miValueResult("name", miValueConst);
+                    return vwrMiValueList.Add(miValueResult);
+                }
+                case eVariableInfoFormat_AllValues:
+                case eVariableInfoFormat_SimpleValues:
+                {
                     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);
+                    break;
+                }
+                default:
+                    break;
+            }
             return vwrMiValueList.Add(miValueTuple);
         }
     }
     else if (utilValue.IsChildCharType())
     {
+        switch (veVarInfoFormat)
+        {
+            case eVariableInfoFormat_NoValues:
+            {
+                const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                const CMICmnMIValueResult miValueResult("name", miValueConst);
+                return vwrMiValueList.Add(miValueResult);
+            }
+            case eVariableInfoFormat_AllValues:
+            case eVariableInfoFormat_SimpleValues:
+            {
                 // 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);
                     }
                 }
+                break;
+            }
+            default:
+                break;
+        }
         return vwrMiValueList.Add(miValueTuple);
     }
     else
     {
+        switch (veVarInfoFormat)
+        {
+            case eVariableInfoFormat_NoValues:
+            {
+                const CMICmnMIValueConst miValueConst(utilValue.GetName());
+                const CMICmnMIValueResult miValueResult("name", miValueConst);
+                return vwrMiValueList.Add(miValueResult);
+            }
+            case eVariableInfoFormat_AllValues:
+            case eVariableInfoFormat_SimpleValues:
+            {
                 // 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);
+                    bOk = GetVariableInfo(vnMaxDepth, member, true, veVarInfoFormat, 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);
+                break;
+            }
+            default:
+                break;
+        }
         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.

lldb/trunk/tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

CMICmnLLDBDebuggerHandleEvents::MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt)
     CMICmnMIValueResult miValueResultB("bkptno", miValueConstB);
     bOk = bOk && miOutOfBandRecord.Add(miValueResultB);
 
     // frame={addr=\"0x%08x\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"}
     if (bOk)
     {
         CMICmnMIValueList miValueList(true);
         const MIuint maskVarTypes = CMICmnLLDBDebugSessionInfo::eVariableType_Arguments;
-        bOk = rSession.MIResponseFormVariableInfo2(frame, maskVarTypes, miValueList);
+        bOk = rSession.MIResponseFormVariableInfo2(frame, maskVarTypes, CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues, miValueList);
 
         CMICmnMIValueTuple miValueTuple;
         bOk = bOk && rSession.MIResponseFormFrameInfo2(pc, miValueList.GetString(), fnName, fileName, path, nLine, miValueTuple);
         const CMICmnMIValueResult miValueResult8("frame", miValueTuple);
         bOk = bOk && miOutOfBandRecord.Add(miValueResult8);
     }
 
     // Add to MI thread-id=\"%d\",stopped-threads=\"all\"
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopReasonTrace(void)
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBOUTOFBAND_ERR_FRAME_INFO_GET), "HandleProcessEventStopReasonTrace()"));
         return MIstatus::failure;
     }
 
     // Function args
     CMICmnMIValueList miValueList(true);
     const MIuint maskVarTypes = CMICmnLLDBDebugSessionInfo::eVariableType_Arguments;
-    if (!rSession.MIResponseFormVariableInfo2(frame, maskVarTypes, miValueList))
+    if (!rSession.MIResponseFormVariableInfo2(frame, maskVarTypes, CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues, miValueList))
         return MIstatus::failure;
     CMICmnMIValueTuple miValueTuple;
     if (!rSession.MIResponseFormFrameInfo2(pc, miValueList.GetString(), fnName, fileName, path, nLine, miValueTuple))
         return MIstatus::failure;
 
     const CMICmnMIValueConst miValueConst("end-stepping-range");
     const CMICmnMIValueResult miValueResult("reason", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);

lldb/trunk/tools/lldb-mi/MICmnResources.h

enum
     IDS_CMD_ERR_CMD_RUN_BUT_NO_ACTION,
     IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION,
     IDS_CMD_ERR_DISASM_ADDR_START_INVALID,
     IDS_CMD_ERR_DISASM_ADDR_END_INVALID,
     IDS_CMD_ERR_MEMORY_ALLOC_FAILURE,
     IDS_CMD_ERR_LLDB_ERR_NOT_READ_WHOLE_BLK,
     IDS_CMD_ERR_LLDB_ERR_READ_MEM_BYTES,
     IDS_CMD_ERR_INVALID_PROCESS,
+    IDS_CMD_ERR_INVALID_PRINT_VALUES,
     IDS_CMD_ERR_INVALID_FORMAT_TYPE,
     IDS_CMD_ERR_BRKPT_INFO_OBJ_NOT_FOUND,
     IDS_CMD_ERR_LLDB_ERR_WRITE_MEM_BYTES,
     IDS_CMD_ERR_LLDB_ERR_NOT_WRITE_WHOLEBLK,
     IDS_CMD_ERR_SET_NEW_DRIVER_STATE,
     IDS_CMD_ERR_INFO_PRINTFN_NOT_FOUND,
     IDS_CMD_ERR_INFO_PRINTFN_FAILED,
     IDS_CMD_ERR_GDBSET_OPT_SOLIBSEARCHPATH

lldb/trunk/tools/lldb-mi/MICmnResources.cpp

const CMICmnResources::SRsrcTextData CMICmnResources::ms_pResourceId2TextData[] = {
     {IDS_CMD_ERR_CMD_RUN_BUT_NO_ACTION, "<Error: Command run but command did not do anything useful. No MI response formed>"},
     {IDS_CMD_ERR_EVENT_HANDLED_BUT_NO_ACTION, "<Error: Command run and event caught, did nothing useful. No MI Out-of-Bound formed>"},
     {IDS_CMD_ERR_DISASM_ADDR_START_INVALID, "Command '%s'. Invalid start value '%s'"},
     {IDS_CMD_ERR_DISASM_ADDR_END_INVALID, "Command '%s'. Invalid end value '%s'"},
     {IDS_CMD_ERR_MEMORY_ALLOC_FAILURE, "Command '%s'. Failed to allocate memory %d bytes"},
     {IDS_CMD_ERR_LLDB_ERR_NOT_READ_WHOLE_BLK, "Command '%s'. LLDB unable to read entire memory block of %u bytes at address 0x%08x"},
     {IDS_CMD_ERR_LLDB_ERR_READ_MEM_BYTES, "Command '%s'. Unable to read memory block of %u bytes at address 0x%08x: %s "},
     {IDS_CMD_ERR_INVALID_PROCESS, "Command '%s'. Invalid process during debug session"},
+    {IDS_CMD_ERR_INVALID_PRINT_VALUES, "Command '%s'. Unknown value for PRINT_VALUES: must be: 0 or \"--no-values\", 1 or \"all-values\", 2 or \"simple-values\""},
     {IDS_CMD_ERR_INVALID_FORMAT_TYPE, "Command '%s'. Invalid var format type '%s'"},
     {IDS_CMD_ERR_BRKPT_INFO_OBJ_NOT_FOUND, "Command '%s'. Breakpoint information for breakpoint ID %d not found"},
     {IDS_CMD_ERR_LLDB_ERR_READ_MEM_BYTES, "Command '%s'. Unable to write memory block of %u bytes at address 0x%08x: %s "},
     {IDS_CMD_ERR_LLDB_ERR_NOT_WRITE_WHOLEBLK, "Command '%s'. LLDB unable to write entire memory block of %u bytes at address 0x%08x"},
     {IDS_CMD_ERR_SET_NEW_DRIVER_STATE, "Command '%s'. Command tried to set new MI Driver running state and failed. %s"},
     {IDS_CMD_ERR_INFO_PRINTFN_NOT_FOUND, "The request '%s' was not recogised, not implemented"},
     {IDS_CMD_ERR_INFO_PRINTFN_FAILED, "The request '%s' failed."},
     {IDS_CMD_ERR_GDBSET_OPT_SOLIBSEARCHPATH, "'solib-search-path' requires at least one argument"}};