OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k/trunk/gdb-5.0/gdb/tui
    from Rev 107 to Rev 1765
    ↔ Reverse comparison
  •

Rev 107 → Rev 1765

/tuiIO.h
0,0 → 1,44
#ifndef _TUI_IO_H
#define _TUI_IO_H
/*
** This header contains defitions to support tuiIO.c
*/
 
 
#include <stdio.h>
 
extern void tuiPuts_unfiltered (const char *, struct ui_file *);
extern unsigned int tuiGetc PARAMS ((void));
extern unsigned int tuiBufferGetc PARAMS ((void));
extern int tuiRead PARAMS ((int, char *, int));
extern void tuiStartNewLines PARAMS ((int));
extern void tui_vStartNewLines PARAMS ((va_list));
extern unsigned int tui_vwgetch PARAMS ((va_list));
extern void tuiTermSetup PARAMS ((int));
extern void tuiTermUnsetup PARAMS ((int, int));
 
 
 
#define m_tuiStartNewLine tuiStartNewLines(1)
#define m_isStartSequence(ch) (ch == 27)
#define m_isEndSequence(ch) (ch == 126)
#define m_isBackspace(ch) (ch == 8)
#define m_isDeleteChar(ch) (ch == KEY_DC)
#define m_isDeleteLine(ch) (ch == KEY_DL)
#define m_isDeleteToEol(ch) (ch == KEY_EOL)
#define m_isNextPage(ch) (ch == KEY_NPAGE)
#define m_isPrevPage(ch) (ch == KEY_PPAGE)
#define m_isLeftArrow(ch) (ch == KEY_LEFT)
#define m_isRightArrow(ch) (ch == KEY_RIGHT)
 
#define m_isCommandChar(ch) (m_isNextPage(ch) || m_isPrevPage(ch) || \
m_isLeftArrow(ch) || m_isRightArrow(ch) || \
(ch == KEY_UP) || (ch == KEY_DOWN) || \
(ch == KEY_SF) || (ch == KEY_SR) || \
(ch == (int)'\f') || m_isStartSequence(ch))
 
#define m_isXdbStyleCommandChar(ch) (m_isNextPage(ch) || m_isPrevPage(ch))
 
 
#endif
/*_TUI_IO_H*/
/tuiDisassem.h
0,0 → 1,23
#ifndef _TUI_DISASSEM_H
#define _TUI_DISASSEM_H
/*
** This header file supports
*/
 
/*****************************************
** TYPE DEFINITIONS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTION EXTERNAL DECLS **
******************************************/
extern TuiStatus tuiSetDisassemContent PARAMS ((struct symtab *, Opaque));
extern void tuiShowDisassem PARAMS ((Opaque));
extern void tuiShowDisassemAndUpdateSource PARAMS ((Opaque));
extern void tuiVerticalDisassemScroll PARAMS ((TuiScrollDirection, int));
extern Opaque tuiGetBeginAsmAddress PARAMS ((void));
 
#endif
/*_TUI_DISASSEM_H*/
/tuiLayout.c
0,0 → 1,1410
/*
** tuiLayout.c
** This module contains procedures for handling the layout of the windows.
*/
 
 
#include "defs.h"
#include "command.h"
#include "symtab.h"
#include "frame.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiGeneralWin.h"
#include "tuiStack.h"
#include "tuiRegs.h"
#include "tuiDisassem.h"
 
/*******************************
** Static Local Decls
********************************/
 
static void _initGenWinInfo PARAMS
((TuiGenWinInfoPtr, TuiWinType, int, int, int, int));
static void _initAndMakeWin PARAMS
((Opaque *, TuiWinType, int, int, int, int, int));
static void _showSourceOrDisassemAndCommand PARAMS
((TuiLayoutType));
static void _makeSourceOrDisassemWindow PARAMS
((TuiWinInfoPtr *, TuiWinType, int, int));
static void _makeCommandWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _makeSourceWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _makeDisassemWindow PARAMS
((TuiWinInfoPtr *, int, int));
static void _makeDataWindow PARAMS ((TuiWinInfoPtr *, int, int));
static void _showSourceCommand PARAMS ((void));
static void _showDisassemCommand PARAMS ((void));
static void _showSourceDisassemCommand PARAMS ((void));
static void _showData PARAMS ((TuiLayoutType));
static TuiLayoutType _nextLayout PARAMS ((void));
static TuiLayoutType _prevLayout PARAMS ((void));
static void _tuiLayout_command PARAMS ((char *, int));
static void _tuiToggleLayout_command PARAMS ((char *, int));
static void _tui_vToggleLayout_command PARAMS ((va_list));
static void _tuiToggleSplitLayout_command PARAMS ((char *, int));
static void _tui_vToggleSplitLayout_command PARAMS ((va_list));
static Opaque _extractDisplayStartAddr PARAMS ((void));
static void _tuiHandleXDBLayout PARAMS ((TuiLayoutDefPtr));
static TuiStatus _tuiSetLayoutTo PARAMS ((char *));
 
 
/***************************************
** DEFINITIONS
***************************************/
 
#define LAYOUT_USAGE "Usage: layout prev | next | <layout_name> \n"
 
/***************************************
** Static Local Data
***************************************/
static TuiLayoutType lastLayout = UNDEFINED_LAYOUT;
 
/***************************************
** PUBLIC FUNCTIONS
***************************************/
 
/*
** showLayout().
** Show the screen layout defined
*/
void
#ifdef __STDC__
showLayout (
TuiLayoutType layout)
#else
showLayout (layout)
TuiLayoutType layout;
#endif
{
TuiLayoutType curLayout = currentLayout ();
 
if (layout != curLayout)
{
/*
** Since the new layout may cause changes in window size, we
** should free the content and reallocate on next display of
** source/asm
*/
tuiClearAllSourceWinsContent (NO_EMPTY_SOURCE_PROMPT);
freeAllSourceWinsContent ();
clearSourceWindows ();
if (layout == SRC_DATA_COMMAND || layout == DISASSEM_DATA_COMMAND)
{
_showData (layout);
refreshAll (winList);
}
else
{
/* First make the current layout be invisible */
m_allBeInvisible ();
m_beInvisible (locatorWinInfoPtr ());
 
switch (layout)
{
/* Now show the new layout */
case SRC_COMMAND:
_showSourceCommand ();
addToSourceWindows (srcWin);
break;
case DISASSEM_COMMAND:
_showDisassemCommand ();
addToSourceWindows (disassemWin);
break;
case SRC_DISASSEM_COMMAND:
_showSourceDisassemCommand ();
addToSourceWindows (srcWin);
addToSourceWindows (disassemWin);
break;
default:
break;
}
}
}
 
return;
} /* showLayout */
 
 
/*
** tuiSetLayout()
** Function to set the layout to SRC_COMMAND, DISASSEM_COMMAND,
** SRC_DISASSEM_COMMAND, SRC_DATA_COMMAND, or DISASSEM_DATA_COMMAND.
** If the layout is SRC_DATA_COMMAND, DISASSEM_DATA_COMMAND, or
** UNDEFINED_LAYOUT, then the data window is populated according
** to regsDisplayType.
*/
TuiStatus
#ifdef __STDC__
tuiSetLayout (
TuiLayoutType layoutType,
TuiRegisterDisplayType regsDisplayType)
#else
tuiSetLayout (layoutType, regsDisplayType)
TuiLayoutType layoutType;
TuiRegisterDisplayType regsDisplayType;
#endif
{
TuiStatus status = TUI_SUCCESS;
 
if (layoutType != UNDEFINED_LAYOUT || regsDisplayType != TUI_UNDEFINED_REGS)
{
TuiLayoutType curLayout = currentLayout (), newLayout = UNDEFINED_LAYOUT;
int regsPopulate = FALSE;
Opaque addr = _extractDisplayStartAddr ();
TuiWinInfoPtr newWinWithFocus = (TuiWinInfoPtr) NULL, winWithFocus = tuiWinWithFocus ();
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
 
if (layoutType == UNDEFINED_LAYOUT &&
regsDisplayType != TUI_UNDEFINED_REGS)
{
if (curLayout == SRC_DISASSEM_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
else if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
newLayout = SRC_DATA_COMMAND;
else if (curLayout == DISASSEM_COMMAND ||
curLayout == DISASSEM_DATA_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
}
else
newLayout = layoutType;
 
regsPopulate = (newLayout == SRC_DATA_COMMAND ||
newLayout == DISASSEM_DATA_COMMAND ||
regsDisplayType != TUI_UNDEFINED_REGS);
if (newLayout != curLayout || regsDisplayType != TUI_UNDEFINED_REGS)
{
if (newLayout != curLayout)
{
if (winWithFocus != cmdWin)
tuiClearWinFocus ();
showLayout (newLayout);
/*
** Now determine where focus should be
*/
if (winWithFocus != cmdWin)
{
switch (newLayout)
{
case SRC_COMMAND:
tuiSetWinFocusTo (srcWin);
layoutDef->displayMode = SRC_WIN;
layoutDef->split = FALSE;
break;
case DISASSEM_COMMAND:
/* the previous layout was not showing
** code. this can happen if there is no
** source available:
** 1. if the source file is in another dir OR
** 2. if target was compiled without -g
** We still want to show the assembly though!
*/
addr = vcatch_errors ((OpaqueFuncPtr)
tuiGetBeginAsmAddress);
tuiSetWinFocusTo (disassemWin);
layoutDef->displayMode = DISASSEM_WIN;
layoutDef->split = FALSE;
break;
case SRC_DISASSEM_COMMAND:
/* the previous layout was not showing
** code. this can happen if there is no
** source available:
** 1. if the source file is in another dir OR
** 2. if target was compiled without -g
** We still want to show the assembly though!
*/
addr = vcatch_errors ((OpaqueFuncPtr)
tuiGetBeginAsmAddress);
if (winWithFocus == srcWin)
tuiSetWinFocusTo (srcWin);
else
tuiSetWinFocusTo (disassemWin);
layoutDef->split = TRUE;
break;
case SRC_DATA_COMMAND:
if (winWithFocus != dataWin)
tuiSetWinFocusTo (srcWin);
else
tuiSetWinFocusTo (dataWin);
layoutDef->displayMode = SRC_WIN;
layoutDef->split = FALSE;
break;
case DISASSEM_DATA_COMMAND:
/* the previous layout was not showing
** code. this can happen if there is no
** source available:
** 1. if the source file is in another dir OR
** 2. if target was compiled without -g
** We still want to show the assembly though!
*/
addr = vcatch_errors ((OpaqueFuncPtr)
tuiGetBeginAsmAddress);
if (winWithFocus != dataWin)
tuiSetWinFocusTo (disassemWin);
else
tuiSetWinFocusTo (dataWin);
layoutDef->displayMode = DISASSEM_WIN;
layoutDef->split = FALSE;
break;
default:
break;
}
}
if (newWinWithFocus != (TuiWinInfoPtr) NULL)
tuiSetWinFocusTo (newWinWithFocus);
/*
** Now update the window content
*/
if (!regsPopulate &&
(newLayout == SRC_DATA_COMMAND ||
newLayout == DISASSEM_DATA_COMMAND))
tuiDisplayAllData ();
 
tuiUpdateSourceWindowsWithAddr (addr);
}
if (regsPopulate)
{
layoutDef->regsDisplayType =
(regsDisplayType == TUI_UNDEFINED_REGS ?
TUI_GENERAL_REGS : regsDisplayType);
tuiShowRegisters (layoutDef->regsDisplayType);
}
}
}
else
status = TUI_FAILURE;
 
return status;
} /* tuiSetLayout */
 
 
/*
** tui_vSetLayoutTo()
** Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA,
** REGS, $REGS, $GREGS, $FREGS, $SREGS with arguments in a va_list
*/
TuiStatus
#ifdef __STDC__
tui_vSetLayoutTo (
va_list args)
#else
tui_vSetLayoutTo (args)
va_list args;
#endif
{
char *layoutName;
 
layoutName = va_arg (args, char *);
 
return (_tuiSetLayoutTo (layoutName));
} /* tui_vSetLayoutTo */
 
 
/*
** tuiAddWinToLayout().
** Add the specified window to the layout in a logical way.
** This means setting up the most logical layout given the
** window to be added.
*/
void
#ifdef __STDC__
tuiAddWinToLayout (
TuiWinType type)
#else
tuiAddWinToLayout (type)
TuiWinType type;
#endif
{
TuiLayoutType curLayout = currentLayout ();
 
switch (type)
{
case SRC_WIN:
if (curLayout != SRC_COMMAND &&
curLayout != SRC_DISASSEM_COMMAND &&
curLayout != SRC_DATA_COMMAND)
{
clearSourceWindowsDetail ();
if (curLayout == DISASSEM_DATA_COMMAND)
showLayout (SRC_DATA_COMMAND);
else
showLayout (SRC_COMMAND);
}
break;
case DISASSEM_WIN:
if (curLayout != DISASSEM_COMMAND &&
curLayout != SRC_DISASSEM_COMMAND &&
curLayout != DISASSEM_DATA_COMMAND)
{
clearSourceWindowsDetail ();
if (curLayout == SRC_DATA_COMMAND)
showLayout (DISASSEM_DATA_COMMAND);
else
showLayout (DISASSEM_COMMAND);
}
break;
case DATA_WIN:
if (curLayout != SRC_DATA_COMMAND &&
curLayout != DISASSEM_DATA_COMMAND)
{
if (curLayout == DISASSEM_COMMAND)
showLayout (DISASSEM_DATA_COMMAND);
else
showLayout (SRC_DATA_COMMAND);
}
break;
default:
break;
}
 
return;
} /* tuiAddWinToLayout */
 
 
/*
** tui_vAddWinToLayout().
** Add the specified window to the layout in a logical way,
** with arguments in a va_list.
*/
void
#ifdef __STDC__
tui_vAddWinToLayout (
va_list args)
#else
tui_vAddWinToLayout (args)
va_list args;
#endif
{
TuiWinType type = va_arg (args, TuiWinType);
 
tuiAddWinToLayout (type);
 
return;
} /* tui_vAddWinToLayout */
 
 
/*
** tuiDefaultWinHeight().
** Answer the height of a window. If it hasn't been created yet,
** answer what the height of a window would be based upon its
** type and the layout.
*/
int
#ifdef __STDC__
tuiDefaultWinHeight (
TuiWinType type,
TuiLayoutType layout)
#else
tuiDefaultWinHeight (type, layout)
TuiWinType type;
TuiLayoutType layout;
#endif
{
int h;
 
if (winList[type] != (TuiWinInfoPtr) NULL)
h = winList[type]->generic.height;
else
{
switch (layout)
{
case SRC_COMMAND:
case DISASSEM_COMMAND:
if (m_winPtrIsNull (cmdWin))
h = termHeight () / 2;
else
h = termHeight () - cmdWin->generic.height;
break;
case SRC_DISASSEM_COMMAND:
case SRC_DATA_COMMAND:
case DISASSEM_DATA_COMMAND:
if (m_winPtrIsNull (cmdWin))
h = termHeight () / 3;
else
h = (termHeight () - cmdWin->generic.height) / 2;
break;
default:
h = 0;
break;
}
}
 
return h;
} /* tuiDefaultWinHeight */
 
 
/*
** tuiDefaultWinViewportHeight().
** Answer the height of a window. If it hasn't been created yet,
** answer what the height of a window would be based upon its
** type and the layout.
*/
int
#ifdef __STDC__
tuiDefaultWinViewportHeight (
TuiWinType type,
TuiLayoutType layout)
#else
tuiDefaultWinViewportHeight (type, layout)
TuiWinType type;
TuiLayoutType layout;
#endif
{
int h;
 
h = tuiDefaultWinHeight (type, layout);
 
if (winList[type] == cmdWin)
h -= 1;
else
h -= 2;
 
return h;
} /* tuiDefaultWinViewportHeight */
 
 
/*
** _initialize_tuiLayout().
** Function to initialize gdb commands, for tui window layout
** manipulation.
*/
void
_initialize_tuiLayout ()
{
if (tui_version)
{
add_com ("layout", class_tui, _tuiLayout_command,
"Change the layout of windows.\n\
Usage: layout prev | next | <layout_name> \n\
Layout names are:\n\
src : Displays source and command windows.\n\
asm : Displays disassembly and command windows.\n\
split : Displays source, disassembly and command windows.\n\
regs : Displays register window. If existing layout\n\
is source/command or assembly/command, the \n\
register window is displayed. If the\n\
source/assembly/command (split) is displayed, \n\
the register window is displayed with \n\
the window that has current logical focus.\n");
if (xdb_commands)
{
add_com ("td", class_tui, _tuiToggleLayout_command,
"Toggle between Source/Command and Disassembly/Command layouts.\n");
add_com ("ts", class_tui, _tuiToggleSplitLayout_command,
"Toggle between Source/Command or Disassembly/Command and \n\
Source/Disassembly/Command layouts.\n");
}
}
 
return;
} /* _intialize_tuiLayout */
 
 
/*************************
** STATIC LOCAL FUNCTIONS
**************************/
 
 
/*
** _tuiSetLayoutTo()
** Function to set the layout to SRC, ASM, SPLIT, NEXT, PREV, DATA, REGS,
** $REGS, $GREGS, $FREGS, $SREGS.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetLayoutTo (
char *layoutName)
#else
_tuiSetLayoutTo (layoutName)
char *layoutName;
#endif
{
TuiStatus status = TUI_SUCCESS;
 
if (layoutName != (char *) NULL)
{
register int i;
register char *bufPtr;
TuiLayoutType newLayout = UNDEFINED_LAYOUT;
TuiRegisterDisplayType dpyType = TUI_UNDEFINED_REGS;
TuiLayoutType curLayout = currentLayout ();
 
bufPtr = (char *) tuiStrDup (layoutName);
for (i = 0; (i < strlen (layoutName)); i++)
bufPtr[i] = toupper (bufPtr[i]);
 
/* First check for ambiguous input */
if (strlen (bufPtr) <= 1 && (*bufPtr == 'S' || *bufPtr == '$'))
{
warning ("Ambiguous command input.\n");
status = TUI_FAILURE;
}
else
{
if (subsetCompare (bufPtr, "SRC"))
newLayout = SRC_COMMAND;
else if (subsetCompare (bufPtr, "ASM"))
newLayout = DISASSEM_COMMAND;
else if (subsetCompare (bufPtr, "SPLIT"))
newLayout = SRC_DISASSEM_COMMAND;
else if (subsetCompare (bufPtr, "REGS") ||
subsetCompare (bufPtr, TUI_GENERAL_SPECIAL_REGS_NAME) ||
subsetCompare (bufPtr, TUI_GENERAL_REGS_NAME) ||
subsetCompare (bufPtr, TUI_FLOAT_REGS_NAME) ||
subsetCompare (bufPtr, TUI_SPECIAL_REGS_NAME))
{
if (curLayout == SRC_COMMAND || curLayout == SRC_DATA_COMMAND)
newLayout = SRC_DATA_COMMAND;
else
newLayout = DISASSEM_DATA_COMMAND;
 
/* could ifdef out the following code. when compile with -z, there are null
pointer references that cause a core dump if 'layout regs' is the first
layout command issued by the user. HP has asked us to hook up this code
- edie epstein
*/
if (subsetCompare (bufPtr, TUI_FLOAT_REGS_NAME))
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_SFLOAT_REGS &&
dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_DFLOAT_REGS)
dpyType = TUI_SFLOAT_REGS;
else
dpyType =
dataWin->detail.dataDisplayInfo.regsDisplayType;
}
else if (subsetCompare (bufPtr,
TUI_GENERAL_SPECIAL_REGS_NAME))
dpyType = TUI_GENERAL_AND_SPECIAL_REGS;
else if (subsetCompare (bufPtr, TUI_GENERAL_REGS_NAME))
dpyType = TUI_GENERAL_REGS;
else if (subsetCompare (bufPtr, TUI_SPECIAL_REGS_NAME))
dpyType = TUI_SPECIAL_REGS;
else
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType !=
TUI_UNDEFINED_REGS)
dpyType =
dataWin->detail.dataDisplayInfo.regsDisplayType;
else
dpyType = TUI_GENERAL_REGS;
}
 
/* end of potential ifdef
*/
 
/* if ifdefed out code above, then assume that the user wishes to display the
general purpose registers
*/
 
/* dpyType = TUI_GENERAL_REGS;
*/
}
else if (subsetCompare (bufPtr, "NEXT"))
newLayout = _nextLayout ();
else if (subsetCompare (bufPtr, "PREV"))
newLayout = _prevLayout ();
else
status = TUI_FAILURE;
free (bufPtr);
 
tuiSetLayout (newLayout, dpyType);
}
}
else
status = TUI_FAILURE;
 
return status;
} /* _tuiSetLayoutTo */
 
 
static Opaque
#ifdef __STDC__
_extractDisplayStartAddr (void)
#else
_extractDisplayStartAddr ()
#endif
{
TuiLayoutType curLayout = currentLayout ();
Opaque addr;
 
switch (curLayout)
{
case SRC_COMMAND:
case SRC_DATA_COMMAND:
addr = (Opaque) find_line_pc (
current_source_symtab,
srcWin->detail.sourceInfo.startLineOrAddr.lineNo);
break;
case DISASSEM_COMMAND:
case SRC_DISASSEM_COMMAND:
case DISASSEM_DATA_COMMAND:
addr = disassemWin->detail.sourceInfo.startLineOrAddr.addr;
break;
default:
addr = (Opaque) NULL;
break;
}
 
return addr;
} /* _extractDisplayStartAddr */
 
 
static void
#ifdef __STDC__
_tuiHandleXDBLayout (
TuiLayoutDefPtr layoutDef)
#else
_tuiHandleXDBLayout (layoutDef)
TuiLayoutDefPtr layoutDef;
#endif
{
if (layoutDef->split)
{
tuiSetLayout (SRC_DISASSEM_COMMAND, TUI_UNDEFINED_REGS);
tuiSetWinFocusTo (winList[layoutDef->displayMode]);
}
else
{
if (layoutDef->displayMode == SRC_WIN)
tuiSetLayout (SRC_COMMAND, TUI_UNDEFINED_REGS);
else
tuiSetLayout (DISASSEM_DATA_COMMAND, layoutDef->regsDisplayType);
}
 
 
return;
} /* _tuiHandleXDBLayout */
 
 
static void
#ifdef __STDC__
_tuiToggleLayout_command (
char *arg,
int fromTTY)
#else
_tuiToggleLayout_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vToggleLayout_command, arg, fromTTY);
}
 
static void
#ifdef __STDC__
_tui_vToggleLayout_command (
va_list args)
#else
_tui_vToggleLayout_command (args)
va_list args;
#endif
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
if (layoutDef->displayMode == SRC_WIN)
layoutDef->displayMode = DISASSEM_WIN;
else
layoutDef->displayMode = SRC_WIN;
 
if (!layoutDef->split)
_tuiHandleXDBLayout (layoutDef);
 
return;
} /* _tuiToggleLayout_command */
 
 
static void
#ifdef __STDC__
_tuiToggleSplitLayout_command (
char *arg,
int fromTTY)
#else
_tuiToggleSplitLayout_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vToggleSplitLayout_command, arg, fromTTY);
}
 
static void
#ifdef __STDC__
_tui_vToggleSplitLayout_command (
va_list args)
#else
_tui_vToggleSplitLayout_command (args)
va_list args;
#endif
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
layoutDef->split = (!layoutDef->split);
_tuiHandleXDBLayout (layoutDef);
 
return;
} /* _tui_vToggleSplitLayout_command */
 
 
static void
#ifdef __STDC__
_tuiLayout_command (
char *arg,
int fromTTY)
#else
_tuiLayout_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if ((TuiStatus) tuiDo (
(TuiOpaqueFuncPtr) tui_vSetLayoutTo, arg) != TUI_SUCCESS)
warning ("Invalid layout specified.\n%s" LAYOUT_USAGE);
 
return;
} /* _tuiLayout_command */
 
/*
** _nextLayout().
** Answer the previous layout to cycle to.
*/
static TuiLayoutType
#ifdef __STDC__
_nextLayout (void)
#else
_nextLayout ()
#endif
{
TuiLayoutType newLayout;
 
newLayout = currentLayout ();
if (newLayout == UNDEFINED_LAYOUT)
newLayout = SRC_COMMAND;
else
{
newLayout++;
if (newLayout == UNDEFINED_LAYOUT)
newLayout = SRC_COMMAND;
}
 
return newLayout;
} /* _nextLayout */
 
 
/*
** _prevLayout().
** Answer the next layout to cycle to.
*/
static TuiLayoutType
#ifdef __STDC__
_prevLayout (void)
#else
_prevLayout ()
#endif
{
TuiLayoutType newLayout;
 
newLayout = currentLayout ();
if (newLayout == SRC_COMMAND)
newLayout = DISASSEM_DATA_COMMAND;
else
{
newLayout--;
if (newLayout == UNDEFINED_LAYOUT)
newLayout = DISASSEM_DATA_COMMAND;
}
 
return newLayout;
} /* _prevLayout */
 
 
 
/*
** _makeCommandWindow().
*/
static void
#ifdef __STDC__
_makeCommandWindow (
TuiWinInfoPtr * winInfoPtr,
int height,
int originY)
#else
_makeCommandWindow (winInfoPtr, height, originY)
TuiWinInfoPtr *winInfoPtr;
int height;
int originY;
#endif
{
_initAndMakeWin ((Opaque *) winInfoPtr,
CMD_WIN,
height,
termWidth (),
0,
originY,
DONT_BOX_WINDOW);
 
(*winInfoPtr)->canHighlight = FALSE;
 
return;
} /* _makeCommandWindow */
 
 
/*
** _makeSourceWindow().
*/
static void
#ifdef __STDC__
_makeSourceWindow (
TuiWinInfoPtr * winInfoPtr,
int height,
int originY)
#else
_makeSourceWindow (winInfoPtr, height, originY)
TuiWinInfoPtr *winInfoPtr;
int height;
int originY;
#endif
{
_makeSourceOrDisassemWindow (winInfoPtr, SRC_WIN, height, originY);
 
return;
} /* _makeSourceWindow */
 
 
/*
** _makeDisassemWindow().
*/
static void
#ifdef __STDC__
_makeDisassemWindow (
TuiWinInfoPtr * winInfoPtr,
int height,
int originY)
#else
_makeDisassemWindow (winInfoPtr, height, originY)
TuiWinInfoPtr *winInfoPtr;
int height;
int originY;
#endif
{
_makeSourceOrDisassemWindow (winInfoPtr, DISASSEM_WIN, height, originY);
 
return;
} /* _makeDisassemWindow */
 
 
/*
** _makeDataWindow().
*/
static void
#ifdef __STDC__
_makeDataWindow (
TuiWinInfoPtr * winInfoPtr,
int height,
int originY)
#else
_makeDataWindow (winInfoPtr, height, originY)
TuiWinInfoPtr *winInfoPtr;
int height;
int originY;
#endif
{
_initAndMakeWin ((Opaque *) winInfoPtr,
DATA_WIN,
height,
termWidth (),
0,
originY,
BOX_WINDOW);
 
return;
} /* _makeDataWindow */
 
 
 
/*
** _showSourceCommand().
** Show the Source/Command layout
*/
static void
#ifdef __STDC__
_showSourceCommand (void)
#else
_showSourceCommand ()
#endif
{
_showSourceOrDisassemAndCommand (SRC_COMMAND);
 
return;
} /* _showSourceCommand */
 
 
/*
** _showDisassemCommand().
** Show the Dissassem/Command layout
*/
static void
#ifdef __STDC__
_showDisassemCommand (void)
#else
_showDisassemCommand ()
#endif
{
_showSourceOrDisassemAndCommand (DISASSEM_COMMAND);
 
return;
} /* _showDisassemCommand */
 
 
/*
** _showSourceDisassemCommand().
** Show the Source/Disassem/Command layout
*/
static void
#ifdef __STDC__
_showSourceDisassemCommand (void)
#else
_showSourceDisassemCommand ()
#endif
{
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
if (currentLayout () != SRC_DISASSEM_COMMAND)
{
int cmdHeight, srcHeight, asmHeight;
 
if (m_winPtrNotNull (cmdWin))
cmdHeight = cmdWin->generic.height;
else
cmdHeight = termHeight () / 3;
 
srcHeight = (termHeight () - cmdHeight) / 2;
asmHeight = termHeight () - (srcHeight + cmdHeight);
 
if (m_winPtrIsNull (srcWin))
_makeSourceWindow (&srcWin, srcHeight, 0);
else
{
_initGenWinInfo (&srcWin->generic,
srcWin->generic.type,
srcHeight,
srcWin->generic.width,
srcWin->detail.sourceInfo.executionInfo->width,
0);
srcWin->canHighlight = TRUE;
_initGenWinInfo (srcWin->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight,
3,
0,
0);
m_beVisible (srcWin);
m_beVisible (srcWin->detail.sourceInfo.executionInfo);
srcWin->detail.sourceInfo.hasLocator = FALSE;;
}
if (m_winPtrNotNull (srcWin))
{
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
tuiShowSourceContent (srcWin);
if (m_winPtrIsNull (disassemWin))
{
_makeDisassemWindow (&disassemWin, asmHeight, srcHeight - 1);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
(srcHeight + asmHeight) - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
(srcHeight + asmHeight) - 1);
disassemWin->detail.sourceInfo.hasLocator = TRUE;
_initGenWinInfo (
&disassemWin->generic,
disassemWin->generic.type,
asmHeight,
disassemWin->generic.width,
disassemWin->detail.sourceInfo.executionInfo->width,
srcHeight - 1);
_initGenWinInfo (disassemWin->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
asmHeight,
3,
0,
srcHeight - 1);
disassemWin->canHighlight = TRUE;
m_beVisible (disassemWin);
m_beVisible (disassemWin->detail.sourceInfo.executionInfo);
}
if (m_winPtrNotNull (disassemWin))
{
srcWin->detail.sourceInfo.hasLocator = FALSE;
disassemWin->detail.sourceInfo.hasLocator = TRUE;
m_beVisible (locator);
tuiShowLocatorContent ();
tuiShowSourceContent (disassemWin);
 
if (m_winPtrIsNull (cmdWin))
_makeCommandWindow (&cmdWin,
cmdHeight,
termHeight () - cmdHeight);
else
{
_initGenWinInfo (&cmdWin->generic,
cmdWin->generic.type,
cmdWin->generic.height,
cmdWin->generic.width,
0,
cmdWin->generic.origin.y);
cmdWin->canHighlight = FALSE;
m_beVisible (cmdWin);
}
if (m_winPtrNotNull (cmdWin))
tuiRefreshWin (&cmdWin->generic);
}
}
setCurrentLayoutTo (SRC_DISASSEM_COMMAND);
}
 
return;
} /* _showSourceDisassemCommand */
 
 
/*
** _showData().
** Show the Source/Data/Command or the Dissassembly/Data/Command layout
*/
static void
#ifdef __STDC__
_showData (
TuiLayoutType newLayout)
#else
_showData (newLayout)
TuiLayoutType newLayout;
#endif
{
int totalHeight = (termHeight () - cmdWin->generic.height);
int srcHeight, dataHeight;
TuiWinType winType;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
 
dataHeight = totalHeight / 2;
srcHeight = totalHeight - dataHeight;
m_allBeInvisible ();
m_beInvisible (locator);
_makeDataWindow (&dataWin, dataHeight, 0);
dataWin->canHighlight = TRUE;
if (newLayout == SRC_DATA_COMMAND)
winType = SRC_WIN;
else
winType = DISASSEM_WIN;
if (m_winPtrIsNull (winList[winType]))
{
if (winType == SRC_WIN)
_makeSourceWindow (&winList[winType], srcHeight, dataHeight - 1);
else
_makeDisassemWindow (&winList[winType], srcHeight, dataHeight - 1);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
totalHeight - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (&winList[winType]->generic,
winList[winType]->generic.type,
srcHeight,
winList[winType]->generic.width,
winList[winType]->detail.sourceInfo.executionInfo->width,
dataHeight - 1);
_initGenWinInfo (winList[winType]->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight,
3,
0,
dataHeight - 1);
m_beVisible (winList[winType]);
m_beVisible (winList[winType]->detail.sourceInfo.executionInfo);
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
totalHeight - 1);
}
winList[winType]->detail.sourceInfo.hasLocator = TRUE;
m_beVisible (locator);
tuiShowLocatorContent ();
addToSourceWindows (winList[winType]);
setCurrentLayoutTo (newLayout);
 
return;
} /* _showData */
 
/*
** _initGenWinInfo().
*/
static void
#ifdef __STDC__
_initGenWinInfo (
TuiGenWinInfoPtr winInfo,
TuiWinType type,
int height,
int width,
int originX,
int originY)
#else
_initGenWinInfo (winInfo, type, height, width, originX, originY)
TuiGenWinInfoPtr winInfo;
TuiWinType type;
int height;
int width;
int originX;
int originY;
#endif
{
int h = height;
 
winInfo->type = type;
winInfo->width = width;
winInfo->height = h;
if (h > 1)
{
winInfo->viewportHeight = h - 1;
if (winInfo->type != CMD_WIN)
winInfo->viewportHeight--;
}
else
winInfo->viewportHeight = 1;
winInfo->origin.x = originX;
winInfo->origin.y = originY;
 
return;
} /* _initGenWinInfo */
 
