[deliverable/binutils-gdb.git] / gdb / tui / tuiStack.c

/* TUI display locator.

   Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
   Inc.

   Contributed by Hewlett-Packard Company.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
#include "command.h"
#include "inferior.h"
#include "target.h"
#include "top.h"

#include "tui.h"
#include "tuiData.h"
#include "tuiStack.h"
#include "tuiGeneralWin.h"
#include "tuiSource.h"
#include "tuiSourceWin.h"
#include "tui-file.h"

#ifdef HAVE_NCURSES_H       
#include <ncurses.h>
#else
#ifdef HAVE_CURSES_H
#include <curses.h>
#endif
#endif

/* Get a printable name for the function at the address.
   The symbol name is demangled if demangling is turned on.
   Returns a pointer to a static area holding the result.  */
static char* tui_get_function_from_frame (struct frame_info *fi);

/* Set the filename portion of the locator.  */
static void tui_set_locator_filename (const char *filename);

/* Update the locator, with the provided arguments.  */
static void tui_set_locator_info (const char *filename, const char *procname,
                                  int lineno, CORE_ADDR addr);

static void tui_update_command (char *, int);
\f

/* Create the status line to display as much information as we
   can on this single line: target name, process number, current
   function, current line, current PC, SingleKey mode.  */
static char*
tui_make_status_line (TuiLocatorElement* loc)
{
  char* string;
  char line_buf[50], *pname;
  char* buf;
  int status_size;
  int i, proc_width;
  const char* pid_name;
  const char* pc_buf;
  int target_width;
  int pid_width;
  int line_width;
  int pc_width;
  struct ui_file *pc_out;

  if (ptid_equal (inferior_ptid, null_ptid))
    pid_name = "No process";
  else
    pid_name = target_pid_to_str (inferior_ptid);

  target_width = strlen (target_shortname);
  if (target_width > MAX_TARGET_WIDTH)
    target_width = MAX_TARGET_WIDTH;

  pid_width = strlen (pid_name);
  if (pid_width > MAX_PID_WIDTH)
    pid_width = MAX_PID_WIDTH;

  status_size = termWidth ();  
  string = (char *) xmalloc (status_size + 1);
  buf = (char*) alloca (status_size + 1);

  /* Translate line number and obtain its size.  */
  if (loc->lineNo > 0)
    sprintf (line_buf, "%d", loc->lineNo);
  else
    strcpy (line_buf, "??");
  line_width = strlen (line_buf);
  if (line_width < MIN_LINE_WIDTH)
    line_width = MIN_LINE_WIDTH;

  /* Translate PC address.  */
  pc_out = tui_sfileopen (128);
  print_address_numeric (loc->addr, 1, pc_out);
  pc_buf = tui_file_get_strbuf (pc_out);
  pc_width = strlen (pc_buf);
  
  /* First determine the amount of proc name width we have available.
     The +1 are for a space separator between fields.
     The -1 are to take into account the \0 counted by sizeof.  */
  proc_width = (status_size
                - (target_width + 1)
                - (pid_width + 1)
                - (sizeof (PROC_PREFIX) - 1 + 1)
                - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
                - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
                - (tui_current_key_mode == tui_single_key_mode
                   ? (sizeof (SINGLE_KEY) - 1 + 1)
                   : 0));

  /* If there is no room to print the function name, try by removing
     some fields.  */
  if (proc_width < MIN_PROC_WIDTH)
    {
      proc_width += target_width + 1;
      target_width = 0;
      if (proc_width < MIN_PROC_WIDTH)
        {
          proc_width += pid_width + 1;
          pid_width = 0;
          if (proc_width <= MIN_PROC_WIDTH)
            {
              proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
              pc_width = 0;
              if (proc_width < 0)
                {
                  proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
                  line_width = 0;
                  if (proc_width < 0)
                    proc_width = 0;
                }
            }
        }
    }

  /* Now convert elements to string form */
  pname = loc->procName;

  /* Now create the locator line from the string version
     of the elements.  We could use sprintf() here but
     that wouldn't ensure that we don't overrun the size
     of the allocated buffer.  strcat_to_buf() will.  */
  *string = (char) 0;

  if (target_width > 0)
    {
      sprintf (buf, "%*.*s ",
               -target_width, target_width, target_shortname);
      strcat_to_buf (string, status_size, buf);
    }
  if (pid_width > 0)
    {
      sprintf (buf, "%*.*s ",
               -pid_width, pid_width, pid_name);
      strcat_to_buf (string, status_size, buf);
    }
  
  /* Show whether we are in SingleKey mode.  */
  if (tui_current_key_mode == tui_single_key_mode)
    {
      strcat_to_buf (string, status_size, SINGLE_KEY);
      strcat_to_buf (string, status_size, " ");
    }

  /* procedure/class name */
  if (proc_width > 0)
    {
      if (strlen (pname) > proc_width)
        sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
                 1 - proc_width, proc_width - 1, pname);
      else
        sprintf (buf, "%s%*.*s ", PROC_PREFIX,
                 -proc_width, proc_width, pname);
      strcat_to_buf (string, status_size, buf);
    }

  if (line_width > 0)
    {
      sprintf (buf, "%s%*.*s ", LINE_PREFIX,
               -line_width, line_width, line_buf);
      strcat_to_buf (string, status_size, buf);
    }
  if (pc_width > 0)
    {
      strcat_to_buf (string, status_size, PC_PREFIX);
      strcat_to_buf (string, status_size, pc_buf);
    }
  
  
  for (i = strlen (string); i < status_size; i++)
    string[i] = ' ';
  string[status_size] = (char) 0;

  ui_file_delete (pc_out);
  return string;
}

