CMakeLists.txt 25.8 KB
Newer Older
1 2
#=============================================================================
# CMake - Cross Platform Makefile Generator
3
# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
4 5 6 7 8 9 10 11
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
12
CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 FATAL_ERROR)
13
SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
Ken Martin's avatar
Ken Martin committed
14
PROJECT(CMake)
15

16 17 18 19 20 21
IF(CMAKE_BOOTSTRAP)
  # Running from bootstrap script.  Set local variable and remove from cache.
  SET(CMAKE_BOOTSTRAP 1)
  UNSET(CMAKE_BOOTSTRAP CACHE)
ENDIF()

22 23
SET(CMake_BIN_DIR ${CMake_BINARY_DIR}/bin)

24 25 26 27 28 29 30 31 32 33 34
IF("${CMake_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
  # Disallow architecture-specific try_run.  It may not run on the host.
  MACRO(TRY_RUN)
    IF(CMAKE_TRY_COMPILE_OSX_ARCHITECTURES)
      MESSAGE(FATAL_ERROR "TRY_RUN not allowed with CMAKE_TRY_COMPILE_OSX_ARCHITECTURES=[${CMAKE_TRY_COMPILE_OSX_ARCHITECTURES}]")
    ELSE()
      _TRY_RUN(${ARGV})
    ENDIF()
  ENDMACRO()
ENDIF()

35 36 37 38 39
#-----------------------------------------------------------------------
# a macro to deal with system libraries, implemented as a macro
# simply to improve readability of the main script
#-----------------------------------------------------------------------
MACRO(CMAKE_HANDLE_SYSTEM_LIBRARIES)
40 41
  # Options have dependencies.
  INCLUDE(CMakeDependentOption)
42

43 44 45 46
  # Optionally use system xmlrpc.  We no longer build or use it by default.
  OPTION(CTEST_USE_XMLRPC "Enable xmlrpc submission method in CTest." OFF)
  MARK_AS_ADVANCED(CTEST_USE_XMLRPC)

47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
  # Allow the user to enable/disable all system utility library options by
  # defining CMAKE_USE_SYSTEM_LIBRARIES or CMAKE_USE_SYSTEM_LIBRARY_${util}.
  SET(UTILITIES BZIP2 CURL EXPAT LIBARCHIVE ZLIB)
  FOREACH(util ${UTILITIES})
    IF(NOT DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util}
        AND DEFINED CMAKE_USE_SYSTEM_LIBRARIES)
      SET(CMAKE_USE_SYSTEM_LIBRARY_${util} "${CMAKE_USE_SYSTEM_LIBRARIES}")
    ENDIF()
    IF(DEFINED CMAKE_USE_SYSTEM_LIBRARY_${util})
      IF(CMAKE_USE_SYSTEM_LIBRARY_${util})
        SET(CMAKE_USE_SYSTEM_LIBRARY_${util} ON)
      ELSE()
        SET(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
      ENDIF()
      IF(CMAKE_BOOTSTRAP)
        UNSET(CMAKE_USE_SYSTEM_LIBRARY_${util} CACHE)
      ENDIF()
      STRING(TOLOWER "${util}" lutil)
      SET(CMAKE_USE_SYSTEM_${util} "${CMAKE_USE_SYSTEM_LIBRARY_${util}}"
        CACHE BOOL "Use system-installed ${lutil}" FORCE)
    ELSE()
      SET(CMAKE_USE_SYSTEM_LIBRARY_${util} OFF)
    ENDIF()
  ENDFOREACH(util)
  IF(CMAKE_BOOTSTRAP)
    UNSET(CMAKE_USE_SYSTEM_LIBRARIES CACHE)
  ENDIF()
74 75

  # Optionally use system utility libraries.
76
  OPTION(CMAKE_USE_SYSTEM_LIBARCHIVE "Use system-installed libarchive" "${CMAKE_USE_SYSTEM_LIBRARY_LIBARCHIVE}")
77
  CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_CURL "Use system-installed curl"
78
    "${CMAKE_USE_SYSTEM_LIBRARY_CURL}" "NOT CTEST_USE_XMLRPC" ON)
79
  CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_EXPAT "Use system-installed expat"
80
    "${CMAKE_USE_SYSTEM_LIBRARY_EXPAT}" "NOT CTEST_USE_XMLRPC" ON)
81
  CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_ZLIB "Use system-installed zlib"
82
    "${CMAKE_USE_SYSTEM_LIBRARY_ZLIB}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE;NOT CMAKE_USE_SYSTEM_CURL" ON)
83
  CMAKE_DEPENDENT_OPTION(CMAKE_USE_SYSTEM_BZIP2 "Use system-installed bzip2"
84
    "${CMAKE_USE_SYSTEM_LIBRARY_BZIP2}" "NOT CMAKE_USE_SYSTEM_LIBARCHIVE" ON)
