readline/input.c

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