CMakeLists.txt 41.7 KB
Newer Older
1
#=============================================================================
2
3
# KWSys - Kitware System Library
# Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
4
#
5
6
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
7
#
8
9
10
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
11
12
13
14
#=============================================================================

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

# Typical usage is to import the kwsys directory tree into a
19
20
21
# 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:
22
#
23
24
#  SET(KWSYS_NAMESPACE foosys)
#  SET(KWSYS_USE_Directory 1)    # Enable Directory class.
25
26
27
28
#  SUBDIRS(kwsys)
#
# Optional settings are as follows:
#
29
30
31
#  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.
32
33
34
#
#    Example:
#
Andy Cedilnik's avatar
Andy Cedilnik committed
35
36
#      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
#      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
37
#
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#  KWSYS_IOS_FORCE_OLD = Force use of old non-ANSI C++ streams even if
#                        new streams are available.  This may be used
#                        by projects that cannot configure their
#                        streams library.
#    Example:
#
#      SET(KWSYS_IOS_FORCE_OLD 1)
#
#
# Optional settings to setup install rules work in one of two ways.
# The modern way utilizes the CMake 2.4 INSTALL command.  Settings
# for this mode are as follows:
#
#  KWSYS_INSTALL_BIN_DIR     = The installation target directories into
#  KWSYS_INSTALL_LIB_DIR       which the libraries and headers from
#  KWSYS_INSTALL_INCLUDE_DIR   kwsys should be installed by a "make install".
#                              The values should be specified relative to
#                              the installation prefix and NOT start with '/'.
56
57
#  KWSYS_INSTALL_DOC_DIR     = The installation target directory for documentation
#                              such as copyright information.
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#
#  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.
#
#    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)
#
# The old way uses the original CMake INSTALL_* commands.  Settings
# for this mode are as follows:
#
75
76
77
78
79
80
81
82
83
84
#  KWSYS_LIBRARY_INSTALL_DIR = The installation target directories into
#  KWSYS_HEADER_INSTALL_DIR    which the libraries and headers from
#                              kwsys should be installed by a "make install".
#                              The values should be specified relative to
#                              the installation prefix and start with a '/'.
#    Example:
#
#      SET(KWSYS_LIBRARY_INSTALL_DIR /lib)
#      SET(KWSYS_HEADER_INSTALL_DIR /include)
#
85
86
87
88
89
# The modern way will be used whenever the INSTALL command is
# available.  If the settings are not available the old names will be
# used to construct them.  The old way will be used whenever the
# INSTALL command is not available.  If the settings are not available
# the new names will be used to construct them.
90
91
92

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

98
99
100
101
102
103
104
105
# 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.

106
107
108
109
#-----------------------------------------------------------------------------
# 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.
110
111
IF(NOT KWSYS_NAMESPACE)
  SET(KWSYS_NAMESPACE "kwsys")
112
  SET(KWSYS_STANDALONE 1)
113
ENDIF(NOT KWSYS_NAMESPACE)
114
115
116
117
118
119
IF(KWSYS_STANDALONE)
  CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
  IF(COMMAND CMAKE_POLICY)
    CMAKE_POLICY(SET CMP0003 NEW)
  ENDIF(COMMAND CMAKE_POLICY)
ENDIF(KWSYS_STANDALONE)
120

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

125
126
127
128
129
130
131
132
133
134
# Some properties we set only with CMake 2.6 and above.
IF(COMMAND SET_PROPERTY)
  MACRO(KWSYS_SET_PROPERTY)
    SET_PROPERTY(${ARGV})
  ENDMACRO(KWSYS_SET_PROPERTY)
ELSE(COMMAND SET_PROPERTY)
  MACRO(KWSYS_SET_PROPERTY)
  ENDMACRO(KWSYS_SET_PROPERTY)
ENDIF(COMMAND SET_PROPERTY)

135
136
137
138
139
140
141
# Tell CMake how to follow dependencies of sources in this directory.
IF(COMMAND SET_PROPERTY)
  SET_PROPERTY(DIRECTORY
    PROPERTY IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
    "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>"
    )
ENDIF(COMMAND SET_PROPERTY)
142
143
144
145
146
147
# add option to disable memory cleanup at exit of putenv memory
IF(DEFINED KWSYS_DO_NOT_CLEAN_PUTENV)
  SET(KWSYS_DO_NOT_CLEAN_PUTENV 1)
ELSE(DEFINED KWSYS_DO_NOT_CLEAN_PUTENV)
  SET(KWSYS_DO_NOT_CLEAN_PUTENV 0)
ENDIF(DEFINED KWSYS_DO_NOT_CLEAN_PUTENV)
148

149
# Select library components.
150
IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
151
  SET(KWSYS_ENABLE_C 1)
152
  # Enable all components.
153
  SET(KWSYS_USE_Base64 1)
154
  SET(KWSYS_USE_Directory 1)
Mathieu Malaterre's avatar
Mathieu Malaterre committed
155
  SET(KWSYS_USE_DynamicLoader 1)
