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