1: /* rltty.c -- functions to prepare and restore the terminal for readline's
2: use. */
3:
4: /* Copyright (C) 1992-2017 Free Software Foundation, Inc.
5:
6: This file is part of the GNU Readline Library (Readline), a library
7: for reading lines of text with interactive input and history editing.
8:
9: Readline is free software: you can redistribute it and/or modify
10: it under the terms of the GNU General Public License as published by
11: the Free Software Foundation, either version 3 of the License, or
12: (at your option) any later version.
13:
14: Readline is distributed in the hope that it will be useful,
15: but WITHOUT ANY WARRANTY; without even the implied warranty of
16: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17: GNU General Public License for more details.
18:
19: You should have received a copy of the GNU General Public License
20: along with Readline. If not, see <http://www.gnu.org/licenses/>.
21: */
22:
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: #include "rltty.h"
41: #if defined (HAVE_SYS_IOCTL_H)
42: # include <sys/ioctl.h> /* include for declaration of ioctl */
43: #endif
44:
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 set_winsize PARAMS((int));
56:
57: /* **************************************************************** */
58: /* */
59: /* Saving and Restoring the TTY */
60: /* */
61: /* **************************************************************** */
62:
63: /* Non-zero means that the terminal is in a prepped state. There are several
64: flags that are OR'd in to denote whether or not we have sent various
65: init strings to the terminal. */
66: #define TPX_PREPPED 0x01
67: #define TPX_BRACKPASTE 0x02
68: #define TPX_METAKEY 0x04
69:
70: static int terminal_prepped;
71:
72: static _RL_TTY_CHARS _rl_tty_chars, _rl_last_tty_chars;
73:
74: /* If non-zero, means that this process has called tcflow(fd, TCOOFF)
75: and output is suspended. */
76: #if defined (__ksr1__)
77: static int ksrflow;
78: #endif
79:
80: /* Dummy call to force a backgrounded readline to stop before it tries
81: to get the tty settings. */
82: static void
83: set_winsize (tty)
84: int tty;
85: {
86: #if defined (TIOCGWINSZ)
87: struct winsize w;
88:
89: if (ioctl (tty, TIOCGWINSZ, &w) == 0)
90: (void) ioctl (tty, TIOCSWINSZ, &w);
91: #endif /* TIOCGWINSZ */
92: }
93:
94: #if defined (NO_TTY_DRIVER)
95: /* Nothing */
96: #elif defined (NEW_TTY_DRIVER)
97:
98: /* Values for the `flags' field of a struct bsdtty. This tells which
99: elements of the struct bsdtty have been fetched from the system and
100: are valid. */
101: #define SGTTY_SET 0x01
102: #define LFLAG_SET 0x02
103: #define TCHARS_SET 0x04
104: #define LTCHARS_SET 0x08
105:
106: struct bsdtty {
107: struct sgttyb sgttyb; /* Basic BSD tty driver information. */
108: int lflag; /* Local mode flags, like LPASS8. */
109: #if defined (TIOCGETC)
110: struct tchars tchars; /* Terminal special characters, including ^S and ^Q. */
111: #endif
112: #if defined (TIOCGLTC)
113: struct ltchars ltchars; /* 4.2 BSD editing characters */
114: #endif
115: int flags; /* Bitmap saying which parts of the struct are valid. */
116: };
117:
118: #define TIOTYPE struct bsdtty
119:
120: static TIOTYPE otio;
121:
122: static void save_tty_chars PARAMS((TIOTYPE *));
123: static int _get_tty_settings PARAMS((int, TIOTYPE *));
124: static int get_tty_settings PARAMS((int, TIOTYPE *));
125: static int _set_tty_settings PARAMS((int, TIOTYPE *));
126: static int set_tty_settings PARAMS((int, TIOTYPE *));
127:
128: static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
129:
130: static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t *));
131:
132: static void
133: save_tty_chars (TIOTYPE *tiop)
134: {
135: _rl_last_tty_chars = _rl_tty_chars;
136:
137: if (tiop->flags & SGTTY_SET)
138: {
139: _rl_tty_chars.t_erase = tiop->sgttyb.sg_erase;
140: _rl_tty_chars.t_kill = tiop->sgttyb.sg_kill;
141: }
142:
143: if (tiop->flags & TCHARS_SET)
144: {
145: _rl_intr_char = _rl_tty_chars.t_intr = tiop->tchars.t_intrc;
146: _rl_quit_char = _rl_tty_chars.t_quit = tiop->tchars.t_quitc;
147:
148: _rl_tty_chars.t_start = tiop->tchars.t_startc;
149: _rl_tty_chars.t_stop = tiop->tchars.t_stopc;
150: _rl_tty_chars.t_eof = tiop->tchars.t_eofc;
151: _rl_tty_chars.t_eol = '\n';
152: _rl_tty_chars.t_eol2 = tiop->tchars.t_brkc;
153: }
154:
155: if (tiop->flags & LTCHARS_SET)
156: {
157: _rl_susp_char = _rl_tty_chars.t_susp = tiop->ltchars.t_suspc;
158:
159: _rl_tty_chars.t_dsusp = tiop->ltchars.t_dsuspc;
160: _rl_tty_chars.t_reprint = tiop->ltchars.t_rprntc;
161: _rl_tty_chars.t_flush = tiop->ltchars.t_flushc;
162: _rl_tty_chars.t_werase = tiop->ltchars.t_werasc;
163: _rl_tty_chars.t_lnext = tiop->ltchars.t_lnextc;
164: }
165:
166: _rl_tty_chars.t_status = -1;
167: }
168:
169: static int
170: get_tty_settings (int tty, TIOTYPE *tiop)
171: {
172: set_winsize (tty);
173:
174: tiop->flags = tiop->lflag = 0;
175:
176: errno = 0;
177: if (ioctl (tty, TIOCGETP, &(tiop->sgttyb)) < 0)
178: return -1;
179: tiop->flags |= SGTTY_SET;
180:
181: #if defined (TIOCLGET)
182: if (ioctl (tty, TIOCLGET, &(tiop->lflag)) == 0)
183: tiop->flags |= LFLAG_SET;
184: #endif
185:
186: #if defined (TIOCGETC)
187: if (ioctl (tty, TIOCGETC, &(tiop->tchars)) == 0)
188: tiop->flags |= TCHARS_SET;
189: #endif
190:
191: #if defined (TIOCGLTC)
192: if (ioctl (tty, TIOCGLTC, &(tiop->ltchars)) == 0)
193: tiop->flags |= LTCHARS_SET;
194: #endif
195:
196: return 0;
197: }
198:
199: static int
200: set_tty_settings (int tty, TIOTYPE *tiop)
201: {
202: if (tiop->flags & SGTTY_SET)
203: {
204: ioctl (tty, TIOCSETN, &(tiop->sgttyb));
205: tiop->flags &= ~SGTTY_SET;
206: }
207: _rl_echoing_p = 1;
208:
209: #if defined (TIOCLSET)
210: if (tiop->flags & LFLAG_SET)
211: {
212: ioctl (tty, TIOCLSET, &(tiop->lflag));
213: tiop->flags &= ~LFLAG_SET;
214: }
215: #endif
216:
217: #if defined (TIOCSETC)
218: if (tiop->flags & TCHARS_SET)
219: {
220: ioctl (tty, TIOCSETC, &(tiop->tchars));
221: tiop->flags &= ~TCHARS_SET;
222: }
223: #endif
224:
225: #if defined (TIOCSLTC)
226: if (tiop->flags & LTCHARS_SET)
227: {
228: ioctl (tty, TIOCSLTC, &(tiop->ltchars));
229: tiop->flags &= ~LTCHARS_SET;
230: }
231: #endif
232:
233: return 0;
234: }
235:
236: static void
237: prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
238: {
239: _rl_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
240: _rl_echoctl = (oldtio.sgttyb.sg_flags & ECHOCTL);
241:
242: /* Copy the original settings to the structure we're going to use for
243: our settings. */
244: tiop->sgttyb = oldtio.sgttyb;
245: tiop->lflag = oldtio.lflag;
246: #if defined (TIOCGETC)
247: tiop->tchars = oldtio.tchars;
248: #endif
249: #if defined (TIOCGLTC)
250: tiop->ltchars = oldtio.ltchars;
251: #endif
252: tiop->flags = oldtio.flags;
253:
254: /* First, the basic settings to put us into character-at-a-time, no-echo
255: input mode. */
256: tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
257: tiop->sgttyb.sg_flags |= CBREAK;
258:
259: /* If this terminal doesn't care how the 8th bit is used, then we can
260: use it for the meta-key. If only one of even or odd parity is
261: specified, then the terminal is using parity, and we cannot. */
262: #if !defined (ANYP)
263: # define ANYP (EVENP | ODDP)
264: #endif
265: if (((oldtio.sgttyb.sg_flags & ANYP) == ANYP) ||
266: ((oldtio.sgttyb.sg_flags & ANYP) == 0))
267: {
268: tiop->sgttyb.sg_flags |= ANYP;
269:
270: /* Hack on local mode flags if we can. */
271: #if defined (TIOCLGET)
272: # if defined (LPASS8)
273: tiop->lflag |= LPASS8;
274: # endif /* LPASS8 */
275: #endif /* TIOCLGET */
276: }
277:
278: #if defined (TIOCGETC)
279: # if defined (USE_XON_XOFF)
280: /* Get rid of terminal output start and stop characters. */
281: tiop->tchars.t_stopc = -1; /* C-s */
282: tiop->tchars.t_startc = -1; /* C-q */
283:
284: /* If there is an XON character, bind it to restart the output. */
285: if (oldtio.tchars.t_startc != -1)
286: rl_bind_key (oldtio.tchars.t_startc, rl_restart_output);
287: # endif /* USE_XON_XOFF */
288:
289: /* If there is an EOF char, bind _rl_eof_char to it. */
290: if (oldtio.tchars.t_eofc != -1)
291: _rl_eof_char = oldtio.tchars.t_eofc;
292:
293: # if defined (NO_KILL_INTR)
294: /* Get rid of terminal-generated SIGQUIT and SIGINT. */
295: tiop->tchars.t_quitc = -1; /* C-\ */
296: tiop->tchars.t_intrc = -1; /* C-c */
297: # endif /* NO_KILL_INTR */
298: #endif /* TIOCGETC */
299:
300: #if defined (TIOCGLTC)
301: /* Make the interrupt keys go away. Just enough to make people happy. */
302: tiop->ltchars.t_dsuspc = -1; /* C-y */
303: tiop->ltchars.t_lnextc = -1; /* C-v */
304: #endif /* TIOCGLTC */
305: }
306:
307: #else /* !defined (NEW_TTY_DRIVER) */
308:
309: #if !defined (VMIN)
310: # define VMIN VEOF
311: #endif
312:
313: #if !defined (VTIME)
314: # define VTIME VEOL
315: #endif
316:
317: #if defined (TERMIOS_TTY_DRIVER)
318: # define TIOTYPE struct termios
319: # define DRAIN_OUTPUT(fd) tcdrain (fd)
320: # define GETATTR(tty, tiop) (tcgetattr (tty, tiop))
321: # ifdef M_UNIX
322: # define SETATTR(tty, tiop) (tcsetattr (tty, TCSANOW, tiop))
323: # else
324: # define SETATTR(tty, tiop) (tcsetattr (tty, TCSADRAIN, tiop))
325: # endif /* !M_UNIX */
326: #else
327: # define TIOTYPE struct termio
328: # define DRAIN_OUTPUT(fd)
329: # define GETATTR(tty, tiop) (ioctl (tty, TCGETA, tiop))
330: # define SETATTR(tty, tiop) (ioctl (tty, TCSETAW, tiop))
331: #endif /* !TERMIOS_TTY_DRIVER */
332:
333: static TIOTYPE otio;
334:
335: static void save_tty_chars PARAMS((TIOTYPE *));
336: static int _get_tty_settings PARAMS((int, TIOTYPE *));
337: static int get_tty_settings PARAMS((int, TIOTYPE *));
338: static int _set_tty_settings PARAMS((int, TIOTYPE *));
339: static int set_tty_settings PARAMS((int, TIOTYPE *));
340:
341: static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
342:
343: static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t *));
344: static void _rl_bind_tty_special_chars PARAMS((Keymap, TIOTYPE));
345:
346: #if defined (FLUSHO)
347: # define OUTPUT_BEING_FLUSHED(tp) (tp->c_lflag & FLUSHO)
348: #else
349: # define OUTPUT_BEING_FLUSHED(tp) 0
350: #endif
351:
352: static void
353: save_tty_chars (TIOTYPE *tiop)
354: {
355: _rl_last_tty_chars = _rl_tty_chars;
356:
357: _rl_tty_chars.t_eof = tiop->c_cc[VEOF];
358: _rl_tty_chars.t_eol = tiop->c_cc[VEOL];
359: #ifdef VEOL2
360: _rl_tty_chars.t_eol2 = tiop->c_cc[VEOL2];
361: #endif
362: _rl_tty_chars.t_erase = tiop->c_cc[VERASE];
363: #ifdef VWERASE
364: _rl_tty_chars.t_werase = tiop->c_cc[VWERASE];
365: #endif
366: _rl_tty_chars.t_kill = tiop->c_cc[VKILL];
367: #ifdef VREPRINT
368: _rl_tty_chars.t_reprint = tiop->c_cc[VREPRINT];
369: #endif
370: _rl_intr_char = _rl_tty_chars.t_intr = tiop->c_cc[VINTR];
371: _rl_quit_char = _rl_tty_chars.t_quit = tiop->c_cc[VQUIT];
372: #ifdef VSUSP
373: _rl_susp_char = _rl_tty_chars.t_susp = tiop->c_cc[VSUSP];
374: #endif
375: #ifdef VDSUSP
376: _rl_tty_chars.t_dsusp = tiop->c_cc[VDSUSP];
377: #endif
378: #ifdef VSTART
379: _rl_tty_chars.t_start = tiop->c_cc[VSTART];
380: #endif
381: #ifdef VSTOP
382: _rl_tty_chars.t_stop = tiop->c_cc[VSTOP];
383: #endif
384: #ifdef VLNEXT
385: _rl_tty_chars.t_lnext = tiop->c_cc[VLNEXT];
386: #endif
387: #ifdef VDISCARD
388: _rl_tty_chars.t_flush = tiop->c_cc[VDISCARD];
389: #endif
390: #ifdef VSTATUS
391: _rl_tty_chars.t_status = tiop->c_cc[VSTATUS];
392: #endif
393: }
394:
395: #if defined (_AIX) || defined (_AIX41)
396: /* Currently this is only used on AIX */
397: static void
398: rltty_warning (char *msg)
399: {
400: _rl_errmsg ("warning: %s", msg);
401: }
402: #endif
403:
404: #if defined (_AIX)
405: void
406: setopost (TIOTYPE *tp)
407: {
408: if ((tp->c_oflag & OPOST) == 0)
409: {
410: _rl_errmsg ("warning: turning on OPOST for terminal\r");
411: tp->c_oflag |= OPOST|ONLCR;
412: }
413: }
414: #endif
415:
416: static int
417: _get_tty_settings (int tty, TIOTYPE *tiop)
418: {
419: int ioctl_ret;
420:
421: while (1)
422: {
423: ioctl_ret = GETATTR (tty, tiop);
424: if (ioctl_ret < 0)
425: {
426: if (errno != EINTR)
427: return -1;
428: else
429: continue;
430: }
431: if (OUTPUT_BEING_FLUSHED (tiop))
432: {
433: #if defined (FLUSHO)
434: _rl_errmsg ("warning: turning off output flushing");
435: tiop->c_lflag &= ~FLUSHO;
436: break;
437: #else
438: continue;
439: #endif
440: }
441: break;
442: }
443:
444: return 0;
445: }
446:
447: static int
448: get_tty_settings (int tty, TIOTYPE *tiop)
449: {
450: set_winsize (tty);
451:
452: errno = 0;
453: if (_get_tty_settings (tty, tiop) < 0)
454: return -1;
455:
456: #if defined (_AIX)
457: setopost(tiop);
458: #endif
459:
460: return 0;
461: }
462:
463: static int
464: _set_tty_settings (int tty, TIOTYPE *tiop)
465: {
466: while (SETATTR (tty, tiop) < 0)
467: {
468: if (errno != EINTR)
469: return -1;
470: errno = 0;
471: }
472: return 0;
473: }
474:
475: static int
476: set_tty_settings (int tty, TIOTYPE *tiop)
477: {
478: if (_set_tty_settings (tty, tiop) < 0)
479: return -1;
480:
481: #if 0
482:
483: #if defined (TERMIOS_TTY_DRIVER)
484: # if defined (__ksr1__)
485: if (ksrflow)
486: {
487: ksrflow = 0;
488: tcflow (tty, TCOON);
489: }
490: # else /* !ksr1 */
491: tcflow (tty, TCOON); /* Simulate a ^Q. */
492: # endif /* !ksr1 */
493: #else
494: ioctl (tty, TCXONC, 1); /* Simulate a ^Q. */
495: #endif /* !TERMIOS_TTY_DRIVER */
496:
497: #endif /* 0 */
498:
499: return 0;
500: }
501:
502: static void
503: prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
504: {
505: int sc;
506: Keymap kmap;
507:
508: _rl_echoing_p = (oldtio.c_lflag & ECHO);
509: #if defined (ECHOCTL)
510: _rl_echoctl = (oldtio.c_lflag & ECHOCTL);
511: #endif
512:
513: tiop->c_lflag &= ~(ICANON | ECHO);
514:
515: if ((unsigned char) oldtio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
516: _rl_eof_char = oldtio.c_cc[VEOF];
517:
518: #if defined (USE_XON_XOFF)
519: #if defined (IXANY)
520: tiop->c_iflag &= ~(IXON | IXANY);
521: #else
522: /* `strict' Posix systems do not define IXANY. */
523: tiop->c_iflag &= ~IXON;
524: #endif /* IXANY */
525: #endif /* USE_XON_XOFF */
526:
527: /* Only turn this off if we are using all 8 bits. */
528: if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag)
529: tiop->c_iflag &= ~(ISTRIP | INPCK);
530:
531: /* Make sure we differentiate between CR and NL on input. */
532: tiop->c_iflag &= ~(ICRNL | INLCR);
533:
534: #if !defined (HANDLE_SIGNALS)
535: tiop->c_lflag &= ~ISIG;
536: #else
537: tiop->c_lflag |= ISIG;
538: #endif
539:
540: tiop->c_cc[VMIN] = 1;
541: tiop->c_cc[VTIME] = 0;
542:
543: #if defined (FLUSHO)
544: if (OUTPUT_BEING_FLUSHED (tiop))
545: {
546: tiop->c_lflag &= ~FLUSHO;
547: oldtio.c_lflag &= ~FLUSHO;
548: }
549: #endif
550:
551: /* Turn off characters that we need on Posix systems with job control,
552: just to be sure. This includes ^Y and ^V. This should not really
553: be necessary. */
554: #if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)
555:
556: #if defined (VLNEXT)
557: tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
558: #endif
559:
560: #if defined (VDSUSP)
561: tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
562: #endif
563:
564: /* Conditionally disable some other tty special characters if there is a
565: key binding for them in the current keymap. Readline ordinarily doesn't
566: bind these characters, but an application or user might. */
567: #if defined (VI_MODE)
568: kmap = (rl_editing_mode == vi_mode) ? vi_insertion_keymap : _rl_keymap;
569: #else
570: kmap = _rl_keymap;
571: #endif
572: #if defined (VDISCARD)
573: sc = tiop->c_cc[VDISCARD];
574: if (sc != _POSIX_VDISABLE && kmap[(unsigned char)sc].type == ISFUNC)
575: tiop->c_cc[VDISCARD] = _POSIX_VDISABLE;
576: #endif /* VDISCARD */
577:
578: #endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
579: }
580: #endif /* !NEW_TTY_DRIVER */
581:
582: /* Put the terminal in CBREAK mode so that we can detect key presses. */
583: #if defined (NO_TTY_DRIVER)
584: void
585: rl_prep_terminal (int meta_flag)
586: {
587: _rl_echoing_p = 1;
588: }
589:
590: void
591: rl_deprep_terminal (void)
592: {
593: }
594:
595: #else /* ! NO_TTY_DRIVER */
596: void
597: rl_prep_terminal (int meta_flag)
598: {
599: int tty, nprep;
600: TIOTYPE tio;
601:
602: if (terminal_prepped)
603: return;
604:
605: /* Try to keep this function from being INTerrupted. */
606: _rl_block_sigint ();
607:
608: tty = rl_instream ? fileno (rl_instream) : fileno (stdin);
609:
610: if (get_tty_settings (tty, &tio) < 0)
611: {
612: #if defined (ENOTSUP)
613: /* MacOS X and Linux, at least, lie about the value of errno if
614: tcgetattr fails. */
615: if (errno == ENOTTY || errno == EINVAL || errno == ENOTSUP)
616: #else
617: if (errno == ENOTTY || errno == EINVAL)
618: #endif
619: _rl_echoing_p = 1; /* XXX */
620:
621: _rl_release_sigint ();
622: return;
623: }
624:
625: otio = tio;
626:
627: if (_rl_bind_stty_chars)
628: {
629: #if defined (VI_MODE)
630: /* If editing in vi mode, make sure we restore the bindings in the
631: insertion keymap no matter what keymap we ended up in. */
632: if (rl_editing_mode == vi_mode)
633: rl_tty_unset_default_bindings (vi_insertion_keymap);
634: else
635: #endif
636: rl_tty_unset_default_bindings (_rl_keymap);
637: }
638: save_tty_chars (&otio);
639: RL_SETSTATE(RL_STATE_TTYCSAVED);
640: if (_rl_bind_stty_chars)
641: {
642: #if defined (VI_MODE)
643: /* If editing in vi mode, make sure we set the bindings in the
644: insertion keymap no matter what keymap we ended up in. */
645: if (rl_editing_mode == vi_mode)
646: _rl_bind_tty_special_chars (vi_insertion_keymap, tio);
647: else
648: #endif
649: _rl_bind_tty_special_chars (_rl_keymap, tio);
650: }
651:
652: prepare_terminal_settings (meta_flag, otio, &tio);
653:
654: if (set_tty_settings (tty, &tio) < 0)
655: {
656: _rl_release_sigint ();
657: return;
658: }
659:
660: if (_rl_enable_keypad)
661: _rl_control_keypad (1);
662:
663: nprep = TPX_PREPPED;
664:
665: if (_rl_enable_bracketed_paste)
666: {
667: fprintf (rl_outstream, BRACK_PASTE_INIT);
668: nprep |= TPX_BRACKPASTE;
669: }
670:
671: fflush (rl_outstream);
672: terminal_prepped = nprep;
673: RL_SETSTATE(RL_STATE_TERMPREPPED);
674:
675: _rl_release_sigint ();
676: }
677:
678: /* Restore the terminal's normal settings and modes. */
679: void
680: rl_deprep_terminal (void)
681: {
682: int tty;
683:
684: if (terminal_prepped == 0)
685: return;
686:
687: /* Try to keep this function from being interrupted. */
688: _rl_block_sigint ();
689:
690: tty = rl_instream ? fileno (rl_instream) : fileno (stdin);
691:
692: if (terminal_prepped & TPX_BRACKPASTE)
693: {
694: fprintf (rl_outstream, BRACK_PASTE_FINI);
695: if (_rl_eof_found)
696: fprintf (rl_outstream, "\n");
697: }
698:
699: if (_rl_enable_keypad)
700: _rl_control_keypad (0);
701:
702: fflush (rl_outstream);
703:
704: if (set_tty_settings (tty, &otio) < 0)
705: {
706: _rl_release_sigint ();
707: return;
708: }
709:
710: terminal_prepped = 0;
711: RL_UNSETSTATE(RL_STATE_TERMPREPPED);
712:
713: _rl_release_sigint ();
714: }
715: #endif /* !NO_TTY_DRIVER */
716:
717: /* Set readline's idea of whether or not it is echoing output to the terminal,
718: returning the old value. */
719: int
720: rl_tty_set_echoing (int u)
721: {
722: int o;
723:
724: o = _rl_echoing_p;
725: _rl_echoing_p = u;
726: return o;
727: }
728:
729: /* **************************************************************** */
730: /* */
731: /* Bogus Flow Control */
732: /* */
733: /* **************************************************************** */
734:
735: int
736: rl_restart_output (int count, int key)
737: {
738: #if defined (__MINGW32__)
739: return 0;
740: #else /* !__MING32__ */
741:
742: int fildes = fileno (rl_outstream);
743: #if defined (TIOCSTART)
744: #if defined (apollo)
745: ioctl (&fildes, TIOCSTART, 0);
746: #else
747: ioctl (fildes, TIOCSTART, 0);
748: #endif /* apollo */
749:
750: #else /* !TIOCSTART */
751: # if defined (TERMIOS_TTY_DRIVER)
752: # if defined (__ksr1__)
753: if (ksrflow)
754: {
755: ksrflow = 0;
756: tcflow (fildes, TCOON);
757: }
758: # else /* !ksr1 */
759: tcflow (fildes, TCOON); /* Simulate a ^Q. */
760: # endif /* !ksr1 */
761: # else /* !TERMIOS_TTY_DRIVER */
762: # if defined (TCXONC)
763: ioctl (fildes, TCXONC, TCOON);
764: # endif /* TCXONC */
765: # endif /* !TERMIOS_TTY_DRIVER */
766: #endif /* !TIOCSTART */
767:
768: return 0;
769: #endif /* !__MINGW32__ */
770: }
771:
772: int
773: rl_stop_output (int count, int key)
774: {
775: #if defined (__MINGW32__)
776: return 0;
777: #else
778:
779: int fildes = fileno (rl_instream);
780:
781: #if defined (TIOCSTOP)
782: # if defined (apollo)
783: ioctl (&fildes, TIOCSTOP, 0);
784: # else
785: ioctl (fildes, TIOCSTOP, 0);
786: # endif /* apollo */
787: #else /* !TIOCSTOP */
788: # if defined (TERMIOS_TTY_DRIVER)
789: # if defined (__ksr1__)
790: ksrflow = 1;
791: # endif /* ksr1 */
792: tcflow (fildes, TCOOFF);
793: # else
794: # if defined (TCXONC)
795: ioctl (fildes, TCXONC, TCOON);
796: # endif /* TCXONC */
797: # endif /* !TERMIOS_TTY_DRIVER */
798: #endif /* !TIOCSTOP */
799:
800: return 0;
801: #endif /* !__MINGW32__ */
802: }
803:
804: /* **************************************************************** */
805: /* */
806: /* Default Key Bindings */
807: /* */
808: /* **************************************************************** */
809:
810: #if !defined (NO_TTY_DRIVER)
811: #define SET_SPECIAL(sc, func) set_special_char(kmap, &ttybuff, sc, func)
812: #endif
813:
814: #if defined (NO_TTY_DRIVER)
815:
816: #define SET_SPECIAL(sc, func)
817: #define RESET_SPECIAL(c)
818:
819: #elif defined (NEW_TTY_DRIVER)
820: static void
821: set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
822: {
823: if (sc != -1 && kmap[(unsigned char)sc].type == ISFUNC)
824: kmap[(unsigned char)sc].function = func;
825: }
826:
827: #define RESET_SPECIAL(c) \
828: if (c != -1 && kmap[(unsigned char)c].type == ISFUNC) \
829: kmap[(unsigned char)c].function = rl_insert;
830:
831: static void
832: _rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
833: {
834: if (ttybuff.flags & SGTTY_SET)
835: {
836: SET_SPECIAL (ttybuff.sgttyb.sg_erase, rl_rubout);
837: SET_SPECIAL (ttybuff.sgttyb.sg_kill, rl_unix_line_discard);
838: }
839:
840: # if defined (TIOCGLTC)
841: if (ttybuff.flags & LTCHARS_SET)
842: {
843: SET_SPECIAL (ttybuff.ltchars.t_werasc, rl_unix_word_rubout);
844: SET_SPECIAL (ttybuff.ltchars.t_lnextc, rl_quoted_insert);
845: }
846: # endif /* TIOCGLTC */
847: }
848:
849: #else /* !NEW_TTY_DRIVER */
850: static void
851: set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
852: {
853: unsigned char uc;
854:
855: uc = tiop->c_cc[sc];
856: if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC)
857: kmap[uc].function = func;
858: }
859:
860: /* used later */
861: #define RESET_SPECIAL(uc) \
862: if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC) \
863: kmap[uc].function = rl_insert;
864:
865: static void
866: _rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
867: {
868: SET_SPECIAL (VERASE, rl_rubout);
869: SET_SPECIAL (VKILL, rl_unix_line_discard);
870:
871: # if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
872: SET_SPECIAL (VLNEXT, rl_quoted_insert);
873: # endif /* VLNEXT && TERMIOS_TTY_DRIVER */
874:
875: # if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
876: # if defined (VI_MODE)
877: if (rl_editing_mode == vi_mode)
878: SET_SPECIAL (VWERASE, rl_vi_unix_word_rubout);
879: else
880: # endif
881: SET_SPECIAL (VWERASE, rl_unix_word_rubout);
882: # endif /* VWERASE && TERMIOS_TTY_DRIVER */
883: }
884:
885: #endif /* !NEW_TTY_DRIVER */
886:
887: /* Set the system's default editing characters to their readline equivalents
888: in KMAP. Should be static, now that we have rl_tty_set_default_bindings. */
889: void
890: rltty_set_default_bindings (Keymap kmap)
891: {
892: #if !defined (NO_TTY_DRIVER)
893: TIOTYPE ttybuff;
894: int tty;
895:
896: tty = fileno (rl_instream);
897:
898: if (get_tty_settings (tty, &ttybuff) == 0)
899: _rl_bind_tty_special_chars (kmap, ttybuff);
900: #endif
901: }
902:
903: /* New public way to set the system default editing chars to their readline
904: equivalents. */
905: void
906: rl_tty_set_default_bindings (Keymap kmap)
907: {
908: rltty_set_default_bindings (kmap);
909: }
910:
911: /* Rebind all of the tty special chars that readline worries about back
912: to self-insert. Call this before saving the current terminal special
913: chars with save_tty_chars(). This only works on POSIX termios or termio
914: systems. */
915: void
916: rl_tty_unset_default_bindings (Keymap kmap)
917: {
918: /* Don't bother before we've saved the tty special chars at least once. */
919: if (RL_ISSTATE(RL_STATE_TTYCSAVED) == 0)
920: return;
921:
922: RESET_SPECIAL (_rl_tty_chars.t_erase);
923: RESET_SPECIAL (_rl_tty_chars.t_kill);
924:
925: # if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
926: RESET_SPECIAL (_rl_tty_chars.t_lnext);
927: # endif /* VLNEXT && TERMIOS_TTY_DRIVER */
928:
929: # if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
930: RESET_SPECIAL (_rl_tty_chars.t_werase);
931: # endif /* VWERASE && TERMIOS_TTY_DRIVER */
932: }
933:
934: #if defined (HANDLE_SIGNALS)
935:
936: #if defined (NEW_TTY_DRIVER) || defined (NO_TTY_DRIVER)
937: int
938: _rl_disable_tty_signals (void)
939: {
940: return 0;
941: }
942:
943: int
944: _rl_restore_tty_signals (void)
945: {
946: return 0;
947: }
948: #else
949:
950: static TIOTYPE sigstty, nosigstty;
951: static int tty_sigs_disabled = 0;
952:
953: int
954: _rl_disable_tty_signals (void)
955: {
956: if (tty_sigs_disabled)
957: return 0;
958:
959: if (_get_tty_settings (fileno (rl_instream), &sigstty) < 0)
960: return -1;
961:
962: nosigstty = sigstty;
963:
964: nosigstty.c_lflag &= ~ISIG;
965: nosigstty.c_iflag &= ~IXON;
966:
967: if (_set_tty_settings (fileno (rl_instream), &nosigstty) < 0)
968: return (_set_tty_settings (fileno (rl_instream), &sigstty));
969:
970: tty_sigs_disabled = 1;
971: return 0;
972: }
973:
974: int
975: _rl_restore_tty_signals (void)
976: {
977: int r;
978:
979: if (tty_sigs_disabled == 0)
980: return 0;
981:
982: r = _set_tty_settings (fileno (rl_instream), &sigstty);
983:
984: if (r == 0)
985: tty_sigs_disabled = 0;
986:
987: return r;
988: }
989: #endif /* !NEW_TTY_DRIVER */
990:
991: #endif /* HANDLE_SIGNALS */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rltty.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline