[LLDB-MI] Escape MI output in a more consistent manner

[enlight]

Summary

While attempting to run lldb-mi on Windows it became apparent that it doesn't consistently escape output, for instance error messages contained paths with unescaped backslashes, and unescaped double-quotes. To address this issue without spending a ridiculous amount of time trying to track down every case where output isn't properly escaped I've opted to move all escaping into CMICmnMIValueConst. CMICmnMIValueConst is the basic building block of all output emitted by lldb-mi, so handling escaping in a consistent manner here will help to ensure all output is properly escaped. This change required removing any existing escaping of output to prevent double-escaping.

I've also removed the spacing code from CMICmnMIValueTuple and CMICmnMIValueResult, it was only misused to format composite values in CMICmnLLDBUtilSBValue::GetCompositeValue(). The format of composite values isn't specified by the GDB-MI spec, and as such these values shouldn't be built using CMICmnMIValueTuple, CMICmnMIValueResult, and CMICmnMIValueConst.

Tested on Ubuntu 14.10 x64 VM

[abidh]

I have a quick look and it seems ok. Apart from fixing the issue, it is a useful clean up too. If testcases are ok then please free to commit.

If you have noted that a function (AddSlashes?) is not longer needed after this then you may like to remove that too.

tools/lldb-mi/MICmnMIValueConst.cpp

48

So the Escape call here makes sure that we are escaping in all cases.

[enlight]

Thanks for the review. AddSlashes is still used in a couple of places (but not for escaping MI output), so I'll leave it be for now.

[enlight]

@ki.stfu Are you OK with this going in?

[ki.stfu]

@enlight , thanks for giving a chance to review it, and sorry that it took to long from my side.

Most of these changes look good to me, especially removing of meaningless temporal variables during construction of Result values. But I can't agree with that:

I've also removed the spacing code from CMICmnMIValueTuple and CMICmnMIValueResult, it was only misused to format composite values in CMICmnLLDBUtilSBValue::GetCompositeValue(). The format of composite values isn't specified by the GDB-MI spec, and as such these values shouldn't be built using CMICmnMIValueTuple, CMICmnMIValueResult, and CMICmnMIValueConst.

I'm not sure about extra spaces in tuple or result records (vbUseSpacing opt in CMICmnMIValueResult and CMICmnMIValueTuple respectively), but regarding CMICmnLLDBUtilSBValue::GetCompositeValue I'd like to leave "as is". Construction of tuples by hands (see my inline comment) looks terrible for me while using of CMICmnMIValueTuple looked very naturally.

