[deliverable/binutils-gdb.git] / readline / rltty.c

/* rltty.c -- functions to prepare and restore the terminal for readline's
   use. */

/* Copyright (C) 1992 Free Software Foundation, Inc.

   This file is part of the GNU Readline Library, a library for
   reading lines of text with interactive input and history editing.

   The GNU Readline Library 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 1, or
   (at your option) any later version.

   The GNU Readline Library 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.

   The GNU General Public License is often shipped with GNU software, and
   is generally kept in a file called COPYING or LICENSE.  If you do not
   have a copy of the license, write to the Free Software Foundation,
   675 Mass Ave, Cambridge, MA 02139, USA. */
#include "sysdep.h"
#include <signal.h>
#include <errno.h>
#include <stdio.h>
#ifndef	NO_SYS_FILE
#include <sys/file.h>
#endif

#if defined (HAVE_UNISTD_H)
#  include <unistd.h>
#endif /* HAVE_UNISTD_H */

#include "rldefs.h"
#include "readline.h"

#if !defined (errno)
extern int errno;
#endif /* !errno */

extern int readline_echoing_p;
extern int _rl_eof_char;

#if defined (__GO32__)
#  include <sys/pc.h>
#  undef HANDLE_SIGNALS
#endif /* __GO32__ */

/* **************************************************************** */
/*								    */
/*			   Signal Management			    */
/*								    */
/* **************************************************************** */

#if defined (HAVE_POSIX_SIGNALS)
static sigset_t sigint_set, sigint_oset;
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
static int sigint_oldmask;
#  endif /* HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

static int sigint_blocked = 0;

/* Cause SIGINT to not be delivered until the corresponding call to
   release_sigint(). */
static void
block_sigint ()
{
  if (sigint_blocked)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigemptyset (&sigint_set);
  sigemptyset (&sigint_oset);
  sigaddset (&sigint_set, SIGINT);
  sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
#else /* !HAVE_POSIX_SIGNALS */
#  if defined (HAVE_BSD_SIGNALS)
  sigint_oldmask = sigblock (sigmask (SIGINT));
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sighold (SIGINT);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */
  sigint_blocked = 1;
}

/* Allow SIGINT to be delivered. */
static void
release_sigint ()
{
  if (!sigint_blocked)
    return;

#if defined (HAVE_POSIX_SIGNALS)
  sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
#else
#  if defined (HAVE_BSD_SIGNALS)
  sigsetmask (sigint_oldmask);
#  else /* !HAVE_BSD_SIGNALS */
#    if defined (HAVE_USG_SIGHOLD)
  sigrelse (SIGINT);
#    endif /* HAVE_USG_SIGHOLD */
#  endif /* !HAVE_BSD_SIGNALS */
#endif /* !HAVE_POSIX_SIGNALS */

  sigint_blocked = 0;
}
\f
/* **************************************************************** */
/*								    */
/*		      Controlling the Meta Key			    */
/*								    */
/* **************************************************************** */

extern int term_has_meta;
extern char *term_mm;
extern char *term_mo;

static void
outchar (c)
     int c;
{
  putc (c, rl_outstream);
}

/* Turn on/off the meta key depending on ON. */
static void
control_meta_key (on)
     int on;
{
  if (term_has_meta)
    {
      if (on && term_mm)
	tputs (term_mm, 1, outchar);
      else if (!on && term_mo)
	tputs (term_mo, 1, outchar);
    }
}
\f
/* **************************************************************** */
/*								    */
/*		      Saving and Restoring the TTY	    	    */
/*								    */
/* **************************************************************** */

/* Non-zero means that the terminal is in a prepped state. */
static int terminal_prepped = 0;

/* If non-zero, means that this process has called tcflow(fd, TCOOFF)
   and output is suspended. */
#if defined (__ksr1__)
static int ksrflow = 0;
#endif
#if defined (NEW_TTY_DRIVER)

/* Values for the `flags' field of a struct bsdtty.  This tells which
   elements of the struct bsdtty have been fetched from the system and
   are valid. */
#define SGTTY_SET	0x01
#define LFLAG_SET	0x02
#define TCHARS_SET	0x04
#define LTCHARS_SET	0x08

struct bsdtty {
  struct sgttyb sgttyb;	/* Basic BSD tty driver information. */
  int lflag;		/* Local mode flags, like LPASS8. */
#if defined (TIOCGETC)
  struct tchars tchars;	/* Terminal special characters, including ^S and ^Q. */
#endif
#if defined (TIOCGLTC)
  struct ltchars ltchars; /* 4.2 BSD editing characters */
#endif
  int flags;		/* Bitmap saying which parts of the struct are valid. */
};

#define TIOTYPE struct bsdtty

static TIOTYPE otio;

static int
get_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  tiop->flags = tiop->lflag = 0;

  ioctl (tty, TIOCGETP, &(tiop->sgttyb));
  tiop->flags |= SGTTY_SET;

#if defined (TIOCLGET)
  ioctl (tty, TIOCLGET, &(tiop->lflag));
  tiop->flags |= LFLAG_SET;
#endif

#if defined (TIOCGETC)
  ioctl (tty, TIOCGETC, &(tiop->tchars));
  tiop->flags |= TCHARS_SET;
#endif

#if defined (TIOCGLTC)
  ioctl (tty, TIOCGLTC, &(tiop->ltchars));
  tiop->flags |= LTCHARS_SET;
