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