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 NCHARS
46
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 delimiter
49
-p prompt output the string PROMPT without a trailing newline before
51
-r do not allow backslashes to escape any characters
52
-s do not echo input coming from a terminal
53
-t timeout time out and return failure if a complete line of input is
54
not read within TIMEOUT seconds. The value of the TMOUT
55
variable is the default timeout. TIMEOUT may be a
56
fractional number. If TIMEOUT is 0, read returns immediately,
57
without trying to read any data, returning success only if
58
input is available on the specified file descriptor. The
59
exit status is greater than 128 if the timeout is exceeded
60
-u fd read from file descriptor FD instead of the standard input
63
The return code is zero, unless end-of-file is encountered, read times out
64
(in which case it's greater than 128), a variable assignment error occurs,
65
or an invalid file descriptor is supplied as the argument to -u.
70
#include "bashtypes.h"
71
#include "posixstat.h"
77
#if defined (HAVE_UNISTD_H)
89
#include "../bashintl.h"
93
#include "bashgetopt.h"
97
#if defined (READLINE)
98
#include "../bashline.h"
99
#include <readline/readline.h>
102
#if defined (BUFFERED_INPUT)
106
#include "shmbutil.h"
112
extern void run_pending_traps __P((void));
114
extern int posixly_correct;
115
extern int trapped_signal_received;
123
#if defined (READLINE)
124
static void reset_attempted_completion_function __P((char *));
125
static int set_itext __P((void));
126
static char *edit_line __P((char *, char *));
127
static void set_eol_delim __P((int));
128
static void reset_eol_delim __P((char *));
130
static SHELL_VAR *bind_read_variable __P((char *, char *));
131
#if defined (HANDLE_MULTIBYTE)
132
static int read_mbchar __P((int, char *, int, int, int));
134
static void ttyrestore __P((struct ttsave *));
136
static sighandler sigalrm __P((int));
137
static void reset_alarm __P((void));
139
/* Try this to see what the rest of the shell can do with the information. */
144
static SigHandler *old_alrm;
145
static unsigned char delim;
147
/* In all cases, SIGALRM just sets a flag that we check periodically. This
148
avoids problems with the semi-tricky stuff we do with the xfree of
149
input_string at the top of the unwind-protect list (see below). */
151
/* Set a flag that CHECK_ALRM can check. This relies on zread calling
152
trap.c:check_signals_and_traps(), which knows about sigalrm_seen and
164
set_signal_handler (SIGALRM, old_alrm);
168
/* Read the value of the shell variables whose names follow.
169
The reading is done from the current input stream, whatever
170
that may be. Successive words of the input line are assigned
171
to the variables mentioned in LIST. The last variable in LIST
172
gets the remainder of the words on the line. If no variables
173
are mentioned in LIST, then the default variable is $REPLY. */
178
register char *varname;
179
int size, i, nr, pass_next, saw_escape, eof, opt, retval, code, print_ps2;
180
int input_is_tty, input_is_pipe, unbuffered_read, skip_ctlesc, skip_ctlnul;
181
int raw, edit, nchars, silent, have_timeout, ignore_delim, fd, lastsig, t_errno;
182
unsigned int tmsec, tmusec;
186
char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname;
187
char *e, *t, *t1, *ps2, *tofree;
190
TTYSTRUCT ttattrs, ttset;
191
struct ttsave termsave;
192
#if defined (ARRAY_VARS)
195
#if defined (READLINE)
205
USE_VAR(input_is_pipe);
215
#if defined (READLINE)
224
sigalrm_seen = reading = 0;
226
i = 0; /* Index into the string that we are reading. */
227
raw = edit = 0; /* Not reading raw input by default. */
229
arrayname = prompt = (char *)NULL;
230
fd = 0; /* file descriptor to read from */
232
#if defined (READLINE)
233
rlbuf = itext = (char *)0;
237
tmsec = tmusec = 0; /* no timeout */
238
nr = nchars = input_is_tty = input_is_pipe = unbuffered_read = have_timeout = 0;
239
delim = '\n'; /* read until newline */
242
reset_internal_getopt ();
243
while ((opt = internal_getopt (list, "ersa:d:i:n:p:t:u:N:")) != -1)
251
prompt = list_optarg;
257
#if defined (READLINE)
262
#if defined (READLINE)
266
#if defined (ARRAY_VARS)
268
arrayname = list_optarg;
272
code = uconvert (list_optarg, &ival, &uval);
273
if (code == 0 || ival < 0 || uval < 0)
275
builtin_error (_("%s: invalid timeout specification"), list_optarg);
276
return (EXECUTION_FAILURE);
289
code = legal_number (list_optarg, &intval);
290
if (code == 0 || intval < 0 || intval != (int)intval)
292
sh_invalidnum (list_optarg);
293
return (EXECUTION_FAILURE);
299
code = legal_number (list_optarg, &intval);
300
if (code == 0 || intval < 0 || intval != (int)intval)
302
builtin_error (_("%s: invalid file descriptor specification"), list_optarg);
303
return (EXECUTION_FAILURE);
307
if (sh_validfd (fd) == 0)
309
builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno));
310
return (EXECUTION_FAILURE);
314
delim = *list_optarg;
323
/* `read -t 0 var' tests whether input is available with select/FIONREAD,
324
and fails if those are unavailable */
325
if (have_timeout && tmsec == 0 && tmusec == 0)
327
return (EXECUTION_FAILURE);
329
return (input_avail (fd) ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
332
/* Convenience: check early whether or not the first of possibly several
333
variable names is a valid identifier, and bail early if so. */
334
#if defined (ARRAY_VARS)
335
if (list && legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word) == 0)
337
if (list && legal_identifier (list->word->word) == 0)
340
sh_invalidid (list->word->word);
341
return (EXECUTION_FAILURE);
344
/* If we're asked to ignore the delimiter, make sure we do. */
348
/* IF IFS is unset, we use the default of " \t\n". */
349
ifs_chars = getifs ();
350
if (ifs_chars == 0) /* XXX - shouldn't happen */
352
/* If we want to read exactly NCHARS chars, don't split on IFS */
355
for (skip_ctlesc = skip_ctlnul = 0, e = ifs_chars; *e; e++)
356
skip_ctlesc |= *e == CTLESC, skip_ctlnul |= *e == CTLNUL;
358
input_string = (char *)xmalloc (size = 112); /* XXX was 128 */
359
input_string[0] = '\0';
361
/* $TMOUT, if set, is the default timeout for read. */
362
if (have_timeout == 0 && (e = get_string_value ("TMOUT")))
364
code = uconvert (e, &ival, &uval);
365
if (code == 0 || ival < 0 || uval < 0)
374
begin_unwind_frame ("read_builtin");
376
#if defined (BUFFERED_INPUT)
377
if (interactive == 0 && default_buffered_input >= 0 && fd_is_bash_input (fd))
378
sync_buffered_stream (default_buffered_input);
381
input_is_tty = isatty (fd);
382
if (input_is_tty == 0)
384
input_is_pipe = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
389
/* If the -p, -e or -s flags were given, but input is not coming from the
390
terminal, turn them off. */
391
if ((prompt || edit || silent) && input_is_tty == 0)
393
prompt = (char *)NULL;
394
#if defined (READLINE)
395
itext = (char *)NULL;
400
#if defined (READLINE)
402
add_unwind_protect (xfree, rlbuf);
405
pass_next = 0; /* Non-zero signifies last char was backslash. */
406
saw_escape = 0; /* Non-zero signifies that we saw an escape char */
408
if (tmsec > 0 || tmusec > 0)
410
/* Turn off the timeout if stdin is a regular file (e.g. from
411
input redirection). */
412
if ((fstat (fd, &tsb) < 0) || S_ISREG (tsb.st_mode))
416
if (tmsec > 0 || tmusec > 0)
418
code = setjmp_nosigs (alrmbuf);
422
/* Tricky. The top of the unwind-protect stack is the free of
423
input_string. We want to run all the rest and use input_string,
424
so we have to save input_string temporarily, run the unwind-
425
protects, then restore input_string so we can use it later */
426
orig_input_string = 0;
427
input_string[i] = '\0'; /* make sure it's terminated */
430
t = (char *)xmalloc (1);
434
t = savestring (input_string);
436
run_unwind_frame ("read_builtin");
438
retval = 128+SIGALRM;
441
old_alrm = set_signal_handler (SIGALRM, sigalrm);
442
add_unwind_protect (reset_alarm, (char *)NULL);
443
#if defined (READLINE)
445
add_unwind_protect (reset_attempted_completion_function, (char *)NULL);
447
falarm (tmsec, tmusec);
450
/* If we've been asked to read only NCHARS chars, or we're using some
451
character other than newline to terminate the line, do the right
452
thing to readline or the tty. */
453
if (nchars > 0 || delim != '\n')
455
#if defined (READLINE)
460
unwind_protect_int (rl_num_chars_to_read);
461
rl_num_chars_to_read = nchars;
465
set_eol_delim (delim);
466
add_unwind_protect (reset_eol_delim, (char *)NULL);
475
ttgetattr (fd, &ttattrs);
476
termsave.attrs = &ttattrs;
479
i = silent ? ttfd_cbreak (fd, &ttset) : ttfd_onechar (fd, &ttset);
482
add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
485
else if (silent) /* turn off echo but leave term in canonical mode */
489
ttgetattr (fd, &ttattrs);
490
termsave.attrs = &ttattrs;
493
i = ttfd_noecho (fd, &ttset); /* ttnoecho (); */
497
add_unwind_protect ((Function *)ttyrestore, (char *)&termsave);
500
/* This *must* be the top unwind-protect on the stack, so the manipulation
501
of the unwind-protect stack after the realloc() works right. */
502
add_unwind_protect (xfree, input_string);
505
if ((nchars > 0) && (input_is_tty == 0) && ignore_delim) /* read -N */
507
else if ((nchars > 0) || (delim != '\n') || input_is_pipe)
510
if (prompt && edit == 0)
512
fprintf (stderr, "%s", prompt);
516
#if defined (__CYGWIN__) && defined (O_TEXT)
521
for (print_ps2 = eof = retval = 0;;)
525
#if defined (READLINE)
528
if (rlbuf && rlbuf[rlind] == '\0')
536
rlbuf = edit_line (prompt ? prompt : "", itext);
554
ps2 = get_string_value ("PS2");
555
fprintf (stderr, "%s", ps2 ? ps2 : "");
561
if (posixly_correct == 0)
562
interrupt_immediately++;
565
if (unbuffered_read == 2)
566
retval = posixly_correct ? zreadintr (fd, &c, 1) : zreadn (fd, &c, nchars - nr);
567
else if (unbuffered_read)
568
retval = posixly_correct ? zreadintr (fd, &c, 1) : zread (fd, &c, 1);
570
retval = posixly_correct ? zreadcintr (fd, &c) : zreadc (fd, &c);
573
if (posixly_correct == 0)
574
interrupt_immediately--;
579
if (retval < 0 && errno == EINTR)
583
lastsig = trapped_signal_received;
584
run_pending_traps (); /* because interrupt_immediately is not set */
595
#if defined (READLINE)
600
if (i + 4 >= size) /* XXX was i + 2; use i + 4 for multibyte/read_mbchar */
603
t = (char *)xrealloc (input_string, size += 128);
605
/* Only need to change unwind-protect if input_string changes */
606
if (t != input_string)
609
remove_unwind_protect ();
610
add_unwind_protect (xfree, input_string);
614
/* If the next character is to be accepted verbatim, a backslash
615
newline pair still disappears from the input. */
621
i--; /* back up over the CTLESC */
622
if (interactive && input_is_tty && raw == 0)
630
/* This may cause problems if IFS contains CTLESC */
631
if (c == '\\' && raw == 0)
634
if (skip_ctlesc == 0)
637
input_string[i++] = CTLESC;
642
if (ignore_delim == 0 && (unsigned char)c == delim)
645
if (c == '\0' && delim != '\0')
646
continue; /* skip NUL bytes in input */
648
if ((skip_ctlesc == 0 && c == CTLESC) || (skip_ctlnul == 0 && c == CTLNUL))
651
input_string[i++] = CTLESC;
655
input_string[i++] = c;
658
#if defined (HANDLE_MULTIBYTE)
659
if (nchars > 0 && MB_CUR_MAX > 1 && is_basic (c) == 0)
661
input_string[i] = '\0'; /* for simplicity and debugging */
662
i += read_mbchar (fd, input_string, i, c, unbuffered_read);
668
if (nchars > 0 && nr >= nchars)
671
input_string[i] = '\0';
678
builtin_error (_("read error: %d: %s"), fd, strerror (errno));
679
run_unwind_frame ("read_builtin");
680
return ((t_errno != EINTR) ? EXECUTION_FAILURE : 128+lastsig);
683
if (tmsec > 0 || tmusec > 0)
686
if (nchars > 0 || delim != '\n')
688
#if defined (READLINE)
692
rl_num_chars_to_read = 0;
694
reset_eol_delim ((char *)NULL);
699
ttyrestore (&termsave);
702
ttyrestore (&termsave);
704
if (unbuffered_read == 0)
707
discard_unwind_frame ("read_builtin");
709
retval = eof ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
713
#if defined (ARRAY_VARS)
714
/* If -a was given, take the string read, break it into a list of words,
715
an assign them to `arrayname' in turn. */
718
if (legal_identifier (arrayname) == 0)
720
sh_invalidid (arrayname);
721
xfree (input_string);
722
return (EXECUTION_FAILURE);
725
var = find_or_make_array_variable (arrayname, 1);
728
xfree (input_string);
729
return EXECUTION_FAILURE; /* readonly or noassign */
733
builtin_error (_("%s: cannot convert associative to indexed array"), arrayname);
734
xfree (input_string);
735
return EXECUTION_FAILURE; /* existing associative array */
737
else if (invisible_p (var))
738
VUNSETATTR (var, att_invisible);
739
array_flush (array_cell (var));
741
alist = list_string (input_string, ifs_chars, 0);
745
dequote_list (alist);
747
word_list_remove_quoted_nulls (alist);
748
assign_array_var_from_word_list (var, alist, 0);
749
dispose_words (alist);
751
xfree (input_string);
754
#endif /* ARRAY_VARS */
756
/* If there are no variables, save the text of the line read to the
757
variable $REPLY. ksh93 strips leading and trailing IFS whitespace,
758
so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the
759
same way, but I believe that the difference in behaviors is useful
760
enough to not do it. Without the bash behavior, there is no way
761
to read a line completely without interpretation or modification
762
unless you mess with $IFS (e.g., setting it to the empty string).
763
If you disagree, change the occurrences of `#if 0' to `#if 1' below. */
767
orig_input_string = input_string;
768
for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
771
input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
776
t = dequote_string (input_string);
777
var = bind_variable ("REPLY", t, 0);
781
var = bind_variable ("REPLY", input_string, 0);
782
VUNSETATTR (var, att_invisible);
784
xfree (input_string);
788
/* This code implements the Posix.2 spec for splitting the words
789
read and assigning them to variables. */
790
orig_input_string = input_string;
792
/* Remove IFS white space at the beginning of the input string. If
793
$IFS is null, no field splitting is performed. */
794
for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++)
797
for (; list->next; list = list->next)
799
varname = list->word->word;
800
#if defined (ARRAY_VARS)
801
if (legal_identifier (varname) == 0 && valid_array_reference (varname) == 0)
803
if (legal_identifier (varname) == 0)
806
sh_invalidid (varname);
807
xfree (orig_input_string);
808
return (EXECUTION_FAILURE);
811
/* If there are more variables than words read from the input,
812
the remaining variables are set to the empty string. */
815
/* This call updates INPUT_STRING. */
816
t = get_word_from_string (&input_string, ifs_chars, &e);
819
/* Don't bother to remove the CTLESC unless we added one
820
somewhere while reading the string. */
823
t1 = dequote_string (t);
824
var = bind_read_variable (varname, t1);
828
var = bind_read_variable (varname, t ? t : "");
833
var = bind_read_variable (varname, "");
839
xfree (orig_input_string);
840
return (EXECUTION_FAILURE);
843
stupidly_hack_special_variables (varname);
844
VUNSETATTR (var, att_invisible);
847
/* Now assign the rest of the line to the last variable argument. */
848
#if defined (ARRAY_VARS)
849
if (legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word) == 0)
851
if (legal_identifier (list->word->word) == 0)
854
sh_invalidid (list->word->word);
855
xfree (orig_input_string);
856
return (EXECUTION_FAILURE);
860
/* This has to be done this way rather than using string_list
861
and list_string because Posix.2 says that the last variable gets the
862
remaining words and their intervening separators. */
863
input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape);
865
/* Check whether or not the number of fields is exactly the same as the
866
number of variables. */
871
t = get_word_from_string (&input_string, ifs_chars, &e);
872
if (*input_string == 0)
873
tofree = input_string = t;
876
input_string = strip_trailing_ifs_whitespace (t1, ifs_chars, saw_escape);
882
if (saw_escape && input_string && *input_string)
884
t = dequote_string (input_string);
885
var = bind_read_variable (list->word->word, t);
889
var = bind_read_variable (list->word->word, input_string ? input_string : "");
893
stupidly_hack_special_variables (list->word->word);
894
VUNSETATTR (var, att_invisible);
897
retval = EXECUTION_FAILURE;
900
xfree (orig_input_string);
906
bind_read_variable (name, value)
911
#if defined (ARRAY_VARS)
912
if (valid_array_reference (name) == 0)
913
v = bind_variable (name, value, 0);
915
v = assign_array_element (name, value, 0);
916
#else /* !ARRAY_VARS */
917
v = bind_variable (name, value, 0);
918
#endif /* !ARRAY_VARS */
920
: ((readonly_p (v) || noassign_p (v)) ? (SHELL_VAR *)NULL : v));
923
#if defined (HANDLE_MULTIBYTE)
925
read_mbchar (fd, string, ind, ch, unbuffered)
928
int ind, ch, unbuffered;
930
char mbchar[MB_LEN_MAX + 1];
934
mbstate_t ps, ps_back;
937
memset (&ps, '\0', sizeof (mbstate_t));
938
memset (&ps_back, '\0', sizeof (mbstate_t));
942
for (n = 0; n <= MB_LEN_MAX; n++)
945
ret = mbrtowc (&wc, mbchar, i, &ps);
946
if (ret == (size_t)-2)
949
/* We don't want to be interrupted during a multibyte char read */
951
r = zread (fd, &c, 1);
959
else if (ret == (size_t)-1 || ret == (size_t)0 || ret > (size_t)0)
964
if (i > 1) /* read a multibyte char */
965
/* mbchar[0] is already string[ind-1] */
966
for (r = 1; r < i; r++)
967
string[ind+r-1] = mbchar[r];
977
ttsetattr (ttp->fd, ttp->attrs);
980
#if defined (READLINE)
981
static rl_completion_func_t *old_attempted_completion_function = 0;
982
static rl_hook_func_t *old_startup_hook;
983
static char *deftext;
986
reset_attempted_completion_function (cp)
989
if (rl_attempted_completion_function == 0 && old_attempted_completion_function)
990
rl_attempted_completion_function = old_attempted_completion_function;
999
if (old_startup_hook)
1000
r1 = (*old_startup_hook) ();
1003
r2 = rl_insert_text (deftext);
1004
deftext = (char *)NULL;
1005
rl_startup_hook = old_startup_hook;
1006
old_startup_hook = (rl_hook_func_t *)NULL;
1012
edit_line (p, itext)
1019
if (bash_readline_initialized == 0)
1020
initialize_readline ();
1022
old_attempted_completion_function = rl_attempted_completion_function;
1023
rl_attempted_completion_function = (rl_completion_func_t *)NULL;
1026
old_startup_hook = rl_startup_hook;
1027
rl_startup_hook = set_itext;
1033
rl_attempted_completion_function = old_attempted_completion_function;
1034
old_attempted_completion_function = (rl_completion_func_t *)NULL;
1039
ret = (char *)xrealloc (ret, len + 2);
1045
static int old_delim_ctype;
1046
static rl_command_func_t *old_delim_func;
1047
static int old_newline_ctype;
1048
static rl_command_func_t *old_newline_func;
1050
static unsigned char delim_char;
1058
if (bash_readline_initialized == 0)
1059
initialize_readline ();
1060
cmap = rl_get_keymap ();
1062
/* Change newline to self-insert */
1063
old_newline_ctype = cmap[RETURN].type;
1064
old_newline_func = cmap[RETURN].function;
1065
cmap[RETURN].type = ISFUNC;
1066
cmap[RETURN].function = rl_insert;
1068
/* Bind the delimiter character to accept-line. */
1069
old_delim_ctype = cmap[c].type;
1070
old_delim_func = cmap[c].function;
1071
cmap[c].type = ISFUNC;
1072
cmap[c].function = rl_newline;
1078
reset_eol_delim (cp)
1083
cmap = rl_get_keymap ();
1085
cmap[RETURN].type = old_newline_ctype;
1086
cmap[RETURN].function = old_newline_func;
1088
cmap[delim_char].type = old_delim_ctype;
1089
cmap[delim_char].function = old_delim_func;
added
removed
builtins/read.def