#endif

  return 0;
}

set_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  if (tiop->flags & SGTTY_SET)
    {
      ioctl (tty, TIOCSETN, &(tiop->sgttyb));
      tiop->flags &= ~SGTTY_SET;
    }

#if defined (TIOCLSET)
  if (tiop->flags & LFLAG_SET)
    {
      ioctl (tty, TIOCLSET, &(tiop->lflag));
      tiop->flags &= ~LFLAG_SET;
    }
#endif

#if defined (TIOCSETC)
  if (tiop->flags & TCHARS_SET)
    {
      ioctl (tty, TIOCSETC, &(tiop->tchars));
      tiop->flags &= ~TCHARS_SET;
    }
#endif

#if defined (TIOCSLTC)
  if (tiop->flags & LTCHARS_SET)
    {
      ioctl (tty, TIOCSLTC, &(tiop->ltchars));
      tiop->flags &= ~LTCHARS_SET;
    }
#endif

  return 0;
}

static void
prepare_terminal_settings (meta_flag, otio, tiop)
     int meta_flag;
     TIOTYPE otio, *tiop;
{
#if !defined (__GO32__)
  readline_echoing_p = (otio.sgttyb.sg_flags & ECHO);

  /* Copy the original settings to the structure we're going to use for
     our settings. */
  tiop->sgttyb = otio.sgttyb;
  tiop->lflag = otio.lflag;
#if defined (TIOCGETC)
  tiop->tchars = otio.tchars;
#endif
#if defined (TIOCGLTC)
  tiop->ltchars = otio.ltchars;
#endif
  tiop->flags = otio.flags;

  /* First, the basic settings to put us into character-at-a-time, no-echo
     input mode. */
  tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
  tiop->sgttyb.sg_flags |= CBREAK;

  /* If this terminal doesn't care how the 8th bit is used, then we can
     use it for the meta-key.  If only one of even or odd parity is
     specified, then the terminal is using parity, and we cannot. */
#if !defined (ANYP)
#  define ANYP (EVENP | ODDP)
#endif
  if (((otio.sgttyb.sg_flags & ANYP) == ANYP) ||
      ((otio.sgttyb.sg_flags & ANYP) == 0))
    {
      tiop->sgttyb.sg_flags |= ANYP;

      /* Hack on local mode flags if we can. */
#if defined (TIOCLGET)
#  if defined (LPASS8)
      tiop->lflag |= LPASS8;
#  endif /* LPASS8 */
#endif /* TIOCLGET */
    }

#if defined (TIOCGETC)
#  if defined (USE_XON_XOFF)
  /* Get rid of terminal output start and stop characters. */
  tiop->tchars.t_stopc = -1; /* C-s */
  tiop->tchars.t_startc = -1; /* C-q */

  /* If there is an XON character, bind it to restart the output. */
  if (otio.tchars.t_startc != -1)
    rl_bind_key (otio.tchars.t_startc, rl_restart_output);
#  endif /* USE_XON_XOFF */

  /* If there is an EOF char, bind _rl_eof_char to it. */
  if (otio.tchars.t_eofc != -1)
    _rl_eof_char = otio.tchars.t_eofc;

#  if defined (NO_KILL_INTR)
  /* Get rid of terminal-generated SIGQUIT and SIGINT. */
  tiop->tchars.t_quitc = -1; /* C-\ */
  tiop->tchars.t_intrc = -1; /* C-c */
#  endif /* NO_KILL_INTR */
#endif /* TIOCGETC */

#if defined (TIOCGLTC)
  /* Make the interrupt keys go away.  Just enough to make people happy. */
  tiop->ltchars.t_dsuspc = -1;	/* C-y */
  tiop->ltchars.t_lnextc = -1;	/* C-v */
#endif /* TIOCGLTC */
#endif /* !__GO32__ */
}
#endif /* defined (NEW_TTY_DRIVER) */

#if !defined (NEW_TTY_DRIVER) && !defined(__GO32__)

#if !defined (VMIN)
#  define VMIN VEOF
#endif

#if !defined (VTIME)
#  define VTIME VEOL
#endif

#if defined (TERMIOS_TTY_DRIVER)
#  define TIOTYPE struct termios
#  define DRAIN_OUTPUT(fd)	tcdrain (fd)
#  define GETATTR(tty, tiop)	(tcgetattr (tty, tiop))
#  define SETATTR(tty, tiop)	(tcsetattr (tty, TCSANOW, tiop))
#else
#  define TIOTYPE struct termio
#  define DRAIN_OUTPUT(fd)
#  define GETATTR(tty, tiop)	(ioctl (tty, TCGETA, tiop))
#  define SETATTR(tty, tiop)	(ioctl (tty, TCSETA, tiop))
#endif /* !TERMIOS_TTY_DRIVER */

static TIOTYPE otio;

static int
get_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  while (GETATTR (tty, tiop) < 0)
    {
      if (errno != EINTR)
	return -1;
      errno = 0;
    }
  return 0;
}

static int
set_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  while (SETATTR (tty, tiop) < 0)
    {
      if (errno != EINTR)
	return -1;
      errno = 0;
    }

#if 0

#if defined (TERMIOS_TTY_DRIVER)
#  if defined (__ksr1__)
  if (ksrflow)
    {
      ksrflow = 0;
      tcflow (tty, TCOON);
    }
