OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [readline/] [rltty.c] - Blame information for rev 298

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* rltty.c -- functions to prepare and restore the terminal for readline's
2
   use. */
3
 
4
/* Copyright (C) 1992-2005 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 (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
 
167
struct 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
 
181
static TIOTYPE otio;
182
 
183
static void save_tty_chars PARAMS((TIOTYPE *));
184
static int _get_tty_settings PARAMS((int, TIOTYPE *));
185
static int get_tty_settings PARAMS((int, TIOTYPE *));
186
static int _set_tty_settings PARAMS((int, TIOTYPE *));
187
static int set_tty_settings PARAMS((int, TIOTYPE *));
188
 
189
static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
190
 
191
static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t));
192
 
193
static void
194
save_tty_chars (tiop)
195
     TIOTYPE *tiop;
196
{
197
  _rl_last_tty_chars = _rl_tty_chars;
198
 
199
  if (tiop->flags & SGTTY_SET)
200
    {
201
      _rl_tty_chars.t_erase = tiop->sgttyb.sg_erase;
202
      _rl_tty_chars.t_kill = tiop->sgttyb.sg_kill;
203
    }
204
 
205
  if (tiop->flags & TCHARS_SET)
206
    {
207
      _rl_tty_chars.t_intr = tiop->tchars.t_intrc;
208
      _rl_tty_chars.t_quit = tiop->tchars.t_quitc;
209
      _rl_tty_chars.t_start = tiop->tchars.t_startc;
210
      _rl_tty_chars.t_stop = tiop->tchars.t_stopc;
211
      _rl_tty_chars.t_eof = tiop->tchars.t_eofc;
212
      _rl_tty_chars.t_eol = '\n';
213
      _rl_tty_chars.t_eol2 = tiop->tchars.t_brkc;
214
    }
215
 
216
  if (tiop->flags & LTCHARS_SET)
217
    {
218
      _rl_tty_chars.t_susp = tiop->ltchars.t_suspc;
219
      _rl_tty_chars.t_dsusp = tiop->ltchars.t_dsuspc;
220
      _rl_tty_chars.t_reprint = tiop->ltchars.t_rprntc;
221
      _rl_tty_chars.t_flush = tiop->ltchars.t_flushc;
222
      _rl_tty_chars.t_werase = tiop->ltchars.t_werasc;
223
      _rl_tty_chars.t_lnext = tiop->ltchars.t_lnextc;
224
    }
225
 
226
  _rl_tty_chars.t_status = -1;
227
}
228
 
229
static int
230
get_tty_settings (tty, tiop)
231
     int tty;
232
     TIOTYPE *tiop;
233
{
234
  set_winsize (tty);
235
 
236
  tiop->flags = tiop->lflag = 0;
237
 
238
  errno = 0;
239
  if (ioctl (tty, TIOCGETP, &(tiop->sgttyb)) < 0)
240
    return -1;
241
  tiop->flags |= SGTTY_SET;
242
 
243
#if defined (TIOCLGET)
244
  if (ioctl (tty, TIOCLGET, &(tiop->lflag)) == 0)
245
    tiop->flags |= LFLAG_SET;
246
#endif
247
 
248
#if defined (TIOCGETC)
249
  if (ioctl (tty, TIOCGETC, &(tiop->tchars)) == 0)
250
    tiop->flags |= TCHARS_SET;
251
#endif
252
 
253
#if defined (TIOCGLTC)
254
  if (ioctl (tty, TIOCGLTC, &(tiop->ltchars)) == 0)
255
    tiop->flags |= LTCHARS_SET;
256
#endif
257
 
258
  return 0;
259
}
260
 
261
static int
262
set_tty_settings (tty, tiop)
263
     int tty;
264
     TIOTYPE *tiop;
265
{
266
  if (tiop->flags & SGTTY_SET)
267
    {
268
      ioctl (tty, TIOCSETN, &(tiop->sgttyb));
269
      tiop->flags &= ~SGTTY_SET;
270
    }
271
  readline_echoing_p = 1;
272
 
273
#if defined (TIOCLSET)
274
  if (tiop->flags & LFLAG_SET)
275
    {
276
      ioctl (tty, TIOCLSET, &(tiop->lflag));
277
      tiop->flags &= ~LFLAG_SET;
278
    }
279
#endif
280
 
281
#if defined (TIOCSETC)
282
  if (tiop->flags & TCHARS_SET)
283
    {
284
      ioctl (tty, TIOCSETC, &(tiop->tchars));
285
      tiop->flags &= ~TCHARS_SET;
286
    }
287
#endif
288
 
289
#if defined (TIOCSLTC)
290
  if (tiop->flags & LTCHARS_SET)
291
    {
292
      ioctl (tty, TIOCSLTC, &(tiop->ltchars));
293
      tiop->flags &= ~LTCHARS_SET;
294
    }
295
#endif
296
 
297
  return 0;
298
}
299
 
300
static void
301
prepare_terminal_settings (meta_flag, oldtio, tiop)
302
     int meta_flag;
303
     TIOTYPE oldtio, *tiop;
304
{
305
  readline_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
306
 
307
  /* Copy the original settings to the structure we're going to use for
308
     our settings. */