/* Get a printable name for the function at the address.
   The symbol name is demangled if demangling is turned on.
   Returns a pointer to a static area holding the result.  */
static char*
tui_get_function_from_frame (struct frame_info *fi)
{
  static char name[256];
  struct ui_file *stream = tui_sfileopen (256);
  char *p;

  print_address_symbolic (get_frame_pc (fi), stream, demangle, "");
  p = tui_file_get_strbuf (stream);

  /* Use simple heuristics to isolate the function name.  The symbol can
     be demangled and we can have function parameters.  Remove them because
     the status line is too short to display them.  */
  if (*p == '<')
    p++;
  strncpy (name, p, sizeof (name));
  p = strchr (name, '(');
  if (!p)
    p = strchr (name, '>');
  if (p)
    *p = 0;
  p = strchr (name, '+');
  if (p)
    *p = 0;
  ui_file_delete (stream);
  return name;
}

/*
   ** tuiShowLocatorContent()
 */
void
tuiShowLocatorContent (void)
{
  char *string;
  TuiGenWinInfoPtr locator;

  locator = locatorWinInfoPtr ();

  if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
    {
      TuiWinElementPtr element;

      element = (TuiWinElementPtr) locator->content[0];

      string = tui_make_status_line (&element->whichElement.locator);
      wmove (locator->handle, 0, 0);
      wstandout (locator->handle);
      waddstr (locator->handle, string);
      wclrtoeol (locator->handle);
      wstandend (locator->handle);
      tuiRefreshWin (locator);
      wmove (locator->handle, 0, 0);
      xfree (string);
      locator->contentInUse = TRUE;
    }
}


/* Set the filename portion of the locator.  */
static void
tui_set_locator_filename (const char *filename)
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
  TuiLocatorElementPtr element;

  if (locator->content[0] == (Opaque) NULL)
    {
      tui_set_locator_info (filename, NULL, 0, 0);
      return;
    }

  element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
  element->fileName[0] = 0;
  strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, filename);
}