85

86
  # Mention to the user what system libraries are being used.
87
  FOREACH(util ${UTILITIES})
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
    IF(CMAKE_USE_SYSTEM_${util})
      MESSAGE(STATUS "Using system-installed ${util}")
    ENDIF(CMAKE_USE_SYSTEM_${util})
  ENDFOREACH(util)

  # Inform utility library header wrappers whether to use system versions.
  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Utilities/cmThirdParty.h.in
    ${CMake_BINARY_DIR}/Utilities/cmThirdParty.h
    @ONLY)

ENDMACRO(CMAKE_HANDLE_SYSTEM_LIBRARIES)




103 104 105 106
SET(CMAKE_BUILD_ON_VISUAL_STUDIO 0)
IF(WIN32 AND NOT UNIX AND NOT BORLAND AND NOT MINGW )
  SET(CMAKE_BUILD_ON_VISUAL_STUDIO 1)
ENDIF(WIN32 AND NOT UNIX AND NOT BORLAND AND NOT MINGW )
107 108 109 110 111 112 113


#-----------------------------------------------------------------------
# a macro to determine the generator and ctest executable to use
# for testing. Simply to improve readability of the main script.
#-----------------------------------------------------------------------
MACRO(CMAKE_SETUP_TESTING)
Ken Martin's avatar
Ken Martin committed
114 115 116
  IF (NOT DART_ROOT)
    SET(MAKEPROGRAM ${CMAKE_MAKE_PROGRAM})
  ENDIF (NOT DART_ROOT)
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
  
  IF(BUILD_TESTING)
    SET(CMAKE_TEST_GENERATOR "" CACHE STRING 
      "Generator used when running tests")
    SET(CMAKE_TEST_MAKEPROGRAM "" CACHE FILEPATH 
      "Generator used when running tests")
    IF(NOT CMAKE_TEST_GENERATOR)
      SET(CMAKE_TEST_GENERATOR "${CMAKE_GENERATOR}")
      SET(CMAKE_TEST_MAKEPROGRAM "${MAKEPROGRAM}")
    ELSE(NOT CMAKE_TEST_GENERATOR)
      SET(CMAKE_TEST_DIFFERENT_GENERATOR TRUE)
    ENDIF(NOT CMAKE_TEST_GENERATOR)
    
    # Are we testing with the MSVC compiler?
    SET(CMAKE_TEST_MSVC 0)
    IF(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
      SET(CMAKE_TEST_MSVC 1)
    ELSE(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
      IF("${CMAKE_TEST_GENERATOR}" MATCHES "NMake" OR
          "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio")
        SET(CMAKE_TEST_MSVC 1)
      ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "NMake" OR
        "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio")
    ENDIF(MSVC AND NOT CMAKE_TEST_DIFFERENT_GENERATOR)
    
    SET(CMAKE_TEST_SYSTEM_LIBRARIES 0)
    FOREACH(util CURL EXPAT XMLRPC ZLIB)
      IF(CMAKE_USE_SYSTEM_${util})
        SET(CMAKE_TEST_SYSTEM_LIBRARIES 1)
      ENDIF(CMAKE_USE_SYSTEM_${util})
    ENDFOREACH(util)
    
    # This variable is set by cmake, however to
    # test cmake we want to make sure that
    # the ctest from this cmake is used for testing
    # and not the ctest from the cmake building and testing
    # cmake.
154 155 156
    SET(CMAKE_CTEST_COMMAND "${CMake_BIN_DIR}/ctest")
    SET(CMAKE_CMAKE_COMMAND "${CMake_BIN_DIR}/cmake")
    SET(CMAKE_CPACK_COMMAND "${CMake_BIN_DIR}/cpack")
157 158 159 160 161
  ENDIF(BUILD_TESTING)

  # configure some files for testing
  CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/Templates/CTestScript.cmake.in"
    "${CMAKE_CURRENT_BINARY_DIR}/CTestScript.cmake"
162
    @ONLY)
163 164 165 166
  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
    ${CMake_BINARY_DIR}/Tests/.NoDartCoverage)
  CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/.NoDartCoverage
    ${CMake_BINARY_DIR}/Modules/.NoDartCoverage)
167 168
  CONFIGURE_FILE(${CMake_SOURCE_DIR}/CTestCustom.cmake.in
    ${CMake_BINARY_DIR}/CTestCustom.cmake @ONLY)
169 170
  CONFIGURE_FILE(${CMake_SOURCE_DIR}/CTestCustom.ctest.in
    ${CMake_BINARY_DIR}/CTestCustom.ctest @ONLY)
