Miscellaneous
-------------

accept-and-hold (ESC-A ESC-a) (unbound) (unbound)
     Push the contents of the buffer on the buffer stack and execute it.

accept-and-infer-next-history
     Execute the contents of the buffer.  Then search the history list
     for a line matching the current one and push the event following
     onto the buffer stack.

accept-line (^J ^M) (^J ^M) (^J ^M)
     Finish editing the buffer.  Normally this causes the buffer to be
     executed as a shell command.

accept-line-and-down-history (^O) (unbound) (unbound)
     Execute the current line, and push the next history event on the
     the buffer stack.

beep
     Beep, unless the BEEP option is unset.

vi-cmd-mode (^X^V) (unbound) (^[)
     Enter command mode; that is, select the `vicmd' keymap.  Yes, this
     is bound by default in emacs mode.

vi-caps-lock-panic
     Hang until any lowercase key is pressed.  This is for vi users
     without the mental capacity to keep track of their caps lock key
     (like the author).

clear-screen (^L ESC-^L) (^L) (^L)
     Clear the screen and redraw the prompt.

describe-key-briefly
     Reads a key sequence, then prints the function bound to that
     sequence.

exchange-point-and-mark (^X^X) (unbound) (unbound)
     Exchange the cursor position with the position of the mark.

execute-named-cmd (ESC-x) (unbound) (unbound)
     Read the name of an editor command and execute it.  A restricted
     set of editing functions is available in the mini-buffer.  An
     interrupt signal, as defined by the stty setting, will abort the
     function. The allowed functions are: backward-delete-char,
     vi-backward-delete-char, clear-screen, redisplay, quoted-insert,
     vi-quoted-insert, backward-kill-word, vi-backward-kill-word,
     kill-whole-line, vi-kill-line, backward-kill-line, list-choices,
     delete-char-or-list, complete-word, accept-line,
     expand-or-complete and expand-or-complete-prefix.

     kill-region kills the last word, and vi-cmd-mode is treated the
     same as accept-line.  The space and tab characters, if not bound
     to one of these functions, will complete the name and then list the
     possibilities if the AUTO_LIST option is set.  Any other character
     that is not bound to self-insert or self-insert-unmeta will beep
     and be ignored.  The bindings of the current insert mode will be
     used.

execute-last-named-cmd (ESC-z) (unbound) (unbound)
     Redo the last function executed with execute-named-cmd.

get-line (ESC-G ESC-g) (unbound) (unbound)
     Pop the top line off the buffer stack and insert it at the cursor
     position.

pound-insert (unbound) (#) (unbound)
     If there is no # character at the beginning of the buffer, add one
     to the beginning of each line.  If there is one, remove a # from
     each line that has one.  In either case, accept the current line.
     The INTERACTIVE_COMMENTS option must be set for this to have any
     usefulness.

vi-pound-insert
     If there is no # character at the beginning of the current line,
     add one.  If there is one, remove it.  The INTERACTIVE_COMMENTS
     option must be set for this to have any usefulness.

push-input
     Push the entire current multiline construct onto the buffer stack
     and return to the top-level (PS1) prompt.  If the current parser
     construct is only a single line, this is exactly like push-line.
     Next time the editor starts up or is popped with get-line, the
     construct will be popped off the top of the buffer stack and loaded
     into the editing buffer.

push-line (^Q ESC-Q ESC-q) (unbound) (unbound)
     Push the current buffer onto the buffer stack and clear the buffer.
     Next time the editor starts up, the buffer will be popped off the
     top of the buffer stack and loaded into the editing buffer.

push-line-or-edit
     At the top-level (PS1) prompt, equivalent to push-line.  At a
     secondary (PS2) prompt, move the entire current multiline
     construct into the editor buffer.  The latter is equivalent to
     push-input followed by get-line.

redisplay (unbound) (^R) (^R)
     Redisplays the edit buffer.

send-break (^G ESC-^G) (unbound) (unbound)
     Abort the current editor function, e.g. execute-named-command, or
     the editor itself, e.g. if you are in vared. Otherwise abort the
     parsing of the current line.

run-help (ESC-H ESC-h) (unbound) (unbound)
     Push the buffer onto the buffer stack, and execute the command
     `run-help CMD', where CMD is the current command.  run-help is
     normally aliased to man.

vi-set-buffer (unbound) (") (unbound)
     Specify a buffer to be used in the following command.  There are
     35 buffers that can be specified: the 26 `named' buffers "a to "z
     and the nine `queued' buffers "1 to "9.  The named buffers can also
     be specified as "A to "Z.

     When a buffer is specified for a cut command, the text being cut
     replaces the previous contents of the specified buffer.  If a
     named buffer is specified using a capital, the newly cut text is
     appended to the buffer instead of overwriting it.

     If no buffer is specified for a cut command, "1 is used, and the
     contents of "1 to "8 are each shifted along one buffer; the
     contents of "9 is lost.

vi-set-mark (unbound) (m) (unbound)
     Set the specified mark at the cursor position.

set-mark-command (^@) (unbound) (unbound)
     Set the mark at the cursor position.

spell-word (ESC-$ ESC-S ESC-s) (unbound) (unbound)
     Attempt spelling correction on the current word.

undefined-key
     This command is executed when a key sequence that is not bound to
     any command is typed.  By default it beeps.

undo (^_ ^Xu ^X^U) (unbound) (unbound)
     Incrementally undo the last text modification.

redo
     Incrementally redo undone text modifications.

vi-undo-change (unbound) (u) (unbound)
     Undo the last text modification.  If repeated, redo the
     modification.

what-cursor-position (^X=) (unbound) (unbound)
     Print the character under the cursor, its code as an octal,
     decimal and hexadecimal number, the current cursor position within
     the buffer and the column of the cursor in the current line.

where-is
     Read the name of an editor command and and print the listing of key
     sequences that invoke the specified command.

which-command (ESC-?) (unbound) (unbound)
     Push the buffer onto the buffer stack, and execute the command
     `which-command CMD'. where CMD is the current command.
     which-command is normally aliased to WHENCE.

vi-digit-or-beginning-of-line (unbound) (0) (unbound)
     If the last command executed was a digit as part of an argument,
     continue the argument.  Otherwise, execute vi-beginning-of-line.

Completion Widgets
******************

Description
===========

The shell's programmable completion mechanism can be manipulated in two
ways; here the low-level features supporting the newer, function-based
mechanism are defined.  A complete set of shell functions based on these
features is described in the next chapter, see Completion System,
and users with no interest in adding to that system (or, potentially,
writing their own -- see dictionary entry for `hubris') should skip this
section.  The older system based on the compctl builtin command is
described in the chapter Completion Using compctl.

Completion widgets are defined by the -C option to the zle builtin
command provided by the zsh/zle module (see The zsh/zle Module).
For example,

     zle -C complete expand-or-complete completer

defines a widget named `complete'.  The second argument is the name of
any of the builtin widgets that handle completions: complete-word,
expand-or-complete, expand-or-complete-prefix, menu-complete,
menu-expand-or-complete, reverse-menu-complete, list-choices, or
delete-char-or-list.  Note that this will still work even if the widget
in question has been re-bound.

When this newly defined widget is bound to a key using the bindkey
builtin command defined in the zsh/zle module (see Zsh Line Editor),
typing that key will call the shell function `completer'.
This function is responsible for generating the possible matches using
the builtins described below.  As with other ZLE widgets, the function
is called with its standard input closed.

Once the function returns, the completion code takes over control again
and treats the matches in the same manner as the specified builtin
widget, in this case expand-or-complete.

Special Parameters
==================

Inside completion widgets, and any functions called from them, some
parameters have special meaning; outside these functions they are not
special to the shell in any way.  These parameters are used to pass
information between the completion code and the completion widget. Some
of the builtin commands and the condition codes use or change the
current values of these parameters.  Any existing values will be hidden
during execution of completion widgets; except for compstate, the
parameters are reset on each function exit (including nested function
calls from within the completion widget) to the values they had when
the function was entered.

CURRENT
     This is the number of the current word, i.e. the word the cursor is
     currently on in the words array.  Note that this value is only
     correct if the ksharrays option is not set.

IPREFIX
     Initially this will be set to the empty string.  This parameter
     functions like PREFIX; it contains a string which precedes the one
     in PREFIX and is not considered part of the list of matches.
     Typically, a string is transferred from the beginning of PREFIX to
     the end of IPREFIX, for example:

          IPREFIX=${PREFIX%%\=*}=
          PREFIX=${PREFIX#*=}

     causes the part of the prefix up to and including the first equal
     sign not to be treated as part of a matched string.  This can be
     done automatically by the compset builtin, see below.

ISUFFIX
     As IPREFIX, but for a suffix that should not be considered part of
     the matches; note that the ISUFFIX string follows the SUFFIX
     string.

PREFIX
     Initially this will be set to the part of the current word from the
     beginning of the word up to the position of the cursor; it may be
     altered to give a common prefix for all matches.

QIPREFIX
     This parameter is read-only and contains the quoted string up to
     the word being completed. E.g. when completing `"foo', this
     parameter contains the double quote. If the -q option of compset
     is used (see below), and the original string was `"foo bar' with
     the cursor on the `bar', this parameter contains `"foo '.

QISUFFIX
     Like QIPREFIX, but containing the suffix.

SUFFIX
     Initially this will be set to the part of the current word from the
     cursor position to the end; it may be altered to give a common
     suffix for all matches.  It is most useful when the option
     COMPLETE_IN_WORD is set, as otherwise the whole word on the
     command line is treated as a prefix.

compstate
     This is an associative array with various keys and values that the
     completion code uses to exchange information with the completion
     widget.  The keys are:

    all_quotes
          The -q option of the compset builtin command (see below)
          allows a quoted string to be broken into separate words; if
          the cursor is on one of those words, that word will be
          completed, possibly invoking `compset -q' recursively.  With
          this key it is possible to test the types of quoted strings
          which are currently broken into parts in this fashion.  Its
          value contains one character for each quoting level.  The
          characters are a single quote or a double quote for strings
          quoted with these characters and a backslash for strings not
          starting with a quote character.  The first character in the
          value always corresponds to the innermost quoting level.

    context
          This will be set by the completion code to the overall context
          in which completion is attempted. Possible values are:

         array_value
               when completing inside the value of an array parameter
               assignment; in this case the words array contains the
               words inside the parentheses.

         brace_parameter
               when completing the name of a parameter in a parameter
               expansion beginning with ${.

         command
               when completing for a normal command (either in command
               position or for an argument of the command).

         condition
               when completing inside a `[[...]]' conditional
               expression; in this case the words array contains only
               the words inside the conditional expression.

         math
               when completing in a mathematical environment such as a
               `((...))' construct.

         parameter
               when completing the name of a parameter in a parameter
               expansion beginning with $ but not ${.

         redirect
               when completing after a redirection operator.

         subscript
               when completing inside a parameter subscript.

         value
               when completing the value of a parameter assignment.

    exact
          Controls the behaviour when the REC_EXACT option is set.  It
          will be set to accept if an exact match would be accepted,
          and will be unset otherwise.

          If it was set when at least one match equal to the string on
          the line was generated, the match is accepted.

    exact_string
          The string of an exact match if one was found, otherwise
          unset.

    ignored
          The number of words that were ignored because they matched
          one of the patterns given with the -F option to the compadd
          builtin command.

    insert
          This controls the manner in which a match is inserted into
          the command line.  On entry to the widget function, if it is
          unset the command line is not to be changed; if set to
          unambiguous, any prefix common to all matches is to be
          inserted; if set to automenu-unambiguous, the common prefix
          is to be inserted and the next invocation of the completion
          code may start menu completion (due to the AUTO_MENU option
          being set); if set to menu or automenu menu completion will
          be started for the matches currently generated (in the latter
          case this will happen because the AUTO_MENU is set). The
          value may also contain the string `tab' when the completion
          code would normally not really do completion, but only insert
          the TAB character.

          On exit it may be set to any of the values above (where
          setting it to the empty string is the same as unsetting it),
          or to a number, in which case the match whose number is given
          will be inserted into the command line.  Negative numbers
          count backward from the last match (with `-1' selecting the
          last match) and out-of-range values are wrapped around, so
          that a value of zero selects the last match and a value one
          more than the maximum selects the first. Unless the value of
          this key ends in a space, the match is inserted as in a menu
          completion, i.e. without automatically appending a space.

          Both menu and automenu may also specify the the number of the
          match to insert, given after a colon.  For example, `menu:2'
          says to start menu completion, beginning with the second
          match.

          Note that a value containing the substring `tab' makes the
          matches generated be ignored and only the TAB be inserted.

          Finally, it may also be set to all, which makes all matches
          generated be inserted into the line.

    insert_positions
          When the completion system inserts an unambiguous string into
          the line, there may be multiple places where characters are
          missing or where the character inserted differs from at least
          one match.  The value of this key contains a colon separated
          list of all these positions, as indexes into the command line.

    last_prompt
          If this is set to a non-empty string for every match added,
          the completion code will move the cursor back to the previous
          prompt after the list of completions has been displayed.
          Initially this is set or unset according to the
          ALWAYS_LAST_PROMPT option.

    list
          This controls whether or how the list of matches will be
          displayed.  If it is unset or empty they will never be
          listed; if its value begins with list, they will always be
          listed; if it begins with autolist or ambiguous, they will be
          listed when the AUTO_LIST or LIST_AMBIGUOUS options
          respectively would normally cause them to be.

          If the substring force appears in the value, this makes the
          list be shown even if there is only one match. Normally, the
          list would be shown only if there are at least two matches.

          The value contains the substring packed if the LIST_PACKED
          option is set. If this substring is given for all matches
          added to a group, this group will show the LIST_PACKED
          behavior. The same is done for the LIST_ROWS_FIRST option
          with the substring rows.

          Finally, if the value contains the string explanations, only
          the explanation strings, if any, will be listed and if it
          contains messages, only the messages (added with the -x
          option of compadd) will be listed.  If it contains both
          explanations and messages both kinds of explanation strings
          will be listed.  It will be set appropriately on entry to a
          completion widget and may be changed there.

    list_lines
          This gives the number of lines that are needed to display the
          full list of completions.  Note that to calculate the total
          number of lines to display you need to add the number of
          lines needed for the command line to this value, this is
          available as the value of the BUFFERLINES special parameter.

    list_max
          Initially this is set to the value of the LISTMAX parameter.
          It may be set to any other value; when the widget exits this
          value will be used in the same way as the value of LISTMAX.

    nmatches
          The number of matches generated and accepted by the
          completion code so far.

    old_insert
          On entry to the widget this will be set to the number of the
          match of an old list of completions that is currently
          inserted into the command line. If no match has been
          inserted, this is unset.

          As with old_list, the value of this key will only be used if
          it is the string keep. If it was set to this value by the
          widget and there was an old match inserted into the command
          line, this match will be kept and if the value of the insert
          key specifies that another match should be inserted, this
          will be inserted after the old one.

    old_list
          This is set to yes if there is still a valid list of
          completions from a previous completion at the time the widget
          is invoked.  This will usually be the case if and only if the
          previous editing operation was a completion widget or one of
          the builtin completion functions.  If there is a valid list
          and it is also currently shown on the screen, the value of
          this key is shown.

          After the widget has exited the value of this key is only
          used if it was set to keep.  In this case the completion code
          will continue to use this old list.  If the widget generated
          new matches, they will not be used.

    parameter
          The name of the parameter when completing in a subscript or
          in the value of a parameter assignment.

    pattern_insert
          Normally this is set to menu, which specifies that menu
          completion will be used whenever a set of matches was
          generated using pattern matching.  If it is set to any other
          non-empty string by the user and menu completion is not
          selected by other option settings, the code will instead
          insert any common prefix for the generated matches as with
          normal completion.

    pattern_match
          Locally controls the behaviour given by the GLOB_COMPLETE
          option.  Initially it is set to `*' if and only if the option
          is set.  The completion widget may set it to this value, to
          an empty string (which has the same effect as unsetting it),
          or to any other non-empty string.  If it is non-empty,
          unquoted metacharacters on the command line will be treated
          as patterns; if it is `*', then additionally a wildcard `*'
          is assumed at the cursor position; if it is empty or unset,
          metacharacters will be treated literally.

          Note that the matcher specifications given to the compadd
          builtin command are not used if this is set to a non-empty
          string.

    quote
          When completing inside quotes, this contains the quotation
          character (i.e. either a single quote, a double quote, or a
          backtick).  Otherwise it is unset.

    quoting
          When completing inside single quotes, this is set to the
          string single; inside double quotes, the string double;
          inside backticks, the string backtick.  Otherwise it is unset.

    redirect
          The redirection operator when completing in a redirection
          position, i.e. one of <, >, etc.

    restore
          This is set to auto before a function is entered, which
          forces the special parameters mentioned above (words,
          CURRENT, PREFIX, IPREFIX, SUFFIX, and ISUFFIX) to be restored
          to their previous values when the function exits.   If a
          function unsets it or sets it to any other string, they will
          not be restored.

    to_end
          Specifies the occasions on which the cursor is moved to the
          end of a string when a match is inserted.  On entry to a
          widget function, it may be single if this will happen when a
          single unambiguous match was inserted or match if it will
          happen any time a match is inserted (for example, by menu
          completion; this is likely to be the effect of the
          ALWAYS_TO_END option).

          On exit, it may be set to single as above.  It may also be
          set to always, or to the empty string or unset; in those
          cases the cursor will be moved to the end of the string
          always or never respectively.  Any other string is treated as
          match.

    unambiguous
          This key is read-only and will always be set to the common
          (unambiguous) prefix the completion code has generated for
          all matches added so far.

    unambiguous_cursor
          This gives the position the cursor would be placed at if the
          common prefix in the unambiguous key were inserted, relative
          to the value of that key. The cursor would be placed before
          the character whose index is given by this key.

    unambiguous_positions
          This contains all positions where characters in the
          unambiguous string are missing or where the character
          inserted differs from at least one of the matches.  The
          positions are given as indexes into the string given by the
          value of the unambiguous key.

    vared
          If completion is called while editing a line using the vared
          builtin, the value of this key is set to the name of the
          parameter given as an argument to vared.  This key is only
          set while a vared command is active.

words
     This array contains the words present on the command line
     currently being edited.

Builtin Commands
================

compadd [ -akqQfenUl12C ] [ -F ARRAY ]
[ -P PREFIX ] [ -S SUFFIX ]
[ -p HIDDEN-PREFIX ] [ -s HIDDEN-SUFFIX ]
[ -i IGNORED-PREFIX ] [ -I IGNORED-SUFFIX ]
[ -W FILE-PREFIX ] [ -d ARRAY ]
[ -J NAME ] [ -V NAME ] [ -X EXPLANATION ] [ -x MESSAGE ]
[ -r REMOVE-CHARS ] [ -R REMOVE-FUNC ]
[ -D ARRAY ] [ -O ARRAY ] [ -A ARRAY ]
[ -M MATCH-SPEC ] [ - ] [ WORDS ... ]
     This builtin command can be used to add matches directly and
     control all the information the completion code stores with each
     possible match. The return value is zero if at least one match was
     added and non-zero if no matches were added.

     The completion code breaks the string to complete into seven
     fields in the order:

          <IPRE><APRE><HPRE><WORD><HSUF><ASUF><ISUF>

     The first field is an ignored prefix taken from the command line,
     the contents of the IPREFIX parameter plus the string given with
     the -i option. With the -U option, only the string from the -i
     option is used. The field <APRE> is an optional prefix string
     given with the -P option.  The <HPRE> field is a string that is
     considered part of the match but that should not be shown when
     listing completions, given with the -p option; for example,
     functions that do filename generation might specify a common path
     prefix this way.  <WORD> is the part of the match that should
     appear in the list of completions, i.e. one of the WORDS given at
     the end of the compadd command line. The suffixes <HSUF>, <ASUF>
     and <ISUF> correspond to the prefixes <HPRE>, <APRE> and <IPRE>
     and are given by the options -s, -S and -I, respectively.

     The supported flags are:

    -P PREFIX
          This gives a string to be inserted before the given WORDS.
          The string given is not considered as part of the match and
          any shell metacharacters in it will not be quoted when the
          string is inserted.

    -S SUFFIX
          Like -P, but gives a string to be inserted after the match.

    -p HIDDEN-PREFIX
          This gives a string that should be inserted into the command
          line before the match but that should not appear in the list
          of matches. Unless the -U option is given, this string must
          be matched as part of the string on the command line.

    -s HIDDEN-SUFFIX
          Like `-p', but gives a string to insert after the match.

    -i IGNORED-PREFIX
          This gives a string to insert into the command line just
          before any string given with the `-P' option.  Without `-P'
          the string is inserted before the string given with `-p' or
          directly before the match.

    -I IGNORED-SUFFIX
          Like -i, but gives an ignored suffix.

    -a
          With this flag the WORDS are taken as names of arrays and the
          possible matches are their values.  If only some elements of
          the arrays are needed, the WORDS may also contain subscripts,
          as in `foo[2,-1]'.

    -k
          With this flag the WORDS are taken as names of associative
          arrays and the possible matches are their keys.  As for -a,
          the WORDS may also contain subscripts, as in `foo[(R)*bar*]'.

    -d ARRAY
          This adds per-match display strings. The ARRAY should contain
          one element per WORD given. The completion code will then
          display the first element instead of the first WORD, and so
          on. The ARRAY may be given as the name of an array parameter
          or directly as a space-separated list of words in parentheses.

          If there are fewer display strings than WORDS, the leftover
          WORDS will be displayed unchanged and if there are more
          display strings than WORDS, the leftover display strings will
          be silently ignored.

    -l
          This option only has an effect if used together with the -d
          option. If it is given, the display strings are listed one
          per line, not arrayed in columns.

    -J NAME
          Gives the name of the group of matches the words should be
          stored in.

    -V NAME
          Like -J but naming a unsorted group. These are in a different
          name space than groups created with the -J flag.

    -1
          If given together with the -V option, makes only consecutive
          duplicates in the group be removed. If combined with the -J
          option, this has no visible effect. Note that groups with and
          without this flag are in different name spaces.

    -2
          If given together with the -J or -V option, makes all
          duplicates be kept. Again, groups with and without this flag
          are in different name spaces.

    -X EXPLANATION
          The EXPLANATION string will be printed with the list of
          matches, above the group currently selected.

    -x MESSAGE
          Like -X, but the MESSAGE will be printed even if there are no
          matches in the group.

    -q
          The suffix given with -S will be automatically removed if the
          next character typed is a blank or does not insert anything,
          or if the suffix consists of only one character and the next
          character typed is the same character.

    -r REMOVE-CHARS
          This is a more versatile form of the -q option.  The suffix
          given with -S or the slash automatically added after
          completing directories will be automatically removed if the
          next character typed inserts one of the characters given in
          the REMOVE-CHARS.  This string is parsed as a characters
          class and understands the backslash sequences used by the
          print command.  For example, `-r "a-z\t"' removes the suffix
          if the next character typed inserts a lowercase character or
          a TAB, and `-r "^0-9"' removes the suffix if the next
          character typed inserts anything but a digit. One extra
          backslash sequence is understood in this string: `\-' stands
          for all characters that insert nothing. Thus `-S "=" -q' is
          the same as `-S "=" -r "= \t\n\-"'.

    -R REMOVE-FUNC
          This is another form of the -r option. When a suffix has been
          inserted and the completion accepted, the function
          REMOVE-FUNC will be called after the next character typed.
          It is passed the length of the suffix as an argument and can
          use the special parameters available in ordinary
          (non-completion) zle widgets (see Zsh Line Editor) to
          analyse and modify the command line.

    -f
          If this flag is given, all of the matches built from WORDS are
          marked as being the names of files.  They are not required to
          be actual filenames, but if they are, and the option
          LIST_TYPES is set, the characters describing the types of the
          files in the completion lists will be shown. This also forces
          a slash to be added when the name of a directory is completed.

    -e
          This flag can be used to tell the completion code that the
          matches added are parameter names for a parameter expansion.
          This will make the AUTO_PARAM_SLASH and AUTO_PARAM_KEYS
          options be used for the matches.

    -W FILE-PREFIX
          This string is a pathname that will be prepended to each of
          the matches formed by the given WORDS together with any
          prefix specified by the -p option to form a complete filename
          for testing.  Hence it is only useful if combined with the -f
          flag, as the tests will not otherwise be performed.

    -F ARRAY
          Specifies an array containing patterns. Words matching one of
          these patterns are ignored, i.e. not considered to be
          possible matches.

          The ARRAY may be the name of an array parameter or a list of
          literal patterns enclosed in parentheses and quoted, as in
          `-F "(*?.o *?.h)"'. If the name of an array is given, the
          elements of the array are taken as the patterns.

    -Q
          This flag instructs the completion code not to quote any
          metacharacters in the words when inserting them into the
          command line.

    -M MATCH-SPEC
          This gives local match specifications as described below in
          Matching Control. This option may be given more than
          once. In this case all MATCH-SPECs given are concatenated
          with spaces between them to form the specification string to
          use.  Note that they will only be used if the -U option is
          not given.

    -n
          Specifies that the words added are to be used as possible
          matches, but are not to appear in the completion listing.

    -U
          If this flag is given, all words given will be accepted and
          no matching will be done by the completion code. Normally
          this is used in functions that do the matching themselves.

    -O ARRAY
          If this option is given, the WORDS are _not_ added to the set
          of possible completions.  Instead, matching is done as usual
          and all of the WORDS given as arguments that match the string
          on the command line will be stored in the array parameter
          whose name is given as ARRAY.

    -A ARRAY
          As the -O option, except that instead of those of the WORDS
          which match being stored in ARRAY, the strings generated
          internally by the completion code are stored. For example,
          with a matching specification of `-M "L:|no="', the string
          `nof' on the command line and the string `foo' as one of the
          WORDS, this option stores the string `nofoo' in the array,
          whereas the -O option stores the `foo' originally given.

    -D ARRAY
          As with -O, the WORDS are not added to the set of possible
          completions.  Instead, the completion code tests whether each
          WORD in turn matches what is on the line.  If the N'th WORD
          does not match, the N'th element of the ARRAY is removed.
          Elements for which the corresponding WORD is matched are
          retained.

    -C
          This option adds a special match which expands to all other
          matches when inserted into the line, even those that are
          added after this option is used.  Together with the -d option
          it is possible to specify a string that should be displayed
          in the list for this special match.  If no string is given,
          it will be shown as a string containing the strings that
          would be inserted for the other matches, truncated to the
          width of the screen.

    -
    --
          This flag ends the list of flags and options. All arguments
          after it will be taken as the words to use as matches even if
          they begin with hyphens.

     Except for the -M flag, if any of these flags is given more than
     once, the first one (and its argument) will be used.

compset -p NUMBER
compset -P [ NUMBER ] PATTERN
compset -s NUMBER
compset -S [ NUMBER ] PATTERN
compset -n BEGIN [ END ]
compset -N BEG-PAT [ END-PAT ]
compset -q
     This command simplifies modification of the special parameters,
     while its return value allows tests on them to be carried out.

     The options are:

    -p NUMBER
          If the contents of the PREFIX parameter is longer than NUMBER
          characters, the first NUMBER characters are removed from it
          and appended to the contents of the IPREFIX parameter.

    -P [ NUMBER ] PATTERN
          If the value of the PREFIX parameter begins with anything that
          matches the PATTERN, the matched portion is removed from
          PREFIX and appended to IPREFIX.

          Without the optional NUMBER, the longest match is taken, but
          if NUMBER is given, anything up to the NUMBER'th match is
          moved.  If the NUMBER is negative, the NUMBER'th longest
          match is moved. For example, if PREFIX contains the string
          `a=b=c', then compset -P '*\=' will move the string `a=b='
          into the IPREFIX parameter, but compset -P 1 '*\=' will move
          only the string `a='.

    -s NUMBER
          As -p, but transfer the last NUMBER characters from the value
          of SUFFIX to the front of the value of ISUFFIX.

    -S [ NUMBER ] PATTERN
          As -P, but match the last portion of SUFFIX and transfer the
          matched portion to the front of the value of ISUFFIX.

    -n BEGIN [ END ]
          If the current word position as specified by the parameter
          CURRENT is greater than or equal to BEGIN, anything up to the
          BEGIN'th word is removed from the words array and the value
          of the parameter CURRENT is decremented by BEGIN.

          If the optional END is given, the modification is done only if
          the current word position is also less than or equal to END.
          In this case, the words from position END onwards are also
          removed from the words array.

          Both BEGIN and END may be negative to count backwards from
          the last element of the words array.

    -N BEG-PAT [ END-PAT ]
          If one of the elements of the words array before the one at
          the index given by the value of the parameter CURRENT matches
          the pattern BEG-PAT, all elements up to and including the
          matching one are removed from the words array and the value
          of CURRENT is changed to point to the same word in the
          changed array.

          If the optional pattern END-PAT is also given, and there is an
          element in the words array matching this pattern, the
          parameters are modified only if the index of this word is
          higher than the one given by the CURRENT parameter (so that
          the matching word has to be after the cursor). In this case,
          the words starting with the one matching end-pat are also
          removed from the words array. If words contains no word
          matching END-PAT, the testing and modification is performed
          as if it were not given.

    -q
          The word currently being completed is split on spaces into
          separate words, respecting the usual shell quoting
          conventions.  The resulting words are stored in the words
          array, and CURRENT, PREFIX, SUFFIX, QIPREFIX, and QISUFFIX
          are modified to reflect the word part that is completed.

     In all the above cases the return value is zero if the test
     succeeded and the parameters were modified and non-zero otherwise.
     This allows one to use this builtin in tests such as:

          if compset -P '*\='; then ...

     This forces anything up to and including the last equal sign to be
     ignored by the completion code.

compcall [ -TD ]
     This allows the use of completions defined with the compctl builtin
     from within completion widgets.  The list of matches will be
     generated as if one of the non-widget completion function
     (complete-word, etc.)  had been called, except that only compctls
     given for specific commands are used. To force the code to try
     completions defined with the -T option of compctl and/or the
     default completion (whether defined by compctl -D or the builtin
     default) in the appropriate places, the -T and/or -D flags can be
     passed to compcall.

     The return value can be used to test if a matching compctl
     definition was found. It is non-zero if a compctl was found and
     zero otherwise.

     Note that this builtin is defined by the zsh/compctl module.

Condition Codes
===============

The following additional condition codes for use within the [[ ... ]]
construct are available in completion widgets.  These work on the
special parameters.  All of these tests can also be performed by the
compset builtin, but in the case of the condition codes the contents of
the special parameters are not modified.

-prefix [ NUMBER ] PATTERN
     true if the test for the -P option of compset would succeed.

-suffix [ NUMBER ] PATTERN
     true if the test for the -S option of compset would succeed.

-after BEG-PAT
     true if the test of the -N option with only the BEG-PAT given
     would succeed.

-between BEG-PAT END-PAT
     true if the test for the -N option with both patterns would
     succeed.