#  else /* !ksr1 */
  tcflow (tty, TCOON);		/* Simulate a ^Q. */
#  endif /* !ksr1 */
#else
  ioctl (tty, TCXONC, 1);	/* Simulate a ^Q. */
#endif /* !TERMIOS_TTY_DRIVER */

#endif

  return 0;
}

static void
prepare_terminal_settings (meta_flag, otio, tiop)
     int meta_flag;
     TIOTYPE otio, *tiop;
{
  readline_echoing_p = (otio.c_lflag & ECHO);

  tiop->c_lflag &= ~(ICANON | ECHO);

  if ((unsigned char) otio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
    _rl_eof_char = otio.c_cc[VEOF];

#if defined (USE_XON_XOFF)
#if defined (IXANY)
  tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
#else
  /* `strict' Posix systems do not define IXANY. */
  tiop->c_iflag &= ~(IXON | IXOFF);
#endif /* IXANY */
#endif /* USE_XON_XOFF */

  /* Only turn this off if we are using all 8 bits. */
  if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag)
    tiop->c_iflag &= ~(ISTRIP | INPCK);

  /* Make sure we differentiate between CR and NL on input. */
  tiop->c_iflag &= ~(ICRNL | INLCR);

#if !defined (HANDLE_SIGNALS)
  tiop->c_lflag &= ~ISIG;
#else
  tiop->c_lflag |= ISIG;
#endif

  tiop->c_cc[VMIN] = 1;
  tiop->c_cc[VTIME] = 0;

  /* Turn off characters that we need on Posix systems with job control,
     just to be sure.  This includes ^Y and ^V.  This should not really
     be necessary.  */
#if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)

#if defined (VLNEXT)
  tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
#endif

#if defined (VDSUSP)
  tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
#endif

#endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
}
#endif /* !defined (NEW_TTY_DRIVER) && !defined(__GO32__) */

/* Put the terminal in CBREAK mode so that we can detect key presses. */
void
rl_prep_terminal (meta_flag)
     int meta_flag;
{
#if !defined (__GO32__)
  int tty = fileno (rl_instream);
  TIOTYPE tio;

  if (terminal_prepped)
    return;

  /* Try to keep this function from being INTerrupted. */
  block_sigint ();

  if (get_tty_settings (tty, &tio) < 0)
    {
      release_sigint ();
      return;
    }

  otio = tio;

  prepare_terminal_settings (meta_flag, otio, &tio);

  if (set_tty_settings (tty, &tio) < 0)
    {
      release_sigint ();
      return;
    }

  control_meta_key (1);
  terminal_prepped = 1;

  release_sigint ();
#endif /* !__GO32__ */
}

/* Restore the terminal's normal settings and modes. */
void
rl_deprep_terminal ()
{
#if !defined (__GO32__)
  int tty = fileno (rl_instream);

  if (!terminal_prepped)
    return;

  /* Try to keep this function from being INTerrupted. */
  block_sigint ();

  if (set_tty_settings (tty, &otio) < 0)
    {
      release_sigint ();
      return;
    }
#ifdef NEW_TTY_DRIVER
  readline_echoing_p = 1;
#endif

  control_meta_key (0);
  terminal_prepped = 0;

  release_sigint ();
#endif /* !__GO32__ */
}
\f
/* **************************************************************** */
/*								    */
/*			Bogus Flow Control      		    */
/*								    */
/* **************************************************************** */

rl_restart_output (count, key)
     int count, key;
{
  int fildes = fileno (rl_outstream);
#if defined (TIOCSTART)
#if defined (apollo)
  ioctl (&fildes, TIOCSTART, 0);
#else
  ioctl (fildes, TIOCSTART, 0);
#endif /* apollo */

#else /* !TIOCSTART */
#  if defined (TERMIOS_TTY_DRIVER)
#    if defined (__ksr1__)
  if (ksrflow)
    {
      ksrflow = 0;
      tcflow (fildes, TCOON);
    }
#    else /* !ksr1 */
  tcflow (fildes, TCOON);		/* Simulate a ^Q. */
#    endif /* !ksr1 */
#  else /* !TERMIOS_TTY_DRIVER */
#    if defined (TCXONC)
  ioctl (fildes, TCXONC, TCOON);
#    endif /* TCXONC */
#  endif /* !TERMIOS_TTY_DRIVER */
#endif /* !TIOCSTART */
}