Andy Cedilnik's avatar
Andy Cedilnik committed
156
  SET(KWSYS_USE_Glob 1)
157
  SET(KWSYS_USE_MD5 1)
158
  SET(KWSYS_USE_Process 1)
159
  SET(KWSYS_USE_RegularExpression 1)
160
  SET(KWSYS_USE_Registry 1)
161
  SET(KWSYS_USE_System 1)
162
  SET(KWSYS_USE_SystemTools 1)
163
  SET(KWSYS_USE_CommandLineArguments 1)
164
  SET(KWSYS_USE_FundamentalType 1)
165
  SET(KWSYS_USE_Terminal 1)
166
  SET(KWSYS_USE_IOStream 1)
167
  SET(KWSYS_USE_DateStamp 1)
168
  SET(KWSYS_USE_String 1)
169
  SET(KWSYS_USE_SystemInformation 1)
170
  SET(KWSYS_USE_CPU 1)
171
ENDIF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
172
173
174
175
176
177
178
179
180
181
182
183
184

# Enforce component dependencies.
IF(KWSYS_USE_SystemTools)
  SET(KWSYS_USE_Directory 1)
ENDIF(KWSYS_USE_SystemTools)
IF(KWSYS_USE_Glob)
  SET(KWSYS_USE_Directory 1)
  SET(KWSYS_USE_SystemTools 1)
  SET(KWSYS_USE_RegularExpression 1)
ENDIF(KWSYS_USE_Glob)
IF(KWSYS_USE_Process)
  SET(KWSYS_USE_System 1)
ENDIF(KWSYS_USE_Process)
185
186
187
188
IF(KWSYS_USE_SystemInformation)
  SET(KWSYS_USE_FundamentalType 1)
  SET(KWSYS_USE_Process 1)
ENDIF(KWSYS_USE_SystemInformation)
189

Brad King's avatar
Brad King committed
190
191
192
193
194
195
196
# Setup the large file support default.
IF(KWSYS_LFS_DISABLE)
  SET(KWSYS_LFS_REQUESTED 0)
ELSE(KWSYS_LFS_DISABLE)
  SET(KWSYS_LFS_REQUESTED 1)
ENDIF(KWSYS_LFS_DISABLE)

197
198
# Enable testing if building standalone.
IF(KWSYS_STANDALONE)
199
  INCLUDE(Dart)
200
201
202
203
  MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
  IF(BUILD_TESTING)
    ENABLE_TESTING()
  ENDIF(BUILD_TESTING)
204
ENDIF(KWSYS_STANDALONE)
205

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

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

213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
# Choose which kind of install commands to use.
IF(COMMAND INSTALL)
  # 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}")
  ENDIF(NOT KWSYS_INSTALL_INCLUDE_DIR)
  IF(NOT KWSYS_INSTALL_LIB_DIR)
    STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
      "${KWSYS_LIBRARY_INSTALL_DIR}")
  ENDIF(NOT KWSYS_INSTALL_LIB_DIR)
  IF(NOT KWSYS_INSTALL_BIN_DIR)
    STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
      "${KWSYS_LIBRARY_INSTALL_DIR}")
  ENDIF(NOT KWSYS_INSTALL_BIN_DIR)

232
233
234
235
236
237
238
239
  # 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}
      )
  ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)

240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
  # Setup library install rules.
  SET(KWSYS_INSTALL_LIBRARY_RULE)
  IF(KWSYS_INSTALL_LIB_DIR)
    # Install the shared library to the lib directory.
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR}
      )
    # Assign the shared library to the runtime component.
    IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
        )
    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)

    # Install the archive to the lib directory.
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
      )
    # Assign the archive to the development component.
    IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
        )
    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
  ENDIF(KWSYS_INSTALL_LIB_DIR)
  IF(KWSYS_INSTALL_BIN_DIR)
    # Install the runtime library to the bin directory.
    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
      RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
      )
    # Assign the runtime library to the runtime component.
    IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
        )
    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
  ENDIF(KWSYS_INSTALL_BIN_DIR)

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

ELSE(COMMAND INSTALL)
  # Use old KWSYS_*_INSTALL_DIR variable names.
  # Take defaults from the new names.
  IF(KWSYS_INSTALL_LIB_DIR)
    IF(NOT KWSYS_LIBRARY_INSTALL_DIR)
      SET(KWSYS_LIBRARY_INSTALL_DIR "/${KWSYS_INSTALL_LIB_DIR}")
    ENDIF(NOT KWSYS_LIBRARY_INSTALL_DIR)
  ENDIF(KWSYS_INSTALL_LIB_DIR)
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    IF(NOT KWSYS_HEADER_INSTALL_DIR)
      SET(KWSYS_HEADER_INSTALL_DIR "/${KWSYS_INSTALL_INCLUDE_DIR}")
    ENDIF(NOT KWSYS_HEADER_INSTALL_DIR)
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)

  # Do not support new KWSYS_INSTALL_*_DIR variable names.
  SET(KWSYS_INSTALL_BIN_DIR)
  SET(KWSYS_INSTALL_INCLUDE_DIR)
  SET(KWSYS_INSTALL_LIB_DIR)
