diff options
Diffstat (limited to 'contrib/gdb/gdb/tui/tuiLayout.c')
| -rw-r--r-- | contrib/gdb/gdb/tui/tuiLayout.c | 1410 |
1 files changed, 1410 insertions, 0 deletions
diff --git a/contrib/gdb/gdb/tui/tuiLayout.c b/contrib/gdb/gdb/tui/tuiLayout.c new file mode 100644 index 0000000..6aa380c --- /dev/null +++ b/contrib/gdb/gdb/tui/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 */ |
