This is zsh.info, produced by makeinfo version 4.0 from ./zsh.texi.

INFO-DIR-SECTION Utilities
START-INFO-DIR-ENTRY
* ZSH: (zsh).                     The Z Shell Manual.
END-INFO-DIR-ENTRY


File: zsh.info,  Node: Other Functions,  Prev: MIME Functions,  Up: User Contributions

Other Functions
===============

There are a large number of helpful functions in the Functions/Misc
directory of the zsh distribution.  Most are very simple and do not
require documentation here, but a few are worthy of special mention.

Descriptions
------------

colors
     This function initializes several associative arrays to map color
     names to (and from) the ANSI standard eight-color terminal codes.
     These are used by the prompt theme system (*Note Prompt Themes::).
     You seldom should need to run colors more than once.

     The eight base colors are: black, red, green, yellow, blue,
     magenta, cyan, and white.  Each of these has codes for foreground
     and background.  In addition there are eight intensity attributes:
     bold, faint, standout, underline, blink, reverse, and conceal.
     Finally, there are six codes used to negate attributes: none
     (reset all attributes to the defaults), normal (neither bold nor
     faint), no-standout, no-underline, no-blink, and no-reverse.

     Some terminals do not support all combinations of colors and
     intensities.

     The associative arrays are:

    color
    colour
          Map all the color names to their integer codes, and integer
          codes to the color names.  The eight base names map to the
          foreground color codes, as do names prefixed with `fg-', such
          as `fg-red'.  Names prefixed with `bg-', such as `bg-blue',
          refer to the background codes.  The reverse mapping from code
          to color yields base name for foreground codes and the bg-
          form for backgrounds.

          Although it is a misnomer to call them `colors', these arrays
          also map the other fourteen attributes from names to codes
          and codes to names.

    fg
    fg_bold
    fg_no_bold
          Map the eight basic color names to ANSI terminal escape
          sequences that set the corresponding foreground text
          properties.  The fg sequences change the color without
          changing the eight intensity attributes.

    bg
    bg_bold
    bg_no_bold
          Map the eight basic color names to ANSI terminal escape
          sequences that set the corresponding background properties.
          The bg sequences change the color without changing the eight
          intensity attributes.

     In addition, the scalar parameters reset_color and bold_color are
     set to the ANSI terminal escapes that turn off all attributes and
     turn on bold intensity, respectively.

fned NAME
     Same as zed -f.  This function does not appear in the zsh
     distribution, but can be created by linking zed to the name fned
     in some directory in your fpath.

is-at-least NEEDED [ PRESENT ]
     Perform a greater-than-or-equal-to comparison of two strings
     having the format of a zsh version number; that is, a string of
     numbers and text with segments separated by dots or dashes.  If
     the PRESENT string is not provided, $ZSH_VERSION is used.
     Segments are paired left-to-right in the two strings with leading
     non-number parts ignored.  If one string has fewer segments than
     the other, the missing segments are considered zero.

     This is useful in startup files to set options and other state
     that are not available in all versions of zsh.

          is-at-least 3.1.6-15 && setopt NO_GLOBAL_RCS
          is-at-least 3.1.0 && setopt HIST_REDUCE_BLANKS
          is-at-least 2.6-17 || print "You can't use is-at-least here."

nslookup [ ARG ... ]
     This wrapper function for the nslookup command requires the
     zsh/zpty module (see *Note The zsh/zpty Module::).  It behaves
     exactly like the standard nslookup except that it provides
     customizable prompts (including a right-side prompt) and
     completion of nslookup commands, host names, etc. (if you use the
     function-based completion system).  Completion styles may be set
     with the context prefix `:completion:nslookup'.

     See also the pager, prompt and rprompt styles below.

run-help
     See `Accessing On-Line Help' (*Note Utilities::).

