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

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [readline/] [rltty.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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