Manual Pages for UNIX Darwin command on man zshcompsys

ZSHCOMPSYS(1) ZSHCOMPSYS(1)

NAME

zshcompsys - zsh completion system

DESCRIPTION

This describes the shell code for the new completion system. It con-

sists of various shell functions; those beginning `ccoommpp' are to be called directly, while those beginning `' are called by the completion

code. The shell functions of the second set, which implement comple-

tion behaviour and may be bound to keystrokes, are referred to as `wid-

gets'. IINNIITTIIAALLIIZZAATTIIOONN If the system was installed completely, it should be enough to call the shell function ccoommppiinniitt from your initialization file; see the next section. However, the function ccoommppiinnssttaallll can be run by a user to configure various aspects of the completion system. Usually, ccoommppiinnssttaallll will insert code into ..zzsshhrrcc, although if that is not writable it will save it in another file and tell you that file's location. Note that it is up to you to make sure that the lines added to ..zzsshhrrcc are actually run; you may, for example, need to move them to an earlier place in the file if ..zzsshhrrcc usually returns early. So long as you keep them all together (including the comment lines at the start and finish), you can rerun ccoommppiinnssttaallll and it will correctly locate and

modify these lines. Note, however, that any code you add to this sec-

tion by hand is likely to be lost if you rerun ccoommppiinnssttaallll, although lines using the command `zzssttyyllee' should be gracefully handled. The new code will take effect next time you start the shell, or run

..zzsshhrrcc by hand; there is also an option to make them take effect imme-

diately. However, if ccoommppiinnssttaallll has removed definitions, you will need to restart the shell to see the changes.

To run ccoommppiinnssttaallll you will need to make sure it is in a directory men-

tioned in your ffppaatthh parameter, which should already be the case if zsh was properly configured as long as your startup files do not remove the appropriate directories from ffppaatthh. Then it must be autoloaded

