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 parame­
              ters are restored when the file is done  executing.
              The exit status is the exit status of the last com­
              mand 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 expan­
              sion.   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  cur­
              rently  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 pat­
              terns  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

              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 func­
              tion, 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 argu­
              ments.  This replaces the  previous  definition  of
              the  function.  If no function definition is found,
              an error is printed and the function remains  unde­
              fined and marked for autoloading.

              The  flag  +X  attempts  to  load  each  name as an
              autoloaded function, but does not execute it.   The
              exit  status  is zero (success) if the function was
              not previously defined and a definition for it  was
              found.   This does not replace any existing defini­
              tion 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  executed  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  autoload­
              ing.

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

       bindkey
              See   the   section   `The   zsh/zle   Module'   in


       break [ n ]
              Exit from an enclosing for, while, until, select or
              repeat loop.  If n is specified, then break n  lev­
              els 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 zshmod­
              ules(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  direc­
              tory.

              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 con­
              tains 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.


       clone  See the section `The zsh/clone Module'  in  zshmod­
              ules(1).

       command simple command
              See the section `Precommand Modifiers'.

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

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

       compctl
              See the section `The zsh/compctl Module' in zshmod­
              ules(1).

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

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

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

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

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

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

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

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

              Same as typeset.

       dirs [ -v ] [ arg ... ]
              With no arguments, print the contents of the direc­
              tory  stack.  If the -v option is given, number the
              directories in the stack when  printing.   Directo­
              ries  are  added  to this stack with the pushd com­
              mand, and removed with the cd or popd commands.  If
              arguments  are specified, load them onto the direc­
              tory stack, replacing anything that was there,  and
              push the current directory 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 disabled 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  pre­
              sent,  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

              \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 zshmod­
              ules(1).

       echoti See  the  section `The zsh/terminfo Module' in zsh­
              modules(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 emu­
              lated.  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  zshmisc(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 emulate command and any  setopt  and
              trap  commands  to be local to the immediately sur­
              rounding 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  earlier  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 command.

       eval [ arg ... ]
              Read the  arguments  as  input  to  the  shell  and

              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  environment  of subsequently executed com­
              mands.  Equivalent to typeset -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  nega­
              tive  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  argument  is  taken as a pattern
              (should be quoted)  and  only  the  history  events
              matching this pattern will be shown.  Otherwise the
              editor program ename is invoked on a file  contain­
              ing  these  history 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 specified, 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  list­
              ing.   Also  when listing, -d prints timestamps for

              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 history 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  per­
              mitted.

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

       getcap See  the  section  `The  zsh/cap Module' in zshmod­
              ules(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  con­
              tains  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,

              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 ini­
              tial 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 explic­
              itly 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  mes­
              sage 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  command 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  immediately.   For
              the command hash table this hashes all the absolute
              directories in the PATH, and for the  named  direc­
              tory  hash table this adds all users' home directo­
              ries.  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.

              `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 feature 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 num­
              ber  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.

              in  the  job  list.  In the third form, kill -l, if
              sig is not specified the signal names  are  listed.
              Otherwise,  for each sig that is a name, the corre­
              sponding 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 descrip­
              tion of arithmetic expressions.  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 current 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 operations.
              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.

                     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 system.  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 permitted.  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 current 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 per­
              form a cd to the new top directory.  With no  argu­
              ment,  the  current top entry is removed.  An argu­
              ment 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.

              ]
              With no flags or with 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 fol­
              lowing 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 trail­
                     ing  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 bindkey command, see  zshmodules(1).

              -m     Take the first argument as a pattern (should
                     be quoted), and remove it from the  argument
                     list together with subsequent 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 spaces.

              -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


              -z     Push  the  arguments onto the editing buffer
                     stack,  separated  by  spaces;   no   escape
                     sequences are recognized.

              -D     Treat  the  arguments  as  directory  names,
                     replacing prefixes 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 cur­
              rent 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  interpreted
              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 rotat­
              ing  the  directory  list.  An argument of the form
              `+n' identifies a stack entry by counting from  the
              left  of the list shown by the dirs command, start­
              ing 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 direc­
              tory stack will be printed after a  pushd  is  per­
              formed.

       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  sym­
              bolic links.

       r      Same as fc -e -.

       read [ -rzpqAclneEt ] [ -k [ num ] ]
        [ -un ] [ name[?prompt] ] [ name ...  ]
              Read  one  line  and break it into fields using the

              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  back­
                     slashes  in the line don't quote the follow­
                     ing 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' otherwise.  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 terminal
                     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 pre­
                     sent.

              -e
              -E     The input read is printed  (echoed)  to  the
                     standard output.  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 (spec­
                     ified  with the -K flag to compctl).  If the

                     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 sepa­
                     rated from -u by any whitespace.

              -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  avail­
                     able  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  processing 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  han­
                     dled;  note  that  only  availability 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 com­
              pctl function, or as described for  -q.   Otherwise
              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


              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 speci­
              fied 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
              processing; with a non-zero status, the shell  will
              behave as interrupted 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  zshmod­
              ules(1).

       set [ {+|-}options | {+|-}o option_name ] ... [ {+|-}A [
              name ] ] [ arg ... ]
              Set  the options for the shell and/or set the posi­
              tional parameters, 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
              positional 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 parameters are
              printed.

              ules(1).

       setopt [ {+|-}options | {+|-}o option_name ] [ name ... ]
              Set  the options for the shell.  All options speci­
              fied 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  zshmod­
              ules(1).

       suspend [ -f ]
              Suspend the execution of the shell (send it a SIGT­
              STP) 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 compat­
              ibility;  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 pro­
              tect 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

              DEBUG then arg will be executed after each command.
              If  sig is 0 or EXIT and the trap statement is exe­
              cuted inside the body of a function, then the  com­
              mand  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  different  from those defined as `TRAPNAL
              () { ... }', as the latter have their own  function
              environment  (line  numbers, local variables, 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 suspended.  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

              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 vari­
              able 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 manipulated as nor­
              mal.  If one is unset, the other will automatically
              be unset too.  There is no way of untying the vari­
              ables 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  necessar­
              ily  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 listing existing parameters, nor
              does the flag +g have any effect except in combina­
              tion 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 display to only those parameters
              that have the specified attributes, and  using  `+'

              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 parameters (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  created 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, association,
              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 parame­
                     ters; 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 deter­
                     mined 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

                     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  tracing
                     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 referenced; see
                     the section `Functions'.

              -h     Hide: only  useful  for  special  parameters
                     (those  marked  `<S>'  in  the table in zsh­
                     params(1)), and for  local  parameters  with
                     the same name as a special parameter, though
                     harmless for others.   A  special  parameter
                     with this attribute will not retain its spe­
                     cial effect when  made  local.   Thus  after
                     `typeset  -h  PATH',  a  function containing
                     `typeset PATH' will create an ordinary local
                     parameter  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 param­
                     eter using `typeset +h special',  where  the
                     local  copy  of special will retain its spe­
                     cial properties regardless of having the  -h
                     attribute.  Global special parameters loaded
                     from  shell  modules  (currently  those   in
                     zsh/mapfile and zsh/parameter) are automati­
                     cally given the -h attribute to  avoid  name
                     clashes.

                     display the  value  of  the  parameter  when
                     listing  parameters;  the  display  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-special parameters.

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

              -E     Use  an  internal  double-precision floating
                     point representation.  On output  the  vari­
                     able  will  be converted to scientific nota­
                     tion.  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  representation.   On output the vari­
                     able will be converted to fixed-point  deci­
                     mal  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  subsequently  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

                     is for compatibility 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'.  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  writ­
                     ten.
              -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 permissions 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

              is  given  the  arguments  are  taken  as  patterns
              (should be quoted) and all elements of  the  corre­
              sponding  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 privileges, 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  pre­
              fixed  with  noglob)  to protect the subscript 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 can­
              not  be  used when unsetting associative array ele­
              ments, 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 spec­
              ified  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 inter­
              preted as glob  patterns),  and  all  options  with
              names matching these patterns are unset.

       vared  See  the  section  `The  zsh/zle Module' in zshmod­
              ules(1).

       wait [ job ... ]
              Wait for the specified jobs or processes.   If  job
              is  not  given then all currently active child pro­
              cesses are waited for.  Each job can  be  either  a
              job specification or the process ID of a job in the

              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 hap­
                     pen 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 matching one of these  pat­
                     terns.

              -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  func­
              tions  or  scripts,  storing the compiled form in a
              file, and to examine files containing the  compiled
              form.   This allows faster autoloading of functions

              text when the files are read.

              The  first  form (without the -c, -a or -t options)
              creates a compiled 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  func­
              tion  is  autoloaded;  see the section `Autoloading
              Functions' in zshfunc(1) for a description  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 func­
              tions into file.  For -c, the names must  be  func­
              tions  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 definition files for those
              functions, if found, are compiled  into  file.   If
              both  -c  and  -a  are given, names of both defined
              functions 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 defi­
              nition  files for autoloading define multiple func­
              tions, 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  additional  functions  defined in the
              file, and any other initialization 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 func­
              tions currently defined  or  marked  as  autoloaded
              will be written.

              existing compiled file.  Without further arguments,
              the  names  of  the original 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 argu­
              ments, 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  defini­
              tion 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  autoload­
                     able 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, consequently 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 compiled 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 determined 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

                     functions, up to the next -k or -z.

                     The  created  file  always contains two ver­
                     sions  of  the  compiled  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 zshmod­
              ules(1).

       zftp   See the section `The zsh/zftp  Module'  in  zshmod­
              ules(1).

       zle    See  the  section  `The  zsh/zle Module' in zshmod­
              ules(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 mod­
              ules.   Loading  of modules while the shell is run­
              ning (`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 modules 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 command is, using $module_path instead

                     formed  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  filesystem.
                     The  -i  option  suppresses the error if the
                     module is already  unloaded  (or  was  never
                     loaded).

                     Each  module  has a boot and a cleanup func­
                     tion.  The module will not be loaded if  its
                     boot function fails.  Similarly a module can
                     only be unloaded  if  its  cleanup  function
                     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 sec­
                     ond  and subsequent arguments will be loaded
                     before the module named in the  first  argu­
                     ment.

                     With  -d  and one argument, all dependencies
                     for that module 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  com­
                     mands.

                     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

                     (if  different)  shown  in parentheses after
                     the builtin name.   The  -L  option  changes
                     this  format  to  a list of zmodload -a com­
                     mands.

                     If -b is used together with the  -u  option,
                     it  removes builtins previously defined with
                     -ab.  This is only possible 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 mod­
                     ule. 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 conditions.

              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 param­
                     eters 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  corresponding  to
                     loaded  modules  are   also   shown.    With

                     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
                     availability of things implemented  by  mod­
                     ules.   In  this case, any aliases are auto­
                     matically resolved and the -A  flag  is  not
                     used.

              zmodload -A [ -L ] [ modalias[=module] ... ]
                     For each argument, if both modalias and mod­
                     ule 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 listing, 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 com­
                     pletely  independent  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 for­
                     mat  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 mod­
                     ule will already be  marked  as  a  loadable
                     module in its own right.

                     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 previ­
                     ously defined as a module alias via zmodload
                     -A,  delete  the  alias.   If  any  was  not
                     defined, an error is caused and the  remain­
                     der 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  available  the
              builtins   and  other  things  defined  by  modules
              (unless the module is autoloaded on  these  defini­
              tions).  This  is  true even for systems that don't
              support dynamic loading of modules.

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

       zprof  See  the  section `The zsh/zprof Module' in zshmod­
              ules(1).

       zpty   See the section `The zsh/zpty  Module'  in  zshmod­
              ules(1).

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

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


Man(1) output converted with man2html