1 This file is read.def, from which is created read.c.
2 It implements the builtin "read" in Bash.
4 Copyright (C) 1987-2012 Free Software Foundation, Inc.
6 This file is part of GNU Bash, the Bourne Again SHell.
8 Bash 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.
13 Bash 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.
18 You should have received a copy of the GNU General Public License
19 along with Bash. If not, see <http://www.gnu.org/licenses/>.
24 $FUNCTION read_builtin
25 $SHORT_DOC read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...]
26 Read a line from the standard input and split it into fields.
28 Reads a single line from the standard input, or from file descriptor FD
29 if the -u option is supplied. The line is split into fields as with word
30 splitting, and the first word is assigned to the first NAME, the second
31 word to the second NAME, and so on, with any leftover words assigned to
32 the last NAME. Only the characters found in $IFS are recognized as word
35 If no NAMEs are supplied, the line read is stored in the REPLY variable.
38 -a array assign the words read to sequential indices of the array
39 variable ARRAY, starting at zero
40 -d delim continue until the first character of DELIM is read, rather
42 -e use Readline to obtain the line in an interactive shell
43 -i text use TEXT as the initial text for Readline
44 -n nchars return after reading NCHARS characters rather than waiting
45 for a newline, but honor a delimiter if fewer than
46 NCHARS characters are read before the delimiter
47 -N nchars return only after reading exactly NCHARS characters, unless
48 EOF is encountered or read times out, ignoring any
50 -p prompt output the string PROMPT without a trailing newline before
52 -r do not allow backslashes to escape any characters
53 -s do not echo input coming from a terminal
54 -t timeout time out and return failure if a complete line of
55 input is not read within TIMEOUT seconds. The value of the
56 TMOUT variable is the default timeout. TIMEOUT may be a
57 fractional number. If TIMEOUT is 0, read returns
58 immediately, without trying to read any data, returning
59 success only if input is available on the specified
60 file descriptor. The exit status is greater than 128
61 if the timeout is exceeded
62 -u fd read from file descriptor FD instead of the standard input
65 The return code is zero, unless end-of-file is encountered, read times out
66 (in which case it's greater than 128), a variable assignment error occurs,
67 or an invalid file descriptor is supplied as the argument to -u.
72 #include "bashtypes.h"
73 #include "posixstat.h"
79 #if defined (HAVE_UNISTD_H)
91 #include "../bashintl.h"
95 #include "bashgetopt.h"
99 #if defined (READLINE)
100 #include "../bashline.h"
101 #include <readline/readline.h>
104 #if defined (BUFFERED_INPUT)
108 #include "shmbutil.h"
114 extern void run_pending_traps __P((void));
116 extern int posixly_correct;
117 extern int trapped_signal_received;
125 #if defined (READLINE)
126 static void reset_attempted_completion_function __P((char *));
127 static int set_itext __P((void));
128 static char *edit_line __P((char *, char *));
129 static void set_eol_delim __P((int));
130 static void reset_eol_delim __P((char *));
132 static SHELL_VAR *bind_read_variable __P((char *, char *));
133 #if defined (HANDLE_MULTIBYTE)
134 static int read_mbchar __P((int, char *, int, int, int));
136 static void ttyrestore __P((struct ttsave *));
138 static sighandler sigalrm __P((int));
139 static void reset_alarm __P((void));
141 /* Try this to see what the rest of the shell can do with the information. */
145 static int reading, tty_modified;
146 static SigHandler *old_alrm;
147 static unsigned char delim;
149 static struct ttsave termsave;
151 /* In all cases, SIGALRM just sets a flag that we check periodically. This
152 avoids problems with the semi-tricky stuff we do with the xfree of
153 input_string at the top of the unwind-protect list (see below). */
155 /* Set a flag that CHECK_ALRM can check. This relies on zread calling
156 trap.c:check_signals_and_traps(), which knows about sigalrm_seen and
168 /* Cancel alarm before restoring signal handler. */
170 set_signal_handler (SIGALRM, old_alrm);
173 /* Read the value of the shell variables whose names follow.
174 The reading is done from the current input stream, whatever
175 that may be. Successive words of the input line are assigned
176 to the variables mentioned in LIST. The last variable in LIST
177 gets the remainder of the words on the line. If no variables
178 are mentioned in LIST, then the default variable is $REPLY. */
183 register char *varname;
184 int size, i, nr, pass_next, saw_escape, eof, opt, retval, code, print_ps2;
185 int input_is_tty, input_is_pipe, unbuffered_read, skip_ctlesc, skip_ctlnul;
186 int raw, edit, nchars, silent, have_timeout, ignore_delim, fd, lastsig, t_errno;
187 unsigned int tmsec, tmusec;
191 char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname;
192 char *e, *t, *t1, *ps2, *tofree;
195 TTYSTRUCT ttattrs, ttset;
196 #if defined (ARRAY_VARS)
199 #if defined (READLINE)
209 USE_VAR(input_is_pipe);
219 #if defined (READLINE)
228 sigalrm_seen = reading = tty_modified = 0;
230 i = 0; /* Index into the string that we are reading. */
231 raw = edit = 0; /* Not reading raw input by default. */
233 arrayname = prompt = (char *)NULL;
234 fd = 0; /* file descriptor to read from */
236 #if defined (READLINE)
237 rlbuf = itext = (char *)0;
241 tmsec = tmusec = 0; /* no timeout */
242 nr = nchars = input_is_tty = input_is_pipe = unbuffered_read = have_timeout = 0;
243 delim = '\n'; /* read until newline */
246 reset_internal_getopt ();
247 while ((opt = internal_getopt (list, "ersa:d:i:n:p:t:u:N:")) != -1)
255 prompt = list_optarg;
261 #if defined (READLINE)
266 #if defined (READLINE)
270 #if defined (ARRAY_VARS)
272 arrayname = list_optarg;
276 code = uconvert (list_optarg, &ival, &uval);
277 if (code == 0 || ival < 0 || uval < 0)
279 builtin_error (_("%s: invalid timeout specification"), list_optarg);
280 return (EXECUTION_FAILURE);
293 code = legal_number (list_optarg, &intval);
294 if (code == 0 || intval < 0 || intval != (int)intval)
296 sh_invalidnum (list_optarg);
297 return (EXECUTION_FAILURE);
303 code = legal_number (list_optarg, &intval);
304 if (code == 0 || intval < 0 || intval != (int)intval)
306 builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
307 return (EXECUTION_FAILURE);
311 if (sh_validfd (fd) == 0)
313 builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
314 return (EXECUTION_FAILURE);
318 delim = *list_optarg;
327 /* `read -t 0 var' tests whether input is available with select/FIONREAD,
328 and fails if those are unavailable */
329 if (have_timeout && tmsec == 0 && tmusec == 0)
331 return (EXECUTION_FAILURE);
333 return (input_avail (fd) ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
336 /* Convenience: check early whether or not the first of possibly several
337 variable names is a valid identifier, and bail early if so. */
338 #if defined (ARRAY_VARS)
339 if (list && legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, 0) == 0)
341 if (list && legal_identifier (list->word->word) == 0)
344 sh_invalidid (list->word->word);
345 return (EXECUTION_FAILURE);
348 /* If we're asked to ignore the delimiter, make sure we do. */
352 /* IF IFS is unset, we use the default of " \t\n". */
353 ifs_chars = getifs ();
354 if (ifs_chars == 0) /* XXX - shouldn't happen */
356 /* If we want to read exactly NCHARS chars, don't split on IFS */
359 for (skip_ctlesc = skip_ctlnul = 0, e = ifs_chars; *e; e++)
360 skip_ctlesc |= *e == CTLESC, skip_ctlnul |= *e == CTLNUL;
362 input_string = (char *)xmalloc (size = 112); /* XXX was 128 */
363 input_string[0] = '\0';
365 /* $TMOUT, if set, is the default timeout for read. */
366 if (have_timeout == 0 && (e = get_string_value ("TMOUT")))
368 code = uconvert (e, &ival, &uval);
369 if (code == 0 || ival < 0 || uval < 0)
378 begin_unwind_frame ("read_builtin");
380 #if defined (BUFFERED_INPUT)
381 if (interactive == 0 && default_buffered_input >= 0 && fd_is_bash_input (fd))
382 sync_buffered_stream (default_buffered_input);
385 input_is_tty = isatty (fd);
386 if (input_is_tty == 0)
388 input_is_pipe = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
393 /* If the -p, -e or -s flags were given, but input is not coming from the
394 terminal, turn them off. */
395 if ((prompt || edit || silent) && input_is_tty == 0)
397 prompt = (char *)NULL;
398 #if defined (READLINE)
399 itext = (char *)NULL;
404 #if defined (READLINE)
406 add_unwind_protect (xfree, rlbuf);
409 pass_next = 0; /* Non-zero signifies last char was backslash. */
410 saw_escape = 0; /* Non-zero signifies that we saw an escape char */
412 if (tmsec > 0 || tmusec > 0)
414 /* Turn off the timeout if stdin is a regular file (e.g. from
415 input redirection). */
416 if ((fstat (fd, &tsb) < 0) || S_ISREG (tsb.st_mode))
420 if (tmsec > 0 || tmusec > 0)
422 code = setjmp_nosigs (alrmbuf);
426 /* Tricky. The top of the unwind-protect stack is the free of
427 input_string. We want to run all the rest and use input_string,
428 so we have to save input_string temporarily, run the unwind-
429 protects, then restore input_string so we can use it later */
430 orig_input_string = 0;
431 input_string[i] = '\0'; /* make sure it's terminated */
434 t = (char *)xmalloc (1);
438 t = savestring (input_string);
440 run_unwind_frame ("read_builtin");
442 retval = 128+SIGALRM;
445 if (interactive_shell == 0)
446 initialize_terminating_signals ();
447 old_alrm = set_signal_handler (SIGALRM, sigalrm);
448 add_unwind_protect (reset_alarm, (char *)NULL);
449 #if defined (READLINE)
452 add_unwind_protect (reset_attempted_completion_function, (char *)NULL);
453 add_unwind_protect (bashline_reset_event_hook, (char *)NULL);
456 falarm (tmsec, tmusec);
459 /* If we've been asked to read only NCHARS chars, or we're using some
460 character other than newline to terminate the line, do the right
461 thing to readline or the tty. */
462 if (nchars > 0 || delim != '\n')
464 #if defined (READLINE)
469 unwind_protect_int (rl_num_chars_to_read);
470 rl_num_chars_to_read = nchars;
474 set_eol_delim (delim);
475 add_unwind_protect (reset_eol_delim, (char *)NULL);
484 ttgetattr (fd, &ttattrs);
485 termsave.attrs = &ttattrs;
488 i = silent ? ttfd_cbreak (fd, &ttset) : ttfd_onechar (fd, &ttset);
492 add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
493 if (interactive_shell == 0)
494 initialize_terminating_signals ();
497 else if (silent) /* turn off echo but leave term in canonical mode */
501 ttgetattr (fd, &ttattrs);
502 termsave.attrs = &ttattrs;
505 i = ttfd_noecho (fd, &ttset); /* ttnoecho (); */
510 add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
511 if (interactive_shell == 0)
512 initialize_terminating_signals ();
515 /* This *must* be the top unwind-protect on the stack, so the manipulation
516 of the unwind-protect stack after the realloc() works right. */
517 add_unwind_protect (xfree, input_string);
520 if ((nchars > 0) && (input_is_tty == 0) && ignore_delim) /* read -N */
522 else if ((nchars > 0) || (delim != '\n') || input_is_pipe)
525 if (prompt && edit == 0)
527 fprintf (stderr, "%s", prompt);
531 #if defined (__CYGWIN__) && defined (O_TEXT)
536 for (print_ps2 = eof = retval = 0;;)
540 #if defined (READLINE)
543 if (rlbuf && rlbuf[rlind] == '\0')
551 rlbuf = edit_line (prompt ? prompt : "", itext);
569 ps2 = get_string_value ("PS2");
570 fprintf (stderr, "%s", ps2 ? ps2 : "");
576 if (posixly_correct == 0)
577 interrupt_immediately++;
580 if (unbuffered_read == 2)
581 retval = posixly_correct ? zreadintr (fd, &c, 1) : zreadn (fd, &c, nchars - nr);
582 else if (unbuffered_read)
583 retval = posixly_correct ? zreadintr (fd, &c, 1) : zread (fd, &c, 1);
585 retval = posixly_correct ? zreadcintr (fd, &c) : zreadc (fd, &c);
588 if (posixly_correct == 0)
589 interrupt_immediately--;
594 if (retval < 0 && errno == EINTR)
598 lastsig = trapped_signal_received;
599 run_pending_traps (); /* because interrupt_immediately is not set */
603 if (terminating_signal && tty_modified)
604 ttyrestore (&termsave); /* fix terminal before exiting */
612 #if defined (READLINE)
617 if (i + 4 >= size) /* XXX was i + 2; use i + 4 for multibyte/read_mbchar */
620 t = (char *)xrealloc (input_string, size += 128);
622 /* Only need to change unwind-protect if input_string changes */
623 if (t != input_string)
626 remove_unwind_protect ();
627 add_unwind_protect (xfree, input_string);
631 /* If the next character is to be accepted verbatim, a backslash
632 newline pair still disappears from the input. */
638 i--; /* back up over the CTLESC */
639 if (interactive && input_is_tty && raw == 0)
647 /* This may cause problems if IFS contains CTLESC */
648 if (c == '\\' && raw == 0)
651 if (skip_ctlesc == 0)
654 input_string[i++] = CTLESC;
659 if (ignore_delim == 0 && (unsigned char)c == delim)
662 if (c == '\0' && delim != '\0')
663 continue; /* skip NUL bytes in input */
665 if ((skip_ctlesc == 0 && c == CTLESC) || (skip_ctlnul == 0 && c == CTLNUL))
668 input_string[i++] = CTLESC;
672 input_string[i++] = c;
675 #if defined (HANDLE_MULTIBYTE)
676 if (nchars > 0 && MB_CUR_MAX > 1 && is_basic (c) == 0)
678 input_string[i] = '\0'; /* for simplicity and debugging */
679 i += read_mbchar (fd, input_string, i, c, unbuffered_read);
685 if (nchars > 0 && nr >= nchars)
688 input_string[i] = '\0';
695 builtin_error (_("read error: %d: %s"), fd, strerror (errno));
696 run_unwind_frame ("read_builtin");
697 return ((t_errno != EINTR) ? EXECUTION_FAILURE : 128+lastsig);
700 if (tmsec > 0 || tmusec > 0)
703 if (nchars > 0 || delim != '\n')
705 #if defined (READLINE)
709 rl_num_chars_to_read = 0;
711 reset_eol_delim ((char *)NULL);
716 ttyrestore (&termsave);
719 ttyrestore (&termsave);
721 if (unbuffered_read == 0)
724 discard_unwind_frame ("read_builtin");
726 retval = eof ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
730 #if defined (ARRAY_VARS)
731 /* If -a was given, take the string read, break it into a list of words,
732 an assign them to `arrayname' in turn. */
735 if (legal_identifier (arrayname) == 0)
737 sh_invalidid (arrayname);
738 xfree (input_string);
739 return (EXECUTION_FAILURE);
742 var = find_or_make_array_variable (arrayname, 1);
745 xfree (input_string);
746 return EXECUTION_FAILURE; /* readonly or noassign */
750 builtin_error (_("%s: cannot convert associative to indexed array"), arrayname);
751 xfree (input_string);
752 return EXECUTION_FAILURE; /* existing associative array */
754 else if (invisible_p (var))
755 VUNSETATTR (var, att_invisible);
756 array_flush (array_cell (var));
758 alist = list_string (input_string, ifs_chars, 0);
762 dequote_list (alist);
764 word_list_remove_quoted_nulls (alist);
765 assign_array_var_from_word_list (var, alist, 0);
766 dispose_words (alist);
768 xfree (input_string);
771 #endif /* ARRAY_VARS */
773 /* If there are no variables, save the text of the line read to the
774 variable $REPLY. ksh93 strips leading and trailing IFS whitespace,
775 so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the
776 same way, but I believe that the difference in behaviors is useful
777 enough to not do it. Without the bash behavior, there is no way
778 to read a line completely without interpretation or modification
779 unless you mess with $IFS (e.g., setting it to the empty string).
780 If you disagree, change the occurrences of `#if 0' to `#if 1' below. */
784 orig_input_string = input_string;
785 for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
788 input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
793 t = dequote_string (input_string);
794 var = bind_variable ("REPLY", t, 0);
798 var = bind_variable ("REPLY", input_string, 0);
799 VUNSETATTR (var, att_invisible);
800 if (readonly_p (var) || noassign_p (var))
801 retval = EXECUTION_FAILURE;
803 xfree (input_string);
807 /* This code implements the Posix.2 spec for splitting the words
808 read and assigning them to variables. */
809 orig_input_string = input_string;
811 /* Remove IFS white space at the beginning of the input string. If
812 $IFS is null, no field splitting is performed. */
813 for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
816 for (; list->next; list = list->next)
818 varname = list->word->word;
819 #if defined (ARRAY_VARS)
820 if (legal_identifier (varname) == 0 && valid_array_reference (varname, 0) == 0)
822 if (legal_identifier (varname) == 0)
825 sh_invalidid (varname);
826 xfree (orig_input_string);
827 return (EXECUTION_FAILURE);
830 /* If there are more variables than words read from the input,
831 the remaining variables are set to the empty string. */
834 /* This call updates INPUT_STRING. */
835 t = get_word_from_string (&input_string, ifs_chars, &e);
838 /* Don't bother to remove the CTLESC unless we added one
839 somewhere while reading the string. */
842 t1 = dequote_string (t);
843 var = bind_read_variable (varname, t1);
847 var = bind_read_variable (varname, t ? t : "");
852 var = bind_read_variable (varname, "");
858 xfree (orig_input_string);
859 return (EXECUTION_FAILURE);
862 stupidly_hack_special_variables (varname);
863 VUNSETATTR (var, att_invisible);
866 /* Now assign the rest of the line to the last variable argument. */
867 #if defined (ARRAY_VARS)
868 if (legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word, 0) == 0)
870 if (legal_identifier (list->word->word) == 0)
873 sh_invalidid (list->word->word);
874 xfree (orig_input_string);
875 return (EXECUTION_FAILURE);
879 /* This has to be done this way rather than using string_list
880 and list_string because Posix.2 says that the last variable gets the
881 remaining words and their intervening separators. */
882 input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
884 /* Check whether or not the number of fields is exactly the same as the
885 number of variables. */
890 t = get_word_from_string (&input_string, ifs_chars, &e);
891 if (*input_string == 0)
892 tofree = input_string = t;
895 input_string = strip_trailing_ifs_whitespace (t1, ifs_chars, saw_escape);
901 if (saw_escape && input_string && *input_string)
903 t = dequote_string (input_string);
904 var = bind_read_variable (list->word->word, t);
908 var = bind_read_variable (list->word->word, input_string ? input_string : "");
912 stupidly_hack_special_variables (list->word->word);
913 VUNSETATTR (var, att_invisible);
916 retval = EXECUTION_FAILURE;
919 xfree (orig_input_string);
925 bind_read_variable (name, value)
930 #if defined (ARRAY_VARS)
931 if (valid_array_reference (name, 0) == 0)
932 v = bind_variable (name, value, 0);
934 v = assign_array_element (name, value, 0);
935 #else /* !ARRAY_VARS */
936 v = bind_variable (name, value, 0);
937 #endif /* !ARRAY_VARS */
939 : ((readonly_p (v) || noassign_p (v)) ? (SHELL_VAR *)NULL : v));
942 #if defined (HANDLE_MULTIBYTE)
944 read_mbchar (fd, string, ind, ch, unbuffered)
947 int ind, ch, unbuffered;
949 char mbchar[MB_LEN_MAX + 1];
953 mbstate_t ps, ps_back;
956 memset (&ps, '\0', sizeof (mbstate_t));
957 memset (&ps_back, '\0', sizeof (mbstate_t));
961 for (n = 0; n <= MB_LEN_MAX; n++)
964 ret = mbrtowc (&wc, mbchar, i, &ps);
965 if (ret == (size_t)-2)
968 /* We don't want to be interrupted during a multibyte char read */
970 r = zread (fd, &c, 1);
978 else if (ret == (size_t)-1 || ret == (size_t)0 || ret > (size_t)0)
983 if (i > 1) /* read a multibyte char */
984 /* mbchar[0] is already string[ind-1] */
985 for (r = 1; r < i; r++)
986 string[ind+r-1] = mbchar[r];
996 ttsetattr (ttp->fd, ttp->attrs);
1004 ttyrestore (&termsave);
1008 read_tty_modified ()
1010 return (tty_modified);
1013 #if defined (READLINE)
1014 static rl_completion_func_t *old_attempted_completion_function = 0;
1015 static rl_hook_func_t *old_startup_hook;
1016 static char *deftext;
1019 reset_attempted_completion_function (cp)
1022 if (rl_attempted_completion_function == 0 && old_attempted_completion_function)
1023 rl_attempted_completion_function = old_attempted_completion_function;
1032 if (old_startup_hook)
1033 r1 = (*old_startup_hook) ();
1036 r2 = rl_insert_text (deftext);
1037 deftext = (char *)NULL;
1038 rl_startup_hook = old_startup_hook;
1039 old_startup_hook = (rl_hook_func_t *)NULL;
1045 edit_line (p, itext)
1052 if (bash_readline_initialized == 0)
1053 initialize_readline ();
1055 old_attempted_completion_function = rl_attempted_completion_function;
1056 rl_attempted_completion_function = (rl_completion_func_t *)NULL;
1057 bashline_set_event_hook ();
1060 old_startup_hook = rl_startup_hook;
1061 rl_startup_hook = set_itext;
1067 rl_attempted_completion_function = old_attempted_completion_function;
1068 old_attempted_completion_function = (rl_completion_func_t *)NULL;
1069 bashline_reset_event_hook ();
1074 ret = (char *)xrealloc (ret, len + 2);
1080 static int old_delim_ctype;
1081 static rl_command_func_t *old_delim_func;
1082 static int old_newline_ctype;
1083 static rl_command_func_t *old_newline_func;
1085 static unsigned char delim_char;
1093 if (bash_readline_initialized == 0)
1094 initialize_readline ();
1095 cmap = rl_get_keymap ();
1097 /* Change newline to self-insert */
1098 old_newline_ctype = cmap[RETURN].type;
1099 old_newline_func = cmap[RETURN].function;
1100 cmap[RETURN].type = ISFUNC;
1101 cmap[RETURN].function = rl_insert;
1103 /* Bind the delimiter character to accept-line. */
1104 old_delim_ctype = cmap[c].type;
1105 old_delim_func = cmap[c].function;
1106 cmap[c].type = ISFUNC;
1107 cmap[c].function = rl_newline;
1113 reset_eol_delim (cp)
1118 cmap = rl_get_keymap ();
1120 cmap[RETURN].type = old_newline_ctype;
1121 cmap[RETURN].function = old_newline_func;
1123 cmap[delim_char].type = old_delim_ctype;
1124 cmap[delim_char].function = old_delim_func;