CMakeLists.txt 46.3 KB
Newer Older
1 2
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing#kwsys for details.
3 4 5

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

# Typical usage is to import the kwsys directory tree into a
10 11 12
# 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:
13
#
14 15
#  SET(KWSYS_NAMESPACE foosys)
#  SET(KWSYS_USE_Directory 1)    # Enable Directory class.
16 17 18 19
#  SUBDIRS(kwsys)
#
# Optional settings are as follows:
#
20 21 22
#  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.
23 24 25 26 27 28 29 30
#  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.
31
#                            Note: This is omitted from the install rules
32 33 34 35 36 37
#                        ${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.
38 39 40
#
#    Example:
#
Andy Cedilnik's avatar
Andy Cedilnik committed
41 42
#      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
#      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
43
#
44
# Optional settings to setup install rules are as follows:
45 46 47 48 49 50
#
#  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 '/'.
51 52
#  KWSYS_INSTALL_DOC_DIR     = The installation target directory for documentation
#                              such as copyright information.
53 54 55 56 57 58
#
#  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.
#
59 60
#  KWSYS_INSTALL_EXPORT_NAME = The EXPORT option value for install(TARGETS) calls.
#
61 62 63 64 65 66 67
#    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)
68 69 70

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

76 77 78 79 80 81 82 83
# 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.

84
CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 FATAL_ERROR)
Brad King's avatar
Brad King committed
85
FOREACH(p
86
    CMP0022 # CMake 2.8, Define link interface - required by android_mk export
Brad King's avatar
Brad King committed
87
    CMP0025 # CMake 3.0, Compiler id for Apple Clang is now AppleClang.
88
    CMP0042 # CMake 3.0, MACOSX_RPATH is enabled by default.
89
    CMP0048 # CMake 3.0, Let the project command manage version variables.
Brad King's avatar
Brad King committed
90
    CMP0056 # CMake 3.2, Honor link flags in try_compile() source-file signature.
91
    CMP0063 # CMake 3.3, Honor visibility properties for all target types.
Brad King's avatar
Brad King committed
92 93 94 95 96
    )
  IF(POLICY ${p})
    CMAKE_POLICY(SET ${p} NEW)
  ENDIF()
ENDFOREACH()
97
SET(CMAKE_LEGACY_CYGWIN_WIN32 0)
98

99 100 101 102
IF(CMAKE_VERSION VERSION_LESS 3.0)
  SET(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE 0)
ENDIF()

103 104 105 106
#-----------------------------------------------------------------------------
# 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.
107 108
IF(NOT KWSYS_NAMESPACE)
  SET(KWSYS_NAMESPACE "kwsys")
109
  SET(KWSYS_STANDALONE 1)
110
ENDIF()
111

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

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

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

# Enforce component dependencies.
IF(KWSYS_USE_SystemTools)
  SET(KWSYS_USE_Directory 1)
148 149
  SET(KWSYS_USE_FStream 1)
  SET(KWSYS_USE_Encoding 1)
150
ENDIF()
151 152 153 154
IF(KWSYS_USE_Glob)
  SET(KWSYS_USE_Directory 1)
  SET(KWSYS_USE_SystemTools 1)
  SET(KWSYS_USE_RegularExpression 1)
155 156
  SET(KWSYS_USE_FStream 1)
  SET(KWSYS_USE_Encoding 1)
157
ENDIF()
158 159
IF(KWSYS_USE_Process)
  SET(KWSYS_USE_System 1)
160
  SET(KWSYS_USE_Encoding 1)
161
ENDIF()
162 163
IF(KWSYS_USE_SystemInformation)
  SET(KWSYS_USE_Process 1)
164
ENDIF()
165 166
IF(KWSYS_USE_System)
  SET(KWSYS_USE_Encoding 1)
167
ENDIF()
168 169
IF(KWSYS_USE_Directory)
  SET(KWSYS_USE_Encoding 1)
