~ubuntu-branches/debian/stretch/readline6/stretch

1 by Matthias Klose
Import upstream version 6.0
1
/* input.c -- character input functions for readline. */
2
17 by Matthias Klose
* readline 6.3 release.
3
/* Copyright (C) 1994-2013 Free Software Foundation, Inc.
1 by Matthias Klose
Import upstream version 6.0
4
5
   This file is part of the GNU Readline Library (Readline), a library
6
   for reading lines of text with interactive input and history editing.      
7
8
   Readline is free software: you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation, either version 3 of the License, or
11
   (at your option) any later version.
12
13
   Readline is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
18
   You should have received a copy of the GNU General Public License
19
   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
20
*/
21
22
#define READLINE_LIBRARY
23
24
#if defined (__TANDEM)
25
#  include <floss.h>
26
#endif
27
28
#if defined (HAVE_CONFIG_H)
29
#  include <config.h>
30
#endif
31
32
#include <sys/types.h>
33
#include <fcntl.h>
34
#if defined (HAVE_SYS_FILE_H)
35
#  include <sys/file.h>
36
#endif /* HAVE_SYS_FILE_H */
37
38
#if defined (HAVE_UNISTD_H)
39
#  include <unistd.h>
40
#endif /* HAVE_UNISTD_H */
41
42
#if defined (HAVE_STDLIB_H)
43
#  include <stdlib.h>
44
#else
45
#  include "ansi_stdlib.h"
46
#endif /* HAVE_STDLIB_H */
47
17 by Matthias Klose
* readline 6.3 release.
48
#include <signal.h>
49
1.1.1 by Matthias Klose
Import upstream version 6.1
50
#include "posixselect.h"
1 by Matthias Klose
Import upstream version 6.0
51
52
#if defined (FIONREAD_IN_SYS_IOCTL)
53
#  include <sys/ioctl.h>
54
#endif
55
56
#include <stdio.h>
57
#include <errno.h>
58
59
#if !defined (errno)
60
extern int errno;
61
#endif /* !errno */
62
63
/* System-specific feature definitions and include files. */
64
#include "rldefs.h"
65
#include "rlmbutil.h"
66
67
/* Some standard library routines. */
68
#include "readline.h"
69
70
#include "rlprivate.h"
71
#include "rlshell.h"
72
#include "xmalloc.h"
73
74
/* What kind of non-blocking I/O do we have? */
75
#if !defined (O_NDELAY) && defined (O_NONBLOCK)
76
#  define O_NDELAY O_NONBLOCK	/* Posix style */
77
#endif
78
79
/* Non-null means it is a pointer to a function to run while waiting for
80
   character input. */
81
rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
82
17 by Matthias Klose
* readline 6.3 release.
83
/* A function to call if a read(2) is interrupted by a signal. */
84
rl_hook_func_t *rl_signal_event_hook = (rl_hook_func_t *)NULL;
85
86
/* A function to replace _rl_input_available for applications using the
87
   callback interface. */
88
rl_hook_func_t *rl_input_available_hook = (rl_hook_func_t *)NULL;
89
1 by Matthias Klose
Import upstream version 6.0
90
rl_getc_func_t *rl_getc_function = rl_getc;
91
92
static int _keyboard_input_timeout = 100000;		/* 0.1 seconds; it's in usec */
93
94
static int ibuffer_space PARAMS((void));
95
static int rl_get_char PARAMS((int *));
96
static int rl_gather_tyi PARAMS((void));
97
98
/* **************************************************************** */
99
/*								    */
100
/*			Character Input Buffering       	    */
101
/*								    */
102
/* **************************************************************** */
103
104
static int pop_index, push_index;
105
static unsigned char ibuffer[512];
106
static int ibuffer_len = sizeof (ibuffer) - 1;
107
108
#define any_typein (push_index != pop_index)
109
110
int
111
_rl_any_typein ()
112
{
113
  return any_typein;
114
}
115
17 by Matthias Klose
* readline 6.3 release.
116
int
117
_rl_pushed_input_available ()
118
{
119
  return (push_index != pop_index);
120
}
121
1 by Matthias Klose
Import upstream version 6.0
122
/* Return the amount of space available in the buffer for stuffing
123
   characters. */
