Ansgar Burchardt authored 9 years ago and Christoph Grüninger committed 9 years ago

(cherry picked from commit d22ed390)

Ansgar Burchardt authored 9 years ago and Christoph Grüninger committed 9 years ago

(cherry picked from commit a5d7774e)

This fixes FS#1614.

(cherry picked from commit f12adb99)

The Metis test used the wrong one and I copied it for PTScotch... :/

This test has been added while the dune_enable_all_packages
feature was developed...

This branch adds the required infrastructure to automatically enable all
external packages and Dune-internal libraries for all targets inside a
given Dune modules. For this purpose, it adds a number of new CMake
macros:

- dune_enable_all_packages is the central macro that needs to be called
  in the main CMakeLists.txt of your project.

- dune_library_add_sources is an optional macro that you only need if
  your project also contains a library and you want your executables to
  automatically link against that library. Note that this support
  requires CMake 3.1. Most user modules don't create their own libraries
  and can thus ignore this macro.

- dune_register_package_flags has to be called in all configuration
  tests to register the outcome of the test so that
  dune_enable_all_packages can automatically add the required compiler
  and linker flags required to use the library that the configuration
  test has been written for.

The branch also adds the required calls to dune_register_package_flags
to all configuration tests in dune_common.

There is a similar branch in dune-grid that updates the configuration
tests in that module.

* feature/FS1557-add-all-flags-by-default-infrastructure:
  [CMake] dune_library_add_sources: Add some sanity checks
  [CMake] dune_enable_all_packages: Add sensible scoping to macro variables
  [CMake] Avoid duplicate version warnings in dune_library_add_sources
  [CMake] dune_enable_all_packages(): Add version check to library support
  [CMake] Clean up dune_enable_all_packages() and fix library handling
  [CMake][ParMETIS] Fix some typos in dune_register_package_flags() call
  [CMake] Export project revision as ProjectVersionRevision
  Fix c&p error in verbosity code
  Introduce an APPEND parameter on the dune_register_package_flags macro
  Issue a warning when the registry macros parameters cannot be parsed
  Introduce an optional VERBOSE argument on the dune_enable_all_packages macro
  Introduce a macro dune_register_package flags to be used by find modules
  [CMake] Move the enable_all_packages feature to a separate module
  Update the duneproject script to ask the user whether to use all flags
  Introduce a macro that adds all flags to all targets
  Update all find scripts split definitions from includes
  Split ALL_PKG_FLAGS into ALL_PKG_DEFS and ALL_PKG_INCS

This patch adds some sanity checks to dune_library_add_sources:

- Make sure that dune_enable_all_packages has been called

- Test whether the library has been declared in the MODULE_LIBRARIES
  argument of dune_enable_all_packages

In case of an error, the macro aborts the CMake run with a fatal error.

All variables defined in the macros stick around forever, so add a scope
matching the macro name to avoid name clashes.

The check for a correct cmake_minimum_version already happened in
dune_enable_all_packages, so let's avoid spamming the user...

The library support in dune_enable_all_packages (more specifically, the
ability to add source files to an existing library target with
dune_library_add_sources) relies on target_sources, which only exists in
CMake 3.1+.

To avoid confusing users, this patch emits a meaningful error for older
versions of CMake and generates a warning for more recent versions. This
warning can be disabled by defining
DUNE_ENABLE_ALL_PACKAGES_SILENCE_LIBRARY_WARNING.

...unless specificially set to false by the user.

Needed to properly support pthreads.
The copied file is modified because of
- lacking support of INTERFACE in older CMake versions
- difficulties finding default FindPackageHandleStandardArgs

Commit 	29405741 accidentally changed the file
permissions to non-executable.

* feature/FS1612-improve-error-massage-for-missing-MPIHelper:
  [MPI] Check that MPI was initialized when constructing a CollectiveCommunication

This check was added to improve the error message returned when using
MPI without correctly initializing it (e.g. by creating a parallel
grid), see FS#1612 for further information.

This reverts commit 5f053401.

I was a little hasty in cherry-picking this from the dune_enable_all_packages()
branch, as it needs some infrastructure from over there.

dune_enable_all_packages() doesn't really work if a module contains
libraries (it triggers CMP022 and CMP038). This patch works around that
problem and also adds a number of convenience features to the overall
mechanism. In particular:

- dune_enable_all_packages() now accepts optional lists of additional
  include directories and compile definitions that will be applied to
  all targets in the module. There is a new option APPEND that controls
  the placement of those compiler arguments, analogous to
  dune_register_package_flags().

