Fix evaluation commands (MI)

[ki.stfu]

Summary

These changes include:

• Fix -var-create to be able use current frame '*' (MI)
• Fix print-values option in -var-update (MI)
• Fix 'variable doesn't exist' error in -var-show-attributes (MI)
• Mark print-values option as 'handled-by-cmd' in -var-update (MI)
• Fix SBValue::GetValueDidChange if value was changed
• Fix lldb-mi: -data-evaluate-expression shows undef vars. Before this fix -data-evaluate-expression perceives undefined variables as strings:

(gdb)
-data-evaluate-expression undef
^done,value="undef"

• Minor fix: -data-evaluate-expression uses IsUnknownValue()
• Enable MiEvaluateTestCase test

All test pass on OS X.

[clayborg]

Looks good

lldb/trunk/source/API/SBValue.cpp

 SBValue::GetValueDidChange ()
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     bool result = false;
     ValueLocker locker;
     lldb::ValueObjectSP value_sp(GetSP(locker));
     if (value_sp)
     {
+        if (value_sp->UpdateValueIfNeeded(false))
             result = value_sp->GetValueDidChange ();
     }
     if (log)
         log->Printf ("SBValue(%p)::GetValueDidChange() => %i",
                      static_cast<void*>(value_sp.get()), result);
 
     return result;
 }
 

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

 """
 Test that the lldb-mi driver can evaluate expressions.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiEvaluateTestCase(lldbmi_testcase.MiTestCaseBase):
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("evaluation doesn't work properly")
     def test_lldbmi_eval(self):
         """Test that 'lldb-mi --interpreter' works for evaluating."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

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

CMICmdCmdDataEvaluateExpression::Execute(void)
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBThread thread = sbProcess.GetSelectedThread();
     m_bExpressionValid = (thread.GetNumFrames() > 0);
     if (!m_bExpressionValid)
         return MIstatus::success;
 
     lldb::SBFrame frame = thread.GetSelectedFrame();
     lldb::SBValue value = frame.EvaluateExpression(rExpression.c_str());
-    if (!value.IsValid())
+    if (!value.IsValid() || value.GetError().Fail())
         value = frame.FindVariable(rExpression.c_str());
-    if (!value.IsValid())
+    const CMICmnLLDBUtilSBValue utilValue(value);
+    if (!utilValue.IsValid() || utilValue.IsValueUnknown())
     {
         m_bEvaluatedExpression = false;
         return MIstatus::success;
     }
-    const CMICmnLLDBUtilSBValue utilValue(value);
     if (!utilValue.HasName())
     {
         if (HaveInvalidCharacterInExpression(rExpression, m_cExpressionInvalidChar))
         {
             m_bFoundInvalidChar = true;
             return MIstatus::success;
         }
 

 // Args:    vrExpr          - (R) Expression string given to *this command.
 //          vrwInvalidChar  - (W) True = Invalid character found, false = nothing found.
 // Return:  bool - True = Invalid character found, false = nothing found.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataEvaluateExpression::HaveInvalidCharacterInExpression(const CMIUtilString &vrExpr, MIchar &vrwInvalidChar)
 {
-    bool bFoundInvalidCharInExpression = false;
-    vrwInvalidChar = 0x00;
-
-    if (vrExpr.at(0) == '\\')
-    {
-        // Example: Mouse hover over "%5d" expression has \"%5d\" in it
-        bFoundInvalidCharInExpression = true;
-        vrwInvalidChar = '\\';
-    }
-
+    static const std::string strInvalidCharacters(";#\\");
+    const size_t nInvalidCharacterOffset = vrExpr.find_first_of(strInvalidCharacters);
+    const bool bFoundInvalidCharInExpression = (nInvalidCharacterOffset != CMIUtilString::npos);
+    vrwInvalidChar = bFoundInvalidCharInExpression ? vrExpr[nInvalidCharacterOffset] : 0x00;
     return bFoundInvalidCharInExpression;
 }
 
 //---------------------------------------------------------------------------------------
 //---------------------------------------------------------------------------------------
 //---------------------------------------------------------------------------------------
 
 //++ ------------------------------------------------------------------------------------

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

 //--
 
 #pragma once
 
 // In-house headers:
 #include "MICmdBase.h"
 #include "MICmnMIValueTuple.h"
 #include "MICmnMIValueList.h"
+#include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnLLDBDebugSessionInfoVarObj.h"
 
 // Declarations:
 class CMICmnLLDBDebugSessionInfoVarObj;
 
 //++ ============================================================================
 // Details: MI command class. MI commands derived from the command base class.
 //          *this class implements MI command "var-create".
public:
     // Methods:
   private:
     bool ExamineSBValueForChange(const CMICmnLLDBDebugSessionInfoVarObj &vrVarObj, const bool vbIgnoreVarType, bool &vrwbChanged);
     bool MIFormResponse(const CMIUtilString &vrStrVarName, const CMIUtilString &vrStrValue, const CMIUtilString &vrStrScope);
 
     // Attribute:
   private:
     CMIUtilString m_strValueName;
+    CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e m_eVarInfoFormat;
     const CMIUtilString m_constStrArgPrintValues; // Not handled by *this command
     const CMIUtilString m_constStrArgName;
     bool m_bValueChangedArrayType;     // True = yes value changed, false = no change
     bool m_bValueChangedCompositeType; // True = yes value changed, false = no change
     bool m_bValueChangedNormalType;    // True = yes value changed, false = no change
     CMICmnMIValueList m_miValueList;
 };
 

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

