Fix handling of double quotes (MI)

[ki.stfu]

Summary

• Clean CMICmdArgValString::Validate: now it's based on CMIUtilString::SplitConsiderQuotes method:

A bit of introduction:

1. Command line is wrapped into CMICmdArgContext.
2. CMICmdArgSet is a set of arguments to be parsed. This class contains CMICmdArgContext as a private member.
3. MI command is class which is inhereted from CMICmdBase. It contains CMICmdArgSet as a private member.

When command is executed CMICmdBase::ParseArgs() is called. This method adds args for parsing using CMICmdArgSet::Add(). Then CMICmdBase::ParseValidateCmdOptions() is called, which calls CMICmdArgSet::Validate(). Then it gets a number of arguments (using SplitConsiderQuotes().array_length) and for each arguments registered in ParseArgs() tries to validate it using CMICmdArgValBase::Validate(). Every user commands parses this string again (first time it was made in SplitConsiderQuotes) and in case of CMICmdArgValString it was made incorrectly. It searches the first and last quotes (but it should be first and next after first). Besides, it was splitted into 4 cases.
I'm just using SplitConsiderQuotes directly, and I don't split them by hand again.

Actually, I think we should do so in every CMICmdArgVal_XXX::Validate() method.

• Enable MiInterpreterExecTestCase.test_lldbmi_target_create test
• Fix MiExecTestCase.test_lldbmi_exec_arguments_set test

All tests pass on OS X.

[ki.stfu]

Add CMIUtilString::AddSlashes/StripSlashes; Fix --executable option; Fix -symbol-list-lines command

[clayborg]

Looks good.

