LinuxGuruz
  • Last 5 Forum Topics
    Replies
    Views
    Last post


The Web Only This Site
  • BOOKMARK

  • ADD TO FAVORITES

  • REFERENCES


  • MARC

    Mailing list ARChives
    - Search by -
     Subjects
     Authors
     Bodies





    FOLDOC

    Computing Dictionary




  • Text Link Ads






  • LINUX man pages
  • Linux Man Page Viewer


    The following form allows you to view linux man pages.

    Command:

    zshbuiltins

    
    
    

    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.  If file was not found the return status
                  is  127;  if  file  was  found  but contained a syntax error the
                  return status is 126; else the return 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 status is returned.
    
           alias [ {+|-}gmrsL ] [ 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.
    
                  If  the  -s flags is present, define a suffix alias: if the com-
                  mand word on a command line is in the  form  'text.name',  where
                  text  is any non-empty string, it is replaced by the text 'value
                  text.name'.  Note that name is treated as a literal string,  not
                  a  pattern.   A  trailing  space in value is not special in this
                  case.  For example,
    
                         alias -s ps=gv
    
                  will cause the command '*.ps' to be expanded to 'gv  *.ps'.   As
                  alias expansion is carried out earlier than globbing, the '*.ps'
                  will then be expanded.  Suffix aliases  constitute  a  different
                  name  space  from  other  aliases (so in the above example it is
                  still possible to create an alias for the command  ps)  and  the
                  two sets are never listed together.
    
                  For  each  name  with no value, print the value of name, if any.
                  has been defined.
    
                  For more on aliases, include common problems,  see  the  section
                  ALIASING in zshmisc(1).
    
           autoload [ {+|-}UXktz ] [ -w ] [ name ... ]
                  Equivalent  to functions -u, with the exception of -X/+X and -w.
    
                  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.   If ksh-style autoloading is enabled,
                  the function created will contain the contents of the file  plus
                  a call to the function itself appended to it, thus giving 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.
    
                  The flags -z and -k mark the function to be autoloaded in native
                  or  ksh  emulation,  as if the option KSH_AUTOLOAD were unset or
                  were set, respectively.  The flags override the setting  of  the
                  option at the time the function is loaded.
    
           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.
    
                  If arg does not begin with a slash,  the  behaviour  depends  on
                  whether the current directory '.' occurs in the list of directo-
                  ries contained in the shell parameter cdpath.  If it  does  not,
                  first  attempt  to change to the directory arg under the current
                  directory, and if that fails but cdpath is set and  contains  at
                  least  one  element attempt to change to the directory arg under
                  each component of cdpath  in  turn  until  successful.   If  '.'
                  occurs  in  cdpath, then cdpath is searched strictly in order so
                  that '.' is only tried at the appropriate point.
    
                  The order of testing cdpath is modified if the  option  POSIX_CD
                  is set, as described in the documentation for the option.
    
                  If  no  directory is found, 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 -q (quiet) option is specified, the hook  function  chpwd
                  and  the  functions in the array chpwd_functions are not called.
                  This is useful for calls to cd that do not change  the  environ-
                  ment seen by an interactive user.
    
                  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 retained in the directory (and not resolved)
                  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 [ -pvV ] simple command
                  The simple command argument is  taken  as  an  external  command
                  instead  of  a  function  or  builtin  and  is  executed. If the
                  POSIX_BUILTINS option is set, builtins will also be executed but
                  certain  special  properties of them are suppressed. The -p flag
                  causes a default path to be searched instead of that  in  $path.
                  With  the  -v flag, command is similar to whence and with -V, it
                  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 [ -c ] [ arg ... ]
           dirs [ -lpv ]
                  With no arguments, print the contents of  the  directory  stack.
                  Directories  are added to this stack with the pushd command, and
                  removed with the cd or popd commands.  If arguments  are  speci-
                  fied,  load  them  onto  the directory stack, replacing anything
                  that was there, and push the current directory onto the stack.
    
                  -c     clear the directory stack.
    
                  -l     print directory names in full instead of using of using ~
                         expressions.
    
                  -p     print directory entries one per line.
    
                  -v     number the directories in the stack when printing.
    
           disable [ -afmrs ] 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 regular  or  global  aliases.
                  The  -s  option causes disable to act on suffix aliases.  The -f
                  exit  an  interactive shell with them running or stopped.  If no
                  job is specified, disown the current job.
    
                  If the jobs are currently stopped and the  AUTO_CONTINUE  option
                  is  not  set,  a warning is printed containing information about
                  how to make them running after they have been disowned.  If  one
                  of  the latter two forms is used, the jobs will automatically be
                  made running, independent of the setting  of  the  AUTO_CONTINUE
                  option.
    
           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
                  \uNNNN unicode character code in hexadecimal
                  \UNNNNNNNN
                         unicode 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} [ -c arg ] ]
                  Without any argument print current emulation mode.
    
                  With single argument 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 'Compatibil-
                  ity' in zshmisc(1) .
    
                  If  the  -R  option  is  given,  all  options are reset to their
                  default value corresponding to  the  specified  emulation  mode,
    
                  Use of -c enables 'sticky' emulation mode for functions  defined
                  within  the evaluated expression:  the emulation mode is associ-
                  ated thereafter with the function so that whenever the  function
                  is  executed  the emulation (respecting the -R flag, if present)
                  and all options are  set  before  entry  to  the  function,  and
                  restored  after exit.  If the function is called when the sticky
                  emulation is already in effect, either within an 'emulate  shell
                  -c'  expression  or within another function with the same sticky
                  emulation, entry and exit from the function do not cause options
                  to  be  altered  (except  due to standard processing such as the
                  LOCAL_OPTIONS option).
    
                  For example:
    
                         emulate sh -c 'fni() { setopt cshnullglob; }
                         fno() { fni; }'
                         fno
    
                  The two functions fni and fno are defined with sticky sh  emula-
                  tion.   fno  is  then  executed, causing options associated with
                  emulations to be set to their values in sh.  fni then calls fno;
                  because  fno  is  also marked for sticky sh emulation, no option
                  changes take place on entry to  or  exit  from  it.   Hence  the
                  option  cshnullglob,  turned off by sh emulation, will be turned
                  on within fni and remain on on return to fno.  On exit from fno,
                  the emulation mode and all options will be restored to the state
                  they were in before entry to the temporary emulation.
    
                  The documentation above is typically sufficient for the intended
                  purpose  of  executing code designed for other shells in a suit-
                  able environment.  More detailed rules follow.
                  1.     The sticky emulation  environment  provided  by  'emulate
                         shell  -c'  is  identical  to that provided by entry to a
                         function marked for sticky emulation as a consequence  of
                         being  defined  in such an environment.  Hence, for exam-
                         ple, the sticky emulation is  inherited  by  subfunctions
                         defined within functions with sticky emulation.
                  2.     No change of options takes place on entry to or exit from
                         functions that are not marked for sticky emulation, other
                         than  those that would normally take place, even if those
                         functions are called within sticky emulation.
                  3.     No special handling is provided for functions marked  for
                         autoload nor for functions present in wordcode created by
                         the zcompile command.
                  4.     The presence or absence of the -R flag to emulate  corre-
                         sponds  to different sticky emulation modes, so for exam-
                         ple 'emulate sh -c', 'emulate -R sh -c' and 'emulate  csh
                         -c' are treated as three distinct sticky emulations.
    
           enable [ -afmrs ] name ...
                  Enable  the  named hash table elements, presumably disabled ear-
                  ing  command(s) in the current shell process.  The return status
                  is the same as if the commands had been executed directly by the
                  shell;  if  there  are no args or they contain no commands (i.e.
                  are an empty string or whitespace) the return status is zero.
    
           exec [ -cl ] [ -a argv0 ] simple command
                  Replace the current shell with an external command  rather  than
                  forking.   With  -c  clear the environment; with -l prepend - to
                  the argv[0] string of the command executed (to simulate a  login
                  shell); with -a argv0 set the argv[0] string of the command exe-
                  cuted.  See the section 'Precommand Modifiers'.
    
           exit [ n ]
                  Exit the shell with the exit status specified by n; if  none  is
                  specified,  use  the exit status 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 status of 1.
    
           fc [ -e ename ] [ -m match ] [ old=new ... ] [ first [ last ] ]
           fc -l [ -nrdfEiD ] [ -t timefmt ] [ -m match ]
                 [ old=new ... ] [ first [ last ] ]
           fc -p [ -a ] [ filename [ histsize [ savehistsize ] ] ]
           fc -P
           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 that is not set the value of the parameter
                  EDITOR is used; if that is not set a  builtin  default,  usually
                  'vi'  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
                         hh:mm' format
                  -t fmt prints  time  and date stamps in the given format; fmt is
                         formatted with the strftime function with the zsh  exten-
                         sions  described  for the %D{string} prompt format in the
                         section EXPANSION OF PROMPT SEQUENCES in zshmisc(1).  The
                         resulting formatted string must be no more than 256 char-
                         acters or will not be printed.
                  -D     prints elapsed times; may be combined  with  one  of  the
                         options above.
    
                  'fc  -p'  pushes  the  current  history  list  onto  a stack and
                  switches to a new history list.  If the -a option is also speci-
                  fied,  this  history  list will be automatically popped when the
                  current function  scope  is  exited,  which  is  a  much  better
                  solution than creating a trap function to call 'fc -P' manually.
                  If no arguments are specified, the history list is  left  empty,
                  $HISTFILE  is  unset, and $HISTSIZE & $SAVEHIST are set to their
                  default values.  If one argument is given, $HISTFILE is  set  to
                  that filename, $HISTSIZE & $SAVEHIST are left unchanged, and the
                  history file is read in (if it exists)  to  initialize  the  new
                  list.   If a second argument is specified, $HISTSIZE & $SAVEHIST
                  are instead set to the single specified numeric value.  Finally,
                  if a third argument is specified, $SAVEHIST is set to a separate
                  value from $HISTSIZE.  You are free to change these  environment
                  values  for  the new history list however you desire in order to
                  manipulate the new history list.
    
                  'fc -P' pops the history list back to an older list saved by 'fc
                  -p'.   The  current  list is saved to its $HISTFILE before it is
                  destroyed (assuming that $HISTFILE and $SAVEHIST are set  appro-
                  priately,  of  course).  The values of $HISTFILE, $HISTSIZE, and
                  $SAVEHIST are restored to the values they had when 'fc  -p'  was
                  called.   Note  that  this  restoration can conflict with making
                  these variables "local", so your best bet is to avoid local dec-
                  larations  for  these  variables  in functions that use 'fc -p'.
                  The one other guaranteed-safe  combination  is  declaring  these
                  variables  to be local at the top of your function and using the
                  automatic option (-a) with 'fc -p'.  Finally, note  that  it  is
                  legal to manually pop a push marked for automatic popping if you
                  need to do so before the function exits.
    
                  '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.
    
                  Use of the -M option may not be combined with any of the options
                  handled by typeset -f.
    
                  functions -M mathfn defines mathfn as the name of a mathematical
                  function recognised in all forms  of  arithmetical  expressions;
                  see  the  section  'Arithmetic  Evaluation'  in  zshmisc(1).  By
                  default mathfn may take any number of comma-separated arguments.
                  If  min  is given, it must have exactly min args; if min and max
                  are both given, it must have at least min and at most max  args.
                  max may be -1 to indicate that there is no upper limit.
    
                  By  default  the  function is implemented by a shell function of
                  the same name; if shellfn is specified it gives the name of  the
                  corresponding  shell function while mathfn remains the name used
                  in arithmetical expressions.  The name of the function in $0  is
                  mathfn  (not shellfn as would usually be the case), provided the
                  option FUNCTION_ARGZERO is in effect.  The positional parameters
                  in  the shell function correspond to the arguments of the mathe-
                  matical function call.  The  result  of  the  last  arithmetical
                  expression  evaluated inside the shell function (even if it is a
                  form that normally only returns a status) gives  the  result  of
                  the mathematical function.
    
                  functions -M with no arguments lists all such user-defined func-
                  tions in the same form as a  definition.   With  the  additional
                  option  -m  and  a list of arguments, all functions whose mathfn
                  matches one of the pattern arguments are listed.
    
                  function +M removes the list of mathematical functions; with the
                  additional  option  -m the arguments are treated as patterns and
                  all functions whose mathfn  matches  the  pattern  are  removed.
                  Note  that  the shell function implementing the behaviour is not
                  removed (regardless of whether its name coincides with  mathfn).
    
                  For example, the following prints the cube of 3:
    
                         zmath_cube() { (( $1 * $1 * $1 )) }
                         functions -M cube 1 1 zmath_cube
                         print $(( cube(3) ))
    
           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.  Note that a single '-'
                  is not considered a valid option argument.   optstring  contains
                  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 argument  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.
    
                  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 | -n signal_number | -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, with  or
                  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 second form, kill -l, if sig is not
                  specified  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.
    
                  On  some systems, alternative signal names are allowed for a few
                  signals.  Typical examples are SIGCHLD and SIGCLD or SIGPOLL and
                  SIGIO, assuming they correspond to the same signal number.  kill
                  -l will only list the preferred form, however kill -l  alt  will
                  show  if  the  alternative  form corresponds to a signal number.
                  For example, under Linux kill -l IO and kill -l POLL both output
                  29, hence kill -IO and kill -POLL have the same effect.
    
                  Many  systems  will  allow  process IDs to be negative to kill a
                  process group or zero to kill the current process group.
    
           let arg ...
                  Evaluate each arg as an arithmetic expression.  See the  section
                  'Arithmetic  Evaluation'  in  zshmisc(1)  for  a  description of
                  arithmetic expressions.  The exit status is 0 if  the  value  of
                  the  last  expression  is  nonzero, 1 if it is zero, and 2 if an
                  error occurred.
    
           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
                         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.
                  msgqueue
                         Maximum number of bytes in POSIX message queues.
                  resident
                         Maximum resident set size.
                  sigpending
                         Maximum number of pending signals.
                  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.  It
                  can also be an integer, which corresponds to the integer defined
                  for the resource by the operating system.
    
                  If argument corresponds to a number which is out of the range of
                  the  resources  configured into the shell, the shell will try to
                  read or write the limit anyway, and will report an error if this
                  fails.   As  the shell does not store such resources internally,
                  an attempt to set the limit will fail unless the  -s  option  is
                  present.
    
                  limit is a number, with an optional scaling factor, as follows:
    
                  nh     hours
                  nk     kilobytes (default)
                  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 [ [-q] {+|-}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.
    
                  If the -q (quiet) option is specified, the hook  function  chpwd
                  and  the functions in the array $chpwd_functions are not called,
                  and the new directory stack is not printed.  This is useful  for
                  calls  to  popd  that  do  not change the environment seen by an
                  interactive user.
    
           print [ -abcDilmnNoOpPrsSz ] [ -u n ] [ -f format ] [ -C cols ]
             [ -R [ -en ]] [ arg ... ]
                  With the '-f' option the arguments are printed as  described  by
                  printf.   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.
    
                  -a     Print arguments with the column incrementing first.  Only
                         useful with the -c and -C options.
    
                  -b     Recognize  all the escape sequences defined for the bind-
                         key command, see zshzle(1).
    
                  -c     Print the arguments in columns.  Unless -a is also given,
                         arguments are printed with the row incrementing first.
    
                  -C cols
                         Print  the  arguments in cols columns.  Unless -a is also
                         given, arguments are printed with  the  row  incrementing
                         first.
    
                  -D     Treat  the  arguments  as directory names, replacing pre-
                         fixes with ~ expressions, as appropriate.
    
                  -o     Print the arguments sorted in ascending order.
    
                  -O     Print the arguments sorted in descending order.
    
                  -p     Print the arguments to the input of the coprocess.
    
                  -P     Perform  prompt  expansion  (see  EXPANSION   OF   PROMPT
                         SEQUENCES in zshmisc(1)).
    
                  -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.
    
                  -s     Place  the  results in the history list instead of on the
                         standard output.  Each argument to the print  command  is
                         treated  as  a  single word in the history, regardless of
                         its content.
    
                  -S     Place the results in the history list instead of  on  the
                         standard  output.  In this case only a single argument is
                         allowed; it will be split into words as if it were a full
                         shell command line.  The effect is similar to reading the
                         line from a history file with the  HIST_LEX_WORDS  option
                         active.
    
                  -u n   Print the arguments to file descriptor n.
    
                  -z     Push  the  arguments onto the editing buffer stack, sepa-
                         rated by spaces.
    
                  If any of '-m', '-o' or '-O' are used in combination  with  '-f'
                  and  there  are  no  arguments (after the removal process in the
                  case of '-m') then nothing is printed.
    
           printf format [ arg ... ]
                  Print the arguments according to the format specification.  For-
                  matting  rules  are  the  same  as  used  in  C. The same escape
                  sequences as for echo are recognised in the format. All  C  con-
                  version  specifications ending in one of csdiouxXeEfgGn are han-
                  dled. In addition to this, '%b' can be used instead of  '%s'  to
                  cause escape sequences in the argument to be recognised and '%q'
                  can be used to quote the argument in such a way that  allows  it
                  to be reused as shell input. With the numeric format specifiers,
                  if the corresponding argument starts with a quote character, the
                  numeric  value  of the following character is used as the number
                  to print otherwise the argument is evaluated  as  an  arithmetic
                  expression.  See  the  section  'Arithmetic  Evaluation' in zsh-
                  misc(1) for a description of arithmetic expressions. With  '%n',
                  the  behaviour  is as if zero or an empty string had been speci-
                  fied as the argument.
    
           pushd [ -qsLP ] [ arg ]
           pushd [ -qsLP ] old new
           pushd [ -qsLP ] {+|-}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 -q (quiet) option is specified, the hook  function  chpwd
                  and  the functions in the array $chpwd_functions are not called,
                  and the new directory stack is not printed.  This is useful  for
                  calls  to  pushd  that  do not change the environment seen by an
                  interactive user.
    
                  If  the  option  -q  is  not  specified  and  the  shell  option
                  PUSHD_SILENT  is  not  set,  the directory stack will be printed
                  after a pushd is performed.
    
                  The options -s, -L and -P have the same meanings as for  the  cd
                  builtin.
    
           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 [ -rszpqAclneE ] [ -t [ num ] ] [ -k [ num ] ] [ -d delim ]
            [ -u n ] [ 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
                         of  file,  status  2 is returned.  Input is read from the
                         terminal unless one of -u or -p is present.  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  despite  the  mnemonic 'key' this option does
                         read full characters, which may consist of multiple bytes
                         if the option MULTIBYTE is set.
    
                  -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.
    
                  -u n   Input is read from file descriptor n.
    
                  -p     Input is read from the coprocess.
    
                  -d delim
                         Input is terminated  by  the  first  character  of  delim
                         instead of by newline.
    
                         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
                         input is processed one key at a time; in this case,  only
                         availability  of  the  first character is tested, so that
                         e.g. 'read -t -k 2' can still block on the second charac-
                         ter.   Use  two  instances of 'read -t -k' if this is not
                         what is wanted.
    
                  If the first argument contains a '?', the remainder of this word
                  is used as a prompt on standard error when the shell is interac-
                  tive.
    
                  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).
    
                  If  the -A flag is specified, name is set to an array containing
                  the given args; if no name is specified, all arrays are  printed
                  together with their values.
    
                  If  +A  is  used  and name is an array, the given arguments will
                  replace the initial elements of that array; if no name is speci-
                  fied, all arrays are printed without their values.
    
                  The  behaviour  of arguments after -A name or +A name depends on
                  whether the option KSH_ARRAYS is set.  If it  is  not  set,  all
                  arguments  following  name  are treated as values for the array,
                  regardless of their form.  If the option is set,  normal  option
                  processing  continues  at that point; only regular arguments are
                  treated as values for the array.  This means that
    
                         set -A array -x -- foo
    
                  sets array to '-x -- foo' if KSH_ARRAYS is not set, but sets the
                  array to foo and turns on the option '-x' if it is set.
    
                  If  the  -A  flag is not present, but there are arguments beyond
                  the options, the positional parameters are set.  If  the  option
                  list  (if  any)  is terminated by '--', and there are no further
                  arguments, the positional parameters will be unset.
    
                  If no arguments and no '--' 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.
    
                  For historical reasons, 'set -' is treated as 'set +xv' and 'set
                  -  args'  as  'set +xv -- args' when in any other emulation mode
                  than zsh's native mode.
    
           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.  The form is chosen so as to minimize the  dif-
                  ferences from the default options for the current emulation (the
                  default emulation being native  zsh,  shown  as  <Z>  in  zshop-
                  tions(1)).  Options that are on by default for the emulation are
                  shown with the prefix no only  if  they  are  off,  while  other
                  options are shown without the prefix no and only if they are on.
                  In addition to options changed from the  default  state  by  the
                  user,  any  options  activated  automatically  by the shell (for
                  example, SHIN_STDIN or INTERACTIVE) will be shown in  the  list.
                  The  format  is further modified by the option KSH_OPTION_PRINT,
                  however the rationale for choosing options with or  without  the
                  no prefix remains the same in this case.
                  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').   The  main  differences  between the conditional
                  expression syntax and the test and [ builtins are:   these  com-
                  mands  are  not  handled  syntactically, so for example an empty
                  variable expansion may cause an argument to be  omitted;  syntax
                  errors  cause  status 2 to be returned instead of a shell error;
                  and arithmetic operators expect integer  arguments  rather  than
                  arithmetic expressions.
    
                  The command attempts to implement POSIX and its extensions where
                  these are specified.  Unfortunately there are intrinsic ambigui-
                  ties  in  the  syntax;  in  particular  there  is no distinction
                  between test operators and  strings  that  resemble  them.   The
                  standard  attempts  to  resolve these for small numbers of argu-
                  ments (up to four); for five  or  more  arguments  compatibility
                  cannot  be  relied on.  Users are urged wherever possible to use
                  the '[[' test syntax which does not have these ambiguities.
    
           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 any of the signals specified by one or more
                  sig args.  Each sig can be given as a number, or as the name  of
                  a signal either with or without the string SIG in front (e.g. 1,
                  HUP, and SIGHUP are all the same signal).
    
                  If arg is '-', then the specified signals  are  reset  to  their
                  defaults, or, if no sig args are present, all traps are reset.
    
                  If  arg  is  an  empty  string,  then  the specified signals are
                  ignored by the shell (and by the commands it invokes).
    
                  If arg is omitted but one or more sig args  are  provided  (i.e.
                  the first argument is a valid signal number or name), the effect
                  is the same as if arg had been specified as '-'.
    
                  description of the ERR_EXIT option in zshoptions(1).  Also,  the
                  shell parameter ZSH_DEBUG_CMD is set to the string corresponding
                  to the command to be executed following  the  trap.   Note  that
                  this  string  is  reconstructed from the internal format and may
                  not be formatted the same way as the original text.  The parame-
                  ter is unset after the trap is executed.
    
                  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.  The value of $? at the start of execu-
                  tion is the exit status of the shell or the return status of the
                  function exiting.  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 runs before any
                  zshexit hook functions.
    
                  ZERR, DEBUG, and EXIT traps are not executed inside other traps.
                  ZERR  and  DEBUG  traps  are  kept within subshells, while other
                  traps are reset.
    
                  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.
    
                  Alternative  signal  names  are  allowed as described under kill
                  above.  Defining a trap under either name causes any trap  under
                  an  alternative  name to be removed.  However, it is recommended
                  that for consistency users stick  exclusively  to  one  name  or
                  another.
    
           true [ arg ... ]
                  Do nothing and return an exit status 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
                  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.   Unless  the option
                  KSH_TYPESET is set, normal expansion rules apply  to  assignment
                  arguments,  so  value  may  be split into separate words; if the
                  option is set, assignments which can be recognised  when  expan-
                  sion  is performed are treated as single words.  For example the
                  command typeset vbl=$(echo one two) is  treated  as  having  one
                  argument if KSH_TYPESET is set, but otherwise is treated as hav-
                  ing the two arguments vbl=one and two.
    
                  If the shell option TYPESET_SILENT is not set, for each  remain-
                  ing  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 -p option is given, parameters and values are printed  in
                  the  form  of a typeset command and an assignment (which will be
                  printed separately for arrays and associative  arrays),  regard-
                  less  of  other  flags  and  options.   Note that the -h flag on
                  parameters is respected; no value will be shown for these param-
                  eters.
    
                  If  the  -T  option  is  given,  two  or three arguments must be
                  present (an exception is that zero arguments are allowed to show
                  the  list of parameters created in this fashion).  The first two
                  are the name of a scalar and an array parameter (in that  order)
                  that  will  be  tied  together in the manner of $PATH and $path.
                  The optional third  argument  is  a  single-character  separator
                  which will be used to join the elements of the array to form the
                  scalar; if absent, a colon is used, as  with  $PATH.   Only  the
                  first  character  of the separator is significant; any remaining
                  characters are  ignored.   Only  the  scalar  parameter  may  be
                  assigned  an  initial  value.  Both the scalar and the array may
                  otherwise be manipulated 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, assign-
                  ing 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.  Setting the value using the scalar
                  version causes a  split  on  all  separators  (which  cannot  be
                  quoted).
    
                  The  -g  (global)  flag  is treated specially: it means that any
                  resulting parameter will not be restricted to local scope.  Note
    
                  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  (the  shell  option  TYPESET_SILENT is not used in this
                  case).  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.
    
                  Attribute  flags that transform the final value (-L, -R, -Z, -l,
                  u) are only applied to the expanded value  at  the  point  of  a
                  parameter  expansion expression using '$'.  They are not applied
                  when a parameter is retrieved internally by the  shell  for  any
                  purpose.
    
                  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.  If n is
                         zero, the width is determined by the width of  the  value
                         of  the first assignment.  In the case of numeric parame-
                         ters, the length of the complete value  assigned  to  the
                         parameter  is  used to determine the width, not the value
                         that would be output.
    
                         The width is the count of characters, which may be multi-
                         byte  characters  if  the  MULTIBYTE option is in effect.
                         Note that the screen width of the character is not  taken
                         into  account;  if  this  is  required,  use padding with
                         parameter expansion flags ${(ml...)...} as  described  in
                         'Parameter Expansion Flags' in zshexpn(1).
    
                         When the parameter is expanded, it is filled on the right
                         with blanks or truncated if necessary to fit  the  field.
                         Note  truncation  can  lead  to  unexpected  results with
                         numeric parameters.  Leading zeros are removed if the  -Z
                         flag is also set.
    
                         character  is  a digit.  Numeric parameters are specially
                         handled:  they  are  always  eligible  for  padding  with
                         zeroes,  and  the  zeroes  are inserted at an appropriate
                         place in the output.
    
                  -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,  -k, -u, -U and -z.  The flag -t turns on execu-
                         tion 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 refer-
                         enced;  see  the section 'Functions'. The -k and -z flags
                         make the function be loaded using ksh-style or  zsh-style
                         autoloading  respectively.  If neither is given, the set-
                         ting of the KSH_AUTOLOAD option determines how the  func-
                         tion is loaded.
    
                  -h     Hide:  only  useful  for special parameters (those marked
                         '<S>' in the table in zshparam(1)), and for local parame-
                         ters  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-
                         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.  Note that  if  name
                         is  a  special  parameter,  the readonly attribute can be
                         turned on, but cannot then be turned off.
    
                  -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 [ [ -SHacdfilmnpqstvx | -N resource [ 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 one of  the  values  'unlimited',  which
                  removes  the  limit  on  the resource, or 'hard', which uses the
                  current value of the hard limit on the resource.
    
                  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 value is printed, the
                  limit name and unit is printed before each value.
    
                  When looping over multiple resources, the shell will abort imme-
                  diately  if  it detects a badly formed argument.  However, if it
                  fails to set a limit for some other reason it will continue try-
                  ing to set the remaining limits.
    
                  -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.
                  resource', where resource corresponds to the integer defined for
                  the resource by the operating system.  This may be used  to  set
                  the  limits for resources known to the shell which do not corre-
                  spond to option letters.  Such limits will be shown by number in
                  the output of 'ulimit -a'.
    
                  The  number may alternatively be out of the range of limits com-
                  piled into the shell.  The shell will try to read or  write  the
                  limit anyway, and will report an error if this fails.
    
           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 [ -adfms ] 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 regular or global aliases; note
                  when removing a global aliases that the argument must be  quoted
                  to  prevent  it  from  being expanded before being passed to the
                  command.  The -s option causes unhash to remove suffix  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  arguments 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.
    
                  The  unlimit  command  is not made available by default when the
                  shell starts in a mode emulating another shell.  It can be  made
                  available  with the command 'zmodload -F zsh/rlimits b:unlimit'.
    
           unset [ -fmv ] name ...
                  Each named parameter is unset.  Local  parameters  remain  local
                  even  if unset; they appear unset within scope, but the previous
                  the default behaviour.
    
                  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-
    
                  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 zshmisc(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-
                         -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.  These options  also
                         take  precedence  over  any -k or -z options specified to
                         the autoload builtin. 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  com-
                         piled 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 -F [ -lLme -P param ] module [+-]feature...
           zmodload -e [ -A ] [ ... ]
           zmodload [ -a [ -bcpf [ -I ] ] ] [ -iL ] ...
           zmodload -u [ -abcdpf [ -I ] ] [ -iL ] ...
    
                  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 the duplicate module is ignored.  If zmod-
                         load detects an inconsistency, such as an invalid  module
                         name  or circular dependency list, the current code block
                         is aborted.   Hence 'zmodload module 2>/dev/null' is suf-
                         ficient  to test whether a module is available.  If it is
                         available, the module is loaded if necessary, while if it
                         is  not  available, non-zero status is silently returned.
                         The option -i is accepted for compatibility  but  has  no
                         effect.
    
                         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.
    
                         If  the  module  supports  features (see below), zmodload
                         tries to enable all features when loading a  module.   If
                         the  module  was successfully loaded but not all features
                         could be enabled, zmodload returns status 2.
    
                         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 file sys-
                         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 -F [ -almLe -P param ] module [+-]feature...
                         zmodload  -F  allows more selective control over the fea-
                         tures provided by modules.  With no  options  apart  from
                         -F,  the  module  named  module  is loaded, if it was not
                         already loaded, and the list of features is  set  to  the
                         required state.  If no features are specified, the module
                         is loaded, if it was not already loaded, but the state of
                         features is unchanged.  Each feature may be preceded by a
                         + to turn the feature on, or - to turn it off; the  +  is
                         assumed if neither character is present.  Any feature not
                         explicitly mentioned is left in its current state; if the
                         module was not previously loaded this means any such fea-
                         tures will remain disabled.  The return status is zero if
                         fix.
    
                         With  -l  or  -L,  features  provided  by  the module are
                         listed.  With -l alone, a list of features together  with
                         their  states  is  shown,  one feature per line.  With -L
                         alone, a zmodload -F command  that  would  cause  enabled
                         features  of  the  module to be turned on is shown.  With
                         -lL, a zmodload -F command that would cause all the  fea-
                         tures  to be set to their current state is shown.  If one
                         of these combinations is given the option -P  param  then
                         the  parameter  param  is  set  to  an array of features,
                         either features together with their state or (if -L alone
                         is given) enabled features.
    
                         With the option -L the module name may be omitted; then a
                         list of all enabled features for  all  modules  providing
                         features  is printed in the form of zmodload -F commands.
                         If -l is also given, the state of both enabled  and  dis-
                         abled features is output in that form.
    
                         A  set of features may be provided together with -l or -L
                         and a module name; in that case only the state  of  those
                         features  is considered.  Each feature may be preceded by
                         + or - but the character has no effect.   If  no  set  of
                         features is provided, all features are considered.
    
                         With  -e,  the  command  first  tests  that the module is
                         loaded; if it is not, status 1 is returned.  If the  mod-
                         ule  is loaded, the list of features given as an argument
                         is examined.  Any feature given with no prefix is  simply
                         tested  to  see  if  the  module provides it; any feature
                         given with a prefix + or - is tested to see  if  is  pro-
                         vided  and  in the given state.  If the tests on all fea-
                         tures in the list succeed, status  0  is  returned,  else
                         status 1.
    
                         With  -m,  each  entry  in  the given list of features is
                         taken as a pattern to be matched against the list of fea-
                         tures  provided by the module.  An initial + or - must be
                         given explicitly.  This may not be combined with  the  -a
                         option as autoloads must be specified explicitly.
    
                         With  -a,  the  given  list  of  features  is  marked for
                         autoload from the specified module, which may not yet  be
                         loaded.   An  optional  +  may  appear before the feature
                         name.  If the feature is prefixed with  -,  any  existing
                         autoload  is  removed.  The options -l and -L may be used
                         to list autoloads.  Autoloading is specific to individual
                         features;  when  the  module is loaded only the requested
                         feature is enabled.  Autoload requests are  preserved  if
                         the  module  is  subsequently  unloaded until an explicit
                         'zmodload -Fa module -feature' is issued.  It is  not  an
                         options   for   listing  and  testing  the  existence  of
                         autoloadable features.  In this case -l is ignored if  -L
                         is  specified.   zmodload  -FaL with no module name lists
                         autoloads for all modules.
    
                         Note that only standard features as described  above  can
                         be  autoloaded;  other  features require the module to be
                         loaded before enabling.
    
                  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 and all its features are  enabled  (for  selective
                         control  of  features  use  'zmodload -F -a' as described
                         above).  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,  but  not if another builtin of the same name
                         is already defined.
    
                         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).
    
                         (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.  If arguments
                         are provided, nothing is printed; 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 availability 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
                         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).
    
           zsocket
                  See the section 'The zsh/net/socket Module' in zshmodules(1).
    
           zstyle See the section 'The zsh/zutil Module' in zshmodules(1).
    
           ztcp   See the section 'The zsh/net/tcp Module' in zshmodules(1).
    
    
    

    zsh 4.3.17 February 22, 2011 ZSHBUILTINS(1)

    
    
  • MORE RESOURCE


  • Linux

    The Distributions





    Linux

    The Software





    Linux

    The News



  • MARKETING






  • Toll Free

webmaster@linuxguruz.com
Copyright © 1999 - 2016 by LinuxGuruz