[LLDB-MI] Minor cleanup of CMICmnLLDBUtilSBValue class

[enlight]

Summary

Placeholder c-strings don't need to be instance variables.

[ki.stfu]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

21–22

use unnamed namespace here

22

I dislike Placeholder suffix because the previous one is also a placeholder for unknown values. How about renaming to kUnresolvedValue/kUnresolvedCompositeValue?

[enlight]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

21–22

I would like to use an anonymous namespace but the LLVM coding standards say

make anonymous namespaces as small as possible, and only use them for class declarations

I don't really buy their reasoning, but we are supposed to be following their style now aren't we?

kUnresolvedValue/kUnresolvedCompositeValue does sound better, I'll rename them.

[enlight]

Renamed placeholder c-strings.

[ki.stfu]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

21–22

Okay, we have to follow the coding style.

22

Actually I like kUnknownValue and I meant to rename the second one only. But it looks good to me also.

[ki.stfu]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

116

After couple of minutes I see the lack of logic there: the value is still composite but we return kUnresolvedValue instead of kUnresolvedCompositeValue.

I think we have to rename kUnresolvedValue back to kUnknownValue.

[enlight]

Rename kUnresolvedValue back to kUknownValue.

[enlight]

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

116

Yep, good point, I've renamed it back.

tools/lldb-mi/MICmnLLDBUtilSBValue.h

private:
 
   // Statics:
 private:
   static bool IsCharBasicType(lldb::BasicType eType);
 
   // Attributes:
 private:
   lldb::SBValue &m_rValue;
-  const char *m_pUnkwn;
-  const char *m_pComposite;
   bool m_bValidSBValue; // True = SBValue is a valid object, false = not valid.
   bool m_bHandleCharType;  // True = Yes return text molding to char type, false
                            // = just return data.
   bool m_bHandleArrayType; // True = Yes return special stub for array type,
                            // false = just return data.
 };

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

 
 // In-house headers:
 #include "MICmnLLDBDebugSessionInfo.h"
 #include "MICmnLLDBUtilSBValue.h"
 #include "MICmnMIValueConst.h"
 #include "MICmnMIValueTuple.h"
 #include "MIUtilString.h"
 
+static const char *kUnknownValue = "??";
+static const char *kUnresolvedCompositeValue = "{...}";
+
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnLLDBUtilSBValue constructor.
 // Type:    Method.
 // Args:    vrValue             - (R) The LLDB value object.
 //          vbHandleCharType    - (R) True = Yes return text molding to char
 //          type,
 //                                    False = just return data.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnLLDBUtilSBValue::CMICmnLLDBUtilSBValue(
     const lldb::SBValue &vrValue, const bool vbHandleCharType /* = false */,
     const bool vbHandleArrayType /* = true */)
