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

1.1       misho       1: /* input.c -- character input functions for readline. */
                      2: 
1.1.1.3 ! misho       3: /* Copyright (C) 1994-2017 Free Software Foundation, Inc.
1.1       misho       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)
1.1.1.3 ! misho      25: #  define _XOPEN_SOURCE_EXTENDED 1
        !            26: #  define _TANDEM_SOURCE 1
1.1       misho      27: #  include <floss.h>
                     28: #endif
                     29: 
                     30: #if defined (HAVE_CONFIG_H)
                     31: #  include <config.h>
                     32: #endif
                     33: 
                     34: #include <sys/types.h>
                     35: #include <fcntl.h>
                     36: #if defined (HAVE_SYS_FILE_H)
                     37: #  include <sys/file.h>
                     38: #endif /* HAVE_SYS_FILE_H */
                     39: 
                     40: #if defined (HAVE_UNISTD_H)
                     41: #  include <unistd.h>
                     42: #endif /* HAVE_UNISTD_H */
                     43: 
                     44: #if defined (HAVE_STDLIB_H)
                     45: #  include <stdlib.h>
                     46: #else
                     47: #  include "ansi_stdlib.h"
                     48: #endif /* HAVE_STDLIB_H */
                     49: 
                     50: #include <signal.h>
                     51: 
                     52: #include "posixselect.h"
                     53: 
                     54: #if defined (FIONREAD_IN_SYS_IOCTL)
                     55: #  include <sys/ioctl.h>
                     56: #endif
                     57: 
                     58: #include <stdio.h>
                     59: #include <errno.h>
                     60: 
                     61: #if !defined (errno)
                     62: extern int errno;
                     63: #endif /* !errno */
                     64: 
                     65: /* System-specific feature definitions and include files. */
                     66: #include "rldefs.h"
                     67: #include "rlmbutil.h"
                     68: 
                     69: /* Some standard library routines. */
                     70: #include "readline.h"
                     71: 
                     72: #include "rlprivate.h"
                     73: #include "rlshell.h"
                     74: #include "xmalloc.h"
                     75: 
                     76: /* What kind of non-blocking I/O do we have? */
                     77: #if !defined (O_NDELAY) && defined (O_NONBLOCK)
                     78: #  define O_NDELAY O_NONBLOCK  /* Posix style */
                     79: #endif
                     80: 
1.1.1.3 ! misho      81: #if defined (HAVE_PSELECT)
        !            82: extern sigset_t _rl_orig_sigset;
        !            83: #endif
        !            84: 
1.1       misho      85: /* Non-null means it is a pointer to a function to run while waiting for
                     86:    character input. */
                     87: rl_hook_func_t *rl_event_hook = (rl_hook_func_t *)NULL;
                     88: 
                     89: /* A function to call if a read(2) is interrupted by a signal. */
                     90: rl_hook_func_t *rl_signal_event_hook = (rl_hook_func_t *)NULL;
                     91: 
                     92: /* A function to replace _rl_input_available for applications using the
                     93:    callback interface. */
                     94: rl_hook_func_t *rl_input_available_hook = (rl_hook_func_t *)NULL;
                     95: 
                     96: rl_getc_func_t *rl_getc_function = rl_getc;
                     97: 
                     98: static int _keyboard_input_timeout = 100000;           /* 0.1 seconds; it's in usec */
                     99: 
                    100: static int ibuffer_space PARAMS((void));
                    101: static int rl_get_char PARAMS((int *));
                    102: static int rl_gather_tyi PARAMS((void));
                    103: 