Regarding your note about the format of composite values, the[[ https://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Output-Syntax.html#GDB_002fMI-Output-Syntax | GDB-MI spec ]] clearly says that:

result ==> variable "=" value
variable ==> string 
value ==> const | tuple | list 
const ==> c-string 
tuple ==> "{}" | "{" result ( "," result )* "}"

So, the aggregates are those whose root values are represented by tuples.

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

197–208

here

packages/Python/lldbsuite/test/tools/lldb-mi/syntax/TestMiSyntax.py

def test_lldbmi_specialchars(self):
         self.expect("\^done")
 
         # Check that it was loaded correctly
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_backslashes(self):
+        """Test that 'lldb-mi --interpreter' escapes backslashes in output."""
+
+        self.spawnLldbMi()
+
+        # Test that backslashes are escaped in error output records
+        unescaped_path = r'X:\this\is\a\fake\path'
+        escaped_path = r'X:\\this\\is\\a\\fake\\path'
+        self.runCmd('-file-exec-and-symbols %s' % unescaped_path)
+        self.expect(
+            """^error,msg="Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'""" %
+            (escaped_path, escaped_path), exactly=True)
+
+    @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
+    @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll(
         oslist=["linux"],
         bugnumber="Failing in ~6/600 dosep runs (build 3120-3122)")
     def test_lldbmi_process_output(self):
         """Test that 'lldb-mi --interpreter' wraps process output correctly."""
 
         self.spawnLldbMi(args=None)
 

packages/Python/lldbsuite/test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

def test_lldbmi_gdb_set_show_print_expand_aggregates(self):
         self.runCmd("-var-create var4 * complx_array")
         self.expect(
             "\^done,name=\"var4\",numchild=\"2\",value=\"{\[0\] = {i = 4, inner = {l = 4}, complex_ptr = 0x[0-9a-f]+}, \[1\] = {i = 5, inner = {l = 5}, complex_ptr = 0x[0-9a-f]+}}\",type=\"complex_type \[2\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that -gdb-set print expand-aggregates fails if "on"/"off" isn't
         # specified
         self.runCmd("-gdb-set print expand-aggregates")
         self.expect(
-            "\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
+            '''^error,msg="The request ''print' expects option-name and \\"on\\" or \\"off\\"' failed."''',
+            exactly=True)
 
         # Test that -gdb-set print expand-aggregates fails when option is
         # unknown
         self.runCmd("-gdb-set print expand-aggregates unknown")
         self.expect(
-            "\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
+            '''^error,msg="The request ''print' expects option-name and \\"on\\" or \\"off\\"' failed."''',
+            exactly=True)
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi working on Windows
     @expectedFailureAll(compiler="gcc", bugnumber="llvm.org/pr23357")
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_show_print_aggregate_field_names(self):
         """Test that 'lldb-mi --interpreter' can expand aggregates everywhere."""
 
         self.spawnLldbMi(args=None)
def test_lldbmi_gdb_set_show_print_aggregate_field_names(self):
         self.runCmd("-var-create var4 * complx_array")
         self.expect(
             "\^done,name=\"var4\",numchild=\"2\",value=\"{{4,\{4\},0x[0-9a-f]+},{5,\{5\},0x[0-9a-f]+}}\",type=\"complex_type \[2\]\",thread-id=\"1\",has_more=\"0\"")
 
         # Test that -gdb-set print aggregate-field-names fails if "on"/"off"
         # isn't specified
         self.runCmd("-gdb-set print aggregate-field-names")
         self.expect(
-            "\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
+            '''^error,msg="The request ''print' expects option-name and \\"on\\" or \\"off\\"' failed."''',
+            exactly=True)
 
         # Test that -gdb-set print aggregate-field-names fails when option is
         # unknown
         self.runCmd("-gdb-set print aggregate-field-names unknown")
         self.expect(
-            "\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
+            '''^error,msg="The request ''print' expects option-name and \\"on\\" or \\"off\\"' failed."''',
+            exactly=True)

tools/lldb-mi/MICmdCmdData.cpp

if (!utilValue.HasName()) {
 
     m_strValue = rExpression;
     return MIstatus::success;
   }
   if (rExpression.IsQuoted()) {
     m_strValue = rExpression.Trim('\"');
     return MIstatus::success;
   }
-  m_strValue = utilValue.GetValue(true).Escape().AddSlashes();
+  m_strValue = utilValue.GetValue(true);
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record
 // Result
 //          for the work carried out in the Execute().
if (m_bEvaluatedExpression) {
           m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done,
           miValueResult);
       m_miResultRecord = miRecordResult;
       return MIstatus::success;
     }
     CMIUtilString mi_error_msg = "Could not evaluate expression";
     if (const char *err_msg = m_Error.GetCString())
       mi_error_msg = err_msg;
-    const CMICmnMIValueConst miValueConst(mi_error_msg.Escape(true));
-    const CMICmnMIValueResult miValueResult("msg", miValueConst);
     const CMICmnMIResultRecord miRecordResult(
         m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-        miValueResult);
+        CMICmnMIValueResult("msg", CMICmnMIValueConst(mi_error_msg)));
     m_miResultRecord = miRecordResult;
     return MIstatus::success;
   }
 
   const CMICmnMIValueConst miValueConst("Invalid expression");
   const CMICmnMIValueResult miValueResult("msg", miValueConst);
   const CMICmnMIResultRecord miRecordResult(
       m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
for (size_t i = 0; i < nInstructions; i++) {
     const CMICmnMIValueResult miValueResult3("offset", miValueConst3);
     miValueTuple.Add(miValueResult3);
     const CMICmnMIValueConst miValueConst4(
         CMIUtilString::Format("%d", instrtSize));
     const CMICmnMIValueResult miValueResult4("size", miValueConst4);
     miValueTuple.Add(miValueResult4);
     const CMICmnMIValueConst miValueConst5(
         CMIUtilString::Format("%s %s%s", pStrMnemonic, pStrOperands,
-                              strComment.Escape(true).c_str()));
+                              strComment.c_str()));
     const CMICmnMIValueResult miValueResult5("inst", miValueConst5);
     miValueTuple.Add(miValueResult5);
 
     if (nDisasmMode == 1) {
       lldb::SBLineEntry lineEntry = address.GetLineEntry();
       const MIuint nLine = lineEntry.GetLine();
       const char *pFileName = lineEntry.GetFileSpec().GetFilename();
       pFileName = (pFileName != nullptr) ? pFileName : pUnknown;

tools/lldb-mi/MICmdCmdVar.cpp

if (m_bValid) {
 
     return MIstatus::success;
   }
 
   CMIUtilString strErrMsg(m_strValue);
   if (m_strValue.empty())
     strErrMsg = CMIUtilString::Format(
         MIRSRC(IDS_CMD_ERR_VARIABLE_CREATION_FAILED), m_strExpression.c_str());
-  const CMICmnMIValueConst miValueConst(
-      strErrMsg.Escape(true /* vbEscapeQuotes */));
-  CMICmnMIValueResult miValueResult("msg", miValueConst);
   const CMICmnMIResultRecord miRecordResult(
       m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Error,
-      miValueResult);
+      CMICmnMIValueResult("msg", CMICmnMIValueConst(strErrMsg)));
   m_miResultRecord = miRecordResult;
 
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Required by the CMICmdFactory when registering *this command. The

