read  [  -rszpqAclneE ] [ -t [ num ] ] [ -k [ num ] ] [ -d
delim ]
 [ -u n ] [ 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.

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

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

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

       -u n   Input is read from file descriptor n.

       -p     Input is read from the coprocess.

       -d delim
              Input is terminated by the  first  character
              of delim instead of by newline.

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

              This  option  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 read-
              ing,  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 input is processed one  key
              at  a  time; in this case, only availability
              of the first character is  tested,  so  that
              e.g.  `read  -t -k 2' can still block on the
              second  character.   Use  two  instances  of
              `read  -t -k' if this is not what is wanted.
              If the first argument contains  a  `?',  the
              remainder  of  this word is used as a prompt
              on standard error when the shell is interac-
              tive.

       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.