/*
** _initAndMakeWin().
*/
static void
#ifdef __STDC__
_initAndMakeWin (
Opaque * winInfoPtr,
TuiWinType winType,
int height,
int width,
int originX,
int originY,
int boxIt)
#else
_initAndMakeWin (winInfoPtr, winType, height, width, originX, originY, boxIt)
Opaque *winInfoPtr;
TuiWinType winType;
int height;
int width;
int originX;
int originY;
int boxIt;
#endif
{
Opaque opaqueWinInfo = *winInfoPtr;
TuiGenWinInfoPtr generic;
 
if (opaqueWinInfo == (Opaque) NULL)
{
if (m_winIsAuxillary (winType))
opaqueWinInfo = (Opaque) allocGenericWinInfo ();
else
opaqueWinInfo = (Opaque) allocWinInfo (winType);
}
if (m_winIsAuxillary (winType))
generic = (TuiGenWinInfoPtr) opaqueWinInfo;
else
generic = &((TuiWinInfoPtr) opaqueWinInfo)->generic;
 
if (opaqueWinInfo != (Opaque) NULL)
{
_initGenWinInfo (generic, winType, height, width, originX, originY);
if (!m_winIsAuxillary (winType))
{
if (generic->type == CMD_WIN)
((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = FALSE;
else
((TuiWinInfoPtr) opaqueWinInfo)->canHighlight = TRUE;
}
makeWindow (generic, boxIt);
if (winType == LOCATOR_WIN)
tuiClearLocatorDisplay ();
echo ();
}
*winInfoPtr = opaqueWinInfo;
 
return;
} /* _initAndMakeWin */
 
 
/*
** _makeSourceOrDisassemWindow().
*/
static void
#ifdef __STDC__
_makeSourceOrDisassemWindow (
TuiWinInfoPtr * winInfoPtr,
TuiWinType type,
int height,
int originY)
#else
_makeSourceOrDisassemWindow (winInfoPtr, type, height, originY)
TuiWinInfoPtr *winInfoPtr;
TuiWinType type;
int height;
int originY;
#endif
{
TuiGenWinInfoPtr executionInfo = (TuiGenWinInfoPtr) NULL;
 
/*
** Create the exeuction info window.
*/
if (type == SRC_WIN)
executionInfo = sourceExecInfoWinPtr ();
else
executionInfo = disassemExecInfoWinPtr ();
_initAndMakeWin ((Opaque *) & executionInfo,
EXEC_INFO_WIN,
height,
3,
0,
originY,
DONT_BOX_WINDOW);
/*
** Now create the source window.
*/
_initAndMakeWin ((Opaque *) winInfoPtr,
type,
height,
termWidth () - executionInfo->width,
executionInfo->width,
originY,
BOX_WINDOW);
 
(*winInfoPtr)->detail.sourceInfo.executionInfo = executionInfo;
 
return;
} /* _makeSourceOrDisassemWindow */
 
 
/*
** _showSourceOrDisassemAndCommand().
** Show the Source/Command or the Disassem layout
*/
static void
#ifdef __STDC__
_showSourceOrDisassemAndCommand (
TuiLayoutType layoutType)
#else
_showSourceOrDisassemAndCommand (layoutType)
TuiLayoutType layoutType;
#endif
{
if (currentLayout () != layoutType)
{
TuiWinInfoPtr *winInfoPtr;
int areaLeft;
int srcHeight, cmdHeight;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
if (m_winPtrNotNull (cmdWin))
cmdHeight = cmdWin->generic.height;
else
cmdHeight = termHeight () / 3;
srcHeight = termHeight () - cmdHeight;
 
 
if (layoutType == SRC_COMMAND)
winInfoPtr = &srcWin;
else
winInfoPtr = &disassemWin;
 
if (m_winPtrIsNull (*winInfoPtr))
{
if (layoutType == SRC_COMMAND)
_makeSourceWindow (winInfoPtr, srcHeight - 1, 0);
else
_makeDisassemWindow (winInfoPtr, srcHeight - 1, 0);
_initAndMakeWin ((Opaque *) & locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
srcHeight - 1,
DONT_BOX_WINDOW);
}
else
{
_initGenWinInfo (locator,
LOCATOR_WIN,
2 /* 1 */ ,
termWidth (),
0,
srcHeight - 1);
(*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
_initGenWinInfo (
&(*winInfoPtr)->generic,
(*winInfoPtr)->generic.type,
srcHeight - 1,
(*winInfoPtr)->generic.width,
(*winInfoPtr)->detail.sourceInfo.executionInfo->width,
0);
_initGenWinInfo ((*winInfoPtr)->detail.sourceInfo.executionInfo,
EXEC_INFO_WIN,
srcHeight - 1,
3,
0,
0);
(*winInfoPtr)->canHighlight = TRUE;
m_beVisible (*winInfoPtr);
m_beVisible ((*winInfoPtr)->detail.sourceInfo.executionInfo);
}
if (m_winPtrNotNull (*winInfoPtr))
{
(*winInfoPtr)->detail.sourceInfo.hasLocator = TRUE;
m_beVisible (locator);
tuiShowLocatorContent ();
tuiShowSourceContent (*winInfoPtr);
 
if (m_winPtrIsNull (cmdWin))
{
_makeCommandWindow (&cmdWin, cmdHeight, srcHeight);
tuiRefreshWin (&cmdWin->generic);
}
else
{
_initGenWinInfo (&cmdWin->generic,
cmdWin->generic.type,
cmdWin->generic.height,
cmdWin->generic.width,
cmdWin->generic.origin.x,
cmdWin->generic.origin.y);
cmdWin->canHighlight = FALSE;
m_beVisible (cmdWin);
}
}
setCurrentLayoutTo (layoutType);
}
 
return;
} /* _showSourceOrDisassemAndCommand */
/tuiData.h
0,0 → 1,332
#ifndef TUI_DATA_H
#define TUI_DATA_H
 
/* Constant definitions */
#define DEFAULT_TAB_LEN 8
#define NO_SRC_STRING "[ No Source Available ]"
#define NO_DISASSEM_STRING "[ No Assembly Available ]"
#define NO_REGS_STRING "[ Register Values Unavailable ]"
#define NO_DATA_STRING "[ No Data Values Displayed ]"
#define MAX_CONTENT_COUNT 100
#define SRC_NAME "SRC"
#define CMD_NAME "CMD"
#define DATA_NAME "REGS"
#define DISASSEM_NAME "ASM"
#define TUI_NULL_STR ""
#define DEFAULT_HISTORY_COUNT 25
#define BOX_WINDOW TRUE
#define DONT_BOX_WINDOW FALSE
#define HILITE TRUE
#define NO_HILITE FALSE
#define WITH_LOCATOR TRUE
#define NO_LOCATOR FALSE
#define EMPTY_SOURCE_PROMPT TRUE
#define NO_EMPTY_SOURCE_PROMPT FALSE
#define UNDEFINED_ITEM -1
#define MIN_WIN_HEIGHT 3
#define MIN_CMD_WIN_HEIGHT 3
 
#define FILE_PREFIX "File: "
#define PROC_PREFIX "Procedure: "
#define LINE_PREFIX "Line: "
#define PC_PREFIX "pc: "
 
#define TUI_FLOAT_REGS_NAME "$FREGS"
#define TUI_FLOAT_REGS_NAME_LOWER "$fregs"
#define TUI_GENERAL_REGS_NAME "$GREGS"
#define TUI_GENERAL_REGS_NAME_LOWER "$gregs"
#define TUI_SPECIAL_REGS_NAME "$SREGS"
#define TUI_SPECIAL_REGS_NAME_LOWER "$sregs"
#define TUI_GENERAL_SPECIAL_REGS_NAME "$REGS"
#define TUI_GENERAL_SPECIAL_REGS_NAME_LOWER "$regs"
 
/* Scroll direction enum */
typedef enum
{
FORWARD_SCROLL,
BACKWARD_SCROLL,
LEFT_SCROLL,
RIGHT_SCROLL
}
TuiScrollDirection, *TuiScrollDirectionPtr;
 
 
/* General list struct */
typedef struct _TuiList
{
OpaqueList list;
int count;
}
TuiList, *TuiListPtr;
 
 
/* The kinds of layouts available */
typedef enum
{
SRC_COMMAND,
DISASSEM_COMMAND,
SRC_DISASSEM_COMMAND,
SRC_DATA_COMMAND,
DISASSEM_DATA_COMMAND,
UNDEFINED_LAYOUT
}
TuiLayoutType, *TuiLayoutTypePtr;
 
/* Basic data types that can be displayed in the data window. */
typedef enum _TuiDataType
{
TUI_REGISTER,
TUI_SCALAR,
TUI_COMPLEX,
TUI_STRUCT
}
TuiDataType, TuiDataTypePtr;
 
/* Types of register displays */
typedef enum _TuiRegisterDisplayType
{
TUI_UNDEFINED_REGS,
TUI_GENERAL_REGS,
TUI_SFLOAT_REGS,
TUI_DFLOAT_REGS,
TUI_SPECIAL_REGS,
TUI_GENERAL_AND_SPECIAL_REGS
}
TuiRegisterDisplayType, *TuiRegisterDisplayTypePtr;
 
/* Structure describing source line or line address */
typedef union _TuiLineOrAddress
{
int lineNo;
Opaque addr;
}
TuiLineOrAddress, *TuiLineOrAddressPtr;
 
/* Current Layout definition */
typedef struct _TuiLayoutDef
{
TuiWinType displayMode;
int split;
TuiRegisterDisplayType regsDisplayType;
TuiRegisterDisplayType floatRegsDisplayType;
}
TuiLayoutDef, *TuiLayoutDefPtr;
 
/* Elements in the Source/Disassembly Window */
typedef struct _TuiSourceElement
{
char *line;
TuiLineOrAddress lineOrAddr;
int isExecPoint;
int hasBreak;
}
TuiSourceElement, *TuiSourceElementPtr;
 
 
/* Elements in the data display window content */
typedef struct _TuiDataElement
{
char *name;
int itemNo; /* the register number, or data display number */
TuiDataType type;
Opaque value;
int highlight;
}
TuiDataElement, *TuiDataElementPtr;
 
 
/* Elements in the command window content */
typedef struct _TuiCommandElement
{
char *line;
}
TuiCommandElement, *TuiCommandElementPtr;
 
 
#define MAX_LOCATOR_ELEMENT_LEN 100
 
/* Elements in the locator window content */
typedef struct _TuiLocatorElement
{
char fileName[MAX_LOCATOR_ELEMENT_LEN];
char procName[MAX_LOCATOR_ELEMENT_LEN];
int lineNo;
Opaque addr;
}
TuiLocatorElement, *TuiLocatorElementPtr;
 
 
/* An content element in a window */
typedef union
{
TuiSourceElement source; /* the source elements */
TuiGenWinInfo dataWindow; /* data display elements */
TuiDataElement data; /* elements of dataWindow */
TuiCommandElement command; /* command elements */
TuiLocatorElement locator; /* locator elements */
char *simpleString; /* simple char based elements */
}
TuiWhichElement, *TuiWhichElementPtr;
 
typedef struct _TuiWinElement
{
int highlight;
TuiWhichElement whichElement;
}
TuiWinElement, *TuiWinElementPtr;
 
 
/* This describes the content of the window. */
typedef TuiWinElementPtr *TuiWinContent;
 
 
/* This struct defines the specific information about a data display window */
typedef struct _TuiDataInfo
{
TuiWinContent dataContent; /* start of data display content */
int dataContentCount;
TuiWinContent regsContent; /* start of regs display content */
int regsContentCount;
TuiRegisterDisplayType regsDisplayType;
int regsColumnCount;
int displayRegs; /* Should regs be displayed at all? */
}
TuiDataInfo, *TuiDataInfoPtr;
 
 
typedef struct _TuiSourceInfo
{
int hasLocator; /* Does locator belongs to this window? */
TuiGenWinInfoPtr executionInfo; /* execution information window */
int horizontalOffset; /* used for horizontal scroll */
TuiLineOrAddress startLineOrAddr;
}
TuiSourceInfo, *TuiSourceInfoPtr;
 
 
typedef struct _TuiCommandInfo
{
int curLine; /* The current line position */
int curch; /* The current cursor position */
}
TuiCommandInfo, *TuiCommandInfoPtr;
 
 
/* This defines information about each logical window */
typedef struct _TuiWinInfo
{
TuiGenWinInfo generic; /* general window information */
union
{
TuiSourceInfo sourceInfo;
TuiDataInfo dataDisplayInfo;
TuiCommandInfo commandInfo;
Opaque opaque;
}
detail;
int canHighlight; /* Can this window ever be highlighted? */
int isHighlighted; /* Is this window highlighted? */
}
TuiWinInfo, *TuiWinInfoPtr;
 
/* MACROS (prefixed with m_) */
 
/* Testing macros */
#define m_genWinPtrIsNull(winInfo) \
((winInfo) == (TuiGenWinInfoPtr)NULL)
#define m_genWinPtrNotNull(winInfo) \
((winInfo) != (TuiGenWinInfoPtr)NULL)
#define m_winPtrIsNull(winInfo) \
((winInfo) == (TuiWinInfoPtr)NULL)
#define m_winPtrNotNull(winInfo) \
((winInfo) != (TuiWinInfoPtr)NULL)
 
#define m_winIsSourceType(type) \
(type == SRC_WIN || type == DISASSEM_WIN)
#define m_winIsAuxillary(winType) \
(winType > MAX_MAJOR_WINDOWS)
#define m_hasLocator(winInfo) \
( ((winInfo) != (TuiWinInfoPtr)NULL) ? \
(winInfo->detail.sourceInfo.hasLocator) : \
FALSE )
 
#define m_setWinHighlightOn(winInfo) \
if ((winInfo) != (TuiWinInfoPtr)NULL) \
(winInfo)->isHighlighted = TRUE
#define m_setWinHighlightOff(winInfo) \
if ((winInfo) != (TuiWinInfoPtr)NULL) \
(winInfo)->isHighlighted = FALSE
 
 
/* Global Data */
extern TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
extern int tui_version;
 
/* Macros */
#define srcWin winList[SRC_WIN]
#define disassemWin winList[DISASSEM_WIN]
#define dataWin winList[DATA_WIN]
#define cmdWin winList[CMD_WIN]
 
/* Data Manipulation Functions */
extern void initializeStaticData PARAMS ((void));
extern TuiGenWinInfoPtr allocGenericWinInfo PARAMS ((void));
extern TuiWinInfoPtr allocWinInfo PARAMS ((TuiWinType));
extern void initGenericPart PARAMS ((TuiGenWinInfoPtr));
extern void initWinInfo PARAMS ((TuiWinInfoPtr));
extern TuiWinContent allocContent PARAMS ((int, TuiWinType));
extern int addContentElements
PARAMS ((TuiGenWinInfoPtr, int));
extern void initContentElement
PARAMS ((TuiWinElementPtr, TuiWinType));
extern void freeWindow PARAMS ((TuiWinInfoPtr));
extern void freeAllWindows PARAMS ((void));
extern void freeWinContent PARAMS ((TuiGenWinInfoPtr));
extern void freeDataContent PARAMS ((TuiWinContent, int));
extern void freeAllSourceWinsContent PARAMS ((void));
extern void tuiDelWindow PARAMS ((TuiWinInfoPtr));
extern void tuiDelDataWindows PARAMS ((TuiWinContent, int));
extern TuiWinInfoPtr winByName PARAMS ((char *));
extern TuiWinInfoPtr partialWinByName PARAMS ((char *));
extern char *winName PARAMS ((TuiGenWinInfoPtr));
extern char *displayableWinContentOf
PARAMS ((TuiGenWinInfoPtr, TuiWinElementPtr));
extern char *displayableWinContentAt
PARAMS ((TuiGenWinInfoPtr, int));
extern int winElementHeight
PARAMS ((TuiGenWinInfoPtr, TuiWinElementPtr));
extern TuiLayoutType currentLayout PARAMS ((void));
extern void setCurrentLayoutTo PARAMS ((TuiLayoutType));
extern int termHeight PARAMS ((void));
extern void setTermHeight PARAMS ((int));
extern int termWidth PARAMS ((void));
extern void setTermWidth PARAMS ((int));
extern int historyLimit PARAMS ((void));
extern void setHistoryLimit PARAMS ((int));
extern void setGenWinOrigin PARAMS ((TuiGenWinInfoPtr, int, int));
extern TuiGenWinInfoPtr locatorWinInfoPtr PARAMS ((void));
extern TuiGenWinInfoPtr sourceExecInfoWinPtr PARAMS ((void));
extern TuiGenWinInfoPtr disassemExecInfoWinPtr PARAMS ((void));
extern char *nullStr PARAMS ((void));
extern char *blankStr PARAMS ((void));
extern char *locationStr PARAMS ((void));
extern char *breakStr PARAMS ((void));
extern char *breakLocationStr PARAMS ((void));
extern TuiListPtr sourceWindows PARAMS ((void));
extern void clearSourceWindows PARAMS ((void));
extern void clearSourceWindowsDetail PARAMS ((void));
extern void clearWinDetail PARAMS ((TuiWinInfoPtr winInfo));
extern void tuiAddToSourceWindows PARAMS ((TuiWinInfoPtr));
extern int tuiDefaultTabLen PARAMS ((void));
extern void tuiSetDefaultTabLen PARAMS ((int));
extern TuiWinInfoPtr tuiWinWithFocus PARAMS ((void));
extern void tuiSetWinWithFocus PARAMS ((TuiWinInfoPtr));
extern TuiLayoutDefPtr tuiLayoutDef PARAMS ((void));
extern int tuiWinResized PARAMS ((void));
extern void tuiSetWinResizedTo PARAMS ((int));
 
extern TuiWinInfoPtr tuiNextWin PARAMS ((TuiWinInfoPtr));
extern TuiWinInfoPtr tuiPrevWin PARAMS ((TuiWinInfoPtr));
 
 
#endif /* TUI_DATA_H */
/tuiCommand.c
0,0 → 1,215
/*
** tuiCommand.c
** This module contains functions specific to command window processing.
*/
 
 
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiWin.h"
#include "tuiIO.h"
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
 
/*
** tuiDispatchCtrlChar().
** Dispatch the correct tui function based upon the control character.
*/
unsigned int
#ifdef __STDC__
tuiDispatchCtrlChar (
unsigned int ch)
#else
tuiDispatchCtrlChar (ch)
unsigned int ch;
#endif
{
TuiWinInfoPtr winInfo = tuiWinWithFocus ();
 
/*
** If the command window has the logical focus, or no-one does
** assume it is the command window; in this case, pass the
** character on through and do nothing here.
*/
if (winInfo == (TuiWinInfoPtr) NULL || winInfo == cmdWin)
return ch;
else
{
unsigned int c = 0, chCopy = ch;
register int i;
char *term;
 
/* If this is an xterm, page next/prev keys aren't returned
** by keypad as a single char, so we must handle them here.
** Seems like a bug in the curses library?
*/
term = (char *) getenv ("TERM");
for (i = 0; (term && term[i]); i++)
term[i] = toupper (term[i]);
if ((strcmp (term, "XTERM") == 0) && m_isStartSequence (ch))
{
unsigned int pageCh = 0, tmpChar;
 
tmpChar = 0;
while (!m_isEndSequence (tmpChar))
{
tmpChar = (int) wgetch (cmdWin->generic.handle);
if (!tmpChar)
break;
if (tmpChar == 53)
pageCh = KEY_PPAGE;
else if (tmpChar == 54)
pageCh = KEY_NPAGE;
}
chCopy = pageCh;
}
 
switch (chCopy)
{
case KEY_NPAGE:
tuiScrollForward (winInfo, 0);
break;
case KEY_PPAGE:
tuiScrollBackward (winInfo, 0);
break;
case KEY_DOWN:
case KEY_SF:
tuiScrollForward (winInfo, 1);
break;
case KEY_UP:
case KEY_SR:
tuiScrollBackward (winInfo, 1);
break;
case KEY_RIGHT:
tuiScrollLeft (winInfo, 1);
break;
case KEY_LEFT:
tuiScrollRight (winInfo, 1);
break;
case '\f':
tuiRefreshAll ();
break;
default:
c = chCopy;
break;
}
return c;
}
} /* tuiDispatchCtrlChar */
 
 
/*
** tuiIncrCommandCharCountBy()
** Increment the current character count in the command window,
** checking for overflow. Returns the new value of the char count.
*/
int
#ifdef __STDC__
tuiIncrCommandCharCountBy (
int count)
#else
tuiIncrCommandCharCountBy (count)
int count;
#endif
{
if (tui_version)
{
if ((count + cmdWin->detail.commandInfo.curch) >= cmdWin->generic.width)
cmdWin->detail.commandInfo.curch =
(count + cmdWin->detail.commandInfo.curch) - cmdWin->generic.width;
else
cmdWin->detail.commandInfo.curch += count;
}
 
return cmdWin->detail.commandInfo.curch;
} /* tuiIncrCommandCharCountBy */
 
 
/*
** tuiDecrCommandCharCountBy()
** Decrement the current character count in the command window,
** checking for overflow. Returns the new value of the char count.
*/
int
#ifdef __STDC__
tuiDecrCommandCharCountBy (
int count)
#else
tuiDecrCommandCharCountBy (count)
int count;
#endif
{
if (tui_version)
{
if ((cmdWin->detail.commandInfo.curch - count) < 0)
cmdWin->detail.commandInfo.curch =
cmdWin->generic.width + (cmdWin->detail.commandInfo.curch - count);
else
cmdWin->detail.commandInfo.curch -= count;
}
 
return cmdWin->detail.commandInfo.curch;
} /* tuiDecrCommandCharCountBy */
 
 
/*
** tuiSetCommandCharCountTo()
** Set the character count to count.
*/
int
#ifdef __STDC__
tuiSetCommandCharCountTo (
int count)
#else
tuiSetCommandCharCountTo (count)
int count;
#endif
{
if (tui_version)
{
if (count > cmdWin->generic.width - 1)
{
cmdWin->detail.commandInfo.curch = 0;
tuiIncrCommandCharCountBy (count);
}
else
cmdWin->detail.commandInfo.curch -= count;
}
 
return cmdWin->detail.commandInfo.curch;
} /* tuiSetCommandCharCountTo */
 
 
 
/*
** tuiClearCommandCharCount()
** Clear the character count to count.
*/
int
#ifdef __STDC__
tuiClearCommandCharCount (void)
#else
tuiClearCommandCharCount ()
#endif
{
if (tui_version)
cmdWin->detail.commandInfo.curch = 0;
 
return cmdWin->detail.commandInfo.curch;
} /* tuiClearCommandCharCount */
 
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
/tuiSourceWin.c
0,0 → 1,1098
/*
** tuiSourceWin.c
** This module contains functions for displaying source or assembly in the "source" window.
* The "source" window may be the assembly or the source windows.
*/
 
#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 **
*********************************/
 
/*
** tuiSrcWinIsDisplayed().
*/
int
#ifdef __STDC__
tuiSrcWinIsDisplayed (void)
#else
tuiSrcWinIsDisplayed ()
#endif
{
return (m_winPtrNotNull (srcWin) && srcWin->generic.isVisible);
} /* tuiSrcWinIsDisplayed */
 
 
/*
** tuiAsmWinIsDisplayed().
*/
int
#ifdef __STDC__
tuiAsmWinIsDisplayed (void)
#else
tuiAsmWinIsDisplayed ()
#endif
{
return (m_winPtrNotNull (disassemWin) && disassemWin->generic.isVisible);
} /* tuiAsmWinIsDisplayed */
 
 
/*
** 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 */
 
 
 
/*
** 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 */
 
 
/*
** 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;
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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
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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 **
*********************************/
 
/*
** 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];
/*
** 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;
}
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** 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 */
 
 
/*
** tuiClearExecInfoContent().
*/
void
#ifdef __STDC__
tuiClearExecInfoContent (
TuiWinInfoPtr winInfo)
#else
tuiClearExecInfoContent (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
winInfo->detail.sourceInfo.executionInfo->contentInUse = FALSE;
tuiEraseExecInfoContent (winInfo);
 
return;
} /* tuiClearExecInfoContent */
 
 
/*
** 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 */
 
 
/*
** 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
 
 
/*
** tuiUpdateAllExecInfos()
*/
void
#ifdef __STDC__
tuiUpdateAllExecInfos (void)
#else
tuiUpdateAllExecInfos ()
#endif
{
int i;
 
for (i = 0; i < (sourceWindows ())->count; i++)
tuiUpdateExecInfo ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
 
return;
} /* tuiUpdateAllExecInfos */
 
 
 
/* tuiUpdateOnEnd()
** 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 */
tuiSetExecInfoContent (winInfo); /*set winInfo so that > is'n displayed */
tuiShowExecInfoContent (winInfo); /* display the new contents */
}
 
/*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;
/*
** 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 */
 
 
/*
** 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 **
******************************************/
/tui.c
0,0 → 1,829
/*
** tui.c
** General functions for the WDB TUI
*/
 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <malloc.h>
#include <curses.h>
#ifdef HAVE_TERM_H
#include <term.h>
#endif
#include <signal.h>
#include <fcntl.h>
#include <termio.h>
#include <setjmp.h>
#include "defs.h"
#include "gdbcmd.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiIO.h"
#include "tuiRegs.h"
#include "tuiWin.h"
 
/* The Solaris header files seem to provide no declaration for this at
all when __STDC__ is defined. This shouldn't conflict with
anything. */
extern char *tgoto ();
 
/***********************
** Local Definitions
************************/
#define FILEDES 2
/* Solaris <sys/termios.h> defines CTRL. */
#ifndef CTRL
#define CTRL(x) (x & ~0140)
#endif
#define CHK(val, dft) (val<=0 ? dft : val)
 
#define TOGGLE_USAGE "Usage:toggle breakpoints"
#define TUI_TOGGLE_USAGE "Usage:\ttoggle $fregs\n\ttoggle breakpoints"
 
/*****************************
** Local static forward decls
******************************/
static void _tuiReset PARAMS ((void));
static void _toggle_command PARAMS ((char *, int));
static void _tui_vToggle_command PARAMS ((va_list));
static Opaque _tui_vDo PARAMS ((TuiOpaqueFuncPtr, va_list));
 
 
 
/***********************
** Public Functions
************************/
 
/*
** tuiInit().
*/
void
#ifdef __STDC__
tuiInit (char *argv0)
#else
tuiInit (argv0)
char *argv0;
#endif
{
extern void init_page_info ();
extern void initialize_tui_files PARAMS ((void));
 
initialize_tui_files ();
initializeStaticData ();
initscr ();
refresh ();
setTermHeightTo (LINES);
setTermWidthTo (COLS);
tuiInitWindows ();
wrefresh (cmdWin->generic.handle);
init_page_info ();
/* Don't hook debugger output if doing command-window
* the XDB way. However, one thing we do want to do in
* XDB style is set up the scrolling region to be
* the bottom of the screen (tuiTermUnsetup()).
*/
fputs_unfiltered_hook = NULL;
rl_initialize (); /* need readline initialization to
* create termcap sequences
*/
tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);
 
return;
} /* tuiInit */
 
 
/*
** tuiInitWindows().
*/
void
#ifdef __STDC__
tuiInitWindows (void)
#else
tuiInitWindows ()
#endif
{
TuiWinType type;
 
tuiSetLocatorContent (0);
showLayout (SRC_COMMAND);
keypad (cmdWin->generic.handle, TRUE);
echo ();
crmode ();
nl ();
tuiSetWinFocusTo (srcWin);
 
return;
} /* tuiInitWindows */
 
 
/*
** tuiCleanUp().
** Kill signal handler and cleanup termination method
*/
void
#ifdef __STDC__
tuiResetScreen (void)
#else
tuiResetScreen ()
#endif
{
TuiWinType type = SRC_WIN;
 
keypad (cmdWin->generic.handle, FALSE);
for (; type < MAX_MAJOR_WINDOWS; type++)
{
if (m_winPtrNotNull (winList[type]) &&
winList[type]->generic.type != UNDEFINED_WIN &&
!winList[type]->generic.isVisible)
tuiDelWindow (winList[type]);
}
endwin ();
initscr ();
refresh ();
echo ();
crmode ();
nl ();
 
return;
} /* tuiResetScreen */
 
 
/*
** tuiCleanUp().
** Kill signal handler and cleanup termination method
*/
void
#ifdef __STDC__
tuiCleanUp (void)
#else
tuiCleanUp ()
#endif
{
char *buffer;
extern char *term_cursor_move;
 
signal (SIGINT, SIG_IGN);
tuiTermSetup (0); /* Restore scrolling region to whole screen */
keypad (cmdWin->generic.handle, FALSE);
freeAllWindows ();
endwin ();
buffer = tgoto (term_cursor_move, 0, termHeight ());
tputs (buffer, 1, putchar);
_tuiReset ();
 
return;
} /* tuiCleanUp */
 
 
/*
** tuiError().
*/
void
#ifdef __STDC__
tuiError (
char *string,
int exitGdb)
#else
tuiError (string, exitGdb)
char *string;
int exitGdb;
#endif
{
puts_unfiltered (string);
if (exitGdb)
{
tuiCleanUp ();
exit (-1);
}
 
return;
} /* tuiError */
 
 
/*
** tui_vError()
** tuiError with args in a va_list.
*/
void
#ifdef __STDC__
tui_vError (
va_list args)
#else
tui_vError (args)
va_list args;
#endif
{
char *string;
int exitGdb;
 
string = va_arg (args, char *);
exitGdb = va_arg (args, int);
 
tuiError (string, exitGdb);
 
return;
} /* tui_vError */
 
 
/*
** tuiFree()
** Wrapper on top of free() to ensure that input address is greater than 0x0
*/
void
#ifdef __STDC__
tuiFree (
char *ptr)
#else
tuiFree (ptr)
char *ptr;
#endif
{
if (ptr != (char *) NULL)
{
free (ptr);
}
 
return;
} /* tuiFree */
 
 
/* tuiGetLowDisassemblyAddress().
** Determine what the low address will be to display in the TUI's
** disassembly window. This may or may not be the same as the
** low address input.
*/
Opaque
#ifdef __STDC__
tuiGetLowDisassemblyAddress (
Opaque low,
Opaque pc)
#else
tuiGetLowDisassemblyAddress (low, pc)
Opaque low;
Opaque pc;
#endif
{
int line;
Opaque newLow;
 
/*
** Determine where to start the disassembly so that the pc is about in the
** middle of the viewport.
*/
for (line = 0, newLow = pc;
(newLow > low &&
line < (tuiDefaultWinViewportHeight (DISASSEM_WIN,
DISASSEM_COMMAND) / 2));)
{
bfd_byte buffer[4];
 
newLow -= sizeof (bfd_getb32 (buffer));
line++;
}
 
return newLow;
} /* tuiGetLowDisassemblyAddress */
 
 
/* tui_vGetLowDisassemblyAddress().
** Determine what the low address will be to display in the TUI's
** disassembly window with args in a va_list.
*/
Opaque
#ifdef __STDC__
tui_vGetLowDisassemblyAddress (
va_list args)
#else
tui_vGetLowDisassemblyAddress (args)
va_list args;
#endif
{
int line;
Opaque newLow;
Opaque low;
Opaque pc;
 
low = va_arg (args, Opaque);
pc = va_arg (args, Opaque);
 
return (tuiGetLowDisassemblyAddress (low, pc));
 
} /* tui_vGetLowDisassemblyAddress */
 
 
/*
** tuiDo().
** General purpose function to execute a tui function. Transitions
** between curses and the are handled here. This function is called
** by non-tui gdb functions.
**
** Errors are caught here.
** If there is no error, the value returned by 'func' is returned.
** If there is an error, then zero is returned.
**
** Must not be called with immediate_quit in effect (bad things might
** happen, say we got a signal in the middle of a memcpy to quit_return).
** This is an OK restriction; with very few exceptions immediate_quit can
** be replaced by judicious use of QUIT.
*/
Opaque
#ifdef __STDC__
tuiDo (
TuiOpaqueFuncPtr func,...)
#else
tuiDo (func, va_alist)
TuiOpaqueFuncPtr func;
va_dcl
#endif
{
extern int terminal_is_ours;
 
Opaque ret = (Opaque) NULL;
 
/* It is an error to be tuiDo'ing if we
* don't own the terminal.
*/
if (!terminal_is_ours)
return ret;
 
if (tui_version)
{
va_list args;
 
#ifdef __STDC__
va_start (args, func);
#else
va_start (args);
#endif
ret = _tui_vDo (func, args);
va_end (args);
}
 
return ret;
} /* tuiDo */
 
 
/*
** tuiDoAndReturnToTop().
** General purpose function to execute a tui function. Transitions
** between curses and the are handled here. This function is called
** by non-tui gdb functions who wish to reset gdb to the top level.
** After the tuiDo is performed, a return to the top level occurs.
**
** Errors are caught here.
** If there is no error, the value returned by 'func' is returned.
** If there is an error, then zero is returned.
**
** Must not be called with immediate_quit in effect (bad things might
** happen, say we got a signal in the middle of a memcpy to quit_return).
** This is an OK restriction; with very few exceptions immediate_quit can
** be replaced by judicious use of QUIT.
**
*/
Opaque
#ifdef __STDC__
tuiDoAndReturnToTop (
TuiOpaqueFuncPtr func,...)
#else
tuiDoAndReturnToTop (func, va_alist)
TuiOpaqueFuncPtr func;
va_dcl
#endif
{
extern int terminal_is_ours;
 
Opaque ret = (Opaque) NULL;
 
/* It is an error to be tuiDo'ing if we
* don't own the terminal.
*/
if (!terminal_is_ours)
return ret;
 
if (tui_version)
{
va_list args;
 
#ifdef __STDC__
va_start (args, func);
#else
va_start (args);
#endif
ret = _tui_vDo (func, args);
 
/* force a return to the top level */
return_to_top_level (RETURN_ERROR);
}
 
return ret;
} /* tuiDoAndReturnToTop */
 
 
void
#ifdef __STDC__
tui_vSelectSourceSymtab (
va_list args)
#else
tui_vSelectSourceSymtab (args)
va_list args;
#endif
{
struct symtab *s = va_arg (args, struct symtab *);
 
select_source_symtab (s);
return;
} /* tui_vSelectSourceSymtab */
 
 
/*
** _initialize_tui().
** Function to initialize gdb commands, for tui window manipulation.
*/
void
_initialize_tui ()
{
#if 0
if (tui_version)
{
add_com ("toggle", class_tui, _toggle_command,
"Toggle Terminal UI Features\n\
Usage: Toggle $fregs\n\
\tToggles between single and double precision floating point registers.\n");
}
#endif
char *helpStr;
 
if (tui_version)
helpStr = "Toggle Specified Features\n\
Usage:\ttoggle $fregs\n\ttoggle breakpoints";
else
helpStr = "Toggle Specified Features\nUsage:toggle breakpoints";
add_abbrev_prefix_cmd ("toggle",
class_tui,
_toggle_command,
helpStr,
&togglelist,
"toggle ",
1,
&cmdlist);
} /* _initialize_tui */
 
 
/*
** va_catch_errors().
** General purpose function to execute a function, catching errors.
** If there is no error, the value returned by 'func' is returned.
** If there is error, then zero is returned.
** Note that 'func' must take a variable argument list as well.
**
** Must not be called with immediate_quit in effect (bad things might
** happen, say we got a signal in the middle of a memcpy to quit_return).
** This is an OK restriction; with very few exceptions immediate_quit can
** be replaced by judicious use of QUIT.
*/
Opaque
#ifdef __STDC__
va_catch_errors (
TuiOpaqueFuncPtr func,
va_list args)
#else
va_catch_errors (func, args)
TuiOpaqueFuncPtr func;
va_list args;
#endif
{
Opaque ret = (Opaque) NULL;
 
/*
** We could have used catch_errors(), but it doesn't handle variable args.
** Also, for the tui, we always want to catch all errors, so we don't
** need to pass a mask, or an error string.
*/
jmp_buf saved_error;
jmp_buf saved_quit;
jmp_buf tmp_jmp;
struct cleanup *saved_cleanup_chain;
char *saved_error_pre_print;
char *saved_quit_pre_print;
extern jmp_buf error_return;
extern jmp_buf quit_return;
 
saved_cleanup_chain = save_cleanups ();
saved_error_pre_print = error_pre_print;
saved_quit_pre_print = quit_pre_print;
 
memcpy ((char *) saved_error, (char *) error_return, sizeof (jmp_buf));
error_pre_print = "";
memcpy (saved_quit, quit_return, sizeof (jmp_buf));
quit_pre_print = "";
 
if (setjmp (tmp_jmp) == 0)
{
va_list argList = args;
memcpy (error_return, tmp_jmp, sizeof (jmp_buf));
memcpy (quit_return, tmp_jmp, sizeof (jmp_buf));
ret = func (argList);
}
restore_cleanups (saved_cleanup_chain);
memcpy (error_return, saved_error, sizeof (jmp_buf));
error_pre_print = saved_error_pre_print;
memcpy (quit_return, saved_quit, sizeof (jmp_buf));
quit_pre_print = saved_quit_pre_print;
 
return ret;
}
 
/*
** vcatch_errors().
** Catch errors occurring in tui or non tui function, handling
** variable param lists. Note that 'func' must take a variable
** argument list as well.
*/
Opaque
#ifdef __STDC__
vcatch_errors (
OpaqueFuncPtr func,...)
#else
vcatch_errors (va_alist)
va_dcl
/*
vcatch_errors(func, va_alist)
OpaqueFuncPtr func;
va_dcl
*/
#endif
{
Opaque ret = (Opaque) NULL;
va_list args;
#ifdef __STDC__
va_start (args, func);
/*
va_arg(args, OpaqueFuncPtr);
*/
#else
OpaqueFuncPtr func;
 
va_start (args);
func = va_arg (args, OpaqueFuncPtr);
#endif
ret = va_catch_errors (func, args);
va_end (args);
 
return ret;
}
 
 
void
#ifdef __STDC__
strcat_to_buf (
char *buf,
int buflen,
char *itemToAdd)
#else
strcat_to_buf (buf, buflen, itemToAdd)
char *buf;
int buflen;
char *itemToAdd;
#endif
{
if (itemToAdd != (char *) NULL && buf != (char *) NULL)
{
if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
strcat (buf, itemToAdd);
else
strncat (buf, itemToAdd, (buflen - strlen (buf)));
}
 
return;
} /* strcat_to_buf */
 
/* VARARGS */
void
#ifdef ANSI_PROTOTYPES
strcat_to_buf_with_fmt (
char *buf,
int bufLen,
char *format,...)
#else
strcat_to_buf_with_fmt (va_alist)
va_dcl
#endif
{
char *linebuffer;
struct cleanup *old_cleanups;
va_list args;
#ifdef ANSI_PROTOTYPES
va_start (args, format);
#else
char *buf;
int bufLen;
char *format;
 
va_start (args);
buf = va_arg (args, char *);
bufLen = va_arg (args, int);
format = va_arg (args, char *);
#endif
vasprintf (&linebuffer, format, args);
old_cleanups = make_cleanup (free, linebuffer);
strcat_to_buf (buf, bufLen, linebuffer);
do_cleanups (old_cleanups);
va_end (args);
}
 
 
 
 
 
/***********************
** Static Functions
************************/
 
 
/*
** _tui_vDo().
** General purpose function to execute a tui function. Transitions
** between curses and the are handled here. This function is called
** by non-tui gdb functions.
**
** Errors are caught here.
** If there is no error, the value returned by 'func' is returned.
** If there is an error, then zero is returned.
**
** Must not be called with immediate_quit in effect (bad things might
** happen, say we got a signal in the middle of a memcpy to quit_return).
** This is an OK restriction; with very few exceptions immediate_quit can
** be replaced by judicious use of QUIT.
*/
static Opaque
#ifdef __STDC__
_tui_vDo (
TuiOpaqueFuncPtr func,
va_list args)
#else
_tui_vDo (func, args)
TuiOpaqueFuncPtr func;
va_list args;
#endif
{
extern int terminal_is_ours;
 
Opaque ret = (Opaque) NULL;
 
/* It is an error to be tuiDo'ing if we
* don't own the terminal.
*/
if (!terminal_is_ours)
return ret;
 
if (tui_version)
{
/* If doing command window the "XDB way" (command window
* is unmanaged by curses...
*/
/* Set up terminal for TUI */
tuiTermSetup (1);
 
ret = va_catch_errors (func, args);
 
/* Set up terminal for command window */
tuiTermUnsetup (1, cmdWin->detail.commandInfo.curch);
}
 
return ret;
} /* _tui_vDo */
 
 
static void
#ifdef __STDC__
_toggle_command (
char *arg,
int fromTTY)
#else
_toggle_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
printf_filtered ("Specify feature to toggle.\n%s\n",
(tui_version) ? TUI_TOGGLE_USAGE : TOGGLE_USAGE);
/*
tuiDo((TuiOpaqueFuncPtr)_Toggle_command, arg, fromTTY);
*/
}
 
