read [ -rszpqAclneE ] [ -t [ num ] ] [ -k [ num ] ] [ -d delim ]
     [ -u n ] [ [name][?prompt] ] [ name ...  ]
       Read  one line and break it into fields using the characters in $IFS
       as separators, except as noted below.  The first field  is  assigned
       to  the  first name, the second field to the second name, etc., with
       leftover fields assigned to the last name.  If name is omitted  then
       REPLY is used for scalars and reply for arrays.

       -r     Raw  mode:  a  `\' at the end of a line does not signify line
              continuation and backslashes in the line don't quote the fol-
              lowing character and are not removed.

       -s     Don't echo back characters if reading from the terminal.

       -q     Read only one character from the terminal and set name to `y'
              if this character was `y' or `Y' and to `n' otherwise.   With
              this flag set the return status is zero only if the character
              was  `y' or `Y'.  This option may be used with a timeout (see
              -t); if the read times out, or encounters end of file, status
              2 is returned.  Input is read from the terminal unless one of
              -u or -p is present.  This option may also be used within zle
              widgets.

       -k [ num ]
              Read only one (or num) characters.  All are assigned  to  the
              first  name,  without  word  splitting.  This flag is ignored
              when -q is present.  Input is read from the  terminal  unless
              one  of  -u  or  -p is present.  This option may also be used
              within zle widgets.

              Note that despite the mnemonic `key' this  option  does  read
              full  characters,  which may consist of multiple bytes if the
              option MULTIBYTE is set.

       -z     Read one entry from the editor buffer stack and assign it  to
              the  first name, without word splitting.  Text is pushed onto
              the stack with `print -z' or with push-line from the line ed-
              itor (see zshzle(1)).  This flag is ignored when the -k or -q
              flags are present.

       -e
       -E     The input read is printed (echoed) to  the  standard  output.
              If  the  -e flag is used, no input is assigned to the parame-
              ters.

       -A     The first name is taken as the name of an array and all words
              are assigned to it.

       -c
       -l     These flags are allowed only if called inside a function used
              for completion (specified with the -K flag to  compctl).   If
              the  -c  flag  is given, the words of the current command are
              read. If the -l flag is given, the whole line is assigned  as
              a  scalar.   If  both flags are present, -l is used and -c is
              ignored.

       -n     Together with -c, the number of the word the cursor is on  is
              read.   With  -l, the index of the character the cursor is on
              is read.  Note that the command name is word  number  1,  not
              word  0,  and that when the cursor is at the end of the line,
              its character index is the length of the line plus one.

       -u n   Input is read from file descriptor n.

       -p     Input is read from the coprocess.

       -d delim
              Input is terminated by the first character of  delim  instead
              of by newline.

       -t [ num ]
              Test if input is available before attempting to read.  If num
              is  present, it must begin with a digit and will be evaluated
              to give a number of seconds, which may be  a  floating  point
              number;  in  this  case  the  read  times out if input is not
              available within this time.  If num is  not  present,  it  is
              taken  to be zero, so that read returns immediately if no in-
              put is available.  If no input is available, return status  1
              and do not set any variables.

              This  option  is  not  available when reading from the editor
              buffer with -z, when called from within completion with -c or
              -l, with -q which clears the input queue before  reading,  or
              within  zle where other mechanisms should be used to test for
              input.

              Note that read does not attempt to alter the input processing
              mode.  The default mode is canonical input, in which  an  en-
              tire  line  is  read at a time, so usually `read -t' will not
              read anything until an entire line has been typed.   However,
              when reading from the terminal with -k input is processed one
              key  at  a time; in this case, only availability of the first
              character is tested, so that e.g. `read -t -k  2'  can  still
              block on the second character.  Use two instances of `read -t
              -k' if this is not what is wanted.

       If  the first argument contains a `?', the remainder of this word is
       used as a prompt on standard error when the shell is interactive.

       The value (exit status) of read is 1 when an end-of-file is  encoun-
       tered,  or  when  -c  or -l is present and the command is not called
       from a compctl function, or as  described  for  -q.   Otherwise  the
       value is 0.

       The behavior of some combinations of the -k, -p, -q, -u and -z flags
       is  undefined.   Presently -q cancels all the others, -p cancels -u,
       -k cancels -z, and otherwise -z cancels both -p and -u.

       The -c or -l flags cancel any and all of -kpquz.
