Bump to 0.2.29

Allow arbitrary CMake expressions as conditions

.clang-format

@@ -19,7 +19,7 @@ AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
-BraceWrapping:   
+BraceWrapping:
   AfterClass:      false
   AfterControlStatement: false
   AfterEnum:       false

.editorconfig

@@ -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

.github/workflows/build.yml

@@ -1,16 +1,16 @@
-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-2022, macos-11, ubuntu-20.04]
+        os: [windows-2022, macos-latest, ubuntu-20.04]
     env:
       BUILD_TYPE: 'Release'
       CMAKE_GENERATOR: 'Ninja'

.github/workflows/lint.yml

@@ -3,7 +3,7 @@ name: lint
 on: [push]
 
 jobs:
-  lint:
+  clang-format:
     runs-on: ubuntu-latest
 
     steps:
@@ -24,4 +24,14 @@ jobs:
         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
+          exit 1
+
+  editorconfig:
+    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

CMakeLists.txt

@@ -22,7 +22,7 @@ project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.2.23
+		0.2.29
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )

cmake.toml

@@ -4,7 +4,7 @@ cmkr-include = false
 
 [project]
 name = "cmkr"
-version = "0.2.23"
+version = "0.2.29"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
 include-after = [

cmake/bump_version.cmake

@@ -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}")

cmake/cmkr.cmake

@@ -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.23" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+set(CMKR_TAG "v0.2.29" 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

cmake/generate_documentation.cmake

@@ -15,7 +15,7 @@ function(generate_documentation)
                 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()

cmake/resource.hpp.in

@@ -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";
+
+}
 }

docs/CNAME

@@ -1 +1 @@
-cmkr.build
+cmkr.build

docs/cmake-toml.md

@@ -39,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 EQUAL 8"
-arch32 = "CMAKE_SIZEOF_VOID_P EQUAL 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:
 
@@ -57,9 +85,11 @@ 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):
@@ -72,8 +102,10 @@ 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\" 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$\")"
 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"
