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

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [readline/] [terminal.c] - Blame information for rev 26

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 jlechner
/* terminal.c -- controlling the terminal with termcap. */
2
 
3
/* Copyright (C) 1996-2005 Free Software Foundation, Inc.
4
 
5
   This file is part of the GNU Readline Library, a library for
6
   reading lines of text with interactive input and history editing.
7
 
8
   The GNU Readline Library is free software; you can redistribute it
9
   and/or modify it under the terms of the GNU General Public License
10
   as published by the Free Software Foundation; either version 2, or
11
   (at your option) any later version.
12
 
13
   The GNU Readline Library is distributed in the hope that it will be
14
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   The GNU General Public License is often shipped with GNU software, and
19
   is generally kept in a file called COPYING or LICENSE.  If you do not
20
   have a copy of the license, write to the Free Software Foundation,
21
   59 Temple Place, Suite 330, Boston, MA 02111 USA. */
22
#define READLINE_LIBRARY
23
 
24
#if defined (HAVE_CONFIG_H)
25
#  include <config.h>
26
#endif
27
 
28
#include <sys/types.h>
29
#include "posixstat.h"
30
#include <fcntl.h>
31
#if defined (HAVE_SYS_FILE_H)
32
#  include <sys/file.h>
33
#endif /* HAVE_SYS_FILE_H */
34
 
35
#if defined (HAVE_UNISTD_H)
36
#  include <unistd.h>
37
#endif /* HAVE_UNISTD_H */
38
 
39
#if defined (HAVE_STDLIB_H)
40
#  include <stdlib.h>
41
#else
42
#  include "ansi_stdlib.h"
43
#endif /* HAVE_STDLIB_H */
44
 
45
#if defined (HAVE_LOCALE_H)
46
#  include <locale.h>
47
#endif
48
 
49
#include <stdio.h>
50
 
51
/* System-specific feature definitions and include files. */
52
#include "rldefs.h"
53
 
54
#if defined (GWINSZ_IN_SYS_IOCTL) && !defined (TIOCGWINSZ)
55
#  include <sys/ioctl.h>
56
#endif /* GWINSZ_IN_SYS_IOCTL && !TIOCGWINSZ */
57
 
58
#ifdef __MSDOS__
59
# include <pc.h>
60
#endif
61
 
62
#include "rltty.h"
63
#include "tcap.h"
64
 
65
/* Some standard library routines. */
66
#include "readline.h"
67
#include "history.h"
68
 
69
#include "rlprivate.h"
70
#include "rlshell.h"
71
#include "xmalloc.h"
72
 
73
#if defined (__MINGW32__)
74
# include <windows.h>
75
# include <wincon.h>
76
#endif
77
 
78
#define CUSTOM_REDISPLAY_FUNC() (rl_redisplay_function != rl_redisplay)
79
#define CUSTOM_INPUT_FUNC() (rl_getc_function != rl_getc)
80
 
81
int rl_prefer_env_winsize;
82
 
83
/* **************************************************************** */
84
/*                                                                  */
85
/*                      Terminal and Termcap                        */
86
/*                                                                  */
87
/* **************************************************************** */
88
 
89
#ifndef __MSDOS__
90
static char *term_buffer = (char *)NULL;
91
static char *term_string_buffer = (char *)NULL;
92
#endif /* !__MSDOS__ */
93
 
94
static int tcap_initialized;
95
 
96
#if !defined (__linux__)
97
#  if defined (__EMX__) || defined (NEED_EXTERN_PC)
98
extern
99
#  endif /* __EMX__ || NEED_EXTERN_PC */
100
char PC, *BC, *UP;
101
#endif /* __linux__ */
102
 
103
/* Some strings to control terminal actions.  These are output by tputs (). */
104
char *_rl_term_clreol;
105
char *_rl_term_clrpag;
106
char *_rl_term_cr;
107
char *_rl_term_backspace;
108
char *_rl_term_goto;
109
char *_rl_term_pc;
110
 
111
/* Non-zero if we determine that the terminal can do character insertion. */
112
int _rl_terminal_can_insert = 0;
113
 
