Bump to 0.2.40

Use absolute paths for vcpkg overlays

.github/workflows/lint.yml

@@ -1,9 +1,11 @@
 name: lint
 
-on: [push]
+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:
@@ -12,7 +14,7 @@ jobs:
 
       - name: clang-format
         id: clang-format
-        uses: DoozyX/clang-format-lint-action@c3b2c943e924028b93a707a5b1b017976ab8d50c # v0.15
+        uses: DoozyX/clang-format-lint-action@c71d0bf4e21876ebec3e5647491186f8797fde31 # v0.18.2
         with:
           exclude: './third_party'
           extensions: 'c,h,cpp,hpp'
@@ -27,6 +29,8 @@ jobs:
           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:

CMakeLists.txt

@@ -22,7 +22,7 @@ project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.2.29
+		0.2.40
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )
@@ -58,12 +58,9 @@ generate_documentation()
 
 # Target: cmkr
 set(cmkr_SOURCES
-	"src/arguments.cpp"
-	"src/build.cpp"
-	"src/cmake_generator.cpp"
-	"src/help.cpp"
-	"src/main.cpp"
-	"src/project_parser.cpp"
+	cmake.toml
+	"cmake/cmkr.cmake"
+	"cmake/version.hpp.in"
 	"include/arguments.hpp"
 	"include/build.hpp"
 	"include/cmake_generator.hpp"
@@ -71,9 +68,12 @@ set(cmkr_SOURCES
 	"include/help.hpp"
 	"include/literals.hpp"
 	"include/project_parser.hpp"
-	"cmake/cmkr.cmake"
-	"cmake/version.hpp.in"
-	cmake.toml
+	"src/arguments.cpp"
+	"src/build.cpp"
+	"src/cmake_generator.cpp"
+	"src/help.cpp"
+	"src/main.cpp"
+	"src/project_parser.cpp"
 )
 
 add_executable(cmkr)
@@ -94,7 +94,6 @@ target_link_libraries(cmkr PRIVATE
 	ghc_filesystem
 	mpark_variant
 	ordered_map
-	nlohmann_json
 )
 
 get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
@@ -103,7 +102,7 @@ if(NOT CMKR_VS_STARTUP_PROJECT)
 endif()
 
 set(CMKR_TARGET cmkr)
-generate_resources(${CMKR_TARGET})
+include("cmake/custom_targets.cmake")
 
 install(
 	TARGETS

cmake.toml

@@ -4,7 +4,7 @@ cmkr-include = false
 
 [project]
 name = "cmkr"
-version = "0.2.29"
+version = "0.2.40"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
 include-after = [
@@ -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"]

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.29" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+set(CMKR_TAG "v0.2.40" 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/custom_targets.cmake

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

docs/cmake-toml.md

@@ -109,6 +109,13 @@ clang-any = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATC
 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
@@ -153,14 +160,18 @@ Variables emit a [`set`](https://cmake.org/cmake/help/latest/command/set.html) a
 
 ```toml
 [vcpkg]
-version = "2024.03.25"
-url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2024.03.25.tar.gz"
+version = "2024.11.16"
+url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2024.11.16.tar.gz"
 packages = ["fmt", "zlib"]
+overlay-ports = ["my-ports"]
+overlay-triplets = ["my-triplets"]
 ```
 
-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).
+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) or [vcpkg.link](https://vcpkg.link).
 
-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]`. To disable the [default features](https://learn.microsoft.com/en-us/vcpkg/concepts/default-features) you can do: `cpp-httplib[core,openssl]`
+
+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). The `overlay-triplets` feature allows you to customize triplets and change the default behavior (for example always preferring static libraries on Windows). To specify both in one go you can do `[vcpkg].overlay = "my-overlay"`.
 
 ## Packages
 
@@ -208,28 +219,28 @@ Table keys that match CMake variable names (`[A-Z_]+`) will be passed to the [`F
 [target.mytarget]
 condition = "mycondition"
 alias = "mytarget::mytarget"
-type = "static" # executable, shared (DLL), static, interface, object, library, custom
+type = "static" # executable, library, shared (DLL), static, interface, object, 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
-compile-definitions = [""]
+compile-definitions = [""] # preprocessor define (-DFOO)
 private-compile-definitions = [""]
-compile-features = [""]
+compile-features = [""] # C++ standard version (cxx_std_20)
 private-compile-features = [""]
-compile-options = [""]
+compile-options = [""] # compiler flags
 private-compile-options = [""]
-include-directories = [""]
+include-directories = [""] # include paths/directories
 private-include-directories = [""]
-link-directories = [""]
+link-directories = [""] # library directories
 private-link-directories = [""]
-link-libraries = [""]
+link-libraries = [""] # dependencies
 private-link-libraries = [""]
-link-options = [""]
+link-options = [""] # linker flags
 private-link-options = [""]
-precompile-headers = [""]
+precompile-headers = [""] # precompiled headers
 private-precompile-headers = [""]
 
 cmake-before = """
@@ -248,6 +259,35 @@ CXX_STANDARD_REQUIRED = true
 FOLDER = "MyFolder"
 ```
 
+A table mapping the cmkr features to the relevant CMake construct and the relevant documentation pages:
+
+| cmkr | CMake construct | Description |
+| ---- | ----- | ----------- |
+| `alias` | [Alias Libraries](https://cmake.org/cmake/help/latest/command/add_library.html#alias-libraries) | Create an [alias target](https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#alias-targets), used for namespacing or clarity. |
+| `sources` | [`target_sources`](https://cmake.org/cmake/help/latest/command/target_sources.html) | Source files (`PRIVATE` except `interface` targets). |
+| `headers` | [`target_sources`](https://cmake.org/cmake/help/latest/command/target_sources.html) | For readability (and future packaging). |
+| `msvc-runtime` | [`MSVC_RUNTIME_LIBRARY`](https://cmake.org/cmake/help/latest/prop_tgt/MSVC_RUNTIME_LIBRARY.html) | The [CMP0091](https://cmake.org/cmake/help/latest/policy/CMP0091.html) policy is set automatically. |
+| `compile-definitions` | [`target_compile_definitions`](https://cmake.org/cmake/help/latest/command/target_compile_definitions.html) | Adds a macro definition (define, `-DMYMACRO=XXX`). |
+| `compile-features` | [`target_compile_features`](https://cmake.org/cmake/help/latest/command/target_compile_features.html) | Specifies the C++ standard version (`cxx_std_20`). |
+| `compile-options` | [`target_compile_options`](https://cmake.org/cmake/help/latest/command/target_compile_options.html) | Adds compiler flags. |
+| `include-directories` | [`target_include_directories`](https://cmake.org/cmake/help/latest/command/target_include_directories.html) | Adds include directories. |
+| `link-directories` | [`target_link_directories`](https://cmake.org/cmake/help/latest/command/target_link_directories.html) | Adds library directories. |
+| `link-libraries` | [`target_link_libraries`](https://cmake.org/cmake/help/latest/command/target_link_libraries.html) | Adds library dependencies. |
+| `link-options` | [`target_link_options`](https://cmake.org/cmake/help/latest/command/target_link_options.html) | Adds linker flags. |
+| `precompile-headers` | [`target_precompile_headers`](https://cmake.org/cmake/help/latest/command/target_precompile_headers.html) | Specifies precompiled headers. |
+| `properties` | [`set_target_properties`](https://cmake.org/cmake/help/latest/command/set_target_properties.html) | See [properties on targets](https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#properties-on-targets) for more information. |
+
+The default [visibility](/basics) is as follows:
+
+| Type         | Visibility  |
+| ------------ | ----------- |
+| `executable` | `PRIVATE`   |
+| `library`    | `PUBLIC`    |
+| `shared`     | `PUBLIC`    |
+| `static`     | `PUBLIC`    |
+| `object`     | `PUBLIC`    |
+| `interface`  | `INTERFACE` |
+
 ## Templates
 
 To avoid repeating yourself you can create your own target type and use it in your targets:

docs/examples/compile-options.md

@@ -9,7 +9,7 @@ nav_order: 9
 
 # Compiler flags
 
-Example project that sets compiler/linker flags for various platforms.
+Example project that sets compiler flags and preprocessor defines for various platforms.
 
 ```toml
 [project]
@@ -20,11 +20,14 @@ description = "Compiler flags"
 type = "executable"
 sources = ["src/main.cpp"]
 msvc.compile-options = ["/W2"]
+msvc.compile-definitions = ["PLATFORM=\"msvc\""]
 gcc.compile-options = ["-Wall"]
+gcc.compile-definitions = ["PLATFORM=\"gcc\""]
 clang.compile-options = ["-Wall"]
+clang.compile-definitions = ["PLATFORM=\"clang\""]
 ```
 
-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.
+The `hello` target uses [conditions](/cmake-toml#conditions) to set different compiler flags and definitions 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.
 

docs/examples/vcpkg.md

@@ -9,7 +9,7 @@ nav_order: 4
 
 # Dependencies from vcpkg
 
-Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://vcpkg.io/) and links an `example` target to it:
+Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://github.com/microsoft/vcpkg) and links an `example` target to it:
 
 ```toml
 [project]
@@ -17,13 +17,12 @@ name = "vcpkg"
 description = "Dependencies from vcpkg"
 
 # See https://github.com/microsoft/vcpkg/releases for vcpkg versions
-# See https://vcpkg.io/en/packages.html for available packages
+# See https://vcpkg.io/en/packages or https://vcpkg.link for available packages
 [vcpkg]
-version = "2024.03.25"
+version = "2024.11.16"
 packages = ["fmt"]
 
-[find-package]
-fmt = {}
+[find-package.fmt]
 
 [target.example]
 type = "executable"

include/project_parser.hpp

@@ -45,10 +45,15 @@ struct Vcpkg {
     struct Package {
         std::string name;
         std::vector<std::string> features;
+        bool default_features = true;
     };
 
     std::vector<Package> packages;
 
+    // https://github.com/Microsoft/vcpkg-docs/blob/main/vcpkg/users/buildsystems/cmake-integration.md
+    std::vector<std::string> overlay_ports;
+    std::vector<std::string> overlay_triplets;
+
     bool enabled() const {
         return !packages.empty();
     }
@@ -155,7 +160,7 @@ struct Content {
     Condition<std::string> cmake_after;
     ConditionVector include_before;
     ConditionVector include_after;
-    bool system;
+    bool system = false;
     std::string subdir;
 };
 

src/cmake_generator.cpp

@@ -54,57 +54,85 @@ static std::string format(const char *format, const tsl::ordered_map<std::string
     return s;
 }
 
-static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs::path &toml_dir, bool is_root_project) {
-    std::vector<std::string> temp;
-
-    auto extract_suffix = [](const fs::path &base, const fs::path &full) {
-        auto fullpath = full.string();
-        auto base_len = base.string().length();
-        auto delet = fullpath.substr(base_len + 1, fullpath.length() - base_len);
-        return delet;
+static std::vector<fs::path> expand_cmake_path(const fs::path &source_path, const fs::path &toml_dir, bool is_root_project) {
+    auto is_subdir = [](fs::path p, const fs::path &root) {
+        while (true) {
+            if (p == root) {
+                return true;
+            }
+            auto parent = p.parent_path();
+            if (parent == p) {
+                break;
+            }
+            p = parent;
+        }
+        return false;
     };
-
-    auto stem = name.filename().stem().string();
-    auto ext = name.extension();
-
-    if (is_root_project && stem == "**" && name == name.filename()) {
-        throw std::runtime_error("Recursive globbing not allowed in project root: " + name.string());
+    if (!is_subdir(fs::absolute(toml_dir / source_path), toml_dir)) {
+        throw std::runtime_error("Path traversal is not allowed: " + source_path.string());
     }
 
+    // Split the path at the first period (since fs::path::stem() and fs::path::extension() split at the last period)
+    std::string stem, extension;
+    auto filename = source_path.filename().string();
+    auto dot_position = filename.find('.');
+    if (dot_position != std::string::npos) {
+        stem = filename.substr(0, dot_position);
+        extension = filename.substr(dot_position);
+    } else {
+        stem = filename;
+    }
+
+    if (is_root_project && stem == "**" && !source_path.has_parent_path()) {
+        throw std::runtime_error("Recursive globbing not allowed in project root: " + source_path.string());
+    }
+
+    auto has_extension = [](const fs::path &file_path, const std::string &extension) {
+        auto path = file_path.string();
+        return path.rfind(extension) == path.length() - extension.length();
+    };
+
+    std::vector<fs::path> paths;
     if (stem == "*") {
-        for (const auto &f : fs::directory_iterator(toml_dir / name.parent_path(), fs::directory_options::follow_directory_symlink)) {
-            if (!f.is_directory() && f.path().extension() == ext) {
-                temp.push_back(extract_suffix(toml_dir, f));
+        for (const auto &f : fs::directory_iterator(toml_dir / source_path.parent_path(), fs::directory_options::follow_directory_symlink)) {
+            if (!f.is_directory() && has_extension(f.path(), extension)) {
+                paths.push_back(fs::relative(f, toml_dir));
             }
         }
     } else if (stem == "**") {
-        for (const auto &f : fs::recursive_directory_iterator(toml_dir / name.parent_path(), fs::directory_options::follow_directory_symlink)) {
-            if (!f.is_directory() && f.path().extension() == ext) {
-                temp.push_back(extract_suffix(toml_dir, f.path()));
+        for (const auto &f :
+             fs::recursive_directory_iterator(toml_dir / source_path.parent_path(), fs::directory_options::follow_directory_symlink)) {
+            if (!f.is_directory() && has_extension(f.path(), extension)) {
+                paths.push_back(fs::relative(f, toml_dir));
             }
         }
     } else {
-        temp.push_back(name.string());
+        paths.push_back(source_path);
     }
-    // Normalize all paths to work with CMake (it needs a / on Windows as well)
-    for (auto &path : temp) {
-        std::replace(path.begin(), path.end(), '\\', '/');
-    }
-    // Sort paths alphabetically for consistent cross-OS generation
-    std::sort(temp.begin(), temp.end());
-    return temp;
+
+    return paths;
 }
 
 static std::vector<std::string> expand_cmake_paths(const std::vector<std::string> &sources, const fs::path &toml_dir, bool is_root_project) {
-    // TODO: add duplicate checking
-    std::vector<std::string> result;
+    std::vector<std::string> paths;
     for (const auto &src : sources) {
         auto expanded = expand_cmake_path(src, toml_dir, is_root_project);
         for (const auto &f : expanded) {
-            result.push_back(f);
+            paths.push_back(f.string());
         }
     }
-    return result;
+
+    // Normalize all paths to work with CMake (it needs a / on Windows as well)
+    for (auto &path : paths) {
+        std::replace(path.begin(), path.end(), '\\', '/');
+    }
+
+    // Sort paths alphabetically for consistent cross-OS generation
+    std::sort(paths.begin(), paths.end());
+
+    // TODO: remove duplicates
+
+    return paths;
 }
 
 static void create_file(const fs::path &path, const std::string &contents) {
@@ -549,7 +577,7 @@ struct Generator {
             }
             cmd("if", "NOTE: unnamed condition")(RawArg(cmake_condition(condition)));
         } else {
-            cmd("if", condition)(RawArg(found->second));
+            cmd("if", condition)(RawArg(cmake_condition(found->second)));
         }
         return true;
     }
@@ -653,7 +681,10 @@ static std::string vcpkg_escape_identifier(const std::string &name) {
             ch = '-';
         }
 
-        escaped += std::tolower(ch);
+        if (ch >= 'A' && ch <= 'Z') {
+            ch += ('a' - 'A');
+        }
+        escaped += ch;
     }
     if (!vcpkg_valid_identifier(escaped)) {
         throw std::runtime_error("The escaped project name '" + escaped + "' is not usable with [vcpkg]");
@@ -674,7 +705,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
 
     parser::Project project(parent_project, path, false);
 
-    for (auto const &lang : project.project_languages) {
+    for (const auto &lang : project.project_languages) {
         if (known_languages.find(lang) == known_languages.end()) {
             if (project.project_allow_unknown_languages) {
                 printf("[warning] Unknown language '%s' specified\n", lang.c_str());
@@ -700,24 +731,6 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
     if (is_root_project) {
         cmd("cmake_minimum_required")("VERSION", project.cmake_version).endl();
 
-        if (project.project_msvc_runtime != parser::msvc_last) {
-            comment("Enable support for MSVC_RUNTIME_LIBRARY");
-            cmd("cmake_policy")("SET", "CMP0091", "NEW");
-
-            switch (project.project_msvc_runtime) {
-            case parser::msvc_dynamic:
-                cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL");
-                break;
-            case parser::msvc_static:
-                cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>");
-                break;
-            default:
-                break;
-            }
-            endl();
-        }
-
-        // clang-format on
         if (!project.allow_in_tree) {
             // clang-format off
             cmd("if")("CMAKE_SOURCE_DIR", "STREQUAL", "CMAKE_BINARY_DIR");
@@ -726,6 +739,11 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             // clang-format on
         }
 
+        if (project.project_msvc_runtime != parser::msvc_last) {
+            comment("Enable support for MSVC_RUNTIME_LIBRARY");
+            cmd("cmake_policy")("SET", "CMP0091", "NEW").endl();
+        }
+
         cmd("set")("CMKR_ROOT_PROJECT", "OFF");
         // clang-format off
         cmd("if")("CMAKE_CURRENT_SOURCE_DIR", "STREQUAL", "CMAKE_SOURCE_DIR");
@@ -743,7 +761,26 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             cmd("set_property")("GLOBAL", "PROPERTY", "USE_FOLDERS", "ON").endl();
 
             comment("Create a configure-time dependency on cmake.toml to improve IDE support");
-            cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
+            if (project.cmake_minimum_version(3, 0)) {
+                cmd("set_property")("DIRECTORY", "APPEND", "PROPERTY", "CMAKE_CONFIGURE_DEPENDS", "cmake.toml");
+            } else {
+                cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
+            }
+
+            if (project.project_msvc_runtime != parser::msvc_last) {
+                cmd("if")("NOT", "DEFINED", "CMAKE_MSVC_RUNTIME_LIBRARY");
+                switch (project.project_msvc_runtime) {
+                case parser::msvc_dynamic:
+                    cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL");
+                    break;
+                case parser::msvc_static:
+                    cmd("set")("CMAKE_MSVC_RUNTIME_LIBRARY", "MultiThreaded$<$<CONFIG:Debug>:Debug>");
+                    break;
+                default:
+                    break;
+                }
+                cmd("endif")().endl();
+            }
         cmd("endif")().endl();
         // clang-format on
 
@@ -752,12 +789,14 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             create_file(cmkr_include, resources::cmkr);
         }
     } else {
-        // clang-format off
         comment("Create a configure-time dependency on cmake.toml to improve IDE support");
         cmd("if")("CMKR_ROOT_PROJECT");
+        if (project.cmake_minimum_version(3, 0)) {
+            cmd("set_property")("DIRECTORY", "APPEND", "PROPERTY", "CMAKE_CONFIGURE_DEPENDS", "cmake.toml");
+        } else {
             cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
+        }
         cmd("endif")().endl();
-        // clang-format on
     }
 
     // TODO: remove support and replace with global compile-features
@@ -822,6 +861,27 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         endl();
     }
 
+    if (project.vcpkg.enabled()) {
+        comment("vcpkg settings");
+        auto emit_overlay = [&cmd](const std::string &name, const std::vector<std::string> &overlay) {
+            if (!overlay.empty()) {
+                std::vector<std::string> set_args;
+                for (const auto &directory : overlay) {
+                    if (!fs::path(directory).is_relative()) {
+                        throw std::runtime_error("[vcpkg] overlay is not a relative path: " + directory);
+                    }
+                    if (!fs::is_directory(directory)) {
+                        throw std::runtime_error("[vcpkg] overlay is not a directory: " + directory);
+                    }
+                    set_args.emplace_back("${CMAKE_CURRENT_SOURCE_DIR}/" + directory);
+                }
+                cmd("set")(name, set_args);
+            }
+        };
+        emit_overlay("VCPKG_OVERLAY_PORTS", project.vcpkg.overlay_ports);
+        emit_overlay("VCPKG_OVERLAY_TRIPLETS", project.vcpkg.overlay_triplets);
+    }
+
     gen.conditional_includes(project.include_before);
     gen.conditional_cmake(project.cmake_before);
 
@@ -866,6 +926,13 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
             }
         }
 
+        tsl::ordered_map<std::string, std::string> vcpkg_args = {
+            {"URL", url},
+            {"SUBBUILD_DIR", "CMakeFiles/vcpkg-subbuild"},
+            {"SOURCE_DIR", "vcpkg"},
+            {"BINARY_DIR", "CMakeFiles/vcpkg-build"},
+        };
+
         // CMake to bootstrap vcpkg and download the packages
         // clang-format off
         cmd("if")("CMKR_ROOT_PROJECT", "AND", "NOT", "CMKR_DISABLE_VCPKG");
@@ -875,7 +942,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                 cmd("cmake_policy")("SET", "CMP0135", "NEW");
             cmd("endif")();
             cmd("message")("STATUS", "Fetching vcpkg (" + version_name + ")...");
-            cmd("FetchContent_Declare")("vcpkg", "URL", url);
+            cmd("FetchContent_Declare")("vcpkg", vcpkg_args);
             // Not using FetchContent_MakeAvailable here in case vcpkg adds CMakeLists.txt
             cmd("FetchContent_GetProperties")("vcpkg");
             cmd("if")("NOT", "vcpkg_POPULATED");
@@ -897,7 +964,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         ofs << R"({
   "$cmkr": "This file is automatically generated from cmake.toml - DO NOT EDIT",
   "$cmkr-url": "https://github.com/build-cpp/cmkr",
-  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
   "dependencies": [
 )";
 
@@ -918,17 +985,20 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
                     throw std::runtime_error("Invalid vcpkg package feature '" + feature + "', name is reserved");
                 }
             }
-            if (features.empty()) {
+            if (features.empty() && package.default_features) {
                 ofs << "    \"" << package.name << '\"';
             } else {
                 ofs << "    {\n";
                 ofs << "      \"name\": \"" << package.name << "\",\n";
+                if (!package.default_features) {
+                    ofs << "      \"default-features\": false,\n";
+                }
                 ofs << "      \"features\": [";
                 for (size_t j = 0; j < features.size(); j++) {
                     const auto &feature = features[j];
                     ofs << '\"' << feature << '\"';
                     if (j + 1 < features.size()) {
-                        ofs << ',';
+                        ofs << ", ";
                     }
                 }
                 ofs << "]\n";
@@ -954,7 +1024,7 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
         ofs << "  ],\n";
         ofs << "  \"description\": \"" << escape(project.project_description) << "\",\n";
         ofs << "  \"name\": \"" << escape(vcpkg_escape_identifier(project.project_name)) << "\",\n";
-        ofs << R"(  "version-string": "")" << '\n';
+        ofs << "  \"version-string\": \"none\"\n";
         ofs << "}\n";
     }
 
@@ -1052,6 +1122,9 @@ void generate_cmake(const char *path, const parser::Project *parent_project) {
     if (project_languages.empty())
         project_languages = {"C", "CXX"};
 
+    // Reference: https://gitlab.kitware.com/cmake/cmake/-/issues/24340#note_1304703
+    project_languages.push_back("RC");
+
     // All acceptable extensions based off our given languages.
     tsl::ordered_set<std::string> project_extensions;
     for (const auto &language : project_languages) {

src/project_parser.cpp

@@ -274,6 +274,13 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
         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;
@@ -381,7 +388,8 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 if (ch == '_') {
                     normalized += '-';
                 } else if (ch >= 'A' && ch <= 'Z') {
-                    normalized += std::tolower(ch);
+                    ch += ('a' - 'A');
+                    normalized += ch;
                 } else if (ch == '-' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z')) {
                     normalized += ch;
                 } else {
@@ -431,6 +439,9 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
             }
             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) {
@@ -532,10 +543,21 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                     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";
@@ -643,20 +665,16 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                         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)) {
+                    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
                     }
-
-                    // Prepend ${CMAKE_CURRENT_SOURCE_DIR} to the path
-                    library_path.insert(0, "${CMAKE_CURRENT_SOURCE_DIR}/");
                 }
             }
         };
@@ -711,6 +729,8 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                         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 {
@@ -827,13 +847,33 @@ Project::Project(const Project *parent, const std::string &path, bool build) : p
                 std::istringstream feature_stream{features};
                 std::string feature;
                 while (std::getline(feature_stream, feature, ',')) {
-                    package.features.emplace_back(feature);
+                    // Disable default features with package-name[core,feature1]
+                    if (feature == "core") {
+                        package.default_features = false;
+                    } else {
+                        package.features.emplace_back(feature);
+                    }
                 }
             } else {
                 throw_key_error("Invalid package name '" + package_str + "'", "packages", p);
             }
             vcpkg.packages.emplace_back(std::move(package));
         }
+
+        if (v.contains("overlay")) {
+            std::string overlay;
+            v.optional("overlay", overlay);
+            vcpkg.overlay_triplets = vcpkg.overlay_ports = {overlay};
+            if (v.contains("overlay-ports")) {
+                throw_key_error("[vcpkg].overlay was already specified", "overlay-ports", v.find("overlay-ports"));
+            }
+            if (v.contains("overlay-triplets")) {
+                throw_key_error("[vcpkg].overlay was already specified", "overlay-triplets", v.find("overlay-triplets"));
+            }
+        } else {
+            v.optional("overlay-ports", vcpkg.overlay_ports);
+            v.optional("overlay-triplets", vcpkg.overlay_triplets);
+        }
     }
 
     checker.check(conditions, true);
@@ -866,9 +906,8 @@ bool Project::cmake_minimum_version(int major, int minor) const {
 }
 
 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'))) {
+        if (!std::isalnum(ch) && ch != '-' && ch != '_') {
             return false;
         }
     }

tests/.gitignore

@@ -1,3 +1,4 @@
 # These will be generated by cmkr, so no point in tracking them
 **/CMakeLists.txt
-**/cmkr.cmake
+**/cmkr.cmake
+**/vcpkg.json

tests/compile-options/cmake.toml

@@ -1,4 +1,4 @@
-# Example project that sets compiler/linker flags for various platforms.
+# Example project that sets compiler flags and preprocessor defines for various platforms.
 
 [project]
 name = "compile-options"
@@ -8,8 +8,11 @@ description = "Compiler flags"
 type = "executable"
 sources = ["src/main.cpp"]
 msvc.compile-options = ["/W2"]
+msvc.compile-definitions = ["PLATFORM=\"msvc\""]
 gcc.compile-options = ["-Wall"]
+gcc.compile-definitions = ["PLATFORM=\"gcc\""]
 clang.compile-options = ["-Wall"]
+clang.compile-definitions = ["PLATFORM=\"clang\""]
 
-# 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.
+# The `hello` target uses [conditions](/cmake-toml#conditions) to set different compiler flags and definitions 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/globbing/mylib/include/mylib/mylib.hpp

@@ -4,4 +4,4 @@
 
 namespace mylib {
 std::string message();
-}
+} // namespace mylib

tests/vcpkg/cmake.toml

@@ -1,17 +1,16 @@
-# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://vcpkg.io/) and links an `example` target to it:
+# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://github.com/microsoft/vcpkg) and links an `example` target to it:
 
 [project]
 name = "vcpkg"
 description = "Dependencies from vcpkg"
 
 # See https://github.com/microsoft/vcpkg/releases for vcpkg versions
-# See https://vcpkg.io/en/packages.html for available packages
+# See https://vcpkg.io/en/packages or https://vcpkg.link for available packages
 [vcpkg]
-version = "2024.03.25"
+version = "2024.11.16"
 packages = ["fmt"]
 
-[find-package]
-fmt = {}
+[find-package.fmt]
 
 [target.example]
 type = "executable"

tests/vcpkg/vcpkg.json

@@ -1,11 +0,0 @@
-{
-  "$cmkr": "This file is automatically generated from cmake.toml - DO NOT EDIT",
-  "$cmkr-url": "https://github.com/build-cpp/cmkr",
-  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg/master/scripts/vcpkg.schema.json",
-  "dependencies": [
-    "fmt"
-  ],
-  "description": "Dependencies from vcpkg",
-  "name": "vcpkg",
-  "version-string": ""
-}

third_party/CMakeLists.txt

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

third_party/nlohmann-3.9.1/LICENSE

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