CMakeLists.txt 47.1 KB
Newer Older
Kitware Robot's avatar
Kitware Robot committed
1 2
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing#kwsys for details.
Kitware Robot's avatar
Kitware Robot committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# The Kitware System Library is intended to be included in other
# projects.  It is completely configurable in that the library's
# namespace can be configured and the components that are included can
# be selected invididually.

# Typical usage is to import the kwsys directory tree into a
# subdirectory under a parent project and enable the classes that will
# be used.  All classes are disabled by default.  The CMake listfile
# above this one configures the library as follows:
#
#  SET(KWSYS_NAMESPACE foosys)
#  SET(KWSYS_USE_Directory 1)    # Enable Directory class.
#  SUBDIRS(kwsys)
#
# Optional settings are as follows:
#
#  KWSYS_HEADER_ROOT = The directory into which to generate the kwsys headers.
#                      A directory called "${KWSYS_NAMESPACE}" will be
#                      created under this root directory to hold the files.
Kitware Robot's avatar
Kitware Robot committed
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
#  KWSYS_SPLIT_OBJECTS_FROM_INTERFACE
#                    = Instead of creating a single ${KWSYS_NAMESPACE} library
#                      target, create three separate targets:
#                        ${KWSYS_NAMESPACE}
#                          - An INTERFACE library only containing usage
#                            requirements.
#                        ${KWSYS_NAMESPACE}_objects
#                          - An OBJECT library for the built kwsys objects.
#                            Note: This is omitted from the install rules
#                        ${KWSYS_NAMESPACE}_private
#                          - An INTERFACE library combining both that is
#                            appropriate for use with PRIVATE linking in
#                            target_link_libraries. Because of how interface
#                            properties propagate, this target is not suitable
#                            for use with PUBLIC or INTERFACE linking.
Kitware Robot's avatar
Kitware Robot committed
38
#  KWSYS_ALIAS_TARGET = The name of an alias target to create to the actual target.
Kitware Robot's avatar
Kitware Robot committed
39 40 41 42 43 44
#
#    Example:
#
#      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
#      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
#
Kitware Robot's avatar
Kitware Robot committed
45 46 47 48
#  KWSYS_CXX_STANDARD         = A value for CMAKE_CXX_STANDARD within KWSys.
#                               Set to empty string to use no default value.
#  KWSYS_CXX_COMPILE_FEATURES = target_compile_features arguments for KWSys.
#
Kitware Robot's avatar
Kitware Robot committed
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 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
# Optional settings to setup install rules are as follows:
#
#  KWSYS_INSTALL_BIN_DIR     = The installation target directories into
#  KWSYS_INSTALL_LIB_DIR       which the libraries and headers from
#  KWSYS_INSTALL_INCLUDE_DIR   kwsys should be installed by a "make install".
#                              The values should be specified relative to
#                              the installation prefix and NOT start with '/'.
#  KWSYS_INSTALL_DOC_DIR     = The installation target directory for documentation
#                              such as copyright information.
#
#  KWSYS_INSTALL_COMPONENT_NAME_RUNTIME     = Name of runtime and development
#  KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT   installation components.
#                                             If not given the install rules
#                                             will not be in any component.
#
#  KWSYS_INSTALL_EXPORT_NAME = The EXPORT option value for install(TARGETS) calls.
#
#    Example:
#
#      SET(KWSYS_INSTALL_BIN_DIR bin)
#      SET(KWSYS_INSTALL_LIB_DIR lib)
#      SET(KWSYS_INSTALL_INCLUDE_DIR include)
#      SET(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME Runtime)
#      SET(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT Development)

# Once configured, kwsys should be used as follows from C or C++ code:
#
#  #include <foosys/Directory.hxx>
#   ...
#  foosys::Directory directory;
#

# NOTE: This library is intended for internal use by Kitware-driven
# projects.  In order to keep it simple no attempt will be made to
# maintain backward compatibility when changes are made to KWSys.
# When an incompatible change is made Kitware's projects that use
# KWSys will be fixed, but no notification will necessarily be sent to
# any outside mailing list and no documentation of the change will be
# written.

Kitware Robot's avatar
Kitware Robot committed
89
CMAKE_MINIMUM_REQUIRED(VERSION 3.1 FATAL_ERROR)
Kitware Robot's avatar
Kitware Robot committed
90 91 92
FOREACH(p
    CMP0056 # CMake 3.2, Honor link flags in try_compile() source-file signature.
    CMP0063 # CMake 3.3, Honor visibility properties for all target types.
Kitware Robot's avatar
Kitware Robot committed
93
    CMP0067 # CMake 3.8, Honor language standard in try_compile source-file signature.
Kitware Robot's avatar
Kitware Robot committed
94
    CMP0069 # CMake 3.9, INTERPROCEDURAL_OPTIMIZATION is enforced when enabled.
Kitware Robot's avatar
Kitware Robot committed
95 96 97 98 99
    )
  IF(POLICY ${p})
    CMAKE_POLICY(SET ${p} NEW)
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
100

Kitware Robot's avatar
Kitware Robot committed
101 102 103 104 105 106 107
#-----------------------------------------------------------------------------
# If a namespace is not specified, use "kwsys" and enable testing.
# This should be the case only when kwsys is not included inside
# another project and is being tested.
IF(NOT KWSYS_NAMESPACE)
  SET(KWSYS_NAMESPACE "kwsys")
  SET(KWSYS_STANDALONE 1)
Kitware Robot's avatar
Kitware Robot committed
108
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
109 110 111 112 113 114 115 116 117 118 119

#-----------------------------------------------------------------------------
# The project name is that of the specified namespace.
PROJECT(${KWSYS_NAMESPACE})

# Tell CMake how to follow dependencies of sources in this directory.
SET_PROPERTY(DIRECTORY
  PROPERTY IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
  "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>"
  )

Kitware Robot's avatar
Kitware Robot committed
120 121 122 123 124 125
if(KWSYS_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD "${KWSYS_CXX_STANDARD}")
elseif(NOT DEFINED CMAKE_CXX_STANDARD AND NOT DEFINED KWSYS_CXX_STANDARD)
  set(CMAKE_CXX_STANDARD 11)
endif()

Kitware Robot's avatar
Kitware Robot committed
126 127 128 129 130 131 132
# Select library components.
IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
  SET(KWSYS_ENABLE_C 1)
  # Enable all components.
  SET(KWSYS_USE_Base64 1)
  SET(KWSYS_USE_Directory 1)
  SET(KWSYS_USE_DynamicLoader 1)
Kitware Robot's avatar
Kitware Robot committed
133
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
134 135 136 137 138 139 140 141 142
  SET(KWSYS_USE_Glob 1)
  SET(KWSYS_USE_MD5 1)
  SET(KWSYS_USE_Process 1)
  SET(KWSYS_USE_RegularExpression 1)
  SET(KWSYS_USE_System 1)
  SET(KWSYS_USE_SystemTools 1)
  SET(KWSYS_USE_CommandLineArguments 1)
  SET(KWSYS_USE_Terminal 1)
  SET(KWSYS_USE_IOStream 1)
Kitware Robot's avatar
Kitware Robot committed
143
  SET(KWSYS_USE_FStream 1)
Kitware Robot's avatar
Kitware Robot committed
144 145
  SET(KWSYS_USE_String 1)
  SET(KWSYS_USE_SystemInformation 1)