@@ -103,7 +135,7 @@ 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).
+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]`).
 
@@ -121,8 +153,8 @@ Variables emit a [`set`](https://cmake.org/cmake/help/latest/command/set.html) a
 
 ```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"]
 ```
 
@@ -151,6 +183,8 @@ condition = "mycondition"
 git = "https://github.com/myuser/gitcontent"
 tag = "v0.1"
 shallow = false
+system = false
+subdir = ""
 
 [fetch-content.svncontent]
 condition = "mycondition"
@@ -166,6 +200,8 @@ 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

docs/examples/compile-options.md

@@ -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>

docs/examples/vcpkg.md

@@ -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 = "2022.11.14"
+version = "2024.03.25"
 packages = ["fmt"]
 
 [find-package]

docs/getting-started.html

@@ -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>

include/fs.hpp

@@ -10,4 +10,4 @@ namespace fs = std::filesystem;
 #ifndef GHC_USE_STD_FS
 #include <ghc/filesystem.hpp>
 namespace fs = ghc::filesystem;
-#endif
+#endif

include/project_parser.hpp

@@ -155,6 +155,8 @@ struct Content {
     Condition<std::string> cmake_after;
     ConditionVector include_before;
     ConditionVector include_after;
+    bool system;
+    std::string subdir;
 };
 
 enum MsvcRuntimeType {
@@ -206,9 +208,10 @@ struct Project {
     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

src/cmake_generator.cpp

@@ -215,7 +215,7 @@ void generate_project(const std::string &type) {
     generate_gitfile(".gitattributes", {"/**/CMakeLists.txt linguist-generated", "/**/cmkr.cmake linguist-vendored"});
 
     // Generate .gitignore with reasonable defaults for CMake
-    generate_gitfile(".gitignore", {"build*/", "cmake-build*/", ".idea/", ".vscode/"});
+    generate_gitfile(".gitignore", {"build*/", "cmake-build*/", "CMakerLists.txt", "CMakeLists.txt.user"});
 
     tsl::ordered_map<std::string, std::string> variables = {
         {"@name", name},
@@ -493,7 +493,7 @@ struct Generator {
                 throw std::runtime_error("Detected additional \" at the end of cmake block");
             }
             auto cmake_lf = tolf(cmake);
-            while (cmake_lf.back() == '\n')
+            while (!cmake_lf.empty() && cmake_lf.back() == '\n')
                 cmake_lf.pop_back();
             bool did_indent = false;
             for (char ch : cmake_lf) {
@@ -514,15 +514,13 @@ struct Generator {
         if (!value.empty()) {
             for (const auto &itr : value) {
                 const auto &condition = itr.first;
-                if (!condition.empty()) {
-                    cmd("if", condition)(RawArg(project.conditions.at(condition)));
-                }
+                auto endif = if_condition(condition);
 
                 if (!itr.second.empty()) {
                     fn(condition, itr.second);
                 }
 
-                if (!condition.empty()) {
+                if (endif) {
                     cmd("endif")().endl();
                 } else if (!itr.second.empty()) {
                     endl();
@@ -538,6 +536,68 @@ struct Generator {
     void conditional_cmake(const parser::Condition<std::string> &cmake) {
         handle_condition(cmake, [this](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
     }
+
+    bool if_condition(const std::string &condition) {
+        if (condition.empty()) {
+            return false;
+        }
+        auto found = project.conditions.find(condition);
+        if (found == project.conditions.end()) {
+            if (cmkr::parser::Project::is_condition_name(condition)) {
+                // NOTE: this should have been caught by the parser already
+                throw std::runtime_error("Condition '" + condition + "' is not defined");
+            }
+            cmd("if", "NOTE: unnamed condition")(RawArg(cmake_condition(condition)));
+        } else {
+            cmd("if", condition)(RawArg(found->second));
+        }
+        return true;
+    }
+
+  private:
+    std::string cmake_condition(const std::string &condition) {
+        // HACK: this replaces '$<name>' with the value of the 'name' condition. We can safely
+        // reuse the generator expression syntax, because it is not valid in CMake conditions.
+        // TODO: properly handle quoted arguments (using a simple state machine):
+        // https://cmake.org/cmake/help/latest/manual/cmake-language.7.html#quoted-argument
+        std::string result = "";
+        bool in_replacement = false;
+        std::string temp;
+        for (size_t i = 0; i < condition.length(); i++) {
+            if (in_replacement) {
+                if (condition[i] == '>') {
+                    in_replacement = false;
+                    if (temp.empty()) {
+                        throw std::runtime_error("Empty replacement in condition '" + condition + "'");
+                    }
+                    auto found = project.conditions.find(temp);
+                    if (found == project.conditions.end()) {
+                        throw std::runtime_error("Unknown condition '" + temp + "' in replacement");
+                    }
+                    auto has_space = found->second.find(' ') != std::string::npos;
+                    if (has_space) {
+                        result += '(';
+                    }
+                    result += found->second;
+                    if (has_space) {
+                        result += ')';
+                    }
+                    temp.clear();
+                } else {
+                    temp += condition[i];
+                }
+            } else if (condition[i] == '$' && i + 1 < condition.length() && condition[i + 1] == '<') {
+                i++;
+                in_replacement = true;
+            } else {
+                result += condition[i];
+            }
+        }
+        if (!temp.empty()) {
+            throw std::runtime_error("Unterminated replacement in condition '" + condition + "'");
+        }
+        return result;
+    }
 };
 
 struct ConditionScope {
@@ -545,10 +605,7 @@ struct ConditionScope {
     bool endif = false;
 
     ConditionScope(Generator &gen, const std::string &condition) : gen(gen) {
-        if (!condition.empty()) {
-            gen.cmd("if", condition)(RawArg(gen.project.conditions.at(condition)));
-            endif = true;
-        }
+        endif = gen.if_condition(condition);
     }
 
     ConditionScope(const ConditionScope &) = delete;
@@ -562,28 +619,26 @@ struct ConditionScope {
 };
 
 static bool vcpkg_valid_identifier(const std::string &name) {
-    // prn|aux|nul|con|lpt[1-9]|com[1-9]|core|default
-    auto is_reserved = [](const std::string &s) {
-        if (s == "prn" || s == "aux" || s == "nul" || s == "con" || s == "core" || s == "default") {
-            return true;
-        }
-        if (s.length() == 4 && (s.compare(0, 3, "lpt") == 0 || s.compare(0, 3, "com") == 0) && (s[3] >= '1' && s[3] <= '9')) {
-            return true;
+    // [a-z0-9]+(-[a-z0-9]+)*
+    for (size_t i = 0; i < name.length(); i++) {
+        auto c = name[i];
+        if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (i > 0 && c == '-')) {
+            continue;
         }
         return false;
-    };
-    // [a-z0-9]+(-[a-z0-9]+)*
-    auto is_identifier = [](const std::string &s) {
-        for (size_t i = 0; i < s.length(); i++) {
-            auto c = s[i];
-            if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || (i > 0 && c == '-')) {
-                continue;
-            }
-            return false;
-        }
+    }
+    return true;
+}
+
+static bool vcpkg_identifier_reserved(const std::string &name) {
+    // prn|aux|nul|con|lpt[1-9]|com[1-9]|core|default
+    if (name == "prn" || name == "aux" || name == "nul" || name == "con" || name == "core" || name == "default") {
         return true;
-    };
-    return is_identifier(name) && !is_reserved(name);
+    }
+    if (name.length() == 4 && (name.compare(0, 3, "lpt") == 0 || name.compare(0, 3, "com") == 0) && (name[3] >= '1' && name[3] <= '9')) {
+        return true;
+    }
+    return false;
 }
 
 static std::string vcpkg_escape_identifier(const std::string &name) {
@@ -600,10 +655,12 @@ static std::string vcpkg_escape_identifier(const std::string &name) {
 
         escaped += std::tolower(ch);
     }
-
     if (!vcpkg_valid_identifier(escaped)) {
         throw std::runtime_error("The escaped project name '" + escaped + "' is not usable with [vcpkg]");
     }
+    if (vcpkg_identifier_reserved(escaped)) {
+        throw std::runtime_error("The escaped project name '" + escaped + "' is a reserved name [vcpkg]");
+    }
     return escaped;
 }
 
@@ -814,19 +871,20 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         cmd("if")("CMKR_ROOT_PROJECT", "AND", "NOT", "CMKR_DISABLE_VCPKG");
             cmd("include")("FetchContent");
             comment("Fix warnings about DOWNLOAD_EXTRACT_TIMESTAMP");
-            // clang-format off
             cmd("if")("POLICY", "CMP0135");
                 cmd("cmake_policy")("SET", "CMP0135", "NEW");
             cmd("endif")();
-        // clang-format on
-        cmd("message")("STATUS", "Fetching vcpkg (" + version_name + ")...");
-        cmd("FetchContent_Declare")("vcpkg", "URL", url);
-        // Not using FetchContent_MakeAvailable here in case vcpkg adds CMakeLists.txt
-        cmd("FetchContent_GetProperties")("vcpkg");
-        cmd("if")("NOT", "vcpkg_POPULATED");
-        cmd("FetchContent_Populate")("vcpkg");
-        cmd("include")("${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake");
-        cmd("endif")();
+            cmd("message")("STATUS", "Fetching vcpkg (" + version_name + ")...");
+            cmd("FetchContent_Declare")("vcpkg", "URL", url);
+            // Not using FetchContent_MakeAvailable here in case vcpkg adds CMakeLists.txt
+            cmd("FetchContent_GetProperties")("vcpkg");
+            cmd("if")("NOT", "vcpkg_POPULATED");
+                cmd("FetchContent_Populate")("vcpkg");
+                cmd("if")("CMAKE_HOST_SYSTEM_NAME", "STREQUAL", "Darwin", "AND", "CMAKE_OSX_ARCHITECTURES", "STREQUAL", RawArg("\"\""));
+                    cmd("set")("CMAKE_OSX_ARCHITECTURES", "${CMAKE_HOST_SYSTEM_PROCESSOR}", "CACHE", "STRING", RawArg("\"\""), "FORCE");
+                cmd("endif")();
+                cmd("include")("${vcpkg_SOURCE_DIR}/scripts/buildsystems/vcpkg.cmake");
+            cmd("endif")();
         cmd("endif")();
         endl();
         // clang-format on
@@ -847,11 +905,17 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             const auto &package = packages[i];
             const auto &features = package.features;
             if (!vcpkg_valid_identifier(package.name)) {
-                throw std::runtime_error("Invalid vcpkg package name '" + package.name + "'");
+                throw std::runtime_error("Invalid vcpkg package name '" + package.name + "', name is not valid");
+            }
+            if (vcpkg_identifier_reserved(package.name)) {
+                throw std::runtime_error("Invalid vcpkg package name '" + package.name + "', name is reserved");
             }
             for (const auto &feature : features) {
                 if (!vcpkg_valid_identifier(feature)) {
-                    throw std::runtime_error("Invalid vcpkg package feature '" + feature + "'");
+                    throw std::runtime_error("Invalid vcpkg package feature '" + feature + "', name is not valid");
+                }
+                if (vcpkg_identifier_reserved(feature)) {
+                    throw std::runtime_error("Invalid vcpkg package feature '" + feature + "', name is reserved");
                 }
             }
             if (features.empty()) {
@@ -894,6 +958,20 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         ofs << "}\n";
     }
 
+    if (!project.packages.empty()) {
+        comment("Packages");
+        for (const auto &dep : project.packages) {
+            auto version = dep.version;
+            if (version == "*")
+                version.clear();
+            auto required = dep.required ? "REQUIRED" : "";
+            auto config = dep.config ? "CONFIG" : "";
+            auto components = std::make_pair("COMPONENTS", dep.components);
+            ConditionScope cs(gen, dep.condition);
+            cmd("find_package")(dep.name, version, required, config, components).endl();
+        }
+    }
+
     if (!project.contents.empty()) {
         cmd("include")("FetchContent").endl();
         if (!project.root()->vcpkg.enabled()) {
@@ -917,7 +995,11 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                 version_info = " (" + content.arguments.at("SVN_REVISION") + ")";
             }
             cmd("message")("STATUS", "Fetching " + content.name + version_info + "...");
-            cmd("FetchContent_Declare")(content.name, content.arguments);
+            if (content.system) {
+                cmd("FetchContent_Declare")(content.name, "SYSTEM", content.arguments);
+            } else {
+                cmd("FetchContent_Declare")(content.name, content.arguments);
+            }
             cmd("FetchContent_MakeAvailable")(content.name).endl();
 
             gen.conditional_includes(content.include_after);
@@ -925,20 +1007,6 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         }
     }
 
-    if (!project.packages.empty()) {
-        comment("Packages");
-        for (const auto &dep : project.packages) {
-            auto version = dep.version;
-            if (version == "*")
-                version.clear();
-            auto required = dep.required ? "REQUIRED" : "";
-            auto config = dep.config ? "CONFIG" : "";
-            auto components = std::make_pair("COMPONENTS", dep.components);
-            ConditionScope cs(gen, dep.condition);
-            cmd("find_package")(dep.name, version, required, config, components).endl();
-        }
-    }
-
     auto add_subdir = [&](const std::string &dir) {
         // clang-format off
         comment("Subdirectory: " + dir);
@@ -1337,7 +1405,12 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             }
             auto working_directory = std::make_pair("WORKING_DIRECTORY", dir);
             auto command = std::make_pair("COMMAND", test.command);
-            auto arguments = std::make_pair("", test.arguments);
+
+            // Transform the provided arguments into raw arguments to prevent them from being quoted when the generator runs
+            std::vector<RawArg> raw_arguments{};
+            for (const auto &argument : test.arguments)
+                raw_arguments.emplace_back(argument);
+            auto arguments = std::make_pair("", raw_arguments);
             ConditionScope cs(gen, test.condition);
             cmd("add_test")(name, configurations, working_directory, command, arguments).endl();
         }
@@ -1368,10 +1441,19 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         }
     }
 
+    // Fetch the generated CMakeLists.txt output from the stringstream buffer
+    auto generated_cmake = ss.str();
+
+    // Make sure the file ends in a single newline
+    while (!generated_cmake.empty() && std::isspace(generated_cmake.back())) {
+        generated_cmake.pop_back();
+    }
+    generated_cmake += '\n';
+
     // Generate CMakeLists.txt
     auto list_path = fs::path(path) / "CMakeLists.txt";
 
-    auto should_regenerate = [&list_path, &ss]() {
+    auto should_regenerate = [&list_path, &generated_cmake]() {
         if (!fs::exists(list_path))
             return true;
 
@@ -1381,11 +1463,11 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         }
 
         std::string data((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
-        return data != ss.str();
+        return data != generated_cmake;
     }();
 
     if (should_regenerate) {
-        create_file(list_path, ss.str());
+        create_file(list_path, generated_cmake);
     }
 
     auto generate_subdir = [path, &project](const fs::path &sub) {

src/project_parser.cpp

@@ -140,7 +140,7 @@ class TomlChecker {
         for (const auto &itr : m_v.as_table()) {
             const auto &ky = itr.first;
             if (m_conditionVisited.contains(ky)) {
-                if (!conditions.contains(ky)) {
+                if (!conditions.contains(ky) && Project::is_condition_name(ky)) {
                     throw_key_error("Unknown condition '" + ky + "'", ky, itr.second);
                 }
 
@@ -160,7 +160,7 @@ class TomlChecker {
                 throw_key_error("Unknown key '" + ky + "'", ky, itr.second);
             } else if (ky == "condition") {
                 std::string condition = itr.second.as_string();
-                if (!conditions.contains(condition)) {
+                if (!conditions.contains(condition) && Project::is_condition_name(condition)) {
                     throw_key_error("Unknown condition '" + condition + "'", condition, itr.second);
                 }
             }
@@ -265,9 +265,12 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         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["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["msvc"] = R"cmake(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";
@@ -279,6 +282,9 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
     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;
         }
     }
@@ -369,6 +375,24 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
     }
 
     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') {
+                    normalized += std::tolower(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) {
@@ -406,7 +430,18 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 throw_key_error(toml::concat_to_string("Unsupported value type: ", itr.second.type()), itr.first, itr.second);
             }
             options.push_back(o);
-            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);
+            }
         }
     }
 
@@ -443,6 +478,15 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
             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;
@@ -495,6 +539,8 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                     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)) {
@@ -585,6 +631,38 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         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;
+                    }
+
+                    // Skip paths that don't contain backwards or forwards slashes
+                    if (library_path.find_first_of(R"(\/)") == std::string::npos) {
+                        continue;
+                    }
+
+                    // Check if the new file path exists, otherwise emit an error
+                    const auto expected_library_file_path = fs::path{path} / library_path;
+                    if (!fs::exists(expected_library_file_path)) {
+                        throw std::runtime_error("Attempted to link against a library file that doesn't exist for target \"" + name + "\" in \"" +
+                                                 key + "\": " + library_path);
+                    }
+
+                    // Prepend ${CMAKE_CURRENT_SOURCE_DIR} to the path
+                    library_path.insert(0, "${CMAKE_CURRENT_SOURCE_DIR}/");
+                }
+            }
+        };
+        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);
 
@@ -593,28 +671,28 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
 
         Condition<std::string> msvc_runtime;
         t.optional("msvc-runtime", msvc_runtime);
-        for (const auto &condItr : msvc_runtime) {
-            switch (parse_msvcRuntimeType(condItr.second)) {
+        for (const auto &cond_itr : msvc_runtime) {
+            switch (parse_msvcRuntimeType(cond_itr.second)) {
             case msvc_dynamic:
-                target.properties[condItr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL";
+                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL";
                 break;
             case msvc_static:
-                target.properties[condItr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>";
+                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>";
                 break;
             default: {
-                std::string error = "Unknown runtime '" + condItr.second + "'\n";
+                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 (condItr.first.empty()) {
+                if (cond_itr.first.empty()) {
                     report = &t.find("msvc-runtime");
                 } else {
-                    report = &t.find(condItr.first).as_table().find("msvc-runtime").value();
+                    report = &t.find(cond_itr.first).as_table().find("msvc-runtime").value();
                 }
-                throw_key_error(error, condItr.second, *report);
+                throw_key_error(error, cond_itr.second, *report);
             }
             }
         }
@@ -771,7 +849,6 @@ const Project *Project::root() const {
 bool Project::cmake_minimum_version(int major, int minor) const {
     // NOTE: this code is like pulling teeth, sorry
     auto root_version = root()->cmake_version;
-    puts(root_version.c_str());
     auto range_index = root_version.find("...");
     if (range_index != std::string::npos) {
         root_version.resize(range_index);
@@ -788,6 +865,16 @@ bool Project::cmake_minimum_version(int major, int minor) const {
     return std::tie(root_major, root_minor) >= std::tie(major, minor);
 }
 
+bool Project::is_condition_name(const std::string &name) {
+    auto is_named_condition = true;
+    for (auto ch : name) {
+        if (!(ch == '-' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z'))) {
+            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)) {

tests/CMakeLists.txt

@@ -100,3 +100,25 @@ if(MSVC) # msvc
 	)
 
 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()

tests/basic/cmake.toml

@@ -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)`.

