binutils-gdb/gdb/tui/tuiSourceWin.c

1114 lines
25 KiB
C
Raw Normal View History

/* TUI display source/assembly window.
Copyright 1998, 1999, 2000, 2001 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 <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "breakpoint.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiStack.h"
#include "tuiSourceWin.h"
#include "tuiSource.h"
#include "tuiDisassem.h"
/*****************************************
** EXTERNAL FUNCTION DECLS **
******************************************/
/*****************************************
** EXTERNAL DATA DECLS **
******************************************/
extern int current_source_line;
extern struct symtab *current_source_symtab;
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
/*****************************************
** STATIC LOCAL DATA **
******************************************/
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
/*********************************
** SOURCE/DISASSEM FUNCTIONS **
*********************************/
/*
1999-07-07 22:19:36 +02:00
** tuiSrcWinIsDisplayed().
*/
int
#ifdef __STDC__
tuiSrcWinIsDisplayed (void)
#else
tuiSrcWinIsDisplayed ()
#endif
{
return (m_winPtrNotNull (srcWin) && srcWin->generic.isVisible);
} /* tuiSrcWinIsDisplayed */
/*
1999-07-07 22:19:36 +02:00
** tuiAsmWinIsDisplayed().
*/
int
#ifdef __STDC__
tuiAsmWinIsDisplayed (void)
#else
tuiAsmWinIsDisplayed ()
#endif
{
return (m_winPtrNotNull (disassemWin) && disassemWin->generic.isVisible);
} /* tuiAsmWinIsDisplayed */
/*
1999-07-07 22:19:36 +02:00
** tuiDisplayMainFunction().
** Function to display the "main" routine"
*/
void
#ifdef __STDC__
tuiDisplayMainFunction (void)
#else
tuiDisplayMainFunction ()
#endif
{
if ((sourceWindows ())->count > 0)
{
CORE_ADDR addr;
addr = parse_and_eval_address ("main");
if (addr <= (CORE_ADDR) 0)
addr = parse_and_eval_address ("MAIN");
if (addr > (CORE_ADDR) 0)
{
struct symtab_and_line sal;
tuiUpdateSourceWindowsWithAddr ((Opaque) addr);
sal = find_pc_line (addr, 0);
tuiSwitchFilename (sal.symtab->filename);
}
}
return;
} /* tuiDisplayMainFunction */
/*
1999-07-07 22:19:36 +02:00
** tuiUpdateSourceWindow().
** Function to display source in the source window. This function
** initializes the horizontal scroll to 0.
*/
void
#ifdef __STDC__
tuiUpdateSourceWindow (
TuiWinInfoPtr winInfo,
struct symtab *s,
Opaque lineOrAddr,
int noerror)
#else
tuiUpdateSourceWindow (winInfo, s, lineOrAddr, noerror)
TuiWinInfoPtr winInfo;
struct symtab *s;
Opaque lineOrAddr;
int noerror;
#endif
{
winInfo->detail.sourceInfo.horizontalOffset = 0;
tuiUpdateSourceWindowAsIs (winInfo, s, lineOrAddr, noerror);
return;
} /* tuiUpdateSourceWindow */
/*
1999-07-07 22:19:36 +02:00
** tuiUpdateSourceWindowAsIs().
** Function to display source in the source/asm window. This
** function shows the source as specified by the horizontal offset.
*/
void
#ifdef __STDC__
tuiUpdateSourceWindowAsIs (
TuiWinInfoPtr winInfo,
struct symtab *s,
Opaque lineOrAddr,
int noerror)
#else
tuiUpdateSourceWindowAsIs (winInfo, s, lineOrAddr, noerror)
TuiWinInfoPtr winInfo;
struct symtab *s;
Opaque lineOrAddr;
int noerror;
#endif
{
TuiStatus ret;
if (winInfo->generic.type == SRC_WIN)
ret = tuiSetSourceContent (s, (int) lineOrAddr, noerror);
else
ret = tuiSetDisassemContent (s, (Opaque) lineOrAddr);
if (ret == TUI_FAILURE)
{
tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
tuiClearExecInfoContent (winInfo);
}
else
{
tuiEraseSourceContent (winInfo, NO_EMPTY_SOURCE_PROMPT);
tuiShowSourceContent (winInfo);
tuiUpdateExecInfo (winInfo);
if (winInfo->generic.type == SRC_WIN)
{
current_source_line = (int) lineOrAddr +
(winInfo->generic.contentSize - 2);
current_source_symtab = s;
/*
1999-07-07 22:19:36 +02:00
** If the focus was in the asm win, put it in the src
** win if we don't have a split layout
*/
if (tuiWinWithFocus () == disassemWin &&
currentLayout () != SRC_DISASSEM_COMMAND)
tuiSetWinFocusTo (srcWin);
}
}
return;
} /* tuiUpdateSourceWindowAsIs */
/*
1999-07-07 22:19:36 +02:00
** tuiUpdateSourceWindowsWithAddr().
** Function to ensure that the source and/or disassemly windows
** reflect the input address.
*/
void
#ifdef __STDC__
tuiUpdateSourceWindowsWithAddr (
Opaque addr)
#else
tuiUpdateSourceWindowsWithAddr (addr)
Opaque addr;
#endif
{
if (addr > (Opaque) NULL)
{
struct symtab_and_line sal;
switch (currentLayout ())
{
case DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
tuiShowDisassem (addr);
break;
case SRC_DISASSEM_COMMAND:
tuiShowDisassemAndUpdateSource (addr);
break;
default:
sal = find_pc_line ((CORE_ADDR) addr, 0);
tuiShowSource (sal.symtab,
(Opaque) sal.line,
FALSE);
break;
}
}
else
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
{
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
tuiClearExecInfoContent (winInfo);
}
}
return;
} /* tuiUpdateSourceWindowsWithAddr */
/*
1999-07-07 22:19:36 +02:00
** tui_vUpdateSourceWindowsWithAddr()
** Update the source window with the address in a va_list
*/
void
#ifdef __STDC__
tui_vUpdateSourceWindowsWithAddr (
va_list args)
#else
tui_vUpdateSourceWindowsWithAddr (args)
va_list args;
#endif
{
Opaque addr = va_arg (args, Opaque);
tuiUpdateSourceWindowsWithAddr (addr);
return;
} /* tui_vUpdateSourceWindowsWithAddr */
/*
1999-07-07 22:19:36 +02:00
** tuiUpdateSourceWindowsWithLine().
** Function to ensure that the source and/or disassemly windows
** reflect the input address.
*/
void
#ifdef __STDC__
tuiUpdateSourceWindowsWithLine (
struct symtab *s,
int line)
#else
tuiUpdateSourceWindowsWithLine (s, line)
struct symtab *s;
int line;
#endif
{
switch (currentLayout ())
{
case DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
tuiUpdateSourceWindowsWithAddr ((Opaque) find_line_pc (s, line));
break;
default:
tuiShowSource (s, (Opaque) line, FALSE);
if (currentLayout () == SRC_DISASSEM_COMMAND)
tuiShowDisassem ((Opaque) find_line_pc (s, line));
break;
}
return;
} /* tuiUpdateSourceWindowsWithLine */
/*
1999-07-07 22:19:36 +02:00
** tui_vUpdateSourceWindowsWithLine()
** Update the source window with the line number in a va_list
*/
void
#ifdef __STDC__
tui_vUpdateSourceWindowsWithLine (
va_list args)
#else
tui_vUpdateSourceWindowsWithLine (args)
va_list args;
#endif
{
struct symtab *s = va_arg (args, struct symtab *);
int line = va_arg (args, int);
tuiUpdateSourceWindowsWithLine (s, line);
return;
} /* tui_vUpdateSourceWindowsWithLine */
/*
1999-07-07 22:19:36 +02:00
** tuiClearSourceContent().
*/
void
#ifdef __STDC__
tuiClearSourceContent (
TuiWinInfoPtr winInfo,
int displayPrompt)
#else
tuiClearSourceContent (winInfo, displayPrompt)
TuiWinInfoPtr winInfo;
int displayPrompt;
#endif
{
if (m_winPtrNotNull (winInfo))
{
register int i;
winInfo->generic.contentInUse = FALSE;
tuiEraseSourceContent (winInfo, displayPrompt);
for (i = 0; i < winInfo->generic.contentSize; i++)
{
TuiWinElementPtr element =
(TuiWinElementPtr) winInfo->generic.content[i];
element->whichElement.source.hasBreak = FALSE;
element->whichElement.source.isExecPoint = FALSE;
}
}
return;
} /* tuiClearSourceContent */
/*
1999-07-07 22:19:36 +02:00
** tuiClearAllSourceWinsContent().
*/
void
#ifdef __STDC__
tuiClearAllSourceWinsContent (
int displayPrompt)
#else
tuiClearAllSourceWinsContent (displayPrompt)
int displayPrompt;
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiClearSourceContent ((TuiWinInfoPtr) (sourceWindows ())->list[i],
displayPrompt);
return;
} /* tuiClearAllSourceWinsContent */
/*
1999-07-07 22:19:36 +02:00
** tuiEraseSourceContent().
*/
void
#ifdef __STDC__
tuiEraseSourceContent (
TuiWinInfoPtr winInfo,
int displayPrompt)
#else
tuiEraseSourceContent (winInfo, displayPrompt)
TuiWinInfoPtr winInfo;
int displayPrompt;
#endif
{
int xPos;
int halfWidth = (winInfo->generic.width - 2) / 2;
if (winInfo->generic.handle != (WINDOW *) NULL)
{
werase (winInfo->generic.handle);
checkAndDisplayHighlightIfNeeded (winInfo);
if (displayPrompt == EMPTY_SOURCE_PROMPT)
{
char *noSrcStr;
if (winInfo->generic.type == SRC_WIN)
noSrcStr = NO_SRC_STRING;
else
noSrcStr = NO_DISASSEM_STRING;
if (strlen (noSrcStr) >= halfWidth)
xPos = 1;
else
xPos = halfWidth - strlen (noSrcStr);
mvwaddstr (winInfo->generic.handle,
(winInfo->generic.height / 2),
xPos,
noSrcStr);
/* elz: added this function call to set the real contents of
1999-07-07 22:19:36 +02:00
the window to what is on the screen, so that later calls
to refresh, do display
the correct stuff, and not the old image */
tuiSetSourceContentNil (winInfo, noSrcStr);
}
tuiRefreshWin (&winInfo->generic);
}
return;
} /* tuiEraseSourceContent */
/*
1999-07-07 22:19:36 +02:00
** tuiEraseAllSourceContent().
*/
void
#ifdef __STDC__
tuiEraseAllSourceWinsContent (
int displayPrompt)
#else
tuiEraseAllSourceWinsContent (displayPrompt)
int displayPrompt;
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiEraseSourceContent ((TuiWinInfoPtr) (sourceWindows ())->list[i],
displayPrompt);
return;
} /* tuiEraseAllSourceWinsContent */
/*
1999-07-07 22:19:36 +02:00
** tuiShowSourceContent().
*/
void
#ifdef __STDC__
tuiShowSourceContent (
TuiWinInfoPtr winInfo)
#else
tuiShowSourceContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
int curLine, i, curX;
tuiEraseSourceContent (winInfo, (winInfo->generic.contentSize <= 0));
if (winInfo->generic.contentSize > 0)
{
char *line;
for (curLine = 1; (curLine <= winInfo->generic.contentSize); curLine++)
mvwaddstr (
winInfo->generic.handle,
curLine,
1,
((TuiWinElementPtr)
winInfo->generic.content[curLine - 1])->whichElement.source.line);
}
checkAndDisplayHighlightIfNeeded (winInfo);
tuiRefreshWin (&winInfo->generic);
winInfo->generic.contentInUse = TRUE;
return;
} /* tuiShowSourceContent */
/*
1999-07-07 22:19:36 +02:00
** tuiShowAllSourceWinsContent()
*/
void
#ifdef __STDC__
tuiShowAllSourceWinsContent (void)
#else
tuiShowAllSourceWinsContent ()
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiShowSourceContent ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
return;
} /* tuiShowAllSourceWinsContent */
/*
1999-07-07 22:19:36 +02:00
** tuiHorizontalSourceScroll().
** Scroll the source forward or backward horizontally
*/
void
#ifdef __STDC__
tuiHorizontalSourceScroll (
TuiWinInfoPtr winInfo,
TuiScrollDirection direction,
int numToScroll)
#else
tuiHorizontalSourceScroll (winInfo, direction, numToScroll)
TuiWinInfoPtr winInfo;
TuiScrollDirection direction;
int numToScroll;
#endif
{
if (winInfo->generic.content != (OpaquePtr) NULL)
{
int offset;
struct symtab *s;
if (current_source_symtab == (struct symtab *) NULL)
s = find_pc_symtab (selected_frame->pc);
else
s = current_source_symtab;
if (direction == LEFT_SCROLL)
offset = winInfo->detail.sourceInfo.horizontalOffset + numToScroll;
else
{
if ((offset =
winInfo->detail.sourceInfo.horizontalOffset - numToScroll) < 0)
offset = 0;
}
winInfo->detail.sourceInfo.horizontalOffset = offset;
tuiUpdateSourceWindowAsIs (
winInfo,
s,
((winInfo == srcWin) ?
(Opaque) ((TuiWinElementPtr)
winInfo->generic.content[0])->whichElement.source.lineOrAddr.lineNo :
(Opaque) ((TuiWinElementPtr)
winInfo->generic.content[0])->whichElement.source.lineOrAddr.addr),
(int) FALSE);
}
return;
} /* tuiHorizontalSourceScroll */
/*
1999-07-07 22:19:36 +02:00
** tuiSetHasExecPointAt().
** Set or clear the hasBreak flag in the line whose line is lineNo.
*/
void
#ifdef __STDC__
tuiSetIsExecPointAt (
Opaque lineOrAddr,
TuiWinInfoPtr winInfo)
#else
tuiSetIsExecPointAt (lineOrAddr, winInfo)
Opaque lineOrAddr;
TuiWinInfoPtr winInfo;
#endif
{
int i;
TuiWinContent content = (TuiWinContent) winInfo->generic.content;
i = 0;
while (i < winInfo->generic.contentSize)
{
if (content[i]->whichElement.source.lineOrAddr.addr == lineOrAddr)
content[i]->whichElement.source.isExecPoint = TRUE;
else
content[i]->whichElement.source.isExecPoint = FALSE;
i++;
}
return;
} /* tuiSetIsExecPointAt */
/*
1999-07-07 22:19:36 +02:00
** tuiSetHasBreakAt().
** Set or clear the hasBreak flag in the line whose line is lineNo.
*/
void
#ifdef __STDC__
tuiSetHasBreakAt (
struct breakpoint *bp,
TuiWinInfoPtr winInfo,
int hasBreak)
#else
tuiSetHasBreakAt (bp, winInfo, hasBreak)
struct breakpoint *bp;
TuiWinInfoPtr winInfo;
int hasBreak;
#endif
{
int i;
TuiWinContent content = (TuiWinContent) winInfo->generic.content;
i = 0;
while (i < winInfo->generic.contentSize)
{
int gotIt;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
if (winInfo == srcWin)
{
char *fileNameDisplayed = (char *) NULL;
if (((TuiWinElementPtr)
locator->content[0])->whichElement.locator.fileName !=
(char *) NULL)
fileNameDisplayed = ((TuiWinElementPtr)
locator->content[0])->whichElement.locator.fileName;
else if (current_source_symtab != (struct symtab *) NULL)
fileNameDisplayed = current_source_symtab->filename;
gotIt = (fileNameDisplayed != (char *) NULL &&
(strcmp (bp->source_file, fileNameDisplayed) == 0) &&
content[i]->whichElement.source.lineOrAddr.lineNo ==
bp->line_number);
}
else
gotIt = (content[i]->whichElement.source.lineOrAddr.addr
== (Opaque) bp->address);
if (gotIt)
{
content[i]->whichElement.source.hasBreak = hasBreak;
break;
}
i++;
}
return;
} /* tuiSetHasBreakAt */
/*
1999-07-07 22:19:36 +02:00
** tuiAllSetHasBreakAt().
** Set or clear the hasBreak flag in all displayed source windows.
*/
void
#ifdef __STDC__
tuiAllSetHasBreakAt (
struct breakpoint *bp,
int hasBreak)
#else
tuiAllSetHasBreakAt (bp, hasBreak)
struct breakpoint *bp;
int hasBreak;
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiSetHasBreakAt (bp,
(TuiWinInfoPtr) (sourceWindows ())->list[i], hasBreak);
return;
} /* tuiAllSetHasBreakAt */
/*
1999-07-07 22:19:36 +02:00
** tui_vAllSetHasBreakAt()
** Set or clear the hasBreak flag in all displayed source windows,
** with params in a va_list
*/
void
#ifdef __STDC__
tui_vAllSetHasBreakAt (
va_list args)
#else
tui_vAllSetHasBreakAt (args)
va_list args;
#endif
{
struct breakpoint *bp = va_arg (args, struct breakpoint *);
int hasBreak = va_arg (args, int);
tuiAllSetHasBreakAt (bp, hasBreak);
return;
} /* tui_vAllSetHasBreakAt */
/*********************************
** EXECUTION INFO FUNCTIONS **
*********************************/
/*
1999-07-07 22:19:36 +02:00
** tuiSetExecInfoContent().
** Function to initialize the content of the execution info window,
** based upon the input window which is either the source or
** disassembly window.
*/
TuiStatus
#ifdef __STDC__
tuiSetExecInfoContent (
TuiWinInfoPtr winInfo)
#else
tuiSetExecInfoContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
TuiStatus ret = TUI_SUCCESS;
if (winInfo->detail.sourceInfo.executionInfo != (TuiGenWinInfoPtr) NULL)
{
TuiGenWinInfoPtr execInfoPtr = winInfo->detail.sourceInfo.executionInfo;
if (execInfoPtr->content == (OpaquePtr) NULL)
execInfoPtr->content =
(OpaquePtr) allocContent (winInfo->generic.height,
execInfoPtr->type);
if (execInfoPtr->content != (OpaquePtr) NULL)
{
int i;
for (i = 0; i < winInfo->generic.contentSize; i++)
{
TuiWinElementPtr element;
TuiWinElementPtr srcElement;
element = (TuiWinElementPtr) execInfoPtr->content[i];
srcElement = (TuiWinElementPtr) winInfo->generic.content[i];
/*
1999-07-07 22:19:36 +02:00
** First check to see if we have a breakpoint that is
** temporary. If so, and this is our current execution point,
** then clear the break indicator.
*/
if (srcElement->whichElement.source.hasBreak &&
srcElement->whichElement.source.isExecPoint)
{
struct breakpoint *bp;
int found = FALSE;
extern struct breakpoint *breakpoint_chain;
for (bp = breakpoint_chain;
(bp != (struct breakpoint *) NULL && !found);
bp = bp->next)
{
found =
(winInfo == srcWin &&
bp->line_number ==
srcElement->whichElement.source.lineOrAddr.lineNo) ||
(winInfo == disassemWin &&
bp->address == (CORE_ADDR)
srcElement->whichElement.source.lineOrAddr.addr);
if (found)
srcElement->whichElement.source.hasBreak =
(bp->disposition != del || bp->hit_count <= 0);
}
if (!found)
srcElement->whichElement.source.hasBreak = FALSE;
}
/*
1999-07-07 22:19:36 +02:00
** Now update the exec info content based upon the state
** of each line as indicated by the source content.
*/
if (srcElement->whichElement.source.hasBreak &&
srcElement->whichElement.source.isExecPoint)
element->whichElement.simpleString = breakLocationStr ();
else if (srcElement->whichElement.source.hasBreak)
element->whichElement.simpleString = breakStr ();
else if (srcElement->whichElement.source.isExecPoint)
element->whichElement.simpleString = locationStr ();
else
element->whichElement.simpleString = blankStr ();
}
execInfoPtr->contentSize = winInfo->generic.contentSize;
}
else
ret = TUI_FAILURE;
}
return ret;
} /* tuiSetExecInfoContent */
/*
1999-07-07 22:19:36 +02:00
** tuiShowExecInfoContent().
*/
void
#ifdef __STDC__
tuiShowExecInfoContent (
TuiWinInfoPtr winInfo)
#else
tuiShowExecInfoContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
int curLine;
werase (execInfo->handle);
tuiRefreshWin (execInfo);
for (curLine = 1; (curLine <= execInfo->contentSize); curLine++)
mvwaddstr (execInfo->handle,
curLine,
0,
((TuiWinElementPtr)
execInfo->content[curLine - 1])->whichElement.simpleString);
tuiRefreshWin (execInfo);
execInfo->contentInUse = TRUE;
return;
} /* tuiShowExecInfoContent */
/*
1999-07-07 22:19:36 +02:00
** tuiShowAllExecInfosContent()
*/
void
#ifdef __STDC__
tuiShowAllExecInfosContent (void)
#else
tuiShowAllExecInfosContent ()
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiShowExecInfoContent ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
return;
} /* tuiShowAllExecInfosContent */
/*
1999-07-07 22:19:36 +02:00
** tuiEraseExecInfoContent().
*/
void
#ifdef __STDC__
tuiEraseExecInfoContent (
TuiWinInfoPtr winInfo)
#else
tuiEraseExecInfoContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
TuiGenWinInfoPtr execInfo = winInfo->detail.sourceInfo.executionInfo;
werase (execInfo->handle);
tuiRefreshWin (execInfo);
return;
} /* tuiEraseExecInfoContent */
/*
1999-07-07 22:19:36 +02:00
** tuiEraseAllExecInfosContent()
*/
void
#ifdef __STDC__
tuiEraseAllExecInfosContent (void)
#else
tuiEraseAllExecInfosContent ()
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiEraseExecInfoContent ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
return;
} /* tuiEraseAllExecInfosContent */
/*
1999-07-07 22:19:36 +02:00
** tuiClearExecInfoContent().
*/
void
#ifdef __STDC__
tuiClearExecInfoContent (
TuiWinInfoPtr winInfo)
#else
tuiClearExecInfoContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
winInfo->detail.sourceInfo.executionInfo->contentInUse = FALSE;
tuiEraseExecInfoContent (winInfo);
return;
} /* tuiClearExecInfoContent */
/*
1999-07-07 22:19:36 +02:00
** tuiClearAllExecInfosContent()
*/
void
#ifdef __STDC__
tuiClearAllExecInfosContent (void)
#else
tuiClearAllExecInfosContent ()
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiClearExecInfoContent ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
return;
} /* tuiClearAllExecInfosContent */
/*
1999-07-07 22:19:36 +02:00
** tuiUpdateExecInfo().
** Function to update the execution info window
*/
void
#ifdef __STDC__
tuiUpdateExecInfo (
TuiWinInfoPtr winInfo)
#else
tuiUpdateExecInfo (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
tuiSetExecInfoContent (winInfo);
tuiShowExecInfoContent (winInfo);
} /* tuiUpdateExecInfo
1999-07-07 22:19:36 +02:00
/*
** tuiUpdateAllExecInfos()
*/
void
#ifdef __STDC__
tuiUpdateAllExecInfos (void)
#else
tuiUpdateAllExecInfos ()
#endif
{
int i;
for (i = 0; i < (sourceWindows ())->count; i++)
tuiUpdateExecInfo ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
return;
1999-07-07 22:19:36 +02:00
} /* tuiUpdateAllExecInfos */
/* tuiUpdateOnEnd()
1999-07-07 22:19:36 +02:00
** elz: This function clears the execution info from the source windows
** and resets the locator to display no line info, procedure info, pc
** info. It is called by stack_publish_stopped_with_no_frame, which
** is called then the target terminates execution
*/
void
#ifdef __STDC__
tuiUpdateOnEnd (void)
#else
tuiUpdateOnEnd ()
#endif
{
int i;
TuiGenWinInfoPtr locator;
char *filename;
TuiWinInfoPtr winInfo;
locator = locatorWinInfoPtr ();
/* for all the windows (src, asm) */
for (i = 0; i < (sourceWindows ())->count; i++)
{
winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
tuiSetIsExecPointAt ((Opaque) - 1, winInfo); /* the target is'n running */
/* -1 should not match any line number or pc */
1999-07-07 22:19:36 +02:00
tuiSetExecInfoContent (winInfo); /*set winInfo so that > is'n displayed */
tuiShowExecInfoContent (winInfo); /* display the new contents */
}
1999-07-07 22:19:36 +02:00
/*now update the locator */
tuiClearLocatorDisplay ();
tuiGetLocatorFilename (locator, &filename);
tuiSetLocatorInfo (
filename,
(char *) NULL,
0,
(Opaque) NULL,
&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
tuiShowLocatorContent ();
return;
} /* tuiUpdateOnEnd */
TuiStatus
#ifdef __STDC__
tuiAllocSourceBuffer (
TuiWinInfoPtr winInfo)
#else
tuiAllocSourceBuffer (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
register char *srcLine, *srcLineBuf;
register int i, lineWidth, c, maxLines;
TuiStatus ret = TUI_FAILURE;
maxLines = winInfo->generic.height; /* less the highlight box */
lineWidth = winInfo->generic.width - 1;
/*
1999-07-07 22:19:36 +02:00
** Allocate the buffer for the source lines. Do this only once since they
** will be re-used for all source displays. The only other time this will
** be done is when a window's size changes.
*/
if (winInfo->generic.content == (OpaquePtr) NULL)
{
srcLineBuf = (char *) xmalloc ((maxLines * lineWidth) * sizeof (char));
if (srcLineBuf == (char *) NULL)
fputs_unfiltered (
"Unable to Allocate Memory for Source or Disassembly Display.\n",
gdb_stderr);
else
{
/* allocate the content list */
if ((winInfo->generic.content =
(OpaquePtr) allocContent (maxLines, SRC_WIN)) == (OpaquePtr) NULL)
{
tuiFree (srcLineBuf);
srcLineBuf = (char *) NULL;
fputs_unfiltered (
"Unable to Allocate Memory for Source or Disassembly Display.\n",
gdb_stderr);
}
}
for (i = 0; i < maxLines; i++)
((TuiWinElementPtr)
winInfo->generic.content[i])->whichElement.source.line =
srcLineBuf + (lineWidth * i);
ret = TUI_SUCCESS;
}
else
ret = TUI_SUCCESS;
return ret;
} /* tuiAllocSourceBuffer */
/*
1999-07-07 22:19:36 +02:00
** tuiLineIsDisplayed().
** Answer whether the a particular line number or address is displayed
** in the current source window.
*/
int
#ifdef __STDC__
tuiLineIsDisplayed (
Opaque lineNoOrAddr,
TuiWinInfoPtr winInfo,
int checkThreshold)
#else
tuiLineIsDisplayed (lineNoOrAddr, winInfo, checkThreshold)
Opaque lineNoOrAddr;
TuiWinInfoPtr winInfo;
int checkThreshold;
#endif
{
int isDisplayed = FALSE;
int i, threshold;
if (checkThreshold)
threshold = SCROLL_THRESHOLD;
else
threshold = 0;
i = 0;
while (i < winInfo->generic.contentSize - threshold && !isDisplayed)
{
if (winInfo == srcWin)
isDisplayed = (((TuiWinElementPtr)
winInfo->generic.content[i])->whichElement.source.lineOrAddr.lineNo
== (int) lineNoOrAddr);
else
isDisplayed = (((TuiWinElementPtr)
winInfo->generic.content[i])->whichElement.source.lineOrAddr.addr
== lineNoOrAddr);
i++;
}
return isDisplayed;
} /* tuiLineIsDisplayed */
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/