Kitware Robot's avatar
Kitware Robot committed
146
  SET(KWSYS_USE_ConsoleBuf 1)
Kitware Robot's avatar
Kitware Robot committed
147
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
148 149 150 151

# Enforce component dependencies.
IF(KWSYS_USE_SystemTools)
  SET(KWSYS_USE_Directory 1)
Kitware Robot's avatar
Kitware Robot committed
152 153
  SET(KWSYS_USE_FStream 1)
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
154
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
155 156 157 158
IF(KWSYS_USE_Glob)
  SET(KWSYS_USE_Directory 1)
  SET(KWSYS_USE_SystemTools 1)
  SET(KWSYS_USE_RegularExpression 1)
Kitware Robot's avatar
Kitware Robot committed
159 160
  SET(KWSYS_USE_FStream 1)
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
161
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
162 163
IF(KWSYS_USE_Process)
  SET(KWSYS_USE_System 1)
Kitware Robot's avatar
Kitware Robot committed
164
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
165
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
166 167
IF(KWSYS_USE_SystemInformation)
  SET(KWSYS_USE_Process 1)
Kitware Robot's avatar
Kitware Robot committed
168
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
169 170
IF(KWSYS_USE_System)
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
171
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
172 173
IF(KWSYS_USE_Directory)
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
174
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
175 176
IF(KWSYS_USE_FStream)
  SET(KWSYS_USE_Encoding 1)
Kitware Robot's avatar
Kitware Robot committed
177
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
178 179 180
IF(KWSYS_USE_ConsoleBuf)
  SET(KWSYS_USE_Encoding 1)
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
181 182 183 184

# Setup the large file support default.
IF(KWSYS_LFS_DISABLE)
  SET(KWSYS_LFS_REQUESTED 0)
Kitware Robot's avatar
Kitware Robot committed
185
ELSE()
Kitware Robot's avatar
Kitware Robot committed
186
  SET(KWSYS_LFS_REQUESTED 1)
Kitware Robot's avatar
Kitware Robot committed
187
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
188

Kitware Robot's avatar
Kitware Robot committed
189 190 191
# Specify default 8 bit encoding for Windows
IF(NOT KWSYS_ENCODING_DEFAULT_CODEPAGE)
  SET(KWSYS_ENCODING_DEFAULT_CODEPAGE CP_ACP)
Kitware Robot's avatar
Kitware Robot committed
192
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
193

Kitware Robot's avatar
Kitware Robot committed
194 195 196 197 198 199
# Enable testing if building standalone.
IF(KWSYS_STANDALONE)
  INCLUDE(Dart)
  MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
  IF(BUILD_TESTING)
    ENABLE_TESTING()
Kitware Robot's avatar
Kitware Robot committed
200 201
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
202

Kitware Robot's avatar
Kitware Robot committed
203 204 205 206 207
# Choose default shared/static build if not specified.
IF(NOT DEFINED KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
208 209 210 211 212 213 214 215 216 217 218 219 220 221
# Include helper macros.
INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
INCLUDE(CheckTypeSize)

# Do full dependency headers.
INCLUDE_REGULAR_EXPRESSION("^.*$")

# Use new KWSYS_INSTALL_*_DIR variable names to control installation.
# Take defaults from the old names.  Note that there was no old name
# for the bin dir, so we take the old lib dir name so DLLs will be
# installed in a compatible way for old code.
IF(NOT KWSYS_INSTALL_INCLUDE_DIR)
  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
    "${KWSYS_HEADER_INSTALL_DIR}")
Kitware Robot's avatar
Kitware Robot committed
222
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
223 224 225
IF(NOT KWSYS_INSTALL_LIB_DIR)
  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
    "${KWSYS_LIBRARY_INSTALL_DIR}")
Kitware Robot's avatar
Kitware Robot committed
226
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
227 228 229
IF(NOT KWSYS_INSTALL_BIN_DIR)
  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
    "${KWSYS_LIBRARY_INSTALL_DIR}")
Kitware Robot's avatar
Kitware Robot committed
230
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
231 232 233 234 235 236 237

# Setup header install rules.
SET(KWSYS_INSTALL_INCLUDE_OPTIONS)
IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
  SET(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
    COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
    )
Kitware Robot's avatar
Kitware Robot committed
238
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
239 240 241

# Setup library install rules.
SET(KWSYS_INSTALL_LIBRARY_RULE)
Kitware Robot's avatar
Kitware Robot committed
242
SET(KWSYS_INSTALL_NAMELINK_RULE)
Kitware Robot's avatar
Kitware Robot committed
243 244 245 246 247 248
IF(KWSYS_INSTALL_LIB_DIR)
  IF(KWSYS_INSTALL_EXPORT_NAME)
    LIST(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
  ENDIF()
  # Install the shared library to the lib directory.
  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
Kitware Robot's avatar
Kitware Robot committed
249
    LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_SKIP
Kitware Robot's avatar
Kitware Robot committed
250 251 252 253 254 255
    )
  # Assign the shared library to the runtime component.
  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
      )
Kitware Robot's avatar
Kitware Robot committed
256
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
257 258 259 260 261 262 263 264 265 266 267
  IF(KWSYS_BUILD_SHARED)
    SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
      LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_ONLY
      )
    # Assign the namelink to the development component.
    IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
      SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
        )
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
268 269 270 271 272 273 274 275 276 277

  # Install the archive to the lib directory.
  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
    ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
    )
  # Assign the archive to the development component.
  IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
      )
Kitware Robot's avatar
Kitware Robot committed
278 279
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
280 281 282 283 284 285 286 287 288 289
IF(KWSYS_INSTALL_BIN_DIR)
  # Install the runtime library to the bin directory.
  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
    RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
    )
  # Assign the runtime library to the runtime component.
  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
      )
Kitware Robot's avatar
Kitware Robot committed
290 291
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
292 293 294 295 296 297 298 299 300 301

# Do not support old KWSYS_*a_INSTALL_DIR variable names.
SET(KWSYS_HEADER_INSTALL_DIR)
SET(KWSYS_LIBRARY_INSTALL_DIR)

# Generated source files will need this header.
STRING(COMPARE EQUAL "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}"
  KWSYS_IN_SOURCE_BUILD)
IF(NOT KWSYS_IN_SOURCE_BUILD)
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsysPrivate.h
Kitware Robot's avatar
Kitware Robot committed
302
    ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPYONLY IMMEDIATE)
Kitware Robot's avatar
Kitware Robot committed
303
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
304 305 306 307 308 309 310 311 312 313 314 315 316

# Select plugin module file name convention.
IF(NOT KWSYS_DynamicLoader_PREFIX)
  SET(KWSYS_DynamicLoader_PREFIX ${CMAKE_SHARED_MODULE_PREFIX})
ENDIF()
IF(NOT KWSYS_DynamicLoader_SUFFIX)
  SET(KWSYS_DynamicLoader_SUFFIX ${CMAKE_SHARED_MODULE_SUFFIX})
ENDIF()

#-----------------------------------------------------------------------------
# We require ANSI support from the C compiler.  Add any needed flags.
IF(CMAKE_ANSI_CFLAGS)
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
Kitware Robot's avatar
Kitware Robot committed
317
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
318 319 320 321 322 323 324 325 326 327 328