rl_stop_output (count, key)
     int count, key;
{
  int fildes = fileno (rl_instream);

#if defined (TIOCSTOP)
# if defined (apollo)
  ioctl (&fildes, TIOCSTOP, 0);
# else
  ioctl (fildes, TIOCSTOP, 0);
# endif /* apollo */
#else /* !TIOCSTOP */
# if defined (TERMIOS_TTY_DRIVER)
#  if defined (__ksr1__)
  ksrflow = 1;
#  endif /* ksr1 */
  tcflow (fildes, TCOOFF);
# else
#   if defined (TCXONC)
  ioctl (fildes, TCXONC, TCOON);
#   endif /* TCXONC */
# endif /* !TERMIOS_TTY_DRIVER */
#endif /* !TIOCSTOP */
}
\f
/* **************************************************************** */
/*								    */
/*			Default Key Bindings			    */
/*								    */
/* **************************************************************** */
#if !defined (__GO32__)
void
rltty_set_default_bindings (kmap)
     Keymap kmap;
{
  TIOTYPE ttybuff;
  int tty = fileno (rl_instream);

#if defined (NEW_TTY_DRIVER)

  if (get_tty_settings (tty, &ttybuff) == 0)
    {
      if (ttybuff.flags & SGTTY_SET)
	{
	  int erase, kill;

	  erase = ttybuff.sgttyb.sg_erase;
	  kill  = ttybuff.sgttyb.sg_kill;

	  if (erase != -1 && kmap[erase].type == ISFUNC)
	    kmap[erase].function = rl_rubout;

	  if (kill != -1 && kmap[kill].type == ISFUNC)
	    kmap[kill].function = rl_unix_line_discard;
	}

#  if defined (TIOCGLTC)

      if (ttybuff.flags & LTCHARS_SET)
	{
	  int werase, nextc;

	  werase = ttybuff.ltchars.t_werasc;
	  nextc = ttybuff.ltchars.t_lnextc;

	  if (werase != -1 && kmap[werase].type == ISFUNC)
	    kmap[werase].function = rl_unix_word_rubout;

	  if (nextc != -1 && kmap[nextc].type == ISFUNC)
	    kmap[nextc].function = rl_quoted_insert;
	}
    }
#  endif /* TIOCGLTC */

#else /* !NEW_TTY_DRIVER */

  if (get_tty_settings (tty, &ttybuff) == 0)
    {
      unsigned char erase, kill;

      erase = ttybuff.c_cc[VERASE];
      kill = ttybuff.c_cc[VKILL];

      if (erase != (unsigned char)_POSIX_VDISABLE &&
	  kmap[erase].type == ISFUNC)
	kmap[erase].function = rl_rubout;

      if (kill != (unsigned char)_POSIX_VDISABLE &&
	  kmap[kill].type == ISFUNC)
	kmap[kill].function = rl_unix_line_discard;

#  if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
      {
	unsigned char nextc;

	nextc = ttybuff.c_cc[VLNEXT];

	if (nextc != (unsigned char)_POSIX_VDISABLE &&
	    kmap[nextc].type == ISFUNC)
	  kmap[nextc].function = rl_quoted_insert;
      }
#  endif /* VLNEXT && TERMIOS_TTY_DRIVER */

#  if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
      {
	unsigned char werase;

	werase = ttybuff.c_cc[VWERASE];

	if (werase != (unsigned char)_POSIX_VDISABLE &&
	    kmap[werase].type == ISFUNC)
	  kmap[werase].function = rl_unix_word_rubout;
      }
#  endif /* VWERASE && TERMIOS_TTY_DRIVER */
    }
#endif /* !NEW_TTY_DRIVER */
}
#endif /* !__GO32__ */
Commit	Line	Data
166557e7 PB	1	/* rltty.c -- functions to prepare and restore the terminal for readline's
	2	use. */
	3
	4	/* Copyright (C) 1992 Free Software Foundation, Inc.
	5
	6	This file is part of the GNU Readline Library, a library for
	7	reading lines of text with interactive input and history editing.
	8
	9	The GNU Readline Library is free software; you can redistribute it
	10	and/or modify it under the terms of the GNU General Public License
	11	as published by the Free Software Foundation; either version 1, or
	12	(at your option) any later version.
	13
	14	The GNU Readline Library is distributed in the hope that it will be
	15	useful, but WITHOUT ANY WARRANTY; without even the implied warranty
	16	of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
	18
	19	The GNU General Public License is often shipped with GNU software, and
	20	is generally kept in a file called COPYING or LICENSE. If you do not
	21	have a copy of the license, write to the Free Software Foundation,
	22	675 Mass Ave, Cambridge, MA 02139, USA. */
3dc889b4	23	#include "sysdep.h"
166557e7 PB	24	#include <signal.h>
	25	#include <errno.h>
	26	#include <stdio.h>
3dc889b4 ILT	27	#ifndef NO_SYS_FILE
	28	#include <sys/file.h>
	29	#endif
166557e7 PB	30
	31	#if defined (HAVE_UNISTD_H)
	32	# include <unistd.h>
	33	#endif /* HAVE_UNISTD_H */
	34
	35	#include "rldefs.h"
	36	#include "readline.h"
	37
	38	#if !defined (errno)
	39	extern int errno;
	40	#endif /* !errno */
	41
	42	extern int readline_echoing_p;
	43	extern int _rl_eof_char;
	44
