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