

CMAKE_MINIMUM_REQUIRED(VERSION 2.7)


#
# A) Basic top-level Trilinos stuff
#

MESSAGE("")
MESSAGE("Configuring Trilinos build directory")
MESSAGE("")

IF ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
  MESSAGE(FATAL_ERROR "Error, CMAKE_CURRENT_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
    " == CMAKE_CURRENT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}"
    " Trilinos does not support in source builds!" )
ENDIF()

PROJECT(Trilinos NONE)

SET(TRILINOS_HOME_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL "")
SET(TRILINOS_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR} CACHE INTERNAL "")
# Above, we put these in the cache so we can grep them out

MESSAGE("-- " "TRILINOS_HOME_DIR = ${TRILINOS_HOME_DIR}")
MESSAGE("-- " "TRILINOS_BUILD_DIR = ${TRILINOS_BUILD_DIR}")

SET( CMAKE_MODULE_PATH
   ${TRILINOS_HOME_DIR}
   ${TRILINOS_HOME_DIR}/cmake
   ${TRILINOS_HOME_DIR}/cmake/utils
   ${TRILINOS_HOME_DIR}/cmake/package_arch
   ${TRILINOS_HOME_DIR}/cmake/config_tests
   )

#Pull in Trilinos version information and create the version header file.
INCLUDE(TrilinosVersion)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/Trilinos_version.h.in
  Trilinos_version.h)

#Automatically update the version file for sierra too.
IF (NOT WIN32)
  # Only configure on non-windows system because of the dreaded ^M
  CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/Trilinos_version.h.in
    ${CMAKE_CURRENT_SOURCE_DIR}/SIERRA/bjam/config_headers/Trilinos_version.h)
ENDIF()

#Since the version header file is now configured the root build
#dir needs to be on the include path
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_BINARY_DIR})

INCLUDE(PackageArchGlobalMacros)
INCLUDE(TrilinosGlobalMacros)
INCLUDE(AdvancedSet)
INCLUDE(AdvancedOption)

OPTION(Trilinos_VERBOSE_CONFIGURE
  "Make the Trilinos configure process verbose." OFF)

#
# A.1) Run misc unit tests that don't need anything else
#
# These below tests are a bit strange.  See
# cmake/TestingUnitTests/CMakeLists.txt for details!
#

IF (Trilinos_INVOKE_TESTING_UNIT_TESTS)
  ADD_SUBDIRECTORY(cmake/TestingUnitTests/UnitTests)
  RETURN()
ENDIF()

#
# A.2) Set up other stuff
#

# Find Python executable which is needed for dependency file building
FIND_PACKAGE(PythonInterp)


#
# B) Set up user options and global variables that will be used throughout
#

MESSAGE("")
MESSAGE("Setting up major user options ...")
MESSAGE("")

PACKAGE_ARCH_DEFINE_GLOBAL_OPTIONS()

ADVANCED_SET(Trilinos_DATA_DIR
  "NOTFOUND"
  CACHE PATH
  "Path TrilinosData directory to find more tests and other stuff" )

ADVANCED_OPTION(Trilinos_SHORTCIRCUIT_AFTER_DEPENDENCY_HANDLING
  "Shortcircut after dependency handling is complete"
  OFF )

ADVANCED_OPTION(Trilinos_SKIP_FORTRANCINTERFACE_VERIFY_TEST
  "Skip the Fortran/C++ compatibility test"
  OFF )

IF (WIN32 AND NOT CYGWIN)
  SET(Trilinos_DEPS_XML_OUTPUT_FILE_DEFAULT "")
ELSE()
  SET(Trilinos_DEPS_XML_OUTPUT_FILE_DEFAULT
    "${TRILINOS_HOME_DIR}/cmake/python/data/TrilinosPackageDependencies.xml" )
ENDIF()
ADVANCED_SET(Trilinos_DEPS_XML_OUTPUT_FILE
  "${Trilinos_DEPS_XML_OUTPUT_FILE_DEFAULT}"
  CACHE STRING
  "Output XML file containing Trilinos dependenices used by tools (if not empty)." )
# 2009/01/19: rabartl: Above: This file outputs just fine on MS# Windows using MS Visual Studio but it causes the entire file to
# diff.  There must be something wrong with a newlines or something
# that is causing this.  If people are going to be doing real
# development work on MS Windows with MS Visual Studio, then we need
# to fix this so that the dependency files will get created and
# checked in correctly.  I will look into this later.

IF(Trilinos_DEPS_XML_OUTPUT_FILE AND PYTHON_EXECUTABLE)
  SET(Trilinos_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT
    "${TRILINOS_HOME_DIR}/cmake/python/data/CDashSubprojectDependencies.xml" )
ELSE()
  SET(Trilinos_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT "")
