CMakeLists.txt

   1 #-------------------------------------------------------------------------------
   2 #               ______                _     ____          __  __
   3 #              |  ____|             _| |_  / __ \   /\   |  \/  |
   4 #              | |__ _ __ ___  ___ /     \| |  | | /  \  | \  / |
   5 #              |  __| '__/ _ \/ _ ( (| |) ) |  | |/ /\ \ | |\/| |
   6 #              | |  | | |  __/  __/\_   _/| |__| / ____ \| |  | |
   7 #              |_|  |_|  \___|\___|  |_|   \____/_/    \_\_|  |_|
   8 #
   9 #                   FreeFOAM: The Cross-Platform CFD Toolkit
  10 #
  11 # Copyright (C) 2008-2010 Michael Wild <themiwi@users.sf.net>
  12 #                         Gerber van der Graaf <gerber_graaf@users.sf.net>
  13 #-------------------------------------------------------------------------------
  14 # License
  15 #   This file is part of FreeFOAM.
  16 #
  17 #   FreeFOAM is free software; you can redistribute it and/or modify it
  18 #   under the terms of the GNU General Public License as published by the
  19 #   Free Software Foundation; either version 2 of the License, or (at your
  20 #   option) any later version.
  21 #
  22 #   FreeFOAM is distributed in the hope that it will be useful, but WITHOUT
  23 #   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  24 #   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25 #   for more details.
  26 #
  27 #   You should have received a copy of the GNU General Public License
  28 #   along with FreeFOAM; if not, write to the Free Software Foundation,
  29 #   Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  30 #-------------------------------------------------------------------------------
  31
  32 cmake_minimum_required(VERSION 2.8.0 FATAL_ERROR)
  33
  34 project(FreeFOAM)
  35
  36 string(TOLOWER "${PROJECT_NAME}" LOWER_PROJECT_NAME)
  37
  38 # version information
  39 set(FOAM_VERSION_MAJOR 0)
  40 set(FOAM_VERSION_MINOR 1)
  41 set(FOAM_VERSION_PATCH 0)
  42 set(FOAM_VERSION ${FOAM_VERSION_MAJOR}.${FOAM_VERSION_MINOR})
  43 set(FOAM_VERSION_FULL ${FOAM_VERSION}.${FOAM_VERSION_PATCH})
  44
  45 # set up custom cmake module path
  46 set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/CMake/Modules)
  47
  48 # utilities
  49 set(FOAM_CREATE_INCLUDE_WRAPPERS TRUE)
  50 set(FOAM_HAS_FLEX_SOURCES TRUE)
  51 set(FOAM_ENABLE_DOC_INDEX TRUE)
  52 set(FOAM_EXPORT_NAMESPACE FOAM_)
  53 include(${CMAKE_SOURCE_DIR}/CMake/FOAMUtilities.cmake)
  54 include(${CMAKE_SOURCE_DIR}/CMake/FOAMThirdPartyUtilities.cmake)
  55 include(${CMAKE_SOURCE_DIR}/CMake/FOAMInternal.cmake)
  56 include(CTest)
  57
  58 # determine computer system
  59 include(${CMAKE_SOURCE_DIR}/CMake/FOAMDetermineArch.cmake)
  60
  61 # select precision
  62 foam_option(FOAM_DOUBLE_PRECISION "Double precision"
  63   "Compile ${PROJECT_NAME} with double precision floating point arithmetics." ON)
  64 if(FOAM_DOUBLE_PRECISION)
  65   set(FOAM_PRECISION DP)
  66 else()
  67   set(FOAM_PRECISION SP)
  68 endif()
  69
  70 # select whether we want to build framewors on Mac OS X
  71 if(APPLE)
  72   foam_option(FOAM_BUILD_FRAMEWORKS "Build frameworks"
  73     "Build frameworks on Mac OS X" OFF)
  74 else()
  75   set(FOAM_BUILD_FRAMEWORKS OFF)
  76 endif()
  77
  78 # find python interpreter
  79 find_package(PythonInterp REQUIRED)
  80
  81 # make sure we got Python version 2.6 or newer
  82 foam_dependent_variables(PYTHON_EXECUTABLE PYTHON_VERSION)
  83 if(NOT PYTHON_VERSION)
  84   execute_process(
  85     COMMAND ${PYTHON_EXECUTABLE} -c
  86     "import sys; sys.stdout.write('%s.%s.%s\\n'%sys.version_info[0:3])"
  87     RESULT_VARIABLE _py_version_result
  88     OUTPUT_VARIABLE _py_version_output
  89     ERROR_VARIABLE _py_version_output
  90     OUTPUT_STRIP_TRAILING_WHITESPACE
  91     )
  92   if(NOT _py_version_result)
  93     string(REGEX MATCH "([0-9]+\\.)+[0-9]+" PYTHON_VERSION "${_py_version_output}")
  94     message(STATUS "Python version ${PYTHON_VERSION} found")
  95     if(${PYTHON_VERSION} VERSION_LESS 2.4.0)
  96       message(SEND_ERROR "Python version 2.4 or newer required")
  97     endif()
  98   else()
  99     set(PYTHON_VERSION PYTHON_VERSION-NOTFOUND)
 100     message(SEND_ERROR "Failed to determine the python version: ${_py_version_output}")
 101   endif()
 102   set(PYTHON_VERSION ${PYTHON_VERSION} CACHE INTERNAL "The Python version")
 103 endif()
 104 string(REGEX REPLACE "\\.[0-9]+$" "" PYTHON_SHORT_VERSION ${PYTHON_VERSION})
 105
 106 # find the installed ParaView executable
 107 find_program(
 108   FOAM_PARAVIEW3_APP NAMES "ParaView 3.8.1" "ParaView 3.8.0" ParaView paraview
 109   DOC "Path to the ParaView 3.8 (or newer) application"
 110   )
 111 foam_dependent_variables(FOAM_PARAVIEW3_APP FOAM_PARAVIEW3_VERSION)
 112 if(FOAM_PARAVIEW3_APP)
 113   if(NOT FOAM_PARAVIEW3_VERSION)
 114     execute_process(COMMAND ${FOAM_PARAVIEW3_APP} --version
 115       OUTPUT_VARIABLE _pv_version_output
 116       ERROR_VARIABLE _pv_version_output
 117       OUTPUT_STRIP_TRAILING_WHITESPACE
 118       )
 119     if(_pv_version_output MATCHES "ParaView(([0-9]+\\.)+[0-9]+)")
 120       set(FOAM_PARAVIEW3_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL
 121         "The ParaView version")
 122       message(STATUS
 123         "ParaView ${FOAM_PARAVIEW3_VERSION} found: ${FOAM_PARAVIEW3_APP}")
 124     else()
 125       message(SEND_ERROR
 126         "Failed to determine the ParaView version: ${_pv_version_output}")
 127     endif()
 128   endif()
 129   if(${FOAM_PARAVIEW3_VERSION} VERSION_LESS 3.8)
 130     message(WARNING
 131       "ParaView versions older than 3.8 might not be able\n"
 132       "to read ${PROJECT_NAME} cases.")
 133   endif()
 134 else()
 135   message(WARNING
 136     "Failed to find the ParaView application")
 137   set(FOAM_PARAVIEW3_APP)
 138 endif()
 139
 140 # we want shared libraries
 141 set(BUILD_SHARED_LIBS SHARED)
 142
 143 # installation directories
 144 foam_installation_path(FOAM_INSTALL_BIN_PATH bin "Executables"
 145   "Executables installation path")
 146 if(APPLE AND FOAM_BUILD_FRAMEWORKS)
 147   foam_installation_path(FOAM_INSTALL_FRAMEWORK_PATH /Library/Frameworks
 148     "Frameworks" "Framework installation path")
 149 endif()
 150 foam_installation_path(FOAM_INSTALL_LIBRARY_PATH
 151   lib/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL}
 152   "Libraries" "Library installation path")
 153 foam_installation_path(FOAM_INSTALL_LIBEXEC_PATH
 154   libexec/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Private executables"
 155   "Installation path for executables not on PATH.")
 156 foam_installation_path(FOAM_INSTALL_HEADER_PATH
 157   include/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL}
 158   "Headers" "Header installation path (not for frameworks)")
 159 foam_installation_path(FOAM_INSTALL_CONFIG_PATH
 160   etc/${CMAKE_PROJECT_NAME}/${FOAM_VERSION_FULL} "Config files"
 161   "Configuration files installation path")
 162 foam_installation_path(FOAM_INSTALL_DATA_PATH
 163   share/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Data files"
 164   "Data files installation path")
 165 foam_installation_path(FOAM_INSTALL_DOC_PATH
 166   share/doc/${CMAKE_PROJECT_NAME}-${FOAM_VERSION_FULL} "Documentation"
 167   "Documentation files installation path")
 168 foam_installation_path(FOAM_INSTALL_MAN_PATH share/man "Man pages"
 169   "Man-pages installation path")
 170 foam_installation_path(FOAM_INSTALL_TUTORIALS_PATH
 171   "${FOAM_INSTALL_DOC_PATH_ORIG}" "Tutorials" "Tutorials installation path")
 172 foam_installation_path(FOAM_INSTALL_CMAKE_PATH
 173   "${FOAM_INSTALL_DATA_PATH_ORIG}/CMake"
 174   "CMake files" "CMake configuration files installation path")
 175 foam_installation_path(FOAM_INSTALL_USERDFOAM_PATH
 176   "${FOAM_INSTALL_LIBRARY_PATH_ORIG}/plugins/ensightReader"
 177   "Ensight plugin" "Ensight OpenFOAM-reader plugin installation path")
 178 foam_installation_path(FOAM_INSTALL_PYTHON_PATH
 179   "lib/python${PYTHON_SHORT_VERSION}/site-packages"
 180   "Python modules" "Python modules installation base path")
 181
 182 set(FOAM_INSTALL_RUNTIME_PATH "${FOAM_INSTALL_LIBEXEC_PATH}")
 183
 184 # determine the INSTALL_NAME_DIR of potential frameworks
 185 if(APPLE AND FOAM_BUILD_FRAMEWORKS)
 186   set(FOAM_FRAMEWORK_INSTALL_NAME_DIR "${FOAM_INSTALL_FRAMEWORK_PATH}")
 187 else()
 188   set(FOAM_FRAMEWORK_INSTALL_NAME_DIR "${FOAM_INSTALL_LIBRARY_PATH}")
 189 endif()
 190
 191 # select html documentation browser (try a few well known ones for default)
 192 # have to loop, because find_program(HTML_DOC_BROWSER NAMES ...) garbles things up
 193 foreach(browser open gnome-open kde-open x-www-browser www-browser
 194     firefox epiphany konqueror w3m lynx launch open)
 195   find_program(HTML_DOC_BROWSER ${browser}
 196     DOC "Program to open an HTML file")
 197   if(HTML_DOC_BROWSER)
 198     break()
 199   endif()
 200 endforeach()
 201 if(NOT HTML_DOC_BROWSER)
 202   message(STATUS
 203     "Failed to find a program to open HTML pages with (a.k.a a browser).\n"
 204     "Point HTML_DOC_BROWSER to a suitable program.")
 205   set(HTML_DOC_BROWSER "ECHO" CACHE STRING
 206     "Command to open an HTML file (ECHO will print it to STDOUT)" FORCE)
 207 endif()
 208 set(FOAM_HTML_DOC_BROWSER_COMMAND
 209   "\${HTML_DOC_BROWSER} %f" CACHE STRING "Command to open an HTML file")
 210 string(CONFIGURE "${FOAM_HTML_DOC_BROWSER_COMMAND}"
 211   FOAM_HTML_DOC_BROWSER_COMMAND ESCAPE_QUOTES)
 212 mark_as_advanced(HTML_DOC_BROWSER FOAM_HTML_DOC_BROWSER_COMMAND)
 213
 214 # Executable-prefix
 215 string(TOLOWER "${PROJECT_NAME}-" _FOAM_DEFAULT_EXE_PREFIX)
 216 set(FOAM_EXE_PREFIX "${_FOAM_DEFAULT_EXE_PREFIX}"
 217   CACHE STRING "Prefix for application output-names")
 218 mark_as_advanced(FOAM_EXE_PREFIX)
 219 string(TOUPPER "${FOAM_EXE_PREFIX}" FOAM_UPPER_EXE_PREFIX)
 220
 221 # ask user whether she wants to build Doxygen docs
 222 foam_option(FOAM_ENABLE_DOXYGEN_DOCS "Doxygen API documentation"
 223   "Build the Doxygen API documentation" OFF)
 224 # if user wants doxygen docs, find Doxygen and set up some options
 225 if(FOAM_ENABLE_DOXYGEN_DOCS)
 226   find_package(Doxygen REQUIRED)
 227   execute_process(COMMAND ${DOXYGEN_EXECUTABLE} --version
 228     RESULT_VARIABLE DOXYGEN_VERSION_RESULT
 229     OUTPUT_VARIABLE DOXYGEN_VERSION_OUTPUT
 230     OUTPUT_STRIP_TRAILING_WHITESPACE)
 231   if(DOXYGEN_VERSION_RESULT)
 232     message(SEND_ERROR "Failed to determine doxygen version")
 233   endif()
 234   if(${DOXYGEN_VERSION_OUTPUT} VERSION_GREATER 1.6.3 AND
 235       ${DOXYGEN_VERSION_OUTPUT} VERSION_LESS 1.7.2-20101106)
 236     message(WARNING
 237       "Found Doxygen version ${DOXYGEN_VERSION_OUTPUT}. "
 238       "Versions newer than 1.6.3 and older than 1.7.2-20101106 "
 239       "usually crash when processing the ${PROJECT_NAME} documentation.")
 240   endif()
 241   foam_option(FOAM_DOXYDOCS_FOR_SF "Doxygen for SourceForge"
 242     "Build the Doxygen docs for deployment on SourceForge" OFF)
 243   # ask user whether she prefers local or www docs
 244   foam_option(FOAM_USE_LOCAL_DOXYGEN_DOCS "Use local API docs"
 245     "Use the local Doxygen documentation instead of the one on http://freefoam.sf.net/doc/Doxygen/html" OFF)
 246 endif()
 247
 248 # ask user whether she wants to build the man pages
 249 foam_option(FOAM_ENABLE_MANPAGE_HELP "Build manpage help"
 250   "Build the manpages (requires asciidoc)" OFF)
 251 # ask user whether she wants to build the xhtml man pages
 252 foam_option(FOAM_ENABLE_XHTML_HELP "Build xhtml help"
 253   "Build the xhtml help pages (requires asciidoc)" OFF)
 254
 255 if(BUILD_TESTING)
 256   # ask user whether whe wants full tutorial tests
 257   foam_option(FOAM_ENABLE_FULL_TUTORIAL_TESTS
 258     "Full tutorial tests"
 259     "Run the complete tutorial tests (not just a single time step)" OFF)
 260 endif()
 261
 262 option(FOAM_ENABLE_CPACK "Enable CPACK packaging support" OFF)
 263
 264 # assemble the list of enabled manpage formats
 265 set(FOAM_MANPAGE_FORMATS)
 266 if(FOAM_ENABLE_MANPAGE_HELP)
 267   list(APPEND FOAM_MANPAGE_FORMATS manpage)
 268 endif()
 269 if(FOAM_ENABLE_XHTML_HELP)
 270   list(APPEND FOAM_MANPAGE_FORMATS xhtml)
 271 endif()
 272
 273 if(FOAM_MANPAGE_FORMATS OR FOAM_ENABLE_CPACK)
 274   # find AsciiDoc
 275   find_program(ASCIIDOC_EXECUTABLE NAMES asciidoc.py asciidoc)
 276   get_filename_component(asciidoc_path "${ASCIIDOC_EXECUTABLE}" PATH)
 277   find_program(A2X_EXECUTABLE NAMES a2x.py a2x HINTS "${asciidoc_path}")
 278   if(NOT ASCIIDOC_EXECUTABLE OR NOT A2X_EXECUTABLE)
 279     message(SEND_ERROR "AsciiDoc is required to create man and html help")
 280   endif()
 281 endif()
 282
 283 # set up the RPATH for installation
 284 set(CMAKE_INSTALL_RPATH ${FOAM_INSTALL_LIBRARY_PATH})
 285 set(CMAKE_INSTALL_NAME_DIR ${FOAM_FRAMEWORK_INSTALL_NAME_DIR})
 286
 287 # we want executables and libraries in uniform places
 288 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
 289   "${CMAKE_BINARY_DIR}/libexec/${PROJECT_NAME}/${FOAM_VERSION_FULL}")
 290 set(FOAM_LIBRARY_OUTPUT_DIRECTORY
 291   "${CMAKE_BINARY_DIR}/lib/${PROJECT_NAME}-${FOAM_VERSION_FULL}")
 292 set(FOAM_FRAMEWORK_OUTPUT_DIRECTORY
 293   "${CMAKE_BINARY_DIR}/Library/Frameworks")
 294 if(FOAM_BUILD_FRAMEWORKS)
 295   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${FOAM_FRAMEWORK_OUTPUT_DIRECTORY}")
 296 else()
 297   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${FOAM_LIBRARY_OUTPUT_DIRECTORY}")
 298 endif()
 299 set(FOAM_ARCHIVE_OUTPUT_DIRECTORY "${FOAM_LIBRARY_OUTPUT_DIRECTORY}")
 300
 301 # find parallel libraries
 302 find_package(MPI)
 303 if(MPI_FOUND)
 304   set(_FOAM_USE_MPI ON)
 305 else()
 306   set(_FOAM_USE_MPI OFF)
 307 endif()
 308 foam_option(FOAM_USE_MPI "Use MPI"
 309   "Build ${CMAKE_PROJECT} against MPI parallel libraries" ${_FOAM_USE_MPI})
 310 if(FOAM_USE_MPI AND NOT MPI_FOUND)
 311   message(SEND_ERROR
 312     "FOAM_ENABLE_MPI is true, but MPI cannot be found.\n"
 313     "If you have MPI installed on your system, edit the variables\n"
 314     "MPI_INCLUDE_DIR and MPI_LIBRARY in the cache, else disable the\n"
 315     "setting FOAM_USE_MPI."
 316   )
 317 endif()
 318
 319 # find readline
 320 find_package(Readline)
 321
 322 # substitution for build-tree and install-tree as used by
 323 # foam_configure_files.
 324 set(FOAM_CONFIGURE_FILES_VARIABLES
 325   FOAM_DATA_DIR
 326     "${CMAKE_BINARY_DIR}/data"
 327     "${FOAM_INSTALL_DATA_PATH}"
 328   FOAM_LOCAL_DOC_DIR
 329     "${CMAKE_BINARY_DIR}/doc"
 330     "${FOAM_INSTALL_DOC_PATH}"
 331   FOAM_BIN_DIR
 332     "${CMAKE_BINARY_DIR}/bin"
 333     "${FOAM_INSTALL_BIN_PATH}"
 334   FOAM_LIB_DIR
 335     "${CMAKE_BINARY_DIR}/lib/FreeFOAM-${FOAM_VERSION_FULL}"
 336     "${FOAM_INSTALL_LIBRARY_PATH}"
 337   FOAM_LIBEXEC_DIR
 338     "${CMAKE_BINARY_DIR}/libexec/FreeFOAM/${FOAM_VERSION_FULL}"
 339     "${FOAM_INSTALL_LIBEXEC_PATH}"
 340   FOAM_FRAMEWORK_DIR
 341     "${CMAKE_BINARY_DIR}/Library/Frameworks"
 342     "${FOAM_INSTALL_FRAMEWORK_PATH}"
 343   FOAM_INCLUDE_DIR
 344     "${CMAKE_BINARY_DIR}/include"
 345     "${FOAM_INSTALL_HEADER_PATH}"
 346   FOAM_CONFIG_DIR
 347     "${CMAKE_BINARY_DIR}/etc"
 348     "${FOAM_INSTALL_CONFIG_PATH}"
 349   FOAM_CMAKECONFIG_DIR
 350     "${CMAKE_BINARY_DIR}/CMake"
 351     "${FOAM_INSTALL_CMAKE_PATH}"
 352   FOAM_PYTHON_DIR
 353     "${CMAKE_BINARY_DIR}/data/python"
 354     "${FOAM_INSTALL_PYTHON_PATH}"
 355   FOAM_IS_INSTALLED
 356     "FALSE"
 357     "TRUE"
 358   )
 359 if(FOAM_USE_LOCAL_DOXYGEN_DOCS)
 360   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 361     FOAM_DOC_DIR "${CMAKE_BINARY_DIR}/doc" "${FOAM_INSTALL_DOC_PATH}")
 362 else()
 363   set(_sf_doc "http://freefoam.sf.net/doc/${FOAM_VERSION_FULL}")
 364   list(APPEND FOAM_CONFIGURE_FILES_VARIABLES
 365     FOAM_DOC_DIR "${_sf_doc}" "${_sf_doc}")
 366 endif()
 367
 368 # thirdparty libraries
 369 foam_thirdparty_option(Metis
 370   "Required by the metis decomposition method"
 371   Metis TRUE ON)
 372 if(FOAM_ENABLE_METIS)
 373   if(FOAM_ENABLE_METIS AND METIS_REQUIRES_MPI AND NOT FOAM_USE_MPI)
 374     message(SEND_ERROR
 375       "Your metis implementation requires FOAM_USE_MPI to be enabled."
 376       "If you don't have/want MPI, enable FOAM_BUILD_PRIVATE_METIS instead.")
 377   endif()
 378 endif()
 379 foam_thirdparty_option(ParMetis
 380   "Required by the parmetis decomposition method"
 381   ParMetis TRUE ${FOAM_USE_MPI}
 382   PARMETIS_metis_LIBRARY PARMETIS_parmetis_LIBRARY)
 383 if(FOAM_ENABLE_PARMETIS AND NOT FOAM_USE_MPI)
 384   message(SEND_ERROR
 385     "ParMetis requires FOAM_USE_MPI to be enabled.")
 386 endif()
 387 if(FOAM_ENABLE_PARMETIS AND NOT FOAM_ENABLE_METIS)
 388   message(SEND_ERROR
 389     "ParMetis requires FOAM_ENABLE_METIS to be enabled.")
 390 endif()
 391 set(SCOTCH_USE_ERREXIT TRUE)
 392 foam_thirdparty_option(SCOTCH "" SCOTCH FALSE ON SCOTCH_scotch_LIBRARY
 393   SCOTCH_scotcherr_LIBRARY SCOTCH_scotcherrexit_LIBRARY)
 394 # do not enable mgridgen by default (licensing issues)
 395 if(NOT FOAM_DOUBLE_PRECISION)
 396   set(MGRIDGEN_USE_REAL ON)
 397 endif()
 398 foam_thirdparty_option(MGRIDGEN
 399   "Required by the MGridGen GAMG agglomerator. LICENSE UNCLEAR"
 400   MGRIDGEN TRUE OFF)
 401 # do not enable libccmio by default (licensing issues)
 402 foam_thirdparty_option(ccmio
 403   "Required by ccm26ToFoam. REQUIRES PERMISSION BY CDADAPCO!"
 404   Ccmio TRUE OFF)
 405 foam_thirdparty_option(zlib "" ZLIB FALSE ON)
 406
 407 # figure out default Pstream library
 408 if(FOAM_USE_MPI)
 409   set(_FOAM_DEFAULT_PSTREAM mpi)
 410 else()
 411   set(_FOAM_DEFAULT_PSTREAM dummy)
 412 endif()
 413 set(FOAM_DEFAULT_PSTREAM ${_FOAM_DEFAULT_PSTREAM} CACHE STRING
 414   "Default Pstream library implementation [dummy|mpi]")
 415 mark_as_advanced(FOAM_DEFAULT_PSTREAM)
 416
 417 # find m4 macro processor
 418 find_program(M4_EXECUTABLE m4 DOC "Path to the m4 macro processor")
 419 mark_as_advanced(M4_EXECUTABLE)
 420 if(NOT M4_EXECUTABLE)
 421   message("WARNING: Failed to find M4 macro processor.\n"
 422     "Some of the tutorials will fail if it can't be found.")
 423   set(M4_EXECUTABLE m4)
 424 endif()
 425
 426 # find gnuplot executable
 427 find_program(GNUPLOT_EXECUTABLE gnuplot DOC "Path to the gnuplot program")
 428 mark_as_advanced(GNUPLOT_EXECUTABLE)
 429 if(NOT GNUPLOT_EXECUTABLE)
 430   message("WARNING: Failed ot find gnuplot.\n"
 431     "Some tutorials will not create quantitative comparison plots.")
 432 endif()
 433
 434 # on APPLE use cp -R -P -p, otherwise use cp -a
 435 if(APPLE)
 436   set(FOAM_CP_A_FLAGS "-R -P -p")
 437 else()
 438   set(FOAM_CP_A_FLAGS "-a")
 439 endif()
 440
 441 # execinfo.h and cxxabi.h only work using GNU gcc and Debug config
 442 # assume that if we have execinfo.h, cxxabi.h is also present.
 443 if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_BUILD_TYPE STREQUAL Debug)
 444   find_package(Execinfo)
 445 endif()
 446
 447 # create the FOAMConfig.h file
 448 configure_file(${CMAKE_SOURCE_DIR}/FOAMConfig.h.in
 449   ${CMAKE_BINARY_DIR}/include/FOAMConfig.h @ONLY)
 450
 451 # on Solaris/SunOS fix up the shebangs
 452 if(CMAKE_SYSTEM_NAME STREQUAL SunOS AND NOT EXISTS ${CMAKE_BINARY_DIR}/replaceAllShellSun.run)
 453   message(STATUS "Fixing shell-interpreter for SunOS and Solaris")
 454   execute_process(
 455     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun bin
 456     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun data
 457     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun tutorials
 458     COMMAND ${CMAKE_SOURCE_DIR}/data/utilities/replaceAllShellSun doc
 459     COMMAND ${CMAKE_COMMAND} -E touch${CMAKE_BINARY_DIR}/replaceAllShellSun.run
 460     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
 461     )
 462 endif()
 463
 464 # set up defines
 465 set(FOAM_COMPILE_DEFINITIONS
 466   -D${FOAM_PRECISION}
 467   -DNoRepository
 468   -D${FOAM_OS}
 469   )
 470 if(APPLE)
 471   list(APPEND FOAM_COMPILE_DEFINITIONS -Ddarwin)
 472 endif()
 473 add_definitions(${FOAM_COMPILE_DEFINITIONS})
 474
 475 # set up include-directories for own headers
 476 include_directories(${CMAKE_BINARY_DIR}/include)
 477
 478 # descend into the sources...
 479 add_subdirectory(bin)
 480 add_subdirectory(etc)
 481 add_subdirectory(data)
 482 add_subdirectory(src)
 483 add_subdirectory(applications)
 484 add_subdirectory(tutorials)
 485 add_subdirectory(doc)
 486
 487 # export the library dependencies to the build tree
 488 foam_export_targets_to_build_tree(${PROJECT_NAME}LibraryDepends)
 489 export(PACKAGE ${PROJECT_NAME})
 490
 491 # write the doc index file and install it
 492 foam_write_doc_index()
 493 install(FILES
 494   ${CMAKE_BINARY_DIR}/InstallFiles/data/DoxyDocIndex
 495   DESTINATION ${FOAM_INSTALL_DATA_PATH}
 496   COMPONENT data
 497   )
 498
 499 # create ${PROJECT_NAME}Config.cmake ${PROJECT_NAME}Use.cmake,
 500 # ${PROJECT_NAME}Utilities.cmake and ${PROJECT_NAME}WmakeCompatibility.cmake
 501 # for the build and install tree
 502 foam_configure_files(ConfigInstallFiles
 503   "CMake/FOAMConfig.cmake.in==CMake/${PROJECT_NAME}Config.cmake"
 504   "CMake/FOAMUse.cmake.in==CMake/${PROJECT_NAME}Use.cmake"
 505   "CMake/FOAMWmakeCompatibility.cmake.in==CMake/${PROJECT_NAME}WmakeCompatibility.cmake"
 506   COPYONLY
 507   "CMake/FOAMUtilities.cmake==CMake/${PROJECT_NAME}Utilities.cmake"
 508   )
 509
 510 # install the CMake config files
 511 install(FILES
 512   ${ConfigInstallFiles}
 513   DESTINATION ${FOAM_INSTALL_CMAKE_PATH}
 514   COMPONENT dev
 515   )
 516
 517 # install the ${PROJECT_NAME}LibraryDepends.cmake file
 518 install(EXPORT ${PROJECT_NAME}LibraryDepends
 519   DESTINATION ${FOAM_INSTALL_CMAKE_PATH}
 520   NAMESPACE FOAM_
 521   COMPONENT dev
 522   )
 523
 524 # pack things up
 525 if(FOAM_ENABLE_CPACK)
 526   include(${CMAKE_SOURCE_DIR}/CMake/FOAMCPack.cmake)
 527 endif()
 528
 529 # uninstall target
 530 configure_file(
 531   "${CMAKE_SOURCE_DIR}/CMake/Modules/cmake_uninstall.cmake.in"
 532   "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
 533   @ONLY
 534   )
 535
 536 add_custom_target(uninstall
 537   "${CMAKE_COMMAND}" -P "${CMAKE_BINARY_DIR}/cmake_uninstall.cmake"
 538   )
 539
 540 # print cool feature summary
 541 foam_print_feature_summary()
 542
 543 # ------------------------- vim: set sw=2 sts=2 et: --------------- end-of-file