Readline 5.1 import for HEAD.
[external/binutils.git] / readline / input.c
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)
65 extern 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. */
86 rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
87
88 rl_getc_func_t *rl_getc_function = rl_getc;
89
90 static int _keyboard_input_timeout = 100000;            /* 0.1 seconds; it's in usec */
91
92 static int ibuffer_space PARAMS((void));
93 static int rl_get_char PARAMS((int *));
94 static int rl_gather_tyi PARAMS((void));
95
96 /* **************************************************************** */
97 /*                                                                  */
98 /*                      Character Input Buffering                   */
99 /*                                                                  */
100 /* **************************************************************** */
101
102 static int pop_index, push_index;
103 static unsigned char ibuffer[512];
104 static int ibuffer_len = sizeof (ibuffer) - 1;
105
106 #define any_typein (push_index != pop_index)
107
108 int
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. */
116 static int
117 ibuffer_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. */
128 static int
129 rl_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. */
146 int
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
161 int
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). */
170 static int
171 rl_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   tty = fileno (rl_instream);
183
184 #if defined (HAVE_SELECT)
185   FD_ZERO (&readfds);
186   FD_ZERO (&exceptfds);
187   FD_SET (tty, &readfds);
188   FD_SET (tty, &exceptfds);
189   timeout.tv_sec = 0;
190   timeout.tv_usec = _keyboard_input_timeout;
191   result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
192   if (result <= 0)
193     return 0;   /* Nothing to read. */
194 #endif
195
196   result = -1;
197 #if defined (FIONREAD)
198   errno = 0;
199   result = ioctl (tty, FIONREAD, &chars_avail);
200   if (result == -1 && errno == EIO)
201     return -1;
202 #endif
203
204 #if defined (O_NDELAY)
205   if (result == -1)
206     {
207       tem = fcntl (tty, F_GETFL, 0);
208
209       fcntl (tty, F_SETFL, (tem | O_NDELAY));
210       chars_avail = read (tty, &input, 1);
211
212       fcntl (tty, F_SETFL, tem);
213       if (chars_avail == -1 && errno == EAGAIN)
214         return 0;
215       if (chars_avail == 0)     /* EOF */
216         {
217           rl_stuff_char (EOF);
218           return (0);
219         }
220     }
221 #endif /* O_NDELAY */
222
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 ();
228   else
229     chars_avail = 0;
230   result = 0;
231 #endif
232
233   /* If there's nothing available, don't waste time trying to read
234      something. */
235   if (chars_avail <= 0)
236     return 0;
237
238   tem = ibuffer_space ();
239
240   if (chars_avail > tem)
241     chars_avail = tem;
242
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.
246      Damn! */
247   if (tem < ibuffer_len)
248     chars_avail = 0;
249
250   if (result != -1)
251     {
252       while (chars_avail--)
253         {
254           k = (*rl_getc_function) (rl_instream);
255           rl_stuff_char (k);
256           if (k == NEWLINE || k == RETURN)
257             break;
258         }
259     }
260   else
261     {
262       if (chars_avail)
263         rl_stuff_char (input);
264     }
265
266   return 1;
267 }
268
269 int
270 rl_set_keyboard_input_timeout (u)
271      int u;
272 {
273   int o;
274
275   o = _keyboard_input_timeout;
276   if (u > 0)
277     _keyboard_input_timeout = u;
278   return (o);
279 }
280
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)
286    instead. */
287 int
288 _rl_input_available ()
289 {
290 #if defined(HAVE_SELECT)
291   fd_set readfds, exceptfds;
292   struct timeval timeout;
293 #endif
294 #if !defined (HAVE_SELECT) && defined(FIONREAD)
295   int chars_avail;
296 #endif
297   int tty;
298
299   tty = fileno (rl_instream);
300
301 #if defined (HAVE_SELECT)
302   FD_ZERO (&readfds);
303   FD_ZERO (&exceptfds);
304   FD_SET (tty, &readfds);
305   FD_SET (tty, &exceptfds);
306   timeout.tv_sec = 0;
307   timeout.tv_usec = _keyboard_input_timeout;
308   return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
309 #else
310
311 #if defined (FIONREAD)
312   if (ioctl (tty, FIONREAD, &chars_avail) == 0)
313     return (chars_avail);
314 #endif
315
316 #endif
317
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)))
322     return _kbhit ();
323 #endif
324
325   return 0;
326 }
327
328 int
329 _rl_input_queued (t)
330      int t;
331 {
332   int old_timeout, r;
333
334   old_timeout = rl_set_keyboard_input_timeout (t);
335   r = _rl_input_available ();
336   rl_set_keyboard_input_timeout (old_timeout);
337   return r;
338 }
339
340 void
341 _rl_insert_typein (c)
342      int c;     
343 {       
344   int key, t, i;
345   char *string;
346
347   i = key = 0;
348   string = (char *)xmalloc (ibuffer_len + 1);
349   string[i++] = (char) c;
350
351   while ((t = rl_get_char (&key)) &&
352          _rl_keymap[key].type == ISFUNC &&
353          _rl_keymap[key].function == rl_insert)
354     string[i++] = key;
355
356   if (t)
357     _rl_unget_char (key);
358
359   string[i] = '\0';
360   rl_insert_text (string);
361   free (string);
362 }
363
364 /* Add KEY to the buffer of characters to be read.  Returns 1 if the
365    character was stuffed correctly; 0 otherwise. */
366 int
367 rl_stuff_char (key)
368      int key;
369 {
370   if (ibuffer_space () == 0)
371     return 0;
372
373   if (key == EOF)
374     {
375       key = NEWLINE;
376       rl_pending_input = EOF;
377       RL_SETSTATE (RL_STATE_INPUTPENDING);
378     }
379   ibuffer[push_index++] = key;
380   if (push_index >= ibuffer_len)
381     push_index = 0;
382
383   return 1;
384 }
385
386 /* Make C be the next command to be executed. */
387 int
388 rl_execute_next (c)
389      int c;
390 {
391   rl_pending_input = c;
392   RL_SETSTATE (RL_STATE_INPUTPENDING);
393   return 0;
394 }
395
396 /* Clear any pending input pushed with rl_execute_next() */
397 int
398 rl_clear_pending_input ()
399 {
400   rl_pending_input = 0;
401   RL_UNSETSTATE (RL_STATE_INPUTPENDING);
402   return 0;
403 }
404
405 /* **************************************************************** */
406 /*                                                                  */
407 /*                           Character Input                        */
408 /*                                                                  */
409 /* **************************************************************** */
410
411 /* Read a key, including pending input. */
412 int
413 rl_read_key ()
414 {
415   int c;
416
417   rl_key_sequence_length++;
418
419   if (rl_pending_input)
420     {
421       c = rl_pending_input;
422       rl_clear_pending_input ();
423     }
424   else
425     {
426       /* If input is coming from a macro, then use that. */
427       if (c = _rl_next_macro_key ())
428         return (c);
429
430       /* If the user has an event function, then call it periodically. */
431       if (rl_event_hook)
432         {
433           while (rl_event_hook && rl_get_char (&c) == 0)
434             {
435               (*rl_event_hook) ();
436               if (rl_done)              /* XXX - experimental */
437                 return ('\n');
438               if (rl_gather_tyi () < 0) /* XXX - EIO */
439                 {
440                   rl_done = 1;
441                   return ('\n');
442                 }
443             }
444         }
445       else
446         {
447           if (rl_get_char (&c) == 0)
448             c = (*rl_getc_function) (rl_instream);
449         }
450     }
451
452   return (c);
453 }
454
455 int
456 rl_getc (stream)
457      FILE *stream;
458 {
459   int result;
460   unsigned char c;
461
462   while (1)
463     {
464 #if defined (__MINGW32__)
465       if (isatty (fileno (stream)))
466         return (getch ());
467 #endif
468       result = read (fileno (stream), &c, sizeof (unsigned char));
469
470       if (result == sizeof (unsigned char))
471         return (c);
472
473       /* If zero characters are returned, then the file that we are
474          reading from is empty!  Return EOF in that case. */
475       if (result == 0)
476         return (EOF);
477
478 #if defined (__BEOS__)
479       if (errno == EINTR)
480         continue;
481 #endif
482
483 #if defined (EWOULDBLOCK)
484 #  define X_EWOULDBLOCK EWOULDBLOCK
485 #else
486 #  define X_EWOULDBLOCK -99
487 #endif
488
489 #if defined (EAGAIN)
490 #  define X_EAGAIN EAGAIN
491 #else
492 #  define X_EAGAIN -99
493 #endif
494
495       if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
496         {
497           if (sh_unset_nodelay_mode (fileno (stream)) < 0)
498             return (EOF);
499           continue;
500         }
501
502 #undef X_EWOULDBLOCK
503 #undef X_EAGAIN
504
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. */
508       if (errno != EINTR)
509         return (EOF);
510     }
511 }
512
513 #if defined (HANDLE_MULTIBYTE)
514 /* read multibyte char */
515 int
516 _rl_read_mbchar (mbchar, size)
517      char *mbchar;
518      int size;
519 {
520   int mb_len = 0;
521   size_t mbchar_bytes_length;
522   wchar_t wc;
523   mbstate_t ps, ps_back;
524
525   memset(&ps, 0, sizeof (mbstate_t));
526   memset(&ps_back, 0, sizeof (mbstate_t));
527   
528   while (mb_len < size)
529     {
530       RL_SETSTATE(RL_STATE_MOREINPUT);
531       mbchar[mb_len++] = rl_read_key ();
532       RL_UNSETSTATE(RL_STATE_MOREINPUT);
533
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))
538         {
539           /* shorted bytes */
540           ps = ps_back;
541           continue;
542         } 
543       else if (mbchar_bytes_length == 0)
544         {
545           mbchar[0] = '\0';     /* null wide character */
546           mb_len = 1;
547           break;
548         }
549       else if (mbchar_bytes_length > (size_t)(0))
550         break;
551     }
552
553   return mb_len;
554 }
555
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. */
560 int
561 _rl_read_mbstring (first, mb, mblen)
562      int first;
563      char *mb;
564      int mblen;
565 {
566   int i, c;
567   mbstate_t ps;
568
569   c = first;
570   memset (mb, 0, mblen);
571   for (i = 0; i < mblen; i++)
572     {
573       mb[i] = (char)c;
574       memset (&ps, 0, sizeof (mbstate_t));
575       if (_rl_get_char_len (mb, &ps) == -2)
576         {
577           /* Read more for multibyte character */
578           RL_SETSTATE (RL_STATE_MOREINPUT);
579           c = rl_read_key ();
580           RL_UNSETSTATE (RL_STATE_MOREINPUT);
581         }
582       else
583         break;
584     }
585   return c;
586 }
587 #endif /* HANDLE_MULTIBYTE */