170
ENDIF()
171 172
IF(KWSYS_USE_FStream)
  SET(KWSYS_USE_Encoding 1)
173
ENDIF()
174 175 176
IF(KWSYS_USE_ConsoleBuf)
  SET(KWSYS_USE_Encoding 1)
ENDIF()
177

Brad King's avatar
Brad King committed
178 179 180
# Setup the large file support default.
IF(KWSYS_LFS_DISABLE)
  SET(KWSYS_LFS_REQUESTED 0)
181
ELSE()
Brad King's avatar
Brad King committed
182
  SET(KWSYS_LFS_REQUESTED 1)
183
ENDIF()
Brad King's avatar
Brad King committed
184

185 186 187
# Specify default 8 bit encoding for Windows
IF(NOT KWSYS_ENCODING_DEFAULT_CODEPAGE)
  SET(KWSYS_ENCODING_DEFAULT_CODEPAGE CP_ACP)
188
ENDIF()
189

190 191
# Enable testing if building standalone.
IF(KWSYS_STANDALONE)
192
  INCLUDE(Dart)
193 194 195
  MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
  IF(BUILD_TESTING)
    ENABLE_TESTING()
196 197
  ENDIF()
ENDIF()
198

199 200 201 202 203
# Choose default shared/static build if not specified.
IF(NOT DEFINED KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
ENDIF()

204
# Include helper macros.
205
INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
206
INCLUDE(CheckTypeSize)
207

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

211 212 213 214 215 216 217
# 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}")
218
ENDIF()
219 220 221
IF(NOT KWSYS_INSTALL_LIB_DIR)
  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
    "${KWSYS_LIBRARY_INSTALL_DIR}")
222
ENDIF()
223 224 225
IF(NOT KWSYS_INSTALL_BIN_DIR)
  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
    "${KWSYS_LIBRARY_INSTALL_DIR}")
226
ENDIF()
227 228 229 230 231 232 233

# 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}
    )
234
ENDIF()
235

236 237
# Setup library install rules.
SET(KWSYS_INSTALL_LIBRARY_RULE)
238
SET(KWSYS_INSTALL_NAMELINK_RULE)
239 240 241 242 243 244
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}
245
    LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_SKIP
246 247 248
    )
  # Assign the shared library to the runtime component.
  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
249
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
250
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
251
      )
252
  ENDIF()
253 254 255 256 257 258 259 260 261 262 263
  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()
264

265 266 267 268 269 270
  # 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)
271
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
272
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
273
      )
274 275
  ENDIF()
ENDIF()
276 277 278 279 280 281 282
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)
283
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
284
      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
285
      )
286 287
  ENDIF()
ENDIF()
288

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

293 294 295 296 297
# 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
298
    ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPYONLY IMMEDIATE)
299
ENDIF()
300

301 302 303 304 305 306 307 308
# 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()

309 310 311 312
#-----------------------------------------------------------------------------
# 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}")
313
ENDIF()
314

315 316 317 318 319 320 321 322 323 324
#-----------------------------------------------------------------------------
# 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")
325
    ENDIF()
326 327
    IF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
328 329
    ENDIF()
  ENDIF()
330 331
  IF(CMAKE_SYSTEM MATCHES "HP-UX")
    SET(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
332 333 334 335 336 337 338
    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()
339 340
  ENDIF()
ENDIF()
341 342 343 344 345 346 347 348 349
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()
350

351 352
#-----------------------------------------------------------------------------
# Configure Large File Support.
353 354
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDIO
  "Checking whether header cstdio is available" DIRECT)
355 356 357 358 359 360
SET(KWSYS_LFS_AVAILABLE 0)
IF(KWSYS_LFS_REQUESTED)
  # Large File Support is requested.
  SET(KWSYS_LFS_REQUESTED 1)

  # Check for large file support.
361 362
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
    -DKWSYS_CXX_HAS_CSTDIO=${KWSYS_CXX_HAS_CSTDIO})
