gdb/tui/tui.c

   1 /* General functions for the WDB TUI.
   2
   3    Copyright (C) 1998-2014 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-data.h"
  27 #include "tui/tui-layout.h"
  28 #include "tui/tui-io.h"
  29 #include "tui/tui-regs.h"
  30 #include "tui/tui-stack.h"
  31 #include "tui/tui-win.h"
  32 #include "tui/tui-winsource.h"
  33 #include "tui/tui-windata.h"
  34 #include "target.h"
  35 #include "frame.h"
  36 #include "breakpoint.h"
  37 #include "inferior.h"
  38 #include "symtab.h"
  39 #include "source.h"
  40 #include "terminal.h"
  41
  42 #include <ctype.h>
  43 #include <signal.h>
  44 #include <fcntl.h>
  45 #if 0
  46 #include <termio.h>
  47 #endif
  48 #include <setjmp.h>
  49
  50 #include "gdb_curses.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 int tui_active = 0;
  59 static int tui_finish_init = 1;
  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   { 'r', "run" },
  77   { 's', "step" },
  78   { 'u', "up" },
  79   { 'v', "info locals" },
  80   { 'w', "where" },
  81   { 0, 0 },
  82 };
  83
  84 static Keymap tui_keymap;
  85 static Keymap tui_readline_standard_keymap;
  86
  87 /* TUI readline command.
  88    Switch the output mode between TUI/standard gdb.  */
  89 static int
  90 tui_rl_switch_mode (int notused1, int notused2)
  91 {
  92   if (tui_active)
  93     {
  94       tui_disable ();
  95       rl_prep_terminal (0);
  96     }
  97   else
  98     {
  99       rl_deprep_terminal ();
 100       tui_enable ();
 101     }
 102
 103   /* Clear the readline in case switching occurred in middle of
 104      something.  */
 105   if (rl_end)
 106     rl_kill_text (0, rl_end);
 107
 108   /* Since we left the curses mode, the terminal mode is restored to
 109      some previous state.  That state may not be suitable for readline
 110      to work correctly (it may be restored in line mode).  We force an
 111      exit of the current readline so that readline is re-entered and
 112      it will be able to setup the terminal for its needs.  By
 113      re-entering in readline, we also redisplay its prompt in the
 114      non-curses mode.  */
 115   rl_newline (1, '\n');
 116
 117   /* Make sure the \n we are returning does not repeat the last
 118      command.  */
 119   dont_repeat ();
 120   return 0;
 121 }
 122
 123 /* TUI readline command.
 124    Change the TUI layout to show a next layout.
 125    This function is bound to CTRL-X 2.  It is intended to provide
 126    a functionality close to the Emacs split-window command.  We
 127    always show two windows (src+asm), (src+regs) or (asm+regs).  */
 128 static int
 129 tui_rl_change_windows (int notused1, int notused2)
 130 {
 131   if (!tui_active)
 132     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 133
 134   if (tui_active)
 135     {
 136       enum tui_layout_type new_layout;
 137       enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 138
 139       new_layout = tui_current_layout ();
 140
 141       /* Select a new layout to have a rolling layout behavior with
 142          always two windows (except when undefined).  */
 143       switch (new_layout)
 144         {
 145         case SRC_COMMAND:
 146           new_layout = SRC_DISASSEM_COMMAND;
 147           break;
 148
 149         case DISASSEM_COMMAND:
 150           new_layout = SRC_DISASSEM_COMMAND;
 151           break;
 152
 153         case SRC_DATA_COMMAND:
 154           new_layout = SRC_DISASSEM_COMMAND;
 155           break;
 156
 157         case SRC_DISASSEM_COMMAND:
 158           new_layout = DISASSEM_DATA_COMMAND;
 159           break;
 160
 161         case DISASSEM_DATA_COMMAND:
 162           new_layout = SRC_DATA_COMMAND;
 163           break;
 164
 165         default:
 166           new_layout = SRC_COMMAND;
 167           break;
 168         }
 169       tui_set_layout (new_layout, regs_type);
 170     }
 171   return 0;
 172 }
 173
 174 /* TUI readline command.
 175    Delete the second TUI window to only show one.  */
 176 static int
 177 tui_rl_delete_other_windows (int notused1, int notused2)
 178 {
 179   if (!tui_active)
 180     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 181
 182   if (tui_active)
 183     {
 184       enum tui_layout_type new_layout;
 185       enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 186
 187       new_layout = tui_current_layout ();
 188
 189       /* Kill one window.  */
 190       switch (new_layout)
 191         {
 192         case SRC_COMMAND:
 193         case SRC_DATA_COMMAND:
 194         case SRC_DISASSEM_COMMAND:
 195         default:
 196           new_layout = SRC_COMMAND;
 197           break;
 198
 199         case DISASSEM_COMMAND:
 200         case DISASSEM_DATA_COMMAND:
 201           new_layout = DISASSEM_COMMAND;
 202           break;
 203         }
 204       tui_set_layout (new_layout, regs_type);
 205     }
 206   return 0;
 207 }
 208
 209 /* TUI readline command.
 210    Switch the active window to give the focus to a next window.  */
 211 static int
 212 tui_rl_other_window (int count, int key)
 213 {
 214   struct tui_win_info *win_info;
 215
 216   if (!tui_active)
 217     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 218
 219   win_info = tui_next_win (tui_win_with_focus ());
 220   if (win_info)
 221     {
 222       tui_set_win_focus_to (win_info);
 223       if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
 224         tui_refresh_data_win ();
 225       keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
 226     }
 227   return 0;
 228 }
 229
 230 /* TUI readline command.
 231    Execute the gdb command bound to the specified key.  */
 232 static int
 233 tui_rl_command_key (int count, int key)
 234 {
 235   int i;
 236
 237   reinitialize_more_filter ();
 238   for (i = 0; tui_commands[i].cmd; i++)
 239     {
 240       if (tui_commands[i].key == key)
 241         {
 242           /* Insert the command in the readline buffer.
 243              Avoid calling the gdb command here since it creates
 244              a possible recursion on readline if prompt_for_continue
 245              is called (See PR 9584).  The command will also appear
 246              in the readline history which turns out to be better.  */
 247           rl_insert_text (tui_commands[i].cmd);
 248           rl_newline (1, '\n');
 249
 250           /* Switch to gdb command mode while executing the command.
 251              This way the gdb's continue prompty will be displayed.  */
 252           tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 253           return 0;
 254         }
 255     }
 256   return 0;
 257 }
 258
 259 /* TUI readline command.
 260    Temporarily leave the TUI SingleKey mode to allow editing
 261    a gdb command with the normal readline.  Once the command
 262    is executed, the TUI SingleKey mode is installed back.  */
 263 static int
 264 tui_rl_command_mode (int count, int key)
 265 {
 266   tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 267   return rl_insert (count, key);
 268 }
 269
 270 /* TUI readline command.
 271    Switch between TUI SingleKey mode and gdb readline editing.  */
 272 static int
 273 tui_rl_next_keymap (int notused1, int notused2)
 274 {
 275   if (!tui_active)
 276     tui_rl_switch_mode (0 /* notused */, 0 /* notused */);
 277
 278   tui_set_key_mode (tui_current_key_mode == TUI_COMMAND_MODE
 279                     ? TUI_SINGLE_KEY_MODE : TUI_COMMAND_MODE);
 280   return 0;
 281 }
 282
 283 /* Readline hook to redisplay ourself the gdb prompt.
 284    In the SingleKey mode, the prompt is not printed so that
 285    the command window is cleaner.  It will be displayed if
 286    we temporarily leave the SingleKey mode.  */
 287 static int
 288 tui_rl_startup_hook (void)
 289 {
 290   rl_already_prompted = 1;
 291   if (tui_current_key_mode != TUI_COMMAND_MODE && immediate_quit == 0)
 292     tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 293   tui_redisplay_readline ();
 294   return 0;
 295 }
 296
 297 /* Change the TUI key mode by installing the appropriate readline
 298    keymap.  */
 299 void
 300 tui_set_key_mode (enum tui_key_mode mode)
 301 {
 302   tui_current_key_mode = mode;
 303   rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
 304                  ? tui_keymap : tui_readline_standard_keymap);
 305   tui_show_locator_content ();
 306 }
 307
 308 /* Initialize readline and configure the keymap for the switching
 309    key shortcut.  */
 310 void
 311 tui_initialize_readline (void)
 312 {
 313   int i;
 314   Keymap tui_ctlx_keymap;
 315
 316   rl_initialize ();
 317
 318   rl_add_defun ("tui-switch-mode", tui_rl_switch_mode, -1);
 319   rl_add_defun ("gdb-command", tui_rl_command_key, -1);
 320   rl_add_defun ("next-keymap", tui_rl_next_keymap, -1);
 321
 322   tui_keymap = rl_make_bare_keymap ();
 323   tui_ctlx_keymap = rl_make_bare_keymap ();
 324   tui_readline_standard_keymap = rl_get_keymap ();
 325
 326   for (i = 0; tui_commands[i].cmd; i++)
 327     rl_bind_key_in_map (tui_commands[i].key, tui_rl_command_key, tui_keymap);
 328
 329   rl_generic_bind (ISKMAP, "\\C-x", (char*) tui_ctlx_keymap, tui_keymap);
 330
 331   /* Bind all other keys to tui_rl_command_mode so that we switch
 332      temporarily from SingleKey mode and can enter a gdb command.  */
 333   for (i = ' '; i < 0x7f; i++)
 334     {
 335       int j;
 336
 337       for (j = 0; tui_commands[j].cmd; j++)
 338         if (tui_commands[j].key == i)
 339           break;
 340
 341       if (tui_commands[j].cmd)
 342         continue;
 343
 344       rl_bind_key_in_map (i, tui_rl_command_mode, tui_keymap);
 345     }
 346
 347   rl_bind_key_in_map ('a', tui_rl_switch_mode, emacs_ctlx_keymap);
 348   rl_bind_key_in_map ('a', tui_rl_switch_mode, tui_ctlx_keymap);
 349   rl_bind_key_in_map ('A', tui_rl_switch_mode, emacs_ctlx_keymap);
 350   rl_bind_key_in_map ('A', tui_rl_switch_mode, tui_ctlx_keymap);
 351   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, emacs_ctlx_keymap);
 352   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, tui_ctlx_keymap);
 353   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, emacs_ctlx_keymap);
 354   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, tui_ctlx_keymap);
 355   rl_bind_key_in_map ('2', tui_rl_change_windows, emacs_ctlx_keymap);
 356   rl_bind_key_in_map ('2', tui_rl_change_windows, tui_ctlx_keymap);
 357   rl_bind_key_in_map ('o', tui_rl_other_window, emacs_ctlx_keymap);
 358   rl_bind_key_in_map ('o', tui_rl_other_window, tui_ctlx_keymap);
 359   rl_bind_key_in_map ('q', tui_rl_next_keymap, tui_keymap);
 360   rl_bind_key_in_map ('s', tui_rl_next_keymap, emacs_ctlx_keymap);
 361   rl_bind_key_in_map ('s', tui_rl_next_keymap, tui_ctlx_keymap);
 362 }
 363
 364 /* Enter in the tui mode (curses).
 365    When in normal mode, it installs the tui hooks in gdb, redirects
 366    the gdb output, configures the readline to work in tui mode.
 367    When in curses mode, it does nothing.  */
 368 void
 369 tui_enable (void)
 370 {
 371   if (!tui_allowed_p ())
 372     error (_("TUI mode not allowed"));
 373
 374   if (tui_active)
 375     return;
 376
 377   /* To avoid to initialize curses when gdb starts, there is a defered
 378      curses initialization.  This initialization is made only once
 379      and the first time the curses mode is entered.  */
 380   if (tui_finish_init)
 381     {
 382       WINDOW *w;
 383
 384       w = initscr ();
 385
 386       cbreak ();
 387       noecho ();
 388       /* timeout (1); */
 389       nodelay(w, FALSE);
 390       nl();
 391       keypad (w, TRUE);
 392       rl_initialize ();
 393       tui_set_term_height_to (LINES);
 394       tui_set_term_width_to (COLS);
 395       def_prog_mode ();
 396
 397       tui_show_frame_info (0);
 398       tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
 399       tui_set_win_focus_to (TUI_SRC_WIN);
 400       keypad (TUI_CMD_WIN->generic.handle, TRUE);
 401       wrefresh (TUI_CMD_WIN->generic.handle);
 402       tui_finish_init = 0;
 403     }
 404   else
 405     {
 406      /* Save the current gdb setting of the terminal.
 407         Curses will restore this state when endwin() is called.  */
 408      def_shell_mode ();
 409      clearok (stdscr, TRUE);
 410    }
 411
 412   /* Install the TUI specific hooks.  */
 413   tui_install_hooks ();
 414   rl_startup_hook = tui_rl_startup_hook;
 415
 416   tui_update_variables ();
 417
 418   tui_setup_io (1);
 419
 420   tui_active = 1;
 421   if (deprecated_safe_get_selected_frame ())
 422      tui_show_frame_info (deprecated_safe_get_selected_frame ());
 423
 424   /* Restore TUI keymap.  */
 425   tui_set_key_mode (tui_current_key_mode);
 426   tui_refresh_all_win ();
 427
 428   /* Update gdb's knowledge of its terminal.  */
 429   gdb_save_tty_state ();
 430   tui_update_gdb_sizes ();
 431 }
 432
 433 /* Leave the tui mode.
 434    Remove the tui hooks and configure the gdb output and readline
 435    back to their original state.  The curses mode is left so that
 436    the terminal setting is restored to the point when we entered.  */
 437 void
 438 tui_disable (void)
 439 {
 440   if (!tui_active)
 441     return;
 442
 443   /* Restore initial readline keymap.  */
 444   rl_set_keymap (tui_readline_standard_keymap);
 445
 446   /* Remove TUI hooks.  */
 447   tui_remove_hooks ();
 448   rl_startup_hook = 0;
 449   rl_already_prompted = 0;
 450
 451   /* Leave curses and restore previous gdb terminal setting.  */
 452   endwin ();
 453
 454   /* gdb terminal has changed, update gdb internal copy of it
 455      so that terminal management with the inferior works.  */
 456   tui_setup_io (0);
 457
 458   /* Update gdb's knowledge of its terminal.  */
 459   gdb_save_tty_state ();
 460
 461   tui_active = 0;
 462   tui_update_gdb_sizes ();
 463 }
 464
 465 void
 466 strcat_to_buf (char *buf, int buflen,
 467                const char *item_to_add)
 468 {
 469   if (item_to_add != (char *) NULL && buf != (char *) NULL)
 470     {
 471       if ((strlen (buf) + strlen (item_to_add)) <= buflen)
 472         strcat (buf, item_to_add);
 473       else
 474         strncat (buf, item_to_add, (buflen - strlen (buf)));
 475     }
 476 }
 477
 478 #if 0
 479 /* Solaris <sys/termios.h> defines CTRL.  */
 480 #ifndef CTRL
 481 #define CTRL(x)         (x & ~0140)
 482 #endif
 483
 484 #define FILEDES         2
 485 #define CHK(val, dft)   (val<=0 ? dft : val)
 486
 487 static void
 488 tui_reset (void)
 489 {
 490   struct termio mode;
 491
 492   /* Reset the teletype mode bits to a sensible state.
 493      Copied tset.c.  */
 494 #if defined (TIOCGETC)
 495   struct tchars tbuf;
 496 #endif /* TIOCGETC */
 497 #ifdef UCB_NTTY
 498   struct ltchars ltc;
 499
 500   if (ldisc == NTTYDISC)
 501     {
 502       ioctl (FILEDES, TIOCGLTC, &ltc);
 503       ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
 504       ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
 505       ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
 506       ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
 507       ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
 508       ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
 509       ioctl (FILEDES, TIOCSLTC, &ltc);
 510     }
 511 #endif /* UCB_NTTY */
 512 #ifdef TIOCGETC
 513   ioctl (FILEDES, TIOCGETC, &tbuf);
 514   tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
 515   tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
 516   tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
 517   tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
 518   tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
 519   /* brkc is left alone.  */
 520   ioctl (FILEDES, TIOCSETC, &tbuf);
 521 #endif /* TIOCGETC */
 522   mode.sg_flags &= ~(RAW
 523 #ifdef CBREAK
 524                      | CBREAK
 525 #endif /* CBREAK */
 526                      | VTDELAY | ALLDELAY);
 527   mode.sg_flags |= XTABS | ECHO | CRMOD | ANYP;
 528
 529   return;
 530 }
 531 #endif
 532
 533 void
 534 tui_show_source (const char *fullname, int line)
 535 {
 536   struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 537
 538   /* Make sure that the source window is displayed.  */
 539   tui_add_win_to_layout (SRC_WIN);
 540
 541   tui_update_source_windows_with_line (cursal.symtab, line);
 542   tui_update_locator_fullname (fullname);
 543 }
 544
 545 void
 546 tui_show_assembly (struct gdbarch *gdbarch, CORE_ADDR addr)
 547 {
 548   tui_add_win_to_layout (DISASSEM_WIN);
 549   tui_update_source_windows_with_addr (gdbarch, addr);
 550 }
 551
 552 int
 553 tui_is_window_visible (enum tui_win_type type)
 554 {
 555   if (tui_active == 0)
 556     return 0;
 557
 558   if (tui_win_list[type] == 0)
 559     return 0;
 560
 561   return tui_win_list[type]->generic.is_visible;
 562 }
 563
 564 int
 565 tui_get_command_dimension (unsigned int *width,
 566                            unsigned int *height)
 567 {
 568   if (!tui_active || (TUI_CMD_WIN == NULL))
 569     {
 570       return 0;
 571     }
 572
 573   *width = TUI_CMD_WIN->generic.width;
 574   *height = TUI_CMD_WIN->generic.height;
 575   return 1;
 576 }