ceph/cmake/modules/FindBoost.cmake

   1 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2 # file Copyright.txt or https://cmake.org/licensing for details.
   3
   4 #[=======================================================================[.rst:
   5 FindBoost
   6 ---------
   7
   8 Find Boost include dirs and libraries
   9
  10 Use this module by invoking :command:`find_package` with the form:
  11
  12 .. code-block:: cmake
  13
  14   find_package(Boost
  15     [version] [EXACT]      # Minimum or EXACT version e.g. 1.67.0
  16     [REQUIRED]             # Fail with error if Boost is not found
  17     [COMPONENTS <libs>...] # Boost libraries by their canonical name
  18                            # e.g. "date_time" for "libboost_date_time"
  19     [OPTIONAL_COMPONENTS <libs>...]
  20                            # Optional Boost libraries by their canonical name)
  21     )                      # e.g. "date_time" for "libboost_date_time"
  22
  23 This module finds headers and requested component libraries OR a CMake
  24 package configuration file provided by a "Boost CMake" build.  For the
  25 latter case skip to the :ref:`Boost CMake` section below.
  26
  27 .. versionadded:: 3.7
  28   ``bzip2`` and ``zlib`` components (Windows only).
  29
  30 .. versionadded:: 3.11
  31   The ``OPTIONAL_COMPONENTS`` option.
  32
  33 .. versionadded:: 3.13
  34   ``stacktrace_*`` components.
  35
  36 .. versionadded:: 3.19
  37   ``bzip2`` and ``zlib`` components on all platforms.
  38
  39 Result Variables
  40 ^^^^^^^^^^^^^^^^
  41
  42 This module defines the following variables:
  43
  44 ``Boost_FOUND``
  45   True if headers and requested libraries were found.
  46
  47 ``Boost_INCLUDE_DIRS``
  48   Boost include directories.
  49
  50 ``Boost_LIBRARY_DIRS``
  51   Link directories for Boost libraries.
  52
  53 ``Boost_LIBRARIES``
  54   Boost component libraries to be linked.
  55
  56 ``Boost_<COMPONENT>_FOUND``
  57   True if component ``<COMPONENT>`` was found (``<COMPONENT>`` name is upper-case).
  58
  59 ``Boost_<COMPONENT>_LIBRARY``
  60   Libraries to link for component ``<COMPONENT>`` (may include
  61   :command:`target_link_libraries` debug/optimized keywords).
  62
  63 ``Boost_VERSION_MACRO``
  64   ``BOOST_VERSION`` value from ``boost/version.hpp``.
  65
  66 ``Boost_VERSION_STRING``
  67   Boost version number in ``X.Y.Z`` format.
  68
  69 ``Boost_VERSION``
  70   Boost version number in ``X.Y.Z`` format (same as ``Boost_VERSION_STRING``).
  71
  72   .. versionchanged:: 3.15
  73     In previous CMake versions, this variable used the raw version string
  74     from the Boost header (same as ``Boost_VERSION_MACRO``).
  75     See policy :policy:`CMP0093`.
  76
  77 ``Boost_LIB_VERSION``
  78   Version string appended to library filenames.
  79
  80 ``Boost_VERSION_MAJOR``, ``Boost_MAJOR_VERSION``
  81   Boost major version number (``X`` in ``X.Y.Z``).
  82
  83 ``Boost_VERSION_MINOR``, ``Boost_MINOR_VERSION``
  84   Boost minor version number (``Y`` in ``X.Y.Z``).
  85
  86 ``Boost_VERSION_PATCH``, ``Boost_SUBMINOR_VERSION``
  87   Boost subminor version number (``Z`` in ``X.Y.Z``).
  88
  89 ``Boost_VERSION_COUNT``
  90   Amount of version components (3).
  91
  92 ``Boost_LIB_DIAGNOSTIC_DEFINITIONS`` (Windows-specific)
  93   Pass to :command:`add_definitions` to have diagnostic
  94   information about Boost's automatic linking
  95   displayed during compilation
  96
  97 .. versionadded:: 3.15
  98   The ``Boost_VERSION_<PART>`` variables.
  99
 100 Cache variables
 101 ^^^^^^^^^^^^^^^
 102
 103 Search results are saved persistently in CMake cache entries:
 104
 105 ``Boost_INCLUDE_DIR``
 106   Directory containing Boost headers.
 107
 108 ``Boost_LIBRARY_DIR_RELEASE``
 109   Directory containing release Boost libraries.
 110
 111 ``Boost_LIBRARY_DIR_DEBUG``
 112   Directory containing debug Boost libraries.
 113
 114 ``Boost_<COMPONENT>_LIBRARY_DEBUG``
 115   Component ``<COMPONENT>`` library debug variant.
 116
 117 ``Boost_<COMPONENT>_LIBRARY_RELEASE``
 118   Component ``<COMPONENT>`` library release variant.
 119
 120 .. versionadded:: 3.3
 121   Per-configuration variables ``Boost_LIBRARY_DIR_RELEASE`` and
 122   ``Boost_LIBRARY_DIR_DEBUG``.
 123
 124 Hints
 125 ^^^^^
 126
 127 This module reads hints about search locations from variables:
 128
 129 ``BOOST_ROOT``, ``BOOSTROOT``
 130   Preferred installation prefix.
 131
 132 ``BOOST_INCLUDEDIR``
 133   Preferred include directory e.g. ``<prefix>/include``.
 134
 135 ``BOOST_LIBRARYDIR``
 136   Preferred library directory e.g. ``<prefix>/lib``.
 137
 138 ``Boost_NO_SYSTEM_PATHS``
 139   Set to ``ON`` to disable searching in locations not
 140   specified by these hint variables. Default is ``OFF``.
 141
 142 ``Boost_ADDITIONAL_VERSIONS``
 143   List of Boost versions not known to this module.
 144   (Boost install locations may contain the version).
 145
 146 Users may set these hints or results as ``CACHE`` entries.  Projects
 147 should not read these entries directly but instead use the above
 148 result variables.  Note that some hint names start in upper-case
 149 ``BOOST``.  One may specify these as environment variables if they are
 150 not specified as CMake variables or cache entries.
 151
 152 This module first searches for the Boost header files using the above
 153 hint variables (excluding ``BOOST_LIBRARYDIR``) and saves the result in
 154 ``Boost_INCLUDE_DIR``.  Then it searches for requested component libraries
 155 using the above hints (excluding ``BOOST_INCLUDEDIR`` and
 156 ``Boost_ADDITIONAL_VERSIONS``), "lib" directories near ``Boost_INCLUDE_DIR``,
 157 and the library name configuration settings below.  It saves the
 158 library directories in ``Boost_LIBRARY_DIR_DEBUG`` and
 159 ``Boost_LIBRARY_DIR_RELEASE`` and individual library
 160 locations in ``Boost_<COMPONENT>_LIBRARY_DEBUG`` and ``Boost_<COMPONENT>_LIBRARY_RELEASE``.
 161 When one changes settings used by previous searches in the same build
 162 tree (excluding environment variables) this module discards previous
 163 search results affected by the changes and searches again.
 164
 165 Imported Targets
 166 ^^^^^^^^^^^^^^^^
 167
 168 .. versionadded:: 3.5
 169
 170 This module defines the following :prop_tgt:`IMPORTED` targets:
 171
 172 ``Boost::boost``
 173   Target for header-only dependencies. (Boost include directory).
 174
 175 ``Boost::headers``
 176   .. versionadded:: 3.15
 177     Alias for ``Boost::boost``.
 178
 179 ``Boost::<component>``
 180   Target for specific component dependency (shared or static library);
 181   ``<component>`` name is lower-case.
 182
 183 ``Boost::diagnostic_definitions``
 184   Interface target to enable diagnostic information about Boost's automatic
 185   linking during compilation (adds ``-DBOOST_LIB_DIAGNOSTIC``).
 186
 187 ``Boost::disable_autolinking``
 188   Interface target to disable automatic linking with MSVC
 189   (adds ``-DBOOST_ALL_NO_LIB``).
 190
 191 ``Boost::dynamic_linking``
 192   Interface target to enable dynamic linking with MSVC
 193   (adds ``-DBOOST_ALL_DYN_LINK``).
 194
 195 Implicit dependencies such as ``Boost::filesystem`` requiring
 196 ``Boost::system`` will be automatically detected and satisfied, even
 197 if system is not specified when using :command:`find_package` and if
 198 ``Boost::system`` is not added to :command:`target_link_libraries`.  If using
 199 ``Boost::thread``, then ``Threads::Threads`` will also be added automatically.
 200
 201 It is important to note that the imported targets behave differently
 202 than variables created by this module: multiple calls to
 203 :command:`find_package(Boost)` in the same directory or sub-directories with
 204 different options (e.g. static or shared) will not override the
 205 values of the targets created by the first call.
 206
 207 Other Variables
 208 ^^^^^^^^^^^^^^^
 209
 210 Boost libraries come in many variants encoded in their file name.
 211 Users or projects may tell this module which variant to find by
 212 setting variables:
 213
 214 ``Boost_USE_DEBUG_LIBS``
 215   .. versionadded:: 3.10
 216
 217   Set to ``ON`` or ``OFF`` to specify whether to search and use the debug
 218   libraries.  Default is ``ON``.
 219
 220 ``Boost_USE_RELEASE_LIBS``
 221   .. versionadded:: 3.10
 222
 223   Set to ``ON`` or ``OFF`` to specify whether to search and use the release
 224   libraries.  Default is ``ON``.
 225
 226 ``Boost_USE_MULTITHREADED``
 227   Set to OFF to use the non-multithreaded libraries ("mt" tag). Default is
 228   ``ON``.
 229
 230 ``Boost_USE_STATIC_LIBS``
 231   Set to ON to force the use of the static libraries.  Default is ``OFF``.
 232
 233 ``Boost_USE_STATIC_RUNTIME``
 234   Set to ``ON`` or ``OFF`` to specify whether to use libraries linked
 235   statically to the C++ runtime ("s" tag).  Default is platform dependent.
 236
 237 ``Boost_USE_DEBUG_RUNTIME``
 238   Set to ``ON`` or ``OFF`` to specify whether to use libraries linked to the
 239   MS debug C++ runtime ("g" tag).  Default is ``ON``.
 240
 241 ``Boost_USE_DEBUG_PYTHON``
 242   Set to ``ON`` to use libraries compiled with a debug Python build ("y"
 243   tag).  Default is ``OFF``.
 244
 245 ``Boost_USE_STLPORT``
 246   Set to ``ON`` to use libraries compiled with STLPort ("p" tag). Default is
 247   ``OFF``.
 248
 249 ``Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS``
 250   Set to ON to use libraries compiled with STLPort deprecated "native
 251   iostreams" ("n" tag).  Default is ``OFF``.
 252
 253 ``Boost_COMPILER``
 254   Set to the compiler-specific library suffix (e.g. ``-gcc43``).  Default is
 255   auto-computed for the C++ compiler in use.
 256
 257   .. versionchanged:: 3.9
 258     A list may be used if multiple compatible suffixes should be tested for,
 259     in decreasing order of preference.
 260
 261 ``Boost_LIB_PREFIX``
 262   .. versionadded:: 3.18
 263
 264   Set to the platform-specific library name prefix (e.g. ``lib``) used by
 265   Boost static libs.  This is needed only on platforms where CMake does not
 266   know the prefix by default.
 267
 268 ``Boost_ARCHITECTURE``
 269   .. versionadded:: 3.13
 270
 271   Set to the architecture-specific library suffix (e.g. ``-x64``).
 272   Default is auto-computed for the C++ compiler in use.
 273
 274 ``Boost_THREADAPI``
 275   Suffix for ``thread`` component library name, such as ``pthread`` or
 276   ``win32``.  Names with and without this suffix will both be tried.
 277
 278 ``Boost_NAMESPACE``
 279   Alternate namespace used to build boost with e.g. if set to ``myboost``,
 280   will search for ``myboost_thread`` instead of ``boost_thread``.
 281
 282 Other variables one may set to control this module are:
 283
 284 ``Boost_DEBUG``
 285   Set to ``ON`` to enable debug output from ``FindBoost``.
 286   Please enable this before filing any bug report.
 287
 288 ``Boost_REALPATH``
 289   Set to ``ON`` to resolve symlinks for discovered libraries to assist with
 290   packaging.  For example, the "system" component library may be resolved to
 291   ``/usr/lib/libboost_system.so.1.67.0`` instead of
 292   ``/usr/lib/libboost_system.so``.  This does not affect linking and should
 293   not be enabled unless the user needs this information.
 294
 295 ``Boost_LIBRARY_DIR``
 296   Default value for ``Boost_LIBRARY_DIR_RELEASE`` and
 297   ``Boost_LIBRARY_DIR_DEBUG``.
 298
 299 ``Boost_NO_WARN_NEW_VERSIONS``
 300   .. versionadded:: 3.20
 301
 302   Set to ``ON`` to suppress the warning about unknown dependencies for new
 303   Boost versions.
 304
 305 On Visual Studio and Borland compilers Boost headers request automatic
 306 linking to corresponding libraries.  This requires matching libraries
 307 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 libraries with a few exceptions (such as ``Boost.Python``).  Use:
 311
 312 .. code-block:: cmake
 313
 314   add_definitions(${Boost_LIB_DIAGNOSTIC_DEFINITIONS})
 315
 316 to ask Boost to report information about automatic linking requests.
 317
 318 Examples
 319 ^^^^^^^^
 320
 321 Find Boost headers only:
 322
 323 .. code-block:: cmake
 324
 325   find_package(Boost 1.36.0)
 326   if(Boost_FOUND)
 327     include_directories(${Boost_INCLUDE_DIRS})
 328     add_executable(foo foo.cc)
 329   endif()
 330
 331 Find Boost libraries and use imported targets:
 332
 333 .. code-block:: cmake
 334
 335   find_package(Boost 1.56 REQUIRED COMPONENTS
 336                date_time filesystem iostreams)
 337   add_executable(foo foo.cc)
 338   target_link_libraries(foo Boost::date_time Boost::filesystem
 339                             Boost::iostreams)
 340
 341 Find Boost Python 3.6 libraries and use imported targets:
 342
 343 .. code-block:: cmake
 344
 345   find_package(Boost 1.67 REQUIRED COMPONENTS
 346                python36 numpy36)
 347   add_executable(foo foo.cc)
 348   target_link_libraries(foo Boost::python36 Boost::numpy36)
 349
 350 Find Boost headers and some *static* (release only) libraries:
 351
 352 .. 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   set(Boost_USE_RELEASE_LIBS       ON)  # only find release libs
 357   set(Boost_USE_MULTITHREADED      ON)
 358   set(Boost_USE_STATIC_RUNTIME    OFF)
 359   find_package(Boost 1.66.0 COMPONENTS date_time filesystem system ...)
 360   if(Boost_FOUND)
 361     include_directories(${Boost_INCLUDE_DIRS})
 362     add_executable(foo foo.cc)
 363     target_link_libraries(foo ${Boost_LIBRARIES})
 364   endif()
 365
 366 .. _`Boost CMake`:
 367
 368 Boost CMake
 369 ^^^^^^^^^^^
 370
 371 If Boost was built using the boost-cmake project or from Boost 1.70.0 on
 372 it provides a package configuration file for use with find_package's config mode.
 373 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 and this module returns with no further action.  See documentation of
 377 the Boost CMake package configuration for details on what it provides.
 378
 379 Set ``Boost_NO_BOOST_CMAKE`` to ``ON``, to disable the search for boost-cmake.
 380 #]=======================================================================]
 381
 382 # The FPHSA helper provides standard way of reporting final search results to
 383 # the user including the version and component checks.
 384 include(FindPackageHandleStandardArgs)
 385
 386 # Save project's policies
 387 cmake_policy(PUSH)
 388 cmake_policy(SET CMP0057 NEW) # if IN_LIST
 389 if(POLICY CMP0102)
 390   cmake_policy(SET CMP0102 NEW) # if mark_as_advanced(non_cache_var)
 391 endif()
 392
 393 function(_boost_get_existing_target component target_var)
 394   set(names "${component}")
 395   if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9]+)?$")
 396     # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
 397     list(APPEND names
 398       "${CMAKE_MATCH_1}${CMAKE_MATCH_2}" # python
 399       "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}" # pythonX
 400       "${CMAKE_MATCH_1}${CMAKE_MATCH_2}${CMAKE_MATCH_3}${CMAKE_MATCH_4}" #pythonXY
 401     )
 402   endif()
 403   # https://github.com/boost-cmake/boost-cmake uses boost::file_system etc.
 404   # So handle similar constructions of target names
 405   string(TOLOWER "${component}" lower_component)
 406   list(APPEND names "${lower_component}")
 407   foreach(prefix Boost boost)
 408     foreach(name IN LISTS names)
 409       if(TARGET "${prefix}::${name}")
 410         # The target may be an INTERFACE library that wraps around a single other
 411         # target for compatibility.  Unwrap this layer so we can extract real info.
 412         if("${name}" MATCHES "^(python|numpy|mpi_python)([1-9])([0-9]+)$")
 413           set(name_nv "${CMAKE_MATCH_1}")
 414           if(TARGET "${prefix}::${name_nv}")
 415             get_property(type TARGET "${prefix}::${name}" PROPERTY TYPE)
 416             if(type STREQUAL "INTERFACE_LIBRARY")
 417               get_property(lib TARGET "${prefix}::${name}" PROPERTY INTERFACE_LINK_LIBRARIES)
 418               if("${lib}" STREQUAL "${prefix}::${name_nv}")
 419                 set(${target_var} "${prefix}::${name_nv}" PARENT_SCOPE)
 420                 return()
 421               endif()
 422             endif()
 423           endif()
 424         endif()
 425         set(${target_var} "${prefix}::${name}" PARENT_SCOPE)
 426         return()
 427       endif()
 428     endforeach()
 429   endforeach()
 430   set(${target_var} "" PARENT_SCOPE)
 431 endfunction()
 432
 433 function(_boost_get_canonical_target_name component target_var)
 434   string(TOLOWER "${component}" component)
 435   if(component MATCHES "^([a-z_]*)(python|numpy)([1-9])\\.?([0-9]+)?$")
 436     # handle pythonXY and numpyXY versioned components and also python X.Y, mpi_python etc.
 437     set(${target_var} "Boost::${CMAKE_MATCH_1}${CMAKE_MATCH_2}" PARENT_SCOPE)
 438   else()
 439     set(${target_var} "Boost::${component}" PARENT_SCOPE)
 440   endif()
 441 endfunction()
 442
 443 macro(_boost_set_in_parent_scope name value)
 444   # Set a variable in parent scope and make it visible in current scope
 445   set(${name} "${value}" PARENT_SCOPE)
 446   set(${name} "${value}")
 447 endmacro()
 448
 449 macro(_boost_set_if_unset name value)
 450   if(NOT ${name})
 451     _boost_set_in_parent_scope(${name} "${value}")
 452   endif()
 453 endmacro()
 454
 455 macro(_boost_set_cache_if_unset name value)
 456   if(NOT ${name})
 457     set(${name} "${value}" CACHE STRING "" FORCE)
 458   endif()
 459 endmacro()
 460
 461 macro(_boost_append_include_dir target)
 462   get_target_property(inc "${target}" INTERFACE_INCLUDE_DIRECTORIES)
 463   if(inc)
 464     list(APPEND include_dirs "${inc}")
 465   endif()
 466 endmacro()
 467
 468 function(_boost_set_legacy_variables_from_config)
 469   # Set legacy variables for compatibility if not set
 470   set(include_dirs "")
 471   set(library_dirs "")
 472   set(libraries "")
 473   # Header targets Boost::headers or Boost::boost
 474   foreach(comp headers boost)
 475     _boost_get_existing_target(${comp} target)
 476     if(target)
 477       _boost_append_include_dir("${target}")
 478     endif()
 479   endforeach()
 480   # Library targets
 481   foreach(comp IN LISTS Boost_FIND_COMPONENTS)
 482     string(TOUPPER ${comp} uppercomp)
 483     # Overwrite if set
 484     _boost_set_in_parent_scope(Boost_${uppercomp}_FOUND "${Boost_${comp}_FOUND}")
 485     if(Boost_${comp}_FOUND)
 486       _boost_get_existing_target(${comp} target)
 487       if(NOT target)
 488         if(Boost_DEBUG OR Boost_VERBOSE)
 489           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.")
 490         endif()
 491         continue()
 492       endif()
 493       _boost_append_include_dir("${target}")
 494       _boost_set_if_unset(Boost_${uppercomp}_LIBRARY "${target}")
 495       _boost_set_if_unset(Boost_${uppercomp}_LIBRARIES "${target}") # Very old legacy variable
 496       list(APPEND libraries "${target}")
 497       get_property(type TARGET "${target}" PROPERTY TYPE)
 498       if(NOT type STREQUAL "INTERFACE_LIBRARY")
 499         foreach(cfg RELEASE DEBUG)
 500           get_target_property(lib ${target} IMPORTED_LOCATION_${cfg})
 501           if(lib)
 502             get_filename_component(lib_dir "${lib}" DIRECTORY)
 503             list(APPEND library_dirs ${lib_dir})
 504             _boost_set_cache_if_unset(Boost_${uppercomp}_LIBRARY_${cfg} "${lib}")
 505           endif()
 506         endforeach()
 507       elseif(Boost_DEBUG OR Boost_VERBOSE)
 508         # For projects using only the Boost::* targets this warning can be safely ignored.
 509         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.")
 510       endif()
 511       _boost_get_canonical_target_name("${comp}" canonical_target)
 512       if(NOT TARGET "${canonical_target}")
 513         add_library("${canonical_target}" INTERFACE IMPORTED)
 514         target_link_libraries("${canonical_target}" INTERFACE "${target}")
 515       endif()
 516     endif()
 517   endforeach()
 518   list(REMOVE_DUPLICATES include_dirs)
 519   list(REMOVE_DUPLICATES library_dirs)
 520   _boost_set_if_unset(Boost_INCLUDE_DIRS "${include_dirs}")
 521   _boost_set_if_unset(Boost_LIBRARY_DIRS "${library_dirs}")
 522   _boost_set_if_unset(Boost_LIBRARIES "${libraries}")
 523   _boost_set_if_unset(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}")
 524   find_path(Boost_INCLUDE_DIR
 525     NAMES boost/version.hpp boost/config.hpp
 526     HINTS ${Boost_INCLUDE_DIRS}
 527     NO_DEFAULT_PATH
 528   )
 529   if(NOT Boost_VERSION_MACRO OR NOT Boost_LIB_VERSION)
 530     set(version_file ${Boost_INCLUDE_DIR}/boost/version.hpp)
 531     if(EXISTS "${version_file}")
 532       file(STRINGS "${version_file}" contents REGEX "#define BOOST_(LIB_)?VERSION ")
 533       if(contents MATCHES "#define BOOST_VERSION ([0-9]+)")
 534         _boost_set_if_unset(Boost_VERSION_MACRO "${CMAKE_MATCH_1}")
 535       endif()
 536       if(contents MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"")
 537         _boost_set_if_unset(Boost_LIB_VERSION "${CMAKE_MATCH_1}")
 538       endif()
 539     endif()
 540   endif()
 541   _boost_set_if_unset(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR})
 542   _boost_set_if_unset(Boost_MINOR_VERSION ${Boost_VERSION_MINOR})
 543   _boost_set_if_unset(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH})
 544   if(WIN32)
 545     _boost_set_if_unset(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC")
 546   endif()
 547   if(NOT TARGET Boost::headers)
 548     add_library(Boost::headers INTERFACE IMPORTED)
 549     target_include_directories(Boost::headers INTERFACE ${Boost_INCLUDE_DIRS})
 550   endif()
 551   # Legacy targets w/o functionality as all handled by defined targets
 552   foreach(lib diagnostic_definitions disable_autolinking dynamic_linking)
 553     if(NOT TARGET Boost::${lib})
 554       add_library(Boost::${lib} INTERFACE IMPORTED)
 555     endif()
 556   endforeach()
 557   if(NOT TARGET Boost::boost)
 558     add_library(Boost::boost INTERFACE IMPORTED)
 559     target_link_libraries(Boost::boost INTERFACE Boost::headers)
 560   endif()
 561 endfunction()
 562
 563 #-------------------------------------------------------------------------------
 564 # Before we go searching, check whether a boost cmake package is available, unless
 565 # the user specifically asked NOT to search for one.
 566 #
 567 # If Boost_DIR is set, this behaves as any find_package call would. If not,
 568 # it looks at BOOST_ROOT and BOOSTROOT to find Boost.
 569 #
 570 if (NOT Boost_NO_BOOST_CMAKE)
 571   # If Boost_DIR is not set, look for BOOSTROOT and BOOST_ROOT as alternatives,
 572   # since these are more conventional for Boost.
 573   if ("$ENV{Boost_DIR}" STREQUAL "")
 574     if (NOT "$ENV{BOOST_ROOT}" STREQUAL "")
 575       set(ENV{Boost_DIR} $ENV{BOOST_ROOT})
 576     elseif (NOT "$ENV{BOOSTROOT}" STREQUAL "")
 577       set(ENV{Boost_DIR} $ENV{BOOSTROOT})
 578     endif()
 579   endif()
 580
 581   set(_boost_FIND_PACKAGE_ARGS "")
 582   if(Boost_NO_SYSTEM_PATHS)
 583     list(APPEND _boost_FIND_PACKAGE_ARGS NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH)
 584   endif()
 585
 586   # Do the same find_package call but look specifically for the CMake version.
 587   # Note that args are passed in the Boost_FIND_xxxxx variables, so there is no
 588   # need to delegate them to this find_package call.
 589   cmake_policy(PUSH)
 590   if(BOOST_ROOT AND NOT Boost_ROOT)
 591     # Honor BOOST_ROOT by setting Boost_ROOT with CMP0074 NEW behavior.
 592     if(POLICY CMP0074)
 593       cmake_policy(SET CMP0074 NEW)
 594     endif()
 595     set(Boost_ROOT "${BOOST_ROOT}")
 596     set(_Boost_ROOT_FOR_CONFIG 1)
 597   endif()
 598   find_package(Boost QUIET NO_MODULE ${_boost_FIND_PACKAGE_ARGS})
 599   cmake_policy(POP)
 600   if (DEFINED Boost_DIR)
 601     mark_as_advanced(Boost_DIR)
 602   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     # Convert component found variables to standard variables if required
 608     # Necessary for legacy boost-cmake and 1.70 builtin BoostConfig
 609     if(Boost_FIND_COMPONENTS)
 610       # Ignore the meta-component "ALL", introduced by Boost 1.73
 611       list(REMOVE_ITEM Boost_FIND_COMPONENTS "ALL")
 612
 613       foreach(_comp IN LISTS Boost_FIND_COMPONENTS)
 614         if(DEFINED Boost_${_comp}_FOUND)
 615           continue()
 616         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           set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND})
 622         endif()
 623       endforeach()
 624     endif()
 625
 626     find_package_handle_standard_args(Boost HANDLE_COMPONENTS CONFIG_MODE)
 627     _boost_set_legacy_variables_from_config()
 628
 629     # Restore project's policies
 630     cmake_policy(POP)
 631     return()
 632   endif()
 633 endif()
 634
 635
 636 #-------------------------------------------------------------------------------
 637 #  FindBoost functions & macros
 638 #
 639
 640 #
 641 # Print debug text if Boost_DEBUG is set.
 642 # Call example:
 643 # _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "debug message")
 644 #
 645 function(_Boost_DEBUG_PRINT file line text)
 646   if(Boost_DEBUG)
 647     message(STATUS "[ ${file}:${line} ] ${text}")
 648   endif()
 649 endfunction()
 650
 651 #
 652 # _Boost_DEBUG_PRINT_VAR(file line variable_name [ENVIRONMENT]
 653 #                        [SOURCE "short explanation of origin of var value"])
 654 #
 655 #   ENVIRONMENT - look up environment variable instead of CMake variable
 656 #
 657 # Print variable name and its value if Boost_DEBUG is set.
 658 # Call example:
 659 # _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" BOOST_ROOT)
 660 #
 661 function(_Boost_DEBUG_PRINT_VAR file line name)
 662   if(Boost_DEBUG)
 663     cmake_parse_arguments(_args "ENVIRONMENT" "SOURCE" "" ${ARGN})
 664
 665     unset(source)
 666     if(_args_SOURCE)
 667       set(source " (${_args_SOURCE})")
 668     endif()
 669
 670     if(_args_ENVIRONMENT)
 671       if(DEFINED ENV{${name}})
 672         set(value "\"$ENV{${name}}\"")
 673       else()
 674         set(value "<unset>")
 675       endif()
 676       set(_name "ENV{${name}}")
 677     else()
 678       if(DEFINED "${name}")
 679         set(value "\"${${name}}\"")
 680       else()
 681         set(value "<unset>")
 682       endif()
 683       set(_name "${name}")
 684     endif()
 685
 686     _Boost_DEBUG_PRINT("${file}" "${line}" "${_name} = ${value}${source}")
 687   endif()
 688 endfunction()
 689
 690 ############################################
 691 #
 692 # Check the existence of the libraries.
 693 #
 694 ############################################
 695 # This macro was taken directly from the FindQt4.cmake file that is included
 696 # with the CMake distribution. This is NOT my work. All work was done by the
 697 # original authors of the FindQt4.cmake file. Only minor modifications were
 698 # 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 macro(_Boost_ADJUST_LIB_VARS basename)
 703   if(Boost_INCLUDE_DIR )
 704     if(Boost_${basename}_LIBRARY_DEBUG AND Boost_${basename}_LIBRARY_RELEASE)
 705       # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for
 706       # single-config generators, set optimized and debug libraries
 707       get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 708       if(_isMultiConfig OR CMAKE_BUILD_TYPE)
 709         set(Boost_${basename}_LIBRARY optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
 710       else()
 711         # For single-config generators where CMAKE_BUILD_TYPE has no value,
 712         # just use the release libraries
 713         set(Boost_${basename}_LIBRARY ${Boost_${basename}_LIBRARY_RELEASE} )
 714       endif()
 715       # FIXME: This probably should be set for both cases
 716       set(Boost_${basename}_LIBRARIES optimized ${Boost_${basename}_LIBRARY_RELEASE} debug ${Boost_${basename}_LIBRARY_DEBUG})
 717     endif()
 718
 719     # if only the release version was found, set the debug variable also to the release version
 720     if(Boost_${basename}_LIBRARY_RELEASE AND NOT Boost_${basename}_LIBRARY_DEBUG)
 721       set(Boost_${basename}_LIBRARY_DEBUG ${Boost_${basename}_LIBRARY_RELEASE})
 722       set(Boost_${basename}_LIBRARY       ${Boost_${basename}_LIBRARY_RELEASE})
 723       set(Boost_${basename}_LIBRARIES     ${Boost_${basename}_LIBRARY_RELEASE})
 724     endif()
 725
 726     # if only the debug version was found, set the release variable also to the debug version
 727     if(Boost_${basename}_LIBRARY_DEBUG AND NOT Boost_${basename}_LIBRARY_RELEASE)
 728       set(Boost_${basename}_LIBRARY_RELEASE ${Boost_${basename}_LIBRARY_DEBUG})
 729       set(Boost_${basename}_LIBRARY         ${Boost_${basename}_LIBRARY_DEBUG})
 730       set(Boost_${basename}_LIBRARIES       ${Boost_${basename}_LIBRARY_DEBUG})
 731     endif()
 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}")
 735       set(Boost_${basename}_LIBRARY   ${Boost_${basename}_LIBRARY_RELEASE} )
 736       set(Boost_${basename}_LIBRARIES ${Boost_${basename}_LIBRARY_RELEASE} )
 737     endif()
 738
 739     if(Boost_${basename}_LIBRARY AND Boost_${basename}_HEADER)
 740       set(Boost_${basename}_FOUND ON)
 741       if("x${basename}" STREQUAL "xTHREAD" AND NOT TARGET Threads::Threads)
 742         string(APPEND Boost_ERROR_REASON_THREAD " (missing dependency: Threads)")
 743         set(Boost_THREAD_FOUND OFF)
 744       endif()
 745     endif()
 746
 747   endif()
 748   # Make variables changeable to the advanced user
 749   mark_as_advanced(
 750       Boost_${basename}_LIBRARY_RELEASE
 751       Boost_${basename}_LIBRARY_DEBUG
 752   )
 753 endmacro()
 754
 755 # Detect changes in used variables.
 756 # Compares the current variable value with the last one.
 757 # In short form:
 758 # v != v_LAST                      -> CHANGED = 1
 759 # v is defined, v_LAST not         -> CHANGED = 1
 760 # v is not defined, but v_LAST is  -> CHANGED = 1
 761 # otherwise                        -> CHANGED = 0
 762 # CHANGED is returned in variable named ${changed_var}
 763 macro(_Boost_CHANGE_DETECT changed_var)
 764   set(${changed_var} 0)
 765   foreach(v ${ARGN})
 766     if(DEFINED _Boost_COMPONENTS_SEARCHED)
 767       if(${v})
 768         if(_${v}_LAST)
 769           string(COMPARE NOTEQUAL "${${v}}" "${_${v}_LAST}" _${v}_CHANGED)
 770         else()
 771           set(_${v}_CHANGED 1)
 772         endif()
 773       elseif(_${v}_LAST)
 774         set(_${v}_CHANGED 1)
 775       endif()
 776       if(_${v}_CHANGED)
 777         set(${changed_var} 1)
 778       endif()
 779     else()
 780       set(_${v}_CHANGED 0)
 781     endif()
 782   endforeach()
 783 endmacro()
 784
 785 #
 786 # Find the given library (var).
 787 # Use 'build_type' to support different lib paths for RELEASE or DEBUG builds
 788 #
 789 macro(_Boost_FIND_LIBRARY var build_type)
 790
 791   find_library(${var} ${ARGN})
 792
 793   if(${var})
 794     # If this is the first library found then save Boost_LIBRARY_DIR_[RELEASE,DEBUG].
 795     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     endif()
 799   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   endif()
 803
 804   # If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is known then search only there.
 805   if(Boost_LIBRARY_DIR_${build_type})
 806     set(_boost_LIBRARY_SEARCH_DIRS_${build_type} ${Boost_LIBRARY_DIR_${build_type}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
 807     _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
 808                            "Boost_LIBRARY_DIR_${build_type}")
 809     _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
 810                            "_boost_LIBRARY_SEARCH_DIRS_${build_type}")
 811   endif()
 812 endmacro()
 813
 814 #-------------------------------------------------------------------------------
 815
 816 # Convert CMAKE_CXX_COMPILER_VERSION to boost compiler suffix version.
 817 function(_Boost_COMPILER_DUMPVERSION _OUTPUT_VERSION _OUTPUT_VERSION_MAJOR _OUTPUT_VERSION_MINOR)
 818   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   set(${_OUTPUT_VERSION_MAJOR} ${_boost_COMPILER_VERSION_MAJOR} PARENT_SCOPE)
 827   set(${_OUTPUT_VERSION_MINOR} ${_boost_COMPILER_VERSION_MINOR} PARENT_SCOPE)
 828 endfunction()
 829
 830 #
 831 # Take a list of libraries with "thread" in it
 832 # and prepend duplicates with "thread_${Boost_THREADAPI}"
 833 # at the front of the list
 834 #
 835 function(_Boost_PREPEND_LIST_WITH_THREADAPI _output)
 836   set(_orig_libnames ${ARGN})
 837   string(REPLACE "thread" "thread_${Boost_THREADAPI}" _threadapi_libnames "${_orig_libnames}")
 838   set(${_output} ${_threadapi_libnames} ${_orig_libnames} PARENT_SCOPE)
 839 endfunction()
 840
 841 #
 842 # If a library is found, replace its cache entry with its REALPATH
 843 #
 844 function(_Boost_SWAP_WITH_REALPATH _library _docstring)
 845   if(${_library})
 846     get_filename_component(_boost_filepathreal ${${_library}} REALPATH)
 847     unset(${_library} CACHE)
 848     set(${_library} ${_boost_filepathreal} CACHE FILEPATH "${_docstring}")
 849   endif()
 850 endfunction()
 851
 852 function(_Boost_CHECK_SPELLING _var)
 853   if(${_var})
 854     string(TOUPPER ${_var} _var_UC)
 855     message(FATAL_ERROR "ERROR: ${_var} is not the correct spelling.  The proper spelling is ${_var_UC}.")
 856   endif()
 857 endfunction()
 858
 859 # Guesses Boost's compiler prefix used in built library names
 860 # Returns the guess by setting the variable pointed to by _ret
 861 function(_Boost_GUESS_COMPILER_PREFIX _ret)
 862   if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel"
 863       OR "x${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "xIntelLLVM")
 864     if(WIN32)
 865       set (_boost_COMPILER "-iw")
 866     else()
 867       set (_boost_COMPILER "-il")
 868     endif()
 869   elseif (GHSMULTI)
 870     set(_boost_COMPILER "-ghs")
 871   elseif("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC" OR "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
 872     if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150)
 873       # Not yet known.
 874       set(_boost_COMPILER "")
 875     elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140)
 876       # MSVC toolset 14.x versions are forward compatible.
 877       set(_boost_COMPILER "")
 878       foreach(v 9 8 7 6 5 4 3 2 1 0)
 879         if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v})
 880           list(APPEND _boost_COMPILER "-vc14${v}")
 881         endif()
 882       endforeach()
 883     elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
 884       set(_boost_COMPILER "-vc${MSVC_TOOLSET_VERSION}")
 885     elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13.10)
 886       set(_boost_COMPILER "-vc71")
 887     elseif(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 13) # Good luck!
 888       set(_boost_COMPILER "-vc7") # yes, this is correct
 889     else() # VS 6.0 Good luck!
 890       set(_boost_COMPILER "-vc6") # yes, this is correct
 891     endif()
 892
 893     if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang")
 894       string(REPLACE "." ";" VERSION_LIST "${CMAKE_CXX_COMPILER_VERSION}")
 895       list(GET VERSION_LIST 0 CLANG_VERSION_MAJOR)
 896       set(_boost_COMPILER "-clangw${CLANG_VERSION_MAJOR};${_boost_COMPILER}")
 897     endif()
 898   elseif (BORLAND)
 899     set(_boost_COMPILER "-bcb")
 900   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "SunPro")
 901     set(_boost_COMPILER "-sw")
 902   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "XL")
 903     set(_boost_COMPILER "-xlc")
 904   elseif (MINGW)
 905     if(Boost_VERSION_STRING VERSION_LESS 1.34)
 906         set(_boost_COMPILER "-mgw") # no GCC version encoding prior to 1.34
 907     else()
 908       _Boost_COMPILER_DUMPVERSION(_boost_COMPILER_VERSION _boost_COMPILER_VERSION_MAJOR _boost_COMPILER_VERSION_MINOR)
 909       if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.73 AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER_EQUAL 5)
 910         set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION_MAJOR}")
 911       else()
 912         set(_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}")
 913       endif()
 914     endif()
 915   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       # From GCC 5 and clang 4, versioning changes and minor becomes patch.
 919       # 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         set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
 922       elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND _boost_COMPILER_VERSION_MAJOR VERSION_GREATER 3)
 923         set(_boost_COMPILER_VERSION "${_boost_COMPILER_VERSION_MAJOR}")
 924       endif()
 925     endif()
 926
 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         set(_boost_COMPILER "-gcc") # no GCC version encoding prior to 1.34
 930       else()
 931         # Determine which version of GCC we have.
 932         if(APPLE)
 933           if(Boost_VERSION_STRING VERSION_LESS 1.36.0)
 934             # In Boost <= 1.35.0, there is no mangled compiler name for
 935             # the macOS/Darwin version of GCC.
 936             set(_boost_COMPILER "")
 937           else()
 938             # In Boost 1.36.0 and newer, the mangled compiler name used
 939             # on macOS/Darwin is "xgcc".
 940             set(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}")
 941           endif()
 942         else()
 943           set(_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}")
 944         endif()
 945       endif()
 946     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
 947       # TODO: Find out any Boost version constraints vs clang support.
 948       set(_boost_COMPILER "-clang${_boost_COMPILER_VERSION}")
 949     endif()
 950   else()
 951     set(_boost_COMPILER "")
 952   endif()
 953   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
 954                          "_boost_COMPILER" SOURCE "guessed")
 955   set(${_ret} ${_boost_COMPILER} PARENT_SCOPE)
 956 endfunction()
 957
 958 #
 959 # Get component dependencies.  Requires the dependencies to have been
 960 # defined for the Boost release version.
 961 #
 962 # component - the component to check
 963 # _ret - list of library dependencies
 964 #
 965 function(_Boost_COMPONENT_DEPENDENCIES component _ret)
 966   # Note: to add a new Boost release, run
 967   #
 968   #   % cmake -DBOOST_DIR=/path/to/boost/source -P Utilities/Scripts/BoostScanDeps.cmake
 969   #
 970   # The output may be added in a new block below.  If it's the same as
 971   # the previous release, simply update the version range of the block
 972   # for the previous release.  Also check if any new components have
 973   # been added, and add any new components to
 974   # _Boost_COMPONENT_HEADERS.
 975   #
 976   # This information was originally generated by running
 977   # BoostScanDeps.cmake against every boost release to date supported
 978   # by FindBoost:
 979   #
 980   #   % for version in /path/to/boost/sources/*
 981   #     do
 982   #       cmake -DBOOST_DIR=$version -P Utilities/Scripts/BoostScanDeps.cmake
 983   #     done
 984   #
 985   # The output was then updated by search and replace with these regexes:
 986   #
 987   # - Strip message(STATUS) prefix dashes
 988   #   s;^-- ;;
 989   # - Indent
 990   #   s;^set(;    set(;;
 991   # - 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   # This results in the logic seen below, but will require the xxxx
 995   # replacing with the following Boost release version (or the next
 996   # minor version to be released, e.g. 1.59 was the latest at the time
 997   # of writing, making 1.60 the next. Identical consecutive releases
 998   # were then merged together by updating the end range of the first
 999   # block and removing the following redundant blocks.
