[lldb-mi] Remove unused bool results.

[brucem]

Summary

Many methods, in particular various 'Add' methods didn't have
any actual failure scenarios that were being emitted. This meant
that a lot of surrounding code could be simplified.

[abidh]

Apart from one little comment, looks good.

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

512 ↗

(On Diff #30344)

Does this function return false somewhere or this return type is also redundant.

[brucem]

tools/lldb-mi/MICmnLLDBDebugSessionInfo.cpp

512 ↗

(On Diff #30344)

That return type is also redundant. There are some of them remaining, especially in threading stuff. But I wanted to keep the current patch relatively self-contained.

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

public:
     // Typedefs:
   public:
     typedef std::vector<CMICmdArgValBase *> SetCmdArgs_t;
 
     // Methods:
   public:
     /* ctor */ CMICmdArgSet(void);
 
-    bool Add(const CMICmdArgValBase &vArg);
+    void Add(const CMICmdArgValBase &vArg);
     bool GetArg(const CMIUtilString &vArgName, CMICmdArgValBase *&vpArg) const;
     const SetCmdArgs_t &GetArgsThatAreMissing(void) const;
     const SetCmdArgs_t &GetArgsThatInvalid(void) const;
     size_t GetCount(void) const;
     bool IsArgContextEmpty(void) const;
     bool IsArgsPresentButNotHandledByCmd(void) const;
     void WarningArgsNotHandledbyCmdLogFile(const CMIUtilString &vrCmdName);
     bool Validate(const CMIUtilString &vStrMiCmd, CMICmdArgContext &vwCmdArgsText);

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

 {
     return m_bIsArgsPresentButNotHandledByCmd;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add the list of command's arguments to parse and validate another one.
 // Type:    Method.
 // Args:    vArg    - (R) A command argument object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmdArgSet::Add(const CMICmdArgValBase &vArg)
 {
     CMICmdArgValBase *pArg = const_cast<CMICmdArgValBase *>(&vArg);
     m_setCmdArgs.push_back(pArg);
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: After validating an options line of text (the context) and there is a failure,
 //          it is likely a mandatory command argument that is required is missing. This
 //          function returns the argument that should be present.
 // Type:    Method.
 // Args:    None.

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

class CMICmdBase : public CMICmnBase, public CMICmdInvoker::ICmd, public CMICmdFactory::ICmd
   public:
     /* ctor */ CMICmdBase(void);
 
     // Overridden:
   public:
     // From CMICmdInvoker::ICmd
     virtual const SMICmdData &GetCmdData(void) const;
     virtual const CMIUtilString &GetErrorDescription(void) const;
-    virtual bool SetCmdData(const SMICmdData &vCmdData);
+    virtual void SetCmdData(const SMICmdData &vCmdData);
     virtual void CmdFinishedTellInvoker(void) const;
     virtual const CMIUtilString &GetMIResultRecord(void) const;
     virtual const CMIUtilString &GetMIResultRecordExtra(void) const;
     virtual bool HasMIResultRecordExtra(void) const;
     virtual bool ParseArgs(void);
     // From CMICmdFactory::ICmd
     virtual const CMIUtilString &GetMiCmd(void) const;
     virtual CMICmdFactory::CmdCreatorFnPtr GetCmdCreatorFn(void) const;

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

CMICmdBase::GetMiCmd(void) const
     return m_strMiCmd;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. A command must be given working data and
 //          provide data about its status or provide information to other objects.
 // Type:    Overridden.
 // Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmdBase::SetCmdData(const SMICmdData &vCmdData)
 {
     m_cmdData = vCmdData;
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The command factory requires this function. The factory calls this function
 //          so it can obtain *this command's creation function.
 // Type:    Overridden.
 // Args:    None.
 // Return:  CMICmdFactory::CmdCreatorFnPtr - Function pointer.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakInsert::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedTempBrkPt, false, true)));
-    // Not implemented bOk = bOk && m_setCmdArgs.Add( *(new CMICmdArgValOptionShort( m_constStrArgNamedHWBrkPt, false, false ) ) );
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedPendinfBrkPt, false, true,
-                                                         CMICmdArgValListBase::eArgValType_StringQuotedNumberPath, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedDisableBrkPt, false, false)));
-    // Not implemented bOk = bOk && m_setCmdArgs.Add( *(new CMICmdArgValOptionShort( m_constStrArgNamedTracePt, false, false ) ) );
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedConditionalBrkPt, false, true,
-                                                         CMICmdArgValListBase::eArgValType_StringQuoted, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionShort(m_constStrArgNamedInoreCnt, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedRestrictBrkPtToThreadId, false, true,
-                                                         CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedLocation, false, true)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGroup, false, true, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedTempBrkPt, false, true)));
+    // Not implemented m_setCmdArgs.Add( *(new CMICmdArgValOptionShort( m_constStrArgNamedHWBrkPt, false, false ) ) );
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedDisableBrkPt, false, false)));
+    // Not implemented m_setCmdArgs.Add( *(new CMICmdArgValOptionShort( m_constStrArgNamedTracePt, false, false ) ) );
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedLocation, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakDelete::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk =
-        bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakDisable::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk =
-        bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 {
     if (m_bBrkPtDisabledOk)
     {
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", m_nBrkPtId));
         const CMICmnMIValueResult miValueResult("number", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueConst miValueConst2("n");
         const CMICmnMIValueResult miValueResult2("enabled", miValueConst2);
-        bool bOk = miValueTuple.Add(miValueResult2);
+        miValueTuple.Add(miValueResult2);
         const CMICmnMIValueResult miValueResult3("bkpt", miValueTuple);
         const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, miValueResult3);
-        bOk = bOk && CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
+        bool bOk = CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
 
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
         m_miResultRecord = miRecordResult;
         return bOk;
     }
 
     const CMIUtilString strBrkPtId(CMIUtilString::Format("%d", m_nBrkPtId));
     const CMICmnMIValueConst miValueConst(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_BRKPT_INVALID), strBrkPtId.c_str()));

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakEnable::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk =
-        bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedBrkPt, true, true, CMICmdArgValListBase::eArgValType_Number)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 {
     if (m_bBrkPtEnabledOk)
     {
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", m_nBrkPtId));
         const CMICmnMIValueResult miValueResult("number", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueConst miValueConst2("y");
         const CMICmnMIValueResult miValueResult2("enabled", miValueConst2);
-        bool bOk = miValueTuple.Add(miValueResult2);
+        miValueTuple.Add(miValueResult2);
         const CMICmnMIValueResult miValueResult3("bkpt", miValueTuple);
         const CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_BreakPointModified, miValueResult3);
-        bOk = bOk && CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
+        bool bOk = CMICmnStreamStdout::TextToStdout(miOutOfBandRecord.GetString());
 
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done);
         m_miResultRecord = miRecordResult;
         return bOk;
     }
 
     const CMIUtilString strBrkPtId(CMIUtilString::Format("%d", m_nBrkPtId));
     const CMICmnMIValueConst miValueConst(CMIUtilString::Format(MIRSRC(IDS_CMD_ERR_BRKPT_INVALID), strBrkPtId.c_str()));

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakAfter::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedNumber, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedCount, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedNumber, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedCount, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdBreakCondition::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedNumber, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedExpr, true, true, true, true)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedExprNoQuotes, true, false,
-                                                     CMICmdArgValListBase::eArgValType_StringQuotedNumber)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedNumber, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedExpr, true, true, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

public:
     bool Acknowledge(void) override;
     bool ParseArgs(void) override;
     // From CMICmnBase
     /* dtor */ ~CMICmdCmdDataListRegisterValues(void) override;
 
     // Methods:
   private:
     lldb::SBValue GetRegister(const MIuint vRegisterIndex) const;
-    bool AddToOutput(const MIuint vnIndex, const lldb::SBValue &vrValue, CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veVarFormat);
+    void AddToOutput(const MIuint vnIndex, const lldb::SBValue &vrValue, CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veVarFormat);
 
     // Attributes:
   private:
     const CMIUtilString m_constStrArgThread; // Not specified in MI spec but Eclipse gives this option
     const CMIUtilString m_constStrArgSkip;   // Not handled by *this command
     const CMIUtilString m_constStrArgFormat;
     const CMIUtilString m_constStrArgRegNo;
     CMICmnMIValueList m_miValueList;

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataEvaluateExpression::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpr, true, true, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpr, true, true, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataDisassemble::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionShort(m_constStrArgAddrStart, true, true, CMICmdArgValListBase::eArgValType_StringQuotedNumber, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionShort(m_constStrArgAddrEnd, true, true, CMICmdArgValListBase::eArgValType_StringQuotedNumber, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValConsume(m_constStrArgConsume, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgMode, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValConsume(m_constStrArgConsume, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgMode, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataReadMemoryBytes::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk =
-        bOk &&
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgByteOffset, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgAddrExpr, true, true, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumBytes, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgAddrExpr, true, true, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumBytes, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataListRegisterNames::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
-        *(new CMICmdArgValOptionLong(m_constStrArgThreadGroup, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgRegNo, false, false, CMICmdArgValListBase::eArgValType_Number)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThreadGroup, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgRegNo, false, false, CMICmdArgValListBase::eArgValType_Number)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
else
             lldb::SBValue value = registers.GetValueAtIndex(i);
             const MIuint nRegChildren = value.GetNumChildren();
             for (MIuint j = 0; j < nRegChildren; j++)
             {
                 lldb::SBValue regValue = value.GetChildAtIndex(j);
                 if (regValue.IsValid())
                 {
                     const CMICmnMIValueConst miValueConst(CMICmnLLDBUtilSBValue(regValue).GetName());
-                    const bool bOk = m_miValueList.Add(miValueConst);
-                    if (!bOk)
-                        return MIstatus::failure;
+                    m_miValueList.Add(miValueConst);
                 }
             }
         }
     }
 
     return MIstatus::success;
 }
 

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataListRegisterValues::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgSkip, false, false)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFormat, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgRegNo, false, true, CMICmdArgValListBase::eArgValType_Number)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgSkip, false, false)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFormat, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgRegNo, false, true, CMICmdArgValListBase::eArgValType_Number)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
if (!rVecRegNo.empty())
         CMICmdArgValListBase::VecArgObjPtr_t::const_iterator it = rVecRegNo.begin();
         while (it != rVecRegNo.end())
         {
             const CMICmdArgValNumber *pRegNo = static_cast<CMICmdArgValNumber *>(*it);
             const MIuint nRegIndex = pRegNo->GetValue();
             lldb::SBValue regValue = GetRegister(nRegIndex);
             if (regValue.IsValid())
             {
-                const bool bOk = AddToOutput(nRegIndex, regValue, eFormat);
-                if (!bOk)
-                    return MIstatus::failure;
+                AddToOutput(nRegIndex, regValue, eFormat);
             }
 
             // Next
             ++it;
         }
     }
     else
     {
         // No register numbers are provided. Output all registers.
         lldb::SBThread thread = sbProcess.GetSelectedThread();
         lldb::SBFrame frame = thread.GetSelectedFrame();
         lldb::SBValueList registers = frame.GetRegisters();
         const MIuint nRegisters = registers.GetSize();
         MIuint nRegIndex = 0;
         for (MIuint i = 0; i < nRegisters; i++)
         {
             lldb::SBValue value = registers.GetValueAtIndex(i);
             const MIuint nRegChildren = value.GetNumChildren();
             for (MIuint j = 0; j < nRegChildren; j++)
             {
                 lldb::SBValue regValue = value.GetChildAtIndex(j);
                 if (regValue.IsValid())
                 {
-                    const bool bOk = AddToOutput(nRegIndex, regValue, eFormat);
-                    if (!bOk)
-                        return MIstatus::failure;
+                    AddToOutput(nRegIndex, regValue, eFormat);
                 }
 
                 // Next
                 ++nRegIndex;
             }
         }
     }
 

 
 //++ ------------------------------------------------------------------------------------
 // Details: Adds the register value to the output list.
 // Type:    Method.
 // Args:    Value of the register, its index and output format.
 // Return:  None
 // Throws:  None.
 //--
