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.