124
static int
125
ibuffer_space ()
126
{
127
  if (pop_index > push_index)
128
    return (pop_index - push_index - 1);
129
  else
130
    return (ibuffer_len - (push_index - pop_index));
131
}
132
133
/* Get a key from the buffer of characters to be read.
134
   Return the key in KEY.
17 by Matthias Klose
* readline 6.3 release.
135
   Result is non-zero if there was a key, or 0 if there wasn't. */
1 by Matthias Klose
Import upstream version 6.0
136
static int
137
rl_get_char (key)
138
     int *key;
139
{
140
  if (push_index == pop_index)
141
    return (0);
142
143
  *key = ibuffer[pop_index++];
144
#if 0
145
  if (pop_index >= ibuffer_len)
146
#else
147
  if (pop_index > ibuffer_len)
148
#endif
149
    pop_index = 0;
150
151
  return (1);
152
}
153
154
/* Stuff KEY into the *front* of the input buffer.
155
   Returns non-zero if successful, zero if there is
156
   no space left in the buffer. */
157
int
158
_rl_unget_char (key)
159
     int key;
160
{
161
  if (ibuffer_space ())
162
    {
163
      pop_index--;
164
      if (pop_index < 0)
165
	pop_index = ibuffer_len;
166
      ibuffer[pop_index] = key;
167
      return (1);
168
    }
169
  return (0);
170
}
171
172
/* If a character is available to be read, then read it and stuff it into
173
   IBUFFER.  Otherwise, just return.  Returns number of characters read
174
   (0 if none available) and -1 on error (EIO). */
175
static int
176
rl_gather_tyi ()
177
{
178
  int tty;
179
  register int tem, result;
180
  int chars_avail, k;
181
  char input;
182
#if defined(HAVE_SELECT)
183
  fd_set readfds, exceptfds;
184
  struct timeval timeout;
185
#endif
186
187
  chars_avail = 0;
188
  tty = fileno (rl_instream);
189
190
#if defined (HAVE_SELECT)
191
  FD_ZERO (&readfds);
192
  FD_ZERO (&exceptfds);
193
  FD_SET (tty, &readfds);
194
  FD_SET (tty, &exceptfds);
1.1.1 by Matthias Klose
Import upstream version 6.1
195
  USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
1 by Matthias Klose
Import upstream version 6.0
196
  result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
197
  if (result <= 0)
198
    return 0;	/* Nothing to read. */
199
#endif
200
201
  result = -1;
202
#if defined (FIONREAD)
203
  errno = 0;
204
  result = ioctl (tty, FIONREAD, &chars_avail);
205
  if (result == -1 && errno == EIO)
206
    return -1;
207
#endif
208
209
#if defined (O_NDELAY)
210
  if (result == -1)
211
    {
212
      tem = fcntl (tty, F_GETFL, 0);
213
214
      fcntl (tty, F_SETFL, (tem | O_NDELAY));
215
      chars_avail = read (tty, &input, 1);
216
217
      fcntl (tty, F_SETFL, tem);
218
      if (chars_avail == -1 && errno == EAGAIN)
219
	return 0;
220
      if (chars_avail == 0)	/* EOF */
221
	{
222
	  rl_stuff_char (EOF);
223
	  return (0);
224
	}
225
    }
226
#endif /* O_NDELAY */
227
228
#if defined (__MINGW32__)
229
  /* Use getch/_kbhit to check for available console input, in the same way
230
     that we read it normally. */
231
   chars_avail = isatty (tty) ? _kbhit () : 0;
232
   result = 0;
233
#endif
234
235
  /* If there's nothing available, don't waste time trying to read
236
     something. */
237
  if (chars_avail <= 0)
238
    return 0;
239
240
  tem = ibuffer_space ();
241
242
  if (chars_avail > tem)
243
    chars_avail = tem;
244
245
  /* One cannot read all of the available input.  I can only read a single
246
     character at a time, or else programs which require input can be
247
     thwarted.  If the buffer is larger than one character, I lose.
248
     Damn! */
249
  if (tem < ibuffer_len)
250
    chars_avail = 0;
251
252
  if (result != -1)
253
    {
254
      while (chars_avail--)
255
	{
256
	  RL_CHECK_SIGNALS ();
257
	  k = (*rl_getc_function) (rl_instream);
258
	  if (rl_stuff_char (k) == 0)
259
	    break;			/* some problem; no more room */
260
	  if (k == NEWLINE || k == RETURN)
261
	    break;
262
	}
263
    }
264
  else
265
    {
266
      if (chars_avail)
267
	rl_stuff_char (input);
268
    }
269
270
  return 1;
271
}
272
273
int
274
rl_set_keyboard_input_timeout (u)
275
     int u;
