Allow to construct CMIUtilString using std::string directly + cleanup CMIUtilString (MI)

[ki.stfu]

Summary

Allow to construct CMIUtilString using std::string directly + cleanup CMIUtilString (MI)

This patch cleans up lldb-mi code, and serves to simplify
the following case:

std::string strGoodbye = "!Hello";
CMIUtilString strHello(strGoodbye.substr(1).c_str());

With CMIUtilString(std::string) we can omit .c_str():

std::string strGoodbye = "!Hello";
CMIUtilString strHello(strGoodbye.substr(1));

Also, it removes 2 ctors because they aren't needed:

1. CMIUtilString::CMIUtilString(const char *const *vpData)
2. CMIUtilString::CMIUtilString(const char *vpData, size_t nLen)

and cleans up CMIUtilString::operator=(const std::string &vrRhs).

[brucem]

tools/lldb-mi/MICmdInterpreter.cpp

166

Can this one be changed too?

[ki.stfu]

tools/lldb-mi/MICmdInterpreter.cpp

166

Sure.

[ki.stfu]

A little fix as @brucem requested; Remove CMIUtilString(const char *const *vpData) and CMIUtilString(const char *vpData, size_t nLen) ctors; Cleanup CMIUtilString::operator=(const std::string &vrRhs)

[ki.stfu]

I perceive it as a simple patch, so I am going to go ahead.

tools/lldb-mi/MICmdArgContext.cpp

while (1)
             if (bPass2)
                 break;
         }
 
         nPos = m_strCmdArgsAndOptions.find(vArg, nEnd);
     }
 
     const size_t nPosEnd = nLen + nExtraSpace;
-    m_strCmdArgsAndOptions = m_strCmdArgsAndOptions.replace(nPos, nPosEnd, "").c_str();
+    m_strCmdArgsAndOptions = m_strCmdArgsAndOptions.replace(nPos, nPosEnd, "");
     m_strCmdArgsAndOptions = m_strCmdArgsAndOptions.Trim();
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove the argument at the Nth word position along in the context string.
 //          Any space after the argument is removed if applicable. A search is not

tools/lldb-mi/MICmdArgValOptionLong.cpp

CMICmdArgValOptionLong::IsArgLongOption(const CMIUtilString &vrTxt) const
 
     const size_t nPos = vrTxt.find("--");
     if (nPos != 0)
         return false;
 
     if (vrTxt.length() < 3)
         return false;
 
-    const CMIUtilString strArg = vrTxt.substr(2).c_str();
+    const CMIUtilString strArg = vrTxt.substr(2);
     if (strArg.IsNumber())
         return false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Examine the string and determine if it is a valid long type option argument.

 // Type:    Method.
 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes arg name matched, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValOptionLong::ArgNameMatch(const CMIUtilString &vrTxt) const
 {
-    const CMIUtilString strArg = vrTxt.substr(2).c_str();
+    const CMIUtilString strArg = vrTxt.substr(2);
     return (strArg == GetName());
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the list of CMICmdArgValBase derived option objects found following
 //          *this long option argument. For example "list-thread-groups [ --recurse 1 ]"
 //          where 1 is the list of expected option to follow.
 // Type:    Method.

tools/lldb-mi/MICmdArgValOptionShort.cpp

 // Type:    Overridden.
 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes arg name matched, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValOptionShort::ArgNameMatch(const CMIUtilString &vrTxt) const
 {
-    const CMIUtilString strArg = vrTxt.substr(1).c_str();
+    const CMIUtilString strArg = vrTxt.substr(1);
     return (strArg == GetName());
 }

tools/lldb-mi/MICmdArgValThreadGrp.cpp

 bool
 CMICmdArgValThreadGrp::IsArgThreadGrp(const CMIUtilString &vrTxt) const
 {
     // Look for i1 i2 i3....
     const MIint nPos = vrTxt.find('i');
     if (nPos != 0)
         return false;
 
-    const CMIUtilString strNum = vrTxt.substr(1).c_str();
+    const CMIUtilString strNum = vrTxt.substr(1);
     if (!strNum.IsNumber())
         return false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Extract the thread group number from the thread group argument.
 // Type:    Method.
 // Args:    vrTxt   - (R) Some text.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdArgValThreadGrp::ExtractNumber(const CMIUtilString &vrTxt)
 {
-    const CMIUtilString strNum = vrTxt.substr(1).c_str();
+    const CMIUtilString strNum = vrTxt.substr(1);
     MIint64 nNumber = 0;
     bool bOk = strNum.ExtractNumber(nNumber);
     if (bOk)
     {
         m_nThreadGrp = static_cast<MIuint>(nNumber);
     }
 
     return bOk;

tools/lldb-mi/MICmdCmdData.cpp

CMICmdCmdDataInfoLine::Execute()
 
     const CMIUtilString &strLocation(pArgLocation->GetValue());
     CMIUtilString strCmdOptionsLocation;
     if (strLocation.at(0) == '*')
     {
         // Parse argument:
         // *0x12345
         //  ^^^^^^^ -- address
-        const CMIUtilString strAddress(strLocation.c_str() + 1);
+        const CMIUtilString strAddress(strLocation.substr(1));
         strCmdOptionsLocation = CMIUtilString::Format("--address %s", strAddress.c_str());
     }
     else
     {
         const size_t nLineStartPos = strLocation.rfind(':');
         if ((nLineStartPos == std::string::npos) || (nLineStartPos == 0) || (nLineStartPos == strLocation.length() - 1))
         {
             SetError(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_INVALID_LOCATION_FORMAT), m_cmdData.strMiCmd.c_str(), strLocation.c_str())
                          .c_str());
             return MIstatus::failure;
         }
         // Parse argument:
         // hello.cpp:5
         // ^^^^^^^^^ -- file
         //           ^ -- line
-        const CMIUtilString strFile(strLocation.substr(0, nLineStartPos).c_str());
-        const CMIUtilString strLine(strLocation.substr(nLineStartPos + 1).c_str());
+        const CMIUtilString strFile(strLocation.substr(0, nLineStartPos));
+        const CMIUtilString strLine(strLocation.substr(nLineStartPos + 1));
         strCmdOptionsLocation = CMIUtilString::Format("--file \"%s\" --line %s", strFile.AddSlashes().c_str(), strLine.c_str());
     }
     const CMIUtilString strCmd(CMIUtilString::Format("target modules lookup -v %s", strCmdOptionsLocation.c_str()));
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::ReturnStatus rtn = rSessionInfo.GetDebugger().GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult);
     MIunused(rtn);
 

