]>
git.ipfire.org Git - thirdparty/bash.git/blob - lib/readline/input.c
1 /* input.c -- character input functions for readline. */
3 /* Copyright (C) 1994-2005 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library, a library for
6 reading lines of text with interactive input and history editing.
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.
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.
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
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 */
48 #if defined (HAVE_SELECT)
49 # if !defined (HAVE_SYS_SELECT_H) || !defined (M_UNIX)
50 # include <sys/time.h>
52 #endif /* HAVE_SELECT */
53 #if defined (HAVE_SYS_SELECT_H)
54 # include <sys/select.h>
57 #if defined (FIONREAD_IN_SYS_IOCTL)
58 # include <sys/ioctl.h>
68 /* System-specific feature definitions and include files. */
72 /* Some standard library routines. */
75 #include "rlprivate.h"
79 /* What kind of non-blocking I/O do we have? */
80 #if !defined (O_NDELAY) && defined (O_NONBLOCK)
81 # define O_NDELAY O_NONBLOCK /* Posix style */
84 /* Non-null means it is a pointer to a function to run while waiting for
86 rl_hook_func_t
*rl_event_hook
= (rl_hook_func_t
*)NULL
;
88 rl_getc_func_t
*rl_getc_function
= rl_getc
;
90 static int _keyboard_input_timeout
= 100000; /* 0.1 seconds; it's in usec */
92 static int ibuffer_space
PARAMS((void));
93 static int rl_get_char
PARAMS((int *));
94 static int rl_gather_tyi
PARAMS((void));
96 /* **************************************************************** */
98 /* Character Input Buffering */
100 /* **************************************************************** */
102 static int pop_index
, push_index
;
103 static unsigned char ibuffer
[512];
104 static int ibuffer_len
= sizeof (ibuffer
) - 1;
106 #define any_typein (push_index != pop_index)
114 /* Return the amount of space available in the buffer for stuffing
119 if (pop_index
> push_index
)
120 return (pop_index
- push_index
- 1);
122 return (ibuffer_len
- (push_index
- pop_index
) - 1);
125 /* Get a key from the buffer of characters to be read.
126 Return the key in KEY.
127 Result is KEY if there was a key, or 0 if there wasn't. */
132 if (push_index
== pop_index
)
135 *key
= ibuffer
[pop_index
++];
137 if (pop_index
>= ibuffer_len
)
143 /* Stuff KEY into the *front* of the input buffer.
144 Returns non-zero if successful, zero if there is
145 no space left in the buffer. */
150 if (ibuffer_space ())
154 pop_index
= ibuffer_len
- 1;
155 ibuffer
[pop_index
] = key
;
162 _rl_pushed_input_available ()
164 return (push_index
!= pop_index
);
167 /* If a character is available to be read, then read it and stuff it into
168 IBUFFER. Otherwise, just return. Returns number of characters read
169 (0 if none available) and -1 on error (EIO). */
174 register int tem
, result
;
177 #if defined(HAVE_SELECT)
178 fd_set readfds
, exceptfds
;
179 struct timeval timeout
;
183 tty
= fileno (rl_instream
);
185 #if defined (HAVE_SELECT)
187 FD_ZERO (&exceptfds
);
188 FD_SET (tty
, &readfds
);
189 FD_SET (tty
, &exceptfds
);
191 timeout
.tv_usec
= _keyboard_input_timeout
;
192 result
= select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
);
194 return 0; /* Nothing to read. */
198 #if defined (FIONREAD)
200 result
= ioctl (tty
, FIONREAD
, &chars_avail
);
201 if (result
== -1 && errno
== EIO
)
205 #if defined (O_NDELAY)
208 tem
= fcntl (tty
, F_GETFL
, 0);
210 fcntl (tty
, F_SETFL
, (tem
| O_NDELAY
));
211 chars_avail
= read (tty
, &input
, 1);
213 fcntl (tty
, F_SETFL
, tem
);
214 if (chars_avail
== -1 && errno
== EAGAIN
)
216 if (chars_avail
== 0) /* EOF */
222 #endif /* O_NDELAY */
224 #if defined (__MINGW32__)
225 /* Use getch/_kbhit to check for available console input, in the same way
226 that we read it normally. */
227 chars_avail
= isatty (tty
) ? _kbhit () : 0;
231 /* If there's nothing available, don't waste time trying to read
233 if (chars_avail
<= 0)
236 tem
= ibuffer_space ();
238 if (chars_avail
> tem
)
241 /* One cannot read all of the available input. I can only read a single
242 character at a time, or else programs which require input can be
243 thwarted. If the buffer is larger than one character, I lose.
245 if (tem
< ibuffer_len
)
250 while (chars_avail
--)
252 k
= (*rl_getc_function
) (rl_instream
);
254 if (k
== NEWLINE
|| k
== RETURN
)
261 rl_stuff_char (input
);
268 rl_set_keyboard_input_timeout (u
)
273 o
= _keyboard_input_timeout
;
275 _keyboard_input_timeout
= u
;
279 /* Is there input available to be read on the readline input file
280 descriptor? Only works if the system has select(2) or FIONREAD.
281 Uses the value of _keyboard_input_timeout as the timeout; if another
282 readline function wants to specify a timeout and not leave it up to
283 the user, it should use _rl_input_queued(timeout_value_in_microseconds)
286 _rl_input_available ()
288 #if defined(HAVE_SELECT)
289 fd_set readfds
, exceptfds
;
290 struct timeval timeout
;
292 #if !defined (HAVE_SELECT) && defined(FIONREAD)
297 tty
= fileno (rl_instream
);
299 #if defined (HAVE_SELECT)
301 FD_ZERO (&exceptfds
);
302 FD_SET (tty
, &readfds
);
303 FD_SET (tty
, &exceptfds
);
305 timeout
.tv_usec
= _keyboard_input_timeout
;
306 return (select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
) > 0);
309 #if defined (FIONREAD)
310 if (ioctl (tty
, FIONREAD
, &chars_avail
) == 0)
311 return (chars_avail
);
316 #if defined (__MINGW32__)
330 old_timeout
= rl_set_keyboard_input_timeout (t
);
331 r
= _rl_input_available ();
332 rl_set_keyboard_input_timeout (old_timeout
);
337 _rl_insert_typein (c
)
344 string
= (char *)xmalloc (ibuffer_len
+ 1);
345 string
[i
++] = (char) c
;
347 while ((t
= rl_get_char (&key
)) &&
348 _rl_keymap
[key
].type
== ISFUNC
&&
349 _rl_keymap
[key
].function
== rl_insert
)
353 _rl_unget_char (key
);
356 rl_insert_text (string
);
360 /* Add KEY to the buffer of characters to be read. Returns 1 if the
361 character was stuffed correctly; 0 otherwise. */
366 if (ibuffer_space () == 0)
372 rl_pending_input
= EOF
;
373 RL_SETSTATE (RL_STATE_INPUTPENDING
);
375 ibuffer
[push_index
++] = key
;
376 if (push_index
>= ibuffer_len
)
382 /* Make C be the next command to be executed. */
387 rl_pending_input
= c
;
388 RL_SETSTATE (RL_STATE_INPUTPENDING
);
392 /* Clear any pending input pushed with rl_execute_next() */
394 rl_clear_pending_input ()
396 rl_pending_input
= 0;
397 RL_UNSETSTATE (RL_STATE_INPUTPENDING
);
401 /* **************************************************************** */
403 /* Character Input */
405 /* **************************************************************** */
407 /* Read a key, including pending input. */
413 rl_key_sequence_length
++;
415 if (rl_pending_input
)
417 c
= rl_pending_input
;
418 rl_clear_pending_input ();
422 /* If input is coming from a macro, then use that. */
423 if (c
= _rl_next_macro_key ())
426 /* If the user has an event function, then call it periodically. */
429 while (rl_event_hook
&& rl_get_char (&c
) == 0)
432 if (rl_done
) /* XXX - experimental */
434 if (rl_gather_tyi () < 0) /* XXX - EIO */
443 if (rl_get_char (&c
) == 0)
444 c
= (*rl_getc_function
) (rl_instream
);
460 #if defined (__MINGW32__)
461 if (isatty (fileno (stream
)))
464 result
= read (fileno (stream
), &c
, sizeof (unsigned char));
466 if (result
== sizeof (unsigned char))
469 /* If zero characters are returned, then the file that we are
470 reading from is empty! Return EOF in that case. */
474 #if defined (__BEOS__)
479 #if defined (EWOULDBLOCK)
480 # define X_EWOULDBLOCK EWOULDBLOCK
482 # define X_EWOULDBLOCK -99
486 # define X_EAGAIN EAGAIN
488 # define X_EAGAIN -99
491 if (errno
== X_EWOULDBLOCK
|| errno
== X_EAGAIN
)
493 if (sh_unset_nodelay_mode (fileno (stream
)) < 0)
501 /* If the error that we received was SIGINT, then try again,
502 this is simply an interrupted system call to read ().
503 Otherwise, some error ocurred, also signifying EOF. */
505 return (RL_ISSTATE (RL_STATE_READCMD
) ? READERR
: EOF
);
509 #if defined (HANDLE_MULTIBYTE)
510 /* read multibyte char */
512 _rl_read_mbchar (mbchar
, size
)
517 size_t mbchar_bytes_length
;
519 mbstate_t ps
, ps_back
;
521 memset(&ps
, 0, sizeof (mbstate_t));
522 memset(&ps_back
, 0, sizeof (mbstate_t));
525 while (mb_len
< size
)
527 RL_SETSTATE(RL_STATE_MOREINPUT
);
529 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
534 mbchar
[mb_len
++] = c
;
536 mbchar_bytes_length
= mbrtowc (&wc
, mbchar
, mb_len
, &ps
);
537 if (mbchar_bytes_length
== (size_t)(-1))
538 break; /* invalid byte sequence for the current locale */
539 else if (mbchar_bytes_length
== (size_t)(-2))
545 else if (mbchar_bytes_length
== 0)
547 mbchar
[0] = '\0'; /* null wide character */
551 else if (mbchar_bytes_length
> (size_t)(0))
558 /* Read a multibyte-character string whose first character is FIRST into
559 the buffer MB of length MLEN. Returns the last character read, which
560 may be FIRST. Used by the search functions, among others. Very similar
561 to _rl_read_mbchar. */
563 _rl_read_mbstring (first
, mb
, mlen
)
572 memset (mb
, 0, mlen
);
573 for (i
= 0; c
> 0 && i
< mlen
; i
++)
576 memset (&ps
, 0, sizeof (mbstate_t));
577 if (_rl_get_char_len (mb
, &ps
) == -2)
579 /* Read more for multibyte character */
580 RL_SETSTATE (RL_STATE_MOREINPUT
);
582 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
589 #endif /* HANDLE_MULTIBYTE */