read [ -rzpqAclneEt ] [ -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.  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
              following character and are not removed.

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

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

       -p     Input is read from the coprocess.

       -t     Test if input is available before attempting
              to read; if none is, return status 1 and  do
              not   set   any   variables.   This  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 entire 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  this  is  automatically
              handled; note that only availability of  the
              first  character  is  tested,  so  that e.g.
              `read -t -k 2' can still block on the second
              character.  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
       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.