- Libraries need special handling to work around the problem with the
  two CMake policies listed above. Those get triggered because libraries
  defined in the module ended up linking to themselves, and newer
  versions of CMake really don't like that. We can avoid this problem by
  exploiting the fact that the set of libraries contained in
  link_libraries is evaluated only once, at the point when a target is
  created. So we only have to make sure that libraries inside the module
  are created before they are added to link_libraries(). But we have to
  be careful to make sure that link_libraries() is called before the
  user creates any targets that depend on the module library.
  In order to minimize the risk of user error, I have integrated those
  two tasks (creating the library and adding it to link_libraries())
  into the dune_enable_all_packages() macro. So this macro now accepts a
  list of library names (as the multi argument MODULE_LIBRARIES). These
  are automatically created using dune_add_library() (placing them in
  lib/) in the order that they are listed and added to link_libraries()
  afterwards. Users MUST use this mechanism if they want the library to
  be linked automatically to programs in the module. On the other hand,
  you can still manually create libraries, but then you have to link to
  them manually (e.g. the Alberta libs in dune-grid).

- There is a new macro dune_library_add_sources() that can be used to add
  source files to libraries created with the help of
  dune_enable_all_packages(). That macro can be called repeatedly and in
  any subdirectory of the source tree. Using this facility, I think we
  can mostly get rid of OBJECT libraries. :-)

- CMake doesn't like to create a target without any source files, so the
  patch generates a small stub source for each library that contains two
  functions that are named after the library and return the version of
  the associated dune module.

CMake exports the major and minor components of the module version, but
not the revision. This patch fixes that omission.

CMake exports the major and minor components of the module version, but
not the revision. This patch fixes that omission.

I was bitten again by not properly cleaning build directories
while testing build system features. With this patch, the feature
* builds the symlinks in finalize_project instead of dune_project
  Only there the existence of the subdirectories in the build tree
  is guaranteed.
* The globbing expression is sane again.
* Properly excludes build directories
* works with cmake 2.8 and 3.1, per-module or global out-of-source builds.

We got the workaround_9220 code from Eigen. Now we
use the code as the Eigen project does, see for
example their file lapack/CMakeLists.txt.
This fixes the Fortran detection with Visual Studio
2015 CTP 6.

* master:
  Allow enabling dune_symlink_to_source_tree from the opts file
  Fix dune_symlink_to_source_tree for cmake 3.1

Patching the dune core modules just to have the advantages of
symlinks to the source tree is a bad idea. The patch introduces
a check for the variable DUNE_SYMLINK_TO_SOURCE_TREE instead, which
enables the macro if set.

CMake 3.1 issued a lot of warnings because it tried to symlink:
- git specific subdirs that are not present in the build tree
- build directories that are a subdir of the source instead of a sibling

The change
- adds a symlink iff a CMakeLists file was found in the source dir.
- excludes such build directory.

* master: (82 commits)
  [Type] Fix documentation of DuneSymlinkOrCopy
  [CMake][CPack] Set some basic CPack wariables for tarballs.
  [CMake] Don't search for malloc.h, stdint.h and memory.
  [CMake] Don't output twice that we generate Doxyfile.in.
  [CMake] Doxygen ignores existens of doc/doxygen/html/index.html in src
  [duneproject] use CMake variable for install dir
  [duneproject] fix typos in README
  [duneproject] remove empty lines at beginning and end of generated files
  [Autotools] Install DuneSymlinkOrCopy.cmake
  [CMake] install DuneSymlinkOrCopy.cmake
  [Cmake][bugfix] Still do the header globbing
  [Cmake][bugfix] Fix error in making headercheck configurable
  [CMake] make the headercheck feature configurable
  [bugfix] fix typos in add_dune_library
  [cleanup] Replace or and not by || and !.
  [m4] fix mixup when using autools/cmake 2.4 + an installed 2.3
  [bugfix] inlcude header algorithm to pass headercheck
  [dunecontrol] check for left over la files
  [reservedvector] allow to construct a reserved vector from an initializer_list
  Document new option --current-dep on the man page
  ...

Tarballs can be built using "make package_source". But they contain
all files from the source directory. There is a way to ignore files.

We assume anyway that stdint.h and memrory are provided. The
according macros are never used. They were probably provided
to stay as compatible to Autotools as possible.
This fixes FS#1605.

It is already printed as the comment of the custom command.

Felix Gruber authored 10 years ago and Christoph Grüninger committed 10 years ago

The install path for header files can be configured in CMake with the
variable ${CMAKE_INSTALL_INCLUDEDIR}.