114
/* How to insert characters. */
115
char *_rl_term_im;
116
char *_rl_term_ei;
117
char *_rl_term_ic;
118
char *_rl_term_ip;
119
char *_rl_term_IC;
120
 
121
/* How to delete characters. */
122
char *_rl_term_dc;
123
char *_rl_term_DC;
124
 
125
#if defined (HACK_TERMCAP_MOTION)
126
char *_rl_term_forward_char;
127
#endif  /* HACK_TERMCAP_MOTION */
128
 
129
/* How to go up a line. */
130
char *_rl_term_up;
131
 
132
/* A visible bell; char if the terminal can be made to flash the screen. */
133
static char *_rl_visible_bell;
134
 
135
/* Non-zero means the terminal can auto-wrap lines. */
136
int _rl_term_autowrap = -1;
137
 
138
/* Non-zero means that this terminal has a meta key. */
139
static int term_has_meta;
140
 
141
/* The sequences to write to turn on and off the meta key, if this
142
   terminal has one. */
143
static char *_rl_term_mm;
144
static char *_rl_term_mo;
145
 
146
/* The key sequences output by the arrow keys, if this terminal has any. */
147
static char *_rl_term_ku;
148
static char *_rl_term_kd;
149
static char *_rl_term_kr;
150
static char *_rl_term_kl;
151
 
152
/* How to initialize and reset the arrow keys, if this terminal has any. */
153
static char *_rl_term_ks;
154
static char *_rl_term_ke;
155
 
156
/* The key sequences sent by the Home and End keys, if any. */
157
static char *_rl_term_kh;
158
static char *_rl_term_kH;
159
static char *_rl_term_at7;      /* @7 */
160
 
161
/* Delete key */
162
static char *_rl_term_kD;
163
 
164
/* Insert key */
165
static char *_rl_term_kI;
166
 
167
/* Cursor control */
168
static char *_rl_term_vs;       /* very visible */
169
static char *_rl_term_ve;       /* normal */
170
 
171
static void bind_termcap_arrow_keys PARAMS((Keymap));
172
 
173
/* Variables that hold the screen dimensions, used by the display code. */
174
int _rl_screenwidth, _rl_screenheight, _rl_screenchars;
175
 
176
/* Non-zero means the user wants to enable the keypad. */
177
int _rl_enable_keypad;
178
 
179
/* Non-zero means the user wants to enable a meta key. */
180
int _rl_enable_meta = 1;
181
 
182
#if defined (__EMX__)
183
static void
184
_emx_get_screensize (swp, shp)
185
     int *swp, *shp;
186
{
187
  int sz[2];
188
 
189
  _scrsize (sz);
190
 
191
  if (swp)
192
    *swp = sz[0];
193
  if (shp)
194
    *shp = sz[1];
195
}
196
#endif
197
 
198
/* Get readline's idea of the screen size.  TTY is a file descriptor open
199
   to the terminal.  If IGNORE_ENV is true, we do not pay attention to the
200
   values of $LINES and $COLUMNS.  The tests for TERM_STRING_BUFFER being
201
   non-null serve to check whether or not we have initialized termcap. */
202
void
203
_rl_get_screen_size (tty, ignore_env)
204
     int tty, ignore_env;