#-----------------------------------------------------------------------------
# Adjust compiler flags for some platforms.
IF(NOT CMAKE_COMPILER_IS_GNUCXX)
  IF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
    STRING(REGEX MATCH "-timplicit_local"
      KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL "${CMAKE_CXX_FLAGS}")
    STRING(REGEX MATCH "-no_implicit_include"
      KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE "${CMAKE_CXX_FLAGS}")
    IF(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local")
Kitware Robot's avatar
Kitware Robot committed
329
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
330 331
    IF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
Kitware Robot's avatar
Kitware Robot committed
332 333
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
334 335
  IF(CMAKE_SYSTEM MATCHES "HP-UX")
    SET(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
Kitware Robot's avatar
Kitware Robot committed
336 337 338 339 340 341 342
    IF(CMAKE_CXX_COMPILER_ID MATCHES "HP")
      # it is known that version 3.85 fails and 6.25 works without these flags
      IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4)
        # use new C++ library and improved template support
        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -AA +hpxstd98")
      ENDIF()
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
343 344
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
345 346 347 348 349 350 351 352 353
IF(KWSYS_STANDALONE)
  IF(CMAKE_CXX_COMPILER_ID STREQUAL SunPro)
    IF(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++03")
    ELSE()
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stlport4")
    ENDIF()
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372

#-----------------------------------------------------------------------------
# Configure Large File Support.
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDIO
  "Checking whether header cstdio is available" DIRECT)
SET(KWSYS_LFS_AVAILABLE 0)
IF(KWSYS_LFS_REQUESTED)
  # Large File Support is requested.
  SET(KWSYS_LFS_REQUESTED 1)

  # Check for large file support.
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
    -DKWSYS_CXX_HAS_CSTDIO=${KWSYS_CXX_HAS_CSTDIO})
  KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_LFS_WORKS
    "Checking for Large File Support" DIRECT)
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)

  IF(KWSYS_LFS_WORKS)
    SET(KWSYS_LFS_AVAILABLE 1)
Kitware Robot's avatar
Kitware Robot committed
373 374
  ENDIF()
ELSE()
Kitware Robot's avatar
Kitware Robot committed
375 376
  # Large File Support is not requested.
  SET(KWSYS_LFS_REQUESTED 0)
Kitware Robot's avatar
Kitware Robot committed
377
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416

#-----------------------------------------------------------------------------
# Configure the standard library header wrappers based on compiler's
# capabilities and parent project's request.  Enforce 0/1 as only
# possible values for configuration into Configure.hxx.

# Check existence and uniqueness of long long and __int64.
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_LONG_LONG
  "Checking whether C++ compiler has 'long long'" DIRECT)
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS___INT64
  "Checking whether C++ compiler has '__int64'" DIRECT)
IF(KWSYS_CXX_HAS___INT64)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_AND___INT64
    "Checking whether long and __int64 are the same type" DIRECT)
  IF(KWSYS_CXX_HAS_LONG_LONG)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_LONG_AND___INT64
      "Checking whether long long and __int64 are the same type" DIRECT)
  ENDIF()
ENDIF()

# Enable the "long long" type if it is available.  It is standard in
# C99 and C++03 but not in earlier standards.
IF(KWSYS_CXX_HAS_LONG_LONG)
  SET(KWSYS_USE_LONG_LONG 1)
ELSE()
  SET(KWSYS_USE_LONG_LONG 0)
ENDIF()

# Enable the "__int64" type if it is available and unique.  It is not
# standard.
SET(KWSYS_USE___INT64 0)
IF(KWSYS_CXX_HAS___INT64)
  IF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
    IF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
      SET(KWSYS_USE___INT64 1)
    ENDIF()
  ENDIF()
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
417 418 419 420
IF(KWSYS_USE_Encoding)
  # Look for type size helper macros.
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_WSTRING
    "Checking whether wstring is available" DIRECT)
Kitware Robot's avatar
Kitware Robot committed
421
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
422

Kitware Robot's avatar
Kitware Robot committed
423 424 425 426 427 428 429 430 431 432 433
IF(KWSYS_USE_IOStream)
  # Determine whether iostreams support long long.
  IF(KWSYS_CXX_HAS_LONG_LONG)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM_LONG_LONG
      "Checking if istream supports long long" DIRECT)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_OSTREAM_LONG_LONG
      "Checking if ostream supports long long" DIRECT)
  ELSE()
    SET(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
    SET(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
434 435 436 437 438 439 440 441 442
  IF(KWSYS_CXX_HAS___INT64)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM___INT64
      "Checking if istream supports __int64" DIRECT)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_OSTREAM___INT64
      "Checking if ostream supports __int64" DIRECT)
  ELSE()
    SET(KWSYS_IOS_HAS_ISTREAM___INT64 0)
    SET(KWSYS_IOS_HAS_OSTREAM___INT64 0)
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
443
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
444 445 446

IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
  SET(KWSYS_NAME_IS_KWSYS 1)
Kitware Robot's avatar
Kitware Robot committed
447
ELSE()
Kitware Robot's avatar
Kitware Robot committed
448
  SET(KWSYS_NAME_IS_KWSYS 0)
Kitware Robot's avatar
Kitware Robot committed
449
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
450 451 452 453

IF(KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED 1)
  SET(KWSYS_LIBRARY_TYPE SHARED)
Kitware Robot's avatar
Kitware Robot committed
454
ELSE()
Kitware Robot's avatar
Kitware Robot committed
455 456
  SET(KWSYS_BUILD_SHARED 0)
  SET(KWSYS_LIBRARY_TYPE STATIC)
Kitware Robot's avatar
Kitware Robot committed
457
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
458

Kitware Robot's avatar
Kitware Robot committed
459 460 461 462
if(NOT DEFINED KWSYS_BUILD_PIC)
  set(KWSYS_BUILD_PIC 0)
endif()

Kitware Robot's avatar
Kitware Robot committed
463 464 465 466 467 468 469
#-----------------------------------------------------------------------------
# Configure some implementation details.

KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_PTRDIFF_T
  "Checking whether C compiler has ptrdiff_t in stddef.h" DIRECT)
KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_SSIZE_T
  "Checking whether C compiler has ssize_t in unistd.h" DIRECT)
Kitware Robot's avatar
Kitware Robot committed
470 471 472 473 474
IF(KWSYS_USE_Process)
  KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC
    "Checking whether C compiler has clock_gettime" DIRECT)
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
475
SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c System.c PROPERTIES
Kitware Robot's avatar
Kitware Robot committed
476
  COMPILE_FLAGS "-DKWSYS_C_HAS_PTRDIFF_T=${KWSYS_C_HAS_PTRDIFF_T} -DKWSYS_C_HAS_SSIZE_T=${KWSYS_C_HAS_SSIZE_T} -DKWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC=${KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC}"
Kitware Robot's avatar
Kitware Robot committed
477 478
  )

Kitware Robot's avatar
Kitware Robot committed
479 480 481 482 483
IF(DEFINED KWSYS_PROCESS_USE_SELECT)
  GET_PROPERTY(ProcessUNIX_FLAGS SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS)
  SET_PROPERTY(SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS "${ProcessUNIX_FLAGS} -DKWSYSPE_USE_SELECT=${KWSYSPE_USE_SELECT}")
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
484 485 486 487 488 489 490 491 492 493 494
IF(KWSYS_USE_DynamicLoader)
  GET_PROPERTY(KWSYS_SUPPORTS_SHARED_LIBS GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
  IF(KWSYS_SUPPORTS_SHARED_LIBS)
    SET(KWSYS_SUPPORTS_SHARED_LIBS 1)
  ELSE()
    SET(KWSYS_SUPPORTS_SHARED_LIBS 0)
  ENDIF()
  SET_PROPERTY(SOURCE DynamicLoader.cxx APPEND PROPERTY COMPILE_DEFINITIONS
    KWSYS_SUPPORTS_SHARED_LIBS=${KWSYS_SUPPORTS_SHARED_LIBS})
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
495 496 497 498 499 500 501
IF(KWSYS_USE_SystemTools)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_SETENV
    "Checking whether CXX compiler has setenv" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UNSETENV
    "Checking whether CXX compiler has unsetenv" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H
    "Checking whether CXX compiler has environ in stdlib.h" DIRECT)
