Bump to 0.2.36

Merge pull request #156 from build-cpp/vcpkg-overlay-ports
Add [vcpkg].overlay-ports feature
2026-06-08 13:22:55 +00:00 · 2024-11-26 13:36:24 +01:00 · 2024-11-26 13:35:32 +01:00 · 2024-11-26 12:33:29 +01:00 · 2024-11-03 11:44:02 +01:00 · 2024-11-03 10:49:33 +01:00
70 changed files with 1911 additions and 26215 deletions
@@ -10,7 +10,7 @@ AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: false
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
@@ -19,7 +19,7 @@ AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
-BraceWrapping:   
+BraceWrapping:
  AfterClass:      false
  AfterControlStatement: false
  AfterEnum:       false
@@ -72,7 +72,7 @@ PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Right
 ReflowComments:  true
-SortIncludes:    true
+SortIncludes:    false
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: true
@@ -0,0 +1,24 @@
+root = true
+
+[*]
+end_of_line = lf
+trim_trailing_whitespace = true
+charset = utf-8
+
+[*.{c,h,cpp,hpp,toml}]
+indent_style = space
+insert_final_newline = true
+
+[{CMakeLists.txt, *.cmake}]
+indent_style = tab
+tab_width = 8
+insert_final_newline = true
+
+# Exclude the third_party folder
+[/third_party/**]
+charset = unset
+end_of_line = unset
+insert_final_newline = unset
+trim_trailing_whitespace = unset
+indent_style = unset
+indent_size = unset
@@ -1,21 +1,28 @@
-name: CMake
+name: build

 on: [push, pull_request]

 jobs:
-  build:
+  cmake:
    # Skip building pull requests from the same repository
    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
-        os: [windows-2019, macos-10.15, ubuntu-20.04]
+        os: [windows-2022, macos-latest, ubuntu-20.04]
    env:
-      BUILD_TYPE: Release
+      BUILD_TYPE: 'Release'
+      CMAKE_GENERATOR: 'Ninja'
    steps:
    - name: Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
+
+    - name: Install Ninja
+      uses: seanmiddleditch/gha-setup-ninja@6263846cf3c17009dfc81604efabae16044fc074 # master
+
+    - name: Visual Studio Development Environment
+      uses: ilammy/msvc-dev-cmd@cec98b9d092141f74527d0afa6feb2af698cfe89 # v1.12.1

    - name: Tag cmkr.cmake
      if: ${{ startsWith(github.ref, 'refs/tags/') }}
@@ -38,28 +45,31 @@ jobs:
        ctest -C ${{ env.BUILD_TYPE }} --verbose

    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
      with:
        name: ${{ github.event.repository.name }}-${{ matrix.os }}
        path: install/bin/*

    - name: Get lowercase OS name
      id: osname
-      uses: ASzc/change-string-case-action@v1
+      uses: ASzc/change-string-case-action@07c1e24a97f0951e13f88870b99c058fcf0b14cf # v5
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
      with:
        string: ${{ runner.os }}

    - name: Compress artifacts
-      uses: vimtor/action-zip@v1
+      uses: vimtor/action-zip@26a249fb00d43ca98dad77a4b3838025fc226aa1 # v1.1
+      if: ${{ startsWith(github.ref, 'refs/tags/') }}
      with:
        files: install/bin/
        dest: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip

    - name: Release
-      uses: softprops/action-gh-release@v1
+      uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v0.1.15
      if: ${{ startsWith(github.ref, 'refs/tags/') }}
      with:
        prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') || contains(github.ref, '-pre') }}
        files: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
+        generate_release_notes: true
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,41 @@
+name: lint
+
+on: [push, pull_request]
+
+jobs:
+  clang-format:
+    # Skip building pull requests from the same repository
+    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: clang-format
+        id: clang-format
+        uses: DoozyX/clang-format-lint-action@c71d0bf4e21876ebec3e5647491186f8797fde31 # v0.18.2
+        with:
+          exclude: './third_party'
+          extensions: 'c,h,cpp,hpp'
+          clangFormatVersion: 15
+          style: file
+
+      - name: clang-format instructions
+        if: ${{ failure() && steps.clang-format.outcome == 'failure' }}
+        run: |
+          # Instructions for fixing the formatting errors
+          echo -e "\n\033[0;31mTo fix the formatting, run:\nclang-format -style=file -i \$(git ls-files \"*.c\" \"*.h\" \"*.cpp\" \"*.hpp\")\033[0m\n"
+          exit 1
+
+  editorconfig:
+    # Skip building pull requests from the same repository
+    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Run editorconfig-checker
+        uses: editorconfig-checker/action-editorconfig-checker@d4fca16fc71adef10fbe101903b654449fa9570c # master 2022-03-15
@@ -9,3 +9,5 @@ build*/
 .idea/
 cmake-build*/
 CMakeLists.txt.user
+.vscode/
+.DS_Store
@@ -7,17 +7,14 @@ if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
 	message(FATAL_ERROR "In-tree builds are not supported. Run CMake from a separate directory: cmake -B build")
 endif()

-# Regenerate CMakeLists.txt automatically in the root project
 set(CMKR_ROOT_PROJECT OFF)
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
 	set(CMKR_ROOT_PROJECT ON)

 	# Enable folder support
 	set_property(GLOBAL PROPERTY USE_FOLDERS ON)
-endif()

-# Create a configure-time dependency on cmake.toml to improve IDE support
-if(CMKR_ROOT_PROJECT)
+	# Create a configure-time dependency on cmake.toml to improve IDE support
 	configure_file(cmake.toml cmake.toml COPYONLY)
 endif()

@@ -25,7 +22,7 @@ project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.2.13
+		0.2.36
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )
@@ -33,7 +30,7 @@ project(cmkr
 include("cmake/generate_documentation.cmake")
 include("cmake/generate_resources.cmake")

-# third_party
+# Subdirectory: third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/third_party")
@@ -43,7 +40,7 @@ endif()
 add_subdirectory(third_party)
 set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})

-# tests
+# Subdirectory: tests
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/tests")
@@ -53,64 +50,35 @@ endif()
 add_subdirectory(tests)
 set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})

-
-
-# Target cmkr_generate_documentation
-set(CMKR_TARGET cmkr_generate_documentation)
-set(cmkr_generate_documentation_SOURCES "")
-
-set(CMKR_SOURCES ${cmkr_generate_documentation_SOURCES})
+# Target: cmkr_generate_documentation
 add_library(cmkr_generate_documentation INTERFACE)

-if(cmkr_generate_documentation_SOURCES)
-	target_sources(cmkr_generate_documentation INTERFACE ${cmkr_generate_documentation_SOURCES})
-endif()
-
+set(CMKR_TARGET cmkr_generate_documentation)
 generate_documentation()

-unset(CMKR_TARGET)
-unset(CMKR_SOURCES)
-
-# Target cmkr
-set(CMKR_TARGET cmkr)
-set(cmkr_SOURCES "")
-
-list(APPEND cmkr_SOURCES
-	"src/arguments.cpp"
-	"src/build.cpp"
-	"src/cmake_generator.cpp"
-	"src/error.cpp"
-	"src/help.cpp"
-	"src/main.cpp"
-	"src/project_parser.cpp"
+# Target: cmkr
+set(cmkr_SOURCES
+	cmake.toml
+	"cmake/cmkr.cmake"
+	"cmake/version.hpp.in"
 	"include/arguments.hpp"
 	"include/build.hpp"
 	"include/cmake_generator.hpp"
-	"include/error.hpp"
 	"include/fs.hpp"
 	"include/help.hpp"
 	"include/literals.hpp"
 	"include/project_parser.hpp"
-	"cmake/cmkr.cmake"
-	"cmake/version.hpp.in"
+	"src/arguments.cpp"
+	"src/build.cpp"
+	"src/cmake_generator.cpp"
+	"src/help.cpp"
+	"src/main.cpp"
+	"src/project_parser.cpp"
 )

-list(APPEND cmkr_SOURCES
-	cmake.toml
-)
-
-set(CMKR_SOURCES ${cmkr_SOURCES})
 add_executable(cmkr)

-if(cmkr_SOURCES)
-	target_sources(cmkr PRIVATE ${cmkr_SOURCES})
-endif()
-
-get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
-if(NOT CMKR_VS_STARTUP_PROJECT)
-	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT cmkr)
-endif()
-
+target_sources(cmkr PRIVATE ${cmkr_SOURCES})
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${cmkr_SOURCES})

 target_compile_features(cmkr PRIVATE
@@ -126,13 +94,15 @@ target_link_libraries(cmkr PRIVATE
 	ghc_filesystem
 	mpark_variant
 	ordered_map
-	nlohmann_json
 )

-generate_resources(${CMKR_TARGET})
+get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+if(NOT CMKR_VS_STARTUP_PROJECT)
+	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT cmkr)
+endif()