309
  tiop->sgttyb = oldtio.sgttyb;
310
  tiop->lflag = oldtio.lflag;
311
#if defined (TIOCGETC)
312
  tiop->tchars = oldtio.tchars;
313
#endif
314
#if defined (TIOCGLTC)
315
  tiop->ltchars = oldtio.ltchars;
316
#endif
317
  tiop->flags = oldtio.flags;
318
 
319
  /* First, the basic settings to put us into character-at-a-time, no-echo
320
     input mode. */
321
  tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
322
  tiop->sgttyb.sg_flags |= CBREAK;
323
 
324
  /* If this terminal doesn't care how the 8th bit is used, then we can
325
     use it for the meta-key.  If only one of even or odd parity is
326
     specified, then the terminal is using parity, and we cannot. */
327
#if !defined (ANYP)
328
#  define ANYP (EVENP | ODDP)
329
#endif
330
  if (((oldtio.sgttyb.sg_flags & ANYP) == ANYP) ||
331
      ((oldtio.sgttyb.sg_flags & ANYP) == 0))
332
    {
333
      tiop->sgttyb.sg_flags |= ANYP;
334
 
335
      /* Hack on local mode flags if we can. */
336
#if defined (TIOCLGET)
337
#  if defined (LPASS8)
338
      tiop->lflag |= LPASS8;
339
#  endif /* LPASS8 */
340
#endif /* TIOCLGET */
341
    }
342
 
343
#if defined (TIOCGETC)
344
#  if defined (USE_XON_XOFF)
345
  /* Get rid of terminal output start and stop characters. */
346
  tiop->tchars.t_stopc = -1; /* C-s */
347
  tiop->tchars.t_startc = -1; /* C-q */
348
 
349
  /* If there is an XON character, bind it to restart the output. */
350
  if (oldtio.tchars.t_startc != -1)
351
    rl_bind_key (oldtio.tchars.t_startc, rl_restart_output);
352
#  endif /* USE_XON_XOFF */
353
 
354
  /* If there is an EOF char, bind _rl_eof_char to it. */
355
  if (oldtio.tchars.t_eofc != -1)
356
    _rl_eof_char = oldtio.tchars.t_eofc;
357
 
358
#  if defined (NO_KILL_INTR)
359
  /* Get rid of terminal-generated SIGQUIT and SIGINT. */
360
  tiop->tchars.t_quitc = -1; /* C-\ */
361
  tiop->tchars.t_intrc = -1; /* C-c */
362
#  endif /* NO_KILL_INTR */
363
#endif /* TIOCGETC */
364
 
365
#if defined (TIOCGLTC)
366
  /* Make the interrupt keys go away.  Just enough to make people happy. */
