OSDN Git Service

r284@cf-ppc-macosx: monabuilder | 2008-12-07 10:57:41 +0900
[pf3gnuchains/pf3gnuchains4x.git] / gdb / tui / tui-interp.c
1 /* TUI Interpreter definitions for GDB, the GNU debugger.
2
3    Copyright (C) 2003, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "interps.h"
22 #include "top.h"
23 #include "event-top.h"
24 #include "event-loop.h"
25 #include "ui-out.h"
26 #include "cli-out.h"
27 #include "tui/tui-data.h"
28 #include "readline/readline.h"
29 #include "tui/tui-win.h"
30 #include "tui/tui.h"
31 #include "tui/tui-io.h"
32 #include "exceptions.h"
33
34 /* Set to 1 when the TUI mode must be activated when we first start
35    gdb.  */
36 static int tui_start_enabled = 0;
37
38 /* Cleanup the tui before exiting.  */
39
40 static void
41 tui_exit (void)
42 {
43   /* Disable the tui.  Curses mode is left leaving the screen in a
44      clean state (see endwin()).  */
45   tui_disable ();
46 }
47
48 /* These implement the TUI interpreter.  */
49
50 static void *
51 tui_init (int top_level)
52 {
53   /* Install exit handler to leave the screen in a good shape.  */
54   atexit (tui_exit);
55
56   tui_initialize_static_data ();
57
58   tui_initialize_io ();
59   tui_initialize_win ();
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
71      previously writing to gdb_stdout, then set it to the new
72      gdb_stdout afterwards.  */
73
74   stream = cli_out_set_stream (tui_old_uiout, gdb_stdout);
75   if (stream != gdb_stdout)
76     {
77       cli_out_set_stream (tui_old_uiout, stream);
78       stream = NULL;
79     }
80
81   gdb_setup_readline ();
82
83   if (stream != NULL)
84     cli_out_set_stream (tui_old_uiout, gdb_stdout);
85
86   if (tui_start_enabled)
87     tui_enable ();
88   return 1;
89 }
90
91 static int
92 tui_suspend (void *data)
93 {
94   tui_start_enabled = tui_active;
95   tui_disable ();
96   return 1;
97 }
98
99 /* Display the prompt if we are silent.  */
100
101 static int
102 tui_display_prompt_p (void *data)
103 {
104   if (interp_quiet_p (NULL))
105     return 0;
106   else
107     return 1;
108 }
109
110 static struct gdb_exception
111 tui_exec (void *data, const char *command_str)
112 {
113   internal_error (__FILE__, __LINE__, _("tui_exec called"));
114 }
115
116
117 /* Initialize all the necessary variables, start the event loop,
118    register readline, and stdin, start the loop.  */
119
120 static void
121 tui_command_loop (void *data)
122 {
123   /* If we are using readline, set things up and display the first
124      prompt, otherwise just print the prompt.  */
125   if (async_command_editing_p)
126     {
127       int length;
128       char *a_prompt;
129       char *gdb_prompt = get_prompt ();
130
131       /* Tell readline what the prompt to display is and what function
132          it will need to call after a whole line is read. This also
133          displays the first prompt.  */
134       length = strlen (PREFIX (0)) 
135         + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
136       a_prompt = (char *) alloca (length);
137       strcpy (a_prompt, PREFIX (0));
138       strcat (a_prompt, gdb_prompt);
139       strcat (a_prompt, SUFFIX (0));
140       rl_callback_handler_install (a_prompt, input_handler);
141     }
142   else
143     display_gdb_prompt (0);
144
145   /* Loop until there is nothing to do. This is the entry point to the
146      event loop engine. gdb_do_one_event, called via catch_errors()
147      will process one event for each invocation.  It blocks waits for
148      an event and then processes it.  >0 when an event is processed, 0
149      when catch_errors() caught an error and <0 when there are no
150      longer any event sources registered.  */
151   while (1)
152     {
153       int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
154       if (result < 0)
155         break;
156
157       /* Update gdb output according to TUI mode.  Since catch_errors
158          preserves the uiout from changing, this must be done at top
159          level of event loop.  */
160       if (tui_active)
161         uiout = tui_out;
162       else
163         uiout = tui_old_uiout;
164       
165       if (result == 0)
166         {
167           /* If any exception escaped to here, we better enable
168              stdin.  Otherwise, any command that calls async_disable_stdin,
169              and then throws, will leave stdin inoperable.  */
170           async_enable_stdin ();
171           /* FIXME: this should really be a call to a hook that is
172              interface specific, because interfaces can display the
173              prompt in their own way.  */
174           display_gdb_prompt (0);
175           /* This call looks bizarre, but it is required.  If the user
176              entered a command that caused an error,
177              after_char_processing_hook won't be called from
178              rl_callback_read_char_wrapper.  Using a cleanup there
179              won't work, since we want this function to be called
180              after a new prompt is printed.  */
181           if (after_char_processing_hook)
182             (*after_char_processing_hook) ();
183           /* Maybe better to set a flag to be checked somewhere as to
184              whether display the prompt or not.  */
185         }
186     }
187
188   /* We are done with the event loop. There are no more event sources
189      to listen to.  So we exit GDB.  */
190   return;
191 }
192
193 void
194 _initialize_tui_interp (void)
195 {
196   static const struct interp_procs procs = {
197     tui_init,
198     tui_resume,
199     tui_suspend,
200     tui_exec,
201     tui_display_prompt_p,
202     tui_command_loop,
203   };
204   struct interp *tui_interp;
205
206   /* Create a default uiout builder for the TUI.  */
207   tui_out = tui_out_new (gdb_stdout);
208   interp_add (interp_new (INTERP_TUI, NULL, tui_out, &procs));
209   if (interpreter_p && strcmp (interpreter_p, INTERP_TUI) == 0)
210     tui_start_enabled = 1;
211
212   if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0)
213     {
214       xfree (interpreter_p);
215       interpreter_p = xstrdup (INTERP_TUI);
216     }
217 }