WIP O2

.clang-format

@@ -10,7 +10,7 @@ AlignTrailingComments: true
 AllowAllParametersOfDeclarationOnNextLine: true
 AllowShortBlocksOnASingleLine: false
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: true
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 AlwaysBreakAfterDefinitionReturnType: None
@@ -19,7 +19,7 @@ AlwaysBreakBeforeMultilineStrings: false
 AlwaysBreakTemplateDeclarations: true
 BinPackArguments: true
 BinPackParameters: true
-BraceWrapping:
+BraceWrapping:   
   AfterClass:      false
   AfterControlStatement: false
   AfterEnum:       false
@@ -72,7 +72,7 @@ PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
 PointerAlignment: Right
 ReflowComments:  true
-SortIncludes:    false
+SortIncludes:    true
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: true

.editorconfig

@@ -1,24 +0,0 @@
-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/FUNDING.yml

@@ -1 +0,0 @@
-github: [mrexodia]

.github/workflows/build.yml

@@ -1,75 +1,34 @@
-name: build
+name: CMake
 
 on: [push, pull_request]
 
 jobs:
-  cmake:
+  build:
     # 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) }}
+    if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != '${{ github.repository }}'
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2022, macos-latest, ubuntu-20.04]
+        os: [windows-2016, windows-2019, macos-10.15, ubuntu-16.04, ubuntu-18.04, ubuntu-20.04]
     env:
-      BUILD_TYPE: 'Release'
+      BUILD_TYPE: Release
-      CMAKE_GENERATOR: 'Ninja'
     steps:
     - name: Checkout
-      uses: actions/checkout@v3
+      uses: actions/checkout@v2
-
-    - name: Install Ninja
-      uses: seanmiddleditch/gha-setup-ninja@6263846cf3c17009dfc81604efabae16044fc074 # master
-
-    - name: Visual Studio Development Environment
-      uses: ilammy/msvc-dev-cmd@cec98b9d092141f74527d0afa6feb2af698cfe89 # v1.12.1
-
-    - name: Tag cmkr.cmake
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      run: cmake -P "cmake/replace_tag.cmake"
 
     - name: Build
       run: |
-        cmake -B build -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} -DCMAKE_UNITY_BUILD=ON
+        cmake -S. -Bbuild -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} "-DCMAKE_INSTALL_PREFIX=${{ github.workspace }}/install"
         cmake --build build --config ${{ env.BUILD_TYPE }} --parallel
-        cmake --install build --prefix ./install --config ${{ env.BUILD_TYPE }}
+        cmake --install build --config ${{ env.BUILD_TYPE }}
 
     - name: Check if cmkr was run
       run: |
         ./install/bin/cmkr gen
-        git diff --exit-code -- . ":(exclude)cmake/cmkr.cmake"
+        git diff --exit-code
 
     - name: Test
       run: |
         cd build/tests
-        ctest -C ${{ env.BUILD_TYPE }} --verbose
+        ctest -C ${{ env.BUILD_TYPE }}
-
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v3
-      with:
-        name: ${{ github.event.repository.name }}-${{ matrix.os }}
-        path: install/bin/*
-
-    - name: Get lowercase OS name
-      id: osname
-      uses: ASzc/change-string-case-action@07c1e24a97f0951e13f88870b99c058fcf0b14cf # v5
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      with:
-        string: ${{ runner.os }}
-
-    - name: Compress artifacts
-      uses: vimtor/action-zip@26a249fb00d43ca98dad77a4b3838025fc226aa1 # v1.1
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      with:
-        files: install/bin/
-        dest: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
-
-    - name: Release
-      uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 # v0.1.15
-      if: ${{ startsWith(github.ref, 'refs/tags/') }}
-      with:
-        prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') || contains(github.ref, '-pre') }}
-        files: ${{ github.event.repository.name }}-${{ steps.osname.outputs.lowercase }}.zip
-        generate_release_notes: true
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lint.yml

@@ -1,41 +0,0 @@
-name: lint
-
-on: [push, pull_request]
-
-jobs:
-  clang-format:
-    # Skip building pull requests from the same repository
-    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: clang-format
-        id: clang-format
-        uses: DoozyX/clang-format-lint-action@c3b2c943e924028b93a707a5b1b017976ab8d50c # v0.15
-        with:
-          exclude: './third_party'
-          extensions: 'c,h,cpp,hpp'
-          clangFormatVersion: 15
-          style: file
-
-      - name: clang-format instructions
-        if: ${{ failure() && steps.clang-format.outcome == 'failure' }}
-        run: |
-          # Instructions for fixing the formatting errors
-          echo -e "\n\033[0;31mTo fix the formatting, run:\nclang-format -style=file -i \$(git ls-files \"*.c\" \"*.h\" \"*.cpp\" \"*.hpp\")\033[0m\n"
-          exit 1
-
-  editorconfig:
-    # Skip building pull requests from the same repository
-    if: ${{ github.event_name == 'push' || (github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name != github.repository) }}
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v3
-
-      - name: Run editorconfig-checker
-        uses: editorconfig-checker/action-editorconfig-checker@d4fca16fc71adef10fbe101903b654449fa9570c # master 2022-03-15

.gitignore

@@ -9,5 +9,3 @@ build*/
 .idea/
 cmake-build*/
 CMakeLists.txt.user
-.vscode/
-.DS_Store

CMakeLists.txt

@@ -3,34 +3,38 @@
 
 cmake_minimum_required(VERSION 2.8...3.8)
 
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
+# Regenerate CMakeLists.txt automatically in the root project
-	message(FATAL_ERROR "In-tree builds are not supported. Run CMake from a separate directory: cmake -B build")
-endif()
-
 set(CMKR_ROOT_PROJECT OFF)
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
 	set(CMKR_ROOT_PROJECT ON)
 
+	# Bootstrap cmkr
+	include(cmkr.cmake OPTIONAL RESULT_VARIABLE CMKR_INCLUDE_RESULT)
+	if(CMKR_INCLUDE_RESULT)
+		cmkr()
+	endif()
+
 	# Enable folder support
 	set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+endif()
 
-	# Create a configure-time dependency on cmake.toml to improve IDE support
+# Create a configure-time dependency on cmake.toml to improve IDE support
+if(CMKR_ROOT_PROJECT)
 	configure_file(cmake.toml cmake.toml COPYONLY)
 endif()
 
+include("cmake/O2.cmake")
+
 project(cmkr
 	LANGUAGES
 		CXX
 	VERSION
-		0.2.33
+		0.1.4
 	DESCRIPTION
 		"CMakeLists generator from TOML"
 )
 
-include("cmake/generate_documentation.cmake")
+# third_party
-include("cmake/generate_resources.cmake")
-
-# Subdirectory: third_party
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/third_party")
@@ -40,7 +44,7 @@ endif()
 add_subdirectory(third_party)
 set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})
 
-# Subdirectory: tests
+# tests
 set(CMKR_CMAKE_FOLDER ${CMAKE_FOLDER})
 if(CMAKE_FOLDER)
 	set(CMAKE_FOLDER "${CMAKE_FOLDER}/tests")
@@ -50,35 +54,47 @@ endif()
 add_subdirectory(tests)
 set(CMAKE_FOLDER ${CMKR_CMAKE_FOLDER})
 
-# Target: cmkr_generate_documentation
-add_library(cmkr_generate_documentation INTERFACE)
 
-set(CMKR_TARGET cmkr_generate_documentation)
-generate_documentation()
 
-# Target: cmkr
+# Target cmkr
-set(cmkr_SOURCES
+set(CMKR_TARGET cmkr)
-	cmake.toml
+set(cmkr_SOURCES "")
-	"cmake/cmkr.cmake"
+
-	"cmake/version.hpp.in"
+list(APPEND cmkr_SOURCES
-	"include/arguments.hpp"
+	"src/args.cpp"
+	"src/build.cpp"
+	"src/cmake.cpp"
+	"src/error.cpp"
+	"src/gen.cpp"
+	"src/help.cpp"
+	"src/main.cpp"
+	"include/args.hpp"
 	"include/build.hpp"
-	"include/cmake_generator.hpp"
+	"include/cmake.hpp"
+	"include/enum_helper.hpp"
+	"include/error.hpp"
 	"include/fs.hpp"
+	"include/gen.hpp"
 	"include/help.hpp"
 	"include/literals.hpp"
-	"include/project_parser.hpp"
-	"src/arguments.cpp"
-	"src/build.cpp"
-	"src/cmake_generator.cpp"
-	"src/help.cpp"
-	"src/main.cpp"
-	"src/project_parser.cpp"
 )
 
+list(APPEND cmkr_SOURCES
+	cmake.toml
+)
+
+set(CMKR_SOURCES ${cmkr_SOURCES})
 add_executable(cmkr)
 
-target_sources(cmkr PRIVATE ${cmkr_SOURCES})
+if(cmkr_SOURCES)
+	target_sources(cmkr PRIVATE ${cmkr_SOURCES})
+endif()
+
+get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+if(NOT CMKR_VS_STARTUP_PROJECT)
+	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT cmkr)
+endif()
+
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${cmkr_SOURCES})
 
 target_compile_features(cmkr PRIVATE
@@ -96,19 +112,13 @@ target_link_libraries(cmkr PRIVATE
 	ordered_map
 )
 
-get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+unset(CMKR_TARGET)
-if(NOT CMKR_VS_STARTUP_PROJECT)
+unset(CMKR_SOURCES)
-	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT cmkr)
-endif()
-
-set(CMKR_TARGET cmkr)
-include("cmake/custom_targets.cmake")
-
 install(
 	TARGETS
 		cmkr
 	DESTINATION
-		bin
+		"${CMAKE_INSTALL_PREFIX}/bin"
 	COMPONENT
 		cmkr
 )

README.md

@@ -1,75 +1,55 @@
 # cmkr
 