-bool
+void
 CMICmdCmdDataListRegisterValues::AddToOutput(const MIuint vnIndex, const lldb::SBValue &vrValue,
       CMICmnLLDBDebugSessionInfoVarObj::varFormat_e veVarFormat)
 {
     const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%u", vnIndex));
     const CMICmnMIValueResult miValueResult("number", miValueConst);
     CMICmnMIValueTuple miValueTuple(miValueResult);
     const CMIUtilString strRegValue(CMICmnLLDBDebugSessionInfoVarObj::GetValueStringFormatted(vrValue, veVarFormat));
     const CMICmnMIValueConst miValueConst2(strRegValue);
     const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-    bool bOk = miValueTuple.Add(miValueResult2);
-    return bOk && m_miValueList.Add(miValueTuple);
+    miValueTuple.Add(miValueResult2);
+    m_miValueList.Add(miValueTuple);
 }
 
 //---------------------------------------------------------------------------------------
 //---------------------------------------------------------------------------------------
 //---------------------------------------------------------------------------------------
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdDataListRegisterChanged constructor.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataWriteMemoryBytes::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgAddr, true, true, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgContents, true, true, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgCount, false, true, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgAddr, true, true, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgContents, true, true, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgCount, false, true, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataWriteMemory::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgOffset, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgAddr, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgD, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgContents, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgAddr, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgD, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgContents, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdDataInfoLine::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgLocation, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgLocation, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
else if (m_lldbResult.GetOutputSize() > 0)
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                 ^^^^^^^^^^^^^^^^^^ -- end address
             const size_t nEndAddressEndPos = rLine.find(')');
             const size_t nEndAddressLen = nEndAddressEndPos - nStartAddressEndPos - 1;
             const CMIUtilString strEndAddress(rLine.substr(nStartAddressEndPos + 1, nEndAddressLen).c_str());
             const CMICmnMIValueConst miValueConst2(strEndAddress);
             const CMICmnMIValueResult miValueResult2("end", miValueConst2);
-            bool bOk = miRecordResult.Add(miValueResult2);
-            if (!bOk)
-                return MIstatus::failure;
+            miRecordResult.Add(miValueResult2);
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                                       ^^^^^^^^^^^^^ -- file
             //                                                                     ^ -- line
             //                                                                        ^ -- column (optional)
             const size_t nFileStartPos = rLine.find_first_not_of(' ', nEndAddressEndPos + 2);
             const size_t nFileOrLineEndPos = rLine.rfind(':');
             const size_t nFileOrLineStartPos = rLine.rfind(':', nFileOrLineEndPos - 1);
             const size_t nFileEndPos = nFileStartPos < nFileOrLineStartPos ? nFileOrLineStartPos : nFileOrLineEndPos;
             const size_t nFileLen = nFileEndPos - nFileStartPos;
             const CMIUtilString strFile(rLine.substr(nFileStartPos, nFileLen).c_str());
             const CMICmnMIValueConst miValueConst3(strFile);
             const CMICmnMIValueResult miValueResult3("file", miValueConst3);
-            bOk = miRecordResult.Add(miValueResult3);
-            if (!bOk)
-                return MIstatus::failure;
+            miRecordResult.Add(miValueResult3);
 
             // LineEntry: \[0x0000000100000f37-0x0000000100000f45\): /path/to/file:3[:1]
             //                                                                     ^ -- line
             const size_t nLineStartPos = nFileEndPos + 1;
             const size_t nLineEndPos = rLine.find(':', nLineStartPos);
             const size_t nLineLen = nLineEndPos != std::string::npos ? nLineEndPos - nLineStartPos
                                                                      : std::string::npos;
             const CMIUtilString strLine(rLine.substr(nLineStartPos, nLineLen).c_str());
             const CMICmnMIValueConst miValueConst4(strLine);
             const CMICmnMIValueResult miValueResult4("line", miValueConst4);
-            bOk = miRecordResult.Add(miValueResult4);
-            if (!bOk)
-                return MIstatus::failure;
+            miRecordResult.Add(miValueResult4);
 
             // MI print "%s^done,start=\"%d\",end=\"%d\"",file=\"%s\",line=\"%d\"
             m_miResultRecord = miRecordResult;
 
             return MIstatus::success;
         }
     }
 

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdEnvironmentCd::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNamePathDir, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNamePathDir, true, true)));
     CMICmdArgContext argCntxt(m_cmdData.strMiCmdOption);
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecNext::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecStep::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecNextInstruction::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecStepInstruction::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNumber, false, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecFinish::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, false, CMICmdArgValListBase::eArgValType_Number, 1)));
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdExecArguments::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValListOfN(m_constStrArgArguments, false, true, CMICmdArgValListBase::eArgValType_StringAnything)));
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdFileExecAndSymbols::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNameFile, true, true)));
-    bOk = bOk &&
+    m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNameFile, true, true)));
     m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedPlatformName, false, true,
                                                    CMICmdArgValListBase::eArgValType_String, 1)));
