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