Kitware Robot's avatar
Kitware Robot committed
502 503 504 505
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMES
    "Checking whether CXX compiler has utimes" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UTIMENSAT
    "Checking whether CXX compiler has utimensat" DIRECT)
Kitware Robot's avatar
Kitware Robot committed
506 507 508 509
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIM
    "Checking whether CXX compiler struct stat has st_mtim member" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
    "Checking whether CXX compiler struct stat has st_mtimespec member" DIRECT)
Kitware Robot's avatar
Kitware Robot committed
510 511 512 513 514 515
  SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
    KWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV}
    KWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV}
    KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H}
    KWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES}
    KWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT}
Kitware Robot's avatar
Kitware Robot committed
516 517
    KWSYS_CXX_STAT_HAS_ST_MTIM=${KWSYS_CXX_STAT_HAS_ST_MTIM}
    KWSYS_CXX_STAT_HAS_ST_MTIMESPEC=${KWSYS_CXX_STAT_HAS_ST_MTIMESPEC}
Kitware Robot's avatar
Kitware Robot committed
518
    )
Kitware Robot's avatar
Kitware Robot committed
519 520 521 522 523 524 525 526 527 528
  IF(NOT WIN32)
    IF(KWSYS_STANDALONE)
      OPTION(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES "If true, Windows paths will be supported on Unix as well" ON)
    ENDIF()
    IF(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES)
      SET_PROPERTY(SOURCE SystemTools.cxx testSystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
        KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES
        )
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
529 530 531 532 533 534 535 536

  # Disable getpwnam for static linux builds since it depends on shared glibc
  GET_PROPERTY(SHARED_LIBS_SUPPORTED GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
  IF(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT SHARED_LIBS_SUPPORTED)
    SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
      HAVE_GETPWNAM=0
      )
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
537 538 539
ENDIF()

IF(KWSYS_USE_SystemInformation)
Kitware Robot's avatar
Kitware Robot committed
540 541
  SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
    COMPILE_DEFINITIONS SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P})
Kitware Robot's avatar
Kitware Robot committed
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
  IF(NOT CYGWIN)
    INCLUDE(CheckIncludeFiles)
    CHECK_INCLUDE_FILES("sys/types.h;ifaddrs.h" KWSYS_SYS_HAS_IFADDRS_H)
    IF(KWSYS_SYS_HAS_IFADDRS_H)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_IFADDRS_H=1)
    ENDIF()
  ENDIF()
  IF(WIN32)
    INCLUDE(CheckSymbolExists)
    SET(CMAKE_REQUIRED_LIBRARIES Psapi)
    CHECK_SYMBOL_EXISTS(GetProcessMemoryInfo "windows.h;psapi.h" KWSYS_SYS_HAS_PSAPI)
    UNSET(CMAKE_REQUIRED_LIBRARIES)
    IF(KWSYS_SYS_HAS_PSAPI)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_PSAPI=1)
      IF(MSVC70 OR MSVC71)
        # Suppress LNK4089: all references to 'PSAPI.DLL' discarded by /OPT:REF
        SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /IGNORE:4089")
      ENDIF()
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
564 565 566 567 568 569 570
  IF(CMAKE_SYSTEM MATCHES "HP-UX")
    CHECK_INCLUDE_FILES("sys/mpctl.h" KWSYS_SYS_HAS_MPCTL_H)
    IF(KWSYS_SYS_HAS_MPCTL_H)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_MPCTL_H=1)
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
571 572 573 574 575 576 577
  IF(CMAKE_SYSTEM MATCHES "BSD")
    CHECK_INCLUDE_FILES("machine/cpu.h" KWSYS_SYS_HAS_MACHINE_CPU_H)
    IF(KWSYS_SYS_HAS_MACHINE_CPU_H)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_MACHINE_CPU_H=1)
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
  IF(KWSYS_LFS_AVAILABLE AND NOT KWSYS_LFS_DISABLE)
    SET(KWSYS_PLATFORM_CXX_TEST_DEFINES -DKWSYS_HAS_LFS=1)
  ENDIF()
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_RLIMIT64
    "Checking whether CXX compiler has rlimit64" DIRECT)
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
  IF(KWSYS_CXX_HAS_RLIMIT64)
    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_CXX_HAS_RLIMIT64=1)
  ENDIF()
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ATOL
    "Checking whether CXX compiler has atol" DIRECT)
  IF(KWSYS_CXX_HAS_ATOL)
    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_CXX_HAS_ATOL=1)
  ENDIF()
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ATOLL
    "Checking whether CXX compiler has atoll" DIRECT)
  IF(KWSYS_CXX_HAS_ATOLL)
    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_CXX_HAS_ATOLL=1)
  ENDIF()
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS__ATOI64
    "Checking whether CXX compiler has _atoi64" DIRECT)
  IF(KWSYS_CXX_HAS__ATOI64)
    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_CXX_HAS__ATOI64=1)
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
606 607 608 609 610 611
  IF(UNIX)
    INCLUDE(CheckIncludeFileCXX)
    # check for simple stack trace
    # usually it's in libc but on FreeBSD
    # it's in libexecinfo
    FIND_LIBRARY(EXECINFO_LIB "execinfo")
Kitware Robot's avatar
Kitware Robot committed
612
    MARK_AS_ADVANCED(EXECINFO_LIB)
Kitware Robot's avatar
Kitware Robot committed
613 614 615 616 617 618
    IF (NOT EXECINFO_LIB)
      SET(EXECINFO_LIB "")
    ENDIF()
    CHECK_INCLUDE_FILE_CXX("execinfo.h" KWSYS_CXX_HAS_EXECINFOH)
    IF (KWSYS_CXX_HAS_EXECINFOH)
      # we have the backtrace header check if it
Kitware Robot's avatar
Kitware Robot committed
619
      # can be used with this compiler
