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

4
5
6
7
8
9
#[=======================================================================[.rst:
FindBoost
---------

Find Boost include dirs and libraries

10
11
12
Use this module by invoking :command:`find_package` with the form:

.. code-block:: cmake
13
14
15
16
17
18
19
20
21
22
23
24

  find_package(Boost
    [version] [EXACT]      # Minimum or EXACT version e.g. 1.67.0
    [REQUIRED]             # Fail with error if Boost is not found
    [COMPONENTS <libs>...] # Boost libraries by their canonical name
                           # e.g. "date_time" for "libboost_date_time"
    [OPTIONAL_COMPONENTS <libs>...]
                           # Optional Boost libraries by their canonical name)
    )                      # e.g. "date_time" for "libboost_date_time"

This module finds headers and requested component libraries OR a CMake
package configuration file provided by a "Boost CMake" build.  For the
25
26
latter case skip to the :ref:`Boost CMake` section below.

27
28
29
30
31
32
33
34
35
36
37
38
.. versionadded:: 3.7
  ``bzip2`` and ``zlib`` components (Windows only).

.. versionadded:: 3.11
  The ``OPTIONAL_COMPONENTS`` option.

.. versionadded:: 3.13
  ``stacktrace_*`` components.

.. versionadded:: 3.19
  ``bzip2`` and ``zlib`` components on all platforms.

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
Result Variables
^^^^^^^^^^^^^^^^

This module defines the following variables:

``Boost_FOUND``
  True if headers and requested libraries were found.

``Boost_INCLUDE_DIRS``
  Boost include directories.

``Boost_LIBRARY_DIRS``
  Link directories for Boost libraries.

``Boost_LIBRARIES``
  Boost component libraries to be linked.

``Boost_<COMPONENT>_FOUND``
  True if component ``<COMPONENT>`` was found (``<COMPONENT>`` name is upper-case).

``Boost_<COMPONENT>_LIBRARY``
  Libraries to link for component ``<COMPONENT>`` (may include
  :command:`target_link_libraries` debug/optimized keywords).

``Boost_VERSION_MACRO``
  ``BOOST_VERSION`` value from ``boost/version.hpp``.

``Boost_VERSION_STRING``
  Boost version number in ``X.Y.Z`` format.

``Boost_VERSION``
70
71
72
73
74
75
  Boost version number in ``X.Y.Z`` format (same as ``Boost_VERSION_STRING``).

  .. versionchanged:: 3.15
    In previous CMake versions, this variable used the raw version string
    from the Boost header (same as ``Boost_VERSION_MACRO``).
    See policy :policy:`CMP0093`.
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

``Boost_LIB_VERSION``
  Version string appended to library filenames.

``Boost_VERSION_MAJOR``, ``Boost_MAJOR_VERSION``
  Boost major version number (``X`` in ``X.Y.Z``).

``Boost_VERSION_MINOR``, ``Boost_MINOR_VERSION``
  Boost minor version number (``Y`` in ``X.Y.Z``).

``Boost_VERSION_PATCH``, ``Boost_SUBMINOR_VERSION``
  Boost subminor version number (``Z`` in ``X.Y.Z``).

``Boost_VERSION_COUNT``
  Amount of version components (3).

``Boost_LIB_DIAGNOSTIC_DEFINITIONS`` (Windows-specific)
  Pass to :command:`add_definitions` to have diagnostic
  information about Boost's automatic linking
  displayed during compilation
96

97
98
.. versionadded:: 3.15
  The ``Boost_VERSION_<PART>`` variables.
99

100
101
Cache variables
^^^^^^^^^^^^^^^
102

103
Search results are saved persistently in CMake cache entries:
104

105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
``Boost_INCLUDE_DIR``
  Directory containing Boost headers.

``Boost_LIBRARY_DIR_RELEASE``
  Directory containing release Boost libraries.

``Boost_LIBRARY_DIR_DEBUG``
  Directory containing debug Boost libraries.

``Boost_<COMPONENT>_LIBRARY_DEBUG``
  Component ``<COMPONENT>`` library debug variant.

``Boost_<COMPONENT>_LIBRARY_RELEASE``
  Component ``<COMPONENT>`` library release variant.

120
121
122
123
.. versionadded:: 3.3
  Per-configuration variables ``Boost_LIBRARY_DIR_RELEASE`` and
  ``Boost_LIBRARY_DIR_DEBUG``.

124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
Hints
^^^^^

This module reads hints about search locations from variables:

``BOOST_ROOT``, ``BOOSTROOT``
  Preferred installation prefix.

``BOOST_INCLUDEDIR``
  Preferred include directory e.g. ``<prefix>/include``.

``BOOST_LIBRARYDIR``
  Preferred library directory e.g. ``<prefix>/lib``.

``Boost_NO_SYSTEM_PATHS``
  Set to ``ON`` to disable searching in locations not
  specified by these hint variables. Default is ``OFF``.

``Boost_ADDITIONAL_VERSIONS``
  List of Boost versions not known to this module.
  (Boost install locations may contain the version).
145

146
Users may set these hints or results as ``CACHE`` entries.  Projects
147
148
should not read these entries directly but instead use the above
result variables.  Note that some hint names start in upper-case
149
``BOOST``.  One may specify these as environment variables if they are
150
151
not specified as CMake variables or cache entries.

