feat update

CMakeLists.txt

@@ -187,14 +187,16 @@ set(TILE_SRCS
     # "tile/rpc/server.cc"
 )
 
-list(APPEND ASM_SRCS "tile/fiber/detail/asm/ucontext_aarch64.S"
+list(
-     "tile/fiber/detail/asm/ucontext_arm.S"
+  APPEND
-     "tile/fiber/detail/asm/ucontext_riscv64.S"
+  ASM_SRCS
-     "tile/fiber/detail/asm/ucontext_mips64.S"
+  "tile/fiber/detail/asm/ucontext_aarch64.S"
-     "tile/fiber/detail/asm/ucontext_mips32.S"
+  "tile/fiber/detail/asm/ucontext_arm.S"
-     "tile/fiber/detail/asm/ucontext_x64.S"
+  "tile/fiber/detail/asm/ucontext_riscv64.S"
-     "tile/fiber/detail/asm/ucontext_x86.S"
+  "tile/fiber/detail/asm/ucontext_mips64.S"
-)
+  "tile/fiber/detail/asm/ucontext_mips32.S"
+  "tile/fiber/detail/asm/ucontext_x64.S"
+  "tile/fiber/detail/asm/ucontext_x86.S")
 set_source_files_properties(${ASM_SRCS} PROPERTIES LANGUAGE C)
 
 if((NOT TILE_HAVE_GETIFADDRS) OR (NOT TILE_HAVE_FREEIFADDRS))