Kitware Robot's avatar
Kitware Robot committed
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
      SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${EXECINFO_LIB})
      KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BACKTRACE
         "Checking whether backtrace works with this C++ compiler" DIRECT)
      SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
      IF (KWSYS_CXX_HAS_BACKTRACE)
        # backtrace is supported by this system and compiler.
        # now check for the more advanced capabilities.
        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
          COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE=1)
        # check for symbol lookup using dladdr
        CHECK_INCLUDE_FILE_CXX("dlfcn.h" KWSYS_CXX_HAS_DLFCNH)
        IF (KWSYS_CXX_HAS_DLFCNH)
          # we have symbol lookup libraries and headers
          # check if they can be used with this compiler
          SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${CMAKE_DL_LIBS})
            KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_DLADDR
            "Checking whether dladdr works with this C++ compiler" DIRECT)
          SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
          IF (KWSYS_CXX_HAS_DLADDR)
            # symbol lookup is supported by this system
            # and compiler.
            SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
              COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP=1)
          ENDIF()
        ENDIF()
        # c++ demangling support
        # check for cxxabi headers
        CHECK_INCLUDE_FILE_CXX("cxxabi.h" KWSYS_CXX_HAS_CXXABIH)
        IF (KWSYS_CXX_HAS_CXXABIH)
          # check if cxxabi can be used with this
          # system and compiler.
          KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CXXABI
            "Checking whether cxxabi works with this C++ compiler" DIRECT)
          IF (KWSYS_CXX_HAS_CXXABI)
            # c++ demangle using cxxabi is supported with
            # this system and compiler
            SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
              COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE=1)
          ENDIF()
        ENDIF()
        # basic backtrace works better with release build
        # don't bother with advanced features for release
        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
          COMPILE_DEFINITIONS_DEBUG KWSYS_SYSTEMINFORMATION_HAS_DEBUG_BUILD=1)
        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
          COMPILE_DEFINITIONS_RELWITHDEBINFO KWSYS_SYSTEMINFORMATION_HAS_DEBUG_BUILD=1)
      ENDIF()
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
669 670 671 672 673 674 675 676 677 678 679 680 681 682
  IF(BORLAND)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BORLAND_ASM
      "Checking whether Borland CXX compiler supports assembler instructions" DIRECT)
    IF(KWSYS_CXX_HAS_BORLAND_ASM)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_CXX_HAS_BORLAND_ASM=1)
      KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BORLAND_ASM_CPUID
        "Checking whether Borland CXX compiler supports CPUID assembler instruction" DIRECT)
      IF(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
          COMPILE_DEFINITIONS KWSYS_CXX_HAS_BORLAND_ASM_CPUID=1)
      ENDIF()
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
  IF(KWSYS_USE___INT64)
    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_USE___INT64=1)
  ENDIF()
  IF(KWSYS_USE_LONG_LONG)
    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_USE_LONG_LONG=1)
  ENDIF()
  IF(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_IOS_HAS_OSTREAM_LONG_LONG=1)
  ENDIF()
  IF(KWSYS_IOS_HAS_OSTREAM___INT64)
    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_IOS_HAS_OSTREAM___INT64=1)
  ENDIF()
  IF(KWSYS_BUILD_SHARED)
    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
      COMPILE_DEFINITIONS KWSYS_BUILD_SHARED=1)
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
703 704 705 706 707 708 709 710 711

  IF(UNIX AND NOT CYGWIN)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_GETLOADAVG
      "Checking whether CXX compiler has getloadavg" DIRECT)
    IF(KWSYS_CXX_HAS_GETLOADAVG)
      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
        COMPILE_DEFINITIONS KWSYS_CXX_HAS_GETLOADAVG=1)
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
712 713
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
714 715 716 717 718
IF(KWSYS_USE_FStream)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H
    "Checking whether <ext/stdio_filebuf.h> is available" DIRECT)
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
719 720 721 722
#-----------------------------------------------------------------------------
# Choose a directory for the generated headers.
IF(NOT KWSYS_HEADER_ROOT)
  SET(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
Kitware Robot's avatar
Kitware Robot committed
723
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
724 725 726 727 728 729 730 731 732 733 734
SET(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
INCLUDE_DIRECTORIES(${KWSYS_HEADER_ROOT})

#-----------------------------------------------------------------------------
IF(KWSYS_INSTALL_DOC_DIR)
  # Assign the license to the runtime component since it must be
  # distributed with binary forms of this software.
  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
    SET(KWSYS_INSTALL_LICENSE_OPTIONS ${KWSYS_INSTALL_LICENSE_OPTIONS}
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
      )
Kitware Robot's avatar
Kitware Robot committed
735
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
736 737 738 739 740

  # Install the license under the documentation directory.
  INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt
    DESTINATION ${KWSYS_INSTALL_DOC_DIR}/${KWSYS_NAMESPACE}
    ${KWSYS_INSTALL_LICENSE_OPTIONS})
Kitware Robot's avatar
Kitware Robot committed
741
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
742 743 744 745 746 747

#-----------------------------------------------------------------------------
# Build a list of classes and headers we need to implement the
# selected components.  Initialize with required components.
SET(KWSYS_CLASSES)
SET(KWSYS_H_FILES Configure SharedForward)
Kitware Robot's avatar
Kitware Robot committed
748 749 750 751 752 753 754
SET(KWSYS_HXX_FILES Configure String)

IF(NOT CMake_SOURCE_DIR)
  SET(KWSYS_HXX_FILES ${KWSYS_HXX_FILES}
    hashtable hash_fun hash_map hash_set
    )
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
755 756 757

# Add selected C++ classes.
SET(cppclasses
Kitware Robot's avatar
Kitware Robot committed
758
  Directory DynamicLoader Encoding Glob RegularExpression SystemTools
Kitware Robot's avatar
Kitware Robot committed
759
  CommandLineArguments IOStream FStream SystemInformation ConsoleBuf
Kitware Robot's avatar
Kitware Robot committed
760 761 762 763 764 765 766 767 768
  )
FOREACH(cpp ${cppclasses})
  IF(KWSYS_USE_${cpp})
    # Use the corresponding class.
    SET(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})

    # Load component-specific CMake code.
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
Kitware Robot's avatar
Kitware Robot committed
769 770 771
    ENDIF()
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
772 773 774

# Add selected C components.
FOREACH(c
Kitware Robot's avatar
Kitware Robot committed
775
    Process Base64 Encoding MD5 Terminal System String
Kitware Robot's avatar
Kitware Robot committed
776 777 778 779 780 781 782 783
    )
  IF(KWSYS_USE_${c})
    # Use the corresponding header file.
    SET(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})

    # Load component-specific CMake code.
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
Kitware Robot's avatar
Kitware Robot committed
784 785 786
    ENDIF()
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
787 788 789 790 791 792 793 794 795 796

#-----------------------------------------------------------------------------
# Build a list of sources for the library based on components that are
# included.
SET(KWSYS_C_SRCS)
SET(KWSYS_CXX_SRCS)

# Add the proper sources for this platform's Process implementation.
IF(KWSYS_USE_Process)
  IF(NOT UNIX)
Kitware Robot's avatar
Kitware Robot committed
797 798
    # Use the Windows implementation.
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c)
Kitware Robot's avatar
Kitware Robot committed
799
  ELSE()
Kitware Robot's avatar
Kitware Robot committed
800 801
    # Use the UNIX implementation.
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
Kitware Robot's avatar
Kitware Robot committed
802 803
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
804 805

# Add selected C sources.
Kitware Robot's avatar
Kitware Robot committed
806
FOREACH(c Base64 Encoding MD5 Terminal System String)
Kitware Robot's avatar
Kitware Robot committed
807
  IF(KWSYS_USE_${c})
Kitware Robot's avatar
Kitware Robot committed
808 809 810 811 812
    IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}C.c)
      LIST(APPEND KWSYS_C_SRCS ${c}C.c)
    ELSE()
      LIST(APPEND KWSYS_C_SRCS ${c}.c)
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
813 814
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
815 816 817 818

# Configure headers of C++ classes and construct the list of sources.
FOREACH(c ${KWSYS_CLASSES})
  # Add this source to the list of source files for the library.