CMICmdCmdVarCreate::Execute(void)
     if (pArgThread->GetFound() && !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;
     }
 
     // Retrieve the --frame option's number
     MIuint64 nFrame = UINT64_MAX;
-    if (!pArgFrame->GetExpectedOption<CMICmdArgValNumber, MIuint64>(nFrame))
+    if (pArgThread->GetFound() && !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;
     }
 
     const CMICmdArgValOptionLong::VecArgObjPtr_t &rVecFrameId(pArgFrame->GetExpectedOptions());
     CMICmdArgValOptionLong::VecArgObjPtr_t::const_iterator it2 = rVecFrameId.begin();
     if (it2 != rVecFrameId.end())
     {
         const CMICmdArgValNumber *pOption = static_cast<CMICmdArgValNumber *>(*it2);
         nFrame = pOption->GetValue();
     }
 
-    bool bAutoName = false;
-    const CMIUtilString strArgName;
+    m_strVarName = "<unnamedvariable>";
     if (pArgName->GetFound())
     {
         const CMIUtilString &rArg = pArgName->GetValue();
-        bAutoName = (rArg == "-");
+        const bool bAutoName = (rArg == "-");
+        if (bAutoName)
+        {
+            m_strVarName = CMIUtilString::Format("var%u", CMICmnLLDBDebugSessionInfoVarObj::VarObjIdGet());
+            CMICmnLLDBDebugSessionInfoVarObj::VarObjIdInc();
+        }
+        else
+            m_strVarName = rArg;
+    }
+
+    bool bCurrentFrame = false;
+    if (pArgFrameAddr->GetFound())
+    {
+        const CMIUtilString &rStrFrameAddr(pArgFrameAddr->GetValue());
+        bCurrentFrame = CMIUtilString::Compare(rStrFrameAddr, "*");
+        if (!bCurrentFrame && (nFrame == UINT64_MAX))
+        {
+            //FIXME: *addr isn't implemented. Exit with error if --thread isn't specified.
+            SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_OPTION_NOT_FOUND), m_cmdData.strMiCmd.c_str(), m_constStrArgFrame.c_str()));
+            return MIstatus::failure;
+        }
     }
 
     const CMIUtilString &rStrExpression(pArgExpression->GetValue());
     m_strExpression = rStrExpression;
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
-    m_strVarName = "<unnamedvariable>";
-    if (bAutoName)
-    {
-        m_strVarName = CMIUtilString::Format("var%u", CMICmnLLDBDebugSessionInfoVarObj::VarObjIdGet());
-        CMICmnLLDBDebugSessionInfoVarObj::VarObjIdInc();
-    }
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBThread thread = (nThreadId != UINT64_MAX) ? sbProcess.GetThreadByIndexID(nThreadId) : sbProcess.GetSelectedThread();
     m_nThreadId = thread.GetIndexID();
