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