Kitware Robot's avatar
Kitware Robot committed
819 820 821 822 823
  IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}CXX.cxx)
    LIST(APPEND KWSYS_CXX_SRCS ${c}CXX.cxx)
  ELSEIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}.cxx)
    LIST(APPEND KWSYS_CXX_SRCS ${c}.cxx)
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
824 825 826 827 828 829 830 831 832 833 834

  # Configure the header for this class.
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${c}.hxx.in ${KWSYS_HEADER_DIR}/${c}.hxx
                 @ONLY IMMEDIATE)
  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${c}.hxx)

  # Create an install target for the header.
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
Kitware Robot's avatar
Kitware Robot committed
835 836
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
837 838 839 840 841 842 843 844 845 846 847 848 849

# Configure C headers.
FOREACH(h ${KWSYS_H_FILES})
  # Configure the header into the given directory.
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.h.in ${KWSYS_HEADER_DIR}/${h}.h
                 @ONLY IMMEDIATE)
  SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)

  # Create an install target for the header.
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.h
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
Kitware Robot's avatar
Kitware Robot committed
850 851
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
852 853 854 855 856 857 858 859 860 861 862 863 864

# Configure other C++ headers.
FOREACH(h ${KWSYS_HXX_FILES})
  # Configure the header into the given directory.
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.hxx.in ${KWSYS_HEADER_DIR}/${h}.hxx
                 @ONLY IMMEDIATE)
  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)

  # Create an install target for the header.
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
Kitware Robot's avatar
Kitware Robot committed
865 866
  ENDIF()
ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
867 868 869 870

#-----------------------------------------------------------------------------
# Add the library with the configured name and list of sources.
IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
Kitware Robot's avatar
Kitware Robot committed
871 872 873 874 875 876 877 878
  IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}_objects)
    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE}_private)
    SET(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_INTERFACE} ${KWSYS_TARGET_LINK})
    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_OBJECT} OBJECT
      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
Kitware Robot's avatar
Kitware Robot committed
879
    IF(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
Kitware Robot's avatar
Kitware Robot committed
880 881 882 883 884 885 886 887 888
      SET_PROPERTY(TARGET ${KWSYS_TARGET_OBJECT} PROPERTY
        POSITION_INDEPENDENT_CODE TRUE)
    ENDIF()
    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_LINK} INTERFACE)
    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_LINK} INTERFACE
      ${KWSYS_TARGET_INTERFACE})
    TARGET_SOURCES(${KWSYS_TARGET_LINK} INTERFACE
      $<TARGET_OBJECTS:${KWSYS_TARGET_OBJECT}>)
Kitware Robot's avatar
Kitware Robot committed
889 890
    target_compile_features(${KWSYS_TARGET_OBJECT} PRIVATE ${KWSYS_CXX_COMPILE_FEATURES})
    target_compile_features(${KWSYS_TARGET_INTERFACE} INTERFACE ${KWSYS_CXX_COMPILE_FEATURES})
Kitware Robot's avatar
Kitware Robot committed
891 892 893 894 895 896 897 898
  ELSE()
    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
    set(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_LINK})
    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
Kitware Robot's avatar
Kitware Robot committed
899
    target_compile_features(${KWSYS_TARGET_INTERFACE} PUBLIC ${KWSYS_CXX_COMPILE_FEATURES})
Kitware Robot's avatar
Kitware Robot committed
900
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
901 902 903
  if (KWSYS_ALIAS_TARGET)
    add_library(${KWSYS_ALIAS_TARGET} ALIAS ${KWSYS_TARGET_INTERFACE})
  endif ()
Kitware Robot's avatar
Kitware Robot committed
904 905 906 907 908 909
  SET_TARGET_PROPERTIES(${KWSYS_TARGET_OBJECT} PROPERTIES
    C_CLANG_TIDY ""
    CXX_CLANG_TIDY ""
    C_INCLUDE_WHAT_YOU_USE ""
    CXX_INCLUDE_WHAT_YOU_USE ""
    LABELS "${KWSYS_LABELS_LIB}")
Kitware Robot's avatar
Kitware Robot committed
910 911
  IF(KWSYS_USE_DynamicLoader)
    IF(UNIX)
Kitware Robot's avatar
Kitware Robot committed
912 913
      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
        ${CMAKE_DL_LIBS})
Kitware Robot's avatar
Kitware Robot committed
914 915
    ENDIF()
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
916

Kitware Robot's avatar
Kitware Robot committed
917 918
  IF(KWSYS_USE_SystemInformation)
    IF(WIN32)
Kitware Robot's avatar
Kitware Robot committed
919
      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
Kitware Robot's avatar
Kitware Robot committed
920
      IF(KWSYS_SYS_HAS_PSAPI)
Kitware Robot's avatar
Kitware Robot committed
921 922
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          Psapi)
Kitware Robot's avatar
Kitware Robot committed
923 924 925 926
      ENDIF()
    ELSEIF(UNIX)
      IF (EXECINFO_LIB AND KWSYS_CXX_HAS_BACKTRACE)
        # backtrace on FreeBSD is not in libc
Kitware Robot's avatar
Kitware Robot committed
927 928
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          ${EXECINFO_LIB})
Kitware Robot's avatar
Kitware Robot committed
929 930 931
      ENDIF()
      IF (KWSYS_CXX_HAS_DLADDR)
        # for symbol lookup using dladdr
Kitware Robot's avatar
Kitware Robot committed
932 933
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          ${CMAKE_DL_LIBS})
Kitware Robot's avatar
Kitware Robot committed
934
      ENDIF()
Kitware Robot's avatar
Kitware Robot committed
935
      IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
Kitware Robot's avatar
Kitware Robot committed
936 937
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          socket)
Kitware Robot's avatar
Kitware Robot committed
938
      ENDIF()
Kitware Robot's avatar
Kitware Robot committed
939
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
940
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
941 942 943

  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_CXX)
Kitware Robot's avatar
Kitware Robot committed
944 945 946 947 948 949 950
    SET_TARGET_PROPERTIES(${KWSYS_TARGET_INTERFACE} PROPERTIES
      ${KWSYS_PROPERTIES_CXX})
  ENDIF()

  # Set up include usage requirement
  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
Kitware Robot's avatar
Kitware Robot committed
951
      $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
Kitware Robot's avatar
Kitware Robot committed
952 953 954 955
    IF(KWSYS_INSTALL_INCLUDE_DIR)
      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
956
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
957 958 959

  # Create an install target for the library.
  IF(KWSYS_INSTALL_LIBRARY_RULE)
Kitware Robot's avatar
Kitware Robot committed
960
    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
Kitware Robot's avatar
Kitware Robot committed
961
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
962 963 964
  IF(KWSYS_INSTALL_NAMELINK_RULE)
    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_NAMELINK_RULE})
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
965
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
966 967 968

# Add a C-only library if requested.
IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
Kitware Robot's avatar
Kitware Robot committed
969 970 971 972 973 974 975 976
 IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c_objects)
    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c_private)
    SET(KWSYS_TARGET_C_INSTALL
      ${KWSYS_TARGET_C_INTERFACE} ${KWSYS_TARGET_C_LINK})
    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
