gdb/tui/tui.c

   1 /* General functions for the WDB TUI.
   2
   3    Copyright (C) 1998-2023 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdbcmd.h"
  24 #include "tui/tui.h"
  25 #include "tui/tui-hooks.h"
  26 #include "tui/tui-command.h"
  27 #include "tui/tui-data.h"
  28 #include "tui/tui-layout.h"
  29 #include "tui/tui-io.h"
  30 #include "tui/tui-regs.h"
  31 #include "tui/tui-stack.h"
  32 #include "tui/tui-win.h"
  33 #include "tui/tui-wingeneral.h"
  34 #include "tui/tui-winsource.h"
  35 #include "tui/tui-source.h"
  36 #include "target.h"
  37 #include "frame.h"
  38 #include "breakpoint.h"
  39 #include "inferior.h"
  40 #include "symtab.h"
  41 #include "source.h"
  42 #include "terminal.h"
  43 #include "top.h"
  44
  45 #include <ctype.h>
  46 #include <signal.h>
  47 #include <fcntl.h>
  48 #include <setjmp.h>
  49
  50 #include "gdb_curses.h"
  51 #include "interps.h"
  52
  53 /* See tui.h.  */
  54
  55 bool debug_tui = false;
  56
  57 /* Implement 'show debug tui'.  */
  58
  59 static void
  60 show_tui_debug (struct ui_file *file, int from_tty,
  61                 struct cmd_list_element *c, const char *value)
  62 {
  63   gdb_printf (file, _("TUI debugging is \"%s\".\n"), value);
  64 }
  65
  66 /* This redefines CTRL if it is not already defined, so it must come
  67    after terminal state releated include files like <term.h> and
  68    "gdb_curses.h".  */
  69 #include "readline/readline.h"
  70
  71 /* Tells whether the TUI is active or not.  */
  72 bool tui_active = false;
  73 static bool tui_finish_init = true;
  74
  75 enum tui_key_mode tui_current_key_mode = TUI_COMMAND_MODE;
  76
  77 struct tui_char_command
  78 {
  79   unsigned char key;
  80   const char *cmd;
  81 };
  82
  83 /* Key mapping to gdb commands when the TUI is using the single key
  84    mode.  */
  85 static const struct tui_char_command tui_commands[] = {
  86   { 'c', "continue" },
  87   { 'd', "down" },
  88   { 'f', "finish" },
  89   { 'n', "next" },
  90   { 'o', "nexti" },
  91   { 'r', "run" },
  92   { 's', "step" },
  93   { 'i', "stepi" },
  94   { 'u', "up" },
  95   { 'v', "info locals" },
  96   { 'w', "where" },
  97   { 0, 0 },
  98 };
  99
 100 static Keymap tui_keymap;
 101 static Keymap tui_readline_standard_keymap;
 102
 103 /* TUI readline command.
 104    Switch the output mode between TUI/standard gdb.  */
 105 static int
 106 tui_rl_switch_mode (int notused1, int notused2)
 107 {
 108
 109   /* Don't let exceptions escape.  We're in the middle of a readline
 110      callback that isn't prepared for that.  */
 111   try
 112     {
 113       if (tui_active)
 114         {
 115           tui_disable ();
 116           rl_prep_terminal (0);
 117         }
 118       else
 119         {
 120           /* If tui_enable throws, we'll re-prep below.  */
 121           rl_deprep_terminal ();
 122           tui_enable ();
 123         }
 124     }
 125   catch (const gdb_exception &ex)
 126     {
 127       exception_print (gdb_stderr, ex);
 128
 129       if (!tui_active)
 130         rl_prep_terminal (0);
 131     }
 132
 133   /* Clear the readline in case switching occurred in middle of
 134      something.  */
 135   if (rl_end)
 136     rl_kill_text (0, rl_end);
 137
 138   /* Since we left the curses mode, the terminal mode is restored to
 139      some previous state.  That state may not be suitable for readline
 140      to work correctly (it may be restored in line mode).  We force an
 141      exit of the current readline so that readline is re-entered and
 142      it will be able to setup the terminal for its needs.  By
 143      re-entering in readline, we also redisplay its prompt in the
 144      non-curses mode.  */
 145   rl_newline (1, '\n');
 146
 147   /* Make sure the \n we are returning does not repeat the last
 148      command.  */
 149   dont_repeat ();
 150   return 0;
 151 }
 152
 153 /* TUI readline command.
 154    Change the TUI layout to show a next layout.
 155    This function is bound to CTRL-X 2.  It is intended to provide
 156    a functionality close to the Emacs split-window command.  */
 157 static int
 158 tui_rl_change_windows (int notused1, int notused2)
 159 {
 160   if (!tui_active)
 161     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 162
 163   if (tui_active)
 164     tui_next_layout ();
 165
 166   return 0;
 167 }
 168
 169 /* TUI readline command.
 170    Delete the second TUI window to only show one.  */
 171 static int
 172 tui_rl_delete_other_windows (int notused1, int notused2)
 173 {
 174   if (!tui_active)
 175     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 176
 177   if (tui_active)
 178     tui_remove_some_windows ();
 179
 180   return 0;
 181 }
 182
 183 /* TUI readline command.
 184    Switch the active window to give the focus to a next window.  */
 185 static int
 186 tui_rl_other_window (int count, int key)
 187 {
 188   struct tui_win_info *win_info;
 189
 190   if (!tui_active)
 191     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 192
 193   win_info = tui_next_win (tui_win_with_focus ());
 194   if (win_info)
 195     tui_set_win_focus_to (win_info);
 196   return 0;
 197 }
 198
 199 /* TUI readline command.
 200    Execute the gdb command bound to the specified key.  */
 201 static int
 202 tui_rl_command_key (int count, int key)
 203 {
 204   int i;
 205
 206   reinitialize_more_filter ();
 207   for (i = 0; tui_commands[i].cmd; i++)
 208     {
 209       if (tui_commands[i].key == key)
 210         {
 211           /* Insert the command in the readline buffer.
 212              Avoid calling the gdb command here since it creates
 213              a possible recursion on readline if prompt_for_continue
 214              is called (See PR 9584).  The command will also appear
 215              in the readline history which turns out to be better.  */
 216           rl_insert_text (tui_commands[i].cmd);
 217           rl_newline (1, '\n');
 218
 219           /* Switch to gdb command mode while executing the command.
 220              This way the gdb's continue prompty will be displayed.  */
 221           tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 222           return 0;
 223         }
 224     }
 225   return 0;
 226 }
 227
 228 /* TUI readline command.
 229    Temporarily leave the TUI SingleKey mode to allow editing
 230    a gdb command with the normal readline.  Once the command
 231    is executed, the TUI SingleKey mode is installed back.  */
 232 static int
 233 tui_rl_command_mode (int count, int key)
 234 {
 235   tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 236   return rl_insert (count, key);
 237 }
 238
 239 /* TUI readline command.
 240    Switch between TUI SingleKey mode and gdb readline editing.  */
 241 static int
 242 tui_rl_next_keymap (int notused1, int notused2)
 243 {
 244   if (!tui_active)
 245     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 246
 247   tui_set_key_mode (tui_current_key_mode == TUI_COMMAND_MODE
 248                     ? TUI_SINGLE_KEY_MODE : TUI_COMMAND_MODE);
 249   return 0;
 250 }
 251
 252 /* Readline hook to redisplay ourself the gdb prompt.
 253    In the SingleKey mode, the prompt is not printed so that
 254    the command window is cleaner.  It will be displayed if
 255    we temporarily leave the SingleKey mode.  */
 256 static int
 257 tui_rl_startup_hook (void)
 258 {
 259   rl_already_prompted = 1;
 260   if (tui_current_key_mode != TUI_COMMAND_MODE
 261       && !gdb_in_secondary_prompt_p (current_ui))
 262     tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 263   tui_redisplay_readline ();
 264   return 0;
 265 }
 266
 267 /* Change the TUI key mode by installing the appropriate readline
 268    keymap.  */
 269 void
 270 tui_set_key_mode (enum tui_key_mode mode)
 271 {
 272   tui_current_key_mode = mode;
 273   rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
 274                  ? tui_keymap : tui_readline_standard_keymap);
 275   tui_show_locator_content ();
 276 }
 277
 278 /* Initialize readline and configure the keymap for the switching
 279    key shortcut.  */
 280 void
 281 tui_ensure_readline_initialized ()
 282 {
 283   static bool initialized;
 284
 285   if (initialized)
 286     return;
 287   initialized = true;
 288
 289   int i;
 290   Keymap tui_ctlx_keymap;
 291
 292   rl_add_defun ("tui-switch-mode", tui_rl_switch_mode, -1);
 293   rl_add_defun ("next-keymap", tui_rl_next_keymap, -1);
 294   rl_add_defun ("tui-delete-other-windows", tui_rl_delete_other_windows, -1);
 295   rl_add_defun ("tui-change-windows", tui_rl_change_windows, -1);
 296   rl_add_defun ("tui-other-window", tui_rl_other_window, -1);
 297
 298   tui_keymap = rl_make_bare_keymap ();
 299
 300   /* The named keymap feature was added in Readline 8.0.  */
 301 #if RL_READLINE_VERSION >= 0x800
 302   rl_set_keymap_name ("SingleKey", tui_keymap);
 303 #endif
 304
 305   tui_ctlx_keymap = rl_make_bare_keymap ();
 306   tui_readline_standard_keymap = rl_get_keymap ();
 307
 308   for (i = 0; tui_commands[i].cmd; i++)
 309     rl_bind_key_in_map (tui_commands[i].key, tui_rl_command_key, tui_keymap);
 310
 311   rl_generic_bind (ISKMAP, "\\C-x", (char*) tui_ctlx_keymap, tui_keymap);
 312
 313   /* Bind all other keys to tui_rl_command_mode so that we switch
 314      temporarily from SingleKey mode and can enter a gdb command.  */
 315   for (i = ' '; i < 0x7f; i++)
 316     {
 317       int j;
 318
 319       for (j = 0; tui_commands[j].cmd; j++)
 320         if (tui_commands[j].key == i)
 321           break;
 322
 323       if (tui_commands[j].cmd)
 324         continue;
 325
 326       rl_bind_key_in_map (i, tui_rl_command_mode, tui_keymap);
 327     }
 328
 329   rl_bind_key_in_map ('a', tui_rl_switch_mode, emacs_ctlx_keymap);
 330   rl_bind_key_in_map ('a', tui_rl_switch_mode, tui_ctlx_keymap);
 331   rl_bind_key_in_map ('A', tui_rl_switch_mode, emacs_ctlx_keymap);
 332   rl_bind_key_in_map ('A', tui_rl_switch_mode, tui_ctlx_keymap);
 333   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, emacs_ctlx_keymap);
 334   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, tui_ctlx_keymap);
 335   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, emacs_ctlx_keymap);
 336   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, tui_ctlx_keymap);
 337   rl_bind_key_in_map ('2', tui_rl_change_windows, emacs_ctlx_keymap);
 338   rl_bind_key_in_map ('2', tui_rl_change_windows, tui_ctlx_keymap);
 339   rl_bind_key_in_map ('o', tui_rl_other_window, emacs_ctlx_keymap);
 340   rl_bind_key_in_map ('o', tui_rl_other_window, tui_ctlx_keymap);
 341   rl_bind_key_in_map ('q', tui_rl_next_keymap, tui_keymap);
 342   rl_bind_key_in_map ('s', tui_rl_next_keymap, emacs_ctlx_keymap);
 343   rl_bind_key_in_map ('s', tui_rl_next_keymap, tui_ctlx_keymap);
 344
 345   /* Initialize readline after the above.  */
 346   rl_initialize ();
 347 }
 348
 349 /* Return the TERM variable from the environment, or "<unset>"
 350    if not set.  */
 351
 352 static const char *
 353 gdb_getenv_term (void)
 354 {
 355   const char *term;
 356
 357   term = getenv ("TERM");
 358   if (term != NULL)
 359     return term;
 360   return "<unset>";
 361 }
 362
 363 /* Enter in the tui mode (curses).
 364    When in normal mode, it installs the tui hooks in gdb, redirects
 365    the gdb output, configures the readline to work in tui mode.
 366    When in curses mode, it does nothing.  */
 367 void
 368 tui_enable (void)
 369 {
 370   TUI_SCOPED_DEBUG_ENTER_EXIT;
 371
 372   if (tui_active)
 373     return;
 374
 375   /* To avoid to initialize curses when gdb starts, there is a deferred
 376      curses initialization.  This initialization is made only once
 377      and the first time the curses mode is entered.  */
 378   if (tui_finish_init)
 379     {
 380       WINDOW *w;
 381       SCREEN *s;
 382 #ifndef __MINGW32__
 383        const char *cap;
 384 #endif
 385       const char *interp;
 386
 387       /* If the top level interpreter is not the console/tui (e.g.,
 388          MI), enabling curses will certainly lose.  */
 389       interp = top_level_interpreter ()->name ();
 390       if (strcmp (interp, INTERP_TUI) != 0)
 391         error (_("Cannot enable the TUI when the interpreter is '%s'"), interp);
 392
 393       /* Don't try to setup curses (and print funny control
 394          characters) if we're not outputting to a terminal.  */
 395       if (!gdb_stderr->isatty ())
 396         error (_("Cannot enable the TUI when output is not a terminal"));
 397
 398       s = newterm (NULL, stdout, stdin);
 399 #ifdef __MINGW32__
 400       /* The MinGW port of ncurses requires $TERM to be unset in order
 401          to activate the Windows console driver.  */
 402       if (s == NULL)
 403         s = newterm ((char *) "unknown", stdout, stdin);
 404 #endif
 405       if (s == NULL)
 406         {
 407           error (_("Cannot enable the TUI: error opening terminal [TERM=%s]"),
 408                  gdb_getenv_term ());
 409         }
 410       w = stdscr;
 411       if (has_colors ())
 412         {
 413 #ifdef HAVE_USE_DEFAULT_COLORS
 414           /* Ncurses extension to help with resetting to the default
 415              color.  */
 416           use_default_colors ();
 417 #endif
 418           start_color ();
 419         }
 420
 421       /* Check required terminal capabilities.  The MinGW port of
 422          ncurses does have them, but doesn't expose them through "cup".  */
 423 #ifndef __MINGW32__
 424       cap = tigetstr ((char *) "cup");
 425       if (cap == NULL || cap == (char *) -1 || *cap == '\0')
 426         {
 427           endwin ();
 428           delscreen (s);
 429           error (_("Cannot enable the TUI: "
 430                    "terminal doesn't support cursor addressing [TERM=%s]"),
 431                  gdb_getenv_term ());
 432         }
 433 #endif
 434
 435       /* We must mark the tui sub-system active before trying to setup the
 436          current layout as tui windows defined by an extension language
 437          rely on this flag being true in order to know that the window
 438          they are creating is currently valid.  */
 439       tui_active = true;
 440
 441       cbreak ();
 442       noecho ();
 443       /* timeout (1); */
 444       nodelay(w, FALSE);
 445       nl();
 446       keypad (w, TRUE);
 447       tui_set_term_height_to (LINES);
 448       tui_set_term_width_to (COLS);
 449       def_prog_mode ();
 450
 451       tui_show_frame_info (0);
 452       tui_set_initial_layout ();
 453       tui_set_win_focus_to (TUI_SRC_WIN);
 454       keypad (TUI_CMD_WIN->handle.get (), TRUE);
 455       wrefresh (TUI_CMD_WIN->handle.get ());
 456       tui_finish_init = false;
 457     }
 458   else
 459     {
 460       /* Save the current gdb setting of the terminal.
 461          Curses will restore this state when endwin() is called.  */
 462       def_shell_mode ();
 463       clearok (stdscr, TRUE);
 464
 465       tui_active = true;
 466     }
 467
 468   gdb_assert (tui_active);
 469
 470   if (tui_update_variables ())
 471     tui_rehighlight_all ();
 472
 473   tui_setup_io (1);
 474
 475   /* Resize windows before anything might display/refresh a
 476      window.  */
 477   if (tui_win_resized ())
 478     {
 479       tui_set_win_resized_to (false);
 480       tui_resize_all ();
 481     }
 482
 483   if (deprecated_safe_get_selected_frame ())
 484     tui_show_frame_info (deprecated_safe_get_selected_frame ());
 485   else
 486     tui_display_main ();
 487
 488   /* Install the TUI specific hooks.  This must be done after the call to
 489      tui_display_main so that we don't detect the symtab changed event it
 490      can cause.  */
 491   tui_install_hooks ();
 492   rl_startup_hook = tui_rl_startup_hook;
 493
 494   /* Restore TUI keymap.  */
 495   tui_set_key_mode (tui_current_key_mode);
 496
 497   /* Refresh the screen.  */
 498   tui_refresh_all_win ();
 499
 500   /* Update gdb's knowledge of its terminal.  */
 501   gdb_save_tty_state ();
 502   tui_update_gdb_sizes ();
 503 }
 504
 505 /* Leave the tui mode.
 506    Remove the tui hooks and configure the gdb output and readline
 507    back to their original state.  The curses mode is left so that
 508    the terminal setting is restored to the point when we entered.  */
 509 void
 510 tui_disable (void)
 511 {
 512   TUI_SCOPED_DEBUG_ENTER_EXIT;
 513
 514   if (!tui_active)
 515     return;
 516
 517   /* Restore initial readline keymap.  */
 518   rl_set_keymap (tui_readline_standard_keymap);
 519
 520   /* Remove TUI hooks.  */
 521   tui_remove_hooks ();
 522   rl_startup_hook = 0;
 523   rl_already_prompted = 0;
 524
 525 #ifdef NCURSES_MOUSE_VERSION
 526   mousemask (0, NULL);
 527 #endif
 528
 529   /* Leave curses and restore previous gdb terminal setting.  */
 530   endwin ();
 531
 532   /* gdb terminal has changed, update gdb internal copy of it
 533      so that terminal management with the inferior works.  */
 534   tui_setup_io (0);
 535
 536   /* Update gdb's knowledge of its terminal.  */
 537   gdb_save_tty_state ();
 538
 539   tui_active = false;
 540   tui_update_gdb_sizes ();
 541 }
 542
 543 /* Command wrapper for enabling tui mode.  */
 544
 545 static void
 546 tui_enable_command (const char *args, int from_tty)
 547 {
 548   tui_enable ();
 549 }
 550
 551 /* Command wrapper for leaving tui mode.  */
 552
 553 static void
 554 tui_disable_command (const char *args, int from_tty)
 555 {
 556   tui_disable ();
 557 }
 558
 559 void
 560 tui_show_assembly (struct gdbarch *gdbarch, CORE_ADDR addr)
 561 {
 562   tui_suppress_output suppress;
 563   tui_add_win_to_layout (DISASSEM_WIN);
 564   tui_update_source_windows_with_addr (gdbarch, addr);
 565 }
 566
 567 bool
 568 tui_is_window_visible (enum tui_win_type type)
 569 {
 570   if (!tui_active)
 571     return false;
 572
 573   if (tui_win_list[type] == nullptr)
 574     return false;
 575
 576   return tui_win_list[type]->is_visible ();
 577 }
 578
 579 bool
 580 tui_get_command_dimension (unsigned int *width,
 581                            unsigned int *height)
 582 {
 583   if (!tui_active || (TUI_CMD_WIN == NULL))
 584     return false;
 585
 586   *width = TUI_CMD_WIN->width;
 587   *height = TUI_CMD_WIN->height;
 588   return true;
 589 }
 590
 591 void _initialize_tui ();
 592 void
 593 _initialize_tui ()
 594 {
 595   struct cmd_list_element **tuicmd;
 596
 597   tuicmd = tui_get_cmd_list ();
 598
 599   add_cmd ("enable", class_tui, tui_enable_command,
 600            _("Enable TUI display mode.\n\
 601 Usage: tui enable"),
 602            tuicmd);
 603   add_cmd ("disable", class_tui, tui_disable_command,
 604            _("Disable TUI display mode.\n\
 605 Usage: tui disable"),
 606            tuicmd);
 607
 608   /* Debug this tui internals.  */
 609   add_setshow_boolean_cmd ("tui", class_maintenance, &debug_tui,  _("\
 610 Set tui debugging."), _("\
 611 Show tui debugging."), _("\
 612 When true, tui specific internal debugging is enabled."),
 613                            NULL,
 614                            show_tui_debug,
 615                            &setdebuglist, &showdebuglist);
 616 }