/* Update the locator, with the provided arguments.  */
static void
tui_set_locator_info (const char *filename, const char *procname, int lineno,
                      CORE_ADDR addr)
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
  TuiLocatorElementPtr element;

  /* Allocate the locator content if necessary.  */
  if (locator->contentSize <= 0)
    {
      locator->content = (OpaquePtr) allocContent (1, locator->type);
      locator->contentSize = 1;
    }

  element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
  element->procName[0] = (char) 0;
  strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
  element->lineNo = lineno;
  element->addr = addr;
  tui_set_locator_filename (filename);
}

/* Update only the filename portion of the locator.  */
void
tuiUpdateLocatorFilename (const char *filename)
{
  tui_set_locator_filename (filename);
  tuiShowLocatorContent ();
}

/* Function to print the frame information for the TUI.  */
void
tuiShowFrameInfo (struct frame_info *fi)
{
  TuiWinInfoPtr winInfo;
  register int i;

  if (fi)
    {
      register int startLine, i;
      CORE_ADDR low;
      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
      int sourceAlreadyDisplayed;
      struct symtab_and_line sal;

      find_frame_sal (fi, &sal);

      sourceAlreadyDisplayed = sal.symtab != 0
        && tuiSourceIsDisplayed (sal.symtab->filename);
      tui_set_locator_info (sal.symtab == 0 ? "??" : sal.symtab->filename,
                            tui_get_function_from_frame (fi),
                            sal.line,
                            get_frame_pc (fi));
      tuiShowLocatorContent ();
      startLine = 0;
      for (i = 0; i < (sourceWindows ())->count; i++)
	{
	  TuiWhichElement *item;
	  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];

	  item = &((TuiWinElementPtr) locator->content[0])->whichElement;
	  if (winInfo == srcWin)
	    {
	      startLine = (item->locator.lineNo -
			   (winInfo->generic.viewportHeight / 2)) + 1;
	      if (startLine <= 0)
		startLine = 1;
	    }
	  else
	    {
	      if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
					    &low, (CORE_ADDR) NULL) == 0)
		error ("No function contains program counter for selected frame.\n");
	      else
		low = tuiGetLowDisassemblyAddress (low, get_frame_pc (fi));
	    }

	  if (winInfo == srcWin)
	    {
	      TuiLineOrAddress l;
	      l.lineNo = startLine;
	      if (!(sourceAlreadyDisplayed
		    && tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
		tuiUpdateSourceWindow (winInfo, sal.symtab, l, TRUE);
	      else
		{
		  l.lineNo = item->locator.lineNo;
		  tuiSetIsExecPointAt (l, winInfo);
		}
	    }
	  else
	    {
	      if (winInfo == disassemWin)
		{
		  TuiLineOrAddress a;
		  a.addr = low;
		  if (!tuiAddrIsDisplayed (item->locator.addr, winInfo, TRUE))
		    tuiUpdateSourceWindow (winInfo, sal.symtab, a, TRUE);
		  else
		    {
		      a.addr = item->locator.addr;
		      tuiSetIsExecPointAt (a, winInfo);
		    }
		}
	    }
	  tuiUpdateExecInfo (winInfo);
	}
    }
  else
    {
      tui_set_locator_info (NULL, NULL, 0, (CORE_ADDR) 0);
      tuiShowLocatorContent ();
      for (i = 0; i < (sourceWindows ())->count; i++)
	{
	  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
	  tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
	  tuiUpdateExecInfo (winInfo);
	}
    }
}

/* Function to initialize gdb commands, for tui window stack manipulation.  */
void
_initialize_tuiStack (void)
{
  add_com ("update", class_tui, tui_update_command,
           "Update the source window and locator to display the current "
           "execution point.\n");
}

/* Command to update the display with the current execution point.  */
static void
tui_update_command (char *arg, int from_tty)
{
  char cmd[sizeof("frame 0")];

  strcpy (cmd, "frame 0");
  execute_command (cmd, from_tty);
}
Commit	Line	Data
f377b406	1	/* TUI display locator.
f33c6cbf	2
96ec9981	3	Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
f33c6cbf AC	4	Inc.
f33c6cbf AC	5
f377b406 SC	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., 59 Temple Place - Suite 330,
	23	Boston, MA 02111-1307, USA. */
