builtins/read.def

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