1.1.1.3 ! misho     104: /* Windows isatty returns true for every character device, including the null
        !           105:    device, so we need to perform additional checks. */
        !           106: #if defined (_WIN32) && !defined (__CYGWIN__)
        !           107: #include <io.h>
        !           108: #include <conio.h>
        !           109: #define WIN32_LEAN_AND_MEAN 1
        !           110: #include <windows.h>
        !           111: 
        !           112: int
        !           113: win32_isatty (int fd)
        !           114: {
        !           115:   if (_isatty(fd))
        !           116:     {
        !           117:       HANDLE h;
        !           118:       DWORD ignored;
        !           119: 
        !           120:       if ((h = (HANDLE) _get_osfhandle (fd)) == INVALID_HANDLE_VALUE)
        !           121:        {
        !           122:          errno = EBADF;
        !           123:          return 0;
        !           124:        }
        !           125:       if (GetConsoleMode (h, &ignored) != 0)
        !           126:        return 1;
        !           127:     }
        !           128:   errno = ENOTTY;
        !           129:   return 0;
        !           130: }
        !           131: 
        !           132: #define isatty(x)      win32_isatty(x)
        !           133: #endif
        !           134: 
1.1       misho     135: /* **************************************************************** */
                    136: /*                                                                 */
                    137: /*                     Character Input Buffering                   */
                    138: /*                                                                 */
                    139: /* **************************************************************** */
                    140: 
                    141: static int pop_index, push_index;
                    142: static unsigned char ibuffer[512];
                    143: static int ibuffer_len = sizeof (ibuffer) - 1;
                    144: 
                    145: #define any_typein (push_index != pop_index)
                    146: 
                    147: int
1.1.1.3 ! misho     148: _rl_any_typein (void)
1.1       misho     149: {
                    150:   return any_typein;
                    151: }
                    152: 
                    153: int
1.1.1.3 ! misho     154: _rl_pushed_input_available (void)
1.1       misho     155: {
                    156:   return (push_index != pop_index);
                    157: }
                    158: 
                    159: /* Return the amount of space available in the buffer for stuffing
                    160:    characters. */
                    161: static int
1.1.1.3 ! misho     162: ibuffer_space (void)
1.1       misho     163: {
                    164:   if (pop_index > push_index)
                    165:     return (pop_index - push_index - 1);
                    166:   else
                    167:     return (ibuffer_len - (push_index - pop_index));
                    168: }
                    169: 
                    170: /* Get a key from the buffer of characters to be read.
                    171:    Return the key in KEY.
                    172:    Result is non-zero if there was a key, or 0 if there wasn't. */
                    173: static int
1.1.1.3 ! misho     174: rl_get_char (int *key)
1.1       misho     175: {
                    176:   if (push_index == pop_index)
                    177:     return (0);
                    178: 
                    179:   *key = ibuffer[pop_index++];
                    180: #if 0
                    181:   if (pop_index >= ibuffer_len)
                    182: #else
                    183:   if (pop_index > ibuffer_len)
                    184: #endif
                    185:     pop_index = 0;
                    186: 
                    187:   return (1);
                    188: }
                    189: 
                    190: /* Stuff KEY into the *front* of the input buffer.
                    191:    Returns non-zero if successful, zero if there is
                    192:    no space left in the buffer. */
                    193: int
1.1.1.3 ! misho     194: _rl_unget_char (int key)
1.1       misho     195: {
                    196:   if (ibuffer_space ())
                    197:     {
                    198:       pop_index--;
                    199:       if (pop_index < 0)
                    200:        pop_index = ibuffer_len;
                    201:       ibuffer[pop_index] = key;
                    202:       return (1);
                    203:     }
                    204:   return (0);
                    205: }
                    206: 
                    207: /* If a character is available to be read, then read it and stuff it into
                    208:    IBUFFER.  Otherwise, just return.  Returns number of characters read
                    209:    (0 if none available) and -1 on error (EIO). */
                    210: static int
1.1.1.3 ! misho     211: rl_gather_tyi (void)
1.1       misho     212: {
                    213:   int tty;
                    214:   register int tem, result;
                    215:   int chars_avail, k;
                    216:   char input;
                    217: #if defined(HAVE_SELECT)
                    218:   fd_set readfds, exceptfds;
                    219:   struct timeval timeout;
                    220: #endif
                    221: 
                    222:   chars_avail = 0;
1.1.1.3 ! misho     223:   input = 0;
1.1       misho     224:   tty = fileno (rl_instream);
                    225: 
                    226: #if defined (HAVE_SELECT)
                    227:   FD_ZERO (&readfds);
                    228:   FD_ZERO (&exceptfds);
                    229:   FD_SET (tty, &readfds);
                    230:   FD_SET (tty, &exceptfds);
                    231:   USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
                    232:   result = select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout);
                    233:   if (result <= 0)
                    234:     return 0;  /* Nothing to read. */
                    235: #endif
                    236: 
                    237:   result = -1;
                    238:   errno = 0;