/*
** _tui_vToggle_command().
*/
static void
#ifdef __STDC__
_tui_vToggle_command (
va_list args)
#else
_tui_vToggle_command (args)
va_list args;
#endif
{
char *arg;
int fromTTY;
 
arg = va_arg (args, char *);
 
if (arg == (char *) NULL)
printf_filtered (TOGGLE_USAGE);
else
{
char *ptr = (char *) tuiStrDup (arg);
int i;
 
for (i = 0; (ptr[i]); i++)
ptr[i] = toupper (arg[i]);
 
if (subsetCompare (ptr, TUI_FLOAT_REGS_NAME))
tuiToggleFloatRegs ();
/* else if (subsetCompare(ptr, "ANOTHER TOGGLE OPTION"))
...
*/
else
printf_filtered (TOGGLE_USAGE);
tuiFree (ptr);
}
 
return;
} /* _tuiToggle_command */
 
 
static void
#ifdef __STDC__
_tuiReset (void)
#else
_tuiReset ()
#endif
{
struct termio mode;
 
/*
** reset the teletype mode bits to a sensible state.
** Copied tset.c
*/
#if ! defined (USG) && defined (TIOCGETC)
struct tchars tbuf;
#endif /* !USG && TIOCGETC */
#ifdef UCB_NTTY
struct ltchars ltc;
 
if (ldisc == NTTYDISC)
{
ioctl (FILEDES, TIOCGLTC, &ltc);
ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
ioctl (FILEDES, TIOCSLTC, &ltc);
}
#endif /* UCB_NTTY */
#ifndef USG
#ifdef TIOCGETC
ioctl (FILEDES, TIOCGETC, &tbuf);
tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
/* brkc is left alone */
ioctl (FILEDES, TIOCSETC, &tbuf);
#endif /* TIOCGETC */
mode.sg_flags &= ~(RAW
#ifdef CBREAK
| CBREAK
#endif /* CBREAK */
| VTDELAY | ALLDELAY);
mode.sg_flags |= XTABS | ECHO | CRMOD | ANYP;
#else /*USG */
ioctl (FILEDES, TCGETA, &mode);
mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));
mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));
mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));
 
mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | INLCR | IGNCR | IUCLC | IXOFF);
mode.c_iflag |= (BRKINT | ISTRIP | ICRNL | IXON);
mode.c_oflag &= ~(OLCUC | OCRNL | ONOCR | ONLRET | OFILL | OFDEL |
NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY);
mode.c_oflag |= (OPOST | ONLCR);
mode.c_cflag &= ~(CSIZE | PARODD | CLOCAL);
#ifndef hp9000s800
mode.c_cflag |= (CS8 | CREAD);
#else /*hp9000s800 */
mode.c_cflag |= (CS8 | CSTOPB | CREAD);
#endif /* hp9000s800 */
mode.c_lflag &= ~(XCASE | ECHONL | NOFLSH);
mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOK);
ioctl (FILEDES, TCSETAW, &mode);
#endif /* USG */
 
return;
} /* _tuiReset */
/Makefile.in
0,0 → 1,171
# Copyright 1998 Free Software Foundation, Inc.
 
# 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.
 
all: libtui.a
 
srcdir=@srcdir@
VPATH = @srcdir@
 
SHELL = @SHELL@
 
CC=@CC@
CFLAGS=@CFLAGS@
AR=@AR@
RANLIB=@RANLIB@
 
# Host and target-dependent makefile fragments come in here.
@host_makefile_frag@
@target_makefile_frag@
# End of host and target-dependent makefile fragments
 
# Where is our "include" directory? Typically $(srcdir)/../include.
# This is essentially the header file directory for the library
# routines in libiberty.
INCLUDE_DIR = $(srcdir)/../../include
INCLUDE_CFLAGS = -I$(INCLUDE_DIR)
 
# Configured by the --with-mmalloc option to configure.
MMALLOC = @MMALLOC@
MMALLOC_CFLAGS = @MMALLOC_CFLAGS@
 
# Where is the BFD library? Typically in ../bfd.
BFD_DIR = ../../bfd
BFD_SRC = $(srcdir)/$(BFD_DIR)
BFD_CFLAGS = -I$(BFD_DIR) -I$(BFD_SRC)
 
# Where is the READLINE library? Typically in ../readline.
READLINE_DIR = ../../readline
READLINE_SRC = $(srcdir)/$(READLINE_DIR)
READLINE_CFLAGS = -I$(READLINE_SRC)
 
# Where is the INTL library? Typically in ../intl.
INTL_DIR = ../../intl
INTL_SRC = $(srcdir)/$(INTL_DIR)
INTL_CFLAGS = -I$(INTL_DIR) -I$(INTL_SRC)
 
# Where is the TCL library? Typically in ../tcl.
TCL_CFLAGS = @TCLHDIR@
 
# Where is the TK library? Typically in ../tk.
TK_CFLAGS = @TKHDIR@ @TK_BUILD_INCLUDES@
 
# Where is Itcl? Typically in ../itcl.
ITCL_CFLAGS = @ITCLHDIR@
 
# Where is Tix? Typically in ../tix.
TIX_CFLAGS = @TIXHDIR@
 
X11_CFLAGS = @TK_XINCLUDES@
 
ENABLE_IDE= @ENABLE_IDE@
 
GUI_CFLAGS_X = -I$(srcdir)/../../libgui/src
 
IDE_CFLAGS_X = -I$(srcdir)/../../libidetcl/src -I$(srcdir)/../../libide/src \
`if [ x"$(ENABLE_IDE)" != x ] ; then \
echo -DIDE -I$(srcdir)/../../ilu/runtime/mainloop;\
fi`
 
IDE_CFLAGS=$(GUI_CFLAGS_X) $(IDE_CFLAGS_X)
 
ENABLE_CFLAGS= @ENABLE_CFLAGS@
 
# -I. for config files.
# -I$(srcdir) for gdb internal headers and possibly for gnu-regex.h also.
# -I$(srcdir)/config for more generic config files.
 
# It is also possible that you will need to add -I/usr/include/sys if
# your system doesn't have fcntl.h in /usr/include (which is where it
# should be according to Posix).
DEFS = @DEFS@
GDB_CFLAGS = -I. -I.. -I$(srcdir) -I$(srcdir)/.. -I$(srcdir)/../config $(DEFS)
 
# M{H,T}_CFLAGS, if defined, have host- and target-dependent CFLAGS
# from the config directory.
GLOBAL_CFLAGS = $(MT_CFLAGS) $(MH_CFLAGS)
#PROFILE_CFLAGS = -pg
 
# INTERNAL_CFLAGS is the aggregate of all other *CFLAGS macros.
INTERNAL_CFLAGS = $(CFLAGS) $(GLOBAL_CFLAGS) $(PROFILE_CFLAGS) \
$(GDB_CFLAGS) $(READLINE_CFLAGS) $(BFD_CFLAGS) \
$(MMALLOC_CFLAGS) $(INCLUDE_CFLAGS) $(INTL_CFLAGS) \
$(ENABLE_CFLAGS)
 
HEADERS = tuiIO.h tuiData.h tuiGeneralWin.h tuiLayout.h tuiStack.h \
tuiSource.h tuiCommand.h tuiWin.h tuiDisassem.h \
tuiSourceWin.h tuiRegs.h tuiDataWin.h
 
SOURCES = tui.c tuiData.c tuiSource.c tuiStack.c tuiIO.c \
tuiGeneralWin.c tuiLayout.c tuiWin.c tuiCommand.c \
tuiDisassem.c tuiSourceWin.c tuiRegs.c tuiDataWin.c
 
OBJECTS = tui.o tuiData.o tuiSource.o tuiStack.o tuiIO.o \
tuiGeneralWin.o tuiLayout.o tuiWin.o tuiCommand.o \
tuiDisassem.o tuiSourceWin.o tuiRegs.o tuiDataWin.o \
tuiInit.o
 
 
# Prevent Sun make from putting in the machine type. Setting
# TARGET_ARCH to nothing works for SunOS 3, 4.0, but not for 4.1.
.c.o:
$(CC) -c $(INTERNAL_CFLAGS) $<
.SUFFIXES: .cpp
.c.cpp:
$(CC) -E $(INTERNAL_CFLAGS) $< > $@
 
libtui.a: $(OBJECTS)
rm -f libtui.a
$(AR) rc libtui.a $(OBJECTS)
$(RANLIB) libtui.a
 
tui.o: tui.c tui.h tuiData.h tuiLayout.h tuiIO.h tuiRegs.h tuiWin.h
tuiCommand.o: tui.h tuiData.h tuiWin.h tuiIO.h
tuiData.o: tui.h tuiData.h
tuiDataWin.o: tui.h tuiData.h tuiRegs.h
tuiDisassem.o: tui.h tuiData.h tuiLayout.h tuiSourceWin.h tuiStack.h
tuiGeneralWin.o: tui.h tuiData.h tuiGeneralWin.h
tuiIO.o: tui.h tuiData.h tuiIO.h tuiCommand.h tuiWin.h
tuiLayout.o: tui.h tuiData.h tuiGeneralWin.h tuiStack.h tuiRegs.h \
tuiDisassem.h
tuiRegs.o: tui.h tuiData.h tuiLayout.h tuiWin.h
tuiSource.o: tui.h tuiData.h tuiStack.h tuiSourceWin.h tuiSource.h
tuiSourceWin.o: tui.h tuiData.h tuiStack.h tuiSourceWin.h tuiSource.h \
tuiDisassem.h
tuiStack.o: tui.h tuiData.h tuiStack.h tuiSourceWin.h
tuiWin.o: tui.h tuiData.h tuiGeneralWin.h tuiStack.h tuiSourceWin.h \
tuiDataWin.h
 
tuiInit.o: tuiInit.c
tuiInit.c: $(SOURCES)
@echo Making tuiInit.c
@rm -f init.c-tmp
@echo '/* Do not modify this file. */' >init.c-tmp
@echo '/* It is created automatically by the Makefile. */'>>init.c-tmp
@echo '#include "ansidecl.h"' >>init.c-tmp
@echo 'extern void initialize_tui_files PARAMS ((void));' >>init.c-tmp
@echo 'void initialize_tui_files PARAMS ((void)) {' >>init.c-tmp
@-( cd $(srcdir) ; grep '^_initialize_[a-z_0-9A-Z]* *(' $(SOURCES) ) 2>/dev/null \
| sed -e 's/^.*://' -e 's/^\([a-z_0-9A-Z]*\).*/ {extern void \1 PARAMS ((void)); \1 ();}/' >>init.c-tmp
@echo '}' >>init.c-tmp
@mv init.c-tmp tuiInit.c
 
clean mostlyclean:
-rm -f *.o *.a
 
distclean maintainer-clean realclean: clean
-rm -f Makefile config.log config.cache
/tuiLayout.h
0,0 → 1,15
#ifndef TUI_LAYOUT_H
#define TUI_LAYOUT_H
 
extern void showLayout PARAMS ((TuiLayoutType));
extern void tuiAddWinToLayout PARAMS ((TuiWinType));
extern void tui_vAddWinToLayout PARAMS ((va_list));
extern int tuiDefaultWinHeight
PARAMS ((TuiWinType, TuiLayoutType));
extern int tuiDefaultWinViewportHeight
PARAMS ((TuiWinType, TuiLayoutType));
extern TuiStatus tuiSetLayout
PARAMS ((TuiLayoutType, TuiRegisterDisplayType));
extern TuiStatus tui_vSetLayoutTo PARAMS ((va_list));
 
#endif /*TUI_LAYOUT_H */
/tuiCommand.h
0,0 → 1,25
#ifndef _TUI_COMMAND_H
#define _TUI_COMMAND_H
/*
** This header file supports
*/
 
 
/*****************************************
** TYPE DEFINITIONS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTION EXTERNAL DECLS **
******************************************/
 
extern unsigned int tuiDispatchCtrlChar PARAMS ((unsigned int));
extern int tuiIncrCommandCharCountBy PARAMS ((int));
extern int tuiDecrCommandCharCountBy PARAMS ((int));
extern int tuiSetCommandCharCountTo PARAMS ((int));
extern int tuiClearCommandCharCount PARAMS ((void));
 
#endif
/*_TUI_COMMAND_H*/
/tuiSourceWin.h
0,0 → 1,75
#ifndef _TUI_SOURCEWIN_H
#define _TUI_SOURCEWIN_H
/*
** This header file supports
*/
 
 
extern void tuiDisplayMainFunction PARAMS ((void));
extern void tuiUpdateSourceWindow PARAMS
((TuiWinInfoPtr, struct symtab *, Opaque, int));
extern void tuiUpdateSourceWindowAsIs PARAMS
((TuiWinInfoPtr, struct symtab *, Opaque, int));
extern void tuiUpdateSourceWindowsWithAddr PARAMS ((Opaque));
extern void tui_vUpdateSourceWindowsWithAddr PARAMS ((va_list));
extern void tuiUpdateSourceWindowsWithLine PARAMS ((struct symtab *, int));
extern void tui_vUpdateSourceWindowsWithLine PARAMS ((va_list));
extern void tuiUpdateSourceWindowsFromLocator PARAMS ((void));
extern void tuiClearSourceContent PARAMS ((TuiWinInfoPtr, int));
extern void tuiClearAllSourceWinsContent PARAMS ((int));
extern void tuiEraseSourceContent PARAMS ((TuiWinInfoPtr, int));
extern void tuiEraseAllSourceWinsContent PARAMS ((int));
extern void tuiSetSourceContentNil PARAMS ((TuiWinInfoPtr, char *));
extern void tuiShowSourceContent PARAMS ((TuiWinInfoPtr));
extern void tuiShowAllSourceWinsContent PARAMS ((void));
extern void tuiHorizontalSourceScroll PARAMS ((TuiWinInfoPtr, TuiScrollDirection, int));
extern void tuiUpdateOnEnd PARAMS ((void));
 
extern TuiStatus tuiSetExecInfoContent PARAMS ((TuiWinInfoPtr));
extern void tuiShowExecInfoContent PARAMS ((TuiWinInfoPtr));
extern void tuiShowAllExecInfosContent PARAMS ((void));
extern void tuiEraseExecInfoContent PARAMS ((TuiWinInfoPtr));
extern void tuiEraseAllExecInfosContent PARAMS ((void));
extern void tuiClearExecInfoContent PARAMS ((TuiWinInfoPtr));
extern void tuiClearAllExecInfosContent PARAMS ((void));
extern void tuiUpdateExecInfo PARAMS ((TuiWinInfoPtr));
extern void tuiUpdateAllExecInfos PARAMS ((void));
 
extern void tuiSetIsExecPointAt PARAMS ((Opaque, TuiWinInfoPtr));
extern void tuiSetHasBreakAt PARAMS ((struct breakpoint *, TuiWinInfoPtr, int));
extern void tuiAllSetHasBreakAt PARAMS ((struct breakpoint *, int));
extern void tui_vAllSetHasBreakAt PARAMS ((va_list));
extern TuiStatus tuiAllocSourceBuffer PARAMS ((TuiWinInfoPtr));
extern int tuiLineIsDisplayed PARAMS ((Opaque, TuiWinInfoPtr, int));
 
 
/*
** Constant definitions
*/
#define SCROLL_THRESHOLD 2 /* threshold for lazy scroll */
 
 
/*
** Macros
*/
#define m_tuiSetBreakAt(bp, winInfo) tuiSetHasBreakAt((bp, winInfo, TRUE)
#define m_tuiClearBreakAt(bp, winInfo) tuiSetHasBreakAt(bp, winInfo, FALSE)
 
#define m_tuiAllSetBreakAt(bp) tuiAllSetHasBreakAt(bp, TRUE)
#define m_tuiAllClearBreakAt(bp) tuiAllSetHasBreakAt(bp, FALSE)
 
#define m_tuiSrcLineDisplayed(lineNo) tuiLineIsDisplayed((Opaque)(lineNo), srcWin, FALSE)
#define m_tuiSrcAddrDisplayed(addr) tuiLineIsDisplayed((Opaque)(addr), disassemWin, FALSE)
#define m_tuiSrcLineDisplayedWithinThreshold(lineNo) \
tuiLineIsDisplayed((Opaque)(lineNo), srcWin, TRUE)
#define m_tuiSrcAddrDisplayedWithinThreshold(addr) \
tuiLineIsDisplayed((Opaque)(addr), disassemWin, TRUE)
#define m_tuiLineDisplayedWithinThreshold(winInfo, lineOrAddr) \
( (winInfo == srcWin) ? \
m_tuiSrcLineDisplayedWithinThreshold(lineOrAddr) : \
m_tuiSrcAddrDisplayedWithinThreshold(lineOrAddr) )
 
 
 
#endif
/*_TUI_SOURCEWIN_H */
/tui.h
0,0 → 1,129
/* External/Public TUI Header File */
 
#ifndef TUI_H
#define TUI_H
#include <curses.h>
 
#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif
 
#include "ansidecl.h"
 
#if defined(reg)
#undef reg
#endif
#if defined(chtype)
#undef chtype
#endif
 
/* Opaque data type */
typedef char *Opaque;
typedef
Opaque (*OpaqueFuncPtr) PARAMS ((va_list));
typedef char **OpaqueList;
typedef OpaqueList OpaquePtr;
 
/* Generic function pointer */
typedef void (*TuiVoidFuncPtr) PARAMS ((va_list));
typedef int (*TuiIntFuncPtr) PARAMS ((va_list));
/*
typedef Opaque (*TuiOpaqueFuncPtr) PARAMS ((va_list));
*/
typedef OpaqueFuncPtr TuiOpaqueFuncPtr;
 
extern Opaque vcatch_errors PARAMS ((OpaqueFuncPtr,...));
extern Opaque va_catch_errors PARAMS ((OpaqueFuncPtr, va_list));
 
extern void strcat_to_buf PARAMS ((char *, int, char *));
extern void strcat_to_buf_with_fmt PARAMS ((char *, int, char *,...));
 
/* Types of error returns */
typedef enum
{
TUI_SUCCESS,
TUI_FAILURE
}
TuiStatus, *TuiStatusPtr;
 
/* Types of windows */
typedef enum
{
SRC_WIN = 0,
DISASSEM_WIN,
DATA_WIN,
CMD_WIN,
/* This must ALWAYS be AFTER the major windows last */
MAX_MAJOR_WINDOWS,
/* auxillary windows */
LOCATOR_WIN,
EXEC_INFO_WIN,
DATA_ITEM_WIN,
/* This must ALWAYS be next to last */
MAX_WINDOWS,
UNDEFINED_WIN /* LAST */
}
TuiWinType, *TuiWinTypePtr;
 
/* This is a point definition */
typedef struct _TuiPoint
{
int x, y;
}
TuiPoint, *TuiPointPtr;
 
/* Generic window information */
typedef struct _TuiGenWinInfo
{
WINDOW *handle; /* window handle */
TuiWinType type; /* type of window */
int width; /* window width */
int height; /* window height */
TuiPoint origin; /* origin of window */
OpaquePtr content; /* content of window */
int contentSize; /* Size of content (# of elements) */
int contentInUse; /* Can it be used, or is it already used? */
int viewportHeight; /* viewport height */
int lastVisibleLine; /* index of last visible line */
int isVisible; /* whether the window is visible or not */
}
TuiGenWinInfo, *TuiGenWinInfoPtr;
 
/* GENERAL TUI FUNCTIONS */
/* tui.c */
extern void tuiInit PARAMS ((char *argv0));
extern void tuiInitWindows PARAMS ((void));
extern void tuiResetScreen PARAMS ((void));
extern void tuiCleanUp PARAMS ((void));
extern void tuiError PARAMS ((char *, int));
extern void tui_vError PARAMS ((va_list));
extern void tuiFree PARAMS ((char *));
extern Opaque tuiDo PARAMS ((TuiOpaqueFuncPtr,...));
extern Opaque tuiDoAndReturnToTop PARAMS ((TuiOpaqueFuncPtr,...));
extern Opaque tuiGetLowDisassemblyAddress PARAMS ((Opaque, Opaque));
extern Opaque tui_vGetLowDisassemblyAddress PARAMS ((va_list));
extern void tui_vSelectSourceSymtab PARAMS ((va_list));
 
/* tuiDataWin.c */
extern void tui_vCheckDataValues PARAMS ((va_list));
 
/* tuiIO.c */
extern void tui_vStartNewLines PARAMS ((va_list));
 
/* tuiLayout.c */
extern void tui_vAddWinToLayout PARAMS ((va_list));
extern TuiStatus tui_vSetLayoutTo PARAMS ((va_list));
 
/* tuiSourceWin.c */
extern void tuiDisplayMainFunction PARAMS ((void));
extern void tuiUpdateAllExecInfos PARAMS ((void));
extern void tuiUpdateOnEnd PARAMS ((void));
extern void tui_vAllSetHasBreakAt PARAMS ((va_list));
extern void tui_vUpdateSourceWindowsWithAddr PARAMS ((va_list));
 
/* tuiStack.c */
extern void tui_vShowFrameInfo PARAMS ((va_list));
extern void tui_vUpdateLocatorFilename PARAMS ((va_list));
#endif /* TUI_H */
/ChangeLog
0,0 → 1,160
Tue Apr 18 15:32:15 2000 Andrew Cagney <cagney@b1.cygnus.com>
 
* Makefile.in (distclean, maintainer-clean, realclean,
mostlyclean): New targets.
 
Tue Feb 1 00:17:12 2000 Andrew Cagney <cagney@b1.cygnus.com>
 
* tui-file.c, tui-file.h, tuiDisassem.c, tuiIO.c, tuiIO.h,
tuiRegs.c: Update to reflect rename of gdb-file / GDB_FILE to
ui-file / ``struct ui_file''.
 
Mon Jan 31 18:12:43 2000 Andrew Cagney <cagney@b1.cygnus.com>
 
* tui-file.c (enum streamtype, struct tui_stream, tui_file_new,
tui_file_delete, tui_fileopen, tui_sfileopen, tui_file_isatty,
tui_file_rewind, tui_file_put, tui_file_fputs,
tui_file_get_strbuf, tui_file_adjust_strbuf, tui_file_flush,
fputs_unfiltered_hook): Move to here from ../utils.c
 
* tui-file.h, tui-file.c: New files.
 
Mon Nov 8 17:47:37 1999 Andrew Cagney <cagney@b1.cygnus.com>
 
* tuiRegs.c (_tuiRegisterFormat), tuiDisassem.c
(tuiSetDisassemContent): Replace gdb_file_init_astring with
tui_sfileopen. Replace gdb_file_get_strbuf with
tui_file_get_strbuf.
Mon Nov 8 16:54:51 1999 Andrew Cagney <cagney@b1.cygnus.com>
 
* tuiRegs.c (_tuiRegisterFormat), tuiDisassem.c
(tuiSetDisassemContent): Repace gdb_file_deallocate with
gdb_file_delete. Replace gdb_file_init_astring with tui_sfileopen.
 
Fri Sep 17 19:34:38 1999 Andrew Cagney <cagney@b1.cygnus.com>
 
* tuiSource.c: Include "source.h".
(open_source_file, find_source_lines): Delete declarations.
 
1999-01-26 Jason Molenda (jsm@bugshack.cygnus.com)
 
* tui.h: Include stdarg.h instead of varargs.h if we're on an ISO Cish
system.
 
Thu Dec 31 12:08:32 1998 David Taylor <taylor@texas.cygnus.com>
 
The following changes were made by Jim Blandy <jimb@cygnus.com>,
Edith Epstein <eepstein@cygnus.com>, Elena Zannoni
<ezannoni@cygnus.com> Stan Shebs <shebs@cygnus.com>, and David
Taylor <taylor@cygnus.com>, as part of the project to merge in
changes originally made by HP; HP did not create ChangeLog
entries.
 
* Makefile.in: New file; we're merging HP's changes into GDB, and
we've moved the TUI files into a subdirectory, so we need a new
Makefile.
 
