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

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

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

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

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

              Each  module  has  a  boot  and  a   cleanup
              function.   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
              second  and  subsequent  arguments  will  be
              loaded  before the module named in the first
              argument.

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

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

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

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

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

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

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

              The   -uc  option  removes  definitions  for
              autoloaded 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
              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   corresponding   to
              loaded   modules   are   also  shown.   With
              arguments 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
              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 listing, if the -L flag was also given,
              list the definition as a zmodload command to
              recreate the alias.

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

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

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

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

       Note that zsh makes no distinction between  modules
       that  were  linked  into the shell and modules that
       are loaded dynamically. In both cases this  builtin
       command  has  to  be  used  to  make  available 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.