test/tools/lldb-mi/TestMiInterpreterExec.py

 """
 Test lldb-mi -interpreter-exec command.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiInterpreterExecTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skip("lldb-mi handles double quotes in passed app path incorrectly")
     def test_lldbmi_target_create(self):
         """Test that 'lldb-mi --interpreter' can create target by 'target create' command."""
 
         self.spawnLldbMi(args = None)
 
         # Test that "target create" loads executable
         self.runCmd("-interpreter-exec console \"target create \\\"%s\\\"\"" % self.myexe)
         self.expect("\^done")

test/tools/lldb-mi/control/TestMiExec.py

def test_lldbmi_exec_arguments_set(self):
         self.expect("\^done,value=\"5\"")
         #self.runCmd("-data-evaluate-expression argv[1]")
         #self.expect("\^done,value=\"--arg1\"")
         self.runCmd("-interpreter-exec command \"print argv[1]\"")
         self.expect("\"--arg1\"")
         #self.runCmd("-data-evaluate-expression argv[2]")
         #self.expect("\^done,value=\"2nd arg\"")
         self.runCmd("-interpreter-exec command \"print argv[2]\"")
-        #FIXME: lldb-mi doesn't handle inner quotes
-        self.expect("\"\\\\\\\"2nd arg\\\\\\\"\"") #FIXME: self.expect("\"2nd arg\"")
+        self.expect("\"2nd arg\"")
         #self.runCmd("-data-evaluate-expression argv[3]")
         #self.expect("\^done,value=\"third_arg\"")
         self.runCmd("-interpreter-exec command \"print argv[3]\"")
         self.expect("\"third_arg\"")
         #self.runCmd("-data-evaluate-expression argv[4]")
         #self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
         self.runCmd("-interpreter-exec command \"print argv[4]\"")
         self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")

tools/lldb-mi/MICmdArgValString.cpp

 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdArgValString constructor.
 // Type:    Method.
 // Args:    vbAnything  - (R) True = Parse a string and accept anything, false = do not accept anything.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmdArgValString::CMICmdArgValString(const bool vbAnything)
-    : m_bHandleQuotedString(false)
+    : m_bHandleQuotedString(vbAnything ? true : false)
     , m_bAcceptNumbers(false)
     , m_bHandleDirPaths(false)
     , m_bHandleAnything(vbAnything)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdArgValString constructor.

 //--
 bool
 CMICmdArgValString::Validate(CMICmdArgContext &vrwArgContext)
 {
     if (vrwArgContext.IsEmpty())
         return MIstatus::success;
 
     if (m_bHandleQuotedString)
-        return (ValidateQuotedText(vrwArgContext) || ValidateQuotedTextEmbedded(vrwArgContext));
+        return ValidateQuotedText(vrwArgContext);
 
     return ValidateSingleText(vrwArgContext);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Parse the command's argument options string and try to extract only the next
 //          word delimited by the next space.
 // Type:    Method.
 // Args:    vrwArgContext   - (RW) The command's argument options string.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::ValidateSingleText(CMICmdArgContext &vrwArgContext)
 {
-    if (vrwArgContext.GetNumberArgsPresent() == 1)
-    {
-        const CMIUtilString &rArg(vrwArgContext.GetArgsLeftToParse());
-        if (IsStringArg(rArg))
-        {
-            m_bFound = true;
-            m_bValid = true;
-            m_argValue = rArg;
-            vrwArgContext.RemoveArg(rArg);
-            return MIstatus::success;
-        }
-        else
-            return MIstatus::failure;
-    }
-
-    // More than one option...
     const CMIUtilString::VecString_t vecOptions(vrwArgContext.GetArgs());
     CMIUtilString::VecString_t::const_iterator it = vecOptions.begin();
     while (it != vecOptions.end())
     {
         const CMIUtilString &rArg(*it);
         if (IsStringArg(rArg))
         {
             m_bFound = true;
 
             if (vrwArgContext.RemoveArg(rArg))
             {
                 m_bValid = true;
-                m_argValue = rArg;
+                m_argValue = rArg.StripSlashes();
                 return MIstatus::success;
             }
             else
                 return MIstatus::failure;
         }
 
         // Next
         ++it;
     }
 
     return MIstatus::failure;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Parse the command's argument options string and try to extract all the words
-//          between quotes then delimited by the next space. Can fall through to
-//          ValidateSingleText() or ValidateQuotedQuotedTextEmbedded().
+//          between quotes then delimited by the next space.
 // Type:    Method.
 // Args:    vrwArgContext   - (RW) The command's argument options string.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::ValidateQuotedText(CMICmdArgContext &vrwArgContext)
 {
-    // CODETAG_QUOTEDTEXT_SIMILAR_CODE
-    CMIUtilString strOptions = vrwArgContext.GetArgsLeftToParse();
-    const MIchar cQuote = '"';
-
-    // Look for first quote of two
-    MIint nPos = strOptions.find(cQuote);
-    if (nPos == (MIint)std::string::npos)
-        return ValidateSingleText(vrwArgContext);
-
-    // Is one and only quote at end of the string
-    const MIint nLen = strOptions.length();
-    if (nPos == (MIint)(nLen - 1))
-        return MIstatus::failure;
-
-    // Quote must be the first character in the string or be preceeded by a space
-    if ((nPos > 0) && (strOptions[nPos - 1] != ' '))
-        return MIstatus::failure;
-
-    // Need to find the other quote
-    const MIint nPos2 = strOptions.rfind(cQuote);
-    if (nPos2 == (MIint)std::string::npos)
-        return MIstatus::failure;
-
-    // Is there quotes surrounding string formatting embedded quotes
-    if (IsStringArgQuotedQuotedTextEmbedded(strOptions))
-        return ValidateQuotedQuotedTextEmbedded(vrwArgContext);
-
-    // Make sure not same back quote, need two quotes
-    if (nPos == nPos2)
-        return MIstatus::failure;
-
-    // Extract quoted text
-    const CMIUtilString strQuotedTxt = strOptions.substr(nPos, nPos2 - nPos + 1).c_str();
-    if (vrwArgContext.RemoveArg(strQuotedTxt))
-    {
-        m_bFound = true;
-        m_bValid = true;
-        m_argValue = strOptions.substr(nPos + 1, nPos2 - nPos - 1).c_str();
-        return MIstatus::success;
-    }
-
-    return MIstatus::failure;
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: Parse the command's argument options string and try to extract all the words
-//          between quotes then delimited by the next space. If there any string format
-//          characters '\\' used to embed quotes these are ignored i.e. "\\\"%5d\\\""
-//          becomes "%5d". Can fall through to ValidateQuotedText().
-// Type:    Method.
-// Args:    vrwArgContext   - (RW) The command's argument options string.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMICmdArgValString::ValidateQuotedTextEmbedded(CMICmdArgContext &vrwArgContext)
-{
-    // CODETAG_QUOTEDTEXT_SIMILAR_CODE
-    CMIUtilString strOptions = vrwArgContext.GetArgsLeftToParse();
-    const MIchar cBckSlash = '\\';
-    const MIint nPos = strOptions.find(cBckSlash);
-    if (nPos == (MIint)std::string::npos)
-        return ValidateQuotedText(vrwArgContext);
-
-    // Back slash must be the first character in the string or be preceeded by a space
-    // or '\\'
-    const MIchar cSpace = ' ';
-    if ((nPos > 0) && (strOptions[nPos - 1] != cSpace))
-        return MIstatus::failure;
-
-    // Need to find the other back slash
-    const MIint nPos2 = strOptions.rfind(cBckSlash);
-    if (nPos2 == (MIint)std::string::npos)
-        return MIstatus::failure;
-
-    // Make sure not same back slash, need two slashs
-    if (nPos == nPos2)
+    const CMIUtilString::VecString_t vecOptions(vrwArgContext.GetArgs());
+    if (vecOptions.size() == 0)
         return MIstatus::failure;
 
-    // Look for the two quotes
-    const MIint nLen = strOptions.length();
-    const MIchar cQuote = '"';
-    const MIint nPosQuote1 = nPos + 1;
-    const MIint nPosQuote2 = (nPos2 < nLen) ? nPos2 + 1 : nPos2;
-    if ((nPosQuote1 != nPosQuote2) && (strOptions[nPosQuote1] != cQuote) && (strOptions[nPosQuote2] != cQuote))
+    const CMIUtilString &rArg(vecOptions[0]);
+    if (!IsStringArg(rArg))
         return MIstatus::failure;
 
-    // Extract quoted text
-    const CMIUtilString strQuotedTxt = strOptions.substr(nPos, nPosQuote2 - nPos + 1).c_str();
-    if (vrwArgContext.RemoveArg(strQuotedTxt))
-    {
-        m_bFound = true;
-        m_bValid = true;
-        m_argValue = strQuotedTxt;
-        return MIstatus::success;
-    }
-
-    return MIstatus::failure;
-}
-
-//++ ------------------------------------------------------------------------------------
-// Details: Parse the command's argument options string and try to extract all the words
-//          between quotes then delimited by the next space. If there any string format
-//          characters '\\' used to embed quotes these are ignored i.e. "\\\"%5d\\\""
-//          becomes "%5d".
-// Type:    Method.
-// Args:    vrwArgContext   - (RW) The command's argument options string.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
-// Throws:  None.
-//--
-bool
-CMICmdArgValString::ValidateQuotedQuotedTextEmbedded(CMICmdArgContext &vrwArgContext)
-{
-    // CODETAG_QUOTEDTEXT_SIMILAR_CODE
-    CMIUtilString strOptions = vrwArgContext.GetArgsLeftToParse();
-    const MIint nPos = strOptions.find("\"\\\"");
-    if (nPos == (MIint)std::string::npos)
-        return MIstatus::failure;
-
-    const MIint nPos2 = strOptions.rfind("\\\"\"");
-    if (nPos2 == (MIint)std::string::npos)
-        return MIstatus::failure;
 
-    const MIint nLen = strOptions.length();
-    if ((nLen > 5) && ((nPos + 2) == (nPos2 - 2)))
-        return MIstatus::failure;
-
-    // Quote must be the first character in the string or be preceeded by a space
-    // or '\\'
-    const MIchar cSpace = ' ';
-    if ((nPos > 0) && (strOptions[nPos - 1] != cSpace))
-        return MIstatus::failure;
-
-    // Extract quoted text
-    const CMIUtilString strQuotedTxt = strOptions.substr(nPos, nPos2 - nPos + 3).c_str();
-    if (vrwArgContext.RemoveArg(strQuotedTxt))
+    if (vrwArgContext.RemoveArg(rArg))
     {
-        m_bFound = true;
         m_bValid = true;
-        m_argValue = strQuotedTxt;
+        const MIchar cQuote = '"';
+        m_argValue = rArg.Trim(cQuote).StripSlashes();
         return MIstatus::success;
     }
 
     return MIstatus::failure;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Examine the string and determine if it is a valid string type argument.

 // Type:    Method.
 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes valid argument value, false = something else.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::IsStringArgSingleText(const CMIUtilString &vrTxt) const
 {
-    // Accept anything as string word
-    if (m_bHandleAnything)
-        return true;
-
     if (!m_bHandleDirPaths)
     {
         // Look for directory file paths, if found reject
         const bool bHavePosSlash = (vrTxt.find_first_of("/") != std::string::npos);
         const bool bHaveBckSlash = (vrTxt.find_first_of("\\") != std::string::npos);
         if (bHavePosSlash || bHaveBckSlash)
             return false;
     }

 // Type:    Method.
 // Args:    vrTxt   - (R) Some text.
 // Return:  bool    - True = yes valid arg, false = no.
 // Throws:  None.
 //--
 bool
 CMICmdArgValString::IsStringArgQuotedText(const CMIUtilString &vrTxt) const
 {
+    // Accept anything as string word
+    if (m_bHandleAnything)
+        return true;
+
     // CODETAG_QUOTEDTEXT_SIMILAR_CODE
     const MIchar cQuote = '"';
     const MIint nPos = vrTxt.find(cQuote);
     if (nPos == (MIint)std::string::npos)
         return false;
 
     // Is one and only quote at end of the string
     if (nPos == (MIint)(vrTxt.length() - 1))

tools/lldb-mi/MICmdCmdSymbol.cpp

 // Throws:  None.
 //--
 bool
 CMICmdCmdSymbolListLines::Execute(void)
 {
     CMICMDBASE_GETOPTION(pArgFile, File, m_constStrArgNameFile);
 
     const CMIUtilString &strFilePath(pArgFile->GetValue());
-    const CMIUtilString strCmd(CMIUtilString::Format("target modules dump line-table \"%s\"", strFilePath.c_str()));
+    const CMIUtilString strCmd(CMIUtilString::Format("target modules dump line-table \"%s\"", strFilePath.AddSlashes().c_str()));
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::ReturnStatus rtn = rSessionInfo.GetDebugger().GetCommandInterpreter().HandleCommand(strCmd.c_str(), m_lldbResult);
     MIunused(rtn);
 
     return MIstatus::success;
 }
 

tools/lldb-mi/MIDriver.cpp

 // Args:    None.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMIDriver::LocalDebugSessionStartupInjectCommands(void)
 {
-    const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.c_str()));
+    const CMIUtilString strCmd(CMIUtilString::Format("-file-exec-and-symbols \"%s\"", m_strCmdLineArgExecuteableFileNamePath.AddSlashes().c_str()));
     const bool bOk = CMICmnStreamStdout::TextToStdout(strCmd);
     return (bOk && InterpretCommand(strCmd));
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Set the MI Driver into "its debugging an executable passed as an argument"
 //          mode as against running via a client like Eclipse.
 // Type:    Method.

tools/lldb-mi/MIUtilString.h

public:
     CMIUtilString StripCREndOfLine(void) const;
     CMIUtilString StripCRAll(void) const;
     CMIUtilString Trim(void) const;
     CMIUtilString Trim(const MIchar vChar) const;
     MIuint FindFirst(const CMIUtilString &vrPattern, const MIuint vnPos = 0) const;
     MIuint FindFirst(const CMIUtilString &vrPattern, const bool vbSkipQuotedText, bool &vrwbNotFoundClosedQuote,
                      const MIuint vnPos = 0) const;
     MIuint FindFirstNot(const CMIUtilString &vrPattern, const MIuint vnPos = 0) const;
+    CMIUtilString AddSlashes(void) const;
+    CMIUtilString StripSlashes(void) const;
     //
     CMIUtilString &operator=(const MIchar *vpRhs);
     CMIUtilString &operator=(const std::string &vrRhs);
 
     // Overrideable:
   public:
     /* dtor */ virtual ~CMIUtilString(void);
 

tools/lldb-mi/MIUtilString.cpp

do
 
         // Skip 2 characters: First is '\', second is that which is escaped by '\'
         nPos = nBckSlashPos + 2;
     }
     while (nPos < nLen);
 
     return (MIuint)std::string::npos;
 }
+
+//++ ------------------------------------------------------------------------------------
+// Details: Get string with backslashes in front of double quote '"' and backslash '\\'
+//          characters.
+// Type:    Method.
+// Args:    None.
+// Return:  CMIUtilString - The wrapped version of the initial string.
+// Throws:  None.
+//--
+CMIUtilString
+CMIUtilString::AddSlashes(void) const
+{
+    const MIchar cBckSlash('\\');
+    const MIuint nLen(length());
+    CMIUtilString strNew;
+    strNew.reserve(nLen);
+
+    MIuint nOffset(0);
+    while (nOffset < nLen)
+    {
+        const MIuint nUnescapedCharPos(find_first_of("\"\\", nOffset));
+        const bool bUnescapedCharNotFound(nUnescapedCharPos == (MIuint)std::string::npos);
+        if (bUnescapedCharNotFound)
+        {
+            const MIuint nAppendAll((MIuint)std::string::npos);
+            strNew.append(*this, nOffset, nAppendAll);
+            break;
+        }
+        const MIuint nAppendLen(nUnescapedCharPos - nOffset);
+        strNew.append(*this, nOffset, nAppendLen);
+        strNew.push_back(cBckSlash);
+        const MIchar cUnescapedChar((*this)[nUnescapedCharPos]);
+        strNew.push_back(cUnescapedChar);
+        nOffset = nUnescapedCharPos + 1;
+    }
+
+    return strNew;
+}
+
+//++ ------------------------------------------------------------------------------------
+// Details: Remove backslashes added by CMIUtilString::AddSlashes.
+// Type:    Method.
+// Args:    None.
+// Return:  CMIUtilString - The initial version of wrapped string.
+// Throws:  None.
+//--
+CMIUtilString
+CMIUtilString::StripSlashes(void) const
+{
+    const MIchar cBckSlash('\\');
+    const MIuint nLen(length());
+    CMIUtilString strNew;
+    strNew.reserve(nLen);
+
+    MIuint nOffset(0);
+    while (nOffset < nLen)
+    {
+        const MIuint nBckSlashPos(find(cBckSlash, nOffset));
+        const bool bBckSlashNotFound(nBckSlashPos == (MIuint)std::string::npos);
+        if (bBckSlashNotFound)
+        {
+            const MIuint nAppendAll((MIuint)std::string::npos);
+            strNew.append(*this, nOffset, nAppendAll);
+            break;
+        }
+        const MIuint nAppendLen(nBckSlashPos - nOffset);
+        strNew.append(*this, nOffset, nAppendLen);
+        const bool bBckSlashIsLast(nBckSlashPos == nLen);
+        if (bBckSlashIsLast)
+        {
+            strNew.push_back(cBckSlash);
+            break;
+        }
+        const MIchar cEscapedChar((*this)[nBckSlashPos + 1]);
+        const MIuint nEscapedCharPos(std::string("\"\\").find(cEscapedChar));
+        const bool bEscapedCharNotFound(nEscapedCharPos == (MIuint)std::string::npos);
+        if (bEscapedCharNotFound)
+            strNew.push_back(cBckSlash);
+        strNew.push_back(cEscapedChar);
+        nOffset = nBckSlashPos + 2;
+    }
+
+    return strNew;
+}