gdb/tui/tui.c

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