NAME

       dunecontrol - Control program for the Dune build system

SYNOPSIS

       dunecontrol [OPTIONS] COMMANDS [COMMAND-OPTIONS]

DESCRIPTION

       dunecontrol is the control program for the build system of the Dune libraries.

       The  Dune  libraries  form a set of modules.  Each can be built independently using CMake.  Additionally,
       though, there are dependencies between modules, which are expected to  form  a  directed  acyclic  graph.
       These  dependencies  are  set  in  a file called dune.module contained in the main directory of each Dune
       module.

       The dunecontrol program helps to build sets of inter-dependent  modules.   It  allows  to  construct  the
       entire  dependency  graph  and  obtain information about it.  Then it allows to run various build-related
       commands for all modules.  These are executed in the order mandated by the dependency graph.

COMMANDS

       Colon-separated list of commands. Available commands are:

       help

              Show a help message and exit

       print

              Print the list of modules sorted according to their dependency relations

       info

              Same as `print', but including whether it is a dependency or suggestion

       printdeps

              Print recursive dependencies of a module

       vcsetup

              Setup version control repository (Git etc.) or working copy (SVN)

       update

              Update all modules from the repository from their respective version control systems

       configure

              Run cmake for each module

       make

              Run make for each module

       all

              Run the 'configure' and 'make' commands for each module

       exec

              Execute an arbitrary command in each module source directory

       bexec

              Execute an arbitrary command in each module build directory

       status

              Show version control status for each module

       svn

              Run svn command for each svn-managed module

       git

              Run git command for each git-managed module

       export

              Run eval `dunecontrol export` to save the list  of  dune.module  files  to  the  DUNE_CONTROL_PATH
              variable

OPTIONS

       -h, --help

              Show this help

       --debug

              Run with debugging output enabled

       --module=mod

              Apply the actions on module mod and all modules it depends on

       --only=mod

              Only apply the actions on module mod , but not on the modules it depends on

       --current

              Only apply the actions on the current module, the one whose source tree we are in

       --current-dep

              Apply the actions on the current module, and all modules it depends on

       --resume

              Resume a previous run (only consider the modules not built successfully on the previous run)

       --skipfirst

              Skip the first module (use with --resume)

       --skipversioncheck

              When looking for Dune modules, do not check whether they have the required versions

       --opts=file

              Load default options from file, for details see the section below.

              Instead  of  a  command  line  parameter,  it  is  also possible to define an environment variable
              DUNE_OPTS_FILE.

       --builddir=name

              Make out-of-source builds in a subdir name.

              If name is a relative path, this directory is created inside each module, if  it  is  an  absolute
              path, a subdirectory for each module is created inside.

              Instead  of  a  command  line  parameter,  it  is  also possible to define an environment variable
              DUNE_BUILDDIR (see below) or to specify a BUILDDIR variable in the opts file.

       --[COMMAND]-opts=opts

              Set options for COMMAND (this is mainly useful for the 'all' COMMAND)

OPTS FILE

       The options file contains different entries to specify the build environment, e.g. which compiler to use,
       which options to pass to cmake, where to build DUNE, etc.

       Variables are

       UNE_CONTROL_PATH

              just as the environment variable DUNE_CONTROL_PATH, it is possible to define  it  in  the  options
              file. For details see the description below.

       BUILDDIR=Ifname

              to specify the build directory, just as via the command line.  Defining the build directory in the
              opts  file,  allows  to  easily  switch  between  different  build  directories for different DUNE
              configurations.

       [COMMAND]_FLAGS=opts

              Set options for COMMAND, e.g. CMAKE_FLAGS, to specify parameters passed to the  specific  command.
              In case of cmake this might look as follows

              CMAKE_FLAGS="-DCMAKE_CXX_COMPILER=g++-11          -DCMAKE_CXX_FLAGS='-fPIC         -g         -O3'
              -DFOO_PREFIX=/path/to/libfoo"

              In case of make a common use case is to enable concurrency, e.g.

              MAKE_FLAGS="-j4"

ENVIRONMENT VARIABLES

       DUNE_CONTROL_PATH

              Colon-separated list to specify where dunecontrol searches for Dune modules.  Entries  are  either
              directories,  which  are  then  used  recursively  for  dune.module files or the user can directly
              specify the full path to specific dune.module files.

              default: The default for the case that  DUNE_CONTROL_PATH  is  empty  is  to  search  the  current
              directory, its subdirectories and a system-wide installation in /usr.

       DUNE_OPTS_FILE

              Specify a default value for an options file, if the user does not specify the --opts= parameter on
              the commandline.

       DUNE_BUILDIR

              Specify  a  default  value  for  an  build directory, if the user does not specify the --builddir=
              parameter on the commandline.

AUTHOR

       Dune was written by the Dune team (https://www.dune-project.org/community/people).

       This manual page was written by Oliver Sander and Christian Engwer.

COPYRIGHT

       Copying and distribution of this file, with or without modification, are permitted in any medium  without
       royalty provided the copyright notice and this notice are preserved.  This file is offered as-is, without
       any warranty.

                                                November 8, 2016                                  DUNECONTROL(1)