ENDIF(COMMAND INSTALL)

302
303
304
305
306
307
308
# Work-around for CMake 1.6.7 bug in custom command dependencies when
# there is no executable output path.
IF(NOT EXECUTABLE_OUTPUT_PATH)
  SET(EXECUTABLE_OUTPUT_PATH "${PROJECT_BINARY_DIR}" CACHE PATH
      "Output directory for executables.")
ENDIF(NOT EXECUTABLE_OUTPUT_PATH)

309
310
311
312
313
314
315
316
# 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
    ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPY_ONLY IMMEDIATE)
ENDIF(NOT KWSYS_IN_SOURCE_BUILD)

317
318
319
320
321
#-----------------------------------------------------------------------------
# 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}")
ENDIF(CMAKE_ANSI_CFLAGS)
322

323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
#-----------------------------------------------------------------------------
# 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")
    ENDIF(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
    IF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
    ENDIF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
  ENDIF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
338
339
340
  IF(CMAKE_SYSTEM MATCHES "HP-UX")
    SET(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
  ENDIF(CMAKE_SYSTEM MATCHES "HP-UX")
341
342
ENDIF(NOT CMAKE_COMPILER_IS_GNUCXX)

343
344
#-----------------------------------------------------------------------------
# Configure Large File Support.
345
346
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDIO
  "Checking whether header cstdio is available" DIRECT)
347
348
349
350
351
352
SET(KWSYS_LFS_AVAILABLE 0)
IF(KWSYS_LFS_REQUESTED)
  # Large File Support is requested.
  SET(KWSYS_LFS_REQUESTED 1)

  # Check for large file support.
353
354
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
    -DKWSYS_CXX_HAS_CSTDIO=${KWSYS_CXX_HAS_CSTDIO})
355
356
  KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_LFS_WORKS
    "Checking for Large File Support" DIRECT)
357
  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
358
359
360
361
362
363
364
365
366

  IF(KWSYS_LFS_WORKS)
    SET(KWSYS_LFS_AVAILABLE 1)
  ENDIF(KWSYS_LFS_WORKS)
ELSE(KWSYS_LFS_REQUESTED)
  # Large File Support is not requested.
  SET(KWSYS_LFS_REQUESTED 0)
ENDIF(KWSYS_LFS_REQUESTED)

367
368
#-----------------------------------------------------------------------------
# Configure the standard library header wrappers based on compiler's
369
370
371
372
373
374
375
# capabilities and parent project's request.  Enforce 0/1 as only
# possible values for configuration into Configure.hxx.

KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAVE_STD
  "Checking whether STL classes are in std namespace" DIRECT)

IF(KWSYS_IOS_FORCE_OLD)
376
  SET(KWSYS_IOS_USE_ANSI 0)
377
ELSE(KWSYS_IOS_FORCE_OLD)
378
  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_ANSI
379
380
381
    "Checking whether ANSI stream headers are available" DIRECT)
ENDIF(KWSYS_IOS_FORCE_OLD)

382
IF(KWSYS_IOS_USE_ANSI)
383
384
  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_STD
    "Checking whether ANSI streams are in std namespace" DIRECT)
385
  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_SSTREAM
386
    "Checking whether ANSI string stream is available" DIRECT)
387
ELSE(KWSYS_IOS_USE_ANSI)
388
  SET(KWSYS_IOS_HAVE_STD 0)
389
390
391
392
393
394
395
396
  SET(KWSYS_IOS_USE_SSTREAM 0)
ENDIF(KWSYS_IOS_USE_ANSI)

IF(KWSYS_IOS_USE_SSTREAM)
  SET(KWSYS_IOS_USE_STRSTREAM_H 0)
  SET(KWSYS_IOS_USE_STRSTREA_H 0)
ELSE(KWSYS_IOS_USE_SSTREAM)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREAM_H
397
    "Checking whether strstream.h is available" DIRECT)
398
399
400
401
  IF(KWSYS_IOS_USE_STRSTREAM_H)
    SET(KWSYS_IOS_USE_STRSTREA_H 0)
  ELSE(KWSYS_IOS_USE_STRSTREAM_H)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREA_H
402
      "Checking whether strstrea.h is available" DIRECT)
403
404
  ENDIF(KWSYS_IOS_USE_STRSTREAM_H)
ENDIF(KWSYS_IOS_USE_SSTREAM)
405

406
407
408
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDDEF
  "Checking whether header cstddef is available" DIRECT)

409
410
SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
  -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD})
411
412
KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_NEQ_CHAR
  "Checking whether stl string has operator!= for char*" DIRECT)
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_TRAITS
  "Checking whether stl has iterator_traits" DIRECT)