367
  tiop->ltchars.t_dsuspc = -1;  /* C-y */
368
  tiop->ltchars.t_lnextc = -1;  /* C-v */
369
#endif /* TIOCGLTC */
370
}
371
 
372
#else  /* !defined (NEW_TTY_DRIVER) */
373
 
374
#if !defined (VMIN)
375
#  define VMIN VEOF
376
#endif
377
 
378
#if !defined (VTIME)
379
#  define VTIME VEOL
380
#endif
381
 
382
#if defined (TERMIOS_TTY_DRIVER)
383
#  define TIOTYPE struct termios
384
#  define DRAIN_OUTPUT(fd)      tcdrain (fd)
385
#  define GETATTR(tty, tiop)    (tcgetattr (tty, tiop))
386
#  ifdef M_UNIX
387
#    define SETATTR(tty, tiop)  (tcsetattr (tty, TCSANOW, tiop))
388
#  else
389
#    define SETATTR(tty, tiop)  (tcsetattr (tty, TCSADRAIN, tiop))
390
#  endif /* !M_UNIX */
391
#else
392
#  define TIOTYPE struct termio
393
#  define DRAIN_OUTPUT(fd)
394
#  define GETATTR(tty, tiop)    (ioctl (tty, TCGETA, tiop))
395
#  define SETATTR(tty, tiop)    (ioctl (tty, TCSETAW, tiop))
396
#endif /* !TERMIOS_TTY_DRIVER */
397
 
398
static TIOTYPE otio;
399
 
400
static void save_tty_chars PARAMS((TIOTYPE *));
401
static int _get_tty_settings PARAMS((int, TIOTYPE *));
402
static int get_tty_settings PARAMS((int, TIOTYPE *));
403
static int _set_tty_settings PARAMS((int, TIOTYPE *));
404
static int set_tty_settings PARAMS((int, TIOTYPE *));
405
 
406
static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
407
 
408
static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t));
409
static void _rl_bind_tty_special_chars PARAMS((Keymap, TIOTYPE));
410
 
411
#if defined (FLUSHO)
412
#  define OUTPUT_BEING_FLUSHED(tp)  (tp->c_lflag & FLUSHO)
413
#else
414
#  define OUTPUT_BEING_FLUSHED(tp)  0
415
#endif
416
 
417
static void
418
save_tty_chars (tiop)
419
     TIOTYPE *tiop;
420
{
421
  _rl_last_tty_chars = _rl_tty_chars;
422
 
423
  _rl_tty_chars.t_eof = tiop->c_cc[VEOF];
424
  _rl_tty_chars.t_eol = tiop->c_cc[VEOL];
425
#ifdef VEOL2
426
  _rl_tty_chars.t_eol2 = tiop->c_cc[VEOL2];
427
#endif
428
  _rl_tty_chars.t_erase = tiop->c_cc[VERASE];
429
#ifdef VWERASE
430
  _rl_tty_chars.t_werase = tiop->c_cc[VWERASE];
431
#endif
432
  _rl_tty_chars.t_kill = tiop->c_cc[VKILL];
433
#ifdef VREPRINT
434
  _rl_tty_chars.t_reprint = tiop->c_cc[VREPRINT];
435
#endif
436
  _rl_tty_chars.t_intr = tiop->c_cc[VINTR];
437
  _rl_tty_chars.t_quit = tiop->c_cc[VQUIT];
438
#ifdef VSUSP
439
  _rl_tty_chars.t_susp = tiop->c_cc[VSUSP];
440
#endif
441
#ifdef VDSUSP
442
  _rl_tty_chars.t_dsusp = tiop->c_cc[VDSUSP];
443
#endif
444
#ifdef VSTART
445
  _rl_tty_chars.t_start = tiop->c_cc[VSTART];
446
#endif
447
#ifdef VSTOP
448
  _rl_tty_chars.t_stop = tiop->c_cc[VSTOP];
449
#endif
450
#ifdef VLNEXT
451
  _rl_tty_chars.t_lnext = tiop->c_cc[VLNEXT];
452
#endif
453
#ifdef VDISCARD
454
  _rl_tty_chars.t_flush = tiop->c_cc[VDISCARD];
455
#endif
456
#ifdef VSTATUS
457
  _rl_tty_chars.t_status = tiop->c_cc[VSTATUS];
458
#endif
459
}
460
 