Ken Martin's avatar
Ken Martin committed
171 172 173 174 175
  IF(BUILD_TESTING AND DART_ROOT)
    CONFIGURE_FILE(${CMake_SOURCE_DIR}/CMakeLogo.gif 
      ${CMake_BINARY_DIR}/Testing/HTML/TestingResults/Icons/Logo.gif COPYONLY)
  ENDIF(BUILD_TESTING AND DART_ROOT)
  MARK_AS_ADVANCED(DART_ROOT)
176 177 178 179
  MARK_AS_ADVANCED(CURL_TESTING)
ENDMACRO(CMAKE_SETUP_TESTING)


180 181 182 183 184 185 186 187 188 189 190 191
# Provide a way for Visual Studio Express users to turn OFF the new FOLDER
# organization feature. Default to ON for non-Express users. Express users must
# explicitly turn off this option to build CMake in the Express IDE...
#
OPTION(CMAKE_USE_FOLDERS "Enable folder grouping of projects in IDEs." ON)
MARK_AS_ADVANCED(CMAKE_USE_FOLDERS)


#-----------------------------------------------------------------------
# a macro that only sets the FOLDER target property if it's
# "appropriate"
#-----------------------------------------------------------------------
192
MACRO(CMAKE_SET_TARGET_FOLDER tgt folder)
193 194 195 196 197 198 199 200 201 202 203
  IF(CMAKE_USE_FOLDERS)
    SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS ON)

    # Really, I just want this to be an "if(TARGET ${tgt})" ...
    # but I'm not sure that our min req'd., CMake 2.4.5 can handle
    # that... so I'm just activating this for now, with a version
    # compare, and only for MSVC builds.
    IF(MSVC)
      IF(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.8)
        SET_PROPERTY(TARGET "${tgt}" PROPERTY FOLDER "${folder}")
      ENDIF()
204
    ENDIF()
205 206
  ELSE()
    SET_PROPERTY(GLOBAL PROPERTY USE_FOLDERS OFF)
207 208 209
  ENDIF()
ENDMACRO(CMAKE_SET_TARGET_FOLDER)

210 211 212 213 214 215

#-----------------------------------------------------------------------
# a macro to build the utilities used by CMake
# Simply to improve readability of the main script.
#-----------------------------------------------------------------------
MACRO (CMAKE_BUILD_UTILITIES)
216 217 218 219 220 221
  #---------------------------------------------------------------------
  # Create the KWIML library for CMake.
  SET(KWIML cmIML)
  SET(KWIML_HEADER_ROOT ${CMake_BINARY_DIR}/Utilities)
  ADD_SUBDIRECTORY(Utilities/KWIML)

222 223 224 225 226 227 228 229 230 231 232
  #---------------------------------------------------------------------
  # Create the kwsys library for CMake.
  SET(KWSYS_NAMESPACE cmsys)
  SET(KWSYS_USE_SystemTools 1)
  SET(KWSYS_USE_Directory 1)
  SET(KWSYS_USE_RegularExpression 1)
  SET(KWSYS_USE_Base64 1)
  SET(KWSYS_USE_MD5 1)
  SET(KWSYS_USE_Process 1)
  SET(KWSYS_USE_CommandLineArguments 1)
  SET(KWSYS_HEADER_ROOT ${CMake_BINARY_DIR}/Source)
233
  SET(KWSYS_INSTALL_DOC_DIR "${CMake_DOC_DEST}")
234
  ADD_SUBDIRECTORY(Source/kwsys)
235 236 237 238 239
  SET(kwsys_folder "Utilities/KWSys")
  CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE} "${kwsys_folder}")
  CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}_c "${kwsys_folder}")
  CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}EncodeExecutable "${kwsys_folder}")
  CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}ProcessFwd9x "${kwsys_folder}")
240 241 242 243 244 245 246
  if(BUILD_TESTING)
    CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}TestDynload "${kwsys_folder}")
    CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}TestProcess "${kwsys_folder}")
    CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}TestsC "${kwsys_folder}")
    CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}TestsCxx "${kwsys_folder}")
    CMAKE_SET_TARGET_FOLDER(${KWSYS_NAMESPACE}TestSharedForward "${kwsys_folder}")
  endif()
247

248 249 250 251 252 253
  #---------------------------------------------------------------------
  # Setup third-party libraries.
  # Everything in the tree should be able to include files from the
  # Utilities directory.
  INCLUDE_DIRECTORIES(
    ${CMake_BINARY_DIR}/Utilities
254
    ${CMake_SOURCE_DIR}/Utilities
255 256 257
    )
  
  # check for the use of system libraries versus builtin ones
Ken Martin's avatar
Ken Martin committed
258
  # (a macro defined in this file)