IF(KWSYS_STL_HAS_ITERATOR_TRAITS)
  SET(KWSYS_STL_HAS_ITERATOR_CATEGORY 0)
  SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
ELSE(KWSYS_STL_HAS_ITERATOR_TRAITS)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_CATEGORY
    "Checking whether stl has old iterator_category" DIRECT)
  IF(KWSYS_STL_HAS_ITERATOR_CATEGORY)
    SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
  ELSE(KWSYS_STL_HAS_ITERATOR_CATEGORY)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS___ITERATOR_CATEGORY
      "Checking whether stl has internal __iterator_category" DIRECT)
  ENDIF(KWSYS_STL_HAS_ITERATOR_CATEGORY)
ENDIF(KWSYS_STL_HAS_ITERATOR_TRAITS)
428
429
430
431
KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
  "Checking whether stl has standard template allocator" DIRECT)
IF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
  SET(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE 0)
432
433
434
435
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_REBIND
    "Checking for rebind member of stl allocator" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
    "Checking for non-standard argument to stl allocator<>::max_size" DIRECT)
436
437
438
439
440
441
442
443
ELSE(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
    "Checking whether stl has old non-template allocator" DIRECT)
  SET(KWSYS_STL_HAS_ALLOCATOR_REBIND 0)
  SET(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT 0)
ENDIF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_OBJECTS
  "Checking whether stl containers support allocator objects." DIRECT)
444
IF(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
445
446
447
  # ANSI streams always have string operators.
  SET(KWSYS_STL_STRING_HAVE_OSTREAM 1)
  SET(KWSYS_STL_STRING_HAVE_ISTREAM 1)
448
ELSE(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
449
450
451
452
453
  # There may not be string operators for old streams.
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_OSTREAM
    "Checking whether stl string has ostream operator<<" DIRECT)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_ISTREAM
    "Checking whether stl string has istream operator>>" DIRECT)
454
ENDIF(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
455
456
457
458
459
SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
  -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI}
  -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD})
KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_BINARY
  "Checking whether ios has binary openmode" DIRECT)
460
SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
461

462
463
464
465
466
467
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
  "Checking whether \"<>\" is needed for template friends" INVERT)
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_MEMBER_TEMPLATES
  "Checking for member template support" DIRECT)
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_FULL_SPECIALIZATION
  "Checking for standard template specialization syntax" DIRECT)
468
469
KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
  "Checking whether argument dependent lookup is supported" DIRECT)
470

471
472
473
474
475
IF(UNIX)
  KWSYS_PLATFORM_CXX_TEST(KWSYS_STAT_HAS_ST_MTIM
    "Checking whether struct stat has st_mtim member" DIRECT)
ENDIF(UNIX)