3dc889b4	45	#if defined (__GO32__)
166557e7 PB	46	# include <sys/pc.h>
166557e7 PB	47	# undef HANDLE_SIGNALS
3dc889b4	48	#endif /* __GO32__ */
166557e7 PB	49
	50	/* **************************************************************** */
	51	/* */
	52	/* Signal Management */
	53	/* */
	54	/* **************************************************************** */
	55
	56	#if defined (HAVE_POSIX_SIGNALS)
	57	static sigset_t sigint_set, sigint_oset;
	58	#else /* !HAVE_POSIX_SIGNALS */
	59	# if defined (HAVE_BSD_SIGNALS)
	60	static int sigint_oldmask;
	61	# endif /* HAVE_BSD_SIGNALS */
	62	#endif /* !HAVE_POSIX_SIGNALS */
	63
	64	static int sigint_blocked = 0;
	65
	66	/* Cause SIGINT to not be delivered until the corresponding call to
	67	release_sigint(). */
	68	static void
	69	block_sigint ()
	70	{
	71	if (sigint_blocked)
	72	return;
	73
	74	#if defined (HAVE_POSIX_SIGNALS)
	75	sigemptyset (&sigint_set);
	76	sigemptyset (&sigint_oset);
	77	sigaddset (&sigint_set, SIGINT);
	78	sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
	79	#else /* !HAVE_POSIX_SIGNALS */
	80	# if defined (HAVE_BSD_SIGNALS)
	81	sigint_oldmask = sigblock (sigmask (SIGINT));
	82	# else /* !HAVE_BSD_SIGNALS */
	83	# if defined (HAVE_USG_SIGHOLD)
	84	sighold (SIGINT);
	85	# endif /* HAVE_USG_SIGHOLD */
	86	# endif /* !HAVE_BSD_SIGNALS */
	87	#endif /* !HAVE_POSIX_SIGNALS */
	88	sigint_blocked = 1;
	89	}
	90
	91	/* Allow SIGINT to be delivered. */
	92	static void
	93	release_sigint ()
	94	{
	95	if (!sigint_blocked)
	96	return;
	97
	98	#if defined (HAVE_POSIX_SIGNALS)
	99	sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
	100	#else
	101	# if defined (HAVE_BSD_SIGNALS)
	102	sigsetmask (sigint_oldmask);
	103	# else /* !HAVE_BSD_SIGNALS */
	104	# if defined (HAVE_USG_SIGHOLD)
	105	sigrelse (SIGINT);
	106	# endif /* HAVE_USG_SIGHOLD */
	107	# endif /* !HAVE_BSD_SIGNALS */
	108	#endif /* !HAVE_POSIX_SIGNALS */
	109
	110	sigint_blocked = 0;
	111	}
	112	\f