152
This module first searches for the Boost header files using the above
153
154
155
156
hint variables (excluding ``BOOST_LIBRARYDIR``) and saves the result in
``Boost_INCLUDE_DIR``.  Then it searches for requested component libraries
using the above hints (excluding ``BOOST_INCLUDEDIR`` and
``Boost_ADDITIONAL_VERSIONS``), "lib" directories near ``Boost_INCLUDE_DIR``,
157
and the library name configuration settings below.  It saves the
158
159
library directories in ``Boost_LIBRARY_DIR_DEBUG`` and
``Boost_LIBRARY_DIR_RELEASE`` and individual library
160
locations in ``Boost_<COMPONENT>_LIBRARY_DEBUG`` and ``Boost_<COMPONENT>_LIBRARY_RELEASE``.
161
162
163
164
When one changes settings used by previous searches in the same build
tree (excluding environment variables) this module discards previous
search results affected by the changes and searches again.

165
166
167
Imported Targets
^^^^^^^^^^^^^^^^

168
169
.. versionadded:: 3.5

170
171
This module defines the following :prop_tgt:`IMPORTED` targets:

172
``Boost::boost``
173
  Target for header-only dependencies. (Boost include directory).
174
175
176
177

``Boost::headers``
  .. versionadded:: 3.15
    Alias for ``Boost::boost``.
178
179
180
181
182
183
184
185
186
187
188
189
190
191

``Boost::<component>``
  Target for specific component dependency (shared or static library);
  ``<component>`` name is lower-case.

``Boost::diagnostic_definitions``
  Interface target to enable diagnostic information about Boost's automatic
  linking during compilation (adds ``-DBOOST_LIB_DIAGNOSTIC``).

``Boost::disable_autolinking``
  Interface target to disable automatic linking with MSVC
  (adds ``-DBOOST_ALL_NO_LIB``).

``Boost::dynamic_linking``
tocic's avatar
tocic committed
192
  Interface target to enable dynamic linking with MSVC
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
  (adds ``-DBOOST_ALL_DYN_LINK``).

Implicit dependencies such as ``Boost::filesystem`` requiring
``Boost::system`` will be automatically detected and satisfied, even
if system is not specified when using :command:`find_package` and if
``Boost::system`` is not added to :command:`target_link_libraries`.  If using
``Boost::thread``, then ``Threads::Threads`` will also be added automatically.

It is important to note that the imported targets behave differently
than variables created by this module: multiple calls to
:command:`find_package(Boost)` in the same directory or sub-directories with
different options (e.g. static or shared) will not override the
values of the targets created by the first call.

Other Variables
^^^^^^^^^^^^^^^

210
211
Boost libraries come in many variants encoded in their file name.
Users or projects may tell this module which variant to find by
212
213
214
setting variables:

``Boost_USE_DEBUG_LIBS``
215
216
  .. versionadded:: 3.10

217
218
219
220
  Set to ``ON`` or ``OFF`` to specify whether to search and use the debug
  libraries.  Default is ``ON``.

``Boost_USE_RELEASE_LIBS``
221
222
  .. versionadded:: 3.10

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
  Set to ``ON`` or ``OFF`` to specify whether to search and use the release
  libraries.  Default is ``ON``.

``Boost_USE_MULTITHREADED``
  Set to OFF to use the non-multithreaded libraries ("mt" tag). Default is
  ``ON``.

``Boost_USE_STATIC_LIBS``
  Set to ON to force the use of the static libraries.  Default is ``OFF``.

``Boost_USE_STATIC_RUNTIME``
  Set to ``ON`` or ``OFF`` to specify whether to use libraries linked
  statically to the C++ runtime ("s" tag).  Default is platform dependent.

``Boost_USE_DEBUG_RUNTIME``
  Set to ``ON`` or ``OFF`` to specify whether to use libraries linked to the
  MS debug C++ runtime ("g" tag).  Default is ``ON``.

``Boost_USE_DEBUG_PYTHON``
  Set to ``ON`` to use libraries compiled with a debug Python build ("y"
  tag).  Default is ``OFF``.

``Boost_USE_STLPORT``
  Set to ``ON`` to use libraries compiled with STLPort ("p" tag). Default is
  ``OFF``.

``Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS``
  Set to ON to use libraries compiled with STLPort deprecated "native
  iostreams" ("n" tag).  Default is ``OFF``.

``Boost_COMPILER``
  Set to the compiler-specific library suffix (e.g. ``-gcc43``).  Default is
255
256
257
258
259
  auto-computed for the C++ compiler in use.

  .. versionchanged:: 3.9
    A list may be used if multiple compatible suffixes should be tested for,
    in decreasing order of preference.
260
261

``Boost_LIB_PREFIX``
262
263
  .. versionadded:: 3.18

264
265
266
267
268
  Set to the platform-specific library name prefix (e.g. ``lib``) used by
  Boost static libs.  This is needed only on platforms where CMake does not
  know the prefix by default.

``Boost_ARCHITECTURE``
269
270
  .. versionadded:: 3.13

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
  Set to the architecture-specific library suffix (e.g. ``-x64``).
  Default is auto-computed for the C++ compiler in use.

``Boost_THREADAPI``
  Suffix for ``thread`` component library name, such as ``pthread`` or
  ``win32``.  Names with and without this suffix will both be tried.

``Boost_NAMESPACE``
  Alternate namespace used to build boost with e.g. if set to ``myboost``,
  will search for ``myboost_thread`` instead of ``boost_thread``.