476
IF(KWSYS_USE_FundamentalType)
477
478
479
480
481
482
483
484
485
486
487
488
489
  # Determine type sizes.
  CHECK_TYPE_SIZE("char"      KWSYS_SIZEOF_CHAR)
  CHECK_TYPE_SIZE("short"     KWSYS_SIZEOF_SHORT)
  CHECK_TYPE_SIZE("int"       KWSYS_SIZEOF_INT)
  CHECK_TYPE_SIZE("long"      KWSYS_SIZEOF_LONG)
  CHECK_TYPE_SIZE("long long" KWSYS_SIZEOF_LONG_LONG)
  CHECK_TYPE_SIZE("__int64"   KWSYS_SIZEOF___INT64)
  IF(NOT KWSYS_SIZEOF_LONG_LONG)
    SET(KWSYS_SIZEOF_LONG_LONG 0)
  ENDIF(NOT KWSYS_SIZEOF_LONG_LONG)
  IF(NOT KWSYS_SIZEOF___INT64)
    SET(KWSYS_SIZEOF___INT64 0)
  ENDIF(NOT KWSYS_SIZEOF___INT64)
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524

  # Check uniqueness of types.
  IF(KWSYS_SIZEOF___INT64)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_AND___INT64
      "Checking whether long and __int64 are the same type" DIRECT)
    IF(KWSYS_SIZEOF_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(KWSYS_SIZEOF_LONG_LONG)
  ENDIF(KWSYS_SIZEOF___INT64)

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

  # Enable the "__int64" type if it is available and unique.  It is not
  # standard.
  SET(KWSYS_USE___INT64 0)
  IF(KWSYS_SIZEOF___INT64)
    IF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
      IF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
        SET(KWSYS_USE___INT64 1)
      ENDIF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
    ENDIF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
  ENDIF(KWSYS_SIZEOF___INT64)
  IF(KWSYS_USE___INT64)
    KWSYS_PLATFORM_CXX_TEST(KWSYS_CAN_CONVERT_UI64_TO_DOUBLE
      "Checking whether unsigned __int64 can convert to double" DIRECT)
  ELSE(KWSYS_USE___INT64)
    SET(KWSYS_CAN_CONVERT_UI64_TO_DOUBLE 1)
  ENDIF(KWSYS_USE___INT64)
525
526

  # Check signedness of "char" type.
527
528
  KWSYS_PLATFORM_CXX_TEST_RUN(KWSYS_CHAR_IS_SIGNED
    "Checking whether char is signed" DIRECT)
529
530
ENDIF(KWSYS_USE_FundamentalType)

531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
IF(KWSYS_USE_IOStream)
  # Determine whether iostreams support long long.
  CHECK_TYPE_SIZE("long long" KWSYS_SIZEOF_LONG_LONG)
  IF(KWSYS_SIZEOF_LONG_LONG)
    SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
      -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI}
      -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD})
    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)
    SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
  ELSE(KWSYS_SIZEOF_LONG_LONG)
    SET(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
    SET(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
  ENDIF(KWSYS_SIZEOF_LONG_LONG)
ENDIF(KWSYS_USE_IOStream)

549
550
551
552
553
554
IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
  SET(KWSYS_NAME_IS_KWSYS 1)
ELSE(KWSYS_NAMESPACE MATCHES "^kwsys$")
  SET(KWSYS_NAME_IS_KWSYS 0)
ENDIF(KWSYS_NAMESPACE MATCHES "^kwsys$")

Brad King's avatar
Brad King committed
555
556
557
558
559
560
561
562
563
564
565
566
567
# Choose default shared/static build if not specified.
IF(KWSYS_BUILD_SHARED MATCHES "^KWSYS_BUILD_SHARED$")
  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
ENDIF(KWSYS_BUILD_SHARED MATCHES "^KWSYS_BUILD_SHARED$")

IF(KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED 1)
  SET(KWSYS_LIBRARY_TYPE SHARED)
ELSE(KWSYS_BUILD_SHARED)
  SET(KWSYS_BUILD_SHARED 0)
  SET(KWSYS_LIBRARY_TYPE STATIC)
ENDIF(KWSYS_BUILD_SHARED)

568
569
#-----------------------------------------------------------------------------
# Choose a directory for the generated headers.
570
571
572
573
IF(NOT KWSYS_HEADER_ROOT)
  SET(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
ENDIF(NOT KWSYS_HEADER_ROOT)
SET(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
574
INCLUDE_DIRECTORIES(${KWSYS_HEADER_ROOT})
575

576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
#-----------------------------------------------------------------------------
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}
      )
  ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)

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

592
593
594
#-----------------------------------------------------------------------------
# Create STL header wrappers to block warnings in the STL headers and
# give standard names by which they may be included.
595
SET(KWSYS_STL_HEADER_EXTRA_string 1)
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
FOREACH(header
  algorithm
  deque
  exception
  functional
  iterator
  list
  map
  memory
  new
  numeric
  queue
  set
  stack
  stdexcept
  string
  utility
  vector
  )
615
616
  # Configure the header wrapper.
  SET(KWSYS_STL_HEADER "${header}")
617
618
619
620
621
622
  IF(KWSYS_STL_HEADER_EXTRA_${header})
    SET(KWSYS_STL_HEADER_EXTRA
      "#define ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n# include <${KWSYS_NAMESPACE}/stl/${header}.hxx>\n#undef ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n")
    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl_${header}.hxx.in
                   ${KWSYS_HEADER_DIR}/stl/${header}.hxx
                   @ONLY IMMEDIATE)
623
624
    IF(KWSYS_INSTALL_INCLUDE_DIR)
      INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx
625
626
        DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
        ${KWSYS_INSTALL_INCLUDE_OPTIONS})
627
    ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
628
629
630
631
632
633
634
635
    IF(KWSYS_HEADER_INSTALL_DIR)
      INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
        FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx)
    ENDIF(KWSYS_HEADER_INSTALL_DIR)
  ELSE(KWSYS_STL_HEADER_EXTRA_${header})
    SET(KWSYS_STL_HEADER_EXTRA "")
  ENDIF(KWSYS_STL_HEADER_EXTRA_${header})
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl.hxx.in
636
                 ${KWSYS_HEADER_DIR}/stl/${header}
637
                 @ONLY IMMEDIATE)
638

639
  # Create an install target for the header wrapper.
640
641
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}
642
643
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
644
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
645
  IF(KWSYS_HEADER_INSTALL_DIR)
646
647
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
      FILES ${KWSYS_HEADER_DIR}/stl/${header})
648
649
650
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
ENDFOREACH(header)

651
652
653
654
# Provide cstddef header.
CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_cstddef.hxx.in
               ${KWSYS_HEADER_DIR}/cstddef
               @ONLY IMMEDIATE)
655
656
657
658
659
660
661
662
663
IF(KWSYS_INSTALL_INCLUDE_DIR)
  INSTALL(FILES ${KWSYS_HEADER_DIR}/cstddef
    DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
    ${KWSYS_INSTALL_INCLUDE_OPTIONS})
  IF(KWSYS_HEADER_INSTALL_DIR)
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
      FILES ${KWSYS_HEADER_DIR}/cstddef)
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
664