tools/lldb-mi/MICmnLLDBDebugSessionInfo.h

private:
   //
   bool GetVariableInfo(const lldb::SBValue &vrValue, const bool vbInSimpleForm,
                        CMIUtilString &vwrStrValue);
   bool GetFrameInfo(const lldb::SBFrame &vrFrame, lldb::addr_t &vwPc,
                     CMIUtilString &vwFnName, CMIUtilString &vwFileName,
                     CMIUtilString &vwPath, MIuint &vwnLine);
   bool GetThreadFrames(const SMICmdData &vCmdData, const MIuint vThreadIdx,
                        const FrameInfoFormat_e veFrameInfoFormat,
-                       CMIUtilString &vwrThreadFrames);
+                       CMICmnMIValueResult &vwrThreadFrames);
   bool
   MIResponseForVariableInfoInternal(const VariableInfoFormat_e veVarInfoFormat,
                                     CMICmnMIValueList &vwrMiValueList,
                                     const lldb::SBValueList &vwrSBValueList,
                                     const MIuint vnMaxDepth,
                                     const bool vbIsArgs, const bool vbMarkArgs);
 
   // Overridden:

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

 //          vThreadIdx      - (R) Thread index.
 //          vwrThreadFrames - (W) Frame data.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmnLLDBDebugSessionInfo::GetThreadFrames(
     const SMICmdData &vCmdData, const MIuint vThreadIdx,
-    const FrameInfoFormat_e veFrameInfoFormat, CMIUtilString &vwrThreadFrames) {
+    const FrameInfoFormat_e veFrameInfoFormat, CMICmnMIValueResult &vwrThreadFrames) {
   lldb::SBThread thread = GetProcess().GetThreadByIndexID(vThreadIdx);
   const uint32_t nFrames = thread.GetNumFrames();
   if (nFrames == 0) {
     // MI print "frame={}"
-    CMICmnMIValueTuple miValueTuple;
-    CMICmnMIValueResult miValueResult("frame", miValueTuple);
-    vwrThreadFrames = miValueResult.GetString();
+    vwrThreadFrames = CMICmnMIValueResult("frame", CMICmnMIValueTuple());
     return MIstatus::success;
   }
 
   // MI print
   // "frame={level=\"%d\",addr=\"0x%016" PRIx64
   // "\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},frame={level=\"%d\",addr=\"0x%016"
   // PRIx64 "\",func=\"%s\",args=[%s],file=\"%s\",fullname=\"%s\",line=\"%d\"},
   // ..."
-  CMIUtilString strListCommaSeparated;
   for (MIuint nLevel = 0; nLevel < nFrames; nLevel++) {
     CMICmnMIValueTuple miValueTuple;
     if (!MIResponseFormFrameInfo(thread, nLevel, veFrameInfoFormat,
                                  miValueTuple))
       return MIstatus::failure;
 
-    const CMICmnMIValueResult miValueResult2("frame", miValueTuple);
     if (nLevel != 0)
-      strListCommaSeparated += ",";
-    strListCommaSeparated += miValueResult2.GetString();
+      vwrThreadFrames.Add("frame", miValueTuple);
+    else
+      vwrThreadFrames = CMICmnMIValueResult("frame", miValueTuple);
   }
 
-  vwrThreadFrames = strListCommaSeparated;
-
   return MIstatus::success;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Return the resolved file's path for the given file.
 // Type:    Method.
 // Args:    vCmdData        - (R) A command's information.
bool CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo(
   else
     strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
   const CMICmnMIValueConst miValueConst2(strThread);
   const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
   vwrMIValueTuple.Add(miValueResult2);
 
   // Add "frame"
   if (veThreadInfoFormat != eThreadInfoFormat_NoFrames) {
-    CMIUtilString strFrames;
+    CMICmnMIValueResult frames;
     if (!GetThreadFrames(vCmdData, rThread.GetIndexID(),
-                         eFrameInfoFormat_AllArgumentsInSimpleForm, strFrames))
+                         eFrameInfoFormat_AllArgumentsInSimpleForm, frames))
       return MIstatus::failure;
 
-    const CMICmnMIValueConst miValueConst3(strFrames, true);
-    vwrMIValueTuple.Add(miValueConst3, false);
+    vwrMIValueTuple.Add(frames);
   }
 
   // Add "state"
   const CMICmnMIValueConst miValueConst4(strState);
   const CMICmnMIValueResult miValueResult4("state", miValueConst4);
   vwrMIValueTuple.Add(miValueResult4);
 
   return MIstatus::success;