(`aauuttoollooaadd -UU ccoommppiinnssttaallll' is recommended). You can abort the instal-

lation any time you are being prompted for information, and your ..zzsshhrrcc will not be altered at all; changes only take place right at the end, where you are specifically asked for confirmation. UUssee ooff ccoommppiinniitt This section describes the use of ccoommppiinniitt to initialize completion for the current session when called directly; if you have run ccoommppiinnssttaallll it will be called automatically from your ..zzsshhrrcc.

To initialize the system, the function ccoommppiinniitt should be in a direc-

tory mentioned in the ffppaatthh parameter, and should be autoloaded

(`aauuttoollooaadd -UU ccoommppiinniitt' is recommended), and then run simply as

`ccoommppiinniitt'. This will define a few utility functions, arrange for all

the necessary shell functions to be autoloaded, and will then re-define

all widgets that do completion to use the new system. If you use the

mmeennuu-sseelleecctt widget, which is part of the zzsshh//ccoommpplliisstt module, you

should make sure that that module is loaded before the call to ccoommppiinniitt

so that that widget is also re-defined. If completion styles (see

below) are set up to perform expansion as well as completion by

default, and the TAB key is bound to eexxppaanndd-oorr-ccoommpplleettee, ccoommppiinniitt will

rebind it to ccoommpplleettee-wwoorrdd; this is necessary to use the correct form

of expansion. Should you need to use the original completion commands, you can still bind keys to the old widgets by putting a `..' in front of the widget

name, e.g. `..eexxppaanndd-oorr-ccoommpplleettee'.

To speed up the running of ccoommppiinniitt, it can be made to produce a dumped configuration that will be read in on future invocations; this is the

default, but can be turned off by calling ccoommppiinniitt with the option -DD.

The dumped file is ..zzccoommppdduummpp in the same directory as the startup

files (i.e. $$ZZDDOOTTDDIIRR or $$HHOOMMEE); alternatively, an explicit file name

can be given by `ccoommppiinniitt -dd dumpfile'. The next invocation of

ccoommppiinniitt will read the dumped file instead of performing a full ini-

tialization. If the number of completion files changes, ccoommppiinniitt will recognise this and produce a new dump file. However, if the name of a function or the

arguments in the first line of a ##ccoommppddeeff function (as described below)

change, it is easiest to delete the dump file by hand so that ccoommppiinniitt

will re-create it the next time it is run. The check performed to see

if there are new functions can be omitted by giving the option -CC. In

this case the dump file will only be created if there isn't one already. The dumping is actually done by another function, ccoommppdduummpp, but you will only need to run this yourself if you change the configuration (e.g. using ccoommppddeeff) and then want to dump the new one. The name of the old dumped file will be remembered for this purpose. If the parameter ccoommppddiirr is set, ccoommppiinniitt uses it as a directory where completion functions can be found; this is only necessary if they are not already in the function search path. For security reasons ccoommppiinniitt also checks if the completion system would use files not owned by root or by the current user, or files in

directories that are world- or group-writable or that are not owned by

root or by the current user. If such files or directories are found, ccoommppiinniitt will ask if the completion system should really be used. To avoid these tests and make all files found be used without asking, use

the option -uu, and to make ccoommppiinniitt silently ignore all insecure files

and directories use the option -ii. This security check is skipped

entirely when the -CC option is given.

The security check can be retried at any time by running the function ccoommppaauuddiitt. This is the same check used by ccoommppiinniitt, but when it is executed directly any changes to ffppaatthh are made local to the function so they do not persist. The directories to be checked may be passed as arguments; if none are given, ccoommppaauuddiitt uses ffppaatthh and ccoommppddiirr to find

completion system directories, adding missing ones to ffppaatthh as neces-

sary. To force a check of exactly the directories currently named in ffppaatthh, set ccoommppddiirr to an empty string before calling ccoommppaauuddiitt or ccoommppiinniitt. AAuuttoollooaaddeedd ffiilleess The convention for autoloaded functions used in completion is that they

start with an underscore; as already mentioned, the ffppaatthh//FFPPAATTHH parame-

ter must contain the directory in which they are stored. If zzsshh was

properly installed on your system, then ffppaatthh//FFPPAATTHH automatically con-

tains the required directories for the standard functions. For incomplete installations, if ccoommppiinniitt does not find enough files beginning with an underscore (fewer than twenty) in the search path, it will try to find more by adding the directory ccoommppddiirr to the search

path. If that directory has a subdirectory named BBaassee, all subdirecto-

ries will be added to the path. Furthermore, if the subdirectory BBaassee has a subdirectory named CCoorree, ccoommppiinniitt will add all subdirectories of the subdirectories is to the path: this allows the functions to be in the same format as in the zzsshh source distribution. When ccoommppiinniitt is run, it searches all such files accessible via ffppaatthh//FFPPAATTHH and reads the first line of each of them. This line should contain one of the tags described below. Files whose first line does not start with one of these tags are not considered to be part of the completion system and will not be treated specially. The tags are:

##ccoommppddeeff names... [ -[[ppPP]] patterns... [ -NN names... ] ]

The file will be made autoloadable and the function defined in it will be called when completing names, each of which is either the name of a command whose arguments are to be completed or one

of a number of special contexts in the form -context- described

below.

Each name may also be of the form `cmd==service'. When complet-

ing the command cmd, the function typically behaves as if the command (or special context) service was being completed

instead. This provides a way of altering the behaviour of func-

tions that can perform many different completions. It is imple-

mented by setting the parameter $$sseerrvviiccee when calling the func-

tion; the function may choose to interpret this how it wishes, and simpler functions will probably ignore it.

If the ##ccoommppddeeff line contains one of the options -pp or -PP, the

words following are taken to be patterns. The function will be called when completion is attempted for a command or context

that matches one of the patterns. The options -pp and -PP are

used to specify patterns to be tried before or after other com-

pletions respectively. Hence -PP may be used to specify default

actions.

The option -NN is used after a list following -pp or -PP; it speci-

fies that remaining words no longer define patterns. It is pos-

sible to toggle between the three options as many times as nec-

essary.

##ccoommppddeeff -kk style key-sequences...

This option creates a widget behaving like the builtin widget

style and binds it to the given key-sequences, if any. The

style must be one of the builtin widgets that perform comple-

tion, namely ccoommpplleettee-wwoorrdd, ddeelleettee-cchhaarr-oorr-lliisstt, eexxppaanndd-oorr-ccoomm-

pplleettee, eexxppaanndd-oorr-ccoommpplleettee-pprreeffiixx, lliisstt-cchhooiicceess, mmeennuu-ccoommpplleettee,

mmeennuu-eexxppaanndd-oorr-ccoommpplleettee, or rreevveerrssee-mmeennuu-ccoommpplleettee. If the

zzsshh//ccoommpplliisstt module is loaded (see zshmodules(1)) the widget

mmeennuu-sseelleecctt is also available.

When one of the key-sequences is typed, the function in the file

will be invoked to generate the matches. Note that a key will

not be re-bound if if it already was (that is, was bound to

something other than uunnddeeffiinneedd-kkeeyy). The widget created has the

same name as the file and can be bound to any other keys using bbiinnddkkeeyy as usual.

##ccoommppddeeff -KK widget-name style key-sequences ...

This is similar to -kk except that only one key-sequences argu-

ment may be given for each widget-name style pair. However, the

entire set of three arguments may be repeated with a different

set of arguments. Note in particular that the widget-name must

be distinct in each set. If it does not begin with `' this

will be added. The widget-name should not clash with the name

of any existing widget: names based on the name of the function are most useful. For example,

##ccoommppddeeff -KK ffooooccoommpplleettee ccoommpplleettee-wwoorrdd ""^^XX^^CC"" \\

ffoooolliisstt lliisstt-cchhooiicceess ""^^XX^^DD""

(all on one line) defines a widget ffooooccoommpplleettee for completion, bound to `^^XX^^CC', and a widget ffoooolliisstt for listing, bound to `^^XX^^DD'.

##aauuttoollooaadd [ options ]

Functions with the ##aauuttoollooaadd tag are marked for autoloading but

are not otherwise treated specially. Typically they are to be called from within one of the completion functions. Any options supplied will be passed to the aauuttoollooaadd builtin; a typical use is ++XX to force the function to be loaded immediately. Note that

the -UU and -zz flags are always added implicitly.

The ## is part of the tag name and no white space is allowed after it.

The ##ccoommppddeeff tags use the ccoommppddeeff function described below; the main

difference is that the name of the function is supplied implicitly. The special contexts for which completion functions can be defined are:

-aarrrraayy-vvaalluuee-

The right hand side of an array-assignment (`ffoooo==((......))')

-bbrraaccee-ppaarraammeetteerr-

The name of a parameter expansion within braces (`$${{......}}')

-aassssiiggnn-ppaarraammeetteerr-

The name of a parameter in an assignment, i.e. on the left hand side of an `=='

-ccoommmmaanndd-

A word in command position

-ccoonnddiittiioonn-

A word inside a condition (`[[[[......]]]]')

-ddeeffaauulltt-

Any word for which no other completion is defined

-eeqquuaall-

A word beginning with an equals sign

-ffiirrsstt-

This is tried before any other completion function. The func-

tion called may set the ccoommppsskkiipp parameter to one of various

values: aallll: no further completion is attempted; a string con-

taining the substring ppaatttteerrnnss: no pattern completion functions will be called; a string containing ddeeffaauulltt: the function for

the `-ddeeffaauulltt-' context will not be called, but functions

defined for commands will

-mmaatthh- Inside mathematical contexts, such as `((((...))))'

-ppaarraammeetteerr-

The name of a parameter expansion (`$$......')

-rreeddiirreecctt-

The word after a redirection operator.

-ssuubbssccrriipptt-

The contents of a parameter subscript.

-ttiillddee-

After an initial tilde (`~~'), but before the first slash in the word.

-vvaalluuee-

On the right hand side of an assignment. Default implementations are supplied for each of these contexts. In

most cases the context -context- is implemented by a corresponding

function context, for example the context `-ttiillddee-' and the function

`ttiillddee').

The contexts -rreeddiirreecctt- and -vvaalluuee- allow extra context-specific infor-

mation. (Internally, this is handled by the functions for each context

calling the function ddiissppaattcchh.) The extra information is added sepa-

rated by commas.

For the -rreeddiirreecctt- context, the extra information is in the form `-rree-

ddiirreecctt-,,op,,command', where op is the redirection operator and command

is the name of the command on the line. If there is no command on the line yet, the command field will be empty.

For the -vvaalluuee- context, the form is `-vvaalluuee-,,name,,command', where name

is the name of the parameter. In the case of elements of an associa-

tive array, for example `aassssoocc==((kkeeyy <>', name is expanded to

`name-key'. In certain special contexts, such as completing after

`mmaakkee CCFFLLAAGGSS==', the command part gives the name of the command, here mmaakkee; otherwise it is empty.

It is not necessary to define fully specific completions as the func-

tions provided will try to generate completions by progressively

replacing the elements with `-ddeeffaauulltt-'. For example, when completing

after `ffoooo==<>', vvaalluuee will try the names `-vvaalluuee-,,ffoooo,,' (note the

empty command part), `-vvaalluuee-,,ffoooo,,-ddeeffaauulltt-'

and`-vvaalluuee-,,-ddeeffaauulltt-,,-ddeeffaauulltt-', in that order, until it finds a func-

tion to handle the context. As an example:

ccoommppddeeff ''ffiilleess -gg ""**..lloogg""'' ''-rreeddiirreecctt-,,22>>,,-ddeeffaauulltt-''

completes files matching `**..lloogg' after `22>> <>' for any command with no more specific handler defined. Also:

ccoommppddeeff ffoooo -vvaalluuee-,,-ddeeffaauulltt-,,-ddeeffaauulltt-

specifies that ffoooo provides completions for the values of parameters

for which no special function has been defined. This is usually han-

dled by the function vvaalluuee itself. The same lookup rules are used when looking up styles (as described below); for example

zzssttyyllee ''::ccoommpplleettiioonn::**::**::-rreeddiirreecctt-,,22>>,,**::**'' ffiillee-ppaatttteerrnnss ''**..lloogg''

is another way to make completion after `22>> <>' complete files matching `**..lloogg'. FFuunnccttiioonnss The following function is defined by ccoommppiinniitt and may be called directly.

ccoommppddeeff [ -aann ] function names... [ -[[ppPP]] patterns... [ -NN names... ] ]

ccoommppddeeff -dd names...

ccoommppddeeff -kk [ -aann ] function style key-sequences...

ccoommppddeeff -KK [ -aann ] function name style key-sequences ...

The first form defines the function to call for completion in

the given contexts as described for the ##ccoommppddeeff tag above.

Alternatively, all the arguments may have the form `cmd==ser-

vice'. Here service should already have been defined by

`cmd1==service' lines in ##ccoommppddeeff files, as described above. The

argument for cmd will be completed in the same way as service. The function argument may alternatively be a string containing any shell code. The string will be executed using the eevvaall builtin command to generate completions. This provides a way of

avoiding having to define a new completion function. For exam-

ple, to complete files ending in `..hh' as arguments to the com-

mand ffoooo:

ccoommppddeeff ''ffiilleess -gg ""**..hh""'' ffoooo

The option -nn prevents any completions already defined for the

command or context from being overwritten.

The option -dd deletes any completion defined for the command or

contexts listed.

The names may also contain -pp, -PP and -NN options as described

for the ##ccoommppddeeff tag. The effect on the argument list is iden-

tical, switching between definitions of patterns tried ini-

tially, patterns tried finally, and normal commands and con-

texts.

The parameter $$ccoommppsskkiipp may be set by any function defined for

a pattern context. If it is set to a value containing the sub-

string `ppaatttteerrnnss' none of the pattern-functions will be called;

if it is set to a value containing the substring `aallll', no other function will be called.

The form with -kk defines a widget with the same name as the

function that will be called for each of the key-sequences; this

is like the ##ccoommppddeeff -kk tag. The function should generate the

completions needed and will otherwise behave like the builtin widget whose name is given as the style argument. The widgets

usable for this are: ccoommpplleettee-wwoorrdd, ddeelleettee-cchhaarr-oorr-lliisstt,

eexxppaanndd-oorr-ccoommpplleettee, eexxppaanndd-oorr-ccoommpplleettee-pprreeffiixx, lliisstt-cchhooiicceess,

mmeennuu-ccoommpplleettee, mmeennuu-eexxppaanndd-oorr-ccoommpplleettee, and rreevveerrssee-mmeennuu-ccoomm-

pplleettee, as well as mmeennuu-sseelleecctt if the zzsshh//ccoommpplliisstt module is

loaded. The option -nn prevents the key being bound if it is

already to bound to something other than uunnddeeffiinneedd-kkeeyy.

The form with -KK is similar and defines multiple widgets based

on the same function, each of which requires the set of three

arguments name, style and key-sequences, where the latter two

are as for -kk and the first must be a unique widget name begin-

ning with an underscore.

Wherever applicable, the -aa option makes the function autoload-

able, equivalent to aauuttoollooaadd -UU function.

The function ccoommppddeeff can be used to associate existing completion func-

tions with new commands. For example, ccoommppddeeff ppiiddss ffoooo uses the function ppiiddss to complete process IDs for the command ffoooo. Note also the ggnnuuggeenneerriicc function described below, which can be used

to complete options for commands that understand the `--hheellpp' option.

CCOOMMPPLLEETTIIOONN SSYYSSTTEEMM CCOONNFFIIGGUURRAATTIIOONN This section gives a short overview of how the completion system works, and then more detail on how users can configure how and when matches are generated. OOvveerrvviieeww

When completion is attempted somewhere on the command line the comple-

tion system first works out the context. This takes account of a num-

ber of things including the command word (such as `ggrreepp' or `zzsshh') and

options to which the current word may be an argument (such as the `-oo'

option to zzsshh which takes a shell option as an argument).

This context information is condensed into a string consisting of mul-

tiple fields separated by colons, referred to simply as `the context' in the remainder of the documentation. This is used to look up styles,

context-sensitive options that can be used to configure the completion

system. The context used for lookup may vary during the same call to the completion system. The context string always consists of the following fields, separated by colons and with a leading colon before the first: +o The literal string ccoommpplleettiioonn, saying that this style is used by the completion system. This distinguishes the context from those used by, for example, zle widgets and ZFTP functions. +o The function, if completion is called from a named widget rather than through the normal completion system. Typically this is

blank, but it is set by special widgets such as pprreeddiicctt-oonn and

the various functions in the WWiiddggeett directory of the distribu-

tion to the name of that function, often in an abbreviated form. +o The completer currently active, the name of the function without the leading underscore. A `completer' is in overall control of how completion is to be performed; `ccoommpplleettee' is the simplest,

but other completers exist to perform related tasks such as cor-

rection, or to modify the behaviour of a later completer. See the section `Control Functions' below for more information.

+o The command or a special -context-, just at it appears following

the ##ccoommppddeeff tag or the ccoommppddeeff function. Completion functions

for commands that have sub-commands usually modify this field to

contain the name of the command followed by a minus sign and the

sub-command. For example, the completion function for the ccvvss

command sets this field to ccvvss-aadddd when completing arguments to

the aadddd subcommand.

+o The argument; this indicates which command line or option argu-

ment we are completing. For command arguments this generally

takes the form aarrgguummeenntt-n, where n is the number of the argu-

ment, and for arguments to options the form ooppttiioonn-opt-n where n

is the number of the argument to option opt. However, this is only the case if the command line is parsed with standard

UNIX-style options and arguments, so many completions do not set

this. +o The tag. Tags are used to discriminate between the types of matches a completion function can generate in a certain context and are described further below. As an example, the context name

::ccoommpplleettiioonn::::ccoommpplleettee::ddvviippss::ooppttiioonn-oo-11::ffiilleess

says that normal completion was attempted as the first argument to the

option -oo of the command ddvviippss:

ddvviippss -oo ......

and the completion function will generate filenames. Each type of completion the system can perform in a given context is described by a `tag', a short descriptive string such as ffiilleess in the example above. Any completion function may use any tag name it likes, but a list of the more common ones is given below. Usually completion will be tried by all possible tags in an order given by the completion function. However, this can be altered by using the

ttaagg-oorrddeerr style. Completion is then restricted to the list of given

tags in the given order. The ccoommpplleetteehheellpp bindable command shows all the contexts and tags available for completion at a particular point. This provides an easy

way of finding information for ttaagg-oorrddeerr and other styles. It is

described in the section `Bindable Commands' below.

Styles determine such things as how the matches are generated, simi-

larly to shell options but with much more control. They can have any number of strings as their value. They are defined with the zzssttyyllee builtin command (see zshmodules(1)). When looking up styles the completion system uses full context names, including the tag. Looking up the value of a style therefore consists of two things: the context, which may be matched as a pattern, and the name of the style itself, which must be given exactly. For example, many completion functions can generate matches in a simple and a verbose form and use the vveerrbboossee style to decide which form should be used. To make all such functions use the verbose form, put zzssttyyllee ''::ccoommpplleettiioonn::**'' vveerrbboossee yyeess in a startup file (probably ..zzsshhrrcc). This gives the vveerrbboossee style the value yyeess in every context inside the completion system, unless that context has a more specific definition. It is best to avoid giving the

context as `**' in case the style has some meaning outside the comple-

tion system. Many such general purpose styles can be configured simply by using the ccoommppiinnssttaallll function.

A more specific example of the use of the vveerrbboossee style is by the com-

pletion for the kkiillll builtin. If the style is set, the builtin lists full job texts and process command lines; otherwise it shows the bare job numbers and PIDs. To turn the style off for this use only: zzssttyyllee ''::ccoommpplleettiioonn::**::**::kkiillll::**'' vveerrbboossee nnoo For even more control, the style can use one of the tags `jjoobbss' or `pprroocceesssseess'. To turn off verbose display only for jobs: zzssttyyllee ''::ccoommpplleettiioonn::**::**::kkiillll::**::jjoobbss'' vveerrbboossee nnoo

The -ee option to zzssttyyllee even allows completion function code to appear

as the argument to a style; this requires some understanding of the

internals of completion functions (see see zshcompwid(1))). For exam-

ple:

zzssttyyllee -ee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ''

iiff [[[[ $$wwoorrddss[[11]] == ccvvss ]]]];; tthheenn

rreeppllyy==((ccoommpplleettee)) eellssee rreeppllyy==((ccoommpplleettee aapppprrooxxiimmaattee)) ffii'' uses the value `ccoommpplleettee' for the ccoommpplleetteerr style in most contexts,

but the value `ccoommpplleettee aapppprrooxxiimmaattee' when the first word on the com-

mand line is `ccvvss'. This is probably more conveniently done by speci-

fying the style for two different contexts. This form can be slow and should be avoided for commonly examined styles such as mmeennuu and

lliisstt-rroowwss-ffiirrsstt.

Note that the order in which styles are defined does not matter; the style mechanism uses the most specific possible match for a particular

style to determine the set of values. More precisely, strings are pre-

ferred over patterns (for example, `::ccoommpplleettiioonn::::ccoommpplleettee::ffoooo' is more

specific than `::ccoommpplleettiioonn::::ccoommpplleettee::**''), and longer patterns are pre-

ferred over shorter patterns.

Style names like those of tags are arbitrary and depend on the comple-

tion function. However, the following two sections list some of the most common tags and styles. SSttaannddaarrdd TTaaggss Some of the following are only used when looking up particular styles and do not refer to a type of match. aaccccoouunnttss

used to look up the uusseerrss-hhoossttss style

aallll-eexxppaannssiioonnss

used by the eexxppaanndd completer when adding the single string con-

taining all possible expansions

aallll-ffiilleess

for the names of all files (as distinct from a particular sub-

set, see the gglloobbbbeedd-ffiilleess tag).

aarrgguummeennttss for arguments to a command aarrrraayyss for names of array parameters

aassssoocciiaattiioonn-kkeeyyss

for keys of associative arrays; used when completing inside a subscript to a parameter of this type bbooookkmmaarrkkss when completing bookmarks (e.g. for URLs and the zzffttpp function suite) bbuuiillttiinnss for names of builtin commands cchhaarraacctteerrss for single characters in arguments of commands such as ssttttyy. Also used when completing character classes after an opening bracket ccoolloorrmmaappiiddss for X colormap ids ccoolloorrss for color names ccoommmmaannddss for names of external commands. Also used by complex commands such as ccvvss when completing names subcommands. ccoonntteexxttss for contexts in arguments to the zzssttyyllee builtin command ccoorrrreeccttiioonnss used by the aapppprrooxxiimmaattee and ccoorrrreecctt completers for possible corrections ccuurrssoorrss for cursor names used by X programs ddeeffaauulltt used in some contexts to provide a way of supplying a default when more specific tags are also valid. Note that this tag is used when only the function field of the context name is set ddeessccrriippttiioonnss used when looking up the value of the ffoorrmmaatt style to generate descriptions for types of matches ddeevviicceess for names of device special files ddiirreeccttoorriieess for names of directories

ddiirreeccttoorryy-ssttaacckk

for entries in the directory stack ddiissppllaayyss for X display names ddoommaaiinnss for network domains eexxppaannssiioonnss used by the eexxppaanndd completer for individual words (as opposed to the complete set of expansions) resulting from the expansion of a word on the command line eexxtteennssiioonnss for X server extensions

ffiillee-ddeessccrriippttoorrss

for numbers of open file descriptors

ffiilleess the generic file-matching tag used by functions completing file-

names ffoonnttss for X font names ffssttyyppeess for file system types (e.g. for the mmoouunntt command) ffuunnccttiioonnss

names of functions -- normally shell functions, although cer-

tain commands may understand other kinds of function

gglloobbbbeedd-ffiilleess

for filenames when the name has been generated by pattern match-

ing ggrroouuppss for names of user groups

hhiissttoorryy-wwoorrddss

for words from the history hhoossttss for hostnames iinnddeexxeess for array indexes jjoobbss for jobs (as listed by the `jjoobbss' builtin) iinntteerrffaacceess for network interfaces kkeeyymmaappss for names of zsh keymaps kkeeyyssyymmss for names of X keysyms lliibbrraarriieess for names of system libraries lliimmiittss for system limits

llooccaall-ddiirreeccttoorriieess

for names of directories that are subdirectories of the current working directory when completing arguments of ccdd and related

builtin commands (compare ppaatthh-ddiirreeccttoorriieess)

mmaannuuaallss for names of manual pages mmaaiillbbooxxeess

for e-mail folders

mmaappss for map names (e.g. NIS maps) mmeessssaaggeess used to look up the ffoorrmmaatt style for messages mmooddiiffiieerrss for names of X modifiers mmoodduulleess for modules (e.g. zzsshh modules)

mmyy-aaccccoouunnttss

used to look up the uusseerrss-hhoossttss style

nnaammeedd-ddiirreeccttoorriieess

for named directories (you wouldn't have guessed that, would you?) nnaammeess for all kinds of names nneewwssggrroouuppss for USENET groups nniicckknnaammeess for nicknames of NIS maps ooppttiioonnss for command options oorriiggiinnaall used by the aapppprrooxxiimmaattee, ccoorrrreecctt and eexxppaanndd completers when offering the original string as a match

ootthheerr-aaccccoouunnttss

used to look up the uusseerrss-hhoossttss style

ppaacckkaaggeess for packages (e.g. rrppmm or installed DDeebbiiaann packages) ppaarraammeetteerrss for names of parameters

ppaatthh-ddiirreeccttoorriieess

for names of directories found by searching the ccddppaatthh array when completing arguments of ccdd and related builtin commands

(compare llooccaall-ddiirreeccttoorriieess)

ppaatthhss used to look up the values of the eexxppaanndd, aammbbiigguuoouuss and ssppee-

cciiaall-ddiirrss styles

ppooddss for perl pods (documentation files) ppoorrttss for communication ports pprreeffiixxeess for prefixes (like those of a URL) pprriinntteerrss for print queue names pprroocceesssseess for process identifiers

pprroocceesssseess-nnaammeess

used to look up the ccoommmmaanndd style when generating the names of processes for kkiillllaallll sseeqquueenncceess for sequences (e.g. mmhh sequences) sseessssiioonnss for sessions in the zzffttpp function suite ssiiggnnaallss for signal names ssttrriinnggss for strings (e.g. the replacement strings for the ccdd builtin command) ssttyylleess for styles used by the zstyle builtin command ssuuffffiixxeess for filename extensions ttaaggss for tags (e.g. rrppmm tags) ttaarrggeettss for makefile targets

ttiimmee-zzoonneess

for time zones (e.g. when setting the TTZZ parameter) ttyyppeess for types of whatever (e.g. address types for the xxhhoosstt command) uurrllss used to look up the uurrllss and llooccaall styles when completing URLs uusseerrss for usernames vvaalluueess for one of a set of values in certain lists vvaarriiaanntt

used by ppiicckkvvaarriiaanntt to look up the command to run when deter-

mining what program is installed for a particular command name. vviissuuaallss for X visuals wwaarrnniinnggss used to look up the ffoorrmmaatt style for warnings wwiiddggeettss for zsh widget names wwiinnddoowwss for IDs of X windows

zzsshh-ooppttiioonnss

for shell options SSttaannddaarrdd SSttyylleess

Note that the values of several of these styles represent boolean val-

ues. Any of the strings `ttrruuee', `oonn', `yyeess', and `11' can be used for the value `true' and any of the strings `ffaallssee', `ooffff', `nnoo', and `00' for the value `false'. The behavior for any other value is undefined except where explicitly mentioned. The default value may be either true or false if the style is not set.

Some of these styles are tested first for every possible tag corre-

sponding to a type of match, and if no style was found, for the ddeeffaauulltt

tag. The most notable styles of this type are mmeennuu, lliisstt-ccoolloorrss and

styles controlling completion listing such as lliisstt-ppaacckkeedd and

llaasstt-pprroommpptt). When tested for the ddeeffaauulltt tag, only the function field

of the context will be set so that a style using the default tag will normally be defined along the lines of: zzssttyyllee ''::ccoommpplleettiioonn::**::ddeeffaauulltt'' mmeennuu ......

aacccceepptt-eexxaacctt

This is tested for the default tag in addition to the tags valid for the current context. If it is set to `true' and any of the trial matches is the same as the string on the command line,

this match will immediately be accepted (even if it would other-

wise be considered ambiguous). When completing pathnames (where the tag used is `ppaatthhss') this style accepts any number of patterns as the value in addition to the boolean values. Pathnames matching one of these patterns will be accepted immediately even if the command line contains some more partially typed pathname components and these match no file under the directory accepted. This style is also used by the eexxppaanndd completer to decide if words beginning with a tilde or parameter expansion should be expanded. For example, if there are parameters ffoooo and ffoooobbaarr,

the string `$$ffoooo' will only be expanded if aacccceepptt-eexxaacctt is set

to `true'; otherwise the completion system will be allowed to

complete $$ffoooo to $$ffoooobbaarr. If the style is set to `continue',

expand will add the expansion as a match and the completion system will also be allowed to continue.

aadddd-ssppaaccee

This style is used by the eexxppaanndd completer. If it is true (the default), a space will be inserted after all words resulting from the expansion, or a slash in the case of directory names. If the value is `ffiillee', the completer will only add a space to names of existing files. Either a boolean true or the value `ffiillee' may be combined with `ssuubbsstt', in which case the completer will not add a space to words generated from the expansion of a

substitution of the form `$$((......))' or `$${{......}}'.

The pprreeffiixx completer uses this style as a simple boolean value to decide if a space should be inserted before the suffix. aammbbiigguuoouuss

This applies when completing non-final components of filename

paths, in other words those with a trailing slash. If it is set, the cursor is left after the first ambiguous component, even if menu completion is in use. The style is always tested with the ppaatthhss tag.

aassssiiggnn-lliisstt

When completing after an equals sign that is being treated as an assignment, the completion system normally completes only one filename. In some cases the value may be a list of filenames separated by colons, as with PPAATTHH and similar parameters. This style can be set to a list of patterns matching the names of such parameters. The default is to complete lists when the word on the line already contains a colon.

aauuttoo-ddeessccrriippttiioonn

If set, this style's value will be used as the description for options that are not described by the completion functions, but

that have exactly one argument. The sequence `%%dd' in the value

will be replaced by the description for this argument. Depend-

ing on personal preferences, it may be useful to set this style

to something like `ssppeecciiffyy:: %%dd'. Note that this may not work

for some commands.

aavvooiidd-ccoommpplleetteerr

This is used by the aallllmmaattcchheess completer to decide if the string consisting of all matches should be added to the list

currently being generated. Its value is a list of names of com-

pleters. If any of these is the name of the completer that gen-

erated the matches in this completion, the string will not be added. The default value for this style is `eexxppaanndd oollddlliisstt ccoorrrreecctt aapppprrooxxiimmaattee', i.e. it contains the completers for which a string with all matches will almost never be wanted.

ccaacchhee-ppaatthh

This style defines the path where any cache files containing

dumped completion data are stored. It defaults to `$$ZZDDOOTT-

DDIIRR//..zzccoommppccaacchhee', or `$$HHOOMMEE//..zzccoommppccaacchhee' if $$ZZDDOOTTDDIIRR is not

defined. The completion cache will not be used unless the

uussee-ccaacchhee style is set.

ccaacchhee-ppoolliiccyy

This style defines the function that will be used to determine whether a cache needs rebuilding. See the section on the ccaacchheeiinnvvaalliidd function below.

ccaallll-ccoommmmaanndd

This style is used in the function for commands such as mmaakkee and

aanntt where calling the command directly to generate matches suf-

fers problems such as being slow or, as in the case of mmaakkee can potentially causes actions in the makefile to be executed. If it is set to `true' the command is called to generate matches. The default value of this style is `false'. ccoommmmaanndd

In many places, completion functions need to call external com-

mands to generate the list of completions. This style can be used to override the command that is called in some such cases.

The elements of the value are joined with spaces to form a com-

mand line to execute. The value can also start with a hyphen, in which case the usual command will be added to the end; this is most useful for putting `bbuuiillttiinn' or `ccoommmmaanndd' in front to make sure the appropriate version of a command is called, for example to avoid calling a shell function with the same name as an external command. As an example, the completion function for process IDs uses this style with the pprroocceesssseess tag to generate the IDs to complete and the list of processes to display (if the vveerrbboossee style is `true'). The list produced by the command should look like the output of the ppss command. The first line is not displayed, but is searched for the string `PPIIDD' (or `ppiidd') to find the position of the process IDs in the following lines. If the line does not contain `PPIIDD', the first numbers in each of the other lines are taken as the process IDs to complete. Note that the completion function generally has to call the specified command for each attempt to generate the completion list. Hence care should be taken to specify only commands that take a short time to run, and in particular to avoid any that may never terminate.

ccoommmmaanndd-ppaatthh

This is a list of directories to search for commands to com-

plete. The default for this style is the value of the special parameter ppaatthh. ccoommmmaannddss

This is used by the function completing sub-commands for the

system initialisation scripts (residing in //eettcc//iinniitt..dd or some-

where not too far away from that). Its values give the default commands to complete for those commands for which the completion function isn't able to find them out automatically. The default for this style are the two strings `ssttaarrtt' and `ssttoopp'. ccoommpplleettee This is used by the eexxppaannddaalliiaass function when invoked as a

bindable command. If it set to `true' and the word on the com-

mand line is not the name of an alias, matching alias names will be completed. ccoommpplleetteerr The strings given as the value of this style provide the names

of the completer functions to use. The available completer func-

tions are described in the section `Control Functions' below. Each string may be either the name of a completer function or a

string of the form `function::name'. In the first case the com-

pleter field of the context will contain the name of the com-

pleter without the leading underscore and with all other under-

scores replaced by hyphens. In the second case the function is the name of the completer to call, but the context will contain

the user-defined name in the completer field of the context. If

the name starts with a hyphen, the string for the context will be build from the name of the completer function as in the first case with the name appended to it. For example:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee ccoommpplleettee::-ffoooo

Here, completion will call the ccoommpplleettee completer twice, once

using `ccoommpplleettee' and once using `ccoommpplleettee-ffoooo' in the completer

field of the context. Normally, using the same completer more than once only makes sense when used with the `functions::name' form, because otherwise the context name will be the same in all calls to the completer; possible exceptions to this rule are the iiggnnoorreedd and pprreeffiixx completers. The default value for this style is `ccoommpplleettee iiggnnoorreedd': only

completion will be done, first using the iiggnnoorreedd-ppaatttteerrnnss style

and the $$ffiiggnnoorree array and then without ignoring matches.

ccoonnddiittiioonn This style is used by the lliisstt completer function to decide if insertion of matches should be delayed unconditionally. The default is `true'. ddiissaabblleedd

If this is set to `true', the eexxppaannddaalliiaass completer and bind-

able command will try to expand disabled aliases, too. The default is `ffaallssee'.

ddiissaabbllee-ssttaatt

This is used with an empty tag by the ccvvss function to decide whether the zzsshh//ssttaatt module should be used to generate names of modified files in the appropriate places (this is its only use). If the style is set, completion will use the llss command. ddoommaaiinnss A list of names of network domains for completion. If this is not set, domain names will be taken from the file //eettcc//rreessoollvv..ccoonnff.

eexxppaanndd This style is used when completing strings consisting of multi-

ple parts, such as path names. If one of its values is the string `pprreeffiixx', the partially typed word from the line will be expanded as far as possible even if trailing parts cannot be completed. If one of its values is the string `ssuuffffiixx', matching names for components after the first ambiguous one will also be added. This means that the resulting string is the longest unambiguous string possible. However, menu completion can be used to cycle through all matches. ffaakkee This style may be set for any completion context. It specifies

additional strings that will always be completed in that con-

text. The form of each string is `value::description'; the colon and description may be omitted, but any literal colons in value must be quoted with a backslash. Any description provided is shown alongside the value in completion listings. It is important to use a sufficiently restrictive context when

specifying fake strings. Note that the styles ffaakkee-ffiilleess and

ffaakkee-ppaarraammeetteerrss provide additional features when completing

files or parameters.

ffaakkee-ffiilleess

This style is used when completing files and looked up without a tag. Its values are of the form `dir::names...'. This will add the names (strings separated by spaces) as possible matches when completing in the directory dir, even if no such files really exist. This can be useful on systems that support special filesystems

whose top-level pathnames can not be listed or generated with

glob patterns. It can also be used for directories for which one does not have read permission.

ffaakkee-ppaarraammeetteerrss

This is used by the completion function for parameter names. Its values are names of parameters that might not yet be set but should be completed nonetheless. Each name may also be followed by a colon and a string specifying the type of the parameter (like `ssccaallaarr', `aarrrraayy' or `iinntteeggeerr'). If the type is given, the name will only be completed if parameters of that type are required in the particular context. Names for which no type is specified will always be completed.

ffiillee-ppaatttteerrnnss

This is used by the standard function for completing filenames, ffiilleess. If the style is unset up to three tags are offered,

`gglloobbbbeedd-ffiilleess',`ddiirreeccttoorriieess' and `aallll-ffiilleess', depending on the

types of files expected by the caller of ffiilleess. The first two

(`gglloobbbbeedd-ffiilleess' and `ddiirreeccttoorriieess') are normally offered

together to make it easier to complete files in sub-directories.

The ffiillee-ppaatttteerrnnss style provides alternatives to the default

tags, which are not used. Its value consists of elements of the form `pattern::tag'; each string may contain any number of such specifications separated by spaces.

The pattern is a pattern that is to be used to generate file-

names. Any occurrence of the sequence `%%pp' is replaced by any

pattern(s) passed by the function calling ffiilleess. Colons in the

pattern must be preceded by a backslash to make them distin-

guishable from the colon before the tag. If more than one pat-

tern is needed, the patterns can be given inside braces, sepa-

rated by commas. The tags of all strings in the value will be offered by ffiilleess and used when looking up other styles. Any tags in the same word will be offered at the same time and before later words. If no `::tag' is given the `ffiilleess' tag will be used. The tag may also be followed by an optional second colon and a

description, which will be used for the `%%dd' in the value of the

ffoorrmmaatt style (if that is set) instead of the default description supplied by the completion function. If the description given

here contains itself a `%%dd', that is replaced with the descrip-

tion supplied by the completion function. For example, to make the rrmm command first complete only names of object files and then the names of all files if there is no matching object file:

zzssttyyllee ''::ccoommpplleettiioonn::**::**::rrmm::**'' ffiillee-ppaatttteerrnnss \\

''**..oo::oobbjjeecctt-ffiilleess'' ''%%pp::aallll-ffiilleess''

To alter the default behaviour of file completion -- offer

files matching a pattern and directories on the first attempt,

then all files -- to offer only matching files on the first

attempt, then directories, and finally all files:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ffiillee-ppaatttteerrnnss \\

''%%pp::gglloobbbbeedd-ffiilleess'' ''**((-//))::ddiirreeccttoorriieess'' ''**::aallll-ffiilleess''

This works even where there is no special pattern: ffiilleess matches all files using the pattern `**' at the first step and stops when it sees this pattern. Note also it will never try a pattern more than once for a single completion attempt. During the execution of completion functions, the EEXXTTEENNDDEEDDGGLLOOBB

option is in effect, so the characters `##', `~~' and `^^' have

special meanings in the patterns.

ffiillee-ssoorrtt

The standard filename completion function uses this style with-

out a tag to determine in which order the names should be listed; menu completion will cycle through them in the same order. The possible values are: `ssiizzee' to sort by the size of the file; `lliinnkkss' to sort by the number of links to the file;

`mmooddiiffiiccaattiioonn' (or `ttiimmee' or `ddaattee') to sort by the last modifi-

cation time; `aacccceessss' to sort by the last access time; and `iinnooddee' (or `cchhaannggee') to sort by the last inode change time. If the style is set to any other value, or is unset, files will be sorted alphabetically by name. If the value contains the string `rreevveerrssee', sorting is done in the opposite order.

ffiilltteerr This is used by the LDAP plugin for e-mail address completion to

specify the attributes to match against when filtering entries. So for example, if the style is set to `ssnn', matching is done against surnames. Standard LDAP filtering is used so normal completion matching is bypassed. If this style is not set, the LDAP plugin is skipped. You may also need to set the ccoommmmaanndd style to specify how to connect to your LDAP server.

ffoorrccee-lliisstt

This forces a list of completions to be shown at any point where listing is done, even in cases where the list would usually be suppressed. For example, normally the list is only shown if there are at least two different matches. By setting this style to `aallwwaayyss', the list will always be shown, even if there is only a single match that will immediately be accepted. The style may also be set to a number. In this case the list will be shown if there are at least that many matches, even if they would all insert the same string. This style is tested for the default tag as well as for each tag valid for the current completion. Hence the listing can be forced only for certain types of match. ffoorrmmaatt If this is set for the ddeessccrriippttiioonnss tag, its value is used as a string to display above matches in completion lists. The

sequence `%%dd' in this string will be replaced with a short

description of what these matches are. This string may also contain the sequences to specify output attributes, such as

`%%BB', `%%SS' and `%%{{...%%}}'.

The style is tested with each tag valid for the current comple-

tion before it is tested for the ddeessccrriippttiioonnss tag. Hence dif-

ferent format strings can be defined for different types of match. Note also that some completer functions define additional

`%%'-sequences. These are described for the completer functions

that make use of them.

Some completion functions display messages that may be cus-

tomised by setting this style for the mmeessssaaggeess tag. Here, the

`%%dd' is replaced with a message given by the completion func-

tion. Finally, the format string is looked up with the wwaarrnniinnggss tag, for use when no matches could be generated at all. In this case

the `%%dd' is replaced with the descriptions for the matches that

were expected separated by spaces. The sequence `%%DD' is

replaced with the same descriptions separated by newlines.

It is possible to use printf-style field width specifiers with

`%%dd' and similar escape sequences. This is handled by the zzffoorr-

mmaatt builtin command from the zzsshh//zzuuttiill module, see zshmod-

ules(1). gglloobb This is used by the eexxppaanndd completer. If it is set to `true' (the default), globbing will be attempted on the words resulting from a previous substitution (see the ssuubbssttiittuuttee style) or else the original string from the line.

gglloobbaall If this is set to `true' (the default), the eexxppaannddaalliiaass com-

pleter and bindable command will try to expand global aliases.

ggrroouupp-nnaammee

The completion system can group different types of matches, which appear in separate lists. This style can be used to give

the names of groups for particular tags. For example, in com-

mand position the completion system generates names of builtin and external commands, names of aliases, shell functions and parameters and reserved words as possible completions. To have the external commands and shell functions listed separately:

zzssttyyllee ''::ccoommpplleettiioonn::**::**::-ccoommmmaanndd-::**::ccoommmmaannddss'' ggrroouupp-nnaammee ccoommmmaannddss

zzssttyyllee ''::ccoommpplleettiioonn::**::**::-ccoommmmaanndd-::**::ffuunnccttiioonnss'' ggrroouupp-nnaammee ffuunnccttiioonnss

As a consequence, any match with the same tag will be displayed in the same group. If the name given is the empty string the name of the tag for the matches will be used as the name of the group. So, to have all different types of matches displayed separately, one can just set:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ggrroouupp-nnaammee ''''

All matches for which no group name is defined will be put in a

group named -ddeeffaauulltt-.

ggrroouupp-oorrddeerr

This style is additional to the ggrroouupp-nnaammee style to specify the

order for display of the groups defined by that style (compare

ttaagg-oorrddeerr, which determines which completions appear at all).

The groups named are shown in the given order; any other groups are shown in the order defined by the completion function. For example, to have names of builtin commands, shell functions and external commands appear in that order when completing in command position:

zzssttyyllee ''::ccoommpplleettiioonn::**::**::-ccoommmmaanndd-::**'' ggrroouupp-oorrddeerr \\

bbuuiillttiinnss ffuunnccttiioonnss ccoommmmaannddss ggrroouuppss A list of names of UNIX groups. If this is not set, group names are taken from the YP database or the file `//eettcc//ggrroouupp'. hhiiddddeenn If this is set to true, matches for the given context will not be listed, although any description for the matches set with the ffoorrmmaatt style will be shown. If it is set to `aallll', not even the description will be displayed. Note that the matches will still be completed; they are just not

shown in the list. To avoid having matches considered as possi-

ble completions at all, the ttaagg-oorrddeerr style can be modified as

described below. hhoossttss A list of names of hosts that should be completed. If this is not set, hostnames are taken from the file `//eettcc//hhoossttss'.

hhoossttss-ppoorrttss

This style is used by commands that need or accept hostnames and network ports. The strings in the value should be of the form `host::port'. Valid ports are determined by the presence of hostnames; multiple ports for the same host may appear.

iiggnnoorree-lliinnee

This is tested for each tag valid for the current completion. If it is set to `ttrruuee', none of the words that are already on the line will be considered as possible completions. If it is

set to `ccuurrrreenntt', the word the cursor is on will not be consid-

ered as a possible completion. The value `ccuurrrreenntt-sshhoowwnn' is

similar but only applies if the list of completions is currently shown on the screen. Finally, if the style is set to `ootthheerr',

no word apart from the current one will be considered as a pos-

sible completion.

The values `ccuurrrreenntt' and `ccuurrrreenntt-sshhoowwnn' are a bit like the

opposite of the aacccceepptt-eexxaacctt style: only strings with missing

characters will be completed. Note that you almost certainly don't want to set this to `true' or `ootthheerr' for a general context such as `::ccoommpplleettiioonn::**'. This is because it would disallow completion of, for example, options multiple times even if the command in question accepts the option more than once.

iiggnnoorree-ppaarreennttss

The style is tested without a tag by the function completing pathnames in order to determine whether to ignore the names of directories already mentioned in the current word, or the name of the current working directory. The value must include one or both of the following strings: ppaarreenntt The name of any directory whose path is already contained in the word on the line is ignored. For example, when completing after ffoooo//....//, the directory ffoooo will not be considered a valid completion. ppwwdd The name of the current working directory will not be completed; hence, for example, completion after ....// will not use the name of the current directory. In addition, the value may include one or both of: .... Ignore the specified directories only when the word on the line contains the substring `....//'. ddiirreeccttoorryy Ignore the specified directories only when names of directories are completed, not when completing names of files. Excluded values act in a similar fashion to values of the

iiggnnoorreedd-ppaatttteerrnnss style, so they can be restored to consideration

by the iiggnnoorreedd completer.

iiggnnoorreedd-ppaatttteerrnnss

A list of patterns; any trial completion matching one of the

patterns will be excluded from consideration. The iiggnnoorreedd com-

pleter can appear in the list of completers to restore the ignored matches. This is a more configurable version of the

shell parameter $$ffiiggnnoorree.

Note that the EEXXTTEENNDDEEDDGGLLOOBB option is set during the execution

of completion functions, so the characters `##', `~~' and `^^' have

special meanings in the patterns. iinnsseerrtt This style is used by the aallllmmaattcchheess completer to decide whether to insert the list of all matches unconditionally instead of adding the list as another match.

iinnsseerrtt-iiddss

When completing process IDs, for example as arguments to the kkiillll and wwaaiitt builtins the name of a command may be converted to the appropriate process ID. A problem arises when the process name typed is not unique. By default (or if this style is set explicitly to `mmeennuu') the name will be converted immediately to a set of possible IDs, and menu completion will be started to cycle through them. If the value of the style is `ssiinnggllee', the shell will wait until

the user has typed enough to make the command unique before con-

verting the name to an ID; attempts at completion will be unsuc-

cessful until that point. If the value is any other string, menu completion will be started when the string typed by the user is longer than the common prefix to the corresponding IDs.

iinnsseerrtt-ttaabb

If this is set to `true', the completion system will insert a TAB character (assuming that was used to start completion)

instead of performing completion when there is no non-blank

character to the left of the cursor. If it is set to `false', completion will be done even there.

The value may also contain the substrings `ppeennddiinngg' or `ppeenndd-

iinngg==val'. In this case, the typed character will be inserted instead of staring completion when there is unprocessed input pending. If a val is given, completion will not be done if there are at least that many characters of unprocessed input. This is often useful when pasting characters into a terminal.

Note however, that it relies on the $$PPEENNDDIINNGG special parameter

from the zzsshh//zzllee module being set properly which is not guaran-

teed on all platforms. The default value of this style is `true' except for completion within vvaarreedd builtin command where it is `false'.

iinnsseerrtt-uunnaammbbiigguuoouuss

This is used by the mmaattcchh and aapppprrooxxiimmaattee completers. These completers are often used with menu completion since the word

typed may bear little resemblance to the final completion. How-

ever, if this style is `true', the completer will start menu completion only if it could find no unambiguous initial string at least as long as the original string typed by the user. In the case of the aapppprrooxxiimmaattee completer, the completer field

in the context will already have been set to one of ccoorrrreecctt-num

or aapppprrooxxiimmaattee-num, where num is the number of errors that were

accepted. In the case of the mmaattcchh completer, the style may also be set to the string `ppaatttteerrnn'. Then the pattern on the line is left unchanged if it does not match unambiguously.

kkeeeepp-pprreeffiixx

This style is used by the eexxppaanndd completer. If it is `true', the completer will try to keep a prefix containing a tilde or parameter expansion. Hence, for example, the string `~~//ff**' would be expanded to `~~//ffoooo' instead of `//hhoommee//uusseerr//ffoooo'. If the style is set to `cchhaannggeedd' (the default), the prefix will only be left unchanged if there were other changes between the expanded words and the original word from the command line. Any other value forces the prefix to be expanded unconditionally. The behaviour of expand when this style is true is to cause eexxppaanndd to give up when a single expansion with the restored

prefix is the same as the original; hence any remaining com-

pleters may be called.

llaasstt-pprroommpptt

This is a more flexible form of the AALLWWAAYYSSLLAASSTTPPRROOMMPPTT option.

If it is true, the completion system will try to return the cur-

sor to the previous command line after displaying a completion

list. It is tested for all tags valid for the current comple-

tion, then the ddeeffaauulltt tag. The cursor will be moved back to the previous line if this style is `true' for all types of match. Note that unlike the AALLWWAAYYSSLLAASSTTPPRROOMMPPTT option this is independent of the numeric prefix argument.

lliisstt This style is used by the hhiissttoorryyccoommpplleetteewwoorrdd bindable com-

mand. If it is set to `true' it has no effect. If it is set to `false' matches will not be listed. This overrides the setting of the options controlling listing behaviour, in particular

AAUUTTOOLLIISSTT. The context always starts with `::ccoommpplleettiioonn::hhiiss-

ttoorryy-wwoorrddss'.

lliisstt-ccoolloorrss

If the zzsshh//ccoommpplliisstt module is loaded, this style can be used to set color specifications. This mechanism replaces the use of

the ZZLLSSCCOOLLOORRSS and ZZLLSSCCOOLLOOUURRSS parameters described in the sec-

tion `The zsh/complist Module' in zshmodules(1), but the syntax is the same. If this style is set for the ddeeffaauulltt tag, the strings in the

value are taken as specifications that are to be used every-

where. If it is set for other tags, the specifications are used only for matches of the type described by the tag. For this to

work best, the ggrroouupp-nnaammee style must be set to an empty string.

In addition to setting styles for specific tags, it is also pos-

sible to use group names specified explicitly by the ggrroouupp-nnaammee

tag together with the `((ggrroouupp))' syntax allowed by the ZZLLSSCCOOLLOORRSS and ZZLLSSCCOOLLOOUURRSS parameters and simply using the ddeeffaauulltt tag. It is possible to use any color specifications already set up for the GNU version of the llss command:

zzssttyyllee ''::ccoommpplleettiioonn::**::ddeeffaauulltt'' lliisstt-ccoolloorrss $${{((ss..::..))LLSSCCOOLLOORRSS}}

The default colors are the same as for the GNU llss command and can be obtained by setting the style to an empty string (i.e. '''').

lliisstt-ggrroouuppeedd

If this style is `true' (the default), the completion system will try to make certain completion listings more compact by grouping matches. For example, options for commands that have the same description (shown when the vveerrbboossee style is set to `true') will appear as a single entry. However, menu selection can be used to cycle through all the matches.

lliisstt-ppaacckkeedd

This is tested for each tag valid in the current context as well as the ddeeffaauulltt tag. If it is set to `true', the corresponding matches appear in listings as if the LLIISSTTPPAACCKKEEDD option were set. If it is set to `false', they are listed normally.

lliisstt-pprroommpptt

If this style is set for the ddeeffaauulltt tag, completion lists that don't fit on the screen can be scrolled (see the description of the zzsshh//ccoommpplliisstt module in zshmodules(1)). The value, if not the empty string, will be displayed after every screenful and the shell will prompt for a key press; if the style is set to the empty string, a default prompt will be used.

The value may contain the escape sequences: `%%ll' or `%%LL', which

will be replaced by the number of the last line displayed and

the total number of lines; `%%mm' or `%%MM', the number of the last

match shown and the total number of matches; and `%%pp' and `%%PP',

`TToopp' when at the beginning of the list, `BBoottttoomm' when at the end and the position shown as a percentage of the total length otherwise. In each case the form with the uppercase letter will be replaced by a string of fixed width, padded to the right with spaces, while the lowercase form will be replaced by a variable width string. As in other prompt strings, the escape

sequences `%%SS', `%%ss', `%%BB', `%%bb', `%%UU', `%%uu' for entering and

leaving the display modes standout, bold and underline are also

available, as is the form `%%{{...%%}}' for enclosing escape

sequences which display with zero width.

lliisstt-rroowwss-ffiirrsstt

This style is tested in the same way as the lliisstt-ppaacckkeedd style

and determines whether matches are to be listed in a rows-first

fashion as if the LLIISSTTRROOWWSSFFIIRRSSTT option were set.

lliisstt-ssuuffffiixxeess

This style is used by the function that completes filenames. If it is true, and completion is attempted on a string containing

multiple partially typed pathname components, all ambiguous com-

ponents will be shown. Otherwise, completion stops at the first ambiguous component.

lliisstt-sseeppaarraattoorr

The value of this style is used in completion listing to sepa-

rate the string to complete from a description when possible

(e.g. when completing options). It defaults to `--' (two

hyphens). llooccaall This is for use with functions that complete URLs for which the

corresponding files are available directly from the filing sys-

tem. Its value should consist of three strings: a hostname, the path to the default web pages for the server, and the directory name used by a user placing web pages within their home area. For example: zzssttyyllee ''::ccoommpplleettiioonn::**'' llooccaall ttooaasstt \\ //vvaarr//hhttttpp//ppuubblliicc//ttooaasstt ppuubblliicchhttmmll Completion after `hhttttpp::////ttooaasstt//ssttuuffff//' will look for files in the directory //vvaarr//hhttttpp//ppuubblliicc//ttooaasstt//ssttuuffff, while completion

after `hhttttpp::////ttooaasstt//~~yyoouussiirr//' will look for files in the direc-

tory ~~yyoouussiirr//ppuubblliicchhttmmll.

mmaaiill-ddiirreeccttoorryy

If set, zsh will assume that mailbox files can be found in the directory specified. It defaults to `~~//MMaaiill'.

mmaattcchh-oorriiggiinnaall

This is used by the mmaattcchh completer. If it is set to oonnllyy, mmaattcchh will try to generate matches without inserting a `**' at

the cursor position. If set to any other non-empty value, it

will first try to generate matches without inserting the `**' and if that yields no matches, it will try again with the `**' inserted. If it is unset or set to the empty string, matching will only be performed with the `**' inserted. mmaattcchheerr

This style is tested separately for each tag valid in the cur-

rent context. Its value is added to any match specifications

given by the mmaattcchheerr-lliisstt style. It should be in the form

described in the section `Matching Control' in zshcompwid(1).

mmaattcchheerr-lliisstt

This style can be set to a list of match specifications that are to be applied everywhere. Match specifications are described in the section `Matching Control' in zshcompwid(1). The completion system will try them one after another for each completer selected. For example, to try first simple completion and, if

that generates no matches, case-insensitive completion:

zzssttyyllee ''::ccoommpplleettiioonn::**'' mmaattcchheerr-lliisstt '''' ''mm::{{aa-zzAA-ZZ}}=={{AA-ZZaa-zz}}''

By default each specification replaces the previous one; how-

ever, if a specification is prefixed with ++, it is added to the

existing list. Hence it is possible to create increasingly gen-

eral specifications without repetition:

zzssttyyllee ''::ccoommpplleettiioonn::**'' mmaattcchheerr-lliisstt '''' ''++mm{{aa-ZZ}}=={{AA-ZZ}}'' ''++mm{{AA-ZZ}}=={{aa-zz}}''

It is possible to create match specifications valid for particu-

lar completers by using the third field of the context. For example, to use the completers ccoommpplleettee and pprreeffiixx but only

allow case-insensitive completion with ccoommpplleettee:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee pprreeffiixx

zzssttyyllee ''::ccoommpplleettiioonn::**::ccoommpplleettee::**'' mmaattcchheerr-lliisstt \\

'''' ''mm::{{aa-zzAA-ZZ}}=={{AA-ZZaa-zz}}''

User-defined names, as explained for the ccoommpplleetteerr style, are

available. This makes it possible to try the same completer more than once with different match specifications each time.

For example, to try normal completion without a match specifica-

tion, then normal completion with case-insensitive matching,

then correction, and finally partial-word completion:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee ccoorrrreecctt ccoommpplleettee::ffoooo

zzssttyyllee ''::ccoommpplleettiioonn::**::ccoommpplleettee::**'' mmaattcchheerr-lliisstt \\

'''' ''mm::{{aa-zzAA-ZZ}}=={{AA-ZZaa-zz}}''

zzssttyyllee ''::ccoommpplleettiioonn::**::ffoooo::**'' mmaattcchheerr-lliisstt \\

''mm::{{aa-zzAA-ZZ}}=={{AA-ZZaa-zz}} rr::||[[-..//]]==** rr::||==**''

If the style is unset in any context no match specification is applied. Note also that some completers such as ccoorrrreecctt and aapppprrooxxiimmaattee do not use the match specifications at all, though these completers will only ever called once even if the

mmaattcchheerr-lliisstt contains more than one element.

Where multiple specifications are useful, note that the entire

completion is done for each element of mmaattcchheerr-lliisstt, which can

quickly reduce the shell's performance. As a rough rule of thumb, one to three strings will give acceptable performance.

On the other hand, putting multiple space-separated values into

the same string does not have an appreciable impact on perfor-

mance.

mmaaxx-eerrrroorrss

This is used by the aapppprrooxxiimmaattee and ccoorrrreecctt completer func-

tions to determine the maximum number of errors to allow. The completer will try to generate completions by first allowing one error, then two errors, and so on, until either a match or matches were found or the maximum number of errors given by this style has been reached. If the value for this style contains the string `nnuummeerriicc', the completer function will take any numeric argument as the maximum number of errors allowed. For example, with

zzssttyyllee ''::ccoommpplleettiioonn::**::aapppprrooxxiimmaattee::::::'' mmaaxx-eerrrroorrss 22 nnuummeerriicc

two errors are allowed if no numeric argument is given, but with

a numeric argument of six (as in `EESSCC-66 TTAABB'), up to six errors

are accepted. Hence with a value of `00 nnuummeerriicc', no correcting completion will be attempted unless a numeric argument is given.

If the value contains the string `nnoott-nnuummeerriicc', the completer

will not try to generate corrected completions when given a numeric argument, so in this case the number given should be

greater than zero. For example, `22 nnoott-nnuummeerriicc' specifies that

correcting completion with two errors will usually be performed, but if a numeric argument is given, correcting completion will not be performed. The default value for this style is `22 nnuummeerriicc'.

mmaaxx-mmaattcchheess-wwiiddtthh

This style is used to determine the trade off between the width of the display used for matches and the width used for their descriptions when the vveerrbboossee style is in effect. The value gives the number of display columns to reserve for the matches. The default is half the width of the screen. This has the most impact when several matches have the same description and so will be grouped together. Increasing the style will allow more matches to be grouped together; decreasing it will allow more of the description to be visible. mmeennuu If this is true in the context of any of the tags defined for the current completion menu completion will be used. The value for a specific tag will take precedence over that for the `ddeeffaauulltt' tag. If none of the values found in this way is true but at least one is set to `aauuttoo', the shell behaves as if the AAUUTTOOMMEENNUU option is set. If one of the values is explicitly set to false, menu completion will be explicitly turned off, overriding the MMEENNUUCCOOMMPPLLEETTEE option and other settings. In the form `yyeess==num', where `yyeess' may be any of the true values (`yyeess', `ttrruuee', `oonn' and `11'), menu completion will be turned on if there are at least num matches. In the form `yyeess==lloonngg', menu completion will be turned on if the list does not fit on the screen. This does not activate menu completion if the widget normally only lists completions, but menu completion can be

activated in that case with the value `yyeess==lloonngg-lliisstt' (Typi-

cally, the value `sseelleecctt==lloonngg-lliisstt' described later is more use-

ful as it provides control over scrolling.) Similarly, with any of the `false' values (as in `nnoo==1100'), menu completion will not be used if there are num or more matches.

The value of this widget also controls menu selection, as imple-

mented by the zzsshh//ccoommpplliisstt module. The following values may appear either alongside or instead of the values above. If the value contains the string `sseelleecctt', menu selection will be started unconditionally. In the form `sseelleecctt==num', menu selection will only be started if there are at least num matches. If the values for more than one tag provide a number, the smallest number is taken. Menu selection can be turned off explicitly by defining a value

containing the string`nnoo-sseelleecctt'.

It is also possible to start menu selection only if the list of matches does not fit on the screen by using the value

`sseelleecctt==lloonngg'. To start menu selection even if the current wid-

get only performs listing, use the value `sseelleecctt==lloonngg-lliisstt'.

To turn on menu completion or menu selection when a there are a certain number of matches or the list of matches does not fit on the screen, both of `yyeess==' and `sseelleecctt==' may be given twice,

once with a number and once with `lloonngg' or `lloonngg-lliisstt'.

Finally, it is possible to activate two special modes of menu

selection. The word `iinntteerraaccttiivvee' in the value causes interac-

tive mode to be entered immediately when menu selection is

started; see the description of the zzsshh//ccoommpplliisstt module in zsh-

modules(1).RE for a description of interactive mode. Including the string `sseeaarrcchh' does the same for incremental search mode. To select backward incremental search, include the string

`sseeaarrcchh-bbaacckkwwaarrdd'. )

mmuuttttrrcc If set, gives the location of the mutt configuration file. It defaults to `~~//..mmuuttttrrcc'. nnuummbbeerrss This is used with the jjoobbss tag. If it is `true', the shell will complete job numbers instead of the shortest unambiguous prefix of the job command text. If the value is a number, job numbers will only be used if that many words from the job descriptions are required to resolve ambiguities. For example, if the value is `11', strings will only be used if all jobs differ in the first word on their command lines.

oolldd-lliisstt

This is used by the oollddlliisstt completer. If it is set to `aallwwaayyss', then standard widgets which perform listing will retain the current list of matches, however they were generated; this can be turned off explicitly with the value `nneevveerr', giving the behaviour without the oollddlliisstt completer. If the style is unset, or any other value, then the existing list of completions is displayed if it is not already; otherwise, the standard completion list is generated; this is the default behaviour of oollddlliisstt. However, if there is an old list and this style contains the name of the completer function that generated the list, then the old list will be used even

if it was generated by a widget which does not do list-

ing.

For example, suppose you type ^^XXcc to use the ccoorr-

rreeccttwwoorrdd widget, which generates a list of corrections for the word under the cursor. Usually, typing ^^DD would generate a standard list of completions for the word on the command line, and show that. With oollddlliisstt, it will instead show the list of corrections already generated. As another example consider the mmaattcchh completer: with

the iinnsseerrtt-uunnaammbbiigguuoouuss style set to `true' it inserts

only a common prefix string, if there is any. However, this may remove parts of the original pattern, so that further completion could produce more matches than on the

first attempt. By using the oollddlliisstt completer and set-

ting this style to mmaattcchh, the list of matches generated on the first attempt will be used again.

oolldd-mmaattcchheess

This is used by the aallllmmaattcchheess completer to decide if an old list of matches should be used if one exists. This is selected by one of the `true' values or by the string `oonnllyy'. If the value is `oonnllyy', aallllmmaattcchheess will only use an old list and won't have any effect on the list of matches currently being generated. If this style is set it is generally unwise to call the aallllmmaattcchheess completer unconditionally. One possible use is for either this style or the ccoommpplleetteerr style to be

defined with the -ee option to zzssttyyllee to make the style

conditional.

oolldd-mmeennuu

This is used by the oollddlliisstt completer. It controls how menu completion behaves when a completion has already been inserted and the user types a standard completion key such as TTAABB. The default behaviour of oollddlliisstt is that menu completion always continues with the existing list of completions. If this style is set to `false', however, a new completion is started if the old list was generated by a different completion command; this is the behaviour without the oollddlliisstt completer. For example, suppose you type ^^XXcc to generate a list of corrections, and menu completion is started in one of the usual ways. Usually, or with this style set to ffaallssee, typing TTAABB at this point would start trying to complete the line as it now appears. With oollddlliisstt, it instead continues to cycle through the list of corrections. oorriiggiinnaall This is used by the aapppprrooxxiimmaattee and ccoorrrreecctt completers to decide if the original string should be added as a possible completion. Normally, this is done only if there are at least two possible corrections, but if this style is set to `true', it is always added. Note that the style will be examined with the completer field in

the context name set to ccoorrrreecctt-num or aapppprrooxxiimmaattee-num,

where num is the number of errors that were accepted. ppaacckkaaggeesseett This style is used when completing arguments of the Debian `ddppkkgg' program. It contains an override for the default package set for a given context. For example,

zzssttyyllee ''::ccoommpplleettiioonn::**::ccoommpplleettee::ddppkkgg::ooppttiioonn--ssttaattuuss-11::**'' \\

ppaacckkaaggeesseett aavvaaiill causes available packages, rather than only installed

packages, to be completed for `dpkg -status'.

ppaatthh The function that completes color names uses this style with the ccoolloorrss tag. The value should be the pathname of a file containing color names in the format of an X11 rrggbb..ttxxtt file. If the style is not set but this file is found in one of various standard locations it will be used as the default.

ppiinnee-ddiirreeccttoorryy

If set, specifies the directory containing PINE mailbox files. It defaults to `~~//mmaaiill'.

ppoorrttss A list of Internet service names (network ports) to com-

plete. If this is not set, service names are taken from the file `//eettcc//sseerrvviicceess'.

pprreeffiixx-hhiiddddeenn

This is used for certain completions which share a common prefix, for example command options beginning with dashes. If it is `true', the prefix will not be shown in the list of matches. The default value for this style is `false'.

pprreeffiixx-nneeeeddeedd

This, too, is used for matches with a common prefix. If it is set to `true' this common prefix must be typed by the user to generate the matches. In the case of command

options, this means that the initial `-', `++', or `--'

must be typed explicitly before option names will be com-

pleted. The default value for this style is `true'.

pprreesseerrvvee-pprreeffiixx

This style is used when completing path names. Its value should be a pattern matching an initial prefix of the word to complete that should be left unchanged under all circumstances. For example, on some Unices an initial `////' (double slash) has a special meaning; setting this style to the string `////' will preserve it. As another example, setting this style to `??:://' under Cygwin would allow completion after `aa:://......' and so on.

rraannggee This is used by the hhiissttoorryy completer and the hhiiss-

ttoorryyccoommpplleetteewwoorrdd bindable command to decide which words should be completed. If it is a singe number, only the last N words from the history will be completed. If it is a range of the form `max::slice', the last slice words will be completed; then if that yields no matches, the slice words before those will be tried and so on. This process stops either when at least one match was been found, or max words have been tried. The default is to complete all words from the history at once. rreegguullaarr This style is used by the eexxppaannddaalliiaass completer and

bindable command. If set to `ttrruuee' (the default), regu-

lar aliases will be expanded but only in command posi-

tion. If it is set to `ffaallssee', regular aliases will never be expanded. If it is set to `aallwwaayyss', regular aliases will be expanded even if not in command position.

rreemmoottee-aacccceessss

If set to ffaallssee, certain commands will be prevented from

making Internet connections to retrieve remote informa-

tion. This includes the completion for the CCVVSS command. It is not always possible to know if connections are in

fact to a remote site, so some may be prevented unneces-

sarily.

rreemmoovvee-aallll-dduuppss

The hhiissttoorryyccoommpplleetteewwoorrdd bindable command and the hhiiss-

ttoorryy completer use this to decide if all duplicate matches should be removed, rather than just consecutive duplicates.

sseelleecctt-pprroommpptt

If this is set for the ddeeffaauulltt tag, its value will be displayed during menu selection (see the mmeennuu style above) when the completion list does not fit on the screen as a whole. The same escapes as for the

lliisstt-pprroommpptt style are understood, except that the numbers

refer to the match or line the mark is on. A default prompt is used when the value is the empty string.

sseelleecctt-ssccrroollll

This style is tested for the ddeeffaauulltt tag and determines how a completion list is scrolled during a menu selection (see the mmeennuu style above) when the completion list does not fit on the screen as a whole. If the value is `00'

(zero), the list is scrolled by half-screenfuls; if it is

a positive integer, the list is scrolled by the given number of lines; if it is a negative number, the list is scrolled by a screenful minus the absolute value of the

given number of lines. The default is to scroll by sin-

gle lines.

sseeppaarraattee-sseeccttiioonnss

This style is used with the mmaannuuaallss tag when completing

names of manual pages. If it is `true', entries for dif-

ferent sections are added separately using tag names of the form `mmaannuuaall..X', where X is the section number. When

the ggrroouupp-nnaammee style is also in effect, pages from dif-

ferent sections will appear separately. This style is also used similarly with the wwoorrddss style when completing

words for the dict command. It allows words from differ-

ent dictionary databases to be added separately. The default for this style is `false'.

sshhooww-ccoommpplleetteerr

Tested whenever a new completer is tried. If it is true, the completion system outputs a progress message in the listing area showing what completer is being tried. The

message will be overwritten by any output when comple-

tions are found and is removed after completion is fin-

ished.

ssiinnggllee-iiggnnoorreedd

This is used by the iiggnnoorreedd completer when there is only one match. If its value is `sshhooww', the single match will be displayed but not inserted. If the value is `mmeennuu', then the single match and the original string are both added as matches and menu completion is started, making it easy to select either of them. ssoorrtt Many completion widgets call ddeessccrriippttiioonn at some point which decides whether the matches are added sorted or unsorted (often indirectly via wwaanntteedd or rreeqquueesstteedd). This style can be set explicitly to one of the usual true or false values as an override. If it is not set for the context, the standard behaviour of the calling widget is used. The style is tested first against the full context including the tag, and if that fails to produce a value against the context without the tag. If the calling widget explicitly requests unsorted matches, this is usually honoured. However, the default

(unsorted) behaviour of completion for the command his-

tory may be overridden by setting the style to ttrruuee. In the eexxppaanndd completer, if it is set to `true', the expansions generated will always be sorted. If it is set to `mmeennuu', then the expansions are only sorted when they

are offered as single strings but not in the string con-

taining all possible expansions.

ssppeecciiaall-ddiirrss

Normally, the completion code will not produce the direc-

tory names `..' and `....' as possible completions. If this style is set to `true', it will add both `..' and `....' as possible completions; if it is set to `....', only `....' will be added.

The following example sets ssppeecciiaall-ddiirrss to `....' when the

current prefix is empty, is a single `..', or consists only of a path beginning with `....//'. Otherwise the value is `false'.

zzssttyyllee -ee ''::ccoommpplleettiioonn::**'' ssppeecciiaall-ddiirrss \\

''[[[[ $$PPRREEFFIIXX == ((....//))##((||..||....)) ]]]] &&&& rreeppllyy==((....))''

ssqquueeeezzee-ssllaasshheess

If set to `true', sequences of slashes in filename paths (for example in `ffoooo////bbaarr') will be treated as a single

slash. This is the usual behaviour of UNIX paths. How-

ever, by default the file completion function behaves as if there were a `**' between the slashes. ssttoopp If set to `true', the hhiissttoorryyccoommpplleetteewwoorrdd bindable command will stop once when reaching the beginning or end of the history. Invoking hhiissttoorryyccoommpplleetteewwoorrdd will then wrap around to the opposite end of the history. If

this style is set to `false' (the default), hhiissttoorryyccoomm-

pplleetteewwoorrdd will loop immediately as in a menu completion.

ssttrriipp-ccoommmmeennttss

If set to `true', this style causes non-essential comment

text to be removed from completion matches. Currently it

is only used when completing e-mail addresses where it

removes any display name from the addresses, cutting them down to plain user@host form.

ssuubbsstt-gglloobbss-oonnllyy

This is used by the eexxppaanndd completer. If it is set to `true', the expansion will only be used if it resulted from globbing; hence, if expansions resulted from the use of the ssuubbssttiittuuttee style described below, but these were not further changed by globbing, the expansions will be rejected. The default for this style is `false'. ssuubbssttiittuuttee This boolean style controls whether the eexxppaanndd completer will first try to expand all substitutions in the string

(such as `$$((......))' and `$${{......}}').

The default is `true'. ssuuffffiixx This is used by the eexxppaanndd completer if the word starts with a tilde or contains a parameter expansion. If it is set to `true', the word will only be expanded if it doesn't have a suffix, i.e. if it is something like

`~~ffoooo' or `$$ffoooo' rather than `~~ffoooo//' or `$$ffoooo//bbaarr',

unless that suffix itself contains characters eligible for expansion. The default for this style is `true'.

ttaagg-oorrddeerr

This provides a mechanism for sorting how the tags avail-

able in a particular context will be used.

The values for the style are sets of space-separated

lists of tags. The tags in each value will be tried at the same time; if no match is found, the next value is

used. (See the ffiillee-ppaatttteerrnnss style for an exception to

this behavior.) For example:

zzssttyyllee ''::ccoommpplleettiioonn::**::ccoommpplleettee::-ccoommmmaanndd-::**'' ttaagg-oorrddeerr \\

''ccoommmmaannddss ffuunnccttiioonnss'' specifies that completion in command position first offers external commands and shell functions. Remaining tags will be tried if no completions are found. In addition to tag names, each string in the value may take one of the following forms:

- If any value consists of only a hyphen, then only

the tags specified in the other values are gener-

ated. Normally all tags not explicitly selected

are tried last if the specified tags fail to gen-

erate any matches. This means that a single value

consisting only of a single hyphen turns off com-

pletion. !! tags...

A string starting with an exclamation mark speci-

fies names of tags that are not to be used. The effect is the same as if all other possible tags for the context had been listed. tag::label ... Here, tag is one of the standard tags and label is

an arbitrary name. Matches are generated as nor-

mal but the name label is used in contexts instead of tag. This is not useful in words starting with !!. If the label starts with a hyphen, the tag is prepended to the label to form the name used for lookup. This can be used to make the completion system try a certain tag more than once, supplying different style settings for each attempt; see below for an example. tag::label::description

As before, but ddeessccrriippttiioonn will replace the `%%dd'

in the value of the ffoorrmmaatt style instead of the default description supplied by the completion function. Spaces in the description must be

quoted with a backslash. A `%%dd' appearing in

description is replaced with the description given by the completion function. In any of the forms above the tag may be a pattern or several patterns in the form `{{pat1,,pat2...}}'. In this case all matching tags will be used except for any given explicitly in the same string. One use of these features is to try one tag more than once, setting other styles differently on each attempt, but still to use all the other tags without having to repeat them all. For example, to make completion of

function names in command position ignore all the comple-

tion functions starting with an underscore the first time completion is tried:

zzssttyyllee ''::ccoommpplleettiioonn::**::**::-ccoommmmaanndd-::**'' ttaagg-oorrddeerr \\

''ffuunnccttiioonnss::-nnoonn-ccoommpp **'' ffuunnccttiioonnss

zzssttyyllee ''::ccoommpplleettiioonn::**::ffuunnccttiioonnss-nnoonn-ccoommpp'' iiggnnoorreedd-ppaatttteerrnnss ''**''

On the first attempt, all tags will be offered but the

ffuunnccttiioonnss tag will be replaced by ffuunnccttiioonnss-nnoonn-ccoommpp.

The iiggnnoorreedd-ppaatttteerrnnss style is set for this tag to exclude

functions starting with an underscore. If there are no

matches, the second value of the ttaagg-oorrddeerr style is used

which completes functions using the default tag, this time presumably including all function names. The matches for one tag can be split into different groups. For example:

zzssttyyllee ''::ccoommpplleettiioonn::**'' ttaagg-oorrddeerr \\

''ooppttiioonnss::-lloonngg::lloonngg\\ ooppttiioonnss

ooppttiioonnss::-sshhoorrtt::sshhoorrtt\\ ooppttiioonnss

ooppttiioonnss::-ssiinnggllee-lleetttteerr::ssiinnggllee\\ lleetttteerr\\ ooppttiioonnss''

zstyle ':completion:*:options-long' ignored-patterns '[-+](|-|[^-]*)'

zstyle ':completion:*:options-short' ignored-patterns '-*' '[-+]?'

zstyle ':completion:*:options-single-letter' ignored-patterns '???*'

With the ggrroouupp-nnaammeess style set, options beginning with

`--', options beginning with a single `-' or `++' but con-

taining multiple characters, and single-letter options

will be displayed in separate groups with different descriptions.

Another use of patterns is to try multiple match specifi-

cations one after another. The mmaattcchheerr-lliisstt style offers

something similar, but it is tested very early in the

completion system and hence can't be set for single com-

mands nor for more specific contexts. Here is how to try normal completion without any match specification and, if

that generates no matches, try again with case-insensi-

tive matching, restricting the effect to arguments of the command ffoooo:

zzssttyyllee ''::ccoommpplleettiioonn::**::**::ffoooo::**'' ttaagg-oorrddeerr ''**'' ''**::-ccaassee''

zzssttyyllee ''::ccoommpplleettiioonn::**-ccaassee'' mmaattcchheerr ''mm::{{aa-zz}}=={{AA-ZZ}}''

First, all the tags offered when completing after ffoooo are tried using the normal tag name. If that generates no

matches, the second value of ttaagg-oorrddeerr is used, which

tries all tags again except that this time each has -ccaassee

appended to its name for lookup of styles. Hence this time the value for the mmaattcchheerr style from the second call to zzssttyyllee in the example is used to make completion

case-insensitive.

It is possible to use the -ee option of the zzssttyyllee builtin

command to specify conditions for the use of particular tags. For example:

zzssttyyllee -ee ''**::-ccoommmmaanndd-::**'' ttaagg-oorrddeerr ''

iiff [[[[ -nn $$PPRREEFFIIXX$$SSUUFFFFIIXX ]]]];; tthheenn

rreeppllyy==(( )) eellssee

rreeppllyy==(( - ))

ffii'' Completion in command position will be attempted only if the string typed so far is not empty. This is tested using the PPRREEFFIIXX special parameter; see zshcompwid for a

description of parameters which are special inside com-

pletion widgets. Setting rreeppllyy to an empty array pro-

vides the default behaviour of trying all tags at once; setting it to an array containing only a hyphen disables the use of all tags and hence of all completions.

If no ttaagg-oorrddeerr style has been defined for a context, the

strings `((||**-))aarrgguummeenntt-** ((||**-))ooppttiioonn-** vvaalluueess' and

`ooppttiioonnss' plus all tags offered by the completion func-

tion will be used to provide a sensible default behavior that causes arguments (whether normal command arguments or arguments of options) to be completed before option names for most commands. uurrllss This is used together with the the uurrllss tag by functions completing URLs. If the value consists of more than one string, or if the only string does not name a file or directory, the strings are used as the URLs to complete. If the value contains only one string which is the name of a normal file the URLs are taken from that file (where the URLs may be separated by white space or newlines).

Finally, if the only string in the value names a direc-

tory, the directory hierarchy rooted at this directory gives the completions. The top level directory should be the file access method, such as `hhttttpp', `ffttpp', `bbooookkmmaarrkk' and so on. In many cases the next level of directories will be a filename. The directory hierarchy can descend as deep as necessary. For example, zzssttyyllee ''::ccoommpplleettiioonn::**'' uurrllss ~~//..uurrllss

mmkkddiirr -pp ~~//..uurrllss//ffttpp//ffttpp..zzsshh..oorrgg//ppuubb//ddeevveellooppmmeenntt

allows completion of all the components of the URL ffttpp::////ffttpp..zzsshh..oorrgg//ppuubb//ddeevveellooppmmeenntt after suitable commands such as `nneettssccaappee' or `llyynnxx'. Note, however, that access methods and files are completed separately, so if the

hhoossttss style is set hosts can be completed without refer-

ence to the uurrllss style. See the description in the function uurrllss itself for more

information (e.g. `mmoorree $$^^ffppaatthh//uurrllss((NN))').

uussee-ccaacchhee

If this is set, the completion caching layer is activated for any completions which use it (via the ssttoorreeccaacchhee, rreettrriieevveeccaacchhee, and ccaacchheeiinnvvaalliidd functions). The directory containing the cache files can be changed with

the ccaacchhee-ppaatthh style.

uussee-ccoommppccttll

If this style is set to a string not equal to ffaallssee, 00, nnoo, and ooffff, the completion system may use any completion specifications defined with the ccoommppccttll builtin command.

If the style is unset, this is done only if the zzsshh//ccoomm-

ppccttll module is loaded. The string may also contain the

substring `ffiirrsstt' to use completions defined with `ccoomm-

ppccttll -TT', and the substring `ddeeffaauulltt' to use the comple-

tion defined with `ccoommppccttll -DD'.

Note that this is only intended to smooth the transition

from ccoommppccttll to the new completion system and may disap-

pear in the future. Note also that the definitions from ccoommppccttll will only be used if there is no specific completion function for the command in question. For example, if there is a function ffoooo to complete arguments to the command ffoooo, ccoommppccttll

will never be invoked for ffoooo. However, the ccoommppccttll ver-

sion will be tried if ffoooo only uses default completion.

uussee-ppeerrll

Various parts of the function system use awk to extract words from files or command output as this universally available. However, many versions of awk have arbitrary limits on the size of input. If this style is set, perl will be used instead. This is almost always preferable if perl is available on your system. Currently this is only used in completions for `make',

but it may be extended depending on authorial frustra-

tion. uusseerrss This may be set to a list of usernames to be completed. If it is not set or the string on the line doesn't match any of the strings in this list, all usernames will be completed.

uusseerrss-hhoossttss

The values of this style should be of the form `user@@host' or `user::host'. It is used for commands that

need pairs of user- and hostnames. These commands will

complete usernames from this style (only), and will restrict subsequent hostname completion to hosts paired with that user in one of the values of the style. It is possible to group values for sets of commands which allow a remote login, such as rrllooggiinn and sssshh, by using

the mmyy-aaccccoouunnttss tag. Similarly, values for sets of com-

mands which usually refer to the accounts of other peo-

ple, such as ttaallkk and ffiinnggeerr, can be grouped by using the

ootthheerr-aaccccoouunnttss tag. More ambivalent commands may use the

aaccccoouunnttss tag.

uusseerrss-hhoossttss-ppoorrttss

Like uusseerrss-hhoossttss but used for commands like tteellnneett and

containing strings of the form `user@@host::port'. vveerrbboossee If set, as it is by default, the completion listing is

more verbose. In particular many commands show descrip-

tions for options if this style is `true'. wwoorrdd This is used by the lliisstt completer, which prevents the insertion of completions until a second completion attempt when the line has not changed. The normal way of finding out if the line has changed is to compare its entire contents between the two occasions. If this style is true, the comparison is instead performed only on the current word. Hence if completion is performed on another word with the same contents, completion will not be delayed. CCOONNTTRROOLL FFUUNNCCTTIIOONNSS

The initialization script ccoommppiinniitt redefines all the widgets which per-

form completion to call the supplied widget function mmaaiinnccoommpplleettee.

This function acts as a wrapper calling the so-called `completer' func-

tions that generate matches. If mmaaiinnccoommpplleettee is called with argu-

ments, these are taken as the names of completer functions to be called in the order given. If no arguments are given, the set of functions to

try is taken from the ccoommpplleetteerr style. For example, to use normal com-

pletion and correction if that doesn't generate any matches: zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee ccoorrrreecctt after calling ccoommppiinniitt. The default value for this style is `ccoommpplleettee iiggnnoorreedd', i.e. normally only ordinary completion is tried, first with

the effect of the iiggnnoorreedd-ppaatttteerrnnss style and then without it. The

mmaaiinnccoommpplleettee function uses the return value of the completer func-

tions to decide if other completers should be called. If the return value is zero, no other completers are tried and the mmaaiinnccoommpplleettee function returns.

If the first argument to mmaaiinnccoommpplleettee is a single hyphen, the argu-

ments will not be taken as names of completers. Instead, the second argument gives a name to use in the completer field of the context and

the other arguments give a command name and arguments to call to gener-

ate the matches. The following completer functions are contained in the distribution, although users may write their own. Note that in contexts the leading underscore is stripped, for example basic completion is performed in the context `::ccoommpplleettiioonn::::ccoommpplleettee::...'. aallllmmaattcchheess This completer can be used to add a string consisting of all other matches. As it influences later completers it must appear as the first completer in the list. The list of all matches is

affected by the aavvooiidd-ccoommpplleetteerr and oolldd-mmaattcchheess styles described

above. It may be useful to use the ggeenneerriicc function described below to bind aallllmmaattcchheess to its own keystroke, for example:

zzllee -CC aallll-mmaattcchheess ccoommpplleettee-wwoorrdd ggeenneerriicc

bbiinnddkkeeyy ''^^XXaa'' aallll-mmaattcchheess

zzssttyyllee ''::ccoommpplleettiioonn::aallll-mmaattcchheess::**'' oolldd-mmaattcchheess oonnllyy

zzssttyyllee ''::ccoommpplleettiioonn::aallll-mmaattcchheess::::::::'' ccoommpplleetteerr aallllmmaattcchheess

aapppprrooxxiimmaattee This is similar to the basic ccoommpplleettee completer but allows the completions to undergo corrections. The maximum number of

errors can be specified by the mmaaxx-eerrrroorrss style; see the

description of approximate matching in zshexpn(1) for how errors are counted. Normally this completer will only be tried after the normal ccoommpplleettee completer: zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee aapppprrooxxiimmaattee

This will give correcting completion if and only if normal com-

pletion yields no possible completions. When corrected comple-

tions are found, the completer will normally start menu comple-

tion allowing you to cycle through these strings.

This completer uses the tags ccoorrrreeccttiioonnss and oorriiggiinnaall when gen-

erating the possible corrections and the original string. The ffoorrmmaatt style for the former may contain the additional sequences

`%%ee' and `%%oo' which will be replaced by the number of errors

accepted to generate the corrections and the original string, respectively. The completer progressively increases the number of errors

allowed up to the limit by the mmaaxx-eerrrroorrss style, hence if a com-

pletion is found with one error, no completions with two errors will be shown, and so on. It modifies the completer name in the context to indicate the number of errors being tried: on the

first try the completer field contains `aapppprrooxxiimmaattee-11', on the

second try `aapppprrooxxiimmaattee-22', and so on.

When aapppprrooxxiimmaattee is called from another function, the number of

errors to accept may be passed with the -aa option. The argument

is in the same format as the mmaaxx-eerrrroorrss style, all in one

string. Note that this completer (and the ccoorrrreecctt completer mentioned below) can be quite expensive to call, especially when a large number of errors are allowed. One way to avoid this is to set

up the ccoommpplleetteerr style using the -ee option to zstyle so that

some completers are only used when completion is attempted a second time on the same string, e.g.:

zzssttyyllee -ee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ''

iiff [[[[ $$llaassttttrryy !!== ""$$HHIISSTTNNOO$$BBUUFFFFEERR$$CCUURRSSOORR"" ]]]];; tthheenn

llaassttttrryy==""$$HHIISSTTNNOO$$BBUUFFFFEERR$$CCUURRSSOORR""

rreeppllyy==((ccoommpplleettee mmaattcchh pprreeffiixx)) eellssee rreeppllyy==((iiggnnoorreedd ccoorrrreecctt aapppprrooxxiimmaattee)) ffii'' This uses the HHIISSTTNNOO parameter and the BBUUFFFFEERR and CCUURRSSOORR special parameters that are available inside zle and completion widgets to find out if the command line hasn't changed since the last time completion was tried. Only then are the iiggnnoorreedd, ccoorrrreecctt and aapppprrooxxiimmaattee completers called. ccoommpplleettee

This completer generates all possible completions in a con-

text-sensitive manner, i.e. using the settings defined with the

ccoommppddeeff function explained above and the current settings of all special parameters. This gives the normal completion behaviour. To complete arguments of commands, ccoommpplleettee uses the utility function nnoorrmmaall, which is in turn responsible for finding the particular function; it is described below. Various contexts of

the form -context- are handled specifically. These are all men-

tioned above as possible arguments to the ##ccoommppddeeff tag.

Before trying to find a function for a specific context, ccoomm-

pplleettee checks if the parameter `ccoommppccoonntteexxtt' is set. Setting `ccoommppccoonntteexxtt' allows the usual completion dispatching to be overridden which is useful in places such as a function that uses vvaarreedd for input. If it is set to an array, the elements are taken to be the possible matches which will be completed using the tag `vvaalluueess' and the description `vvaalluuee'. If it is set to an associative array, the keys are used as the possible completions

and the values (if non-empty) are used as descriptions for the

matches. If `ccoommppccoonntteexxtt' is set to a string containing colons, it should be of the form `tag::descr::action'. In this case the tag and descr give the tag and description to use and the action indicates what should be completed in one of the forms accepted by the aarrgguummeennttss utility function described below. Finally, if `ccoommppccoonntteexxtt' is set to a string without colons, the

value is taken as the name of the context to use and the func-

tion defined for that context will be called. For this purpose,

there is a special context named -ccoommmmaanndd-lliinnee- that completes

whole command lines (commands and their arguments). This is not used by the completion system itself but is nonetheless handled when explicitly called. ccoorrrreecctt Generate corrections, but not completions, for the current word; this is similar to aapppprrooxxiimmaattee but will not allow any number of extra characters at the cursor as that completer does. The

effect is similar to spell-checking. It is based on aapppprrooxxii-

mmaattee, but the completer field in the context name is ccoorrrreecctt. For example, with: zzssttyyllee ''::ccoommpplleettiioonn::::::::::'' ccoommpplleetteerr ccoommpplleettee ccoorrrreecctt aapppprrooxxiimmaattee

zzssttyyllee ''::ccoommpplleettiioonn::**::ccoorrrreecctt::::::'' mmaaxx-eerrrroorrss 22 nnoott-nnuummeerriicc

zzssttyyllee ''::ccoommpplleettiioonn::**::aapppprrooxxiimmaattee::::::'' mmaaxx-eerrrroorrss 33 nnuummeerriicc

correction will accept up to two errors. If a numeric argument

is given, correction will not be performed, but correcting com-

pletion will be, and will accept as many errors as given by the numeric argument. Without a numeric argument, first correction and then correcting completion will be tried, with the first one accepting two errors and the second one accepting three errors. When ccoorrrreecctt is called as a function, the number of errors to

accept may be given following the -aa option. The argument is in

the same form a values to the aacccceepptt style, all in one string. This completer function is intended to be used without the aapppprrooxxiimmaattee completer or, as in the example, just before it. Using it after the aapppprrooxxiimmaattee completer is useless since

aapppprrooxxiimmaattee will at least generate the corrected strings gener-

ated by the ccoorrrreecctt completer - and probably more.

eexxppaanndd This completer function does not really perform completion, but instead checks if the word on the command line is eligible for expansion and, if it is, gives detailed control over how this expansion is done. For this to happen, the completion system

needs to be invoked with ccoommpplleettee-wwoorrdd, not eexxppaanndd-oorr-ccoommpplleettee

(the default binding for TTAABB), as otherwise the string will be expanded by the shell's internal mechanism before the completion system is started. Note also this completer should be called before the ccoommpplleettee completer function.

The tags used when generating expansions are aallll-eexxppaannssiioonnss for

the string containing all possible expansions, eexxppaannssiioonnss when adding the possible expansions as single matches and oorriiggiinnaall when adding the original string from the line. The order in which these strings are generated, if at all, can be controlled

by the ggrroouupp-oorrddeerr and ttaagg-oorrddeerr styles, as usual.

The format string for aallll-eexxppaannssiioonnss and for eexxppaannssiioonnss may con-

tain the sequence `%%oo' which will be replaced by the original

string from the line.

The kind of expansion to be tried is controlled by the ssuubbssttii-

ttuuttee, gglloobb and ssuubbsstt-gglloobbss-oonnllyy styles.

It is also possible to call eexxppaanndd as a function, in which case

the different modes may be selected with options: -ss for ssuubbssttii-

ttuuttee, -gg for gglloobb and -oo for ssuubbsstt-gglloobbss-oonnllyy.

eexxppaannddaalliiaass If the word the cursor is on is an alias, it is expanded and no other completers are called. The types of aliases which are to be expanded can be controlled with the styles rreegguullaarr, gglloobbaall and ddiissaabblleedd.

This function is also a bindable command, see the section `Bind-

able Commands' below. hhiissttoorryy

Complete words from the shell's command history. This com-

pleter can be controlled by the rreemmoovvee-aallll-dduuppss, and ssoorrtt styles

as for the hhiissttoorryyccoommpplleetteewwoorrdd bindable command, see the sec-

tion `Bindable Commands' below and the section `Completion Sys-

tem Configuration' above. iiggnnoorreedd

The iiggnnoorreedd-ppaatttteerrnnss style can be set to a list of patterns

which are compared against possible completions; matching ones

are removed. With this completer those matches can be rein-

stated, as if no iiggnnoorreedd-ppaatttteerrnnss style were set. The completer

actually generates its own list of matches; which completers are

invoked is determined in the same way as for the pprreeffiixx com-

pleter. The ssiinnggllee-iiggnnoorreedd style is also available as described

above. lliisstt This completer allows the insertion of matches to be delayed until completion is attempted a second time without the word on the line being changed. On the first attempt, only the list of matches will be shown. It is affected by the styles ccoonnddiittiioonn and wwoorrdd, see the section `Completion System Configuration' above.

mmaattcchh This completer is intended to be used after the ccoommpplleettee com-

pleter. It behaves similarly but the string on the command line may be a pattern to match against trial completions. This gives the effect of the GGLLOOBBCCOOMMPPLLEETTEE option. Normally completion will be performed by taking the pattern from the line, inserting a `**' at the cursor position and comparing the resulting pattern with the possible completions generated.

This can be modified with the mmaattcchh-oorriiggiinnaall style described

above. The generated matches will be offered in a menu completion

unless the iinnsseerrtt-uunnaammbbiigguuoouuss style is set to `true'; see the

description above for other options for this style. Note that matcher specifications defined globally or used by the

completion functions (the styles mmaattcchheerr-lliisstt and mmaattcchheerr) will

not be used. mmeennuu This completer was written as simple example function to show how menu completion can be enabled in shell code. However, it has the notable effect of disabling menu selection which can be useful with ggeenneerriicc based widgets. It should be used as the first completer in the list. Note that this is independent of the setting of the MMEENNUUCCOOMMPPLLEETTEE option and does not work with

the other menu completion widgets such as rreevveerrssee-mmeennuu-ccoommpplleettee,

or aacccceepptt-aanndd-mmeennuu-ccoommpplleettee.

oollddlliisstt This completer controls how the standard completion widgets behave when there is an existing list of completions which may

have been generated by a special completion (i.e. a sepa-

rately-bound completion command). It allows the ordinary com-

pletion keys to continue to use the list of completions thus

generated, instead of producing a new list of ordinary contex-

tual completions. It should appear in the list of completers before any of the widgets which generate matches. It uses two

styles: oolldd-lliisstt and oolldd-mmeennuu, see the section `Completion Sys-

tem Configuration' above. pprreeffiixx This completer can be used to try completion with the suffix

(everything after the cursor) ignored. In other words, the suf-

fix will not be considered to be part of the word to complete.

The effect is similar to the eexxppaanndd-oorr-ccoommpplleettee-pprreeffiixx command.

The ccoommpplleetteerr style is used to decide which other completers are to be called to generate matches. If this style is unset, the

list of completers set for the current context is used -

except, of course, the pprreeffiixx completer itself. Furthermore,

if this completer appears more than once in the list of com-

pleters only those completers not already tried by the last invocation of pprreeffiixx will be called. For example, consider this global ccoommpplleetteerr style: zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr \\ ccoommpplleettee pprreeffiixx ccoorrrreecctt pprreeffiixx::ffoooo Here, the pprreeffiixx completer tries normal completion but ignoring the suffix. If that doesn't generate any matches, and neither does the call to the ccoorrrreecctt completer after it, pprreeffiixx will be called a second time and, now only trying correction with the suffix ignored. On the second invocation the completer part of the context appears as `ffoooo'. To use pprreeffiixx as the last resort and try only normal completion when it is invoked: zzssttyyllee ''::ccoommpplleettiioonn::**'' ccoommpplleetteerr ccoommpplleettee ...... pprreeffiixx zzssttyyllee ''::ccoommpplleettiioonn::::pprreeffiixx::**'' ccoommpplleetteerr ccoommpplleettee

The aadddd-ssppaaccee style is also respected. If it is set to `true'

then pprreeffiixx will insert a space between the matches generated (if any) and the suffix. Note that this completer is only useful if the CCOOMMPPLLEETTEEIINNWWOORRDD option is set; otherwise, the cursor will be moved to the end of the current word before the completion code is called and hence there will be no suffix. bbaasshhccoommppiinniitt This function provides compatibility with bash's programmable

completion system. When run it will define the functions, ccoommpp-

ggeenn and ccoommpplleettee which correspond to the bash builtins with the

same names. It will then be possible to use completion specifi-

cations and functions written for bash. BBIINNDDAABBLLEE CCOOMMMMAANNDDSS

In addition to the context-dependent completions provided, which are

expected to work in an intuitively obvious way, there are a few widgets implementing special behaviour which can be bound separately to keys. The following is a list of these and their default bindings. bbaasshhccoommpplleettiioonnss

This function is used by two widgets, bbaasshhccoommpplleettee-wwoorrdd and

bbaasshhlliisstt-cchhooiicceess. It exists to provide compatibility with

completion bindings in bash. The last character of the binding

determines what is completed: `!!', command names; `$$', environ-

ment variables; `@@', host names; `//', file names; `~~' user names. In bash, the binding preceded by `\\ee' gives completion, and preceded by `^^XX' lists options. As some of these bindings clash with standard zsh bindings, only `\\ee~~' and `^^XX~~' are bound by default. To add the rest, the following should be added to ..zzsshhrrcc after ccoommppiinniitt has been run:

ffoorr kkeeyy iinn ''!!'' ''$$'' ''@@'' ''//'' ''~~'';; ddoo

bbiinnddkkeeyy ""\\ee$$kkeeyy"" bbaasshhccoommpplleettee-wwoorrdd

bbiinnddkkeeyy ""^^XX$$kkeeyy"" bbaasshhlliisstt-cchhooiicceess

ddoonnee This includes the bindings for `~~' in case they were already bound to something else; the completion code does not override user bindings. ccoorrrreeccttffiilleennaammee ((^^XXCC)) Correct the filename path at the cursor position. Allows up to six errors in the name. Can also be called with an argument to correct a filename path, independently of zle; the correction is printed on standard output. ccoorrrreeccttwwoorrdd (^Xc)

Performs correction of the current argument using the usual con-

textual completions as possible choices. This stores the string

`ccoorrrreecctt-wwoorrdd' in the function field of the context name and

then calls the ccoorrrreecctt completer. eexxppaannddaalliiaass ((^^XXaa))

This function can be used as a completer and as a bindable com-

mand. It expands the word the cursor is on if it is an alias. The types of alias expanded can be controlled with the styles rreegguullaarr, gglloobbaall and ddiissaabblleedd. When used as a bindable command there is one additional feature that can be selected by setting the ccoommpplleettee style to `true'. In this case, if the word is not the name of an alias, eexxppaannddaalliiaass tries to complete the word to a full alias name without expanding it. It leaves the cursor directly after the completed word so that invoking eexxppaannddaalliiaass once more will

expand the now-complete alias name.

eexxppaannddwwoorrdd ((^^XXee))

Performs expansion on the current word: equivalent to the stan-

dard eexxppaanndd-wwoorrdd command, but using the eexxppaanndd completer.

Before calling it, the function field of the context is set to

`eexxppaanndd-wwoorrdd'.

ggeenneerriicc This function is not defined as a widget and not bound by default. However, it can be used to define a widget and will then store the name of the widget in the function field of the

context and call the completion system. This allows custom com-

pletion widgets with their own set of style settings to be defined easily. For example, to define a widget that performs normal completion and starts menu selection:

zzllee -CC ffoooo ccoommpplleettee-wwoorrdd ggeenneerriicc

bbiinnddkkeeyy ''......'' ffoooo zzssttyyllee ''::ccoommpplleettiioonn::ffoooo::**'' mmeennuu yyeess sseelleecctt==11 hhiissttoorryyccoommpplleetteewwoorrdd (\e/) Complete words from the shell's command history. This uses the

lliisstt, rreemmoovvee-aallll-dduuppss, ssoorrtt, and ssttoopp styles.

mmoossttrreecceennttffiillee ((^^XXmm)) Complete the name of the most recently modified file matching the pattern on the command line (which may be blank). If given a numeric argument N, complete the Nth most recently modified file. Note the completion, if any, is always unique. nneexxttttaaggss (^Xn) This command alters the set of matches used to that for the next

tag, or set of tags, either as given by the ttaagg-oorrddeerr style or

as set by default; these matches would otherwise not be avail-

able. Successive invocations of the command cycle through all possible sets of tags. rreeaaddccoommpp ((^^XX^^RR)) Prompt the user for a string, and use that to perform completion on the current word. There are two possibilities for the string. First, it can be a set of words beginning `', for

example `ffiilleess -//', in which case the function with any argu-

ments will be called to generate the completions. Unambiguous

parts of the function name will be completed automatically (nor-

mal completion is not available at this point) until a space is typed. Second, any other string will be passed as a set of arguments to ccoommppaadddd and should hence be an expression specifying what should be completed. A very restricted set of editing commands is available when reading the string: `DDEELL' and `^^HH' delete the last character; `^^UU' deletes the line, and `^^CC' and `^^GG' abort the function, while `RREETT' accepts the completion. Note the string is used verbatim as a command line, so arguments must be quoted in accordance with standard shell rules. Once a string has been read, the next call to rreeaaddccoommpp will use the existing string instead of reading a new one. To force

a new string to be read, call rreeaaddccoommpp with a numeric argu-

ment. ccoommpplleetteeddeebbuugg ((^^XX??))

This widget performs ordinary completion, but captures in a tem-

porary file a trace of the shell commands executed by the com-

pletion system. Each completion attempt gets its own file. A command to view each of these files is pushed onto the editor buffer stack. ccoommpplleetteehheellpp ((^^XXhh)) This widget displays information about the context names, the tags, and the completion functions used when completing at the current cursor position. If given a numeric argument other than

11 (as in `EESSCC-22 ^^XXhh'), then the styles used and the contexts for

which they are used will be shown, too. Note that the information about styles may be incomplete; it

depends on the information available from the completion func-

tions called, which in turn is determined by the user's own styles and other settings. ccoommpplleetteettaagg ((^^XXtt)) This widget completes symbol tags created by the eettaaggss or ccttaaggss

programmes (note there is no connection with the completion sys-

tem's tags) stored in a file TTAAGGSS, in the format used by eettaaggss, or ttaaggss, in the format created by ccttaaggss. It will look back up the path hierarchy for the first occurrence of either file; if both exist, the file TTAAGGSS is preferred. You can specify the

full path to a TTAAGGSS or ttaaggss file by setting the parameter $$TTAAGGSS-

FFIILLEE or $$ttaaggssffiillee respectively. The corresponding completion

tags used are eettaaggss and vvttaaggss, after emacs and vi respectively. UUTTIILLIITTYY FFUUNNCCTTIIOONNSS

Descriptions follow for utility functions that may be useful when writ-

ing completion functions. If functions are installed in subdirecto-

ries, most of these reside in the BBaassee subdirectory. Like the example

functions for commands in the distribution, the utility functions gen-

erating matches all follow the convention of returning zero if they

generated completions and non-zero if no matching completions could be

added. Two more features are offered by the mmaaiinnccoommpplleettee function. The arrays ccoommpppprreeffuunnccss and ccoommppppoossttffuunnccss may contain names of functions that are to be called immediately before or after completion has been

tried. A function will only be called once unless it explicitly rein-

serts itself into the array.

aallllllaabbeellss [ -xx ] [ -1122VVJJ ] tag name descr [ command args ... ]

This is a convenient interface to the nneexxttllaabbeell function below, implementing the loop shown in the nneexxttllaabbeell example. The command and its arguments are called to generate the

matches. The options stored in the parameter name will automat-

ically be inserted into the args passed to the command. Nor-

mally, they are put directly after the command, but if one of the args is a single hyphen, they are inserted directly before that. If the hyphen is the last argument, it will be removed from the argument list before the command is called. This allows aallllllaabbeellss to be used in almost all cases where the matches can be generated by a single call to the ccoommppaadddd builtin command or by a call to one of the utility functions. For example: llooccaall eexxppll ...... iiff rreeqquueesstteedd ffoooo;; tthheenn ......

aallllllaabbeellss ffoooo eexxppll ''......'' ccoommppaadddd ...... - $$mmaattcchheess

ffii

Will complete the strings from the mmaattcchheess parameter, using ccoomm-

ppaadddd with additional options which will take precedence over those generated by aallllllaabbeellss.

aalltteerrnnaattiivvee [ -CC name ] spec ...

This function is useful in simple cases where multiple tags are available. Essentially it implements a loop like the one described for the ttaaggss function below. The tags to use and the action to perform if a tag is requested are described using the specs which are of the form: `tag::descr::action'. The tags are offered using ttaaggss and if the

tag is requested, the action is executed with the given descrip-

tion descr. The actions are those accepted by the aarrgguummeennttss

function (described below), excluding the `->>state' and `==...'

forms. For example, the action may be a simple function call: aalltteerrnnaattiivvee \\ ''uusseerrss::uusseerr::uusseerrss'' \\ ''hhoossttss::hhoosstt::hhoossttss'' offers usernames and hostnames as possible matches, generated by the uusseerrss and hhoossttss functions respectively. Like aarrgguummeennttss, this functions uses aallllllaabbeellss to execute the

actions, which will loop over all sets of tags. Special han-

dling is only required if there is an additional valid tag, for example inside a function called from aalltteerrnnaattiivvee.

Like ttaaggss this function supports the -CC option to give a dif-

ferent name for the argument context field.

aarrgguummeennttss [ -sswwWWAACCRRSS ] [ -OO name ] [ -MM matchspec ] [ :: ] spec ...

This function can be used to give a complete specification for completion for a command whose arguments follow standard UNIX option and argument conventions. The following forms specify individual sets of options and arguments; to avoid ambiguity, these may be separated from the options to aarrgguummeennttss itself by a single colon. n::message::action n::::message::action This describes the n'th normal argument. The message will be printed above the matches generated and the action indicates what can be completed in this position (see below). If there are two colons before the message the argument is optional. If the message contains only white space, nothing will be printed above the matches unless the action adds an explanation string itself. ::message::action ::::message::action Similar, but describes the next argument, whatever number that happens to be. If all arguments are specified in

this form in the correct order the numbers are unneces-

sary. **::message::action **::::message::action **::::::message::action

This describes how arguments (usually non-option argu-

ments, those not beginning with - or ++) are to be com-

pleted when neither of the first two forms was provided. Any number of arguments can be completed in this fashion. With two colons before the message, the wwoorrddss special array and the CCUURRRREENNTT special parameter are modified to refer only to the normal arguments when the action is

executed or evaluated. With three colons before the mes-

sage they are modified to refer only to the normal argu-

ments covered by this description. optspec optspec:... This describes an option. The colon indicates handling for one or more arguments to the option; if it is not present, the option is assumed to take no arguments.

By default, options are multi-character name, one `-word'

per option. With -ss, options may be single characters,

with more than one option per word, although words start-

ing with two hyphens, such as `--pprreeffiixx', are still con-

sidered complete option names. This is suitable for standard GNU options.

The combination of -ss with -ww allows single-letter

options to be combined in a single word even if one or

more of the options take arguments. For example, if -aa

takes an argument, with no -ss `-aabb' is considered as a

single (unhandled) option; with -ss -aabb is an option with

the argument `bb'; with both -ss and -ww, -aabb may be the

option -aa and the option(-b) with arguments still to

come.

The option -WW takes this a stage further: it is possible

to complete single-letter options even after an argument

that occurs in the same word. However, it depends on the action performed whether options will really be completed at this point. For more control, use a utility function like gguuaarrdd as part of the action.

The following forms are available for the initial opt-

spec, whether or not the option has arguments. **optspec Here optspec is one of the remaining forms below. This indicates the following optspec may be repeated. Otherwise if the corresponding option is already present on the command line to the left of the cursor it will not be offered again.

-optname

++optname In the simplest form the optspec is just the option name beginning with a minus or a plus sign,

such as `-ffoooo'. The first argument for the option

(if any) must follow as a separate word directly after the option.

Either of `-++optname' and `++-optname' can be used

to specify that -optname and ++optname are both

valid.

In all the remaining forms, the leading `-' may be

replaced by or paired with `++' in this way.

-optname-

The first argument of the option must come directly after the option name in the same word.

For example, `-ffoooo-::...' specifies that the com-

pleted option and argument will look like

`-ffooooarg'.

-optname++

The first argument may appear immediately after

optname in the same word, or may appear as a sepa-

rate word after the option. For example,

`-ffoooo++::...' specifies that the completed option

and argument will look like either `-ffooooarg' or

`-ffoooo arg'.

-optname==

The argument may appear as the next word, or in same word as the option name provided that it is separated from it by an equals sign, for example

`-ffoooo==arg' or `-ffoooo arg'.

-optname==-

The argument to the option must appear after an equals sign in the same word, and may not be given in the next argument. optspec[[explanation]] An explanation string may be appended to any of the preceding forms of optspec by enclosing it in

brackets, as in `-qq[[qquueerryy ooppeerraattiioonn]]'.

The vveerrbboossee style is used to decide whether the explanation strings are displayed with the option in a completion listing. If no bracketed explanation string is given but

the aauuttoo-ddeessccrriippttiioonn style is set and only one

argument is described for this optspec, the value of the style is displayed, with any appearance of

the sequence `%%dd' in it replaced by the message of

the first optarg that follows the optspec; see below. It is possible for options with a literal `+' or `==' to appear,

but that character must be quoted, for example `-\\++'.

Each optarg following an optspec must take one of the following forms: ::message::action ::::message::action An argument to the option; message and action are treated

as for ordinary arguments. In the first form, the argu-

ment is mandatory, and in the second form it is optional.

This group may be repeated for options which take multi-

ple arguments. In other words, ::message1::action1::mes-

sage2::action2 specifies that the option takes two argu-

ments. ::**pattern::message::action ::**pattern::::message::action ::**pattern::::::message::action This describes multiple arguments. Only the last optarg for an option taking multiple arguments may be given in this form. If the pattern is empty (i.e., ::**::), all the remaining words on the line are to be completed as described by the action; otherwise, all the words up to a word matching the pattern are to be completed using the action. Multiple colons are treated as for the `**::...' forms for ordinary arguments: when the message is preceded by two colons, the wwoorrddss special array and the CCUURRRREENNTT special parameter are modified during the execution or evaluation of the action to refer only to the words after the option. When preceded by three colons, they are modified to refer only to the words covered by this description. Any literal colon in an optname, message, or action must be preceded by a backslash, `\\::'. Each of the forms above may be preceded by a list in parentheses of

option names and argument numbers. If the given option is on the com-

mand line, the options and arguments indicated in parentheses will not

be offered. For example, `((-ttwwoo -tthhrreeee 11))-oonnee::......' completes the

option `-oonnee'; if this appears on the command line, the options -ttwwoo

and -tthhrreeee and the first ordinary argument will not be completed after

it. `((-ffoooo))::...' specifies an ordinary argument completion; -ffoooo will

not be completed if that argument is already present.

Other items may appear in the list of excluded options to indicate var-

ious other items that should not be applied when the current specifica-

tion is matched: a single star (**) for the rest arguments (i.e. a spec-

ification of the form `**::......'); a colon (::) for all normal

(non-option-) arguments; and a hyphen (-) for all options. For exam-

ple, if `((**))' appears before an option and the option appears on the command line, the list of remaining arguments (those shown in the above table beginning with `**::') will not be completed. To aid in reuse of specifications, it is possible to precede any of the forms above with `!!'; then the form will no longer be completed, although if the option or argument appears on the command line they will be skipped as normal. The main use for this is when the arguments are given by an array, and aarrgguummeennttss is called repeatedly for more

specific contexts: on the first call `aarrgguummeennttss $$gglloobbaallooppttiioonnss' is

used, and on subsequent calls `aarrgguummeennttss !!$$^^gglloobbaallooppttiioonnss'.

In each of the forms above the action determines how completions should

be generated. Except for the `->>string' form below, the action will be

executed by calling the aallllllaabbeellss function to process all tag labels. No special handling of tags is needed unless a function call introduces a new one. The forms for action are as follows. (single unquoted space)

This is useful where an argument is required but it is not pos-

sible or desirable to generate matches for it. The message will be displayed but no completions listed. Note that even in this case the colon at the end of the message is needed; it may only be omitted when neither a message nor an action is given. ((item1 item2 ...)) One of a list of possible matches, for example: ::ffoooo::((ffoooo bbaarr bbaazz)) ((((item1\\::desc1 ...)))) Similar to the above, but with descriptions for each possible match. Note the backslash before the colon. For example, ::ffoooo::((((aa\\::bbaarr bb\\::bbaazz)))) The matches will be listed together with their descriptions if the ddeessccrriippttiioonn style is set with the vvaalluueess tag in the context.

->>string

In this form, aarrgguummeennttss processes the arguments and options and then returns control to the calling function with parameters set to indicate the state of processing; the calling function then makes its own arrangements for generating completions. For example, functions that implement a state machine can use this type of action.

Where aarrgguummeennttss encounters a `->>string', it will strip all

leading and trailing whitespace from string and set the array ssttaattee to the set of all stringss for which an action is to be performed. By default and in common with all other well behaved completion functions, arguments returns zero if it was able to add matches

and non-zero otherwise. However, if the -RR option is given,

aarrgguummeennttss will instead return a status of 300 to indicate that

$$ssttaattee is to be handled.

In addition to $$ssttaattee, aarrgguummeennttss also sets the global parame-

ters `ccoonntteexxtt', `lliinnee' and `ooppttaarrggss' as described below, and does not reset any changes made to the special parameters such as PPRREEFFIIXX and wwoorrddss. This gives the calling function the choice of resetting these parameters or propagating changes in them.

A function calling aarrgguummeennttss with at least one action contain-

ing a `->>string' therefore must declare appropriate local param-

eters: llooccaall ccoonntteexxtt ssttaattee lliinnee

ttyyppeesseett -AA ooppttaarrggss

to avoid aarrgguummeennttss from altering the global environment.

A string in braces is evaluated as shell code to generate

matches. If the eval-string itself does not begin with an open-

ing parenthesis or brace it is split into separate words before execution. == action If the action starts with `== ' (an equals sign followed by a space), aarrgguummeennttss will insert the contents of the argument field of the current context as the new first element in the

wwoorrddss special array and increment the value of the CCUURRRREENNTT spe-

cial parameter. This has the effect of inserting a dummy word onto the completion command line while not changing the point at which completion is taking place. This is most useful with one of the specifiers that restrict the words on the command line on which the action is to operate (the

two- and three-colon forms above). One particular use is when

an action itself causes aarrgguummeennttss on a restricted range; it is necessary to use this trick to insert an appropriate command name into the range for the second call to aarrgguummeennttss to be able to parse the line. word... word... This covers all forms other than those above. If the action starts with a space, the remaining list of words will be invoked unchanged. Otherwise it will be invoked with some extra strings placed after the first word; these are to be passed down as options to the ccoommppaadddd builtin. They ensure that the state specified by

aarrgguummeennttss, in particular the descriptions of options and argu-

ments, is correctly passed to the completion command. These additional arguments are taken from the array parameter `eexxppll'; this will be set up before executing the action and hence may be referred to inside it, typically in an expansion of the form

`$$eexxppll[[@@]]' which preserves empty elements of the array.

During the performance of the action the array `lliinnee' will be set to the command name and normal arguments from the command line, i.e. the words from the command line excluding all options and their arguments. Options are stored in the associative array `ooppttaarrggss' with option names as keys and their arguments as the values. For options that have more than one argument these are given as one string, separated by

colons. All colons in the original arguments are preceded with back-

slashes. The parameter `ccoonntteexxtt' is set when returning to the calling function

to perform an action of the form `->>string'. It is set to an array of

elements corresponding to the elements of $$ssttaattee. Each element is a

suitable name for the argument field of the context: either a string of

the form `ooppttiioonn-opt-n' for the n'th argument of the option -opt, or a

string of the form `aarrgguummeenntt-n' for the n'th argument. For `rest'

arguments, that is those in the list at the end not handled by posi-

tion, n is the string `rreesstt'. For example, when completing the argu-

ment of the -oo option, the name is `ooppttiioonn-oo-11', while for the second

normal (non-option-) argument it is `aarrgguummeenntt-22'.

Furthermore, during the evaluation of the action the context name in the ccuurrccoonntteexxtt parameter is altered to append the same string that is stored in the ccoonntteexxtt parameter. It is possible to specify multiple sets of options and arguments with the sets separated by single hyphens. The specifications before the first hyphen (if any) are shared by all the remaining sets. The first word in every other set provides a name for the set which may appear in exclusion lists in specifications, either alone or before one of the

possible values described above. In the second case a `-' should

appear between this name and the remainder. For example: aarrgguummeennttss \\

-aa \\

- sseett11 \\

-cc \\

- sseett22 \\

-dd \\

''::aarrgg::((xx22 yy22))''

This defines two sets. When the command line contains the option `-cc',

the `-dd' option and the argument will not be considered possible com-

pletions. When it contains `-dd' or an argument, the option `-cc' will

not be considered. However, after `-aa' both sets will still be consid-

ered valid. If the name given for one of the mutually exclusive sets is of the form `((name))' then only one value from each set will ever be completed; more

formally, all specifications are mutually exclusive to all other speci-

fications in the same set. This is useful for defining multiple sets of options which are mutually exclusive and in which the options are aliases for each other. For example: aarrgguummeennttss \\

-aa -bb \\

- ''((ccoommpprreessss))'' \\

{{-cc,,--ccoommpprreessss}}''[[ccoommpprreessss]]'' \\

- ''((uunnccoommpprreessss))'' \\

{{-dd,,--ddeeccoommpprreessss}}''[[ddeeccoommpprreessss]]''

As the completion code has to parse the command line separately for each set this form of argument is slow and should only be used when necessary. A useful alternative is often an option specification with

rest-arguments (as in `-ffoooo::**::......'); here the option -ffoooo swallows up

all remaining arguments as described by the optarg definitions.

The options -SS and -AA are available to simplify the specifications for

commands with standard option parsing. With -SS, no option will be com-

pleted after a `--' appearing on its own on the line; this argument

will otherwise be ignored; hence in the line

ffoooobbaarr -aa -- -bb

the `-aa' is considered an option but the `-bb' is considered an argu-

ment, while the `--' is considered to be neither.

With -AA, no options will be completed after the first non-option argu-

ment on the line. The -AA must be followed by a pattern matching all

strings which are not to be taken as arguments. For example, to make aarrgguummeennttss stop completing options after the first normal argument, but ignoring all strings starting with a hyphen even if they are not

described by one of the optspecs, the form is `-AA ""-**""'.

The option `-OO name' specifies the name of an array whose elements will

be passed as arguments to functions called to execute actions. For

example, this can be used to pass the same set of options for the ccoomm-

ppaadddd builtin to all actions.

The option `-MM spec' sets a match specification to use to completion

option names and values. It must appear before the first argument

specification. The default is `rr::||[[-]]==** rr::||==**': this allows partial

word completion after `' and `-', for example `-f-b' can be completed

to `-ffoooo-bbaarr'.

The option -CC tells aarrgguummeennttss to modify the ccuurrccoonntteexxtt parameter for

an action of the form `->>state'. This is the standard parameter used

to keep track of the current context. Here it (and not the ccoonntteexxtt array) should be made local to the calling function to avoid passing back the modified value and should be initialised to the current value at the start of the function:

llooccaall ccuurrccoonntteexxtt==""$$ccuurrccoonntteexxtt""

This is useful where it is not possible for multiple states to be valid together.

The option `--' allows aarrgguummeennttss to work out the names of long options

that support the `--hheellpp' option which is standard in many GNU com-

mands. The command word is called with the argument `--hheellpp' and the

output examined for option names. Clearly, it can be dangerous to pass this to commands which may not support this option as the behaviour of the command is unspecified.

In addition to options, `aarrgguummeennttss --' will try to deduce the types of

arguments available for options when the form `--opt=val' is valid. It

is also possible to provide hints by examining the help text of the command and adding specifiers of the form `pattern::message::action'; note that normal aarrgguummeennttss specifiers are not used. The pattern is

matched against the help text for an option, and if it matches the mes-

sage and action are used as for other argument specifiers. For exam-

ple:

aarrgguummeennttss -- ''**\\**::ttooggggllee::((yyeess nnoo))'' \\

''**==FFIILLEE**::ffiillee::ffiilleess'' \\

''**==DDIIRR**::ddiirreeccttoorryy::ffiilleess -//'' \\

''**==PPAATTHH**::ddiirreeccttoorryy::ffiilleess -//''

Here, `yyeess' and `nnoo' will be completed as the argument of options whose description ends in a star; file names will be completed for options that contain the substring `==FFIILLEE' in the description; and directories will be completed for options whose description contains `==DDIIRR' or `==PPAATTHH'. The last three are in fact the default and so need not be given explicitly, although it is possible to override the use of these patterns. A typical help text which uses this feature is:

-CC,, --ddiirreeccttoorryy==DDIIRR cchhaannggee ttoo ddiirreeccttoorryy DDIIRR

so that the above specifications will cause directories to be completed

after `--ddiirreeccttoorryy', though not after `-CC'.

Note also that aarrgguummeennttss tries to find out automatically if the argu-

ment for an option is optional. This can be specified explicitly by doubling the colon before the message.

If the pattern ends in `((-))', this will removed from the pattern and

the action will be used only directly after the `==', not in the next word. This is the behaviour of a normal specification defined with the

form `==-'.

The `aarrgguummeennttss --' can be followed by the option `-ii patterns' to give

patterns for options which are not to be completed. The patterns can be given as the name of an array parameter or as a literal list in parentheses. For example,

aarrgguummeennttss -- -ii \\

""((--((eenn||ddiiss))aabbllee-FFEEAATTUURREE**))""

will cause completion to ignore the options `--eennaabbllee-FFEEAATTUURREE' and

`--ddiissaabbllee-FFEEAATTUURREE' (this example is useful with GNU ccoonnffiigguurree).

The `aarrgguummeennttss --' form can also be followed by the option `-ss pair'

to describe option aliases. Each pair consists of a pattern and a

replacement. For example, some ccoonnffiigguurree-scripts describe options only

as `--eennaabbllee-ffoooo', but also accept `--ddiissaabbllee-ffoooo'. To allow comple-

tion of the second form:

aarrgguummeennttss -- -ss ""((##--eennaabbllee- --ddiissaabbllee-))""

Here is a more general example of the use of aarrgguummeennttss:

aarrgguummeennttss ''-ll++::lleefftt bboorrddeerr::'' \\

''-ffoorrmmaatt::ppaappeerr ssiizzee::((lleetttteerr AA44))'' \\

''**-ccooppyy::oouuttppuutt ffiillee::ffiilleess::::rreessoolluuttiioonn::((330000 660000))'' \\

''::ppoossttssccrriipptt ffiillee::ffiilleess -gg \\**..\$(ppss\\||eeppss\$)'' \\

''**::ppaaggee nnuummbbeerr::''

This describes three options: `-ll', `-ffoorrmmaatt', and `-ccooppyy'. The first

takes one argument described as `left border' for which no completion will be offered because of the empty action. Its argument may come

directly after the `-ll' or it may be given as the next word on the

line.

The `-ffoorrmmaatt' option takes one argument in the next word, described as

`paper size' for which only the strings `lleetttteerr' and `AA44' will be com-

pleted.

The `-ccooppyy' option may appear more than once on the command line and

takes two arguments. The first is mandatory and will be completed as a filename. The second is optional (because of the second colon before the description `resolution') and will be completed from the strings `330000' and `660000'. The last two descriptions say what should be completed as arguments. The first describes the first argument as a `postscript file' and makes files ending in `ppss' or `eeppss' be completed. The last description gives all other arguments the description `page numbers' but does not offer completions. ccaacchheeiinnvvaalliidd cacheidentifier

This function returns status zero if the completions cache cor-

responding to the given cache identifier needs rebuilding. It

determines this by looking up the ccaacchhee-ppoolliiccyy style for the

current context. This should provide a function name which is run with the full path to the relevant cache file as the only argument. Example: eexxaammpplleeccaacchhiinnggppoolliiccyy (()) {{

## rreebbuuiilldd iiff ccaacchhee iiss mmoorree tthhaann aa wweeeekk oolldd

oollddpp==(( ""$$11""((NNmmww++11)) ))

(((( $$##oollddpp ))))

}} ccaallllffuunnccttiioonn return name [ args ... ] If a function name exists, it is called with the arguments args. The return argument gives the name of a parameter in which the return status from the function name; if return is empty or a single hyphen it is ignored.

The return value of ccaallllffuunnccttiioonn itself is zero if the func-

tion name exists and was called and non-zero otherwise.

ccaallllpprrooggrraamm tag string ... This function provides a mechanism for the user to override the use of an external command. It looks up the ccoommmmaanndd style with the supplied tag. If the style is set, its value is used as the command to execute. The strings from the call to ccaallllpprrooggrraamm, or from the style if set, are concatenated with spaces between them and the resulting string is evaluated. The return value is the return value of the command called.

ccoommbbiinnaattiioonn [ -ss pattern ] tag style spec ... field opts ...

This function is used to complete combinations of values, for example pairs of hostnames and usernames. The style argument gives the style which defines the pairs; it is looked up in a context with the tag specified. The style name consists of field names separated by hyphens, for

example `uusseerrss-hhoossttss-ppoorrttss'. For each field for a value is

already known, a spec of the form `field==pattern' is given. For example, if the command line so far specifies a user `ppwwss', the argument `uusseerrss==ppwwss' should appear. The next argument with no equals sign is taken as the name of the field for which completions should be generated (presumably not one of the fields for which the value is known). The matches generated will be taken from the value of the style. These should contain the possible values for the combinations in the appropriate order (users, hosts, ports in the example above). The different fields the values for the different fields are separated by colons. This can be altered with the

option -ss to ccoommbbiinnaattiioonn which specifies a pattern. Typically

this is a character class, as for example `-ss ""[[::@@]]""' in the

case of the uusseerrss-hhoossttss style. Each `field==pattern' specifi-

cation restricts the completions which apply to elements of the style with appropriately matching fields. If no style with the given name is defined for the given tag, or if none of the strings in style's value match, but a function name of the required field preceded by an underscore is defined,

that function will be called to generate the matches. For exam-

ple, if there is no `uusseerrss-hhoossttss-ppoorrttss' or no matching hostname

when a host is required, the function `hhoossttss' will automati-

cally be called. If the same name is used for more than one field, in both the `field==pattern' and the argument that gives the name of the field to be completed, the number of the field (starting with one) may be given after the fieldname, separated from it by a colon.

All arguments after the required field name are passed to ccoomm-

ppaadddd when generating matches from the style value, or to the functions for the fields if they are called.

ddeessccrriibbee [ -ooOO | -tt tag ] descr name1 [ name2 ] opts ... -- ...

This function associates completions with descriptions. Multi-

ple groups separated by -- can be supplied, potentially with

different completion options opts. The descr is taken as a string to display above the matches if

the ffoorrmmaatt style for the ddeessccrriippttiioonnss tag is set. This is fol-

lowed by one or two names of arrays followed by options to pass to ccoommppaadddd. The first array contains the possible completions with their descriptions in the form `completion::description'. If a second array is given, it should have the same number of elements as the first; in this case the corresponding elements are added as possible completions instead of the completion strings from the first array. The completion list will retain

the descriptions from the first array. Finally, a set of com-

pletion options can appear.

If the option `-oo' appears before the first argument, the

matches added will be treated as names of command options (N.B.

not shell options), typically following a `-', `--' or `++' on

the command line. In this case ddeessccrriibbee uses the pprreeffiixx-hhiidd-

ddeenn, pprreeffiixx-nneeeeddeedd and vveerrbboossee styles to find out if the strings

should be added as completions and if the descriptions should be

shown. Without the `-oo' option, only the vveerrbboossee style is used

to decide how descriptions are shown. If `-OO' is used instead

of `-OO', command options are completed as above but ddeessccrriibbee

will not handle the pprreeffiixx-nneeeeddeedd style.

With the -tt option a tag can be specified. The default is `vvaall-

uueess' or, if the -oo option is given, `ooppttiioonnss'.

If selected by the lliisstt-ggrroouuppeedd style, strings with the same

description will appear together in the list. ddeessccrriibbee uses the aallllllaabbeellss function to generate the matches, so it does not need to appear inside a loop over tag labels.

ddeessccrriippttiioonn [ -xx ] [ -1122VVJJ ] tag name descr [ spec ... ]

This function is not to be confused with the previous one; it is used as a helper function for creating options to ccoommppaadddd. It is buried inside many of the higher level completion functions and so often does not need to be called directly. The styles listed below are tested in the current context using the given tag. The resulting options for ccoommppaadddd are put into the array named name (this is traditionally `eexxppll', but this

convention is not enforced). The description for the corre-

sponding set of matches is passed to the function in descr.

The styles tested are: ffoorrmmaatt, hhiiddddeenn, mmaattcchheerr, iiggnnoorreedd-ppaatttteerrnnss

and ggrroouupp-nnaammee. The ffoorrmmaatt style is first tested for the given

tag and then for the ddeessccrriippttiioonnss tag if no value was found, while the remainder are only tested for the tag given as the first argument. The function also calls sseettuupp which tests some more styles.

The string returned by the ffoorrmmaatt style (if any) will be modi-

fied so that the sequence `%%dd' is replaced by the descr given as

the third argument without any leading or trailing white space. If, after removing the white space, the descr is the empty string, the format style will not be used and the options put into the name array will not contain an explanation string to be displayed above the matches. If ddeessccrriippttiioonn is called with more than three arguments, the additional specs should be of the form `char::str'. These supply

escape sequence replacements for the ffoorrmmaatt style: every appear-

ance of `%%char' will be replaced by string.

If the -xx option is given, the description will be passed to

ccoommppaadddd using the -xx option instead of the default -XX. This

means that the description will be displayed even if there are no corresponding matches. The options placed in the array name take account of the

ggrroouupp-nnaammee style, so matches are placed in a separate group

where necessary. The group normally has its elements sorted (by

passing the option -JJ to ccoommppaadddd), but if an option starting

with `-VV', `-JJ', `-11', or `-22' is passed to ddeessccrriippttiioonn, that

option will be included in the array. Hence it is possible for

the completion group to be unsorted by giving the option `-VV',

`-11VV', or `-22VV'.

In most cases, the function will be used like this: llooccaall eexxppll ddeessccrriippttiioonn ffiilleess eexxppll ffiillee

ccoommppaadddd ""$$eexxppll[[@@]]"" - ""$$ffiilleess[[@@]]""

Note the use of the parameter eexxppll, the hyphen, and the list of

matches. Almost all calls to ccoommppaadddd within the completion sys-

tem use a similar format; this ensures that user-specified

styles are correctly passed down to the builtins which implement the internals of completion. ddiissppaattcchh context string ...

This sets the current context to context and looks for comple-

tion functions to handle this context by hunting through the list of command names or special contexts (as described above for ccoommppddeeff) given as string .... The first completion function to be defined for one of the contexts in the list is used to

generate matches. Typically, the last string is -ddeeffaauulltt- to

cause the function for default completion to be used as a fall-

back.

The function sets the parameter $$sseerrvviiccee to the string being

tried, and sets the context/command field (the fourth) of the

$$ccuurrccoonntteexxtt parameter to the context given as the first argu-

ment. ffiilleess The function ffiilleess calls ppaatthhffiilleess with all the arguments it

was passed except for -gg and -//. The use of these two options

depends on the setting of the ffiillee-ppaatttteerrnnss style.

This function accepts the full set of options allowed by ppaatthhffiilleess, described below. ggnnuuggeenneerriicc This function is a simple wrapper around the aarrgguummeennttss function described above. It can be used to determine automatically the long options understood by commands that produce a list when

passed the option `--hheellpp'. It is intended to be used as a

top-level completion function in its own right. For example, to

enable option completion for the commands ffoooo and bbaarr, use ccoommppddeeff ggnnuuggeenneerriicc ffoooo bbaarr after the call to ccoommppiinniitt. The completion system as supplied is conservative in its use of this function, since it is important to be sure the command

understands the option `-'-hheellpp'.

gguuaarrdd [ options ] pattern descr

This function is intended to be used in the action for the spec-

ifications passed to aarrgguummeennttss and similar functions. It

returns immediately with a non-zero return value if the string

to be completed does not match the pattern. If the pattern matches, the descr is displayed; the function then returns zero

if the word to complete is not empty, non-zero otherwise.

The pattern may be preceded by any of the options understood by

ccoommppaadddd that are passed down from ddeessccrriippttiioonn, namely -MM, -JJ,

-VV, -11, -22, -nn, -FF and -XX. All of these options will be

ignored. This fits in conveniently with the argument-passing

conventions of actions for aarrgguummeennttss.

As an example, consider a command taking the options -nn and

-nnoonnee, where -nn must be followed by a numeric value in the same

word. By using:

aarrgguummeennttss ''-nn-:: ::gguuaarrdd ""[[00-99]]##"" ""nnuummeerriicc vvaalluuee""'' ''-nnoonnee''

aarrgguummeennttss can be made to both display the message `nnuummeerriicc

vvaalluuee' and complete options after `-nn<>'. If the `-nn' is

already followed by one or more digits (the pattern passed to

gguuaarrdd) only the message will be displayed; if the `-nn' is fol-

lowed by another character, only options are completed.

mmeessssaaggee [ -rr1122 ] [ -VVJJ group ] descr

mmeessssaaggee -ee [ tag ] descr

The descr is used in the same way as the third argument to the ddeessccrriippttiioonn function, except that the resulting string will always be shown whether or not matches were generated. This is

useful for displaying a help message in places where no comple-

tions can be generated. The ffoorrmmaatt style is examined with the mmeessssaaggeess tag to find a message; the usual tag, ddeessccrriippttiioonnss, is used only if the style is not set with the former.

If the -rr option is given, no style is used; the descr is taken

literally as the string to display. This is most useful when

the descr comes from a pre-processed argument list which already

contains an expanded description.

The -1122VVJJ options and the group are passed to ccoommppaadddd and hence

determine the group the message string is added to. The second form gives a description for completions with the tag tag to be shown even if there are no matches for that tag. The tag can be omitted and if so the tag is taken from the parameter

$$ccuurrttaagg; this is maintained by the completion system and so is

usually correct. mmuullttiippaarrttss sep array The argument sep is a separator character. The array may be either the name of an array parameter or a literal array in the form `((ffoooo bbaarr))', a parenthesised list of words separated by whitespace. The possible completions are the strings from the array. However, each chunk delimited by sep will be completed separately. For example, the ttaarr function uses `mmuullttiippaarrttss // patharray' to complete partial file paths from the given array of complete file paths.

The -ii option causes mmuullttiippaarrttss to insert a unique match even

if that requires multiple separators to be inserted. This is not usually the expected behaviour with filenames, but certain other types of completion, for example those with a fixed set of possibilities, may be more suited to this form.

Like other utility functions, this function accepts the `-VV',

`-JJ', `-11', `-22', `-nn', `-ff', `-XX', `-MM', `-PP', `-SS', `-rr',

`-RR', and `-qq' options and passes them to the ccoommppaadddd builtin.

nneexxttllaabbeell [ -xx ] [ -1122VVJJ ] tag name descr [ options ... ]

This function is used to implement the loop over different tag

labels for a particular tag as described above for the ttaagg-oorrddeerr

style. On each call it checks to see if there are any more tag

labels; if there is it returns status zero, otherwise non-zero.

As this function requires a current tag to be set, it must always follow a call to ttaaggss or rreeqquueesstteedd.

The -xx1122VVJJ options and the first three arguments are passed to

the ddeessccrriippttiioonn function. Where appropriate the tag will be replaced by a tag label in this call. Any description given in

the ttaagg-oorrddeerr style is preferred to the descr passed to

nneexxttllaabbeell. The options given after the descr are set in the parameter given

by name, and hence are to be passed to ccoommppaadddd or whatever func-

tion is called to add the matches. Here is a typical use of this function for the tag ffoooo. The call to rreeqquueesstteedd determines if tag ffoooo is required at all; the loop over nneexxttllaabbeell handles any labels defined for the tag in

the ttaagg-oorrddeerr style.

llooccaall eexxppll rreett==11 ...... iiff rreeqquueesstteedd ffoooo;; tthheenn ...... wwhhiillee nneexxttllaabbeell ffoooo eexxppll ''......'';; ddoo

ccoommppaadddd ""$$eexxppll[[@@]]"" ...... &&&& rreett==00

ddoonnee ...... ffii rreettuurrnn rreett nnoorrmmaall

This is the standard function called to handle completion out-

side any special -context-. It is called both to complete the

command word and also the arguments for a command. In the sec-

ond case, nnoorrmmaall looks for a special completion for that com-

mand, and if there is none it uses the completion for the

-ddeeffaauulltt- context.

A second use is to reexamine the command line specified by the

$$wwoorrddss array and the $$CCUURRRREENNTT parameter after those have been

modified. For example, the function pprreeccoommmmaanndd, which com-

pletes after pre-command specifiers such as nnoohhuupp, removes the

first word from the wwoorrddss array, decrements the CCUURRRREENNTT parame-

ter, then calls nnoorrmmaall again. The effect is that `nnoohhuupp cmd ...' is treated in the same way as `cmd ...'. If the command name matches one of the patterns given by one of

the options -pp or -PP to ccoommppddeeff, the corresponding completion

function is called and then the parameter ccoommppsskkiipp is checked. If it is set completion is terminated at that point even if no matches have been found. This is the same effect as in the

-ffiirrsstt- context.

ooppttiioonnss This can be used to complete the names of shell options. It provides a matcher specification that ignores a leading `nnoo',

ignores underscores and allows upper-case letters to match their

lower-case counterparts (for example, `gglloobb', `nnoogglloobb',

`NNOOGGLLOOBB' are all completed). Any arguments are propagated to the ccoommppaadddd builtin. ooppttiioonnsssseett and ooppttiioonnssuunnsseett These functions complete only set or unset options, with the same matching specification used in the ooppttiioonnss function.

Note that you need to uncomment a few lines in the mmaaiinnccoomm-

pplleettee function for these functions to work properly. The lines in question are used to store the option settings in effect before the completion widget locally sets the options it needs. Hence these functions are not generally used by the completion system. ppaarraammeetteerrss This is used to complete the names of shell parameters.

The option `-gg pattern' limits the completion to parameters

whose type matches the pattern. The type of a parameter is that

shown by `pprriinntt $${{((tt))param}}', hence judicious use of `**' in pat-

tern is probably necessary. All other arguments are passed to the ccoommppaadddd builtin. ppaatthhffiilleess

This function is used throughout the completion system to com-

plete filenames. It allows completion of partial paths. For example, the string `//uu//ii//ss//ssiigg' may be completed to `//uussrr//iinncclluuddee//ssyyss//ssiiggnnaall..hh'. The options accepted by both ppaatthhffiilleess and ffiilleess are:

-ff Complete all filenames. This is the default.

-// Specifies that only directories should be completed.

-gg pattern

Specifies that only files matching the pattern should be completed.

-WW paths

Specifies path prefixes that are to be prepended to the string from the command line to generate the filenames but that should not be inserted as completions nor shown in completion listings. Here, paths may be the name of an array parameter, a literal list of paths enclosed in parentheses or an absolute pathname.

-FF ignored-files

This behaves as for the corresponding option to the ccoomm-

ppaadddd builtin. It gives direct control over which file-

names should be ignored. If the option is not present,

the iiggnnoorreedd-ppaatttteerrnnss style is used.

Both ppaatthhffiilleess and ffiilleess also accept the following options

which are passed to ccoommppaadddd: `-JJ', `-VV', `-11', `-22', `-nn', `-XX',

`-MM', `-PP', `-SS', `-qq', `-rr', and `-RR'.

Finally, the ppaatthhffiilleess function uses the styles eexxppaanndd,

aammbbiigguuoouuss, ssppeecciiaall-ddiirrss, lliisstt-ssuuffffiixxeess and ffiillee-ssoorrtt described

above.

ppiicckkvvaarriiaanntt [[ -cc command ]] [[ -rr name ]] label==pattern ...... label [[ args

...... ]]

This function is used to resolve situations where a single com-

mand name requires more than one type of handling, either because it has more than one variant or because there is a name clash between two different commands. The command to run is taken from the first element of the array

wwoorrddss unless this is overridden by the option -cc. This command

is run and its output is compared with a series of patterns. Arguments to be passed to the command can be specified at the end after all the other arguments. The patterns to try in order

are given by the arguments label==pattern; if the output of `com-

mand args ......' contains pattern, then llaabbeell is selected as the label for the command variant. If none of the patterns match, the final command label is selected and status 1 is returned.

If the `-rr name' is given, the label picked is stored in the

parameter named name. The results are also cached in the cmdvariant associative array indexed by the name of the command run. rreeggeexxaarrgguummeennttss name spec ... This function generates a completion function name which matches the specifications spec ......, a set of regular expressions as described below. After running rreeggeexxaarrgguummeennttss, the function name should be called at the appropriate point. The pattern to be matched is given by the contents of the wwoorrddss array up to the current cursor position joined together with null characters; no quotation is applied. The arguments are grouped as sets of alternatives separated by `||', which are tried one after the other until one matches. Each alternative consists of a one or more specifications which are tried left to right, with each pattern matched being stripped in turn from the command line being tested, until all of the group succeeds or until one fails; in the latter case, the next alternative is tried. This structure can be repeated to arbitrary depth by using parentheses; matching proceeds from inside to outside. A special procedure is applied if no test succeeds but the

remaining command line string contains no null character (imply-

ing the remaining word is the one for which completions are to be generated). The completion target is restricted to the remaining word and any actions for the corresponding patterns

are executed. In this case, nothing is stripped from the com-

mand line string. The order of evaluation of the actions can be

determined by the ttaagg-oorrddeerr style; the various formats supported

by aalltteerrnnaattiivvee can be used in action. The descr is used for setting up the array parameter eexxppll. Specification arguments take one of following forms, in which

metacharacters such as `((', `))', `##' and `||' should be quoted.

//pattern// [%%lookahead%%] [-guard] [::tag::descr::action]

This is a single primitive component. The function tests

whether the combined pattern `((##bb))((((##BB))pattern))looka-

head**' matches the command line string. If so, `guard'

is evaluated and its return status is examined to deter-

mine if the test has succeeded. The pattern string `[[]]' is guaranteed never to match. The lookahead is not stripped from the command line before the next pattern is examined.

//pattern//++ [%%lookahead%%] [-guard] [::tag::descr::action]

This is similar to `//pattern// ...' but the left part of the command line string (i.e. the part already matched by

previous patterns) is also considered part of the comple-

tion target.

//pattern//- [%%lookahead%%] [-guard] [::tag::descr::action]

This is similar to `//pattern// ...' but the actions of the current and previously matched patterns are ignored even if the following `pattern' matches the empty string. (( spec ))

Parentheses may be used to groups specs; note each paren-

thesis is a single argument to rreeggeexxaarrgguummeennttss.

spec ## This allows any number of repetitions of spec.

spec spec The two specs are to be matched one after the other as described above. spec || spec Either of the two specs can be matched.

rreeqquueesstteedd [ -xx ] [ -1122VVJJ ] tag [ name descr [ command args ... ] ]

This function is called to decide whether a tag already regis-

tered by a call to ttaaggss (see below) has been requested by the user and hence completion should be performed for it. It

returns status zero if the tag is requested and non-zero other-

wise. The function is typically used as part of a loop over different tags as follows: ttaaggss ffoooo bbaarr bbaazz wwhhiillee ttaaggss;; ddoo iiff rreeqquueesstteedd ffoooo;; tthheenn

...... ## ppeerrffoorrmm ccoommpplleettiioonn ffoorr ffoooo

ffii

...... ## tteesstt tthhee ttaaggss bbaarr aanndd bbaazz iinn tthhee ssaammee wwaayy

...... ## eexxiitt lloooopp iiff mmaattcchheess wweerree ggeenneerraatteedd

ddoonnee Note that the test for whether matches were generated is not performed until the end of the ttaaggss loop. This is so that the

user can set the ttaagg-oorrddeerr style to specify a set of tags to be

completed at the same time. If name and descr are given, rreeqquueesstteedd calls the ddeessccrriippttiioonn function with these arguments together with the options passed to rreeqquueesstteedd. If command is given, the aallllllaabbeellss function will be called immediately with the same arguments. In simple cases this makes it possible to perform the test for the tag and the matching in one go. For example: llooccaall eexxppll rreett==11 ttaaggss ffoooo bbaarr bbaazz wwhhiillee ttaaggss;; ddoo rreeqquueesstteedd ffoooo eexxppll ''ddeessccrriippttiioonn'' \\ ccoommppaadddd ffoooobbaarr ffoooobbaazz &&&& rreett==00 ...... (((( rreett )))) |||| bbrreeaakk ddoonnee If the command is not ccoommppaadddd, it must nevertheless be prepared to handle the same options. rreettrriieevveeccaacchhee cacheidentifier This function retrieves completion information from the file given by cacheidentifier, stored in a directory specified by

the ccaacchhee-ppaatthh style which defaults to ~~//..zzccoommppccaacchhee. The

return value is zero if retrieval was successful. It will only

attempt retrieval if the uussee-ccaacchhee style is set, so you can call

this function without worrying about whether the user wanted to use the caching layer. See ssttoorreeccaacchhee below for more details. sseeppppaarrttss This function is passed alternating arrays and separators as arguments. The arrays specify completions for parts of strings to be separated by the separators. The arrays may be the names of array parameters or a quoted list of words in parentheses. For example, with the array `hhoossttss==((ffttpp nneewwss))' the call `sseeppppaarrttss ''((ffoooo bbaarr))'' @@ hhoossttss' will complete the string `ff' to `ffoooo' and the string `bb@@nn' to `bbaarr@@nneewwss'.

This function accepts the ccoommppaadddd options `-VV', `-JJ', `-11',

`-22', `-nn', `-XX', `-MM', `-PP', `-SS', `-rr', `-RR', and `-qq' and

passes them on to the ccoommppaadddd builtin used to add the matches. sseettuupp tag [ group ]

This function sets up the special parameters used by the comple-

tion system appropriately for the tag given as the first argu-

ment. It uses the styles lliisstt-ccoolloorrss, lliisstt-ppaacckkeedd,

lliisstt-rroowwss-ffiirrsstt, llaasstt-pprroommpptt, aacccceepptt-eexxaacctt, mmeennuu and ffoorrccee-lliisstt.

The optional group supplies the name of the group in which the matches will be placed. If it is not given, the tag is used as the group name. This function is called automatically from ddeessccrriippttiioonn and hence is not normally called explicitly. ssttoorreeccaacchhee cacheidentifier params ... This function, together with rreettrriieevveeccaacchhee and ccaacchheeiinnvvaalliidd, implements a caching layer which can be used in any completion function. Data obtained by costly operations are stored in

parameters; this function then dumps the values of those parame-

ters to a file. The data can then be retrieved quickly from that file via rreettrriieevveeccaacchhee, even in different instances of the shell. The cacheidentifier specifies the file which the data should be dumped to. The file is stored in a directory specified by the

ccaacchhee-ppaatthh style which defaults to ~~//..zzccoommppccaacchhee. The remaining

params arguments are the parameters to dump to the file.

The return value is zero if storage was successful. The func-

tion will only attempt storage if the uussee-ccaacchhee style is set, so

you can call this function without worrying about whether the user wanted to use the caching layer. The completion function may avoid calling rreettrriieevveeccaacchhee when it already has the completion data available as parameters. However, in that case it should call ccaacchheeiinnvvaalliidd to check whether the data in the parameters and in the cache are still valid. See the perlmodules completion function for a simple example of the usage of the caching layer.

ttaaggss [ [ -CC name ] tags ... ]

If called with arguments, these are taken to be the names of tags valid for completions in the current context. These tags

are stored internally and sorted by using the ttaagg-oorrddeerr style.

Next, ttaaggss is called repeatedly without arguments from the same

completion function. This successively selects the first, sec-

ond, etc. set of tags requested by the user. The return value

is zero if at least one of the tags is requested and non-zero

otherwise. To test if a particular tag is to be tried, the rreeqquueesstteedd function should be called (see above).

If `-CC name' is given, name is temporarily stored in the argu-

ment field (the fifth) of the context in the ccuurrccoonntteexxtt parame-

ter during the call to ttaaggss; the field is restored on exit. This allows ttaaggss to use a more specific context without having to change and reset the ccuurrccoonntteexxtt parameter (which has the same effect).

vvaalluueess [ -OO name ] [ -ss sep ] [ -SS sep ] [ -wwCC ] desc spec ...

This is used to complete arbitrary keywords (values) and their arguments, or lists of such combinations.

If the first argument is the option `-OO name', it will be used

in the same way as by the aarrgguummeennttss function. In other words, the elements of the name array will be passed to ccoommppaadddd when executing an action.

If the first argument (or the first argument after `-OO name') is

`-ss', the next argument is used as the character that separates

multiple values. This character is automatically added after

each value in an auto-removable fashion (see below); all values

completed by `vvaalluueess -ss' appear in the same word on the command

line, unlike completion using aarrgguummeennttss. If this option is not present, only a single value will be completed per word. Normally, vvaalluueess will only use the current word to determine which values are already present on the command line and hence

are not to be completed again. If the -ww option is given, other

arguments are examined as well.

The first non-option argument is used as a string to print as a

description before listing the values.

All other arguments describe the possible values and their argu-

ments in the same format used for the description of options by the aarrgguummeennttss function (see above). The only differences are that no minus or plus sign is required at the beginning, values can have only one argument, and the forms of action beginning with an equal sign are not supported. The character separating a value from its argument can be set

using the option -SS (like -ss, followed by the character to use

as the separator in the next argument). By default the equals sign will be used as the separator between values and arguments. Example:

vvaalluueess -ss ,, ''ddeessccrriippttiioonn'' \\

''**ffoooo[[bbaarr]]'' \\ ''((ttwwoo))**oonnee[[nnuummbbeerr]]::ffiirrsstt ccoouunntt::'' \\ ''ttwwoo[[aannootthheerr nnuummbbeerr]]::::sseeccoonndd ccoouunntt::((11 22 33))'' This describes three possible values: `ffoooo', `oonnee', and `ttwwoo'. The first is described as `bbaarr', takes no argument and may appear more than once. The second is described as `nnuummbbeerr', may appear more than once, and takes one mandatory argument described as `ffiirrsstt ccoouunntt'; no action is specified, so it will not be completed. The `((ttwwoo))' at the beginning says that if the value `oonnee' is on the line, the value `ttwwoo' will no longer be considered a possible completion. Finally, the last value (`ttwwoo') is described as `aannootthheerr nnuummbbeerr' and takes an optional argument described as `sseeccoonndd ccoouunntt' for which the completions (to appear after an `==') are `11', `22', and `33'. The vvaalluueess

function will complete lists of these values separated by com-

mas. Like aarrgguummeennttss, this function temporarily adds another context

name component to the arguments element (the fifth) of the cur-

rent context while executing the action. Here this name is just the name of the value for which the argument is completed. The style vveerrbboossee is used to decide if the descriptions for the values (but not those for the arguments) should be printed. The associative array vvaallaarrggss is used to report values and

their arguments; this works similarly to the ooppttaarrggss associa-

tive array used by aarrgguummeennttss. Hence the function calling vvaall-

uueess should declare the local parameters ssttaattee, lliinnee, ccoonntteexxtt and vvaallaarrggss: llooccaall ccoonntteexxtt ssttaattee lliinnee

ttyyppeesseett -AA vvaallaarrggss

when using an action of the form `->>string'. With this function

the ccoonntteexxtt parameter will be set to the name of the value whose argument is to be completed. Note also that vvaalluueess normally adds the character used as the

separator between values as an auto-removable suffix (similar to

a `//' after a directory). However, this is not possible for a

`->>string' action as the matches for the argument are generated

by the calling function. To get the usual behaviour, the the calling function can add the separator x as a suffix by passing

the options `-qqSS x' either directly or indirectly to ccoommppaadddd.

The option -CC is treated in the same way as it is by aarrgguummeennttss.

In that case the parameter ccuurrccoonntteexxtt should be made local instead of ccoonntteexxtt (as described above).

wwaanntteedd [ -xx ] [ -CC name ] [ -1122VVJJ ] tag name descr command args ...

In many contexts, completion can only generate one particular set of matches, usually corresponding to a single tag. However, it is still necessary to decide whether the user requires matches of this type. This function is useful in such a case. The arguments to wwaanntteedd are the same as those to rreeqquueesstteedd, i.e. arguments to be passed to ddeessccrriippttiioonn. However, in this case the command is not optional; all the processing of tags,

including the loop over both tags and tag labels and the genera-

tion of matches, is carried out automatically by wwaanntteedd.

Hence to offer only one tag and immediately add the correspond-

ing matches with the given description: wwaanntteedd ttaagg eexxppll ''ddeessccrriippttiioonn'' \\ ccoommppaadddd mmaattcchheess...... Note that, as for rreeqquueesstteedd, the command must be able to accept options to be passed down to ccoommppaadddd.

Like ttaaggss this function supports the -CC option to give a dif-

ferent name for the argument context field. The -xx option has

the same meaning as for ddeessccrriippttiioonn. CCOOMMPPLLEETTIIOONN DDIIRREECCTTOORRIIEESS

In the source distribution, the files are contained in various subdi-

rectories of the CCoommpplleettiioonn directory. They may have been installed in

the same structure, or into one single function directory. The follow-

ing is a description of the files found in the original directory structure. If you wish to alter an installed file, you will need to copy it to some directory which appears earlier in your ffppaatthh than the standard directory where it appears. BBaassee The core functions and special completion widgets automatically bound to keys. You will certainly need most of these, though

will probably not need to alter them. Many of these are docu-

mented above. ZZsshh Functions for completing arguments of shell builtin commands and utility functions for this. Some of these are also used by functions from the UUnniixx directory. UUnniixx Functions for completing arguments of external commands and suites of commands. They may need modifying for your system,

although in many cases some attempt is made to decide which ver-

sion of a command is present. For example, completion for the mmoouunntt command tries to determine the system it is running on, while completion for many other utilities try to decide whether the GNU version of the command is in use, and hence whether the

--hheellpp option is supported.

XX, AAIIXX, BBSSDD, ... Completion and utility function for commands available only on some systems. These are not arranged hierarchically, so, for example, both the LLiinnuuxx and DDeebbiiaann directories, as well as the XX directory, may be useful on your system. zsh 4.2.3 January 13, 2005 ZSHCOMPSYS(1)