ENDIF()
ADVANCED_SET(Trilinos_CDASH_DEPS_XML_OUTPUT_FILE
  "${Trilinos_CDASH_DEPS_XML_OUTPUT_FILE_DEFAULT}"
  CACHE STRING
  "Output XML file used by CDash in Trilinos-independent format (if not empty)." )

IF(Trilinos_DEPS_XML_OUTPUT_FILE AND PYTHON_EXECUTABLE)
  SET(Trilinos_DEPS_HTML_OUTPUT_FILE_DEFAULT
    "${TRILINOS_HOME_DIR}/cmake/python/data/TrilinosPackageDependenciesTable.html" )
ELSE()
  SET(Trilinos_DEPS_HTML_OUTPUT_FILE_DEFAULT "")
ENDIF()
ADVANCED_SET(Trilinos_DEPS_HTML_OUTPUT_FILE
  "${Trilinos_DEPS_HTML_OUTPUT_FILE_DEFAULT}"
  CACHE STRING
  "HTML Trilinos dependenices file that will be written to (if not empty)." )

SET(TRILINOS_BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")

#
# C) Define the list of all Trilinos packages and TPLs
#

# C.1) Packages

IF (NOT Trilinos_PACKAGES_FILE) # Allow testing override
  SET(Trilinos_PACKAGES_FILE "TrilinosPackages")
ENDIF()

MESSAGE("")
MESSAGE("Reading the list of packages from ${Trilinos_PACKAGES_FILE}.cmake ... ")
MESSAGE("")

INCLUDE(${Trilinos_PACKAGES_FILE})

PACKAGE_ARCH_PROCESS_PACKAGES_AND_DIRS_LISTS()

# C.2) TPLs

IF (NOT Trilinos_TPLS_FILE) # Allow testing override
  SET(Trilinos_TPLS_FILE "TrilinosTPLs")
ENDIF()

MESSAGE("")
MESSAGE("Reading the list of TPLs from ${Trilinos_TPLS_FILE}.cmake ... ")
MESSAGE("")

INCLUDE(${Trilinos_TPLS_FILE})

PACKAGE_ARCH_PROCESS_TPLS_LISTS()


#
# D) Process the package and TPL dependencies
#

PACKAGE_ARCH_READ_ALL_PACKAGE_DEPENDENCIES()


#
# E) Apply logic to enable Trilinos packages and tests
#

IF (NOT Trilinos_ENABLE_Fortran)
  MESSAGE(
    "\n***"
    "\n*** Warning: Setting Trilinos_ENABLE_ForTrilinos=OFF"
    " because Trilinos_ENABLE_Fortran=OFF!"
    "\n***\n"
    )
  SET(Trilinos_ENABLE_ForTrilinos OFF)
ENDIF()

PACKAGE_ARCH_PRINT_ENABLED_PACKAGE_LIST(
  "\nExplicitly enabled packages on input (by user)" ON FALSE)
PACKAGE_ARCH_PRINT_ENABLED_PACKAGE_LIST(
  "\nExplicitly disabled packages on input (by user or by default)" OFF FALSE)
PACKAGE_ARCH_PRINT_ENABLED_TPL_LIST(
  "\nExplicitly enabled TPLs on input (by user)" ON FALSE)
PACKAGE_ARCH_PRINT_ENABLED_TPL_LIST(
  "\nExplicitly disabled TPLs on input (by user or by default)" OFF FALSE)

SET(DO_PROCESS_MPI_ENABLES ON) # Should not be needed but CMake is not working!
PACKAGE_ARCH_ADJUST_PACKAGE_ENABLES(TRUE)

PACKAGE_ARCH_PRINT_ENABLED_PACKAGE_LIST(
  "\nFinal set of enabled packages" ON FALSE)
PACKAGE_ARCH_PRINT_ENABLED_PACKAGE_LIST(
  "\nFinal set of non-enabled packages" OFF TRUE)
PACKAGE_ARCH_PRINT_ENABLED_TPL_LIST(
  "\nFinal set of enabled TPLs" ON FALSE)
PACKAGE_ARCH_PRINT_ENABLED_TPL_LIST(
  "\nFinal set of non-enabled TPLs" OFF TRUE)

IF (Trilinos_DEPS_XML_OUTPUT_FILE)
  IF (NOT IS_ABSOLUTE ${Trilinos_DEPS_XML_OUTPUT_FILE})
    SET(Trilinos_DEPS_XML_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${Trilinos_DEPS_XML_OUTPUT_FILE})
  ENDIF()
  MESSAGE("" )
  MESSAGE("Dumping the XML dependencies file ${Trilinos_DEPS_XML_OUTPUT_FILE} ..." )
  MESSAGE("")
  PACKAGE_ARCH_DUMP_DEPS_XML_FILE()
ENDIF()

IF (Trilinos_DEPS_HTML_OUTPUT_FILE AND Trilinos_DEPS_XML_OUTPUT_FILE)
  IF (NOT IS_ABSOLUTE ${Trilinos_DEPS_HTML_OUTPUT_FILE})
    SET(Trilinos_DEPS_HTML_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${Trilinos_DEPS_HTML_OUTPUT_FILE})
  ENDIF()
  MESSAGE("" )
  MESSAGE("Dumping the HTML dependencies webpage file ${Trilinos_DEPS_HTML_OUTPUT_FILE} ..." )
  MESSAGE("" )
  EXECUTE_PROCESS(
    COMMAND ${PYTHON_EXECUTABLE}
      ${TRILINOS_HOME_DIR}/cmake/python/dump-package-dep-table.py
      --input-xml-deps-file=${Trilinos_DEPS_XML_OUTPUT_FILE}
      --output-html-deps-file=${Trilinos_DEPS_HTML_OUTPUT_FILE} )
ENDIF()

IF (Trilinos_CDASH_DEPS_XML_OUTPUT_FILE AND Trilinos_DEPS_XML_OUTPUT_FILE)
  IF (NOT IS_ABSOLUTE ${Trilinos_CDASH_DEPS_XML_OUTPUT_FILE})
    SET(Trilinos_CDASH_DEPS_XML_OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${Trilinos_CDASH_DEPS_XML_OUTPUT_FILE})
  ENDIF()
  MESSAGE("" )
  MESSAGE("" )
  MESSAGE("Dumping the CDash XML dependencies file ${Trilinos_CDASH_DEPS_XML_OUTPUT_FILE} ..." )
  MESSAGE("" )
  EXECUTE_PROCESS(
    COMMAND ${PYTHON_EXECUTABLE}
      ${TRILINOS_HOME_DIR}/cmake/python/dump-cdash-deps-xml-file.py
      --input-xml-deps-file=${Trilinos_DEPS_XML_OUTPUT_FILE}
      --output-cdash-deps-xml-file=${Trilinos_CDASH_DEPS_XML_OUTPUT_FILE} )
ENDIF()

IF (Trilinos_SHORTCIRCUIT_AFTER_DEPENDENCY_HANDLING)
  MESSAGE("")
  MESSAGE(SEND_ERROR "Shortcircuiting after dependency tracking ...")
  RETURN()
ENDIF()

#
# F) Add the 'dashboard' target
#

IF (NOT (WIN32 AND NOT CYGWIN))

  # F.1) Enable all packages that are enabled and have tests enabled

  SET(Trilinos_ENABLED_PACKAGES_LIST)
  SET(Trilinos_ENABLED_PACKAGES_CMAKE_ARG_LIST)
  FOREACH(PACKAGE ${Trilinos_PACKAGES})
    IF (Trilinos_ENABLE_${PACKAGE} AND ${PACKAGE}_ENABLE_TESTS)
      IF (Trilinos_ENABLED_PACKAGES_LIST)
        SET(Trilinos_ENABLED_PACKAGES_LIST
          "${Trilinos_ENABLED_PACKAGES_LIST}\;${PACKAGE}") 
      ELSE()
        SET(Trilinos_ENABLED_PACKAGES_LIST "${PACKAGE}") 
      ENDIF()
      SET(Trilinos_ENABLED_PACKAGES_CMAKE_ARG_LIST
        ${Trilinos_ENABLED_PACKAGES_CMAKE_ARG_LIST} -DTrilinos_ENABLE_${PACKAGE}=ON)
    ENDIF()
  ENDFOREACH()
  #PRINT_VAR(Trilinos_ENABLED_PACKAGES_LIST)
  
  SET(EXPR_CMND_ARGS)
  IF (Trilinos_ENABLE_COVERAGE_TESTING)
    APPEND_SET(EXPR_CMND_ARGS "CTEST_DO_COVERAGE_TESTING=TRUE")
  ENDIF()

  # F.2) Add the custom target to enable all the packages with tests enabled
  
  ADD_CUSTOM_TARGET(dashboard

    VERBATIM
  
    # WARNING: The echoed command and the actual commands are duplicated!  You have to reproduce them!

    COMMAND echo
    COMMAND echo "***************************************************"
    COMMAND echo "*** Running incremental experimental dashboard ***" 
    COMMAND echo "***************************************************"
    COMMAND echo
    COMMAND echo Trilinos_ENABLED_PACKAGES_LIST=${Trilinos_ENABLED_PACKAGES_LIST}
    COMMAND echo

    COMMAND echo
    COMMAND echo "***"
    COMMAND echo "*** A) Clean out the list of packages"
    COMMAND echo "***"
    COMMAND echo
    COMMAND echo Running: ${CMAKE_COMMAND} -DTrilinos_UNENABLE_ENABLED_PACKAGES:BOOL=TRUE
      -DTrilinos_ALLOW_NO_PACKAGES:BOOL=ON -DTrilinos_ENABLE_ALL_PACKAGES:BOOL=OFF ${TRILINOS_HOME_DIR}
    COMMAND echo
    COMMAND ${CMAKE_COMMAND} -DTrilinos_UNENABLE_ENABLED_PACKAGES:BOOL=TRUE
      -DTrilinos_ALLOW_NO_PACKAGES:BOOL=ON -DTrilinos_ENABLE_ALL_PACKAGES:BOOL=OFF ${TRILINOS_HOME_DIR}

    # NOTE: Above, if Trilinos_ENABLE_ALL_PACKAGES was set in CMakeCache.txt, then setting
    # -DTrilinos_ENABLE_ALL_PACKAGES:BOOL=OFF will turn it off in the cache.  Note that it will
    # never be turned on again which means that the list of packages will be set explicitly below.
  
    COMMAND echo
    COMMAND echo "***"
    COMMAND echo "*** B) Run the dashboard command setting the list of packages"
    COMMAND echo "***"
    COMMAND echo
    COMMAND echo Running: env ${EXPR_CMND_ARGS}
      Trilinos_PACKAGES=${Trilinos_ENABLED_PACKAGES_LIST}
      ${CMAKE_CTEST_COMMAND} -S
        ${TRILINOS_HOME_DIR}/cmake/ctest/experimental_build_test.cmake
    COMMAND echo
    COMMAND env ${EXPR_CMND_ARGS}
      Trilinos_PACKAGES=${Trilinos_ENABLED_PACKAGES_LIST}
      ${CMAKE_CTEST_COMMAND} -S
        ${TRILINOS_HOME_DIR}/cmake/ctest/experimental_build_test.cmake || echo

    # 2009/07/05: rabartl: Above, I added the ending '|| echo' to always make
    # the command pass so that 'make will not stop and avoid this last command
    # to set back the enabled packages.
  
    COMMAND echo
    COMMAND echo "***"
    COMMAND echo "*** C) Reconfigure with the original package list"
    COMMAND echo "***"
    COMMAND echo
    COMMAND echo Running: ${CMAKE_COMMAND} ${Trilinos_ENABLED_PACKAGES_CMAKE_ARG_LIST}
      -DTrilinos_ALLOW_NO_PACKAGES:BOOL=ON ${TRILINOS_HOME_DIR}
    COMMAND echo
    COMMAND ${CMAKE_COMMAND} ${Trilinos_ENABLED_PACKAGES_CMAKE_ARG_LIST}
      -DTrilinos_ALLOW_NO_PACKAGES:BOOL=ON ${TRILINOS_HOME_DIR}

    COMMAND echo
    COMMAND echo "See the results at http://trilinos.sandia.gov/cdash/index.php?project=Trilinos&display=project\#Experimental"
    COMMAND echo
 
    )

ENDIF()


#
# G) Set up the environment on this computer
#

MESSAGE("")
MESSAGE("Probing the environment ...")
MESSAGE("")

PACKAGE_ARCH_PRE_SETUP_ENV()

INCLUDE(TrilinosProbeEnv)

PACKAGE_ARCH_POST_SETUP_ENV()


#
# H) Go get the information for all enabled TPLS
#

MESSAGE("")
MESSAGE("Getting information for all enabled TPLs ...")
MESSAGE("")

PACKAGE_ARCH_PROCESS_ENABLED_TPLS()

# OpenMP is similar to a TPL in some respects, but requires only compiler
# flags to enable

OPTION(Trilinos_ENABLE_OpenMP
      "Build with OpenMP support." OFF)
#
# I) Set up for testing with CTest and Trilinos test harness
#

MESSAGE("")
MESSAGE("Setting up testing support ...")
MESSAGE("")

INCLUDE(CTest)

TRILINOS_SETUP_TESTING_SUPPORT()


#
# J) Setup for packaging and distribution
#

TRILINOS_DEFINE_PACKAGING()


#
# K) Configure individual packages
# 

MESSAGE("")
MESSAGE("Configuring individual enabled Trilinos packages ...")
MESSAGE("")

PACKAGE_ARCH_CONFIGURE_ENABLED_PACKAGES()


#
# L) Install-related commands
#

PACKAGE_WRITE_TRILINOS_CONFIG_FILE()

#
# M) Export the library dependencies. This will let client projects
# refer to all TPLs used by Trilinos. (KRL, 26 Nov 2009)
#

MESSAGE("")
MESSAGE("Exporting library dependencies ...")
MESSAGE("")
EXPORT_LIBRARY_DEPENDENCIES( ${Trilinos_BINARY_DIR}/TrilinosLibraryDepends.cmake )
