CMakeLists.txt

# CMake 3.30 is required for C++23 `import std` support;
cmake_minimum_required(VERSION 3.30...4.3)

include(cmake/prelude.cmake)

option(
    CMAKE_CXX_SCAN_FOR_MODULES
    "Whether to scan C++ source files for module dependencies"
    ON
)
option(BUILD_SHARED_LIBS "Build using shared libraries" NO)

if(CMAKE_CXX_SCAN_FOR_MODULES AND CMAKE_VERSION VERSION_LESS 4.3)
    # Set experimental flag to enable `import std` support from CMake.
    # This must be enabled before C++ language support.
    set(CMAKE_EXPERIMENTAL_CXX_IMPORT_STD
        "d0edc3af-4c50-42ea-a356-e2862fe7a444"
    )
endif()

#==================================================
project(
    fmt
    VERSION 12.1.0.2
    DESCRIPTION "A modern formatting library"
    HOMEPAGE_URL https://fmt.dev/12.0/
    LANGUAGES CXX
)
#==================================================

include(cmake/variables.cmake)

if(NOT DEFINED CMAKE_CXX_STANDARD)
    set(CMAKE_CXX_STANDARD 23)
endif()
set(CMAKE_CXX_EXTENSIONS ON)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

set(CMAKE_DEBUG_POSTFIX D)
set(CMAKE_SKIP_TEST_ALL_DEPENDENCY OFF)

set(CPPdefinitions)
option(FMT_SEPARATE_COMPILATION "build fmt lib too" ${PROJECT_IS_TOP_LEVEL})
option(
    FMT_MODULE
    "Build CXX_MODULE fmt if possible"
    ${CMAKE_CXX_SCAN_FOR_MODULES}
)
option(FMT_IMPORT_STD "Import the module std")

if(CMAKE_GENERATOR STREQUAL "Ninja" AND FMT_MODULE)
    list(APPEND CPPdefinitions FMT_MODULE)
    if(
        CMAKE_CXX_COMPILER_ID STREQUAL "Clang"
        AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19.0
    )
        if(APPLE)
            execute_process(
                OUTPUT_VARIABLE LLVM_PREFIX
                COMMAND brew --prefix llvm
                COMMAND_ECHO STDOUT
            )
            string(STRIP ${LLVM_PREFIX} LLVM_PREFIX)
        elseif(LINUX)
            set(LLVM_PREFIX $ENV{LLVM_DIR})
        endif()

        # # /usr/local/opt/llvm/share/libc++/v1/std.cppm
        # # or /usr/lib/llvm-19/share/libc++/v1/std.cppm
        # set(LLVM_LIBC_SOURCE ${LLVM_PREFIX}/share/libc++/v1 CACHE PATH "")
        # file(REAL_PATH ${LLVM_PREFIX} LLVM_DIR)
        # set(LLVM_DIR ${LLVM_DIR} CACHE PATH "")
        # message(STATUS "LLVM_DIR=${LLVM_DIR}")

        # add_link_options(-L${LLVM_DIR}/lib/c++)
        add_compile_options(-stdlib=libc++)
        add_link_options(-stdlib=libc++)
    elseif(
        CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
        AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15.0
    )
        # XXX NO! add_compile_options(-stdlib=libstdc++)
        # XXX NO! add_link_options(-stdlib=libstdc++)
    endif()

    # Tell CMake that we explicitly want `import std`.
    # This will initialize the property on all targets declared after this to 1
    if(${CMAKE_CXX_STANDARD} IN_LIST CMAKE_CXX_COMPILER_IMPORT_STD)
        set(FMT_IMPORT_STD ON)
    endif()

    if(FMT_IMPORT_STD)
        list(APPEND CPPdefinitions FMT_IMPORT_STD)
    endif()

    message(
        STATUS
        "CMAKE_CXX_COMPILER_IMPORT_STD=${CMAKE_CXX_COMPILER_IMPORT_STD}"
    )
    message(STATUS "CMAKE_CXX_SCAN_FOR_MODULES=${CMAKE_CXX_SCAN_FOR_MODULES}")
    message(STATUS "FMT_IMPORT_STD=${FMT_IMPORT_STD}")
    message(STATUS "CPPdefinitions=${CPPdefinitions}")
else()
    option(CMAKE_VERIFY_INTERFACE_HEADER_SETS "" ${PROJECT_IS_TOP_LEVEL})
endif()

