[lldb/CommandInterpreter] Add CommandInterpreterRunResult (NFC)

[JDevlieghere]

Summary

This patch adds a new class CommandInterpreterRunResult which will be backing the SBCommandInterpreterRunResult. It keeps track of the number of errors as well as the result which is an enum, as proposed by Pavel in D79120. The command interpreter now populates the results directly, instead of its own member variables.

[clayborg]

lldb/include/lldb/lldb-enumerations.h

1084

Add some header doc for these to explain a bit maybe since this is a public header file?

lldb/include/lldb/Interpreter/CommandInterpreter.h

 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StringList.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-private.h"
 #include <mutex>
 
 namespace lldb_private {
+class CommandInterpreter;
+
+class CommandInterpreterRunResult {
+public:
+  CommandInterpreterRunResult()
+      : m_num_errors(0), m_result(lldb::eCommandInterpreterResultSuccess) {}
+
+  uint32_t GetNumErrors() const { return m_num_errors; }
+
+  lldb::CommandInterpreterResult GetResult() const { return m_result; }
+
+  bool IsResult(lldb::CommandInterpreterResult result) {
+    return m_result = result;
+  }
+
+protected:
+  friend CommandInterpreter;
+
+  void IncrementNumberOfErrors() { m_num_errors++; }
+
+  void SetResult(lldb::CommandInterpreterResult result) { m_result = result; }
+
+private:
+  int m_num_errors;
+  lldb::CommandInterpreterResult m_result;
+};
 
 class CommandInterpreterRunOptions {
 public:
   /// Construct a CommandInterpreterRunOptions object. This class is used to
   /// control all the instances where we run multiple commands, e.g.
   /// HandleCommands, HandleCommandsFromFile, RunCommandInterpreter.
   ///
   /// The meanings of the options in this object are:
return "*** Some of your variables have more members than the debugger "
            "--show-all-children option to %s or raise the limit by changing "
            "the target.max-children-count setting.\n";
   }
 
   CommandHistory &GetCommandHistory() { return m_command_history; }
 
   bool IsActive();
 
-  void RunCommandInterpreter(CommandInterpreterRunOptions &options);
+  CommandInterpreterRunResult
+  RunCommandInterpreter(CommandInterpreterRunOptions &options);
 
   void GetLLDBCommandsFromIOHandler(const char *prompt,
                                     IOHandlerDelegate &delegate,
                                     void *baton = nullptr);
 
   void GetPythonCommandsFromIOHandler(const char *prompt,
                                       IOHandlerDelegate &delegate,
                                       void *baton = nullptr);
public:
   /// \param[out] exited
   ///     Set to true if the user has called quit with a custom exit code.
   int GetQuitExitCode(bool &exited) const;
 
   void ResolveCommand(const char *command_line, CommandReturnObject &result);
 
   bool GetStopCmdSourceOnError() const;
 
-  uint32_t GetNumErrors() const { return m_num_errors; }
-
-  bool GetQuitRequested() const { return m_quit_requested; }
-
   lldb::IOHandlerSP
   GetIOHandler(bool force_create = false,
                CommandInterpreterRunOptions *options = nullptr);
 
-  bool GetStoppedForCrash() const { return m_stopped_for_crash; }
-
   bool GetSpaceReplPrompts() const;
 
 protected:
   friend class Debugger;
 
   // IOHandlerDelegate functions
   void IOHandlerInputComplete(IOHandler &io_handler,
                               std::string &line) override;
private:
   lldb::IOHandlerSP m_command_io_handler_sp;
   char m_comment_char;
   bool m_batch_command_mode;
   ChildrenTruncatedWarningStatus m_truncation_warning; // Whether we truncated
                                                        // children and whether
                                                        // the user has been told
   uint32_t m_command_source_depth;
   std::vector<uint32_t> m_command_source_flags;
-  uint32_t m_num_errors;
-  bool m_quit_requested;
-  bool m_stopped_for_crash;
+  CommandInterpreterRunResult m_result;
 
   // The exit code the user has requested when calling the 'quit' command.
   // No value means the user hasn't set a custom exit code so far.
   llvm::Optional<int> m_quit_exit_code;
   // If the driver is accepts custom exit codes for the 'quit' command.
   bool m_allow_exit_code = false;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_COMMANDINTERPRETER_H

lldb/include/lldb/lldb-enumerations.h

FLAGS_ENUM(CommandFlags){
     /// the command will fail with an appropriate error message.
     eCommandProcessMustBePaused = (1u << 7)};
 
 /// Whether a summary should cap how much data it returns to users or not.
 enum TypeSummaryCapping {
   eTypeSummaryCapped = true,
   eTypeSummaryUncapped = false
 };
+
+/// The result from a command interpreter run.
+enum CommandInterpreterResult {
+  /// Command interpreter finished successfully.
+  eCommandInterpreterResultSuccess,
+  /// Stopped because the corresponding option was set and the inferior
+  /// crashed.
+  eCommandInterpreterResultInferiorCrash,
+  /// Stopped because the corresponding option was set and a command returned
+  /// an error.
+  eCommandInterpreterResultCommandError,
+  /// Stopped because quit was requested.
+  eCommandInterpreterResultQuitRequested,
+};
 } // namespace lldb
 
 #endif // LLDB_LLDB_ENUMERATIONS_H

