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

/* TUI display locator.

   Copyright 1998, 1999, 2000, 2001, 2002 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.  */

/* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
   "defs.h" should be included first.  Unfortunatly some systems
   (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
   and they clash with "bfd.h"'s definiton of true/false.  The correct
   fix is to remove true/false from "bfd.h", however, until that
   happens, hack around it by including "config.h" and <curses.h>
   first.  */

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

#include "defs.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
#include "command.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"


/* 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 void tui_update_command (char *, int);


/* 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 (fi->pc, 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)
    {
      string = displayableWinContentAt (locator, 0);
      if (string != (char *) NULL)
	{
	  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);
	  if (string != nullStr ())
	    tuiFree (string);
	  locator->contentInUse = TRUE;
	}
    }

  return;
}				/* tuiShowLocatorContent */


/* Update the locator, with the provided arguments.  */
void
tuiSetLocatorInfo (char *fname, char *procname, int lineNo,
                   CORE_ADDR addr, TuiLocatorElementPtr element)
{
  element->fileName[0] = (char) 0;
  element->procName[0] = (char) 0;
  strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, fname);
  strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
  element->lineNo = lineNo;
  element->addr = addr;
}


/*
   ** tuiUpdateLocatorFilename().
   **        Update only the filename portion of the locator.
 */
