fmt-11.0.2/CMakeLists.txt

   1 cmake_minimum_required(VERSION 3.8...3.28)
   2
   3 # Fallback for using newer policies on CMake <3.12.
   4 if (${CMAKE_VERSION} VERSION_LESS 3.12)
   5   cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
   6 endif ()
   7
   8 # Determine if fmt is built as a subproject (using add_subdirectory)
   9 # or if it is the master project.
  10 if (NOT DEFINED FMT_MASTER_PROJECT)
  11   set(FMT_MASTER_PROJECT OFF)
  12   if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
  13     set(FMT_MASTER_PROJECT ON)
  14     message(STATUS "CMake version: ${CMAKE_VERSION}")
  15   endif ()
  16 endif ()
  17
  18 # Joins arguments and places the results in ${result_var}.
  19 function(join result_var)
  20   set(result "")
  21   foreach (arg ${ARGN})
  22     set(result "${result}${arg}")
  23   endforeach ()
  24   set(${result_var} "${result}" PARENT_SCOPE)
  25 endfunction()
  26
  27 # DEPRECATED! Should be merged into add_module_library.
  28 function(enable_module target)
  29   if (MSVC)
  30     set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
  31     target_compile_options(${target}
  32       PRIVATE /interface /ifcOutput ${BMI}
  33       INTERFACE /reference fmt=${BMI})
  34     set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
  35     set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
  36   endif ()
  37 endfunction()
  38
  39 set(FMT_USE_CMAKE_MODULES FALSE)
  40 if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.28 AND
  41     CMAKE_GENERATOR STREQUAL "Ninja")
  42   set(FMT_USE_CMAKE_MODULES TRUE)
  43 endif ()
  44
  45 # Adds a library compiled with C++20 module support.
  46 # `enabled` is a CMake variables that specifies if modules are enabled.
  47 # If modules are disabled `add_module_library` falls back to creating a
  48 # non-modular library.
  49 #
  50 # Usage:
  51 #   add_module_library(<name> [sources...] FALLBACK [sources...] [IF enabled])
  52 function(add_module_library name)
  53   cmake_parse_arguments(AML "" "IF" "FALLBACK" ${ARGN})
  54   set(sources ${AML_UNPARSED_ARGUMENTS})
  55
  56   add_library(${name})
  57   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
  58
  59   if (NOT ${${AML_IF}})
  60     # Create a non-modular library.
  61     target_sources(${name} PRIVATE ${AML_FALLBACK})
  62     set_target_properties(${name} PROPERTIES CXX_SCAN_FOR_MODULES OFF)
  63     return()
  64   endif ()
  65
  66   # Modules require C++20.
  67   target_compile_features(${name} PUBLIC cxx_std_20)
  68   if (CMAKE_COMPILER_IS_GNUCXX)
  69     target_compile_options(${name} PUBLIC -fmodules-ts)
  70   endif ()
  71
  72   target_compile_definitions(${name} PRIVATE FMT_MODULE)
  73
  74   if (FMT_USE_CMAKE_MODULES)
  75     target_sources(${name} PUBLIC FILE_SET fmt TYPE CXX_MODULES
  76                    FILES ${sources})
  77   else()
  78     # `std` is affected by CMake options and may be higher than C++20.
  79     get_target_property(std ${name} CXX_STANDARD)
  80
  81     if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  82       set(pcms)
  83       foreach (src ${sources})
  84         get_filename_component(pcm ${src} NAME_WE)
  85         set(pcm ${pcm}.pcm)
  86
  87         # Propagate -fmodule-file=*.pcm to targets that link with this library.
  88         target_compile_options(
  89           ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
  90
  91         # Use an absolute path to prevent target_link_libraries prepending -l
  92         # to it.
  93         set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
  94         add_custom_command(
  95           OUTPUT ${pcm}
  96           COMMAND ${CMAKE_CXX_COMPILER}
  97                   -std=c++${std} -x c++-module --precompile -c
  98                   -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
  99                   "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
 100           # Required by the -I generator expression above.
 101           COMMAND_EXPAND_LISTS
 102           DEPENDS ${src})
 103       endforeach ()
 104
 105       # Add .pcm files as sources to make sure they are built before the library.
 106       set(sources)
 107       foreach (pcm ${pcms})
 108         get_filename_component(pcm_we ${pcm} NAME_WE)
 109         set(obj ${pcm_we}.o)
 110         # Use an absolute path to prevent target_link_libraries prepending -l.
 111         set(sources ${sources} ${pcm} ${CMAKE_CURRENT_BINARY_DIR}/${obj})
 112         add_custom_command(
 113           OUTPUT ${obj}
 114           COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
 115                   -c -o ${obj} ${pcm}
 116           DEPENDS ${pcm})
 117       endforeach ()
 118     endif ()
 119     target_sources(${name} PRIVATE ${sources})
 120   endif()
 121 endfunction()
 122
 123 include(CMakeParseArguments)
 124
 125 # Sets a cache variable with a docstring joined from multiple arguments:
 126 #   set(<variable> <value>... CACHE <type> <docstring>...)
 127 # This allows splitting a long docstring for readability.
 128 function(set_verbose)
 129   # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
 130   # list instead.
 131   list(GET ARGN 0 var)
 132   list(REMOVE_AT ARGN 0)
 133   list(GET ARGN 0 val)
 134   list(REMOVE_AT ARGN 0)
 135   list(REMOVE_AT ARGN 0)
 136   list(GET ARGN 0 type)
 137   list(REMOVE_AT ARGN 0)
 138   join(doc ${ARGN})
 139   set(${var} ${val} CACHE ${type} ${doc})
 140 endfunction()
 141
 142 # Set the default CMAKE_BUILD_TYPE to Release.
 143 # This should be done before the project command since the latter can set
 144 # CMAKE_BUILD_TYPE itself (it does so for nmake).
 145 if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
 146   set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
 147               "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
 148               "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
 149 endif ()
 150
 151 project(FMT CXX)
 152 include(GNUInstallDirs)
 153 set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
 154             "Installation directory for include files, a relative path that "
 155             "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 156
 157 option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
 158 option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
 159        OFF)
 160
 161 # Options that control generation of various targets.
 162 option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
 163 option(FMT_INSTALL "Generate the install target." ON)
 164 option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
 165 option(FMT_FUZZ "Generate the fuzz target." OFF)
 166 option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
 167 option(FMT_OS "Include OS-specific APIs." ON)
 168 option(FMT_MODULE "Build a module instead of a traditional library." OFF)
 169 option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
 170 option(FMT_UNICODE "Enable Unicode support." ON)
 171
 172 if (FMT_TEST AND FMT_MODULE)
 173   # The tests require {fmt} to be compiled as traditional library
 174   message(STATUS "Testing is incompatible with build mode 'module'.")
 175 endif ()
 176 set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
 177 if (FMT_SYSTEM_HEADERS)
 178   set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
 179 endif ()
 180 if (CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
 181   set(FMT_TEST OFF)
 182   message(STATUS "MSDOS is incompatible with gtest")
 183 endif ()
 184
 185 # Get version from base.h
 186 file(READ include/fmt/base.h base_h)
 187 if (NOT base_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
 188   message(FATAL_ERROR "Cannot get FMT_VERSION from base.h.")
 189 endif ()
 190 # Use math to skip leading zeros if any.
 191 math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
 192 math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
 193 math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
 194 join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
 195                  ${CPACK_PACKAGE_VERSION_PATCH})
 196 message(STATUS "{fmt} version: ${FMT_VERSION}")
 197
 198 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 199
 200 if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
 201   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
 202 endif ()
 203
 204 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
 205   "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
 206
 207 include(CheckCXXCompilerFlag)
 208 include(JoinPaths)
 209
 210 if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
 211   set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
 212               "Preset for the export of private symbols")
 213   set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
 214                hidden default)
 215 endif ()
 216
 217 if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
 218   set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
 219               "Whether to add a compile flag to hide symbols of inline functions")
 220 endif ()
 221
 222 if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
 223   set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
 224       -Wold-style-cast -Wundef
 225       -Wredundant-decls -Wwrite-strings -Wpointer-arith
 226       -Wcast-qual -Wformat=2 -Wmissing-include-dirs
 227       -Wcast-align
 228       -Wctor-dtor-privacy -Wdisabled-optimization
 229       -Winvalid-pch -Woverloaded-virtual
 230       -Wconversion -Wundef
 231       -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
 232   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
 233       set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
 234          -Wno-dangling-else -Wno-unused-local-typedefs)
 235   endif ()
 236   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
 237       set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
 238           -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
 239           -Wvector-operation-performance -Wsized-deallocation -Wshadow)
 240   endif ()
 241   if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
 242       set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
 243           -Wnull-dereference -Wduplicated-cond)
 244   endif ()
 245   set(WERROR_FLAG -Werror)
 246 endif ()
 247
 248 if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 249   set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
 250       -Wdeprecated -Wweak-vtables -Wshadow
 251       -Wno-gnu-zero-variadic-macro-arguments)
 252   check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
 253   if (HAS_NULLPTR_WARNING)
 254     set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
 255         -Wzero-as-null-pointer-constant)
 256   endif ()
 257   set(WERROR_FLAG -Werror)
 258 endif ()
 259
 260 if (MSVC)
 261   set(PEDANTIC_COMPILE_FLAGS /W3)
 262   set(WERROR_FLAG /WX)
 263 endif ()
 264
 265 if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
 266   # If Microsoft SDK is installed create script run-msbuild.bat that
 267   # calls SetEnv.cmd to set up build environment and runs msbuild.
 268   # It is useful when building Visual Studio projects with the SDK
 269   # toolchain rather than Visual Studio.
 270   include(FindSetEnv)
 271   if (WINSDK_SETENV)
 272     set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
 273   endif ()
 274   # Set FrameworkPathOverride to get rid of MSB3644 warnings.
 275   join(netfxpath
 276        "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
 277        ".NETFramework\\v4.0")
 278   file(WRITE run-msbuild.bat "
 279     ${MSBUILD_SETUP}
 280     ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
 281 endif ()
 282
 283 function(add_headers VAR)
 284   set(headers ${${VAR}})
 285   foreach (header ${ARGN})
 286     set(headers ${headers} include/fmt/${header})
 287   endforeach()
 288   set(${VAR} ${headers} PARENT_SCOPE)
 289 endfunction()
 290
 291 # Define the fmt library, its includes and the needed defines.
 292 add_headers(FMT_HEADERS args.h base.h chrono.h color.h compile.h core.h format.h
 293                         format-inl.h os.h ostream.h printf.h ranges.h std.h
 294                         xchar.h)
 295 set(FMT_SOURCES src/format.cc)
 296
 297 add_module_library(fmt src/fmt.cc FALLBACK
 298                    ${FMT_SOURCES} ${FMT_HEADERS} README.md ChangeLog.md
 299                    IF FMT_MODULE)
 300 add_library(fmt::fmt ALIAS fmt)
 301 if (FMT_MODULE)
 302   enable_module(fmt)
 303 elseif (FMT_OS)
 304   target_sources(fmt PRIVATE src/os.cc)
 305 else()
 306   target_compile_definitions(fmt PRIVATE FMT_OS=0)
 307 endif ()
 308
 309 if (FMT_WERROR)
 310   target_compile_options(fmt PRIVATE ${WERROR_FLAG})
 311 endif ()
 312 if (FMT_PEDANTIC)
 313   target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
 314 endif ()
 315
 316 if (cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
 317   target_compile_features(fmt PUBLIC cxx_std_11)
 318 else ()
 319   message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
 320 endif ()
 321
 322 target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
 323   $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 324   $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
 325
 326 set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
 327
 328 set_target_properties(fmt PROPERTIES
 329   VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
 330   PUBLIC_HEADER "${FMT_HEADERS}"
 331   DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}"
 332
 333   # Workaround for Visual Studio 2017:
 334   # Ensure the .pdb is created with the same name and in the same directory
 335   # as the .lib. Newer VS versions already do this by default, but there is no
 336   # harm in setting it for those too. Ignored by other generators.
 337   COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
 338   COMPILE_PDB_NAME "fmt"
 339   COMPILE_PDB_NAME_DEBUG "fmt${FMT_DEBUG_POSTFIX}")
 340
 341 # Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
 342 # property because it's not set by default.
 343 set(FMT_LIB_NAME fmt)
 344 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
 345   set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
 346 endif ()
 347
 348 if (BUILD_SHARED_LIBS)
 349   target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
 350 endif ()
 351 if (FMT_SAFE_DURATION_CAST)
 352   target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
 353 endif ()
 354
 355 add_library(fmt-header-only INTERFACE)
 356 add_library(fmt::fmt-header-only ALIAS fmt-header-only)
 357
 358 if (NOT MSVC)
 359   # Unicode is always supported on compilers other than MSVC.
 360 elseif (FMT_UNICODE)
 361   # Unicode support requires compiling with /utf-8.
 362   target_compile_options(fmt PUBLIC $<$<COMPILE_LANGUAGE:CXX>:/utf-8>)
 363   target_compile_options(fmt-header-only INTERFACE $<$<COMPILE_LANGUAGE:CXX>:/utf-8>)
 364 else ()
 365   target_compile_definitions(fmt PUBLIC FMT_UNICODE=0)
 366 endif ()
 367
 368 target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
 369 target_compile_features(fmt-header-only INTERFACE cxx_std_11)
 370
 371 target_include_directories(fmt-header-only
 372   ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
 373   $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
 374   $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
 375
 376 # Install targets.
 377 if (FMT_INSTALL)
 378   include(CMakePackageConfigHelpers)
 379   set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
 380               "Installation directory for cmake files, a relative path that "
 381               "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
 382               "path.")
 383   set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
 384   set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
 385   set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
 386   set(targets_export_name fmt-targets)
 387
 388   set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
 389               "Installation directory for libraries, a relative path that "
 390               "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 391
 392   set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
 393               "Installation directory for pkgconfig (.pc) files, a relative "
 394               "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
 395               "absolute path.")
 396
 397   # Generate the version, config and target files into the build directory.
 398   write_basic_package_version_file(
 399     ${version_config}
 400     VERSION ${FMT_VERSION}
 401     COMPATIBILITY AnyNewerVersion)
 402
 403   join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
 404   join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
 405
 406   configure_file(
 407     "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
 408     "${pkgconfig}"
 409     @ONLY)
 410   configure_package_config_file(
 411     ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
 412     ${project_config}
 413     INSTALL_DESTINATION ${FMT_CMAKE_DIR})
 414
 415   set(INSTALL_TARGETS fmt fmt-header-only)
 416
 417   set(INSTALL_FILE_SET)
 418   if (FMT_USE_CMAKE_MODULES)
 419     set(INSTALL_FILE_SET FILE_SET fmt DESTINATION "${FMT_INC_DIR}/fmt")
 420   endif()
 421
 422   # Install the library and headers.
 423   install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
 424           LIBRARY DESTINATION ${FMT_LIB_DIR}
 425           ARCHIVE DESTINATION ${FMT_LIB_DIR}
 426           PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
 427           RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
 428           ${INSTALL_FILE_SET})
 429
 430   # Use a namespace because CMake provides better diagnostics for namespaced
 431   # imported targets.
 432   export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
 433          FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
 434
 435   # Install version, config and target files.
 436   install(
 437     FILES ${project_config} ${version_config}
 438     DESTINATION ${FMT_CMAKE_DIR})
 439   install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
 440           NAMESPACE fmt::)
 441
 442   install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
 443 endif ()
 444
 445 function(add_doc_target)
 446   find_program(DOXYGEN doxygen
 447     PATHS "$ENV{ProgramFiles}/doxygen/bin"
 448           "$ENV{ProgramFiles\(x86\)}/doxygen/bin")
 449   if (NOT DOXYGEN)
 450     message(STATUS "Target 'doc' disabled because doxygen not found")
 451     return ()
 452   endif ()
 453
 454   find_program(MKDOCS mkdocs)
 455   if (NOT MKDOCS)
 456     message(STATUS "Target 'doc' disabled because mkdocs not found")
 457     return ()
 458   endif ()
 459
 460   set(sources )
 461   foreach (source api.md index.md syntax.md get-started.md fmt.css fmt.js)
 462     set(sources ${sources} doc/${source})
 463   endforeach()
 464
 465   add_custom_target(
 466     doc
 467     COMMAND
 468       ${CMAKE_COMMAND}
 469         -E env PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}/support/python
 470         ${MKDOCS} build -f ${CMAKE_CURRENT_SOURCE_DIR}/support/mkdocs.yml
 471         # MkDocs requires the site dir to be outside of the doc dir.
 472                         --site-dir ${CMAKE_CURRENT_BINARY_DIR}/doc-html
 473                         --no-directory-urls
 474     SOURCES ${sources})
 475
 476   include(GNUInstallDirs)
 477   install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc-html/
 478           DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/doc/fmt OPTIONAL)
 479 endfunction()
 480
 481 if (FMT_DOC)
 482   add_doc_target()
 483 endif ()
 484
 485 if (FMT_TEST)
 486   enable_testing()
 487   add_subdirectory(test)
 488 endif ()
 489
 490 # Control fuzzing independent of the unit tests.
 491 if (FMT_FUZZ)
 492   add_subdirectory(test/fuzzing)
 493
 494   # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
 495   # mode and make fuzzing practically possible. It is similar to
 496   # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
 497   # avoid interfering with fuzzing of projects that use {fmt}.
 498   # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
 499   target_compile_definitions(fmt PUBLIC FMT_FUZZ)
 500 endif ()
 501
 502 set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
 503 if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
 504   # Get the list of ignored files from .gitignore.
 505   file (STRINGS ${gitignore} lines)
 506   list(REMOVE_ITEM lines /doc/html)
 507   foreach (line ${lines})
 508     string(REPLACE "." "[.]" line "${line}")
 509     string(REPLACE "*" ".*" line "${line}")
 510     set(ignored_files ${ignored_files} "${line}$" "${line}/")
 511   endforeach ()
 512   set(ignored_files ${ignored_files} /.git /build/doxyxml .vagrant)
 513
 514   set(CPACK_SOURCE_GENERATOR ZIP)
 515   set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
 516   set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
 517   set(CPACK_PACKAGE_NAME fmt)
 518   set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.md)
 519   include(CPack)
 520 endif ()