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