276
{
277
  int o;
278
279
  o = _keyboard_input_timeout;
280
  if (u >= 0)
281
    _keyboard_input_timeout = u;
282
  return (o);
283
}
284
285
/* Is there input available to be read on the readline input file
286
   descriptor?  Only works if the system has select(2) or FIONREAD.
287
   Uses the value of _keyboard_input_timeout as the timeout; if another
288
   readline function wants to specify a timeout and not leave it up to
289
   the user, it should use _rl_input_queued(timeout_value_in_microseconds)
290
   instead. */
291
int
292
_rl_input_available ()
293
{
294
#if defined(HAVE_SELECT)
295
  fd_set readfds, exceptfds;
296
  struct timeval timeout;
297
#endif
298
#if !defined (HAVE_SELECT) && defined(FIONREAD)
299
  int chars_avail;
300
#endif
301
  int tty;
302
17 by Matthias Klose
* readline 6.3 release.
303
  if (rl_input_available_hook)
304
    return (*rl_input_available_hook) ();
305
1 by Matthias Klose
Import upstream version 6.0
306
  tty = fileno (rl_instream);
307
308
#if defined (HAVE_SELECT)
309
  FD_ZERO (&readfds);
310
  FD_ZERO (&exceptfds);
311
  FD_SET (tty, &readfds);
312
  FD_SET (tty, &exceptfds);
313
  timeout.tv_sec = 0;
314
  timeout.tv_usec = _keyboard_input_timeout;
315
  return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
316
#else
317
318
#if defined (FIONREAD)
319
  if (ioctl (tty, FIONREAD, &chars_avail) == 0)
320
    return (chars_avail);
321
#endif
322
323
#endif
324
325
#if defined (__MINGW32__)
326
  if (isatty (tty))
327
    return (_kbhit ());
328
#endif
329
330
  return 0;
331
}
332
333
int
334
_rl_input_queued (t)
335
     int t;
336
{
337
  int old_timeout, r;
338
339
  old_timeout = rl_set_keyboard_input_timeout (t);
340
  r = _rl_input_available ();
341
  rl_set_keyboard_input_timeout (old_timeout);
342
  return r;
343
}
344
345
void
346
_rl_insert_typein (c)
347
     int c;     
348
{    	
349
  int key, t, i;
350
  char *string;
351
352
  i = key = 0;
353
  string = (char *)xmalloc (ibuffer_len + 1);
354
  string[i++] = (char) c;
355
356
  while ((t = rl_get_char (&key)) &&
357
	 _rl_keymap[key].type == ISFUNC &&
358
	 _rl_keymap[key].function == rl_insert)
359
    string[i++] = key;
360
361
  if (t)
362
    _rl_unget_char (key);
363
364
  string[i] = '\0';
365
  rl_insert_text (string);
366
  xfree (string);
367
}
368
369
/* Add KEY to the buffer of characters to be read.  Returns 1 if the
370
   character was stuffed correctly; 0 otherwise. */
371
int
372
rl_stuff_char (key)
373
     int key;
374
{
375
  if (ibuffer_space () == 0)
376
    return 0;
377
378
  if (key == EOF)
379
    {
380
      key = NEWLINE;
381
      rl_pending_input = EOF;
382
      RL_SETSTATE (RL_STATE_INPUTPENDING);
383
    }
384
  ibuffer[push_index++] = key;
385
#if 0
386
  if (push_index >= ibuffer_len)
387
#else
388
  if (push_index > ibuffer_len)
389
#endif
390
    push_index = 0;
391
392
  return 1;
393
}
394
395
/* Make C be the next command to be executed. */
396
int
397
rl_execute_next (c)
398
     int c;
