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