gnu/dist/gdb6/gdb/tui/tui.c

   1 /* General functions for the WDB TUI.
   2
   3    Copyright (C) 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., 51 Franklin Street, Fifth Floor,
  23    Boston, MA 02110-1301, USA.  */
  24
  25 #include "defs.h"
  26 #include "gdbcmd.h"
  27 #include "tui/tui.h"
  28 #include "tui/tui-hooks.h"
  29 #include "tui/tui-data.h"
  30 #include "tui/tui-layout.h"
  31 #include "tui/tui-io.h"
  32 #include "tui/tui-regs.h"
  33 #include "tui/tui-stack.h"
  34 #include "tui/tui-win.h"
  35 #include "tui/tui-winsource.h"
  36 #include "tui/tui-windata.h"
  37 #include "target.h"
  38 #include "frame.h"
  39 #include "breakpoint.h"
  40 #include "inferior.h"
  41 #include "symtab.h"
  42 #include "source.h"
  43
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <ctype.h>
  47 #include <signal.h>
  48 #include <fcntl.h>
  49 #if 0
  50 #include <termio.h>
  51 #endif
  52 #include <setjmp.h>
  53
  54 #include "gdb_curses.h"
  55
  56 /* This redefines CTRL if it is not already defined, so it must come
  57    after terminal state releated include files like <term.h> and
  58    "gdb_curses.h".  */
  59 #include "readline/readline.h"
  60
  61 /* Tells whether the TUI is active or not.  */
  62 int tui_active = 0;
  63 static int tui_finish_init = 1;
  64
  65 enum tui_key_mode tui_current_key_mode = TUI_COMMAND_MODE;
  66
  67 struct tui_char_command
  68 {
  69   unsigned char key;
  70   const char* cmd;
  71 };
  72
  73 /* Key mapping to gdb commands when the TUI is using the single key mode.  */
  74 static const struct tui_char_command tui_commands[] = {
  75   { 'c', "continue" },
  76   { 'd', "down" },
  77   { 'f', "finish" },
  78   { 'n', "next" },
  79   { 'r', "run" },
  80   { 's', "step" },
  81   { 'u', "up" },
  82   { 'v', "info locals" },
  83   { 'w', "where" },
  84   { 0, 0 },
  85 };
  86
  87 static Keymap tui_keymap;
  88 static Keymap tui_readline_standard_keymap;
  89
  90 /* TUI readline command.
  91    Switch the output mode between TUI/standard gdb.  */
  92 static int
  93 tui_rl_switch_mode (int notused1, int notused2)
  94 {
  95   if (tui_active)
  96     {
  97       tui_disable ();
  98       rl_prep_terminal (0);
  99     }
 100   else
 101     {
 102       rl_deprep_terminal ();
 103       tui_enable ();
 104     }
 105
 106   /* Clear the readline in case switching occurred in middle of something.  */
 107   if (rl_end)
 108     rl_kill_text (0, rl_end);
 109
 110   /* Since we left the curses mode, the terminal mode is restored to
 111      some previous state.  That state may not be suitable for readline
 112      to work correctly (it may be restored in line mode).  We force an
 113      exit of the current readline so that readline is re-entered and it
 114      will be able to setup the terminal for its needs.  By re-entering
 115      in readline, we also redisplay its prompt in the non-curses mode.  */
 116   rl_newline (1, '\n');
 117
 118   /* Make sure the \n we are returning does not repeat the last 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 always
 127    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
 142          with 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           /* Must save the command because it can be modified
 243              by execute_command.  */
 244           char* cmd = alloca (strlen (tui_commands[i].cmd) + 1);
 245           strcpy (cmd, tui_commands[i].cmd);
 246           execute_command (cmd, TRUE);
 247           return 0;
 248         }
 249     }
 250   return 0;
 251 }
 252
 253 /* TUI readline command.
 254    Temporarily leave the TUI SingleKey mode to allow editing
 255    a gdb command with the normal readline.  Once the command
 256    is executed, the TUI SingleKey mode is installed back.  */
 257 static int
 258 tui_rl_command_mode (int count, int key)
 259 {
 260   tui_set_key_mode (TUI_ONE_COMMAND_MODE);
 261   return rl_insert (count, key);
 262 }
 263
 264 /* TUI readline command.
 265    Switch between TUI SingleKey mode and gdb readline editing.  */
 266 static int
 267 tui_rl_next_keymap (int notused1, int notused2)
 268 {
 269   if (!tui_active)
 270     tui_rl_switch_mode (0/*notused*/, 0/*notused*/);
 271
 272   tui_set_key_mode (tui_current_key_mode == TUI_COMMAND_MODE
 273                     ? TUI_SINGLE_KEY_MODE : TUI_COMMAND_MODE);
 274   return 0;
 275 }
 276
 277 /* Readline hook to redisplay ourself the gdb prompt.
 278    In the SingleKey mode, the prompt is not printed so that
 279    the command window is cleaner.  It will be displayed if
 280    we temporarily leave the SingleKey mode.  */
 281 static int
 282 tui_rl_startup_hook (void)
 283 {
 284   rl_already_prompted = 1;
 285   if (tui_current_key_mode != TUI_COMMAND_MODE)
 286     tui_set_key_mode (TUI_SINGLE_KEY_MODE);
 287   tui_redisplay_readline ();
 288   return 0;
 289 }
 290
 291 /* Change the TUI key mode by installing the appropriate readline keymap.  */
 292 void
 293 tui_set_key_mode (enum tui_key_mode mode)
 294 {
 295   tui_current_key_mode = mode;
 296   rl_set_keymap (mode == TUI_SINGLE_KEY_MODE
 297                  ? tui_keymap : tui_readline_standard_keymap);
 298   tui_show_locator_content ();
 299 }
 300
 301 /* Initialize readline and configure the keymap for the switching
 302    key shortcut.  */
 303 void
 304 tui_initialize_readline (void)
 305 {
 306   int i;
 307   Keymap tui_ctlx_keymap;
 308
 309   rl_initialize ();
 310
 311   rl_add_defun ("tui-switch-mode", tui_rl_switch_mode, -1);
 312   rl_add_defun ("gdb-command", tui_rl_command_key, -1);
 313   rl_add_defun ("next-keymap", tui_rl_next_keymap, -1);
 314
 315   tui_keymap = rl_make_bare_keymap ();
 316   tui_ctlx_keymap = rl_make_bare_keymap ();
 317   tui_readline_standard_keymap = rl_get_keymap ();
 318
 319   for (i = 0; tui_commands[i].cmd; i++)
 320     rl_bind_key_in_map (tui_commands[i].key, tui_rl_command_key, tui_keymap);
 321
 322   rl_generic_bind (ISKMAP, "\\C-x", (char*) tui_ctlx_keymap, tui_keymap);
 323
 324   /* Bind all other keys to tui_rl_command_mode so that we switch
 325      temporarily from SingleKey mode and can enter a gdb command.  */
 326   for (i = ' '; i < 0x7f; i++)
 327     {
 328       int j;
 329
 330       for (j = 0; tui_commands[j].cmd; j++)
 331         if (tui_commands[j].key == i)
 332           break;
 333
 334       if (tui_commands[j].cmd)
 335         continue;
 336
 337       rl_bind_key_in_map (i, tui_rl_command_mode, tui_keymap);
 338     }
 339
 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 ('A', tui_rl_switch_mode, emacs_ctlx_keymap);
 343   rl_bind_key_in_map ('A', tui_rl_switch_mode, tui_ctlx_keymap);
 344   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, emacs_ctlx_keymap);
 345   rl_bind_key_in_map (CTRL ('A'), tui_rl_switch_mode, tui_ctlx_keymap);
 346   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, emacs_ctlx_keymap);
 347   rl_bind_key_in_map ('1', tui_rl_delete_other_windows, tui_ctlx_keymap);
 348   rl_bind_key_in_map ('2', tui_rl_change_windows, emacs_ctlx_keymap);
 349   rl_bind_key_in_map ('2', tui_rl_change_windows, tui_ctlx_keymap);
 350   rl_bind_key_in_map ('o', tui_rl_other_window, emacs_ctlx_keymap);
 351   rl_bind_key_in_map ('o', tui_rl_other_window, tui_ctlx_keymap);
 352   rl_bind_key_in_map ('q', tui_rl_next_keymap, tui_keymap);
 353   rl_bind_key_in_map ('s', tui_rl_next_keymap, emacs_ctlx_keymap);
 354   rl_bind_key_in_map ('s', tui_rl_next_keymap, tui_ctlx_keymap);
 355 }
 356
 357 /* Enter in the tui mode (curses).
 358    When in normal mode, it installs the tui hooks in gdb, redirects
 359    the gdb output, configures the readline to work in tui mode.
 360    When in curses mode, it does nothing.  */
 361 void
 362 tui_enable (void)
 363 {
 364   if (tui_active)
 365     return;
 366
 367   /* To avoid to initialize curses when gdb starts, there is a defered
 368      curses initialization.  This initialization is made only once
 369      and the first time the curses mode is entered.  */
 370   if (tui_finish_init)
 371     {
 372       WINDOW *w;
 373
 374       w = initscr ();
 375
 376       cbreak ();
 377       noecho ();
 378       /*timeout (1);*/
 379       nodelay(w, FALSE);
 380       nl();
 381       keypad (w, TRUE);
 382       rl_initialize ();
 383       tui_set_term_height_to (LINES);
 384       tui_set_term_width_to (COLS);
 385       def_prog_mode ();
 386
 387       tui_show_frame_info (0);
 388       tui_set_layout (SRC_COMMAND, TUI_UNDEFINED_REGS);
 389       tui_set_win_focus_to (TUI_SRC_WIN);
 390       keypad (TUI_CMD_WIN->generic.handle, TRUE);
 391       wrefresh (TUI_CMD_WIN->generic.handle);
 392       tui_finish_init = 0;
 393     }
 394   else
 395     {
 396      /* Save the current gdb setting of the terminal.
 397         Curses will restore this state when endwin() is called.  */
 398      def_shell_mode ();
 399      clearok (stdscr, TRUE);
 400    }
 401
 402   /* Install the TUI specific hooks.  */
 403   tui_install_hooks ();
 404   rl_startup_hook = tui_rl_startup_hook;
 405
 406   tui_update_variables ();
 407
 408   tui_setup_io (1);
 409
 410   tui_active = 1;
 411   if (deprecated_selected_frame)
 412      tui_show_frame_info (deprecated_selected_frame);
 413
 414   /* Restore TUI keymap.  */
 415   tui_set_key_mode (tui_current_key_mode);
 416   tui_refresh_all_win ();
 417
 418   /* Update gdb's knowledge of its terminal.  */
 419   target_terminal_save_ours ();
 420   tui_update_gdb_sizes ();
 421 }
 422
 423 /* Leave the tui mode.
 424    Remove the tui hooks and configure the gdb output and readline
 425    back to their original state.  The curses mode is left so that
 426    the terminal setting is restored to the point when we entered.  */
 427 void
 428 tui_disable (void)
 429 {
 430   if (!tui_active)
 431     return;
 432
 433   /* Restore initial readline keymap.  */
 434   rl_set_keymap (tui_readline_standard_keymap);
 435
 436   /* Remove TUI hooks.  */
 437   tui_remove_hooks ();
 438   rl_startup_hook = 0;
 439   rl_already_prompted = 0;
 440
 441   /* Leave curses and restore previous gdb terminal setting.  */
 442   endwin ();
 443
 444   /* gdb terminal has changed, update gdb internal copy of it
 445      so that terminal management with the inferior works.  */
 446   tui_setup_io (0);
 447
 448   /* Update gdb's knowledge of its terminal.  */
 449   target_terminal_save_ours ();
 450
 451   tui_active = 0;
 452   tui_update_gdb_sizes ();
 453 }
 454
 455 void
 456 strcat_to_buf (char *buf, int buflen, const char *item_to_add)
 457 {
 458   if (item_to_add != (char *) NULL && buf != (char *) NULL)
 459     {
 460       if ((strlen (buf) + strlen (item_to_add)) <= buflen)
 461         strcat (buf, item_to_add);
 462       else
 463         strncat (buf, item_to_add, (buflen - strlen (buf)));
 464     }
 465 }
 466
 467 #if 0
 468 /* Solaris <sys/termios.h> defines CTRL. */
 469 #ifndef CTRL
 470 #define CTRL(x)         (x & ~0140)
 471 #endif
 472
 473 #define FILEDES         2
 474 #define CHK(val, dft)   (val<=0 ? dft : val)
 475
 476 static void
 477 tui_reset (void)
 478 {
 479   struct termio mode;
 480
 481   /*
 482      ** reset the teletype mode bits to a sensible state.
 483      ** Copied tset.c
 484    */
 485 #if defined (TIOCGETC)
 486   struct tchars tbuf;
 487 #endif /* TIOCGETC */
 488 #ifdef UCB_NTTY
 489   struct ltchars ltc;
 490
 491   if (ldisc == NTTYDISC)
 492     {
 493       ioctl (FILEDES, TIOCGLTC, &ltc);
 494       ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
 495       ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
 496       ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
 497       ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
 498       ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
 499       ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
 500       ioctl (FILEDES, TIOCSLTC, &ltc);
 501     }
 502 #endif /* UCB_NTTY */
 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
 520   return;
 521 }
 522 #endif
 523
 524 void
 525 tui_show_source (const char *file, int line)
 526 {
 527   struct symtab_and_line cursal = get_current_source_symtab_and_line ();
 528   /* make sure that the source window is displayed */
 529   tui_add_win_to_layout (SRC_WIN);
 530
 531   tui_update_source_windows_with_line (cursal.symtab, line);
 532   tui_update_locator_filename (file);
 533 }
 534
 535 void
 536 tui_show_assembly (CORE_ADDR addr)
 537 {
 538   tui_add_win_to_layout (DISASSEM_WIN);
 539   tui_update_source_windows_with_addr (addr);
 540 }
 541
 542 int
 543 tui_is_window_visible (enum tui_win_type type)
 544 {
 545   if (tui_active == 0)
 546     return 0;
 547
 548   if (tui_win_list[type] == 0)
 549     return 0;
 550
 551   return tui_win_list[type]->generic.is_visible;
 552 }
 553
 554 int
 555 tui_get_command_dimension (unsigned int *width, unsigned int *height)
 556 {
 557   if (!tui_active || (TUI_CMD_WIN == NULL))
 558     {
 559       return 0;
 560     }
 561
 562   *width = TUI_CMD_WIN->generic.width;
 563   *height = TUI_CMD_WIN->generic.height;
 564   return 1;
 565 }