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

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
ZSHBUILTINS(1)							ZSHBUILTINS(1)

NAME
       zshbuiltins - zsh built-in commands

SHELL BUILTIN COMMANDS
       - simple	command
	      See the section `Precommand Modifiers'.

       . file [	arg ...	]
	      Read  commands  from  file and execute them in the current shell
	      environment.

	      If file does not contain a slash,	or if PATH_DIRS	 is  set,  the
	      shell  looks  in	the  components	of $path to find the directory
	      containing file.	Files in the current directory	are  not  read
	      unless  `.'  appears  somewhere  in  $path.   If	a  file	 named
	      `file.zwc' is found, is newer than file,	and  is	 the  compiled
	      form  (created with the zcompile builtin)	of file, then commands
	      are read from that file instead of file.

	      If any arguments arg  are	 given,	 they  become  the  positional
	      parameters;  the old positional parameters are restored when the
	      file is done executing.  The exit	status is the exit  status  of
	      the last command executed.

       : [ arg ... ]
	      This  command  does nothing, although normal argument expansions
	      is performed which may have effects on shell parameters.	A zero
	      exit code	is returned.

       alias [ {+|-}gmrL ] [ name[=value] ... ]
	      For  each	 name with a corresponding value, define an alias with
	      that value.  A trailing space in value causes the	next  word  to
	      be  checked  for	alias  expansion.   If the -g flag is present,
	      define a global alias; global aliases are	expanded even if  they
	      do not occur in command position.

	      For  each	 name  with no value, print the	value of name, if any.
	      With no arguments, print all currently defined aliases.  If  the
	      -m  flag	is  given  the	arguments  are taken as	patterns (they
	      should be	quoted to preserve them	from being interpreted as glob
	      patterns),  and the aliases matching these patterns are printed.
	      When printing aliases and	the -g or -r flags are	present,  then
	      restrict	the  printing  to  global  or regular aliases, respec-
	      tively.  Using `+' instead of `-', or  ending  the  option  list
	      with a single `+', prevents the values of	the aliases from being
	      printed.

	      If the -L	flag is	present, then print each  alias	 in  a	manner
	      suitable	for  putting  in a startup script.  The	exit status is
	      nonzero if a name	(with no value)	is given for  which  no	 alias
	      has been defined.

       autoload	[ {+|-}UXmt ] [	-wkz ] [ name ... ]
	      Equivalent  to functions -u, with	the exception of -X/+X,	-w, -k
	      and -z.

	      The flag -X may be used only inside a shell  function,  and  may
	      not be followed by a name.  It causes the	calling	function to be
	      marked for autoloading and then immediately loaded and executed,
	      with  the	 current  array	of positional parameters as arguments.
	      This replaces the	previous definition of the  function.	If  no
	      function	definition is found, an	error is printed and the func-
	      tion remains undefined and marked	for autoloading.

	      The flag +X attempts to load each	name as	 an  autoloaded	 func-
	      tion,  but  does	not execute it.	 The exit status is zero (suc-
	      cess) if the function was	not previously defined and  a  defini-
	      tion for it was found.  This does	not replace any	existing defi-
	      nition of	the function.  The exit	status is nonzero (failure) if
	      the  function  was  already  defined  or	when no	definition was
	      found.  In the latter case the function  remains	undefined  and
	      marked for autoloading.

	      The  flag	 +X  may  be combined with either -k or	-z to make the
	      function be loaded using	ksh-style  or  zsh-style  autoloading,
	      respectively.  If	 neither  is given, the	current	setting	of the
	      KSH_AUTOLOAD options determines how the function is loaded. With
	      ksh-style	autoloading, the contents of the file will not be exe-
	      cuted immediately. Instead, the function	created	 will  contain
	      the  contents  of	 the  file  plus a call	to the function	itself
	      appended to it, thus given normal	ksh autoloading	 behaviour  on
	      the first	call to	the function.

	      With the -w flag,	the names are taken as names of	files compiled
	      with the zcompile	builtin, and all functions defined in them are
	      marked for autoloading.

       bg [ job	... ]
       job ... &
	      Put  each	specified job in the background, or the	current	job if
	      none is specified.

       bindkey
	      See the section `Zle Builtins' in	zshzle(1).

       break [ n ]
	      Exit from	an enclosing for, while, until,	select or repeat loop.
	      If n is specified, then break n levels instead of	just one.

       builtin name [ args ... ]
	      Executes the builtin name, with the given	args.

       bye    Same as exit.

       cap    See the section `The zsh/cap Module' in zshmodules(1).

       cd [ -sLP ] [ arg ]
       cd [ -sLP ] old new
       cd [ -sLP ] {+|-}n
	      Change  the  current  directory.	 In the	first form, change the
	      current directory	to arg,	or to the value	of $HOME if arg	is not
	      specified.   If  arg is `-', change to the value of $OLDPWD, the
	      previous directory.  Otherwise, if a directory named arg is  not
	      found  in	 the  current  directory and arg does not begin	with a
	      slash, search each component of the shell	parameter cdpath.   If
	      no  directory  is	found and the option CDABLE_VARS is set, and a
	      parameter	named arg exists whose	value  begins  with  a	slash,
	      treat  its  value	as the directory.  In that case, the parameter
	      is added to the named directory hash table.

	      The second form of cd substitutes	the string new for the	string
	      old in the name of the current directory,	and tries to change to
	      this new directory.

	      The third	form of	cd extracts an entry from the directory	stack,
	      and  changes  to	that  directory.  An argument of the form `+n'
	      identifies a stack entry by counting from	the left of  the  list
	      shown  by	 the dirs command, starting with zero.	An argument of
	      the form `-n' counts from	the right.  If the PUSHD_MINUS	option
	      is set, the meanings of `+' and `-' in this context are swapped.

	      If the -s	option is specified, cd	refuses	to change the  current
	      directory	 if  the  given	pathname contains symlinks.  If	the -P
	      option is	given or the CHASE_LINKS option	is set,	symbolic links
	      are  resolved  to	 their true values.  If	the -L option is given
	      symbolic links are followed  regardless  of  the	state  of  the
	      CHASE_LINKS option.

       chdir  Same as cd.

       clone  See the section `The zsh/clone Module' in	zshmodules(1).

       command simple command
	      See the section `Precommand Modifiers'.

       comparguments
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       compcall
	      See the section `The zsh/compctl Module' in zshmodules(1).

       compctl
	      See the section `The zsh/compctl Module' in zshmodules(1).

       compdescribe
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       compfiles
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       compgroups
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       compquote
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       comptags
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       comptry
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       compvalues
	      See the section `The zsh/computil	Module'	in zshmodules(1).

       continue	[ n ]
	      Resume  the  next	 iteration of the enclosing for, while,	until,
	      select or	repeat loop.  If n is  specified,  break  out  of  n-1
	      loops and	resume at the nth enclosing loop.

       declare
	      Same as typeset.

       dirs [ -v ] [ arg ... ]
	      With  no	arguments,  print the contents of the directory	stack.
	      If the -v	option is given, number	the directories	in  the	 stack
	      when  printing.	Directories  are  added	to this	stack with the
	      pushd command, and removed with the cd  or  popd	commands.   If
	      arguments	 are  specified,  load	them onto the directory	stack,
	      replacing	anything that was there, and push the  current	direc-
	      tory onto	the stack.

       disable [ -afmr ] name ...
	      Temporarily  disable the named hash table	elements.  The default
	      is to disable builtin commands.	This  allows  you  to  use  an
	      external	command	 with the same name as a builtin command.  The
	      -a option	causes disable to  act	on  aliases.   The  -f	option
	      causes disable to	act on shell functions.	 The -r	options	causes
	      disable to act on	reserved words.	 Without  arguments  all  dis-
	      abled  hash table	elements from the corresponding	hash table are
	      printed.	With the -m flag the arguments are taken  as  patterns
	      (which should be quoted to prevent them from undergoing filename
	      expansion), and all hash table elements from  the	 corresponding
	      hash  table  matching  these  patterns  are  disabled.  Disabled
	      objects can be enabled with the enable command.

       disown [	job ...	]
       job ... &|
       job ... &!
	      Remove the specified jobs	from the job table; the	shell will  no
	      longer  report their status, and will not	complain if you	try to
	      exit an interactive shell	with them running or stopped.	If  no
	      job is specified,	disown the current job.

       echo [ -neE ] [ arg ... ]
	      Write  each  arg on the standard output, with a space separating
	      each one.	 If the	-n flag	is not present,	print a	newline	at the
	      end.  echo recognizes the	following escape sequences:

	      \a     bell character
	      \b     backspace
	      \c     suppress final newline
	      \e     escape
	      \f     form feed
	      \n     linefeed (newline)
	      \r     carriage return
	      \t     horizontal	tab
	      \v     vertical tab
	      \\     backslash
	      \0NNN  character code in octal
	      \xNN   character code in hexadecimal

	      The  -E  flag,  or  the  BSD_ECHO	option,	can be used to disable
	      these escape sequences.  In the latter case, -e flag can be used
	      to enable	them.

       echotc See the section `The zsh/termcap Module' in zshmodules(1).

       echoti See the section `The zsh/terminfo	Module'	in zshmodules(1).

       emulate [ -LR ] {zsh|sh|ksh|csh}
	      Set  up  zsh  options  to	emulate	the specified shell as much as
	      possible.	 csh will never	be fully emulated.  If the argument is
	      not  one	of  the	 shells	 listed	 above,	 zsh will be used as a
	      default; more precisely, the tests performed on the argument are
	      the  same	 as  those  used to determine the emulation at startup
	      based on the shell name, see the section `Compatibility' in zsh-
	      misc(1)  .   If the -R option is given, all options are reset to
	      their default value corresponding	 to  the  specified  emulation
	      mode,  except  for  certain  options  describing the interactive
	      environment; otherwise,  only  those  options  likely  to	 cause
	      portability  problems  in	scripts	and functions are altered.  If
	      the  -L  option  is  given,  the	 options   LOCAL_OPTIONS   and
	      LOCAL_TRAPS will be set as well, causing the effects of the emu-
	      late command and any setopt and trap commands to be local	to the
	      immediately  surrounding	shell function,	if any;	normally these
	      options are turned off in	all emulation modes except ksh.

       enable [	-afmr ]	name ...
	      Enable the named hash table elements, presumably	disabled  ear-
	      lier  with  disable.  The	default	is to enable builtin commands.
	      The -a option causes enable to act on aliases.   The  -f	option
	      causes  enable  to act on	shell functions.  The -r option	causes
	      enable to	act on reserved	words.	Without	arguments all  enabled
	      hash  table  elements  from  the	corresponding  hash  table are
	      printed.	With the -m flag the arguments are taken  as  patterns
	      (should  be  quoted) and all hash	table elements from the	corre-
	      sponding	hash  table  matching  these  patterns	are   enabled.
	      Enabled  objects	can  be	disabled with the disable builtin com-
	      mand.

       eval [ arg ... ]
	      Read the arguments as input to the shell and execute the result-
	      ing command in the current shell process.

       exec simple command
	      See the section `Precommand Modifiers'.

       exit [ n	]
	      Exit  the	 shell	with  the exit code specified by n; if none is
	      specified, use the exit code from	the last command executed.  An
	      EOF  condition  will  also  cause	 the shell to exit, unless the
	      IGNORE_EOF option	is set.

       export [	name[=value] ... ]
	      The specified names are marked for automatic export to the envi-
	      ronment  of subsequently executed	commands.  Equivalent to type-
	      set -gx.	If a parameter specified does not already exist, it is
	      created in the global scope.

       false [ arg ... ]
	      Do nothing and return an exit code of 1.

       fc [ -e ename ] [ -nlrdDfEim ] [	old=new	... ] [	first [	last ] ]
       fc -ARWI	[ filename ]
	      Select  a	 range of commands from	first to last from the history
	      list.  The arguments first and last may be specified as a	number
	      or  as  a	string.	 A negative number is used as an offset	to the
	      current history event  number.   A  string  specifies  the  most
	      recent event beginning with the given string.  All substitutions
	      old=new, if any, are then	performed on the commands.

	      If the -l	flag is	given, the resulting commands  are  listed  on
	      standard	output.	  If the -m flag is also given the first argu-
	      ment is taken as a pattern (should be quoted) and	only the  his-
	      tory  events matching this pattern will be shown.	 Otherwise the
	      editor program ename is invoked on a file	containing these  his-
	      tory  events.  If	ename is not given, the	value of the parameter
	      FCEDIT is	used.  If ename	is `-',	no editor  is  invoked.	  When
	      editing is complete, the edited command is executed.

	      If first is not specified, it will be set	to -1 (the most	recent
	      event), or to -16	if the -l flag is given.  If last is not spec-
	      ified,  it  will	be  set	 to  first, or to -1 if	the -l flag is
	      given.

	      The flag -r reverses the order of	the commands and the  flag  -n
	      suppresses  command numbers when listing.	 Also when listing, -d
	      prints timestamps	for each command, and -f prints	full time-date
	      stamps.	Adding	the  -E	flag causes the	dates to be printed as
	      `dd.mm.yyyy', instead of the default `mm/dd/yyyy'.   Adding  the
	      -i  flag	causes the dates to be printed in ISO8601 `yyyy-mm-dd'
	      format.  With the	-D flag, fc prints elapsed times.

	      `fc -R' reads the	history	from the given file,  `fc  -W'	writes
	      the  history out to the given file, and `fc -A' appends the his-
	      tory out to the given file.  If no filename  is  specified,  the
	      $HISTFILE	 is  assumed.	If  the	-I option is added to -R, only
	      those events that	are not	already	contained within the  internal
	      history  list are	added.	If the -I option is added to -A	or -W,
	      only  those  events  that	 are  new   since   last   incremental
	      append/write  to	the history file are appended/written.	In any
	      case, the	created	file will have no more than $SAVEHIST entries.

       fg [ job	... ]
       job ...
	      Bring  each  specified job in turn to the	foreground.  If	no job
	      is specified, resume the current job.

       float [ {+|-}EFghlrtux ]	[ name[=value] ... ]
	      Equivalent to typeset -E,	 except	 that  options	irrelevant  to
	      floating point numbers are not permitted.

       functions [ {+|-}UXmtu ]	[ name ... ]
	      Equivalent to typeset -f.

       getcap See the section `The zsh/cap Module' in zshmodules(1).

       getln [ -AclneE ] name ...
	      Read the top value from the buffer stack and put it in the shell
	      parameter	name.  Equivalent to read -zr.

       getopts optstring name [	arg ...	]
	      Checks the args for legal	options.  If the args are omitted, use
	      the  positional parameters.  A valid option argument begins with
	      a	`+' or a `-'.  An argument not beginning with a	`+' or a  `-',
	      or  the argument `--', ends the options.	optstring contains the
	      letters that getopts recognizes.	If a letter is followed	 by  a
	      `:',  that  option is expected to	have an	argument.  The options
	      can be separated from the	argument by blanks.

	      Each time	it is invoked, getopts places  the  option  letter  it
	      finds in the shell parameter name, prepended with	a `+' when arg
	      begins with a `+'.  The index of	the  next  arg	is  stored  in
	      OPTIND.  The option argument, if any, is stored in OPTARG.

	      The  first  option  to  be examined may be changed by explicitly
	      assigning	to OPTIND.  OPTIND has an initial value	of 1,  and  is
	      normally	reset to 1 upon	exit from a shell function.  OPTARG is
	      not reset	and retains its	value from the	most  recent  call  to
	      getopts.	 If either of OPTIND or	OPTARG is explicitly unset, it
	      remains unset, and the index or option argument is  not  stored.
	      The option itself	is still stored	in name	in this	case.

	      A	leading	`:' in optstring causes	getopts	to store the letter of
	      any invalid option in OPTARG, and	to set	name  to  `?'  for  an
	      unknown  option  and  to	`:' when a required option is missing.
	      Otherwise, getopts sets name to `?' and prints an	error  message
	      when  an	option	is  invalid.   The exit	status is nonzero when
	      there are	no more	options.

       hash [ -Ldfmrv ]	[ name[=value] ] ...
	      hash can be used to directly modify the contents of the  command
	      hash  table,  and	 the named directory hash table.  Normally one
	      would modify these tables	by modifying one's PATH	(for the  com-
	      mand  hash  table)  or  by creating appropriate shell parameters
	      (for the named directory hash table).  The choice	of hash	 table
	      to  work	on  is determined by the -d option; without the	option
	      the command hash table is	used, and with the  option  the	 named
	      directory	hash table is used.

	      Given  no	 arguments,  and  neither  the	-r  or -f options, the
	      selected hash table will be listed in full.

	      The -r option causes the selected	hash table to be emptied.   It
	      will  be	subsequently  rebuilt  in  the normal fashion.	The -f
	      option causes the	selected hash table to be fully	rebuilt	 imme-
	      diately.	 For  the command hash table this hashes all the abso-
	      lute directories in the PATH, and	for the	named  directory  hash
	      table  this adds all users' home directories.  These two options
	      cannot be	used with any arguments.

	      The -m option causes the	arguments  to  be  taken  as  patterns
	      (which  should  be  quoted)  and	the elements of	the hash table
	      matching those patterns are printed.  This is the	 only  way  to
	      display a	limited	selection of hash table	elements.

	      For  each	 name  with  a	corresponding value, put `name'	in the
	      selected hash table, associating it with the  pathname  `value'.
	      In  the  command	hash table, this means that whenever `name' is
	      used as a	command	argument, the shell will try  to  execute  the
	      file  given by `value'.  In the named directory hash table, this
	      means that `value' may be	referred to as `~name'.

	      For each name with no corresponding value, attempt to  add  name
	      to the hash table, checking what the appropriate value is	in the
	      normal manner for	that hash  table.   If	an  appropriate	 value
	      can't be found, then the hash table will be unchanged.

	      The -v option causes hash	table entries to be listed as they are
	      added by explicit	specification.	If has no effect if used  with
	      -f.

	      If the -L	flag is	present, then each hash	table entry is printed
	      in the form of a call to hash.

       history
	      Same as fc -l.

       integer [ {+|-}ghilrtux ] [ name[=value]	... ]
	      Equivalent to typeset -i,	 except	 that  options	irrelevant  to
	      integers are not permitted.

       jobs [ -dlprs ] [ job ... ]
       jobs -Z string
	      Lists  information  about	 each given job, or all	jobs if	job is
	      omitted.	The -l flag lists process IDs, and the -p  flag	 lists
	      process  groups.	 If the	-r flag	is specified only running jobs
	      will be listed and if the	-s flag	is given only stopped jobs are
	      shown.   If  the	-d flag	is given, the directory	from which the
	      job was started (which may not be	the current directory  of  the
	      job) will	also be	shown.

	      The  -Z  option  replaces	 the  shell's argument and environment
	      space with the given string,  truncated  if  necessary  to  fit.
	      This will	normally be visible in ps (ps(1)) listings.  This fea-
	      ture is typically	used by	daemons, to indicate their state.

       kill [ -s signal_name ] job ...
       kill [ -sig ] job ...
       kill -l [ sig ... ]
	      Sends either SIGTERM or the specified signal to the  given  jobs
	      or  processes.  Signals are given	by number or by	names, without
	      the `SIG'	prefix.	 If the	signal being sent  is  not  `KILL'  or
	      `CONT',  then  the  job  will  be	 sent a	`CONT' signal if it is
	      stopped.	The argument job can be	the process ID of a job	not in
	      the  job list.  In the third form, kill -l, if sig is not	speci-
	      fied the signal names are	listed.	 Otherwise, for	each sig  that
	      is  a name, the corresponding signal number is listed.  For each
	      sig that is a signal number or a number  representing  the  exit
	      status  of a process which was terminated	or stopped by a	signal
	      the name of the signal is	printed.

       let arg ...
	      Evaluate each arg	as an arithmetic expression.  See the  section
	      `Arithmetic  Evaluation' for a description of arithmetic expres-
	      sions.  The exit status is 0 if the value	of the last expression
	      is nonzero, and 1	otherwise.

       limit [ -hs ] [ resource	[ limit	] ] ...
	      Set  or  display	resource limits.  Unless the -s	flag is	given,
	      the limit	applies	only the children of  the  shell.   If	-s  is
	      given  without  other arguments, the resource limits of the cur-
	      rent shell is set	to the previously set resource limits  of  the
	      children.

	      If  limit	 is  not  specified, print the current limit placed on
	      resource,	otherwise set the limit	to the	specified  value.   If
	      the  -h  flag  is	given, use hard	limits instead of soft limits.
	      If no resource is	given, print all limits.

	      resource can be one of:

	      addressspace
		     Maximum amount of address space used.
	      aiomemorylocked
		     Maximum amount of memory locked in	 RAM  for  AIO	opera-
		     tions.
	      aiooperations
		     Maximum number of AIO operations.
	      cachedthreads
		     Maximum number of cached threads.
	      coredumpsize
		     Maximum size of a core dump.
	      cputime
		     Maximum CPU seconds per process.
	      datasize
		     Maximum data size (including stack) for each process.
	      descriptors
		     Maximum value for a file descriptor.
	      filesize
		     Largest single file allowed.
	      maxproc
		     Maximum number of processes.
	      maxpthreads
		     Maximum number of threads per process.
	      memorylocked
		     Maximum amount of memory locked in	RAM.
	      memoryuse
		     Maximum resident set size.
	      resident
		     Maximum resident set size.
	      sockbufsize
		     Maximum size of all socket	buffers.
	      stacksize
		     Maximum stack size	for each process.
	      vmemorysize
		     Maximum amount of virtual memory.

	      Which of these resource limits are available depends on the sys-
	      tem.  resource can be abbreviated	to any unambiguous prefix.

	      limit is a number, with an optional scaling factor, as follows:

	      nh     hours
	      nk     kilobytes (default)
	      nm     megabytes or minutes
	      [mm:]ss
		     minutes and seconds

       local [ {+|-}AEFLRUZahilrtux [n]] [ name[=value]	] ...
	      Same as typeset, except that the options -g, and -f are not per-
	      mitted.	In  this  case the -x option does not force the	use of
	      -g, i.e. exported	variables will be local	to functions.

       log    List all users currently logged in who are affected by the  cur-
	      rent setting of the watch	parameter.

       logout [	n ]
	      Same as exit, except that	it only	works in a login shell.

       noglob simple command
	      See the section `Precommand Modifiers'.

       popd [ {+|-}n ]
	      Remove  an  entry	 from the directory stack, and perform a cd to
	      the new top directory.  With no argument,	the current top	 entry
	      is  removed.   An	 argument  of the form `+n' identifies a stack
	      entry by counting	from the left of the list shown	 by  the  dirs
	      command,	starting with zero.  An	argument of the	form -n	counts
	      from the right.  If the PUSHD_MINUS option is set, the  meanings
	      of `+' and `-' in	this context are swapped.

       print [ -bnrslzpNDPoOicm	] [ -un	] [ -R [ -en ]]	[ arg ... ]
	      With no flags or with the	flag `-', the arguments	are printed on
	      the standard output as described by  echo,  with	the  following
	      differences: the escape sequence `\M-x' metafies the character x
	      (sets the	highest	bit),  `\C-x'  produces	 a  control  character
	      (`\C-@' and `\C-?' give the characters NUL and delete), and `\E'
	      is a synonym for `\e'.  Finally, if not in an  escape  sequence,
	      `\' escapes the following	character and is not printed.

	      -r     Ignore the	escape conventions of echo.

	      -R     Emulate  the  BSD	echo  command,	which does not process
		     escape sequences unless the -e flag  is  given.   The  -n
		     flag suppresses the trailing newline.  Only the -e	and -n
		     flags are recognized after	-R; all	 other	arguments  and
		     options are printed.

	      -b     Recognize	all the	escape sequences defined for the bind-
		     key command, see zshzle(1).

	      -m     Take the first argument as	a pattern (should be  quoted),
		     and remove	it from	the argument list together with	subse-
		     quent arguments that do not match this pattern.

	      -s     Place the results in the history list instead of  on  the
		     standard output.

	      -n     Do	not add	a newline to the output.

	      -l     Print the arguments separated by newlines instead of spa-
		     ces.

	      -N     Print the arguments separated and terminated by nulls.

	      -o     Print the arguments sorted	in ascending order.

	      -O     Print the arguments sorted	in descending order.

	      -i     If	given together with -o or  -O,	sorting	 is  performed
		     case-independently.

	      -c     Print the arguments in columns.

	      -un    Print the arguments to file descriptor n.

	      -p     Print the arguments to the	input of the coprocess.

	      -z     Push  the	arguments onto the editing buffer stack, sepa-
		     rated by spaces.

	      -D     Treat the arguments as directory  names,  replacing  pre-
		     fixes with	~ expressions, as appropriate.

	      -P     Perform prompt expansion (see zshmisc(1)).

       pushd [ arg ]
       pushd old new
       pushd {+|-}n
	      Change the current directory, and	push the old current directory
	      onto the directory stack.	 In the	first form, change the current
	      directory	to arg.	 If arg	is not specified, change to the	second
	      directory	on the stack (that is, exchange	the top	two  entries),
	      or  change  to  $HOME  if	 the PUSHD_TO_HOME option is set or if
	      there is only one	entry on the stack.  Otherwise,	arg is	inter-
	      preted  as it would be by	cd.  The meaning of old	and new	in the
	      second form is also the same as for cd.

	      The third	form of	pushd changes directory	by rotating the	direc-
	      tory  list.   An	argument  of  the form `+n' identifies a stack
	      entry by counting	from the left of the list shown	 by  the  dirs
	      command,	starting  with	zero.	An  argument  of the form `-n'
	      counts from the right.  If the PUSHD_MINUS option	 is  set,  the
	      meanings of `+' and `-' in this context are swapped.

	      If  the option PUSHD_SILENT is not set, the directory stack will
	      be printed after a pushd is performed.

       pushln [	arg ...	]
	      Equivalent to print -nz.

       pwd [ -rLP ]
	      Print the	absolute pathname of the  current  working  directory.
	      If the -r	or the -P flag is specified, or	the CHASE_LINKS	option
	      is set and the -L	flag is	not given, the printed path  will  not
	      contain symbolic links.

       r      Same as fc -e -.

       read [ -rzpqAclneEt ] [ -k [ num	] ]
	[ -un ]	[ name[?prompt]	] [ name ...  ]
	      Read  one	 line and break	it into	fields using the characters in
	      $IFS as separators, except as noted below.  The first  field  is
	      assigned to the first name, the second field to the second name,
	      etc., with leftover fields assigned to the last name.   If  name
	      is  omitted then REPLY is	used for scalars and reply for arrays.

	      -r     Raw mode: a `\' at	the end	of a  line  does  not  signify
		     line continuation and backslashes in the line don't quote
		     the following character and are not removed.

	      -q     Read only one character from the terminal and set name to
		     `y'  if  this  character was `y' or `Y' and to `n'	other-
		     wise.  With this flag set the return value	is  zero  only
		     if	 the  character	was `y'	or `Y'.	 Note that this	always
		     reads from	the terminal, even if used with	the -p	or  -u
		     or	 -z  flags  or with redirected input.  This option may
		     also be used within zle widgets.

	      -k [ num ]
		     Read only one (or num) characters.	 All are  assigned  to
		     the  first	 name,	without	 word splitting.  This flag is
		     ignored when -q is	present.  Input	is read	from the  ter-
		     minal unless one of -u or -p is present.  This option may
		     also be used within zle widgets.

		     Note that num must	be in the argument word	 that  follows
		     -k, not in	the same word.	See -u.

	      -z     Read one entry from the editor buffer stack and assign it
		     to	the first  name,  without  word	 splitting.   Text  is
		     pushed  onto  the stack with `print -z' or	with push-line
		     from the line  editor  (see  zshzle(1)).	This  flag  is
		     ignored when the -k or -q flags are present.

	      -e
	      -E     The  input	 read is printed (echoed) to the standard out-
		     put.  If the -e flag is used, no input is assigned	to the
		     parameters.

	      -A     The  first	 name is taken as the name of an array and all
		     words are assigned	to it.

	      -c
	      -l     These flags are allowed only if called inside a  function
		     used  for	completion (specified with the -K flag to com-
		     pctl).  If	the -c flag is given, the words	of the current
		     command are read. If the -l flag is given,	the whole line
		     is	assigned as a scalar.  If both flags are  present,  -l
		     is	used and -c is ignored.

	      -n     Together with -c, the number of the word the cursor is on
		     is	read.  With -l,	the index of the character the	cursor
		     is	on is read.  Note that the command name	is word	number
		     1,	not word 0, and	that when the cursor is	at the end  of
		     the  line,	 its character index is	the length of the line
		     plus one.

	      -un    Input is read from	file descriptor	n, where n is a	single
		     digit  and	 must  not  be separated from -u by any	white-
		     space.

	      -p     Input is read from	the coprocess.

	      -t     Test if input is available	before attempting to read;  if
		     none  is,	return	status 1 and do	not set	any variables.
		     This is not available when	reading	from the editor	buffer
		     with  -z,	when  called from within completion with -c or
		     -l, with -q which clears the input	queue before  reading,
		     or	 within	 zle  where other mechanisms should be used to
		     test for input.

		     Note that read does not attempt to	alter the  input  pro-
		     cessing  mode.   The  default mode	is canonical input, in
		     which an entire line is read at a time, so	usually	 `read
		     -t'  will not read	anything until an entire line has been
		     typed.  However, when reading from	the terminal  with  -k
		     this  is automatically handled; note that only availabil-
		     ity of the	first character	is tested, so that e.g.	 `read
		     -t	-k 2' can still	block on the second character.	If the
		     first argument contains a `?', the	remainder of this word
		     is	 used  as a prompt on standard error when the shell is
		     interactive.

	      The value	(exit status) of read is  1  when  an  end-of-file  is
	      encountered,  or when -c or -l is	present	and the	command	is not
	      called from a compctl function, or as described for -q.	Other-
	      wise the value is	0.

	      The  behavior  of	some combinations of the -k, -p, -q, -u	and -z
	      flags is undefined.  Presently -q	cancels	 all  the  others,  -p
	      cancels  -u, -k cancels -z, and otherwise	-z cancels both	-p and
	      -u.

	      The -c or	-l flags cancel	any and	all of -kpquz.

       readonly
	      Same as typeset -r.

       rehash Same as hash -r.

       return [	n ]
	      Causes a shell function or . script to return  to	 the  invoking
	      script  with the return status specified by n.  If n is omitted,
	      the return status	is that	of the last command executed.

	      If return	was executed from a trap in a  TRAPNAL	function,  the
	      effect  is  different for	zero and non-zero return status.  With
	      zero status (or after an implicit	 return	 at  the  end  of  the
	      trap),  the shell	will return to whatever	it was previously pro-
	      cessing; with a non-zero status, the shell will behave as	inter-
	      rupted  except  that  the	return status of the trap is retained.
	      Note that	the numeric value of the signal	which caused the  trap
	      is  passed  as  the  first  argument,  so	 the statement `return
	      $((128+$1))' will	return the same	status as if  the  signal  had
	      not been trapped.

       sched  See the section `The zsh/sched Module' in	zshmodules(1).

       set [ {+|-}options | {+|-}o option_name ] ... [ {+|-}A [	name ] ] [ arg
       ... ]
	      Set  the options for the shell and/or set	the positional parame-
	      ters, or declare and set an array.  If the -s option  is	given,
	      it  causes the specified arguments to be sorted before assigning
	      them to the positional parameters	(or to the array name if -A is
	      used).   With  +s	 sort  arguments in descending order.  For the
	      meaning of the other flags, see  zshoptions(1).	Flags  may  be
	      specified	by name	using the -o option.

	      If  the -A flag is specified, name is set	to an array containing
	      the given	args. if +A is used and	name is	an  array,  the	 given
	      arguments	will replace the initial elements of that array; if no
	      name is specified, all arrays are	printed.  Otherwise the	 posi-
	      tional  parameters are set.  If no arguments are given, then the
	      names and	values of all parameters are printed on	 the  standard
	      output.	If  the	only argument is `+', the names	of all parame-
	      ters are printed.

       setcap See the section `The zsh/cap Module' in zshmodules(1).

       setopt [	{+|-}options | {+|-}o option_name ] [ name ... ]
	      Set the options for the shell.   All  options  specified	either
	      with  flags  or  by name are set.	 If no arguments are supplied,
	      the names	of all options currently set are printed.  If  the  -m
	      flag  is given the arguments are taken as	patterns (which	should
	      be quoted	to protect them	 from  filename	 expansion),  and  all
	      options with names matching these	patterns are set.

       shift [ n ] [ name ... ]
	      The  positional  parameters  ${n+1}  ...	are renamed to $1 ...,
	      where n is an arithmetic expression that defaults	to 1.  If  any
	      names  are  given	 then  the arrays with these names are shifted
	      instead of the positional	parameters.

       source file [ arg ... ]
	      Same as ., except	that the current directory is always  searched
	      and is always searched first, before directories in $path.

       stat   See the section `The zsh/stat Module' in zshmodules(1).

       suspend [ -f ]
	      Suspend  the execution of	the shell (send	it a SIGTSTP) until it
	      receives a SIGCONT.  Unless the -f option	is  given,  this  will
	      refuse to	suspend	a login	shell.

       test [ arg ... ]
       [ [ arg ... ] ]
	      Like  the	 system	version	of test.  Added	for compatibility; use
	      conditional expressions instead (see  the	 section  `Conditional
	      Expressions').

       times  Print  the  accumulated  user and	system times for the shell and
	      for processes run	from the shell.

       trap [ arg [ sig	... ] ]
	      arg is a series of commands (usually quoted to protect  it  from
	      immediate	 evaluation by the shell) to be	read and executed when
	      the shell	receives sig.  Each sig	can be given as	a number or as
	      the  name	 of  a	signal.	 If arg	is `-',	then all traps sig are
	      reset to their default values.  If arg is	the empty string, then
	      this  signal  is	ignored	 by  the  shell	and by the commands it
	      invokes.

	      If sig is	ZERR then arg will be executed after each command with
	      a	 nonzero  exit	status.	 If sig	is DEBUG then arg will be exe-
	      cuted after each command.	 If sig	is 0  or  EXIT	and  the  trap
	      statement	 is  executed  inside the body of a function, then the
	      command arg is executed after the	function completes.  If	sig is
	      0	or EXIT	and the	trap statement is not executed inside the body
	      of a function, then the command arg is executed when  the	 shell
	      terminates.

	      The  trap	 command  with	no arguments prints a list of commands
	      associated with each signal.

	      Note that	traps defined with the trap builtin are	slightly  dif-
	      ferent from those	defined	as `TRAPNAL () { ... }', as the	latter
	      have their own function environment (line	numbers,  local	 vari-
	      ables, etc.) while the former use	the environment	of the command
	      in which they were called.  For example,

		     trap 'print $LINENO' DEBUG

	      will print the line number of a command executed	after  it  has
	      run, while

		     TRAPDEBUG() { print $LINENO; }

	      will always print	the number zero.

       true [ arg ... ]
	      Do nothing and return an exit code of 0.

       ttyctl -fu
	      The  -f  option  freezes the tty,	and -u unfreezes it.  When the
	      tty is frozen, no	changes	made to	the tty	settings  by  external
	      programs will be honored by the shell, except for	changes	in the
	      size of the screen; the shell will simply	reset the settings  to
	      their  previous  values as soon as each command exits or is sus-
	      pended.  Thus, stty and similar programs have no effect when the
	      tty  is frozen.  Without options it reports whether the terminal
	      is frozen	or not.

       type [ -wfpams ]	name ...
	      Equivalent to whence -v.

       typeset [ {+|-}AEFLRUZafghilrtuxm [n]] [	name[=value] ... ]
       typeset -T [ {+|-}LRUZrux ] SCALAR[=value] array
	      Set or display attributes	and values for shell parameters.

	      A	parameter is created for each name that	does not already refer
	      to  one.	When inside a function,	a new parameter	is created for
	      every name (even those that already exist), and is  unset	 again
	      when  the	 function  completes.	See `Local Parameters' in zsh-
	      param(1).	 The same rules	apply  to  special  shell  parameters,
	      which retain their special attributes when made local.

	      For  each	 name=value  assignment,  the parameter	name is	set to
	      value.  Note that	arrays currently cannot	be assigned in typeset
	      expressions, only	scalars	and integers.

	      For  each	remaining name that refers to a	parameter that is set,
	      the name and value of the	parameter are printed in the  form  of
	      an assignment.  Nothing is printed for newly-created parameters,
	      or when any attribute flags listed below are  given  along  with
	      the  name.  Using	`+' instead of minus to	introduce an attribute
	      turns it off.

	      If the -T	option is given, exactly two (or zero) name  arguments
	      must  be present.	 They represent	a scalar and an	array (in that
	      order) that will be tied together	in the	manner	of  $PATH  and
	      $path.   In other	words, an array	present	in the latter variable
	      appears as a scalar with the elements of	the  array  joined  by
	      colons  in  the  former.	 Only  the  scalar may have an initial
	      value.  Both the scalar and the array may	otherwise  be  manipu-
	      lated  as	normal.	 If one	is unset, the other will automatically
	      be unset too.  There is no way of	untying	the variables  without
	      unsetting	 them,	or  converting	the  type  of one of them with
	      another typeset command; +T does not work, assigning an array to
	      SCALAR  is  an error, and	assigning a scalar to array sets it to
	      be a single-element array.  Note that both `typeset -xT ...' and
	      `export  -T  ...'	 work,	but only the scalar will be marked for
	      export.

	      The -g (global) flag is treated specially:  it  means  that  any
	      resulting	parameter will not be restricted to local scope.  Note
	      that this	does not necessarily mean that the parameter  will  be
	      global,  as  the flag will apply to any existing parameter (even
	      if unset)	from an	enclosing function.  This flag does not	affect
	      the  parameter after creation, hence it has no effect when list-
	      ing existing parameters, nor does	the flag +g  have  any	effect
	      except in	combination with -m (see below).

	      If  no  name  is present,	the names and values of	all parameters
	      are printed.  In this case the attribute flags restrict the dis-
	      play   to	  only	 those	parameters  that  have	the  specified
	      attributes, and using `+'	rather than `-'	to introduce the  flag
	      suppresses printing of the values	of parameters when there is no
	      parameter	name.  Also, if	the last option	is the word `+',  then
	      names are	printed	but values are not.

	      If the -m	flag is	given the name arguments are taken as patterns
	      (which should be quoted).	 With no attribute flags, all  parame-
	      ters  (or	 functions  with  the -f flag) with matching names are
	      printed.	Note that -m is	ignored	if no patterns are given.   If
	      the  +g  flag is combined	with -m, a new local parameter is cre-
	      ated for every matching parameter	that  is  not  already	local.
	      Otherwise	 -m  applies  all  other  flags	 or assignments	to the
	      existing parameters.  Except  when  assignments  are  made  with
	      name=value,  using  +m  forces  the  matching  parameters	 to be
	      printed, even inside a function.

	      If no attribute flags are	given and either no -m flag is present
	      or the +m	form was used, each parameter name printed is preceded
	      by a list	of the attributes of that parameter  (array,  associa-
	      tion,   exported,	 integer,  readonly).	If  +m	is  used  with
	      attribute	flags, and all those flags are introduced with +,  the
	      matching parameter names are printed but their values are	not.

	      The following attribute flags may	be specified:

	      -A     The  names	 refer	to  associative	 array parameters; see
		     `Array Parameters'	in zshparam(1).

	      -L     Left justify and remove leading blanks from value.	 If  n
		     is	 nonzero, it defines the width of the field; otherwise
		     it	is determined by the width of the value	of  the	 first
		     assignment.  When the parameter is	expanded, it is	filled
		     on	the right with blanks or truncated if necessary	to fit
		     the  field.   Leading zeros are removed if	the -Z flag is
		     also set.

	      -R     Right justify and fill with  leading  blanks.   If	 n  is
		     nonzero  if  defines the width of the field; otherwise it
		     is	determined by the width	of  the	 value	of  the	 first
		     assignment.  When the parameter is	expanded, the field is
		     left filled with blanks or	truncated from the end.

	      -U     For arrays	(but not for associative  arrays),  keep  only
		     the  first	occurrence of each duplicated value.  This may
		     also be set for colon-separated special  parameters  like
		     PATH  or FIGNORE, etc.  This flag has a different meaning
		     when used with -f;	see below.

	      -Z     Right justify and fill with leading zeros	if  the	 first
		     non-blank	character  is  a digit and the -L flag has not
		     been set.	If n is	nonzero	it defines the	width  of  the
		     field;  otherwise	it  is	determined by the width	of the
		     value of the first	assignment.

	      -a     The names refer to	array parameters.  An array  parameter
		     may be created this way, but it may not be	assigned to in
		     the typeset statement.  When displaying, both normal  and
		     associative arrays	are shown.

	      -f     The  names	refer to functions rather than parameters.  No
		     assignments can be	made, and the only other  valid	 flags
		     are  -t, -u and -U.  The flag -t turns on execution trac-
		     ing for this function.  The -u and	 -U  flags  cause  the
		     function  to  be  marked  for autoloading;	-U also	causes
		     alias expansion to	be suppressed  when  the  function  is
		     loaded.  The fpath	parameter will be searched to find the
		     function definition when the  function  is	 first	refer-
		     enced; see	the section `Functions'.

	      -h     Hide:  only  useful  for special parameters (those	marked
		     `<S>' in the table	in zshparams(1)), and for local	param-
		     eters  with  the same name	as a special parameter,	though
		     harmless for  others.   A	special	 parameter  with  this
		     attribute	will  not  retain its special effect when made
		     local.  Thus after	`typeset -h PATH', a function contain-
		     ing  `typeset PATH' will create an	ordinary local parame-
		     ter without the usual behaviour of	PATH.	Alternatively,
		     the  local	 parameter may itself be given this attribute;
		     hence inside a function  `typeset	-h  PATH'  creates  an
		     ordinary  local  parameter	and the	special	PATH parameter
		     is	not altered in any way.	 It is also possible to	create
		     a	local  parameter using `typeset	+h special', where the
		     local copy	of special will	retain its special  properties
		     regardless	 of  having  the -h attribute.	Global special
		     parameters	loaded from shell modules (currently those  in
		     zsh/mapfile  and  zsh/parameter)  are automatically given
		     the -h attribute to avoid name clashes.

	      -H     Hide value: specifies that	typeset	will not  display  the
		     value  of the parameter when listing parameters; the dis-
		     play for such parameters is always	as if the `+' flag had
		     been  given.   Use	 of the	parameter is in	other respects
		     normal, and the option does not apply if the parameter is
		     specified	by  name,  or  by  pattern with	the -m option.
		     This  is  on  by  default	for  the  parameters  in   the
		     zsh/parameter  and	 zsh/mapfile  modules.	Note, however,
		     that unlike the -h	flag this is also useful for  non-spe-
		     cial parameters.

	      -i     Use  an internal integer representation.  If n is nonzero
		     it	defines	the output arithmetic base,  otherwise	it  is
		     determined	by the first assignment.

	      -E     Use an internal double-precision floating point represen-
		     tation.  On output	the variable will be converted to sci-
		     entific  notation.	 If n is nonzero it defines the	number
		     of	significant figures to display;	the default is ten.

	      -F     Use an internal double-precision floating point represen-
		     tation.   On  output  the	variable  will be converted to
		     fixed-point decimal notation.  If n is nonzero it defines
		     the  number of digits to display after the	decimal	point;
		     the default is ten.

	      -l     Convert the result	to lower case whenever	the  parameter
		     is	expanded.  The value is	not converted when assigned.

	      -r     The given names are marked	readonly.

	      -t     Tags  the named parameters.  Tags have no special meaning
		     to	the shell.  This flag has  a  different	 meaning  when
		     used with -f; see above.

	      -u     Convert  the  result to upper case	whenever the parameter
		     is	expanded.  The value is	not converted  when  assigned.
		     This  flag	has a different	meaning	when used with -f; see
		     above.

	      -x     Mark for automatic	export to the  environment  of	subse-
		     quently  executed	commands.  If the option GLOBAL_EXPORT
		     is	set, this implies the option -g,  unless  +g  is  also
		     explicitly	 given;	 in  other  words the parameter	is not
		     made local	to the enclosing function.  This is  for  com-
		     patibility	with previous versions of zsh.

       ulimit [	-SHacdflmnpstv [ limit ] ... ]
	      Set  or  display	resource limits	of the shell and the processes
	      started by the shell.  The value of limit	can be a number	in the
	      unit specified below or the value	`unlimited'.  By default, only
	      soft limits are manipulated. If the -H flag is  given  use  hard
	      limits instead of	soft limits.  If the -S	flag is	given together
	      with the -H flag set both	hard and soft limits.  If  no  options
	      are  used,  the  file  size  limit (-f) is assumed.  If limit is
	      omitted  the  current  value  of	the  specified	resources  are
	      printed.	 When  more  than  one resource	values are printed the
	      limit name and unit is printed before each value.

	      -a     Lists all of the current resource limits.
	      -c     512-byte blocks on	the size of core dumps.
	      -d     K-bytes on	the size of the	data segment.
	      -f     512-byte blocks on	the size of files written.
	      -l     K-bytes on	the size of locked-in memory.
	      -m     K-bytes on	the size of physical memory.
	      -n     open file descriptors.
	      -s     K-bytes on	the size of the	stack.
	      -t     CPU seconds to be used.
	      -u     processes available to the	user.
	      -v     K-bytes on	the size of virtual memory.

       umask [ -S ] [ mask ]
	      The umask	is set to mask.	 mask can be either an octal number or
	      a	 symbolic value	as described in	chmod(1).  If mask is omitted,
	      the current value	is printed.  The -S option causes the mask  to
	      be  printed as a symbolic	value.	Otherwise, the mask is printed
	      as an octal number.  Note	that in	the symbolic form the  permis-
	      sions you	specify	are those which	are to be allowed (not denied)
	      to the users specified.

       unalias
	      Same as unhash -a.

       unfunction
	      Same as unhash -f.

       unhash [	-adfm ]	name ...
	      Remove the element named name from an internal hash table.   The
	      default  is remove elements from the command hash	table.	The -a
	      option causes unhash to remove aliases.  The  -f	option	causes
	      unhash  to remove	shell functions.  The -d options causes	unhash
	      to remove	named directories.  If the -m flag is given the	 argu-
	      ments  are taken as patterns (should be quoted) and all elements
	      of the corresponding hash	table  with  matching  names  will  be
	      removed.

       unlimit [ -hs ] resource	...
	      The  resource  limit for each resource is	set to the hard	limit.
	      If the -h	flag is	given and the  shell  has  appropriate	privi-
	      leges,  the  hard	 resource  limit for each resource is removed.
	      The resources of the shell process are only changed  if  the  -s
	      flag is given.

       unset [ -fm ] name ...
	      Each  named  parameter  is unset.	 Local parameters remain local
	      even if unset; they appear unset within scope, but the  previous
	      value will still reappear	when the scope ends.

	      Individual elements of associative array parameters may be unset
	      by using subscript syntax	on name, which should  be  quoted  (or
	      the  entire  command  prefixed  with noglob) to protect the sub-
	      script from filename generation.

	      If the -m	flag is	specified the arguments	are taken as  patterns
	      (should  be  quoted)  and	all parameters with matching names are
	      unset.  Note that	this cannot be used when unsetting associative
	      array  elements, as the subscript	will be	treated	as part	of the
	      pattern.

	      unset -f is equivalent to	unfunction.

       unsetopt	[ {+|-}options | {+|-}o	option_name ] [	name ... ]
	      Unset the	options	for the	shell.	All options  specified	either
	      with  flags or by	name are unset.	 If no arguments are supplied,
	      the names	of all options currently unset are printed.  If	the -m
	      flag  is given the arguments are taken as	patterns (which	should
	      be quoted	to preserve them from being interpreted	as  glob  pat-
	      terns),  and  all	options	with names matching these patterns are
	      unset.

       vared  See the section `Zle Builtins' in	zshzle(1).

       wait [ job ... ]
	      Wait for the specified jobs or processes.	 If job	is  not	 given
	      then  all	currently active child processes are waited for.  Each
	      job can be either	a job specification or the process ID of a job
	      in  the job table.  The exit status from this command is that of
	      the job waited for.

       whence [	-vcwfpams ] name ...
	      For each name, indicate how it would be interpreted if used as a
	      command name.

	      -v     Produce a more verbose report.

	      -c     Print  the	 results  in  a	 csh-like  format.  This takes
		     precedence	over -v.

	      -w     For each name, print `name: word' where word  is  one  of
		     alias,  builtin,  command,	 function, hashed, reserved or
		     none, according  as  name	corresponds  to	 an  alias,  a
		     built-in  command,	an external command, a shell function,
		     a command defined with the	hash builtin, a	reserved word,
		     or	 is not	recognised.  This takes	precedence over	-v and
		     -c.

	      -f     Causes the	contents of a shell function to	be  displayed,
		     which  would otherwise not	happen unless the -c flag were
		     used.

	      -p     Do	a path search  for  name  even	if  it	is  an	alias,
		     reserved word, shell function or builtin.

	      -a     Do	 a  search  for	all occurrences	of name	throughout the
		     command path.  Normally  only  the	 first	occurrence  is
		     printed.

	      -m     The  arguments  are taken as patterns (should be quoted),
		     and the information is displayed for each command	match-
		     ing one of	these patterns.

	      -s     If	 a  pathname contains symlinks,	print the symlink-free
		     pathname as well.

       where [ -wpms ] name ...
	      Equivalent to whence -ca.

       which [ -wpams ]	name ...
	      Equivalent to whence -c.

       zcompile	[ -U ] [ -z | -k ] [ -R	| -M ] file [ name ... ]
       zcompile	-ca [ -m ] [ -R	| -M ] file [ name ... ]
       zcompile	-t file	[ name ... ]
	      This builtin  command  can  be  used  to	compile	 functions  or
	      scripts,	storing	 the  compiled	form in	a file,	and to examine
	      files  containing	 the  compiled	form.	This   allows	faster
	      autoloading  of  functions  and execution	of scripts by avoiding
	      parsing of the text when the files are read.

	      The first	form (without the -c, -a or -t options)	creates	a com-
	      piled file.  If only the file argument is	given, the output file
	      has the name `file.zwc' and will be placed in the	same directory
	      as  the  file.  The shell	will load the compiled file instead of
	      the normal function file when the	function  is  autoloaded;  see
	      the section `Autoloading Functions' in zshfunc(1)	for a descrip-
	      tion of how autoloaded functions are  searched.	The  extension
	      .zwc stands for `zsh word	code'.

	      If  there	is at least one	name argument, all the named files are
	      compiled into the	output file given as the first	argument.   If
	      file  does  not  end  in	.zwc,  this extension is automatically
	      appended.	 Files	containing  multiple  compiled	functions  are
	      called  `digest'	files, and are intended	to be used as elements
	      of the FPATH/fpath special array.

	      The second form, with the	-c or -a options, writes the  compiled
	      definitions  for all the named functions into file.  For -c, the
	      names must be functions currently	 defined  in  the  shell,  not
	      those  marked  for  autoloading.	 Undefined  functions that are
	      marked for autoloading may be written by using the -a option, in
	      which case the fpath is searched and the contents	of the defini-
	      tion files for those functions,  if  found,  are	compiled  into
	      file.   If both -c and -a	are given, names of both defined func-
	      tions and	functions marked for autoloading  may  be  given.   In
	      either  case,  the  functions in files written with the -c or -a
	      option will be autoloaded	as if  the  KSH_AUTOLOAD  option  were
	      unset.

	      The reason for handling loaded and not-yet-loaded	functions with
	      different	options	is that	some definition	files for  autoloading
	      define  multiple functions, including the	function with the same
	      name as the file,	and, at	the end, call that function.  In  such
	      cases  the  output  of  `zcompile	-c' does not include the addi-
	      tional functions defined in the file, and	any other  initializa-
	      tion code	in the file is lost.  Using `zcompile -a' captures all
	      this extra information.

	      If the -m	option is combined with	-c or -a, the names  are  used
	      as  patterns  and	 all  functions	whose names match one of these
	      patterns will be written.	If no name is given,  the  definitions
	      of  all functions	currently defined or marked as autoloaded will
	      be written.

	      The third	form, with the -t option, examines  an	existing  com-
	      piled  file.  Without further arguments, the names of the	origi-
	      nal files	compiled into it are listed.  The first	line of	output
	      shows  the  version of the shell which compiled the file and how
	      the file will be used (i.e. by reading it	directly or by mapping
	      it  into	memory).   With	 arguments,  nothing is	output and the
	      return value is set to zero if definitions for  all  names  were
	      found  in	 the compiled file, and	non-zero if the	definition for
	      at least one name	was not	found.

	      Other options:

	      -U     Aliases are not expanded when compiling the named	files.

	      -R     When  the	compiled file is read, its contents are	copied
		     into the shell's memory, rather than  memory-mapped  (see
		     -M).   This  happens automatically	on systems that	do not
		     support memory mapping.

		     When compiling scripts instead of autoloadable functions,
		     it	 is  often desirable to	use this option; otherwise the
		     whole file, including the code to define functions	 which
		     have  already  been  defined,  will remain	mapped,	conse-
		     quently wasting memory.

	      -M     The compiled file is mapped into the shell's memory  when
		     read.  This is done in such a way that multiple instances
		     of	the shell running on the same  host  will  share  this
		     mapped file.  If neither -R nor -M	is given, the zcompile
		     builtin decides what to do	based on the size of the  com-
		     piled file.

	      -k
	      -z     These  options  are  used when the	compiled file contains
		     functions which are to be autoloaded. If -z is given, the
		     function will be autoloaded as if the KSH_AUTOLOAD	option
		     is	not set, even if it is set at the  time	 the  compiled
		     file is read, while if the	-k is given, the function will
		     be	loaded as if KSH_AUTOLOAD is set.  If neither of these
		     options  is  given, the function will be loaded as	deter-
		     mined by the setting of the KSH_AUTOLOAD  option  at  the
		     time the compiled file is read.

		     These  options may	also appear as many times as necessary
		     between the listed	names to specify the loading style  of
		     all following functions, up to the	next -k	or -z.

		     The created file always contains two versions of the com-
		     piled format, one for big-endian  machines	 and  one  for
		     small-endian  machines.   The  upshot of this is that the
		     compiled file is machine independent and if it is read or
		     mapped,  only  one	half of	the file is actually used (and
		     mapped).

       zformat
	      See the section `The zsh/zutil Module' in	zshmodules(1).

       zftp   See the section `The zsh/zftp Module' in zshmodules(1).

       zle    See the section `Zle Builtins' in	zshzle(1).

       zmodload	[ -dL ]	[ ... ]
       zmodload	-e [ -A	] [ ...	]
       zmodload	[ -a [ -bcpf [ -I ] ] ]	[ -iL ]	...
       zmodload	-u [ -abcdpf [ -I ] ] [	-iL ] ...
       zmodload	-A [ -L	] [ modalias[=module] ... ]
       zmodload	-R modalias ...
	      Performs operations relating to zsh's loadable modules.  Loading
	      of  modules  while the shell is running (`dynamical loading') is
	      not available on all operating systems, or on all	 installations
	      on  a particular operating system, although the zmodload command
	      itself is	always available and can be used to manipulate modules
	      built  into  versions  of	the shell executable without dynamical
	      loading.

	      Without arguments	the names of all currently loaded binary  mod-
	      ules  are	 printed.  The -L option causes	this list to be	in the
	      form of a	series of zmodload  commands.	Forms  with  arguments
	      are:

	      zmodload [ -i ] name ...
	      zmodload -u [ -i ] name ...
		     In	 the  simplest	case,  zmodload	loads a	binary module.
		     The module	must be	in a file with a  name	consisting  of
		     the specified name	followed by a standard suffix, usually
		     `.so' (`.sl' on HPUX).  If	the module  to	be  loaded  is
		     already  loaded and the -i	option is given, the duplicate
		     module is ignored.	 Otherwise zmodload  prints  an	 error
		     message.

		     The  named	 module	is searched for	in the same way	a com-
		     mand is, using $module_path instead of  $path.   However,
		     the  path	search	is performed even when the module name
		     contains a	`/', which it usually does.  There is  no  way
		     to	prevent	the path search.

		     With -u, zmodload unloads modules.	 The same name must be
		     given that	was given when the module was loaded,  but  it
		     is	 not necessary for the module to exist in the filesys-
		     tem.  The -i option suppresses the	error if the module is
		     already unloaded (or was never loaded).

		     Each  module has a	boot and a cleanup function.  The mod-
		     ule will not be loaded if its boot	function fails.	 Simi-
		     larly  a module can only be unloaded if its cleanup func-
		     tion runs successfully.

	      zmodload -d [ -L ] [ name	]
	      zmodload -d name dep ...
	      zmodload -ud name	[ dep ... ]
		     The -d option can be used to specify module dependencies.
		     The  modules named	in the second and subsequent arguments
		     will be loaded before the module named in the first argu-
		     ment.

		     With  -d and one argument,	all dependencies for that mod-
		     ule are listed.  With -d and  no  arguments,  all	module
		     dependencies are listed.  This listing is by default in a
		     Makefile-like format.  The	-L option changes this	format
		     to	a list of zmodload -d commands.

		     If	-d and -u are both used, dependencies are removed.  If
		     only one argument is given,  all  dependencies  for  that
		     module are	removed.

	      zmodload -ab [ -L	]
	      zmodload -ab [ -i	] name [ builtin ... ]
	      zmodload -ub [ -i	] builtin ...
		     The  -ab  option defines autoloaded builtins.  It defines
		     the specified builtins.  When any of  those  builtins  is
		     called,  the  module  specified  in the first argument is
		     loaded.  If only  the  name  is  given,  one  builtin  is
		     defined, with the same name as the	module.	 -i suppresses
		     the  error	 if  the  builtin  is	already	  defined   or
		     autoloaded, regardless of which module it came from.

		     With  -ab	and  no	arguments, all autoloaded builtins are
		     listed, with the module  name  (if	 different)  shown  in
		     parentheses  after	 the  builtin  name.   The  -L	option
		     changes this format to a list of zmodload -a commands.

		     If	-b is used together with the  -u  option,  it  removes
		     builtins  previously defined with -ab.  This is only pos-
		     sible if the builtin is not yet  loaded.	-i  suppresses
		     the  error	 if  the  builtin is already removed (or never
		     existed).

	      zmodload -ac [ -IL ]
	      zmodload -ac [ -iI ] name	[ cond ... ]
	      zmodload -uc [ -iI ] cond	...
		     The -ac option is used  to	 define	 autoloaded  condition
		     codes.  The cond strings give the names of	the conditions
		     defined by	the module. The	optional -I option is used  to
		     define  infix condition names. Without this option	prefix
		     condition names are defined.

		     If	given no condition names, all defined names are	listed
		     (as  a  series  of	 zmodload commands if the -L option is
		     given).

		     The -uc option removes definitions	for autoloaded	condi-
		     tions.

	      zmodload -ap [ -L	]
	      zmodload -ap [ -i	] name [ parameter ... ]
	      zmodload -up [ -i	] parameter ...
		     The  -p  option  is like the -b and -c options, but makes
		     zmodload work on autoloaded parameters instead.

	      zmodload -af [ -L	]
	      zmodload -af [ -i	] name [ function ... ]
	      zmodload -uf [ -i	] function ...
		     The -f option is like the -b, -p,	and  -c	 options,  but
		     makes zmodload work on autoloaded math functions instead.

	      zmodload -a [ -L ]
	      zmodload -a [ -i ] name [	builtin	... ]
	      zmodload -ua [ -i	] builtin ...
		     Equivalent	to -ab and -ub.

	      zmodload -e [ -A ] [ string ... ]
		     The -e option without arguments lists all loaded modules;
		     if	 the  -A  option  is also given, module	aliases	corre-
		     sponding to loaded	modules	are also  shown.   With	 argu-
		     ments  only  the  return  status  is  set	to zero	if all
		     strings given as arguments	are names  of  loaded  modules
		     and  to  one  if  at least	on string is not the name of a
		     loaded module.  This can be used to test for  the	avail-
		     ability  of things	implemented by modules.	 In this case,
		     any aliases are automatically resolved and	the -A flag is
		     not used.

	      zmodload -A [ -L ] [ modalias[=module] ... ]
		     For each argument,	if both	modalias and module are	given,
		     define modalias to	be an alias for	the module module.  If
		     the  module  modalias  is	ever  subsequently  requested,
		     either via	a call to zmodload or  implicitly,  the	 shell
		     will  attempt  to	load module instead.  If module	is not
		     given, show the definition	of modalias.  If no  arguments
		     are  given,  list all defined module aliases.  When list-
		     ing, if the -L flag was also given, list  the  definition
		     as	a zmodload command to recreate the alias.

		     The  existence of aliases for modules is completely inde-
		     pendent of	whether	the name resolved is  actually	loaded
		     as	 a module: while the alias exists, loading and unload-
		     ing the module under  any	alias  has  exactly  the  same
		     effect  as	 using	the resolved name, and does not	affect
		     the connection between the	alias and  the	resolved  name
		     which can be removed either by zmodload -R	or by redefin-
		     ing the alias.  Chains of aliases (i.e. where  the	 first
		     resolved  name  is	 itself	an alias) are valid so long as
		     these are not circular.  As the  aliases  take  the  same
		     format as module names, they may include path separators:
		     in	this case, there is no requirement for any part	of the
		     path  named to exist as the alias will be resolved	first.
		     For example, `any/old/alias' is always a valid alias.

		     Dependencies added	to aliased modules are actually	 added
		     to	 the  resolved	module;	 these	remain if the alias is
		     removed.  It is valid to create an	alias  whose  name  is
		     one of the	standard shell modules and which resolves to a
		     different module.	However, if a module has dependencies,
		     it	 will  not  be	possible  to use the module name as an
		     alias as the module will already be marked	as a  loadable
		     module in its own right.

		     Apart from	the above, aliases can be used in the zmodload
		     command anywhere module  names  are  required.   However,
		     aliases will not be shown in lists	of loaded modules with
		     a bare `zmodload'.

	      zmodload -R modalias ...
		     For each modalias argument	that was previously defined as
		     a module alias via	zmodload -A, delete the	alias.	If any
		     was not defined, an error is caused and the remainder  of
		     the line is ignored.

	      Note  that  zsh  makes  no distinction between modules that were
	      linked into the shell and	modules	that are  loaded  dynamically.
	      In both cases this builtin command has to	be used	to make	avail-
	      able the builtins	and other things defined  by  modules  (unless
	      the  module  is  autoloaded  on these definitions). This is true
	      even for systems that don't support dynamic loading of  modules.

       zparseopts
	      See the section `The zsh/zutil Module' in	zshmodules(1).

       zprof  See the section `The zsh/zprof Module' in	zshmodules(1).

       zpty   See the section `The zsh/zpty Module' in zshmodules(1).

       zregexparse
	      See the section `The zsh/zutil Module' in	zshmodules(1).

       zstyle See the section `The zsh/zutil Module' in	zshmodules(1).

zsh 4.0.6			August 14, 2002			ZSHBUILTINS(1)

NAME | SHELL BUILTIN COMMANDS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=zshbuiltins&sektion=1&manpath=Red+Hat+Linux%2fi386+9>

home | help