]>
Commit | Line | Data |
---|---|---|
726f6388 JA |
1 | This file is read.def, from which is created read.c. |
2 | It implements the builtin "read" in Bash. | |
3 | ||
495aee44 | 4 | Copyright (C) 1987-2010 Free Software Foundation, Inc. |
726f6388 JA |
5 | |
6 | This file is part of GNU Bash, the Bourne Again SHell. | |
7 | ||
3185942a JA |
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. | |
726f6388 | 12 | |
3185942a JA |
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. | |
726f6388 | 17 | |
3185942a JA |
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/>. | |
726f6388 JA |
20 | |
21 | $PRODUCES read.c | |
22 | ||
23 | $BUILTIN read | |
24 | $FUNCTION read_builtin | |
0001803f | 25 | $SHORT_DOC read [-ers] [-a array] [-d delim] [-i text] [-n nchars] [-N nchars] [-p prompt] [-t timeout] [-u fd] [name ...] |
3185942a JA |
26 | Read a line from the standard input and split it into fields. |
27 | ||
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 | |
33 | delimiters. | |
34 | ||
35 | If no NAMEs are supplied, the line read is stored in the REPLY variable. | |
36 | ||
37 | Options: | |
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 | |
41 | than newline | |
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 | |
0001803f CR |
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 | |
3185942a JA |
49 | -p prompt output the string PROMPT without a trailing newline before |
50 | attempting to read | |
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 withint 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 success only | |
57 | if input is available on the specified file descriptor. The | |
58 | exit status is greater than 128 if the timeout is exceeded | |
59 | -u fd read from file descriptor FD instead of the standard input | |
60 | ||
61 | Exit Status: | |
62 | The return code is zero, unless end-of-file is encountered, read times out, | |
63 | or an invalid file descriptor is supplied as the argument to -u. | |
726f6388 JA |
64 | $END |
65 | ||
ccc6cda3 JA |
66 | #include <config.h> |
67 | ||
bb70624e JA |
68 | #include "bashtypes.h" |
69 | #include "posixstat.h" | |
70 | ||
726f6388 | 71 | #include <stdio.h> |
ccc6cda3 | 72 | |
3185942a JA |
73 | #include "bashansi.h" |
74 | ||
ccc6cda3 JA |
75 | #if defined (HAVE_UNISTD_H) |
76 | # include <unistd.h> | |
77 | #endif | |
78 | ||
bb70624e | 79 | #include <signal.h> |
e8ce775d JA |
80 | #include <errno.h> |
81 | ||
28ef6c31 JA |
82 | #ifdef __CYGWIN__ |
83 | # include <fcntl.h> | |
84 | # include <io.h> | |
85 | #endif | |
86 | ||
b80f6443 JA |
87 | #include "../bashintl.h" |
88 | ||
726f6388 JA |
89 | #include "../shell.h" |
90 | #include "common.h" | |
ccc6cda3 | 91 | #include "bashgetopt.h" |
726f6388 | 92 | |
bb70624e JA |
93 | #include <shtty.h> |
94 | ||
ccc6cda3 JA |
95 | #if defined (READLINE) |
96 | #include "../bashline.h" | |
97 | #include <readline/readline.h> | |
98 | #endif | |
726f6388 | 99 | |
95732b49 JA |
100 | #if defined (BUFFERED_INPUT) |
101 | # include "input.h" | |
102 | #endif | |
103 | ||
e8ce775d JA |
104 | #if !defined(errno) |
105 | extern int errno; | |
106 | #endif | |
107 | ||
3185942a JA |
108 | struct ttsave |
109 | { | |
110 | int fd; | |
111 | TTYSTRUCT *attrs; | |
112 | }; | |
113 | ||
ccc6cda3 | 114 | #if defined (READLINE) |
0628567a | 115 | static void reset_attempted_completion_function __P((char *)); |
3185942a JA |
116 | static int set_itext __P((void)); |
117 | static char *edit_line __P((char *, char *)); | |
f73dda09 JA |
118 | static void set_eol_delim __P((int)); |
119 | static void reset_eol_delim __P((char *)); | |
ccc6cda3 | 120 | #endif |
f73dda09 | 121 | static SHELL_VAR *bind_read_variable __P((char *, char *)); |
3185942a JA |
122 | #if defined (HANDLE_MULTIBYTE) |
123 | static int read_mbchar __P((int, char *, int, int, int)); | |
124 | #endif | |
125 | static void ttyrestore __P((struct ttsave *)); | |
f73dda09 JA |
126 | |
127 | static sighandler sigalrm __P((int)); | |
128 | static void reset_alarm __P((void)); | |
ccc6cda3 | 129 | |
bb70624e JA |
130 | static procenv_t alrmbuf; |
131 | static SigHandler *old_alrm; | |
f73dda09 | 132 | static unsigned char delim; |
bb70624e JA |
133 | |
134 | static sighandler | |
135 | sigalrm (s) | |
136 | int s; | |
137 | { | |
138 | longjmp (alrmbuf, 1); | |
139 | } | |
140 | ||
141 | static void | |
142 | reset_alarm () | |
143 | { | |
144 | set_signal_handler (SIGALRM, old_alrm); | |
3185942a | 145 | falarm (0, 0); |
bb70624e JA |
146 | } |
147 | ||
726f6388 JA |
148 | /* Read the value of the shell variables whose names follow. |
149 | The reading is done from the current input stream, whatever | |
150 | that may be. Successive words of the input line are assigned | |
151 | to the variables mentioned in LIST. The last variable in LIST | |
152 | gets the remainder of the words on the line. If no variables | |
ccc6cda3 JA |
153 | are mentioned in LIST, then the default variable is $REPLY. */ |
154 | int | |
726f6388 JA |
155 | read_builtin (list) |
156 | WORD_LIST *list; | |
157 | { | |
158 | register char *varname; | |
f1be666c JA |
159 | int size, i, nr, pass_next, saw_escape, eof, opt, retval, code, print_ps2; |
160 | int input_is_tty, input_is_pipe, unbuffered_read, skip_ctlesc, skip_ctlnul; | |
0001803f | 161 | int raw, edit, nchars, silent, have_timeout, ignore_delim, fd; |
3185942a JA |
162 | unsigned int tmsec, tmusec; |
163 | long ival, uval; | |
7117c2d2 | 164 | intmax_t intval; |
ccc6cda3 JA |
165 | char c; |
166 | char *input_string, *orig_input_string, *ifs_chars, *prompt, *arrayname; | |
f1be666c | 167 | char *e, *t, *t1, *ps2, *tofree; |
bb70624e | 168 | struct stat tsb; |
726f6388 | 169 | SHELL_VAR *var; |
3185942a JA |
170 | TTYSTRUCT ttattrs, ttset; |
171 | struct ttsave termsave; | |
ccc6cda3 JA |
172 | #if defined (ARRAY_VARS) |
173 | WORD_LIST *alist; | |
174 | #endif | |
175 | #if defined (READLINE) | |
3185942a | 176 | char *rlbuf, *itext; |
ccc6cda3 JA |
177 | int rlind; |
178 | #endif | |
726f6388 | 179 | |
f73dda09 JA |
180 | USE_VAR(size); |
181 | USE_VAR(i); | |
182 | USE_VAR(pass_next); | |
f1be666c | 183 | USE_VAR(print_ps2); |
f73dda09 JA |
184 | USE_VAR(saw_escape); |
185 | USE_VAR(input_is_pipe); | |
186 | /* USE_VAR(raw); */ | |
187 | USE_VAR(edit); | |
3185942a JA |
188 | USE_VAR(tmsec); |
189 | USE_VAR(tmusec); | |
f73dda09 JA |
190 | USE_VAR(nchars); |
191 | USE_VAR(silent); | |
192 | USE_VAR(ifs_chars); | |
193 | USE_VAR(prompt); | |
194 | USE_VAR(arrayname); | |
195 | #if defined (READLINE) | |
196 | USE_VAR(rlbuf); | |
197 | USE_VAR(rlind); | |
3185942a | 198 | USE_VAR(itext); |
f73dda09 JA |
199 | #endif |
200 | USE_VAR(list); | |
f1be666c | 201 | USE_VAR(ps2); |
f73dda09 | 202 | |
726f6388 | 203 | i = 0; /* Index into the string that we are reading. */ |
ccc6cda3 | 204 | raw = edit = 0; /* Not reading raw input by default. */ |
bb70624e | 205 | silent = 0; |
ccc6cda3 | 206 | arrayname = prompt = (char *)NULL; |
7117c2d2 | 207 | fd = 0; /* file descriptor to read from */ |
ccc6cda3 JA |
208 | |
209 | #if defined (READLINE) | |
3185942a | 210 | rlbuf = itext = (char *)0; |
ccc6cda3 JA |
211 | rlind = 0; |
212 | #endif | |
726f6388 | 213 | |
3185942a | 214 | tmsec = tmusec = 0; /* no timeout */ |
95732b49 | 215 | nr = nchars = input_is_tty = input_is_pipe = unbuffered_read = have_timeout = 0; |
bb70624e | 216 | delim = '\n'; /* read until newline */ |
0001803f | 217 | ignore_delim = 0; |
bb70624e | 218 | |
ccc6cda3 | 219 | reset_internal_getopt (); |
0001803f | 220 | while ((opt = internal_getopt (list, "ersa:d:i:n:p:t:u:N:")) != -1) |
726f6388 | 221 | { |
ccc6cda3 | 222 | switch (opt) |
28ef6c31 JA |
223 | { |
224 | case 'r': | |
ccc6cda3 | 225 | raw = 1; |
726f6388 | 226 | break; |
ccc6cda3 JA |
227 | case 'p': |
228 | prompt = list_optarg; | |
229 | break; | |
bb70624e JA |
230 | case 's': |
231 | silent = 1; | |
232 | break; | |
ccc6cda3 JA |
233 | case 'e': |
234 | #if defined (READLINE) | |
235 | edit = 1; | |
3185942a JA |
236 | #endif |
237 | break; | |
238 | case 'i': | |
239 | #if defined (READLINE) | |
240 | itext = list_optarg; | |
ccc6cda3 JA |
241 | #endif |
242 | break; | |
243 | #if defined (ARRAY_VARS) | |
244 | case 'a': | |
245 | arrayname = list_optarg; | |
246 | break; | |
247 | #endif | |
bb70624e | 248 | case 't': |
3185942a JA |
249 | code = uconvert (list_optarg, &ival, &uval); |
250 | if (code == 0 || ival < 0 || uval < 0) | |
bb70624e | 251 | { |
b80f6443 | 252 | builtin_error (_("%s: invalid timeout specification"), list_optarg); |
bb70624e JA |
253 | return (EXECUTION_FAILURE); |
254 | } | |
255 | else | |
f73dda09 JA |
256 | { |
257 | have_timeout = 1; | |
3185942a JA |
258 | tmsec = ival; |
259 | tmusec = uval; | |
f73dda09 | 260 | } |
bb70624e | 261 | break; |
0001803f CR |
262 | case 'N': |
263 | ignore_delim = 1; | |
264 | delim = -1; | |
bb70624e | 265 | case 'n': |
7117c2d2 JA |
266 | code = legal_number (list_optarg, &intval); |
267 | if (code == 0 || intval < 0 || intval != (int)intval) | |
bb70624e | 268 | { |
7117c2d2 | 269 | sh_invalidnum (list_optarg); |
bb70624e JA |
270 | return (EXECUTION_FAILURE); |
271 | } | |
272 | else | |
7117c2d2 JA |
273 | nchars = intval; |
274 | break; | |
275 | case 'u': | |
276 | code = legal_number (list_optarg, &intval); | |
277 | if (code == 0 || intval < 0 || intval != (int)intval) | |
278 | { | |
b80f6443 | 279 | builtin_error (_("%s: invalid file descriptor specification"), list_optarg); |
7117c2d2 JA |
280 | return (EXECUTION_FAILURE); |
281 | } | |
282 | else | |
283 | fd = intval; | |
284 | if (sh_validfd (fd) == 0) | |
285 | { | |
b80f6443 | 286 | builtin_error (_("%d: invalid file descriptor: %s"), fd, strerror (errno)); |
7117c2d2 JA |
287 | return (EXECUTION_FAILURE); |
288 | } | |
bb70624e JA |
289 | break; |
290 | case 'd': | |
291 | delim = *list_optarg; | |
292 | break; | |
ccc6cda3 JA |
293 | default: |
294 | builtin_usage (); | |
726f6388 JA |
295 | return (EX_USAGE); |
296 | } | |
726f6388 | 297 | } |
ccc6cda3 | 298 | list = loptend; |
726f6388 | 299 | |
17345e5a JA |
300 | /* `read -t 0 var' tests whether input is available with select/FIONREAD, |
301 | and fails if those are unavailable */ | |
3185942a JA |
302 | if (have_timeout && tmsec == 0 && tmusec == 0) |
303 | #if 0 | |
bb70624e | 304 | return (EXECUTION_FAILURE); |
3185942a JA |
305 | #else |
306 | return (input_avail (fd) ? EXECUTION_SUCCESS : EXECUTION_FAILURE); | |
307 | #endif | |
bb70624e | 308 | |
0001803f CR |
309 | /* If we're asked to ignore the delimiter, make sure we do. */ |
310 | if (ignore_delim) | |
311 | delim = -1; | |
312 | ||
ccc6cda3 | 313 | /* IF IFS is unset, we use the default of " \t\n". */ |
7117c2d2 JA |
314 | ifs_chars = getifs (); |
315 | if (ifs_chars == 0) /* XXX - shouldn't happen */ | |
316 | ifs_chars = ""; | |
0001803f CR |
317 | /* If we want to read exactly NCHARS chars, don't split on IFS */ |
318 | if (ignore_delim) | |
319 | ifs_chars = ""; | |
3185942a JA |
320 | for (skip_ctlesc = skip_ctlnul = 0, e = ifs_chars; *e; e++) |
321 | skip_ctlesc |= *e == CTLESC, skip_ctlnul |= *e == CTLNUL; | |
726f6388 | 322 | |
7117c2d2 | 323 | input_string = (char *)xmalloc (size = 112); /* XXX was 128 */ |
3185942a | 324 | input_string[0] = '\0'; |
7117c2d2 JA |
325 | |
326 | /* $TMOUT, if set, is the default timeout for read. */ | |
327 | if (have_timeout == 0 && (e = get_string_value ("TMOUT"))) | |
328 | { | |
3185942a JA |
329 | code = uconvert (e, &ival, &uval); |
330 | if (code == 0 || ival < 0 || uval < 0) | |
331 | tmsec = tmusec = 0; | |
7117c2d2 | 332 | else |
3185942a JA |
333 | { |
334 | tmsec = ival; | |
335 | tmusec = uval; | |
336 | } | |
7117c2d2 | 337 | } |
726f6388 JA |
338 | |
339 | begin_unwind_frame ("read_builtin"); | |
726f6388 | 340 | |
95732b49 JA |
341 | #if defined (BUFFERED_INPUT) |
342 | if (interactive == 0 && default_buffered_input >= 0 && fd_is_bash_input (fd)) | |
343 | sync_buffered_stream (default_buffered_input); | |
344 | #endif | |
345 | ||
7117c2d2 | 346 | input_is_tty = isatty (fd); |
bb70624e | 347 | if (input_is_tty == 0) |
28ef6c31 | 348 | #ifndef __CYGWIN__ |
95732b49 | 349 | input_is_pipe = (lseek (fd, 0L, SEEK_CUR) < 0) && (errno == ESPIPE); |
bb70624e JA |
350 | #else |
351 | input_is_pipe = 1; | |
352 | #endif | |
353 | ||
354 | /* If the -p, -e or -s flags were given, but input is not coming from the | |
ccc6cda3 | 355 | terminal, turn them off. */ |
bb70624e | 356 | if ((prompt || edit || silent) && input_is_tty == 0) |
ccc6cda3 JA |
357 | { |
358 | prompt = (char *)NULL; | |
3185942a JA |
359 | #if defined (READLINE) |
360 | itext = (char *)NULL; | |
361 | #endif | |
bb70624e | 362 | edit = silent = 0; |
ccc6cda3 JA |
363 | } |
364 | ||
7117c2d2 JA |
365 | #if defined (READLINE) |
366 | if (edit) | |
367 | add_unwind_protect (xfree, rlbuf); | |
368 | #endif | |
369 | ||
726f6388 JA |
370 | pass_next = 0; /* Non-zero signifies last char was backslash. */ |
371 | saw_escape = 0; /* Non-zero signifies that we saw an escape char */ | |
372 | ||
3185942a | 373 | if (tmsec > 0 || tmusec > 0) |
bb70624e JA |
374 | { |
375 | /* Turn off the timeout if stdin is a regular file (e.g. from | |
376 | input redirection). */ | |
7117c2d2 | 377 | if ((fstat (fd, &tsb) < 0) || S_ISREG (tsb.st_mode)) |
3185942a | 378 | tmsec = tmusec = 0; |
bb70624e JA |
379 | } |
380 | ||
3185942a | 381 | if (tmsec > 0 || tmusec > 0) |
bb70624e JA |
382 | { |
383 | code = setjmp (alrmbuf); | |
384 | if (code) | |
385 | { | |
89a92869 CR |
386 | /* Tricky. The top of the unwind-protect stack is the free of |
387 | input_string. We want to run all the rest and use input_string, | |
388 | so we have to remove it from the stack. */ | |
389 | remove_unwind_protect (); | |
bb70624e | 390 | run_unwind_frame ("read_builtin"); |
3185942a | 391 | input_string[i] = '\0'; /* make sure it's terminated */ |
89a92869 | 392 | retval = 128+SIGALRM; |
3185942a | 393 | goto assign_vars; |
bb70624e JA |
394 | } |
395 | old_alrm = set_signal_handler (SIGALRM, sigalrm); | |
396 | add_unwind_protect (reset_alarm, (char *)NULL); | |
0628567a JA |
397 | #if defined (READLINE) |
398 | if (edit) | |
399 | add_unwind_protect (reset_attempted_completion_function, (char *)NULL); | |
400 | #endif | |
3185942a | 401 | falarm (tmsec, tmusec); |
bb70624e JA |
402 | } |
403 | ||
404 | /* If we've been asked to read only NCHARS chars, or we're using some | |
405 | character other than newline to terminate the line, do the right | |
406 | thing to readline or the tty. */ | |
407 | if (nchars > 0 || delim != '\n') | |
408 | { | |
409 | #if defined (READLINE) | |
410 | if (edit) | |
411 | { | |
412 | if (nchars > 0) | |
413 | { | |
414 | unwind_protect_int (rl_num_chars_to_read); | |
415 | rl_num_chars_to_read = nchars; | |
416 | } | |
417 | if (delim != '\n') | |
418 | { | |
419 | set_eol_delim (delim); | |
420 | add_unwind_protect (reset_eol_delim, (char *)NULL); | |
421 | } | |
422 | } | |
423 | else | |
424 | #endif | |
425 | if (input_is_tty) | |
28ef6c31 | 426 | { |
3185942a JA |
427 | /* ttsave() */ |
428 | termsave.fd = fd; | |
429 | ttgetattr (fd, &ttattrs); | |
430 | termsave.attrs = &ttattrs; | |
431 | ||
432 | ttset = ttattrs; | |
17345e5a JA |
433 | i = silent ? ttfd_cbreak (fd, &ttset) : ttfd_onechar (fd, &ttset); |
434 | if (i < 0) | |
435 | sh_ttyerror (1); | |
3185942a | 436 | add_unwind_protect ((Function *)ttyrestore, (char *)&termsave); |
bb70624e JA |
437 | } |
438 | } | |
439 | else if (silent) /* turn off echo but leave term in canonical mode */ | |
440 | { | |
3185942a JA |
441 | /* ttsave (); */ |
442 | termsave.fd = fd; | |
443 | ttgetattr (fd, &ttattrs); | |
444 | termsave.attrs = &ttattrs; | |
445 | ||
446 | ttset = ttattrs; | |
17345e5a JA |
447 | i = ttfd_noecho (fd, &ttset); /* ttnoecho (); */ |
448 | if (i < 0) | |
449 | sh_ttyerror (1); | |
3185942a JA |
450 | |
451 | add_unwind_protect ((Function *)ttyrestore, (char *)&termsave); | |
bb70624e JA |
452 | } |
453 | ||
28ef6c31 JA |
454 | /* This *must* be the top unwind-protect on the stack, so the manipulation |
455 | of the unwind-protect stack after the realloc() works right. */ | |
456 | add_unwind_protect (xfree, input_string); | |
457 | interrupt_immediately++; | |
3185942a | 458 | terminate_immediately++; |
28ef6c31 | 459 | |
bb70624e JA |
460 | unbuffered_read = (nchars > 0) || (delim != '\n') || input_is_pipe; |
461 | ||
3185942a JA |
462 | if (prompt && edit == 0) |
463 | { | |
464 | fprintf (stderr, "%s", prompt); | |
465 | fflush (stderr); | |
466 | } | |
467 | ||
28ef6c31 JA |
468 | #if defined (__CYGWIN__) && defined (O_TEXT) |
469 | setmode (0, O_TEXT); | |
470 | #endif | |
471 | ||
f1be666c JA |
472 | ps2 = 0; |
473 | for (print_ps2 = eof = retval = 0;;) | |
726f6388 | 474 | { |
ccc6cda3 JA |
475 | #if defined (READLINE) |
476 | if (edit) | |
477 | { | |
478 | if (rlbuf && rlbuf[rlind] == '\0') | |
479 | { | |
d166f048 | 480 | xfree (rlbuf); |
ccc6cda3 JA |
481 | rlbuf = (char *)0; |
482 | } | |
483 | if (rlbuf == 0) | |
484 | { | |
3185942a | 485 | rlbuf = edit_line (prompt ? prompt : "", itext); |
ccc6cda3 JA |
486 | rlind = 0; |
487 | } | |
488 | if (rlbuf == 0) | |
489 | { | |
490 | eof = 1; | |
491 | break; | |
492 | } | |
493 | c = rlbuf[rlind++]; | |
494 | } | |
495 | else | |
b72432fd | 496 | { |
e8ce775d JA |
497 | #endif |
498 | ||
f1be666c JA |
499 | if (print_ps2) |
500 | { | |
501 | if (ps2 == 0) | |
502 | ps2 = get_string_value ("PS2"); | |
503 | fprintf (stderr, "%s", ps2 ? ps2 : ""); | |
504 | fflush (stderr); | |
505 | print_ps2 = 0; | |
506 | } | |
507 | ||
bb70624e | 508 | if (unbuffered_read) |
7117c2d2 | 509 | retval = zread (fd, &c, 1); |
bb70624e | 510 | else |
7117c2d2 | 511 | retval = zreadc (fd, &c); |
bb70624e | 512 | |
e8ce775d | 513 | if (retval <= 0) |
ccc6cda3 JA |
514 | { |
515 | eof = 1; | |
516 | break; | |
517 | } | |
518 | ||
b72432fd JA |
519 | #if defined (READLINE) |
520 | } | |
521 | #endif | |
522 | ||
3185942a | 523 | if (i + 4 >= size) /* XXX was i + 2; use i + 4 for multibyte/read_mbchar */ |
28ef6c31 | 524 | { |
f73dda09 | 525 | input_string = (char *)xrealloc (input_string, size += 128); |
28ef6c31 JA |
526 | remove_unwind_protect (); |
527 | add_unwind_protect (xfree, input_string); | |
528 | } | |
726f6388 JA |
529 | |
530 | /* If the next character is to be accepted verbatim, a backslash | |
531 | newline pair still disappears from the input. */ | |
532 | if (pass_next) | |
533 | { | |
95732b49 | 534 | pass_next = 0; |
726f6388 | 535 | if (c == '\n') |
f1be666c JA |
536 | { |
537 | i--; /* back up over the CTLESC */ | |
538 | if (interactive && input_is_tty && raw == 0) | |
539 | print_ps2 = 1; | |
540 | } | |
726f6388 | 541 | else |
95732b49 | 542 | goto add_char; |
726f6388 JA |
543 | continue; |
544 | } | |
545 | ||
3185942a | 546 | /* This may cause problems if IFS contains CTLESC */ |
ccc6cda3 | 547 | if (c == '\\' && raw == 0) |
726f6388 JA |
548 | { |
549 | pass_next++; | |
3185942a JA |
550 | if (skip_ctlesc == 0) |
551 | { | |
552 | saw_escape++; | |
553 | input_string[i++] = CTLESC; | |
554 | } | |
726f6388 JA |
555 | continue; |
556 | } | |
557 | ||
f73dda09 | 558 | if ((unsigned char)c == delim) |
726f6388 JA |
559 | break; |
560 | ||
3185942a | 561 | if ((skip_ctlesc == 0 && c == CTLESC) || (skip_ctlnul == 0 && c == CTLNUL)) |
726f6388 JA |
562 | { |
563 | saw_escape++; | |
564 | input_string[i++] = CTLESC; | |
565 | } | |
566 | ||
95732b49 | 567 | add_char: |
726f6388 | 568 | input_string[i++] = c; |
3185942a JA |
569 | |
570 | #if defined (HANDLE_MULTIBYTE) | |
571 | if (nchars > 0 && MB_CUR_MAX > 1) | |
572 | { | |
573 | input_string[i] = '\0'; /* for simplicity and debugging */ | |
574 | i += read_mbchar (fd, input_string, i, c, unbuffered_read); | |
575 | } | |
576 | #endif | |
577 | ||
95732b49 | 578 | nr++; |
bb70624e | 579 | |
95732b49 | 580 | if (nchars > 0 && nr >= nchars) |
bb70624e | 581 | break; |
726f6388 JA |
582 | } |
583 | input_string[i] = '\0'; | |
584 | ||
7117c2d2 JA |
585 | #if 1 |
586 | if (retval < 0) | |
587 | { | |
b80f6443 | 588 | builtin_error (_("read error: %d: %s"), fd, strerror (errno)); |
0628567a | 589 | run_unwind_frame ("read_builtin"); |
7117c2d2 JA |
590 | return (EXECUTION_FAILURE); |
591 | } | |
592 | #endif | |
593 | ||
3185942a | 594 | if (tmsec > 0 || tmusec > 0) |
bb70624e JA |
595 | reset_alarm (); |
596 | ||
597 | if (nchars > 0 || delim != '\n') | |
598 | { | |
599 | #if defined (READLINE) | |
600 | if (edit) | |
601 | { | |
602 | if (nchars > 0) | |
603 | rl_num_chars_to_read = 0; | |
604 | if (delim != '\n') | |
f73dda09 | 605 | reset_eol_delim ((char *)NULL); |
bb70624e JA |
606 | } |
607 | else | |
608 | #endif | |
609 | if (input_is_tty) | |
3185942a | 610 | ttyrestore (&termsave); |
bb70624e JA |
611 | } |
612 | else if (silent) | |
3185942a | 613 | ttyrestore (&termsave); |
bb70624e JA |
614 | |
615 | if (unbuffered_read == 0) | |
7117c2d2 | 616 | zsyncfd (fd); |
bb70624e | 617 | |
726f6388 JA |
618 | discard_unwind_frame ("read_builtin"); |
619 | ||
ccc6cda3 | 620 | retval = eof ? EXECUTION_FAILURE : EXECUTION_SUCCESS; |
726f6388 | 621 | |
3185942a JA |
622 | assign_vars: |
623 | ||
30d188c2 CR |
624 | interrupt_immediately--; |
625 | terminate_immediately--; | |
626 | ||
ccc6cda3 JA |
627 | #if defined (ARRAY_VARS) |
628 | /* If -a was given, take the string read, break it into a list of words, | |
629 | an assign them to `arrayname' in turn. */ | |
630 | if (arrayname) | |
726f6388 | 631 | { |
b80f6443 JA |
632 | if (legal_identifier (arrayname) == 0) |
633 | { | |
634 | sh_invalidid (arrayname); | |
635 | xfree (input_string); | |
636 | return (EXECUTION_FAILURE); | |
637 | } | |
638 | ||
f73dda09 | 639 | var = find_or_make_array_variable (arrayname, 1); |
ccc6cda3 | 640 | if (var == 0) |
0628567a JA |
641 | { |
642 | xfree (input_string); | |
643 | return EXECUTION_FAILURE; /* readonly or noassign */ | |
644 | } | |
b4d40164 CR |
645 | if (assoc_p (var)) |
646 | { | |
647 | builtin_error (_("%s: cannot convert associative to indexed array"), arrayname); | |
648 | xfree (input_string); | |
649 | return EXECUTION_FAILURE; /* existing associative array */ | |
650 | } | |
7117c2d2 | 651 | array_flush (array_cell (var)); |
ccc6cda3 JA |
652 | |
653 | alist = list_string (input_string, ifs_chars, 0); | |
654 | if (alist) | |
655 | { | |
0628567a JA |
656 | if (saw_escape) |
657 | dequote_list (alist); | |
658 | else | |
659 | word_list_remove_quoted_nulls (alist); | |
95732b49 | 660 | assign_array_var_from_word_list (var, alist, 0); |
ccc6cda3 JA |
661 | dispose_words (alist); |
662 | } | |
d166f048 | 663 | xfree (input_string); |
ccc6cda3 | 664 | return (retval); |
726f6388 | 665 | } |
ccc6cda3 | 666 | #endif /* ARRAY_VARS */ |
726f6388 | 667 | |
d166f048 JA |
668 | /* If there are no variables, save the text of the line read to the |
669 | variable $REPLY. ksh93 strips leading and trailing IFS whitespace, | |
670 | so that `read x ; echo "$x"' and `read ; echo "$REPLY"' behave the | |
671 | same way, but I believe that the difference in behaviors is useful | |
672 | enough to not do it. Without the bash behavior, there is no way | |
28ef6c31 JA |
673 | to read a line completely without interpretation or modification |
674 | unless you mess with $IFS (e.g., setting it to the empty string). | |
d166f048 JA |
675 | If you disagree, change the occurrences of `#if 0' to `#if 1' below. */ |
676 | if (list == 0) | |
726f6388 | 677 | { |
d166f048 JA |
678 | #if 0 |
679 | orig_input_string = input_string; | |
7117c2d2 | 680 | for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++) |
d166f048 JA |
681 | ; |
682 | input_string = t; | |
683 | input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape); | |
684 | #endif | |
685 | ||
726f6388 JA |
686 | if (saw_escape) |
687 | { | |
688 | t = dequote_string (input_string); | |
95732b49 | 689 | var = bind_variable ("REPLY", t, 0); |
726f6388 JA |
690 | free (t); |
691 | } | |
692 | else | |
95732b49 | 693 | var = bind_variable ("REPLY", input_string, 0); |
bb70624e | 694 | VUNSETATTR (var, att_invisible); |
28ef6c31 | 695 | |
726f6388 | 696 | free (input_string); |
ccc6cda3 | 697 | return (retval); |
726f6388 | 698 | } |
ccc6cda3 JA |
699 | |
700 | /* This code implements the Posix.2 spec for splitting the words | |
701 | read and assigning them to variables. */ | |
702 | orig_input_string = input_string; | |
703 | ||
704 | /* Remove IFS white space at the beginning of the input string. If | |
705 | $IFS is null, no field splitting is performed. */ | |
7117c2d2 | 706 | for (t = input_string; ifs_chars && *ifs_chars && spctabnl(*t) && isifs(*t); t++) |
ccc6cda3 JA |
707 | ; |
708 | input_string = t; | |
ccc6cda3 | 709 | for (; list->next; list = list->next) |
726f6388 | 710 | { |
ccc6cda3 JA |
711 | varname = list->word->word; |
712 | #if defined (ARRAY_VARS) | |
713 | if (legal_identifier (varname) == 0 && valid_array_reference (varname) == 0) | |
714 | #else | |
715 | if (legal_identifier (varname) == 0) | |
716 | #endif | |
726f6388 | 717 | { |
7117c2d2 | 718 | sh_invalidid (varname); |
f73dda09 | 719 | xfree (orig_input_string); |
ccc6cda3 JA |
720 | return (EXECUTION_FAILURE); |
721 | } | |
726f6388 | 722 | |
ccc6cda3 JA |
723 | /* If there are more variables than words read from the input, |
724 | the remaining variables are set to the empty string. */ | |
725 | if (*input_string) | |
726 | { | |
727 | /* This call updates INPUT_STRING. */ | |
728 | t = get_word_from_string (&input_string, ifs_chars, &e); | |
729 | if (t) | |
730 | *e = '\0'; | |
731 | /* Don't bother to remove the CTLESC unless we added one | |
732 | somewhere while reading the string. */ | |
733 | if (t && saw_escape) | |
726f6388 | 734 | { |
ccc6cda3 JA |
735 | t1 = dequote_string (t); |
736 | var = bind_read_variable (varname, t1); | |
f73dda09 | 737 | xfree (t1); |
726f6388 JA |
738 | } |
739 | else | |
e6a6f478 | 740 | var = bind_read_variable (varname, t ? t : ""); |
ccc6cda3 JA |
741 | } |
742 | else | |
743 | { | |
744 | t = (char *)0; | |
745 | var = bind_read_variable (varname, ""); | |
726f6388 JA |
746 | } |
747 | ||
ccc6cda3 JA |
748 | FREE (t); |
749 | if (var == 0) | |
726f6388 | 750 | { |
f73dda09 | 751 | xfree (orig_input_string); |
726f6388 JA |
752 | return (EXECUTION_FAILURE); |
753 | } | |
754 | ||
ccc6cda3 | 755 | stupidly_hack_special_variables (varname); |
bb70624e | 756 | VUNSETATTR (var, att_invisible); |
ccc6cda3 JA |
757 | } |
758 | ||
759 | /* Now assign the rest of the line to the last variable argument. */ | |
760 | #if defined (ARRAY_VARS) | |
761 | if (legal_identifier (list->word->word) == 0 && valid_array_reference (list->word->word) == 0) | |
762 | #else | |
763 | if (legal_identifier (list->word->word) == 0) | |
764 | #endif | |
765 | { | |
7117c2d2 | 766 | sh_invalidid (list->word->word); |
f73dda09 | 767 | xfree (orig_input_string); |
ccc6cda3 | 768 | return (EXECUTION_FAILURE); |
726f6388 JA |
769 | } |
770 | ||
95732b49 | 771 | #if 0 |
ccc6cda3 JA |
772 | /* This has to be done this way rather than using string_list |
773 | and list_string because Posix.2 says that the last variable gets the | |
774 | remaining words and their intervening separators. */ | |
775 | input_string = strip_trailing_ifs_whitespace (input_string, ifs_chars, saw_escape); | |
95732b49 JA |
776 | #else |
777 | /* Check whether or not the number of fields is exactly the same as the | |
778 | number of variables. */ | |
f1be666c | 779 | tofree = NULL; |
95732b49 JA |
780 | if (*input_string) |
781 | { | |
782 | t1 = input_string; | |
783 | t = get_word_from_string (&input_string, ifs_chars, &e); | |
784 | if (*input_string == 0) | |
f1be666c | 785 | tofree = input_string = t; |
95732b49 | 786 | else |
89a92869 CR |
787 | { |
788 | input_string = strip_trailing_ifs_whitespace (t1, ifs_chars, saw_escape); | |
789 | tofree = t; | |
790 | } | |
95732b49 JA |
791 | } |
792 | #endif | |
ccc6cda3 JA |
793 | |
794 | if (saw_escape) | |
795 | { | |
796 | t = dequote_string (input_string); | |
797 | var = bind_read_variable (list->word->word, t); | |
f73dda09 | 798 | xfree (t); |
ccc6cda3 JA |
799 | } |
800 | else | |
e6a6f478 | 801 | var = bind_read_variable (list->word->word, input_string ? input_string : ""); |
f1be666c | 802 | |
ccc6cda3 | 803 | if (var) |
495aee44 CR |
804 | { |
805 | stupidly_hack_special_variables (list->word->word); | |
806 | VUNSETATTR (var, att_invisible); | |
807 | } | |
808 | else | |
809 | retval = EXECUTION_FAILURE; | |
810 | ||
811 | FREE (tofree); | |
f73dda09 | 812 | xfree (orig_input_string); |
ccc6cda3 | 813 | |
726f6388 JA |
814 | return (retval); |
815 | } | |
816 | ||
ccc6cda3 JA |
817 | static SHELL_VAR * |
818 | bind_read_variable (name, value) | |
819 | char *name, *value; | |
820 | { | |
495aee44 | 821 | SHELL_VAR *v; |
ccc6cda3 JA |
822 | #if defined (ARRAY_VARS) |
823 | if (valid_array_reference (name) == 0) | |
495aee44 | 824 | v = bind_variable (name, value, 0); |
ccc6cda3 | 825 | else |
495aee44 | 826 | v = assign_array_element (name, value, 0); |
f73dda09 | 827 | #else /* !ARRAY_VARS */ |
495aee44 | 828 | v = bind_variable (name, value, 0); |
f73dda09 | 829 | #endif /* !ARRAY_VARS */ |
495aee44 CR |
830 | return (v == 0 ? v |
831 | : ((readonly_p (v) || noassign_p (v)) ? (SHELL_VAR *)NULL : v)); | |
ccc6cda3 JA |
832 | } |
833 | ||
3185942a JA |
834 | #if defined (HANDLE_MULTIBYTE) |
835 | static int | |
836 | read_mbchar (fd, string, ind, ch, unbuffered) | |
837 | int fd; | |
838 | char *string; | |
839 | int ind, ch, unbuffered; | |
840 | { | |
841 | char mbchar[MB_LEN_MAX + 1]; | |
842 | int i, n, r; | |
843 | char c; | |
844 | size_t ret; | |
845 | mbstate_t ps, ps_back; | |
846 | wchar_t wc; | |
847 | ||
848 | memset (&ps, '\0', sizeof (mbstate_t)); | |
849 | memset (&ps_back, '\0', sizeof (mbstate_t)); | |
850 | ||
851 | mbchar[0] = ch; | |
852 | i = 1; | |
853 | for (n = 0; n <= MB_LEN_MAX; n++) | |
854 | { | |
855 | ps_back = ps; | |
856 | ret = mbrtowc (&wc, mbchar, i, &ps); | |
857 | if (ret == (size_t)-2) | |
858 | { | |
859 | ps = ps_back; | |
860 | if (unbuffered) | |
861 | r = zread (fd, &c, 1); | |
862 | else | |
863 | r = zreadc (fd, &c); | |
864 | if (r < 0) | |
865 | goto mbchar_return; | |
866 | mbchar[i++] = c; | |
867 | continue; | |
868 | } | |
869 | else if (ret == (size_t)-1 || ret == (size_t)0 || ret > (size_t)0) | |
870 | break; | |
871 | } | |
872 | ||
873 | mbchar_return: | |
874 | if (i > 1) /* read a multibyte char */ | |
875 | /* mbchar[0] is already string[ind-1] */ | |
876 | for (r = 1; r < i; r++) | |
877 | string[ind+r-1] = mbchar[r]; | |
878 | return i - 1; | |
879 | } | |
880 | #endif | |
881 | ||
882 | ||
883 | static void | |
884 | ttyrestore (ttp) | |
885 | struct ttsave *ttp; | |
886 | { | |
887 | ttsetattr (ttp->fd, ttp->attrs); | |
888 | } | |
889 | ||
ccc6cda3 | 890 | #if defined (READLINE) |
0628567a | 891 | static rl_completion_func_t *old_attempted_completion_function = 0; |
3185942a JA |
892 | static rl_hook_func_t *old_startup_hook; |
893 | static char *deftext; | |
0628567a JA |
894 | |
895 | static void | |
896 | reset_attempted_completion_function (cp) | |
897 | char *cp; | |
898 | { | |
899 | if (rl_attempted_completion_function == 0 && old_attempted_completion_function) | |
900 | rl_attempted_completion_function = old_attempted_completion_function; | |
901 | } | |
7117c2d2 | 902 | |
3185942a JA |
903 | static int |
904 | set_itext () | |
905 | { | |
906 | int r1, r2; | |
907 | ||
908 | r1 = r2 = 0; | |
909 | if (old_startup_hook) | |
910 | r1 = (*old_startup_hook) (); | |
911 | if (deftext) | |
912 | { | |
913 | r2 = rl_insert_text (deftext); | |
914 | deftext = (char *)NULL; | |
915 | rl_startup_hook = old_startup_hook; | |
916 | old_startup_hook = (rl_hook_func_t *)NULL; | |
917 | } | |
918 | return (r1 || r2); | |
919 | } | |
920 | ||
ccc6cda3 | 921 | static char * |
3185942a | 922 | edit_line (p, itext) |
ccc6cda3 | 923 | char *p; |
3185942a | 924 | char *itext; |
726f6388 | 925 | { |
ccc6cda3 JA |
926 | char *ret; |
927 | int len; | |
928 | ||
95732b49 | 929 | if (bash_readline_initialized == 0) |
ccc6cda3 | 930 | initialize_readline (); |
0628567a | 931 | |
7117c2d2 JA |
932 | old_attempted_completion_function = rl_attempted_completion_function; |
933 | rl_attempted_completion_function = (rl_completion_func_t *)NULL; | |
3185942a JA |
934 | if (itext) |
935 | { | |
936 | old_startup_hook = rl_startup_hook; | |
937 | rl_startup_hook = set_itext; | |
938 | deftext = itext; | |
939 | } | |
ccc6cda3 | 940 | ret = readline (p); |
7117c2d2 | 941 | rl_attempted_completion_function = old_attempted_completion_function; |
0628567a JA |
942 | old_attempted_completion_function = (rl_completion_func_t *)NULL; |
943 | ||
ccc6cda3 JA |
944 | if (ret == 0) |
945 | return ret; | |
946 | len = strlen (ret); | |
f73dda09 | 947 | ret = (char *)xrealloc (ret, len + 2); |
bb70624e | 948 | ret[len++] = delim; |
ccc6cda3 JA |
949 | ret[len] = '\0'; |
950 | return ret; | |
726f6388 | 951 | } |
bb70624e JA |
952 | |
953 | static int old_delim_ctype; | |
f73dda09 | 954 | static rl_command_func_t *old_delim_func; |
bb70624e | 955 | static int old_newline_ctype; |
f73dda09 | 956 | static rl_command_func_t *old_newline_func; |
bb70624e | 957 | |
f73dda09 | 958 | static unsigned char delim_char; |
bb70624e JA |
959 | |
960 | static void | |
961 | set_eol_delim (c) | |
962 | int c; | |
963 | { | |
964 | Keymap cmap; | |
965 | ||
966 | if (bash_readline_initialized == 0) | |
967 | initialize_readline (); | |
968 | cmap = rl_get_keymap (); | |
969 | ||
970 | /* Change newline to self-insert */ | |
971 | old_newline_ctype = cmap[RETURN].type; | |
972 | old_newline_func = cmap[RETURN].function; | |
973 | cmap[RETURN].type = ISFUNC; | |
974 | cmap[RETURN].function = rl_insert; | |
975 | ||
976 | /* Bind the delimiter character to accept-line. */ | |
977 | old_delim_ctype = cmap[c].type; | |
978 | old_delim_func = cmap[c].function; | |
979 | cmap[c].type = ISFUNC; | |
980 | cmap[c].function = rl_newline; | |
981 | ||
982 | delim_char = c; | |
983 | } | |
984 | ||
985 | static void | |
f73dda09 JA |
986 | reset_eol_delim (cp) |
987 | char *cp; | |
bb70624e JA |
988 | { |
989 | Keymap cmap; | |
990 | ||
991 | cmap = rl_get_keymap (); | |
992 | ||
993 | cmap[RETURN].type = old_newline_ctype; | |
994 | cmap[RETURN].function = old_newline_func; | |
995 | ||
996 | cmap[delim_char].type = old_delim_ctype; | |
997 | cmap[delim_char].function = old_delim_func; | |
998 | } | |
ccc6cda3 | 999 | #endif |