* tui.c:
#include <term.h>, if we have it, to get declarations for
the termcap functions on Solaris.
(tgoto): Add external K&R declaration for this; Solaris doesn't
bother to actually declare it in their header files.
(_tuiReset): Ignore the #definition of TIOCGETC if USG is defined;
we'd rather use the USG mechanisms than the Berkeley mechanisms
(TIOCGETC is one of the Berkeley terminal control ioctls).
Apologies if this causes trouble later; this should all be handled
by autoconf...
(strcat_to_buf, strcat_to_buf_with_fmt): New functions, moved here
from ../utils.h.
(tuiFree): replace safe_free with free.
(strcat_to_buf): new function, copied from utils.c.
(tuiInit): Add ignored `argv0' argument, to match the type that
init_ui_hook expects; updated declaration. Call the
initialize_tui_files function constructed above. Initialize
flush_hook to NULL.
(tuiInitWindows): Call tuiSetLocatorContent, to get the first
element of the locator window's content allocated. This seems
wrong, because it must have been initialized somehow in HP's
sources, and we should do it the same way now. But we do get
further before it segfaults. [Postscript: HP didn't bother to
initialize it; they compile
(va_catch_errors, vcatch_errors): Functions moved here from
../utils.c in HP's sources. They're not used anywhere else.
(xdb_style): Delete this variable, and remove all references to
it. It's always true.
(tuiInit, _tui_vDo): References removed.
 
* tui.h: Add prototypes.
Don't #include "gendefs.h"; it's only used in the TUI.
Integrate its contents into this file:
#include <ansidecl.h> here.
(Opaque, OpaqueFuncPtr): Typedefs moved to here.
* tuiCommand.c: #include "defs.h", so we get the appropriate
definition of GDB_FILE.
 
* tuiData.c
(freeWindow): replace safe_free with free.
(tui_version): don't define it here; it's defined in main.c now.
 
* tuiDisassem.c
(tuiSetDisassemContent): Call strcat_address_numeric instead of
strcat_address. Simplify the control structure. Use predefined
GDB function to print asm inst address. Use GDB_FILE to collect
output into buffers.
 
* tuiIO.c
(tgoto): Add external K&R declaration for this here too.
(tuiGetc, tuiTermSetup, tuiTermUnsetup): Same.
(tuiPuts_unfiltered): change FILE to GDB_FILE.
(tui_tputs): fix prototype for 3rd argument.
 
* tuiIO.h (tuiPuts_unfiltered): change declaration.
* tuiLayout.c
(_tuiSetLayoutTo): for displaying registers, hook up the HP code
that decides which registers to display (i.e. single precision
float, double precision float, general, special). Previously,
only handled TUI_GENERAL_REGS. Now that the code is hooked up,
compiling with -z poses a problem. When the first layout command
is 'layout regs', dataWin->detail is a NULL pointer, and gdb
core dumps.
 
* tuiLayout.c (_tuiSetLayoutTo): replace safe_free with free.
 
* tuiRegs.c #include "defs.h" earlier, to avoid problems in
<stdarg.h>. No idea exactly what's conflicting with what, but the
errors went away...
(_tuiRegisterFormat): Change so that function creates a GDB_FILE
object, calls pa_do_strcat_registers_info, copies the register
info into a buffer, and deallocates the GDB_FILE object. Remove
some code that is not executed. Also, call to
pa_do_strcat_registers_info has an additional parameter,
precision. This code requires some new per-target functions that
we don't want to merge. Dyke it out, with #ifdef
TUI_EXTENDED_FORMATTERS.
(_tuiSetSpecialRegsContent): this function was ifdefed out.
Hooked this up.
(_tuiSetGeneralAndSpecialRegsContent): this function was ifdefed
out. Hooked it up.
(IS_64BIT): Just define this to be zero; we're not merging in the
64-bit support.
(tuiShowRegisters): Comment out all references to the "special"
regs; we don't have a distinction between the "special" and
"non-special" regs in most of our machine descriptions. This code
is PA-specific in other ways as well, and needs to be redesigned
to be portable to other processors.
 
* tuiWin.c: #include <string.h>, to get a declaration for
strchr.
* tui.c, tuiCommand.c, tuiData.c, tuiDataWin.c, tuiDisassem.c,
tuiGeneralWin.c, tuiIO.c, tuiLayout.c, tuiRegs.c, tuiSource.c,
tuiSourceWin.c, tuiStack.c, tuiWin.c: New files (from HP). Changed
bool to int throughout. Re-indented, GNU style.
 
* tui.h, tuiCommand.h, tuiData.h, tuiDataWin.h, tuiDisassem.h,
tuiGeneralWin.h, tuiIO.h, tuiLayout.h, tuiRegs.h, tuiSource.h,
tuiSourceWin.h, tuiStack.h, tuiWin.h: new files (from HP).
Changed bool to int throughout.
/tuiDataWin.c
0,0 → 1,400
/*
** tuiDataWin.c
** This module contains functions to support the data/register window display.
*/
 
 
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiRegs.h"
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
 
 
/*
** tuiFirstDataItemDisplayed()
** Answer the index first element displayed.
** If none are displayed, then return (-1).
*/
int
#ifdef __STDC__
tuiFirstDataItemDisplayed (void)
#else
tuiFirstDataItemDisplayed ()
#endif
{
int elementNo = (-1);
int i;
 
for (i = 0; (i < dataWin->generic.contentSize && elementNo < 0); i++)
{
TuiGenWinInfoPtr dataItemWin;
 
dataItemWin = &((TuiWinContent)
dataWin->generic.content)[i]->whichElement.dataWindow;
if (dataItemWin->handle != (WINDOW *) NULL && dataItemWin->isVisible)
elementNo = i;
}
 
return elementNo;
} /* tuiFirstDataItemDisplayed */
 
 
/*
** tuiFirstDataElementNoInLine()
** Answer the index of the first element in lineNo. If lineNo is
** past the data area (-1) is returned.
*/
int
#ifdef __STDC__
tuiFirstDataElementNoInLine (
int lineNo)
#else
tuiFirstDataElementNoInLine (lineNo)
int lineNo;
#endif
{
int firstElementNo = (-1);
 
/*
** First see if there is a register on lineNo, and if so, set the
** first element number
*/
if ((firstElementNo = tuiFirstRegElementNoInLine (lineNo)) == -1)
{ /*
** Looking at the general data, the 1st element on lineNo
*/
}
 
return firstElementNo;
} /* tuiFirstDataElementNoInLine */
 
 
/*
** tuiDeleteDataContentWindows()
** Function to delete all the item windows in the data window.
** This is usually done when the data window is scrolled.
*/
void
#ifdef __STDC__
tuiDeleteDataContentWindows (void)
#else
tuiDeleteDataContentWindows ()
#endif
{
int i;
TuiGenWinInfoPtr dataItemWinPtr;
 
for (i = 0; (i < dataWin->generic.contentSize); i++)
{
dataItemWinPtr = &((TuiWinContent)
dataWin->generic.content)[i]->whichElement.dataWindow;
tuiDelwin (dataItemWinPtr->handle);
dataItemWinPtr->handle = (WINDOW *) NULL;
dataItemWinPtr->isVisible = FALSE;
}
 
return;
} /* tuiDeleteDataContentWindows */
 
 
void
#ifdef __STDC__
tuiEraseDataContent (
char *prompt)
#else
tuiEraseDataContent (prompt)
char *prompt;
#endif
{
werase (dataWin->generic.handle);
checkAndDisplayHighlightIfNeeded (dataWin);
if (prompt != (char *) NULL)
{
int halfWidth = (dataWin->generic.width - 2) / 2;
int xPos;
 
if (strlen (prompt) >= halfWidth)
xPos = 1;
else
xPos = halfWidth - strlen (prompt);
mvwaddstr (dataWin->generic.handle,
(dataWin->generic.height / 2),
xPos,
prompt);
}
wrefresh (dataWin->generic.handle);
 
return;
} /* tuiEraseDataContent */
 
 
/*
** tuiDisplayAllData().
** This function displays the data that is in the data window's
** content. It does not set the content.
*/
void
#ifdef __STDC__
tuiDisplayAllData (void)
#else
tuiDisplayAllData ()
#endif
{
if (dataWin->generic.contentSize <= 0)
tuiEraseDataContent (NO_DATA_STRING);
else
{
tuiEraseDataContent ((char *) NULL);
tuiDeleteDataContentWindows ();
checkAndDisplayHighlightIfNeeded (dataWin);
tuiDisplayRegistersFrom (0);
/*
** Then display the other data
*/
if (dataWin->detail.dataDisplayInfo.dataContent !=
(TuiWinContent) NULL &&
dataWin->detail.dataDisplayInfo.dataContentCount > 0)
{
}
}
return;
} /* tuiDisplayAllData */
 
 
/*
** tuiDisplayDataFromLine()
** Function to display the data starting at line, lineNo, in the
** data window.
*/
void
#ifdef __STDC__
tuiDisplayDataFromLine (
int lineNo)
#else
tuiDisplayDataFromLine (lineNo)
int lineNo;
#endif
{
int _lineNo = lineNo;
 
if (lineNo < 0)
_lineNo = 0;
 
checkAndDisplayHighlightIfNeeded (dataWin);
 
/* there is no general data, force regs to display (if there are any) */
if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0)
tuiDisplayRegistersFromLine (_lineNo, TRUE);
else
{
int elementNo, startLineNo;
int regsLastLine = tuiLastRegsLineNo ();
 
 
/* display regs if we can */
if (tuiDisplayRegistersFromLine (_lineNo, FALSE) < 0)
{ /*
** _lineNo is past the regs display, so calc where the
** start data element is
*/
if (regsLastLine < _lineNo)
{ /* figure out how many lines each element is to obtain
the start elementNo */
}
}
else
{ /*
** calculate the starting element of the data display, given
** regsLastLine and how many lines each element is, up to
** _lineNo
*/
}
/* Now display the data , starting at elementNo */
}
 
return;
} /* tuiDisplayDataFromLine */
 
 
/*
** tuiDisplayDataFrom()
** Display data starting at element elementNo
*/
void
#ifdef __STDC__
tuiDisplayDataFrom (
int elementNo,
int reuseWindows)
#else
tuiDisplayDataFrom (elementNo, reuseWindows)
int elementNo;
int reuseWindows;
#endif
{
int firstLine = (-1);
 
if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
firstLine = tuiLineFromRegElementNo (elementNo);
else
{ /* calculate the firstLine from the element number */
}
 
if (firstLine >= 0)
{
tuiEraseDataContent ((char *) NULL);
if (!reuseWindows)
tuiDeleteDataContentWindows ();
tuiDisplayDataFromLine (firstLine);
}
 
return;
} /* tuiDisplayDataFrom */
 
 
/*
** tuiRefreshDataWin()
** Function to redisplay the contents of the data window.
*/
void
#ifdef __STDC__
tuiRefreshDataWin (void)
#else
tuiRefreshDataWin ()
#endif
{
tuiEraseDataContent ((char *) NULL);
if (dataWin->generic.contentSize > 0)
{
int firstElement = tuiFirstDataItemDisplayed ();
 
if (firstElement >= 0) /* re-use existing windows */
tuiDisplayDataFrom (firstElement, TRUE);
}
 
return;
} /* tuiRefreshDataWin */
 
 
/*
** tuiCheckDataValues().
** Function to check the data values and hilite any that have changed
*/
void
#ifdef __STDC__
tuiCheckDataValues (
struct frame_info *frame)
#else
tuiCheckDataValues (frame)
struct frame_info *frame;
#endif
{
tuiCheckRegisterValues (frame);
 
/* Now check any other data values that there are */
if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
{
int i;
 
for (i = 0; dataWin->detail.dataDisplayInfo.dataContentCount; i++)
{
#ifdef LATER
TuiDataElementPtr dataElementPtr;
TuiGenWinInfoPtr dataItemWinPtr;
Opaque newValue;
 
dataItemPtr = &dataWin->detail.dataDisplayInfo.
dataContent[i]->whichElement.dataWindow;
dataElementPtr = &((TuiWinContent)
dataItemWinPtr->content)[0]->whichElement.data;
if value
has changed (dataElementPtr, frame, &newValue)
{
dataElementPtr->value = newValue;
update the display with the new value, hiliting it.
}
#endif
}
}
} /* tuiCheckDataValues */
 
 
/*
** tui_vCheckDataValues().
** Function to check the data values and hilite any that have
** changed with args in a va_list
*/
void
#ifdef __STDC__
tui_vCheckDataValues (
va_list args)
#else
tui_vCheckDataValues (args)
va_list args;
#endif
{
struct frame_info *frame = va_arg (args, struct frame_info *);
 
tuiCheckDataValues (frame);
 
return;
} /* tui_vCheckDataValues */
 
 
/*
** tuiVerticalDataScroll()
** Scroll the data window vertically forward or backward.
*/
void
#ifdef __STDC__
tuiVerticalDataScroll (
TuiScrollDirection scrollDirection,
int numToScroll)
#else
tuiVerticalDataScroll (scrollDirection, numToScroll)
TuiScrollDirection scrollDirection;
int numToScroll;
#endif
{
int firstElementNo;
int firstLine = (-1);
 
firstElementNo = tuiFirstDataItemDisplayed ();
if (firstElementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
firstLine = tuiLineFromRegElementNo (firstElementNo);
else
{ /* calculate the first line from the element number which is in
** the general data content
*/
}
 
if (firstLine >= 0)
{
int lastElementNo, lastLine;
 
if (scrollDirection == FORWARD_SCROLL)
firstLine += numToScroll;
else
firstLine -= numToScroll;
tuiEraseDataContent ((char *) NULL);
tuiDeleteDataContentWindows ();
tuiDisplayDataFromLine (firstLine);
}
 
return;
} /* tuiVerticalDataScroll */
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
/tuiGeneralWin.c
0,0 → 1,469
/*
** TuiGeneralWin.c
** This module supports general window behavior
*/
 
#include <curses.h>
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiGeneralWin.h"
 
 
/*
** local support functions
*/
static void _winResize PARAMS ((void));
 
 
/***********************
** PUBLIC FUNCTIONS
***********************/
/*
** tuiRefreshWin()
** Refresh the window
*/
void
#ifdef __STDC__
tuiRefreshWin (
TuiGenWinInfoPtr winInfo)
#else
tuiRefreshWin (winInfo)
TuiGenWinInfoPtr winInfo;
#endif
{
if (winInfo->type == DATA_WIN && winInfo->contentSize > 0)
{
int i;
 
for (i = 0; (i < winInfo->contentSize); i++)
{
TuiGenWinInfoPtr dataItemWinPtr;
 
dataItemWinPtr = &((TuiWinContent)
winInfo->content)[i]->whichElement.dataWindow;
if (m_genWinPtrNotNull (dataItemWinPtr) &&
dataItemWinPtr->handle != (WINDOW *) NULL)
wrefresh (dataItemWinPtr->handle);
}
}
else if (winInfo->type == CMD_WIN)
{
/* Do nothing */
}
else
{
if (winInfo->handle != (WINDOW *) NULL)
wrefresh (winInfo->handle);
}
 
return;
} /* tuiRefreshWin */
 
 
/*
** tuiDelwin()
** Function to delete the curses window, checking for null
*/
void
#ifdef __STDC__
tuiDelwin (
WINDOW * window)
#else
tuiDelwin (window)
WINDOW *window;
#endif
{
if (window != (WINDOW *) NULL)
delwin (window);
 
return;
} /* tuiDelwin */
 
 
/*
** boxWin().
*/
void
#ifdef __STDC__
boxWin (
TuiGenWinInfoPtr winInfo,
int highlightFlag)
#else
boxWin (winInfo, highlightFlag)
TuiGenWinInfoPtr winInfo;
int highlightFlag;
#endif
{
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
{
if (highlightFlag == HILITE)
box (winInfo->handle, '|', '-');
else
{
/* wattron(winInfo->handle, A_DIM); */
box (winInfo->handle, ':', '.');
/* wattroff(winInfo->handle, A_DIM); */
}
}
 
return;
} /* boxWin */
 
 
/*
** unhighlightWin().
*/
void
#ifdef __STDC__
unhighlightWin (
TuiWinInfoPtr winInfo)
#else
unhighlightWin (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo) && winInfo->generic.handle != (WINDOW *) NULL)
{
boxWin ((TuiGenWinInfoPtr) winInfo, NO_HILITE);
wrefresh (winInfo->generic.handle);
m_setWinHighlightOff (winInfo);
}
} /* unhighlightWin */
 
 
/*
** highlightWin().
*/
void
#ifdef __STDC__
highlightWin (
TuiWinInfoPtr winInfo)
#else
highlightWin (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo) &&
winInfo->canHighlight && winInfo->generic.handle != (WINDOW *) NULL)
{
boxWin ((TuiGenWinInfoPtr) winInfo, HILITE);
wrefresh (winInfo->generic.handle);
m_setWinHighlightOn (winInfo);
}
} /* highlightWin */
 
 
/*
** checkAndDisplayHighlightIfNecessay
*/
void
#ifdef __STDC__
checkAndDisplayHighlightIfNeeded (
TuiWinInfoPtr winInfo)
#else
checkAndDisplayHighlightIfNeeded (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo) && winInfo->generic.type != CMD_WIN)
{
if (winInfo->isHighlighted)
highlightWin (winInfo);
else
unhighlightWin (winInfo);
 
}
return;
} /* checkAndDisplayHighlightIfNeeded */
 
 
/*
** makeWindow().
*/
void
#ifdef __STDC__
makeWindow (
TuiGenWinInfoPtr winInfo,
int boxIt)
#else
makeWindow (winInfo, boxIt)
TuiGenWinInfoPtr winInfo;
int boxIt;
#endif
{
WINDOW *handle;
 
handle = newwin (winInfo->height,
winInfo->width,
winInfo->origin.y,
winInfo->origin.x);
winInfo->handle = handle;
if (handle != (WINDOW *) NULL)
{
if (boxIt == BOX_WINDOW)
boxWin (winInfo, NO_HILITE);
winInfo->isVisible = TRUE;
scrollok (handle, TRUE);
tuiRefreshWin (winInfo);
 
#ifndef FOR_TEST
if ( /*!m_WinIsAuxillary(winInfo->type) && */
(winInfo->type != CMD_WIN) &&
(winInfo->content == (OpaquePtr) NULL))
{
mvwaddstr (handle, 1, 1, winName (winInfo));
tuiRefreshWin (winInfo);
}
#endif /*FOR_TEST */
}
 
return;
} /* makeWindow */
 
 
/*
** tuiClearWin().
** Clear the window of all contents without calling wclear.
*/
void
#ifdef __STDC__
tuiClearWin (
TuiGenWinInfoPtr winInfo)
#else
tuiClearWin (winInfo)
TuiGenWinInfoPtr winInfo;
#endif
{
if (m_genWinPtrNotNull (winInfo) && winInfo->handle != (WINDOW *) NULL)
{
int curRow, curCol;
 
for (curRow = 0; (curRow < winInfo->height); curRow++)
for (curCol = 0; (curCol < winInfo->width); curCol++)
mvwaddch (winInfo->handle, curRow, curCol, ' ');
 
tuiRefreshWin (winInfo);
}
 
return;
} /* tuiClearWin */
 
 
/*
** makeVisible().
** We can't really make windows visible, or invisible. So we
** have to delete the entire window when making it visible,
** and create it again when making it visible.
*/
void
#ifdef __STDC__
makeVisible (
TuiGenWinInfoPtr winInfo,
int visible)
#else
makeVisible (winInfo, visible)
TuiGenWinInfoPtr winInfo;
int visible;
#endif
{
/* Don't tear down/recreate command window */
if (winInfo->type == CMD_WIN)
return;
 
if (visible)
{
if (!winInfo->isVisible)
{
makeWindow (
winInfo,
(winInfo->type != CMD_WIN && !m_winIsAuxillary (winInfo->type)));
winInfo->isVisible = TRUE;
}
tuiRefreshWin (winInfo);
}
else if (!visible &&
winInfo->isVisible && winInfo->handle != (WINDOW *) NULL)
{
winInfo->isVisible = FALSE;
tuiClearWin (winInfo);
tuiDelwin (winInfo->handle);
winInfo->handle = (WINDOW *) NULL;
}
 
return;
} /* makeVisible */
 
 
/*
** makeAllVisible().
** Makes all windows invisible (except the command and locator windows)
*/
void
#ifdef __STDC__
makeAllVisible (
int visible)
#else
makeAllVisible (visible)
int visible;
#endif
{
int i;
 
for (i = 0; i < MAX_MAJOR_WINDOWS; i++)
{
if (m_winPtrNotNull (winList[i]) &&
((winList[i])->generic.type) != CMD_WIN)
{
if (m_winIsSourceType ((winList[i])->generic.type))
makeVisible ((winList[i])->detail.sourceInfo.executionInfo,
visible);
makeVisible ((TuiGenWinInfoPtr) winList[i], visible);
}
}
 
return;
} /* makeAllVisible */
 
 
/*
** scrollWinForward
*/
void
#ifdef __STDC__
scrollWinForward (
TuiGenWinInfoPtr winInfo,
int numLines)
#else
scrollWinForward (winInfo, numLines)
TuiGenWinInfoPtr winInfo;
int numLines;
#endif
{
if (winInfo->content != (OpaquePtr) NULL &&
winInfo->lastVisibleLine < winInfo->contentSize - 1)
{
int i, firstLine, newLastLine;
 
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
if (winInfo->lastVisibleLine + numLines > winInfo->contentSize)
newLastLine = winInfo->contentSize - 1;
else
newLastLine = winInfo->lastVisibleLine + numLines - 1;
 
for (i = (newLastLine - winInfo->viewportHeight);
(i <= newLastLine); i++)
{
TuiWinElementPtr line;
int lineHeight;
 
line = (TuiWinElementPtr) winInfo->content[i];
if (line->highlight)
wstandout (winInfo->handle);
mvwaddstr (winInfo->handle,
i - (newLastLine - winInfo->viewportHeight),
1,
displayableWinContentOf (winInfo, line));
if (line->highlight)
wstandend (winInfo->handle);
lineHeight = winElementHeight (winInfo, line);
newLastLine += (lineHeight - 1);
}
winInfo->lastVisibleLine = newLastLine;
}
 
return;
} /* scrollWinForward */
 
 
/*
** scrollWinBackward
*/
void
#ifdef __STDC__
scrollWinBackward (
TuiGenWinInfoPtr winInfo,
int numLines)
#else
scrollWinBackward (winInfo, numLines)
TuiGenWinInfoPtr winInfo;
int numLines;
#endif
{
if (winInfo->content != (OpaquePtr) NULL &&
(winInfo->lastVisibleLine - winInfo->viewportHeight) > 0)
{
int i, newLastLine, firstLine;
 
firstLine = winInfo->lastVisibleLine - winInfo->viewportHeight + 1;
if ((firstLine - numLines) < 0)
newLastLine = winInfo->viewportHeight - 1;
else
newLastLine = winInfo->lastVisibleLine - numLines + 1;
 
for (i = newLastLine - winInfo->viewportHeight; (i <= newLastLine); i++)
{
TuiWinElementPtr line;
int lineHeight;
 
line = (TuiWinElementPtr) winInfo->content[i];
if (line->highlight)
wstandout (winInfo->handle);
mvwaddstr (winInfo->handle,
i - (newLastLine - winInfo->viewportHeight),
1,
displayableWinContentOf (winInfo, line));
if (line->highlight)
wstandend (winInfo->handle);
lineHeight = winElementHeight (winInfo, line);
newLastLine += (lineHeight - 1);
}
winInfo->lastVisibleLine = newLastLine;
}
 
return;
} /* scrollWinBackward */
 
 
/*
** refreshAll().
** Function to refresh all the windows currently displayed
*/
void
#ifdef __STDC__
refreshAll (
TuiWinInfoPtr * list)
#else
refreshAll (list)
TuiWinInfoPtr *list;
#endif
{
TuiWinType type;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
{
if (list[type]->generic.isVisible)
{
if (type == SRC_WIN || type == DISASSEM_WIN)
{
touchwin (list[type]->detail.sourceInfo.executionInfo->handle);
tuiRefreshWin (list[type]->detail.sourceInfo.executionInfo);
}
touchwin (list[type]->generic.handle);
tuiRefreshWin (&list[type]->generic);
}
}
if (locator->isVisible)
{
touchwin (locator->handle);
tuiRefreshWin (locator);
}
 
return;
} /* refreshAll */
 
 
/*********************************
** Local Static Functions
*********************************/
/tuiDataWin.h
0,0 → 1,30
#ifndef _TUI_DATAWIN_H
#define _TUI_DATAWIN_H
/*
** This header file supports the display of registers/data in the data window.
*/
 
 
/*****************************************
** TYPE DEFINITIONS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTION EXTERNAL DECLS **
******************************************/
extern void tuiEraseDataContent PARAMS ((char *));
extern void tuiDisplayAllData PARAMS ((void));
extern void tuiCheckDataValues PARAMS ((struct frame_info *));
extern void tui_vCheckDataValues PARAMS ((va_list));
extern void tuiDisplayDataFromLine PARAMS ((int));
extern int tuiFirstDataItemDisplayed PARAMS ((void));
extern int tuiFirstDataElementNoInLine PARAMS ((int));
extern void tuiDeleteDataContentWindows PARAMS ((void));
extern void tuiRefreshDataWin PARAMS ((void));
extern void tuiDisplayDataFrom PARAMS ((int, int));
extern void tuiVerticalDataScroll PARAMS ((TuiScrollDirection, int));
 
#endif
/*_TUI_DATAWIN_H*/
/tui-file.c
0,0 → 1,299
/* UI_FILE - a generic STDIO like output stream.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
 
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 "ui-file.h"
#include "tui/tui-file.h"
 
#include <string.h>
 
/* Called instead of fputs for all TUI_FILE output. */
 
void (*fputs_unfiltered_hook) (const char *linebuffer,
struct ui_file * stream);
 
/* A ``struct ui_file'' that is compatible with all the legacy
code. */
 
/* new */
enum streamtype
{
afile,
astring
};
 
/* new */
struct tui_stream
{
int *ts_magic;
enum streamtype ts_streamtype;
FILE *ts_filestream;
char *ts_strbuf;
int ts_buflen;
};
 
static ui_file_flush_ftype tui_file_flush;
extern ui_file_fputs_ftype tui_file_fputs;
static ui_file_isatty_ftype tui_file_isatty;
static ui_file_rewind_ftype tui_file_rewind;
static ui_file_put_ftype tui_file_put;
static ui_file_delete_ftype tui_file_delete;
static struct ui_file *tui_file_new PARAMS ((void));
static int tui_file_magic;
 
static struct ui_file *
tui_file_new ()
{
struct tui_stream *tui = xmalloc (sizeof (struct tui_stream));
struct ui_file *file = ui_file_new ();
set_ui_file_data (file, tui, tui_file_delete);
set_ui_file_flush (file, tui_file_flush);
set_ui_file_fputs (file, tui_file_fputs);
set_ui_file_isatty (file, tui_file_isatty);
set_ui_file_rewind (file, tui_file_rewind);
set_ui_file_put (file, tui_file_put);
tui->ts_magic = &tui_file_magic;
return file;
}
 
static void
tui_file_delete (file)
struct ui_file *file;
{
struct tui_stream *tmpstream = ui_file_data (file);
if (tmpstream->ts_magic != &tui_file_magic)
internal_error ("tui_file_delete: bad magic number");
if ((tmpstream->ts_streamtype == astring) &&
(tmpstream->ts_strbuf != NULL))
{
free (tmpstream->ts_strbuf);
}
free (tmpstream);
}
 
struct ui_file *
tui_fileopen (stream)
FILE *stream;
{
struct ui_file *file = tui_file_new ();
struct tui_stream *tmpstream = ui_file_data (file);
tmpstream->ts_streamtype = afile;
tmpstream->ts_filestream = stream;
tmpstream->ts_strbuf = NULL;
tmpstream->ts_buflen = 0;
return file;
}
 
struct ui_file *
tui_sfileopen (n)
int n;
{
struct ui_file *file = tui_file_new ();
struct tui_stream *tmpstream = ui_file_data (file);
tmpstream->ts_streamtype = astring;
tmpstream->ts_filestream = NULL;
if (n > 0)
{
tmpstream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
tmpstream->ts_strbuf[0] = '\0';
}
else
/* Do not allocate the buffer now. The first time something is printed
one will be allocated by tui_file_adjust_strbuf() */
tmpstream->ts_strbuf = NULL;
tmpstream->ts_buflen = n;
return file;
}
 
static int
tui_file_isatty (file)
struct ui_file *file;
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_isatty: bad magic number");
if (stream->ts_streamtype == afile)
return (isatty (fileno (stream->ts_filestream)));
else
return 0;
}
 
static void
tui_file_rewind (file)
struct ui_file *file;
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_rewind: bad magic number");
stream->ts_strbuf[0] = '\0';
}
 
static void
tui_file_put (struct ui_file *file,
ui_file_put_method_ftype *write,
void *dest)
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_put: bad magic number");
if (stream->ts_streamtype == astring)
write (dest, stream->ts_strbuf, strlen (stream->ts_strbuf));
}
 
/* All TUI I/O sent to the *_filtered and *_unfiltered functions
eventually ends up here. The fputs_unfiltered_hook is primarily
used by GUIs to collect all output and send it to the GUI, instead
of the controlling terminal. Only output to gdb_stdout and
gdb_stderr are sent to the hook. Everything else is sent on to
fputs to allow file I/O to be handled appropriately. */
 
/* FIXME: Should be broken up and moved to a TUI specific file. */
 
void
tui_file_fputs (linebuffer, file)
const char *linebuffer;
struct ui_file *file;
{
struct tui_stream *stream = ui_file_data (file);
#if defined(TUI)
extern int tui_owns_terminal;
#endif
/* NOTE: cagney/1999-10-13: The use of fputs_unfiltered_hook is
seriously discouraged. Those wanting to hook output should
instead implement their own ui_file object and install that. See
also tui_file_flush(). */
if (fputs_unfiltered_hook
&& (file == gdb_stdout
|| file == gdb_stderr))
fputs_unfiltered_hook (linebuffer, file);
else
{
#if defined(TUI)
if (tui_version && tui_owns_terminal)
{
/* If we get here somehow while updating the TUI (from
* within a tuiDo(), then we need to temporarily
* set up the terminal for GDB output. This probably just
* happens on error output.
*/
 
if (stream->ts_streamtype == astring)
{
tui_file_adjust_strbuf (strlen (linebuffer), stream);
strcat (stream->ts_strbuf, linebuffer);
}
else
{
tuiTermUnsetup (0, (tui_version) ? cmdWin->detail.commandInfo.curch : 0);
fputs (linebuffer, stream->ts_filestream);
tuiTermSetup (0);
if (linebuffer[strlen (linebuffer) - 1] == '\n')
tuiClearCommandCharCount ();
else
tuiIncrCommandCharCountBy (strlen (linebuffer));
}
}
else
{
/* The normal case - just do a fputs() */
if (stream->ts_streamtype == astring)
{
tui_file_adjust_strbuf (strlen (linebuffer), stream);
strcat (stream->ts_strbuf, linebuffer);
}
else
fputs (linebuffer, stream->ts_filestream);
}
 
 
#else
if (stream->ts_streamtype == astring)
{
tui_file_adjust_strbuf (strlen (linebuffer), file);
strcat (stream->ts_strbuf, linebuffer);
}
else
fputs (linebuffer, stream->ts_filestream);
#endif
}
}
 
char *
tui_file_get_strbuf (struct ui_file *file)
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_get_strbuf: bad magic number");
return (stream->ts_strbuf);
}
 
/* adjust the length of the buffer by the amount necessary
to accomodate appending a string of length N to the buffer contents */
void
tui_file_adjust_strbuf (int n, struct ui_file *file)
{
struct tui_stream *stream = ui_file_data (file);
int non_null_chars;
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_adjust_strbuf: bad magic number");
 
if (stream->ts_streamtype != astring)
return;
 
if (stream->ts_strbuf)
{
/* There is already a buffer allocated */
non_null_chars = strlen (stream->ts_strbuf);
 
if (n > (stream->ts_buflen - non_null_chars - 1))
{
stream->ts_buflen = n + non_null_chars + 1;
stream->ts_strbuf = xrealloc (stream->ts_strbuf, stream->ts_buflen);
}
}
else
/* No buffer yet, so allocate one of the desired size */
stream->ts_strbuf = xmalloc ((n + 1) * sizeof (char));
}
 
static void
tui_file_flush (file)
struct ui_file *file;
{
struct tui_stream *stream = ui_file_data (file);
if (stream->ts_magic != &tui_file_magic)
internal_error ("tui_file_flush: bad magic number");
 
/* NOTE: cagney/1999-10-12: If we've been linked with code that uses
fputs_unfiltered_hook then we assume that it doesn't need to know
about flushes. Code that does need to know about flushes can
implement a proper ui_file object. */
if (fputs_unfiltered_hook)
return;
 
switch (stream->ts_streamtype)
{
case astring:
break;
case afile:
fflush (stream->ts_filestream);
break;
}
}
/tuiWin.c
0,0 → 1,1650
/*
** tuiWin.c
** This module contains procedures for handling tui window functions
** like resize, scrolling, scrolling, changing focus, etc.
**
** Author: Susan B. Macchia
*/
 
 
#include <string.h>
#include "defs.h"
#include "command.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiGeneralWin.h"
#include "tuiStack.h"
#include "tuiSourceWin.h"
#include "tuiDataWin.h"
 
/*******************************
** External Declarations
********************************/
extern void init_page_info ();
 
/*******************************
** Static Local Decls
********************************/
static void _makeVisibleWithNewHeight PARAMS ((TuiWinInfoPtr));
static void _makeInvisibleAndSetNewHeight PARAMS ((TuiWinInfoPtr, int));
static TuiStatus _tuiAdjustWinHeights PARAMS ((TuiWinInfoPtr, int));
static int _newHeightOk PARAMS ((TuiWinInfoPtr, int));
static void _tuiSetTabWidth_command PARAMS ((char *, int));
static void _tuiRefreshAll_command PARAMS ((char *, int));
static void _tuiSetWinHeight_command PARAMS ((char *, int));
static void _tuiXDBsetWinHeight_command PARAMS ((char *, int));
static void _tuiAllWindowsInfo PARAMS ((char *, int));
static void _tuiSetFocus_command PARAMS ((char *, int));
static void _tuiScrollForward_command PARAMS ((char *, int));
static void _tuiScrollBackward_command PARAMS ((char *, int));
static void _tuiScrollLeft_command PARAMS ((char *, int));
static void _tuiScrollRight_command PARAMS ((char *, int));
static void _parseScrollingArgs PARAMS ((char *, TuiWinInfoPtr *, int *));
 
 
/***************************************
** DEFINITIONS
***************************************/
#define WIN_HEIGHT_USAGE "Usage: winheight <win_name> [+ | -] <#lines>\n"
#define XDBWIN_HEIGHT_USAGE "Usage: w <#lines>\n"
#define FOCUS_USAGE "Usage: focus {<win> | next | prev}\n"
 
/***************************************
** PUBLIC FUNCTIONS
***************************************/
 
/*
** _initialize_tuiWin().
** Function to initialize gdb commands, for tui window manipulation.
*/
void
_initialize_tuiWin ()
{
if (tui_version)
{
add_com ("refresh", class_tui, _tuiRefreshAll_command,
"Refresh the terminal display.\n");
if (xdb_commands)
add_com_alias ("U", "refresh", class_tui, 0);
add_com ("tabset", class_tui, _tuiSetTabWidth_command,
"Set the width (in characters) of tab stops.\n\
Usage: tabset <n>\n");
add_com ("winheight", class_tui, _tuiSetWinHeight_command,
"Set the height of a specified window.\n\
Usage: winheight <win_name> [+ | -] <#lines>\n\
Window names are:\n\
src : the source window\n\
cmd : the command window\n\
asm : the disassembly window\n\
regs : the register display\n");
add_com_alias ("wh", "winheight", class_tui, 0);
add_info ("win", _tuiAllWindowsInfo,
"List of all displayed windows.\n");
add_com ("focus", class_tui, _tuiSetFocus_command,
"Set focus to named window or next/prev window.\n\
Usage: focus {<win> | next | prev}\n\
Valid Window names are:\n\
src : the source window\n\
asm : the disassembly window\n\
regs : the register display\n\
cmd : the command window\n");
add_com_alias ("fs", "focus", class_tui, 0);
add_com ("+", class_tui, _tuiScrollForward_command,
"Scroll window forward.\nUsage: + [win] [n]\n");
add_com ("-", class_tui, _tuiScrollBackward_command,
"Scroll window backward.\nUsage: - [win] [n]\n");
add_com ("<", class_tui, _tuiScrollLeft_command,
"Scroll window forward.\nUsage: < [win] [n]\n");
add_com (">", class_tui, _tuiScrollRight_command,
"Scroll window backward.\nUsage: > [win] [n]\n");
if (xdb_commands)
add_com ("w", class_xdb, _tuiXDBsetWinHeight_command,
"XDB compatibility command for setting the height of a command window.\n\
Usage: w <#lines>\n");
}
 
return;
} /* _intialize_tuiWin */
 
 
/*
** tuiClearWinFocusFrom
** Clear the logical focus from winInfo
*/
void
#ifdef __STDC__
tuiClearWinFocusFrom (
TuiWinInfoPtr winInfo)
#else
tuiClearWinFocusFrom (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo))
{
if (winInfo->generic.type != CMD_WIN)
unhighlightWin (winInfo);
tuiSetWinWithFocus ((TuiWinInfoPtr) NULL);
}
 
return;
} /* tuiClearWinFocusFrom */
 
 
/*
** tuiClearWinFocus().
** Clear the window that has focus.
*/
void
#ifdef __STDC__
tuiClearWinFocus (void)
#else
tuiClearWinFocus ()
#endif
{
tuiClearWinFocusFrom (tuiWinWithFocus ());
 
return;
} /* tuiClearWinFocus */
 
 
/*
** tuiSetWinFocusTo
** Set the logical focus to winInfo
*/
void
#ifdef __STDC__
tuiSetWinFocusTo (
TuiWinInfoPtr winInfo)
#else
tuiSetWinFocusTo (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo))
{
TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
 
if (m_winPtrNotNull (winWithFocus) &&
winWithFocus->generic.type != CMD_WIN)
unhighlightWin (winWithFocus);
tuiSetWinWithFocus (winInfo);
if (winInfo->generic.type != CMD_WIN)
highlightWin (winInfo);
}
 
return;
} /* tuiSetWinFocusTo */
 
 
char *
#ifdef __STDC__
tuiStrDup (
char *str)
#else
tuiStrDup (str)
char *str;
#endif
{
char *newStr = (char *) NULL;
 
if (str != (char *) NULL)
{
newStr = (char *) xmalloc (strlen (str) + 1);
strcpy (newStr, str);
}
 
return newStr;
} /* tuiStrDup */
 
 
/*
** tuiScrollForward().
*/
void
#ifdef __STDC__
tuiScrollForward (
TuiWinInfoPtr winToScroll,
int numToScroll)
#else
tuiScrollForward (winToScroll, numToScroll)
TuiWinInfoPtr winToScroll;
int numToScroll;
#endif
{
if (winToScroll != cmdWin)
{
int _numToScroll = numToScroll;
 
if (numToScroll == 0)
_numToScroll = winToScroll->generic.height - 3;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
if (winToScroll == srcWin)
tuiVerticalSourceScroll (FORWARD_SCROLL, _numToScroll);
else if (winToScroll == disassemWin)
tuiVerticalDisassemScroll (FORWARD_SCROLL, _numToScroll);
else if (winToScroll == dataWin)
tuiVerticalDataScroll (FORWARD_SCROLL, _numToScroll);
}
 
return;
} /* tuiScrollForward */
 
 
/*
** tuiScrollBackward().
*/
void
#ifdef __STDC__
tuiScrollBackward (
TuiWinInfoPtr winToScroll,
int numToScroll)
#else
tuiScrollBackward (winToScroll, numToScroll)
TuiWinInfoPtr winToScroll;
int numToScroll;
#endif
{
if (winToScroll != cmdWin)
{
int _numToScroll = numToScroll;
 
if (numToScroll == 0)
_numToScroll = winToScroll->generic.height - 3;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
if (winToScroll == srcWin)
tuiVerticalSourceScroll (BACKWARD_SCROLL, _numToScroll);
else if (winToScroll == disassemWin)
tuiVerticalDisassemScroll (BACKWARD_SCROLL, _numToScroll);
else if (winToScroll == dataWin)
tuiVerticalDataScroll (BACKWARD_SCROLL, _numToScroll);
}
return;
} /* tuiScrollBackward */
 
 
/*
** tuiScrollLeft().
*/
void
#ifdef __STDC__
tuiScrollLeft (
TuiWinInfoPtr winToScroll,
int numToScroll)
#else
tuiScrollLeft (winToScroll, numToScroll)
TuiWinInfoPtr winToScroll;
int numToScroll;
#endif
{
if (winToScroll != cmdWin)
{
int _numToScroll = numToScroll;
 
if (_numToScroll == 0)
_numToScroll = 1;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
if (winToScroll == srcWin || winToScroll == disassemWin)
tuiHorizontalSourceScroll (winToScroll, LEFT_SCROLL, _numToScroll);
}
return;
} /* tuiScrollLeft */
 
 
/*
** tuiScrollRight().
*/
void
#ifdef __STDC__
tuiScrollRight (
TuiWinInfoPtr winToScroll,
int numToScroll)
#else
tuiScrollRight (winToScroll, numToScroll)
TuiWinInfoPtr winToScroll;
int numToScroll;
#endif
{
if (winToScroll != cmdWin)
{
int _numToScroll = numToScroll;
 
if (_numToScroll == 0)
_numToScroll = 1;
/*
** If we are scrolling the source or disassembly window, do a
** "psuedo" scroll since not all of the source is in memory,
** only what is in the viewport. If winToScroll is the
** command window do nothing since the term should handle it.
*/
if (winToScroll == srcWin || winToScroll == disassemWin)
tuiHorizontalSourceScroll (winToScroll, RIGHT_SCROLL, _numToScroll);
}
return;
} /* tuiScrollRight */
 
 
/*
** tui_vScroll().
** Scroll a window. Arguments are passed through a va_list.
*/
void
#ifdef __STDC__
tui_vScroll (
va_list args)
#else
tui_vScroll (args)
va_list args;
#endif
{
TuiScrollDirection direction = va_arg (args, TuiScrollDirection);
TuiWinInfoPtr winToScroll = va_arg (args, TuiWinInfoPtr);
int numToScroll = va_arg (args, int);
 
switch (direction)
{
case FORWARD_SCROLL:
tuiScrollForward (winToScroll, numToScroll);
break;
case BACKWARD_SCROLL:
tuiScrollBackward (winToScroll, numToScroll);
break;
case LEFT_SCROLL:
tuiScrollLeft (winToScroll, numToScroll);
break;
case RIGHT_SCROLL:
tuiScrollRight (winToScroll, numToScroll);
break;
default:
break;
}
 
return;
} /* tui_vScroll */
 
 
/*
** tuiRefreshAll().
*/
void
#ifdef __STDC__
tuiRefreshAll (void)
#else
tuiRefreshAll ()
#endif
{
TuiWinType type;
 
refreshAll (winList);
for (type = SRC_WIN; type < MAX_MAJOR_WINDOWS; type++)
{
if (winList[type]->generic.isVisible)
{
switch (type)
{
case SRC_WIN:
case DISASSEM_WIN:
tuiClearWin (&winList[type]->generic);
if (winList[type]->detail.sourceInfo.hasLocator)
tuiClearLocatorDisplay ();
tuiShowSourceContent (winList[type]);
checkAndDisplayHighlightIfNeeded (winList[type]);
tuiEraseExecInfoContent (winList[type]);
tuiUpdateExecInfo (winList[type]);
break;
case DATA_WIN:
tuiRefreshDataWin ();
break;
default:
break;
}
}
}
tuiClearLocatorDisplay ();
tuiShowLocatorContent ();
 
return;
} /* tuiRefreshAll */
 
 
/*
** tuiResizeAll().
** Resize all the windows based on the the terminal size. This
** function gets called from within the readline sinwinch handler.
*/
void
#ifdef __STDC__
tuiResizeAll (void)
#else
tuiResizeAll ()
#endif
{
int heightDiff, widthDiff;
extern int screenheight, screenwidth; /* in readline */
 
widthDiff = screenwidth - termWidth ();
heightDiff = screenheight - termHeight ();
if (heightDiff || widthDiff)
{
TuiLayoutType curLayout = currentLayout ();
TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
TuiWinInfoPtr firstWin, secondWin;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
TuiWinType winType;
int i, newHeight, splitDiff, cmdSplitDiff, numWinsDisplayed = 2;
 
/* turn keypad off while we resize */
if (winWithFocus != cmdWin)
keypad (cmdWin->generic.handle, FALSE);
init_page_info ();
setTermHeightTo (screenheight);
setTermWidthTo (screenwidth);
if (curLayout == SRC_DISASSEM_COMMAND ||
curLayout == SRC_DATA_COMMAND || curLayout == DISASSEM_DATA_COMMAND)
numWinsDisplayed++;
splitDiff = heightDiff / numWinsDisplayed;
cmdSplitDiff = splitDiff;
if (heightDiff % numWinsDisplayed)
{
if (heightDiff < 0)
cmdSplitDiff--;
else
cmdSplitDiff++;
}
/* now adjust each window */
clear ();
refresh ();
switch (curLayout)
{
case SRC_COMMAND:
case DISASSEM_COMMAND:
firstWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
firstWin->generic.width += widthDiff;
locator->width += widthDiff;
/* check for invalid heights */
if (heightDiff == 0)
newHeight = firstWin->generic.height;
else if ((firstWin->generic.height + splitDiff) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
else if ((firstWin->generic.height + splitDiff) <= 0)
newHeight = MIN_WIN_HEIGHT;
else
newHeight = firstWin->generic.height + splitDiff;
 
_makeInvisibleAndSetNewHeight (firstWin, newHeight);
cmdWin->generic.origin.y = locator->origin.y + 1;
cmdWin->generic.width += widthDiff;
newHeight = screenheight - cmdWin->generic.origin.y;
_makeInvisibleAndSetNewHeight (cmdWin, newHeight);
_makeVisibleWithNewHeight (firstWin);
_makeVisibleWithNewHeight (cmdWin);
if (firstWin->generic.contentSize <= 0)
tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
break;
default:
if (curLayout == SRC_DISASSEM_COMMAND)
{
firstWin = srcWin;
firstWin->generic.width += widthDiff;
secondWin = disassemWin;
secondWin->generic.width += widthDiff;
}
else
{
firstWin = dataWin;
firstWin->generic.width += widthDiff;
secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
secondWin->generic.width += widthDiff;
}
/* Change the first window's height/width */
/* check for invalid heights */
if (heightDiff == 0)
newHeight = firstWin->generic.height;
else if ((firstWin->generic.height +
secondWin->generic.height + (splitDiff * 2)) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
newHeight = (screenheight - MIN_CMD_WIN_HEIGHT - 1) / 2;
else if ((firstWin->generic.height + splitDiff) <= 0)
newHeight = MIN_WIN_HEIGHT;
else
newHeight = firstWin->generic.height + splitDiff;
_makeInvisibleAndSetNewHeight (firstWin, newHeight);
 
if (firstWin == dataWin && widthDiff != 0)
firstWin->detail.dataDisplayInfo.regsColumnCount =
tuiCalculateRegsColumnCount (
firstWin->detail.dataDisplayInfo.regsDisplayType);
locator->width += widthDiff;
 
/* Change the second window's height/width */
/* check for invalid heights */
if (heightDiff == 0)
newHeight = secondWin->generic.height;
else if ((firstWin->generic.height +
secondWin->generic.height + (splitDiff * 2)) >=
(screenheight - MIN_CMD_WIN_HEIGHT - 1))
{
newHeight = screenheight - MIN_CMD_WIN_HEIGHT - 1;
if (newHeight % 2)
newHeight = (newHeight / 2) + 1;
else
newHeight /= 2;
}
else if ((secondWin->generic.height + splitDiff) <= 0)
newHeight = MIN_WIN_HEIGHT;
else
newHeight = secondWin->generic.height + splitDiff;
secondWin->generic.origin.y = firstWin->generic.height - 1;
_makeInvisibleAndSetNewHeight (secondWin, newHeight);
 
/* Change the command window's height/width */
cmdWin->generic.origin.y = locator->origin.y + 1;
_makeInvisibleAndSetNewHeight (
cmdWin, cmdWin->generic.height + cmdSplitDiff);
_makeVisibleWithNewHeight (firstWin);
_makeVisibleWithNewHeight (secondWin);
_makeVisibleWithNewHeight (cmdWin);
if (firstWin->generic.contentSize <= 0)
tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
if (secondWin->generic.contentSize <= 0)
tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
break;
}
/*
** Now remove all invisible windows, and their content so that they get
** created again when called for with the new size
*/
for (winType = SRC_WIN; (winType < MAX_MAJOR_WINDOWS); winType++)
{
if (winType != CMD_WIN && m_winPtrNotNull (winList[winType]) &&
!winList[winType]->generic.isVisible)
{
freeWindow (winList[winType]);
winList[winType] = (TuiWinInfoPtr) NULL;
}
}
tuiSetWinResizedTo (TRUE);
/* turn keypad back on, unless focus is in the command window */
if (winWithFocus != cmdWin)
keypad (cmdWin->generic.handle, TRUE);
}
return;
} /* tuiResizeAll */
 
 
/*
** tuiSigwinchHandler()
** SIGWINCH signal handler for the tui. This signal handler is
** always called, even when the readline package clears signals
** because it is set as the old_sigwinch() (TUI only)
*/
void
#ifdef __STDC__
tuiSigwinchHandler (
int signal)
#else
tuiSigwinchHandler (signal)
int signal;
#endif
{
/*
** Say that a resize was done so that the readline can do it
** later when appropriate.
*/
tuiSetWinResizedTo (TRUE);
 
return;
} /* tuiSigwinchHandler */
 
 
 
/*************************
** STATIC LOCAL FUNCTIONS
**************************/
 
 
/*
** _tuiScrollForward_command().
*/
static void
#ifdef __STDC__
_tuiScrollForward_command (
char *arg,
int fromTTY)
#else
_tuiScrollForward_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
int numToScroll = 1;
TuiWinInfoPtr winToScroll;
 
if (arg == (char *) NULL)
_parseScrollingArgs (arg, &winToScroll, (int *) NULL);
else
_parseScrollingArgs (arg, &winToScroll, &numToScroll);
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
FORWARD_SCROLL,
winToScroll,
numToScroll);
 
return;
} /* _tuiScrollForward_command */
 
 
/*
** _tuiScrollBackward_command().
*/
static void
#ifdef __STDC__
_tuiScrollBackward_command (
char *arg,
int fromTTY)
#else
_tuiScrollBackward_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
int numToScroll = 1;
TuiWinInfoPtr winToScroll;
 
if (arg == (char *) NULL)
_parseScrollingArgs (arg, &winToScroll, (int *) NULL);
else
_parseScrollingArgs (arg, &winToScroll, &numToScroll);
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
BACKWARD_SCROLL,
winToScroll,
numToScroll);
 
return;
} /* _tuiScrollBackward_command */
 
 
/*
** _tuiScrollLeft_command().
*/
static void
#ifdef __STDC__
_tuiScrollLeft_command (
char *arg,
int fromTTY)
#else
_tuiScrollLeft_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
int numToScroll;
TuiWinInfoPtr winToScroll;
 
_parseScrollingArgs (arg, &winToScroll, &numToScroll);
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
LEFT_SCROLL,
winToScroll,
numToScroll);
 
return;
} /* _tuiScrollLeft_command */
 
 
/*
** _tuiScrollRight_command().
*/
static void
#ifdef __STDC__
_tuiScrollRight_command (
char *arg,
int fromTTY)
#else
_tuiScrollRight_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
int numToScroll;
TuiWinInfoPtr winToScroll;
 
_parseScrollingArgs (arg, &winToScroll, &numToScroll);
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll,
RIGHT_SCROLL,
winToScroll,
numToScroll);
 
return;
} /* _tuiScrollRight_command */
 
 
/*
** _tuiSetFocus().
** Set focus to the window named by 'arg'
*/
static void
#ifdef __STDC__
_tuiSetFocus (
char *arg,
int fromTTY)
#else
_tuiSetFocus (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (arg != (char *) NULL)
{
char *bufPtr = (char *) tuiStrDup (arg);
int i;
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
 
for (i = 0; (i < strlen (bufPtr)); i++)
bufPtr[i] = toupper (arg[i]);
 
if (subsetCompare (bufPtr, "NEXT"))
winInfo = tuiNextWin (tuiWinWithFocus ());
else if (subsetCompare (bufPtr, "PREV"))
winInfo = tuiPrevWin (tuiWinWithFocus ());
else
winInfo = partialWinByName (bufPtr);
 
if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
else
{
tuiSetWinFocusTo (winInfo);
keypad (cmdWin->generic.handle, (winInfo != cmdWin));
}
 
if (dataWin->generic.isVisible)
tuiRefreshDataWin ();
tuiFree (bufPtr);
printf_filtered ("Focus set to %s window.\n",
winName ((TuiGenWinInfoPtr) tuiWinWithFocus ()));
}
else
warning ("Incorrect Number of Arguments.\n%s", FOCUS_USAGE);
 
return;
} /* _tuiSetFocus */
 
 
/*
** _tui_vSetFocus()
*/
static void
#ifdef __STDC__
_tui_vSetFocus (
va_list args)
#else
_tui_vSetFocus (args)
va_list args;
#endif
{
char *arg = va_arg (args, char *);
int fromTTY = va_arg (args, int);
 
_tuiSetFocus (arg, fromTTY);
 
return;
} /* tui_vSetFocus */
 
 
/*
** _tuiSetFocus_command()
*/
static void
#ifdef __STDC__
_tuiSetFocus_command (
char *arg,
int fromTTY)
#else
_tuiSetFocus_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vSetFocus, arg, fromTTY);
 
return;
} /* tui_SetFocus */
 
 
/*
** _tuiAllWindowsInfo().
*/
static void
#ifdef __STDC__
_tuiAllWindowsInfo (
char *arg,
int fromTTY)
#else
_tuiAllWindowsInfo (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
TuiWinType type;
TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
 
for (type = SRC_WIN; (type < MAX_MAJOR_WINDOWS); type++)
if (winList[type]->generic.isVisible)
{
if (winWithFocus == winList[type])
printf_filtered (" %s\t(%d lines) <has focus>\n",
winName (&winList[type]->generic),
winList[type]->generic.height);
else
printf_filtered (" %s\t(%d lines)\n",
winName (&winList[type]->generic),
winList[type]->generic.height);
}
 
return;
} /* _tuiAllWindowsInfo */
 
 
/*
** _tuiRefreshAll_command().
*/
static void
#ifdef __STDC__
_tuiRefreshAll_command (
char *arg,
int fromTTY)
#else
_tuiRefreshAll_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) tuiRefreshAll);
}
 
 
/*
** _tuiSetWinTabWidth_command().
** Set the height of the specified window.
*/
static void
#ifdef __STDC__
_tuiSetTabWidth_command (
char *arg,
int fromTTY)
#else
_tuiSetTabWidth_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (arg != (char *) NULL)
{
int ts;
 
ts = atoi (arg);
if (ts > 0)
tuiSetDefaultTabLen (ts);
else
warning ("Tab widths greater than 0 must be specified.\n");
}
 
return;
} /* _tuiSetTabWidth_command */
 
 
/*
** _tuiSetWinHeight().
** Set the height of the specified window.
*/
static void
#ifdef __STDC__
_tuiSetWinHeight (
char *arg,
int fromTTY)
#else
_tuiSetWinHeight (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (arg != (char *) NULL)
{
char *buf = tuiStrDup (arg);
char *bufPtr = buf;
char *wname = (char *) NULL;
int newHeight, i;
TuiWinInfoPtr winInfo;
 
wname = bufPtr;
bufPtr = strchr (bufPtr, ' ');
if (bufPtr != (char *) NULL)
{
*bufPtr = (char) 0;
 
/*
** Validate the window name
*/
for (i = 0; i < strlen (wname); i++)
wname[i] = toupper (wname[i]);
winInfo = partialWinByName (wname);
 
if (winInfo == (TuiWinInfoPtr) NULL || !winInfo->generic.isVisible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
else
{
/* Process the size */
while (*(++bufPtr) == ' ')
;
 
if (*bufPtr != (char) 0)
{
int negate = FALSE;
int fixedSize = TRUE;
int inputNo;;
 
if (*bufPtr == '+' || *bufPtr == '-')
{
if (*bufPtr == '-')
negate = TRUE;
fixedSize = FALSE;
bufPtr++;
}
inputNo = atoi (bufPtr);
if (inputNo > 0)
{
if (negate)
inputNo *= (-1);
if (fixedSize)
newHeight = inputNo;
else
newHeight = winInfo->generic.height + inputNo;
/*
** Now change the window's height, and adjust all
** other windows around it
*/
if (_tuiAdjustWinHeights (winInfo,
newHeight) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
WIN_HEIGHT_USAGE);
else
init_page_info ();
}
else
warning ("Invalid window height specified.\n%s",
WIN_HEIGHT_USAGE);
}
}
}
else
printf_filtered (WIN_HEIGHT_USAGE);
 
if (buf != (char *) NULL)
tuiFree (buf);
}
else
printf_filtered (WIN_HEIGHT_USAGE);
 
return;
} /* _tuiSetWinHeight */
 
 
/*
** _tui_vSetWinHeight().
** Set the height of the specified window, with va_list.
*/
static void
#ifdef __STDC__
_tui_vSetWinHeight (
va_list args)
#else
_tui_vSetWinHeight (args)
va_list args;
#endif
{
char *arg = va_arg (args, char *);
int fromTTY = va_arg (args, int);
 
_tuiSetWinHeight (arg, fromTTY);
 
return;
} /* _tui_vSetWinHeight */
 
 
/*
** _tuiSetWinHeight_command().
** Set the height of the specified window, with va_list.
*/
static void
#ifdef __STDC__
_tuiSetWinHeight_command (
char *arg,
int fromTTY)
#else
_tuiSetWinHeight_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vSetWinHeight, arg, fromTTY);
 
return;
} /* _tuiSetWinHeight_command */
 
 
/*
** _tuiXDBsetWinHeight().
** XDB Compatibility command for setting the window height. This will
** increase or decrease the command window by the specified amount.
*/
static void
#ifdef __STDC__
_tuiXDBsetWinHeight (
char *arg,
int fromTTY)
#else
_tuiXDBsetWinHeight (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (arg != (char *) NULL)
{
int inputNo = atoi (arg);
 
if (inputNo > 0)
{ /* Add 1 for the locator */
int newHeight = termHeight () - (inputNo + 1);
 
if (!_newHeightOk (winList[CMD_WIN], newHeight) ||
_tuiAdjustWinHeights (winList[CMD_WIN],
newHeight) == TUI_FAILURE)
warning ("Invalid window height specified.\n%s",
XDBWIN_HEIGHT_USAGE);
}
else
warning ("Invalid window height specified.\n%s",
XDBWIN_HEIGHT_USAGE);
}
else
warning ("Invalid window height specified.\n%s", XDBWIN_HEIGHT_USAGE);
 
return;
} /* _tuiXDBsetWinHeight */
 
 
/*
** _tui_vXDBsetWinHeight().
** Set the height of the specified window, with va_list.
*/
static void
#ifdef __STDC__
_tui_vXDBsetWinHeight (
va_list args)
#else
_tui_vXDBsetWinHeight (args)
va_list args;
#endif
{
char *arg = va_arg (args, char *);
int fromTTY = va_arg (args, int);
 
_tuiXDBsetWinHeight (arg, fromTTY);
 
return;
} /* _tui_vXDBsetWinHeight */
 
 
/*
** _tuiSetWinHeight_command().
** Set the height of the specified window, with va_list.
*/
static void
#ifdef __STDC__
_tuiXDBsetWinHeight_command (
char *arg,
int fromTTY)
#else
_tuiXDBsetWinHeight_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vXDBsetWinHeight, arg, fromTTY);
 
return;
} /* _tuiXDBsetWinHeight_command */
 
 
/*
** _tuiAdjustWinHeights().
** Function to adjust all window heights around the primary
*/
static TuiStatus
#ifdef __STDC__
_tuiAdjustWinHeights (
TuiWinInfoPtr primaryWinInfo,
int newHeight)
#else
_tuiAdjustWinHeights (primaryWinInfo, newHeight)
TuiWinInfoPtr primaryWinInfo;
int newHeight;
#endif
{
TuiStatus status = TUI_FAILURE;
 
if (_newHeightOk (primaryWinInfo, newHeight))
{
status = TUI_SUCCESS;
if (newHeight != primaryWinInfo->generic.height)
{
int i, diff;
TuiWinInfoPtr winInfo;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
TuiLayoutType curLayout = currentLayout ();
 
diff = (newHeight - primaryWinInfo->generic.height) * (-1);
if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
{
TuiWinInfoPtr srcWinInfo;
 
_makeInvisibleAndSetNewHeight (primaryWinInfo, newHeight);
if (primaryWinInfo->generic.type == CMD_WIN)
{
winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
srcWinInfo = winInfo;
}
else
{
winInfo = winList[CMD_WIN];
srcWinInfo = primaryWinInfo;
}
_makeInvisibleAndSetNewHeight (winInfo,
winInfo->generic.height + diff);
cmdWin->generic.origin.y = locator->origin.y + 1;
_makeVisibleWithNewHeight (winInfo);
_makeVisibleWithNewHeight (primaryWinInfo);
if (srcWinInfo->generic.contentSize <= 0)
tuiEraseSourceContent (srcWinInfo, EMPTY_SOURCE_PROMPT);
}
else
{
TuiWinInfoPtr firstWin, secondWin;
 
if (curLayout == SRC_DISASSEM_COMMAND)
{
firstWin = srcWin;
secondWin = disassemWin;
}
else
{
firstWin = dataWin;
secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
}
if (primaryWinInfo == cmdWin)
{ /*
** Split the change in height accross the 1st & 2nd windows
** adjusting them as well.
*/
int firstSplitDiff = diff / 2; /* subtract the locator */
int secondSplitDiff = firstSplitDiff;
 
if (diff % 2)
{
if (firstWin->generic.height >
secondWin->generic.height)
if (diff < 0)
firstSplitDiff--;
else
firstSplitDiff++;
else
{
if (diff < 0)
secondSplitDiff--;
else
secondSplitDiff++;
}
}
/* make sure that the minimum hieghts are honored */
while ((firstWin->generic.height + firstSplitDiff) < 3)
{
firstSplitDiff++;
secondSplitDiff--;
}
while ((secondWin->generic.height + secondSplitDiff) < 3)
{
secondSplitDiff++;
firstSplitDiff--;
}
_makeInvisibleAndSetNewHeight (
firstWin,
firstWin->generic.height + firstSplitDiff);
secondWin->generic.origin.y = firstWin->generic.height - 1;
_makeInvisibleAndSetNewHeight (
secondWin, secondWin->generic.height + secondSplitDiff);
cmdWin->generic.origin.y = locator->origin.y + 1;
_makeInvisibleAndSetNewHeight (cmdWin, newHeight);
}
else
{
if ((cmdWin->generic.height + diff) < 1)
{ /*
** If there is no way to increase the command window
** take real estate from the 1st or 2nd window.
*/
if ((cmdWin->generic.height + diff) < 1)
{
int i;
for (i = cmdWin->generic.height + diff;
(i < 1); i++)
if (primaryWinInfo == firstWin)
secondWin->generic.height--;
else
firstWin->generic.height--;
}
}
if (primaryWinInfo == firstWin)
_makeInvisibleAndSetNewHeight (firstWin, newHeight);
else
_makeInvisibleAndSetNewHeight (
firstWin,
firstWin->generic.height);
secondWin->generic.origin.y = firstWin->generic.height - 1;
if (primaryWinInfo == secondWin)
_makeInvisibleAndSetNewHeight (secondWin, newHeight);
else
_makeInvisibleAndSetNewHeight (
secondWin, secondWin->generic.height);
cmdWin->generic.origin.y = locator->origin.y + 1;
if ((cmdWin->generic.height + diff) < 1)
_makeInvisibleAndSetNewHeight (cmdWin, 1);
else
_makeInvisibleAndSetNewHeight (
cmdWin, cmdWin->generic.height + diff);
}
_makeVisibleWithNewHeight (cmdWin);
_makeVisibleWithNewHeight (secondWin);
_makeVisibleWithNewHeight (firstWin);
if (firstWin->generic.contentSize <= 0)
tuiEraseSourceContent (firstWin, EMPTY_SOURCE_PROMPT);
if (secondWin->generic.contentSize <= 0)
tuiEraseSourceContent (secondWin, EMPTY_SOURCE_PROMPT);
}
}
}
 
return status;
} /* _tuiAdjustWinHeights */
 
 
/*
** _makeInvisibleAndSetNewHeight().
** Function make the target window (and auxillary windows associated
** with the targer) invisible, and set the new height and location.
*/
static void
#ifdef __STDC__
_makeInvisibleAndSetNewHeight (
TuiWinInfoPtr winInfo,
int height)
#else
_makeInvisibleAndSetNewHeight (winInfo, height)
TuiWinInfoPtr winInfo;
int height;
#endif
{
int i;
struct symtab *s;
TuiGenWinInfoPtr genWinInfo;
 
 
m_beInvisible (&winInfo->generic);
winInfo->generic.height = height;
if (height > 1)
winInfo->generic.viewportHeight = height - 1;
else
winInfo->generic.viewportHeight = height;
if (winInfo != cmdWin)
winInfo->generic.viewportHeight--;
 
/* Now deal with the auxillary windows associated with winInfo */
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
genWinInfo = winInfo->detail.sourceInfo.executionInfo;
m_beInvisible (genWinInfo);
genWinInfo->height = height;
genWinInfo->origin.y = winInfo->generic.origin.y;
if (height > 1)
genWinInfo->viewportHeight = height - 1;
else
genWinInfo->viewportHeight = height;
if (winInfo != cmdWin)
genWinInfo->viewportHeight--;
 
if (m_hasLocator (winInfo))
{
genWinInfo = locatorWinInfoPtr ();
m_beInvisible (genWinInfo);
genWinInfo->origin.y = winInfo->generic.origin.y + height;
}
break;
case DATA_WIN:
/* delete all data item windows */
for (i = 0; i < winInfo->generic.contentSize; i++)
{
genWinInfo = (TuiGenWinInfoPtr) & ((TuiWinElementPtr)
winInfo->generic.content[i])->whichElement.dataWindow;
tuiDelwin (genWinInfo->handle);
genWinInfo->handle = (WINDOW *) NULL;
}
break;
default:
break;
}
 
return;
} /* _makeInvisibleAndSetNewHeight */
 
 
/*
** _makeVisibleWithNewHeight().
** Function to make the windows with new heights visible.
** This means re-creating the windows' content since the window
** had to be destroyed to be made invisible.
*/
static void
#ifdef __STDC__
_makeVisibleWithNewHeight (
TuiWinInfoPtr winInfo)
#else
_makeVisibleWithNewHeight (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
int i;
struct symtab *s;
 
m_beVisible (&winInfo->generic);
checkAndDisplayHighlightIfNeeded (winInfo);
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
freeWinContent (winInfo->detail.sourceInfo.executionInfo);
m_beVisible (winInfo->detail.sourceInfo.executionInfo);
if (winInfo->generic.content != (OpaquePtr) NULL)
{
TuiLineOrAddress lineOrAddr;
 
if (winInfo->generic.type == SRC_WIN)
lineOrAddr.lineNo =
winInfo->detail.sourceInfo.startLineOrAddr.lineNo;
else
lineOrAddr.addr =
winInfo->detail.sourceInfo.startLineOrAddr.addr;
freeWinContent (&winInfo->generic);
tuiUpdateSourceWindow (winInfo,
current_source_symtab,
((winInfo->generic.type == SRC_WIN) ?
(Opaque) lineOrAddr.lineNo :
lineOrAddr.addr),
TRUE);
}
else if (selected_frame != (struct frame_info *) NULL)
{
Opaque line = 0;
extern int current_source_line;
 
s = find_pc_symtab (selected_frame->pc);
if (winInfo->generic.type == SRC_WIN)
line = (Opaque) current_source_line;
else
line = (Opaque) find_line_pc (s, current_source_line);
tuiUpdateSourceWindow (winInfo, s, line, TRUE);
}
if (m_hasLocator (winInfo))
{
m_beVisible (locatorWinInfoPtr ());
tuiClearLocatorDisplay ();
tuiShowLocatorContent ();
}
break;
case DATA_WIN:
tuiDisplayAllData ();
break;
case CMD_WIN:
winInfo->detail.commandInfo.curLine = 0;
winInfo->detail.commandInfo.curch = 0;
wmove (winInfo->generic.handle,
winInfo->detail.commandInfo.curLine,
winInfo->detail.commandInfo.curch);
break;
default:
break;
}
 
return;
} /* _makeVisibleWithNewHeight */
 
 
static int
#ifdef __STDC__
_newHeightOk (
TuiWinInfoPtr primaryWinInfo,
int newHeight)
#else
_newHeightOk (primaryWinInfo, newHeight)
TuiWinInfoPtr primaryWinInfo;
int newHeight;
#endif
{
int ok = (newHeight < termHeight ());
 
if (ok)
{
int diff, curHeight;
TuiLayoutType curLayout = currentLayout ();
 
diff = (newHeight - primaryWinInfo->generic.height) * (-1);
if (curLayout == SRC_COMMAND || curLayout == DISASSEM_COMMAND)
{
ok = ((primaryWinInfo->generic.type == CMD_WIN &&
newHeight <= (termHeight () - 4) &&
newHeight >= MIN_CMD_WIN_HEIGHT) ||
(primaryWinInfo->generic.type != CMD_WIN &&
newHeight <= (termHeight () - 2) &&
newHeight >= MIN_WIN_HEIGHT));
if (ok)
{ /* check the total height */
TuiWinInfoPtr winInfo;
 
if (primaryWinInfo == cmdWin)
winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[0];
else
winInfo = cmdWin;
ok = ((newHeight +
(winInfo->generic.height + diff)) <= termHeight ());
}
}
else
{
int curTotalHeight, totalHeight, minHeight;
TuiWinInfoPtr firstWin, secondWin;
 
if (curLayout == SRC_DISASSEM_COMMAND)
{
firstWin = srcWin;
secondWin = disassemWin;
}
else
{
firstWin = dataWin;
secondWin = (TuiWinInfoPtr) (sourceWindows ())->list[0];
}
/*
** We could simply add all the heights to obtain the same result
** but below is more explicit since we subtract 1 for the
** line that the first and second windows share, and add one
** for the locator.
*/
curTotalHeight =
(firstWin->generic.height + secondWin->generic.height - 1)
+ cmdWin->generic.height + 1 /*locator */ ;
if (primaryWinInfo == cmdWin)
{
/* locator included since first & second win share a line */
ok = ((firstWin->generic.height +
secondWin->generic.height + diff) >=
(MIN_WIN_HEIGHT * 2) &&
newHeight >= MIN_CMD_WIN_HEIGHT);
if (ok)
{
totalHeight = newHeight + (firstWin->generic.height +
secondWin->generic.height + diff);
minHeight = MIN_CMD_WIN_HEIGHT;
}
}
else
{
minHeight = MIN_WIN_HEIGHT;
/*
** First see if we can increase/decrease the command
** window. And make sure that the command window is
** at least 1 line
*/
ok = ((cmdWin->generic.height + diff) > 0);
if (!ok)
{ /*
** Looks like we have to increase/decrease one of
** the other windows
*/
if (primaryWinInfo == firstWin)
ok = (secondWin->generic.height + diff) >= minHeight;
else
ok = (firstWin->generic.height + diff) >= minHeight;
}
if (ok)
{
if (primaryWinInfo == firstWin)
totalHeight = newHeight +
secondWin->generic.height +
cmdWin->generic.height + diff;
else
totalHeight = newHeight +
firstWin->generic.height +
cmdWin->generic.height + diff;
}
}
/*
** Now make sure that the proposed total height doesn't exceed
** the old total height.
*/
if (ok)
ok = (newHeight >= minHeight && totalHeight <= curTotalHeight);
}
}
 
return ok;
} /* _newHeightOk */
 
 
/*
** _parseScrollingArgs().
*/
static void
#ifdef __STDC__
_parseScrollingArgs (
char *arg,
TuiWinInfoPtr * winToScroll,
int *numToScroll)
#else
_parseScrollingArgs (arg, winToScroll, numToScroll)
char *arg;
TuiWinInfoPtr *winToScroll;
int *numToScroll;
#endif
{
if (numToScroll)
*numToScroll = 0;
*winToScroll = tuiWinWithFocus ();
 
/*
** First set up the default window to scroll, in case there is no
** window name arg
*/
if (arg != (char *) NULL)
{
char *buf, *bufPtr;
 
/* process the number of lines to scroll */
buf = bufPtr = tuiStrDup (arg);
if (isdigit (*bufPtr))
{
char *numStr;
 
numStr = bufPtr;
bufPtr = strchr (bufPtr, ' ');
if (bufPtr != (char *) NULL)
{
*bufPtr = (char) 0;
if (numToScroll)
*numToScroll = atoi (numStr);
bufPtr++;
}
else if (numToScroll)
*numToScroll = atoi (numStr);
}
 
/* process the window name if one is specified */
if (bufPtr != (char *) NULL)
{
char *wname;
int i;
 
if (*bufPtr == ' ')
while (*(++bufPtr) == ' ')
;
 
if (*bufPtr != (char) 0)
wname = bufPtr;
 
/* Validate the window name */
for (i = 0; i < strlen (wname); i++)
wname[i] = toupper (wname[i]);
*winToScroll = partialWinByName (wname);
 
if (*winToScroll == (TuiWinInfoPtr) NULL ||
!(*winToScroll)->generic.isVisible)
warning ("Invalid window specified. \n\
The window name specified must be valid and visible.\n");
else if (*winToScroll == cmdWin)
*winToScroll = (TuiWinInfoPtr) (sourceWindows ())->list[0];
}
tuiFree (buf);
}
 
return;
} /* _parseScrollingArgs */
/tuiGeneralWin.h
0,0 → 1,31
#ifndef TUI_GENERAL_WIN_H
#define TUI_GENERAL_WIN_H
 
/*
** Functions
*/
extern void tuiClearWin PARAMS ((TuiGenWinInfoPtr));
extern void unhighlightWin PARAMS ((TuiWinInfoPtr));
extern void makeVisible PARAMS ((TuiGenWinInfoPtr, int));
extern void makeAllVisible PARAMS ((int));
extern void scrollWinForward PARAMS ((TuiGenWinInfoPtr, int));
extern void scrollWinBackward PARAMS ((TuiGenWinInfoPtr, int));
extern void makeWindow PARAMS ((TuiGenWinInfoPtr, int));
extern TuiWinInfoPtr copyWin PARAMS ((TuiWinInfoPtr));
extern void boxWin PARAMS ((TuiGenWinInfoPtr, int));
extern void highlightWin PARAMS ((TuiWinInfoPtr));
extern void checkAndDisplayHighlightIfNeeded PARAMS ((TuiWinInfoPtr));
extern void refreshAll PARAMS ((TuiWinInfoPtr *));
extern void tuiDelwin PARAMS ((WINDOW * window));
extern void tuiRefreshWin PARAMS ((TuiGenWinInfoPtr));
 
/*
** Macros
*/
#define m_beVisible(winInfo) makeVisible((TuiGenWinInfoPtr)(winInfo), TRUE)
#define m_beInvisible(winInfo) \
makeVisible((TuiGenWinInfoPtr)(winInfo), FALSE)
#define m_allBeVisible() makeAllVisible(TRUE)
#define m_allBeInvisible() makeAllVisible(FALSE)
 
#endif /*TUI_GENERAL_WIN_H */
/tuiRegs.c
0,0 → 1,1210
 
/*
** tuiRegs.c
** This module contains functions to support display of registers
** in the data window.
*/
 
 
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "gdbcmd.h"
#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "tuiLayout.h"
#include "tuiWin.h"
 
 
/*****************************************
** LOCAL DEFINITIONS **
******************************************/
#define DOUBLE_FLOAT_LABEL_WIDTH 6
#define DOUBLE_FLOAT_LABEL_FMT "%6.6s: "
#define DOUBLE_FLOAT_VALUE_WIDTH 30 /*min of 16 but may be in sci notation */
 
#define SINGLE_FLOAT_LABEL_WIDTH 6
#define SINGLE_FLOAT_LABEL_FMT "%6.6s: "
#define SINGLE_FLOAT_VALUE_WIDTH 25 /* min of 8 but may be in sci notation */
 
#define SINGLE_LABEL_WIDTH 10
#define SINGLE_LABEL_FMT "%10.10s: "
#define SINGLE_VALUE_WIDTH 14 /* minimum of 8 but may be in sci notation */
 
/* In the code HP gave Cygnus, this was actually a function call to a
PA-specific function, which was supposed to determine whether the
target was a 64-bit or 32-bit processor. However, the 64-bit
support wasn't complete, so we didn't merge that in, so we leave
this here as a stub. */
#define IS_64BIT 0
 
/*****************************************
** STATIC DATA **
******************************************/
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
static TuiStatus _tuiSetRegsContent
PARAMS ((int, int, struct frame_info *,
TuiRegisterDisplayType, int));
static char *_tuiRegisterName PARAMS ((int));
static TuiStatus _tuiGetRegisterRawValue
PARAMS ((int, char *, struct frame_info *));
static void _tuiSetRegisterElement
PARAMS ((int, struct frame_info *,
TuiDataElementPtr, int));
static void _tuiDisplayRegister
PARAMS ((int, TuiGenWinInfoPtr, enum precision_type));
static void _tuiRegisterFormat
PARAMS ((char *, int, int, TuiDataElementPtr,
enum precision_type));
static TuiStatus _tuiSetGeneralRegsContent PARAMS ((int));
static TuiStatus _tuiSetSpecialRegsContent PARAMS ((int));
static TuiStatus _tuiSetGeneralAndSpecialRegsContent PARAMS ((int));
static TuiStatus _tuiSetFloatRegsContent PARAMS ((TuiRegisterDisplayType, int));
static int _tuiRegValueHasChanged
PARAMS ((TuiDataElementPtr, struct frame_info *,
char *));
static void _tuiShowFloat_command PARAMS ((char *, int));
static void _tuiShowGeneral_command PARAMS ((char *, int));
static void _tuiShowSpecial_command PARAMS ((char *, int));
static void _tui_vShowRegisters_commandSupport PARAMS ((va_list));
static void _tuiToggleFloatRegs_command PARAMS ((char *, int));
static void _tuiScrollRegsForward_command PARAMS ((char *, int));
static void _tuiScrollRegsBackward_command PARAMS ((char *, int));
static void _tui_vShowRegisters_commandSupport PARAMS ((va_list));
 
 
 
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
 
/*
** tuiLastRegsLineNo()
** Answer the number of the last line in the regs display.
** If there are no registers (-1) is returned.
*/
int
#ifdef __STDC__
tuiLastRegsLineNo (void)
#else
tuiLastRegsLineNo ()
#endif
{
register int numLines = (-1);
 
if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
{
numLines = (dataWin->detail.dataDisplayInfo.regsContentCount /
dataWin->detail.dataDisplayInfo.regsColumnCount);
if (dataWin->detail.dataDisplayInfo.regsContentCount %
dataWin->detail.dataDisplayInfo.regsColumnCount)
numLines++;
}
return numLines;
} /* tuiLastRegsLineNo */
 
 
/*
** tuiLineFromRegElementNo()
** Answer the line number that the register element at elementNo is
** on. If elementNo is greater than the number of register elements
** there are, -1 is returned.
*/
int
#ifdef __STDC__
tuiLineFromRegElementNo (
int elementNo)
#else
tuiLineFromRegElementNo (elementNo)
int elementNo;
#endif
{
if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
{
int i, line = (-1);
 
i = 1;
while (line == (-1))
{
if (elementNo <
(dataWin->detail.dataDisplayInfo.regsColumnCount * i))
line = i - 1;
else
i++;
}
 
return line;
}
else
return (-1);
} /* tuiLineFromRegElementNo */
 
 
/*
** tuiFirstRegElementNoInLine()
** Answer the index of the first element in lineNo. If lineNo is
** past the register area (-1) is returned.
*/
int
#ifdef __STDC__
tuiFirstRegElementNoInLine (
int lineNo)
#else
tuiFirstRegElementNoInLine (lineNo)
int lineNo;
#endif
{
if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount)
<= dataWin->detail.dataDisplayInfo.regsContentCount)
return ((lineNo + 1) *
dataWin->detail.dataDisplayInfo.regsColumnCount) -
dataWin->detail.dataDisplayInfo.regsColumnCount;
else
return (-1);
} /* tuiFirstRegElementNoInLine */
 
 
/*
** tuiLastRegElementNoInLine()
** Answer the index of the last element in lineNo. If lineNo is past
** the register area (-1) is returned.
*/
int
#ifdef __STDC__
tuiLastRegElementNoInLine (
int lineNo)
#else
tuiLastRegElementNoInLine (lineNo)
int lineNo;
#endif
{
if ((lineNo * dataWin->detail.dataDisplayInfo.regsColumnCount) <=
dataWin->detail.dataDisplayInfo.regsContentCount)
return ((lineNo + 1) *
dataWin->detail.dataDisplayInfo.regsColumnCount) - 1;
else
return (-1);
} /* tuiLastRegElementNoInLine */
 
 
/*
** tuiCalculateRegsColumnCount
** Calculate the number of columns that should be used to display
** the registers.
*/
int
#ifdef __STDC__
tuiCalculateRegsColumnCount (
TuiRegisterDisplayType dpyType)
#else
tuiCalculateRegsColumnCount (dpyType)
TuiRegisterDisplayType dpyType;
#endif
{
int colCount, colWidth;
 
if (IS_64BIT || dpyType == TUI_DFLOAT_REGS)
colWidth = DOUBLE_FLOAT_VALUE_WIDTH + DOUBLE_FLOAT_LABEL_WIDTH;
else
{
if (dpyType == TUI_SFLOAT_REGS)
colWidth = SINGLE_FLOAT_VALUE_WIDTH + SINGLE_FLOAT_LABEL_WIDTH;
else
colWidth = SINGLE_VALUE_WIDTH + SINGLE_LABEL_WIDTH;
}
colCount = (dataWin->generic.width - 2) / colWidth;
 
return colCount;
} /* tuiCalulateRegsColumnCount */
 
 
/*
** tuiShowRegisters().
** Show the registers int the data window as indicated by dpyType.
** If there is any other registers being displayed, then they are
** cleared. What registers are displayed is dependent upon dpyType.
*/
void
#ifdef __STDC__
tuiShowRegisters (
TuiRegisterDisplayType dpyType)
#else
tuiShowRegisters (dpyType)
TuiRegisterDisplayType dpyType;
#endif
{
TuiStatus ret = TUI_FAILURE;
int refreshValuesOnly = FALSE;
 
/* Say that registers should be displayed, even if there is a problem */
dataWin->detail.dataDisplayInfo.displayRegs = TRUE;
 
if (target_has_registers)
{
refreshValuesOnly =
(dpyType == dataWin->detail.dataDisplayInfo.regsDisplayType);
switch (dpyType)
{
case TUI_GENERAL_REGS:
ret = _tuiSetGeneralRegsContent (refreshValuesOnly);
break;
case TUI_SFLOAT_REGS:
case TUI_DFLOAT_REGS:
ret = _tuiSetFloatRegsContent (dpyType, refreshValuesOnly);
break;
 
/* could ifdef out */
 
case TUI_SPECIAL_REGS:
ret = _tuiSetSpecialRegsContent (refreshValuesOnly);
break;
case TUI_GENERAL_AND_SPECIAL_REGS:
ret = _tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly);
break;
 
/* end of potential if def */
 
default:
break;
}
}
if (ret == TUI_FAILURE)
{
dataWin->detail.dataDisplayInfo.regsDisplayType = TUI_UNDEFINED_REGS;
tuiEraseDataContent (NO_REGS_STRING);
}
else
{
int i;
 
/* Clear all notation of changed values */
for (i = 0; (i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
{
TuiGenWinInfoPtr dataItemWin;
 
dataItemWin = &dataWin->detail.dataDisplayInfo.
regsContent[i]->whichElement.dataWindow;
(&((TuiWinElementPtr)
dataItemWin->content[0])->whichElement.data)->highlight = FALSE;
}
dataWin->detail.dataDisplayInfo.regsDisplayType = dpyType;
tuiDisplayAllData ();
}
(tuiLayoutDef ())->regsDisplayType = dpyType;
 
return;
} /* tuiShowRegisters */
 
 
/*
** tuiDisplayRegistersFrom().
** Function to display the registers in the content from
** 'startElementNo' until the end of the register content or the
** end of the display height. No checking for displaying past
** the end of the registers is done here.
*/
void
#ifdef __STDC__
tuiDisplayRegistersFrom (
int startElementNo)
#else
tuiDisplayRegistersFrom (startElementNo)
int startElementNo;
#endif
{
if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&
dataWin->detail.dataDisplayInfo.regsContentCount > 0)
{
register int i = startElementNo;
int j, valueCharsWide, charsWide, itemWinWidth, curY, labelWidth;
enum precision_type precision;
 
precision = (dataWin->detail.dataDisplayInfo.regsDisplayType
== TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision;
if (IS_64BIT ||
dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
{
valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
TUI_SFLOAT_REGS)
{
valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
}
else
{
valueCharsWide = SINGLE_VALUE_WIDTH;
labelWidth = SINGLE_LABEL_WIDTH;
}
}
itemWinWidth = valueCharsWide + labelWidth;
/*
** Now create each data "sub" window, and write the display into it.
*/
curY = 1;
while (i < dataWin->detail.dataDisplayInfo.regsContentCount &&
curY <= dataWin->generic.viewportHeight)
{
for (j = 0;
(j < dataWin->detail.dataDisplayInfo.regsColumnCount &&
i < dataWin->detail.dataDisplayInfo.regsContentCount); j++)
{
TuiGenWinInfoPtr dataItemWin;
TuiDataElementPtr dataElementPtr;
 
/* create the window if necessary */
dataItemWin = &dataWin->detail.dataDisplayInfo.
regsContent[i]->whichElement.dataWindow;
dataElementPtr = &((TuiWinElementPtr)
dataItemWin->content[0])->whichElement.data;
if (dataItemWin->handle == (WINDOW *) NULL)
{
dataItemWin->height = 1;
dataItemWin->width = (precision == double_precision) ?
itemWinWidth + 2 : itemWinWidth + 1;
dataItemWin->origin.x = (itemWinWidth * j) + 1;
dataItemWin->origin.y = curY;
makeWindow (dataItemWin, DONT_BOX_WINDOW);
}
/*
** Get the printable representation of the register
** and display it
*/
_tuiDisplayRegister (
dataElementPtr->itemNo, dataItemWin, precision);
i++; /* next register */
}
curY++; /* next row; */
}
}
 
return;
} /* tuiDisplayRegistersFrom */
 
 
/*
** tuiDisplayRegElementAtLine().
** Function to display the registers in the content from
** 'startElementNo' on 'startLineNo' until the end of the
** register content or the end of the display height.
** This function checks that we won't display off the end
** of the register display.
*/
void
#ifdef __STDC__
tuiDisplayRegElementAtLine (
int startElementNo,
int startLineNo)
#else
tuiDisplayRegElementAtLine (startElementNo, startLineNo)
int startElementNo;
int startLineNo;
#endif
{
if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL &&
dataWin->detail.dataDisplayInfo.regsContentCount > 0)
{
register int elementNo = startElementNo;
 
if (startElementNo != 0 && startLineNo != 0)
{
register int lastLineNo, firstLineOnLastPage;
 
lastLineNo = tuiLastRegsLineNo ();
firstLineOnLastPage = lastLineNo - (dataWin->generic.height - 2);
if (firstLineOnLastPage < 0)
firstLineOnLastPage = 0;
/*
** If there is no other data displayed except registers,
** and the elementNo causes us to scroll past the end of the
** registers, adjust what element to really start the display at.
*/
if (dataWin->detail.dataDisplayInfo.dataContentCount <= 0 &&
startLineNo > firstLineOnLastPage)
elementNo = tuiFirstRegElementNoInLine (firstLineOnLastPage);
}
tuiDisplayRegistersFrom (elementNo);
}
 
return;
} /* tuiDisplayRegElementAtLine */
 
 
 
/*
** tuiDisplayRegistersFromLine().
** Function to display the registers starting at line lineNo in
** the data window. Answers the line number that the display
** actually started from. If nothing is displayed (-1) is returned.
*/
int
#ifdef __STDC__
tuiDisplayRegistersFromLine (
int lineNo,
int forceDisplay)
#else
tuiDisplayRegistersFromLine (lineNo, forceDisplay)
int lineNo;
int forceDisplay;
#endif
{
int elementNo;
 
if (dataWin->detail.dataDisplayInfo.regsContentCount > 0)
{
int line, elementNo;
 
if (lineNo < 0)
line = 0;
else if (forceDisplay)
{ /*
** If we must display regs (forceDisplay is true), then make
** sure that we don't display off the end of the registers.
*/
if (lineNo >= tuiLastRegsLineNo ())
{
if ((line = tuiLineFromRegElementNo (
dataWin->detail.dataDisplayInfo.regsContentCount - 1)) < 0)
line = 0;
}
else
line = lineNo;
}
else
line = lineNo;
 
elementNo = tuiFirstRegElementNoInLine (line);
if (elementNo < dataWin->detail.dataDisplayInfo.regsContentCount)
tuiDisplayRegElementAtLine (elementNo, line);
else
line = (-1);
 
return line;
}
 
return (-1); /* nothing was displayed */
} /* tuiDisplayRegistersFromLine */
 
 
/*
** tuiCheckRegisterValues()
** This function check all displayed registers for changes in
** values, given a particular frame. If the values have changed,
** they are updated with the new value and highlighted.
*/
void
#ifdef __STDC__
tuiCheckRegisterValues (
struct frame_info *frame)
#else
tuiCheckRegisterValues (frame)
struct frame_info *frame;
#endif
{
if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
{
if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0 &&
dataWin->detail.dataDisplayInfo.displayRegs)
tuiShowRegisters ((tuiLayoutDef ())->regsDisplayType);
else
{
int i, j;
char rawBuf[MAX_REGISTER_RAW_SIZE];
 
for (i = 0;
(i < dataWin->detail.dataDisplayInfo.regsContentCount); i++)
{
TuiDataElementPtr dataElementPtr;
TuiGenWinInfoPtr dataItemWinPtr;
int wasHilighted;
 
dataItemWinPtr = &dataWin->detail.dataDisplayInfo.
regsContent[i]->whichElement.dataWindow;
dataElementPtr = &((TuiWinElementPtr)
dataItemWinPtr->content[0])->whichElement.data;
wasHilighted = dataElementPtr->highlight;
dataElementPtr->highlight =
_tuiRegValueHasChanged (dataElementPtr, frame, &rawBuf[0]);
if (dataElementPtr->highlight)
{
for (j = 0; j < MAX_REGISTER_RAW_SIZE; j++)
((char *) dataElementPtr->value)[j] = rawBuf[j];
_tuiDisplayRegister (
dataElementPtr->itemNo,
dataItemWinPtr,
((dataWin->detail.dataDisplayInfo.regsDisplayType ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
}
else if (wasHilighted)
{
dataElementPtr->highlight = FALSE;
_tuiDisplayRegister (
dataElementPtr->itemNo,
dataItemWinPtr,
((dataWin->detail.dataDisplayInfo.regsDisplayType ==
TUI_DFLOAT_REGS) ?
double_precision : unspecified_precision));
}
}
}
}
return;
} /* tuiCheckRegisterValues */
 
 
/*
** tuiToggleFloatRegs().
*/
void
#ifdef __STDC__
tuiToggleFloatRegs (void)
#else
tuiToggleFloatRegs ()
#endif
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
else
layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
 
if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible &&
(dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_SFLOAT_REGS ||
dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS))
tuiShowRegisters (layoutDef->floatRegsDisplayType);
 
return;
} /* tuiToggleFloatRegs */
 
 
void
_initialize_tuiRegs ()
{
if (tui_version && xdb_commands)
{
add_com ("fr", class_tui, _tuiShowFloat_command,
"Display only floating point registers\n");
add_com ("gr", class_tui, _tuiShowGeneral_command,
"Display only general registers\n");
add_com ("sr", class_tui, _tuiShowSpecial_command,
"Display only special registers\n");
add_com ("+r", class_tui, _tuiScrollRegsForward_command,
"Scroll the registers window forward\n");
add_com ("-r", class_tui, _tuiScrollRegsBackward_command,
"Scroll the register window backward\n");
add_com ("tf", class_tui, _tuiToggleFloatRegs_command,
"Toggle between single and double precision floating point registers.\n");
add_cmd (TUI_FLOAT_REGS_NAME_LOWER,
class_tui,
_tuiToggleFloatRegs_command,
"Toggle between single and double precision floating point \
registers.\n",
&togglelist);
}
 
return;
} /* _initialize_tuiRegs */
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
 
 
/*
** _tuiRegisterName().
** Return the register name.
*/
static char *
#ifdef __STDC__
_tuiRegisterName (
int regNum)
#else
_tuiRegisterName (regNum)
int regNum;
#endif
{
if (reg_names[regNum] != (char *) NULL && *(reg_names[regNum]) != (char) 0)
return reg_names[regNum];
else
return ((char *) NULL);
} /* tuiGetRegisterName */
 
 
/*
** _tuiRegisterFormat
** Function to format the register name and value into a buffer,
** suitable for printing or display
*/
static void
#ifdef __STDC__
_tuiRegisterFormat (
char *buf,
int bufLen,
int regNum,
TuiDataElementPtr dataElement,
enum precision_type precision)
#else
_tuiRegisterFormat (buf, bufLen, regNum, dataElement, precision)
char *buf;
int bufLen;
int regNum;
TuiDataElementPtr dataElement;
enum precision_type precision;
#endif
{
char tmpBuf[15];
char *fmt;
struct ui_file *stream;
 
stream = tui_sfileopen (bufLen);
pa_do_strcat_registers_info (regNum, 0, stream, precision);
strcpy (buf, tui_file_get_strbuf (stream));
ui_file_delete (stream);
 
return;
} /* _tuiRegisterFormat */
 
 
#define NUM_GENERAL_REGS 32
/*
** _tuiSetGeneralRegsContent().
** Set the content of the data window to consist of the general registers.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetGeneralRegsContent (
int refreshValuesOnly)
#else
_tuiSetGeneralRegsContent (refreshValuesOnly)
int refreshValuesOnly;
#endif
{
return (_tuiSetRegsContent (0,
NUM_GENERAL_REGS - 1,
selected_frame,
TUI_GENERAL_REGS,
refreshValuesOnly));
 
} /* _tuiSetGeneralRegsContent */
 
 
#define START_SPECIAL_REGS PCOQ_HEAD_REGNUM
/*
** _tuiSetSpecialRegsContent().
** Set the content of the data window to consist of the special registers.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetSpecialRegsContent (
int refreshValuesOnly)
#else
_tuiSetSpecialRegsContent (refreshValuesOnly)
int refreshValuesOnly;
#endif
{
TuiStatus ret = TUI_FAILURE;
int i, endRegNum;
 
endRegNum = FP0_REGNUM - 1;
#if 0
endRegNum = (-1);
for (i = START_SPECIAL_REGS; (i < ARCH_NUM_REGS && endRegNum < 0); i++)
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
endRegNum = i - 1;
#endif
ret = _tuiSetRegsContent (START_SPECIAL_REGS,
endRegNum,
selected_frame,
TUI_SPECIAL_REGS,
refreshValuesOnly);
 
return ret;
} /* _tuiSetSpecialRegsContent */
 
 
/*
** _tuiSetGeneralAndSpecialRegsContent().
** Set the content of the data window to consist of the special registers.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetGeneralAndSpecialRegsContent (
int refreshValuesOnly)
#else
_tuiSetGeneralAndSpecialRegsContent (refreshValuesOnly)
int refreshValuesOnly;
#endif
{
TuiStatus ret = TUI_FAILURE;
int i, endRegNum = (-1);
 
endRegNum = FP0_REGNUM - 1;
#if 0
endRegNum = (-1);
for (i = 0; (i < ARCH_NUM_REGS && endRegNum < 0); i++)
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
endRegNum = i - 1;
#endif
ret = _tuiSetRegsContent (
0, endRegNum, selected_frame, TUI_SPECIAL_REGS, refreshValuesOnly);
 
return ret;
} /* _tuiSetGeneralAndSpecialRegsContent */
 
/*
** _tuiSetFloatRegsContent().
** Set the content of the data window to consist of the float registers.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetFloatRegsContent (
TuiRegisterDisplayType dpyType,
int refreshValuesOnly)
#else
_tuiSetFloatRegsContent (dpyType, refreshValuesOnly)
TuiRegisterDisplayType dpyType;
int refreshValuesOnly;
#endif
{
TuiStatus ret = TUI_FAILURE;
int i, startRegNum;
 
startRegNum = FP0_REGNUM;
#if 0
startRegNum = (-1);
for (i = ARCH_NUM_REGS - 1; (i >= 0 && startRegNum < 0); i--)
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) != TYPE_CODE_FLT)
startRegNum = i + 1;
#endif
ret = _tuiSetRegsContent (startRegNum,
ARCH_NUM_REGS - 1,
selected_frame,
dpyType,
refreshValuesOnly);
 
return ret;
} /* _tuiSetFloatRegsContent */
 
 
/*
** _tuiRegValueHasChanged().
** Answer TRUE if the register's value has changed, FALSE otherwise.
** If TRUE, newValue is filled in with the new value.
*/
static int
#ifdef __STDC__
_tuiRegValueHasChanged (
TuiDataElementPtr dataElement,
struct frame_info *frame,
char *newValue)
#else
_tuiRegValueHasChanged (dataElement, frame, newValue)
TuiDataElementPtr dataElement;
struct frame_info *frame;
char *newValue;
#endif
{
int hasChanged = FALSE;
 
if (dataElement->itemNo != UNDEFINED_ITEM &&
_tuiRegisterName (dataElement->itemNo) != (char *) NULL)
{
char rawBuf[MAX_REGISTER_RAW_SIZE];
int i;
 
if (_tuiGetRegisterRawValue (
dataElement->itemNo, rawBuf, frame) == TUI_SUCCESS)
{
for (i = 0; (i < MAX_REGISTER_RAW_SIZE && !hasChanged); i++)
hasChanged = (((char *) dataElement->value)[i] != rawBuf[i]);
if (hasChanged && newValue != (char *) NULL)
{
for (i = 0; (i < MAX_REGISTER_RAW_SIZE); i++)
newValue[i] = rawBuf[i];
}
}
}
return hasChanged;
} /* _tuiRegValueHasChanged */
 
 
 
/*
** _tuiGetRegisterRawValue().
** Get the register raw value. The raw value is returned in regValue.
*/
static TuiStatus
#ifdef __STDC__
_tuiGetRegisterRawValue (
int regNum,
char *regValue,
struct frame_info *frame)
#else
_tuiGetRegisterRawValue (regNum, regValue, frame)
int regNum;
char *regValue;
struct frame_info *frame;
#endif
{
TuiStatus ret = TUI_FAILURE;
 
if (target_has_registers)
{
read_relative_register_raw_bytes_for_frame (regNum, regValue, frame);
ret = TUI_SUCCESS;
}
 
return ret;
} /* _tuiGetRegisterRawValue */
 
 
 
/*
** _tuiSetRegisterElement().
** Function to initialize a data element with the input and
** the register value.
*/
static void
#ifdef __STDC__
_tuiSetRegisterElement (
int regNum,
struct frame_info *frame,
TuiDataElementPtr dataElement,
int refreshValueOnly)
#else
_tuiSetRegisterElement (regNum, frame, dataElement, refreshValueOnly)
int regNum;
struct frame_info *frame;
TuiDataElementPtr dataElement;
int refreshValueOnly;
#endif
{
if (dataElement != (TuiDataElementPtr) NULL)
{
if (!refreshValueOnly)
{
dataElement->itemNo = regNum;
dataElement->name = _tuiRegisterName (regNum);
dataElement->highlight = FALSE;
}
if (dataElement->value == (Opaque) NULL)
dataElement->value = (Opaque) xmalloc (MAX_REGISTER_RAW_SIZE);
if (dataElement->value != (Opaque) NULL)
_tuiGetRegisterRawValue (regNum, dataElement->value, frame);
}
 
return;
} /* _tuiSetRegisterElement */
 
 
/*
** _tuiSetRegsContent().
** Set the content of the data window to consist of the registers
** numbered from startRegNum to endRegNum. Note that if
** refreshValuesOnly is TRUE, startRegNum and endRegNum are ignored.
*/
static TuiStatus
#ifdef __STDC__
_tuiSetRegsContent (
int startRegNum,
int endRegNum,
struct frame_info *frame,
TuiRegisterDisplayType dpyType,
int refreshValuesOnly)
#else
_tuiSetRegsContent (startRegNum, endRegNum, frame, dpyType, refreshValuesOnly)
int startRegNum;
int endRegNum;
struct frame_info *frame;
TuiRegisterDisplayType dpyType;
int refreshValuesOnly;
#endif
{
TuiStatus ret = TUI_FAILURE;
int numRegs = endRegNum - startRegNum + 1;
int allocatedHere = FALSE;
 
if (dataWin->detail.dataDisplayInfo.regsContentCount > 0 &&
!refreshValuesOnly)
{
freeDataContent (dataWin->detail.dataDisplayInfo.regsContent,
dataWin->detail.dataDisplayInfo.regsContentCount);
dataWin->detail.dataDisplayInfo.regsContentCount = 0;
}
if (dataWin->detail.dataDisplayInfo.regsContentCount <= 0)
{
dataWin->detail.dataDisplayInfo.regsContent =
allocContent (numRegs, DATA_WIN);
allocatedHere = TRUE;
}
 
if (dataWin->detail.dataDisplayInfo.regsContent != (TuiWinContent) NULL)
{
int i;
 
if (!refreshValuesOnly || allocatedHere)
{
dataWin->generic.content = (OpaquePtr) NULL;
dataWin->generic.contentSize = 0;
addContentElements (&dataWin->generic, numRegs);
dataWin->detail.dataDisplayInfo.regsContent =
(TuiWinContent) dataWin->generic.content;
dataWin->detail.dataDisplayInfo.regsContentCount = numRegs;
}
/*
** Now set the register names and values
*/
for (i = startRegNum; (i <= endRegNum); i++)
{
TuiGenWinInfoPtr dataItemWin;
 
dataItemWin = &dataWin->detail.dataDisplayInfo.
regsContent[i - startRegNum]->whichElement.dataWindow;
_tuiSetRegisterElement (
i,
frame,
&((TuiWinElementPtr) dataItemWin->content[0])->whichElement.data,
!allocatedHere && refreshValuesOnly);
}
dataWin->detail.dataDisplayInfo.regsColumnCount =
tuiCalculateRegsColumnCount (dpyType);
#ifdef LATER
if (dataWin->detail.dataDisplayInfo.dataContentCount > 0)
{
/* delete all the windows? */
/* realloc content equal to dataContentCount + regsContentCount */
/* append dataWin->detail.dataDisplayInfo.dataContent to content */
}
#endif
dataWin->generic.contentSize =
dataWin->detail.dataDisplayInfo.regsContentCount +
dataWin->detail.dataDisplayInfo.dataContentCount;
ret = TUI_SUCCESS;
}
 
return ret;
} /* _tuiSetRegsContent */
 
 
/*
** _tuiDisplayRegister().
** Function to display a register in a window. If hilite is TRUE,
** than the value will be displayed in reverse video
*/
static void
#ifdef __STDC__
_tuiDisplayRegister (
int regNum,
TuiGenWinInfoPtr winInfo, /* the data item window */
enum precision_type precision)
#else
_tuiDisplayRegister (regNum, winInfo, precision)
int regNum;
TuiGenWinInfoPtr winInfo; /* the data item window */
enum precision_type precision;
#endif
{
if (winInfo->handle != (WINDOW *) NULL)
{
char buf[100];
int valueCharsWide, labelWidth;
TuiDataElementPtr dataElementPtr = &((TuiWinContent)
winInfo->content)[0]->whichElement.data;
 
if (IS_64BIT ||
dataWin->detail.dataDisplayInfo.regsDisplayType == TUI_DFLOAT_REGS)
{
valueCharsWide = DOUBLE_FLOAT_VALUE_WIDTH;
labelWidth = DOUBLE_FLOAT_LABEL_WIDTH;
}
else
{
if (dataWin->detail.dataDisplayInfo.regsDisplayType ==
TUI_SFLOAT_REGS)
{
valueCharsWide = SINGLE_FLOAT_VALUE_WIDTH;
labelWidth = SINGLE_FLOAT_LABEL_WIDTH;
}
else
{
valueCharsWide = SINGLE_VALUE_WIDTH;
labelWidth = SINGLE_LABEL_WIDTH;
}
}
 
buf[0] = (char) 0;
_tuiRegisterFormat (buf,
valueCharsWide + labelWidth,
regNum,
dataElementPtr,
precision);
if (dataElementPtr->highlight)
wstandout (winInfo->handle);
 
werase (winInfo->handle);
wmove (winInfo->handle, 0, 0);
waddstr (winInfo->handle, buf);
 
if (dataElementPtr->highlight)
wstandend (winInfo->handle);
tuiRefreshWin (winInfo);
}
return;
} /* _tuiDisplayRegister */
 
 
static void
#ifdef __STDC__
_tui_vShowRegisters_commandSupport (
va_list args)
#else
_tui_vShowRegisters_commandSupport (args)
va_list args;
#endif
{
TuiRegisterDisplayType dpyType = va_arg (args, TuiRegisterDisplayType);
 
if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
{ /* Data window already displayed, show the registers */
if (dataWin->detail.dataDisplayInfo.regsDisplayType != dpyType)
tuiShowRegisters (dpyType);
}
else
(tuiLayoutDef ())->regsDisplayType = dpyType;
 
return;
} /* _tui_vShowRegisters_commandSupport */
 
 
static void
#ifdef __STDC__
_tuiShowFloat_command (
char *arg,
int fromTTY)
#else
_tuiShowFloat_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (m_winPtrIsNull (dataWin) || !dataWin->generic.isVisible ||
(dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_SFLOAT_REGS &&
dataWin->detail.dataDisplayInfo.regsDisplayType != TUI_DFLOAT_REGS))
tuiDo ((TuiOpaqueFuncPtr) _tui_vShowRegisters_commandSupport,
(tuiLayoutDef ())->floatRegsDisplayType);
 
return;
} /* _tuiShowFloat_command */
 
 
static void
#ifdef __STDC__
_tuiShowGeneral_command (
char *arg,
int fromTTY)
#else
_tuiShowGeneral_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vShowRegisters_commandSupport,
TUI_GENERAL_REGS);
 
return;
} /* _tuiShowGeneral_command */
 
 
static void
#ifdef __STDC__
_tuiShowSpecial_command (
char *arg,
int fromTTY)
#else
_tuiShowSpecial_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) _tui_vShowRegisters_commandSupport,
TUI_SPECIAL_REGS);
 
return;
} /* _tuiShowSpecial_command */
 
 
static void
#ifdef __STDC__
_tuiToggleFloatRegs_command (
char *arg,
int fromTTY)
#else
_tuiToggleFloatRegs_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
if (m_winPtrNotNull (dataWin) && dataWin->generic.isVisible)
tuiDo ((TuiOpaqueFuncPtr) tuiToggleFloatRegs);
else
{
TuiLayoutDefPtr layoutDef = tuiLayoutDef ();
 
if (layoutDef->floatRegsDisplayType == TUI_SFLOAT_REGS)
layoutDef->floatRegsDisplayType = TUI_DFLOAT_REGS;
else
layoutDef->floatRegsDisplayType = TUI_SFLOAT_REGS;
}
 
 
return;
} /* _tuiToggleFloatRegs_command */
 
 
static void
#ifdef __STDC__
_tuiScrollRegsForward_command (
char *arg,
int fromTTY)
#else
_tuiScrollRegsForward_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, FORWARD_SCROLL, dataWin, 1);
 
return;
} /* _tuiScrollRegsForward_command */
 
 
static void
#ifdef __STDC__
_tuiScrollRegsBackward_command (
char *arg,
int fromTTY)
#else
_tuiScrollRegsBackward_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
tuiDo ((TuiOpaqueFuncPtr) tui_vScroll, BACKWARD_SCROLL, dataWin, 1);
 
return;
} /* _tuiScrollRegsBackward_command */
/tuiSource.c
0,0 → 1,459
/*
** tuiSource.c
** This module contains functions for displaying source in the source window
*/
 
#include "defs.h"
#include <ctype.h>
#include "symtab.h"
#include "frame.h"
#include "breakpoint.h"
#include "source.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiStack.h"
#include "tuiSourceWin.h"
#include "tuiSource.h"
 
 
/*****************************************
** EXTERNAL DATA DECLS **
******************************************/
extern int current_source_line;
extern struct symtab *current_source_symtab;
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
 
static struct breakpoint *_hasBreak PARAMS ((char *, int));
 
 
/*****************************************
** STATIC LOCAL DATA **
******************************************/
 
 
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
 
/*********************************
** SOURCE/DISASSEM FUNCTIONS **
*********************************/
 
/*
** tuiSetSourceContent().
** Function to display source in the source window.
*/
TuiStatus
#ifdef __STDC__
tuiSetSourceContent (
struct symtab *s,
int lineNo,
int noerror)
#else
tuiSetSourceContent (s, lineNo, noerror)
struct symtab *s;
int lineNo;
int noerror;
#endif
{
TuiStatus ret = TUI_FAILURE;
 
if (s != (struct symtab *) NULL && s->filename != (char *) NULL)
{
register FILE *stream;
register int i, desc, c, lineWidth, nlines;
register char *srcLine;
 
if ((ret = tuiAllocSourceBuffer (srcWin)) == TUI_SUCCESS)
{
lineWidth = srcWin->generic.width - 1;
/*
** Take hilite (window border) into account, when calculating
** the number of lines
*/
nlines = (lineNo + (srcWin->generic.height - 2)) - lineNo;
desc = open_source_file (s);
if (desc < 0)
{
if (!noerror)
{
char *name = alloca (strlen (s->filename) + 100);
sprintf (name, "%s:%d", s->filename, lineNo);
print_sys_errmsg (name, errno);
}
ret = TUI_FAILURE;
}
else
{
if (s->line_charpos == 0)
find_source_lines (s, desc);
 
if (lineNo < 1 || lineNo > s->nlines)
{
close (desc);
printf_unfiltered (
"Line number %d out of range; %s has %d lines.\n",
lineNo, s->filename, s->nlines);
}
else if (lseek (desc, s->line_charpos[lineNo - 1], 0) < 0)
{
close (desc);
perror_with_name (s->filename);
}
else
{
register int offset, curLineNo, curLine, curLen, threshold;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
/*
** Determine the threshold for the length of the line
** and the offset to start the display
*/
offset = srcWin->detail.sourceInfo.horizontalOffset;
threshold = (lineWidth - 1) + offset;
stream = fdopen (desc, FOPEN_RT);
clearerr (stream);
curLine = 0;
curLineNo =
srcWin->detail.sourceInfo.startLineOrAddr.lineNo = lineNo;
if (offset > 0)
srcLine = (char *) xmalloc (
(threshold + 1) * sizeof (char));
while (curLine < nlines)
{
TuiWinElementPtr element = (TuiWinElementPtr)
srcWin->generic.content[curLine];
struct breakpoint *bp;
 
/* get the first character in the line */
c = fgetc (stream);
 
if (offset == 0)
srcLine = ((TuiWinElementPtr)
srcWin->generic.content[
curLine])->whichElement.source.line;
/* Init the line with the line number */
sprintf (srcLine, "%-6d", curLineNo);
curLen = strlen (srcLine);
i = curLen -
((curLen / tuiDefaultTabLen ()) * tuiDefaultTabLen ());
while (i < tuiDefaultTabLen ())
{
srcLine[curLen] = ' ';
i++;
curLen++;
}
srcLine[curLen] = (char) 0;
 
/*
** Set whether element is the execution point and
** whether there is a break point on it.
*/
element->whichElement.source.lineOrAddr.lineNo =
curLineNo;
element->whichElement.source.isExecPoint =
(strcmp (((TuiWinElementPtr)
locator->content[0])->whichElement.locator.fileName,
s->filename) == 0
&& curLineNo == ((TuiWinElementPtr)
locator->content[0])->whichElement.locator.lineNo);
bp = _hasBreak (s->filename, curLineNo);
element->whichElement.source.hasBreak =
(bp != (struct breakpoint *) NULL &&
(!element->whichElement.source.isExecPoint ||
(bp->disposition != del || bp->hit_count <= 0)));
if (c != EOF)
{
i = strlen (srcLine) - 1;
do
{
if ((c != '\n') &&
(c != '\r') && (++i < threshold))
{
if (c < 040 && c != '\t')
{
srcLine[i++] = '^';
srcLine[i] = c + 0100;
}
else if (c == 0177)
{
srcLine[i++] = '^';
srcLine[i] = '?';
}
else
{ /*
** Store the charcter in the line
** buffer. If it is a tab, then
** translate to the correct number of
** chars so we don't overwrite our
** buffer.
*/
if (c == '\t')
{
int j, maxTabLen = tuiDefaultTabLen ();
 
for (j = i - (
(i / maxTabLen) * maxTabLen);
((j < maxTabLen) &&
i < threshold);
i++, j++)
srcLine[i] = ' ';
i--;
}
else
srcLine[i] = c;
}
srcLine[i + 1] = 0;
}
else
{ /*
** if we have not reached EOL, then eat
** chars until we do
*/
while (c != EOF && c != '\n' && c != '\r')
c = fgetc (stream);
}
}
while (c != EOF && c != '\n' && c != '\r' &&
i < threshold && (c = fgetc (stream)));
}
/* Now copy the line taking the offset into account */
if (strlen (srcLine) > offset)
strcpy (((TuiWinElementPtr) srcWin->generic.content[
curLine])->whichElement.source.line,
&srcLine[offset]);
else
((TuiWinElementPtr)
srcWin->generic.content[
curLine])->whichElement.source.line[0] = (char) 0;
curLine++;
curLineNo++;
}
if (offset > 0)
tuiFree (srcLine);
fclose (stream);
srcWin->generic.contentSize = nlines;
ret = TUI_SUCCESS;
}
}
}
}
return ret;
} /* tuiSetSourceContent */
 
 
/* elz: this function sets the contents of the source window to empty
except for a line in the middle with a warning message about the
source not being available. This function is called by
tuiEraseSourceContents, which in turn is invoked when the source files
cannot be accessed */
 
void
#ifdef __STDC__
tuiSetSourceContentNil (
TuiWinInfoPtr winInfo,
char *warning_string)
#else
tuiSetSourceContentNil (winInfo, warning_string)
TuiWinInfoPtr winInfo;
char *warning_string;
#endif
{
int lineWidth;
int nLines;
int curr_line = 0;
 
lineWidth = winInfo->generic.width - 1;
nLines = winInfo->generic.height - 2;
 
/* set to empty each line in the window, except for the one
which contains the message */
while (curr_line < winInfo->generic.contentSize)
{
/* set the information related to each displayed line
to null: i.e. the line number is 0, there is no bp,
it is not where the program is stopped */
 
TuiWinElementPtr element =
(TuiWinElementPtr) winInfo->generic.content[curr_line];
element->whichElement.source.lineOrAddr.lineNo = 0;
element->whichElement.source.isExecPoint = FALSE;
element->whichElement.source.hasBreak = FALSE;
 
/* set the contents of the line to blank */
element->whichElement.source.line[0] = (char) 0;
 
/* if the current line is in the middle of the screen, then we want to
display the 'no source available' message in it.
Note: the 'weird' arithmetic with the line width and height comes from
the function tuiEraseSourceContent. We need to keep the screen and the
window's actual contents in synch */
 
if (curr_line == (nLines / 2 + 1))
{
int i;
int xpos;
int warning_length = strlen (warning_string);
char *srcLine;
 
srcLine = element->whichElement.source.line;
 
if (warning_length >= ((lineWidth - 1) / 2))
xpos = 1;
else
xpos = (lineWidth - 1) / 2 - warning_length;
 
for (i = 0; i < xpos; i++)
srcLine[i] = ' ';
 
sprintf (srcLine + i, "%s", warning_string);
 
for (i = xpos + warning_length; i < lineWidth; i++)
srcLine[i] = ' ';
 
srcLine[i] = '\n';
 
} /* end if */
 
curr_line++;
 
} /* end while */
 
} /*tuiSetSourceContentNil */
 
 
 
 
/*
** tuiShowSource().
** Function to display source in the source window. This function
** initializes the horizontal scroll to 0.
*/
void
#ifdef __STDC__
tuiShowSource (
struct symtab *s,
Opaque line,
int noerror)
#else
tuiShowSource (s, line, noerror)
struct symtab *s;
Opaque line;
int noerror;
#endif
{
srcWin->detail.sourceInfo.horizontalOffset = 0;
m_tuiShowSourceAsIs (s, line, noerror);
 
return;
} /* tuiShowSource */
 
 
/*
** tuiSourceIsDisplayed().
** Answer whether the source is currently displayed in the source window.
*/
int
#ifdef __STDC__
tuiSourceIsDisplayed (
char *fname)
#else
tuiSourceIsDisplayed (fname)
char *fname;
#endif
{
return (srcWin->generic.contentInUse &&
(strcmp (((TuiWinElementPtr) (locatorWinInfoPtr ())->
content[0])->whichElement.locator.fileName, fname) == 0));
} /* tuiSourceIsDisplayed */
 
 
/*
** tuiVerticalSourceScroll().
** Scroll the source forward or backward vertically
*/
void
#ifdef __STDC__
tuiVerticalSourceScroll (
TuiScrollDirection scrollDirection,
int numToScroll)
#else
tuiVerticalSourceScroll (scrollDirection, numToScroll)
TuiScrollDirection scrollDirection;
int numToScroll;
#endif
{
if (srcWin->generic.content != (OpaquePtr) NULL)
{
int line;
Opaque addr;
struct symtab *s;
TuiWinContent content = (TuiWinContent) srcWin->generic.content;
 
if (current_source_symtab == (struct symtab *) NULL)
s = find_pc_symtab (selected_frame->pc);
else
s = current_source_symtab;
 
if (scrollDirection == FORWARD_SCROLL)
{
line = content[0]->whichElement.source.lineOrAddr.lineNo +
numToScroll;
if (line > s->nlines)
/*line = s->nlines - winInfo->generic.contentSize + 1; */
/*elz: fix for dts 23398 */
line = content[0]->whichElement.source.lineOrAddr.lineNo;
}
else
{
line = content[0]->whichElement.source.lineOrAddr.lineNo -
numToScroll;
if (line <= 0)
line = 1;
}
tuiUpdateSourceWindowAsIs (srcWin, s, (Opaque) line, FALSE);
}
 
return;
} /* tuiVerticalSourceScroll */
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
 
/*
** _hasBreak().
** Answer whether there is a break point at the input line in
** the source file indicated
*/
static struct breakpoint *
#ifdef __STDC__
_hasBreak (
char *sourceFileName,
int lineNo)
#else
_hasBreak (sourceFileName, lineNo)
char *sourceFileName;
int lineNo;
#endif
{
struct breakpoint *bpWithBreak = (struct breakpoint *) NULL;
struct breakpoint *bp;
extern struct breakpoint *breakpoint_chain;
 
 
for (bp = breakpoint_chain;
(bp != (struct breakpoint *) NULL &&
bpWithBreak == (struct breakpoint *) NULL);
bp = bp->next)
if ((strcmp (sourceFileName, bp->source_file) == 0) &&
(lineNo == bp->line_number))
bpWithBreak = bp;
 
return bpWithBreak;
} /* _hasBreak */
/tui-file.h
0,0 → 1,34
/* UI_FILE - a generic STDIO like output stream.
Copyright (C) 1999, 2000 Free Software Foundation, Inc.
 
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. */
 
#ifndef TUI_FILE_H
#define TUI_FILE_H
 
extern struct ui_file *tui_fileopen (FILE *);
extern struct ui_file *tui_sfileopen (int);
extern char *tui_file_get_strbuf (struct ui_file *);
extern void tui_file_adjust_strbuf (int, struct ui_file *);
 
/* NOTE: cagney/1999-10-14: fputs_unfiltered_hook is deprecated. Code
wanting to control GDB's output should override the gdb_std...
files. */
extern void (*fputs_unfiltered_hook) (const char *linebuffer,
struct ui_file * stream);
#endif
/tuiWin.h
0,0 → 1,29
#ifndef _TUI_WIN_H
#define _TUI_WIN_H
/*
** This header file supports
*/
 
/*****************************************
** TYPE DEFINITIONS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTION EXTERNAL DECLS **
******************************************/
extern void tuiScrollForward PARAMS ((TuiWinInfoPtr, int));
extern void tuiScrollBackward PARAMS ((TuiWinInfoPtr, int));
extern void tuiScrollLeft PARAMS ((TuiWinInfoPtr, int));
extern void tuiScrollRight PARAMS ((TuiWinInfoPtr, int));
extern void tui_vScroll PARAMS ((va_list));
extern void tuiSetWinFocusTo PARAMS ((TuiWinInfoPtr));
extern void tuiClearWinFocusFrom PARAMS ((TuiWinInfoPtr));
extern void tuiClearWinFocus PARAMS ((void));
extern void tuiResizeAll PARAMS ((void));
extern void tuiRefreshAll PARAMS ((void));
extern void tuiSigwinchHandler PARAMS ((int));
 
#endif
/*_TUI_WIN_H*/
/tuiRegs.h
0,0 → 1,29
#ifndef _TUI_REGS_H
#define _TUI_REGS_H
/*
** This header file supports the display of registers in the data window.
*/
 
/*****************************************
** TYPE DEFINITIONS **
******************************************/
 
 
 
/*****************************************
** PUBLIC FUNCTION EXTERNAL DECLS **
******************************************/
extern void tuiCheckRegisterValues PARAMS ((struct frame_info *));
extern void tuiShowRegisters PARAMS ((TuiRegisterDisplayType));
extern void tuiDisplayRegistersFrom PARAMS ((int));
extern int tuiDisplayRegistersFromLine PARAMS ((int, int));
extern int tuiLastRegsLineNo PARAMS ((void));
extern int tuiFirstRegElementInLine PARAMS ((int));
extern int tuiLastRegElementInLine PARAMS ((int));
extern int tuiLineFromRegElementNo PARAMS ((int));
extern void tuiToggleFloatRegs PARAMS ((void));
extern int tuiCalculateRegsColumnCount PARAMS ((TuiRegisterDisplayType));
 
 
#endif
/*_TUI_REGS_H*/
/tuiSource.h
0,0 → 1,28
#ifndef _TUI_SOURCE_H
#define _TUI_SOURCE_H
/*
** This header file supports
*/
 
 
#include "defs.h"
#if 0
#include "symtab.h"
#include "breakpoint.h"
#endif
 
extern TuiStatus tuiSetSourceContent PARAMS ((struct symtab *, int, int));
extern void tuiShowSource PARAMS ((struct symtab *, Opaque, int));
extern void tuiShowSourceAsIs PARAMS ((struct symtab *, Opaque, int));
extern int tuiSourceIsDisplayed PARAMS ((char *));
extern void tuiVerticalSourceScroll PARAMS ((TuiScrollDirection, int));
 
 
/*******************
** MACROS **
*******************/
#define m_tuiShowSourceAsIs(s, line, noerror) tuiUpdateSourceWindowAsIs(srcWin, s, line, noerror)
 
 
#endif
/*_TUI_SOURCE_H*/
/tuiStack.c
0,0 → 1,554
/*
** This module contains functions for displaying the locator information in the locator window.
*/
 
#include "defs.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiStack.h"
#include "tuiSourceWin.h"
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
 
static char *_getFuncNameFromFrame PARAMS ((struct frame_info *));
static void _tuiUpdateLocation_command PARAMS ((char *, int));
 
 
 
/*****************************************
** PUBLIC FUNCTION **
******************************************/
 
/*
** tuiClearLocatorDisplay()
*/
void
#ifdef __STDC__
tuiClearLocatorDisplay (void)
#else
tuiClearLocatorDisplay ()
#endif
{
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
int i;
 
if (locator->handle != (WINDOW *) NULL)
{
/* No need to werase, since writing a line of
* blanks which we do below, is equivalent.
*/
/* werase(locator->handle); */
wmove (locator->handle, 0, 0);
wstandout (locator->handle);
for (i = 0; i < locator->width; i++)
waddch (locator->handle, ' ');
wstandend (locator->handle);
tuiRefreshWin (locator);
wmove (locator->handle, 0, 0);
locator->contentInUse = FALSE;
}
 
return;
} /* tuiClearLocatorDisplay */
 
 
/*
** tuiShowLocatorContent()
*/
void
#ifdef __STDC__
tuiShowLocatorContent (void)
#else
tuiShowLocatorContent ()
#endif
{
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);
wstandend (locator->handle);
tuiRefreshWin (locator);
wmove (locator->handle, 0, 0);
if (string != nullStr ())
tuiFree (string);
locator->contentInUse = TRUE;
}
}
 
return;
} /* tuiShowLocatorContent */
 
 
/*
** tuiSetLocatorInfo().
** Function to update the locator, with the provided arguments.
*/
void
#ifdef __STDC__
tuiSetLocatorInfo (
char *fname,
char *procname,
int lineNo,
Opaque addr,
TuiLocatorElementPtr element)
#else
tuiSetLocatorInfo (fname, procname, lineNo, addr, element)
char *fname;
char *procname;
int lineNo;
Opaque addr;
TuiLocatorElementPtr element;
#endif
{
#ifdef COMMENT
/* first free the old info */
if (element->fileName)
tuiFree (element->fileName);
if (element->procName)
tuiFree (element->procName);
 
if (fname == (char *) NULL)
element->fileName = fname;
else
element->fileName = tuiStrDup (fname);
if (procname == (char *) NULL)
element->procName = procname;
else
element->procName = tuiStrDup (procname);
#else
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);
#endif
element->lineNo = lineNo;
element->addr = (Opaque) addr;
 
return;
} /* tuiSetLocatorInfo */
 
 
/*
** tuiUpdateLocatorFilename().
** Update only the filename portion of the locator.
*/
void
#ifdef __STDC__
tuiUpdateLocatorFilename (
char *fileName)
#else
tuiUpdateLocatorFilename (fileName)
char *fileName;
#endif
{
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 */
 
 
/*
** tui_vUpdateLocatorFilename().
** Update only the filename portion of the locator with args in a va_list.
*/
void
#ifdef __STDC__
tui_vUpdateLocatorFilename (
va_list args)
#else
tui_vUpdateLocatorFilename (args)
va_list args;
#endif
{
char *fileName;
 
fileName = va_arg (args, char *);
tuiUpdateLocatorFilename (fileName);
 
return;
} /* tui_vUpdateLocatorFilename */
 
 
/*
** tuiSwitchFilename().
** Update the filename portion of the locator. Clear the other info in locator.
** (elz)
*/
void
#ifdef __STDC__
tuiSwitchFilename (
char *fileName)
#else
tuiSwitchFilename (fileName)
char *fileName;
#endif
{
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,
(Opaque) NULL,
&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
 
tuiShowLocatorContent ();
 
return;
} /* tuiSwitchFilename */
 
 
/*
** tuiGetLocatorFilename().
** Get the filename portion of the locator.
** (elz)
*/
void
#ifdef __STDC__
tuiGetLocatorFilename (
TuiGenWinInfoPtr locator,
char **filename)
#else
tuiGetLocatorFilename (locator, filename)
TuiGenWinInfoPtr locator;
char **filename;
#endif
{
 
/* 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
#ifdef __STDC__
tuiUpdateLocatorInfoFromFrame (
struct frame_info *frameInfo,
TuiLocatorElementPtr element)
#else
tuiUpdateLocatorInfoFromFrame (frameInfo, element)
struct frame_info *frameInfo;
TuiLocatorElementPtr element;
#endif
{
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,
_getFuncNameFromFrame (frameInfo),
symtabAndLine.line,
(Opaque) frameInfo->pc,
element);
else
tuiSetLocatorInfo ((char *) NULL,
_getFuncNameFromFrame (frameInfo),
0,
(Opaque) frameInfo->pc,
element);
 
return;
} /* tuiUpdateLocatorInfoFromFrame */
 
 
/*
** tuiSetLocatorContent().
** Function to set the content of the locator
*/
void
#ifdef __STDC__
tuiSetLocatorContent (
struct frame_info *frameInfo)
#else
tuiSetLocatorContent (frameInfo)
struct frame_info *frameInfo;
#endif
{
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,
(Opaque) NULL,
&((TuiWinElementPtr) locator->content[0])->whichElement.locator);
return;
} /* tuiSetLocatorContent */
 
 
/*
** tuiUpdateLocatorDisplay().
** Function to update the locator display
*/
void
#ifdef __STDC__
tuiUpdateLocatorDisplay (
struct frame_info *frameInfo)
#else
tuiUpdateLocatorDisplay (frameInfo)
struct frame_info *frameInfo;
#endif
{
tuiClearLocatorDisplay ();
tuiSetLocatorContent (frameInfo);
tuiShowLocatorContent ();
 
return;
} /* tuiUpdateLocatorDisplay */
 
 
/*
** tuiShowFrameInfo().
** Function to print the frame inforrmation for the TUI.
*/
void
#ifdef __STDC__
tuiShowFrameInfo (
struct frame_info *fi)
#else
tuiShowFrameInfo (fi)
struct frame_info *fi;
#endif
{
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);
sourceAlreadyDisplayed = tuiSourceIsDisplayed (s->filename);
tuiUpdateLocatorDisplay (fi);
for (i = 0; i < (sourceWindows ())->count; i++)
{
winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
if (winInfo == srcWin)
{
startLine =
(((TuiWinElementPtr) locator->content[0])->whichElement.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 = (CORE_ADDR) tuiGetLowDisassemblyAddress ((Opaque) low, (Opaque) fi->pc);
}
 
if (winInfo == srcWin)
{
if (!(sourceAlreadyDisplayed && m_tuiLineDisplayedWithinThreshold (
winInfo,
((TuiWinElementPtr) locator->content[0])->whichElement.locator.lineNo)))
tuiUpdateSourceWindow (winInfo, s, (Opaque) startLine, TRUE);
else
tuiSetIsExecPointAt ((Opaque)
((TuiWinElementPtr) locator->content[0])->whichElement.locator.lineNo,
winInfo);
}
else
{
if (winInfo == disassemWin)
{
if (!m_tuiLineDisplayedWithinThreshold (winInfo,
((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr))
tuiUpdateSourceWindow (winInfo, s, (Opaque) low, TRUE);
else
tuiSetIsExecPointAt ((Opaque)
((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr,
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 */
 
 
/*
** tui_vShowFrameInfo().
** Function to print the frame inforrmation for the TUI with args in a va_list.
*/
void
#ifdef __STDC__
tui_vShowFrameInfo (
va_list args)
#else
tui_vShowFrameInfo (args)
va_list args;
#endif
{
struct frame_info *fi;
 
fi = va_arg (args, struct frame_info *);
tuiShowFrameInfo (fi);
 
return;
} /* tui_vShowFrameInfo */
 
 
/*
** _initialize_tuiStack().
** Function to initialize gdb commands, for tui window stack manipulation.
*/
void
_initialize_tuiStack ()
{
if (tui_version)
{
add_com ("update", class_tui, _tuiUpdateLocation_command,
"Update the source window and locator to display the current execution point.\n");
}
 
return;
} /* _initialize_tuiStack */
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
 
/*
** _getFuncNameFromFrame().
*/
static char *
#ifdef __STDC__
_getFuncNameFromFrame (
struct frame_info *frameInfo)
#else
_getFuncNameFromFrame (frameInfo)
struct frame_info *frameInfo;
#endif
{
char *funcName = (char *) NULL;
 
find_pc_partial_function (frameInfo->pc,
&funcName,
(CORE_ADDR *) NULL,
(CORE_ADDR *) NULL);
return funcName;
} /* _getFuncNameFromFrame */
 
 
/*
** _tuiUpdateLocation_command().
** Command to update the display with the current execution point
*/
static void
#ifdef __STDC__
_tuiUpdateLocation_command (
char *arg,
int fromTTY)
#else
_tuiUpdateLocation_command (arg, fromTTY)
char *arg;
int fromTTY;
#endif
{
#ifndef TRY
extern void frame_command PARAMS ((char *, int));
frame_command ("0", FALSE);
#else
struct frame_info *curFrame;
 
/* Obtain the current execution point */
if ((curFrame = get_current_frame ()) != (struct frame_info *) NULL)
{
struct frame_info *frame;
int curLevel = 0;
 
for (frame = get_prev_frame (curLevel);
(frame != (struct frame_info *) NULL && (frame != curFrame));
frame = get_prev_frame (frame))
curLevel++;
 
if (curFrame != (struct frame_info *) NULL)
print_frame_info (frame, curLevel, 0, 1);
}
#endif
 
return;
} /* _tuiUpdateLocation_command */
/tuiIO.c
0,0 → 1,734
 
/*
** This module contains functions to support i/o in the TUI
*/
 
 
#include <stdio.h>
#include "defs.h"
#include "terminal.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiIO.h"
#include "tuiCommand.h"
#include "tuiWin.h"
 
#ifdef ANSI_PROTOTYPES
#include <stdarg.h>
#else
#include <varargs.h>
#endif
 
/* The Solaris header files seem to provide no declaration for this at
all when __STDC__ is defined. This shouldn't conflict with
anything. */
extern char *tgoto ();
 
int insert_mode = 0;
 
/********************************************
** LOCAL STATIC FORWARD DECLS **
********************************************/
static void _updateCommandInfo PARAMS ((int));
static unsigned int _tuiHandleResizeDuringIO PARAMS ((unsigned int));
 
 
/*********************************************************************************
** PUBLIC FUNCTIONS **
*********************************************************************************/
 
/*
** tuiPuts_unfiltered().
** Function to put a string to the command window
** When running in TUI mode, this is the "hook"
** for fputs_unfiltered(). That is, all debugger
** output eventually makes it's way to the bottom-level
** routine fputs_unfiltered (main.c), which (in TUI
** mode), calls tuiPuts_unfiltered().
*/
void
#ifdef __STDC__
tuiPuts_unfiltered (
const char *string,
struct ui_file * stream)
#else
tuiPuts_unfiltered (string, stream)
char *string;
struct ui_file *stream;
#endif
{
int len = strlen (string);
int i, linech;
 
for (i = 0; i < len; i++)
{
if (string[i] == '\n' || string[i] == '\r')
m_tuiStartNewLine;
else
{
if ((cmdWin->detail.commandInfo.curch + 1) > cmdWin->generic.width)
m_tuiStartNewLine;
 
if (insert_mode)
{
mvwinsch (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch++,
string[i]);
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
}
else
mvwaddch (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch++,
string[i]);
}
}
tuiRefreshWin (&cmdWin->generic);
 
return;
} /* tuiPuts_unfiltered */
 
/* A cover routine for tputs().
* tputs() is called from the readline package to put
* out strings representing cursor positioning.
* In TUI mode (non-XDB-style), tui_tputs() is called instead.
*
* The reason we need to hook tputs() is:
* Since the output is going to curses and not to
* a raw terminal, we need to intercept these special
* sequences, and handle them them here.
*
* This function seems to be correctly handling all sequences
* aimed at hpterm's, but there is additional work to do
* for xterm's and dtterm's. I abandoned further work on this
* in favor of "XDB style". In "XDB style", the command region
* looks like terminal, not a curses window, and this routine
* is not called. - RT
*/
void
tui_tputs (str, affcnt, putfunc)
char *str;
int affcnt;
int (*putfunc) PARAMS ((int));
{
extern char *rl_prompt; /* the prompt string */
 
/* This set of globals are defined and initialized
* by the readline package.
*
* Note we're assuming tui_tputs() is being called
* by the readline package. That's because we're recognizing
* that a given string is being passed by
* matching the string address against readline's
* term_<whatever> global. To make this more general,
* we'd have to actually recognize the termcap sequence
* inside the string (more work than I want to do). - RT
*
* We don't see or need to handle every one of these here;
* this is just the full list defined in readline/readline.c
*/
extern char *term_backspace;
extern char *term_clreol;
extern char *term_clrpag;
extern char *term_cr;
extern char *term_dc;
extern char *term_ei;
extern char *term_goto;
extern char *term_ic;
extern char *term_im;
extern char *term_mm;
extern char *term_mo;
extern char *term_up;
extern char *term_scroll_region;
extern char *term_memory_lock;
extern char *term_memory_unlock;
extern char *term_cursor_move;
extern char *visible_bell;
 
/* Sanity check - if not TUI, just call tputs() */
if (!tui_version)
tputs (str, affcnt, putfunc);
 
/* The strings we special-case are handled first */
 
if (str == term_backspace)
{
/* Backspace. */
 
/* We see this on an emacs control-B.
* I.e., it's like the left-arrow key (not like the backspace key).
* The effect that readline wants when it transmits this
* character to us is simply to back up one character
* (but not to write a space over the old character).
*/
 
_updateCommandInfo (-1);
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
wrefresh (cmdWin->generic.handle);
 
}
else if (str == term_clreol)
{
 
/* Clear to end of line. */
wclrtoeol (cmdWin->generic.handle);
wrefresh (cmdWin->generic.handle);
 
}
else if (str == term_cr)
{
 
/* Carriage return */
_updateCommandInfo (-cmdWin->detail.commandInfo.curch);
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
0 /* readline will rewrite the prompt from 0 */ );
wrefresh (cmdWin->generic.handle);
 
}
else if (str == term_goto)
{
 
/* This is actually a tgoto() specifying a character position,
* followed by either a term_IC/term_DC which [I think] means
* insert/delete one character at that position.
* There are complications with this one - need to either
* extract the position from the string, or have a backdoor
* means of communicating it from ../readline/display.c.
* So this one is not yet implemented.
* Not doing it seems to have no ill effects on command-line-editing
* that I've noticed so far. - RT
*/
 
}
else if (str == term_dc)
{
 
/* Delete character at current cursor position */
wdelch (cmdWin->generic.handle);
wrefresh (cmdWin->generic.handle);
 
}
else if (str == term_im)
{
 
/* Turn on insert mode. */
insert_mode = 1;
 
}
else if (str == term_ei)
{
 
/* Turn off insert mode. */
insert_mode = 0;
 
/* Strings we know about but don't handle
* specially here are just passed along to tputs().
*
* These are not handled because (as far as I can tell)
* they are not actually emitted by the readline package
* in the course of doing command-line editing. Some of them
* theoretically could be used in the future, in which case we'd
* need to handle them.
*/
}
else if (str == term_ic || /* insert character */
str == term_cursor_move || /* cursor move */
str == term_clrpag || /* clear page */
str == term_mm || /* turn on meta key */
str == term_mo || /* turn off meta key */
str == term_up || /* up one line (not expected) */
str == term_scroll_region || /* set scroll region */
str == term_memory_lock || /* lock screen above cursor */
str == term_memory_unlock || /* unlock screen above cursor */
str == visible_bell)
{ /* flash screen */
tputs (str, affcnt, putfunc);
}
else
{ /* something else */
tputs (str, affcnt, putfunc);
}
} /* tui_tputs */
 
 
/*
** tui_vwgetch()
** Wrapper around wgetch with the window in a va_list
*/
unsigned int
#ifdef __STDC__
tui_vwgetch (va_list args)
#else
tui_vwgetch (args)
va_list args;
#endif
{
unsigned int ch;
WINDOW *window;
 
window = va_arg (args, WINDOW *);
 
return ((unsigned int) wgetch (window));
} /* tui_vwgetch */
 
 
/*
** tui_vread()
** Wrapper around read() with paramets in a va_list
*/
unsigned int
#ifdef __STDC__
tui_vread (va_list args)
#else
tui_vread (args)
va_list args;
#endif
{
int result = 0;
int filedes = va_arg (args, int);
char *buf = va_arg (args, char *);
int nbytes = va_arg (args, int);
 
result = read (filedes, buf, nbytes);
 
return result;
} /* tui_vread() */
 
/*
** tuiRead()
** Function to perform a read() catching resize events
*/
int
#ifdef __STDC__
tuiRead (
int filedes,
char *buf,
int nbytes)
#else
tuiRead (filedes, buf, nbytes)
int filedes;
char *buf;
int nbytes;
#endif
{
int result = 0;
 
result = (int) vcatch_errors ((OpaqueFuncPtr) tui_vread, filedes, buf, nbytes);
*buf = _tuiHandleResizeDuringIO (*buf);
 
return result;
} /* tuiRead */
 
 
/*
** tuiGetc().
** Get a character from the command window.
** This is called from the readline package,
** that is, we have:
** tuiGetc() [here], called from
** readline code [in ../readline/], called from
** command_line_input() in top.c
*/
unsigned int
#ifdef __STDC__
tuiGetc (void)
#else
tuiGetc ()
#endif
{
unsigned int ch;
extern char *rl_prompt;
extern char *rl_line_buffer;
extern int rl_point;
 
/* Call the curses routine that reads one character */
#ifndef COMMENT
ch = (unsigned int) vcatch_errors ((OpaqueFuncPtr) tui_vwgetch,
cmdWin->generic.handle);
#else
ch = wgetch (cmdWin->generic.handle);
#endif
ch = _tuiHandleResizeDuringIO (ch);
 
if (m_isCommandChar (ch))
{ /* Handle prev/next/up/down here */
tuiTermSetup (0);
ch = tuiDispatchCtrlChar (ch);
cmdWin->detail.commandInfo.curch = strlen (rl_prompt) + rl_point;
tuiTermUnsetup (0, cmdWin->detail.commandInfo.curch);
}
if (ch == '\n' || ch == '\r' || ch == '\f')
cmdWin->detail.commandInfo.curch = 0;
else
tuiIncrCommandCharCountBy (1);
 
return ch;
} /* tuiGetc */
 
 
/*
** tuiBufferGetc().
*/
/*elz: this function reads a line of input from the user and
puts it in a static buffer. Subsequent calls to this same function
obtain one char at the time, providing the caller with a behavior
similar to fgetc. When the input is buffered, the backspaces have
the needed effect, i.e. ignore the last char active in the buffer */
/* so far this function is called only from the query function in
utils.c */
 
unsigned int
#ifdef __STDC__
tuiBufferGetc (void)
#else
tuiBufferGetc ()
#endif
{
unsigned int ch;
static unsigned char _ibuffer[512];
static int index_read = -1;
static int length_of_answer = -1;
int pos = 0;
 
if (length_of_answer == -1)
{
/* this is the first time through, need to read the answer */
do
{
/* Call the curses routine that reads one character */
ch = (unsigned int) wgetch (cmdWin->generic.handle);
if (ch != '\b')
{
_ibuffer[pos] = ch;
pos++;
}
else
pos--;
}
while (ch != '\r' && ch != '\n');
 
length_of_answer = pos;
index_read = 0;
}
 
ch = _ibuffer[index_read];
index_read++;
 
if (index_read == length_of_answer)
{
/*this is the last time through, reset for next query */
index_read = -1;
length_of_answer = -1;
}
 
wrefresh (cmdWin->generic.handle);
 
return (ch);
} /* tuiBufferGetc */
 
 
/*
** tuiStartNewLines().
*/
void
#ifdef __STDC__
tuiStartNewLines (
int numLines)
#else
tuiStartNewLines (numLines)
int numLines;
#endif
{
if (numLines > 0)
{
if (cmdWin->generic.viewportHeight > 1 &&
cmdWin->detail.commandInfo.curLine < cmdWin->generic.viewportHeight)
cmdWin->detail.commandInfo.curLine += numLines;
else
scroll (cmdWin->generic.handle);
cmdWin->detail.commandInfo.curch = 0;
wmove (cmdWin->generic.handle,
cmdWin->detail.commandInfo.curLine,
cmdWin->detail.commandInfo.curch);
tuiRefreshWin (&cmdWin->generic);
}
 
return;
} /* tuiStartNewLines */
 
 
/*
** tui_vStartNewLines().
** With numLines in a va_list
*/
void
#ifdef __STDC__
tui_vStartNewLines (
va_list args)
#else
tui_vStartNewLines (args)
va_list args;
#endif
{
int numLines = va_arg (args, int);
 
tuiStartNewLines (numLines);
 
return;
} /* tui_vStartNewLines */
 
 
/****************************************************************************
** LOCAL STATIC FUNCTIONS **
*****************************************************************************/
 
 
/*
** _tuiHandleResizeDuringIO
** This function manages the cleanup when a resize has occured
** From within a call to getch() or read. Returns the character
** to return from getc or read.
*/
static unsigned int
#ifdef __STDC__
_tuiHandleResizeDuringIO (
unsigned int originalCh) /* the char just read */
#else
_tuiHandleResizeDuringIO (originalCh)
unsigned int originalCh;
#endif
{
if (tuiWinResized ())
{
tuiDo ((TuiOpaqueFuncPtr) tuiRefreshAll);
dont_repeat ();
tuiSetWinResizedTo (FALSE);
rl_reset ();
return '\n';
}
else
return originalCh;
} /* _tuiHandleResizeDuringIO */
 
 
/*
** _updateCommandInfo().
** Function to update the command window information.
*/
static void
#ifdef __STDC__
_updateCommandInfo (
int sizeOfString)
#else
_updateCommandInfo (sizeOfString)
int sizeOfString;
#endif
{
 
if ((sizeOfString +
cmdWin->detail.commandInfo.curch) > cmdWin->generic.width)
{
int newCurch = sizeOfString + cmdWin->detail.commandInfo.curch;
 
tuiStartNewLines (1);
cmdWin->detail.commandInfo.curch = newCurch - cmdWin->generic.width;
}
else
cmdWin->detail.commandInfo.curch += sizeOfString;
 
return;
} /* _updateCommandInfo */
 
 
/* Looked at in main.c, fputs_unfiltered(), to decide
* if it's safe to do standard output to the command window.
*/
int tui_owns_terminal = 0;
 
/* Called to set up the terminal for TUI (curses) I/O.
* We do this either on our way "in" to GDB after target
* program execution, or else within tuiDo just before
* going off to TUI routines.
*/
 
void
#ifdef __STDC__
tuiTermSetup (
int turn_off_echo)
#else
tuiTermSetup (turn_off_echo)
int turn_off_echo;
#endif
{
char *buffer;
int start;
int end;
int endcol;
extern char *term_scroll_region;
extern char *term_cursor_move;
extern char *term_memory_lock;
extern char *term_memory_unlock;
 
/* Turn off echoing, since the TUI does not
* expect echoing. Below I only put in the TERMIOS
* case, since that is what applies on HP-UX. turn_off_echo
* is 1 except for the case where we're being called
* on a "quit", in which case we want to leave echo on.
*/
if (turn_off_echo)
{
#ifdef HAVE_TERMIOS
struct termios tio;
tcgetattr (0, &tio);
tio.c_lflag &= ~(ECHO);
tcsetattr (0, TCSANOW, &tio);
#endif
}
 
/* Compute the start and end lines of the command
* region. (Actually we only use end here)
*/
start = winList[CMD_WIN]->generic.origin.y;
end = start + winList[CMD_WIN]->generic.height - 1;
endcol = winList[CMD_WIN]->generic.width - 1;
 
if (term_memory_unlock)
{
 
/* Un-do the effect of the memory lock in terminal_inferior() */
tputs (term_memory_unlock, 1, (int (*)PARAMS ((int))) putchar);
fflush (stdout);
 
}
else if (term_scroll_region)
{
 
/* Un-do the effect of setting scroll region in terminal_inferior() */
/* I'm actually not sure how to do this (we don't know for
* sure what the scroll region was *before* we changed it),
* but I'll guess that setting it to the whole screen is
* the right thing. So, ...
*/
 
/* Set scroll region to be 0..end */
buffer = (char *) tgoto (term_scroll_region, end, 0);
tputs (buffer, 1, (int (*)PARAMS ((int))) putchar);
 
} /* else we're out of luck */
 
/* This is an attempt to keep the logical & physical
* cursor in synch, going into curses. Without this,
* curses seems to be confused by the fact that
* GDB has physically moved the curser on it. One
* visible effect of removing this code is that the
* locator window fails to get updated and the line
* of text that *should* go into the locator window
* often goes to the wrong place.
*/
/* What's done here is to tell curses to write a ' '
* at the bottom right corner of the screen.
* The idea is to wind up with the cursor in a known
* place.
* Note I'm relying on refresh()
* only writing what changed (the space),
* not the whole screen.
*/
standend ();
move (end, endcol - 1);
addch (' ');
refresh ();
 
tui_owns_terminal = 1;
} /* tuiTermSetup */
 
 
/* Called to set up the terminal for target program I/O, meaning I/O
* is confined to the command-window area. We also call this on our
* way out of tuiDo, thus setting up the terminal this way for
* debugger command I/O. */
void
#ifdef __STDC__
tuiTermUnsetup (
int turn_on_echo,
int to_column)
#else
tuiTermUnsetup (turn_on_echo, to_column)
int turn_on_echo;
int to_column;
#endif
{
int start;
int end;
int curline;
char *buffer;
/* The next bunch of things are from readline */
extern char *term_scroll_region;
extern char *term_cursor_move;
extern char *term_memory_lock;
extern char *term_memory_unlock;
extern char *term_se;
 
/* We need to turn on echoing, since the TUI turns it off */
/* Below I only put in the TERMIOS case, since that
* is what applies on HP-UX.
*/
if (turn_on_echo)
{
#ifdef HAVE_TERMIOS
struct termios tio;
tcgetattr (0, &tio);
tio.c_lflag |= (ECHO);
tcsetattr (0, TCSANOW, &tio);
#endif
}
 
/* Compute the start and end lines of the command
* region, as well as the last "real" line of
* the region (normally same as end, except when
* we're first populating the region)
*/
start = winList[CMD_WIN]->generic.origin.y;
end = start + winList[CMD_WIN]->generic.height - 1;
curline = start + winList[CMD_WIN]->detail.commandInfo.curLine;
 
/* We want to confine target I/O to the command region.
* In order to do so, we must either have "memory lock"
* (hpterm's) or "scroll regions" (xterm's).
*/
if (term_cursor_move && term_memory_lock)
{
 
/* Memory lock means lock region above cursor.
* So first position the cursor, then call memory lock.
*/
buffer = tgoto (term_cursor_move, 0, start);
tputs (buffer, 1, (int (*)PARAMS ((int))) putchar);
tputs (term_memory_lock, 1, (int (*)PARAMS ((int))) putchar);
 
}
else if (term_scroll_region)
{
 
/* Set the scroll region to the command window */
buffer = tgoto (term_scroll_region, end, start);
tputs (buffer, 1, (int (*)PARAMS ((int))) putchar);
 
} /* else we can't do anything about target I/O */
 
/* Also turn off standout mode, in case it is on */
if (term_se != NULL)
tputs (term_se, 1, (int (*)PARAMS ((int))) putchar);
 
/* Now go to the appropriate spot on the end line */
buffer = tgoto (term_cursor_move, to_column, end);
tputs (buffer, 1, (int (*)PARAMS ((int))) putchar);
fflush (stdout);
 
tui_owns_terminal = 0;
} /* tuiTermUnsetup */
/tuiDisassem.c
0,0 → 1,344
/*
** tuiDisassem.c
** This module contains functions for handling disassembly display.
*/
 
 
#include "defs.h"
#include "symtab.h"
#include "breakpoint.h"
#include "frame.h"
 
#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiSourceWin.h"
#include "tuiStack.h"
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS **
******************************************/
 
static struct breakpoint *_hasBreak PARAMS ((CORE_ADDR));
 
 
/*****************************************
** PUBLIC FUNCTIONS **
******************************************/
 
/*
** tuiSetDisassemContent().
** Function to set the disassembly window's content.
*/
TuiStatus
#ifdef __STDC__
tuiSetDisassemContent (
struct symtab *s,
Opaque startAddr)
#else
tuiSetDisassemContent (s, startAddr)
struct symtab *s;
Opaque startAddr;
#endif
{
TuiStatus ret = TUI_FAILURE;
struct ui_file *gdb_dis_out;
 
if (startAddr != (Opaque) NULL)
{
register int i, desc;
 
if ((ret = tuiAllocSourceBuffer (disassemWin)) == TUI_SUCCESS)
{
register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
register int threshold, curLine = 0, lineWidth, maxLines;
CORE_ADDR newpc, pc;
disassemble_info asmInfo;
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
extern void strcat_address PARAMS ((CORE_ADDR, char *, int));
extern void strcat_address_numeric PARAMS ((CORE_ADDR, int, char *, int));
int curLen = 0;
int tab_len = tuiDefaultTabLen ();
 
maxLines = disassemWin->generic.height - 2; /* account for hilite */
lineWidth = disassemWin->generic.width - 1;
threshold = (lineWidth - 1) + offset;
 
/* now init the ui_file structure */
gdb_dis_out = tui_sfileopen (threshold);
 
INIT_DISASSEMBLE_INFO_NO_ARCH (asmInfo, gdb_dis_out, (fprintf_ftype) fprintf_filtered);
asmInfo.read_memory_func = dis_asm_read_memory;
asmInfo.memory_error_func = dis_asm_memory_error;
 
disassemWin->detail.sourceInfo.startLineOrAddr.addr = startAddr;
 
/* Now construct each line */
for (curLine = 0, pc = (CORE_ADDR) startAddr; (curLine < maxLines);)
{
TuiWinElementPtr element = (TuiWinElementPtr) disassemWin->generic.content[curLine];
struct breakpoint *bp;
 
print_address (pc, gdb_dis_out);
 
curLen = strlen (tui_file_get_strbuf (gdb_dis_out));
i = curLen - ((curLen / tab_len) * tab_len);
 
/* adjust buffer length if necessary */
tui_file_adjust_strbuf ((tab_len - i > 0) ? (tab_len - i) : 0, gdb_dis_out);
 
/* Add spaces to make the instructions start onthe same column */
while (i < tab_len)
{
tui_file_get_strbuf (gdb_dis_out)[curLen] = ' ';
i++;
curLen++;
}
tui_file_get_strbuf (gdb_dis_out)[curLen] = '\0';
 
newpc = pc + ((*tm_print_insn) (pc, &asmInfo));
 
/* Now copy the line taking the offset into account */
if (strlen (tui_file_get_strbuf (gdb_dis_out)) > offset)
strcpy (element->whichElement.source.line,
&(tui_file_get_strbuf (gdb_dis_out)[offset]));
else
element->whichElement.source.line[0] = '\0';
element->whichElement.source.lineOrAddr.addr = (Opaque) pc;
element->whichElement.source.isExecPoint =
(pc == (CORE_ADDR) ((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
bp = _hasBreak (pc);
element->whichElement.source.hasBreak =
(bp != (struct breakpoint *) NULL &&
(!element->whichElement.source.isExecPoint ||
(bp->disposition != del || bp->hit_count <= 0)));
curLine++;
pc = newpc;
/* reset the buffer to empty */
tui_file_get_strbuf (gdb_dis_out)[0] = '\0';
}
ui_file_delete (gdb_dis_out);
gdb_dis_out = NULL;
disassemWin->generic.contentSize = curLine;
ret = TUI_SUCCESS;
}
}
 
return ret;
} /* tuiSetDisassemContent */
 
 
/*
** tuiShowDisassem().
** Function to display the disassembly window with disassembled code.
*/
void
#ifdef __STDC__
tuiShowDisassem (
Opaque startAddr)
#else
tuiShowDisassem (startAddr)
Opaque startAddr;
#endif
{
struct symtab *s = find_pc_symtab ((CORE_ADDR) startAddr);
TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
 
tuiAddWinToLayout (DISASSEM_WIN);
tuiUpdateSourceWindow (disassemWin, s, startAddr, FALSE);
/*
** if the focus was in the src win, put it in the asm win, if the
** source view isn't split
*/
if (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
tuiSetWinFocusTo (disassemWin);
 
return;
} /* tuiShowDisassem */
 
 
/*
** tuiShowDisassemAndUpdateSource().
** Function to display the disassembly window.
*/
void
#ifdef __STDC__
tuiShowDisassemAndUpdateSource (
Opaque startAddr)
#else
tuiShowDisassemAndUpdateSource (startAddr)
Opaque startAddr;
#endif
{
struct symtab_and_line sal;
 
tuiShowDisassem (startAddr);
if (currentLayout () == SRC_DISASSEM_COMMAND)
{
TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
/*
** Update what is in the source window if it is displayed too,
** note that it follows what is in the disassembly window and visa-versa
*/
sal = find_pc_line ((CORE_ADDR) startAddr, 0);
current_source_symtab = sal.symtab;
tuiUpdateSourceWindow (srcWin, sal.symtab, (Opaque) sal.line, TRUE);
tuiUpdateLocatorFilename (sal.symtab->filename);
}
 
return;
} /* tuiShowDisassemAndUpdateSource */
 
 
/*
** tuiShowDisassemAsIs().
** Function to display the disassembly window. This function shows
** the disassembly as specified by the horizontal offset.
*/
void
#ifdef __STDC__
tuiShowDisassemAsIs (
Opaque addr)
#else
tuiShowDisassemAsIs (addr)
Opaque addr;
#endif
{
tuiAddWinToLayout (DISASSEM_WIN);
tuiUpdateSourceWindowAsIs (disassemWin, (struct symtab *) NULL, addr, FALSE);
/*
** Update what is in the source window if it is displayed too, not that it
** follows what is in the disassembly window and visa-versa
*/
if (currentLayout () == SRC_DISASSEM_COMMAND)
tuiShowSourceContent (srcWin); /*???? Need to do more? */
 
return;
} /* tuiShowDisassem */
 
 
/*
** tuiGetBeginAsmAddress().
*/
Opaque
#ifdef __STDC__
tuiGetBeginAsmAddress (void)
#else
tuiGetBeginAsmAddress ()
#endif
{
TuiGenWinInfoPtr locator;
TuiLocatorElementPtr element;
Opaque addr;
 
locator = locatorWinInfoPtr ();
element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
 
if (element->addr == (Opaque) 0)
{
/*the target is not executing, because the pc is 0 */
 
addr = (Opaque) parse_and_eval_address ("main");
 
if (addr == (Opaque) 0)
addr = (Opaque) parse_and_eval_address ("MAIN");
 
}
else /* the target is executing */
addr = element->addr;
 
return addr;
} /* tuiGetBeginAsmAddress */
 
 
/*
** tuiVerticalDisassemScroll().
** Scroll the disassembly forward or backward vertically
*/
void
#ifdef __STDC__
tuiVerticalDisassemScroll (
TuiScrollDirection scrollDirection,
int numToScroll)
#else
tuiVerticalDisassemScroll (scrollDirection, numToScroll)
TuiScrollDirection scrollDirection;
int numToScroll;
#endif
{
if (disassemWin->generic.content != (OpaquePtr) NULL)
{
Opaque pc, lowAddr;
TuiWinContent content;
struct symtab *s;
 
content = (TuiWinContent) disassemWin->generic.content;
if (current_source_symtab == (struct symtab *) NULL)
s = find_pc_symtab (selected_frame->pc);
else
s = current_source_symtab;
 
pc = content[0]->whichElement.source.lineOrAddr.addr;
if (find_pc_partial_function ((CORE_ADDR) pc,
(char **) NULL,
(CORE_ADDR *) & lowAddr,
(CORE_ADDR) NULL) == 0)
error ("No function contains prgram counter for selected frame.\n");
else
{
register int line = 0;
register Opaque newLow;
bfd_byte buffer[4];
 
newLow = pc;
if (scrollDirection == FORWARD_SCROLL)
{
for (; line < numToScroll; line++)
newLow += sizeof (bfd_getb32 (buffer));
}
else
{
for (; newLow >= (Opaque) 0 && line < numToScroll; line++)
newLow -= sizeof (bfd_getb32 (buffer));
}
tuiUpdateSourceWindowAsIs (disassemWin, s, newLow, FALSE);
}
}
 
return;
} /* tuiVerticalDisassemScroll */
 
 
 
/*****************************************
** STATIC LOCAL FUNCTIONS **
******************************************/
/*
** _hasBreak().
** Answer whether there is a break point at the input line in the
** source file indicated
*/
static struct breakpoint *
#ifdef __STDC__
_hasBreak (
CORE_ADDR addr)
#else
_hasBreak (addr)
CORE_ADDR addr;
#endif
{
struct breakpoint *bpWithBreak = (struct breakpoint *) NULL;
struct breakpoint *bp;
extern struct breakpoint *breakpoint_chain;
 
 
for (bp = breakpoint_chain;
(bp != (struct breakpoint *) NULL &&
bpWithBreak == (struct breakpoint *) NULL);
bp = bp->next)
if (addr == bp->address)
bpWithBreak = bp;
 
return bpWithBreak;
} /* _hasBreak */
/tuiData.c
0,0 → 1,1624
/*
** tuiData.c
** This module contains functions for manipulating the data
** structures used by the TUI
*/
 
#include "defs.h"
#include "tui.h"
#include "tuiData.h"
 
/****************************
** GLOBAL DECLARATIONS
****************************/
TuiWinInfoPtr winList[MAX_MAJOR_WINDOWS];
 
/***************************
** Private Definitions
****************************/
#define FILE_WIDTH 30
#define PROC_WIDTH 40
#define LINE_WIDTH 4
#define PC_WIDTH 8
 
/***************************
** Private data
****************************/
static char *_tuiNullStr = TUI_NULL_STR;
static char *_tuiBlankStr = " ";
static char *_tuiLocationStr = " >";
static char *_tuiBreakStr = " * ";
static char *_tuiBreakLocationStr = " *>";
static TuiLayoutType _currentLayout = UNDEFINED_LAYOUT;
static int _termHeight, _termWidth;
static int _historyLimit = DEFAULT_HISTORY_COUNT;
static TuiGenWinInfo _locator;
static TuiGenWinInfo _execInfo[2];
static TuiWinInfoPtr _srcWinList[2];
static TuiList _sourceWindows =
{(OpaqueList) _srcWinList, 0};
static int _defaultTabLen = DEFAULT_TAB_LEN;
static TuiWinInfoPtr _winWithFocus = (TuiWinInfoPtr) NULL;
static TuiLayoutDef _layoutDef =
{SRC_WIN, /* displayMode */
FALSE, /* split */
TUI_UNDEFINED_REGS, /* regsDisplayType */
TUI_SFLOAT_REGS}; /* floatRegsDisplayType */
static int _winResized = FALSE;
 
 
/*********************************
** Static function forward decls
**********************************/
static void freeContent PARAMS ((TuiWinContent, int, TuiWinType));
static void freeContentElements PARAMS ((TuiWinContent, int, TuiWinType));
 
 
 
/*********************************
** PUBLIC FUNCTIONS
**********************************/
 
/******************************************
** ACCESSORS & MUTATORS FOR PRIVATE DATA
******************************************/
 
/*
** tuiWinResized().
** Answer a whether the terminal window has been resized or not
*/
int
#ifdef __STDC__
tuiWinResized (void)
#else
tuiWinResized ()
#endif
{
return _winResized;
} /* tuiWinResized */
 
 
/*
** tuiSetWinResized().
** Set a whether the terminal window has been resized or not
*/
void
#ifdef __STDC__
tuiSetWinResizedTo (
int resized)
#else
tuiSetWinResizedTo (resized)
int resized;
#endif
{
_winResized = resized;
 
return;
} /* tuiSetWinResizedTo */
 
 
/*
** tuiLayoutDef().
** Answer a pointer to the current layout definition
*/
TuiLayoutDefPtr
#ifdef __STDC__
tuiLayoutDef (void)
#else
tuiLayoutDef ()
#endif
{
return &_layoutDef;
} /* tuiLayoutDef */
 
 
/*
** tuiWinWithFocus().
** Answer the window with the logical focus
*/
TuiWinInfoPtr
#ifdef __STDC__
tuiWinWithFocus (void)
#else
tuiWinWithFocus ()
#endif
{
return _winWithFocus;
} /* tuiWinWithFocus */
 
 
/*
** tuiSetWinWithFocus().
** Set the window that has the logical focus
*/
void
#ifdef __STDC__
tuiSetWinWithFocus (
TuiWinInfoPtr winInfo)
#else
tuiSetWinWithFocus (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
_winWithFocus = winInfo;
 
return;
} /* tuiSetWinWithFocus */
 
 
/*
** tuiDefaultTabLen().
** Answer the length in chars, of tabs
*/
int
#ifdef __STDC__
tuiDefaultTabLen (void)
#else
tuiDefaultTabLen ()
#endif
{
return _defaultTabLen;
} /* tuiDefaultTabLen */
 
 
/*
** tuiSetDefaultTabLen().
** Set the length in chars, of tabs
*/
void
#ifdef __STDC__
tuiSetDefaultTabLen (
int len)
#else
tuiSetDefaultTabLen (len)
int len;
#endif
{
_defaultTabLen = len;
 
return;
} /* tuiSetDefaultTabLen */
 
 
/*
** currentSourceWin()
** Accessor for the current source window. Usually there is only
** one source window (either source or disassembly), but both can
** be displayed at the same time.
*/
TuiListPtr
#ifdef __STDC__
sourceWindows (void)
#else
sourceWindows ()
#endif
{
return &_sourceWindows;
} /* currentSourceWindows */
 
 
/*
** clearSourceWindows()
** Clear the list of source windows. Usually there is only one
** source window (either source or disassembly), but both can be
** displayed at the same time.
*/
void
#ifdef __STDC__
clearSourceWindows (void)
#else
clearSourceWindows ()
#endif
{
_sourceWindows.list[0] = (Opaque) NULL;
_sourceWindows.list[1] = (Opaque) NULL;
_sourceWindows.count = 0;
 
return;
} /* currentSourceWindows */
 
 
/*
** clearSourceWindowsDetail()
** Clear the pertinant detail in the source windows.
*/
void
#ifdef __STDC__
clearSourceWindowsDetail (void)
#else
clearSourceWindowsDetail ()
#endif
{
int i;
 
for (i = 0; i < (sourceWindows ())->count; i++)
clearWinDetail ((TuiWinInfoPtr) (sourceWindows ())->list[i]);
 
return;
} /* currentSourceWindows */
 
 
/*
** addSourceWindowToList().
** Add a window to the list of source windows. Usually there is
** only one source window (either source or disassembly), but
** both can be displayed at the same time.
*/
void
#ifdef __STDC__
addToSourceWindows (
TuiWinInfoPtr winInfo)
#else
addToSourceWindows (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (_sourceWindows.count < 2)
_sourceWindows.list[_sourceWindows.count++] = (Opaque) winInfo;
 
return;
} /* addToSourceWindows */
 
 
/*
** clearWinDetail()
** Clear the pertinant detail in the windows.
*/
void
#ifdef __STDC__
clearWinDetail (
TuiWinInfoPtr winInfo)
#else
clearWinDetail (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
if (m_winPtrNotNull (winInfo))
{
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
winInfo->detail.sourceInfo.startLineOrAddr.addr = (Opaque) NULL;
winInfo->detail.sourceInfo.horizontalOffset = 0;
break;
case CMD_WIN:
winInfo->detail.commandInfo.curLine =
winInfo->detail.commandInfo.curch = 0;
break;
case DATA_WIN:
winInfo->detail.dataDisplayInfo.dataContent =
(TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.dataContentCount = 0;
winInfo->detail.dataDisplayInfo.regsContent =
(TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.regsContentCount = 0;
winInfo->detail.dataDisplayInfo.regsDisplayType =
TUI_UNDEFINED_REGS;
winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
break;
default:
break;
}
}
 
return;
} /* clearWinDetail */
 
 
/*
** blankStr()
** Accessor for the blank string.
*/
char *
#ifdef __STDC__
blankStr (void)
#else
blankStr ()
#endif
{
return _tuiBlankStr;
} /* blankStr */
 
 
/*
** locationStr()
** Accessor for the location string.
*/
char *
#ifdef __STDC__
locationStr (void)
#else
locationStr ()
#endif
{
return _tuiLocationStr;
} /* locationStr */
 
 
/*
** breakStr()
** Accessor for the break string.
*/
char *
#ifdef __STDC__
breakStr (void)
#else
breakStr ()
#endif
{
return _tuiBreakStr;
} /* breakStr */
 
 
/*
** breakLocationStr()
** Accessor for the breakLocation string.
*/
char *
#ifdef __STDC__
breakLocationStr (void)
#else
breakLocationStr ()
#endif
{
return _tuiBreakLocationStr;
} /* breakLocationStr */
 
 
/*
** nullStr()
** Accessor for the null string.
*/
char *
#ifdef __STDC__
nullStr (void)
#else
nullStr ()
#endif
{
return _tuiNullStr;
} /* nullStr */
 
 
/*
** sourceExecInfoPtr().
** Accessor for the source execution info ptr.
*/
TuiGenWinInfoPtr
#ifdef __STDC__
sourceExecInfoWinPtr (void)
#else
sourceExecInfoWinPtr ()
#endif
{
return &_execInfo[0];
} /* sourceExecInfoWinPtr */
 
 
/*
** disassemExecInfoPtr().
** Accessor for the disassem execution info ptr.
*/
TuiGenWinInfoPtr
#ifdef __STDC__
disassemExecInfoWinPtr (void)
#else
disassemExecInfoWinPtr ()
#endif
{
return &_execInfo[1];
} /* disassemExecInfoWinPtr */
 
 
/*
** locatorWinInfoPtr().
** Accessor for the locator win info. Answers a pointer to the
** static locator win info struct.
*/
TuiGenWinInfoPtr
#ifdef __STDC__
locatorWinInfoPtr (void)
#else
locatorWinInfoPtr ()
#endif
{
return &_locator;
} /* locatorWinInfoPtr */
 
 
/*
** historyLimit().
** Accessor for the history limit
*/
int
#ifdef __STDC__
historyLimit (void)
#else
historyLimit ()
#endif
{
return _historyLimit;
} /* historyLimit */
 
 
/*
** setHistoryLimitTo().
** Mutator for the history limit
*/
void
#ifdef __STDC__
setHistoryLimitTo (
int h)
#else
setHistoryLimitTo (h)
int h;
#endif
{
_historyLimit = h;
 
return;
} /* setHistoryLimitTo */
 
/*
** termHeight().
** Accessor for the termHeight
*/
int
#ifdef __STDC__
termHeight (void)
#else
termHeight ()
#endif
{
return _termHeight;
} /* termHeight */
 
 
/*
** setTermHeightTo().
** Mutator for the term height
*/
void
#ifdef __STDC__
setTermHeightTo (
int h)
#else
setTermHeightTo (h)
int h;
#endif
{
_termHeight = h;
 
return;
} /* setTermHeightTo */
 
 
/*
** termWidth().
** Accessor for the termWidth
*/
int
#ifdef __STDC__
termWidth (void)
#else
termWidth ()
#endif
{
return _termWidth;
} /* termWidth */
 
 
/*
** setTermWidth().
** Mutator for the termWidth
*/
void
#ifdef __STDC__
setTermWidthTo (
int w)
#else
setTermWidthTo (w)
int w;
#endif
{
_termWidth = w;
 
return;
} /* setTermWidthTo */
 
 
/*
** currentLayout().
** Accessor for the current layout
*/
TuiLayoutType
#ifdef __STDC__
currentLayout (void)
#else
currentLayout ()
#endif
{
return _currentLayout;
} /* currentLayout */
 
 
/*
** setCurrentLayoutTo().
** Mutator for the current layout
*/
void
#ifdef __STDC__
setCurrentLayoutTo (
TuiLayoutType newLayout)
#else
setCurrentLayoutTo (newLayout)
TuiLayoutType newLayout;
#endif
{
_currentLayout = newLayout;
 
return;
} /* setCurrentLayoutTo */
 
 
/*
** setGenWinOrigin().
** Set the origin of the window
*/
void
#ifdef __STDC__
setGenWinOrigin (
TuiGenWinInfoPtr winInfo,
int x,
int y)
#else
setGenWinOrigin (winInfo, x, y)
TuiGenWinInfoPtr winInfo;
int x;
int y;
#endif
{
winInfo->origin.x = x;
winInfo->origin.y = y;
 
return;
} /* setGenWinOrigin */
 
 
/*****************************
** OTHER PUBLIC FUNCTIONS
*****************************/
 
 
/*
** tuiNextWin().
** Answer the next window in the list, cycling back to the top
** if necessary
*/
TuiWinInfoPtr
#ifdef __STDC__
tuiNextWin (
TuiWinInfoPtr curWin)
#else
tuiNextWin (curWin)
TuiWinInfoPtr curWin;
#endif
{
TuiWinType type = curWin->generic.type;
TuiWinInfoPtr nextWin = (TuiWinInfoPtr) NULL;
 
if (curWin->generic.type == CMD_WIN)
type = SRC_WIN;
else
type = curWin->generic.type + 1;
while (type != curWin->generic.type && m_winPtrIsNull (nextWin))
{
if (winList[type]->generic.isVisible)
nextWin = winList[type];
else
{
if (type == CMD_WIN)
type = SRC_WIN;
else
type++;
}
}
 
return nextWin;
} /* tuiNextWin */
 
 
/*
** tuiPrevWin().
** Answer the prev window in the list, cycling back to the bottom
** if necessary
*/
TuiWinInfoPtr
#ifdef __STDC__
tuiPrevWin (
TuiWinInfoPtr curWin)
#else
tuiPrevWin (curWin)
TuiWinInfoPtr curWin;
#endif
{
TuiWinType type = curWin->generic.type;
TuiWinInfoPtr prev = (TuiWinInfoPtr) NULL;
 
if (curWin->generic.type == SRC_WIN)
type = CMD_WIN;
else
type = curWin->generic.type - 1;
while (type != curWin->generic.type && m_winPtrIsNull (prev))
{
if (winList[type]->generic.isVisible)
prev = winList[type];
else
{
if (type == SRC_WIN)
type = CMD_WIN;
else
type--;
}
}
 
return prev;
} /* tuiPrevWin */
 
 
/*
** displayableWinContentOf().
** Answer a the content at the location indicated by index. Note
** that if this is a locator window, the string returned should be
** freed after use.
*/
char *
#ifdef __STDC__
displayableWinContentOf (
TuiGenWinInfoPtr winInfo,
TuiWinElementPtr elementPtr)
#else
displayableWinContentOf (winInfo, elementPtr)
TuiGenWinInfoPtr winInfo;
TuiWinElementPtr elementPtr;
#endif
{
 
char *string = nullStr ();
 
if (elementPtr != (TuiWinElementPtr) NULL || winInfo->type == LOCATOR_WIN)
{
/*
** Now convert the line to a displayable string
*/
switch (winInfo->type)
{
case SRC_WIN:
case DISASSEM_WIN:
string = elementPtr->whichElement.source.line;
break;
case CMD_WIN:
string = elementPtr->whichElement.command.line;
break;
case LOCATOR_WIN:
if ((string = (char *) xmalloc (
(termWidth () + 1) * sizeof (char))) == (char *) NULL)
string = nullStr ();
else
{
char lineNo[50], pc[50], buf[50], *fname, *pname;
register int strSize = termWidth (), i, procWidth, fileWidth;
 
/*
** First determine the amount of file/proc name width
** we have available
*/
i = strSize - (PC_WIDTH + LINE_WIDTH
+ 25 /* pc and line labels */
+ strlen (FILE_PREFIX) + 1 /* file label */
+ 15 /* procedure label */ );
if (i >= FILE_WIDTH + PROC_WIDTH)
{
fileWidth = FILE_WIDTH;
procWidth = PROC_WIDTH;
}
else
{
fileWidth = i / 2;
procWidth = i - fileWidth;
}
 
/* Now convert elements to string form */
if (elementPtr != (TuiWinElementPtr) NULL &&
*elementPtr->whichElement.locator.fileName != (char) 0 &&
srcWin->generic.isVisible)
fname = elementPtr->whichElement.locator.fileName;
else
fname = "??";
if (elementPtr != (TuiWinElementPtr) NULL &&
*elementPtr->whichElement.locator.procName != (char) 0)
pname = elementPtr->whichElement.locator.procName;
else
pname = "??";
if (elementPtr != (TuiWinElementPtr) NULL &&
elementPtr->whichElement.locator.lineNo > 0)
sprintf (lineNo, "%d",
elementPtr->whichElement.locator.lineNo);
else
strcpy (lineNo, "??");
if (elementPtr != (TuiWinElementPtr) NULL &&
elementPtr->whichElement.locator.addr > (Opaque) 0)
sprintf (pc, "0x%x",
elementPtr->whichElement.locator.addr);
else
strcpy (pc, "??");
/*
** 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;
/* Filename */
strcat_to_buf (string, strSize, " ");
strcat_to_buf (string, strSize, FILE_PREFIX);
if (strlen (fname) > fileWidth)
{
strncpy (buf, fname, fileWidth - 1);
buf[fileWidth - 1] = '*';
buf[fileWidth] = (char) 0;
}
else
strcpy (buf, fname);
strcat_to_buf (string, strSize, buf);
/* procedure/class name */
sprintf (buf, "%15s", PROC_PREFIX);
strcat_to_buf (string, strSize, buf);
if (strlen (pname) > procWidth)
{
strncpy (buf, pname, procWidth - 1);
buf[procWidth - 1] = '*';
buf[procWidth] = (char) 0;
}
else
strcpy (buf, pname);
strcat_to_buf (string, strSize, buf);
sprintf (buf, "%10s", LINE_PREFIX);
strcat_to_buf (string, strSize, buf);
strcat_to_buf (string, strSize, lineNo);
sprintf (buf, "%10s", PC_PREFIX);
strcat_to_buf (string, strSize, buf);
strcat_to_buf (string, strSize, pc);
for (i = strlen (string); i < strSize; i++)
string[i] = ' ';
string[strSize] = (char) 0;
}
break;
case EXEC_INFO_WIN:
string = elementPtr->whichElement.simpleString;
break;
default:
break;
}
}
return string;
} /* displayableWinContentOf */
 
 
/*
** winContentAt().
** Answer a the content at the location indicated by index
*/
char *
#ifdef __STDC__
displayableWinContentAt (
TuiGenWinInfoPtr winInfo,
int index)
#else
displayableWinContentAt (winInfo, index)
TuiGenWinInfoPtr winInfo;
int index;
#endif
{
return (displayableWinContentOf (winInfo, (TuiWinElementPtr) winInfo->content[index]));
} /* winContentAt */
 
 
/*
** winElementHeight().
** Answer the height of the element in lines
*/
int
#ifdef __STDC__
winElementHeight (
TuiGenWinInfoPtr winInfo,
TuiWinElementPtr element)
#else
winElementHeight (winInfo, element)
TuiGenWinInfoPtr winInfo;
TuiWinElementPtr element;
#endif
{
int h;
 
if (winInfo->type == DATA_WIN)
/* FOR NOW SAY IT IS ONLY ONE LINE HIGH */
h = 1;
else
h = 1;
 
return h;
} /* winElementHeight */
 
 
/*
** winByName().
** Answer the window represented by name
*/
TuiWinInfoPtr
#ifdef __STDC__
winByName (
char *name)
#else
winByName (name)
char *name;
#endif
{
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
int i = 0;
 
while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
{
if (strcmp (name, winName (&(winList[i]->generic))) == 0)
winInfo = winList[i];
i++;
}
 
return winInfo;
} /* winByName */
 
 
/*
** partialWinByName().
** Answer the window represented by name
*/
TuiWinInfoPtr
#ifdef __STDC__
partialWinByName (
char *name)
#else
partialWinByName (name)
char *name;
#endif
{
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
 
if (name != (char *) NULL)
{
int i = 0;
 
while (i < MAX_MAJOR_WINDOWS && m_winPtrIsNull (winInfo))
{
char *curName = winName (&winList[i]->generic);
if (strlen (name) <= strlen (curName) &&
strncmp (name, curName, strlen (name)) == 0)
winInfo = winList[i];
i++;
}
}
 
return winInfo;
} /* partialWinByName */
 
 
/*
** winName().
** Answer the name of the window
*/
char *
#ifdef __STDC__
winName (
TuiGenWinInfoPtr winInfo)
#else
winName (winInfo)
TuiGenWinInfoPtr winInfo;
#endif
{
char *name = (char *) NULL;
 
switch (winInfo->type)
{
case SRC_WIN:
name = SRC_NAME;
break;
case CMD_WIN:
name = CMD_NAME;
break;
case DISASSEM_WIN:
name = DISASSEM_NAME;
break;
case DATA_WIN:
name = DATA_NAME;
break;
default:
name = "";
break;
}
 
return name;
} /* winName */
 
 
/*
** initializeStaticData
*/
void
#ifdef __STDC__
initializeStaticData (void)
#else
initializeStaticData ()
#endif
{
initGenericPart (sourceExecInfoWinPtr ());
initGenericPart (disassemExecInfoWinPtr ());
initGenericPart (locatorWinInfoPtr ());
 
return;
} /* initializeStaticData */
 
 
/*
** allocGenericWinInfo().
*/
TuiGenWinInfoPtr
#ifdef __STDC__
allocGenericWinInfo (void)
#else
allocGenericWinInfo ()
#endif
{
TuiGenWinInfoPtr win;
 
if ((win = (TuiGenWinInfoPtr) xmalloc (
sizeof (TuiGenWinInfoPtr))) != (TuiGenWinInfoPtr) NULL)
initGenericPart (win);
 
return win;
} /* allocGenericWinInfo */
 
 
/*
** initGenericPart().
*/
void
#ifdef __STDC__
initGenericPart (
TuiGenWinInfoPtr win)
#else
initGenericPart (win)
TuiGenWinInfoPtr win;
#endif
{
win->width =
win->height =
win->origin.x =
win->origin.y =
win->viewportHeight =
win->contentSize =
win->lastVisibleLine = 0;
win->handle = (WINDOW *) NULL;
win->content = (OpaquePtr) NULL;
win->contentInUse =
win->isVisible = FALSE;
 
return;
} /* initGenericPart */
 
 
/*
** initContentElement().
*/
void
#ifdef __STDC__
initContentElement (
TuiWinElementPtr element,
TuiWinType type)
#else
initContentElement (element, type)
TuiWinElementPtr element;
TuiWinType type;
#endif
{
element->highlight = FALSE;
switch (type)
{
case SRC_WIN:
case DISASSEM_WIN:
element->whichElement.source.line = (char *) NULL;
element->whichElement.source.lineOrAddr.lineNo = 0;
element->whichElement.source.isExecPoint = FALSE;
element->whichElement.source.hasBreak = FALSE;
break;
case DATA_WIN:
initGenericPart (&element->whichElement.dataWindow);
element->whichElement.dataWindow.type = DATA_ITEM_WIN;
((TuiGenWinInfoPtr) & element->whichElement.dataWindow)->content =
(OpaquePtr) allocContent (1, DATA_ITEM_WIN);
((TuiGenWinInfoPtr)
& element->whichElement.dataWindow)->contentSize = 1;
break;
case CMD_WIN:
element->whichElement.command.line = (char *) NULL;
break;
case DATA_ITEM_WIN:
element->whichElement.data.name = (char *) NULL;
element->whichElement.data.type = TUI_REGISTER;
element->whichElement.data.itemNo = UNDEFINED_ITEM;
element->whichElement.data.value = (Opaque) NULL;
element->whichElement.data.highlight = FALSE;
break;
case LOCATOR_WIN:
element->whichElement.locator.fileName[0] =
element->whichElement.locator.procName[0] = (char) 0;
element->whichElement.locator.lineNo = 0;
element->whichElement.locator.addr = 0;
break;
case EXEC_INFO_WIN:
element->whichElement.simpleString = blankStr ();
break;
default:
break;
}
return;
} /* initContentElement */
 
/*
** initWinInfo().
*/
void
#ifdef __STDC__
initWinInfo (
TuiWinInfoPtr winInfo)
#else
initWinInfo (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
initGenericPart (&winInfo->generic);
winInfo->canHighlight =
winInfo->isHighlighted = FALSE;
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
winInfo->detail.sourceInfo.executionInfo = (TuiGenWinInfoPtr) NULL;
winInfo->detail.sourceInfo.hasLocator = FALSE;
winInfo->detail.sourceInfo.horizontalOffset = 0;
winInfo->detail.sourceInfo.startLineOrAddr.addr = (Opaque) NULL;
break;
case DATA_WIN:
winInfo->detail.dataDisplayInfo.dataContent = (TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.dataContentCount = 0;
winInfo->detail.dataDisplayInfo.regsContent = (TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.regsContentCount = 0;
winInfo->detail.dataDisplayInfo.regsDisplayType =
TUI_UNDEFINED_REGS;
winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
break;
case CMD_WIN:
winInfo->detail.commandInfo.curLine = 0;
winInfo->detail.commandInfo.curch = 0;
break;
default:
winInfo->detail.opaque = (Opaque) NULL;
break;
}
 
return;
} /* initWinInfo */
 
 
/*
** allocWinInfo().
*/
TuiWinInfoPtr
#ifdef __STDC__
allocWinInfo (
TuiWinType type)
#else
allocWinInfo (type)
TuiWinType type;
#endif
{
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) NULL;
 
winInfo = (TuiWinInfoPtr) xmalloc (sizeof (TuiWinInfo));
if (m_winPtrNotNull (winInfo))
{
winInfo->generic.type = type;
initWinInfo (winInfo);
}
 
return winInfo;
} /* allocWinInfo */
 
 
/*
** allocContent().
** Allocates the content and elements in a block.
*/
TuiWinContent
#ifdef __STDC__
allocContent (
int numElements,
TuiWinType type)
#else
allocContent (numElements, type)
int numElements;
TuiWinType type;
#endif
{
TuiWinContent content = (TuiWinContent) NULL;
char *elementBlockPtr = (char *) NULL;
int i;
 
if ((content = (TuiWinContent)
xmalloc (sizeof (TuiWinElementPtr) * numElements)) != (TuiWinContent) NULL)
{ /*
** All windows, except the data window, can allocate the elements
** in a chunk. The data window cannot because items can be
** added/removed from the data display by the user at any time.
*/
if (type != DATA_WIN)
{
if ((elementBlockPtr = (char *)
xmalloc (sizeof (TuiWinElement) * numElements)) != (char *) NULL)
{
for (i = 0; i < numElements; i++)
{
content[i] = (TuiWinElementPtr) elementBlockPtr;
initContentElement (content[i], type);
elementBlockPtr += sizeof (TuiWinElement);
}
}
else
{
tuiFree ((char *) content);
content = (TuiWinContent) NULL;
}
}
}
 
return content;
} /* allocContent */
 
 
/*
** addContentElements().
** Adds the input number of elements to the windows's content. If
** no content has been allocated yet, allocContent() is called to
** do this. The index of the first element added is returned,
** unless there is a memory allocation error, in which case, (-1)
** is returned.
*/
int
#ifdef __STDC__
addContentElements (
TuiGenWinInfoPtr winInfo,
int numElements)
#else
addContentElements (winInfo, numElements)
TuiGenWinInfoPtr winInfo;
int numElements;
#endif
{
TuiWinElementPtr elementPtr;
int i, indexStart;
 
if (winInfo->content == (OpaquePtr) NULL)
{
winInfo->content = (OpaquePtr) allocContent (numElements, winInfo->type);
indexStart = 0;
}
else
indexStart = winInfo->contentSize;
if (winInfo->content != (OpaquePtr) NULL)
{
for (i = indexStart; (i < numElements + indexStart); i++)
{
if ((elementPtr = (TuiWinElementPtr)
xmalloc (sizeof (TuiWinElement))) != (TuiWinElementPtr) NULL)
{
winInfo->content[i] = (Opaque) elementPtr;
initContentElement (elementPtr, winInfo->type);
winInfo->contentSize++;
}
else /* things must be really hosed now! We ran out of memory!? */
return (-1);
}
}
 
return indexStart;
} /* addContentElements */
 
 
/*
** tuiDelWindow().
** Delete all curses windows associated with winInfo, leaving everything
** else in tact.
*/
void
#ifdef __STDC__
tuiDelWindow (
TuiWinInfoPtr winInfo)
#else
tuiDelWindow (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
Opaque detail;
int i;
TuiGenWinInfoPtr genericWin;
 
 
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
genericWin = locatorWinInfoPtr ();
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
genericWin->isVisible = FALSE;
}
genericWin = winInfo->detail.sourceInfo.executionInfo;
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
genericWin->isVisible = FALSE;
}
break;
case DATA_WIN:
if (winInfo->generic.content != (OpaquePtr) NULL)
{
int i;
 
tuiDelDataWindows (
winInfo->detail.dataDisplayInfo.regsContent,
winInfo->detail.dataDisplayInfo.regsContentCount);
tuiDelDataWindows (
winInfo->detail.dataDisplayInfo.dataContent,
winInfo->detail.dataDisplayInfo.dataContentCount);
}
break;
default:
break;
}
if (winInfo->generic.handle != (WINDOW *) NULL)
{
tuiDelwin (winInfo->generic.handle);
winInfo->generic.handle = (WINDOW *) NULL;
winInfo->generic.isVisible = FALSE;
}
 
return;
} /* tuiDelWindow */
 
 
/*
** freeWindow().
*/
void
#ifdef __STDC__
freeWindow (
TuiWinInfoPtr winInfo)
#else
freeWindow (winInfo)
TuiWinInfoPtr winInfo;
#endif
{
Opaque detail;
int i;
TuiGenWinInfoPtr genericWin;
 
 
switch (winInfo->generic.type)
{
case SRC_WIN:
case DISASSEM_WIN:
genericWin = locatorWinInfoPtr ();
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
}
freeWinContent (genericWin);
genericWin = winInfo->detail.sourceInfo.executionInfo;
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
freeWinContent (genericWin);
}
break;
case DATA_WIN:
if (winInfo->generic.content != (OpaquePtr) NULL)
{
freeDataContent (
winInfo->detail.dataDisplayInfo.regsContent,
winInfo->detail.dataDisplayInfo.regsContentCount);
winInfo->detail.dataDisplayInfo.regsContent =
(TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.regsContentCount = 0;
freeDataContent (
winInfo->detail.dataDisplayInfo.dataContent,
winInfo->detail.dataDisplayInfo.dataContentCount);
winInfo->detail.dataDisplayInfo.dataContent =
(TuiWinContent) NULL;
winInfo->detail.dataDisplayInfo.dataContentCount = 0;
winInfo->detail.dataDisplayInfo.regsDisplayType =
TUI_UNDEFINED_REGS;
winInfo->detail.dataDisplayInfo.regsColumnCount = 1;
winInfo->detail.dataDisplayInfo.displayRegs = FALSE;
winInfo->generic.content = (OpaquePtr) NULL;
winInfo->generic.contentSize = 0;
}
break;
default:
break;
}
if (winInfo->generic.handle != (WINDOW *) NULL)
{
tuiDelwin (winInfo->generic.handle);
winInfo->generic.handle = (WINDOW *) NULL;
freeWinContent (&winInfo->generic);
}
free (winInfo);
 
return;
} /* freeWindow */
 
 
/*
** freeAllSourceWinsContent().
*/
void
#ifdef __STDC__
freeAllSourceWinsContent (void)
#else
freeAllSourceWinsContent ()
#endif
{
int i;
 
for (i = 0; i < (sourceWindows ())->count; i++)
{
TuiWinInfoPtr winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
 
if (m_winPtrNotNull (winInfo))
{
freeWinContent (&(winInfo->generic));
freeWinContent (winInfo->detail.sourceInfo.executionInfo);
}
}
 
return;
} /* freeAllSourceWinsContent */
 
 
/*
** freeWinContent().
*/
void
#ifdef __STDC__
freeWinContent (
TuiGenWinInfoPtr winInfo)
#else
freeWinContent (winInfo)
TuiGenWinInfoPtr winInfo;
#endif
{
if (winInfo->content != (OpaquePtr) NULL)
{
freeContent ((TuiWinContent) winInfo->content,
winInfo->contentSize,
winInfo->type);
winInfo->content = (OpaquePtr) NULL;
}
winInfo->contentSize = 0;
 
return;
} /* freeWinContent */
 
 
/*
** freeAllWindows().
*/
void
#ifdef __STDC__
freeAllWindows (void)
#else
freeAllWindows ()
#endif
{
TuiWinType type = SRC_WIN;
 
for (; type < MAX_MAJOR_WINDOWS; type++)
if (m_winPtrNotNull (winList[type]) &&
winList[type]->generic.type != UNDEFINED_WIN)
freeWindow (winList[type]);
return;
} /* freeAllWindows */
 
 
void
#ifdef __STDC__
tuiDelDataWindows (
TuiWinContent content,
int contentSize)
#else
tuiDelDataWindows (content, contentSize)
TuiWinContent content;
int contentSize;
#endif
{
int i;
 
/*
** Remember that data window content elements are of type TuiGenWinInfoPtr,
** each of which whose single element is a data element.
*/
for (i = 0; i < contentSize; i++)
{
TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
 
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
genericWin->isVisible = FALSE;
}
}
 
return;
} /* tuiDelDataWindows */
 
 
void
#ifdef __STDC__
freeDataContent (
TuiWinContent content,
int contentSize)
#else
freeDataContent (content, contentSize)
TuiWinContent content;
int contentSize;
#endif
{
int i;
 
/*
** Remember that data window content elements are of type TuiGenWinInfoPtr,
** each of which whose single element is a data element.
*/
for (i = 0; i < contentSize; i++)
{
TuiGenWinInfoPtr genericWin = &content[i]->whichElement.dataWindow;
 
if (genericWin != (TuiGenWinInfoPtr) NULL)
{
tuiDelwin (genericWin->handle);
genericWin->handle = (WINDOW *) NULL;
freeWinContent (genericWin);
}
}
freeContent (content,
contentSize,
DATA_WIN);
 
return;
} /* freeDataContent */
 
 
/**********************************
** LOCAL STATIC FUNCTIONS **
**********************************/
 
 
/*
** freeContent().
*/
static void
#ifdef __STDC__
freeContent (
TuiWinContent content,
int contentSize,
TuiWinType winType)
#else
freeContent (content, contentSize, winType)
TuiWinContent content;
int contentSize;
TuiWinType winType;
#endif
{
if (content != (TuiWinContent) NULL)
{
freeContentElements (content, contentSize, winType);
tuiFree ((char *) content);
}
 
return;
} /* freeContent */
 
 
/*
** freeContentElements().
*/
static void
#ifdef __STDC__
freeContentElements (
TuiWinContent content,
int contentSize,
TuiWinType type)
#else
freeContentElements (content, contentSize, type)
TuiWinContent content;
int contentSize;
TuiWinType type;
#endif
{
if (content != (TuiWinContent) NULL)
{
int i;
 
if (type == SRC_WIN || type == DISASSEM_WIN)
{
/* free whole source block */
if (content[0]->whichElement.source.line != (char *) NULL)
tuiFree (content[0]->whichElement.source.line);
}
else
{
for (i = 0; i < contentSize; i++)
{
TuiWinElementPtr element;
 
element = content[i];
if (element != (TuiWinElementPtr) NULL)
{
switch (type)
{
case DATA_WIN:
tuiFree ((char *) element);
break;
case DATA_ITEM_WIN:
/*
** Note that data elements are not allocated
** in a single block, but individually, as needed.
*/
if (element->whichElement.data.type != TUI_REGISTER)
tuiFree ((char *)
element->whichElement.data.name);
tuiFree ((char *) element->whichElement.data.value);
tuiFree ((char *) element);
break;
case CMD_WIN:
tuiFree ((char *) element->whichElement.command.line);
break;
default:
break;
}
}
}
}
if (type != DATA_WIN && type != DATA_ITEM_WIN)
tuiFree ((char *) content[0]); /* free the element block */
}
 
return;
} /* freeContentElements */
/tuiStack.h
0,0 → 1,23
#ifndef _TUI_STACK_H
#define _TUI_STACK_H
/*
** This header file supports
*/
 
extern void tuiSetLocatorInfo PARAMS ((char *, char *, int, Opaque, TuiLocatorElementPtr));
extern void tuiUpdateLocatorFilename PARAMS ((char *));
extern void tui_vUpdateLocatorFilename PARAMS ((va_list));
extern void tuiUpdateLocatorInfoFromFrame
PARAMS ((struct frame_info *, TuiLocatorElementPtr));
extern void tuiUpdateLocatorDisplay PARAMS ((struct frame_info *));
extern void tuiSetLocatorContent PARAMS ((struct frame_info *));
extern void tuiShowLocatorContent PARAMS ((void));
extern void tuiClearLocatorContent PARAMS ((void));
extern void tuiSwitchFilename PARAMS ((char *));
extern void tuiShowFrameInfo PARAMS ((struct frame_info *));
extern void tui_vShowFrameInfo PARAMS ((va_list));
extern void tuiGetLocatorFilename PARAMS ((TuiGenWinInfoPtr, char **));
 
 
#endif
/*_TUI_STACK_H*/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.