363 364
  KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_LFS_WORKS
    "Checking for Large File Support" DIRECT)
365
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
366 367 368

  IF(KWSYS_LFS_WORKS)
    SET(KWSYS_LFS_AVAILABLE 1)
369 370
  ENDIF()
ELSE()
371 372
  # Large File Support is not requested.
  SET(KWSYS_LFS_REQUESTED 0)
373
ENDIF()
374

375 376
#-----------------------------------------------------------------------------
# Configure the standard library header wrappers based on compiler's
377 378
# capabilities and parent project's request.  Enforce 0/1 as only
# possible values for configuration into Configure.hxx.
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
# 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()

413 414 415 416
IF(KWSYS_USE_Encoding)
  # Look for type size helper macros.
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_WSTRING
    "Checking whether wstring is available" DIRECT)
417
ENDIF()
418

419 420
IF(KWSYS_USE_IOStream)
  # Determine whether iostreams support long long.
421
  IF(KWSYS_CXX_HAS_LONG_LONG)
422 423 424 425
    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)
426
  ELSE()
427 428
    SET(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
    SET(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
429
  ENDIF()
430 431 432 433 434 435 436 437 438
  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()
439
ENDIF()
440

441 442
IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
  SET(KWSYS_NAME_IS_KWSYS 1)
443
ELSE()
444
  SET(KWSYS_NAME_IS_KWSYS 0)
445
ENDIF()
446

Brad King's avatar
Brad King committed
447 448 449
IF(KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED 1)
  SET(KWSYS_LIBRARY_TYPE SHARED)
450
ELSE()
Brad King's avatar
Brad King committed
451 452
  SET(KWSYS_BUILD_SHARED 0)
  SET(KWSYS_LIBRARY_TYPE STATIC)
453
ENDIF()
Brad King's avatar
Brad King committed
454

455 456 457
#-----------------------------------------------------------------------------
# Configure some implementation details.

458 459 460 461
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)
462 463 464 465 466
IF(KWSYS_USE_Process)
  KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC
    "Checking whether C compiler has clock_gettime" DIRECT)
ENDIF()

467
SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c System.c PROPERTIES
468
  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}"
469 470
  )

471 472 473 474 475
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()

476 477 478 479 480 481 482 483 484 485 486
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()

487 488 489 490 491 492 493
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)
494 495 496 497
  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)
498 499
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIM
    "Checking whether CXX compiler struct stat has st_mtim member" DIRECT)
500 501
  KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
    "Checking whether CXX compiler struct stat has st_mtimespec member" DIRECT)
502 503 504 505
  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}
506 507
    KWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES}
    KWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT}
508
    KWSYS_CXX_STAT_HAS_ST_MTIM=${KWSYS_CXX_STAT_HAS_ST_MTIM}
509
    KWSYS_CXX_STAT_HAS_ST_MTIMESPEC=${KWSYS_CXX_STAT_HAS_ST_MTIMESPEC}
510
    )
511 512 513 514 515 516 517 518 519 520
  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()
521 522 523 524 525 526 527 528

  # 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()
529
ENDIF()
530

531
IF(KWSYS_USE_SystemInformation)
532 533
  SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
    COMPILE_DEFINITIONS SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P})
534 535 536 537 538
  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
539
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_IFADDRS_H=1)
540 541
    ENDIF()
  ENDIF()
542 543 544 545 546 547 548
  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
549
        COMPILE_DEFINITIONS KWSYS_SYS_HAS_PSAPI=1)
550
      IF(MSVC70 OR MSVC71)
551 552
        # Suppress LNK4089: all references to 'PSAPI.DLL' discarded by /OPT:REF
        SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /IGNORE:4089")
553 554 555
      ENDIF()
    ENDIF()
  ENDIF()
556 557 558 559 560 561 562
  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()
563 564 565 566 567 568 569
  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()
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
  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()
598 599 600 601 602 603
  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")