461
#if defined (_AIX) || defined (_AIX41)
462
/* Currently this is only used on AIX */
463
static void
464
rltty_warning (msg)
465
     char *msg;
466
{
467
  fprintf (stderr, "readline: warning: %s\n", msg);
468
}
469
#endif
470
 
471
#if defined (_AIX)
472
void
473
setopost(tp)
474
TIOTYPE *tp;
475
{
476
  if ((tp->c_oflag & OPOST) == 0)
477
    {
478
      rltty_warning ("turning on OPOST for terminal\r");
479
      tp->c_oflag |= OPOST|ONLCR;
480
    }
481
}
482
#endif
483
 
484
static int
485
_get_tty_settings (tty, tiop)
486
     int tty;
487
     TIOTYPE *tiop;
488
{
489
  int ioctl_ret;
490
 
491
  while (1)
492
    {
493
      ioctl_ret = GETATTR (tty, tiop);
494
      if (ioctl_ret < 0)
495
        {
496
          if (errno != EINTR)
497
            return -1;
498
          else
499
            continue;
500
        }
501
      if (OUTPUT_BEING_FLUSHED (tiop))
502
        {
503
#if defined (FLUSHO) && defined (_AIX41)
504
          rltty_warning ("turning off output flushing");
505
          tiop->c_lflag &= ~FLUSHO;
506
          break;
507
#else
508
          continue;
509
#endif
510
        }
511
      break;
512
    }
513
 
514
  return 0;
515
}
516
 
517
static int
518
get_tty_settings (tty, tiop)
519
     int tty;
520
     TIOTYPE *tiop;
521
{
522
  set_winsize (tty);
523
 
524
  errno = 0;
525
  if (_get_tty_settings (tty, tiop) < 0)
526
    return -1;
527
 
528
#if defined (_AIX)
529
  setopost(tiop);
530
#endif
531
 
532
  return 0;
533
}
534
 
535
static int
536
_set_tty_settings (tty, tiop)
537
     int tty;
538
     TIOTYPE *tiop;
539
{
540
  while (SETATTR (tty, tiop) < 0)
541
    {
542
      if (errno != EINTR)
543
        return -1;
544
      errno = 0;
545
    }
546
  return 0;
547
}
548
 
549
static int
550
set_tty_settings (tty, tiop)
551
     int tty;
552
     TIOTYPE *tiop;
553
{
554
  if (_set_tty_settings (tty, tiop) < 0)
555
    return -1;
556
 
557
#if 0
558
 
559
#if defined (TERMIOS_TTY_DRIVER)
560
#  if defined (__ksr1__)
561
  if (ksrflow)
562
    {
563
      ksrflow = 0;
564
      tcflow (tty, TCOON);
565
    }
566
#  else /* !ksr1 */
567
  tcflow (tty, TCOON);          /* Simulate a ^Q. */
568
#  endif /* !ksr1 */
569
#else
570
  ioctl (tty, TCXONC, 1);       /* Simulate a ^Q. */
571
#endif /* !TERMIOS_TTY_DRIVER */
572
 
573
#endif /* 0 */
574
 
575
  return 0;
576
}
577
 
578
static void
579
prepare_terminal_settings (meta_flag, oldtio, tiop)
580
     int meta_flag;
581
     TIOTYPE oldtio, *tiop;
