Support escapes and quotes in string and character values.

[ki.stfu]

Summary

Escape characters in strings and strings containing quotes were not appearing correctly in expression values.

Patch from [e-mail]

[ki.stfu]

Looks good apart 1 inline comment in tests.

test/tools/lldb-mi/variable/main.cpp

63–65 ↗

(On Diff #30194)

please replace these strings with your improved strings (lines 67-72).

[paulmaybee]

test/tools/lldb-mi/variable/main.cpp

63–65 ↗

(On Diff #30194)

So you want me to remove the original tests instead of adding new tests?

[ki.stfu]

test/tools/lldb-mi/variable/main.cpp

63–65 ↗

(On Diff #30194)

Yes. Your tests are better and there is no reason to have both sets of tests.

[paulmaybee]

Replace "hello" with "\t\"hello\"\n" in string value tests.

[ki.stfu]

Please remove "###" and go ahead.

test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

70 ↗

(On Diff #30361)

remove please

[paulmaybee]

remove '###'

[paulmaybee]

Can someone please check this in for me. Thanks.

[ki.stfu]

In D11371#210778, @paulmaybee wrote:

Can someone please check this in for me. Thanks.

Sure, I can do it tomorrow.

[ki.stfu]

Rebase against ToT

lldb/trunk/test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

def test_lldbmi_gdb_set_show_print_char_array_as_string(self):
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that default print char-array-as-string value is "off"
         self.runCmd("-gdb-show print char-array-as-string")
         self.expect("\^done,value=\"off\"")
 
         # Test that an char* is expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * cp")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"hello\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that an char[] isn't expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * ca")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"\[6\]\",type=\"const char \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char \[10\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that an char16_t* is expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * u16p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"hello\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that an char16_t[] isn't expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * u16a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"\[6\]\",type=\"const char16_t \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char16_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that an char32_t* is expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * u32p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"hello\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that an char32_t[] isn't expanded to string when print char-array-as-string is "off"
         self.runCmd("-var-create - * u32a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"\[6\]\",type=\"const char32_t \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\[10\]\",type=\"const char32_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that -gdb-set can set print char-array-as-string flag
         self.runCmd("-gdb-set print char-array-as-string on")
         self.expect("\^done")
         self.runCmd("-gdb-set print char-array-as-string 1")
         self.expect("\^done")
         self.runCmd("-gdb-show print char-array-as-string")
         self.expect("\^done,value=\"on\"")
 
-        # Test that an char* is expanded to string when print char-array-as-string is "on"
+        # Test that an char* with escape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * cp")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"hello\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ \\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \*\",thread-id=\"1\",has_more=\"0\"")
         
-        # Test that an char[] isn't expanded to string when print char-array-as-string is "on"
+        # Test that an char[] with escape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * ca")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"\\\\\\\"hello\\\\\\\"\",type=\"const char \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char \[10\]\",thread-id=\"1\",has_more=\"0\"")
         
-        # Test that an char16_t* is expanded to string when print char-array-as-string is "on"
+        # Test that an char16_t* with esc1ape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * u16p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"hello\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \*\",thread-id=\"1\",has_more=\"0\"")
         
-        # Test that an char16_t[] isn't expanded to string when print char-array-as-string is "on"
+        # Test that an char16_t[] with escape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * u16a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"u\\\\\\\"hello\\\\\\\"\",type=\"const char16_t \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"u\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char16_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
         
-        # Test that an char32_t* is expanded to string when print char-array-as-string is "on"
+        # Test that an char32_t* with escape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * u32p")
-        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"hello\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"1\",value=\"0x[0-9a-f]+ U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \*\",thread-id=\"1\",has_more=\"0\"")
         
-        # Test that an char32_t[] isn't expanded to string when print char-array-as-string is "on"
+        # Test that an char32_t[] with escape chars is expanded to string when print char-array-as-string is "on"
         self.runCmd("-var-create - * u32a")
-        self.expect("\^done,name=\"var\d+\",numchild=\"6\",value=\"U\\\\\\\"hello\\\\\\\"\",type=\"const char32_t \[6\]\",thread-id=\"1\",has_more=\"0\"")
+        self.expect("\^done,name=\"var\d+\",numchild=\"10\",value=\"U\\\\\\\"\\\\\\\\t\\\\\\\\\\\\\"hello\\\\\\\\\\\\\"\\\\\\\\n\\\\\\\"\",type=\"const char32_t \[10\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that -gdb-set print char-array-as-string fails if "on"/"off" isn't specified
         self.runCmd("-gdb-set print char-array-as-string")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
         # Test that -gdb-set print char-array-as-string fails when option is unknown
         self.runCmd("-gdb-set print char-array-as-string unknown")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")

lldb/trunk/test/tools/lldb-mi/variable/main.cpp

var_list_children_test(void)
     pcomplex_type pcomplx({ 6, { 6L }, &pcomplx}, { 7, { 7L }, &pcomplx});
 
     // BP_var_list_children_test
 }
 
 void
 gdb_set_show_print_char_array_as_string_test(void)
 {
-    const char *cp = "hello";
-    const char ca[] = "hello";
-    const char16_t *u16p = u"hello";
-    const char16_t u16a[] = u"hello";
-    const char32_t *u32p = U"hello";
-    const char32_t u32a[] = U"hello";
+    const char *cp = "\t\"hello\"\n";
+    const char ca[] = "\t\"hello\"\n";
+    const char16_t *u16p = u"\t\"hello\"\n";
+    const char16_t u16a[] = u"\t\"hello\"\n";
+    const char32_t *u32p = U"\t\"hello\"\n";
+    const char32_t u32a[] = U"\t\"hello\"\n";
 
     // BP_gdb_set_show_print_char_array_as_string_test
 }
 
 void
 gdb_set_show_print_expand_aggregates(void)
 {
     complex_type complx = { 3, { 3L }, &complx };

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

if (utilValue.IsIntegerType())
         MIuint64 nValue = 0;
         if (CMICmnLLDBProxySBValue::GetValueAsUnsigned(vrValue, nValue))
         {
             lldb::SBValue &rValue = const_cast<lldb::SBValue &>(vrValue);
             return GetStringFormatted(nValue, rValue.GetValue(), veVarFormat);
         }
     }
 
-    return utilValue.GetValue().Escape().AddSlashes();
+    return utilValue.GetValue().AddSlashes();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Return number formatted string according to the given value type.
 // Type:    Static method.
 // Args:    vnValue             - (R) The number value to get formatted.
 //          vpStrValueNatural   - (R) The natural representation of the number value.
 //          veVarFormat         - (R) Var format enumeration.

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

CMICmnLLDBUtilSBValue::GetSimpleValueCStringPointer(void) const
     switch (eType)
     {
         default:
             assert(0 && "child must be a char type");
         case lldb::eBasicTypeChar:
         case lldb::eBasicTypeSignedChar:
         case lldb::eBasicTypeUnsignedChar:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(child).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(child));
             // 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
             return CMIUtilString::Format("%s \"%s\"", value, prefix.c_str());
         }
         case lldb::eBasicTypeChar16:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(child).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(child));
             return CMIUtilString::Format("%s u\"%s\"", value, prefix.c_str());
         }
         case lldb::eBasicTypeChar32:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(child).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(child));
             return CMIUtilString::Format("%s U\"%s\"", value, prefix.c_str());
         }
     }
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve from the LLDB SB Value object of type char[] the c-string value.
 // Type:    Method.
