read  [  -rzpqAclneE ] [ -k [ num ] ] [ -un ] [
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.

       -r     Raw  mode:  a  `\' at the end of a line does
              not signify line continuation.

       -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 value is zero only if
              the character was `y'  or  `Y'.   Note  that
              this always reads from the terminal, even if
              used with the -p or -u or -z flags  or  with
              redirected  input.   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 num must be in the  argument  word
              that  follows -k, not in the same word.  See
              -u.

       -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 editor (see zshzle(1)).  This  flag
              is  ignored when the -k or -q flags are pre
              sent.

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

       -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 (spec
              ified  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.  If name is omitted then  REPLY  is
              used for scalars and reply for arrays.

       -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.

       -un    Input  is read from file descriptor n, where
              n is a single digit and must  not  be  sepa
              rated from -u by any whitespace.

       -p     Input is read from the coprocess.

       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 encountered, or when  -c  or  -l  is
       present  and  the command is not called from a com
       pctl 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.