c906108c SS	24
	25	#include "defs.h"
	26	#include "symtab.h"
	27	#include "breakpoint.h"
	28	#include "frame.h"
75fd9bc1	29	#include "command.h"
50265402 SC	30	#include "inferior.h"
50265402 SC	31	#include "target.h"
7563e053	32	#include "top.h"
c906108c SS	33
	34	#include "tui.h"
	35	#include "tuiData.h"
	36	#include "tuiStack.h"
75fd9bc1 SC	37	#include "tuiGeneralWin.h"
75fd9bc1 SC	38	#include "tuiSource.h"
c906108c	39	#include "tuiSourceWin.h"
5564c769	40	#include "tui-file.h"
c906108c	41
96ec9981 DJ	42	#ifdef HAVE_NCURSES_H
	43	#include <ncurses.h>
	44	#else
	45	#ifdef HAVE_CURSES_H
	46	#include <curses.h>
	47	#endif
	48	#endif
c906108c	49
5564c769 SC	50	/* Get a printable name for the function at the address.
	51	The symbol name is demangled if demangling is turned on.
	52	Returns a pointer to a static area holding the result. */
	53	static char* tui_get_function_from_frame (struct frame_info *fi);
c906108c	54
2e17b763 SC	55	/* Set the filename portion of the locator. */
	56	static void tui_set_locator_filename (const char *filename);
	57
	58	/* Update the locator, with the provided arguments. */
	59	static void tui_set_locator_info (const char filename, const char procname,
7d6dd1e9	60	int lineno, CORE_ADDR addr);
2e17b763	61
7563e053	62	static void tui_update_command (char *, int);
7d6dd1e9	63	\f
c906108c	64
50265402 SC	65	/* Create the status line to display as much information as we
	66	can on this single line: target name, process number, current
	67	function, current line, current PC, SingleKey mode. */
	68	static char*
	69	tui_make_status_line (TuiLocatorElement* loc)
	70	{
	71	char* string;
a42a37b7 SC	72	char line_buf[50], *pname;
	73	char* buf;
	74	int status_size;
50265402 SC	75	int i, proc_width;
	76	const char* pid_name;
	77	const char* pc_buf;
	78	int target_width;
	79	int pid_width;
	80	int line_width;
	81	int pc_width;
	82	struct ui_file *pc_out;
	83
	84	if (ptid_equal (inferior_ptid, null_ptid))
	85	pid_name = "No process";
	86	else
	87	pid_name = target_pid_to_str (inferior_ptid);
	88
	89	target_width = strlen (target_shortname);
	90	if (target_width > MAX_TARGET_WIDTH)
	91	target_width = MAX_TARGET_WIDTH;
	92
	93	pid_width = strlen (pid_name);
	94	if (pid_width > MAX_PID_WIDTH)
	95	pid_width = MAX_PID_WIDTH;
a42a37b7 SC	96
a42a37b7 SC	97	status_size = termWidth ();
50265402	98	string = (char *) xmalloc (status_size + 1);
a42a37b7	99	buf = (char*) alloca (status_size + 1);
50265402 SC	100
	101	/* Translate line number and obtain its size. */
	102	if (loc->lineNo > 0)
	103	sprintf (line_buf, "%d", loc->lineNo);
	104	else
	105	strcpy (line_buf, "??");
	106	line_width = strlen (line_buf);
	107	if (line_width < MIN_LINE_WIDTH)
	108	line_width = MIN_LINE_WIDTH;
	109
	110	/* Translate PC address. */
	111	pc_out = tui_sfileopen (128);
	112	print_address_numeric (loc->addr, 1, pc_out);
	113	pc_buf = tui_file_get_strbuf (pc_out);
	114	pc_width = strlen (pc_buf);
	115
	116	/* First determine the amount of proc name width we have available.
	117	The +1 are for a space separator between fields.
	118	The -1 are to take into account the \0 counted by sizeof. */
	119	proc_width = (status_size
	120	- (target_width + 1)
	121	- (pid_width + 1)
	122	- (sizeof (PROC_PREFIX) - 1 + 1)
	123	- (sizeof (LINE_PREFIX) - 1 + line_width + 1)
	124	- (sizeof (PC_PREFIX) - 1 + pc_width + 1)
	125	- (tui_current_key_mode == tui_single_key_mode
	126	? (sizeof (SINGLE_KEY) - 1 + 1)
	127	: 0));
	128
	129	/* If there is no room to print the function name, try by removing
	130	some fields. */
	131	if (proc_width < MIN_PROC_WIDTH)
	132	{
	133	proc_width += target_width + 1;
	134	target_width = 0;
	135	if (proc_width < MIN_PROC_WIDTH)
	136	{
	137	proc_width += pid_width + 1;
	138	pid_width = 0;
	139	if (proc_width <= MIN_PROC_WIDTH)
	140	{
	141	proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
	142	pc_width = 0;
	143	if (proc_width < 0)
	144	{
	145	proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
	146	line_width = 0;
	147	if (proc_width < 0)
	148	proc_width = 0;
	149	}
	150	}
	151	}
	152	}
	153
	154	/* Now convert elements to string form */
	155	pname = loc->procName;
	156
	157	/* Now create the locator line from the string version
	158	of the elements. We could use sprintf() here but
	159	that wouldn't ensure that we don't overrun the size
	160	of the allocated buffer. strcat_to_buf() will. */
	161	*string = (char) 0;
	162
	163	if (target_width > 0)
164	{
165	sprintf (buf, "%.s ",
166	-target_width, target_width, target_shortname);
167	strcat_to_buf (string, status_size, buf);
168	}
169	if (pid_width > 0)
170	{
171	sprintf (buf, "%.s ",
172	-pid_width, pid_width, pid_name);
173	strcat_to_buf (string, status_size, buf);
174	}
175
176	/* Show whether we are in SingleKey mode. */
177	if (tui_current_key_mode == tui_single_key_mode)
178	{
179	strcat_to_buf (string, status_size, SINGLE_KEY);
180	strcat_to_buf (string, status_size, " ");
181	}
182
183	/* procedure/class name */
184	if (proc_width > 0)
185	{
186	if (strlen (pname) > proc_width)
187	sprintf (buf, "%s%.s* ", PROC_PREFIX,
188	1 - proc_width, proc_width - 1, pname);
189	else
190	sprintf (buf, "%s%.s ", PROC_PREFIX,
191	-proc_width, proc_width, pname);
192	strcat_to_buf (string, status_size, buf);
193	}
194
195	if (line_width > 0)
196	{
197	sprintf (buf, "%s%.s ", LINE_PREFIX,
198	-line_width, line_width, line_buf);
199	strcat_to_buf (string, status_size, buf);
200	}
201	if (pc_width > 0)
202	{
203	strcat_to_buf (string, status_size, PC_PREFIX);
204	strcat_to_buf (string, status_size, pc_buf);
205	}
206
207
208	for (i = strlen (string); i < status_size; i++)
209	string[i] = ' ';
210	string[status_size] = (char) 0;
211
212	ui_file_delete (pc_out);
213	return string;
214	}
215
5564c769 SC	216	/* Get a printable name for the function at the address.
	217	The symbol name is demangled if demangling is turned on.
	218	Returns a pointer to a static area holding the result. */
	219	static char*
	220	tui_get_function_from_frame (struct frame_info *fi)
	221	{
	222	static char name[256];
	223	struct ui_file *stream = tui_sfileopen (256);
	224	char *p;
	225
f70a7d61	226	print_address_symbolic (get_frame_pc (fi), stream, demangle, "");
5564c769 SC	227	p = tui_file_get_strbuf (stream);
	228
	229	/* Use simple heuristics to isolate the function name. The symbol can
	230	be demangled and we can have function parameters. Remove them because
	231	the status line is too short to display them. */
	232	if (*p == '<')
	233	p++;
	234	strncpy (name, p, sizeof (name));
	235	p = strchr (name, '(');
	236	if (!p)
	237	p = strchr (name, '>');
	238	if (p)
	239	*p = 0;
	240	p = strchr (name, '+');
	241	if (p)
	242	*p = 0;
	243	ui_file_delete (stream);
	244	return name;
	245	}
