This fixes FS#1614.

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

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.

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.

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.

Similar to last commit:
This macro was split off from DuneMacros.cmake in commit
e63ea0cf, but the new macro file was
not included in the list of installed modules.

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

This macro was split off from DuneMacros.cmake in commit
e63ea0cf, but the new macro file was
not included in the list of installed macros.

It seems the exclusion macros need to have a full list of headers
to work. This is hopefully the last commit...

The property must exist in order to have the exclusion macros work.
I only tested dune common which has no exclusions...

Thanks to Andreas Buhr for noticing!

As proposed in FS1584, make headercheck is now disabled by
default in cmake. This fact and how to enable it is printed
upon "make headercheck".

Apparently, that code never for executed/tested...

Together with the last patch, this fixes FS#1592.

[Typetraits][Compatibility] Provide partial backwards compatibility for is_indexable on old GCC versions

Older GCC versions have some nasty bugs related to SFINAE and indexing
with operator[]. This patch adds a configuration check for those
problems and a partial backwards compatibility hack for those older
compilers that is sufficient for our current use case in the VTK
writer.

GCC 4.4, I'm looking at you

The file DuneMacros.cmake is very crowded. Macros that belong
together should be placed in a separate module in order to increase
the visibility of its documentation IMO.