void
tuiUpdateLocatorFilename (const char *fileName)
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();

  if (locator->content[0] == (Opaque) NULL)
    tuiSetLocatorContent ((struct frame_info *) NULL);
  ((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName[0] = (char) 0;
  strcat_to_buf (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName,
		 MAX_LOCATOR_ELEMENT_LEN,
		 fileName);

  tuiShowLocatorContent ();

  return;
}				/* tuiUpdateLocatorFilename */

/*
   ** tuiSwitchFilename().
   **   Update the filename portion of the locator. Clear the other info in locator.
   ** (elz)
 */
void
tuiSwitchFilename (char *fileName)
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();

  if (locator->content[0] == (Opaque) NULL)
    tuiSetLocatorContent ((struct frame_info *) NULL);
  ((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName[0] = (char) 0;

  tuiSetLocatorInfo (fileName,
		     (char *) NULL,
		     0,
		     (CORE_ADDR) 0,
	   &((TuiWinElementPtr) locator->content[0])->whichElement.locator);

  tuiShowLocatorContent ();

  return;
}				/* tuiSwitchFilename */


/*
   ** tuiGetLocatorFilename().
   **   Get the filename portion of the locator.
   ** (elz)
 */
void
tuiGetLocatorFilename (TuiGenWinInfoPtr locator, char **filename)
{

  /* the current filename could be non known, in which case the xmalloc would
     allocate no memory, because the length would be 0 */
  if (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName)
    {
      int name_length =
      strlen (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName);

      (*filename) = (char *) xmalloc (name_length + 1);
      strcpy ((*filename),
	      ((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName);
    }

  return;
}				/* tuiGetLocatorFilename */


/*
   ** tuiUpdateLocatorInfoFromFrame().
   **        Function to update the locator, with the information extracted from frameInfo
 */
void
tuiUpdateLocatorInfoFromFrame (struct frame_info *frameInfo,
                               TuiLocatorElementPtr element)
{
  struct symtab_and_line symtabAndLine;

  /* now get the new info */
  symtabAndLine = find_pc_line (frameInfo->pc,
			   (frameInfo->next != (struct frame_info *) NULL &&
			    !frameInfo->next->signal_handler_caller &&
			    !frame_in_dummy (frameInfo->next)));
  if (symtabAndLine.symtab && symtabAndLine.symtab->filename)
    tuiSetLocatorInfo (symtabAndLine.symtab->filename,
		       tui_get_function_from_frame (frameInfo),
		       symtabAndLine.line,
		       frameInfo->pc,
		       element);
  else
    tuiSetLocatorInfo ((char *) NULL,
		       tui_get_function_from_frame (frameInfo),
		       0,
		       frameInfo->pc,
		       element);

  return;
}				/* tuiUpdateLocatorInfoFromFrame */


/*
   ** tuiSetLocatorContent().
   **        Function to set the content of the locator
 */
void
tuiSetLocatorContent (struct frame_info *frameInfo)
{
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
  TuiWinElementPtr element;
  struct symtab_and_line symtabAndLine;

  /* Allocate the element if necessary */
  if (locator->contentSize <= 0)
    {
      TuiWinContent contentPtr;

      if ((locator->content = (OpaquePtr) allocContent (1, locator->type)) == (OpaquePtr) NULL)
	error ("Unable to Allocate Memory to Display Location.");
      locator->contentSize = 1;
    }

  if (frameInfo != (struct frame_info *) NULL)
    tuiUpdateLocatorInfoFromFrame (frameInfo,
	   &((TuiWinElementPtr) locator->content[0])->whichElement.locator);
  else
    tuiSetLocatorInfo ((char *) NULL,
		       (char *) NULL,
		       0,
		       (CORE_ADDR) 0,
	   &((TuiWinElementPtr) locator->content[0])->whichElement.locator);
  return;
}				/* tuiSetLocatorContent */


/*
   ** tuiUpdateLocatorDisplay().
   **        Function to update the locator display
 */
void
tuiUpdateLocatorDisplay (struct frame_info *frameInfo)
{
  tuiSetLocatorContent (frameInfo);
  tuiShowLocatorContent ();

  return;
}				/* tuiUpdateLocatorDisplay */


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

  if (fi)
    {
      register int startLine, i;
      register struct symtab *s;
      CORE_ADDR low;
      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
      int sourceAlreadyDisplayed;


      s = find_pc_symtab (fi->pc);
      if (s == 0)
        return;

      startLine = 0;
      sourceAlreadyDisplayed = tuiSourceIsDisplayed (s->filename);
      tuiUpdateLocatorDisplay (fi);
      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 (fi->pc, (char **) NULL, &low, (CORE_ADDR) NULL) == 0)
		error ("No function contains program counter for selected frame.\n");
	      else
		low = tuiGetLowDisassemblyAddress (low, fi->pc);
	    }

	  if (winInfo == srcWin)
	    {
	      TuiLineOrAddress l;
	      l.lineNo = startLine;
	      if (!(sourceAlreadyDisplayed
		    && tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
		tuiUpdateSourceWindow (winInfo, s, 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, s, a, TRUE);
		  else
		    {
		      a.addr = item->locator.addr;
		      tuiSetIsExecPointAt (a, winInfo);
		    }
		}
	    }
	  tuiUpdateExecInfo (winInfo);
	}
    }
  else
    {
      tuiUpdateLocatorDisplay (fi);
      for (i = 0; i < (sourceWindows ())->count; i++)
	{
	  winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
	  tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
	  tuiUpdateExecInfo (winInfo);
	}
    }

  return;
}				/* tuiShowFrameInfo */

/* 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 AC	2
	3	Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
	4	Inc.
	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	24
f33c6cbf AC	25	/* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
	26	"defs.h" should be included first. Unfortunatly some systems
	27	(currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
	28	and they clash with "bfd.h"'s definiton of true/false. The correct
	29	fix is to remove true/false from "bfd.h", however, until that
	30	happens, hack around it by including "config.h" and <curses.h>
	31	first. */
	32
4e8f7a8b DJ	33	#include "config.h"
	34	#ifdef HAVE_NCURSES_H
	35	#include <ncurses.h>
	36	#else
	37	#ifdef HAVE_CURSES_H
	38	#include <curses.h>
	39	#endif
	40	#endif
	41
c906108c SS	42	#include "defs.h"
	43	#include "symtab.h"
	44	#include "breakpoint.h"
	45	#include "frame.h"
75fd9bc1	46	#include "command.h"
7563e053	47	#include "top.h"
c906108c SS	48
	49	#include "tui.h"
	50	#include "tuiData.h"
	51	#include "tuiStack.h"
75fd9bc1 SC	52	#include "tuiGeneralWin.h"
75fd9bc1 SC	53	#include "tuiSource.h"
c906108c	54	#include "tuiSourceWin.h"
5564c769	55	#include "tui-file.h"
c906108c SS	56
c906108c SS	57
5564c769 SC	58	/* Get a printable name for the function at the address.
	59	The symbol name is demangled if demangling is turned on.
	60	Returns a pointer to a static area holding the result. */
	61	static char* tui_get_function_from_frame (struct frame_info *fi);
c906108c	62
7563e053	63	static void tui_update_command (char *, int);
c906108c SS	64
c906108c SS	65
5564c769 SC	66	/* Get a printable name for the function at the address.
	67	The symbol name is demangled if demangling is turned on.
	68	Returns a pointer to a static area holding the result. */
	69	static char*
	70	tui_get_function_from_frame (struct frame_info *fi)
	71	{
	72	static char name[256];
	73	struct ui_file *stream = tui_sfileopen (256);
	74	char *p;
	75
	76	print_address_symbolic (fi->pc, stream, demangle, "");
	77	p = tui_file_get_strbuf (stream);
	78
	79	/* Use simple heuristics to isolate the function name. The symbol can
	80	be demangled and we can have function parameters. Remove them because
	81	the status line is too short to display them. */
	82	if (*p == '<')
	83	p++;
	84	strncpy (name, p, sizeof (name));
	85	p = strchr (name, '(');
	86	if (!p)
	87	p = strchr (name, '>');
	88	if (p)
	89	*p = 0;
	90	p = strchr (name, '+');
	91	if (p)
	92	*p = 0;
	93	ui_file_delete (stream);
	94	return name;
	95	}
c906108c	96
c906108c	97	/*
c5aa993b JM	98	** tuiShowLocatorContent()
c5aa993b JM	99	*/
c906108c	100	void
c906108c	101	tuiShowLocatorContent (void)
c906108c SS	102	{
	103	char *string;
	104	TuiGenWinInfoPtr locator;
	105
	106	locator = locatorWinInfoPtr ();
	107
	108	if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
	109	{
	110	string = displayableWinContentAt (locator, 0);
	111	if (string != (char *) NULL)
	112	{
	113	wmove (locator->handle, 0, 0);
	114	wstandout (locator->handle);
	115	waddstr (locator->handle, string);
3a42771a	116	wclrtoeol (locator->handle);
c906108c SS	117	wstandend (locator->handle);
	118	tuiRefreshWin (locator);
	119	wmove (locator->handle, 0, 0);
	120	if (string != nullStr ())
	121	tuiFree (string);
	122	locator->contentInUse = TRUE;
	123	}
	124	}
	125
	126	return;
	127	} /* tuiShowLocatorContent */
	128
	129
c7c228ed	130	/* Update the locator, with the provided arguments. */
c906108c	131	void
eca6576c	132	tuiSetLocatorInfo (char fname, char procname, int lineNo,
c774cec6	133	CORE_ADDR addr, TuiLocatorElementPtr element)
c906108c	134	{
c906108c SS	135	element->fileName[0] = (char) 0;
	136	element->procName[0] = (char) 0;
	137	strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, fname);
	138	strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
c906108c	139	element->lineNo = lineNo;
c774cec6	140	element->addr = addr;
c7c228ed	141	}
c906108c SS	142
	143
	144	/*
c5aa993b JM	145	** tuiUpdateLocatorFilename().
	146	** Update only the filename portion of the locator.
	147	*/