205
{
206
  char *ss;
207
#if defined (TIOCGWINSZ)
208
  struct winsize window_size;
209
#endif /* TIOCGWINSZ */
210
  int wr, wc;
211
 
212
  wr = wc = -1;
213
#if defined (TIOCGWINSZ)
214
  if (ioctl (tty, TIOCGWINSZ, &window_size) == 0)
215
    {
216
      wc = (int) window_size.ws_col;
217
      wr = (int) window_size.ws_row;
218
    }
219
#endif /* TIOCGWINSZ */
220
 
221
  /* For MinGW, we get the console size from the Windows API.  */
222
#if defined (__MINGW32__)
223
  HANDLE hConOut = GetStdHandle (STD_OUTPUT_HANDLE);
224
  if (hConOut != INVALID_HANDLE_VALUE)
225
    {
226
      CONSOLE_SCREEN_BUFFER_INFO scr;
227
      if (GetConsoleScreenBufferInfo (hConOut, &scr))
228
        {
229
          wc = scr.dwSize.X;
230
          wr = scr.srWindow.Bottom - scr.srWindow.Top + 1;
231
        }
232
    }
233
#endif
234
 
235
#if defined (__EMX__)
236
  _emx_get_screensize (&_rl_screenwidth, &_rl_screenheight);
237
#endif
238
 
239
  if (ignore_env || rl_prefer_env_winsize == 0)
240
    {
241
      _rl_screenwidth = wc;
242
      _rl_screenheight = wr;
243
    }
244
  else
245
    _rl_screenwidth = _rl_screenheight = -1;
246
 
247
  /* Environment variable COLUMNS overrides setting of "co" if IGNORE_ENV
248
     is unset.  If we prefer the environment, check it first before
249
     assigning the value returned by the kernel. */
250
  if (_rl_screenwidth <= 0)
251
    {
252
      if (ignore_env == 0 && (ss = sh_get_env_value ("COLUMNS")))
253
        _rl_screenwidth = atoi (ss);
254
 
255
      if (_rl_screenwidth <= 0)
256
        _rl_screenwidth = wc;
257
 
258
#if defined (__DJGPP__)
259
      if (_rl_screenwidth <= 0)
260
        _rl_screenwidth = ScreenCols ();
261
#else
262
      if (_rl_screenwidth <= 0 && term_string_buffer)
263
        _rl_screenwidth = tgetnum ("co");
264
#endif
265
    }
266
 
267
  /* Environment variable LINES overrides setting of "li" if IGNORE_ENV
268
     is unset. */
269
  if (_rl_screenheight <= 0)
270
    {
271
      if (ignore_env == 0 && (ss = sh_get_env_value ("LINES")))
272
        _rl_screenheight = atoi (ss);
273
 
274
      if (_rl_screenheight <= 0)
275
        _rl_screenheight = wr;
276
 
277
#if defined (__DJGPP__)
278
      if (_rl_screenheight <= 0)
279
        _rl_screenheight = ScreenRows ();
280
#else
281
      if (_rl_screenheight <= 0 && term_string_buffer)
282
        _rl_screenheight = tgetnum ("li");
283
#endif
284
    }
285
 
286
  /* If all else fails, default to 80x24 terminal. */
287
  if (_rl_screenwidth <= 1)
288
    _rl_screenwidth = 80;
289
 
290
  if (_rl_screenheight <= 0)
291
    _rl_screenheight = 24;
292
 
293
  /* If we're being compiled as part of bash, set the environment
294
     variables $LINES and $COLUMNS to new values.  Otherwise, just
295
     do a pair of putenv () or setenv () calls. */
296
  sh_set_lines_and_columns (_rl_screenheight, _rl_screenwidth);
297
 
298
  if (_rl_term_autowrap == 0)
299
    _rl_screenwidth--;
300
 
301
  _rl_screenchars = _rl_screenwidth * _rl_screenheight;
302
}
303
 
304
void
305
_rl_set_screen_size (rows, cols)
306
     int rows, cols;
307
{
308
  if (_rl_term_autowrap == -1)
309
    _rl_init_terminal_io (rl_terminal_name);
310
 
311
  if (rows > 0)
312
    _rl_screenheight = rows;
313
  if (cols > 0)
314
    {
315
      _rl_screenwidth = cols;
316
      if (_rl_term_autowrap == 0)
317
        _rl_screenwidth--;
318
    }
319
 
320
  if (rows > 0 || cols > 0)
321
    _rl_screenchars = _rl_screenwidth * _rl_screenheight;
322
}
323
 
324
void
325
rl_set_screen_size (rows, cols)
326
     int rows, cols;
327
{
328
  _rl_set_screen_size (rows, cols);
329
}
330
 
331
void
332
rl_get_screen_size (rows, cols)
333
     int *rows, *cols;
334
{
335
  if (rows)
336
    *rows = _rl_screenheight;
337
  if (cols)
338
    *cols = _rl_screenwidth;
339
}
340
 
