lib/readline/input.c

   1 /* input.c -- character input functions for readline. */
   2
   3 /* Copyright (C) 1994 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     }
 216 #endif /* O_NDELAY */
 217
 218   /* If there's nothing available, don't waste time trying to read
 219      something. */
 220   if (chars_avail <= 0)
 221     return 0;
 222
 223   tem = ibuffer_space ();
 224
 225   if (chars_avail > tem)
 226     chars_avail = tem;
 227
 228   /* One cannot read all of the available input.  I can only read a single
 229      character at a time, or else programs which require input can be
 230      thwarted.  If the buffer is larger than one character, I lose.
 231      Damn! */
 232   if (tem < ibuffer_len)
 233     chars_avail = 0;
 234
 235   if (result != -1)
 236     {
 237       while (chars_avail--)
 238         {
 239           k = (*rl_getc_function) (rl_instream);
 240           rl_stuff_char (k);
 241           if (k == NEWLINE || k == RETURN)
 242             break;
 243         }
 244     }
 245   else
 246     {
 247       if (chars_avail)
 248         rl_stuff_char (input);
 249     }
 250
 251   return 1;
 252 }
 253
 254 int
 255 rl_set_keyboard_input_timeout (u)
 256      int u;
 257 {
 258   int o;
 259
 260   o = _keyboard_input_timeout;
 261   if (u > 0)
 262     _keyboard_input_timeout = u;
 263   return (o);
 264 }
 265
 266 /* Is there input available to be read on the readline input file
 267    descriptor?  Only works if the system has select(2) or FIONREAD.
 268    Uses the value of _keyboard_input_timeout as the timeout; if another
 269    readline function wants to specify a timeout and not leave it up to
 270    the user, it should use _rl_input_queued(timeout_value_in_microseconds)
 271    instead. */
 272 int
 273 _rl_input_available ()
 274 {
 275 #if defined(HAVE_SELECT)
 276   fd_set readfds, exceptfds;
 277   struct timeval timeout;
 278 #endif
 279 #if !defined (HAVE_SELECT) && defined(FIONREAD)
 280   int chars_avail;
 281 #endif
 282   int tty;
 283
 284   tty = fileno (rl_instream);
 285
 286 #if defined (HAVE_SELECT)
 287   FD_ZERO (&readfds);
 288   FD_ZERO (&exceptfds);
 289   FD_SET (tty, &readfds);
 290   FD_SET (tty, &exceptfds);
 291   timeout.tv_sec = 0;
 292   timeout.tv_usec = _keyboard_input_timeout;
 293   return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
 294 #else
 295
 296 #if defined (FIONREAD)
 297   if (ioctl (tty, FIONREAD, &chars_avail) == 0)
 298     return (chars_avail);
 299 #endif
 300
 301 #endif
 302
 303   return 0;
 304 }
 305
 306 int
 307 _rl_input_queued (t)
 308      int t;
 309 {
 310   int old_timeout, r;
 311
 312   old_timeout = rl_set_keyboard_input_timeout (t);
 313   r = _rl_input_available ();
 314   rl_set_keyboard_input_timeout (old_timeout);
 315   return r;
 316 }
 317
 318 void
 319 _rl_insert_typein (c)
 320      int c;
 321 {
 322   int key, t, i;
 323   char *string;
 324
 325   i = key = 0;
 326   string = (char *)xmalloc (ibuffer_len + 1);
 327   string[i++] = (char) c;
 328
 329   while ((t = rl_get_char (&key)) &&
 330          _rl_keymap[key].type == ISFUNC &&
 331          _rl_keymap[key].function == rl_insert)
 332     string[i++] = key;
 333
 334   if (t)
 335     _rl_unget_char (key);
 336
 337   string[i] = '\0';
 338   rl_insert_text (string);
 339   free (string);
 340 }
 341
 342 /* Add KEY to the buffer of characters to be read.  Returns 1 if the
 343    character was stuffed correctly; 0 otherwise. */
 344 int
 345 rl_stuff_char (key)
 346      int key;
 347 {
 348   if (ibuffer_space () == 0)
 349     return 0;
 350
 351   if (key == EOF)
 352     {
 353       key = NEWLINE;
 354       rl_pending_input = EOF;
 355       RL_SETSTATE (RL_STATE_INPUTPENDING);
 356     }
 357   ibuffer[push_index++] = key;
 358   if (push_index >= ibuffer_len)
 359     push_index = 0;
 360
 361   return 1;
 362 }
 363
 364 /* Make C be the next command to be executed. */
 365 int
 366 rl_execute_next (c)
 367      int c;
 368 {
 369   rl_pending_input = c;
 370   RL_SETSTATE (RL_STATE_INPUTPENDING);
 371   return 0;
 372 }
 373
 374 /* Clear any pending input pushed with rl_execute_next() */
 375 int
 376 rl_clear_pending_input ()
 377 {
 378   rl_pending_input = 0;
 379   RL_UNSETSTATE (RL_STATE_INPUTPENDING);
 380   return 0;
 381 }
 382
 383 /* **************************************************************** */
 384 /*                                                                  */
 385 /*                           Character Input                        */
 386 /*                                                                  */
 387 /* **************************************************************** */
 388
 389 /* Read a key, including pending input. */
 390 int
 391 rl_read_key ()
 392 {
 393   int c;
 394
 395   rl_key_sequence_length++;
 396
 397   if (rl_pending_input)
 398     {
 399       c = rl_pending_input;
 400       rl_clear_pending_input ();
 401     }
 402   else
 403     {
 404       /* If input is coming from a macro, then use that. */
 405       if (c = _rl_next_macro_key ())
 406         return (c);
 407
 408       /* If the user has an event function, then call it periodically. */
 409       if (rl_event_hook)
 410         {
 411           while (rl_event_hook && rl_get_char (&c) == 0)
 412             {
 413               (*rl_event_hook) ();
 414               if (rl_done)              /* XXX - experimental */
 415                 return ('\n');
 416               if (rl_gather_tyi () < 0) /* XXX - EIO */
 417                 {
 418                   rl_done = 1;
 419                   return ('\n');
 420                 }
 421             }
 422         }
 423       else
 424         {
 425           if (rl_get_char (&c) == 0)
 426             c = (*rl_getc_function) (rl_instream);
 427         }
 428     }
 429
 430   return (c);
 431 }
 432
 433 int
 434 rl_getc (stream)
 435      FILE *stream;
 436 {
 437   int result;
 438   unsigned char c;
 439
 440   while (1)
 441     {
 442       result = read (fileno (stream), &c, sizeof (unsigned char));
 443
 444       if (result == sizeof (unsigned char))
 445         return (c);
 446
 447       /* If zero characters are returned, then the file that we are
 448          reading from is empty!  Return EOF in that case. */
 449       if (result == 0)
 450         return (EOF);
 451
 452 #if defined (__BEOS__)
 453       if (errno == EINTR)
 454         continue;
 455 #endif
 456
 457 #if defined (EWOULDBLOCK)
 458 #  define X_EWOULDBLOCK EWOULDBLOCK
 459 #else
 460 #  define X_EWOULDBLOCK -99
 461 #endif
 462
 463 #if defined (EAGAIN)
 464 #  define X_EAGAIN EAGAIN
 465 #else
 466 #  define X_EAGAIN -99
 467 #endif
 468
 469       if (errno == X_EWOULDBLOCK || errno == X_EAGAIN)
 470         {
 471           if (sh_unset_nodelay_mode (fileno (stream)) < 0)
 472             return (EOF);
 473           continue;
 474         }
 475
 476 #undef X_EWOULDBLOCK
 477 #undef X_EAGAIN
 478
 479       /* If the error that we received was SIGINT, then try again,
 480          this is simply an interrupted system call to read ().
 481          Otherwise, some error ocurred, also signifying EOF. */
 482       if (errno != EINTR)
 483         return (EOF);
 484     }
 485 }
 486
 487 #if defined (HANDLE_MULTIBYTE)
 488 /* read multibyte char */
 489 int
 490 _rl_read_mbchar (mbchar, size)
 491      char *mbchar;
 492      int size;
 493 {
 494   int mb_len = 0;
 495   size_t mbchar_bytes_length;
 496   wchar_t wc;
 497   mbstate_t ps, ps_back;
 498
 499   memset(&ps, 0, sizeof (mbstate_t));
 500   memset(&ps_back, 0, sizeof (mbstate_t));
 501
 502   while (mb_len < size)
 503     {
 504       RL_SETSTATE(RL_STATE_MOREINPUT);
 505       mbchar[mb_len++] = rl_read_key ();
 506       RL_UNSETSTATE(RL_STATE_MOREINPUT);
 507
 508       mbchar_bytes_length = mbrtowc (&wc, mbchar, mb_len, &ps);
 509       if (mbchar_bytes_length == (size_t)(-1))
 510         break;          /* invalid byte sequence for the current locale */
 511       else if (mbchar_bytes_length == (size_t)(-2))
 512         {
 513           /* shorted bytes */
 514           ps = ps_back;
 515           continue;
 516         }
 517       else if (mbchar_bytes_length > (size_t)(0))
 518         break;
 519     }
 520
 521   return mb_len;
 522 }
 523
 524 /* Read a multibyte-character string whose first character is FIRST into
 525    the buffer MB of length MBLEN.  Returns the last character read, which
 526    may be FIRST.  Used by the search functions, among others.  Very similar
 527    to _rl_read_mbchar. */
 528 int
 529 _rl_read_mbstring (first, mb, mblen)
 530      int first;
 531      char *mb;
 532      int mblen;
 533 {
 534   int i, c;
 535   mbstate_t ps;
 536
 537   c = first;
 538   memset (mb, 0, mblen);
 539   for (i = 0; i < mblen; i++)
 540     {
 541       mb[i] = (char)c;
 542       memset (&ps, 0, sizeof (mbstate_t));
 543       if (_rl_get_char_len (mb, &ps) == -2)
 544         {
 545           /* Read more for multibyte character */
 546           RL_SETSTATE (RL_STATE_MOREINPUT);
 547           c = rl_read_key ();
 548           RL_UNSETSTATE (RL_STATE_MOREINPUT);
 549         }
 550       else
 551         break;
 552     }
 553   return c;
 554 }
 555 #endif /* HANDLE_MULTIBYTE */