gdb/cli/cli-interp.c

   1 /* CLI Definitions for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "cli-interp.h"
  21 #include "exceptions.h"
  22 #include "interps.h"
  23 #include "event-top.h"
  24 #include "ui-out.h"
  25 #include "cli-out.h"
  26 #include "top.h"
  27 #include "ui.h"
  28 #include "infrun.h"
  29 #include "observable.h"
  30 #include "gdbthread.h"
  31 #include "thread-fsm.h"
  32 #include "inferior.h"
  33
  34 cli_interp_base::cli_interp_base (const char *name)
  35   : interp (name)
  36 {}
  37
  38 cli_interp_base::~cli_interp_base ()
  39 {}
  40
  41 /* The console interpreter.  */
  42
  43 class cli_interp final : public cli_interp_base
  44 {
  45  public:
  46   explicit cli_interp (const char *name);
  47   ~cli_interp () = default;
  48
  49   void init (bool top_level) override;
  50   void resume () override;
  51   void suspend () override;
  52   void exec (const char *command_str) override;
  53   ui_out *interp_ui_out () override;
  54
  55 private:
  56
  57   /* The ui_out for the console interpreter.  */
  58   std::unique_ptr<cli_ui_out> m_cli_uiout;
  59 };
  60
  61 cli_interp::cli_interp (const char *name)
  62   : cli_interp_base (name),
  63     m_cli_uiout (new cli_ui_out (gdb_stdout))
  64 {
  65 }
  66
  67 /* Suppress notification struct.  */
  68 struct cli_suppress_notification cli_suppress_notification;
  69
  70 /* See cli-interp.h.
  71
  72    Breakpoint hits should always be mirrored to a console.  Deciding
  73    what to mirror to a console wrt to breakpoints and random stops
  74    gets messy real fast.  E.g., say "s" trips on a breakpoint.  We'd
  75    clearly want to mirror the event to the console in this case.  But
  76    what about more complicated cases like "s&; thread n; s&", and one
  77    of those steps spawning a new thread, and that thread hitting a
  78    breakpoint?  It's impossible in general to track whether the thread
  79    had any relation to the commands that had been executed.  So we
  80    just simplify and always mirror breakpoints and random events to
  81    all consoles.
  82
  83    OTOH, we should print the source line to the console when stepping
  84    or other similar commands, iff the step was started by that console
  85    (or in MI's case, by a console command), but not if it was started
  86    with MI's -exec-step or similar.  */
  87
  88 int
  89 should_print_stop_to_console (struct interp *console_interp,
  90                               struct thread_info *tp)
  91 {
  92   if ((bpstat_what (tp->control.stop_bpstat).main_action
  93        == BPSTAT_WHAT_STOP_NOISY)
  94       || tp->thread_fsm () == nullptr
  95       || tp->thread_fsm ()->command_interp == console_interp
  96       || !tp->thread_fsm ()->finished_p ())
  97     return 1;
  98   return 0;
  99 }
 100
 101 /* Observers for several run control events.  If the interpreter is
 102    quiet (i.e., another interpreter is being run with
 103    interpreter-exec), print nothing.  These are named "cli_base" as
 104    they print to both CLI interpreters and TUI interpreters.  */
 105
 106 void
 107 cli_interp_base::on_normal_stop (struct bpstat *bs, int print_frame)
 108 {
 109   if (!print_frame)
 110     return;
 111
 112   /* This event is suppressed.  */
 113   if (cli_suppress_notification.normal_stop)
 114     return;
 115
 116   thread_info *thread = inferior_thread ();
 117   if (should_print_stop_to_console (this, thread))
 118     print_stop_event (this->interp_ui_out ());
 119
 120 }
 121
 122 void
 123 cli_interp_base::on_signal_received (enum gdb_signal siggnal)
 124 {
 125   print_signal_received_reason (this->interp_ui_out (), siggnal);
 126 }
 127
 128 void
 129 cli_interp_base::on_signal_exited (gdb_signal sig)
 130 {
 131   print_signal_exited_reason (this->interp_ui_out (), sig);
 132 }
 133
 134 void
 135 cli_interp_base::on_exited (int status)
 136 {
 137   print_exited_reason (this->interp_ui_out (), status);
 138 }
 139
 140 void
 141 cli_interp_base::on_no_history ()
 142 {
 143   print_no_history_reason (this->interp_ui_out ());
 144 }
 145
 146 void
 147 cli_interp_base::on_sync_execution_done ()
 148 {
 149   display_gdb_prompt (NULL);
 150 }
 151
 152 void
 153 cli_interp_base::on_command_error ()
 154 {
 155   display_gdb_prompt (NULL);
 156 }
 157
 158 void
 159 cli_interp_base::on_user_selected_context_changed (user_selected_what selection)
 160 {
 161   /* This event is suppressed.  */
 162   if (cli_suppress_notification.user_selected_context)
 163     return;
 164
 165   thread_info *tp = inferior_ptid != null_ptid ? inferior_thread () : nullptr;
 166
 167   if (selection & USER_SELECTED_INFERIOR)
 168     print_selected_inferior (this->interp_ui_out ());
 169
 170   if (tp != nullptr
 171       && ((selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME))))
 172     print_selected_thread_frame (this->interp_ui_out (), selection);
 173 }
 174
 175 /* pre_command_loop implementation.  */
 176
 177 void
 178 cli_interp_base::pre_command_loop ()
 179 {
 180   display_gdb_prompt (0);
 181 }
 182
 183 /* These implement the cli out interpreter: */
 184
 185 void
 186 cli_interp::init (bool top_level)
 187 {
 188 }
 189
 190 void
 191 cli_interp::resume ()
 192 {
 193   struct ui *ui = current_ui;
 194   struct ui_file *stream;
 195
 196   /*sync_execution = 1; */
 197
 198   /* gdb_setup_readline will change gdb_stdout.  If the CLI was
 199      previously writing to gdb_stdout, then set it to the new
 200      gdb_stdout afterwards.  */
 201
 202   stream = m_cli_uiout->set_stream (gdb_stdout);
 203   if (stream != gdb_stdout)
 204     {
 205       m_cli_uiout->set_stream (stream);
 206       stream = NULL;
 207     }
 208
 209   gdb_setup_readline (1);
 210
 211   ui->input_handler = command_line_handler;
 212
 213   if (stream != NULL)
 214     m_cli_uiout->set_stream (gdb_stdout);
 215 }
 216
 217 void
 218 cli_interp::suspend ()
 219 {
 220   gdb_disable_readline ();
 221 }
 222
 223 void
 224 cli_interp::exec (const char *command_str)
 225 {
 226   /* gdb_stdout could change between the time m_cli_uiout was
 227      initialized and now.  Since we're probably using a different
 228      interpreter which has a new ui_file for gdb_stdout, use that one
 229      instead of the default.
 230
 231      It is important that it gets reset every time, since the user
 232      could set gdb to use a different interpreter.  */
 233   ui_file *old_stream = m_cli_uiout->set_stream (gdb_stdout);
 234   SCOPE_EXIT { m_cli_uiout->set_stream (old_stream); };
 235
 236   /* Save and override the global ``struct ui_out'' builder.  */
 237   scoped_restore saved_uiout = make_scoped_restore (&current_uiout,
 238                                                     m_cli_uiout.get ());
 239
 240   try
 241     {
 242       execute_command (command_str, 1);
 243     }
 244   catch (const gdb_exception_error &ex)
 245     {
 246       exception_print (gdb_stderr, ex);
 247       throw;
 248     }
 249 }
 250
 251 bool
 252 cli_interp_base::supports_command_editing ()
 253 {
 254   return true;
 255 }
 256
 257 ui_out *
 258 cli_interp::interp_ui_out ()
 259 {
 260   return m_cli_uiout.get ();
 261 }
 262
 263 /* See cli-interp.h.  */
 264
 265 void
 266 cli_interp_base::set_logging (ui_file_up logfile, bool logging_redirect,
 267                               bool debug_redirect)
 268 {
 269   if (logfile != nullptr)
 270     {
 271       gdb_assert (m_saved_output == nullptr);
 272       m_saved_output = std::make_unique<saved_output_files> ();
 273       m_saved_output->out = gdb_stdout;
 274       m_saved_output->err = gdb_stderr;
 275       m_saved_output->log = gdb_stdlog;
 276       m_saved_output->targ = gdb_stdtarg;
 277
 278       ui_file *logfile_p = logfile.get ();
 279       m_saved_output->logfile_holder = std::move (logfile);
 280
 281       /* The new stdout and stderr only depend on whether logging
 282          redirection is being done.  */
 283       ui_file *new_stdout = logfile_p;
 284       ui_file *new_stderr = logfile_p;
 285       if (!logging_redirect)
 286         {
 287           m_saved_output->stdout_holder.reset
 288             (new tee_file (gdb_stdout, logfile_p));
 289           new_stdout = m_saved_output->stdout_holder.get ();
 290           m_saved_output->stderr_holder.reset
 291             (new tee_file (gdb_stderr, logfile_p));
 292           new_stderr = m_saved_output->stderr_holder.get ();
 293         }
 294
 295       m_saved_output->stdlog_holder.reset
 296         (new timestamped_file (debug_redirect ? logfile_p : new_stderr));
 297
 298       gdb_stdout = new_stdout;
 299       gdb_stdlog = m_saved_output->stdlog_holder.get ();
 300       gdb_stderr = new_stderr;
 301       gdb_stdtarg = new_stderr;
 302     }
 303   else
 304     {
 305       gdb_stdout = m_saved_output->out;
 306       gdb_stderr = m_saved_output->err;
 307       gdb_stdlog = m_saved_output->log;
 308       gdb_stdtarg = m_saved_output->targ;
 309
 310       m_saved_output.reset (nullptr);
 311     }
 312 }
 313
 314 /* Factory for CLI interpreters.  */
 315
 316 static struct interp *
 317 cli_interp_factory (const char *name)
 318 {
 319   return new cli_interp (name);
 320 }
 321
 322 /* Standard gdb initialization hook.  */
 323
 324 void _initialize_cli_interp ();
 325 void
 326 _initialize_cli_interp ()
 327 {
 328   interp_factory_register (INTERP_CONSOLE, cli_interp_factory);
 329 }