Propagate command interpreter errors from lldlbinit

[JDevlieghere]

Summary

This patch ensures that we propagate errors coming from the lldbinit file trough the command/script interpreter. Before, if you did something like command script import syntax_error.py, and the python file contained a syntax error, lldb wouldn't tell you about it. This changes with the current patch: errors are now propagated by default.

PS: Jim authored this change and I added testing.

[jingham]

I wonder if it would make this a little more convenient if we added a SetNoisy as the opposite of SetSilent?

[aprantl]

Seems plausible.

lldb/source/Interpreter/CommandInterpreter.cpp

2472 ↗

(On Diff #198215)

Is m_command_source_flags.empty() || Flags(m_command_source_flags.back()).Test(eHandleCommandFlagPrintErrors) better? Not sure.

[JDevlieghere]

lldb/source/Interpreter/CommandInterpreter.cpp

2472 ↗

(On Diff #198215)

Personally I think this is easier to read, and consistent with what we do elsewhere. Happy to be convinced otherwise though :-)

[jingham]

lldb/source/Interpreter/CommandInterpreter.cpp

2472 ↗

(On Diff #198215)

I agree with Jonas, the original is easier to read.

include/lldb/Interpreter/CommandInterpreter.h

public:
   /// \param[in] echo_commands
   ///    If \b true, echo the command before executing it. If \b false, execute
   ///    silently.
   /// \param[in] echo_comments
   ///    If \b true, echo command even if it is a pure comment line. If
   ///    \b false, print no ouput in this case. This setting has an effect only
   ///    if \param echo_commands is \b true.
   /// \param[in] print_results
-  ///    If \b true print the results of the command after executing it. If
-  ///    \b false, execute silently.
+  ///    If \b true and the command succeeds, print the results of the command
+  ///    after executing it. If \b false, execute silently.
+  /// \param[in] print_errors
+  ///    If \b true and the command fails, print the results of the command
+  ///    after executing it. If \b false, execute silently.
   /// \param[in] add_to_history
   ///    If \b true add the commands to the command history. If \b false, don't
   ///    add them.
   CommandInterpreterRunOptions(LazyBool stop_on_continue,
                                LazyBool stop_on_error, LazyBool stop_on_crash,
                                LazyBool echo_commands, LazyBool echo_comments,
-                               LazyBool print_results, LazyBool add_to_history)
+                               LazyBool print_results, LazyBool print_errors,
+                               LazyBool add_to_history)
       : m_stop_on_continue(stop_on_continue), m_stop_on_error(stop_on_error),
         m_stop_on_crash(stop_on_crash), m_echo_commands(echo_commands),
         m_echo_comment_commands(echo_comments), m_print_results(print_results),
-        m_add_to_history(add_to_history) {}
+        m_print_errors(print_errors), m_add_to_history(add_to_history) {}
 
   CommandInterpreterRunOptions()
       : m_stop_on_continue(eLazyBoolCalculate),
         m_stop_on_error(eLazyBoolCalculate),
         m_stop_on_crash(eLazyBoolCalculate),
         m_echo_commands(eLazyBoolCalculate),
         m_echo_comment_commands(eLazyBoolCalculate),
-        m_print_results(eLazyBoolCalculate),
+        m_print_results(eLazyBoolCalculate), m_print_errors(eLazyBoolCalculate),
         m_add_to_history(eLazyBoolCalculate) {}
 
   void SetSilent(bool silent) {
     LazyBool value = silent ? eLazyBoolNo : eLazyBoolYes;
 
     m_print_results = value;
+    m_print_errors = value;
     m_echo_commands = value;
     m_echo_comment_commands = value;
     m_add_to_history = value;
   }
   // These return the default behaviors if the behavior is not
   // eLazyBoolCalculate. But I've also left the ivars public since for
   // different ways of running the interpreter you might want to force
   // different defaults...  In that case, just grab the LazyBool ivars directly
public:
   }
 
   bool GetPrintResults() const { return DefaultToYes(m_print_results); }
 
   void SetPrintResults(bool print_results) {
     m_print_results = print_results ? eLazyBoolYes : eLazyBoolNo;
   }
 
+  bool GetPrintErrors() const { return DefaultToYes(m_print_errors); }
+
+  void SetPrintErrors(bool print_errors) {
+    m_print_errors = print_errors ? eLazyBoolYes : eLazyBoolNo;
+  }
+
   bool GetAddToHistory() const { return DefaultToYes(m_add_to_history); }
 
   void SetAddToHistory(bool add_to_history) {
     m_add_to_history = add_to_history ? eLazyBoolYes : eLazyBoolNo;
   }
 
   LazyBool m_stop_on_continue;
   LazyBool m_stop_on_error;
   LazyBool m_stop_on_crash;
   LazyBool m_echo_commands;
   LazyBool m_echo_comment_commands;
   LazyBool m_print_results;