341
void
342
rl_reset_screen_size ()
343
{
344
  _rl_get_screen_size (fileno (rl_instream), 0);
345
}
346
 
347
void
348
rl_resize_terminal ()
349
{
350
  if (readline_echoing_p)
351
    {
352
      _rl_get_screen_size (fileno (rl_instream), 1);
353
      if (CUSTOM_REDISPLAY_FUNC ())
354
        rl_forced_update_display ();
355
      else
356
        _rl_redisplay_after_sigwinch ();
357
    }
358
}
359
 
360
struct _tc_string {
361
     const char *tc_var;
362
     char **tc_value;
363
};
364
 
365
/* This should be kept sorted, just in case we decide to change the
366
   search algorithm to something smarter. */
367
static struct _tc_string tc_strings[] =
368
{
369
  { "@7", &_rl_term_at7 },
370
  { "DC", &_rl_term_DC },
371
  { "IC", &_rl_term_IC },
372
  { "ce", &_rl_term_clreol },
373
  { "cl", &_rl_term_clrpag },
374
  { "cr", &_rl_term_cr },
375
  { "dc", &_rl_term_dc },
376
  { "ei", &_rl_term_ei },
377
  { "ic", &_rl_term_ic },
378
  { "im", &_rl_term_im },
379
  { "kD", &_rl_term_kD },       /* delete */
380
  { "kH", &_rl_term_kH },       /* home down ?? */
381
  { "kI", &_rl_term_kI },       /* insert */
382
  { "kd", &_rl_term_kd },
383
  { "ke", &_rl_term_ke },       /* end keypad mode */
384
  { "kh", &_rl_term_kh },       /* home */
385
  { "kl", &_rl_term_kl },
386
  { "kr", &_rl_term_kr },
387
  { "ks", &_rl_term_ks },       /* start keypad mode */
388
  { "ku", &_rl_term_ku },
389
  { "le", &_rl_term_backspace },
390
  { "mm", &_rl_term_mm },
391
  { "mo", &_rl_term_mo },
392
#if defined (HACK_TERMCAP_MOTION)
393
  { "nd", &_rl_term_forward_char },
394
#endif
395
  { "pc", &_rl_term_pc },
396
  { "up", &_rl_term_up },
397
  { "vb", &_rl_visible_bell },
398
  { "vs", &_rl_term_vs },
399
  { "ve", &_rl_term_ve },
400
};
401
 
402
#define NUM_TC_STRINGS (sizeof (tc_strings) / sizeof (struct _tc_string))
403
 
404
/* Read the desired terminal capability strings into BP.  The capabilities
405
   are described in the TC_STRINGS table. */
406
static void
407
get_term_capabilities (bp)
408
     char **bp;
409
{
410
#if !defined (__DJGPP__)        /* XXX - doesn't DJGPP have a termcap library? */
411
  register int i;
412
 
413
  for (i = 0; i < NUM_TC_STRINGS; i++)
414
    *(tc_strings[i].tc_value) = tgetstr ((char *)tc_strings[i].tc_var, bp);
415
#endif
416
  tcap_initialized = 1;
417
}
418
 
419
int
420
_rl_init_terminal_io (terminal_name)
421
     const char *terminal_name;