1.1.1.3 ! misho     239: #if defined (FIONREAD)
1.1       misho     240:   result = ioctl (tty, FIONREAD, &chars_avail);
                    241:   if (result == -1 && errno == EIO)
                    242:     return -1;
1.1.1.3 ! misho     243:   if (result == -1)
        !           244:     chars_avail = 0;
1.1       misho     245: #endif
                    246: 
                    247: #if defined (O_NDELAY)
                    248:   if (result == -1)
                    249:     {
                    250:       tem = fcntl (tty, F_GETFL, 0);
                    251: 
                    252:       fcntl (tty, F_SETFL, (tem | O_NDELAY));
                    253:       chars_avail = read (tty, &input, 1);
                    254: 
                    255:       fcntl (tty, F_SETFL, tem);
                    256:       if (chars_avail == -1 && errno == EAGAIN)
                    257:        return 0;
1.1.1.3 ! misho     258:       if (chars_avail == -1 && errno == EIO)
        !           259:        return -1;
1.1       misho     260:       if (chars_avail == 0)    /* EOF */
                    261:        {
                    262:          rl_stuff_char (EOF);
                    263:          return (0);
                    264:        }
                    265:     }
                    266: #endif /* O_NDELAY */
                    267: 
                    268: #if defined (__MINGW32__)
                    269:   /* Use getch/_kbhit to check for available console input, in the same way
                    270:      that we read it normally. */
                    271:    chars_avail = isatty (tty) ? _kbhit () : 0;
                    272:    result = 0;
                    273: #endif
                    274: 
                    275:   /* If there's nothing available, don't waste time trying to read
                    276:      something. */
                    277:   if (chars_avail <= 0)
                    278:     return 0;
                    279: 
                    280:   tem = ibuffer_space ();
                    281: 
                    282:   if (chars_avail > tem)
                    283:     chars_avail = tem;
                    284: 
                    285:   /* One cannot read all of the available input.  I can only read a single
                    286:      character at a time, or else programs which require input can be
                    287:      thwarted.  If the buffer is larger than one character, I lose.
                    288:      Damn! */
                    289:   if (tem < ibuffer_len)
                    290:     chars_avail = 0;
                    291: 
                    292:   if (result != -1)
                    293:     {
                    294:       while (chars_avail--)
                    295:        {
                    296:          RL_CHECK_SIGNALS ();
                    297:          k = (*rl_getc_function) (rl_instream);
                    298:          if (rl_stuff_char (k) == 0)
                    299:            break;                      /* some problem; no more room */
                    300:          if (k == NEWLINE || k == RETURN)
                    301:            break;
                    302:        }
                    303:     }
                    304:   else
                    305:     {
                    306:       if (chars_avail)
                    307:        rl_stuff_char (input);
                    308:     }
                    309: 
                    310:   return 1;
                    311: }
                    312: 
                    313: int
1.1.1.3 ! misho     314: rl_set_keyboard_input_timeout (int u)
1.1       misho     315: {
                    316:   int o;
                    317: 
                    318:   o = _keyboard_input_timeout;
                    319:   if (u >= 0)
                    320:     _keyboard_input_timeout = u;
                    321:   return (o);
                    322: }
                    323: 
                    324: /* Is there input available to be read on the readline input file
                    325:    descriptor?  Only works if the system has select(2) or FIONREAD.
                    326:    Uses the value of _keyboard_input_timeout as the timeout; if another
                    327:    readline function wants to specify a timeout and not leave it up to
                    328:    the user, it should use _rl_input_queued(timeout_value_in_microseconds)
                    329:    instead. */
                    330: int
