zmodload [ -dL ] [ -s ] [ ... ]
zmodload -F [ -alLme -P param ] module [ [+-]feature ... ]
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 [ -is ] 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 speci-
              fied name followed by a standard suffix, usually `.so' (`.sl'
              on  HPUX).   If the module to be loaded is already loaded the
              duplicate module is ignored.  If zmodload detects  an  incon-
              sistency,  such  as an invalid module name or circular depen-
              dency list, the current code block  is  aborted.   If  it  is
              available,  the module is loaded if necessary, while if it is
              not available, non-zero status is silently returned.  The op-
              tion -i is accepted for compatibility but has no effect.

              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.

              If  the  module supports features (see below), zmodload tries
              to enable all features when loading a module.  If the  module
              was  successfully  loaded  but  not all features could be en-
              abled, zmodload returns status 2.

              If the option -s is given, no error is printed if the  module
              was  not  available (though other errors indicating a problem
              with the module are printed).  The return status indicates if
              the module was loaded.  This is  appropriate  if  the  caller
              considers the module optional.

              With  -u,  zmodload  unloads  modules.  The same name must be
              given that was given when the module was loaded,  but  it  is
              not  necessary  for  the  module to exist in the file system.
              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 suc-
              cessfully.

       zmodload -F [ -almLe -P param ] module [ [+-]feature ... ]
              zmodload  -F  allows more selective control over the features
              provided by modules.  With no options apart from -F, the mod-
              ule named module is loaded, if it was not already loaded, and
              the list of features is set to the  required  state.   If  no
              features  are  specified, the module is loaded, if it was not
              already loaded, but the state of features is unchanged.  Each
              feature may be preceded by a + to turn the feature on,  or  -
              to  turn  it  off;  the  + is assumed if neither character is
              present.  Any feature not explicitly mentioned is left in its
              current state; if the module was not previously  loaded  this
              means  any  such  features  will remain disabled.  The return
              status is zero if all features were  set,  1  if  the  module
              failed  to load, and 2 if some features could not be set (for
              example, a parameter couldn't be added because  there  was  a
              different  parameter  of  the  same  name) but the module was
              loaded.

              The standard features are  builtins,  conditions,  parameters
              and  math  functions; these are indicated by the prefix `b:',
              `c:' (`C:' for an infix condition), `p:'  and  `f:',  respec-
              tively,  followed  by the name that the corresponding feature
              would have in the shell.  For example, `b:strftime' indicates
              a builtin named strftime and p:EPOCHSECONDS indicates a para-
              meter named EPOCHSECONDS.  The module may provide other (`ab-
              stract') features of its own as indicated by  its  documenta-
              tion; these have no prefix.

              With  -l  or  -L, features provided by the module are listed.
              With -l alone, a list of features together with their  states
              is shown, one feature per line.  With -L alone, a zmodload -F
              command that would cause enabled features of the module to be
              turned  on  is  shown.   With -lL, a zmodload -F command that
              would cause all the features to be set to their current state
              is shown.  If one of these combinations is given with the op-
              tion -P param then the parameter param is set to an array  of
              features, either features together with their state or (if -L
              alone is given) enabled features.

              With  the  option  -L  the module name may be omitted; then a
              list of all enabled features for all modules  providing  fea-
              tures  is printed in the form of zmodload -F commands.  If -l
              is also given, the state of both enabled  and  disabled  fea-
              tures is output in that form.

              A  set of features may be provided together with -l or -L and
              a module name; in that case only the state of those  features
              is  considered.   Each  feature may be preceded by + or - but
              the character has no effect.  If no set of features  is  pro-
              vided, all features are considered.

              With  -e,  the command first tests that the module is loaded;
              if it is not, status 1 is returned.  If the module is loaded,
              the list of features given as an argument is  examined.   Any
              feature  given  with no prefix is simply tested to see if the
              module provides it; any feature given with a prefix + or - is
              tested to see if is provided and in the given state.  If  the
              tests  on  all  features in the list succeed, status 0 is re-
              turned, else status 1.

              With -m, each entry in the given list of features is taken as
              a pattern to be matched against the list of features provided
              by the module.  An initial + or - must be  given  explicitly.
              This may not be combined with the -a option as autoloads must
              be specified explicitly.

              With  -a,  the  given list of features is marked for autoload
              from the specified module, which may not yet be  loaded.   An
              optional  +  may appear before the feature name.  If the fea-
              ture is prefixed with -, any existing  autoload  is  removed.
              The  options  -l  and  -L may be used to list autoloads.  Au-
              toloading is specific to individual features; when the module
              is loaded only the requested feature  is  enabled.   Autoload
              requests are preserved if the module is subsequently unloaded
              until  an  explicit `zmodload -Fa module -feature' is issued.
              It is not an error to request an autoload for a feature of  a
              module that is already loaded.

              When  the  module  is loaded each autoload is checked against
              the features actually provided by the module; if the  feature
              is  not  provided the autoload request is deleted.  A warning
              message is output; if the module is being loaded to provide a
              different feature, and that autoload is successful, there  is
              no  effect on the status of the current command.  If the mod-
              ule is already loaded at the time when zmodload -Fa  is  run,
              an error message is printed and status 1 returned.

              zmodload  -Fa  can be used with the -l, -L, -e and -P options
              for listing and testing the existence  of  autoloadable  fea-
              tures.  In this case -l is ignored if -L is specified.  zmod-
              load  -FaL  with  no module name lists autoloads for all mod-
              ules.

              Note that only standard features as described  above  can  be
              autoloaded;  other  features  require the module to be loaded
              before enabling.

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

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

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

       zmodload -ab [ -L ]
       zmodload -ab [ -i ] name [ builtin ... ]
       zmodload -ub [ -i ] builtin ...
              The  -ab  option defines autoloaded builtins.  It defines the
              specified builtins.  When any of those  builtins  is  called,
              the  module specified in the first argument is loaded and all
              its features are enabled (for selective control  of  features
              use  `zmodload  -F -a' as described above).  If only the name
              is given, one builtin is defined, with the same name  as  the
              module.   -i  suppresses  the error if the builtin is already
              defined or autoloaded, but not if another builtin of the same
              name is already defined.

              With -ab  and  no  arguments,  all  autoloaded  builtins  are
              listed,  with  the module name (if different) shown in paren-
              theses 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).

              Autoload  requests are retained if the module is subsequently
              unloaded until an explicit `zmodload -ub builtin' is issued.

       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  zmod-
              load 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.  If  arguments  are  provided,
              nothing  is  printed; the return status is set to zero if all
              strings given as arguments are names of loaded modules and to
              one if at least on string is not the name of a loaded module.
              This can be used to test for the availability of  things  im-
              plemented by modules.  In this case, any aliases are automat-
              ically resolved and the -A flag is not used.

       zmodload -A [ -L ] [ modalias[=module] ... ]
              For each argument, if both modalias and module are given, de-
              fine  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 defin-
              ition of modalias.  If no arguments are given, list  all  de-
              fined  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 indepen-
              dent 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 sepa-
              rators:  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 stan-
              dard shell modules and which resolves to a different  module.
              However,  if a module has dependencies, it will not be possi-
              ble to use the module name as an alias as the module will al-
              ready 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.
