Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
ZSHPARAM(1)							   ZSHPARAM(1)

       zshparam	- zsh parameters

       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 numerically),  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


       If the integer attribute, -i, is	set for	name, the value	is subject  to
       arithmetic  evaluation.	 See  the section `Array Parameters' for addi-
       tional forms of assignment.

       To refer	to the value of	a parameter, write `$name' or `${name}'.   See
       Parameter Expansion in zshexpn(1) for complete details.

       In  the	parameter lists	that follow, the mark `<S>' indicates 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	emula-
       tion mode.

       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:

	      set -A name key value ...
	      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

   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	expan-
       sion 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  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 (not the
       keys, but see Subscript Flags below), in	no particular order.  When  an
       array  parameter	is referenced as `$name' (with no subscript) it	evalu-
       ates 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	nth 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'.

   Array Element Assignment
       A subscript may be used on the left side	of an assignment like so:


       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 sup-
       ported 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  sin-
       gle-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	whitespace.

	      This gives the string that separates words (for use with	the  w

       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 ele-
	      ments separated by newlines.  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 ele-
	      ment, so that pairs of subscripts	such  as  `$foo[(r)??,3]'  and
	      `$foo[(r)??,(r)f*]'  are possible.  If the parameter is an asso-
	      ciative 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 associative arrays.

       R      Like  `r',  but  gives  the last match.  For associative 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 patterns, 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 asso-
	      ciative  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 same	effect as `R'.

	      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.

	      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	parameter 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 subscript expressions  (or
       both!), so the rules have two important differences.

       The first difference is that brackets (`[' and `]') must	appear as bal-
       anced 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 nor-
       mally required; for example, the	pattern	`[^[]' (to match any character
       other than an open bracket) should be written `[^\[]' in	a reverse-sub-
       script 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 back-
       slash, 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	paren-

       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 dou-
       ble-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 associa-
       tive array key, the `e' flag must be used:

	      typeset -A aa
	      print $aa[(e)*]

       A last detail must be considered	 when  reverse	subscripting  is  per-
       formed.	 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	 back-
       slashes	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}'	(see zshexpn(1)) to quote the expanded

       Note that the `k' and `K' flags are reverse subscripting	for  an	 ordi-
       nary  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

       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  sub-
       script  syntax  to extract a substring from a positional	parameter, the
       expansion must be surrounded by braces; for example, `${2[3,5]}'	evalu-
       ates  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]'.

       The  positional parameters provide access to the	command-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	 posi-
       tional  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 assign-
       ment of the form	`n=(value ...)'	is allowed,  and  has  the  effect  of
       shifting	 all  the  values at positions greater than n by as many posi-
       tions as	necessary to accommodate the new values.

       Shell function executions delimit scopes	for shell parameters.  (Param-
       eters  are  dynamically scoped.)	 The typeset builtin, and its alterna-
       tive 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 parame-
       ter 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 parame-
       ters were never exported	has been removed.

       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  par-
	      ticular,	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.

       - <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 FUNC-
	      TION_ARGZERO option is set, this is  set	temporarily  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 command.

	      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	suffi-
	      cient  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)'

       EUID <S>
	      The effective user ID of the shell process.  If you have	suffi-
	      cient  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)'

       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 purposes.

       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	privi-
	      leges),  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  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	 func-
	      tions builtin.

	      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 machine type (microprocessor class  or  machine  model),  as
	      determined at compile time.

       OLDPWD The previous working directory.  This is set when	the shell ini-
	      tializes and whenever the	directory changes.

       OPTARG <S>
	      The value	of the last option argument processed by  the  getopts

       OPTIND <S>
	      The  index  of the last option argument processed	by the getopts

       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  ini-
	      tializes 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.

	      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 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	privi-
	      leges),  you  may	start a	single command under a different user-
	      name (and	user ID	and group  ID)	by  `(USERNAME=username;  com-

       VENDOR The vendor, as determined	at compile time.

	      Expands  to  the	basename  of  the  command used	to invoke this
	      instance of zsh.

	      The version number of this zsh.

       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 cre-
       ated 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	recre-
       ated, and recreating one	of the pair will recreate the other.

       ARGV0  If exported, its value is	used as	the argv[0] of	external  com-
	      mands.  Usually used in constructs like `ARGV0=emacs nethack'.

       BAUD   The  baud	rate of	the current connection.	 Used by the line edi-
	      tor update mechanism to compensate for a slow terminal by	delay-
	      ing  updates  until  necessary.  This may	be profitably set to a
	      lower value in some circumstances, e.g.  for slow	modems dialing
	      into  a communications server which is connected to a host via a
	      fast link; in this case, this variable would be set  by  default
	      to  the speed of the fast	link, and not the modem.  This parame-
	      ter 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 suffixes of files
	      to  be  ignored during filename completion.  However, if comple-
	      tion 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 with the -u attribute is referenced.  If an exe-
	      cutable file is found, then it is	read and executed in the  cur-
	      rent environment.

       histchars <S>
	      Three  characters	used by	the shell's history and	lexical	analy-
	      sis mechanism.  The first	character signals the start of a  his-
	      tory  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.)

	      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  dif-
	      ference as a cushion for saving duplicated history 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 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.

	      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  col-
	      lation  information within ranges	in glob	brackets and for sort-

       LC_CTYPE	<S>
	      This variable determines the locale category for character  han-
	      dling functions.

       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	print-
	      ing select lists and for the line	editor.

	      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.

	      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.

	      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.

       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_VER-
	      SION'.   (The  `/usr/local/lib' part varies from installation to
	      installation.)  For security reasons, any	value set in the envi-
	      ronment 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
	      and all files found are put in a hash table.

       POSTEDIT	<S>
	      This  string  is output whenever the line	editor exits.  It usu-
	      ally 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	expan-
	      sion before being	displayed; see the section `Prompt Expansion'.

       PS2 <S>
	      The secondary prompt, printed when the shell needs more informa-
	      tion 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 dis-
	      plays the	name of	the current shell structure and	the line  num-
	      ber 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

	      The  command  name  to  assume  if a single input	redirection is
	      specified	with no	command.  Defaults to more.

	      If nonnegative, commands whose combined user and	system	execu-
	      tion  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	examines its value when	evalu-
	      ating  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  SINGLELINEZLE  option  is	 set.	It  is
	      expanded in the same way as PS1.

	      The  maximum  number  of	history	 events	to save	in the history

       SPROMPT <S>
	      The prompt used for  spelling  correction.   The	sequence  `%R'
	      expands  to  the	string which presumably	needs spelling correc-
	      tion, and	`%r' expands to	the proposed  correction.   All	 other
	      prompt escapes are also allowed.

       STTY   If  this	parameter is set in a command's	environment, the shell
	      runs the stty command with the value of this parameter as	 argu-
	      ments  in	order to set up	the terminal before executing the com-
	      mand. The	modes apply only to the	command, and are reset when it
	      finishes	or  is suspended. If the command is suspended and con-
	      tinued later with	the fg or wait builtins	it will	see the	 modes
	      specified	 by  STTY,  as if it were not suspended.  This (inten-
	      tionally)	does not apply if the command is continued  via	 `kill
	      -CONT'.	STTY  is  ignored  if  the command is run in the back-
	      ground, 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 specifi-
	      cations; these will not be local to the command.

       TERM <S>
	      The type of terminal in use.  This is used when looking up term-
	      cap  sequences.  An assignment to	TERM causes zsh	to re-initial-
	      ize 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.

	      The  format  of process time reports with	the time keyword.  The
	      default is `%E real  %U user  %S system  %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	print-
	      ing time.	 This cause the	time to	be printed  in	`hh:mm:ss.ttt'
	      format  (hours  and  minutes  are	 only  printed if they are not

       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.	Other-
	      wise  a  new  alarm is scheduled to TMOUT	seconds	after the last

	      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

       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  or	all  of	 these components may be present in an
	      entry; if	a login/logout	event  matches	all  of	 them,	it  is

	      The  format  of  login/logout  reports if	the watch parameter is
	      set.  Default is `%n has %a %l from %m'.	Recognizes the follow-
	      ing 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.	Other-
		     wise they are treated as ordinary strings.

	      %S (%s)
		     Start (stop) standout mode.

	      %U (%u)
		     Start (stop) underline mode.

	      %B (%b)
		     Start (stop) boldface mode.

	      %@     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.

		     Specifies	a ternary expression.  The character following
		     the x is arbitrary; the same character is used  to	 sepa-
		     rate  the	text  for  the "true" result from that for the
		     "false" result.  Both the separator and the right	paren-
		     thesis  may be escaped with a backslash.  Ternary expres-
		     sions 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 zshmodules(1), that will be output to the	termi-
	      nal  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.

	      The directory to search for shell	startup	files  (.zshrc,	 etc),
	      if not $HOME.

zsh 4.0.6			August 14, 2002			   ZSHPARAM(1)


Want to link to this manual page? Use this URL:

home | help