-
Notifications
You must be signed in to change notification settings - Fork 0
/
CMakeLists.txt
466 lines (398 loc) · 14.6 KB
/
CMakeLists.txt
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
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
#!/usr/bin/cmake
cmake_minimum_required (VERSION 3.15)
# -------------------------------------------------------------------------------------------------
project(
NuclexSupportNative
VERSION 1.0.0
DESCRIPTION "Utility functions and basic interface definitions"
)
option(
BUILD_DOCS
"Whether to generate documentation via Doxygen"
OFF
)
option(
BUILD_UNIT_TESTS
"Whether to build the unit test executable. This will require an extra \
compilation of the entire source tree as well as the GoogleTest library."
OFF
)
option(
BUILD_BENCHMARK
"Whether to build the benchmark executable. This will require an extra \
compilation of the entire source tree as well as the Celero library."
OFF
)
option(
BENCHMARK_THIRD_PARTY_LIBRARIES
"Whether to include third-party libraries in the benchmarks. If you enable \
this option, you need to manually place the extra libraries into your \
source tree (easiest done by just enabling and checking the missing files \
in the compiler output)."
OFF
)
# -------------------------------------------------------------------------------------------------
# This sets a bunch of compile flags and defined ${NUCLEX_COMPILER_TAG} to
# say something like linux-gcc-13.2-amd64-debug. You should have this directory
# if you do a full clone of a project that is using this third-party library build.
include("../build-system/cmake/cplusplus.cmake")
# The Unix build pipeline doesn't automatically include threading, so search for
# the pthreads library in order to link against it later on.
# https://en.wikipedia.org/wiki/Pthreads
find_package(Threads REQUIRED)
# Add LibArchive as a sub-project, we use it to create and extract tar archives
if(NOT (TARGET MoodyCamelQueue))
add_subdirectory(
${PROJECT_SOURCE_DIR}/../third-party/nuclex-moodycamelqueues
${CMAKE_BINARY_DIR}/nuclex-moodycamelqueues
)
endif()
message(STATUS "Enabled options for Nuclex.Support.Native:")
message(STATUS " ⚫ Build core library")
if(BUILD_UNIT_TESTS)
message(STATUS " ⚫ Build unit tests")
# Add GoogleTest as a sub-project so we can link our unit test executable
if(NOT (TARGET GoogleTest))
add_subdirectory(
${PROJECT_SOURCE_DIR}/../third-party/nuclex-googletest
${CMAKE_BINARY_DIR}/nuclex-googletest
)
endif()
endif()
if(BUILD_BENCHMARK)
message(STATUS " ⚫ Build benchmark")
if(BENCHMARK_THIRD_PARTY_LIBRARIES)
message(STATUS " ⚫ Include third-party libraries in benchmark")
endif()
# Add Celero as a sub-project so we can link our benchmark executable
if(NOT (TARGET Celero))
add_subdirectory(
${PROJECT_SOURCE_DIR}/../third-party/nuclex-celero
${CMAKE_BINARY_DIR}/niclex-celero
)
endif()
endif()
# Use CMake's own package for locating Doxygen on the system
if(BUILD_DOCS)
find_package(Doxygen)
endif()
# -------------------------------------------------------------------------------------------------
# Project structure
#
# ProjectName/
# Source/ All source files, using deeper directories as needed
# Include/ProjectName/ All public headers, using deeper directories as needed
# Tests/ All unit tests, using deeper directories as needed
# Benchmarks/ All benchmark files, using deeper directories as needed
#
# From CMake documentation:
# | Note: We do not recommend using GLOB to collect a list of
# | source files from your source tree. If no CMakeLists.txt file
# | changes when a source is added or removed then the generated
# | build system cannot know when to ask CMake to regenerate.
#
# As so very often, CMake becomes a hurdle rather than helping.
# I'm not going to manually maintain a list of source files. Rebuilds
# where files are added, removed or renamed need to be from scratch.
#
file(
GLOB_RECURSE sourceFiles
CONFIGURE_DEPENDS
"Source/*.cpp"
"Source/*.c"
)
file(
GLOB_RECURSE headerFiles
CONFIGURE_DEPENDS
"Include/Nuclex/Support/*.h"
)
file(
GLOB_RECURSE unittestFiles
CONFIGURE_DEPENDS
"Tests/*.cpp"
)
file(
GLOB_RECURSE benchmarkFiles
CONFIGURE_DEPENDS
"Benchmarks/*.cpp"
)
# -------------------------------------------------------------------------------------------------
# Shared library that can be linked to other projects
add_library(NuclexSupportNative SHARED)
# Enable compiler warnings only if this library is compiled on its own.
# If it's used as a sub-project, the including project's developers aren't
# interested in seeing warnings from a project they're not maintaining.
if(${CMAKE_PROJECT_NAME} STREQUAL "NuclexSupportNative")
enable_target_compiler_warnings(NuclexSupportNative)
else()
disable_target_compiler_warnings(NuclexSupportNative)
endif()
# Add directory with public headers to include path
target_include_directories(
NuclexSupportNative
PUBLIC "Include"
)
# Add public headers and sources to compilation list
# (headers, too, in case CMake is used to generate an IDE project)
target_sources(
NuclexSupportNative
PUBLIC ${headerFiles}
PRIVATE ${sourceFiles}
)
# Link against PThreads
target_link_libraries(
NuclexSupportNative
PRIVATE Threads::Threads
PRIVATE MoodyCamelQueues::Static
)
# On Windows, we want the shared library to be named Nuclex.Support.Native.dll
if(WIN32)
target_link_libraries(
NuclexSupportNative
PRIVATE synchronization.lib
)
set_target_properties(
NuclexSupportNative
PROPERTIES OUTPUT_NAME "Nuclex.Support.Native"
)
endif()
# -------------------------------------------------------------------------------------------------
if(BUILD_UNIT_TESTS)
# Executable that runs the unit tests (main() supplied by GoogleTest)
add_executable(NuclexSupportNativeTests)
# Enable compiler warnings only if this library is compiles on its own.
# If it's used as a sub-project, the including project's developers aren't
# interested in seeing warnings from a project they're not maintaining.
if(${CMAKE_PROJECT_NAME} STREQUAL "NuclexSupportNative")
enable_target_compiler_warnings(NuclexSupportNativeTests)
else()
disable_target_compiler_warnings(NuclexSupportNativeTests)
endif()
# Let the code know it's not being compiled into a shared library
# (this disables visibility/exports, thus allowing the compiler detect
# additional unused code and warn about it)
target_compile_definitions(
NuclexSupportNativeTests
PRIVATE NUCLEX_SUPPORT_EXECUTABLE
)
# Add directory with public headers to include path
target_include_directories(
NuclexSupportNativeTests
PUBLIC "Include"
)
# Add public headers and sources (normal + unit tests) to compilation list
# (headers, too, in case CMake is used to generate an IDE project)
target_sources(
NuclexSupportNativeTests
PRIVATE ${headerFiles}
PRIVATE ${sourceFiles}
PRIVATE ${unittestFiles}
)
# Link GoogleTest and the main() function supplied by GoogleTest
# Also link against PThreads
target_link_libraries(
NuclexSupportNativeTests
PRIVATE GoogleTest::Static
PRIVATE GoogleTest::Main
PRIVATE Threads::Threads
PRIVATE MoodyCamelQueues::Static
)
# On Windows, we want the executable to be named Nuclex.Support.Native.Tests.exe
if(WIN32)
target_link_libraries(
NuclexSupportNativeTests
PRIVATE synchronization.lib
)
set_target_properties(
NuclexSupportNativeTests
PROPERTIES OUTPUT_NAME "Nuclex.Support.Native.Tests"
)
endif()
endif() # if BUILD_UNIT_TESTS enabled
# -------------------------------------------------------------------------------------------------
if(BUILD_BENCHMARK)
# Executable that runs the benchmark (main() supplied by Celero)
add_executable(NuclexSupportNativeBenchmark)
# Enable compiler warnings only if this library is compiles on its own.
# If it's used as a sub-project, the including project's developers aren't
# interested in seeing warnings from a project they're not maintaining.
if(${CMAKE_PROJECT_NAME} STREQUAL "NuclexSupportNative")
enable_target_compiler_warnings(NuclexSupportNativeBenchmark)
else()
disable_target_compiler_warnings(NuclexSupportNativeBenchmark)
endif()
# Let the code know it's not being compiled into a shared library
# (this disables visibility/exports, thus allowing the compiler detect
# additional unused code and warn about it)
target_compile_definitions(
NuclexSupportNativeBenchmark
PRIVATE NUCLEX_SUPPORT_EXECUTABLE
)
if(BENCHMARK_THIRD_PARTY_LIBRARIES)
target_compile_definitions(
NuclexSupportNativeBenchmark
PRIVATE HAVE_BOOST_SIGNALS
PRIVATE HAVE_LSIGNAL
PRIVATE HAVE_NANO_SIGNALS
PRIVATE HAVE_JEAIII_ITOA
)
if(NOT WIN32)
target_compile_definitions(
NuclexSupportNativeBenchmark
PRIVATE HAVE_AMDN_ITOA
)
endif()
endif()
# Add directory with public headers to include path
target_include_directories(
NuclexSupportNativeBenchmark
PUBLIC "Include"
)
# Add public headers and sources (normal + benchmark) to compilation list
# (headers, too, in case CMake is used to generate an IDE project)
target_sources(
NuclexSupportNativeBenchmark
PRIVATE ${headerFiles}
PRIVATE ${sourceFiles}
PRIVATE ${benchmarkFiles}
)
# Link GoogleTest and the main() function supplied by GoogleTest
# Also link against PThreads
target_link_libraries(
NuclexSupportNativeBenchmark
PRIVATE Celero::Static
PRIVATE Threads::Threads
PRIVATE MoodyCamelQueues::Static
)
# On Windows, we want the executable to be named Nuclex.Support.Native.Benchmark.exe
if(WIN32)
target_link_libraries(
NuclexSupportNativeBenchmark
PRIVATE synchronization.lib
)
set_target_properties(
NuclexSupportNativeBenchmark
PROPERTIES OUTPUT_NAME "Nuclex.Support.Native.Benchmark"
)
endif()
endif() # if BUILD_BENCHMARK enabled
# -------------------------------------------------------------------------------------------------
# Install the shared library into a subdirectory of this CMakeLists.txt file
# under ./bin/linux-gcc9.3-amd64-debug/ (the second-level directory is called
# "compiler tag" and dynamically formed -- it ensures that when linking
# a pre-compiled shared library, the correct library is used).
install(
TARGETS NuclexSupportNative
ARCHIVE DESTINATION ${PROJECT_SOURCE_DIR}/bin/${NUCLEX_COMPILER_TAG}
LIBRARY DESTINATION ${PROJECT_SOURCE_DIR}/bin/${NUCLEX_COMPILER_TAG}
RUNTIME DESTINATION ${PROJECT_SOURCE_DIR}/bin/${NUCLEX_COMPILER_TAG}
)
# Install .pdb files on Windows platforms.
#
# CMake forgets installing .pdb files for debug builds. These are needed by
# Microsoft compilers when debugging to associate machine code locations to
# source files and line numbers.
install_debug_symbols(NuclexSupportNative)
# Install unit tests in same location as shared library.
if(BUILD_UNIT_TESTS)
install(
TARGETS NuclexSupportNativeTests
RUNTIME DESTINATION ${PROJECT_SOURCE_DIR}/bin/${NUCLEX_COMPILER_TAG}
)
# Install .pdb files on Windows platforms for the unit tests, too.
install_debug_symbols(NuclexSupportNativeTests)
endif()
# Install benchmarks in same location as shared library.
if(BUILD_BENCHMARK)
install(
TARGETS NuclexSupportNativeBenchmark
RUNTIME DESTINATION ${PROJECT_SOURCE_DIR}/bin/${NUCLEX_COMPILER_TAG}
)
# Install .pdb files on Windows platforms for the unit tests, too.
install_debug_symbols(NuclexSupportNativeBenchmark)
endif()
# -------------------------------------------------------------------------------------------------
if(BUILD_DOCS)
if(NOT DOXYGEN_FOUND)
message(FATAL_ERROR "Can't build documentation because Doxygen was not found")
endif()
add_custom_target(
NuclexSupportNativeDocs ALL
COMMAND ${DOXYGEN_EXECUTABLE} "Nuclex.Support.Native.doxygen.cfg"
WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
)
endif()
# -------------------------------------------------------------------------------------------------
file(
WRITE "${PROJECT_SOURCE_DIR}/NuclexSupportNativeConfig.cmake"
"#!/usr/bin/cmake
# Configuration to include Nuclex.Support.Native in a CMake-based project. If you want to
# reference Nuclex.Support.Native as an externally compiled static library, do this:
#
# set(NuclexSupportNative_DIR \"../Nuclex.Support.Native\")
# find_package(NuclexSupportNative REQUIRED CONFIG)
#
# target_link_libraries(
# MyAwesomeProject
# PRIVATE NuclexSupportNative::Dynamic
# )
#
# Alternatively, if you want to build Nuclex.Support.Native together with your project,
# use the normal CMakeLists.txt with CMake's add_subdirectory() command:
#
# add_subdirectory(
# \"\${PROJECT_SOURCE_DIR}/../Nuclex.Support.Native\"
# \"\${CMAKE_BINARY_DIR}/nuclex.support.native\"
# )
#
# target_link_libraries(
# MyAwesomeProject
# PRIVATE NuclexSupportNative
# )
#
# -------------------------------------------------------------------------------------------------
if(NOT DEFINED NUCLEX_COMPILER_TAG)
message(
FATAL_ERROR
\"NUCLEX_COMPILER_TAG not defined! Include cplusplus.cmake before importing this package \\
in order to generate a tag identifying the platform/compiler/architecture/variant!\"
)
endif()
# -------------------------------------------------------------------------------------------------
if(NOT EXISTS \"\${CMAKE_CURRENT_LIST_DIR}/bin/\${NUCLEX_COMPILER_TAG}\")
# TODO: Warn and link release build when compiling in debug mode
# TODO: Warn and link build for older compiler version if found
message(
FATAL_ERROR
\"Directory '\${CMAKE_CURRENT_LIST_DIR}/bin/\${NUCLEX_COMPILER_TAG}' not found. \\
Please either build and install this project before importing it via \\
find_package() or use this project's main CMakeFiles.txt via add_subdirectory()!\"
)
endif()
# -------------------------------------------------------------------------------------------------
add_library(NuclexSupportNative::Dynamic SHARED IMPORTED)
# This may cause warnings on recent GCC versions (10.0.0+?) with LTO because GCC detects
# that the headers used during build (residing in build/) are not the same used when
# linking the library (copies resising in Include/).
#
# CMake doesn't run the install step during build, so the only way to get the headers
# in place before building would be by copying them rather than installing them.
set_target_properties(
NuclexSupportNative::Dynamic PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES \"\${CMAKE_CURRENT_LIST_DIR}/Include\"
IMPORTED_LINK_INTERFACE_LANGUAGES \"C\"
)
if(WIN32)
set_target_properties(
NuclexSupportNative::Dynamic PROPERTIES
IMPORTED_LOCATION \"\${CMAKE_CURRENT_LIST_DIR}/bin/\${NUCLEX_COMPILER_TAG}/Nuclex.Support.Native.lib\"
)
else()
set_target_properties(
NuclexSupportNative::Dynamic PROPERTIES
IMPORTED_LOCATION \"\${CMAKE_CURRENT_LIST_DIR}/bin/\${NUCLEX_COMPILER_TAG}/libNuclexSupportNative.so\"
)
endif()
message(STATUS \"Imported Nuclex.Support.Native targets with binaries in '\${CMAKE_CURRENT_LIST_DIR}'\")"
) # end of a long file() statement
# -------------------------------------------------------------------------------------------------