604
    MARK_AS_ADVANCED(EXECINFO_LIB)
605 606 607 608 609 610
    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
611
      # can be used with this compiler
612 613 614 615 616 617 618 619 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
      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()
661 662 663 664 665 666 667 668 669 670 671 672 673 674
  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()
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
  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()
695 696 697 698 699 700 701 702 703

  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()
704 705
ENDIF()

Dāvis Mosāns's avatar
Dāvis Mosāns committed
706 707 708 709 710
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()

711 712
#-----------------------------------------------------------------------------
# Choose a directory for the generated headers.
713 714
IF(NOT KWSYS_HEADER_ROOT)
  SET(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
715
ENDIF()
716
SET(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
717
INCLUDE_DIRECTORIES(${KWSYS_HEADER_ROOT})
718

719 720 721 722 723 724 725 726
#-----------------------------------------------------------------------------
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}
      )
727
  ENDIF()
728 729 730 731 732

  # 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})
733
ENDIF()
734

735 736 737 738
#-----------------------------------------------------------------------------
# Build a list of classes and headers we need to implement the
# selected components.  Initialize with required components.
SET(KWSYS_CLASSES)
739
SET(KWSYS_H_FILES Configure SharedForward)
740 741 742 743 744 745 746
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()
747 748

# Add selected C++ classes.
749
SET(cppclasses
750
  Directory DynamicLoader Encoding Glob RegularExpression SystemTools
751
  CommandLineArguments IOStream FStream SystemInformation ConsoleBuf
752
  )
753 754
FOREACH(cpp ${cppclasses})
  IF(KWSYS_USE_${cpp})
755
    # Use the corresponding class.
756
    SET(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
757 758

    # Load component-specific CMake code.
759
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
760
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
761 762 763
    ENDIF()
  ENDIF()
ENDFOREACH()
764 765

# Add selected C components.
766
FOREACH(c
767
    Process Base64 Encoding MD5 Terminal System String
768
    )
769
  IF(KWSYS_USE_${c})
770
    # Use the corresponding header file.
771
    SET(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})
772 773

    # Load component-specific CMake code.
774
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
775
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
776 777 778
    ENDIF()
  ENDIF()
ENDFOREACH()
779

780 781 782
#-----------------------------------------------------------------------------
# Build a list of sources for the library based on components that are
# included.
783 784
SET(KWSYS_C_SRCS)
SET(KWSYS_CXX_SRCS)
785 786 787

# Add the proper sources for this platform's Process implementation.
IF(KWSYS_USE_Process)
788
  IF(NOT UNIX)
789 790
    # Use the Windows implementation.
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c)
791
  ELSE()
792
    # Use the UNIX implementation.
793
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
794 795
  ENDIF()
ENDIF()
796

797
# Add selected C sources.
798
FOREACH(c Base64 Encoding MD5 Terminal System String)
799
  IF(KWSYS_USE_${c})
800 801 802 803 804
    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()
805 806
  ENDIF()
ENDFOREACH()
807

808 809 810
# 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.
811 812
  IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}CXX.cxx)
    LIST(APPEND KWSYS_CXX_SRCS ${c}CXX.cxx)
813
  ELSEIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}.cxx)
814 815
    LIST(APPEND KWSYS_CXX_SRCS ${c}.cxx)
  ENDIF()
816

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

  # Create an install target for the header.
823 824
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
825 826
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
827 828
  ENDIF()
ENDFOREACH()
829

830 831 832 833
# 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
834
                 @ONLY IMMEDIATE)
835
  SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)
836 837

  # Create an install target for the header.
838 839
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.h
840 841
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
842 843
  ENDIF()
ENDFOREACH()
844

845 846 847 848
# 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
849
                 @ONLY IMMEDIATE)
850
  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)
851

852
  # Create an install target for the header.
853 854
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
855 856
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
857 858
  ENDIF()
ENDFOREACH()
859