+  LazyBool m_print_errors;
   LazyBool m_add_to_history;
 
 private:
   static bool DefaultToYes(LazyBool flag) {
     switch (flag) {
     case eLazyBoolNo:
       return false;
     default:

lit/Driver/Inputs/.lldbinit

 settings set -f frame-format "bogus"
+command script import syntax_error.py

lit/Driver/Inputs/syntax_error.py

+prlnt("foo")

lit/Driver/LocalLLDBInit.test

 # RUN: mkdir -p %t.root
 # RUN: mkdir -p %t.home
 # RUN: cp %S/Inputs/.lldbinit %t.root
+# RUN: cp %S/Inputs/syntax_error.py %t.root
 # RUN: cd %t.root
 # RUN: env HOME=%t.home %lldb-init -o 'settings show frame-format' 2>&1 | FileCheck %s --check-prefix=WARNINIT --check-prefix=CHECK
 # RUN: env HOME=%t.home %lldb-init -local-lldbinit -o 'settings show frame-format' 2>&1 | FileCheck %s --check-prefix=ALLOWINIT --check-prefix=NOINIT
 # RUN: %lldb -o 'settings show frame-format' 2>&1 | FileCheck %s --check-prefix=NOINIT --check-prefix=CHECK
 
 # WARNINIT: There is a .lldbinit file in the current directory which is not being read.
 # NOINIT-NOT: There is a .lldbinit file in the current directory which is not being read.
 # CHECK-NOT: bogus
+# ALLOWINIT: name 'prlnt' is not defined
 # ALLOWINIT: bogus

source/Breakpoint/BreakpointOptions.cpp

if (target) {
       result.SetImmediateOutputStream(output_stream);
       result.SetImmediateErrorStream(error_stream);
 
       CommandInterpreterRunOptions options;
       options.SetStopOnContinue(true);
       options.SetStopOnError(data->stop_on_error);
       options.SetEchoCommands(true);
       options.SetPrintResults(true);
+      options.SetPrintErrors(true);
       options.SetAddToHistory(false);
 
       debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
                                                       options, result);
       result.GetImmediateOutputStream()->Flush();
       result.GetImmediateErrorStream()->Flush();
     }
   }

source/Commands/CommandObjectBugreport.cpp

if (outfile_spec) {
 
       result.SetImmediateOutputStream(outfile_stream);
     }
 
     CommandInterpreterRunOptions options;
     options.SetStopOnError(false);
     options.SetEchoCommands(true);
     options.SetPrintResults(true);
+    options.SetPrintErrors(true);
     options.SetAddToHistory(false);
     m_interpreter.HandleCommands(commands, &m_exe_ctx, options, result);
 
     return result.Succeeded();
   }
 
 private:
   OptionGroupOptions m_option_group;

source/Commands/CommandObjectCommands.cpp

if (m_options.m_stop_on_error.OptionWasSet() ||
       if (m_options.m_stop_on_error.OptionWasSet())
         options.SetStopOnError(m_options.m_stop_on_error.GetCurrentValue());
 
       // Individual silent setting is override for global command echo settings.
       if (m_options.m_silent_run.GetCurrentValue()) {
         options.SetSilent(true);
       } else {
         options.SetPrintResults(true);
+        options.SetPrintErrors(true);
         options.SetEchoCommands(m_interpreter.GetEchoCommands());
         options.SetEchoCommentCommands(m_interpreter.GetEchoCommentCommands());
       }
 
       m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
     } else {
       // No options were set, inherit any settings from nested "command source"
       // commands, or set to sane default settings...

source/Commands/CommandObjectSettings.cpp

protected:
   bool DoExecute(Args &command, CommandReturnObject &result) override {
     FileSpec file(m_options.m_filename);
     FileSystem::Instance().Resolve(file);
     ExecutionContext clean_ctx;
     CommandInterpreterRunOptions options;
     options.SetAddToHistory(false);
     options.SetEchoCommands(false);
     options.SetPrintResults(true);
+    options.SetPrintErrors(true);
     options.SetStopOnError(false);
     m_interpreter.HandleCommandsFromFile(file, &clean_ctx, options, result);
     return result.Succeeded();
   }
 
 private:
   CommandOptions m_options;
 };

source/Commands/CommandObjectWatchpointCommand.cpp

if (commands.GetSize() > 0) {
         result.SetImmediateOutputStream(output_stream);
         result.SetImmediateErrorStream(error_stream);
 
         CommandInterpreterRunOptions options;
         options.SetStopOnContinue(true);
         options.SetStopOnError(data->stop_on_error);
         options.SetEchoCommands(false);
         options.SetPrintResults(true);
+        options.SetPrintErrors(true);
         options.SetAddToHistory(false);
 
         debugger.GetCommandInterpreter().HandleCommands(commands, &exe_ctx,
                                                         options, result);
         result.GetImmediateOutputStream()->Flush();
         result.GetImmediateErrorStream()->Flush();
       }
     }

source/Interpreter/CommandInterpreter.cpp

