Bash is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 1, or (at your option) any later
+Software Foundation; either version 2, or (at your option) any later
version.
Bash is distributed in the hope that it will be useful, but WITHOUT ANY
You should have received a copy of the GNU General Public License along
with Bash; see the file COPYING. If not, write to the Free Software
-Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA.
$PRODUCES read.c
$BUILTIN read
$FUNCTION read_builtin
-$SHORT_DOC read [-r] [-p prompt] [-a array] [-e] [name ...]
+$SHORT_DOC read [-ers] [-t timeout] [-p prompt] [-a array] [-n nchars] [-d delim] [name ...]
One line is read from the standard input, and the first word is
assigned to the first NAME, the second word to the second NAME, and so
on, with leftover words assigned to the last NAME. Only the characters
-found in $IFS are recognized as word delimiters. The return code is
-zero, unless end-of-file is encountered. If no NAMEs are supplied, the
-line read is stored in the REPLY variable. If the -r option is given,
-this signifies `raw' input, and backslash escaping is disabled. If
-the `-p' option is supplied, the string supplied as an argument is
-output without a trailing newline before attempting to read. If -a is
-supplied, the words read are assigned to sequential indices of ARRAY,
-starting at zero. If -e is supplied and the shell is interactive,
-readline is used to obtain the line.
+found in $IFS are recognized as word delimiters. If no NAMEs are supplied,
+the line read is stored in the REPLY variable. If the -r option is given,
+this signifies `raw' input, and backslash escaping is disabled. The
+-d option causes read to continue until the first character of DELIM is
+read, rather than newline. If the `-p' option is supplied, the string
+PROMPT is output without a trailing newline before attempting to read.
+If -a is supplied, the words read are assigned to sequential indices of
+ARRAY, starting at zero. If -e is supplied and the shell is interactive,
+readline is used to obtain the line. If -n is supplied with a non-zero
+NCHARS argument, read returns after NCHARS characters have been read.
+The -s option causes input coming from a terminal to not be echoed.
+
+The -t option causes read to time out and return failure if a complete line
+of input is not read within TIMEOUT seconds. The return code is zero,
+unless end-of-file is encountered or read times out.
$END
#include <config.h>
+#include "bashtypes.h"
+#include "posixstat.h"
+
#include <stdio.h>
#if defined (HAVE_UNISTD_H)
# include <unistd.h>
#endif
+#include <signal.h>
#include <errno.h>
+#ifdef __CYGWIN__
+# include <fcntl.h>
+# include <io.h>
+#endif
+
#include "../shell.h"
#include "common.h"
#include "bashgetopt.h"
+#include <shtty.h>
+
#if defined (READLINE)
#include "../bashline.h"
#include <readline/readline.h>
#if defined (READLINE)
static char *edit_line ();
+static void set_eol_delim ();
+static void reset_eol_delim ();
#endif
static SHELL_VAR *bind_read_variable ();
+static procenv_t alrmbuf;
+static SigHandler *old_alrm;
+static int delim;
+
+static sighandler
+sigalrm (s)
+ int s;
+{
+ longjmp (alrmbuf, 1);
+}
+
+static void
+reset_alarm ()
+{
+ set_signal_handler (SIGALRM, old_alrm);
+ alarm (0);
+}
+
/* Read the value of the shell variables whose names follow.
The reading is done from the current input stream, whatever
that may be. Successive words of the input line are assigned
WORD_LIST *list;
{
register char *varname;
- int size, i, raw, pass_next, saw_escape, eof, opt, retval, edit;
+ int size, i, pass_next, saw_escape, eof, opt, retval, code;
+ int input_is_tty, input_is_pipe, unbuffered_read;
+ int raw, edit, tmout, nchars, silent;
+ long timeoutval, ncharsval;
char c;
char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname;
char *e, *t, *t1;
+ struct stat tsb;
SHELL_VAR *var;
#if defined (ARRAY_VARS)
WORD_LIST *alist;
i = 0; /* Index into the string that we are reading. */
raw = edit = 0; /* Not reading raw input by default. */
+ silent = 0;
arrayname = prompt = (char *)NULL;
#if defined (READLINE)
rlind = 0;
#endif
+ tmout = -1; /* no timeout */
+ nchars = input_is_tty = input_is_pipe = unbuffered_read = 0;
+ delim = '\n'; /* read until newline */
+
reset_internal_getopt ();
- while ((opt = internal_getopt (list, "erp:a:")) != -1)
+ while ((opt = internal_getopt (list, "erp:a:d:t:n:s")) != -1)
{
switch (opt)
- {
- case 'r':
+ {
+ case 'r':
raw = 1;
break;
case 'p':
prompt = list_optarg;
break;
+ case 's':
+ silent = 1;
+ break;
case 'e':
#if defined (READLINE)
edit = 1;
arrayname = list_optarg;
break;
#endif
+ case 't':
+ code = legal_number (list_optarg, &timeoutval);
+ if (code == 0 || timeoutval < 0)
+ {
+ builtin_error ("%s: invalid timeout specification", list_optarg);
+ return (EXECUTION_FAILURE);
+ }
+ else
+ tmout = timeoutval;
+ break;
+ case 'n':
+ code = legal_number (list_optarg, &ncharsval);
+ if (code == 0 || ncharsval < 0)
+ {
+ builtin_error ("%s: invalid number specification", list_optarg);
+ return (EXECUTION_FAILURE);
+ }
+ else
+ nchars = ncharsval;
+ break;
+ case 'd':
+ delim = *list_optarg;
+ break;
default:
builtin_usage ();
return (EX_USAGE);
}
list = loptend;
+ /* `read -t 0 var' returns failure immediately. */
+ if (tmout == 0)
+ return (EXECUTION_FAILURE);
+
/* IF IFS is unset, we use the default of " \t\n". */
var = find_variable ("IFS");
ifs_chars = var ? value_cell (var) : " \t\n";
input_string = xmalloc (size = 128);
begin_unwind_frame ("read_builtin");
- add_unwind_protect (xfree, input_string);
#if defined (READLINE)
add_unwind_protect (xfree, rlbuf);
#endif
- interrupt_immediately++;
- /* If the -p or -e flags were given, but input is not coming from the
+ input_is_tty = isatty (0);
+ if (input_is_tty == 0)
+#ifndef __CYGWIN__
+ input_is_pipe = (lseek (0, 0L, SEEK_CUR) < 0) && (errno == ESPIPE);
+#else
+ input_is_pipe = 1;
+#endif
+
+ /* If the -p, -e or -s flags were given, but input is not coming from the
terminal, turn them off. */
- if ((prompt || edit) && (isatty (0) == 0))
+ if ((prompt || edit || silent) && input_is_tty == 0)
{
prompt = (char *)NULL;
- edit = 0;
+ edit = silent = 0;
}
if (prompt && edit == 0)
pass_next = 0; /* Non-zero signifies last char was backslash. */
saw_escape = 0; /* Non-zero signifies that we saw an escape char */
+ if (tmout > 0)
+ {
+ /* Turn off the timeout if stdin is a regular file (e.g. from
+ input redirection). */
+ if ((fstat (0, &tsb) < 0) || S_ISREG (tsb.st_mode))
+ tmout = -1;
+ }
+
+ if (tmout > 0)
+ {
+ code = setjmp (alrmbuf);
+ if (code)
+ {
+ run_unwind_frame ("read_builtin");
+ return (EXECUTION_FAILURE);
+ }
+ old_alrm = set_signal_handler (SIGALRM, sigalrm);
+ add_unwind_protect (reset_alarm, (char *)NULL);
+ alarm (tmout);
+ }
+
+ /* If we've been asked to read only NCHARS chars, or we're using some
+ character other than newline to terminate the line, do the right
+ thing to readline or the tty. */
+ if (nchars > 0 || delim != '\n')
+ {
+#if defined (READLINE)
+ if (edit)
+ {
+ if (nchars > 0)
+ {
+ unwind_protect_int (rl_num_chars_to_read);
+ rl_num_chars_to_read = nchars;
+ }
+ if (delim != '\n')
+ {
+ set_eol_delim (delim);
+ add_unwind_protect (reset_eol_delim, (char *)NULL);
+ }
+ }
+ else
+#endif
+ if (input_is_tty)
+ {
+ ttsave ();
+ if (silent)
+ ttcbreak ();
+ else
+ ttonechar ();
+ add_unwind_protect ((Function *)ttrestore, (char *)NULL);
+ }
+ }
+ else if (silent) /* turn off echo but leave term in canonical mode */
+ {
+ ttsave ();
+ ttnoecho ();
+ add_unwind_protect ((Function *)ttrestore, (char *)NULL);
+ }
+
+ /* This *must* be the top unwind-protect on the stack, so the manipulation
+ of the unwind-protect stack after the realloc() works right. */
+ add_unwind_protect (xfree, input_string);
+ interrupt_immediately++;
+
+ unbuffered_read = (nchars > 0) || (delim != '\n') || input_is_pipe;
+
+#if defined (__CYGWIN__) && defined (O_TEXT)
+ setmode (0, O_TEXT);
+#endif
+
for (eof = 0;;)
{
#if defined (READLINE)
c = rlbuf[rlind++];
}
else
+ {
#endif
- while (((retval = read (0, &c, 1)) < 0) && errno == EINTR)
- ;
+ if (unbuffered_read)
+ retval = zread (0, &c, 1);
+ else
+ retval = zreadc (0, &c);
+
if (retval <= 0)
{
eof = 1;
break;
}
+#if defined (READLINE)
+ }
+#endif
+
if (i + 2 >= size)
- input_string = xrealloc (input_string, size += 128);
+ {
+ input_string = xrealloc (input_string, size += 128);
+ remove_unwind_protect ();
+ add_unwind_protect (xfree, input_string);
+ }
/* If the next character is to be accepted verbatim, a backslash
newline pair still disappears from the input. */
continue;
}
- if (c == '\n')
+ if (c == delim)
break;
if (c == CTLESC || c == CTLNUL)
}
input_string[i++] = c;
+
+ if (nchars > 0 && i >= nchars)
+ break;
}
input_string[i] = '\0';
+ if (tmout > 0)
+ reset_alarm ();
+
+ if (nchars > 0 || delim != '\n')
+ {
+#if defined (READLINE)
+ if (edit)
+ {
+ if (nchars > 0)
+ rl_num_chars_to_read = 0;
+ if (delim != '\n')
+ reset_eol_delim ();
+ }
+ else
+#endif
+ if (input_is_tty)
+ ttrestore ();
+ }
+ else if (silent)
+ ttrestore ();
+
+ if (unbuffered_read == 0)
+ zsyncfd (0);
+
interrupt_immediately--;
discard_unwind_frame ("read_builtin");
{
var = find_variable (arrayname);
if (var == 0)
- var = make_new_array_variable (arrayname);
+ var = make_new_array_variable (arrayname);
else if (array_p (var) == 0)
- var = convert_var_to_array (var);
+ var = convert_var_to_array (var);
empty_array (array_cell (var));
so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the
same way, but I believe that the difference in behaviors is useful
enough to not do it. Without the bash behavior, there is no way
- to read a line completely without interpretation or modification.
+ to read a line completely without interpretation or modification
+ unless you mess with $IFS (e.g., setting it to the empty string).
If you disagree, change the occurrences of `#if 0' to `#if 1' below. */
if (list == 0)
{
}
else
var = bind_variable ("REPLY", input_string);
- var->attributes &= ~att_invisible;
-#if 0
- free (orig_input_string);
-#else
+ VUNSETATTR (var, att_invisible);
+
free (input_string);
-#endif
return (retval);
}
}
stupidly_hack_special_variables (varname);
- var->attributes &= ~att_invisible;
+ VUNSETATTR (var, att_invisible);
}
/* Now assign the rest of the line to the last variable argument. */
var = bind_read_variable (list->word->word, input_string);
stupidly_hack_special_variables (list->word->word);
if (var)
- var->attributes &= ~att_invisible;
+ VUNSETATTR (var, att_invisible);
free (orig_input_string);
return (retval);
#if defined (ARRAY_VARS)
if (valid_array_reference (name) == 0)
{
+#if 0
if (legal_identifier (name) == 0)
- {
+ {
builtin_error ("`%s': not a valid identifier", name);
return ((SHELL_VAR *)NULL);
- }
+ }
+#endif
return (bind_variable (name, value));
}
else
return ret;
len = strlen (ret);
ret = xrealloc (ret, len + 2);
- ret[len++] = '\n';
+ ret[len++] = delim;
ret[len] = '\0';
return ret;
}
+
+static int old_delim_ctype;
+static Function *old_delim_func;
+static int old_newline_ctype;
+static Function *old_newline_func;
+
+static int delim_char;
+
+static void
+set_eol_delim (c)
+ int c;
+{
+ Keymap cmap;
+
+ if (bash_readline_initialized == 0)
+ initialize_readline ();
+ cmap = rl_get_keymap ();
+
+ /* Change newline to self-insert */
+ old_newline_ctype = cmap[RETURN].type;
+ old_newline_func = cmap[RETURN].function;
+ cmap[RETURN].type = ISFUNC;
+ cmap[RETURN].function = rl_insert;
+
+ /* Bind the delimiter character to accept-line. */
+ old_delim_ctype = cmap[c].type;
+ old_delim_func = cmap[c].function;
+ cmap[c].type = ISFUNC;
+ cmap[c].function = rl_newline;
+
+ delim_char = c;
+}
+
+static void
+reset_eol_delim (c)
+ int c;
+{
+ Keymap cmap;
+
+ cmap = rl_get_keymap ();
+
+ cmap[RETURN].type = old_newline_ctype;
+ cmap[RETURN].function = old_newline_func;
+
+ cmap[delim_char].type = old_delim_ctype;
+ cmap[delim_char].function = old_delim_func;
+}
#endif
projects / thirdparty / bash.git / blobdiff