if (veVarInfoFormat != eVariableInfoFormat_NoValues) {
       }
       const MIuint nChildren = value.GetNumChildren();
       const bool bIsPointerType = value.GetType().IsPointerType();
       if (nChildren == 0 ||                                 // no children
           (bIsPointerType && nChildren == 1) ||             // pointers
           veVarInfoFormat == eVariableInfoFormat_AllValues) // show all values
       {
         CMIUtilString strValue;
-        if (GetVariableInfo(value, vnMaxDepth == 0, strValue)) {
-          const CMICmnMIValueConst miValueConst2(
-              strValue.Escape().AddSlashes());
-          const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-          miValueTuple.Add(miValueResult2);
-        }
+        if (GetVariableInfo(value, vnMaxDepth == 0, strValue))
+          miValueTuple.Add(CMICmnMIValueResult("value",
+                                               CMICmnMIValueConst(strValue)));
       }
       vwrMiValueList.Add(miValueTuple);
       continue;
     }
 
     if (vbMarkArgs) {
       // If we are printing names only with vbMarkArgs, we still need to add the
       // name to the value tuple

tools/lldb-mi/MICmnLLDBDebugSessionInfoVarObj.cpp

CMICmnLLDBDebugSessionInfoVarObj::GetVarFormatForChar(char vcFormat) {
   }
 
   return eVarFormat_Invalid;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Return the equivalent var value formatted string for the given value
-// type,
-//          which was prepared for printing (i.e. value was escaped and now it's
-//          ready
-//          for wrapping into quotes).
+// type.
 //          The SBValue vrValue parameter is checked by LLDB private code for
 //          valid
 //          scalar type via MI Driver proxy function as the valued returned can
 //          also be
 //          an error condition. The proxy function determines if the check was
 //          valid
 //          otherwise return an error condition state by other means saying so.
 // Type:    Static method.
CMIUtilString CMICmnLLDBDebugSessionInfoVarObj::GetValueStringFormatted(
   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().AddSlashes();
+  return utilValue.GetValue();
 }
 
 //++
 //------------------------------------------------------------------------------------
 // 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

tools/lldb-mi/MICmnLLDBDebuggerHandleEvents.cpp

bool CMICmnLLDBDebuggerHandleEvents::MiHelpGetModuleInfo(
     CMICmnMIOutOfBandRecord &vwrMiOutOfBandRecord) {
   bool bOk = MIstatus::success;
 
   // First, build standard fields:
   // Build "id" field
   std::unique_ptr<char[]> apPath(new char[PATH_MAX]);
   vModule.GetFileSpec().GetPath(apPath.get(), PATH_MAX);
   const CMIUtilString strTargetPath(apPath.get());
-  const CMICmnMIValueConst miValueConst(strTargetPath.AddSlashes());
-  const CMICmnMIValueResult miValueResult("id", miValueConst);
-  vwrMiOutOfBandRecord.Add(miValueResult);
+  vwrMiOutOfBandRecord.Add(
+      CMICmnMIValueResult("id", CMICmnMIValueConst(strTargetPath)));
   // Build "target-name" field
-  const CMICmnMIValueConst miValueConst2(strTargetPath.AddSlashes());
-  const CMICmnMIValueResult miValueResult2("target-name", miValueConst2);
-  vwrMiOutOfBandRecord.Add(miValueResult2);
+  vwrMiOutOfBandRecord.Add(
+      CMICmnMIValueResult("target-name", CMICmnMIValueConst(strTargetPath)));
   // Build "host-name" field
   vModule.GetPlatformFileSpec().GetPath(apPath.get(), PATH_MAX);
   const CMIUtilString strHostPath(apPath.get());
-  const CMICmnMIValueConst miValueConst3(strHostPath.AddSlashes());
-  const CMICmnMIValueResult miValueResult3("host-name", miValueConst3);
-  vwrMiOutOfBandRecord.Add(miValueResult3);
+  vwrMiOutOfBandRecord.Add(
+      CMICmnMIValueResult("host-name", CMICmnMIValueConst(strHostPath)));
 
   // Then build extra fields if needed:
   if (vbWithExtraFields) {
     // Build "symbols-loaded" field
     vModule.GetSymbolFileSpec().GetPath(apPath.get(), PATH_MAX);
     const CMIUtilString strSymbolsPath(apPath.get());
     const bool bSymbolsLoaded =
         !CMIUtilString::Compare(strHostPath, strSymbolsPath);
     const CMICmnMIValueConst miValueConst4(
         CMIUtilString::Format("%d", bSymbolsLoaded));
     const CMICmnMIValueResult miValueResult4("symbols-loaded", miValueConst4);
     vwrMiOutOfBandRecord.Add(miValueResult4);
     // Build "symbols-path" field
     if (bSymbolsLoaded) {
-      const CMICmnMIValueConst miValueConst5(strSymbolsPath.AddSlashes());
-      const CMICmnMIValueResult miValueResult5("symbols-path", miValueConst5);
-      vwrMiOutOfBandRecord.Add(miValueResult5);
+      vwrMiOutOfBandRecord.Add(
+          CMICmnMIValueResult("symbols-path",
+                              CMICmnMIValueConst(strSymbolsPath)));
     }
     // Build "loaded_addr" field
     lldb::SBAddress sbAddress(vModule.GetObjectFileHeaderAddress());
     CMICmnLLDBDebugSessionInfo &rSessionInfo(
         CMICmnLLDBDebugSessionInfo::Instance());
     const lldb::addr_t nLoadAddress(
         sbAddress.GetLoadAddress(rSessionInfo.GetTarget()));
     const CMIUtilString strLoadedAddr(
while (1) {
 
     while (1) {
       const size_t nNewLine = text.find('\n');
       if (nNewLine == std::string::npos)
         break;
 
       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);
+          CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput,
+          CMICmnMIValueConst(line));
       const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
       if (!bOk)
         return MIstatus::failure;
     }
 
     if (nBytes == 0) {
       if (!text.empty()) {
-        const bool bEscapeQuotes(true);
-        CMICmnMIValueConst miValueConst(text.Escape(bEscapeQuotes));
         CMICmnMIOutOfBandRecord miOutOfBandRecord(
             CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput,
-            miValueConst);
+            CMICmnMIValueConst(text));
         return MiOutOfBandRecordToStdout(miOutOfBandRecord);
       }
       break;
     }
   }
 
   return MIstatus::success;
 }
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));
-      const bool bEscapeQuotes(true);
-      CMICmnMIValueConst miValueConst(line.Escape(bEscapeQuotes));
       CMICmnMIOutOfBandRecord miOutOfBandRecord(
-          CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput, miValueConst);
+          CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput,
+          CMICmnMIValueConst(line));
       const bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
       if (!bOk)
         return MIstatus::failure;
     }
 
     if (nBytes == 0) {
       if (!text.empty()) {
-        const bool bEscapeQuotes(true);
-        CMICmnMIValueConst miValueConst(text.Escape(bEscapeQuotes));
         CMICmnMIOutOfBandRecord miOutOfBandRecord(
             CMICmnMIOutOfBandRecord::eOutOfBand_TargetStreamOutput,
-            miValueConst);
+            CMICmnMIValueConst(text));
         return MiOutOfBandRecordToStdout(miOutOfBandRecord);
       }
       break;
     }
   }
 
   return MIstatus::success;
 }

