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' other-
              wise.  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  ter-
              minal 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 out-
              put.  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 com-
              pctl).  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 whites-
              pace.

       -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  pro-
              cessing  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 availabil-
              ity 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.   Other-
       wise 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.
