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    675 Mass Ave, Cambridge, MA 02139, USA. */
  22 #define READLINE_LIBRARY
  23
  24 #if defined (HAVE_CONFIG_H)
  25 #  include <config.h>
  26 #endif
  27
  28 #include <sys/types.h>
  29 #include <fcntl.h>
  30 #if defined (HAVE_SYS_FILE_H)
  31 #  include <sys/file.h>
  32 #endif /* HAVE_SYS_FILE_H */
  33
  34 #if defined (HAVE_UNISTD_H)
  35 #  include <unistd.h>
  36 #endif /* HAVE_UNISTD_H */
  37
  38 #if defined (HAVE_STDLIB_H)
  39 #  include <stdlib.h>
  40 #else
  41 #  include "ansi_stdlib.h"
  42 #endif /* HAVE_STDLIB_H */
  43
  44 #if defined (HAVE_SELECT)
  45 #  if !defined (HAVE_SYS_SELECT_H) || !defined (M_UNIX)
  46 #    include <sys/time.h>
  47 #  endif
  48 #endif /* HAVE_SELECT */
  49 #if defined (HAVE_SYS_SELECT_H)
  50 #  include <sys/select.h>
  51 #endif
  52
  53 #if defined (FIONREAD_IN_SYS_IOCTL)
  54 #  include <sys/ioctl.h>
  55 #endif
  56
  57 #include <stdio.h>
  58 #include <errno.h>
  59
  60 #if !defined (errno)
  61 extern int errno;
  62 #endif /* !errno */
  63
  64 /* System-specific feature definitions and include files. */
  65 #include "rldefs.h"
  66
  67 /* Some standard library routines. */
  68 #include "readline.h"
  69
  70 /* What kind of non-blocking I/O do we have? */
  71 #if !defined (O_NDELAY) && defined (O_NONBLOCK)
  72 #  define O_NDELAY O_NONBLOCK   /* Posix style */
  73 #endif
  74
  75 /* Functions imported from other files in the library. */
  76 extern char *xmalloc (), *xrealloc ();
  77
  78 /* Variables and functions from macro.c. */
  79 extern void _rl_add_macro_char ();
  80 extern void _rl_with_macro_input ();
  81 extern int _rl_next_macro_key ();
  82 extern int _rl_defining_kbd_macro;
  83
  84 #if defined (VI_MODE)
  85 extern void _rl_vi_set_last ();
  86 extern int _rl_vi_textmod_command ();
  87 #endif /* VI_MODE */
  88
  89 extern FILE *rl_instream, *rl_outstream;
  90 extern Function *rl_last_func;
  91 extern int rl_key_sequence_length;
  92 extern int rl_pending_input;
  93 extern int rl_editing_mode;
  94
  95 extern Keymap _rl_keymap;
  96
  97 extern int _rl_convert_meta_chars_to_ascii;
  98
  99 #if defined (__GO32__)
 100 #  include <pc.h>
 101 #endif /* __GO32__ */
 102
 103 /* Non-null means it is a pointer to a function to run while waiting for
 104    character input. */
 105 Function *rl_event_hook = (Function *)NULL;
 106
 107 Function *rl_getc_function = rl_getc;
 108
 109 /* **************************************************************** */
 110 /*                                                                  */
 111 /*                      Character Input Buffering                   */
 112 /*                                                                  */
 113 /* **************************************************************** */
 114
 115 static int pop_index, push_index;
 116 static unsigned char ibuffer[512];
 117 static int ibuffer_len = sizeof (ibuffer) - 1;
 118
 119 #define any_typein (push_index != pop_index)
 120
 121 int
 122 _rl_any_typein ()
 123 {
 124   return any_typein;
 125 }
 126
 127 /* Return the amount of space available in the buffer for stuffing
 128    characters. */
 129 static int
 130 ibuffer_space ()
 131 {
 132   if (pop_index > push_index)
 133     return (pop_index - push_index - 1);
 134   else
 135     return (ibuffer_len - (push_index - pop_index));
 136 }
 137
 138 /* Get a key from the buffer of characters to be read.
 139    Return the key in KEY.
 140    Result is KEY if there was a key, or 0 if there wasn't. */
 141 static int
 142 rl_get_char (key)
 143      int *key;
 144 {
 145   if (push_index == pop_index)
 146     return (0);
 147
 148   *key = ibuffer[pop_index++];
 149
 150   if (pop_index >= ibuffer_len)
 151     pop_index = 0;
 152
 153   return (1);
 154 }
 155
 156 /* Stuff KEY into the *front* of the input buffer.
 157    Returns non-zero if successful, zero if there is
 158    no space left in the buffer. */
 159 static int
 160 rl_unget_char (key)
 161      int key;
 162 {
 163   if (ibuffer_space ())
 164     {
 165       pop_index--;
 166       if (pop_index < 0)
 167         pop_index = ibuffer_len - 1;
 168       ibuffer[pop_index] = key;
 169       return (1);
 170     }
 171   return (0);
 172 }
 173
 174 /* If a character is available to be read, then read it
 175    and stuff it into IBUFFER.  Otherwise, just return. */
 176 static void
 177 rl_gather_tyi ()
 178 {
 179 #if defined (__GO32__)
 180   char input;
 181
 182   if (isatty (0) && kbhit () && ibuffer_space ())
 183     {
 184       int i;
 185       i = (*rl_getc_function) (rl_instream);
 186       rl_stuff_char (i);
 187     }
 188 #else /* !__GO32__ */
 189
 190   int tty;
 191   register int tem, result;
 192   int chars_avail;
 193   char input;
 194 #if defined(HAVE_SELECT)
 195   fd_set readfds, exceptfds;
 196   struct timeval timeout;
 197 #endif
 198
 199   tty = fileno (rl_instream);
 200
 201 #if defined (HAVE_SELECT)
 202   FD_ZERO (&readfds);
 203   FD_ZERO (&exceptfds);
 204   FD_SET (tty, &readfds);
 205   FD_SET (tty, &exceptfds);
 206   timeout.tv_sec = 0;
 207   timeout.tv_usec = 100000;     /* 0.1 seconds */
 208   if (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) <= 0)
 209     return;     /* Nothing to read. */
 210 #endif
 211
 212   result = -1;
 213 #if defined (FIONREAD)
 214   result = ioctl (tty, FIONREAD, &chars_avail);
 215 #endif
 216
 217 #if defined (O_NDELAY)
 218   if (result == -1)
 219     {
 220       tem = fcntl (tty, F_GETFL, 0);
 221
 222       fcntl (tty, F_SETFL, (tem | O_NDELAY));
 223       chars_avail = read (tty, &input, 1);
 224
 225       fcntl (tty, F_SETFL, tem);
 226       if (chars_avail == -1 && errno == EAGAIN)
 227         return;
 228     }
 229 #endif /* O_NDELAY */
 230
 231   /* If there's nothing available, don't waste time trying to read
 232      something. */
 233   if (chars_avail <= 0)
 234     return;
 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         rl_stuff_char ((*rl_getc_function) (rl_instream));
 252     }
 253   else
 254     {
 255       if (chars_avail)
 256         rl_stuff_char (input);
 257     }
 258 #endif /* !__GO32__ */
 259 }
 260
 261 /* Is there input available to be read on the readline input file
 262    descriptor?  Only works if the system has select(2) or FIONREAD. */
 263 int
 264 _rl_input_available ()
 265 {
 266 #if defined(HAVE_SELECT)
 267   fd_set readfds, exceptfds;
 268   struct timeval timeout;
 269 #endif
 270 #if defined(FIONREAD)
 271   int chars_avail;
 272 #endif
 273   int tty;
 274
 275   tty = fileno (rl_instream);
 276
 277 #if defined (HAVE_SELECT)
 278   FD_ZERO (&readfds);
 279   FD_ZERO (&exceptfds);
 280   FD_SET (tty, &readfds);
 281   FD_SET (tty, &exceptfds);
 282   timeout.tv_sec = 0;
 283   timeout.tv_usec = 100000;     /* 0.1 seconds */
 284   return (select (tty + 1, &readfds, (fd_set *)NULL, &exceptfds, &timeout) > 0);
 285 #endif
 286
 287 #if defined (FIONREAD)
 288   if (ioctl (tty, FIONREAD, &chars_avail) == 0)
 289     return (chars_avail);
 290 #endif
 291
 292   return 0;
 293 }
 294
 295 void
 296 _rl_insert_typein (c)
 297      int c;
 298 {
 299   int key, t, i;
 300   char *string;
 301
 302   i = key = 0;
 303   string = xmalloc (ibuffer_len + 1);
 304   string[i++] = (char) c;
 305
 306   while ((t = rl_get_char (&key)) &&
 307          _rl_keymap[key].type == ISFUNC &&
 308          _rl_keymap[key].function == rl_insert)
 309     string[i++] = key;
 310
 311   if (t)
 312     rl_unget_char (key);
 313
 314   string[i] = '\0';
 315   rl_insert_text (string);
 316   free (string);
 317 }
 318
 319 /* Add KEY to the buffer of characters to be read.  Returns 1 if the
 320    character was stuffed correctly; 0 otherwise. */
 321 int
 322 rl_stuff_char (key)
 323      int key;
 324 {
 325   if (ibuffer_space () == 0)
 326     return 0;
 327
 328   if (key == EOF)
 329     {
 330       key = NEWLINE;
 331       rl_pending_input = EOF;
 332     }
 333   ibuffer[push_index++] = key;
 334   if (push_index >= ibuffer_len)
 335     push_index = 0;
 336
 337   return 1;
 338 }
 339
 340 /* Make C be the next command to be executed. */
 341 int
 342 rl_execute_next (c)
 343      int c;
 344 {
 345   rl_pending_input = c;
 346   return 0;
 347 }
 348
 349 /* **************************************************************** */
 350 /*                                                                  */
 351 /*                           Character Input                        */
 352 /*                                                                  */
 353 /* **************************************************************** */
 354
 355 /* Read a key, including pending input. */
 356 int
 357 rl_read_key ()
 358 {
 359   int c;
 360
 361   rl_key_sequence_length++;
 362
 363   if (rl_pending_input)
 364     {
 365       c = rl_pending_input;
 366       rl_pending_input = 0;
 367     }
 368   else
 369     {
 370       /* If input is coming from a macro, then use that. */
 371       if (c = _rl_next_macro_key ())
 372         return (c);
 373
 374       /* If the user has an event function, then call it periodically. */
 375       if (rl_event_hook)
 376         {
 377           while (rl_event_hook && rl_get_char (&c) == 0)
 378             {
 379               (*rl_event_hook) ();
 380               rl_gather_tyi ();
 381             }
 382         }
 383       else
 384         {
 385           if (rl_get_char (&c) == 0)
 386             c = (*rl_getc_function) (rl_instream);
 387         }
 388     }
 389
 390   return (c);
 391 }
 392
 393 int
 394 rl_getc (stream)
 395      FILE *stream;
 396 {
 397   int result, flags;
 398   unsigned char c;
 399
 400 #if defined (__GO32__)
 401   if (isatty (0))
 402     return (getkey () & 0x7F);
 403 #endif /* __GO32__ */
 404
 405   while (1)
 406     {
 407       result = read (fileno (stream), &c, sizeof (unsigned char));
 408
 409       if (result == sizeof (unsigned char))
 410         return (c);
 411
 412       /* If zero characters are returned, then the file that we are
 413          reading from is empty!  Return EOF in that case. */
 414       if (result == 0)
 415         return (EOF);
 416
 417 #if defined (__BEOS__)
 418       if (errno == EINTR)
 419         continue;
 420 #endif
 421
 422 #if defined (EWOULDBLOCK)
 423       if (errno == EWOULDBLOCK)
 424         {
 425           if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0)
 426             return (EOF);
 427           if (flags & O_NDELAY)
 428             {
 429               flags &= ~O_NDELAY;
 430               fcntl (fileno (stream), F_SETFL, flags);
 431               continue;
 432             }
 433           continue;
 434         }
 435 #endif /* EWOULDBLOCK */
 436
 437 #if defined (_POSIX_VERSION) && defined (EAGAIN) && defined (O_NONBLOCK)
 438       if (errno == EAGAIN)
 439         {
 440           if ((flags = fcntl (fileno (stream), F_GETFL, 0)) < 0)
 441             return (EOF);
 442           if (flags & O_NONBLOCK)
 443             {
 444               flags &= ~O_NONBLOCK;
 445               fcntl (fileno (stream), F_SETFL, flags);
 446               continue;
 447             }
 448         }
 449 #endif /* _POSIX_VERSION && EAGAIN && O_NONBLOCK */
 450
 451 #if !defined (__GO32__)
 452       /* If the error that we received was SIGINT, then try again,
 453          this is simply an interrupted system call to read ().
 454          Otherwise, some error ocurred, also signifying EOF. */
 455       if (errno != EINTR)
 456         return (EOF);
 457 #endif /* !__GO32__ */
 458     }
 459 }