[deliverable/binutils-gdb.git] / gdb / tui / tui.c

/* General functions for the WDB TUI.
   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   Contributed by Hewlett-Packard Company.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <malloc.h>
#ifdef HAVE_TERM_H
#include <term.h>
#endif
#include <signal.h>
#include <fcntl.h>
#include <termio.h>
#include <setjmp.h>
#include "defs.h"
#include "gdbcmd.h"
#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiIO.h"
#include "tuiRegs.h"
#include "tuiStack.h"
#include "tuiWin.h"
#include "tuiSourceWin.h"
#include "readline/readline.h"
#include "target.h"
#include "frame.h"
#include "breakpoint.h"
#include "inferior.h"

/* Tells whether the TUI is active or not.  */
int tui_active = 0;
static int tui_finish_init = 1;

/* Switch the output mode between TUI/standard gdb.  */
static int
tui_switch_mode (void)
{
  if (tui_active)
    {
      tui_disable ();
      rl_prep_terminal (0);

      printf_filtered ("Left the TUI mode\n");
    }
  else
    {
      rl_deprep_terminal ();
      tui_enable ();
      printf_filtered ("Entered the TUI mode\n");
    }

  /* Clear the readline in case switching occurred in middle of something.  */
  if (rl_end)
    rl_kill_text (0, rl_end);

  /* Since we left the curses mode, the terminal mode is restored to
     some previous state.  That state may not be suitable for readline
     to work correctly (it may be restored in line mode).  We force an
     exit of the current readline so that readline is re-entered and it
     will be able to setup the terminal for its needs.  By re-entering
     in readline, we also redisplay its prompt in the non-curses mode.  */
  rl_newline (1, '\n');

  /* Make sure the \n we are returning does not repeat the last command.  */
  dont_repeat ();
  return 0;
}

/* Change the TUI layout to show a next layout.
   This function is bound to CTRL-X 2.  It is intended to provide
   a functionality close to the Emacs split-window command.  We always
   show two windows (src+asm), (src+regs) or (asm+regs).  */
static int
tui_change_windows (void)
{
  if (!tui_active)
    tui_switch_mode ();

  if (tui_active)
    {
      TuiLayoutType new_layout;
      TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;

      new_layout = currentLayout ();

      /* Select a new layout to have a rolling layout behavior
	 with always two windows (except when undefined).  */
      switch (new_layout)
	{
	case SRC_COMMAND:
	  new_layout = SRC_DISASSEM_COMMAND;
	  break;

	case DISASSEM_COMMAND:
	  new_layout = SRC_DISASSEM_COMMAND;
	  break;

	case SRC_DATA_COMMAND:
	  new_layout = SRC_DISASSEM_COMMAND;
	  break;

	case SRC_DISASSEM_COMMAND:
	  new_layout = DISASSEM_DATA_COMMAND;
	  break;
	  
	case DISASSEM_DATA_COMMAND:
	  new_layout = SRC_DATA_COMMAND;
	  break;

	default:
	  new_layout = SRC_COMMAND;
	  break;
	}
      tuiSetLayout (new_layout, regs_type);
    }
  return 0;
}


/* Delete the second TUI window to only show one.  */
static int
tui_delete_other_windows (void)
{
  if (!tui_active)
    tui_switch_mode ();

  if (tui_active)
    {
      TuiLayoutType new_layout;
      TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;

      new_layout = currentLayout ();

      /* Kill one window.  */
      switch (new_layout)
	{
	case SRC_COMMAND:
	case SRC_DATA_COMMAND:
	case SRC_DISASSEM_COMMAND:
	default:
	  new_layout = SRC_COMMAND;
	  break;

	case DISASSEM_COMMAND:
	case DISASSEM_DATA_COMMAND:
	  new_layout = DISASSEM_COMMAND;
	  break;
	}
      tuiSetLayout (new_layout, regs_type);
    }
  return 0;
}

/* Initialize readline and configure the keymap for the switching
   key shortcut.  */