1.1.1.3 ! misho     331: _rl_input_available (void)
1.1       misho     332: {
                    333: #if defined(HAVE_SELECT)
                    334:   fd_set readfds, exceptfds;
                    335:   struct timeval timeout;
                    336: #endif
                    337: #if !defined (HAVE_SELECT) && defined(FIONREAD)
                    338:   int chars_avail;
                    339: #endif
                    340:   int tty;
                    341: 
                    342:   if (rl_input_available_hook)
                    343:     return (*rl_input_available_hook) ();
                    344: 
                    345:   tty = fileno (rl_instream);
                    346: 
                    347: #if defined (HAVE_SELECT)
                    348:   FD_ZERO (&readfds);
                    349:   FD_ZERO (&exceptfds);
                    350:   FD_SET (tty, &readfds);
                    351:   FD_SET (tty, &exceptfds);
1.1.1.3 ! misho     352:   USEC_TO_TIMEVAL (_keyboard_input_timeout, timeout);
1.1       misho     353:   return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
                    354: #else
                    355: 
                    356: #if defined (FIONREAD)
                    357:   if (ioctl (tty, FIONREAD, &chars_avail) == 0)
                    358:     return (chars_avail);
                    359: #endif
                    360: 
                    361: #endif
                    362: 
                    363: #if defined (__MINGW32__)
                    364:   if (isatty (tty))
                    365:     return (_kbhit ());
                    366: #endif
                    367: 
                    368:   return 0;
                    369: }
                    370: 
                    371: int
1.1.1.3 ! misho     372: _rl_nchars_available ()
        !           373: {
        !           374:   int chars_avail, fd, result;
        !           375:   
        !           376:   chars_avail = 0;
        !           377:      
        !           378: #if defined (FIONREAD)
        !           379:   fd = fileno (rl_instream);
        !           380:   errno = 0;    
        !           381:   result = ioctl (fd, FIONREAD, &chars_avail);    
        !           382:   if (result == -1 && errno == EIO)    
        !           383:     return -1;    
        !           384: #endif
        !           385: 
        !           386:   return chars_avail;
        !           387: }
        !           388: 
        !           389: int
        !           390: _rl_input_queued (int t)
1.1       misho     391: {
                    392:   int old_timeout, r;
                    393: 
                    394:   old_timeout = rl_set_keyboard_input_timeout (t);
                    395:   r = _rl_input_available ();
                    396:   rl_set_keyboard_input_timeout (old_timeout);
                    397:   return r;
                    398: }
                    399: 
                    400: void
1.1.1.3 ! misho     401: _rl_insert_typein (int c)
1.1       misho     402: {      
                    403:   int key, t, i;
                    404:   char *string;
                    405: 
                    406:   i = key = 0;
                    407:   string = (char *)xmalloc (ibuffer_len + 1);
                    408:   string[i++] = (char) c;
                    409: 
                    410:   while ((t = rl_get_char (&key)) &&
                    411:         _rl_keymap[key].type == ISFUNC &&
                    412:         _rl_keymap[key].function == rl_insert)
                    413:     string[i++] = key;
                    414: 
                    415:   if (t)
                    416:     _rl_unget_char (key);
                    417: 
                    418:   string[i] = '\0';
                    419:   rl_insert_text (string);
                    420:   xfree (string);
                    421: }
                    422: 
                    423: /* Add KEY to the buffer of characters to be read.  Returns 1 if the
                    424:    character was stuffed correctly; 0 otherwise. */
                    425: int
1.1.1.3 ! misho     426: rl_stuff_char (int key)
1.1       misho     427: {
                    428:   if (ibuffer_space () == 0)
                    429:     return 0;
                    430: 
                    431:   if (key == EOF)
                    432:     {
                    433:       key = NEWLINE;
                    434:       rl_pending_input = EOF;
                    435:       RL_SETSTATE (RL_STATE_INPUTPENDING);
                    436:     }
                    437:   ibuffer[push_index++] = key;
                    438: #if 0
                    439:   if (push_index >= ibuffer_len)
                    440: #else
                    441:   if (push_index > ibuffer_len)
                    442: #endif
                    443:     push_index = 0;
                    444: 
                    445:   return 1;
                    446: }
                    447: 
                    448: /* Make C be the next command to be executed. */
                    449: int