-    bOk = bOk &&
     m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedRemotePath, false, true,
                                                    CMICmdArgValListBase::eArgValType_StringQuotedNumberPath, 1)));
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 //          Synopsis: -file-exec-and-symbols file
 //          Ref: http://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-File-Commands.html#GDB_002fMI-File-Commands
 // Type:    Overridden.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdGdbInfo::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedPrint, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedPrint, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdGdbSet::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValListOfN(m_constStrArgNamedGdbOption, true, true, CMICmdArgValListBase::eArgValType_StringAnything)));
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command is executed in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdGdbShow::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionLong(m_constStrArgNamedThreadGrp, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValListOfN(m_constStrArgNamedGdbOption, true, true, CMICmdArgValListBase::eArgValType_StringAnything)));
-    return (bOk && ParseValidateCmdOptions());
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command is executed in this function.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdListThreadGroups::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgNamedAvailable, false, true)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionLong(m_constStrArgNamedRecurse, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk =
-        bOk && m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedGroup, false, true, CMICmdArgValListBase::eArgValType_Number)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValThreadGrp(m_constStrArgNamedThreadGroup, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgNamedAvailable, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValListOfN(m_constStrArgNamedGroup, false, true, CMICmdArgValListBase::eArgValType_Number)));
+    m_setCmdArgs.Add(*(new CMICmdArgValThreadGrp(m_constStrArgNamedThreadGroup, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 //          Synopsis: -list-thread-groups [ --available ] [ --recurse 1 ] [ group ... ]
 //          This command does not follow the MI documentation exactly. Has an extra
 //          argument "i1" to handle.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdInterpreterExec::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedInterpreter, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedCommand, true, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedInterpreter, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedCommand, true, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackInfoDepth::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgMaxDepth, false, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgMaxDepth, false, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListFrames::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameLow, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameHigh, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameLow, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameHigh, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListArguments::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameLow, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameHigh, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameLow, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrameHigh, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListLocals::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackListVariables::ParseArgs(void)
 {
-    bool bOk =
     m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
     m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.
 //          MIstatus::failure - Function failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdStackSelectFrame::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrame, true, false)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrame, true, false)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Function succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdSupportInfoMiCmdQuery::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgCmdName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgCmdName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdSymbolListLines::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNameFile, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValFile(m_constStrArgNameFile, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 //          Synopsis: -symbol-list-lines file
 //          Ref: http://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Symbol-Query.html#GDB_002fMI-Symbol-Query
 // Type:    Overridden.
else
             const size_t nLineOrColumnStartPos = rLine.rfind(':');
             const CMIUtilString strLineOrColumn(rLine.substr(nLineOrColumnStartPos + 1).c_str());
             const size_t nPathOrLineStartPos = rLine.rfind(':', nLineOrColumnStartPos - 1);
             const size_t nPathOrLineLen = nLineOrColumnStartPos - nPathOrLineStartPos - 1;
             const CMIUtilString strPathOrLine(rLine.substr(nPathOrLineStartPos + 1, nPathOrLineLen).c_str());
             const CMIUtilString strLine(strPathOrLine.IsNumber() ? strPathOrLine : strLineOrColumn);
             const CMICmnMIValueConst miValueConst2(strLine);
             const CMICmnMIValueResult miValueResult2("line", miValueConst2);
-            bool bOk = miValueTuple.Add(miValueResult2);
+            miValueTuple.Add(miValueResult2);
 
-            bOk = bOk && miValueList.Add(miValueTuple);
-            if (!bOk)
-                return MIstatus::failure;
+            miValueList.Add(miValueTuple);
         }
 
         // MI print "%s^done,lines=[{pc=\"%d\",line=\"%d\"}...]"
         const CMICmnMIValueResult miValueResult("lines", miValueList);
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done, miValueResult);
         m_miResultRecord = miRecordResult;
     }
 

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdTargetSelect::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedType, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedParameters, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedType, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgNamedParameters, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 //          Synopsis: -target-select type parameters ...
 //          Ref: http://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Target-Manipulation.html#GDB_002fMI-Target-Manipulation
 // Type:    Overridden.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdTargetAttach::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPid, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedFile, false, true,
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgPid, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionShort(m_constStrArgNamedFile, false, true,
                                                               CMICmdArgValListBase::eArgValType_String, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgWaitFor, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgWaitFor, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 //          Synopsis: -target-attach file
 //          Ref: http://sourceware.org/gdb/onlinedocs/gdb/GDB_002fMI-Target-Manipulation.html#GDB_002fMI-Target-Manipulation
 // Type:    Overridden.

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdThreadInfo::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedThreadId, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgNamedThreadId, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

public:
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmdCmdVarUpdate(void) override;
 
     // Methods:
   private:
     bool ExamineSBValueForChange(lldb::SBValue &vrwValue, bool &vrwbChanged);
-    bool MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope);
+    void MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope);
 
     // Attribute:
   private:
     const CMIUtilString m_constStrArgPrintValues;
     const CMIUtilString m_constStrArgName;
     bool m_bValueChanged; // True = yes value changed, false = no change
     CMICmnMIValueList m_miValueList;
 };

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

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarCreate::ParseArgs(void)
 {
-    bool bOk =
-        m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgThread, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(
-              *(new CMICmdArgValOptionLong(m_constStrArgThreadGroup, false, false, CMICmdArgValListBase::eArgValType_ThreadGrp, 1)));
-    bOk = bOk &&
-          m_setCmdArgs.Add(*(new CMICmdArgValOptionLong(m_constStrArgFrame, false, true, CMICmdArgValListBase::eArgValType_Number, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFrameAddr, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpression, true, true, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFrameAddr, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpression, true, true, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarUpdate::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
CMICmdCmdVarUpdate::Execute(void)
 
     if (m_bValueChanged)
     {
         varObj.UpdateValue();
         const bool bPrintValue((eVarInfoFormat == CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues) ||
                                (eVarInfoFormat == CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues && rValue.GetNumChildren() == 0));
         const CMIUtilString strValue(bPrintValue ? varObj.GetValueFormatted() : "");
         const CMIUtilString strInScope(rValue.IsInScope() ? "true" : "false");
-        return MIFormResponse(rVarObjName, bPrintValue ? strValue.c_str() : nullptr, strInScope);
+        MIFormResponse(rVarObjName, bPrintValue ? strValue.c_str() : nullptr, strInScope);
     }
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record Result
 //          for the work carried out in the Execute().

 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form the MI response for multiple variables.
 // Type:    Method.
 // Args:    vrStrVarName    - (R)   Session var object's name.
 //          vpValue         - (R)   Text version of the value held in the variable.
 //          vrStrScope      - (R)   In scope "yes" or "no".
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmdCmdVarUpdate::MIFormResponse(const CMIUtilString &vrStrVarName, const char *const vpValue, const CMIUtilString &vrStrScope)
 {
     // MI print "[{name=\"%s\",value=\"%s\",in_scope=\"%s\",type_changed=\"false\",has_more=\"0\"}]"
     const CMICmnMIValueConst miValueConst(vrStrVarName);
     const CMICmnMIValueResult miValueResult("name", miValueConst);
     CMICmnMIValueTuple miValueTuple(miValueResult);
-    bool bOk = true;
     if (vpValue != nullptr)
     {
         const CMICmnMIValueConst miValueConst2(vpValue);
         const CMICmnMIValueResult miValueResult2("value", miValueConst2);
-        bOk = bOk && miValueTuple.Add(miValueResult2);
+        miValueTuple.Add(miValueResult2);
     }
     const CMICmnMIValueConst miValueConst3(vrStrScope);
     const CMICmnMIValueResult miValueResult3("in_scope", miValueConst3);
-    bOk = bOk && miValueTuple.Add(miValueResult3);
+    miValueTuple.Add(miValueResult3);
     const CMICmnMIValueConst miValueConst4("false");
     const CMICmnMIValueResult miValueResult4("type_changed", miValueConst4);
-    bOk = bOk && miValueTuple.Add(miValueResult4);
+    miValueTuple.Add(miValueResult4);
     const CMICmnMIValueConst miValueConst5("0");
     const CMICmnMIValueResult miValueResult5("has_more", miValueConst5);
-    bOk = bOk && miValueTuple.Add(miValueResult5);
-    bOk = bOk && m_miValueList.Add(miValueTuple);
-
-    return bOk;
+    miValueTuple.Add(miValueResult5);
+    m_miValueList.Add(miValueTuple);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Determine if the var object was changed.
 // Type:    Method.
 // Args:    vrVarObj    - (R)   Session var object to examine.
 //          vrwbChanged - (W)   True = The var object was changed,
 //                              False = It was not changed.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarDelete::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: CMICmdCmdVarDelete destructor.
 // Type:    Overrideable.
 // Args:    None.
 // Return:  None.
 // Throws:  None.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarAssign::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpression, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgExpression, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarSetFormat::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFormatSpec, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgFormatSpec, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarListChildren::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrom, false, true)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgTo, false, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValPrintValues(m_constStrArgPrintValues, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgFrom, false, true)));
+    m_setCmdArgs.Add(*(new CMICmdArgValNumber(m_constStrArgTo, false, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
for (MIuint i = nFrom; i < nTo; i++)
         const CMIUtilString strThreadId(CMIUtilString::Format("%u", member.GetThread().GetIndexID()));
 
         // MI print "child={name=\"%s\",exp=\"%s\",numchild=\"%d\",value=\"%s\",type=\"%s\",thread-id=\"%u\",has_more=\"%u\"}"
         const CMICmnMIValueConst miValueConst(name);
         const CMICmnMIValueResult miValueResult("name", miValueConst);
         CMICmnMIValueTuple miValueTuple(miValueResult);
         const CMICmnMIValueConst miValueConst2(strExp);
         const CMICmnMIValueResult miValueResult2("exp", miValueConst2);
-        bool bOk = miValueTuple.Add(miValueResult2);
+        miValueTuple.Add(miValueResult2);
         const CMIUtilString strNumChild(CMIUtilString::Format("%u", nChildren));
         const CMICmnMIValueConst miValueConst3(strNumChild);
         const CMICmnMIValueResult miValueResult3("numchild", miValueConst3);
-        bOk = bOk && miValueTuple.Add(miValueResult3);
+        miValueTuple.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst5(utilValue.GetTypeNameDisplay());
         const CMICmnMIValueResult miValueResult5("type", miValueConst5);
-        bOk = bOk && miValueTuple.Add(miValueResult5);
+        miValueTuple.Add(miValueResult5);
         const CMICmnMIValueConst miValueConst6(strThreadId);
         const CMICmnMIValueResult miValueResult6("thread-id", miValueConst6);
-        bOk = bOk && miValueTuple.Add(miValueResult6);
+        miValueTuple.Add(miValueResult6);
         // nChildren == 0 is used to check for simple values
         if (eVarInfoFormat == CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_AllValues ||
             (eVarInfoFormat == CMICmnLLDBDebugSessionInfo::eVariableInfoFormat_SimpleValues && nChildren == 0))
         {
             // Varobj gets added to CMICmnLLDBDebugSessionInfoVarObj static container of varObjs
             CMICmnLLDBDebugSessionInfoVarObj var(strExp, name, member, rVarObjName);
             const CMIUtilString strValue(
             CMICmnLLDBDebugSessionInfoVarObj::GetValueStringFormatted(member, CMICmnLLDBDebugSessionInfoVarObj::eVarFormat_Natural));
             const CMICmnMIValueConst miValueConst7(strValue);
             const CMICmnMIValueResult miValueResult7("value", miValueConst7);
-            bOk = bOk && miValueTuple.Add(miValueResult7);
+            miValueTuple.Add(miValueResult7);
         }
         const CMICmnMIValueConst miValueConst8("0");
         const CMICmnMIValueResult miValueResult8("has_more", miValueConst8);
-        bOk = bOk && miValueTuple.Add(miValueResult8);
+        miValueTuple.Add(miValueResult8);
         const CMICmnMIValueResult miValueResult9("child", miValueTuple);
-        bOk = bOk && m_miValueList.Add(miValueResult9);
-        if (!bOk)
-            return MIstatus::failure;
+        m_miValueList.Add(miValueResult9);
     }
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command prepares a MI Record Result
 //          for the work carried out in the Execute().
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarListChildren::Acknowledge(void)
 {
     if (m_bValueValid)
     {
         // MI print "%s^done,numchild=\"%u\",children=[%s],has_more=\"%d\""
         const CMIUtilString strNumChild(CMIUtilString::Format("%u", m_nChildren));
         const CMICmnMIValueConst miValueConst(strNumChild);
         CMICmnMIValueResult miValueResult("numchild", miValueConst);
-        bool bOk = MIstatus::success;
         if (m_nChildren != 0)
-            bOk = bOk && miValueResult.Add("children", m_miValueList);
+            miValueResult.Add("children", m_miValueList);
         const CMIUtilString strHasMore(m_bHasMore ? "1" : "0");
         const CMICmnMIValueConst miValueConst2(strHasMore);
-        bOk = bOk && miValueResult.Add("has_more", miValueConst2);
-        if (!bOk)
-            return MIstatus::failure;
+        miValueResult.Add("has_more", miValueConst2);
 
         const CMICmnMIResultRecord miRecordResult(m_cmdData.strMiCmdToken, CMICmnMIResultRecord::eResultClass_Done, miValueResult);
         m_miResultRecord = miRecordResult;
 
         return MIstatus::success;
     }
 
     // MI print "%s^error,msg=\"variable invalid\""

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarEvaluateExpression::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(
+    m_setCmdArgs.Add(
         *(new CMICmdArgValOptionShort(m_constStrArgFormatSpec, false, false, CMICmdArgValListBase::eArgValType_String, 1)));
-    bOk = bOk && m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarInfoPathExpression::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
 bool
 CMICmdCmdVarShowAttributes::ParseArgs(void)
 {
-    bool bOk = m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
-    return (bOk && ParseValidateCmdOptions());
+    m_setCmdArgs.Add(*(new CMICmdArgValString(m_constStrArgName, true, true)));
+    return ParseValidateCmdOptions();
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: The invoker requires this function. The command does work in this function.
 //          The command is likely to communicate with the LLDB SBDebugger in here.
 // Type:    Overridden.
 // Args:    None.
 // Return:  MIstatus::success - Functional succeeded.

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

 //          vpNewCmd    - (W) New command instance.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
 // Throws:  None.
 //--
 bool
 CMICmdFactory::CmdCreate(const CMIUtilString &vMiCmd, const SMICmdData &vCmdData, CMICmdBase *&vpNewCmd)
 {
-    bool bOk = MIstatus::success;
-
     vpNewCmd = nullptr;
 
     if (!IsValid(vMiCmd))
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_CMDFACTORY_ERR_INVALID_CMD_NAME), vMiCmd.c_str()));
         return MIstatus::failure;
     }
     if (!HaveAlready(vMiCmd))
     {
         SetErrorDescription(CMIUtilString::Format(MIRSRC(IDS_CMDFACTORY_ERR_CMD_NOT_REGISTERED), vMiCmd.c_str()));
         return MIstatus::failure;
     }
 
     const MapMiCmdToCmdCreatorFn_t::const_iterator it = m_mapMiCmdToCmdCreatorFn.find(vMiCmd);
     const CMIUtilString &rMiCmd((*it).first);
     MIunused(rMiCmd);
     CmdCreatorFnPtr pFn = (*it).second;
     CMICmdBase *pCmd = (*pFn)();
 
     SMICmdData cmdData(vCmdData);
     cmdData.id = pCmd->GetGUID();
-    bOk = pCmd->SetCmdData(cmdData);
-    if (bOk)
-        vpNewCmd = pCmd;
+    pCmd->SetCmdData(cmdData);
 
-    return bOk;
+    return MIstatus::success;
 }

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

public:
     // Description: Invoker's interface for commands to implement.
     //--
     class ICmd
     {
       public:
         virtual bool Acknowledge(void) = 0;
         virtual bool Execute(void) = 0;
         virtual bool ParseArgs(void) = 0;
-        virtual bool SetCmdData(const SMICmdData &vCmdData) = 0;
+        virtual void SetCmdData(const SMICmdData &vCmdData) = 0;
         virtual const SMICmdData &GetCmdData(void) const = 0;
         virtual const CMIUtilString &GetErrorDescription(void) const = 0;
         virtual void CmdFinishedTellInvoker(void) const = 0;
         virtual const CMIUtilString &GetMIResultRecord(void) const = 0;
         virtual const CMIUtilString &GetMIResultRecordExtra(void) const = 0;
         virtual bool HasMIResultRecordExtra(void) const = 0;
 
         /* dtor */ virtual ~ICmd(void){}

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

public:
     bool ResolvePath(const CMIUtilString &vstrUnknown, CMIUtilString &vwrResolvedPath);
     bool MIResponseFormFrameInfo(const lldb::SBThread &vrThread, const MIuint vnLevel,
                                  const FrameInfoFormat_e veFrameInfoFormat, CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
                                   const ThreadInfoFormat_e veThreadInfoFormat, CMICmnMIValueTuple &vwrMIValueTuple);
     bool MIResponseFormVariableInfo(const lldb::SBFrame &vrFrame, const MIuint vMaskVarTypes,
                                     const VariableInfoFormat_e veVarInfoFormat, CMICmnMIValueList &vwrMiValueList,
                                     const MIuint vnMaxDepth = 10, const bool vbMarkArgs = false);
-    bool MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
+    void MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool MIResponseFormBrkPtInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple);
     bool GetBrkPtInfo(const lldb::SBBreakpoint &vBrkPt, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfo(const MIuint vnBrkPtId, const SBrkPtInfo &vrBrkPtInfo);
     bool RecordBrkPtInfoGet(const MIuint vnBrkPtId, SBrkPtInfo &vrwBrkPtInfo) const;
     bool RecordBrkPtInfoDelete(const MIuint vnBrkPtId);
     CMIUtilThreadMutex& GetSessionMutex() { return m_sessionMutex;}
     lldb::SBDebugger &GetDebugger() const;
     lldb::SBListener &GetListener() const;

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

CMICmnLLDBDebugSessionInfo::MIResponseFormThreadInfo(const SMICmdData &vCmdData, const lldb::SBThread &vrThread,
     const lldb::StopReason eReason = rThread.GetStopReason();
     const bool bValidReason = !((eReason == lldb::eStopReasonNone) || (eReason == lldb::eStopReasonInvalid));
     const CMIUtilString strState((bSuspended || bValidReason) ? "stopped" : "running");
 
     // Add "id"
     const CMIUtilString strId(CMIUtilString::Format("%d", rThread.GetIndexID()));
     const CMICmnMIValueConst miValueConst1(strId);
     const CMICmnMIValueResult miValueResult1("id", miValueConst1);
-    if (!vwrMIValueTuple.Add(miValueResult1))
-        return MIstatus::failure;
+    vwrMIValueTuple.Add(miValueResult1);
 
     // Add "target-id"
     const char *pThreadName = rThread.GetName();
     const MIuint len = (pThreadName != nullptr) ? CMIUtilString(pThreadName).length() : 0;
     const bool bHaveName = ((pThreadName != nullptr) && (len > 0) && (len < 32) &&
                             CMIUtilString::IsAllValidAlphaAndNumeric(pThreadName)); // 32 is arbitrary number
     const char *pThrdFmt = bHaveName ? "%s" : "Thread %d";
     CMIUtilString strThread;
     if (bHaveName)
         strThread = CMIUtilString::Format(pThrdFmt, pThreadName);
     else
         strThread = CMIUtilString::Format(pThrdFmt, rThread.GetIndexID());
     const CMICmnMIValueConst miValueConst2(strThread);
     const CMICmnMIValueResult miValueResult2("target-id", miValueConst2);
-    if (!vwrMIValueTuple.Add(miValueResult2))
-        return MIstatus::failure;
+    vwrMIValueTuple.Add(miValueResult2);
 
     // Add "frame"
     if (veThreadInfoFormat != eThreadInfoFormat_NoFrames)
     {
         CMIUtilString strFrames;
         if (!GetThreadFrames(vCmdData, rThread.GetIndexID(), eFrameInfoFormat_AllArgumentsInSimpleForm, strFrames))
             return MIstatus::failure;
 
         const CMICmnMIValueConst miValueConst3(strFrames, true);
-        if (!vwrMIValueTuple.Add(miValueConst3, false))
-            return MIstatus::failure;
+        vwrMIValueTuple.Add(miValueConst3, false);
     }
 
     // Add "state"
     const CMICmnMIValueConst miValueConst4(strState);
     const CMICmnMIValueResult miValueResult4("state", miValueConst4);
-    if (!vwrMIValueTuple.Add(miValueResult4))
-        return MIstatus::failure;
+    vwrMIValueTuple.Add(miValueResult4);
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form MI partial response by appending more MI value type objects to the
 //          tuple type object past in.
 // Type:    Method.

 bool
 CMICmnLLDBDebugSessionInfo::MIResponseForVariableInfoInternal(const VariableInfoFormat_e veVarInfoFormat,
                                                               CMICmnMIValueList &vwrMiValueList,
                                                               const lldb::SBValueList &vwrSBValueList,
                                                               const MIuint vnMaxDepth,
                                                               const bool vbIsArgs,
                                                               const bool vbMarkArgs)
 {
-    bool bOk = MIstatus::success;
     const MIuint nArgs = vwrSBValueList.GetSize();
-    for (MIuint i = 0; bOk && (i < nArgs); i++)
+    for (MIuint i = 0; i < nArgs; i++)
     {
         CMICmnMIValueTuple miValueTuple;
         lldb::SBValue value = vwrSBValueList.GetValueAtIndex(i);
         const CMICmnMIValueConst miValueConst(value.GetName());
         const CMICmnMIValueResult miValueResultName("name", miValueConst);
         if (vbMarkArgs && vbIsArgs)
         {
             const CMICmnMIValueConst miValueConstArg("1");
for (MIuint i = 0; i < nArgs; i++)
             vwrMiValueList.Add(miValueTuple);
         }
         else
         {
             // If we are printing name only then no need to put it in the tuple.
             vwrMiValueList.Add(miValueResultName);
         }
     }
-    return bOk;
+    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Extract the value's name and value or recurse into child value object.
 // Type:    Method.
 // Args:    vrValue         - (R)  LLDB value object.
 //          vbInSimpleForm  - (R)  True = Get variable info in simple form (i.e. don't expand aggregates).
 //                          -      False = Get variable info (and expand aggregates if any).
CMICmnLLDBDebugSessionInfo::MIResponseFormFrameInfo(const lldb::SBThread &vrThread, const MIuint vnLevel,
     MIuint nLine = 0;
     if (!GetFrameInfo(frame, pc, fnName, fileName, path, nLine))
         return MIstatus::failure;
 
     // MI print "{level=\"0\",addr=\"0x%016" PRIx64 "\",func=\"%s\",file=\"%s\",fullname=\"%s\",line=\"%d\"}"
     const CMIUtilString strLevel(CMIUtilString::Format("%d", vnLevel));
     const CMICmnMIValueConst miValueConst(strLevel);
     const CMICmnMIValueResult miValueResult("level", miValueConst);
-    if (!vwrMiValueTuple.Add(miValueResult))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult);
     const CMIUtilString strAddr(CMIUtilString::Format("0x%016" PRIx64, pc));
     const CMICmnMIValueConst miValueConst2(strAddr);
     const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
-    if (!vwrMiValueTuple.Add(miValueResult2))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult2);
     const CMICmnMIValueConst miValueConst3(fnName);
     const CMICmnMIValueResult miValueResult3("func", miValueConst3);
-    if (!vwrMiValueTuple.Add(miValueResult3))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult3);
     if (veFrameInfoFormat != eFrameInfoFormat_NoArguments)
     {
         CMICmnMIValueList miValueList(true);
         const MIuint maskVarTypes = eVariableType_Arguments;
         if (veFrameInfoFormat == eFrameInfoFormat_AllArgumentsInSimpleForm)
         {
             if (!MIResponseFormVariableInfo(frame, maskVarTypes, eVariableInfoFormat_AllValues, miValueList, 0))
                 return MIstatus::failure;
         }
         else
             if (!MIResponseFormVariableInfo(frame, maskVarTypes, eVariableInfoFormat_AllValues, miValueList))
                 return MIstatus::failure;
 
         const CMICmnMIValueResult miValueResult4("args", miValueList);
-        if (!vwrMiValueTuple.Add(miValueResult4))
-            return MIstatus::failure;
+        vwrMiValueTuple.Add(miValueResult4);
     }
     const CMICmnMIValueConst miValueConst5(fileName);
     const CMICmnMIValueResult miValueResult5("file", miValueConst5);
-    if (!vwrMiValueTuple.Add(miValueResult5))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult5);
     const CMICmnMIValueConst miValueConst6(path);
     const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
-    if (!vwrMiValueTuple.Add(miValueResult6))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult6);
     const CMIUtilString strLine(CMIUtilString::Format("%d", nLine));
     const CMICmnMIValueConst miValueConst7(strLine);
     const CMICmnMIValueResult miValueResult7("line", miValueConst7);
-    if (!vwrMiValueTuple.Add(miValueResult7))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult7);
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the frame information from LLDB frame object.
 // Type:    Method.
 // Args:    vrFrame         - (R) LLDB thread object.

 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form MI partial response by appending more MI value type objects to the
 //          tuple type object past in.
 // Type:    Method.
 // Args:    vrBrkPtInfo     - (R) Break point information object.
 //          vwrMIValueTuple - (W) MI value tuple object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtFrameInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple)
 {
     const CMIUtilString strAddr(CMIUtilString::Format("0x%016" PRIx64, vrBrkPtInfo.m_pc));
     const CMICmnMIValueConst miValueConst2(strAddr);
     const CMICmnMIValueResult miValueResult2("addr", miValueConst2);
-    if (!vwrMiValueTuple.Add(miValueResult2))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult2);
     const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_fnName);
     const CMICmnMIValueResult miValueResult3("func", miValueConst3);
-    if (!vwrMiValueTuple.Add(miValueResult3))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult3);
     const CMICmnMIValueConst miValueConst5(vrBrkPtInfo.m_fileName);
     const CMICmnMIValueResult miValueResult5("file", miValueConst5);
-    if (!vwrMiValueTuple.Add(miValueResult5))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult5);
     const CMIUtilString strN5 = CMIUtilString::Format("%s/%s", vrBrkPtInfo.m_path.c_str(), vrBrkPtInfo.m_fileName.c_str());
     const CMICmnMIValueConst miValueConst6(strN5);
     const CMICmnMIValueResult miValueResult6("fullname", miValueConst6);
-    if (!vwrMiValueTuple.Add(miValueResult6))
-        return MIstatus::failure;
+    vwrMiValueTuple.Add(miValueResult6);
     const CMIUtilString strLine(CMIUtilString::Format("%d", vrBrkPtInfo.m_nLine));
     const CMICmnMIValueConst miValueConst7(strLine);
     const CMICmnMIValueResult miValueResult7("line", miValueConst7);
-    if (!vwrMiValueTuple.Add(miValueResult7))
-        return MIstatus::failure;
-
-    return MIstatus::success;
+    vwrMiValueTuple.Add(miValueResult7);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form MI partial response by appending more MI value type objects to the
 //          tuple type object past in.
 // Type:    Method.
 // Args:    vrBrkPtInfo     - (R) Break point information object.
 //          vwrMIValueTuple - (W) MI value tuple object.
CMICmnLLDBDebugSessionInfo::MIResponseFormBrkPtInfo(const SBrkPtInfo &vrBrkPtInfo, CMICmnMIValueTuple &vwrMiValueTuple)
 
     // "number="
     const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_id));
     const CMICmnMIValueResult miValueResult("number", miValueConst);
     CMICmnMIValueTuple miValueTuple(miValueResult);
     // "type="
     const CMICmnMIValueConst miValueConst2(vrBrkPtInfo.m_strType);
     const CMICmnMIValueResult miValueResult2("type", miValueConst2);
