diff options
| -rw-r--r-- | gdb/tui/.Sanitize | 64 | ||||
| -rw-r--r-- | gdb/tui/ChangeLog | 116 | ||||
| -rw-r--r-- | gdb/tui/Makefile.in | 168 | ||||
| -rw-r--r-- | gdb/tui/tuiCommand.c | 215 | ||||
| -rw-r--r-- | gdb/tui/tuiCommand.h | 24 | ||||
| -rw-r--r-- | gdb/tui/tuiData.c | 1624 | ||||
| -rw-r--r-- | gdb/tui/tuiData.h | 302 | ||||
| -rw-r--r-- | gdb/tui/tuiDataWin.c | 400 | ||||
| -rw-r--r-- | gdb/tui/tuiDataWin.h | 29 | ||||
| -rw-r--r-- | gdb/tui/tuiDisassem.c | 343 | ||||
| -rw-r--r-- | gdb/tui/tuiDisassem.h | 22 | ||||
| -rw-r--r-- | gdb/tui/tuiGeneralWin.c | 469 | ||||
| -rw-r--r-- | gdb/tui/tuiGeneralWin.h | 31 | ||||
| -rw-r--r-- | gdb/tui/tuiIO.c | 734 | ||||
| -rw-r--r-- | gdb/tui/tuiIO.h | 43 | ||||
| -rw-r--r-- | gdb/tui/tuiLayout.c | 1410 | ||||
| -rw-r--r-- | gdb/tui/tuiLayout.h | 15 | ||||
| -rw-r--r-- | gdb/tui/tuiRegs.c | 1210 | ||||
| -rw-r--r-- | gdb/tui/tuiRegs.h | 28 | ||||
| -rw-r--r-- | gdb/tui/tuiSource.c | 465 | ||||
| -rw-r--r-- | gdb/tui/tuiSource.h | 27 | ||||
| -rw-r--r-- | gdb/tui/tuiSourceWin.c | 1098 | ||||
| -rw-r--r-- | gdb/tui/tuiSourceWin.h | 74 | ||||
| -rw-r--r-- | gdb/tui/tuiStack.c | 554 | ||||
| -rw-r--r-- | gdb/tui/tuiStack.h | 22 | ||||
| -rw-r--r-- | gdb/tui/tuiWin.c | 1650 | ||||
| -rw-r--r-- | gdb/tui/tuiWin.h | 28 |
27 files changed, 11165 insertions, 0 deletions
diff --git a/gdb/tui/.Sanitize b/gdb/tui/.Sanitize new file mode 100644 index 0000000..16d5f59 --- /dev/null +++ b/gdb/tui/.Sanitize @@ -0,0 +1,64 @@ +# .Sanitize for devo/gdb/tui. + +# Each directory to survive its way into a release will need a file +# like this one called "./.Sanitize". All keyword lines must exist, +# and must exist in the order specified by this file. Each directory +# in the tree will be processed, top down, in the following order. + +# Hash started lines like this one are comments and will be deleted +# before anything else is done. Blank lines will also be squashed +# out. + +# The lines between the "Do-first:" line and the "Things-to-keep:" +# line are executed as a /bin/sh shell script before anything else is +# done in this directory. + +Do-first: + +# All files listed between the "Things-to-keep:" line and the +# "Files-to-sed:" line will be kept. All other files will be removed. +# Directories listed in this section will have their own Sanitize +# called. Directories not listed will be removed in their entirety +# with rm -rf. + +Things-to-keep: + +Makefile.in +tui.c +tui.h +tuiCommand.c +tuiCommand.h +tuiData.c +tuiData.h +tuiDataWin.c +tuiDataWin.h +tuiDisassem.c +tuiDisassem.h +tuiGeneralWin.c +tuiGeneralWin.h +tuiIO.c +tuiIO.h +tuiLayout.c +tuiLayout.h +tuiRegs.c +tuiRegs.h +tuiSource.c +tuiSource.h +tuiSourceWin.c +tuiSourceWin.h +tuiStack.c +tuiStack.h +tuiWin.c +tuiWin.h + +# Things which are explicitly *not* kept, for now. + +Things-to-lose: + +Do-last: + +# Don't try to clean directories here, as the 'mv' command will fail. +# Also, grep fails on NFS mounted directories. + +# +# End of file. diff --git a/gdb/tui/ChangeLog b/gdb/tui/ChangeLog new file mode 100644 index 0000000..8e8b92d --- /dev/null +++ b/gdb/tui/ChangeLog @@ -0,0 +1,116 @@ +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. diff --git a/gdb/tui/Makefile.in b/gdb/tui/Makefile.in new file mode 100644 index 0000000..256464b --- /dev/null +++ b/gdb/tui/Makefile.in @@ -0,0 +1,168 @@ +# 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: + rm -f *.o *.a diff --git a/gdb/tui/tuiCommand.c b/gdb/tui/tuiCommand.c new file mode 100644 index 0000000..454dc62 --- /dev/null +++ b/gdb/tui/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 ** +******************************************/ diff --git a/gdb/tui/tuiCommand.h b/gdb/tui/tuiCommand.h new file mode 100644 index 0000000..206d918 --- /dev/null +++ b/gdb/tui/tuiCommand.h @@ -0,0 +1,24 @@ +#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*/ diff --git a/gdb/tui/tuiData.c b/gdb/tui/tuiData.c new file mode 100644 index 0000000..758a6cd --- /dev/null +++ b/gdb/tui/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 */ diff --git a/gdb/tui/tuiData.h b/gdb/tui/tuiData.h new file mode 100644 index 0000000..bb4d19c --- /dev/null +++ b/gdb/tui/tuiData.h @@ -0,0 +1,302 @@ +#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 */ diff --git a/gdb/tui/tuiDataWin.c b/gdb/tui/tuiDataWin.c new file mode 100644 index 0000000..522730a --- /dev/null +++ b/gdb/tui/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 ** +******************************************/ diff --git a/gdb/tui/tuiDataWin.h b/gdb/tui/tuiDataWin.h new file mode 100644 index 0000000..8f9e46d --- /dev/null +++ b/gdb/tui/tuiDataWin.h @@ -0,0 +1,29 @@ +#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*/ diff --git a/gdb/tui/tuiDisassem.c b/gdb/tui/tuiDisassem.c new file mode 100644 index 0000000..ad0b70f --- /dev/null +++ b/gdb/tui/tuiDisassem.c @@ -0,0 +1,343 @@ +/* +** 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; + GDB_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 gdb_file structure */ + gdb_dis_out = gdb_file_init_astring (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 (gdb_file_get_strbuf (gdb_dis_out)); + i = curLen - ((curLen / tab_len) * tab_len); + + /* adjust buffer length if necessary */ + gdb_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) + { + gdb_file_get_strbuf (gdb_dis_out)[curLen] = ' '; + i++; + curLen++; + } + gdb_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 (gdb_file_get_strbuf (gdb_dis_out)) > offset) + strcpy (element->whichElement.source.line, + &(gdb_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 */ + gdb_file_get_strbuf (gdb_dis_out)[0] = '\0'; + } + gdb_file_deallocate (&gdb_dis_out); + 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 */ diff --git a/gdb/tui/tuiDisassem.h b/gdb/tui/tuiDisassem.h new file mode 100644 index 0000000..711ac48 --- /dev/null +++ b/gdb/tui/tuiDisassem.h @@ -0,0 +1,22 @@ +#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*/ diff --git a/gdb/tui/tuiGeneralWin.c b/gdb/tui/tuiGeneralWin.c new file mode 100644 index 0000000..5af0cd7 --- /dev/null +++ b/gdb/tui/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 +*********************************/ diff --git a/gdb/tui/tuiGeneralWin.h b/gdb/tui/tuiGeneralWin.h new file mode 100644 index 0000000..559f8ab --- /dev/null +++ b/gdb/tui/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*/ diff --git a/gdb/tui/tuiIO.c b/gdb/tui/tuiIO.c new file mode 100644 index 0000000..29a3613 --- /dev/null +++ b/gdb/tui/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, + GDB_FILE * stream) +#else +tuiPuts_unfiltered (string, stream) + char *string; + GDB_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 */ diff --git a/gdb/tui/tuiIO.h b/gdb/tui/tuiIO.h new file mode 100644 index 0000000..bcbeffe --- /dev/null +++ b/gdb/tui/tuiIO.h @@ -0,0 +1,43 @@ +#ifndef _TUI_IO_H +#define _TUI_IO_H +/* +** This header contains defitions to support tuiIO.c +*/ + + +#include <stdio.h> + +extern void tuiPuts_unfiltered PARAMS ((const char *, GDB_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*/ diff --git a/gdb/tui/tuiLayout.c b/gdb/tui/tuiLayout.c new file mode 100644 index 0000000..6aa380c --- /dev/null +++ b/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 */ diff --git a/gdb/tui/tuiLayout.h b/gdb/tui/tuiLayout.h new file mode 100644 index 0000000..57d8bbc --- /dev/null +++ b/gdb/tui/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*/ diff --git a/gdb/tui/tuiRegs.c b/gdb/tui/tuiRegs.c new file mode 100644 index 0000000..b78b9bc --- /dev/null +++ b/gdb/tui/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; + GDB_FILE *stream; + + stream = gdb_file_init_astring(bufLen); + pa_do_strcat_registers_info (regNum, 0, stream, precision); + strcpy (buf, gdb_file_get_strbuf(stream)); + gdb_file_deallocate(&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 */ diff --git a/gdb/tui/tuiRegs.h b/gdb/tui/tuiRegs.h new file mode 100644 index 0000000..4a777ec --- /dev/null +++ b/gdb/tui/tuiRegs.h @@ -0,0 +1,28 @@ +#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*/ diff --git a/gdb/tui/tuiSource.c b/gdb/tui/tuiSource.c new file mode 100644 index 0000000..e0259d0 --- /dev/null +++ b/gdb/tui/tuiSource.c @@ -0,0 +1,465 @@ +/* +** 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 "tui.h" +#include "tuiData.h" +#include "tuiStack.h" +#include "tuiSourceWin.h" +#include "tuiSource.h" + + +/***************************************** +** EXTERNAL FUNCTION DECLS ** +******************************************/ + +extern int open_source_file PARAMS ((struct symtab *)); +extern void find_source_lines PARAMS ((struct symtab *, int)); + +/***************************************** +** 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 */ diff --git a/gdb/tui/tuiSource.h b/gdb/tui/tuiSource.h new file mode 100644 index 0000000..f898c61 --- /dev/null +++ b/gdb/tui/tuiSource.h @@ -0,0 +1,27 @@ +#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*/ diff --git a/gdb/tui/tuiSourceWin.c b/gdb/tui/tuiSourceWin.c new file mode 100644 index 0000000..e203925 --- /dev/null +++ b/gdb/tui/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 ** +******************************************/ diff --git a/gdb/tui/tuiSourceWin.h b/gdb/tui/tuiSourceWin.h new file mode 100644 index 0000000..13f3a78 --- /dev/null +++ b/gdb/tui/tuiSourceWin.h @@ -0,0 +1,74 @@ +#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 */ diff --git a/gdb/tui/tuiStack.c b/gdb/tui/tuiStack.c new file mode 100644 index 0000000..401dfe2 --- /dev/null +++ b/gdb/tui/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 */ diff --git a/gdb/tui/tuiStack.h b/gdb/tui/tuiStack.h new file mode 100644 index 0000000..20e9a92 --- /dev/null +++ b/gdb/tui/tuiStack.h @@ -0,0 +1,22 @@ +#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*/ diff --git a/gdb/tui/tuiWin.c b/gdb/tui/tuiWin.c new file mode 100644 index 0000000..45bb0f6 --- /dev/null +++ b/gdb/tui/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 */ diff --git a/gdb/tui/tuiWin.h b/gdb/tui/tuiWin.h new file mode 100644 index 0000000..cb8455d --- /dev/null +++ b/gdb/tui/tuiWin.h @@ -0,0 +1,28 @@ +#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*/ |