1.1.1.3 ! misho     450: rl_execute_next (int c)
1.1       misho     451: {
                    452:   rl_pending_input = c;
                    453:   RL_SETSTATE (RL_STATE_INPUTPENDING);
                    454:   return 0;
                    455: }
                    456: 
                    457: /* Clear any pending input pushed with rl_execute_next() */
                    458: int
1.1.1.3 ! misho     459: rl_clear_pending_input (void)
1.1       misho     460: {
                    461:   rl_pending_input = 0;
                    462:   RL_UNSETSTATE (RL_STATE_INPUTPENDING);
                    463:   return 0;
                    464: }
                    465: 
                    466: /* **************************************************************** */
                    467: /*                                                                 */
                    468: /*                          Character Input                        */
                    469: /*                                                                 */
                    470: /* **************************************************************** */
                    471: 
                    472: /* Read a key, including pending input. */
                    473: int
1.1.1.3 ! misho     474: rl_read_key (void)
1.1       misho     475: {
                    476:   int c, r;
                    477: 
                    478:   if (rl_pending_input)
                    479:     {
1.1.1.3 ! misho     480:       c = rl_pending_input;    /* XXX - cast to unsigned char if > 0? */
1.1       misho     481:       rl_clear_pending_input ();
                    482:     }
                    483:   else
                    484:     {
                    485:       /* If input is coming from a macro, then use that. */
                    486:       if (c = _rl_next_macro_key ())
1.1.1.3 ! misho     487:        return ((unsigned char)c);
1.1       misho     488: 
                    489:       /* If the user has an event function, then call it periodically. */
                    490:       if (rl_event_hook)
                    491:        {
                    492:          while (rl_event_hook)
                    493:            {
                    494:              if (rl_get_char (&c) != 0)
                    495:                break;
                    496:                
                    497:              if ((r = rl_gather_tyi ()) < 0)   /* XXX - EIO */
                    498:                {
                    499:                  rl_done = 1;
1.1.1.3 ! misho     500:                  return (errno == EIO ? (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF) : '\n');
1.1       misho     501:                }
                    502:              else if (r > 0)                   /* read something */
                    503:                continue;
                    504: 
                    505:              RL_CHECK_SIGNALS ();
                    506:              if (rl_done)              /* XXX - experimental */
                    507:                return ('\n');
                    508:              (*rl_event_hook) ();
                    509:            }
                    510:        }
                    511:       else
                    512:        {
                    513:          if (rl_get_char (&c) == 0)
                    514:            c = (*rl_getc_function) (rl_instream);
1.1.1.3 ! misho     515: /* fprintf(stderr, "rl_read_key: calling RL_CHECK_SIGNALS: _rl_caught_signal = %d\r\n", _rl_caught_signal); */
1.1       misho     516:          RL_CHECK_SIGNALS ();
                    517:        }
                    518:     }
                    519: 
                    520:   return (c);
                    521: }
                    522: 
                    523: int