tools/lldb-mi/MICmnLLDBUtilSBValue.h

 private:
   template <typename charT>
   CMIUtilString
   ReadCStringFromHostMemory(lldb::SBValue &vrValue,
                             const MIuint vnMaxLen = UINT32_MAX) const;
   bool GetSimpleValue(const bool vbHandleArrayType,
                       CMIUtilString &vrValue) const;
   bool GetCompositeValue(const bool vbPrintFieldNames,
-                         CMICmnMIValueTuple &vwrMiValueTuple,
+                         CMIUtilString &vwrCompositeValue,
                          const MIuint vnDepth = 1) const;
   CMIUtilString
   GetValueSummary(bool valueOnly,
                   const CMIUtilString &failVal = CMIUtilString()) const;
 
   // Statics:
 private:
   static bool IsCharBasicType(lldb::BasicType eType);

tools/lldb-mi/MICmnLLDBUtilSBValue.cpp

CMIUtilString CMICmnLLDBUtilSBValue::GetValue(
 
   bool bPrintAggregateFieldNames = false;
   bPrintAggregateFieldNames =
       !rSessionInfo.SharedDataRetrieve<bool>(
           rSessionInfo.m_constStrPrintAggregateFieldNames,
           bPrintAggregateFieldNames) ||
       bPrintAggregateFieldNames;
 
-  CMICmnMIValueTuple miValueTuple;
-  const bool bOk = GetCompositeValue(bPrintAggregateFieldNames, miValueTuple);
+  const bool bOk = GetCompositeValue(bPrintAggregateFieldNames, value);
   if (!bOk)
     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).
if (!vwrValue.empty())
       return MIstatus::success;
   }
 
   // Composite variable type i.e. struct
   return MIstatus::failure;
 }
 
 bool CMICmnLLDBUtilSBValue::GetCompositeValue(
-    const bool vbPrintFieldNames, CMICmnMIValueTuple &vwrMiValueTuple,
+    const bool vbPrintFieldNames, CMIUtilString &vwrCompositeValue,
     const MIuint vnDepth /* = 1 */) const {
   const MIuint nMaxDepth = 10;
   const MIuint nChildren = m_rValue.GetNumChildren();
+  vwrCompositeValue = "{";
   for (MIuint i = 0; i < nChildren; ++i) {
     const lldb::SBValue member = m_rValue.GetChildAtIndex(i);
     const CMICmnLLDBUtilSBValue utilMember(member, m_bHandleCharType,
                                            m_bHandleArrayType);
     const bool bHandleArrayTypeAsSimple = false;
     CMIUtilString value;
     const bool bIsSimpleValue =
         utilMember.GetSimpleValue(bHandleArrayTypeAsSimple, value);
     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);
+                                                    value, vnDepth + 1);
       if (!bOk)
         // Can't obtain composite type
         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 = 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);
