gdb/tui/tui.c

   1 /* General functions for the WDB TUI.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
   4    Foundation, Inc.
   5
   6    Contributed by Hewlett-Packard Company.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <ctype.h>
  28 #ifdef HAVE_TERM_H
  29 #include <term.h>
  30 #endif
  31 #include <signal.h>
  32 #include <fcntl.h>
  33 #if 0
  34 #include <termio.h>
  35 #endif
  36 #include <setjmp.h>
  37 #include "defs.h"
  38 #include "gdbcmd.h"
  39 #include "tui/tui.h"
  40 #include "tui/tui-hooks.h"
  41 #include "tui/tui-data.h"
  42 #include "tui/tui-layout.h"
  43 #include "tui/tui-io.h"
  44 #include "tui/tui-regs.h"
  45 #include "tui/tui-stack.h"
  46 #include "tui/tui-win.h"
  47 #include "tui/tui-winsource.h"
  48 #include "tui/tui-windata.h"
  49 #include "readline/readline.h"
  50 #include "target.h"
  51 #include "frame.h"
  52 #include "breakpoint.h"
  53 #include "inferior.h"
  54 #include "symtab.h"
  55 #include "source.h"
  56
  57 #include "gdb_curses.h"
  58
  59 /* Tells whether the TUI is active or not.  */
  60 int tui_active = 0;
  61 static int tui_finish_init = 1;
  62
  63 enum tui_key_mode tui_current_key_mode = TUI_COMMAND_MODE;
  64
  65 struct tui_char_command
  66 {
  67   unsigned char key;
  68   const char* cmd;
  69 };
  70
  71 /* Key mapping to gdb commands when the TUI is using the single key mode.  */
  72 static const struct tui_char_command tui_commands[] = {
  73   { 'c', "continue" },
  74   { 'd', "down" },
  75   { 'f', "finish" },
  76   { 'n', "next" },
  77   { 'r', "run" },
  78   { 's', "step" },
  79   { 'u', "up" },
  80   { 'v', "info locals" },
  81   { 'w', "where" },
  82   { 0, 0 },
  83 };
  84
  85 static Keymap tui_keymap;
  86 static Keymap tui_readline_standard_keymap;
  87
  88 /* TUI readline command.
  89    Switch the output mode between TUI/standard gdb.  */
  90 static int
  91 tui_rl_switch_mode (int notused1, int notused2)
  92 {
  93   if (tui_active)
  94     {
  95       tui_disable ();
  96       rl_prep_terminal (0);
  97     }
  98   else
  99     {
 100       rl_deprep_terminal ();
 101       tui_enable ();
 102     }
 103
 104   /* Clear the readline in case switching occurred in middle of 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 it
 112      will be able to setup the terminal for its needs.  By re-entering
 113      in readline, we also redisplay its prompt in the non-curses mode.  */
 114   rl_newline (1, '\n');
 115
 116   /* Make sure the \n we are returning does not repeat the last command.  */
 117   dont_repeat ();
 118   return 0;
 119 }
 120
 121 /* TUI readline command.
 122    Change the TUI layout to show a next layout.
 123    This function is bound to CTRL-X 2.  It is intended to provide
 124    a functionality close to the Emacs split-window command.  We always
 125    show two windows (src+asm), (src+regs) or (asm+regs).  */
 126 static int
 127 tui_rl_change_windows (int notused1, int notused2)
 128 {
 129   if (!tui_active)
 130     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 131
 132   if (tui_active)
 133     {
 134       enum tui_layout_type new_layout;
 135       enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 136
 137       new_layout = tui_current_layout ();
 138
 139       /* Select a new layout to have a rolling layout behavior
 140          with always two windows (except when undefined).  */
 141       switch (new_layout)
 142         {
 143         case SRC_COMMAND:
 144           new_layout = SRC_DISASSEM_COMMAND;
 145           break;
 146
 147         case DISASSEM_COMMAND:
 148           new_layout = SRC_DISASSEM_COMMAND;
 149           break;
 150
 151         case SRC_DATA_COMMAND:
 152           new_layout = SRC_DISASSEM_COMMAND;
 153           break;
 154
 155         case SRC_DISASSEM_COMMAND:
 156           new_layout = DISASSEM_DATA_COMMAND;
 157           break;
 158
 159         case DISASSEM_DATA_COMMAND:
 160           new_layout = SRC_DATA_COMMAND;
 161           break;
 162
 163         default:
 164           new_layout = SRC_COMMAND;
 165           break;
 166         }
 167       tui_set_layout (new_layout, regs_type);
 168     }
 169   return 0;
 170 }
 171
 172 /* TUI readline command.
 173    Delete the second TUI window to only show one.  */
 174 static int
 175 tui_rl_delete_other_windows (int notused1, int notused2)
 176 {
 177   if (!tui_active)
 178     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 179
 180   if (tui_active)
 181     {
 182       enum tui_layout_type new_layout;
 183       enum tui_register_display_type regs_type = TUI_UNDEFINED_REGS;
 184
 185       new_layout = tui_current_layout ();
 186
 187       /* Kill one window.  */
 188       switch (new_layout)
 189         {
 190         case SRC_COMMAND:
 191         case SRC_DATA_COMMAND:
 192         case SRC_DISASSEM_COMMAND:
 193         default:
 194           new_layout = SRC_COMMAND;
 195           break;
 196
 197         case DISASSEM_COMMAND:
 198         case DISASSEM_DATA_COMMAND:
 199           new_layout = DISASSEM_COMMAND;
 200           break;
 201         }
 202       tui_set_layout (new_layout, regs_type);
 203     }
 204   return 0;
 205 }
 206
 207 /* TUI readline command.
 208    Switch the active window to give the focus to a next window.  */
 209 static int
 210 tui_rl_other_window (int count, int key)
 211 {
 212   struct tui_win_info * win_info;
 213
 214   if (!tui_active)
 215     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 216
 217   win_info = tui_next_win (tui_win_with_focus ());
 218   if (win_info)
 219     {
 220       tui_set_win_focus_to (win_info);
 221       if (TUI_DATA_WIN && TUI_DATA_WIN->generic.is_visible)
 222         tui_refresh_data_win ();
 223       keypad (TUI_CMD_WIN->generic.handle, (win_info != TUI_CMD_WIN));
 224     }
 225   return 0;
 226 }
 227
 228 /* TUI readline command.
 229    Execute the gdb command bound to the specified key.  */
 230 static int
 231 tui_rl_command_key (int count, int key)
 232 {
 233   int i;
 234
 235   reinitialize_more_filter ();
 236   for (i = 0; tui_commands[i].cmd; i++)
 237     {
 238       if (tui_commands[i].key == key)
 239         {
 240           /* Must save the command because it can be modified
 241              by execute_command.  */
 242           char* cmd = alloca (strlen (tui_commands[i].cmd) + 1);
 243           strcpy (cmd, tui_commands[i].cmd);
 244           execute_command (cmd, TRUE);
 245           return 0;
 246         }
 247     }
 248   return 0;
 249 }
 250
 251 /* TUI readline command.
 252    Temporarily leave the TUI SingleKey mode to allow editing
 253    a gdb command with the normal readline.  Once the command
 254    is executed, the TUI SingleKey mode is installed back.  */
 255 static int
 256 tui_rl_command_mode (int count, int key)
 257 {
 258   tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 259   return rl_insert (count, key);
 260 }
 261
 262 /* TUI readline command.
 263    Switch between TUI SingleKey mode and gdb readline editing.  */
 264 static int
 265 tui_rl_next_keymap (int notused1, int notused2)
 266 {
 267   if (!tui_active)
 268     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 269
 270   tui_set_key_mode (tui_current_key_mode == TUI_COMMAND_MODE
 271                     ? TUI_SINGLE_KEY_MODE : TUI_COMMAND_MODE);
 272   return 0;
 273 }
 274
 275 /* Readline hook to redisplay ourself the gdb prompt.
 276    In the SingleKey mode, the prompt is not printed so that
 277    the command window is cleaner.  It will be displayed if
 278    we temporarily leave the SingleKey mode.  */
 279 static int
 280 tui_rl_startup_hook (void)
 281 {
 282   rl_already_prompted = 1;
 283   if (tui_current_key_mode != TUI_COMMAND_MODE)
 284     tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 285   tui_redisplay_readline ();
 286   return 0;
 287 }
 288
 289 /* Change the TUI key mode by installing the appropriate readline keymap.  */
 290 void
 291 tui_set_key_mode (enum tui_key_mode mode)
 292 {
 293   tui_current_key_mode = mode;
 294   rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
 295                  ? tui_keymap : tui_readline_standard_keymap);
 296   tui_show_locator_content ();
 297 }
 298
 299 /* Initialize readline and configure the keymap for the switching
 300    key shortcut.  */
 301 void
 302 tui_initialize_readline (void)
 303 {
 304   int i;
 305   Keymap tui_ctlx_keymap;
 306
 307   rl_initialize ();
 308
 309   rl_add_defun ("tui-switch-mode", tui_rl_switch_mode, -1);
 310   rl_add_defun ("gdb-command", tui_rl_command_key, -1);
 311   rl_add_defun ("next-keymap", tui_rl_next_keymap, -1);
 312
 313   tui_keymap = rl_make_bare_keymap ();
 314   tui_ctlx_keymap = rl_make_bare_keymap ();
 315   tui_readline_standard_keymap = rl_get_keymap ();
 316
 317   for (i = 0; tui_commands[i].cmd; i++)
 318     rl_bind_key_in_map (tui_commands[i].key, tui_rl_command_key, tui_keymap);
 319
 320   rl_generic_bind (ISKMAP, "\\C-x", (char*) tui_ctlx_keymap, tui_keymap);
 321
 322   /* Bind all other keys to tui_rl_command_mode so that we switch
 323      temporarily from SingleKey mode and can enter a gdb command.  */
 324   for (i = ' '; i < 0x7f; i++)
 325     {
 326       int j;
 327
 328       for (j = 0; tui_commands[j].cmd; j++)
 329         if (tui_commands[j].key == i)
 330           break;
 331
 332       if (tui_commands[j].cmd)
 333         continue;
 334
 335       rl_bind_key_in_map (i, tui_rl_command_mode, tui_keymap);
 336     }
 337
 338   rl_bind_key_in_map ('a', tui_rl_switch_mode, emacs_ctlx_keymap);
 339   rl_bind_key_in_map ('a', tui_rl_switch_mode, tui_ctlx_keymap);
 340   rl_bind_key_in_map ('A', tui_rl_switch_mode, emacs_ctlx_keymap);
 341   rl_bind_key_in_map ('A', tui_rl_switch_mode, tui_ctlx_keymap);
 342   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, emacs_ctlx_keymap);
 343   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, tui_ctlx_keymap);
 344   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, emacs_ctlx_keymap);
 345   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, tui_ctlx_keymap);
 346   rl_bind_key_in_map ('2', tui_rl_change_windows, emacs_ctlx_keymap);
 347   rl_bind_key_in_map ('2', tui_rl_change_windows, tui_ctlx_keymap);
 348   rl_bind_key_in_map ('o', tui_rl_other_window, emacs_ctlx_keymap);
 349   rl_bind_key_in_map ('o', tui_rl_other_window, tui_ctlx_keymap);
 350   rl_bind_key_in_map ('q', tui_rl_next_keymap, tui_keymap);
 351   rl_bind_key_in_map ('s', tui_rl_next_keymap, emacs_ctlx_keymap);
 352   rl_bind_key_in_map ('s', tui_rl_next_keymap, tui_ctlx_keymap);
 353 }
 354
 355 /* Enter in the tui mode (curses).
 356    When in normal mode, it installs the tui hooks in gdb, redirects
 357    the gdb output, configures the readline to work in tui mode.
 358    When in curses mode, it does nothing.  */
 359 void
 360 tui_enable (void)
 361 {
 362   if (tui_active)
 363     return;
 364
 365   /* To avoid to initialize curses when gdb starts, there is a defered
 366      curses initialization.  This initialization is made only once
 367      and the first time the curses mode is entered.  */
 368   if (tui_finish_init)
 369     {
 370       WINDOW *w;
 371
 372       w = initscr ();
 373
 374       cbreak ();
 375       noecho ();
 376       /*timeout (1);*/
 377       nodelay(w, FALSE);
 378       nl();
 379       keypad (w, TRUE);
 380       rl_initialize ();
 381       tui_set_term_height_to (LINES);
 382       tui_set_term_width_to (COLS);
 383       def_prog_mode ();
 384
 385       tui_show_frame_info (0);
 386       tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
 387       tui_set_win_focus_to (TUI_SRC_WIN);
 388       keypad (TUI_CMD_WIN->generic.handle, TRUE);
 389       wrefresh (TUI_CMD_WIN->generic.handle);
 390       tui_finish_init = 0;
 391     }
 392   else
 393     {
 394      /* Save the current gdb setting of the terminal.
 395         Curses will restore this state when endwin() is called.  */
 396      def_shell_mode ();
 397      clearok (stdscr, TRUE);
 398    }
 399
 400   /* Install the TUI specific hooks.  */
 401   tui_install_hooks ();
 402   rl_startup_hook = tui_rl_startup_hook;
 403
 404   tui_update_variables ();
 405
 406   tui_setup_io (1);
 407
 408   tui_active = 1;
 409   if (deprecated_selected_frame)
 410      tui_show_frame_info (deprecated_selected_frame);
 411
 412   /* Restore TUI keymap.  */
 413   tui_set_key_mode (tui_current_key_mode);
 414   tui_refresh_all_win ();
 415
 416   /* Update gdb's knowledge of its terminal.  */
 417   target_terminal_save_ours ();
 418   tui_update_gdb_sizes ();
 419 }
 420
 421 /* Leave the tui mode.
 422    Remove the tui hooks and configure the gdb output and readline
 423    back to their original state.  The curses mode is left so that
 424    the terminal setting is restored to the point when we entered.  */
 425 void
 426 tui_disable (void)
 427 {
 428   if (!tui_active)
 429     return;
 430
 431   /* Restore initial readline keymap.  */
 432   rl_set_keymap (tui_readline_standard_keymap);
 433
 434   /* Remove TUI hooks.  */
 435   tui_remove_hooks ();
 436   rl_startup_hook = 0;
 437   rl_already_prompted = 0;
 438
 439   /* Leave curses and restore previous gdb terminal setting.  */
 440   endwin ();
 441
 442   /* gdb terminal has changed, update gdb internal copy of it
 443      so that terminal management with the inferior works.  */
 444   tui_setup_io (0);
 445
 446   /* Update gdb's knowledge of its terminal.  */
 447   target_terminal_save_ours ();
 448
 449   tui_active = 0;
 450   tui_update_gdb_sizes ();
 451 }
 452
 453 void
 454 strcat_to_buf (char *buf, int buflen, const char *item_to_add)
 455 {
 456   if (item_to_add != (char *) NULL && buf != (char *) NULL)
 457     {
 458       if ((strlen (buf) + strlen (item_to_add)) <= buflen)
 459         strcat (buf, item_to_add);
 460       else
 461         strncat (buf, item_to_add, (buflen - strlen (buf)));
 462     }
 463 }
 464
 465 #if 0
 466 /* Solaris <sys/termios.h> defines CTRL. */
 467 #ifndef CTRL
 468 #define CTRL(x)         (x & ~0140)
 469 #endif
 470
 471 #define FILEDES         2
 472 #define CHK(val, dft)   (val<=0 ? dft : val)
 473
 474 static void
 475 tui_reset (void)
 476 {
 477   struct termio mode;
 478
 479   /*
 480      ** reset the teletype mode bits to a sensible state.
 481      ** Copied tset.c
 482    */
 483 #if ! defined (USG) && defined (TIOCGETC)
 484   struct tchars tbuf;
 485 #endif /* !USG && TIOCGETC */
 486 #ifdef UCB_NTTY
 487   struct ltchars ltc;
 488
 489   if (ldisc == NTTYDISC)
 490     {
 491       ioctl (FILEDES, TIOCGLTC, &ltc);
 492       ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
 493       ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
 494       ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
 495       ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
 496       ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
 497       ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
 498       ioctl (FILEDES, TIOCSLTC, &ltc);
 499     }
 500 #endif /* UCB_NTTY */
 501 #ifndef USG
 502 #ifdef TIOCGETC
 503   ioctl (FILEDES, TIOCGETC, &tbuf);
 504   tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
 505   tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
 506   tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
 507   tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
 508   tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
 509   /* brkc is left alone */
 510   ioctl (FILEDES, TIOCSETC, &tbuf);
 511 #endif /* TIOCGETC */
 512   mode.sg_flags &= ~(RAW
 513 #ifdef CBREAK
 514                      | CBREAK
 515 #endif /* CBREAK */
 516                      | VTDELAY | ALLDELAY);
 517   mode.sg_flags |= XTABS | ECHO | CRMOD | ANYP;
 518 #else /*USG */
 519   ioctl (FILEDES, TCGETA, &mode);
 520   mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));
 521   mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));
 522   mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));
 523
 524   mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | INLCR | IGNCR | IUCLC | IXOFF);
 525   mode.c_iflag |= (BRKINT | ISTRIP | ICRNL | IXON);
 526   mode.c_oflag &= ~(OLCUC | OCRNL | ONOCR | ONLRET | OFILL | OFDEL |
 527                     NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY);
 528   mode.c_oflag |= (OPOST | ONLCR);
 529   mode.c_cflag &= ~(CSIZE | PARODD | CLOCAL);
 530 #ifndef hp9000s800
 531   mode.c_cflag |= (CS8 | CREAD);
 532 #else /*hp9000s800 */
 533   mode.c_cflag |= (CS8 | CSTOPB | CREAD);
 534 #endif /* hp9000s800 */
 535   mode.c_lflag &= ~(XCASE | ECHONL | NOFLSH);
 536   mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOK);
 537   ioctl (FILEDES, TCSETAW, &mode);
 538 #endif /* USG */
 539
 540   return;
 541 }
 542 #endif
 543
 544 void
 545 tui_show_source (const char *file, int line)
 546 {
 547   struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 548   /* make sure that the source window is displayed */
 549   tui_add_win_to_layout (SRC_WIN);
 550
 551   tui_update_source_windows_with_line (cursal.symtab, line);
 552   tui_update_locator_filename (file);
 553 }
 554
 555 void
 556 tui_show_assembly (CORE_ADDR addr)
 557 {
 558   tui_add_win_to_layout (DISASSEM_WIN);
 559   tui_update_source_windows_with_addr (addr);
 560 }
 561
 562 int
 563 tui_is_window_visible (enum tui_win_type type)
 564 {
 565   if (tui_active == 0)
 566     return 0;
 567
 568   if (tui_win_list[type] == 0)
 569     return 0;
 570
 571   return tui_win_list[type]->generic.is_visible;
 572 }
 573
 574 int
 575 tui_get_command_dimension (int *width, int *height)
 576 {
 577   if (!tui_active || (TUI_CMD_WIN == NULL))
 578     {
 579       return 0;
 580     }
 581
 582   *width = TUI_CMD_WIN->generic.width;
 583   *height = TUI_CMD_WIN->generic.height;
 584   return 1;
 585 }