Other variables one may set to control this module are:

``Boost_DEBUG``
  Set to ``ON`` to enable debug output from ``FindBoost``.
  Please enable this before filing any bug report.

``Boost_REALPATH``
  Set to ``ON`` to resolve symlinks for discovered libraries to assist with
  packaging.  For example, the "system" component library may be resolved to
  ``/usr/lib/libboost_system.so.1.67.0`` instead of
  ``/usr/lib/libboost_system.so``.  This does not affect linking and should
  not be enabled unless the user needs this information.

``Boost_LIBRARY_DIR``
  Default value for ``Boost_LIBRARY_DIR_RELEASE`` and
  ``Boost_LIBRARY_DIR_DEBUG``.
298

299
300
301
302
303
304
``Boost_NO_WARN_NEW_VERSIONS``
  .. versionadded:: 3.20

  Set to ``ON`` to suppress the warning about unknown dependencies for new
  Boost versions.

305
306
307
On Visual Studio and Borland compilers Boost headers request automatic
linking to corresponding libraries.  This requires matching libraries
to be linked explicitly or available in the link library search path.
308
In this case setting ``Boost_USE_STATIC_LIBS`` to ``OFF`` may not achieve
309
dynamic linking.  Boost automatic linking typically requests static
310
311
312
libraries with a few exceptions (such as ``Boost.Python``).  Use:

.. code-block:: cmake
313
314
315
316
317

  add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})

to ask Boost to report information about automatic linking requests.

318
319
320
321
322
323
Examples
^^^^^^^^

Find Boost headers only:

.. code-block:: cmake
324
325
326
327
328
329
330

  find_package(Boost 1.36.0)
  if(Boost_FOUND)
    include_directories(${Boost_INCLUDE_DIRS})
    add_executable(foo foo.cc)
  endif()

331
332
333
Find Boost libraries and use imported targets:

.. code-block:: cmake
334
335
336
337
338
339
340

  find_package(Boost 1.56 REQUIRED COMPONENTS
               date_time filesystem iostreams)
  add_executable(foo foo.cc)
  target_link_libraries(foo Boost::date_time Boost::filesystem
                            Boost::iostreams)

341
342
343
Find Boost Python 3.6 libraries and use imported targets:

.. code-block:: cmake
344
345
346
347
348
349

  find_package(Boost 1.67 REQUIRED COMPONENTS
               python36 numpy36)
  add_executable(foo foo.cc)
  target_link_libraries(foo Boost::python36 Boost::numpy36)

350
351
352
Find Boost headers and some *static* (release only) libraries:

.. code-block:: cmake
353
354

  set(Boost_USE_STATIC_LIBS        ON)  # only find static libs
355
  set(Boost_USE_DEBUG_LIBS        OFF)  # ignore debug libs and
356
357
358
359
360
361
362
363
364
365
  set(Boost_USE_RELEASE_LIBS       ON)  # only find release libs
  set(Boost_USE_MULTITHREADED      ON)
  set(Boost_USE_STATIC_RUNTIME    OFF)
  find_package(Boost 1.66.0 COMPONENTS date_time filesystem system ...)
  if(Boost_FOUND)
    include_directories(${Boost_INCLUDE_DIRS})
    add_executable(foo foo.cc)
    target_link_libraries(foo ${Boost_LIBRARIES})
  endif()

366
367
.. _`Boost CMake`:

368
369
370
Boost CMake
^^^^^^^^^^^

371
372
373
If Boost was built using the boost-cmake project or from Boost 1.70.0 on
it provides a package configuration file for use with find_package's config mode.
This module looks for the package configuration file called
374
``BoostConfig.cmake`` or ``boost-config.cmake`` and stores the result in
375
``CACHE`` entry ``Boost_DIR``.  If found, the package configuration file is loaded
376
377
378
and this module returns with no further action.  See documentation of
the Boost CMake package configuration for details on what it provides.

379
Set ``Boost_NO_BOOST_CMAKE`` to ``ON``, to disable the search for boost-cmake.
380
#]=======================================================================]
381

382
383
384
385
# The FPHSA helper provides standard way of reporting final search results to
# the user including the version and component checks.
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)

386
387
388
# Save project's policies
cmake_policy(PUSH)
cmake_policy(SET CMP0057 NEW) # if IN_LIST
389
cmake_policy(SET CMP0102 NEW) # if mark_as_advanced(non_cache_var)
390

391
392
function(_boost_get_existing_target component target_var)
  set(names "${component}")
393
  if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9]+)?$")
394
395
396
397
398
399
400
401
402
403
404
405
406
407
    # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
    list(APPEND names
      "${CMAKE_MATCH_1}${CMAKE_MATCH_2}" # python
      "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}" # pythonX
      "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}${CMAKE_MATCH_4}" #pythonXY
    )
  endif()
  # https://github.com/boost-cmake/boost-cmake uses boost::file_system etc.
  # So handle similar constructions of target names
  string(TOLOWER "${component}" lower_component)
  list(APPEND names "${lower_component}")
  foreach(prefix Boost boost)
    foreach(name IN LISTS names)
      if(TARGET "${prefix}::${name}")
408
409
        # The target may be an INTERFACE library that wraps around a single other
        # target for compatibility.  Unwrap this layer so we can extract real info.
410
        if("${name}" MATCHES "^(python|numpy|mpi_python)([1-9])([0-9]+)$")
