File: CMakeLists.txt

package info (click to toggle)
cmake 2.8.11.1-1~bpo70+1
  • links: PTS, VCS
  • area: main
  • in suites: wheezy-backports
  • size: 37,056 kB
  • sloc: cpp: 157,219; ansic: 137,155; yacc: 3,254; sh: 2,745; xml: 2,483; lex: 1,028; lisp: 215; python: 199; objc: 134; f90: 105; perl: 99; fortran: 93; makefile: 65; tcl: 55; asm: 28; php: 25; ruby: 22; java: 20
file content (398 lines) | stat: -rw-r--r-- 14,011 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
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
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
cmake_minimum_required (VERSION 2.6)
project (TestSimpleInstall)
set(CMAKE_VERBOSE_MAKEFILE 1)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
  "${TestSimpleInstall_BINARY_DIR}/bin")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
  "${TestSimpleInstall_BINARY_DIR}/lib/static")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
  "${TestSimpleInstall_BINARY_DIR}/lib")

# Skip generating the rpath pointing at the build tree to make sure
# the executable is installed with the proper rpath in the install
# tree.
set(CMAKE_SKIP_BUILD_RPATH 1)

# Make sure the executable can run from the install tree.
set(CMAKE_INSTALL_NAME_DIR ${CMAKE_INSTALL_PREFIX}/MyTest/lib)

# Skip the dependency that causes a build when installing.  This
# avoids infinite loops when the post-build rule below installs.
set(CMAKE_SKIP_INSTALL_ALL_DEPENDENCY 1)
set(CMAKE_SKIP_PACKAGE_ALL_DEPENDENCY 1)

set(CMAKE_DEBUG_POSTFIX "_test_debug_postfix")

set(EXTRA_INSTALL_FLAGS)
message("Extra install: ${EXTRA_INSTALL_FLAGS}")

