gdb/tui/tui-interp.c

   1 /* TUI Interpreter definitions for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003, 2007 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20    Boston, MA 02110-1301, USA.  */
  21
  22 #include "defs.h"
  23 #include "interps.h"
  24 #include "top.h"
  25 #include "event-top.h"
  26 #include "event-loop.h"
  27 #include "ui-out.h"
  28 #include "cli-out.h"
  29 #include "tui/tui-data.h"
  30 #include "readline/readline.h"
  31 #include "tui/tui-win.h"
  32 #include "tui/tui.h"
  33 #include "tui/tui-io.h"
  34 #include "exceptions.h"
  35
  36 /* Set to 1 when the TUI mode must be activated when we first start gdb.  */
  37 static int tui_start_enabled = 0;
  38
  39 /* Cleanup the tui before exiting.  */
  40
  41 static void
  42 tui_exit (void)
  43 {
  44   /* Disable the tui.  Curses mode is left leaving the screen
  45      in a clean state (see endwin()).  */
  46   tui_disable ();
  47 }
  48
  49 /* These implement the TUI interpreter.  */
  50
  51 static void *
  52 tui_init (void)
  53 {
  54   /* Install exit handler to leave the screen in a good shape.  */
  55   atexit (tui_exit);
  56
  57   tui_initialize_static_data ();
  58
  59   tui_initialize_io ();
  60   tui_initialize_readline ();
  61
  62   return NULL;
  63 }
  64
  65 static int
  66 tui_resume (void *data)
  67 {
  68   struct ui_file *stream;
  69
  70   /* gdb_setup_readline will change gdb_stdout.  If the TUI was previously
  71      writing to gdb_stdout, then set it to the new gdb_stdout afterwards.  */
  72
  73   stream = cli_out_set_stream (tui_old_uiout, gdb_stdout);
  74   if (stream != gdb_stdout)
  75     {
  76       cli_out_set_stream (tui_old_uiout, stream);
  77       stream = NULL;
  78     }
  79
  80   gdb_setup_readline ();
  81
  82   if (stream != NULL)
  83     cli_out_set_stream (tui_old_uiout, gdb_stdout);
  84
  85   if (tui_start_enabled)
  86     tui_enable ();
  87   return 1;
  88 }
  89
  90 static int
  91 tui_suspend (void *data)
  92 {
  93   tui_start_enabled = tui_active;
  94   tui_disable ();
  95   return 1;
  96 }
  97
  98 /* Display the prompt if we are silent.  */
  99
 100 static int
 101 tui_display_prompt_p (void *data)
 102 {
 103   if (interp_quiet_p (NULL))
 104     return 0;
 105   else
 106     return 1;
 107 }
 108
 109 static struct gdb_exception
 110 tui_exec (void *data, const char *command_str)
 111 {
 112   internal_error (__FILE__, __LINE__, _("tui_exec called"));
 113 }
 114
 115
 116 /* Initialize all the necessary variables, start the event loop,
 117    register readline, and stdin, start the loop.  */
 118
 119 static void
 120 tui_command_loop (void *data)
 121 {
 122   /* If we are using readline, set things up and display the first
 123      prompt, otherwise just print the prompt.  */
 124   if (async_command_editing_p)
 125     {
 126       int length;
 127       char *a_prompt;
 128       char *gdb_prompt = get_prompt ();
 129
 130       /* Tell readline what the prompt to display is and what function
 131          it will need to call after a whole line is read. This also
 132          displays the first prompt.  */
 133       length = strlen (PREFIX (0))
 134         + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
 135       a_prompt = (char *) alloca (length);
 136       strcpy (a_prompt, PREFIX (0));
 137       strcat (a_prompt, gdb_prompt);
 138       strcat (a_prompt, SUFFIX (0));
 139       rl_callback_handler_install (a_prompt, input_handler);
 140     }
 141   else
 142     display_gdb_prompt (0);
 143
 144   /* Loop until there is nothing to do. This is the entry point to the
 145      event loop engine. gdb_do_one_event, called via catch_errors()
 146      will process one event for each invocation.  It blocks waits for
 147      an event and then processes it.  >0 when an event is processed, 0
 148      when catch_errors() caught an error and <0 when there are no
 149      longer any event sources registered.  */
 150   while (1)
 151     {
 152       int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
 153       if (result < 0)
 154         break;
 155
 156       /* Update gdb output according to TUI mode.  Since catch_errors
 157          preserves the uiout from changing, this must be done at top
 158          level of event loop.  */
 159       if (tui_active)
 160         uiout = tui_out;
 161       else
 162         uiout = tui_old_uiout;
 163
 164       if (result == 0)
 165         {
 166           /* FIXME: this should really be a call to a hook that is
 167              interface specific, because interfaces can display the
 168              prompt in their own way.  */
 169           display_gdb_prompt (0);
 170           /* This call looks bizarre, but it is required.  If the user
 171              entered a command that caused an error,
 172              after_char_processing_hook won't be called from
 173              rl_callback_read_char_wrapper.  Using a cleanup there
 174              won't work, since we want this function to be called
 175              after a new prompt is printed.  */
 176           if (after_char_processing_hook)
 177             (*after_char_processing_hook) ();
 178           /* Maybe better to set a flag to be checked somewhere as to
 179              whether display the prompt or not.  */
 180         }
 181     }
 182
 183   /* We are done with the event loop. There are no more event sources
 184      to listen to.  So we exit GDB.  */
 185   return;
 186 }
 187
 188 void
 189 _initialize_tui_interp (void)
 190 {
 191   static const struct interp_procs procs = {
 192     tui_init,
 193     tui_resume,
 194     tui_suspend,
 195     tui_exec,
 196     tui_display_prompt_p,
 197     tui_command_loop,
 198   };
 199   struct interp *tui_interp;
 200
 201   /* Create a default uiout builder for the TUI. */
 202   tui_out = tui_out_new (gdb_stdout);
 203   interp_add (interp_new (INTERP_TUI, NULL, tui_out, &procs));
 204   if (interpreter_p && strcmp (interpreter_p, INTERP_TUI) == 0)
 205     tui_start_enabled = 1;
 206
 207   if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0)
 208     {
 209       xfree (interpreter_p);
 210       interpreter_p = xstrdup (INTERP_TUI);
 211     }
 212 }