void
tui_initialize_readline ()
{
  rl_initialize ();

  rl_add_defun ("tui-switch-mode", tui_switch_mode, -1);
  rl_bind_key_in_map ('a', tui_switch_mode, emacs_ctlx_keymap);
  rl_bind_key_in_map ('A', tui_switch_mode, emacs_ctlx_keymap);
  rl_bind_key_in_map (CTRL ('A'), tui_switch_mode, emacs_ctlx_keymap);
  rl_bind_key_in_map ('1', tui_delete_other_windows, emacs_ctlx_keymap);
  rl_bind_key_in_map ('2', tui_change_windows, emacs_ctlx_keymap);
}

/* Enter in the tui mode (curses).
   When in normal mode, it installs the tui hooks in gdb, redirects
   the gdb output, configures the readline to work in tui mode.
   When in curses mode, it does nothing.  */
void
tui_enable (void)
{
  if (tui_active)
    return;

  /* To avoid to initialize curses when gdb starts, there is a defered
     curses initialization.  This initialization is made only once
     and the first time the curses mode is entered.  */
  if (tui_finish_init)
    {
      WINDOW *w;

      w = initscr ();
  
      cbreak ();
      noecho ();
      /*timeout (1);*/
      nodelay(w, FALSE);
      nl();
      keypad (w, TRUE);
      rl_initialize ();
      setTermHeightTo (LINES);
      setTermWidthTo (COLS);
      def_prog_mode ();

      tuiSetLocatorContent (0);
      showLayout (SRC_COMMAND);
      tuiSetWinFocusTo (srcWin);
      keypad (cmdWin->generic.handle, TRUE);
      wrefresh (cmdWin->generic.handle);
      tui_finish_init = 0;
    }
  else
    {
     /* Save the current gdb setting of the terminal.
        Curses will restore this state when endwin() is called.  */
     def_shell_mode ();
     clearok (stdscr, TRUE);
   }

  /* Install the TUI specific hooks.  */
  tui_install_hooks ();

  tui_update_variables ();
  
  tui_setup_io (1);

  tui_version = 1;
  tui_active = 1;
  refresh ();
}

/* Leave the tui mode.
   Remove the tui hooks and configure the gdb output and readline
   back to their original state.  The curses mode is left so that
   the terminal setting is restored to the point when we entered.  */
void
tui_disable (void)
{
  if (!tui_active)
    return;

  /* Remove TUI hooks.  */
  tui_remove_hooks ();

  /* Leave curses and restore previous gdb terminal setting.  */
  endwin ();

  /* gdb terminal has changed, update gdb internal copy of it
     so that terminal management with the inferior works.  */
  tui_setup_io (0);

  tui_version = 0;
  tui_active = 0;
}

/* Wrapper on top of free() to ensure that input address
   is greater than 0x0.  */
void
tuiFree (char *ptr)
{
  if (ptr != (char *) NULL)
    {
      xfree (ptr);
    }
}

/* Determine what the low address will be to display in the TUI's
   disassembly window.  This may or may not be the same as the
   low address input.  */
CORE_ADDR
tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
{
  int line;
  CORE_ADDR newLow;

  /* Determine where to start the disassembly so that the pc is about in the
     middle of the viewport.  */
  for (line = 0, newLow = pc;
       (newLow > low &&
	line < (tuiDefaultWinViewportHeight (DISASSEM_WIN,
					     DISASSEM_COMMAND) / 2));)
    {
      bfd_byte buffer[4];

      newLow -= sizeof (bfd_getb32 (buffer));
      line++;
    }

  return newLow;
}

void
strcat_to_buf (char *buf, int buflen, char *itemToAdd)
{
  if (itemToAdd != (char *) NULL && buf != (char *) NULL)
    {
      if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
	strcat (buf, itemToAdd);
      else
	strncat (buf, itemToAdd, (buflen - strlen (buf)));
    }
}

#if 0
/* Solaris <sys/termios.h> defines CTRL. */
#ifndef CTRL
#define CTRL(x)         (x & ~0140)
#endif

#define FILEDES         2
#define CHK(val, dft)   (val<=0 ? dft : val)