# ---- add dependency libraries ----

include(cmake/CPM.cmake)

cpmaddpackage(
    NAME fmt
    GITHUB_REPOSITORY fmtlib/fmt
    GIT_TAG 12.1.0
    VERSION 12.1.0
    DOWNLOAD_ONLY ON
    # NO! PATCH_COMMAND git apply -p 1 ${CMAKE_CURRENT_SOURCE_DIR}/fmt.patch
)

# -----------------------------------------
# ---- Collect the fmt library sources ----
# -----------------------------------------

# TODO(CK): manually  apply the patch if needed (compare) and possible!
if(
    EXISTS ${fmt_SOURCE_DIR}/src/fmt.cc
    AND NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/module/fmt.cppm
)
    configure_file(
        ${fmt_SOURCE_DIR}/src/fmt.cc
        ${CMAKE_CURRENT_SOURCE_DIR}/module/fmt.cppm
        COPYONLY
    )
endif()

configure_file(
    ${fmt_SOURCE_DIR}/src/format.cc
    ${CMAKE_CURRENT_SOURCE_DIR}/module/format.cc
    COPYONLY
)
configure_file(
    ${fmt_SOURCE_DIR}/src/os.cc
    ${CMAKE_CURRENT_SOURCE_DIR}/module/os.cc
    COPYONLY
)

file(
    GLOB_RECURSE _fmt_all_sources
    CONFIGURE_DEPENDS
    RELATIVE ${CMAKE_CURRENT_LIST_DIR}
    module/*.cc
)

# -----------------------------------------
# -----------------------------------------

#
# build the fmt interface library
#
add_library(fmt-header-only INTERFACE)
add_library(fmt::fmt-header-only ALIAS fmt-header-only)

file(
    GLOB_RECURSE _fmt_public_header
    CONFIGURE_DEPENDS
    # NO! RELATIVE ${fmt_SOURCE_DIR}/include
    ${fmt_SOURCE_DIR}/include/fmt/*.h
)
target_sources(
    fmt-header-only
    INTERFACE
        FILE_SET HEADERS
            BASE_DIRS ${fmt_SOURCE_DIR}/include
            FILES ${_fmt_public_header}
)

target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY)
target_compile_features(fmt-header-only INTERFACE cxx_std_23)

# Unicode support requires compiling with /utf-8.
target_compile_options(
    fmt-header-only
    INTERFACE $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>
)

#
# build the fmt library
#
if(FMT_SEPARATE_COMPILATION)
    add_library(fmt)
    add_library(fmt::fmt ALIAS fmt)
    target_sources(
        fmt
        PUBLIC
            FILE_SET public_headers
                TYPE HEADERS
                BASE_DIRS ${fmt_SOURCE_DIR}/include
                FILES ${_fmt_public_header}
    )

    target_compile_definitions(fmt PUBLIC ${CPPdefinitions})
    # NOTE: NO! target_link_libraries(fmt PUBLIC fmt-header-only)
    target_compile_options(
        fmt
        PUBLIC $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CXX_COMPILER_ID:MSVC>>:/utf-8>
    )
    target_compile_features(fmt PUBLIC cxx_std_23)

    if(FMT_MODULE)
        message(STATUS "FMT_MODULE=${FMT_MODULE}")
        target_sources(
            fmt
            PUBLIC
                FILE_SET public_modules
                    TYPE CXX_MODULES
                    BASE_DIRS module
                    FILES module/fmt.cppm
        )
        if(FMT_IMPORT_STD)
            set_target_properties(fmt PROPERTIES CXX_MODULE_STD ON)
        endif()
    else()
        message(WARNING "Missing or disabled support for CXX_MODULES!")
        target_sources(fmt PRIVATE ${_fmt_all_sources})
    endif()

    if(FMT_WARNINGS_AS_ERRORS AND FMT_DEVELOPER_MODE AND UNIX)
        target_compile_options(fmt PRIVATE -Werror)
    endif()
endif()

# ---- Install rules ----

if(NOT CMAKE_SKIP_INSTALL_RULES)
    include(cmake/install-rules.cmake)
endif()

# ---- Developer mode ----

if(NOT FMT_DEVELOPER_MODE)
    return()
elseif(NOT PROJECT_IS_TOP_LEVEL)
    message(AUTHOR_WARNING "Developer mode is intended for developers of fmt")
endif()

include(cmake/dev-mode.cmake)