422
{
423
  const char *term;
424
  char *buffer;
425
  int tty, tgetent_ret;
426
 
427
  term = terminal_name ? terminal_name : sh_get_env_value ("TERM");
428
  _rl_term_clrpag = _rl_term_cr = _rl_term_clreol = (char *)NULL;
429
  tty = rl_instream ? fileno (rl_instream) : 0;
430
 
431
  if (term == 0)
432
    term = "dumb";
433
 
434
#ifdef __MSDOS__
435
  _rl_term_im = _rl_term_ei = _rl_term_ic = _rl_term_IC = (char *)NULL;
436
  _rl_term_up = _rl_term_dc = _rl_term_DC = _rl_visible_bell = (char *)NULL;
437
  _rl_term_ku = _rl_term_kd = _rl_term_kl = _rl_term_kr = (char *)NULL;
438
  _rl_term_mm = _rl_term_mo = (char *)NULL;
439
  _rl_terminal_can_insert = term_has_meta = _rl_term_autowrap = 0;
440
  _rl_term_cr = "\r";
441
  _rl_term_clreol = _rl_term_clrpag = _rl_term_backspace = (char *)NULL;
442
  _rl_term_goto = _rl_term_pc = _rl_term_ip = (char *)NULL;
443
  _rl_term_ks = _rl_term_ke =_rl_term_vs = _rl_term_ve = (char *)NULL;
444
  _rl_term_kh = _rl_term_kH = _rl_term_at7 = _rl_term_kI = (char *)NULL;
445
#if defined(HACK_TERMCAP_MOTION)
446
  _rl_term_forward_char = (char *)NULL;
447
#endif
448
 
449
  _rl_get_screen_size (tty, 0);
450
#else  /* !__MSDOS__ */
451
  /* I've separated this out for later work on not calling tgetent at all
452
     if the calling application has supplied a custom redisplay function,
453
     (and possibly if the application has supplied a custom input function). */
454
  if (CUSTOM_REDISPLAY_FUNC())
455
    {
456
      tgetent_ret = -1;
457
    }
458
  else
459
    {
460
      if (term_string_buffer == 0)
461
        term_string_buffer = (char *)xmalloc(2032);
462
 
463
      if (term_buffer == 0)
464
        term_buffer = (char *)xmalloc(4080);
465
 
466
      buffer = term_string_buffer;
467
 
468
      tgetent_ret = tgetent (term_buffer, term);
469
    }
470
 
471
  if (tgetent_ret <= 0)
472
    {
473
      FREE (term_string_buffer);
474
      FREE (term_buffer);
475
      buffer = term_buffer = term_string_buffer = (char *)NULL;
476
 
477
      _rl_term_autowrap = 0;     /* used by _rl_get_screen_size */
478
 
479
      /* Allow calling application to set default height and width, using
480
         rl_set_screen_size */
481
      if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
482
        {
483
#if defined (__EMX__)
484
          _emx_get_screensize (&_rl_screenwidth, &_rl_screenheight);
485
          _rl_screenwidth--;
486
#else /* !__EMX__ */
487
          _rl_get_screen_size (tty, 0);
488
#endif /* !__EMX__ */
489
        }
490
 
491
      /* Defaults. */
492
      if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
493
        {
494
          _rl_screenwidth = 79;
495
          _rl_screenheight = 24;
496
        }
497
 
498
      /* Everything below here is used by the redisplay code (tputs). */
499
      _rl_screenchars = _rl_screenwidth * _rl_screenheight;
500
      _rl_term_cr = "\r";
501
      _rl_term_im = _rl_term_ei = _rl_term_ic = _rl_term_IC = (char *)NULL;
502
      _rl_term_up = _rl_term_dc = _rl_term_DC = _rl_visible_bell = (char *)NULL;
503
      _rl_term_ku = _rl_term_kd = _rl_term_kl = _rl_term_kr = (char *)NULL;
504
      _rl_term_kh = _rl_term_kH = _rl_term_kI = _rl_term_kD = (char *)NULL;
505
      _rl_term_ks = _rl_term_ke = _rl_term_at7 = (char *)NULL;
506
      _rl_term_mm = _rl_term_mo = (char *)NULL;
507
      _rl_term_ve = _rl_term_vs = (char *)NULL;
508
#if defined (HACK_TERMCAP_MOTION)
509
      term_forward_char = (char *)NULL;
510
#endif
511
      _rl_terminal_can_insert = term_has_meta = 0;
512
 
513
      /* Reasonable defaults for tgoto().  Readline currently only uses
514
         tgoto if _rl_term_IC or _rl_term_DC is defined, but just in case we
515
         change that later... */
516
      PC = '\0';
517
      BC = _rl_term_backspace = "\b";
518
      UP = _rl_term_up;
519
 
520
      return 0;
521
    }
522
 
523
  get_term_capabilities (&buffer);
524
 
525
  /* Set up the variables that the termcap library expects the application
526
     to provide. */
527
  PC = _rl_term_pc ? *_rl_term_pc : 0;
528
  BC = _rl_term_backspace;
529
  UP = _rl_term_up;
530
 
531
  if (!_rl_term_cr)
532
    _rl_term_cr = "\r";
533
 
534
  _rl_term_autowrap = tgetflag ("am") && tgetflag ("xn");
535
 
536
  /* Allow calling application to set default height and width, using
537
     rl_set_screen_size */
538
  if (_rl_screenwidth <= 0 || _rl_screenheight <= 0)
539
    _rl_get_screen_size (tty, 0);
540
 
541
  /* "An application program can assume that the terminal can do
542
      character insertion if *any one of* the capabilities `IC',
543
      `im', `ic' or `ip' is provided."  But we can't do anything if
544
      only `ip' is provided, so... */
545
  _rl_terminal_can_insert = (_rl_term_IC || _rl_term_im || _rl_term_ic);
546
 
547
  /* Check to see if this terminal has a meta key and clear the capability
548
     variables if there is none. */
549
  term_has_meta = (tgetflag ("km") || tgetflag ("MT"));
550
  if (!term_has_meta)
551
    _rl_term_mm = _rl_term_mo = (char *)NULL;
552
 
553
#endif /* !__MSDOS__ */
554
 
555
  /* Attempt to find and bind the arrow keys.  Do not override already
556
     bound keys in an overzealous attempt, however. */
557
 
558
  bind_termcap_arrow_keys (emacs_standard_keymap);
559
 
560
#if defined (VI_MODE)
561
  bind_termcap_arrow_keys (vi_movement_keymap);
562
  bind_termcap_arrow_keys (vi_insertion_keymap);
563
#endif /* VI_MODE */
564
 
565
  return 0;
566
}
567
 