665
666
667
668
669
#-----------------------------------------------------------------------------
# Create streams header wrappers to give standard names by which they
# may be included.
FOREACH(header iostream fstream sstream iosfwd)
  # Configure the header wrapper.
670
671
  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_ios_${header}.h.in
                 ${KWSYS_HEADER_DIR}/ios/${header}
672
673
674
                 @ONLY IMMEDIATE)

  # Create an install target for the header wrapper.
675
676
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/ios/${header}
677
678
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/ios
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
679
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
680
  IF(KWSYS_HEADER_INSTALL_DIR)
681
682
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/ios
      FILES ${KWSYS_HEADER_DIR}/ios/${header})
683
684
685
686
687
688
689
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
ENDFOREACH(header)

#-----------------------------------------------------------------------------
# Build a list of classes and headers we need to implement the
# selected components.  Initialize with required components.
SET(KWSYS_CLASSES)
690
SET(KWSYS_H_FILES Configure SharedForward)
691
692
693
694
SET(KWSYS_HXX_FILES Configure String
  hashtable hash_fun hash_map hash_set
  auto_ptr
  )
695
696

# Add selected C++ classes.
697
698
SET(cppclasses
  Directory DynamicLoader Glob RegularExpression SystemTools
699
  CommandLineArguments Registry IOStream SystemInformation
700
  )
701
702
FOREACH(cpp ${cppclasses})
  IF(KWSYS_USE_${cpp})
703
    # Use the corresponding class.
704
    SET(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
705
706

    # Load component-specific CMake code.
707
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
708
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
709
    ENDIF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
710
711
  ENDIF(KWSYS_USE_${cpp})
ENDFOREACH(cpp)
712
713

# Add selected C components.
714
715
716
FOREACH(c
    Process Base64 FundamentalType MD5 Terminal System DateStamp String CPU
    )
717
  IF(KWSYS_USE_${c})
718
    # Use the corresponding header file.
719
    SET(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})
720
721

    # Load component-specific CMake code.
722
    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
723
      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
724
    ENDIF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
725
726
  ENDIF(KWSYS_USE_${c})
ENDFOREACH(c)
727

728
729
730
#-----------------------------------------------------------------------------
# Build a list of sources for the library based on components that are
# included.
731
732
SET(KWSYS_C_SRCS)
SET(KWSYS_CXX_SRCS)
733
734
735

# Add the proper sources for this platform's Process implementation.
IF(KWSYS_USE_Process)
736
  IF(NOT UNIX)
737
    # Use the Windows implementation.  We need the encoded forwarding executable.
738
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c
739
740
741
742
      ${PROJECT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c)
    SET_SOURCE_FILES_PROPERTIES(
      ${PROJECT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
      PROPERTIES GENERATED 1)
743
  ELSE(NOT UNIX)
744
    # Use the UNIX implementation.
745
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
746
747
748
749
750
751
752
753
754

    # Help ProcessUNIX.c compile properly on all platforms.
    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)
    SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c PROPERTIES
      COMPILE_FLAGS "-DKWSYS_C_HAS_PTRDIFF_T=${KWSYS_C_HAS_PTRDIFF_T} -DKWSYS_C_HAS_SSIZE_T=${KWSYS_C_HAS_SSIZE_T}"
      )
755
  ENDIF(NOT UNIX)
756
757
ENDIF(KWSYS_USE_Process)

758
# Add selected C sources.
759
FOREACH(c Base64 MD5 Terminal System String)
760
761
762
763
  IF(KWSYS_USE_${c})
    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${c}.c)
  ENDIF(KWSYS_USE_${c})
ENDFOREACH(c)
Andy Cedilnik's avatar
Andy Cedilnik committed
764

765
766
767
# 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.
768
  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${c}.cxx)
769

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

  # Create an install target for the header.
776
777
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
778
779
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
780
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
781
782
783
784
  IF(KWSYS_HEADER_INSTALL_DIR)
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
                  FILES  ${KWSYS_HEADER_DIR}/${c}.hxx)
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
785
786
ENDFOREACH(c)

787
788
789
790
# 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
791
                 @ONLY IMMEDIATE)
792
  SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)
793
794

  # Create an install target for the header.
795
796
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.h
797
798
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
799
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
800
801
802
803
  IF(KWSYS_HEADER_INSTALL_DIR)
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
                  FILES  ${KWSYS_HEADER_DIR}/${h}.h)
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
804
805
ENDFOREACH(h)

806
807
808
809
# 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
810
                 @ONLY IMMEDIATE)
811
  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)
812

813
  # Create an install target for the header.
814
815
  IF(KWSYS_INSTALL_INCLUDE_DIR)
    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
816
817
      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
818
  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
819
820
821
822
823
  IF(KWSYS_HEADER_INSTALL_DIR)
    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
                  FILES  ${KWSYS_HEADER_DIR}/${h}.hxx)
  ENDIF(KWSYS_HEADER_INSTALL_DIR)
ENDFOREACH(h)
824