c906108c	246
c906108c	247	/*
c5aa993b JM	248	** tuiShowLocatorContent()
c5aa993b JM	249	*/
c906108c	250	void
c906108c	251	tuiShowLocatorContent (void)
c906108c SS	252	{
	253	char *string;
	254	TuiGenWinInfoPtr locator;
	255
	256	locator = locatorWinInfoPtr ();
	257
	258	if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
	259	{
50265402 SC	260	TuiWinElementPtr element;
	261
	262	element = (TuiWinElementPtr) locator->content[0];
	263
	264	string = tui_make_status_line (&element->whichElement.locator);
	265	wmove (locator->handle, 0, 0);
	266	wstandout (locator->handle);
	267	waddstr (locator->handle, string);
	268	wclrtoeol (locator->handle);
	269	wstandend (locator->handle);
	270	tuiRefreshWin (locator);
	271	wmove (locator->handle, 0, 0);
	272	xfree (string);
	273	locator->contentInUse = TRUE;
c906108c	274	}
50265402	275	}
c906108c	276
c906108c	277
2e17b763 SC	278	/* Set the filename portion of the locator. */
	279	static void
	280	tui_set_locator_filename (const char *filename)
	281	{
	282	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	283	TuiLocatorElementPtr element;
	284
	285	if (locator->content[0] == (Opaque) NULL)
7d6dd1e9 SC	286	{
	287	tui_set_locator_info (filename, NULL, 0, 0);
	288	return;
	289	}
2e17b763 SC	290
	291	element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
	292	element->fileName[0] = 0;
	293	strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, filename);
	294	}