-    : m_rValue(const_cast<lldb::SBValue &>(vrValue)), m_pUnkwn("??"),
-      m_pComposite("{...}"), m_bHandleCharType(vbHandleCharType),
+    : m_rValue(const_cast<lldb::SBValue &>(vrValue)),
+      m_bHandleCharType(vbHandleCharType),
       m_bHandleArrayType(vbHandleArrayType) {
   m_bValidSBValue = m_rValue.IsValid();
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnLLDBUtilSBValue destructor.
 // Type:    Method.

 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - Text description of the variable's value or "??".
 // Throws:  None.
 //--
 CMIUtilString CMICmnLLDBUtilSBValue::GetValue(
     const bool vbExpandAggregates /* = false */) const {
   if (!m_bValidSBValue)
-    return m_pUnkwn;
+    return kUnknownValue;
 
   CMICmnLLDBDebugSessionInfo &rSessionInfo(
       CMICmnLLDBDebugSessionInfo::Instance());
   bool bPrintExpandAggregates = false;
   bPrintExpandAggregates = rSessionInfo.SharedDataRetrieve<bool>(
                                rSessionInfo.m_constStrPrintExpandAggregates,
                                bPrintExpandAggregates) &&
                            bPrintExpandAggregates;
 
   const bool bHandleArrayTypeAsSimple =
       m_bHandleArrayType && !vbExpandAggregates && !bPrintExpandAggregates;
   CMIUtilString value;
   const bool bIsSimpleValue = GetSimpleValue(bHandleArrayTypeAsSimple, value);
   if (bIsSimpleValue)
     return value;
 
   if (!vbExpandAggregates && !bPrintExpandAggregates)
-    return m_pComposite;
+    return kUnresolvedCompositeValue;
 
   bool bPrintAggregateFieldNames = false;
   bPrintAggregateFieldNames =
       !rSessionInfo.SharedDataRetrieve<bool>(
           rSessionInfo.m_constStrPrintAggregateFieldNames,
           bPrintAggregateFieldNames) ||
       bPrintAggregateFieldNames;
 
   CMICmnMIValueTuple miValueTuple;
   const bool bOk = GetCompositeValue(bPrintAggregateFieldNames, miValueTuple);
   if (!bOk)
-    return m_pUnkwn;
+    return kUnknownValue;
 
   value = miValueTuple.GetString();
   return value;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve from the LLDB SB Value object the value of the variable
 // described in
 //          text if it has a simple format (not composite).
 // Type:    Method.
 // Args:    vwrValue          - (W) The SBValue in a string format.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--
 bool CMICmnLLDBUtilSBValue::GetSimpleValue(const bool vbHandleArrayType,
                                            CMIUtilString &vwrValue) const {
   const MIuint nChildren = m_rValue.GetNumChildren();
   if (nChildren == 0) {
-    vwrValue = GetValueSummary(!m_bHandleCharType && IsCharType(), m_pUnkwn);
+    vwrValue = GetValueSummary(!m_bHandleCharType && IsCharType(), kUnknownValue);
     return MIstatus::success;
   } else if (IsPointerType()) {
     vwrValue =
-        GetValueSummary(!m_bHandleCharType && IsPointeeCharType(), m_pUnkwn);
+        GetValueSummary(!m_bHandleCharType && IsPointeeCharType(), kUnknownValue);
     return MIstatus::success;
   } else if (IsArrayType()) {
     CMICmnLLDBDebugSessionInfo &rSessionInfo(
         CMICmnLLDBDebugSessionInfo::Instance());
     bool bPrintCharArrayAsString = false;
     bPrintCharArrayAsString = rSessionInfo.SharedDataRetrieve<bool>(
                                   rSessionInfo.m_constStrPrintCharArrayAsString,
                                   bPrintCharArrayAsString) &&
if (bIsSimpleValue) {
       // OK. Value is simple (not composite) and was successfully got
     } else if (vnDepth < nMaxDepth) {
       // Need to get value from composite type
       CMICmnMIValueTuple miValueTuple;
       const bool bOk = utilMember.GetCompositeValue(vbPrintFieldNames,
                                                     miValueTuple, vnDepth + 1);
       if (!bOk)
         // Can't obtain composite type
-        value = m_pUnkwn;
+        value = kUnknownValue;
       else
         // OK. Value is composite and was successfully got
         value = miValueTuple.GetString();
     } else {
       // Need to get value from composite type, but vnMaxDepth is reached
-      value = m_pComposite;
+      value = kUnresolvedCompositeValue;
     }
     const bool bNoQuotes = true;
     const CMICmnMIValueConst miValueConst(value, bNoQuotes);
     if (vbPrintFieldNames) {
       const bool bUseSpacing = true;
       const CMICmnMIValueResult miValueResult(utilMember.GetName(),
                                               miValueConst, bUseSpacing);
       vwrMiValueTuple.Add(miValueResult, bUseSpacing);
lldb::addr_t addr = vrValue.GetLoadAddress(),
                end_addr = addr + vnMaxLen * sizeof(charT);
   lldb::SBProcess process = CMICmnLLDBDebugSessionInfo::Instance().GetProcess();
   lldb::SBError error;
   while (addr < end_addr) {
     charT ch;
     const MIuint64 nReadBytes =
         process.ReadMemory(addr, &ch, sizeof(ch), error);
     if (error.Fail() || nReadBytes != sizeof(ch))
-      return m_pUnkwn;
+      return kUnknownValue;
     else if (ch == 0)
       break;
     result.append(
         CMIUtilString::ConvertToPrintableASCII(ch, true /* bEscapeQuotes */));
     addr += sizeof(ch);
   }
 
   return result;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve the state of the value object's name.
 // Type:    Method.
 // Args:    None.
 // Return:  bool    - True = yes name is indeterminate, false = name is valid.
 // Throws:  None.
 //--
 bool CMICmnLLDBUtilSBValue::IsNameUnknown() const {
   const CMIUtilString name(GetName());
-  return (name == m_pUnkwn);
+  return (name == kUnknownValue);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve the state of the value object's value data.
 // Type:    Method.
 // Args:    None.
 // Return:  bool    - True = yes value is indeterminate, false = value valid.
 // Throws:  None.
 //--
 bool CMICmnLLDBUtilSBValue::IsValueUnknown() const {
   const CMIUtilString value(GetValue());
-  return (value == m_pUnkwn);
+  return (value == kUnknownValue);
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve the value object's type name if valid.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The type name or "??".
 // Throws:  None.
 //--
 CMIUtilString CMICmnLLDBUtilSBValue::GetTypeName() const {
   const char *pName = m_bValidSBValue ? m_rValue.GetTypeName() : nullptr;
-  const CMIUtilString text((pName != nullptr) ? pName : m_pUnkwn);
+  const CMIUtilString text((pName != nullptr) ? pName : kUnknownValue);
 
   return text;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve the value object's display type name if valid.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString   - The type name or "??".
 // Throws:  None.
 //--
 CMIUtilString CMICmnLLDBUtilSBValue::GetTypeNameDisplay() const {
   const char *pName = m_bValidSBValue ? m_rValue.GetDisplayTypeName() : nullptr;
-  const CMIUtilString text((pName != nullptr) ? pName : m_pUnkwn);
+  const CMIUtilString text((pName != nullptr) ? pName : kUnknownValue);
 
   return text;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve whether the value object's is valid or not.
 // Type:    Method.