411
412
413
414
415
416
417
418
419
420
421
422
          set(name_nv "${CMAKE_MATCH_1}")
          if(TARGET "${prefix}::${name_nv}")
            get_property(type TARGET "${prefix}::${name}" PROPERTY TYPE)
            if(type STREQUAL "INTERFACE_LIBRARY")
              get_property(lib TARGET "${prefix}::${name}" PROPERTY INTERFACE_LINK_LIBRARIES)
              if("${lib}" STREQUAL "${prefix}::${name_nv}")
                set(${target_var} "${prefix}::${name_nv}" PARENT_SCOPE)
                return()
              endif()
            endif()
          endif()
        endif()
423
424
425
426
427
428
429
430
431
432
        set(${target_var} "${prefix}::${name}" PARENT_SCOPE)
        return()
      endif()
    endforeach()
  endforeach()
  set(${target_var} "" PARENT_SCOPE)
endfunction()

function(_boost_get_canonical_target_name component target_var)
  string(TOLOWER "${component}" component)
433
  if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9]+)?$")
434
435
436
437
438
439
440
441
    # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
    set(${target_var} "Boost::${CMAKE_MATCH_1}${CMAKE_MATCH_2}" PARENT_SCOPE)
  else()
    set(${target_var} "Boost::${component}" PARENT_SCOPE)
  endif()
endfunction()

macro(_boost_set_in_parent_scope name value)
442
  # Set a variable in parent scope and make it visible in current scope
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
  set(${name} "${value}" PARENT_SCOPE)
  set(${name} "${value}")
endmacro()

macro(_boost_set_if_unset name value)
  if(NOT ${name})
    _boost_set_in_parent_scope(${name} "${value}")
  endif()
endmacro()

macro(_boost_set_cache_if_unset name value)
  if(NOT ${name})
    set(${name} "${value}" CACHE STRING "" FORCE)
  endif()
endmacro()

macro(_boost_append_include_dir target)
  get_target_property(inc "${target}" INTERFACE_INCLUDE_DIRECTORIES)
  if(inc)
    list(APPEND include_dirs "${inc}")
  endif()
endmacro()

function(_boost_set_legacy_variables_from_config)
  # Set legacy variables for compatibility if not set
  set(include_dirs "")
  set(library_dirs "")
  set(libraries "")
  # Header targets Boost::headers or Boost::boost
  foreach(comp headers boost)
    _boost_get_existing_target(${comp} target)
    if(target)
      _boost_append_include_dir("${target}")
    endif()
  endforeach()
  # Library targets
  foreach(comp IN LISTS Boost_FIND_COMPONENTS)
    string(TOUPPER ${comp} uppercomp)
    # Overwrite if set
    _boost_set_in_parent_scope(Boost_${uppercomp}_FOUND "${Boost_${comp}_FOUND}")
    if(Boost_${comp}_FOUND)
      _boost_get_existing_target(${comp} target)
      if(NOT target)
        if(Boost_DEBUG OR Boost_VERBOSE)
487
          message(WARNING "Could not find imported target for required component '${comp}'. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.")
488
489
490
491
492
493
494
        endif()
        continue()
      endif()
      _boost_append_include_dir("${target}")
      _boost_set_if_unset(Boost_${uppercomp}_LIBRARY "${target}")
      _boost_set_if_unset(Boost_${uppercomp}_LIBRARIES "${target}") # Very old legacy variable
      list(APPEND libraries "${target}")