-`cmkr`, pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).
+cmkr, pronounced "cmaker", is a modern build system based on CMake and TOML. It was originally created by [Mohammed Alyousef](https://github.com/MoAlyousef).
 
-`cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:
+**NOTE**: The documentation is currently a work-in-progress due to breaking changes since `0.1.4`. For examples you can check the [cmkr GitHub topic](https://github.com/topics/cmkr) and the [tests](https://github.com/build-cpp/cmkr/tree/main/tests).
-
-```toml
-[project]
-name = "cmkr_for_beginners"
-
-[target.hello_world]
-type = "executable"
-sources = ["src/main.cpp"]
-```
-
-`cmkr` can bootstrap itself and you only need CMake and a C++ compiler to use it.
 
 ## Getting started
 
-To get started, run the following commands from your project directory:
+`cmkr` parses `cmake.toml` files and generates a modern, idomatic `CMakeLists.txt` for you. A basic hello world format with the minimum required fields:
 
-```sh
+```toml
-curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
+[cmake]
-cmake -P cmkr.cmake
+minimum = "3.15"
-```
 
-After the bootstrapping process finishes, customize [`cmake.toml`](https://build-cpp.github.io/cmkr/cmake-toml) for your project and run CMake:
+[project]
+name = "app"
+version = "0.1.0"
 
-```sh
+[target.app]
-cmake -B build
+type = "executable"
-cmake --build build
+sources = ["src/main.cpp"]
 ```
 
-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.
+## Building
-
-<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
 
-In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.
+`cmkr` requires a C++11 compiler and CMake >= ~3.x (exact minimum version is not yet specified). C++11 was picked to allow the broadest possible set of compilers to bootstrap `cmkr`.
-
-## Template repositories
-
-Another way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
 
 ```sh
-cmake -B build
+git clone https://github.com/moalyousef/cmkr
-cmake --build build
+cd cmkr
+cmake -Bbin
+cmake --build bin --parallel
 ```
 
-Check out the [cmkr topic](https://github.com/topics/cmkr), the [build-cpp organization](https://github.com/build-cpp) or the [tests](https://github.com/build-cpp/cmkr/tree/main/tests) for more examples and templates.
-
 ## Command line
 
-Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/releases) in your `PATH` and use it as a utility from the command line:
+The `cmkr` executable can be run from the command-line:
 
 ```
 Usage: cmkr [arguments]
 arguments:
-    init    [executable|library|shared|static|interface] Create a project.
+    init    [executable|library|shared|static|interface] Starts a new project in the same directory.
     gen                                                  Generates CMakeLists.txt file.
     build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install.
+    install                                              Run cmake --install. Needs admin privileges.
     clean                                                Clean the build directory.
     help                                                 Show help.
     version                                              Current cmkr version.
 ```
 
-## Credits
+The build command invokes `cmake` and the default build-system on your platform (unless a generator is specified), it also accepts extra build arguments:
 
-- [gulrak/filesystem](https://github.com/gulrak/filesystem)
+```sh
-- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
+cmkr build --config Release 
-- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
+```
-- [mpark/variant](https://github.com/mpark/variant)
-- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
-- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
-- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️

cmake.toml

@@ -1,44 +1,21 @@
 [cmake]
 version = "2.8...3.8"
-cmkr-include = false
 
 [project]
 name = "cmkr"
-version = "0.2.33"
+version = "0.1.4"
 description = "CMakeLists generator from TOML"
 languages = ["CXX"]
-include-after = [
-    "cmake/generate_documentation.cmake",
-    "cmake/generate_resources.cmake"
-]
 subdirs = ["third_party", "tests"]
-
+include-before = ["cmake/O2.cmake"]
-[target.cmkr_generate_documentation]
-type = "interface"
-cmake-after = """
-generate_documentation()
-"""
 
 [target.cmkr]
 type = "executable"
-sources = [
+sources = ["src/*.cpp", "include/*.hpp"]
-    "src/*.cpp",
+include-directories = ["include"]
-    "include/*.hpp",
-    "cmake/cmkr.cmake",
-    "cmake/version.hpp.in",
-]
-include-directories = [
-    "include",
-]
 compile-features = ["cxx_std_11"]
-link-libraries = [
+link-libraries = ["toml11", "ghc_filesystem", "mpark_variant", "ordered_map"]
-    "toml11",
-    "ghc_filesystem",
-    "mpark_variant",
-    "ordered_map",
-]
-include-after = ["cmake/custom_targets.cmake"]
 
 [[install]]
 targets = ["cmkr"]
-destination = "bin"
+destination = "${CMAKE_INSTALL_PREFIX}/bin"

cmake/CMakeLists.txt

@@ -0,0 +1,44 @@
+# This file was generated automatically by cmkr.
+
+cmake_minimum_required(VERSION 3.15)
+
+# Regenerate CMakeLists.txt automatically in the root project
+set(CMKR_ROOT_PROJECT OFF)
+if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+	set(CMKR_ROOT_PROJECT ON)
+
+	# Bootstrap cmkr
+	include(cmkr.cmake OPTIONAL RESULT_VARIABLE CMKR_INCLUDE_RESULT)
+	if(CMKR_INCLUDE_RESULT)
+		cmkr()
+	endif()
+
+	# Enable folder support
+	set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+endif()
+
+# Create a configure-time dependency on cmake.toml to improve IDE support
+if(CMKR_ROOT_PROJECT)
+	configure_file(cmake.toml cmake.toml COPYONLY)
+endif()
+
+project(example
+	VERSION
+		0.1.0
+)
+
+# Target example
+set(example_SOURCES
+	"src/example.cpp"
+	cmake.toml
+)
+
+add_executable(example ${example_SOURCES})
+
+get_directory_property(CMKR_VS_STARTUP_PROJECT DIRECTORY ${PROJECT_SOURCE_DIR} DEFINITION VS_STARTUP_PROJECT)
+if(NOT CMKR_VS_STARTUP_PROJECT)
+	set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT example)
+endif()
+
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${example_SOURCES})
+

cmake/O2.cmake

@@ -0,0 +1,6 @@
+# Modify compile flags to change optimization level from O3 to O2
+if(MSVC)
+    set(CMAKE_CXX_FLAGS_RELEASE "/Od /Ob2 /DNDEBUG")
+else()
+    set(CMAKE_CXX_FLAGS_RELEASE "-O2")
+endif()

cmake/bump_version.cmake

@@ -1,78 +0,0 @@
-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/cmake.toml

@@ -0,0 +1,12 @@
+# This is a minimal example project used for testing the cmkr bootstrapping process
+
+[cmake]
+version = "3.15"
+
+[project]
+name = "example"
+version = "0.1.0"
+
+[target.example]
+type = "executable"
+sources = ["src/example.cpp"]

cmake/cmkr.cmake

@@ -1,253 +1,156 @@
-include_guard()
+include_guard()
-
+
-# Change these defaults to point to your infrastructure if desired
+# 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_REPO "https://github.com/build-cpp/cmkr" CACHE STRING "cmkr git repository" FORCE)
-set(CMKR_TAG "v0.2.33" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
+set(CMKR_TAG "archive_7cdf36f3" CACHE STRING "cmkr git tag (this needs to be available forever)" FORCE)
-set(CMKR_COMMIT_HASH "" CACHE STRING "cmkr git commit hash (optional)" FORCE)
+
-
+# Set these from the command line to customize for development/debugging purposes
-# To bootstrap/generate a cmkr project: cmake -P cmkr.cmake
+set(CMKR_EXECUTABLE "" CACHE FILEPATH "cmkr executable")
-if(CMAKE_SCRIPT_MODE_FILE)
+set(CMKR_SKIP_GENERATION OFF CACHE BOOL "skip automatic cmkr generation")
-    set(CMAKE_BINARY_DIR "${CMAKE_BINARY_DIR}/build")
+
-    set(CMAKE_CURRENT_BINARY_DIR "${CMAKE_BINARY_DIR}")
+# Disable cmkr if generation is disabled
-    file(MAKE_DIRECTORY "${CMAKE_BINARY_DIR}")
+if(CMKR_SKIP_GENERATION)
-endif()
+    message(STATUS "[cmkr] Skipping automatic cmkr generation")
-
+    macro(cmkr)
-# Set these from the command line to customize for development/debugging purposes
+    endmacro()
-set(CMKR_EXECUTABLE "" CACHE FILEPATH "cmkr executable")
+    return()
-set(CMKR_SKIP_GENERATION OFF CACHE BOOL "skip automatic cmkr generation")
+endif()
-set(CMKR_BUILD_TYPE "Debug" CACHE STRING "cmkr build configuration")
+
-mark_as_advanced(CMKR_REPO CMKR_TAG CMKR_COMMIT_HASH CMKR_EXECUTABLE CMKR_SKIP_GENERATION CMKR_BUILD_TYPE)
+# Disable cmkr if no cmake.toml file is found
-
+if(NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
-# Disable cmkr if generation is disabled
+    message(AUTHOR_WARNING "[cmkr] Not found: ${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
-if(DEFINED ENV{CI} OR CMKR_SKIP_GENERATION OR CMKR_BUILD_SKIP_GENERATION)
+    macro(cmkr)
-    message(STATUS "[cmkr] Skipping automatic cmkr generation")
+    endmacro()
-    unset(CMKR_BUILD_SKIP_GENERATION CACHE)
+    return()
-    macro(cmkr)
+endif()
-    endmacro()
+
-    return()
+# Convert a Windows native path to CMake path
-endif()
+if(CMKR_EXECUTABLE MATCHES "\\\\")
-
+    string(REPLACE "\\" "/" CMKR_EXECUTABLE_CMAKE "${CMKR_EXECUTABLE}")
-# Disable cmkr if no cmake.toml file is found
+    set(CMKR_EXECUTABLE "${CMKR_EXECUTABLE_CMAKE}" CACHE FILEPATH "" FORCE)
-if(NOT CMAKE_SCRIPT_MODE_FILE AND NOT EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
+    unset(CMKR_EXECUTABLE_CMAKE)
-    message(AUTHOR_WARNING "[cmkr] Not found: ${CMAKE_CURRENT_SOURCE_DIR}/cmake.toml")
+endif()
-    macro(cmkr)
+
-    endmacro()
+# Helper macro to execute a process (COMMAND_ERROR_IS_FATAL ANY is 3.19 and higher)
-    return()
+function(cmkr_exec)
-endif()
+    execute_process(COMMAND ${ARGV} RESULT_VARIABLE CMKR_EXEC_RESULT)
-
+    if(NOT CMKR_EXEC_RESULT EQUAL 0)
-# Convert a Windows native path to CMake path
+        message(FATAL_ERROR "cmkr_exec(${ARGV}) failed (exit code ${CMKR_EXEC_RESULT})")
-if(CMKR_EXECUTABLE MATCHES "\\\\")
+    endif()
-    string(REPLACE "\\" "/" CMKR_EXECUTABLE_CMAKE "${CMKR_EXECUTABLE}")
+endfunction()
-    set(CMKR_EXECUTABLE "${CMKR_EXECUTABLE_CMAKE}" CACHE FILEPATH "" FORCE)
+
-    unset(CMKR_EXECUTABLE_CMAKE)
+# Windows-specific hack (CMAKE_EXECUTABLE_PREFIX is not set at the moment)
-endif()
+if(WIN32)
-
+    set(CMKR_EXECUTABLE_NAME "cmkr.exe")
-# Helper macro to execute a process (COMMAND_ERROR_IS_FATAL ANY is 3.19 and higher)
+else()
-function(cmkr_exec)
+    set(CMKR_EXECUTABLE_NAME "cmkr")
-    execute_process(COMMAND ${ARGV} RESULT_VARIABLE CMKR_EXEC_RESULT)
+endif()
-    if(NOT CMKR_EXEC_RESULT EQUAL 0)
+
-        message(FATAL_ERROR "cmkr_exec(${ARGV}) failed (exit code ${CMKR_EXEC_RESULT})")
+# Use cached cmkr if found
-    endif()
+set(CMKR_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/_cmkr_${CMKR_TAG}")
-endfunction()
+set(CMKR_CACHED_EXECUTABLE "${CMKR_DIRECTORY}/bin/${CMKR_EXECUTABLE_NAME}")
-
+
-# Windows-specific hack (CMAKE_EXECUTABLE_PREFIX is not set at the moment)
+if(NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE AND CMKR_EXECUTABLE MATCHES "^${CMAKE_CURRENT_BINARY_DIR}/_cmkr")
-if(WIN32)
+    message(AUTHOR_WARNING "[cmkr] Upgrading '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
-    set(CMKR_EXECUTABLE_NAME "cmkr.exe")
+    unset(CMKR_EXECUTABLE CACHE)
-else()
+endif()
-    set(CMKR_EXECUTABLE_NAME "cmkr")
+
-endif()
+if(CMKR_EXECUTABLE AND EXISTS "${CMKR_EXECUTABLE}")
-
+    message(VERBOSE "[cmkr] Found cmkr: '${CMKR_EXECUTABLE}'")
-# Use cached cmkr if found
+elseif(CMKR_EXECUTABLE AND NOT CMKR_EXECUTABLE STREQUAL CMKR_CACHED_EXECUTABLE)
-if(DEFINED ENV{CMKR_CACHE})
+    message(FATAL_ERROR "[cmkr] '${CMKR_EXECUTABLE}' not found")
-    set(CMKR_DIRECTORY_PREFIX "$ENV{CMKR_CACHE}")
+else()
-    string(REPLACE "\\" "/" CMKR_DIRECTORY_PREFIX "${CMKR_DIRECTORY_PREFIX}")
+    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
-    if(NOT CMKR_DIRECTORY_PREFIX MATCHES "\\/$")
+    message(VERBOSE "[cmkr] Bootstrapping '${CMKR_EXECUTABLE}'")
-        set(CMKR_DIRECTORY_PREFIX "${CMKR_DIRECTORY_PREFIX}/")
+    
-    endif()
+    message(STATUS "[cmkr] Fetching cmkr...")
-    # Build in release mode for the cache
+    if(EXISTS "${CMKR_DIRECTORY}")
-    set(CMKR_BUILD_TYPE "Release")
+        cmkr_exec("${CMAKE_COMMAND}" -E rm -rf "${CMKR_DIRECTORY}")
-else()
+    endif()
-    set(CMKR_DIRECTORY_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/_cmkr_")
+    find_package(Git QUIET REQUIRED)
-endif()
+    cmkr_exec("${GIT_EXECUTABLE}"
-set(CMKR_DIRECTORY "${CMKR_DIRECTORY_PREFIX}${CMKR_TAG}")
+        clone
-set(CMKR_CACHED_EXECUTABLE "${CMKR_DIRECTORY}/bin/${CMKR_EXECUTABLE_NAME}")
+        --config advice.detachedHead=false
-
+        --branch ${CMKR_TAG}
-# Helper function to check if a string starts with a prefix
+        --depth 1
-# Cannot use MATCHES, see: https://github.com/build-cpp/cmkr/issues/61
+        ${CMKR_REPO}
-function(cmkr_startswith str prefix result)
+        "${CMKR_DIRECTORY}"
-    string(LENGTH "${prefix}" prefix_length)
+    )
-    string(LENGTH "${str}" str_length)
+    message(STATUS "[cmkr] Building cmkr...")
-    if(prefix_length LESS_EQUAL str_length)
+    cmkr_exec("${CMAKE_COMMAND}"
-        string(SUBSTRING "${str}" 0 ${prefix_length} str_prefix)
+        --no-warn-unused-cli
-        if(prefix STREQUAL str_prefix)
+        "${CMKR_DIRECTORY}"
-            set("${result}" ON PARENT_SCOPE)
+        "-B${CMKR_DIRECTORY}/build"
-            return()
+        "-DCMAKE_BUILD_TYPE=Release"
-        endif()
+        "-DCMAKE_INSTALL_PREFIX=${CMKR_DIRECTORY}"
-    endif()
+    )
-    set("${result}" OFF PARENT_SCOPE)
+    cmkr_exec("${CMAKE_COMMAND}"
-endfunction()
+        --build "${CMKR_DIRECTORY}/build"
-
+        --config Release
-# Handle upgrading logic
+        --parallel
-if(CMKR_EXECUTABLE AND NOT CMKR_CACHED_EXECUTABLE STREQUAL CMKR_EXECUTABLE)
+    )
-    cmkr_startswith("${CMKR_EXECUTABLE}" "${CMAKE_CURRENT_BINARY_DIR}/_cmkr" CMKR_STARTSWITH_BUILD)
+    cmkr_exec("${CMAKE_COMMAND}"
-    cmkr_startswith("${CMKR_EXECUTABLE}" "${CMKR_DIRECTORY_PREFIX}" CMKR_STARTSWITH_CACHE)
+        --install "${CMKR_DIRECTORY}/build"
-    if(CMKR_STARTSWITH_BUILD)
+        --config Release
-        if(DEFINED ENV{CMKR_CACHE})
+        --prefix "${CMKR_DIRECTORY}"
-            message(AUTHOR_WARNING "[cmkr] Switching to cached cmkr: '${CMKR_CACHED_EXECUTABLE}'")
+        --component cmkr
-            if(EXISTS "${CMKR_CACHED_EXECUTABLE}")
+    )
-                set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+    if(NOT EXISTS ${CMKR_EXECUTABLE})
-            else()
+        message(FATAL_ERROR "[cmkr] Failed to bootstrap '${CMKR_EXECUTABLE}'")
-                unset(CMKR_EXECUTABLE CACHE)
+    endif()
-            endif()
+    cmkr_exec("${CMKR_EXECUTABLE}" version)
-        else()
+    message(STATUS "[cmkr] Bootstrapped ${CMKR_EXECUTABLE}")
-            message(AUTHOR_WARNING "[cmkr] Upgrading '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
+endif()
-            unset(CMKR_EXECUTABLE CACHE)
+execute_process(COMMAND "${CMKR_EXECUTABLE}" version
-        endif()
+    RESULT_VARIABLE CMKR_EXEC_RESULT
-    elseif(DEFINED ENV{CMKR_CACHE} AND CMKR_STARTSWITH_CACHE)
+)
-        message(AUTHOR_WARNING "[cmkr] Upgrading cached '${CMKR_EXECUTABLE}' to '${CMKR_CACHED_EXECUTABLE}'")
+if(NOT CMKR_EXEC_RESULT EQUAL 0)
-        unset(CMKR_EXECUTABLE CACHE)
+    message(FATAL_ERROR "[cmkr] Failed to get version, try clearing the cache and rebuilding")
-    endif()
+endif()
-endif()
+
-
+# This is the macro that contains black magic
-if(CMKR_EXECUTABLE AND EXISTS "${CMKR_EXECUTABLE}")
+macro(cmkr)
-    message(VERBOSE "[cmkr] Found cmkr: '${CMKR_EXECUTABLE}'")
+    # When this macro is called from the generated file, fake some internal CMake variables
-elseif(CMKR_EXECUTABLE AND NOT CMKR_EXECUTABLE STREQUAL CMKR_CACHED_EXECUTABLE)
+    get_source_file_property(CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}" CMKR_CURRENT_LIST_FILE)
-    message(FATAL_ERROR "[cmkr] '${CMKR_EXECUTABLE}' not found")
+    if(CMKR_CURRENT_LIST_FILE)
-elseif(NOT CMKR_EXECUTABLE AND EXISTS "${CMKR_CACHED_EXECUTABLE}")
+        set(CMAKE_CURRENT_LIST_FILE "${CMKR_CURRENT_LIST_FILE}")
-    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+        get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
-    message(STATUS "[cmkr] Found cached cmkr: '${CMKR_EXECUTABLE}'")
+    endif()
-else()
+
-    set(CMKR_EXECUTABLE "${CMKR_CACHED_EXECUTABLE}" CACHE FILEPATH "Full path to cmkr executable" FORCE)
+    # File-based include guard (include_guard is not documented to work)
-    message(VERBOSE "[cmkr] Bootstrapping '${CMKR_EXECUTABLE}'")
+    get_source_file_property(CMKR_INCLUDE_GUARD "${CMAKE_CURRENT_LIST_FILE}" CMKR_INCLUDE_GUARD)
-
+    if(NOT CMKR_INCLUDE_GUARD)
-    message(STATUS "[cmkr] Fetching cmkr...")
+        set_source_files_properties("${CMAKE_CURRENT_LIST_FILE}" PROPERTIES CMKR_INCLUDE_GUARD TRUE)
-    if(EXISTS "${CMKR_DIRECTORY}")
+
-        cmkr_exec("${CMAKE_COMMAND}" -E rm -rf "${CMKR_DIRECTORY}")
+        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_PRE)
-    endif()
+
-    find_package(Git QUIET REQUIRED)
+        # Generate CMakeLists.txt
-    cmkr_exec("${GIT_EXECUTABLE}"
+        cmkr_exec("${CMKR_EXECUTABLE}" gen
-        clone
+            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        --config advice.detachedHead=false
+        )
-        --branch ${CMKR_TAG}
+
-        --depth 1
+        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_POST)
-        ${CMKR_REPO}
+
-        "${CMKR_DIRECTORY}"
+        if(NOT CMKR_LIST_FILE_SHA256_PRE STREQUAL CMKR_LIST_FILE_SHA256_POST)
-    )
+            # Copy the now-generated CMakeLists.txt to CMakerLists.txt
-    if(CMKR_COMMIT_HASH)
+            # This is done because you cannot include() a file you are currently in
-        execute_process(
+            set(CMKR_TEMP_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMakerLists.txt")
-            COMMAND "${GIT_EXECUTABLE}" checkout -q "${CMKR_COMMIT_HASH}"
+            configure_file(CMakeLists.txt "${CMKR_TEMP_FILE}" COPYONLY)
-            RESULT_VARIABLE CMKR_EXEC_RESULT
+            
-            WORKING_DIRECTORY "${CMKR_DIRECTORY}"
+            # Add the macro required for the hack at the start of the cmkr macro
-        )
+            set_source_files_properties("${CMKR_TEMP_FILE}" PROPERTIES
-        if(NOT CMKR_EXEC_RESULT EQUAL 0)
+                CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}"
-            message(FATAL_ERROR "Tag '${CMKR_TAG}' hash is not '${CMKR_COMMIT_HASH}'")
+            )
-        endif()
+            
-    endif()
+            # 'Execute' the newly-generated CMakeLists.txt
-    message(STATUS "[cmkr] Building cmkr (using system compiler)...")
+            include("${CMKR_TEMP_FILE}")
-    cmkr_exec("${CMAKE_COMMAND}"
+            
-        --no-warn-unused-cli
+            # Delete the generated file
-        "${CMKR_DIRECTORY}"
+            file(REMOVE "${CMKR_TEMP_FILE}")
-        "-B${CMKR_DIRECTORY}/build"
+            
-        "-DCMAKE_BUILD_TYPE=${CMKR_BUILD_TYPE}"
+            # Do not execute the rest of the original CMakeLists.txt
-        "-DCMAKE_UNITY_BUILD=ON"
+            return()
-        "-DCMAKE_INSTALL_PREFIX=${CMKR_DIRECTORY}"
+        endif()
-        "-DCMKR_GENERATE_DOCUMENTATION=OFF"
+        # Resume executing the unmodified CMakeLists.txt
-    )
+    endif()
-    cmkr_exec("${CMAKE_COMMAND}"
+endmacro()
-        --build "${CMKR_DIRECTORY}/build"
-        --config "${CMKR_BUILD_TYPE}"
-        --parallel
-    )
-    cmkr_exec("${CMAKE_COMMAND}"
-        --install "${CMKR_DIRECTORY}/build"
-        --config "${CMKR_BUILD_TYPE}"
-        --prefix "${CMKR_DIRECTORY}"
-        --component cmkr
-    )
-    if(NOT EXISTS ${CMKR_EXECUTABLE})
-        message(FATAL_ERROR "[cmkr] Failed to bootstrap '${CMKR_EXECUTABLE}'")
-    endif()
-    cmkr_exec("${CMKR_EXECUTABLE}" version)
-    message(STATUS "[cmkr] Bootstrapped ${CMKR_EXECUTABLE}")
-endif()
-execute_process(COMMAND "${CMKR_EXECUTABLE}" version
-    RESULT_VARIABLE CMKR_EXEC_RESULT
-)
-if(NOT CMKR_EXEC_RESULT EQUAL 0)
-    message(FATAL_ERROR "[cmkr] Failed to get version, try clearing the cache and rebuilding")
-endif()
-
-# Use cmkr.cmake as a script
-if(CMAKE_SCRIPT_MODE_FILE)
-    if(NOT EXISTS "${CMAKE_SOURCE_DIR}/cmake.toml")
-        execute_process(COMMAND "${CMKR_EXECUTABLE}" init
-            RESULT_VARIABLE CMKR_EXEC_RESULT
-        )
-        if(NOT CMKR_EXEC_RESULT EQUAL 0)
-            message(FATAL_ERROR "[cmkr] Failed to bootstrap cmkr project. Please report an issue: https://github.com/build-cpp/cmkr/issues/new")
-        else()
-            message(STATUS "[cmkr] Modify cmake.toml and then configure using: cmake -B build")
-        endif()
-    else()
-        execute_process(COMMAND "${CMKR_EXECUTABLE}" gen
-            RESULT_VARIABLE CMKR_EXEC_RESULT
-        )
-        if(NOT CMKR_EXEC_RESULT EQUAL 0)
-            message(FATAL_ERROR "[cmkr] Failed to generate project.")
-        else()
-            message(STATUS "[cmkr] Configure using: cmake -B build")
-        endif()
-    endif()
-endif()
-
-# This is the macro that contains black magic
-macro(cmkr)
-    # When this macro is called from the generated file, fake some internal CMake variables
-    get_source_file_property(CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}" CMKR_CURRENT_LIST_FILE)
-    if(CMKR_CURRENT_LIST_FILE)
-        set(CMAKE_CURRENT_LIST_FILE "${CMKR_CURRENT_LIST_FILE}")
-        get_filename_component(CMAKE_CURRENT_LIST_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
-    endif()
-
-    # File-based include guard (include_guard is not documented to work)
-    get_source_file_property(CMKR_INCLUDE_GUARD "${CMAKE_CURRENT_LIST_FILE}" CMKR_INCLUDE_GUARD)
-    if(NOT CMKR_INCLUDE_GUARD)
-        set_source_files_properties("${CMAKE_CURRENT_LIST_FILE}" PROPERTIES CMKR_INCLUDE_GUARD TRUE)
-
-        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_PRE)
-
-        # Generate CMakeLists.txt
-        cmkr_exec("${CMKR_EXECUTABLE}" gen
-            WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-        )
-
-        file(SHA256 "${CMAKE_CURRENT_LIST_FILE}" CMKR_LIST_FILE_SHA256_POST)
-
-        # Delete the temporary file if it was left for some reason
-        set(CMKR_TEMP_FILE "${CMAKE_CURRENT_SOURCE_DIR}/CMakerLists.txt")
-        if(EXISTS "${CMKR_TEMP_FILE}")
-            file(REMOVE "${CMKR_TEMP_FILE}")
-        endif()
-
-        if(NOT CMKR_LIST_FILE_SHA256_PRE STREQUAL CMKR_LIST_FILE_SHA256_POST)
-            # Copy the now-generated CMakeLists.txt to CMakerLists.txt
-            # This is done because you cannot include() a file you are currently in
-            configure_file(CMakeLists.txt "${CMKR_TEMP_FILE}" COPYONLY)
-
-            # Add the macro required for the hack at the start of the cmkr macro
-            set_source_files_properties("${CMKR_TEMP_FILE}" PROPERTIES
-                CMKR_CURRENT_LIST_FILE "${CMAKE_CURRENT_LIST_FILE}"
-            )
-
-            # 'Execute' the newly-generated CMakeLists.txt
-            include("${CMKR_TEMP_FILE}")
-
-            # Delete the generated file
-            file(REMOVE "${CMKR_TEMP_FILE}")
-
-            # Do not execute the rest of the original CMakeLists.txt
-            return()
-        endif()
-        # Resume executing the unmodified CMakeLists.txt
-    endif()
-endmacro()

cmake/custom_targets.cmake

@@ -1,18 +0,0 @@
-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()

cmake/example.md.in

@@ -1,20 +0,0 @@
----
-# Automatically generated from tests/@EXAMPLE_PERMALINK@/cmake.toml - DO NOT EDIT
-layout: default
-title: @EXAMPLE_TITLE@
-permalink: /examples/@EXAMPLE_PERMALINK@
-parent: Examples
-nav_order: @EXAMPLE_INDEX@
----
-
-# @EXAMPLE_TITLE@
-
-@EXAMPLE_HEADER@
-
-```toml
-@EXAMPLE_TOML@
-```
-
-@EXAMPLE_FOOTER@
-
-<sup><sub>This page was automatically generated from [tests/@EXAMPLE_PERMALINK@/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/@EXAMPLE_PERMALINK@/cmake.toml).</sub></sup>

cmake/generate_documentation.cmake

@@ -1,76 +0,0 @@
-option(CMKR_GENERATE_DOCUMENTATION "Generate cmkr documentation" ${CMKR_ROOT_PROJECT})
-
-function(generate_documentation)
-    if(CMKR_GENERATE_DOCUMENTATION)
-        message(STATUS "[cmkr] Generating documentation...")
-
-        # Extract the order of the tests
-        set(CMKR_TESTS "")
-        file(READ "${PROJECT_SOURCE_DIR}/tests/cmake.toml" tests_toml NO_HEX_CONVERSION)
-        string(REGEX MATCHALL "working-directory = \"([^\"]+)\"" tests_match "${tests_toml}")
-        foreach(match ${tests_match})
-            if(match MATCHES "working-directory = \"([^\"]+)\"")
-                list(APPEND CMKR_TESTS "${CMAKE_MATCH_1}")
-            else()
-                message(FATAL_ERROR "This should not happen (wrong regex?)")
-            endif()
-        endforeach()
-
-        # Delete previously generated examples
-        set(example_folder "${PROJECT_SOURCE_DIR}/docs/examples")
-        file(GLOB example_files "${example_folder}/*.md")
-        list(REMOVE_ITEM example_files "${example_folder}/index.md")
-        if(example_files)
-            file(REMOVE ${example_files})
-        endif()
-
-        message(DEBUG "[cmkr] Test directories: ${CMKR_TESTS}")
-        set(test_index 0)
-        foreach(test_dir ${CMKR_TESTS})
-            set(test_name "${test_dir}")
-            set(test_dir "${PROJECT_SOURCE_DIR}/tests/${test_dir}")
-            set(test_toml "${test_dir}/cmake.toml")
-            if(IS_DIRECTORY "${test_dir}" AND EXISTS "${test_toml}")
-                message(DEBUG "[cmkr] Generating documentation for: ${test_toml} (index: ${test_index})")
-
-                # Set template variables
-                set(EXAMPLE_PERMALINK "${test_name}")
-                set(EXAMPLE_INDEX ${test_index})
-                math(EXPR test_index "${test_index}+1")
-
-                # 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)
-                string(STRIP "${EXAMPLE_TOML}" EXAMPLE_TOML)
-
-                # 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()
-                    message(DEBUG "[cmkr] Skipping documentation generation for ${test_name} because description is missing")
-                endif()
-            endif()
-        endforeach()
-    endif()
-endfunction()

cmake/generate_resources.cmake

@@ -1,24 +0,0 @@
-# Enumerates the target sources and automatically generates include/resources/${RESOURCE_NAME}.h from all .cmake files
-function(generate_resources target)
-    get_property(TARGET_SOURCES
-        TARGET ${target}
-        PROPERTY SOURCES
-    )
-    foreach(SOURCE ${TARGET_SOURCES})
-        get_filename_component(RESOURCE_NAME "${SOURCE}" NAME_WE)
-        set(RESOURCE_HEADER "include/resources/${RESOURCE_NAME}.hpp")
-
-        if(SOURCE MATCHES ".cmake$")
-            # Add configure-time dependency on the source file
-            configure_file("${SOURCE}" "${RESOURCE_HEADER}" COPYONLY)
-            # Generate the actual resource into the header
-            file(READ "${SOURCE}" RESOURCE_CONTENTS)
-            configure_file("${PROJECT_SOURCE_DIR}/cmake/resource.hpp.in" "${RESOURCE_HEADER}" @ONLY)
-            message(STATUS "[cmkr] Generated ${RESOURCE_HEADER}")
-        elseif(SOURCE MATCHES ".in$")
-            configure_file("${SOURCE}" "${RESOURCE_HEADER}" @ONLY)
-            message(STATUS "[cmkr] Generated ${RESOURCE_HEADER}")
-        endif()
-    endforeach()
-    target_include_directories(${target} PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/include")
-endfunction()

cmake/replace_tag.cmake

@@ -1,27 +0,0 @@
-cmake_minimum_required(VERSION 3.20)
-
-find_package(Git REQUIRED)
-
-execute_process(COMMAND
-    "${GIT_EXECUTABLE}" name-rev --tags --name-only HEAD
-    OUTPUT_VARIABLE GIT_TAG
-)
-
-string(FIND "${GIT_TAG}" "\n" NEWLINE_POS)
-string(SUBSTRING "${GIT_TAG}" 0 ${NEWLINE_POS} GIT_TAG)
-string(STRIP "${GIT_TAG}" GIT_TAG)
-
-if("${GIT_TAG}" STREQUAL "")
-    message(FATAL_ERROR "Failed to retrieve git tag!")
-endif()
-
-message(STATUS "CMKR_TAG: '${GIT_TAG}'")
-
-file(READ "cmake/cmkr.cmake" CMKR_CMAKE)
-string(REGEX REPLACE "CMKR_TAG \"[^\"]+\"" "CMKR_TAG \"${GIT_TAG}\"" CMKR_CMAKE "${CMKR_CMAKE}")
-file(CONFIGURE
-    OUTPUT "cmake/cmkr.cmake"
-    CONTENT "${CMKR_CMAKE}"
-    @ONLY
-    NEWLINE_STYLE LF
-)

cmake/resource.hpp.in

@@ -1,7 +0,0 @@
-namespace cmkr {
-namespace resources {
-
-static const char* @RESOURCE_NAME@ = R"RESOURCE(@RESOURCE_CONTENTS@)RESOURCE";
-
-}
-}

cmake/src/example.cpp

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

cmake/version.hpp.in

@@ -1,3 +0,0 @@
-#pragma once
-
-#define CMKR_VERSION "@PROJECT_VERSION@"

docs/.gitignore

@@ -1,3 +0,0 @@
-_site/
-.jekyll-metadata
-assets/

docs/404.html

@@ -1,25 +0,0 @@
----
-permalink: /404.html
-layout: default
----
-
-<style type="text/css" media="screen">
-  .container {
-    margin: 10px auto;
-    max-width: 600px;
-    text-align: center;
-  }
-  h1 {
-    margin: 30px 0;
-    font-size: 4em;
-    line-height: 1;
-    letter-spacing: -1px;
-  }
-</style>
-
-<div class="container">
-  <h1>404</h1>
-
-  <p><strong>Page not found :(</strong></p>
-  <p>The requested page could not be found.</p>
-</div>

docs/CNAME

@@ -1 +0,0 @@
-cmkr.build

docs/Gemfile

@@ -1,16 +0,0 @@
-source "https://rubygems.org"
-gem "minima", "~> 2.5"
-gem "github-pages", group: :jekyll_plugins
-
-gem "jekyll-remote-theme"
-gem "jekyll-sitemap", "~> 1.4.0"
-
-platforms :mingw, :x64_mingw, :mswin, :jruby do
-  gem "tzinfo", "~> 1.2"
-  gem "tzinfo-data"
-end
-
-gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin]
-gem "just-the-docs"
-
-gem "webrick", "~> 1.7"

docs/Gemfile.lock

@@ -1,283 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activesupport (6.0.3.6)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 5.0)
-    coffee-script (2.4.1)
-      coffee-script-source
-      execjs
-    coffee-script-source (1.11.1)
-    colorator (1.1.0)
-    commonmarker (0.17.13)
-      ruby-enum (~> 0.5)
-    concurrent-ruby (1.1.8)
-    dnsruby (1.61.5)
-      simpleidn (~> 0.1)
-    em-websocket (0.5.2)
-      eventmachine (>= 0.12.9)
-      http_parser.rb (~> 0.6.0)
-    ethon (0.14.0)
-      ffi (>= 1.15.0)
-    eventmachine (1.2.7)
-    execjs (2.7.0)
-    faraday (1.4.1)
-      faraday-excon (~> 1.1)
-      faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.1)
-      multipart-post (>= 1.2, < 3)
-      ruby2_keywords (>= 0.0.4)
-    faraday-excon (1.1.0)
-    faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.1.0)
-    ffi (1.15.0)
-    forwardable-extended (2.6.0)
-    gemoji (3.0.1)
-    github-pages (214)
-      github-pages-health-check (= 1.17.0)
-      jekyll (= 3.9.0)
-      jekyll-avatar (= 0.7.0)
-      jekyll-coffeescript (= 1.1.1)
-      jekyll-commonmark-ghpages (= 0.1.6)
-      jekyll-default-layout (= 0.1.4)
-      jekyll-feed (= 0.15.1)
-      jekyll-gist (= 1.5.0)
-      jekyll-github-metadata (= 2.13.0)
-      jekyll-mentions (= 1.6.0)
-      jekyll-optional-front-matter (= 0.3.2)
-      jekyll-paginate (= 1.1.0)
-      jekyll-readme-index (= 0.3.0)
-      jekyll-redirect-from (= 0.16.0)
-      jekyll-relative-links (= 0.6.1)
-      jekyll-remote-theme (= 0.4.3)
-      jekyll-sass-converter (= 1.5.2)
-      jekyll-seo-tag (= 2.7.1)
-      jekyll-sitemap (= 1.4.0)
-      jekyll-swiss (= 1.0.0)
-      jekyll-theme-architect (= 0.1.1)
-      jekyll-theme-cayman (= 0.1.1)
-      jekyll-theme-dinky (= 0.1.1)
-      jekyll-theme-hacker (= 0.1.2)
-      jekyll-theme-leap-day (= 0.1.1)
-      jekyll-theme-merlot (= 0.1.1)
-      jekyll-theme-midnight (= 0.1.1)
-      jekyll-theme-minimal (= 0.1.1)
-      jekyll-theme-modernist (= 0.1.1)
-      jekyll-theme-primer (= 0.5.4)
-      jekyll-theme-slate (= 0.1.1)
-      jekyll-theme-tactile (= 0.1.1)
-      jekyll-theme-time-machine (= 0.1.1)
-      jekyll-titles-from-headings (= 0.5.3)
-      jemoji (= 0.12.0)
-      kramdown (= 2.3.1)
-      kramdown-parser-gfm (= 1.1.0)
-      liquid (= 4.0.3)
-      mercenary (~> 0.3)
-      minima (= 2.5.1)
-      nokogiri (>= 1.10.4, < 2.0)
-      rouge (= 3.26.0)
-      terminal-table (~> 1.4)
-    github-pages-health-check (1.17.0)
-      addressable (~> 2.3)
-      dnsruby (~> 1.60)
-      octokit (~> 4.0)
-      public_suffix (>= 2.0.2, < 5.0)
-      typhoeus (~> 1.3)
-    html-pipeline (2.14.0)
-      activesupport (>= 2)
-      nokogiri (>= 1.4)
-    http_parser.rb (0.6.0)
-    i18n (0.9.5)
-      concurrent-ruby (~> 1.0)
-    jekyll (3.9.0)
-      addressable (~> 2.4)
-      colorator (~> 1.0)
-      em-websocket (~> 0.5)
-      i18n (~> 0.7)
-      jekyll-sass-converter (~> 1.0)
-      jekyll-watch (~> 2.0)
-      kramdown (>= 1.17, < 3)
-      liquid (~> 4.0)
-      mercenary (~> 0.3.3)
-      pathutil (~> 0.9)
-      rouge (>= 1.7, < 4)
-      safe_yaml (~> 1.0)
-    jekyll-avatar (0.7.0)
-      jekyll (>= 3.0, < 5.0)
-    jekyll-coffeescript (1.1.1)
-      coffee-script (~> 2.2)
-      coffee-script-source (~> 1.11.1)
-    jekyll-commonmark (1.3.1)
-      commonmarker (~> 0.14)
-      jekyll (>= 3.7, < 5.0)
-    jekyll-commonmark-ghpages (0.1.6)
-      commonmarker (~> 0.17.6)
-      jekyll-commonmark (~> 1.2)
-      rouge (>= 2.0, < 4.0)
-    jekyll-default-layout (0.1.4)
-      jekyll (~> 3.0)
-    jekyll-feed (0.15.1)
-      jekyll (>= 3.7, < 5.0)
-    jekyll-gist (1.5.0)
-      octokit (~> 4.2)
-    jekyll-github-metadata (2.13.0)
-      jekyll (>= 3.4, < 5.0)
-      octokit (~> 4.0, != 4.4.0)
-    jekyll-mentions (1.6.0)
-      html-pipeline (~> 2.3)
-      jekyll (>= 3.7, < 5.0)
-    jekyll-optional-front-matter (0.3.2)
-      jekyll (>= 3.0, < 5.0)
-    jekyll-paginate (1.1.0)
-    jekyll-readme-index (0.3.0)
-      jekyll (>= 3.0, < 5.0)
-    jekyll-redirect-from (0.16.0)
-      jekyll (>= 3.3, < 5.0)
-    jekyll-relative-links (0.6.1)
-      jekyll (>= 3.3, < 5.0)
-    jekyll-remote-theme (0.4.3)
-      addressable (~> 2.0)
-      jekyll (>= 3.5, < 5.0)
-      jekyll-sass-converter (>= 1.0, <= 3.0.0, != 2.0.0)
-      rubyzip (>= 1.3.0, < 3.0)
-    jekyll-sass-converter (1.5.2)
-      sass (~> 3.4)
-    jekyll-seo-tag (2.7.1)
-      jekyll (>= 3.8, < 5.0)
-    jekyll-sitemap (1.4.0)
-      jekyll (>= 3.7, < 5.0)
-    jekyll-swiss (1.0.0)
-    jekyll-theme-architect (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-cayman (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-dinky (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-hacker (0.1.2)
-      jekyll (> 3.5, < 5.0)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-leap-day (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-merlot (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-midnight (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-minimal (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-modernist (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-primer (0.5.4)
-      jekyll (> 3.5, < 5.0)
-      jekyll-github-metadata (~> 2.9)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-slate (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-tactile (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-theme-time-machine (0.1.1)
-      jekyll (~> 3.5)
-      jekyll-seo-tag (~> 2.0)
-    jekyll-titles-from-headings (0.5.3)
-      jekyll (>= 3.3, < 5.0)
-    jekyll-watch (2.2.1)
-      listen (~> 3.0)
-    jemoji (0.12.0)
-      gemoji (~> 3.0)
-      html-pipeline (~> 2.2)
-      jekyll (>= 3.0, < 5.0)
-    just-the-docs (0.3.3)
-      jekyll (>= 3.8.5)
-      jekyll-seo-tag (~> 2.0)
-      rake (>= 12.3.1, < 13.1.0)
-    kramdown (2.3.1)
-      rexml
-    kramdown-parser-gfm (1.1.0)
-      kramdown (~> 2.0)
-    liquid (4.0.3)
-    listen (3.5.1)
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
-    mercenary (0.3.6)
-    mini_portile2 (2.5.1)
-    minima (2.5.1)
-      jekyll (>= 3.5, < 5.0)
-      jekyll-feed (~> 0.9)
-      jekyll-seo-tag (~> 2.1)
-    minitest (5.14.4)
-    multipart-post (2.1.1)
-    nokogiri (1.11.3)
-      mini_portile2 (~> 2.5.0)
-      racc (~> 1.4)
-    octokit (4.21.0)
-      faraday (>= 0.9)
-      sawyer (~> 0.8.0, >= 0.5.3)
-    pathutil (0.16.2)
-      forwardable-extended (~> 2.6)
-    public_suffix (4.0.6)
-    racc (1.5.2)
-    rake (13.0.3)
-    rb-fsevent (0.10.4)
-    rb-inotify (0.10.1)
-      ffi (~> 1.0)
-    rexml (3.2.5)
-    rouge (3.26.0)
-    ruby-enum (0.9.0)
-      i18n
-    ruby2_keywords (0.0.4)
-    rubyzip (2.3.0)
-    safe_yaml (1.0.5)
-    sass (3.7.4)
-      sass-listen (~> 4.0.0)
-    sass-listen (4.0.0)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
-    sawyer (0.8.2)
-      addressable (>= 2.3.5)
-      faraday (> 0.8, < 2.0)
-    simpleidn (0.2.1)
-      unf (~> 0.1.4)
-    terminal-table (1.8.0)
-      unicode-display_width (~> 1.1, >= 1.1.1)
-    thread_safe (0.3.6)
-    typhoeus (1.4.0)
-      ethon (>= 0.9.0)
-    tzinfo (1.2.9)
-      thread_safe (~> 0.1)
-    unf (0.1.4)
-      unf_ext
-    unf_ext (0.0.7.7)
-    unicode-display_width (1.7.0)
-    webrick (1.7.0)
-    zeitwerk (2.4.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  github-pages
-  jekyll-remote-theme
-  jekyll-sitemap (~> 1.4.0)
-  just-the-docs
-  minima (~> 2.5)
-  tzinfo (~> 1.2)
-  tzinfo-data
-  wdm (~> 0.1.1)
-  webrick (~> 1.7)
-
-BUNDLED WITH
-   2.2.26

docs/_config.yml

@@ -1,42 +0,0 @@
-title: cmkr
-
-plugins:
-  - jekyll-remote-theme
-  - jekyll-sitemap
-
-# Automatically deduce dark theme preference https://github.com/pmarsceill/just-the-docs/pull/464
-remote_theme: build-cpp/just-the-docs@light-switch
-search_enabled: true
-color_scheme: light-or-dark
-heading_anchors: true
-aux_links:
-  "GitHub":
-    - "https://github.com/build-cpp/cmkr"
-aux_links_new_tab: true
-
-gh_edit_link: true
-gh_edit_link_text: "Edit this page on GitHub."
-gh_edit_repository: "https://github.com/build-cpp/cmkr"
-gh_edit_branch: "main"
-gh_edit_view_mode: "edit"
-gh_edit_source: docs
-
-ga_tracking: G-DY172KY7Z9
-
-production_url : https://cmkr.build
-footer_content: |
-  <script src="https://giscus.app/client.js"
-          data-repo="build-cpp/cmkr"
-          data-repo-id="MDEwOlJlcG9zaXRvcnkyOTQwMDc3MzY="
-          data-category="Documentation"
-          data-category-id="DIC_kwDOEYYzuM4CTXeA"
-          data-mapping="pathname"
-          data-strict="1"
-          data-reactions-enabled="1"
-          data-emit-metadata="0"
-          data-input-position="top"
-          data-theme="preferred_color_scheme"
-          data-lang="en"
-          crossorigin="anonymous"
-          async>
-  </script>

docs/basics.md

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

docs/cmake-toml.md

@@ -1,306 +0,0 @@
----
-layout: page
-title: Reference
-permalink: /cmake-toml/
-nav_order: 3
----
-
-# Reference
-
-This page is a reference for the options in the `cmake.toml` file. If you think anything is missing or unclear, please [edit this page](https://github.com/build-cpp/cmkr/edit/main/docs/cmake-toml.md) or open an [issue](https://github.com/build-cpp/cmkr/issues).
-
-This is a reference page. Check out the [examples](/examples) and the [cmkr topic](https://github.com/topics/cmkr) as well.
-{:.info}
-
-## CMake configuration
-
-```toml
-[cmake]
-version = "3.15"
-cmkr-include = "cmkr.cmake"
-```
-
-## Project configuration
-
-```toml
-[project]
-name = "myproject"
-version = "1.0.0"
-description = "Description of the project"
-languages = ["C", "CXX"]
-msvc-runtime = "" # dynamic (implicit default), static
-cmake-before = """
-message(STATUS "CMake injected before the project() call")
-"""
-cmake-after = """
-message(STATUS "CMake injected after the project() call")
-"""
-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 named conditions and use them in any `condition` field:
-
-```toml
-[conditions]
-ptr64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
-ptr32 = "CMAKE_SIZEOF_VOID_P EQUAL 4"
-```
-
-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:
-
-```toml
-[target]
-type = "executable"
-sources = ["src/main.cpp"]
-ptr64.sources = ["src/ptr64_only.cpp"]
-```
-
-Instead of a named condition you can also specify a [CMake expression](https://cmake.org/cmake/help/latest/command/if.html#condition-syntax) in quotes. Instances of `$<name>` are replaced with the corresponding condition. For example: `"CONDITIONS_BUILD_TESTS AND $<linux>"` becomes `CONDITIONS_BUILD_TESTS AND (CMAKE_SYSTEM_NAME MATCHES "Linux")` in the final `CMakeLists.txt` file.
-
-### Predefined conditions
-
-The following conditions are predefined (you can override them if you desire):
-
-```toml
-[conditions]
-windows = "WIN32"
-macos = "CMAKE_SYSTEM_NAME MATCHES \"Darwin\""
-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\""
-msvc = "MSVC"
-clang = "(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\") OR (CMAKE_C_COMPILER_ID MATCHES \"Clang\" AND NOT CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\")"
-clang-cl = "(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\") OR (CMAKE_C_COMPILER_ID MATCHES \"Clang\" AND CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES \"^MSVC$\")"
-clang-any = "CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" OR CMAKE_C_COMPILER_ID MATCHES \"Clang\""
-root = "CMKR_ROOT_PROJECT"
-x64 = "CMAKE_SIZEOF_VOID_P EQUAL 8"
-x32 = "CMAKE_SIZEOF_VOID_P EQUAL 4"
-android = "ANDROID"
-apple = "APPLE"
-bsd = "BSD"
-cygwin = "CYGWIN"
-ios = "IOS"
-xcode = "XCODE"
-wince = "WINCE"
-```
-
-## Subdirectories
-
-```toml
-[subdir.mysubdir]
-condition = "mycondition"
-cmake-before = """
-message(STATUS "CMake injected before the add_subdirectory() call"
-"""
-cmake-after = """
-message(STATUS "CMake injected after the add_subdirectory() call")
-"""
-include-before = ["cmake/before-subdir.cmake"]
-include-after = ["cmake/after-subdir.cmake"]
-```
-
-## Options
-
-```toml
-[options]
-MYPROJECT_BUILD_TESTS = false
-MYPROJECT_SPECIAL_OPTION = { value = true, help = "Docstring for this option." }
-MYPROJECT_BUILD_EXAMPLES = "root"
-```
-
-Options correspond to [CMake cache variables](https://cmake.org/cmake/help/book/mastering-cmake/chapter/CMake%20Cache.html) that can be used to customize your project at configure-time. You can configure with `cmake -DMYPROJECT_BUILD_TESTS=ON` to enable the option. Every option automatically gets a corresponding [condition](#conditions). Additionally, a normalized condition is created based on the `[project].name` (i.e. `MYPROJECT_BUILD_TESTS` becomes `build-tests`).
-
-The special value `root` can be used to set the option to `true` if the project is compiled as the root project (it will be `false` if someone is including your project via `[fetch-content]` or `[subdir]`).
-
-## Variables
-
-```toml
-[variables]
-MYBOOL = true
-MYSTRING = "hello"
-```
-
-Variables emit a [`set`](https://cmake.org/cmake/help/latest/command/set.html) and can be used to configure subprojects and packages.
-
-## Vcpkg
-
-```toml
-[vcpkg]
-version = "2024.03.25"
-url = "https://github.com/microsoft/vcpkg/archive/refs/tags/2024.03.25.tar.gz"
-packages = ["fmt", "zlib"]
-```
-
-The vcpkg `version` will automatically generate the `url` from the [official repository](https://github.com/microsoft/vcpkg/releases). For a custom registry you can specify your own `url` (and omit the `version`). You can browse available packages on [vcpkg.io](https://vcpkg.io/en/packages.html).
-
-To specify package features you can use the following syntax: `imgui[docking-experimental,freetype,sdl2-binding,opengl3-binding]`.
-
-## Packages
-
-```toml
-[find-package.mypackage]
-condition = "mycondition"
-version = "1.0"
-required = true
-config = true
-components = ["mycomponent"]
-```
-
-## FetchContent
-
-**Note**: The `[fetch-content]` feature is unpolished and will likely change in a future release.
-
-```toml
-[fetch-content.gitcontent]
-condition = "mycondition"
-git = "https://github.com/myuser/gitcontent"
-tag = "v0.1"
-shallow = false
-system = false
-subdir = ""
-
-[fetch-content.svncontent]
-condition = "mycondition"
-svn = "https://svn-host.com/url"
-rev = "svn_rev"
-
-[fetch-content.urlcontent]
-condition = "mycondition"
-url = "https://content-host.com/urlcontent.zip"
-# These are equivalent, supported algorithms:
-# md5, sha1, sha224, sha256, sha384, sha512, sha3_224, sha3_256, sha3_384, sha3_512
-hash = "SHA1 502a4e25b8b209889c99c7fa0732102682c2e4ff"
-sha1 = "502a4e25b8b209889c99c7fa0732102682c2e4ff"
-```
-
-Table keys that match CMake variable names (`[A-Z_]+`) will be passed to the [`FetchContent_Declare`](https://cmake.org/cmake/help/latest/module/FetchContent.html#command:fetchcontent_declare) command.
-
-## Targets
-
-```toml
-[target.mytarget]
-condition = "mycondition"
-alias = "mytarget::mytarget"
-type = "static" # executable, shared (DLL), static, interface, object, library, custom
-headers = ["src/mytarget.h"]
-sources = ["src/mytarget.cpp"]
-msvc-runtime = "" # dynamic (implicit default), static
-
-# The keys below match the target_xxx CMake commands
-# Keys prefixed with private- will get PRIVATE visibility
-compile-definitions = [""]
-private-compile-definitions = [""]
-compile-features = [""]
-private-compile-features = [""]
-compile-options = [""]
-private-compile-options = [""]
-include-directories = [""]
-private-include-directories = [""]
-link-directories = [""]
-private-link-directories = [""]
-link-libraries = [""]
-private-link-libraries = [""]
-link-options = [""]
-private-link-options = [""]
-precompile-headers = [""]
-private-precompile-headers = [""]
-
-cmake-before = """
-message(STATUS "CMake injected before the target")
-"""
-cmake-after = """
-message(STATUS "CMake injected after the target")
-"""
-include-before = "cmake/target-before.cmake"
-include-after = "cmake/target-after.cmake"
-
-# See https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#properties-on-targets for a list of target properties
-[target.mytarget.properties]
-CXX_STANDARD = 17
-CXX_STANDARD_REQUIRED = true
-FOLDER = "MyFolder"
-```
-
-## Templates
-
-To avoid repeating yourself you can create your own target type and use it in your targets:
-
-```toml
-[template.example]
-condition = "MYPROJECT_BUILD_EXAMPLES"
-type = "executable"
-link-libraries = ["myproject::mylib"]
-add-function = ""
-pass-sources = false
-
-# Properties from the template are merged with the ones here
-[target.myexample]
-type = "example"
-sources = ["src/myexample.cpp"]
-```
-
-The properties declared on a `template` are the same as the ones you use for targets. The only exceptions are:
-
-- `add-function`: Specifies a custom add function. Projects like [pybind11](https://pybind11.readthedocs.io/en/stable/cmake/index.html#new-findpython-mode) have their own `add_xxx` function, which you can specify here.
-- `pass-sources`: Pass sources directly to the add function instead of using `target_sources`.
-
-## Tests and installation (unfinished)
-
-**Note**: The `[[test]]` and `[[install]]` are unfinished features and will likely change in a future release.
-
-```toml
-# You can declare as many as you want like this, but the name has to be unique
-[[test]]
-condition = "mycondition"
-name = "mytest"
-command = "$<TARGET_FILE:mytest>"
-arguments = ["arg1", "arg2"]
-configurations = ["Debug", "Release", "RelWithDebInfo", "MinSizeRelease"]
-working-directory = "mytest-dir"
-```
-
-```toml
-[[install]]
-condition = "mycondition"
-targets = ["mytarget", "mytest"]
-destination = ["bin"]
-component = "mycomponent"
-files = ["content/my.png"]
-dirs = ["include"]
-configs = ["Release", "Debug"]
-optional = false
-```

docs/examples/basic.md

@@ -1,26 +0,0 @@
----
-# Automatically generated from tests/basic/cmake.toml - DO NOT EDIT
-layout: default
-title: Minimal example
-permalink: /examples/basic
-parent: Examples
-nav_order: 0
----
-
-# Minimal example
-
-A minimal `cmake.toml` project:
-
-```toml
-[project]
-name = "basic"
-description = "Minimal example"
-
-[target.basic]
-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)`.
-
-<sup><sub>This page was automatically generated from [tests/basic/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/basic/cmake.toml).</sub></sup>

docs/examples/compile-options.md

@@ -1,31 +0,0 @@
----
-# 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/cxx-standard.md

@@ -1,27 +0,0 @@
----
-# Automatically generated from tests/cxx-standard/cmake.toml - DO NOT EDIT
-layout: default
-title: Changing C++ standard
-permalink: /examples/cxx-standard
-parent: Examples
-nav_order: 5
----
-
-# Changing C++ standard
-
-Require a C++11 compiler for the target `example`.
-
-```toml
-[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).
-
-<sup><sub>This page was automatically generated from [tests/cxx-standard/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/cxx-standard/cmake.toml).</sub></sup>

docs/examples/fetch-content.md

@@ -1,30 +0,0 @@
----
-# Automatically generated from tests/fetch-content/cmake.toml - DO NOT EDIT
-layout: default
-title: Fetching from git
-permalink: /examples/fetch-content
-parent: Examples
-nav_order: 2
----
-
-# Fetching from git
-
-Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) from [GitHub](https://github.com) and links an `example` target to it:
-
-```toml
-[project]
-name = "fetch-content"
-description = "Fetching from git"
-
-[fetch-content]
-fmt = { git = "https://github.com/fmtlib/fmt", tag = "7.1.3" }
-
-[target.example]
-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).
-
-<sup><sub>This page was automatically generated from [tests/fetch-content/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/fetch-content/cmake.toml).</sub></sup>

docs/examples/globbing.md

@@ -1,35 +0,0 @@
----
-# Automatically generated from tests/globbing/cmake.toml - DO NOT EDIT
-layout: default
-title: Globbing sources
-permalink: /examples/globbing
-parent: Examples
-nav_order: 6
----
-
-# Globbing sources
-
-
-
-```toml
-[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.
-
-<sup><sub>This page was automatically generated from [tests/globbing/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/globbing/cmake.toml).</sub></sup>

docs/examples/index.md

@@ -1,11 +0,0 @@
----
-layout: default
-title: Examples
-permalink: /examples/
-nav_order: 100
-has_children: true
----
-
-# Examples
-
-The examples in this section are automatically generated from the [tests](https://github.com/build-cpp/cmkr/blob/main/tests/cmake.toml).

docs/examples/interface.md

@@ -1,32 +0,0 @@
----
-# Automatically generated from tests/interface/cmake.toml - DO NOT EDIT
-layout: default
-title: Header-only library
-permalink: /examples/interface
-parent: Examples
-nav_order: 1
----
-
-# Header-only library
-
-
-
-```toml
-[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"]
-```
-
-
-
-<sup><sub>This page was automatically generated from [tests/interface/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/interface/cmake.toml).</sub></sup>

docs/examples/msvc-runtime.md

@@ -1,34 +0,0 @@
----
-# Automatically generated from tests/msvc-runtime/cmake.toml - DO NOT EDIT
-layout: default
-title: Static MSVC runtime
-permalink: /examples/msvc-runtime
-parent: Examples
-nav_order: 8
----
-
-# Static MSVC runtime
-
-
-
-```toml
-[project]
-name = "msvc-runtime"
-description = "Static MSVC runtime"
-msvc-runtime = "static"
-
-# This target will compile with a static runtime
-[target.static-runtime]
-type = "executable"
-sources = ["src/main.cpp"]
-
-# This target overrides the [project].msvc-runtime
-[target.dynamic-runtime]
-type = "executable"
-sources = ["src/main.cpp"]
-msvc-runtime = "dynamic"
-```
-
-
-
-<sup><sub>This page was automatically generated from [tests/msvc-runtime/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/msvc-runtime/cmake.toml).</sub></sup>

docs/examples/templates.md

@@ -1,40 +0,0 @@
----
-# Automatically generated from tests/templates/cmake.toml - DO NOT EDIT
-layout: default
-title: Target templates
-permalink: /examples/templates
-parent: Examples
-nav_order: 7
----
-
-# Target templates
-
-To avoid repeating yourself in targets you can create your own target type (template). All properties of the template are inherited when used as a target type.
-
-```toml
-[project]
-name = "templates"
-description = "Target templates"
-
-[template.app]
-type = "executable"
-sources = ["src/templates.cpp"]
-compile-definitions = ["IS_APP"]
-
-# Unlike interface targets you can also inherit properties
-[template.app.properties]
-CXX_STANDARD = "11"
-CXX_STANDARD_REQUIRED = true
-
-[target.app-a]
-type = "app"
-compile-definitions = ["APP_A"]
-
-[target.app-b]
-type = "app"
-compile-definitions = ["APP_B"]
-```
-
-**Note**: In most cases you probably want to use an [interface](/examples/interface) target instead.
-
-<sup><sub>This page was automatically generated from [tests/templates/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/templates/cmake.toml).</sub></sup>

docs/examples/vcpkg.md

@@ -1,38 +0,0 @@
----
-# Automatically generated from tests/vcpkg/cmake.toml - DO NOT EDIT
-layout: default
-title: Dependencies from vcpkg
-permalink: /examples/vcpkg
-parent: Examples
-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:
-
-```toml
-[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
-[vcpkg]
-version = "2024.03.25"
-packages = ["fmt"]
-
-[find-package]
-fmt = {}
-
-[target.example]
-type = "executable"
-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]`.
-
-<sup><sub>This page was automatically generated from [tests/vcpkg/cmake.toml](https://github.com/build-cpp/cmkr/tree/main/tests/vcpkg/cmake.toml).</sub></sup>

docs/getting-started.html

@@ -1,10 +0,0 @@
----
-layout: null
-permalink: /getting-started/
----
-
-<html>
-    <head>
-        <meta http-equiv="refresh" content="0;url=https://cmkr.build">
-    </head>
-</html>

docs/google13f7c659b54c069f.html

@@ -1 +0,0 @@
-google-site-verification: google13f7c659b54c069f.html

docs/hammer-svgrepo-com.svg

@@ -1,46 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 508 508" style="enable-background:new 0 0 508 508;" xml:space="preserve">
-<circle style="fill:#90DFAA;" cx="254" cy="254" r="254"/>
-<rect x="185.183" y="201.014" transform="matrix(-0.6939 -0.7201 0.7201 -0.6939 234.8233 525.8541)" style="fill:#2B3B4E;" width="88.002" height="24"/>
-<g>
-	<path style="fill:#324A5E;" d="M121.6,194.4c-8.8-16.4-2.8-40,14-56.4c50.8-50.4,108.8-52.4,136.8-49.6c4,0.4,3.6,6.4-0.8,8
-		c-11.6,4-21.2,8.8-29.6,14c-25.2,15.2-34,47.6-17.6,64.8l2.8,2.8c1.2,1.2,0.8,3.2-0.8,4.8l-26,25.2c-1.2,1.2-3.2,1.6-4.4,0.8
-		c-8.8-7.2-22-8.4-35.2-4C138.8,212.4,127.2,205.2,121.6,194.4z"/>
-	<path style="fill:#324A5E;" d="M144,228l-18,17.2c-4.8,4.8-12.4,4.4-17.2-0.4l-29.2-30c-4.8-4.8-4.4-12.4,0.4-17.2l18-17.2
-		c4.8-4.8,12.4-4.4,17.2,0.4l29.2,30C149.2,216,148.8,223.6,144,228z"/>
-</g>
-<path style="fill:#FFFFFF;" d="M249.6,240.8l7.2-6.8c5.2-4.8,13.6-4,20,1.6L402,353.2c6.8,6.4,7.6,16,2.4,21.2l-19.6,18.8
-	c-5.6,5.2-15.2,4-21.2-3.2L250.4,260.8C244.8,254.4,244.4,245.6,249.6,240.8z"/>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-<g>
-</g>
-</svg>

docs/index.md

@@ -1,81 +0,0 @@
----
-layout: home
-title: Documentation
-nav_order: 0
----
-
-# Documentation
-
-[`cmkr`](https://github.com/build-cpp/cmkr), pronounced "cmaker", is a modern build system based on [CMake](https://cmake.org/) and [TOML](https://toml.io).
-
-`cmkr` parses `cmake.toml` files and generates a modern, idiomatic `CMakeLists.txt` for you. A minimal example:
-
-```toml
-[project]
-name = "cmkr_for_beginners"
-
-[target.hello_world]
-type = "executable"
-sources = ["src/main.cpp"]
-```
-
-`cmkr` can bootstrap itself, and you only need CMake and a C++ compiler to use it.
-
-## Getting started
-
-To get started, run the following commands from your project directory:
-
-```sh
-curl https://raw.githubusercontent.com/build-cpp/cmkr/main/cmake/cmkr.cmake -o cmkr.cmake
-cmake -P cmkr.cmake
-```
-
-After the bootstrapping process finishes, customize [`cmake.toml`](./cmake-toml) for your project and run CMake:
-
-```sh
-cmake -B build
-cmake --build build
-```
-
-Once bootstrapped, `cmkr` does not introduce extra steps to your workflow. After modifying `cmake.toml` you simply build/configure your CMake project and `cmkr` will automatically regenerate `CMakeLists.txt` when necessary.
-
-<sub>**Note**: The `cmake.toml` project file, generated `CMakeLists.txt` and `cmkr.cmake` bootstrapping script are all intended to be added to source control.</sub>
-
-In CI environments the `cmkr` bootstrapping process is skipped, so there is no additional overhead in your pipelines.
-
-## Template repositories
-
-Another way to get started is to use the [cmkr_for_beginners](https://github.com/build-cpp/cmkr_for_beginners) template repository. Either open it in [Gitpod](https://gitpod.io/#https://github.com/build-cpp/cmkr_for_beginners), or clone the repository and run:
-
-```sh
-cmake -B build
-cmake --build build
-```
-
-Check out the [cmkr topic](https://github.com/topics/cmkr), the [build-cpp organization](https://github.com/build-cpp) or the [tests](https://github.com/build-cpp/cmkr/tree/main/tests) for more examples and templates.
-
-## Command line
-
-Optionally you can put a [`cmkr` release](https://github.com/build-cpp/cmkr/releases) in your `PATH` and use it as a utility from the command line:
-
-```
-Usage: cmkr [arguments]
-arguments:
-    init    [executable|library|shared|static|interface] Create a project.
-    gen                                                  Generates CMakeLists.txt file.
-    build   <extra cmake args>                           Run cmake and build.
-    install                                              Run cmake --install.
-    clean                                                Clean the build directory.
-    help                                                 Show help.
-    version                                              Current cmkr version.
-```
-
-## Credits
-
-- [gulrak/filesystem](https://github.com/gulrak/filesystem)
-- [Tessil/ordered-map](https://github.com/Tessil/ordered-map)
-- [ToruNiina/toml11](https://github.com/ToruNiina/toml11)
-- [mpark/variant](https://github.com/mpark/variant)
-- [SVG Repo Hammer](https://www.svgrepo.com/svg/192268/hammer)
-- [can1357](https://github.com/can1357) for buying `cmkr.build` ❤️
-- [JustasMasiulis](https://github.com/JustasMasiulis) for fixing the dark theme ❤️

docs/philosophy.md

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

docs/serve.sh

@@ -1,2 +0,0 @@
-bundle install
-bundle exec jekyll serve --force_polling --livereload --incremental

include/args.hpp

@@ -7,3 +7,5 @@ const char *handle_args(int argc, char **argv);
 
 } // namespace args
 } // namespace cmkr
+
+const char *cmkr_args_handle_args(int, char **);

include/build.hpp

@@ -11,3 +11,9 @@ int install();
 
 } // namespace build
 } // namespace cmkr
+
+int cmkr_build_run(int argc, char **argv);
+
+int cmkr_build_clean();
+
+int cmkr_build_install();

include/cmake.hpp

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <map>
+#include <mpark/variant.hpp>
+#include <stdexcept>
+#include <string>
+#include <tsl/ordered_map.h>
+#include <vector>
+
+namespace cmkr {
+namespace cmake {
+
+struct Setting {
+    std::string name;
+    std::string comment;
+    mpark::variant<bool, std::string> val;
+    bool cache = false;
+    bool force = false;
+};
+
+struct Option {
+    std::string name;
+    std::string comment;
+    bool val = false;
+};
+
+struct Package {
+    std::string name;
+    std::string version;
+    bool required = true;
+    bool config = true;
+    std::vector<std::string> components;
+};
+
+struct Vcpkg {
+    std::string version;
+    std::string triplet;
+    std::vector<std::string> packages;
+    std::vector<std::string> ports;
+    std::vector<std::string> overlay_ports;
+    std::vector<std::string> overlay_triplets;
+};
+
+enum TargetType {
+    target_executable,
+    target_library,
+    target_shared,
+    target_static,
+    target_interface,
+    target_custom,
+};
+
+template <typename T>
+using Condition = tsl::ordered_map<std::string, T>;
+
+using ConditionVector = Condition<std::vector<std::string>>;
+
+struct Target {
+    std::string name;
+    TargetType type = {};
+
+    // https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html#project-commands
+    ConditionVector compile_definitions;
+    ConditionVector compile_features;
+    ConditionVector compile_options;
+    ConditionVector include_directories;
+    ConditionVector link_directories;
+    ConditionVector link_libraries;
+    ConditionVector link_options;
+    ConditionVector precompile_headers;
+    ConditionVector sources;
+
+    std::string alias;
+    tsl::ordered_map<std::string, std::string> properties;
+
+    Condition<std::string> cmake_before;
+    Condition<std::string> cmake_after;
+    ConditionVector include_before;
+    ConditionVector include_after;
+};
+
+struct Test {
+    std::string name;
+    std::vector<std::string> configurations;
+    std::string working_directory;
+    std::string command;
+    std::vector<std::string> arguments;
+};
+
+struct Install {
+    std::vector<std::string> targets;
+    std::vector<std::string> files;
+    std::vector<std::string> dirs;
+    std::vector<std::string> configs;
+    std::string destination;
+};
+
+struct CMake {
+    // This is the CMake version required to use all cmkr versions.
+    std::string cmake_version = "3.15";
+    std::string cmkr_include = "cmkr.cmake";
+    std::string build_dir = "build";
+    std::string generator;
+    std::string config;
+    Condition<std::vector<std::string>> subdirs;
+    std::vector<std::string> cppflags;
+    std::vector<std::string> cflags;
+    std::vector<std::string> linkflags;
+    std::vector<std::string> gen_args;
+    std::vector<std::string> build_args;
+    std::string project_name;
+    std::string project_version;
+    std::string project_description;
+    std::vector<std::string> project_languages;
+    Condition<std::string> cmake_before;
+    Condition<std::string> cmake_after;
+    ConditionVector include_before;
+    ConditionVector include_after;
+    std::vector<Setting> settings;
+    std::vector<Option> options;
+    std::vector<Package> packages;
+    Vcpkg vcpkg;
+    tsl::ordered_map<std::string, std::map<std::string, std::string>> contents;
+    std::vector<Target> targets;
+    std::vector<Test> tests;
+    std::vector<Install> installs;
+    tsl::ordered_map<std::string, std::string> conditions;
+
+    CMake(const std::string &path, bool build);
+};
+
+} // namespace cmake
+} // namespace cmkr

include/cmake_generator.hpp

@@ -1,13 +0,0 @@
-#pragma once
-
-#include "project_parser.hpp"
-
-namespace cmkr {
-namespace gen {
-
-void generate_project(const std::string &type);
-
-void generate_cmake(const char *path, const parser::Project *parent_project = nullptr);
-
-} // namespace gen
-} // namespace cmkr

include/enum_helper.hpp

@@ -0,0 +1,69 @@
+// https://codereview.stackexchange.com/a/14315
+
+#include <algorithm>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+// This is the type that will hold all the strings.
+// Each enumeration type will declare its own specialization.
+// Any enum that does not have a specialization will generate a compiler error
+// indicating that there is no definition of this variable (as there should be
+// be no definition of a generic version).
+template <typename T>
+struct enumStrings {
+    static char const *data[];
+};
+
+// This is a utility type.
+// Created automatically. Should not be used directly.
+template <typename T>
+struct enumRefHolder {
+    T &enumVal;
+    enumRefHolder(T &enumVal) : enumVal(enumVal) {}
+};
+template <typename T>
+struct enumConstRefHolder {
+    T const &enumVal;
+    enumConstRefHolder(T const &enumVal) : enumVal(enumVal) {}
+};
+
+// The next two functions do the actual work of reading/writing an
+// enum as a string.
+template <typename T>
+std::ostream &operator<<(std::ostream &str, enumConstRefHolder<T> const &data) {
+    return str << enumStrings<T>::data[data.enumVal];
+}
+
+template <typename T>
+std::istream &operator>>(std::istream &str, enumRefHolder<T> const &data) {
+    std::string value;
+    str >> value;
+
+    // These two can be made easier to read in C++11
+    // using std::begin() and std::end()
+    //
+    static auto begin = std::begin(enumStrings<T>::data);
+    static auto end = std::end(enumStrings<T>::data);
+
+    auto find = std::find(begin, end, value);
+    if (find != end) {
+        data.enumVal = static_cast<T>(std::distance(begin, find));
+    } else {
+        throw std::invalid_argument("");
+    }
+    return str;
+}
+
+// This is the public interface:
+// use the ability of function to deduce their template type without
+// being explicitly told to create the correct type of enumRefHolder<T>
+template <typename T>
+enumConstRefHolder<T> enumToString(T const &e) {
+    return enumConstRefHolder<T>(e);
+}
+
+template <typename T>
+enumRefHolder<T> enumFromString(T &e) {
+    return enumRefHolder<T>(e);
+}

include/error.hpp

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

include/fs.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
-#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || (defined(__cplusplus) && __cplusplus >= 201703L)) && defined(__has_include)
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) ||                                             \
+     (defined(__cplusplus) && __cplusplus >= 201703L)) &&                                          \
+    defined(__has_include)
 #if __has_include(<filesystem>) && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500)
 #define GHC_USE_STD_FS
 #include <filesystem>
@@ -10,4 +12,4 @@ namespace fs = std::filesystem;
 #ifndef GHC_USE_STD_FS
 #include <ghc/filesystem.hpp>
 namespace fs = ghc::filesystem;
-#endif
+#endif

include/gen.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace cmkr {
+namespace gen {
+
+int generate_project(const char *typ);
+
+int generate_cmake(const char *path, bool root = true);
+
+} // namespace gen
+} // namespace cmkr
+
+int cmkr_gen_generate_project(const char *typ);
+
+int cmkr_gen_generate_cmake(const char *path);

include/help.hpp

@@ -9,3 +9,7 @@ const char *message() noexcept;
 
 } // namespace help
 } // namespace cmkr
+
+const char *cmkr_help_version(void);
+
+const char *cmkr_help_message(void);

include/literals.hpp

@@ -1,100 +1,45 @@
 #pragma once
 
-static const char *cpp_executable = &R"lit(
+static const char *hello_world = &R"lit(
 #include <iostream>
-#include <cstdlib>
 
-int main() {
+int %s() {
-    std::cout << "Hello from cmkr!\n";
+    std::cout << "Hello World!\n";
-    return EXIT_SUCCESS;
+    return 0;
 }
 )lit"[1]; // skip initial newline
 
-static const char *cpp_library = &R"lit(
+static const char *cmake_toml = &R"lit(
-#include <@name/@name.hpp>
+[cmake]
+version = "3.15"
+# subdirs = []
+# build-dir = ""
+# cpp-flags = []
+# c-flags = []
+# link-flags = []
+# generator = ""
+# arguments = []
 
-#include <iostream>
-
-namespace @name {
-
-void hello() {
-    std::cout << "Hello from cmkr!\n";
-}
-
-} // namespace @name
-)lit"[1]; // skip initial newline
-
-static const char *hpp_library = &R"lit(
-#pragma once
-
-namespace @name {
-
-void hello();
-
-} // namespace @name
-)lit"[1]; // skip initial newline
-
-static const char *hpp_interface = &R"lit(
-#pragma once
-
-#include <iostream>
-
-namespace @name {
-
-inline void hello() {
-    std::cout << "Hello from cmkr!\n";
-}
-
-} // namespace @name
-)lit"[1]; // skip initial newline
-
-static const char *toml_executable = &R"lit(
-# Reference: https://build-cpp.github.io/cmkr/cmake-toml
 [project]
-name = "@name"
+name = "%s"
-
+version = "0.1.0"
-[target.@name]
-type = "executable"
-sources = ["src/@name/main.cpp"]
-compile-features = ["cxx_std_11"]
-)lit"[1]; // skip initial newline
 
-static const char *toml_library = &R"lit(
+# [find-package]
-# Reference: https://build-cpp.github.io/cmkr/cmake-toml
-[project]
-name = "@name"
 
-[target.@name]
+# [fetch-content]
-type = "@type"
-sources = [
-    "src/@name/@name.cpp",
-    "include/@name/@name.hpp"
-]
-include-directories = ["include"]
-compile-features = ["cxx_std_11"]
-)lit"[1]; // skip initial newline
 
-static const char *toml_interface = &R"lit(
+# [options]
-# Reference: https://build-cpp.github.io/cmkr/cmake-toml
-[project]
-name = "@name"
 
-[target.@name]
+[target.%s]
-type = "interface"
+type = "%s"
+sources = ["src/*.cpp"]
 include-directories = ["include"]
-compile-features = ["cxx_std_11"]
+# alias = ""
-)lit"[1]; // skip initial newline
+# compile-features = []
-
+# compile-definitions = []
-static const char *toml_migration = &R"lit(
+# link-libraries = []
-# Reference: https://build-cpp.github.io/cmkr/cmake-toml
+
-[project]
+[[install]]
-name = "@name"
+%s = ["%s"]
-
+destination = "${CMAKE_INSTALL_PREFIX}/%s"
-# TODO: define a target for each of your executables/libraries like this:
-#[target.myexecutable]
-#type = "executable" # static, shared
-#sources = ["src/@name/*.cpp", "include/@name/*.hpp"]
-#include-directories = ["include"]
-#compile-features = ["cxx_std_11"]
-#link-libraries = ["target-or-library"]
 )lit"[1]; // skip initial newline

include/project_parser.hpp

@@ -1,217 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <string>
-
-#include <mpark/variant.hpp>
-#include <tsl/ordered_map.h>
-#include <tsl/ordered_set.h>
-
-namespace cmkr {
-namespace parser {
-
-template <typename T>
-using Condition = tsl::ordered_map<std::string, T>;
-
-using ConditionVector = Condition<std::vector<std::string>>;
-
-struct Variable {
-    std::string name;
-    std::string help;
-    mpark::variant<bool, std::string> value;
-    bool cache = false;
-    bool force = false;
-};
-
-struct Option {
-    std::string name;
-    std::string help;
-    mpark::variant<bool, std::string> value;
-};
-
-struct Package {
-    std::string name;
-    std::string condition;
-    std::string version;
-    bool required = true;
-    bool config = false;
-    std::vector<std::string> components;
-};
-
-struct Vcpkg {
-    std::string version;
-    std::string url;
-
-    struct Package {
-        std::string name;
-        std::vector<std::string> features;
-    };
-
-    std::vector<Package> packages;
-
-    bool enabled() const {
-        return !packages.empty();
-    }
-};
-
-enum TargetType {
-    target_executable,
-    target_library,
-    target_shared,
-    target_static,
-    target_interface,
-    target_custom,
-    target_object,
-    target_template,
-    target_last,
-};
-
-extern const char *targetTypeNames[target_last];
-
-struct Target {
-    std::string name;
-    TargetType type = target_last;
-    std::string type_name;
-
-    ConditionVector sources;
-
-    // https://cmake.org/cmake/help/latest/manual/cmake-commands.7.html#project-commands
-    ConditionVector compile_definitions;
-    ConditionVector private_compile_definitions;
-
-    ConditionVector compile_features;
-    ConditionVector private_compile_features;
-
-    ConditionVector compile_options;
-    ConditionVector private_compile_options;
-
-    ConditionVector include_directories;
-    ConditionVector private_include_directories;
-
-    ConditionVector link_directories;
-    ConditionVector private_link_directories;
-
-    ConditionVector link_libraries;
-    ConditionVector private_link_libraries;
-
-    ConditionVector link_options;
-    ConditionVector private_link_options;
-
-    ConditionVector precompile_headers;
-    ConditionVector private_precompile_headers;
-
-    std::string condition;
-    std::string alias;
-    Condition<tsl::ordered_map<std::string, std::string>> properties;
-
-    Condition<std::string> cmake_before;
-    Condition<std::string> cmake_after;
-    ConditionVector include_before;
-    ConditionVector include_after;
-};
-
-struct Template {
-    Target outline;
-    std::string add_function;
-    bool pass_sources_to_add_function = false;
-};
-
-struct Test {
-    std::string name;
-    std::string condition;
-    std::vector<std::string> configurations;
-    std::string working_directory;
-    std::string command;
-    std::vector<std::string> arguments;
-};
-
-struct Install {
-    std::string condition;
-    std::vector<std::string> targets;
-    std::vector<std::string> files;
-    std::vector<std::string> dirs;
-    std::vector<std::string> configs;
-    std::string destination;
-    std::string component;
-    bool optional = false;
-};
-
-struct Subdir {
-    std::string name;
-    std::string condition;
-
-    Condition<std::string> cmake_before;
-    Condition<std::string> cmake_after;
-    ConditionVector include_before;
-    ConditionVector include_after;
-};
-
-struct Content {
-    std::string name;
-    std::string condition;
-    tsl::ordered_map<std::string, std::string> arguments;
-
-    Condition<std::string> cmake_before;
-    Condition<std::string> cmake_after;
-    ConditionVector include_before;
-    ConditionVector include_after;
-    bool system = false;
-    std::string subdir;
-};
-
-enum MsvcRuntimeType {
-    msvc_dynamic,
-    msvc_static,
-    msvc_last,
-};
-
-extern const char *msvcRuntimeTypeNames[msvc_last];
-
-struct Project {
-    const Project *parent;
-
-    // This is the CMake version required to use all cmkr versions.
-    std::string cmake_version = "3.15";
-    std::string cmkr_include = "cmkr.cmake";
-    std::string build_dir = "build";
-    std::string generator;
-    std::string config;
-    bool allow_in_tree = false;
-    Condition<std::vector<std::string>> project_subdirs;
-    std::vector<std::string> cppflags;
-    std::vector<std::string> cflags;
-    std::vector<std::string> linkflags;
-    std::vector<std::string> gen_args;
-    std::vector<std::string> build_args;
-    std::string project_name;
-    std::string project_version;
-    std::string project_description;
-    std::vector<std::string> project_languages;
-    bool project_allow_unknown_languages = false;
-    MsvcRuntimeType project_msvc_runtime = msvc_last;
-    Condition<std::string> cmake_before;
-    Condition<std::string> cmake_after;
-    ConditionVector include_before;
-    ConditionVector include_after;
-    std::vector<Variable> variables;
-    std::vector<Option> options;
-    std::vector<Package> packages;
-    Vcpkg vcpkg;
-    std::vector<Content> contents;
-    std::vector<Template> templates;
-    std::vector<Target> targets;
-    std::vector<Test> tests;
-    std::vector<Install> installs;
-    tsl::ordered_map<std::string, std::string> conditions;
-    std::vector<Subdir> subdirs;
-
-    Project(const Project *parent, const std::string &path, bool build);
-    const Project *root() const;
-    bool cmake_minimum_version(int major, int minor) const;
-    static bool is_condition_name(const std::string &name);
-};
-
-bool is_root_path(const std::string &path);
-
-} // namespace parser
-} // namespace cmkr

src/args.cpp

@@ -1,9 +1,11 @@
-#include "arguments.hpp"
+#include "args.hpp"
 #include "build.hpp"
-#include "cmake_generator.hpp"
+#include "gen.hpp"
 #include "help.hpp"
-#include "fs.hpp"
 
+#include "fs.hpp"
+#include <exception>
+#include <iostream>
 #include <stdexcept>
 #include <string>
 #include <vector>
@@ -19,7 +21,9 @@ const char *handle_args(int argc, char **argv) {
         throw std::runtime_error(cmkr::help::message());
     std::string main_arg = args[1];
     if (main_arg == "gen") {
-        cmkr::gen::generate_cmake(fs::current_path().string().c_str());
+        auto ret = cmkr::gen::generate_cmake(fs::current_path().string().c_str());
+        if (ret)
+            return "CMake generation error!";
         return "CMake generation successful!";
     } else if (main_arg == "help") {
         return cmkr::help::message();
@@ -29,23 +33,24 @@ const char *handle_args(int argc, char **argv) {
         std::string type = "executable";
         if (args.size() > 2)
             type = args[2];
-        cmkr::gen::generate_project(type.c_str());
+        auto ret = cmkr::gen::generate_project(type.c_str());
-        cmkr::gen::generate_cmake(fs::current_path().string().c_str());
+        if (ret)
+            return "Initialization failure!";
         return "Directory initialized!";
     } else if (main_arg == "build") {
         auto ret = build::run(argc, argv);
         if (ret)
-            throw std::runtime_error("CMake build failed!");
+            return "CMake build error!";
-        return "CMake build completed!";
+        return "CMake run completed!";
     } else if (main_arg == "install") {
         auto ret = build::install();
         if (ret)
-            throw std::runtime_error("CMake install failed!");
+            return "CMake install error!";
         return "CMake install completed!";
     } else if (main_arg == "clean") {
         auto ret = build::clean();
         if (ret)
-            throw std::runtime_error("CMake clean failed!");
+            return "CMake clean error!";
         return "Cleaned build directory!";
     } else {
         throw std::runtime_error(cmkr::help::message());
@@ -53,3 +58,13 @@ const char *handle_args(int argc, char **argv) {
 }
 } // namespace args
 } // namespace cmkr
+
+const char *cmkr_args_handle_args(int argc, char **argv) {
+    try {
+        return cmkr::args::handle_args(argc, argv);
+    } catch (const std::exception &e) {
+        return e.what();
+    } catch (...) {
+        return "Unknown error!";
+    }
+}

src/build.cpp

@@ -1,41 +1,46 @@
 #include "build.hpp"
-#include "cmake_generator.hpp"
+#include "cmake.hpp"
-#include "project_parser.hpp"
+#include "error.hpp"
+#include "gen.hpp"
 
 #include "fs.hpp"
-#include <cstdlib>
 #include <sstream>
+#include <stddef.h>
+#include <stdexcept>
+#include <stdlib.h>
+#include <system_error>
 
 namespace cmkr {
 namespace build {
 
 int run(int argc, char **argv) {
-    parser::Project project(nullptr, ".", true);
+    cmake::CMake cmake(".", true);
     if (argc > 2) {
         for (int i = 2; i < argc; ++i) {
-            project.build_args.emplace_back(argv[i]);
+            cmake.build_args.push_back(argv[i]);
         }
     }
     std::stringstream ss;
 
-    gen::generate_cmake(fs::current_path().string().c_str());
+    if (gen::generate_cmake(fs::current_path().string().c_str()))
+        throw std::runtime_error("CMake generation failure!");
 
-    ss << "cmake -DCMKR_BUILD_SKIP_GENERATION=ON -B" << project.build_dir << " ";
+    ss << "cmake -S. -B" << cmake.build_dir << " ";
 
-    if (!project.generator.empty()) {
+    if (!cmake.generator.empty()) {
-        ss << "-G \"" << project.generator << "\" ";
+        ss << "-G \"" << cmake.generator << "\" ";
     }
-    if (!project.config.empty()) {
+    if (!cmake.config.empty()) {
-        ss << "-DCMAKE_BUILD_TYPE=" << project.config << " ";
+        ss << "-DCMAKE_BUILD_TYPE=" << cmake.config << " ";
     }
-    if (!project.gen_args.empty()) {
+    if (!cmake.gen_args.empty()) {
-        for (const auto &arg : project.gen_args) {
+        for (const auto &arg : cmake.gen_args) {
             ss << "-D" << arg << " ";
         }
     }
-    ss << "&& cmake --build " << project.build_dir << " --parallel";
+    ss << "&& cmake --build " << cmake.build_dir << " --parallel";
     if (argc > 2) {
-        for (const auto &arg : project.build_args) {
+        for (const auto &arg : cmake.build_args) {
             ss << " " << arg;
         }
     }
@@ -44,19 +49,49 @@ int run(int argc, char **argv) {
 }
 
 int clean() {
-    bool success = false;
+    bool ret = false;
-    parser::Project project(nullptr, ".", true);
+    cmake::CMake cmake(".", true);
-    if (fs::exists(project.build_dir)) {
+    if (fs::exists(cmake.build_dir)) {
-        success = fs::remove_all(project.build_dir);
+        ret = fs::remove_all(cmake.build_dir);
-        fs::create_directory(project.build_dir);
+        fs::create_directory(cmake.build_dir);
     }
-    return success ? EXIT_SUCCESS : EXIT_FAILURE;
+    return !ret;
 }
 
 int install() {
-    parser::Project project(nullptr, ".", false);
+    cmake::CMake cmake(".", false);
-    auto cmd = "cmake --install " + project.build_dir;
+    auto cmd = "cmake --install " + cmake.build_dir;
     return ::system(cmd.c_str());
 }
 } // namespace build
 } // namespace cmkr
+
+int cmkr_build_run(int argc, char **argv) {
+    try {
+        return cmkr::build::run(argc, argv);
+    } catch (const std::system_error &e) {
+        return e.code().value();
+    } catch (...) {
+        return cmkr::error::Status(cmkr::error::Status::Code::BuildError);
+    }
+}
+
+int cmkr_build_clean(void) {
+    try {
+        return cmkr::build::clean();
+    } catch (const std::system_error &e) {
+        return e.code().value();
+    } catch (...) {
+        return cmkr::error::Status(cmkr::error::Status::Code::CleanError);
+    }
+}
+
+int cmkr_build_install(void) {
+    try {
+        return cmkr::build::install();
+    } catch (const std::system_error &e) {
+        return e.code().value();
+    } catch (...) {
+        return cmkr::error::Status(cmkr::error::Status::Code::InstallError);
+    }
+}

src/cmake.cpp

@@ -0,0 +1,280 @@
+#include "cmake.hpp"
+
+#include "enum_helper.hpp"
+#include "fs.hpp"
+#include <stdexcept>
+#include <toml.hpp>
+#include <tsl/ordered_map.h>
+
+template <>
+const char *enumStrings<cmkr::cmake::TargetType>::data[] = {"executable", "library", "shared", "static", "interface", "custom"};
+
+namespace cmkr {
+namespace cmake {
+
+using TomlBasicValue = toml::basic_value<toml::preserve_comments, tsl::ordered_map, std::vector>;
+
+template <typename EnumType>
+static EnumType to_enum(const std::string &str, const std::string &help_name) {
+    EnumType value;
+    try {
+        std::stringstream ss(str);
+        ss >> enumFromString(value);
+    } catch (std::invalid_argument &) {
+        std::string supported;
+        for (const auto &s : enumStrings<EnumType>::data) {
+            if (!supported.empty()) {
+                supported += ", ";
+            }
+            supported += s;
+        }
+        throw std::runtime_error("Unknown " + help_name + "'" + str + "'! Supported types are: " + supported);
+    }
+    return value;
+}
+
+// If the key is found, get strongly-typed value (throws on user-error)
+template <typename T>
+static void get_optional(const TomlBasicValue &v, const toml::key &ky, T &destination);
+
+template <typename T>
+static void get_optional(const TomlBasicValue &v, const toml::key &ky, Condition<T> &destination) {
+    // TODO: this algorithm in O(n) over the amount of keys, kinda bad
+    const auto &table = v.as_table();
+    for (const auto &itr : table) {
+        const auto &key = itr.first;
+        const auto &value = itr.second;
+        if (value.is_table()) {
+            if (value.contains(ky)) {
+                destination[key] = toml::find<T>(value, ky);
+            }
+        } else if (key == ky) {
+            destination[""] = toml::find<T>(v, ky);
+        }
+    }
+}
+
+template <typename T>
+static void get_optional(const TomlBasicValue &v, const toml::key &ky, T &destination) {
+    if (v.contains(ky)) {
+        destination = toml::find<T>(v, ky);
+    }
+}
+
+CMake::CMake(const std::string &path, bool build) {
+    if (!fs::exists(fs::path(path) / "cmake.toml")) {
+        throw std::runtime_error("No cmake.toml was found!");
+    }
+    const auto toml = toml::parse<toml::preserve_comments, tsl::ordered_map, std::vector>((fs::path(path) / "cmake.toml").string());
+    if (build) {
+        if (toml.contains("cmake")) {
+            const auto &cmake = toml::find(toml, "cmake");
+
+            if (cmake.contains("bin-dir")) {
+                throw std::runtime_error("bin-dir has been renamed to build-dir");
+            }
+
+            get_optional(cmake, "build-dir", build_dir);
+            get_optional(cmake, "generator", generator);
+            get_optional(cmake, "config", config);
+            get_optional(cmake, "arguments", gen_args);
+        }
+    } else {
+        if (toml.contains("cmake")) {
+            const auto &cmake = toml::find(toml, "cmake");
+            cmake_version = toml::find(cmake, "version").as_string();
+            get_optional(cmake, "cmkr-include", cmkr_include);
+            get_optional(cmake, "cpp-flags", cppflags);
+            get_optional(cmake, "c-flags", cflags);
+            get_optional(cmake, "link-flags", linkflags);
+        }
+
+        if (toml.contains("project")) {
+            const auto &project = toml::find(toml, "project");
+            project_name = toml::find(project, "name").as_string();
+            get_optional(project, "version", project_version);
+            get_optional(project, "description", project_description);
+            get_optional(project, "languages", project_languages);
+            get_optional(project, "cmake-before", cmake_before);
+            get_optional(project, "cmake-after", cmake_after);
+            get_optional(project, "include-before", include_before);
+            get_optional(project, "include-after", include_after);
+            get_optional(project, "subdirs", subdirs);
+        }
+
+        if (toml.contains("settings")) {
+            using set_map = std::map<std::string, TomlBasicValue>;
+            const auto &sets = toml::find<set_map>(toml, "settings");
+            for (const auto &set : sets) {
+                Setting s;
+                s.name = set.first;
+                if (set.second.is_boolean()) {
+                    s.val = set.second.as_boolean();
+                } else if (set.second.is_string()) {
+                    s.val = set.second.as_string();
+                } else {
+                    get_optional(set.second, "comment", s.comment);
+                    if (set.second.contains("value")) {
+                        auto v = toml::find(set.second, "value");
+                        if (v.is_boolean()) {
+                            s.val = v.as_boolean();
+                        } else {
+                            s.val = v.as_string();
+                        }
+                    }
+                    get_optional(set.second, "cache", s.cache);
+                    get_optional(set.second, "force", s.force);
+                }
+                settings.push_back(s);
+            }
+        }
+
+        if (toml.contains("options")) {
+            using opts_map = tsl::ordered_map<std::string, TomlBasicValue>;
+            const auto &opts = toml::find<opts_map>(toml, "options");
+            for (const auto &opt : opts) {
+                Option o;
+                o.name = opt.first;
+                if (opt.second.is_boolean()) {
+                    o.val = opt.second.as_boolean();
+                } else {
+                    get_optional(opt.second, "comment", o.comment);
+                    get_optional(opt.second, "value", o.val);
+                }
+                options.push_back(o);
+            }
+        }
+
+        if (toml.contains("find-package")) {
+            using pkg_map = tsl::ordered_map<std::string, TomlBasicValue>;
+            const auto &pkgs = toml::find<pkg_map>(toml, "find-package");
+            for (const auto &pkg : pkgs) {
+                Package p;
+                p.name = pkg.first;
+                if (pkg.second.is_string()) {
+                    p.version = pkg.second.as_string();
+                } else {
+                    get_optional(pkg.second, "version", p.version);
+                    get_optional(pkg.second, "required", p.required);
+                    get_optional(pkg.second, "config", p.config);
+                    get_optional(pkg.second, "components", p.components);
+                }
+                packages.push_back(p);
+            }
+        }
+
+        // TODO: refactor to std::vector<Content> instead of this hacky thing?
+        get_optional(toml, "fetch-content", contents);
+
+        if (toml.contains("bin")) {
+            throw std::runtime_error("[[bin]] has been renamed to [[target]]");
+        }
+
+        if (toml.contains("target")) {
+            const auto &ts = toml::find(toml, "target").as_table();
+
+            for (const auto &itr : ts) {
+                const auto &t = itr.second;
+                Target target;
+                target.name = itr.first;
+                target.type = to_enum<TargetType>(toml::find(t, "type").as_string(), "target type");
+
+                get_optional(t, "sources", target.sources);
+                get_optional(t, "compile-definitions", target.compile_definitions);
+                get_optional(t, "compile-features", target.compile_features);
+                get_optional(t, "compile-options", target.compile_options);
+                get_optional(t, "include-directories", target.include_directories);
+                get_optional(t, "link-directories", target.link_directories);
+                get_optional(t, "link-libraries", target.link_libraries);
+                get_optional(t, "link-options", target.link_options);
+                get_optional(t, "precompile-headers", target.precompile_headers);
+
+                if (t.contains("alias")) {
+                    target.alias = toml::find(t, "alias").as_string();
+                }
+
+                if (t.contains("properties")) {
+                    const auto &props = toml::find(t, "properties").as_table();
+                    for (const auto &propKv : props) {
+                        if (propKv.second.is_array()) {
+                            std::string property_list;
+                            for (const auto &list_val : propKv.second.as_array()) {
+                                if (!property_list.empty()) {
+                                    property_list += ';';
+                                }
+                                property_list += list_val.as_string();
+                            }
+                            target.properties[propKv.first] = property_list;
+                        } else {
+                            target.properties[propKv.first] = propKv.second.as_string();
+                        }
+                    }
+                }
+
+                get_optional(t, "cmake-before", target.cmake_before);
+                get_optional(t, "cmake-after", target.cmake_after);
+                get_optional(t, "include-before", target.include_before);
+                get_optional(t, "include-after", target.include_after);
+
+                targets.push_back(target);
+            }
+        }
+
+        if (toml.contains("test")) {
+            const auto &ts = toml::find(toml, "test").as_array();
+            for (const auto &t : ts) {
+                Test test;
+                test.name = toml::find(t, "name").as_string();
+                get_optional(t, "configurations", test.configurations);
+                get_optional(t, "working-directory", test.working_directory);
+                test.command = toml::find(t, "command").as_string();
+                get_optional(t, "arguments", test.arguments);
+                tests.push_back(test);
+            }
+        }
+
+        if (toml.contains("install")) {
+            const auto &ts = toml::find(toml, "install").as_array();
+            for (const auto &t : ts) {
+                Install inst;
+                get_optional(t, "targets", inst.targets);
+                get_optional(t, "files", inst.files);
+                get_optional(t, "dirs", inst.dirs);
+                get_optional(t, "configs", inst.configs);
+                inst.destination = toml::find(t, "destination").as_string();
+                installs.push_back(inst);
+            }
+        }
+
+        if (toml.contains("vcpkg")) {
+            const auto &v = toml::find(toml, "vcpkg");
+            vcpkg.version = toml::find(v, "version").as_string();
+            vcpkg.packages = toml::find<decltype(vcpkg.packages)>(v, "packages");
+            get_optional(v, "overlay-ports", vcpkg.overlay_ports);
+            get_optional(v, "overlay-triplets", vcpkg.overlay_triplets);
+
+            // This allows the user to use a custom pmm version if desired
+            if (contents.count("pmm") == 0) {
+                contents["pmm"]["url"] = "https://github.com/vector-of-bool/pmm/archive/refs/tags/1.5.1.tar.gz";
+                // Hack to not execute pmm's example CMakeLists.txt
+                contents["pmm"]["SOURCE_SUBDIR"] = "pmm";
+            }
+        }
+
+        // Reasonable default conditions (you can override these if you desire)
+        conditions["windows"] = R"cmake(WIN32)cmake";
+        conditions["macos"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")cmake";
+        conditions["unix"] = R"cmake(UNIX)cmake";
+        conditions["bsd"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "BSD")cmake";
+        conditions["linux"] = conditions["lunix"] = R"cmake("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")cmake";
+
+        if (toml.contains("conditions")) {
+            auto conds = toml::find<decltype(conditions)>(toml, "conditions");
+            for (const auto &cond : conds) {
+                conditions[cond.first] = cond.second;
+            }
+        }
+    }
+}
+} // namespace cmake
+} // namespace cmkr

src/error.cpp

@@ -0,0 +1,24 @@
+#include "error.hpp"
+
+#include <assert.h>
+
+namespace cmkr {
+namespace error {
+
+Status::Status(Code ec) noexcept : ec_(ec) {}
+
+Status::operator int() const noexcept { return static_cast<int>(ec_); }
+
+Status::Code Status::code() const noexcept { return ec_; }
+
+} // namespace error
+} // namespace cmkr
+
+const char *err_string[] = {
+    "Success", "Runtime error", "Initialization error", "CMake generation error", "Build error",
+};
+
+const char *cmkr_error_status(int i) {
+    assert(i >= 0 && i < 5);
+    return err_string[i];
+}

src/gen.cpp

@@ -0,0 +1,810 @@
+#include "gen.hpp"
+#include "cmake.hpp"
+#include "error.hpp"
+#include "literals.hpp"
+
+#include "fs.hpp"
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <new>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+namespace cmkr {
+namespace gen {
+
+inline std::string to_upper(const std::string &str) {
+    std::string temp;
+    temp.reserve(str.size());
+    for (auto c : str) {
+        temp.push_back(::toupper(c));
+    }
+    return temp;
+}
+
+template <typename... Args>
+std::string format(const char *fmt, Args... args) {
+    auto sz = snprintf(nullptr, 0, fmt, args...) + 1;
+    char *buf = new char[sz];
+    int ret = snprintf(buf, sz, fmt, args...);
+    if (ret != sz - 1)
+        throw std::runtime_error("Error formatting string!");
+    std::string temp(buf, buf + sz - 1);
+    delete[] buf;
+    return temp;
+}
+
+static std::vector<std::string> expand_cmake_path(const fs::path &name, const fs::path &toml_dir) {
+    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;
+    };
+
+    auto stem = name.filename().stem().string();
+    auto ext = name.extension();
+
+    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));
+            }
+        }
+    } 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()));
+            }
+        }
+    } else {
+        temp.push_back(name.string());
+    }
+    // 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;
+}
+
+static std::vector<std::string> expand_cmake_paths(const std::vector<std::string> &sources, const fs::path &toml_dir) {
+    // TODO: add duplicate checking
+    std::vector<std::string> result;
+    for (const auto &src : sources) {
+        auto expanded = expand_cmake_path(src, toml_dir);
+        for (const auto &f : expanded) {
+            result.push_back(f);
+        }
+    }
+    return result;
+}
+
+int generate_project(const char *str) {
+    fs::create_directory("src");
+    fs::create_directory("include");
+    const auto dir_name = fs::current_path().stem().string();
+    std::string mainbuf;
+    std::string installed;
+    std::string target;
+    std::string dest;
+    if (!strcmp(str, "executable")) {
+        mainbuf = format(hello_world, "main");
+        installed = "targets";
+        target = dir_name;
+        dest = "bin";
+    } else if (!strcmp(str, "static") || !strcmp(str, "shared") || !strcmp(str, "library")) {
+        mainbuf = format(hello_world, "test");
+        installed = "targets";
+        target = dir_name;
+        dest = "lib";
+    } else if (!strcmp(str, "interface")) {
+        installed = "files";
+        target = "include/*.h";
+        dest = "include/" + dir_name;
+    } else {
+        throw std::runtime_error("Unknown project type " + std::string(str) +
+                                 "! Supported types are: executable, library, shared, static, interface");
+    }
+
+    const auto tomlbuf = format(cmake_toml, dir_name.c_str(), dir_name.c_str(), str, installed.c_str(), target.c_str(), dest.c_str());
+
+    if (strcmp(str, "interface")) {
+        std::ofstream ofs("src/main.cpp");
+        if (ofs.is_open()) {
+            ofs << mainbuf;
+        }
+        ofs.flush();
+        ofs.close();
+    }
+
+    std::ofstream ofs2("cmake.toml");
+    if (ofs2.is_open()) {
+        ofs2 << tomlbuf;
+    }
+    ofs2.flush();
+    ofs2.close();
+
+    return 0;
+}
+
+struct CommandEndl {
+    std::stringstream &ss;
+    CommandEndl(std::stringstream &ss) : ss(ss) {}
+    void endl() { ss << '\n'; }
+};
+
+struct RawArg {
+    RawArg() = default;
+    RawArg(std::string arg) : arg(std::move(arg)) {}
+
+    std::string arg;
+};
+
+// Credit: JustMagic
+struct Command {
+    std::stringstream &ss;
+    int depth = 0;
+    std::string command;
+    bool first_arg = true;
+    bool had_newline = false;
+    bool generated = false;
+
+    Command(std::stringstream &ss, int depth, const std::string &command) : ss(ss), depth(depth), command(command) {}
+
+    ~Command() {
+        if (!generated) {
+            assert(false && "Incorrect usage of cmd()");
+        }
+    }
+
+    std::string quote(const std::string &str) {
+        // Don't quote arguments that don't need quoting
+        if (str.find(' ') == std::string::npos && str.find('\"') == std::string::npos && str.find('/') == std::string::npos &&
+            str.find(';') == std::string::npos) {
+            return str;
+        }
+        std::string result;
+        result += "\"";
+        for (char ch : str) {
+            switch (ch) {
+            case '\\':
+            case '\"':
+                result += '\\';
+            default:
+                result += ch;
+                break;
+            }
+        }
+        result += "\"";
+        return result;
+    }
+
+    static std::string indent(int n) {
+        std::string result;
+        for (int i = 0; i < n; i++) {
+            result += '\t';
+        }
+        return result;
+    }
+
+    template <class T>
+    bool print_arg(const std::vector<T> &vec) {
+        if (vec.empty()) {
+            return true;
+        }
+
+        had_newline = true;
+        for (const auto &value : vec) {
+            print_arg(value);
+        }
+
+        return true;
+    }
+
+    template <class Key, class Value>
+    bool print_arg(const tsl::ordered_map<Key, Value> &map) {
+        if (map.empty()) {
+            return true;
+        }
+
+        for (const auto &itr : map) {
+            print_arg(itr);
+        }
+
+        return true;
+    }
+
+    template <class K>
+    bool print_arg(const std::pair<K, std::vector<std::string>> &kv) {
+        if (kv.second.empty()) {
+            return true;
+        }
+
+        had_newline = true;
+        print_arg(kv.first);
+        depth++;
+        for (const auto &s : kv.second) {
+            print_arg(s);
+        }
+        depth--;
+
+        return true;
+    }
+
+    template <class K, class V>
+    bool print_arg(const std::pair<K, V> &kv) {
+        if (kv.second.empty()) {
+            return true;
+        }
+
+        had_newline = true;
+        print_arg(kv.first);
+        depth++;
+        print_arg(kv.second);
+        depth--;
+
+        return true;
+    }
+
+    bool print_arg(const RawArg &arg) {
+        if (arg.arg.empty()) {
+            return true;
+        }
+
+        if (had_newline) {
+            first_arg = false;
+            ss << '\n' << indent(depth + 1);
+        } else if (first_arg) {
+            first_arg = false;
+        } else {
+            ss << ' ';
+        }
+
+        ss << arg.arg;
+        return true;
+    }
+
+    template <class T>
+    bool print_arg(const T &value) {
+        std::stringstream tmp;
+        tmp << value;
+        auto str = tmp.str();
+        if (str.empty()) {
+            return true;
+        }
+
+        if (had_newline) {
+            first_arg = false;
+            ss << '\n' << indent(depth + 1);
+        } else if (first_arg) {
+            first_arg = false;
+        } else {
+            ss << ' ';
+        }
+
+        ss << quote(str);
+        return true;
+    }
+
+    template <class... Ts>
+    CommandEndl operator()(Ts &&...values) {
+        generated = true;
+        ss << indent(depth) << command << '(';
+        (void)std::initializer_list<bool>{print_arg(values)...};
+        if (had_newline)
+            ss << '\n' << indent(depth);
+        ss << ")\n";
+        return CommandEndl(ss);
+    }
+};
+
+static std::string tolf(const std::string &str) {
+    std::string result;
+    for (char ch : str) {
+        if (ch != '\r') {
+            result += ch;
+        }
+    }
+    return result;
+};
+
+struct Generator {
+    Generator(cmake::CMake &cmake) : cmake(cmake) {}
+    Generator(const Generator &) = delete;
+
+    cmake::CMake &cmake;
+    std::stringstream ss;
+    int indent = 0;
+
+    Command cmd(const std::string &command) {
+        if (command.empty())
+            throw std::invalid_argument("command cannot be empty");
+        if (command == "if") {
+            indent++;
+            return Command(ss, indent - 1, command);
+        } else if (command == "else" || command == "elseif") {
+            return Command(ss, indent - 1, command);
+        } else if (command == "endif") {
+            indent--;
+        }
+        return Command(ss, indent, command);
+    }
+
+    CommandEndl comment(const std::string &comment) {
+        ss << Command::indent(indent) << "# " << comment << '\n';
+        return CommandEndl(ss);
+    }
+
+    void endl() { ss << '\n'; }
+
+    void inject_includes(const std::vector<std::string> &includes) {
+        if (!includes.empty()) {
+            for (const auto &file : includes) {
+                if (!fs::is_regular_file(file)) {
+                    throw std::runtime_error("Include '" + file + "' does not exist");
+                }
+                cmd("include")(file);
+            }
+        }
+    }
+
+    void inject_cmake(const std::string &cmake) {
+        if (!cmake.empty()) {
+            if (cmake.back() == '\"') {
+                throw std::runtime_error("Detected additional \" at the end of cmake block");
+            }
+            auto cmake_lf = tolf(cmake);
+            while (cmake_lf.back() == '\n')
+                cmake_lf.pop_back();
+            bool did_indent = false;
+            for (char ch : cmake_lf) {
+                if (!did_indent) {
+                    ss << Command::indent(indent);
+                    did_indent = true;
+                } else if (ch == '\n') {
+                    did_indent = false;
+                }
+                ss << ch;
+            }
+            ss << '\n';
+        }
+    }
+
+    template <typename T, typename Lambda>
+    void handle_condition(const cmake::Condition<T> &value, const Lambda &fn) {
+        if (!value.empty()) {
+            for (const auto &itr : value) {
+                const auto &condition = itr.first;
+                if (!condition.empty()) {
+                    if (cmake.conditions.count(condition) == 0) {
+                        // TODO: somehow print line number information here?
+                        throw std::runtime_error("Unknown condition '" + condition + "'");
+                    }
+                    cmd("if")(RawArg(cmake.conditions[condition]));
+                }
+
+                if (!itr.second.empty()) {
+                    fn(condition, itr.second);
+                }
+
+                if (!condition.empty()) {
+                    cmd("endif")();
+                }
+                endl();
+            }
+        }
+    }
+};
+
+int generate_cmake(const char *path, bool root) {
+    if (!fs::exists(fs::path(path) / "cmake.toml")) {
+        throw std::runtime_error("No cmake.toml found!");
+    }
+
+    cmake::CMake cmake(path, false);
+    Generator gen(cmake);
+
+    // Helper lambdas for more convenient CMake generation
+    auto &ss = gen.ss;
+    auto cmd = [&gen](const std::string &comment) { return gen.cmd(comment); };
+    auto comment = [&gen](const std::string &comment) { return gen.comment(comment); };
+    auto endl = [&gen]() { gen.endl(); };
+    auto inject_includes = [&gen](const std::vector<std::string> &includes) { gen.inject_includes(includes); };
+    auto inject_cmake = [&gen](const std::string &cmake) { gen.inject_cmake(cmake); };
+
+    comment("This file is automatically generated from cmake.toml - DO NOT EDIT");
+    comment("See https://github.com/build-cpp/cmkr for more information");
+    endl();
+
+    if (root) {
+        cmd("cmake_minimum_required")("VERSION", cmake.cmake_version).endl();
+
+        comment("Regenerate CMakeLists.txt automatically in the root project");
+        cmd("set")("CMKR_ROOT_PROJECT", "OFF");
+        // clang-format off
+        cmd("if")("CMAKE_CURRENT_SOURCE_DIR", "STREQUAL", "CMAKE_SOURCE_DIR");
+            cmd("set")("CMKR_ROOT_PROJECT", "ON").endl();
+
+            comment("Bootstrap cmkr");
+            cmd("include")(cmake.cmkr_include, "OPTIONAL", "RESULT_VARIABLE", "CMKR_INCLUDE_RESULT");
+            cmd("if")("CMKR_INCLUDE_RESULT");
+                cmd("cmkr")();
+            cmd("endif")().endl();
+
+            comment("Enable folder support");
+            cmd("set_property")("GLOBAL", "PROPERTY", "USE_FOLDERS", "ON");
+        cmd("endif")().endl();
+        // clang-format on
+    }
+
+    // clang-format off
+    comment("Create a configure-time dependency on cmake.toml to improve IDE support");
+    cmd("if")("CMKR_ROOT_PROJECT");
+        cmd("configure_file")("cmake.toml", "cmake.toml", "COPYONLY");
+    cmd("endif")().endl();
+    // clang-format on
+
+    // TODO: remove support and replace with global compile-features
+    if (!cmake.cppflags.empty()) {
+        ss << "set(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} \"";
+        for (const auto &flag : cmake.cppflags) {
+            ss << flag << " ";
+        }
+        ss << "\")\n\n";
+    }
+
+    // TODO: remove support and replace with global compile-features
+    if (!cmake.cflags.empty()) {
+        ss << "set(CMAKE_C_FLAGS ${CMAKE_C_FLAGS} \"";
+        for (const auto &flag : cmake.cflags) {
+            ss << flag << " ";
+        }
+        ss << "\")\n\n";
+    }
+
+    // TODO: remove support and replace with global linker-flags
+    if (!cmake.linkflags.empty()) {
+        ss << "set(CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} \"";
+        for (const auto &flag : cmake.linkflags) {
+            ss << flag << " ";
+        }
+        ss << "\")\n\n";
+    }
+
+    gen.handle_condition(cmake.include_before, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+    gen.handle_condition(cmake.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+    if (!cmake.project_name.empty()) {
+        auto languages = std::make_pair("LANGUAGES", cmake.project_languages);
+        auto version = std::make_pair("VERSION", cmake.project_version);
+        auto description = std::make_pair("DESCRIPTION", cmake.project_description);
+        cmd("project")(cmake.project_name, languages, version, description).endl();
+    }
+
+    gen.handle_condition(cmake.include_after, [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+    gen.handle_condition(cmake.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+    if (!cmake.contents.empty()) {
+        cmd("include")("FetchContent").endl();
+        for (const auto &dep : cmake.contents) {
+            cmd("message")("STATUS", "Fetching " + dep.first + "...");
+            ss << "FetchContent_Declare(\n\t" << dep.first << "\n";
+            for (const auto &arg : dep.second) {
+                std::string first_arg = arg.first;
+                if (first_arg == "git") {
+                    first_arg = "GIT_REPOSITORY";
+                } else if (first_arg == "tag") {
+                    first_arg = "GIT_TAG";
+                } else if (first_arg == "svn") {
+                    first_arg = "SVN_REPOSITORY";
+                } else if (first_arg == "rev") {
+                    first_arg = "SVN_REVISION";
+                } else if (first_arg == "url") {
+                    first_arg = "URL";
+                } else if (first_arg == "hash") {
+                    first_arg = "URL_HASH";
+                } else {
+                    // don't change arg
+                }
+                ss << "\t" << first_arg << "\n\t\t" << arg.second << "\n";
+            }
+            ss << ")\n";
+            cmd("FetchContent_MakeAvailable")(dep.first).endl();
+        }
+    }
+
+    if (!cmake.vcpkg.version.empty()) {
+        assert("pmm is required in fetch-content for vcpkg to work" && cmake.contents.count("pmm") != 0);
+        comment("Bootstrap vcpkg");
+        cmd("include")("${pmm_SOURCE_DIR}/pmm.cmake");
+        tsl::ordered_map<std::string, std::vector<std::string>> vcpkg_args;
+        vcpkg_args["REVISION"] = {cmake.vcpkg.version};
+        vcpkg_args["TRIPLET"] = {cmake.vcpkg.triplet};
+        vcpkg_args["REQUIRES"] = cmake.vcpkg.packages;
+        vcpkg_args["PORTS"] = cmake.vcpkg.ports;
+        vcpkg_args["OVERLAY_PORTS"] = cmake.vcpkg.overlay_ports;
+        vcpkg_args["OVERLAY_TRIPLETS"] = cmake.vcpkg.overlay_triplets;
+        auto vcpkg = std::make_pair("VCPKG", vcpkg_args);
+        cmd("pmm")(vcpkg).endl();
+    }
+
+    if (!cmake.packages.empty()) {
+        comment("Packages");
+        for (const auto &dep : cmake.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);
+            cmd("find_package")(dep.name, version, required, config, components).endl();
+        }
+    }
+
+    if (!cmake.options.empty()) {
+        comment("Options");
+        for (const auto &opt : cmake.options) {
+            cmd("option")(opt.name, opt.comment, opt.val ? "ON" : "OFF");
+        }
+        endl();
+    }
+
+    if (!cmake.settings.empty()) {
+        comment("Settings");
+        for (const auto &set : cmake.settings) {
+            std::string set_val;
+            if (set.val.index() == 1) {
+                set_val = mpark::get<1>(set.val);
+            } else {
+                set_val = mpark::get<0>(set.val) ? "ON" : "OFF";
+            }
+
+            if (set.cache) {
+                auto typ = set.val.index() == 1 ? "STRING" : "BOOL";
+                auto force = set.force ? "FORCE" : "";
+                cmd("set")(set.name, set_val, typ, set.comment, force);
+            } else {
+                cmd("set")(set.name, set_val);
+            }
+        }
+        endl();
+    }
+
+    // generate_cmake is called on the subdirectories recursively later
+    if (!cmake.subdirs.empty()) {
+        gen.handle_condition(cmake.subdirs, [&](const std::string &, const std::vector<std::string> &subdirs) {
+            for (const auto &dir : subdirs) {
+                // clang-format off
+                comment(dir);
+                cmd("set")("CMKR_CMAKE_FOLDER", "${CMAKE_FOLDER}");
+                cmd("if")("CMAKE_FOLDER");
+                    cmd("set")("CMAKE_FOLDER", "${CMAKE_FOLDER}/" + dir);
+                cmd("else")();
+                    cmd("set")("CMAKE_FOLDER", dir);
+                cmd("endif")();
+                // clang-format on
+
+                cmd("add_subdirectory")(dir);
+                cmd("set")("CMAKE_FOLDER", "${CMKR_CMAKE_FOLDER}").endl();
+            }
+        });
+        endl();
+    }
+
+    if (!cmake.targets.empty()) {
+        for (const auto &target : cmake.targets) {
+            comment("Target " + target.name);
+            cmd("set")("CMKR_TARGET", target.name);
+
+            gen.handle_condition(target.include_before,
+                                 [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+            gen.handle_condition(target.cmake_before, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+            auto sources_var = target.name + "_SOURCES";
+
+            bool added_toml = false;
+            cmd("set")(sources_var, RawArg("\"\"")).endl();
+            gen.handle_condition(target.sources, [&](const std::string &condition, const std::vector<std::string> &condition_sources) {
+                auto sources = expand_cmake_paths(condition_sources, path);
+                if (sources.empty()) {
+                    auto source_key = condition.empty() ? "sources" : (condition + ".sources");
+                    throw std::runtime_error(target.name + " " + source_key + " wildcard found 0 files");
+                }
+                // Do not add cmake.toml twice
+                if (!added_toml && std::find(sources.begin(), sources.end(), "cmake.toml") != sources.end()) {
+                    added_toml = true;
+                }
+                cmd("list")("APPEND", sources_var, sources);
+            });
+
+            if (!added_toml && target.type != cmake::target_interface) {
+                cmd("list")("APPEND", sources_var, std::vector<std::string>{"cmake.toml"}).endl();
+            }
+            cmd("set")("CMKR_SOURCES", "${" + sources_var + "}");
+
+            std::string add_command;
+            std::string target_type;
+            std::string target_scope;
+            switch (target.type) {
+            case cmake::target_executable:
+                add_command = "add_executable";
+                target_type = "";
+                target_scope = "PRIVATE";
+                break;
+            case cmake::target_library:
+                add_command = "add_library";
+                target_type = "";
+                target_scope = "PUBLIC";
+                break;
+            case cmake::target_shared:
+                add_command = "add_library";
+                target_type = "SHARED";
+                target_scope = "PUBLIC";
+                break;
+            case cmake::target_static:
+                add_command = "add_library";
+                target_type = "STATIC";
+                target_scope = "PUBLIC";
+                break;
+            case cmake::target_interface:
+                add_command = "add_library";
+                target_type = "INTERFACE";
+                target_scope = "INTERFACE";
+                break;
+            case cmake::target_custom:
+                // TODO: add proper support, this is hacky
+                add_command = "add_custom_target";
+                target_type = "SOURCES";
+                target_scope = "PUBLIC";
+                break;
+            default:
+                assert("Unimplemented enum value" && false);
+            }
+
+            cmd(add_command)(target.name, target_type).endl();
+
+            // clang-format off
+            cmd("if")(sources_var);
+                cmd("target_sources")(target.name, target.type == cmake::target_interface ? "INTERFACE" : "PRIVATE", "${" + sources_var + "}");
+            cmd("endif")().endl();
+            // clang-format on
+
+            // The first executable target will become the Visual Studio startup project
+            if (target.type == cmake::target_executable) {
+                cmd("get_directory_property")("CMKR_VS_STARTUP_PROJECT", "DIRECTORY", "${PROJECT_SOURCE_DIR}", "DEFINITION", "VS_STARTUP_PROJECT");
+                // clang-format off
+                cmd("if")("NOT", "CMKR_VS_STARTUP_PROJECT");
+                    cmd("set_property")("DIRECTORY", "${PROJECT_SOURCE_DIR}", "PROPERTY", "VS_STARTUP_PROJECT", target.name);
+                cmd("endif")().endl();
+                // clang-format on
+            }
+
+            if (!target.sources.empty()) {
+                cmd("source_group")("TREE", "${CMAKE_CURRENT_SOURCE_DIR}", "FILES", "${" + target.name + "_SOURCES}").endl();
+            }
+
+            if (!target.alias.empty()) {
+                cmd("add_library")(target.alias, "ALIAS", target.name);
+            }
+
+            auto target_cmd = [&](const char *command, const cmake::ConditionVector &cargs) {
+                gen.handle_condition(
+                    cargs, [&](const std::string &, const std::vector<std::string> &args) { cmd(command)(target.name, target_scope, args); });
+            };
+
+            target_cmd("target_compile_definitions", target.compile_definitions);
+            target_cmd("target_compile_features", target.compile_features);
+            target_cmd("target_compile_options", target.compile_options);
+            target_cmd("target_include_directories", target.include_directories);
+            target_cmd("target_link_directories", target.link_directories);
+            target_cmd("target_link_libraries", target.link_libraries);
+            target_cmd("target_precompile_headers", target.precompile_headers);
+
+            if (!target.properties.empty()) {
+                cmd("set_target_properties")(target.name, "PROPERTIES", target.properties).endl();
+            }
+
+            gen.handle_condition(target.include_after,
+                                 [&](const std::string &, const std::vector<std::string> &includes) { inject_includes(includes); });
+            gen.handle_condition(target.cmake_after, [&](const std::string &, const std::string &cmake) { inject_cmake(cmake); });
+
+            cmd("unset")("CMKR_TARGET");
+            cmd("unset")("CMKR_SOURCES");
+        }
+    }
+
+    if (!cmake.tests.empty()) {
+        cmd("enable_testing")().endl();
+        for (const auto &test : cmake.tests) {
+            auto name = std::make_pair("NAME", test.name);
+            auto configurations = std::make_pair("CONFIGURATIONS", test.configurations);
+            auto working_directory = std::make_pair("WORKING_DIRECTORY", test.working_directory);
+            auto command = std::make_pair("COMMAND", test.command);
+            auto arguments = std::make_pair("", test.arguments);
+            cmd("add_test")(name, configurations, working_directory, command, arguments).endl();
+        }
+    }
+
+    if (!cmake.installs.empty()) {
+        for (const auto &inst : cmake.installs) {
+            auto targets = std::make_pair("TARGETS", inst.targets);
+            auto dirs = std::make_pair("DIRS", inst.dirs);
+            std::vector<std::string> files_data;
+            if (!inst.files.empty()) {
+                files_data = expand_cmake_paths(inst.files, path);
+                if (files_data.empty()) {
+                    throw std::runtime_error("[[install]] files wildcard did not resolve to any files");
+                }
+            }
+            auto files = std::make_pair("FILES", inst.files);
+            auto configs = std::make_pair("CONFIGURATIONS", inst.configs);
+            auto destination = std::make_pair("DESTINATION", inst.destination);
+            auto component = std::make_pair("COMPONENT", inst.targets.empty() ? "" : inst.targets.front());
+            cmd("install")(targets, dirs, files, configs, destination, component);
+        }
+    }
+
+    // Generate CMakeLists.txt
+    auto list_path = fs::path(path) / "CMakeLists.txt";
+
+    auto should_regenerate = [&list_path, &ss]() {
+        if (!fs::exists(list_path))
+            return true;
+
+        std::ifstream ifs(list_path, std::ios_base::binary);
+        if (!ifs.is_open()) {
+            throw std::runtime_error("Failed to read " + list_path.string());
+        }
+
+        std::string data((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
+        return data != ss.str();
+    }();
+
+    if (should_regenerate) {
+        std::ofstream ofs(list_path, std::ios_base::binary);
+        if (ofs.is_open()) {
+            ofs << ss.str();
+        } else {
+            throw std::runtime_error("Failed to write " + list_path.string());
+        }
+    }
+
+    for (const auto &itr : cmake.subdirs) {
+        for (const auto &sub : itr.second) {
+            auto subpath = fs::path(path) / fs::path(sub);
+            if (fs::exists(subpath / "cmake.toml"))
+                generate_cmake(subpath.string().c_str(), false);
+        }
+    }
+
+    return 0;
+}
+} // namespace gen
+} // namespace cmkr
+
+int cmkr_gen_generate_project(const char *typ) {
+    try {
+        return cmkr::gen::generate_project(typ);
+    } catch (const std::system_error &e) {
+        return e.code().value();
+    } catch (...) {
+        return cmkr::error::Status(cmkr::error::Status::Code::InitError);
+    }
+}
+
+int cmkr_gen_generate_cmake(const char *path) {
+    try {
+        return cmkr::gen::generate_cmake(path);
+    } catch (const std::system_error &e) {
+        return e.code().value();
+    } catch (...) {
+        return cmkr::error::Status(cmkr::error::Status::Code::GenerationError);
+    }
+}

src/help.cpp

@@ -1,12 +1,9 @@
 #include "help.hpp"
-#include <resources/version.hpp>
 
 namespace cmkr {
 namespace help {
 
-const char *version() noexcept {
+const char *version() noexcept { return "cmkr version 0.1.3"; }
-    return "cmkr version " CMKR_VERSION;
-}
 
 const char *message() noexcept {
     return R"lit(
@@ -23,3 +20,7 @@ arguments:
 }
 } // namespace help
 } // namespace cmkr
+
+const char *cmkr_help_version(void) { return cmkr::help::version(); }
+
+const char *cmkr_help_message(void) { return cmkr::help::message(); }

src/main.cpp

@@ -1,4 +1,4 @@
-#include "arguments.hpp"
+#include "args.hpp"
 
 #include <cstdio>
 #include <cstdlib>

src/project_parser.cpp

@@ -1,901 +0,0 @@
-#include "project_parser.hpp"
-
-#include "fs.hpp"
-#include <deque>
-#include <stdexcept>
-#include <toml.hpp>
-
-namespace cmkr {
-namespace parser {
-
-const char *targetTypeNames[target_last] = {"executable", "library", "shared", "static", "interface", "custom", "object", "template"};
-
-static TargetType parse_targetType(const std::string &name) {
-    for (int i = 0; i < target_last; i++) {
-        if (name == targetTypeNames[i]) {
-            return static_cast<TargetType>(i);
-        }
-    }
-    return target_last;
-}
-
-const char *msvcRuntimeTypeNames[msvc_last] = {"dynamic", "static"};
-
-static MsvcRuntimeType parse_msvcRuntimeType(const std::string &name) {
-    for (int i = 0; i < msvc_last; i++) {
-        if (name == msvcRuntimeTypeNames[i]) {
-            return static_cast<MsvcRuntimeType>(i);
-        }
-    }
-    return msvc_last;
-}
-
-using TomlBasicValue = toml::basic_value<toml::discard_comments, tsl::ordered_map, std::vector>;
-
-static std::string format_key_message(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
-    auto loc = value.location();
-    auto line_number_str = std::to_string(loc.line());
-    auto line_width = line_number_str.length();
-    const auto &line_str = loc.line_str();
-
-    std::ostringstream oss;
-    oss << message << "\n";
-    oss << " --> " << loc.file_name() << ':' << loc.line() << '\n';
-
-    oss << std::string(line_width + 2, ' ') << "|\n";
-    oss << ' ' << line_number_str << " | " << line_str << '\n';
-
-    oss << std::string(line_width + 2, ' ') << '|';
-    auto key_start = line_str.substr(0, loc.column() - 1).rfind(ky);
-    if (key_start == std::string::npos) {
-        key_start = line_str.find(ky);
-    }
-    if (key_start != std::string::npos) {
-        oss << std::string(key_start + 1, ' ') << std::string(ky.length(), '~');
-    }
-
-    return oss.str();
-}
-
-static void throw_key_error(const std::string &error, const toml::key &ky, const TomlBasicValue &value) {
-    throw std::runtime_error(format_key_message("[error] " + error, ky, value));
-}
-
-static void print_key_warning(const std::string &message, const toml::key &ky, const TomlBasicValue &value) {
-    puts(format_key_message("[warning] " + message, ky, value).c_str());
-}
-
-class TomlChecker {
-    const TomlBasicValue &m_v;
-    tsl::ordered_set<toml::key> m_visited;
-    tsl::ordered_set<toml::key> m_conditionVisited;
-
-  public:
-    TomlChecker(const TomlBasicValue &v, const toml::key &ky) : m_v(toml::find(v, ky)) {
-    }
-    explicit TomlChecker(const TomlBasicValue &v) : m_v(v) {
-    }
-    TomlChecker(const TomlChecker &) = delete;
-    TomlChecker(TomlChecker &&) = delete;
-
-    template <typename T>
-    void optional(const toml::key &ky, Condition<T> &destination) {
-        // TODO: this algorithm in O(n) over the amount of keys, kinda bad
-        const auto &table = m_v.as_table();
-        for (const auto &itr : table) {
-            const auto &key = itr.first;
-            const auto &value = itr.second;
-            if (value.is_table()) {
-                if (value.contains(ky)) {
-                    destination[key] = toml::find<T>(value, ky);
-                }
-            } else if (key == ky) {
-                destination[""] = toml::find<T>(m_v, ky);
-            }
-        }
-
-        // Handle visiting logic
-        for (const auto &itr : destination) {
-            if (!itr.first.empty()) {
-                m_conditionVisited.emplace(itr.first);
-            }
-        }
-        visit(ky);
-    }
-
-    template <typename T>
-    void optional(const toml::key &ky, T &destination) {
-        // TODO: this currently doesn't allow you to get an optional map<string, X>
-        if (m_v.contains(ky)) {
-            destination = toml::find<T>(m_v, ky);
-        }
-        visit(ky);
-    }
-
-    template <typename T>
-    void required(const toml::key &ky, T &destination) {
-        destination = toml::find<T>(m_v, ky);
-        visit(ky);
-    }
-
-    bool contains(const toml::key &ky) {
-        visit(ky);
-        return m_v.contains(ky);
-    }
-
-    const TomlBasicValue &find(const toml::key &ky) {
-        visit(ky);
-        return toml::find(m_v, ky);
-    }
-
-    void visit(const toml::key &ky) {
-        m_visited.emplace(ky);
-    }
-
-    bool visisted(const toml::key &ky) const {
-        return m_visited.contains(ky);
-    }
-
-    void check(const tsl::ordered_map<std::string, std::string> &conditions) const {
-        for (const auto &itr : m_v.as_table()) {
-            const auto &ky = itr.first;
-            if (m_conditionVisited.contains(ky)) {
-                if (!conditions.contains(ky) && Project::is_condition_name(ky)) {
-                    throw_key_error("Unknown condition '" + ky + "'", ky, itr.second);
-                }
-
-                for (const auto &jtr : itr.second.as_table()) {
-                    if (!m_visited.contains(jtr.first)) {
-                        throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
-                    }
-                }
-            } else if (!m_visited.contains(ky)) {
-                if (itr.second.is_table()) {
-                    for (const auto &jtr : itr.second.as_table()) {
-                        if (!m_visited.contains(jtr.first)) {
-                            throw_key_error("Unknown key '" + jtr.first + "'", jtr.first, jtr.second);
-                        }
-                    }
-                }
-                throw_key_error("Unknown key '" + ky + "'", ky, itr.second);
-            } else if (ky == "condition") {
-                std::string condition = itr.second.as_string();
-                if (!conditions.contains(condition) && Project::is_condition_name(condition)) {
-                    throw_key_error("Unknown condition '" + condition + "'", condition, itr.second);
-                }
-            }
-        }
-    }
-};
-
-class TomlCheckerRoot {
-    const TomlBasicValue &m_root;
-    std::deque<TomlChecker> m_checkers;
-    tsl::ordered_set<toml::key> m_visisted;
-    bool m_checked = false;
-
-  public:
-    explicit TomlCheckerRoot(const TomlBasicValue &root) : m_root(root) {
-    }
-    TomlCheckerRoot(const TomlCheckerRoot &) = delete;
-    TomlCheckerRoot(TomlCheckerRoot &&) = delete;
-
-    bool contains(const toml::key &ky) {
-        m_visisted.emplace(ky);
-        return m_root.contains(ky);
-    }
-
-    TomlChecker &create(const TomlBasicValue &v) {
-        m_checkers.emplace_back(v);
-        return m_checkers.back();
-    }
-
-    TomlChecker &create(const TomlBasicValue &v, const toml::key &ky) {
-        m_checkers.emplace_back(v, ky);
-        return m_checkers.back();
-    }
-
-    void check(const tsl::ordered_map<std::string, std::string> &conditions, bool check_root) {
-        if (check_root) {
-            for (const auto &itr : m_root.as_table()) {
-                if (!m_visisted.contains(itr.first)) {
-                    throw_key_error("Unknown key '" + itr.first + "'", itr.first, itr.second);
-                }
-            }
-        }
-        for (const auto &checker : m_checkers) {
-            checker.check(conditions);
-        }
-    }
-};
-
-Project::Project(const Project *parent, const std::string &path, bool build) : parent(parent) {
-    const auto toml_path = fs::path(path) / "cmake.toml";
-    if (!fs::exists(toml_path)) {
-        throw std::runtime_error("File not found '" + toml_path.string() + "'");
-    }
-    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
-    if (toml.size() == 0) {
-        throw std::runtime_error("Empty TOML '" + toml_path.string() + "'");
-    }
-
-    TomlCheckerRoot checker(toml);
-
-    if (checker.contains("cmake")) {
-        auto &cmake = checker.create(toml, "cmake");
-
-        cmake.required("version", cmake_version);
-
-        if (cmake.contains("bin-dir")) {
-            throw_key_error("bin-dir has been renamed to build-dir", "bin-dir", cmake.find("bin-dir"));
-        }
-
-        cmake.optional("build-dir", build_dir);
-        cmake.optional("generator", generator);
-        cmake.optional("config", config);
-        cmake.optional("arguments", gen_args);
-        cmake.optional("allow-in-tree", allow_in_tree);
-
-        if (cmake.contains("cmkr-include")) {
-            const auto &cmkr_include_kv = cmake.find("cmkr-include");
-            if (cmkr_include_kv.is_string()) {
-                cmkr_include = cmkr_include_kv.as_string();
-            } else {
-                // Allow disabling this feature with cmkr-include = false
-                cmkr_include = "";
-            }
-        }
-
-        cmake.optional("cpp-flags", cppflags);
-        cmake.optional("c-flags", cflags);
-        cmake.optional("link-flags", linkflags);
-    }
-
-    // Skip the rest of the parsing when building
-    if (build) {
-        checker.check(conditions, false);
-        return;
-    }
-
-    // Reasonable default conditions (you can override these if you desire)
-    if (parent == nullptr) {
-        conditions["windows"] = R"cmake(WIN32)cmake";
-        conditions["macos"] = R"cmake(CMAKE_SYSTEM_NAME MATCHES "Darwin")cmake";
-        conditions["unix"] = R"cmake(UNIX)cmake";
-        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["clang-cl"] =
-            R"cmake((CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$") OR (CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_C_COMPILER_FRONTEND_VARIANT MATCHES "^MSVC$"))cmake";
-        conditions["clang-any"] = R"cmake(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID MATCHES "Clang")cmake";
-        conditions["root"] = R"cmake(CMKR_ROOT_PROJECT)cmake";
-        conditions["x64"] = R"cmake(CMAKE_SIZEOF_VOID_P EQUAL 8)cmake";
-        conditions["x32"] = R"cmake(CMAKE_SIZEOF_VOID_P EQUAL 4)cmake";
-        conditions["android"] = R"cmake(ANDROID)cmake";
-        conditions["apple"] = R"cmake(APPLE)cmake";
-        conditions["bsd"] = R"cmake(BSD)cmake";
-        conditions["cygwin"] = R"cmake(CYGWIN)cmake";
-        conditions["ios"] = R"cmake(IOS)cmake";
-        conditions["xcode"] = R"cmake(XCODE)cmake";
-        conditions["wince"] = R"cmake(WINCE)cmake";
-    } else {
-        conditions = parent->conditions;
-        templates = parent->templates;
-    }
-
-    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;
-        }
-    }
-
-    if (checker.contains("project")) {
-        auto &project = checker.create(toml, "project");
-        project.required("name", project_name);
-        project.optional("version", project_version);
-        project.optional("description", project_description);
-        project.optional("languages", project_languages);
-        project.optional("allow-unknown-languages", project_allow_unknown_languages);
-        project.optional("cmake-before", cmake_before);
-        project.optional("cmake-after", cmake_after);
-        project.optional("include-before", include_before);
-        project.optional("include-after", include_after);
-        project.optional("subdirs", project_subdirs);
-
-        std::string msvc_runtime;
-        project.optional("msvc-runtime", msvc_runtime);
-        if (!msvc_runtime.empty()) {
-            project_msvc_runtime = parse_msvcRuntimeType(msvc_runtime);
-            if (project_msvc_runtime == msvc_last) {
-                std::string error = "Unknown runtime '" + msvc_runtime + "'\n";
-                error += "Available types:\n";
-                for (std::string type_name : msvcRuntimeTypeNames) {
-                    error += "  - " + type_name + "\n";
-                }
-                error.pop_back(); // Remove last newline
-                throw_key_error(error, msvc_runtime, project.find("msvc-runtime"));
-            }
-        }
-    }
-
-    if (checker.contains("subdir")) {
-        const auto &subs = toml::find(toml, "subdir").as_table();
-        for (const auto &itr : subs) {
-            Subdir subdir;
-            subdir.name = itr.first;
-
-            auto &sub = checker.create(itr.second);
-            sub.optional("condition", subdir.condition);
-            sub.optional("cmake-before", subdir.cmake_before);
-            sub.optional("cmake-after", subdir.cmake_after);
-            sub.optional("include-before", subdir.include_before);
-            sub.optional("include-after", subdir.include_after);
-
-            subdirs.push_back(subdir);
-        }
-    }
-
-    if (checker.contains("variables")) {
-        using set_map = tsl::ordered_map<std::string, TomlBasicValue>;
-        auto vars = toml::find<set_map>(toml, "variables");
-        if (checker.contains("settings")) {
-            print_key_warning("[settings] has been renamed to [variables]", "settings", toml.at("settings"));
-            const auto &sets = toml::find<set_map>(toml, "settings");
-            for (const auto &itr : sets) {
-                if (!vars.insert(itr).second) {
-                    throw_key_error("Key '" + itr.first + "' shadows existing variable", itr.first, itr.second);
-                }
-            }
-        }
-
-        for (const auto &itr : vars) {
-            Variable s;
-            s.name = itr.first;
-            const auto &value = itr.second;
-            if (value.is_boolean()) {
-                s.value = value.as_boolean();
-            } else if (value.is_string()) {
-                s.value = value.as_string();
-            } else {
-                auto &setting = checker.create(value);
-                setting.optional("help", s.help);
-                if (setting.contains("value")) {
-                    const auto &v = setting.find("value");
-                    if (v.is_boolean()) {
-                        s.value = v.as_boolean();
-                    } else {
-                        s.value = v.as_string();
-                    }
-                }
-                setting.optional("cache", s.cache);
-                setting.optional("force", s.force);
-            }
-            variables.push_back(s);
-        }
-    }
-
-    if (checker.contains("options")) {
-        auto normalize = [](const std::string &name) {
-            std::string normalized;
-            for (char ch : name) {
-                if (ch == '_') {
-                    normalized += '-';
-                } else if (ch >= 'A' && ch <= 'Z') {
-                    ch += ('a' - 'A');
-                    normalized += ch;
-                } else if (ch == '-' || (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z')) {
-                    normalized += ch;
-                } else {
-                    // Ignore all other characters
-                }
-            }
-            return normalized;
-        };
-        auto nproject_prefix = normalize(project_name);
-        nproject_prefix += '-';
-
-        using opts_map = tsl::ordered_map<std::string, TomlBasicValue>;
-        const auto &opts = toml::find<opts_map>(toml, "options");
-        for (const auto &itr : opts) {
-            Option o;
-            o.name = itr.first;
-            const auto &value = itr.second;
-            if (value.is_boolean()) {
-                o.value = value.as_boolean();
-            } else if (value.is_string()) {
-                auto str = std::string(value.as_string());
-                if (str == "root") {
-                    o.value = std::string("${CMKR_ROOT_PROJECT}");
-                } else {
-                    throw_key_error("Unsupported option value '" + str + "'", str, value);
-                }
-            } else if (value.is_table()) {
-                auto &option = checker.create(value);
-                option.optional("help", o.help);
-                if (option.contains("value")) {
-                    const auto &ovalue = option.find("value");
-                    if (ovalue.is_boolean()) {
-                        o.value = ovalue.as_boolean();
-                    } else if (ovalue.is_string()) {
-                        auto str = std::string(ovalue.as_string());
-                        if (str == "root") {
-                            o.value = std::string("${CMKR_ROOT_PROJECT}");
-                        } else {
-                            throw_key_error("Unsupported option value '" + str + "'", str, value);
-                        }
-                    } else {
-                        throw_key_error(toml::concat_to_string("Unsupported value type: ", ovalue.type()), "value", value);
-                    }
-                }
-            } else {
-                throw_key_error(toml::concat_to_string("Unsupported value type: ", itr.second.type()), itr.first, itr.second);
-            }
-            options.push_back(o);
-
-            // Add a condition matching the option name
-            conditions.emplace(o.name, o.name);
-
-            // Add an implicit condition for the option
-            auto ncondition = normalize(o.name);
-            if (ncondition.find(nproject_prefix) == 0) {
-                ncondition = ncondition.substr(nproject_prefix.size());
-            }
-            if (!ncondition.empty()) {
-                if (conditions.contains(ncondition)) {
-                    print_key_warning("Option '" + o.name + "' would create a condition '" + ncondition + "' that already exists", o.name, value);
-                }
-                conditions.emplace(ncondition, o.name);
-            }
-        }
-    }
-
-    if (checker.contains("find-package")) {
-        using pkg_map = tsl::ordered_map<std::string, TomlBasicValue>;
-        const auto &pkgs = toml::find<pkg_map>(toml, "find-package");
-        for (const auto &itr : pkgs) {
-            Package p;
-            p.name = itr.first;
-            const auto &value = itr.second;
-            if (itr.second.is_string()) {
-                p.version = itr.second.as_string();
-            } else {
-                auto &pkg = checker.create(value);
-                pkg.optional("condition", p.condition);
-                pkg.optional("version", p.version);
-                pkg.optional("required", p.required);
-                pkg.optional("config", p.config);
-                pkg.optional("components", p.components);
-            }
-            packages.push_back(p);
-        }
-    }
-
-    if (checker.contains("fetch-content")) {
-        const auto &fc = toml::find(toml, "fetch-content").as_table();
-        for (const auto &itr : fc) {
-            Content content;
-            content.name = itr.first;
-
-            auto &c = checker.create(itr.second);
-            c.optional("condition", content.condition);
-            c.optional("cmake-before", content.cmake_before);
-            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;
-                if (argItr.second.is_array()) {
-                    for (const auto &list_val : argItr.second.as_array()) {
-                        if (!value.empty()) {
-                            value += ';';
-                        }
-                        value += list_val.as_string();
-                    }
-                } else if (argItr.second.is_boolean()) {
-                    value = argItr.second.as_boolean() ? "ON" : "OFF";
-                } else {
-                    value = argItr.second.as_string();
-                }
-
-                auto is_cmake_arg = [](const std::string &s) {
-                    for (auto c : s) {
-                        if (!(std::isdigit(c) || std::isupper(c) || c == '_')) {
-                            return false;
-                        }
-                    }
-                    return true;
-                };
-
-                // https://cmake.org/cmake/help/latest/command/string.html#supported-hash-algorithms
-                tsl::ordered_set<std::string> hash_algorithms = {
-                    "md5", "sha1", "sha224", "sha256", "sha384", "sha512", "sha3_224", "sha3_256", "sha3_384", "sha3_512",
-                };
-
-                auto key = argItr.first;
-                if (key == "git") {
-                    key = "GIT_REPOSITORY";
-                } else if (key == "tag") {
-                    key = "GIT_TAG";
-                } else if (key == "shallow") {
-                    key = "GIT_SHALLOW";
-                } else if (key == "svn") {
-                    key = "SVN_REPOSITORY";
-                } else if (key == "rev") {
-                    key = "SVN_REVISION";
-                } else if (key == "url") {
-                    key = "URL";
-                } else if (hash_algorithms.contains(key)) {
-                    std::string algo;
-                    for (auto ch : key) {
-                        if (ch >= 'a' && ch <= 'z') {
-                            ch -= ('a' - 'A');
-                        }
-                        algo.push_back(ch);
-                    }
-                    key = "URL_HASH";
-                    value = algo + "=" + value;
-                } else if (key == "hash") {
-                    key = "URL_HASH";
-                } else if (key == "subdir") {
-                    key = "SOURCE_SUBDIR";
-                } else if (is_cmake_arg(key)) {
-                    // allow passthrough of ExternalProject options
-                } else if (!c.visisted(key)) {
-                    throw_key_error("Unknown key '" + argItr.first + "'", argItr.first, argItr.second);
-                }
-
-                // Make sure not to emit keys like "condition" in the FetchContent call
-                if (!c.visisted(key)) {
-                    content.arguments.emplace(key, value);
-                }
-
-                c.visit(argItr.first);
-            }
-            contents.emplace_back(std::move(content));
-        }
-    }
-
-    if (checker.contains("bin")) {
-        throw_key_error("[[bin]] has been renamed to [target.<name>]", "", toml.at("bin"));
-    }
-
-    auto parse_target = [&](const std::string &name, TomlChecker &t, bool isTemplate) {
-        Target target;
-        target.name = name;
-
-        t.required("type", target.type_name);
-        target.type = parse_targetType(target.type_name);
-
-        // Users cannot set this target type
-        if (target.type == target_template) {
-            target.type = target_last;
-        }
-
-        if (!isTemplate && target.type == target_last) {
-            for (const auto &tmplate : templates) {
-                if (target.type_name == tmplate.outline.name) {
-                    target.type = target_template;
-                    break;
-                }
-            }
-        }
-
-        if (target.type == target_last) {
-            std::string error = "Unknown target type '" + target.type_name + "'\n";
-            error += "Available types:\n";
-            for (std::string type_name : targetTypeNames) {
-                if (type_name != "template") {
-                    error += "  - " + type_name + "\n";
-                }
-            }
-            if (!isTemplate && !templates.empty()) {
-                error += "Available templates:\n";
-                for (const auto &tmplate : templates) {
-                    error += "  - " + tmplate.outline.name + "\n";
-                }
-            }
-            error.pop_back(); // Remove last newline
-            throw_key_error(error, target.type_name, t.find("type"));
-        }
-
-        t.optional("sources", target.sources);
-
-        // Merge the headers into the sources
-        ConditionVector headers;
-        t.optional("headers", headers);
-        for (const auto &itr : headers) {
-            auto &dest = target.sources[itr.first];
-            for (const auto &jtr : itr.second) {
-                dest.push_back(jtr);
-            }
-        }
-
-        t.optional("compile-definitions", target.compile_definitions);
-        t.optional("private-compile-definitions", target.private_compile_definitions);
-
-        t.optional("compile-features", target.compile_features);
-        t.optional("private-compile-features", target.private_compile_features);
-
-        t.optional("compile-options", target.compile_options);
-        t.optional("private-compile-options", target.private_compile_options);
-
-        t.optional("include-directories", target.include_directories);
-        t.optional("private-include-directories", target.private_include_directories);
-
-        t.optional("link-directories", target.link_directories);
-        t.optional("private-link-directories", target.private_link_directories);
-
-        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);
-
-        t.optional("precompile-headers", target.precompile_headers);
-        t.optional("private-precompile-headers", target.private_precompile_headers);
-
-        Condition<std::string> msvc_runtime;
-        t.optional("msvc-runtime", msvc_runtime);
-        for (const auto &cond_itr : msvc_runtime) {
-            switch (parse_msvcRuntimeType(cond_itr.second)) {
-            case msvc_dynamic:
-                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL";
-                break;
-            case msvc_static:
-                target.properties[cond_itr.first]["MSVC_RUNTIME_LIBRARY"] = "MultiThreaded$<$<CONFIG:Debug>:Debug>";
-                break;
-            default: {
-                std::string error = "Unknown runtime '" + cond_itr.second + "'\n";
-                error += "Available types:\n";
-                for (std::string type_name : msvcRuntimeTypeNames) {
-                    error += "  - " + type_name + "\n";
-                }
-                error.pop_back(); // Remove last newline
-                const TomlBasicValue *report;
-                if (cond_itr.first.empty()) {
-                    report = &t.find("msvc-runtime");
-                } else {
-                    report = &t.find(cond_itr.first).as_table().find("msvc-runtime").value();
-                }
-                throw_key_error(error, cond_itr.second, *report);
-            }
-            }
-        }
-
-        t.optional("condition", target.condition);
-        t.optional("alias", target.alias);
-
-        if (t.contains("properties")) {
-            auto store_property = [&target](const toml::key &k, const TomlBasicValue &v, const std::string &condition) {
-                if (v.is_array()) {
-                    std::string property_list;
-                    for (const auto &list_val : v.as_array()) {
-                        if (!property_list.empty()) {
-                            property_list += ';';
-                        }
-                        property_list += list_val.as_string();
-                    }
-                    target.properties[condition][k] = property_list;
-                } else if (v.is_boolean()) {
-                    target.properties[condition][k] = v.as_boolean() ? "ON" : "OFF";
-                } else {
-                    target.properties[condition][k] = v.as_string();
-                }
-            };
-
-            const auto &props = t.find("properties").as_table();
-            for (const auto &propKv : props) {
-                const auto &k = propKv.first;
-                const auto &v = propKv.second;
-                if (v.is_table()) {
-                    for (const auto &condKv : v.as_table()) {
-                        store_property(condKv.first, condKv.second, k);
-                    }
-                } else {
-                    store_property(k, v, "");
-                }
-            }
-        }
-
-        t.optional("cmake-before", target.cmake_before);
-        t.optional("cmake-after", target.cmake_after);
-        t.optional("include-before", target.include_before);
-        t.optional("include-after", target.include_after);
-
-        return target;
-    };
-
-    if (checker.contains("template")) {
-        const auto &ts = toml::find(toml, "template").as_table();
-        for (const auto &itr : ts) {
-            auto &t = checker.create(itr.second);
-            const auto &name = itr.first;
-
-            for (const auto &type_name : targetTypeNames) {
-                if (name == type_name) {
-                    throw_key_error("Reserved template name '" + name + "'", name, itr.second);
-                }
-            }
-
-            for (const auto &tmplate : templates) {
-                if (name == tmplate.outline.name) {
-                    throw_key_error("Template '" + name + "' already defined", name, itr.second);
-                }
-            }
-
-            Template tmplate;
-            tmplate.outline = parse_target(name, t, true);
-
-            t.optional("add-function", tmplate.add_function);
-            t.optional("pass-sources-to-add-function", tmplate.pass_sources_to_add_function);
-            t.optional("pass-sources", tmplate.pass_sources_to_add_function);
-
-            templates.push_back(tmplate);
-        }
-    }
-
-    if (checker.contains("target")) {
-        const auto &ts = toml::find(toml, "target").as_table();
-        for (const auto &itr : ts) {
-            auto &t = checker.create(itr.second);
-            targets.push_back(parse_target(itr.first, t, false));
-        }
-    }
-
-    if (checker.contains("test")) {
-        const auto &ts = toml::find(toml, "test").as_array();
-        for (const auto &value : ts) {
-            auto &t = checker.create(value);
-            Test test;
-            t.required("name", test.name);
-            t.optional("condition", test.condition);
-            t.optional("configurations", test.configurations);
-            t.optional("working-directory", test.working_directory);
-            t.required("command", test.command);
-            t.optional("arguments", test.arguments);
-            tests.push_back(test);
-        }
-    }
-
-    if (checker.contains("install")) {
-        const auto &is = toml::find(toml, "install").as_array();
-        for (const auto &value : is) {
-            auto &i = checker.create(value);
-            Install inst;
-            i.optional("condition", inst.condition);
-            i.optional("targets", inst.targets);
-            i.optional("files", inst.files);
-            i.optional("dirs", inst.dirs);
-            i.optional("configs", inst.configs);
-            i.required("destination", inst.destination);
-            i.optional("component", inst.component);
-            i.optional("optional", inst.optional);
-            installs.push_back(inst);
-        }
-    }
-
-    if (checker.contains("vcpkg")) {
-        auto &v = checker.create(toml, "vcpkg");
-        v.optional("url", vcpkg.url);
-        v.optional("version", vcpkg.version);
-
-        for (const auto &p : v.find("packages").as_array()) {
-            Vcpkg::Package package;
-            const auto &package_str = p.as_string().str;
-            const auto open_bracket = package_str.find('[');
-            const auto close_bracket = package_str.find(']', open_bracket);
-            if (open_bracket == std::string::npos && close_bracket == std::string::npos) {
-                package.name = package_str;
-            } else if (close_bracket != std::string::npos) {
-                package.name = package_str.substr(0, open_bracket);
-                const auto features = package_str.substr(open_bracket + 1, close_bracket - open_bracket - 1);
-                std::istringstream feature_stream{features};
-                std::string feature;
-                while (std::getline(feature_stream, feature, ',')) {
-                    package.features.emplace_back(feature);
-                }
-            } else {
-                throw_key_error("Invalid package name '" + package_str + "'", "packages", p);
-            }
-            vcpkg.packages.emplace_back(std::move(package));
-        }
-    }
-
-    checker.check(conditions, true);
-}
-
-const Project *Project::root() const {
-    auto root = this;
-    while (root->parent != nullptr)
-        root = root->parent;
-    return root;
-}
-
-bool Project::cmake_minimum_version(int major, int minor) const {
-    // NOTE: this code is like pulling teeth, sorry
-    auto root_version = root()->cmake_version;
-    auto range_index = root_version.find("...");
-    if (range_index != std::string::npos) {
-        root_version.resize(range_index);
-    }
-
-    auto period_index = root_version.find('.');
-    auto root_major = atoi(root_version.substr(0, period_index).c_str());
-    int root_minor = 0;
-    if (period_index != std::string::npos) {
-        auto end_index = root_version.find('.', period_index + 1);
-        root_minor = atoi(root_version.substr(period_index + 1, end_index).c_str());
-    }
-
-    return std::tie(root_major, root_minor) >= std::tie(major, minor);
-}
-
-bool Project::is_condition_name(const std::string &name) {
-    for (auto ch : name) {
-        if (!std::isalnum(ch) && ch != '-' && ch != '_') {
-            return false;
-        }
-    }
-    return true;
-}
-
-bool is_root_path(const std::string &path) {
-    const auto toml_path = fs::path(path) / "cmake.toml";
-    if (!fs::exists(toml_path)) {
-        return false;
-    }
-    const auto toml = toml::parse<toml::discard_comments, tsl::ordered_map, std::vector>(toml_path.string());
-    return toml.contains("project");
-}
-
-} // namespace parser
-} // namespace cmkr

tests/.gitignore

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

tests/CMakeLists.txt

@@ -14,27 +14,7 @@ add_test(
 	WORKING_DIRECTORY
 		"${CMAKE_CURRENT_LIST_DIR}/basic"
 	COMMAND
-		"$<TARGET_FILE:cmkr>"
+		$<TARGET_FILE:cmkr>
-		build
-)
-
-add_test(
-	NAME
-		interface
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/interface"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
-		build
-)
-
-add_test(
-	NAME
-		fetch-content
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/fetch-content"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
 		build
 )
 
@@ -44,81 +24,17 @@ add_test(
 	WORKING_DIRECTORY
 		"${CMAKE_CURRENT_LIST_DIR}/conditions"
 	COMMAND
-		"$<TARGET_FILE:cmkr>"
+		$<TARGET_FILE:cmkr>
-		build
-)
-
-add_test(
-	NAME
-		vcpkg
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/vcpkg"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
-		build
-)
-
-add_test(
-	NAME
-		cxx-standard
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/cxx-standard"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
 		build
 )
 
 add_test(
 	NAME
-		globbing
+		interface
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/globbing"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
-		build
-)
-
-add_test(
-	NAME
-		templates
-	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/templates"
-	COMMAND
-		"$<TARGET_FILE:cmkr>"
-		build
-)
-
-if(MSVC) # msvc
-	add_test(
-		NAME
-			msvc-runtime
-		WORKING_DIRECTORY
-			"${CMAKE_CURRENT_LIST_DIR}/msvc-runtime"
-		COMMAND
-			"$<TARGET_FILE:cmkr>"
-			build
-	)
-
-endif()
-add_test(
-	NAME
-		compile-options
 	WORKING_DIRECTORY
-		"${CMAKE_CURRENT_LIST_DIR}/compile-options"
+		"${CMAKE_CURRENT_LIST_DIR}/interface"
 	COMMAND
-		"$<TARGET_FILE:cmkr>"
+		$<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

@@ -1,11 +1,9 @@
-# A minimal `cmake.toml` project:
+[cmake]
+version = "3.5"
 
 [project]
 name = "basic"
-description = "Minimal example"
 
 [target.basic]
 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)`.

tests/cmake.toml

@@ -1,67 +1,17 @@
 [[test]]
 name = "basic"
-working-directory = "basic"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "interface"
-working-directory = "interface"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "fetch-content"
-working-directory = "fetch-content"
 command = "$<TARGET_FILE:cmkr>"
+working-directory = "${CMAKE_CURRENT_LIST_DIR}/basic"
 arguments = ["build"]
 
 [[test]]
 name = "conditions"
-working-directory = "conditions"
 command = "$<TARGET_FILE:cmkr>"
+working-directory = "${CMAKE_CURRENT_LIST_DIR}/conditions"
 arguments = ["build"]
 
 [[test]]
-name = "vcpkg"
+name = "interface"
-working-directory = "vcpkg"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "cxx-standard"
-working-directory = "cxx-standard"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "globbing"
-working-directory = "globbing"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "templates"
-working-directory = "templates"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-condition = "msvc"
-name = "msvc-runtime"
-working-directory = "msvc-runtime"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-name = "compile-options"
-working-directory = "compile-options"
-command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
-
-[[test]]
-condition = "windows"
-name = "relative-paths"
-working-directory = "relative-paths"
 command = "$<TARGET_FILE:cmkr>"
-arguments = ["build"]
+working-directory = "${CMAKE_CURRENT_LIST_DIR}/interface"
+arguments = ["build"]

tests/compile-options/cmake.toml

@@ -1,15 +0,0 @@
-# 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/conditions/cmake.toml

@@ -1,28 +1,17 @@
-[project]
+[project]
-name = "conditions"
+name = "conditions"
-cmake-after = "set(CUSTOM ON)"
+cmake-after = "set(CUSTOM ON)"
-
+
-[options]
+[conditions]
-CONDITIONS_BUILD_TESTS = "root"
+custom = "CUSTOM"
-
+
-[conditions]
+[target.example]
-custom = "CUSTOM"
+type = "executable"
-
+sources = ["src/main.cpp"]
-[target.example]
+windows.sources = ["src/windows_specific.cpp"]
-type = "executable"
+cmake-after = "message(STATUS cmake-after)"
-sources = ["src/main.cpp"]
+windows.cmake-after = "message(STATUS win32-after)"
-windows.sources = ["src/windows_specific.cpp"]
+macos.cmake-after = "message(STATUS macos-after)"
-cmake-after = "message(STATUS cmake-after)"
+linux.cmake-after = "message(STATUS linux-after)"
-windows.cmake-after = "message(STATUS win32-after)"
+unix.cmake-after = "message(STATUS unix-after)"
-macos.cmake-after = "message(STATUS macos-after)"
+custom.cmake-after = "message(STATUS custom-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 @@
-int main() {
+int main() { }
-}

tests/conditions/src/win32.cpp

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

tests/cxx-standard/cmake.toml

@@ -1,12 +0,0 @@
-# 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 +0,0 @@
-#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

@@ -1,15 +0,0 @@
-# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) from [GitHub](https://github.com) and links an `example` target to it:
-
-[project]
-name = "fetch-content"
-description = "Fetching from git"
-
-[fetch-content]
-fmt = { git = "https://github.com/fmtlib/fmt", tag = "7.1.3" }
-
-[target.example]
-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).

tests/fetch-content/src/main.cpp

@@ -1,5 +0,0 @@
-#include <fmt/core.h>
-
-int main() {
-    fmt::print("Hello, world!\n");
-}

tests/globbing/cmake.toml

@@ -1,18 +0,0 @@
-[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 +0,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 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace mylib {
-std::string message();
-} // namespace mylib

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

@@ -1,5 +0,0 @@
-#include <mylib/mylib.hpp>
-
-std::string mylib::message() {
-    return "cmkr is awesome!";
-}

tests/interface/cmake.toml

@@ -1,13 +1,11 @@
-[project]
+[project]
-name = "interface"
+name = "interface"
-description = "Header-only library"
+
-
+[target.mylib]
-[target.mylib]
+type = "interface"
-type = "interface"
+include-directories = ["include"]
-include-directories = ["include"]
+
-compile-features = ["cxx_std_11"]
+[target.example]
-
+type = "executable"
-[target.example]
+sources = ["src/main.cpp"]
-type = "executable"
+link-libraries = ["mylib"]
-sources = ["src/main.cpp"]
-link-libraries = ["mylib"]

tests/interface/include/mylib/mylib.hpp

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

tests/interface/src/main.cpp

@@ -1,7 +1,8 @@
-#include <cstdio>
+#include <cstdio>
-
+
-#include "mylib/mylib.hpp"
+#include "mylib/mylib.hpp"
-
+
-int main() {
+int main()
-    printf("mylib version: %s\n", mylib::version());
+{
-}
+    printf("mylib version: %s\n", mylib::version())
+}

tests/msvc-runtime/cmake.toml

@@ -1,15 +0,0 @@
-[project]
-name = "msvc-runtime"
-description = "Static MSVC runtime"
-msvc-runtime = "static"
-
-# This target will compile with a static runtime
-[target.static-runtime]
-type = "executable"
-sources = ["src/main.cpp"]
-
-# This target overrides the [project].msvc-runtime
-[target.dynamic-runtime]
-type = "executable"
-sources = ["src/main.cpp"]
-msvc-runtime = "dynamic"

tests/msvc-runtime/src/main.cpp

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

tests/relative-paths/cmake.toml

@@ -1,11 +0,0 @@
-[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

@@ -1,6 +0,0 @@
-// 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

@@ -1,12 +0,0 @@
-// 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

@@ -1,25 +0,0 @@
-# To avoid repeating yourself in targets you can create your own target type (template). All properties of the template are inherited when used as a target type.
-
-[project]
-name = "templates"
-description = "Target templates"
-
-[template.app]
-type = "executable"
-sources = ["src/templates.cpp"]
-compile-definitions = ["IS_APP"]
-
-# Unlike interface targets you can also inherit properties
-[template.app.properties]
-CXX_STANDARD = "11"
-CXX_STANDARD_REQUIRED = true
-
-[target.app-a]
-type = "app"
-compile-definitions = ["APP_A"]
-
-[target.app-b]
-type = "app"
-compile-definitions = ["APP_B"]
-
-# **Note**: In most cases you probably want to use an [interface](/examples/interface) target instead.

tests/templates/src/templates.cpp

@@ -1,13 +0,0 @@
-#include <cstdio>
-
-#if !defined(IS_APP)
-#error Something went wrong with the template
-#endif // IS_APP
-
-int main() {
-#if defined(APP_A)
-    puts("Hello from app A!");
-#elif defined(APP_B)
-    puts("Hello from app B!");
-#endif
-}

tests/vcpkg-subdir/cmake.toml

@@ -0,0 +1,16 @@
+[cmake]
+version = "3.15"
+
+[project]
+name = "vcpkg_template"
+
+#[fetch-content]
+#cmkr-issue-repoA = { git = "https://github.com/darknessxk/cmkr-issue-repoA.git" }
+
+[vcpkg]
+version = "2020.11"
+packages = ["fmt", "sqlite3"]
+
+[find-package]
+fmt = { version = "*" }
+unofficial-sqlite3 = { version = "*" }

tests/vcpkg-subdir/subdir/cmake.toml

@@ -0,0 +1,10 @@
+[project]
+name = "vcpkg_template"
+
+[vcpkg]
+version = "2020.11"
+packages = ["fmt", "sqlite3"]
+
+[find-package]
+fmt = { version = "*" }
+unofficial-sqlite3 = { version = "*" }

tests/vcpkg/cmake.toml

@@ -1,22 +0,0 @@
-# Downloads [fmt v7.1.3](https://fmt.dev/7.1.3/) using [vcpkg](https://vcpkg.io/) 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
-[vcpkg]
-version = "2024.03.25"
-packages = ["fmt"]
-
-[find-package]
-fmt = {}
-
-[target.example]
-type = "executable"
-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]`.