static void
_tuiReset (void)
{
  struct termio mode;

  /*
     ** reset the teletype mode bits to a sensible state.
     ** Copied tset.c
   */
#if ! defined (USG) && defined (TIOCGETC)
  struct tchars tbuf;
#endif /* !USG && TIOCGETC */
#ifdef UCB_NTTY
  struct ltchars ltc;

  if (ldisc == NTTYDISC)
    {
      ioctl (FILEDES, TIOCGLTC, &ltc);
      ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
      ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
      ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
      ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
      ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
      ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
      ioctl (FILEDES, TIOCSLTC, &ltc);
    }
#endif /* UCB_NTTY */
#ifndef USG
#ifdef TIOCGETC
  ioctl (FILEDES, TIOCGETC, &tbuf);
  tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
  tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
  tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
  tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
  tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
  /* brkc is left alone */
  ioctl (FILEDES, TIOCSETC, &tbuf);
#endif /* TIOCGETC */
  mode.sg_flags &= ~(RAW
#ifdef CBREAK
		     | CBREAK
#endif /* CBREAK */
		     | VTDELAY | ALLDELAY);
  mode.sg_flags |= XTABS | ECHO | CRMOD | ANYP;
#else /*USG */
  ioctl (FILEDES, TCGETA, &mode);
  mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));
  mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));
  mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));

  mode.c_iflag &= ~(IGNBRK | PARMRK | INPCK | INLCR | IGNCR | IUCLC | IXOFF);
  mode.c_iflag |= (BRKINT | ISTRIP | ICRNL | IXON);
  mode.c_oflag &= ~(OLCUC | OCRNL | ONOCR | ONLRET | OFILL | OFDEL |
		    NLDLY | CRDLY | TABDLY | BSDLY | VTDLY | FFDLY);
  mode.c_oflag |= (OPOST | ONLCR);
  mode.c_cflag &= ~(CSIZE | PARODD | CLOCAL);
#ifndef hp9000s800
  mode.c_cflag |= (CS8 | CREAD);
#else /*hp9000s800 */
  mode.c_cflag |= (CS8 | CSTOPB | CREAD);
#endif /* hp9000s800 */
  mode.c_lflag &= ~(XCASE | ECHONL | NOFLSH);
  mode.c_lflag |= (ISIG | ICANON | ECHO | ECHOK);
  ioctl (FILEDES, TCSETAW, &mode);
#endif /* USG */

  return;
}				/* _tuiReset */
#endif

void
tui_show_source (const char *file, int line)
{
  /* make sure that the source window is displayed */
  tuiAddWinToLayout (SRC_WIN);

  tuiUpdateSourceWindowsWithLine (current_source_symtab, line);
  tuiUpdateLocatorFilename (file);
}

void
tui_show_assembly (CORE_ADDR addr)
{
  tuiAddWinToLayout (DISASSEM_WIN);
  tuiUpdateSourceWindowsWithAddr (addr);
}

int
tui_is_window_visible (TuiWinType type)
{
  if (tui_version == 0)
    return 0;

  if (winList[type] == 0)
    return 0;
  
  return winList[type]->generic.isVisible;
}

int
tui_get_command_dimension (int *width, int *height)
{
  if (!tui_version || !m_winPtrNotNull (cmdWin))
    {
      return 0;
    }
  
  *width = cmdWin->generic.width;
  *height = cmdWin->generic.height;
  return 1;
}
Commit	Line	Data
f377b406 SC	1	/* General functions for the WDB TUI.
	2	Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
	3	Contributed by Hewlett-Packard Company.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include <stdio.h>
	23	#include <stdlib.h>
	24	#include <ctype.h>
	25	#include <malloc.h>
c906108c SS	26	#ifdef HAVE_TERM_H
	27	#include <term.h>
	28	#endif
	29	#include <signal.h>
	30	#include <fcntl.h>
	31	#include <termio.h>
	32	#include <setjmp.h>
	33	#include "defs.h"
	34	#include "gdbcmd.h"
	35	#include "tui.h"
	36	#include "tuiData.h"
	37	#include "tuiLayout.h"
	38	#include "tuiIO.h"
	39	#include "tuiRegs.h"
377c38ea	40	#include "tuiStack.h"
c906108c	41	#include "tuiWin.h"
c6f60bcd	42	#include "tuiSourceWin.h"
39db33d6 SC	43	#include "readline/readline.h"
	44	#include "target.h"
	45	#include "frame.h"
	46	#include "breakpoint.h"
c6f60bcd	47	#include "inferior.h"
39db33d6 SC	48
	49	/* Tells whether the TUI is active or not. */
	50	int tui_active = 0;
	51	static int tui_finish_init = 1;
	52
	53	/* Switch the output mode between TUI/standard gdb. */
	54	static int
	55	tui_switch_mode (void)
