readline/input.c

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