开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
rltty.c
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：16k
源码类别：

MySQL数据库

开发平台：

Visual C++

rltty.c：源码内容
  1. /* rltty.c -- functions to prepare and restore the terminal for readline's
  2.    use. */
  4. /* Copyright (C) 1992 Free Software Foundation, Inc.
  6.    This file is part of the GNU Readline Library, a library for
  7.    reading lines of text with interactive input and history editing.
  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.
  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.
  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. */
  23. #define READLINE_LIBRARY
  25. #if defined (HAVE_CONFIG_H)
  26. #  include <config.h>
  27. #endif
  29. #include <sys/types.h>
  30. #include <signal.h>
  31. #include <errno.h>
  32. #include <stdio.h>
  34. #if defined (HAVE_UNISTD_H)
  35. #  include <unistd.h>
  36. #endif /* HAVE_UNISTD_H */
  38. #include "rldefs.h"
  40. #if defined (GWINSZ_IN_SYS_IOCTL)
  41. #  include <sys/ioctl.h>
  42. #endif /* GWINSZ_IN_SYS_IOCTL */
  44. #include "rltty.h"
  45. #include "readline.h"
  47. #if !defined (errno)
  48. extern int errno;
  49. #endif /* !errno */
  51. extern int readline_echoing_p;
  52. extern int _rl_eof_char;
  54. extern int _rl_enable_keypad, _rl_enable_meta;
  56. extern void _rl_control_keypad ();
  58. #if defined (__GO32__)
  59. #  include <pc.h>
  60. #  undef HANDLE_SIGNALS
  61. #endif /* __GO32__ */
  63. /* Indirect functions to allow apps control over terminal management. */
  64. extern void rl_prep_terminal (), rl_deprep_terminal ();
  66. VFunction *rl_prep_term_function = rl_prep_terminal;
  67. VFunction *rl_deprep_term_function = rl_deprep_terminal;
  69. /* **************************************************************** */
  70. /*     */
  71. /*    Signal Management     */
  72. /*     */
  73. /* **************************************************************** */
  75. #if defined (HAVE_POSIX_SIGNALS)
  76. static sigset_t sigint_set, sigint_oset;
  77. #else /* !HAVE_POSIX_SIGNALS */
  78. #  if defined (HAVE_BSD_SIGNALS)
  79. static int sigint_oldmask;
  80. #  endif /* HAVE_BSD_SIGNALS */
  81. #endif /* !HAVE_POSIX_SIGNALS */
  83. static int sigint_blocked;
  85. /* Cause SIGINT to not be delivered until the corresponding call to
  86.    release_sigint(). */
  87. static void
  88. block_sigint ()
  89. {
  90.   if (sigint_blocked)
  91.     return;
  93. #if defined (HAVE_POSIX_SIGNALS)
  94.   sigemptyset (&sigint_set);
  95.   sigemptyset (&sigint_oset);
  96.   sigaddset (&sigint_set, SIGINT);
  97.   sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
  98. #else /* !HAVE_POSIX_SIGNALS */
  99. #  if defined (HAVE_BSD_SIGNALS)
  100.   sigint_oldmask = sigblock (sigmask (SIGINT));
  101. #  else /* !HAVE_BSD_SIGNALS */
  102. #    if defined (HAVE_USG_SIGHOLD)
  103.   sighold (SIGINT);
  104. #    endif /* HAVE_USG_SIGHOLD */
  105. #  endif /* !HAVE_BSD_SIGNALS */
  106. #endif /* !HAVE_POSIX_SIGNALS */
  107.   sigint_blocked = 1;
  108. }
  110. /* Allow SIGINT to be delivered. */
  111. static void
  112. release_sigint ()
  113. {
  114.   if (!sigint_blocked)
  115.     return;
  117. #if defined (HAVE_POSIX_SIGNALS)
  118.   sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
  119. #else
  120. #  if defined (HAVE_BSD_SIGNALS)
  121.   sigsetmask (sigint_oldmask);
  122. #  else /* !HAVE_BSD_SIGNALS */
  123. #    if defined (HAVE_USG_SIGHOLD)
  124.   sigrelse (SIGINT);
  125. #    endif /* HAVE_USG_SIGHOLD */
  126. #  endif /* !HAVE_BSD_SIGNALS */
  127. #endif /* !HAVE_POSIX_SIGNALS */
  129.   sigint_blocked = 0;
  130. }
  132. /* **************************************************************** */
  133. /*     */
  134. /*       Saving and Restoring the TTY          */
  135. /*     */
  136. /* **************************************************************** */
  138. /* Non-zero means that the terminal is in a prepped state. */
  139. static int terminal_prepped;
  141. /* If non-zero, means that this process has called tcflow(fd, TCOOFF)
  142.    and output is suspended. */
  143. #if defined (__ksr1__)
  144. static int ksrflow;
  145. #endif
  147. #if defined (TIOCGWINSZ)
  148. /* Dummy call to force a backgrounded readline to stop before it tries
  149.    to get the tty settings. */
  150. static void
  151. set_winsize (tty)
  152.      int tty;
  153. {
  154.   struct winsize w;
  156.   if (ioctl (tty, TIOCGWINSZ, &w) == 0)
  157.       (void) ioctl (tty, TIOCSWINSZ, &w);
  158. }
  159. #else
  160. static void
  161. set_winsize (tty)
  162.      int tty;
  163. {
  164. // dummy function, required by other code. What should be doing?
  165. }
  166. #endif /* TIOCGWINSZ */
  168. #if defined (NEW_TTY_DRIVER)
  170. /* Values for the `flags' field of a struct bsdtty.  This tells which
  171.    elements of the struct bsdtty have been fetched from the system and
  172.    are valid. */
  173. #define SGTTY_SET 0x01
  174. #define LFLAG_SET 0x02
  175. #define TCHARS_SET 0x04
  176. #define LTCHARS_SET 0x08
  178. struct bsdtty {
  179.   struct sgttyb sgttyb; /* Basic BSD tty driver information. */
  180.   int lflag; /* Local mode flags, like LPASS8. */
  181. #if defined (TIOCGETC)
  182.   struct tchars tchars; /* Terminal special characters, including ^S and ^Q. */
  183. #endif
  184. #if defined (TIOCGLTC)
  185.   struct ltchars ltchars; /* 4.2 BSD editing characters */
  186. #endif
  187.   int flags; /* Bitmap saying which parts of the struct are valid. */
  188. };
  190. #define TIOTYPE struct bsdtty
  192. static TIOTYPE otio;
  194. static int
  195. get_tty_settings (tty, tiop)
  196.      int tty;
  197.      TIOTYPE *tiop;
  198. {
  199.   set_winsize (tty);
  201.   tiop->flags = tiop->lflag = 0;
  203.   ioctl (tty, TIOCGETP, &(tiop->sgttyb));
  204.   tiop->flags |= SGTTY_SET;
  206. #if defined (TIOCLGET)
  207.   ioctl (tty, TIOCLGET, &(tiop->lflag));
  208.   tiop->flags |= LFLAG_SET;
  209. #endif
  211. #if defined (TIOCGETC)
  212.   ioctl (tty, TIOCGETC, &(tiop->tchars));
  213.   tiop->flags |= TCHARS_SET;
  214. #endif
  216. #if defined (TIOCGLTC)
  217.   ioctl (tty, TIOCGLTC, &(tiop->ltchars));
  218.   tiop->flags |= LTCHARS_SET;
  219. #endif
  221.   return 0;
  222. }
  224. static int
  225. set_tty_settings (tty, tiop)
  226.      int tty;
  227.      TIOTYPE *tiop;
  228. {
  229.   if (tiop->flags & SGTTY_SET)
  230.     {
  231.       ioctl (tty, TIOCSETN, &(tiop->sgttyb));
  232.       tiop->flags &= ~SGTTY_SET;
  233.     }
  234.   readline_echoing_p = 1;
  236. #if defined (TIOCLSET)
  237.   if (tiop->flags & LFLAG_SET)
  238.     {
  239.       ioctl (tty, TIOCLSET, &(tiop->lflag));
  240.       tiop->flags &= ~LFLAG_SET;
  241.     }
  242. #endif
  244. #if defined (TIOCSETC)
  245.   if (tiop->flags & TCHARS_SET)
  246.     {
  247.       ioctl (tty, TIOCSETC, &(tiop->tchars));
  248.       tiop->flags &= ~TCHARS_SET;
  249.     }
  250. #endif
  252. #if defined (TIOCSLTC)
  253.   if (tiop->flags & LTCHARS_SET)
  254.     {
  255.       ioctl (tty, TIOCSLTC, &(tiop->ltchars));
  256.       tiop->flags &= ~LTCHARS_SET;
  257.     }
  258. #endif
  260.   return 0;
  261. }
  263. static void
  264. prepare_terminal_settings (meta_flag, otio, tiop)
  265.      int meta_flag;
  266.      TIOTYPE otio, *tiop;
  267. {
  268. #if !defined (__GO32__)
  269.   readline_echoing_p = (otio.sgttyb.sg_flags & ECHO);
  271.   /* Copy the original settings to the structure we're going to use for
  272.      our settings. */
  273.   tiop->sgttyb = otio.sgttyb;
  274.   tiop->lflag = otio.lflag;
  275. #if defined (TIOCGETC)
  276.   tiop->tchars = otio.tchars;
  277. #endif
  278. #if defined (TIOCGLTC)
  279.   tiop->ltchars = otio.ltchars;
  280. #endif
  281.   tiop->flags = otio.flags;
  283.   /* First, the basic settings to put us into character-at-a-time, no-echo
  284.      input mode. */
  285.   tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
  286.   tiop->sgttyb.sg_flags |= CBREAK;
  288.   /* If this terminal doesn't care how the 8th bit is used, then we can
  289.      use it for the meta-key.  If only one of even or odd parity is
  290.      specified, then the terminal is using parity, and we cannot. */
  291. #if !defined (ANYP)
  292. #  define ANYP (EVENP | ODDP)
  293. #endif
  294.   if (((otio.sgttyb.sg_flags & ANYP) == ANYP) ||
  295.       ((otio.sgttyb.sg_flags & ANYP) == 0))
  296.     {
  297.       tiop->sgttyb.sg_flags |= ANYP;
  299.       /* Hack on local mode flags if we can. */
  300. #if defined (TIOCLGET)
  301. #  if defined (LPASS8)
  302.       tiop->lflag |= LPASS8;
  303. #  endif /* LPASS8 */
  304. #endif /* TIOCLGET */
  305.     }
  307. #if defined (TIOCGETC)
  308. #  if defined (USE_XON_XOFF)
  309.   /* Get rid of terminal output start and stop characters. */
  310.   tiop->tchars.t_stopc = -1; /* C-s */
  311.   tiop->tchars.t_startc = -1; /* C-q */
  313.   /* If there is an XON character, bind it to restart the output. */
  314.   if (otio.tchars.t_startc != -1)
  315.     rl_bind_key (otio.tchars.t_startc, rl_restart_output);
  316. #  endif /* USE_XON_XOFF */
  318.   /* If there is an EOF char, bind _rl_eof_char to it. */
  319.   if (otio.tchars.t_eofc != -1)
  320.     _rl_eof_char = otio.tchars.t_eofc;
  322. #  if defined (NO_KILL_INTR)
  323.   /* Get rid of terminal-generated SIGQUIT and SIGINT. */
  324.   tiop->tchars.t_quitc = -1; /* C- */
  325.   tiop->tchars.t_intrc = -1; /* C-c */
  326. #  endif /* NO_KILL_INTR */
  327. #endif /* TIOCGETC */
  329. #if defined (TIOCGLTC)
  330.   /* Make the interrupt keys go away.  Just enough to make people happy. */
  331.   tiop->ltchars.t_dsuspc = -1; /* C-y */
  332.   tiop->ltchars.t_lnextc = -1; /* C-v */
  333. #endif /* TIOCGLTC */
  334. #endif /* !__GO32__ */
  335. }
  337. #else  /* !defined (NEW_TTY_DRIVER) */
  339. #if !defined (VMIN)
  340. #  define VMIN VEOF
  341. #endif
  343. #if !defined (VTIME)
  344. #  define VTIME VEOL
  345. #endif
  347. #if defined (TERMIOS_TTY_DRIVER)
  348. #  define TIOTYPE struct termios
  349. #  define DRAIN_OUTPUT(fd) tcdrain (fd)
  350. #  define GETATTR(tty, tiop) (tcgetattr (tty, tiop))
  351. #  ifdef M_UNIX
  352. #    define SETATTR(tty, tiop) (tcsetattr (tty, TCSANOW, tiop))
  353. #  else
  354. #    define SETATTR(tty, tiop) (tcsetattr (tty, TCSADRAIN, tiop))
  355. #  endif /* !M_UNIX */
  356. #else
  357. #  define TIOTYPE struct termio
  358. #  define DRAIN_OUTPUT(fd)
  359. #  define GETATTR(tty, tiop) (ioctl (tty, TCGETA, tiop))
  360. #  define SETATTR(tty, tiop) (ioctl (tty, TCSETA, tiop))
  361. #endif /* !TERMIOS_TTY_DRIVER */
  363. static TIOTYPE otio;
  365. #if defined (FLUSHO)
  366. #  define OUTPUT_BEING_FLUSHED(tp)  (tp->c_lflag & FLUSHO)
  367. #else
  368. #  define OUTPUT_BEING_FLUSHED(tp)  0
  369. #endif
  371. static void
  372. rltty_warning (msg)
  373.      char *msg;
  374. {
  375.   fprintf (stderr, "readline: warning: %sn", msg);
  376. }
  378. #if defined (_AIX)
  379. void
  380. setopost(tp)
  381. TIOTYPE *tp;
  382. {
  383.   if ((tp->c_oflag & OPOST) == 0)
  384.     {
  385.       rltty_warning ("turning on OPOST for terminalr");
  386.       tp->c_oflag |= OPOST|ONLCR;
  387.     }
  388. }
  389. #endif
  391. static int
  392. get_tty_settings (tty, tiop)
  393.      int tty;
  394.      TIOTYPE *tiop;
  395. {
  396.   int ioctl_ret;
  398.   set_winsize (tty);
  400.   while (1)
  401.     {
  402.       ioctl_ret = GETATTR (tty, tiop);
  403.       if (ioctl_ret < 0)
  404. {
  405.   if (errno != EINTR)
  406.     return -1;
  407.   else
  408.     continue;
  409. }
  410.       if (OUTPUT_BEING_FLUSHED (tiop))
  411. {
  412. #if defined (FLUSHO) && defined (_AIX41)
  413.   rltty_warning ("turning off output flushing");
  414.   tiop->c_lflag &= ~FLUSHO;
  415.   break;
  416. #else
  417.   continue;
  418. #endif
  419. }
  420.       break;
  421.     }
  423. #if defined (_AIX)
  424.   setopost(tiop);
  425. #endif
  427.   return 0;
  428. }
  430. static int
  431. set_tty_settings (tty, tiop)
  432.      int tty;
  433.      TIOTYPE *tiop;
  434. {
  435.   while (SETATTR (tty, tiop) < 0)
  436.     {
  437.       if (errno != EINTR)
  438. return -1;
  439.       errno = 0;
  440.     }
  442. #if 0
  444. #if defined (TERMIOS_TTY_DRIVER)
  445. #  if defined (__ksr1__)
  446.   if (ksrflow)
  447.     {
  448.       ksrflow = 0;
  449.       tcflow (tty, TCOON);
  450.     }
  451. #  else /* !ksr1 */
  452.   tcflow (tty, TCOON); /* Simulate a ^Q. */
  453. #  endif /* !ksr1 */
  454. #else
  455.   ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */
  456. #endif /* !TERMIOS_TTY_DRIVER */
  458. #endif
  460.   return 0;
  461. }
  463. static void
  464. prepare_terminal_settings (meta_flag, otio, tiop)
  465.      int meta_flag;
  466.      TIOTYPE otio, *tiop;
  467. {
  468.   readline_echoing_p = (otio.c_lflag & ECHO);
  470.   tiop->c_lflag &= ~(ICANON | ECHO);
  472.   if ((unsigned char) otio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
  473.     _rl_eof_char = otio.c_cc[VEOF];
  475. #if defined (USE_XON_XOFF)
  476. #if defined (IXANY)
  477.   tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
  478. #else
  479.   /* `strict' Posix systems do not define IXANY. */
  480.   tiop->c_iflag &= ~(IXON | IXOFF);
  481. #endif /* IXANY */
  482. #endif /* USE_XON_XOFF */
  484.   /* Only turn this off if we are using all 8 bits. */
  485.   if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag)
  486.     tiop->c_iflag &= ~(ISTRIP | INPCK);
  488.   /* Make sure we differentiate between CR and NL on input. */
  489.   tiop->c_iflag &= ~(ICRNL | INLCR);
  491. #if !defined (HANDLE_SIGNALS)
  492.   tiop->c_lflag &= ~ISIG;
  493. #else
  494.   tiop->c_lflag |= ISIG;
  495. #endif
  497.   tiop->c_cc[VMIN] = 1;
  498.   tiop->c_cc[VTIME] = 0;
  500. #if defined (FLUSHO)
  501.   if (OUTPUT_BEING_FLUSHED (tiop))
  502.     {
  503.       tiop->c_lflag &= ~FLUSHO;
  504.       otio.c_lflag &= ~FLUSHO;
  505.     }
  506. #endif
  508.   /* Turn off characters that we need on Posix systems with job control,
  509.      just to be sure.  This includes ^Y and ^V.  This should not really
  510.      be necessary.  */
  511. #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)
  513. #if defined (VLNEXT)
  514.   tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
  515. #endif
  517. #if defined (VDSUSP)
  518.   tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
  519. #endif
  521. #endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
  522. }
  523. #endif  /* NEW_TTY_DRIVER */
  525. /* Put the terminal in CBREAK mode so that we can detect key presses. */
  526. void
  527. rl_prep_terminal (meta_flag)
  528.      int meta_flag;
  529. {
  530. #if !defined (__GO32__)
  531.   int tty;
  532.   TIOTYPE tio;
  534.   if (terminal_prepped)
  535.     return;
  537.   /* Try to keep this function from being INTerrupted. */
  538.   block_sigint ();
  540.   tty = fileno (rl_instream);
  542.   if (get_tty_settings (tty, &tio) < 0)
  543.     {
  544.       release_sigint ();
  545.       return;
  546.     }
  548.   otio = tio;
  550.   prepare_terminal_settings (meta_flag, otio, &tio);
  552.   if (set_tty_settings (tty, &tio) < 0)
  553.     {
  554.       release_sigint ();
  555.       return;
  556.     }
  558.   if (_rl_enable_keypad)
  559.     _rl_control_keypad (1);
  561.   fflush (rl_outstream);
  562.   terminal_prepped = 1;
  564.   release_sigint ();
  565. #endif /* !__GO32__ */
  566. }
  568. /* Restore the terminal's normal settings and modes. */
  569. void
  570. rl_deprep_terminal ()
  571. {
  572. #if !defined (__GO32__)
  573.   int tty;
  575.   if (!terminal_prepped)
  576.     return;
  578.   /* Try to keep this function from being interrupted. */
  579.   block_sigint ();
  581.   tty = fileno (rl_instream);
  583.   if (_rl_enable_keypad)
  584.     _rl_control_keypad (0);
  586.   fflush (rl_outstream);
  588.   if (set_tty_settings (tty, &otio) < 0)
  589.     {
  590.       release_sigint ();
  591.       return;
  592.     }
  594.   terminal_prepped = 0;
  596.   release_sigint ();
  597. #endif /* !__GO32__ */
  598. }
  600. /* **************************************************************** */
  601. /*     */
  602. /* Bogus Flow Control           */
  603. /*     */
  604. /* **************************************************************** */
  606. int
  607. rl_restart_output (count, key)
  608.      int count, key;
  609. {
  610.   int fildes = fileno (rl_outstream);
  611. #if defined (TIOCSTART)
  612. #if defined (apollo)
  613.   ioctl (&fildes, TIOCSTART, 0);
  614. #else
  615.   ioctl (fildes, TIOCSTART, 0);
  616. #endif /* apollo */
  618. #else /* !TIOCSTART */
  619. #  if defined (TERMIOS_TTY_DRIVER)
  620. #    if defined (__ksr1__)
  621.   if (ksrflow)
  622.     {
  623.       ksrflow = 0;
  624.       tcflow (fildes, TCOON);
  625.     }
  626. #    else /* !ksr1 */
  627.   tcflow (fildes, TCOON); /* Simulate a ^Q. */
  628. #    endif /* !ksr1 */
  629. #  else /* !TERMIOS_TTY_DRIVER */
  630. #    if defined (TCXONC)
  631.   ioctl (fildes, TCXONC, TCOON);
  632. #    endif /* TCXONC */
  633. #  endif /* !TERMIOS_TTY_DRIVER */
  634. #endif /* !TIOCSTART */
  636.   return 0;
  637. }
  639. int
  640. rl_stop_output (count, key)
  641.      int count, key;
  642. {
  643.   int fildes = fileno (rl_instream);
  645. #if defined (TIOCSTOP)
  646. # if defined (apollo)
  647.   ioctl (&fildes, TIOCSTOP, 0);
  648. # else
  649.   ioctl (fildes, TIOCSTOP, 0);
  650. # endif /* apollo */
  651. #else /* !TIOCSTOP */
  652. # if defined (TERMIOS_TTY_DRIVER)
  653. #  if defined (__ksr1__)
  654.   ksrflow = 1;
  655. #  endif /* ksr1 */
  656.   tcflow (fildes, TCOOFF);
  657. # else
  658. #   if defined (TCXONC)
  659.   ioctl (fildes, TCXONC, TCOON);
  660. #   endif /* TCXONC */
  661. # endif /* !TERMIOS_TTY_DRIVER */
  662. #endif /* !TIOCSTOP */
  664.   return 0;
  665. }
  667. /* **************************************************************** */
  668. /*     */
  669. /* Default Key Bindings     */
  670. /*     */
  671. /* **************************************************************** */
  672. void
  673. rltty_set_default_bindings (kmap)
  674.      Keymap kmap;
  675. {
  676.   TIOTYPE ttybuff;
  677.   int tty = fileno (rl_instream);
  679. #if defined (NEW_TTY_DRIVER)
  681. #define SET_SPECIAL(sc, func) 
  682.   do 
  683.     { 
  684.       int ic; 
  685.       ic = sc; 
  686.       if (ic != -1 && kmap[ic].type == ISFUNC) 
  687. kmap[ic].function = func; 
  688.     } 
  689.   while (0)
  691.   if (get_tty_settings (tty, &ttybuff) == 0)
  692.     {
  693.       if (ttybuff.flags & SGTTY_SET)
  694. {
  695.   SET_SPECIAL (ttybuff.sgttyb.sg_erase, rl_rubout);
  696.   SET_SPECIAL (ttybuff.sgttyb.sg_kill, rl_unix_line_discard);
  697. }
  699. #  if defined (TIOCGLTC)
  700.       if (ttybuff.flags & LTCHARS_SET)
  701. {
  702.   SET_SPECIAL (ttybuff.ltchars.t_werasc, rl_unix_word_rubout);
  703.   SET_SPECIAL (ttybuff.ltchars.t_lnextc, rl_quoted_insert);
  704. }
  705. #  endif /* TIOCGLTC */
  706.     }
  708. #else /* !NEW_TTY_DRIVER */
  710. #define SET_SPECIAL(sc, func) 
  711.   do 
  712.     { 
  713.       unsigned char uc; 
  714.       uc = ttybuff.c_cc[sc]; 
  715.       if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC) 
  716. kmap[uc].function = func; 
  717.     } 
  718.   while (0)
  720.   if (get_tty_settings (tty, &ttybuff) == 0)
  721.     {
  722.       SET_SPECIAL (VERASE, rl_rubout);
  723.       SET_SPECIAL (VKILL, rl_unix_line_discard);
  725. #  if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
  726.       SET_SPECIAL (VLNEXT, rl_quoted_insert);
  727. #  endif /* VLNEXT && TERMIOS_TTY_DRIVER */
  729. #  if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
  730.       SET_SPECIAL (VWERASE, rl_unix_word_rubout);
  731. #  endif /* VWERASE && TERMIOS_TTY_DRIVER */
  732.     }
  733. #endif /* !NEW_TTY_DRIVER */
  734. }