AAP(1)                      General Commands Manual                     AAP(1)

       aap, a powerful build tool

       aap [-f recipe] [option ...] [VAR=value ...] [target ...]

       Aap executes recipes.  A recipe has the structure of a Makefile:
       dependencies and build commands.  Aap includes support for downloading,
       uploading, version control, Python commands and much more.

       The default recipe used is "main.aap" in the current directory.
       Another one may be specified with the "-f" argument.  For example, to
       use the recipe "doit.aap":

              aap -f doit.aap

              The recipe may be a URL.  It will be downloaded to the current
              directory before it is executed.  Example:

                     aap -f ftp://ftp.vim.org/pub/vim/runtime/main.aap

                     An alternative is to use the "-u" or "--up" argument to
                     search upwards in the directory tree for a "main.aap"

                     For the format of the recipe and the supported commands
                     see the A-A-P web site:
                     http://www.A-A-P.org/documentation.html.  You may find it
                     locally as /usr/local/share/doc/aap/html/index.html.

                     Here is an example for a recipe that compiles the
                     "foobar" program from three source files:

                            :program foobar : main.c common.c version.c

                            Target arguments indicate the files or virtual
                            targets that are to be built.  For example, this
                            command builds the two targets "foo" and "bar":

                                   aap foo bar

                                   When no target is specified on the command
                                   line, the "all" target specified in the
                                   recipe is built.  If there is no "all"
                                   target the programs and libraries specified
                                   with ":program", ":lib" and similar
                                   commands are built.  If none of these
                                   targets are specified this results in an

                                   Assignments take the form "VAR=value".
                                   "VAR" is the name of a variable and "value"
                                   the value assigned to it.  Example:

                                          aap GUI=motif

                                          Note that aap does not use
                                          environment variables for internal
                                          variables to avoid unexpected side
                                          effects.  Assignments on the command
                                          line do not overrule assignments in
                                          the recipe.

                                          Here is an example that uses all of
                                          the above arguments to use the
                                          recipe "foo.aap", set the "BUILD"
                                          variable to "debug" and build the
                                          "test" target:

                                                 aap -f foo.aap BUILD=debug test

       The options may be given in any order, before or after targets and
       assignments.  Options without an argument can be combined after a
       single dash.

       --          End of options, only targets and assignments follow.  Use
                   this if a target starts with "-".

       -a, --nocache
                   Always download files, do not use the cache.

       -c CMD, --command CMD
                   After reading the recipe execute CMD.  No targets are built
                   other than the one(s) specified in the command line.

       --changed FILE
                   The file FILE is considered changed, no matter whether it
                   was really changed.  Similar to the recipe command
                   ":changed FILE".

       -C, --contents
                   Targets are only considered outdated when file contents
                   changed, not when attributes or build signatures changed.
                   Useful after changing a "publish" attribute that should not
                   cause uploading or changing build commands that should not
                   trigger them to be executed.

       -d FLAGS, --debug FLAGS
                   Debug the specified items.  Not yet implemented.

       -f FILE, --recipe FILE
                   Specify the recipe to execute.  If this is omitted the
                   "main.aap" recipe will be used.

       -F, --force Force building targets even when they are up-to-date.

       -h, --help  Print a help message and exit.

       -I DIR, --include DIR
                   Directory to search for included recipes.

       --install PACKAGE
                   Install the package PACKAGE.  Only works for a few packages
                   that are supported, such as "scp" and "unzip".  Does not
                   read a recipe in the usual way, only the specified package
                   is installed.

       -j N, --jobs N
                   Maximum number of parallel jobs (not implemented yet).

       -k, --continue
                   Continue building after encountering an error. (Not fully
                   implemented yet)

       -l, --local Do not recurse into subdirectories.  Applies to the "add"
                   and "remove" targets.  Also for "revise" concerning
                   removing files.

       -n, --nobuild
                   Do not execute build commands, only display them.  Commands
                   at the toplevel and commands to discover dependencies will
                   still be executed.  System commands, commands that
                   download, upload, write or delete files and version control
                   commands are skipped.  ":child" and ":include" commands
                   won't work for recipes that have not been downloaded yet.

       -N, --nofetch-recipe
                   Do not fetch recipes when using the "fetch" or "update"
                   argument, only fetch files.

       --profile FILE
                   Profile execution and write the results in FILE.  Use the
                   Python pstats module to view the results.  The PrintProfile
                   module in aap lists the most useful info.

       -R, --fetch-recipe
                   For recipes that have a "fetch" attribute, obtain the
                   latest version (refresh).  This is done automatically for
                   the "refresh", "fetch" and "update" targets, unless
                   --nofetch-recipe was specified.

       -s, --silent
                   Print less information while executing recipes.

       -S, --stop  Stop building after encountering an error (this is the

       -t, --touch Do not execute build commands but do update signatures as
                   if they were built.  After doing this the specified targets
                   will be considered up-to-date.  Commands at the toplevel
                   will also be executed, except system commands, commands
                   that write a file and version control commands.

       -u, --search-up, --up
                   Search the directory tree upwards for a "main.aap" recipe.

       -v, --verbose
                   Print more information while executing recipes.

       -V, --version
                   Print version information and exit.

                      The aap documentation in HTML.

                      The aap documentation in PDF.  Useful for printing.

       AAPDIR/log, AAPDIR/log1, AAPDIR/log2, ..., AAPDIR/log9
                      The log file with detailed messages about executing a
                      recipe.  Older log files are called log1, log2, etc.

       For recent info see the A-A-P web site:

       aap exits with a non-zero value when something went wrong.

       Project leader for A-A-P is Bram Moolenaar <Bram@A-A-P.org>.

       Probably.  Not everything has been properly tested.  For recent info
       see the A-A-P web site:

                                  2003 Aug 7                            AAP(1)