-    bool bOk = miValueTuple.Add(miValueResult2);
+    miValueTuple.Add(miValueResult2);
     // "disp="
     const CMICmnMIValueConst miValueConst3(vrBrkPtInfo.m_bDisp ? "del" : "keep");
     const CMICmnMIValueResult miValueResult3("disp", miValueConst3);
-    bOk = bOk && miValueTuple.Add(miValueResult3);
+    miValueTuple.Add(miValueResult3);
     // "enabled="
     const CMICmnMIValueConst miValueConst4(vrBrkPtInfo.m_bEnabled ? "y" : "n");
     const CMICmnMIValueResult miValueResult4("enabled", miValueConst4);
-    bOk = bOk && miValueTuple.Add(miValueResult4);
+    miValueTuple.Add(miValueResult4);
     // "addr="
     // "func="
     // "file="
     // "fullname="
     // "line="
-    bOk = bOk && MIResponseFormBrkPtFrameInfo(vrBrkPtInfo, miValueTuple);
+    MIResponseFormBrkPtFrameInfo(vrBrkPtInfo, miValueTuple);
     // "pending="
     if (vrBrkPtInfo.m_bPending)
     {
         const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOrigLoc);
         const CMICmnMIValueList miValueList(miValueConst);
         const CMICmnMIValueResult miValueResult("pending", miValueList);