-    lldb::SBFrame frame = thread.GetFrameAtIndex(nFrame);
+    lldb::SBFrame frame = bCurrentFrame ? thread.GetSelectedFrame() : thread.GetFrameAtIndex(nFrame);
     lldb::SBValue value = frame.FindVariable(rStrExpression.c_str());
     if (!value.IsValid())
         value = frame.EvaluateExpression(rStrExpression.c_str());
     if (value.IsValid())
     {
         m_bValid = true;
         m_nChildren = value.GetNumChildren();
         m_strType = CMICmnLLDBUtilSBValue(value).GetTypeNameDisplay();

 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdVarUpdate constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmdCmdVarUpdate::CMICmdCmdVarUpdate(void)
-    : m_constStrArgPrintValues("print-values")
+    : m_eVarInfoFormat(CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_NoValues)
+    , m_constStrArgPrintValues("print-values")
     , m_constStrArgName("name")
     , m_bValueChangedArrayType(false)
     , m_bValueChangedCompositeType(false)
     , m_bValueChangedNormalType(false)
     , m_miValueList(true)
 {
     // Command factory matches this name with that received from the stdin stream
     m_strMiCmd = "var-update";

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarUpdate::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, false, false)));
+    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPrintValues, false, true)));
     bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, 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
 CMICmdCmdVarUpdate::Execute(void)
 {
+    CMICMDBASE_GETOPTION(pArgPrintValues, Number, m_constStrArgPrintValues);
     CMICMDBASE_GETOPTION(pArgName, String, m_constStrArgName);
 
     const CMIUtilString &rVarObjName(pArgName->GetValue());
     CMICmnLLDBDebugSessionInfoVarObj varObj;
     if (!CMICmnLLDBDebugSessionInfoVarObj::VarObjGet(rVarObjName, varObj))
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_VARIABLE_DOESNOTEXIST), m_cmdData.strMiCmd.c_str(), rVarObjName.c_str()));
         return MIstatus::failure;
     }
 
+    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;
+    }
+    m_eVarInfoFormat = static_cast<CMICmnLLDBDebugSessionInfo::VariableInfoFormat_e>(nPrintValues);
+
     const CMIUtilString &rVarRealName(varObj.GetNameReal());
     MIunused(rVarRealName);
     lldb::SBValue &rValue = const_cast<lldb::SBValue &>(varObj.GetValue());
     const bool bValid = rValue.IsValid();
     if (bValid && rValue.GetValueDidChange())
     {
         m_bValueChangedNormalType = true;
         varObj.UpdateValue();
if (m_bValueChangedArrayType || m_bValueChangedNormalType)
         const bool bValid = rValue.IsValid();
         const CMIUtilString strValue(bValid ? varObj.GetValueFormatted() : "<unknown>");
         const CMIUtilString strInScope((bValid && rValue.IsInScope()) ? "true" : "false");
 
         // MI print "%s^done,changelist=[{name=\"%s\",value=\"%s\",in_scope=\"%s\",type_changed=\"false\",has_more=\"0\"}]"
         const CMICmnMIValueConst miValueConst(m_strValueName);
         CMICmnMIValueResult miValueResult("name", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
+        if (m_eVarInfoFormat != CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_NoValues)
+        {
             const CMICmnMIValueConst miValueConst2(strValue);
             CMICmnMIValueResult miValueResult2("value", miValueConst2);
             miValueTuple.Add(miValueResult2);
+        }
         const CMICmnMIValueConst miValueConst3(strInScope);
         CMICmnMIValueResult miValueResult3("in_scope", miValueConst3);
         miValueTuple.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst4("false");
         CMICmnMIValueResult miValueResult4("type_changed", miValueConst4);
         miValueTuple.Add(miValueResult4);
         const CMICmnMIValueConst miValueConst5("0");
         CMICmnMIValueResult miValueResult5("has_more", miValueConst5);

 //--
 bool
 CMICmdCmdVarShowAttributes::Execute(void)
 {
     CMICMDBASE_GETOPTION(pArgName, String, m_constStrArgName);
 
     const CMIUtilString &rVarObjName(pArgName->GetValue());
     CMICmnLLDBDebugSessionInfoVarObj varObj;
-    if (CMICmnLLDBDebugSessionInfoVarObj::VarObjGet(rVarObjName, varObj))
+    if (!CMICmnLLDBDebugSessionInfoVarObj::VarObjGet(rVarObjName, varObj))
     {
         SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_VARIABLE_DOESNOTEXIST), m_cmdData.strMiCmd.c_str(), rVarObjName.c_str()));
         return MIstatus::failure;
     }
 
     return MIstatus::success;
 }