568
/* Bind the arrow key sequences from the termcap description in MAP. */
569
static void
570
bind_termcap_arrow_keys (map)
571
     Keymap map;
572
{
573
  Keymap xkeymap;
574
 
575
  xkeymap = _rl_keymap;
576
  _rl_keymap = map;
577
 
578
  rl_bind_keyseq_if_unbound (_rl_term_ku, rl_get_previous_history);
579
  rl_bind_keyseq_if_unbound (_rl_term_kd, rl_get_next_history);
580
  rl_bind_keyseq_if_unbound (_rl_term_kr, rl_forward_char);
581
  rl_bind_keyseq_if_unbound (_rl_term_kl, rl_backward_char);
582
 
583
  rl_bind_keyseq_if_unbound (_rl_term_kh, rl_beg_of_line);      /* Home */
584
  rl_bind_keyseq_if_unbound (_rl_term_at7, rl_end_of_line);     /* End */
585
 
586
  rl_bind_keyseq_if_unbound (_rl_term_kD, rl_delete);
587
 
588
  _rl_keymap = xkeymap;
589
}
590
 
591
char *
592
rl_get_termcap (cap)
593
     const char *cap;
594
{
595
  register int i;
596
 
597
  if (tcap_initialized == 0)
598
    return ((char *)NULL);
599
  for (i = 0; i < NUM_TC_STRINGS; i++)
600
    {
601
      if (tc_strings[i].tc_var[0] == cap[0] && strcmp (tc_strings[i].tc_var, cap) == 0)
602
        return *(tc_strings[i].tc_value);
603
    }
604
  return ((char *)NULL);
605
}
606
 
607
/* Re-initialize the terminal considering that the TERM/TERMCAP variable
608
   has changed. */
609
int
610
rl_reset_terminal (terminal_name)
611
     const char *terminal_name;
612
{
613
  _rl_screenwidth = _rl_screenheight = 0;
614
  _rl_init_terminal_io (terminal_name);
615
  return 0;
616
}
617
 
618
/* A function for the use of tputs () */
619
#ifdef _MINIX
620
void
621
_rl_output_character_function (c)
622
     int c;