-        bOk = bOk && miValueTuple.Add(miValueResult);
+        miValueTuple.Add(miValueResult);
     }
     if (vrBrkPtInfo.m_bHaveArgOptionThreadGrp)
     {
         const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strOptThrdGrp);
         const CMICmnMIValueList miValueList(miValueConst);
         const CMICmnMIValueResult miValueResult("thread-groups", miValueList);
-        bOk = bOk && miValueTuple.Add(miValueResult);
+        miValueTuple.Add(miValueResult);
     }
     // "times="
     const CMICmnMIValueConst miValueConstB(CMIUtilString::Format("%d", vrBrkPtInfo.m_nTimes));
     const CMICmnMIValueResult miValueResultB("times", miValueConstB);
-    bOk = bOk && miValueTuple.Add(miValueResultB);
+    miValueTuple.Add(miValueResultB);
     // "thread="
     if (vrBrkPtInfo.m_bBrkPtThreadId)
     {
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_nBrkPtThreadId));
         const CMICmnMIValueResult miValueResult("thread", miValueConst);
-        bOk = bOk && miValueTuple.Add(miValueResult);
+        miValueTuple.Add(miValueResult);
     }
     // "cond="
     if (vrBrkPtInfo.m_bCondition)
     {
         const CMICmnMIValueConst miValueConst(vrBrkPtInfo.m_strCondition);
         const CMICmnMIValueResult miValueResult("cond", miValueConst);
-        bOk = bOk && miValueTuple.Add(miValueResult);
+        miValueTuple.Add(miValueResult);
     }
     // "ignore="
     if (vrBrkPtInfo.m_nIgnore != 0)
     {
         const CMICmnMIValueConst miValueConst(CMIUtilString::Format("%d", vrBrkPtInfo.m_nIgnore));
         const CMICmnMIValueResult miValueResult("ignore", miValueConst);
-        bOk = bOk && miValueTuple.Add(miValueResult);
+        miValueTuple.Add(miValueResult);
     }
     // "original-location="
     const CMICmnMIValueConst miValueConstC(vrBrkPtInfo.m_strOrigLoc);
     const CMICmnMIValueResult miValueResultC("original-location", miValueConstC);
-    bOk = bOk && miValueTuple.Add(miValueResultC);
+    miValueTuple.Add(miValueResultC);
 
     vwrMiValueTuple = miValueTuple;
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve breakpoint information and write into the given breakpoint information

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

CMICmnLLDBDebuggerHandleEvents::HandleEventSBThreadSuspended(const lldb::SBEvent &vEvent)
     const MIuint64 nId = thread.GetStopReasonDataAtIndex(0);
     const CMIUtilString strThread(CMIUtilString::Format("%d", thread.GetThreadID()));
     const CMICmnMIValueConst miValueConst(strThread);
     const CMICmnMIValueResult miValueResult("thread", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Thread, miValueResult);
     const CMIUtilString strSignal(CMIUtilString::Format("%lld", nId));
     const CMICmnMIValueConst miValueConst2(strSignal);
     const CMICmnMIValueResult miValueResult2("signal", miValueConst2);
-    bool bOk = miOutOfBandRecord.Add(miValueResult2);
-    bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
-
-    return bOk;
+    miOutOfBandRecord.Add(miValueResult2);
+    return MiOutOfBandRecordToStdout(miOutOfBandRecord);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Handle a LLDB SBThread event.
 // Type:    Method.
 // Args:    vEvent  - (R) An LLDB broadcast event.
 // Return:  MIstatus::success - Functionality succeeded.
 //          MIstatus::failure - Functionality failed.
CMICmnLLDBDebuggerHandleEvents::MiHelpGetModuleInfo(const lldb::SBModule &vModule, const bool vbWithExtraFields,
 
     // 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);
     const CMICmnMIValueResult miValueResult("id", miValueConst);
-    bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult);
+    vwrMiOutOfBandRecord.Add(miValueResult);
     // Build "target-name" field
     const CMICmnMIValueConst miValueConst2(strTargetPath);
     const CMICmnMIValueResult miValueResult2("target-name", miValueConst2);