tools/lldb-mi/MICmdCmdVar.cpp

CMICmdCmdVarCreate::Execute()
     lldb::SBProcess sbProcess = rSessionInfo.GetProcess();
     lldb::SBThread thread = (nThreadId != UINT64_MAX) ? sbProcess.GetThreadByIndexID(nThreadId) : sbProcess.GetSelectedThread();
     m_nThreadId = thread.GetIndexID();
     lldb::SBFrame frame = bCurrentFrame ? thread.GetSelectedFrame() : thread.GetFrameAtIndex(nFrame);
     lldb::SBValue value;
 
     if (rStrExpression[0] == '$')
     {
-        const CMIUtilString rStrRegister(rStrExpression.substr(1).c_str());
+        const CMIUtilString rStrRegister(rStrExpression.substr(1));
         value = frame.FindRegister(rStrRegister.c_str());
     }
     else
     {
         const bool bArgs = true;
         const bool bLocals = true;
         const bool bStatics = true;
         const bool bInScopeOnly = false;

tools/lldb-mi/MICmdInterpreter.cpp

CMICmdInterpreter::MiHasCmdTokenEndingHyphen(const CMIUtilString &vTextLine)
     // The hyphen is mandatory
     const size_t nPos = vTextLine.find('-', 0);
     if ((nPos == std::string::npos))
         return false;
 
     if (MiHasCmdTokenPresent(vTextLine))
     {
         const std::string strNum = vTextLine.substr(0, nPos);
-        if (!CMIUtilString(strNum.c_str()).IsNumber())
+        if (!CMIUtilString(strNum).IsNumber())
             return false;
 
         m_miCmdData.strMiCmdToken = strNum.c_str();
     }
 
     m_miCmdData.bMIOldStyle = false;
 
     return true;
 }
 
 //++ ------------------------------------------------------------------------------------
CMICmdInterpreter::MiHasCmd(const CMIUtilString &vTextLine)
 
     bool bFoundCmd = false;
     const size_t nLen = vTextLine.length();
     const size_t nPos2 = vTextLine.find(' ', nPos);
     if (nPos2 != std::string::npos)
     {
         if (nPos2 == nLen)
             return false;
-        const CMIUtilString cmd = CMIUtilString(vTextLine.substr(nPos + 1, nPos2 - nPos - 1).c_str());
+        const CMIUtilString cmd = CMIUtilString(vTextLine.substr(nPos + 1, nPos2 - nPos - 1));
         if (cmd.empty())
             return false;
 
         m_miCmdData.strMiCmd = cmd;
 
         if (nPos2 < nLen)
-            m_miCmdData.strMiCmdOption = CMIUtilString(vTextLine.substr(nPos2 + 1, nLen - nPos2 - 1).c_str());
+            m_miCmdData.strMiCmdOption = CMIUtilString(vTextLine.substr(nPos2 + 1, nLen - nPos2 - 1));
 
         bFoundCmd = true;
     }
     else
     {
-        const CMIUtilString cmd = CMIUtilString(vTextLine.substr(nPos + 1, nLen - nPos - 1).c_str());
+        const CMIUtilString cmd = CMIUtilString(vTextLine.substr(nPos + 1, nLen - nPos - 1));
         if (cmd.empty())
             return false;
         m_miCmdData.strMiCmd = cmd;
         bFoundCmd = true;
     }
 
     if (bFoundCmd)
         m_miCmdData.strMiCmdAll = vTextLine;

