Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
CARE

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Glossary
MoreInfo
Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
FAQ
Copyright Info
Terms of Use
Privacy Info
Disclaimer
WorkBoard
Thanks
Donations
Advertising
Masthead / Impressum
Your Account

Communication
Feedback
Forums
Private Messages
Surveys

Features
HOWTOs
News Archive
Submit News
Topics
User Articles
Web Links

Google
Google


The Web
linux-tutorial.info

Who's Online
There are currently, 217 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here

  

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 parame­
              ters are restored when the file is done  executing.
              The exit status is the exit status of the last com­
              mand executed.

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

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

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

              If the -L flag is present, then print each alias in
              a  manner suitable for putting in a startup script.
              the  function.  If no function definition is found,
              an error is printed and the function remains  unde­
              fined and marked for autoloading.

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

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

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

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

       bindkey
              See the section `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 lev­
              els instead of just one.

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

       bye    Same as exit.

       cap    See the section `The  zsh/cap  Module'  in  zshmod­
              ules(1).
              treat  its  value  as the directory.  In that case,
              the parameter is added to the named directory  hash
              table.

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

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

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

       chdir  Same as cd.

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

       command simple command
              See the section `Precommand Modifiers'.

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

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

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

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

       compfiles
              See the section `The zsh/computil Module'  in  zsh­

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

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

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

       declare
              Same as typeset.

       dirs [ -c ] [ arg ... ]
       dirs [ -lpv ]
              With no arguments, print the contents of the direc­
              tory stack.  Directories are added  to  this  stack
              with  the pushd command, and removed with the cd or
              popd commands.  If arguments  are  specified,  load
              them  onto  the directory stack, replacing anything
              that was there, and push the current 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 [ -afmr ] name ...
              Temporarily  disable the named hash table elements.
              The default is to disable builtin  commands.   This
              allows you to use an external command with the same
              name as a builtin command.  The  -a  option  causes
              disable  to  act  on aliases.  The -f option causes
              disable to act on shell functions.  The -r  options
              causes  disable  to act on reserved words.  Without
              arguments all disabled hash table elements from the
              corresponding  hash table are printed.  With the -m
              flag the arguments are  taken  as  patterns  (which
              should  be  quoted  to prevent them from undergoing
              filename expansion), and all  hash  table  elements
              from  the  corresponding  hash table matching these
              taining  information about how to make them running
              after they have been disowned.  If one of the  lat­
              ter  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  pre­
              sent,  print a newline at the end.  echo recognizes
              the following escape sequences:

              \a     bell character
              \b     backspace
              \c     suppress final newline
              \e     escape
              \f     form feed
              \n     linefeed (newline)
              \r     carriage return
              \t     horizontal tab
              \v     vertical tab
              \\     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 zshmod­
              ules(1).

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

       emulate [ -LR ] {zsh|sh|ksh|csh}
              Set up zsh options to emulate the  specified  shell
              as  much as possible.  csh will never be fully emu­
              lated.  If the argument is not one  of  the  shells
              listed  above,  zsh will be used as a default; more
              precisely, the tests performed on the argument  are
              the  same  as those used to determine the emulation
              at startup based on the shell name, see the section
              `Compatibility'  in  zshmisc(1) .  If the -R option
              is given, all options are reset  to  their  default
              value  corresponding  to  the  specified  emulation
              mode, except for  certain  options  describing  the
              interactive   environment;  otherwise,  only  those
              options likely to  cause  portability  problems  in
              enable to act on shell functions.   The  -r  option
              causes  enable  to  act on reserved words.  Without
              arguments all enabled hash table elements from  the
              corresponding  hash table are printed.  With the -m
              flag the arguments are taken as patterns (should be
              quoted) and all hash table elements from the corre­
              sponding hash table  matching  these  patterns  are
              enabled.   Enabled objects can be disabled with the
              disable builtin command.

       eval [ arg ... ]
              Read the arguments as input to the shell  and  exe­
              cute  the  resulting  command  in the current shell
              process.

       exec simple command
              See the section `Precommand Modifiers'.

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

       export [ name[=value] ... ]
              The specified names are marked for automatic export
              to  the  environment  of subsequently executed com­
              mands.  Equivalent to typeset -gx.  If a  parameter
              specified  does not already exist, it is created in
              the global scope.

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

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

              If the -l flag is given, the resulting commands are
              listed on standard output.  If the -m flag is  also
              given  the  first  argument  is  taken as a pattern
              (should be quoted)  and  only  the  history  events
              matching this pattern will be shown.  Otherwise the
              each command, and -f prints full time-date  stamps.
              Adding  the  -E flag causes the dates to be printed
              as   `dd.mm.yyyy',   instead   of    the    default
              `mm/dd/yyyy'.   Adding the -i flag causes the dates
              to be printed in ISO8601 `yyyy-mm-dd' format.  With
              the -D flag, fc prints elapsed times.

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

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

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

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

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

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

       getopts optstring name [ arg ... ]
              Checks the args for legal options.  If the args are
              omitted,  use  the  positional parameters.  A valid
              option argument begins with a `+'  or  a  `-'.   An
              argument  not beginning with a `+' or a `-', or the
              argument `--', ends the options.  Note that a  sin­
              gle  `-' is not considered a valid option argument.
              optstring contains the letters that getopts  recog­
              nizes.   If  a  letter  is  followed by a `:', that
              option  is  expected  to  have  an  argument.   The
              options  can  be  separated  from  the  argument by
              itly unset, it remains  unset,  and  the  index  or
              option  argument  is not stored.  The option itself
              is still stored in name in this case.

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

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

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

              The  -r option causes the selected hash table to be
              emptied.  It will be subsequently  rebuilt  in  the
              normal  fashion.  The -f option causes the selected
              hash table to be fully  rebuilt  immediately.   For
              the command hash table this hashes all the absolute
              directories in the PATH, and for the  named  direc­
              tory  hash table this adds all users' home directo­
              ries.  These two options cannot be  used  with  any
              arguments.

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

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

       history
              Same as fc -l.

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

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

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

       kill  [ -s signal_name | -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 num­
              ber  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.

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

       limit [ -hs ] [ resource [ limit ] ] ...
              Set or display resource limits.  Unless the -s flag
              is  given,  the  limit applies only the children of
              the shell.  If -s is given without other arguments,
                     Maximum  amount  of memory locked in RAM for
                     AIO operations.
              aiooperations
                     Maximum number of AIO operations.
              cachedthreads
                     Maximum number of cached threads.
              coredumpsize
                     Maximum size of a core dump.
              cputime
                     Maximum CPU seconds per process.
              datasize
                     Maximum data size (including stack) for each
                     process.
              descriptors
                     Maximum value for a file descriptor.
              filesize
                     Largest single file allowed.
              maxproc
                     Maximum number of processes.
              maxpthreads
                     Maximum number of threads per process.
              memorylocked
                     Maximum amount of memory locked in RAM.
              memoryuse
                     Maximum resident set size.
              resident
                     Maximum resident set size.
              sockbufsize
                     Maximum size of all socket buffers.
              stacksize
                     Maximum stack size for each process.
              vmemorysize
                     Maximum amount of virtual memory.

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

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

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

       local [ {+|-}AEFHLRUZahilprtux [n]] [ name[=value] ] ...
              Same as typeset, except that the options -g, and -f
              are not permitted.  In this case the -x option does
              not force the use of -g,  i.e.  exported  variables
              will be local to functions.
              ment,  the  current top entry is removed.  An argu­
              ment of the form `+n' identifies a stack  entry  by
              counting  from  the  left  of the list shown by the
              dirs command, starting with zero.  An  argument  of
              the   form  -n  counts  from  the  right.   If  the
              PUSHD_MINUS option is set, the meanings of `+'  and
              `-' in this context are swapped.

       print  [  -abcDilmnNoOpPrsz  ]  [ -un ] [ -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' pro­
              duces  a  control character (`\C-@' and `\C-?' give
              the characters NUL and delete), and `\E' is a  syn­
              onym  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 bindkey 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  prefixes  with  ~ expressions, as
                     appropriate.

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

              -l     Print  the  arguments  separated by newlines
                     instead of spaces.

              -m     Take the first argument as a pattern (should
                     be  quoted), and remove it from the argument
                     list together with subsequent arguments that
                     coprocess.

              -P     Perform prompt expansion (see 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 trail­
                     ing 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.

              -un    Print the arguments to file descriptor n.

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

              If any of `-m', `-o' or `-O' are used  in  combina­
              tion  with  `-f'  and there are no arguments (after
              the removal process in the case of `-m') then noth­
              ing is printed.

       printf format [ arg ... ]
              Print  the arguments according to the format speci­
              fication. Formatting rules are the same as used  in
              C. The same escape sequences as for echo are recog­
              nised in the format. All  C  conversion  specifica­
              tions  ending in one of csdiouxXeEfgGn are handled.
              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 char­
              acter  is used as the number to print otherwise the
              argument is evaluated as an arithmetic  expression.
              See  the  section  `Arithmetic  Evaluation'  for  a
              description of arithmetic expressions.  With  `%n',
              the  corresponding  argument is taken as an identi­
              fier which is created as an integer parameter.

              Normally, conversion specifications are applied  to
              each  argument  in  order  but  they can explicitly
              specify the nth argument is to be used by replacing
              `%'  by  `%n$' and `*' by `*n$'.  It is recommended
              that you do not mix  references  of  this  explicit
              style  with  the  normal  style and the handling of
              rent directory onto the directory  stack.   In  the
              first  form,  change  the current directory to arg.
              If arg is  not  specified,  change  to  the  second
              directory  on  the stack (that is, exchange the top
              two  entries),  or   change   to   $HOME   if   the
              PUSHD_TO_HOME option is set or if there is only one
              entry on the stack.  Otherwise, arg is  interpreted
              as  it  would be by cd.  The meaning of old and new
              in the second form is also the same as for cd.

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

              If  the  option PUSHD_SILENT is not set, the direc­
              tory stack will be printed after a  pushd  is  per­
              formed.

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

       r      Same as fc -e -.

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

              -r     Raw mode: a `\' at the end of  a  line  does
                     not  signify  line  continuation  and  back­
                     slashes in the line don't quote the  follow­
                     used within zle widgets.

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

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

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

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

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

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

              -un    Input is read from file descriptor n.

              -p     Input is read from the coprocess.

              -d delim
                     Input  is  terminated by the first character
                     of delim instead of by newline.

                     from  the editor buffer with -z, when called
                     from within completion with -c or  -l,  with
                     -q which clears the input queue before read­
                     ing, or within zle  where  other  mechanisms
                     should be used to test for input.

                     Note that read does not attempt to alter the
                     input processing mode.  The default mode  is
                     canonical  input, in which an entire line is
                     read at a time, so usually  `read  -t'  will
                     not  read  anything until an entire line has
                     been typed.  However, when reading from  the
                     terminal  with -k 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  character.   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  com­
              pctl  function,  or as described for -q.  Otherwise
              the value is 0.

              The behavior of some combinations of  the  -k,  -p,
              -q,  -u  and  -z  flags is undefined.  Presently -q
              cancels all the others, -p cancels -u,  -k  cancels
              -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  speci­
              fied  by  n.  If n is omitted, the return status is
              that of the last command executed.

              If return was executed from a  trap  in  a  TRAPNAL
              function,  the  effect  is  different  for zero and
              non-zero return status.  With zero status (or after
              an  implicit  return  at  the end of the trap), the
              shell will return to  whatever  it  was  previously
              tional parameters, or declare and set an array.  If
              the -s option is given,  it  causes  the  specified
              arguments to be sorted before assigning them to the
              positional parameters (or to the array name  if  -A
              is  used).   With  +s  sort arguments in descending
              order.  For the meaning of  the  other  flags,  see
              zshoptions(1).   Flags  may  be  specified  by name
              using the -o option. If no option name is  supplied
              with  -o,  the  current  option states are printed.
              With +o they are printed in a form that can be used
              as input to the shell.

              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 argu­
              ments  will  replace  the  initial elements of that
              array; if no name  is  specified,  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  argu­
              ments 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.

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

       setopt [ {+|-}options | {+|-}o option_name ] [ name ... ]
              positional parameters.

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

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

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

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

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

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

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

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

              Note  that  traps defined with the trap builtin are
              slightly different from those defined  as  `TRAPNAL
              ()  { ... }', as the latter have their own function
              environment (line numbers, local  variables,  etc.)

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

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

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

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

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

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

              If the -p option is given,  parameters  and  values
              are  printed in the form of a typeset comand and an
              assignment (which will be  printed  separately  for
              arrays and associative arrays), regardless of other
              flags and options.  Note that the -h flag on param­
              eters  is  respected;  no  value  will be shown for
              these parameters.
              +T  does  not work, assigning an array to SCALAR is
              an error, and assigning a scalar to array  sets  it
              to  be  a  single-element  array.   Note  that both
              `typeset -xT ...' and `export  -T  ...'  work,  but
              only the scalar will be marked for export.

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

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

              If the -m flag is  given  the  name  arguments  are
              taken  as  patterns (which should be quoted).  With
              no attribute flags, all  parameters  (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 created for every matching
              parameter that is not already local.  Otherwise  -m
              applies  all  other  flags  or  assignments  to the
              existing parameters.  Except when  assignments  are
              made  with name=value, using +m forces the matching
              parameters to be printed, even inside a function.

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

              The following attribute flags may be specified:

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

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

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

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

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

              -h     Hide: only  useful  for  special  parameters
                     (those  marked  `<S>'  in  the table in zsh­
                     params(1)), and for  local  parameters  with
                     the same name as a special parameter, though
                     harmless for others.   A  special  parameter
                     with this attribute will not retain its spe­
                     cial effect when  made  local.   Thus  after
                     `typeset  -h  PATH',  a  function containing
                     `typeset PATH' will create an ordinary local
                     parameter  without  the  usual  behaviour of
                     PATH.  Alternatively,  the  local  parameter
                     may  itself  be  given this attribute; hence
                     display the  value  of  the  parameter  when
                     listing  parameters;  the  display  for such
                     parameters is always as if the `+' flag  had
                     been  given.   Use  of  the  parameter is in
                     other respects normal, and the  option  does
                     not  apply  if the parameter is specified by
                     name, or by  pattern  with  the  -m  option.
                     This  is on by default for the parameters in
                     the zsh/parameter and  zsh/mapfile  modules.
                     Note,  however, that unlike the -h flag this
                     is also useful for non-special parameters.

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

              -E     Use  an  internal  double-precision floating
                     point representation.  On output  the  vari­
                     able  will  be converted to scientific nota­
                     tion.  If n is nonzero it defines the number
                     of   significant  figures  to  display;  the
                     default is ten.

              -F     Use an  internal  double-precision  floating
                     point  representation.   On output the vari­
                     able will be converted to fixed-point  deci­
                     mal  notation.   If  n is nonzero it defines
                     the number of digits to  display  after  the
                     decimal point; the default is ten.

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

              -r     The  given  names are marked readonly.  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
              limits  instead  of soft limits.  If the -S flag is
              given together with the -H flag set both  hard  and
              soft limits.  If no options are used, the file size
              limit (-f) is assumed.  If  limit  is  omitted  the
              current   value  of  the  specified  resources  are
              printed.  When more than one  resource  values  are
              printed  the  limit name and unit is printed before
              each value.

              -a     Lists all of the current resource limits.
              -c     512-byte blocks on the size of core dumps.
              -d     K-bytes on the size of the data segment.
              -f     512-byte blocks on the size of  files  writ­
                     ten.
              -l     K-bytes on the size of locked-in memory.
              -m     K-bytes on the size of physical memory.
              -n     open file descriptors.
              -s     K-bytes on the size of the stack.
              -t     CPU seconds to be used.
              -u     processes available to the user.
              -v     K-bytes  on  the size of virtual memory.  On
                     some systems this refers to the limit called
                     `address space'.

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

       unalias
              Same as unhash -a.

       unfunction
              Same as unhash -f.

       unhash [ -adfm ] name ...
              Remove the element named name from an internal hash
              table.  The default is  remove  elements  from  the
              command hash table.  The -a option causes unhash to
              remove aliases.  The -f  option  causes  unhash  to
              remove  shell  functions.   The  -d  options causes
              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  corre­
              sponding  hash  table  with  matching names will be
              removed.

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

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

              The  -v  flag specifies that name refers to parame­
              ters. This is the default behaviour.

              unset -f is equivalent to unfunction.

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

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

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

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

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

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

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

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

       zcompile [ -U ] [ -z | -k ] [ -R | -M ] file [ name ... ]
       zcompile -ca [ -m ] [ -R | -M ] file [ name ... ]
       zcompile -t file [ name ... ]
              This  builtin  command can be used to compile func­
              tions or scripts, storing the compiled  form  in  a
              file,  and to examine files containing the compiled
              form.  This allows faster autoloading of  functions
              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 compiled file.  If only the file argument
              is given, the output file has the  name  `file.zwc'
              and  will  be  placed  in the same directory as the
              file.   The  shell  will  load  the  compiled  file
              instead  of the normal function file when the func­
              tion is autoloaded; see  the  section  `Autoloading
              Functions'  in  zshfunc(1) for a description of how
              autoloaded functions are searched.   The  extension
              .zwc stands for `zsh word code'.

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

              The  second form, with the -c or -a options, writes
              the compiled definitions for all  the  named  func­
              tions  into  file.  For -c, the names must be func­
              tions currently defined in  the  shell,  not  those
              marked  for  autoloading.  Undefined functions that
              the file, and, at the end, call that function.   In
              such  cases  the  output  of `zcompile -c' does not
              include the additional  functions  defined  in  the
              file, and any other initialization code in the file
              is lost.  Using `zcompile  -a'  captures  all  this
              extra information.

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

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

              Other options:

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

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

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

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

                     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  ver­
                     sions   of  the  compiled  format,  one  for
                     big-endian machines and one for small-endian
                     machines.   The  upshot  of this is that the
                     compiled file is machine independent and  if
                     it  is  read or mapped, only one half of the
                     file is actually used (and mapped).

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

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

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

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

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

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

                     Each  module  has a boot and a cleanup func­
                     tion.  The module will not be loaded if  its
                     boot function fails.  Similarly a module can
                     only be unloaded  if  its  cleanup  function
                     runs successfully.

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

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

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

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

                     With  -ab  and  no arguments, all autoloaded
                     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 com­
                     mands.

                     If -b is used together with the  -u  option,
                     it  removes builtins previously defined with
                     -ab.  This is only possible if  the  builtin
                     If given no  condition  names,  all  defined
                     names  are  listed  (as a series of zmodload
                     commands if the -L option is given).

                     The  -uc  option  removes  definitions   for
                     autoloaded conditions.

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

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

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

              zmodload -e [ -A ] [ string ... ]
                     The  -e  option  without arguments lists all
                     loaded modules; if the  -A  option  is  also
                     given,   module   aliases  corresponding  to
                     loaded modules are also shown.   With  argu­
                     ments  only the return status is set to zero
                     if all strings given as arguments are  names
                     of  loaded modules and to one if at least on
                     string is not the name of a  loaded  module.
                     This  can be used to test for the availabil­
                     ity 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 mod­
                     ule  are  given,  define  modalias  to be an
                     alias for the module module.  If the  module
                     modalias  is  ever  subsequently  requested,
                     either via a call to zmodload or implicitly,
                     the   shell  will  attempt  to  load  module
                     instead.  If module is not given,  show  the
                     definition of modalias.  If no arguments are
                     given,  list  all  defined  module  aliases.
                     When listing, if the -L flag was also given,
                     list the definition as a zmodload command to
                     circular.  As the aliases take the same for­
                     mat as module names, they may  include  path
                     separators:   in  this  case,  there  is  no
                     requirement for any part of the  path  named
                     to  exist  as  the  alias  will  be resolved
                     first.   For  example,  `any/old/alias'   is
                     always a valid alias.

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

                     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  previ­
                     ously defined as a module alias via zmodload
                     -A,  delete  the  alias.   If  any  was  not
                     defined,  an error is caused and the remain­
                     der of the line is ignored.

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

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

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

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

       zregexparse

zsh 4.1.1                 June 18, 2003            ZSHBUILTINS(1)
  




Login
Nickname

Password

Security Code
Security Code
Type Security Code


Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!


Amazon Wish List

Did You Know?
You can help in many different ways.


Friends



Tell a Friend About Us

Bookmark and Share



Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.20 Seconds