582
{
583
  readline_echoing_p = (oldtio.c_lflag & ECHO);
584
 
585
  tiop->c_lflag &= ~(ICANON | ECHO);
586
 
587
  if ((unsigned char) oldtio.c_cc[VEOF] != (unsigned char) _POSIX_VDISABLE)
588
    _rl_eof_char = oldtio.c_cc[VEOF];
589
 
590
#if defined (USE_XON_XOFF)
591
#if defined (IXANY)
592
  tiop->c_iflag &= ~(IXON | IXOFF | IXANY);
593
#else
594
  /* `strict' Posix systems do not define IXANY. */
595
  tiop->c_iflag &= ~(IXON | IXOFF);
596
#endif /* IXANY */
597
#endif /* USE_XON_XOFF */
598
 
599
  /* Only turn this off if we are using all 8 bits. */
600
  if (((tiop->c_cflag & CSIZE) == CS8) || meta_flag)
601
    tiop->c_iflag &= ~(ISTRIP | INPCK);
602
 
603
  /* Make sure we differentiate between CR and NL on input. */
604
  tiop->c_iflag &= ~(ICRNL | INLCR);
605
 
606
#if !defined (HANDLE_SIGNALS)
607
  tiop->c_lflag &= ~ISIG;
608
#else
609
  tiop->c_lflag |= ISIG;
610
#endif
611
 
612
  tiop->c_cc[VMIN] = 1;
613
  tiop->c_cc[VTIME] = 0;
614
 
615
#if defined (FLUSHO)
616
  if (OUTPUT_BEING_FLUSHED (tiop))
617
    {
618
      tiop->c_lflag &= ~FLUSHO;
619
      oldtio.c_lflag &= ~FLUSHO;
620
    }
621
#endif
622
 
623
  /* Turn off characters that we need on Posix systems with job control,
624
     just to be sure.  This includes ^Y and ^V.  This should not really
625
     be necessary.  */
626
#if defined (TERMIOS_TTY_DRIVER) && defined (_POSIX_VDISABLE)
627
 
628
#if defined (VLNEXT)
629
  tiop->c_cc[VLNEXT] = _POSIX_VDISABLE;
630
#endif
631
 
632
#if defined (VDSUSP)
633
  tiop->c_cc[VDSUSP] = _POSIX_VDISABLE;
634
#endif
635
 
636
#endif /* TERMIOS_TTY_DRIVER && _POSIX_VDISABLE */
637
}
638
#endif  /* !NEW_TTY_DRIVER */
639
 
640
/* Put the terminal in CBREAK mode so that we can detect key presses. */
641
#if defined (NO_TTY_DRIVER)
642
void
643
rl_prep_terminal (meta_flag)
644
     int meta_flag;
645
{
646
  readline_echoing_p = 1;
647
}
648
 
649
void
650
rl_deprep_terminal ()
651
{
652
}
653
 
654
#else /* ! NO_TTY_DRIVER */
655
void
656
rl_prep_terminal (meta_flag)
657
     int meta_flag;
658
{
659
  int tty;
660
  TIOTYPE tio;
661
 
662
  if (terminal_prepped)
663
    return;
664
 
665
  /* Try to keep this function from being INTerrupted. */
666
  block_sigint ();
667
 
668
  tty = fileno (rl_instream);
669
 
670
  if (get_tty_settings (tty, &tio) < 0)
671
    {
672
#if defined (ENOTSUP)
673
      /* MacOS X, at least, lies about the value of errno if tcgetattr fails. */
674
      if (errno == ENOTTY || errno == ENOTSUP)
675
#else
676
      if (errno == ENOTTY)
677
#endif
678
        readline_echoing_p = 1;         /* XXX */
679
      release_sigint ();
680
      return;
681
    }
682
 
683
  otio = tio;
684
 
685
  if (_rl_bind_stty_chars)
686
    {
687
#if defined (VI_MODE)
688
      /* If editing in vi mode, make sure we restore the bindings in the
689
         insertion keymap no matter what keymap we ended up in. */
690
      if (rl_editing_mode == vi_mode)
691
        rl_tty_unset_default_bindings (vi_insertion_keymap);
692
      else
693
#endif
694
        rl_tty_unset_default_bindings (_rl_keymap);
695
    }
696
  save_tty_chars (&otio);
697
  RL_SETSTATE(RL_STATE_TTYCSAVED);
698
  if (_rl_bind_stty_chars)
699
    {
700
#if defined (VI_MODE)
701
      /* If editing in vi mode, make sure we set the bindings in the
702
         insertion keymap no matter what keymap we ended up in. */
703
      if (rl_editing_mode == vi_mode)
704
        _rl_bind_tty_special_chars (vi_insertion_keymap, tio);
705
      else
706
#endif
707
        _rl_bind_tty_special_chars (_rl_keymap, tio);
708
    }
709
 
710
  prepare_terminal_settings (meta_flag, otio, &tio);
711
 
712
  if (set_tty_settings (tty, &tio) < 0)
713
    {
714
      release_sigint ();
715
      return;
716
    }
717
 
718
  if (_rl_enable_keypad)
719
    _rl_control_keypad (1);
720
 
721
  fflush (rl_outstream);
722
  terminal_prepped = 1;
723
  RL_SETSTATE(RL_STATE_TERMPREPPED);
724
 
725
  release_sigint ();
726
}
727
 