495
496
497
498
499
500
501
502
503
504
505
506
507
508
      get_property(type TARGET "${target}" PROPERTY TYPE)
      if(NOT type STREQUAL "INTERFACE_LIBRARY")
        foreach(cfg RELEASE DEBUG)
          get_target_property(lib ${target} IMPORTED_LOCATION_${cfg})
          if(lib)
            get_filename_component(lib_dir "${lib}" DIRECTORY)
            list(APPEND library_dirs ${lib_dir})
            _boost_set_cache_if_unset(Boost_${uppercomp}_LIBRARY_${cfg} "${lib}")
          endif()
        endforeach()
      elseif(Boost_DEBUG OR Boost_VERBOSE)
        # For projects using only the Boost::* targets this warning can be safely ignored.
        message(WARNING "Imported target '${target}' for required component '${comp}' has no artifact. Legacy variables for this component might be missing. Refer to the documentation of your Boost installation for help on variables to use.")
      endif()
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
      _boost_get_canonical_target_name("${comp}" canonical_target)
      if(NOT TARGET "${canonical_target}")
        add_library("${canonical_target}" INTERFACE IMPORTED)
        target_link_libraries("${canonical_target}" INTERFACE "${target}")
      endif()
    endif()
  endforeach()
  list(REMOVE_DUPLICATES include_dirs)
  list(REMOVE_DUPLICATES library_dirs)
  _boost_set_if_unset(Boost_INCLUDE_DIRS "${include_dirs}")
  _boost_set_if_unset(Boost_LIBRARY_DIRS "${library_dirs}")
  _boost_set_if_unset(Boost_LIBRARIES "${libraries}")
  _boost_set_if_unset(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}")
  find_path(Boost_INCLUDE_DIR
    NAMES boost/version.hpp boost/config.hpp
    HINTS ${Boost_INCLUDE_DIRS}
    NO_DEFAULT_PATH
  )
  if(NOT Boost_VERSION_MACRO OR NOT Boost_LIB_VERSION)
    set(version_file ${Boost_INCLUDE_DIR}/boost/version.hpp)
    if(EXISTS "${version_file}")
      file(STRINGS "${version_file}" contents REGEX "#define BOOST_(LIB_)?VERSION ")
      if(contents MATCHES "#define BOOST_VERSION ([0-9]+)")
        _boost_set_if_unset(Boost_VERSION_MACRO "${CMAKE_MATCH_1}")
      endif()
      if(contents MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"")
        _boost_set_if_unset(Boost_LIB_VERSION "${CMAKE_MATCH_1}")
      endif()
    endif()
  endif()
  _boost_set_if_unset(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR})
  _boost_set_if_unset(Boost_MINOR_VERSION ${Boost_VERSION_MINOR})
  _boost_set_if_unset(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH})
  if(WIN32)
    _boost_set_if_unset(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC")
  endif()
  if(NOT TARGET Boost::headers)
    add_library(Boost::headers INTERFACE IMPORTED)
    target_include_directories(Boost::headers INTERFACE ${Boost_INCLUDE_DIRS})
  endif()
  # Legacy targets w/o functionality as all handled by defined targets
  foreach(lib diagnostic_definitions disable_autolinking dynamic_linking)
    if(NOT TARGET Boost::${lib})
      add_library(Boost::${lib} INTERFACE IMPORTED)
    endif()
  endforeach()
  if(NOT TARGET Boost::boost)
    add_library(Boost::boost INTERFACE IMPORTED)
    target_link_libraries(Boost::boost INTERFACE Boost::headers)
  endif()
endfunction()

561
#-------------------------------------------------------------------------------
562
563
# Before we go searching, check whether a boost cmake package is available, unless
# the user specifically asked NOT to search for one.
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
#
# If Boost_DIR is set, this behaves as any find_package call would. If not,
# it looks at BOOST_ROOT and BOOSTROOT to find Boost.
#
if (NOT Boost_NO_BOOST_CMAKE)
  # If Boost_DIR is not set, look for BOOSTROOT and BOOST_ROOT as alternatives,
  # since these are more conventional for Boost.
  if ("$ENV{Boost_DIR}" STREQUAL "")
    if (NOT "$ENV{BOOST_ROOT}" STREQUAL "")
      set(ENV{Boost_DIR} $ENV{BOOST_ROOT})
    elseif (NOT "$ENV{BOOSTROOT}" STREQUAL "")
      set(ENV{Boost_DIR} $ENV{BOOSTROOT})
    endif()
  endif()

579
580
581
582
583
  set(_boost_FIND_PACKAGE_ARGS "")
  if(Boost_NO_SYSTEM_PATHS)
    list(APPEND _boost_FIND_PACKAGE_ARGS NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH)
  endif()

584
585
586
  # Do the same find_package call but look specifically for the CMake version.
  # Note that args are passed in the Boost_FIND_xxxxx variables, so there is no
  # need to delegate them to this find_package call.
587
  if(BOOST_ROOT AND NOT Boost_ROOT)
588
589
    # Honor BOOST_ROOT by setting Boost_ROOT with CMP0074 NEW behavior.
    cmake_policy(PUSH)
590
591
    cmake_policy(SET CMP0074 NEW)
    set(Boost_ROOT "${BOOST_ROOT}")
592
    set(_Boost_ROOT_FOR_CONFIG 1)
593
  endif()
594
  find_package(Boost QUIET NO_MODULE ${_boost_FIND_PACKAGE_ARGS})
595
596
597
598
599
  if(_Boost_ROOT_FOR_CONFIG)
    unset(_Boost_ROOT_FOR_CONFIG)
    unset(Boost_ROOT)
    cmake_policy(POP)
  endif()
600
601
602
  if (DEFINED Boost_DIR)
    mark_as_advanced(Boost_DIR)
  endif ()
603

604
  # If we found a boost cmake package, then we're done. Print out what we found.
605
  # Otherwise let the rest of the module try to find it.
606
  if(Boost_FOUND)
607
608
    # Convert component found variables to standard variables if required
    # Necessary for legacy boost-cmake and 1.70 builtin BoostConfig
609
    if(Boost_FIND_COMPONENTS)
610
611
612
      # Ignore the meta-component "ALL", introduced by Boost 1.73
      list(REMOVE_ITEM Boost_FIND_COMPONENTS "ALL")

613
      foreach(_comp IN LISTS Boost_FIND_COMPONENTS)
614
615
616
        if(DEFINED Boost_${_comp}_FOUND)
          continue()
        endif()
617
        string(TOUPPER ${_comp} _uppercomp)
618
        if(DEFINED Boost${_comp}_FOUND) # legacy boost-cmake project
619
          set(Boost_${_comp}_FOUND ${Boost${_comp}_FOUND})
620
        elseif(DEFINED Boost_${_uppercomp}_FOUND) # Boost 1.70
621
622
623
          set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND})
        endif()
      endforeach()
624
    endif()
625
626

    find_package_handle_standard_args(Boost HANDLE_COMPONENTS CONFIG_MODE)
627
    _boost_set_legacy_variables_from_config()
628

629
630
    # Restore project's policies
    cmake_policy(POP)
631
632
633
634
635
    return()
  endif()
endif()


636
637
638
#-------------------------------------------------------------------------------
#  FindBoost functions & macros
#
639

