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  to
`n'  other-

              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  are
              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'   this
              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
              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  length
              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  char-
              instead of by newline.

       -t [ num ]
              Test if input is available before attempting
              num  is  present,  it must begin with a dig-
              evaluated  to  give  a  number  of  seconds,
              floating point number; in this case the read
              input is not available within this time.  If
              present,  it  is  taken  to be zero, so that
              immediately if no input is  available.    If
              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
              cessing  mode.  The default mode is  canoni-
              which  an entire line is read at a time,  so
              -t'  will  not read anything until an entire
              typed.   However,   when  reading  from  the
              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'
              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 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
       cancels  -u, -k cancels -z, and otherwise  -z  can-
       -u.

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