input.c revision 165670 
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   59 Temple Place, Suite 330, Boston, MA 02111 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.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  return 0;
322}
323
324int
325_rl_input_queued (t)
326     int t;
327{
328  int old_timeout, r;
329
330  old_timeout = rl_set_keyboard_input_timeout (t);
331  r = _rl_input_available ();
332  rl_set_keyboard_input_timeout (old_timeout);
333  return r;
334}
335
336void
337_rl_insert_typein (c)
338     int c;
339{
340  int key, t, i;
341  char *string;
342
343  i = key = 0;
344  string = (char *)xmalloc (ibuffer_len + 1);
345  string[i++] = (char) c;
346
347  while ((t = rl_get_char (&key)) &&
348	 _rl_keymap[key].type == ISFUNC &&
349	 _rl_keymap[key].function == rl_insert)
350    string[i++] = key;
351
352  if (t)
353    _rl_unget_char (key);
354
355  string[i] = '\0';
356  rl_insert_text (string);
357  free (string);
358}
359
360/* Add KEY to the buffer of characters to be read.  Returns 1 if the
361   character was stuffed correctly; 0 otherwise. */
362int
363rl_stuff_char (key)
364     int key;
365{
366  if (ibuffer_space () == 0)
367    return 0;
368
369  if (key == EOF)
370    {
371      key = NEWLINE;
372      rl_pending_input = EOF;
373      RL_SETSTATE (RL_STATE_INPUTPENDING);
374    }
375  ibuffer[push_index++] = key;
376  if (push_index >= ibuffer_len)
377    push_index = 0;
378
379  return 1;
380}
381
382/* Make C be the next command to be executed. */
383int
384rl_execute_next (c)
385     int c;
386{
387  rl_pending_input = c;
388  RL_SETSTATE (RL_STATE_INPUTPENDING);
389  return 0;
390}
391
392/* Clear any pending input pushed with rl_execute_next() */
393int
394rl_clear_pending_input ()
395{
396  rl_pending_input = 0;
397  RL_UNSETSTATE (RL_STATE_INPUTPENDING);
398  return 0;
399}
400
401/* **************************************************************** */
402/*								    */
403/*			     Character Input			    */
404/*								    */
405/* **************************************************************** */
406
407/* Read a key, including pending input. */
408int
409rl_read_key ()
410{
411  int c;
412
413  rl_key_sequence_length++;
414
415  if (rl_pending_input)
416    {
417      c = rl_pending_input;
418      rl_clear_pending_input ();
419    }
420  else
421    {
422      /* If input is coming from a macro, then use that. */
423      if (c = _rl_next_macro_key ())
424	return (c);
425
426      /* If the user has an event function, then call it periodically. */
427      if (rl_event_hook)
428	{
429	  while (rl_event_hook && rl_get_char (&c) == 0)
430	    {
431	      (*rl_event_hook) ();
432	      if (rl_done)		/* XXX - experimental */
433		return ('\n');
434	      if (rl_gather_tyi () < 0)	/* XXX - EIO */
435		{
436		  rl_done = 1;
437		  return ('\n');
438		}
439	    }
440	}
441      else
442	{
443	  if (rl_get_char (&c) == 0)
444	    c = (*rl_getc_function) (rl_instream);
445	}
446    }
447
448  return (c);
449}
450
451int
452rl_getc (stream)
453     FILE *stream;
454{
455  int result;
456  unsigned char c;
457
458  while (1)
459    {
460#if defined (__MINGW32__)
461      if (isatty (fileno (stream)))
462	return (getch ());
463#endif
464      result = read (fileno (stream), &c, sizeof (unsigned char));
465
466      if (result == sizeof (unsigned char))
467	return (c);
468
469      /* If zero characters are returned, then the file that we are
470	 reading from is empty!  Return EOF in that case. */
471      if (result == 0)
472	return (EOF);
473
474#if defined (__BEOS__)
475      if (errno == EINTR)
476	continue;
477#endif
478
479#if defined (EWOULDBLOCK)
480#  define X_EWOULDBLOCK EWOULDBLOCK
481#else
482#  define X_EWOULDBLOCK -99
483#endif
484
485#if defined (EAGAIN)
486#  define X_EAGAIN EAGAIN
487#else
488#  define X_EAGAIN -99
489#endif
490
491      if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
492	{
493	  if (sh_unset_nodelay_mode (fileno (stream)) < 0)
494	    return (EOF);
495	  continue;
496	}
497
498#undef X_EWOULDBLOCK
499#undef X_EAGAIN
500
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. */
504      if (errno != EINTR)
505	return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
506    }
507}
508
509#if defined (HANDLE_MULTIBYTE)
510/* read multibyte char */
511int
512_rl_read_mbchar (mbchar, size)
513     char *mbchar;
514     int size;
515{
516  int mb_len = 0;
517  size_t mbchar_bytes_length;
518  wchar_t wc;
519  mbstate_t ps, ps_back;
520
521  memset(&ps, 0, sizeof (mbstate_t));
522  memset(&ps_back, 0, sizeof (mbstate_t));
523
524  while (mb_len < size)
525    {
526      RL_SETSTATE(RL_STATE_MOREINPUT);
527      mbchar[mb_len++] = rl_read_key ();
528      RL_UNSETSTATE(RL_STATE_MOREINPUT);
529
530      mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
531      if (mbchar_bytes_length == (size_t)(-1))
532	break;		/* invalid byte sequence for the current locale */
533      else if (mbchar_bytes_length == (size_t)(-2))
534	{
535	  /* shorted bytes */
536	  ps = ps_back;
537	  continue;
538	}
539      else if (mbchar_bytes_length == 0)
540	{
541	  mbchar[0] = '\0';	/* null wide character */
542	  mb_len = 1;
543	  break;
544	}
545      else if (mbchar_bytes_length > (size_t)(0))
546	break;
547    }
548
549  return mb_len;
550}
551
552/* Read a multibyte-character string whose first character is FIRST into
553   the buffer MB of length MLEN.  Returns the last character read, which
554   may be FIRST.  Used by the search functions, among others.  Very similar
555   to _rl_read_mbchar. */
556int
557_rl_read_mbstring (first, mb, mlen)
558     int first;
559     char *mb;
560     int mlen;
561{
562  int i, c;
563  mbstate_t ps;
564
565  c = first;
566  memset (mb, 0, mlen);
567  for (i = 0; i < mlen; i++)
568    {
569      mb[i] = (char)c;
570      memset (&ps, 0, sizeof (mbstate_t));
571      if (_rl_get_char_len (mb, &ps) == -2)
572	{
573	  /* Read more for multibyte character */
574	  RL_SETSTATE (RL_STATE_MOREINPUT);
575	  c = rl_read_key ();
576	  RL_UNSETSTATE (RL_STATE_MOREINPUT);
577	}
578      else
579	break;
580    }
581  return c;
582}
583#endif /* HANDLE_MULTIBYTE */
584