tests/cmake.toml

@@ -52,3 +52,16 @@ 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"]

tests/compile-options/cmake.toml

@@ -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.

tests/compile-options/src/main.cpp

@@ -0,0 +1,5 @@
+#include <cstdio>
+
+int main() {
+    puts("Hello from cmkr!");
+}

tests/conditions/cmake.toml

@@ -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"

tests/conditions/src/main.cpp

@@ -1,2 +1,2 @@
 int main() {
-}
+}

tests/conditions/src/windows_specific.cpp

@@ -1,4 +1,4 @@
-#include <Windows.h>
-
-void foo() {
-}
+#include <Windows.h>
+
+void foo() {
+}

tests/cxx-standard/cmake.toml

@@ -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).

tests/cxx-standard/src/main.cpp

@@ -1,7 +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));
+}

tests/fetch-content/cmake.toml

@@ -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).

tests/fetch-content/src/main.cpp

@@ -2,4 +2,4 @@
 
 int main() {
     fmt::print("Hello, world!\n");
-}
+}

tests/globbing/cmake.toml

@@ -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.

tests/globbing/example/src/main.cpp

@@ -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;
+}

tests/globbing/mylib/include/mylib/mylib.hpp

@@ -1,7 +1,7 @@
-#pragma once
-
-#include <string>
-
-namespace mylib {
-std::string message();
-}
+#pragma once
+
+#include <string>
+
+namespace mylib {
+std::string message();
+}