259 260 261 262 263 264 265 266 267 268 269 270 271 272
  CMAKE_HANDLE_SYSTEM_LIBRARIES()
  
  #---------------------------------------------------------------------
  # Build zlib library for Curl, CMake, and CTest.
  SET(CMAKE_ZLIB_HEADER "cm_zlib.h")
  IF(CMAKE_USE_SYSTEM_ZLIB)
    FIND_PACKAGE(ZLIB)
    IF(NOT ZLIB_FOUND)
      MESSAGE(FATAL_ERROR 
        "CMAKE_USE_SYSTEM_ZLIB is ON but a zlib is not found!")
    ENDIF(NOT ZLIB_FOUND)
    SET(CMAKE_ZLIB_INCLUDES ${ZLIB_INCLUDE_DIR})
    SET(CMAKE_ZLIB_LIBRARIES ${ZLIB_LIBRARIES})
  ELSE(CMAKE_USE_SYSTEM_ZLIB)
273
    SET(CMAKE_ZLIB_INCLUDES ${CMake_SOURCE_DIR}/Utilities)
274
    SET(CMAKE_ZLIB_LIBRARIES cmzlib)
275
    ADD_SUBDIRECTORY(Utilities/cmzlib)
276
    CMAKE_SET_TARGET_FOLDER(cmzlib "Utilities/3rdParty")
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292
  ENDIF(CMAKE_USE_SYSTEM_ZLIB)
  
  #---------------------------------------------------------------------
  # Build Curl library for CTest.
  IF(CMAKE_USE_SYSTEM_CURL)
    FIND_PACKAGE(CURL)
    IF(NOT CURL_FOUND)
      MESSAGE(FATAL_ERROR 
        "CMAKE_USE_SYSTEM_CURL is ON but a curl is not found!")
    ENDIF(NOT CURL_FOUND)
    SET(CMAKE_CURL_INCLUDES ${CURL_INCLUDE_DIRS})
    SET(CMAKE_CURL_LIBRARIES ${CURL_LIBRARIES})
  ELSE(CMAKE_USE_SYSTEM_CURL)
    SET(CURL_SPECIAL_ZLIB_H ${CMAKE_ZLIB_HEADER})
    SET(CURL_SPECIAL_LIBZ_INCLUDES ${CMAKE_ZLIB_INCLUDES})
    SET(CURL_SPECIAL_LIBZ ${CMAKE_ZLIB_LIBRARIES})
293 294 295 296
    OPTION(CMAKE_BUILD_CURL_SHARED "Should curl be built shared" FALSE)
    IF(NOT CMAKE_BUILD_CURL_SHARED)
      ADD_DEFINITIONS(-DCURL_STATICLIB)
    ENDIF(NOT CMAKE_BUILD_CURL_SHARED)
297 298
    SET(CMAKE_CURL_INCLUDES)
    SET(CMAKE_CURL_LIBRARIES cmcurl)
299 300 301
    IF(CMAKE_TESTS_CDASH_SERVER)
      SET(CMAKE_CURL_TEST_URL "${CMAKE_TESTS_CDASH_SERVER}/user.php")
    ENDIF(CMAKE_TESTS_CDASH_SERVER)
302
    ADD_SUBDIRECTORY(Utilities/cmcurl)
303 304
    CMAKE_SET_TARGET_FOLDER(cmcurl "Utilities/3rdParty")
    CMAKE_SET_TARGET_FOLDER(LIBCURL "Utilities/3rdParty")
305 306 307 308 309 310 311
  ENDIF(CMAKE_USE_SYSTEM_CURL)

  #---------------------------------------------------------------------
  # Build Compress library for CTest.
  SET(CMAKE_COMPRESS_INCLUDES 
    "${CMAKE_CURRENT_BINARY_DIR}/Utilities/cmcompress")
  SET(CMAKE_COMPRESS_LIBRARIES "cmcompress")
312
  ADD_SUBDIRECTORY(Utilities/cmcompress)
313
  CMAKE_SET_TARGET_FOLDER(cmcompress "Utilities/3rdParty")
314 315 316 317 318 319
  IF(CMAKE_USE_SYSTEM_BZIP2)
    FIND_PACKAGE(BZip2)
  ELSE()
    SET(BZIP2_INCLUDE_DIR 
      "${CMAKE_CURRENT_SOURCE_DIR}/Utilities/cmbzip2")
    SET(BZIP2_LIBRARIES cmbzip2)
320
    ADD_SUBDIRECTORY(Utilities/cmbzip2)
321
    CMAKE_SET_TARGET_FOLDER(cmbzip2 "Utilities/3rdParty")
322
  ENDIF()
323 324 325

  #---------------------------------------------------------------------
  # Build or use system libarchive for CMake and CTest.
326
  IF(CMAKE_USE_SYSTEM_LIBARCHIVE)
