mirror of
https://git.eden-emu.dev/eden-emu/eden.git
synced 2025-10-06 00:02:44 +02:00
83730cd4c1
Updates sirit to our fork's latest version w/ SPIRV Headers included (end goal is to remove spirv-headers entirely, as spirv-tools-ci should include them inline as well) Adds a sirit CI on our fork for all platforms (saves a bit of compile time) My CI spec has changed a little bit, and now there is no need for an additional CMake file after the initial CMakeLists.txt (since targets are now global imported). Plus, UNIX amd64 now has the amd64 suffix like aarch64 and windows Updates SDL2 to 2.32.10 and OpenSSL to 3.6.0 Finally, on Solaris all CI packages (sans FFmpeg) are now built with OmniOS, which should in theory be fully compatible with OpenIndiana (our recommended Sun-based target) but obviously will need testing Need testing: - [ ] Make sure I didn't nuke shader emission - [ ] Make sure FreeBSD, OpenBSD, and OpenIndiana work fine with bundled sirit (check linking especially) - [ ] Make sure SDL2, OpenSSL work with OpenIndiana now - [ ] SDL2 on all platforms (input, etc) Signed-off-by: crueter <crueter@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2655
619 lines
19 KiB
CMake
619 lines
19 KiB
CMake
# SPDX-FileCopyrightText: Copyright 2025 crueter
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
if (MSVC OR ANDROID)
|
|
set(BUNDLED_DEFAULT ON)
|
|
else()
|
|
set(BUNDLED_DEFAULT OFF)
|
|
endif()
|
|
|
|
option(CPMUTIL_FORCE_BUNDLED
|
|
"Force bundled packages for all CPM depdendencies" ${BUNDLED_DEFAULT})
|
|
|
|
option(CPMUTIL_FORCE_SYSTEM
|
|
"Force system packages for all CPM dependencies (NOT RECOMMENDED)" OFF)
|
|
|
|
cmake_minimum_required(VERSION 3.22)
|
|
include(CPM)
|
|
|
|
# cpmfile parsing
|
|
set(CPMUTIL_JSON_FILE "${CMAKE_CURRENT_SOURCE_DIR}/cpmfile.json")
|
|
|
|
if (EXISTS ${CPMUTIL_JSON_FILE})
|
|
file(READ ${CPMUTIL_JSON_FILE} CPMFILE_CONTENT)
|
|
else()
|
|
message(WARNING "[CPMUtil] cpmfile ${CPMUTIL_JSON_FILE} does not exist, AddJsonPackage will be a no-op")
|
|
endif()
|
|
|
|
# Utility stuff
|
|
function(cpm_utils_message level name message)
|
|
message(${level} "[CPMUtil] ${name}: ${message}")
|
|
endfunction()
|
|
|
|
function(array_to_list array length out)
|
|
math(EXPR range "${length} - 1")
|
|
|
|
foreach(IDX RANGE ${range})
|
|
string(JSON _element GET "${array}" "${IDX}")
|
|
|
|
list(APPEND NEW_LIST ${_element})
|
|
endforeach()
|
|
|
|
set("${out}" "${NEW_LIST}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(get_json_element object out member default)
|
|
string(JSON out_type ERROR_VARIABLE err TYPE "${object}" ${member})
|
|
|
|
if (err)
|
|
set("${out}" "${default}" PARENT_SCOPE)
|
|
return()
|
|
endif()
|
|
|
|
string(JSON outvar GET "${object}" ${member})
|
|
|
|
if (out_type STREQUAL "ARRAY")
|
|
string(JSON _len LENGTH "${object}" ${member})
|
|
# array_to_list("${outvar}" ${_len} outvar)
|
|
set("${out}_LENGTH" "${_len}" PARENT_SCOPE)
|
|
endif()
|
|
|
|
set("${out}" "${outvar}" PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# The preferred usage
|
|
function(AddJsonPackage)
|
|
set(oneValueArgs
|
|
NAME
|
|
|
|
# these are overrides that can be generated at runtime, so can be defined separately from the json
|
|
DOWNLOAD_ONLY
|
|
BUNDLED_PACKAGE
|
|
)
|
|
|
|
set(multiValueArgs OPTIONS)
|
|
|
|
cmake_parse_arguments(JSON "" "${oneValueArgs}" "${multiValueArgs}"
|
|
"${ARGN}")
|
|
|
|
list(LENGTH ARGN argnLength)
|
|
|
|
# single name argument
|
|
if(argnLength EQUAL 1)
|
|
set(JSON_NAME "${ARGV0}")
|
|
endif()
|
|
|
|
if (NOT DEFINED CPMFILE_CONTENT)
|
|
cpm_utils_message(WARNING ${name} "No cpmfile, AddJsonPackage is a no-op")
|
|
return()
|
|
endif()
|
|
|
|
if (NOT DEFINED JSON_NAME)
|
|
cpm_utils_message(FATAL_ERROR "json package" "No name specified")
|
|
endif()
|
|
|
|
string(JSON object ERROR_VARIABLE err GET "${CPMFILE_CONTENT}" "${JSON_NAME}")
|
|
|
|
if (err)
|
|
cpm_utils_message(FATAL_ERROR ${JSON_NAME} "Not found in cpmfile")
|
|
endif()
|
|
|
|
get_json_element("${object}" package package ${JSON_NAME})
|
|
get_json_element("${object}" repo repo "")
|
|
get_json_element("${object}" ci ci OFF)
|
|
get_json_element("${object}" version version "")
|
|
|
|
if (ci)
|
|
get_json_element("${object}" name name "${JSON_NAME}")
|
|
get_json_element("${object}" extension extension "tar.zst")
|
|
get_json_element("${object}" min_version min_version "")
|
|
get_json_element("${object}" raw_disabled disabled_platforms "")
|
|
|
|
if (raw_disabled)
|
|
array_to_list("${raw_disabled}" ${raw_disabled_LENGTH} disabled_platforms)
|
|
else()
|
|
set(disabled_platforms "")
|
|
endif()
|
|
|
|
AddCIPackage(
|
|
VERSION ${version}
|
|
NAME ${name}
|
|
REPO ${repo}
|
|
PACKAGE ${package}
|
|
EXTENSION ${extension}
|
|
MIN_VERSION ${min_version}
|
|
DISABLED_PLATFORMS ${disabled_platforms}
|
|
)
|
|
|
|
# pass stuff to parent scope
|
|
set(${package}_ADDED "${${package}_ADDED}"
|
|
PARENT_SCOPE)
|
|
set(${package}_SOURCE_DIR "${${package}_SOURCE_DIR}"
|
|
PARENT_SCOPE)
|
|
set(${package}_BINARY_DIR "${${package}_BINARY_DIR}"
|
|
PARENT_SCOPE)
|
|
|
|
return()
|
|
endif()
|
|
|
|
get_json_element("${object}" hash hash "")
|
|
get_json_element("${object}" hash_suffix hash_suffix "")
|
|
get_json_element("${object}" sha sha "")
|
|
get_json_element("${object}" url url "")
|
|
get_json_element("${object}" key key "")
|
|
get_json_element("${object}" tag tag "")
|
|
get_json_element("${object}" artifact artifact "")
|
|
get_json_element("${object}" git_version git_version "")
|
|
get_json_element("${object}" git_host git_host "")
|
|
get_json_element("${object}" source_subdir source_subdir "")
|
|
get_json_element("${object}" bundled bundled "unset")
|
|
get_json_element("${object}" find_args find_args "")
|
|
get_json_element("${object}" raw_patches patches "")
|
|
|
|
# okay here comes the fun part: REPLACEMENTS!
|
|
# first: tag gets %VERSION% replaced if applicable, with either git_version (preferred) or version
|
|
# second: artifact gets %VERSION% and %TAG% replaced accordingly (same rules for VERSION)
|
|
|
|
if (git_version)
|
|
set(version_replace ${git_version})
|
|
else()
|
|
set(version_replace ${version})
|
|
endif()
|
|
|
|
# TODO(crueter): fmt module for cmake
|
|
if (tag)
|
|
string(REPLACE "%VERSION%" "${version_replace}" tag ${tag})
|
|
endif()
|
|
|
|
if (artifact)
|
|
string(REPLACE "%VERSION%" "${version_replace}" artifact ${artifact})
|
|
string(REPLACE "%TAG%" "${tag}" artifact ${artifact})
|
|
endif()
|
|
|
|
# format patchdir
|
|
if (raw_patches)
|
|
math(EXPR range "${raw_patches_LENGTH} - 1")
|
|
|
|
foreach(IDX RANGE ${range})
|
|
string(JSON _patch GET "${raw_patches}" "${IDX}")
|
|
|
|
set(full_patch "${CMAKE_SOURCE_DIR}/.patch/${JSON_NAME}/${_patch}")
|
|
if (NOT EXISTS ${full_patch})
|
|
cpm_utils_message(FATAL_ERROR ${JSON_NAME} "specifies patch ${full_patch} which does not exist")
|
|
endif()
|
|
|
|
list(APPEND patches "${full_patch}")
|
|
endforeach()
|
|
endif()
|
|
# end format patchdir
|
|
|
|
# options
|
|
get_json_element("${object}" raw_options options "")
|
|
|
|
if (raw_options)
|
|
array_to_list("${raw_options}" ${raw_options_LENGTH} options)
|
|
endif()
|
|
|
|
set(options ${options} ${JSON_OPTIONS})
|
|
# end options
|
|
|
|
# system/bundled
|
|
if (bundled STREQUAL "unset" AND DEFINED JSON_BUNDLED_PACKAGE)
|
|
set(bundled ${JSON_BUNDLED_PACKAGE})
|
|
endif()
|
|
|
|
AddPackage(
|
|
NAME "${package}"
|
|
VERSION "${version}"
|
|
URL "${url}"
|
|
HASH "${hash}"
|
|
HASH_SUFFIX "${hash_suffix}"
|
|
SHA "${sha}"
|
|
REPO "${repo}"
|
|
KEY "${key}"
|
|
PATCHES "${patches}"
|
|
OPTIONS "${options}"
|
|
FIND_PACKAGE_ARGUMENTS "${find_args}"
|
|
BUNDLED_PACKAGE "${bundled}"
|
|
SOURCE_SUBDIR "${source_subdir}"
|
|
|
|
GIT_VERSION ${git_version}
|
|
GIT_HOST ${git_host}
|
|
|
|
ARTIFACT ${artifact}
|
|
TAG ${tag}
|
|
)
|
|
|
|
# pass stuff to parent scope
|
|
set(${package}_ADDED "${${package}_ADDED}"
|
|
PARENT_SCOPE)
|
|
set(${package}_SOURCE_DIR "${${package}_SOURCE_DIR}"
|
|
PARENT_SCOPE)
|
|
set(${package}_BINARY_DIR "${${package}_BINARY_DIR}"
|
|
PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
function(AddPackage)
|
|
cpm_set_policies()
|
|
|
|
# TODO(crueter): git clone?
|
|
|
|
#[[
|
|
URL configurations, descending order of precedence:
|
|
- URL [+ GIT_URL] -> bare URL fetch
|
|
- REPO + TAG + ARTIFACT -> github release artifact
|
|
- REPO + TAG -> github release archive
|
|
- REPO + SHA -> github commit archive
|
|
- REPO + BRANCH -> github branch
|
|
|
|
Hash configurations, descending order of precedence:
|
|
- HASH -> bare sha512sum
|
|
- HASH_SUFFIX -> hash grabbed from the URL + this suffix
|
|
- HASH_URL -> hash grabbed from a URL
|
|
* technically this is unsafe since a hacker can attack that url
|
|
|
|
NOTE: hash algo defaults to sha512
|
|
#]]
|
|
set(oneValueArgs
|
|
NAME
|
|
VERSION
|
|
GIT_VERSION
|
|
GIT_HOST
|
|
|
|
REPO
|
|
TAG
|
|
ARTIFACT
|
|
SHA
|
|
BRANCH
|
|
|
|
HASH
|
|
HASH_SUFFIX
|
|
HASH_URL
|
|
HASH_ALGO
|
|
|
|
URL
|
|
GIT_URL
|
|
|
|
KEY
|
|
BUNDLED_PACKAGE
|
|
FIND_PACKAGE_ARGUMENTS
|
|
)
|
|
|
|
set(multiValueArgs OPTIONS PATCHES)
|
|
|
|
cmake_parse_arguments(PKG_ARGS "" "${oneValueArgs}" "${multiValueArgs}"
|
|
"${ARGN}")
|
|
|
|
if (NOT DEFINED PKG_ARGS_NAME)
|
|
cpm_utils_message(FATAL_ERROR "package" "No package name defined")
|
|
endif()
|
|
|
|
option(${PKG_ARGS_NAME}_FORCE_SYSTEM "Force the system package for ${PKG_ARGS_NAME}")
|
|
option(${PKG_ARGS_NAME}_FORCE_BUNDLED "Force the bundled package for ${PKG_ARGS_NAME}")
|
|
|
|
if (NOT DEFINED PKG_ARGS_GIT_HOST)
|
|
set(git_host github.com)
|
|
else()
|
|
set(git_host ${PKG_ARGS_GIT_HOST})
|
|
endif()
|
|
|
|
if (DEFINED PKG_ARGS_URL)
|
|
set(pkg_url ${PKG_ARGS_URL})
|
|
|
|
if (DEFINED PKG_ARGS_REPO)
|
|
set(pkg_git_url https://${git_host}/${PKG_ARGS_REPO})
|
|
else()
|
|
if (DEFINED PKG_ARGS_GIT_URL)
|
|
set(pkg_git_url ${PKG_ARGS_GIT_URL})
|
|
else()
|
|
set(pkg_git_url ${pkg_url})
|
|
endif()
|
|
endif()
|
|
elseif (DEFINED PKG_ARGS_REPO)
|
|
set(pkg_git_url https://${git_host}/${PKG_ARGS_REPO})
|
|
|
|
if (DEFINED PKG_ARGS_TAG)
|
|
set(pkg_key ${PKG_ARGS_TAG})
|
|
|
|
if(DEFINED PKG_ARGS_ARTIFACT)
|
|
set(pkg_url
|
|
${pkg_git_url}/releases/download/${PKG_ARGS_TAG}/${PKG_ARGS_ARTIFACT})
|
|
else()
|
|
set(pkg_url
|
|
${pkg_git_url}/archive/refs/tags/${PKG_ARGS_TAG}.tar.gz)
|
|
endif()
|
|
elseif (DEFINED PKG_ARGS_SHA)
|
|
set(pkg_url "${pkg_git_url}/archive/${PKG_ARGS_SHA}.zip")
|
|
else()
|
|
if (DEFINED PKG_ARGS_BRANCH)
|
|
set(PKG_BRANCH ${PKG_ARGS_BRANCH})
|
|
else()
|
|
cpm_utils_message(WARNING ${PKG_ARGS_NAME}
|
|
"REPO defined but no TAG, SHA, BRANCH, or URL specified, defaulting to master")
|
|
set(PKG_BRANCH master)
|
|
endif()
|
|
|
|
set(pkg_url ${pkg_git_url}/archive/refs/heads/${PKG_BRANCH}.zip)
|
|
endif()
|
|
else()
|
|
cpm_utils_message(FATAL_ERROR ${PKG_ARGS_NAME} "No URL or repository defined")
|
|
endif()
|
|
|
|
cpm_utils_message(STATUS ${PKG_ARGS_NAME} "Download URL is ${pkg_url}")
|
|
|
|
if (NOT DEFINED PKG_ARGS_KEY)
|
|
if (DEFINED PKG_ARGS_SHA)
|
|
string(SUBSTRING ${PKG_ARGS_SHA} 0 4 pkg_key)
|
|
cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
|
|
"No custom key defined, using ${pkg_key} from sha")
|
|
elseif(DEFINED PKG_ARGS_GIT_VERSION)
|
|
set(pkg_key ${PKG_ARGS_GIT_VERSION})
|
|
cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
|
|
"No custom key defined, using ${pkg_key}")
|
|
elseif (DEFINED PKG_ARGS_TAG)
|
|
set(pkg_key ${PKG_ARGS_TAG})
|
|
cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
|
|
"No custom key defined, using ${pkg_key}")
|
|
elseif (DEFINED PKG_ARGS_VERSION)
|
|
set(pkg_key ${PKG_ARGS_VERSION})
|
|
cpm_utils_message(DEBUG ${PKG_ARGS_NAME}
|
|
"No custom key defined, using ${pkg_key}")
|
|
else()
|
|
cpm_utils_message(WARNING ${PKG_ARGS_NAME}
|
|
"Could not determine cache key, using CPM defaults")
|
|
endif()
|
|
else()
|
|
set(pkg_key ${PKG_ARGS_KEY})
|
|
endif()
|
|
|
|
if (DEFINED PKG_ARGS_HASH_ALGO)
|
|
set(hash_algo ${PKG_ARGS_HASH_ALGO})
|
|
else()
|
|
set(hash_algo SHA512)
|
|
endif()
|
|
|
|
if (DEFINED PKG_ARGS_HASH)
|
|
set(pkg_hash "${hash_algo}=${PKG_ARGS_HASH}")
|
|
elseif (DEFINED PKG_ARGS_HASH_SUFFIX)
|
|
# funny sanity check
|
|
string(TOLOWER ${hash_algo} hash_algo_lower)
|
|
string(TOLOWER ${PKG_ARGS_HASH_SUFFIX} suffix_lower)
|
|
if (NOT ${suffix_lower} MATCHES ${hash_algo_lower})
|
|
cpm_utils_message(WARNING
|
|
"Hash algorithm and hash suffix do not match, errors may occur")
|
|
endif()
|
|
|
|
set(hash_url ${pkg_url}.${PKG_ARGS_HASH_SUFFIX})
|
|
elseif (DEFINED PKG_ARGS_HASH_URL)
|
|
set(hash_url ${PKG_ARGS_HASH_URL})
|
|
else()
|
|
cpm_utils_message(WARNING ${PKG_ARGS_NAME}
|
|
"No hash or hash URL found")
|
|
endif()
|
|
|
|
if (DEFINED hash_url)
|
|
set(outfile ${CMAKE_CURRENT_BINARY_DIR}/${PKG_ARGS_NAME}.hash)
|
|
|
|
# TODO(crueter): This is kind of a bad solution
|
|
# because "technically" the hash is invalidated each week
|
|
# but it works for now kjsdnfkjdnfjksdn
|
|
string(TOLOWER ${PKG_ARGS_NAME} lowername)
|
|
if (NOT EXISTS ${outfile} AND NOT EXISTS ${CPM_SOURCE_CACHE}/${lowername}/${pkg_key})
|
|
file(DOWNLOAD ${hash_url} ${outfile})
|
|
endif()
|
|
|
|
if (EXISTS ${outfile})
|
|
file(READ ${outfile} pkg_hash_tmp)
|
|
endif()
|
|
|
|
if (DEFINED ${pkg_hash_tmp})
|
|
set(pkg_hash "${hash_algo}=${pkg_hash_tmp}")
|
|
endif()
|
|
endif()
|
|
|
|
macro(set_precedence local force)
|
|
set(CPM_USE_LOCAL_PACKAGES ${local})
|
|
set(CPM_LOCAL_PACKAGES_ONLY ${force})
|
|
endmacro()
|
|
|
|
#[[
|
|
Precedence:
|
|
- package_FORCE_SYSTEM
|
|
- package_FORCE_BUNDLED
|
|
- CPMUTIL_FORCE_SYSTEM
|
|
- CPMUTIL_FORCE_BUNDLED
|
|
- BUNDLED_PACKAGE
|
|
- default to allow local
|
|
]]#
|
|
if (${PKG_ARGS_NAME}_FORCE_SYSTEM)
|
|
set_precedence(ON ON)
|
|
elseif (${PKG_ARGS_NAME}_FORCE_BUNDLED)
|
|
set_precedence(OFF OFF)
|
|
elseif (CPMUTIL_FORCE_SYSTEM)
|
|
set_precedence(ON ON)
|
|
elseif(CPMUTIL_FORCE_BUNDLED)
|
|
set_precedence(OFF OFF)
|
|
elseif (DEFINED PKG_ARGS_BUNDLED_PACKAGE AND NOT PKG_ARGS_BUNDLED_PACKAGE STREQUAL "unset")
|
|
if (PKG_ARGS_BUNDLED_PACKAGE)
|
|
set(local OFF)
|
|
else()
|
|
set(local ON)
|
|
endif()
|
|
|
|
set_precedence(${local} OFF)
|
|
else()
|
|
set_precedence(ON OFF)
|
|
endif()
|
|
|
|
CPMAddPackage(
|
|
NAME ${PKG_ARGS_NAME}
|
|
VERSION ${PKG_ARGS_VERSION}
|
|
URL ${pkg_url}
|
|
URL_HASH ${pkg_hash}
|
|
CUSTOM_CACHE_KEY ${pkg_key}
|
|
DOWNLOAD_ONLY ${PKG_ARGS_DOWNLOAD_ONLY}
|
|
FIND_PACKAGE_ARGUMENTS ${PKG_ARGS_FIND_PACKAGE_ARGUMENTS}
|
|
|
|
OPTIONS ${PKG_ARGS_OPTIONS}
|
|
PATCHES ${PKG_ARGS_PATCHES}
|
|
EXCLUDE_FROM_ALL ON
|
|
|
|
${PKG_ARGS_UNPARSED_ARGUMENTS}
|
|
)
|
|
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_NAMES ${PKG_ARGS_NAME})
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_URLS ${pkg_git_url})
|
|
|
|
if (${PKG_ARGS_NAME}_ADDED)
|
|
if (DEFINED PKG_ARGS_SHA)
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
${PKG_ARGS_SHA})
|
|
elseif (DEFINED PKG_ARGS_GIT_VERSION)
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
${PKG_ARGS_GIT_VERSION})
|
|
elseif (DEFINED PKG_ARGS_TAG)
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
${PKG_ARGS_TAG})
|
|
elseif(DEFINED PKG_ARGS_VERSION)
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
${PKG_ARGS_VERSION})
|
|
else()
|
|
cpm_utils_message(WARNING ${PKG_ARGS_NAME}
|
|
"Package has no specified sha, tag, or version")
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS "unknown")
|
|
endif()
|
|
else()
|
|
if (DEFINED CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION AND NOT
|
|
"${CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION}" STREQUAL "")
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
"${CPM_PACKAGE_${PKG_ARGS_NAME}_VERSION} (system)")
|
|
else()
|
|
set_property(GLOBAL APPEND PROPERTY CPM_PACKAGE_SHAS
|
|
"unknown (system)")
|
|
endif()
|
|
endif()
|
|
|
|
# pass stuff to parent scope
|
|
set(${PKG_ARGS_NAME}_ADDED "${${PKG_ARGS_NAME}_ADDED}"
|
|
PARENT_SCOPE)
|
|
set(${PKG_ARGS_NAME}_SOURCE_DIR "${${PKG_ARGS_NAME}_SOURCE_DIR}"
|
|
PARENT_SCOPE)
|
|
set(${PKG_ARGS_NAME}_BINARY_DIR "${${PKG_ARGS_NAME}_BINARY_DIR}"
|
|
PARENT_SCOPE)
|
|
|
|
endfunction()
|
|
|
|
function(add_ci_package key)
|
|
set(ARTIFACT ${ARTIFACT_NAME}-${key}-${ARTIFACT_VERSION}.${ARTIFACT_EXT})
|
|
|
|
AddPackage(
|
|
NAME ${ARTIFACT_PACKAGE}
|
|
REPO ${ARTIFACT_REPO}
|
|
TAG v${ARTIFACT_VERSION}
|
|
VERSION ${ARTIFACT_VERSION}
|
|
ARTIFACT ${ARTIFACT}
|
|
|
|
KEY ${key}
|
|
HASH_SUFFIX sha512sum
|
|
BUNDLED_PACKAGE ON
|
|
)
|
|
|
|
set(ARTIFACT_DIR ${${ARTIFACT_PACKAGE}_SOURCE_DIR} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
# TODO(crueter): we could do an AddMultiArchPackage, multiplatformpackage?
|
|
# name is the artifact name, package is for find_package override
|
|
function(AddCIPackage)
|
|
set(oneValueArgs
|
|
VERSION
|
|
NAME
|
|
REPO
|
|
PACKAGE
|
|
EXTENSION
|
|
MIN_VERSION
|
|
DISABLED_PLATFORMS
|
|
)
|
|
|
|
cmake_parse_arguments(PKG_ARGS "" "${oneValueArgs}" "" ${ARGN})
|
|
|
|
if(NOT DEFINED PKG_ARGS_VERSION)
|
|
message(FATAL_ERROR "[CPMUtil] VERSION is required")
|
|
endif()
|
|
if(NOT DEFINED PKG_ARGS_NAME)
|
|
message(FATAL_ERROR "[CPMUtil] NAME is required")
|
|
endif()
|
|
if(NOT DEFINED PKG_ARGS_REPO)
|
|
message(FATAL_ERROR "[CPMUtil] REPO is required")
|
|
endif()
|
|
if(NOT DEFINED PKG_ARGS_PACKAGE)
|
|
message(FATAL_ERROR "[CPMUtil] PACKAGE is required")
|
|
endif()
|
|
|
|
if (NOT DEFINED PKG_ARGS_CMAKE_FILENAME)
|
|
set(ARTIFACT_CMAKE ${PKG_ARGS_NAME})
|
|
else()
|
|
set(ARTIFACT_CMAKE ${PKG_ARGS_CMAKE_FILENAME})
|
|
endif()
|
|
|
|
if(NOT DEFINED PKG_ARGS_EXTENSION)
|
|
set(ARTIFACT_EXT "tar.zst")
|
|
else()
|
|
set(ARTIFACT_EXT ${PKG_ARGS_EXTENSION})
|
|
endif()
|
|
|
|
if (DEFINED PKG_ARGS_MIN_VERSION)
|
|
set(ARTIFACT_MIN_VERSION ${PKG_ARGS_MIN_VERSION})
|
|
endif()
|
|
|
|
if (DEFINED PKG_ARGS_DISABLED_PLATFORMS)
|
|
set(DISABLED_PLATFORMS ${PKG_ARGS_DISABLED_PLATFORMS})
|
|
endif()
|
|
|
|
# this is mildly annoying
|
|
set(ARTIFACT_VERSION ${PKG_ARGS_VERSION})
|
|
set(ARTIFACT_NAME ${PKG_ARGS_NAME})
|
|
set(ARTIFACT_REPO ${PKG_ARGS_REPO})
|
|
set(ARTIFACT_PACKAGE ${PKG_ARGS_PACKAGE})
|
|
|
|
if ((MSVC AND ARCHITECTURE_x86_64) AND NOT "windows-amd64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(windows-amd64)
|
|
endif()
|
|
|
|
if ((MSVC AND ARCHITECTURE_arm64) AND NOT "windows-arm64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(windows-arm64)
|
|
endif()
|
|
|
|
if (ANDROID AND NOT "android" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(android)
|
|
endif()
|
|
|
|
if(PLATFORM_SUN AND NOT "solaris-amd64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(solaris-amd64)
|
|
endif()
|
|
|
|
if(PLATFORM_FREEBSD AND NOT "freebsd-amd64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(freebsd-amd64)
|
|
endif()
|
|
|
|
if((PLATFORM_LINUX AND ARCHITECTURE_x86_64) AND NOT "linux-amd64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(linux-amd64)
|
|
endif()
|
|
|
|
if((PLATFORM_LINUX AND ARCHITECTURE_arm64) AND NOT "linux-aarch64" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(linux-aarch64)
|
|
endif()
|
|
|
|
# TODO(crueter): macOS amd64/aarch64 split mayhaps
|
|
if (APPLE AND NOT "macos-universal" IN_LIST DISABLED_PLATFORMS)
|
|
add_ci_package(macos-universal)
|
|
endif()
|
|
|
|
if (DEFINED ARTIFACT_DIR)
|
|
set(${ARTIFACT_PACKAGE}_ADDED TRUE PARENT_SCOPE)
|
|
set(${ARTIFACT_PACKAGE}_SOURCE_DIR "${ARTIFACT_DIR}" PARENT_SCOPE)
|
|
else()
|
|
find_package(${ARTIFACT_PACKAGE} ${ARTIFACT_MIN_VERSION} REQUIRED)
|
|
endif()
|
|
endfunction()
|