xref: /dragonfly/contrib/gdb-7/gdb/tui/tui-stack.c (revision a68e0df0)
1 /* TUI display locator.
2 
3    Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008,
4    2009 Free Software 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 3 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, see <http://www.gnu.org/licenses/>.  */
22 
23 #include "defs.h"
24 #include "symtab.h"
25 #include "breakpoint.h"
26 #include "frame.h"
27 #include "command.h"
28 #include "inferior.h"
29 #include "target.h"
30 #include "top.h"
31 #include "gdb_string.h"
32 #include "tui/tui.h"
33 #include "tui/tui-data.h"
34 #include "tui/tui-stack.h"
35 #include "tui/tui-wingeneral.h"
36 #include "tui/tui-source.h"
37 #include "tui/tui-winsource.h"
38 #include "tui/tui-file.h"
39 
40 #include "gdb_curses.h"
41 
42 /* Get a printable name for the function at the address.
43    The symbol name is demangled if demangling is turned on.
44    Returns a pointer to a static area holding the result.  */
45 static char *tui_get_function_from_frame (struct frame_info *fi);
46 
47 /* Set the filename portion of the locator.  */
48 static void tui_set_locator_filename (const char *filename);
49 
50 /* Update the locator, with the provided arguments.  */
51 static void tui_set_locator_info (struct gdbarch *gdbarch,
52 				  const char *filename,
53 				  const char *procname,
54                                   int lineno, CORE_ADDR addr);
55 
56 static void tui_update_command (char *, int);
57 
58 
59 /* Create the status line to display as much information as we can on
60    this single line: target name, process number, current function,
61    current line, current PC, SingleKey mode.  */
62 static char*
63 tui_make_status_line (struct tui_locator_element *loc)
64 {
65   char *string;
66   char line_buf[50], *pname;
67   char *buf;
68   int status_size;
69   int i, proc_width;
70   const char *pid_name;
71   const char *pc_buf;
72   int target_width;
73   int pid_width;
74   int line_width;
75   int pc_width;
76   struct ui_file *pc_out;
77 
78   if (ptid_equal (inferior_ptid, null_ptid))
79     pid_name = "No process";
80   else
81     pid_name = target_pid_to_str (inferior_ptid);
82 
83   target_width = strlen (target_shortname);
84   if (target_width > MAX_TARGET_WIDTH)
85     target_width = MAX_TARGET_WIDTH;
86 
87   pid_width = strlen (pid_name);
88   if (pid_width > MAX_PID_WIDTH)
89     pid_width = MAX_PID_WIDTH;
90 
91   status_size = tui_term_width ();
92   string = (char *) xmalloc (status_size + 1);
93   buf = (char*) alloca (status_size + 1);
94 
95   /* Translate line number and obtain its size.  */
96   if (loc->line_no > 0)
97     sprintf (line_buf, "%d", loc->line_no);
98   else
99     strcpy (line_buf, "??");
100   line_width = strlen (line_buf);
101   if (line_width < MIN_LINE_WIDTH)
102     line_width = MIN_LINE_WIDTH;
103 
104   /* Translate PC address.  */
105   pc_out = tui_sfileopen (128);
106   fputs_filtered (loc->gdbarch? paddress (loc->gdbarch, loc->addr) : "??",
107 		  pc_out);
108   pc_buf = tui_file_get_strbuf (pc_out);
109   pc_width = strlen (pc_buf);
110 
111   /* First determine the amount of proc name width we have available.
112      The +1 are for a space separator between fields.
113      The -1 are to take into account the \0 counted by sizeof.  */
114   proc_width = (status_size
115                 - (target_width + 1)
116                 - (pid_width + 1)
117                 - (sizeof (PROC_PREFIX) - 1 + 1)
118                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
119                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
120                 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
121                    ? (sizeof (SINGLE_KEY) - 1 + 1)
122                    : 0));
123 
124   /* If there is no room to print the function name, try by removing
125      some fields.  */
126   if (proc_width < MIN_PROC_WIDTH)
127     {
128       proc_width += target_width + 1;
129       target_width = 0;
130       if (proc_width < MIN_PROC_WIDTH)
131         {
132           proc_width += pid_width + 1;
133           pid_width = 0;
134           if (proc_width <= MIN_PROC_WIDTH)
135             {
136               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
137               pc_width = 0;
138               if (proc_width < 0)
139                 {
140                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
141                   line_width = 0;
142                   if (proc_width < 0)
143                     proc_width = 0;
144                 }
145             }
146         }
147     }
148 
149   /* Now convert elements to string form.  */
150   pname = loc->proc_name;
151 
152   /* Now create the locator line from the string version of the
153      elements.  We could use sprintf() here but that wouldn't ensure
154      that we don't overrun the size of the allocated buffer.
155      strcat_to_buf() will.  */
156   *string = (char) 0;
157 
158   if (target_width > 0)
159     {
160       sprintf (buf, "%*.*s ",
161                -target_width, target_width, target_shortname);
162       strcat_to_buf (string, status_size, buf);
163     }
164   if (pid_width > 0)
165     {
166       sprintf (buf, "%*.*s ",
167                -pid_width, pid_width, pid_name);
168       strcat_to_buf (string, status_size, buf);
169     }
170 
171   /* Show whether we are in SingleKey mode.  */
172   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
173     {
174       strcat_to_buf (string, status_size, SINGLE_KEY);
175       strcat_to_buf (string, status_size, " ");
176     }
177 
178   /* Procedure/class name.  */
179   if (proc_width > 0)
180     {
181       if (strlen (pname) > proc_width)
182         sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
183                  1 - proc_width, proc_width - 1, pname);
184       else
185         sprintf (buf, "%s%*.*s ", PROC_PREFIX,
186                  -proc_width, proc_width, pname);
187       strcat_to_buf (string, status_size, buf);
188     }
189 
190   if (line_width > 0)
191     {
192       sprintf (buf, "%s%*.*s ", LINE_PREFIX,
193                -line_width, line_width, line_buf);
194       strcat_to_buf (string, status_size, buf);
195     }
196   if (pc_width > 0)
197     {
198       strcat_to_buf (string, status_size, PC_PREFIX);
199       strcat_to_buf (string, status_size, pc_buf);
200     }
201 
202 
203   for (i = strlen (string); i < status_size; i++)
204     string[i] = ' ';
205   string[status_size] = (char) 0;
206 
207   ui_file_delete (pc_out);
208   return string;
209 }
210 
211 /* Get a printable name for the function at the address.  The symbol
212    name is demangled if demangling is turned on.  Returns a pointer to
213    a static area holding the result.  */
214 static char*
215 tui_get_function_from_frame (struct frame_info *fi)
216 {
217   static char name[256];
218   struct ui_file *stream = tui_sfileopen (256);
219   char *p;
220 
221   print_address_symbolic (get_frame_pc (fi), stream, demangle, "");
222   p = tui_file_get_strbuf (stream);
223 
224   /* Use simple heuristics to isolate the function name.  The symbol
225      can be demangled and we can have function parameters.  Remove
226      them because the status line is too short to display them.  */
227   if (*p == '<')
228     p++;
229   strncpy (name, p, sizeof (name));
230   p = strchr (name, '(');
231   if (!p)
232     p = strchr (name, '>');
233   if (p)
234     *p = 0;
235   p = strchr (name, '+');
236   if (p)
237     *p = 0;
238   ui_file_delete (stream);
239   return name;
240 }
241 
242 void
243 tui_show_locator_content (void)
244 {
245   char *string;
246   struct tui_gen_win_info *locator;
247 
248   locator = tui_locator_win_info_ptr ();
249 
250   if (locator != NULL && locator->handle != (WINDOW *) NULL)
251     {
252       struct tui_win_element *element;
253 
254       element = (struct tui_win_element *) locator->content[0];
255 
256       string = tui_make_status_line (&element->which_element.locator);
257       wmove (locator->handle, 0, 0);
258       wstandout (locator->handle);
259       waddstr (locator->handle, string);
260       wclrtoeol (locator->handle);
261       wstandend (locator->handle);
262       tui_refresh_win (locator);
263       wmove (locator->handle, 0, 0);
264       xfree (string);
265       locator->content_in_use = TRUE;
266     }
267 }
268 
269 
270 /* Set the filename portion of the locator.  */
271 static void
272 tui_set_locator_filename (const char *filename)
273 {
274   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
275   struct tui_locator_element *element;
276 
277   if (locator->content[0] == NULL)
278     {
279       tui_set_locator_info (NULL, filename, NULL, 0, 0);
280       return;
281     }
282 
283   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
284   element->file_name[0] = 0;
285   strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
286 }
287 
288 /* Update the locator, with the provided arguments.  */
289 static void
290 tui_set_locator_info (struct gdbarch *gdbarch,
291 		      const char *filename,
292 		      const char *procname,
293 		      int lineno,
294                       CORE_ADDR addr)
295 {
296   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
297   struct tui_locator_element *element;
298 
299   /* Allocate the locator content if necessary.  */
300   if (locator->content_size <= 0)
301     {
302       locator->content = (void **) tui_alloc_content (1, locator->type);
303       locator->content_size = 1;
304     }
305 
306   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
307   element->proc_name[0] = (char) 0;
308   strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
309   element->line_no = lineno;
310   element->addr = addr;
311   element->gdbarch = gdbarch;
312   tui_set_locator_filename (filename);
313 }
314 
315 /* Update only the filename portion of the locator.  */
316 void
317 tui_update_locator_filename (const char *filename)
318 {
319   tui_set_locator_filename (filename);
320   tui_show_locator_content ();
321 }
322 
323 /* Function to print the frame information for the TUI.  */
324 void
325 tui_show_frame_info (struct frame_info *fi)
326 {
327   struct tui_win_info *win_info;
328   int i;
329 
330   if (fi)
331     {
332       int start_line, i;
333       CORE_ADDR low;
334       struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
335       int source_already_displayed;
336       struct symtab_and_line sal;
337 
338       find_frame_sal (fi, &sal);
339 
340       source_already_displayed = sal.symtab != 0
341         && tui_source_is_displayed (sal.symtab->filename);
342       tui_set_locator_info (get_frame_arch (fi),
343 			    sal.symtab == 0 ? "??" : sal.symtab->filename,
344                             tui_get_function_from_frame (fi),
345                             sal.line,
346                             get_frame_pc (fi));
347       tui_show_locator_content ();
348       start_line = 0;
349       for (i = 0; i < (tui_source_windows ())->count; i++)
350 	{
351 	  union tui_which_element *item;
352 	  win_info = (tui_source_windows ())->list[i];
353 
354 	  item = &((struct tui_win_element *) locator->content[0])->which_element;
355 	  if (win_info == TUI_SRC_WIN)
356 	    {
357 	      start_line = (item->locator.line_no -
358 			   (win_info->generic.viewport_height / 2)) + 1;
359 	      if (start_line <= 0)
360 		start_line = 1;
361 	    }
362 	  else
363 	    {
364 	      if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
365 					    &low, (CORE_ADDR) 0) == 0)
366 		error (_("No function contains program counter for selected frame."));
367 	      else
368 		low = tui_get_low_disassembly_address (get_frame_arch (fi),
369 						       low, get_frame_pc (fi));
370 	    }
371 
372 	  if (win_info == TUI_SRC_WIN)
373 	    {
374 	      struct tui_line_or_address l;
375 	      l.loa = LOA_LINE;
376 	      l.u.line_no = start_line;
377 	      if (!(source_already_displayed
378 		    && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
379 		tui_update_source_window (win_info, get_frame_arch (fi),
380 					  sal.symtab, l, TRUE);
381 	      else
382 		{
383 		  l.u.line_no = item->locator.line_no;
384 		  tui_set_is_exec_point_at (l, win_info);
385 		}
386 	    }
387 	  else
388 	    {
389 	      if (win_info == TUI_DISASM_WIN)
390 		{
391 		  struct tui_line_or_address a;
392 		  a.loa = LOA_ADDRESS;
393 		  a.u.addr = low;
394 		  if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
395 		    tui_update_source_window (win_info, get_frame_arch (fi),
396 					      sal.symtab, a, TRUE);
397 		  else
398 		    {
399 		      a.u.addr = item->locator.addr;
400 		      tui_set_is_exec_point_at (a, win_info);
401 		    }
402 		}
403 	    }
404 	  tui_update_exec_info (win_info);
405 	}
406     }
407   else
408     {
409       tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
410       tui_show_locator_content ();
411       for (i = 0; i < (tui_source_windows ())->count; i++)
412 	{
413 	  win_info = (tui_source_windows ())->list[i];
414 	  tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
415 	  tui_update_exec_info (win_info);
416 	}
417     }
418 }
419 
420 /* Function to initialize gdb commands, for tui window stack
421    manipulation.  */
422 
423 /* Provide a prototype to silence -Wmissing-prototypes.  */
424 extern initialize_file_ftype _initialize_tui_stack;
425 
426 void
427 _initialize_tui_stack (void)
428 {
429   add_com ("update", class_tui, tui_update_command, _("\
430 Update the source window and locator to display the current execution point.\n"));
431 }
432 
433 /* Command to update the display with the current execution point.  */
434 static void
435 tui_update_command (char *arg, int from_tty)
436 {
437   char cmd[sizeof("frame 0")];
438 
439   strcpy (cmd, "frame 0");
440   execute_command (cmd, from_tty);
441 }
442