113	/* **************************************************************** */
114	/* */
115	/* Controlling the Meta Key */
116	/* */
117	/* **************************************************************** */
118
119	extern int term_has_meta;
120	extern char *term_mm;
121	extern char *term_mo;
122
123	static void
124	outchar (c)
125	int c;
126	{
127	putc (c, rl_outstream);
128	}
129
130	/* Turn on/off the meta key depending on ON. */
131	static void
132	control_meta_key (on)
133	int on;
134	{
135	if (term_has_meta)
136	{
137	if (on && term_mm)
138	tputs (term_mm, 1, outchar);
139	else if (!on && term_mo)
140	tputs (term_mo, 1, outchar);
141	}
142	}
143	\f
144	/* **************************************************************** */
145	/* */
146	/* Saving and Restoring the TTY */
147	/* */
148	/* **************************************************************** */
149
150	/* Non-zero means that the terminal is in a prepped state. */
151	static int terminal_prepped = 0;
152
153	/* If non-zero, means that this process has called tcflow(fd, TCOOFF)
154	and output is suspended. */
155	#if defined (__ksr1__)
156	static int ksrflow = 0;
157	#endif
158	#if defined (NEW_TTY_DRIVER)
159
160	/* Values for the `flags' field of a struct bsdtty. This tells which
161	elements of the struct bsdtty have been fetched from the system and
162	are valid. */
163	#define SGTTY_SET 0x01
164	#define LFLAG_SET 0x02
165	#define TCHARS_SET 0x04
166	#define LTCHARS_SET 0x08
167
168	struct bsdtty {
169	struct sgttyb sgttyb; /* Basic BSD tty driver information. */
170	int lflag; /* Local mode flags, like LPASS8. */
171	#if defined (TIOCGETC)
172	struct tchars tchars; /* Terminal special characters, including ^S and ^Q. */
173	#endif
174	#if defined (TIOCGLTC)
175	struct ltchars ltchars; /* 4.2 BSD editing characters */
176	#endif
177	int flags; /* Bitmap saying which parts of the struct are valid. */
178	};
179
180	#define TIOTYPE struct bsdtty
181
182	static TIOTYPE otio;
183
184	static int
185	get_tty_settings (tty, tiop)
186	int tty;
187	TIOTYPE *tiop;
188	{
189	tiop->flags = tiop->lflag = 0;
190
191	ioctl (tty, TIOCGETP, &(tiop->sgttyb));
192	tiop->flags \|= SGTTY_SET;
193
194	#if defined (TIOCLGET)
195	ioctl (tty, TIOCLGET, &(tiop->lflag));
196	tiop->flags \|= LFLAG_SET;
197	#endif
198
199	#if defined (TIOCGETC)
200	ioctl (tty, TIOCGETC, &(tiop->tchars));
201	tiop->flags \|= TCHARS_SET;
202	#endif
203
204	#if defined (TIOCGLTC)
205	ioctl (tty, TIOCGLTC, &(tiop->ltchars));
206	tiop->flags \|= LTCHARS_SET;
207	#endif
208
209	return 0;
210	}
211
212	set_tty_settings (tty, tiop)
213	int tty;
214	TIOTYPE *tiop;
215	{
216	if (tiop->flags & SGTTY_SET)
217	{
218	ioctl (tty, TIOCSETN, &(tiop->sgttyb));
219	tiop->flags &= ~SGTTY_SET;
220	}
166557e7 PB	221
	222	#if defined (TIOCLSET)
	223	if (tiop->flags & LFLAG_SET)
	224	{
	225	ioctl (tty, TIOCLSET, &(tiop->lflag));
	226	tiop->flags &= ~LFLAG_SET;
	227	}
	228	#endif
	229
	230	#if defined (TIOCSETC)
	231	if (tiop->flags & TCHARS_SET)
	232	{
	233	ioctl (tty, TIOCSETC, &(tiop->tchars));
	234	tiop->flags &= ~TCHARS_SET;
	235	}
	236	#endif
	237
	238	#if defined (TIOCSLTC)
	239	if (tiop->flags & LTCHARS_SET)
	240	{
	241	ioctl (tty, TIOCSLTC, &(tiop->ltchars));
	242	tiop->flags &= ~LTCHARS_SET;
	243	}
	244	#endif
	245
	246	return 0;
	247	}
	248
	249	static void
	250	prepare_terminal_settings (meta_flag, otio, tiop)
	251	int meta_flag;
	252	TIOTYPE otio, *tiop;
	253	{
3dc889b4	254	#if !defined (__GO32__)
166557e7 PB	255	readline_echoing_p = (otio.sgttyb.sg_flags & ECHO);
	256
	257	/* Copy the original settings to the structure we're going to use for
	258	our settings. */
	259	tiop->sgttyb = otio.sgttyb;
	260	tiop->lflag = otio.lflag;
	261	#if defined (TIOCGETC)
	262	tiop->tchars = otio.tchars;
	263	#endif
	264	#if defined (TIOCGLTC)
	265	tiop->ltchars = otio.ltchars;
	266	#endif
	267	tiop->flags = otio.flags;
	268
	269	/* First, the basic settings to put us into character-at-a-time, no-echo
	270	input mode. */
	271	tiop->sgttyb.sg_flags &= ~(ECHO \| CRMOD);
	272	tiop->sgttyb.sg_flags \|= CBREAK;
	273
	274	/* If this terminal doesn't care how the 8th bit is used, then we can
	275	use it for the meta-key. If only one of even or odd parity is
	276	specified, then the terminal is using parity, and we cannot. */
	277	#if !defined (ANYP)
	278	# define ANYP (EVENP \| ODDP)
	279	#endif
	280	if (((otio.sgttyb.sg_flags & ANYP) == ANYP) \|\|
	281	((otio.sgttyb.sg_flags & ANYP) == 0))
	282	{
	283	tiop->sgttyb.sg_flags \|= ANYP;
	284
	285	/* Hack on local mode flags if we can. */
	286	#if defined (TIOCLGET)
	287	# if defined (LPASS8)
	288	tiop->lflag \|= LPASS8;
	289	# endif /* LPASS8 */
	290	#endif /* TIOCLGET */
	291	}
	292
	293	#if defined (TIOCGETC)
	294	# if defined (USE_XON_XOFF)
	295	/* Get rid of terminal output start and stop characters. */
	296	tiop->tchars.t_stopc = -1; /* C-s */
	297	tiop->tchars.t_startc = -1; /* C-q */
	298
	299	/* If there is an XON character, bind it to restart the output. */
	300	if (otio.tchars.t_startc != -1)
	301	rl_bind_key (otio.tchars.t_startc, rl_restart_output);
	302	# endif /* USE_XON_XOFF */
	303
	304	/* If there is an EOF char, bind _rl_eof_char to it. */
	305	if (otio.tchars.t_eofc != -1)
	306	_rl_eof_char = otio.tchars.t_eofc;
	307
	308	# if defined (NO_KILL_INTR)
	309	/* Get rid of terminal-generated SIGQUIT and SIGINT. */
	310	tiop->tchars.t_quitc = -1; /* C-\ */
	311	tiop->tchars.t_intrc = -1; /* C-c */
	312	# endif /* NO_KILL_INTR */
	313	#endif /* TIOCGETC */
	314
	315	#if defined (TIOCGLTC)
	316	/* Make the interrupt keys go away. Just enough to make people happy. */
	317	tiop->ltchars.t_dsuspc = -1; /* C-y */
	318	tiop->ltchars.t_lnextc = -1; /* C-v */
319	#endif /* TIOCGLTC */
3dc889b4	320	#endif /* !__GO32__ */
166557e7 PB	321	}
	322	#endif /* defined (NEW_TTY_DRIVER) */
	323