399
{
400
  rl_pending_input = c;
401
  RL_SETSTATE (RL_STATE_INPUTPENDING);
402
  return 0;
403
}
404
405
/* Clear any pending input pushed with rl_execute_next() */
406
int
407
rl_clear_pending_input ()
408
{
409
  rl_pending_input = 0;
410
  RL_UNSETSTATE (RL_STATE_INPUTPENDING);
411
  return 0;
412
}
413
414
/* **************************************************************** */
415
/*								    */
416
/*			     Character Input			    */
417
/*								    */
418
/* **************************************************************** */
419
420
/* Read a key, including pending input. */
421
int
422
rl_read_key ()
423
{
15 by Matthias Klose
* Apply upstream patches 002 - 004. Fixes:
424
  int c, r;
1 by Matthias Klose
Import upstream version 6.0
425
426
  if (rl_pending_input)
427
    {
428
      c = rl_pending_input;
429
      rl_clear_pending_input ();
430
    }
431
  else
432
    {
433
      /* If input is coming from a macro, then use that. */
434
      if (c = _rl_next_macro_key ())
435
	return (c);
436
437
      /* If the user has an event function, then call it periodically. */
438
      if (rl_event_hook)
439
	{
7 by Matthias Klose
New upstream version.
440
	  while (rl_event_hook)
1 by Matthias Klose
Import upstream version 6.0
441
	    {
15 by Matthias Klose
* Apply upstream patches 002 - 004. Fixes:
442
	      if (rl_get_char (&c) != 0)
443
		break;
444
		
445
	      if ((r = rl_gather_tyi ()) < 0)	/* XXX - EIO */
1 by Matthias Klose
Import upstream version 6.0
446
		{
447
		  rl_done = 1;
448
		  return ('\n');
449
		}
17 by Matthias Klose
* readline 6.3 release.
450
	      else if (r > 0)			/* read something */
15 by Matthias Klose
* Apply upstream patches 002 - 004. Fixes:
451
		continue;
452
7 by Matthias Klose
New upstream version.
453
	      RL_CHECK_SIGNALS ();
454
	      if (rl_done)		/* XXX - experimental */
455
		return ('\n');
456
	      (*rl_event_hook) ();
1 by Matthias Klose
Import upstream version 6.0
457
	    }
458
	}
459
      else
460
	{
461
	  if (rl_get_char (&c) == 0)
462
	    c = (*rl_getc_function) (rl_instream);
17 by Matthias Klose
* readline 6.3 release.
463
/* fprintf(stderr, "rl_read_key: calling RL_CHECK_SIGNALS: _rl_caught_signal = %d", _rl_caught_signal); */
1 by Matthias Klose
Import upstream version 6.0
464
	  RL_CHECK_SIGNALS ();
465
	}
466
    }
467
468
  return (c);
469
}
470
471
int
472
rl_getc (stream)
473
     FILE *stream;
