lib/readline/rltty.c

   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 2, 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    59 Temple Place, Suite 330, Boston, MA 02111 USA. */
  23 #define READLINE_LIBRARY
  24
  25 #if defined (HAVE_CONFIG_H)
  26 #  include <config.h>
  27 #endif
  28
  29 #include <sys/types.h>
  30 #include <signal.h>
  31 #include <errno.h>
  32 #include <stdio.h>
  33
  34 #if defined (HAVE_UNISTD_H)
  35 #  include <unistd.h>
  36 #endif /* HAVE_UNISTD_H */
  37
  38 #include "rldefs.h"
  39
  40 #if defined (GWINSZ_IN_SYS_IOCTL)
  41 #  include <sys/ioctl.h>
  42 #endif /* GWINSZ_IN_SYS_IOCTL */
  43
  44 #include "rltty.h"
  45 #include "readline.h"
  46 #include "rlprivate.h"
  47
  48 #if !defined (errno)
  49 extern int errno;
  50 #endif /* !errno */
  51
  52 rl_vintfunc_t *rl_prep_term_function = rl_prep_terminal;
  53 rl_voidfunc_t *rl_deprep_term_function = rl_deprep_terminal;
  54
  55 static void block_sigint PARAMS((void));
  56 static void release_sigint PARAMS((void));
  57
  58 static void set_winsize PARAMS((int));
  59
  60 /* **************************************************************** */
  61 /*                                                                  */
  62 /*                         Signal Management                        */
  63 /*                                                                  */
  64 /* **************************************************************** */
  65
  66 #if defined (HAVE_POSIX_SIGNALS)
  67 static sigset_t sigint_set, sigint_oset;
  68 #else /* !HAVE_POSIX_SIGNALS */
  69 #  if defined (HAVE_BSD_SIGNALS)
  70 static int sigint_oldmask;
  71 #  endif /* HAVE_BSD_SIGNALS */
  72 #endif /* !HAVE_POSIX_SIGNALS */
  73
  74 static int sigint_blocked;
  75
  76 /* Cause SIGINT to not be delivered until the corresponding call to
  77    release_sigint(). */
  78 static void
  79 block_sigint ()
  80 {
  81   if (sigint_blocked)
  82     return;
  83
  84 #if defined (HAVE_POSIX_SIGNALS)
  85   sigemptyset (&sigint_set);
  86   sigemptyset (&sigint_oset);
  87   sigaddset (&sigint_set, SIGINT);
  88   sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
  89 #else /* !HAVE_POSIX_SIGNALS */
  90 #  if defined (HAVE_BSD_SIGNALS)
  91   sigint_oldmask = sigblock (sigmask (SIGINT));
  92 #  else /* !HAVE_BSD_SIGNALS */
  93 #    if defined (HAVE_USG_SIGHOLD)
  94   sighold (SIGINT);
  95 #    endif /* HAVE_USG_SIGHOLD */
  96 #  endif /* !HAVE_BSD_SIGNALS */
  97 #endif /* !HAVE_POSIX_SIGNALS */
  98
  99   sigint_blocked = 1;
 100 }
 101
 102 /* Allow SIGINT to be delivered. */
 103 static void
 104 release_sigint ()
 105 {
 106   if (sigint_blocked == 0)
 107     return;
 108
 109 #if defined (HAVE_POSIX_SIGNALS)
 110   sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
 111 #else
 112 #  if defined (HAVE_BSD_SIGNALS)
 113   sigsetmask (sigint_oldmask);
 114 #  else /* !HAVE_BSD_SIGNALS */
 115 #    if defined (HAVE_USG_SIGHOLD)
 116   sigrelse (SIGINT);
 117 #    endif /* HAVE_USG_SIGHOLD */
 118 #  endif /* !HAVE_BSD_SIGNALS */
 119 #endif /* !HAVE_POSIX_SIGNALS */
 120
 121   sigint_blocked = 0;
 122 }
 123
 124 /* **************************************************************** */
 125 /*                                                                  */
 126 /*                    Saving and Restoring the TTY                  */
 127 /*                                                                  */
 128 /* **************************************************************** */
 129
 130 /* Non-zero means that the terminal is in a prepped state. */
 131 static int terminal_prepped;
 132
 133 static _RL_TTY_CHARS _rl_tty_chars, _rl_last_tty_chars;
 134
 135 /* If non-zero, means that this process has called tcflow(fd, TCOOFF)
 136    and output is suspended. */
 137 #if defined (__ksr1__)
 138 static int ksrflow;
 139 #endif
 140
 141 /* Dummy call to force a backgrounded readline to stop before it tries
 142    to get the tty settings. */
 143 static void
 144 set_winsize (tty)
 145      int tty;
 146 {
 147 #if defined (TIOCGWINSZ)
 148   struct winsize w;
 149
 150   if (ioctl (tty, TIOCGWINSZ, &w) == 0)
 151       (void) ioctl (tty, TIOCSWINSZ, &w);
 152 #endif /* TIOCGWINSZ */
 153 }
 154
 155 #if defined (NEW_TTY_DRIVER)
 156
 157 /* Values for the `flags' field of a struct bsdtty.  This tells which
 158    elements of the struct bsdtty have been fetched from the system and
 159    are valid. */
 160 #define SGTTY_SET       0x01
 161 #define LFLAG_SET       0x02
 162 #define TCHARS_SET      0x04
 163 #define LTCHARS_SET     0x08
 164
 165 struct bsdtty {
 166   struct sgttyb sgttyb; /* Basic BSD tty driver information. */
 167   int lflag;            /* Local mode flags, like LPASS8. */
 168 #if defined (TIOCGETC)
 169   struct tchars tchars; /* Terminal special characters, including ^S and ^Q. */
 170 #endif
 171 #if defined (TIOCGLTC)
 172   struct ltchars ltchars; /* 4.2 BSD editing characters */
 173 #endif
 174   int flags;            /* Bitmap saying which parts of the struct are valid. */
 175 };
 176
 177 #define TIOTYPE struct bsdtty
 178
 179 static TIOTYPE otio;
 180
 181 static void save_tty_chars PARAMS((TIOTYPE *));
 182 static int _get_tty_settings PARAMS((int, TIOTYPE *));
 183 static int get_tty_settings PARAMS((int, TIOTYPE *));
 184 static int _set_tty_settings PARAMS((int, TIOTYPE *));
 185 static int set_tty_settings PARAMS((int, TIOTYPE *));
 186
 187 static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
 188
 189 static void
 190 save_tty_chars (tiop)
 191      TIOTYPE *tiop;
 192 {
 193   _rl_last_tty_chars = _rl_tty_chars;
 194
 195   if (tiop->flags & SGTTY_SET)
 196     {
 197       _rl_tty_chars.t_erase = tiop->sgttyb.sg_erase;
 198       _rl_tty_chars.t_kill = tiop->sgttyb.sg_kill;
 199     }
 200
 201   if (tiop->flags & TCHARS_SET)
 202     {
 203       _rl_tty_chars.t_intr = tiop->tchars.t_intrc;
 204       _rl_tty_chars.t_quit = tiop->tchars.t_quitc;
 205       _rl_tty_chars.t_start = tiop->tchars.t_startc;
 206       _rl_tty_chars.t_stop = tiop->tchars.t_stopc;
 207       _rl_tty_chars.t_eof = tiop->tchars.t_eofc;
 208       _rl_tty_chars.t_eol = '\n';
 209       _rl_tty_chars.t_eol2 = tiop->tchars.t_brkc;
 210     }
 211
 212   if (tiop->flags & LTCHARS_SET)
 213     {
 214       _rl_tty_chars.t_susp = tiop->ltchars.t_suspc;
 215       _rl_tty_chars.t_dsusp = tiop->ltchars.t_dsuspc;
 216       _rl_tty_chars.t_reprint = tiop->ltchars.t_rprntc;
 217       _rl_tty_chars.t_flush = tiop->ltchars.t_flushc;
 218       _rl_tty_chars.t_werase = tiop->ltchars.t_werasc;
 219       _rl_tty_chars.t_lnext = tiop->ltchars.t_lnextc;
 220     }
 221
 222   _rl_tty_chars.t_status = -1;
 223 }
 224
 225 static int
 226 get_tty_settings (tty, tiop)
 227      int tty;
 228      TIOTYPE *tiop;
 229 {
 230   set_winsize (tty);
 231
 232   tiop->flags = tiop->lflag = 0;
 233
 234   if (ioctl (tty, TIOCGETP, &(tiop->sgttyb)) < 0)
 235     return -1;
 236   tiop->flags |= SGTTY_SET;
 237
 238 #if defined (TIOCLGET)
 239   if (ioctl (tty, TIOCLGET, &(tiop->lflag)) == 0)
 240     tiop->flags |= LFLAG_SET;
 241 #endif
 242
 243 #if defined (TIOCGETC)
 244   if (ioctl (tty, TIOCGETC, &(tiop->tchars)) == 0)
 245     tiop->flags |= TCHARS_SET;
 246 #endif
 247
 248 #if defined (TIOCGLTC)
 249   if (ioctl (tty, TIOCGLTC, &(tiop->ltchars)) == 0)
 250     tiop->flags |= LTCHARS_SET;
 251 #endif
 252
 253   return 0;
 254 }
 255
 256 static int
 257 set_tty_settings (tty, tiop)
 258      int tty;
 259      TIOTYPE *tiop;
 260 {
 261   if (tiop->flags & SGTTY_SET)
 262     {
 263       ioctl (tty, TIOCSETN, &(tiop->sgttyb));
 264       tiop->flags &= ~SGTTY_SET;
 265     }
 266   readline_echoing_p = 1;
 267
 268 #if defined (TIOCLSET)
 269   if (tiop->flags & LFLAG_SET)
 270     {
 271       ioctl (tty, TIOCLSET, &(tiop->lflag));
 272       tiop->flags &= ~LFLAG_SET;
 273     }
 274 #endif
 275
 276 #if defined (TIOCSETC)
 277   if (tiop->flags & TCHARS_SET)
 278     {
 279       ioctl (tty, TIOCSETC, &(tiop->tchars));
 280       tiop->flags &= ~TCHARS_SET;
 281     }
 282 #endif
 283
 284 #if defined (TIOCSLTC)
 285   if (tiop->flags & LTCHARS_SET)
 286     {
 287       ioctl (tty, TIOCSLTC, &(tiop->ltchars));
 288       tiop->flags &= ~LTCHARS_SET;
 289     }
 290 #endif
 291
 292   return 0;
 293 }
 294
 295 static void
 296 prepare_terminal_settings (meta_flag, oldtio, tiop)
 297      int meta_flag;
 298      TIOTYPE oldtio, *tiop;
 299 {
 300   readline_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
 301
 302   /* Copy the original settings to the structure we're going to use for
 303      our settings. */
 304   tiop->sgttyb = oldtio.sgttyb;
 305   tiop->lflag = oldtio.lflag;
 306 #if defined (TIOCGETC)
 307   tiop->tchars = oldtio.tchars;
 308 #endif
 309 #if defined (TIOCGLTC)
 310   tiop->ltchars = oldtio.ltchars;
 311 #endif
 312   tiop->flags = oldtio.flags;
 313
 314   /* First, the basic settings to put us into character-at-a-time, no-echo
 315      input mode. */
 316   tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
 317   tiop->sgttyb.sg_flags |= CBREAK;
 318
 319   /* If this terminal doesn't care how the 8th bit is used, then we can
 320      use it for the meta-key.  If only one of even or odd parity is
 321      specified, then the terminal is using parity, and we cannot. */
 322 #if !defined (ANYP)
 323 #  define ANYP (EVENP | ODDP)
 324 #endif
 325   if (((oldtio.sgttyb.sg_flags & ANYP) == ANYP) ||
 326       ((oldtio.sgttyb.sg_flags & ANYP) == 0))
 327     {
 328       tiop->sgttyb.sg_flags |= ANYP;
 329
 330       /* Hack on local mode flags if we can. */
 331 #if defined (TIOCLGET)
 332 #  if defined (LPASS8)
 333       tiop->lflag |= LPASS8;
 334 #  endif /* LPASS8 */
 335 #endif /* TIOCLGET */
 336     }
 337
 338 #if defined (TIOCGETC)
 339 #  if defined (USE_XON_XOFF)
 340   /* Get rid of terminal output start and stop characters. */
 341   tiop->tchars.t_stopc = -1; /* C-s */
 342   tiop->tchars.t_startc = -1; /* C-q */
 343
 344   /* If there is an XON character, bind it to restart the output. */
 345   if (oldtio.tchars.t_startc != -1)
 346     rl_bind_key (oldtio.tchars.t_startc, rl_restart_output);
 347 #  endif /* USE_XON_XOFF */
 348
 349   /* If there is an EOF char, bind _rl_eof_char to it. */
 350   if (oldtio.tchars.t_eofc != -1)
 351     _rl_eof_char = oldtio.tchars.t_eofc;
 352
 353 #  if defined (NO_KILL_INTR)
 354   /* Get rid of terminal-generated SIGQUIT and SIGINT. */
 355   tiop->tchars.t_quitc = -1; /* C-\ */
 356   tiop->tchars.t_intrc = -1; /* C-c */
 357 #  endif /* NO_KILL_INTR */
 358 #endif /* TIOCGETC */
 359
 360 #if defined (TIOCGLTC)
 361   /* Make the interrupt keys go away.  Just enough to make people happy. */
 362   tiop->ltchars.t_dsuspc = -1;  /* C-y */
 363   tiop->ltchars.t_lnextc = -1;  /* C-v */
 364 #endif /* TIOCGLTC */
 365 }
 366
 367 #else  /* !defined (NEW_TTY_DRIVER) */
 368
 369 #if !defined (VMIN)
 370 #  define VMIN VEOF
 371 #endif
 372
 373 #if !defined (VTIME)
 374 #  define VTIME VEOL
 375 #endif
 376
 377 #if defined (TERMIOS_TTY_DRIVER)
 378 #  define TIOTYPE struct termios
 379 #  define DRAIN_OUTPUT(fd)      tcdrain (fd)
 380 #  define GETATTR(tty, tiop)    (tcgetattr (tty, tiop))
 381 #  ifdef M_UNIX
 382 #    define SETATTR(tty, tiop)  (tcsetattr (tty, TCSANOW, tiop))
 383 #  else
 384 #    define SETATTR(tty, tiop)  (tcsetattr (tty, TCSADRAIN, tiop))
 385 #  endif /* !M_UNIX */
 386 #else
 387 #  define TIOTYPE struct termio
 388 #  define DRAIN_OUTPUT(fd)
 389 #  define GETATTR(tty, tiop)    (ioctl (tty, TCGETA, tiop))
 390 #  define SETATTR(tty, tiop)    (ioctl (tty, TCSETAW, tiop))
 391 #endif /* !TERMIOS_TTY_DRIVER */
 392
 393 static TIOTYPE otio;
 394
 395 static void save_tty_chars PARAMS((TIOTYPE *));
 396 static int _get_tty_settings PARAMS((int, TIOTYPE *));
 397 static int get_tty_settings PARAMS((int, TIOTYPE *));
 398 static int _set_tty_settings PARAMS((int, TIOTYPE *));
 399 static int set_tty_settings PARAMS((int, TIOTYPE *));
 400
 401 static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
 402
 403 #if defined (FLUSHO)
 404 #  define OUTPUT_BEING_FLUSHED(tp)  (tp->c_lflag & FLUSHO)
 405 #else
 406 #  define OUTPUT_BEING_FLUSHED(tp)  0
 407 #endif
 408
 409 static void
 410 save_tty_chars (tiop)
 411      TIOTYPE *tiop;
 412 {
 413   _rl_last_tty_chars = _rl_tty_chars;
 414
 415   _rl_tty_chars.t_eof = tiop->c_cc[VEOF];
 416   _rl_tty_chars.t_eol = tiop->c_cc[VEOL];
 417 #ifdef VEOL2
 418   _rl_tty_chars.t_eol2 = tiop->c_cc[VEOL2];
 419 #endif
 420   _rl_tty_chars.t_erase = tiop->c_cc[VERASE];
 421 #ifdef VWERASE
 422   _rl_tty_chars.t_werase = tiop->c_cc[VWERASE];
 423 #endif
 424   _rl_tty_chars.t_kill = tiop->c_cc[VKILL];
 425 #ifdef VREPRINT
 426   _rl_tty_chars.t_reprint = tiop->c_cc[VREPRINT];
 427 #endif
 428   _rl_tty_chars.t_intr = tiop->c_cc[VINTR];
 429   _rl_tty_chars.t_quit = tiop->c_cc[VQUIT];
 430 #ifdef VSUSP
 431   _rl_tty_chars.t_susp = tiop->c_cc[VSUSP];
 432 #endif
 433 #ifdef VDSUSP
 434   _rl_tty_chars.t_dsusp = tiop->c_cc[VDSUSP];
 435 #endif
 436 #ifdef VSTART
 437   _rl_tty_chars.t_start = tiop->c_cc[VSTART];
 438 #endif
 439 #ifdef VSTOP
 440   _rl_tty_chars.t_stop = tiop->c_cc[VSTOP];
 441 #endif
 442 #ifdef VLNEXT
 443   _rl_tty_chars.t_lnext = tiop->c_cc[VLNEXT];
 444 #endif
 445 #ifdef VDISCARD
 446   _rl_tty_chars.t_flush = tiop->c_cc[VDISCARD];
 447 #endif
 448 #ifdef VSTATUS
 449   _rl_tty_chars.t_status = tiop->c_cc[VSTATUS];
 450 #endif
 451 }
 452
 453 #if defined (_AIX) || defined (_AIX41)
 454 /* Currently this is only used on AIX */
 455 static void
 456 rltty_warning (msg)
 457      char *msg;
 458 {
 459   fprintf (stderr, "readline: warning: %s\n", msg);
 460 }
 461 #endif
 462
 463 #if defined (_AIX)
 464 void
 465 setopost(tp)
 466 TIOTYPE *tp;
 467 {
 468   if ((tp->c_oflag & OPOST) == 0)
 469     {
 470       rltty_warning ("turning on OPOST for terminal\r");
 471       tp->c_oflag |= OPOST|ONLCR;
 472     }
 473 }
 474 #endif
 475
 476 static int
 477 _get_tty_settings (tty, tiop)
 478      int tty;
 479      TIOTYPE *tiop;
 480 {
 481   int ioctl_ret;
 482
 483   while (1)
 484     {
 485       ioctl_ret = GETATTR (tty, tiop);
 486       if (ioctl_ret < 0)
 487         {
 488           if (errno != EINTR)
 489             return -1;
 490           else
 491             continue;
 492         }
 493       if (OUTPUT_BEING_FLUSHED (tiop))
 494         {
 495 #if defined (FLUSHO) && defined (_AIX41)
 496           rltty_warning ("turning off output flushing");
 497           tiop->c_lflag &= ~FLUSHO;
 498           break;
 499 #else
 500           continue;
 501 #endif
 502         }
 503       break;
 504     }
 505
 506   return 0;
 507 }
 508
 509 static int
 510 get_tty_settings (tty, tiop)
 511      int tty;
 512      TIOTYPE *tiop;
 513 {
 514   set_winsize (tty);
 515
 516   if (_get_tty_settings (tty, tiop) < 0)
 517     return -1;
 518
 519 #if defined (_AIX)
 520   setopost(tiop);
 521 #endif
 522
 523   return 0;
 524 }
 525
 526 static int
 527 _set_tty_settings (tty, tiop)
 528      int tty;
 529      TIOTYPE *tiop;
 530 {
 531   while (SETATTR (tty, tiop) < 0)
 532     {
 533       if (errno != EINTR)
 534         return -1;
 535       errno = 0;
 536     }
 537   return 0;
 538 }
 539
 540 static int
 541 set_tty_settings (tty, tiop)
 542      int tty;
 543      TIOTYPE *tiop;
 544 {
 545   if (_set_tty_settings (tty, tiop) < 0)
 546     return -1;
 547
 548 #if 0
 549
 550 #if defined (TERMIOS_TTY_DRIVER)
 551 #  if defined (__ksr1__)
 552   if (ksrflow)
 553     {
 554       ksrflow = 0;
 555       tcflow (tty, TCOON);
 556     }
 557 #  else /* !ksr1 */
 558   tcflow (tty, TCOON);          /* Simulate a ^Q. */
 559 #  endif /* !ksr1 */
 560 #else
 561   ioctl (tty, TCXONC, 1);       /* Simulate a ^Q. */
 562 #endif /* !TERMIOS_TTY_DRIVER */
 563
 564 #endif /* 0 */
 565
 566   return 0;
 567 }
 568
 569 static void
 570 prepare_terminal_settings (meta_flag, oldtio, tiop)
 571      int meta_flag;
 572      TIOTYPE oldtio, *tiop;
 573 {
 574   readline_echoing_p = (oldtio.c_lflag & ECHO);
 575
 576   tiop->c_lflag &= ~(ICANON | ECHO);
 577
 578   if ((unsigned char) oldtio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
 579     _rl_eof_char = oldtio.c_cc[VEOF];
 580
 581 #if defined (USE_XON_XOFF)
 582 #if defined (IXANY)
 583   tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
 584 #else
 585   /* `strict' Posix systems do not define IXANY. */
 586   tiop->c_iflag &= ~(IXON | IXOFF);
 587 #endif /* IXANY */
 588 #endif /* USE_XON_XOFF */
 589
 590   /* Only turn this off if we are using all 8 bits. */
 591   if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag)
 592     tiop->c_iflag &= ~(ISTRIP | INPCK);
 593
 594   /* Make sure we differentiate between CR and NL on input. */
 595   tiop->c_iflag &= ~(ICRNL | INLCR);
 596
 597 #if !defined (HANDLE_SIGNALS)
 598   tiop->c_lflag &= ~ISIG;
 599 #else
 600   tiop->c_lflag |= ISIG;
 601 #endif
 602
 603   tiop->c_cc[VMIN] = 1;
 604   tiop->c_cc[VTIME] = 0;
 605
 606 #if defined (FLUSHO)
 607   if (OUTPUT_BEING_FLUSHED (tiop))
 608     {
 609       tiop->c_lflag &= ~FLUSHO;
 610       oldtio.c_lflag &= ~FLUSHO;
 611     }
 612 #endif
 613
 614   /* Turn off characters that we need on Posix systems with job control,
 615      just to be sure.  This includes ^Y and ^V.  This should not really
 616      be necessary.  */
 617 #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)
 618
 619 #if defined (VLNEXT)
 620   tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
 621 #endif
 622
 623 #if defined (VDSUSP)
 624   tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
 625 #endif
 626
 627 #endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
 628 }
 629 #endif  /* NEW_TTY_DRIVER */
 630
 631 /* Put the terminal in CBREAK mode so that we can detect key presses. */
 632 void
 633 rl_prep_terminal (meta_flag)
 634      int meta_flag;
 635 {
 636   int tty;
 637   TIOTYPE tio;
 638
 639   if (terminal_prepped)
 640     return;
 641
 642   /* Try to keep this function from being INTerrupted. */
 643   block_sigint ();
 644
 645   tty = fileno (rl_instream);
 646
 647   if (get_tty_settings (tty, &tio) < 0)
 648     {
 649       release_sigint ();
 650 fprintf(stderr, "readline: warning: rl_prep_terminal: cannot get terminal settings");
 651       return;
 652     }
 653
 654   otio = tio;
 655
 656   save_tty_chars (&otio);
 657
 658   prepare_terminal_settings (meta_flag, otio, &tio);
 659
 660   if (set_tty_settings (tty, &tio) < 0)
 661     {
 662       release_sigint ();
 663       return;
 664     }
 665
 666   if (_rl_enable_keypad)
 667     _rl_control_keypad (1);
 668
 669   fflush (rl_outstream);
 670   terminal_prepped = 1;
 671   RL_SETSTATE(RL_STATE_TERMPREPPED);
 672
 673   release_sigint ();
 674 }
 675
 676 /* Restore the terminal's normal settings and modes. */
 677 void
 678 rl_deprep_terminal ()
 679 {
 680   int tty;
 681
 682   if (!terminal_prepped)
 683     return;
 684
 685   /* Try to keep this function from being interrupted. */
 686   block_sigint ();
 687
 688   tty = fileno (rl_instream);
 689
 690   if (_rl_enable_keypad)
 691     _rl_control_keypad (0);
 692
 693   fflush (rl_outstream);
 694
 695   if (set_tty_settings (tty, &otio) < 0)
 696     {
 697       release_sigint ();
 698       return;
 699     }
 700
 701   terminal_prepped = 0;
 702   RL_UNSETSTATE(RL_STATE_TERMPREPPED);
 703
 704   release_sigint ();
 705 }
 706 \f
 707 /* **************************************************************** */
 708 /*                                                                  */
 709 /*                      Bogus Flow Control                          */
 710 /*                                                                  */
 711 /* **************************************************************** */
 712
 713 int
 714 rl_restart_output (count, key)
 715      int count, key;
 716 {
 717   int fildes = fileno (rl_outstream);
 718 #if defined (TIOCSTART)
 719 #if defined (apollo)
 720   ioctl (&fildes, TIOCSTART, 0);
 721 #else
 722   ioctl (fildes, TIOCSTART, 0);
 723 #endif /* apollo */
 724
 725 #else /* !TIOCSTART */
 726 #  if defined (TERMIOS_TTY_DRIVER)
 727 #    if defined (__ksr1__)
 728   if (ksrflow)
 729     {
 730       ksrflow = 0;
 731       tcflow (fildes, TCOON);
 732     }
 733 #    else /* !ksr1 */
 734   tcflow (fildes, TCOON);               /* Simulate a ^Q. */
 735 #    endif /* !ksr1 */
 736 #  else /* !TERMIOS_TTY_DRIVER */
 737 #    if defined (TCXONC)
 738   ioctl (fildes, TCXONC, TCOON);
 739 #    endif /* TCXONC */
 740 #  endif /* !TERMIOS_TTY_DRIVER */
 741 #endif /* !TIOCSTART */
 742
 743   return 0;
 744 }
 745
 746 int
 747 rl_stop_output (count, key)
 748      int count, key;
 749 {
 750   int fildes = fileno (rl_instream);
 751
 752 #if defined (TIOCSTOP)
 753 # if defined (apollo)
 754   ioctl (&fildes, TIOCSTOP, 0);
 755 # else
 756   ioctl (fildes, TIOCSTOP, 0);
 757 # endif /* apollo */
 758 #else /* !TIOCSTOP */
 759 # if defined (TERMIOS_TTY_DRIVER)
 760 #  if defined (__ksr1__)
 761   ksrflow = 1;
 762 #  endif /* ksr1 */
 763   tcflow (fildes, TCOOFF);
 764 # else
 765 #   if defined (TCXONC)
 766   ioctl (fildes, TCXONC, TCOON);
 767 #   endif /* TCXONC */
 768 # endif /* !TERMIOS_TTY_DRIVER */
 769 #endif /* !TIOCSTOP */
 770
 771   return 0;
 772 }
 773
 774 /* **************************************************************** */
 775 /*                                                                  */
 776 /*                      Default Key Bindings                        */
 777 /*                                                                  */
 778 /* **************************************************************** */
 779
 780 /* Set the system's default editing characters to their readline equivalents
 781    in KMAP.  Should be static, now that we have rl_tty_set_default_bindings. */
 782 void
 783 rltty_set_default_bindings (kmap)
 784      Keymap kmap;
 785 {
 786   TIOTYPE ttybuff;
 787   int tty = fileno (rl_instream);
 788
 789 #if defined (NEW_TTY_DRIVER)
 790
 791 #define SET_SPECIAL(sc, func) \
 792   do \
 793     { \
 794       int ic; \
 795       ic = sc; \
 796       if (ic != -1 && kmap[(unsigned char)ic].type == ISFUNC) \
 797         kmap[(unsigned char)ic].function = func; \
 798     } \
 799   while (0)
 800
 801   if (get_tty_settings (tty, &ttybuff) == 0)
 802     {
 803       if (ttybuff.flags & SGTTY_SET)
 804         {
 805           SET_SPECIAL (ttybuff.sgttyb.sg_erase, rl_rubout);
 806           SET_SPECIAL (ttybuff.sgttyb.sg_kill, rl_unix_line_discard);
 807         }
 808
 809 #  if defined (TIOCGLTC)
 810       if (ttybuff.flags & LTCHARS_SET)
 811         {
 812           SET_SPECIAL (ttybuff.ltchars.t_werasc, rl_unix_word_rubout);
 813           SET_SPECIAL (ttybuff.ltchars.t_lnextc, rl_quoted_insert);
 814         }
 815 #  endif /* TIOCGLTC */
 816     }
 817
 818 #else /* !NEW_TTY_DRIVER */
 819
 820 #define SET_SPECIAL(sc, func) \
 821   do \
 822     { \
 823       unsigned char uc; \
 824       uc = ttybuff.c_cc[sc]; \
 825       if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC) \
 826         kmap[uc].function = func; \
 827     } \
 828   while (0)
 829
 830   if (get_tty_settings (tty, &ttybuff) == 0)
 831     {
 832       SET_SPECIAL (VERASE, rl_rubout);
 833       SET_SPECIAL (VKILL, rl_unix_line_discard);
 834
 835 #  if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
 836       SET_SPECIAL (VLNEXT, rl_quoted_insert);
 837 #  endif /* VLNEXT && TERMIOS_TTY_DRIVER */
 838
 839 #  if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
 840       SET_SPECIAL (VWERASE, rl_unix_word_rubout);
 841 #  endif /* VWERASE && TERMIOS_TTY_DRIVER */
 842     }
 843 #endif /* !NEW_TTY_DRIVER */
 844 }
 845
 846 /* New public way to set the system default editing chars to their readline
 847    equivalents. */
 848 void
 849 rl_tty_set_default_bindings (kmap)
 850      Keymap kmap;
 851 {
 852   rltty_set_default_bindings (kmap);
 853 }
 854
 855 #if defined (HANDLE_SIGNALS)
 856
 857 #if defined (NEW_TTY_DRIVER)
 858 int
 859 _rl_disable_tty_signals ()
 860 {
 861   return 0;
 862 }
 863
 864 int
 865 _rl_restore_tty_signals ()
 866 {
 867   return 0;
 868 }
 869 #else
 870
 871 static TIOTYPE sigstty, nosigstty;
 872 static int tty_sigs_disabled = 0;
 873
 874 int
 875 _rl_disable_tty_signals ()
 876 {
 877   if (tty_sigs_disabled)
 878     return 0;
 879
 880   if (_get_tty_settings (fileno (rl_instream), &sigstty) < 0)
 881     return -1;
 882
 883   nosigstty = sigstty;
 884
 885   nosigstty.c_lflag &= ~ISIG;
 886   nosigstty.c_iflag &= ~IXON;
 887
 888   if (_set_tty_settings (fileno (rl_instream), &nosigstty) < 0)
 889     return (_set_tty_settings (fileno (rl_instream), &sigstty));
 890
 891   tty_sigs_disabled = 1;
 892   return 0;
 893 }
 894
 895 int
 896 _rl_restore_tty_signals ()
 897 {
 898   int r;
 899
 900   if (tty_sigs_disabled == 0)
 901     return 0;
 902
 903   r = _set_tty_settings (fileno (rl_instream), &sigstty);
 904
 905   if (r == 0)
 906     tty_sigs_disabled = 0;
 907
 908   return r;
 909 }
 910 #endif /* !NEW_TTY_DRIVER */
 911
 912 #endif /* HANDLE_SIGNALS */