728
/* Restore the terminal's normal settings and modes. */
729
void
730
rl_deprep_terminal ()
731
{
732
  int tty;
733
 
734
  if (!terminal_prepped)
735
    return;
736
 
737
  /* Try to keep this function from being interrupted. */
738
  block_sigint ();
739
 
740
  tty = fileno (rl_instream);
741
 
742
  if (_rl_enable_keypad)
743
    _rl_control_keypad (0);
744
 
745
  fflush (rl_outstream);
746
 
747
  if (set_tty_settings (tty, &otio) < 0)
748
    {
749
      release_sigint ();
750
      return;
751
    }
752
 
753
  terminal_prepped = 0;
754
  RL_UNSETSTATE(RL_STATE_TERMPREPPED);
755
 
756
  release_sigint ();
757
}
758
#endif /* !NO_TTY_DRIVER */
759
 
760
/* **************************************************************** */
761
/*                                                                  */
762
/*                      Bogus Flow Control                          */
763
/*                                                                  */
764
/* **************************************************************** */
765
 
766
int
767
rl_restart_output (count, key)
768
     int count, key;
769
{
770
#if defined (__MINGW32__)
771
  return 0;
772
#else /* !__MING32__ */
773
 
774
  int fildes = fileno (rl_outstream);
775
#if defined (TIOCSTART)
776
#if defined (apollo)
777
  ioctl (&fildes, TIOCSTART, 0);
778
#else
779
  ioctl (fildes, TIOCSTART, 0);
780
#endif /* apollo */
781
 
782
#else /* !TIOCSTART */
783
#  if defined (TERMIOS_TTY_DRIVER)
784
#    if defined (__ksr1__)
785
  if (ksrflow)
786
    {
787
      ksrflow = 0;
788
      tcflow (fildes, TCOON);
789
    }
790
#    else /* !ksr1 */
791
  tcflow (fildes, TCOON);               /* Simulate a ^Q. */
792
#    endif /* !ksr1 */
793
#  else /* !TERMIOS_TTY_DRIVER */
794
#    if defined (TCXONC)
795
  ioctl (fildes, TCXONC, TCOON);
796
#    endif /* TCXONC */
797
#  endif /* !TERMIOS_TTY_DRIVER */
798
#endif /* !TIOCSTART */
799
 
800
  return 0;
801
#endif /* !__MINGW32__ */
802
}
803
 
804
int
805
rl_stop_output (count, key)
806
     int count, key;