+      if (vwrCompositeValue.back() != '{')
+        vwrCompositeValue += ", ";
+      vwrCompositeValue += CMIUtilString::Format("%s = %s",
+                                                 utilMember.GetName().c_str(),
+                                                 value.c_str());
     } else {
-      const bool bUseSpacing = false;
-      vwrMiValueTuple.Add(miValueConst, bUseSpacing);
+      if (vwrCompositeValue.back() != '{')
+        vwrCompositeValue += ",";
+      vwrCompositeValue += value;
     }
   }
+  vwrCompositeValue += "}";
 
   return MIstatus::success;
 }
 
 // Returns value or value + summary, depending on valueOnly parameter value.
 // If result is an empty string returns failVal.
 CMIUtilString
 CMICmnLLDBUtilSBValue::GetValueSummary(bool valueOnly,

tools/lldb-mi/MICmnMIValueConst.h

 //
 //          The text formed in *this Result class is stripped of any '\n'
 //          characters.
 //--
 class CMICmnMIValueConst : public CMICmnMIValue {
   // Methods:
 public:
   /* ctor */ CMICmnMIValueConst(const CMIUtilString &vString);
-  /* ctor */ CMICmnMIValueConst(const CMIUtilString &vString,
-                                const bool vbNoQuotes);
 
   // Overridden:
 public:
   // From CMICmnBase
   /* dtor */ ~CMICmnMIValueConst() override;
 
   // Methods:
 private:
   bool BuildConst();
 
   // Attributes:
 private:
-  static const CMIUtilString ms_constStrDblQuote;
   //
   CMIUtilString m_strPartConst;
-  bool m_bNoQuotes; // True = return string not surrounded with quotes, false =
-                    // use quotes
 };

tools/lldb-mi/MICmnMIValueConst.cpp

 //===-- MICmnMIValueConst.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // In-house headers:
 #include "MICmnMIValueConst.h"
 
-// Instantiations:
-const CMIUtilString CMICmnMIValueConst::ms_constStrDblQuote("\"");
-
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueConst constructor.
 // Type:    Method.
 // Args:    vString - (R) MI Const c-string value.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueConst::CMICmnMIValueConst(const CMIUtilString &vString)
-    : m_strPartConst(vString), m_bNoQuotes(false) {
-  BuildConst();
-}
-
-//++
-//------------------------------------------------------------------------------------
-// Details: CMICmnMIValueConst constructor.
-// Type:    Method.
-// Args:    vString     - (R) MI Const c-string value.
-//          vbNoQuotes  - (R) True = return string not surrounded with quotes,
-//          false = use quotes.
-// Return:  None.
-// Throws:  None.
-//--
-CMICmnMIValueConst::CMICmnMIValueConst(const CMIUtilString &vString,
-                                       const bool vbNoQuotes)
-    : m_strPartConst(vString), m_bNoQuotes(vbNoQuotes) {
+    : m_strPartConst(vString) {
   BuildConst();
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueConst destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueConst::~CMICmnMIValueConst() {}
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Build the Value Const data.
 // Type:    Method.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool CMICmnMIValueConst::BuildConst() {
   if (m_strPartConst.length() != 0) {
-    const CMIUtilString strValue(m_strPartConst.StripCREndOfLine());
-    if (m_bNoQuotes) {
-      m_strValue = strValue;
-    } else {
-      const char *pFormat = "%s%s%s";
-      m_strValue =
-          CMIUtilString::Format(pFormat, ms_constStrDblQuote.c_str(),
-                                strValue.c_str(), ms_constStrDblQuote.c_str());
-    }
+    m_strValue = CMIUtilString::Format("\"%s\"",
+                                       m_strPartConst.Escape(true).c_str());
   } else {
-    const char *pFormat = "%s%s";
-    m_strValue = CMIUtilString::Format(pFormat, ms_constStrDblQuote.c_str(),
-                                       ms_constStrDblQuote.c_str());
+    m_strValue = "\"\"";
   }
 
   return MIstatus::success;
 }

tools/lldb-mi/MICmnMIValueResult.h

 //          http://ftp.gnu.org/old-gnu/Manuals/gdb-5.1.1/html_chapter/gdb_22.html
 //--
 class CMICmnMIValueResult : public CMICmnMIValue {
   // Methods:
 public:
   /* ctor */ CMICmnMIValueResult();
   /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable,
                                  const CMICmnMIValue &vValue);
-  /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable,
-                                 const CMICmnMIValue &vValue,
-                                 const bool vbUseSpacing);
   //
   void Add(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
 
   // Overridden:
 public:
   // From CMICmnBase
   /* dtor */ ~CMICmnMIValueResult() override;
 
   // Methods:
 private:
   void BuildResult();
   void BuildResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
 
   // Attributes:
 private:
-  static const CMIUtilString ms_constStrEqual;
   //
   CMIUtilString m_strPartVariable;
   CMICmnMIValue m_partMIValue;
   bool m_bEmptyConstruction; // True = *this object used constructor with no
                              // parameters, false = constructor with parameters
-  bool m_bUseSpacing; // True = put space separators into the string, false = no
-                      // spaces used
 };

tools/lldb-mi/MICmnMIValueResult.cpp

 //===-- MICmnMIValueResult.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // In-house headers:
 #include "MICmnMIValueResult.h"
 #include "MICmnResources.h"
 
-// Instantiations:
-const CMIUtilString CMICmnMIValueResult::ms_constStrEqual("=");
-
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueResult constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueResult::CMICmnMIValueResult() : m_bEmptyConstruction(true) {}
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueResult constructor.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.
 //          vrValue     - (R) The MI value.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueResult::CMICmnMIValueResult(const CMIUtilString &vrVariable,
                                          const CMICmnMIValue &vrValue)
     : m_strPartVariable(vrVariable), m_partMIValue(vrValue),
