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
));
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
;
182 tty
= fileno (rl_instream
);
184 #if defined (HAVE_SELECT)
186 FD_ZERO (&exceptfds
);
187 FD_SET (tty
, &readfds
);
188 FD_SET (tty
, &exceptfds
);
190 timeout
.tv_usec
= _keyboard_input_timeout
;
191 result
= select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
);
193 return 0; /* Nothing to read. */
197 #if defined (FIONREAD)
199 result
= ioctl (tty
, FIONREAD
, &chars_avail
);
200 if (result
== -1 && errno
== EIO
)
204 #if defined (O_NDELAY)
207 tem
= fcntl (tty
, F_GETFL
, 0);
209 fcntl (tty
, F_SETFL
, (tem
| O_NDELAY
));
210 chars_avail
= read (tty
, &input
, 1);
212 fcntl (tty
, F_SETFL
, tem
);
213 if (chars_avail
== -1 && errno
== EAGAIN
)
215 if (chars_avail
== 0) /* EOF */
221 #endif /* O_NDELAY */
223 #if defined (__MINGW32__)
224 /* We use getch to read console input, so use the same
225 mechanism to check for more. Otherwise, we don't know. */
226 if (isatty (fileno (rl_instream
)))
227 chars_avail
= _kbhit ();
233 /* If there's nothing available, don't waste time trying to read
235 if (chars_avail
<= 0)
238 tem
= ibuffer_space ();
240 if (chars_avail
> tem
)
243 /* One cannot read all of the available input. I can only read a single
244 character at a time, or else programs which require input can be
245 thwarted. If the buffer is larger than one character, I lose.
247 if (tem
< ibuffer_len
)
252 while (chars_avail
--)
254 k
= (*rl_getc_function
) (rl_instream
);
256 if (k
== NEWLINE
|| k
== RETURN
)
263 rl_stuff_char (input
);
270 rl_set_keyboard_input_timeout (u
)
275 o
= _keyboard_input_timeout
;
277 _keyboard_input_timeout
= u
;
281 /* Is there input available to be read on the readline input file
282 descriptor? Only works if the system has select(2) or FIONREAD.
283 Uses the value of _keyboard_input_timeout as the timeout; if another
284 readline function wants to specify a timeout and not leave it up to
285 the user, it should use _rl_input_queued(timeout_value_in_microseconds)
288 _rl_input_available ()
290 #if defined(HAVE_SELECT)
291 fd_set readfds
, exceptfds
;
292 struct timeval timeout
;
294 #if !defined (HAVE_SELECT) && defined(FIONREAD)
299 tty
= fileno (rl_instream
);
301 #if defined (HAVE_SELECT)
303 FD_ZERO (&exceptfds
);
304 FD_SET (tty
, &readfds
);
305 FD_SET (tty
, &exceptfds
);
307 timeout
.tv_usec
= _keyboard_input_timeout
;
308 return (select (tty
+ 1, &readfds
, (fd_set
*)NULL
, &exceptfds
, &timeout
) > 0);
311 #if defined (FIONREAD)
312 if (ioctl (tty
, FIONREAD
, &chars_avail
) == 0)
313 return (chars_avail
);
318 #if defined (__MINGW32__)
319 /* We use getch to read console input, so use the same
320 mechanism to check for more. Otherwise, we don't know. */
321 if (isatty (fileno (rl_instream
)))
334 old_timeout
= rl_set_keyboard_input_timeout (t
);
335 r
= _rl_input_available ();
336 rl_set_keyboard_input_timeout (old_timeout
);
341 _rl_insert_typein (c
)
348 string
= (char *)xmalloc (ibuffer_len
+ 1);
349 string
[i
++] = (char) c
;
351 while ((t
= rl_get_char (&key
)) &&
352 _rl_keymap
[key
].type
== ISFUNC
&&
353 _rl_keymap
[key
].function
== rl_insert
)
357 _rl_unget_char (key
);
360 rl_insert_text (string
);
364 /* Add KEY to the buffer of characters to be read. Returns 1 if the
365 character was stuffed correctly; 0 otherwise. */
370 if (ibuffer_space () == 0)
376 rl_pending_input
= EOF
;
377 RL_SETSTATE (RL_STATE_INPUTPENDING
);
379 ibuffer
[push_index
++] = key
;
380 if (push_index
>= ibuffer_len
)
386 /* Make C be the next command to be executed. */
391 rl_pending_input
= c
;
392 RL_SETSTATE (RL_STATE_INPUTPENDING
);
396 /* Clear any pending input pushed with rl_execute_next() */
398 rl_clear_pending_input ()
400 rl_pending_input
= 0;
401 RL_UNSETSTATE (RL_STATE_INPUTPENDING
);
405 /* **************************************************************** */
407 /* Character Input */
409 /* **************************************************************** */
411 /* Read a key, including pending input. */
417 rl_key_sequence_length
++;
419 if (rl_pending_input
)
421 c
= rl_pending_input
;
422 rl_clear_pending_input ();
426 /* If input is coming from a macro, then use that. */
427 if (c
= _rl_next_macro_key ())
430 /* If the user has an event function, then call it periodically. */
433 while (rl_event_hook
&& rl_get_char (&c
) == 0)
436 if (rl_done
) /* XXX - experimental */
438 if (rl_gather_tyi () < 0) /* XXX - EIO */
447 if (rl_get_char (&c
) == 0)
448 c
= (*rl_getc_function
) (rl_instream
);
464 #if defined (__MINGW32__)
465 if (isatty (fileno (stream
)))
468 result
= read (fileno (stream
), &c
, sizeof (unsigned char));
470 if (result
== sizeof (unsigned char))
473 /* If zero characters are returned, then the file that we are
474 reading from is empty! Return EOF in that case. */
478 #if defined (__BEOS__)
483 #if defined (EWOULDBLOCK)
484 # define X_EWOULDBLOCK EWOULDBLOCK
486 # define X_EWOULDBLOCK -99
490 # define X_EAGAIN EAGAIN
492 # define X_EAGAIN -99
495 if (errno
== X_EWOULDBLOCK
|| errno
== X_EAGAIN
)
497 if (sh_unset_nodelay_mode (fileno (stream
)) < 0)
505 /* If the error that we received was SIGINT, then try again,
506 this is simply an interrupted system call to read ().
507 Otherwise, some error ocurred, also signifying EOF. */
513 #if defined (HANDLE_MULTIBYTE)
514 /* read multibyte char */
516 _rl_read_mbchar (mbchar
, size
)
521 size_t mbchar_bytes_length
;
523 mbstate_t ps
, ps_back
;
525 memset(&ps
, 0, sizeof (mbstate_t));
526 memset(&ps_back
, 0, sizeof (mbstate_t));
528 while (mb_len
< size
)
530 RL_SETSTATE(RL_STATE_MOREINPUT
);
531 mbchar
[mb_len
++] = rl_read_key ();
532 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
534 mbchar_bytes_length
= mbrtowc (&wc
, mbchar
, mb_len
, &ps
);
535 if (mbchar_bytes_length
== (size_t)(-1))
536 break; /* invalid byte sequence for the current locale */
537 else if (mbchar_bytes_length
== (size_t)(-2))
543 else if (mbchar_bytes_length
== 0)
545 mbchar
[0] = '\0'; /* null wide character */
549 else if (mbchar_bytes_length
> (size_t)(0))
556 /* Read a multibyte-character string whose first character is FIRST into
557 the buffer MB of length MBLEN. Returns the last character read, which
558 may be FIRST. Used by the search functions, among others. Very similar
559 to _rl_read_mbchar. */
561 _rl_read_mbstring (first
, mb
, mblen
)
570 memset (mb
, 0, mblen
);
571 for (i
= 0; i
< mblen
; i
++)
574 memset (&ps
, 0, sizeof (mbstate_t));
575 if (_rl_get_char_len (mb
, &ps
) == -2)
577 /* Read more for multibyte character */
578 RL_SETSTATE (RL_STATE_MOREINPUT
);
580 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
587 #endif /* HANDLE_MULTIBYTE */
This page took 0.040444 seconds and 4 git commands to generate.