tools/lldb-mi/MICmnLLDBDebugger.cpp

 MIuint
 CMICmnLLDBDebugger::ClientGetMaskForAllClients(const CMIUtilString &vBroadcasterClass) const
 {
     MIuint mask = 0;
     MapIdToEventMask_t::const_iterator it = m_mapIdToEventMask.begin();
     while (it != m_mapIdToEventMask.end())
     {
         const CMIUtilString &rId((*it).first);
-        if (rId.find(vBroadcasterClass.c_str()) != std::string::npos)
+        if (rId.find(vBroadcasterClass) != std::string::npos)
         {
             const MIuint clientsMask = (*it).second;
             mask |= clientsMask;
         }
 
         // Next
         ++it;
     }
CMICmnLLDBDebugger::ClientGetTheirMask(const CMIUtilString &vClientName, const CMIUtilString &vBroadcasterClass, MIuint &vwEventMask)
     vwEventMask = 0;
 
     if (vClientName.empty())
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_INVALIDCLIENTNAME), vClientName.c_str()));
         return MIstatus::failure;
     }
 
-    CMIUtilString strId(vBroadcasterClass.c_str());
-    strId += vClientName;
-
+    const CMIUtilString strId(vBroadcasterClass + vClientName);
     const MapIdToEventMask_t::const_iterator it = m_mapIdToEventMask.find(strId);
     if (it != m_mapIdToEventMask.end())
     {
         vwEventMask = (*it).second;
     }
 
     SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_LLDBDEBUGGER_ERR_CLIENTNOTREGISTERED), vClientName.c_str()));
 

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

while (1)
         text.append(apStdoutBuffer.get(), nBytes);
 
         while (1)
         {
             const size_t nNewLine = text.find('\n');
             if (nNewLine == std::string::npos)
                 break;
 
-            const CMIUtilString line(text.substr(0, nNewLine + 1).c_str());
+            const CMIUtilString line(text.substr(0, nNewLine + 1));
             text.erase(0, nNewLine + 1);
             const bool bEscapeQuotes(true);
             CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes));
             CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst);
             const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
             if (!bOk)
                 return MIstatus::failure;
         }
while (1)
         text.append(apStderrBuffer.get(), nBytes);
 
         while (1)
         {
             const size_t nNewLine = text.find('\n');
             if (nNewLine == std::string::npos)
                 break;
 
-            const CMIUtilString line(text.substr(0, nNewLine + 1).c_str());
+            const CMIUtilString line(text.substr(0, nNewLine + 1));
             const bool bEscapeQuotes(true);
             CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes));
             CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst);
             const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
             if (!bOk)
                 return MIstatus::failure;
         }
 

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

while (addr < end_addr)
         if (error.Fail() || nReadBytes != sizeof(ch))
             return m_pUnkwn;
         else if (ch == 0)
             break;
         result.append(CMIUtilString::ConvertToPrintableASCII(ch, true /* bEscapeQuotes */));
         addr += sizeof(ch);
     }
 
-    return result.c_str();
+    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.

tools/lldb-mi/MIDriver.cpp

CMIDriver::WrapCLICommandIntoMICommand(const CMIUtilString &vTextLine) const
 
    // 4. Wrap CLI command to make it MI-compatible
    //
    // 001target create "/path/to/file"
    // ^^^ -- token
    const std::string vToken(vTextLine.begin(), vTextLine.begin() + nCommandOffset);
    // 001target create "/path/to/file"
    //    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- CLI command
-   const CMIUtilString vCliCommand(std::string(vTextLine, nCommandOffset).c_str());
+   const CMIUtilString vCliCommand(std::string(vTextLine, nCommandOffset));
 
    // 5. Escape special characters and embed the command in a string
    // Result: it looks like -- target create \"/path/to/file\".
    const std::string vShieldedCliCommand(vCliCommand.AddSlashes());
 
    // 6. Turn the CLI command into an MI command, as in:
    // 001-interpreter-exec command "target create \"/path/to/file\""
    // ^^^ -- token

tools/lldb-mi/MIUtilString.h