tests/globbing/mylib/src/mylib/mylib.cpp

@@ -1,5 +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!";
+}

tests/interface/cmake.toml

@@ -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"]

tests/interface/include/mylib/mylib.hpp

@@ -1,5 +1,5 @@
-namespace mylib {
-static const char *version() {
-    return "v1.0";
-}
-} // namespace mylib
+namespace mylib {
+static const char *version() {
+    return "v1.0";
+}
+} // namespace mylib

tests/interface/src/main.cpp

@@ -1,7 +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());
+}

tests/msvc-runtime/cmake.toml

@@ -12,4 +12,4 @@ sources = ["src/main.cpp"]
 [target.dynamic-runtime]
 type = "executable"
 sources = ["src/main.cpp"]
-msvc-runtime = "dynamic"
+msvc-runtime = "dynamic"

tests/relative-paths/cmake.toml

@@ -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"]

tests/relative-paths/src/library-code.cpp

@@ -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!");
+}

tests/relative-paths/src/main.cpp

@@ -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
+}

tests/templates/cmake.toml

@@ -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.

tests/vcpkg/cmake.toml

@@ -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 = "2022.11.14"
+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]`.

tests/vcpkg/src/main.cpp

@@ -2,4 +2,4 @@
 
 int main() {
     fmt::print("Hello, world!\n");
-}
+}