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  functions  or  scripts,
       storing the compiled form in a file, and to examine files containing
       the  compiled form.  This allows faster autoloading of functions and
       sourcing 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 function is autoloaded; see the section  `Au-
       toloading  Functions'  in  zshmisc(1)  for  a description of how au-
       toloaded functions are searched.  The extension .zwc stands for `zsh
       word code'.

       If there is at least one name argument, all the named files are com-
       piled 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 def-
       initions for all the named functions into file.  For -c,  the  names
       must  be  functions currently defined in the shell, not those marked
       for autoloading.  Undefined functions that are marked for  autoload-
       ing  may  be written by using the -a option, in which case the fpath
       is searched and the contents of the definition files for those func-
       tions, if found, are compiled into file.  If  both  -c  and  -a  are
       given,  names of both defined functions and functions marked for au-
       toloading may be given.  In either  case,  the  functions  in  files
       written  with  the  -c  or  -a  option  will be autoloaded as if the
       KSH_AUTOLOAD option were unset.

       The reason for handling loaded  and  not-yet-loaded  functions  with
       different  options is that some definition files for autoloading de-
       fine multiple functions, including the function with the  same  name
       as the file, and, at the end, call that function.  In such cases the
       output  of  `zcompile  -c' does not include the 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.

       Note the second form cannot be used for compiling functions that in-
       clude redirections as part of the definition rather than within  the
       body of the function; for example

              fn1() { { ... } >~/logfile }

       can be compiled but

              fn1() { ... } >~/logfile

       cannot.  It is possible to use the first form of zcompile to compile
       autoloadable functions that include the full function definition in-
       stead of just the body of the function.

       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 arguments, nothing is output and the return status  is  set  to
       zero  if  definitions for all names were found in the compiled file,
       and non-zero if the definition 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 autoloadable functions,  it
              is  often  desirable  to use this option; otherwise the whole
              file, including the code to define functions which  have  al-
              ready  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.

       -k
       -z     These options are used when the compiled file contains  func-
              tions  which  are to be autoloaded. If -z is given, the func-
              tion will be autoloaded as if the KSH_AUTOLOAD option is  not
              set, even if it is set at the time the compiled file is read,
              while  if  the -k is given, the function will be loaded as if
              KSH_AUTOLOAD is set.  These options also take precedence over
              any -k or -z options specified to the  autoload  builtin.  If
              neither  of  these  options  is  given,  the function will be
              loaded as determined by the setting of the  KSH_AUTOLOAD  op-
              tion at the time the compiled file is read.

              These  options may also appear as many times as necessary be-
              tween the listed names to specify the loading  style  of  all
              following functions, up to the next -k or -z.

              The created file always contains two versions of the 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).