860 861
#-----------------------------------------------------------------------------
# Add the library with the configured name and list of sources.
862
IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
863 864 865 866
  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)
867
    SET(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_INTERFACE} ${KWSYS_TARGET_LINK})
868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_OBJECT} OBJECT
      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
    IF(KWSYS_BUILD_SHARED)
      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}>)
  ELSE()
    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
885
    set(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_LINK})
886 887 888 889 890 891 892 893 894 895
    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
  ENDIF()
  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}")
896 897
  IF(KWSYS_USE_DynamicLoader)
    IF(UNIX)
898 899
      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
        ${CMAKE_DL_LIBS})
900 901
    ENDIF()
  ENDIF()
902

903 904
  IF(KWSYS_USE_SystemInformation)
    IF(WIN32)
905
      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
906
      IF(KWSYS_SYS_HAS_PSAPI)
907 908
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          Psapi)
909 910 911 912
      ENDIF()
    ELSEIF(UNIX)
      IF (EXECINFO_LIB AND KWSYS_CXX_HAS_BACKTRACE)
        # backtrace on FreeBSD is not in libc
913 914
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          ${EXECINFO_LIB})
915 916 917
      ENDIF()
      IF (KWSYS_CXX_HAS_DLADDR)
        # for symbol lookup using dladdr
918 919
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          ${CMAKE_DL_LIBS})
920
      ENDIF()
921
      IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
922 923
        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
          socket)
924
      ENDIF()
925
    ENDIF()
926
  ENDIF()
927

928 929
  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_CXX)
930 931 932 933 934 935 936
    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
937
      $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
938 939 940 941
    IF(KWSYS_INSTALL_INCLUDE_DIR)
      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
    ENDIF()
942
  ENDIF()
943

944
  # Create an install target for the library.
945
  IF(KWSYS_INSTALL_LIBRARY_RULE)
946
    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
947
  ENDIF()
948 949 950
  IF(KWSYS_INSTALL_NAMELINK_RULE)
    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_NAMELINK_RULE})
  ENDIF()
951
ENDIF()
952 953 954

# Add a C-only library if requested.
IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
955 956 957 958
 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)
959 960
    SET(KWSYS_TARGET_C_INSTALL
      ${KWSYS_TARGET_C_INTERFACE} ${KWSYS_TARGET_C_LINK})
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
    ADD_LIBRARY(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
    IF(KWSYS_BUILD_SHARED)
      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)
977
    SET(KWSYS_TARGET_C_INSTALL ${KWSYS_TARGET_C_LINK})
978 979 980 981 982 983
    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}")
984

985 986
  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_C)
987 988
    SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
      ${KWSYS_PROPERTIES_C})
989
  ENDIF()
990

991 992 993
  # Set up include usage requirement
  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
994
      $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
995 996 997 998 999 1000
    IF(KWSYS_INSTALL_INCLUDE_DIR)
      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
    ENDIF()
  ENDIF()

1001
  # Create an install target for the library.
1002
  IF(KWSYS_INSTALL_LIBRARY_RULE)
1003 1004
    INSTALL(TARGETS ${KWSYS_TARGET_C_INSTALL})
  ENDIF()
1005
ENDIF()
1006

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

1011
# Disable deprecation warnings for standard C functions.
1012
IF(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID STREQUAL "Intel"))
1013 1014 1015 1016 1017 1018 1019 1020
  ADD_DEFINITIONS(
    -D_CRT_NONSTDC_NO_DEPRECATE
    -D_CRT_SECURE_NO_DEPRECATE
    -D_CRT_SECURE_NO_WARNINGS
    -D_SCL_SECURE_NO_DEPRECATE
    )
ENDIF()

1021 1022 1023 1024 1025
IF(WIN32)
  # Help enforce the use of wide Windows apis.
  ADD_DEFINITIONS(-DUNICODE -D_UNICODE)
ENDIF()

1026 1027 1028 1029
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")
1030
ENDIF()
1031