CMICmnLLDBUtilSBValue::GetSimpleValueCStringArray(void) const
     switch (eType)
     {
         default:
             assert(0 && "value must be a char[] type");
         case lldb::eBasicTypeChar:
         case lldb::eBasicTypeSignedChar:
         case lldb::eBasicTypeUnsignedChar:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(m_rValue, nChildren).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char>(m_rValue, nChildren));
             // TODO: to match char* it should be the following
             //       return CMIUtilString::Format("[%u] \"%s\"", nChildren, prefix.c_str());
             return CMIUtilString::Format("\"%s\"", prefix.c_str());
         }
         case lldb::eBasicTypeChar16:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(m_rValue, nChildren).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char16_t>(m_rValue, nChildren));
             return CMIUtilString::Format("u\"%s\"", prefix.c_str());
         }
         case lldb::eBasicTypeChar32:
         {
-            // FIXME Add slashes before double quotes
-            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(m_rValue, nChildren).AddSlashes());
+            const CMIUtilString prefix(ReadCStringFromHostMemory<char32_t>(m_rValue, nChildren));
             return CMIUtilString::Format("U\"%s\"", prefix.c_str());
         }
     }
 }
 
 bool
 CMICmnLLDBUtilSBValue::GetCompositeValue(const bool vbPrintFieldNames, CMICmnMIValueTuple &vwrMiValueTuple,
                                          const MIuint vnDepth /* = 1 */) const
CMICmnLLDBUtilSBValue::ReadCStringFromHostMemory(lldb::SBValue &vrValue, const MIuint vnMaxLen) const
     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;
         else if (ch == 0)
             break;
-        result.append(CMIUtilString::ConvertToPrintableASCII(ch));
+        result.append(CMIUtilString::ConvertToPrintableASCII(ch, true /* bEscapeQuotes */));
         addr += sizeof(ch);
     }
 
     return result.c_str();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the state of the value object's name.

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

public:
 
     // Static method:
   public:
     static CMIUtilString Format(const CMIUtilString vFormating, ...);
     static CMIUtilString FormatBinary(const MIuint64 vnDecimal);
     static CMIUtilString FormatValist(const CMIUtilString &vrFormating, va_list vArgs);
     static bool IsAllValidAlphaAndNumeric(const char *vpText);
     static bool Compare(const CMIUtilString &vrLhs, const CMIUtilString &vrRhs);
