| /* |
| ** 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 ** |
| ******************************************/ |