1.1.1.3 ! misho     524: rl_getc (FILE *stream)
1.1       misho     525: {
                    526:   int result;
                    527:   unsigned char c;
1.1.1.3 ! misho     528: #if defined (HAVE_PSELECT)
        !           529:   sigset_t empty_set;
        !           530:   fd_set readfds;
        !           531: #endif
1.1       misho     532: 
                    533:   while (1)
                    534:     {
                    535:       RL_CHECK_SIGNALS ();
                    536: 
                    537:       /* We know at this point that _rl_caught_signal == 0 */
                    538: 
                    539: #if defined (__MINGW32__)
                    540:       if (isatty (fileno (stream)))
1.1.1.3 ! misho     541:        return (_getch ());     /* "There is no error return." */
        !           542: #endif
        !           543:       result = 0;
        !           544: #if defined (HAVE_PSELECT)
        !           545:       FD_ZERO (&readfds);
        !           546:       FD_SET (fileno (stream), &readfds);
        !           547: #  if defined (HANDLE_SIGNALS)
        !           548:       result = pselect (fileno (stream) + 1, &readfds, NULL, NULL, NULL, &_rl_orig_sigset);
        !           549: #  else
        !           550:       sigemptyset (&empty_set);
        !           551:       sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &empty_set);
        !           552:       result = pselect (fileno (stream) + 1, &readfds, NULL, NULL, NULL, &empty_set);
        !           553: #  endif /* HANDLE_SIGNALS */
1.1       misho     554: #endif
1.1.1.3 ! misho     555:       if (result >= 0)
        !           556:        result = read (fileno (stream), &c, sizeof (unsigned char));
1.1       misho     557: 
                    558:       if (result == sizeof (unsigned char))
                    559:        return (c);
                    560: 
                    561:       /* If zero characters are returned, then the file that we are
                    562:         reading from is empty!  Return EOF in that case. */
                    563:       if (result == 0)
                    564:        return (EOF);
                    565: 
                    566: #if defined (__BEOS__)
                    567:       if (errno == EINTR)
                    568:        continue;
                    569: #endif
                    570: 
                    571: #if defined (EWOULDBLOCK)
                    572: #  define X_EWOULDBLOCK EWOULDBLOCK
                    573: #else
                    574: #  define X_EWOULDBLOCK -99
                    575: #endif
                    576: 
                    577: #if defined (EAGAIN)
                    578: #  define X_EAGAIN EAGAIN
                    579: #else
                    580: #  define X_EAGAIN -99
                    581: #endif
                    582: 
                    583:       if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
                    584:        {
                    585:          if (sh_unset_nodelay_mode (fileno (stream)) < 0)
                    586:            return (EOF);
                    587:          continue;
                    588:        }
                    589: 
                    590: #undef X_EWOULDBLOCK
                    591: #undef X_EAGAIN
                    592: 
                    593: /* fprintf(stderr, "rl_getc: result = %d errno = %d\n", result, errno); */
                    594: 
1.1.1.3 ! misho     595: handle_error:
1.1       misho     596:       /* If the error that we received was EINTR, then try again,
                    597:         this is simply an interrupted system call to read ().  We allow
1.1.1.3 ! misho     598:         the read to be interrupted if we caught SIGHUP, SIGTERM, or any
        !           599:         of the other signals readline treats specially. If the
1.1       misho     600:         application sets an event hook, call it for other signals.
                    601:         Otherwise (not EINTR), some error occurred, also signifying EOF. */
                    602:       if (errno != EINTR)
                    603:        return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
1.1.1.3 ! misho     604:       /* fatal signals of interest */
        !           605: #if defined (SIGHUP)
1.1       misho     606:       else if (_rl_caught_signal == SIGHUP || _rl_caught_signal == SIGTERM)
1.1.1.3 ! misho     607: #else
        !           608:       else if (_rl_caught_signal == SIGTERM)
        !           609: #endif
1.1       misho     610:        return (RL_ISSTATE (RL_STATE_READCMD) ? READERR : EOF);
1.1.1.2   misho     611:       /* keyboard-generated signals of interest */
1.1.1.3 ! misho     612: #if defined (SIGQUIT)
1.1       misho     613:       else if (_rl_caught_signal == SIGINT || _rl_caught_signal == SIGQUIT)
1.1.1.3 ! misho     614: #else
        !           615:       else if (_rl_caught_signal == SIGINT)
        !           616: #endif
1.1.1.2   misho     617:         RL_CHECK_SIGNALS ();
1.1.1.3 ! misho     618: #if defined (SIGTSTP)
        !           619:       else if (_rl_caught_signal == SIGTSTP)
        !           620:        RL_CHECK_SIGNALS ();
        !           621: #endif
1.1.1.2   misho     622:       /* non-keyboard-generated signals of interest */
1.1.1.3 ! misho     623: #if defined (SIGWINCH)
        !           624:       else if (_rl_caught_signal == SIGWINCH)
        !           625:        RL_CHECK_SIGNALS ();
        !           626: #endif /* SIGWINCH */
        !           627: #if defined (SIGALRM)
1.1.1.2   misho     628:       else if (_rl_caught_signal == SIGALRM
1.1.1.3 ! misho     629: #  if defined (SIGVTALRM)
1.1.1.2   misho     630:                || _rl_caught_signal == SIGVTALRM
1.1.1.3 ! misho     631: #  endif
1.1.1.2   misho     632:              )
1.1       misho     633:         RL_CHECK_SIGNALS ();
1.1.1.3 ! misho     634: #endif  /* SIGALRM */
1.1       misho     635: 
                    636:       if (rl_signal_event_hook)
                    637:        (*rl_signal_event_hook) ();
                    638:     }
                    639: }
                    640: 
                    641: #if defined (HANDLE_MULTIBYTE)
                    642: /* read multibyte char */
                    643: int
