Man Linux: Main Page and Category List


       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

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

       For  the  format of the recipe and the supported commands see the A-A-P
       web site:   You  may  find  it
       locally                                                              as

       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

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

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


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

                                  2003 Aug 7