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

   1 /* TUI Interpreter definitions for GDB, the GNU debugger.
   2
   3    Copyright (C) 2003 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   int length;
 123   char *a_prompt;
 124   char *gdb_prompt = get_prompt ();
 125
 126   /* If we are using readline, set things up and display the first
 127      prompt, otherwise just print the prompt.  */
 128   if (async_command_editing_p)
 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)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
 134       a_prompt = (char *) xmalloc (length);
 135       strcpy (a_prompt, PREFIX (0));
 136       strcat (a_prompt, gdb_prompt);
 137       strcat (a_prompt, SUFFIX (0));
 138       rl_callback_handler_install (a_prompt, input_handler);
 139     }
 140   else
 141     display_gdb_prompt (0);
 142
 143   /* Loop until there is nothing to do. This is the entry point to the
 144      event loop engine. gdb_do_one_event, called via catch_errors()
 145      will process one event for each invocation.  It blocks waits for
 146      an event and then processes it.  >0 when an event is processed, 0
 147      when catch_errors() caught an error and <0 when there are no
 148      longer any event sources registered.  */
 149   while (1)
 150     {
 151       int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
 152       if (result < 0)
 153         break;
 154
 155       /* Update gdb output according to TUI mode.  Since catch_errors
 156          preserves the uiout from changing, this must be done at top
 157          level of event loop.  */
 158       if (tui_active)
 159         uiout = tui_out;
 160       else
 161         uiout = tui_old_uiout;
 162
 163       if (result == 0)
 164         {
 165           /* FIXME: this should really be a call to a hook that is
 166              interface specific, because interfaces can display the
 167              prompt in their own way.  */
 168           display_gdb_prompt (0);
 169           /* This call looks bizarre, but it is required.  If the user
 170              entered a command that caused an error,
 171              after_char_processing_hook won't be called from
 172              rl_callback_read_char_wrapper.  Using a cleanup there
 173              won't work, since we want this function to be called
 174              after a new prompt is printed.  */
 175           if (after_char_processing_hook)
 176             (*after_char_processing_hook) ();
 177           /* Maybe better to set a flag to be checked somewhere as to
 178              whether display the prompt or not.  */
 179         }
 180     }
 181
 182   /* We are done with the event loop. There are no more event sources
 183      to listen to.  So we exit GDB.  */
 184   return;
 185 }
 186
 187 void
 188 _initialize_tui_interp (void)
 189 {
 190   static const struct interp_procs procs = {
 191     tui_init,
 192     tui_resume,
 193     tui_suspend,
 194     tui_exec,
 195     tui_display_prompt_p,
 196     tui_command_loop,
 197   };
 198   struct interp *tui_interp;
 199
 200   /* Create a default uiout builder for the TUI. */
 201   tui_out = tui_out_new (gdb_stdout);
 202   interp_add (interp_new (INTERP_TUI, NULL, tui_out, &procs));
 203   if (interpreter_p && strcmp (interpreter_p, INTERP_TUI) == 0)
 204     tui_start_enabled = 1;
 205
 206   if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0)
 207     {
 208       xfree (interpreter_p);
 209       interpreter_p = xstrdup (INTERP_TUI);
 210     }
 211 }