void CommandInterpreter::SourceInitFile(bool in_cwd,
   // If the file exists, tell HandleCommand to 'source' it; this will do the
   // actual broadcasting of the commands back to any appropriate listener (see
   // CommandObjectSource::Execute for more details).
 
   if (FileSystem::Instance().Exists(init_file)) {
     const bool saved_batch = SetBatchCommandMode(true);
     CommandInterpreterRunOptions options;
     options.SetSilent(true);
+    options.SetPrintErrors(true);
     options.SetStopOnError(false);
     options.SetStopOnContinue(true);
 
     HandleCommandsFromFile(init_file,
                            nullptr, // Execution context
                            options, result);
     SetBatchCommandMode(saved_batch);
   } else {

 // Make flags that we can pass into the IOHandler so our delegates can do the
 // right thing
 enum {
   eHandleCommandFlagStopOnContinue = (1u << 0),
   eHandleCommandFlagStopOnError = (1u << 1),
   eHandleCommandFlagEchoCommand = (1u << 2),
   eHandleCommandFlagEchoCommentCommand = (1u << 3),
   eHandleCommandFlagPrintResult = (1u << 4),
-  eHandleCommandFlagStopOnCrash = (1u << 5)
+  eHandleCommandFlagPrintErrors = (1u << 5),
+  eHandleCommandFlagStopOnCrash = (1u << 6)
 };
 
 void CommandInterpreter::HandleCommandsFromFile(
     FileSpec &cmd_file, ExecutionContext *context,
     CommandInterpreterRunOptions &options, CommandReturnObject &result) {
   if (!FileSystem::Instance().Exists(cmd_file)) {
     result.AppendErrorWithFormat(
         "Error reading commands from file %s - file not found.\n",
if (m_command_source_flags.empty()) {
       flags |= eHandleCommandFlagPrintResult;
     } else if (m_command_source_flags.back() & eHandleCommandFlagPrintResult) {
       flags |= eHandleCommandFlagPrintResult;
     }
   } else if (options.m_print_results == eLazyBoolYes) {
     flags |= eHandleCommandFlagPrintResult;
   }
 
+  if (options.m_print_errors == eLazyBoolCalculate) {
+    if (m_command_source_flags.empty()) {
+      // Print output by default
+      flags |= eHandleCommandFlagPrintErrors;
+    } else if (m_command_source_flags.back() & eHandleCommandFlagPrintErrors) {
+      flags |= eHandleCommandFlagPrintErrors;
+    }
+  } else if (options.m_print_errors == eLazyBoolYes) {
+    flags |= eHandleCommandFlagPrintErrors;
+  }
+
   if (flags & eHandleCommandFlagPrintResult) {
     debugger.GetOutputFile()->Printf("Executing commands in '%s'.\n",
                                      cmd_file_path.c_str());
   }
 
   // Used for inheriting the right settings when "command source" might
   // have nested "command source" commands
   lldb::StreamFileSP empty_stream_sp;
void CommandInterpreter::IOHandlerInputComplete(IOHandler &io_handler,
   }
 
   StartHandlingCommand();
 
   lldb_private::CommandReturnObject result;
   HandleCommand(line.c_str(), eLazyBoolCalculate, result);
 
   // Now emit the command output text from the command we just executed
-  if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) {
+  if ((result.Succeeded() &&
+       io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) ||
+      io_handler.GetFlags().Test(eHandleCommandFlagPrintErrors)) {
     // Display any STDOUT/STDERR _prior_ to emitting the command result text
     GetProcessOutput();
 
     if (!result.GetImmediateOutputStream()) {
       llvm::StringRef output = result.GetOutputData();
       PrintCommandOutput(*io_handler.GetOutputStreamFile(), output);
     }
 
if (options) {
       if (options->m_stop_on_crash == eLazyBoolYes)
         flags |= eHandleCommandFlagStopOnCrash;
       if (options->m_echo_commands != eLazyBoolNo)
         flags |= eHandleCommandFlagEchoCommand;
       if (options->m_echo_comment_commands != eLazyBoolNo)
         flags |= eHandleCommandFlagEchoCommentCommand;
       if (options->m_print_results != eLazyBoolNo)
         flags |= eHandleCommandFlagPrintResult;
+      if (options->m_print_errors != eLazyBoolNo)
+        flags |= eHandleCommandFlagPrintErrors;
     } else {
-      flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult;
+      flags = eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult |
+              eHandleCommandFlagPrintErrors;
     }
 
     m_command_io_handler_sp = std::make_shared<IOHandlerEditline>(
         m_debugger, IOHandler::Type::CommandInterpreter,
         m_debugger.GetInputFile(), m_debugger.GetOutputFile(),
         m_debugger.GetErrorFile(), flags, "lldb", m_debugger.GetPrompt(),
         llvm::StringRef(), // Continuation prompt
         false, // Don't enable multiple line input, just single line commands

source/Target/Target.cpp

for (size_t i = 0; keep_going && i < num_exe_ctx; i++) {
               "-- Thread %d\n",
               exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID());
 
         CommandInterpreterRunOptions options;
         options.SetStopOnContinue(true);
         options.SetStopOnError(true);
         options.SetEchoCommands(false);
         options.SetPrintResults(true);
+        options.SetPrintErrors(true);
         options.SetAddToHistory(false);
 
         // Force Async:
         bool old_async = GetDebugger().GetAsyncExecution();
         GetDebugger().SetAsyncExecution(true);
         GetDebugger().GetCommandInterpreter().HandleCommands(
             cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], options,
             result);