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  back-
              slashes  in the line don't quote the follow-
              ing 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 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.

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

       -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  avail-
              able  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  han-
              dled;  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 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.