-      m_bEmptyConstruction(false), m_bUseSpacing(false) {
-  BuildResult();
-}
-
-//++
-//------------------------------------------------------------------------------------
-// Details: CMICmnMIValueResult constructor.
-// Type:    Method.
-// Args:    vrVariable      - (R) MI value's name.
-//          vrValue         - (R) The MI value.
-//          vbUseSpacing    - (R) True = put space separators into the string,
-//          false = no spaces used.
-// Return:  None.
-// Throws:  None.
-//--
-CMICmnMIValueResult::CMICmnMIValueResult(const CMIUtilString &vrVariable,
-                                         const CMICmnMIValue &vrValue,
-                                         const bool vbUseSpacing)
-    : m_strPartVariable(vrVariable), m_partMIValue(vrValue),
-      m_bEmptyConstruction(false), m_bUseSpacing(vbUseSpacing) {
+      m_bEmptyConstruction(false) {
   BuildResult();
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueResult destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueResult::~CMICmnMIValueResult() {}
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Build the MI value result string.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 void CMICmnMIValueResult::BuildResult() {
-  const char *pFormat = m_bUseSpacing ? "%s %s %s" : "%s%s%s";
-  m_strValue = CMIUtilString::Format(pFormat, m_strPartVariable.c_str(),
-                                     ms_constStrEqual.c_str(),
+  m_strValue = CMIUtilString::Format("%s=%s", m_strPartVariable.c_str(),
                                      m_partMIValue.GetString().c_str());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Build the MI value result string.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.
 //          vrValue     - (R) The MI value.
 // Return:  None.
 // Throws:  None.
 //--
 void CMICmnMIValueResult::BuildResult(const CMIUtilString &vVariable,
                                       const CMICmnMIValue &vValue) {
-  const char *pFormat = m_bUseSpacing ? "%s, %s %s %s" : "%s,%s%s%s";
   m_strValue = CMIUtilString::Format(
-      pFormat, m_strValue.c_str(), vVariable.c_str(), ms_constStrEqual.c_str(),
+      "%s,%s=%s", m_strValue.c_str(), vVariable.c_str(),
       vValue.GetString().c_str());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Append another MI value object to *this MI value result.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.

tools/lldb-mi/MICmnMIValueTuple.h

 //          More information see:
 //          http://ftp.gnu.org/old-gnu/Manuals/gdb-5.1.1/html_chapter/gdb_22.html
 //--
 class CMICmnMIValueTuple : public CMICmnMIValue {
   // Methods:
 public:
   /* ctor */ CMICmnMIValueTuple();
   /* ctor */ CMICmnMIValueTuple(const CMICmnMIValueResult &vResult);
-  /* ctor */ CMICmnMIValueTuple(const CMICmnMIValueResult &vResult,
-                                const bool vbUseSpacing);
   //
   void Add(const CMICmnMIValueResult &vResult);
-  void Add(const CMICmnMIValueResult &vResult, const bool vbUseSpacing);
-  void Add(const CMICmnMIValueConst &vValue, const bool vbUseSpacing);
+  void Add(const CMICmnMIValueConst &vValue);
   CMIUtilString ExtractContentNoBrackets() const;
 
   // Overridden:
 public:
   // From CMICmnBase
   /* dtor */ ~CMICmnMIValueTuple() override;
 
   // Methods:
 private:
   void BuildTuple();
   void BuildTuple(const CMICmnMIValueResult &vResult);
   void BuildTuple(const CMIUtilString &vValue);
-
-  // Attributes:
-private:
-  bool m_bSpaceAfterComma; // True = put space separators into the string, false
-                           // = no spaces used
 };

tools/lldb-mi/MICmnMIValueTuple.cpp

 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueTuple constructor.
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmnMIValueTuple::CMICmnMIValueTuple() : m_bSpaceAfterComma(false) {
+CMICmnMIValueTuple::CMICmnMIValueTuple() {
   m_strValue = "{}";
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueTuple constructor.
 // Type:    Method.
 // Args:    vResult - (R) MI result object.
 // Return:  None.
 // Throws:  None.
 //--
-CMICmnMIValueTuple::CMICmnMIValueTuple(const CMICmnMIValueResult &vResult)
-    : m_bSpaceAfterComma(false) {
-  m_strValue = vResult.GetString();
-  BuildTuple();
-  m_bJustConstructed = false;
-}
-
-//++
-//------------------------------------------------------------------------------------
-// Details: CMICmnMIValueTuple constructor.
-// Type:    Method.
-// Args:    vResult         - (R) MI result object.
-//          vbUseSpacing    - (R) True = put space separators into the string,
-//          false = no spaces used.
-// Return:  None.
-// Throws:  None.
-//--
-CMICmnMIValueTuple::CMICmnMIValueTuple(const CMICmnMIValueResult &vResult,
-                                       const bool vbUseSpacing)
-    : m_bSpaceAfterComma(vbUseSpacing) {
+CMICmnMIValueTuple::CMICmnMIValueTuple(const CMICmnMIValueResult &vResult) {
   m_strValue = vResult.GetString();
   BuildTuple();
   m_bJustConstructed = false;
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnMIValueTuple destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 CMICmnMIValueTuple::~CMICmnMIValueTuple() {}
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Build the result value's mandatory data part, one tuple
 // Type:    Method.
 // Args:    None.
 // Return:  None.
 // Throws:  None.
 //--
 void CMICmnMIValueTuple::BuildTuple() {
-  const char *pFormat = "{%s}";
-  m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str());
+  m_strValue = CMIUtilString::Format("{%s}", m_strValue.c_str());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Add another MI result object to the value's list of tuples.
 // Type:    Method.
 // Args:    vResult - (R) The MI result object.
 // Return:  None.
void CMICmnMIValueTuple::BuildTuple(const CMICmnMIValueResult &vResult) {
 
   if (m_strValue[0] == '{') {
     m_strValue = m_strValue.substr(1, m_strValue.size() - 1);
   }
   if (m_strValue[m_strValue.size() - 1] == '}') {
     m_strValue = m_strValue.substr(0, m_strValue.size() - 1);
   }
 
-  const char *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
-  m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str(),
+  m_strValue = CMIUtilString::Format("{%s,%s}", m_strValue.c_str(),
                                      vResult.GetString().c_str());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Add string value to the value's list of tuples.
 // Type:    Method.
 // Args:    vValue  - (R) The string object.
 // Return:  None.
 // Throws:  None.
 //--
 void CMICmnMIValueTuple::BuildTuple(const CMIUtilString &vValue) {
   // Clear out the default "<Invalid>" text
   if (m_bJustConstructed) {
     m_bJustConstructed = false;
     m_strValue = vValue;
     BuildTuple();
     return;
   }
 
   const CMIUtilString data(ExtractContentNoBrackets());
-  const char *pFormat = m_bSpaceAfterComma ? "{%s, %s}" : "{%s,%s}";
-  m_strValue = CMIUtilString::Format(pFormat, data.c_str(), vValue.c_str());
+  m_strValue = CMIUtilString::Format("{%s,%s}", data.c_str(), vValue.c_str());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Add another MI value object to  the value list's of list is values.
 //          Only values objects can be added to a list of values otherwise this
 //          function
 //          will return MIstatus::failure.

 //++
 //------------------------------------------------------------------------------------
 // Details: Add another MI value object to  the value list's of list is values.
 //          Only values objects can be added to a list of values otherwise this
 //          function
 //          will return MIstatus::failure.
 // Type:    Method.
 // Args:    vValue          - (R) The MI value object.
-//          vbUseSpacing    - (R) True = put space separators into the string,
-//          false = no spaces used.
-// Return:  None.
-// Throws:  None.
-//--
-void CMICmnMIValueTuple::Add(const CMICmnMIValueResult &vResult,
-                             const bool vbUseSpacing) {
-  m_bSpaceAfterComma = vbUseSpacing;
-  BuildTuple(vResult);
-}
-
-//++
-//------------------------------------------------------------------------------------
-// Details: Add another MI value object to  the value list's of list is values.
-//          Only values objects can be added to a list of values otherwise this
-//          function
-//          will return MIstatus::failure.
-// Type:    Method.
-// Args:    vValue          - (R) The MI value object.
-//          vbUseSpacing    - (R) True = put space separators into the string,
 //          false = no spaces used.
 // Return:  None.
 // Throws:  None.
 //--
-void CMICmnMIValueTuple::Add(const CMICmnMIValueConst &vValue,
-                             const bool vbUseSpacing) {
-  m_bSpaceAfterComma = vbUseSpacing;
+void CMICmnMIValueTuple::Add(const CMICmnMIValueConst &vValue) {
   BuildTuple(vValue.GetString());
 }
 
 //++
 //------------------------------------------------------------------------------------
 // Details: Retrieve the contents of *this value object but without the outer
 // most
 //          brackets.