474
{
475
  int result;
476
  unsigned char c;
477
478
  while (1)
479
    {
480
      RL_CHECK_SIGNALS ();
481
17 by Matthias Klose
* readline 6.3 release.
482
      /* We know at this point that _rl_caught_signal == 0 */
483
1 by Matthias Klose
Import upstream version 6.0
484
#if defined (__MINGW32__)
485
      if (isatty (fileno (stream)))
486
	return (getch ());
487
#endif
488
      result = read (fileno (stream), &c, sizeof (unsigned char));
489
490
      if (result == sizeof (unsigned char))
491
	return (c);
492
493
      /* If zero characters are returned, then the file that we are
494
	 reading from is empty!  Return EOF in that case. */
495
      if (result == 0)
496
	return (EOF);
497
498
#if defined (__BEOS__)
499
      if (errno == EINTR)
500
	continue;
501
#endif
502
503
#if defined (EWOULDBLOCK)
504
#  define X_EWOULDBLOCK EWOULDBLOCK
505
#else
506
#  define X_EWOULDBLOCK -99
507
#endif
508
509
#if defined (EAGAIN)
510
#  define X_EAGAIN EAGAIN
511
#else
512
#  define X_EAGAIN -99
513
#endif
514
515
      if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
516
	{
517
	  if (sh_unset_nodelay_mode (fileno (stream)) < 0)
518
	    return (EOF);
519
	  continue;
520
	}
521
522
#undef X_EWOULDBLOCK
523
#undef X_EAGAIN
524
17 by Matthias Klose
* readline 6.3 release.
525
/* fprintf(stderr, "rl_getc: result = %d errno = %d\n", result, errno); */
526
527
      /* If the error that we received was EINTR, then try again,
528
	 this is simply an interrupted system call to read ().  We allow
529
	 the read to be interrupted if we caught SIGHUP or SIGTERM (but
530
	 not SIGINT; let the signal handler deal with that), but if the
531
	 application sets an event hook, call it for other signals.
532
	 Otherwise (not EINTR), some error occurred, also signifying EOF. */
1 by Matthias Klose
Import upstream version 6.0
533
      if (errno != EINTR)
534
	return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
17 by Matthias Klose
* readline 6.3 release.
535
      else if (_rl_caught_signal == SIGHUP || _rl_caught_signal == SIGTERM)
536
	return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
537
      else if (_rl_caught_signal == SIGINT || _rl_caught_signal == SIGQUIT)
538
        RL_CHECK_SIGNALS ();
539
540
      if (rl_signal_event_hook)
541
	(*rl_signal_event_hook) ();
1 by Matthias Klose
Import upstream version 6.0
542
    }
543
}
544
545
#if defined (HANDLE_MULTIBYTE)
546
/* read multibyte char */
547
int
548
_rl_read_mbchar (mbchar, size)
549
     char *mbchar;
550
     int size;
551
{
552
  int mb_len, c;
553
  size_t mbchar_bytes_length;
554
  wchar_t wc;
555
  mbstate_t ps, ps_back;
556
557
  memset(&ps, 0, sizeof (mbstate_t));
558
  memset(&ps_back, 0, sizeof (mbstate_t));
559
560
  mb_len = 0;  
561
  while (mb_len < size)
562
    {
563
      RL_SETSTATE(RL_STATE_MOREINPUT);
564
      c = rl_read_key ();
565
      RL_UNSETSTATE(RL_STATE_MOREINPUT);
566
567
      if (c < 0)
568
	break;
569
570
      mbchar[mb_len++] = c;
571
572
      mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
573
      if (mbchar_bytes_length == (size_t)(-1))
574
	break;		/* invalid byte sequence for the current locale */
575
      else if (mbchar_bytes_length == (size_t)(-2))
576
	{
577
	  /* shorted bytes */
578
	  ps = ps_back;
579
	  continue;
580
	} 
581
      else if (mbchar_bytes_length == 0)
582
	{
583
	  mbchar[0] = '\0';	/* null wide character */
584
	  mb_len = 1;
585
	  break;
586
	}
587
      else if (mbchar_bytes_length > (size_t)(0))
588
	break;
589
    }
590
591
  return mb_len;
592
}
593
594
/* Read a multibyte-character string whose first character is FIRST into
595
   the buffer MB of length MLEN.  Returns the last character read, which
596
   may be FIRST.  Used by the search functions, among others.  Very similar
597
   to _rl_read_mbchar. */
598
int
599
_rl_read_mbstring (first, mb, mlen)
600
     int first;
601
     char *mb;
602
     int mlen;
603
{
604
  int i, c;
605
  mbstate_t ps;
606
607
  c = first;
608
  memset (mb, 0, mlen);
609
  for (i = 0; c >= 0 && i < mlen; i++)
610
    {
611
      mb[i] = (char)c;
612
      memset (&ps, 0, sizeof (mbstate_t));
613
      if (_rl_get_char_len (mb, &ps) == -2)
614
	{
615
	  /* Read more for multibyte character */
616
	  RL_SETSTATE (RL_STATE_MOREINPUT);
617
	  c = rl_read_key ();
618
	  RL_UNSETSTATE (RL_STATE_MOREINPUT);
619
	}
620
      else
621
	break;
622
    }
623
  return c;
624
}
625
#endif /* HANDLE_MULTIBYTE */