Kitware Robot's avatar
Kitware Robot committed
977
    IF(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
Kitware Robot's avatar
Kitware Robot committed
978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997
      SET_PROPERTY(TARGET ${KWSYS_TARGET_C_OBJECT} PROPERTY
        POSITION_INDEPENDENT_CODE TRUE)
    ENDIF()
    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_C_LINK} INTERFACE)
    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_C_LINK} INTERFACE
      ${KWSYS_TARGET_C_INTERFACE})
    TARGET_SOURCES(${KWSYS_TARGET_C_LINK} INTERFACE
      $<TARGET_OBJECTS:${KWSYS_TARGET_C_OBJECT}>)
  ELSE()
    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c)
    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c)
    SET(KWSYS_TARGET_C_INSTALL ${KWSYS_TARGET_C_LINK})
    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} ${KWSYS_LIBRARY_TYPE}
      ${KWSYS_C_SRCS})
  ENDIF()
  SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_OBJECT} PROPERTIES
    LABELS "${KWSYS_LABELS_LIB}")
Kitware Robot's avatar
Kitware Robot committed
998 999 1000

  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_C)
Kitware Robot's avatar
Kitware Robot committed
1001 1002 1003 1004 1005 1006 1007
    SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
      ${KWSYS_PROPERTIES_C})
  ENDIF()

  # Set up include usage requirement
  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
Kitware Robot's avatar
Kitware Robot committed
1008
      $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
Kitware Robot's avatar
Kitware Robot committed
1009 1010 1011 1012
    IF(KWSYS_INSTALL_INCLUDE_DIR)
      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1013
  ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1014 1015 1016

  # Create an install target for the library.
  IF(KWSYS_INSTALL_LIBRARY_RULE)
Kitware Robot's avatar
Kitware Robot committed
1017
    INSTALL(TARGETS ${KWSYS_TARGET_C_INSTALL})
Kitware Robot's avatar
Kitware Robot committed
1018 1019
  ENDIF()
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1020 1021 1022 1023 1024

# For building kwsys itself, we use a macro defined on the command
# line to configure the namespace in the C and C++ source files.
ADD_DEFINITIONS("-DKWSYS_NAMESPACE=${KWSYS_NAMESPACE}")

Kitware Robot's avatar
Kitware Robot committed
1025
# Disable deprecation warnings for standard C functions.
Kitware Robot's avatar
Kitware Robot committed
1026
IF(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "Intel"))
Kitware Robot's avatar
Kitware Robot committed
1027 1028 1029 1030 1031 1032 1033 1034
  ADD_DEFINITIONS(
    -D_CRT_NONSTDC_NO_DEPRECATE
    -D_CRT_SECURE_NO_DEPRECATE
    -D_CRT_SECURE_NO_WARNINGS
    -D_SCL_SECURE_NO_DEPRECATE
    )
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
1035 1036 1037 1038 1039
IF(WIN32)
  # Help enforce the use of wide Windows apis.
  ADD_DEFINITIONS(-DUNICODE -D_UNICODE)
ENDIF()

Kitware Robot's avatar
Kitware Robot committed
1040 1041 1042 1043
IF(KWSYS_USE_String)
  # Activate code in "String.c".  See the comment in the source.
  SET_SOURCE_FILES_PROPERTIES(String.c PROPERTIES
    COMPILE_FLAGS "-DKWSYS_STRING_C")
Kitware Robot's avatar
Kitware Robot committed
1044
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1045

Kitware Robot's avatar
Kitware Robot committed
1046 1047
IF(KWSYS_USE_Encoding)
  # Set default 8 bit encoding in "EndcodingC.c".
Kitware Robot's avatar
Kitware Robot committed
1048
  SET_PROPERTY(SOURCE EncodingC.c EncodingCXX.cxx APPEND PROPERTY COMPILE_DEFINITIONS
Kitware Robot's avatar
Kitware Robot committed
1049
    KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
Kitware Robot's avatar
Kitware Robot committed
1050
ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1051

Kitware Robot's avatar
Kitware Robot committed
1052 1053 1054 1055 1056 1057 1058 1059
#-----------------------------------------------------------------------------
# Setup testing if not being built as part of another project.
IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
  IF(BUILD_TESTING)
    # Compute the location of executables.
    SET(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
    IF(EXECUTABLE_OUTPUT_PATH)
      SET(EXEC_DIR "${EXECUTABLE_OUTPUT_PATH}")
Kitware Robot's avatar
Kitware Robot committed
1060
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1061 1062 1063

    # C tests
    SET(KWSYS_C_TESTS
Kitware Robot's avatar
Kitware Robot committed
1064 1065
      testEncode.c
      testTerminal.c
Kitware Robot's avatar
Kitware Robot committed
1066 1067
      )
    IF(KWSYS_STANDALONE)
Kitware Robot's avatar
Kitware Robot committed
1068
      SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail.c)
Kitware Robot's avatar
Kitware Robot committed
1069 1070 1071 1072 1073 1074 1075
    ENDIF()
    CREATE_TEST_SOURCELIST(
      KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
      ${KWSYS_C_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
Kitware Robot's avatar
Kitware Robot committed
1076
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
Kitware Robot's avatar
Kitware Robot committed
1077 1078
    FOREACH(testfile ${KWSYS_C_TESTS})
      get_filename_component(test "${testfile}" NAME_WE)
Kitware Robot's avatar
Kitware Robot committed
1079 1080
      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
Kitware Robot's avatar
Kitware Robot committed
1081
    ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
1082 1083

    # C++ tests
Kitware Robot's avatar
Kitware Robot committed
1084
    IF(NOT WATCOM AND NOT CMake_SOURCE_DIR)
Kitware Robot's avatar
Kitware Robot committed
1085
      SET(KWSYS_CXX_TESTS
Kitware Robot's avatar
Kitware Robot committed
1086
        testHashSTL.cxx
Kitware Robot's avatar
Kitware Robot committed
1087
        )
Kitware Robot's avatar
Kitware Robot committed
1088
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1089
    SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
Kitware Robot's avatar
Kitware Robot committed
1090 1091 1092 1093 1094
      testConfigure.cxx
      testSystemTools.cxx
      testCommandLineArguments.cxx
      testCommandLineArguments1.cxx
      testDirectory.cxx
Kitware Robot's avatar
Kitware Robot committed
1095
      )
Kitware Robot's avatar
Kitware Robot committed
1096 1097
    IF(KWSYS_STL_HAS_WSTRING)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
Kitware Robot's avatar
Kitware Robot committed
1098
        testEncoding.cxx
Kitware Robot's avatar
Kitware Robot committed
1099
        )
Kitware Robot's avatar
Kitware Robot committed
1100
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1101 1102
    IF(KWSYS_USE_FStream)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
Kitware Robot's avatar
Kitware Robot committed
1103
        testFStream.cxx
Kitware Robot's avatar
Kitware Robot committed
1104
        )
Kitware Robot's avatar
Kitware Robot committed
1105
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1106 1107
    IF(KWSYS_USE_ConsoleBuf)
      ADD_EXECUTABLE(testConsoleBufChild testConsoleBufChild.cxx)
Kitware Robot's avatar
Kitware Robot committed
1108 1109
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_CLANG_TIDY "")
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_CLANG_TIDY "")
Kitware Robot's avatar
Kitware Robot committed
1110 1111
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
Kitware Robot's avatar
Kitware Robot committed
1112
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
Kitware Robot's avatar
Kitware Robot committed
1113
      TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_TARGET_LINK})
Kitware Robot's avatar
Kitware Robot committed
1114
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
Kitware Robot's avatar
Kitware Robot committed
1115
        testConsoleBuf.cxx
Kitware Robot's avatar
Kitware Robot committed
1116 1117
        )
      IF("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" AND
Kitware Robot's avatar
Kitware Robot committed
1118
         CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "19.0.23506")