1000   #
1001   # Running the script against all historical releases should be
1002   # required only if the BoostScanDeps.cmake script logic is changed.
1003   # The addition of a new release should only require it to be run
1004   # against the new release.
1005
1006   # Handle Python version suffixes
1007   if(component MATCHES "^(python|mpi_python|numpy)([0-9][0-9]?|[0-9]\\.[0-9]+)\$")
1008     set(component "${CMAKE_MATCH_1}")
1009     set(component_python_version "${CMAKE_MATCH_2}")
1010   endif()
1011
1012   set(_Boost_IMPORTED_TARGETS TRUE)
1013   if(Boost_VERSION_STRING)
1014     if(Boost_VERSION_STRING VERSION_LESS 1.33.0)
1015       message(WARNING "Imported targets and dependency information not available for Boost version ${Boost_VERSION_STRING} (all versions older than 1.33)")
1016       set(_Boost_IMPORTED_TARGETS FALSE)
1017     elseif(Boost_VERSION_STRING VERSION_LESS 1.35.0)
1018       set(_Boost_IOSTREAMS_DEPENDENCIES regex thread)
1019       set(_Boost_REGEX_DEPENDENCIES thread)
1020       set(_Boost_WAVE_DEPENDENCIES filesystem thread)
1021       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1022     elseif(Boost_VERSION_STRING VERSION_LESS 1.36.0)
1023       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1024       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1025       set(_Boost_MPI_DEPENDENCIES serialization)
1026       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1027       set(_Boost_WAVE_DEPENDENCIES filesystem system thread)
1028       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1029     elseif(Boost_VERSION_STRING VERSION_LESS 1.38.0)
1030       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1031       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1032       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
1033       set(_Boost_MPI_DEPENDENCIES serialization)
1034       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1035       set(_Boost_WAVE_DEPENDENCIES filesystem system thread)
1036       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1037     elseif(Boost_VERSION_STRING VERSION_LESS 1.43.0)
1038       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1039       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1040       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
1041       set(_Boost_MPI_DEPENDENCIES serialization)
1042       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1043       set(_Boost_THREAD_DEPENDENCIES date_time)
1044       set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time)
1045       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1046     elseif(Boost_VERSION_STRING VERSION_LESS 1.44.0)
1047       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1048       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1049       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
1050       set(_Boost_MPI_DEPENDENCIES serialization)
1051       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1052       set(_Boost_THREAD_DEPENDENCIES date_time)
1053       set(_Boost_WAVE_DEPENDENCIES filesystem system thread date_time)
1054       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1055     elseif(Boost_VERSION_STRING VERSION_LESS 1.45.0)
1056       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1057       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1058       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random serialization)
1059       set(_Boost_MPI_DEPENDENCIES serialization)
1060       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1061       set(_Boost_THREAD_DEPENDENCIES date_time)
1062       set(_Boost_WAVE_DEPENDENCIES serialization filesystem system thread date_time)
1063       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1064     elseif(Boost_VERSION_STRING VERSION_LESS 1.47.0)
1065       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1066       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1067       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
1068       set(_Boost_MPI_DEPENDENCIES serialization)
1069       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1070       set(_Boost_THREAD_DEPENDENCIES date_time)
1071       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
1072       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1073     elseif(Boost_VERSION_STRING VERSION_LESS 1.48.0)
1074       set(_Boost_CHRONO_DEPENDENCIES system)
1075       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1076       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1077       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
1078       set(_Boost_MPI_DEPENDENCIES serialization)
1079       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1080       set(_Boost_THREAD_DEPENDENCIES date_time)
1081       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
1082       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1083     elseif(Boost_VERSION_STRING VERSION_LESS 1.50.0)
1084       set(_Boost_CHRONO_DEPENDENCIES system)
1085       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1086       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1087       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l random)
1088       set(_Boost_MPI_DEPENDENCIES serialization)
1089       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1090       set(_Boost_THREAD_DEPENDENCIES date_time)
1091       set(_Boost_TIMER_DEPENDENCIES chrono system)
1092       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread date_time)
1093       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1094     elseif(Boost_VERSION_STRING VERSION_LESS 1.53.0)
1095       set(_Boost_CHRONO_DEPENDENCIES system)
1096       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1097       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1098       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
1099       set(_Boost_MPI_DEPENDENCIES serialization)
1100       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1101       set(_Boost_THREAD_DEPENDENCIES chrono system date_time)
1102       set(_Boost_TIMER_DEPENDENCIES chrono system)
1103       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time)
1104       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1105     elseif(Boost_VERSION_STRING VERSION_LESS 1.54.0)
1106       set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time)
1107       set(_Boost_CHRONO_DEPENDENCIES system)
1108       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1109       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1110       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
1111       set(_Boost_MPI_DEPENDENCIES serialization)
1112       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1113       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1114       set(_Boost_TIMER_DEPENDENCIES chrono system)
1115       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time)
1116       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1117     elseif(Boost_VERSION_STRING VERSION_LESS 1.55.0)
1118       set(_Boost_ATOMIC_DEPENDENCIES thread chrono system date_time)
1119       set(_Boost_CHRONO_DEPENDENCIES system)
1120       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1121       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1122       set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
1123       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
1124       set(_Boost_MPI_DEPENDENCIES serialization)
1125       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1126       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1127       set(_Boost_TIMER_DEPENDENCIES chrono system)
1128       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1129       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1130     elseif(Boost_VERSION_STRING VERSION_LESS 1.56.0)
1131       set(_Boost_CHRONO_DEPENDENCIES system)
1132       set(_Boost_COROUTINE_DEPENDENCIES context system)
1133       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1134       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1135       set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
1136       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l regex random)
1137       set(_Boost_MPI_DEPENDENCIES serialization)
1138       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1139       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1140       set(_Boost_TIMER_DEPENDENCIES chrono system)
1141       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1142       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1143     elseif(Boost_VERSION_STRING VERSION_LESS 1.59.0)
1144       set(_Boost_CHRONO_DEPENDENCIES system)
1145       set(_Boost_COROUTINE_DEPENDENCIES context system)
1146       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1147       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1148       set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono)
1149       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1150       set(_Boost_MPI_DEPENDENCIES serialization)
1151       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1152       set(_Boost_RANDOM_DEPENDENCIES system)
1153       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1154       set(_Boost_TIMER_DEPENDENCIES chrono system)
1155       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1156       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1157     elseif(Boost_VERSION_STRING VERSION_LESS 1.60.0)
1158       set(_Boost_CHRONO_DEPENDENCIES system)
1159       set(_Boost_COROUTINE_DEPENDENCIES context system)
1160       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1161       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1162       set(_Boost_LOG_DEPENDENCIES log_setup date_time system filesystem thread regex chrono atomic)
1163       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1164       set(_Boost_MPI_DEPENDENCIES serialization)
1165       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1166       set(_Boost_RANDOM_DEPENDENCIES system)
1167       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1168       set(_Boost_TIMER_DEPENDENCIES chrono system)
1169       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1170       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1171     elseif(Boost_VERSION_STRING VERSION_LESS 1.61.0)
1172       set(_Boost_CHRONO_DEPENDENCIES system)
1173       set(_Boost_COROUTINE_DEPENDENCIES context system)
1174       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1175       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1176       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1177       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1178       set(_Boost_MPI_DEPENDENCIES serialization)
1179       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1180       set(_Boost_RANDOM_DEPENDENCIES system)
1181       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1182       set(_Boost_TIMER_DEPENDENCIES chrono system)
1183       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1184       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1185     elseif(Boost_VERSION_STRING VERSION_LESS 1.62.0)
1186       set(_Boost_CHRONO_DEPENDENCIES system)
1187       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1188       set(_Boost_COROUTINE_DEPENDENCIES context system)
1189       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1190       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1191       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1192       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1193       set(_Boost_MPI_DEPENDENCIES serialization)
1194       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1195       set(_Boost_RANDOM_DEPENDENCIES system)
1196       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1197       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1198       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1199     elseif(Boost_VERSION_STRING VERSION_LESS 1.63.0)
1200       set(_Boost_CHRONO_DEPENDENCIES system)
1201       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1202       set(_Boost_COROUTINE_DEPENDENCIES context system)
1203       set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
1204       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1205       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1206       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1207       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1208       set(_Boost_MPI_DEPENDENCIES serialization)
1209       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1210       set(_Boost_RANDOM_DEPENDENCIES system)
1211       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1212       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1213       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1214     elseif(Boost_VERSION_STRING VERSION_LESS 1.65.0)
1215       set(_Boost_CHRONO_DEPENDENCIES system)
1216       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1217       set(_Boost_COROUTINE_DEPENDENCIES context system)
1218       set(_Boost_COROUTINE2_DEPENDENCIES context fiber thread chrono system date_time)
1219       set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
1220       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1221       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1222       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1223       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1224       set(_Boost_MPI_DEPENDENCIES serialization)
1225       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1226       set(_Boost_RANDOM_DEPENDENCIES system)
1227       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1228       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1229       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1230     elseif(Boost_VERSION_STRING VERSION_LESS 1.67.0)
1231       set(_Boost_CHRONO_DEPENDENCIES system)
1232       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1233       set(_Boost_COROUTINE_DEPENDENCIES context system)
1234       set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
1235       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1236       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1237       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1238       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1239       set(_Boost_MPI_DEPENDENCIES serialization)
1240       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1241       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1242       set(_Boost_RANDOM_DEPENDENCIES system)
1243       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1244       set(_Boost_TIMER_DEPENDENCIES chrono system)
1245       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1246       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1247     elseif(Boost_VERSION_STRING VERSION_LESS 1.68.0)
1248       set(_Boost_CHRONO_DEPENDENCIES system)
1249       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1250       set(_Boost_COROUTINE_DEPENDENCIES context system)
1251       set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
1252       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1253       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1254       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1255       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1256       set(_Boost_MPI_DEPENDENCIES serialization)
1257       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1258       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1259       set(_Boost_RANDOM_DEPENDENCIES system)
1260       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1261       set(_Boost_TIMER_DEPENDENCIES chrono system)
1262       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1263       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1264     elseif(Boost_VERSION_STRING VERSION_LESS 1.69.0)
1265       set(_Boost_CHRONO_DEPENDENCIES system)
1266       set(_Boost_CONTEXT_DEPENDENCIES thread chrono system date_time)
1267       set(_Boost_CONTRACT_DEPENDENCIES thread chrono system date_time)
1268       set(_Boost_COROUTINE_DEPENDENCIES context system)
1269       set(_Boost_FIBER_DEPENDENCIES context thread chrono system date_time)
1270       set(_Boost_FILESYSTEM_DEPENDENCIES system)
1271       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1272       set(_Boost_LOG_DEPENDENCIES date_time log_setup system filesystem thread regex chrono atomic)
1273       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1274       set(_Boost_MPI_DEPENDENCIES serialization)
1275       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1276       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1277       set(_Boost_RANDOM_DEPENDENCIES system)
1278       set(_Boost_THREAD_DEPENDENCIES chrono system date_time atomic)
1279       set(_Boost_TIMER_DEPENDENCIES chrono system)
1280       set(_Boost_WAVE_DEPENDENCIES filesystem system serialization thread chrono date_time atomic)
1281       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1282     elseif(Boost_VERSION_STRING VERSION_LESS 1.70.0)
1283       set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
1284       set(_Boost_COROUTINE_DEPENDENCIES context)
1285       set(_Boost_FIBER_DEPENDENCIES context)
1286       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1287       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1288       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1289       set(_Boost_MPI_DEPENDENCIES serialization)
1290       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1291       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1292       set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
1293       set(_Boost_TIMER_DEPENDENCIES chrono system)
1294       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
1295       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1296     elseif(Boost_VERSION_STRING VERSION_LESS 1.72.0)
1297       set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
1298       set(_Boost_COROUTINE_DEPENDENCIES context)
1299       set(_Boost_FIBER_DEPENDENCIES context)
1300       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1301       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1302       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1303       set(_Boost_MPI_DEPENDENCIES serialization)
1304       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1305       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1306       set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
1307       set(_Boost_TIMER_DEPENDENCIES chrono)
1308       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
1309       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1310     elseif(Boost_VERSION_STRING VERSION_LESS 1.73.0)
1311       set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
1312       set(_Boost_COROUTINE_DEPENDENCIES context)
1313       set(_Boost_FIBER_DEPENDENCIES context)
1314       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1315       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1316       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l chrono atomic)
1317       set(_Boost_MPI_DEPENDENCIES serialization)
1318       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1319       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1320       set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
1321       set(_Boost_TIMER_DEPENDENCIES chrono)
1322       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
1323       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1324     elseif(Boost_VERSION_STRING VERSION_LESS 1.75.0)
1325       set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
1326       set(_Boost_COROUTINE_DEPENDENCIES context)
1327       set(_Boost_FIBER_DEPENDENCIES context)
1328       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1329       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1330       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1331       set(_Boost_MPI_DEPENDENCIES serialization)
1332       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1333       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1334       set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
1335       set(_Boost_TIMER_DEPENDENCIES chrono)
1336       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
1337       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1338     elseif(Boost_VERSION_STRING VERSION_LESS 1.77.0)
1339       set(_Boost_CONTRACT_DEPENDENCIES thread chrono date_time)
1340       set(_Boost_COROUTINE_DEPENDENCIES context)
1341       set(_Boost_FIBER_DEPENDENCIES context)
1342       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1343       set(_Boost_JSON_DEPENDENCIES container)
1344       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1345       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l atomic)
1346       set(_Boost_MPI_DEPENDENCIES serialization)
1347       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1348       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1349       set(_Boost_THREAD_DEPENDENCIES chrono date_time atomic)
1350       set(_Boost_TIMER_DEPENDENCIES chrono)
1351       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono date_time atomic)
1352       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1353     elseif(Boost_VERSION_STRING VERSION_LESS 1.78.0)
1354       set(_Boost_CONTRACT_DEPENDENCIES thread chrono)
1355       set(_Boost_COROUTINE_DEPENDENCIES context)
1356       set(_Boost_FIBER_DEPENDENCIES context)
1357       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1358       set(_Boost_JSON_DEPENDENCIES container)
1359       set(_Boost_LOG_DEPENDENCIES date_time log_setup filesystem thread regex chrono atomic)
1360       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
1361       set(_Boost_MPI_DEPENDENCIES serialization)
1362       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1363       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1364       set(_Boost_THREAD_DEPENDENCIES chrono atomic)
1365       set(_Boost_TIMER_DEPENDENCIES chrono)
1366       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono atomic)
1367       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1368     else()
1369       set(_Boost_CONTRACT_DEPENDENCIES thread chrono)
1370       set(_Boost_COROUTINE_DEPENDENCIES context)
1371       set(_Boost_FIBER_DEPENDENCIES context)
1372       set(_Boost_IOSTREAMS_DEPENDENCIES regex)
1373       set(_Boost_JSON_DEPENDENCIES container)
1374       set(_Boost_LOG_DEPENDENCIES log_setup filesystem thread regex chrono atomic)
1375       set(_Boost_MATH_DEPENDENCIES math_c99 math_c99f math_c99l math_tr1 math_tr1f math_tr1l)
1376       set(_Boost_MPI_DEPENDENCIES serialization)
1377       set(_Boost_MPI_PYTHON_DEPENDENCIES python${component_python_version} mpi serialization)
1378       set(_Boost_NUMPY_DEPENDENCIES python${component_python_version})
1379       set(_Boost_THREAD_DEPENDENCIES chrono atomic)
1380       set(_Boost_TIMER_DEPENDENCIES chrono)
1381       set(_Boost_WAVE_DEPENDENCIES filesystem serialization thread chrono atomic)
1382       set(_Boost_WSERIALIZATION_DEPENDENCIES serialization)
1383       if(Boost_VERSION_STRING VERSION_GREATER_EQUAL 1.81.0 AND NOT Boost_NO_WARN_NEW_VERSIONS)
1384         message(WARNING "New Boost version may have incorrect or missing dependencies and imported targets")
1385       endif()
1386     endif()
1387   endif()
1388
1389   string(TOUPPER ${component} uppercomponent)
1390   set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
1391   set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE)
1392
1393   string(REGEX REPLACE ";" " " _boost_DEPS_STRING "${_Boost_${uppercomponent}_DEPENDENCIES}")
1394   if (NOT _boost_DEPS_STRING)
1395     set(_boost_DEPS_STRING "(none)")
1396   endif()
1397   # message(STATUS "Dependencies for Boost::${component}: ${_boost_DEPS_STRING}")
1398 endfunction()
1399
1400 #
1401 # Get component headers.  This is the primary header (or headers) for
1402 # a given component, and is used to check that the headers are present
1403 # as well as the library itself as an extra sanity check of the build
1404 # environment.
1405 #
1406 # component - the component to check
1407 # _hdrs
1408 #
1409 function(_Boost_COMPONENT_HEADERS component _hdrs)
1410   # Handle Python version suffixes
1411   if(component MATCHES "^(python|mpi_python|numpy)([0-9]+|[0-9]\\.[0-9]+)\$")
1412     set(component "${CMAKE_MATCH_1}")
1413     set(component_python_version "${CMAKE_MATCH_2}")
1414   endif()
1415
1416   # Note: new boost components will require adding here.  The header
1417   # must be present in all versions of Boost providing a library.
1418   set(_Boost_ATOMIC_HEADERS              "boost/atomic.hpp")
1419   set(_Boost_CHRONO_HEADERS              "boost/chrono.hpp")
1420   set(_Boost_CONTAINER_HEADERS           "boost/container/container_fwd.hpp")
1421   set(_Boost_CONTRACT_HEADERS            "boost/contract.hpp")
1422   if(Boost_VERSION_STRING VERSION_LESS 1.61.0)
1423     set(_Boost_CONTEXT_HEADERS           "boost/context/all.hpp")
1424   else()
1425     set(_Boost_CONTEXT_HEADERS           "boost/context/detail/fcontext.hpp")
1426   endif()
1427   set(_Boost_COROUTINE_HEADERS           "boost/coroutine/all.hpp")
1428   set(_Boost_DATE_TIME_HEADERS           "boost/date_time/date.hpp")
1429   set(_Boost_EXCEPTION_HEADERS           "boost/exception/exception.hpp")
1430   set(_Boost_FIBER_HEADERS               "boost/fiber/all.hpp")
1431   set(_Boost_FILESYSTEM_HEADERS          "boost/filesystem/path.hpp")
1432   set(_Boost_GRAPH_HEADERS               "boost/graph/adjacency_list.hpp")
1433   set(_Boost_GRAPH_PARALLEL_HEADERS      "boost/graph/adjacency_list.hpp")
1434   set(_Boost_IOSTREAMS_HEADERS           "boost/iostreams/stream.hpp")
1435   set(_Boost_LOCALE_HEADERS              "boost/locale.hpp")
1436   set(_Boost_LOG_HEADERS                 "boost/log/core.hpp")
1437   set(_Boost_LOG_SETUP_HEADERS           "boost/log/detail/setup_config.hpp")
1438   set(_Boost_JSON_HEADERS                "boost/json.hpp")
1439   set(_Boost_MATH_HEADERS                "boost/math_fwd.hpp")
1440   set(_Boost_MATH_C99_HEADERS            "boost/math/tr1.hpp")
1441   set(_Boost_MATH_C99F_HEADERS           "boost/math/tr1.hpp")
1442   set(_Boost_MATH_C99L_HEADERS           "boost/math/tr1.hpp")
1443   set(_Boost_MATH_TR1_HEADERS            "boost/math/tr1.hpp")
1444   set(_Boost_MATH_TR1F_HEADERS           "boost/math/tr1.hpp")
1445   set(_Boost_MATH_TR1L_HEADERS           "boost/math/tr1.hpp")
1446   set(_Boost_MPI_HEADERS                 "boost/mpi.hpp")
1447   set(_Boost_MPI_PYTHON_HEADERS          "boost/mpi/python/config.hpp")
1448   set(_Boost_NUMPY_HEADERS               "boost/python/numpy.hpp")
1449   set(_Boost_NOWIDE_HEADERS              "boost/nowide/cstdlib.hpp")
1450   set(_Boost_PRG_EXEC_MONITOR_HEADERS    "boost/test/prg_exec_monitor.hpp")
1451   set(_Boost_PROGRAM_OPTIONS_HEADERS     "boost/program_options.hpp")
1452   set(_Boost_PYTHON_HEADERS              "boost/python.hpp")
1453   set(_Boost_RANDOM_HEADERS              "boost/random.hpp")
1454   set(_Boost_REGEX_HEADERS               "boost/regex.hpp")
1455   set(_Boost_SERIALIZATION_HEADERS       "boost/serialization/serialization.hpp")
1456   set(_Boost_SIGNALS_HEADERS             "boost/signals.hpp")
1457   set(_Boost_STACKTRACE_ADDR2LINE_HEADERS "boost/stacktrace.hpp")
1458   set(_Boost_STACKTRACE_BACKTRACE_HEADERS "boost/stacktrace.hpp")
1459   set(_Boost_STACKTRACE_BASIC_HEADERS    "boost/stacktrace.hpp")
1460   set(_Boost_STACKTRACE_NOOP_HEADERS     "boost/stacktrace.hpp")
1461   set(_Boost_STACKTRACE_WINDBG_CACHED_HEADERS "boost/stacktrace.hpp")
1462   set(_Boost_STACKTRACE_WINDBG_HEADERS   "boost/stacktrace.hpp")
1463   set(_Boost_SYSTEM_HEADERS              "boost/system/config.hpp")
1464   set(_Boost_TEST_EXEC_MONITOR_HEADERS   "boost/test/test_exec_monitor.hpp")
1465   set(_Boost_THREAD_HEADERS              "boost/thread.hpp")
1466   set(_Boost_TIMER_HEADERS               "boost/timer.hpp")
1467   set(_Boost_TYPE_ERASURE_HEADERS        "boost/type_erasure/config.hpp")
1468   set(_Boost_UNIT_TEST_FRAMEWORK_HEADERS "boost/test/framework.hpp")
1469   set(_Boost_WAVE_HEADERS                "boost/wave.hpp")
1470   set(_Boost_WSERIALIZATION_HEADERS      "boost/archive/text_wiarchive.hpp")
1471   set(_Boost_BZIP2_HEADERS               "boost/iostreams/filter/bzip2.hpp")
1472   set(_Boost_ZLIB_HEADERS                "boost/iostreams/filter/zlib.hpp")
1473
1474   string(TOUPPER ${component} uppercomponent)
1475   set(${_hdrs} ${_Boost_${uppercomponent}_HEADERS} PARENT_SCOPE)
1476
1477   string(REGEX REPLACE ";" " " _boost_HDRS_STRING "${_Boost_${uppercomponent}_HEADERS}")
1478   if (NOT _boost_HDRS_STRING)
1479     set(_boost_HDRS_STRING "(none)")
1480   endif()
1481   # message(STATUS "Headers for Boost::${component}: ${_boost_HDRS_STRING}")
1482 endfunction()
1483
1484 #
1485 # Determine if any missing dependencies require adding to the component list.
1486 #
1487 # Sets _Boost_${COMPONENT}_DEPENDENCIES for each required component,
1488 # plus _Boost_IMPORTED_TARGETS (TRUE if imported targets should be
1489 # defined; FALSE if dependency information is unavailable).
1490 #
1491 # componentvar - the component list variable name
1492 # extravar - the indirect dependency list variable name
1493 #
1494 #
1495 function(_Boost_MISSING_DEPENDENCIES componentvar extravar)
1496   # _boost_unprocessed_components - list of components requiring processing
1497   # _boost_processed_components - components already processed (or currently being processed)
1498   # _boost_new_components - new components discovered for future processing
1499   #
1500   list(APPEND _boost_unprocessed_components ${${componentvar}})
1501
1502   while(_boost_unprocessed_components)
1503     list(APPEND _boost_processed_components ${_boost_unprocessed_components})
1504     foreach(component ${_boost_unprocessed_components})
1505       string(TOUPPER ${component} uppercomponent)
1506       set(${_ret} ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
1507       _Boost_COMPONENT_DEPENDENCIES("${component}" _Boost_${uppercomponent}_DEPENDENCIES)
1508       set(_Boost_${uppercomponent}_DEPENDENCIES ${_Boost_${uppercomponent}_DEPENDENCIES} PARENT_SCOPE)
1509       set(_Boost_IMPORTED_TARGETS ${_Boost_IMPORTED_TARGETS} PARENT_SCOPE)
1510       foreach(componentdep ${_Boost_${uppercomponent}_DEPENDENCIES})
1511         if (NOT ("${componentdep}" IN_LIST _boost_processed_components OR "${componentdep}" IN_LIST _boost_new_components))
1512           list(APPEND _boost_new_components ${componentdep})
1513         endif()
1514       endforeach()
1515     endforeach()
1516     set(_boost_unprocessed_components ${_boost_new_components})
1517     unset(_boost_new_components)
1518   endwhile()
1519   set(_boost_extra_components ${_boost_processed_components})
1520   if(_boost_extra_components AND ${componentvar})
1521     list(REMOVE_ITEM _boost_extra_components ${${componentvar}})
1522   endif()
1523   set(${componentvar} ${_boost_processed_components} PARENT_SCOPE)
1524   set(${extravar} ${_boost_extra_components} PARENT_SCOPE)
1525 endfunction()
1526
1527 #
1528 # Some boost libraries may require particular set of compler features.
1529 # The very first one was `boost::fiber` introduced in Boost 1.62.
1530 # One can check required compiler features of it in
1531 # - `${Boost_ROOT}/libs/fiber/build/Jamfile.v2`;
1532 # - `${Boost_ROOT}/libs/context/build/Jamfile.v2`.
1533 #
1534 # TODO (Re)Check compiler features on (every?) release ???
1535 # One may use the following command to get the files to check:
1536 #
1537 #   $ find . -name Jamfile.v2 | grep build | xargs grep -l cxx1
1538 #
1539 function(_Boost_COMPILER_FEATURES component _ret)
1540   # Boost >= 1.62
1541   if(NOT Boost_VERSION_STRING VERSION_LESS 1.62.0)
1542     set(_Boost_FIBER_COMPILER_FEATURES
1543         cxx_alias_templates
1544         cxx_auto_type
1545         cxx_constexpr
1546         cxx_defaulted_functions
1547         cxx_final
1548         cxx_lambdas
1549         cxx_noexcept
1550         cxx_nullptr
1551         cxx_rvalue_references
1552         cxx_thread_local
1553         cxx_variadic_templates
1554     )
1555     # Compiler feature for `context` same as for `fiber`.
1556     set(_Boost_CONTEXT_COMPILER_FEATURES ${_Boost_FIBER_COMPILER_FEATURES})
1557   endif()
1558
1559   # Boost Contract library available in >= 1.67
1560   if(NOT Boost_VERSION_STRING VERSION_LESS 1.67.0)
1561     # From `libs/contract/build/boost_contract_build.jam`
1562     set(_Boost_CONTRACT_COMPILER_FEATURES
1563         cxx_lambdas
1564         cxx_variadic_templates
1565     )
1566   endif()
1567
1568   string(TOUPPER ${component} uppercomponent)
1569   set(${_ret} ${_Boost_${uppercomponent}_COMPILER_FEATURES} PARENT_SCOPE)
1570 endfunction()
1571
1572 #
1573 # Update library search directory hint variable with paths used by prebuilt boost binaries.
1574 #
1575 # Prebuilt windows binaries (https://sourceforge.net/projects/boost/files/boost-binaries/)
1576 # have library directories named using MSVC compiler version and architecture.
1577 # This function would append corresponding directories if MSVC is a current compiler,
1578 # so having `BOOST_ROOT` would be enough to specify to find everything.
1579 #
1580 function(_Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS componentlibvar basedir)
1581   if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
1582     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
1583       set(_arch_suffix 64)
1584     else()
1585       set(_arch_suffix 32)
1586     endif()
1587     if(MSVC_TOOLSET_VERSION GREATER_EQUAL 150)
1588       # Not yet known.
1589     elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 140)
1590       # MSVC toolset 14.x versions are forward compatible.
1591       foreach(v 9 8 7 6 5 4 3 2 1 0)
1592         if(MSVC_TOOLSET_VERSION GREATER_EQUAL 14${v})
1593           list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-14.${v})
1594         endif()
1595       endforeach()
1596     elseif(MSVC_TOOLSET_VERSION GREATER_EQUAL 80)
1597       math(EXPR _toolset_major_version "${MSVC_TOOLSET_VERSION} / 10")
1598       list(APPEND ${componentlibvar} ${basedir}/lib${_arch_suffix}-msvc-${_toolset_major_version}.0)
1599     endif()
1600     set(${componentlibvar} ${${componentlibvar}} PARENT_SCOPE)
1601   endif()
1602 endfunction()
1603
1604 #
1605 # End functions/macros
1606 #
1607 #-------------------------------------------------------------------------------
1608
1609 #-------------------------------------------------------------------------------
1610 # main.
1611 #-------------------------------------------------------------------------------
1612
1613
1614 # If the user sets Boost_LIBRARY_DIR, use it as the default for both
1615 # configurations.
1616 if(NOT Boost_LIBRARY_DIR_RELEASE AND Boost_LIBRARY_DIR)
1617   set(Boost_LIBRARY_DIR_RELEASE "${Boost_LIBRARY_DIR}")
1618 endif()
1619 if(NOT Boost_LIBRARY_DIR_DEBUG AND Boost_LIBRARY_DIR)
1620   set(Boost_LIBRARY_DIR_DEBUG   "${Boost_LIBRARY_DIR}")
1621 endif()
1622
1623 if(NOT DEFINED Boost_USE_DEBUG_LIBS)
1624   set(Boost_USE_DEBUG_LIBS TRUE)
1625 endif()
1626 if(NOT DEFINED Boost_USE_RELEASE_LIBS)
1627   set(Boost_USE_RELEASE_LIBS TRUE)
1628 endif()
1629 if(NOT DEFINED Boost_USE_MULTITHREADED)
1630   set(Boost_USE_MULTITHREADED TRUE)
1631 endif()
1632 if(NOT DEFINED Boost_USE_DEBUG_RUNTIME)
1633   set(Boost_USE_DEBUG_RUNTIME TRUE)
1634 endif()
1635
1636 # Check the version of Boost against the requested version.
1637 if(Boost_FIND_VERSION AND NOT Boost_FIND_VERSION_MINOR)
1638   message(SEND_ERROR "When requesting a specific version of Boost, you must provide at least the major and minor version numbers, e.g., 1.34")
1639 endif()
1640
1641 if(Boost_FIND_VERSION_EXACT)
1642   # The version may appear in a directory with or without the patch
1643   # level, even when the patch level is non-zero.
1644   set(_boost_TEST_VERSIONS
1645     "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}.${Boost_FIND_VERSION_PATCH}"
1646     "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
1647 else()
1648   # The user has not requested an exact version.  Among known
1649   # versions, find those that are acceptable to the user request.
1650   #
1651   # Note: When adding a new Boost release, also update the dependency
1652   # information in _Boost_COMPONENT_DEPENDENCIES and
1653   # _Boost_COMPONENT_HEADERS.  See the instructions at the top of
1654   # _Boost_COMPONENT_DEPENDENCIES.
1655   set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
1656     "1.80.0" "1.80" "1.79.0" "1.79"
1657     "1.78.0" "1.78" "1.77.0" "1.77" "1.76.0" "1.76" "1.75.0" "1.75" "1.74.0" "1.74"
1658     "1.73.0" "1.73" "1.72.0" "1.72" "1.71.0" "1.71" "1.70.0" "1.70" "1.69.0" "1.69"
1659     "1.68.0" "1.68" "1.67.0" "1.67" "1.66.0" "1.66" "1.65.1" "1.65.0" "1.65"
1660     "1.64.0" "1.64" "1.63.0" "1.63" "1.62.0" "1.62" "1.61.0" "1.61" "1.60.0" "1.60"
1661     "1.59.0" "1.59" "1.58.0" "1.58" "1.57.0" "1.57" "1.56.0" "1.56" "1.55.0" "1.55"
1662     "1.54.0" "1.54" "1.53.0" "1.53" "1.52.0" "1.52" "1.51.0" "1.51"
1663     "1.50.0" "1.50" "1.49.0" "1.49" "1.48.0" "1.48" "1.47.0" "1.47" "1.46.1"
1664     "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
1665     "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37"
1666     "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0"
1667     "1.34" "1.33.1" "1.33.0" "1.33")
1668
1669   set(_boost_TEST_VERSIONS)
1670   if(Boost_FIND_VERSION)
1671     set(_Boost_FIND_VERSION_SHORT "${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
1672     # Select acceptable versions.
1673     foreach(version ${_Boost_KNOWN_VERSIONS})
1674       if(NOT "${version}" VERSION_LESS "${Boost_FIND_VERSION}")
1675         # This version is high enough.
1676         list(APPEND _boost_TEST_VERSIONS "${version}")
1677       elseif("${version}.99" VERSION_EQUAL "${_Boost_FIND_VERSION_SHORT}.99")
1678         # This version is a short-form for the requested version with
1679         # the patch level dropped.
1680         list(APPEND _boost_TEST_VERSIONS "${version}")
1681       endif()
1682     endforeach()
1683   else()
1684     # Any version is acceptable.
1685     set(_boost_TEST_VERSIONS "${_Boost_KNOWN_VERSIONS}")
1686   endif()
1687 endif()
1688
1689 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_TEST_VERSIONS")
1690 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_MULTITHREADED")
1691 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_LIBS")
1692 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_USE_STATIC_RUNTIME")
1693 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_ADDITIONAL_VERSIONS")
1694 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_NO_SYSTEM_PATHS")
1695
1696 if(POLICY CMP0074)
1697   cmake_policy(GET CMP0074 _Boost_CMP0074)
1698   if(NOT "x${_Boost_CMP0074}x" STREQUAL "xNEWx")
1699     _Boost_CHECK_SPELLING(Boost_ROOT)
1700   endif()
1701   unset(_Boost_CMP0074)
1702 endif()
1703 _Boost_CHECK_SPELLING(Boost_LIBRARYDIR)
1704 _Boost_CHECK_SPELLING(Boost_INCLUDEDIR)
1705
1706 # Collect environment variable inputs as hints.  Do not consider changes.
1707 foreach(v BOOSTROOT BOOST_ROOT BOOST_INCLUDEDIR BOOST_LIBRARYDIR)
1708   set(_env $ENV{${v}})
1709   if(_env)
1710     file(TO_CMAKE_PATH "${_env}" _ENV_${v})
1711   else()
1712     set(_ENV_${v} "")
1713   endif()
1714 endforeach()
1715 if(NOT _ENV_BOOST_ROOT AND _ENV_BOOSTROOT)
1716   set(_ENV_BOOST_ROOT "${_ENV_BOOSTROOT}")
1717 endif()
1718
1719 # Collect inputs and cached results.  Detect changes since the last run.
1720 if(NOT BOOST_ROOT AND BOOSTROOT)
1721   set(BOOST_ROOT "${BOOSTROOT}")
1722 endif()
1723 set(_Boost_VARS_DIR
1724   BOOST_ROOT
1725   Boost_NO_SYSTEM_PATHS
1726   )
1727
1728 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_ROOT")
1729 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_ROOT" ENVIRONMENT)
1730 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_INCLUDEDIR")
1731 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_INCLUDEDIR" ENVIRONMENT)
1732 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_LIBRARYDIR")
1733 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "BOOST_LIBRARYDIR" ENVIRONMENT)
1734
1735 # ------------------------------------------------------------------------
1736 #  Search for Boost include DIR
1737 # ------------------------------------------------------------------------
1738
1739 set(_Boost_VARS_INC BOOST_INCLUDEDIR Boost_INCLUDE_DIR Boost_ADDITIONAL_VERSIONS)
1740 _Boost_CHANGE_DETECT(_Boost_CHANGE_INCDIR ${_Boost_VARS_DIR} ${_Boost_VARS_INC})
1741 # Clear Boost_INCLUDE_DIR if it did not change but other input affecting the
1742 # location did.  We will find a new one based on the new inputs.
1743 if(_Boost_CHANGE_INCDIR AND NOT _Boost_INCLUDE_DIR_CHANGED)
1744   unset(Boost_INCLUDE_DIR CACHE)
1745 endif()
1746
1747 if(NOT Boost_INCLUDE_DIR)
1748   set(_boost_INCLUDE_SEARCH_DIRS "")
1749   if(BOOST_INCLUDEDIR)
1750     list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_INCLUDEDIR})
1751   elseif(_ENV_BOOST_INCLUDEDIR)
1752     list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_INCLUDEDIR})
1753   endif()
1754
1755   if( BOOST_ROOT )
1756     list(APPEND _boost_INCLUDE_SEARCH_DIRS ${BOOST_ROOT}/include ${BOOST_ROOT})
1757   elseif( _ENV_BOOST_ROOT )
1758     list(APPEND _boost_INCLUDE_SEARCH_DIRS ${_ENV_BOOST_ROOT}/include ${_ENV_BOOST_ROOT})
1759   endif()
1760
1761   if( Boost_NO_SYSTEM_PATHS)
1762     list(APPEND _boost_INCLUDE_SEARCH_DIRS NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH)
1763   else()
1764     if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
1765       foreach(ver ${_boost_TEST_VERSIONS})
1766         string(REPLACE "." "_" ver "${ver}")
1767         list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS "C:/local/boost_${ver}")
1768       endforeach()
1769     endif()
1770     list(APPEND _boost_INCLUDE_SEARCH_DIRS PATHS
1771       C:/boost/include
1772       C:/boost
1773       /sw/local/include
1774       )
1775   endif()
1776
1777   # Try to find Boost by stepping backwards through the Boost versions
1778   # we know about.
1779   # Build a list of path suffixes for each version.
1780   set(_boost_PATH_SUFFIXES)
1781   foreach(_boost_VER ${_boost_TEST_VERSIONS})
1782     # Add in a path suffix, based on the required version, ideally
1783     # we could read this from version.hpp, but for that to work we'd
1784     # need to know the include dir already
1785     set(_boost_BOOSTIFIED_VERSION)
1786
1787     # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0
1788     if(_boost_VER MATCHES "([0-9]+)\\.([0-9]+)\\.([0-9]+)")
1789         set(_boost_BOOSTIFIED_VERSION
1790           "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}_${CMAKE_MATCH_3}")
1791     elseif(_boost_VER MATCHES "([0-9]+)\\.([0-9]+)")
1792         set(_boost_BOOSTIFIED_VERSION
1793           "${CMAKE_MATCH_1}_${CMAKE_MATCH_2}")
1794     endif()
1795
1796     list(APPEND _boost_PATH_SUFFIXES
1797       "boost-${_boost_BOOSTIFIED_VERSION}"
1798       "boost_${_boost_BOOSTIFIED_VERSION}"
1799       "boost/boost-${_boost_BOOSTIFIED_VERSION}"
1800       "boost/boost_${_boost_BOOSTIFIED_VERSION}"
1801       )
1802
1803   endforeach()
1804
1805   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_INCLUDE_SEARCH_DIRS")
1806   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_PATH_SUFFIXES")
1807
1808   # Look for a standard boost header file.
1809   find_path(Boost_INCLUDE_DIR
1810     NAMES         boost/config.hpp
1811     HINTS         ${_boost_INCLUDE_SEARCH_DIRS}
1812     PATH_SUFFIXES ${_boost_PATH_SUFFIXES}
1813     )
1814 endif()
1815
1816 # ------------------------------------------------------------------------
1817 #  Extract version information from version.hpp
1818 # ------------------------------------------------------------------------
1819
1820 if(Boost_INCLUDE_DIR)
1821   _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
1822                      "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp")
1823
1824   # Extract Boost_VERSION_MACRO and Boost_LIB_VERSION from version.hpp
1825   set(Boost_VERSION_MACRO 0)
1826   set(Boost_LIB_VERSION "")
1827   file(STRINGS "${Boost_INCLUDE_DIR}/boost/version.hpp" _boost_VERSION_HPP_CONTENTS REGEX "#define BOOST_(LIB_)?VERSION ")
1828   if("${_boost_VERSION_HPP_CONTENTS}" MATCHES "#define BOOST_VERSION ([0-9]+)")
1829     set(Boost_VERSION_MACRO "${CMAKE_MATCH_1}")
1830   endif()
1831   if("${_boost_VERSION_HPP_CONTENTS}" MATCHES "#define BOOST_LIB_VERSION \"([0-9_]+)\"")
1832     set(Boost_LIB_VERSION "${CMAKE_MATCH_1}")
1833   endif()
1834   unset(_boost_VERSION_HPP_CONTENTS)
1835
1836   # Calculate version components
1837   math(EXPR Boost_VERSION_MAJOR "${Boost_VERSION_MACRO} / 100000")
1838   math(EXPR Boost_VERSION_MINOR "${Boost_VERSION_MACRO} / 100 % 1000")
1839   math(EXPR Boost_VERSION_PATCH "${Boost_VERSION_MACRO} % 100")
1840   set(Boost_VERSION_COUNT 3)
1841
1842   # Define alias variables for backwards compat.
1843   set(Boost_MAJOR_VERSION ${Boost_VERSION_MAJOR})
1844   set(Boost_MINOR_VERSION ${Boost_VERSION_MINOR})
1845   set(Boost_SUBMINOR_VERSION ${Boost_VERSION_PATCH})
1846
1847   # Define Boost version in x.y.z format
1848   set(Boost_VERSION_STRING "${Boost_VERSION_MAJOR}.${Boost_VERSION_MINOR}.${Boost_VERSION_PATCH}")
1849
1850   # Define final Boost_VERSION
1851   if(POLICY CMP0093)
1852     cmake_policy(GET CMP0093 _Boost_CMP0093
1853       PARENT_SCOPE # undocumented, do not use outside of CMake
1854     )
1855     if("x${_Boost_CMP0093}x" STREQUAL "xNEWx")
1856       set(Boost_VERSION ${Boost_VERSION_STRING})
1857     else()
1858       set(Boost_VERSION ${Boost_VERSION_MACRO})
1859     endif()
1860     unset(_Boost_CMP0093)
1861   else()
1862     set(Boost_VERSION ${Boost_VERSION_MACRO})
1863   endif()
1864   unset(_Boost_CMP0093)
1865
1866   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION")
1867   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_STRING")
1868   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MACRO")
1869   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MAJOR")
1870   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_MINOR")
1871   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_PATCH")
1872   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_VERSION_COUNT")
1873 endif()
1874
1875 # ------------------------------------------------------------------------
1876 #  Prefix initialization
1877 # ------------------------------------------------------------------------
1878
1879 if ( NOT DEFINED Boost_LIB_PREFIX )
1880   # Boost's static libraries use a "lib" prefix on DLL platforms
1881   # to distinguish them from the DLL import libraries.
1882   if (Boost_USE_STATIC_LIBS AND (
1883       (WIN32 AND NOT CYGWIN)
1884       OR GHSMULTI
1885       ))
1886     set(Boost_LIB_PREFIX "lib")
1887   else()
1888     set(Boost_LIB_PREFIX "")
1889   endif()
1890 endif()
1891
1892 if ( NOT Boost_NAMESPACE )
1893   set(Boost_NAMESPACE "boost")
1894 endif()
1895
1896 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_LIB_PREFIX")
1897 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "Boost_NAMESPACE")
1898
1899 # ------------------------------------------------------------------------
1900 #  Suffix initialization and compiler suffix detection.
1901 # ------------------------------------------------------------------------
1902
1903 set(_Boost_VARS_NAME
1904   Boost_NAMESPACE
1905   Boost_COMPILER
1906   Boost_THREADAPI
1907   Boost_USE_DEBUG_PYTHON
1908   Boost_USE_MULTITHREADED
1909   Boost_USE_STATIC_LIBS
1910   Boost_USE_STATIC_RUNTIME
1911   Boost_USE_STLPORT
1912   Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS
1913   )
1914 _Boost_CHANGE_DETECT(_Boost_CHANGE_LIBNAME ${_Boost_VARS_NAME})
1915
1916 # Setting some more suffixes for the library
1917 if (Boost_COMPILER)
1918   set(_boost_COMPILER ${Boost_COMPILER})
1919   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
1920                          "_boost_COMPILER" SOURCE "user-specified via Boost_COMPILER")
1921 else()
1922   # Attempt to guess the compiler suffix
1923   # NOTE: this is not perfect yet, if you experience any issues
1924   # please report them and use the Boost_COMPILER variable
1925   # to work around the problems.
1926   _Boost_GUESS_COMPILER_PREFIX(_boost_COMPILER)
1927 endif()
1928
1929 set (_boost_MULTITHREADED "-mt")
1930 if( NOT Boost_USE_MULTITHREADED )
1931   set (_boost_MULTITHREADED "")
1932 endif()
1933 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_MULTITHREADED")
1934
1935 #======================
1936 # Systematically build up the Boost ABI tag for the 'tagged' and 'versioned' layouts
1937 # http://boost.org/doc/libs/1_66_0/more/getting_started/windows.html#library-naming
1938 # http://boost.org/doc/libs/1_66_0/boost/config/auto_link.hpp
1939 # http://boost.org/doc/libs/1_66_0/tools/build/src/tools/common.jam
1940 # http://boost.org/doc/libs/1_66_0/boostcpp.jam
1941 set( _boost_RELEASE_ABI_TAG "-")
1942 set( _boost_DEBUG_ABI_TAG   "-")
1943 # Key       Use this library when:
1944 #  s        linking statically to the C++ standard library and
1945 #           compiler runtime support libraries.
1946 if(Boost_USE_STATIC_RUNTIME)
1947   set( _boost_RELEASE_ABI_TAG "${_boost_RELEASE_ABI_TAG}s")
1948   set( _boost_DEBUG_ABI_TAG   "${_boost_DEBUG_ABI_TAG}s")
1949 endif()
1950 #  g        using debug versions of the standard and runtime
1951 #           support libraries
1952 if(WIN32 AND Boost_USE_DEBUG_RUNTIME)
1953   if("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC"
1954           OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xClang"
1955           OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntel"
1956           OR "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xIntelLLVM")
1957     string(APPEND _boost_DEBUG_ABI_TAG "g")
1958   endif()
1959 endif()
1960 #  y        using special debug build of python
1961 if(Boost_USE_DEBUG_PYTHON)
1962   string(APPEND _boost_DEBUG_ABI_TAG "y")
1963 endif()
1964 #  d        using a debug version of your code
1965 string(APPEND _boost_DEBUG_ABI_TAG "d")
1966 #  p        using the STLport standard library rather than the
1967 #           default one supplied with your compiler
1968 if(Boost_USE_STLPORT)
1969   string(APPEND _boost_RELEASE_ABI_TAG "p")
1970   string(APPEND _boost_DEBUG_ABI_TAG "p")
1971 endif()
1972 #  n        using the STLport deprecated "native iostreams" feature
1973 #           removed from the documentation in 1.43.0 but still present in
1974 #           boost/config/auto_link.hpp
1975 if(Boost_USE_STLPORT_DEPRECATED_NATIVE_IOSTREAMS)
1976   string(APPEND _boost_RELEASE_ABI_TAG "n")
1977   string(APPEND _boost_DEBUG_ABI_TAG "n")
1978 endif()
1979
1980 #  -x86     Architecture and address model tag
1981 #           First character is the architecture, then word-size, either 32 or 64
1982 #           Only used in 'versioned' layout, added in Boost 1.66.0
1983 if(DEFINED Boost_ARCHITECTURE)
1984   set(_boost_ARCHITECTURE_TAG "${Boost_ARCHITECTURE}")
1985   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
1986                          "_boost_ARCHITECTURE_TAG" SOURCE "user-specified via Boost_ARCHITECTURE")
1987 else()
1988   set(_boost_ARCHITECTURE_TAG "")
1989   # {CMAKE_CXX_COMPILER_ARCHITECTURE_ID} is not currently set for all compilers
1990   if(NOT "x${CMAKE_CXX_COMPILER_ARCHITECTURE_ID}" STREQUAL "x" AND NOT Boost_VERSION_STRING VERSION_LESS 1.66.0)
1991     string(APPEND _boost_ARCHITECTURE_TAG "-")
1992     # This needs to be kept in-sync with the section of CMakePlatformId.h.in
1993     # inside 'defined(_WIN32) && defined(_MSC_VER)'
1994     if(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "IA64")
1995       string(APPEND _boost_ARCHITECTURE_TAG "i")
1996     elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "X86"
1997               OR CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "x64")
1998       string(APPEND _boost_ARCHITECTURE_TAG "x")
1999     elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID MATCHES "^ARM")
2000       string(APPEND _boost_ARCHITECTURE_TAG "a")
2001     elseif(CMAKE_CXX_COMPILER_ARCHITECTURE_ID STREQUAL "MIPS")
2002       string(APPEND _boost_ARCHITECTURE_TAG "m")
2003     endif()
2004
2005     if(CMAKE_SIZEOF_VOID_P EQUAL 8)
2006       string(APPEND _boost_ARCHITECTURE_TAG "64")
2007     else()
2008       string(APPEND _boost_ARCHITECTURE_TAG "32")
2009     endif()
2010   endif()
2011   _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
2012                          "_boost_ARCHITECTURE_TAG" SOURCE "detected")
2013 endif()
2014
2015 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_RELEASE_ABI_TAG")
2016 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_DEBUG_ABI_TAG")
2017
2018 # ------------------------------------------------------------------------
2019 #  Begin finding boost libraries
2020 # ------------------------------------------------------------------------
2021
2022 set(_Boost_VARS_LIB "")
2023 foreach(c DEBUG RELEASE)
2024   set(_Boost_VARS_LIB_${c} BOOST_LIBRARYDIR Boost_LIBRARY_DIR_${c})
2025   list(APPEND _Boost_VARS_LIB ${_Boost_VARS_LIB_${c}})
2026   _Boost_CHANGE_DETECT(_Boost_CHANGE_LIBDIR_${c} ${_Boost_VARS_DIR} ${_Boost_VARS_LIB_${c}} Boost_INCLUDE_DIR)
2027   # Clear Boost_LIBRARY_DIR_${c} if it did not change but other input affecting the
2028   # location did.  We will find a new one based on the new inputs.
2029   if(_Boost_CHANGE_LIBDIR_${c} AND NOT _Boost_LIBRARY_DIR_${c}_CHANGED)
2030     unset(Boost_LIBRARY_DIR_${c} CACHE)
2031   endif()
2032
2033   # If Boost_LIBRARY_DIR_[RELEASE,DEBUG] is set, prefer its value.
2034   if(Boost_LIBRARY_DIR_${c})
2035     set(_boost_LIBRARY_SEARCH_DIRS_${c} ${Boost_LIBRARY_DIR_${c}} NO_DEFAULT_PATH NO_CMAKE_FIND_ROOT_PATH)
2036   else()
2037     set(_boost_LIBRARY_SEARCH_DIRS_${c} "")
2038     if(BOOST_LIBRARYDIR)
2039       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${BOOST_LIBRARYDIR})
2040     elseif(_ENV_BOOST_LIBRARYDIR)
2041       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${_ENV_BOOST_LIBRARYDIR})
2042     endif()
2043
2044     if(BOOST_ROOT)
2045       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${BOOST_ROOT}/lib ${BOOST_ROOT}/stage/lib)
2046       _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${BOOST_ROOT}")
2047     elseif(_ENV_BOOST_ROOT)
2048       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} ${_ENV_BOOST_ROOT}/lib ${_ENV_BOOST_ROOT}/stage/lib)
2049       _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${_ENV_BOOST_ROOT}")
2050     endif()
2051
2052     list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c}
2053       ${Boost_INCLUDE_DIR}/lib
2054       ${Boost_INCLUDE_DIR}/../lib
2055       ${Boost_INCLUDE_DIR}/stage/lib
2056       )
2057     _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${Boost_INCLUDE_DIR}/..")
2058     _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "${Boost_INCLUDE_DIR}")
2059     if( Boost_NO_SYSTEM_PATHS )
2060       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} NO_CMAKE_SYSTEM_PATH NO_SYSTEM_ENVIRONMENT_PATH)
2061     else()
2062       foreach(ver ${_boost_TEST_VERSIONS})
2063         string(REPLACE "." "_" ver "${ver}")
2064         _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "C:/local/boost_${ver}")
2065       endforeach()
2066       _Boost_UPDATE_WINDOWS_LIBRARY_SEARCH_DIRS_WITH_PREBUILT_PATHS(_boost_LIBRARY_SEARCH_DIRS_${c} "C:/boost")
2067       list(APPEND _boost_LIBRARY_SEARCH_DIRS_${c} PATHS
2068         C:/boost/lib
2069         C:/boost
2070         /sw/local/lib
2071         )
2072     endif()
2073   endif()
2074 endforeach()
2075
2076 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_LIBRARY_SEARCH_DIRS_RELEASE")
2077 _Boost_DEBUG_PRINT_VAR("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}" "_boost_LIBRARY_SEARCH_DIRS_DEBUG")
2078
2079 # Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
2080 if( Boost_USE_STATIC_LIBS )
2081   set( _boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
2082   if(WIN32)
2083     list(INSERT CMAKE_FIND_LIBRARY_SUFFIXES 0 .lib .a)
2084   else()
2085     set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
2086   endif()
2087 endif()
2088
2089 # We want to use the tag inline below without risking double dashes
2090 if(_boost_RELEASE_ABI_TAG)
2091   if(${_boost_RELEASE_ABI_TAG} STREQUAL "-")
2092     set(_boost_RELEASE_ABI_TAG "")
2093   endif()
2094 endif()
2095 if(_boost_DEBUG_ABI_TAG)
2096   if(${_boost_DEBUG_ABI_TAG} STREQUAL "-")
2097     set(_boost_DEBUG_ABI_TAG "")
2098   endif()
2099 endif()
2100
2101 # The previous behavior of FindBoost when Boost_USE_STATIC_LIBS was enabled
2102 # on WIN32 was to:
2103 #  1. Search for static libs compiled against a SHARED C++ standard runtime library (use if found)
2104 #  2. Search for static libs compiled against a STATIC C++ standard runtime library (use if found)
2105 # We maintain this behavior since changing it could break people's builds.
2106 # To disable the ambiguous behavior, the user need only
2107 # set Boost_USE_STATIC_RUNTIME either ON or OFF.
2108 set(_boost_STATIC_RUNTIME_WORKAROUND false)
2109 if(WIN32 AND Boost_USE_STATIC_LIBS)
2110   if(NOT DEFINED Boost_USE_STATIC_RUNTIME)
2111     set(_boost_STATIC_RUNTIME_WORKAROUND TRUE)
2112   endif()
2113 endif()
2114
2115 # On versions < 1.35, remove the System library from the considered list
2116 # since it wasn't added until 1.35.
2117 if(Boost_VERSION_STRING AND Boost_FIND_COMPONENTS)
2118   if(Boost_VERSION_STRING VERSION_LESS 1.35.0)
2119     list(REMOVE_ITEM Boost_FIND_COMPONENTS system)
2120   endif()
2121 endif()
2122
2123 # Additional components may be required via component dependencies.
2124 # Add any missing components to the list.
2125 _Boost_MISSING_DEPENDENCIES(Boost_FIND_COMPONENTS _Boost_EXTRA_FIND_COMPONENTS)
2126
2127 # If thread is required, get the thread libs as a dependency
2128 if("thread" IN_LIST Boost_FIND_COMPONENTS)
2129   if(Boost_FIND_QUIETLY)
2130     set(_Boost_find_quiet QUIET)
2131   else()
2132     set(_Boost_find_quiet "")
2133   endif()
2134   find_package(Threads ${_Boost_find_quiet})
2135   unset(_Boost_find_quiet)
2136 endif()
2137
2138 # If the user changed any of our control inputs flush previous results.
2139 if(_Boost_CHANGE_LIBDIR_DEBUG OR _Boost_CHANGE_LIBDIR_RELEASE OR _Boost_CHANGE_LIBNAME)
2140   foreach(COMPONENT ${_Boost_COMPONENTS_SEARCHED})
2141     string(TOUPPER ${COMPONENT} UPPERCOMPONENT)
2142     foreach(c DEBUG RELEASE)
2143       set(_var Boost_${UPPERCOMPONENT}_LIBRARY_${c})
2144       unset(${_var} CACHE)
2145       set(${_var} "${_var}-NOTFOUND")
2146     endforeach()
2147   endforeach()
2148   set(_Boost_COMPONENTS_SEARCHED "")
2149 endif()
2150
2151 foreach(COMPONENT ${Boost_FIND_COMPONENTS})
2152   string(TOUPPER ${COMPONENT} UPPERCOMPONENT)
2153
2154   set( _boost_docstring_release "Boost ${COMPONENT} library (release)")
2155   set( _boost_docstring_debug   "Boost ${COMPONENT} library (debug)")
2156
2157   # Compute component-specific hints.
2158   set(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT "")
2159   if(${COMPONENT} STREQUAL "mpi" OR ${COMPONENT} STREQUAL "mpi_python" OR
2160      ${COMPONENT} STREQUAL "graph_parallel")
2161     foreach(lib ${MPI_CXX_LIBRARIES} ${MPI_C_LIBRARIES})
2162       if(IS_ABSOLUTE "${lib}")
2163         get_filename_component(libdir "${lib}" PATH)
2164         string(REPLACE "\\" "/" libdir "${libdir}")
2165         list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT ${libdir})
2166       endif()
2167     endforeach()
2168   endif()
2169
2170   # Handle Python version suffixes
2171   unset(COMPONENT_PYTHON_VERSION_MAJOR)
2172   unset(COMPONENT_PYTHON_VERSION_MINOR)
2173   if(${COMPONENT} MATCHES "^(python|mpi_python|numpy)([0-9])\$")
2174     set(COMPONENT_UNVERSIONED "${CMAKE_MATCH_1}")
2175     set(COMPONENT_PYTHON_VERSION_MAJOR "${CMAKE_MATCH_2}")
2176   elseif(${COMPONENT} MATCHES "^(python|mpi_python|numpy)([0-9])\\.?([0-9]+)\$")
2177     set(COMPONENT_UNVERSIONED "${CMAKE_MATCH_1}")
2178     set(COMPONENT_PYTHON_VERSION_MAJOR "${CMAKE_MATCH_2}")
2179     set(COMPONENT_PYTHON_VERSION_MINOR "${CMAKE_MATCH_3}")
2180   endif()
2181
2182   unset(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME)
2183   if (COMPONENT_PYTHON_VERSION_MINOR)
2184     # Boost >= 1.67
2185     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}")
2186     # Debian/Ubuntu (Some versions omit the 2 and/or 3 from the suffix)
2187     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}-py${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}")
2188     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-py${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}")
2189     # Gentoo
2190     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-${COMPONENT_PYTHON_VERSION_MAJOR}.${COMPONENT_PYTHON_VERSION_MINOR}")
2191     # RPMs
2192     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}-${COMPONENT_PYTHON_VERSION_MAJOR}${COMPONENT_PYTHON_VERSION_MINOR}")
2193   endif()
2194   if (COMPONENT_PYTHON_VERSION_MAJOR AND NOT COMPONENT_PYTHON_VERSION_MINOR)
2195     # Boost < 1.67
2196     list(APPEND _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME "${COMPONENT_UNVERSIONED}${COMPONENT_PYTHON_VERSION_MAJOR}")
2197   endif()
2198
2199   # Consolidate and report component-specific hints.
2200   if(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME)
2201     list(REMOVE_DUPLICATES _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME)
2202     _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
2203       "Component-specific library search names for ${COMPONENT_NAME}: ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME}")
2204   endif()
2205   if(_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT)
2206     list(REMOVE_DUPLICATES _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT)
2207     _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
2208       "Component-specific library search paths for ${COMPONENT}: ${_Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT}")
2209   endif()
2210
2211   #
2212   # Find headers
2213   #
2214   _Boost_COMPONENT_HEADERS("${COMPONENT}" Boost_${UPPERCOMPONENT}_HEADER_NAME)
2215   # Look for a standard boost header file.
2216   if(Boost_${UPPERCOMPONENT}_HEADER_NAME)
2217     if(EXISTS "${Boost_INCLUDE_DIR}/${Boost_${UPPERCOMPONENT}_HEADER_NAME}")
2218       set(Boost_${UPPERCOMPONENT}_HEADER ON)
2219     else()
2220       set(Boost_${UPPERCOMPONENT}_HEADER OFF)
2221     endif()
2222   else()
2223     set(Boost_${UPPERCOMPONENT}_HEADER ON)
2224     message(WARNING "No header defined for ${COMPONENT}; skipping header check "
2225                     "(note: header-only libraries have no designated component)")
2226   endif()
2227
2228   #
2229   # Find RELEASE libraries
2230   #
2231   unset(_boost_RELEASE_NAMES)
2232   foreach(component IN LISTS _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME COMPONENT)
2233     foreach(compiler IN LISTS _boost_COMPILER)
2234       list(APPEND _boost_RELEASE_NAMES
2235         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2236         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2237         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG} )
2238     endforeach()
2239     list(APPEND _boost_RELEASE_NAMES
2240       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2241       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2242       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}
2243       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}
2244       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )
2245     if(_boost_STATIC_RUNTIME_WORKAROUND)
2246       set(_boost_RELEASE_STATIC_ABI_TAG "-s${_boost_RELEASE_ABI_TAG}")
2247       foreach(compiler IN LISTS _boost_COMPILER)
2248         list(APPEND _boost_RELEASE_NAMES
2249           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2250           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2251           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )
2252       endforeach()
2253       list(APPEND _boost_RELEASE_NAMES
2254         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2255         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2256         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )
2257     endif()
2258   endforeach()
2259   if(Boost_THREADAPI AND ${COMPONENT} STREQUAL "thread")
2260     _Boost_PREPEND_LIST_WITH_THREADAPI(_boost_RELEASE_NAMES ${_boost_RELEASE_NAMES})
2261   endif()
2262   _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
2263                      "Searching for ${UPPERCOMPONENT}_LIBRARY_RELEASE: ${_boost_RELEASE_NAMES}")
2264
2265   # if Boost_LIBRARY_DIR_RELEASE is not defined,
2266   # but Boost_LIBRARY_DIR_DEBUG is, look there first for RELEASE libs
2267   if(NOT Boost_LIBRARY_DIR_RELEASE AND Boost_LIBRARY_DIR_DEBUG)
2268     list(INSERT _boost_LIBRARY_SEARCH_DIRS_RELEASE 0 ${Boost_LIBRARY_DIR_DEBUG})
2269   endif()
2270
2271   # Avoid passing backslashes to _Boost_FIND_LIBRARY due to macro re-parsing.
2272   string(REPLACE "\\" "/" _boost_LIBRARY_SEARCH_DIRS_tmp "${_boost_LIBRARY_SEARCH_DIRS_RELEASE}")
2273
2274   if(Boost_USE_RELEASE_LIBS)
2275     _Boost_FIND_LIBRARY(Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE RELEASE
2276       NAMES ${_boost_RELEASE_NAMES}
2277       HINTS ${_boost_LIBRARY_SEARCH_DIRS_tmp}
2278       NAMES_PER_DIR
2279       DOC "${_boost_docstring_release}"
2280       )
2281   endif()
2282
2283   #
2284   # Find DEBUG libraries
2285   #
2286   unset(_boost_DEBUG_NAMES)
2287   foreach(component IN LISTS _Boost_FIND_LIBRARY_HINTS_FOR_COMPONENT_NAME COMPONENT)
2288     foreach(compiler IN LISTS _boost_COMPILER)
2289       list(APPEND _boost_DEBUG_NAMES
2290         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2291         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2292         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG} )
2293     endforeach()
2294     list(APPEND _boost_DEBUG_NAMES
2295       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2296       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2297       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}
2298       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}
2299       ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )
2300     if(_boost_STATIC_RUNTIME_WORKAROUND)
2301       set(_boost_DEBUG_STATIC_ABI_TAG "-s${_boost_DEBUG_ABI_TAG}")
2302       foreach(compiler IN LISTS _boost_COMPILER)
2303         list(APPEND _boost_DEBUG_NAMES
2304           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2305           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2306           ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )
2307       endforeach()
2308       list(APPEND _boost_DEBUG_NAMES
2309         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}
2310         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}
2311         ${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )
2312     endif()
2313   endforeach()
2314   if(Boost_THREADAPI AND ${COMPONENT} STREQUAL "thread")
2315      _Boost_PREPEND_LIST_WITH_THREADAPI(_boost_DEBUG_NAMES ${_boost_DEBUG_NAMES})
2316   endif()
2317   _Boost_DEBUG_PRINT("${CMAKE_CURRENT_LIST_FILE}" "${CMAKE_CURRENT_LIST_LINE}"
2318                      "Searching for ${UPPERCOMPONENT}_LIBRARY_DEBUG: ${_boost_DEBUG_NAMES}")
2319
2320   # if Boost_LIBRARY_DIR_DEBUG is not defined,
2321   # but Boost_LIBRARY_DIR_RELEASE is, look there first for DEBUG libs
2322   if(NOT Boost_LIBRARY_DIR_DEBUG AND Boost_LIBRARY_DIR_RELEASE)
2323     list(INSERT _boost_LIBRARY_SEARCH_DIRS_DEBUG 0 ${Boost_LIBRARY_DIR_RELEASE})
2324   endif()
2325
2326   # Avoid passing backslashes to _Boost_FIND_LIBRARY due to macro re-parsing.
2327   string(REPLACE "\\" "/" _boost_LIBRARY_SEARCH_DIRS_tmp "${_boost_LIBRARY_SEARCH_DIRS_DEBUG}")
2328
2329   if(Boost_USE_DEBUG_LIBS)
2330     _Boost_FIND_LIBRARY(Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG DEBUG
2331       NAMES ${_boost_DEBUG_NAMES}
2332       HINTS ${_boost_LIBRARY_SEARCH_DIRS_tmp}
2333       NAMES_PER_DIR
2334       DOC "${_boost_docstring_debug}"
2335       )
2336   endif ()
2337
2338   if(Boost_REALPATH)
2339     _Boost_SWAP_WITH_REALPATH(Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE "${_boost_docstring_release}")
2340     _Boost_SWAP_WITH_REALPATH(Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG   "${_boost_docstring_debug}"  )
2341   endif()
2342
2343   _Boost_ADJUST_LIB_VARS(${UPPERCOMPONENT})
2344
2345   # Check if component requires some compiler features
2346   _Boost_COMPILER_FEATURES(${COMPONENT} _Boost_${UPPERCOMPONENT}_COMPILER_FEATURES)
2347
2348 endforeach()
2349
2350 # Restore the original find library ordering
2351 if( Boost_USE_STATIC_LIBS )
2352   set(CMAKE_FIND_LIBRARY_SUFFIXES ${_boost_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
2353 endif()
2354
2355 # ------------------------------------------------------------------------
2356 #  End finding boost libraries
2357 # ------------------------------------------------------------------------
2358
2359 set(Boost_INCLUDE_DIRS ${Boost_INCLUDE_DIR})
2360 set(Boost_LIBRARY_DIRS)
2361 if(Boost_LIBRARY_DIR_RELEASE)
2362   list(APPEND Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR_RELEASE})
2363 endif()
2364 if(Boost_LIBRARY_DIR_DEBUG)
2365   list(APPEND Boost_LIBRARY_DIRS ${Boost_LIBRARY_DIR_DEBUG})
2366 endif()
2367 if(Boost_LIBRARY_DIRS)
2368   list(REMOVE_DUPLICATES Boost_LIBRARY_DIRS)
2369 endif()
2370
2371 # ------------------------------------------------------------------------
2372 #  Call FPHSA helper, see https://cmake.org/cmake/help/latest/module/FindPackageHandleStandardArgs.html
2373 # ------------------------------------------------------------------------
2374
2375 # Define aliases as needed by the component handler in the FPHSA helper below
2376 foreach(_comp IN LISTS Boost_FIND_COMPONENTS)
2377   string(TOUPPER ${_comp} _uppercomp)
2378   if(DEFINED Boost_${_uppercomp}_FOUND)
2379     set(Boost_${_comp}_FOUND ${Boost_${_uppercomp}_FOUND})
2380   endif()
2381 endforeach()
2382
2383 find_package_handle_standard_args(Boost
2384   REQUIRED_VARS Boost_INCLUDE_DIR
2385   VERSION_VAR Boost_VERSION_STRING
2386   HANDLE_COMPONENTS)
2387
2388 if(Boost_FOUND)
2389   if( NOT Boost_LIBRARY_DIRS )
2390     # Compatibility Code for backwards compatibility with CMake
2391     # 2.4's FindBoost module.
2392
2393     # Look for the boost library path.
2394     # Note that the user may not have installed any libraries
2395     # so it is quite possible the Boost_LIBRARY_DIRS may not exist.
2396     set(_boost_LIB_DIR ${Boost_INCLUDE_DIR})
2397
2398     if("${_boost_LIB_DIR}" MATCHES "boost-[0-9]+")
2399       get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH)
2400     endif()
2401
2402     if("${_boost_LIB_DIR}" MATCHES "/include$")
2403       # Strip off the trailing "/include" in the path.
2404       get_filename_component(_boost_LIB_DIR ${_boost_LIB_DIR} PATH)
2405     endif()
2406
2407     if(EXISTS "${_boost_LIB_DIR}/lib")
2408       string(APPEND _boost_LIB_DIR /lib)
2409     elseif(EXISTS "${_boost_LIB_DIR}/stage/lib")
2410       string(APPEND _boost_LIB_DIR "/stage/lib")
2411     else()
2412       set(_boost_LIB_DIR "")
2413     endif()
2414
2415     if(_boost_LIB_DIR AND EXISTS "${_boost_LIB_DIR}")
2416       set(Boost_LIBRARY_DIRS ${_boost_LIB_DIR})
2417     endif()
2418
2419   endif()
2420 else()
2421   # Boost headers were not found so no components were found.
2422   foreach(COMPONENT ${Boost_FIND_COMPONENTS})
2423     string(TOUPPER ${COMPONENT} UPPERCOMPONENT)
2424     set(Boost_${UPPERCOMPONENT}_FOUND 0)
2425   endforeach()
2426 endif()
2427
2428 # ------------------------------------------------------------------------
2429 #  Add imported targets
2430 # ------------------------------------------------------------------------
2431
2432 if(Boost_FOUND)
2433   # The builtin CMake package in Boost 1.70+ introduces a new name
2434   # for the header-only lib, let's provide the same UI in module mode
2435   if(NOT TARGET Boost::headers)
2436     add_library(Boost::headers INTERFACE IMPORTED)
2437     if(Boost_INCLUDE_DIRS)
2438       set_target_properties(Boost::headers PROPERTIES
2439         INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}")
2440     endif()
2441   endif()
2442
2443   # Define the old target name for header-only libraries for backwards
2444   # compat.
2445   if(NOT TARGET Boost::boost)
2446     add_library(Boost::boost INTERFACE IMPORTED)
2447     set_target_properties(Boost::boost
2448       PROPERTIES INTERFACE_LINK_LIBRARIES Boost::headers)
2449   endif()
2450
2451   foreach(COMPONENT ${Boost_FIND_COMPONENTS})
2452     if(_Boost_IMPORTED_TARGETS AND NOT TARGET Boost::${COMPONENT})
2453       string(TOUPPER ${COMPONENT} UPPERCOMPONENT)
2454       if(Boost_${UPPERCOMPONENT}_FOUND)
2455         if(Boost_USE_STATIC_LIBS)
2456           add_library(Boost::${COMPONENT} STATIC IMPORTED)
2457         else()
2458           # Even if Boost_USE_STATIC_LIBS is OFF, we might have static
2459           # libraries as a result.
2460           add_library(Boost::${COMPONENT} UNKNOWN IMPORTED)
2461         endif()
2462         if(Boost_INCLUDE_DIRS)
2463           set_target_properties(Boost::${COMPONENT} PROPERTIES
2464             INTERFACE_INCLUDE_DIRECTORIES "${Boost_INCLUDE_DIRS}")
2465         endif()
2466         if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY}")
2467           set_target_properties(Boost::${COMPONENT} PROPERTIES
2468             IMPORTED_LINK_INTERFACE_LANGUAGES "CXX"
2469             IMPORTED_LOCATION "${Boost_${UPPERCOMPONENT}_LIBRARY}")
2470         endif()
2471         if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE}")
2472           set_property(TARGET Boost::${COMPONENT} APPEND PROPERTY
2473             IMPORTED_CONFIGURATIONS RELEASE)
2474           set_target_properties(Boost::${COMPONENT} PROPERTIES
2475             IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "CXX"
2476             IMPORTED_LOCATION_RELEASE "${Boost_${UPPERCOMPONENT}_LIBRARY_RELEASE}")
2477         endif()
2478         if(EXISTS "${Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG}")
2479           set_property(TARGET Boost::${COMPONENT} APPEND PROPERTY
2480             IMPORTED_CONFIGURATIONS DEBUG)
2481           set_target_properties(Boost::${COMPONENT} PROPERTIES
2482             IMPORTED_LINK_INTERFACE_LANGUAGES_DEBUG "CXX"
2483             IMPORTED_LOCATION_DEBUG "${Boost_${UPPERCOMPONENT}_LIBRARY_DEBUG}")
2484         endif()
2485         if(_Boost_${UPPERCOMPONENT}_DEPENDENCIES)
2486           unset(_Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES)
2487           foreach(dep ${_Boost_${UPPERCOMPONENT}_DEPENDENCIES})
2488             list(APPEND _Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES Boost::${dep})
2489           endforeach()
2490           if(COMPONENT STREQUAL "thread")
2491             list(APPEND _Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES Threads::Threads)
2492           endif()
2493           set_target_properties(Boost::${COMPONENT} PROPERTIES
2494             INTERFACE_LINK_LIBRARIES "${_Boost_${UPPERCOMPONENT}_TARGET_DEPENDENCIES}")
2495         endif()
2496         if(_Boost_${UPPERCOMPONENT}_COMPILER_FEATURES)
2497           set_target_properties(Boost::${COMPONENT} PROPERTIES
2498             INTERFACE_COMPILE_FEATURES "${_Boost_${UPPERCOMPONENT}_COMPILER_FEATURES}")
2499         endif()
2500       endif()
2501     endif()
2502   endforeach()
2503
2504   # Supply Boost_LIB_DIAGNOSTIC_DEFINITIONS as a convenience target. It
2505   # will only contain any interface definitions on WIN32, but is created
2506   # on all platforms to keep end user code free from platform dependent
2507   # code.  Also provide convenience targets to disable autolinking and
2508   # enable dynamic linking.
2509   if(NOT TARGET Boost::diagnostic_definitions)
2510     add_library(Boost::diagnostic_definitions INTERFACE IMPORTED)
2511     add_library(Boost::disable_autolinking INTERFACE IMPORTED)
2512     add_library(Boost::dynamic_linking INTERFACE IMPORTED)
2513     set_target_properties(Boost::dynamic_linking PROPERTIES
2514       INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_DYN_LINK")
2515   endif()
2516   if(WIN32)
2517     # In windows, automatic linking is performed, so you do not have
2518     # to specify the libraries.  If you are linking to a dynamic
2519     # runtime, then you can choose to link to either a static or a
2520     # dynamic Boost library, the default is to do a static link.  You
2521     # can alter this for a specific library "whatever" by defining
2522     # BOOST_WHATEVER_DYN_LINK to force Boost library "whatever" to be
2523     # linked dynamically.  Alternatively you can force all Boost
2524     # libraries to dynamic link by defining BOOST_ALL_DYN_LINK.
2525
2526     # This feature can be disabled for Boost library "whatever" by
2527     # defining BOOST_WHATEVER_NO_LIB, or for all of Boost by defining
2528     # BOOST_ALL_NO_LIB.
2529
2530     # If you want to observe which libraries are being linked against
2531     # then defining BOOST_LIB_DIAGNOSTIC will cause the auto-linking
2532     # code to emit a #pragma message each time a library is selected
2533     # for linking.
2534     set(Boost_LIB_DIAGNOSTIC_DEFINITIONS "-DBOOST_LIB_DIAGNOSTIC")
2535     set_target_properties(Boost::diagnostic_definitions PROPERTIES
2536       INTERFACE_COMPILE_DEFINITIONS "BOOST_LIB_DIAGNOSTIC")
2537     set_target_properties(Boost::disable_autolinking PROPERTIES
2538       INTERFACE_COMPILE_DEFINITIONS "BOOST_ALL_NO_LIB")
2539   endif()
2540 endif()
2541
2542 # ------------------------------------------------------------------------
2543 #  Finalize
2544 # ------------------------------------------------------------------------
2545
2546 # Report Boost_LIBRARIES
2547 set(Boost_LIBRARIES "")
2548 foreach(_comp IN LISTS Boost_FIND_COMPONENTS)
2549   string(TOUPPER ${_comp} _uppercomp)
2550   if(Boost_${_uppercomp}_FOUND)
2551     list(APPEND Boost_LIBRARIES ${Boost_${_uppercomp}_LIBRARY})
2552     if(_comp STREQUAL "thread")
2553       list(APPEND Boost_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
2554     endif()
2555   endif()
2556 endforeach()
2557
2558 # Configure display of cache entries in GUI.
2559 foreach(v BOOSTROOT BOOST_ROOT ${_Boost_VARS_INC} ${_Boost_VARS_LIB})
2560   get_property(_type CACHE ${v} PROPERTY TYPE)
2561   if(_type)
2562     set_property(CACHE ${v} PROPERTY ADVANCED 1)
2563     if("x${_type}" STREQUAL "xUNINITIALIZED")
2564       if("x${v}" STREQUAL "xBoost_ADDITIONAL_VERSIONS")
2565         set_property(CACHE ${v} PROPERTY TYPE STRING)
2566       else()
2567         set_property(CACHE ${v} PROPERTY TYPE PATH)
2568       endif()
2569     endif()
2570   endif()
2571 endforeach()
2572
2573 # Record last used values of input variables so we can
2574 # detect on the next run if the user changed them.
2575 foreach(v
2576     ${_Boost_VARS_INC} ${_Boost_VARS_LIB}
2577     ${_Boost_VARS_DIR} ${_Boost_VARS_NAME}
2578     )
2579   if(DEFINED ${v})
2580     set(_${v}_LAST "${${v}}" CACHE INTERNAL "Last used ${v} value.")
2581   else()
2582     unset(_${v}_LAST CACHE)
2583   endif()
2584 endforeach()
2585
2586 # Maintain a persistent list of components requested anywhere since
2587 # the last flush.
2588 set(_Boost_COMPONENTS_SEARCHED "${_Boost_COMPONENTS_SEARCHED}")
2589 list(APPEND _Boost_COMPONENTS_SEARCHED ${Boost_FIND_COMPONENTS})
2590 list(REMOVE_DUPLICATES _Boost_COMPONENTS_SEARCHED)
2591 list(SORT _Boost_COMPONENTS_SEARCHED)
2592 set(_Boost_COMPONENTS_SEARCHED "${_Boost_COMPONENTS_SEARCHED}"
2593   CACHE INTERNAL "Components requested for this build tree.")
2594
2595 # Restore project's policies
2596 cmake_policy(POP)