c906108c	56	{
39db33d6	57	if (tui_active)
c906108c	58	{
39db33d6	59	tui_disable ();
c6f60bcd SC	60	rl_prep_terminal (0);
c6f60bcd SC	61
39db33d6 SC	62	printf_filtered ("Left the TUI mode\n");
	63	}
	64	else
	65	{
c6f60bcd	66	rl_deprep_terminal ();
39db33d6 SC	67	tui_enable ();
39db33d6 SC	68	printf_filtered ("Entered the TUI mode\n");
c906108c	69	}
c906108c	70
39db33d6 SC	71	/* Clear the readline in case switching occurred in middle of something. */
	72	if (rl_end)
	73	rl_kill_text (0, rl_end);
	74
	75	/* Since we left the curses mode, the terminal mode is restored to
	76	some previous state. That state may not be suitable for readline
	77	to work correctly (it may be restored in line mode). We force an
	78	exit of the current readline so that readline is re-entered and it
	79	will be able to setup the terminal for its needs. By re-entering
	80	in readline, we also redisplay its prompt in the non-curses mode. */
	81	rl_newline (1, '\n');
c6f60bcd SC	82
	83	/* Make sure the \n we are returning does not repeat the last command. */
	84	dont_repeat ();
39db33d6 SC	85	return 0;
39db33d6 SC	86	}
c906108c	87
377c38ea SC	88	/* Change the TUI layout to show a next layout.
	89	This function is bound to CTRL-X 2. It is intended to provide
	90	a functionality close to the Emacs split-window command. We always
	91	show two windows (src+asm), (src+regs) or (asm+regs). */
	92	static int
	93	tui_change_windows (void)
	94	{
	95	if (!tui_active)
	96	tui_switch_mode ();
	97
	98	if (tui_active)
	99	{
	100	TuiLayoutType new_layout;
	101	TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;
	102
	103	new_layout = currentLayout ();
	104
	105	/* Select a new layout to have a rolling layout behavior
	106	with always two windows (except when undefined). */
	107	switch (new_layout)
	108	{
	109	case SRC_COMMAND:
	110	new_layout = SRC_DISASSEM_COMMAND;
	111	break;
	112
	113	case DISASSEM_COMMAND:
	114	new_layout = SRC_DISASSEM_COMMAND;
	115	break;
	116
	117	case SRC_DATA_COMMAND:
	118	new_layout = SRC_DISASSEM_COMMAND;
	119	break;
	120
	121	case SRC_DISASSEM_COMMAND:
	122	new_layout = DISASSEM_DATA_COMMAND;
	123	break;
	124
	125	case DISASSEM_DATA_COMMAND:
	126	new_layout = SRC_DATA_COMMAND;
	127	break;
	128
	129	default:
	130	new_layout = SRC_COMMAND;
	131	break;
	132	}
	133	tuiSetLayout (new_layout, regs_type);
	134	}
	135	return 0;
	136	}
	137
	138
	139	/* Delete the second TUI window to only show one. */
	140	static int
	141	tui_delete_other_windows (void)
	142	{
	143	if (!tui_active)
	144	tui_switch_mode ();
	145
	146	if (tui_active)
	147	{
	148	TuiLayoutType new_layout;
	149	TuiRegisterDisplayType regs_type = TUI_UNDEFINED_REGS;
	150
	151	new_layout = currentLayout ();
152
153	/* Kill one window. */
154	switch (new_layout)
155	{
156	case SRC_COMMAND:
157	case SRC_DATA_COMMAND:
158	case SRC_DISASSEM_COMMAND:
159	default:
160	new_layout = SRC_COMMAND;
161	break;
162
163	case DISASSEM_COMMAND:
164	case DISASSEM_DATA_COMMAND:
165	new_layout = DISASSEM_COMMAND;
166	break;
167	}
168	tuiSetLayout (new_layout, regs_type);
169	}
170	return 0;
171	}
172
39db33d6 SC	173	/* Initialize readline and configure the keymap for the switching
39db33d6 SC	174	key shortcut. */
c906108c	175	void
39db33d6	176	tui_initialize_readline ()
c906108c	177	{
39db33d6	178	rl_initialize ();
c906108c	179
39db33d6 SC	180	rl_add_defun ("tui-switch-mode", tui_switch_mode, -1);
	181	rl_bind_key_in_map ('a', tui_switch_mode, emacs_ctlx_keymap);
	182	rl_bind_key_in_map ('A', tui_switch_mode, emacs_ctlx_keymap);
	183	rl_bind_key_in_map (CTRL ('A'), tui_switch_mode, emacs_ctlx_keymap);
377c38ea SC	184	rl_bind_key_in_map ('1', tui_delete_other_windows, emacs_ctlx_keymap);
377c38ea SC	185	rl_bind_key_in_map ('2', tui_change_windows, emacs_ctlx_keymap);
39db33d6	186	}
c906108c	187
39db33d6 SC	188	/* Enter in the tui mode (curses).
	189	When in normal mode, it installs the tui hooks in gdb, redirects
	190	the gdb output, configures the readline to work in tui mode.
	191	When in curses mode, it does nothing. */