327 328 329 330 331 332 333 334 335
    IF(EXISTS ${CMAKE_ROOT}/Modules/FindLibArchive.cmake)
      FIND_PACKAGE(LibArchive)
    ELSE()
      CMAKE_MINIMUM_REQUIRED(VERSION 2.8.0 FATAL_ERROR)
      INCLUDE(${CMake_SOURCE_DIR}/Modules/FindLibArchive.cmake)
    ENDIF()
    IF(NOT LibArchive_FOUND)
      MESSAGE(FATAL_ERROR "CMAKE_USE_SYSTEM_LIBARCHIVE is ON but LibArchive is not found!")
    ENDIF()
336
    SET(CMAKE_TAR_INCLUDES ${LibArchive_INCLUDE_DIRS})
337
    SET(CMAKE_TAR_LIBRARIES ${LibArchive_LIBRARIES})
338
  ELSE(CMAKE_USE_SYSTEM_LIBARCHIVE)
339
    SET(ZLIB_INCLUDE_DIR ${CMAKE_ZLIB_INCLUDES})
340
    SET(ZLIB_LIBRARY ${CMAKE_ZLIB_LIBRARIES})
341
    ADD_DEFINITIONS(-DLIBARCHIVE_STATIC)
342 343 344 345 346
    SET(ENABLE_NETTLE OFF CACHE INTERNAL "Enable use of Nettle")
    SET(ENABLE_OPENSSL ${CMAKE_USE_OPENSSL} CACHE INTERNAL "Enable use of OpenSSL")
    SET(ENABLE_XATTR OFF CACHE INTERNAL "Enable extended attribute support")
    SET(ENABLE_ACL OFF CACHE INTERNAL "Enable ACL support")
    SET(ENABLE_ICONV OFF CACHE INTERNAL "Enable iconv support")
347
    ADD_SUBDIRECTORY(Utilities/cmlibarchive)
348
    CMAKE_SET_TARGET_FOLDER(cmlibarchive "Utilities/3rdParty")
349 350 351
    SET(CMAKE_TAR_LIBRARIES cmlibarchive ${BZIP2_LIBRARIES})
  ENDIF(CMAKE_USE_SYSTEM_LIBARCHIVE)

352 353 354 355 356 357 358 359 360 361 362 363 364
  #---------------------------------------------------------------------
  # Build expat library for CMake and CTest.
  IF(CMAKE_USE_SYSTEM_EXPAT)
    FIND_PACKAGE(EXPAT)
    IF(NOT EXPAT_FOUND)
      MESSAGE(FATAL_ERROR
        "CMAKE_USE_SYSTEM_EXPAT is ON but a expat is not found!")
    ENDIF(NOT EXPAT_FOUND)
    SET(CMAKE_EXPAT_INCLUDES ${EXPAT_INCLUDE_DIRS})
    SET(CMAKE_EXPAT_LIBRARIES ${EXPAT_LIBRARIES})
  ELSE(CMAKE_USE_SYSTEM_EXPAT)
    SET(CMAKE_EXPAT_INCLUDES)
    SET(CMAKE_EXPAT_LIBRARIES cmexpat)
365
    ADD_SUBDIRECTORY(Utilities/cmexpat)
366
    CMAKE_SET_TARGET_FOLDER(cmexpat "Utilities/3rdParty")
367 368 369 370
  ENDIF(CMAKE_USE_SYSTEM_EXPAT)
  
  #---------------------------------------------------------------------
  # Build XMLRPC library for CMake and CTest.
371
  IF(CTEST_USE_XMLRPC)
372 373 374
    FIND_PACKAGE(XMLRPC QUIET REQUIRED libwww-client)
    IF(NOT XMLRPC_FOUND)
      MESSAGE(FATAL_ERROR
375
        "CTEST_USE_XMLRPC is ON but xmlrpc is not found!")
376 377 378
    ENDIF(NOT XMLRPC_FOUND)
    SET(CMAKE_XMLRPC_INCLUDES ${XMLRPC_INCLUDE_DIRS})
    SET(CMAKE_XMLRPC_LIBRARIES ${XMLRPC_LIBRARIES})
379
  ENDIF(CTEST_USE_XMLRPC)
380 381 382 383
  
  #---------------------------------------------------------------------
  # Use curses?
  IF (UNIX)