@@ -220,10 +222,9 @@ target_link_libraries(
   PUBLIC # -Wl,--start-group
          zlib gflags::gflags glog::glog
          # -Wl,--end-group
-         libcurl fmt::fmt Threads::Threads)
+         libcurl fmt Threads::Threads)
-if(
+if((CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64") OR (CMAKE_SYSTEM_PROCESSOR MATCHES
-(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64") OR
+                                                  "mips*"))
-(CMAKE_SYSTEM_PROCESSOR MATCHES "mips*"))
   if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     target_link_libraries(tile PUBLIC atomic)
   endif()
@@ -272,7 +273,7 @@ if(TILE_BUILD_TESTS)
 
   tile_add_test(base_internal_meta_test "tile/base/internal/meta_test.cc")
   # tile_add_test(net_internal_http_engine_test
-  #               "tile/net/internal/http_engine_test.cc")
+  # "tile/net/internal/http_engine_test.cc")
   tile_add_test(net_internal_http_task_test
                 "tile/net/internal/http_task_test.cc")
   tile_add_test(net_http_http_client_test "tile/net/http/http_client_test.cc")

third_party/fmt/CMakeLists.txt

@@ -1,48 +1,50 @@
 cmake_minimum_required(VERSION 3.8...3.26)
 
 # Fallback for using newer policies on CMake <3.12.
-if (${CMAKE_VERSION} VERSION_LESS 3.12)
+if(${CMAKE_VERSION} VERSION_LESS 3.12)
   cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-endif ()
+endif()
 
-# Determine if fmt is built as a subproject (using add_subdirectory)
+# Determine if fmt is built as a subproject (using add_subdirectory) or if it is
-# or if it is the master project.
+# the master project.
-if (NOT DEFINED FMT_MASTER_PROJECT)
+if(NOT DEFINED FMT_MASTER_PROJECT)
   set(FMT_MASTER_PROJECT OFF)
-  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+  if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     set(FMT_MASTER_PROJECT ON)
     message(STATUS "CMake version: ${CMAKE_VERSION}")
-  endif ()
+  endif()
-endif ()
+endif()
 
 # Joins arguments and places the results in ${result_var}.
 function(join result_var)
   set(result "")
-  foreach (arg ${ARGN})
+  foreach(arg ${ARGN})
     set(result "${result}${arg}")
-  endforeach ()
+  endforeach()
-  set(${result_var} "${result}" PARENT_SCOPE)
+  set(${result_var}
+      "${result}"
+      PARENT_SCOPE)
 endfunction()
 
 # DEPRECATED! Should be merged into add_module_library.
 function(enable_module target)
-  if (MSVC)
+  if(MSVC)
     set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
-    target_compile_options(${target}
+    target_compile_options(
+      ${target}
       PRIVATE /interface /ifcOutput ${BMI}
       INTERFACE /reference fmt=${BMI})
     set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
     set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
-  endif ()
+  endif()
 endfunction()
 
-# Adds a library compiled with C++20 module support.
+# Adds a library compiled with C++20 module support. `enabled` is a CMake
-# `enabled` is a CMake variables that specifies if modules are enabled.
+# variables that specifies if modules are enabled. If modules are disabled
-# If modules are disabled `add_module_library` falls back to creating a
+# `add_module_library` falls back to creating a non-modular library.
-# non-modular library.
 #
-# Usage:
+# Usage: add_module_library(<name> [sources...] FALLBACK [sources...] [IF
-#   add_module_library(<name> [sources...] FALLBACK [sources...] [IF enabled])
+# enabled])
 function(add_module_library name)
   cmake_parse_arguments(AML "" "IF" "FALLBACK" ${ARGN})
   set(sources ${AML_UNPARSED_ARGUMENTS})
@@ -50,24 +52,24 @@ function(add_module_library name)
   add_library(${name})
   set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
 
-  if (NOT ${${AML_IF}})
+  if(NOT ${${AML_IF}})
     # Create a non-modular library.
     target_sources(${name} PRIVATE ${AML_FALLBACK})
     return()
-  endif ()
+  endif()
 
   # Modules require C++20.
   target_compile_features(${name} PUBLIC cxx_std_20)
-  if (CMAKE_COMPILER_IS_GNUCXX)
+  if(CMAKE_COMPILER_IS_GNUCXX)
     target_compile_options(${name} PUBLIC -fmodules-ts)
-  endif ()
+  endif()
 
   # `std` is affected by CMake options and may be higher than C++20.
   get_target_property(std ${name} CXX_STANDARD)
 
-  if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(pcms)
-    foreach (src ${sources})
+    foreach(src ${sources})
       get_filename_component(pcm ${src} NAME_WE)
       set(pcm ${pcm}.pcm)
 
@@ -75,23 +77,23 @@ function(add_module_library name)
       target_compile_options(
         ${name} PUBLIC -fmodule-file=${CMAKE_CURRENT_BINARY_DIR}/${pcm})
 
-      # Use an absolute path to prevent target_link_libraries prepending -l
+      # Use an absolute path to prevent target_link_libraries prepending -l to
-      # to it.
+      # it.
       set(pcms ${pcms} ${CMAKE_CURRENT_BINARY_DIR}/${pcm})
       add_custom_command(
         OUTPUT ${pcm}
-        COMMAND ${CMAKE_CXX_COMPILER}
+        COMMAND
-                -std=c++${std} -x c++-module --precompile -c
+          ${CMAKE_CXX_COMPILER} -std=c++${std} -x c++-module --precompile -c -o
-                -o ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
+          ${pcm} ${CMAKE_CURRENT_SOURCE_DIR}/${src}
-                "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
+          "-I$<JOIN:$<TARGET_PROPERTY:${name},INCLUDE_DIRECTORIES>,;-I>"
         # Required by the -I generator expression above.
         COMMAND_EXPAND_LISTS
         DEPENDS ${src})
-    endforeach ()
+    endforeach()
 
     # Add .pcm files as sources to make sure they are built before the library.
     set(sources)
-    foreach (pcm ${pcms})
+    foreach(pcm ${pcms})
       get_filename_component(pcm_we ${pcm} NAME_WE)
       set(obj ${pcm_we}.o)
       # Use an absolute path to prevent target_link_libraries prepending -l.
@@ -101,16 +103,16 @@ function(add_module_library name)
         COMMAND ${CMAKE_CXX_COMPILER} $<TARGET_PROPERTY:${name},COMPILE_OPTIONS>
                 -c -o ${obj} ${pcm}
         DEPENDS ${pcm})
-    endforeach ()
+    endforeach()
-  endif ()
+  endif()
   target_sources(${name} PRIVATE ${sources})
 endfunction()
 
 include(CMakeParseArguments)
 
 # Sets a cache variable with a docstring joined from multiple arguments:
-#   set(<variable> <value>... CACHE <type> <docstring>...)
+# set(<variable> <value>... CACHE <type> <docstring>...) This allows splitting a
-# This allows splitting a long docstring for readability.
+# long docstring for readability.
 function(set_verbose)
   # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
   # list instead.
@@ -122,23 +124,27 @@ function(set_verbose)
   list(GET ARGN 0 type)
   list(REMOVE_AT ARGN 0)
   join(doc ${ARGN})
-  set(${var} ${val} CACHE ${type} ${doc})
+  set(${var}
+      ${val}
+      CACHE ${type} ${doc})
 endfunction()
 
-# Set the default CMAKE_BUILD_TYPE to Release.
+# Set the default CMAKE_BUILD_TYPE to Release. This should be done before the
-# This should be done before the project command since the latter can set
+# project command since the latter can set CMAKE_BUILD_TYPE itself (it does so
-# CMAKE_BUILD_TYPE itself (it does so for nmake).
+# for nmake).
-if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
+if(FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
-  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
+  set_verbose(
-              "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
+    CMAKE_BUILD_TYPE Release CACHE STRING
-              "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+    "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
-endif ()
+    "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+endif()
 
 project(FMT CXX)
 include(GNUInstallDirs)
-set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
+set_verbose(
-            "Installation directory for include files, a relative path that "
+  FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
-            "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+  "Installation directory for include files, a relative path that "
+  "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 
 option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
 option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
@@ -154,187 +160,246 @@ option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
 option(FMT_MODULE "Build a module instead of a traditional library." OFF)
 option(FMT_SYSTEM_HEADERS "Expose headers with marking them as system." OFF)
 
-if (FMT_TEST AND FMT_MODULE)
+if(FMT_TEST AND FMT_MODULE)
   # The tests require {fmt} to be compiled as traditional library
   message(STATUS "Testing is incompatible with build mode 'module'.")
-endif ()
+endif()
 set(FMT_SYSTEM_HEADERS_ATTRIBUTE "")
-if (FMT_SYSTEM_HEADERS)
+if(FMT_SYSTEM_HEADERS)
   set(FMT_SYSTEM_HEADERS_ATTRIBUTE SYSTEM)
-endif ()
+endif()
-if (CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
+if(CMAKE_SYSTEM_NAME STREQUAL "MSDOS")
   set(FMT_TEST OFF)
   message(STATUS "MSDOS is incompatible with gtest")
-endif ()
+endif()
 
 # Get version from core.h
 file(READ include/fmt/core.h core_h)
-if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+if(NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
   message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
-endif ()
+endif()
 # Use math to skip leading zeros if any.
 math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
 math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
 math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
 join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
-                 ${CPACK_PACKAGE_VERSION_PATCH})
+     ${CPACK_PACKAGE_VERSION_PATCH})
 message(STATUS "Version: ${FMT_VERSION}")
 
 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
 
-if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+if(NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
   set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
-endif ()
+endif()
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
+                      "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
 
 include(CheckCXXCompilerFlag)
 include(JoinPaths)
 
-if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+if(FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
   set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
               "Preset for the export of private symbols")
-  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
+  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS hidden
-               hidden default)
+                                                          default)
-endif ()
+endif()
 
-if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
+if(FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
-  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
+  set_verbose(
-              "Whether to add a compile flag to hide symbols of inline functions")
+    CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
-endif ()
+    "Whether to add a compile flag to hide symbols of inline functions")
+endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
+  set(PEDANTIC_COMPILE_FLAGS
-      -Wold-style-cast -Wundef
+      -pedantic-errors
-      -Wredundant-decls -Wwrite-strings -Wpointer-arith
+      -Wall
-      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
+      -Wextra
+      -pedantic
+      -Wold-style-cast
+      -Wundef
+      -Wredundant-decls
+      -Wwrite-strings
+      -Wpointer-arith
+      -Wcast-qual
+      -Wformat=2
+      -Wmissing-include-dirs
       -Wcast-align
-      -Wctor-dtor-privacy -Wdisabled-optimization
+      -Wctor-dtor-privacy
-      -Winvalid-pch -Woverloaded-virtual
+      -Wdisabled-optimization
-      -Wconversion -Wundef
+      -Winvalid-pch
-      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
+      -Woverloaded-virtual
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+      -Wconversion
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+      -Wundef
-         -Wno-dangling-else -Wno-unused-local-typedefs)
+      -Wno-ctor-dtor-privacy
-  endif ()
+      -Wno-format-nonliteral)
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-dangling-else
-          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
+                               -Wno-unused-local-typedefs)
-          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
+  endif()
-  endif ()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
-  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+    set(PEDANTIC_COMPILE_FLAGS
-      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
+        ${PEDANTIC_COMPILE_FLAGS}
-          -Wnull-dereference -Wduplicated-cond)
+        -Wdouble-promotion
-  endif ()
+        -Wtrampolines
+        -Wzero-as-null-pointer-constant
+        -Wuseless-cast
+        -Wvector-operation-performance
+        -Wsized-deallocation
+        -Wshadow)
+  endif()
+  if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
+                               -Wnull-dereference -Wduplicated-cond)
+  endif()
   set(WERROR_FLAG -Werror)