c906108c	192	void
39db33d6	193	tui_enable (void)
c906108c	194	{
39db33d6 SC	195	if (tui_active)
	196	return;
	197
	198	/* To avoid to initialize curses when gdb starts, there is a defered
	199	curses initialization. This initialization is made only once
	200	and the first time the curses mode is entered. */
	201	if (tui_finish_init)
c906108c	202	{
39db33d6 SC	203	WINDOW *w;
	204
	205	w = initscr ();
	206
377c38ea SC	207	cbreak ();
377c38ea SC	208	noecho ();
39db33d6 SC	209	/timeout (1);/
	210	nodelay(w, FALSE);
	211	nl();
	212	keypad (w, TRUE);
	213	rl_initialize ();
	214	setTermHeightTo (LINES);
	215	setTermWidthTo (COLS);
	216	def_prog_mode ();
	217
	218	tuiSetLocatorContent (0);
	219	showLayout (SRC_COMMAND);
	220	tuiSetWinFocusTo (srcWin);
377c38ea	221	keypad (cmdWin->generic.handle, TRUE);
39db33d6 SC	222	wrefresh (cmdWin->generic.handle);
39db33d6 SC	223	tui_finish_init = 0;
c906108c	224	}
39db33d6 SC	225	else
	226	{
	227	/* Save the current gdb setting of the terminal.
	228	Curses will restore this state when endwin() is called. */
	229	def_shell_mode ();
	230	clearok (stdscr, TRUE);
	231	}
c906108c	232
39db33d6 SC	233	/* Install the TUI specific hooks. */
39db33d6 SC	234	tui_install_hooks ();
c906108c	235
377c38ea SC	236	tui_update_variables ();
377c38ea SC	237
39db33d6	238	tui_setup_io (1);
c906108c	239
39db33d6 SC	240	tui_version = 1;
	241	tui_active = 1;
	242	refresh ();
	243	}
	244
	245	/* Leave the tui mode.
	246	Remove the tui hooks and configure the gdb output and readline
	247	back to their original state. The curses mode is left so that
	248	the terminal setting is restored to the point when we entered. */
c906108c	249	void
39db33d6	250	tui_disable (void)
c906108c	251	{
39db33d6 SC	252	if (!tui_active)
39db33d6 SC	253	return;
c906108c	254
39db33d6 SC	255	/* Remove TUI hooks. */
39db33d6 SC	256	tui_remove_hooks ();
c906108c	257
39db33d6 SC	258	/* Leave curses and restore previous gdb terminal setting. */
39db33d6 SC	259	endwin ();
c906108c	260
39db33d6 SC	261	/* gdb terminal has changed, update gdb internal copy of it
	262	so that terminal management with the inferior works. */
	263	tui_setup_io (0);
c906108c	264
39db33d6 SC	265	tui_version = 0;
	266	tui_active = 0;
	267	}