623
{
624
  putc (c, _rl_out_stream);
625
}
626
#else /* !_MINIX */
627
int
628
_rl_output_character_function (c)
629
     int c;
630
{
631
  return putc (c, _rl_out_stream);
632
}
633
#endif /* !_MINIX */
634
 
635
/* Write COUNT characters from STRING to the output stream. */
636
void
637
_rl_output_some_chars (string, count)
638
     const char *string;
639
     int count;
640
{
641
  fwrite (string, 1, count, _rl_out_stream);
642
}
643
 
644
/* Move the cursor back. */
645
int
646
_rl_backspace (count)
647
     int count;
648
{
649
  register int i;
650
 
651
#ifndef __MSDOS__
652
  if (_rl_term_backspace)
653
    for (i = 0; i < count; i++)
654
      tputs (_rl_term_backspace, 1, _rl_output_character_function);
655
  else
656
#endif
657
    for (i = 0; i < count; i++)
658
      putc ('\b', _rl_out_stream);
659
  return 0;
660
}
661
 
662
/* Move to the start of the next line. */
663
int
664
rl_crlf ()
665
{
666
#if defined (NEW_TTY_DRIVER)
667
  if (_rl_term_cr)
668
    tputs (_rl_term_cr, 1, _rl_output_character_function);
669
#endif /* NEW_TTY_DRIVER */
670
  putc ('\n', _rl_out_stream);
671
  return 0;
672
}
673
 
674
/* Ring the terminal bell. */
675
int
676
rl_ding ()
677
{
678
  if (readline_echoing_p)
679
    {
680
      switch (_rl_bell_preference)
681
        {
682
        case NO_BELL:
683
        default:
684
          break;
685
        case VISIBLE_BELL:
686
#ifdef __MSDOS__
687
          ScreenVisualBell ();
688
          break;
689
#else
690
          if (_rl_visible_bell)
691
            {
692
              tputs (_rl_visible_bell, 1, _rl_output_character_function);
693
              break;
694
            }
695
          /* FALLTHROUGH */
696
#endif
697
        case AUDIBLE_BELL:
698
          fprintf (stderr, "\007");
699
          fflush (stderr);
700
          break;
701
        }
702
      return (0);
703
    }
704
  return (-1);
705
}
706
 
707
/* **************************************************************** */
708
/*                                                                  */
709
/*              Controlling the Meta Key and Keypad                 */
710
/*                                                                  */
711
/* **************************************************************** */
712
 
713
void
714
_rl_enable_meta_key ()
715
{
716
#if !defined (__DJGPP__)
717
  if (term_has_meta && _rl_term_mm)
718
    tputs (_rl_term_mm, 1, _rl_output_character_function);
719
#endif
720
}
721
 
722
void
723
_rl_control_keypad (on)
724
     int on;
725
{
726
#if !defined (__DJGPP__)
727
  if (on && _rl_term_ks)
728
    tputs (_rl_term_ks, 1, _rl_output_character_function);
729
  else if (!on && _rl_term_ke)
730
    tputs (_rl_term_ke, 1, _rl_output_character_function);
731
#endif
732
}
733
 
734
/* **************************************************************** */
735
/*                                                                  */
736
/*                      Controlling the Cursor                      */
737
/*                                                                  */
738
/* **************************************************************** */
739
 
740
/* Set the cursor appropriately depending on IM, which is one of the
741
   insert modes (insert or overwrite).  Insert mode gets the normal
742
   cursor.  Overwrite mode gets a very visible cursor.  Only does
743
   anything if we have both capabilities. */
744
void
745
_rl_set_cursor (im, force)
746
     int im, force;
747
{
748
#ifndef __MSDOS__
749
  if (_rl_term_ve && _rl_term_vs)
750
    {
751
      if (force || im != rl_insert_mode)
752
        {
753
          if (im == RL_IM_OVERWRITE)
754
            tputs (_rl_term_vs, 1, _rl_output_character_function);
755
          else
756
            tputs (_rl_term_ve, 1, _rl_output_character_function);
757
        }
758
    }
759
#endif
760
}

powered by: WebSVN 2.1.0

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