1.1.1.3 ! misho     644: _rl_read_mbchar (char *mbchar, int size)
1.1       misho     645: {
                    646:   int mb_len, c;
                    647:   size_t mbchar_bytes_length;
                    648:   wchar_t wc;
                    649:   mbstate_t ps, ps_back;
                    650: 
                    651:   memset(&ps, 0, sizeof (mbstate_t));
                    652:   memset(&ps_back, 0, sizeof (mbstate_t));
                    653: 
                    654:   mb_len = 0;  
                    655:   while (mb_len < size)
                    656:     {
1.1.1.3 ! misho     657:       c = (mb_len == 0) ? _rl_bracketed_read_key () : rl_read_key ();
1.1       misho     658: 
                    659:       if (c < 0)
                    660:        break;
                    661: 
                    662:       mbchar[mb_len++] = c;
                    663: 
                    664:       mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
                    665:       if (mbchar_bytes_length == (size_t)(-1))
                    666:        break;          /* invalid byte sequence for the current locale */
                    667:       else if (mbchar_bytes_length == (size_t)(-2))
                    668:        {
                    669:          /* shorted bytes */
                    670:          ps = ps_back;
                    671:          continue;
                    672:        } 
                    673:       else if (mbchar_bytes_length == 0)
                    674:        {
                    675:          mbchar[0] = '\0';     /* null wide character */
                    676:          mb_len = 1;
                    677:          break;
                    678:        }
                    679:       else if (mbchar_bytes_length > (size_t)(0))
                    680:        break;
                    681:     }
                    682: 
                    683:   return mb_len;
                    684: }
                    685: 
                    686: /* Read a multibyte-character string whose first character is FIRST into
                    687:    the buffer MB of length MLEN.  Returns the last character read, which
                    688:    may be FIRST.  Used by the search functions, among others.  Very similar
                    689:    to _rl_read_mbchar. */
                    690: int
1.1.1.3 ! misho     691: _rl_read_mbstring (int first, char *mb, int mlen)
1.1       misho     692: {
1.1.1.3 ! misho     693:   int i, c, n;
1.1       misho     694:   mbstate_t ps;
                    695: 
                    696:   c = first;
                    697:   memset (mb, 0, mlen);
                    698:   for (i = 0; c >= 0 && i < mlen; i++)
                    699:     {
                    700:       mb[i] = (char)c;
                    701:       memset (&ps, 0, sizeof (mbstate_t));
1.1.1.3 ! misho     702:       n = _rl_get_char_len (mb, &ps);
        !           703:       if (n == -2)
1.1       misho     704:        {
                    705:          /* Read more for multibyte character */
                    706:          RL_SETSTATE (RL_STATE_MOREINPUT);
                    707:          c = rl_read_key ();
                    708:          RL_UNSETSTATE (RL_STATE_MOREINPUT);
                    709:        }
                    710:       else
                    711:        break;
                    712:     }
                    713:   return c;
                    714: }
                    715: #endif /* HANDLE_MULTIBYTE */

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