if(STAGE2)
  set(LIBPATHS
    ${CMAKE_INSTALL_PREFIX}/MyTest/lib/static
    ${CMAKE_INSTALL_PREFIX}/MyTest/lib
    )
  set(t1NAMES test1 test1${CMAKE_DEBUG_POSTFIX} test1rel)
  set(t2NAMES test2 test2${CMAKE_DEBUG_POSTFIX})
  set(t4NAMES test4out test4out${CMAKE_DEBUG_POSTFIX})

  # Make sure the install script ran.
  set(CMAKE_INSTALL_SCRIPT_DID_RUN 0)
  include(${CMAKE_INSTALL_PREFIX}/MyTest/InstallScriptOut.cmake OPTIONAL)
  if(CMAKE_INSTALL_SCRIPT_DID_RUN)
    message(STATUS "Stage 1 did run install script 2.")
  else()
    message(SEND_ERROR "Stage 1 did not run install script 2.")
  endif()

  if(CYGWIN OR MINGW)
    set(LIBPATHS ${LIBPATHS} "${CMAKE_INSTALL_PREFIX}/MyTest/bin")
  endif()
  message("Search for library in: ${LIBPATHS}")

  set(TEST1_LIBRARY "TEST1_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)
  set(TEST2_LIBRARY "TEST2_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)
  set(TEST4_LIBRARY "TEST4_LIBRARY-NOTFOUND" CACHE FILEPATH "Force find." FORCE)

  find_library(TEST1_LIBRARY
    NAMES ${t1NAMES}
    PATHS ${LIBPATHS}
    DOC "First library")
  find_library(TEST2_LIBRARY
    NAMES ${t2NAMES}
    PATHS ${LIBPATHS}
    DOC "Second library")
  find_library(TEST4_LIBRARY
    NAMES ${t4NAMES}
    PATHS ${LIBPATHS}
    DOC "Fourth library")

  # Test importing a library found on disk.
  add_library(lib_test4 UNKNOWN IMPORTED)
  set_property(TARGET lib_test4 PROPERTY IMPORTED_LOCATION ${TEST4_LIBRARY})

  include_directories(${CMAKE_INSTALL_PREFIX}/MyTest/include)
  add_executable (SimpleInstExeS2 inst2.cxx foo.c foo.h)
  target_link_libraries(SimpleInstExeS2 ${TEST1_LIBRARY} ${TEST2_LIBRARY} lib_test4)
  set(install_target SimpleInstExeS2)

  if("${TEST1_LIBRARY}" MATCHES "static")
    message(STATUS "test1 correctly found in lib/static")
  else()
    message(SEND_ERROR "test1 not found in lib/static!")
  endif()

  # Check for failure of configuration-specific installation.
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Release/lib1debug.h")
    message(FATAL_ERROR "Debug-configuration file installed for Release!")
  endif()
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/include/Debug/lib1release.h")
    message(FATAL_ERROR "Release-configuration file installed for Debug!")
  endif()

  # Check for failure of directory installation.
  if(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/TSD.h")
    message(FATAL_ERROR "Directory installation did not install TSD.h")
  endif()
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS")
    message(FATAL_ERROR "Directory installation installed CVS directory.")
  endif()
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS")
    message(FATAL_ERROR "Directory installation installed CVS directory.")
  endif()
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/CMakeLists.txt")
    message(FATAL_ERROR "Directory installation installed CMakeLists.txt.")
  endif()
  if(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.h")
    message(FATAL_ERROR "Directory installation did not install alternate TSD.h")
  endif()
  if(EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/alt/TestSubDir/TSD.cxx")
    message(FATAL_ERROR "Directory installation installed alternate TSD.cxx")
  endif()

  # Check that scripts properly installed.
  if(WIN32 AND NOT CYGWIN)
    set(BAT .bat)
  else()
    set(BAT)
  endif()
  foreach(loc share share/old1 share/old2 share/old3 share/alt)
    set(CUR_SCRIPT "${CMAKE_INSTALL_PREFIX}/MyTest/${loc}/sample_script${BAT}")
    execute_process(
      COMMAND ${CUR_SCRIPT}
      RESULT_VARIABLE SAMPLE_SCRIPT_RESULT
      OUTPUT_VARIABLE SAMPLE_SCRIPT_OUTPUT
      )
    if(NOT "${SAMPLE_SCRIPT_RESULT}" MATCHES "^0$")
      message(FATAL_ERROR
        "Sample script [${CUR_SCRIPT}] failed: [${SAMPLE_SCRIPT_RESULT}]")
    endif()
    if(NOT "${SAMPLE_SCRIPT_OUTPUT}" MATCHES "Sample Script Output")
      message(FATAL_ERROR
        "Bad sample script [${CUR_SCRIPT}] output: [${SAMPLE_SCRIPT_OUTPUT}]")
    endif()
  endforeach()

  # Check for failure of empty directory installation.
  if(NOT EXISTS "${CMAKE_INSTALL_PREFIX}/MyTest/share/empty")
    message(FATAL_ERROR "Empty directory installation did not install.")
  endif()
  file(GLOB EMPTY_FILES "${CMAKE_INSTALL_PREFIX}/MyTest/share/empty/*")
  if(EMPTY_FILES)
    message(FATAL_ERROR "Empty directory installed [${EMPTY_FILES}].")
  endif()

  # Make sure the test executable can run from the install tree.
  set_target_properties(SimpleInstExeS2 PROPERTIES
    INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/MyTest/lib)

  install_targets(/MyTest/bin SimpleInstExeS2)

# try to import the exported targets again
  set(SimpleInstallS1_DIR ${CMAKE_INSTALL_PREFIX}/MyTest/lib)
  find_package(SimpleInstallS1 REQUIRED)
  get_target_property(simpleInstallImported S1_SimpleInstall IMPORTED)
  if(NOT simpleInstallImported)
    message(FATAL_ERROR "Target S1_SimpleInstall could not be imported")
  endif()

else()
  # Wipe out the install directory to do a fresh test.
  file(REMOVE_RECURSE ${CMAKE_INSTALL_PREFIX}/MyTest)

  # this is stage 1, so create libraries and modules and install everything
  add_library(test1 STATIC lib1.cxx)
  add_library(test2 SHARED lib2.cxx)
  add_library(test3 MODULE lib3.cxx)
  add_library(test4 SHARED lib4.cxx)

  # Test <ARCHIVE|LIBRARY|RUNTIME>_OUTPUT_NAME properties.
  set_property(TARGET test4 PROPERTY ARCHIVE_OUTPUT_NAME test4out)
  set_property(TARGET test4 PROPERTY LIBRARY_OUTPUT_NAME test4out)

  add_executable (SimpleInstall inst.cxx foo.c foo.h)
  target_link_libraries(SimpleInstall test1 test2 test4)
  set(install_target SimpleInstall)

  set_target_properties(SimpleInstall PROPERTIES OUTPUT_NAME SimpleInstExe)
  # Disable VERSION test until it is implemented in the Xcode generator.
  if(NOT XCODE)
    set_target_properties(SimpleInstall PROPERTIES VERSION 1.2)
  endif()

  # Make sure the test executable can run from the install tree.
  set_target_properties(SimpleInstall PROPERTIES
    INSTALL_RPATH ${CMAKE_INSTALL_PREFIX}/MyTest/lib)

  # Test per-configuration output name.
  set_target_properties(test1 PROPERTIES RELEASE_OUTPUT_NAME test1rel)
  set_target_properties(test2 PROPERTIES PUBLIC_HEADER foo.h)

  if(CMAKE_GENERATOR MATCHES "Makefiles")
    add_subdirectory(TestSubDir)
    add_dependencies(SimpleInstall TSD)
  endif()

  add_dependencies(SimpleInstall test3)
  add_dependencies(test2 test3)
  add_dependencies(test4 test2)

  install(TARGETS SimpleInstall test1 test2 test3 EXPORT SimpleInstallS1
    RUNTIME DESTINATION MyTest/bin        COMPONENT Runtime     # .exe, .dll
    LIBRARY DESTINATION MyTest/lib        COMPONENT Runtime     # .so, mod.dll
    ARCHIVE DESTINATION MyTest/lib/static COMPONENT Development # .a, .lib
    PUBLIC_HEADER DESTINATION MyTest/include COMPONENT Development
    )

  install(TARGETS test4 PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
    RUNTIME DESTINATION MyTest/bin
    LIBRARY DESTINATION MyTest/lib
    ARCHIVE DESTINATION MyTest/lib/static
    OPTIONAL # for coverage...target should always exist
    )
  install(FILES lib1.h DESTINATION MyTest/include/foo)
  install(FILES lib2.h
    DESTINATION MyTest/include/foo
    COMPONENT Development
    PERMISSIONS OWNER_READ OWNER_WRITE
    RENAME lib2renamed.h
    )

  # Test old-style install commands.
  install_files(/MyTest/include FILES lib3.h)
  install_files(/MyTest/include/old .h lib3)
  install_files(/MyTest/include/old "^lib2.h$")
  install_programs(/MyTest/share/old1 FILES
    scripts/sample_script scripts/sample_script.bat)
  install_programs(/MyTest/share/old2
    scripts/sample_script scripts/sample_script.bat)

# "export" the targets collected in "SimpleInstallS1"
  install(EXPORT SimpleInstallS1 FILE SimpleInstallS1Config.cmake
                                 DESTINATION MyTest/lib
                                 NAMESPACE S1_ )

  export(TARGETS SimpleInstall test1 test2 test3
         FILE "${CMAKE_CURRENT_BINARY_DIR}/SimpleInstallS1Config.cmake"
         NAMESPACE S2_ )

  add_subdirectory(scripts)

  # Test optional installation.
  install(FILES does_not_exist.h DESTINATION MyTest/include/foo OPTIONAL)

  # Test configuration-specific installation.
  install(FILES lib1.h RENAME lib1release.h CONFIGURATIONS Release
    DESTINATION MyTest/include/Release
    )
  install(FILES lib1.h RENAME lib1debug.h CONFIGURATIONS Debug
    DESTINATION MyTest/include/Debug
    )

  # Test directory installation.
  file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/CVS")
  file(REMOVE_RECURSE "${CMAKE_INSTALL_PREFIX}/MyTest/share/TestSubDir/CVS")
  install(
    DIRECTORY TestSubDir scripts/ DESTINATION MyTest/share
    FILE_PERMISSIONS OWNER_READ OWNER_WRITE
    DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
                          GROUP_READ GROUP_EXECUTE
    PATTERN "CVS" EXCLUDE
    REGEX "\\.txt$" EXCLUDE
    PATTERN "scripts/*" PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
    )

  # Alternate directory installation for coverage.
  install(
    DIRECTORY scripts/ DESTINATION MyTest/share/alt
    COMPONENT Development
    USE_SOURCE_PERMISSIONS
    PATTERN "CVS" EXCLUDE
    REGEX "\\.txt$" EXCLUDE
    )
  install(
    DIRECTORY TestSubDir DESTINATION MyTest/share/alt
    FILE_PERMISSIONS OWNER_READ OWNER_WRITE
    DIRECTORY_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE
                          GROUP_READ GROUP_EXECUTE
    FILES_MATCHING PATTERN "*.h"
    )

  # Test empty directory installation.
  install(DIRECTORY DESTINATION MyTest/share/empty)

  # Test optional directory installation.
  install(DIRECTORY does-not-exist DESTINATION MyTest/share OPTIONAL)

  # Test user-specified install scripts, with and without COMPONENT.
  install(
    SCRIPT InstallScript1.cmake
    CODE "set(INSTALL_CODE_DID_RUN 1)"
    SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/InstallScript2.cmake
    )
  install(
    SCRIPT InstallScript3.cmake
    CODE "set(INSTALL_CODE_WITH_COMPONENT_DID_RUN 1)"
    SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/InstallScript4.cmake
    COMPONENT Development
    )
  set_directory_properties(PROPERTIES
    ADDITIONAL_MAKE_CLEAN_FILES
    "${CMAKE_INSTALL_PREFIX}/InstallScriptOut.cmake;${CMAKE_INSTALL_PREFIX}/InstallScript4Out.cmake")

  set_target_properties(SimpleInstall PROPERTIES PRE_INSTALL_SCRIPT
    ${CMAKE_CURRENT_SOURCE_DIR}/PreInstall.cmake)
  set_target_properties(SimpleInstall PROPERTIES POST_INSTALL_SCRIPT
    ${CMAKE_CURRENT_SOURCE_DIR}/PostInstall.cmake)
  set_target_properties(test4 PROPERTIES VERSION 1.2 SOVERSION 3
        INSTALL_NAME_DIR @executable_path/../lib)
endif()

if(CMAKE_CONFIGURATION_TYPES)
  set(SI_CONFIG -C ${CMAKE_CFG_INTDIR})
else()
  set(SI_CONFIG)
endif()

# Dummy test of CPack
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Test of packaging with cpack")
set(CPACK_PACKAGE_VENDOR "Kitware")
set(CPACK_INSTALL_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/PackageScript.cmake")

if(WIN32 AND NOT UNIX)
  find_program(NSIS_MAKENSIS NAMES makensis
    PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
    DOC "Where is makensis.exe located"
    )
  if(NOT NSIS_MAKENSIS)
    set(CPACK_GENERATOR TGZ)
  endif()
endif()
if(UNIX AND NOT APPLE)
  set(CPACK_GENERATOR "TGZ;STGZ;TZ")
  #  find_program(found_compress
  #    NAMES compress)
  #  if(found_compress)
  #    find_program(file_command NAMES file)
  #    if(NOT file_command)
  #      set(file_command file)
  #    endif()
  #    execute_process(COMMAND ${file_command} ${found_compress}
  #      OUTPUT_VARIABLE output)
  #    set(SKIP_TZ FALSE)
  #    if("${output}" MATCHES "script")
  #      set(SKIP_TZ TRUE)
  #    endif()
  #    if("${output}" MATCHES "dummy.sh")
  #      set(SKIP_TZ TRUE)
  #    endif()
  #    if(NOT SKIP_TZ)
  #      message("compress found and it was not a script")
  #      message("output from file command: [${output}]")
  #      set(CPACK_GENERATOR "${CPACK_GENERATOR};TZ")
  #    else()
  #      message("compress found, but it was a script so dont use it")
  #      message("output from file command: [${output}]")
  #    endif()
  #  endif()
  find_program(found_bz2
    NAMES bzip2)
  if(found_bz2)
    set(CPACK_GENERATOR "${CPACK_GENERATOR};TBZ2")
  endif()
endif()

set(CPACK_PACKAGE_EXECUTABLES "SimpleInstall" "Simple Install")
set(CMAKE_INSTALL_MFC_LIBRARIES 1)
set(CMAKE_INSTALL_DEBUG_LIBRARIES 1)
include(InstallRequiredSystemLibraries)

if(CTEST_TEST_CPACK)
  set(PACKAGE_TARGET --build-target package)

  # Avoid settings that require the .zip file command line tools...
  # (just build an NSIS installer without component support)
  #
  set(CPACK_BINARY_ZIP OFF)
  set(CPACK_MONOLITHIC_INSTALL ON)
else()
  set(PACKAGE_TARGET)
endif()

include(CPack)

add_custom_command(
  TARGET ${install_target}
  POST_BUILD
  COMMAND ${CMAKE_CTEST_COMMAND}
  ARGS ${SI_CONFIG}
  --build-and-test
  ${CMAKE_SOURCE_DIR}
  ${CMAKE_BINARY_DIR}
  --build-generator ${CMAKE_GENERATOR}
  --build-project ${PROJECT_NAME}
  --build-makeprogram ${CMAKE_MAKE_PROGRAM}
  --build-noclean
  --build-target install
  ${PACKAGE_TARGET}
  COMMENT "Install Project"
  )