-    bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult2);
+    vwrMiOutOfBandRecord.Add(miValueResult2);
     // Build "host-name" field
     vModule.GetPlatformFileSpec().GetPath(apPath.get(), PATH_MAX);
     const CMIUtilString strHostPath(apPath.get());
     const CMICmnMIValueConst miValueConst3(strHostPath);
     const CMICmnMIValueResult miValueResult3("host-name", miValueConst3);
-    bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult3);
+    vwrMiOutOfBandRecord.Add(miValueResult3);
 
     // 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);
-        bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult4);
+        vwrMiOutOfBandRecord.Add(miValueResult4);
         // Build "symbols-path" field
         if (bSymbolsLoaded)
         {
             const CMICmnMIValueConst miValueConst5(strSymbolsPath);
             const CMICmnMIValueResult miValueResult5("symbols-path", miValueConst5);
-            bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult5);
+            vwrMiOutOfBandRecord.Add(miValueResult5);
         }
         // Build "loaded_addr" field
         const lldb::SBAddress sbAddress(vModule.GetObjectFileHeaderAddress());
         CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
         const lldb::addr_t nLoadAddress(sbAddress.GetLoadAddress(rSessionInfo.GetTarget()));
         const CMIUtilString strLoadedAddr(nLoadAddress != LLDB_INVALID_ADDRESS ?
                                           CMIUtilString::Format("0x%016" PRIx64, nLoadAddress) : "-");
         const CMICmnMIValueConst miValueConst6(strLoadedAddr);
         const CMICmnMIValueResult miValueResult6("loaded_addr", miValueConst6);
-        bOk = bOk && vwrMiOutOfBandRecord.Add(miValueResult6);
+        vwrMiOutOfBandRecord.Add(miValueResult6);
     }
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Handle a LLDB SBCommandInterpreter event.
 // Type:    Method.
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopSignal(const lldb::SBEvent &vrEvent)
     if (nStopReason == m_SIGINT || (nStopReason == m_SIGSTOP && bInterrupted))
     {
         // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",frame={%s},thread-id=\"%d\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("signal-received");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("SIGINT");
         const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2);
-        bOk = miOutOfBandRecord.Add(miValueResult2);
+        miOutOfBandRecord.Add(miValueResult2);
         const CMICmnMIValueConst miValueConst3("Interrupt");
         const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+        miOutOfBandRecord.Add(miValueResult3);
         CMICmnMIValueTuple miValueTuple;
         bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple);
         const CMICmnMIValueResult miValueResult4("frame", miValueTuple);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+        miOutOfBandRecord.Add(miValueResult4);
         const CMIUtilString strThreadId(CMIUtilString::Format("%" PRIu32, sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst5(strThreadId);
         const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult5);
+        miOutOfBandRecord.Add(miValueResult5);
         const CMICmnMIValueConst miValueConst6("all");
         const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult6);
+        miOutOfBandRecord.Add(miValueResult6);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
     else if (nStopReason == m_SIGSTOP)
     {
         // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",frame={%s},thread-id=\"%d\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("signal-received");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("SIGSTOP");
         const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2);
-        bOk = miOutOfBandRecord.Add(miValueResult2);
+        miOutOfBandRecord.Add(miValueResult2);
         const CMICmnMIValueConst miValueConst3("Stop");
         const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+        miOutOfBandRecord.Add(miValueResult3);
         CMICmnMIValueTuple miValueTuple;
         bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple);
         const CMICmnMIValueResult miValueResult4("frame", miValueTuple);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+        miOutOfBandRecord.Add(miValueResult4);
         const CMIUtilString strThreadId(CMIUtilString::Format("%" PRIu32, sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst5(strThreadId);
         const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult5);
+        miOutOfBandRecord.Add(miValueResult5);
         const CMICmnMIValueConst miValueConst6("all");
         const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult6);
+        miOutOfBandRecord.Add(miValueResult6);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
     else if (nStopReason == m_SIGSEGV)
     {
         // MI print "*stopped,reason=\"signal-received\",signal-name=\"SIGSEGV\",signal-meaning=\"Segmentation fault\",thread-id=\"%d\",frame={%s}"
         const CMICmnMIValueConst miValueConst("signal-received");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("SIGSEGV");
         const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2);
-        bOk = miOutOfBandRecord.Add(miValueResult2);
+        miOutOfBandRecord.Add(miValueResult2);
         const CMICmnMIValueConst miValueConst3("Segmentation fault");
         const CMICmnMIValueResult miValueResult3("signal-meaning", miValueConst3);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+        miOutOfBandRecord.Add(miValueResult3);
         CMICmnMIValueTuple miValueTuple;
         bOk = bOk && MiHelpGetCurrentThreadFrame(miValueTuple);
         const CMICmnMIValueResult miValueResult4("frame", miValueTuple);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+        miOutOfBandRecord.Add(miValueResult4);
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst5(strThreadId);
         const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult5);
+        miOutOfBandRecord.Add(miValueResult5);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
         // Note no "(gdb)" output here
     }
     else if (nStopReason == m_SIGTRAP)
     {
         lldb::SBThread thread = sbProcess.GetSelectedThread();
         const MIuint nFrames = thread.GetNumFrames();
         if (nFrames > 0)
else
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         lldb::SBUnixSignals sbUnixSignals = sbProcess.GetUnixSignals();
         const char *pSignal = sbUnixSignals.GetSignalAsCString(nStopReason);
         if (pSignal)
         {
             const CMICmnMIValueConst miValueConst2(pSignal);
             const CMICmnMIValueResult miValueResult2("signal-name", miValueConst2);
-            bOk = miOutOfBandRecord.Add(miValueResult2);
+            miOutOfBandRecord.Add(miValueResult2);
         }
         else
         {
             const CMIUtilString strSignal(CMIUtilString::Format("%" PRIu64, nStopReason));
             const CMICmnMIValueConst miValueConst2(strSignal);
             const CMICmnMIValueResult miValueResult2("signal", miValueConst2);
-            bOk = miOutOfBandRecord.Add(miValueResult2);
+            miOutOfBandRecord.Add(miValueResult2);
         }
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbProcess.GetSelectedThread().GetIndexID()));
         const CMICmnMIValueConst miValueConst3(strThreadId);
         const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+        miOutOfBandRecord.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst4("all");
         const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+        miOutOfBandRecord.Add(miValueResult4);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Asynchronous event handler for LLDB Process stop exception.
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopException(void)
 
     // MI print "*stopped,reason=\"exception-received\",exception=\"%s\",thread-id=\"%d\",stopped-threads=\"all\""
     const CMICmnMIValueConst miValueConst("exception-received");
     const CMICmnMIValueResult miValueResult("reason", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
     const CMIUtilString strReason(apStopDescription.get());
     const CMICmnMIValueConst miValueConst2(strReason);
     const CMICmnMIValueResult miValueResult2("exception", miValueConst2);
-    bool bOk = miOutOfBandRecord.Add(miValueResult2);
+    miOutOfBandRecord.Add(miValueResult2);
     const CMIUtilString strThreadId(CMIUtilString::Format("%d", sbThread.GetIndexID()));
     const CMICmnMIValueConst miValueConst3(strThreadId);
     const CMICmnMIValueResult miValueResult3("thread-id", miValueConst3);
-    bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+    miOutOfBandRecord.Add(miValueResult3);
     const CMICmnMIValueConst miValueConst4("all");
     const CMICmnMIValueResult miValueResult4("stopped-threads", miValueConst4);
-    bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
-    bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
+    miOutOfBandRecord.Add(miValueResult4);
+    bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
     bOk = bOk && CMICmnStreamStdout::WritePrompt();
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Form partial MI response in a MI value tuple object.
 // Type:    Method.
CMICmnLLDBDebuggerHandleEvents::MiStoppedAtBreakPoint(const MIuint64 vBrkPtId, const lldb::SBBreakpoint &vBrkPt)
     if (nFrame == 0)
     {
         // MI print "*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"%d\",frame={},thread-id=\"%d\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("breakpoint-hit");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("del");
         const CMICmnMIValueResult miValueResult2("disp", miValueConst2);
-        bOk = miOutOfBandRecord.Add(miValueResult2);
+        miOutOfBandRecord.Add(miValueResult2);
         const CMIUtilString strBkp(CMIUtilString::Format("%d", vBrkPtId));
         const CMICmnMIValueConst miValueConst3(strBkp);
         CMICmnMIValueResult miValueResult3("bkptno", miValueConst3);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult3);
+        miOutOfBandRecord.Add(miValueResult3);
         const CMICmnMIValueConst miValueConst4("{}");
         const CMICmnMIValueResult miValueResult4("frame", miValueConst4);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult4);
+        miOutOfBandRecord.Add(miValueResult4);
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", vBrkPt.GetThreadIndex()));
         const CMICmnMIValueConst miValueConst5(strThreadId);
         const CMICmnMIValueResult miValueResult5("thread-id", miValueConst5);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult5);
+        miOutOfBandRecord.Add(miValueResult5);
         const CMICmnMIValueConst miValueConst6("all");
         const CMICmnMIValueResult miValueResult6("stopped-threads", miValueConst6);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult6);