tetris
     Zsh was once accused of not being as complete as Emacs, because it
     lacked a Tetris game.  This function was written to refute this
     vicious slander.

     This function must be used as a ZLE widget:

          autoload -U tetris
          zle -N tetris
          bindkey KEYS tetris

     To start a game, execute the widget by typing the KEYS.  Whatever
     command line you were editing disappears temporarily, and your
     keymap is also temporarily replaced by the Tetris control keys.
     The previous editor state is restored when you quit the game (by
     pressing `q') or when you lose.

     If you quit in the middle of a game, the next invocation of the
     tetris widget will continue where you left off.  If you lost, it
     will start a new game.

zargs [ OPTION ... -- ] [ INPUT ... ] [ -- COMMAND [ ARG ... ] ]
     This function works like GNU xargs, except that instead of reading
     lines of arguments from the standard input, it takes them from the
     command line.  This is useful because zsh, especially with
     recursive glob operators, often can construct a command line for a
     shell function that is longer than can be accepted by an external
     command.

     The OPTION list represents options of the zargs command itself,
     which are the same as those of xargs.  The INPUT list is the
     collection of strings (often file names) that become the arguments
     of the command, analogous to the standard input of xargs.
     Finally, the ARG list consists of those arguments (usually
     options) that are passed to the COMMAND each time it runs.  The
     ARG list precedes the elements from the input list in each run.
     If no COMMAND is provided, then no ARG list may be provided, and
     in that event the default command is `print' with arguments `-r
     --'.

     For example, to get a long ls listing of all plain files in the
     current directory or its subdirectories:

          autoload -U zargs
          zargs -- **/*(.) -- ls -l

     Note that `--' is used both to mark the end of the OPTION list and
     to mark the end of the INPUT list, so it must appear twice
     whenever the INPUT list may be empty.  If there is guaranteed to be
     at least one INPUT and the first INPUT does not begin with a `-',
     then the first `--' may be omitted.

     In the event that the string `--' is or may be an INPUT, the -e
     option may be used to change the end-of-inputs marker.  Note that
     this does _not_ change the end-of-options marker.  For example, to
     use `..' as the marker:

          zargs -e.. -- **/*(.) .. ls -l

     This is a good choice in that example because no plain file can be
     named `..', but the best end-marker depends on the circumstances.

     For details of the other zargs options, see man page xargs(1) or
     run zargs with the --help option.

zcalc [ EXPRESSION ... ]
     A reasonably powerful calculator based on zsh's arithmetic
     evaluation facility.  The syntax is similar to that of formulae in
     most programming languages; see *Note Arithmetic Evaluation:: for
     details.  The mathematical library zsh/mathfunc will be loaded if
     it is available; see *Note The zsh/mathfunc Module::.  The
     mathematical functions correspond to the raw system libraries, so
     trigonometric functions are evaluated using radians, and so on.

     Each line typed is evaluated as an expression.  The prompt shows a
     number, which corresponds to a positional parameter where the
     result of that calculation is stored.  For example, the result of
     the calculation on the line preceded by `4> ' is available as $4.
     Full command line editing, including the history of previous
     calculations, is available; the history is saved in the file
     ~/.zcalc_history.  To exit, enter a blank line or type `q' on its
     own.

     If arguments are given to zcalc on start up, they are used to
     prime the first few positional parameters.  A visual indication of
     this is given when the calculator starts.

     The constants PI (3.14159...) and E (2.71828...) are provided.
     Parameter assignment is possible, but note that all parameters
     will be put into the global namespace.

     An extra facility is provided for changing the default output
     base.  Use, for example, `[#16]' to display hexadecimal output
     preceded by an indication of the base, or `[##16]' just to display
     the raw number in the given base.  Bases themselves are always
     specified in decimal.  `[#]' restores the normal output format.

     The output base can be initialised by passing the option `-#BASE',
     for example `zcalc -#16' (the `#' may have to be quoted, depending
     on the globbing options set).

     The prompt is configurable via the parameter ZCALCPROMPT, which
     undergoes standard prompt expansion.  The index of the current
     entry is stored locally in the first element of the array psvar,
     which can be referred to in ZCALCPROMPT as `%1v'.  The default
     prompt is `%1v> '.

     See the comments in the function for a few extra tips.

zed [ -f ] NAME
zed -b
     This function uses the ZLE editor to edit a file or function.

     Only one NAME argument is allowed.  If the -f option is given, the
     name is taken to be that of a function; if the function is marked
     for autoloading, zed searches for it in the fpath and loads it.
     Note that functions edited this way are installed into the current
     shell, but _not_ written back to the autoload file.

     Without -f, NAME is the path name of the file to edit, which need
     not exist; it is created on write, if necessary.

     While editing, the function sets the main keymap to zed and the vi
     command keymap to zed-vicmd.  These will be copied from the
     existing main and vicmd keymaps if they do not exist the first
     time zed is run.  They can be used to provide special key bindings
     used only in zed.

     If it creates the keymap, zed rebinds the return key to insert a
     line break and `^X^W' to accept the edit in the zed keymap, and
     binds `ZZ' to accept the edit in the zed-vicmd keymap.

     The bindings alone can be installed by running `zed -b'.  This is
     suitable for putting into a startup file.  Note that, if rerun,
     this will overwrite the existing zed and zed-vicmd keymaps.

     Completion is available, and styles may be set with the context
     prefix `:completion:zed'.

     A zle widget zed-set-file-name is available.  This can be called by
     name from within zed using `\ex zed-set-file-name' (note, however,
     that because of zed's rebindings you will have to type ^j at the
     end instead of the return key), or can be bound to a key in either
     of the zed or zed-vicmd keymaps after `zed -b' has been run.  When
     the widget is called, it prompts for a new name for the file being
     edited.  When zed exits the file will be written under that name
     and the original file will be left alone.  The widget has no
     effect with `zed -f'.

     While zed-set-file-name is running, zed uses the keymap
     zed-normal-keymap, which is linked from the main keymap in effect
     at the time zed initialised its bindings.  (This is to make the
     return key operate normally.)  The result is that if the main
     keymap has been changed, the widget won't notice.  This is not a
     concern for most users.

zcp [ -finqQvwW ] SRCPAT DEST
zln [ -finqQsvwW ] SRCPAT DEST
     Same as zmv -C and zmv -L, respectively.  These functions do not
     appear in the zsh distribution, but can be created by linking zmv
     to the names zcp and zln in some directory in your fpath.

zkbd
     See `Keyboard Definition' (*Note Utilities::).

zmv [ -finqQsvwW ] [ -C | -L | -M | -p PROGRAM ] [ -o OPTSTRING ] SRCPAT DEST
     Move (usually, rename) files matching the pattern SRCPAT to
     corresponding files having names of the form given by DEST, where
     SRCPAT contains parentheses surrounding patterns which will be
     replaced in turn by $1, $2, ... in DEST.  For example,

          zmv '(*).lis' '$1.txt'

     renames `foo.lis' to `foo.txt', `my.old.stuff.lis' to
     `my.old.stuff.txt', and so on.

     The pattern is always treated as an EXTENDED_GLOB pattern.  Any
     file whose name is not changed by the substitution is simply
     ignored.  Any error (a substitution resulted in an empty string,
     two substitutions gave the same result, the destination was an
     existing regular file and -f was not given) causes the entire
     function to abort without doing anything.

     Options:

    -f
          Force overwriting of destination files.  Not currently passed
          down to the mv/cp/ln command due to vagaries of
          implementations (but you can use -o-f to do that).

    -i
          Interactive: show each line to be executed and ask the user
          whether to execute it.  `Y' or `y' will execute it, anything
          else will skip it.  Note that you just need to type one
          character.

    -n
          No execution: print what would happen, but don't do it.

    -q
          Turn bare glob qualifiers off: now assumed by default, so
          this has no effect.

    -Q
          Force bare glob qualifiers on.  Don't turn this on unless you
          are actually using glob qualifiers in a pattern.

    -s
          Symbolic, passed down to ln; only works with -L.

    -v
          Verbose: print each command as it's being executed.

    -w
          Pick out wildcard parts of the pattern, as described above,
          and implicitly add parentheses for referring to them.

    -W
          Just like -w, with the addition of turning wildcards in the
          replacement pattern into sequential ${1} .. ${N} references.

    -C
    -L
    -M
          Force cp, ln or mv, respectively, regardless of the name of
          the function.

    -p PROGRAM
          Call PROGRAM instead of cp, ln or mv.  Whatever it does, it
          should at least understand the form
               PROGRAM -- OLDNAME NEWNAME
          where OLDNAME and NEWNAME are filenames generated by zmv.

    -o OPTSTRING
          The OPTSTRING is split into words and passed down verbatim to
          the cp, ln or mv command called to perform the work.  It
          should probably begin with a `-'.

     For more complete examples and other implementation details, see
     the zmv source file, usually located in one of the directories
     named in your fpath, or in Functions/Misc/zmv in the zsh
     distribution.

zrecompile
     See `Recompiling Functions' (*Note Utilities::).

zstyle+ CONTEXT STYLE VALUE [ + SUBCONTEXT STYLE VALUE ... ]
     This makes defining styles a bit simpler by using a single `+' as a
     special token that allows you to append a context name to the
     previously used context name.  Like this:

          zstyle+ ':foo:bar' style1 value1 \
                + ':baz'     style2 value2 \
                + ':frob'    style3 value3

     This defines `style1' with `value1' for the context :foo:bar as
     usual, but it also defines `style2' with `value2' for the context
     :foo:bar:baz and `style3' with `value3' for :foo:bar:frob.  Any
     SUBCONTEXT may be the empty string to re-use the first context
     unchanged.

Styles
------

insert-tab
     The zed function _sets_ this style in context `:completion:zed:*'
     to turn off completion when TAB is typed at the beginning of a
     line.  You may override this by setting your own value for this
     context and style.

pager
     The nslookup function looks up this style in the context
     `:nslookup' to determine the program used to display output that
     does not fit on a single screen.

prompt
rprompt
     The nslookup function looks up this style in the context
     `:nslookup' to set the prompt and the right-side prompt,
     respectively.  The usual expansions for the PS1 and RPS1
     parameters may be used (see *Note Prompt Expansion::).


File: zsh.info,  Node: Concept Index,  Next: Variables Index,  Prev: Top,  Up: Top

Concept Index
*************

* Menu:

* $0, setting:                           Description of Options.
* -help:                                 Invocation.
* -version:                              Invocation.
* .zwc files, creation:                  Shell Builtin Commands.
* acquiring zsh by FTP:                  Availability.
* aliases, completion of:                Description of Options.
* aliases, defining:                     Shell Builtin Commands.
* aliases, expansion:                    Description of Options.
* aliases, global:                       Aliasing.
* aliases, listing:                      Shell Builtin Commands.
* aliases, removing:                     Shell Builtin Commands.
* aliasing:                              Aliasing.
* alternate forms for complex commands:  Alternate Forms For Complex Commands.
* always blocks:                         Complex Commands.
* ambiguous completion:                  Description of Options.
* annoying keyboard, sun:                Description of Options.
* argument splitting, in typeset etc.:   Description of Options.
* arithmetic base:                       Arithmetic Evaluation.
* arithmetic evaluation:                 Arithmetic Evaluation.
* arithmetic expansion:                  Arithmetic Expansion.
* arithmetic operators:                  Arithmetic Evaluation.
* array assignment:                      Array Parameters.
* array expansion style, rc:             Parameter Expansion.
* array parameters, setting:             Shell Builtin Commands.
* array style, ksh:                      Description of Options.
* arrays, ksh style:                     Description of Options.
* assignment:                            Parameters.
* author:                                Author.
* autoloading functions <1>:             Shell Builtin Commands.
* autoloading functions:                 Functions.
* availability of zsh:                   Availability.
* background jobs, I/O:                  Jobs & Signals.
* background jobs, notification:         Description of Options.
* background jobs, priority of:          Description of Options.
* bases, in arithmetic:                  Arithmetic Evaluation.
* bases, output in C format:             Description of Options.
* beep, ambiguous completion:            Description of Options.
* beep, enabling:                        Description of Options.
* beep, history:                         Description of Options.
* binding keys:                          Zle Builtins.
* binding widgets:                       Zle Builtins.
* bindings, key:                         Keymaps.
* brace expansion:                       Brace Expansion.
* brace expansion, disabling:            Description of Options.
* brace expansion, extending:            Description of Options.
* builtin commands:                      Shell Builtin Commands.
* builtins, utility:                     The zsh/zutil Module.
* calling widgets:                       Zle Builtins.
* capabilities, getting from files:      The zsh/cap Module.
* capabilities, setting:                 The zsh/cap Module.
* capabilities, setting on files:        The zsh/cap Module.
* case selection:                        Complex Commands.
* case-insensitive globbing, option:     Description of Options.
* cd, automatic:                         Description of Options.
* cd, behaving like pushd:               Description of Options.
* cd, to parameter:                      Description of Options.
* cd, with .. in argument:               Description of Options.
* character classes:                     Filename Generation.
* clobbering, of files:                  Description of Options.
* cloning the shell:                     The zsh/clone Module.
* colon modifiers:                       Modifiers.
* command execution:                     Command Execution.
* command execution, enabling:           Description of Options.
* command hashing:                       Description of Options.
* command substitution:                  Command Substitution.
* commands, alternate forms for complex: Alternate Forms For Complex Commands.
* commands, builtin:                     Shell Builtin Commands.
* commands, complex:                     Complex Commands.
* commands, disabling:                   Shell Builtin Commands.
* commands, enabling:                    Shell Builtin Commands.
* commands, simple:                      Simple Commands & Pipelines.
* commands, tracing:                     Description of Options.
* comments:                              Comments.
* comments, in interactive shells:       Description of Options.
* compatibility:                         Compatibility.
* compatibility, csh:                    Shell Builtin Commands.
* compatibility, ksh:                    Shell Builtin Commands.
* compatibility, sh:                     Shell Builtin Commands.
* compdef, use of by compinit:           Initialization.
* compilation:                           Shell Builtin Commands.
* completion system:                     Completion System.
* completion system, adding definitions: Initialization.
* completion system, autoloaded functions: Initialization.
* completion system, bindable commands:  Bindable Commands.
* completion system, choosing completers: Control Functions.
* completion system, completers:         Control Functions.
* completion system, configuration:      Completion System Configuration.
* completion system, directory structure: Completion Directories.
* completion system, initializing:       Initialization.
* completion system, installing:         Initialization.
* completion system, styles:             Completion System Configuration.
* completion system, tags:               Completion System Configuration.
* completion system, utility functions:  Completion Functions.
* completion widgets, adding specified matches: Builtin Commands.
* completion widgets, condition codes:   Condition Codes.
* completion widgets, creating:          Zle Builtins.
* completion widgets, examining and setting state in: Special Parameters.
* completion widgets, example:           Completion Widget Example.
* completion widgets, modifying special parameters: Builtin Commands.
* completion, ambiguous:                 Description of Options.
* completion, beep on ambiguous:         Description of Options.
* completion, coloured listings:         The zsh/complist Module.
* completion, controlling <1>:           Completion Widgets.
* completion, controlling <2>:           Completion System.
* completion, controlling:               Completion Using compctl.
* completion, exact matches:             Description of Options.
* completion, listing <1>:               Description of Options.
* completion, listing:                   The zsh/complist Module.
* completion, listing choices:           Description of Options.
* completion, listing choices, bash style: Description of Options.
* completion, listing order:             Description of Options.
* completion, menu:                      Description of Options.
* completion, programmable <1>:          Completion System.
* completion, programmable <2>:          Completion Widgets.
* completion, programmable:              Completion Using compctl.
* completion, scroll listings:           The zsh/complist Module.
* completion, selecting by cursor:       The zsh/complist Module.
* completion, utility:                   The zsh/computil Module.
* completion, widgets:                   Completion Widgets.
* complex commands:                      Complex Commands.
* conditional expression:                Complex Commands.
* conditional expressions:               Conditional Expressions.
* continuing jobs automatically:         Description of Options.
* continuing loops:                      Shell Builtin Commands.
* coprocess:                             Simple Commands & Pipelines.
* correction, spelling:                  Description of Options.
* csh, compatibility:                    Shell Builtin Commands.
* csh, history style:                    Description of Options.
* csh, loop style:                       Description of Options.
* csh, null command style:               Parameters Used By The Shell.
* csh, null globbing style:              Description of Options.
* csh, quoting style:                    Description of Options.
* csh, redirections with no command:     Description of Options.
* date string, printing:                 The zsh/datetime Module.
* defining widgets:                      Zle Builtins.
* descriptors, file:                     Redirection.
* directories, changing:                 Shell Builtin Commands.
* directories, hashing:                  Description of Options.
* directories, marking:                  Description of Options.
* directories, named <1>:                Filename Expansion.
* directories, named:                    Description of Options.
* directory stack, controlling syntax:   Description of Options.
* directory stack, ignoring duplicates:  Description of Options.
* directory stack, printing:             Shell Builtin Commands.
* directory stack, silencing:            Description of Options.
* disabling brace expansion:             Description of Options.
* disabling commands:                    Shell Builtin Commands.
* disowning jobs:                        Jobs & Signals.
* doing nothing:                         Shell Builtin Commands.
* doing nothing, successfully:           Shell Builtin Commands.
* doing nothing, unsuccessfully:         Shell Builtin Commands.
* echo, BSD compatible:                  Description of Options.
* editing history:                       Shell Builtin Commands.
* editing parameters:                    Zle Builtins.
* editor ksh style:                      Zsh Line Editor.
* editor, enabling:                      Description of Options.
* editor, line:                          Zsh Line Editor.
* editor, overstrike mode:               Description of Options.
* editor, single line mode:              Description of Options.
* eight bit characters, printing:        Description of Options.
* enable globbing qualifiers:            Description of Options.
* enable history substitution:           Description of Options.
* enabling commands:                     Shell Builtin Commands.
* enabling globbing:                     Description of Options.
* enabling the beep:                     Description of Options.
* enabling the editor:                   Description of Options.
* environment, and local parameters:     Description of Options.
* EOF, ignoring:                         Description of Options.
* evaluating arguments as commands:      Shell Builtin Commands.
* evaluation, arithmetic:                Arithmetic Evaluation.
* event designators, history:            Event Designators.
* execution, of commands:                Command Execution.
* execution, timed:                      The zsh/sched Module.
* exit status, printing:                 Description of Options.
* exit status, trapping:                 Description of Options.
* exiting loops:                         Shell Builtin Commands.
* exiting, checking jobs when:           Description of Options.
* expanding parameters:                  Shell Builtin Commands.
* expansion:                             Expansion.
* expansion style, sh:                   Description of Options.
* expansion, arithmetic:                 Arithmetic Expansion.
* expansion, brace:                      Brace Expansion.
* expansion, brace, disabling:           Description of Options.
* expansion, brace, extending:           Description of Options.
* expansion, filename:                   Filename Expansion.
* expansion, history:                    History Expansion.
* expansion, parameter:                  Parameter Expansion.
* expansion, prompt:                     Prompt Expansion.
* export, automatic:                     Description of Options.
* exporting, and local parameters:       Description of Options.
* expressions, conditional:              Conditional Expressions.
* field splitting, sh style:             Description of Options.
* field splitting, sh style, parameter:  Parameter Expansion.
* file clobbering, allowing:             Description of Options.
* file descriptors:                      Redirection.
* file descriptors, waiting for:         The zsh/zselect Module.
* file, history:                         Shell Builtin Commands.
* filename expansion:                    Filename Expansion.
* filename expansion, =:                 Description of Options.
* filename generation:                   Filename Generation.
* filename generation, bad pattern:      Description of Options.
* files used:                            Files.
* files, examining:                      The zsh/stat Module.
* files, global startup, inhibiting:     Description of Options.
* files, listing:                        The zsh/stat Module.
* files, manipulating:                   The zsh/files Module.
* files, marking type of:                Description of Options.
* files, shutdown:                       Files.
* files, startup:                        Files.
* files, transferring:                   The zsh/zftp Module.
* flags, parameter expansion:            Parameter Expansion.
* flags, shell:                          Invocation.
* floating point parameters:             Arithmetic Evaluation.
* flow control:                          Description of Options.
* for loops:                             Complex Commands.
* FTP:                                   The zsh/zftp Module.
* FTP sites for zsh:                     Availability.
* FTP, functions for using shell as client: Zftp Function System.
* FTP, starting a session:               The zsh/zftp Module.
* function return, on error:             Description of Options.
* functions:                             Functions.
* functions, autoloading <1>:            Shell Builtin Commands.
* functions, autoloading:                Functions.
* functions, math, use of:               Arithmetic Evaluation.
* functions, mathematical:               The zsh/mathfunc Module.
* functions, profiling:                  The zsh/zprof Module.
* functions, recompiling:                Utilities.
* functions, removing:                   Shell Builtin Commands.
* functions, returning from:             Shell Builtin Commands.
* globbing:                              Expansion.
* globbing modifiers:                    Modifiers.
* globbing qualifiers, enable:           Description of Options.
* globbing style, sh:                    Description of Options.
* globbing, bad pattern:                 Description of Options.
* globbing, enabling:                    Description of Options.
* globbing, extended:                    Description of Options.
* globbing, no matches:                  Description of Options.
* globbing, null, style, csh:            Description of Options.
* globbing, of . files:                  Description of Options.
* globbing, qualifiers:                  Filename Generation.
* globbing, sorting numerically:         Description of Options.
* grammar, shell:                        Shell Grammar.
* hashing, of commands:                  Description of Options.
* hashing, of directories:               Description of Options.
* helpfiles utility:                     Utilities.
* hexadecimal, output in C format:       Description of Options.
* history:                               History Expansion.
* history beeping:                       Description of Options.
* history event designators:             Event Designators.
* history expansion:                     History Expansion.
* history modifiers:                     Modifiers.
* history style, csh:                    Description of Options.
* history word designators:              Word Designators.
* history, appending to a file:          Description of Options.
* history, editing:                      Shell Builtin Commands.
* history, enable substitution:          Description of Options.
* history, expiring duplicates:          Description of Options.
* history, file:                         Shell Builtin Commands.
* history, ignoring all duplicates:      Description of Options.
* history, ignoring duplicates:          Description of Options.
* history, ignoring duplicates in search: Description of Options.
* history, ignoring spaces:              Description of Options.
* history, incremental appending to a file: Description of Options.
* history, sharing:                      Description of Options.
* history, stack:                        Shell Builtin Commands.
* history, timestamping:                 Description of Options.
* history, verifying substitution:       Description of Options.
* if construct:                          Complex Commands.
* input, tracing:                        Description of Options.
* integer parameters:                    Arithmetic Evaluation.
* introduction:                          Introduction.
* invocation:                            Invocation.
* invoking widgets:                      Zle Builtins.
* job control, allowing:                 Description of Options.
* jobs:                                  Jobs & Signals.
* jobs, background priority:             Description of Options.
* jobs, background, I/O:                 Jobs & Signals.
* jobs, backgrounding:                   Shell Builtin Commands.
* jobs, continuing automatically:        Description of Options.
* jobs, disowning <1>:                   Jobs & Signals.
* jobs, disowning:                       Shell Builtin Commands.
* jobs, foregrounding:                   Shell Builtin Commands.
* jobs, HUP:                             Description of Options.
* jobs, killing:                         Shell Builtin Commands.
* jobs, list format:                     Description of Options.
* jobs, referring to:                    Jobs & Signals.
* jobs, resuming:                        Shell Builtin Commands.
* jobs, resuming automatically:          Description of Options.
* jobs, suspending:                      Jobs & Signals.
* jobs, waiting for:                     Shell Builtin Commands.
* key bindings:                          Keymaps.
* keyboard definition:                   Utilities.
* keymaps <1>:                           Zle Builtins.
* keymaps:                               Keymaps.
* keys, binding:                         Zle Builtins.
* keys, rebinding:                       Zle Builtins.
* killing jobs:                          Shell Builtin Commands.
* ksh compatibility:                     Compatibility.
* ksh, argument splitting in typeset:    Description of Options.
* ksh, array style:                      Description of Options.
* ksh, compatibility:                    Shell Builtin Commands.
* ksh, editor mode:                      Zsh Line Editor.
* ksh, null command style:               Parameters Used By The Shell.
* ksh, option printing style:            Description of Options.
* ksh, redirections with no command:     Description of Options.
* ksh, single letter options style:      Description of Options.
* limits, resource:                      Shell Builtin Commands.
* line editor:                           Zsh Line Editor.
* line, reading:                         Shell Builtin Commands.
* links, symbolic:                       Description of Options.
* list:                                  Simple Commands & Pipelines.
* loading modules:                       Shell Builtin Commands.
* logging out, checking jobs when:       Description of Options.
* long option:                           Invocation.
* loop style, csh:                       Description of Options.
* loops, continuing:                     Shell Builtin Commands.
* loops, exiting:                        Shell Builtin Commands.
* loops, for:                            Complex Commands.
* loops, repeat:                         Complex Commands.
* loops, until:                          Complex Commands.
* loops, while:                          Complex Commands.
* mail, warning of reading:              Description of Options.
* mailing lists:                         Mailing Lists.
* marking directories:                   Description of Options.
* marking file types:                    Description of Options.
* mathematical functions:                The zsh/mathfunc Module.
* mathematical functions, use of:        Arithmetic Evaluation.
* mode, privileged:                      Description of Options.
* modifiers:                             Modifiers.
* modifiers, precommand:                 Precommand Modifiers.
* modules:                               Zsh Modules.
* modules, example:                      The zsh/example Module.
* modules, loading:                      Shell Builtin Commands.
* modules, writing:                      The zsh/example Module.
* multios:                               Redirection.
* named directories:                     Filename Expansion.
* notification of background jobs:       Description of Options.
* null command style:                    Parameters Used By The Shell.
* null globbing style, csh:              Description of Options.
* octal, arithmetic expressions:         Description of Options.
* octal, output in C format:             Description of Options.
* operators, arithmetic:                 Arithmetic Evaluation.
* option printing style, ksh:            Description of Options.
* option printing, ksh style:            Description of Options.
* options:                               Options.
* options, aliases:                      Option Aliases.
* options, description:                  Description of Options.
* options, processing:                   Shell Builtin Commands.
* options, setting:                      Shell Builtin Commands.
* options, shell:                        Invocation.
* options, single letter:                Single Letter Options.
* options, single letter, ksh style:     Description of Options.
* options, specifying:                   Specifying Options.
* options, unsetting:                    Shell Builtin Commands.
* overstrike mode, of editor:            Description of Options.
* parameter expansion:                   Parameter Expansion.
* parameter expansion flags:             Parameter Expansion.
* parameter expansion style, rc:         Description of Options.
* parameter modifiers:                   Modifiers.
* parameter, file access via:            The zsh/mapfile Module.
* parameters:                            Parameters.
* parameters, declaring:                 Shell Builtin Commands.
* parameters, editing:                   Zle Builtins.
* parameters, editor:                    Zle Widgets.
* parameters, expanding:                 Shell Builtin Commands.
* parameters, floating point:            Arithmetic Evaluation.
* parameters, integer:                   Arithmetic Evaluation.
* parameters, listing:                   Shell Builtin Commands.
* parameters, marking readonly:          Shell Builtin Commands.
* parameters, positional:                Shell Builtin Commands.
* parameters, setting:                   Shell Builtin Commands.
* parameters, setting array:             Shell Builtin Commands.
* parameters, special <1>:               The zsh/parameter Module.
* parameters, special:                   The zsh/zleparameter Module.
* parameters, substituting unset:        Description of Options.
* parameters, unsetting:                 Shell Builtin Commands.
* parameters, zle:                       Zle Widgets.
* path search, extended:                 Description of Options.
* pipeline:                              Simple Commands & Pipelines.
* precedence of glob operators:          Filename Generation.
* precommand modifiers:                  Precommand Modifiers.
* priority of background jobs:           Description of Options.
* privileged mode:                       Description of Options.
* process substitution:                  Process Substitution.
* prompt expansion:                      Prompt Expansion.
* prompt, ! expansion:                   Description of Options.
* prompt, % expansion:                   Description of Options.
* prompt, parameter expansion:           Description of Options.
* prompt, with CR:                       Description of Options.
* pushd, making cd behave like:          Description of Options.
* pushd, to home:                        Description of Options.
* qualifiers, globbing:                  Filename Generation.
* querying before rm *:                  Description of Options.
* quoting:                               Quoting.
* quoting style, csh:                    Description of Options.
* quoting style, rc:                     Description of Options.
* rc, array expansion style:             Parameter Expansion.
* rc, parameter expansion style:         Description of Options.
* rc, quoting style:                     Description of Options.
* reading a line:                        Shell Builtin Commands.
* rebinding keys:                        Zle Builtins.
* rebinding widgets:                     Zle Builtins.
* redirection:                           Redirection.
* redirections with no command, csh:     Description of Options.
* redirections with no command, ksh:     Description of Options.
* redirections with no command, sh:      Description of Options.
* referring to jobs:                     Jobs & Signals.
* regular expressions, perl-compatible:  The zsh/pcre Module.
* repeat loops:                          Complex Commands.
* reporter utility:                      Utilities.
* reserved words:                        Reserved Words.
* resource limits:                       Shell Builtin Commands.
* restricted shell <1>:                  Restricted Shell.
* restricted shell:                      Description of Options.
* resuming jobs automatically:           Description of Options.
* rm *, querying before:                 Description of Options.
* rm *, waiting before:                  Description of Options.
* select, system call:                   The zsh/zselect Module.
* selection, case:                       Complex Commands.
* selection, user:                       Complex Commands.
* sh compatibility:                      Compatibility.
* sh, compatibility:                     Shell Builtin Commands.
* sh, expansion style:                   Description of Options.
* sh, field splitting style:             Description of Options.
* sh, field splitting style, parameter:  Parameter Expansion.
* sh, globbing style:                    Description of Options.
* sh, redirections with no command:      Description of Options.
* sh, single letter options style:       Description of Options.
* share history:                         Description of Options.
* shell flags:                           Invocation.
* shell grammar:                         Shell Grammar.
* shell options:                         Invocation.
* shell, cloning:                        The zsh/clone Module.
* shell, suspending:                     Shell Builtin Commands.
* shell, timing:                         Shell Builtin Commands.
* shutdown files:                        Files.
* signals, trapping <1>:                 Shell Builtin Commands.
* signals, trapping:                     Functions.
* simple commands:                       Simple Commands & Pipelines.
* single command:                        Description of Options.
* single letter options:                 Single Letter Options.
* single letter options, ksh style:      Description of Options.
* slash, removing trailing:              Description of Options.
* sockets:                               The zsh/net/socket Module.
* sockets, closing TCP:                  The zsh/net/tcp Module.
* sockets, inbound TCP:                  The zsh/net/tcp Module.
* sockets, inbound Unix domain:          The zsh/net/socket Module.
* sockets, outbound TCP:                 The zsh/net/tcp Module.
* sockets, outbound Unix domain:         The zsh/net/socket Module.
* sockets, TCP:                          The zsh/net/tcp Module.
* sockets, Unix domain:                  The zsh/net/socket Module.
* spelling correction:                   Description of Options.
* stack, history:                        Shell Builtin Commands.
* startup files:                         Files.
* startup files, global, inhibiting:     Description of Options.
* startup files, sourcing:               Description of Options.
* styles in zftp functions:              Miscellaneous Features.
* sublist:                               Simple Commands & Pipelines.
* subscript flags:                       Array Parameters.
* subscripts:                            Array Parameters.
* subshell:                              Complex Commands.
* substitution, command:                 Command Substitution.
* substitution, parameter, flags:        Parameter Expansion.
* substitution, process:                 Process Substitution.
* sun keyboard, annoying:                Description of Options.
* suspending jobs:                       Jobs & Signals.
* suspending the shell:                  Shell Builtin Commands.
* symbolic links:                        Description of Options.
* TCP:                                   The zsh/net/tcp Module.
* TCP function system:                   TCP Function System.
* TCP, example:                          The zsh/net/tcp Module.
* termcap value, printing:               The zsh/termcap Module.
* terminal:                              The zsh/clone Module.
* terminfo value, printing:              The zsh/terminfo Module.
* timed execution:                       The zsh/sched Module.
* timing:                                Complex Commands.
* timing the shell:                      Shell Builtin Commands.
* tracing, of commands:                  Description of Options.
* tracing, of input lines:               Description of Options.
* trapping signals <1>:                  Functions.
* trapping signals:                      Shell Builtin Commands.
* traps, asynchronous:                   Description of Options.
* try blocks:                            Complex Commands.
* tty, freezing:                         Shell Builtin Commands.
* umask:                                 Shell Builtin Commands.
* unset parameters, substituting:        Description of Options.
* until loops:                           Complex Commands.
* user contributions:                    User Contributions.
* user selection:                        Complex Commands.
* users, watching:                       Shell Builtin Commands.
* version:                               Top.
* waiting before rm *:                   Description of Options.
* waiting for jobs:                      Shell Builtin Commands.
* watching users:                        Shell Builtin Commands.
* while loops:                           Complex Commands.
* widgets:                               Zle Widgets.
* widgets, binding:                      Zle Builtins.
* widgets, calling:                      Zle Builtins.
* widgets, defining:                     Zle Builtins.
* widgets, invoking:                     Zle Builtins.
* widgets, rebinding:                    Zle Builtins.
* widgets, standard:                     Zle Widgets.
* widgets, user-defined:                 Zle Widgets.
* word designators, history:             Word Designators.
* writing modules:                       The zsh/example Module.
* zftp function system:                  Zftp Function System.
* zftp function system, automatic reopening: Miscellaneous Features.
* zftp function system, configuration:   Miscellaneous Features.
* zftp function system, remote globbing: Miscellaneous Features.
* zftp function system, styles:          Miscellaneous Features.
* zftp, functions:                       The zsh/zftp Module.
* zftp, parameters:                      The zsh/zftp Module.
* zftp, problems:                        The zsh/zftp Module.
* zftp, subcommands:                     The zsh/zftp Module.
* ZLE:                                   Zsh Line Editor.
* zle, builtin commands:                 Zle Builtins.
* zlogin:                                Files.
* zlogout:                               Files.
* zprofile:                              Files.
* zrecompile utility:                    Utilities.
* zshenv:                                Files.
* zshrc:                                 Files.
* ztcp, function system based on:        TCP Function System.

