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.