public:
     static CMIUtilString ConvertToPrintableASCII(const char32_t vChar32, bool bEscapeQuotes = false);
 
     // Methods:
   public:
     /* ctor */ CMIUtilString();
     /* ctor */ CMIUtilString(const char *vpData);
     /* ctor */ CMIUtilString(const char *const *vpData);
     /* ctor */ CMIUtilString(const char *vpData, size_t nLen);
+    /* ctor */ CMIUtilString(const std::string& vrStr);
     //
     bool ExtractNumber(MIint64 &vwrNumber) const;
     CMIUtilString FindAndReplace(const CMIUtilString &vFind, const CMIUtilString &vReplaceWith) const;
     bool IsNumber() const;
     bool IsHexadecimalNumber() const;
     bool IsQuoted() const;
     CMIUtilString RemoveRepeatedCharacters(const char vChar);
     size_t Split(const CMIUtilString &vDelimiter, VecString_t &vwVecSplits) const;

tools/lldb-mi/MIUtilString.cpp

 // Throws:  None.
 //--
 CMIUtilString::CMIUtilString(const char *vpData, size_t nLen)
     : std::string(vpData, nLen)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
+// Details: CMIUtilString constructor.
+// Type:    Method.
+// Args:    vpStr  - Text data.
+// Return:  None.
+// Throws:  None.
+//--
+CMIUtilString::CMIUtilString(const std::string& vrStr)
+    : std::string(vrStr)
+{
+}
+
+//++ ------------------------------------------------------------------------------------
 // Details: CMIUtilString assignment operator.
 // Type:    Method.
 // Args:    vpRhs   - Pointer to UTF8 text data.
 // Return:  CMIUtilString & - *this string.
 // Throws:  None.
 //--
 CMIUtilString &CMIUtilString::operator=(const char *vpRhs)
 {
do
         // Find next occurrence of the delimiter after section
         size_t nNextDelimiterPos(FindFirst(vDelimiter, nSectionPos));
         if (nNextDelimiterPos == std::string::npos)
             nNextDelimiterPos = nLen;
 
         // Extract string between delimiters
         const size_t nSectionLen(nNextDelimiterPos - nSectionPos);
         const std::string strSection(substr(nSectionPos, nSectionLen));
-        vwVecSplits.push_back(strSection.c_str());
+        vwVecSplits.push_back(strSection);
 
         // Next
         nOffset = nNextDelimiterPos + 1;
     }
     while (nOffset < nLen);
 
     return vwVecSplits.size();
 }
do
             return 0;
         }
         if (nNextDelimiterPos == std::string::npos)
             nNextDelimiterPos = nLen;
 
         // Extract string between delimiters
         const size_t nSectionLen(nNextDelimiterPos - nSectionPos);
         const std::string strSection(substr(nSectionPos, nSectionLen));
-        vwVecSplits.push_back(strSection.c_str());
+        vwVecSplits.push_back(strSection);
 
         // Next
         nOffset = nNextDelimiterPos + 1;
     }
     while (nOffset < nLen);
 
     return vwVecSplits.size();
 }

 //--
 CMIUtilString
 CMIUtilString::StripCREndOfLine() const
 {
     const size_t nPos = rfind('\n');
     if (nPos == std::string::npos)
         return *this;
 
-    const CMIUtilString strNew(substr(0, nPos).c_str());
+    const CMIUtilString strNew(substr(0, nPos));
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove all '\n' from the string and replace with a space. It does not alter
 //          *this string.
 // Type:    Method.

 CMIUtilString
 CMIUtilString::Trim() const
 {
     CMIUtilString strNew(*this);
     const char *pWhiteSpace = " \t\n\v\f\r";
     const size_t nPos = find_last_not_of(pWhiteSpace);
     if (nPos != std::string::npos)
     {
-        strNew = substr(0, nPos + 1).c_str();
+        strNew = substr(0, nPos + 1);
     }
     const size_t nPos2 = strNew.find_first_not_of(pWhiteSpace);
     if (nPos2 != std::string::npos)
     {
-        strNew = strNew.substr(nPos2).c_str();
+        strNew = strNew.substr(nPos2);
     }
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Remove from either end of *this string the specified character.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - Trimmed string.
 // Throws:  None.
 //--
 CMIUtilString
 CMIUtilString::Trim(const char vChar) const
 {
     CMIUtilString strNew(*this);
     const size_t nLen = strNew.length();
     if (nLen > 1)
     {
         if ((strNew[0] == vChar) && (strNew[nLen - 1] == vChar))
-            strNew = strNew.substr(1, nLen - 2).c_str();
+            strNew = strNew.substr(1, nLen - 2);
     }
 
     return strNew;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Do a printf equivalent for printing a number in binary i.e. "b%llB".
 // Type:    Static method.