read  [  -rszpqAclneE ] [ -t [ num ] ] [ -k [ num ] ] [ -d
 [ -u n ] [ name[?prompt] ] [ name ...  ]
       Read  one  line and break it into fields using  the
       $IFS  as  separators,  except  as noted below.  The
       assigned to the first name, the second field to the
       etc.,  with  leftover  fields  assigned to the last
       is omitted then REPLY is used for scalars and reply

       -r     Raw  mode:  a  `'  at the end of a line does
              line continuation  and  backslashes  in  the
              the following character and are not removed.

       -s      Don't  echo back characters if reading from
              Currently does not work with the -q option.

       -q     Read only one character  from  the  terminal
              `y'   if  this  character was `y' or `Y' and
              wise.  With this flag set the return  status
              if  the  character was `y' or `Y'.  This op-
              with a timeout; if the read  times  out,  or
              of   file,  status  2 is returned.  Input is
              terminal unless one of -u or -p is  present.
              may also be used within zle widgets.

       -k [ num ]
              Read   only   one  (or num) characters.  All
              the first  name,  without  word   splitting.
              ignored   when -q is present.  Input is read
              minal unless one of -u  or  -p  is  present.
              also be used within zle widgets.

              Note   that   despite   the   mnemonic `key'
              read full characters, which may  consist  of
              if the option MULTIBYTE is set.

       -z      Read one entry from the editor buffer stack
              to the first  name,  without   word   split-
              pushed   onto   the stack with `print -z' or
              from the  line   editor   (see   zshzle(1)).
              ignored when the -k or -q flags are present.

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

       -A      The  first  name is taken as the name of an
              words are assigned to it.

       -c
       -l     These flags are allowed only if  called  in-
              used  for  completion (specified with the -K
              pctl).  If the -c flag is given,  the  words
              command  are  read. If the -l flag is given,
              is assigned as a scalar.  If both flags  are
              is used and -c is ignored.

       -n     Together with -c, the number of the word the
              is read.  With -l, the index of the  charac-
              is  on  is read.  Note that the command name
              1, not word 0, and that when the  cursor  is
              the   line,   its  character  index  is  the
              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  charac-
              instead of by newline.

       -t [ num ]
              Test if input is available before attempting
              num is present, it must begin with  a  digit
              evaluated   to   give  a  number of seconds,
              floating point number; in this case the read
              input   is   not available within this time.
              present, it is taken to be zero,   so   that
              immediately   if   no   input  is available.
              available, return status 1 and  do  not  set

              This  option  is  not available when reading
              buffer  with  -z, when  called  from  within
              -c  or  -l, with -q which clears  the  input
              reading,  or  within zle where other  mecha-
              used to test for input.

              Note that read does not attempt to alter the
              cessing  mode.   The  default mode is canon-
              which  an  entire line is read at a time, so
              -t'  will not read anything until an  entire
              typed.   However, when reading from the ter-
              input  is processed one key at  a  time;  in
              availability   of  the  first  character  is
              e.g. `read -t -k 2' can still block  on  the
              ter.   Use  two instances of `read -t -k' if
              what is wanted.

       If the first argument contains a `?', the remainder
       is  used  as  a  prompt  on standard error when the
       tive.

       The  value  (exit  status)  of  read is 1  when  an
       encountered,  or  when  -c or -l is present and the
       called  from a compctl function,  or  as  described
       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
       cancels -u, -k cancels -z, and otherwise -z cancels
       -u.

       The -c or -l flags cancel any and all of -kpquz.