-    static CMIUtilString ConvertToPrintableASCII(const char vChar);
-    static CMIUtilString ConvertToPrintableASCII(const char16_t vChar16);
-    static CMIUtilString ConvertToPrintableASCII(const char32_t vChar32);
+    static CMIUtilString ConvertToPrintableASCII(const char vChar, bool bEscapeQuotes = false);
+    static CMIUtilString ConvertToPrintableASCII(const char16_t vChar16, bool bEscapeQuotes = false);
+    static CMIUtilString ConvertToPrintableASCII(const char32_t vChar32, bool bEscapeQuotes = false);
 
     // Methods:
   public:
     /* ctor */ CMIUtilString(void);
     /* ctor */ CMIUtilString(const char *vpData);
     /* ctor */ CMIUtilString(const char *const *vpData);
     //
     bool ExtractNumber(MIint64 &vwrNumber) const;
public:
 
     // Overrideable:
   public:
     /* dtor */ virtual ~CMIUtilString(void);
 
     // Static method:
   private:
     static CMIUtilString FormatPriv(const CMIUtilString &vrFormat, va_list vArgs);
+    static CMIUtilString ConvertCharValueToPrintableASCII(char vChar, bool bEscapeQuotes);
 
     // Methods:
   private:
     bool ExtractNumberFromHexadecimal(MIint64 &vwrNumber) const;
     CMIUtilString RemoveRepeatedCharacters(size_t vnPos, const char vChar);
     size_t FindFirstQuote(size_t vnPos) const;
 };

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

while (nOffset < nLen)
         strNew.push_back(cEscapedChar);
         nOffset = nBckSlashPos + 2;
     }
 
     return strNew;
 }
 
 CMIUtilString
-CMIUtilString::ConvertToPrintableASCII(const char vChar)
+CMIUtilString::ConvertToPrintableASCII(const char vChar, bool bEscapeQuotes)
 {
     switch (vChar)
     {
         case '\a':
             return "\\a";
         case '\b':
             return "\\b";
         case '\t':
             return "\\t";
         case '\n':
             return "\\n";
         case '\v':
             return "\\v";
         case '\f':
             return "\\f";
         case '\r':
             return "\\r";
         case '\033':
             return "\\e";
         case '\\':
             return "\\\\";
+        case '"':
+            if (bEscapeQuotes)
+                return "\\\"";
+            // fall thru
         default:
             if (::isprint(vChar))
                 return Format("%c", vChar);
             else
                 return Format("\\x%02" PRIx8, vChar);
     }
 }
 
 CMIUtilString
-CMIUtilString::ConvertToPrintableASCII(const char16_t vChar16)
+CMIUtilString::ConvertCharValueToPrintableASCII(char vChar, bool bEscapeQuotes)
 {
-    if (vChar16 == (char16_t)(char)vChar16 && ::isprint(vChar16))
-        // Convert char16_t to char (if possible)
-        return Format("%c", vChar16);
+    switch (vChar)
+    {
+        case '\a':
+            return "\\a";
+        case '\b':
+            return "\\b";
+        case '\t':
+            return "\\t";
+        case '\n':
+            return "\\n";
+        case '\v':
+            return "\\v";
+        case '\f':
+            return "\\f";
+        case '\r':
+            return "\\r";
+        case '\033':
+            return "\\e";
+        case '\\':
+            return "\\\\";
+        case '"':
+            if (bEscapeQuotes)
+                return "\\\"";
+            // fall thru
+        default:
+            if (::isprint(vChar))
+                return Format("%c", vChar);
             else
-        return Format("\\u%02" PRIx8 "%02" PRIx8,
+                return CMIUtilString();
+    }
+}
+
+CMIUtilString
+CMIUtilString::ConvertToPrintableASCII(const char16_t vChar16, bool bEscapeQuotes)
+{
+    if (vChar16 == (char16_t)(char)vChar16)
+    {
+        // Convert char16_t to char (if possible)
+        CMIUtilString str = ConvertCharValueToPrintableASCII((char)vChar16, bEscapeQuotes);
+        if (str.length() > 0)
+            return str;
+    }
                       (vChar16 >> 8) & 0xff, vChar16 & 0xff);
 }
 
 CMIUtilString
-CMIUtilString::ConvertToPrintableASCII(const char32_t vChar32)
+CMIUtilString::ConvertToPrintableASCII(const char32_t vChar32, bool bEscapeQuotes)
+{
+    if (vChar32 == (char32_t)(char)vChar32)
     {
-    if (vChar32 == (char32_t)(char)vChar32 && ::isprint(vChar32))
         // Convert char32_t to char (if possible)
-        return Format("%c", vChar32);
-    else
-        return Format("\\U%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8,
+        CMIUtilString str = ConvertCharValueToPrintableASCII((char)vChar32, bEscapeQuotes);
+        if (str.length() > 0)
+            return str;
+    }
                       (vChar32 >> 24) & 0xff, (vChar32 >> 16) & 0xff,
                       (vChar32 >> 8) & 0xff, vChar32 & 0xff);
 }