1/* input.c -- character input functions for readline. */
2
3/* Copyright (C) 1994-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 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
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_readline.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
48#if defined (HAVE_SELECT)
49# if !defined (HAVE_SYS_SELECT_H) || !defined (M_UNIX)
50# include <sys/time.h>
51# endif
52#endif /* HAVE_SELECT */
53#if defined (HAVE_SYS_SELECT_H)
54# include <sys/select.h>
55#endif
56
57#if defined (FIONREAD_IN_SYS_IOCTL)
58# include <sys/ioctl.h>
59#endif
60
61#include <stdio.h>
62#include <errno.h>
63
64#if !defined (errno)
65extern int errno;
66#endif /* !errno */
67
68/* System-specific feature definitions and include files. */
69#include "rldefs.h"
70#include "rlmbutil.h"
71
72/* Some standard library routines. */
73#include "readline.h"
74
75#include "rlprivate.h"
76#include "rlshell.h"
77#include "xmalloc.h"
78
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 */
82#endif
83
84/* Non-null means it is a pointer to a function to run while waiting for
85 character input. */
86rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
87
88rl_getc_func_t *rl_getc_function = rl_getc;
89
90static int _keyboard_input_timeout = 100000; /* 0.1 seconds; it's in usec */
91
92static int ibuffer_space PARAMS((void));
93static int rl_get_char PARAMS((int *));
94static int rl_gather_tyi PARAMS((void));
95
96/* **************************************************************** */
97/* */
98/* Character Input Buffering */
99/* */
100/* **************************************************************** */
101
102static int pop_index, push_index;
103static unsigned char ibuffer[512];
104static int ibuffer_len = sizeof (ibuffer) - 1;
105
106#define any_typein (push_index != pop_index)
107
108int
109_rl_any_typein ()
110{
111 return any_typein;
112}
113
114/* Return the amount of space available in the buffer for stuffing
115 characters. */
116static int
117ibuffer_space ()
118{
119 if (pop_index > push_index)
120 return (pop_index - push_index - 1);
121 else
122 return (ibuffer_len - (push_index - pop_index));
123}
124
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. */
128static int
129rl_get_char (key)
130 int *key;
131{
132 if (push_index == pop_index)
133 return (0);
134
135 *key = ibuffer[pop_index++];
136
137 if (pop_index >= ibuffer_len)
138 pop_index = 0;
139
140 return (1);
141}
142
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. */
146int
147_rl_unget_char (key)
148 int key;
149{
150 if (ibuffer_space ())
151 {
152 pop_index--;
153 if (pop_index < 0)
154 pop_index = ibuffer_len - 1;
155 ibuffer[pop_index] = key;
156 return (1);
157 }
158 return (0);
159}
160
161int
162_rl_pushed_input_available ()
163{
164 return (push_index != pop_index);
165}
166
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). */
170static int
171rl_gather_tyi ()
172{
173 int tty;
174 register int tem, result;
175 int chars_avail, k;
176 char input;
177#if defined(HAVE_SELECT)
178 fd_set readfds, exceptfds;
179 struct timeval timeout;
180#endif
181
182 chars_avail = 0;
183 tty = fileno (rl_instream);
184
185#if defined (HAVE_SELECT)
186 FD_ZERO (&readfds);
187 FD_ZERO (&exceptfds);
188 FD_SET (tty, &readfds);
189 FD_SET (tty, &exceptfds);
190 timeout.tv_sec = 0;
191 timeout.tv_usec = _keyboard_input_timeout;
192 result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
193 if (result <= 0)
194 return 0; /* Nothing to read. */
195#endif
196
197 result = -1;
198#if defined (FIONREAD)
199 errno = 0;
200 result = ioctl (tty, FIONREAD, &chars_avail);
201 if (result == -1 && errno == EIO)
202 return -1;
203#endif
204
205#if defined (O_NDELAY)
206 if (result == -1)
207 {
208 tem = fcntl (tty, F_GETFL, 0);
209
210 fcntl (tty, F_SETFL, (tem | O_NDELAY));
211 chars_avail = read (tty, &input, 1);
212
213 fcntl (tty, F_SETFL, tem);
214 if (chars_avail == -1 && errno == EAGAIN)
215 return 0;
216 if (chars_avail == 0) /* EOF */
217 {
218 rl_stuff_char (EOF);
219 return (0);
220 }
221 }
222#endif /* O_NDELAY */
223
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;
228 result = 0;
229#endif
230
231 /* If there's nothing available, don't waste time trying to read
232 something. */
233 if (chars_avail <= 0)
234 return 0;
235
236 tem = ibuffer_space ();
237
238 if (chars_avail > tem)
239 chars_avail = tem;
240
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.
244 Damn! */
245 if (tem < ibuffer_len)
246 chars_avail = 0;
247
248 if (result != -1)
249 {
250 while (chars_avail--)
251 {
252 k = (*rl_getc_function) (rl_instream);
253 rl_stuff_char (k);
254 if (k == NEWLINE || k == RETURN)
255 break;
256 }
257 }
258 else
259 {
260 if (chars_avail)
261 rl_stuff_char (input);
262 }
263
264 return 1;
265}
266
267int
268rl_set_keyboard_input_timeout (u)
269 int u;
270{
271 int o;
272
273 o = _keyboard_input_timeout;
274 if (u >= 0)
275 _keyboard_input_timeout = u;
276 return (o);
277}
278
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)
284 instead. */
285int
286_rl_input_available ()
287{
288#if defined(HAVE_SELECT)
289 fd_set readfds, exceptfds;
290 struct timeval timeout;
291#endif
292#if !defined (HAVE_SELECT) && defined(FIONREAD)
293 int chars_avail;
294#endif
295 int tty;
296
297 tty = fileno (rl_instream);
298
299#if defined (HAVE_SELECT)
300 FD_ZERO (&readfds);
301 FD_ZERO (&exceptfds);
302 FD_SET (tty, &readfds);
303 FD_SET (tty, &exceptfds);
304 timeout.tv_sec = 0;
305 timeout.tv_usec = _keyboard_input_timeout;
306 return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
307#else
308
309#if defined (FIONREAD)
310 if (ioctl (tty, FIONREAD, &chars_avail) == 0)
311 return (chars_avail);
312#endif
313
314#endif
315
316#if defined (__MINGW32__)
317 if (isatty (tty))
318 return (_kbhit ());
319#endif
320
321#if !defined (HAVE_SELECT)
322 return 0;
323#endif
324}
325
326int
327_rl_input_queued (t)
328 int t;
329{
330 int old_timeout, r;
331
332 old_timeout = rl_set_keyboard_input_timeout (t);
333 r = _rl_input_available ();
334 rl_set_keyboard_input_timeout (old_timeout);
335 return r;
336}
337
338void
339_rl_insert_typein (c)
340 int c;
341{
342 int key, t, i;
343 char *string;
344
345 i = key = 0;
346 string = (char *)xmalloc (ibuffer_len + 1);
347 string[i++] = (char) c;
348
349 while ((t = rl_get_char (&key)) &&
350 _rl_keymap[key].type == ISFUNC &&
351 _rl_keymap[key].function == rl_insert)
352 string[i++] = key;
353
354 if (t)
355 _rl_unget_char (key);
356
357 string[i] = '\0';
358 rl_insert_text (string);
359 free (string);
360}
361
362/* Add KEY to the buffer of characters to be read. Returns 1 if the
363 character was stuffed correctly; 0 otherwise. */
364int
365rl_stuff_char (key)
366 int key;
367{
368 if (ibuffer_space () == 0)
369 return 0;
370
371 if (key == EOF)
372 {
373 key = NEWLINE;
374 rl_pending_input = EOF;
375 RL_SETSTATE (RL_STATE_INPUTPENDING);
376 }
377 ibuffer[push_index++] = key;
378 if (push_index >= ibuffer_len)
379 push_index = 0;
380
381 return 1;
382}
383
384/* Make C be the next command to be executed. */
385int
386rl_execute_next (c)
387 int c;
388{
389 rl_pending_input = c;
390 RL_SETSTATE (RL_STATE_INPUTPENDING);
391 return 0;
392}
393
394/* Clear any pending input pushed with rl_execute_next() */
395int
396rl_clear_pending_input ()
397{
398 rl_pending_input = 0;
399 RL_UNSETSTATE (RL_STATE_INPUTPENDING);
400 return 0;
401}
402
403/* **************************************************************** */
404/* */
405/* Character Input */
406/* */
407/* **************************************************************** */
408
409/* Read a key, including pending input. */
410int
411rl_read_key ()
412{
413 int c;
414
415 rl_key_sequence_length++;
416
417 if (rl_pending_input)
418 {
419 c = rl_pending_input;
420 rl_clear_pending_input ();
421 }
422 else
423 {
424 /* If input is coming from a macro, then use that. */
425 if ((c = _rl_next_macro_key ()))
426 return (c);
427
428 /* If the user has an event function, then call it periodically. */
429 if (rl_event_hook)
430 {
431 while (rl_event_hook && rl_get_char (&c) == 0)
432 {
433 (*rl_event_hook) ();
434 if (rl_done) /* XXX - experimental */
435 return ('\n');
436 if (rl_gather_tyi () < 0) /* XXX - EIO */
437 {
438 rl_done = 1;
439 return ('\n');
440 }
441 }
442 }
443 else
444 {
445 if (rl_get_char (&c) == 0)
446 c = (*rl_getc_function) (rl_instream);
447 }
448 }
449
450 return (c);
451}
452
453int
454rl_getc (stream)
455 FILE *stream;
456{
457 int result;
458 unsigned char c;
459
460 while (1)
461 {
462#if defined (__MINGW32__)
463 if (isatty (fileno (stream)))
464 return (getch ());
465#endif
466 result = read (fileno (stream), &c, sizeof (unsigned char));
467
468 if (result == sizeof (unsigned char))
469 return (c);
470
471 /* If zero characters are returned, then the file that we are
472 reading from is empty! Return EOF in that case. */
473 if (result == 0)
474 return (EOF);
475
476#if defined (__BEOS__)
477 if (errno == EINTR)
478 continue;
479#endif
480
481#if defined (EWOULDBLOCK)
482# define X_EWOULDBLOCK EWOULDBLOCK
483#else
484# define X_EWOULDBLOCK -99
485#endif
486
487#if defined (EAGAIN)
488# define X_EAGAIN EAGAIN
489#else
490# define X_EAGAIN -99
491#endif
492
493 if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
494 {
495 if (sh_unset_nodelay_mode (fileno (stream)) < 0)
496 return (EOF);
497 continue;
498 }
499
500#undef X_EWOULDBLOCK
501#undef X_EAGAIN
502
503 /* If the error that we received was SIGINT, then try again,
504 this is simply an interrupted system call to read ().
505 Otherwise, some error ocurred, also signifying EOF. */
506 if (errno != EINTR)
507 return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
508 }
509}
510
511#if defined (HANDLE_MULTIBYTE)
512/* read multibyte char */
513int
514_rl_read_mbchar (mbchar, size)
515 char *mbchar;
516 int size;
517{
518 int mb_len = 0;
519 size_t mbchar_bytes_length;
520 wchar_t wc;
521 mbstate_t ps, ps_back;
522
523 memset(&ps, 0, sizeof (mbstate_t));
524 memset(&ps_back, 0, sizeof (mbstate_t));
525
526 while (mb_len < size)
527 {
528 RL_SETSTATE(RL_STATE_MOREINPUT);
529 mbchar[mb_len++] = rl_read_key ();
530 RL_UNSETSTATE(RL_STATE_MOREINPUT);
531
532 mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
533 if (mbchar_bytes_length == (size_t)(-1))
534 break; /* invalid byte sequence for the current locale */
535 else if (mbchar_bytes_length == (size_t)(-2))
536 {
537 /* shorted bytes */
538 ps = ps_back;
539 continue;
540 }
541 else if (mbchar_bytes_length == 0)
542 {
543 mbchar[0] = '\0'; /* null wide character */
544 mb_len = 1;
545 break;
546 }
547 else if (mbchar_bytes_length > (size_t)(0))
548 break;
549 }
550
551 return mb_len;
552}
553
554/* Read a multibyte-character string whose first character is FIRST into
555 the buffer MB of length MLEN. Returns the last character read, which
556 may be FIRST. Used by the search functions, among others. Very similar
557 to _rl_read_mbchar. */
558int
559_rl_read_mbstring (first, mb, mlen)
560 int first;
561 char *mb;
562 int mlen;
563{
564 int i, c;
565 mbstate_t ps;
566
567 c = first;
568 memset (mb, 0, mlen);
569 for (i = 0; i < mlen; i++)
570 {
571 mb[i] = (char)c;
572 memset (&ps, 0, sizeof (mbstate_t));
573 if (_rl_get_char_len (mb, &ps) == -2)
574 {
575 /* Read more for multibyte character */
576 RL_SETSTATE (RL_STATE_MOREINPUT);
577 c = rl_read_key ();
578 RL_UNSETSTATE (RL_STATE_MOREINPUT);
579 }
580 else
581 break;
582 }
583 return c;
584}
585#endif /* HANDLE_MULTIBYTE */
586