gdb/cli/cli-interp.c

   1 /* CLI Definitions for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2018 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 "defs.h"
  21 #include "cli-interp.h"
  22 #include "interps.h"
  23 #include "event-top.h"
  24 #include "ui-out.h"
  25 #include "cli-out.h"
  26 #include "top.h"                /* for "execute_command" */
  27 #include "event-top.h"
  28 #include "infrun.h"
  29 #include "observable.h"
  30 #include "gdbthread.h"
  31 #include "thread-fsm.h"
  32
  33 cli_interp_base::cli_interp_base (const char *name)
  34   : interp (name)
  35 {}
  36
  37 cli_interp_base::~cli_interp_base ()
  38 {}
  39
  40 /* The console interpreter.  */
  41
  42 class cli_interp final : public cli_interp_base
  43 {
  44  public:
  45   explicit cli_interp (const char *name);
  46
  47   void init (bool top_level) override;
  48   void resume () override;
  49   void suspend () override;
  50   gdb_exception exec (const char *command_str) override;
  51   ui_out *interp_ui_out () override;
  52
  53   /* The ui_out for the console interpreter.  */
  54   cli_ui_out *cli_uiout;
  55 };
  56
  57 cli_interp::cli_interp (const char *name)
  58   : cli_interp_base (name)
  59 {
  60   /* Create a default uiout builder for the CLI.  */
  61   this->cli_uiout = cli_out_new (gdb_stdout);
  62 }
  63
  64 /* Suppress notification struct.  */
  65 struct cli_suppress_notification cli_suppress_notification =
  66   {
  67     0   /* user_selected_context_changed */
  68   };
  69
  70 /* Returns the INTERP's data cast as cli_interp if INTERP is a CLI,
  71    and returns NULL otherwise.  */
  72
  73 static struct cli_interp *
  74 as_cli_interp (struct interp *interp)
  75 {
  76   if (strcmp (interp_name (interp), INTERP_CONSOLE) == 0)
  77     return (struct cli_interp *) interp;
  78   return NULL;
  79 }
  80
  81 /* Longjmp-safe wrapper for "execute_command".  */
  82 static struct gdb_exception safe_execute_command (struct ui_out *uiout,
  83                                                   const char *command,
  84                                                   int from_tty);
  85
  86 /* See cli-interp.h.
  87
  88    Breakpoint hits should always be mirrored to a console.  Deciding
  89    what to mirror to a console wrt to breakpoints and random stops
  90    gets messy real fast.  E.g., say "s" trips on a breakpoint.  We'd
  91    clearly want to mirror the event to the console in this case.  But
  92    what about more complicated cases like "s&; thread n; s&", and one
  93    of those steps spawning a new thread, and that thread hitting a
  94    breakpoint?  It's impossible in general to track whether the thread
  95    had any relation to the commands that had been executed.  So we
  96    just simplify and always mirror breakpoints and random events to
  97    all consoles.
  98
  99    OTOH, we should print the source line to the console when stepping
 100    or other similar commands, iff the step was started by that console
 101    (or in MI's case, by a console command), but not if it was started
 102    with MI's -exec-step or similar.  */
 103
 104 int
 105 should_print_stop_to_console (struct interp *console_interp,
 106                               struct thread_info *tp)
 107 {
 108   if ((bpstat_what (tp->control.stop_bpstat).main_action
 109        == BPSTAT_WHAT_STOP_NOISY)
 110       || tp->thread_fsm == NULL
 111       || tp->thread_fsm->command_interp == console_interp
 112       || !thread_fsm_finished_p (tp->thread_fsm))
 113     return 1;
 114   return 0;
 115 }
 116
 117 /* Observers for several run control events.  If the interpreter is
 118    quiet (i.e., another interpreter is being run with
 119    interpreter-exec), print nothing.  */
 120
 121 /* Observer for the normal_stop notification.  */
 122
 123 static void
 124 cli_on_normal_stop (struct bpstats *bs, int print_frame)
 125 {
 126   if (!print_frame)
 127     return;
 128
 129   SWITCH_THRU_ALL_UIS ()
 130     {
 131       struct interp *interp = top_level_interpreter ();
 132       struct cli_interp *cli = as_cli_interp (interp);
 133       struct thread_info *thread;
 134
 135       if (cli == NULL)
 136         continue;
 137
 138       thread = inferior_thread ();
 139       if (should_print_stop_to_console (interp, thread))
 140         print_stop_event (cli->cli_uiout);
 141     }
 142 }
 143
 144 /* Observer for the signal_received notification.  */
 145
 146 static void
 147 cli_on_signal_received (enum gdb_signal siggnal)
 148 {
 149   SWITCH_THRU_ALL_UIS ()
 150     {
 151       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 152
 153       if (cli == NULL)
 154         continue;
 155
 156       print_signal_received_reason (cli->cli_uiout, siggnal);
 157     }
 158 }
 159
 160 /* Observer for the end_stepping_range notification.  */
 161
 162 static void
 163 cli_on_end_stepping_range (void)
 164 {
 165   SWITCH_THRU_ALL_UIS ()
 166     {
 167       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 168
 169       if (cli == NULL)
 170         continue;
 171
 172       print_end_stepping_range_reason (cli->cli_uiout);
 173     }
 174 }
 175
 176 /* Observer for the signalled notification.  */
 177
 178 static void
 179 cli_on_signal_exited (enum gdb_signal siggnal)
 180 {
 181   SWITCH_THRU_ALL_UIS ()
 182     {
 183       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 184
 185       if (cli == NULL)
 186         continue;
 187
 188       print_signal_exited_reason (cli->cli_uiout, siggnal);
 189     }
 190 }
 191
 192 /* Observer for the exited notification.  */
 193
 194 static void
 195 cli_on_exited (int exitstatus)
 196 {
 197   SWITCH_THRU_ALL_UIS ()
 198     {
 199       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 200
 201       if (cli == NULL)
 202         continue;
 203
 204       print_exited_reason (cli->cli_uiout, exitstatus);
 205     }
 206 }
 207
 208 /* Observer for the no_history notification.  */
 209
 210 static void
 211 cli_on_no_history (void)
 212 {
 213   SWITCH_THRU_ALL_UIS ()
 214     {
 215       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 216
 217       if (cli == NULL)
 218         continue;
 219
 220       print_no_history_reason (cli->cli_uiout);
 221     }
 222 }
 223
 224 /* Observer for the sync_execution_done notification.  */
 225
 226 static void
 227 cli_on_sync_execution_done (void)
 228 {
 229   struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 230
 231   if (cli == NULL)
 232     return;
 233
 234   display_gdb_prompt (NULL);
 235 }
 236
 237 /* Observer for the command_error notification.  */
 238
 239 static void
 240 cli_on_command_error (void)
 241 {
 242   struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 243
 244   if (cli == NULL)
 245     return;
 246
 247   display_gdb_prompt (NULL);
 248 }
 249
 250 /* Observer for the user_selected_context_changed notification.  */
 251
 252 static void
 253 cli_on_user_selected_context_changed (user_selected_what selection)
 254 {
 255   struct thread_info *tp;
 256
 257   /* This event is suppressed.  */
 258   if (cli_suppress_notification.user_selected_context)
 259     return;
 260
 261   tp = find_thread_ptid (inferior_ptid);
 262
 263   SWITCH_THRU_ALL_UIS ()
 264     {
 265       struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
 266
 267       if (cli == NULL)
 268         continue;
 269
 270       if (selection & USER_SELECTED_INFERIOR)
 271         print_selected_inferior (cli->cli_uiout);
 272
 273       if (tp != NULL
 274           && ((selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME))))
 275         print_selected_thread_frame (cli->cli_uiout, selection);
 276     }
 277 }
 278
 279 /* pre_command_loop implementation.  */
 280
 281 void
 282 cli_interp_base::pre_command_loop ()
 283 {
 284   display_gdb_prompt (0);
 285 }
 286
 287 /* These implement the cli out interpreter: */
 288
 289 void
 290 cli_interp::init (bool top_level)
 291 {
 292 }
 293
 294 void
 295 cli_interp::resume ()
 296 {
 297   struct ui *ui = current_ui;
 298   struct cli_interp *cli = this;
 299   struct ui_file *stream;
 300
 301   /*sync_execution = 1; */
 302
 303   /* gdb_setup_readline will change gdb_stdout.  If the CLI was
 304      previously writing to gdb_stdout, then set it to the new
 305      gdb_stdout afterwards.  */
 306
 307   stream = cli->cli_uiout->set_stream (gdb_stdout);
 308   if (stream != gdb_stdout)
 309     {
 310       cli->cli_uiout->set_stream (stream);
 311       stream = NULL;
 312     }
 313
 314   gdb_setup_readline (1);
 315
 316   ui->input_handler = command_line_handler;
 317
 318   if (stream != NULL)
 319     cli->cli_uiout->set_stream (gdb_stdout);
 320 }
 321
 322 void
 323 cli_interp::suspend ()
 324 {
 325   gdb_disable_readline ();
 326 }
 327
 328 gdb_exception
 329 cli_interp::exec (const char *command_str)
 330 {
 331   struct cli_interp *cli = this;
 332   struct ui_file *old_stream;
 333   struct gdb_exception result;
 334
 335   /* gdb_stdout could change between the time cli_uiout was
 336      initialized and now.  Since we're probably using a different
 337      interpreter which has a new ui_file for gdb_stdout, use that one
 338      instead of the default.
 339
 340      It is important that it gets reset everytime, since the user
 341      could set gdb to use a different interpreter.  */
 342   old_stream = cli->cli_uiout->set_stream (gdb_stdout);
 343   result = safe_execute_command (cli->cli_uiout, command_str, 1);
 344   cli->cli_uiout->set_stream (old_stream);
 345   return result;
 346 }
 347
 348 bool
 349 cli_interp_base::supports_command_editing ()
 350 {
 351   return true;
 352 }
 353
 354 static struct gdb_exception
 355 safe_execute_command (struct ui_out *command_uiout, const char *command,
 356                       int from_tty)
 357 {
 358   struct gdb_exception e = exception_none;
 359   struct ui_out *saved_uiout;
 360
 361   /* Save and override the global ``struct ui_out'' builder.  */
 362   saved_uiout = current_uiout;
 363   current_uiout = command_uiout;
 364
 365   TRY
 366     {
 367       execute_command (command, from_tty);
 368     }
 369   CATCH (exception, RETURN_MASK_ALL)
 370     {
 371       e = exception;
 372     }
 373   END_CATCH
 374
 375   /* Restore the global builder.  */
 376   current_uiout = saved_uiout;
 377
 378   /* FIXME: cagney/2005-01-13: This shouldn't be needed.  Instead the
 379      caller should print the exception.  */
 380   exception_print (gdb_stderr, e);
 381   return e;
 382 }
 383
 384 ui_out *
 385 cli_interp::interp_ui_out ()
 386 {
 387   struct cli_interp *cli = (struct cli_interp *) this;
 388
 389   return cli->cli_uiout;
 390 }
 391
 392 /* These hold the pushed copies of the gdb output files.
 393    If NULL then nothing has yet been pushed.  */
 394 struct saved_output_files
 395 {
 396   ui_file *out;
 397   ui_file *err;
 398   ui_file *log;
 399   ui_file *targ;
 400   ui_file *targerr;
 401 };
 402 static saved_output_files saved_output;
 403
 404 /* See cli-interp.h.  */
 405
 406 void
 407 cli_interp_base::set_logging (ui_file_up logfile, bool logging_redirect)
 408 {
 409   if (logfile != NULL)
 410     {
 411       saved_output.out = gdb_stdout;
 412       saved_output.err = gdb_stderr;
 413       saved_output.log = gdb_stdlog;
 414       saved_output.targ = gdb_stdtarg;
 415       saved_output.targerr = gdb_stdtargerr;
 416
 417       /* A raw pointer since ownership is transferred to
 418          gdb_stdout.  */
 419       ui_file *output = make_logging_output (gdb_stdout,
 420                                              std::move (logfile),
 421                                              logging_redirect);
 422       gdb_stdout = output;
 423       gdb_stdlog = output;
 424       gdb_stderr = output;
 425       gdb_stdtarg = output;
 426       gdb_stdtargerr = output;
 427     }
 428   else
 429     {
 430       /* Only delete one of the files -- they are all set to the same
 431          value.  */
 432       delete gdb_stdout;
 433
 434       gdb_stdout = saved_output.out;
 435       gdb_stderr = saved_output.err;
 436       gdb_stdlog = saved_output.log;
 437       gdb_stdtarg = saved_output.targ;
 438       gdb_stdtargerr = saved_output.targerr;
 439
 440       saved_output.out = NULL;
 441       saved_output.err = NULL;
 442       saved_output.log = NULL;
 443       saved_output.targ = NULL;
 444       saved_output.targerr = NULL;
 445     }
 446 }
 447
 448 /* Factory for CLI interpreters.  */
 449
 450 static struct interp *
 451 cli_interp_factory (const char *name)
 452 {
 453   return new cli_interp (name);
 454 }
 455
 456 /* Standard gdb initialization hook.  */
 457
 458 void
 459 _initialize_cli_interp (void)
 460 {
 461   interp_factory_register (INTERP_CONSOLE, cli_interp_factory);
 462
 463   /* If changing this, remember to update tui-interp.c as well.  */
 464   gdb::observers::normal_stop.attach (cli_on_normal_stop);
 465   gdb::observers::end_stepping_range.attach (cli_on_end_stepping_range);
 466   gdb::observers::signal_received.attach (cli_on_signal_received);
 467   gdb::observers::signal_exited.attach (cli_on_signal_exited);
 468   gdb::observers::exited.attach (cli_on_exited);
 469   gdb::observers::no_history.attach (cli_on_no_history);
 470   gdb::observers::sync_execution_done.attach (cli_on_sync_execution_done);
 471   gdb::observers::command_error.attach (cli_on_command_error);
 472   gdb::observers::user_selected_context_changed.attach
 473     (cli_on_user_selected_context_changed);
 474 }