-endif ()
+endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
+  set(PEDANTIC_COMPILE_FLAGS
-      -Wdeprecated -Wweak-vtables -Wshadow
+      -Wall
+      -Wextra
+      -pedantic
+      -Wconversion
+      -Wundef
+      -Wdeprecated
+      -Wweak-vtables
+      -Wshadow
       -Wno-gnu-zero-variadic-macro-arguments)
   check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
-  if (HAS_NULLPTR_WARNING)
+  if(HAS_NULLPTR_WARNING)
     set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
-        -Wzero-as-null-pointer-constant)
+                               -Wzero-as-null-pointer-constant)
-  endif ()
+  endif()
   set(WERROR_FLAG -Werror)
-endif ()
+endif()
 
-if (MSVC)
+if(MSVC)
   set(PEDANTIC_COMPILE_FLAGS /W3)
   set(WERROR_FLAG /WX)
-endif ()
+endif()
 
-if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
+if(FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
-  # If Microsoft SDK is installed create script run-msbuild.bat that
+  # If Microsoft SDK is installed create script run-msbuild.bat that calls
-  # calls SetEnv.cmd to set up build environment and runs msbuild.
+  # SetEnv.cmd to set up build environment and runs msbuild. It is useful when
-  # It is useful when building Visual Studio projects with the SDK
+  # building Visual Studio projects with the SDK toolchain rather than Visual
-  # toolchain rather than Visual Studio.
+  # Studio.
   include(FindSetEnv)
-  if (WINSDK_SETENV)
+  if(WINSDK_SETENV)
     set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
-  endif ()
+  endif()
   # Set FrameworkPathOverride to get rid of MSB3644 warnings.
   join(netfxpath
        "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
        ".NETFramework\\v4.0")
-  file(WRITE run-msbuild.bat "
+  file(
+    WRITE run-msbuild.bat
+    "
     ${MSBUILD_SETUP}
     ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
-endif ()
+endif()
 
 function(add_headers VAR)
   set(headers ${${VAR}})
-  foreach (header ${ARGN})
+  foreach(header ${ARGN})
     set(headers ${headers} include/fmt/${header})
   endforeach()
-  set(${VAR} ${headers} PARENT_SCOPE)
+  set(${VAR}
+      ${headers}
+      PARENT_SCOPE)
 endfunction()
 
 # Define the fmt library, its includes and the needed defines.
-add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
+add_headers(
-                        format-inl.h os.h ostream.h printf.h ranges.h std.h
+  FMT_HEADERS
-                        xchar.h)
+  args.h
+  chrono.h
+  color.h
+  compile.h
+  core.h
+  format.h
+  format-inl.h
+  os.h
+  ostream.h
+  printf.h
+  ranges.h
+  std.h
+  xchar.h)
 set(FMT_SOURCES src/format.cc)
-if (FMT_OS)
+if(FMT_OS)
   set(FMT_SOURCES ${FMT_SOURCES} src/os.cc)
-endif ()
+endif()
 
-add_module_library(fmt src/fmt.cc FALLBACK
+add_module_library(
-                   ${FMT_SOURCES} ${FMT_HEADERS} README.md ChangeLog.md
+  fmt
-                   IF FMT_MODULE)
+  src/fmt.cc
+  FALLBACK
+  ${FMT_SOURCES}
+  ${FMT_HEADERS}
+  README.md
+  ChangeLog.md
+  IF
+  FMT_MODULE)
 add_library(fmt::fmt ALIAS fmt)
-if (FMT_MODULE)
+if(FMT_MODULE)
   enable_module(fmt)
-endif ()
+endif()
 
-if (FMT_WERROR)
+if(FMT_WERROR)
   target_compile_options(fmt PRIVATE ${WERROR_FLAG})
-endif ()
+endif()
-if (FMT_PEDANTIC)
+if(FMT_PEDANTIC)
   target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
-endif ()
+endif()
 
-if (cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
+if(cxx_std_11 IN_LIST CMAKE_CXX_COMPILE_FEATURES)
   target_compile_features(fmt PUBLIC cxx_std_11)
-else ()
+else()
   message(WARNING "Feature cxx_std_11 is unknown for the CXX compiler")
-endif ()
+endif()
 
-target_include_directories(fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE} PUBLIC
+target_include_directories(
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  fmt ${FMT_SYSTEM_HEADERS_ATTRIBUTE}
-  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+  PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+         $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
 
-set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
+set(FMT_DEBUG_POSTFIX
+    d
+    CACHE STRING "Debug library postfix.")
 
-set_target_properties(fmt PROPERTIES
+set_target_properties(
-  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
+  fmt
-  PUBLIC_HEADER "${FMT_HEADERS}"
+  PROPERTIES VERSION ${FMT_VERSION}
-  DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}"
+             SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
-
+             PUBLIC_HEADER "${FMT_HEADERS}"
-  # Workaround for Visual Studio 2017:
+             DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}"
-  # Ensure the .pdb is created with the same name and in the same directory
+             # Workaround for Visual Studio 2017:
-  # as the .lib. Newer VS versions already do this by default, but there is no
+             # Ensure the .pdb is created with the same name and in the same
-  # harm in setting it for those too. Ignored by other generators.
+             # directory
-  COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+             # as the .lib. Newer VS versions already do this by default, but
-  COMPILE_PDB_NAME "fmt"
+             # there is no
-  COMPILE_PDB_NAME_DEBUG "fmt${FMT_DEBUG_POSTFIX}")
+             # harm in setting it for those too. Ignored by other generators.
+             COMPILE_PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+             COMPILE_PDB_NAME "fmt"
+             COMPILE_PDB_NAME_DEBUG "fmt${FMT_DEBUG_POSTFIX}")
 
 # Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
 # property because it's not set by default.
 set(FMT_LIB_NAME fmt)
-if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
   set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
-endif ()
+endif()
 
-if (BUILD_SHARED_LIBS)
+if(BUILD_SHARED_LIBS)
-  target_compile_definitions(fmt PRIVATE FMT_LIB_EXPORT INTERFACE FMT_SHARED)
+  target_compile_definitions(
-endif ()
+    fmt
-if (FMT_SAFE_DURATION_CAST)
+    PRIVATE FMT_LIB_EXPORT
+    INTERFACE FMT_SHARED)
+endif()
+if(FMT_SAFE_DURATION_CAST)
   target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
-endif ()
+endif()
 
 add_library(fmt-header-only INTERFACE)
 add_library(fmt::fmt-header-only ALIAS fmt-header-only)
@@ -342,31 +407,40 @@ add_library(fmt::fmt-header-only ALIAS fmt-header-only)
 target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
 target_compile_features(fmt-header-only INTERFACE cxx_std_11)
 
-target_include_directories(fmt-header-only
+target_include_directories(
-  ${FMT_SYSTEM_HEADERS_ATTRIBUTE} INTERFACE
+  fmt-header-only ${FMT_SYSTEM_HEADERS_ATTRIBUTE}
-  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  INTERFACE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
-  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+            $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
 
 # Install targets.
-if (FMT_INSTALL)
+if(FMT_INSTALL)
   include(CMakePackageConfigHelpers)
-  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
+  set_verbose(
-              "Installation directory for cmake files, a relative path that "
+    FMT_CMAKE_DIR
-              "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
+    ${CMAKE_INSTALL_LIBDIR}/cmake/fmt
-              "path.")
+    CACHE
+    STRING
+    "Installation directory for cmake files, a relative path that "
+    "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
+    "path.")
   set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
   set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
   set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
   set(targets_export_name fmt-targets)
 
-  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
+  set_verbose(
-              "Installation directory for libraries, a relative path that "
+    FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
-              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+    "Installation directory for libraries, a relative path that "
+    "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
 
-  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE STRING
+  set_verbose(
-              "Installation directory for pkgconfig (.pc) files, a relative "
+    FMT_PKGCONFIG_DIR
-              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
+    ${CMAKE_INSTALL_LIBDIR}/pkgconfig
-              "absolute path.")
+    CACHE
+    STRING
+    "Installation directory for pkgconfig (.pc) files, a relative "
+    "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
+    "absolute path.")
 
   # Generate the version, config and target files into the build directory.
   write_basic_package_version_file(
@@ -377,72 +451,80 @@ if (FMT_INSTALL)
   join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
   join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
 
-  configure_file(
+  configure_file("${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in" "${pkgconfig}"
-    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
+                 @ONLY)
-    "${pkgconfig}"
-    @ONLY)
   configure_package_config_file(
-    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
+    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in ${project_config}
-    ${project_config}
     INSTALL_DESTINATION ${FMT_CMAKE_DIR})
 
   set(INSTALL_TARGETS fmt fmt-header-only)
 
   # Install the library and headers.
-  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
+  install(
-          LIBRARY DESTINATION ${FMT_LIB_DIR}
+    TARGETS ${INSTALL_TARGETS}
-          ARCHIVE DESTINATION ${FMT_LIB_DIR}
+    EXPORT ${targets_export_name}
-          PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
+    LIBRARY DESTINATION ${FMT_LIB_DIR}
-          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+    ARCHIVE DESTINATION ${FMT_LIB_DIR}
+    PUBLIC_HEADER DESTINATION "${FMT_INC_DIR}/fmt"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
   # Use a namespace because CMake provides better diagnostics for namespaced
   # imported targets.
-  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
+  export(
-         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+    TARGETS ${INSTALL_TARGETS}
+    NAMESPACE fmt::
+    FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
 
   # Install version, config and target files.
+  install(FILES ${project_config} ${version_config}
+          DESTINATION ${FMT_CMAKE_DIR})
   install(
-    FILES ${project_config} ${version_config}
+    EXPORT ${targets_export_name}
-    DESTINATION ${FMT_CMAKE_DIR})
+    DESTINATION ${FMT_CMAKE_DIR}
-  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
+    NAMESPACE fmt::)
-          NAMESPACE fmt::)
 
   install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
-endif ()
+endif()
 
-if (FMT_DOC)
+if(FMT_DOC)
   add_subdirectory(doc)
-endif ()
+endif()
 
-if (FMT_TEST)
+if(FMT_TEST)
   enable_testing()
   add_subdirectory(test)
-endif ()
+endif()
 
 # Control fuzzing independent of the unit tests.
-if (FMT_FUZZ)
+if(FMT_FUZZ)
   add_subdirectory(test/fuzzing)
 
-  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
+  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing mode
-  # mode and make fuzzing practically possible. It is similar to
+  # and make fuzzing practically possible. It is similar to
-  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
+  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to avoid
-  # avoid interfering with fuzzing of projects that use {fmt}.
+  # interfering with fuzzing of projects that use {fmt}. See also
-  # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
+  # https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
   target_compile_definitions(fmt PUBLIC FMT_FUZZ)
-endif ()
+endif()
 
 set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
-if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
+if(FMT_MASTER_PROJECT AND EXISTS ${gitignore})
   # Get the list of ignored files from .gitignore.
-  file (STRINGS ${gitignore} lines)
+  file(STRINGS ${gitignore} lines)
   list(REMOVE_ITEM lines /doc/html)
-  foreach (line ${lines})
+  foreach(line ${lines})
     string(REPLACE "." "[.]" line "${line}")
     string(REPLACE "*" ".*" line "${line}")
     set(ignored_files ${ignored_files} "${line}$" "${line}/")
-  endforeach ()
+  endforeach()
-  set(ignored_files ${ignored_files}
+  set(ignored_files
-    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)
+      ${ignored_files}
+      /.git
+      /breathe
+      /format-benchmark
+      sphinx/
+      .buildinfo
+      .doctrees)
 
   set(CPACK_SOURCE_GENERATOR ZIP)
   set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
@@ -450,4 +532,4 @@ if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
   set(CPACK_PACKAGE_NAME fmt)
   set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.md)
   include(CPack)
-endif ()
+endif()