c906108c	268
39db33d6 SC	269	/* Wrapper on top of free() to ensure that input address
39db33d6 SC	270	is greater than 0x0. */
c906108c	271	void
eca6576c	272	tuiFree (char *ptr)
c906108c SS	273	{
	274	if (ptr != (char *) NULL)
	275	{
b8c9b27d	276	xfree (ptr);
c906108c	277	}
39db33d6	278	}
c906108c	279
39db33d6 SC	280	/* Determine what the low address will be to display in the TUI's
	281	disassembly window. This may or may not be the same as the
	282	low address input. */
	283	CORE_ADDR
	284	tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
c906108c SS	285	{
c906108c SS	286	int line;
c6f60bcd	287	CORE_ADDR newLow;
c906108c	288
39db33d6 SC	289	/* Determine where to start the disassembly so that the pc is about in the
39db33d6 SC	290	middle of the viewport. */
c906108c SS	291	for (line = 0, newLow = pc;
	292	(newLow > low &&
	293	line < (tuiDefaultWinViewportHeight (DISASSEM_WIN,
	294	DISASSEM_COMMAND) / 2));)
	295	{
	296	bfd_byte buffer[4];
	297
	298	newLow -= sizeof (bfd_getb32 (buffer));
	299	line++;
	300	}
	301
	302	return newLow;
39db33d6	303	}
c906108c	304
c906108c	305	void
eca6576c	306	strcat_to_buf (char buf, int buflen, char itemToAdd)
c906108c SS	307	{
	308	if (itemToAdd != (char ) NULL && buf != (char ) NULL)
	309	{
	310	if ((strlen (buf) + strlen (itemToAdd)) <= buflen)
	311	strcat (buf, itemToAdd);
	312	else
	313	strncat (buf, itemToAdd, (buflen - strlen (buf)));
	314	}
c906108c SS	315	}
c906108c SS	316
39db33d6 SC	317	#if 0
	318	/* Solaris <sys/termios.h> defines CTRL. */
	319	#ifndef CTRL
	320	#define CTRL(x) (x & ~0140)
	321	#endif