640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
#
# Print debug text if Boost_DEBUG is set.
# Call example:
# _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "debug message")
#
function(_Boost_DEBUG_PRINT file line text)
  if(Boost_DEBUG)
    message(STATUS "[ ${file}:${line} ] ${text}")
  endif()
endfunction()

#
# _Boost_DEBUG_PRINT_VAR(file line variable_name [ENVIRONMENT]
#                        [SOURCE "short explanation of origin of var value"])
#
#   ENVIRONMENT - look up environment variable instead of CMake variable
#
# Print variable name and its value if Boost_DEBUG is set.
# Call example:
# _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" BOOST_ROOT)
#
function(_Boost_DEBUG_PRINT_VAR file line name)
  if(Boost_DEBUG)
    cmake_parse_arguments(_args "ENVIRONMENT" "SOURCE" "" ${ARGN})

    unset(source)
    if(_args_SOURCE)
      set(source " (${_args_SOURCE})")
    endif()

    if(_args_ENVIRONMENT)
      if(DEFINED ENV{${name}})
        set(value "\"$ENV{${name}}\"")
      else()
        set(value "<unset>")
      endif()
      set(_name "ENV{${name}}")
    else()
      if(DEFINED "${name}")
        set(value "\"${${name}}\"")
      else()
        set(value "<unset>")
      endif()
      set(_name "${name}")
    endif()

    _Boost_DEBUG_PRINT("${file}" "${line}" "${_name} = ${value}${source}")
  endif()
endfunction()

690
############################################
691
#
692
# Check the existence of the libraries.
693
#
694
695
696
697
698
############################################
# This macro was taken directly from the FindQt4.cmake file that is included
# with the CMake distribution. This is NOT my work. All work was done by the
# original authors of the FindQt4.cmake file. Only minor modifications were
# made to remove references to Qt and make this file more generally applicable
699
# And ELSE/ENDIF pairs were removed for readability.
700
#########################################################################
701

702
703
704
macro(_Boost_ADJUST_LIB_VARS basename)
  if(Boost_INCLUDE_DIR )
    if(Boost_${basename}_LIBRARY_DEBUG AND Boost_${basename}_LIBRARY_RELEASE)
705
706
707
708
      # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
      # single-config generators, set optimized and debug libraries
      get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
      if(_isMultiConfig OR CMAKE_BUILD_TYPE)
709
710
        set(Boost_${basename}_LIBRARY optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
      else()
711
712
        # For single-config generators where CMAKE_BUILD_TYPE has no value,
        # just use the release libraries
713
714
        set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} )
      endif()
715
      # FIXME: This probably should be set for both cases
716
717
      set(Boost_${basename}_LIBRARIES optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
    endif()
718

719
    # if only the release version was found, set the debug variable also to the release version
720
721
722
723
724
    if(Boost_${basename}_LIBRARY_RELEASE AND NOT Boost_${basename}_LIBRARY_DEBUG)
      set(Boost_${basename}_LIBRARY_DEBUG ${Boost_${basename}_LIBRARY_RELEASE})
      set(Boost_${basename}_LIBRARY       ${Boost_${basename}_LIBRARY_RELEASE})
      set(Boost_${basename}_LIBRARIES     ${Boost_${basename}_LIBRARY_RELEASE})
    endif()
725

726
    # if only the debug version was found, set the release variable also to the debug version
727
728
729
730
731
    if(Boost_${basename}_LIBRARY_DEBUG AND NOT Boost_${basename}_LIBRARY_RELEASE)
      set(Boost_${basename}_LIBRARY_RELEASE ${Boost_${basename}_LIBRARY_DEBUG})
      set(Boost_${basename}_LIBRARY         ${Boost_${basename}_LIBRARY_DEBUG})
      set(Boost_${basename}_LIBRARIES       ${Boost_${basename}_LIBRARY_DEBUG})
    endif()
Philip Lowman's avatar
Philip Lowman committed
732
733

    # If the debug & release library ends up being the same, omit the keywords
734
    if("${Boost_${basename}_LIBRARY_RELEASE}" STREQUAL "${Boost_${basename}_LIBRARY_DEBUG}")
Philip Lowman's avatar
Philip Lowman committed
735
736
737
      set(Boost_${basename}_LIBRARY   ${Boost_${basename}_LIBRARY_RELEASE} )
      set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE} )
    endif()
738

739
    if(Boost_${basename}_LIBRARY AND Boost_${basename}_HEADER)
740
      set(Boost_${basename}_FOUND ON)
741
742
743
744
      if("x${basename}" STREQUAL "xTHREAD" AND NOT TARGET Threads::Threads)
        string(APPEND Boost_ERROR_REASON_THREAD " (missing dependency: Threads)")
        set(Boost_THREAD_FOUND OFF)
      endif()
745
    endif()
746

747
  endif()
748
  # Make variables changeable to the advanced user
749
  mark_as_advanced(
750
751
752
      Boost_${basename}_LIBRARY_RELEASE
      Boost_${basename}_LIBRARY_DEBUG
  )
753
endmacro()
754