+        miOutOfBandRecord.Add(miValueResult6);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
         return bOk;
     }
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
 
     // MI print
     // "*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"%d\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\""
     const CMICmnMIValueConst miValueConst("breakpoint-hit");
     const CMICmnMIValueResult miValueResult("reason", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
     const CMICmnMIValueConst miValueConstA("del");
     const CMICmnMIValueResult miValueResultA("disp", miValueConstA);
-    bOk = miOutOfBandRecord.Add(miValueResultA);
+    miOutOfBandRecord.Add(miValueResultA);
     const CMIUtilString strBkp(CMIUtilString::Format("%d", vBrkPtId));
     const CMICmnMIValueConst miValueConstB(strBkp);
     CMICmnMIValueResult miValueResultB("bkptno", miValueConstB);
-    bOk = bOk && miOutOfBandRecord.Add(miValueResultB);
+    miOutOfBandRecord.Add(miValueResultB);
 
     // frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[],file=\"%s\",fullname=\"%s\",line=\"%d\"}
     if (bOk)
     {
         CMICmnMIValueTuple miValueTuple;
         bOk = bOk && rSessionInfo.MIResponseFormFrameInfo(thread, 0, CMICmnLLDBDebugSessionInfo::eFrameInfoFormat_AllArguments, miValueTuple);
         const CMICmnMIValueResult miValueResult8("frame", miValueTuple);
-        bOk = bOk && miOutOfBandRecord.Add(miValueResult8);
+        miOutOfBandRecord.Add(miValueResult8);
     }
 
     // Add to MI thread-id=\"%d\",stopped-threads=\"all\"
     if (bOk)
     {
         const CMIUtilString strThreadId(CMIUtilString::Format("%d", thread.GetIndexID()));
         const CMICmnMIValueConst miValueConst8(strThreadId);
         const CMICmnMIValueResult miValueResult8("thread-id", miValueConst8);
-        bOk = miOutOfBandRecord.Add(miValueResult8);
+        miOutOfBandRecord.Add(miValueResult8);
     }
     if (bOk)
     {
         const CMICmnMIValueConst miValueConst9("all");
         const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9);
-        bOk = miOutOfBandRecord.Add(miValueResult9);
+        miOutOfBandRecord.Add(miValueResult9);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
     }
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStopReasonTrace(void)
     if (nFrame == 0)
     {
         // MI print "*stopped,reason=\"trace\",stopped-threads=\"all\""
         const CMICmnMIValueConst miValueConst("trace");
         const CMICmnMIValueResult miValueResult("reason", miValueConst);
         CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
         const CMICmnMIValueConst miValueConst2("all");
         const CMICmnMIValueResult miValueResult2("stopped-threads", miValueConst2);
-        bOk = miOutOfBandRecord.Add(miValueResult2);
+        miOutOfBandRecord.Add(miValueResult2);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
         bOk = bOk && CMICmnStreamStdout::WritePrompt();
         return bOk;
     }
 
     CMICmnLLDBDebugSessionInfo &rSessionInfo(CMICmnLLDBDebugSessionInfo::Instance());
 
     // MI print
     // "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x%016" PRIx64 "\",func=\"%s\",args=[\"%s\"],file=\"%s\",fullname=\"%s\",line=\"%d\"},thread-id=\"%d\",stopped-threads=\"all\""
 
     // Function args
     CMICmnMIValueTuple miValueTuple;
     if (!rSessionInfo.MIResponseFormFrameInfo(thread, 0, CMICmnLLDBDebugSessionInfo::eFrameInfoFormat_AllArguments, miValueTuple))
         return MIstatus::failure;
 
     const CMICmnMIValueConst miValueConst("end-stepping-range");
     const CMICmnMIValueResult miValueResult("reason", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult);
     const CMICmnMIValueResult miValueResult2("frame", miValueTuple);
-    bOk = miOutOfBandRecord.Add(miValueResult2);
+    miOutOfBandRecord.Add(miValueResult2);
 
     // Add to MI thread-id=\"%d\",stopped-threads=\"all\"
-    if (bOk)
-    {
-        const CMIUtilString strThreadId(CMIUtilString::Format("%d", thread.GetIndexID()));
-        const CMICmnMIValueConst miValueConst8(strThreadId);
-        const CMICmnMIValueResult miValueResult8("thread-id", miValueConst8);
-        bOk = miOutOfBandRecord.Add(miValueResult8);
-    }
-    if (bOk)
-    {
-        const CMICmnMIValueConst miValueConst9("all");
-        const CMICmnMIValueResult miValueResult9("stopped-threads", miValueConst9);
-        bOk = miOutOfBandRecord.Add(miValueResult9);
-        bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
-        bOk = bOk && CMICmnStreamStdout::WritePrompt();
-    }
+    miOutOfBandRecord.Add(miValueResult8);
+
+    miOutOfBandRecord.Add(miValueResult9);
 
     return bOk;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Asynchronous function update selected thread.
 // Type:    Method.
 // Args:    None.

 CMICmnLLDBDebuggerHandleEvents::HandleProcessEventStateExited(void)
 {
     const CMIUtilString strId(CMIUtilString::Format("%ld", 1));
     CMICmnMIValueConst miValueConst(strId);
     CMICmnMIValueResult miValueResult("id", miValueConst);
     CMICmnMIOutOfBandRecord miOutOfBandRecord(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, miValueResult);
     CMICmnMIValueConst miValueConst2("i1");
     CMICmnMIValueResult miValueResult2("group-id", miValueConst2);
-    bool bOk = miOutOfBandRecord.Add(miValueResult2);
-    bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord);
+    miOutOfBandRecord.Add(miValueResult2);
+    bool bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord);
     if (bOk)
     {
         CMICmnMIValueConst miValueConst3("i1");
         CMICmnMIValueResult miValueResult3("id", miValueConst3);
         CMICmnMIOutOfBandRecord miOutOfBandRecord2(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadGroupExited, miValueResult3);
         CMICmnMIValueConst miValueConst2("0");
         CMICmnMIValueResult miValueResult2("exit-code", miValueConst2);
-        bOk = miOutOfBandRecord2.Add(miValueResult2);
+        miOutOfBandRecord2.Add(miValueResult2);
         bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBandRecord2);
     }
     if (bOk)
     {
         CMICmnMIValueConst miValueConst4("exited-normally");
         CMICmnMIValueResult miValueResult4("reason", miValueConst4);
         CMICmnMIOutOfBandRecord miOutOfBandRecord3(CMICmnMIOutOfBandRecord::eOutOfBand_Stopped, miValueResult4);
         bOk = MiOutOfBandRecordToStdout(miOutOfBandRecord3);
for (MIuint i = 0; i < nThread; i++)
 
             // Form MI "=thread-created,id=\"%d\",group-id=\"i1\""
             const CMIUtilString strValue(CMIUtilString::Format("%d", threadIndexID));
             const CMICmnMIValueConst miValueConst(strValue);
             const CMICmnMIValueResult miValueResult("id", miValueConst);
             CMICmnMIOutOfBandRecord miOutOfBand(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadCreated, miValueResult);
             const CMICmnMIValueConst miValueConst2("i1");
             const CMICmnMIValueResult miValueResult2("group-id", miValueConst2);
-            bool bOk = miOutOfBand.Add(miValueResult2);
-            bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBand);
+            miOutOfBand.Add(miValueResult2);
+            bool bOk = MiOutOfBandRecordToStdout(miOutOfBand);
             if (!bOk)
                 return MIstatus::failure;
         }
     }
 
     lldb::SBThread currentThread = sbProcess.GetSelectedThread();
     if (currentThread.IsValid())
     {
while (it != rSessionInfo.m_vecActiveThreadId.end())
         {
             // Form MI "=thread-exited,id=\"%ld\",group-id=\"i1\""
             const CMIUtilString strValue(CMIUtilString::Format("%ld", threadIndexID));
             const CMICmnMIValueConst miValueConst(strValue);
             const CMICmnMIValueResult miValueResult("id", miValueConst);
             CMICmnMIOutOfBandRecord miOutOfBand(CMICmnMIOutOfBandRecord::eOutOfBand_ThreadExited, miValueResult);
             const CMICmnMIValueConst miValueConst2("i1");
             const CMICmnMIValueResult miValueResult2("group-id", miValueConst2);
-            bool bOk = miOutOfBand.Add(miValueResult2);
-            bOk = bOk && MiOutOfBandRecordToStdout(miOutOfBand);
+            miOutOfBand.Add(miValueResult2);
+            bool bOk = MiOutOfBandRecordToStdout(miOutOfBand);
             if (!bOk)
                 return MIstatus::failure;
 
             // Remove current thread from cache and get next
             it = rSessionInfo.m_vecActiveThreadId.erase(it);
         }
         else
             // Next

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

for (MIuint i = 0; i < nChildren; ++i)
             value = m_pComposite;
         }
         const bool bNoQuotes = true;
         const CMICmnMIValueConst miValueConst(value, bNoQuotes);
         if (vbPrintFieldNames)
         {
             const bool bUseSpacing = true;
             const CMICmnMIValueResult miValueResult(utilMember.GetName(), miValueConst, bUseSpacing);
-            const bool bOk = vwrMiValueTuple.Add(miValueResult, bUseSpacing);
-            if (!bOk)
-                return MIstatus::failure;
+            vwrMiValueTuple.Add(miValueResult, bUseSpacing);
         }
         else
         {
             const bool bUseSpacing = false;
-            const bool bOk = vwrMiValueTuple.Add(miValueConst, bUseSpacing);
-            if (!bOk)
-                return MIstatus::failure;
+            vwrMiValueTuple.Add(miValueConst, bUseSpacing);
         }
     }
 
     return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the flag stating whether this value object is a char type or some

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

public:
     // Methods:
   public:
     /* ctor */ CMICmnMIOutOfBandRecord(void);
     /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType);
     /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueConst &vConst);
     /* ctor */ CMICmnMIOutOfBandRecord(const OutOfBand_e veType, const CMICmnMIValueResult &vResult);
     //
     const CMIUtilString &GetString(void) const;
-    bool Add(const CMICmnMIValueResult &vResult);
+    void Add(const CMICmnMIValueResult &vResult);
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIOutOfBandRecord(void) override;
 
     // Methods:
   private:
-    bool BuildAsyncRecord(void);
+    void BuildAsyncRecord(void);
 
     // Attributes:
   private:
     static MapOutOfBandToOutOfBandText_t ms_constMapOutOfBandToAsyncRecordText;
     static MapOutOfBandToToken_t ms_constMapOutOfBandTextToToken;
     //
     OutOfBand_e m_eResultAsyncRecordClass;
     CMIUtilString m_strAsyncRecord; // Holds the text version of the result record to date
     CMICmnMIValueResult m_partResult;
 };

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