825
826
#-----------------------------------------------------------------------------
# Add the library with the configured name and list of sources.
827
828
829
IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
  ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
    ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
830
  KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
831
832
  IF(KWSYS_USE_DynamicLoader)
    IF(UNIX)
833
      TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
834
835
    ENDIF(UNIX)
  ENDIF(KWSYS_USE_DynamicLoader)
836
837
838
839
  
  IF(KWSYS_USE_SystemInformation AND WIN32)
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ws2_32)
  ENDIF(KWSYS_USE_SystemInformation AND WIN32)
840

841
842
843
844
845
846
847
  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_CXX)
    SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
      ${KWSYS_PROPERTIES_CXX}
      )
  ENDIF(KWSYS_PROPERTIES_CXX)

848
  # Create an install target for the library.
849
850
851
  IF(KWSYS_INSTALL_LIBRARY_RULE)
    INSTALL(TARGETS ${KWSYS_NAMESPACE} ${KWSYS_INSTALL_LIBRARY_RULE})
  ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
852
  IF(KWSYS_LIBRARY_INSTALL_DIR)
853
    INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE})
854
  ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
855
856
857
858
859
ENDIF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)

# Add a C-only library if requested.
IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
  ADD_LIBRARY(${KWSYS_NAMESPACE}_c ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS})
860
  KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}_c PROPERTY LABELS ${KWSYS_LABELS_LIB})
861

862
863
864
865
866
867
868
  # Apply user-defined target properties to the library.
  IF(KWSYS_PROPERTIES_C)
    SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
      ${KWSYS_PROPERTIES_C}
      )
  ENDIF(KWSYS_PROPERTIES_C)

869
  # Create an install target for the library.
870
871
872
  IF(KWSYS_INSTALL_LIBRARY_RULE)
    INSTALL(TARGETS ${KWSYS_NAMESPACE}_c ${KWSYS_INSTALL_LIBRARY_RULE})
  ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
873
874
875
876
  IF(KWSYS_LIBRARY_INSTALL_DIR)
    INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE}_c)
  ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
ENDIF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
877

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

882
883
884
885
886
887
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")
ENDIF(KWSYS_USE_String)

888
#-----------------------------------------------------------------------------
889
890
891
892
893
# Process execution on windows needs to build a forwarding executable
# that works around a Win9x bug.  We encode the executable into a C
# file and build it into the library.  Win9x platforms reproduce the
# executable into a temporary directory when it is needed.
IF(KWSYS_USE_Process)
894
  IF(NOT UNIX)
895
896
897
898
    # Build the forwarding executable itself and a program that will
    # encode it into a C file.
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}ProcessFwd9x ProcessFwd9x.c)
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}EncodeExecutable EncodeExecutable.c)
899
900
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}ProcessFwd9x PROPERTY LABELS ${KWSYS_LABELS_EXE})
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}EncodeExecutable PROPERTY LABELS ${KWSYS_LABELS_EXE})
901

902
903
904
905
906
    # Construct the location of the executable to be encoded.
    SET(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
    IF(EXECUTABLE_OUTPUT_PATH)
      SET(BIN_DIR ${EXECUTABLE_OUTPUT_PATH})
    ENDIF(EXECUTABLE_OUTPUT_PATH)
907

908
909
910
911
    SET(CFG_INTDIR "/${CMAKE_CFG_INTDIR}")
    IF(CMAKE_BUILD_TOOL MATCHES "make")
      SET(CFG_INTDIR "")
    ENDIF(CMAKE_BUILD_TOOL MATCHES "make")
912

913
914
915
916
917
918
919
920
    # Take advantage of a better custom command syntax if possible.
    SET(CMD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}EncodeExecutable.exe)
    SET(FWD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}ProcessFwd9x.exe)
    IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
      ADD_CUSTOM_COMMAND(
        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
        COMMAND ${CMD}
        ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
921
             ${KWSYS_NAMESPACE} ProcessFwd9x
922
923
924
925
926
927
928
        DEPENDS ${CMD} ${FWD})
    ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
      ADD_CUSTOM_COMMAND(
        TARGET ${KWSYS_NAMESPACE}
        SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/ProcessFwd9x.c
        COMMAND ${CMD}
        ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
929
             ${KWSYS_NAMESPACE} ProcessFwd9x
930
931
932
        OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
        DEPENDS ${CMD} ${FWD})
    ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
933

934
935
936
    # Make sure build occurs in proper order.
    ADD_DEPENDENCIES(${KWSYS_NAMESPACE} ${KWSYS_NAMESPACE}ProcessFwd9x
                     ${KWSYS_NAMESPACE}EncodeExecutable)
937
  ENDIF(NOT UNIX)
938
939
940
941
ENDIF(KWSYS_USE_Process)

#-----------------------------------------------------------------------------
# Setup testing if not being built as part of another project.
942
IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
943
  IF(BUILD_TESTING)
944
    # Compute the location of executables.
