zshparam - zsh parameters
DESCRIPTION
A parameter has a name, a value, and a number of
attributes. A name may be any sequence of alphanumeric
characters and underscores, or the single characters `*',
`@', `#', `?', `-', `$', or `!'. The value may be a
scalar (a string), an integer, an array (indexed numeri
cally), or an associative array (an unordered set of
name-value pairs, indexed by name). To declare the type
of a parameter, or to assign a scalar or integer value to
a parameter, use the typeset builtin.
The value of a scalar or integer parameter may also be
assigned by writing:
name=value
If the integer attribute, -i, is set for name, the value
is subject to arithmetic evaluation. See the section
`Array Parameters' for additional forms of assignment.
To refer to the value of a parameter, write `$name' or
`${name}'. See Parameter Expansion in zshexpn(1) for com
plete details.
In the parameter lists that follow, the mark `<S>' indi
cates that the parameter is special. Special parameters
cannot have their type changed, and they stay special even
if unset. `<Z>' indicates that the parameter does not
exist when the shell initializes in sh or ksh emulation
mode.
ARRAY PARAMETERS
To assign an array value, write one of:
set -A name value ...
name=(value ...)
If no parameter name exists, an ordinary array parameter
is created. If the parameter name exists and is a scalar,
it is replaced by a new array. Ordinary array parameters
may also be explicitly declared with:
typeset -a name
Associative arrays must be declared before assignment, by
using:
typeset -A name
When name refers to an associative array, the list in an
assignment is interpreted as alternating keys and values:
name=(key value ...)
Every key must have a value in this case. Note that this
assigns to the entire array, deleting any elements that do
not appear in the list.
To create an empty array (including associative arrays),
use one of:
set -A name
name=()
Array Subscripts
Individual elements of an array may be selected using a
subscript. A subscript of the form `[exp]' selects the
single element exp, where exp is an arithmetic expression
which will be subject to arithmetic expansion as if it
were surrounded by `$((...))'. The elements are numbered
beginning with 1, unless the KSH_ARRAYS option is set in
which case they are numbered from zero.
Subscripts may be used inside braces used to delimit a
parameter name, thus `${foo[2]}' is equivalent to
`$foo[2]'. If the KSH_ARRAYS option is set, the braced
form is the only one that works, as bracketed expressions
otherwise are not treated as subscripts.
The same subscripting syntax is used for associative
arrays, except that no arithmetic expansion is applied to
exp. However, the parsing rules for arithmetic expres
sions still apply, which affects the way that certain spe
cial characters must be protected from interpretation.
See Subscript Parsing below for details.
A subscript of the form `[*]' or `[@]' evaluates to all
elements of an array; there is no difference between the
two except when they appear within double quotes.
`"$foo[*]"' evaluates to `"$foo[1] $foo[2] ..."', whereas
`"$foo[@]"' evaluates to `"$foo[1]" "$foo[2]" ...'. For
associative arrays, `[*]' or `[@]' evaluate to all the
values (not the keys, but see Subscript Flags below), in
no particular order. When an array parameter is refer
enced as `$name' (with no subscript) it evaluates to
`$name[*]', unless the KSH_ARRAYS option is set in which
case it evaluates to `${name[0]}' (for an associative
array, this means the value of the key `0', which may not
exist even if there are values for other keys).
A subscript of the form `[exp1,exp2]' selects all elements
in the range exp1 to exp2, inclusive. (Associative arrays
are unordered, and so do not support ranges.) If one of
the subscripts evaluates to a negative number, say -n,
Thus `$foo[-3]' is the third element from the end of the
array foo, and `$foo[1,-1]' is the same as `$foo[*]'.
Subscripting may also be performed on non-array values, in
which case the subscripts specify a substring to be
extracted. For example, if FOO is set to `foobar', then
`echo $FOO[2,5]' prints `ooba'.
Array Element Assignment
A subscript may be used on the left side of an assignment
like so:
name[exp]=value
In this form of assignment the element or range specified
by exp is replaced by the expression on the right side.
An array (but not an associative array) may be created by
assignment to a range or element. Arrays do not nest, so
assigning a parenthesized list of values to an element or
range changes the number of elements in the array, shift
ing the other elements to accommodate the new values.
(This is not supported for associative arrays.)
This syntax also works as an argument to the typeset com
mand:
typeset "name[exp]"=value
The value may not be a parenthesized list in this case;
only single-element assignments may be made with typeset.
Note that quotes are necessary in this case to prevent the
brackets from being interpreted as filename generation
operators. The noglob precommand modifier could be used
instead.
To delete an element of an ordinary array, assign `()' to
that element. To delete an element of an associative
array, use the unset command:
unset "name[exp]"
Subscript Flags
If the opening bracket, or the comma in a range, in any
subscript expression is directly followed by an opening
parenthesis, the string up to the matching closing one is
considered to be a list of flags, as in
`name[(flags)exp]'. The flags currently understood are:
w If the parameter subscripted is a scalar than this
flag makes subscripting work on words instead of
characters. The default word separator is
s:string:
This gives the string that separates words (for use
with the w flag).
p Recognize the same escape sequences as the print
builtin in the string argument of a subsequent `s'
flag.
f If the parameter subscripted is a scalar than this
flag makes subscripting work on lines instead of
characters, i.e. with elements separated by new
lines. This is a shorthand for `pws:\n:'.
r Reverse subscripting: if this flag is given, the
exp is taken as a pattern and the result is the
first matching array element, substring or word (if
the parameter is an array, if it is a scalar, or if
it is a scalar and the `w' flag is given, respec
tively). The subscript used is the number of the
matching element, so that pairs of subscripts such
as `$foo[(r)??,3]' and `$foo[(r)??,(r)f*]' are pos
sible. If the parameter is an associative array,
only the value part of each pair is compared to the
pattern, and the result is that value. Reverse
subscripts may be used for assigning to ordinary
array elements, but not for assigning to associa
tive arrays.
R Like `r', but gives the last match. For associa
tive arrays, gives all possible matches.
i Like `r', but gives the index of the match instead;
this may not be combined with a second argument.
On the left side of an assignment, behaves like
`r'. For associative arrays, the key part of each
pair is compared to the pattern, and the first
matching key found is the result.
I Like `i', but gives the index of the last match, or
all possible matching keys in an associative array.
k If used in a subscript on an associative array,
this flag causes the keys to be interpreted as pat
terns, and returns the value for the first key
found where exp is matched by the key. This flag
does not work on the left side of an assignment to
an associative array element. If used on another
type of parameter, this behaves like `r'.
K On an associative array this is like `k' but
returns all values where exp is matched by the
keys. On other types of parameters this has the
n:expr:
If combined with `r', `R', `i' or `I', makes them
give the nth or nth last match (if expr evaluates
to n). This flag is ignored when the array is
associative.
b:expr:
If combined with `r', `R', `i' or `I', makes them
begin at the nth or nth last element, word, or
character (if expr evaluates to n). This flag is
ignored when the array is associative.
e This flag has no effect and for ordinary arrays is
retained for backward compatibility only. For
associative arrays, this flag can be used to force
* or @ to be interpreted as a single key rather
than as a reference to all values. This flag may
be used on the left side of an assignment.
See Parameter Expansion Flags (zshexpn(1)) for additional
ways to manipulate the results of array subscripting.
Subscript Parsing
This discussion applies mainly to associative array key
strings and to patterns used for reverse subscripting (the
`r', `R', `i', etc. flags), but it may also affect parame
ter substitutions that appear as part of an arithmetic
expression in an ordinary subscript.
The basic rule to remember when writing a subscript
expression is that all text between the opening `[' and
the closing `]' is interpreted as if it were in double
quotes (see zshmisc(1)). However, unlike double quotes
which normally cannot nest, subscript expressions may
appear inside double-quoted strings or inside other sub
script expressions (or both!), so the rules have two
important differences.
The first difference is that brackets (`[' and `]') must
appear as balanced pairs in a subscript expression unless
they are preceded by a backslash (`\'). Therefore, within
a subscript expression (and unlike true double-quoting)
the sequence `\[' becomes `[', and similarly `\]' becomes
`]'. This applies even in cases where a backslash is not
normally required; for example, the pattern `[^[]' (to
match any character other than an open bracket) should be
written `[^\[]' in a reverse-subscript pattern. However,
note that `\[^\[\]' and even `\[^[]' mean the same thing,
because backslashes are always stripped when they appear
before brackets!
braces (`{' and `}'): they must appear either in balanced
pairs or preceded by a backslash, and backslashes that
protect parentheses or braces are removed during parsing.
This is because parameter expansions may be surrounded
balanced braces, and subscript flags are introduced by
balanced parenthesis.
The second difference is that a double-quote (`"') may
appear as part of a subscript expression without being
preceded by a backslash, and therefore that the two char
acters `\"' remain as two characters in the subscript (in
true double-quoting, `\"' becomes `"'). However, because
of the standard shell quoting rules, any double-quotes
that appear must occur in balanced pairs unless preceded
by a backslash. This makes it more difficult to write a
subscript expression that contains an odd number of dou
ble-quote characters, but the reason for this difference
is so that when a subscript expression appears inside true
double-quotes, one can still write `\"' (rather than
`\\\"') for `"'.
To use an odd number of double quotes as a key in an
assignment, use the typeset builtin and an enclosing pair
of double quotes; to refer to the value of that key, again
use double quotes:
typeset -A aa
typeset "aa[one\"two\"three\"quotes]"=QQQ
print "$aa[one\"two\"three\"quotes]"
It is important to note that the quoting rules do not
change when a parameter expansion with a subscript is
nested inside another subscript expression. That is, it
is not necessary to use additional backslashes within the
inner subscript expression; they are removed only once,
from the innermost subscript outwards. Parameters are
also expanded from the innermost subscript first, as each
expansion is encountered left to right in the outer
expression.
A further complication arises from a way in which sub
script parsing is not different from double quote parsing.
As in true double-quoting, the sequences `\*', and `\@'
remain as two characters when they appear in a subscript
expression. To use a literal `*' or `@' as an associative
array key, the `e' flag must be used:
typeset -A aa
aa[(e)*]=star
print $aa[(e)*]
A last detail must be considered when reverse subscripting
is performed. Parameters appearing in the subscript
expression is interpreted as a pattern. This has two
effects: first, parameters behave as if GLOB_SUBST were on
(and it cannot be turned off); second, backslashes are
interpreted twice, once when parsing the array subscript
and again when parsing the pattern. In a reverse sub
script, it's necessary to use four backslashes to cause a
single backslash to match literally in the pattern. For
complex patterns, it is often easiest to assign the
desired pattern to a parameter and then refer to that
parameter in the subscript, because then the backslashes,
brackets, parentheses, etc., are seen only when the com
plete expression is converted to a pattern. To match the
value of a parameter literally in a reverse subscript,
rather than as a pattern, use `${(q)name}' (see zsh
expn(1)) to quote the expanded value.
Note that the `k' and `K' flags are reverse subscripting
for an ordinary array, but are not reverse subscripting
for an associative array! (For an associative array, the
keys in the array itself are interpreted as patterns by
those flags; the subscript is a plain string in that
case.)
One final note, not directly related to subscripting: the
numeric names of positional parameters (described below)
are parsed specially, so for example `$2foo' is equivalent
to `${2}foo'. Therefore, to use subscript syntax to
extract a substring from a positional parameter, the
expansion must be surrounded by braces; for example,
`${2[3,5]}' evaluates to the third through fifth charac
ters of the second positional parameter, but `$2[3,5]' is
the entire second parameter concatenated with the filename
generation pattern `[3,5]'.
POSITIONAL PARAMETERS
The positional parameters provide access to the com
mand-line arguments of a shell function, shell script, or
the shell itself; see the section `Invocation', and also
the section `Functions'. The parameter n, where n is a
number, is the nth positional parameter. The parameters
*, @ and argv are arrays containing all the positional
parameters; thus `$argv[n]', etc., is equivalent to simply
`$n'.
Positional parameters may be changed after the shell or
function starts by using the set builtin, by assigning to
the argv array, or by direct assignment of the form
`n=value' where n is the number of the positional parame
ter to be changed. This also creates (with empty values)
any of the positions from 1 to n that do not already have
values. Note that, because the positional parameters form
an array, an array assignment of the form `n=(value ...)'
at positions greater than n by as many positions as neces
sary to accommodate the new values.
LOCAL PARAMETERS
Shell function executions delimit scopes for shell parame
ters. (Parameters are dynamically scoped.) The typeset
builtin, and its alternative forms declare, integer, local
and readonly (but not export), can be used to declare a
parameter as being local to the innermost scope.
When a parameter is read or assigned to, the innermost
existing parameter of that name is used. (That is, the
local parameter hides any less-local parameter.) However,
assigning to a non-existent parameter, or declaring a new
parameter with export, causes it to be created in the out
ermost scope.
Local parameters disappear when their scope ends. unset
can be used to delete a parameter while it is still in
scope; any outer parameter of the same name remains hid
den.
Special parameters may also be made local; they retain
their special attributes unless either the existing or the
newly-created parameter has the -h (hide) attribute. This
may have unexpected effects: there is no default value, so
if there is no assignment at the point the variable is
made local, it will be set to an empty value (or zero in
the case of integers). The following:
typeset PATH=/new/directory:$PATH
is valid for temporarily allowing the shell or programmes
called from it to find the programs in /new/directory
inside a function.
Note that the restriction in older versions of zsh that
local parameters were never exported has been removed.
PARAMETERS SET BY THE SHELL
The following parameters are automatically set by the
shell:
! <S> The process ID of the last background command
invoked.
# <S> The number of positional parameters in decimal.
Note that some confusion may occur with the syntax
$#param which substitutes the length of param. Use
${#} to resolve ambiguities. In particular, the
sequence `$#-...' in an arithmetic expression is
ARGC <S> <Z>
Same as #.
$ <S> The process ID of this shell.
- <S> Flags supplied to the shell on invocation or by the
set or setopt commands.
* <S> An array containing the positional parameters.
argv <S> <Z>
Same as *. Assigning to argv changes the local
positional parameters, but argv is not itself a
local parameter. Deleting argv with unset in any
function deletes it everywhere, although only the
innermost positional parameter array is deleted (so
* and @ in other scopes are not affected).
@ <S> Same as argv[@], even when argv is not set.
? <S> The exit value returned by the last command.
0 <S> The name used to invoke the current shell. If the
FUNCTION_ARGZERO option is set, this is set tem
porarily within a shell function to the name of the
function, and within a sourced script to the name
of the script.
status <S> <Z>
Same as ?.
pipestatus <S> <Z>
An array containing the exit values returned by all
commands in the last pipeline.
_ <S> The last argument of the previous command. Also,
this parameter is set in the environment of every
command executed to the full pathname of the com
mand.
CPUTYPE
The machine type (microprocessor class or machine
model), as determined at run time.
EGID <S>
The effective group ID of the shell process. If
you have sufficient privileges, you may change the
effective group ID of the shell process by assign
ing to this parameter. Also (assuming sufficient
privileges), you may start a single command with a
different effective group ID by `(EGID=gid; com
mand)'
The effective user ID of the shell process. If you
have sufficient privileges, you may change the
effective user ID of the shell process by assigning
to this parameter. Also (assuming sufficient priv
ileges), you may start a single command with a dif
ferent effective user ID by `(EUID=uid; command)'
ERRNO <S>
The value of errno (see errno(3)) as set by the
most recently failed system call. This value is
system dependent and is intended for debugging pur
poses.
GID <S>
The real group ID of the shell process. If you
have sufficient privileges, you may change the
group ID of the shell process by assigning to this
parameter. Also (assuming sufficient privileges),
you may start a single command under a different
group ID by `(GID=gid; command)'
HOST The current hostname.
LINENO <S>
The line number of the current line within the cur
rent script, sourced file, or shell function being
executed, whichever was started most recently.
Note that in the case of shell functions the line
number refers to the function as it appeared in the
original definition, not necessarily as displayed
by the functions builtin.
LOGNAME
If the corresponding variable is not set in the
environment of the shell, it is initialized to the
login name corresponding to the current login ses
sion. This parameter is exported by default but
this can be disabled using the typeset builtin.
MACHTYPE
The machine type (microprocessor class or machine
model), as determined at compile time.
OLDPWD The previous working directory. This is set when
the shell initializes and whenever the directory
changes.
OPTARG <S>
The value of the last option argument processed by
the getopts command.
OPTIND <S>
The index of the last option argument processed by
OSTYPE The operating system, as determined at compile
time.
PPID <S>
The process ID of the parent of the shell.
PWD The present working directory. This is set when
the shell initializes and whenever the directory
changes.
RANDOM <S>
A random integer from 0 to 32767, newly generated
each time this parameter is referenced. The random
number generator can be seeded by assigning a
numeric value to RANDOM.
SECONDS <S>
The number of seconds since shell invocation. If
this parameter is assigned a value, then the value
returned upon reference will be the value that was
assigned plus the number of seconds since the
assignment.
SHLVL <S>
Incremented by one each time a new shell is
started.
signals
An array containing the names of the signals.
TTY The name of the tty associated with the shell, if
any.
TTYIDLE <S>
The idle time of the tty associated with the shell
in seconds or -1 if there is no such tty.
UID <S>
The real user ID of the shell process. If you have
sufficient privileges, you may change the user ID
of the shell by assigning to this parameter. Also
(assuming sufficient privileges), you may start a
single command under a different user ID by
`(UID=uid; command)'
USERNAME <S>
The username corresponding to the real user ID of
the shell process. If you have sufficient privi
leges, you may change the username (and also the
user ID and group ID) of the shell by assigning to
this parameter. Also (assuming sufficient privi
leges), you may start a single command under a
`(USERNAME=username; command)'
VENDOR The vendor, as determined at compile time.
ZSH_NAME
Expands to the basename of the command used to
invoke this instance of zsh.
ZSH_VERSION
The version number of this zsh.
PARAMETERS USED BY THE SHELL
The following parameters are used by the shell.
In cases where there are two parameters with an upper- and
lowercase form of the same name, such as path and PATH,
the lowercase form is an array and the uppercase form is a
scalar with the elements of the array joined together by
colons. These are similar to tied parameters created via
`typeset -T'. The normal use for the colon-separated form
is for exporting to the environment, while the array form
is easier to manipulate within the shell. Note that
unsetting either of the pair will unset the other; they
retain their special properties when recreated, and recre
ating one of the pair will recreate the other.
ARGV0 If exported, its value is used as the argv[0] of
external commands. Usually used in constructs like
`ARGV0=emacs nethack'.
BAUD The baud rate of the current connection. Used by
the line editor update mechanism to compensate for
a slow terminal by delaying updates until neces
sary. This may be profitably set to a lower value
in some circumstances, e.g. for slow modems dial
ing into a communications server which is connected
to a host via a fast link; in this case, this vari
able would be set by default to the speed of the
fast link, and not the modem. This parameter
should be set to the baud rate of the slowest part
of the link for best performance. The compensation
mechanism can be turned off by setting the variable
to zero.
cdpath <S> <Z> (CDPATH <S>)
An array (colon-separated list) of directories
specifying the search path for the cd command.
COLUMNS <S>
The number of columns for this terminal session.
Used for printing select lists and for the line
editor.
The maximum size of the directory stack. If the
stack gets larger than this, it will be truncated
automatically. This is useful with the AUTO_PUSHD
option.
FCEDIT The default editor for the fc builtin.
fignore <S> <Z> (FIGNORE <S>)
An array (colon separated list) containing the suf
fixes of files to be ignored during filename com
pletion. However, if the completion generates only
files which would match if this variable would be
ignored, than these files are completed anyway.
fpath <S> <Z> (FPATH <S>)
An array (colon separated list) of directories
specifying the search path for function defini
tions. This path is searched when a function with
the -u attribute is referenced. If an executable
file is found, then it is read and executed in the
current environment.
histchars <S>
Three characters used by the shell's history and
lexical analysis mechanism. The first character
signals the start of a history expansion (default
`!'). The second character signals the start of a
quick history substitution (default `^'). The
third character is the comment character (default
`#').
HISTCHARS <S> <Z>
Same as histchars. (Deprecated.)
HISTFILE
The file to save the history in when an interactive
shell exits. If unset, the history is not saved.
HISTSIZE <S>
The maximum number of events stored in the internal
history list. If you use the
HIST_EXPIRE_DUPS_FIRST option, setting this value
larger than the SAVEHIST size will give you the
difference as a cushion for saving duplicated his
tory events.
HOME <S>
The default argument for the cd command.
IFS <S>
Internal field separators (by default space, tab,
newline and NUL), that are used to separate words
which result from command or parameter expansion
from the set space, tab and newline that appear in
the IFS are called IFS white space. One or more
IFS white space characters or one non-IFS white
space character together with any adjacent IFS
white space character delimit a field. If an IFS
white space character appears twice consecutively
in the IFS, this character is treated as if it were
not an IFS white space character.
KEYTIMEOUT
The time the shell waits, in hundredths of seconds,
for another key to be pressed when reading bound
multi-character sequences.
LANG <S>
This variable determines the locale category for
any category not specifically selected via a vari
able starting with `LC_'.
LC_ALL <S>
This variable overrides the value of the `LANG'
variable and the value of any of the other vari
ables starting with `LC_'.
LC_COLLATE <S>
This variable determines the locale category for
character collation information within ranges in
glob brackets and for sorting.
LC_CTYPE <S>
This variable determines the locale category for
character handling functions.
LC_MESSAGES <S>
This variable determines the language in which mes
sages should be written. Note that zsh does not
use message catalogs.
LC_NUMERIC <S>
This variable affects the decimal point character
and thousands separator character for the formatted
input/output functions and string conversion func
tions. Note that zsh ignores this setting when
parsing floating point mathematical expressions.
LC_TIME <S>
This variable determines the locale category for
date and time formatting in prompt escape
sequences.
LINES <S>
The number of lines for this terminal session.
Used for printing select lists and for the line
LISTMAX
In the line editor, the number of matches to list
without asking first. If the value is negative, the
list will be shown if it spans at most as many
lines as given by the absolute value. If set to
zero, the shell asks only if the top of the listing
would scroll off the screen.
LOGCHECK
The interval in seconds between checks for
login/logout activity using the watch parameter.
MAIL If this parameter is set and mailpath is not set,
the shell looks for mail in the specified file.
MAILCHECK
The interval in seconds between checks for new
mail.
mailpath <S> <Z> (MAILPATH <S>)
An array (colon-separated list) of filenames to
check for new mail. Each filename can be followed
by a `?' and a message that will be printed. The
message will undergo parameter expansion, command
substitution and arithmetic expansion with the
variable $_ defined as the name of the file that
has changed. The default message is `You have new
mail'. If an element is a directory instead of a
file the shell will recursively check every file in
every subdirectory of the element.
manpath <S> <Z> (MANPATH <S> <Z>)
An array (colon-separated list) whose value is not
used by the shell. The manpath array can be use
ful, however, since setting it also sets MANPATH,
and vice versa.
module_path <S> <Z> (MODULE_PATH <S>)
An array (colon-separated list) of directories that
zmodload searches for dynamically loadable modules.
This is initialized to a standard pathname, usually
`/usr/local/lib/zsh/$ZSH_VERSION'. (The
`/usr/local/lib' part varies from installation to
installation.) For security reasons, any value set
in the environment when the shell is started will
be ignored.
These parameters only exist if the installation
supports dynamic module loading.
NULLCMD <S>
The command name to assume if a redirection is
sh/ksh behavior, change this to :. For csh-like
behavior, unset this parameter; the shell will
print an error message if null commands are
entered.
path <S> <Z> (PATH <S>)
An array (colon-separated list) of directories to
search for commands. When this parameter is set,
each directory is scanned and all files found are
put in a hash table.
POSTEDIT <S>
This string is output whenever the line editor
exits. It usually contains termcap strings to
reset the terminal.
PROMPT <S> <Z>
PROMPT2 <S> <Z>
PROMPT3 <S> <Z>
PROMPT4 <S> <Z>
Same as PS1, PS2, PS3 and PS4, respectively.
prompt <S> <Z>
Same as PS1.
PS1 <S>
The primary prompt string, printed before a command
is read. the default is `%m%# '. It undergoes a
special form of expansion before being displayed;
see the section `Prompt Expansion'.
PS2 <S>
The secondary prompt, printed when the shell needs
more information to complete a command. It is
expanded in the same way as PS1. The default is
`%_> ', which displays any shell constructs or quo
tation marks which are currently being processed.
PS3 <S>
Selection prompt used within a select loop. It is
expanded in the same way as PS1. The default is
`?# '.
PS4 <S>
The execution trace prompt. Default is `+%N:%i> ',
which displays the name of the current shell struc
ture and the line number within it. In sh or ksh
emulation, the default is `+ '.
psvar <S> <Z> (PSVAR <S>)
An array (colon-separated list) whose first nine
values can be used in PROMPT strings. Setting
psvar also sets PSVAR, and vice versa.
The command name to assume if a single input redi
rection is specified with no command. Defaults to
more.
REPORTTIME
If nonnegative, commands whose combined user and
system execution times (measured in seconds) are
greater than this value have timing statistics
printed for them.
REPLY This parameter is reserved by convention to pass
string values between shell scripts and shell
builtins in situations where a function call or
redirection are impossible or undesirable. The
read builtin and the select complex command may set
REPLY, and filename generation both sets and exam
ines its value when evaluating certain expressions.
Some modules also employ REPLY for similar pur
poses.
reply As REPLY, but for array values rather than strings.
RPROMPT <S>
RPS1 <S>
This prompt is displayed on the right-hand side of
the screen when the primary prompt is being dis
played on the left. This does not work if the SIN
GLELINEZLE option is set. It is expanded in the
same way as PS1.
SAVEHIST
The maximum number of history events to save in the
history file.
SPROMPT <S>
The prompt used for spelling correction. The
sequence `%R' expands to the string which presum
ably needs spelling correction, and `%r' expands to
the proposed correction. All other prompt escapes
are also allowed.
STTY If this parameter is set in a command's environ
ment, the shell runs the stty command with the
value of this parameter as arguments in order to
set up the terminal before executing the command.
The modes apply only to the command, and are reset
when it finishes or is suspended. If the command is
suspended and continued later with the fg or wait
builtins it will see the modes specified by STTY,
as if it were not suspended. This (intentionally)
does not apply if the command is continued via
`kill -CONT'. STTY is ignored if the command is
run in the background, or if it is in the
assigned to in the input line. This avoids running
stty at every external command by accidentally
exporting it. Also note that STTY should not be
used for window size specifications; these will not
be local to the command.
TERM <S>
The type of terminal in use. This is used when
looking up termcap sequences.
TIMEFMT
The format of process time reports with the time
keyword. The default is `%E real %U user %S sys
tem %P %J'. Recognizes the following escape
sequences:
%% A `%'.
%U CPU seconds spent in user mode.
%S CPU seconds spent in kernel mode.
%E Elapsed time in seconds.
%P The CPU percentage, computed as (%U+%S)/%E.
%J The name of this job.
A star may be inserted between the percent sign and
flags printing time. This cause the time to be
printed in `hh:mm:ss.ttt' format (hours and minutes
are only printed if they are not zero).
TMOUT If this parameter is nonzero, the shell will
receive an ALRM signal if a command is not entered
within the specified number of seconds after issu
ing a prompt. If there is a trap on SIGALRM, it
will be executed and a new alarm is scheduled using
the value of the TMOUT parameter after executing
the trap. If no trap is set, and the idle time of
the terminal is not less than the value of the
TMOUT parameter, zsh terminates. Otherwise a new
alarm is scheduled to TMOUT seconds after the last
keypress.
TMPPREFIX
A pathname prefix which the shell will use for all
temporary files. Note that this should include an
initial part for the file name as well as any
directory names. The default is `/tmp/zsh'.
watch <S> <Z> (WATCH <S>)
An array (colon-separated list) of login/logout
events to report. If it contains the single word
`all', then all login/logout events are reported.
If it contains the single word `notme', then all
events are reported as with `all' except $USERNAME.
An entry in this list may consist of a username, an
lowed by a line (tty). Any or all of these compo
nents may be present in an entry; if a login/logout
event matches all of them, it is reported.
WATCHFMT
The format of login/logout reports if the watch
parameter is set. Default is `%n has %a %l from
%m'. Recognizes the following escape sequences:
%n The name of the user that logged in/out.
%a The observed action, i.e. "logged on" or
"logged off".
%l The line (tty) the user is logged in on.
%M The full hostname of the remote host.
%m The hostname up to the first `.'. If only
the IP address is available or the utmp
field contains the name of an X-windows dis
play, the whole name is printed.
NOTE: The `%m' and `%M' escapes will work
only if there is a host name field in the
utmp on your machine. Otherwise they are
treated as ordinary strings.
%S (%s)
Start (stop) standout mode.
%U (%u)
Start (stop) underline mode.
%B (%b)
Start (stop) boldface mode.
%t
%@ The time, in 12-hour, am/pm format.
%T The time, in 24-hour format.
%w The date in `day-dd' format.
%W The date in `mm/dd/yy' format.
%D The date in `yy-mm-dd' format.
%(x:true-text:false-text)
Specifies a ternary expression. The charac
ter following the x is arbitrary; the same
character is used to separate the text for
the "true" result from that for the "false"
parenthesis may be escaped with a backslash.
Ternary expressions may be nested.
The test character x may be any one of `l',
`n', `m' or `M', which indicate a `true'
result if the corresponding escape sequence
would return a non-empty value; or it may be
`a', which indicates a `true' result if the
watched user has logged in, or `false' if he
has logged out. Other characters evaluate
to neither true nor false; the entire
expression is omitted in this case.
If the result is `true', then the true-text
is formatted according to the rules above
and printed, and the false-text is skipped.
If `false', the true-text is skipped and the
false-text is formatted and printed. Either
or both of the branches may be empty, but
both separators must be present in any case.
WORDCHARS <S>
A list of non-alphanumeric characters considered
part of a word by the line editor.
ZBEEP If set, this gives a string of characters, which
can use all the same codes as the bindkey command
as described in the zsh/zle module entry in zshmod
ules(1), that will be output to the terminal
instead of beeping. This may have a visible
instead of an audible effect; for example, the
string `\e[?5h\e[?5l' on a vt100 or xterm will have
the effect of flashing reverse video on and off (if
you usually use reverse video, you should use the
string `\e[?5l\e[?5h' instead). This takes prece
dence over the NOBEEP option.
ZDOTDIR
The directory to search for shell startup files
(.zshrc, etc), if not $HOME.
Man(1) output converted with
man2html