gdb/tui/tui.c

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