c906108c	295
c7c228ed	296	/* Update the locator, with the provided arguments. */
2e17b763 SC	297	static void
2e17b763 SC	298	tui_set_locator_info (const char filename, const char procname, int lineno,
7d6dd1e9	299	CORE_ADDR addr)
c906108c	300	{
7d6dd1e9 SC	301	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	302	TuiLocatorElementPtr element;
	303
	304	/* Allocate the locator content if necessary. */
	305	if (locator->contentSize <= 0)
	306	{
	307	locator->content = (OpaquePtr) allocContent (1, locator->type);
	308	locator->contentSize = 1;
	309	}
	310
	311	element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
c906108c	312	element->procName[0] = (char) 0;
c906108c	313	strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
2e17b763	314	element->lineNo = lineno;
c774cec6	315	element->addr = addr;
2e17b763	316	tui_set_locator_filename (filename);
c7c228ed	317	}
c906108c	318
2e17b763	319	/* Update only the filename portion of the locator. */
c906108c	320	void
2e17b763	321	tuiUpdateLocatorFilename (const char *filename)
c906108c	322	{
2e17b763	323	tui_set_locator_filename (filename);
c906108c	324	tuiShowLocatorContent ();
2e17b763	325	}
c906108c	326
7d6dd1e9	327	/* Function to print the frame information for the TUI. */
c906108c	328	void
eca6576c	329	tuiShowFrameInfo (struct frame_info *fi)
c906108c SS	330	{
	331	TuiWinInfoPtr winInfo;
	332	register int i;
	333
	334	if (fi)
	335	{
	336	register int startLine, i;
c906108c SS	337	CORE_ADDR low;
	338	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	339	int sourceAlreadyDisplayed;
7d6dd1e9 SC	340	struct symtab_and_line sal;
7d6dd1e9 SC	341
3d7442da	342	find_frame_sal (fi, &sal);
7d6dd1e9 SC	343
	344	sourceAlreadyDisplayed = sal.symtab != 0
	345	&& tuiSourceIsDisplayed (sal.symtab->filename);
	346	tui_set_locator_info (sal.symtab == 0 ? "??" : sal.symtab->filename,
	347	tui_get_function_from_frame (fi),
	348	sal.line,
f70a7d61	349	get_frame_pc (fi));
d059f789	350	tuiShowLocatorContent ();
7d6dd1e9	351	startLine = 0;
c906108c SS	352	for (i = 0; i < (sourceWindows ())->count; i++)
c906108c SS	353	{
a4b99e53	354	TuiWhichElement *item;
c906108c	355	winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
a4b99e53 SC	356
a4b99e53 SC	357	item = &((TuiWinElementPtr) locator->content[0])->whichElement;
c906108c SS	358	if (winInfo == srcWin)
c906108c SS	359	{
a4b99e53 SC	360	startLine = (item->locator.lineNo -
a4b99e53 SC	361	(winInfo->generic.viewportHeight / 2)) + 1;
c906108c SS	362	if (startLine <= 0)
	363	startLine = 1;
	364	}
	365	else
	366	{
f70a7d61 AS	367	if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
f70a7d61 AS	368	&low, (CORE_ADDR) NULL) == 0)
c906108c SS	369	error ("No function contains program counter for selected frame.\n");
c906108c SS	370	else
f70a7d61	371	low = tuiGetLowDisassemblyAddress (low, get_frame_pc (fi));
c906108c SS	372	}
	373
	374	if (winInfo == srcWin)
	375	{
a4b99e53 SC	376	TuiLineOrAddress l;
	377	l.lineNo = startLine;
	378	if (!(sourceAlreadyDisplayed
	379	&& tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
7d6dd1e9	380	tuiUpdateSourceWindow (winInfo, sal.symtab, l, TRUE);
c906108c	381	else
a4b99e53 SC	382	{
	383	l.lineNo = item->locator.lineNo;
	384	tuiSetIsExecPointAt (l, winInfo);
	385	}
c906108c SS	386	}
	387	else
	388	{
	389	if (winInfo == disassemWin)
	390	{
a4b99e53 SC	391	TuiLineOrAddress a;
	392	a.addr = low;
	393	if (!tuiAddrIsDisplayed (item->locator.addr, winInfo, TRUE))
7d6dd1e9	394	tuiUpdateSourceWindow (winInfo, sal.symtab, a, TRUE);
c906108c	395	else
a4b99e53 SC	396	{
	397	a.addr = item->locator.addr;
	398	tuiSetIsExecPointAt (a, winInfo);
	399	}
c906108c SS	400	}
	401	}
	402	tuiUpdateExecInfo (winInfo);
	403	}
	404	}
	405	else
	406	{
7d6dd1e9	407	tui_set_locator_info (NULL, NULL, 0, (CORE_ADDR) 0);
d059f789	408	tuiShowLocatorContent ();
c906108c SS	409	for (i = 0; i < (sourceWindows ())->count; i++)
	410	{
	411	winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
	412	tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
	413	tuiUpdateExecInfo (winInfo);
	414	}
	415	}
7d6dd1e9	416	}
c906108c	417
7563e053	418	/* Function to initialize gdb commands, for tui window stack manipulation. */
c906108c	419	void
fba45db2	420	_initialize_tuiStack (void)
c906108c	421	{
7563e053 SC	422	add_com ("update", class_tui, tui_update_command,
	423	"Update the source window and locator to display the current "
	424	"execution point.\n");
41783295	425	}
c906108c	426
7563e053	427	/* Command to update the display with the current execution point. */
c906108c	428	static void
7563e053	429	tui_update_command (char *arg, int from_tty)
c906108c	430	{
7563e053	431	char cmd[sizeof("frame 0")];
c906108c	432
7563e053 SC	433	strcpy (cmd, "frame 0");
	434	execute_command (cmd, from_tty);
	435	}