CMICmnMIOutOfBandRecord::GetString(void) const
     return m_strAsyncRecord;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the Out-of-band record's mandatory data part. The part up to the first
 //          (additional) result i.e. async-record ==>  "*" type.
 // Type:    Method.
 // Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIOutOfBandRecord::BuildAsyncRecord(void)
 {
     const char *pFormat = "%s%s";
     const CMIUtilString &rStrAsyncRecord(ms_MapOutOfBandToOutOfBandText[m_eResultAsyncRecordClass]);
     const CMIUtilString &rStrToken(ms_constMapAsyncRecordTextToToken[m_eResultAsyncRecordClass]);
     m_strAsyncRecord = CMIUtilString::Format(pFormat, rStrToken.c_str(), rStrAsyncRecord.c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add to *this Out-of-band record additional information.
 // Type:    Method.
 // Args:    vResult           - (R) A MI result object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIOutOfBandRecord::Add(const CMICmnMIValueResult &vResult)
 {
     m_strAsyncRecord += ",";
     m_strAsyncRecord += vResult.GetString();
-
-    return MIstatus::success;
 }

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

public:
 
     // Methods:
   public:
     /* ctor */ CMICmnMIResultRecord();
     /* ctor */ CMICmnMIResultRecord(const CMIUtilString &vrToken, ResultClass_e veType);
     /* ctor */ CMICmnMIResultRecord(const CMIUtilString &vrToken, ResultClass_e veType, const CMICmnMIValueResult &vValue);
     //
     const CMIUtilString &GetString() const;
-    bool Add(const CMICmnMIValue &vMIValue);
+    void Add(const CMICmnMIValue &vMIValue);
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIResultRecord() override;
 
     // Attributes:
   private:
     CMIUtilString m_strResultRecord; // Holds the text version of the result record to date
 };

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

 {
     return m_strResultRecord;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add to *this result record additional information.
 // Type:    Method.
 // Args:    vMIValue    - (R) A MI value derived object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIResultRecord::Add(const CMICmnMIValue &vMIValue)
 {
     m_strResultRecord += ",";
     m_strResultRecord += vMIValue.GetString();
-
-    return MIstatus::success;
 }

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

 class CMICmnMIValueList : public CMICmnMIValue
 {
     // Methods:
   public:
     /* ctor */ CMICmnMIValueList(const bool vbValueTypeList);
     /* ctor */ CMICmnMIValueList(const CMICmnMIValueResult &vResult);
     /* ctor */ CMICmnMIValueList(const CMICmnMIValue &vValue);
     //
-    bool Add(const CMICmnMIValueResult &vResult);
-    bool Add(const CMICmnMIValue &vValue);
+    void Add(const CMICmnMIValueResult &vResult);
+    void Add(const CMICmnMIValue &vValue);
     CMIUtilString ExtractContentNoBrackets(void) const;
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIValueList(void) override;
 
     // Methods:
   private:
-    bool BuildList(void);
-    bool BuildList(const CMICmnMIValueResult &vResult);
-    bool BuildList(const CMICmnMIValue &vResult);
+    void BuildList(void);
+    void BuildList(const CMICmnMIValueResult &vResult);
+    void BuildList(const CMICmnMIValue &vResult);
 };

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

 CMICmnMIValueList::~CMICmnMIValueList(void)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the result value's mandatory data part, one tuple
 // Type:    Method.
 // Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueList::BuildList(void)
 {
     const char *pFormat = "[%s]";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI result object to  the value list's of list is results.
 //          Only result objects can be added to a list of result otherwise this function
 //          will return MIstatus::failure.
 // Type:    Method.
 // Args:    vResult - (R) The MI result object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueList::Add(const CMICmnMIValueResult &vResult)
 {
-    return BuildList(vResult);
+    BuildList(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.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueList::Add(const CMICmnMIValue &vValue)
 {
-    return BuildList(vValue);
+    BuildList(vValue);
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI result object to  the value list's of list is results.
 //          Only result objects can be added to a list of result otherwise this function
 //          will return MIstatus::failure.
 // Type:    Method.
 // Args:    vResult - (R) The MI result object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueList::BuildList(const CMICmnMIValueResult &vResult)
 {
     // Clear out the default "<Invalid>" text
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vResult.GetString();
-        return BuildList();
+        BuildList();
+        return;
     }
 
     const CMIUtilString data(ExtractContentNoBrackets());
     const char *pFormat = "[%s,%s]";
     m_strValue = CMIUtilString::Format(pFormat, data.c_str(), vResult.GetString().c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // 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.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueList::BuildList(const CMICmnMIValue &vValue)
 {
     // Clear out the default "<Invalid>" text
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vValue.GetString();
-        return BuildList();
+        BuildList();
+        return;
     }
 
     // Remove already present '[' and ']' from the start and end
     m_strValue = m_strValue.Trim();
     size_t len = m_strValue.size();
     if ( (len > 1) && (m_strValue[0] == '[') && (m_strValue[len - 1] == ']') )
         m_strValue = m_strValue.substr(1, len - 2);
     const char *pFormat = "[%s,%s]";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str(), vValue.GetString().c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the contents of *this value object but without the outer most
 //          brackets.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - Data within the object.

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

 class CMICmnMIValueResult : public CMICmnMIValue
 {
     // Methods:
   public:
     /* ctor */ CMICmnMIValueResult(void);
     /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
     /* ctor */ CMICmnMIValueResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue, const bool vbUseSpacing);
     //
-    bool Add(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
+    void Add(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIValueResult(void) override;
 
     // Methods:
   private:
-    bool BuildResult(void);
-    bool BuildResult(const CMIUtilString &vVariable, const CMICmnMIValue &vValue);
+    void BuildResult(void);
+    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
 };

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

 CMICmnMIValueResult::~CMICmnMIValueResult(void)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the MI value result string.
 // Type:    Method.
 // Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueResult::BuildResult(void)
 {
     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_partMIValue.GetString().c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the MI value result string.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.
 //          vrValue     - (R) The MI value.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+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(), vValue.GetString().c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Append another MI value object to *this MI value result.
 // Type:    Method.
 // Args:    vrVariable  - (R) MI value's name.
 //          vrValue     - (R) The MI value.
 // Return:  MIstatus::success - Functional succeeded.
 //          MIstatus::failure - Functional failed.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueResult::Add(const CMIUtilString &vrVariable, const CMICmnMIValue &vrValue)
 {
     if (!m_bEmptyConstruction)
-        return BuildResult(vrVariable, vrValue);
+        BuildResult(vrVariable, vrValue);
     else
     {
         m_bEmptyConstruction = false;
         m_strPartVariable = vrVariable;
         m_partMIValue = vrValue;
-        return BuildResult();
+        BuildResult();
     }
 }

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

 class CMICmnMIValueTuple : public CMICmnMIValue
 {
     // Methods:
   public:
     /* ctor */ CMICmnMIValueTuple(void);
     /* ctor */ CMICmnMIValueTuple(const CMICmnMIValueResult &vResult);
     /* ctor */ CMICmnMIValueTuple(const CMICmnMIValueResult &vResult, const bool vbUseSpacing);
     //
-    bool Add(const CMICmnMIValueResult &vResult);
-    bool Add(const CMICmnMIValueResult &vResult, const bool vbUseSpacing);
-    bool Add(const CMICmnMIValueConst &vValue, const bool vbUseSpacing);
+    void Add(const CMICmnMIValueResult &vResult);
+    void Add(const CMICmnMIValueResult &vResult, const bool vbUseSpacing);
+    void Add(const CMICmnMIValueConst &vValue, const bool vbUseSpacing);
     CMIUtilString ExtractContentNoBrackets(void) const;
 
     // Overridden:
   public:
     // From CMICmnBase
     /* dtor */ ~CMICmnMIValueTuple(void) override;
 
     // Methods:
   private:
-    bool BuildTuple(void);
-    bool BuildTuple(const CMICmnMIValueResult &vResult);
-    bool BuildTuple(const CMIUtilString &vValue);
+    void BuildTuple(void);
+    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
 };

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

 CMICmnMIValueTuple::~CMICmnMIValueTuple(void)
 {
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Build the result value's mandatory data part, one tuple
 // Type:    Method.
 // Args:    None.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::BuildTuple(void)
 {
     const char *pFormat = "{%s}";
     m_strValue = CMIUtilString::Format(pFormat, m_strValue.c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add another MI result object to the value's list of tuples.
 // Type:    Method.
 // Args:    vResult - (R) The MI result object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::BuildTuple(const CMICmnMIValueResult &vResult)
 {
     // Clear out the default "<Invalid>" text
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vResult.GetString();
-        return BuildTuple();
+        BuildTuple();
+        return;
     }
 
     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(), vResult.GetString().c_str());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Add string value to the value's list of tuples.
 // Type:    Method.
 // Args:    vValue  - (R) The string object.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::BuildTuple(const CMIUtilString &vValue)
 {
     // Clear out the default "<Invalid>" text
     if (m_bJustConstructed)
     {
         m_bJustConstructed = false;
         m_strValue = vValue;
-        return BuildTuple();
+        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());
-
-    return MIstatus::success;
 }
 
 //++ ------------------------------------------------------------------------------------
 // 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.
-// Return:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::Add(const CMICmnMIValueResult &vResult)
 {
-    return BuildTuple(vResult);
+    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:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::Add(const CMICmnMIValueResult &vResult, const bool vbUseSpacing)
 {
     m_bSpaceAfterComma = vbUseSpacing;
-    return BuildTuple(vResult);
+    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:  MIstatus::success - Functional succeeded.
-//          MIstatus::failure - Functional failed.
+// Return:  None.
 // Throws:  None.
 //--
-bool
+void
 CMICmnMIValueTuple::Add(const CMICmnMIValueConst &vValue, const bool vbUseSpacing)
 {
     m_bSpaceAfterComma = vbUseSpacing;
-    return BuildTuple(vValue.GetString());
+    BuildTuple(vValue.GetString());
 }
 
 //++ ------------------------------------------------------------------------------------
 // Details: Retrieve the contents of *this value object but without the outer most
 //          brackets.
 // Type:    Method.
 // Args:    None.
 // Return:  CMIUtilString - Data within the object.