├── .gitattributes ├── .gitignore ├── .clang-format ├── CMakeLists.txt ├── README.md ├── LICENSE ├── src └── main.cpp └── cmake └── CPM.cmake /.gitattributes: -------------------------------------------------------------------------------- 1 | cmake/CPM.cmake linguist-vendored 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | build/ 3 | cmake-build*/ 4 | cpm-cache/ 5 | -------------------------------------------------------------------------------- /.clang-format: -------------------------------------------------------------------------------- 1 | BasedOnStyle: LLVM 2 | AlignConsecutiveAssignments: Consecutive 3 | AlignConsecutiveDeclarations: Consecutive 4 | ColumnLimit: 0 5 | IndentWidth: 4 6 | PointerAlignment: Left 7 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.14...3.31) 2 | 3 | project(mcpelauncherstrafesprintfix) 4 | 5 | if(NOT CMAKE_ANDROID_ARCH_ABI STREQUAL "x86_64") 6 | message(FATAL_ERROR "Unsupported ABI") 7 | endif() 8 | 9 | set(CMAKE_CXX_STANDARD 23) 10 | 11 | set(CPM_SOURCE_CACHE ${PROJECT_SOURCE_DIR}/cpm-cache CACHE PATH "") 12 | include(cmake/CPM.cmake) 13 | 14 | add_library(mcpelauncherstrafesprintfix SHARED src/main.cpp) 15 | 16 | #CPMAddPackage("gh:BasedInc/libhat@0.6.0") 17 | CPMAddPackage("gh:CrackedMatter/libhat#72d1bca325ee06a37e4510b70a54ba43aa0cb4ec") 18 | target_link_libraries(mcpelauncherstrafesprintfix PRIVATE libhat::libhat log) 19 | 20 | install(TARGETS mcpelauncherstrafesprintfix LIBRARY DESTINATION mods) 21 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # mcpelauncher-strafe-sprint-fix 2 | 3 | A mod for [mcpelauncher](https://minecraft-linux.github.io) that allows you to sprint while strafing on Intel CPUs. 4 | 5 | 6 | ## Installation 7 | 8 | Create a `mods` directory in the directory of your mcpelauncher profile (e.g. `~/.local/share/mcpelauncher`) if you have not already done so. 9 | Download the mod from [releases](https://github.com/CrackedMatter/mcpelauncher-strafe-sprint-fix/releases) and move the file into the `mods` directory. 10 | 11 | 12 | ## Building 13 | 14 | Prerequisites: 15 | 16 | - Android NDK r27 or later. [Download](https://developer.android.com/ndk/downloads) 17 | - CMake 3.14 or later 18 | 19 | Replace `/path/to/ndk` with the actual path to the Android NDK: 20 | 21 | ``` 22 | cmake -DCMAKE_TOOLCHAIN_FILE=/path/to/ndk/build/cmake/android.toolchain.cmake -DANDROID_ABI=x86_64 -DCMAKE_BUILD_TYPE=Release -B build 23 | cmake --build build 24 | ``` 25 | 26 | This will create a `build` directory containing the mod file. Install it as described in [Installation](#installation). 27 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 CrackedMatter 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /src/main.cpp: -------------------------------------------------------------------------------- 1 | #define LOG_TAG "StrafeSprintFix" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | extern "C" [[gnu::visibility("default")]] void mod_preinit() {} 8 | 9 | extern "C" [[gnu::visibility("default")]] void mod_init() { 10 | using namespace hat::signature_literals; 11 | 12 | auto mcLib = dlopen("libminecraftpe.so", 0); 13 | 14 | std::span range; 15 | 16 | auto callback = [&](const dl_phdr_info& info) { 17 | if (auto h = dlopen(info.dlpi_name, RTLD_NOLOAD); dlclose(h), h != mcLib) 18 | return 0; 19 | range = {reinterpret_cast(info.dlpi_addr + info.dlpi_phdr[1].p_vaddr), info.dlpi_phdr[1].p_memsz}; 20 | return 1; 21 | }; 22 | 23 | dl_iterate_phdr( 24 | [](dl_phdr_info* info, size_t, void* data) { 25 | return (*static_cast(data))(*info); 26 | }, 27 | &callback); 28 | 29 | auto value = [range] -> float* { 30 | auto sigs = std::to_array>({ 31 | {"0F 2E 1D ? ? ? ? B3 01"_sigv, 3}, 32 | {"F3 0F 10 05 ? ? ? ? 41 0F 2E ? ? 76 ? EB"_sigv, 4}, 33 | {"F3 0F 10 05 ? ? ? ? F3 0F 59 E0 0F 28 EA"_sigv, 4}, 34 | }); 35 | 36 | for (auto [sig, offset] : sigs) { 37 | auto result = hat::find_pattern(range, sig); 38 | 39 | if (result.has_result()) { 40 | ALOGD("Found pattern '%s' at %p", to_string(sig).c_str(), result.get()); 41 | return reinterpret_cast(result.rel(offset)); 42 | } 43 | } 44 | 45 | return nullptr; 46 | }(); 47 | 48 | if (value == nullptr) { 49 | ALOGE("No pattern found!"); 50 | return; 51 | } 52 | 53 | if (*value != 0.70710677f) { 54 | if (*value == 0.7071068f) { 55 | ALOGI("Patch already applied (address: %p)", value); 56 | } else { 57 | ALOGE("Wrong value! Expected 0.70710677, got %.8f (address: %p)", *value, value); 58 | } 59 | return; 60 | } 61 | 62 | *value = 0.7071068f; 63 | ALOGI("Patch applied successfully (address: %p)", value); 64 | } 65 | -------------------------------------------------------------------------------- /cmake/CPM.cmake: -------------------------------------------------------------------------------- 1 | # CPM.cmake - CMake's missing package manager 2 | # =========================================== 3 | # See https://github.com/cpm-cmake/CPM.cmake for usage and update instructions. 4 | # 5 | # MIT License 6 | # ----------- 7 | #[[ 8 | Copyright (c) 2019-2023 Lars Melchior and contributors 9 | 10 | Permission is hereby granted, free of charge, to any person obtaining a copy 11 | of this software and associated documentation files (the "Software"), to deal 12 | in the Software without restriction, including without limitation the rights 13 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 | copies of the Software, and to permit persons to whom the Software is 15 | furnished to do so, subject to the following conditions: 16 | 17 | The above copyright notice and this permission notice shall be included in all 18 | copies or substantial portions of the Software. 19 | 20 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 23 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 26 | SOFTWARE. 27 | ]] 28 | 29 | cmake_minimum_required(VERSION 3.14 FATAL_ERROR) 30 | 31 | # Initialize logging prefix 32 | if(NOT CPM_INDENT) 33 | set(CPM_INDENT 34 | "CPM:" 35 | CACHE INTERNAL "" 36 | ) 37 | endif() 38 | 39 | if(NOT COMMAND cpm_message) 40 | function(cpm_message) 41 | message(${ARGV}) 42 | endfunction() 43 | endif() 44 | 45 | if(DEFINED EXTRACTED_CPM_VERSION) 46 | set(CURRENT_CPM_VERSION "${EXTRACTED_CPM_VERSION}${CPM_DEVELOPMENT}") 47 | else() 48 | set(CURRENT_CPM_VERSION 0.40.8) 49 | endif() 50 | 51 | get_filename_component(CPM_CURRENT_DIRECTORY "${CMAKE_CURRENT_LIST_DIR}" REALPATH) 52 | if(CPM_DIRECTORY) 53 | if(NOT CPM_DIRECTORY STREQUAL CPM_CURRENT_DIRECTORY) 54 | if(CPM_VERSION VERSION_LESS CURRENT_CPM_VERSION) 55 | message( 56 | AUTHOR_WARNING 57 | "${CPM_INDENT} \ 58 | A dependency is using a more recent CPM version (${CURRENT_CPM_VERSION}) than the current project (${CPM_VERSION}). \ 59 | It is recommended to upgrade CPM to the most recent version. \ 60 | See https://github.com/cpm-cmake/CPM.cmake for more information." 61 | ) 62 | endif() 63 | if(${CMAKE_VERSION} VERSION_LESS "3.17.0") 64 | include(FetchContent) 65 | endif() 66 | return() 67 | endif() 68 | 69 | get_property( 70 | CPM_INITIALIZED GLOBAL "" 71 | PROPERTY CPM_INITIALIZED 72 | SET 73 | ) 74 | if(CPM_INITIALIZED) 75 | return() 76 | endif() 77 | endif() 78 | 79 | if(CURRENT_CPM_VERSION MATCHES "development-version") 80 | message( 81 | WARNING "${CPM_INDENT} Your project is using an unstable development version of CPM.cmake. \ 82 | Please update to a recent release if possible. \ 83 | See https://github.com/cpm-cmake/CPM.cmake for details." 84 | ) 85 | endif() 86 | 87 | set_property(GLOBAL PROPERTY CPM_INITIALIZED true) 88 | 89 | macro(cpm_set_policies) 90 | # the policy allows us to change options without caching 91 | cmake_policy(SET CMP0077 NEW) 92 | set(CMAKE_POLICY_DEFAULT_CMP0077 NEW) 93 | 94 | # the policy allows us to change set(CACHE) without caching 95 | if(POLICY CMP0126) 96 | cmake_policy(SET CMP0126 NEW) 97 | set(CMAKE_POLICY_DEFAULT_CMP0126 NEW) 98 | endif() 99 | 100 | # The policy uses the download time for timestamp, instead of the timestamp in the archive. This 101 | # allows for proper rebuilds when a projects url changes 102 | if(POLICY CMP0135) 103 | cmake_policy(SET CMP0135 NEW) 104 | set(CMAKE_POLICY_DEFAULT_CMP0135 NEW) 105 | endif() 106 | 107 | # treat relative git repository paths as being relative to the parent project's remote 108 | if(POLICY CMP0150) 109 | cmake_policy(SET CMP0150 NEW) 110 | set(CMAKE_POLICY_DEFAULT_CMP0150 NEW) 111 | endif() 112 | endmacro() 113 | cpm_set_policies() 114 | 115 | option(CPM_USE_LOCAL_PACKAGES "Always try to use `find_package` to get dependencies" 116 | $ENV{CPM_USE_LOCAL_PACKAGES} 117 | ) 118 | option(CPM_LOCAL_PACKAGES_ONLY "Only use `find_package` to get dependencies" 119 | $ENV{CPM_LOCAL_PACKAGES_ONLY} 120 | ) 121 | option(CPM_DOWNLOAD_ALL "Always download dependencies from source" $ENV{CPM_DOWNLOAD_ALL}) 122 | option(CPM_DONT_UPDATE_MODULE_PATH "Don't update the module path to allow using find_package" 123 | $ENV{CPM_DONT_UPDATE_MODULE_PATH} 124 | ) 125 | option(CPM_DONT_CREATE_PACKAGE_LOCK "Don't create a package lock file in the binary path" 126 | $ENV{CPM_DONT_CREATE_PACKAGE_LOCK} 127 | ) 128 | option(CPM_INCLUDE_ALL_IN_PACKAGE_LOCK 129 | "Add all packages added through CPM.cmake to the package lock" 130 | $ENV{CPM_INCLUDE_ALL_IN_PACKAGE_LOCK} 131 | ) 132 | option(CPM_USE_NAMED_CACHE_DIRECTORIES 133 | "Use additional directory of package name in cache on the most nested level." 134 | $ENV{CPM_USE_NAMED_CACHE_DIRECTORIES} 135 | ) 136 | 137 | set(CPM_VERSION 138 | ${CURRENT_CPM_VERSION} 139 | CACHE INTERNAL "" 140 | ) 141 | set(CPM_DIRECTORY 142 | ${CPM_CURRENT_DIRECTORY} 143 | CACHE INTERNAL "" 144 | ) 145 | set(CPM_FILE 146 | ${CMAKE_CURRENT_LIST_FILE} 147 | CACHE INTERNAL "" 148 | ) 149 | set(CPM_PACKAGES 150 | "" 151 | CACHE INTERNAL "" 152 | ) 153 | set(CPM_DRY_RUN 154 | OFF 155 | CACHE INTERNAL "Don't download or configure dependencies (for testing)" 156 | ) 157 | 158 | if(DEFINED ENV{CPM_SOURCE_CACHE}) 159 | set(CPM_SOURCE_CACHE_DEFAULT $ENV{CPM_SOURCE_CACHE}) 160 | else() 161 | set(CPM_SOURCE_CACHE_DEFAULT OFF) 162 | endif() 163 | 164 | set(CPM_SOURCE_CACHE 165 | ${CPM_SOURCE_CACHE_DEFAULT} 166 | CACHE PATH "Directory to download CPM dependencies" 167 | ) 168 | 169 | if(NOT CPM_DONT_UPDATE_MODULE_PATH AND NOT DEFINED CMAKE_FIND_PACKAGE_REDIRECTS_DIR) 170 | set(CPM_MODULE_PATH 171 | "${CMAKE_BINARY_DIR}/CPM_modules" 172 | CACHE INTERNAL "" 173 | ) 174 | # remove old modules 175 | file(REMOVE_RECURSE ${CPM_MODULE_PATH}) 176 | file(MAKE_DIRECTORY ${CPM_MODULE_PATH}) 177 | # locally added CPM modules should override global packages 178 | set(CMAKE_MODULE_PATH "${CPM_MODULE_PATH};${CMAKE_MODULE_PATH}") 179 | endif() 180 | 181 | if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) 182 | set(CPM_PACKAGE_LOCK_FILE 183 | "${CMAKE_BINARY_DIR}/cpm-package-lock.cmake" 184 | CACHE INTERNAL "" 185 | ) 186 | file(WRITE ${CPM_PACKAGE_LOCK_FILE} 187 | "# CPM Package Lock\n# This file should be committed to version control\n\n" 188 | ) 189 | endif() 190 | 191 | include(FetchContent) 192 | 193 | # Try to infer package name from git repository uri (path or url) 194 | function(cpm_package_name_from_git_uri URI RESULT) 195 | if("${URI}" MATCHES "([^/:]+)/?.git/?$") 196 | set(${RESULT} 197 | ${CMAKE_MATCH_1} 198 | PARENT_SCOPE 199 | ) 200 | else() 201 | unset(${RESULT} PARENT_SCOPE) 202 | endif() 203 | endfunction() 204 | 205 | # Try to infer package name and version from a url 206 | function(cpm_package_name_and_ver_from_url url outName outVer) 207 | if(url MATCHES "[/\\?]([a-zA-Z0-9_\\.-]+)\\.(tar|tar\\.gz|tar\\.bz2|zip|ZIP)(\\?|/|$)") 208 | # We matched an archive 209 | set(filename "${CMAKE_MATCH_1}") 210 | 211 | if(filename MATCHES "([a-zA-Z0-9_\\.-]+)[_-]v?(([0-9]+\\.)*[0-9]+[a-zA-Z0-9]*)") 212 | # We matched - (ie foo-1.2.3) 213 | set(${outName} 214 | "${CMAKE_MATCH_1}" 215 | PARENT_SCOPE 216 | ) 217 | set(${outVer} 218 | "${CMAKE_MATCH_2}" 219 | PARENT_SCOPE 220 | ) 221 | elseif(filename MATCHES "(([0-9]+\\.)+[0-9]+[a-zA-Z0-9]*)") 222 | # We couldn't find a name, but we found a version 223 | # 224 | # In many cases (which we don't handle here) the url would look something like 225 | # `irrelevant/ACTUAL_PACKAGE_NAME/irrelevant/1.2.3.zip`. In such a case we can't possibly 226 | # distinguish the package name from the irrelevant bits. Moreover if we try to match the 227 | # package name from the filename, we'd get bogus at best. 228 | unset(${outName} PARENT_SCOPE) 229 | set(${outVer} 230 | "${CMAKE_MATCH_1}" 231 | PARENT_SCOPE 232 | ) 233 | else() 234 | # Boldly assume that the file name is the package name. 235 | # 236 | # Yes, something like `irrelevant/ACTUAL_NAME/irrelevant/download.zip` will ruin our day, but 237 | # such cases should be quite rare. No popular service does this... we think. 238 | set(${outName} 239 | "${filename}" 240 | PARENT_SCOPE 241 | ) 242 | unset(${outVer} PARENT_SCOPE) 243 | endif() 244 | else() 245 | # No ideas yet what to do with non-archives 246 | unset(${outName} PARENT_SCOPE) 247 | unset(${outVer} PARENT_SCOPE) 248 | endif() 249 | endfunction() 250 | 251 | function(cpm_find_package NAME VERSION) 252 | string(REPLACE " " ";" EXTRA_ARGS "${ARGN}") 253 | find_package(${NAME} ${VERSION} ${EXTRA_ARGS} QUIET) 254 | if(${CPM_ARGS_NAME}_FOUND) 255 | if(DEFINED ${CPM_ARGS_NAME}_VERSION) 256 | set(VERSION ${${CPM_ARGS_NAME}_VERSION}) 257 | endif() 258 | cpm_message(STATUS "${CPM_INDENT} Using local package ${CPM_ARGS_NAME}@${VERSION}") 259 | CPMRegisterPackage(${CPM_ARGS_NAME} "${VERSION}") 260 | set(CPM_PACKAGE_FOUND 261 | YES 262 | PARENT_SCOPE 263 | ) 264 | else() 265 | set(CPM_PACKAGE_FOUND 266 | NO 267 | PARENT_SCOPE 268 | ) 269 | endif() 270 | endfunction() 271 | 272 | # Create a custom FindXXX.cmake module for a CPM package This prevents `find_package(NAME)` from 273 | # finding the system library 274 | function(cpm_create_module_file Name) 275 | if(NOT CPM_DONT_UPDATE_MODULE_PATH) 276 | if(DEFINED CMAKE_FIND_PACKAGE_REDIRECTS_DIR) 277 | # Redirect find_package calls to the CPM package. This is what FetchContent does when you set 278 | # OVERRIDE_FIND_PACKAGE. The CMAKE_FIND_PACKAGE_REDIRECTS_DIR works for find_package in CONFIG 279 | # mode, unlike the Find${Name}.cmake fallback. CMAKE_FIND_PACKAGE_REDIRECTS_DIR is not defined 280 | # in script mode, or in CMake < 3.24. 281 | # https://cmake.org/cmake/help/latest/module/FetchContent.html#fetchcontent-find-package-integration-examples 282 | string(TOLOWER ${Name} NameLower) 283 | file(WRITE ${CMAKE_FIND_PACKAGE_REDIRECTS_DIR}/${NameLower}-config.cmake 284 | "include(\"\${CMAKE_CURRENT_LIST_DIR}/${NameLower}-extra.cmake\" OPTIONAL)\n" 285 | "include(\"\${CMAKE_CURRENT_LIST_DIR}/${Name}Extra.cmake\" OPTIONAL)\n" 286 | ) 287 | file(WRITE ${CMAKE_FIND_PACKAGE_REDIRECTS_DIR}/${NameLower}-config-version.cmake 288 | "set(PACKAGE_VERSION_COMPATIBLE TRUE)\n" "set(PACKAGE_VERSION_EXACT TRUE)\n" 289 | ) 290 | else() 291 | file(WRITE ${CPM_MODULE_PATH}/Find${Name}.cmake 292 | "include(\"${CPM_FILE}\")\n${ARGN}\nset(${Name}_FOUND TRUE)" 293 | ) 294 | endif() 295 | endif() 296 | endfunction() 297 | 298 | # Find a package locally or fallback to CPMAddPackage 299 | function(CPMFindPackage) 300 | set(oneValueArgs NAME VERSION GIT_TAG FIND_PACKAGE_ARGUMENTS) 301 | 302 | cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "" ${ARGN}) 303 | 304 | if(NOT DEFINED CPM_ARGS_VERSION) 305 | if(DEFINED CPM_ARGS_GIT_TAG) 306 | cpm_get_version_from_git_tag("${CPM_ARGS_GIT_TAG}" CPM_ARGS_VERSION) 307 | endif() 308 | endif() 309 | 310 | set(downloadPackage ${CPM_DOWNLOAD_ALL}) 311 | if(DEFINED CPM_DOWNLOAD_${CPM_ARGS_NAME}) 312 | set(downloadPackage ${CPM_DOWNLOAD_${CPM_ARGS_NAME}}) 313 | elseif(DEFINED ENV{CPM_DOWNLOAD_${CPM_ARGS_NAME}}) 314 | set(downloadPackage $ENV{CPM_DOWNLOAD_${CPM_ARGS_NAME}}) 315 | endif() 316 | if(downloadPackage) 317 | CPMAddPackage(${ARGN}) 318 | cpm_export_variables(${CPM_ARGS_NAME}) 319 | return() 320 | endif() 321 | 322 | cpm_find_package(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}" ${CPM_ARGS_FIND_PACKAGE_ARGUMENTS}) 323 | 324 | if(NOT CPM_PACKAGE_FOUND) 325 | CPMAddPackage(${ARGN}) 326 | cpm_export_variables(${CPM_ARGS_NAME}) 327 | endif() 328 | 329 | endfunction() 330 | 331 | # checks if a package has been added before 332 | function(cpm_check_if_package_already_added CPM_ARGS_NAME CPM_ARGS_VERSION) 333 | if("${CPM_ARGS_NAME}" IN_LIST CPM_PACKAGES) 334 | CPMGetPackageVersion(${CPM_ARGS_NAME} CPM_PACKAGE_VERSION) 335 | if("${CPM_PACKAGE_VERSION}" VERSION_LESS "${CPM_ARGS_VERSION}") 336 | message( 337 | WARNING 338 | "${CPM_INDENT} Requires a newer version of ${CPM_ARGS_NAME} (${CPM_ARGS_VERSION}) than currently included (${CPM_PACKAGE_VERSION})." 339 | ) 340 | endif() 341 | cpm_get_fetch_properties(${CPM_ARGS_NAME}) 342 | set(${CPM_ARGS_NAME}_ADDED NO) 343 | set(CPM_PACKAGE_ALREADY_ADDED 344 | YES 345 | PARENT_SCOPE 346 | ) 347 | cpm_export_variables(${CPM_ARGS_NAME}) 348 | else() 349 | set(CPM_PACKAGE_ALREADY_ADDED 350 | NO 351 | PARENT_SCOPE 352 | ) 353 | endif() 354 | endfunction() 355 | 356 | # Parse the argument of CPMAddPackage in case a single one was provided and convert it to a list of 357 | # arguments which can then be parsed idiomatically. For example gh:foo/bar@1.2.3 will be converted 358 | # to: GITHUB_REPOSITORY;foo/bar;VERSION;1.2.3 359 | function(cpm_parse_add_package_single_arg arg outArgs) 360 | # Look for a scheme 361 | if("${arg}" MATCHES "^([a-zA-Z]+):(.+)$") 362 | string(TOLOWER "${CMAKE_MATCH_1}" scheme) 363 | set(uri "${CMAKE_MATCH_2}") 364 | 365 | # Check for CPM-specific schemes 366 | if(scheme STREQUAL "gh") 367 | set(out "GITHUB_REPOSITORY;${uri}") 368 | set(packageType "git") 369 | elseif(scheme STREQUAL "gl") 370 | set(out "GITLAB_REPOSITORY;${uri}") 371 | set(packageType "git") 372 | elseif(scheme STREQUAL "bb") 373 | set(out "BITBUCKET_REPOSITORY;${uri}") 374 | set(packageType "git") 375 | # A CPM-specific scheme was not found. Looks like this is a generic URL so try to determine 376 | # type 377 | elseif(arg MATCHES ".git/?(@|#|$)") 378 | set(out "GIT_REPOSITORY;${arg}") 379 | set(packageType "git") 380 | else() 381 | # Fall back to a URL 382 | set(out "URL;${arg}") 383 | set(packageType "archive") 384 | 385 | # We could also check for SVN since FetchContent supports it, but SVN is so rare these days. 386 | # We just won't bother with the additional complexity it will induce in this function. SVN is 387 | # done by multi-arg 388 | endif() 389 | else() 390 | if(arg MATCHES ".git/?(@|#|$)") 391 | set(out "GIT_REPOSITORY;${arg}") 392 | set(packageType "git") 393 | else() 394 | # Give up 395 | message(FATAL_ERROR "${CPM_INDENT} Can't determine package type of '${arg}'") 396 | endif() 397 | endif() 398 | 399 | # For all packages we interpret @... as version. Only replace the last occurrence. Thus URIs 400 | # containing '@' can be used 401 | string(REGEX REPLACE "@([^@]+)$" ";VERSION;\\1" out "${out}") 402 | 403 | # Parse the rest according to package type 404 | if(packageType STREQUAL "git") 405 | # For git repos we interpret #... as a tag or branch or commit hash 406 | string(REGEX REPLACE "#([^#]+)$" ";GIT_TAG;\\1" out "${out}") 407 | elseif(packageType STREQUAL "archive") 408 | # For archives we interpret #... as a URL hash. 409 | string(REGEX REPLACE "#([^#]+)$" ";URL_HASH;\\1" out "${out}") 410 | # We don't try to parse the version if it's not provided explicitly. cpm_get_version_from_url 411 | # should do this at a later point 412 | else() 413 | # We should never get here. This is an assertion and hitting it means there's a problem with the 414 | # code above. A packageType was set, but not handled by this if-else. 415 | message(FATAL_ERROR "${CPM_INDENT} Unsupported package type '${packageType}' of '${arg}'") 416 | endif() 417 | 418 | set(${outArgs} 419 | ${out} 420 | PARENT_SCOPE 421 | ) 422 | endfunction() 423 | 424 | # Check that the working directory for a git repo is clean 425 | function(cpm_check_git_working_dir_is_clean repoPath gitTag isClean) 426 | 427 | find_package(Git REQUIRED) 428 | 429 | if(NOT GIT_EXECUTABLE) 430 | # No git executable, assume directory is clean 431 | set(${isClean} 432 | TRUE 433 | PARENT_SCOPE 434 | ) 435 | return() 436 | endif() 437 | 438 | # check for uncommitted changes 439 | execute_process( 440 | COMMAND ${GIT_EXECUTABLE} status --porcelain 441 | RESULT_VARIABLE resultGitStatus 442 | OUTPUT_VARIABLE repoStatus 443 | OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET 444 | WORKING_DIRECTORY ${repoPath} 445 | ) 446 | if(resultGitStatus) 447 | # not supposed to happen, assume clean anyway 448 | message(WARNING "${CPM_INDENT} Calling git status on folder ${repoPath} failed") 449 | set(${isClean} 450 | TRUE 451 | PARENT_SCOPE 452 | ) 453 | return() 454 | endif() 455 | 456 | if(NOT "${repoStatus}" STREQUAL "") 457 | set(${isClean} 458 | FALSE 459 | PARENT_SCOPE 460 | ) 461 | return() 462 | endif() 463 | 464 | # check for committed changes 465 | execute_process( 466 | COMMAND ${GIT_EXECUTABLE} diff -s --exit-code ${gitTag} 467 | RESULT_VARIABLE resultGitDiff 468 | OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_QUIET 469 | WORKING_DIRECTORY ${repoPath} 470 | ) 471 | 472 | if(${resultGitDiff} EQUAL 0) 473 | set(${isClean} 474 | TRUE 475 | PARENT_SCOPE 476 | ) 477 | else() 478 | set(${isClean} 479 | FALSE 480 | PARENT_SCOPE 481 | ) 482 | endif() 483 | 484 | endfunction() 485 | 486 | # Add PATCH_COMMAND to CPM_ARGS_UNPARSED_ARGUMENTS. This method consumes a list of files in ARGN 487 | # then generates a `PATCH_COMMAND` appropriate for `ExternalProject_Add()`. This command is appended 488 | # to the parent scope's `CPM_ARGS_UNPARSED_ARGUMENTS`. 489 | function(cpm_add_patches) 490 | # Return if no patch files are supplied. 491 | if(NOT ARGN) 492 | return() 493 | endif() 494 | 495 | # Find the patch program. 496 | find_program(PATCH_EXECUTABLE patch) 497 | if(CMAKE_HOST_WIN32 AND NOT PATCH_EXECUTABLE) 498 | # The Windows git executable is distributed with patch.exe. Find the path to the executable, if 499 | # it exists, then search `../usr/bin` and `../../usr/bin` for patch.exe. 500 | find_package(Git QUIET) 501 | if(GIT_EXECUTABLE) 502 | get_filename_component(extra_search_path ${GIT_EXECUTABLE} DIRECTORY) 503 | get_filename_component(extra_search_path_1up ${extra_search_path} DIRECTORY) 504 | get_filename_component(extra_search_path_2up ${extra_search_path_1up} DIRECTORY) 505 | find_program( 506 | PATCH_EXECUTABLE patch HINTS "${extra_search_path_1up}/usr/bin" 507 | "${extra_search_path_2up}/usr/bin" 508 | ) 509 | endif() 510 | endif() 511 | if(NOT PATCH_EXECUTABLE) 512 | message(FATAL_ERROR "Couldn't find `patch` executable to use with PATCHES keyword.") 513 | endif() 514 | 515 | # Create a temporary 516 | set(temp_list ${CPM_ARGS_UNPARSED_ARGUMENTS}) 517 | 518 | # Ensure each file exists (or error out) and add it to the list. 519 | set(first_item True) 520 | foreach(PATCH_FILE ${ARGN}) 521 | # Make sure the patch file exists, if we can't find it, try again in the current directory. 522 | if(NOT EXISTS "${PATCH_FILE}") 523 | if(NOT EXISTS "${CMAKE_CURRENT_LIST_DIR}/${PATCH_FILE}") 524 | message(FATAL_ERROR "Couldn't find patch file: '${PATCH_FILE}'") 525 | endif() 526 | set(PATCH_FILE "${CMAKE_CURRENT_LIST_DIR}/${PATCH_FILE}") 527 | endif() 528 | 529 | # Convert to absolute path for use with patch file command. 530 | get_filename_component(PATCH_FILE "${PATCH_FILE}" ABSOLUTE) 531 | 532 | # The first patch entry must be preceded by "PATCH_COMMAND" while the following items are 533 | # preceded by "&&". 534 | if(first_item) 535 | set(first_item False) 536 | list(APPEND temp_list "PATCH_COMMAND") 537 | else() 538 | list(APPEND temp_list "&&") 539 | endif() 540 | # Add the patch command to the list 541 | list(APPEND temp_list "${PATCH_EXECUTABLE}" "-p1" "<" "${PATCH_FILE}") 542 | endforeach() 543 | 544 | # Move temp out into parent scope. 545 | set(CPM_ARGS_UNPARSED_ARGUMENTS 546 | ${temp_list} 547 | PARENT_SCOPE 548 | ) 549 | 550 | endfunction() 551 | 552 | # method to overwrite internal FetchContent properties, to allow using CPM.cmake to overload 553 | # FetchContent calls. As these are internal cmake properties, this method should be used carefully 554 | # and may need modification in future CMake versions. Source: 555 | # https://github.com/Kitware/CMake/blob/dc3d0b5a0a7d26d43d6cfeb511e224533b5d188f/Modules/FetchContent.cmake#L1152 556 | function(cpm_override_fetchcontent contentName) 557 | cmake_parse_arguments(PARSE_ARGV 1 arg "" "SOURCE_DIR;BINARY_DIR" "") 558 | if(NOT "${arg_UNPARSED_ARGUMENTS}" STREQUAL "") 559 | message(FATAL_ERROR "${CPM_INDENT} Unsupported arguments: ${arg_UNPARSED_ARGUMENTS}") 560 | endif() 561 | 562 | string(TOLOWER ${contentName} contentNameLower) 563 | set(prefix "_FetchContent_${contentNameLower}") 564 | 565 | set(propertyName "${prefix}_sourceDir") 566 | define_property( 567 | GLOBAL 568 | PROPERTY ${propertyName} 569 | BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" 570 | FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" 571 | ) 572 | set_property(GLOBAL PROPERTY ${propertyName} "${arg_SOURCE_DIR}") 573 | 574 | set(propertyName "${prefix}_binaryDir") 575 | define_property( 576 | GLOBAL 577 | PROPERTY ${propertyName} 578 | BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" 579 | FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" 580 | ) 581 | set_property(GLOBAL PROPERTY ${propertyName} "${arg_BINARY_DIR}") 582 | 583 | set(propertyName "${prefix}_populated") 584 | define_property( 585 | GLOBAL 586 | PROPERTY ${propertyName} 587 | BRIEF_DOCS "Internal implementation detail of FetchContent_Populate()" 588 | FULL_DOCS "Details used by FetchContent_Populate() for ${contentName}" 589 | ) 590 | set_property(GLOBAL PROPERTY ${propertyName} TRUE) 591 | endfunction() 592 | 593 | # Download and add a package from source 594 | function(CPMAddPackage) 595 | cpm_set_policies() 596 | 597 | list(LENGTH ARGN argnLength) 598 | if(argnLength EQUAL 1) 599 | cpm_parse_add_package_single_arg("${ARGN}" ARGN) 600 | 601 | # The shorthand syntax implies EXCLUDE_FROM_ALL and SYSTEM 602 | set(ARGN "${ARGN};EXCLUDE_FROM_ALL;YES;SYSTEM;YES;") 603 | endif() 604 | 605 | set(oneValueArgs 606 | NAME 607 | FORCE 608 | VERSION 609 | GIT_TAG 610 | DOWNLOAD_ONLY 611 | GITHUB_REPOSITORY 612 | GITLAB_REPOSITORY 613 | BITBUCKET_REPOSITORY 614 | GIT_REPOSITORY 615 | SOURCE_DIR 616 | FIND_PACKAGE_ARGUMENTS 617 | NO_CACHE 618 | SYSTEM 619 | GIT_SHALLOW 620 | EXCLUDE_FROM_ALL 621 | SOURCE_SUBDIR 622 | CUSTOM_CACHE_KEY 623 | ) 624 | 625 | set(multiValueArgs URL OPTIONS DOWNLOAD_COMMAND PATCHES) 626 | 627 | cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}") 628 | 629 | # Set default values for arguments 630 | 631 | if(NOT DEFINED CPM_ARGS_VERSION) 632 | if(DEFINED CPM_ARGS_GIT_TAG) 633 | cpm_get_version_from_git_tag("${CPM_ARGS_GIT_TAG}" CPM_ARGS_VERSION) 634 | endif() 635 | endif() 636 | 637 | if(CPM_ARGS_DOWNLOAD_ONLY) 638 | set(DOWNLOAD_ONLY ${CPM_ARGS_DOWNLOAD_ONLY}) 639 | else() 640 | set(DOWNLOAD_ONLY NO) 641 | endif() 642 | 643 | if(DEFINED CPM_ARGS_GITHUB_REPOSITORY) 644 | set(CPM_ARGS_GIT_REPOSITORY "https://github.com/${CPM_ARGS_GITHUB_REPOSITORY}.git") 645 | elseif(DEFINED CPM_ARGS_GITLAB_REPOSITORY) 646 | set(CPM_ARGS_GIT_REPOSITORY "https://gitlab.com/${CPM_ARGS_GITLAB_REPOSITORY}.git") 647 | elseif(DEFINED CPM_ARGS_BITBUCKET_REPOSITORY) 648 | set(CPM_ARGS_GIT_REPOSITORY "https://bitbucket.org/${CPM_ARGS_BITBUCKET_REPOSITORY}.git") 649 | endif() 650 | 651 | if(DEFINED CPM_ARGS_GIT_REPOSITORY) 652 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_REPOSITORY ${CPM_ARGS_GIT_REPOSITORY}) 653 | if(NOT DEFINED CPM_ARGS_GIT_TAG) 654 | set(CPM_ARGS_GIT_TAG v${CPM_ARGS_VERSION}) 655 | endif() 656 | 657 | # If a name wasn't provided, try to infer it from the git repo 658 | if(NOT DEFINED CPM_ARGS_NAME) 659 | cpm_package_name_from_git_uri(${CPM_ARGS_GIT_REPOSITORY} CPM_ARGS_NAME) 660 | endif() 661 | endif() 662 | 663 | set(CPM_SKIP_FETCH FALSE) 664 | 665 | if(DEFINED CPM_ARGS_GIT_TAG) 666 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_TAG ${CPM_ARGS_GIT_TAG}) 667 | # If GIT_SHALLOW is explicitly specified, honor the value. 668 | if(DEFINED CPM_ARGS_GIT_SHALLOW) 669 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_SHALLOW ${CPM_ARGS_GIT_SHALLOW}) 670 | endif() 671 | endif() 672 | 673 | if(DEFINED CPM_ARGS_URL) 674 | # If a name or version aren't provided, try to infer them from the URL 675 | list(GET CPM_ARGS_URL 0 firstUrl) 676 | cpm_package_name_and_ver_from_url(${firstUrl} nameFromUrl verFromUrl) 677 | # If we fail to obtain name and version from the first URL, we could try other URLs if any. 678 | # However multiple URLs are expected to be quite rare, so for now we won't bother. 679 | 680 | # If the caller provided their own name and version, they trump the inferred ones. 681 | if(NOT DEFINED CPM_ARGS_NAME) 682 | set(CPM_ARGS_NAME ${nameFromUrl}) 683 | endif() 684 | if(NOT DEFINED CPM_ARGS_VERSION) 685 | set(CPM_ARGS_VERSION ${verFromUrl}) 686 | endif() 687 | 688 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS URL "${CPM_ARGS_URL}") 689 | endif() 690 | 691 | # Check for required arguments 692 | 693 | if(NOT DEFINED CPM_ARGS_NAME) 694 | message( 695 | FATAL_ERROR 696 | "${CPM_INDENT} 'NAME' was not provided and couldn't be automatically inferred for package added with arguments: '${ARGN}'" 697 | ) 698 | endif() 699 | 700 | # Check if package has been added before 701 | cpm_check_if_package_already_added(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}") 702 | if(CPM_PACKAGE_ALREADY_ADDED) 703 | cpm_export_variables(${CPM_ARGS_NAME}) 704 | return() 705 | endif() 706 | 707 | # Check for manual overrides 708 | if(NOT CPM_ARGS_FORCE AND NOT "${CPM_${CPM_ARGS_NAME}_SOURCE}" STREQUAL "") 709 | set(PACKAGE_SOURCE ${CPM_${CPM_ARGS_NAME}_SOURCE}) 710 | set(CPM_${CPM_ARGS_NAME}_SOURCE "") 711 | CPMAddPackage( 712 | NAME "${CPM_ARGS_NAME}" 713 | SOURCE_DIR "${PACKAGE_SOURCE}" 714 | EXCLUDE_FROM_ALL "${CPM_ARGS_EXCLUDE_FROM_ALL}" 715 | SYSTEM "${CPM_ARGS_SYSTEM}" 716 | PATCHES "${CPM_ARGS_PATCHES}" 717 | OPTIONS "${CPM_ARGS_OPTIONS}" 718 | SOURCE_SUBDIR "${CPM_ARGS_SOURCE_SUBDIR}" 719 | DOWNLOAD_ONLY "${DOWNLOAD_ONLY}" 720 | FORCE True 721 | ) 722 | cpm_export_variables(${CPM_ARGS_NAME}) 723 | return() 724 | endif() 725 | 726 | # Check for available declaration 727 | if(NOT CPM_ARGS_FORCE AND NOT "${CPM_DECLARATION_${CPM_ARGS_NAME}}" STREQUAL "") 728 | set(declaration ${CPM_DECLARATION_${CPM_ARGS_NAME}}) 729 | set(CPM_DECLARATION_${CPM_ARGS_NAME} "") 730 | CPMAddPackage(${declaration}) 731 | cpm_export_variables(${CPM_ARGS_NAME}) 732 | # checking again to ensure version and option compatibility 733 | cpm_check_if_package_already_added(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}") 734 | return() 735 | endif() 736 | 737 | if(NOT CPM_ARGS_FORCE) 738 | if(CPM_USE_LOCAL_PACKAGES OR CPM_LOCAL_PACKAGES_ONLY) 739 | cpm_find_package(${CPM_ARGS_NAME} "${CPM_ARGS_VERSION}" ${CPM_ARGS_FIND_PACKAGE_ARGUMENTS}) 740 | 741 | if(CPM_PACKAGE_FOUND) 742 | cpm_export_variables(${CPM_ARGS_NAME}) 743 | return() 744 | endif() 745 | 746 | if(CPM_LOCAL_PACKAGES_ONLY) 747 | message( 748 | SEND_ERROR 749 | "${CPM_INDENT} ${CPM_ARGS_NAME} not found via find_package(${CPM_ARGS_NAME} ${CPM_ARGS_VERSION})" 750 | ) 751 | endif() 752 | endif() 753 | endif() 754 | 755 | CPMRegisterPackage("${CPM_ARGS_NAME}" "${CPM_ARGS_VERSION}") 756 | 757 | if(DEFINED CPM_ARGS_GIT_TAG) 758 | set(PACKAGE_INFO "${CPM_ARGS_GIT_TAG}") 759 | elseif(DEFINED CPM_ARGS_SOURCE_DIR) 760 | set(PACKAGE_INFO "${CPM_ARGS_SOURCE_DIR}") 761 | else() 762 | set(PACKAGE_INFO "${CPM_ARGS_VERSION}") 763 | endif() 764 | 765 | if(DEFINED FETCHCONTENT_BASE_DIR) 766 | # respect user's FETCHCONTENT_BASE_DIR if set 767 | set(CPM_FETCHCONTENT_BASE_DIR ${FETCHCONTENT_BASE_DIR}) 768 | else() 769 | set(CPM_FETCHCONTENT_BASE_DIR ${CMAKE_BINARY_DIR}/_deps) 770 | endif() 771 | 772 | cpm_add_patches(${CPM_ARGS_PATCHES}) 773 | 774 | if(DEFINED CPM_ARGS_DOWNLOAD_COMMAND) 775 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS DOWNLOAD_COMMAND ${CPM_ARGS_DOWNLOAD_COMMAND}) 776 | elseif(DEFINED CPM_ARGS_SOURCE_DIR) 777 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS SOURCE_DIR ${CPM_ARGS_SOURCE_DIR}) 778 | if(NOT IS_ABSOLUTE ${CPM_ARGS_SOURCE_DIR}) 779 | # Expand `CPM_ARGS_SOURCE_DIR` relative path. This is important because EXISTS doesn't work 780 | # for relative paths. 781 | get_filename_component( 782 | source_directory ${CPM_ARGS_SOURCE_DIR} REALPATH BASE_DIR ${CMAKE_CURRENT_BINARY_DIR} 783 | ) 784 | else() 785 | set(source_directory ${CPM_ARGS_SOURCE_DIR}) 786 | endif() 787 | if(NOT EXISTS ${source_directory}) 788 | string(TOLOWER ${CPM_ARGS_NAME} lower_case_name) 789 | # remove timestamps so CMake will re-download the dependency 790 | file(REMOVE_RECURSE "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild") 791 | endif() 792 | elseif(CPM_SOURCE_CACHE AND NOT CPM_ARGS_NO_CACHE) 793 | string(TOLOWER ${CPM_ARGS_NAME} lower_case_name) 794 | set(origin_parameters ${CPM_ARGS_UNPARSED_ARGUMENTS}) 795 | list(SORT origin_parameters) 796 | if(CPM_ARGS_CUSTOM_CACHE_KEY) 797 | # Application set a custom unique directory name 798 | set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${CPM_ARGS_CUSTOM_CACHE_KEY}) 799 | elseif(CPM_USE_NAMED_CACHE_DIRECTORIES) 800 | string(SHA1 origin_hash "${origin_parameters};NEW_CACHE_STRUCTURE_TAG") 801 | set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${origin_hash}/${CPM_ARGS_NAME}) 802 | else() 803 | string(SHA1 origin_hash "${origin_parameters}") 804 | set(download_directory ${CPM_SOURCE_CACHE}/${lower_case_name}/${origin_hash}) 805 | endif() 806 | # Expand `download_directory` relative path. This is important because EXISTS doesn't work for 807 | # relative paths. 808 | get_filename_component(download_directory ${download_directory} ABSOLUTE) 809 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS SOURCE_DIR ${download_directory}) 810 | 811 | if(CPM_SOURCE_CACHE) 812 | file(LOCK ${download_directory}/../cmake.lock) 813 | endif() 814 | 815 | if(EXISTS ${download_directory}) 816 | if(CPM_SOURCE_CACHE) 817 | file(LOCK ${download_directory}/../cmake.lock RELEASE) 818 | endif() 819 | 820 | cpm_store_fetch_properties( 821 | ${CPM_ARGS_NAME} "${download_directory}" 822 | "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-build" 823 | ) 824 | cpm_get_fetch_properties("${CPM_ARGS_NAME}") 825 | 826 | if(DEFINED CPM_ARGS_GIT_TAG AND NOT (PATCH_COMMAND IN_LIST CPM_ARGS_UNPARSED_ARGUMENTS)) 827 | # warn if cache has been changed since checkout 828 | cpm_check_git_working_dir_is_clean(${download_directory} ${CPM_ARGS_GIT_TAG} IS_CLEAN) 829 | if(NOT ${IS_CLEAN}) 830 | message( 831 | WARNING "${CPM_INDENT} Cache for ${CPM_ARGS_NAME} (${download_directory}) is dirty" 832 | ) 833 | endif() 834 | endif() 835 | 836 | cpm_add_subdirectory( 837 | "${CPM_ARGS_NAME}" 838 | "${DOWNLOAD_ONLY}" 839 | "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" 840 | "${${CPM_ARGS_NAME}_BINARY_DIR}" 841 | "${CPM_ARGS_EXCLUDE_FROM_ALL}" 842 | "${CPM_ARGS_SYSTEM}" 843 | "${CPM_ARGS_OPTIONS}" 844 | ) 845 | set(PACKAGE_INFO "${PACKAGE_INFO} at ${download_directory}") 846 | 847 | # As the source dir is already cached/populated, we override the call to FetchContent. 848 | set(CPM_SKIP_FETCH TRUE) 849 | cpm_override_fetchcontent( 850 | "${lower_case_name}" SOURCE_DIR "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" 851 | BINARY_DIR "${${CPM_ARGS_NAME}_BINARY_DIR}" 852 | ) 853 | 854 | else() 855 | # Enable shallow clone when GIT_TAG is not a commit hash. Our guess may not be accurate, but 856 | # it should guarantee no commit hash get mis-detected. 857 | if(NOT DEFINED CPM_ARGS_GIT_SHALLOW) 858 | cpm_is_git_tag_commit_hash("${CPM_ARGS_GIT_TAG}" IS_HASH) 859 | if(NOT ${IS_HASH}) 860 | list(APPEND CPM_ARGS_UNPARSED_ARGUMENTS GIT_SHALLOW TRUE) 861 | endif() 862 | endif() 863 | 864 | # remove timestamps so CMake will re-download the dependency 865 | file(REMOVE_RECURSE ${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild) 866 | set(PACKAGE_INFO "${PACKAGE_INFO} to ${download_directory}") 867 | endif() 868 | endif() 869 | 870 | if(NOT "${DOWNLOAD_ONLY}") 871 | cpm_create_module_file(${CPM_ARGS_NAME} "CPMAddPackage(\"${ARGN}\")") 872 | endif() 873 | 874 | if(CPM_PACKAGE_LOCK_ENABLED) 875 | if((CPM_ARGS_VERSION AND NOT CPM_ARGS_SOURCE_DIR) OR CPM_INCLUDE_ALL_IN_PACKAGE_LOCK) 876 | cpm_add_to_package_lock(${CPM_ARGS_NAME} "${ARGN}") 877 | elseif(CPM_ARGS_SOURCE_DIR) 878 | cpm_add_comment_to_package_lock(${CPM_ARGS_NAME} "local directory") 879 | else() 880 | cpm_add_comment_to_package_lock(${CPM_ARGS_NAME} "${ARGN}") 881 | endif() 882 | endif() 883 | 884 | cpm_message( 885 | STATUS "${CPM_INDENT} Adding package ${CPM_ARGS_NAME}@${CPM_ARGS_VERSION} (${PACKAGE_INFO})" 886 | ) 887 | 888 | if(NOT CPM_SKIP_FETCH) 889 | # CMake 3.28 added EXCLUDE, SYSTEM (3.25), and SOURCE_SUBDIR (3.18) to FetchContent_Declare. 890 | # Calling FetchContent_MakeAvailable will then internally forward these options to 891 | # add_subdirectory. Up until these changes, we had to call FetchContent_Populate and 892 | # add_subdirectory separately, which is no longer necessary and has been deprecated as of 3.30. 893 | # A Bug in CMake prevents us to use the non-deprecated functions until 3.30.3. 894 | set(fetchContentDeclareExtraArgs "") 895 | if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30.3") 896 | if(${CPM_ARGS_EXCLUDE_FROM_ALL}) 897 | list(APPEND fetchContentDeclareExtraArgs EXCLUDE_FROM_ALL) 898 | endif() 899 | if(${CPM_ARGS_SYSTEM}) 900 | list(APPEND fetchContentDeclareExtraArgs SYSTEM) 901 | endif() 902 | if(DEFINED CPM_ARGS_SOURCE_SUBDIR) 903 | list(APPEND fetchContentDeclareExtraArgs SOURCE_SUBDIR ${CPM_ARGS_SOURCE_SUBDIR}) 904 | endif() 905 | # For CMake version <3.28 OPTIONS are parsed in cpm_add_subdirectory 906 | if(CPM_ARGS_OPTIONS AND NOT DOWNLOAD_ONLY) 907 | foreach(OPTION ${CPM_ARGS_OPTIONS}) 908 | cpm_parse_option("${OPTION}") 909 | set(${OPTION_KEY} "${OPTION_VALUE}") 910 | endforeach() 911 | endif() 912 | endif() 913 | cpm_declare_fetch( 914 | "${CPM_ARGS_NAME}" ${fetchContentDeclareExtraArgs} "${CPM_ARGS_UNPARSED_ARGUMENTS}" 915 | ) 916 | 917 | cpm_fetch_package("${CPM_ARGS_NAME}" ${DOWNLOAD_ONLY} populated ${CPM_ARGS_UNPARSED_ARGUMENTS}) 918 | if(CPM_SOURCE_CACHE AND download_directory) 919 | file(LOCK ${download_directory}/../cmake.lock RELEASE) 920 | endif() 921 | if(${populated} AND ${CMAKE_VERSION} VERSION_LESS "3.30.3") 922 | cpm_add_subdirectory( 923 | "${CPM_ARGS_NAME}" 924 | "${DOWNLOAD_ONLY}" 925 | "${${CPM_ARGS_NAME}_SOURCE_DIR}/${CPM_ARGS_SOURCE_SUBDIR}" 926 | "${${CPM_ARGS_NAME}_BINARY_DIR}" 927 | "${CPM_ARGS_EXCLUDE_FROM_ALL}" 928 | "${CPM_ARGS_SYSTEM}" 929 | "${CPM_ARGS_OPTIONS}" 930 | ) 931 | endif() 932 | cpm_get_fetch_properties("${CPM_ARGS_NAME}") 933 | endif() 934 | 935 | set(${CPM_ARGS_NAME}_ADDED YES) 936 | cpm_export_variables("${CPM_ARGS_NAME}") 937 | endfunction() 938 | 939 | # Fetch a previously declared package 940 | macro(CPMGetPackage Name) 941 | if(DEFINED "CPM_DECLARATION_${Name}") 942 | CPMAddPackage(NAME ${Name}) 943 | else() 944 | message(SEND_ERROR "${CPM_INDENT} Cannot retrieve package ${Name}: no declaration available") 945 | endif() 946 | endmacro() 947 | 948 | # export variables available to the caller to the parent scope expects ${CPM_ARGS_NAME} to be set 949 | macro(cpm_export_variables name) 950 | set(${name}_SOURCE_DIR 951 | "${${name}_SOURCE_DIR}" 952 | PARENT_SCOPE 953 | ) 954 | set(${name}_BINARY_DIR 955 | "${${name}_BINARY_DIR}" 956 | PARENT_SCOPE 957 | ) 958 | set(${name}_ADDED 959 | "${${name}_ADDED}" 960 | PARENT_SCOPE 961 | ) 962 | set(CPM_LAST_PACKAGE_NAME 963 | "${name}" 964 | PARENT_SCOPE 965 | ) 966 | endmacro() 967 | 968 | # declares a package, so that any call to CPMAddPackage for the package name will use these 969 | # arguments instead. Previous declarations will not be overridden. 970 | macro(CPMDeclarePackage Name) 971 | if(NOT DEFINED "CPM_DECLARATION_${Name}") 972 | set("CPM_DECLARATION_${Name}" "${ARGN}") 973 | endif() 974 | endmacro() 975 | 976 | function(cpm_add_to_package_lock Name) 977 | if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) 978 | cpm_prettify_package_arguments(PRETTY_ARGN false ${ARGN}) 979 | file(APPEND ${CPM_PACKAGE_LOCK_FILE} "# ${Name}\nCPMDeclarePackage(${Name}\n${PRETTY_ARGN})\n") 980 | endif() 981 | endfunction() 982 | 983 | function(cpm_add_comment_to_package_lock Name) 984 | if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) 985 | cpm_prettify_package_arguments(PRETTY_ARGN true ${ARGN}) 986 | file(APPEND ${CPM_PACKAGE_LOCK_FILE} 987 | "# ${Name} (unversioned)\n# CPMDeclarePackage(${Name}\n${PRETTY_ARGN}#)\n" 988 | ) 989 | endif() 990 | endfunction() 991 | 992 | # includes the package lock file if it exists and creates a target `cpm-update-package-lock` to 993 | # update it 994 | macro(CPMUsePackageLock file) 995 | if(NOT CPM_DONT_CREATE_PACKAGE_LOCK) 996 | get_filename_component(CPM_ABSOLUTE_PACKAGE_LOCK_PATH ${file} ABSOLUTE) 997 | if(EXISTS ${CPM_ABSOLUTE_PACKAGE_LOCK_PATH}) 998 | include(${CPM_ABSOLUTE_PACKAGE_LOCK_PATH}) 999 | endif() 1000 | if(NOT TARGET cpm-update-package-lock) 1001 | add_custom_target( 1002 | cpm-update-package-lock COMMAND ${CMAKE_COMMAND} -E copy ${CPM_PACKAGE_LOCK_FILE} 1003 | ${CPM_ABSOLUTE_PACKAGE_LOCK_PATH} 1004 | ) 1005 | endif() 1006 | set(CPM_PACKAGE_LOCK_ENABLED true) 1007 | endif() 1008 | endmacro() 1009 | 1010 | # registers a package that has been added to CPM 1011 | function(CPMRegisterPackage PACKAGE VERSION) 1012 | list(APPEND CPM_PACKAGES ${PACKAGE}) 1013 | set(CPM_PACKAGES 1014 | ${CPM_PACKAGES} 1015 | CACHE INTERNAL "" 1016 | ) 1017 | set("CPM_PACKAGE_${PACKAGE}_VERSION" 1018 | ${VERSION} 1019 | CACHE INTERNAL "" 1020 | ) 1021 | endfunction() 1022 | 1023 | # retrieve the current version of the package to ${OUTPUT} 1024 | function(CPMGetPackageVersion PACKAGE OUTPUT) 1025 | set(${OUTPUT} 1026 | "${CPM_PACKAGE_${PACKAGE}_VERSION}" 1027 | PARENT_SCOPE 1028 | ) 1029 | endfunction() 1030 | 1031 | # declares a package in FetchContent_Declare 1032 | function(cpm_declare_fetch PACKAGE) 1033 | if(${CPM_DRY_RUN}) 1034 | cpm_message(STATUS "${CPM_INDENT} Package not declared (dry run)") 1035 | return() 1036 | endif() 1037 | 1038 | FetchContent_Declare(${PACKAGE} ${ARGN}) 1039 | endfunction() 1040 | 1041 | # returns properties for a package previously defined by cpm_declare_fetch 1042 | function(cpm_get_fetch_properties PACKAGE) 1043 | if(${CPM_DRY_RUN}) 1044 | return() 1045 | endif() 1046 | 1047 | set(${PACKAGE}_SOURCE_DIR 1048 | "${CPM_PACKAGE_${PACKAGE}_SOURCE_DIR}" 1049 | PARENT_SCOPE 1050 | ) 1051 | set(${PACKAGE}_BINARY_DIR 1052 | "${CPM_PACKAGE_${PACKAGE}_BINARY_DIR}" 1053 | PARENT_SCOPE 1054 | ) 1055 | endfunction() 1056 | 1057 | function(cpm_store_fetch_properties PACKAGE source_dir binary_dir) 1058 | if(${CPM_DRY_RUN}) 1059 | return() 1060 | endif() 1061 | 1062 | set(CPM_PACKAGE_${PACKAGE}_SOURCE_DIR 1063 | "${source_dir}" 1064 | CACHE INTERNAL "" 1065 | ) 1066 | set(CPM_PACKAGE_${PACKAGE}_BINARY_DIR 1067 | "${binary_dir}" 1068 | CACHE INTERNAL "" 1069 | ) 1070 | endfunction() 1071 | 1072 | # adds a package as a subdirectory if viable, according to provided options 1073 | function( 1074 | cpm_add_subdirectory 1075 | PACKAGE 1076 | DOWNLOAD_ONLY 1077 | SOURCE_DIR 1078 | BINARY_DIR 1079 | EXCLUDE 1080 | SYSTEM 1081 | OPTIONS 1082 | ) 1083 | 1084 | if(NOT DOWNLOAD_ONLY AND EXISTS ${SOURCE_DIR}/CMakeLists.txt) 1085 | set(addSubdirectoryExtraArgs "") 1086 | if(EXCLUDE) 1087 | list(APPEND addSubdirectoryExtraArgs EXCLUDE_FROM_ALL) 1088 | endif() 1089 | if("${SYSTEM}" AND "${CMAKE_VERSION}" VERSION_GREATER_EQUAL "3.25") 1090 | # https://cmake.org/cmake/help/latest/prop_dir/SYSTEM.html#prop_dir:SYSTEM 1091 | list(APPEND addSubdirectoryExtraArgs SYSTEM) 1092 | endif() 1093 | if(OPTIONS) 1094 | foreach(OPTION ${OPTIONS}) 1095 | cpm_parse_option("${OPTION}") 1096 | set(${OPTION_KEY} "${OPTION_VALUE}") 1097 | endforeach() 1098 | endif() 1099 | set(CPM_OLD_INDENT "${CPM_INDENT}") 1100 | set(CPM_INDENT "${CPM_INDENT} ${PACKAGE}:") 1101 | add_subdirectory(${SOURCE_DIR} ${BINARY_DIR} ${addSubdirectoryExtraArgs}) 1102 | set(CPM_INDENT "${CPM_OLD_INDENT}") 1103 | endif() 1104 | endfunction() 1105 | 1106 | # downloads a previously declared package via FetchContent and exports the variables 1107 | # `${PACKAGE}_SOURCE_DIR` and `${PACKAGE}_BINARY_DIR` to the parent scope 1108 | function(cpm_fetch_package PACKAGE DOWNLOAD_ONLY populated) 1109 | set(${populated} 1110 | FALSE 1111 | PARENT_SCOPE 1112 | ) 1113 | if(${CPM_DRY_RUN}) 1114 | cpm_message(STATUS "${CPM_INDENT} Package ${PACKAGE} not fetched (dry run)") 1115 | return() 1116 | endif() 1117 | 1118 | FetchContent_GetProperties(${PACKAGE}) 1119 | 1120 | string(TOLOWER "${PACKAGE}" lower_case_name) 1121 | 1122 | if(NOT ${lower_case_name}_POPULATED) 1123 | if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.30.3") 1124 | if(DOWNLOAD_ONLY) 1125 | # MakeAvailable will call add_subdirectory internally which is not what we want when 1126 | # DOWNLOAD_ONLY is set. Populate will only download the dependency without adding it to the 1127 | # build 1128 | FetchContent_Populate( 1129 | ${PACKAGE} 1130 | SOURCE_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-src" 1131 | BINARY_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-build" 1132 | SUBBUILD_DIR "${CPM_FETCHCONTENT_BASE_DIR}/${lower_case_name}-subbuild" 1133 | ${ARGN} 1134 | ) 1135 | else() 1136 | FetchContent_MakeAvailable(${PACKAGE}) 1137 | endif() 1138 | else() 1139 | FetchContent_Populate(${PACKAGE}) 1140 | endif() 1141 | set(${populated} 1142 | TRUE 1143 | PARENT_SCOPE 1144 | ) 1145 | endif() 1146 | 1147 | cpm_store_fetch_properties( 1148 | ${CPM_ARGS_NAME} ${${lower_case_name}_SOURCE_DIR} ${${lower_case_name}_BINARY_DIR} 1149 | ) 1150 | 1151 | set(${PACKAGE}_SOURCE_DIR 1152 | ${${lower_case_name}_SOURCE_DIR} 1153 | PARENT_SCOPE 1154 | ) 1155 | set(${PACKAGE}_BINARY_DIR 1156 | ${${lower_case_name}_BINARY_DIR} 1157 | PARENT_SCOPE 1158 | ) 1159 | endfunction() 1160 | 1161 | # splits a package option 1162 | function(cpm_parse_option OPTION) 1163 | string(REGEX MATCH "^[^ ]+" OPTION_KEY "${OPTION}") 1164 | string(LENGTH "${OPTION}" OPTION_LENGTH) 1165 | string(LENGTH "${OPTION_KEY}" OPTION_KEY_LENGTH) 1166 | if(OPTION_KEY_LENGTH STREQUAL OPTION_LENGTH) 1167 | # no value for key provided, assume user wants to set option to "ON" 1168 | set(OPTION_VALUE "ON") 1169 | else() 1170 | math(EXPR OPTION_KEY_LENGTH "${OPTION_KEY_LENGTH}+1") 1171 | string(SUBSTRING "${OPTION}" "${OPTION_KEY_LENGTH}" "-1" OPTION_VALUE) 1172 | endif() 1173 | set(OPTION_KEY 1174 | "${OPTION_KEY}" 1175 | PARENT_SCOPE 1176 | ) 1177 | set(OPTION_VALUE 1178 | "${OPTION_VALUE}" 1179 | PARENT_SCOPE 1180 | ) 1181 | endfunction() 1182 | 1183 | # guesses the package version from a git tag 1184 | function(cpm_get_version_from_git_tag GIT_TAG RESULT) 1185 | string(LENGTH ${GIT_TAG} length) 1186 | if(length EQUAL 40) 1187 | # GIT_TAG is probably a git hash 1188 | set(${RESULT} 1189 | 0 1190 | PARENT_SCOPE 1191 | ) 1192 | else() 1193 | string(REGEX MATCH "v?([0123456789.]*).*" _ ${GIT_TAG}) 1194 | set(${RESULT} 1195 | ${CMAKE_MATCH_1} 1196 | PARENT_SCOPE 1197 | ) 1198 | endif() 1199 | endfunction() 1200 | 1201 | # guesses if the git tag is a commit hash or an actual tag or a branch name. 1202 | function(cpm_is_git_tag_commit_hash GIT_TAG RESULT) 1203 | string(LENGTH "${GIT_TAG}" length) 1204 | # full hash has 40 characters, and short hash has at least 7 characters. 1205 | if(length LESS 7 OR length GREATER 40) 1206 | set(${RESULT} 1207 | 0 1208 | PARENT_SCOPE 1209 | ) 1210 | else() 1211 | if(${GIT_TAG} MATCHES "^[a-fA-F0-9]+$") 1212 | set(${RESULT} 1213 | 1 1214 | PARENT_SCOPE 1215 | ) 1216 | else() 1217 | set(${RESULT} 1218 | 0 1219 | PARENT_SCOPE 1220 | ) 1221 | endif() 1222 | endif() 1223 | endfunction() 1224 | 1225 | function(cpm_prettify_package_arguments OUT_VAR IS_IN_COMMENT) 1226 | set(oneValueArgs 1227 | NAME 1228 | FORCE 1229 | VERSION 1230 | GIT_TAG 1231 | DOWNLOAD_ONLY 1232 | GITHUB_REPOSITORY 1233 | GITLAB_REPOSITORY 1234 | BITBUCKET_REPOSITORY 1235 | GIT_REPOSITORY 1236 | SOURCE_DIR 1237 | FIND_PACKAGE_ARGUMENTS 1238 | NO_CACHE 1239 | SYSTEM 1240 | GIT_SHALLOW 1241 | EXCLUDE_FROM_ALL 1242 | SOURCE_SUBDIR 1243 | ) 1244 | set(multiValueArgs URL OPTIONS DOWNLOAD_COMMAND) 1245 | cmake_parse_arguments(CPM_ARGS "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN}) 1246 | 1247 | foreach(oneArgName ${oneValueArgs}) 1248 | if(DEFINED CPM_ARGS_${oneArgName}) 1249 | if(${IS_IN_COMMENT}) 1250 | string(APPEND PRETTY_OUT_VAR "#") 1251 | endif() 1252 | if(${oneArgName} STREQUAL "SOURCE_DIR") 1253 | string(REPLACE ${CMAKE_SOURCE_DIR} "\${CMAKE_SOURCE_DIR}" CPM_ARGS_${oneArgName} 1254 | ${CPM_ARGS_${oneArgName}} 1255 | ) 1256 | endif() 1257 | string(APPEND PRETTY_OUT_VAR " ${oneArgName} ${CPM_ARGS_${oneArgName}}\n") 1258 | endif() 1259 | endforeach() 1260 | foreach(multiArgName ${multiValueArgs}) 1261 | if(DEFINED CPM_ARGS_${multiArgName}) 1262 | if(${IS_IN_COMMENT}) 1263 | string(APPEND PRETTY_OUT_VAR "#") 1264 | endif() 1265 | string(APPEND PRETTY_OUT_VAR " ${multiArgName}\n") 1266 | foreach(singleOption ${CPM_ARGS_${multiArgName}}) 1267 | if(${IS_IN_COMMENT}) 1268 | string(APPEND PRETTY_OUT_VAR "#") 1269 | endif() 1270 | string(APPEND PRETTY_OUT_VAR " \"${singleOption}\"\n") 1271 | endforeach() 1272 | endif() 1273 | endforeach() 1274 | 1275 | if(NOT "${CPM_ARGS_UNPARSED_ARGUMENTS}" STREQUAL "") 1276 | if(${IS_IN_COMMENT}) 1277 | string(APPEND PRETTY_OUT_VAR "#") 1278 | endif() 1279 | string(APPEND PRETTY_OUT_VAR " ") 1280 | foreach(CPM_ARGS_UNPARSED_ARGUMENT ${CPM_ARGS_UNPARSED_ARGUMENTS}) 1281 | string(APPEND PRETTY_OUT_VAR " ${CPM_ARGS_UNPARSED_ARGUMENT}") 1282 | endforeach() 1283 | string(APPEND PRETTY_OUT_VAR "\n") 1284 | endif() 1285 | 1286 | set(${OUT_VAR} 1287 | ${PRETTY_OUT_VAR} 1288 | PARENT_SCOPE 1289 | ) 1290 | 1291 | endfunction() 1292 | --------------------------------------------------------------------------------