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