c906108c	322
39db33d6 SC	323	#define FILEDES 2
39db33d6 SC	324	#define CHK(val, dft) (val<=0 ? dft : val)
c906108c SS	325
c906108c SS	326	static void
c906108c	327	_tuiReset (void)
c906108c SS	328	{
	329	struct termio mode;
	330
	331	/*
c5aa993b JM	332	** reset the teletype mode bits to a sensible state.
	333	** Copied tset.c
	334	*/
c906108c SS	335	#if ! defined (USG) && defined (TIOCGETC)
	336	struct tchars tbuf;
	337	#endif /* !USG && TIOCGETC */
	338	#ifdef UCB_NTTY
	339	struct ltchars ltc;
	340
	341	if (ldisc == NTTYDISC)
	342	{
	343	ioctl (FILEDES, TIOCGLTC, &ltc);
	344	ltc.t_suspc = CHK (ltc.t_suspc, CTRL ('Z'));
	345	ltc.t_dsuspc = CHK (ltc.t_dsuspc, CTRL ('Y'));
	346	ltc.t_rprntc = CHK (ltc.t_rprntc, CTRL ('R'));
	347	ltc.t_flushc = CHK (ltc.t_flushc, CTRL ('O'));
	348	ltc.t_werasc = CHK (ltc.t_werasc, CTRL ('W'));
	349	ltc.t_lnextc = CHK (ltc.t_lnextc, CTRL ('V'));
	350	ioctl (FILEDES, TIOCSLTC, &ltc);
	351	}
	352	#endif /* UCB_NTTY */
	353	#ifndef USG
	354	#ifdef TIOCGETC
	355	ioctl (FILEDES, TIOCGETC, &tbuf);
	356	tbuf.t_intrc = CHK (tbuf.t_intrc, CTRL ('?'));
	357	tbuf.t_quitc = CHK (tbuf.t_quitc, CTRL ('\\'));
	358	tbuf.t_startc = CHK (tbuf.t_startc, CTRL ('Q'));
	359	tbuf.t_stopc = CHK (tbuf.t_stopc, CTRL ('S'));
	360	tbuf.t_eofc = CHK (tbuf.t_eofc, CTRL ('D'));
	361	/* brkc is left alone */
	362	ioctl (FILEDES, TIOCSETC, &tbuf);
	363	#endif /* TIOCGETC */
	364	mode.sg_flags &= ~(RAW
	365	#ifdef CBREAK
	366	\| CBREAK
	367	#endif /* CBREAK */
	368	\| VTDELAY \| ALLDELAY);
	369	mode.sg_flags \|= XTABS \| ECHO \| CRMOD \| ANYP;
c5aa993b	370	#else /USG /
c906108c SS	371	ioctl (FILEDES, TCGETA, &mode);
	372	mode.c_cc[VINTR] = CHK (mode.c_cc[VINTR], CTRL ('?'));
	373	mode.c_cc[VQUIT] = CHK (mode.c_cc[VQUIT], CTRL ('\\'));
	374	mode.c_cc[VEOF] = CHK (mode.c_cc[VEOF], CTRL ('D'));
	375
	376	mode.c_iflag &= ~(IGNBRK \| PARMRK \| INPCK \| INLCR \| IGNCR \| IUCLC \| IXOFF);
	377	mode.c_iflag \|= (BRKINT \| ISTRIP \| ICRNL \| IXON);
	378	mode.c_oflag &= ~(OLCUC \| OCRNL \| ONOCR \| ONLRET \| OFILL \| OFDEL \|
	379	NLDLY \| CRDLY \| TABDLY \| BSDLY \| VTDLY \| FFDLY);
	380	mode.c_oflag \|= (OPOST \| ONLCR);
	381	mode.c_cflag &= ~(CSIZE \| PARODD \| CLOCAL);
	382	#ifndef hp9000s800
	383	mode.c_cflag \|= (CS8 \| CREAD);
c5aa993b	384	#else /hp9000s800 /
c906108c SS	385	mode.c_cflag \|= (CS8 \| CSTOPB \| CREAD);
	386	#endif /* hp9000s800 */
	387	mode.c_lflag &= ~(XCASE \| ECHONL \| NOFLSH);
	388	mode.c_lflag \|= (ISIG \| ICANON \| ECHO \| ECHOK);
	389	ioctl (FILEDES, TCSETAW, &mode);
	390	#endif /* USG */
	391
	392	return;
	393	} /* _tuiReset */
39db33d6 SC	394	#endif
39db33d6 SC	395
c6f60bcd SC	396	void
	397	tui_show_source (const char *file, int line)
	398	{
	399	/* make sure that the source window is displayed */
	400	tuiAddWinToLayout (SRC_WIN);
	401
	402	tuiUpdateSourceWindowsWithLine (current_source_symtab, line);
	403	tuiUpdateLocatorFilename (file);
	404	}
1403b519 SC	405
	406	void
	407	tui_show_assembly (CORE_ADDR addr)
	408	{
	409	tuiAddWinToLayout (DISASSEM_WIN);
	410	tuiUpdateSourceWindowsWithAddr (addr);
	411	}
	412
	413	int
	414	tui_is_window_visible (TuiWinType type)
	415	{
	416	if (tui_version == 0)
	417	return 0;
	418
	419	if (winList[type] == 0)
	420	return 0;
	421
	422	return winList[type]->generic.isVisible;
	423	}
	424
	425	int
	426	tui_get_command_dimension (int width, int height)
	427	{
	428	if (!tui_version \|\| !m_winPtrNotNull (cmdWin))
	429	{
	430	return 0;
	431	}
	432
	433	*width = cmdWin->generic.width;
	434	*height = cmdWin->generic.height;
	435	return 1;
	436	}