Annotation of embedaddon/readline/input.c, revision 1.1.1.1

1.1       misho       1: /* input.c -- character input functions for readline. */
                      2: 
                      3: /* Copyright (C) 1994-2013 Free Software Foundation, Inc.
                      4: 
                      5:    This file is part of the GNU Readline Library (Readline), a library
                      6:    for reading lines of text with interactive input and history editing.      
                      7: 
                      8:    Readline is free software: you can redistribute it and/or modify
                      9:    it under the terms of the GNU General Public License as published by
                     10:    the Free Software Foundation, either version 3 of the License, or
                     11:    (at your option) any later version.
                     12: 
                     13:    Readline is distributed in the hope that it will be useful,
                     14:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     16:    GNU General Public License for more details.
                     17: 
                     18:    You should have received a copy of the GNU General Public License
                     19:    along with Readline.  If not, see <http://www.gnu.org/licenses/>.
                     20: */
                     21: 
                     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: #include <signal.h>
                     49: 
                     50: #include "posixselect.h"
                     51: 
                     52: #if defined (FIONREAD_IN_SYS_IOCTL)
                     53: #  include <sys/ioctl.h>
                     54: #endif
                     55: 
                     56: #include <stdio.h>
                     57: #include <errno.h>
                     58: 
                     59: #if !defined (errno)
                     60: extern int errno;
                     61: #endif /* !errno */
                     62: 
                     63: /* System-specific feature definitions and include files. */
                     64: #include "rldefs.h"
                     65: #include "rlmbutil.h"
                     66: 
                     67: /* Some standard library routines. */
                     68: #include "readline.h"
                     69: 
                     70: #include "rlprivate.h"
                     71: #include "rlshell.h"
                     72: #include "xmalloc.h"
                     73: 
                     74: /* What kind of non-blocking I/O do we have? */
                     75: #if !defined (O_NDELAY) && defined (O_NONBLOCK)
                     76: #  define O_NDELAY O_NONBLOCK  /* Posix style */
                     77: #endif
                     78: 
                     79: /* Non-null means it is a pointer to a function to run while waiting for
                     80:    character input. */
                     81: rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
                     82: 
                     83: /* A function to call if a read(2) is interrupted by a signal. */
                     84: rl_hook_func_t *rl_signal_event_hook = (rl_hook_func_t *)NULL;
                     85: 
                     86: /* A function to replace _rl_input_available for applications using the
                     87:    callback interface. */
                     88: rl_hook_func_t *rl_input_available_hook = (rl_hook_func_t *)NULL;
                     89: 
                     90: rl_getc_func_t *rl_getc_function = rl_getc;
                     91: 
                     92: static int _keyboard_input_timeout = 100000;           /* 0.1 seconds; it's in usec */
                     93: 
                     94: static int ibuffer_space PARAMS((void));
                     95: static int rl_get_char PARAMS((int *));
                     96: static int rl_gather_tyi PARAMS((void));
                     97: 
                     98: /* **************************************************************** */
                     99: /*                                                                 */
                    100: /*                     Character Input Buffering                   */
                    101: /*                                                                 */
                    102: /* **************************************************************** */
                    103: 
                    104: static int pop_index, push_index;
                    105: static unsigned char ibuffer[512];
                    106: static int ibuffer_len = sizeof (ibuffer) - 1;
                    107: 
                    108: #define any_typein (push_index != pop_index)
                    109: 
                    110: int
                    111: _rl_any_typein ()
                    112: {
                    113:   return any_typein;
                    114: }
                    115: 
                    116: int
                    117: _rl_pushed_input_available ()
                    118: {
                    119:   return (push_index != pop_index);
                    120: }
                    121: 
                    122: /* Return the amount of space available in the buffer for stuffing
                    123:    characters. */
                    124: static int
                    125: ibuffer_space ()
                    126: {
                    127:   if (pop_index > push_index)
                    128:     return (pop_index - push_index - 1);
                    129:   else
                    130:     return (ibuffer_len - (push_index - pop_index));
                    131: }
                    132: 
                    133: /* Get a key from the buffer of characters to be read.
                    134:    Return the key in KEY.
                    135:    Result is non-zero if there was a key, or 0 if there wasn't. */
                    136: static int
                    137: rl_get_char (key)
                    138:      int *key;
                    139: {
                    140:   if (push_index == pop_index)
                    141:     return (0);
                    142: 
                    143:   *key = ibuffer[pop_index++];
                    144: #if 0
                    145:   if (pop_index >= ibuffer_len)
                    146: #else
                    147:   if (pop_index > ibuffer_len)
                    148: #endif
                    149:     pop_index = 0;
                    150: 
                    151:   return (1);
                    152: }
                    153: 
                    154: /* Stuff KEY into the *front* of the input buffer.
                    155:    Returns non-zero if successful, zero if there is
                    156:    no space left in the buffer. */
                    157: int
                    158: _rl_unget_char (key)
                    159:      int key;
                    160: {
                    161:   if (ibuffer_space ())
                    162:     {
                    163:       pop_index--;
                    164:       if (pop_index < 0)
                    165:        pop_index = ibuffer_len;
                    166:       ibuffer[pop_index] = key;
                    167:       return (1);
                    168:     }
                    169:   return (0);
                    170: }
                    171: 
                    172: /* If a character is available to be read, then read it and stuff it into
                    173:    IBUFFER.  Otherwise, just return.  Returns number of characters read
                    174:    (0 if none available) and -1 on error (EIO). */
                    175: static int
                    176: rl_gather_tyi ()
                    177: {
                    178:   int tty;
                    179:   register int tem, result;
                    180:   int chars_avail, k;
                    181:   char input;
                    182: #if defined(HAVE_SELECT)
                    183:   fd_set readfds, exceptfds;
                    184:   struct timeval timeout;
                    185: #endif
                    186: 
                    187:   chars_avail = 0;
                    188:   tty = fileno (rl_instream);
                    189: 
                    190: #if defined (HAVE_SELECT)
                    191:   FD_ZERO (&readfds);
                    192:   FD_ZERO (&exceptfds);
                    193:   FD_SET (tty, &readfds);
                    194:   FD_SET (tty, &exceptfds);
                    195:   USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
                    196:   result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
                    197:   if (result <= 0)
                    198:     return 0;  /* Nothing to read. */
                    199: #endif
                    200: 
                    201:   result = -1;
                    202: #if defined (FIONREAD)
                    203:   errno = 0;
                    204:   result = ioctl (tty, FIONREAD, &chars_avail);
                    205:   if (result == -1 && errno == EIO)
                    206:     return -1;
                    207: #endif
                    208: 
                    209: #if defined (O_NDELAY)
                    210:   if (result == -1)
                    211:     {
                    212:       tem = fcntl (tty, F_GETFL, 0);
                    213: 
                    214:       fcntl (tty, F_SETFL, (tem | O_NDELAY));
                    215:       chars_avail = read (tty, &input, 1);
                    216: 
                    217:       fcntl (tty, F_SETFL, tem);
                    218:       if (chars_avail == -1 && errno == EAGAIN)
                    219:        return 0;
                    220:       if (chars_avail == 0)    /* EOF */
                    221:        {
                    222:          rl_stuff_char (EOF);
                    223:          return (0);
                    224:        }
                    225:     }
                    226: #endif /* O_NDELAY */
                    227: 
                    228: #if defined (__MINGW32__)
                    229:   /* Use getch/_kbhit to check for available console input, in the same way
                    230:      that we read it normally. */
                    231:    chars_avail = isatty (tty) ? _kbhit () : 0;
                    232:    result = 0;
                    233: #endif
                    234: 
                    235:   /* If there's nothing available, don't waste time trying to read
                    236:      something. */
                    237:   if (chars_avail <= 0)
                    238:     return 0;
                    239: 
                    240:   tem = ibuffer_space ();
                    241: 
                    242:   if (chars_avail > tem)
                    243:     chars_avail = tem;
                    244: 
                    245:   /* One cannot read all of the available input.  I can only read a single
                    246:      character at a time, or else programs which require input can be
                    247:      thwarted.  If the buffer is larger than one character, I lose.
                    248:      Damn! */
                    249:   if (tem < ibuffer_len)
                    250:     chars_avail = 0;
                    251: 
                    252:   if (result != -1)
                    253:     {
                    254:       while (chars_avail--)
                    255:        {
                    256:          RL_CHECK_SIGNALS ();
                    257:          k = (*rl_getc_function) (rl_instream);
                    258:          if (rl_stuff_char (k) == 0)
                    259:            break;                      /* some problem; no more room */
                    260:          if (k == NEWLINE || k == RETURN)
                    261:            break;
                    262:        }
                    263:     }
                    264:   else
                    265:     {
                    266:       if (chars_avail)
                    267:        rl_stuff_char (input);
                    268:     }
                    269: 
                    270:   return 1;
                    271: }
                    272: 
                    273: int
                    274: rl_set_keyboard_input_timeout (u)
                    275:      int u;
                    276: {
                    277:   int o;
                    278: 
                    279:   o = _keyboard_input_timeout;
                    280:   if (u >= 0)
                    281:     _keyboard_input_timeout = u;
                    282:   return (o);
                    283: }
                    284: 
                    285: /* Is there input available to be read on the readline input file
                    286:    descriptor?  Only works if the system has select(2) or FIONREAD.
                    287:    Uses the value of _keyboard_input_timeout as the timeout; if another
                    288:    readline function wants to specify a timeout and not leave it up to
                    289:    the user, it should use _rl_input_queued(timeout_value_in_microseconds)
                    290:    instead. */
                    291: int
                    292: _rl_input_available ()
                    293: {
                    294: #if defined(HAVE_SELECT)
                    295:   fd_set readfds, exceptfds;
                    296:   struct timeval timeout;
                    297: #endif
                    298: #if !defined (HAVE_SELECT) && defined(FIONREAD)
                    299:   int chars_avail;
                    300: #endif
                    301:   int tty;
                    302: 
                    303:   if (rl_input_available_hook)
                    304:     return (*rl_input_available_hook) ();
                    305: 
                    306:   tty = fileno (rl_instream);
                    307: 
                    308: #if defined (HAVE_SELECT)
                    309:   FD_ZERO (&readfds);
                    310:   FD_ZERO (&exceptfds);
                    311:   FD_SET (tty, &readfds);
                    312:   FD_SET (tty, &exceptfds);
                    313:   timeout.tv_sec = 0;
                    314:   timeout.tv_usec = _keyboard_input_timeout;
                    315:   return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
                    316: #else
                    317: 
                    318: #if defined (FIONREAD)
                    319:   if (ioctl (tty, FIONREAD, &chars_avail) == 0)
                    320:     return (chars_avail);
                    321: #endif
                    322: 
                    323: #endif
                    324: 
                    325: #if defined (__MINGW32__)
                    326:   if (isatty (tty))
                    327:     return (_kbhit ());
                    328: #endif
                    329: 
                    330:   return 0;
                    331: }
                    332: 
                    333: int
                    334: _rl_input_queued (t)
                    335:      int t;
                    336: {
                    337:   int old_timeout, r;
                    338: 
                    339:   old_timeout = rl_set_keyboard_input_timeout (t);
                    340:   r = _rl_input_available ();
                    341:   rl_set_keyboard_input_timeout (old_timeout);
                    342:   return r;
                    343: }
                    344: 
                    345: void
                    346: _rl_insert_typein (c)
                    347:      int c;     
                    348: {      
                    349:   int key, t, i;
                    350:   char *string;
                    351: 
                    352:   i = key = 0;
                    353:   string = (char *)xmalloc (ibuffer_len + 1);
                    354:   string[i++] = (char) c;
                    355: 
                    356:   while ((t = rl_get_char (&key)) &&
                    357:         _rl_keymap[key].type == ISFUNC &&
                    358:         _rl_keymap[key].function == rl_insert)
                    359:     string[i++] = key;
                    360: 
                    361:   if (t)
                    362:     _rl_unget_char (key);
                    363: 
                    364:   string[i] = '\0';
                    365:   rl_insert_text (string);
                    366:   xfree (string);
                    367: }
                    368: 
                    369: /* Add KEY to the buffer of characters to be read.  Returns 1 if the
                    370:    character was stuffed correctly; 0 otherwise. */
                    371: int
                    372: rl_stuff_char (key)
                    373:      int key;
                    374: {
                    375:   if (ibuffer_space () == 0)
                    376:     return 0;
                    377: 
                    378:   if (key == EOF)
                    379:     {
                    380:       key = NEWLINE;
                    381:       rl_pending_input = EOF;
                    382:       RL_SETSTATE (RL_STATE_INPUTPENDING);
                    383:     }
                    384:   ibuffer[push_index++] = key;
                    385: #if 0
                    386:   if (push_index >= ibuffer_len)
                    387: #else
                    388:   if (push_index > ibuffer_len)
                    389: #endif
                    390:     push_index = 0;
                    391: 
                    392:   return 1;
                    393: }
                    394: 
                    395: /* Make C be the next command to be executed. */
                    396: int
                    397: rl_execute_next (c)
                    398:      int c;
                    399: {
                    400:   rl_pending_input = c;
                    401:   RL_SETSTATE (RL_STATE_INPUTPENDING);
                    402:   return 0;
                    403: }
                    404: 
                    405: /* Clear any pending input pushed with rl_execute_next() */
                    406: int
                    407: rl_clear_pending_input ()
                    408: {
                    409:   rl_pending_input = 0;
                    410:   RL_UNSETSTATE (RL_STATE_INPUTPENDING);
                    411:   return 0;
                    412: }
                    413: 
                    414: /* **************************************************************** */
                    415: /*                                                                 */
                    416: /*                          Character Input                        */
                    417: /*                                                                 */
                    418: /* **************************************************************** */
                    419: 
                    420: /* Read a key, including pending input. */
                    421: int
                    422: rl_read_key ()
                    423: {
                    424:   int c, r;
                    425: 
                    426:   if (rl_pending_input)
                    427:     {
                    428:       c = rl_pending_input;
                    429:       rl_clear_pending_input ();
                    430:     }
                    431:   else
                    432:     {
                    433:       /* If input is coming from a macro, then use that. */
                    434:       if (c = _rl_next_macro_key ())
                    435:        return (c);
                    436: 
                    437:       /* If the user has an event function, then call it periodically. */
                    438:       if (rl_event_hook)
                    439:        {
                    440:          while (rl_event_hook)
                    441:            {
                    442:              if (rl_get_char (&c) != 0)
                    443:                break;
                    444:                
                    445:              if ((r = rl_gather_tyi ()) < 0)   /* XXX - EIO */
                    446:                {
                    447:                  rl_done = 1;
                    448:                  return ('\n');
                    449:                }
                    450:              else if (r > 0)                   /* read something */
                    451:                continue;
                    452: 
                    453:              RL_CHECK_SIGNALS ();
                    454:              if (rl_done)              /* XXX - experimental */
                    455:                return ('\n');
                    456:              (*rl_event_hook) ();
                    457:            }
                    458:        }
                    459:       else
                    460:        {
                    461:          if (rl_get_char (&c) == 0)
                    462:            c = (*rl_getc_function) (rl_instream);
                    463: /* fprintf(stderr, "rl_read_key: calling RL_CHECK_SIGNALS: _rl_caught_signal = %d", _rl_caught_signal); */
                    464:          RL_CHECK_SIGNALS ();
                    465:        }
                    466:     }
                    467: 
                    468:   return (c);
                    469: }
                    470: 
                    471: int
                    472: rl_getc (stream)
                    473:      FILE *stream;
                    474: {
                    475:   int result;
                    476:   unsigned char c;
                    477: 
                    478:   while (1)
                    479:     {
                    480:       RL_CHECK_SIGNALS ();
                    481: 
                    482:       /* We know at this point that _rl_caught_signal == 0 */
                    483: 
                    484: #if defined (__MINGW32__)
                    485:       if (isatty (fileno (stream)))
                    486:        return (getch ());
                    487: #endif
                    488:       result = read (fileno (stream), &c, sizeof (unsigned char));
                    489: 
                    490:       if (result == sizeof (unsigned char))
                    491:        return (c);
                    492: 
                    493:       /* If zero characters are returned, then the file that we are
                    494:         reading from is empty!  Return EOF in that case. */
                    495:       if (result == 0)
                    496:        return (EOF);
                    497: 
                    498: #if defined (__BEOS__)
                    499:       if (errno == EINTR)
                    500:        continue;
                    501: #endif
                    502: 
                    503: #if defined (EWOULDBLOCK)
                    504: #  define X_EWOULDBLOCK EWOULDBLOCK
                    505: #else
                    506: #  define X_EWOULDBLOCK -99
                    507: #endif
                    508: 
                    509: #if defined (EAGAIN)
                    510: #  define X_EAGAIN EAGAIN
                    511: #else
                    512: #  define X_EAGAIN -99
                    513: #endif
                    514: 
                    515:       if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
                    516:        {
                    517:          if (sh_unset_nodelay_mode (fileno (stream)) < 0)
                    518:            return (EOF);
                    519:          continue;
                    520:        }
                    521: 
                    522: #undef X_EWOULDBLOCK
                    523: #undef X_EAGAIN
                    524: 
                    525: /* fprintf(stderr, "rl_getc: result = %d errno = %d\n", result, errno); */
                    526: 
                    527:       /* If the error that we received was EINTR, then try again,
                    528:         this is simply an interrupted system call to read ().  We allow
                    529:         the read to be interrupted if we caught SIGHUP or SIGTERM (but
                    530:         not SIGINT; let the signal handler deal with that), but if the
                    531:         application sets an event hook, call it for other signals.
                    532:         Otherwise (not EINTR), some error occurred, also signifying EOF. */
                    533:       if (errno != EINTR)
                    534:        return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
                    535:       else if (_rl_caught_signal == SIGHUP || _rl_caught_signal == SIGTERM)
                    536:        return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
                    537:       else if (_rl_caught_signal == SIGINT || _rl_caught_signal == SIGQUIT)
                    538:         RL_CHECK_SIGNALS ();
                    539: 
                    540:       if (rl_signal_event_hook)
                    541:        (*rl_signal_event_hook) ();
                    542:     }
                    543: }
                    544: 
                    545: #if defined (HANDLE_MULTIBYTE)
                    546: /* read multibyte char */
                    547: int
                    548: _rl_read_mbchar (mbchar, size)
                    549:      char *mbchar;
                    550:      int size;
                    551: {
                    552:   int mb_len, c;
                    553:   size_t mbchar_bytes_length;
                    554:   wchar_t wc;
                    555:   mbstate_t ps, ps_back;
                    556: 
                    557:   memset(&ps, 0, sizeof (mbstate_t));
                    558:   memset(&ps_back, 0, sizeof (mbstate_t));
                    559: 
                    560:   mb_len = 0;  
                    561:   while (mb_len < size)
                    562:     {
                    563:       RL_SETSTATE(RL_STATE_MOREINPUT);
                    564:       c = rl_read_key ();
                    565:       RL_UNSETSTATE(RL_STATE_MOREINPUT);
                    566: 
                    567:       if (c < 0)
                    568:        break;
                    569: 
                    570:       mbchar[mb_len++] = c;
                    571: 
                    572:       mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
                    573:       if (mbchar_bytes_length == (size_t)(-1))
                    574:        break;          /* invalid byte sequence for the current locale */
                    575:       else if (mbchar_bytes_length == (size_t)(-2))
                    576:        {
                    577:          /* shorted bytes */
                    578:          ps = ps_back;
                    579:          continue;
                    580:        } 
                    581:       else if (mbchar_bytes_length == 0)
                    582:        {
                    583:          mbchar[0] = '\0';     /* null wide character */
                    584:          mb_len = 1;
                    585:          break;
                    586:        }
                    587:       else if (mbchar_bytes_length > (size_t)(0))
                    588:        break;
                    589:     }
                    590: 
                    591:   return mb_len;
                    592: }
                    593: 
                    594: /* Read a multibyte-character string whose first character is FIRST into
                    595:    the buffer MB of length MLEN.  Returns the last character read, which
                    596:    may be FIRST.  Used by the search functions, among others.  Very similar
                    597:    to _rl_read_mbchar. */
                    598: int
                    599: _rl_read_mbstring (first, mb, mlen)
                    600:      int first;
                    601:      char *mb;
                    602:      int mlen;
                    603: {
                    604:   int i, c;
                    605:   mbstate_t ps;
                    606: 
                    607:   c = first;
                    608:   memset (mb, 0, mlen);
                    609:   for (i = 0; c >= 0 && i < mlen; i++)
                    610:     {
                    611:       mb[i] = (char)c;
                    612:       memset (&ps, 0, sizeof (mbstate_t));
                    613:       if (_rl_get_char_len (mb, &ps) == -2)
                    614:        {
                    615:          /* Read more for multibyte character */
                    616:          RL_SETSTATE (RL_STATE_MOREINPUT);
                    617:          c = rl_read_key ();
                    618:          RL_UNSETSTATE (RL_STATE_MOREINPUT);
                    619:        }
                    620:       else
                    621:        break;
                    622:     }
                    623:   return c;
                    624: }
                    625: #endif /* HANDLE_MULTIBYTE */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>