807
{
808
#if defined (__MINGW32__)
809
  return 0;
810
#else
811
 
812
  int fildes = fileno (rl_instream);
813
 
814
#if defined (TIOCSTOP)
815
# if defined (apollo)
816
  ioctl (&fildes, TIOCSTOP, 0);
817
# else
818
  ioctl (fildes, TIOCSTOP, 0);
819
# endif /* apollo */
820
#else /* !TIOCSTOP */
821
# if defined (TERMIOS_TTY_DRIVER)
822
#  if defined (__ksr1__)
823
  ksrflow = 1;
824
#  endif /* ksr1 */
825
  tcflow (fildes, TCOOFF);
826
# else
827
#   if defined (TCXONC)
828
  ioctl (fildes, TCXONC, TCOON);
829
#   endif /* TCXONC */
830
# endif /* !TERMIOS_TTY_DRIVER */
831
#endif /* !TIOCSTOP */
832
 
833
  return 0;
834
#endif /* !__MINGW32__ */
835
}
836
 
837
/* **************************************************************** */
838
/*                                                                  */
839
/*                      Default Key Bindings                        */
840
/*                                                                  */
841
/* **************************************************************** */
842
 
843
#if !defined (NO_TTY_DRIVER)
844
#define SET_SPECIAL(sc, func)   set_special_char(kmap, &ttybuff, sc, func)
845
#endif
846
 
847
#if defined (NO_TTY_DRIVER)
848
 
849
#define SET_SPECIAL(sc, func)
850
#define RESET_SPECIAL(c)
851
 
852
#elif defined (NEW_TTY_DRIVER)
853
static void
854
set_special_char (kmap, tiop, sc, func)
855
     Keymap kmap;
856
     TIOTYPE *tiop;
857
     int sc;
858
     rl_command_func_t *func;
859
{
860
  if (sc != -1 && kmap[(unsigned char)sc].type == ISFUNC)
861
    kmap[(unsigned char)sc].function = func;
862
}
863
 
864
#define RESET_SPECIAL(c) \
865
  if (c != -1 && kmap[(unsigned char)c].type == ISFUNC)
866
    kmap[(unsigned char)c].function = rl_insert;
867
 
868
static void
869
_rl_bind_tty_special_chars (kmap, ttybuff)
870
     Keymap kmap;
871
     TIOTYPE ttybuff;
872
{
873
  if (ttybuff.flags & SGTTY_SET)
874
    {
875
      SET_SPECIAL (ttybuff.sgttyb.sg_erase, rl_rubout);
876
      SET_SPECIAL (ttybuff.sgttyb.sg_kill, rl_unix_line_discard);
877
    }
878
 
879
#  if defined (TIOCGLTC)
880
  if (ttybuff.flags & LTCHARS_SET)
881
    {
882
      SET_SPECIAL (ttybuff.ltchars.t_werasc, rl_unix_word_rubout);
883
      SET_SPECIAL (ttybuff.ltchars.t_lnextc, rl_quoted_insert);
884
    }
885
#  endif /* TIOCGLTC */
886
}
887
 
888
#else /* !NEW_TTY_DRIVER */
889
static void
890
set_special_char (kmap, tiop, sc, func)
891
     Keymap kmap;
892
     TIOTYPE *tiop;
893
     int sc;
894
     rl_command_func_t *func;
895
{
896
  unsigned char uc;
897
 
898
  uc = tiop->c_cc[sc];
899
  if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC)
900
    kmap[uc].function = func;
901
}
902
 
903
/* used later */
904
#define RESET_SPECIAL(uc) \
905
  if (uc != (unsigned char)_POSIX_VDISABLE && kmap[uc].type == ISFUNC) \
906
    kmap[uc].function = rl_insert;
907
 
908
static void
909
_rl_bind_tty_special_chars (kmap, ttybuff)
910
     Keymap kmap;
911
     TIOTYPE ttybuff;
912
{
913
  SET_SPECIAL (VERASE, rl_rubout);
914
  SET_SPECIAL (VKILL, rl_unix_line_discard);
915
 
916
#  if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
917
  SET_SPECIAL (VLNEXT, rl_quoted_insert);
918
#  endif /* VLNEXT && TERMIOS_TTY_DRIVER */
919
 
920
#  if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
921
  SET_SPECIAL (VWERASE, rl_unix_word_rubout);
922
#  endif /* VWERASE && TERMIOS_TTY_DRIVER */
923
}
924
 