945
946
947
948
949
    SET(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
    IF(EXECUTABLE_OUTPUT_PATH)
      SET(EXEC_DIR "${EXECUTABLE_OUTPUT_PATH}")
    ENDIF(EXECUTABLE_OUTPUT_PATH)

950
951
    # C tests
    SET(KWSYS_C_TESTS
952
      testEncode
953
954
955
956
957
958
959
960
961
962
      testTerminal
      )
    IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
      SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail)
    ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
    CREATE_TEST_SOURCELIST(
      KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
      ${KWSYS_C_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
963
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
964
965
966
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_NAMESPACE}_c)
    FOREACH(test ${KWSYS_C_TESTS})
      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
967
      KWSYS_SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
968
969
970
    ENDFOREACH(test)

    # C++ tests
971
972
973
974
975
976
977
    IF(NOT WATCOM)
      SET(KWSYS_CXX_TESTS
        testAutoPtr
        testHashSTL
        )
    ENDIF(NOT WATCOM)
    SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
978
979
980
981
982
983
      testRegistry
      testIOS
      testSystemTools
      testCommandLineArguments
      testCommandLineArguments1
      )
Bill Hoffman's avatar
Bill Hoffman committed
984
985
986
    IF(KWSYS_USE_SystemInformation)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation)
    ENDIF(KWSYS_USE_SystemInformation)
987
988
989
990
    IF(KWSYS_USE_DynamicLoader)
      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader)
      # If kwsys contains the DynamicLoader, need extra library
      ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
991
      KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
992
993
994
995
996
997
    ENDIF(KWSYS_USE_DynamicLoader)
    CREATE_TEST_SOURCELIST(
      KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
      ${KWSYS_CXX_TESTS}
      )
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
998
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
999
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_NAMESPACE})
1000
1001
    SET(TEST_SYSTEMTOOLS_BIN_FILE
      "${CMAKE_CURRENT_SOURCE_DIR}/testSystemTools.bin")
1002
    SET(TEST_SYSTEMTOOLS_SRC_FILE
1003
      "${CMAKE_CURRENT_SOURCE_DIR}/testSystemTools.cxx")
1004
1005
1006
1007
1008
    CONFIGURE_FILE(
      ${PROJECT_SOURCE_DIR}/testSystemTools.h.in
      ${PROJECT_BINARY_DIR}/testSystemTools.h)
    INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})

1009
1010
1011
1012
1013
    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")
    ENDIF(CTEST_TEST_KWSYS)
1014
1015

    SET(KWSYS_TEST_ARGS_testCommandLineArguments
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
      --another-bool-variable
      --long3=opt
      --set-bool-arg1
      -SSS ken brad bill andy
      --some-bool-variable=true
      --some-double-variable12.5
      --some-int-variable 14
      "--some-string-variable=test string with space"
      --some-multi-argument 5 1 8 3 7 1 3 9 7 1
      -N 12.5 -SS=andy -N 1.31 -N 22
      -SS=bill -BBtrue -SS=brad
1027
      -BBtrue
1028
1029
1030
1031
      -BBfalse
      -SS=ken
      -A
      -C=test
1032
1033
1034
      --long2 hello
      )
    SET(KWSYS_TEST_ARGS_testCommandLineArguments1
1035
1036
1037
1038
1039
1040
      --ignored
      -n 24
      --second-ignored
      "-m=test value"
      third-ignored
      -p
1041
1042
1043
1044
      some junk at the end
      )
    FOREACH(test ${KWSYS_CXX_TESTS})
      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
1045
      KWSYS_SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
1046
1047
1048
1049
    ENDFOREACH(test)

    # Process tests.
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
1050
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
1051
1052
1053
1054
1055
1056
    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_NAMESPACE}_c)
    IF(NOT CYGWIN)
      SET(KWSYS_TEST_PROCESS_7 7)
    ENDIF(NOT CYGWIN)
    FOREACH(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7})
      ADD_TEST(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
1057
      KWSYS_SET_PROPERTY(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
1058
1059
    ENDFOREACH(n)

1060
1061
1062
1063
1064
    # Test SharedForward
    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
                   ${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestSharedForward
                   ${PROJECT_BINARY_DIR}/testSharedForward.c)
1065
    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
1066
    ADD_TEST(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
1067
    KWSYS_SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
1068

1069
    # Configure some test properties.
1070
    IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
1071
      # We expect test to fail
1072
      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES WILL_FAIL ON)
1073
      GET_TEST_PROPERTY(kwsys.testFail WILL_FAIL wfv)
1074
      SET_TESTS_PROPERTIES(kwsys.testRegistry PROPERTIES FAIL_REGULAR_EXPRESSION "ERROR_NOT_VALGRIND;FAIL;Test failed")
1075
      SET_TESTS_PROPERTIES(kwsys.testRegistry PROPERTIES PASS_REGULAR_EXPRESSION "Test passed")
1076
      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
Andy Cedilnik's avatar
Andy Cedilnik committed
1077
      MESSAGE(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
1078
    ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
1079
  ENDIF(BUILD_TESTING)
1080
ENDIF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)