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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       zmodload -e [ -A ] [ string ... ]
              The -e option without arguments lists all loaded modules;
              if  the  -A  option  is  also   given,   module   aliases
              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 avail-
              ability of things implemented by modules.  In this  case,
              any aliases are automatically resolved and the -A flag is
              not used.

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

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

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

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

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

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