diff --git a/.gitignore b/.gitignore
index 1d306b5f7fd776dd520ffc01cc738bcb2ca2698b..45cc03a8b75d01f0f15905f4844f3eb862a908f9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,13 @@
Makefile
Makefile.in
-config.*
+config.guess
+config.h.in
+config.log
+config.status
+config.h
+config.lt
+config.sub
+configure
configure
aclocal.m4
autom4te.cache
@@ -19,3 +26,8 @@ ltmain.sh
.libs
dependencies.m4
dune.css
+config.h.in
+config.h
+config.log
+config.guess
+
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1b7cb29caa5e09336cdaea4db7aa952132bbc5b8
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,31 @@
+# set up project
+project("dune-common" C CXX)
+
+# general stuff
+cmake_minimum_required(VERSION 2.8.6)
+message("CMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}|")
+# make sure our own modules are found
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/modules")
+message("CMAKE_MODULE_PATH=${CMAKE_MODULE_PATH}")
+# set the script dir for the macros.
+set(DUNE_COMMON_SCRIPT_DIR "${PROJECT_SOURCE_DIR}/cmake/scripts")
+
+#include the dune macros
+include(DuneMacros)
+
+# start a dune project with information from dune.module
+dune_project()
+
+# add subdirectories to execute CMakeLists.txt there
+add_subdirectory("lib")
+add_subdirectory("dune")
+add_subdirectory("bin")
+add_subdirectory("m4")
+add_subdirectory("am")
+add_subdirectory("doc")
+add_subdirectory("cmake/modules")
+add_subdirectory("cmake/scripts")
+
+# finalize the dune project, e.g. generating config.h etc.
+finalize_dune_project()
+include(CPack)
diff --git a/Makefile.am b/Makefile.am
index f3f3b446880d522edca6c7a31e49238d4c81c82c..3281582d234b7c250a6a30ddda5531f176e50fad 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,16 +1,20 @@
# $Id$
# we need the module file to be able to build via dunecontrol
-EXTRA_DIST=dune.module
+EXTRA_DIST= CMakeLists.txt dune.module dune-common-config.cmake.in dune-common-version.cmake.in
# don't follow the full GNU-standard
# we need automake 1.9 or newer
AUTOMAKE_OPTIONS = foreign 1.9
-SUBDIRS = dune lib doc bin m4 am
+SUBDIRS = cmake dune lib doc bin m4 am
# use configured compiler for "make distcheck"
DISTCHECK_CONFIGURE_FLAGS = CXX="$(CXX)" CC="$(CC)" --enable-parallel=@ENABLE_PARALLEL@ MPICC="$(MPICC)"
include $(top_srcdir)/am/global-rules
include $(top_srcdir)/am/top-rules
+
+# Distribute and install config.h.cmake
+configdir = $(datadir)/dune-common
+dist_config_DATA = config.h.cmake
diff --git a/am/CMakeLists.txt b/am/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..47e3e52d80ae9fa13dc209b0eae115220617c10b
--- /dev/null
+++ b/am/CMakeLists.txt
@@ -0,0 +1,14 @@
+install(PROGRAMS
+ checklog
+ documentation
+ doxygen
+ global-rules
+ headercheck
+ inkscape.am
+ latex
+ no-check-without-lib
+ sourcescheck
+ top-rules
+ webstuff
+ DESTINATION ${CMAKE_INSTALL_DATADIR}/am
+)
diff --git a/am/Makefile.am b/am/Makefile.am
index d4df39c4aa6cf2db04609900332c672295c3ca42..4b80086c781444941aa377eca009a395ed6f66bb 100644
--- a/am/Makefile.am
+++ b/am/Makefile.am
@@ -1,6 +1,6 @@
# $Id$
-EXTRA_DIST = inkscape.am webstuff global-rules sourcescheck \
+EXTRA_DIST = CMakeLists.txt inkscape.am webstuff global-rules sourcescheck \
no-check-without-lib latex checklog doxygen top-rules \
headercheck documentation
diff --git a/bin/CMakeLists.txt b/bin/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3213d8412da3601d11c452060d43c4d150b866b7
--- /dev/null
+++ b/bin/CMakeLists.txt
@@ -0,0 +1,8 @@
+install(PROGRAMS
+ am2cmake.py
+ dunedoxynize
+ duneproject
+ dunecontrol
+ mpi-config
+ dune-autogen
+ DESTINATION ${CMAKE_INSTALL_BINDIR})
diff --git a/bin/Makefile.am b/bin/Makefile.am
index 89779dfd6a9b4aaa48ac602a232b4d78c8be248a..e3bdcd124628318766a27ec03daf8ea915ce621c 100644
--- a/bin/Makefile.am
+++ b/bin/Makefile.am
@@ -1,7 +1,7 @@
# $Id$
# put scripts into dist-tarball
-EXTRA_DIST = duneproject dunecontrol \
+EXTRA_DIST = am2cmake.py CMakeLists.txt duneproject dunecontrol \
dunedoxynize \
mpi-config dune-autogen \
xfail-compile-tests
diff --git a/bin/am2cmake.py b/bin/am2cmake.py
new file mode 100755
index 0000000000000000000000000000000000000000..2c50a1ce2c94eacb15fa836163202ff0d4db8026
--- /dev/null
+++ b/bin/am2cmake.py
@@ -0,0 +1,880 @@
+#!/usr/bin/python
+import sys
+import re
+import os
+import fnmatch
+import errno
+from optparse import OptionParser
+from pyparsing import *
+
+class rem_proc:
+ def __init__(self, name):
+ self.name=name
+ self.found=False
+ def parse(self,tokens):
+ self.found=True
+ def foreach_begin(self):
+ return "\nforeach(i ${"+self.name+"})\n"
+
+ def foreach_end(self):
+ return "endforeach(i ${"+self.name+"})\n"
+
+ def process_SUBDIRS(self):
+ return ''.join([self.foreach_begin(),
+ " if(${i} STREQUAL \"test\")\n",
+ " set(opt EXCLUDE_FROM_ALL)\n",
+ " endif(${i} STREQUAL \"test\")\n",
+ " add_subdirectory(${i} ${opt})\n"+self.foreach_end()])
+
+ def process(self):
+ s=""
+ if self.found:
+ s= getattr(self, "process_%s" % self.name)()
+ return s
+
+
+ def process_TESTS(self):
+ return ''.join(['\n',
+ self.foreach_begin(),
+ " add_test(${i} ${i})\n",
+ self.foreach_end()])
+
+ def process_XFAIL_TESTS(self):
+ return ''.join(['\n#Set properties for failing tests\n',
+ 'set_tests_properties(\n',
+ ' ${XFAIL_TESTS} PROPERTIES\n',
+ ' WILL_FAIL true)'])
+
+ def process_COMPILE_XFAIL_TESTS(self):
+ return ''.join(['# Add test for programs that should not compile',
+ '\nforeach(_TEST ${COMPILE_XFAIL_TESTS})\n'
+ ' add_test(NAME ${_TEST}',
+ ' COMMAND ${CMAKE_COMMAND} --build . --target ${_TEST} --config $<CONFIGURATION>)\n',
+ 'endforeach(_TEST)\n',
+ 'set_tests_properties(${COMPILE_XFAIL_TESTS}\n',
+ ' PROPERTIES WILL_FAIL true)'])
+
+
+def parse_dependency(tokens):
+ tokens[0][0]='add_dependencies('+tokens[0][0]+' '
+ tokens[0][-1]=tokens[0][-1]+')'
+
+def comment_lines(tokens):
+ tokens[0][0]='# The following lines are comment out as the translation is not clear. TODO review\n#\n# '+tokens[0][0]
+ if len(tokens[0])>0:
+ for i in range(1, len(tokens[0])):
+ if tokens[0][i] == '\n':
+ tokens[0][i]='\n#'
+
+def repl_gnudir(m):
+ #print "gnudir %s" % m
+ return "CMAKE_INSTALL_"+m.upper()
+
+def parse_sources(tokens):
+ target=re.sub('_$', '', tokens[0][0])
+ tokens[0][0]='add_executable('+target+' '
+ tokens[0][-1]=tokens[0][-1]+')'
+
+class installer:
+ def __init__(self, name):
+ self.name = name
+ self.found_dirs = set()
+ self.regex= re.compile(r'(?P<prefix>\S+[^_])_'+self.name)
+ self.install_prefix = {
+ 'SCRIPTS': 'PROGRAMS',
+ 'DATA': 'FILES',
+ 'PROGRAMS': 'TARGETS',
+ 'LIBRARIES': 'TARGETS',
+ 'HEADERS': 'FILES',
+ 'check_PROGRAMS': ''
+ }[name]
+ def create_parser(self,lowercase_name,opt_ws,equals,value):
+ parser=Group(Combine(Optional(lowercase_name)+self.name)+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ return parser
+ def parse(self,tokens):
+ #import pdb; pdb.set_trace()
+ m=self.regex.match(tokens[0][0])
+ if m:
+ self.found_dirs.add(m.group('prefix'))
+ else:
+ self.found_dirs.add('')
+
+ def process(self):
+ #import pdb; pdb.set_trace()
+ s=""
+ for i in self.found_dirs:
+ if i:
+ install_dir=i+'dir'
+ else:
+ install_dir=repl_gnudir({
+ 'SCRIPTS': 'bindir',
+ 'DATA': 'datadir',
+ 'PROGRAMS': 'bindir',
+ 'LIBRARIES': 'libdir',
+ 'HEADERS': 'includedir'
+ }[self.name])
+ if not (i == ""):
+ var=""+i+'_'+self.name
+ else:
+ var=self.name
+ if not (var.strip().startswith('noinst_')
+ or var.strip().startswith('check_')
+ or var.strip().startswith('dist_noinst_')):
+ s= s+"\ninstall("+self.install_prefix+" ${"+var+"} DESTINATION ${"+install_dir+"})"
+ return s
+
+class target_flags:
+ def __init__(self, suffix):
+ self.suffix=suffix
+ self.known_flags = {
+ 'ALBERTA_': ['add_dune_alberta_flags',''],
+ 'AM_': ['target_link_libraries', '${DUNE_LIBS}'],
+ 'ALUGRID_': ['add_dune_alugrid_flags',''],
+ 'UG_': ['add_dune_ug_flags', ''],
+ 'SUPERLU_': ['add_dune_superlu_flags', ''],
+ 'DUNEMPI': ['add_dune_mpi_flags', ''],
+ 'AMIRAMESH_': ['add_dune_amiramesh_flags',''],
+ 'BOOST_': ['add_dune_boost_flags',''],
+ 'GMP_': ['add_dune_gmp_flags',''],
+ 'GRAPE_': ['add_dune_grape_flags',''],
+ 'PARMETIS_': ['add_dune_parmetis_flags',''],
+ 'PETSC_': ['add_dune_petsc_flags',''],
+ 'PSURFACE_': ['add_dune_psurface_flags','']
+ }
+ for i in range(1,9):
+ self.known_flags.update({
+ 'ALBERTA'+str(i)+'D_' : ['add_dune_alberta_flags', ''+'GRIDDIM '+str(i)]})
+ def parse(self, stri,loc,tokens):
+ #print 'target_flags'
+ #print self.suffix
+ #print tokens
+ if (self.suffix == 'CPPFLAGS' or self.suffix=='CXXFLAGS'):
+ line=''.join(tokens[0])
+ s=''
+ for key, value in self.known_flags.items():
+ if line.find(key)>-1:
+ s+='\n'+value[0]+'('+re.sub(r'set\((.*)_', '\\1',tokens[0][0])+value[1]+')'
+ tokens[0]=s
+ #print tokens
+ else:
+ comment_lines(tokens)
+
+class dir_parser:
+ def __init__(self):
+ self.has_doxygen=False
+ def parse_dir(self,stri,loc,tokens):
+ #import pdb; pdb.set_trace()
+ #print "parse_dir"
+ #print tokens
+ tokens[0][1]=''.join(tokens[0][1:])
+ if tokens[0][1].find('doxygen')>-1:
+ self.has_doxygen=True
+ #print range(2, len(tokens[0]))
+ if len(tokens[0]) >=2:
+ for i in range(2, len(tokens[0])):
+ tokens[0].pop()
+ #print tokens
+ #print "str="+stri+" |"
+ #print "loc="+str(loc)+" |"
+ #print tokens[0][1]
+ #for i in range(0,len(tokens[0])):
+
+ tokens[0][1]=re.sub(r'\$\{([a-z]+dir)\}(\S*)\)', (lambda m: "${"+repl_gnudir(m.group(1))+"}"+m.group(2)+')'), tokens[0][1])
+ #print tokens[0][1]
+ tokens[0][1]=tokens[0][1].replace('${CMAKE_INSTALL_DATADIR}/doc',
+ '${CMAKE_INSTALL_DOCDIR}')
+ tokens[0][1]=tokens[0][1].replace('${CMAKE_INSTALL_DATAROOTDIR}/doc',
+ '${CMAKE_INSTALL_DOCDIR}')
+ #print tokens
+
+ def process(self):
+ if self.has_doxygen:
+ return '\n\n# Create and install doxygen documentation\nadd_doxygen_target()\n'
+ else:
+ return ''
+
+def parse_include(tokens):
+ tokens[0][0]='# include not needed for CMake\n# '+tokens[0][0]
+
+def parse_if(tokens):
+
+ expression = tokens[0][1]+' '
+ tokens[0][0] ='if('
+ tokens[0][2] =')\n'
+ tokens[0][len([0])-2] ='endif('+expression+')'
+ if tokens[0].elsestart :
+ tokens[0][4] ='else('+expression+')'
+
+def parse_assign(tokens):
+ tokens[0][0]='set('+tokens[0][0]+' '
+ tokens[0][-1]=tokens[0][-1]+')'
+
+def parse_append(tokens):
+ tokens[0][0]='list(APPEND '+tokens[0][0]+' '
+ tokens[0][-1]=tokens[0][-1]+')'
+
+
+def parse_var(stri,loc,tokens):
+ #print "parse_var"
+ #print tokens
+ #print "str="+stri+" |"
+ #print "loc=%s|" % loc
+ tokens[0]='${'+tokens[0]+'}'
+ #print tokens
+
+def rename_var(tokens):
+ #print 'rename_var |%s|' % tokens[0]
+ #print tokens
+ name = re.sub('[ ]*([a-zA-Z0-9_])[ ]*[\n]?', '\\1', tokens[0])
+ #print '|%s|' %name
+ tokens[0]={
+ 'ALBERTA': 'ALBERTA_FOUND',
+ 'ALUGRID': 'ALUGRID_FOUND',
+ 'AMIRAMESH': 'AMIRAMESH_FOUND',
+ 'CONVERT': 'CONVERT_FOUND',
+ 'DUNEWEB': 'DUNEWEB_FOUND',
+ 'EIGEN': 'EIGEN_FOUND',
+ 'GLUT': 'GLUT_FOUND',
+ 'GMP': 'GMP_FOUND',
+ 'GRAPE': 'GRAPE_FOUND',
+ 'INKSCAPE': 'INKSCAPE_FOUND',
+ 'MPI': 'MPI_FOUND',
+ 'PARDISO': 'PARDISO_FOUND',
+ 'PETSC': 'PETSC_FOUND',
+ 'PSURFACE': 'PSURFACE_FOUND',
+ 'SUPERLU': 'SUPERLU_FOUND',
+ 'TEX4HT': 'TEX4HT_FOUND',
+ 'UG': 'UG_FOUND',
+ 'WML': 'WML_FOUND'}.setdefault(name, tokens[0])
+ if name.startswith('HAVE_DUNE'):
+ tokens[0]=re.sub(r'have-(.*)$', '\\1', name.lower().replace('_','-'))+'_FOUND'
+ #print tokens[0]
+
+#print rename_var(['bla'])
+#print rename_var(['UG'])
+#print rename_var(['A'])
+change_var2=1
+
+def parse_var2(stri,loc,tokens):
+ if change_var2:
+ tokens[0]='${'+tokens[0]+'}'
+ else:
+ tokens[0][0]='@'+tokens[0][0]+'@'
+
+class is_present:
+ def __init__(self):
+ self.found=False
+ def parse(self,tokens):
+ self.found=True
+
+def repl_tabs(tokens):
+ for i in range(0, len(tokens)):
+ tokens[i]=tokens[i].replace('\t', ' ')
+
+def am_2_cmake_string(amstring):
+ ParserElement.setDefaultWhitespaceChars("")
+ word = Word(alphanums+"*:.-_=<>&!;,/")
+ ws=Word(' ')
+ opt_ws=Optional(ws)
+ varopen = Literal("$(")#.replaceWith("${")
+ varclose = Literal(")")#.replaceWith("}")
+ var = Combine(varopen.suppress() + Word(alphanums+"_-")+varclose.suppress())
+ var.addParseAction(rename_var)
+ var.addParseAction(parse_var)
+ var2 = Combine(Literal("@").suppress() +Word(alphanums+"_-")+Literal("@").suppress())
+ var2.setParseAction(parse_var2)
+ wordorvar = var|var2| word
+ qwordorvar=("\""+wordorvar+"\"")|wordorvar
+ NL = opt_ws.suppress() + Or(lineEnd,stringEnd)
+ #NL.setDebug()
+ multiple_words = wordorvar + ZeroOrMore( opt_ws + wordorvar)
+ qmultiple_words = ("\""+multiple_words+"\"")|multiple_words
+ word_line = qmultiple_words+ZeroOrMore(opt_ws+qmultiple_words)
+ comment = Group('#'+ restOfLine('commenttext'))
+ continuation = Suppress('\\')+LineEnd()
+ #continuation.setDebug()
+ equals = Literal("=").suppress()
+ value = ZeroOrMore(opt_ws + Optional(word_line) + opt_ws + continuation)+ opt_ws+ word_line
+ name = Word(alphanums+"_-")
+ beginif = Literal("if")
+ #beginif.setDebug()
+ lines = Forward()
+ ifexpression = restOfLine + NL
+ ifexpression.setParseAction(rename_var)
+ ifbody = Group(lines)
+ endif = Literal('endif')+restOfLine.suppress()
+ elsestatement = Forward()
+ elsestatement << (opt_ws+ Literal('else').setResultsName('elsestart') + NL + Group (lines))
+ #endif.setDebug()
+ ifstatement =Forward()
+ ifstatement << Group(beginif + ifexpression + Group(lines) + Optional(elsestatement) + opt_ws + endif)#+ NL# +endif #+ NL
+ #ifstatement.setDebug()
+ ifstatement.setParseAction(parse_if)
+
+ varAssign = Group(name + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ varAssign.setParseAction(parse_assign)
+
+ docsAssign = Group(Or(Literal("DOCFILES"), Literal("DOCFILES_EXTRA"))+ Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ docsAssign.setParseAction(parse_assign)
+ docs_present = is_present()
+ docsAssign.addParseAction(docs_present.parse)
+ varAddAssign = Group(name + Suppress(opt_ws) + Literal('+=').suppress() + Suppress(opt_ws) + Optional(value))
+ varAddAssign.setParseAction(parse_append)
+
+ # Grammar for <lowercase>dir. A parser is needed to convert the GNU autoconf dirs to
+ # CMAKE GNU dirs.
+ dir_name = Regex("[a-z0-9_-]+dir")#Word(srange("[a-z0-9_-]"))
+ dirAssign=Group(dir_name+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ dirAssign.setParseAction(parse_assign)
+ dirParser = dir_parser()
+ dirAssign.addParseAction(dirParser.parse_dir)
+ #dirAssign.setDebug()
+
+ lowercase_name_= Regex("[a-z0-9_-]+_")
+
+ cppflagsAssign = Group(lowercase_name_+'CPPFLAGS' + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ cppflagsAssign.addParseAction(parse_assign)
+ cppflags=target_flags('CPPFLAGS')
+ cppflagsAssign.addParseAction(cppflags.parse)
+
+ cxxflagsAssign = Group(lowercase_name_+'CXXFLAGS' + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ cxxflags=target_flags('CXXFLAGS')
+ cxxflagsAssign.addParseAction(parse_assign)
+ cxxflagsAssign.addParseAction(cxxflags.parse)
+
+ ldflagsAssign = Group(lowercase_name_+'LDFLAGS' + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ ldflagsAssign.addParseAction(parse_assign)
+ ldflags=target_flags('LDFLAGS')
+ ldflagsAssign.addParseAction(ldflags.parse)
+
+ ldaddAssign = Group(lowercase_name_+'LDADD' + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ ldaddAssign.addParseAction(parse_assign)
+ ldadd=target_flags('LDADD')
+ ldaddAssign.addParseAction(ldadd.parse)
+
+ libsAssign = Group(lowercase_name_+'LIBS' + Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ libsAssign.addParseAction(parse_assign)
+ libs=target_flags('LIBS')
+ libsAssign.addParseAction(libs.parse)
+
+
+
+
+ # Process dir_SOURCES assignment
+ sourcesAssign = Group(lowercase_name_+Suppress(Literal("SOURCES"))+Suppress(opt_ws)+ equals + Suppress(opt_ws) + Optional(value))
+ sourcesAssign.setParseAction(parse_sources)
+
+ # Process <dir>_DATA assignment
+ data_install = installer("DATA")
+ dataAssign = data_install.create_parser(lowercase_name_, opt_ws, equals, value)
+ #dataAssign.setDebug()
+ dataAssign.addParseAction(data_install.parse)
+ dataAssign.addParseAction(parse_assign)
+ #dataAssign.addParseAction(lambda tokens: data_install.parse(tokens))
+
+ # Process check_Programs but never install them
+ check_programs = installer("check_PROGRAMS")
+ check_programsAssign = check_programs.create_parser(lowercase_name_, opt_ws, equals, value)
+
+ # Process <dir>_PROGRAMS assignment
+ programs_install = installer("PROGRAMS")
+ programsAssign = programs_install.create_parser(lowercase_name_, opt_ws, equals, value)
+ programsAssign.addParseAction(programs_install.parse)
+ programsAssign.addParseAction(parse_assign)
+
+ # Process <dir>_LIBRARIES assignment
+ libraries_install = installer("LIBRARIES")
+ librariesAssign = libraries_install.create_parser(lowercase_name_, opt_ws, equals, value)
+ librariesAssign.addParseAction(libraries_install.parse)
+ librariesAssign.addParseAction(parse_assign)
+
+ # Process <dir>_SCRIPTS assignment
+ scripts_install = installer("SCRIPTS")
+ scriptsAssign = scripts_install.create_parser(lowercase_name_, opt_ws, equals, value)
+ scriptsAssign.addParseAction(scripts_install.parse)
+ scriptsAssign.addParseAction(parse_assign)
+
+ # Process <dir>_HEADERS assignment
+ headers_install = installer("HEADERS")
+ headersAssign = headers_install.create_parser(lowercase_name_, opt_ws, equals, value)
+ headersAssign.addParseAction(headers_install.parse)
+ headersAssign.addParseAction(parse_assign)
+
+ # SUBDIRS
+ subdirsAssign = Group(Combine(Literal("SUBDIRS"))+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ subdirsAssign.setParseAction(parse_assign)
+ subdirs= rem_proc("SUBDIRS")
+ subdirsAssign.addParseAction(subdirs.parse)
+
+ testsAssign = Group(Combine(Literal("TESTS"))+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ #testsAssign.setDebug()
+ testsAssign.setParseAction(parse_assign)
+ tests=rem_proc("TESTS")
+ testsAssign.addParseAction(tests.parse)
+
+ fail_testsAssign = Group(Combine(Literal("XFAIL_TESTS"))+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ fail_testsAssign.setParseAction(parse_assign)
+ fail_tests=rem_proc("XFAIL_TESTS")
+ fail_testsAssign.addParseAction(fail_tests.parse)
+
+ compile_fail_testsAssign = Group(Combine(Literal("COMPILE_XFAIL_TESTS"))+Suppress(opt_ws)+ equals + opt_ws + Optional(value))
+ compile_fail_testsAssign.setParseAction(parse_assign)
+ compile_fail_tests=rem_proc("COMPILE_XFAIL_TESTS")
+ compile_fail_testsAssign.addParseAction(compile_fail_tests.parse)
+
+ # Process include lines and just comment them out.
+ includeLine = opt_ws.suppress() + Group(Literal('include') + restOfLine )
+ includeLine.setParseAction(parse_include)
+ #includeLine.setDebug()
+ rule_line = multiple_words+Combine(Optional(Literal("\\")),lineEnd)
+ dependency_rule= Group(opt_ws+word+opt_ws+Suppress(Literal(':'))+ opt_ws+multiple_words)
+ dependency_rule.setParseAction(parse_dependency)
+
+ easy_rule = Group(opt_ws+word+opt_ws+Literal(':')+ opt_ws+Optional(word_line)+opt_ws+
+ ZeroOrMore(Or(NL,continuation)+ws+Optional(word_line)+opt_ws)+NL)
+ easy_rule.setParseAction(comment_lines)
+ #easy_rule.setDebug()
+
+ lines << ZeroOrMore(opt_ws+(dependency_rule+NL|easy_rule|(sourcesAssign|dataAssign|check_programsAssign|programsAssign|librariesAssign|scriptsAssign|headersAssign|subdirsAssign|compile_fail_testsAssign|fail_testsAssign|testsAssign|dirAssign|cppflagsAssign|cxxflagsAssign|ldaddAssign|ldflagsAssign|libsAssign|varAddAssign|docsAssign|varAssign|comment|ifstatement|includeLine|Empty())+NL))
+
+ s= ''.join(lines.parseString(amstring)._asStringList())
+ #print s
+ s=s+data_install.process()
+ s=s+programs_install.process()
+ s=s+libraries_install.process()
+ s=s+scripts_install.process()
+ s=s+headers_install.process()
+ s=s+subdirs.process()
+
+ s+=tests.process()
+ s+=fail_tests.process()
+ s+=compile_fail_tests.process()
+ s+=dirParser.process()
+ if tests.found or compile_fail_tests.found:
+ s+=''.join(['\n\n# We do not want want to build the tests during make all\n',
+ '# but just build them on demand\n',
+ 'add_directory_test_target(_test_target)\n',
+ 'add_dependencies(${_test_target} ${TESTS} ${COMPILE_XFAIL_TESTS})'])
+ if docs_present.found:
+ s=s+''.join(['\n# Install documentation',
+ '\n# We assume that ${DOCFILES} and ${DOCFILES_EXTRA} are targets\n',
+ 'install(TARGETS ${DOCFILES} ${DOCFILES_EXTRA} DESTINATION ${docdir})\n'])
+
+ return s
+
+str1="""# $Id: Makefile.am 8330 2012-08-09 08:12:25Z sander $
+
+#
+## Find out which tests can be built
+#
+
+if ALBERTA
+ APROG = test-alberta-1-1 test-alberta-1-2 test-alberta-2-2 \
+ test-alberta-1-3 test-alberta-2-3 test-alberta-3-3 \
+ test-alberta-generic
+ ALBERTA_EXTRA_PROGS = test-alberta
+endif
+
+if ALUGRID
+ ALUPROG = test-alugrid
+endif
+
+if UG
+ UPROG = test-ug test-parallel-ug
+if ALUGRID
+ DGFALU_UGGRID = test-dgfalu-uggrid-combination
+else
+ DGFALU_UGGRID =
+endif
+endif
+
+#
+## Defines for gridtype.hh
+#
+GRIDTYPE=YASPGRID
+GRIDDIM=2
+
+ALBERTA_DIM = $(WORLDDIM)
+
+#
+## Some parameters for the geogrid test
+#
+COORDFUNCTION = IdenticalCoordFunction\<double,$(GRIDDIM)\>
+# COORDFUNCTION = Helix
+# COORDFUNCTION = ThickHelix
+# COORDFUNCTION = DGFCoordFunction\<$(GRIDDIM),$(GRIDDIM)\>
+# COORDFUNCTION = DGFCoordFunction\<2,3\>
+CACHECOORDFUNCTION = 0
+
+#
+## define the lists of tests to build and run
+#
+
+# tests where program to build and program to run are equal
+NORMALTESTS = test-sgrid test-oned test-yaspgrid test-geogrid $(APROG) $(UPROG) $(ALUPROG) $(DGFALU_UGGRID)
+
+# list of tests to run
+TESTS = $(NORMALTESTS)
+
+# programs just to build when "make check" is used
+check_PROGRAMS = $(NORMALTESTS)
+
+EXTRA_PROGRAMS = $(ALBERTA_EXTRA_PROGS)
+
+#
+## common flags
+#
+
+# paranoia
+DUNE_EXTRA_CHECKS = -DDUNE_DEVEL_MODE
+# output coverage
+#COVERAGE = -fprofile-arcs -ftest-coverage
+AM_CXXFLAGS = $(COVERAGE)
+AM_CPPFLAGS = @AM_CPPFLAGS@ $(DUNE_EXTRA_CHECKS)
+
+# The directory where the example grid files used for testing are located
+AM_CPPFLAGS+=-DDUNE_GRID_EXAMPLE_GRIDS_PATH=\"$(top_srcdir)/doc/grids/\"
+
+#
+## define the programs
+#
+
+test_sgrid_SOURCES = test-sgrid.cc
+
+test_oned_SOURCES = test-oned.cc
+
+test_yaspgrid_SOURCES = test-yaspgrid.cc
+test_yaspgrid_CPPFLAGS = $(AM_CPPFLAGS) \
+ $(DUNEMPICPPFLAGS)
+test_yaspgrid_LDFLAGS = $(AM_LDFLAGS) \
+ $(DUNEMPILDFLAGS)
+test_yaspgrid_LDADD = \
+ $(DUNEMPILIBS) \
+ $(LDADD)
+
+# this implicitly checks the autoconf-test as well...
+test_alberta_SOURCES = test-alberta.cc
+test_alberta_CPPFLAGS = $(AM_CPPFLAGS) $(ALBERTA_CPPFLAGS) -DGRIDDIM=$(GRIDDIM) $(GRAPE_CPPFLAGS)
+test_alberta_LDFLAGS = $(AM_LDFLAGS) $(ALBERTA_LDFLAGS) $(GRAPE_LDFLAGS)
+test_alberta_LDADD = \
+ $(GRAPE_LIBS) \
+ $(ALBERTA_LIBS) \
+ $(LDADD)
+
+test_alberta_1_1_SOURCES = test-alberta.cc
+test_alberta_1_1_CPPFLAGS = -DGRIDDIM=1 -DWORLDDIM=1 $(ALBERTA1D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_1_1_LDFLAGS = $(ALBERTA1D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_1_1_LDADD = $(ALBERTA1D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_1_2_SOURCES = test-alberta.cc
+test_alberta_1_2_CPPFLAGS = -DGRIDDIM=1 -DWORLDDIM=2 $(ALBERTA2D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_1_2_LDFLAGS = $(ALBERTA2D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_1_2_LDADD = $(ALBERTA2D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_2_2_SOURCES = test-alberta.cc
+test_alberta_2_2_CPPFLAGS = -DGRIDDIM=2 -DWORLDDIM=2 $(ALBERTA2D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_2_2_LDFLAGS = $(ALBERTA2D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_2_2_LDADD = $(ALBERTA2D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_1_3_SOURCES = test-alberta.cc
+test_alberta_1_3_CPPFLAGS = -DGRIDDIM=1 -DWORLDDIM=3 $(ALBERTA3D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_1_3_LDFLAGS = $(ALBERTA3D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_1_3_LDADD = $(ALBERTA3D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_2_3_SOURCES = test-alberta.cc
+test_alberta_2_3_CPPFLAGS = -DGRIDDIM=2 -DWORLDDIM=3 $(ALBERTA3D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_2_3_LDFLAGS = $(ALBERTA3D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_2_3_LDADD = $(ALBERTA3D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_3_3_SOURCES = test-alberta.cc
+test_alberta_3_3_CPPFLAGS = -DGRIDDIM=3 -DWORLDDIM=3 $(ALBERTA3D_CPPFLAGS) $(GRAPE_CPPFLAGS) $(AM_CPPFLAGS)
+test_alberta_3_3_LDFLAGS = $(ALBERTA3D_LDFLAGS) $(GRAPE_LDFLAGS) $(AM_LDFLAGS)
+test_alberta_3_3_LDADD = $(ALBERTA3D_LIBS) $(GRAPE_LIBS) $(LDADD)
+
+test_alberta_generic_SOURCES = $(test_alberta_SOURCES)
+test_alberta_generic_CPPFLAGS = $(test_alberta_CPPFLAGS) -DDUNE_ALBERTA_USE_GENERICGEOMETRY=1
+test_alberta_generic_LDFLAGS = $(test_alberta_LDFLAGS)
+test_alberta_generic_LDADD = $(test_alberta_LDADD)
+
+# files for alugrid
+test_alugrid_SOURCES = test-alugrid.cc
+test_alugrid_CPPFLAGS = $(AM_CPPFLAGS) \
+ $(ALL_PKG_CPPFLAGS)
+test_alugrid_LDFLAGS = $(AM_LDFLAGS) \
+ $(ALL_PKG_LDFLAGS) \
+ -static
+test_alugrid_LDADD = \
+ $(ALL_PKG_LIBS) \
+ $(LDADD)
+
+test_geogrid_SOURCES = test-geogrid.cc functions.hh
+test_geogrid_CPPFLAGS = $(AM_CPPFLAGS) \
+ $(ALL_PKG_CPPFLAGS) \
+ -DCOORDFUNCTION=$(COORDFUNCTION) \
+ -DCACHECOORDFUNCTION=$(CACHECOORDFUNCTION)
+test_geogrid_LDFLAGS = $(AM_LDFLAGS) \
+ $(ALL_PKG_LDFLAGS)
+test_geogrid_LDADD = \
+ $(ALL_PKG_LIBS) \
+ $(LDADD)
+
+# libdune contains both libugX2 and libugX3, always test both dimensions
+test_ug_SOURCES = test-ug.cc
+test_ug_CPPFLAGS = $(AM_CPPFLAGS) \
+ $(DUNEMPICPPFLAGS) \
+ $(UG_CPPFLAGS)
+test_ug_LDFLAGS = $(AM_LDFLAGS) \
+ $(DUNEMPILDFLAGS) \
+ $(UG_LDFLAGS)
+test_ug_LDADD = \
+ $(UG_LIBS) \
+ $(DUNEMPILIBS) \
+ $(LDADD)
+
+# libdune contains both libugX2 and libugX3, always test both dimensions
+test_parallel_ug_SOURCES = test-parallel-ug.cc
+test_parallel_ug_CPPFLAGS = $(AM_CPPFLAGS) \
+ $(DUNEMPICPPFLAGS) \
+ $(UG_CPPFLAGS)
+test_parallel_ug_LDFLAGS = $(AM_LDFLAGS) \
+ $(DUNEMPILDFLAGS) \
+ $(UG_LDFLAGS)
+test_parallel_ug_LDADD = \
+ $(UG_LIBS) \
+ $(DUNEMPILIBS) \
+ $(LDADD)
+
+# Test whether you can combine the different implementations in one file
+test_dgfalu_uggrid_combination_SOURCES = test-dgfalu-uggrid-combination.cc
+test_dgfalu_uggrid_combination_CPPFLAGS = $(AM_CPPFLAGS) $(UG_CPPFLAGS) $(ALUGRID_CPPFLAGS)
+test_dgfalu_uggrid_combination_LDFLAGS = $(AM_LDFLAGS) $(UG_LDFLAGS) $(ALUGRID_LDFLAGS)
+test_dgfalu_uggrid_combination_LDADD = \
+ $(ALUGRID_LIBS) \
+ $(UG_LIBS) \
+ $(LDADD)
+
+## distribution tarball
+SOURCES = gridcheck.cc staticcheck.hh checkindexset.cc checkgeometryinfather.cc checkintersectionit.cc checkcommunicate.cc checkiterators.cc checktwists.cc check-albertareader.cc basicunitcube.hh checkadaptation.cc checkgeometry.cc checkpartition.cc checkentityseed.cc
+
+# gridcheck not used explicitly, we should still ship it :)
+EXTRA_DIST = $(SOURCES)
+
+CLEANFILES = *.gcda *.gcno semantic.cache simplex-testgrid*.dgf.* cube-testgrid*.dgf.* dgfparser.log
+
+include $(top_srcdir)/am/global-rules
+
+doxygendir = $(datadir)/doc/dune-localfunctions/doxygen
+doxygen_DATA = $(WHAT)
+
+# install the html pages
+docdir=$(datadir)/doc/dune-common/buildsystem
+if BUILD_DOCS
+ DOCFILES=buildsystem.pdf
+ EXTRA_DIST=$(DOCFILES)
+ EXTRAINSTALL=$(DOCFILES)
+endif
+
+all: $(WHAT) $(DOXYGENFILES)
+clean-local:
+ if test "x$(VPATH)" != "x" && test ! -e $(srcdir)/doxygen-tag; then \
+ if test -e $(top_srcdir)/doc/doxygen/Doxydep; then \
+ rm -rf $(SVNCLEANFILES); \
+ fi; \
+ fi
+# also build these sub directories
+SUBDIRS = doxygen buildsystem
+docdir=$(datadir)/doc/dune-common
+doc_DATA=data_bla data_blu
+doc_PROGRAMS= balla
+XFAIL_TESTS=ftest1 ftest2 ftest3
+COMPILE_XFAIL_TESTS=cftest1 cftest2
+"""
+
+#print am_2_cmake_string("""# which tests to run
+#TESTS = lagrangeshapefunctiontest \
+# monomshapefunctiontest \
+# virtualshapefunctiontest \
+# testgenericfem \
+# $(ALUPROG)
+#""")
+
+str2=''.join(['TESTS = lagrangeshapefunctiontest \\\n', '\tmonomshapefunctiontest\t\t\t\\\n', '\tvirtualshapefunctiontest\t\t\\\n', '\ttestgenericfem \\\n', '\t$(ALUPROG)\n'])
+#print "s=%s" % output
+
+def init_cmake_module(module_name):
+ return''.join(['# set up project\n',
+ 'project("'+module_name+'" C CXX)\n\n#circumvent not building docs\nset(BUILD_DOCS 1)\n\n',
+ '# general stuff\n',
+ 'cmake_minimum_required(VERSION 2.8.6)\n\n',
+ '#find dune-common and set the module path\n',
+ 'find_package(dune-common)\n'
+ 'list(APPEND CMAKE_MODULE_PATH ${dune-common_MODULE_PATH}\n'
+ ' "${CMAKE_SOURCE_DIR}/cmake/modules")# make sure our own modules are found\n\n',
+ '#include the dune macros\n'
+ 'include(DuneMacros)\n\n',
+ '# start a dune project with information from dune.module\n',
+ 'dune_project()\n\n'])
+
+def finalize_cmake_module(module_name):
+ upper_name =re.sub('-(\S)', lambda m: m.group(1).capitalize(),
+ module_name.capitalize())
+ name_wo_dasch=module_name.replace('-', '')
+ lines = ['\nadd_subdirectory(cmake/modules)\n',
+ '# finalize the dune project, e.g. generating config.h etc.\n'
+ 'finalize_dune_project(GENERATE_CONFIG_H_CMAKE)\n']
+ return ''.join(lines)
+
+def create_cmake_dirs_and_file(dirname, module_name):
+ upper_name =re.sub('-(\S)', lambda m: m.group(1).capitalize(),
+ module_name.capitalize())
+ print 'module_name %s' % module_name
+ print 'upper_name %s' % upper_name
+ dirs={'modules': os.path.join(dirname, 'cmake', 'modules'),
+ 'pkg': os.path.join(dirname, 'cmake', 'pkg')}
+ cdirs=[]
+ for dir in dirs.values():
+ try:
+ print "Creating %s" % dir
+ os.makedirs(dir)
+ except OSError as exception:
+ if exception.errno != errno.EEXIST:
+ raise
+ text="message(AUTHOR_WARNING \"TODO: Implement module test.\")"
+ output=open(os.path.join(dirs['modules'], upper_name+'Macros.cmake'), 'w')
+ output.write(text)
+ output.close()
+ lines=['if(NOT @DUNE_MOD_NAME@_FOUND)\n',
+ '#compute installation prefix relative to this file\n',
+ 'get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)\n',
+ 'get_filename_component(_prefix "${_dir}/../../.." ABSOLUTE)\n',
+ '\n',
+ '#import the target\n',
+ 'if(EXISTS "${_prefix}/lib/cmake/@DUNE_MOD_NAME@-targets.cmake")\n',
+ ' include("${_prefix}/lib/cmake/@DUNE_MOD_NAME@-targets.cmake")\n',
+ 'endif(EXISTS "${_prefix}/lib/cmake/@DUNE_MOD_NAME@-targets.cmake")\n',
+ '\n',
+ '#report other information\n',
+ 'set(@DUNE_MOD_NAME@_PREFIX "${_prefix}")\n',
+ 'set(@DUNE_MOD_NAME@_INCLUDE_DIRS "${_prefix}/include")\n',
+ 'set(@DUNE_MOD_NAME@_CXX_FLAGS "@CMAKE_CXX_FLAGS@")\n',
+ 'set(@DUNE_MOD_NAME@_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")\n',
+ 'set(@DUNE_MOD_NAME@_CXX_FLAGS_MINSIZEREL "@CMAKE_CXX_FLAGS_MINSIZEREL@")\n',
+ 'set(@DUNE_MOD_NAME@_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")\n',
+ 'set(@DUNE_MOD_NAME@_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@")\n',
+ 'set(@DUNE_MOD_NAME@_LIBRARIES "")\n',
+ 'set(@DUNE_MOD_NAME@_DEPENDS "@DUNE_DEPENDS@")\n',
+ 'set(@DUNE_MOD_NAME@_SUGGESTS "@DUNE_SUGGESTS@")\n',
+ 'set(@DUNE_MOD_NAME@_MODULE_PATH "@DUNE_INSTALL_MODULEDIR@")\n',
+ 'endif(NOT @DUNE_MOD_NAME@_FOUND)\n']
+ text = ''.join(lines)
+ output=open(os.path.join(dirs['pkg'], module_name+'-config.cmake.in'), 'w')
+ output.write(text)
+ output.close()
+ l=[lines[0]]
+ l.extend([lines[5],
+ 'if(EXISTS "@CMAKE_BINARY_DIR@/@DUNE_MOD_NAME@-targets.cmake")\n'
+ ' include("@CMAKE_BINARY_DIR@/@DUNE_MOD_NAME@-targets.cmake")\n',
+ 'endif(EXISTS "@CMAKE_BINARY_DIR@/@DUNE_MOD_NAME@-targets.cmake")\n\n',
+ '#report other information\n',
+ 'set(@DUNE_MOD_NAME@_PREFIX "@CMAKE_SOURCE_DIR@")\n',
+ 'set(@DUNE_MOD_NAME@_INCLUDE_DIRS "@CMAKE_SOURCE_DIR@")\n'])
+ l.extend(lines[13:])
+ l[-2]='set(@DUNE_MOD_NAME@_MODULE_PATH "@CMAKE_SOURCE_DIR@/cmake/modules")\n'
+ output=open(os.path.join(dirname, module_name+'-config.cmake.in'), 'w')
+ output.write(''.join(l))
+ output.close()
+ # CMakeLists.txt in module directory
+ # list files *.cmake
+ all_cmake_files=[]
+ for root, dirnames, filenames in os.walk(dirs['modules']):
+ all_cmake_files.extend(fnmatch.filter(filenames,'*.cmake')[:])
+ lines=['set(modules \n ', '\n '.join(all_cmake_files), '\n)\n']
+ output=open(os.path.join(dirs['modules'], 'CMakeLists.txt'), 'w')
+ lines.extend(['install(FILES "${modules}" DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/modules)\n'])
+ output.write(''.join(lines))
+ output.close()
+ output=open(os.path.join(dirname, module_name+'-version.cmake.in'), 'w')
+ lines=['set(PACKAGE_VERSION "@DUNE_MOD_VERSION@")\n\n',
+ 'if(NOT "${PACKAGE_FIND_VERSION}" VERSION_GREATER "@DUNE_MOD_VERSION@")\n',
+ ' set (PACKAGE_VERSION_COMPATIBLE 1) # compatible with older\n',
+ ' if ("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "@DUNE_MOD_VERSION@")\n'
+ ' set(PACKAGE_VERSION_EXACT 1) #exact match for this version\n',
+ ' endif()\n',
+ 'endif()\n']
+ output.write(''.join(lines))
+ output.close()
+
+
+def am_2_cmake(amfile, cmakefile, module_root=False):
+ output = open(cmakefile, 'w')
+ if module_root:
+ dirname=os.path.dirname(amfile)
+ dune_module_path = os.path.join(dirname, 'dune.module')
+ module_file = open(dune_module_path, 'r')
+ lines = module_file.readlines()
+ print ''.join(lines)
+ m=re.search(r'.*Module:[ \t]*(\S+)[ \t]*[\n]?.*', ''.join(lines))
+ if not m:
+ raise Exception("Could not find module name in dune.module file.")
+ module_file.close()
+ module_name=m.group(1)
+ print 'Module name is %s'% module_name
+ output.write(init_cmake_module(module_name))
+ create_cmake_dirs_and_file(dirname, module_name)
+ input = open(amfile, 'r')
+ lines = input.readlines()
+ str = ''.join(lines)
+ output.write(am_2_cmake_string(str))
+ input.close()
+ if module_root:
+ output.write(finalize_cmake_module(module_name))
+ output.close()
+
+def am_2_cmake_dir(directory):
+ for root, dirnames, filenames in os.walk(directory):
+ for filename in fnmatch.filter(filenames, 'Makefile.am'):
+ print "root=%s" % root
+ print "filename=%s" % filename
+ amfile=os.path.join(root, filename)
+ cmfile=os.path.join(root, 'CMakeLists.txt')
+ is_module_root = len(fnmatch.filter(filenames, 'dune.module'))
+
+ print ''.join(['Converting ', amfile, ' -> ', cmfile])
+ print is_module_root
+ am_2_cmake(amfile, cmfile, is_module_root)
+
+ # Add doxygen target
+ doxygendir=os.path.join(directory, 'doc', 'doxygen')
+ if os.path.isdir(doxygendir) and os.path.exists(os.path.join(doxygendir, 'Doxylocal')):
+ output=open(os.path.join(doxygendir, 'CMakeLists.txt'),'a')
+ output.write('\n'.join(['# Create Doxyfile.in and Doxyfile, and doxygen documentation',
+'add_doxygen_target()']))
+ output.close()
+
+def main():
+ usage = "usage: am2cmake "
+ parser = OptionParser(usage=usage)
+ parser.add_option("-a", "--am-file", dest="amfile",
+ help="The Makefile.am", metavar="FILE")
+ parser.add_option("-c", "--cmake-file",
+ dest="cmakefile",
+ help="The CMake file")
+ parser.add_option("-d", "--directory",
+ dest="directory",
+ help="Root directory of dune-module")
+ (options, args) = parser.parse_args()
+ if not options.amfile and not options.directory:
+ parser.error("options -a or option -d has to be present")
+ if options.directory and (options.amfile or options.cmakefile):
+ parser.error("Cannot provide a directory and a CMake or am file.")
+ if not options.cmakefile and not options.directory:
+ options.cmakefile = options.amfile.replace('Makefile.am', 'CMakeLists.txt')
+
+ #import pdb; pdb.set_trace()
+ if options.directory:
+ am_2_cmake_dir(options.directory)
+ else:
+ print ''.join([options.amfile, '->', options.cmakefile])
+ am_2_cmake(options.amfile, options.cmakefile)
+if __name__ == "__main__":
+ main()
diff --git a/bin/dunecontrol b/bin/dunecontrol
index 18561ba443201ca263ea255ac04f4335088a0856..673dded90ca4e802d562fab06382007dc1e2837d 100755
--- a/bin/dunecontrol
+++ b/bin/dunecontrol
@@ -165,7 +165,12 @@ load_opts() {
local CMD_FLAGS_FROM_FILE=""
BUILDDIR=$DUNE_BUILDDIR
if test "x$DUNE_OPTS_FILE" != "x"; then
- BUILDDIR="$(eval BUILDDIR=""; . $DUNE_OPTS_FILE; eval echo \$BUILDDIR)"
+ # use build dir from opts file if set
+ OPTS_FILE_BUILDDIR="$(eval BUILDDIR=""; . $DUNE_OPTS_FILE; eval echo \$BUILDDIR)"
+ if test -n "$OPTS_FILE_BUILDDIR"; then
+ BUILDDIR="$OPTS_FILE_BUILDDIR"
+ fi
+ CMAKE_FLAGS="$(. $DUNE_OPTS_FILE; eval echo \$CMAKE_FLAGS)"
CMD_FLAGS_FROM_FILE="$(eval ${COMMAND}_FLAGS=""; . $DUNE_OPTS_FILE; eval echo \$${COMMAND}_FLAGS)"
fi
if test -n "$CMD_FLAGS_FROM_FILE"; then
@@ -216,16 +221,17 @@ esac'
}
# list of all dunecontrol commands
-COMMANDS="printdeps update autogen configure make all exec status svn"
+COMMANDS="printdeps update autogen configure make all exec bexec status svn"
# help string for the commands
printdeps_HELP="print recursive dependencies of a module"
update_HELP="updated all modules from the repository"
-autogen_HELP="run the autogen.sh script for each module"
-configure_HELP="run configure for each module"
+autogen_HELP="run the autogen.sh script for each module. Does nothing, if CMake is activated"
+configure_HELP="run configure or cmake for each module"
make_HELP="run make for each module"
all_HELP="\trun 'autogen', 'configure' and 'make' command for each module"
-exec_HELP="execute an arbitrary command in each module directory"
+exec_HELP="execute an arbitrary command in each module source directory"
+bexec_HELP="execute an arbitrary command in each module build directory"
status_HELP="show vc status for all modules"
svn_HELP="\trun svn command for each svn managed module"
@@ -245,6 +251,8 @@ done
run_default_exec () { bash -c "eval $CMD_FLAGS"; }
+run_default_bexec () { bash -c "cd "$BUILDDIR" && eval $CMD_FLAGS"; }
+
run_default_status () {
local verbose=0
local update=""
@@ -342,29 +350,39 @@ run_default_update () {
}
run_default_autogen () {
- PARAMS="$CMD_FLAGS"
- local M4_PATH=""
- if test -f configure.ac && \
- ( test -d .svn || test -d .git || test -d CVS || test -f stamp-vc ); then
- sort_modules $FOUND_MODULES
- for m in $MODULES; do
- path=$(eval "echo \$PATH_$m")
- MODULE_PATHS="$MODULE_PATHS$path "
- done
- if test -f autogen.sh; then
- eval echo "WARNING: \$NAME_$module contains obsolete autogen.sh," \
- >&2
- echo " dune-autogen is used instead." >&2
+ if test "x$USE_CMAKE" != "xyes" || test ! -e $(eval "echo \$PATH_$module")/CMakeLists.txt ; then
+ PARAMS="$CMD_FLAGS"
+ local M4_PATH=""
+ if test -f configure.ac && \
+ ( test -d .svn || test -d .git || test -d CVS || test -f stamp-vc ); then
+ sort_modules $FOUND_MODULES
+ for m in $FOUND_MODULES; do
+ path=$(eval "echo \$PATH_$m")
+ MODULE_PATHS="$MODULE_PATHS$path "
+ done
+ if test -f autogen.sh; then
+ eval echo "WARNING: \$NAME_$module contains obsolete autogen.sh," \
+ >&2
+ echo " dune-autogen is used instead." >&2
+ fi
+ eval "$PREFIX_DIR/bin/dune-autogen" "$MODULE_PATHS" "$PARAMS" || exit 1
+ else
+ echo Skipping dune-autogen
fi
- eval "$PREFIX_DIR/bin/dune-autogen" "$MODULE_PATHS" "$PARAMS" || exit 1
- else
- echo Skipping dune-autogen
+ else
+ echo Skipping dune-autogen because of CMake
fi
}
run_default_configure () {
PARAMS="$CMD_FLAGS"
- if test -x configure; then
+ if test "x$USE_CMAKE" = "xyes" && test -e $(eval "echo \$PATH_$module")/CMakeLists.txt; then
+ LOCAL_USE_CMAKE=yes
+ else
+ LOCAL_USE_CMAKE=no
+ fi
+ echo "LOCAL_USE_CMAKE=$LOCAL_USE_CMAKE $(eval "echo \$PATH_$module")/CMakeLists.txt"
+ if test -x configure || test "x$LOCAL_USE_CMAKE" = "xyes" ; then
ACLOCAL_FLAGS="-I ."
if test -d "m4"; then
ACLOCAL_FLAGS="$ACLOCAL_FLAGS -I m4"
@@ -387,20 +405,42 @@ run_default_configure () {
else
PARAMS="$PARAMS \"--with-$name=$path\""
fi
+ if test "x$USE_CMAKE" = "xyes"; then
+ if test -d "$path/$BUILDDIR"; then
+ CMAKE_PARAMS="$CMAKE_PARAMS \"-D""$name""_DIR=$path/$BUILDDIR\""
+ else
+ if test -d "$path/lib/cmake/$name"; then
+ CMAKE_PARAMS="$CMAKE_PARAMS \"-D""$name""_DIR=$path/lib/cmake/$name\""
+ else
+ CMAKE_PARAMS="$CMAKE_PARAMS \"-D""$name""_DIR=$path\""
+ fi
+ fi
+ fi
done
+
if test "x$HAVE_duneweb" == "xyes"; then
PARAMS="$PARAMS \"--with-duneweb=$PATH_duneweb\""
fi
PARAMS="$PARAMS ACLOCAL_AMFLAGS=\"$ACLOCAL_FLAGS\""
- echo ./configure "$PARAMS"
- # create build directory of requested
- if test -n "$BUILDDIR"; then
+
+ if test "x$LOCAL_USE_CMAKE" = "xyes"; then
test -d "$BUILDDIR" || mkdir "$BUILDDIR"
SRCDIR="$PWD"
cd "$BUILDDIR"
- eval "$SRCDIR/configure" "$PARAMS" || exit 1
+ echo `pwd`
+ echo "cmake -DBUILD_SHARED_LIBS:BOOL=OFF -DCMAKE_MODULE_PATH=\"$CMAKE_MODULE_PATH\" $CMAKE_PARAMS $CMAKE_FLAGS $SRCDIR"
+ eval cmake "-DBUILD_SHARED_LIBS:BOOL=OFF -DCMAKE_MODULE_PATH=\"$CMAKE_MODULE_PATH\" $CMAKE_PARAMS $CMAKE_FLAGS $SRCDIR"
else
- eval ./configure "$PARAMS" || exit 1
+ echo ./configure "$PARAMS"
+ # create build directory of requested
+ if test -n "$BUILDDIR"; then
+ test -d "$BUILDDIR" || mkdir "$BUILDDIR"
+ SRCDIR="$PWD"
+ cd "$BUILDDIR"
+ eval "$SRCDIR/configure" "$PARAMS" || exit 1
+ else
+ eval ./configure "$PARAMS" || exit 1
+ fi
fi
else
if test -f configure.in || test -f configure.ac; then
@@ -457,21 +497,22 @@ usage () {
echo " Dependencies are controlled by the $CONTROL files."
echo ""
echo "OPTIONS:"
- echo " -h, --help show this help"
- echo " --debug enable debug output of this script"
- echo " --module=mod only apply the actions on module mod"
- echo " and all modules it depends on"
- echo " --only=mod only apply the actions on module mod"
- echo " and not the modules it depends on"
- echo " --current only apply the actions on the current module,"
- echo " the one whose source tree we are standing in"
- echo " --resume resume a previous run (only consider the modules"
- echo " not built successfully on the previous run)"
- echo " --skipfirst skip the first module (use with --resume)"
- echo " --opts=FILE load default options from FILE"
- echo " (see dune-common/doc/example.opts)"
+ echo " -h, --help show this help"
+ echo " --debug enable debug output of this script"
+ echo " --use-cmake use cmake instead autotools of cmake for building"
+ echo " --module=mod only apply the actions on module mod"
+ echo " and all modules it depends on"
+ echo " --only=mod only apply the actions on module mod"
+ echo " and not the modules it depends on"
+ echo " --current only apply the actions on the current module,"
+ echo " the one whose source tree we are standing in"
+ echo " --resume resume a previous run (only consider the modules"
+ echo " not built successfully on the previous run)"
+ echo " --skipfirst skip the first module (use with --resume)"
+ echo " --opts=FILE load default options from FILE"
+ echo " (see dune-common/doc/example.opts)"
echo " --builddir=NAME make out-of-source builds in a subdir NAME."
- echo " This directory is created inside each module."
+ echo " This directory is created inside each module."
echo " --[COMMAND]-opts=opts set options for COMMAND"
echo " (this is mainly useful for the 'all' COMMAND)"
echo "COMMANDS:"
@@ -550,6 +591,7 @@ export ONLY=""
export RESUME_FLAG=no
export REVERSE_FLAG=no
export SKIPFIRST=no
+export USE_CMAKE=no
# parse commandline parameters
while test $# -gt 0; do
@@ -658,6 +700,9 @@ while test $# -gt 0; do
--skipfirst)
export SKIPFIRST=yes
;;
+ --use-cmake)
+ export USE_CMAKE=yes
+ ;;
--debug) true ;; # ignore this option, it is handled right at the beginning
--*)
usage
@@ -673,6 +718,11 @@ while test $# -gt 0; do
shift
done
+if test "x$USE_CMAKE" = "xyes" && test -z "$DUNE_BUILDDIR"; then
+ echo "No build directory provided. Defaulting to the sub directory build-cmake"
+ export DUNE_BUILDDIR=build-cmake
+fi
+echo "USE_CMAKE=$USE_CMAKE DUNE_BUILDDIR=$DUNE_BUILDDIR"
# we assume there should be a command...
if test "x$command" = "x"; then
usage
diff --git a/bin/duneproject b/bin/duneproject
index 9eb33ebeb1cdb91b9240142c70888b7bdacf8688..f4a63fb8e0bb8e6df043c3c521572d49367d8816 100755
--- a/bin/duneproject
+++ b/bin/duneproject
@@ -313,7 +313,7 @@ echo "writing initial files:"
# we need the module with _ instead of - to not confuse automake
fix_and_assign CMODULE $MODULE
NAME=`echo $PROJECT | sed -e 's/dune[_-]//' | tr '-' '_'`
-
+UNAME=`echo $PROJECT | tr '-' '_' | sed 's/\(.*\)/\U\1/'`
################## CONFIGURE.AC ##################
echo "- $PROJECT/configure.ac"
cat > "$PROJECT/configure.ac" <<C_DELIM
@@ -462,6 +462,32 @@ include \$(top_srcdir)/am/global-rules
M_DELIM
+################## CMakeLists.txt ##################
+echo " - $PROJECT/CMakeLists.txt"
+cat> "$PROJECT/CMakeLists.txt" << M_DELIM
+cmake_minimum_required(VERSION 2.8.6)
+project($PROJECT CXX)
+
+#find dune-common and set the module path
+find_package(dune-common)
+list(APPEND CMAKE_MODULE_PATH ${dune-common_MODULE_PATH}
+ "${CMAKE_SOURCE_DIR}/cmake/modules")
+
+#include the dune macros
+include(DuneMacros)
+
+# start a dune project with information from dune.module
+dune_project()
+
+add_subdirectory("src")
+add_subdirectory("m4")
+add_subdirectory("dune")
+add_subdirectory("doc")
+
+# finalize the dune project, e.g. generating config.h etc.
+finalize_dune_project(GENERATE_CONFIG_H_CMAKE)
+M_DELIM
+
################## STAMP-VC ##################
echo "- $PROJECT/stamp-vc"
echo 'A stamp file to signify that this directory comes from a version control system, not an unpacked tarball' > $PROJECT/stamp-vc
@@ -494,6 +520,16 @@ echo " Description and URL are missing right now."
mkdir "$PROJECT/src"
+################## src/CMakeLists.txt ##################
+
+echo "- $PROJECT/src/CMakeLists.txt"
+cat> "$PROJECT/src/CMakeLists.txt" << M_DELIM
+
+add_executable("${CMODULE}" ${CMODULE}.cc)
+target_link_dune_default_libraries("${CMODULE}")
+
+M_DELIM
+
################## src/MAKEFILE.AM ##################
echo "- $PROJECT/src/Makefile.am"
@@ -588,6 +624,14 @@ EXTRA_DIST = \$(M4FILES)
include \$(top_srcdir)/am/global-rules
CC_DELIM
+
+echo "- $PROJECT/m4/CMakeLists.txt"
+cat> "$PROJECT/m4/CMakeLists.txt" << CC_DELIM
+
+install(PROGRAMS $MODULE.m4 DESTINATION share/aclocal)
+
+CC_DELIM
+
################## M4/PROJECT.M4 ####################
M4_MODULE=`echo $MODULE | tr '[a-z-]' '[A-Z_]'`
echo "- $PROJECT/m4/$MODULE.m4"
@@ -628,6 +672,12 @@ SUBDIRS = $NAME
include \$(top_srcdir)/am/global-rules
EOF
+echo "- $PROJECT/dune/CMakeLists.txt"
+cat> $PROJECT/dune/CMakeLists.txt <<EOF
+add_subdirectory($NAME)
+EOF
+
+
################## dune/$NAME/Makefile.am ##############
echo "- $PROJECT/dune/$NAME/Makefile.am"
cat> $PROJECT/dune/$NAME/Makefile.am <<EOF
@@ -637,6 +687,13 @@ ${NAME}include_HEADERS = ${NAME}.hh
include \$(top_srcdir)/am/global-rules
EOF
+echo "- $PROJECT/dune/$NAME/CMakeLists.txt"
+cat> $PROJECT/dune/$NAME/CMakeLists.txt <<EOF
+#install headers
+install(FILES ${NAME}.hh DESTINATION include/dune/$NAME)
+
+EOF
+
################## dune/$NAME/$NAME.hh #################
echo "- $PROJECT/dune/$NAME/$NAME.hh"
cat> $PROJECT/dune/$NAME/$NAME.hh <<EOF
@@ -672,6 +729,12 @@ include \$(top_srcdir)/am/webstuff
include \$(top_srcdir)/am/global-rules
CC_DELIM
+
+echo "- $PROJECT/doc/CMakeLists.txt"
+cat> "$PROJECT/doc/CMakeLists.txt" << CC_DELIM
+add_subdirectory("doxygen")
+CC_DELIM
+
###############################################################
############### The doc/doxygen subdirectory ##################
###############################################################
@@ -733,7 +796,126 @@ include \$(top_srcdir)/am/global-rules
CC_DELIM
+
+echo "- $PROJECT/doc/doxygen/CMakeLists.txt"
+cat> "$PROJECT/doc/doxygen/CMakeLists.txt" << CC_DELIM
+# shortcut for creating the Doxyfile.in and Doxyfile
+add_doxygen_target()
+CC_DELIM
+
+echo "- $PROJECT/config.h.cmake"
+cat> "$PROJECT/config.h.cmake" <<EOF
+/* begin $NAME
+ put the definitions for config.h specific to
+ your project here. Everything above will be
+ overwritten
+*/
+
+/* begin private */
+/* Name of package */
+#define PACKAGE "@DUNE_MOD_NAME"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "@DUNE_MAINTAINER@"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "@DUNE_MOD_NAME@"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "@DUNE_MOD_NAME@ @DUNE_MOD_VERSION@"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "@DUNE_MOD_NAME@"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "@DUNE_MOD_URL@"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "@DUNE_MOD_VERSION@"
+
+/* end private */
+
+/* Define to the version of $PROJECT */
+#define ${UNAME}_VERSION "@${UNAME}_VERSION@"
+
+/* Define to the major version of $PROJECT */
+#define ${UNAME}_VERSION_MAJOR @${UNAME}_VERSION_MAJOR@
+
+/* Define to the minor version of $PROJECT */
+#define ${UNAME}_VERSION_MINOR @${UNAME}_VERSION_MINOR@
+
+/* Define to the revision of $PROJECT */
+#define ${UNAME}_VERSION_REVISION @${UNAME}_VERSION_REVISION@
+
+/* end $NAME
+ Everything below here will be overwritten
+*/
+EOF
## done
+
+echo "- $PROJECT/$PROJECT""-config.cmake.in"
+cat> "$PROJECT/$PROJECT""-config.cmake.in" <<EOF
+if(NOT @DUNE_MOD_NAME@_FOUND)
+#import the target
+#include("@CMAKE_BINARY_DIR@/@DUNE_MOD_NAME@-targets.cmake")
+
+#report other information
+set(@DUNE_MOD_NAME@_PREFIX "@CMAKE_SOURCE_DIR@")
+set(@DUNE_MOD_NAME@_INCLUDE_DIRS "@CMAKE_SOURCE_DIR@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_MINSIZEREL "@CMAKE_CXX_FLAGS_MINSIZEREL@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@")
+set(@DUNE_MOD_NAME@_LIBRARIES "") # list exported libraries here
+set(@DUNE_MOD_NAME@_DEPENDS "@DUNE_DEPENDS@")
+set(@DUNE_MOD_NAME@_SUGGESTS "@DUNE_SUGGESTS@")
+endif(NOT @DUNE_MOD_NAME@_FOUND)
+endif(NOT @DUNE_MOD_NAME@_FOUND)
+EOF
+
+mkdir "$PROJECT/cmake"
+mkdir "$PROJECT/cmake/modules"
+mkdir "$PROJECT/cmake/pkg"
+
+echo "- $PROJECT/cmake/pkg/$PROJECT""-config.cmake.in"
+cat> "$PROJECT/cmake/pkg/$PROJECT""-config.cmake.in" <<EOF
+if(NOT @DUNE_MOD_NAME@_FOUND)
+#compute installation prefix relative to this file
+get_filename_component(_dir "\${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_prefix "\${_dir}/../../.." ABSOLUTE)
+
+#import the target
+#include("\${_prefix}/lib/cmake/@DUNE_MOD_NAME@-targets.cmake")
+
+#report other information
+set(@DUNE_MOD_NAME@_INCLUDE_DIRS "\${_prefix}/include")
+set(@DUNE_MOD_NAME@_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_MINSIZEREL "@CMAKE_CXX_FLAGS_MINSIZEREL@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@")
+set(@DUNE_MOD_NAME@_MODULE_PATH "@DUNE_INSTALL_MODULEDIR@")
+set(@DUNE_MOD_NAME@_LIBRARIES "") # list libraries
+set(@DUNE_MOD_NAME@_DEPENDS "@DUNE_DEPENDS@")
+set(@DUNE_MOD_NAME@_SUGGESTS "@DUNE_SUGGESTS@")
+endif(NOT @DUNE_MOD_NAME@_FOUND)
+EOF
+
+echo "- $PROJECT/$PROJECT""-version.cmake.in"
+cat> "$PROJECT/$PROJECT""-version.cmake.in" <<EOF
+set(PACKAGE_VERSION "@DUNE_MOD_VERSION@")
+
+if(NOT "\${PACKAGE_FIND_VERSION}" VERSION_GREATER "@DUNE_MOD_VERSION@")
+ set (PACKAGE_VERSION_COMPATIBLE 1) # compatible with older
+ if ("\${PACKAGE_FIND_VERSION}" VERSION_EQUAL "@DUNE_MOD_VERSION@")
+ set(PACKAGE_VERSION_EXACT 1) #exact match for this version
+ endif()
+endif()
+EOF
+echo "- $PROJECT/stamp-regenerate-config-h"
+touch $PROJECT/stamp-regenerate-config-h
+echo
echo "done."
echo "------------------------------------------"
echo "For further details read the Dune Buildsystem-Howto:"
diff --git a/cmake/.gitignore b/cmake/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3dda72986fc5af262451a760393b3a7065938c80
--- /dev/null
+++ b/cmake/.gitignore
@@ -0,0 +1,2 @@
+Makefile.in
+Makefile
diff --git a/cmake/Makefile.am b/cmake/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..f2c914a4a064ca1bd33d1f57b86e4a8d3cc4789e
--- /dev/null
+++ b/cmake/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS=modules pkg scripts
diff --git a/cmake/modules/.gitignore b/cmake/modules/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3dda72986fc5af262451a760393b3a7065938c80
--- /dev/null
+++ b/cmake/modules/.gitignore
@@ -0,0 +1,2 @@
+Makefile.in
+Makefile
diff --git a/cmake/modules/CMakeLists.txt b/cmake/modules/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..00e6852a10d206c33b990005680e130fbdeabda3
--- /dev/null
+++ b/cmake/modules/CMakeLists.txt
@@ -0,0 +1,22 @@
+set(modules DuneBoost.cmake
+ DuneCommonMacros.cmake
+ DuneCxaDemangle.cmake
+ DuneDoc.cmake
+ DuneDoxygen.cmake
+ DuneMacros.cmake
+ DuneMPI.cmake
+ DunePkgConfig.cmake
+ DuneStreams.cmake
+ DuneTestMacros.cmake
+ DuneTests.cmake
+ FindBoostFusion.cmake
+ FindCXX11Features.cmake
+ FindGMP.cmake
+ FindInkscape.cmake
+ FindMETIS.cmake
+ FindMProtect.cmake
+ FindParMETIS.cmake
+ FindSharedPtr.cmake
+ LanguageSupport.cmake
+ UseLATEX.cmake)
+install(FILES ${modules} DESTINATION ${DUNE_INSTALL_MODULEDIR})
diff --git a/cmake/modules/DuneBoost.cmake b/cmake/modules/DuneBoost.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b717aaa6cf3bad3e8cd0ec48181b9640c9eb9f4f
--- /dev/null
+++ b/cmake/modules/DuneBoost.cmake
@@ -0,0 +1,23 @@
+# Searches for boost and provides the following function:
+#
+# add_dune_boost_flags(targets)
+#
+# Adds boost compiler flags and libraries, and activates
+# Boost for the specified targets.
+find_package(Boost)
+set(HAVE_BOOST ${Boost_FOUND})
+
+function(add_dune_boost_flags _targets)
+ if(Boost_FOUND)
+ include_directories("${Boost_INCLUDE_DIRS}")
+ foreach(_target ${_targets})
+ target_link_libraries(${_target} ${Boost_LIBRARIES})
+ # The definitions are a hack as we do not seem to know which MPI implementation was
+ # found.
+ GET_TARGET_PROPERTY(_props ${_target} COMPILE_FLAGS)
+ string(REPLACE "_props-NOTFOUND" "" _props "${_props}")
+ SET_TARGET_PROPERTIES(${_target} PROPERTIES COMPILE_FLAGS
+ "${_props} -DENABLE_BOOST=1")
+ endforeach(_target)
+ endif(Boost_FOUND)
+endfunction(add_dune_boost_flags)
diff --git a/cmake/modules/DuneCommonMacros.cmake b/cmake/modules/DuneCommonMacros.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..fbe318c3eafec1d53f9b923ee9765fc87f1ac5d4
--- /dev/null
+++ b/cmake/modules/DuneCommonMacros.cmake
@@ -0,0 +1,27 @@
+# This cmake file holds tests and directives that are executed
+# for the module dune-common and have to be executed by
+# all dependent modules
+#
+# Specifically it configure the DUNE debug streams and
+# tests whether std::shared_ptr, LAPACK and BLAS are available.
+#
+include(DuneStreams)
+dune_set_minimal_debug_level()
+
+find_package(SharedPtr)
+if(Fortran_Works)
+ # search for lapack
+ find_package(LAPACK)
+ set(HAVE_LAPACK ${LAPACK_FOUND})
+ set(HAVE_BLAS ${BLAS_FOUND})
+else(Fortran_Works)
+ set(HAVE_LAPACK Off)
+ set(HAVE_BLAS Off)
+ # Write an empty FC header
+ file(WRITE ${CMAKE_BINARY_DIR}/FC.h "")
+endif(Fortran_Works)
+
+find_package(GMP)
+find_package(Inkscape)
+include(FindMProtect)
+include(DuneBoost)
diff --git a/cmake/modules/DuneCxaDemangle.cmake b/cmake/modules/DuneCxaDemangle.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..9f480fa9a519fa85a5d95da36df5f5c7fdc3110d
--- /dev/null
+++ b/cmake/modules/DuneCxaDemangle.cmake
@@ -0,0 +1,17 @@
+# Module that checks whether the compiler supports the
+# abi::__cxa_demangle function required to
+# make the type names returned by typeid() human-readable
+#
+# Sets the following variable:
+# HAVE_CXA_DEMANGLE
+#
+# perform tests
+include(CheckCXXSourceCompiles)
+
+CHECK_CXX_SOURCE_COMPILES("#include <cxxabi.h>
+int main(void){
+ int foobar = 0;
+ const char *foo = typeid(foobar).name();
+ int status;
+ char *demangled = abi::__cxa_demangle( foo, 0, 0, &status );
+}" HAVE_CXA_DEMANGLE)
diff --git a/cmake/modules/DuneDoc.cmake b/cmake/modules/DuneDoc.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..ea2858d08e4378a0321ad9ad18890520d2ebbf1d
--- /dev/null
+++ b/cmake/modules/DuneDoc.cmake
@@ -0,0 +1,105 @@
+#
+# Module that provides a custom target make doc at the top level
+# directory and utility macros for creating install directives
+# that make sure that the files to be installed are previously
+# generated even if make doc was not called.
+#
+# All documentation (Latex, Doxygen) will be generated during
+# make doc.
+# It provides the following macros:
+#
+# create_doc_install(FILENAME TARGETDIR [DEPENDENCY])
+#
+# creates a target for installing the file FILENAME
+# to the directory TARGETDIR.
+# If DEPENDENCY is specified, this is a dependency for
+# the installation. Otherwise FILENAME becomes the dependency
+#
+# dune_add_latex_document()
+
+FIND_PACKAGE(LATEX)
+FIND_PROGRAM(IMAGEMAGICK_CONVERT convert
+ DOC "The convert program that comes with ImageMagick (available at http://www.imagemagick.org)."
+ )
+set(LATEX_USABLE "ON")
+
+if(NOT LATEX_COMPILER)
+ message(WARNING " Need latex to create documentation!")
+ set(LATEX_USABLE)
+endif(NOT LATEX_COMPILER)
+if(NOT BIBTEX_COMPILER)
+ message(WARNING " Need bibtex to create documentation!")
+ set(LATEX_USABLE)
+endif(NOT BIBTEX_COMPILER)
+if(NOT MAKEINDEX_COMPILER)
+ message(WARNING " Need makeindex to create documentation!")
+ set(LATEX_USABLE)
+endif(NOT MAKEINDEX_COMPILER)
+if(NOT IMAGEMAGICK_CONVERT)
+ message(WARNING " Need imagemagick to create latex documentation!")
+ set(LATEX_USABLE)
+endif(NOT IMAGEMAGICK_CONVERT)
+if(LATEX_USABLE)
+ set(LATEX_MANGLE_TARGET_NAMES "ON" CACHE INTERNAL "Mangle target names to allow multiple latex documents")
+ include(UseLATEX)
+endif(LATEX_USABLE)
+
+
+add_custom_target(doc)
+
+
+MACRO(create_doc_install filename targetdir)
+ dune_common_script_dir(SCRIPT_DIR)
+ get_filename_component(targetfile ${filename} NAME)
+ # The doc file might be in CMAKE_CURRENT_<SOURCE|BINARY>_DIR
+ # Depending on whether this is a tarball or not
+ set(_src_file _src_file-NOTFOUND)
+ find_file(_src_file ${targetfile} ${CMAKE_CURRENT_SOURCE_DIR})
+ if(NOT _src_file)
+ set(_src_file ${filename})
+ set(_need_to_generate TRUE)
+ endif(NOT _src_file)
+ set(install_command ${CMAKE_COMMAND} -D FILES=${_src_file} -D DIR=${CMAKE_INSTALL_PREFIX}/${targetdir} -P ${SCRIPT_DIR}/InstallFile.cmake)
+ # create a custom target for the installation
+ if("${ARGC}" EQUAL "3" AND _need_to_generate)
+ set(_depends ${ARGV2})
+ else("${ARGC}" EQUAL "3" AND _need_to_generate)
+ set(_depends ${_src_file})
+ endif("${ARGC}" EQUAL "3" AND _need_to_generate)
+ add_custom_target(install_${targetfile} ${install_command}
+ COMMENT "Installing ${filename} to ${targetdir}"
+ DEPENDS ${_depends})
+ # When installing, call cmake install with the above install target and add the file to install_manifest.txt
+ install(CODE "execute_process(COMMAND \"${CMAKE_COMMAND}\" --build \"${CMAKE_BINARY_DIR}\" --target install_${targetfile} )
+ LIST(APPEND CMAKE_INSTALL_MANIFEST_FILES ${CMAKE_INSTALL_PREFIX}/${targetdir}/${targetfile})")
+ENDMACRO(create_doc_install)
+
+
+MACRO(dune_add_latex_document tex_file)
+ # We assume that we always generate a PDF file.
+ # If the corresponding pdf file already exists in the source tree
+ # we do not add a rule to build it.
+ string(REGEX REPLACE "(.+).tex" "\\1.pdf" file ${tex_file})
+ string(REGEX REPLACE "/" "_" "${CMAKE_CURRENT_SOURCE_DIR}/${file}" filevar ${file})
+ set(filevar "filevar-NOTFOUND")
+ find_file(filevar ${tex_file} ${CMAKE_CURRENT_SOURCE_DIR})
+ message(filevar=${filevar} tex_file=${tex_file} CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR})
+ if(filevar)
+ if(LATEX_USABLE)
+ # add rule to create latex document
+ add_latex_document(${tex_file} ${ARGN})
+ else(LATEX_USABLE)
+ message(WARNING "Not adding rule to create ${file} as LaTEX is not usable!")
+ endif(LATEX_USABLE)
+ else(filevar)
+ # Check for the pdf file
+ set(pdffilevar "pdffilevar-NOTFOUND")
+ find_file(pdffilevar ${file} ${CMAKE_CURRENT_SOURCE_DIR})
+ if(NOT pdffilevar)
+ message(SEND_ERROR "No tex source ${tex_file} and no generated ${file} found!")
+ endif(NOT pdffilevar)
+ endif(filevar)
+ENDMACRO(dune_add_latex_document tex_file)
+
+# Support building documentation with doxygen.
+include(DuneDoxygen)
diff --git a/cmake/modules/DuneDoxygen.cmake b/cmake/modules/DuneDoxygen.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..0aef15c62428f486318b84ee69fe12da2b4d1e5b
--- /dev/null
+++ b/cmake/modules/DuneDoxygen.cmake
@@ -0,0 +1,90 @@
+# Module for building documentation using doxygen.
+#
+# provides the following macros:
+#
+# add_doxgen_target
+#
+# This macro creates a target for building (doxygen_${DUNE_MOD_NAME}) and installing
+# (doxygen_install_${DUNE_MOD_NAME}) the generated doxygen documentation.
+# The documentation is built during the top-level make doc call. We have added a dependency
+# that makes sure it is built before running make install.
+#
+#
+FIND_PACKAGE(Doxygen)
+
+#
+# Set DOT_TRUE for the Doxyfile generation.
+#
+if (NOT DOXYGEN_DOT_FOUND)
+ set(DOT_TRUE '\#')
+endif (NOT DOXYGEN_DOT_FOUND)
+
+add_custom_target(doxygen_install)
+
+#
+# prepare_doxyfile()
+# This functions adds the necessary routines for the generation of the
+# Doxyfile[.in] files needed to doxygen.
+MACRO (prepare_doxyfile)
+ message(STATUS "using ${DOXYSTYLE_FILE} to create doxystyle file")
+ set(make_doxyfile_command ${CMAKE_COMMAND} -D DOT_TRUE=${DOT_TRUE} -D DUNEWEB_TRUE=\# -D DUNE_MOD_NAME=${DUNE_MOD_NAME} -D DUNE_MOD_VERSION=${DUNE_MOD_VERSION} -D DOXYSTYLE=${DOXYSTYLE_FILE} -D DOXYLOCAL=${CMAKE_CURRENT_SOURCE_DIR}/Doxylocal -D abs_top_srcdir=${CMAKE_SOURCE_DIR} -D srcdir=${CMAKE_CURRENT_SOURCE_DIR} -D top_srcdir=${CMAKE_SOURCE_DIR} -P ${SCRIPT_DIR}/CreateDoxyFile.cmake)
+ add_custom_command (OUTPUT Doxyfile.in Doxyfile
+ COMMAND ${make_doxyfile_command} COMMENT "Creating Doxyfile.in")
+ add_custom_target(Doxyfile DEPENDS Doxyfile.in Doxyfile)
+ENDMACRO (prepare_doxyfile)
+
+#
+# add_doxgen_target
+#
+# This macro creates a target for building (doxygen_${DUNE_MOD_NAME}) and installing
+# (doxygen_install_${DUNE_MOD_NAME}) the generated doxygen documentation.
+# The documentation is built during the top-level make doc call. We have added a dependency
+# that make sure it is built before running make install.
+MACRO (add_doxygen_target)
+ dune_common_script_dir(SCRIPT_DIR)
+ if("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ set(DOXYSTYLE_FILE ${CMAKE_CURRENT_SOURCE_DIR}/Doxystyle)
+ endif("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ message(STATUS "Using scripts from ${SCRIPT_DIR} for creating doxygen stuff.")
+ set(_src_file _src_file-NOTFOUND)
+ find_file(_src_file index.html ${CMAKE_CURRENT_SOURCE_DIR}/html)
+ if(_src_file)
+ set(_src_dir ${CMAKE_CURRENT_SOURCE_DIR})
+ add_custom_target(doxygen_${DUNE_MOD_NAME})
+ else(_src_file)
+ if(DOXYGEN_FOUND)
+ prepare_doxyfile()
+ # A custom command that exectutes doxygen
+ add_custom_command(OUTPUT html COMMAND
+ ${CMAKE_COMMAND} -D DOXYGEN_EXECUTABLE=${DOXYGEN_EXECUTABLE} -P ${SCRIPT_DIR}/RunDoxygen.cmake
+ COMMENT "Running doxygen documentation. This may take a while"
+ DEPENDS Doxyfile)
+ # Create a target for building the doxygen documentation of a module,
+ # that is run during make doc.
+ add_custom_target(doxygen_${DUNE_MOD_NAME} DEPENDS html)
+ add_dependencies(doc doxygen_${DUNE_MOD_NAME})
+ endif(DOXYGEN_FOUND)
+ set(_src_dir ${CMAKE_CURRENT_BINARY_DIR})
+ endif(_src_file)
+
+ # Use a cmake call to install the doxygen documentation and create a
+ # target for it
+ include(GNUInstallDirs)
+ # When installing call cmake install with the above install target
+ install(CODE
+ "execute_process(COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target doxygen_${DUNE_MOD_NAME}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+ file(GLOB doxygenfiles
+ GLOB ${_src_dir}/html/*.html
+ ${_src_dir}/html/*.png
+ ${_src_dir}/html/*.css
+ ${_src_dir}/html/*.gif)
+ set(doxygenfiles \"\${doxygenfiles}\")
+ foreach(_file \${doxygenfiles})
+ get_filename_component(_basename \${_file} NAME)
+ LIST(APPEND CMAKE_INSTALL_MANIFEST_FILES ${CMAKE_INSTALL_FULL_DOCDIR}/doxygen/\${_basename})
+ endforeach(_file in \${doxygenfiles})
+ file(INSTALL \${doxygenfiles} DESTINATION ${CMAKE_INSTALL_FULL_DOCDIR}/doxygen)
+ message(STATUS \"Installed doxygen into ${CMAKE_INSTALL_FULL_DOCDIR}/doxygen\")")
+
+ENDMACRO (add_doxygen_target)
diff --git a/cmake/modules/DuneMPI.cmake b/cmake/modules/DuneMPI.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f6ca504d500593eae263483c358d8d550e731920
--- /dev/null
+++ b/cmake/modules/DuneMPI.cmake
@@ -0,0 +1,67 @@
+# Searches for MPI and thread support and sets the following
+# DUNE specific flags:
+#
+# MPI_DUNE_COMPILE_FLAGS Compiler flags for MPI applications.
+# MPI_DUNE_INCLUDE_PATH Include path for MPI applications.
+# MPI_DUNE_LINK_FLAGS Linker flags for MPI applications.
+# MPI_DUNE_LIBRARIES Libraries for MPI applications.
+#
+# The DUNE way to compile MPI applications is to use the CXX
+# compiler with MPI flags usually used for C. CXX bindings
+# are deactivated to prevent ABI problems.
+#
+# The following function is defined:
+#
+# add_dune_mpi_flags(targets)
+#
+# Adds the above flags and libraries to the specified targets.
+#
+
+find_package(MPI)
+find_package(Threads)
+
+if(MPI_FOUND)
+ set(HAVE_MPI MPI_CXX_FOUND)
+ # We do not support the CXX bindings of MPI
+ set(MPI_DUNE_COMPILE_FLAGS ${MPI_C_COMPILE_FLAGS} CACHE STRING
+ "Compile flags used by DUNE when compiling MPI programs")
+ set(MPI_DUNE_INCLUDE_PATH ${MPI_C_INCLUDE_PATH} CACHE STRING
+ "Include path used by DUNE when compiling MPI programs")
+ # There seems to be no target specific include path, use the global one.
+ include_directories(${MPI_DUNE_INCLUDE_PATH})
+ set(MPI_DUNE_LINK_FLAGS ${MPI_C_LINK_FLAGS} CACHE STRING
+ "Linker flags used by DUNE when compiling MPI programs")
+ set(MPI_DUNE_LIBRARIES ${CMAKE_THREAD_LIBS_INIT} ${MPI_C_LIBRARIES} CACHE STRING
+ "Libraries used by DUNE when linking MPI programs")
+
+ # Check whether the MPI-2 standard is supported
+ include(CMakePushCheckState)
+ include(CheckFunctionExists)
+ cmake_push_check_state()
+ set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES};${MPI_DUNE_LIBRARIES})
+ set(CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} "-DENABLE_MPI=1 -DMPICH_SKIP_MPICXX -DMPIPP_H")
+ set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES};${MPI_DUNE_INCLUDE_PATH})
+ check_function_exists(MPI_Finalized MPI_2)
+ cmake_pop_check_state()
+endif(MPI_FOUND)
+
+# adds MPI flags to the targets
+function(add_dune_mpi_flags)
+ cmake_parse_arguments(ADD_MPI "SOURCE_ONLY;OBJECT" "" "" ${ARGN})
+ if(ADD_MPI_SOURCE_ONLY)
+ set(_prefix SOURCE)
+ else()
+ set(_prefix TARGET)
+ endif()
+ if(MPI_FOUND)
+ set_property(${_prefix} ${ADD_MPI_UNPARSED_ARGUMENTS} APPEND PROPERTY COMPILE_FLAGS ${MPI_DUNE_COMPILE_FLAGS})
+ set_property(${_prefix} ${ADD_MPI_UNPARSED_ARGUMENTS} APPEND PROPERTY COMPILE_DEFINITIONS ENABLE_MPI=1
+ MPICH_SKIP_MPICXX MPIPP_H)
+ if(NOT (ADD_MPI_SOURCE_ONLY OR ADD_MPI_OBJECT))
+ set_property(${_prefix} ${ADD_MPI_UNPARSED_ARGUMENTS} APPEND_STRING PROPERTY LINK_FLAGS ${MPI_DUNE_LINK_FLAGS})
+ foreach(target ${ADD_MPI_UNPARSED_ARGUMENTS})
+ target_link_libraries(${target} ${MPI_DUNE_LIBRARIES})
+ endforeach(target ${ADD_MPI_UNPARSED_ARGUMENTS})
+ endif(NOT (ADD_MPI_SOURCE_ONLY OR ADD_MPI_OBJECT))
+ endif(MPI_FOUND)
+endfunction(add_dune_mpi_flags)
diff --git a/cmake/modules/DuneMacros.cmake b/cmake/modules/DuneMacros.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..8c77a2f0f5750e85c2d1d6750bce89c73ee167ca
--- /dev/null
+++ b/cmake/modules/DuneMacros.cmake
@@ -0,0 +1,883 @@
+# Core DUNE module for CMake.
+#
+# Provides the following macros:
+#
+# dune_module_to_uppercase(upper_name module_name)
+#
+# Converts a module name given by module_name into an uppercase string
+# upper_name where all dashes (-) are replaced by underscores (_)
+# Example: dune-common -> DUNE_COMMON
+#
+# dune_module_information(MODULE_DIR)
+#
+# Parse ${MODULE_DIR}/dune.module and provide that information.
+#
+#
+# dune_project()
+#
+# macro that should be called near the begin of the top level CMakeLists.txt.
+# Namely it sets up the module, defines basic variables and manages
+# depedencies.
+# Don't forget to call finalize_dune_project afterwards.
+#
+#
+# dune_create_dependency_tree()
+#
+# Creates the dependency tree of the module.
+#
+# dune_module_to_macro(_macro_name, _dune_module)
+#
+# Converts a module name given by _dune_module into a string _macro_name
+# where all dashes (-) are removed and letters after a dash are capitalized
+# Example: dune-grid-howto -> DuneGridHowto
+#
+# _macro_name: variable where the name will be stored.
+# _dune_module: the name of the dune module.
+#
+#
+# dune_regenerate_config_cmake()
+#
+# Creates a new config.h.cmake file in ${CMAKE_CURRENT_BINARY_DIR) that
+# consists of entries from ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
+# and includes non-private entries from the files config.h.cmake files
+# of all dependent modules.
+# Finally config.h is created from config.h.cmake.
+#
+#
+# dune_add_library(<basename> [NO_EXPORT] [ADD_LIBS <lib1> [<lib2> ...]]
+# [OBJECT] SOURCES <source1> [<source2> ...] [COMPILE_FLAGS <flags>])
+#
+# Creates shared and static libraries with the same basename.
+# <basename> is the basename of the library.
+# On Unix this creates lib<basename>.so and lib<BASENAME>.a.
+# Libraries that should be incorporate into this libary can
+# be specified with the ADD_LIBS option.
+# The libraries will be built in ${PROJECT_BINARY_DIR}/lib.
+# If the option NO_EXPORT is omitted the library is exported
+# for usage in other modules.
+#
+# Object libraries can now be created with dune_add_library(<target>
+# OBJECT <sources>). It will create a GLOBAL property
+# _DUNE_TARGET_OBJECTS:<target>_ that records the full path to the
+# source files. Theses can later be referenced by providing
+# _DUNE_TARGET_OBJECTS:<target>_ as one of the sources to dune_add_library
+#
+# finalize_dune_project()
+#
+# macro that should be called at the end of the top level CMakeLists.txt.
+# Namely it creates config.h and the cmake-config files,
+# some install directives and exports the module.
+#
+#
+# dune_target_link_libraries(BASENAME, LIBRARIES)
+#
+# Link libraries to the static and shared version of
+# library BASENAME
+#
+
+enable_language(C) # Enable C to skip CXX bindings for some tests.
+
+# Converts a module name given by _module into an uppercase string
+# _upper where all dashes (-) are replaced by underscores (_)
+# Example: dune-common -> DUNE_COMMON
+macro(dune_module_to_uppercase _upper _module)
+ string(TOUPPER "${_module}" ${_upper})
+ string(REPLACE "-" "_" ${_upper} "${${_upper}}")
+endmacro(dune_module_to_uppercase _upper _module)
+
+macro(extract_line HEADER OUTPUT FILE_CONTENT)
+ set(REGEX "${HEADER}[ ]*[^\n]+")
+ string(REGEX MATCH ${REGEX} OUTPUT1 "${FILE_CONTENT}")
+ if(OUTPUT1)
+ set(REGEX "^[ ]*${HEADER}[ ]*(.+)[ ]*$")
+ string(REGEX REPLACE ${REGEX} "\\1" ${OUTPUT} "${OUTPUT1}")
+ else(OUTPUT1)
+ set(OUTPUT OUTPUT-NOTFOUND)
+ endif(OUTPUT1)
+endmacro(extract_line)
+
+macro(split_module_version STRING MODULES VERSIONS)
+ set(REGEX "[a-zA-Z-]+[ ]*(\\([ ]*([^ ]+)?[ ]*[^ ]+[ ]*\\))?")
+ #set(REGEX "dune")
+ string(REGEX MATCHALL "${REGEX}" matches "${STRING}")
+ set(${MODULES} "")
+ set(${VERSION} "")
+ foreach(i ${matches})
+ string(REGEX REPLACE "^([a-zA-Z-]+).*$" "\\1" mod ${i})
+ string(REGEX MATCH "\\([ ]*(([^ ]+)?[ ]*[^ ]+)[ ]*\\)" have_version
+ ${i})
+ if(have_version)
+ string(REGEX REPLACE "^\\([ ]*([^ ]*[ ]*[^ ]+)[ ]*\\)$" "\\1"
+ version ${have_version})
+ else(have_version)
+ set(version >=0.0)
+ endif(have_version)
+ list(APPEND ${MODULES} ${mod})
+ list(APPEND ${VERSIONS} ${version})
+ endforeach(i "${matches}")
+endmacro(split_module_version)
+
+function(convert_deps_to_list var)
+ string(REGEX REPLACE "([a-zA-Z\\)]) ([a-zA-Z])" "\\1;\\2" ${var} ${${var}})
+ set(${var} ${${var}} PARENT_SCOPE)
+endfunction(convert_deps_to_list var)
+
+# add dune-common version from dune.module to config.h
+macro(dune_module_information MODULE_DIR)
+ file(READ "${MODULE_DIR}/dune.module" DUNE_MODULE)
+
+ # find version string
+ extract_line("Version:" MODULE_LINE "${DUNE_MODULE}")
+ if(NOT MODULE_LINE)
+ message(FATAL_ERROR "${MODULE_DIR}/dune.module is missing a version.")
+ endif(NOT MODULE_LINE)
+
+ string(REGEX REPLACE ".*Version:[ ]*([^ \n]+).*" "\\1" DUNE_MOD_VERSION "${MODULE_LINE}")
+ string(REGEX REPLACE "([0-9]).*" "\\1" DUNE_VERSION_MAJOR "${DUNE_MOD_VERSION}")
+ string(REGEX REPLACE "[0-9]*\\.([0-9]).*" "\\1" DUNE_VERSION_MINOR "${DUNE_MOD_VERSION}")
+ string(REGEX REPLACE "[0-9]*\\.[0-9]*\\.([0-9]).*" "\\1" DUNE_VERSION_REVISION "${DUNE_MOD_VERSION}")
+
+ # remove false matches in version string
+ string(REGEX MATCH "[^0-9]" NON_NUMBER_CHARACTER "${DUNE_VERSION_MINOR}")
+ if(NON_NUMBER_CHARACTER)
+ set(DUNE_VERSION_MINOR "0")
+ endif(NON_NUMBER_CHARACTER)
+ string(REGEX MATCH "[^0-9]" NON_NUMBER_CHARACTER "${DUNE_VERSION_REVISION}")
+ if(NON_NUMBER_CHARACTER)
+ set(DUNE_VERSION_REVISION "0")
+ endif(NON_NUMBER_CHARACTER)
+
+ # find strings for module name, maintainer
+ # 1. Check for line starting with Module
+ extract_line("Module:" DUNE_MOD_NAME "${DUNE_MODULE}")
+ if(NOT DUNE_MOD_NAME)
+ message(FATAL_ERROR "${MODULE_DIR}/dune.module is missing a module name.")
+ endif(NOT DUNE_MOD_NAME)
+
+ # 2. Check for line starting with Maintainer
+ extract_line("Maintainer:" DUNE_MAINTAINER "${DUNE_MODULE}")
+ if(NOT DUNE_MAINTAINER)
+ message(FATAL_ERROR "${MODULE_DIR}/dune.module is missing a maintainer.")
+ endif(NOT DUNE_MAINTAINER)
+
+ # 3. Check for line starting with Depends
+ extract_line("Depends:" DUNE_DEPENDS "${DUNE_MODULE}")
+ if(DUNE_DEPENDS)
+ split_module_version(${DUNE_DEPENDS} DEPENDS_MODULE DEPENDS_VERSIONS)
+ foreach(_mod ${DUNE_DEPENDS})
+ set(${_mod}_REQUIRED REQUIRED)
+ endforeach(_mod ${DUNE_DEPENDS})
+ convert_deps_to_list(DUNE_DEPENDS)
+ message(STATUS "Dependencies: ${DEPENDS_MODULE} (versions: ${DEPENDS_VERSIONS}) DUNE_DEPENDS=${DUNE_DEPENDS}")
+ endif(DUNE_DEPENDS)
+
+ # 4. Check for line starting with Suggests
+ extract_line("Suggests:" DUNE_SUGGESTS "${DUNE_MODULE}")
+ if(DUNE_SUGGESTS)
+ split_module_version(${DUNE_SUGGESTS} SUGGESTS_MODULE SUGGESTS_VERSION)
+ convert_deps_to_list(DUNE_SUGGESTS)
+ message(STATUS "Suggestions: ${SUGGESTS_MODULE} (versions: ${SUGGESTS_VERSIONS}) DUNE_SUGGESTS=${DUNE_SUGGESTS}")
+ endif(DUNE_SUGGESTS)
+
+ dune_module_to_uppercase(DUNE_MOD_NAME_UPPERCASE ${DUNE_MOD_NAME})
+
+ # set module version
+ set(${DUNE_MOD_NAME_UPPERCASE}_VERSION "${DUNE_MOD_VERSION}")
+ set(${DUNE_MOD_NAME_UPPERCASE}_VERSION_MAJOR "${DUNE_VERSION_MAJOR}")
+ set(${DUNE_MOD_NAME_UPPERCASE}_VERSION_MINOR "${DUNE_VERSION_MINOR}")
+ set(${DUNE_MOD_NAME_UPPERCASE}_VERSION_REVISION "${DUNE_VERSION_REVISION}")
+endmacro(dune_module_information)
+
+macro(dune_process_dependency_leafs modules versions is_required next_level_deps
+ next_level_sugs)
+ # modules is not a real variable, make it one
+ set(mmodules ${modules})
+ list(LENGTH mmodules mlength)
+ if(mlength GREATER 0)
+ math(EXPR length "${mlength}-1")
+ foreach(i RANGE 0 ${length})
+ list(GET mmodules ${i} _mod)
+ find_package(${_mod} ${REQUIRED})
+ if(${_mod}_MODULE_PATH)
+ list(APPEND CMAKE_MODULE_PATH ${${_mod}_MODULE_PATH})
+ endif(${_mod}_MODULE_PATH)
+ set(${_mod}_SEARCHED ON)
+ if(NOT "${is_required}" STREQUAL "")
+ set(${_mod}_REQUIRED ON)
+ set(${next_level_deps} ${${_mod}_DEPENDS} ${${next_level_deps}})
+ else(NOT "${is_required}" STREQUAL "")
+ set(${next_level_sugs} ${${_mod}_DEPENDS} ${${next_level_sugs}})
+ endif(NOT "${is_required}" STREQUAL "")
+ set(${next_level_sugs} ${${_mod}_SUGGESTS} ${${next_level_sugs}})
+ endforeach(i RANGE 0 ${length})
+ endif(mlength GREATER 0)
+endmacro(dune_process_dependency_leafs)
+
+function(remove_processed_modules modules versions is_required)
+ list(LENGTH ${modules} mlength)
+ if(mlength GREATER 0)
+ math(EXPR length "${mlength}-1")
+ foreach(i RANGE ${length} 0 -1)
+ list(GET ${modules} ${i} _mod)
+ if(${_mod}_SEARCHED)
+ list(REMOVE_AT ${modules} ${i})
+ list(REMOVE_AT ${versions} ${i})
+ if(is_required AND NOT ${_mod}_REQUIRED AND NOT ${_mod}_FOUND)
+ message(FATAL_ERROR "Required module ${_mod} not found!")
+ endif(is_required AND NOT ${_mod}_REQUIRED AND NOT ${_mod}_FOUND)
+ endif(${_mod}_SEARCHED)
+ endforeach(i RANGE 0 ${length})
+ endif(mlength GREATER 0)
+ set(${modules} ${${modules}} PARENT_SCOPE)
+ set(${versions} ${${versions}} PARENT_SCOPE)
+endfunction(remove_processed_modules modules versions is_required)
+
+macro(dune_create_dependency_leafs depends depends_versions suggests suggests_versions
+ global_depends global_suggests)
+ set(deps "")
+ set(sugs "")
+ #Process dependencies
+ if(NOT "${depends}" STREQUAL "")
+ dune_process_dependency_leafs("${depends}" "${depends_versions}" REQUIRED deps sugs)
+ endif(NOT "${depends}" STREQUAL "")
+ # Process suggestions
+ if(NOT "${suggests}" STREQUAL "")
+ dune_process_dependency_leafs("${suggests}" "${suggests_versions}" "" deps sugs)
+ endif(NOT "${suggests}" STREQUAL "")
+ split_module_version("${deps}" next_mod_depends next_depends_versions)
+ #remove_processed_modules(next_mod_depends next_depends_versions REQUIRED)
+ set(${global_depends} "${${global_depends}}" ${next_mod_depends})
+ split_module_version("${sugs}" next_mod_suggests next_suggests_versions)
+ #remove_processed_modules(next_mod_suggests next_suggests_versions "")
+ set(${global_suggests} "${${global_suggests}}" ${next_mod_suggests})
+ # Move to next level
+ if(next_mod_suggests OR next_mod_depends)
+ dune_create_dependency_leafs("${next_mod_depends}" "${next_depends_versions}"
+ "${next_mod_suggests}" "${next_suggests_versions}" global_depends global_suggests)
+ endif(next_mod_suggests OR next_mod_depends)
+endmacro(dune_create_dependency_leafs)
+
+macro(dune_create_dependency_tree)
+ set(ALL_DEPENDENCIES "")
+ if(DEPENDS_MODULE OR SUGGESTS_MODULE)
+ set(global_depends ${DEPENDS_MODULE})
+ set(global_suggests ${SUGGESTS_MODULE})
+ foreach(_mod ${DEPENDS_MODULE})
+ find_package(${_mod} REQUIRED)
+ if(${_mod}_MODULE_PATH)
+ list(APPEND CMAKE_MODULE_PATH ${${_mod}_MODULE_PATH})
+ endif(${_mod}_MODULE_PATH)
+ set(${_mod}_REQUIRED ON)
+ endforeach(_mod ${DEPENDS_MODULE})
+ foreach(_mod ${SUGGESTS_MODULE})
+ find_package(${_mod})
+ if(${_mod}_MODULE_PATH)
+ list(APPEND CMAKE_MODULE_PATH ${${_mod}_MODULE_PATH})
+ endif(${_mod}_MODULE_PATH)
+ set(${_mod}_REQUIRED ON)
+ endforeach(_mod ${SUGGESTS_MODULE})
+ dune_create_dependency_leafs("${DEPENDS_MODULE}" "${DEPENDS_VERSIONS}"
+ "${SUGGESTS_MODULE}" "${SUGGESTS_VERSIONS}" global_depends
+ global_suggests)
+ set(ALL_DEPENDENCIES "${global_depends}" "${global_suggests}")
+ endif(DEPENDS_MODULE OR SUGGESTS_MODULE)
+ # reverse ALL_DEPENDENCIES
+ list(REVERSE ALL_DEPENDENCIES)
+ list(REMOVE_DUPLICATES ALL_DEPENDENCIES)
+ list(REMOVE_DUPLICATES CMAKE_MODULE_PATH)
+endmacro(dune_create_dependency_tree _immediates)
+
+# Converts a module name given by _dune_module into a string _macro_name
+# where all dashes (-) are removed and letters after a dash are capitalized
+# Example: dune-grid-howto -> DuneGridHowto
+macro(dune_module_to_macro _macro_name _dune_module)
+ set(${_macro_name} "")
+ set(_rest "${_dune_module}")
+ string(FIND "${_rest}" "-" _found)
+ while(_found GREATER -1)
+ string(REGEX REPLACE "([^-]*)-.*" "\\1" _first_part
+ "${_rest}")
+ string(REGEX REPLACE "[^-]*-(.*)" "\\1" _rest
+ "${_rest}")
+ string(SUBSTRING "${_first_part}" 0 1 _first_letter)
+ string(SUBSTRING "${_first_part}" 1 -1 _rest_first_part)
+ string(TOUPPER "${_first_letter}" _first_letter)
+ set(${_macro_name} "${${_macro_name}}${_first_letter}${_rest_first_part}")
+ string(FIND "${_rest}" "-" _found)
+ endwhile(_found GREATER -1)
+ string(LENGTH "${_rest}" _length)
+ string(SUBSTRING "${_rest}" 0 1 _first_letter)
+ string(SUBSTRING "${_rest}" 1 -1 _rest)
+ string(TOUPPER "${_first_letter}" _first_letter)
+ set(${_macro_name} "${${_macro_name}}${_first_letter}${_rest}")
+endmacro(dune_module_to_macro _macro_name _dune_module)
+
+macro(dune_process_dependency_tree DEPENDS DVERSIONS SUGGESTS SVERSIONS)
+ foreach(_mod ${ALL_DEPENDENCIES})
+ if(NOT ${_mod}_PROCESSED)
+ # module not processed yet
+ set(${_mod}_PROCESSED ${_mod})
+ # Search for a cmake files containing tests and directives
+ # specific to this module
+ dune_module_to_macro(_cmake_mod_name "${_mod}")
+ set(_macro "${_cmake_mod_name}Macros")
+ set(_mod_cmake _mod_cmake-NOTFOUND) # Prevent false positives due to caching
+ find_file(_mod_cmake ${_macro}.cmake ${CMAKE_MODULE_PATH}
+ NO_DEFAULT_PATH)
+ if(_mod_cmake)
+ message(STATUS "Performing tests specific to ${_mod} from file ${_mod_cmake}.")
+ include(${_mod_cmake})
+ endif(_mod_cmake)
+ # Find the module
+ #find_package(${_mod})
+ # set includes
+ dune_module_to_uppercase(_upper_case "${_mod}")
+ if(${_mod}_INCLUDE_DIRS)
+ message(STATUS "Setting ${_mod}_INCLUDE_DIRS=${${_mod}_INCLUDE_DIRS}")
+ include_directories("${${_mod}_INCLUDE_DIRS}")
+ endif(${_mod}_INCLUDE_DIRS)
+ if(${_mod}_LIBRARIES)
+ message(STATUS "Setting ${_mod}_LIBRARIES=${${_mod}_LIBRARIES}")
+ foreach(_lib ${${_mod}_LIBRARIES})
+ list(INSERT DUNE_DEFAULT_LIBS 0 "${_lib}")
+ list(INSERT DUNE_LIBS 0 "${_lib}")
+ endforeach(_lib ${${_mod}_LIBRARIES})
+ endif(${_mod}_LIBRARIES)
+ message(STATUS "Dependencies for ${_mod}: ${${_mod}_DEPENDENCIES}")
+ endif(NOT ${_mod}_PROCESSED)
+ endforeach(_mod DEPENDENCIES)
+endmacro(dune_process_dependency_tree)
+
+# macro that should be called near the begin of the top level CMakeLists.txt.
+# Namely it sets up the module, defines basic variables and manages
+# depedencies.
+# Don't forget to call finalize_dune_project afterwards.
+macro(dune_project)
+ # Set the flags
+ set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
+ set(CMAKE_C_FLAGS_DEBUG "-g -O0")
+ set(CMAKE_CXX_FLAGS_RELEASE "-funroll-loops -O3")
+ set(CMAKE_C_FLAGS_RELEASE "-funroll-loops -O3")
+
+ # extract information from dune.module
+ dune_module_information(${CMAKE_SOURCE_DIR})
+ set(ProjectName "${DUNE_MOD_NAME}")
+ set(ProjectVersion "${DUNE_MOD_VERSION}")
+ set(ProjectMaintainerEmail "${DUNE_MAINTAINER}")
+
+ dune_create_dependency_tree()
+
+ # assert the project names matches
+ if(NOT (ProjectName STREQUAL CMAKE_PROJECT_NAME))
+ message(FATAL_ERROR "Module name from dune.module does not match the name given in CMakeLists.txt.")
+ endif(NOT (ProjectName STREQUAL CMAKE_PROJECT_NAME))
+
+ # optional Fortran support
+ include(LanguageSupport)
+ workaround_9220(Fortran Fortran_Works)
+ if(Fortran_Works)
+ enable_language(Fortran OPTIONAL)
+ endif(Fortran_Works)
+
+ option(DUNE_USE_ONLY_STATIC_LIBS "If set to ON, we will force static linkage everywhere" OFF)
+ if(DUNE_USE_ONLY_STATIC_LIBS)
+ set(_default_enable_shared OFF)
+ set(_default_enable_static ON)
+ else(DUNE_USE_ONLY_STATIC_LIBS)
+ set(_default_enable_shared ON)
+ set(_default_enable_static OFF)
+ endif(DUNE_USE_ONLY_STATIC_LIBS)
+ option(BUILD_SHARED_LIBS "If set to ON, shared libs will be built" ${_default_enable_shared})
+ option(DUNE_BUILD_BOTH_LIBS "If set to ON, shared and static libs will be built"
+ ${_default_enable_static})
+
+ if(DUNE_USE_ONLY_STATIC_LIBS)
+ # Use only static libraries.
+ # We do this by overriding the library suffixes.
+ set( BLA_STATIC 1)
+ set( _dune_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
+ if (WIN32)
+ set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
+ endif (WIN32)
+ if (APPLE)
+ set(CMAKE_FIND_LIBRARY_SUFFIXES .lib ${CMAKE_FIND_LIBRARY_SUFFIXES})
+ else (APPLE)
+ set(CMAKE_FIND_LIBRARY_SUFFIXES .a )
+ endif (APPLE)
+ endif(DUNE_USE_ONLY_STATIC_LIBS)
+
+ # set required compiler flags for C++11 (former C++0x)
+ find_package(CXX11Features)
+
+ include(DuneCxaDemangle)
+
+ # search for headers
+ include(CheckIncludeFile)
+ include(CheckIncludeFileCXX)
+ check_include_file("malloc.h" HAVE_MALLOC_H)
+ check_include_file("stdint.h" HAVE_STDINT_H)
+ check_include_file_cxx("memory" HAVE_MEMORY)
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -DHAVE_MEMORY=${HAVE_MEMORY}")
+
+ # set include path and link path for the current project.
+ include_directories("${CMAKE_BINARY_DIR}")
+ include_directories("${CMAKE_SOURCE_DIR}")
+ link_directories("${CMAKE_SOURCE_DIR}/lib")
+ include_directories("${CMAKE_CURRENT_BINARY_DIR}")
+ include_directories("/\${CMAKE_CURRENT_SOURCE_DIR}")
+ add_definitions(-DHAVE_CONFIG_H)
+
+ # Search for MPI and set the relevant variables.
+ include(DuneMPI)
+
+ # Make calling fortran routines from C/C++ possible
+ if(Fortran_Works)
+ include(FortranCInterface)
+ FortranCInterface_VERIFY(CXX)
+ # Write FC.h header containing information about
+ # how to call fortran routined.
+ # It will be included in config.h
+ FortranCInterface_HEADER(FC.h MACRO_NAMESPACE "FC_")
+ else(Fortran_Works)
+ # Write empty FC.h header
+ file(WRITE ${CMAKE_BINARY_DIR}/FC.h "")
+ endif(Fortran_Works)
+
+ # Create custom target for building the documentation
+ # and provide macros for installing the docs and force
+ # building them before.
+ include(DuneDoc)
+
+ # activate testing the DUNE way
+ include(DuneTests)
+
+ # activate pkg-config
+ include(DunePkgConfig)
+
+ dune_process_dependency_tree("${DEPENDS_MODULE}" "${DEPENDS_VERSION}"
+ "${SUGGESTS_MODULE}" "${SUGGESTS_VERSION}")
+
+ # Search for cmake files containing tests and directives
+ # specific to this module
+ dune_module_to_macro(_macro ${DUNE_MOD_NAME})
+ set(DUNE_MOD_NAME_CMAKE "${_macro}")
+ set(_macro "${_macro}Macros")
+ set(_mod_cmake _mod_cmake-NOTFOUND) # Prevent false positives due to caching
+ find_file(_mod_cmake ${_macro}.cmake ${CMAKE_MODULE_PATH}
+ ${CMAKE_SOURCE_DIR}/cmake/modules NO_DEFAULT_PATH)
+ if(_mod_cmake)
+ set(${DUNE_MOD_NAME_CMAKE}_FOUND FOUND)
+ message(STATUS " Performing tests specific to ${DUNE_MOD_NAME} from file ${_mod_cmake}.")
+ include(${_mod_cmake})
+ else(_mod_cmake)
+ message(STATUS "There are no tests for module ${DUNE_MOD_NAME}.")
+ endif(_mod_cmake)
+ include(GNUInstallDirs)
+ # Set variable where the cmake modules will be installed.
+ # Thus the user can override it and for example install
+ # directly into the CMake installation. This has to be an
+ # absolute path. Default: ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/cmake/modules
+ if(NOT DEFINED DUNE_INSTALL_MODULEDIR)
+ set(DUNE_INSTALL_MODULEDIR ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/cmake/modules
+ CACHE PATH
+ "Installation directory for CMake modules. Be careful when overriding this as the modules might not be found any more. Might be set to ${CMAKE_ROOT}/Modules or better \${CMAKE_ROOT}/Modules to make the modules available to all CMake runs. This has to be an absolute path. Default: \${CMAKE_INSTALL_PREFIX}/\${CMAKE_INSTALL_DATAROOTDIR}/cmake/modules")
+ endif()
+endmacro(dune_project MODULE_DIR)
+
+# create a new config.h file and overwrite the existing one
+macro(dune_regenerate_config_cmake)
+ set(CONFIG_H_CMAKE_FILE "${CMAKE_BINARY_DIR}/config.h.cmake")
+ if(EXISTS ${CMAKE_SOURCE_DIR}/config.h.cmake)
+ file(READ ${CMAKE_SOURCE_DIR}/config.h.cmake _file)
+ string(REGEX MATCH
+ "/[\\*/][ ]*begin[ ]+${DUNE_MOD_NAME}.*\\/[/\\*][ ]*end[ ]*${DUNE_MOD_NAME}[^\\*]*\\*/"
+ _myfile "${_file}")
+ endif(EXISTS ${CMAKE_SOURCE_DIR}/config.h.cmake)
+ # overwrite file with new content
+ file(WRITE ${CONFIG_H_CMAKE_FILE} "/* config.h. Generated from config.h.cmake by CMake.
+ It was generated from config.h.cmake which in turn is generated automatically
+ from the config.h.cmake files of modules this module depends on. */"
+ )
+
+ # define that we found this module
+ set(${DUNE_MOD_NAME}_FOUND 1)
+
+ foreach(_dep ${DUNE_MOD_NAME} ${ALL_DEPENDENCIES})
+ dune_module_to_uppercase(upper ${_dep})
+ set(HAVE_${upper} ${${_dep}_FOUND})
+ file(APPEND ${CONFIG_H_CMAKE_FILE}
+ "\n\n/* Define to 1 if you have module ${_dep} available */
+#cmakedefine01 HAVE_${upper}\n")
+ endforeach(_dep ${DUNE_MOD_NAME} ${ALL_DEPENDENCIES})
+
+ # add previous module specific section
+ foreach(_dep ${ALL_DEPENDENCIES})
+ foreach(_mod_conf_file ${${_dep}_PREFIX}/config.h.cmake
+ ${${_dep}_PREFIX}/share/${_dep}/config.h.cmake)
+ if(EXISTS ${_mod_conf_file})
+ file(READ "${_mod_conf_file}" _file)
+ string(REGEX REPLACE
+ ".*/\\*[ ]*begin[ ]+${_dep}[^\\*]*\\*/(.*)/[/\\*][ ]*end[ ]*${_dep}[^\\*]*\\*/" "\\1"
+ _tfile "${_file}")
+ # strip the private section
+ string(REGEX REPLACE "(.*)/[\\*][ ]*begin private.*/[\\*][ ]*end[ ]*private[^\\*]\\*/(.*)" "\\1\\2" _file "${_tfile}")
+ file(APPEND ${CONFIG_H_CMAKE_FILE} "${_file}")
+ endif(EXISTS ${_mod_conf_file})
+ endforeach()
+ endforeach(_dep ${ALL_DEPENDENCIES})
+ file(APPEND ${CONFIG_H_CMAKE_FILE} "\n${_myfile}")
+endmacro(dune_regenerate_config_cmake)
+
+# macro that should be called at the end of the top level CMakeLists.txt.
+# Namely it creates config.h and the cmake-config files,
+# some install directives and exports the module.
+macro(finalize_dune_project)
+ #create cmake-config files for build tree
+ configure_file(
+ ${PROJECT_SOURCE_DIR}/${DUNE_MOD_NAME}-config.cmake.in
+ ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-config.cmake @ONLY)
+
+ #create cmake-config files for installation tree
+ configure_file(
+ ${PROJECT_SOURCE_DIR}/cmake/pkg/${DUNE_MOD_NAME}-config.cmake.in
+ ${PROJECT_BINARY_DIR}/cmake/pkg/${DUNE_MOD_NAME}-config.cmake @ONLY)
+ list(LENGTH DEPENDS_MODULE mlength)
+ math(EXPR len2 "${mlength}-1")
+ if(mlength GREATER 0)
+ foreach(i RANGE 0 ${len2})
+ list(GET DEPENDS_MODULE ${i} _mod)
+ dune_module_to_macro(_macro ${_mod})
+ list(GET DEPENDS_VERSION ${i} _ver)
+ #file(APPEND ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-config.cmake
+ #"find_package(${_mod})\n")#include(${_macro}Macros)\n")
+ #file(APPEND ${PROJECT_BINARY_DIR}/cmake/pkg/${DUNE_MOD_NAME}-config.cmake
+ #"find_package(${_mod})\n")#include(${_macro}Macros)\n")
+ endforeach(i RANGE 0 ${mlength})
+ endif(mlength GREATER 0)
+
+ if(${DUNE_MOD_NAME_CMAKE}_FOUND)
+ # This module hast its own tests.
+ # Execute them during find_package
+ #file(APPEND ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-config.cmake
+ # "include(${DUNE_MOD_NAME_CMAKE}Macros)\n")
+ #file(APPEND ${PROJECT_BINARY_DIR}/cmake/pkg/${DUNE_MOD_NAME}-config.cmake
+ # "\ninclude(${DUNE_MOD_NAME_CMAKE}Macros)\n")
+ endif(${DUNE_MOD_NAME_CMAKE}_FOUND)
+ configure_file(
+ ${PROJECT_SOURCE_DIR}/${DUNE_MOD_NAME}-version.cmake.in
+ ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-version.cmake @ONLY)
+
+ #install dune.module file
+ install(FILES dune.module DESTINATION lib/dunecontrol/${DUNE_MOD_NAME})
+
+ #install cmake-config files
+ install(FILES ${PROJECT_BINARY_DIR}/cmake/pkg/${DUNE_MOD_NAME}-config.cmake
+ ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-version.cmake
+ DESTINATION lib/cmake/${DUNE_MOD_NAME})
+
+ #install config.h
+ if(EXISTS ${CMAKE_SOURCE_DIR}/config.h.cmake)
+ install(FILES config.h.cmake DESTINATION share/${DUNE_MOD_NAME})
+ endif(EXISTS ${CMAKE_SOURCE_DIR}/config.h.cmake)
+ export(PACKAGE ${DUNE_MOD_NAME})
+
+ if("${ARGC}" EQUAL "1")
+ message(STATUS "Adding custom target for config.h generation")
+ dune_regenerate_config_cmake()
+ # add a target to generate config.h.cmake
+ add_custom_target(OUTPUT config.h.cmake
+ COMMAND dune_regenerate_config_cmake()
+ DEPENDS stamp-regenerate-config-h)
+ # actually write the config.h file to disk
+ # using generated file
+ configure_file(${CMAKE_CURRENT_BINARY_DIR}/config.h.cmake
+ ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+ else("${ARGC}" EQUAL "1")
+ message(STATUS "Not adding custom target for config.h generation")
+ # actually write the config.h file to disk
+ configure_file(config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+ endif("${ARGC}" EQUAL "1")
+
+ test_dep()
+endmacro(finalize_dune_project)
+
+macro(target_link_dune_default_libraries _target)
+ foreach(_lib ${DUNE_DEFAULT_LIBS})
+ target_link_libraries(${_target} ${_lib})
+ endforeach(_lib ${DUNE_DEFAULT_LIBS})
+endmacro(target_link_dune_default_libraries)
+
+# Gets path to the common Dune CMake scripts
+macro(dune_common_script_dir _script_dir)
+ if("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ set(${_script_dir} ${CMAKE_SOURCE_DIR}/cmake/scripts)
+ else("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ set(${_script_dir} ${dune-common_SCRIPT_DIR})
+ endif("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+endmacro(dune_common_script_dir)
+
+# Gets path to the common Dune CMake scripts source
+macro(dune_common_script_source_dir _script_dir)
+ if("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ set(${_script_dir} ${CMAKE_SOURCE_DIR}/cmake/scripts)
+ else("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+ set(${_script_dir} ${dune-ommon_SCRIPT_SOURCE_DIR})
+ endif("${CMAKE_PROJECT_NAME}" STREQUAL "dune-common")
+endmacro(dune_common_script_source_dir)
+
+function(dune_expand_object_libraries _SOURCES_var _ADD_LIBS_var _COMPILE_FLAGS_var)
+ set(_new_SOURCES "")
+ set(_new_ADD_LIBS "${${_ADD_LIBS_var}}")
+ set(_new_COMPILE_FLAGS "${${_COMPILE_FLAGS_var}}")
+ set(_regex "_DUNE_TARGET_OBJECTS:([a-zA-Z0-9_-]+)_")
+ foreach(_source ${${_SOURCES_var}})
+ string(REGEX MATCH ${_regex} _matched "${_source}")
+ if(_matched)
+ string(REGEX REPLACE "${_regex}" "\\1" _basename "${_source}")
+ foreach(var _SOURCES _ADD_LIBS _COMPILE_FLAGS)
+ get_property(_prop GLOBAL PROPERTY DUNE_LIB_${_basename}${var})
+ list(APPEND _new${var} "${_prop}")
+ endforeach(var _SOURCES _ADD_LIBS _COMPILE_FLAGS)
+ else(_matched)
+ list(APPEND _new_SOURCES "${_source}")
+ endif(_matched)
+ endforeach(_source ${${_SOURCES_var}})
+
+ foreach(var _SOURCES _ADD_LIBS _COMPILE_FLAGS)
+ set(${${var}_var} "${_new${var}}" PARENT_SCOPE)
+ endforeach(var _SOURCES _ADD_LIBS _COMPILE_FLAGS)
+endfunction(dune_expand_object_libraries)
+
+# Creates shared and static libraries with the same basename.
+# More docu can be found at the top of this file.
+macro(dune_add_library basename)
+ include(CMakeParseArguments)
+ cmake_parse_arguments(DUNE_LIB "NO_EXPORT;OBJECT" "COMPILE_FLAGS"
+ "ADD_LIBS;SOURCES" ${ARGN})
+ if(DUNE_LIB_OBJECT)
+ if(DUNE_LIB_${basename}_SOURCES)
+ message(FATAL_ERROR "There is already a library with the name ${basename}, "
+ "but only one is allowed!")
+ else(DUNE_LIB_${basename}_SOURCES)
+ foreach(source ${DUNE_LIB_UNPARSED_ARGUMENTS})
+ list(APPEND full_path_sources ${CMAKE_CURRENT_SOURCE_DIR}/${source})
+ endforeach(source ${DUNE_LIB_UNPARSED_ARGUMENTS})
+ # register sources, libs and flags for building the library later
+ define_property(GLOBAL PROPERTY DUNE_LIB_${basename}_SOURCES
+ BRIEF_DOCS "Convenience property with sources for library ${basename}. DO NOT EDIT!"
+ FULL_DOCS "Convenience property with sources for library ${basename}. DO NOT EDIT!")
+ set_property(GLOBAL PROPERTY DUNE_LIB_${basename}_SOURCES
+ "${full_path_sources}")
+ define_property(GLOBAL PROPERTY DUNE_LIB_${basename}_ADD_LIBS
+ BRIEF_DOCS "Convenience property with libraries for library ${basename}. DO NOT EDIT!"
+ FULL_DOCS "Convenience property with libraries for library ${basename}. DO NOT EDIT!")
+ set_property(GLOBAL PROPERTY DUNE_LIB_${basename}_ADD_LIBS
+ "${DUNE_LIB_ADD_LIBS}")
+ define_property(GLOBAL PROPERTY DUNE_LIB_${basename}_COMPILE_FLAGS
+ BRIEF_DOCS "Convenience property with compile flags for library ${basename}. DO NOT EDIT!"
+ FULL_DOCS "Convenience property with compile flags for library ${basename}. DO NOT EDIT!")
+ set_property(GLOBAL PROPERTY DUNE_LIB_${basename}_COMPILE_FLAGS
+ "${DUNE_LIB_COMPILE_FLAGS}")
+ endif(DUNE_LIB_${basename}_SOURCES)
+ else(DUNE_LIB_OBJECT)
+ list(APPEND DUNE_LIB_SOURCES ${DUNE_LIB_UNPARSED_ARGUMENTS})
+ dune_expand_object_libraries(DUNE_LIB_SOURCES DUNE_LIB_ADD_LIBS DUNE_LIB_COMPILE_FLAGS)
+ #create lib
+ add_library(${basename} ${DUNE_LIB_SOURCES})
+ # link with specified libraries.
+ if(DUNE_LIB_ADD_LIBS)
+ dune_target_link_libraries(${basename} ${DUNE_LIB_ADD_LIBS})
+ endif(DUNE_LIB_ADD_LIBS)
+ if(DUNE_LIB_COMPILE_FLAGS)
+ setproperty(${basename} APPEND_STRING COMPILE_FLAGS
+ "${DUNE_LIB_COMPILE_FLAGS}")
+ endif(DUNE_LIB_COMPILE_FLAGS)
+ # Build library in ${PROJECT_BINARY_DIR}/lib
+ set_target_properties(${basename} PROPERTIES
+ LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib"
+ ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+
+ set(_created_libs ${basename})
+
+ if(DUNE_BUILD_BOTH_LIBS)
+ if(BUILD_SHARED_LIBS)
+ #create static lib
+ add_library(${basename}-static STATIC ${DUNE_LIB_SOURCES})
+ # make sure both libs have the same name.
+ set_target_properties(${basename}-static PROPERTIES
+ OUTPUT_NAME ${basename}
+ ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+ list(APPEND _created_libs ${basename}-static)
+ # link with specified libraries.
+ if(DUNE_LIB_ADD_LIBS)
+ dune_target_link_libraries(${basename}-static ${DUNE_LIB_ADD_LIBS})
+ endif(DUNE_LIB_ADD_LIBS)
+ if(DUNE_LIB_COMPILE_FLAGS)
+ setproperty(${basename}-static APPEND_STRING COMPILE_FLAGS
+ "${DUNE_LIB_COMPILE_FLAGS}")
+ endif(DUNE_LIB_COMPILE_FLAGS)
+ else(BUILD_SHARED_LIBS)
+ #create shared libs
+ add_library(${basename}-shared SHARED ${DUNE_LIB_SOURCES})
+ set_target_properties(${basename}-shared PROPERTIES
+ OUTPUT_NAME ${basename}
+ LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/lib")
+ # link with specified libraries.
+ if(DUNE_LIB_ADD_LIBS)
+ dune_target_link_libraries(${basename}-shared ${DUNE_LIB_ADD_LIBS})
+ endif(DUNE_LIB_ADD_LIBS)
+ if(DUNE_LIB_COMPILE_FLAGS)
+ setproperty(${basename}-shared APPEND_STRING COMPILE_FLAGS
+ "${DUNE_LIB_COMPILE_FLAGS}")
+ endif(DUNE_LIB_COMPILE_FLAGS)
+ list(APPEND _created_libs ${basename}-shared)
+ endif(BUILD_SHARED_LIBS)
+ endif(DUNE_BUILD_BOTH_LIBS)
+
+ if(NOT DUNE_LIB_NO_EXPORT)
+ if(NOT _MODULE_EXPORT_USED)
+ set(_MODULE_EXPORT_USED ON)
+ set(_append "")
+ else(NOT _MODULE_EXPORT_USED)
+ set(_append APPEND)
+ endif(NOT _MODULE_EXPORT_USED)
+ # install targets to use the libraries in other modules.
+ install(TARGETS ${_created_libs}
+ EXPORT ${DUNE_MOD_NAME}-targets DESTINATION lib)
+ install(EXPORT ${DUNE_MOD_NAME}-targets
+ DESTINATION lib/cmake)
+
+ # export libraries for use in build tree
+ export(TARGETS ${_created_libs} ${_append}
+ FILE ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}-targets.cmake)
+ endif(NOT DUNE_LIB_NO_EXPORT)
+ endif(DUNE_LIB_OBJECT)
+endmacro(dune_add_library basename sources)
+
+macro(replace_properties_for_one)
+ get_property(properties ${option_command} ${_target}
+ PROPERTY ${REPLACE_PROPERTY})
+ if(NOT properties)
+ # property not set. set it directly
+ foreach(i RANGE 0 ${hlength})
+ math(EXPR idx "(2 * ${i}) + 1")
+ list(GET REPLACE_UNPARSED_ARGUMENTS ${idx} repl)
+ list(APPEND replacement ${repl})
+ endforeach(i RANGE 0 ${hlength})
+ list(REMOVE_DUPLICATES replacement)
+ set_property(${option_command} ${_target} ${REPLACE_APPEND}
+ ${REPLACE_APPEND_STRING} PROPERTY ${REPLACE_PROPERTY} ${replacement})
+ else(NOT properties)
+ foreach(prop ${properties})
+ set(matched FALSE)
+ foreach(i RANGE 0 ${hlength})
+ math(EXPR regexi "2 * ${i}")
+ math(EXPR repli "${regexi} +1")
+ list(GET REPLACE_UNPARSED_ARGUMENTS ${regexi} regex)
+ list(GET REPLACE_UNPARSED_ARGUMENTS ${repli} replacement)
+ string(REGEX MATCH ${regex} match ${prop})
+
+ if(match)
+ list(APPEND new_props ${replacement})
+ set(matched TRUE)
+ endif(match)
+ endforeach(i RANGE 0 ${hlength})
+
+ if(NOT matched)
+ list(APPEND new_props ${prop})
+ endif(NOT matched)
+ endforeach(prop ${properties})
+ list(REMOVE_DUPLICATES new_props)
+ set_property(${option_command} ${_target}
+ PROPERTY ${REPLACE_PROPERTY} ${new_props})
+ endif(NOT properties)
+ get_property(properties ${option_command} ${_target} PROPERTY ${REPLACE_PROPERTY})
+endmacro(replace_properties_for_one)
+
+function(dune_target_link_libraries basename libraries)
+ target_link_libraries(${basename} ${libraries})
+ if(DUNE_BUILD_BOTH_LIBS)
+ if(BUILD_SHARED_LIBS)
+ target_link_libraries(${basename}-static ${libraries})
+ else(BUILD_SHARED_LIBS)
+ target_link_libraries(${basename}-shared ${libraries})
+ endif(BUILD_SHARED_LIBS)
+ endif(DUNE_BUILD_BOTH_LIBS)
+endfunction(dune_target_link_libraries basename libraries)
+
+function(replace_properties)
+ include(CMakeParseArguments)
+ set(_first_opts "GLOBAL;DIRECTORY;TARGET;SOURCE;CACHE")
+ cmake_parse_arguments(REPLACE "GLOBAL"
+ "DIRECTORY;PROPERTY" "TARGET;SOURCE;TEST;CACHE" ${ARGN})
+
+ set(MY_DIRECTORY TRUE)
+ foreach(i ${_first_opts})
+ if(REPLACE_${i})
+ set(MY_DIRECTORY FALSE)
+ endif(REPLACE_${i})
+ endforeach(i ${_first_opts})
+ if(NOT MY_DIRECTORY)
+ list(FIND REPLACE_UNPARSED_ARGUMENTS DIRECTORY _found)
+ if(_found GREATER -1)
+ list(REMOVE_AT REPLACE_UNPARSED_ARGUMENTS ${_found})
+ set(MY_DIRECTORY TRUE)
+ set(REPLACE_DIRECTORY "")
+ endif(_found GREATER -1)
+ else(NOT MY_DIRECTORY)
+ #set(REPLACE_PROPERTY
+ endif(NOT MY_DIRECTORY)
+
+ #setup options
+ if(REPLACE_GLOBAL)
+ set(option_command GLOBAL)
+ elseif(MY_DIRECTORY)
+ set(option_command DIRECTORY)
+ elseif(REPLACE_DIRECTORY)
+ set(option_command DIRECTORY)
+ set(option_arg ${REPLACE_DIRECTORY})
+ elseif(REPLACE_TARGET)
+ set(option_command TARGET)
+ set(option_arg ${REPLACE_TARGET})
+ elseif(REPLACE_SOURCE)
+ set(option_command SOURCE)
+ set(option_arg ${REPLACE_SOURCE})
+ elseif(REPLACE_TEST)
+ set(option_command TEST)
+ set(option_arg${REPLACE_TEST})
+ elseif(REPLACE_CACHE)
+ set(option_command CACHE)
+ set(option_arg ${REPLACE_CACHE})
+ endif()
+
+ if(NOT (REPLACE_CACHE OR REPLACE_TEST OR REPLACE_SOURCE
+ OR REPLACE_TARGET OR REPLACE_DIRECTORY OR REPLACE_GLOBAL
+ OR MY_DIRECTORY))
+ message(ERROR "One of GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, or CACHE"
+ " has to be present")
+ endif()
+
+ list(LENGTH REPLACE_UNPARSED_ARGUMENTS length)
+# if(NOT (REPLACE_GLOBAL AND REPLACE_TARGET AND
+# REPLACE_SOURCE AND REPLACE
+ math(EXPR mlength "${length} % 2 ")
+ math(EXPR hlength "${length} / 2 - 1")
+
+ if(NOT ${mlength} EQUAL 0)
+ message(ERROR "You need to specify pairs consisting of a regular expression and a replacement string.")
+ endif(NOT ${mlength} EQUAL 0)
+
+ if(NOT length GREATER 0)
+ message(ERROR "You need to specify at least on pair consisting of a regular expression
+and a replacement string. ${REPLACE_UNPARSED_ARGUMENTS}")
+ endif(NOT length GREATER 0)
+
+ foreach(_target ${option_arg})
+ replace_properties_for_one()
+ endforeach(_target ${option_arg})
+
+ list(LENGTH option_arg _length)
+ if(_length EQUAL 0)
+ replace_properties_for_one()
+ endif(_length EQUAL 0)
+endfunction(replace_properties)
diff --git a/cmake/modules/DunePkgConfig.cmake b/cmake/modules/DunePkgConfig.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..20197e932fc1ba42243e735f041be71d6d0930d4
--- /dev/null
+++ b/cmake/modules/DunePkgConfig.cmake
@@ -0,0 +1,30 @@
+# searches for pkg-config, creates the
+# file <module-name>.pc from <module-name>.pc.in,
+# and adds installation directives.
+#
+
+find_package(PkgConfig)
+
+# set some variables that are used in the pkg-config file
+set( prefix ${CMAKE_INSTALL_PREFIX})
+set(exec_prefix "\${prefix}")
+set(libdir "\${exec_prefix}/lib")
+set(includedir "\${prefix}/include")
+set(PACKAGE_NAME ${DUNE_MOD_NAME})
+set(VERSION ${DUNE_MOD_VERSION})
+set(CC ${CMAKE_C_COMPILER})
+set(CXX "${CMAKE_CXX_COMPILER} ${CXX_STD11_FLAGS}")
+
+set(REQUIRES ${DUNE_DEPENDS})
+#create pkg-config file
+configure_file(
+ ${PROJECT_SOURCE_DIR}/${DUNE_MOD_NAME}.pc.in
+ ${PROJECT_BINARY_DIR}/${DUNE_MOD_NAME}.pc
+ @ONLY
+)
+
+# install pkgconfig file
+if(PKG_CONFIG_FOUND )
+ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DUNE_MOD_NAME}.pc
+ DESTINATION lib/pkgconfig)
+endif(PKG_CONFIG_FOUND)
diff --git a/cmake/modules/DuneStreams.cmake b/cmake/modules/DuneStreams.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..bd1f5068b4a30ad48077a4f1e52df197c329fb9a
--- /dev/null
+++ b/cmake/modules/DuneStreams.cmake
@@ -0,0 +1,20 @@
+# Module configures the DUNE debug streams.
+# A default debug level can be specified with
+# MINIMAL_DEBUG_LEVEL
+#
+macro(dune_set_minimal_debug_level)
+set(MINIMAL_DEBUG_LEVEL ON CACHE STRING "set the MINIMAL_DEBUG_LEVEL. Standard debug streams with level below MINIMAL_DEBUG_LEVEL will collapse to doing nothing if output is requested. (default=warn)")
+set_property(CACHE MINIMAL_DEBUG_LEVEL PROPERTY STRINGS
+ "grave" "warn" "info" "verb" "vverb")
+if(MINIMAL_DEBUG_LEVEL MATCHES "grave")
+ set(DUNE_MINIMAL_DEBUG_LEVEL 5)
+elseif(MINIMAL_DEBUG_LEVEL MATCHES "info")
+ set(DUNE_MINIMAL_DEBUG_LEVEL 3)
+elseif(MINIMAL_DEBUG_LEVEL MATCHES "verb")
+ set(DUNE_MINIMAL_DEBUG_LEVEL 2)
+elseif(MINIMAL_DEBUG_LEVEL MATCHES "vverb")
+ set(DUNE_MINIMAL_DEBUG_LEVEL 1)
+else()
+ set(DUNE_MINIMAL_DEBUG_LEVEL 4)
+endif()
+endmacro(dune_set_minimal_debug_level)
diff --git a/cmake/modules/DuneTestMacros.cmake b/cmake/modules/DuneTestMacros.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..a1c4ae4005818429a478ea8e946b6c8438ce53af
--- /dev/null
+++ b/cmake/modules/DuneTestMacros.cmake
@@ -0,0 +1,53 @@
+# Module provides macros that allow for on demand test building.
+# In DUNE tests are not built by make all but by make test.
+#
+# Provides the following macros:
+#
+# test_dep()
+#
+# Finds all directories called test and creates a dependency for
+# testing that calls builds the tests for this directory.
+#
+#
+# add_directory_test_target(_target)
+#
+# Creates a custom target for building
+# the tests in the current directory.
+#
+# The target name will be the path of the
+# current directory relative to ${CMAKE_BINARY_DIR}
+# with all slashes replaced by underlines.
+# E.g. for dune/istl/test the target will be dune_istl_test.
+#
+macro(test_dep)
+ dune_common_script_dir(SCRIPT_DIR)
+ execute_process(COMMAND ${CMAKE_COMMAND} -D RELPATH=${CMAKE_SOURCE_DIR} -P ${SCRIPT_DIR}/FindFiles.cmake
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+ RESULT_VARIABLE _res ERROR_VARIABLE _dirs)
+
+ foreach(_dir ${_dirs})
+ string(REGEX REPLACE "([^ \t\n]+)[ \n\t]*$" "\\1" _dir ${_dir})
+ set_property(DIRECTORY ${_dir} PROPERTY TEST_INCLUDE_FILE ${CMAKE_BINARY_DIR}/${_dir}/BuildTests.cmake)
+ endforeach(_dir ${_dirs})
+endmacro(test_dep)
+
+macro(get_directory_test_target _target _dir)
+ string(REPLACE "${CMAKE_BINARY_DIR}" "" _relative_dir "${_dir}")
+ string(REPLACE "/" "_" ${_target} "${_relative_dir}")
+endmacro(get_directory_test_target _target _dir)
+
+#
+# - Create a custom target for building
+# the tests in the current directory.
+#
+# The target name will be the path of the
+# current directory relative to ${CMAKE_BINARY_DIR}
+# with all slashes replaced by underlines.
+# E.g. for dune/istl/test the target will be dune_istl_test.
+#
+macro(add_directory_test_target _target)
+ get_directory_test_target(${_target} "${CMAKE_CURRENT_BINARY_DIR}")
+ add_custom_target(${${_target}})
+ dune_common_script_dir(SCRIPT_DIR)
+ configure_file(${SCRIPT_DIR}/BuildTests.cmake.in BuildTests.cmake @ONLY)
+endmacro(add_directory_test_target)
diff --git a/cmake/modules/DuneTests.cmake b/cmake/modules/DuneTests.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f711f7a8b93da5ab89b63d8e3534c108869bd360
--- /dev/null
+++ b/cmake/modules/DuneTests.cmake
@@ -0,0 +1,19 @@
+# Create a custom target for building the tests.
+# Thus they will not be built by make all any more.
+# Actually I wanted this target to be a dependency
+# of make test but that is currently not possible.
+# See http://public.kitware.com/Bug/view.php?id=8438
+# This really sucks!
+# Therefore currently make build_tests has to be called
+# before make test.
+
+# enable testing before adding the subdirectories.
+# Thus we can add the tests in the subdirectories
+# where they actually are.
+enable_testing()
+
+#activate CTest
+include(CTest)
+
+#include our macros
+include(DuneTestMacros)
diff --git a/cmake/modules/FindBoostFusion.cmake b/cmake/modules/FindBoostFusion.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..86162fed4d43c29e7d5bdbdee924e7641933b4a6
--- /dev/null
+++ b/cmake/modules/FindBoostFusion.cmake
@@ -0,0 +1,19 @@
+#
+# Module that checks whether boost::fusion is available and usable.
+#
+# Sets the follwing variable:
+#
+# HAVE_BOOST_FUSION True if boost::fusion is available.
+#
+include(DuneBoost)
+
+message(STATUS "Checking whether the Boost::FUSION library is available")
+check_cxx_source_compiles("
+\#include <boost/fusion/container.hpp>
+int main(){
+ boost::fusion::vector<int,char,double> v;
+ return 0;
+}" HAVE_BOOST_FUSION )
+if(HAVE_BOOST_FUSION)
+message(STATUS "Boost::FUSION is available")
+endif(HAVE_BOOST_FUSION)
diff --git a/cmake/modules/FindCXX11Features.cmake b/cmake/modules/FindCXX11Features.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d8627cc2c92736245d8c1bf38c1d880ba34b075e
--- /dev/null
+++ b/cmake/modules/FindCXX11Features.cmake
@@ -0,0 +1,295 @@
+#
+# Module that checks for supported C++11 (former C++0x) features.
+#
+# Sets the follwing variable:
+#
+# HAVE_NULLPTR True if nullptr is available
+# HAVE_ARRAY True if header <array> and fill() are available
+# HAVE_ATTRIBUTE_ALWAYS_INLINE True if attribute always inline is supported
+# HAS_ATTRIBUTE_UNUSED True if attribute unused is supported
+# HAS_ATTRIBUTE_DEPRECATED True if attribute deprecated is supported
+# HAS_ATTRIBUTE_DEPRECATED_MSG True if attribute deprecated("msg") is supported
+# HAVE_INTEGRAL_CONSTANT True if compiler supports integral_constant
+# HAVE_STATIC_ASSERT True if static_assert is available
+# HAVE_VARIADIC_TEMPLATES True if variadic templates are supprt
+# HAVE_VARIADIC_CONSTRUCTOR_SFINAE True if variadic constructor sfinae is supported
+# HAVE_RVALUE_REFERENCES True if rvalue references are supported
+
+include(CMakePushCheckState)
+cmake_push_check_state()
+
+# test for C++11 flags
+include(TestCXXAcceptsFlag)
+
+# try to use compiler flag -std=c++11
+CHECK_CXX_ACCEPTS_FLAG("-std=c++11" CXX_FLAG_CXX11)
+if(CXX_FLAG_CXX11)
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++11")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ")
+ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++11 ")
+ set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -std=c++11 ")
+ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++11 ")
+ set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -std=c++11 ")
+ set(CXX_STD11_FLAGS "-std=c++11")
+else()
+ # try to use compiler flag -std=c++0x for older compilers
+ CHECK_CXX_ACCEPTS_FLAG("-std=c++0x" CXX_FLAG_CXX0X)
+ if(CXX_FLAG_CXX0X)
+ set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -std=c++0x" )
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x ")
+ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -std=c++0x ")
+ set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -std=c++0x ")
+ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -std=c++0x ")
+ set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -std=c++0x ")
+ set(CXX_STD11_FLAGS "-std=c++0x")
+ endif(CXX_FLAG_CXX0X)
+endif(CXX_FLAG_CXX11)
+
+# perform tests
+include(CheckCXXSourceCompiles)
+
+# nullptr
+CHECK_CXX_SOURCE_COMPILES("
+ int main(void)
+ {
+ char* ch = nullptr;
+ return 0;
+ }
+" HAVE_NULLPTR
+)
+
+# array and fill
+CHECK_CXX_SOURCE_COMPILES("
+ #include <array>
+
+ int main(void)
+ {
+ std::array<int,2> a;
+ a.fill(9);
+ return 0;
+ }
+" HAVE_ARRAY
+)
+
+# Check whether if std::integral_constant< T, v > is supported and casts into T
+CHECK_CXX_SOURCE_COMPILES("
+ #include <type_traits>
+ void f( int ){}
+
+ int main(void){
+ f( std::integral_constant< int, 42 >() );
+ }
+" HAVE_INTEGRAL_CONSTANT
+)
+
+# __attribute__((always_inline))
+CHECK_CXX_SOURCE_COMPILES("
+ void __attribute__((always_inline)) foo(void) {}
+ int main(void)
+ {
+ foo();
+ return 0;
+ };
+" HAVE_ATTRIBUTE_ALWAYS_INLINE
+)
+
+# __attribute__((unused))
+CHECK_CXX_SOURCE_COMPILES("
+ int main(void)
+ {
+ int __attribute__((unused)) foo;
+ return 0;
+ };
+" HAS_ATTRIBUTE_UNUSED
+)
+
+# __attribute__((deprecated))
+CHECK_CXX_SOURCE_COMPILES("
+#define DEP __attribute__((deprecated))
+ class bar
+ {
+ bar() DEP;
+ };
+
+ class peng { } DEP;
+
+ template <class T>
+ class t_bar
+ {
+ t_bar() DEP;
+ };
+
+ template <class T>
+ class t_peng {
+ t_peng() {};
+ } DEP;
+
+ void foo() DEP;
+
+ void foo() {};
+
+ int main(void)
+ {
+ return 0;
+ };
+" HAS_ATTRIBUTE_DEPRECATED
+)
+
+# __attribute__((deprecated("msg")))
+CHECK_CXX_SOURCE_COMPILES("
+#define DEP __attribute__((deprecated(\"message\")))
+ class bar {
+ bar() DEP;
+ };
+
+ class peng { } DEP;
+
+ template <class T>
+ class t_bar
+ {
+ t_bar() DEP;
+ };
+
+ template <class T>
+ class t_peng
+ {
+ t_peng() {};
+ } DEP;
+
+ void foo() DEP;
+
+ void foo() {};
+
+ int main(void)
+ {
+ return 0;
+ };
+" HAS_ATTRIBUTE_DEPRECATED_MSG
+)
+
+# static assert
+CHECK_CXX_SOURCE_COMPILES("
+ int main(void)
+ {
+ static_assert(true,\"MSG\");
+ return 0;
+ }
+" HAVE_STATIC_ASSERT
+)
+
+# variadic template support
+CHECK_CXX_SOURCE_COMPILES("
+ #include <cassert>
+
+ template<typename... T>
+ int addints(T... x);
+
+ int add_ints()
+ {
+ return 0;
+ }
+
+ template<typename T1, typename... T>
+ int add_ints(T1 t1, T... t)
+ {
+ return t1 + add_ints(t...);
+ }
+
+ int main(void)
+ {
+ assert( 5 == add_ints(9,3,-5,-2) );
+ return 0;
+ }
+" HAVE_VARIADIC_TEMPLATES
+)
+
+# SFINAE on variadic template constructors within template classes
+CHECK_CXX_SOURCE_COMPILES("
+ #include <functional>
+
+ template<typename... U>
+ struct A
+ {
+ template<typename... T,
+ typename = typename std::enable_if<(sizeof...(T) < 2)>::type
+ >
+ A(T... t)
+ : i(1)
+ {}
+
+ template<typename... T,
+ typename = typename std::enable_if<(sizeof...(T) >= 2)>::type,
+ typename = void
+ >
+ A(T... t)
+ : i(-1)
+ {}
+
+ A()
+ : i(1)
+ {}
+
+ int i;
+ };
+
+ int main(void)
+ {
+ return (A<int>().i + A<int>(2).i + A<int>(\"foo\",3.4).i + A<int>(8,'a',A<int>()).i == 0 ? 0 : 1);
+ }
+" HAVE_VARIADIC_CONSTRUCTOR_SFINAE
+)
+
+# rvalue references
+CHECK_CXX_SOURCE_COMPILES("
+ #include <cassert>
+ #include <utility>
+ int foo(int&& x) { return 1; }
+ int foo(const int& x) { return -1; }
+
+ template<typename T>
+ int forward(T&& x)
+ {
+ return foo(std::forward<T>(x));
+ }
+
+ int main(void)
+ {
+ int i = 0;
+ assert( forward(i) + forward(int(2)) == 0);
+ return 0;
+ }
+" HAVE_RVALUE_REFERENCES
+)
+include(CheckIncludeFile)
+include(CheckIncludeFileCXX)
+# Search for some tr1 headers
+foreach(_HEADER tuple tr1/tuple type_traits tr1/type_traits)
+ string(REPLACE "/" "_" _HEADER_VAR ${_HEADER})
+ string(TOUPPER ${_HEADER_VAR} _HEADER_VAR )
+ check_include_file_cxx(${_HEADER} "HAVE_${_HEADER_VAR}")
+endforeach(_HEADER tuple tr1/tuple tr1/type_traits)
+
+# Check for hash support
+check_include_file_cxx("functional" "HAVE_FUNCTIONAL")
+if(NOT HAVE_FUNCTIONAL)
+ check_include_file_cxx("tr1/functional" "HAVE_TR1_FUNCTIONAL")
+ if(HAVE_TR1_FUNCTIONAL)
+ set(_functional_header "tr1/functional")
+ set(_hash_type "std::tr1::hash")
+ set(_hash_variable "HAVE_TR1_HASH")
+ endif(HAVE_TR1_FUNCTIONAL)
+else()
+ set(_functional_header "functional")
+ set(_hash_type "std::hash")
+ set(_hash_variable "HAVE_STD_HASH")
+endif(NOT HAVE_FUNCTIONAL)
+
+if(_functional_header)
+ check_cxx_source_compiles("
+#include <${_functional_header}>
+int main(void){
+ ${_hash_type}<int> hasher; hasher(42);
+}" ${_hash_variable})
+endif(_functional_header)
+
+cmake_pop_check_state()
diff --git a/cmake/modules/FindGMP.cmake b/cmake/modules/FindGMP.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..f912033a5227adc6c27f2a4fc941c029f6f346ce
--- /dev/null
+++ b/cmake/modules/FindGMP.cmake
@@ -0,0 +1,101 @@
+# Module that checks for the GNU MP Bignum (GMP) library, include
+# dirs and
+#
+# Variables used by this module which you may want to set:
+# GMP_PREFIX Path list to search for GMP
+#
+# Sets the following variables:
+# GMP_FOUND True if the GMP library was found.
+#
+
+# adds GMP flags to the targets
+function(add_dune_gmp_flags _targets)
+ if(GMP_FOUND)
+ foreach(_target ${_targets})
+ target_link_libraries(${_target} ${GMP_LIBRARIES})
+ set_property(TARGET ${_target}
+ APPEND_STRING
+ PROPERTY COMPILE_FLAGS "-DENABLE_GMP=1 ")
+ foreach(_path ${GMP_INCLUDE_DIRS})
+ set_property(TARGET ${_target}
+ APPEND_STRING
+ PROPERTY COMPILE_FLAGS "-I${_path}")
+ endforeach(_path ${GMP_INCLUDE_DIRS})
+ endforeach(_target ${_targets})
+ endif(GMP_FOUND)
+endfunction(add_dune_gmp_flags)
+
+# search for location of header gmpxx.h", only at positions given by the user
+find_path(GMP_INCLUDE_DIR
+ NAMES "gmpxx.h"
+ PATHS ${GMP_PREFIX}
+ PATH_SUFFIXES include
+ NO_DEFAULT_PATH)
+# try default paths now
+find_path(GMP_INCLUDE_DIR
+ NAMES "gmpxx.h")
+
+# check if header is accepted
+include(CMakePushCheckState)
+cmake_push_check_state()
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${GMP_INCLUDE_DIR})
+include(CheckIncludeFileCXX)
+check_include_file_cxx("gmpxx.h" GMP_FOUND)
+
+# look for library gmp, only at positions given by the user
+find_library(GMP_LIB gmp
+ PATHS ${GMP_PREFIX}
+ PATH_SUFFIXES lib lib64
+ NO_DEFAULT_PATH
+ DOC "GNU GMP library")
+# try default paths now
+find_library(GMP_LIB gmp)
+
+# look for library gmpxx, only at positions given by the user
+find_library(GMPXX_LIB gmpxx
+ PATHS ${GMP_PREFIX}
+ PATH_SUFFIXES lib lib64
+ NO_DEFAULT_PATH
+ DOC "GNU GMPXX library")
+# try default paths now
+find_library(GMPXX_LIB gmpxx)
+
+# check if library works
+set(GMP_FOUND "GMP_FOUND-NOTFOUND")
+if(GMP_LIB AND GMPXX_LIB)
+ include(CheckSymbolExists)
+ check_symbol_exists(__gmpz_abs ${GMP_LIB} GMP_FOUND)
+endif(GMP_LIB AND GMPXX_LIB)
+cmake_pop_check_state()
+
+# behave like a CMake module is supposed to behave
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+ "GMP"
+ DEFAULT_MSG
+ GMP_INCLUDE_DIR GMP_LIB GMPXX_LIB GMP_FOUND
+)
+
+mark_as_advanced(GMP_LIB GMPXX_LIB GMP_INCLUDE_DIR)
+
+# if both headers and library are found, store results
+if(GMP_FOUND)
+ set(GMP_INCLUDE_DIRS ${GMP_INCLUDE_DIR})
+ set(GMP_LIBRARIES ${GMP_LIB} ${GMPXX_LIB})
+ set(GMP_COMPILE_FLAGS "-DENABLE_GMP=1")
+ # log result
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+ "Determing location of GMP succeded:\n"
+ "Include directory: ${GMP_INCLUDE_DIRS}\n"
+ "Library directory: ${GMP_LIBRARIES}\n\n")
+else(GMP_FOUND)
+ # log errornous result
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+ "Determing location of GMP failed:\n"
+ "Include directory: ${GMP_INCLUDE_DIR}\n"
+ "gmp library directory: ${GMP_LIB}\n"
+ "gmpx library directory: ${GMPXX_LIB}\n\n")
+endif(GMP_FOUND)
+
+# set HAVE_GMP for config.h
+set(HAVE_GMP GMP_FOUND)
diff --git a/cmake/modules/FindInkscape.cmake b/cmake/modules/FindInkscape.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..d47bc20c1ca4ca4c3d03a69e65d1a48d18d6161f
--- /dev/null
+++ b/cmake/modules/FindInkscape.cmake
@@ -0,0 +1,67 @@
+# Module thaat checks for inkscape
+#
+# Sets the following variables
+#
+# INSCAPE: Path to inkscape to generate .png's form .svg's
+#
+# Provides the following functions:
+#
+# inkscape_generate_png_from_svg([OUTPUT_DIR <output_dir>] <pngfile1.png> [<pngfile2.png> ....])
+#
+# Generates pngfile1, ... from svg input files pngfile1.svg, ....
+# The output directory can be specified with the option OUTPUT_DIR. If it is omitted
+# the files will be generated in CMAKE_CURRENT_BINARY_DIR.
+
+find_program(INKSCAPE inkscape DOC "Path to inkscape to generate png files from svg files")
+find_program(CONVERT convert DOC "Path to convert program")
+if(INKSCAPE)
+ set(INKSCAPE_FOUND True)
+endif(INKSCAPE)
+
+include(CMakeParseArguments)
+
+function(inkscape_generate_png_from_svg)
+ if(NOT INKSCAPE)
+ return()
+ endif(NOT INKSCAPE)
+ cmake_parse_arguments(INKSCAPE "" "OUTPUT_DIR;DPI" "" ${ARGN})
+ if(NOT INKSCAPE_OUTPUT_DIR)
+ set(INKSCAPE_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
+ endif(NOT INKSCAPE_OUTPUT_DIR)
+ if(NOT INKSCAPE_DPI)
+ set(INKSCAPE_DPI 90)
+ endif(NOT INKSCAPE_DPI)
+
+ foreach(pic ${INKSCAPE_UNPARSED_ARGUMENTS})
+ string(REGEX REPLACE "\\.[a-zA-Z]+" ".svg" input ${pic})
+ add_custom_command(OUTPUT ${pic}
+ COMMAND ${INKSCAPE} --export-dpi=${INKSCAPE_DPI} -e ${pic} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${input}
+ COMMENT "Generating ${INKSCAPE_OUTPUT_DIR}/${pic} from ${CMAKE_CURRENT_SOURCE_DIR}/${input}"
+ WORKING_DIRECTORY ${INKSCAPE_OUTPUT_DIR})
+ endforeach(pic)
+endfunction(inkscape_generate_png_from_svg)
+
+function(inkscape_generate_eps_from_svg)
+ cmake_parse_arguments(INKSCAPE "" "INPUT_DIR;OUTPUT_DIR;DPI" "" ${ARGN})
+ if(NOT INKSCAPE_INPUT_DIR)
+ set(INKSCAPE_INPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+ endif(NOT INKSCAPE_INPUT_DIR)
+ if(NOT INKSCAPE_INPUT_DIR)
+ set(INKSCAPE_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
+ endif(NOT INKSCAPE_INPUT_DIR)
+
+ foreach(_pic ${INKSCAPE_UNPARSED_ARGUMENTS})
+ string(REGEX REPLACE "\\.[a-zA-Z]+" ".png" input "${_pic}")
+ string(REGEX REPLACE "\\.[a-zA-Z]+" ".svg" svginput "${_pic}")
+
+ add_custom_target(${input}
+ COMMAND ${INKSCAPE} --export-dpi=${INKSCAPE_DPI} -e ${input} ${CMAKE_CURRENT_SOURCE_DIR}/${svginput}
+ COMMENT "Generating ${INKSCAPE_OUTPUT_DIR}/${svginput} from ${CMAKE_CURRENT_SOURCE_DIR}/${input}")
+ add_custom_command(OUTPUT ${_pic}
+ COMMAND ${CONVERT} ${INKSCAPE_OUTPUT_DIR}/${input} EPS:${_pic}
+ DEPENDS ${input}
+ COMMENT "Converting ${INKSCAPE_OUTPUT_DIR}/${input} to ${INKSCAPE_OUTPUT_DIR}/${_pic}"
+ WORKING_DIRECTORY ${INKSCAPE_OUTPUT_DIR})
+ endforeach(_pic ${INKSCAPE_UNPARSED_ARGUMENTS})
+endfunction(inkscape_generate_eps_from_svg)
diff --git a/cmake/modules/FindMETIS.cmake b/cmake/modules/FindMETIS.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b9274c02c632ec04c8c63eae964011eb6f47f04f
--- /dev/null
+++ b/cmake/modules/FindMETIS.cmake
@@ -0,0 +1,101 @@
+# Accepts the following variables:
+#
+# METIS_DIR: Prefix where ParMETIS is installed.
+# METIS_LIB_NAME: Name of the METIS library (default: metis).
+# METIS_LIBRARY: Full path of the METIS library.
+
+# Sets the following variables:
+#
+# METIS_LIBRARY: Full path of the METIS library.
+# METIS_FOUND: True if ParMETIS was found.
+# METIS_LIBRARIES: List of all libraries needed for linking with METIS,
+#
+# Provides the following macros:
+#
+# find_package(METIS)
+#
+# Searches for METIS (See above)
+#
+#
+# add_dune_metis_flags(TARGETS)
+#
+# Adds the necessary flags to comile and link TARGETS with ParMETIS support.
+#
+
+# function to add the metis flags to a target
+function(add_dune_metis_flags _targets)
+ if(METIS_FOUND)
+ foreach(_target ${_targets})
+ target_link_libraries(${_target} ${METIS_LIBRARY})
+ endforeach(_target ${_targets})
+ set_property(TARGET ${_targets} APPEND PROPERTIES
+ COMPILE_DIRECTORIES ${METIS_INCLUDE_DIR})
+ endif(METIS_FOUND)
+endfunction(add_dune_metis_flags _targets)
+
+# search metis header
+find_path(METIS_INCLUDE_DIR metis.h
+ PATHS ${METIS_DIR}
+ PATH_SUFFIXES metis include include/metis Lib
+ NO_DEFAULT_PATH
+ DOC "Include directory of metis")
+find_path(METIS_INCLUDE_DIR metis.h
+ PATH_SUFFIXES metis include include/metis Lib)
+
+set(METIS_LIBRARY METIS_LIBRARY-NOTFOUND CACHE FILEPATH "Full path of the METIS library")
+
+# check metis header
+include(CMakePushCheckState)
+cmake_push_check_state() # Save variables
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${METIS_INCLUDE_DIR})
+check_include_file(metis.h METIS_FOUND)
+
+# search metis library
+if(NOT METIS_LIB_NAME)
+ set(METIS_LIB_NAME metis)
+endif(NOT METIS_LIB_NAME)
+
+find_library(METIS_LIBRARY ${METIS_LIB_NAME}
+ PATHS ${METIS_DIR}
+ PATH_SUFFIXES lib
+ NO_DEFAULT_PATH)
+find_library(METIS_LIBRARY ${METIS_LIB_NAME}
+ PATH_SUFFIXES lib
+)
+
+# behave like a CMake module is supposed to behave
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+ "METIS"
+ DEFAULT_MSG
+ METIS_INCLUDE_DIR
+ METIS_LIBRARY
+)
+
+# check metis library
+if(METIS_LIBRARY)
+ list(APPEND CMAKE_REQUIRED_LIBRARIES ${METIS_LIBRARIY})
+ set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${METIS_LIBRARY})
+ include(CheckSymbolExists)
+ check_symbol_exists(METIS_PartMeshDual metis.h METIS_FOUND)
+endif(METIS_LIBRARY)
+cmake_pop_check_state()
+
+mark_as_advanced(METIS_INCLUDE_DIR METIS_LIBRARIES METIS_LIB_NAME)
+
+# if both headers and library are found, store results
+if(METIS_FOUND)
+ set(METIS_INCLUDE_DIRS ${METIS_INCLUDE_DIR})
+ set(METIS_LIBRARIES ${METIS_LIBRARY})
+ # log result
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+ "Determing location of METIS succeded:\n"
+ "Include directory: ${METIS_INCLUDE_DIRS}\n"
+ "Library directory: ${METIS_LIBRARIES}\n\n")
+else(METIS_FOUND)
+ # log errornous result
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+ "Determing location of METIS failed:\n"
+ "Include directory: ${METIS_INCLUDE_DIRS}\n"
+ "Library directory: ${METIS_LIBRARIES}\n\n")
+endif(METIS_FOUND)
diff --git a/cmake/modules/FindMProtect.cmake b/cmake/modules/FindMProtect.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..e4afe68f82b1328165b1a1b54177c542d479d936
--- /dev/null
+++ b/cmake/modules/FindMProtect.cmake
@@ -0,0 +1,15 @@
+#
+# Module that detects mproctect support
+#
+# Sets the following variables
+# HAVE_SYS_MMAN_H
+# HAVE_MPROTECT
+check_include_file("sys/mman.h" HAVE_SYS_MMAN_H)
+message(STATUS HAVE_SYS_MMAN_H=${HAVE_SYS_MMAN_H})
+include(CheckCSourceCompiles)
+check_c_source_compiles("
+#include <sys/mman.h>
+int main(void){
+ mprotect(0,0,PROT_NONE);
+}" HAVE_MPROTECT)
+message(STATUS HAVE_MPROTECT=${HAVE_MPROTECT})
diff --git a/cmake/modules/FindParMETIS.cmake b/cmake/modules/FindParMETIS.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..aa71114a1456c9fe6dbf46e35883c5c7d1ca6515
--- /dev/null
+++ b/cmake/modules/FindParMETIS.cmake
@@ -0,0 +1,125 @@
+# Module that checks whether ParMETIS is available.
+#
+# Accepts the following variables:
+#
+# PARMETIS_DIR: Prefix where ParMETIS is installed.
+# METIS_LIB_NAME: Name of the METIS library (default: metis).
+# PARMETIS_LIB_NAME: Name of the ParMETIS library (default: parmetis).
+# METIS_LIBRARY: Full path of the METIS library.
+# PARMETIS_LIBRARY: Full path of the ParMETIS library
+
+# Sets the following variables:
+#
+# METIS_LIBRARY: Full path of the METIS library.
+# PARMETIS_LIBRARY: Full path of the ParMETIS library.
+# PARMETIS_FOUND: True if ParMETIS was found.
+# PARMETIS_LIBRARIES: List of all libraries needed for linking with ParMETIS,
+#
+# Provides the following macros:
+#
+# find_package(ParMETIS)
+#
+# Searches for ParMETIS (See above)
+#
+#
+# add_dune_parmetis_flags(TARGETS)
+#
+# Adds the necessary flags to comile and link TARGETS with ParMETIS support.
+#
+
+# adds ParMETIS flags to the targets
+function(add_dune_parmetis_flags _targets)
+ if(PARMETIS_FOUND)
+ foreach(_target ${_targets})
+ target_link_libraries(${_target} ${PARMETIS_LIBRARY} ${METIS_LIBRARY})
+ GET_TARGET_PROPERTY(_props ${_target} COMPILE_FLAGS)
+ string(REPLACE "_props-NOTFOUND" "" _props "${_props}")
+ SET_TARGET_PROPERTIES(${_target} PROPERTIES COMPILE_FLAGS
+ "${_props} ${PARMETIS_COMPILE_FLAGS} -DENABLE_PARMETS=1")
+ endforeach(_target ${_targets})
+ add_dune_mpi_flags(${_targets})
+ endif(PARMETIS_FOUND)
+endfunction(add_dune_parmetis_flags)
+
+
+include(DuneMPI)
+
+# search for header parmetis.h
+find_path(PARMETIS_INCLUDE_DIR parmetis.h
+ PATHS ${PARMETIS_DIR}
+ PATH_SUFFIXES include parmetis
+ NO_DEFAULT_PATH
+ DOC "Include directory of ParMETIS")
+find_path(PARMETIS_INCLUDE_DIR parmetis.h
+ PATH_SUFFIXES include parmetis)
+
+set(METIS_LIB_NAME metis
+ CACHE STRING "Name of the METIS library (default: metis).")
+set(PARMETIS_LIB_NAME parmetis
+ CACHE STRING "Name of the ParMETIS library (default: parmetis).")
+set(METIS_LIBRARY METIS_LIBRARY-NOTFOUND
+ CACHE FILEPATH "Full path of the METIS library")
+set(PARMETIS_LIBRARY ParMETIS_LIBRARY-NOTFOUND
+ CACHE FILEPATH "Full path of the ParMETIS library")
+
+# check METIS and ParMETIS headers
+include(CMakePushCheckState)
+cmake_push_check_state() # Save variables
+set(CMAKE_REQUIRED_INCLUDES ${CMAKE_REQUIRED_INCLUDES} ${MPI_DUNE_INCLUDE_PATH} ${PARMETIS_INCLUDE_DIR})
+set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} ${MPI_DUNE_COMPILE_FLAGS}")
+check_include_file(metis.h METIS_FOUND)
+check_include_file(parmetis.h PARMETIS_FOUND)
+
+if(PARMETIS_FOUND)
+ set(ParMETIS_INCLUDE_PATH ${CMAKE_REQUIRED_INCLUDES})
+ set(ParMETIS_COMPILE_FLAGS "${CMAKE_REQUIRED_FLAGS} -DENABLE_PARMETIS=1")
+
+ # search METIS library
+ find_library(METIS_LIBRARY metis
+ PATHS ${PARMETIS_DIR}
+ PATH_SUFFIXES lib
+ NO_DEFAULT_PATH)
+ find_library(METIS_LIBRARY metis)
+
+ # search ParMETIS library
+ find_library(PARMETIS_LIBRARY parmetis
+ PATHS ${PARMETIS_DIR}
+ PATH_SUFFIXES lib
+ NO_DEFAULT_PATH)
+ find_library(PARMETIS_LIBRARY parmetis)
+
+ # check ParMETIS library
+ if(PARMETIS_LIBRARY)
+ list(APPEND CMAKE_REQUIRED_LIBRARIES ${PARMETIS_LIBRARY} ${METIS_LIBRARY} ${MPI_DUNE_LIBRARIES})
+ include(CheckSymbolExists)
+ check_symbol_exists(parmetis_v3_partkway parmetis.h PARMETIS_FOUND)
+ endif(PARMETIS_LIBRARY)
+endif(PARMETIS_FOUND)
+
+# behave like a CMake module is supposed to behave
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(
+ "ParMETIS"
+ DEFAULT_MSG
+ PARMETIS_INCLUDE_DIR
+ PARMETIS_LIBRARY
+ PARMETIS_FOUND
+)
+
+mark_as_advanced(PARMETIS_INCLUDE_DIR METIS_LIBRARY PARMETIS_LIBRARY METIS_LIB_NAME PARMETIS_LIB_NAME)
+
+#restore old values
+cmake_pop_check_state()
+
+if(PARMETIS_FOUND)
+ set(PARMETIS_INCLUDE_DIRS ${PARMETIS_INCLUDE_DIR})
+ set(PARMETIS_LIBRARIES "${PARMETIS_LIBRARY};${METIS_LIBRARY};${MPI_DUNE_LIBRARIES}"
+ CACHE FILEPATH "ParMETIS libraries needed for linking")
+ set(PARMETIS_LINK_FLAGS "${DUNE_MPI_LINK_FLAGS}"
+ CACHE STRING "ParMETIS link flags")
+ # log result
+ file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+ "Determing location of ParMETIS succeded:\n"
+ "Include directory: ${PARMETIS_INCLUDE_DIRS}\n"
+ "Library directory: ${PARMETIS_LIBRARIES}\n\n")
+endif(PARMETIS_FOUND)
diff --git a/cmake/modules/FindSharedPtr.cmake b/cmake/modules/FindSharedPtr.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..38288481e4cefa62796cab5c6580f5a01112b0ed
--- /dev/null
+++ b/cmake/modules/FindSharedPtr.cmake
@@ -0,0 +1,84 @@
+# Module checks for shared_ptr support.
+#
+# Sets the following variables:
+#
+# HAVE_BOOST_MAKE_SHARED_HPP: True if boost/make_shared.hpp is found
+# SHARED_PTR_NAMESPACE: Namespace of shared_ptr (e.g. std)
+# SHARED_PTR_HEADER: The name of header file supplying shared_ptr
+#
+# check if make_shared works
+macro(CHECK_MAKE_SHARED)
+ include(CheckIncludeFileCXX)
+
+ if(SHARED_PTR_NAMESPACE EQUAL "boost")
+ CHECK_INCLUDE_FILE_CXX("boost/make_shared.hpp" HAVE_BOOST_MAKE_SHARED_HPP)
+ endif(SHARED_PTR_NAMESPACE EQUAL "boost")
+
+ CHECK_INCLUDE_FILE_CXX("boost/shared_ptr.hpp" HAVE_BOOST_SHARED_PTR_HPP)
+
+ CHECK_CXX_SOURCE_COMPILES("
+ #if defined(HAVE_MEMORY)
+ # include <memory>
+ #endif
+ #if defined(HAVE_TR1_MEMORY)
+ # include <tr1/memory>
+ #endif
+ #if defined(HAVE_BOOST_SHARED_PTR_HPP) && defined(HAVE_BOOST_MAKE_SHARED_HPP)
+ # include <boost/shared_ptr.hpp>
+ # include <boost/make_shared.hpp>
+ #endif
+
+ int main(void)
+ {
+ ${SHARED_PTR_NAMESPACE}::make_shared<int>(3);
+ return 0;
+ }
+ " HAVE_MAKE_SHARED)
+endmacro(CHECK_MAKE_SHARED)
+
+# check location of shared_ptr header file and the necessary namespace
+include(CheckCXXSourceCompiles)
+
+# search namespace
+foreach(SHARED_PTR_NAMESPACE_ "std" "tr1" "std::tr1" "boost")
+ CHECK_CXX_SOURCE_COMPILES("
+ #include <memory>
+ #include <string>
+
+ using ${SHARED_PTR_NAMESPACE_}::shared_ptr;
+ using namespace std;
+
+ int main(void)
+ {
+ shared_ptr<string> test_ptr(new string(\"test string\"));
+ return 0;
+ }"
+ SHARED_PTR_NAMESPACE_FOUND)
+
+ if(SHARED_PTR_NAMESPACE_FOUND)
+ #search header name
+ foreach(SHARED_PTR_HEADER_ "<memory>" "<tr1/memory>" "<boost/shared_ptr.hpp>")
+ CHECK_CXX_SOURCE_COMPILES("
+ # include ${SHARED_PTR_HEADER_}
+ #include <string>
+
+ using ${SHARED_PTR_NAMESPACE_}::shared_ptr;
+ using namespace std;
+
+ int main(void)
+ {
+ shared_ptr<string> test_ptr(new string(\"test string\"));
+ return 0;
+ }"
+ SHARED_PTR_HEADER_FOUND)
+
+ if(SHARED_PTR_HEADER_FOUND)
+ # save result
+ set(SHARED_PTR_NAMESPACE ${SHARED_PTR_NAMESPACE_})
+ set(SHARED_PTR_HEADER ${SHARED_PTR_HEADER_})
+ CHECK_MAKE_SHARED()
+ return()
+ endif(SHARED_PTR_HEADER_FOUND)
+ endforeach(SHARED_PTR_HEADER_)
+ endif(SHARED_PTR_NAMESPACE_FOUND)
+endforeach(SHARED_PTR_NAMESPACE_)
diff --git a/cmake/modules/LanguageSupport.cmake b/cmake/modules/LanguageSupport.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..457b2a2110b52ab1a2958f6e8d63e97f1436a14a
--- /dev/null
+++ b/cmake/modules/LanguageSupport.cmake
@@ -0,0 +1,65 @@
+# cmake/modules/language_support.cmake
+#
+# Temporary additional general language support is contained within this
+# file.
+
+# This additional function definition is needed to provide a workaround for
+# CMake bug 9220.
+
+# On debian testing (cmake 2.6.2), I get return code zero when calling
+# cmake the first time, but cmake crashes when running a second time
+# as follows:
+#
+# -- The Fortran compiler identification is unknown
+# CMake Error at /usr/share/cmake-2.6/Modules/CMakeFortranInformation.cmake:7 (GET_FILENAME_COMPONENT):
+# get_filename_component called with incorrect number of arguments
+# Call Stack (most recent call first):
+# CMakeLists.txt:3 (enable_language)
+#
+# My workaround is to invoke cmake twice. If both return codes are zero,
+# it is safe to invoke ENABLE_LANGUAGE(Fortran OPTIONAL)
+
+function(workaround_9220 language language_works)
+ #message("DEBUG: language = ${language}")
+ set(text
+ "project(test NONE)
+cmake_minimum_required(VERSION 2.6.0)
+enable_language(${language} OPTIONAL)
+"
+ )
+ file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/language_tests/${language})
+ file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language})
+ file(WRITE ${CMAKE_BINARY_DIR}/language_tests/${language}/CMakeLists.txt
+ ${text})
+ execute_process(
+ COMMAND ${CMAKE_COMMAND} .
+ WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
+ RESULT_VARIABLE return_code
+ OUTPUT_QUIET
+ ERROR_QUIET
+ )
+
+ if(return_code EQUAL 0)
+ # Second run
+ execute_process (
+ COMMAND ${CMAKE_COMMAND} .
+ WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/language_tests/${language}
+ RESULT_VARIABLE return_code
+ OUTPUT_QUIET
+ ERROR_QUIET
+ )
+ if(return_code EQUAL 0)
+ set(${language_works} ON PARENT_SCOPE)
+ else(return_code EQUAL 0)
+ set(${language_works} OFF PARENT_SCOPE)
+ endif(return_code EQUAL 0)
+ else(return_code EQUAL 0)
+ set(${language_works} OFF PARENT_SCOPE)
+ endif(return_code EQUAL 0)
+endfunction(workaround_9220)
+
+# Temporary tests of the above function.
+#workaround_9220(CXX CXX_language_works)
+#message("CXX_language_works = ${CXX_language_works}")
+#workaround_9220(CXXp CXXp_language_works)
+#message("CXXp_language_works = ${CXXp_language_works}")
diff --git a/cmake/modules/Makefile.am b/cmake/modules/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..04631b7ddae96c54891037b9e56207a31e14888a
--- /dev/null
+++ b/cmake/modules/Makefile.am
@@ -0,0 +1,27 @@
+MODULES = DuneBoost.cmake \
+ DuneCommonMacros.cmake \
+ DuneCxaDemangle.cmake \
+ DuneDoc.cmake \
+ DuneDoxygen.cmake \
+ DuneMacros.cmake \
+ DuneMPI.cmake \
+ DunePkgConfig.cmake \
+ DuneStreams.cmake \
+ DuneTestMacros.cmake \
+ DuneTests.cmake \
+ FindBoostFusion.cmake \
+ FindCXX11Features.cmake \
+ FindGMP.cmake \
+ FindInkscape.cmake \
+ FindMETIS.cmake \
+ FindMProtect.cmake \
+ FindParMETIS.cmake \
+ FindSharedPtr.cmake \
+ LanguageSupport.cmake \
+ UseLATEX.cmake
+
+modulesdir = $(datadir)/cmake/modules
+dist_modules_DATA = ${MODULES}
+
+include $(top_srcdir)/am/global-rules
+EXTRA_DIST = CMakeLists.txt
diff --git a/cmake/modules/UseLATEX.cmake b/cmake/modules/UseLATEX.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3408ced433ddfc2cac0194217762808c86db1921
--- /dev/null
+++ b/cmake/modules/UseLATEX.cmake
@@ -0,0 +1,1219 @@
+# File: UseLATX.cmake
+# CMAKE commands to actually use the LaTeX compiler
+# Version: 1.9.1
+# Author: Kenneth Moreland <kmorel@sandia.gov>
+#
+# Copyright 2004 Sandia Corporation.
+# Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
+# license for use of this work by or on behalf of the
+# U.S. Government. Redistribution and use in source and binary forms, with
+# or without modification, are permitted provided that this Notice and any
+# statement of authorship are reproduced on all copies.
+#
+# The following MACROS are defined:
+#
+# ADD_LATEX_DOCUMENT(<tex_file>
+# [FATHER_TARGET <father_target>]
+# [BIBFILES <bib_files>]
+# [INPUTS <input_tex_files>]
+# [IMAGE_DIRS] <image_directories>
+# [IMAGES] <image_files>
+# [CONFIGURE] <tex_files>
+# [DEPENDS] <tex_files>
+# [MULTIBIB_NEWCITES] <suffix_list>
+# [USE_INDEX] [USE_GLOSSARY] [USE_NOMENCL]
+# [DEFAULT_PDF] [DEFAULT_SAFEPDF]
+# [MANGLE_TARGET_NAMES])
+# Adds targets that compile <tex_file>. The latex output is placed
+# in LATEX_OUTPUT_PATH or CMAKE_CURRENT_BINARY_DIR if the former is
+# not set. The latex program is picky about where files are located,
+# so all input files are copied from the source directory to the
+# output directory. This includes the target tex file, any tex file
+# listed with the INPUTS option, the bibliography files listed with
+# the BIBFILES option, and any .cls, .bst, and .clo files found in
+# the current source directory. Images found in the IMAGE_DIRS
+# directories or listed by IMAGES are also copied to the output
+# directory and coverted to an appropriate format if necessary. Any
+# tex files also listed with the CONFIGURE option are also processed
+# with the CMake CONFIGURE_FILE command (with the @ONLY flag). Any
+# file listed in CONFIGURE but not the target tex file or listed with
+# INPUTS has no effect. DEPENDS can be used to specify generated files
+# that are needed to compile the latex target.
+#
+# The following targets are made:
+# dvi: Makes <name>.dvi
+# pdf: Makes <name>.pdf using pdflatex.
+# safepdf: Makes <name>.pdf using ps2pdf. If using the default
+# program arguments, this will ensure all fonts are
+# embedded and no lossy compression has been performed
+# on images.
+# ps: Makes <name>.ps
+# html: Makes <name>.html
+# auxclean: Deletes <name>.aux and other auxiliary files.
+# This is sometimes necessary if a LaTeX error occurs
+# and writes a bad aux file. Unlike the regular clean
+# target, it does not delete other input files, such as
+# converted images, to save time on the rebuild.
+#
+# If FATHER_TARGET is omitted, the dvi target is added to the ALL.
+# That is, it will be the target built by default. If the DEFAULT_PDF
+# argument is given, then the pdf target will be the default instead of
+# dvi. If FATHER_TARGET is set, the files will be a dependency of
+# FATHER_TARGET. By setting FATHER_TARGET to doc, the files will be build
+# during make doc
+#
+# If the argument MANGLE_TARGET_NAMES is given, then each of the
+# target names above will be mangled with the <tex_file> name. This
+# is to make the targets unique if ADD_LATEX_DOCUMENT is called for
+# multiple documents. If the argument USE_INDEX is given, then
+# commands to build an index are made. If the argument USE_GLOSSARY
+# is given, then commands to build a glossary are made. If the
+# argument MULTIBIB_NEWCITES is given, then additional bibtex calls
+# are added to the build to support the extra auxiliary files created
+# with the \newcite command in the multibib package.
+#
+# History:
+#
+# 1.9.1 Fixed typo that caused the LATEX_SMALL_IMAGES option to fail to
+# activate.
+#
+# 1.9.0 Add support for the multibib package (thanks to Antonio LaTorre).
+#
+# 1.8.2 Fix corner case when an argument name was also a variable containing
+# the text of an argument. In this case, the CMake IF was matching
+# the argument text with the contents of the variable with the same
+# argument name.
+#
+# 1.8.1 Fix problem where ps2pdf was not getting the appropriate arguments.
+#
+# 1.8.0 Add support for synctex.
+#
+# 1.7.7 Support calling xindy when making glossaries.
+#
+# Improved make clean support.
+#
+# 1.7.6 Add support for the nomencl package (thanks to Myles English).
+#
+# 1.7.5 Fix issue with bibfiles being copied two different ways, which causes
+# Problems with dependencies (thanks to Edwin van Leeuwen).
+#
+# 1.7.4 Added the DEFAULT_SAFEPDF option (thanks to Raymond Wan).
+#
+# Added warnings when image directories are not found (and were
+# probably not given relative to the source directory).
+#
+# 1.7.3 Fix some issues with interactions between makeglossaries and bibtex
+# (thanks to Mark de Wever).
+#
+# 1.7.2 Use ps2pdf to convert eps to pdf to get around the problem with
+# ImageMagick dropping the bounding box (thanks to Lukasz Lis).
+#
+# 1.7.1 Fixed some dependency issues.
+#
+# 1.7.0 Added DEPENDS options (thanks to Theodore Papadopoulo).
+#
+# 1.6.1 Ported the makeglossaries command to CMake and embedded the port
+# into UseLATEX.cmake.
+#
+# 1.6.0 Allow the use of the makeglossaries command. Thanks to Oystein
+# S. Haaland for the patch.
+#
+# 1.5.0 Allow any type of file in the INPUTS lists, not just tex file
+# (suggested by Eric Noulard). As a consequence, the ability to
+# specify tex files without the .tex extension is removed. The removed
+# function is of dubious value anyway.
+#
+# When copying input files, skip over any file that exists in the
+# binary directory but does not exist in the source directory with the
+# assumption that these files were added by some other mechanism. I
+# find this useful when creating large documents with multiple
+# chapters that I want to build separately (for speed) as I work on
+# them. I use the same boilerplate as the starting point for all
+# and just copy it with different configurations. This was what the
+# separate ADD_LATEX_DOCUMENT method was supposed to originally be for.
+# Since its external use is pretty much deprecated, I removed that
+# documentation.
+#
+# 1.4.1 Copy .sty files along with the other class and package files.
+#
+# 1.4.0 Added a MANGLE_TARGET_NAMES option that will mangle the target names.
+#
+# Fixed problem with copying bib files that became apparent with
+# CMake 2.4.
+#
+# 1.3.0 Added a LATEX_OUTPUT_PATH variable that allows you or the user to
+# specify where the built latex documents to go. This is especially
+# handy if you want to do in-source builds.
+#
+# Removed the ADD_LATEX_IMAGES macro and absorbed the functionality
+# into ADD_LATEX_DOCUMENT. The old interface was always kind of
+# clunky anyway since you had to specify the image directory in both
+# places. It also made supporting LATEX_OUTPUT_PATH problematic.
+#
+# Added support for jpeg files.
+#
+# 1.2.0 Changed the configuration options yet again. Removed the NO_CONFIGURE
+# Replaced it with a CONFIGURE option that lists input files for which
+# configure should be run.
+#
+# The pdf target no longer depends on the dvi target. This allows you
+# to build latex documents that require pdflatex. Also added an option
+# to make the pdf target the default one.
+#
+# 1.1.1 Added the NO_CONFIGURE option. The @ character can be used when
+# specifying table column separators. If two or more are used, then
+# will incorrectly substitute them.
+#
+# 1.1.0 Added ability include multiple bib files. Added ability to do copy
+# sub-tex files for multipart tex files.
+#
+# 1.0.0 If both ps and pdf type images exist, just copy the one that
+# matches the current render mode. Replaced a bunch of STRING
+# commands with GET_FILENAME_COMPONENT commands that were made to do
+# the desired function.
+#
+# 0.4.0 First version posted to CMake Wiki.
+#
+
+#############################################################################
+# Find the location of myself while originally executing. If you do this
+# inside of a macro, it will recode where the macro was invoked.
+#############################################################################
+SET(LATEX_USE_LATEX_LOCATION ${CMAKE_CURRENT_LIST_FILE}
+ CACHE INTERNAL "Location of UseLATEX.cmake file." FORCE
+ )
+
+#############################################################################
+# Generic helper macros
+#############################################################################
+
+# Helpful list macros.
+MACRO(LATEX_CAR var)
+ SET(${var} ${ARGV1})
+ENDMACRO(LATEX_CAR)
+MACRO(LATEX_CDR var junk)
+ SET(${var} ${ARGN})
+ENDMACRO(LATEX_CDR)
+
+MACRO(LATEX_LIST_CONTAINS var value)
+ SET(${var})
+ FOREACH (value2 ${ARGN})
+ IF ("not_a_var_${value}" STREQUAL "not_a_var_${value2}")
+ SET(${var} TRUE)
+ ENDIF ("not_a_var_${value}" STREQUAL "not_a_var_${value2}")
+ ENDFOREACH (value2)
+ENDMACRO(LATEX_LIST_CONTAINS)
+
+# Parse macro arguments.
+MACRO(LATEX_PARSE_ARGUMENTS prefix arg_names option_names)
+ SET(DEFAULT_ARGS)
+ FOREACH(arg_name ${arg_names})
+ SET(${prefix}_${arg_name})
+ ENDFOREACH(arg_name)
+ FOREACH(option ${option_names})
+ SET(${prefix}_${option})
+ ENDFOREACH(option)
+
+ SET(current_arg_name DEFAULT_ARGS)
+ SET(current_arg_list)
+ FOREACH(arg ${ARGN})
+ LATEX_LIST_CONTAINS(is_arg_name ${arg} ${arg_names})
+ IF (is_arg_name)
+ SET(${prefix}_${current_arg_name} ${current_arg_list})
+ SET(current_arg_name ${arg})
+ SET(current_arg_list)
+ ELSE (is_arg_name)
+ LATEX_LIST_CONTAINS(is_option ${arg} ${option_names})
+ IF (is_option)
+ SET(${prefix}_${arg} TRUE)
+ ELSE (is_option)
+ SET(current_arg_list ${current_arg_list} ${arg})
+ ENDIF (is_option)
+ ENDIF (is_arg_name)
+ ENDFOREACH(arg)
+ SET(${prefix}_${current_arg_name} ${current_arg_list})
+ENDMACRO(LATEX_PARSE_ARGUMENTS)
+
+# Match the contents of a file to a regular expression.
+MACRO(LATEX_FILE_MATCH variable filename regexp default)
+ # The FILE STRINGS command would be a bit better, but it's not supported on
+ # older versions of CMake.
+ FILE(READ ${filename} file_contents)
+ STRING(REGEX MATCHALL "${regexp}"
+ ${variable} ${file_contents}
+ )
+ IF (NOT ${variable})
+ SET(${variable} "${default}")
+ ENDIF (NOT ${variable})
+ENDMACRO(LATEX_FILE_MATCH)
+
+#############################################################################
+# Macros that perform processing during a LaTeX build.
+#############################################################################
+MACRO(LATEX_MAKEGLOSSARIES)
+ # This is really a bare bones port of the makeglossaries perl script into
+ # CMake scripting.
+ MESSAGE("**************************** In makeglossaries")
+ IF (NOT LATEX_TARGET)
+ MESSAGE(SEND_ERROR "Need to define LATEX_TARGET")
+ ENDIF (NOT LATEX_TARGET)
+
+ SET(aux_file ${LATEX_TARGET}.aux)
+
+ IF (NOT EXISTS ${aux_file})
+ MESSAGE(SEND_ERROR "${aux_file} does not exist. Run latex on your target file.")
+ ENDIF (NOT EXISTS ${aux_file})
+
+ LATEX_FILE_MATCH(newglossary_lines ${aux_file}
+ "@newglossary[ \t]*{([^}]*)}{([^}]*)}{([^}]*)}{([^}]*)}"
+ "@newglossary{main}{glg}{gls}{glo}"
+ )
+
+ LATEX_FILE_MATCH(istfile_line ${aux_file}
+ "@istfilename[ \t]*{([^}]*)}"
+ "@istfilename{${LATEX_TARGET}.ist}"
+ )
+ STRING(REGEX REPLACE "@istfilename[ \t]*{([^}]*)}" "\\1"
+ istfile ${istfile_line}
+ )
+
+ STRING(REGEX MATCH ".*\\.xdy" use_xindy "${istfile}")
+ IF (use_xindy)
+ MESSAGE("*************** Using xindy")
+ IF (NOT XINDY_COMPILER)
+ MESSAGE(SEND_ERROR "Need to define XINDY_COMPILER")
+ ENDIF (NOT XINDY_COMPILER)
+ ELSE (use_xindy)
+ MESSAGE("*************** Using makeindex")
+ IF (NOT MAKEINDEX_COMPILER)
+ MESSAGE(SEND_ERROR "Need to define MAKEINDEX_COMPILER")
+ ENDIF (NOT MAKEINDEX_COMPILER)
+ ENDIF (use_xindy)
+
+ FOREACH(newglossary ${newglossary_lines})
+ STRING(REGEX REPLACE
+ "@newglossary[ \t]*{([^}]*)}{([^}]*)}{([^}]*)}{([^}]*)}"
+ "\\1" glossary_name ${newglossary}
+ )
+ STRING(REGEX REPLACE
+ "@newglossary[ \t]*{([^}]*)}{([^}]*)}{([^}]*)}{([^}]*)}"
+ "${LATEX_TARGET}.\\2" glossary_log ${newglossary}
+ )
+ STRING(REGEX REPLACE
+ "@newglossary[ \t]*{([^}]*)}{([^}]*)}{([^}]*)}{([^}]*)}"
+ "${LATEX_TARGET}.\\3" glossary_out ${newglossary}
+ )
+ STRING(REGEX REPLACE
+ "@newglossary[ \t]*{([^}]*)}{([^}]*)}{([^}]*)}{([^}]*)}"
+ "${LATEX_TARGET}.\\4" glossary_in ${newglossary}
+ )
+
+ IF (use_xindy)
+ LATEX_FILE_MATCH(xdylanguage_line ${aux_file}
+ "@xdylanguage[ \t]*{${glossary_name}}{([^}]*)}"
+ "@xdylanguage{${glossary_name}}{english}"
+ )
+ STRING(REGEX REPLACE
+ "@xdylanguage[ \t]*{${glossary_name}}{([^}]*)}"
+ "\\1"
+ language
+ ${xdylanguage_line}
+ )
+ # What crazy person makes a LaTeX index generater that uses different
+ # identifiers for language than babel (or at least does not support
+ # the old ones)?
+ IF (${language} STREQUAL "frenchb")
+ SET(language "french")
+ ELSEIF (${language} MATCHES "^n?germanb?$")
+ SET(language "german")
+ ELSEIF (${language} STREQUAL "magyar")
+ SET(language "hungarian")
+ ELSEIF (${language} STREQUAL "lsorbian")
+ SET(language "lower-sorbian")
+ ELSEIF (${language} STREQUAL "norsk")
+ SET(language "norwegian")
+ ELSEIF (${language} STREQUAL "portuges")
+ SET(language "portuguese")
+ ELSEIF (${language} STREQUAL "russianb")
+ SET(language "russian")
+ ELSEIF (${language} STREQUAL "slovene")
+ SET(language "slovenian")
+ ELSEIF (${language} STREQUAL "ukraineb")
+ SET(language "ukrainian")
+ ELSEIF (${language} STREQUAL "usorbian")
+ SET(language "upper-sorbian")
+ ENDIF (${language} STREQUAL "frenchb")
+ IF (language)
+ SET(language_flags "-L ${language}")
+ ELSE (language)
+ SET(language_flags "")
+ ENDIF (language)
+
+ LATEX_FILE_MATCH(codepage_line ${aux_file}
+ "@gls@codepage[ \t]*{${glossary_name}}{([^}]*)}"
+ "@gls@codepage{${glossary_name}}{utf}"
+ )
+ STRING(REGEX REPLACE
+ "@gls@codepage[ \t]*{${glossary_name}}{([^}]*)}"
+ "\\1"
+ codepage
+ ${codepage_line}
+ )
+ IF (codepage)
+ SET(codepage_flags "-C ${codepage}")
+ ELSE (codepage)
+ # Ideally, we would check that the language is compatible with the
+ # default codepage, but I'm hoping that distributions will be smart
+ # enough to specify their own codepage. I know, it's asking a lot.
+ SET(codepage_flags "")
+ ENDIF (codepage)
+
+ MESSAGE("${XINDY_COMPILER} ${MAKEGLOSSARIES_COMPILER_FLAGS} ${language_flags} ${codepage_flags} -I xindy -M ${glossary_name} -t ${glossary_log} -o ${glossary_out} ${glossary_in}"
+ )
+ EXEC_PROGRAM(${XINDY_COMPILER}
+ ARGS ${MAKEGLOSSARIES_COMPILER_FLAGS}
+ ${language_flags}
+ ${codepage_flags}
+ -I xindy
+ -M ${glossary_name}
+ -t ${glossary_log}
+ -o ${glossary_out}
+ ${glossary_in}
+ OUTPUT_VARIABLE xindy_output
+ )
+ MESSAGE("${xindy_output}")
+
+ # So, it is possible (perhaps common?) for aux files to specify a
+ # language and codepage that are incompatible with each other. Check
+ # for that condition, and if it happens run again with the default
+ # codepage.
+ IF ("${xindy_output}" MATCHES "^Cannot locate xindy module for language (.+) in codepage (.+)\\.$")
+ MESSAGE("*************** Retrying xindy with default codepage.")
+ EXEC_PROGRAM(${XINDY_COMPILER}
+ ARGS ${MAKEGLOSSARIES_COMPILER_FLAGS}
+ ${language_flags}
+ -I xindy
+ -M ${glossary_name}
+ -t ${glossary_log}
+ -o ${glossary_out}
+ ${glossary_in}
+ )
+ ENDIF ("${xindy_output}" MATCHES "^Cannot locate xindy module for language (.+) in codepage (.+)\\.$")
+ #ENDIF ("${xindy_output}" MATCHES "Cannot locate xindy module for language (.+) in codepage (.+)\\.")
+
+ ELSE (use_xindy)
+ MESSAGE("${MAKEINDEX_COMPILER} ${MAKEGLOSSARIES_COMPILER_FLAGS} -s ${istfile} -t ${glossary_log} -o ${glossary_out} ${glossary_in}")
+ EXEC_PROGRAM(${MAKEINDEX_COMPILER} ARGS ${MAKEGLOSSARIES_COMPILER_FLAGS}
+ -s ${istfile} -t ${glossary_log} -o ${glossary_out} ${glossary_in}
+ )
+ ENDIF (use_xindy)
+
+ ENDFOREACH(newglossary)
+ENDMACRO(LATEX_MAKEGLOSSARIES)
+
+MACRO(LATEX_MAKENOMENCLATURE)
+ MESSAGE("**************************** In makenomenclature")
+ IF (NOT LATEX_TARGET)
+ MESSAGE(SEND_ERROR "Need to define LATEX_TARGET")
+ ENDIF (NOT LATEX_TARGET)
+
+ IF (NOT MAKEINDEX_COMPILER)
+ MESSAGE(SEND_ERROR "Need to define MAKEINDEX_COMPILER")
+ ENDIF (NOT MAKEINDEX_COMPILER)
+
+ SET(nomencl_out ${LATEX_TARGET}.nls)
+ SET(nomencl_in ${LATEX_TARGET}.nlo)
+
+ EXEC_PROGRAM(${MAKEINDEX_COMPILER} ARGS ${MAKENOMENCLATURE_COMPILER_FLAGS}
+ ${nomencl_in} -s "nomencl.ist" -o ${nomencl_out}
+ )
+ENDMACRO(LATEX_MAKENOMENCLATURE)
+
+MACRO(LATEX_CORRECT_SYNCTEX)
+ MESSAGE("**************************** In correct SyncTeX")
+ IF (NOT LATEX_TARGET)
+ MESSAGE(SEND_ERROR "Need to define LATEX_TARGET")
+ ENDIF (NOT LATEX_TARGET)
+
+ IF (NOT GZIP)
+ MESSAGE(SEND_ERROR "Need to define GZIP")
+ ENDIF (NOT GZIP)
+
+ IF (NOT LATEX_SOURCE_DIRECTORY)
+ MESSAGE(SEND_ERROR "Need to define LATEX_SOURCE_DIRECTORY")
+ ENDIF (NOT LATEX_SOURCE_DIRECTORY)
+
+ IF (NOT LATEX_BINARY_DIRECTORY)
+ MESSAGE(SEND_ERROR "Need to define LATEX_BINARY_DIRECTORY")
+ ENDIF (NOT LATEX_BINARY_DIRECTORY)
+
+ SET(synctex_file ${LATEX_BINARY_DIRECTORY}/${LATEX_TARGET}.synctex)
+ SET(synctex_file_gz ${synctex_file}.gz)
+
+ IF (EXISTS ${synctex_file_gz})
+
+ MESSAGE("Making backup of synctex file.")
+ CONFIGURE_FILE(${synctex_file_gz} ${synctex_file}.bak.gz COPYONLY)
+
+ MESSAGE("Uncompressing synctex file.")
+ EXEC_PROGRAM(${GZIP}
+ ARGS --decompress ${synctex_file_gz}
+ )
+
+ MESSAGE("Reading synctex file.")
+ FILE(READ ${synctex_file} synctex_data)
+
+ MESSAGE("Replacing relative with absolute paths.")
+ STRING(REGEX REPLACE
+ "(Input:[0-9]+:)([^/\n][^\n]*)"
+ "\\1${LATEX_SOURCE_DIRECTORY}/\\2"
+ synctex_data
+ "${synctex_data}"
+ )
+
+ MESSAGE("Writing synctex file.")
+ FILE(WRITE ${synctex_file} "${synctex_data}")
+
+ MESSAGE("Compressing synctex file.")
+ EXEC_PROGRAM(${GZIP}
+ ARGS ${synctex_file}
+ )
+
+ ELSE (EXISTS ${synctex_file_gz})
+
+ MESSAGE(SEND_ERROR "File ${synctex_file_gz} not found. Perhaps synctex is not supported by your LaTeX compiler.")
+
+ ENDIF (EXISTS ${synctex_file_gz})
+
+ENDMACRO(LATEX_CORRECT_SYNCTEX)
+
+#############################################################################
+# Helper macros for establishing LaTeX build.
+#############################################################################
+
+MACRO(LATEX_NEEDIT VAR NAME)
+ IF (NOT ${VAR})
+ MESSAGE(SEND_ERROR "I need the ${NAME} command.")
+ ENDIF(NOT ${VAR})
+ENDMACRO(LATEX_NEEDIT)
+
+MACRO(LATEX_WANTIT VAR NAME)
+ IF (NOT ${VAR})
+ MESSAGE(STATUS "I could not find the ${NAME} command.")
+ ENDIF(NOT ${VAR})
+ENDMACRO(LATEX_WANTIT)
+
+MACRO(LATEX_SETUP_VARIABLES)
+ SET(LATEX_OUTPUT_PATH "${LATEX_OUTPUT_PATH}"
+ CACHE PATH "If non empty, specifies the location to place LaTeX output."
+ )
+
+ FIND_PACKAGE(LATEX)
+
+ FIND_PROGRAM(XINDY_COMPILER
+ NAME xindy
+ PATHS ${MIKTEX_BINARY_PATH} /usr/bin
+ )
+
+ FIND_PACKAGE(UnixCommands)
+
+ MARK_AS_ADVANCED(CLEAR
+ LATEX_COMPILER
+ PDFLATEX_COMPILER
+ BIBTEX_COMPILER
+ MAKEINDEX_COMPILER
+ XINDY_COMPILER
+ DVIPS_CONVERTER
+ PS2PDF_CONVERTER
+ LATEX2HTML_CONVERTER
+ )
+
+ LATEX_NEEDIT(LATEX_COMPILER latex)
+ LATEX_WANTIT(PDFLATEX_COMPILER pdflatex)
+ LATEX_NEEDIT(BIBTEX_COMPILER bibtex)
+ LATEX_NEEDIT(MAKEINDEX_COMPILER makeindex)
+ LATEX_WANTIT(DVIPS_CONVERTER dvips)
+ LATEX_WANTIT(PS2PDF_CONVERTER ps2pdf)
+ LATEX_WANTIT(LATEX2HTML_CONVERTER latex2html)
+
+ SET(LATEX_COMPILER_FLAGS "-interaction=nonstopmode"
+ CACHE STRING "Flags passed to latex.")
+ SET(PDFLATEX_COMPILER_FLAGS ${LATEX_COMPILER_FLAGS}
+ CACHE STRING "Flags passed to pdflatex.")
+ SET(LATEX_SYNCTEX_FLAGS "-synctex=1"
+ CACHE STRING "latex/pdflatex flags used to create synctex file.")
+ SET(BIBTEX_COMPILER_FLAGS ""
+ CACHE STRING "Flags passed to bibtex.")
+ SET(MAKEINDEX_COMPILER_FLAGS ""
+ CACHE STRING "Flags passed to makeindex.")
+ SET(MAKEGLOSSARIES_COMPILER_FLAGS ""
+ CACHE STRING "Flags passed to makeglossaries.")
+ SET(MAKENOMENCLATURE_COMPILER_FLAGS ""
+ CACHE STRING "Flags passed to makenomenclature.")
+ SET(DVIPS_CONVERTER_FLAGS "-Ppdf -G0 -t letter"
+ CACHE STRING "Flags passed to dvips.")
+ SET(PS2PDF_CONVERTER_FLAGS "-dMaxSubsetPct=100 -dCompatibilityLevel=1.3 -dSubsetFonts=true -dEmbedAllFonts=true -dAutoFilterColorImages=false -dAutoFilterGrayImages=false -dColorImageFilter=/FlateEncode -dGrayImageFilter=/FlateEncode -dMonoImageFilter=/FlateEncode"
+ CACHE STRING "Flags passed to ps2pdf.")
+ SET(LATEX2HTML_CONVERTER_FLAGS ""
+ CACHE STRING "Flags passed to latex2html.")
+ MARK_AS_ADVANCED(
+ LATEX_COMPILER_FLAGS
+ PDFLATEX_COMPILER_FLAGS
+ LATEX_SYNCTEX_FLAGS
+ BIBTEX_COMPILER_FLAGS
+ MAKEINDEX_COMPILER_FLAGS
+ MAKEGLOSSARIES_COMPILER_FLAGS
+ MAKENOMENCLATURE_COMPILER_FLAGS
+ DVIPS_CONVERTER_FLAGS
+ PS2PDF_CONVERTER_FLAGS
+ LATEX2HTML_CONVERTER_FLAGS
+ )
+ SEPARATE_ARGUMENTS(LATEX_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(PDFLATEX_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(LATEX_SYNCTEX_FLAGS)
+ SEPARATE_ARGUMENTS(BIBTEX_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(MAKEINDEX_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(MAKEGLOSSARIES_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(MAKENOMENCLATURE_COMPILER_FLAGS)
+ SEPARATE_ARGUMENTS(DVIPS_CONVERTER_FLAGS)
+ SEPARATE_ARGUMENTS(PS2PDF_CONVERTER_FLAGS)
+ SEPARATE_ARGUMENTS(LATEX2HTML_CONVERTER_FLAGS)
+
+ FIND_PROGRAM(IMAGEMAGICK_CONVERT convert
+ DOC "The convert program that comes with ImageMagick (available at http://www.imagemagick.org)."
+ )
+ IF (NOT IMAGEMAGICK_CONVERT)
+ MESSAGE(SEND_ERROR "Could not find convert program. Please download ImageMagick from http://www.imagemagick.org and install.")
+ ENDIF (NOT IMAGEMAGICK_CONVERT)
+
+ OPTION(LATEX_USE_SYNCTEX
+ "If on, have LaTeX generate a synctex file, which WYSIWYG editors can use to correlate output files like dvi and pdf with the lines of LaTeX source that generates them. In addition to adding the LATEX_SYNCTEX_FLAGS to the command line, this option also adds build commands that \"corrects\" the resulting synctex file to point to the original LaTeX files rather than those generated by UseLATEX.cmake."
+ OFF
+ )
+
+ OPTION(LATEX_SMALL_IMAGES
+ "If on, the raster images will be converted to 1/6 the original size. This is because papers usually require 600 dpi images whereas most monitors only require at most 96 dpi. Thus, smaller images make smaller files for web distributation and can make it faster to read dvi files."
+ OFF)
+ IF (LATEX_SMALL_IMAGES)
+ SET(LATEX_RASTER_SCALE 16)
+ SET(LATEX_OPPOSITE_RASTER_SCALE 100)
+ ELSE (LATEX_SMALL_IMAGES)
+ SET(LATEX_RASTER_SCALE 100)
+ SET(LATEX_OPPOSITE_RASTER_SCALE 16)
+ ENDIF (LATEX_SMALL_IMAGES)
+
+ # Just holds extensions for known image types. They should all be lower case.
+ SET(LATEX_DVI_VECTOR_IMAGE_EXTENSIONS .eps)
+ SET(LATEX_DVI_RASTER_IMAGE_EXTENSIONS)
+ SET(LATEX_DVI_IMAGE_EXTENSIONS
+ ${LATEX_DVI_VECTOR_IMAGE_EXTENSIONS} ${LATEX_DVI_RASTER_IMAGE_EXTENSIONS})
+ SET(LATEX_PDF_VECTOR_IMAGE_EXTENSIONS .pdf)
+ SET(LATEX_PDF_RASTER_IMAGE_EXTENSIONS .png .jpeg .jpg)
+ SET(LATEX_PDF_IMAGE_EXTENSIONS
+ ${LATEX_PDF_VECTOR_IMAGE_EXTENSIONS} ${LATEX_PDF_RASTER_IMAGE_EXTENSIONS})
+ SET(LATEX_IMAGE_EXTENSIONS
+ ${LATEX_DVI_IMAGE_EXTENSIONS} ${LATEX_PDF_IMAGE_EXTENSIONS})
+ENDMACRO(LATEX_SETUP_VARIABLES)
+
+MACRO(LATEX_GET_OUTPUT_PATH var)
+ SET(${var})
+ IF (LATEX_OUTPUT_PATH)
+ IF ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ MESSAGE(SEND_ERROR "You cannot set LATEX_OUTPUT_PATH to the same directory that contains LaTeX input files.")
+ ELSE ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ SET(${var} "${LATEX_OUTPUT_PATH}")
+ ENDIF ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ ELSE (LATEX_OUTPUT_PATH)
+ IF ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ MESSAGE(SEND_ERROR "LaTeX files must be built out of source or you must set LATEX_OUTPUT_PATH.")
+ ELSE ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ SET(${var} "${CMAKE_CURRENT_BINARY_DIR}")
+ ENDIF ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
+ ENDIF (LATEX_OUTPUT_PATH)
+ENDMACRO(LATEX_GET_OUTPUT_PATH)
+
+MACRO(LATEX_ADD_CONVERT_COMMAND output_path input_path output_extension
+ input_extension flags)
+ SET (converter ${IMAGEMAGICK_CONVERT})
+ SET (convert_flags "")
+ # ImageMagick has broken eps to pdf conversion
+ # use ps2pdf instead
+ IF (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
+ IF (PS2PDF_CONVERTER)
+ SET (converter ${PS2PDF_CONVERTER})
+ SET (convert_flags -dEPSCrop ${PS2PDF_CONVERTER_FLAGS})
+ ELSE (PS2PDF_CONVERTER)
+ MESSAGE(SEND_ERROR "Using postscript files with pdflatex requires ps2pdf for conversion.")
+ ENDIF (PS2PDF_CONVERTER)
+ ELSE (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
+ SET (convert_flags ${flags})
+ ENDIF (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
+
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_path}
+ COMMAND ${converter}
+ ARGS ${convert_flags} ${input_path} ${output_path}
+ DEPENDS ${input_path}
+ )
+ENDMACRO(LATEX_ADD_CONVERT_COMMAND)
+
+# Makes custom commands to convert a file to a particular type.
+MACRO(LATEX_CONVERT_IMAGE output_files input_file output_extension convert_flags
+ output_extensions other_files)
+ SET(input_dir ${CMAKE_CURRENT_SOURCE_DIR})
+ LATEX_GET_OUTPUT_PATH(output_dir)
+
+ GET_FILENAME_COMPONENT(extension "${input_file}" EXT)
+
+ STRING(REGEX REPLACE "\\.[^.]*\$" ${output_extension} output_file
+ "${input_file}")
+
+ LATEX_LIST_CONTAINS(is_type ${extension} ${output_extensions})
+ IF (is_type)
+ IF (convert_flags)
+ LATEX_ADD_CONVERT_COMMAND(${output_dir}/${output_file}
+ ${input_dir}/${input_file} ${output_extension} ${extension}
+ "${convert_flags}")
+ SET(${output_files} ${${output_files}} ${output_dir}/${output_file})
+ ELSE (convert_flags)
+ # As a shortcut, we can just copy the file.
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${input_file}
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy ${input_dir}/${input_file} ${output_dir}/${input_file}
+ DEPENDS ${input_dir}/${input_file}
+ )
+ SET(${output_files} ${${output_files}} ${output_dir}/${input_file})
+ ENDIF (convert_flags)
+ ELSE (is_type)
+ SET(do_convert TRUE)
+ # Check to see if there is another input file of the appropriate type.
+ FOREACH(valid_extension ${output_extensions})
+ STRING(REGEX REPLACE "\\.[^.]*\$" ${output_extension} try_file
+ "${input_file}")
+ LATEX_LIST_CONTAINS(has_native_file "${try_file}" ${other_files})
+ IF (has_native_file)
+ SET(do_convert FALSE)
+ ENDIF (has_native_file)
+ ENDFOREACH(valid_extension)
+
+ # If we still need to convert, do it.
+ IF (do_convert)
+ LATEX_ADD_CONVERT_COMMAND(${output_dir}/${output_file}
+ ${input_dir}/${input_file} ${output_extension} ${extension}
+ "${convert_flags}")
+ SET(${output_files} ${${output_files}} ${output_dir}/${output_file})
+ ENDIF (do_convert)
+ ENDIF (is_type)
+ENDMACRO(LATEX_CONVERT_IMAGE)
+
+# Adds custom commands to process the given files for dvi and pdf builds.
+# Adds the output files to the given variables (does not replace).
+MACRO(LATEX_PROCESS_IMAGES dvi_outputs pdf_outputs)
+ LATEX_GET_OUTPUT_PATH(output_dir)
+ FOREACH(file ${ARGN})
+ IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+ GET_FILENAME_COMPONENT(extension "${file}" EXT)
+ SET(convert_flags)
+
+ # Check to see if we need to downsample the image.
+ LATEX_LIST_CONTAINS(is_raster "${extension}"
+ ${LATEX_DVI_RASTER_IMAGE_EXTENSIONS}
+ ${LATEX_PDF_RASTER_IMAGE_EXTENSIONS})
+ IF (LATEX_SMALL_IMAGES)
+ IF (is_raster)
+ SET(convert_flags -resize ${LATEX_RASTER_SCALE}%)
+ ENDIF (is_raster)
+ ENDIF (LATEX_SMALL_IMAGES)
+
+ # Make sure the output directory exists.
+ GET_FILENAME_COMPONENT(path "${output_dir}/${file}" PATH)
+ MAKE_DIRECTORY("${path}")
+
+ # Do conversions for dvi.
+ LATEX_CONVERT_IMAGE(${dvi_outputs} "${file}" .eps "${convert_flags}"
+ "${LATEX_DVI_IMAGE_EXTENSIONS}" "${ARGN}")
+
+ # Do conversions for pdf.
+ IF (is_raster)
+ LATEX_CONVERT_IMAGE(${pdf_outputs} "${file}" .png "${convert_flags}"
+ "${LATEX_PDF_IMAGE_EXTENSIONS}" "${ARGN}")
+ ELSE (is_raster)
+ LATEX_CONVERT_IMAGE(${pdf_outputs} "${file}" .pdf "${convert_flags}"
+ "${LATEX_PDF_IMAGE_EXTENSIONS}" "${ARGN}")
+ ENDIF (is_raster)
+ ELSE (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+ MESSAGE(WARNING "Could not find file ${CMAKE_CURRENT_SOURCE_DIR}/${file}. Are you sure you gave relative paths to IMAGES?")
+ ENDIF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+ ENDFOREACH(file)
+ENDMACRO(LATEX_PROCESS_IMAGES)
+
+MACRO(ADD_LATEX_IMAGES)
+ MESSAGE("The ADD_LATEX_IMAGES macro is deprecated. Image directories are specified with LATEX_ADD_DOCUMENT.")
+ENDMACRO(ADD_LATEX_IMAGES)
+
+MACRO(LATEX_COPY_GLOBBED_FILES pattern dest)
+ FILE(GLOB file_list ${pattern})
+ FOREACH(in_file ${file_list})
+ GET_FILENAME_COMPONENT(out_file ${in_file} NAME)
+ CONFIGURE_FILE(${in_file} ${dest}/${out_file} COPYONLY)
+ ENDFOREACH(in_file)
+ENDMACRO(LATEX_COPY_GLOBBED_FILES)
+
+MACRO(LATEX_COPY_INPUT_FILE file)
+ LATEX_GET_OUTPUT_PATH(output_dir)
+
+ IF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
+ GET_FILENAME_COMPONENT(path ${file} PATH)
+ FILE(MAKE_DIRECTORY ${output_dir}/${path})
+
+ LATEX_LIST_CONTAINS(use_config ${file} ${LATEX_CONFIGURE})
+ IF (use_config)
+ CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${file}
+ ${output_dir}/${file}
+ @ONLY
+ )
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${file}
+ COMMAND ${CMAKE_COMMAND}
+ ARGS ${CMAKE_BINARY_DIR}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${file}
+ )
+ ELSE (use_config)
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${file}
+ COMMAND ${CMAKE_COMMAND}
+ ARGS -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${file} ${output_dir}/${file}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${file}
+ )
+ ENDIF (use_config)
+ ELSE (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
+ IF (EXISTS ${output_dir}/${file})
+ # Special case: output exists but input does not. Assume that it was
+ # created elsewhere and skip the input file copy.
+ ELSE (EXISTS ${output_dir}/${file})
+ MESSAGE("Could not find input file ${CMAKE_CURRENT_SOURCE_DIR}/${file}")
+ ENDIF (EXISTS ${output_dir}/${file})
+ ENDIF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
+ENDMACRO(LATEX_COPY_INPUT_FILE)
+
+#############################################################################
+# Commands provided by the UseLATEX.cmake "package"
+#############################################################################
+
+MACRO(LATEX_USAGE command message)
+ MESSAGE(SEND_ERROR
+ "${message}\nUsage: ${command}(<tex_file>\n [BIBFILES <bib_file> <bib_file> ...]\n [INPUTS <tex_file> <tex_file> ...]\n [IMAGE_DIRS <directory1> <directory2> ...]\n [IMAGES <image_file1> <image_file2>\n [CONFIGURE <tex_file> <tex_file> ...]\n [DEPENDS <tex_file> <tex_file> ...]\n [MULTIBIB_NEWCITES] <suffix_list>\n [USE_INDEX] [USE_GLOSSARY] [USE_NOMENCL]\n [DEFAULT_PDF] [DEFAULT_SAFEPDF]\n [MANGLE_TARGET_NAMES])"
+ )
+ENDMACRO(LATEX_USAGE command message)
+
+# Parses arguments to ADD_LATEX_DOCUMENT and ADD_LATEX_TARGETS and sets the
+# variables LATEX_TARGET, LATEX_IMAGE_DIR, LATEX_BIBFILES, LATEX_DEPENDS, and
+# LATEX_INPUTS.
+MACRO(PARSE_ADD_LATEX_ARGUMENTS command)
+ LATEX_PARSE_ARGUMENTS(
+ LATEX
+ "BIBFILES;FATHER_TARGET;MULTIBIB_NEWCITES;INPUTS;IMAGE_DIRS;IMAGES;CONFIGURE;DEPENDS"
+ "USE_INDEX;USE_GLOSSARY;USE_GLOSSARIES;USE_NOMENCL;DEFAULT_PDF;DEFAULT_SAFEPDF;MANGLE_TARGET_NAMES"
+ ${ARGN}
+ )
+
+ # The first argument is the target latex file.
+ IF (LATEX_DEFAULT_ARGS)
+ LATEX_CAR(LATEX_MAIN_INPUT ${LATEX_DEFAULT_ARGS})
+ LATEX_CDR(LATEX_DEFAULT_ARGS ${LATEX_DEFAULT_ARGS})
+ GET_FILENAME_COMPONENT(LATEX_TARGET ${LATEX_MAIN_INPUT} NAME_WE)
+ ELSE (LATEX_DEFAULT_ARGS)
+ LATEX_USAGE(${command} "No tex file target given to ${command}.")
+ ENDIF (LATEX_DEFAULT_ARGS)
+
+ IF (LATEX_DEFAULT_ARGS)
+ LATEX_USAGE(${command} "Invalid or depricated arguments: ${LATEX_DEFAULT_ARGS}")
+ ENDIF (LATEX_DEFAULT_ARGS)
+
+ # Backward compatibility between 1.6.0 and 1.6.1.
+ IF (LATEX_USE_GLOSSARIES)
+ SET(LATEX_USE_GLOSSARY TRUE)
+ ENDIF (LATEX_USE_GLOSSARIES)
+ENDMACRO(PARSE_ADD_LATEX_ARGUMENTS)
+
+MACRO(ADD_LATEX_TARGETS)
+ LATEX_GET_OUTPUT_PATH(output_dir)
+ PARSE_ADD_LATEX_ARGUMENTS(ADD_LATEX_TARGETS ${ARGV})
+
+ IF (LATEX_USE_SYNCTEX)
+ SET(synctex_flags ${LATEX_SYNCTEX_FLAGS})
+ ELSE (LATEX_USE_SYNCTEX)
+ SET(synctex_flags)
+ ENDIF (LATEX_USE_SYNCTEX)
+
+ # The commands to run LaTeX. They are repeated multiple times.
+ SET(latex_build_command
+ ${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${synctex_flags} ${LATEX_MAIN_INPUT}
+ )
+ SET(pdflatex_build_command
+ ${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${synctex_flags} ${LATEX_MAIN_INPUT}
+ )
+
+ # Set up target names.
+ IF (LATEX_MANGLE_TARGET_NAMES)
+ SET(dvi_target ${LATEX_TARGET}_dvi)
+ SET(pdf_target ${LATEX_TARGET}_pdf)
+ SET(ps_target ${LATEX_TARGET}_ps)
+ SET(safepdf_target ${LATEX_TARGET}_safepdf)
+ SET(html_target ${LATEX_TARGET}_html)
+ SET(auxclean_target ${LATEX_TARGET}_auxclean)
+ ELSE (LATEX_MANGLE_TARGET_NAMES)
+ SET(dvi_target dvi)
+ SET(pdf_target pdf)
+ SET(ps_target ps)
+ SET(safepdf_target safepdf)
+ SET(html_target html)
+ SET(auxclean_target auxclean)
+ ENDIF (LATEX_MANGLE_TARGET_NAMES)
+
+ # Probably not all of these will be generated, but they could be.
+ # Note that the aux file is added later.
+ SET(auxiliary_clean_files
+ ${output_dir}/${LATEX_TARGET}.bbl
+ ${output_dir}/${LATEX_TARGET}.blg
+ ${output_dir}/${LATEX_TARGET}-blx.bib
+ ${output_dir}/${LATEX_TARGET}.glg
+ ${output_dir}/${LATEX_TARGET}.glo
+ ${output_dir}/${LATEX_TARGET}.gls
+ ${output_dir}/${LATEX_TARGET}.idx
+ ${output_dir}/${LATEX_TARGET}.ilg
+ ${output_dir}/${LATEX_TARGET}.ind
+ ${output_dir}/${LATEX_TARGET}.ist
+ ${output_dir}/${LATEX_TARGET}.log
+ ${output_dir}/${LATEX_TARGET}.out
+ ${output_dir}/${LATEX_TARGET}.toc
+ ${output_dir}/${LATEX_TARGET}.lof
+ ${output_dir}/${LATEX_TARGET}.xdy
+ ${output_dir}/${LATEX_TARGET}.synctex.gz
+ ${output_dir}/${LATEX_TARGET}.synctex.bak.gz
+ ${output_dir}/${LATEX_TARGET}.dvi
+ ${output_dir}/${LATEX_TARGET}.ps
+ ${output_dir}/${LATEX_TARGET}.pdf
+ )
+
+ # For each directory in LATEX_IMAGE_DIRS, glob all the image files and
+ # place them in LATEX_IMAGES.
+ FOREACH(dir ${LATEX_IMAGE_DIRS})
+ FOREACH(extension ${LATEX_IMAGE_EXTENSIONS})
+ IF (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
+ MESSAGE(WARNING "Image directory ${CMAKE_CURRENT_SOURCE_DIR}/${dir} does not exist. Are you sure you gave relative directories to IMAGE_DIRS?")
+ ENDIF (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${dir})
+ FILE(GLOB files ${CMAKE_CURRENT_SOURCE_DIR}/${dir}/*${extension})
+ FOREACH(file ${files})
+ GET_FILENAME_COMPONENT(filename ${file} NAME)
+ SET(LATEX_IMAGES ${LATEX_IMAGES} ${dir}/${filename})
+ ENDFOREACH(file)
+ ENDFOREACH(extension)
+ ENDFOREACH(dir)
+
+ SET(dvi_images)
+ SET(pdf_images)
+ LATEX_PROCESS_IMAGES(dvi_images pdf_images ${LATEX_IMAGES})
+
+ SET(make_dvi_command
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command})
+ SET(make_pdf_command
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command}
+ )
+
+ SET(make_dvi_depends ${LATEX_DEPENDS} ${dvi_images})
+ SET(make_pdf_depends ${LATEX_DEPENDS} ${pdf_images})
+ FOREACH(input ${LATEX_MAIN_INPUT} ${LATEX_INPUTS})
+ SET(make_dvi_depends ${make_dvi_depends} ${output_dir}/${input})
+ SET(make_pdf_depends ${make_pdf_depends} ${output_dir}/${input})
+ IF (${input} MATCHES "\\.tex$")
+ STRING(REGEX REPLACE "\\.tex$" "" input_we ${input})
+ SET(auxiliary_clean_files ${auxiliary_clean_files}
+ ${output_dir}/${input_we}.aux
+ ${output_dir}/${input}.aux
+ )
+ ENDIF (${input} MATCHES "\\.tex$")
+ ENDFOREACH(input)
+
+ IF (LATEX_USE_GLOSSARY)
+ FOREACH(dummy 0 1) # Repeat these commands twice.
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=makeglossaries
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
+ -D XINDY_COMPILER=${XINDY_COMPILER}
+ -D MAKEGLOSSARIES_COMPILER_FLAGS=${MAKEGLOSSARIES_COMPILER_FLAGS}
+ -P ${LATEX_USE_LATEX_LOCATION}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command}
+ )
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=makeglossaries
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
+ -D XINDY_COMPILER=${XINDY_COMPILER}
+ -D MAKEGLOSSARIES_COMPILER_FLAGS=${MAKEGLOSSARIES_COMPILER_FLAGS}
+ -P ${LATEX_USE_LATEX_LOCATION}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command}
+ )
+ ENDFOREACH(dummy)
+ ENDIF (LATEX_USE_GLOSSARY)
+
+ IF (LATEX_USE_NOMENCL)
+ FOREACH(dummy 0 1) # Repeat these commands twice.
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=makenomenclature
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
+ -D MAKENOMENCLATURE_COMPILER_FLAGS=${MAKENOMENCLATURE_COMPILER_FLAGS}
+ -P ${LATEX_USE_LATEX_LOCATION}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command}
+ )
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=makenomenclature
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
+ -D MAKENOMENCLATURE_COMPILER_FLAGS=${MAKENOMENCLATURE_COMPILER_FLAGS}
+ -P ${LATEX_USE_LATEX_LOCATION}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command}
+ )
+ ENDFOREACH(dummy)
+ ENDIF (LATEX_USE_NOMENCL)
+
+ IF (LATEX_BIBFILES)
+ IF (LATEX_MULTIBIB_NEWCITES)
+ FOREACH (multibib_auxfile ${LATEX_MULTIBIB_NEWCITES})
+ GET_FILENAME_COMPONENT(multibib_target ${multibib_auxfile} NAME_WE)
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${multibib_target})
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${multibib_target})
+ SET(auxiliary_clean_files ${auxiliary_clean_files}
+ ${output_dir}/${multibib_target}.aux)
+ ENDFOREACH (multibib_auxfile ${LATEX_MULTIBIB_NEWCITES})
+ ELSE (LATEX_MULTIBIB_NEWCITES)
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${LATEX_TARGET})
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${LATEX_TARGET})
+ ENDIF (LATEX_MULTIBIB_NEWCITES)
+
+ FOREACH (bibfile ${LATEX_BIBFILES})
+ SET(make_dvi_depends ${make_dvi_depends} ${output_dir}/${bibfile})
+ SET(make_pdf_depends ${make_pdf_depends} ${output_dir}/${bibfile})
+ ENDFOREACH (bibfile ${LATEX_BIBFILES})
+ ELSE (LATEX_BIBFILES)
+ IF (LATEX_MULTIBIB_NEWCITES)
+ MESSAGE(WARNING "MULTIBIB_NEWCITES has no effect without BIBFILES option.")
+ ENDIF (LATEX_MULTIBIB_NEWCITES)
+ ENDIF (LATEX_BIBFILES)
+
+ IF (LATEX_USE_INDEX)
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${MAKEINDEX_COMPILER} ${MAKEINDEX_COMPILER_FLAGS} ${LATEX_TARGET}.idx)
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${MAKEINDEX_COMPILER} ${MAKEINDEX_COMPILER_FLAGS} ${LATEX_TARGET}.idx)
+ ENDIF (LATEX_USE_INDEX)
+
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${latex_build_command})
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command}
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${pdflatex_build_command})
+
+ IF (LATEX_USE_SYNCTEX)
+ IF (NOT GZIP)
+ MESSAGE(SEND_ERROR "UseLATEX.cmake: USE_SYNTEX option requires gzip program. Set GZIP variable.")
+ ENDIF (NOT GZIP)
+ SET(make_dvi_command ${make_dvi_command}
+ COMMAND ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=correct_synctex
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D GZIP=${GZIP}
+ -D "LATEX_SOURCE_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}"
+ -D "LATEX_BINARY_DIRECTORY=${output_dir}"
+ -P ${LATEX_USE_LATEX_LOCATION}
+ )
+ SET(make_pdf_command ${make_pdf_command}
+ COMMAND ${CMAKE_COMMAND}
+ -D LATEX_BUILD_COMMAND=correct_synctex
+ -D LATEX_TARGET=${LATEX_TARGET}
+ -D GZIP=${GZIP}
+ -D "LATEX_SOURCE_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}"
+ -D "LATEX_BINARY_DIRECTORY=${output_dir}"
+ -P ${LATEX_USE_LATEX_LOCATION}
+ )
+ ENDIF (LATEX_USE_SYNCTEX)
+
+ # Add commands and targets for building dvi outputs.
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.dvi
+ COMMAND ${make_dvi_command}
+ DEPENDS ${make_dvi_depends}
+ )
+ IF (LATEX_DEFAULT_PDF OR LATEX_DEFAULT_SAFEPDF)
+ ADD_CUSTOM_TARGET(${dvi_target}
+ DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
+ ELSE (LATEX_DEFAULT_PDF OR LATEX_DEFAULT_SAFEPDF)
+ IF (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${dvi_target}
+ DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
+ ADD_DEPENDENCIES(${LATEX_FATHER_TARGET} ${dvi_target})
+ ELSE (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${dvi_target} ALL
+ DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
+ ENDIF (LATEX_FATHER_TARGET)
+ ENDIF (LATEX_DEFAULT_PDF OR LATEX_DEFAULT_SAFEPDF)
+
+ # Add commands and targets for building pdf outputs (with pdflatex).
+ IF (PDFLATEX_COMPILER)
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.pdf
+ COMMAND ${make_pdf_command}
+ DEPENDS ${make_pdf_depends}
+ )
+ IF (LATEX_DEFAULT_PDF)
+ IF (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${pdf_target}
+ DEPENDS ${output_dir}/${LATEX_TARGET}.pdf)
+ ADD_DEPENDENCIES(${LATEX_FATHER_TARGET} ${pdf_target})
+ ELSE (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${pdf_target} ALL
+ DEPENDS ${output_dir}/${LATEX_TARGET}.pdf)
+ ENDIF (LATEX_FATHER_TARGET)
+ ELSE (LATEX_DEFAULT_PDF)
+ ADD_CUSTOM_TARGET(${pdf_target}
+ DEPENDS ${output_dir}/${LATEX_TARGET}.pdf)
+ ENDIF (LATEX_DEFAULT_PDF)
+ ENDIF (PDFLATEX_COMPILER)
+
+ IF (DVIPS_CONVERTER)
+ ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.ps
+ COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${DVIPS_CONVERTER} ${DVIPS_CONVERTER_FLAGS} -o ${LATEX_TARGET}.ps ${LATEX_TARGET}.dvi
+ DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
+ ADD_CUSTOM_TARGET(${ps_target}
+ DEPENDS ${output_dir}/${LATEX_TARGET}.ps)
+ IF (PS2PDF_CONVERTER)
+ # Since both the pdf and safepdf targets have the same output, we
+ # cannot properly do the dependencies for both. When selecting safepdf,
+ # simply force a recompile every time.
+ IF (LATEX_DEFAULT_SAFEPDF)
+ IF (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${safepdf_target}
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${PS2PDF_CONVERTER} ${PS2PDF_CONVERTER_FLAGS} ${LATEX_TARGET}.ps ${LATEX_TARGET}.pdf
+ )
+ ADD_DEPENDENCIES(${LATEX_FATHER_TARGET} ${safepdf_target})
+ ELSE (LATEX_FATHER_TARGET)
+ ADD_CUSTOM_TARGET(${safepdf_target} ALL
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${PS2PDF_CONVERTER} ${PS2PDF_CONVERTER_FLAGS} ${LATEX_TARGET}.ps ${LATEX_TARGET}.pdf
+ )
+ ENDIF (LATEX_FATHER_TARGET)
+ ELSE (LATEX_DEFAULT_SAFEPDF)
+ ADD_CUSTOM_TARGET(${safepdf_target}
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${PS2PDF_CONVERTER} ${PS2PDF_CONVERTER_FLAGS} ${LATEX_TARGET}.ps ${LATEX_TARGET}.pdf
+ )
+ ENDIF (LATEX_DEFAULT_SAFEPDF)
+ ADD_DEPENDENCIES(${safepdf_target} ${ps_target})
+ ENDIF (PS2PDF_CONVERTER)
+ ENDIF (DVIPS_CONVERTER)
+
+ IF (LATEX2HTML_CONVERTER)
+ ADD_CUSTOM_TARGET(${html_target}
+ ${CMAKE_COMMAND} -E chdir ${output_dir}
+ ${LATEX2HTML_CONVERTER} ${LATEX2HTML_CONVERTER_FLAGS} ${LATEX_MAIN_INPUT}
+ )
+ ADD_DEPENDENCIES(${html_target} ${LATEX_MAIN_INPUT} ${LATEX_INPUTS})
+ ENDIF (LATEX2HTML_CONVERTER)
+
+ SET_DIRECTORY_PROPERTIES(.
+ ADDITIONAL_MAKE_CLEAN_FILES "${auxiliary_clean_files}"
+ )
+
+ ADD_CUSTOM_TARGET(${auxclean_target}
+ COMMENT "Cleaning auxiliary LaTeX files."
+ COMMAND ${CMAKE_COMMAND} -E remove ${auxiliary_clean_files}
+ )
+ENDMACRO(ADD_LATEX_TARGETS)
+
+MACRO(ADD_LATEX_DOCUMENT)
+ LATEX_GET_OUTPUT_PATH(output_dir)
+ IF (output_dir)
+ PARSE_ADD_LATEX_ARGUMENTS(ADD_LATEX_DOCUMENT ${ARGV})
+
+ LATEX_COPY_INPUT_FILE(${LATEX_MAIN_INPUT})
+
+ FOREACH (bib_file ${LATEX_BIBFILES})
+ LATEX_COPY_INPUT_FILE(${bib_file})
+ ENDFOREACH (bib_file)
+
+ FOREACH (input ${LATEX_INPUTS})
+ LATEX_COPY_INPUT_FILE(${input})
+ ENDFOREACH(input)
+
+ LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.cls ${output_dir})
+ LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.bst ${output_dir})
+ LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.clo ${output_dir})
+ LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.sty ${output_dir})
+ LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.ist ${output_dir})
+
+ ADD_LATEX_TARGETS(${ARGV})
+ ENDIF (output_dir)
+ENDMACRO(ADD_LATEX_DOCUMENT)
+
+#############################################################################
+# Actually do stuff
+#############################################################################
+
+IF (LATEX_BUILD_COMMAND)
+ SET(command_handled)
+
+ IF ("${LATEX_BUILD_COMMAND}" STREQUAL makeglossaries)
+ LATEX_MAKEGLOSSARIES()
+ SET(command_handled TRUE)
+ ENDIF ("${LATEX_BUILD_COMMAND}" STREQUAL makeglossaries)
+
+ IF ("${LATEX_BUILD_COMMAND}" STREQUAL makenomenclature)
+ LATEX_MAKENOMENCLATURE()
+ SET(command_handled TRUE)
+ ENDIF ("${LATEX_BUILD_COMMAND}" STREQUAL makenomenclature)
+
+ IF ("${LATEX_BUILD_COMMAND}" STREQUAL correct_synctex)
+ LATEX_CORRECT_SYNCTEX()
+ SET(command_handled TRUE)
+ ENDIF ("${LATEX_BUILD_COMMAND}" STREQUAL correct_synctex)
+
+ IF (NOT command_handled)
+ MESSAGE(SEND_ERROR "Unknown command: ${LATEX_BUILD_COMMAND}")
+ ENDIF (NOT command_handled)
+
+ELSE (LATEX_BUILD_COMMAND)
+ # Must be part of the actual configure (included from CMakeLists.txt).
+ LATEX_SETUP_VARIABLES()
+ENDIF (LATEX_BUILD_COMMAND)
diff --git a/cmake/pkg/.gitignore b/cmake/pkg/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3dda72986fc5af262451a760393b3a7065938c80
--- /dev/null
+++ b/cmake/pkg/.gitignore
@@ -0,0 +1,2 @@
+Makefile.in
+Makefile
diff --git a/cmake/pkg/Makefile.am b/cmake/pkg/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..1d7d2c8a2bcd4983d7c54cc6e9da010441257cc2
--- /dev/null
+++ b/cmake/pkg/Makefile.am
@@ -0,0 +1 @@
+EXTRA_DIST = dune-common-config.cmake.in
diff --git a/cmake/pkg/dune-common-config.cmake.in b/cmake/pkg/dune-common-config.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..3f02188e8e760bb65e75bf97cd0edf38d1941fee
--- /dev/null
+++ b/cmake/pkg/dune-common-config.cmake.in
@@ -0,0 +1,24 @@
+if(NOT @DUNE_MOD_NAME@_FOUND)
+#compute installation prefix relative to this file
+get_filename_component(_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_prefix "${_dir}/../../.." ABSOLUTE)
+
+#import the target
+include("${_prefix}/lib/cmake/@DUNE_MOD_NAME@-targets.cmake")
+
+#report other information
+set(@DUNE_MOD_NAME@_PREFIX "${_prefix}")
+set(@DUNE_MOD_NAME@_INCLUDE_DIRS "${_prefix}/include")
+set(@DUNE_MOD_NAME@_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_MINSIZEREL "@CMAKE_CXX_FLAGS_MINSIZEREL@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@")
+set(@DUNE_MOD_NAME@_LIBRARIES "dunecommon")
+set(@DUNE_MOD_NAME@_SCRIPT_DIR "${_prefix}/share/cmake/scripts")
+set(@DUNE_MOD_NAME@_SCRIPT_SOURCE_DIR "${_prefix}/share/cmake/scripts")
+set(DOXYSTYLE_FILE "${_prefix}/share/doc/dune-common/doxygen/Doxystyle")
+set(@DUNE_MOD_NAME@_DEPENDS "@DUNE_DEPENDS@")
+set(@DUNE_MOD_NAME@_SUGGESTS "@DUNE_SUGGESTS@")
+set(@DUNE_MOD_NAME@_MODULE_PATH "@DUNE_INSTALL_MODULEDIR@")
+endif(NOT @DUNE_MOD_NAME@_FOUND)
\ No newline at end of file
diff --git a/cmake/scripts/.gitignore b/cmake/scripts/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3dda72986fc5af262451a760393b3a7065938c80
--- /dev/null
+++ b/cmake/scripts/.gitignore
@@ -0,0 +1,2 @@
+Makefile.in
+Makefile
diff --git a/cmake/scripts/BuildTests.cmake.in b/cmake/scripts/BuildTests.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..c2aadf7ab12745790f001bb59ae6a9d4eb73829f
--- /dev/null
+++ b/cmake/scripts/BuildTests.cmake.in
@@ -0,0 +1,12 @@
+MACRO(get_directory_test_target _target _dir)
+ message("$_dir")
+ string(REPLACE "@CMAKE_BINARY_DIR@" "" _relative_dir "${_dir}")
+ message("$_relative_dir")
+ string(REPLACE "/" "_" ${_target} "${_relative_dir}")
+ message("target=${${_target}}")
+ENDMACRO(get_directory_test_target _target _dir)
+
+get_directory_test_target(_build_test_target "@CMAKE_CURRENT_BINARY_DIR@")
+message("binary_dir=@CMAKE_CURRENT_BINARY_DIR@")
+execute_process(COMMAND @CMAKE_COMMAND@ --build @CMAKE_BINARY_DIR@
+ --target ${_build_test_target})
\ No newline at end of file
diff --git a/cmake/scripts/CMakeLists.txt b/cmake/scripts/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9facdd6c4ab72f608697b73462ecb592b203c708
--- /dev/null
+++ b/cmake/scripts/CMakeLists.txt
@@ -0,0 +1,8 @@
+set(modules
+ CreateDoxyFile.cmake
+ FindFiles.cmake
+ InstallFile.cmake
+ RunDoxygen.cmake)
+
+install(FILES ${modules} ${CMAKE_CURRENT_SOURCE_DIR}/BuildTests.cmake.in
+ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/cmake/scripts)
diff --git a/cmake/scripts/CreateDoxyFile.cmake b/cmake/scripts/CreateDoxyFile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..bb69d9513559aad2173051b8e29a8df79c144228
--- /dev/null
+++ b/cmake/scripts/CreateDoxyFile.cmake
@@ -0,0 +1,14 @@
+#For now we just support appending Doxyfile and Doxylocal
+message(STATUS "Generating Doxyfile.in")
+FILE(READ ${DOXYSTYLE} file_contents)
+FILE(WRITE Doxyfile.in ${file_contents})
+FILE(READ ${DOXYLOCAL} file_contents)
+FILE(APPEND Doxyfile.in ${file_contents})
+
+# configure_file does not work as it insists an existing input file, which in our
+# needs to be generated first.
+# Therfore we read the Doxyfile.in and replace the variables using STRING(CONFIGURE)
+# and the write the file.
+FILE(READ Doxyfile.in file_contents)
+STRING(CONFIGURE ${file_contents} output)
+FILE(WRITE Doxyfile ${output})
diff --git a/cmake/scripts/FindFiles.cmake b/cmake/scripts/FindFiles.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..b3afa251a88e95c78532babb357e280fccd612ad
--- /dev/null
+++ b/cmake/scripts/FindFiles.cmake
@@ -0,0 +1,12 @@
+#Do not follow symlinks during FILE GLOB_RECURSE
+cmake_policy(SET CMP0009 NEW)
+file(GLOB_RECURSE makefiles RELATIVE ${RELPATH} "CMakeLists.txt")
+foreach(_file ${makefiles})
+ string(REGEX MATCH ".*/test" _testdir ${_file})
+ if(_testdir)
+ list(APPEND _makefiles ${_testdir})
+ endif(_testdir)
+endforeach(_file ${makefiles})
+if(_makefiles)
+ message("${_makefiles}")
+endif(_makefiles)
diff --git a/cmake/scripts/InstallFile.cmake b/cmake/scripts/InstallFile.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..5d8a9a9c40aebe4e25b48ad6359b939890b3e0ff
--- /dev/null
+++ b/cmake/scripts/InstallFile.cmake
@@ -0,0 +1,6 @@
+
+# Somehow variable list get destroyed when calling cmake (; is replaced with
+# whitespace character. Undo this change
+string(REGEX REPLACE "([a-zA-Z0-9]) ([/a-zA-Z0-9])" "\\1;\\2" files "${FILES}")
+file(INSTALL ${files} DESTINATION ${DIR})
+
diff --git a/cmake/scripts/Makefile.am b/cmake/scripts/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..1d2f0c9be9e4f4df49464f1f4678e802eeb29d9e
--- /dev/null
+++ b/cmake/scripts/Makefile.am
@@ -0,0 +1,11 @@
+MODULES = BuildTests.cmake.in \
+ CreateDoxyFile.cmake \
+ FindFiles.cmake \
+ InstallFile.cmake \
+ RunDoxygen.cmake
+
+modulesdir = $(datadir)/cmake/scripts
+dist_modules_DATA = ${MODULES}
+
+include $(top_srcdir)/am/global-rules
+EXTRA_DIST = CMakeLists.txt
diff --git a/cmake/scripts/RunDoxygen.cmake b/cmake/scripts/RunDoxygen.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..3c79b11ca86758886873a8a82baffa90811f2d54
--- /dev/null
+++ b/cmake/scripts/RunDoxygen.cmake
@@ -0,0 +1,3 @@
+execute_process(COMMAND
+ ${DOXYGEN_EXECUTABLE} Doxyfile OUTPUT_FILE doxygen.log ERROR_FILE doxygen.log
+ TIMEOUT 120)
diff --git a/config.h.cmake b/config.h.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..4ebc98f750a91979d8dfc584666af32d22f6beb2
--- /dev/null
+++ b/config.h.cmake
@@ -0,0 +1,167 @@
+/* config.h. Generated from config.h.cmake by CMake. */
+
+/* begin dune-common */
+
+#ifdef DEPRECATED_MPI_CPPFLAGS_USED
+#warning The MPI_CPPFLAGS configure substitute is deprecated. Please change
+#warning your Makefile.am to use DUNEMPICPPFLAGS instead. Note that it is a
+#warning good idea to change any occurance of MPI_LDFLAGS into DUNEMPILIBS and
+#warning DUNEMPILDFLAGS as appropriate, since it is not possible to issue a
+#warning deprecation warning in that case.
+#endif
+
+/* If this is set, the member 'size' of FieldVector is a method rather than an
+ enum */
+#define DUNE_COMMON_FIELDVECTOR_SIZE_IS_METHOD 1
+
+/* Define to the version of dune-common */
+#define DUNE_COMMON_VERSION "${DUNE_COMMON_VERSION}"
+
+/* Define to the major version of dune-common */
+#define DUNE_COMMON_VERSION_MAJOR ${DUNE_COMMON_VERSION_MAJOR}
+
+/* Define to the minor version of dune-common */
+#define DUNE_COMMON_VERSION_MINOR ${DUNE_COMMON_VERSION_MINOR}
+
+/* Define to the revision of dune-common */
+#define DUNE_COMMON_VERSION_REVISION ${DUNE_COMMON_VERSION_REVISION}
+
+/* Standard debug streams with a level below will collapse to doing nothing */
+#define DUNE_MINIMAL_DEBUG_LEVEL ${DUNE_MINIMAL_DEBUG_LEVEL}
+
+/* does the compiler support __attribute__((deprecated))? */
+#cmakedefine HAS_ATTRIBUTE_DEPRECATED 1
+
+/* does the compiler support __attribute__((deprecated("message"))? */
+#cmakedefine HAS_ATTRIBUTE_DEPRECATED_MSG 1
+
+/* does the compiler support __attribute__((unused))? */
+#cmakedefine HAS_ATTRIBUTE_UNUSED 1
+
+/* Define to 1 if the <array> C++11 is available and support array::fill */
+#cmakedefine HAVE_ARRAY 1
+
+/* Define if you have a BLAS library. */
+#cmakedefine HAVE_BLAS 1
+
+/* Define to ENABLE_BOOST if the Boost library is available */
+#cmakedefine HAVE_BOOST ENABLE_BOOST
+
+/* Define to 1 if you have <boost/make_shared.hpp>. */
+#cmakedefine HAVE_BOOST_MAKE_SHARED_HPP 1
+
+/* Define to 1 if you have the <boost/shared_ptr.hpp> header file. */
+#cmakedefine HAVE_BOOST_SHARED_PTR_HPP 1
+
+/* does the compiler support abi::__cxa_demangle */
+#cmakedefine HAVE_CXA_DEMANGLE 1
+
+/* Define if you have LAPACK library. */
+#cmakedefine HAVE_LAPACK 1
+
+/* Define to 1 if SHARED_PTR_NAMESPACE::make_shared is usable. */
+#cmakedefine HAVE_MAKE_SHARED 1
+
+/* Define to 1 if you have the <malloc.h> header file. */
+// Not used! #cmakedefine01 HAVE_MALLOC_H
+
+/* Define if you have the MPI library. This is only true if MPI was found by
+ configure _and_ if the application uses the DUNEMPICPPFLAGS (or the
+ deprecated MPI_CPPFLAGS) */
+#cmakedefine HAVE_MPI ENABLE_MPI
+
+/* Define if you have the GNU GMP library. The value should be ENABLE_GMP
+ to facilitate activating and deactivating GMP using compile flags. */
+#cmakedefine HAVE_GMP ENABLE_GMP
+
+/* Define to 1 if you have the symbol mprotect. */
+#cmakedefine HAVE_MPROTECT 1
+
+/* Define to 1 if nullptr is supported */
+#cmakedefine HAVE_NULLPTR 1
+
+/* Define to 1 if static_assert is supported */
+#cmakedefine HAVE_STATIC_ASSERT 1
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#cmakedefine HAVE_STDINT_H 1
+
+/* Define to 1 if you have <sys/mman.h>. */
+#cmakedefine HAVE_SYS_MMAN_H 1
+
+/* Define to 1 if the std::tr1::hash template from TR1 is available. */
+#cmakedefine HAVE_TR1_HASH 1
+
+/* Define to 1 if you have the <tr1/tuple> header file. */
+#cmakedefine HAVE_TR1_TUPLE 1
+
+/* Define to 1 if you have the <tr1/type_traits> header file. */
+#cmakedefine HAVE_TR1_TYPE_TRAITS 1
+
+/* Define to 1 if std::integral_constant< T, v > is supported
+ * and casts into T
+ */
+#cmakedefine HAVE_INTEGRAL_CONSTANT 1
+
+/* Define to 1 if the std::hash template from C++11 is available. */
+#cmakedefine HAVE_STD_HASH 1
+
+/* Define to 1 if you have the <tuple> header file. */
+#cmakedefine HAVE_TUPLE 1
+
+/* Define to 1 if you have the <type_traits> header file. */
+#cmakedefine HAVE_TYPE_TRAITS 1
+
+/* Define to 1 if the MPI2 Standard is supported */
+#cmakedefine MPI_2 1
+
+/* begin private */
+
+/* Name of package */
+#define PACKAGE "dune-common"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT "@DUNE_MAINTAINER@"
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "@DUNE_MOD_NAME@"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "@DUNE_MOD_NAME@ @DUNE_MOD_VERSION@"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "@DUNE_MOD_NAME@"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL "@DUNE_MOD_URL@"
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "@DUNE_MOD_VERSION@"
+
+/* Version number of package */
+#define VERSION "@DUNE_MOD_VERSION@"
+
+/* end private */
+
+/* The header in which SHARED_PTR can be found */
+#cmakedefine SHARED_PTR_HEADER ${SHARED_PTR_HEADER}
+
+/* The namespace in which SHARED_PTR can be found */
+#cmakedefine SHARED_PTR_NAMESPACE ${SHARED_PTR_NAMESPACE}
+
+/* Define to 1 if variadic templates are supported */
+#cmakedefine HAVE_VARIADIC_TEMPLATES 1
+
+/* Define to 1 if SFINAE on variadic template constructors is fully supported */
+#cmakedefine HAVE_VARIADIC_CONSTRUCTOR_SFINAE 1
+
+/* Define to 1 if rvalue references are supported */
+#cmakedefine HAVE_RVALUE_REFERENCES 1
+
+/* Include always useful headers */
+#include <dune/common/deprecated.hh>
+#include <dune/common/unused.hh>
+#include "FC.h"
+#define FC_FUNC FC_GLOBAL_
+
+/* end dune-common */
diff --git a/configure.ac b/configure.ac
index 0baa437afbd1a5478da19135a25920d4bef059cb..36700e251b3db72a8781fdffae47f79105faefe5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -23,6 +23,10 @@ AC_SUBST([LDADD], '$(top_builddir)/lib/libdunecommon.la')
AC_CONFIG_FILES([Makefile
lib/Makefile
bin/Makefile
+ cmake/Makefile
+ cmake/modules/Makefile
+ cmake/scripts/Makefile
+ cmake/pkg/Makefile
dune/Makefile
dune/common/Makefile
dune/common/test/Makefile
diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..3714c7a1071c3e0d6be298fb952c6f59978fc849
--- /dev/null
+++ b/doc/CMakeLists.txt
@@ -0,0 +1,6 @@
+add_subdirectory("doxygen")
+add_subdirectory("buildsystem")
+add_subdirectory("comm")
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/example.opts
+ DESTINATION ${CMAKE_INSTALL_DOCDIR}
+ )
diff --git a/doc/Makefile.am b/doc/Makefile.am
index caa75253a8b906d243385af68f2d933c25b73649..494b9fd65c4c8b3dbac997c5b3a724e367f5e5f0 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -15,7 +15,7 @@ docdir=$(datadir)/doc/dune-common
DOCFILES = $(PAGES)
DOCFILES_EXTRA = example.opts
-EXTRA_DIST = $(PAGES) example.opts
+EXTRA_DIST = CMakeLists.txt $(PAGES) example.opts
# include rules for wml -> html transformation
include $(top_srcdir)/am/webstuff
diff --git a/doc/buildsystem/CMakeLists.txt b/doc/buildsystem/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..22bb42b89a32769683dcf5e081bbfc1e1220c5c7
--- /dev/null
+++ b/doc/buildsystem/CMakeLists.txt
@@ -0,0 +1,2 @@
+dune_add_latex_document(buildsystem.tex FATHER_TARGET doc DEFAULT_PDF INPUTS ../Makefile.am ../../configure.ac ../example.opts)
+create_doc_install(${CMAKE_CURRENT_BINARY_DIR}/buildsystem.pdf ${CMAKE_INSTALL_DOCDIR}/buildsystem)
diff --git a/doc/buildsystem/Makefile.am b/doc/buildsystem/Makefile.am
index 1cb4f2d55af7ff73d86644515ccf9f05275f69fd..3f953d611b0a60364fb8fc2792fec8a174659764 100644
--- a/doc/buildsystem/Makefile.am
+++ b/doc/buildsystem/Makefile.am
@@ -8,7 +8,7 @@ BASEDIR=../..
docdir=$(datadir)/doc/dune-common/buildsystem
if BUILD_DOCS
DOCFILES=buildsystem.pdf
- EXTRA_DIST=$(DOCFILES)
+ EXTRA_DIST= CMakeLists.txt $(DOCFILES)
EXTRAINSTALL=$(DOCFILES)
endif
diff --git a/doc/comm/CMakeLists.txt b/doc/comm/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..07daa544847e1f5bf1eca504758bef8e1eb3b7c4
--- /dev/null
+++ b/doc/comm/CMakeLists.txt
@@ -0,0 +1,11 @@
+add_executable(poosc08 "poosc08.cc")
+target_link_libraries(poosc08 "dunecommon")
+add_executable(poosc08_test "poosc08_test.cc")
+target_link_libraries(poosc08_test "dunecommon")
+add_executable(indexset "indexset.cc")
+target_link_libraries(indexset "dunecommon")
+add_dune_mpi_flags("poosc08;poosc08_test;indexset")
+dune_add_latex_document(communication.tex FATHER_TARGET doc
+ BIBFILES communication.bib DEFAULT_SAFEPDF INPUTS poosc08_test.cc
+ IMAGE_DIRS figures)
+create_doc_install(${CMAKE_CURRENT_BINARY_DIR}/communication.pdf ${CMAKE_INSTALL_DOCDIR}/comm communication_safepdf)
diff --git a/doc/doxygen/CMakeLists.txt b/doc/doxygen/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c4e01f1c3e1f9da69ea6fab790f3da1cd956fed2
--- /dev/null
+++ b/doc/doxygen/CMakeLists.txt
@@ -0,0 +1,3 @@
+# quickhack for creating the Doxyfile.in and Doxyfile
+add_doxygen_target()
+install(FILES Doxystyle DESTINATION ${CMAKE_INSTALL_DOCDIR}/doxygen)
diff --git a/doc/doxygen/Makefile.am b/doc/doxygen/Makefile.am
index da6c9745d2b4368cb63f56447ab636ae5987590f..2bf1067570e18db16242feb76d82a0f1c09e6370 100644
--- a/doc/doxygen/Makefile.am
+++ b/doc/doxygen/Makefile.am
@@ -2,7 +2,7 @@
doxydir = $(pkgdatadir)/doc/doxygen
-doxy_DATA = \
+dist_doxy_DATA = \
Doxystyle
# setting like in dune-web
@@ -12,7 +12,7 @@ PAGES =
# add some more stuff to install and tarball
DOCFILES = $(PAGES)
-EXTRA_DIST = $(PAGES) Doxystyle
+EXTRA_DIST = CMakeLists.txt $(PAGES) Doxylocal
include $(top_srcdir)/am/doxygen
include $(top_srcdir)/am/global-rules
diff --git a/dune-common-config.cmake.in b/dune-common-config.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..1344876e4f78cf49963c2abfedb72cb3f6f27c97
--- /dev/null
+++ b/dune-common-config.cmake.in
@@ -0,0 +1,19 @@
+if(NOT @DUNE_MOD_NAME@_FOUND)
+#import the target
+include("@CMAKE_BINARY_DIR@/@DUNE_MOD_NAME@-targets.cmake")
+
+#report other information
+set(@DUNE_MOD_NAME@_PREFIX "@CMAKE_SOURCE_DIR@")
+set(@DUNE_MOD_NAME@_INCLUDE_DIRS "@CMAKE_SOURCE_DIR@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS "@CMAKE_CXX_FLAGS@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_DEBUG "@CMAKE_CXX_FLAGS_DEBUG@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_MINSIZEREL "@CMAKE_CXX_FLAGS_MINSIZEREL@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELEASE "@CMAKE_CXX_FLAGS_RELEASE@")
+set(@DUNE_MOD_NAME@_CXX_FLAGS_RELWITHDEBINFO "@CMAKE_CXX_FLAGS_RELWITHDEBINFO@")
+set(@DUNE_MOD_NAME@_LIBRARIES "dunecommon")
+set(@DUNE_MOD_NAME@_SCRIPT_DIR "@CMAKE_SOURCE_DIR@/cmake/scripts")
+set(DOXYSTYLE_FILE "@CMAKE_SOURCE_DIR@/doc/doxygen/Doxystyle")
+set(@DUNE_MOD_NAME@_DEPENDS "@DUNE_DEPENDS@")
+set(@DUNE_MOD_NAME@_SUGGESTS "@DUNE_SUGGESTS@")
+set(@DUNE_MOD_NAME@_MODULE_PATH "@CMAKE_SOURCE_DIR@/cmake/modules")
+endif(NOT @DUNE_MOD_NAME@_FOUND)
\ No newline at end of file
diff --git a/dune-common-version.cmake.in b/dune-common-version.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..a1c2199d972b8943a646d4feb40d12e9e239b141
--- /dev/null
+++ b/dune-common-version.cmake.in
@@ -0,0 +1,8 @@
+set(PACKAGE_VERSION "@DUNE_MOD_VERSION@")
+
+if(NOT "${PACKAGE_FIND_VERSION}" VERSION_GREATER "@DUNE_MOD_VERSION@")
+ set (PACKAGE_VERSION_COMPATIBLE 1) # compatible with older
+ if ("${PACKAGE_FIND_VERSION}" VERSION_EQUAL "@DUNE_MOD_VERSION@")
+ set(PACKAGE_VERSION_EXACT 1) #exact match for this version
+ endif()
+endif()
diff --git a/dune/CMakeLists.txt b/dune/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b85be7f4a617bd64be563fd7e08e7a0467b2960e
--- /dev/null
+++ b/dune/CMakeLists.txt
@@ -0,0 +1 @@
+add_subdirectory("common")
diff --git a/dune/Makefile.am b/dune/Makefile.am
index d0b3a1009f33caa681e665e402b27c41ecf55103..1a1e5262878ddf5a857eee3ceee5c9b10cade26d 100644
--- a/dune/Makefile.am
+++ b/dune/Makefile.am
@@ -3,3 +3,5 @@
SUBDIRS = common
include $(top_srcdir)/am/global-rules
+
+EXTRA_DIST = CMakeLists.txt
diff --git a/dune/common/CMakeLists.txt b/dune/common/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..43fe8fc7bb947de70988c3dd100ca531283619c3
--- /dev/null
+++ b/dune/common/CMakeLists.txt
@@ -0,0 +1,99 @@
+add_subdirectory("parallel")
+add_subdirectory("test" EXCLUDE_FROM_ALL)
+
+#build the library dunecommon
+if(LAPACK_FOUND)
+ set(_additional_libs ${LAPACK_LIBRARIES})
+elseif(BLAS_FOUND)
+ set(_additional_libs ${BLAS_LIBRARIES})
+endif(LAPACK_FOUND)
+
+dune_add_library("dunecommon"
+ debugallocator.cc
+ dynmatrixev.cc
+ exceptions.cc
+ fmatrixev.cc
+ ios_state.cc
+ parametertree.cc
+ parametertreeparser.cc
+ path.cc
+ stdstreams.cc
+ ADD_LIBS "${_additional_libs}")
+
+#install headers
+install(FILES
+ alignment.hh
+ array.hh
+ arraylist.hh
+ bartonnackmanifcheck.hh
+ bigunsignedint.hh
+ binaryfunctions.hh
+ bitsetvector.hh
+ classname.hh
+ collectivecommunication.hh
+ debugallocator.hh
+ debugstream.hh
+ deprecated.hh
+ densematrix.hh
+ densevector.hh
+ diagonalmatrix.hh
+ documentation.hh
+ dotproduct.hh
+ dynmatrix.hh
+ dynmatrixev.hh
+ dynvector.hh
+ enumset.hh
+ exceptions.hh
+ fassign.hh
+ float_cmp.cc
+ float_cmp.hh
+ fmatrix.hh
+ fmatrixev.hh
+ forloop.hh
+ ftraits.hh
+ function.hh
+ fvector.hh
+ gcd.hh
+ genericiterator.hh
+ gmpfield.hh
+ hash.hh
+ indent.hh
+ interfaces.hh
+ ios_state.hh
+ iteratorfacades.hh
+ lcm.hh
+ lru.hh
+ mallocallocator.hh
+ math.hh
+ matvectraits.hh
+ misc.hh
+ mpicollectivecommunication.hh
+ mpiguard.hh
+ mpihelper.hh
+ mpitraits.hh
+ nullptr.hh
+ parametertree.hh
+ parametertreeparser.hh
+ path.hh
+ poolallocator.hh
+ power.hh
+ precision.hh
+ propertymap.hh
+ promotiontraits.hh
+ reservedvector.hh
+ shared_ptr.hh
+ singleton.hh
+ sllist.hh
+ static_assert.hh
+ stdstreams.hh
+ timer.hh
+ tuples.hh
+ tupleutility.hh
+ typetraits.hh
+ unused.hh
+ version.hh
+DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/common)
+
+# Install some test headers, because they get used by tests in other modules
+# We do this here as test will not be considered for make install
+install(FILES test/iteratortest.hh DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/common/test)
diff --git a/dune/common/Makefile.am b/dune/common/Makefile.am
index df7239be62183bcfcd606ce9d855d48c936aa887..51bdd376ef9587ef48332e7948fa48ac57337ff8 100644
--- a/dune/common/Makefile.am
+++ b/dune/common/Makefile.am
@@ -91,3 +91,5 @@ commoninclude_HEADERS = \
version.hh
include $(top_srcdir)/am/global-rules
+
+EXTRA_DIST = CMakeLists.txt
diff --git a/dune/common/parallel/CMakeLists.txt b/dune/common/parallel/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..298789bce5fd502d012a6d844dd46edec0182e2d
--- /dev/null
+++ b/dune/common/parallel/CMakeLists.txt
@@ -0,0 +1,19 @@
+add_subdirectory("test" EXCLUDE_FROM_ALL)
+
+#install headers
+install(FILES
+ collectivecommunication.hh
+ communicator.hh
+ indexset.hh
+ indicessyncer.hh
+ interface.hh
+ localindex.hh
+ mpicollectivecommunication.hh
+ mpiguard.hh
+ mpihelper.hh
+ mpitraits.hh
+ plocalindex.hh
+ remoteindices.hh
+ selection.hh
+ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/dune/common/parallel)
+
diff --git a/dune/common/parallel/Makefile.am b/dune/common/parallel/Makefile.am
index 96bec851a21b57bfc670f5c80badd84d238f0e6b..461560291b5d556e4acb99a94684891c5af2e49f 100644
--- a/dune/common/parallel/Makefile.am
+++ b/dune/common/parallel/Makefile.am
@@ -19,3 +19,5 @@ parallelinclude_HEADERS = \
selection.hh
include $(top_srcdir)/am/global-rules
+
+EXTRA_DIST = CMakeLists.txt
diff --git a/dune/common/parallel/test/CMakeLists.txt b/dune/common/parallel/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b6134ad913186bcfaeef7c56ed65f8f64566f93f
--- /dev/null
+++ b/dune/common/parallel/test/CMakeLists.txt
@@ -0,0 +1,27 @@
+set(MPITESTPROGS indicestest indexsettest syncertest selectiontest)
+
+add_directory_test_target(_test_target)
+# We do not want want to build the tests during make all,
+# but just build them on demand
+add_dependencies(${_test_target} ${MPITESTPROGS})
+
+add_executable("indexsettest" indexsettest.cc)
+target_link_libraries("indexsettest" "dunecommon" ${CMAKE_THREAD_LIBS_INIT} ${})
+
+include(DuneMPI)
+add_executable("indicestest" indicestest.cc)
+target_link_libraries("indicestest" "dunecommon")
+add_dune_mpi_flags(indicestest)
+
+add_executable("selectiontest" selectiontest.cc)
+target_link_libraries("selectiontest" "dunecommon")
+add_dune_mpi_flags(selectiontest)
+
+add_executable("syncertest" syncertest.cc)
+target_link_libraries("syncertest" "dunecommon")
+add_dune_mpi_flags(syncertest)
+
+add_test(indexsettest indexsettest)
+add_test(selectiontest selectiontest)
+add_test(indicestest indicestest)
+add_test(syncertest syncertest)
diff --git a/dune/common/parallel/test/Makefile.am b/dune/common/parallel/test/Makefile.am
index f864a8b38bad2ba2f4eddb8d7ec9e367a806292b..23b658707cb697e11993a7fbfb1d0cdc0f7d3756 100644
--- a/dune/common/parallel/test/Makefile.am
+++ b/dune/common/parallel/test/Makefile.am
@@ -45,3 +45,5 @@ syncertest_LDADD = \
$(LDADD)
include $(top_srcdir)/am/global-rules
+
+EXTRA_DIST = CMakeLists.txt
diff --git a/dune/common/test/.gitignore b/dune/common/test/.gitignore
index f47a8adb50cff64de57b4d3cc1df49fa1918d8f6..8ebde22bd0128505ce45f356a7fe2e3238b5ef43 100644
--- a/dune/common/test/.gitignore
+++ b/dune/common/test/.gitignore
@@ -70,3 +70,4 @@ testdebugallocator_fail3
testdebugallocator_fail4
testdebugallocator_fail5
eigenvaluestest
+
diff --git a/dune/common/test/CMakeLists.txt b/dune/common/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..831b2f80e1f33366f90f7dbd8a7d865c199a5dbb
--- /dev/null
+++ b/dune/common/test/CMakeLists.txt
@@ -0,0 +1,252 @@
+# tests that should build and run successfully
+set(TESTS
+ arraylisttest
+ arraytest
+ bigunsignedinttest
+ bitsetvectortest
+ check_fvector_size
+ conversiontest
+ diagonalmatrixtest
+ dynmatrixtest
+ dynvectortest
+ eigenvaluestest
+ enumsettest
+ fassigntest
+ fmatrixtest
+ fvectortest
+ gcdlcmtest
+ iteratorfacadetest
+ iteratorfacadetest2
+ lrutest
+ mpicollectivecommunication
+ mpiguardtest
+ mpihelpertest
+ mpihelpertest2
+ nullptr_test
+ pathtest
+ parametertreetest
+ poolallocatortest
+ shared_ptrtest_config
+ shared_ptrtest_dune
+ singletontest
+ static_assert_test
+ streamtest
+ testfassign1
+ testfassign2
+ testfassign3
+ testfassign4
+ testfconstruct
+ testfloatcmp
+ tuplestest_config
+ tuplestest_dune
+ tuplestest_tr1
+ tupleutilitytest
+ utilitytest)
+
+#test that should build but fail to run successfully
+set(FAILTESTS
+ testdebugallocator_fail1
+ testdebugallocator_fail2
+ testdebugallocator_fail3
+ testdebugallocator_fail4
+ testdebugallocator_fail5
+ testfassign_fail1
+ testfassign_fail2
+ testfassign_fail3
+ testfassign_fail4
+ testfassign_fail5
+ testfassign_fail6)
+
+set(COMPILEFAILTESTS
+ check_fvector_size_fail1
+ check_fvector_size_fail2
+ genericiterator_compile_fail
+ nullptr-test-fail
+ static_assert_test_fail
+ testfconstruct_fail1
+ testfconstruct_fail2)
+
+set(TESTPROGS ${TESTS} ${FAILTESTS})
+
+# We do not want want to build the tests during make all,
+# but just build them on demand
+add_directory_test_target(_test_target)
+add_dependencies(${_test_target} ${TESTPROGS})
+
+# Add the executables needed for the tests
+add_executable("arraylisttest" arraylisttest.cc)
+add_executable("arraytest" arraytest.cc)
+
+add_executable("bigunsignedinttest" bigunsignedinttest.cc)
+target_link_libraries("bigunsignedinttest" "dunecommon")
+add_dune_boost_flags("bigunsignedinttest")
+
+add_executable("bitsetvectortest" bitsetvectortest.cc)
+add_executable("check_fvector_size" check_fvector_size.cc)
+add_executable("check_fvector_size_fail1" EXCLUDE_FROM_ALL check_fvector_size_fail.cc)
+set_target_properties(check_fvector_size_fail1 PROPERTIES COMPILE_FLAGS "-DDIM=1")
+add_executable("check_fvector_size_fail2" EXCLUDE_FROM_ALL check_fvector_size_fail.cc)
+set_target_properties(check_fvector_size_fail2 PROPERTIES COMPILE_FLAGS "-DDIM=3")
+add_executable("conversiontest" conversiontest.cc)
+
+add_executable("dynmatrixtest" dynmatrixtest.cc)
+target_link_libraries("dynmatrixtest" "dunecommon")
+
+add_executable("dynvectortest" dynvectortest.cc)
+
+add_executable("eigenvaluestest" eigenvaluestest.cc)
+target_link_libraries(eigenvaluestest dunecommon)
+if(LAPACK_FOUND)
+ target_link_libraries(eigenvaluestest ${LAPACK_LIBRARIES})
+endif(LAPACK_FOUND)
+
+add_executable("diagonalmatrixtest" diagonalmatrixtest.cc)
+target_link_libraries("diagonalmatrixtest" "dunecommon")
+
+add_executable("enumsettest" enumsettest.cc)
+
+add_executable("fassigntest" fassigntest.cc)
+target_link_libraries("fassigntest" "dunecommon")
+
+
+add_executable("testfloatcmp" testfloatcmp.cc)
+target_link_libraries("testfloatcmp" "dunecommon")
+
+# we provide an empty fortran file to force the linker
+# to link to the fortran libraries (needed for static linking)
+add_executable("fmatrixtest" fmatrixtest.cc dummy.f)
+target_link_libraries("fmatrixtest" "dunecommon")
+add_executable("fvectortest" fvectortest.cc)
+add_executable("gcdlcmtest" gcdlcmtest.cc)
+add_executable("genericiterator_compile_fail" EXCLUDE_FROM_ALL genericiterator_compile_fail.cc)
+add_executable("iteratorfacadetest2" iteratorfacadetest2.cc)
+add_executable("iteratorfacadetest" iteratorfacadetest.cc)
+add_executable("lrutest" lrutest.cc)
+add_executable("mpiguardtest" mpiguardtest.cc)
+target_link_libraries("mpiguardtest" "dunecommon")
+add_DUNE_MPI_flags(mpiguardtest)
+
+add_executable("mpicollectivecommunication" mpicollectivecommunication.cc)
+target_link_libraries(mpicollectivecommunication "dunecommon")
+add_DUNE_MPI_flags(mpicollectivecommunication)
+
+add_executable("mpihelpertest" mpihelpertest.cc)
+target_link_libraries(mpihelpertest "dunecommon")
+add_DUNE_MPI_flags(mpihelpertest)
+
+add_executable("mpihelpertest2" mpihelpertest.cc)
+target_link_libraries(mpihelpertest2 "dunecommon")
+add_DUNE_MPI_flags(mpihelpertest2)
+set_target_properties(mpihelpertest2 PROPERTIES COMPILE_FLAGS "-DMPIHELPER_PREINITIALIZE")
+
+add_executable("nullptr_test" nullptr-test.cc nullptr-test2.cc)
+target_link_libraries(nullptr_test "dunecommon")
+add_executable("nullptr_test_fail" EXCLUDE_FROM_ALL nullptr-test.cc)
+target_link_libraries(nullptr_test_fail "dunecommon")
+set_target_properties(nullptr_test_fail PROPERTIES COMPILE_FLAGS "-DFAIL")
+
+add_executable("parametertreetest" parametertreetest.cc)
+target_link_libraries("parametertreetest" "dunecommon")
+
+add_executable("pathtest" pathtest.cc)
+target_link_libraries("pathtest" "dunecommon")
+
+add_executable("poolallocatortest" poolallocatortest.cc)
+add_executable("shared_ptrtest_config" shared_ptrtest.cc)
+add_executable("shared_ptrtest_dune" shared_ptrtest.cc)
+set_target_properties(shared_ptrtest_dune PROPERTIES COMPILE_FLAGS "-DDISABLE_CONFIGURED_SHARED_PTR")
+add_executable("singletontest" singletontest.cc)
+add_executable("sllisttest" EXCLUDE_FROM_ALL sllisttest.cc)
+add_executable("static_assert_test" EXCLUDE_FROM_ALL static_assert_test.cc)
+add_executable("static_assert_test_fail" EXCLUDE_FROM_ALL static_assert_test_fail.cc)
+
+add_executable("streamtest" streamtest.cc)
+target_link_libraries("streamtest" "dunecommon")
+
+add_executable("testfassign1" testfassign.cc testfassign2.cc)
+set_target_properties(testfassign1 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=3 -D_VALUES=\"1,2,3\"")
+target_link_libraries(testfassign1 "dunecommon")
+add_executable("testfassign2" testfassign.cc)
+set_target_properties(testfassign2 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=3 -D_VALUES=\"1,zero\"")
+target_link_libraries(testfassign2 "dunecommon")
+add_executable("testfassign3" testfassign.cc)
+set_target_properties(testfassign3 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=3 -D_VALUES=\"zero\"")
+target_link_libraries(testfassign3 "dunecommon")
+add_executable("testfassign4" testfassign.cc)
+set_target_properties(testfassign4 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=2 -D_DUNE_TEST_M=3 -D_VALUES=\"1, zero, nextRow, 2, 3, 4\"")
+target_link_libraries(testfassign4 "dunecommon")
+
+add_executable("testdebugallocator" testdebugallocator.cc)
+target_link_libraries(testdebugallocator dunecommon)
+add_executable("testdebugallocator_fail1" testdebugallocator.cc)
+target_link_libraries(testdebugallocator_fail1 dunecommon)
+set_target_properties(testdebugallocator_fail1 PROPERTIES COMPILE_DEFINITIONS "FAILURE1")
+add_executable("testdebugallocator_fail2" testdebugallocator.cc)
+target_link_libraries(testdebugallocator_fail2 dunecommon)
+set_target_properties(testdebugallocator_fail2 PROPERTIES COMPILE_DEFINITIONS "FAILURE2")
+add_executable("testdebugallocator_fail3" testdebugallocator.cc)
+target_link_libraries(testdebugallocator_fail3 dunecommon)
+set_target_properties(testdebugallocator_fail3 PROPERTIES COMPILE_DEFINITIONS "FAILURE3")
+add_executable("testdebugallocator_fail4" testdebugallocator.cc)
+target_link_libraries(testdebugallocator_fail4 dunecommon)
+set_target_properties(testdebugallocator_fail4 PROPERTIES COMPILE_DEFINITIONS "FAILURE4;DEBUG_ALLOCATOR_KEEP=1")
+add_executable("testdebugallocator_fail5" testdebugallocator.cc)
+target_link_libraries(testdebugallocator_fail5 dunecommon)
+set_target_properties(testdebugallocator_fail5 PROPERTIES COMPILE_DEFINITIONS "FAILURE5")
+
+add_executable("testfassign_fail1" testfassign.cc)
+set_target_properties(testfassign_fail1 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=3 -D_VALUES=\"1,2\"")
+target_link_libraries(testfassign_fail1 "dunecommon")
+add_executable("testfassign_fail2" testfassign.cc)
+set_target_properties(testfassign_fail2 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=3 -D_VALUES=\"1,2,3,4\"")
+target_link_libraries(testfassign_fail2 "dunecommon")
+add_executable("testfassign_fail3" testfassign.cc)
+set_target_properties(testfassign_fail3 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=2 -D_DUNE_TEST_M=2 -D_VALUES=\"1, nextRow, 2, 3\"")
+target_link_libraries(testfassign_fail3 "dunecommon")
+add_executable("testfassign_fail4" testfassign.cc)
+set_target_properties(testfassign_fail4 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=2 -D_DUNE_TEST_M=2 -D_VALUES=\"1, 2, 3, nextRow, 2, 3\"")
+target_link_libraries(testfassign_fail4 "dunecommon")
+add_executable("testfassign_fail5" testfassign.cc)
+set_target_properties(testfassign_fail5 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=2 -D_DUNE_TEST_M=2 -D_VALUES=\"1, 2\"")
+target_link_libraries(testfassign_fail5 "dunecommon")
+add_executable("testfassign_fail6" testfassign.cc)
+set_target_properties(testfassign_fail6 PROPERTIES COMPILE_FLAGS "-D_DUNE_TEST_N=2 -D_DUNE_TEST_M=2 -D_VALUES=\"1, 2, nextRow, 2, 3, nextRow, 4, 5\"")
+target_link_libraries(testfassign_fail6 "dunecommon")
+
+add_executable("testfconstruct" EXCLUDE_FROM_ALL testfconstruct.cc)
+set_target_properties(testfconstruct PROPERTIES COMPILE_FLAGS "-DFVSIZE=3")
+target_link_libraries(testfconstruct "dunecommon")
+add_executable("testfconstruct_fail1" EXCLUDE_FROM_ALL testfconstruct.cc)
+set_target_properties(testfconstruct_fail1 PROPERTIES COMPILE_FLAGS "-DFVSIZE=2")
+target_link_libraries(testfconstruct_fail1 "dunecommon")
+add_executable("testfconstruct_fail2" EXCLUDE_FROM_ALL testfconstruct.cc)
+set_target_properties(testfconstruct_fail2 PROPERTIES COMPILE_FLAGS "-DFVSIZE=5")
+target_link_libraries(testfconstruct_fail2 "dunecommon")
+add_executable("tuplestest_config" tuplestest.cc)
+add_executable("tuplestest_dune" tuplestest.cc)
+set_target_properties(tuplestest_dune PROPERTIES COMPILE_FLAGS "-DDISABLE_TR1_TUPLE -DDISABLE_STD_TUPLE")
+add_executable("tuplestest_tr1" tuplestest.cc)
+set_target_properties(tuplestest_tr1 PROPERTIES COMPILE_FLAGS "-DDISABLE_STD_TUPLE")
+add_executable("tupleutilitytest" tupleutilitytest.cc)
+add_executable("utilitytest" utilitytest.cc)
+
+# Add the tests to be executed
+foreach(_TEST ${TESTPROGS})
+ add_test(${_TEST} ${_TEST})
+endforeach(_TEST)
+
+#Set properties for failing tests
+set_tests_properties(
+ ${FAILTESTS}
+ PROPERTIES WILL_FAIL true)
+
+# compile tests that should fail
+foreach(_TEST ${COMPILEFAILTESTS})
+ add_test(NAME ${_TEST}
+ COMMAND ${CMAKE_COMMAND} --build . --target ${_TEST} --config $<CONFIGURATION>)
+endforeach(_TEST)
+set_tests_properties(
+ ${COMPILEFAILTESTS}
+ PROPERTIES WILL_FAIL true)
+
+
diff --git a/dune/common/test/Makefile.am b/dune/common/test/Makefile.am
index 2b622e429de799eb1111811f3ab7cc41abd91a11..17d87196d3ac10cc30e10820509fef69084f1385 100644
--- a/dune/common/test/Makefile.am
+++ b/dune/common/test/Makefile.am
@@ -275,3 +275,5 @@ testfloatcmp_SOURCES = testfloatcmp.cc
genericiterator_compile_fail_SOURCES = genericiterator_compile_fail.cc
include $(top_srcdir)/am/global-rules
+
+EXTRA_DIST = CMakeLists.txt dummy.f
diff --git a/dune/common/test/dummy.f b/dune/common/test/dummy.f
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ca5b5f7ecd973bebcfe4f6c58011f34017f742f5
--- /dev/null
+++ b/lib/CMakeLists.txt
@@ -0,0 +1 @@
+install(FILES dunemodules.lib DESTINATION ${CMAKE_INSTALL_BINDIR}/../lib)
diff --git a/lib/Makefile.am b/lib/Makefile.am
index 0d16e20ff4a6b1032e3fbb40ee04c5624c0d5aae..2f42b259de161806d24474d23754f194f2c7cd79 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -1,7 +1,7 @@
# $Id: $
dunemodulelibdir=$(libdir)
-EXTRA_DIST = dunemodules.lib
+EXTRA_DIST = CMakeLists.txt dunemodules.lib
dunemodulelib_DATA = dunemodules.lib
#the dune-common library
diff --git a/m4/CMakeLists.txt b/m4/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5a842931e66674c4c53c92a75f81b363982c02fb
--- /dev/null
+++ b/m4/CMakeLists.txt
@@ -0,0 +1,46 @@
+install(PROGRAMS
+ acx_blas.m4
+ acx_lapack.m4
+ acx_mpi.m4
+ acx_pthread.m4
+ ax_boost_base.m4
+ ax_check_gl.m4
+ ax_lang_compiler_ms.m4
+ boost_fusion.m4
+ cxx0x_compiler.m4
+ cxx0x_rvaluereference.m4
+ cxx0x_nullptr.m4
+ cxx0x_static_assert.m4
+ cxx0x_variadic.m4
+ cxx0x_variadic_constructor_sfinae.m4
+ dune.m4
+ dune_all.m4
+ dune_autobuild.m4
+ dune_boost_base.m4
+ dune_check_lib.m4
+ dune_common.m4
+ dune_compiler.m4
+ dune_fortran.m4
+ dune_deprecated.m4
+ dune_deprecated_cppflags.m4
+ dune_docu.m4
+ dune_linkcxx.m4
+ dune_mpi.m4
+ dune_streams.m4
+ dune_tr1_headers.m4
+ dune_unused.m4
+ fortran_overwrite.m4
+ gmp.m4
+ hdf5.m4
+ immdx_lib_metis.m4
+ inkscape.m4
+ libtoolcompat.m4
+ make_shared.m4
+ mprotect.m4
+ mpi-config.m4
+ opengl.m4
+ parmetis.m4
+ shared_ptr.m4
+ xdr.m4
+ DESTINATION share/aclocal
+)
diff --git a/m4/Makefile.am b/m4/Makefile.am
index 59cf4dbeac593c1aa2fe0546d6cb1e34743bbdb3..68a0b3f51e1ecc4bfaff302f2f02901b15854b47 100644
--- a/m4/Makefile.am
+++ b/m4/Makefile.am
@@ -50,6 +50,6 @@ ALLM4S = \
aclocaldir = $(datadir)/aclocal
aclocal_DATA = $(ALLM4S)
-EXTRA_DIST = $(ALLM4S)
+EXTRA_DIST = CMakeLists.txt $(ALLM4S)
include $(top_srcdir)/am/global-rules
diff --git a/m4/dune.m4 b/m4/dune.m4
index addf57bedc8d4aa3e92ee7d3ecdcd610f92b0c2e..1215df0ab15f7374251f8201621888bb5c84d9f2 100644
--- a/m4/dune.m4
+++ b/m4/dune.m4
@@ -368,14 +368,22 @@ AC_DEFUN([DUNE_CHECK_MODULES],[
_dune_cm_LIBS="-L$_DUNE_MODULE[]_LIBDIR -l[]_dune_lib"
],[
_DUNE_MODULE[]_SRCDIR=$_DUNE_MODULE[]_ROOT
- # extract src and build path from Makefile, if found
- AS_IF([test -f $_DUNE_MODULE[]_ROOT/Makefile],[
+ echo "testing $_DUNE_MODULE[]_ROOT/CMakeCache.txt"
+ # extract src and build path from Makefile or CMakeCache.txt, if found
+ AS_IF([test -f $_DUNE_MODULE[]_ROOT/CMakeCache.txt],[
+ _DUNE_MODULE[]_SRCDIR="`sed -ne '/^[]_dune_name[]_SOURCE_DIR:STATIC=/{s/^[]_dune_name[]_SOURCE_DIR:STATIC=//; p;}' $_DUNE_MODULE[]_ROOT/CMakeCache.txt`"
+ echo srcdir=$_DUNE_MODULE[]_SRCDIR
+ ],[test -f $_DUNE_MODULE[]_ROOT/Makefile],[
_DUNE_MODULE[]_SRCDIR="`sed -ne '/^abs_top_srcdir = /{s/^abs_top_srcdir = //; p;}' $_DUNE_MODULE[]_ROOT/Makefile`"
])
_dune_cm_CPPFLAGS="-I$_DUNE_MODULE[]_SRCDIR"
_DUNE_MODULE[]_VERSION="`grep Version $_DUNE_MODULE[]_SRCDIR/dune.module | sed -e 's/^Version: *//'`" 2>/dev/null
- # local modules is linked directly via the .la file
- _dune_cm_LIBS="$_DUNE_MODULE[]_LIBDIR[]/lib[]_dune_lib[].la"
+ AS_IF([test -f "$_DUNE_MODULE[]_LIBDIR[]/lib[]_dune_lib[].la"], [
+ # local modules is linked directly via the .la file
+ _dune_cm_LIBS="$_DUNE_MODULE[]_LIBDIR[]/lib[]_dune_lib[].la"],[
+ # No libtool file. This indicates a module build with CMake. Fall back to direct linking
+ _dune_cm_LIBS="-L$_DUNE_MODULE[]_LIBDIR[]/ -l[]_dune_lib[]"
+ ])
])
# set expanded module path
with_[]_dune_module="$_DUNE_MODULE[]_ROOT"