755
756
757
758
759
760
761
762
# Detect changes in used variables.
# Compares the current variable value with the last one.
# In short form:
# v != v_LAST                      -> CHANGED = 1
# v is defined, v_LAST not         -> CHANGED = 1
# v is not defined, but v_LAST is  -> CHANGED = 1
# otherwise                        -> CHANGED = 0
# CHANGED is returned in variable named ${changed_var}
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
macro(_Boost_CHANGE_DETECT changed_var)
  set(${changed_var} 0)
  foreach(v ${ARGN})
    if(DEFINED _Boost_COMPONENTS_SEARCHED)
      if(${v})
        if(_${v}_LAST)
          string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED)
        else()
          set(_${v}_CHANGED 1)
        endif()
      elseif(_${v}_LAST)
        set(_${v}_CHANGED 1)
      endif()
      if(_${v}_CHANGED)
        set(${changed_var} 1)
      endif()
    else()
      set(_${v}_CHANGED 0)
    endif()
  endforeach()
endmacro()

785
786
787
788
789
790
#
# Find the given library (var).
# Use 'build_type' to support different lib paths for RELEASE or DEBUG builds
#
macro(_Boost_FIND_LIBRARY var build_type)

791
792
  find_library(${var} ${ARGN})

793
  if(${var})
794
795
    # If this is the first library found then save Boost_LIBRARY_DIR_[RELEASE,DEBUG].
    if(NOT Boost_LIBRARY_DIR_${build_type})
796
      get_filename_component(_dir "${${var}}" PATH)
797
      set(Boost_LIBRARY_DIR_${build_type} "${_dir}" CACHE PATH "Boost library directory ${build_type}" FORCE)
798
799
    endif()
  elseif(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT)
800
    # Try component-specific hints but do not save Boost_LIBRARY_DIR_[RELEASE,DEBUG].
801
    find_library(${var} HINTS ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT} ${ARGN})
802
803
  endif()

804
805
806
  # If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is known then search only there.
  if(Boost_LIBRARY_DIR_${build_type})
    set(_boost_LIBRARY_SEARCH_DIRS_${build_type} ${Boost_LIBRARY_DIR_${build_type}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
807
808
809
810
    _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
                           "Boost_LIBRARY_DIR_${build_type}")
    _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
                           "_boost_LIBRARY_SEARCH_DIRS_${build_type}")
811
812
813
  endif()
endmacro()

814
815
#-------------------------------------------------------------------------------

816
# Convert CMAKE_CXX_COMPILER_VERSION to boost compiler suffix version.
817
818
function(_Boost_COMPILER_DUMPVERSION _OUTPUT_VERSION _OUTPUT_VERSION_MAJOR _OUTPUT_VERSION_MINOR)
  string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\1"
819
    _boost_COMPILER_VERSION_MAJOR "${CMAKE_CXX_COMPILER_VERSION}")
820
  string(REGEX REPLACE "([0-9]+)\\.([0-9]+)(\\.[0-9]+)?" "\\2"
821
    _boost_COMPILER_VERSION_MINOR "${CMAKE_CXX_COMPILER_VERSION}")
822
823

  set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}${_boost_COMPILER_VERSION_MINOR}")
824

825
  set(${_OUTPUT_VERSION} ${_boost_COMPILER_VERSION} PARENT_SCOPE)
826
827
  set(${_OUTPUT_VERSION_MAJOR} ${_boost_COMPILER_VERSION_MAJOR} PARENT_SCOPE)
  set(${_OUTPUT_VERSION_MINOR} ${_boost_COMPILER_VERSION_MINOR} PARENT_SCOPE)
828
endfunction()
829

Philip Lowman's avatar
Philip Lowman committed
830
831
832
833
834
835
836
#
# Take a list of libraries with "thread" in it
# and prepend duplicates with "thread_${Boost_THREADAPI}"
# at the front of the list
#
function(_Boost_PREPEND_LIST_WITH_THREADAPI _output)
  set(_orig_libnames ${ARGN})
837
  string(REPLACE "thread" "thread_${Boost_THREADAPI}" _threadapi_libnames "${_orig_libnames}")
Philip Lowman's avatar
Philip Lowman committed
838
839
840
  set(${_output} ${_threadapi_libnames} ${_orig_libnames} PARENT_SCOPE)
endfunction()

841
842
843
844
845
846
847
848
849
850
851
#
# If a library is found, replace its cache entry with its REALPATH
#
function(_Boost_SWAP_WITH_REALPATH _library _docstring)
  if(${_library})
    get_filename_component(_boost_filepathreal ${${_library}} REALPATH)
    unset(${_library} CACHE)
    set(${_library} ${_boost_filepathreal} CACHE FILEPATH "${_docstring}")
  endif()
endfunction()

852
853
854
855
856
857
858
function(_Boost_CHECK_SPELLING _var)
  if(${_var})
    string(TOUPPER ${_var} _var_UC)
    message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling.  The proper spelling is ${_var_UC}.")
  endif()
endfunction()

859
860
861
# Guesses Boost's compiler prefix used in built library names
# Returns the guess by setting the variable pointed to by _ret
function(_Boost_GUESS_COMPILER_PREFIX _ret)
862
863
  if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel"
      OR "x${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "xIntelLLVM")
864
865
866
867
868
    if(WIN32)
      set (_boost_COMPILER "-iw")
    else()
      set (_boost_COMPILER "-il")
    endif()
869
870
  elseif (GHSMULTI)
    set(_boost_COMPILER "-ghs")