lldb/source/API/SBDebugger.cpp

LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
                       bool &, bool &),
                      auto_handle_events, spawn_thread, options, num_errors,
                      quit_requested, stopped_for_crash);
 
   if (m_opaque_sp) {
     options.SetAutoHandleEvents(auto_handle_events);
     options.SetSpawnThread(spawn_thread);
     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
+    CommandInterpreterRunResult result =
         interp.RunCommandInterpreter(options.ref());
-    num_errors = interp.GetNumErrors();
-    quit_requested = interp.GetQuitRequested();
-    stopped_for_crash = interp.GetStoppedForCrash();
+    num_errors = result.GetNumErrors();
+    quit_requested =
+        result.IsResult(lldb::eCommandInterpreterResultQuitRequested);
+    stopped_for_crash =
+        result.IsResult(lldb::eCommandInterpreterResultInferiorCrash);
   }
 }
 
 SBError SBDebugger::RunREPL(lldb::LanguageType language,
                             const char *repl_options) {
   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
                      (lldb::LanguageType, const char *), language,
                      repl_options);

lldb/source/Interpreter/CommandInterpreter.cpp

: Broadcaster(debugger.GetBroadcasterManager(),
                   CommandInterpreter::GetStaticBroadcasterClass().AsCString()),
       Properties(OptionValuePropertiesSP(
           new OptionValueProperties(ConstString("interpreter")))),
       IOHandlerDelegate(IOHandlerDelegate::Completion::LLDBCommand),
       m_debugger(debugger), m_synchronous_execution(true),
       m_skip_lldbinit_files(false), m_skip_app_init_files(false),
       m_command_io_handler_sp(), m_comment_char('#'),
       m_batch_command_mode(false), m_truncation_warning(eNoTruncation),
-      m_command_source_depth(0), m_num_errors(0), m_quit_requested(false),
-      m_stopped_for_crash(false) {
+      m_command_source_depth(0) {
   SetEventName(eBroadcastBitThreadShouldExit, "thread-should-exit");
   SetEventName(eBroadcastBitResetPrompt, "reset-prompt");
   SetEventName(eBroadcastBitQuitCommandReceived, "quit");
   SetSynchronous(synchronous_execution);
   CheckInWithManager();
   m_collection_sp->Initialize(g_interpreter_properties);
 }
 
void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
 
   case eReturnStatusSuccessContinuingNoResult:
   case eReturnStatusSuccessContinuingResult:
     if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnContinue))
       io_handler.SetIsDone(true);
     break;
 
   case eReturnStatusFailed:
-    m_num_errors++;
+    m_result.IncrementNumberOfErrors();
     if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnError))
       io_handler.SetIsDone(true);
     break;
 
   case eReturnStatusQuit:
-    m_quit_requested = true;
+    m_result.SetResult(lldb::eCommandInterpreterResultQuitRequested);
     io_handler.SetIsDone(true);
     break;
   }
 
   // Finally, if we're going to stop on crash, check that here:
-  if (!m_quit_requested && result.GetDidChangeProcessState() &&
+  if (m_result.IsResult(lldb::eCommandInterpreterResultSuccess) &&
+      result.GetDidChangeProcessState() &&
       io_handler.GetFlags().Test(eHandleCommandFlagStopOnCrash) &&
       DidProcessStopAbnormally()) {
     io_handler.SetIsDone(true);
-    m_stopped_for_crash = true;
+    m_result.SetResult(lldb::eCommandInterpreterResultInferiorCrash);
   }
 }
 
 bool CommandInterpreter::IOHandlerInterrupt(IOHandler &io_handler) {
   ExecutionContext exe_ctx(GetExecutionContext());
   Process *process = exe_ctx.GetProcessPtr();
 
   if (InterruptCommand())
m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
         m_debugger.GetUseColor(),
         0,     // Don't show line numbers
         *this, // IOHandlerDelegate
         GetDebugger().GetInputRecorder());
   }
   return m_command_io_handler_sp;
 }
 
-void CommandInterpreter::RunCommandInterpreter(
+CommandInterpreterRunResult CommandInterpreter::RunCommandInterpreter(
     CommandInterpreterRunOptions &options) {
   // Always re-create the command interpreter when we run it in case any file
   // handles have changed.
   bool force_create = true;
   m_debugger.RunIOHandlerAsync(GetIOHandler(force_create, &options));
-  m_stopped_for_crash = false;
+  m_result = CommandInterpreterRunResult();
 
   if (options.GetAutoHandleEvents())
     m_debugger.StartEventHandlerThread();
 
   if (options.GetSpawnThread()) {
     m_debugger.StartIOHandlerThread();
   } else {
     m_debugger.RunIOHandlers();
 
     if (options.GetAutoHandleEvents())
       m_debugger.StopEventHandlerThread();
   }
+
+  return m_result;
 }
 
 CommandObject *
 CommandInterpreter::ResolveCommandImpl(std::string &command_line,
                                        CommandReturnObject &result) {
   std::string scratch_command(command_line); // working copy so we don't modify
                                              // command_line unless we succeed
   CommandObject *cmd_obj = nullptr;