3dc889b4	324	#if !defined (NEW_TTY_DRIVER) && !defined(__GO32__)
166557e7 PB	325
	326	#if !defined (VMIN)
	327	# define VMIN VEOF
	328	#endif
	329
	330	#if !defined (VTIME)
	331	# define VTIME VEOL
	332	#endif
	333
	334	#if defined (TERMIOS_TTY_DRIVER)
	335	# define TIOTYPE struct termios
	336	# define DRAIN_OUTPUT(fd) tcdrain (fd)
	337	# define GETATTR(tty, tiop) (tcgetattr (tty, tiop))
	338	# define SETATTR(tty, tiop) (tcsetattr (tty, TCSANOW, tiop))
	339	#else
	340	# define TIOTYPE struct termio
	341	# define DRAIN_OUTPUT(fd)
	342	# define GETATTR(tty, tiop) (ioctl (tty, TCGETA, tiop))
	343	# define SETATTR(tty, tiop) (ioctl (tty, TCSETA, tiop))
	344	#endif /* !TERMIOS_TTY_DRIVER */
	345
	346	static TIOTYPE otio;
	347
	348	static int
	349	get_tty_settings (tty, tiop)
	350	int tty;
	351	TIOTYPE *tiop;
	352	{
	353	while (GETATTR (tty, tiop) < 0)
	354	{
	355	if (errno != EINTR)
	356	return -1;
	357	errno = 0;
	358	}
	359	return 0;
	360	}
	361
	362	static int
	363	set_tty_settings (tty, tiop)
	364	int tty;
	365	TIOTYPE *tiop;
	366	{
	367	while (SETATTR (tty, tiop) < 0)
	368	{
	369	if (errno != EINTR)
	370	return -1;
	371	errno = 0;
	372	}
	373
	374	#if 0
	375
	376	#if defined (TERMIOS_TTY_DRIVER)
	377	# if defined (__ksr1__)
	378	if (ksrflow)
	379	{
	380	ksrflow = 0;
	381	tcflow (tty, TCOON);
	382	}
	383	# else /* !ksr1 */
	384	tcflow (tty, TCOON); /* Simulate a ^Q. */
	385	# endif /* !ksr1 */
	386	#else
	387	ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */
	388	#endif /* !TERMIOS_TTY_DRIVER */
389
390	#endif
391
392	return 0;
393	}
394
395	static void
396	prepare_terminal_settings (meta_flag, otio, tiop)
397	int meta_flag;
398	TIOTYPE otio, *tiop;
399	{
400	readline_echoing_p = (otio.c_lflag & ECHO);
401
402	tiop->c_lflag &= ~(ICANON \| ECHO);
403
404	if ((unsigned char) otio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
405	_rl_eof_char = otio.c_cc[VEOF];
406
407	#if defined (USE_XON_XOFF)
408	#if defined (IXANY)
409	tiop->c_iflag &= ~(IXON \| IXOFF \| IXANY);
410	#else
411	/* `strict' Posix systems do not define IXANY. */
412	tiop->c_iflag &= ~(IXON \| IXOFF);
413	#endif /* IXANY */
414	#endif /* USE_XON_XOFF */
415
416	/* Only turn this off if we are using all 8 bits. */
417	if (((tiop->c_cflag & CSIZE) == CS8) \|\| meta_flag)
418	tiop->c_iflag &= ~(ISTRIP \| INPCK);
419
420	/* Make sure we differentiate between CR and NL on input. */
421	tiop->c_iflag &= ~(ICRNL \| INLCR);
422
423	#if !defined (HANDLE_SIGNALS)
424	tiop->c_lflag &= ~ISIG;
425	#else
426	tiop->c_lflag \|= ISIG;
427	#endif
428
429	tiop->c_cc[VMIN] = 1;
430	tiop->c_cc[VTIME] = 0;
431
432	/* Turn off characters that we need on Posix systems with job control,
433	just to be sure. This includes ^Y and ^V. This should not really
434	be necessary. */
435	#if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)
436
437	#if defined (VLNEXT)
438	tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
439	#endif
440
441	#if defined (VDSUSP)
442	tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
443	#endif
444
445	#endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
446	}
3dc889b4	447	#endif /* !defined (NEW_TTY_DRIVER) && !defined(__GO32__) */
166557e7 PB	448
	449	/* Put the terminal in CBREAK mode so that we can detect key presses. */
	450	void
	451	rl_prep_terminal (meta_flag)
	452	int meta_flag;
	453	{
3dc889b4	454	#if !defined (__GO32__)
166557e7 PB	455	int tty = fileno (rl_instream);
	456	TIOTYPE tio;
	457
	458	if (terminal_prepped)
	459	return;
	460
	461	/* Try to keep this function from being INTerrupted. */
	462	block_sigint ();
	463
	464	if (get_tty_settings (tty, &tio) < 0)
	465	{
	466	release_sigint ();
	467	return;
	468	}
	469
	470	otio = tio;
	471
	472	prepare_terminal_settings (meta_flag, otio, &tio);
	473
	474	if (set_tty_settings (tty, &tio) < 0)
	475	{
	476	release_sigint ();
	477	return;
	478	}
	479
	480	control_meta_key (1);
	481	terminal_prepped = 1;
	482
	483	release_sigint ();
3dc889b4	484	#endif /* !__GO32__ */
166557e7 PB	485	}
	486
	487	/* Restore the terminal's normal settings and modes. */
	488	void
	489	rl_deprep_terminal ()
	490	{
3dc889b4	491	#if !defined (__GO32__)
166557e7 PB	492	int tty = fileno (rl_instream);
	493
	494	if (!terminal_prepped)
	495	return;
	496
	497	/* Try to keep this function from being INTerrupted. */
	498	block_sigint ();
	499
	500	if (set_tty_settings (tty, &otio) < 0)
	501	{
	502	release_sigint ();
	503	return;
	504	}
3dc889b4 ILT	505	#ifdef NEW_TTY_DRIVER
	506	readline_echoing_p = 1;
	507	#endif
166557e7 PB	508
	509	control_meta_key (0);
	510	terminal_prepped = 0;
	511
	512	release_sigint ();
3dc889b4	513	#endif /* !__GO32__ */
166557e7 PB	514	}
	515	\f
	516	/* **************************************************************** */
	517	/* */
	518	/* Bogus Flow Control */
	519	/* */
	520	/* **************************************************************** */
	521
	522	rl_restart_output (count, key)
	523	int count, key;
	524	{
	525	int fildes = fileno (rl_outstream);
	526	#if defined (TIOCSTART)
	527	#if defined (apollo)
	528	ioctl (&fildes, TIOCSTART, 0);
	529	#else
	530	ioctl (fildes, TIOCSTART, 0);
	531	#endif /* apollo */
	532
	533	#else /* !TIOCSTART */
	534	# if defined (TERMIOS_TTY_DRIVER)
	535	# if defined (__ksr1__)
	536	if (ksrflow)
	537	{
	538	ksrflow = 0;
	539	tcflow (fildes, TCOON);
	540	}
	541	# else /* !ksr1 */
	542	tcflow (fildes, TCOON); /* Simulate a ^Q. */
	543	# endif /* !ksr1 */
	544	# else /* !TERMIOS_TTY_DRIVER */
	545	# if defined (TCXONC)
	546	ioctl (fildes, TCXONC, TCOON);
	547	# endif /* TCXONC */
	548	# endif /* !TERMIOS_TTY_DRIVER */
	549	#endif /* !TIOCSTART */
	550	}
	551
	552	rl_stop_output (count, key)
	553	int count, key;
	554	{
	555	int fildes = fileno (rl_instream);
	556
	557	#if defined (TIOCSTOP)
	558	# if defined (apollo)
	559	ioctl (&fildes, TIOCSTOP, 0);
	560	# else
	561	ioctl (fildes, TIOCSTOP, 0);
	562	# endif /* apollo */
	563	#else /* !TIOCSTOP */
	564	# if defined (TERMIOS_TTY_DRIVER)
	565	# if defined (__ksr1__)
	566	ksrflow = 1;
	567	# endif /* ksr1 */
	568	tcflow (fildes, TCOOFF);
	569	# else
	570	# if defined (TCXONC)
	571	ioctl (fildes, TCXONC, TCOON);
	572	# endif /* TCXONC */
	573	# endif /* !TERMIOS_TTY_DRIVER */
	574	#endif /* !TIOCSTOP */
	575	}
	576	\f
	577	/* **************************************************************** */
578	/* */
579	/* Default Key Bindings */
580	/* */
581	/* **************************************************************** */
3dc889b4	582	#if !defined (__GO32__)
166557e7 PB	583	void
	584	rltty_set_default_bindings (kmap)
	585	Keymap kmap;
	586	{
	587	TIOTYPE ttybuff;
	588	int tty = fileno (rl_instream);
	589
	590	#if defined (NEW_TTY_DRIVER)
	591
	592	if (get_tty_settings (tty, &ttybuff) == 0)
	593	{
	594	if (ttybuff.flags & SGTTY_SET)
	595	{
	596	int erase, kill;
	597
	598	erase = ttybuff.sgttyb.sg_erase;
	599	kill = ttybuff.sgttyb.sg_kill;
	600
	601	if (erase != -1 && kmap[erase].type == ISFUNC)
	602	kmap[erase].function = rl_rubout;
	603
	604	if (kill != -1 && kmap[kill].type == ISFUNC)
	605	kmap[kill].function = rl_unix_line_discard;
	606	}
	607
	608	# if defined (TIOCGLTC)
	609
	610	if (ttybuff.flags & LTCHARS_SET)
	611	{
	612	int werase, nextc;
	613
	614	werase = ttybuff.ltchars.t_werasc;
	615	nextc = ttybuff.ltchars.t_lnextc;
	616
	617	if (werase != -1 && kmap[werase].type == ISFUNC)
	618	kmap[werase].function = rl_unix_word_rubout;
	619
	620	if (nextc != -1 && kmap[nextc].type == ISFUNC)
	621	kmap[nextc].function = rl_quoted_insert;
	622	}
	623	}
	624	# endif /* TIOCGLTC */
	625
	626	#else /* !NEW_TTY_DRIVER */
	627
	628	if (get_tty_settings (tty, &ttybuff) == 0)
	629	{
	630	unsigned char erase, kill;
	631
	632	erase = ttybuff.c_cc[VERASE];
	633	kill = ttybuff.c_cc[VKILL];
	634
	635	if (erase != (unsigned char)_POSIX_VDISABLE &&
	636	kmap[erase].type == ISFUNC)
	637	kmap[erase].function = rl_rubout;
	638
	639	if (kill != (unsigned char)_POSIX_VDISABLE &&
	640	kmap[kill].type == ISFUNC)
	641	kmap[kill].function = rl_unix_line_discard;
	642
	643	# if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
	644	{
	645	unsigned char nextc;
	646
647	nextc = ttybuff.c_cc[VLNEXT];
648
649	if (nextc != (unsigned char)_POSIX_VDISABLE &&
650	kmap[nextc].type == ISFUNC)
651	kmap[nextc].function = rl_quoted_insert;
652	}
653	# endif /* VLNEXT && TERMIOS_TTY_DRIVER */
654
655	# if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
656	{
657	unsigned char werase;
658
659	werase = ttybuff.c_cc[VWERASE];
660
661	if (werase != (unsigned char)_POSIX_VDISABLE &&
662	kmap[werase].type == ISFUNC)
663	kmap[werase].function = rl_unix_word_rubout;
664	}
665	# endif /* VWERASE && TERMIOS_TTY_DRIVER */
666	}
667	#endif /* !NEW_TTY_DRIVER */
668	}
3dc889b4	669	#endif /* !__GO32__ */