Table of Contents generated with DocToc
15 Parameters
15.1 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 ‘!
’. A
parameter whose name begins with an alphanumeric or underscore is also
referred to as a variable.
The attributes of a parameter determine the type of its value, often referred to as the parameter type or variable type, and also control other processing that may be applied to the value when it is referenced. The value type may be a scalar (a string, an integer, or a floating point number), an array (indexed numerically), or an associative array (an unordered set of name-value pairs, indexed by name, also referred to as a hash).
Named scalar parameters may have the exported, -x
, attribute, to
copy them into the process environment, which is then passed from the
shell to any new processes that it starts. Exported parameters are
called environment variables. The shell also imports environment
variables at startup time and automatically marks the corresponding
parameters as exported. Some environment variables are not imported for
reasons of security or because they would interfere with the correct
operation of other shell features.
Parameters may also be special, that is, they have a predetermined meaning to the shell. Special parameters cannot have their type changed or their readonly attribute turned off, and if a special parameter is unset, then later recreated, the special properties will be retained.
To declare the type of a parameter, or to assign a string or numeric
value to a scalar parameter, use the typeset
builtin.
The value of a scalar parameter may also be assigned by writing:
name``=``value
In scalar assignment, value
is expanded as a single string, in which
the elements of arrays are joined together; filename expansion is not
performed unless the option GLOB_ASSIGN
is set.
When the integer attribute, -i
, or a floating point attribute, -E
or
-F
, is set for name
, the value
is subject to arithmetic
evaluation. Furthermore, by replacing ‘=
’ with ‘+=
’, a parameter can
be incremented or appended to. See Array Parameters
and Arithmetic
Evaluation for
additional forms of assignment.
Note that assignment may implicitly change the attributes of a
parameter. For example, assigning a number to a variable in arithmetic
evaluation may change its type to integer or float, and with
GLOB_ASSIGN
assigning a pattern to a variable may change its type to
an array.
To reference the value of a parameter, write ‘$``name
’ or
‘${``name``}
’. See Parameter
Expansion for complete details.
That section also explains the effect of the difference between scalar
and array assignment on parameter expansion.
15.2 Array Parameters
To assign an array value, write one of:
set -A
name
value
...
name``=(``value
...)
name``=(``[``key``]=``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.
In the third form, key
is an expression that will be evaluated in
arithmetic context (in its simplest form, an integer) that gives the
index of the element to be assigned with value
. In this form any
elements not explicitly mentioned that come before the largest index to
which a value is assigned are assigned an empty string. The indices may
be in any order. Note that this syntax is strict: [
and ]=
must not
be quoted, and key
may not consist of the unquoted string ]=
, but is
otherwise treated as a simple string. The enhanced forms of subscript
expression that may be used when directly subscripting a variable name,
described in the section Array Subscripts below, are not available.
The syntaxes with and without the explicit key may be mixed. An implicit
key
is deduced by incrementing the index from the previously assigned
element. Note that it is not treated as an error if latter assignments
in this form overwrite earlier assignments.
For example, assuming the option KSH_ARRAYS
is not set, the following:
array=(one [3]=three four)
causes the array variable array
to contain four elements one
, an
empty string, three
and four
, in that order.
In the forms where only value
is specified, full command line
expansion is performed.
In the [``key``]=``value
form, both key
and value
undergo all
forms of expansion allowed for single word shell expansions (this does
not include filename generation); these are as performed by the
parameter expansion flag (e)
as described in Parameter
Expansion. Nested parentheses may
surround value
and are included as part of the value, which is joined
into a plain string; this differs from ksh which allows the values
themselves to be arrays. A future version of zsh may support that. To
cause the brackets to be interpreted as a character class for filename
generation, and therefore to treat the resulting list of files as a set
of values, quote the equal sign using any form of quoting. Example:
name``=(``[a-z]’=’*)
To append to an array without changing the existing values, use one of the following:
name``+=(``value
...)
name``+=(``[``key``]=``value
...)
In the second form key
may specify an existing index as well as an
index off the end of the old array; any existing value is overwritten by
value
. Also, it is possible to use [``key``]+=``value
to append to
the existing value at that index.
Within the parentheses on the right hand side of either form of the
assignment, newlines and semicolons are treated the same as white space,
separating individual value
s. Any consecutive sequence of such
characters has the same effect.
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:
set -A
name
key
value
...
name``=(``key
value
...)
name``=(``[``key``]=``value
...)
Note that only one of the two syntaxes above may be used in any given assignment; the forms may not be mixed. This is unlike the case of numerically indexed arrays.
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.
The append syntax may also be used with an associative array:
name``+=(``key
value
...)
name``+=(``[``key``]=``value
...)
This adds a new key/value pair if the key is not already present, and
replaces the value for the existing key if it is. In the second form it
is also possible to use [``key``]+=``value
to append to the existing
value at that key. Expansion is performed identically to the
corresponding forms for normal arrays, as described above.
To create an empty array (including associative arrays), use one of:
set -A
name
name``=()
15.2.1 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.
If the KSH_ARRAYS
option is not set, then by default accesses to an
array element with a subscript that evaluates to zero return an empty
string, while an attempt to write such an element is treated as an
error. For backward compatibility the KSH_ZERO_SUBSCRIPT
option can be
set to cause subscript values 0 and 1 to be equivalent; see the
description of the option in Description of
Options.
The same subscripting syntax is used for associative arrays, except that
no arithmetic expansion is applied to exp
. However, the parsing rules
for arithmetic expressions still apply, which affects the way that
certain special 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, in no particular order. Note that this does not substitute the
keys; see the documentation for the ‘k
’ flag under Parameter
Expansion for complete details.
When an array parameter is referenced 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
, then the n
th element from
the end of the array is used. 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
’.
Note that some forms of subscripting described below perform pattern
matching, and in that case the substring extends from the start of the
match of the first subscript to the end of the match of the second
subscript. For example,
string="abcdefghijklm"
print ${string[(r)d?,(r)h?]}
prints ‘defghi
’. This is an obvious generalisation of the rule for
single-character matches. For a single subscript, only a single
character is referenced (not the range of characters covered by the
match).
Note that in substring operations the second subscript is handled
differently by the r
and R
subscript flags: the former takes the
shortest match as the length and the latter the longest match. Hence in
the former case a *
at the end is redundant while in the latter case
it matches the whole remainder of the string. This does not affect the
result of the single subscript case as here the length of the match is
irrelevant.
15.2.2 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, shifting
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
command:
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``]"
15.2.3 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 s
, n
and b
take an argument; the delimiter is shown
below as ‘:
’, but any character, or the matching pairs ‘(
...)
’,
‘{
...}
’, ‘[
...]
’, or ‘<
...>
’, may be used, but note that
‘<
...>
’ can only be used if the subscript is inside a double
quoted expression or a parameter substitution enclosed in braces as
otherwise the expression is interpreted as a redirection.
The flags currently understood are:
-
w
If the parameter subscripted is a scalar then this flag makes subscripting work on words instead of characters. The default word separator is whitespace. When combined with thei
orI
flag, the effect is to produce the index of the first character of the first/last word which matches the given pattern; note that a failed match in this case always yields 0. -
s:``string``:
This gives thestring
that separates words (for use with thew
flag). The delimiter character:
is arbitrary; see above. -
p
Recognize the same escape sequences as theprint
builtin in the string argument of a subsequent ‘s
’ flag. -
f
If the parameter subscripted is a scalar then this flag makes subscripting work on lines instead of characters, i.e. with elements separated by newlines. This is a shorthand for ‘pws:\n:
’. -
r
Reverse subscripting: if this flag is given, theexp
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, respectively). 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 possible if the parameter is not an associative array. 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.If a search through an ordinary array failed, the search sets the subscript to one past the end of the array, and hence
${array[(r)``pattern``]}
will substitute the empty string. Thus the success of a search can be tested by using the(i)
flag, for example (assuming the optionKSH_ARRAYS
is not in effect):[[ ${array[(i)pattern]} -le ${#array} ]]
If
KSH_ARRAYS
is in effect, the-le
should be replaced by-lt
. -
R
Like ‘r
’, but gives the last match. For associative arrays, gives all possible matches. May be used for assigning to ordinary array elements, but not for assigning to associative arrays. On failure, for normal arrays this has the effect of returning the element corresponding to subscript 0; this is empty unless one of the optionsKSH_ARRAYS
orKSH_ZERO_SUBSCRIPT
is in effect.Note that in subscripts with both ‘
r
’ and ‘R
’ pattern characters are active even if they were substituted for a parameter (regardless of the setting ofGLOB_SUBST
which controls this feature in normal pattern matching). The flag ‘e
’ can be added to inhibit pattern matching. As this flag does not inhibit other forms of substitution, care is still required; using a parameter to hold the key has the desired effect:key2='original key' print ${array[(Re)$key2]}
-
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. On failure substitutes the length of the array plus one, as discussed under the description of ‘r
’, or the empty string for an associative array. -
I
Like ‘i
’, but gives the index of the last match, or all possible matching keys in an associative array. On failure substitutes 0, or the empty string for an associative array. This flag is best when testing for values or keys that do not exist. -
k
If used in a subscript on an associative array, this flag causes the keys to be interpreted as patterns, and returns the value for the first key found whereexp
is matched by the key. Note this could be any such key as no ordering of associative arrays is defined. 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 whereexp
is matched by the keys. On other types of parameters this has the same effect as ‘R
’. -
n:``expr``:
If combined with ‘r
’, ‘R
’, ‘i
’ or ‘I
’, makes them give then
th orn
th last match (ifexpr
evaluates ton
). This flag is ignored when the array is associative. The delimiter character:
is arbitrary; see above. -
b:``expr``:
If combined with ‘r
’, ‘R
’, ‘i
’ or ‘I
’, makes them begin at then
th orn
th last element, word, or character (ifexpr
evaluates ton
). This flag is ignored when the array is associative. The delimiter character:
is arbitrary; see above. -
e
This flag causes any pattern matching that would be performed on the subscript to use plain string matching instead. Hence ‘${array[(re)*]}
’ matches only the array element whose value is*
. Note that other forms of substitution such as parameter substitution are not inhibited.This flag can also be used to force
*
or@
to be interpreted as a single key rather than as a reference to all values. It may be used for either purpose on the left side of an assignment.
See Parameter Expansion Flags (Parameter Expansion) for additional ways to manipulate the results of array subscripting.
15.2.4 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 parameter substitutions that appear as
part of an arithmetic expression in an ordinary subscript.
To avoid subscript parsing limitations in assignments to associative array elements, use the append syntax:
aa+=('key with "*strange*" characters' 'value string')
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
(Quoting). However, unlike double quotes
which normally cannot nest, subscript expressions may appear inside
double-quoted strings or inside other subscript 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!
The same rule applies to parentheses (‘(
’ and ‘)
’) and 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 by balanced braces, and subscript flags are introduced by
balanced parentheses.
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 characters ‘\"
’ 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 double-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 subscript 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 are first expanded and
then the complete 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 subscript, 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 complete 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``}
’ (Parameter
Expansion) 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 (Positional
Parameters) 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 characters of the second positional
parameter, but ‘$2[3,5]
’ is the entire second parameter concatenated
with the filename generation pattern ‘[3,5]
’.
15.3 Positional Parameters
The positional parameters provide access to the command-line arguments
of a shell function, shell script, or the shell itself; see
Invocation, and also
Functions. The parameter n
, where n
is a
number, is the n
th positional parameter. The parameter ‘$0
’ is a
special case, see Parameters Set By The
Shell.
The parameters *
, @
and argv
are arrays containing all the
positional parameters; thus ‘$argv[``n``]
’, etc., is equivalent to
simply ‘$``n
’. Note that the options KSH_ARRAYS
or
KSH_ZERO_SUBSCRIPT
apply to these arrays as well, so with either of
those options set, ‘${argv[0]}
’ is equivalent to ‘$1
’ and so on.
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 parameter 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
...)
’ is allowed, and has
the effect of shifting all the values at positions greater than n
by
as many positions as necessary to accommodate the new values.
15.4 Local Parameters
Shell function executions delimit scopes for shell parameters.
(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 outermost 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 hidden.
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.
15.5 Parameters Set By The Shell
In the parameter lists that follow, the mark ‘<S>’ indicates that the
parameter is special. ‘<Z>’ indicates that the parameter does not
exist when the shell initializes in sh
or ksh
emulation mode.
The following parameters are automatically set by the shell:
!
<S>
The process ID of the last command started in the background with &
,
put into the background with the bg
builtin, or spawned with coproc
.
#
<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 interpreted as the length
of the parameter -
, q.v.
ARGC
<S> <Z>
Same as #
.
$
<S>
The process ID of this shell. Note that this indicates the original
shell started by invoking zsh
; all processes forked from the shells
without executing a new program, such as subshells started by
(``...``)
, substitute the same value.
-
<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 status returned by the last command.
0
<S>
The name used to invoke the current shell, or as set by the -c
command
line option upon invocation. If the FUNCTION_ARGZERO
option is set,
$0
is set upon entry to a shell function to the name of the function,
and upon entry to a sourced script to the name of the script, and reset
to its previous value when the function or script returns.
status
<S> <Z>
Same as ?
.
pipestatus
<S> <Z>
An array containing the exit statuses 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 command.
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 assigning to this parameter. Also (assuming sufficient privileges),
you may start a single command with a different effective group ID by
‘(EGID=``gid``; command)
’
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
EUID
<S>
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 privileges), you
may start a single command with a different effective user ID by
‘(EUID=``uid``; command)
’
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
ERRNO
<S>
The value of errno (see man page errno(3)) as set by the most recently
failed system call. This value is system dependent and is intended for
debugging purposes. It is also useful with the zsh/system
module which
allows the number to be turned into a name or message.
FUNCNEST
<S>
Integer. If greater than or equal to zero, the maximum nesting depth of shell functions. When it is exceeded, an error is raised at the point where a function is called. The default value is determined when the shell is configured, but is typically 500. Increasing the value increases the danger of a runaway function recursion causing the shell to crash. Setting a negative value turns off the check.
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)
’
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
HISTCMD
The current history event number in an interactive shell, in other words
the event number for the command that caused $HISTCMD
to be read. If
the current history event modifies the history, HISTCMD
changes to the
new maximum history event number.
HOST
The current hostname.
LINENO
<S>
The line number of the current line within the current 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 session. This parameter is exported by default but this can be
disabled using the typeset
builtin. The value is set to the string
returned by the man page getlogin(3) system call if that is available.
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 the getopts
command.
OSTYPE
The operating system, as determined at compile time.
PPID
<S>
The process ID of the parent of the shell. As for $$
, the value
indicates the parent of the original shell and does not change in
subshells.
PWD
The present working directory. This is set when the shell initializes and whenever the directory changes.
RANDOM
<S>
A pseudo-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
.
sequence; subshells that reference RANDOM
will result in identical
pseudo-random values unless the value of RANDOM
is referenced or
seeded in the parent shell in between subshell invocations.
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.
Unlike other special parameters, the type of the SECONDS
parameter can
be changed using the typeset
command. Only integer and one of the
floating point types are allowed. For example, ‘typeset -F SECONDS
’
causes the value to be reported as a floating point number. The value is
available to microsecond accuracy, although the shell may show more or
fewer digits depending on the use of typeset
. See the documentation
for the builtin typeset
in Shell Builtin
Commands for more
details.
SHLVL
<S>
Incremented by one each time a new shell is started.
signals
An array containing the names of the signals. Note that with the
standard zsh numbering of array indices, where the first element has
index 1, the signals are offset by 1 from the signal number used by the
operating system. For example, on typical Unix-like systems HUP
is
signal number 1, but is referred to as $signals[2]
. This is because of
EXIT
at position 1 in the array, which is used internally by zsh but
is not known to the operating system.
TRY_BLOCK_ERROR
<S>
In an always
block, indicates whether the preceding list of code
caused an error. The value is 1 to indicate an error, 0 otherwise. It
may be reset, clearing the error condition. See Complex
Commands
TRY_BLOCK_INTERRUPT
<S>
This variable works in a similar way to TRY_BLOCK_ERROR
, but
represents the status of an interrupt from the signal SIGINT, which
typically comes from the keyboard when the user types ^C
. If set to 0,
any such interrupt will be reset; otherwise, the interrupt is propagated
after the always
block.
Note that it is possible that an interrupt arrives during the execution
of the always
block; this interrupt is also propagated.
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)
’
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
USERNAME
<S>
The username corresponding to the real user ID of the shell process. If
you have sufficient privileges, you may change the username (and also
the user ID and group ID) of the shell by assigning to this parameter.
Also (assuming sufficient privileges), you may start a single command
under a different username (and user ID and group ID) by
‘(USERNAME=``username``; command)
’
VENDOR
The vendor, as determined at compile time.
zsh_eval_context
<S> <Z> (ZSH_EVAL_CONTEXT
<S>)
An array (colon-separated list) indicating the context of shell code that is being run. Each time a piece of shell code that is stored within the shell is executed a string is temporarily appended to the array to indicate the type of operation that is being performed. Read in order the array gives an indication of the stack of operations being performed with the most immediate context last.
Note that the variable does not give information on syntactic context
such as pipelines or subshells. Use $ZSH_SUBSHELL
to detect subshells.
The context is one of the following:
-
cmdarg
Code specified by the-c
option to the command line that invoked the shell. -
cmdsubst
Command substitution using the‘``...``‘
or$(``...``)
construct. -
equalsubst
File substitution using the=(``...``)
construct. -
eval
Code executed by theeval
builtin. -
evalautofunc
Code executed with theKSH_AUTOLOAD
mechanism in order to define an autoloaded function. -
fc
Code from the shell history executed by the-e
option to thefc
builtin. -
file
Lines of code being read directly from a file, for example by thesource
builtin. -
filecode
Lines of code being read from a.zwc
file instead of directly from the source file. -
globqual
Code executed by thee
or+
glob qualifier. -
globsort
Code executed to order files by theo
glob qualifier. -
insubst
File substitution using the<(``...``)
construct. -
loadautofunc
Code read directly from a file to define an autoloaded function. -
outsubst
File substitution using the>(``...``)
construct. -
sched
Code executed by thesched
builtin. -
shfunc
A shell function. -
stty
Code passed tostty
by theSTTY
environment variable. Normally this is passed directly to the system’sstty
command, so this value is unlikely to be seen in practice. -
style
Code executed as part of a style retrieved by thezstyle
builtin from thezsh/zutil
module. -
toplevel
The highest execution level of a script or interactive shell. -
trap
Code executed as a trap defined by thetrap
builtin. Traps defined as functions have the contextshfunc
. As traps are asynchronous they may have a different hierarchy from other code. -
zpty
Code executed by thezpty
builtin from thezsh/zpty
module. -
zregexparse-guard
Code executed as a guard by thezregexparse
command from thezsh/zutil
module. -
zregexparse-action
Code executed as an action by thezregexparse
command from thezsh/zutil
module.
ZSH_ARGZERO
If zsh was invoked to run a script, this is the name of the script.
Otherwise, it is the name used to invoke the current shell. This is the
same as the value of $0
when the POSIX_ARGZERO
option is set, but is
always available.
ZSH_EXECUTION_STRING
If the shell was started with the option -c
, this contains the
argument passed to the option. Otherwise it is not set.
ZSH_NAME
Expands to the basename of the command used to invoke this instance of zsh.
ZSH_PATCHLEVEL
The output of ‘git describe –tags –long
’ for the zsh repository used
to build the shell. This is most useful in order to keep track of
versions of the shell during development between releases; hence most
users should not use it and should instead rely on $ZSH_VERSION
.
zsh_scheduled_events
See The zsh/sched Module.
ZSH_SCRIPT
If zsh was invoked to run a script, this is the name of the script, otherwise it is unset.
ZSH_SUBSHELL
Readonly integer. Initially zero, incremented each time the shell forks
to create a subshell for executing code. Hence ‘(print $ZSH_SUBSHELL)
’
and ‘print $(print $ZSH_SUBSHELL)
’ output 1, while ‘( (print $ZSH_SUBSHELL) )
’ outputs 2.
ZSH_VERSION
The version number of the release of zsh.
15.6 Parameters Used By The Shell
The following parameters are used by the shell. Again, ‘<S>’ indicates
that the parameter is special and ‘<Z>’ indicates that the parameter
does not exist when the shell initializes in sh
or ksh
emulation
mode.
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 recreating 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 rate in bits per second at which data reaches the terminal. The line editor will use this value in order to compensate for a slow terminal by delaying updates to the display until necessary. If the parameter is unset or the value is zero the compensation mechanism is turned off. The parameter is not set by default.
This parameter may be profitably set in some circumstances, e.g. for slow modems dialing into a communications server, or on a slow wide area network. It should be set to the baud rate of the slowest part of the link for best performance.
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.
CORRECT_IGNORE
If set, is treated as a pattern during spelling correction. Any
potential correction that matches the pattern is ignored. For example,
if the value is ‘_*
’ then completion functions (which, by convention,
have names beginning with ‘_
’) will never be offered as spelling
corrections. The pattern does not apply to the correction of file names,
as applied by the CORRECT_ALL
option (so with the example just given
files beginning with ‘_
’ in the current directory would still be
completed).
CORRECT_IGNORE_FILE
If set, is treated as a pattern during spelling correction of file
names. Any file name that matches the pattern is never offered as a
correction. For example, if the value is ‘.*
’ then dot file names will
never be offered as spelling corrections. This is useful with the
CORRECT_ALL
option.
DIRSTACKSIZE
The maximum size of the directory stack, by default there is no limit.
If the stack gets larger than this, it will be truncated automatically.
This is useful with the AUTO_PUSHD
option.
ENV
If the ENV
environment variable is set when zsh is invoked as sh
or
ksh
, $ENV
is sourced after the profile scripts. The value of ENV
is subjected to parameter expansion, command substitution, and
arithmetic expansion before being interpreted as a pathname. Note that
ENV
is not used unless the shell is interactive and zsh is emulating
sh or ksh.
FCEDIT
The default editor for the fc
builtin. If FCEDIT
is not set, the
parameter EDITOR
is used; if that is not set either, a builtin
default, usually vi
, is used.
fignore
<S> <Z> (FIGNORE
<S>)
An array (colon separated list) containing the suffixes of files to be ignored during filename completion. However, if completion only generates files with suffixes in this list, then these files are completed anyway.
fpath
<S> <Z> (FPATH
<S>)
An array (colon separated list) of directories specifying the search path for function definitions. This path is searched when a function 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 ‘#
’).
The characters must be in the ASCII character set; any attempt to set
histchars
to characters with a locale-dependent meaning will be
rejected with an error message.
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.
HISTORY_IGNORE
If set, is treated as a pattern at the time history files are written.
Any potential history entry that matches the pattern is skipped. For
example, if the value is ‘fc *
’ then commands that invoke the
interactive history editor are never written to the history file.
Note that HISTORY_IGNORE
defines a single pattern: to specify
alternatives use the ‘(``first``|``second``|``...``)
’ syntax.
Compare the HIST_NO_STORE
option or the zshaddhistory
hook, either
of which would prevent such commands from being added to the interactive
history at all. If you wish to use HISTORY_IGNORE
to stop history
being added in the first place, you can define the following hook:
zshaddhistory() {
emulate -L zsh
## uncomment if HISTORY_IGNORE
## should use EXTENDED_GLOB syntax
# setopt extendedglob
[[ $1 != ${~HISTORY_IGNORE} ]]
}
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 history events.
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
HOME
<S>
The default argument for the cd
command. This is not set automatically
by the shell in sh
, ksh
or csh
emulation, but it is typically
present in the environment anyway, and if it becomes set it has its
usual special behaviour.
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 and words read by the read
builtin. Any characters 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.
If the parameter is unset, the default is used. Note this has a different effect from setting the parameter to an empty string.
KEYBOARD_HACK
This variable defines a character to be removed from the end of the
command line before interpreting it (interactive shells only). It is
intended to fix the problem with keys placed annoyingly close to return
and replaces the SUNKEYBOARDHACK
option which did this for backquotes
only. Should the chosen character be one of singlequote, doublequote or
backquote, there must also be an odd number of them on the command line
for the last one to be removed.
For backward compatibility, if the SUNKEYBOARDHACK
option is
explicitly set, the value of KEYBOARD_HACK
reverts to backquote. If
the option is explicitly unset, this variable is set to empty.
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 variable starting with ‘LC_
’.
LC_ALL
<S>
This variable overrides the value of the ‘LANG
’ variable and the value
of any of the other variables 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. If the MULTIBYTE
option is in effect this variable or
LANG
should contain a value that reflects the character set in use,
even if it is a single-byte character set, unless only the 7-bit subset
(ASCII) is used. For example, if the character set Linux distributions)
or en_US.ISO8859-1
(MacOS).
LC_MESSAGES
<S>
This variable determines the language in which messages 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 functions. 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 editor.
LISTMAX
In the line editor, the number of matches to list without asking 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 useful, however, since setting it also sets
MANPATH
, and vice versa.
match
mbegin
mend
Arrays set by the shell when the b
globbing flag is used in pattern
matches. See the subsection Globbing flags in Filename
Generation.
MATCH
MBEGIN
MEND
Set by the shell when the m
globbing flag is used in pattern matches.
See the subsection Globbing flags in Filename
Generation.
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 specified with no
command. Defaults to cat
. For 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
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
.
PROMPT_EOL_MARK
When the PROMPT_CR
and PROMPT_SP
options are set, the
PROMPT_EOL_MARK
parameter can be used to customize how the end of
partial lines are shown. This parameter undergoes prompt expansion, with
the PROMPT_PERCENT
option set. If not set, the default behavior is
equivalent to the value ‘%B%S%#%s%b
’.
PS1
<S>
The primary prompt string, printed before a command is read. It
undergoes a special form of expansion before being displayed; see
Prompt Expansion. The default
is ‘%m%#
’.
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 quotation 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 structure 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 elements can be used in PROMPT
strings. Setting psvar
also sets PSVAR
, and vice versa.
READNULLCMD
<S>
The command name to assume if a single input redirection is specified
with no command. Defaults to more
.
REPORTMEMORY
If nonnegative, commands whose maximum resident set size (roughly
speaking, main memory usage) in kilobytes is greater than this value
have timing statistics reported. The format used to output statistics is
the value of the TIMEFMT
parameter, which is the same as for the
REPORTTIME
variable and the time
builtin; note that by default this
does not output memory usage. Appending " max RSS %M"
to the value of
TIMEFMT
causes it to output the value that triggered the report. If
REPORTTIME
is also in use, at most a single report is printed for both
triggers. This feature requires the getrusage()
system call, commonly
supported by modern Unix-like systems.
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. Output is suppressed for commands executed within the
line editor, including completion; commands explicitly marked with the
time
keyword still cause the summary to be printed in this case.
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 examines its value when evaluating certain expressions. Some
modules also employ REPLY
for similar purposes.
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 displayed on the left. This does not work if the
SINGLE_LINE_ZLE
option is set. It is expanded in the same way as
PS1
.
RPROMPT2
<S>
RPS2
<S>
This prompt is displayed on the right-hand side of the screen when the
secondary prompt is being displayed on the left. This does not work if
the SINGLE_LINE_ZLE
option is set. It is expanded in the same way as
PS2
.
SAVEHIST
The maximum number of history events to save in the history file.
If this is made local, it is not implicitly set to 0, but may be explicitly set locally.
SPROMPT
<S>
The prompt used for spelling correction. The sequence ‘%R
’ expands to
the string which presumably needs spelling correction, and ‘%r
’
expands to the proposed correction. All other prompt escapes are also
allowed.
The actions available at the prompt are [nyae]
:
-
n
(‘no’) (default)
Discard the correction and run the command. -
y
(‘yes’)
Make the correction and run the command. -
a
(‘abort’)
Discard the entire command line without running it. -
e
(‘edit’)
Resume editing the command line.
STTY
If this parameter is set in a command’s environment, 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 environment of the shell but not
explicitly 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. An assignment to TERM
causes zsh to re-initialize the
terminal, even if the value does not change (e.g., ‘TERM=$TERM
’). It
is necessary to make such an assignment upon any change to the terminal
definition database or terminal type in order for the new settings to
take effect.
TERMINFO
<S>
A reference to your terminfo database, used by the ‘terminfo’ library
when the system has it; see man page terminfo(5). If set, this causes
the shell to reinitialise the terminal, making the workaround
‘TERM=$TERM
’ unnecessary.
TERMINFO_DIRS
<S>
A colon-seprarated list of terminfo databases, used by the ‘terminfo’
library when the system has it; see man page terminfo(5). This variable
is only used by certain terminal libraries, in particular ncurses; see
man page terminfo(5) to check support on your system. If set, this
causes the shell to reinitialise the terminal, making the workaround
‘TERM=$TERM
’ unnecessary. Note that unlike other colon-separated
arrays this is not tied to a zsh array.
TIMEFMT
The format of process time reports with the time
keyword. The default
is ‘%J %U user %S system %P cpu %*E total
’. Recognizes the following
escape sequences, although not all may be available on all systems, and
some that are available may not be useful:
-
%%
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 100*(%U
+%S
)/%E
. -
%W
Number of times the process was swapped. -
%X
The average amount in (shared) text space used in kilobytes. -
%D
The average amount in (unshared) data/stack space used in kilobytes. -
%K
The total space used (%X
+%D
) in kilobytes. -
%M
The maximum memory the process had in use at any time in kilobytes. -
%F
The number of major page faults (page needed to be brought from disk). -
%R
The number of minor page faults. -
%I
The number of input operations. -
%O
The number of output operations. -
%r
The number of socket messages received. -
%s
The number of socket messages sent. -
%k
The number of signals received. -
%w
Number of voluntary context switches (waits). -
%c
Number of involuntary context switches. -
%J
The name of this job.
A star may be inserted between the percent sign and flags printing time
(e.g., ‘%*E
’); this causes the time to be printed in
‘hh``:``mm``:``ss``.``ttt
’ format (hours and minutes are only
printed if they are not zero). Alternatively, ‘m
’ or ‘u
’ may be used
(e.g., ‘%mE
’) to produce time output in milliseconds or microseconds,
respectively.
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
issuing 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
’.
TMPSUFFIX
A filename suffix which the shell will use for temporary files created
by process substitutions (e.g., ‘=(list)
’). Note that the value should
include a leading dot ‘.
’ if intended to be interpreted as a file
extension. The default is not to append any suffix, thus this parameter
should be assigned only when needed and then unset again.
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 ‘@
’ followed by a
remote hostname, and a ‘%
’ followed by a line (tty). Any of these may
be a pattern (be sure to quote this during the assignment to watch
so
that it does not immediately perform file generation); the setting of
the EXTENDED_GLOB
option is respected. Any or all of these components
may be present in an entry; if a login/logout event matches all of them,
it is reported.
For example, with the EXTENDED_GLOB
option set, the following:
watch=('^(pws|barts)')
causes reports for activity associated with any user other than pws
or
barts
.
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 display, 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. -
%D{``string``}
The date formatted asstring
using thestrftime
function, with zsh extensions as described by Prompt Expansion. -
%(``x``:``true-text``:``false-text``)
Specifies a ternary expression. The character following thex
is arbitrary; the same character is used to separate the text for the "true" result from that for the "false" result. Both the separator and the right 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 thefalse-text
is skipped. If ‘false’, thetrue-text
is skipped and thefalse-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, 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 precedence over the NOBEEP
option.
ZDOTDIR
The directory to search for shell startup files (.zshrc, etc), if not
$HOME
.
zle_bracketed_paste
Many terminal emulators have a feature that allows applications to identify when text is pasted into the terminal rather than being typed normally. For ZLE, this means that special characters such as tabs and newlines can be inserted instead of invoking editor commands. Furthermore, pasted text forms a single undo event and if the region is active, pasted text will replace the region.
This two-element array contains the terminal escape sequences for enabling and disabling the feature. These escape sequences are used to enable bracketed paste when ZLE is active and disable it at other times. Unsetting the parameter has the effect of ensuring that bracketed paste remains disabled.
zle_highlight
An array describing contexts in which ZLE should highlight the input text. See Character Highlighting.
ZLE_LINE_ABORTED
This parameter is set by the line editor when an error occurs. It
contains the line that was being edited at the point of the error.
‘print -zr – $ZLE_LINE_ABORTED
’ can be used to recover the line.
Only the most recent line of this kind is remembered.
ZLE_REMOVE_SUFFIX_CHARS
ZLE_SPACE_SUFFIX_CHARS
These parameters are used by the line editor. In certain circumstances suffixes (typically space or slash) added by the completion system will be removed automatically, either because the next editing command as requiring the suffix to be removed.
These variables can contain the sets of characters that will cause the
suffix to be removed. If ZLE_REMOVE_SUFFIX_CHARS
is set, those
characters will cause the suffix to be removed; if
ZLE_SPACE_SUFFIX_CHARS
is set, those characters will cause the suffix
to be removed and replaced by a space.
If ZLE_REMOVE_SUFFIX_CHARS
is not set, the default behaviour is
equivalent to:
ZLE_REMOVE_SUFFIX_CHARS=$' \t\n;&|'
If ZLE_REMOVE_SUFFIX_CHARS
is set but is empty, no characters have
this behaviour. ZLE_SPACE_SUFFIX_CHARS
takes precedence, so that the
following:
ZLE_SPACE_SUFFIX_CHARS=$'&|'
causes the characters ‘&
’ and ‘|
’ to remove the suffix but to
replace it with a space.
To illustrate the difference, suppose that the option
AUTO_REMOVE_SLASH
is in effect and the directory DIR
has just been
completed, with an appended /
, following which the user types ‘&
’.
The default result is ‘DIR&
’. With ZLE_REMOVE_SUFFIX_CHARS
set but
without including ‘&
’ the result is ‘DIR/&
’. With
ZLE_SPACE_SUFFIX_CHARS
set to include ‘&
’ the result is ‘DIR &
’.
Note that certain completions may provide their own suffix removal or replacement behaviour which overrides the values described here. See the completion system documentation in Completion System.
ZLE_RPROMPT_INDENT
<S>
If set, used to give the indentation between the right hand side of the
right prompt in the line editor as given by RPS1
or RPROMPT
and the
right hand side of the screen. If not set, the value 1 is used.
Typically this will be used to set the value to 0 so that the prompt appears flush with the right hand side of the screen. This is not the default as many terminals do not handle this correctly, in particular when the prompt appears at the extreme bottom right of the screen. Recent virtual terminals are more likely to handle this case correctly. Some experimentation is necessary.
This document was generated on February 15, 2020 using
texi2html 5.0.
Zsh version 5.8, released on February 14, 2020.