[build-win]

Author: Kataglyphis

.github/workflows/Windows.yml

@@ -48,7 +48,7 @@ jobs:
 
       - name: Run build inside container
         run: |
-          docker run --rm --cpus 4 `
+          docker run --rm --memory 16g --cpus 4 `
             --mount "type=bind,source=${{ github.workspace }},target=C:\workspace" `
             -w "C:\workspace" `
             "${{ env.CONTAINER_IMAGE }}" `

CMakeLists.txt

@@ -10,11 +10,20 @@ project(
 
 set(AUTHOR "Jonas Heinle")
 
+include(cmake/BuildTypeHelpers.cmake)
+
+# Resolve symlinks before comparing so aliased source/build paths are still rejected.
+get_filename_component(_myproject_source_dir "${CMAKE_SOURCE_DIR}" REALPATH)
+get_filename_component(_myproject_binary_dir "${CMAKE_BINARY_DIR}" REALPATH)
+if("${_myproject_source_dir}" STREQUAL "${_myproject_binary_dir}")
+  message(
+    FATAL_ERROR "In-source builds are disabled. Please create a separate build directory and run CMake from there.")
+endif()
+
 set(MYPROJECT_GCC_TOOLCHAIN_PATH
     ""
     CACHE PATH "Optional GCC toolchain root used by Clang and Rust tooling on Linux (for example /opt/gcc-15.2.0)")
 
-include(cmake/PreventInSourceBuilds.cmake)
 include(cmake/ProjectOptions.cmake)
 include(cmake/MSVCRuntimeConfig.cmake)
 include(cmake/RustOptions.cmake)
@@ -57,7 +66,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
       # If a profile path is supplied, use it for profile-guided optimizations.
       target_compile_options(myproject_options INTERFACE -fprofile-instr-use=${myproject_PGO_PROFILE})
       target_link_options(myproject_options INTERFACE -fprofile-instr-use=${myproject_PGO_PROFILE})
-    elseif(myproject_ENABLE_PGO AND (CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" OR CMAKE_BUILD_TYPE STREQUAL "Release"))
+    elseif(myproject_ENABLE_PGO AND (MYPROJECT_BUILD_IS_RELWITHDEBINFO OR MYPROJECT_BUILD_IS_RELEASE))
       # Instrument the build to generate runtime profiles (.profraw).
       target_compile_options(myproject_options INTERFACE -fprofile-instr-generate)
       target_link_options(myproject_options INTERFACE -fprofile-instr-generate)
@@ -75,6 +84,18 @@ myproject_configure_msvc_runtime()
 
 add_subdirectory(ExternalLib)
 
+# FUZZTEST pulls antlr4-cpp transitively on Windows clang-cl debug builds.
+# antlr4-cpp 4.13.2's ProfilingATNSimulator.cpp uses std::chrono without
+# including <chrono>, so fix that at the target level instead of patching the
+# vendored source tree.
+if(MSVC AND CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
+  foreach(_myproject_antlr_target antlr4_static antlr4_shared)
+    if(TARGET ${_myproject_antlr_target})
+      target_compile_options(${_myproject_antlr_target} PRIVATE /FIchrono)
+    endif()
+  endforeach()
+endif()
+
 # If the nlohmann.json module target was created, expose a compile-time macro
 # so consumer module units can conditionally import the module. This lets
 # translation units fall back to the header-only include if the module BMI
@@ -96,7 +117,7 @@ if(BUILD_TESTING)
   include(CTest)
   enable_testing()
 
-  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+  if(MYPROJECT_BUILD_IS_DEBUG)
     add_subdirectory(Test/commit)
     add_subdirectory(Test/compile)
     if(NOT USE_THREAD_SANITIZER)
@@ -105,7 +126,7 @@ if(BUILD_TESTING)
   endif()
 endif()
 
-if(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+if(MYPROJECT_BUILD_IS_RELWITHDEBINFO)
   add_subdirectory(Test/perf)
 endif()
 

ExternalLib/CMakeLists.txt

@@ -1,7 +1,6 @@
 include(FetchContent)
 
-message(STATUS "ExternalLib/CMakeLists: RUST_FEATURES=${RUST_FEATURES} CMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}")
-
+include(${CMAKE_SOURCE_DIR}/cmake/BuildTypeHelpers.cmake)
 include(${CMAKE_SOURCE_DIR}/cmake/CompilerConfigHelpers.cmake)
 
 if(BUILD_TESTING)
@@ -19,23 +18,37 @@ set(BENCHMARK_USE_BUNDLED_GTEST OFF CACHE BOOL "Disable the bundled GTest usage.
 
 add_subdirectory(GOOGLE_BENCHMARK)
 
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND BUILD_TESTING AND CMAKE_BUILD_TYPE STREQUAL "Debug")
-  if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang" AND NOT USE_THREAD_SANITIZER)
-    message("Adding Fuzztest")
-    option(KATAGLYPHIS_ENABLE_FUZZTEST_FUZZING_MODE
-           "Build FUZZTEST in fuzzing mode (injects AddressSanitizer/coverage flags; keep OFF for normal builds)"
-           ON)
-    set(FUZZTEST_FUZZING_MODE OFF CACHE BOOL "" FORCE)
-    add_subdirectory(FUZZTEST)
+set(_kataglyphis_enable_fuzztest FALSE)
+if(BUILD_TESTING
+   AND MYPROJECT_BUILD_IS_DEBUG
+   AND CMAKE_CXX_COMPILER_ID MATCHES ".*Clang"
+   AND NOT USE_THREAD_SANITIZER
+   AND (CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "Windows"))
+  set(_kataglyphis_enable_fuzztest TRUE)
+endif()
+
+if(_kataglyphis_enable_fuzztest)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Windows" AND FUZZTEST_COMPATIBILITY_MODE STREQUAL "libfuzzer")
+    message(FATAL_ERROR "FUZZTEST_COMPATIBILITY_MODE=libfuzzer is not supported on Windows clang-cl.")
   endif()
+
+  set(_kataglyphis_default_fuzztest_fuzzing_mode OFF)
+  if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(_kataglyphis_default_fuzztest_fuzzing_mode ON)
+  endif()
+
+  option(KATAGLYPHIS_ENABLE_FUZZTEST_FUZZING_MODE
+         "Build FUZZTEST in fuzzing mode (injects AddressSanitizer/coverage flags; keep OFF for normal builds)"
+         ${_kataglyphis_default_fuzztest_fuzzing_mode})
+  set(FUZZTEST_FUZZING_MODE OFF CACHE BOOL "" FORCE)
+  add_subdirectory(FUZZTEST)
 endif()
 
 FetchContent_Declare(GSL GIT_REPOSITORY "https://github.com/microsoft/GSL" GIT_TAG "v4.2.1")
 FetchContent_MakeAvailable(GSL)
 
 FetchContent_Declare(abseil-cpp GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git GIT_TAG 20260107.1)
 FetchContent_MakeAvailable(abseil-cpp)
-include_directories(${abseil-cpp_SOURCE_DIR})
 
 if(myproject_DISABLE_EXCEPTIONS)
   set(SPDLOG_NO_EXCEPTIONS ON CACHE BOOL "Disable SPDLOG exceptions.")
@@ -95,4 +108,4 @@ endif()
 
 if(TARGET nlohmann_json_modules AND TARGET nlohmann_json)
   set_target_properties(nlohmann_json PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "")
-endif()
+endif()

ExternalLib/Kataglyphis-ContainerHub

@@ -3,13 +3,11 @@ set(PROJECT_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/)
 set(PROJECT_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/)
 set(EXTERNAL_LIB_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../ExternalLib/)
 
-include(cmake/filters/SetProjectFilters.cmake)
-include(cmake/SetSourceGroups.cmake)
-
 file(GLOB_RECURSE KataglyphisCppProject_SOURCES "*.cpp")
 file(GLOB_RECURSE KataglyphisCppProject_HEADERS "*.hpp")
 set(KATAGLYPHIS_MAIN_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/Main.cpp")
 list(REMOVE_ITEM KataglyphisCppProject_SOURCES "${KATAGLYPHIS_MAIN_SOURCE}")
+source_group("main" FILES "${KATAGLYPHIS_MAIN_SOURCE}")
 
 # Ensure the Abseil flags translation unit is compiled and linked into the
 # executable. We add it explicitly so module-aware compilers see the TU even
@@ -64,25 +62,8 @@ if(MSVC)
   target_compile_options(${PROJECT_NAME} PRIVATE /EHsc)
 endif()
 
-if(WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  target_compile_definitions(${PROJECT_NAME} PRIVATE RELATIVE_RESOURCE_PATH="/../../Resources/"
-                                                        RELATIVE_INCLUDE_PATH="/../../Src/")
-else()
-  target_compile_definitions(${PROJECT_NAME} PRIVATE RELATIVE_RESOURCE_PATH="/../Resources/"
-                                                        RELATIVE_INCLUDE_PATH="/../Src/")
-endif()
-
 install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)
 
-# Treat MSVC and clang-cl on Windows differently in a sense of deployment
-if(WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
-  target_compile_definitions(${KATAGLYPHIS_CORE_TARGET} PRIVATE RELATIVE_RESOURCE_PATH="/../../Resources/"
-                                                        RELATIVE_INCLUDE_PATH="/../../Src/")
-else()
-  target_compile_definitions(${KATAGLYPHIS_CORE_TARGET} PRIVATE RELATIVE_RESOURCE_PATH="/../Resources/"
-                                                        RELATIVE_INCLUDE_PATH="/../Src/")
-endif()
-
 target_sources(
   ${KATAGLYPHIS_CORE_TARGET}
   PRIVATE ${KataglyphisCppProject_SOURCES}

Src/CMakeLists.txt

@@ -45,11 +45,14 @@ auto run() -> int
               << "\n";
 
 #if defined(TOMLPLUSPLUS_MODULE_AVAILABLE)
-    // Parse the example TOML resource to demonstrate module usage.
-    // Use the no-exceptions API (parse_result) so this code compiles when
-    // exceptions are disabled for the toolchain.
+    // Parse an in-memory TOML document to demonstrate module usage without
+    // depending on the current working directory at runtime.
     {
-        auto res = toml::parse_file("${CMAKE_SOURCE_DIR}/Src/resources/example.toml");
+        auto res = toml::parse(R"(
+            [application]
+            name = "Kataglyphis Runtime"
+            version = "0.0.1"
+        )");
         if (res) {
             // parse_result is convertible to toml::table when successful
             const auto &t = static_cast<const toml::table &>(res);

Src/KataglyphisCppProject.ixx

@@ -5,9 +5,9 @@ import kataglyphis_core;
 // the declaration at global scope avoids declaring `main` with extern "C"
 // linkage (which triggers a warning) and avoids putting linkage-specifiers
 // inside the function body which can confuse some frontends.
-extern "C" void kataglyphis_parse_flags(int argc, char** argv);
+extern "C" void kataglyphis_parse_flags(int argc, char **argv);
 
-int main(int argc, char** argv)
+int main(int argc, char **argv)
 {
     // Parse flags in a separate translation unit to avoid including Abseil
     // headers in a module-importing TU. The parse_flags function is defined

Src/Main.cpp

@@ -17,19 +17,16 @@ ABSL_FLAG(bool, verbose, false, "Enable verbose logging");
 
 namespace kataglyphis {
 
-void parse_flags(int argc, char** argv)
+void parse_flags(int argc, char **argv)
 {
     absl::SetProgramUsageMessage("Usage: kataglyphis --input=FILE [options]");
     // Parse and ignore leftover positional arguments here.
     (void)absl::ParseCommandLine(argc, argv);
 }
 
-} // namespace kataglyphis
+}// namespace kataglyphis
 
 // Provide a C-linkage wrapper so the module-based main can reliably call the
 // flag parsing function without depending on C++ name mangling or module
 // visibility rules across translation units.
-extern "C" void kataglyphis_parse_flags(int argc, char** argv)
-{
-    kataglyphis::parse_flags(argc, argv);
-}
+extern "C" void kataglyphis_parse_flags(int argc, char **argv) { kataglyphis::parse_flags(argc, argv); }