Kitware Robot's avatar
Kitware Robot committed
1119 1120 1121 1122 1123
        set_property(SOURCE testConsoleBuf.cxx testConsoleBufChild.cxx PROPERTY COMPILE_FLAGS /utf-8)
      ENDIF()
      SET_PROPERTY(SOURCE testConsoleBuf.cxx APPEND PROPERTY COMPILE_DEFINITIONS
        KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1124
    IF(KWSYS_USE_SystemInformation)
Kitware Robot's avatar
Kitware Robot committed
1125
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation.cxx)
Kitware Robot's avatar
Kitware Robot committed
1126
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1127
    IF(KWSYS_USE_DynamicLoader)
Kitware Robot's avatar
Kitware Robot committed
1128
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader.cxx)
Kitware Robot's avatar
Kitware Robot committed
1129 1130 1131
      # If kwsys contains the DynamicLoader, need extra library
      ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
      SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
Kitware Robot's avatar
Kitware Robot committed
1132
      ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
Kitware Robot's avatar
Kitware Robot committed
1133
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1134 1135 1136 1137 1138
    CREATE_TEST_SOURCELIST(
      KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
      ${KWSYS_CXX_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
Kitware Robot's avatar
Kitware Robot committed
1139 1140
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_CLANG_TIDY "")
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_CLANG_TIDY "")
Kitware Robot's avatar
Kitware Robot committed
1141 1142
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
Kitware Robot's avatar
Kitware Robot committed
1143
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
Kitware Robot's avatar
Kitware Robot committed
1144
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
Kitware Robot's avatar
Kitware Robot committed
1145 1146 1147

    SET(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
    SET(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
Kitware Robot's avatar
Kitware Robot committed
1148 1149 1150 1151 1152 1153 1154 1155 1156
    CONFIGURE_FILE(
      ${PROJECT_SOURCE_DIR}/testSystemTools.h.in
      ${PROJECT_BINARY_DIR}/testSystemTools.h)
    INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})

    IF(CTEST_TEST_KWSYS)
      CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ExtraTest.cmake.in"
        "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
      SET_DIRECTORY_PROPERTIES(PROPERTIES TEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
Kitware Robot's avatar
Kitware Robot committed
1157
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186

    SET(KWSYS_TEST_ARGS_testCommandLineArguments
      --another-bool-variable
      --long3=opt
      --set-bool-arg1
      -SSS ken brad bill andy
      --some-bool-variable=true
      --some-double-variable12.5
      --some-int-variable 14
      "--some-string-variable=test string with space"
      --some-multi-argument 5 1 8 3 7 1 3 9 7 1
      -N 12.5 -SS=andy -N 1.31 -N 22
      -SS=bill -BBtrue -SS=brad
      -BBtrue
      -BBfalse
      -SS=ken
      -A
      -C=test
      --long2 hello
      )
    SET(KWSYS_TEST_ARGS_testCommandLineArguments1
      --ignored
      -n 24
      --second-ignored
      "-m=test value"
      third-ignored
      -p
      some junk at the end
      )
Kitware Robot's avatar
Kitware Robot committed
1187 1188
    FOREACH(testfile ${KWSYS_CXX_TESTS})
      get_filename_component(test "${testfile}" NAME_WE)
Kitware Robot's avatar
Kitware Robot committed
1189 1190
      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
Kitware Robot's avatar
Kitware Robot committed
1191
    ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
1192 1193 1194 1195

    # Process tests.
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
Kitware Robot's avatar
Kitware Robot committed
1196
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
Kitware Robot's avatar
Kitware Robot committed
1197 1198
    IF(NOT CYGWIN)
      SET(KWSYS_TEST_PROCESS_7 7)
Kitware Robot's avatar
Kitware Robot committed
1199
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1200
    FOREACH(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7} 9 10)
Kitware Robot's avatar
Kitware Robot committed
1201 1202 1203
      ADD_TEST(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
      SET_PROPERTY(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
      SET_TESTS_PROPERTIES(kwsys.testProcess-${n} PROPERTIES TIMEOUT 120)
Kitware Robot's avatar
Kitware Robot committed
1204
    ENDFOREACH()
Kitware Robot's avatar
Kitware Robot committed
1205

Kitware Robot's avatar
Kitware Robot committed
1206
    SET(testProcess_COMPILE_FLAGS "")
Kitware Robot's avatar
Kitware Robot committed
1207
    # Some Apple compilers produce bad optimizations in this source.
Kitware Robot's avatar
Kitware Robot committed
1208
    IF(APPLE AND CMAKE_C_COMPILER_ID MATCHES "^(GNU|LLVM)$")
Kitware Robot's avatar
Kitware Robot committed
1209
      SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -O0")
Kitware Robot's avatar
Kitware Robot committed
1210
    ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL")
Kitware Robot's avatar
Kitware Robot committed
1211
      # Tell IBM XL not to warn about our test infinite loop
Kitware Robot's avatar
Kitware Robot committed
1212 1213 1214 1215 1216 1217 1218 1219 1220
      IF(CMAKE_SYSTEM MATCHES "Linux.*ppc64le"
         AND CMAKE_C_COMPILER_VERSION VERSION_LESS "16.1.0"
         AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS "13.1.1")
        # v13.1.[1-6] on Linux ppc64le is clang based and does not accept
        # the -qsuppress option, so just suppress all warnings.
        SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -w")
      ELSE()
        SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -qsuppress=1500-010")
      ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1221
    ENDIF()
Kitware Robot's avatar
Kitware Robot committed
1222
    IF(CMAKE_C_FLAGS MATCHES "-fsanitize=")
Kitware Robot's avatar
Kitware Robot committed
1223
      SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -DCRASH_USING_ABORT")
Kitware Robot's avatar
Kitware Robot committed
1224 1225
    ENDIF()
    SET_PROPERTY(SOURCE testProcess.c PROPERTY COMPILE_FLAGS "${testProcess_COMPILE_FLAGS}")
Kitware Robot's avatar
Kitware Robot committed
1226 1227 1228 1229 1230 1231 1232

    # Test SharedForward
    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
                   ${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestSharedForward
                   ${PROJECT_BINARY_DIR}/testSharedForward.c)
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
Kitware Robot's avatar
Kitware Robot committed
1233
    ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_TARGET_C_LINK})
Kitware Robot's avatar
Kitware Robot committed
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
    ADD_TEST(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
    SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})

    # Configure some test properties.
    IF(KWSYS_STANDALONE)
      # We expect test to fail
      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES WILL_FAIL ON)
      GET_TEST_PROPERTY(kwsys.testFail WILL_FAIL wfv)
      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
      MESSAGE(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
    ENDIF()

Kitware Robot's avatar
Kitware Robot committed
1246 1247 1248 1249
    # Set up ctest custom configuration file.
    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/CTestCustom.cmake.in
                   ${PROJECT_BINARY_DIR}/CTestCustom.cmake @ONLY)

Kitware Robot's avatar
Kitware Robot committed
1250 1251 1252 1253 1254
    # Suppress known consistent failures on buggy systems.
    IF(KWSYS_TEST_BOGUS_FAILURES)
      SET_TESTS_PROPERTIES(${KWSYS_TEST_BOGUS_FAILURES} PROPERTIES WILL_FAIL ON)
    ENDIF()

Kitware Robot's avatar
Kitware Robot committed
1255 1256
  ENDIF()
ENDIF()