1 /* input.c -- character input functions for readline. */
3 /* Copyright (C) 1994-2015 Free Software Foundation, Inc.
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.
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.
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.
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/>.
22 #define READLINE_LIBRARY
24 #if defined (__TANDEM)
28 #if defined (HAVE_CONFIG_H)
32 #include <sys/types.h>
34 #if defined (HAVE_SYS_FILE_H)
35 # include <sys/file.h>
36 #endif /* HAVE_SYS_FILE_H */
38 #if defined (HAVE_UNISTD_H)
40 #endif /* HAVE_UNISTD_H */
42 #if defined (HAVE_STDLIB_H)
45 # include "ansi_stdlib.h"
46 #endif /* HAVE_STDLIB_H */
50 #include "posixselect.h"
52 #if defined (FIONREAD_IN_SYS_IOCTL)
53 # include <sys/ioctl.h>
63 /* System-specific feature definitions and include files. */
67 /* Some standard library routines. */
70 #include "rlprivate.h"
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 */
79 /* Non-null means it is a pointer to a function to run while waiting for
81 rl_hook_func_t
*rl_event_hook
= (rl_hook_func_t
*)NULL
;
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
;
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
;
90 rl_getc_func_t
*rl_getc_function
= rl_getc
;
92 static int _keyboard_input_timeout
= 100000; /* 0.1 seconds; it's in usec */
94 static int ibuffer_space
PARAMS((void));
95 static int rl_get_char
PARAMS((int *));
96 static int rl_gather_tyi
PARAMS((void));
98 #if defined (_WIN32) && !defined (__CYGWIN__)
100 /* 'isatty' in the Windows runtime returns non-zero for every
101 character device, including the null device. Repair that. */
104 #define WIN32_LEAN_AND_MEAN 1
107 int w32_isatty (int fd
)
111 HANDLE h
= (HANDLE
) _get_osfhandle (fd
);
114 if (h
== INVALID_HANDLE_VALUE
)
119 if (GetConsoleMode (h
, &ignored
) != 0)
126 #define isatty(x) w32_isatty(x)
129 /* **************************************************************** */
131 /* Character Input Buffering */
133 /* **************************************************************** */
135 static int pop_index
, push_index
;
136 static unsigned char ibuffer
[512];
137 static int ibuffer_len
= sizeof (ibuffer
) - 1;
139 #define any_typein (push_index != pop_index)
148 _rl_pushed_input_available ()
150 return (push_index
!= pop_index
);
153 /* Return the amount of space available in the buffer for stuffing
158 if (pop_index
> push_index
)
159 return (pop_index
- push_index
- 1);
161 return (ibuffer_len
- (push_index
- pop_index
));
164 /* Get a key from the buffer of characters to be read.
165 Return the key in KEY.
166 Result is non-zero if there was a key, or 0 if there wasn't. */
171 if (push_index
== pop_index
)
174 *key
= ibuffer
[pop_index
++];
176 if (pop_index
>= ibuffer_len
)
178 if (pop_index
> ibuffer_len
)
185 /* Stuff KEY into the *front* of the input buffer.
186 Returns non-zero if successful, zero if there is
187 no space left in the buffer. */
192 if (ibuffer_space ())
196 pop_index
= ibuffer_len
;
197 ibuffer
[pop_index
] = key
;
203 /* If a character is available to be read, then read it and stuff it into
204 IBUFFER. Otherwise, just return. Returns number of characters read
205 (0 if none available) and -1 on error (EIO). */
210 register int tem
, result
;
213 #if defined(HAVE_SELECT)
214 fd_set readfds
, exceptfds
;
215 struct timeval timeout
;
220 tty
= fileno (rl_instream
);
222 #if defined (HAVE_SELECT)
224 FD_ZERO (&exceptfds
);
225 FD_SET (tty
, &readfds
);
226 FD_SET (tty
, &exceptfds
);
227 USEC_TO_TIMEVAL (_keyboard_input_timeout
, timeout
);
228 result
= select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
);
230 return 0; /* Nothing to read. */
235 #if defined (FIONREAD)
236 result
= ioctl (tty
, FIONREAD
, &chars_avail
);
237 if (result
== -1 && errno
== EIO
)
243 #if defined (O_NDELAY)
246 tem
= fcntl (tty
, F_GETFL
, 0);
248 fcntl (tty
, F_SETFL
, (tem
| O_NDELAY
));
249 chars_avail
= read (tty
, &input
, 1);
251 fcntl (tty
, F_SETFL
, tem
);
252 if (chars_avail
== -1 && errno
== EAGAIN
)
254 if (chars_avail
== -1 && errno
== EIO
)
256 if (chars_avail
== 0) /* EOF */
262 #endif /* O_NDELAY */
264 #if defined (__MINGW32__)
265 /* Use getch/_kbhit to check for available console input, in the same way
266 that we read it normally. */
267 chars_avail
= isatty (tty
) ? _kbhit () : 0;
271 /* If there's nothing available, don't waste time trying to read
273 if (chars_avail
<= 0)
276 tem
= ibuffer_space ();
278 if (chars_avail
> tem
)
281 /* One cannot read all of the available input. I can only read a single
282 character at a time, or else programs which require input can be
283 thwarted. If the buffer is larger than one character, I lose.
285 if (tem
< ibuffer_len
)
290 while (chars_avail
--)
293 k
= (*rl_getc_function
) (rl_instream
);
294 if (rl_stuff_char (k
) == 0)
295 break; /* some problem; no more room */
296 if (k
== NEWLINE
|| k
== RETURN
)
303 rl_stuff_char (input
);
310 rl_set_keyboard_input_timeout (u
)
315 o
= _keyboard_input_timeout
;
317 _keyboard_input_timeout
= u
;
321 /* Is there input available to be read on the readline input file
322 descriptor? Only works if the system has select(2) or FIONREAD.
323 Uses the value of _keyboard_input_timeout as the timeout; if another
324 readline function wants to specify a timeout and not leave it up to
325 the user, it should use _rl_input_queued(timeout_value_in_microseconds)
328 _rl_input_available ()
330 #if defined(HAVE_SELECT)
331 fd_set readfds
, exceptfds
;
332 struct timeval timeout
;
334 #if !defined (HAVE_SELECT) && defined(FIONREAD)
339 if (rl_input_available_hook
)
340 return (*rl_input_available_hook
) ();
342 tty
= fileno (rl_instream
);
344 #if defined (HAVE_SELECT)
346 FD_ZERO (&exceptfds
);
347 FD_SET (tty
, &readfds
);
348 FD_SET (tty
, &exceptfds
);
350 timeout
.tv_usec
= _keyboard_input_timeout
;
351 return (select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
) > 0);
354 #if defined (FIONREAD)
355 if (ioctl (tty
, FIONREAD
, &chars_avail
) == 0)
356 return (chars_avail
);
361 #if defined (__MINGW32__)
375 old_timeout
= rl_set_keyboard_input_timeout (t
);
376 r
= _rl_input_available ();
377 rl_set_keyboard_input_timeout (old_timeout
);
382 _rl_insert_typein (c
)
389 string
= (char *)xmalloc (ibuffer_len
+ 1);
390 string
[i
++] = (char) c
;
392 while ((t
= rl_get_char (&key
)) &&
393 _rl_keymap
[key
].type
== ISFUNC
&&
394 _rl_keymap
[key
].function
== rl_insert
)
398 _rl_unget_char (key
);
401 rl_insert_text (string
);
405 /* Add KEY to the buffer of characters to be read. Returns 1 if the
406 character was stuffed correctly; 0 otherwise. */
411 if (ibuffer_space () == 0)
417 rl_pending_input
= EOF
;
418 RL_SETSTATE (RL_STATE_INPUTPENDING
);
420 ibuffer
[push_index
++] = key
;
422 if (push_index
>= ibuffer_len
)
424 if (push_index
> ibuffer_len
)
431 /* Make C be the next command to be executed. */
436 rl_pending_input
= c
;
437 RL_SETSTATE (RL_STATE_INPUTPENDING
);
441 /* Clear any pending input pushed with rl_execute_next() */
443 rl_clear_pending_input ()
445 rl_pending_input
= 0;
446 RL_UNSETSTATE (RL_STATE_INPUTPENDING
);
450 /* **************************************************************** */
452 /* Character Input */
454 /* **************************************************************** */
456 /* Read a key, including pending input. */
462 if (rl_pending_input
)
464 c
= rl_pending_input
;
465 rl_clear_pending_input ();
469 /* If input is coming from a macro, then use that. */
470 if (c
= _rl_next_macro_key ())
473 /* If the user has an event function, then call it periodically. */
476 while (rl_event_hook
)
478 if (rl_get_char (&c
) != 0)
481 if ((r
= rl_gather_tyi ()) < 0) /* XXX - EIO */
484 return (errno
== EIO
? (RL_ISSTATE (RL_STATE_READCMD
) ? READERR
: EOF
) : '\n');
486 else if (r
> 0) /* read something */
490 if (rl_done
) /* XXX - experimental */
497 if (rl_get_char (&c
) == 0)
498 c
= (*rl_getc_function
) (rl_instream
);
499 /* fprintf(stderr, "rl_read_key: calling RL_CHECK_SIGNALS: _rl_caught_signal = %d", _rl_caught_signal); */
513 #if defined (HAVE_PSELECT)
522 /* We know at this point that _rl_caught_signal == 0 */
524 #if defined (__MINGW32__)
525 if (isatty (fileno (stream
)))
526 return (_getch ()); /* "There is no error return." */
529 #if defined (HAVE_PSELECT)
530 sigemptyset (&empty_set
);
531 sigprocmask (SIG_BLOCK
, (sigset_t
*)NULL
, &empty_set
);
533 FD_SET (fileno (stream
), &readfds
);
534 result
= pselect (fileno (stream
) + 1, &readfds
, NULL
, NULL
, NULL
, &empty_set
);
537 result
= read (fileno (stream
), &c
, sizeof (unsigned char));
539 if (result
== sizeof (unsigned char))
542 /* If zero characters are returned, then the file that we are
543 reading from is empty! Return EOF in that case. */
547 #if defined (__BEOS__)
552 #if defined (EWOULDBLOCK)
553 # define X_EWOULDBLOCK EWOULDBLOCK
555 # define X_EWOULDBLOCK -99
559 # define X_EAGAIN EAGAIN
561 # define X_EAGAIN -99
564 if (errno
== X_EWOULDBLOCK
|| errno
== X_EAGAIN
)
566 if (sh_unset_nodelay_mode (fileno (stream
)) < 0)
574 /* fprintf(stderr, "rl_getc: result = %d errno = %d\n", result, errno); */
577 /* If the error that we received was EINTR, then try again,
578 this is simply an interrupted system call to read (). We allow
579 the read to be interrupted if we caught SIGHUP, SIGTERM, or any
580 of the other signals readline treats specially. If the
581 application sets an event hook, call it for other signals.
582 Otherwise (not EINTR), some error occurred, also signifying EOF. */
584 return (RL_ISSTATE (RL_STATE_READCMD
) ? READERR
: EOF
);
585 /* fatal signals of interest */
587 else if (_rl_caught_signal
== SIGHUP
|| _rl_caught_signal
== SIGTERM
)
589 else if (_rl_caught_signal
== SIGTERM
)
591 return (RL_ISSTATE (RL_STATE_READCMD
) ? READERR
: EOF
);
592 /* keyboard-generated signals of interest */
593 #if defined (SIGQUIT)
594 else if (_rl_caught_signal
== SIGINT
|| _rl_caught_signal
== SIGQUIT
)
596 else if (_rl_caught_signal
== SIGINT
)
599 /* non-keyboard-generated signals of interest */
600 #if defined (SIGWINCH)
601 else if (_rl_caught_signal
== SIGWINCH
)
603 #endif /* SIGWINCH */
604 #if defined (SIGALRM)
605 else if (_rl_caught_signal
== SIGALRM
606 # if defined (SIGVTALRM)
607 || _rl_caught_signal
== SIGVTALRM
613 if (rl_signal_event_hook
)
614 (*rl_signal_event_hook
) ();
618 #if defined (HANDLE_MULTIBYTE)
619 /* read multibyte char */
621 _rl_read_mbchar (mbchar
, size
)
626 size_t mbchar_bytes_length
;
628 mbstate_t ps
, ps_back
;
630 memset(&ps
, 0, sizeof (mbstate_t));
631 memset(&ps_back
, 0, sizeof (mbstate_t));
634 while (mb_len
< size
)
636 RL_SETSTATE(RL_STATE_MOREINPUT
);
638 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
643 mbchar
[mb_len
++] = c
;
645 mbchar_bytes_length
= mbrtowc (&wc
, mbchar
, mb_len
, &ps
);
646 if (mbchar_bytes_length
== (size_t)(-1))
647 break; /* invalid byte sequence for the current locale */
648 else if (mbchar_bytes_length
== (size_t)(-2))
654 else if (mbchar_bytes_length
== 0)
656 mbchar
[0] = '\0'; /* null wide character */
660 else if (mbchar_bytes_length
> (size_t)(0))
667 /* Read a multibyte-character string whose first character is FIRST into
668 the buffer MB of length MLEN. Returns the last character read, which
669 may be FIRST. Used by the search functions, among others. Very similar
670 to _rl_read_mbchar. */
672 _rl_read_mbstring (first
, mb
, mlen
)
681 memset (mb
, 0, mlen
);
682 for (i
= 0; c
>= 0 && i
< mlen
; i
++)
685 memset (&ps
, 0, sizeof (mbstate_t));
686 if (_rl_get_char_len (mb
, &ps
) == -2)
688 /* Read more for multibyte character */
689 RL_SETSTATE (RL_STATE_MOREINPUT
);
691 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
698 #endif /* HANDLE_MULTIBYTE */
This page took 0.043344 seconds and 5 git commands to generate.