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