-unset(CMKR_TARGET)
-unset(CMKR_SOURCES)
+set(CMKR_TARGET cmkr)
+include("cmake/custom_targets.cmake")

 install(
 	TARGETS
@@ -13,27 +13,29 @@ type = "executable"
 sources = ["src/main.cpp"]
 ```

-`cmkr` can bootstrap itself from CMake and you only need CMake to use it.
+`cmkr` can bootstrap itself and you only need CMake and a C++ compiler to use it.

 ## Getting started

-To get started run the following commands from your project directory:
+To get started, run the following commands from your project directory:

 ```sh
 curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
 cmake -P cmkr.cmake
 ```

-After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:
+After the bootstrapping process finishes, customize [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) for your project and run CMake:

 ```sh
 cmake -B build
 cmake --build build
 ```

-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.

-In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
+
+In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.

 ## Template repositories

@@ -53,10 +55,10 @@ Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/rele
 ```
 Usage: cmkr [arguments]
 arguments:
-    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
+    init    [executable|library|shared|static|interface] Create a project.
    gen                                                  Generates CMakeLists.txt file.
    build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install. Needs admin privileges.
+    install                                              Run cmake --install.
    clean                                                Clean the build directory.
    help                                                 Show help.
    version                                              Current cmkr version.
@@ -64,10 +66,10 @@ arguments:

 ## Credits

- https://github.com/gulrak/filesystem
- https://github.com/Tessil/ordered-map
- https://github.com/ToruNiina/toml11
- https://github.com/mpark/variant
- https://www.svgrepo.com/svg/192268/hammer
- https://github.com/can1357 for buying `cmkr.build` ❤️
- https://github.com/JustasMasiulis for fixing the dark theme ❤️
+- [gulrak/filesystem](https://github.com/gulrak/filesystem)
+- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
+- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
+- [mpark/variant](https://github.com/mpark/variant)
+- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
+- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
+- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️
@@ -4,14 +4,14 @@ cmkr-include = false

 [project]
 name = "cmkr"
-version = "0.2.13"
+version = "0.2.36"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
-subdirs = ["third_party", "tests"]
 include-after = [
    "cmake/generate_documentation.cmake",
    "cmake/generate_resources.cmake"
 ]
+subdirs = ["third_party", "tests"]

 [target.cmkr_generate_documentation]
 type = "interface"
@@ -36,11 +36,8 @@ link-libraries = [
    "ghc_filesystem",
    "mpark_variant",
    "ordered_map",
-    "nlohmann_json",
 ]
-cmake-after = """
-generate_resources(${CMKR_TARGET})
-"""
+include-after = ["cmake/custom_targets.cmake"]

 [[install]]
 targets = ["cmkr"]
@@ -1,78 +1,78 @@
-cmake_minimum_required(VERSION 3.20)
-
-if(NOT CMAKE_SCRIPT_MODE_FILE)
-    message(FATAL_ERROR "Usage: cmake -P bump_version.cmake [1.2.3]")
-endif()
-
-if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake.toml")
-    message(FATAL_ERROR "Cannot find cmake.toml")
-endif()
-
-if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake")
-    message(FATAL_ERROR "Cannot find cmkr.cmake")
-endif()
-
-# Validate branch
-find_package(Git REQUIRED)
-execute_process(COMMAND "${GIT_EXECUTABLE}" branch --show-current OUTPUT_VARIABLE GIT_BRANCH)
-string(STRIP "${GIT_BRANCH}" GIT_BRANCH)
-if(NOT GIT_BRANCH STREQUAL "main")
-    message(FATAL_ERROR "You need to be on the main branch, you are on: ${GIT_BRANCH}")
-endif()
-
-file(READ "${CMAKE_SOURCE_DIR}/cmake.toml" CMAKE_TOML)
-string(FIND "${CMAKE_TOML}" "[project]" PROJECT_INDEX)
-string(SUBSTRING "${CMAKE_TOML}" ${PROJECT_INDEX} -1 CMAKE_TOML_PROJECT)
-set(SEMVER_REGEX "([0-9]+)\\.([0-9]+)\\.([0-9]+)")
-set(VERSION_REGEX "version = \"${SEMVER_REGEX}\"")
-if(CMAKE_TOML_PROJECT MATCHES "${VERSION_REGEX}")
-    set(MAJOR "${CMAKE_MATCH_1}")
-    set(MINOR "${CMAKE_MATCH_2}")
-    set(PATCH "${CMAKE_MATCH_3}")
-    set(OLDVERSION "${MAJOR}.${MINOR}.${PATCH}")
-else()
-    message(FATAL_ERROR "Failed to match semantic version in cmake.toml")
-endif()
-
-if(CMAKE_ARGV3)
-    if(NOT CMAKE_ARGV3 MATCHES "${SEMVER_REGEX}")
-        message(FATAL_ERROR "Invalid semantic version number '${CMAKE_ARGV3}'")
-    endif()
-    set(NEWVERSION "${CMAKE_ARGV3}")
-else()
-    math(EXPR NEWPATCH "${PATCH} + 1")
-    set(NEWVERSION "${MAJOR}.${MINOR}.${NEWPATCH}")
-endif()
-
-message(STATUS "Version ${OLDVERSION} -> ${NEWVERSION}")
-
-find_program(CMKR_EXECUTABLE "cmkr" PATHS "${CMAKE_SOURCE_DIR}/build" PATH_SUFFIXES Debug Release RelWithDebInfo MinSizeRel NO_CACHE REQUIRED)
-message(STATUS "Found cmkr: ${CMKR_EXECUTABLE}")
-
-# Replace version in cmake.toml
-string(REPLACE "version = \"${OLDVERSION}\"" "version = \"${NEWVERSION}\"" CMAKE_TOML "${CMAKE_TOML}")
-file(CONFIGURE
-    OUTPUT "${CMAKE_SOURCE_DIR}/cmake.toml"
-    CONTENT "${CMAKE_TOML}"
-    @ONLY
-    NEWLINE_STYLE LF
-)
-
-# Run cmkr gen
-execute_process(COMMAND "${CMKR_EXECUTABLE}" gen RESULT_VARIABLE CMKR_EXEC_RESULT)
-if(NOT CMKR_EXEC_RESULT EQUAL 0)
-    message(FATAL_ERROR "cmkr gen failed (exit code ${CMKR_EXEC_RESULT})")
-endif()
-
-# Replace version in cmkr.cmake
-file(READ "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake" CMKR_CMAKE)
-string(REGEX REPLACE "CMKR_TAG \"[^\"]+\"" "CMKR_TAG \"v${NEWVERSION}\"" CMKR_CMAKE "${CMKR_CMAKE}")
-file(CONFIGURE
-    OUTPUT "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake"
-    CONTENT "${CMKR_CMAKE}"
-    @ONLY
-    NEWLINE_STYLE LF
-)
-
-# Print git commands
+cmake_minimum_required(VERSION 3.20)
+
+if(NOT CMAKE_SCRIPT_MODE_FILE)
+    message(FATAL_ERROR "Usage: cmake -P bump_version.cmake [1.2.3]")
+endif()
+
+if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake.toml")
+    message(FATAL_ERROR "Cannot find cmake.toml")
+endif()
+
+if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake")
+    message(FATAL_ERROR "Cannot find cmkr.cmake")
+endif()
+
+# Validate branch
+find_package(Git REQUIRED)
+execute_process(COMMAND "${GIT_EXECUTABLE}" branch --show-current OUTPUT_VARIABLE GIT_BRANCH)
+string(STRIP "${GIT_BRANCH}" GIT_BRANCH)
+if(NOT GIT_BRANCH STREQUAL "main")
+    message(FATAL_ERROR "You need to be on the main branch, you are on: ${GIT_BRANCH}")
+endif()
+
+file(READ "${CMAKE_SOURCE_DIR}/cmake.toml" CMAKE_TOML)
+string(FIND "${CMAKE_TOML}" "[project]" PROJECT_INDEX)
+string(SUBSTRING "${CMAKE_TOML}" ${PROJECT_INDEX} -1 CMAKE_TOML_PROJECT)
+set(SEMVER_REGEX "([0-9]+)\\.([0-9]+)\\.([0-9]+)")
+set(VERSION_REGEX "version = \"${SEMVER_REGEX}\"")
+if(CMAKE_TOML_PROJECT MATCHES "${VERSION_REGEX}")
+    set(MAJOR "${CMAKE_MATCH_1}")
+    set(MINOR "${CMAKE_MATCH_2}")
+    set(PATCH "${CMAKE_MATCH_3}")
+    set(OLDVERSION "${MAJOR}.${MINOR}.${PATCH}")
+else()
+    message(FATAL_ERROR "Failed to match semantic version in cmake.toml")
+endif()
+
+if(CMAKE_ARGV3)
+    if(NOT CMAKE_ARGV3 MATCHES "${SEMVER_REGEX}")
+        message(FATAL_ERROR "Invalid semantic version number '${CMAKE_ARGV3}'")
+    endif()
+    set(NEWVERSION "${CMAKE_ARGV3}")
+else()
+    math(EXPR NEWPATCH "${PATCH} + 1")
+    set(NEWVERSION "${MAJOR}.${MINOR}.${NEWPATCH}")
+endif()
+
+message(STATUS "Version ${OLDVERSION} -> ${NEWVERSION}")
+
+find_program(CMKR_EXECUTABLE "cmkr" PATHS "${CMAKE_SOURCE_DIR}/build" PATH_SUFFIXES Debug Release RelWithDebInfo MinSizeRel NO_CACHE REQUIRED)
+message(STATUS "Found cmkr: ${CMKR_EXECUTABLE}")
+
+# Replace version in cmake.toml
+string(REPLACE "version = \"${OLDVERSION}\"" "version = \"${NEWVERSION}\"" CMAKE_TOML "${CMAKE_TOML}")
+file(CONFIGURE
+    OUTPUT "${CMAKE_SOURCE_DIR}/cmake.toml"
+    CONTENT "${CMAKE_TOML}"
+    @ONLY
+    NEWLINE_STYLE LF
+)
+
+# Run cmkr gen
+execute_process(COMMAND "${CMKR_EXECUTABLE}" gen RESULT_VARIABLE CMKR_EXEC_RESULT)
+if(NOT CMKR_EXEC_RESULT EQUAL 0)
+    message(FATAL_ERROR "cmkr gen failed (exit code ${CMKR_EXEC_RESULT})")
+endif()
+
+# Replace version in cmkr.cmake
+file(READ "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake" CMKR_CMAKE)
+string(REGEX REPLACE "CMKR_TAG \"[^\"]+\"" "CMKR_TAG \"v${NEWVERSION}\"" CMKR_CMAKE "${CMKR_CMAKE}")
+file(CONFIGURE
+    OUTPUT "${CMAKE_SOURCE_DIR}/cmake/cmkr.cmake"
+    CONTENT "${CMKR_CMAKE}"
+    @ONLY
+    NEWLINE_STYLE LF
+)
+
+# Print git commands
 message(STATUS "Git commands to create new version:\ngit commit -a -m \"Bump to ${NEWVERSION}\"\ngit tag v${NEWVERSION}\ngit push origin main v${NEWVERSION}")
@@ -2,7 +2,7 @@ include_guard()

 # Change these defaults to point to your infrastructure if desired
 set(CMKR_REPO "https://github.com/build-cpp/cmkr" CACHE STRING "cmkr git repository" FORCE)
-set(CMKR_TAG "v0.2.13" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+set(CMKR_TAG "v0.2.36" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
 set(CMKR_COMMIT_HASH "" CACHE STRING "cmkr git commit hash (optional)" FORCE)

 # To bootstrap/generate a cmkr project: cmake -P cmkr.cmake
@@ -58,7 +58,7 @@ else()
 endif()

 # Use cached cmkr if found
-if(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}")
+if(DEFINED ENV{CMKR_CACHE})
    set(CMKR_DIRECTORY_PREFIX "$ENV{CMKR_CACHE}")
    string(REPLACE "\\" "/" CMKR_DIRECTORY_PREFIX "${CMKR_DIRECTORY_PREFIX}")
    if(NOT CMKR_DIRECTORY_PREFIX MATCHES "\\/$")
@@ -72,10 +72,27 @@ endif()
 set(CMKR_DIRECTORY "${CMKR_DIRECTORY_PREFIX}${CMKR_TAG}")
 set(CMKR_CACHED_EXECUTABLE "${CMKR_DIRECTORY}/bin/${CMKR_EXECUTABLE_NAME}")

+# Helper function to check if a string starts with a prefix
+# Cannot use MATCHES, see: https://github.com/build-cpp/cmkr/issues/61
+function(cmkr_startswith str prefix result)
+    string(LENGTH "${prefix}" prefix_length)
+    string(LENGTH "${str}" str_length)
+    if(prefix_length LESS_EQUAL str_length)
+        string(SUBSTRING "${str}" 0 ${prefix_length} str_prefix)
+        if(prefix STREQUAL str_prefix)
+            set("${result}" ON PARENT_SCOPE)
+            return()
+        endif()
+    endif()
+    set("${result}" OFF PARENT_SCOPE)
+endfunction()
+
 # Handle upgrading logic
 if(CMKR_EXECUTABLE AND NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE)
-    if(CMKR_EXECUTABLE MATCHES "^${CMAKE_CURRENT_BINARY_DIR}/_cmkr")
-        if(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}")
+    cmkr_startswith("${CMKR_EXECUTABLE}" "${CMAKE_CURRENT_BINARY_DIR}/_cmkr" CMKR_STARTSWITH_BUILD)
+    cmkr_startswith("${CMKR_EXECUTABLE}" "${CMKR_DIRECTORY_PREFIX}" CMKR_STARTSWITH_CACHE)
+    if(CMKR_STARTSWITH_BUILD)
+        if(DEFINED ENV{CMKR_CACHE})
            message(AUTHOR_WARNING "[cmkr] Switching to cached cmkr: '${CMKR_CACHED_EXECUTABLE}'")
            if(EXISTS "${CMKR_CACHED_EXECUTABLE}")
                set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
@@ -86,7 +103,7 @@ if(CMKR_EXECUTABLE AND NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE)
            message(AUTHOR_WARNING "[cmkr] Upgrading '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
            unset(CMKR_EXECUTABLE CACHE)
        endif()
-    elseif(DEFINED ENV{CMKR_CACHE} AND EXISTS "$ENV{CMKR_CACHE}" AND CMKR_EXECUTABLE MATCHES "^${CMKR_DIRECTORY_PREFIX}")
+    elseif(DEFINED ENV{CMKR_CACHE} AND CMKR_STARTSWITH_CACHE)
        message(AUTHOR_WARNING "[cmkr] Upgrading cached '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
        unset(CMKR_EXECUTABLE CACHE)
    endif()
@@ -0,0 +1,18 @@
+generate_resources(cmkr)
+
+add_custom_target(regenerate-cmake
+        COMMAND "$<TARGET_FILE:cmkr>" gen
+        WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+)
+
+if(CMAKE_CONFIGURATION_TYPES)
+    add_custom_target(run-tests
+            COMMAND "${CMAKE_CTEST_COMMAND}" -C $<CONFIG>
+            WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/tests"
+    )
+else()
+    add_custom_target(run-tests
+            COMMAND "${CMAKE_CTEST_COMMAND}"
+            WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/tests"
+    )
+endif()
@@ -1,21 +1,21 @@
 option(CMKR_GENERATE_DOCUMENTATION "Generate cmkr documentation" ${CMKR_ROOT_PROJECT})
-set(CMKR_TESTS "" CACHE INTERNAL "List of test directories in the order declared in tests/cmake.toml")
-
-if(CMKR_GENERATE_DOCUMENTATION)
-    # Hook the add_test function to capture the tests in the order declared in tests/cmake.toml
-    function(add_test)
-        cmake_parse_arguments(TEST "" "WORKING_DIRECTORY" "" ${ARGN})
-        get_filename_component(TEST_WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" NAME)
-        list(APPEND CMKR_TESTS "${TEST_WORKING_DIRECTORY}")
-        set(CMKR_TESTS "${CMKR_TESTS}" CACHE INTERNAL "")
-        _add_test(${test} ${ARGN})
-    endfunction()
-endif()

 function(generate_documentation)
    if(CMKR_GENERATE_DOCUMENTATION)
        message(STATUS "[cmkr] Generating documentation...")
-        
+
+        # Extract the order of the tests
+        set(CMKR_TESTS "")
+        file(READ "${PROJECT_SOURCE_DIR}/tests/cmake.toml" tests_toml NO_HEX_CONVERSION)
+        string(REGEX MATCHALL "working-directory = \"([^\"]+)\"" tests_match "${tests_toml}")
+        foreach(match ${tests_match})
+            if(match MATCHES "working-directory = \"([^\"]+)\"")
+                list(APPEND CMKR_TESTS "${CMAKE_MATCH_1}")
+            else()
+                message(FATAL_ERROR "This should not happen (wrong regex?)")
+            endif()
+        endforeach()
+
        # Delete previously generated examples
        set(example_folder "${PROJECT_SOURCE_DIR}/docs/examples")
        file(GLOB example_files "${example_folder}/*.md")
@@ -41,21 +41,21 @@ function(generate_documentation)
                # Read cmake.toml file
                file(READ "${test_toml}" test_contents NO_HEX_CONVERSION)
                string(LENGTH "${test_contents}" toml_length)
-                
+
                # Extract header text
                string(REGEX MATCH "^(\n*(#[^\n]+\n)+\n*)" EXAMPLE_HEADER "${test_contents}")
                string(LENGTH "${EXAMPLE_HEADER}" header_length)
                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
                string(REGEX REPLACE "\n# ?" "\n\n" EXAMPLE_HEADER "\n${EXAMPLE_HEADER}")
                string(STRIP "${EXAMPLE_HEADER}" EXAMPLE_HEADER)
-                
+
                # Extract footer text
                string(REGEX MATCH "(((#[^\n]+)(\n+|$))+)$" EXAMPLE_FOOTER "${test_contents}")
                string(LENGTH "${EXAMPLE_FOOTER}" footer_length)
                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
                string(REGEX REPLACE "\n# ?" "\n\n" EXAMPLE_FOOTER "\n${EXAMPLE_FOOTER}")
                string(STRIP "${EXAMPLE_FOOTER}" EXAMPLE_FOOTER)
-                
+
                # Extract toml body
                math(EXPR toml_length "${toml_length}-${header_length}-${footer_length}")
                string(SUBSTRING "${test_contents}" ${header_length} ${toml_length} EXAMPLE_TOML)
@@ -64,7 +64,7 @@ function(generate_documentation)
                # Extract title from description
                if("${EXAMPLE_TOML}" MATCHES "description *= *\"([^\"]+)\"")
                    set(EXAMPLE_TITLE "${CMAKE_MATCH_1}")
-    
+
                    # Generate documentation markdown page
                    configure_file("${PROJECT_SOURCE_DIR}/cmake/example.md.in" "${example_folder}/${EXAMPLE_PERMALINK}.md" @ONLY NEWLINE_STYLE LF)
                else()
@@ -1,7 +1,7 @@
-namespace cmkr {
-namespace resources {
-
-static const char* @RESOURCE_NAME@ = R"RESOURCE(@RESOURCE_CONTENTS@)RESOURCE";
-
-}
+namespace cmkr {
+namespace resources {
+
+static const char* @RESOURCE_NAME@ = R"RESOURCE(@RESOURCE_CONTENTS@)RESOURCE";
+
+}
 }
@@ -1 +1 @@
-cmkr.build
+cmkr.build
@@ -21,4 +21,22 @@ gh_edit_branch: "main"
 gh_edit_view_mode: "edit"
 gh_edit_source: docs

-production_url : https://cmkr.build
+ga_tracking: G-DY172KY7Z9
+
+production_url : https://cmkr.build
+footer_content: |
+  <script src="https://giscus.app/client.js"
+          data-repo="build-cpp/cmkr"
+          data-repo-id="MDEwOlJlcG9zaXRvcnkyOTQwMDc3MzY="
+          data-category="Documentation"
+          data-category-id="DIC_kwDOEYYzuM4CTXeA"
+          data-mapping="pathname"
+          data-strict="1"
+          data-reactions-enabled="1"
+          data-emit-metadata="0"
+          data-input-position="top"
+          data-theme="preferred_color_scheme"
+          data-lang="en"
+          crossorigin="anonymous"
+          async>
+  </script>
@@ -0,0 +1,76 @@
+---
+layout: page
+title: Basics
+nav_order: 1
+---
+
+# Basics
+
+To effectively use cmkr it helps to understand the basic concepts of CMake.
+
+## Projects
+
+A CMake **project** is a collection of targets. In the context of libraries the project usually corresponds to the **package** that other projects can depend on.
+
+<sub>Visual Studio: a CMake **project** corresponds to a _solution_.</sub>
+
+## Targets
+
+The basic unit of CMake is called a **target**. A target (also referred to as [binary target](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#binary-targets) in the CMake documentation) corresponds to an executable or library you can build. There are also [pseudo targets](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#pseudo-targets), but we ignore them for now.
+
+<sub>Visual Studio: a **target** corresponds to a _project_.</sub>
+
+## Target Properties
+
+Targets have a collection of **properties** that describe how to build them.
+
+Examples of properties:
+
+- _Sources_: the `*.cpp` files used to build the target.
+- _Compile options_: Command line flags for the compiler.
+- _Link libraries_: The **dependencies** required to build this target.
+
+<sub>See the [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#properties-on-targets) for an exhaustive list of target properties.</sub>
+
+**Important**: The term **link** has a slightly different meaning in CMake than you might expect. In addition to adding a library to the command line of the linker, CMake also propagates properties of the target you link to.
+
+<sub>You can think of **linking** as _depending on_.</sub>
+
+The propagation of properties depends on their **visibility**:
+
+- **Private**: properties that are only used when building the target itself.
+- **Interface**: properties that are used when depending on this target.
+- **Public**: combination of private and interface.
+
+In practice you default to **private**, unless consumers of your library _require_ the property to build their target. In that case you use **public**.
+
+### Example
+
+The most intuitive example is with _include directories_. Imagine there are two targets:
+
+1. `StringUtils`: A library with string utilities.
+   - _Sources_: `StringUtils/src/stringutils.cpp`
+   - _Include directories_: `StringUtils/include`
+2. `DataProcessor`: An executable that uses functionality from `StringUtils` to process some data.
+   - _Sources_: `DataProcessor/src/main.cpp`
+   - _Link libraries_: `StringUtils`
+
+The _include directories_ property of `StringUtils` has to be **public**. If it was **private**, the `DataProcessor` target would fail to `#include <stringutils.hpp>` since the _include directories_ property is not propagated.
+
+The `cmake.toml` for this example would look something like this:
+
+```toml
+[project]
+name = "DataProcessor"
+
+[target.StringUtils]
+type = "static"
+sources = ["StringUtils/src/stringutils.cpp"]
+headers = ["StringUtils/include/stringutils.hpp"]
+include-directories = ["StringUtils/include"]
+
+[target.DataProcessor]
+type = "executable"
+sources = ["DataProcessor/src/main.cpp"]
+link-libraries = ["StringUtils"]
+```
@@ -2,14 +2,15 @@
 layout: page
 title: Reference
 permalink: /cmake-toml/
-nav_order: 1
+nav_order: 3
 ---

 # Reference

 This page is a reference for the options in the `cmake.toml` file. If you think anything is missing or unclear, please [edit this page](https://github.com/build-cpp/cmkr/edit/main/docs/cmake-toml.md) or open an [issue](https://github.com/build-cpp/cmkr/issues).

-See the [examples](/examples) section for concrete examples.
+This is a reference page. Check out the [examples](/examples) and the [cmkr topic](https://github.com/topics/cmkr) as well.
+{:.info}

 ## CMake configuration

@@ -27,6 +28,7 @@ name = "myproject"
 version = "1.0.0"
 description = "Description of the project"
 languages = ["C", "CXX"]
+msvc-runtime = "" # dynamic (implicit default), static
 cmake-before = """
 message(STATUS "CMake injected before the project() call")
 """
@@ -37,17 +39,45 @@ include-before = ["cmake/before-project.cmake"]
 include-after = ["cmake/after-project.cmake"]
 ```

+### Languages
+
+Supported languages are (see [`enable_language`](https://cmake.org/cmake/help/latest/command/enable_language.html) for more information):
+
+- `C`
+- `CXX` → C++
+- `CSharp` → C#
+- `CUDA`
+- `OBJC` → Objective-C
+- `OBJCXX` → Objective-C++
+- `Fortran`
+- `HIP`
+- `ISPC`
+- `Swift`
+- `ASM`
+- `ASM_MASM` → [Microsoft Macro Assembler (MASM)](https://learn.microsoft.com/en-US/cpp/assembler/masm/masm-for-x64-ml64-exe)
+- `ASM_NASM` → [Netwide Assembler (NASM)](https://www.nasm.us)
+- `ASM_MARMASM` [Microsoft ARM Assembler](https://learn.microsoft.com/en-us/cpp/assembler/arm/arm-assembler-command-line-reference)
+- `ASM-ATT`
+- `Java` (undocumented)
+- `RC` (undocumented)
+
+After a language is enabled, adding sources files with the corresponding extension to your target will automatically use the appropriate compiler/assembler for it.
+
+_Note_: It is generally discouraged to disable the `C` language, unless you are absolutely sure it is not used. Sometimes projects added with `fetch-content` implicitly require it and the error messages can be extremely confusing.
+
 ## Conditions

-You can specify your own conditions and use them in any `condition` field:
+You can specify your own named conditions and use them in any `condition` field:

 ```toml
 [conditions]
-arch64 = "CMAKE_SIZEOF_VOID_P EQUALS 8"
-arch32 = "CMAKE_SIZEOF_VOID_P EQUALS 4"
+ptr64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
+ptr32 = "CMAKE_SIZEOF_VOID_P EQUAL 4"
 ```

-This will make the `arch64` and `arch32` conditions available with their respective CMake expressions. 
+This will make the `ptr64` and `ptr32` conditions available with their respective CMake expressions.
+
+**Note**: condition names can only contain lower-case alphanumeric characters (`[0-9a-z]`) and dashes (`-`).

 You can also prefix most keys with `condition.` to represent a conditional:

@@ -55,9 +85,13 @@ You can also prefix most keys with `condition.` to represent a conditional:
 [target]
 type = "executable"
 sources = ["src/main.cpp"]
-windows.sources = ["src/windows_specific.cpp"]
+ptr64.sources = ["src/ptr64_only.cpp"]
 ```

+Instead of a named condition you can also specify a [CMake expression](https://cmake.org/cmake/help/latest/command/if.html#condition-syntax) in quotes. Instances of `$<name>` are replaced with the corresponding condition. For example: `"CONDITIONS_BUILD_TESTS AND $<linux>"` becomes `CONDITIONS_BUILD_TESTS AND (CMAKE_SYSTEM_NAME MATCHES "Linux")` in the final `CMakeLists.txt` file.
+
+### Predefined conditions
+
 The following conditions are predefined (you can override them if you desire):

 ```toml
@@ -68,11 +102,20 @@ unix = "UNIX"
 bsd = "CMAKE_SYSTEM_NAME MATCHES \"BSD\""
 linux = "CMAKE_SYSTEM_NAME MATCHES \"Linux\""
 gcc = "CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" OR CMAKE_C_COMPILER_ID STREQUAL \"GNU\""
-clang = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATCHES \"Clang\""
 msvc = "MSVC"
+clang = "(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\") OR (CMAKE_C_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\")"
+clang-cl = "(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\") OR (CMAKE_C_COMPILER_ID MATCHES \"Clang\" AND CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\")"
+clang-any = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATCHES \"Clang\""
 root = "CMKR_ROOT_PROJECT"
 x64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
 x32 = "CMAKE_SIZEOF_VOID_P EQUAL 4"
+android = "ANDROID"
+apple = "APPLE"
+bsd = "BSD"
+cygwin = "CYGWIN"
+ios = "IOS"
+xcode = "XCODE"
+wince = "WINCE"
 ```

 ## Subdirectories
@@ -90,19 +133,45 @@ include-before = ["cmake/before-subdir.cmake"]
 include-after = ["cmake/after-subdir.cmake"]
 ```

+## Options
+
+```toml
+[options]
+MYPROJECT_BUILD_TESTS = false
+MYPROJECT_SPECIAL_OPTION = { value = true, help = "Docstring for this option." }
+MYPROJECT_BUILD_EXAMPLES = "root"
+```
+
+Options correspond to [CMake cache variables](https://cmake.org/cmake/help/book/mastering-cmake/chapter/CMake%20Cache.html) that can be used to customize your project at configure-time. You can configure with `cmake -DMYPROJECT_BUILD_TESTS=ON` to enable the option. Every option automatically gets a corresponding [condition](#conditions). Additionally, a normalized condition is created based on the `[project].name` (i.e. `MYPROJECT_BUILD_TESTS` becomes `build-tests`).
+
+The special value `root` can be used to set the option to `true` if the project is compiled as the root project (it will be `false` if someone is including your project via `[fetch-content]` or `[subdir]`).
+
+## Variables
+
+```toml
+[variables]
+MYBOOL = true
+MYSTRING = "hello"
+```
+
+Variables emit a [`set`](https://cmake.org/cmake/help/latest/command/set.html) and can be used to configure subprojects and packages.
+
 ## Vcpkg

 ```toml
 [vcpkg]
-version = "2021.05.12"
-url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2021.05.12.tar.gz"
+version = "2024.03.25"
+url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2024.03.25.tar.gz"
 packages = ["fmt", "zlib"]
+overlay-ports = ["my-ports"]
 ```

 The vcpkg `version` will automatically generate the `url` from the [official repository](https://github.com/microsoft/vcpkg/releases). For a custom registry you can specify your own `url` (and omit the `version`). You can browse available packages on [vcpkg.io](https://vcpkg.io/en/packages.html).

 To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.

+The `overlay-ports` feature allows you to embed vcpkg ports inside your project, without having to fork the main vcpkg registry or creating a custom registry. You can find more information in the relevant [documentation](https://learn.microsoft.com/en-us/vcpkg/concepts/overlay-ports).
+
 ## Packages

 ```toml
@@ -123,6 +192,9 @@ components = ["mycomponent"]
 condition = "mycondition"
 git = "https://github.com/myuser/gitcontent"
 tag = "v0.1"
+shallow = false
+system = false
+subdir = ""

 [fetch-content.svncontent]
 condition = "mycondition"
@@ -132,9 +204,14 @@ rev = "svn_rev"
 [fetch-content.urlcontent]
 condition = "mycondition"
 url = "https://content-host.com/urlcontent.zip"
-hash = "123123123123"
+# These are equivalent, supported algorithms:
+# md5, sha1, sha224, sha256, sha384, sha512, sha3_224, sha3_256, sha3_384, sha3_512
+hash = "SHA1 502a4e25b8b209889c99c7fa0732102682c2e4ff"
+sha1 = "502a4e25b8b209889c99c7fa0732102682c2e4ff"
 ```

+Table keys that match CMake variable names (`[A-Z_]+`) will be passed to the [`FetchContent_Declare`](https://cmake.org/cmake/help/latest/module/FetchContent.html#command:fetchcontent_declare) command.
+
 ## Targets

 ```toml
@@ -144,6 +221,7 @@ alias = "mytarget::mytarget"
 type = "static" # executable, shared (DLL), static, interface, object, library, custom
 headers = ["src/mytarget.h"]
 sources = ["src/mytarget.cpp"]
+msvc-runtime = "" # dynamic (implicit default), static

 # The keys below match the target_xxx CMake commands
 # Keys prefixed with private- will get PRIVATE visibility
@@ -180,6 +258,29 @@ CXX_STANDARD_REQUIRED = true
 FOLDER = "MyFolder"
 ```

+## Templates
+
+To avoid repeating yourself you can create your own target type and use it in your targets:
+
+```toml
+[template.example]
+condition = "MYPROJECT_BUILD_EXAMPLES"
+type = "executable"
+link-libraries = ["myproject::mylib"]
+add-function = ""
+pass-sources = false
+
+# Properties from the template are merged with the ones here
+[target.myexample]
+type = "example"
+sources = ["src/myexample.cpp"]
+```
+
+The properties declared on a `template` are the same as the ones you use for targets. The only exceptions are:
+
+- `add-function`: Specifies a custom add function. Projects like [pybind11](https://pybind11.readthedocs.io/en/stable/cmake/index.html#new-findpython-mode) have their own `add_xxx` function, which you can specify here.
+- `pass-sources`: Pass sources directly to the add function instead of using `target_sources`.
+
 ## Tests and installation (unfinished)

 **Note**: The `[[test]]` and `[[install]]` are unfinished features and will likely change in a future release.
@@ -0,0 +1,31 @@
+---
+# Automatically generated from tests/compile-options/cmake.toml - DO NOT EDIT
+layout: default
+title: Compiler flags
+permalink: /examples/compile-options
+parent: Examples
+nav_order: 9
+---
+
+# Compiler flags
+
+Example project that sets compiler/linker flags for various platforms.
+
+```toml
+[project]
+name = "compile-options"
+description = "Compiler flags"
+
+[target.hello]
+type = "executable"
+sources = ["src/main.cpp"]
+msvc.compile-options = ["/W2"]
+gcc.compile-options = ["-Wall"]
+clang.compile-options = ["-Wall"]
+```
+
+The `hello` target uses [conditions](/cmake-toml#conditions) to set different compiler flags depending on the platform. See the [targets](/cmake-toml/#targets) documentation for other things you can set.
+
+_Note_: In general you only want to specify flags _required_ to compile your code without errors.
+
+<sup><sub>This page was automatically generated from [tests/compile-options/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/compile-options/cmake.toml).</sub></sup>
@@ -0,0 +1,34 @@
+---
+# Automatically generated from tests/msvc-runtime/cmake.toml - DO NOT EDIT
+layout: default
+title: Static MSVC runtime
+permalink: /examples/msvc-runtime
+parent: Examples
+nav_order: 8
+---
+
+# Static MSVC runtime
+
+
+
+```toml
+[project]
+name = "msvc-runtime"
+description = "Static MSVC runtime"
+msvc-runtime = "static"
+
+# This target will compile with a static runtime
+[target.static-runtime]
+type = "executable"
+sources = ["src/main.cpp"]
+
+# This target overrides the [project].msvc-runtime
+[target.dynamic-runtime]
+type = "executable"
+sources = ["src/main.cpp"]
+msvc-runtime = "dynamic"
+```
+
+
+
+<sup><sub>This page was automatically generated from [tests/msvc-runtime/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/msvc-runtime/cmake.toml).</sub></sup>
@@ -19,7 +19,7 @@ description = "Dependencies from vcpkg"
 # See https://github.com/microsoft/vcpkg/releases for vcpkg versions
 # See https://vcpkg.io/en/packages.html for available packages
 [vcpkg]
-version = "2021.05.12"
+version = "2024.03.25"
 packages = ["fmt"]

 [find-package]
@@ -1,10 +1,10 @@
---
-layout: null
-permalink: /getting-started/
---
-
-<html>
-    <head>
-        <meta http-equiv="refresh" content="0;url=https://cmkr.build">
-    </head>
+---
+layout: null
+permalink: /getting-started/
+---
+
+<html>
+    <head>
+        <meta http-equiv="refresh" content="0;url=https://cmkr.build">
+    </head>
 </html>
@@ -1,12 +1,12 @@
 ---
 layout: home
-title: Index
+title: Documentation
 nav_order: 0
 ---

-# Index
+# Documentation

-`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).
+[`cmkr`](https://github.com/build-cpp/cmkr), pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).

 `cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:

@@ -19,27 +19,29 @@ type = "executable"
 sources = ["src/main.cpp"]
 ```

-`cmkr` can bootstrap itself from CMake and you only need CMake to use it.
+`cmkr` can bootstrap itself, and you only need CMake and a C++ compiler to use it.

 ## Getting started

-To get started run the following commands from your project directory:
+To get started, run the following commands from your project directory:

 ```sh
 curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
 cmake -P cmkr.cmake
 ```

-After the bootstrapping process finishes, modify [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) and open the project in your favorite IDE or build with CMake:
+After the bootstrapping process finishes, customize [`cmake.toml`](./cmake-toml) for your project and run CMake:

 ```sh
 cmake -B build
 cmake --build build
 ```

-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt`.
+Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.

-In CI settings the `cmkr` bootstrapping process is skipped so there is no extra configure-time overhead in your pipelines.
+<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
+
+In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.

 ## Template repositories

@@ -59,10 +61,10 @@ Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/rele
 ```
 Usage: cmkr [arguments]
 arguments:
-    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
+    init    [executable|library|shared|static|interface] Create a project.
    gen                                                  Generates CMakeLists.txt file.
    build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install. Needs admin privileges.
+    install                                              Run cmake --install.
    clean                                                Clean the build directory.
    help                                                 Show help.
    version                                              Current cmkr version.
@@ -70,8 +72,10 @@ arguments:

 ## Credits

- https://github.com/gulrak/filesystem
- https://github.com/Tessil/ordered-map
- https://github.com/ToruNiina/toml11
- https://github.com/mpark/variant
- https://www.svgrepo.com/svg/192268/hammer
+- [gulrak/filesystem](https://github.com/gulrak/filesystem)
+- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
+- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
+- [mpark/variant](https://github.com/mpark/variant)
+- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
+- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
+- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️
@@ -0,0 +1,83 @@
+---
+layout: page
+title: Philosophy
+nav_order: 2
+published: false
+---
+
+# Philosophy
+
+## Problem statement
+
+Similar to writing good C++, writing good CMake is difficult. The main difference is that nobody actually wants to learn CMake. The build system is something that should "just work".
+
+There have been many attempts at creating new build systems (with varying levels of success). Naturally this causes [competing standards](https://xkcd.com/927/), which is undesirable. CMake is pretty much the de facto standard, and it has seen extensive use in complex software projects.
+
+One of the main issues of CMake is the turing-complete scripting language you use to describe your projects. As your project gets more complex this can be very helpful, but it also unnecessarily complicates simple projects. There have been discussions about a declarative language on the [CMake issue tracker](https://gitlab.kitware.com/cmake/cmake/-/issues/19891) to solve this problem, but it looks like a "LISP-like" language is seriously being considered...
+
+## The solution
+
+The way cmkr (pronounced "cmaker") solves this problem is by using [TOML](https://toml.io/). Below is a minimal `cmake.toml` project:
+
+```toml
+[project]
+name = "cmkr_for_beginners"
+
+[target.hello_world]
+type = "executable"
+sources = ["src/main.cpp"]
+```
+
+The key difference between `cmkr` and other build systems is that it _generates_ CMake. This means that your projects are fully compatible with the CMake ecosystem, and you can try it out without having to rewrite your whole build system.
+
+TODO: link/include more examples? Talk about conditions, packaging (missing)
+
+### Another layer?!
+
+A common issue people have with cmkr is that it introduces an additional layer of indirection to your build system. CMake is already a meta-buildsystem, which means you could call cmkr a "meta-meta-buildsystem".
+
+Presumably the reason for this friction is that additional layers of abstraction introduce additional complexity. Because of this cmkr has been designed to be completely seamless:
+
+- The user doesn't have to install any additional software to use cmkr. All you need is a semi-recent version of CMake and a C++ compiler.
+- Modifying `cmake.toml` automatically triggers a regeneration of `CMakeLists.txt`. There is no change to your build process.
+- The `CMakeLists.txt` is generated to be human-readable. This means you can easily "eject" from cmkr and go back to CMake.
+
+An additional argument for cmkr is that anecdotally people say it "just works". Because of its simplicity it's also easy to teach, even to people without programming experience.
+
+There is also precedent in the JavaScript community. Bundlers and translators are the norm there and their developer experience is miles ahead of C++.
+
+<sub>Not to say the JavaScript ecosystem is without its flaws, but generators does not appear to be one of them</sub>
+
+### Unsupported features
+
+Because cmkr is still in early in development there are many missing/unfinished features. It was decided that users can bridge the gap by including CMake at arbitrary locations.
+
+This has the advantage that it forces complexity in the build system to be self-contained and modular, a problem all too common in projects as they age.
+
+## Enterprise
+
+Words like "bootstrapping" and "generating code" might worry engineers working in an enterprise environment, and rightly so. From the beginning it has been a priority to make cmkr suitable for use in big corporations with strict protocols for security and reproducibility.
+
+### No additional dependencies
+
+As mentioned above, the only thing you need is a working C++ compiler and a semi-recent version of CMake. It is assumed that you are already building (and executing) C++ projects on your servers, so cmkr does not introduce additional requirements.
+
+All the logic for downloading and compiling the `cmkr` executable is self-contained in a ~250 line `cmkr.cmake` script. You can easily audit it and see if it's up to your standards.
+
+### Reproducibility
+
+Per default the `cmkr.cmake` bootstrapping script contains the exact version of cmkr used to generate your project. As long as the cmkr repository is available you will build the exact same version of cmkr, which will generate the exact same `CMakeLists.txt` file.
+
+This also means that cmkr can decide to break backwards compatibility without affecting legacy projects. An effort will always be made to maintain backwards compatibility though.
+
+### Integrity
+
+As an additional safeguard you can modify `cmkr.cmake` to pin the version tag to a commit hash. This hash is checked to ensure the integrity of the upstream repository.
+
+### Availability
+
+You can easily point `cmkr.cmake` to a mirror of the cmkr repository to ensure availability should something catastrophic happen.
+
+### Not executed in CI
+
+The final (and key) feature is that the bootstrapping process is never executed in CI environments. This means `cmkr` is only ever executed on your developer's machines and not on your infrastructure.
@@ -1,2 +0,0 @@
-bundle exec just-the-docs rake search:init
-bundle exec jekyll serve --livereload
@@ -1,2 +1,2 @@
 bundle install
-bundle exec jekyll serve --force_polling --livereload --incremental
+bundle exec jekyll serve --force_polling --livereload --incremental
@@ -7,5 +7,3 @@ const char *handle_args(int argc, char **argv);

 } // namespace args
 } // namespace cmkr
-
-const char *cmkr_args_handle_args(int, char **);
@@ -11,9 +11,3 @@ int install();

 } // namespace build
 } // namespace cmkr
-
-int cmkr_build_run(int argc, char **argv);
-
-int cmkr_build_clean();
-
-int cmkr_build_install();
@@ -1,27 +0,0 @@
-#pragma once
-
-namespace cmkr {
-namespace error {
-
-struct Status {
-    enum class Code {
-        Success = 0,
-        RuntimeError,
-        InitError,
-        GenerationError,
-        BuildError,
-        CleanError,
-        InstallError,
-    };
-    Status(Code ec) noexcept;
-    operator int() const noexcept;
-    Code code() const noexcept;
-
-  private:
-    Code ec_ = Code::Success;
-};
-
-} // namespace error
-} // namespace cmkr
-
-const char *cmkr_error_status_string(int);
@@ -1,8 +1,6 @@
 #pragma once

-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) ||                                             \
-     (defined(__cplusplus) && __cplusplus >= 201703L)) &&                                          \
-    defined(__has_include)
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
 #if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
 #define GHC_USE_STD_FS
 #include <filesystem>
@@ -12,4 +10,4 @@ namespace fs = std::filesystem;
 #ifndef GHC_USE_STD_FS
 #include <ghc/filesystem.hpp>
 namespace fs = ghc::filesystem;
-#endif
+#endif
@@ -9,7 +9,3 @@ const char *message() noexcept;

 } // namespace help
 } // namespace cmkr
-
-const char *cmkr_help_version(void);
-
-const char *cmkr_help_message(void);
@@ -1,9 +1,11 @@
 #pragma once

-#include <mpark/variant.hpp>
-#include <string>
-#include <tsl/ordered_map.h>
 #include <vector>
+#include <string>
+
+#include <mpark/variant.hpp>
+#include <tsl/ordered_map.h>
+#include <tsl/ordered_set.h>

 namespace cmkr {
 namespace parser {
@@ -13,18 +15,18 @@ using Condition = tsl::ordered_map<std::string, T>;

 using ConditionVector = Condition<std::vector<std::string>>;

-struct Setting {
+struct Variable {
    std::string name;
-    std::string comment;
-    mpark::variant<bool, std::string> val;
+    std::string help;
+    mpark::variant<bool, std::string> value;
    bool cache = false;
    bool force = false;
 };

 struct Option {
    std::string name;
-    std::string comment;
-    bool val = false;
+    std::string help;
+    mpark::variant<bool, std::string> value;
 };

 struct Package {
@@ -46,6 +48,11 @@ struct Vcpkg {
    };

    std::vector<Package> packages;
+    std::vector<std::string> overlay_ports;
+
+    bool enabled() const {
+        return !packages.empty();
+    }
 };

 enum TargetType {
@@ -67,7 +74,6 @@ struct Target {
    TargetType type = target_last;
    std::string type_name;

-    ConditionVector headers;
    ConditionVector sources;

    // https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html#project-commands
@@ -150,9 +156,21 @@ struct Content {
    Condition<std::string> cmake_after;
    ConditionVector include_before;
    ConditionVector include_after;
+    bool system = false;
+    std::string subdir;
 };

+enum MsvcRuntimeType {
+    msvc_dynamic,
+    msvc_static,
+    msvc_last,
+};
+
+extern const char *msvcRuntimeTypeNames[msvc_last];
+
 struct Project {
+    const Project *parent;
+
    // This is the CMake version required to use all cmkr versions.
    std::string cmake_version = "3.15";
    std::string cmkr_include = "cmkr.cmake";
@@ -170,11 +188,13 @@ struct Project {
    std::string project_version;
    std::string project_description;
    std::vector<std::string> project_languages;
+    bool project_allow_unknown_languages = false;
+    MsvcRuntimeType project_msvc_runtime = msvc_last;
    Condition<std::string> cmake_before;
    Condition<std::string> cmake_after;
    ConditionVector include_before;
    ConditionVector include_after;
-    std::vector<Setting> settings;
+    std::vector<Variable> variables;
    std::vector<Option> options;
    std::vector<Package> packages;
    Vcpkg vcpkg;
@@ -187,9 +207,12 @@ struct Project {
    std::vector<Subdir> subdirs;

    Project(const Project *parent, const std::string &path, bool build);
+    const Project *root() const;
+    bool cmake_minimum_version(int major, int minor) const;
+    static bool is_condition_name(const std::string &name);
 };

 bool is_root_path(const std::string &path);

 } // namespace parser
-} // namespace cmkr
+} // namespace cmkr
@@ -2,10 +2,8 @@
 #include "build.hpp"
 #include "cmake_generator.hpp"
 #include "help.hpp"
-
 #include "fs.hpp"
-#include <exception>
-#include <iostream>
+
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -37,17 +35,17 @@ const char *handle_args(int argc, char **argv) {
    } else if (main_arg == "build") {
        auto ret = build::run(argc, argv);
        if (ret)
-            return "CMake build error!";
+            throw std::runtime_error("CMake build failed!");
        return "CMake build completed!";
    } else if (main_arg == "install") {
        auto ret = build::install();
        if (ret)
-            return "CMake install error!";
+            throw std::runtime_error("CMake install failed!");
        return "CMake install completed!";
    } else if (main_arg == "clean") {
        auto ret = build::clean();
        if (ret)
-            return "CMake clean error!";
+            throw std::runtime_error("CMake clean failed!");
        return "Cleaned build directory!";
    } else {
        throw std::runtime_error(cmkr::help::message());
@@ -55,13 +53,3 @@ const char *handle_args(int argc, char **argv) {
 }
 } // namespace args
 } // namespace cmkr
-
-const char *cmkr_args_handle_args(int argc, char **argv) {
-    try {
-        return cmkr::args::handle_args(argc, argv);
-    } catch (const std::exception &e) {
-        return e.what();
-    } catch (...) {
-        return "Unknown error!";
-    }
-}
@@ -1,14 +1,10 @@
 #include "build.hpp"
 #include "cmake_generator.hpp"
-#include "error.hpp"
 #include "project_parser.hpp"

 #include "fs.hpp"
-#include <cstddef>
 #include <cstdlib>
 #include <sstream>
-#include <stdexcept>
-#include <system_error>

 namespace cmkr {
 namespace build {
@@ -17,7 +13,7 @@ int run(int argc, char **argv) {
    parser::Project project(nullptr, ".", true);
    if (argc > 2) {
        for (int i = 2; i < argc; ++i) {
-            project.build_args.push_back(argv[i]);
+            project.build_args.emplace_back(argv[i]);
        }
    }
    std::stringstream ss;
@@ -48,13 +44,13 @@ int run(int argc, char **argv) {
 }

 int clean() {
-    bool ret = false;
+    bool success = false;
    parser::Project project(nullptr, ".", true);
    if (fs::exists(project.build_dir)) {
-        ret = fs::remove_all(project.build_dir);
+        success = fs::remove_all(project.build_dir);
        fs::create_directory(project.build_dir);
    }
-    return !ret;
+    return success ? EXIT_SUCCESS : EXIT_FAILURE;
 }

 int install() {
@@ -64,33 +60,3 @@ int install() {
 }
 } // namespace build
 } // namespace cmkr
-
-int cmkr_build_run(int argc, char **argv) {
-    try {
-        return cmkr::build::run(argc, argv);
-    } catch (const std::system_error &e) {
-        return e.code().value();
-    } catch (...) {
-        return cmkr::error::Status(cmkr::error::Status::Code::BuildError);
-    }
-}
-
-int cmkr_build_clean(void) {
-    try {
-        return cmkr::build::clean();
-    } catch (const std::system_error &e) {
-        return e.code().value();
-    } catch (...) {
-        return cmkr::error::Status(cmkr::error::Status::Code::CleanError);
-    }
-}
-
-int cmkr_build_install(void) {
-    try {
-        return cmkr::build::install();
-    } catch (const std::system_error &e) {
-        return e.code().value();
-    } catch (...) {
-        return cmkr::error::Status(cmkr::error::Status::Code::InstallError);
-    }
-}
@@ -1,25 +0,0 @@
-#include "error.hpp"
-
-#include <cassert>
-
-namespace cmkr {
-namespace error {
-
-Status::Status(Code ec) noexcept : ec_(ec) {}
-
-Status::operator int() const noexcept { return static_cast<int>(ec_); }
-
-Status::Code Status::code() const noexcept { return ec_; }
-
-} // namespace error
-} // namespace cmkr
-
-// strings for cmkr::error::Status::Code
-static const char *err_string[] = {
-    "Success", "Runtime error", "Initialization error", "CMake generation error", "Build error", "Clean error", "Install error",
-};
-
-const char *cmkr_error_status(int i) {
-    assert(i >= 0 && i < (sizeof(err_string) / sizeof(*(err_string))));
-    return err_string[i];
-}
@@ -4,7 +4,9 @@
 namespace cmkr {
 namespace help {

-const char *version() noexcept { return "cmkr version " CMKR_VERSION; }
+const char *version() noexcept {
+    return "cmkr version " CMKR_VERSION;
+}

 const char *message() noexcept {
    return R"lit(
@@ -21,7 +23,3 @@ arguments:
 }
 } // namespace help
 } // namespace cmkr
-
-const char *cmkr_help_version(void) { return cmkr::help::version(); }
-
-const char *cmkr_help_message(void) { return cmkr::help::message(); }
@@ -4,8 +4,6 @@
 #include <deque>
 #include <stdexcept>
 #include <toml.hpp>
-#include <tsl/ordered_map.h>
-#include <tsl/ordered_set.h>

 namespace cmkr {
 namespace parser {
@@ -21,16 +19,27 @@ static TargetType parse_targetType(const std::string &name) {
    return target_last;
 }

+const char *msvcRuntimeTypeNames[msvc_last] = {"dynamic", "static"};
+
+static MsvcRuntimeType parse_msvcRuntimeType(const std::string &name) {
+    for (int i = 0; i < msvc_last; i++) {
+        if (name == msvcRuntimeTypeNames[i]) {
+            return static_cast<MsvcRuntimeType>(i);
+        }
+    }
+    return msvc_last;
+}
+
 using TomlBasicValue = toml::basic_value<toml::discard_comments, tsl::ordered_map, std::vector>;

-static std::string format_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+static std::string format_key_message(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
    auto loc = value.location();
    auto line_number_str = std::to_string(loc.line());
    auto line_width = line_number_str.length();
-    auto line_str = loc.line_str();
+    const auto &line_str = loc.line_str();

    std::ostringstream oss;
-    oss << "[error] " << error << '\n';
+    oss << message << "\n";
    oss << " --> " << loc.file_name() << ':' << loc.line() << '\n';

    oss << std::string(line_width + 2, ' ') << "|\n";
@@ -48,14 +57,24 @@ static std::string format_key_error(const std::string &error, const toml::key &k
    return oss.str();
 }

+static void throw_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
+    throw std::runtime_error(format_key_message("[error] " + error, ky, value));
+}
+
+static void print_key_warning(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
+    puts(format_key_message("[warning] " + message, ky, value).c_str());
+}
+
 class TomlChecker {
    const TomlBasicValue &m_v;
    tsl::ordered_set<toml::key> m_visited;
    tsl::ordered_set<toml::key> m_conditionVisited;

  public:
-    TomlChecker(const TomlBasicValue &v, const toml::key &ky) : m_v(toml::find(v, ky)) {}
-    TomlChecker(const TomlBasicValue &v) : m_v(v) {}
+    TomlChecker(const TomlBasicValue &v, const toml::key &ky) : m_v(toml::find(v, ky)) {
+    }
+    explicit TomlChecker(const TomlBasicValue &v) : m_v(v) {
+    }
    TomlChecker(const TomlChecker &) = delete;
    TomlChecker(TomlChecker &&) = delete;

@@ -109,36 +128,40 @@ class TomlChecker {
        return toml::find(m_v, ky);
    }

-    void visit(const toml::key &ky) { m_visited.emplace(ky); }
+    void visit(const toml::key &ky) {
+        m_visited.emplace(ky);
+    }

-    bool visisted(const toml::key &ky) const { return m_visited.contains(ky); }
+    bool visisted(const toml::key &ky) const {
+        return m_visited.contains(ky);
+    }

    void check(const tsl::ordered_map<std::string, std::string> &conditions) const {
        for (const auto &itr : m_v.as_table()) {
            const auto &ky = itr.first;
            if (m_conditionVisited.contains(ky)) {
-                if (!conditions.contains(ky)) {
-                    throw std::runtime_error(format_key_error("Unknown condition '" + ky + "'", ky, itr.second));
+                if (!conditions.contains(ky) && Project::is_condition_name(ky)) {
+                    throw_key_error("Unknown condition '" + ky + "'", ky, itr.second);
                }

                for (const auto &jtr : itr.second.as_table()) {
                    if (!m_visited.contains(jtr.first)) {
-                        throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                        throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
                    }
                }
            } else if (!m_visited.contains(ky)) {
                if (itr.second.is_table()) {
                    for (const auto &jtr : itr.second.as_table()) {
                        if (!m_visited.contains(jtr.first)) {
-                            throw std::runtime_error(format_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second));
+                            throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
                        }
                    }
                }
-                throw std::runtime_error(format_key_error("Unknown key '" + ky + "'", ky, itr.second));
+                throw_key_error("Unknown key '" + ky + "'", ky, itr.second);
            } else if (ky == "condition") {
                std::string condition = itr.second.as_string();
-                if (!conditions.contains(condition)) {
-                    throw std::runtime_error(format_key_error("Unknown condition '" + condition + "'", condition, itr.second));
+                if (!conditions.contains(condition) && Project::is_condition_name(condition)) {
+                    throw_key_error("Unknown condition '" + condition + "'", condition, itr.second);
                }
            }
        }
@@ -152,7 +175,8 @@ class TomlCheckerRoot {
    bool m_checked = false;

  public:
-    TomlCheckerRoot(const TomlBasicValue &root) : m_root(root) {}
+    explicit TomlCheckerRoot(const TomlBasicValue &root) : m_root(root) {
+    }
    TomlCheckerRoot(const TomlCheckerRoot &) = delete;
    TomlCheckerRoot(TomlCheckerRoot &&) = delete;

@@ -175,7 +199,7 @@ class TomlCheckerRoot {
        if (check_root) {
            for (const auto &itr : m_root.as_table()) {
                if (!m_visisted.contains(itr.first)) {
-                    throw std::runtime_error(format_key_error("Unknown key '" + itr.first + "'", itr.first, itr.second));
+                    throw_key_error("Unknown key '" + itr.first + "'", itr.first, itr.second);
                }
            }
        }
@@ -185,7 +209,7 @@ class TomlCheckerRoot {
    }
 };

-Project::Project(const Project *parent, const std::string &path, bool build) {
+Project::Project(const Project *parent, const std::string &path, bool build) : parent(parent) {
    const auto toml_path = fs::path(path) / "cmake.toml";
    if (!fs::exists(toml_path)) {
        throw std::runtime_error("File not found '" + toml_path.string() + "'");
@@ -203,7 +227,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
        cmake.required("version", cmake_version);

        if (cmake.contains("bin-dir")) {
-            throw std::runtime_error("bin-dir has been renamed to build-dir");
+            throw_key_error("bin-dir has been renamed to build-dir", "bin-dir", cmake.find("bin-dir"));
        }

        cmake.optional("build-dir", build_dir);
@@ -241,11 +265,22 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
        conditions["bsd"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "BSD")cmake";
        conditions["linux"] = conditions["lunix"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "Linux")cmake";
        conditions["gcc"] = R"cmake(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")cmake";
-        conditions["clang"] = R"cmake(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "Clang")cmake";
        conditions["msvc"] = R"cmake(MSVC)cmake";
+        conditions["clang"] =
+            R"cmake((CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$") OR (CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$"))cmake";
+        conditions["clang-cl"] =
+            R"cmake((CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$") OR (CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$"))cmake";
+        conditions["clang-any"] = R"cmake(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "Clang")cmake";
        conditions["root"] = R"cmake(CMKR_ROOT_PROJECT)cmake";
        conditions["x64"] = R"cmake(CMAKE_SIZEOF_VOID_P EQUAL 8)cmake";
        conditions["x32"] = R"cmake(CMAKE_SIZEOF_VOID_P EQUAL 4)cmake";
+        conditions["android"] = R"cmake(ANDROID)cmake";
+        conditions["apple"] = R"cmake(APPLE)cmake";
+        conditions["bsd"] = R"cmake(BSD)cmake";
+        conditions["cygwin"] = R"cmake(CYGWIN)cmake";
+        conditions["ios"] = R"cmake(IOS)cmake";
+        conditions["xcode"] = R"cmake(XCODE)cmake";
+        conditions["wince"] = R"cmake(WINCE)cmake";
    } else {
        conditions = parent->conditions;
        templates = parent->templates;
@@ -254,6 +289,9 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
    if (checker.contains("conditions")) {
        auto conds = toml::find<decltype(conditions)>(toml, "conditions");
        for (const auto &cond : conds) {
+            if (!is_condition_name(cond.first)) {
+                throw_key_error("Invalid condition name '" + cond.first + "'", cond.first, toml::find(toml::find(toml, "conditions"), cond.first));
+            }
            conditions[cond.first] = cond.second;
        }
    }
@@ -264,11 +302,27 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
        project.optional("version", project_version);
        project.optional("description", project_description);
        project.optional("languages", project_languages);
+        project.optional("allow-unknown-languages", project_allow_unknown_languages);
        project.optional("cmake-before", cmake_before);
        project.optional("cmake-after", cmake_after);
        project.optional("include-before", include_before);
        project.optional("include-after", include_after);
        project.optional("subdirs", project_subdirs);
+
+        std::string msvc_runtime;
+        project.optional("msvc-runtime", msvc_runtime);
+        if (!msvc_runtime.empty()) {
+            project_msvc_runtime = parse_msvcRuntimeType(msvc_runtime);
+            if (project_msvc_runtime == msvc_last) {
+                std::string error = "Unknown runtime '" + msvc_runtime + "'\n";
+                error += "Available types:\n";
+                for (std::string type_name : msvcRuntimeTypeNames) {
+                    error += "  - " + type_name + "\n";
+                }
+                error.pop_back(); // Remove last newline
+                throw_key_error(error, msvc_runtime, project.find("msvc-runtime"));
+            }
+        }
    }

    if (checker.contains("subdir")) {
@@ -288,36 +342,65 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
        }
    }

-    if (checker.contains("settings")) {
+    if (checker.contains("variables")) {
        using set_map = tsl::ordered_map<std::string, TomlBasicValue>;
-        const auto &sets = toml::find<set_map>(toml, "settings");
-        for (const auto &itr : sets) {
-            Setting s;
+        auto vars = toml::find<set_map>(toml, "variables");
+        if (checker.contains("settings")) {
+            print_key_warning("[settings] has been renamed to [variables]", "settings", toml.at("settings"));
+            const auto &sets = toml::find<set_map>(toml, "settings");
+            for (const auto &itr : sets) {
+                if (!vars.insert(itr).second) {
+                    throw_key_error("Key '" + itr.first + "' shadows existing variable", itr.first, itr.second);
+                }
+            }
+        }
+
+        for (const auto &itr : vars) {
+            Variable s;
            s.name = itr.first;
            const auto &value = itr.second;
            if (value.is_boolean()) {
-                s.val = value.as_boolean();
+                s.value = value.as_boolean();
            } else if (value.is_string()) {
-                s.val = value.as_string();
+                s.value = value.as_string();
            } else {
                auto &setting = checker.create(value);
-                setting.optional("comment", s.comment);
+                setting.optional("help", s.help);
                if (setting.contains("value")) {
                    const auto &v = setting.find("value");
                    if (v.is_boolean()) {
-                        s.val = v.as_boolean();
+                        s.value = v.as_boolean();
                    } else {
-                        s.val = v.as_string();
+                        s.value = v.as_string();
                    }
                }
                setting.optional("cache", s.cache);
                setting.optional("force", s.force);
            }
-            settings.push_back(s);
+            variables.push_back(s);
        }
    }

    if (checker.contains("options")) {
+        auto normalize = [](const std::string &name) {
+            std::string normalized;
+            for (char ch : name) {
+                if (ch == '_') {
+                    normalized += '-';
+                } else if (ch >= 'A' && ch <= 'Z') {
+                    ch += ('a' - 'A');
+                    normalized += ch;
+                } else if (ch == '-' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z')) {
+                    normalized += ch;
+                } else {
+                    // Ignore all other characters
+                }
+            }
+            return normalized;
+        };
+        auto nproject_prefix = normalize(project_name);
+        nproject_prefix += '-';
+
        using opts_map = tsl::ordered_map<std::string, TomlBasicValue>;
        const auto &opts = toml::find<opts_map>(toml, "options");
        for (const auto &itr : opts) {
@@ -325,13 +408,51 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
            o.name = itr.first;
            const auto &value = itr.second;
            if (value.is_boolean()) {
-                o.val = value.as_boolean();
-            } else {
+                o.value = value.as_boolean();
+            } else if (value.is_string()) {
+                auto str = std::string(value.as_string());
+                if (str == "root") {
+                    o.value = std::string("${CMKR_ROOT_PROJECT}");
+                } else {
+                    throw_key_error("Unsupported option value '" + str + "'", str, value);
+                }
+            } else if (value.is_table()) {
                auto &option = checker.create(value);
-                option.optional("comment", o.comment);
-                option.optional("value", o.val);
+                option.optional("help", o.help);
+                if (option.contains("value")) {
+                    const auto &ovalue = option.find("value");
+                    if (ovalue.is_boolean()) {
+                        o.value = ovalue.as_boolean();
+                    } else if (ovalue.is_string()) {
+                        auto str = std::string(ovalue.as_string());
+                        if (str == "root") {
+                            o.value = std::string("${CMKR_ROOT_PROJECT}");
+                        } else {
+                            throw_key_error("Unsupported option value '" + str + "'", str, value);
+                        }
+                    } else {
+                        throw_key_error(toml::concat_to_string("Unsupported value type: ", ovalue.type()), "value", value);
+                    }
+                }
+            } else {
+                throw_key_error(toml::concat_to_string("Unsupported value type: ", itr.second.type()), itr.first, itr.second);
            }
            options.push_back(o);
+
+            // Add a condition matching the option name
+            conditions.emplace(o.name, o.name);
+
+            // Add an implicit condition for the option
+            auto ncondition = normalize(o.name);
+            if (ncondition.find(nproject_prefix) == 0) {
+                ncondition = ncondition.substr(nproject_prefix.size());
+            }
+            if (!ncondition.empty()) {
+                if (conditions.contains(ncondition)) {
+                    print_key_warning("Option '" + o.name + "' would create a condition '" + ncondition + "' that already exists", o.name, value);
+                }
+                conditions.emplace(ncondition, o.name);
+            }
        }
    }

@@ -368,6 +489,15 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
            c.optional("cmake-after", content.cmake_after);
            c.optional("include-before", content.include_before);
            c.optional("include-after", content.include_after);
+            c.optional("system", content.system);
+
+            // Check if the minimum version requirement is satisfied (CMake 3.25)
+            if (c.contains("system") && !this->cmake_minimum_version(3, 25)) {
+                throw_key_error("The system argument is only supported on CMake version 3.25 and above.\nSet the CMake version in cmake.toml:\n"
+                                "[cmake]\n"
+                                "version = \"3.25\"\n",
+                                "system", "");
+            }

            for (const auto &argItr : itr.second.as_table()) {
                std::string value;
@@ -413,17 +543,30 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
                    key = "URL";
                } else if (hash_algorithms.contains(key)) {
                    std::string algo;
-                    for (auto c : key) {
-                        algo.push_back(std::toupper(c));
+                    for (auto ch : key) {
+                        if (ch >= 'a' && ch <= 'z') {
+                            ch -= ('a' - 'A');
+                        }
+                        algo.push_back(ch);
                    }
                    key = "URL_HASH";
+                    if (value.empty()) {
+                        throw_key_error("Empty hash value", argItr.first, argItr.second);
+                    }
+                    for (char c : value) {
+                        if (!std::isxdigit(c)) {
+                            throw_key_error("Hash value must be a hex string", argItr.first, argItr.second);
+                        }
+                    }
                    value = algo + "=" + value;
                } else if (key == "hash") {
                    key = "URL_HASH";
+                } else if (key == "subdir") {
+                    key = "SOURCE_SUBDIR";
                } else if (is_cmake_arg(key)) {
                    // allow passthrough of ExternalProject options
                } else if (!c.visisted(key)) {
-                    throw std::runtime_error(format_key_error("Unknown key '" + argItr.first + "'", argItr.first, argItr.second));
+                    throw_key_error("Unknown key '" + argItr.first + "'", argItr.first, argItr.second);
                }

                // Make sure not to emit keys like "condition" in the FetchContent call
@@ -438,7 +581,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
    }

    if (checker.contains("bin")) {
-        throw std::runtime_error("[[bin]] has been renamed to [[target]]");
+        throw_key_error("[[bin]] has been renamed to [target.<name>]", "", toml.at("bin"));
    }

    auto parse_target = [&](const std::string &name, TomlChecker &t, bool isTemplate) {
@@ -477,12 +620,21 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
                }
            }
            error.pop_back(); // Remove last newline
-            throw std::runtime_error(format_key_error(error, target.type_name, t.find("type")));
+            throw_key_error(error, target.type_name, t.find("type"));
        }

-        t.optional("headers", target.headers);
        t.optional("sources", target.sources);

+        // Merge the headers into the sources
+        ConditionVector headers;
+        t.optional("headers", headers);
+        for (const auto &itr : headers) {
+            auto &dest = target.sources[itr.first];
+            for (const auto &jtr : itr.second) {
+                dest.push_back(jtr);
+            }
+        }
+
        t.optional("compile-definitions", target.compile_definitions);
        t.optional("private-compile-definitions", target.private_compile_definitions);

@@ -501,16 +653,66 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
        t.optional("link-libraries", target.link_libraries);
        t.optional("private-link-libraries", target.private_link_libraries);

+        // Add support for relative paths for (private-)link-libraries
+        const auto fix_relative_paths = [&name, &path](ConditionVector &libraries, const char *key) {
+            for (const auto &library_entries : libraries) {
+                for (auto &library_path : libraries[library_entries.first]) {
+                    // Skip processing paths with potential CMake macros in them (this check isn't perfect)
+                    // https://cmake.org/cmake/help/latest/manual/cmake-language.7.html#variable-references
+                    if ((library_path.find("${") != std::string::npos || library_path.find("$ENV{") != std::string::npos ||
+                         library_path.find("$CACHE{") != std::string::npos) &&
+                        library_path.find('}') != std::string::npos) {
+                        continue;
+                    }
+
+                    if (fs::exists(fs::path(path) / library_path)) {
+                        // If the file path is relative, prepend ${CMAKE_CURRENT_SOURCE_DIR}
+                        library_path.insert(0, "${CMAKE_CURRENT_SOURCE_DIR}/");
+                    } else if (library_path.find_first_of(R"(\/)") != std::string::npos) {
+                        // Error if the path contains a directory separator and the file doesn't exist
+                        throw std::runtime_error("Attempted to link against a library file that doesn't exist for target \"" + name + "\" in \"" +
+                                                 key + "\": " + library_path);
+                    } else {
+                        // NOTE: We cannot check if system libraries exist, so we leave them as-is
+                    }
+                }
+            }
+        };
+        fix_relative_paths(target.link_libraries, "link-libraries");
+        fix_relative_paths(target.private_link_libraries, "private-link-libraries");
+
        t.optional("link-options", target.link_options);
        t.optional("private-link-options", target.private_link_options);

        t.optional("precompile-headers", target.precompile_headers);
        t.optional("private-precompile-headers", target.private_precompile_headers);

-        if (!target.headers.empty()) {
-            auto &sources = target.sources.nth(0).value();
-            const auto &headers = target.headers.nth(0)->second;
-            sources.insert(sources.end(), headers.begin(), headers.end());
+        Condition<std::string> msvc_runtime;
+        t.optional("msvc-runtime", msvc_runtime);
+        for (const auto &cond_itr : msvc_runtime) {
+            switch (parse_msvcRuntimeType(cond_itr.second)) {
+            case msvc_dynamic:
+                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL";
+                break;
+            case msvc_static:
+                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>";
+                break;
+            default: {
+                std::string error = "Unknown runtime '" + cond_itr.second + "'\n";
+                error += "Available types:\n";
+                for (std::string type_name : msvcRuntimeTypeNames) {
+                    error += "  - " + type_name + "\n";
+                }
+                error.pop_back(); // Remove last newline
+                const TomlBasicValue *report;
+                if (cond_itr.first.empty()) {
+                    report = &t.find("msvc-runtime");
+                } else {
+                    report = &t.find(cond_itr.first).as_table().find("msvc-runtime").value();
+                }
+                throw_key_error(error, cond_itr.second, *report);
+            }
+            }
        }

        t.optional("condition", target.condition);
@@ -527,6 +729,8 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
                        property_list += list_val.as_string();
                    }
                    target.properties[condition][k] = property_list;
+                } else if (v.is_integer()) {
+                    target.properties[condition][k] = std::to_string(v.as_integer());
                } else if (v.is_boolean()) {
                    target.properties[condition][k] = v.as_boolean() ? "ON" : "OFF";
                } else {
@@ -564,13 +768,13 @@ Project::Project(const Project *parent, const std::string &path, bool build) {

            for (const auto &type_name : targetTypeNames) {
                if (name == type_name) {
-                    throw std::runtime_error(format_key_error("Reserved template name '" + name + "'", name, itr.second));
+                    throw_key_error("Reserved template name '" + name + "'", name, itr.second);
                }
            }

            for (const auto &tmplate : templates) {
                if (name == tmplate.outline.name) {
-                    throw std::runtime_error(format_key_error("Template '" + name + "' already defined", name, itr.second));
+                    throw_key_error("Template '" + name + "' already defined", name, itr.second);
                }
            }

@@ -579,6 +783,7 @@ Project::Project(const Project *parent, const std::string &path, bool build) {

            t.optional("add-function", tmplate.add_function);
            t.optional("pass-sources-to-add-function", tmplate.pass_sources_to_add_function);
+            t.optional("pass-sources", tmplate.pass_sources_to_add_function);

            templates.push_back(tmplate);
        }
@@ -645,15 +850,52 @@ Project::Project(const Project *parent, const std::string &path, bool build) {
                    package.features.emplace_back(feature);
                }
            } else {
-                throw std::runtime_error("Invalid vcpkg package '" + package_str + "'");
+                throw_key_error("Invalid package name '" + package_str + "'", "packages", p);
            }
            vcpkg.packages.emplace_back(std::move(package));
        }
+
+        v.optional("overlay-ports", vcpkg.overlay_ports);
    }

    checker.check(conditions, true);
 }

+const Project *Project::root() const {
+    auto root = this;
+    while (root->parent != nullptr)
+        root = root->parent;
+    return root;
+}
+
+bool Project::cmake_minimum_version(int major, int minor) const {
+    // NOTE: this code is like pulling teeth, sorry
+    auto root_version = root()->cmake_version;
+    auto range_index = root_version.find("...");
+    if (range_index != std::string::npos) {
+        root_version.resize(range_index);
+    }
+
+    auto period_index = root_version.find('.');
+    auto root_major = atoi(root_version.substr(0, period_index).c_str());
+    int root_minor = 0;
+    if (period_index != std::string::npos) {
+        auto end_index = root_version.find('.', period_index + 1);
+        root_minor = atoi(root_version.substr(period_index + 1, end_index).c_str());
+    }
+
+    return std::tie(root_major, root_minor) >= std::tie(major, minor);
+}
+
+bool Project::is_condition_name(const std::string &name) {
+    for (auto ch : name) {
+        if (!std::isalnum(ch) && ch != '-' && ch != '_') {
+            return false;
+        }
+    }
+    return true;
+}
+
 bool is_root_path(const std::string &path) {
    const auto toml_path = fs::path(path) / "cmake.toml";
    if (!fs::exists(toml_path)) {
@@ -88,3 +88,37 @@ add_test(
 		build
 )

+if(MSVC) # msvc
+	add_test(
+		NAME
+			msvc-runtime
+		WORKING_DIRECTORY
+			"${CMAKE_CURRENT_LIST_DIR}/msvc-runtime"
+		COMMAND
+			"$<TARGET_FILE:cmkr>"
+			build
+	)
+
+endif()
+add_test(
+	NAME
+		compile-options
+	WORKING_DIRECTORY
+		"${CMAKE_CURRENT_LIST_DIR}/compile-options"
+	COMMAND
+		"$<TARGET_FILE:cmkr>"
+		build
+)
+
+if(WIN32) # windows
+	add_test(
+		NAME
+			relative-paths
+		WORKING_DIRECTORY
+			"${CMAKE_CURRENT_LIST_DIR}/relative-paths"
+		COMMAND
+			"$<TARGET_FILE:cmkr>"
+			build
+	)
+
+endif()
@@ -8,4 +8,4 @@ description = "Minimal example"
 type = "executable"
 sources = ["src/basic.cpp"]

-# Declares an executable target called `basic` with `src/basic.cpp` as a source file. Equivalent to CMake's [add_executable](https://cmake.org/cmake/help/latest/command/add_executable.html)`(basic src/basic.cpp)`.
+# Declares an executable target called `basic` with `src/basic.cpp` as a source file. Equivalent to CMake's [add_executable](https://cmake.org/cmake/help/latest/command/add_executable.html)`(basic src/basic.cpp)`.
@@ -45,3 +45,23 @@ name = "templates"
 working-directory = "templates"
 command = "$<TARGET_FILE:cmkr>"
 arguments = ["build"]
+
+[[test]]
+condition = "msvc"
+name = "msvc-runtime"
+working-directory = "msvc-runtime"
+command = "$<TARGET_FILE:cmkr>"
+arguments = ["build"]
+
+[[test]]
+name = "compile-options"
+working-directory = "compile-options"
+command = "$<TARGET_FILE:cmkr>"
+arguments = ["build"]
+
+[[test]]
+condition = "windows"
+name = "relative-paths"
+working-directory = "relative-paths"
+command = "$<TARGET_FILE:cmkr>"
+arguments = ["build"]
@@ -0,0 +1,15 @@
+# Example project that sets compiler/linker flags for various platforms.
+
+[project]
+name = "compile-options"
+description = "Compiler flags"
+
+[target.hello]
+type = "executable"
+sources = ["src/main.cpp"]
+msvc.compile-options = ["/W2"]
+gcc.compile-options = ["-Wall"]
+clang.compile-options = ["-Wall"]
+
+# The `hello` target uses [conditions](/cmake-toml#conditions) to set different compiler flags depending on the platform. See the [targets](/cmake-toml/#targets) documentation for other things you can set.
+# _Note_: In general you only want to specify flags _required_ to compile your code without errors.
@@ -0,0 +1,5 @@
+#include <cstdio>
+
+int main() {
+    puts("Hello from cmkr!");
+}
@@ -1,23 +1,28 @@
-[project]
-name = "conditions"
-cmake-after = "set(CUSTOM ON)"
-
-[conditions]
-custom = "CUSTOM"
-
-[target.example]
-type = "executable"
-sources = ["src/main.cpp"]
-windows.sources = ["src/windows_specific.cpp"]
-cmake-after = "message(STATUS cmake-after)"
-windows.cmake-after = "message(STATUS win32-after)"
-macos.cmake-after = "message(STATUS macos-after)"
-linux.cmake-after = "message(STATUS linux-after)"
-unix.cmake-after = "message(STATUS unix-after)"
-custom.cmake-after = "message(STATUS custom-after)"
-
-[target.example.properties]
-AUTOMOC = false
-custom.OUTPUT_NAME = "example2"
-custom.AUTORCC = true
-AUTOGEN = "ON"
+[project]
+name = "conditions"
+cmake-after = "set(CUSTOM ON)"
+
+[options]
+CONDITIONS_BUILD_TESTS = "root"
+
+[conditions]
+custom = "CUSTOM"
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+windows.sources = ["src/windows_specific.cpp"]
+cmake-after = "message(STATUS cmake-after)"
+windows.cmake-after = "message(STATUS win32-after)"
+macos.cmake-after = "message(STATUS macos-after)"
+linux.cmake-after = "message(STATUS linux-after)"
+unix.cmake-after = "message(STATUS unix-after)"
+custom.cmake-after = "message(STATUS custom-after)"
+build-tests.cmake-after = "message(STATUS build-tests)"
+"CONDITIONS_BUILD_TESTS AND $<linux>".cmake-after = "message(STATUS linux-tests)"
+
+[target.example.properties]
+AUTOMOC = false
+custom.OUTPUT_NAME = "example2"
+custom.AUTORCC = true
+AUTOGEN = "ON"
@@ -1 +1,2 @@
-int main() { }
+int main() {
+}
@@ -1,3 +1,4 @@
-#include <Windows.h>
-
-void foo() { }
+#include <Windows.h>
+
+void foo() {
+}
@@ -1,12 +1,12 @@
-# Require a C++11 compiler for the target `example`.
-
-[project]
-name = "cxx-standard"
-description = "Changing C++ standard"
-
-[target.example]
-type = "executable"
-sources = ["src/main.cpp"]
-compile-features = ["cxx_std_11"]
-
-# This is equivalent to CMake's [target_compile_features](https://cmake.org/cmake/help/latest/command/target_compile_features.html)`(example PRIVATE cxx_std_11)`. For more information on available C/C++ standards and features see [cmake-compile-features(7)](https://cmake.org/cmake/help/latest/manual/cmake-compile-features.7.html).
+# Require a C++11 compiler for the target `example`.
+
+[project]
+name = "cxx-standard"
+description = "Changing C++ standard"
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+compile-features = ["cxx_std_11"]
+
+# This is equivalent to CMake's [target_compile_features](https://cmake.org/cmake/help/latest/command/target_compile_features.html)`(example PRIVATE cxx_std_11)`. For more information on available C/C++ standards and features see [cmake-compile-features(7)](https://cmake.org/cmake/help/latest/manual/cmake-compile-features.7.html).
@@ -1,8 +1,7 @@
-#include <cstdio>
-#include <tuple>
-
-int main()
-{
-    auto tpl = std::make_tuple(1, 2);
-    printf("Hello from C++11 %d\n", std::get<0>(tpl));
-}
+#include <cstdio>
+#include <tuple>
+
+int main() {
+    auto tpl = std::make_tuple(1, 2);
+    printf("Hello from C++11 %d\n", std::get<0>(tpl));
+}
@@ -12,4 +12,4 @@ type = "executable"
 sources = ["src/main.cpp"]
 link-libraries = ["fmt::fmt"]

-# This is equivalent to calling CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html).
+# This is equivalent to calling CMake's [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html).
@@ -1,6 +1,5 @@
 #include <fmt/core.h>

-int main()
-{
+int main() {
    fmt::print("Hello, world!\n");
-}
+}
@@ -1,18 +1,18 @@
-[project]
-name = "globbing"
-description = "Globbing sources"
-
-# Recursively glob in the mylib/ folder
-[target.mylib]
-type = "static"
-alias = "mylib::mylib"
-sources = ["mylib/**.hpp", "mylib/**.cpp"]
-include-directories = ["mylib/include"]
-
-# Single-folder glob in example/src/
-[target.example]
-type = "executable"
-sources = ["example/src/*.cpp"]
-link-libraries = ["mylib::mylib"]
-
-# As you can see in the example above you can use `**.ext` to glob recursively and `*.ext` to glob non-recursively. This **does not** generate `file(GLOB ...)` commands, but instead globs when cmkr is run. Files are sorted to give deterministic results regardless of the platform used.
+[project]
+name = "globbing"
+description = "Globbing sources"
+
+# Recursively glob in the mylib/ folder
+[target.mylib]
+type = "static"
+alias = "mylib::mylib"
+sources = ["mylib/**.hpp", "mylib/**.cpp"]
+include-directories = ["mylib/include"]
+
+# Single-folder glob in example/src/
+[target.example]
+type = "executable"
+sources = ["example/src/*.cpp"]
+link-libraries = ["mylib::mylib"]
+
+# As you can see in the example above you can use `**.ext` to glob recursively and `*.ext` to glob non-recursively. This **does not** generate `file(GLOB ...)` commands, but instead globs when cmkr is run. Files are sorted to give deterministic results regardless of the platform used.
@@ -1,7 +1,7 @@
-#include <iostream>
-#include <mylib/mylib.hpp>
-
-int main() {
-    std::cout << mylib::message() << std::endl;
-    return 0;
-}
+#include <iostream>
+#include <mylib/mylib.hpp>
+
+int main() {
+    std::cout << mylib::message() << std::endl;
+    return 0;
+}
@@ -1,8 +1,7 @@
-#pragma once
-
-#include <string>
-
-namespace mylib
-{
-std::string message();
-}
+#pragma once
+
+#include <string>
+
+namespace mylib {
+std::string message();
+} // namespace mylib
@@ -1,6 +1,5 @@
-#include <mylib/mylib.hpp>
-
-std::string mylib::message()
-{
-    return "cmkr is awesome!";
-}
+#include <mylib/mylib.hpp>
+
+std::string mylib::message() {
+    return "cmkr is awesome!";
+}
@@ -1,13 +1,13 @@
-[project]
-name = "interface"
-description = "Header-only library"
-
-[target.mylib]
-type = "interface"
-include-directories = ["include"]
-compile-features = ["cxx_std_11"]
-
-[target.example]
-type = "executable"
-sources = ["src/main.cpp"]
-link-libraries = ["mylib"]
+[project]
+name = "interface"
+description = "Header-only library"
+
+[target.mylib]
+type = "interface"
+include-directories = ["include"]
+compile-features = ["cxx_std_11"]
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+link-libraries = ["mylib"]
@@ -1,4 +1,5 @@
-namespace mylib
-{
-static const char* version() { return "v1.0"; }
-} // namespace mylib
+namespace mylib {
+static const char *version() {
+    return "v1.0";
+}
+} // namespace mylib
@@ -1,8 +1,7 @@
-#include <cstdio>
-
-#include "mylib/mylib.hpp"
-
-int main()
-{
-    printf("mylib version: %s\n", mylib::version())
-}
+#include <cstdio>
+
+#include "mylib/mylib.hpp"
+
+int main() {
+    printf("mylib version: %s\n", mylib::version());
+}
@@ -0,0 +1,15 @@
+[project]
+name = "msvc-runtime"
+description = "Static MSVC runtime"
+msvc-runtime = "static"
+
+# This target will compile with a static runtime
+[target.static-runtime]
+type = "executable"
+sources = ["src/main.cpp"]
+
+# This target overrides the [project].msvc-runtime
+[target.dynamic-runtime]
+type = "executable"
+sources = ["src/main.cpp"]
+msvc-runtime = "dynamic"
@@ -0,0 +1,5 @@
+#include <cstdio>
+
+int main() {
+    puts("Hello from cmkr(msvc-static)!");
+}
@@ -0,0 +1,11 @@
+[project]
+name = "relative-paths"
+
+[target.test-library]
+type = "static"
+sources = ["src/library-code.cpp"]
+
+[target.example]
+type = "executable"
+sources = ["src/main.cpp"]
+windows.link-libraries = ["libs/test-library-x64-Release.lib"]
@@ -0,0 +1,6 @@
+// Created by Anthony Printup on 9/18/2023.
+#include <cstdio>
+
+extern "C" void library_function() {
+    std::puts("Hello from library_function!");
+}
@@ -0,0 +1,12 @@
+// Created by Anthony Printup on 9/18/2023.
+#include <cstdio>
+
+#ifdef WIN32
+extern "C" void library_function();
+#endif
+int main() {
+    puts("Hello from cmkr(relative-paths)!");
+#ifdef WIN32
+    library_function();
+#endif
+}
@@ -22,4 +22,4 @@ compile-definitions = ["APP_A"]
 type = "app"
 compile-definitions = ["APP_B"]

-# **Note**: In most cases you probably want to use an [interface](/examples/interface) target instead.
+# **Note**: In most cases you probably want to use an [interface](/examples/interface) target instead.
@@ -7,7 +7,7 @@ description = "Dependencies from vcpkg"
 # See https://github.com/microsoft/vcpkg/releases for vcpkg versions
 # See https://vcpkg.io/en/packages.html for available packages
 [vcpkg]
-version = "2021.05.12"
+version = "2024.03.25"
 packages = ["fmt"]

 [find-package]
@@ -19,4 +19,4 @@ sources = ["src/main.cpp"]
 link-libraries = ["fmt::fmt"]

 # The bootstrapping of vcpkg is fully automated and no user interaction is necessary. You can disable vcpkg by setting `CMKR_DISABLE_VCPKG=ON`.
-# To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
+# To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
@@ -1,6 +1,5 @@
 #include <fmt/core.h>

-int main()
-{
+int main() {
    fmt::print("Hello, world!\n");
-}
+}
@@ -0,0 +1,3 @@
+# Disable clang-format in this folder
+DisableFormat: true
+SortIncludes: Never
@@ -16,7 +16,3 @@ target_include_directories(toml11 INTERFACE toml11-3.6.0)
 # https://github.com/mpark/variant (BSL-1.0)
 add_library(mpark_variant INTERFACE)
 target_include_directories(mpark_variant INTERFACE variant-1.4.0/include)
-
-# https://github.com/nlohmann/json (MIT)
-add_library(nlohmann_json INTERFACE)
-target_include_directories(nlohmann_json INTERFACE nlohmann-3.9.1/include)
@@ -1,21 +0,0 @@
-MIT License 
-
-Copyright (c) 2013-2021 Niels Lohmann
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
Author	SHA1	Message	Date
Duncan Ogilvie	13a7a8788a	Bump to 0.2.36	2024-11-26 13:36:24 +01:00
Duncan Ogilvie	45ca74099c	Merge pull request #156 from build-cpp/vcpkg-overlay-ports Add [vcpkg].overlay-ports feature	2024-11-26 13:35:32 +01:00
Duncan Ogilvie	ae3d73896e	Add [vcpkg].overlay-ports feature	2024-11-26 12:33:29 +01:00
Duncan Ogilvie	57042565d1	Merge pull request #154 from build-cpp/configure-depends Use CMAKE_CONFIGURE_DEPENDS when supported	2024-11-03 11:44:02 +01:00
deep	d02ee3ed24	Added check to make sure hash is valid hex (#153 )	2024-11-03 10:49:33 +01:00
Duncan Ogilvie	4a15d2ba55	Use CMAKE_CONFIGURE_DEPENDS when supported	2024-11-03 10:33:32 +01:00
Duncan Ogilvie	87c0295f93	Fix CI	2024-10-14 13:02:20 +02:00
Duncan Ogilvie	a608e6b778	Bump to 0.2.35	2024-10-13 16:16:36 +02:00
Duncan Ogilvie	523f5f4a8a	Merge pull request #150 from build-cpp/msvc-runtime-root Only emit `MSVC_RUNTIME_LIBRARY` in the root project	2024-09-06 14:39:47 +02:00
Duncan Ogilvie	510cf71af5	Only emit MSVC_RUNTIME_LIBRARY in the root project	2024-09-06 14:33:04 +02:00
Duncan Ogilvie	87d90138b4	Merge pull request #149 from build-cpp/relative-libs Improve relative path functionality for link-libraries	2024-09-06 14:25:33 +02:00
Duncan Ogilvie	50615e0c27	Bump clang-format-lint-action https://github.com/DoozyX/clang-format-lint-action/issues/73	2024-09-06 14:22:12 +02:00
Duncan Ogilvie	42ed3048b3	Improve relative path functionality for link-libraries	2024-09-06 13:50:43 +02:00
Duncan Ogilvie	b0a1d79a42	Bump to 0.2.34	2024-08-05 15:28:58 +02:00
Duncan Ogilvie	5882bc082d	Support integer properties Closes #148	2024-08-05 15:28:38 +02:00
Duncan Ogilvie	a90b3c6095	Add RC as a default language	2024-08-05 15:28:16 +02:00
Duncan Ogilvie	0a887c08f8	Bump to 0.2.33	2024-07-06 14:50:39 +02:00
Duncan Ogilvie	9f2cfe4083	Merge pull request #146 from build-cpp/improved-conditions Improve error-prone condition handling	2024-07-06 14:49:32 +02:00
Duncan Ogilvie	15ad1dc6a7	Support nested condition syntax for named conditions	2024-07-06 14:43:32 +02:00
Duncan Ogilvie	dabffeaed9	Add back the option name as a named condition	2024-07-06 14:43:32 +02:00
Duncan Ogilvie	59fe5c38b8	Consider PROJECT_OPTION to be a valid condition	2024-07-06 14:43:32 +02:00
Duncan Ogilvie	dcdc7ac410	Add a few more default named conditions	2024-07-06 14:43:32 +02:00
Duncan Ogilvie	88377a8bfb	Bump to 0.2.32	2024-07-06 14:03:55 +02:00
Duncan Ogilvie	3a9685be82	Merge pull request #145 from build-cpp/system-bug Fix uninitialized 'system' field for fetch-content	2024-07-06 14:03:08 +02:00
Duncan Ogilvie	5576789c18	Fix uninitialized 'system' field for fetch-content	2024-07-06 14:02:33 +02:00
Duncan Ogilvie	a362978f99	Bump to 0.2.31	2024-06-21 00:33:33 +02:00
Duncan Ogilvie	a2f33297e4	Merge pull request #144 from build-cpp/msvc-runtime-subproject Do not set CMAKE_MSVC_RUNTIME_LIBRARY if it's already set	2024-06-21 00:32:50 +02:00
Duncan Ogilvie	674c976647	Do not set CMAKE_MSVC_RUNTIME_LIBRARY if it's already set	2024-06-21 00:32:30 +02:00
Duncan Ogilvie	714a666e88	Merge pull request #143 from build-cpp/project-improvements Project improvements	2024-06-01 01:25:26 +02:00
Duncan Ogilvie	d613e433d5	Skip linting on pull requests for the same repository	2024-06-01 00:55:31 +02:00
Duncan Ogilvie	7c828d8740	Add custom targets for running cmkr/tests	2024-06-01 00:55:31 +02:00
Duncan Ogilvie	559f750c89	Fix undefined behavior with std::tolower/toupper	2024-06-01 00:55:29 +02:00
Duncan Ogilvie	4b6b72874e	Remove nlohmann_json	2024-05-31 22:45:27 +02:00
Duncan Ogilvie	6bffa7cc71	Bump to 0.2.30	2024-05-31 22:36:39 +02:00
Duncan Ogilvie	f415b432ed	Also run linting on pull requests	2024-05-31 22:34:27 +02:00
Duncan Ogilvie	6c46664336	Merge pull request #142 from anthonyprintup/globbing-extension-fix Fixed globbing when multiple extensions are present in the file name	2024-05-31 22:31:18 +02:00
Duncan Ogilvie	f32aac63aa	Review improvements	2024-05-31 22:24:01 +02:00
Anthony Printup	33d4cc4156	Fixed globbing when multiple extensions are present in the file name	2024-05-30 00:36:14 +02:00
Duncan Ogilvie	9288c8a87d	Bump to 0.2.29	2024-04-15 03:08:33 +02:00
Duncan Ogilvie	e36eee4420	Merge pull request #140 from build-cpp/improved-conditions Allow arbitrary CMake expressions as conditions	2024-04-15 03:08:02 +02:00
Duncan Ogilvie	53820c9f65	Support $<condition> in unnamed conditions	2024-04-15 03:01:51 +02:00
Duncan Ogilvie	ff7e4b8f23	Allow arbitrary CMake expressions as conditions	2024-04-15 02:12:02 +02:00
Duncan Ogilvie	1072cb44e2	Bump to 0.2.28	2024-04-14 00:08:11 +02:00
Duncan Ogilvie	926fc15fa2	Merge pull request #139 from build-cpp/vcpkg-bump Bump to the latest vcpkg	2024-04-14 00:06:00 +02:00
Duncan Ogilvie	e2c929adb0	Fix out-of-the-box vcpkg experience on macos	2024-04-13 23:57:30 +02:00
Duncan Ogilvie	0dec7ca4d5	Bump to the latest vcpkg	2024-04-13 23:21:25 +02:00
Duncan Ogilvie	45e346b4a3	Bump to 0.2.27	2024-03-28 11:38:01 +01:00
Duncan Ogilvie	7165986190	Merge pull request #138 from build-cpp/find-package-first Generate find-package before fetch-content	2024-03-28 11:37:31 +01:00
Duncan Ogilvie	be0ef6d615	Generate find-package before fetch-content	2024-03-28 11:36:15 +01:00
Duncan Ogilvie	d607b9028c	Bump to 0.2.26	2023-11-09 13:32:05 +01:00
Duncan Ogilvie	099b14552c	Merge pull request #131 from build-cpp/fetch-subdir Add [fetch-content].subdir	2023-11-09 13:31:48 +01:00
Duncan Ogilvie	771c80a41a	Add [fetch-content].subdir Closes #98	2023-11-09 13:28:29 +01:00
Duncan Ogilvie	58c7de1d60	Merge pull request #129 from build-cpp/gitignore-improvement Improve the default .gitignore that's generated	2023-10-18 13:22:44 +02:00
Duncan Ogilvie	a61e4bb999	Merge pull request #128 from build-cpp/language-documentation Document the supported languages	2023-10-18 13:22:32 +02:00
Duncan Ogilvie	47aaeaf8ce	Document the supported languages	2023-10-18 12:27:04 +02:00
Duncan Ogilvie	62609a0088	Improve the default .gitignore that's generated	2023-10-18 12:26:38 +02:00
Duncan Ogilvie	e0d8a085db	Merge pull request #121 from anthonyprintup/relative-paths Added support for relative paths in `link-libraries`	2023-09-22 16:13:03 +02:00
Duncan Ogilvie	56da4144ae	Merge pull request #125 from anthonyprintup/fix-124 fix(generator): Prevent calling `std::string::back` on an empty string	2023-09-22 16:12:20 +02:00
Duncan Ogilvie	9388b3f29d	Merge pull request #123 from anthonyprintup/quotes-fix Prevent wrapping test command arguments in quotes	2023-09-22 16:12:07 +02:00
Anthony Printup	079644cfeb	fix(generator): Prevent calling `std::string::back` on an empty string Fixes #124	2023-09-20 02:34:02 +02:00
Anthony Printup	a7ca9f04c0	fix(relative-paths): Replaced `has_parent_path` with a simpler path check	2023-09-20 00:35:41 +02:00
Anthony Printup	339c2aac94	fix(generator): Prevent command arguments from being quoted when generating tests Fixes #122	2023-09-18 18:36:58 +02:00
Anthony Printup	c573c9a76d	test(relative-paths): Add the test-library file to libs	2023-09-18 17:49:21 +02:00
Anthony Printup	b24a0a2fdc	test(relative-paths): Make `link-libraries` conditional to the Windows platform	2023-09-18 17:49:20 +02:00
Anthony Printup	854e8817c4	test(relative-paths): Remove inlined CMake from cmake.toml	2023-09-18 17:49:11 +02:00
Anthony Printup	1c2947b2fc	fix(relative-paths): Prevent processing paths which may contain CMake macros, added a check to see if the library that's being linked exists on disk	2023-09-18 17:35:46 +02:00
Anthony Printup	19e61aa1aa	test(relative-paths): Attempt to fix the tests workflow	2023-09-18 16:41:37 +02:00
Anthony Printup	bfa1e1fe0d	test(relative-paths): Added the latest `relative-paths` test to the tests workflow	2023-09-18 15:49:17 +02:00
Anthony Printup	56bd78f7ad	feat(project-parser): Added support for relative paths in `link-libraries` Fixes #116	2023-09-18 15:44:44 +02:00
Anthony Printup	4362b3547f	test(relative-paths): Added tests for #116	2023-09-18 15:43:46 +02:00
Duncan Ogilvie	08204d9847	Bump to 0.2.25	2023-09-16 18:51:26 +02:00
Duncan Ogilvie	2202aa8173	Merge pull request #120 from anthonyprintup/new-lines-fix Trim additional newline characters at the end of CMakeLists.txt	2023-09-16 18:49:45 +02:00
Anthony Printup	d3829fb6cd	Trim additional new lines at the end of the generated CMakeLists.txt	2023-09-16 18:49:30 +02:00
Duncan Ogilvie	3fb095210a	Merge pull request #118 from ZehMatt/vcpkg-errors Report better error messages for vcpkg projects and features	2023-08-25 22:21:52 +02:00
ζeh Matt	9f99365a25	Report better error messages for vcpkg projects and features	2023-08-25 15:58:24 +03:00
Duncan Ogilvie	be387141b5	Add a 'Compiler flags' example to the documentation	2023-07-09 19:26:07 +02:00
Duncan Ogilvie	09ded38f70	Merge pull request #115 from build-cpp/clang-cl-condition Add `clang-cl` and `clang-any` conditions	2023-07-09 18:01:06 +02:00
Duncan Ogilvie	ad90b1ad3e	Add 'clang-cl' and 'clang-any' conditions	2023-07-09 16:20:05 +02:00
Duncan Ogilvie	5bfa03d311	Bump to 0.2.24	2023-06-12 19:12:47 +02:00
Duncan Ogilvie	bdd9d393d6	Merge pull request #113 from build-cpp/editorconfig Add `.editorconfig` and linting	2023-06-12 18:28:12 +02:00
Duncan Ogilvie	1deaec2b41	Add .editorconfig and linting Closes #112	2023-06-12 18:26:13 +02:00
Duncan Ogilvie	cfee3bbc14	Merge pull request #111 from anthonyprintup/fetch-content-system Fix #110	2023-06-12 17:48:54 +02:00
Anthony Printup	bcaa60cabe	feat: Added SYSTEM flag support to fetch-content	2023-06-12 15:41:20 +02:00
Duncan Ogilvie	7b1d33395e	Bump to 0.2.23	2023-03-25 11:25:18 +00:00
Duncan Ogilvie	240fafc102	Merge pull request #101 from build-cpp/minor-cleanup Cleanup	2023-03-25 11:24:44 +00:00
Duncan Ogilvie	7a7ddf2699	Speed up the pipeline by using Ninja	2023-03-25 11:19:48 +00:00
Duncan Ogilvie	605a04e72d	Fix formatting of files	2023-03-24 11:07:02 +00:00
Duncan Ogilvie	fd7f078127	Add workflow for checking clang-format	2023-03-24 11:04:58 +00:00
Duncan Ogilvie	ee0e0d71d9	Remove a bunch of dead code	2023-03-24 11:03:45 +00:00
Duncan Ogilvie	9d6897b572	Suppress warnings related to DOWNLOAD_EXTRACT_TIMESTAMP	2023-03-24 11:03:40 +00:00
Duncan Ogilvie	f8c34e5545	Error when [vcpkg] is used from a non-root project	2023-03-24 10:43:17 +00:00
Duncan Ogilvie	e6d783ea20	Fix a few clang-tidy warnings	2023-03-24 10:41:59 +00:00
Duncan Ogilvie	ee7fe38a7b	Merge pull request #100 from build-cpp/include-subdir-bugfix Fix a bug where includes in a subdir would not work	2023-03-24 10:13:30 +00:00
Duncan Ogilvie	66b2aad843	Fix a bug where includes in a subdir would not work	2023-03-24 10:04:32 +00:00
Duncan Ogilvie	d2e376080a	Bump to 0.2.22	2023-03-09 21:36:11 +01:00
Duncan Ogilvie	634908c651	Merge pull request #97 from build-cpp/cmkr-init-regression Fix a regression where cmkr init wouldn't create any source files	2023-03-09 21:35:25 +01:00
Duncan Ogilvie	33911f3f1b	Fix a regression where cmkr init wouldn't create any source files	2023-03-09 21:35:11 +01:00
Duncan Ogilvie	e650073bef	Bump to 0.2.21	2023-03-08 09:48:40 +01:00
Duncan Ogilvie	96e44f7771	Merge pull request #96 from build-cpp/check-sources Improve error messages and check if specified sources exist	2023-03-08 09:47:43 +01:00
Duncan Ogilvie	cb9ad5cdb3	Improve error messages and check if specified sources exist	2023-03-08 09:41:40 +01:00
Duncan Ogilvie	c785b540d3	Document target templates	2023-03-08 09:01:39 +01:00
Duncan Ogilvie	275b73eefa	Remove debug print	2023-03-02 08:43:45 +01:00
Duncan Ogilvie	ea49a3acb7	Bump to 0.2.20	2023-02-28 21:31:18 +01:00
Duncan Ogilvie	257e14c869	Merge pull request #93 from build-cpp/gitattributes Automatically generate .gitattributes and .gitignore with cmkr init	2023-02-28 21:30:34 +01:00
Duncan Ogilvie	7508816fe7	Merge pull request #94 from build-cpp/user-experience Add a special "root" value for `[options]`	2023-02-28 21:27:11 +01:00
Duncan Ogilvie	45678bc5bc	Automatically generate .gitattributes and .gitignore with cmkr init	2023-02-28 21:26:07 +01:00
Duncan Ogilvie	b869e5646f	Add a special "root" value for [options]	2023-02-28 19:34:31 +01:00
Duncan Ogilvie	a499df84b1	Bump to 0.2.19	2023-02-28 17:11:55 +01:00
Duncan Ogilvie	49440f99e0	Merge pull request #92 from build-cpp/improved-options Improve and document the `[options]` feature	2023-02-20 02:13:50 +01:00
Duncan Ogilvie	0c19c3da0c	Improve the code related to [options]	2023-02-20 02:09:36 +01:00
Duncan Ogilvie	233cadadd0	Merge pull request #90 from mike1k/sanity Error on unknown language & unacceptable source file.	2023-02-20 01:31:47 +01:00
Duncan Ogilvie	58a5a935e5	Add a bunch of missing languages and extensions and refactor	2023-02-20 01:18:48 +01:00
Duncan Ogilvie	e69427bf94	Merge pull request #91 from build-cpp/clang-condition Fix the `clang` condition and CI improvements	2023-02-19 22:30:15 +01:00
Duncan Ogilvie	bc6359805d	Change the `clang` condition to not detect clang-cl References: - https://github.com/cursey/safetyhook/issues/18 - https://discourse.cmake.org/t/clang-on-windows-detected-with-msvc-interface/3470	2023-02-19 22:23:34 +01:00
Duncan Ogilvie	8dcc11e349	Add helper function Project::cmake_minimum_version for version-dependent features	2023-02-19 22:19:12 +01:00
Duncan Ogilvie	51dc49e6f1	Improve CI performance for non-tagged builds	2023-02-19 20:06:58 +01:00
mike	7d27c28b59	Fixed failing tests due to implicit project languages (internal list empty)	2023-02-09 10:53:48 -06:00
Duncan Ogilvie	ae6bea3b58	Improve reference documentation	2023-01-28 11:57:22 +01:00
Duncan Ogilvie	5a0eda7abc	Automatically generate release notes	2023-01-15 13:34:36 +01:00
Duncan Ogilvie	f17923c18b	Bump to 0.2.18	2023-01-14 21:28:17 +01:00
Duncan Ogilvie	ad17890e23	Merge pull request #85 from build-cpp/settings-rename Rename `[settings]` to `[variables]`	2023-01-14 21:14:12 +01:00
Duncan Ogilvie	c0b98b3ef4	Add documentation for the [variables] section	2023-01-14 18:12:57 +01:00
Duncan Ogilvie	2c6fc569af	Preserve backwards compatibility	2023-01-14 16:17:06 +01:00
Duncan Ogilvie	12ee23a44c	Improve error messages	2023-01-14 15:52:19 +01:00
Duncan Ogilvie	82342a6b6f	Rename [settings] to [variables]	2023-01-14 15:51:57 +01:00
Duncan Ogilvie	1d95fab0ce	Switch to giscus for documentation comments	2023-01-02 14:56:38 +01:00
Duncan Ogilvie	44a77329bf	Merge pull request #83 from build-cpp/document-basics Document basics	2023-01-02 12:43:24 +01:00
Duncan Ogilvie	e68c5fccdc	Add utteranc.es comments	2023-01-02 12:43:20 +01:00
Duncan Ogilvie	e2722d2c09	Initial draft of new documentation	2023-01-02 12:02:24 +01:00
Duncan Ogilvie	2627864383	Merge pull request #78 from build-cpp/fix-tests Successfully fail when running cmkr subcommands	2022-11-29 10:11:45 +01:00
Duncan Ogilvie	05e21f734a	Fix the tests	2022-11-29 10:06:34 +01:00
Duncan Ogilvie	1fd18503cd	Successfully fail when running cmkr subcommands	2022-11-24 00:32:31 +01:00
Duncan Ogilvie	8b19441d34	Bump to 0.2.17	2022-11-24 00:31:42 +01:00
Duncan Ogilvie	2437eb90fe	Minor improvements - Drastically improve quality of generated CMake - Fix a regression with recursive globbing in the root - Automatically include CSharpUtilities when using CSharp	2022-11-24 00:23:30 +01:00
Duncan Ogilvie	6e4006ec07	Fix typo in the docs	2022-10-25 00:59:58 +02:00
Duncan Ogilvie	697b638723	Fix warning on macos	2022-10-11 14:19:29 +02:00
Duncan Ogilvie	109c4bc99f	Bump to 0.2.16	2022-10-08 10:48:16 +02:00
Duncan Ogilvie	cad85f0bb1	Merge pull request #70 from build-cpp/fix-msvc-runtime Actually generate the set(CMAKE_MSVC_RUNTIME_LIBRARY)	2022-10-08 10:47:56 +02:00
Duncan Ogilvie	53c88ceafa	Actually generate the set(CMAKE_MSVC_RUNTIME_LIBRARY) Closes #69 (nice)	2022-10-08 10:37:27 +02:00
Duncan Ogilvie	d2aa15b1c7	Bump to 0.2.15	2022-10-07 22:21:07 +02:00
Duncan Ogilvie	e6ded077cf	Merge pull request #65 from gmh5225/feature-msvc-static [feature] msvc-static	2022-10-07 22:20:36 +02:00
Duncan Ogilvie	3615ccab94	Document msvc-runtime feature	2022-10-07 22:15:32 +02:00
Duncan Ogilvie	73622aa5ba	Remove the add_test hook to generate tests the same on all platforms	2022-10-07 22:09:54 +02:00
Duncan Ogilvie	69d844a152	Refactor msvc-static to msvc-runtime	2022-10-07 17:46:36 +02:00
gmh5225	af9a117f50	Fix merge	2022-10-07 06:50:26 +08:00
gmh5225	5fe8220728	Merge branch 'feature-msvc-static' of https://github.com/gmh5225/cmkr into feature-msvc-static	2022-10-07 06:41:43 +08:00
gmh5225	28f541cd3c	[feature] add CMP0091	2022-10-07 06:41:11 +08:00
gmh5225	2f3fd7b95e	Merge branch 'main' into feature-msvc-static	2022-10-07 05:35:11 +08:00
Duncan Ogilvie	07d99c582d	Merge pull request #68 from build-cpp/headers-crash Fix the way target.headers is merged into target.sources	2022-10-06 18:30:13 +02:00
Duncan Ogilvie	5af2385cc3	Fix the way target.headers is merged into target.sources - It would crash if you did not specify target.sources - Headers with condition would be merged incorrectly	2022-10-06 18:22:51 +02:00
gmh5225	981c48dbc5	[feature] msvc-static	2022-10-02 10:43:32 +08:00
Duncan Ogilvie	153bdbe591	Bump to 0.2.14	2022-07-19 14:17:47 +02:00
Duncan Ogilvie	97f1c5c1cc	Fix a bug when there are regex characters in the path Closes #61	2022-07-19 14:05:47 +02:00
Duncan Ogilvie	5b6d9c3826	Replace illegal characters in the project name with _ when doing cmkr init	2022-07-19 13:42:56 +02:00
Duncan Ogilvie	a90988b81a	Update the formatting to now allow functions on a single line This makes it less annoying when the IDE is auto-formatting while you type	2022-07-19 13:41:43 +02:00
Duncan Ogilvie	3a1298f4e8	Merge pull request #60 from pmeerw/fix-warning error: fix warning, signedness of comparison	2022-06-28 19:47:39 +02:00
Peter Meerwald-Stadler	534f955827	error: fix warning, signedness of comparison cmkr/src/error.cpp:23:24: warning: comparison of integer expressions of different signedness: ‘int’ and ‘long unsigned int’ [-Wsign-compare] 23 \| assert(i >= 0 && i < (sizeof(err_string) / sizeof(*(err_string))));	2022-06-28 18:21:15 +02:00