CMakeLua/Source/kwsys/CMakeLists.txt

   1 #=============================================================================
   2 #
   3 #  Program:   KWSys - Kitware System Library
   4 #  Module:    $RCSfile: CMakeLists.txt,v $
   5 #
   6 #  Copyright (c) Kitware, Inc., Insight Consortium.  All rights reserved.
   7 #  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   8 #
   9 #     This software is distributed WITHOUT ANY WARRANTY; without even
  10 #     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11 #     PURPOSE.  See the above copyright notices for more information.
  12 #
  13 #=============================================================================
  14
  15 # The Kitware System Library is intended to be included in other
  16 # projects.  It is completely configurable in that the library's
  17 # namespace can be configured and the components that are included can
  18 # be selected invididually.
  19
  20 # Typical usage is to import the kwsys directory tree into a
  21 # subdirectory under a parent project and enable the classes that will
  22 # be used.  All classes are disabled by default.  The CMake listfile
  23 # above this one configures the library as follows:
  24 #
  25 #  SET(KWSYS_NAMESPACE foosys)
  26 #  SET(KWSYS_USE_Directory 1)    # Enable Directory class.
  27 #  SUBDIRS(kwsys)
  28 #
  29 # Optional settings are as follows:
  30 #
  31 #  KWSYS_HEADER_ROOT = The directory into which to generate the kwsys headers.
  32 #                      A directory called "${KWSYS_NAMESPACE}" will be
  33 #                      created under this root directory to hold the files.
  34 #
  35 #    Example:
  36 #
  37 #      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
  38 #      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
  39 #
  40 #  KWSYS_IOS_FORCE_OLD = Force use of old non-ANSI C++ streams even if
  41 #                        new streams are available.  This may be used
  42 #                        by projects that cannot configure their
  43 #                        streams library.
  44 #    Example:
  45 #
  46 #      SET(KWSYS_IOS_FORCE_OLD 1)
  47 #
  48 #
  49 # Optional settings to setup install rules work in one of two ways.
  50 # The modern way utilizes the CMake 2.4 INSTALL command.  Settings
  51 # for this mode are as follows:
  52 #
  53 #  KWSYS_INSTALL_BIN_DIR     = The installation target directories into
  54 #  KWSYS_INSTALL_LIB_DIR       which the libraries and headers from
  55 #  KWSYS_INSTALL_INCLUDE_DIR   kwsys should be installed by a "make install".
  56 #                              The values should be specified relative to
  57 #                              the installation prefix and NOT start with '/'.
  58 #
  59 #  KWSYS_INSTALL_COMPONENT_NAME_RUNTIME     = Name of runtime and development
  60 #  KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT   installation components.
  61 #                                             If not given the install rules
  62 #                                             will not be in any component.
  63 #
  64 #    Example:
  65 #
  66 #      SET(KWSYS_INSTALL_BIN_DIR bin)
  67 #      SET(KWSYS_INSTALL_LIB_DIR lib)
  68 #      SET(KWSYS_INSTALL_INCLUDE_DIR include)
  69 #      SET(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME Runtime)
  70 #      SET(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT Development)
  71 #
  72 # The old way uses the original CMake INSTALL_* commands.  Settings
  73 # for this mode are as follows:
  74 #
  75 #  KWSYS_LIBRARY_INSTALL_DIR = The installation target directories into
  76 #  KWSYS_HEADER_INSTALL_DIR    which the libraries and headers from
  77 #                              kwsys should be installed by a "make install".
  78 #                              The values should be specified relative to
  79 #                              the installation prefix and start with a '/'.
  80 #    Example:
  81 #
  82 #      SET(KWSYS_LIBRARY_INSTALL_DIR /lib)
  83 #      SET(KWSYS_HEADER_INSTALL_DIR /include)
  84 #
  85 # The modern way will be used whenever the INSTALL command is
  86 # available.  If the settings are not available the old names will be
  87 # used to construct them.  The old way will be used whenever the
  88 # INSTALL command is not available.  If the settings are not available
  89 # the new names will be used to construct them.
  90
  91 # Once configured, kwsys should be used as follows from C or C++ code:
  92 #
  93 #  #include <foosys/Directory.hxx>
  94 #   ...
  95 #  foosys::Directory directory;
  96 #
  97
  98 # NOTE: This library is intended for internal use by Kitware-driven
  99 # projects.  In order to keep it simple no attempt will be made to
 100 # maintain backward compatibility when changes are made to KWSys.
 101 # When an incompatible change is made Kitware's projects that use
 102 # KWSys will be fixed, but no notification will necessarily be sent to
 103 # any outside mailing list and no documentation of the change will be
 104 # written.
 105
 106 #-----------------------------------------------------------------------------
 107 # If a namespace is not specified, use "kwsys" and enable testing.
 108 # This should be the case only when kwsys is not included inside
 109 # another project and is being tested.
 110 IF(NOT KWSYS_NAMESPACE)
 111   SET(KWSYS_NAMESPACE "kwsys")
 112   SET(KWSYS_STANDALONE 1)
 113 ENDIF(NOT KWSYS_NAMESPACE)
 114
 115 #-----------------------------------------------------------------------------
 116 # The project name is that of the specified namespace.
 117 PROJECT(${KWSYS_NAMESPACE})
 118
 119 # Select library components.
 120 IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
 121   SET(KWSYS_ENABLE_C 1)
 122
 123   # Enable all components.
 124   SET(KWSYS_USE_Base64 1)
 125   SET(KWSYS_USE_Directory 1)
 126   SET(KWSYS_USE_DynamicLoader 1)
 127   SET(KWSYS_USE_Glob 1)
 128   SET(KWSYS_USE_MD5 1)
 129   SET(KWSYS_USE_Process 1)
 130   SET(KWSYS_USE_RegularExpression 1)
 131   SET(KWSYS_USE_Registry 1)
 132   SET(KWSYS_USE_System 1)
 133   SET(KWSYS_USE_SystemTools 1)
 134   SET(KWSYS_USE_CommandLineArguments 1)
 135   SET(KWSYS_USE_FundamentalType 1)
 136   SET(KWSYS_USE_Terminal 1)
 137   SET(KWSYS_USE_IOStream 1)
 138   SET(KWSYS_USE_DateStamp 1)
 139   SET(KWSYS_USE_String 1)
 140   SET(KWSYS_USE_SystemInformation 1)
 141 ENDIF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
 142
 143 # Setup the large file support default.
 144 IF(KWSYS_LFS_DISABLE)
 145   SET(KWSYS_LFS_REQUESTED 0)
 146 ELSE(KWSYS_LFS_DISABLE)
 147   SET(KWSYS_LFS_REQUESTED 1)
 148 ENDIF(KWSYS_LFS_DISABLE)
 149
 150 # Enable testing if building standalone.
 151 IF(KWSYS_STANDALONE)
 152   INCLUDE(Dart)
 153   MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
 154   IF(BUILD_TESTING)
 155     ENABLE_TESTING()
 156   ENDIF(BUILD_TESTING)
 157 ENDIF(KWSYS_STANDALONE)
 158
 159 # Include helper macros.
 160 INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
 161 INCLUDE(CheckTypeSize)
 162
 163 # Do full dependency headers.
 164 INCLUDE_REGULAR_EXPRESSION("^.*$")
 165
 166 # Choose which kind of install commands to use.
 167 IF(COMMAND INSTALL)
 168   # Use new KWSYS_INSTALL_*_DIR variable names to control installation.
 169   # Take defaults from the old names.  Note that there was no old name
 170   # for the bin dir, so we take the old lib dir name so DLLs will be
 171   # installed in a compatible way for old code.
 172   IF(NOT KWSYS_INSTALL_INCLUDE_DIR)
 173     STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
 174       "${KWSYS_HEADER_INSTALL_DIR}")
 175   ENDIF(NOT KWSYS_INSTALL_INCLUDE_DIR)
 176   IF(NOT KWSYS_INSTALL_LIB_DIR)
 177     STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
 178       "${KWSYS_LIBRARY_INSTALL_DIR}")
 179   ENDIF(NOT KWSYS_INSTALL_LIB_DIR)
 180   IF(NOT KWSYS_INSTALL_BIN_DIR)
 181     STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
 182       "${KWSYS_LIBRARY_INSTALL_DIR}")
 183   ENDIF(NOT KWSYS_INSTALL_BIN_DIR)
 184
 185   # Setup header install rules.
 186   SET(KWSYS_INSTALL_INCLUDE_OPTIONS)
 187   IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
 188     SET(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
 189       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
 190       )
 191   ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
 192
 193   # Setup library install rules.
 194   SET(KWSYS_INSTALL_LIBRARY_RULE)
 195   IF(KWSYS_INSTALL_LIB_DIR)
 196     # Install the shared library to the lib directory.
 197     SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 198       LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR}
 199       )
 200     # Assign the shared library to the runtime component.
 201     IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
 202       SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 203         COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
 204         )
 205     ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
 206
 207     # Install the archive to the lib directory.
 208     SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 209       ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
 210       )
 211     # Assign the archive to the development component.
 212     IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
 213       SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 214         COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
 215         )
 216     ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
 217   ENDIF(KWSYS_INSTALL_LIB_DIR)
 218   IF(KWSYS_INSTALL_BIN_DIR)
 219     # Install the runtime library to the bin directory.
 220     SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 221       RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
 222       )
 223     # Assign the runtime library to the runtime component.
 224     IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
 225       SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
 226         COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
 227         )
 228     ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
 229   ENDIF(KWSYS_INSTALL_BIN_DIR)
 230
 231   # Do not support old KWSYS_*_INSTALL_DIR variable names.
 232   SET(KWSYS_HEADER_INSTALL_DIR)
 233   SET(KWSYS_LIBRARY_INSTALL_DIR)
 234
 235 ELSE(COMMAND INSTALL)
 236   # Use old KWSYS_*_INSTALL_DIR variable names.
 237   # Take defaults from the new names.
 238   IF(KWSYS_INSTALL_LIB_DIR)
 239     IF(NOT KWSYS_LIBRARY_INSTALL_DIR)
 240       SET(KWSYS_LIBRARY_INSTALL_DIR "/${KWSYS_INSTALL_LIB_DIR}")
 241     ENDIF(NOT KWSYS_LIBRARY_INSTALL_DIR)
 242   ENDIF(KWSYS_INSTALL_LIB_DIR)
 243   IF(KWSYS_INSTALL_INCLUDE_DIR)
 244     IF(NOT KWSYS_HEADER_INSTALL_DIR)
 245       SET(KWSYS_HEADER_INSTALL_DIR "/${KWSYS_INSTALL_INCLUDE_DIR}")
 246     ENDIF(NOT KWSYS_HEADER_INSTALL_DIR)
 247   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 248
 249   # Do not support new KWSYS_INSTALL_*_DIR variable names.
 250   SET(KWSYS_INSTALL_BIN_DIR)
 251   SET(KWSYS_INSTALL_INCLUDE_DIR)
 252   SET(KWSYS_INSTALL_LIB_DIR)
 253 ENDIF(COMMAND INSTALL)
 254
 255 # Work-around for CMake 1.6.7 bug in custom command dependencies when
 256 # there is no executable output path.
 257 IF(NOT EXECUTABLE_OUTPUT_PATH)
 258   SET(EXECUTABLE_OUTPUT_PATH "${PROJECT_BINARY_DIR}" CACHE PATH
 259       "Output directory for executables.")
 260 ENDIF(NOT EXECUTABLE_OUTPUT_PATH)
 261
 262 # Generated source files will need this header.
 263 STRING(COMPARE EQUAL "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}"
 264   KWSYS_IN_SOURCE_BUILD)
 265 IF(NOT KWSYS_IN_SOURCE_BUILD)
 266   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsysPrivate.h
 267     ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPY_ONLY IMMEDIATE)
 268 ENDIF(NOT KWSYS_IN_SOURCE_BUILD)
 269
 270 #-----------------------------------------------------------------------------
 271 # We require ANSI support from the C compiler.  Add any needed flags.
 272 IF(CMAKE_ANSI_CFLAGS)
 273   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
 274 ENDIF(CMAKE_ANSI_CFLAGS)
 275
 276 #-----------------------------------------------------------------------------
 277 # Adjust compiler flags for some platforms.
 278 IF(NOT CMAKE_COMPILER_IS_GNUCXX)
 279   IF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
 280     STRING(REGEX MATCH "-timplicit_local"
 281       KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL "${CMAKE_CXX_FLAGS}")
 282     STRING(REGEX MATCH "-no_implicit_include"
 283       KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE "${CMAKE_CXX_FLAGS}")
 284     IF(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
 285       SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local")
 286     ENDIF(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
 287     IF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
 288       SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
 289     ENDIF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
 290   ENDIF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
 291   IF(CMAKE_SYSTEM MATCHES "HP-UX")
 292     SET(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
 293   ENDIF(CMAKE_SYSTEM MATCHES "HP-UX")
 294 ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)
 295
 296 #-----------------------------------------------------------------------------
 297 # Configure Large File Support.
 298 SET(KWSYS_LFS_AVAILABLE 0)
 299 IF(KWSYS_LFS_REQUESTED)
 300   # Large File Support is requested.
 301   SET(KWSYS_LFS_REQUESTED 1)
 302
 303   # Check for large file support.
 304   KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_LFS_WORKS
 305     "Checking for Large File Support" DIRECT)
 306
 307   IF(KWSYS_LFS_WORKS)
 308     SET(KWSYS_LFS_AVAILABLE 1)
 309   ENDIF(KWSYS_LFS_WORKS)
 310 ELSE(KWSYS_LFS_REQUESTED)
 311   # Large File Support is not requested.
 312   SET(KWSYS_LFS_REQUESTED 0)
 313 ENDIF(KWSYS_LFS_REQUESTED)
 314
 315 #-----------------------------------------------------------------------------
 316 # Configure the standard library header wrappers based on compiler's
 317 # capabilities and parent project's request.  Enforce 0/1 as only
 318 # possible values for configuration into Configure.hxx.
 319
 320 KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAVE_STD
 321   "Checking whether STL classes are in std namespace" DIRECT)
 322
 323 IF(KWSYS_IOS_FORCE_OLD)
 324   SET(KWSYS_IOS_USE_ANSI 0)
 325 ELSE(KWSYS_IOS_FORCE_OLD)
 326   KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_ANSI
 327     "Checking whether ANSI stream headers are available" DIRECT)
 328 ENDIF(KWSYS_IOS_FORCE_OLD)
 329
 330 IF(KWSYS_IOS_USE_ANSI)
 331   KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_STD
 332     "Checking whether ANSI streams are in std namespace" DIRECT)
 333   KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_SSTREAM
 334     "Checking whether ANSI string stream is available" DIRECT)
 335 ELSE(KWSYS_IOS_USE_ANSI)
 336   SET(KWSYS_IOS_HAVE_STD 0)
 337   SET(KWSYS_IOS_USE_SSTREAM 0)
 338 ENDIF(KWSYS_IOS_USE_ANSI)
 339
 340 IF(KWSYS_IOS_USE_SSTREAM)
 341   SET(KWSYS_IOS_USE_STRSTREAM_H 0)
 342   SET(KWSYS_IOS_USE_STRSTREA_H 0)
 343 ELSE(KWSYS_IOS_USE_SSTREAM)
 344   KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREAM_H
 345     "Checking whether strstream.h is available" DIRECT)
 346   IF(KWSYS_IOS_USE_STRSTREAM_H)
 347     SET(KWSYS_IOS_USE_STRSTREA_H 0)
 348   ELSE(KWSYS_IOS_USE_STRSTREAM_H)
 349     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREA_H
 350       "Checking whether strstrea.h is available" DIRECT)
 351   ENDIF(KWSYS_IOS_USE_STRSTREAM_H)
 352 ENDIF(KWSYS_IOS_USE_SSTREAM)
 353
 354 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDDEF
 355   "Checking whether header cstddef is available" DIRECT)
 356
 357 SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
 358   -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD})
 359 KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_NEQ_CHAR
 360   "Checking whether stl string has operator!= for char*" DIRECT)
 361 KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_TRAITS
 362   "Checking whether stl has iterator_traits" DIRECT)
 363 IF(KWSYS_STL_HAS_ITERATOR_TRAITS)
 364   SET(KWSYS_STL_HAS_ITERATOR_CATEGORY 0)
 365   SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
 366 ELSE(KWSYS_STL_HAS_ITERATOR_TRAITS)
 367   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_CATEGORY
 368     "Checking whether stl has old iterator_category" DIRECT)
 369   IF(KWSYS_STL_HAS_ITERATOR_CATEGORY)
 370     SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
 371   ELSE(KWSYS_STL_HAS_ITERATOR_CATEGORY)
 372     KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS___ITERATOR_CATEGORY
 373       "Checking whether stl has internal __iterator_category" DIRECT)
 374   ENDIF(KWSYS_STL_HAS_ITERATOR_CATEGORY)
 375 ENDIF(KWSYS_STL_HAS_ITERATOR_TRAITS)
 376 KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
 377   "Checking whether stl has standard template allocator" DIRECT)
 378 IF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
 379   SET(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE 0)
 380   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_REBIND
 381     "Checking for rebind member of stl allocator" DIRECT)
 382   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
 383     "Checking for non-standard argument to stl allocator<>::max_size" DIRECT)
 384 ELSE(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
 385   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
 386     "Checking whether stl has old non-template allocator" DIRECT)
 387   SET(KWSYS_STL_HAS_ALLOCATOR_REBIND 0)
 388   SET(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT 0)
 389 ENDIF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
 390 KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_OBJECTS
 391   "Checking whether stl containers support allocator objects." DIRECT)
 392 IF(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
 393   # ANSI streams always have string operators.
 394   SET(KWSYS_STL_STRING_HAVE_OSTREAM 1)
 395   SET(KWSYS_STL_STRING_HAVE_ISTREAM 1)
 396 ELSE(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
 397   # There may not be string operators for old streams.
 398   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_OSTREAM
 399     "Checking whether stl string has ostream operator<<" DIRECT)
 400   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_ISTREAM
 401     "Checking whether stl string has istream operator>>" DIRECT)
 402 ENDIF(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
 403 SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
 404
 405 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
 406   "Checking whether \"<>\" is needed for template friends" INVERT)
 407 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_MEMBER_TEMPLATES
 408   "Checking for member template support" DIRECT)
 409 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_FULL_SPECIALIZATION
 410   "Checking for standard template specialization syntax" DIRECT)
 411 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
 412   "Checking whether argument dependent lookup is supported" DIRECT)
 413
 414 IF(UNIX)
 415   KWSYS_PLATFORM_CXX_TEST(KWSYS_STAT_HAS_ST_MTIM
 416     "Checking whether struct stat has st_mtim member" DIRECT)
 417 ENDIF(UNIX)
 418
 419 IF(KWSYS_USE_FundamentalType)
 420   # Determine type sizes.
 421   CHECK_TYPE_SIZE("char"      KWSYS_SIZEOF_CHAR)
 422   CHECK_TYPE_SIZE("short"     KWSYS_SIZEOF_SHORT)
 423   CHECK_TYPE_SIZE("int"       KWSYS_SIZEOF_INT)
 424   CHECK_TYPE_SIZE("long"      KWSYS_SIZEOF_LONG)
 425   CHECK_TYPE_SIZE("long long" KWSYS_SIZEOF_LONG_LONG)
 426   CHECK_TYPE_SIZE("__int64"   KWSYS_SIZEOF___INT64)
 427   IF(NOT KWSYS_SIZEOF_LONG_LONG)
 428     SET(KWSYS_SIZEOF_LONG_LONG 0)
 429   ENDIF(NOT KWSYS_SIZEOF_LONG_LONG)
 430   IF(NOT KWSYS_SIZEOF___INT64)
 431     SET(KWSYS_SIZEOF___INT64 0)
 432   ENDIF(NOT KWSYS_SIZEOF___INT64)
 433
 434   # Check uniqueness of types.
 435   IF(KWSYS_SIZEOF___INT64)
 436     KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_AND___INT64
 437       "Checking whether long and __int64 are the same type" DIRECT)
 438     IF(KWSYS_SIZEOF_LONG_LONG)
 439       KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_LONG_AND___INT64
 440         "Checking whether long long and __int64 are the same type" DIRECT)
 441     ENDIF(KWSYS_SIZEOF_LONG_LONG)
 442   ENDIF(KWSYS_SIZEOF___INT64)
 443
 444   # Enable the "long long" type if it is available.  It is standard in
 445   # C99 and C++03 but not in earlier standards.
 446   IF(KWSYS_SIZEOF_LONG_LONG)
 447     SET(KWSYS_USE_LONG_LONG 1)
 448   ELSE(KWSYS_SIZEOF_LONG_LONG)
 449     SET(KWSYS_USE_LONG_LONG 0)
 450   ENDIF(KWSYS_SIZEOF_LONG_LONG)
 451
 452   # Enable the "__int64" type if it is available and unique.  It is not
 453   # standard.
 454   SET(KWSYS_USE___INT64 0)
 455   IF(KWSYS_SIZEOF___INT64)
 456     IF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
 457       IF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
 458         SET(KWSYS_USE___INT64 1)
 459       ENDIF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
 460     ENDIF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
 461   ENDIF(KWSYS_SIZEOF___INT64)
 462   IF(KWSYS_USE___INT64)
 463     KWSYS_PLATFORM_CXX_TEST(KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
 464       "Checking whether unsigned __int64 can convert to double" DIRECT)
 465   ELSE(KWSYS_USE___INT64)
 466     SET(KWSYS_CAN_CONVERT_UI64_TO_DOUBLE 1)
 467   ENDIF(KWSYS_USE___INT64)
 468
 469   # Check signedness of "char" type.
 470   KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_CHAR_IS_SIGNED
 471     "Checking whether char is signed" DIRECT)
 472 ENDIF(KWSYS_USE_FundamentalType)
 473
 474 IF(KWSYS_USE_IOStream)
 475   # Determine whether iostreams support long long.
 476   CHECK_TYPE_SIZE("long long" KWSYS_SIZEOF_LONG_LONG)
 477   IF(KWSYS_SIZEOF_LONG_LONG)
 478     SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
 479       -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI}
 480       -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD})
 481     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM_LONG_LONG
 482       "Checking if istream supports long long" DIRECT)
 483     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_OSTREAM_LONG_LONG
 484       "Checking if ostream supports long long" DIRECT)
 485     SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
 486   ELSE(KWSYS_SIZEOF_LONG_LONG)
 487     SET(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
 488     SET(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
 489   ENDIF(KWSYS_SIZEOF_LONG_LONG)
 490 ENDIF(KWSYS_USE_IOStream)
 491
 492 IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
 493   SET(KWSYS_NAME_IS_KWSYS 1)
 494 ELSE(KWSYS_NAMESPACE MATCHES "^kwsys$")
 495   SET(KWSYS_NAME_IS_KWSYS 0)
 496 ENDIF(KWSYS_NAMESPACE MATCHES "^kwsys$")
 497
 498 # Choose default shared/static build if not specified.
 499 IF(KWSYS_BUILD_SHARED MATCHES "^KWSYS_BUILD_SHARED$")
 500   SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
 501 ENDIF(KWSYS_BUILD_SHARED MATCHES "^KWSYS_BUILD_SHARED$")
 502
 503 IF(KWSYS_BUILD_SHARED)
 504   SET(KWSYS_BUILD_SHARED 1)
 505   SET(KWSYS_LIBRARY_TYPE SHARED)
 506 ELSE(KWSYS_BUILD_SHARED)
 507   SET(KWSYS_BUILD_SHARED 0)
 508   SET(KWSYS_LIBRARY_TYPE STATIC)
 509 ENDIF(KWSYS_BUILD_SHARED)
 510
 511 #-----------------------------------------------------------------------------
 512 # Choose a directory for the generated headers.
 513 IF(NOT KWSYS_HEADER_ROOT)
 514   SET(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
 515 ENDIF(NOT KWSYS_HEADER_ROOT)
 516 SET(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
 517 INCLUDE_DIRECTORIES(${KWSYS_HEADER_ROOT})
 518
 519 #-----------------------------------------------------------------------------
 520 # Create STL header wrappers to block warnings in the STL headers and
 521 # give standard names by which they may be included.
 522 SET(KWSYS_STL_HEADER_EXTRA_string 1)
 523 FOREACH(header
 524   algorithm
 525   deque
 526   exception
 527   functional
 528   iterator
 529   list
 530   map
 531   memory
 532   new
 533   numeric
 534   queue
 535   set
 536   stack
 537   stdexcept
 538   string
 539   utility
 540   vector
 541   )
 542   # Configure the header wrapper.
 543   SET(KWSYS_STL_HEADER "${header}")
 544   IF(KWSYS_STL_HEADER_EXTRA_${header})
 545     SET(KWSYS_STL_HEADER_EXTRA
 546       "#define ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n# include <${KWSYS_NAMESPACE}/stl/${header}.hxx>\n#undef ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n")
 547     CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl_${header}.hxx.in
 548                    ${KWSYS_HEADER_DIR}/stl/${header}.hxx
 549                    @ONLY IMMEDIATE)
 550     IF(KWSYS_INSTALL_INCLUDE_DIR)
 551       INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx
 552         DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
 553         ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 554     ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 555     IF(KWSYS_HEADER_INSTALL_DIR)
 556       INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
 557         FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx)
 558     ENDIF(KWSYS_HEADER_INSTALL_DIR)
 559   ELSE(KWSYS_STL_HEADER_EXTRA_${header})
 560     SET(KWSYS_STL_HEADER_EXTRA "")
 561   ENDIF(KWSYS_STL_HEADER_EXTRA_${header})
 562   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl.hxx.in
 563                  ${KWSYS_HEADER_DIR}/stl/${header}
 564                  @ONLY IMMEDIATE)
 565
 566   # Create an install target for the header wrapper.
 567   IF(KWSYS_INSTALL_INCLUDE_DIR)
 568     INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}
 569       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
 570       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 571   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 572   IF(KWSYS_HEADER_INSTALL_DIR)
 573     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
 574       FILES ${KWSYS_HEADER_DIR}/stl/${header})
 575   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 576 ENDFOREACH(header)
 577
 578 # Provide cstddef header.
 579 CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_cstddef.hxx.in
 580                ${KWSYS_HEADER_DIR}/cstddef
 581                @ONLY IMMEDIATE)
 582 IF(KWSYS_INSTALL_INCLUDE_DIR)
 583   INSTALL(FILES ${KWSYS_HEADER_DIR}/cstddef
 584     DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
 585     ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 586   IF(KWSYS_HEADER_INSTALL_DIR)
 587     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
 588       FILES ${KWSYS_HEADER_DIR}/cstddef)
 589   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 590 ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 591
 592 #-----------------------------------------------------------------------------
 593 # Create streams header wrappers to give standard names by which they
 594 # may be included.
 595 FOREACH(header iostream fstream sstream iosfwd)
 596   # Configure the header wrapper.
 597   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_ios_${header}.h.in
 598                  ${KWSYS_HEADER_DIR}/ios/${header}
 599                  @ONLY IMMEDIATE)
 600
 601   # Create an install target for the header wrapper.
 602   IF(KWSYS_INSTALL_INCLUDE_DIR)
 603     INSTALL(FILES ${KWSYS_HEADER_DIR}/ios/${header}
 604       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/ios
 605       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 606   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 607   IF(KWSYS_HEADER_INSTALL_DIR)
 608     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/ios
 609       FILES ${KWSYS_HEADER_DIR}/ios/${header})
 610   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 611 ENDFOREACH(header)
 612
 613 #-----------------------------------------------------------------------------
 614 # Build a list of classes and headers we need to implement the
 615 # selected components.  Initialize with required components.
 616 SET(KWSYS_CLASSES)
 617 SET(KWSYS_H_FILES Configure SharedForward)
 618 SET(KWSYS_HXX_FILES Configure String
 619   hashtable hash_fun hash_map hash_set
 620   auto_ptr
 621   )
 622
 623 # Enforce component dependencies.
 624 IF(KWSYS_USE_SystemTools)
 625   SET(KWSYS_USE_Directory 1)
 626 ENDIF(KWSYS_USE_SystemTools)
 627 IF(KWSYS_USE_Glob)
 628   SET(KWSYS_USE_Directory 1)
 629   SET(KWSYS_USE_SystemTools 1)
 630   SET(KWSYS_USE_RegularExpression 1)
 631 ENDIF(KWSYS_USE_Glob)
 632 IF(KWSYS_USE_Process)
 633   SET(KWSYS_USE_System 1)
 634 ENDIF(KWSYS_USE_Process)
 635
 636 # Add selected C++ classes.
 637 SET(cppclasses
 638   Directory DynamicLoader Glob RegularExpression SystemTools
 639   CommandLineArguments Registry IOStream SystemInformation
 640   )
 641 FOREACH(cpp ${cppclasses})
 642   IF(KWSYS_USE_${cpp})
 643     # Use the corresponding class.
 644     SET(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
 645
 646     # Load component-specific CMake code.
 647     IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
 648       INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
 649     ENDIF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
 650   ENDIF(KWSYS_USE_${cpp})
 651 ENDFOREACH(cpp)
 652
 653 # Add selected C components.
 654 FOREACH(c Process Base64 FundamentalType MD5 Terminal System DateStamp String)
 655   IF(KWSYS_USE_${c})
 656     # Use the corresponding header file.
 657     SET(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})
 658
 659     # Load component-specific CMake code.
 660     IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
 661       INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
 662     ENDIF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
 663   ENDIF(KWSYS_USE_${c})
 664 ENDFOREACH(c)
 665
 666 #-----------------------------------------------------------------------------
 667 # Build a list of sources for the library based on components that are
 668 # included.
 669 SET(KWSYS_C_SRCS)
 670 SET(KWSYS_CXX_SRCS)
 671
 672 # Add the proper sources for this platform's Process implementation.
 673 IF(KWSYS_USE_Process)
 674   IF(NOT UNIX)
 675     # Use the Windows implementation.  We need the encoded forwarding executable.
 676     SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c
 677       ${PROJECT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c)
 678     SET_SOURCE_FILES_PROPERTIES(
 679       ${PROJECT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
 680       PROPERTIES GENERATED 1)
 681   ELSE(NOT UNIX)
 682     # Use the UNIX implementation.
 683     SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
 684
 685     # Help ProcessUNIX.c compile properly on all platforms.
 686     KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_PTRDIFF_T
 687       "Checking whether C compiler has ptrdiff_t in stddef.h" DIRECT)
 688     KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_SSIZE_T
 689       "Checking whether C compiler has ssize_t in unistd.h" DIRECT)
 690     SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c PROPERTIES
 691       COMPILE_FLAGS "-DKWSYS_C_HAS_PTRDIFF_T=${KWSYS_C_HAS_PTRDIFF_T} -DKWSYS_C_HAS_SSIZE_T=${KWSYS_C_HAS_SSIZE_T}"
 692       )
 693   ENDIF(NOT UNIX)
 694 ENDIF(KWSYS_USE_Process)
 695
 696 # Add selected C sources.
 697 FOREACH(c Base64 MD5 Terminal System String)
 698   IF(KWSYS_USE_${c})
 699     SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${c}.c)
 700   ENDIF(KWSYS_USE_${c})
 701 ENDFOREACH(c)
 702
 703 # Configure headers of C++ classes and construct the list of sources.
 704 FOREACH(c ${KWSYS_CLASSES})
 705   # Add this source to the list of source files for the library.
 706   SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${c}.cxx)
 707
 708   # Configure the header for this class.
 709   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${c}.hxx.in ${KWSYS_HEADER_DIR}/${c}.hxx
 710                  @ONLY IMMEDIATE)
 711
 712   # Create an install target for the header.
 713   IF(KWSYS_INSTALL_INCLUDE_DIR)
 714     INSTALL(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
 715       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
 716       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 717   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 718   IF(KWSYS_HEADER_INSTALL_DIR)
 719     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
 720                   FILES  ${KWSYS_HEADER_DIR}/${c}.hxx)
 721   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 722 ENDFOREACH(c)
 723
 724 # Configure C headers.
 725 FOREACH(h ${KWSYS_H_FILES})
 726   # Configure the header into the given directory.
 727   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.h.in ${KWSYS_HEADER_DIR}/${h}.h
 728                  @ONLY IMMEDIATE)
 729
 730   # Create an install target for the header.
 731   IF(KWSYS_INSTALL_INCLUDE_DIR)
 732     INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.h
 733       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
 734       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 735   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 736   IF(KWSYS_HEADER_INSTALL_DIR)
 737     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
 738                   FILES  ${KWSYS_HEADER_DIR}/${h}.h)
 739   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 740 ENDFOREACH(h)
 741
 742 # Configure other C++ headers.
 743 FOREACH(h ${KWSYS_HXX_FILES})
 744   # Configure the header into the given directory.
 745   CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.hxx.in ${KWSYS_HEADER_DIR}/${h}.hxx
 746                  @ONLY IMMEDIATE)
 747
 748   # Create an install target for the header.
 749   IF(KWSYS_INSTALL_INCLUDE_DIR)
 750     INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
 751       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
 752       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
 753   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 754   IF(KWSYS_HEADER_INSTALL_DIR)
 755     INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
 756                   FILES  ${KWSYS_HEADER_DIR}/${h}.hxx)
 757   ENDIF(KWSYS_HEADER_INSTALL_DIR)
 758 ENDFOREACH(h)
 759
 760 #-----------------------------------------------------------------------------
 761 # Add the library with the configured name and list of sources.
 762 IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
 763   ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
 764     ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
 765   IF(KWSYS_USE_DynamicLoader)
 766     IF(UNIX)
 767       TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
 768     ENDIF(UNIX)
 769   ENDIF(KWSYS_USE_DynamicLoader)
 770
 771   IF(KWSYS_USE_SystemInformation AND WIN32)
 772     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ws2_32)
 773   ENDIF(KWSYS_USE_SystemInformation AND WIN32)
 774
 775   # Apply user-defined target properties to the library.
 776   IF(KWSYS_PROPERTIES_CXX)
 777     SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
 778       ${KWSYS_PROPERTIES_CXX}
 779       )
 780   ENDIF(KWSYS_PROPERTIES_CXX)
 781
 782   # Create an install target for the library.
 783   IF(KWSYS_INSTALL_LIBRARY_RULE)
 784     INSTALL(TARGETS ${KWSYS_NAMESPACE} ${KWSYS_INSTALL_LIBRARY_RULE})
 785   ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
 786   IF(KWSYS_LIBRARY_INSTALL_DIR)
 787     INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE})
 788   ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
 789 ENDIF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
 790
 791 # Add a C-only library if requested.
 792 IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
 793   ADD_LIBRARY(${KWSYS_NAMESPACE}_c ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS})
 794
 795   # Apply user-defined target properties to the library.
 796   IF(KWSYS_PROPERTIES_C)
 797     SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
 798       ${KWSYS_PROPERTIES_C}
 799       )
 800   ENDIF(KWSYS_PROPERTIES_C)
 801
 802   # Create an install target for the library.
 803   IF(KWSYS_INSTALL_LIBRARY_RULE)
 804     INSTALL(TARGETS ${KWSYS_NAMESPACE}_c ${KWSYS_INSTALL_LIBRARY_RULE})
 805   ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
 806   IF(KWSYS_LIBRARY_INSTALL_DIR)
 807     INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE}_c)
 808   ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
 809 ENDIF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
 810
 811 # For building kwsys itself, we use a macro defined on the command
 812 # line to configure the namespace in the C and C++ source files.
 813 ADD_DEFINITIONS("-DKWSYS_NAMESPACE=${KWSYS_NAMESPACE}")
 814
 815 #-----------------------------------------------------------------------------
 816 # Process execution on windows needs to build a forwarding executable
 817 # that works around a Win9x bug.  We encode the executable into a C
 818 # file and build it into the library.  Win9x platforms reproduce the
 819 # executable into a temporary directory when it is needed.
 820 IF(KWSYS_USE_Process)
 821   IF(NOT UNIX)
 822     # Build the forwarding executable itself and a program that will
 823     # encode it into a C file.
 824     ADD_EXECUTABLE(${KWSYS_NAMESPACE}ProcessFwd9x ProcessFwd9x.c)
 825     ADD_EXECUTABLE(${KWSYS_NAMESPACE}EncodeExecutable EncodeExecutable.c)
 826
 827     # Construct the location of the executable to be encoded.
 828     SET(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
 829     IF(EXECUTABLE_OUTPUT_PATH)
 830       SET(BIN_DIR ${EXECUTABLE_OUTPUT_PATH})
 831     ENDIF(EXECUTABLE_OUTPUT_PATH)
 832
 833     SET(CFG_INTDIR "/${CMAKE_CFG_INTDIR}")
 834     IF(CMAKE_BUILD_TOOL MATCHES "make")
 835       SET(CFG_INTDIR "")
 836     ENDIF(CMAKE_BUILD_TOOL MATCHES "make")
 837
 838     # Take advantage of a better custom command syntax if possible.
 839     SET(CMD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}EncodeExecutable.exe)
 840     SET(FWD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}ProcessFwd9x.exe)
 841     IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
 842       ADD_CUSTOM_COMMAND(
 843         OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
 844         COMMAND ${CMD}
 845         ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
 846              ${KWSYS_NAMESPACE} ProcessFwd9x
 847         DEPENDS ${CMD} ${FWD})
 848     ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
 849       ADD_CUSTOM_COMMAND(
 850         TARGET ${KWSYS_NAMESPACE}
 851         SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/ProcessFwd9x.c
 852         COMMAND ${CMD}
 853         ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
 854              ${KWSYS_NAMESPACE} ProcessFwd9x
 855         OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
 856         DEPENDS ${CMD} ${FWD})
 857     ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
 858
 859     # Make sure build occurs in proper order.
 860     ADD_DEPENDENCIES(${KWSYS_NAMESPACE} ${KWSYS_NAMESPACE}ProcessFwd9x
 861                      ${KWSYS_NAMESPACE}EncodeExecutable)
 862   ENDIF(NOT UNIX)
 863 ENDIF(KWSYS_USE_Process)
 864
 865 #-----------------------------------------------------------------------------
 866 # Setup testing if not being built as part of another project.
 867 IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
 868   IF(BUILD_TESTING)
 869     # Compute the location of executables.
 870     SET(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 871     IF(EXECUTABLE_OUTPUT_PATH)
 872       SET(EXEC_DIR "${EXECUTABLE_OUTPUT_PATH}")
 873     ENDIF(EXECUTABLE_OUTPUT_PATH)
 874
 875     # C tests
 876     SET(KWSYS_C_TESTS
 877       testEncode
 878       testTerminal
 879       )
 880     IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
 881       SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail)
 882     ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
 883     CREATE_TEST_SOURCELIST(
 884       KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
 885       ${KWSYS_C_TESTS}
 886       )
 887     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
 888     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_NAMESPACE}_c)
 889     FOREACH(test ${KWSYS_C_TESTS})
 890       ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
 891     ENDFOREACH(test)
 892
 893     # C++ tests
 894     IF(NOT WATCOM)
 895       SET(KWSYS_CXX_TESTS
 896         testAutoPtr
 897         testHashSTL
 898         )
 899     ENDIF(NOT WATCOM)
 900     SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
 901       testRegistry
 902       testIOS
 903       testSystemTools
 904       testCommandLineArguments
 905       testCommandLineArguments1
 906       )
 907     IF(KWSYS_USE_SystemInformation)
 908       SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation)
 909     ENDIF(KWSYS_USE_SystemInformation)
 910     IF(KWSYS_USE_DynamicLoader)
 911       SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader)
 912       # If kwsys contains the DynamicLoader, need extra library
 913       ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
 914     ENDIF(KWSYS_USE_DynamicLoader)
 915     CREATE_TEST_SOURCELIST(
 916       KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
 917       ${KWSYS_CXX_TESTS}
 918       )
 919     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
 920     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_NAMESPACE})
 921     SET(TEST_SYSTEMTOOLS_BIN_FILE
 922       "${CMAKE_CURRENT_SOURCE_DIR}/testSystemTools.bin")
 923     SET(TEST_SYSTEMTOOLS_SRC_FILE
 924       "${CMAKE_CURRENT_SOURCE_DIR}/testSystemTools.cxx")
 925     CONFIGURE_FILE(
 926       ${PROJECT_SOURCE_DIR}/testSystemTools.h.in
 927       ${PROJECT_BINARY_DIR}/testSystemTools.h)
 928     INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
 929
 930     IF(CTEST_TEST_KWSYS)
 931       CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ExtraTest.cmake.in"
 932         "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
 933       SET_DIRECTORY_PROPERTIES(PROPERTIES TEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
 934     ENDIF(CTEST_TEST_KWSYS)
 935
 936     SET(KWSYS_TEST_ARGS_testCommandLineArguments
 937       --another-bool-variable
 938       --long3=opt
 939       --set-bool-arg1
 940       -SSS ken brad bill andy
 941       --some-bool-variable=true
 942       --some-double-variable12.5
 943       --some-int-variable 14
 944       "--some-string-variable=test string with space"
 945       --some-multi-argument 5 1 8 3 7 1 3 9 7 1
 946       -N 12.5 -SS=andy -N 1.31 -N 22
 947       -SS=bill -BBtrue -SS=brad
 948       -BBtrue
 949       -BBfalse
 950       -SS=ken
 951       -A
 952       -C=test
 953       --long2 hello
 954       )
 955     SET(KWSYS_TEST_ARGS_testCommandLineArguments1
 956       --ignored
 957       -n 24
 958       --second-ignored
 959       "-m=test value"
 960       third-ignored
 961       -p
 962       some junk at the end
 963       )
 964     FOREACH(test ${KWSYS_CXX_TESTS})
 965       ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
 966     ENDFOREACH(test)
 967
 968     # Process tests.
 969     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
 970     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_NAMESPACE}_c)
 971     IF(NOT CYGWIN)
 972       SET(KWSYS_TEST_PROCESS_7 7)
 973     ENDIF(NOT CYGWIN)
 974     FOREACH(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7})
 975       ADD_TEST(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
 976     ENDFOREACH(n)
 977
 978     # Configure some test properties.
 979     IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
 980       # We expect test to fail
 981       SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES WILL_FAIL ON)
 982       GET_TEST_PROPERTY(kwsys.testFail WILL_FAIL wfv)
 983       SET_TESTS_PROPERTIES(kwsys.testRegistry PROPERTIES FAIL_REGULAR_EXPRESSION "ERROR_NOT_VALGRIND;FAIL;Test failed")
 984       SET_TESTS_PROPERTIES(kwsys.testRegistry PROPERTIES PASS_REGULAR_EXPRESSION "Test passed")
 985       SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
 986       MESSAGE(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
 987     ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
 988   ENDIF(BUILD_TESTING)
 989 ENDIF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)