871
  elseif("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
872
873
874
875
876
877
878
879
880
881
882
    if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150)
      # Not yet known.
      set(_boost_COMPILER "")
    elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140)
      # MSVC toolset 14.x versions are forward compatible.
      set(_boost_COMPILER "")
      foreach(v 9 8 7 6 5 4 3 2 1 0)
        if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v})
          list(APPEND _boost_COMPILER "-vc14${v}")
        endif()
      endforeach()
883
884
    elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
      set(_boost_COMPILER "-vc${MSVC_TOOLSET_VERSION}")
885
886
887
888
    elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.10)
      set(_boost_COMPILER "-vc71")
    elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13) # Good luck!
      set(_boost_COMPILER "-vc7") # yes, this is correct
889
    else() # VS 6.0 Good luck!
890
891
      set(_boost_COMPILER "-vc6") # yes, this is correct
    endif()
892
893
894
895
896
897

    if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
      string(REPLACE "." ";" VERSION_LIST "${CMAKE_CXX_COMPILER_VERSION}")
      list(GET VERSION_LIST 0 CLANG_VERSION_MAJOR)
      set(_boost_COMPILER "-clangw${CLANG_VERSION_MAJOR};${_boost_COMPILER}")
    endif()
898
899
  elseif (BORLAND)
    set(_boost_COMPILER "-bcb")
900
  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
901
    set(_boost_COMPILER "-sw")
902
903
  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "XL")
    set(_boost_COMPILER "-xlc")
904
  elseif (MINGW)
905
    if(Boost_VERSION_STRING VERSION_LESS 1.34)
906
907
        set(_boost_COMPILER "-mgw") # no GCC version encoding prior to 1.34
    else()
908
      _Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR)
909
910
911
912
913
      if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.73 AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER_EQUAL 5)
        set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION_MAJOR}")
      else()
        set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}")
      endif()
914
915
    endif()
  elseif (UNIX)
916
    _Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR)
917
    if(NOT Boost_VERSION_STRING VERSION_LESS 1.69.0)
918
919
      # From GCC 5 and clang 4, versioning changes and minor becomes patch.
      # For those compilers, patch is exclude from compiler tag in Boost 1.69+ library naming.
920
      if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 4) OR CMAKE_CXX_COMPILER_ID STREQUAL "LCC")
921
922
923
924
925
926
        set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
      elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 3)
        set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
      endif()
    endif()

927
    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "LCC")
928
      if(Boost_VERSION_STRING VERSION_LESS 1.34)
929
930
931
932
        set(_boost_COMPILER "-gcc") # no GCC version encoding prior to 1.34
      else()
        # Determine which version of GCC we have.
        if(APPLE)
933
934
935
          if(Boost_VERSION_STRING VERSION_LESS 1.36.0)
            # In Boost <= 1.35.0, there is no mangled compiler name for
            # the macOS/Darwin version of GCC.
936
            set(_boost_COMPILER "")
937
938
939
940
          else()
            # In Boost 1.36.0 and newer, the mangled compiler name used
            # on macOS/Darwin is "xgcc".
            set(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}")
941
          endif()
942
943
944
945
        else()
          set(_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}")
        endif()
      endif()
946
947
948
949
    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
      # TODO: Find out any Boost version constraints vs clang support.
      set(_boost_COMPILER "-clang${_boost_COMPILER_VERSION}")
    endif()
950
951
952
  else()
    set(_boost_COMPILER "")
  endif()
953
954
  _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
                         "_boost_COMPILER" SOURCE "guessed")
955
956
957
  set(${_ret} ${_boost_COMPILER} PARENT_SCOPE)
endfunction()

958
959
960
961
962
963
964
965
966
967
968
969
970
971
#
# Get component dependencies.  Requires the dependencies to have been
# defined for the Boost release version.
#
# component - the component to check
# _ret - list of library dependencies
#
function(_Boost_COMPONENT_DEPENDENCIES component _ret)
  # Note: to add a new Boost release, run
  #
  #   % cmake -DBOOST_DIR=/path/to/boost/source -P Utilities/Scripts/BoostScanDeps.cmake
  #
  # The output may be added in a new block below.  If it's the same as
  # the previous release, simply update the version range of the block
972
973
974
  # for the previous release.  Also check if any new components have
  # been added, and add any new components to
  # _Boost_COMPONENT_HEADERS.
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
  #
  # This information was originally generated by running
  # BoostScanDeps.cmake against every boost release to date supported
  # by FindBoost:
  #
  #   % for version in /path/to/boost/sources/*
  #     do
  #       cmake -DBOOST_DIR=$version -P Utilities/Scripts/BoostScanDeps.cmake
  #     done
  #
  # The output was then updated by search and replace with these regexes:
  #
  # - Strip message(STATUS) prefix dashes
  #   s;^-- ;;
  # - Indent
  #   s;^set(;    set(;;
  # - Add conditionals
992
  #   s;Scanning /path/to/boost/sources/boost_\(.*\)_\(.*\)_\(.*);  elseif(NOT Boost_VERSION_STRING VERSION_LESS \1\.\2\.\3 AND Boost_VERSION_STRING VERSION_LESS xxxx);
993
994
995
996
  #
  # This results in the logic seen below, but will require the xxxx
  # replacing with the following Boost release version (or the next
  # minor version to be released, e.g. 1.59 was the latest at the time
997
998
999
  # of writing, making 1.60 the next. Identical consecutive releases
  # were then merged together by updating the end range of the first
  # block and removing the following redundant blocks.
1000
  #
For faster browsing, not all history is shown. View entire blame