1032 1033
IF(KWSYS_USE_Encoding)
  # Set default 8 bit encoding in "EndcodingC.c".
1034
  SET_PROPERTY(SOURCE EncodingC.c EncodingCXX.cxx APPEND PROPERTY COMPILE_DEFINITIONS
1035
    KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
1036
ENDIF()
1037

1038 1039
#-----------------------------------------------------------------------------
# Setup testing if not being built as part of another project.
1040
IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
1041
  IF(BUILD_TESTING)
1042
    # Compute the location of executables.
1043 1044 1045
    SET(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
    IF(EXECUTABLE_OUTPUT_PATH)
      SET(EXEC_DIR "${EXECUTABLE_OUTPUT_PATH}")
1046
    ENDIF()
1047

1048 1049
    # C tests
    SET(KWSYS_C_TESTS
1050 1051
      testEncode.c
      testTerminal.c
1052
      )
1053
    IF(KWSYS_STANDALONE)
1054
      SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail.c)
1055
    ENDIF()
1056 1057 1058 1059 1060
    CREATE_TEST_SOURCELIST(
      KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
      ${KWSYS_C_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
1061
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
1062
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
1063 1064
    FOREACH(testfile ${KWSYS_C_TESTS})
      get_filename_component(test "${testfile}" NAME_WE)
1065
      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
1066
      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
1067
    ENDFOREACH()
1068 1069

    # C++ tests
1070
    IF(NOT WATCOM AND NOT CMake_SOURCE_DIR)
1071
      SET(KWSYS_CXX_TESTS
1072
        testHashSTL.cxx
1073
        )
1074
    ENDIF()
1075
    SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
1076 1077 1078 1079 1080
      testConfigure.cxx
      testSystemTools.cxx
      testCommandLineArguments.cxx
      testCommandLineArguments1.cxx
      testDirectory.cxx
1081
      )
1082 1083
    IF(KWSYS_STL_HAS_WSTRING)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
1084
        testEncoding.cxx
1085
        )
1086
    ENDIF()
1087 1088
    IF(KWSYS_USE_FStream)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
1089
        testFStream.cxx
1090
        )
1091
    ENDIF()
1092 1093
    IF(KWSYS_USE_ConsoleBuf)
      ADD_EXECUTABLE(testConsoleBufChild testConsoleBufChild.cxx)
Daniel Pfeifer's avatar
Daniel Pfeifer committed
1094 1095
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_CLANG_TIDY "")
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_CLANG_TIDY "")
1096 1097
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
1098
      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
1099
      TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_TARGET_LINK})
1100
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
1101
        testConsoleBuf.cxx
1102 1103
        )
      IF("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" AND
1104
         CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "19.0.23506")
1105 1106 1107 1108 1109
        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()
Bill Hoffman's avatar
Bill Hoffman committed
1110
    IF(KWSYS_USE_SystemInformation)
1111
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation.cxx)
1112
    ENDIF()
1113
    IF(KWSYS_USE_DynamicLoader)
1114
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader.cxx)
1115 1116
      # If kwsys contains the DynamicLoader, need extra library
      ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
1117
      SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
1118
      ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
1119
    ENDIF()
1120 1121 1122 1123 1124
    CREATE_TEST_SOURCELIST(
      KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
      ${KWSYS_CXX_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
Daniel Pfeifer's avatar
Daniel Pfeifer committed
1125 1126
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_CLANG_TIDY "")
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_CLANG_TIDY "")
1127 1128
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
1129
    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
1130
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
1131 1132 1133

    SET(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
    SET(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
1134 1135 1136 1137 1138
    CONFIGURE_FILE(
      ${PROJECT_SOURCE_DIR}/testSystemTools.h.in
      ${PROJECT_BINARY_DIR}/testSystemTools.h)
    INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})

1139 1140 1141 1142
    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")
1143
    ENDIF()
1144 1145

    SET(KWSYS_TEST_ARGS_testCommandLineArguments
1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
      --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