925
#endif /* !NEW_TTY_DRIVER */
926
 
927
/* Set the system's default editing characters to their readline equivalents
928
   in KMAP.  Should be static, now that we have rl_tty_set_default_bindings. */
929
void
930
rltty_set_default_bindings (kmap)
931
     Keymap kmap;
932
{
933
#if !defined (NO_TTY_DRIVER)
934
  TIOTYPE ttybuff;
935
  int tty;
936
  static int called = 0;
937
 
938
  tty = fileno (rl_instream);
939
 
940
  if (get_tty_settings (tty, &ttybuff) == 0)
941
    _rl_bind_tty_special_chars (kmap, ttybuff);
942
#endif
943
}
944
 
945
/* New public way to set the system default editing chars to their readline
946
   equivalents. */
947
void
948
rl_tty_set_default_bindings (kmap)
949
     Keymap kmap;
950
{
951
  rltty_set_default_bindings (kmap);
952
}
953
 
954
/* Rebind all of the tty special chars that readline worries about back
955
   to self-insert.  Call this before saving the current terminal special
956
   chars with save_tty_chars().  This only works on POSIX termios or termio
957
   systems. */
958
void
959
rl_tty_unset_default_bindings (kmap)
960
     Keymap kmap;
961
{
962
  /* Don't bother before we've saved the tty special chars at least once. */
963
  if (RL_ISSTATE(RL_STATE_TTYCSAVED) == 0)
964
    return;
965
 
966
  RESET_SPECIAL (_rl_tty_chars.t_erase);
967
  RESET_SPECIAL (_rl_tty_chars.t_kill);
968
 
969
#  if defined (VLNEXT) && defined (TERMIOS_TTY_DRIVER)
970
  RESET_SPECIAL (_rl_tty_chars.t_lnext);
971
#  endif /* VLNEXT && TERMIOS_TTY_DRIVER */
972
 
973
#  if defined (VWERASE) && defined (TERMIOS_TTY_DRIVER)
974
  RESET_SPECIAL (_rl_tty_chars.t_werase);
975
#  endif /* VWERASE && TERMIOS_TTY_DRIVER */
976
}
977
 
978
#if defined (HANDLE_SIGNALS)
979
 
980
#if defined (NEW_TTY_DRIVER) || defined (NO_TTY_DRIVER)
981
int
982
_rl_disable_tty_signals ()
983
{
984
  return 0;
985
}
986
 
987
int
988
_rl_restore_tty_signals ()
989
{
990
  return 0;
991
}
992
#else
993
 
994
static TIOTYPE sigstty, nosigstty;
995
static int tty_sigs_disabled = 0;
996
 
997
int
998
_rl_disable_tty_signals ()
999
{
1000
  if (tty_sigs_disabled)
1001
    return 0;
1002
 
1003
  if (_get_tty_settings (fileno (rl_instream), &sigstty) < 0)
1004
    return -1;
1005
 
1006
  nosigstty = sigstty;
1007
 
1008
  nosigstty.c_lflag &= ~ISIG;
1009
  nosigstty.c_iflag &= ~IXON;
1010
 
1011
  if (_set_tty_settings (fileno (rl_instream), &nosigstty) < 0)
1012
    return (_set_tty_settings (fileno (rl_instream), &sigstty));
1013
 
1014
  tty_sigs_disabled = 1;
1015
  return 0;
1016
}
1017
 
1018
int
1019
_rl_restore_tty_signals ()
1020
{
1021
  int r;
1022
 
1023
  if (tty_sigs_disabled == 0)
1024
    return 0;
1025
 
1026
  r = _set_tty_settings (fileno (rl_instream), &sigstty);
1027
 
1028
  if (r == 0)
1029
    tty_sigs_disabled = 0;
1030
 
1031
  return r;
1032
}
1033
#endif /* !NEW_TTY_DRIVER */
1034
 
1035
#endif /* HANDLE_SIGNALS */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.