c906108c	148	void
c6f60bcd	149	tuiUpdateLocatorFilename (const char *fileName)
c906108c SS	150	{
	151	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	152
	153	if (locator->content[0] == (Opaque) NULL)
	154	tuiSetLocatorContent ((struct frame_info *) NULL);
	155	((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName[0] = (char) 0;
	156	strcat_to_buf (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName,
	157	MAX_LOCATOR_ELEMENT_LEN,
	158	fileName);
	159
	160	tuiShowLocatorContent ();
	161
	162	return;
	163	} /* tuiUpdateLocatorFilename */
	164
c906108c	165	/*
c5aa993b JM	166	** tuiSwitchFilename().
	167	** Update the filename portion of the locator. Clear the other info in locator.
	168	** (elz)
	169	*/
c906108c	170	void
eca6576c	171	tuiSwitchFilename (char *fileName)
c906108c SS	172	{
	173	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	174
	175	if (locator->content[0] == (Opaque) NULL)
	176	tuiSetLocatorContent ((struct frame_info *) NULL);
	177	((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName[0] = (char) 0;
	178
	179	tuiSetLocatorInfo (fileName,
	180	(char *) NULL,
	181	0,
c774cec6	182	(CORE_ADDR) 0,
c906108c SS	183	&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
	184
	185	tuiShowLocatorContent ();
	186
	187	return;
	188	} /* tuiSwitchFilename */
	189
	190
	191	/*
c5aa993b JM	192	** tuiGetLocatorFilename().
	193	** Get the filename portion of the locator.
	194	** (elz)
	195	*/
c906108c	196	void
eca6576c	197	tuiGetLocatorFilename (TuiGenWinInfoPtr locator, char **filename)
c906108c SS	198	{
	199
	200	/* the current filename could be non known, in which case the xmalloc would
	201	allocate no memory, because the length would be 0 */
	202	if (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName)
	203	{
	204	int name_length =
	205	strlen (((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName);
	206
	207	(filename) = (char ) xmalloc (name_length + 1);
	208	strcpy ((*filename),
	209	((TuiWinElementPtr) locator->content[0])->whichElement.locator.fileName);
	210	}
	211
	212	return;
	213	} /* tuiGetLocatorFilename */
	214
	215
	216	/*
c5aa993b JM	217	** tuiUpdateLocatorInfoFromFrame().
	218	** Function to update the locator, with the information extracted from frameInfo
	219	*/
c906108c	220	void
eca6576c SC	221	tuiUpdateLocatorInfoFromFrame (struct frame_info *frameInfo,
eca6576c SC	222	TuiLocatorElementPtr element)
c906108c SS	223	{
	224	struct symtab_and_line symtabAndLine;
	225
	226	/* now get the new info */
	227	symtabAndLine = find_pc_line (frameInfo->pc,
	228	(frameInfo->next != (struct frame_info *) NULL &&
	229	!frameInfo->next->signal_handler_caller &&
	230	!frame_in_dummy (frameInfo->next)));
	231	if (symtabAndLine.symtab && symtabAndLine.symtab->filename)
	232	tuiSetLocatorInfo (symtabAndLine.symtab->filename,
5564c769	233	tui_get_function_from_frame (frameInfo),
c906108c	234	symtabAndLine.line,
c774cec6	235	frameInfo->pc,
c906108c SS	236	element);
	237	else
	238	tuiSetLocatorInfo ((char *) NULL,
5564c769	239	tui_get_function_from_frame (frameInfo),
c906108c	240	0,
c774cec6	241	frameInfo->pc,
c906108c SS	242	element);
	243
	244	return;
	245	} /* tuiUpdateLocatorInfoFromFrame */
	246
	247
	248	/*
c5aa993b JM	249	** tuiSetLocatorContent().
	250	** Function to set the content of the locator
	251	*/
c906108c	252	void
eca6576c	253	tuiSetLocatorContent (struct frame_info *frameInfo)
c906108c SS	254	{
	255	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	256	TuiWinElementPtr element;
	257	struct symtab_and_line symtabAndLine;
	258
	259	/* Allocate the element if necessary */
	260	if (locator->contentSize <= 0)
	261	{
	262	TuiWinContent contentPtr;
	263
	264	if ((locator->content = (OpaquePtr) allocContent (1, locator->type)) == (OpaquePtr) NULL)
	265	error ("Unable to Allocate Memory to Display Location.");
	266	locator->contentSize = 1;
	267	}
	268
	269	if (frameInfo != (struct frame_info *) NULL)
	270	tuiUpdateLocatorInfoFromFrame (frameInfo,
	271	&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
	272	else
	273	tuiSetLocatorInfo ((char *) NULL,
	274	(char *) NULL,
	275	0,
c774cec6	276	(CORE_ADDR) 0,
c906108c SS	277	&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
	278	return;
	279	} /* tuiSetLocatorContent */
	280
	281
	282	/*
c5aa993b JM	283	** tuiUpdateLocatorDisplay().
	284	** Function to update the locator display
	285	*/
c906108c	286	void
eca6576c	287	tuiUpdateLocatorDisplay (struct frame_info *frameInfo)
c906108c	288	{
c906108c SS	289	tuiSetLocatorContent (frameInfo);
	290	tuiShowLocatorContent ();
	291
	292	return;
	293	} /* tuiUpdateLocatorDisplay */
	294
	295
	296	/*
c5aa993b JM	297	** tuiShowFrameInfo().
	298	** Function to print the frame inforrmation for the TUI.
	299	*/
c906108c	300	void
eca6576c	301	tuiShowFrameInfo (struct frame_info *fi)
c906108c SS	302	{
	303	TuiWinInfoPtr winInfo;
	304	register int i;
	305
	306	if (fi)
	307	{
	308	register int startLine, i;
	309	register struct symtab *s;
	310	CORE_ADDR low;
	311	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	312	int sourceAlreadyDisplayed;
	313
	314
	315	s = find_pc_symtab (fi->pc);
75fd9bc1 SC	316	if (s == 0)
	317	return;
	318
a4b99e53	319	startLine = 0;
c906108c SS	320	sourceAlreadyDisplayed = tuiSourceIsDisplayed (s->filename);
	321	tuiUpdateLocatorDisplay (fi);
	322	for (i = 0; i < (sourceWindows ())->count; i++)
	323	{
a4b99e53	324	TuiWhichElement *item;
c906108c	325	winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
a4b99e53 SC	326
a4b99e53 SC	327	item = &((TuiWinElementPtr) locator->content[0])->whichElement;
c906108c SS	328	if (winInfo == srcWin)
c906108c SS	329	{
a4b99e53 SC	330	startLine = (item->locator.lineNo -
a4b99e53 SC	331	(winInfo->generic.viewportHeight / 2)) + 1;
c906108c SS	332	if (startLine <= 0)
	333	startLine = 1;
	334	}
	335	else
	336	{
	337	if (find_pc_partial_function (fi->pc, (char **) NULL, &low, (CORE_ADDR) NULL) == 0)
	338	error ("No function contains program counter for selected frame.\n");
	339	else
c774cec6	340	low = tuiGetLowDisassemblyAddress (low, fi->pc);
c906108c SS	341	}
	342
	343	if (winInfo == srcWin)
	344	{
a4b99e53 SC	345	TuiLineOrAddress l;
	346	l.lineNo = startLine;
	347	if (!(sourceAlreadyDisplayed
	348	&& tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
	349	tuiUpdateSourceWindow (winInfo, s, l, TRUE);
c906108c	350	else
a4b99e53 SC	351	{
	352	l.lineNo = item->locator.lineNo;
	353	tuiSetIsExecPointAt (l, winInfo);
	354	}
c906108c SS	355	}
	356	else
	357	{
	358	if (winInfo == disassemWin)
	359	{
a4b99e53 SC	360	TuiLineOrAddress a;
	361	a.addr = low;
	362	if (!tuiAddrIsDisplayed (item->locator.addr, winInfo, TRUE))
	363	tuiUpdateSourceWindow (winInfo, s, a, TRUE);
c906108c	364	else
a4b99e53 SC	365	{
	366	a.addr = item->locator.addr;
	367	tuiSetIsExecPointAt (a, winInfo);
	368	}
c906108c SS	369	}
	370	}
	371	tuiUpdateExecInfo (winInfo);
	372	}
	373	}
	374	else
	375	{
	376	tuiUpdateLocatorDisplay (fi);
	377	for (i = 0; i < (sourceWindows ())->count; i++)
	378	{
	379	winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
	380	tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
	381	tuiUpdateExecInfo (winInfo);
	382	}
	383	}
	384
	385	return;
	386	} /* tuiShowFrameInfo */
	387
7563e053	388	/* Function to initialize gdb commands, for tui window stack manipulation. */
c906108c	389	void
fba45db2	390	_initialize_tuiStack (void)
c906108c	391	{
7563e053 SC	392	add_com ("update", class_tui, tui_update_command,
	393	"Update the source window and locator to display the current "
	394	"execution point.\n");
41783295	395	}
c906108c	396
7563e053	397	/* Command to update the display with the current execution point. */
c906108c	398	static void
7563e053	399	tui_update_command (char *arg, int from_tty)
c906108c	400	{
7563e053	401	char cmd[sizeof("frame 0")];
c906108c	402
7563e053 SC	403	strcpy (cmd, "frame 0");
	404	execute_command (cmd, from_tty);
	405	}