384 385 386 387 388 389 390 391 392 393 394
    # there is a bug in the Syllable libraries which makes linking ccmake fail, Alex
    IF(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
      SET(CURSES_NEED_NCURSES TRUE)
      FIND_PACKAGE(Curses QUIET)
      IF (CURSES_LIBRARY)
        OPTION(BUILD_CursesDialog "Build the CMake Curses Dialog ccmake" ON)
      ELSE (CURSES_LIBRARY)
        MESSAGE("Curses libraries were not found. Curses GUI for CMake will not be built.")
        SET(BUILD_CursesDialog 0)
      ENDIF (CURSES_LIBRARY)
    ELSE(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
395
      SET(BUILD_CursesDialog 0)
396
    ENDIF(NOT "${CMAKE_SYSTEM_NAME}" MATCHES syllable)
397 398 399 400
  ELSE (UNIX)
    SET(BUILD_CursesDialog 0)
  ENDIF (UNIX)
  IF(BUILD_CursesDialog)
401
    ADD_SUBDIRECTORY(Source/CursesDialog/form)
402 403 404
  ENDIF(BUILD_CursesDialog)
ENDMACRO (CMAKE_BUILD_UTILITIES)

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
#-----------------------------------------------------------------------
IF(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
  EXECUTE_PROCESS(COMMAND ${CMAKE_CXX_COMPILER}
    ${CMAKE_CXX_COMPILER_ARG1} -dumpversion
    OUTPUT_VARIABLE _GXX_VERSION
  )
  STRING(REGEX REPLACE "([0-9])\\.([0-9])(\\.[0-9])?" "\\1\\2"
    _GXX_VERSION_SHORT ${_GXX_VERSION})
  IF(_GXX_VERSION_SHORT EQUAL 33)
    MESSAGE(FATAL_ERROR
      "GXX 3.3 on OpenBSD is known to cause CPack to Crash.\n"
      "Please use GXX 4.2 or greater to build CMake on OpenBSD\n"
      "${CMAKE_CXX_COMPILER} version is: ${_GXX_VERSION}")
  ENDIF()
ENDIF()
420 421 422 423 424

#-----------------------------------------------------------------------
# The main section of the CMakeLists file
#
#-----------------------------------------------------------------------
425
# The CMake version number.
426
SET(CMake_VERSION_MAJOR 2)
Bill Hoffman's avatar
Bill Hoffman committed
427
SET(CMake_VERSION_MINOR 8)
David Cole's avatar
David Cole committed
428
SET(CMake_VERSION_PATCH 7)
429 430
#SET(CMake_VERSION_TWEAK 0)
#SET(CMake_VERSION_RC 1)
431

432 433 434
# Releases define a tweak level.
IF(DEFINED CMake_VERSION_TWEAK)
  SET(CMake_VERSION_IS_RELEASE 1)
435
  SET(CMake_VERSION_SOURCE "")
436 437 438 439
ELSE()
  SET(CMake_VERSION_IS_RELEASE 0)

  # Use the date as the tweak level.
440
  INCLUDE(${CMake_SOURCE_DIR}/Source/kwsys/kwsysDateStamp.cmake)
441
  SET(CMake_VERSION_TWEAK
442 443
    "${KWSYS_DATE_STAMP_YEAR}${KWSYS_DATE_STAMP_MONTH}${KWSYS_DATE_STAMP_DAY}"
    )
444 445

  INCLUDE(${CMake_SOURCE_DIR}/Source/CMakeVersionSource.cmake)
446
ENDIF()
447

448 449 450 451 452 453 454 455
# Compute the full version string.
SET(CMake_VERSION ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}.${CMake_VERSION_PATCH})
IF(${CMake_VERSION_TWEAK} GREATER 0)
  SET(CMake_VERSION ${CMake_VERSION}.${CMake_VERSION_TWEAK})
ENDIF()
IF(CMake_VERSION_RC)
  SET(CMake_VERSION ${CMake_VERSION}-rc${CMake_VERSION_RC})
ENDIF()
456 457 458
IF(CMake_VERSION_SOURCE)
  SET(CMake_VERSION ${CMake_VERSION}-${CMake_VERSION_SOURCE})
ENDIF()
459

460 461
# Include the standard Dart testing module
ENABLE_TESTING()
Ken Martin's avatar
Ken Martin committed
462
INCLUDE (${CMAKE_ROOT}/Modules/Dart.cmake)
463

464 465 466 467
# Set up test-time configuration.
SET_DIRECTORY_PROPERTIES(PROPERTIES
  TEST_INCLUDE_FILE "${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake")

468
# where to write the resulting executables and libraries
469
SET(BUILD_SHARED_LIBS OFF)
470
SET(EXECUTABLE_OUTPUT_PATH "" CACHE INTERNAL "No configurable exe dir.")
471 472
SET(LIBRARY_OUTPUT_PATH "" CACHE INTERNAL 
  "Where to put the libraries for CMake")
473

474
# The CMake executables usually do not need any rpath to run in the build or
475 476 477
# install tree.
SET(CMAKE_SKIP_RPATH ON CACHE INTERNAL "CMake does not need RPATHs.")

478
SET(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
479
  "Install location for data (relative to prefix).")
480
SET(CMAKE_DOC_DIR "/doc/cmake-${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}" CACHE STRING
481 482 483 484
  "Install location for documentation (relative to prefix).")
SET(CMAKE_MAN_DIR "/man" CACHE STRING
  "Install location for man pages (relative to prefix).")
MARK_AS_ADVANCED(CMAKE_DATA_DIR CMAKE_DOC_DIR CMAKE_MAN_DIR)
485 486 487 488 489 490 491 492 493 494 495
IF(CYGWIN AND EXISTS "${CMAKE_ROOT}/Modules/CPack.cmake")
  # Force doc, data and man dirs to conform to cygwin layout.
  SET(CMAKE_DOC_DIR  "/share/doc/cmake-${CMake_VERSION}")
  SET(CMAKE_DATA_DIR "/share/cmake-${CMake_VERSION}")
  SET(CMAKE_MAN_DIR  "/share/man")
  # let the user know we just forced these values
  MESSAGE(STATUS "Setup for Cygwin packaging")
  MESSAGE(STATUS "Override cache CMAKE_DOC_DIR = ${CMAKE_DOC_DIR}")
  MESSAGE(STATUS "Override cache CMAKE_DATA_DIR = ${CMAKE_DATA_DIR}")
  MESSAGE(STATUS "Override cache CMAKE_MAN_DIR = ${CMAKE_MAN_DIR}")
ENDIF()
496
STRING(REGEX REPLACE "^/" "" CMake_DATA_DEST "${CMAKE_DATA_DIR}")
497
STRING(REGEX REPLACE "^/" "" CMake_DOC_DEST "${CMAKE_DOC_DIR}")
498

499 500 501 502
IF(BUILD_TESTING)
  INCLUDE(${CMake_SOURCE_DIR}/Tests/CMakeInstall.cmake)
ENDIF()

503
# include special compile flags for some compilers
504
INCLUDE(CompileFlags.cmake)
505

506
# no clue why we are testing for this here
Andy Cedilnik's avatar
Andy Cedilnik committed
507 508 509 510
INCLUDE(CheckSymbolExists)
CHECK_SYMBOL_EXISTS(unsetenv "stdlib.h" HAVE_UNSETENV)
CHECK_SYMBOL_EXISTS(environ "stdlib.h" HAVE_ENVIRON_NOT_REQUIRE_PROTOTYPE)

511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
# CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests.
#
# If not defined or "", this variable defaults to the server at
# http://www.cdash.org/CDash.
#
# If set explicitly to "NOTFOUND", curl tests and ctest tests that use
# the network are skipped.
#
# If set to something starting with "http://localhost/", the CDash is
# expected to be an instance of CDash used for CDash testing, pointing
# to a cdash4simpletest database. In these cases, the CDash dashboards
# should be run first.
#
IF("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x")
  SET(CMAKE_TESTS_CDASH_SERVER "http://www.cdash.org/CDash")
ENDIF("x${CMAKE_TESTS_CDASH_SERVER}" STREQUAL "x")

528 529
# build the utilities (a macro defined in this file) 
CMAKE_BUILD_UTILITIES()
Ken Martin's avatar
Ken Martin committed
530

531 532 533 534 535 536 537 538
# On NetBSD ncurses is required, since curses doesn't have the wsyncup()
# function. ncurses is installed via pkgsrc, so the library is in /usr/pkg/lib,
# which isn't in the default linker search path. So without RPATH ccmake 
# doesn't run and the build doesn't succeed since ccmake is executed for
# generating the documentation.
IF(BUILD_CursesDialog)
  GET_FILENAME_COMPONENT(_CURSES_DIR "${CURSES_LIBRARY}" PATH)
  SET(CURSES_NEED_RPATH FALSE)
539
  IF(NOT "${_CURSES_DIR}" STREQUAL "/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/lib64" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib64")
540
    SET(CURSES_NEED_RPATH TRUE)
541
  ENDIF(NOT "${_CURSES_DIR}" STREQUAL "/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib" AND NOT "${_CURSES_DIR}" STREQUAL "/lib64" AND NOT "${_CURSES_DIR}" STREQUAL "/usr/lib64")
542 543
ENDIF(BUILD_CursesDialog)

544
IF(BUILD_QtDialog)
545
  IF(APPLE)
546
    SET(CMAKE_BUNDLE_NAME
547
      "CMake ${CMake_VERSION_MAJOR}.${CMake_VERSION_MINOR}-${CMake_VERSION_PATCH}")
548
    SET(CMAKE_BUNDLE_LOCATION "${CMAKE_INSTALL_PREFIX}")
549 550 551 552 553 554 555
    # make sure CMAKE_INSTALL_PREFIX ends in /
    STRING(LENGTH "${CMAKE_INSTALL_PREFIX}" LEN)
    MATH(EXPR LEN "${LEN} -1" )
    STRING(SUBSTRING "${CMAKE_INSTALL_PREFIX}" ${LEN} 1 ENDCH)
    IF(NOT "${ENDCH}" STREQUAL "/")
      SET(CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}/")
    ENDIF(NOT "${ENDCH}" STREQUAL "/")
556 557
    SET(CMAKE_INSTALL_PREFIX 
      "${CMAKE_INSTALL_PREFIX}${CMAKE_BUNDLE_NAME}.app/Contents")
558 559
  ENDIF(APPLE)
  
560 561 562 563 564 565 566
  SET(QT_NEED_RPATH FALSE)
  IF(NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib64" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib64")
    SET(QT_NEED_RPATH TRUE)
  ENDIF(NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/lib64" AND NOT "${QT_LIBRARY_DIR}" STREQUAL "/usr/lib64")
ENDIF(BUILD_QtDialog)


567
# The same might be true on other systems for other libraries.
568 569 570 571
# Then only enable RPATH if we have are building at least with cmake 2.4, 
# since this one has much better RPATH features than cmake 2.2.
# The executables are then built with the RPATH for the libraries outside
# the build tree, which is both the build and the install RPATH.
572
IF (UNIX)
573
  IF(   CMAKE_USE_SYSTEM_CURL   OR  CMAKE_USE_SYSTEM_ZLIB
574
        OR  CMAKE_USE_SYSTEM_EXPAT  OR  CTEST_USE_XMLRPC  OR  CURSES_NEED_RPATH  OR  QT_NEED_RPATH)
575 576 577 578
    SET(CMAKE_SKIP_RPATH OFF CACHE INTERNAL "CMake built with RPATH.")
    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)
    SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
  ENDIF(CMAKE_USE_SYSTEM_CURL   OR  CMAKE_USE_SYSTEM_ZLIB
579
        OR  CMAKE_USE_SYSTEM_EXPAT  OR  CTEST_USE_XMLRPC  OR  CURSES_NEED_RPATH  OR  QT_NEED_RPATH)
580
ENDIF (UNIX)
581 582


583
# add the uninstall support
584 585 586
CONFIGURE_FILE(
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in"
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
587
  @ONLY)
588 589
ADD_CUSTOM_TARGET(uninstall
  "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
590

591
INCLUDE (CMakeCPack.cmake)
592

593 594
# setup some Testing support (a macro defined in this file)
CMAKE_SETUP_TESTING()
595 596 597 598
CONFIGURE_FILE(
  "${CMAKE_CURRENT_SOURCE_DIR}/DartLocal.conf.in"
  "${CMAKE_CURRENT_BINARY_DIR}/DartLocal.conf"
  COPYONLY)
599

600 601 602 603 604
OPTION(CMAKE_STRICT   
  "Perform strict testing to record property and variable access. Can be used to report any undefined properties or variables" OFF)
MARK_AS_ADVANCED(CMAKE_STRICT)


605
# build the remaining subdirectories
606 607 608
ADD_SUBDIRECTORY(Source)
ADD_SUBDIRECTORY(Utilities)
ADD_SUBDIRECTORY(Tests)
609

610 611 612
if(BUILD_TESTING)
  CMAKE_SET_TARGET_FOLDER(CMakeLibTests "Tests")
endif()
613 614 615
CMAKE_SET_TARGET_FOLDER(cmw9xcom "Utilities/Win9xCompat")
CMAKE_SET_TARGET_FOLDER(documentation "Documentation")

616 617 618
# add a test
ADD_TEST(SystemInformationNew "${CMAKE_CMAKE_COMMAND}" 
  --system-information  -G "${CMAKE_TEST_GENERATOR}" )
619

Brad King's avatar
Brad King committed
620 621 622
# Install license file as it requires.
INSTALL(FILES Copyright.txt DESTINATION ${CMake_DOC_DEST})

623 624 625 626 627 628 629 630
# Install script directories.
INSTALL(
  DIRECTORY Modules Templates
  DESTINATION "${CMake_DATA_DEST}"
  FILE_PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ
  DIRECTORY_PERMISSIONS OWNER_READ OWNER_EXECUTE OWNER_WRITE
                        GROUP_READ GROUP_EXECUTE
                        WORLD_READ WORLD_EXECUTE
631 632 633
  PATTERN "*.sh*" PERMISSIONS OWNER_READ OWNER_EXECUTE OWNER_WRITE
                              GROUP_READ GROUP_EXECUTE
                              WORLD_READ WORLD_EXECUTE
634 635
  )

636 637 638
#-----------------------------------------------------------------------
# End of the main section of the CMakeLists file
#-----------------------------------------------------------------------
639 640 641 642 643 644 645

# As a special case when building CMake itself, CMake 2.8.0 and below
# look up EXECUTABLE_OUTPUT_PATH in the top-level CMakeLists.txt file
# to compute the location of the "cmake" executable.  We set it here
# so that those CMake versions can find it.  We wait until after all
# the add_subdirectory() calls to avoid affecting the subdirectories.
SET(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})