hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 2853

Browse Source
This commit is contained in:
pineappleEA
2022-07-23 03:01:36 +02:00
parent 1f2b5081b5
commit 1f111bb69c
8955 changed files with 418777 additions and 999 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
externals/vcpkg/scripts/cmake/execute_process.cmake vendored Executable file
View File

@@ -0,0 +1,12 @@
if (NOT DEFINED Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS)
set(Z_VCPKG_OVERRIDEN_EXECUTE_PROCESS ON)
if (DEFINED VCPKG_DOWNLOAD_MODE)
function(execute_process)
message(FATAL_ERROR "This command cannot be executed in Download Mode.\nHalting portfile execution.\n")
endfunction()
set(Z_VCPKG_EXECUTE_PROCESS_NAME "_execute_process")
else()
set(Z_VCPKG_EXECUTE_PROCESS_NAME "execute_process")
endif()
endif()

511
externals/vcpkg/scripts/cmake/vcpkg_acquire_msys.cmake vendored Executable file
View File

@@ -0,0 +1,511 @@
# Mirror list from https://github.com/msys2/MSYS2-packages/blob/master/pacman-mirrors/mirrorlist.msys
# Sourceforge is not used because it does not keep older package versions
set(Z_VCPKG_ACQUIRE_MSYS_MIRRORS
"https://www2.futureware.at/~nickoe/msys2-mirror/"
"https://mirror.yandex.ru/mirrors/msys2/"
"https://mirrors.tuna.tsinghua.edu.cn/msys2/"
"https://mirrors.ustc.edu.cn/msys2/"
"https://mirror.bit.edu.cn/msys2/"
"https://mirror.selfnet.de/msys2/"
"https://mirrors.sjtug.sjtu.edu.cn/msys2/"
)
function(z_vcpkg_acquire_msys_download_package out_archive)
cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "URL;SHA512;FILENAME" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_download_package passed extra args: ${arg_UNPARSED_ARGUMENTS}")
endif()
set(all_urls "${arg_URL}")
foreach(mirror IN LISTS Z_VCPKG_ACQUIRE_MSYS_MIRRORS)
string(REPLACE "https://repo.msys2.org/" "${mirror}" mirror_url "${arg_URL}")
list(APPEND all_urls "${mirror_url}")
endforeach()
vcpkg_download_distfile(msys_archive
URLS ${all_urls}
SHA512 "${arg_SHA512}"
FILENAME "msys-${arg_FILENAME}"
QUIET
)
set("${out_archive}" "${msys_archive}" PARENT_SCOPE)
endfunction()
# writes to the following variables in parent scope:
# - Z_VCPKG_MSYS_ARCHIVES
# - Z_VCPKG_MSYS_TOTAL_HASH
# - Z_VCPKG_MSYS_PACKAGES
function(z_vcpkg_acquire_msys_declare_package)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "NAME;URL;SHA512" "DEPS")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_declare_package passed extra args: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(required_arg IN ITEMS URL SHA512)
if(NOT DEFINED arg_${required_arg})
message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_declare_package requires argument: ${required_arg}")
endif()
endforeach()
if(NOT arg_URL MATCHES [[^https://repo\.msys2\.org/.*/(([^-]+(-[^0-9][^-]*)*)-.+\.pkg\.tar\.(xz|zst))$]])
message(FATAL_ERROR "internal error: regex does not match supplied URL to vcpkg_acquire_msys: ${arg_URL}")
endif()
set(filename "${CMAKE_MATCH_1}")
if(NOT DEFINED arg_NAME)
set(arg_NAME "${CMAKE_MATCH_2}")
endif()
if("${arg_NAME}" IN_LIST Z_VCPKG_MSYS_PACKAGES OR arg_Z_ALL_PACKAGES)
list(REMOVE_ITEM Z_VCPKG_MSYS_PACKAGES "${arg_NAME}")
list(APPEND Z_VCPKG_MSYS_PACKAGES ${arg_DEPS})
set(Z_VCPKG_MSYS_PACKAGES "${Z_VCPKG_MSYS_PACKAGES}" PARENT_SCOPE)
z_vcpkg_acquire_msys_download_package(archive
URL "${arg_URL}"
SHA512 "${arg_SHA512}"
FILENAME "${filename}"
)
list(APPEND Z_VCPKG_MSYS_ARCHIVES "${archive}")
set(Z_VCPKG_MSYS_ARCHIVES "${Z_VCPKG_MSYS_ARCHIVES}" PARENT_SCOPE)
string(APPEND Z_VCPKG_MSYS_TOTAL_HASH "${arg_SHA512}")
set(Z_VCPKG_MSYS_TOTAL_HASH "${Z_VCPKG_MSYS_TOTAL_HASH}" PARENT_SCOPE)
endif()
endfunction()
function(vcpkg_acquire_msys out_msys_root)
cmake_parse_arguments(PARSE_ARGV 1 "arg"
"NO_DEFAULT_PACKAGES;Z_ALL_PACKAGES"
""
"PACKAGES;DIRECT_PACKAGES"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_acquire_msys was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
set(Z_VCPKG_MSYS_TOTAL_HASH)
set(Z_VCPKG_MSYS_ARCHIVES)
set(Z_VCPKG_MSYS_PACKAGES "${arg_PACKAGES}")
if(NOT arg_NO_DEFAULT_PACKAGES)
list(APPEND Z_VCPKG_MSYS_PACKAGES bash coreutils sed grep gawk gzip diffutils make pkg-config)
endif()
if(DEFINED arg_DIRECT_PACKAGES AND NOT arg_DIRECT_PACKAGES STREQUAL "")
list(LENGTH arg_DIRECT_PACKAGES direct_packages_length)
math(EXPR direct_packages_parity "${direct_packages_length} % 2")
math(EXPR direct_packages_number "${direct_packages_length} / 2")
math(EXPR direct_packages_last "${direct_packages_number} - 1")
if(direct_packages_parity EQUAL 1)
message(FATAL_ERROR "vcpkg_acquire_msys(... DIRECT_PACKAGES ...) requires exactly pairs of URL/SHA512")
endif()
# direct_packages_last > direct_packages_number - 1 > 0 - 1 >= 0, so this is fine
foreach(index RANGE "${direct_packages_last}")
math(EXPR url_index "${index} * 2")
math(EXPR sha512_index "${url_index} + 1")
list(GET arg_DIRECT_PACKAGES "${url_index}" url)
list(GET arg_DIRECT_PACKAGES "${sha512_index}" sha512)
get_filename_component(filename "${url}" NAME)
z_vcpkg_acquire_msys_download_package(archive
URL "${url}"
SHA512 "${sha512}"
FILENAME "${filename}"
)
list(APPEND Z_VCPKG_MSYS_ARCHIVES "${archive}")
string(APPEND Z_VCPKG_MSYS_TOTAL_HASH "${sha512}")
endforeach()
endif()
# To add new entries, use https://packages.msys2.org/package/$PACKAGE?repo=msys
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/unzip-6.0-2-x86_64.pkg.tar.xz"
SHA512 b8a1e0ce6deff26939cb46267f80ada0a623b7d782e80873cea3d388b4dc3a1053b14d7565b31f70bc904bf66f66ab58ccc1cd6bfa677065de1f279dd331afb9
DEPS libbz2
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libbz2-1.0.8-3-x86_64.pkg.tar.zst"
SHA512 955420cabd45a02f431f5b685d8dc8acbd07a8dcdda5fdf8b9de37d3ab02d427bdb0a6d8b67c448e307f21094e405e916fd37a8e9805abd03610f45c02d64b9e
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/patch-2.7.6-1-x86_64.pkg.tar.xz"
SHA512 04d06b9d5479f129f56e8290e0afe25217ffa457ec7bed3e576df08d4a85effd80d6e0ad82bd7541043100799b608a64da3c8f535f8ea173d326da6194902e8c
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gzip-1.11-1-x86_64.pkg.tar.zst"
SHA512 bcd9d7839aef5f2b73c4d39b51838e62626c201c808d512806ba0a1619aee83c7deddb0d499fd93f9815fe351d7ab656c31c9dc7ee1171d77ad6d598e04dfcbe
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/texinfo-6.8-3-x86_64.pkg.tar.zst"
SHA512 5cc16d3b3c3b9859fe61233fa27f2146526e2b4d6e626814d283b35bfd77bc15eb4ffaec00bde6c10df93466d9155a06854a7ecf2e0d9af746dd56c4d88d192e
DEPS bash perl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/bash-5.1.008-1-x86_64.pkg.tar.zst"
SHA512 a2ab8c958615134dc666254baca8cb13ed773036954e458de74ffb3bfe661bb33149082d38b677024da451755098a9201ab7dd435ced6e7f6b4e94c3ae368daf
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/autoconf-2.71-3-any.pkg.tar.zst"
SHA512 f639deac9b2191c2096584cf374103bbb1e9d2476dd0ebec94b1e80da59be25b88e362ac5280487a89f0bb0ed57f99b66e314f36b7de9cda03c0974806a3a4e2
DEPS m4 perl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/autoconf-archive-2019.01.06-1-any.pkg.tar.xz"
SHA512 77540d3d3644d94a52ade1f5db27b7b4b5910bbcd6995195d511378ca6d394a1dd8d606d57161c744699e6c63c5e55dfe6e8664d032cc8c650af9fdbb2db08b0
DEPS m4 perl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/diffutils-3.8-2-x86_64.pkg.tar.zst"
SHA512 ee74e457c417d6978b3185f2fb8e15c9c30ecfc316c2474d69c978e7eb2282a3bd050d68dbf43d694cb5ab6f159b0e7ca319d01f8192071d82a224dde87d69b5
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/binutils-2.37-5-x86_64.pkg.tar.zst"
SHA512 32129cf97b53d5f6d87b42f17643e9dfc2e41b9ab4e4dfdc10e69725a9349bb25e57e0937e7504798cae91f7a88e0f4f5814e9f6a021bb68779d023176d2f311
DEPS libiconv libintl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libtool-2.4.6-9-x86_64.pkg.tar.xz"
SHA512 b309799e5a9d248ef66eaf11a0bd21bf4e8b9bd5c677c627ec83fa760ce9f0b54ddf1b62cbb436e641fbbde71e3b61cb71ff541d866f8ca7717a3a0dbeb00ebf
DEPS grep sed coreutils file findutils
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/file-5.41-2-x86_64.pkg.tar.zst"
SHA512 124c3983608879362acea7d487bf23690f371b3cfe0355385f0e643263b2a5568abe5cebda92ef9bc534e81f850138f589e75982f36a53f509676056d71de642
DEPS gcc-libs zlib libbz2
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/zlib-1.2.11-1-x86_64.pkg.tar.xz"
SHA512 b607da40d3388b440f2a09e154f21966cd55ad77e02d47805f78a9dee5de40226225bf0b8335fdfd4b83f25ead3098e9cb974d4f202f28827f8468e30e3b790d
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/bzip2-1.0.8-3-x86_64.pkg.tar.zst"
SHA512 9d03e8fc5677dd1386454bd27a683667e829ad5b1b87fc0879027920b2e79b25a2d773ab2556cd29844b18dd25b26fef5a57bf89e35ca318e39443dcaf0ca3ba
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libbz2-1.0.8-3-x86_64.pkg.tar.zst"
SHA512 955420cabd45a02f431f5b685d8dc8acbd07a8dcdda5fdf8b9de37d3ab02d427bdb0a6d8b67c448e307f21094e405e916fd37a8e9805abd03610f45c02d64b9e
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/coreutils-8.32-2-x86_64.pkg.tar.zst"
SHA512 0719e8d3683711453ff77496cad11583e877ea52806e5ea3f470444705705db20a8a9fe99987166b02c6bd240c06c7d86faa979a7bc5536c9c804d800b60b7be
DEPS libiconv libintl gmp
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/grep-3.0-2-x86_64.pkg.tar.xz"
SHA512 c784d5f8a929ae251f2ffaccf7ab0b3936ae9f012041e8f074826dd6077ad0a859abba19feade1e71b3289cc640626dfe827afe91c272b38a1808f228f2fdd00
DEPS libiconv libintl libpcre
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/sed-4.8-2-x86_64.pkg.tar.zst"
SHA512 8391be777239e0bfc19dc477995ee581ea9dbb1ba34fc27f57ba9d858e7489ac9b7200479d405712b43fa88434dd597be71d161fa8c05606e7ef991711bfc4c1
DEPS libintl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libpcre-8.45-1-x86_64.pkg.tar.zst"
SHA512 b10a69380c44ea35367f310a7400eae26beacf347ddbb5da650b54924b80ffd791f12a9d70923567e5081e3c7098f042e47bcff1328d95b0b27ce63bcd762e88
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/m4-1.4.19-2-x86_64.pkg.tar.zst"
SHA512 7471099ba7e3b47e5b019dc0e563165a8660722f2bbd337fb579e6d1832c0e7dcab0ca9297c4692b18add92c4ad49e94391c621cf38874e2ff63d4f926bac38c
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/automake-wrapper-11-4-any.pkg.tar.zst"
SHA512 175940ebccb490c25d2c431dd025f24a7d0c930a7ee8cb81a44a4989c1d07f4b5a8134e1d05a7a1b206f8e19a2308ee198b1295e31b2e139f5d9c1c077252c94
DEPS gawk
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gawk-5.1.0-2-x86_64.pkg.tar.zst"
SHA512 d4b00e2b53ce99ddd3ee8e41c41add5ab36d26a54107acf7f5a5bf4a0033d72465cdab86f5b2eb8b7aca2cb5027a3e35cb194794c3bf563c0075ca3dbcad6987
DEPS libintl libreadline mpfr
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/mpfr-4.1.0-1-x86_64.pkg.tar.zst"
SHA512 d64fa60e188124591d41fc097d7eb51d7ea4940bac05cdcf5eafde951ed1eaa174468f5ede03e61106e1633e3428964b34c96de76321ed8853b398fbe8c4d072
DEPS gmp gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gmp-6.2.1-1-x86_64.pkg.tar.zst"
SHA512 c5c8009ef069d05c2209b69c8e87094b09aac4b5c3dfdbea474d8262e55d286b400f1360c6a9778fd5eb87fb76a6463c21188286a1a1919ad79153eae3c44b0f
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/xz-5.2.5-1-x86_64.pkg.tar.xz" # this seems to require immediate updating on version bumps.
SHA512 99d092c3398277e47586cead103b41e023e9432911fb7bdeafb967b826f6a57d32e58afc94c8230dad5b5ec2aef4f10d61362a6d9e410a6645cf23f076736bba
DEPS liblzma libiconv gettext
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/liblzma-5.2.5-1-x86_64.pkg.tar.xz"
SHA512 8d5c04354fdc7309e73abce679a4369c0be3dc342de51cef9d2a932b7df6a961c8cb1f7e373b1b8b2be40343a95fbd57ac29ebef63d4a2074be1d865e28ca6ad
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libreadline-8.1.001-1-x86_64.pkg.tar.zst"
SHA512 4104eb0c18b8c06ab3bd4ba6420e3464df8293bec673c88da49e2f74cf1d583c922e9ead5691271fe593d424f92d1fd8668a3002174d756993d5b18337459bab
DEPS ncurses
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/ncurses-6.2-2-x86_64.pkg.tar.zst"
SHA512 4bf744a21ab2030ea9d65eb4d824ec5bed4532b7a489859e5e19bba11b5ba9be08613de48acb38baacfd2a7295722e4d858d7c577565f1999d2583defbbb58f2
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/automake1.16-1.16.3-3-any.pkg.tar.zst"
SHA512 77a195a9fe8680bee55c04b8ecc0e9ee43e2d89607c745098dfac4687f4f853885cabbb005202d70e9a9cdf9facf6849cc47c6b2f25573b5af8201696d926c72
DEPS perl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/perl-5.32.1-2-x86_64.pkg.tar.zst"
SHA512 ad21734c05bc7faa809bc4ba761fb41a3b448d31794d1fd3d430cf4afe05ae991aabece4ec9a25718c01cc323d507bf97530533f0a20aabc18a7a2ccc0ae02b1
DEPS libcrypt
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libcrypt-2.1-3-x86_64.pkg.tar.zst"
SHA512 15cee333a82b55ff6072b7be30bf1c33c926d8ac21a0a91bc4cbf655b6f547bc29496df5fa288eb47ca2f88af2a4696f9b718394437b65dd06e3d6669ca0c2e5
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/pkg-config-0.29.2-4-x86_64.pkg.tar.zst"
SHA512 9f72c81d8095ca1c341998bc80788f7ce125770ec4252f1eb6445b9cba74db5614caf9a6cc7c0fcc2ac18d4a0f972c49b9f245c3c9c8e588126be6c72a8c1818
DEPS libiconv
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/make-4.3-3-x86_64.pkg.tar.zst"
SHA512 1d991bfc2f076c8288023c7dd71c65470ad852e0744870368a4ab56644f88c7f6bbeca89dbeb7ac8b2719340cfec737a8bceae49569bbe4e75b6b8ffdcfe76f1
DEPS libintl msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gettext-devel-0.21-1-x86_64.pkg.tar.zst"
SHA512 44444064b9860dbd3cb886812fb20ee97ab04a65616cca497be69c592d5507e7bc66bfe8dbd060a4df9c5d9bb44cb0f231584d65cb04351146d54d15852227af
DEPS gettext
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gettext-0.21-1-x86_64.pkg.tar.zst"
SHA512 6ef5f4094c4a174550a898cac4f60215d22de09f7e5f72bdb297d18a6f027e6122b4a519aa8d5781f9b0201dcae14ad7910b181b1499d6d8bbeb5a35b3a08581
DEPS libintl libgettextpo libasprintf tar
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/tar-1.34-2-x86_64.pkg.tar.zst"
SHA512 127a971f5c087500ec4858697205b36ae76dba82307f1bcaaa44e746337d85d97360e46e55ef7fecbfa2a4af428ee26d804fa7d7c2b8ce6de1b86328dd14ef2d
DEPS libiconv libintl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libgettextpo-0.21-1-x86_64.pkg.tar.zst"
SHA512 bb217639deadb36734bafb8db5217e654d00b93a3ef366116cc6c9b8b8951abef9a7e9b04be3fae09074cf68576f18575a0d09f3d2f344985606c1449a17222e
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libasprintf-0.21-1-x86_64.pkg.tar.zst"
SHA512 62dde7bfcfea75ea9adb463807d7c128019ffeec0fb23e73bc39f760e45483c61f4f29e89cdbfab1e317d520c83fe3b65306fbd7258fe11ea951612dbee479fe
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/findutils-4.8.0-1-x86_64.pkg.tar.zst"
SHA512 74f8750636becefd3675c89957dfb8a244d2db6fec80bf352998edfef93f66d0e2a37d7f2869a79dd197acf2057ccd6aefd12c58e94154765896a432831ab49c
DEPS libintl libiconv
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libintl-0.21-1-x86_64.pkg.tar.zst"
SHA512 be0242eed25793e86e0560868f76cf06a358ffc0b2beb357e776d6c7819e545ac90f9358b17a85aa598584babe3ab4bb4544e360a28f5cec965f314178b930d1
DEPS libiconv
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/libiconv-1.16-2-x86_64.pkg.tar.zst"
SHA512 3ab569eca9887ef85e7dd5dbca3143d8a60f7103f370a7ecc979a58a56b0c8dcf1f54ac3df4495bc306bd44bf36ee285aaebbb221c4eebfc912cf47d347d45fc
DEPS gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/gcc-libs-11.2.0-3-x86_64.pkg.tar.zst"
SHA512 be7bb61d1b87eafbb91cf9d0fee3270b9d5e2420c403ea394967941195d52ae248ce4ffde20af41a05310527a920269018f49487be617211a5e340486babd0f8
DEPS msys2-runtime
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/msys/x86_64/msys2-runtime-3.2.0-8-x86_64.pkg.tar.zst"
SHA512 fdd86f4ffa6e274d6fef1676a4987971b1f2e1ec556eee947adcb4240dc562180afc4914c2bdecba284012967d3d3cf4d1a392f798a3b32a3668d6678a86e8d3
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-python-numpy-1.20.3-1-any.pkg.tar.zst"
SHA512 ce73d4270942f61963e8307f6bec945d14e3774455684842b8fde836b19a4e9cbf8efd0663ffb28ad872493db70fa3a4e14bd0b248c2067199f4fee94e80e77e
DEPS mingw-w64-x86_64-openblas mingw-w64-x86_64-python
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-openblas-0.3.19-1-any.pkg.tar.zst"
SHA512 0d18a93d7804d6469b8566cf4ad3a7efbdf8a4a4b05d191b23a30e107586423c6338b9f4a5ea2cc93052e6c0336dc82a43c26189c410263a6e705e6f3ebe261a
DEPS mingw-w64-x86_64-gcc-libgfortran mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libwinpthread
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-libgfortran-11.2.0-8-any.pkg.tar.zst"
SHA512 8537b55633bc83d81d528378590e417ffe8c26b6c327d8b6d7ba50a8b5f4e090fbe2dc500deb834120edf25ac3c493055f4de2dc64bde061be23ce0f625a8893
DEPS mingw-w64-x86_64-gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-python-3.8.9-2-any.pkg.tar.zst"
SHA512 8a45b28b2b0471718bd1ab096958872b18ae3b25f06c30718c54d1edaf04214397330a51776f3e4eee556ac47d9e3aa5e1b211c5df0cf6be3046a6f3a79cfa7d
DEPS mingw-w64-x86_64-bzip2 mingw-w64-x86_64-expat mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libffi mingw-w64-x86_64-mpdecimal mingw-w64-x86_64-ncurses mingw-w64-x86_64-openssl mingw-w64-x86_64-sqlite3 mingw-w64-x86_64-tcl mingw-w64-x86_64-tk mingw-w64-x86_64-xz mingw-w64-x86_64-zlib
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-bzip2-1.0.8-2-any.pkg.tar.zst"
SHA512 4f7ba44189d953d4d00e7bbf5a7697233f759c92847c074f0f2888d2a641c59ce4bd3c39617adac0ad7b53c5836e529f9ffd889f976444016976bb517e5c24a2
DEPS mingw-w64-x86_64-gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-mpdecimal-2.5.1-1-any.pkg.tar.zst"
SHA512 1204c31367f9268ffd6658be04af7687c01f984c9d6be8c7a20ee0ebde1ca9a03b766ef1aeb1fa7aaa97b88a57f7a73afa7f7a7fed9c6b895a032db11e6133bf
DEPS mingw-w64-x86_64-gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-ncurses-6.3-3-any.pkg.tar.zst"
SHA512 888c155d878651dc31c9a01455ab689d7b644cec759521b69b8399c20b6ddc77c90f3ee4ddeed8857084335335b4b30e182d826fb5b78719b704f13a1dfdbd54
DEPS mingw-w64-x86_64-libsystre
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libsystre-1.0.1-4-any.pkg.tar.xz"
SHA512 6540e896636d00d1ea4782965b3fe4d4ef1e32e689a98d25e2987191295b319eb1de2e56be3a4b524ff94f522a6c3e55f8159c1a6f58c8739e90f8e24e2d40d8
DEPS mingw-w64-x86_64-libtre
)
z_vcpkg_acquire_msys_declare_package(
NAME "mingw-w64-x86_64-libtre"
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libtre-git-r128.6fb7206-2-any.pkg.tar.xz"
SHA512 d595dbcf3a3b6ed098e46f370533ab86433efcd6b4d3dcf00bbe944ab8c17db7a20f6535b523da43b061f071a3b8aa651700b443ae14ec752ae87500ccc0332d
DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-gettext
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-openssl-1.1.1.m-1-any.pkg.tar.zst"
SHA512 9471b0e5b01453f6ee5c92be6e259446c6b5be45d1da8985a4735b3e54c835d9b86286b2af126546419bf968df096442bd4f60f30efa1a901316e3c02b98525f
DEPS mingw-w64-x86_64-ca-certificates mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-zlib
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-ca-certificates-20210119-1-any.pkg.tar.zst"
SHA512 5590ca116d73572eb336ad73ea5df9da34286d8ff8f6b162b38564d0057aa23b74a30858153013324516af26671046addd6bcade221e94e7b8ed5e8f886e1c58
DEPS mingw-w64-x86_64-p11-kit
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-p11-kit-0.24.1-1-any.pkg.tar.zst"
SHA512 6437919cd61c8b1a59b346bbd93d960adb7f11206e8c0010311d71d0fe9aa03f950ecf08f19a5555b27f481cc0d61b88650b165ae9336ac1a1a0a9be553239b9
DEPS mingw-w64-x86_64-gettext mingw-w64-x86_64-libffi mingw-w64-x86_64-libtasn1
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libtasn1-4.18.0-1-any.pkg.tar.zst"
SHA512 2584a6e0bc2b7d145f026487951b8690e3d8e79f475a7b77f95fc27ca9a9f1887fe9303e340ba2635353c4a6f6a2f10a907dd8778e54be7506a15459f616d4a4
DEPS mingw-w64-x86_64-gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-sqlite3-3.37.2-1-any.pkg.tar.zst"
SHA512 0f83f10b0c8f4699a6b84deb6986fcd471cb80b995561ad793e827f9dd66110d555744918ed91982aec8d9743f6064726dd5eba3e695aa9ab5381ea4f8e76dbe
DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-readline mingw-w64-x86_64-tcl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-readline-8.1.001-1-any.pkg.tar.zst"
SHA512 b38aef9216ea2ba7edd82ce57a48dbc913b9bdcb44b96b9800342fe097d706ba39c9d5ba08d793d2c3388722479258bb05388ae09d74a1edcaaf9002e9d71853
DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-termcap
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-termcap-1.3.1-6-any.pkg.tar.zst"
SHA512 602d182ba0f1e20c4c51ae09b327c345bd736e6e4f22cd7d58374ac68c705dd0af97663b9b94d41870457f46bb9110abb29186d182196133618fc460f71d1300
DEPS mingw-w64-x86_64-gcc-libs
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-tk-8.6.11.1-2-any.pkg.tar.zst"
SHA512 15fd4e085fabe2281f33c8f36f4b1b0be132e5b100f6d4eaf54688842791aa2cf4e6d38a855f74f42be3f86c52e20044518f5843f8e9ca13c54a6ea4adb973a8
DEPS mingw-w64-x86_64-tcl
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-tcl-8.6.11-5-any.pkg.tar.zst"
SHA512 9db75ff47260ea3652d1abf60cd44649d0e8cbe5c4d26c316b99a6edb08252fb87ed017c856f151da99bcaa0bd90c0bebae28234035b008c5bd6508511639852
DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-zlib
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-xz-5.2.5-2-any.pkg.tar.zst"
SHA512 94fcf8b9f9fbc2cfdb2ed53dbe72797806aa3399c4dcfea9c6204702c4504eb4d4204000accd965fcd0680d994bf947eae308bc576e629bbaa3a4cefda3aea52
DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-gettext
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gettext-0.21-3-any.pkg.tar.zst"
SHA512 38daa0edd1a2c1efdd56baeb6805d10501a57e0c8ab98942e4a16f8b021908dac315513ea85f5278adf300bce3052a44a3f8b473adb0d5d3656aa4a48fe61081
DEPS mingw-w64-x86_64-expat mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libiconv
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-libs-11.2.0-8-any.pkg.tar.zst"
SHA512 2481f7c8db7cca549911bc71715af86ca287ffed6d673c9a6c3a4c792b68899a129dd959214af7067f434e74fc518c43749e7d928cbd2232ab4fbc65880dad98
DEPS mingw-w64-x86_64-gmp mingw-w64-x86_64-libwinpthread mingw-w64-x86_64-mpc mingw-w64-x86_64-mpfr
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-mpc-1.2.1-1-any.pkg.tar.zst"
SHA512 f2c137dbb0b6feea68dde9739c38b44dcb570324e3947adf991028e8f63c9ff50a11f47be15b90279ff40bcac7f320d952cfc14e69ba8d02cf8190c848d976a1
DEPS mingw-w64-x86_64-mpfr
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-mpfr-4.1.0-3-any.pkg.tar.zst"
SHA512 be8ad04e53804f18cfeec5b9cba1877af1516762de60891e115826fcfe95166751a68e24cdf351a021294e3189c31ce3c2db0ebf9c1d4d4ab6fea1468f73ced5
DEPS mingw-w64-x86_64-gmp
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gmp-6.2.1-3-any.pkg.tar.zst"
SHA512 d0d4ed1a046b64f437e72bbcf722b30311dde5f5e768a520141423fc0a3127b116bd62cfd4b5cf5c01a71ee0f9cf6479fcc31277904652d8f6ddbf16e33e0b72
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-expat-2.4.4-1-any.pkg.tar.zst"
SHA512 479e6591d06eee2686591d7232a60d4092540deb40cf0c2c418de861b1da6b21fb4be82e603dd4a3b88f5a1b1d21cdb4f016780dda8131e32be5c3dec85dfc4d
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libffi-3.3-4-any.pkg.tar.zst"
SHA512 1d7be396ef132289be0c33792c4e81dea6cb7b1eafa249fb3e8abc0b393d14e5114905c0c0262b6a7aed8f196ae4d7a10fbafd342b08ec76c9196921332747b5
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libiconv-1.16-2-any.pkg.tar.zst"
SHA512 542ed5d898a57a79d3523458f8f3409669b411f87d0852bb566d66f75c96422433f70628314338993461bcb19d4bfac4dadd9d21390cb4d95ef0445669288658
)
z_vcpkg_acquire_msys_declare_package(
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-zlib-1.2.11-9-any.pkg.tar.zst"
SHA512 f386d3a8d8c169a62a4580af074b7fdc0760ef0fde22ef7020a349382dd374a9e946606c757d12da1c1fe68baf5e2eaf459446e653477035a63e0e20df8f4aa0
)
z_vcpkg_acquire_msys_declare_package(
NAME "mingw-w64-x86_64-libwinpthread"
URL "https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libwinpthread-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
SHA512 a2c9e60d23b1310a6cec1fadd2b15a8c07223f3fe90d41b1579e9fc27ee2b0b408456291a55fad54a156e6a247efc20f6fcc247cc567e64fe190938aa3b672e9
)
if(NOT Z_VCPKG_MSYS_PACKAGES STREQUAL "")
message(FATAL_ERROR "Unknown packages were required for vcpkg_acquire_msys(${arg_PACKAGES}): ${packages}
This can be resolved by explicitly passing URL/SHA pairs to DIRECT_PACKAGES.")
endif()
string(SHA512 total_hash "${Z_VCPKG_MSYS_TOTAL_HASH}")
string(SUBSTRING "${total_hash}" 0 16 total_hash)
set(path_to_root "${DOWNLOADS}/tools/msys2/${total_hash}")
if(NOT EXISTS "${path_to_root}")
file(REMOVE_RECURSE "${path_to_root}.tmp")
file(MAKE_DIRECTORY "${path_to_root}.tmp/tmp")
set(index 0)
foreach(archive IN LISTS Z_VCPKG_MSYS_ARCHIVES)
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${CMAKE_COMMAND}" -E tar xzf "${archive}"
LOGNAME "msys-${TARGET_TRIPLET}-${index}"
WORKING_DIRECTORY "${path_to_root}.tmp"
)
math(EXPR index "${index} + 1")
endforeach()
file(RENAME "${path_to_root}.tmp" "${path_to_root}")
endif()
# Due to skipping the regular MSYS2 installer,
# some config files need to be established explicitly.
if(NOT EXISTS "${path_to_root}/etc/fstab")
# This fstab entry removes the cygdrive prefix from paths.
file(WRITE "${path_to_root}/etc/fstab" "none / cygdrive binary,posix=0,noacl,user 0 0")
endif()
message(STATUS "Using msys root at ${path_to_root}")
set("${out_msys_root}" "${path_to_root}" PARENT_SCOPE)
endfunction()

10
externals/vcpkg/scripts/cmake/vcpkg_add_to_path.cmake vendored Executable file
View File

@@ -0,0 +1,10 @@
function(vcpkg_add_to_path)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "PREPEND" "" "")
if(arg_PREPEND)
set(operation PREPEND)
else()
set(operation APPEND)
endif()
vcpkg_host_path_list("${operation}" ENV{PATH} ${arg_UNPARSED_ARGUMENTS})
endfunction()

17
externals/vcpkg/scripts/cmake/vcpkg_apply_patches.cmake vendored Executable file
View File

@@ -0,0 +1,17 @@
function(vcpkg_apply_patches)
z_vcpkg_deprecation_message("vcpkg_apply_patches has been deprecated in favor of the `PATCHES` argument to `vcpkg_from_*`.")
cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
if(arg_QUIET)
set(quiet "QUIET")
else()
set(quiet)
endif()
z_vcpkg_apply_patches(
SOURCE_PATH "${arg_SOURCE_PATH}"
${quiet}
PATCHES ${arg_PATCHES}
)
endfunction()

35
externals/vcpkg/scripts/cmake/vcpkg_backup_restore_env_vars.cmake vendored Executable file
View File

@@ -0,0 +1,35 @@
function(vcpkg_backup_env_variables)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "VARS")
if(NOT DEFINED arg_VARS)
message(FATAL_ERROR "VARS must be defined.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(envvar IN LISTS arg_VARS)
if(DEFINED ENV{${envvar}})
set("z_vcpkg_env_backup_${envvar}" "$ENV{${envvar}}" PARENT_SCOPE)
else()
unset("z_vcpkg_env_backup_${envvar}" PARENT_SCOPE)
endif()
endforeach()
endfunction()
function(vcpkg_restore_env_variables)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "VARS")
if(NOT DEFINED arg_VARS)
message(FATAL_ERROR "VARS must be defined.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(envvar IN LISTS arg_VARS)
if(DEFINED z_vcpkg_env_backup_${envvar})
set("ENV{${envvar}}" "${z_vcpkg_env_backup_${envvar}}")
else()
unset("ENV{${envvar}}")
endif()
endforeach()
endfunction()

95
externals/vcpkg/scripts/cmake/vcpkg_build_cmake.cmake vendored Executable file
View File

@@ -0,0 +1,95 @@
function(vcpkg_build_cmake)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
"DISABLE_PARALLEL;ADD_BIN_TO_PATH"
"TARGET;LOGFILE_ROOT"
""
)
if(Z_VCPKG_CMAKE_BUILD_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_build_cmake in the same port is unsupported.")
endif()
if(NOT DEFINED arg_LOGFILE_ROOT)
set(arg_LOGFILE_ROOT "build")
endif()
vcpkg_list(SET build_param)
vcpkg_list(SET parallel_param)
vcpkg_list(SET no_parallel_param)
if("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "Ninja")
vcpkg_list(SET build_param "-v") # verbose output
vcpkg_list(SET parallel_param "-j${VCPKG_CONCURRENCY}")
vcpkg_list(SET no_parallel_param "-j1")
elseif("${Z_VCPKG_CMAKE_GENERATOR}" MATCHES "^Visual Studio")
vcpkg_list(SET build_param
"/p:VCPkgLocalAppDataDisabled=true"
"/p:UseIntelMKL=No"
)
vcpkg_list(SET parallel_param "/m")
elseif("${Z_VCPKG_CMAKE_GENERATOR}" STREQUAL "NMake Makefiles")
# No options are currently added for nmake builds
elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Unix Makefiles")
vcpkg_list(SET build_args "VERBOSE=1")
vcpkg_list(SET parallel_args "-j${VCPKG_CONCURRENCY}")
vcpkg_list(SET no_parallel_args "")
elseif(Z_VCPKG_CMAKE_GENERATOR STREQUAL "Xcode")
vcpkg_list(SET parallel_args -jobs "${VCPKG_CONCURRENCY}")
vcpkg_list(SET no_parallel_args -jobs 1)
else()
message(FATAL_ERROR "Unrecognized GENERATOR setting from vcpkg_configure_cmake(). Valid generators are: Ninja, Visual Studio, and NMake Makefiles")
endif()
vcpkg_list(SET target_param)
if(arg_TARGET)
vcpkg_list(SET target_param "--target" "${arg_TARGET}")
endif()
foreach(build_type IN ITEMS debug release)
if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "${build_type}")
if("${build_type}" STREQUAL "debug")
set(short_build_type "dbg")
set(config "Debug")
else()
set(short_build_type "rel")
set(config "Release")
endif()
message(STATUS "Building ${TARGET_TRIPLET}-${short_build_type}")
if(arg_ADD_BIN_TO_PATH)
vcpkg_backup_env_variables(VARS PATH)
if("${build_type}" STREQUAL "debug")
vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
else()
vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
endif()
endif()
if(arg_DISABLE_PARALLEL)
vcpkg_execute_build_process(
COMMAND
"${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
-- ${build_param} ${no_parallel_param}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
)
else()
vcpkg_execute_build_process(
COMMAND
"${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
-- ${build_param} ${parallel_param}
NO_PARALLEL_COMMAND
"${CMAKE_COMMAND}" --build . --config "${config}" ${target_param}
-- ${build_param} ${no_parallel_param}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_build_type}"
LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}-${short_build_type}"
)
endif()
if(arg_ADD_BIN_TO_PATH)
vcpkg_restore_env_variables(VARS PATH)
endif()
endif()
endforeach()
endfunction()

203
externals/vcpkg/scripts/cmake/vcpkg_build_make.cmake vendored Executable file
View File

@@ -0,0 +1,203 @@
function(vcpkg_build_make)
z_vcpkg_get_cmake_vars(cmake_vars_file)
include("${cmake_vars_file}")
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
cmake_parse_arguments(PARSE_ARGV 0 arg
"ADD_BIN_TO_PATH;ENABLE_INSTALL;DISABLE_PARALLEL"
"LOGFILE_ROOT;BUILD_TARGET;SUBPATH;MAKEFILE;INSTALL_TARGET"
"OPTIONS"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_make_build was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_LOGFILE_ROOT)
set(arg_LOGFILE_ROOT "build")
endif()
if(NOT DEFINED arg_BUILD_TARGET)
set(arg_BUILD_TARGET "all")
endif()
if (NOT DEFINED arg_MAKEFILE)
set(arg_MAKEFILE Makefile)
endif()
if(NOT DEFINED arg_INSTALL_TARGET)
set(arg_INSTALL_TARGET "install")
endif()
if(WIN32)
set(Z_VCPKG_INSTALLED ${CURRENT_INSTALLED_DIR})
else()
string(REPLACE " " "\ " Z_VCPKG_INSTALLED "${CURRENT_INSTALLED_DIR}")
endif()
vcpkg_list(SET make_opts)
vcpkg_list(SET install_opts)
if (CMAKE_HOST_WIN32)
set(path_backup "$ENV{PATH}")
vcpkg_add_to_path(PREPEND "${SCRIPTS}/buildsystems/make_wrapper")
if(NOT DEFINED Z_VCPKG_MAKE)
vcpkg_acquire_msys(MSYS_ROOT)
find_program(Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED)
endif()
set(make_command "${Z_VCPKG_MAKE}")
vcpkg_list(SET make_opts ${arg_OPTIONS} ${arg_MAKE_OPTIONS} -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
vcpkg_list(SET no_parallel_make_opts ${arg_OPTIONS} ${arg_MAKE_OPTIONS} -j 1 --trace -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
string(REPLACE " " [[\ ]] vcpkg_package_prefix "${CURRENT_PACKAGES_DIR}")
string(REGEX REPLACE [[([a-zA-Z]):/]] [[/\1/]] vcpkg_package_prefix "${vcpkg_package_prefix}")
vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} --trace -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${vcpkg_package_prefix})
#TODO: optimize for install-data (release) and install-exec (release/debug)
else()
if(VCPKG_HOST_IS_OPENBSD)
find_program(Z_VCPKG_MAKE gmake REQUIRED)
else()
find_program(Z_VCPKG_MAKE make REQUIRED)
endif()
set(make_command "${Z_VCPKG_MAKE}")
vcpkg_list(SET make_opts ${arg_MAKE_OPTIONS} V=1 -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
vcpkg_list(SET no_parallel_make_opts ${arg_MAKE_OPTIONS} V=1 -j 1 -f ${arg_MAKEFILE} ${arg_BUILD_TARGET})
vcpkg_list(SET install_opts -j ${VCPKG_CONCURRENCY} -f ${arg_MAKEFILE} ${arg_INSTALL_TARGET} DESTDIR=${CURRENT_PACKAGES_DIR})
endif()
# Since includes are buildtype independent those are setup by vcpkg_configure_make
vcpkg_backup_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
foreach(buildtype IN ITEMS "debug" "release")
if (buildtype STREQUAL "debug" AND _VCPKG_MAKE_NO_DEBUG)
continue()
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "${buildtype}")
if("${buildtype}" STREQUAL "debug")
set(short_buildtype "-dbg")
set(cmake_buildtype "DEBUG")
set(path_suffix "/debug")
else()
# In NO_DEBUG mode, we only use ${TARGET_TRIPLET} directory.
set(short_buildtype "-rel")
set(cmake_buildtype "RELEASE")
set(path_suffix "")
endif()
set(working_directory "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}${short_buildtype}/${arg_SUBPATH}")
message(STATUS "Building ${TARGET_TRIPLET}${short_buildtype}")
z_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags("${cmake_buildtype}")
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
set(LINKER_FLAGS_${cmake_buildtype} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${cmake_buildtype}}")
else() # dynamic
set(LINKER_FLAGS_${cmake_buildtype} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${cmake_buildtype}}")
endif()
set(LDFLAGS_${cmake_buildtype} "")
if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
string(APPEND LDFLAGS_${cmake_buildtype} " -L${Z_VCPKG_INSTALLED}${path_suffix}/lib")
endif()
if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
string(APPEND LDFLAGS_${cmake_buildtype} " -L${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
endif()
if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
set(LINK_ENV_${cmake_buildtype} "$ENV{_LINK_} ${LINKER_FLAGS_${cmake_buildtype}}")
else()
string(APPEND LDFLAGS_${cmake_buildtype} " ${LINKER_FLAGS_${cmake_buildtype}}")
endif()
# Setup environment
set(ENV{CPPFLAGS} "${CPPFLAGS_${cmake_buildtype}}")
set(ENV{CFLAGS} "${CFLAGS_${cmake_buildtype}}")
set(ENV{CXXFLAGS} "${CXXFLAGS_${cmake_buildtype}}")
set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${cmake_buildtype}}")
set(ENV{LDFLAGS} "${LDFLAGS_${cmake_buildtype}}")
vcpkg_list(APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH) # LD_LIBRARY_PATH)
foreach(lib_env_var IN LISTS lib_env_vars)
if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib")
endif()
if(EXISTS "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${Z_VCPKG_INSTALLED}${path_suffix}/lib/manual-link")
endif()
endforeach()
unset(lib_env_vars)
if(LINK_ENV_${cmake_buildtype})
set(config_link_backup "$ENV{_LINK_}")
set(ENV{_LINK_} "${LINK_ENV_${cmake_buildtype}}")
endif()
if(arg_ADD_BIN_TO_PATH)
set(env_backup_path "$ENV{PATH}")
vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}${path_suffix}/bin")
endif()
vcpkg_list(SET make_cmd_line ${make_command} ${make_opts})
vcpkg_list(SET no_parallel_make_cmd_line ${make_command} ${no_parallel_make_opts})
if (arg_DISABLE_PARALLEL)
vcpkg_execute_build_process(
COMMAND ${no_parallel_make_cmd_line}
WORKING_DIRECTORY "${working_directory}"
LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}${short_buildtype}"
)
else()
vcpkg_execute_build_process(
COMMAND ${make_cmd_line}
NO_PARALLEL_COMMAND ${no_parallel_make_cmd_line}
WORKING_DIRECTORY "${working_directory}"
LOGNAME "${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}${short_buildtype}"
)
endif()
file(READ "${CURRENT_BUILDTREES_DIR}/${arg_LOGFILE_ROOT}-${TARGET_TRIPLET}${short_buildtype}-out.log" logdata)
if(logdata MATCHES "Warning: linker path does not have real file for library")
message(FATAL_ERROR "libtool could not find a file being linked against!")
endif()
if (arg_ENABLE_INSTALL)
message(STATUS "Installing ${TARGET_TRIPLET}${short_buildtype}")
vcpkg_list(SET make_cmd_line ${make_command} ${install_opts})
vcpkg_execute_build_process(
COMMAND ${make_cmd_line}
WORKING_DIRECTORY "${working_directory}"
LOGNAME "install-${TARGET_TRIPLET}${short_buildtype}"
)
endif()
if(config_link_backup)
set(ENV{_LINK_} "${config_link_backup}")
unset(config_link_backup)
endif()
if(arg_ADD_BIN_TO_PATH)
set(ENV{PATH} "${env_backup_path}")
endif()
endif()
vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH)
endforeach()
if (arg_ENABLE_INSTALL)
string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" Z_VCPKG_INSTALL_PREFIX "${CURRENT_INSTALLED_DIR}")
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
file(RENAME "${CURRENT_PACKAGES_DIR}" "${CURRENT_PACKAGES_DIR}_tmp")
file(RENAME "${CURRENT_PACKAGES_DIR}_tmp${Z_VCPKG_INSTALL_PREFIX}" "${CURRENT_PACKAGES_DIR}")
file(REMOVE_RECURSE "${CURRENT_PACKAGES_DIR}_tmp")
endif()
# Remove libtool files since they contain absolute paths and are not necessary.
file(GLOB_RECURSE libtool_files "${CURRENT_PACKAGES_DIR}/**/*.la")
if(libtool_files)
file(REMOVE ${libtool_files})
endif()
if (CMAKE_HOST_WIN32)
set(ENV{PATH} "${path_backup}")
endif()
vcpkg_restore_env_variables(VARS LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH CPPFLAGS CFLAGS CXXFLAGS RCFLAGS)
unset(_VCPKG_MAKE_NO_DEBUG PARENT_SCOPE)
endfunction()

87
externals/vcpkg/scripts/cmake/vcpkg_build_msbuild.cmake vendored Executable file
View File

@@ -0,0 +1,87 @@
function(vcpkg_build_msbuild)
cmake_parse_arguments(
PARSE_ARGV 0
arg
"USE_VCPKG_INTEGRATION"
"PROJECT_PATH;RELEASE_CONFIGURATION;DEBUG_CONFIGURATION;PLATFORM;PLATFORM_TOOLSET;TARGET_PLATFORM_VERSION;TARGET"
"OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_build_msbuild was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_RELEASE_CONFIGURATION)
set(arg_RELEASE_CONFIGURATION Release)
endif()
if(NOT DEFINED arg_DEBUG_CONFIGURATION)
set(arg_DEBUG_CONFIGURATION Debug)
endif()
if(NOT DEFINED arg_PLATFORM)
set(arg_PLATFORM "${TRIPLET_SYSTEM_ARCH}")
endif()
if(NOT DEFINED arg_PLATFORM_TOOLSET)
set(arg_PLATFORM_TOOLSET "${VCPKG_PLATFORM_TOOLSET}")
endif()
if(NOT DEFINED arg_TARGET_PLATFORM_VERSION)
vcpkg_get_windows_sdk(arg_TARGET_PLATFORM_VERSION)
endif()
if(NOT DEFINED arg_TARGET)
set(arg_TARGET Rebuild)
endif()
list(APPEND arg_OPTIONS
"/t:${arg_TARGET}"
"/p:Platform=${arg_PLATFORM}"
"/p:PlatformToolset=${arg_PLATFORM_TOOLSET}"
"/p:VCPkgLocalAppDataDisabled=true"
"/p:UseIntelMKL=No"
"/p:WindowsTargetPlatformVersion=${arg_TARGET_PLATFORM_VERSION}"
"/p:VcpkgManifestInstall=false"
"/p:VcpkgManifestEnabled=false"
"/m"
)
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
# Disable LTCG for static libraries because this setting introduces ABI incompatibility between minor compiler versions
# TODO: Add a way for the user to override this if they want to opt-in to incompatibility
list(APPEND arg_OPTIONS "/p:WholeProgramOptimization=false")
endif()
if(arg_USE_VCPKG_INTEGRATION)
list(
APPEND arg_OPTIONS
"/p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets"
"/p:VcpkgTriplet=${TARGET_TRIPLET}"
"/p:VcpkgInstalledDir=${_VCPKG_INSTALLED_DIR}"
)
else()
list(APPEND arg_OPTIONS "/p:VcpkgEnabled=false")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
message(STATUS "Building ${arg_PROJECT_PATH} for Release")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
vcpkg_execute_required_process(
COMMAND msbuild "${arg_PROJECT_PATH}"
"/p:Configuration=${arg_RELEASE_CONFIGURATION}"
${arg_OPTIONS}
${arg_OPTIONS_RELEASE}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
LOGNAME "build-${TARGET_TRIPLET}-rel"
)
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
message(STATUS "Building ${arg_PROJECT_PATH} for Debug")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
vcpkg_execute_required_process(
COMMAND msbuild "${arg_PROJECT_PATH}"
"/p:Configuration=${arg_DEBUG_CONFIGURATION}"
${arg_OPTIONS}
${arg_OPTIONS_DEBUG}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
LOGNAME "build-${TARGET_TRIPLET}-dbg"
)
endif()
endfunction()

30
externals/vcpkg/scripts/cmake/vcpkg_build_ninja.cmake vendored Executable file
View File

@@ -0,0 +1,30 @@
function(z_vcpkg_build_ninja_build config targets)
message(STATUS "Building (${config})...")
vcpkg_execute_build_process(
COMMAND "${NINJA}" -C "${CURRENT_BUILDTREES_DIR}/${config}" ${targets}
WORKING_DIRECTORY "${SOURCE_PATH}"
LOGNAME "build-${config}"
)
endfunction()
function(vcpkg_build_ninja)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "TARGETS")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_TARGETS)
set(arg_TARGETS "")
endif()
vcpkg_find_acquire_program(NINJA)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
z_vcpkg_build_ninja_build("${TARGET_TRIPLET}-dbg" "${arg_TARGETS}")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
z_vcpkg_build_ninja_build("${TARGET_TRIPLET}-rel" "${arg_TARGETS}")
endif()
endfunction()

127
externals/vcpkg/scripts/cmake/vcpkg_build_nmake.cmake vendored Executable file
View File

@@ -0,0 +1,127 @@
function(vcpkg_build_nmake)
cmake_parse_arguments(PARSE_ARGV 0 arg
"ADD_BIN_TO_PATH;ENABLE_INSTALL;NO_DEBUG"
"SOURCE_PATH;PROJECT_SUBPATH;PROJECT_NAME;LOGFILE_ROOT"
"OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG;PRERUN_SHELL;PRERUN_SHELL_DEBUG;PRERUN_SHELL_RELEASE;TARGET"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_SOURCE_PATH)
message(FATAL_ERROR "SOURCE_PATH must be specified")
endif()
if(arg_NO_DEBUG)
message(WARNING "NO_DEBUG argument to ${CMAKE_CURRENT_FUNCTION} is deprecated")
endif()
if(arg_ADD_BIN_TO_PATH)
message(WARNING "ADD_BIN_TO_PATH argument to ${CMAKE_CURRENT_FUNCTION} is deprecated - it never did anything")
endif()
if(NOT VCPKG_HOST_IS_WINDOWS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} only support windows.")
endif()
if(NOT DEFINED arg_LOGFILE_ROOT)
set(arg_LOGFILE_ROOT "build")
endif()
if(NOT DEFINED arg_PROJECT_NAME)
set(arg_PROJECT_NAME makefile.vc)
endif()
if(NOT DEFINED arg_TARGET)
vcpkg_list(SET arg_TARGET all)
endif()
find_program(NMAKE nmake REQUIRED)
get_filename_component(NMAKE_EXE_PATH ${NMAKE} DIRECTORY)
# Load toolchains
if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
endif()
include("${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}")
# Set needed env
set(ENV{PATH} "$ENV{PATH};${NMAKE_EXE_PATH}")
set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include;$ENV{INCLUDE}")
# Set make command and install command
vcpkg_list(SET make_command ${NMAKE} /NOLOGO /G /U)
vcpkg_list(SET make_opts_base -f "${arg_PROJECT_NAME}" ${arg_TARGET})
if(arg_ENABLE_INSTALL)
vcpkg_list(APPEND make_opts_base install)
endif()
# Add subpath to work directory
if(DEFINED arg_PROJECT_SUBPATH)
set(project_subpath "/${arg_PROJECT_SUBPATH}")
else()
set(project_subpath "")
endif()
vcpkg_backup_env_variables(VARS CL)
cmake_path(NATIVE_PATH CURRENT_PACKAGES_DIR NORMALIZE install_dir_native)
foreach(build_type IN ITEMS debug release)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL build_type)
if(build_type STREQUAL "debug")
# Generate obj dir suffix
set(short_build_type "-dbg")
# Add install command and arguments
set(make_opts "${make_opts_base}")
if (arg_ENABLE_INSTALL)
vcpkg_list(APPEND make_opts "INSTALLDIR=${install_dir_native}\\debug")
endif()
vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_DEBUG})
set(ENV{CL} "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_DEBUG}")
set(prerun_variable_name arg_PRERUN_SHELL_DEBUG)
else()
set(short_build_type "-rel")
# Add install command and arguments
set(make_opts "${make_opts_base}")
if (arg_ENABLE_INSTALL)
vcpkg_list(APPEND make_opts "INSTALLDIR=${install_dir_native}")
endif()
vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_RELEASE})
set(ENV{CL} "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_RELEASE}")
set(prerun_variable_name arg_PRERUN_SHELL_RELEASE)
endif()
set(triplet_and_build_type "${TARGET_TRIPLET}${short_build_type}")
set(object_dir "${CURRENT_BUILDTREES_DIR}/${triplet_and_build_type}")
file(REMOVE_RECURSE "${object_dir}")
file(COPY "${arg_SOURCE_PATH}/" DESTINATION "${object_dir}")
if(DEFINED arg_PRERUN_SHELL)
message(STATUS "Prerunning ${triplet_and_build_type}")
vcpkg_execute_required_process(
COMMAND ${arg_PRERUN_SHELL}
WORKING_DIRECTORY "${object_dir}${project_subpath}"
LOGNAME "prerun-${triplet_and_build_type}"
)
endif()
if(DEFINED "${prerun_variable_name}")
message(STATUS "Prerunning ${triplet_and_build_type}")
vcpkg_execute_required_process(
COMMAND ${${prerun_variable_name}}
WORKING_DIRECTORY "${object_dir}${project_subpath}"
LOGNAME "prerun-specific-${triplet_and_build_type}"
)
endif()
if (NOT arg_ENABLE_INSTALL)
message(STATUS "Building ${triplet_and_build_type}")
else()
message(STATUS "Building and installing ${triplet_and_build_type}")
endif()
vcpkg_execute_build_process(
COMMAND ${make_command} ${make_opts}
WORKING_DIRECTORY "${object_dir}${project_subpath}"
LOGNAME "${arg_LOGFILE_ROOT}-${triplet_and_build_type}"
)
vcpkg_restore_env_variables(VARS CL)
endif()
endforeach()
endfunction()

81
externals/vcpkg/scripts/cmake/vcpkg_build_qmake.cmake vendored Executable file
View File

@@ -0,0 +1,81 @@
function(z_run_jom_build invoke_command targets log_prefix log_suffix)
message(STATUS "Package ${log_prefix}-${TARGET_TRIPLET}-${log_suffix}")
vcpkg_execute_build_process(
COMMAND "${invoke_command}" -j ${VCPKG_CONCURRENCY} ${targets}
NO_PARALLEL_COMMAND "${invoke_command}" -j 1 ${targets}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${log_suffix}"
LOGNAME "package-${log_prefix}-${TARGET_TRIPLET}-${log_suffix}"
)
endfunction()
function(vcpkg_build_qmake)
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
cmake_parse_arguments(PARSE_ARGV 0 arg
"SKIP_MAKEFILES"
"BUILD_LOGNAME"
"TARGETS;RELEASE_TARGETS;DEBUG_TARGETS"
)
# Make sure that the linker finds the libraries used
vcpkg_backup_env_variables(VARS PATH LD_LIBRARY_PATH CL _CL_)
# This fixes issues on machines with default codepages that are not ASCII compatible, such as some CJK encodings
set(ENV{_CL_} "/utf-8")
if(CMAKE_HOST_WIN32)
if (VCPKG_QMAKE_USE_NMAKE)
find_program(NMAKE nmake)
set(invoke_command "${NMAKE}")
get_filename_component(nmake_exe_path "${NMAKE}" DIRECTORY)
vcpkg_host_path_list(APPEND ENV{PATH} "${nmake_exe_path}")
set(ENV{CL} "$ENV{CL} /MP${VCPKG_CONCURRENCY}")
else()
vcpkg_find_acquire_program(JOM)
set(invoke_command "${JOM}")
endif()
else()
find_program(MAKE make)
set(invoke_command "${MAKE}")
endif()
file(TO_NATIVE_PATH "${CURRENT_INSTALLED_DIR}" NATIVE_INSTALLED_DIR)
if(NOT DEFINED arg_BUILD_LOGNAME)
set(arg_BUILD_LOGNAME build)
endif()
set(short_name_debug "dbg")
set(path_suffix_debug "/debug")
set(targets_debug "${arg_DEBUG_TARGETS}")
set(short_name_release "rel")
set(path_suffix_release "")
set(targets_release "${arg_RELEASE_TARGETS}")
if(NOT DEFINED VCPKG_BUILD_TYPE)
set(items debug release)
else()
set(items release)
endif()
foreach(build_type IN ITEMS ${items})
set(current_installed_prefix "${CURRENT_INSTALLED_DIR}${path_suffix_${build_type}}")
vcpkg_add_to_path(PREPEND "${current_installed_prefix}/lib" "${current_installed_prefix}/bin")
# We set LD_LIBRARY_PATH ENV variable to allow executing Qt tools (rcc,...) even with dynamic linking
if(CMAKE_HOST_UNIX)
set(ENV{LD_LIBRARY_PATH} "")
vcpkg_host_path_list(APPEND ENV{LD_LIBRARY_PATH} "${current_installed_prefix}/lib" "${current_installed_prefix}/lib/manual-link")
endif()
vcpkg_list(SET targets ${targets_${build_type}} ${arg_TARGETS})
if(NOT arg_SKIP_MAKEFILES)
z_run_jom_build("${invoke_command}" qmake_all makefiles "${short_name_${build_type}}")
endif()
z_run_jom_build("${invoke_command}" "${targets}" "${arg_BUILD_LOGNAME}" "${short_name_${build_type}}")
vcpkg_restore_env_variables(VARS PATH LD_LIBRARY_PATH)
endforeach()
vcpkg_restore_env_variables(VARS CL _CL_)
endfunction()

8
externals/vcpkg/scripts/cmake/vcpkg_buildpath_length_warning.cmake vendored Executable file
View File

@@ -0,0 +1,8 @@
function(vcpkg_buildpath_length_warning warning_length)
string(LENGTH "${CURRENT_BUILDTREES_DIR}" buildtrees_path_length)
if(buildtrees_path_length GREATER warning_length AND CMAKE_HOST_WIN32)
message(WARNING "${PORT}'s buildsystem uses very long paths and may fail on your system.\n"
"We recommend moving vcpkg to a short path such as 'C:\\src\\vcpkg' or using the subst command."
)
endif()
endfunction()

95
externals/vcpkg/scripts/cmake/vcpkg_check_features.cmake vendored Executable file
View File

@@ -0,0 +1,95 @@
function(z_vcpkg_check_features_last_feature out_var features_name features_list)
list(LENGTH features_list features_length)
math(EXPR features_length_mod_2 "${features_length} % 2")
if(NOT features_length_mod_2 EQUAL 0)
message(FATAL_ERROR "vcpkg_check_features has an incorrect number of arguments to ${features_name}")
endif()
math(EXPR last_feature "${features_length} / 2 - 1")
set("${out_var}" "${last_feature}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_check_features_get_feature idx features_list out_feature_name out_feature_var)
math(EXPR feature_name_idx "${idx} * 2")
math(EXPR feature_var_idx "${feature_name_idx} + 1")
list(GET features_list "${feature_name_idx}" feature_name)
list(GET features_list "${feature_var_idx}" feature_var)
set("${out_feature_name}" "${feature_name}" PARENT_SCOPE)
set("${out_feature_var}" "${feature_var}" PARENT_SCOPE)
endfunction()
function(vcpkg_check_features)
cmake_parse_arguments(
PARSE_ARGV 0 "arg"
""
"OUT_FEATURE_OPTIONS;PREFIX"
"FEATURES;INVERTED_FEATURES"
)
if(NOT DEFINED arg_OUT_FEATURE_OPTIONS)
message(FATAL_ERROR "OUT_FEATURE_OPTIONS must be defined.")
endif()
if(NOT DEFINED arg_PREFIX)
set(prefix "")
else()
set(prefix "${arg_PREFIX}_")
endif()
set(feature_options)
set(feature_variables)
if(NOT DEFINED arg_FEATURES AND NOT DEFINED arg_INVERTED_FEATURES)
message(DEPRECATION
"calling `vcpkg_check_features` without the `FEATURES` keyword has been deprecated.
Please add the `FEATURES` keyword to the call.")
set(arg_FEATURES "${arg_UNPARSED_ARGUMENTS}")
elseif(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "vcpkg_check_features called with unknown arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
z_vcpkg_check_features_last_feature(last_feature "FEATURES" "${arg_FEATURES}")
if(last_feature GREATER_EQUAL 0)
foreach(feature_pair_idx RANGE "${last_feature}")
z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_FEATURES}" feature_name feature_var)
list(APPEND feature_variables "${feature_var}")
if(feature_name IN_LIST FEATURES)
list(APPEND feature_options "-D${feature_var}=ON")
set("${prefix}${feature_var}" ON PARENT_SCOPE)
else()
list(APPEND feature_options "-D${feature_var}=OFF")
set("${prefix}${feature_var}" OFF PARENT_SCOPE)
endif()
endforeach()
endif()
z_vcpkg_check_features_last_feature(last_inverted_feature "INVERTED_FEATURES" "${arg_INVERTED_FEATURES}")
if(last_inverted_feature GREATER_EQUAL 0)
foreach(feature_pair_idx RANGE "${last_inverted_feature}")
z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_INVERTED_FEATURES}" feature_name feature_var)
list(APPEND feature_variables "${feature_var}")
if(feature_name IN_LIST FEATURES)
list(APPEND feature_options "-D${feature_var}=OFF")
set("${prefix}${feature_var}" OFF PARENT_SCOPE)
else()
list(APPEND feature_options "-D${feature_var}=ON")
set("${prefix}${feature_var}" ON PARENT_SCOPE)
endif()
endforeach()
endif()
list(SORT feature_variables)
set(last_variable)
foreach(variable IN LISTS feature_variables)
if(variable STREQUAL last_variable)
message(FATAL_ERROR "vcpkg_check_features passed the same feature variable multiple times: '${variable}'")
endif()
endforeach()
set("${arg_OUT_FEATURE_OPTIONS}" "${feature_options}" PARENT_SCOPE)
endfunction()

36
externals/vcpkg/scripts/cmake/vcpkg_check_linkage.cmake vendored Executable file
View File

@@ -0,0 +1,36 @@
function(vcpkg_check_linkage)
cmake_parse_arguments(PARSE_ARGV 0 arg
"ONLY_STATIC_LIBRARY;ONLY_DYNAMIC_LIBRARY;ONLY_DYNAMIC_CRT;ONLY_STATIC_CRT"
""
""
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(arg_ONLY_STATIC_LIBRARY AND arg_ONLY_DYNAMIC_LIBRARY)
message(FATAL_ERROR "Requesting both ONLY_STATIC_LIBRARY and ONLY_DYNAMIC_LIBRARY; this is an error.")
endif()
if(arg_ONLY_STATIC_CRT AND arg_ONLY_DYNAMIC_CRT)
message(FATAL_ERROR "Requesting both ONLY_STATIC_CRT and ONLY_DYNAMIC_CRT; this is an error.")
endif()
if(arg_ONLY_STATIC_LIBRARY AND "${VCPKG_LIBRARY_LINKAGE}" STREQUAL "dynamic")
message(STATUS "Note: ${PORT} only supports static library linkage. Building static library.")
set(VCPKG_LIBRARY_LINKAGE static PARENT_SCOPE)
elseif(arg_ONLY_DYNAMIC_LIBRARY AND "${VCPKG_LIBRARY_LINKAGE}" STREQUAL "static")
message(STATUS "Note: ${PORT} only supports dynamic library linkage. Building dynamic library.")
if("${VCPKG_CRT_LINKAGE}" STREQUAL "static")
message(FATAL_ERROR "Refusing to build unexpected dynamic library against the static CRT.
If this is desired, please configure your triplet to directly request this configuration.")
endif()
set(VCPKG_LIBRARY_LINKAGE dynamic PARENT_SCOPE)
endif()
if(arg_ONLY_DYNAMIC_CRT AND "${VCPKG_CRT_LINKAGE}" STREQUAL "static")
message(FATAL_ERROR "${PORT} only supports dynamic crt linkage")
elseif(arg_ONLY_STATIC_CRT AND "${VCPKG_CRT_LINKAGE}" STREQUAL "dynamic")
message(FATAL_ERROR "${PORT} only supports static crt linkage")
endif()
endfunction()

40
externals/vcpkg/scripts/cmake/vcpkg_clean_executables_in_bin.cmake vendored Executable file
View File

@@ -0,0 +1,40 @@
function(z_vcpkg_clean_executables_in_bin_remove_directory_if_empty directory)
if(NOT EXISTS "${directory}")
return()
endif()
if(NOT IS_DIRECTORY "${directory}")
message(FATAL_ERROR "${directory} must be a directory")
endif()
file(GLOB items "${directory}/*")
if("${items}" STREQUAL "")
file(REMOVE_RECURSE "${directory}")
endif()
endfunction()
function(vcpkg_clean_executables_in_bin)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "FILE_NAMES")
if(NOT DEFINED arg_FILE_NAMES)
message(FATAL_ERROR "FILE_NAMES must be specified.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(file_name IN LISTS arg_FILE_NAMES)
file(REMOVE
"${CURRENT_PACKAGES_DIR}/bin/${file_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}"
"${CURRENT_PACKAGES_DIR}/debug/bin/${file_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}"
"${CURRENT_PACKAGES_DIR}/bin/${file_name}.pdb"
"${CURRENT_PACKAGES_DIR}/debug/bin/${file_name}.pdb"
)
endforeach()
z_vcpkg_clean_executables_in_bin_remove_directory_if_empty("${CURRENT_PACKAGES_DIR}/bin")
z_vcpkg_clean_executables_in_bin_remove_directory_if_empty("${CURRENT_PACKAGES_DIR}/debug/bin")
endfunction()

9
externals/vcpkg/scripts/cmake/vcpkg_clean_msbuild.cmake vendored Executable file
View File

@@ -0,0 +1,9 @@
function(vcpkg_clean_msbuild)
if(NOT ARGC EQUAL 0)
message(WARNING "vcpkg_clean_msbuild was passed extra arguments: ${ARGV}")
endif()
file(REMOVE_RECURSE
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
)
endfunction()

189
externals/vcpkg/scripts/cmake/vcpkg_common_definitions.cmake vendored Executable file
View File

@@ -0,0 +1,189 @@
string(COMPARE NOTEQUAL "${TARGET_TRIPLET}" "${HOST_TRIPLET}" VCPKG_CROSSCOMPILING)
#Helper variable to identify the Target system. VCPKG_TARGET_IS_<targetname>
if (NOT DEFINED VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_CMAKE_SYSTEM_NAME STREQUAL "")
set(VCPKG_TARGET_IS_WINDOWS ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "WindowsStore")
set(VCPKG_TARGET_IS_WINDOWS ON)
set(VCPKG_TARGET_IS_UWP ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set(VCPKG_TARGET_IS_OSX ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "iOS")
set(VCPKG_TARGET_IS_IOS ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Linux")
set(VCPKG_TARGET_IS_LINUX ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "Android")
set(VCPKG_TARGET_IS_ANDROID ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
set(VCPKG_TARGET_IS_FREEBSD ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "OpenBSD")
set(VCPKG_TARGET_IS_OPENBSD ON)
elseif(VCPKG_CMAKE_SYSTEM_NAME STREQUAL "MinGW")
set(VCPKG_TARGET_IS_WINDOWS ON)
set(VCPKG_TARGET_IS_MINGW ON)
endif()
#Helper variables to identify the host system name
if (CMAKE_HOST_WIN32)
set(VCPKG_HOST_IS_WINDOWS ON)
elseif (CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
set(VCPKG_HOST_IS_OSX ON)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
set(VCPKG_HOST_IS_LINUX ON)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
set(VCPKG_HOST_IS_FREEBSD ON)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
set(VCPKG_HOST_IS_OPENBSD ON)
endif()
#Helper variable to identify the host path separator.
if(CMAKE_HOST_WIN32)
set(VCPKG_HOST_PATH_SEPARATOR ";")
elseif(CMAKE_HOST_UNIX)
set(VCPKG_HOST_PATH_SEPARATOR ":")
endif()
#Helper variables to identify executables on host/target
if(CMAKE_HOST_WIN32)
set(VCPKG_HOST_EXECUTABLE_SUFFIX ".exe")
else()
set(VCPKG_HOST_EXECUTABLE_SUFFIX "")
endif()
#set(CMAKE_EXECUTABLE_SUFFIX ${VCPKG_HOST_EXECUTABLE_SUFFIX}) not required by find_program
if(VCPKG_TARGET_IS_WINDOWS)
set(VCPKG_TARGET_EXECUTABLE_SUFFIX ".exe")
else()
set(VCPKG_TARGET_EXECUTABLE_SUFFIX "")
endif()
#Helper variables to identify bundles on host/target
if(VCPKG_HOST_IS_OSX)
set(VCPKG_HOST_BUNDLE_SUFFIX ".app")
else()
set(VCPKG_HOST_BUNDLE_SUFFIX "")
endif()
if(VCPKG_TARGET_IS_OSX)
set(VCPKG_TARGET_BUNDLE_SUFFIX ".app")
else()
set(VCPKG_TARGET_BUNDLE_SUFFIX "")
endif()
#Helper variables for libraries
if(VCPKG_TARGET_IS_MINGW)
set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".dll.a")
set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "lib")
set(VCPKG_FIND_LIBRARY_SUFFIXES ".dll" ".dll.a" ".a" ".lib")
set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
elseif(VCPKG_TARGET_IS_WINDOWS)
set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".lib")
set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dll")
set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX ".lib")
set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "")
set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "")
set(VCPKG_TARGET_IMPORT_LIBRARY_PREFIX "")
set(VCPKG_FIND_LIBRARY_SUFFIXES ".lib" ".dll") #This is a slight modification to CMakes value which does not include ".dll".
set(VCPKG_FIND_LIBRARY_PREFIXES "" "lib") #This is a slight modification to CMakes value which does not include "lib".
elseif(VCPKG_TARGET_IS_OSX)
set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".dylib")
set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
set(VCPKG_FIND_LIBRARY_SUFFIXES ".tbd" ".dylib" ".so" ".a")
set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
else()
set(VCPKG_TARGET_STATIC_LIBRARY_SUFFIX ".a")
set(VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX "")
set(VCPKG_TARGET_SHARED_LIBRARY_SUFFIX ".so")
set(VCPKG_TARGET_STATIC_LIBRARY_PREFIX "lib")
set(VCPKG_TARGET_SHARED_LIBRARY_PREFIX "lib")
set(VCPKG_FIND_LIBRARY_SUFFIXES ".so" ".a")
set(VCPKG_FIND_LIBRARY_PREFIXES "lib" "")
endif()
#Setting these variables allows find_library to work in script mode and thus in portfiles!
#This allows us scale down on hardcoded target dependent paths in portfiles
set(CMAKE_STATIC_LIBRARY_SUFFIX "${VCPKG_TARGET_STATIC_LIBRARY_SUFFIX}")
set(CMAKE_SHARED_LIBRARY_SUFFIX "${VCPKG_TARGET_SHARED_LIBRARY_SUFFIX}")
set(CMAKE_IMPORT_LIBRARY_SUFFIX "${VCPKG_TARGET_IMPORT_LIBRARY_SUFFIX}")
set(CMAKE_STATIC_LIBRARY_PREFIX "${VCPKG_TARGET_STATIC_LIBRARY_PREFIX}")
set(CMAKE_SHARED_LIBRARY_PREFIX "${VCPKG_TARGET_SHARED_LIBRARY_PREFIX}")
set(CMAKE_IMPORT_LIBRARY_PREFIX "${VCPKG_TARGET_IMPORT_LIBRARY_PREFIX}")
set(CMAKE_FIND_LIBRARY_SUFFIXES "${VCPKG_FIND_LIBRARY_SUFFIXES}" CACHE INTERNAL "") # Required by find_library
set(CMAKE_FIND_LIBRARY_PREFIXES "${VCPKG_FIND_LIBRARY_PREFIXES}" CACHE INTERNAL "") # Required by find_library
# Append platform libraries to VCPKG_SYSTEM_LIBRARIES
# The variable are just appended to permit to custom triplets define the variable
# Platforms with libdl
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX)
list(APPEND VCPKG_SYSTEM_LIBRARIES dl)
endif()
# Platforms with libm
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_MINGW)
list(APPEND VCPKG_SYSTEM_LIBRARIES m)
endif()
# Platforms with pthread
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
list(APPEND VCPKG_SYSTEM_LIBRARIES pthread)
endif()
# Platforms with libstdc++
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
list(APPEND VCPKG_SYSTEM_LIBRARIES [[stdc\+\+]])
endif()
# Platforms with libc++
if(VCPKG_TARGET_IS_OSX)
list(APPEND VCPKG_SYSTEM_LIBRARIES [[c\+\+]])
endif()
# Platforms with librt
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_MINGW)
list(APPEND VCPKG_SYSTEM_LIBRARIES rt)
endif()
# Platforms with GCC libs
if(VCPKG_TARGET_IS_LINUX OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_FREEBSD OR VCPKG_TARGET_IS_OPENBSD OR VCPKG_TARGET_IS_MINGW)
list(APPEND VCPKG_SYSTEM_LIBRARIES gcc)
list(APPEND VCPKG_SYSTEM_LIBRARIES gcc_s)
endif()
# Platforms with system iconv
if(VCPKG_TARGET_IS_OSX)
list(APPEND VCPKG_SYSTEM_LIBRARIES iconv)
endif()
# Windows system libs
if(VCPKG_TARGET_IS_WINDOWS)
list(APPEND VCPKG_SYSTEM_LIBRARIES advapi32)
list(APPEND VCPKG_SYSTEM_LIBRARIES bcrypt)
list(APPEND VCPKG_SYSTEM_LIBRARIES dinput8)
list(APPEND VCPKG_SYSTEM_LIBRARIES gdi32)
list(APPEND VCPKG_SYSTEM_LIBRARIES imm32)
list(APPEND VCPKG_SYSTEM_LIBRARIES oleaut32)
list(APPEND VCPKG_SYSTEM_LIBRARIES ole32)
list(APPEND VCPKG_SYSTEM_LIBRARIES psapi)
list(APPEND VCPKG_SYSTEM_LIBRARIES secur32)
list(APPEND VCPKG_SYSTEM_LIBRARIES setupapi)
list(APPEND VCPKG_SYSTEM_LIBRARIES shell32)
list(APPEND VCPKG_SYSTEM_LIBRARIES shlwapi)
list(APPEND VCPKG_SYSTEM_LIBRARIES strmiids)
list(APPEND VCPKG_SYSTEM_LIBRARIES user32)
list(APPEND VCPKG_SYSTEM_LIBRARIES uuid)
list(APPEND VCPKG_SYSTEM_LIBRARIES version)
list(APPEND VCPKG_SYSTEM_LIBRARIES vfw32)
list(APPEND VCPKG_SYSTEM_LIBRARIES winmm)
list(APPEND VCPKG_SYSTEM_LIBRARIES wsock32)
list(APPEND VCPKG_SYSTEM_LIBRARIES Ws2_32)
list(APPEND VCPKG_SYSTEM_LIBRARIES wldap32)
list(APPEND VCPKG_SYSTEM_LIBRARIES crypt32)
endif()

3
externals/vcpkg/scripts/cmake/vcpkg_common_functions.cmake vendored Executable file
View File

@@ -0,0 +1,3 @@
# DEPRECATED
message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_common_functions has been removed and all values are automatically provided in all portfile.cmake invocations. Please remove `include(vcpkg_common_functions)`.")

373
externals/vcpkg/scripts/cmake/vcpkg_configure_cmake.cmake vendored Executable file
View File

@@ -0,0 +1,373 @@
function(z_vcpkg_configure_cmake_both_or_neither_set var1 var2)
if(DEFINED "${var1}" AND NOT DEFINED "${var2}")
message(FATAL_ERROR "If ${var1} is set, ${var2} must be set.")
endif()
if(NOT DEFINED "${var1}" AND DEFINED "${var2}")
message(FATAL_ERROR "If ${var2} is set, ${var1} must be set.")
endif()
endfunction()
function(z_vcpkg_configure_cmake_build_cmakecache out_var whereat build_type)
set(line "build ${whereat}/CMakeCache.txt: CreateProcess\n process = cmd /c \"cd ${whereat} &&")
foreach(arg IN LISTS "${build_type}_command")
string(APPEND line " \"${arg}\"")
endforeach()
set("${out_var}" "${${out_var}}${line}\"\n\n" PARENT_SCOPE)
endfunction()
function(z_vcpkg_get_visual_studio_generator)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "OUT_GENERATOR;OUT_ARCH" "")
if (NOT DEFINED arg_OUT_GENERATOR)
message(FATAL_ERROR "OUT_GENERATOR must be defined.")
endif()
if(NOT DEFINED arg_OUT_ARCH)
message(FATAL_ERROR "OUT_ARCH must be defined.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if("${VCPKG_PLATFORM_TOOLSET}" STREQUAL "v120" AND NOT "${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
set(generator "Visual Studio 12 2013")
elseif("${VCPKG_PLATFORM_TOOLSET}" STREQUAL "v140" AND NOT "${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
set(generator "Visual Studio 14 2015")
elseif("${VCPKG_PLATFORM_TOOLSET}" STREQUAL "v141")
set(generator "Visual Studio 15 2017")
elseif("${VCPKG_PLATFORM_TOOLSET}" STREQUAL "v142")
set(generator "Visual Studio 16 2019")
elseif("${VCPKG_PLATFORM_TOOLSET}" STREQUAL "v143")
set(generator "Visual Studio 17 2022")
endif()
if("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x86")
set(generator_arch "Win32")
elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x64")
set(generator_arch "x64")
elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm")
set(generator_arch "ARM")
elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
set(generator_arch "ARM64")
endif()
set(${arg_OUT_GENERATOR} "${generator}" PARENT_SCOPE)
set(${arg_OUT_ARCH} "${generator_arch}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_select_default_vcpkg_chainload_toolchain)
# Try avoiding adding more defaults here.
# Set VCPKG_CHAINLOAD_TOOLCHAIN_FILE explicitly in the triplet.
if(DEFINED Z_VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${Z_VCPKG_CHAINLOAD_TOOLCHAIN_FILE}")
elseif(VCPKG_TARGET_IS_MINGW)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake")
elseif(VCPKG_TARGET_IS_WINDOWS)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
elseif(VCPKG_TARGET_IS_LINUX)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake")
elseif(VCPKG_TARGET_IS_ANDROID)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake")
elseif(VCPKG_TARGET_IS_OSX)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake")
elseif(VCPKG_TARGET_IS_IOS)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/ios.cmake")
elseif(VCPKG_TARGET_IS_FREEBSD)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake")
elseif(VCPKG_TARGET_IS_OPENBSD)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/openbsd.cmake")
endif()
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE ${VCPKG_CHAINLOAD_TOOLCHAIN_FILE} PARENT_SCOPE)
endfunction()
function(vcpkg_configure_cmake)
cmake_parse_arguments(PARSE_ARGV 0 arg
"PREFER_NINJA;DISABLE_PARALLEL_CONFIGURE;NO_CHARSET_FLAG;Z_GET_CMAKE_VARS_USAGE"
"SOURCE_PATH;GENERATOR;LOGNAME"
"OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;MAYBE_UNUSED_VARIABLES"
)
if(NOT arg_Z_GET_CMAKE_VARS_USAGE AND Z_VCPKG_CMAKE_CONFIGURE_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_configure_cmake in the same port is unsupported.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_SOURCE_PATH)
message(FATAL_ERROR "SOURCE_PATH must be specified")
endif()
if(NOT DEFINED arg_LOGNAME)
set(arg_LOGNAME "config-${TARGET_TRIPLET}")
endif()
vcpkg_list(SET manually_specified_variables)
if(arg_Z_GET_CMAKE_VARS_USAGE)
set(configuring_message "Getting CMake variables for ${TARGET_TRIPLET}")
else()
set(configuring_message "Configuring ${TARGET_TRIPLET}")
foreach(option IN LISTS arg_OPTIONS arg_OPTIONS_RELEASE arg_OPTIONS_DEBUG)
if("${option}" MATCHES "^-D([^:=]*)[:=]")
vcpkg_list(APPEND manually_specified_variables "${CMAKE_MATCH_1}")
endif()
endforeach()
vcpkg_list(REMOVE_DUPLICATES manually_specified_variables)
foreach(maybe_unused_var IN LISTS arg_MAYBE_UNUSED_VARIABLES)
vcpkg_list(REMOVE_ITEM manually_specified_variables "${maybe_unused_var}")
endforeach()
debug_message("manually specified variables: ${manually_specified_variables}")
endif()
set(ninja_can_be_used ON) # Ninja as generator
set(ninja_host ON) # Ninja as parallel configurator
if(NOT arg_PREFER_NINJA AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
set(ninja_can_be_used OFF)
endif()
if(VCPKG_HOST_IS_WINDOWS)
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(host_arch "$ENV{PROCESSOR_ARCHITEW6432}")
else()
set(host_arch "$ENV{PROCESSOR_ARCHITECTURE}")
endif()
if("${host_arch}" STREQUAL "x86")
# Prebuilt ninja binaries are only provided for x64 hosts
set(ninja_can_be_used OFF)
set(ninja_host OFF)
endif()
endif()
set(generator "Ninja") # the default generator is always ninja!
set(generator_arch "")
if(DEFINED arg_GENERATOR)
set(generator "${arg_GENERATOR}")
elseif(NOT ninja_can_be_used)
set(generator "")
z_vcpkg_get_visual_studio_generator(OUT_GENERATOR generator OUT_ARCH generator_arch)
if("${generator}" STREQUAL "" OR "${generator_arch}" STREQUAL "")
message(FATAL_ERROR
"Unable to determine appropriate generator for triplet ${TARGET_TRIPLET}:
platform toolset: ${VCPKG_PLATFORM_TOOLSET}
architecture : ${VCPKG_TARGET_ARCHITECTURE}")
endif()
endif()
# If we use Ninja, make sure it's on PATH
if("${generator}" STREQUAL "Ninja" AND NOT DEFINED ENV{VCPKG_FORCE_SYSTEM_BINARIES})
vcpkg_find_acquire_program(NINJA)
get_filename_component(ninja_path "${NINJA}" DIRECTORY)
vcpkg_add_to_path("${ninja_path}")
vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}")
endif()
file(REMOVE_RECURSE
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
if(DEFINED VCPKG_CMAKE_SYSTEM_NAME)
vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}")
if(VCPKG_TARGET_IS_UWP AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
set(VCPKG_CMAKE_SYSTEM_VERSION 10.0)
elseif(VCPKG_TARGET_IS_ANDROID AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
set(VCPKG_CMAKE_SYSTEM_VERSION 21)
endif()
endif()
if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_VERSION=${VCPKG_CMAKE_SYSTEM_VERSION}")
endif()
if("${VCPKG_LIBRARY_LINKAGE}" STREQUAL "dynamic")
vcpkg_list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=ON)
elseif("${VCPKG_LIBRARY_LINKAGE}" STREQUAL "static")
vcpkg_list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=OFF)
else()
message(FATAL_ERROR
"Invalid setting for VCPKG_LIBRARY_LINKAGE: \"${VCPKG_LIBRARY_LINKAGE}\".
It must be \"static\" or \"dynamic\"")
endif()
z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS_DEBUG VCPKG_C_FLAGS_DEBUG)
z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS_RELEASE VCPKG_C_FLAGS_RELEASE)
z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS VCPKG_C_FLAGS)
set(vcpkg_set_charset_flag ON)
if(arg_NO_CHARSET_FLAG)
set(vcpkg_set_charset_flag OFF)
endif()
if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
z_vcpkg_select_default_vcpkg_chainload_toolchain()
endif()
vcpkg_list(APPEND arg_OPTIONS
"-DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}"
"-DVCPKG_TARGET_TRIPLET=${TARGET_TRIPLET}"
"-DVCPKG_SET_CHARSET_FLAG=${vcpkg_set_charset_flag}"
"-DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}"
"-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON"
"-DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=ON"
"-DCMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY=ON"
"-DCMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP=TRUE"
"-DCMAKE_VERBOSE_MAKEFILE=ON"
"-DVCPKG_APPLOCAL_DEPS=OFF"
"-DCMAKE_TOOLCHAIN_FILE=${SCRIPTS}/buildsystems/vcpkg.cmake"
"-DCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION=ON"
"-DVCPKG_CXX_FLAGS=${VCPKG_CXX_FLAGS}"
"-DVCPKG_CXX_FLAGS_RELEASE=${VCPKG_CXX_FLAGS_RELEASE}"
"-DVCPKG_CXX_FLAGS_DEBUG=${VCPKG_CXX_FLAGS_DEBUG}"
"-DVCPKG_C_FLAGS=${VCPKG_C_FLAGS}"
"-DVCPKG_C_FLAGS_RELEASE=${VCPKG_C_FLAGS_RELEASE}"
"-DVCPKG_C_FLAGS_DEBUG=${VCPKG_C_FLAGS_DEBUG}"
"-DVCPKG_CRT_LINKAGE=${VCPKG_CRT_LINKAGE}"
"-DVCPKG_LINKER_FLAGS=${VCPKG_LINKER_FLAGS}"
"-DVCPKG_LINKER_FLAGS_RELEASE=${VCPKG_LINKER_FLAGS_RELEASE}"
"-DVCPKG_LINKER_FLAGS_DEBUG=${VCPKG_LINKER_FLAGS_DEBUG}"
"-DVCPKG_TARGET_ARCHITECTURE=${VCPKG_TARGET_ARCHITECTURE}"
"-DCMAKE_INSTALL_LIBDIR:STRING=lib"
"-DCMAKE_INSTALL_BINDIR:STRING=bin"
"-D_VCPKG_ROOT_DIR=${VCPKG_ROOT_DIR}"
"-DZ_VCPKG_ROOT_DIR=${VCPKG_ROOT_DIR}"
"-D_VCPKG_INSTALLED_DIR=${_VCPKG_INSTALLED_DIR}"
"-DVCPKG_MANIFEST_INSTALL=OFF"
)
if(NOT "${generator_arch}" STREQUAL "")
vcpkg_list(APPEND arg_OPTIONS "-A${generator_arch}")
endif()
# Sets configuration variables for macOS builds
foreach(config_var IN ITEMS INSTALL_NAME_DIR OSX_DEPLOYMENT_TARGET OSX_SYSROOT OSX_ARCHITECTURES)
if(DEFINED "VCPKG_${config_var}")
vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_${config_var}=${VCPKG_${config_var}}")
endif()
endforeach()
# Allow overrides / additional configuration variables from triplets
if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS)
vcpkg_list(APPEND arg_OPTIONS "${VCPKG_CMAKE_CONFIGURE_OPTIONS}")
endif()
if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS_RELEASE)
vcpkg_list(APPEND arg_OPTIONS_RELEASE "${VCPKG_CMAKE_CONFIGURE_OPTIONS_RELEASE}")
endif()
if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS_DEBUG)
vcpkg_list(APPEND arg_OPTIONS_DEBUG "${VCPKG_CMAKE_CONFIGURE_OPTIONS_DEBUG}")
endif()
vcpkg_list(SET rel_command
"${CMAKE_COMMAND}" "${arg_SOURCE_PATH}"
-G "${generator}"
"-DCMAKE_BUILD_TYPE=Release"
"-DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}"
${arg_OPTIONS} ${arg_OPTIONS_RELEASE})
vcpkg_list(SET dbg_command
"${CMAKE_COMMAND}" "${arg_SOURCE_PATH}"
-G "${generator}"
"-DCMAKE_BUILD_TYPE=Debug"
"-DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}/debug"
${arg_OPTIONS} ${arg_OPTIONS_DEBUG})
if(ninja_host AND CMAKE_HOST_WIN32 AND NOT arg_DISABLE_PARALLEL_CONFIGURE)
vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_DISABLE_SOURCE_CHANGES=ON")
vcpkg_find_acquire_program(NINJA)
if(NOT DEFINED ninja_path)
# if ninja_path was defined above, we've already done this
get_filename_component(ninja_path "${NINJA}" DIRECTORY)
vcpkg_add_to_path("${ninja_path}")
endif()
#parallelize the configure step
set(ninja_configure_contents
"rule CreateProcess\n command = \$process\n\n"
)
if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "release")
z_vcpkg_configure_cmake_build_cmakecache(ninja_configure_contents ".." "rel")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "debug")
z_vcpkg_configure_cmake_build_cmakecache(ninja_configure_contents "../../${TARGET_TRIPLET}-dbg" "dbg")
endif()
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure")
file(WRITE
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure/build.ninja"
"${ninja_configure_contents}")
message(STATUS "${configuring_message}")
vcpkg_execute_required_process(
COMMAND "${NINJA}" -v
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure"
LOGNAME "${arg_LOGNAME}"
)
vcpkg_list(APPEND config_logs
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out.log"
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-err.log")
else()
if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "debug")
message(STATUS "${configuring_message}-dbg")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
vcpkg_execute_required_process(
COMMAND ${dbg_command}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
LOGNAME "${arg_LOGNAME}-dbg"
)
vcpkg_list(APPEND config_logs
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-dbg-out.log"
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-dbg-err.log")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "release")
message(STATUS "${configuring_message}-rel")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
vcpkg_execute_required_process(
COMMAND ${rel_command}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
LOGNAME "${arg_LOGNAME}-rel"
)
vcpkg_list(APPEND config_logs
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-rel-out.log"
"${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-rel-err.log")
endif()
endif()
# Check unused variables
vcpkg_list(SET all_unused_variables)
foreach(config_log IN LISTS config_logs)
if(NOT EXISTS "${config_log}")
continue()
endif()
file(READ "${config_log}" log_contents)
debug_message("Reading configure log ${config_log}...")
if(NOT "${log_contents}" MATCHES "Manually-specified variables were not used by the project:\n\n(( [^\n]*\n)*)")
continue()
endif()
string(STRIP "${CMAKE_MATCH_1}" unused_variables) # remove leading ` ` and trailing `\n`
string(REPLACE "\n " ";" unused_variables "${unused_variables}")
debug_message("unused variables: ${unused_variables}")
foreach(unused_variable IN LISTS unused_variables)
if("${unused_variable}" IN_LIST manually_specified_variables)
debug_message("manually specified unused variable: ${unused_variable}")
vcpkg_list(APPEND all_unused_variables "${unused_variable}")
else()
debug_message("unused variable (not manually specified): ${unused_variable}")
endif()
endforeach()
endforeach()
if(NOT "${all_unused_variables}" STREQUAL "")
vcpkg_list(REMOVE_DUPLICATES all_unused_variables)
vcpkg_list(JOIN all_unused_variables "\n " all_unused_variables)
message(WARNING "The following variables are not used in CMakeLists.txt:
${all_unused_variables}
Please recheck them and remove the unnecessary options from the `vcpkg_configure_cmake` call.
If these options should still be passed for whatever reason, please use the `MAYBE_UNUSED_VARIABLES` argument.")
endif()
if(NOT arg_Z_GET_CMAKE_VARS_USAGE)
set(Z_VCPKG_CMAKE_GENERATOR "${generator}" PARENT_SCOPE)
endif()
endfunction()

49
externals/vcpkg/scripts/cmake/vcpkg_configure_gn.cmake vendored Executable file
View File

@@ -0,0 +1,49 @@
function(z_vcpkg_configure_gn_generate)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;CONFIG;ARGS" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error: generate was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
message(STATUS "Generating build (${arg_CONFIG})...")
vcpkg_execute_required_process(
COMMAND "${GN}" gen "${CURRENT_BUILDTREES_DIR}/${arg_CONFIG}" "${arg_ARGS}"
WORKING_DIRECTORY "${arg_SOURCE_PATH}"
LOGNAME "generate-${arg_CONFIG}"
)
endfunction()
function(vcpkg_configure_gn)
if(Z_VCPKG_GN_CONFIGURE_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_configure_gn in the same port is unsupported.")
endif()
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_configure_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_SOURCE_PATH)
message(FATAL_ERROR "SOURCE_PATH must be specified.")
endif()
vcpkg_find_acquire_program(PYTHON3)
get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
vcpkg_add_to_path(PREPEND "${PYTHON3_DIR}")
vcpkg_find_acquire_program(GN)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
z_vcpkg_configure_gn_generate(
SOURCE_PATH "${arg_SOURCE_PATH}"
CONFIG "${TARGET_TRIPLET}-dbg"
ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_DEBUG}"
)
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
z_vcpkg_configure_gn_generate(
SOURCE_PATH "${arg_SOURCE_PATH}"
CONFIG "${TARGET_TRIPLET}-rel"
ARGS "--args=${arg_OPTIONS} ${arg_OPTIONS_RELEASE}"
)
endif()
endfunction()

760
externals/vcpkg/scripts/cmake/vcpkg_configure_make.cmake vendored Executable file
View File

@@ -0,0 +1,760 @@
macro(z_vcpkg_determine_host_mingw out_var)
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(host_arch $ENV{PROCESSOR_ARCHITEW6432})
else()
set(host_arch $ENV{PROCESSOR_ARCHITECTURE})
endif()
if(host_arch MATCHES "(amd|AMD)64")
set(${out_var} mingw64)
elseif(host_arch MATCHES "(x|X)86")
set(${out_var} mingw32)
else()
message(FATAL_ERROR "Unsupported mingw architecture ${host_arch} in z_vcpkg_determine_autotools_host_cpu!" )
endif()
unset(host_arch)
endmacro()
macro(z_vcpkg_determine_autotools_host_cpu out_var)
# TODO: the host system processor architecture can differ from the host triplet target architecture
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(host_arch $ENV{PROCESSOR_ARCHITEW6432})
elseif(DEFINED ENV{PROCESSOR_ARCHITECTURE})
set(host_arch $ENV{PROCESSOR_ARCHITECTURE})
else()
set(host_arch "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
endif()
if(host_arch MATCHES "(amd|AMD)64")
set(${out_var} x86_64)
elseif(host_arch MATCHES "(x|X)86")
set(${out_var} i686)
elseif(host_arch MATCHES "^(ARM|arm)64$")
set(${out_var} aarch64)
elseif(host_arch MATCHES "^(ARM|arm)$")
set(${out_var} arm)
else()
message(FATAL_ERROR "Unsupported host architecture ${host_arch} in z_vcpkg_determine_autotools_host_cpu!" )
endif()
unset(host_arch)
endmacro()
macro(z_vcpkg_determine_autotools_target_cpu out_var)
if(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64")
set(${out_var} x86_64)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
set(${out_var} i686)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
set(${out_var} aarch64)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
set(${out_var} arm)
else()
message(FATAL_ERROR "Unsupported VCPKG_TARGET_ARCHITECTURE architecture ${VCPKG_TARGET_ARCHITECTURE} in z_vcpkg_determine_autotools_target_cpu!" )
endif()
endmacro()
macro(z_vcpkg_determine_autotools_host_arch_mac out_var)
set(${out_var} "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
endmacro()
macro(z_vcpkg_determine_autotools_target_arch_mac out_var)
list(LENGTH VCPKG_OSX_ARCHITECTURES osx_archs_num)
if(osx_archs_num EQUAL 0)
set(${out_var} "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
elseif(osx_archs_num GREATER_EQUAL 2)
set(${out_var} "universal")
else()
# Better match the arch behavior of config.guess
# See: https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
if(VCPKG_OSX_ARCHITECTURES MATCHES "^(ARM|arm)64$")
set(${out_var} "aarch64")
else()
set(${out_var} "${VCPKG_OSX_ARCHITECTURES}")
endif()
endif()
unset(osx_archs_num)
endmacro()
macro(z_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags flag_suffix)
string(REGEX MATCHALL "( |^)-D[^ ]+" CPPFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${flag_suffix}}")
string(REGEX MATCHALL "( |^)-D[^ ]+" CXXPPFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${flag_suffix}}")
list(JOIN CXXPPFLAGS_${flag_suffix} "|" CXXREGEX)
if(CXXREGEX)
list(FILTER CPPFLAGS_${flag_suffix} INCLUDE REGEX "(${CXXREGEX})")
else()
set(CPPFLAGS_${flag_suffix})
endif()
list(JOIN CPPFLAGS_${flag_suffix} "|" CPPREGEX)
list(JOIN CPPFLAGS_${flag_suffix} " " CPPFLAGS_${flag_suffix})
set(CPPFLAGS_${flag_suffix} "${CPPFLAGS_${flag_suffix}}")
if(CPPREGEX)
string(REGEX REPLACE "(${CPPREGEX})" "" CFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${flag_suffix}}")
string(REGEX REPLACE "(${CPPREGEX})" "" CXXFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${flag_suffix}}")
else()
set(CFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_C_FLAGS_${flag_suffix}}")
set(CXXFLAGS_${flag_suffix} "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${flag_suffix}}")
endif()
string(REGEX REPLACE " +" " " CPPFLAGS_${flag_suffix} "${CPPFLAGS_${flag_suffix}}")
string(REGEX REPLACE " +" " " CFLAGS_${flag_suffix} "${CFLAGS_${flag_suffix}}")
string(REGEX REPLACE " +" " " CXXFLAGS_${flag_suffix} "${CXXFLAGS_${flag_suffix}}")
# libtool has and -R option so we need to guard against -RTC by using -Xcompiler
# while configuring there might be a lot of unknown compiler option warnings due to that
# just ignore them.
string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CFLAGS_${flag_suffix} "${CFLAGS_${flag_suffix}}")
string(REGEX REPLACE "((-|/)RTC[^ ]+)" "-Xcompiler \\1" CXXFLAGS_${flag_suffix} "${CXXFLAGS_${flag_suffix}}")
string(STRIP "${CPPFLAGS_${flag_suffix}}" CPPFLAGS_${flag_suffix})
string(STRIP "${CFLAGS_${flag_suffix}}" CFLAGS_${flag_suffix})
string(STRIP "${CXXFLAGS_${flag_suffix}}" CXXFLAGS_${flag_suffix})
debug_message("CPPFLAGS_${flag_suffix}: ${CPPFLAGS_${flag_suffix}}")
debug_message("CFLAGS_${flag_suffix}: ${CFLAGS_${flag_suffix}}")
debug_message("CXXFLAGS_${flag_suffix}: ${CXXFLAGS_${flag_suffix}}")
endmacro()
macro(z_vcpkg_append_to_configure_environment inoutstring var defaultval)
# Allows to overwrite settings in custom triplets via the environment on windows
if(CMAKE_HOST_WIN32 AND DEFINED ENV{${var}})
string(APPEND ${inoutstring} " ${var}='$ENV{${var}}'")
else()
string(APPEND ${inoutstring} " ${var}='${defaultval}'")
endif()
endmacro()
macro(z_convert_to_list input output)
string(REGEX MATCHALL "(( +|^ *)[^ ]+)" ${output} "${${input}}")
endmacro()
function(vcpkg_configure_make)
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
cmake_parse_arguments(PARSE_ARGV 0 arg
"AUTOCONFIG;SKIP_CONFIGURE;COPY_SOURCE;DISABLE_VERBOSE_FLAGS;NO_ADDITIONAL_PATHS;ADD_BIN_TO_PATH;NO_DEBUG;USE_WRAPPERS;DETERMINE_BUILD_TRIPLET"
"SOURCE_PATH;PROJECT_SUBPATH;PRERUN_SHELL;BUILD_TRIPLET"
"OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;CONFIGURE_ENVIRONMENT_VARIABLES;CONFIG_DEPENDENT_ENVIRONMENT;ADDITIONAL_MSYS_PACKAGES"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
z_vcpkg_get_cmake_vars(cmake_vars_file)
debug_message("Including cmake vars from: ${cmake_vars_file}")
include("${cmake_vars_file}")
if(DEFINED VCPKG_MAKE_BUILD_TRIPLET)
set(arg_BUILD_TRIPLET ${VCPKG_MAKE_BUILD_TRIPLET}) # Triplet overwrite for crosscompiling
endif()
set(src_dir "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}")
set(requires_autogen OFF) # use autogen.sh
set(requires_autoconfig OFF) # use autotools and configure.ac
if(EXISTS "${src_dir}/configure" AND "${src_dir}/configure.ac") # remove configure; rerun autoconf
if(NOT VCPKG_MAINTAINER_SKIP_AUTOCONFIG) # If fixing bugs skipping autoconfig saves a lot of time
set(requires_autoconfig ON)
file(REMOVE "${SRC_DIR}/configure") # remove possible autodated configure scripts
set(arg_AUTOCONFIG ON)
endif()
elseif(EXISTS "${src_dir}/configure" AND NOT arg_SKIP_CONFIGURE) # run normally; no autoconf or autogen required
elseif(EXISTS "${src_dir}/configure.ac") # Run autoconfig
set(requires_autoconfig ON)
set(arg_AUTOCONFIG ON)
elseif(EXISTS "${src_dir}/autogen.sh") # Run autogen
set(requires_autogen ON)
else()
message(FATAL_ERROR "Could not determine method to configure make")
endif()
debug_message("requires_autogen:${requires_autogen}")
debug_message("requires_autoconfig:${requires_autoconfig}")
if(CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe") #only applies to windows (clang-)cl and lib
if(arg_AUTOCONFIG)
set(arg_USE_WRAPPERS ON)
else()
# Keep the setting from portfiles.
# Without autotools we assume a custom configure script which correctly handles cl and lib.
# Otherwise the port needs to set CC|CXX|AR and probably CPP.
endif()
else()
set(arg_USE_WRAPPERS OFF)
endif()
# Backup environment variables
# CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJCXX R UPC Y
set(cm_FLAGS AS CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJXX R UPC Y RC)
list(TRANSFORM cm_FLAGS APPEND "FLAGS")
vcpkg_backup_env_variables(VARS ${cm_FLAGS})
# FC fotran compiler | FF Fortran 77 compiler
# LDFLAGS -> pass -L flags
# LIBS -> pass -l flags
#Used by gcc/linux
vcpkg_backup_env_variables(VARS C_INCLUDE_PATH CPLUS_INCLUDE_PATH LIBRARY_PATH LD_LIBRARY_PATH)
#Used by cl
vcpkg_backup_env_variables(VARS INCLUDE LIB LIBPATH)
set(vcm_paths_with_spaces OFF)
if(CURRENT_PACKAGES_DIR MATCHES " " OR CURRENT_INSTALLED_DIR MATCHES " ")
# Don't bother with whitespace. The tools will probably fail and I tried very hard trying to make it work (no success so far)!
message(WARNING "Detected whitespace in root directory. Please move the path to one without whitespaces! The required tools do not handle whitespaces correctly and the build will most likely fail")
set(vcm_paths_with_spaces ON)
endif()
set(configure_env "V=1")
# Pre-processing windows configure requirements
if (VCPKG_TARGET_IS_WINDOWS)
if(CMAKE_HOST_WIN32)
list(APPEND msys_require_packages binutils libtool autoconf automake-wrapper automake1.16 m4)
vcpkg_acquire_msys(MSYS_ROOT PACKAGES ${msys_require_packages} ${arg_ADDITIONAL_MSYS_PACKAGES})
endif()
if (arg_DETERMINE_BUILD_TRIPLET OR NOT arg_BUILD_TRIPLET)
z_vcpkg_determine_autotools_host_cpu(BUILD_ARCH) # VCPKG_HOST => machine you are building on => --build=
z_vcpkg_determine_autotools_target_cpu(TARGET_ARCH)
# --build: the machine you are building on
# --host: the machine you are building for
# --target: the machine that CC will produce binaries for
# https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
# Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
if(CMAKE_HOST_WIN32)
set(arg_BUILD_TRIPLET "--build=${BUILD_ARCH}-pc-mingw32") # This is required since we are running in a msys
# shell which will be otherwise identified as ${BUILD_ARCH}-pc-msys
endif()
if(NOT TARGET_ARCH MATCHES "${BUILD_ARCH}" OR NOT CMAKE_HOST_WIN32) # we don't need to specify the additional flags if we build nativly, this does not hold when we are not on windows
string(APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-pc-mingw32") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
endif()
if(VCPKG_TARGET_IS_UWP AND NOT arg_BUILD_TRIPLET MATCHES "--host")
# Needs to be different from --build to enable cross builds.
string(APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-unknown-mingw32")
endif()
debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
endif()
if(CMAKE_HOST_WIN32)
set(append_env)
if(arg_USE_WRAPPERS)
set(append_env ";${MSYS_ROOT}/usr/share/automake-1.16")
string(APPEND append_env ";${SCRIPTS}/buildsystems/make_wrapper") # Other required wrappers are also located there
endif()
# This inserts msys before system32 (which masks sort.exe and find.exe) but after MSVC (which avoids masking link.exe)
string(REPLACE ";$ENV{SystemRoot}\\System32;" "${append_env};${MSYS_ROOT}/usr/bin;$ENV{SystemRoot}\\System32;" NEWPATH "$ENV{PATH}")
string(REPLACE ";$ENV{SystemRoot}\\system32;" "${append_env};${MSYS_ROOT}/usr/bin;$ENV{SystemRoot}\\system32;" NEWPATH "$ENV{PATH}")
set(ENV{PATH} "${NEWPATH}")
set(bash_executable "${MSYS_ROOT}/usr/bin/bash.exe")
endif()
# Remove full filepaths due to spaces and prepend filepaths to PATH (cross-compiling tools are unlikely on path by default)
set(progs VCPKG_DETECTED_CMAKE_C_COMPILER VCPKG_DETECTED_CMAKE_CXX_COMPILER VCPKG_DETECTED_CMAKE_AR
VCPKG_DETECTED_CMAKE_LINKER VCPKG_DETECTED_CMAKE_RANLIB VCPKG_DETECTED_CMAKE_OBJDUMP
VCPKG_DETECTED_CMAKE_STRIP VCPKG_DETECTED_CMAKE_NM VCPKG_DETECTED_CMAKE_DLLTOOL VCPKG_DETECTED_CMAKE_RC_COMPILER)
foreach(prog IN LISTS progs)
if(${prog})
set(path "${${prog}}")
unset(prog_found CACHE)
get_filename_component(${prog} "${${prog}}" NAME)
find_program(prog_found ${${prog}} PATHS ENV PATH NO_DEFAULT_PATH)
if(NOT path STREQUAL prog_found)
get_filename_component(path "${path}" DIRECTORY)
vcpkg_add_to_path(PREPEND ${path})
endif()
endif()
endforeach()
if (arg_USE_WRAPPERS)
z_vcpkg_append_to_configure_environment(configure_env CPP "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
z_vcpkg_append_to_configure_environment(configure_env CC "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env CXX "compile ${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env RC "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env WINDRES "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
if(VCPKG_DETECTED_CMAKE_AR)
z_vcpkg_append_to_configure_environment(configure_env AR "ar-lib ${VCPKG_DETECTED_CMAKE_AR}")
else()
z_vcpkg_append_to_configure_environment(configure_env AR "ar-lib lib.exe -verbose")
endif()
else()
z_vcpkg_append_to_configure_environment(configure_env CPP "${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
z_vcpkg_append_to_configure_environment(configure_env CC "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env CXX "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env RC "${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
z_vcpkg_append_to_configure_environment(configure_env WINDRES "${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
if(VCPKG_DETECTED_CMAKE_AR)
z_vcpkg_append_to_configure_environment(configure_env AR "${VCPKG_DETECTED_CMAKE_AR}")
else()
z_vcpkg_append_to_configure_environment(configure_env AR "lib.exe -verbose")
endif()
endif()
z_vcpkg_append_to_configure_environment(configure_env LD "${VCPKG_DETECTED_CMAKE_LINKER} -verbose")
if(VCPKG_DETECTED_CMAKE_RANLIB)
z_vcpkg_append_to_configure_environment(configure_env RANLIB "${VCPKG_DETECTED_CMAKE_RANLIB}") # Trick to ignore the RANLIB call
else()
z_vcpkg_append_to_configure_environment(configure_env RANLIB ":")
endif()
if(VCPKG_DETECTED_CMAKE_OBJDUMP) #Objdump is required to make shared libraries. Otherwise define lt_cv_deplibs_check_method=pass_all
z_vcpkg_append_to_configure_environment(configure_env OBJDUMP "${VCPKG_DETECTED_CMAKE_OBJDUMP}") # Trick to ignore the RANLIB call
endif()
if(VCPKG_DETECTED_CMAKE_STRIP) # If required set the ENV variable STRIP in the portfile correctly
z_vcpkg_append_to_configure_environment(configure_env STRIP "${VCPKG_DETECTED_CMAKE_STRIP}")
else()
z_vcpkg_append_to_configure_environment(configure_env STRIP ":")
list(APPEND arg_OPTIONS ac_cv_prog_ac_ct_STRIP=:)
endif()
if(VCPKG_DETECTED_CMAKE_NM) # If required set the ENV variable NM in the portfile correctly
z_vcpkg_append_to_configure_environment(configure_env NM "${VCPKG_DETECTED_CMAKE_NM}")
else()
# Would be better to have a true nm here! Some symbols (mainly exported variables) get not properly imported with dumpbin as nm
# and require __declspec(dllimport) for some reason (same problem CMake has with WINDOWS_EXPORT_ALL_SYMBOLS)
z_vcpkg_append_to_configure_environment(configure_env NM "dumpbin.exe -symbols -headers")
endif()
if(VCPKG_DETECTED_CMAKE_DLLTOOL) # If required set the ENV variable DLLTOOL in the portfile correctly
z_vcpkg_append_to_configure_environment(configure_env DLLTOOL "${VCPKG_DETECTED_CMAKE_DLLTOOL}")
else()
z_vcpkg_append_to_configure_environment(configure_env DLLTOOL "link.exe -verbose -dll")
endif()
z_vcpkg_append_to_configure_environment(configure_env CCAS ":") # If required set the ENV variable CCAS in the portfile correctly
z_vcpkg_append_to_configure_environment(configure_env AS ":") # If required set the ENV variable AS in the portfile correctly
foreach(_env IN LISTS arg_CONFIGURE_ENVIRONMENT_VARIABLES)
z_vcpkg_append_to_configure_environment(configure_env ${_env} "${${_env}}")
endforeach()
debug_message("configure_env: '${configure_env}'")
# Other maybe interesting variables to control
# COMPILE This is the command used to actually compile a C source file. The file name is appended to form the complete command line.
# LINK This is the command used to actually link a C program.
# CXXCOMPILE The command used to actually compile a C++ source file. The file name is appended to form the complete command line.
# CXXLINK The command used to actually link a C++ program.
# Variables not correctly detected by configure. In release builds.
list(APPEND arg_OPTIONS gl_cv_double_slash_root=yes
ac_cv_func_memmove=yes)
#list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all) # Just ignore libtool checks
if(VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]64$")
list(APPEND arg_OPTIONS gl_cv_host_cpu_c_abi=no)
# Currently needed for arm64 because objdump yields: "unrecognised machine type (0xaa64) in Import Library Format archive"
list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]$")
# Currently needed for arm because objdump yields: "unrecognised machine type (0x1c4) in Import Library Format archive"
list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all)
endif()
endif()
# Some PATH handling for dealing with spaces....some tools will still fail with that!
# In particular, the libtool install command is unable to install correctly to paths with spaces.
# CURRENT_INSTALLED_DIR: Pristine native path (unprotected spaces, Windows drive letters)
# z_vcpkg_installed_path: Native path with escaped space characters
# z_vcpkg_prefix_path: Path with unprotected spaces, but drive letters transformed for mingw/msys
string(REPLACE " " "\\ " z_vcpkg_installed_path "${CURRENT_INSTALLED_DIR}")
if(CMAKE_HOST_WIN32)
string(REGEX REPLACE "([a-zA-Z]):/" "/\\1/" z_vcpkg_prefix_path "${CURRENT_INSTALLED_DIR}")
else()
set(z_vcpkg_prefix_path "${CURRENT_INSTALLED_DIR}")
endif()
# macOS - cross-compiling support
if(VCPKG_TARGET_IS_OSX)
if (requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET)
z_vcpkg_determine_autotools_host_arch_mac(BUILD_ARCH) # machine you are building on => --build=
z_vcpkg_determine_autotools_target_arch_mac(TARGET_ARCH)
# --build: the machine you are building on
# --host: the machine you are building for
# --target: the machine that CC will produce binaries for
# https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
# Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
if(NOT "${TARGET_ARCH}" STREQUAL "${BUILD_ARCH}") # we don't need to specify the additional flags if we build natively.
set(arg_BUILD_TRIPLET "--host=${TARGET_ARCH}-apple-darwin") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
endif()
debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
endif()
endif()
# Linux - cross-compiling support
if(VCPKG_TARGET_IS_LINUX)
if (requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET)
# The regex below takes the prefix from the resulting CMAKE_C_COMPILER variable eg. arm-linux-gnueabihf-gcc
# set in the common toolchains/linux.cmake
# This is used via --host as a prefix for all other bin tools as well.
# Setting the compiler directly via CC=arm-linux-gnueabihf-gcc does not work acording to:
# https://www.gnu.org/software/autoconf/manual/autoconf-2.65/html_node/Specifying-Target-Triplets.html
if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "([^\/]*)-gcc$" AND CMAKE_MATCH_1)
set(arg_BUILD_TRIPLET "--host=${CMAKE_MATCH_1}") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
endif()
debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
endif()
endif()
# Cleanup previous build dirs
file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}")
# Set configure paths
set(arg_OPTIONS_RELEASE ${arg_OPTIONS_RELEASE} "--prefix=${z_vcpkg_prefix_path}")
set(arg_OPTIONS_DEBUG ${arg_OPTIONS_DEBUG} "--prefix=${z_vcpkg_prefix_path}/debug")
if(NOT arg_NO_ADDITIONAL_PATHS)
# ${prefix} has an extra backslash to prevent early expansion when calling `bash -c configure "..."`.
set(arg_OPTIONS_RELEASE ${arg_OPTIONS_RELEASE}
# Important: These should all be relative to prefix!
"--bindir=\\\${prefix}/tools/${PORT}/bin"
"--sbindir=\\\${prefix}/tools/${PORT}/sbin"
"--libdir=\\\${prefix}/lib" # On some Linux distributions lib64 is the default
#"--includedir='\${prefix}'/include" # already the default!
"--mandir=\\\${prefix}/share/${PORT}"
"--docdir=\\\${prefix}/share/${PORT}"
"--datarootdir=\\\${prefix}/share/${PORT}")
set(arg_OPTIONS_DEBUG ${arg_OPTIONS_DEBUG}
# Important: These should all be relative to prefix!
"--bindir=\\\${prefix}/../tools/${PORT}/debug/bin"
"--sbindir=\\\${prefix}/../tools/${PORT}/debug/sbin"
"--libdir=\\\${prefix}/lib" # On some Linux distributions lib64 is the default
"--includedir=\\\${prefix}/../include"
"--datarootdir=\\\${prefix}/share/${PORT}")
endif()
# Setup common options
if(NOT arg_DISABLE_VERBOSE_FLAGS)
list(APPEND arg_OPTIONS --disable-silent-rules --verbose)
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic)
list(APPEND arg_OPTIONS --enable-shared --disable-static)
else()
list(APPEND arg_OPTIONS --disable-shared --enable-static)
endif()
# Can be set in the triplet to append options for configure
if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS)
list(APPEND arg_OPTIONS ${VCPKG_CONFIGURE_MAKE_OPTIONS})
endif()
if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE)
list(APPEND arg_OPTIONS_RELEASE ${VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE})
endif()
if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG)
list(APPEND arg_OPTIONS_DEBUG ${VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG})
endif()
file(RELATIVE_PATH relative_build_path "${CURRENT_BUILDTREES_DIR}" "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}")
set(base_cmd)
if(CMAKE_HOST_WIN32)
set(base_cmd ${bash_executable} --noprofile --norc --debug)
else()
find_program(base_cmd bash REQUIRED)
endif()
# Used by CL
vcpkg_host_path_list(PREPEND ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
# Used by GCC
vcpkg_host_path_list(PREPEND ENV{C_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include")
vcpkg_host_path_list(PREPEND ENV{CPLUS_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include")
# Flags should be set in the toolchain instead (Setting this up correctly requires a function named vcpkg_determined_cmake_compiler_flags which can also be used to setup CC and CXX etc.)
if(VCPKG_TARGET_IS_WINDOWS)
vcpkg_backup_env_variables(VARS _CL_ _LINK_)
# TODO: Should be CPP flags instead -> rewrite when vcpkg_determined_cmake_compiler_flags defined
if(VCPKG_TARGET_IS_UWP)
# Be aware that configure thinks it is crosscompiling due to:
# error while loading shared libraries: VCRUNTIME140D_APP.dll:
# cannot open shared object file: No such file or directory
# IMPORTANT: The only way to pass linker flags through libtool AND the compile wrapper
# is to use the CL and LINK environment variables !!!
# (This is due to libtool and compiler wrapper using the same set of options to pass those variables around)
file(TO_CMAKE_PATH "$ENV{VCToolsInstallDir}" VCToolsInstallDir)
set(_replacement -FU\"${VCToolsInstallDir}/lib/x86/store/references/platform.winmd\")
string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG}")
string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG}")
string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE}")
string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE}")
# Can somebody please check if CMake's compiler flags for UWP are correct?
set(ENV{_CL_} "$ENV{_CL_} -FU\"${VCToolsInstallDir}/lib/x86/store/references/platform.winmd\"")
set(ENV{_LINK_} "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
endif()
endif()
z_convert_to_list(VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES c_libs_list)
z_convert_to_list(VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES cxx_libs_list)
set(all_libs_list ${c_libs_list} ${cxx_libs_list})
list(REMOVE_DUPLICATES all_libs_list)
list(TRANSFORM all_libs_list STRIP)
#Do lib list transformation from name.lib to -lname if necessary
set(x_vcpkg_transform_libs ON)
if(VCPKG_TARGET_IS_UWP)
set(x_vcpkg_transform_libs OFF)
# Avoid libtool choke: "Warning: linker path does not have real file for library -lWindowsApp."
# The problem with the choke is that libtool always falls back to built a static library even if a dynamic was requested.
# Note: Env LIBPATH;LIB are on the search path for libtool by default on windows.
# It even does unix/dos-short/unix transformation with the path to get rid of spaces.
endif()
set(l_prefix)
if(x_vcpkg_transform_libs)
set(l_prefix "-l")
list(TRANSFORM all_libs_list REPLACE "(.dll.lib|.lib|.a|.so)$" "")
if(VCPKG_TARGET_IS_WINDOWS)
list(REMOVE_ITEM all_libs_list "uuid")
endif()
list(TRANSFORM all_libs_list REPLACE "^(${l_prefix})" "")
endif()
list(JOIN all_libs_list " ${l_prefix}" all_libs_string)
if(VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
# libtool must be told explicitly that there is no dynamic linkage for uuid.
# The "-Wl,..." syntax is understood by libtool and gcc, but no by ld.
string(REPLACE " -luuid" " -Wl,-Bstatic,-luuid,-Bdynamic" all_libs_string "${all_libs_string}")
endif()
if(all_libs_string)
set(all_libs_string "${l_prefix}${all_libs_string}")
if(DEFINED ENV{LIBS})
set(ENV{LIBS} "$ENV{LIBS} ${all_libs_string}")
else()
set(ENV{LIBS} "${all_libs_string}")
endif()
endif()
debug_message("ENV{LIBS}:$ENV{LIBS}")
# Run autoconf if necessary
if (arg_AUTOCONFIG OR requires_autoconfig)
find_program(AUTORECONF autoreconf)
if(NOT AUTORECONF)
message(FATAL_ERROR "${PORT} requires autoconf from the system package manager (example: \"sudo apt-get install autoconf\")")
endif()
message(STATUS "Generating configure for ${TARGET_TRIPLET}")
if (CMAKE_HOST_WIN32)
vcpkg_execute_required_process(
COMMAND ${base_cmd} -c "autoreconf -vfi"
WORKING_DIRECTORY "${src_dir}"
LOGNAME "autoconf-${TARGET_TRIPLET}"
)
else()
vcpkg_execute_required_process(
COMMAND "${AUTORECONF}" -vfi
WORKING_DIRECTORY "${src_dir}"
LOGNAME "autoconf-${TARGET_TRIPLET}"
)
endif()
message(STATUS "Finished generating configure for ${TARGET_TRIPLET}")
endif()
if(requires_autogen)
message(STATUS "Generating configure for ${TARGET_TRIPLET} via autogen.sh")
if (CMAKE_HOST_WIN32)
vcpkg_execute_required_process(
COMMAND ${base_cmd} -c "./autogen.sh"
WORKING_DIRECTORY "${src_dir}"
LOGNAME "autoconf-${TARGET_TRIPLET}"
)
else()
vcpkg_execute_required_process(
COMMAND "./autogen.sh"
WORKING_DIRECTORY "${src_dir}"
LOGNAME "autoconf-${TARGET_TRIPLET}"
)
endif()
message(STATUS "Finished generating configure for ${TARGET_TRIPLET}")
endif()
if (arg_PRERUN_SHELL)
message(STATUS "Prerun shell with ${TARGET_TRIPLET}")
if (CMAKE_HOST_WIN32)
vcpkg_execute_required_process(
COMMAND ${base_cmd} -c "${arg_PRERUN_SHELL}"
WORKING_DIRECTORY "${src_dir}"
LOGNAME "prerun-${TARGET_TRIPLET}"
)
else()
vcpkg_execute_required_process(
COMMAND "${base_cmd}" -c "${arg_PRERUN_SHELL}"
WORKING_DIRECTORY "${src_dir}"
LOGNAME "prerun-${TARGET_TRIPLET}"
)
endif()
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug" AND NOT arg_NO_DEBUG)
set(var_suffix DEBUG)
set(path_suffix_${var_suffix} "/debug")
set(short_name_${var_suffix} "dbg")
list(APPEND all_buildtypes ${var_suffix})
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
set(LINKER_FLAGS_${var_suffix} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}")
else() # dynamic
set(LINKER_FLAGS_${var_suffix} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}")
endif()
z_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${var_suffix})
if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
if(NOT vcm_paths_with_spaces)
set(LDFLAGS_${var_suffix} "-L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib -L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib/manual-link")
endif()
if(DEFINED ENV{_LINK_})
set(LINK_ENV_${var_suffix} "$ENV{_LINK_} ${LINKER_FLAGS_${var_suffix}}")
else()
set(LINK_ENV_${var_suffix} "${LINKER_FLAGS_${var_suffix}}")
endif()
else()
set(link_required_dirs)
if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib")
set(link_required_dirs "-L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib")
endif()
if(EXISTS "{CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib/manual-link")
set(link_required_dirs "${link_required_dirs} -L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib/manual-link")
endif()
string(STRIP "${link_required_dirs}" link_required_dirs)
set(LDFLAGS_${var_suffix} "${link_required_dirs} ${LINKER_FLAGS_${var_suffix}}")
endif()
unset(var_suffix)
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
set(var_suffix RELEASE)
set(path_suffix_${var_suffix} "")
set(short_name_${var_suffix} "rel")
list(APPEND all_buildtypes ${var_suffix})
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
set(LINKER_FLAGS_${var_suffix} "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}")
else() # dynamic
set(LINKER_FLAGS_${var_suffix} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}")
endif()
z_vcpkg_extract_cpp_flags_and_set_cflags_and_cxxflags(${var_suffix})
if (CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
if(NOT vcm_paths_with_spaces)
set(LDFLAGS_${var_suffix} "-L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib -L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib/manual-link")
endif()
if(DEFINED ENV{_LINK_})
set(LINK_ENV_${var_suffix} "$ENV{_LINK_} ${LINKER_FLAGS_${var_suffix}}")
else()
set(LINK_ENV_${var_suffix} "${LINKER_FLAGS_${var_suffix}}")
endif()
else()
set(link_required_dirs "")
if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib")
set(link_required_dirs "-L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib")
endif()
if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib/manual-link")
set(link_required_dirs "${link_required_dirs} -L${z_vcpkg_installed_path}${path_suffix_${var_suffix}}/lib/manual-link")
endif()
string(STRIP "${link_required_dirs}" link_required_dirs)
set(LDFLAGS_${var_suffix} "${link_required_dirs} ${LINKER_FLAGS_${var_suffix}}")
endif()
unset(var_suffix)
endif()
foreach(var IN ITEMS arg_OPTIONS arg_OPTIONS_RELEASE arg_OPTIONS_DEBUG)
vcpkg_list(SET tmp)
foreach(element IN LISTS "${var}")
string(REPLACE [["]] [[\"]] element "${element}")
vcpkg_list(APPEND tmp "\"${element}\"")
endforeach()
vcpkg_list(JOIN tmp " " "${var}")
endforeach()
foreach(current_buildtype IN LISTS all_buildtypes)
foreach(ENV_VAR ${arg_CONFIG_DEPENDENT_ENVIRONMENT})
if(DEFINED ENV{${ENV_VAR}})
set(backup_config_${ENV_VAR} "$ENV{${ENV_VAR}}")
endif()
set(ENV{${ENV_VAR}} "${${ENV_VAR}_${current_buildtype}}")
endforeach()
set(target_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_${current_buildtype}}")
file(MAKE_DIRECTORY "${target_dir}")
file(RELATIVE_PATH relative_build_path "${target_dir}" "${src_dir}")
if(arg_COPY_SOURCE)
file(COPY "${src_dir}/" DESTINATION "${target_dir}")
set(relative_build_path .)
endif()
# Setup PKG_CONFIG_PATH
if ("${current_buildtype}" STREQUAL "DEBUG")
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}/debug")
else()
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}")
endif()
# Setup environment
set(ENV{CPPFLAGS} "${CPPFLAGS_${current_buildtype}}")
set(ENV{CFLAGS} "${CFLAGS_${current_buildtype}}")
set(ENV{CXXFLAGS} "${CXXFLAGS_${current_buildtype}}")
set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${current_buildtype}}")
set(ENV{LDFLAGS} "${LDFLAGS_${current_buildtype}}")
# https://www.gnu.org/software/libtool/manual/html_node/Link-mode.html
# -avoid-version is handled specially by libtool link mode, this flag is not forwarded to linker,
# and libtool tries to avoid versioning for shared libraries and no symbolic links are created.
if(VCPKG_TARGET_IS_ANDROID)
set(ENV{LDFLAGS} "-avoid-version $ENV{LDFLAGS}")
endif()
if(LINK_ENV_${current_buildtype})
set(link_config_backup "$ENV{_LINK_}")
set(ENV{_LINK_} "${LINK_ENV_${current_buildtype}}")
endif()
vcpkg_list(APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH) # LD_LIBRARY_PATH)
foreach(lib_env_var IN LISTS lib_env_vars)
if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib")
vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib")
endif()
if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link")
vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link")
endif()
endforeach()
unset(lib_env_vars)
set(command "${base_cmd}" -c "${configure_env} ./${relative_build_path}/configure ${arg_BUILD_TRIPLET} ${arg_OPTIONS} ${arg_OPTIONS_${current_buildtype}}")
if(arg_ADD_BIN_TO_PATH)
set(path_backup $ENV{PATH})
vcpkg_add_to_path("${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/bin")
endif()
debug_message("Configure command:'${command}'")
if (NOT arg_SKIP_CONFIGURE)
message(STATUS "Configuring ${TARGET_TRIPLET}-${short_name_${current_buildtype}}")
vcpkg_execute_required_process(
COMMAND ${command}
WORKING_DIRECTORY "${target_dir}"
LOGNAME "config-${TARGET_TRIPLET}-${short_name_${current_buildtype}}"
)
if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL dynamic)
file(GLOB_RECURSE libtool_files "${target_dir}*/libtool")
foreach(lt_file IN LISTS libtool_files)
file(READ "${lt_file}" _contents)
string(REPLACE ".dll.lib" ".lib" _contents "${_contents}")
file(WRITE "${lt_file}" "${_contents}")
endforeach()
endif()
if(EXISTS "${target_dir}/config.log")
file(RENAME "${target_dir}/config.log" "${CURRENT_BUILDTREES_DIR}/config.log-${TARGET_TRIPLET}-${short_name_${current_buildtype}}.log")
endif()
endif()
z_vcpkg_restore_pkgconfig_path()
if(link_config_backup)
set(ENV{_LINK_} "${link_config_backup}")
unset(link_config_backup)
endif()
if(arg_ADD_BIN_TO_PATH)
set(ENV{PATH} "${path_backup}")
endif()
# Restore environment (config dependent)
foreach(ENV_VAR IN LISTS ${arg_CONFIG_DEPENDENT_ENVIRONMENT})
if(backup_config_${ENV_VAR})
set(ENV{${ENV_VAR}} "${backup_config_${ENV_VAR}}")
else()
unset(ENV{${ENV_VAR}})
endif()
endforeach()
endforeach()
# Export matching make program for vcpkg_build_make (cache variable)
if(CMAKE_HOST_WIN32 AND MSYS_ROOT)
find_program(Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED)
elseif(VCPKG_HOST_IS_OPENBSD)
find_program(Z_VCPKG_MAKE gmake REQUIRED)
else()
find_program(Z_VCPKG_MAKE make REQUIRED)
endif()
# Restore environment
vcpkg_restore_env_variables(VARS ${cm_FLAGS} LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH)
set(_VCPKG_PROJECT_SOURCE_PATH ${arg_SOURCE_PATH} PARENT_SCOPE)
set(_VCPKG_PROJECT_SUBPATH ${arg_PROJECT_SUBPATH} PARENT_SCOPE)
set(_VCPKG_MAKE_NO_DEBUG ${arg_NO_DEBUG} PARENT_SCOPE)
endfunction()

455
externals/vcpkg/scripts/cmake/vcpkg_configure_meson.cmake vendored Executable file
View File

@@ -0,0 +1,455 @@
function(z_vcpkg_append_proglist var_to_append additional_binaries)
string(APPEND "${var_to_append}" "[binaries]\n")
if(VCPKG_TARGET_IS_WINDOWS)
set(proglist MT AR)
else()
set(proglist AR RANLIB STRIP NM OBJDUMP DLLTOOL MT)
endif()
foreach(prog IN LISTS proglist)
if(VCPKG_DETECTED_CMAKE_${prog})
if(meson_${prog})
string(APPEND "${var_to_append}" "${meson_${prog}} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
else()
string(TOLOWER "${prog}" proglower)
string(APPEND "${var_to_append}" "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}}'\n")
endif()
endif()
endforeach()
set(programs C CXX RC)
set(meson_RC windres)
set(meson_CXX cpp)
foreach(prog IN LISTS programs)
if(VCPKG_DETECTED_CMAKE_${prog}_COMPILER)
if(meson_${prog})
string(APPEND "${var_to_append}" "${meson_${prog}} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
else()
string(TOLOWER "${prog}" proglower)
string(APPEND "${var_to_append}" "${proglower} = '${VCPKG_DETECTED_CMAKE_${prog}_COMPILER}'\n")
endif()
endif()
endforeach()
if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
# for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
if (NOT VCPKG_DETECTED_CMAKE_C_COMPILER_ID MATCHES "^(GNU|Intel)$")
string(APPEND "${var_to_append}" "c_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
endif()
endif()
if(VCPKG_DETECTED_CMAKE_LINKER AND VCPKG_TARGET_IS_WINDOWS)
# for gcc and icc the linker flag -fuse-ld is used. See https://github.com/mesonbuild/meson/issues/8647#issuecomment-878673456
if (NOT VCPKG_DETECTED_CMAKE_CXX_COMPILER_ID MATCHES "^(GNU|Intel)$")
string(APPEND "${var_to_append}" "cpp_ld = '${VCPKG_DETECTED_CMAKE_LINKER}'\n")
endif()
endif()
get_filename_component(CMAKE_PATH "${CMAKE_COMMAND}" DIRECTORY)
vcpkg_add_to_path("${CMAKE_PATH}" PREPEND) # Make CMake invokeable for Meson
string(APPEND "${var_to_append}" "cmake = '${CMAKE_COMMAND}'\n")
vcpkg_find_acquire_program(PYTHON3)
get_filename_component(PYTHON3_DIR "${PYTHON3}" DIRECTORY)
vcpkg_add_to_path("${PYTHON3_DIR}")
string(APPEND "${var_to_append}" "python = '${PYTHON3}'\n")
vcpkg_find_acquire_program(NINJA)
get_filename_component(NINJA_PATH ${NINJA} DIRECTORY)
vcpkg_add_to_path(PREPEND "${NINJA_PATH}") # Prepend to use the correct ninja.
# string(APPEND "${var_to_append}" "ninja = '${NINJA}'\n") # This does not work due to meson issues
foreach(additional_binary IN LISTS additional_binaries)
string(APPEND "${var_to_append}" "${additional_binary}\n")
endforeach()
set("${var_to_append}" "${${var_to_append}}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_meson_generate_native_file additional_binaries) #https://mesonbuild.com/Native-environments.html
set(native_config "")
z_vcpkg_append_proglist(native_config "${additional_binaries}")
string(APPEND native_config "[built-in options]\n") #https://mesonbuild.com/Builtin-options.html
if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe")
# This is currently wrongly documented in the meson docs or buggy. The docs say: 'none' = no flags
# In reality however 'none' tries to deactivate eh and meson passes the flags for it resulting in a lot of warnings
# about overriden flags. Until this is fixed in meson vcpkg should not pass this here.
# string(APPEND native_config "cpp_eh='none'\n") # To make sure meson is not adding eh flags by itself using msvc
endif()
if(VCPKG_TARGET_IS_WINDOWS)
set(c_winlibs "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
set(cpp_winlibs "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
foreach(libvar IN ITEMS c_winlibs cpp_winlibs)
string(REGEX REPLACE "( |^)(-|/)" [[;\2]] "${libvar}" "${${libvar}}")
string(REPLACE ".lib " ".lib;" "${libvar}" "${${libvar}}")
vcpkg_list(REMOVE_ITEM "${libvar}" "")
vcpkg_list(JOIN "${libvar}" "', '" "${libvar}")
string(APPEND native_config "${libvar} = ['${${libvar}}']\n")
endforeach()
endif()
set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-native-${TARGET_TRIPLET}.log")
set(vcpkg_meson_native_file "${native_config_name}" PARENT_SCOPE)
file(WRITE "${native_config_name}" "${native_config}")
endfunction()
function(z_vcpkg_meson_convert_compiler_flags_to_list out_var compiler_flags)
string(REPLACE ";" [[\;]] tmp_var "${compiler_flags}")
string(REGEX REPLACE [=[( +|^)((\"(\\"|[^"])+"|\\"|\\ |[^ ])+)]=] ";\\2" tmp_var "${tmp_var}")
vcpkg_list(POP_FRONT tmp_var) # The first element is always empty due to the above replacement
list(TRANSFORM tmp_var STRIP) # Strip leading trailing whitespaces from each element in the list.
set("${out_var}" "${tmp_var}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_meson_convert_list_to_python_array out_var)
z_vcpkg_function_arguments(flag_list 1)
vcpkg_list(REMOVE_ITEM flag_list "") # remove empty elements if any
vcpkg_list(JOIN flag_list "', '" flag_list)
set("${out_var}" "['${flag_list}']" PARENT_SCOPE)
endfunction()
# Generates the required compiler properties for meson
function(z_vcpkg_meson_generate_flags_properties_string out_var config_type)
set(result "")
if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
set(libpath_flag /LIBPATH:)
else()
set(libpath_flag -L)
endif()
if(config_type STREQUAL "DEBUG")
set(path_suffix "/debug")
else()
set(path_suffix "")
endif()
set(libpath "${libpath_flag}${CURRENT_INSTALLED_DIR}${path_suffix}/lib")
z_vcpkg_meson_convert_compiler_flags_to_list(cflags "${VCPKG_DETECTED_CMAKE_C_FLAGS_${config_type}}")
vcpkg_list(APPEND cflags "-I${CURRENT_INSTALLED_DIR}/include")
z_vcpkg_meson_convert_list_to_python_array(cflags ${cflags})
string(APPEND result "c_args = ${cflags}\n")
z_vcpkg_meson_convert_compiler_flags_to_list(cxxflags "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${config_type}}")
vcpkg_list(APPEND cxxflags "-I${CURRENT_INSTALLED_DIR}/include")
z_vcpkg_meson_convert_list_to_python_array(cxxflags ${cxxflags})
string(APPEND result "cpp_args = ${cxxflags}\n")
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
set(linker_flags "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${config_type}}")
else()
set(linker_flags "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${config_type}}")
endif()
z_vcpkg_meson_convert_compiler_flags_to_list(linker_flags "${linker_flags}")
if(VCPKG_TARGET_IS_OSX)
# macOS - append arch and isysroot if cross-compiling
if(NOT "${VCPKG_OSX_ARCHITECTURES}" STREQUAL "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
foreach(arch IN LISTS VCPKG_OSX_ARCHITECTURES)
vcpkg_list(APPEND linker_flags -arch "${arch}")
endforeach()
endif()
if(VCPKG_DETECTED_CMAKE_OSX_SYSROOT)
vcpkg_list(APPEND linker_flags -isysroot "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
endif()
endif()
vcpkg_list(APPEND linker_flags "${libpath}")
z_vcpkg_meson_convert_list_to_python_array(linker_flags ${linker_flags})
string(APPEND result "c_link_args = ${linker_flags}\n")
string(APPEND result "cpp_link_args = ${linker_flags}\n")
set("${out_var}" "${result}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_meson_generate_native_file_config config_type) #https://mesonbuild.com/Native-environments.html
set(native_file "[properties]\n") #https://mesonbuild.com/Builtin-options.html
#Setup CMake properties
string(APPEND native_file "cmake_toolchain_file = '${SCRIPTS}/buildsystems/vcpkg.cmake'\n")
string(APPEND native_file "[cmake]\n")
if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
z_vcpkg_select_default_vcpkg_chainload_toolchain()
endif()
string(APPEND native_file "VCPKG_TARGET_TRIPLET = '${TARGET_TRIPLET}'\n")
string(APPEND native_file "VCPKG_CHAINLOAD_TOOLCHAIN_FILE = '${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}'\n")
string(APPEND native_file "VCPKG_CRT_LINKAGE = '${VCPKG_CRT_LINKAGE}'\n")
string(APPEND native_file "[built-in options]\n")
z_vcpkg_meson_generate_flags_properties_string(native_properties "${config_type}")
string(APPEND native_file "${native_properties}")
if(VCPKG_TARGET_IS_WINDOWS)
if(VCPKG_CRT_LINKAGE STREQUAL "static")
set(crt_type mt)
else()
set(crt_type md)
endif()
if("${config_type}" STREQUAL "DEBUG")
string(APPEND crt_type "d")
endif()
string(APPEND native_file "b_vscrt = '${crt_type}'\n")
endif()
string(TOLOWER "${config_type}" lowerconfig)
set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-native-${TARGET_TRIPLET}-${lowerconfig}.log")
file(WRITE "${native_config_name}" "${native_file}")
set("vcpkg_meson_native_file_${config_type}" "${native_config_name}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_meson_generate_cross_file additional_binaries) #https://mesonbuild.com/Cross-compilation.html
if(CMAKE_HOST_WIN32)
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(build_arch $ENV{PROCESSOR_ARCHITEW6432})
else()
set(build_arch $ENV{PROCESSOR_ARCHITECTURE})
endif()
if(build_arch MATCHES "(amd|AMD)64")
set(build_cpu_fam x86_64)
set(build_cpu x86_64)
elseif(build_arch MATCHES "(x|X)86")
set(build_cpu_fam x86)
set(build_cpu i686)
elseif(build_arch MATCHES "^(ARM|arm)64$")
set(build_cpu_fam aarch64)
set(build_cpu armv8)
elseif(build_arch MATCHES "^(ARM|arm)$")
set(build_cpu_fam arm)
set(build_cpu armv7hl)
else()
message(FATAL_ERROR "Unsupported host architecture ${build_arch}!")
endif()
elseif(CMAKE_HOST_UNIX)
# at this stage, CMAKE_HOST_SYSTEM_PROCESSOR is not defined
execute_process(
COMMAND uname -m
OUTPUT_VARIABLE MACHINE
COMMAND_ERROR_IS_FATAL ANY)
# Show real machine architecture to visually understand whether we are in a native Apple Silicon terminal or running under Rosetta emulation
debug_message("Machine: ${MACHINE}")
if(MACHINE MATCHES "arm64|aarch64")
set(build_cpu_fam aarch64)
set(build_cpu armv8)
elseif(MACHINE MATCHES "x86_64|amd64")
set(build_cpu_fam x86_64)
set(build_cpu x86_64)
elseif(MACHINE MATCHES "x86|i686")
set(build_cpu_fam x86)
set(build_cpu i686)
elseif(MACHINE MATCHES "i386")
set(build_cpu_fam x86)
set(build_cpu i386)
else()
# https://github.com/mesonbuild/meson/blob/master/docs/markdown/Reference-tables.md#cpu-families
message(FATAL_ERROR "Unhandled machine: ${MACHINE}")
endif()
else()
message(FATAL_ERROR "Failed to detect the host architecture!")
endif()
if(VCPKG_TARGET_ARCHITECTURE MATCHES "(amd|AMD|x|X)64")
set(host_cpu_fam x86_64)
set(host_cpu x86_64)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
set(host_cpu_fam x86)
set(host_cpu i686)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
set(host_cpu_fam aarch64)
set(host_cpu armv8)
elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
set(host_cpu_fam arm)
set(host_cpu armv7hl)
else()
message(FATAL_ERROR "Unsupported target architecture ${VCPKG_TARGET_ARCHITECTURE}!" )
endif()
set(cross_file "")
z_vcpkg_append_proglist(cross_file "${additional_binaries}")
string(APPEND cross_file "[properties]\n")
string(APPEND cross_file "[host_machine]\n")
string(APPEND cross_file "endian = 'little'\n")
if(NOT VCPKG_CMAKE_SYSTEM_NAME OR VCPKG_TARGET_IS_MINGW)
set(meson_system_name "windows")
else()
string(TOLOWER "${VCPKG_CMAKE_SYSTEM_NAME}" meson_system_name)
endif()
string(APPEND cross_file "system = '${meson_system_name}'\n")
string(APPEND cross_file "cpu_family = '${host_cpu_fam}'\n")
string(APPEND cross_file "cpu = '${host_cpu}'\n")
string(APPEND cross_file "[build_machine]\n")
string(APPEND cross_file "endian = 'little'\n")
if(WIN32)
string(APPEND cross_file "system = 'windows'\n")
elseif(DARWIN)
string(APPEND cross_file "system = 'darwin'\n")
else()
string(APPEND cross_file "system = 'linux'\n")
endif()
if(DEFINED build_cpu_fam)
string(APPEND cross_file "cpu_family = '${build_cpu_fam}'\n")
endif()
if(DEFINED build_cpu)
string(APPEND cross_file "cpu = '${build_cpu}'\n")
endif()
if(NOT build_cpu_fam MATCHES "${host_cpu_fam}"
OR VCPKG_TARGET_IS_ANDROID OR VCPKG_TARGET_IS_IOS OR VCPKG_TARGET_IS_UWP
OR (VCPKG_TARGET_IS_MINGW AND NOT WIN32))
set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}.log")
set(vcpkg_meson_cross_file "${native_config_name}" PARENT_SCOPE)
file(WRITE "${native_config_name}" "${cross_file}")
endif()
endfunction()
function(z_vcpkg_meson_generate_cross_file_config config_type) #https://mesonbuild.com/Native-environments.html
set(cross_${config_type}_log "[properties]\n") #https://mesonbuild.com/Builtin-options.html
string(APPEND cross_${config_type}_log "[built-in options]\n")
z_vcpkg_meson_generate_flags_properties_string(cross_properties ${config_type})
string(APPEND cross_${config_type}_log "${cross_properties}")
if(VCPKG_TARGET_IS_WINDOWS)
if(VCPKG_CRT_LINKAGE STREQUAL "static")
set(crt_type mt)
else()
set(crt_type md)
endif()
if(${config_type} STREQUAL "DEBUG")
set(crt_type ${crt_type}d)
endif()
string(APPEND cross_${config_type}_log "b_vscrt = '${crt_type}'\n")
endif()
string(TOLOWER "${config_type}" lowerconfig)
set(native_config_name "${CURRENT_BUILDTREES_DIR}/meson-cross-${TARGET_TRIPLET}-${lowerconfig}.log")
set(VCPKG_MESON_CROSS_FILE_${config_type} "${native_config_name}" PARENT_SCOPE)
file(WRITE "${native_config_name}" "${cross_${config_type}_log}")
endfunction()
function(vcpkg_configure_meson)
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
cmake_parse_arguments(PARSE_ARGV 0 arg
"NO_PKG_CONFIG"
"SOURCE_PATH"
"OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;ADDITIONAL_NATIVE_BINARIES;ADDITIONAL_CROSS_BINARIES"
)
file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
z_vcpkg_get_cmake_vars(cmake_vars_file)
debug_message("Including cmake vars from: ${cmake_vars_file}")
include("${cmake_vars_file}")
vcpkg_find_acquire_program(MESON)
vcpkg_list(APPEND arg_OPTIONS --buildtype plain --backend ninja --wrap-mode nodownload)
if(NOT vcpkg_meson_cross_file)
z_vcpkg_meson_generate_cross_file("${arg_ADDITIONAL_CROSS_BINARIES}")
endif()
# We must use uppercase `DEBUG` and `RELEASE` here because they matches the configuration data
if(NOT VCPKG_MESON_CROSS_FILE_DEBUG AND vcpkg_meson_cross_file)
z_vcpkg_meson_generate_cross_file_config(DEBUG)
endif()
if(NOT VCPKG_MESON_CROSS_FILE_RELEASE AND vcpkg_meson_cross_file)
z_vcpkg_meson_generate_cross_file_config(RELEASE)
endif()
if(vcpkg_meson_cross_file)
vcpkg_list(APPEND arg_OPTIONS --cross "${vcpkg_meson_cross_file}")
endif()
if(VCPKG_MESON_CROSS_FILE_DEBUG)
vcpkg_list(APPEND arg_OPTIONS_DEBUG --cross "${VCPKG_MESON_CROSS_FILE_DEBUG}")
endif()
if(VCPKG_MESON_CROSS_FILE_RELEASE)
vcpkg_list(APPEND arg_OPTIONS_RELEASE --cross "${VCPKG_MESON_CROSS_FILE_RELEASE}")
endif()
if(NOT vcpkg_meson_native_file AND NOT vcpkg_meson_cross_file)
z_vcpkg_meson_generate_native_file("${arg_ADDITIONAL_NATIVE_BINARIES}")
endif()
if(NOT vcpkg_meson_native_file_DEBUG AND NOT vcpkg_meson_cross_file)
z_vcpkg_meson_generate_native_file_config(DEBUG)
endif()
if(NOT vcpkg_meson_native_file_RELEASE AND NOT vcpkg_meson_cross_file)
z_vcpkg_meson_generate_native_file_config(RELEASE)
endif()
if(vcpkg_meson_native_file AND NOT vcpkg_meson_cross_file)
vcpkg_list(APPEND arg_OPTIONS --native "${vcpkg_meson_native_file}")
vcpkg_list(APPEND arg_OPTIONS_DEBUG --native "${vcpkg_meson_native_file_DEBUG}")
vcpkg_list(APPEND arg_OPTIONS_RELEASE --native "${vcpkg_meson_native_file_RELEASE}")
else()
vcpkg_list(APPEND arg_OPTIONS --native "${SCRIPTS}/buildsystems/meson/none.txt")
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
vcpkg_list(APPEND arg_OPTIONS --default-library shared)
else()
vcpkg_list(APPEND arg_OPTIONS --default-library static)
endif()
vcpkg_list(APPEND arg_OPTIONS --libdir lib) # else meson install into an architecture describing folder
vcpkg_list(APPEND arg_OPTIONS_DEBUG -Ddebug=true --prefix "${CURRENT_PACKAGES_DIR}/debug" --includedir ../include)
vcpkg_list(APPEND arg_OPTIONS_RELEASE -Ddebug=false --prefix "${CURRENT_PACKAGES_DIR}")
# select meson cmd-line options
if(VCPKG_TARGET_IS_WINDOWS)
vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/share']")
vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}/share']")
else()
vcpkg_list(APPEND arg_OPTIONS_DEBUG "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}/debug','${CURRENT_INSTALLED_DIR}']")
vcpkg_list(APPEND arg_OPTIONS_RELEASE "-Dcmake_prefix_path=['${CURRENT_INSTALLED_DIR}','${CURRENT_INSTALLED_DIR}/debug']")
endif()
set(buildtypes)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
set(buildname "DEBUG")
vcpkg_list(APPEND buildtypes ${buildname})
set(path_suffix_${buildname} "debug/")
set(suffix_${buildname} "dbg")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
set(buildname "RELEASE")
vcpkg_list(APPEND buildtypes ${buildname})
set(path_suffix_${buildname} "")
set(suffix_${buildname} "rel")
endif()
vcpkg_backup_env_variables(VARS INCLUDE)
vcpkg_host_path_list(APPEND ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
# configure build
foreach(buildtype IN LISTS buildtypes)
message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}}")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}")
#setting up PKGCONFIG
if(NOT arg_NO_PKG_CONFIG)
if ("${buildtype}" STREQUAL "DEBUG")
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}/debug")
else()
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}")
endif()
endif()
vcpkg_execute_required_process(
COMMAND ${MESON} ${arg_OPTIONS} ${arg_OPTIONS_${buildtype}} ${arg_SOURCE_PATH}
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}"
LOGNAME config-${TARGET_TRIPLET}-${suffix_${buildtype}}
)
#Copy meson log files into buildtree for CI
if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/meson-log.txt")
file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/meson-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
file(RENAME "${CURRENT_BUILDTREES_DIR}/meson-log.txt" "${CURRENT_BUILDTREES_DIR}/meson-log-${suffix_${buildtype}}.log")
endif()
if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-info/intro-dependencies.json")
file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-info/intro-dependencies.json" DESTINATION "${CURRENT_BUILDTREES_DIR}")
file(RENAME "${CURRENT_BUILDTREES_DIR}/intro-dependencies.json" "${CURRENT_BUILDTREES_DIR}/intro-dependencies-${suffix_${buildtype}}.log")
endif()
if(EXISTS "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/install-log.txt")
file(COPY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${suffix_${buildtype}}/meson-logs/install-log.txt" DESTINATION "${CURRENT_BUILDTREES_DIR}")
file(RENAME "${CURRENT_BUILDTREES_DIR}/install-log.txt" "${CURRENT_BUILDTREES_DIR}/install-log-${suffix_${buildtype}}.log")
endif()
message(STATUS "Configuring ${TARGET_TRIPLET}-${suffix_${buildtype}} done")
if(NOT arg_NO_PKG_CONFIG)
z_vcpkg_restore_pkgconfig_path()
endif()
endforeach()
vcpkg_restore_env_variables(VARS INCLUDE)
endfunction()

100
externals/vcpkg/scripts/cmake/vcpkg_configure_qmake.cmake vendored Executable file
View File

@@ -0,0 +1,100 @@
function(vcpkg_configure_qmake)
# parse parameters such that semicolons in options arguments to COMMAND don't get erased
cmake_parse_arguments(PARSE_ARGV 0 arg
""
"SOURCE_PATH"
"OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG;BUILD_OPTIONS;BUILD_OPTIONS_RELEASE;BUILD_OPTIONS_DEBUG"
)
# Find qmake executable
find_program(qmake_executable NAMES qmake PATHS "${CURRENT_HOST_INSTALLED_DIR}/tools/qt5/bin" NO_DEFAULT_PATH)
if(NOT qmake_executable)
message(FATAL_ERROR "vcpkg_configure_qmake: unable to find qmake.")
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
vcpkg_list(APPEND arg_OPTIONS "CONFIG-=shared" "CONFIG*=static")
else()
vcpkg_list(APPEND arg_OPTIONS "CONFIG-=static" "CONFIG*=shared")
vcpkg_list(APPEND arg_OPTIONS_DEBUG "CONFIG*=separate_debug_info")
endif()
if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_CRT_LINKAGE STREQUAL "static")
vcpkg_list(APPEND arg_OPTIONS "CONFIG*=static-runtime")
endif()
if(DEFINED VCPKG_OSX_DEPLOYMENT_TARGET)
set(ENV{QMAKE_MACOSX_DEPLOYMENT_TARGET} ${VCPKG_OSX_DEPLOYMENT_TARGET})
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}" "${CURRENT_PACKAGES_DIR}")
set(current_binary_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
# Cleanup build directories
file(REMOVE_RECURSE "${current_binary_dir}")
configure_file("${CURRENT_INSTALLED_DIR}/tools/qt5/qt_release.conf" "${current_binary_dir}/qt.conf")
message(STATUS "Configuring ${TARGET_TRIPLET}-rel")
file(MAKE_DIRECTORY "${current_binary_dir}")
vcpkg_list(SET build_opt_param)
if(DEFINED arg_BUILD_OPTIONS OR DEFINED arg_BUILD_OPTIONS_RELEASE)
vcpkg_list(SET build_opt_param -- ${arg_BUILD_OPTIONS} ${arg_BUILD_OPTIONS_RELEASE})
endif()
vcpkg_execute_required_process(
COMMAND "${qmake_executable}" CONFIG-=debug CONFIG+=release
${arg_OPTIONS} ${arg_OPTIONS_RELEASE} ${arg_SOURCE_PATH}
-qtconf "${current_binary_dir}/qt.conf"
${build_opt_param}
WORKING_DIRECTORY "${current_binary_dir}"
LOGNAME "config-${TARGET_TRIPLET}-rel"
)
message(STATUS "Configuring ${TARGET_TRIPLET}-rel done")
if(EXISTS "${current_binary_dir}/config.log")
file(REMOVE "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-rel.log")
file(RENAME "${current_binary_dir}/config.log" "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-rel.log")
endif()
z_vcpkg_restore_pkgconfig_path()
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
z_vcpkg_setup_pkgconfig_path(BASE_DIRS "${CURRENT_INSTALLED_DIR}/debug" "${CURRENT_PACKAGES_DIR}/debug")
set(current_binary_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
# Cleanup build directories
file(REMOVE_RECURSE "${current_binary_dir}")
configure_file("${CURRENT_INSTALLED_DIR}/tools/qt5/qt_debug.conf" "${current_binary_dir}/qt.conf")
message(STATUS "Configuring ${TARGET_TRIPLET}-dbg")
file(MAKE_DIRECTORY "${current_binary_dir}")
vcpkg_list(SET build_opt_param)
if(DEFINED arg_BUILD_OPTIONS OR DEFINED arg_BUILD_OPTIONS_DEBUG)
vcpkg_list(SET build_opt_param -- ${arg_BUILD_OPTIONS} ${arg_BUILD_OPTIONS_DEBUG})
endif()
vcpkg_execute_required_process(
COMMAND "${qmake_executable}" CONFIG-=release CONFIG+=debug
${arg_OPTIONS} ${arg_OPTIONS_DEBUG} ${arg_SOURCE_PATH}
-qtconf "${current_binary_dir}/qt.conf"
${build_opt_param}
WORKING_DIRECTORY "${current_binary_dir}"
LOGNAME "config-${TARGET_TRIPLET}-dbg"
)
message(STATUS "Configuring ${TARGET_TRIPLET}-dbg done")
if(EXISTS "${current_binary_dir}/config.log")
file(REMOVE "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-dbg.log")
file(RENAME "${current_binary_dir}/config.log" "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-dbg.log")
endif()
z_vcpkg_restore_pkgconfig_path()
endif()
endfunction()

49
externals/vcpkg/scripts/cmake/vcpkg_copy_pdbs.cmake vendored Executable file
View File

@@ -0,0 +1,49 @@
function(vcpkg_copy_pdbs)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BUILD_PATHS")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_BUILD_PATHS)
set(arg_BUILD_PATHS
"${CURRENT_PACKAGES_DIR}/bin/*.dll"
"${CURRENT_PACKAGES_DIR}/debug/bin/*.dll"
)
endif()
set(dlls_without_matching_pdbs "")
if(VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic" AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
file(GLOB_RECURSE dlls ${arg_BUILD_PATHS})
set(vslang_backup "$ENV{VSLANG}")
set(ENV{VSLANG} 1033)
foreach(dll IN LISTS dlls)
execute_process(COMMAND dumpbin /PDBPATH "${dll}"
COMMAND findstr PDB
OUTPUT_VARIABLE pdb_line
ERROR_QUIET
RESULT_VARIABLE error_code
)
if(error_code EQUAL "0" AND pdb_line MATCHES "PDB file found at.*'(.*)'")
set(pdb_path "${CMAKE_MATCH_1}")
cmake_path(GET dll PARENT_PATH dll_dir)
file(COPY "${pdb_path}" DESTINATION "${dll_dir}")
else()
list(APPEND dlls_without_matching_pdbs "${dll}")
endif()
endforeach()
set(ENV{VSLANG} "${vslang_backup}")
if(NOT dlls_without_matching_pdbs STREQUAL "")
list(JOIN dlls_without_matching_pdbs "\n " message)
message(WARNING "Could not find a matching pdb file for:
${message}\n")
endif()
endif()
endfunction()

45
externals/vcpkg/scripts/cmake/vcpkg_copy_tool_dependencies.cmake vendored Executable file
View File

@@ -0,0 +1,45 @@
function(z_vcpkg_copy_tool_dependencies_search tool_dir path_to_search)
if(DEFINED Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT)
set(count ${Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT})
else()
set(count 0)
endif()
file(GLOB tools "${tool_dir}/*.exe" "${tool_dir}/*.dll" "${tool_dir}/*.pyd")
foreach(tool IN LISTS tools)
vcpkg_execute_required_process(
COMMAND "${Z_VCPKG_POWERSHELL_CORE}" -noprofile -executionpolicy Bypass -nologo
-file "${SCRIPTS}/buildsystems/msbuild/applocal.ps1"
-targetBinary "${tool}"
-installedDir "${path_to_search}"
-verbose
WORKING_DIRECTORY "${VCPKG_ROOT_DIR}"
LOGNAME copy-tool-dependencies-${count}
)
math(EXPR count "${count} + 1")
endforeach()
set(Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT ${count} CACHE INTERNAL "")
endfunction()
function(vcpkg_copy_tool_dependencies tool_dir)
if(ARGC GREATER 1)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${ARGN}")
endif()
if(VCPKG_TARGET_IS_WINDOWS)
find_program(Z_VCPKG_POWERSHELL_CORE pwsh)
if (NOT Z_VCPKG_POWERSHELL_CORE)
message(FATAL_ERROR "Could not find PowerShell Core; please open an issue to report this.")
endif()
cmake_path(RELATIVE_PATH tool_dir
BASE_DIRECTORY "${CURRENT_PACKAGES_DIR}"
OUTPUT_VARIABLE relative_tool_dir
)
if(relative_tool_dir MATCHES "/debug/")
z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_PACKAGES_DIR}/debug/bin")
z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_INSTALLED_DIR}/debug/bin")
else()
z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_PACKAGES_DIR}/bin")
z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_INSTALLED_DIR}/bin")
endif()
endif()
endfunction()

49
externals/vcpkg/scripts/cmake/vcpkg_copy_tools.cmake vendored Executable file
View File

@@ -0,0 +1,49 @@
function(vcpkg_copy_tools)
cmake_parse_arguments(PARSE_ARGV 0 arg "AUTO_CLEAN" "SEARCH_DIR;DESTINATION" "TOOL_NAMES")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_TOOL_NAMES)
message(FATAL_ERROR "TOOL_NAMES must be specified.")
endif()
if(NOT DEFINED arg_DESTINATION)
set(arg_DESTINATION "${CURRENT_PACKAGES_DIR}/tools/${PORT}")
endif()
if(NOT DEFINED arg_SEARCH_DIR)
set(arg_SEARCH_DIR "${CURRENT_PACKAGES_DIR}/bin")
elseif(NOT IS_DIRECTORY "${arg_SEARCH_DIR}")
message(FATAL_ERROR "SEARCH_DIR (${arg_SEARCH_DIR}) must be a directory")
endif()
foreach(tool_name IN LISTS arg_TOOL_NAMES)
set(tool_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
set(tool_pdb "${arg_SEARCH_DIR}/${tool_name}.pdb")
if(EXISTS "${tool_path}")
file(COPY "${tool_path}" DESTINATION "${arg_DESTINATION}")
elseif(NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "" AND NOT "${VCPKG_TARGET_BUNDLE_SUFFIX}" STREQUAL "${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
set(bundle_path "${arg_SEARCH_DIR}/${tool_name}${VCPKG_TARGET_BUNDLE_SUFFIX}")
if(EXISTS "${bundle_path}")
file(COPY "${bundle_path}" DESTINATION "${arg_DESTINATION}")
else()
message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
neither \"${tool_path}\" nor \"${bundle_path}\" exists")
endif()
else()
message(FATAL_ERROR "Couldn't find tool \"${tool_name}\":
\"${tool_path}\" does not exist")
endif()
if(EXISTS "${tool_pdb}")
file(COPY "${tool_pdb}" DESTINATION "${arg_DESTINATION}")
endif()
endforeach()
if(arg_AUTO_CLEAN)
vcpkg_clean_executables_in_bin(FILE_NAMES ${arg_TOOL_NAMES})
endif()
vcpkg_copy_tool_dependencies("${arg_DESTINATION}")
endfunction()

254
externals/vcpkg/scripts/cmake/vcpkg_download_distfile.cmake vendored Executable file
View File

@@ -0,0 +1,254 @@
function(z_vcpkg_download_distfile_test_hash file_path kind error_advice sha512 skip_sha512)
if(_VCPKG_INTERNAL_NO_HASH_CHECK)
# When using the internal hash skip, do not output an explicit message.
return()
endif()
if(skip_sha512)
message(STATUS "Skipping hash check for ${file_path}.")
return()
endif()
file(SHA512 "${file_path}" file_hash)
string(TOLOWER "${sha512}" sha512_lower)
if(NOT "${file_hash}" STREQUAL "${sha512_lower}")
message(FATAL_ERROR
"\nFile does not have expected hash:\n"
" File path: [ ${file_path} ]\n"
" Expected hash: [ ${sha512} ]\n"
" Actual hash: [ ${file_hash} ]\n"
"${error_advice}\n")
endif()
endfunction()
function(z_vcpkg_download_distfile_show_proxy_and_fail error_code)
message(FATAL_ERROR
" \n"
" Failed to download file with error: ${error_code}\n"
" If you use a proxy, please check your proxy setting. Possible causes are:\n"
" \n"
" 1. You are actually using an HTTP proxy, but setting HTTPS_PROXY variable\n"
" to `https://address:port`. This is not correct, because `https://` prefix\n"
" claims the proxy is an HTTPS proxy, while your proxy (v2ray, shadowsocksr\n"
" , etc..) is an HTTP proxy. Try setting `http://address:port` to both\n"
" HTTP_PROXY and HTTPS_PROXY instead.\n"
" \n"
" 2. You are using Fiddler. Currently a bug (https://github.com/microsoft/vcpkg/issues/17752)\n"
" will set HTTPS_PROXY to `https://fiddler_address:port` which lead to problem 1 above.\n"
" Workaround is open Windows 10 Settings App, and search for Proxy Configuration page,\n"
" Change `http=address:port;https=address:port` to `address`, and fill the port number.\n"
" \n"
" 3. Your proxy's remote server is out of service.\n"
" \n"
" In future vcpkg releases, if you are using Windows, you no longer need to set\n"
" HTTP(S)_PROXY environment variables. Vcpkg will simply apply Windows IE Proxy\n"
" Settings set by your proxy software. See (https://github.com/microsoft/vcpkg-tool/pull/49)\n"
" and (https://github.com/microsoft/vcpkg-tool/pull/77)\n"
" \n"
" Otherwise, please submit an issue at https://github.com/Microsoft/vcpkg/issues\n")
endfunction()
function(z_vcpkg_download_distfile_via_aria)
cmake_parse_arguments(PARSE_ARGV 1 arg
"SKIP_SHA512"
"FILENAME;SHA512"
"URLS;HEADERS"
)
message(STATUS "Downloading ${arg_FILENAME}...")
vcpkg_list(SET headers_param)
foreach(header IN LISTS arg_HEADERS)
vcpkg_list(APPEND headers_param "--header=${header}")
endforeach()
foreach(URL IN LISTS arg_URLS)
debug_message("Download Command: ${ARIA2} ${URL} -o temp/${filename} -l download-${filename}-detailed.log ${headers_param}")
vcpkg_execute_in_download_mode(
COMMAND ${ARIA2} ${URL}
-o temp/${arg_FILENAME}
-l download-${arg_FILENAME}-detailed.log
${headers_param}
OUTPUT_FILE download-${arg_FILENAME}-out.log
ERROR_FILE download-${arg_FILENAME}-err.log
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${DOWNLOADS}"
)
if ("${error_code}" STREQUAL "0")
break()
endif()
endforeach()
if (NOT "${error_code}" STREQUAL "0")
message(STATUS
"Downloading ${arg_FILENAME}... Failed.\n"
" Exit Code: ${error_code}\n"
" See logs for more information:\n"
" ${DOWNLOADS}/download-${arg_FILENAME}-out.log\n"
" ${DOWNLOADS}/download-${arg_FILENAME}-err.log\n"
" ${DOWNLOADS}/download-${arg_FILENAME}-detailed.log\n"
)
z_vcpkg_download_distfile_show_proxy_and_fail("${error_code}")
else()
z_vcpkg_download_distfile_test_hash(
"${DOWNLOADS}/temp/${arg_FILENAME}"
"downloaded file"
"The file may have been corrupted in transit."
"${arg_SHA512}"
${arg_SKIP_SHA512}
)
file(REMOVE
${DOWNLOADS}/download-${arg_FILENAME}-out.log
${DOWNLOADS}/download-${arg_FILENAME}-err.log
${DOWNLOADS}/download-${arg_FILENAME}-detailed.log
)
get_filename_component(downloaded_file_dir "${downloaded_file_path}" DIRECTORY)
file(MAKE_DIRECTORY "${downloaded_file_dir}")
file(RENAME "${DOWNLOADS}/temp/${arg_FILENAME}" "${downloaded_file_path}")
endif()
endfunction()
function(vcpkg_download_distfile out_var)
cmake_parse_arguments(PARSE_ARGV 1 arg
"SKIP_SHA512;SILENT_EXIT;QUIET;ALWAYS_REDOWNLOAD"
"FILENAME;SHA512"
"URLS;HEADERS"
)
if(NOT DEFINED arg_URLS)
message(FATAL_ERROR "vcpkg_download_distfile requires a URLS argument.")
endif()
if(NOT DEFINED arg_FILENAME)
message(FATAL_ERROR "vcpkg_download_distfile requires a FILENAME argument.")
endif()
if(arg_SILENT_EXIT)
message(WARNING "SILENT_EXIT has been deprecated as an argument to vcpkg_download_distfile -- remove the argument to resolve this warning")
endif()
if(arg_ALWAYS_REDOWNLOAD AND NOT arg_SKIP_SHA512)
message(FATAL_ERROR "ALWAYS_REDOWNLOAD option requires SKIP_SHA512 as well")
endif()
if(NOT arg_SKIP_SHA512 AND NOT DEFINED arg_SHA512)
message(FATAL_ERROR "vcpkg_download_distfile requires a SHA512 argument.
If you do not know the SHA512, add it as 'SHA512 0' and re-run this command.")
elseif(arg_SKIP_SHA512 AND DEFINED arg_SHA512)
message(FATAL_ERROR "vcpkg_download_distfile must not be passed both SHA512 and SKIP_SHA512.")
endif()
if(_VCPKG_INTERNAL_NO_HASH_CHECK)
set(arg_SKIP_SHA512 1)
endif()
if(NOT arg_SKIP_SHA512)
if("${arg_SHA512}" STREQUAL "0")
string(REPEAT 0 128 arg_SHA512)
else()
string(LENGTH "${arg_SHA512}" arg_SHA512_length)
if(NOT "${arg_SHA512_length}" EQUAL "128" OR NOT "${arg_SHA512}" MATCHES "^[a-zA-Z0-9]*$")
message(FATAL_ERROR "Invalid SHA512: ${arg_SHA512}.
If you do not know the file's SHA512, set this to \"0\".")
endif()
endif()
endif()
set(downloaded_file_path "${DOWNLOADS}/${arg_FILENAME}")
set(download_file_path_part "${DOWNLOADS}/temp/${arg_FILENAME}")
# Works around issue #3399
# Delete "temp0" directory created by the old version of vcpkg
file(REMOVE_RECURSE "${DOWNLOADS}/temp0")
file(REMOVE_RECURSE "${DOWNLOADS}/temp")
file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
# check if file with same name already exists in downloads
if(EXISTS "${downloaded_file_path}")
set(advice_message "The cached file SHA512 doesn't match. The file may have been corrupted.")
if(_VCPKG_NO_DOWNLOADS)
string(APPEND advice_message " Downloads are disabled please provide a valid file at path ${downloaded_file_path} and retry.")
else()
string(APPEND advice_message " To re-download this file please delete cached file at path ${downloaded_file_path} and retry.")
endif()
z_vcpkg_download_distfile_test_hash(
"${downloaded_file_path}"
"cached file"
"${advice_message}"
"${arg_SHA512}"
"${arg_SKIP_SHA512}"
)
if(NOT vcpkg_download_distfile_QUIET)
message(STATUS "Using cached ${arg_FILENAME}.")
endif()
# Suppress the "Downloading ${arg_URLS} -> ${arg_FILENAME}..." message
set(vcpkg_download_distfile_QUIET TRUE)
endif()
# vcpkg_download_distfile_ALWAYS_REDOWNLOAD only triggers when NOT _VCPKG_NO_DOWNLOADS
# this could be de-morgan'd out but it's more clear this way
if(_VCPKG_NO_DOWNLOADS)
if(NOT EXISTS "${downloaded_file_path}")
message(FATAL_ERROR "Downloads are disabled, but '${downloaded_file_path}' does not exist.")
endif()
set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
return()
endif()
if(NOT arg_DISABLE_ARIA2 AND _VCPKG_DOWNLOAD_TOOL STREQUAL "ARIA2" AND NOT EXISTS "${downloaded_file_path}")
if (arg_SKIP_SHA512)
set(OPTION_SKIP_SHA512 "SKIP_SHA512")
endif()
z_vcpkg_download_distfile_via_aria(
"${OPTION_SKIP_SHA512}"
FILENAME "${arg_FILENAME}"
SHA512 "${arg_SHA512}"
URLS "${arg_URLS}"
HEADERS "${arg_HEADERS}"
)
set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
return()
endif()
vcpkg_list(SET urls_param)
foreach(url IN LISTS arg_URLS)
vcpkg_list(APPEND urls_param "--url=${url}")
endforeach()
if(NOT vcpkg_download_distfile_QUIET)
message(STATUS "Downloading ${arg_URLS} -> ${arg_FILENAME}...")
endif()
vcpkg_list(SET headers_param)
foreach(header IN LISTS arg_HEADERS)
list(APPEND headers_param "--header=${header}")
endforeach()
if(arg_SKIP_SHA512)
vcpkg_list(SET sha512_param "--skip-sha512")
else()
vcpkg_list(SET sha512_param "--sha512=${arg_SHA512}")
endif()
if(NOT EXISTS "${downloaded_file_path}" OR arg_ALWAYS_REDOWNLOAD)
vcpkg_execute_in_download_mode(
COMMAND "$ENV{VCPKG_COMMAND}" x-download
"${downloaded_file_path}"
${sha512_param}
${urls_param}
${headers_param}
--debug
--feature-flags=-manifests # there's a bug in vcpkg x-download when it finds a manifest-root
OUTPUT_VARIABLE output
ERROR_VARIABLE output
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${DOWNLOADS}"
)
if(NOT "${error_code}" EQUAL "0")
message("${output}")
z_vcpkg_download_distfile_show_proxy_and_fail("${error_code}")
endif()
endif()
set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
endfunction()

136
externals/vcpkg/scripts/cmake/vcpkg_execute_build_process.cmake vendored Executable file
View File

@@ -0,0 +1,136 @@
set(Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES
"LINK : fatal error LNK1102:"
" fatal error C1060: "
# The linker ran out of memory during execution. We will try continuing once more, with parallelism disabled.
"LINK : fatal error LNK1318:"
"LINK : fatal error LNK1104:"
"LINK : fatal error LNK1201:"
"ld terminated with signal 9"
"Killed signal terminated program"
# Multiple threads using the same directory at the same time cause conflicts, will try again.
"Cannot create parent directory"
"Cannot write file"
# Multiple threads caused the wrong order of creating folders and creating files in folders
"Can't open"
)
list(JOIN Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES "|" Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES)
function(vcpkg_execute_build_process)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "WORKING_DIRECTORY;LOGNAME" "COMMAND;NO_PARALLEL_COMMAND")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(required_arg IN ITEMS WORKING_DIRECTORY COMMAND)
if(NOT DEFINED arg_${required_arg})
message(FATAL_ERROR "${required_arg} must be specified.")
endif()
endforeach()
if(NOT DEFINED arg_LOGNAME)
message(WARNING "LOGNAME should be specified.")
set(arg_LOGNAME "build")
endif()
set(log_prefix "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}")
set(log_out "${log_prefix}-out.log")
set(log_err "${log_prefix}-err.log")
set(all_logs "${log_out}" "${log_err}")
if(X_PORT_PROFILE)
vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
if(DEFINED arg_NO_PARALLEL_COMMAND)
vcpkg_list(PREPEND arg_NO_PARALLEL_COMMAND "${CMAKE_COMMAND}" "-E" "time")
endif()
endif()
execute_process(
COMMAND ${arg_COMMAND}
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
OUTPUT_FILE "${log_out}"
ERROR_FILE "${log_err}"
RESULT_VARIABLE error_code
)
if(NOT error_code EQUAL "0")
file(READ "${log_out}" out_contents)
file(READ "${log_err}" err_contents)
set(all_contents "${out_contents}${err_contents}")
if(all_contents MATCHES "${Z_VCPKG_EXECUTE_BUILD_PROCESS_RETRY_ERROR_MESSAGES}")
message(WARNING "Please ensure your system has sufficient memory.")
set(log_out "${log_prefix}-out-1.log")
set(log_err "${log_prefix}-err-1.log")
list(APPEND all_logs "${log_out}" "${log_err}")
if(DEFINED arg_NO_PARALLEL_COMMAND)
message(STATUS "Restarting build without parallelism")
execute_process(
COMMAND ${arg_NO_PARALLEL_COMMAND}
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
OUTPUT_FILE "${log_out}"
ERROR_FILE "${log_err}"
RESULT_VARIABLE error_code
)
else()
message(STATUS "Restarting build")
execute_process(
COMMAND ${arg_COMMAND}
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
OUTPUT_FILE "${log_out}"
ERROR_FILE "${log_err}"
RESULT_VARIABLE error_code
)
endif()
elseif(all_contents MATCHES "mt : general error c101008d: ")
# Antivirus workaround - occasionally files are locked and cause mt.exe to fail
message(STATUS "mt.exe has failed. This may be the result of anti-virus. Disabling anti-virus on the buildtree folder may improve build speed")
foreach(iteration RANGE 1 3)
message(STATUS "Restarting Build ${TARGET_TRIPLET}-${SHORT_BUILDTYPE} because of mt.exe file locking issue. Iteration: ${iteration}")
set(log_out "${log_prefix}-out-${iteration}.log")
set(log_err "${log_prefix}-err-${iteration}.log")
list(APPEND all_logs "${log_out}" "${log_err}")
execute_process(
COMMAND ${arg_COMMAND}
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
OUTPUT_FILE "${log_out}"
ERROR_FILE "${log_err}"
RESULT_VARIABLE error_code
)
if(error_code EQUAL "0")
break()
endif()
file(READ "${log_out}" out_contents)
file(READ "${log_err}" err_contents)
set(all_contents "${out_contents}${err_contents}")
if(NOT all_contents MATCHES "mt : general error c101008d: ")
break()
endif()
endforeach()
endif()
endif()
if(NOT error_code EQUAL "0")
set(stringified_logs "")
foreach(log IN LISTS all_logs)
if(NOT EXISTS "${log}")
continue()
endif()
file(SIZE "${log}" log_size)
if(NOT log_size EQUAL "0")
file(TO_NATIVE_PATH "${log}" native_log)
string(APPEND stringified_logs " ${native_log}\n")
file(APPEND "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}" "${native_log}\n")
endif()
endforeach()
z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
message(FATAL_ERROR
" Command failed: ${pretty_command}\n"
" Working Directory: ${arg_WORKING_DIRECTORY}\n"
" See logs for more information:\n"
"${stringified_logs}"
)
endif()
endfunction()

46
externals/vcpkg/scripts/cmake/vcpkg_execute_in_download_mode.cmake vendored Executable file
View File

@@ -0,0 +1,46 @@
function(vcpkg_execute_in_download_mode)
# this allows us to grab the value of the output variables, but pass through the rest of the arguments
cmake_parse_arguments(PARSE_ARGV 0 arg "" "RESULT_VARIABLE;RESULTS_VARIABLE;OUTPUT_VARIABLE;ERROR_VARIABLE" "")
set(output_and_error_same OFF)
set(output_variable_param "")
set(error_variable_param "")
set(result_variable_param "")
set(results_variable_param "")
if(DEFINED arg_OUTPUT_VARIABLE AND DEFINED arg_ERROR_VARIABLE AND arg_OUTPUT_VARIABLE STREQUAL arg_ERROR_VARIABLE)
set(output_variable_param OUTPUT_VARIABLE out_err_var)
set(error_variable_param ERROR_VARIABLE out_err_var)
set(output_and_error_same ON)
else()
if(DEFINED arg_OUTPUT_VARIABLE)
set(output_variable_param OUTPUT_VARIABLE out_var)
endif()
if(DEFINED arg_ERROR_VARIABLE)
set(error_variable_param ERROR_VARIABLE err_var)
endif()
endif()
if(DEFINED arg_RESULT_VARIABLE)
set(result_variable_param RESULT_VARIABLE result_var)
endif()
if(DEFINED arg_RESULTS_VARIABLE)
set(results_variable_param RESULTS_VARIABLE results_var)
endif()
cmake_language(CALL "${Z_VCPKG_EXECUTE_PROCESS_NAME}"
${arg_UNPARSED_ARGUMENTS}
${output_variable_param}
${error_variable_param}
${result_variable_param}
${results_variable_param}
)
if(output_and_error_same)
z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_err_var)
else()
z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_var)
z_vcpkg_forward_output_variable(arg_ERROR_VARIABLE err_var)
endif()
z_vcpkg_forward_output_variable(arg_RESULT_VARIABLE result_var)
z_vcpkg_forward_output_variable(arg_RESULTS_VARIABLE results_var)
endfunction()

100
externals/vcpkg/scripts/cmake/vcpkg_execute_required_process.cmake vendored Executable file
View File

@@ -0,0 +1,100 @@
function(vcpkg_execute_required_process)
cmake_parse_arguments(PARSE_ARGV 0 arg
"ALLOW_IN_DOWNLOAD_MODE"
"WORKING_DIRECTORY;LOGNAME;TIMEOUT;OUTPUT_VARIABLE;ERROR_VARIABLE"
"COMMAND"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(required_arg IN ITEMS WORKING_DIRECTORY COMMAND)
if(NOT DEFINED arg_${required_arg})
message(FATAL_ERROR "${required_arg} must be specified.")
endif()
endforeach()
if(NOT DEFINED arg_LOGNAME)
message(WARNING "LOGNAME should be specified.")
set(arg_LOGNAME "required")
endif()
if (VCPKG_DOWNLOAD_MODE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
message(FATAL_ERROR
[[
This command cannot be executed in Download Mode.
Halting portfile execution.
]])
endif()
set(log_out "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out.log")
set(log_err "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-err.log")
set(timeout_param "")
set(output_and_error_same OFF)
set(output_variable_param "")
set(error_variable_param "")
if(DEFINED arg_TIMEOUT)
set(timeout_param TIMEOUT "${arg_TIMEOUT}")
endif()
if(DEFINED arg_OUTPUT_VARIABLE AND DEFINED arg_ERROR_VARIABLE AND arg_OUTPUT_VARIABLE STREQUAL arg_ERROR_VARIABLE)
set(output_variable_param OUTPUT_VARIABLE out_err_var)
set(error_variable_param ERROR_VARIABLE out_err_var)
set(output_and_error_same ON)
else()
if(DEFINED arg_OUTPUT_VARIABLE)
set(output_variable_param OUTPUT_VARIABLE out_var)
endif()
if(DEFINED arg_ERROR_VARIABLE)
set(error_variable_param ERROR_VARIABLE err_var)
endif()
endif()
if(X_PORT_PROFILE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
endif()
vcpkg_execute_in_download_mode(
COMMAND ${arg_COMMAND}
OUTPUT_FILE "${log_out}"
ERROR_FILE "${log_err}"
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
${timeout_param}
${output_variable_param}
${error_variable_param}
)
if(NOT error_code EQUAL 0)
set(stringified_logs "")
foreach(log IN ITEMS "${log_out}" "${log_err}")
if(NOT EXISTS "${log}")
continue()
endif()
file(SIZE "${log}" log_size)
if(NOT log_size EQUAL "0")
file(TO_NATIVE_PATH "${log}" native_log)
string(APPEND stringified_logs " ${native_log}\n")
file(APPEND "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}" "${native_log}\n")
endif()
endforeach()
z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
message(FATAL_ERROR
" Command failed: ${pretty_command}\n"
" Working Directory: ${arg_WORKING_DIRECTORY}\n"
" Error code: ${error_code}\n"
" See logs for more information:\n"
"${stringified_logs}"
)
endif()
# pass output parameters back to caller's scope
if(output_and_error_same)
z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_err_var)
# arg_ERROR_VARIABLE = arg_OUTPUT_VARIABLE, so no need to set it again
else()
z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_var)
z_vcpkg_forward_output_variable(arg_ERROR_VARIABLE err_var)
endif()
endfunction()

71
externals/vcpkg/scripts/cmake/vcpkg_execute_required_process_repeat.cmake vendored Executable file
View File

@@ -0,0 +1,71 @@
function(vcpkg_execute_required_process_repeat)
cmake_parse_arguments(PARSE_ARGV 0 arg
"ALLOW_IN_DOWNLOAD_MODE"
"COUNT;WORKING_DIRECTORY;LOGNAME"
"COMMAND"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(required_arg IN ITEMS COUNT WORKING_DIRECTORY LOGNAME COMMAND)
if(NOT DEFINED arg_${required_arg})
message(FATAL_ERROR "${required_arg} must be specified.")
endif()
endforeach()
# also checks for COUNT being an integer
if(NOT arg_COUNT GREATER_EQUAL "1")
message(FATAL_ERROR "COUNT (${arg_COUNT}) must be greater than or equal to 1.")
endif()
if (DEFINED VCPKG_DOWNLOAD_MODE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
message(FATAL_ERROR
[[
This command cannot be executed in Download Mode.
Halting portfile execution.
]])
endif()
if(X_PORT_PROFILE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
endif()
set(all_logs "")
foreach(loop_count RANGE 1 ${arg_COUNT})
set(out_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
set(err_log "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out-${loop_count}.log")
list(APPEND all_logs "${out_log}" "${err_log}")
vcpkg_execute_in_download_mode(
COMMAND ${arg_COMMAND}
OUTPUT_FILE "${out_log}"
ERROR_FILE "${err_log}"
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
)
if(error_code EQUAL "0")
return()
endif()
endforeach()
set(stringified_logs "")
foreach(log IN LISTS all_logs)
if(NOT EXISTS "${log}")
continue()
endif()
file(SIZE "${log}" log_size)
if(NOT log_size EQUAL "0")
file(TO_NATIVE_PATH "${log}" native_log)
string(APPEND stringified_logs " ${native_log}\n")
endif()
endforeach()
z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
message(FATAL_ERROR
" Command failed: ${pretty_command}\n"
" Working Directory: ${arg_WORKING_DIRECTORY}\n"
" See logs for more information:\n"
"${stringifed_logs}"
)
endfunction()

164
externals/vcpkg/scripts/cmake/vcpkg_extract_source_archive.cmake vendored Executable file
View File

@@ -0,0 +1,164 @@
function(z_vcpkg_extract_source_archive_deprecated_mode archive working_directory)
cmake_path(GET archive FILENAME archive_filename)
if(NOT EXISTS "${working_directory}/${archive_filename}.extracted")
message(STATUS "Extracting source ${archive}")
file(MAKE_DIRECTORY "${working_directory}")
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${CMAKE_COMMAND}" -E tar xjf "${archive}"
WORKING_DIRECTORY "${working_directory}"
LOGNAME extract
)
file(TOUCH "${working_directory}/${archive_filename}.extracted")
endif()
endfunction()
function(vcpkg_extract_source_archive)
if(ARGC LESS_EQUAL "2")
z_vcpkg_deprecation_message( "Deprecated form of vcpkg_extract_source_archive used:
Please use the `vcpkg_extract_source_archive(<out-var> ARCHIVE <archive>)` form.")
if(ARGC EQUAL "0")
message(FATAL_ERROR "vcpkg_extract_source_archive requires at least one argument.")
endif()
set(archive "${ARGV0}")
if(ARGC EQUAL "1")
set(working_directory "${CURRENT_BUILDTREES_DIR}/src")
else()
set(working_directory "${ARGV1}")
endif()
z_vcpkg_extract_source_archive_deprecated_mode("${archive}" "${working_directory}")
return()
endif()
set(out_source_path "${ARGV0}")
cmake_parse_arguments(PARSE_ARGV 1 "arg"
"NO_REMOVE_ONE_LEVEL;SKIP_PATCH_CHECK;Z_ALLOW_OLD_PARAMETER_NAMES"
"ARCHIVE;SOURCE_BASE;BASE_DIRECTORY;WORKING_DIRECTORY;REF"
"PATCHES"
)
if(DEFINED arg_REF)
if(NOT arg_Z_ALLOW_OLD_PARAMETER_NAMES)
message(FATAL_ERROR "Unexpected argument REF")
elseif(DEFINED arg_SOURCE_BASE)
message(FATAL_ERROR "Cannot specify both REF and SOURCE_BASE")
else()
string(REPLACE "/" "-" arg_SOURCE_BASE "${arg_REF}")
endif()
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_ARCHIVE)
message(FATAL_ERROR "ARCHIVE must be specified")
endif()
if(DEFINED arg_WORKING_DIRECTORY)
if(DEFINED arg_BASE_DIRECTORY)
message(FATAL_ERROR "Cannot specify both BASE_DIRECTORY and WORKING_DIRECTORY")
elseif(NOT IS_ABSOLUTE "${arg_WORKING_DIRECTORY}")
message(FATAL_ERROR "WORKING_DIRECTORY (${arg_WORKING_DIRECTORY}) must be an absolute path")
endif()
set(working_directory "${arg_WORKING_DIRECTORY}")
else()
if(NOT DEFINED arg_BASE_DIRECTORY)
set(arg_BASE_DIRECTORY "src")
elseif(IS_ABSOLUTE "${arg_BASE_DIRECTORY}")
message(FATAL_ERROR "BASE_DIRECTORY (${arg_BASE_DIRECTORY}) must be a relative path")
endif()
cmake_path(APPEND CURRENT_BUILDTREES_DIR "${arg_BASE_DIRECTORY}"
OUTPUT_VARIABLE working_directory)
endif()
if(NOT DEFINED arg_SOURCE_BASE)
cmake_path(GET arg_ARCHIVE STEM arg_SOURCE_BASE)
elseif(arg_SOURCE_BASE MATCHES [[\\|/]])
message(FATAL_ERROR "SOURCE_BASE (${arg_SOURCE_BASE}) must not contain slashes")
endif()
# Take the last 10 chars of the base
set(base_max_length 10)
string(LENGTH "${arg_SOURCE_BASE}" source_base_length)
if(source_base_length GREATER base_max_length)
math(EXPR start "${source_base_length} - ${base_max_length}")
string(SUBSTRING "${arg_SOURCE_BASE}" "${start}" -1 arg_SOURCE_BASE)
endif()
# Hash the archive hash along with the patches. Take the first 10 chars of the hash
file(SHA512 "${arg_ARCHIVE}" patchset_hash)
foreach(patch IN LISTS arg_PATCHES)
cmake_path(ABSOLUTE_PATH patch
BASE_DIRECTORY "${CURRENT_PORT_DIR}"
OUTPUT_VARIABLE absolute_patch
)
if(NOT EXISTS "${absolute_patch}")
message(FATAL_ERROR "Could not find patch: '${patch}'")
endif()
file(SHA512 "${absolute_patch}" current_hash)
string(APPEND patchset_hash "${current_hash}")
endforeach()
string(SHA512 patchset_hash "${patchset_hash}")
string(SUBSTRING "${patchset_hash}" 0 10 patchset_hash)
cmake_path(APPEND working_directory "${arg_SOURCE_BASE}-${patchset_hash}"
OUTPUT_VARIABLE source_path
)
if(_VCPKG_EDITABLE AND EXISTS "${source_path}")
set("${out_source_path}" "${source_path}" PARENT_SCOPE)
message(STATUS "Using source at ${source_path}")
return()
elseif(NOT _VCPKG_EDITABLE)
cmake_path(APPEND_STRING source_path ".clean")
if(EXISTS "${source_path}")
message(STATUS "Cleaning sources at ${source_path}. Use --editable to skip cleaning for the packages you specify.")
file(REMOVE_RECURSE "${source_path}")
endif()
endif()
message(STATUS "Extracting source ${arg_ARCHIVE}")
cmake_path(APPEND_STRING source_path ".tmp" OUTPUT_VARIABLE temp_dir)
file(REMOVE_RECURSE "${temp_dir}")
file(MAKE_DIRECTORY "${temp_dir}")
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${CMAKE_COMMAND}" -E tar xjf "${arg_ARCHIVE}"
WORKING_DIRECTORY "${temp_dir}"
LOGNAME extract
)
if(arg_NO_REMOVE_ONE_LEVEL)
cmake_path(SET temp_source_path "${temp_dir}")
else()
file(GLOB archive_directory "${temp_dir}/*")
# Exclude .DS_Store entries created by the finder on macOS
list(FILTER archive_directory EXCLUDE REGEX ".*/.DS_Store$")
# make sure `archive_directory` is only a single file
if(NOT archive_directory MATCHES ";" AND IS_DIRECTORY "${archive_directory}")
cmake_path(SET temp_source_path "${archive_directory}")
else()
message(FATAL_ERROR "Could not unwrap top level directory from archive. Pass NO_REMOVE_ONE_LEVEL to disable this.")
endif()
endif()
if (arg_SKIP_PATCH_CHECK)
set(quiet_param QUIET)
else()
set(quiet_param "")
endif()
z_vcpkg_apply_patches(
SOURCE_PATH "${temp_source_path}"
PATCHES ${arg_PATCHES}
${quiet_param}
)
file(RENAME "${temp_source_path}" "${source_path}")
file(REMOVE_RECURSE "${temp_dir}")
set("${out_source_path}" "${source_path}" PARENT_SCOPE)
message(STATUS "Using source at ${source_path}")
endfunction()

11
externals/vcpkg/scripts/cmake/vcpkg_extract_source_archive_ex.cmake vendored Executable file
View File

@@ -0,0 +1,11 @@
function(vcpkg_extract_source_archive_ex)
# OUT_SOURCE_PATH is an out-parameter so we need to parse it
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "OUT_SOURCE_PATH" "")
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified")
endif()
vcpkg_extract_source_archive(source_path ${arg_UNPARSED_ARGUMENTS} Z_ALLOW_OLD_PARAMETER_NAMES)
set("${arg_OUT_SOURCE_PATH}" "${source_path}" PARENT_SCOPE)
endfunction()

78
externals/vcpkg/scripts/cmake/vcpkg_fail_port_install.cmake vendored Executable file
View File

@@ -0,0 +1,78 @@
function(vcpkg_fail_port_install)
message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_fail_port_install has been removed and all values should be moved by adding `supports` field to manifest file or directly adding `${PORT}:${FAILED_TRIPLET}=fail` to _scripts/ci.baseline.txt_.\nPlease remove `vcpkg_fail_port_install(...)`.\n")
set(multi_args "ON_TARGET;ON_ARCH;ON_CRT_LINKAGE;ON_LIBRARY_LINKAGE")
cmake_parse_arguments(PARSE_ARGV 0 "arg" "ALWAYS" "MESSAGE" "${multi_args}")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "vcpkg_fail_port_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(arg_ALWAYS)
vcpkg_list(SET extra_args)
foreach(arg IN LISTS multi_args)
if(DEFINED "arg_${arg}")
vcpkg_list(APPEND extra_args "${arg}" "${arg_${arg}}")
endif()
endforeach()
if(NOT "${extra_args}" STREQUAL "")
message(WARNING "vcpkg_fail_port_install set to fail both unconditionally and conditionally on ${extra_args}. This is likely to be an error.")
endif()
if(NOT DEFINED arg_MESSAGE)
message(FATAL_ERROR "vcpkg_fail_port_install(ALWAYS) was called without a specific MESSAGE.")
endif()
message(FATAL_ERROR "${arg_MESSAGE}")
endif()
if(DEFINED arg_MESSAGE)
string(APPEND arg_MESSAGE "\n")
else()
set(arg_MESSAGE "")
endif()
set(fail_port OFF)
# Target fail check
if(DEFINED arg_ON_TARGET)
foreach(target IN LISTS arg_ON_TARGET)
string(TOUPPER "${target}" target_upper)
if(VCPKG_TARGET_IS_${target_upper})
set(fail_port ON)
string(APPEND arg_MESSAGE "Target '${target}' not supported by ${PORT}!\n")
endif()
endforeach()
endif()
# Architecture fail check
if(DEFINED arg_ON_ARCH)
foreach(arch IN LISTS arg_ON_ARCH)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL arch)
set(fail_port ON)
string(APPEND arg_MESSAGE "Architecture '${arch}' not supported by ${PORT}!\n")
endif()
endforeach()
endif()
# CRT linkage fail check
if(DEFINED arg_ON_CRT_LINKAGE)
foreach(crt_linkage IN LISTS arg_ON_CRT_LINKAGE)
if(VCPKG_CRT_LINKAGE STREQUAL crt_linkage)
set(fail_port ON)
string(APPEND arg_MESSAGE "CRT linkage '${VCPKG_CRT_LINKAGE}' not supported by ${PORT}!\n")
endif()
endforeach()
endif()
# Library linkage fail check
if(DEFINED arg_ON_LIBRARY_LINKAGE)
foreach(library_linkage IN LISTS arg_ON_LIBRARY_LINKAGE)
if(VCPKG_LIBRARY_LINKAGE STREQUAL library_linkage)
set(fail_port ON)
string(APPEND arg_MESSAGE "Library linkage '${VCPKG_LIBRARY_LINKAGE}' not supported by ${PORT}!\n")
endif()
endforeach()
endif()
if(fail_port)
message(FATAL_ERROR "${arg_MESSAGE}")
endif()
endfunction()

678
externals/vcpkg/scripts/cmake/vcpkg_find_acquire_program.cmake vendored Executable file
View File

@@ -0,0 +1,678 @@
function(z_vcpkg_find_acquire_program_version_check out_var)
cmake_parse_arguments(PARSE_ARGV 1 arg
"EXACT_VERSION_MATCH"
"MIN_VERSION;PROGRAM_NAME"
"COMMAND"
)
vcpkg_execute_in_download_mode(
COMMAND ${arg_COMMAND}
WORKING_DIRECTORY "${VCPKG_ROOT_DIR}"
OUTPUT_VARIABLE program_version_output
)
string(STRIP "${program_version_output}" program_version_output)
#TODO: REGEX MATCH case for more complex cases!
set(version_compare VERSION_GREATER_EQUAL)
set(version_compare_msg "at least")
if(arg_EXACT_VERSION_MATCH)
set(version_compare VERSION_EQUAL)
set(version_compare_msg "exact")
endif()
if(NOT "${program_version_output}" ${version_compare} "${arg_MIN_VERSION}")
message(STATUS "Found ${arg_PROGRAM_NAME}('${program_version_output}') but ${version_compare_msg} version ${arg_MIN_VERSION} is required! Trying to use internal version if possible!")
set("${out_var}" OFF PARENT_SCOPE)
else()
message(STATUS "Found external ${arg_PROGRAM_NAME}('${program_version_output}').")
set("${out_var}" ON PARENT_SCOPE)
endif()
endfunction()
function(z_vcpkg_find_acquire_program_find_external program)
cmake_parse_arguments(PARSE_ARGV 1 arg
"EXACT_VERSION_MATCH"
"INTERPRETER;MIN_VERSION;PROGRAM_NAME"
"NAMES;VERSION_COMMAND"
)
if(arg_EXACT_VERSION_MATCH)
set(arg_EXACT_VERSION_MATCH EXACT_VERSION_MATCH)
endif()
if("${arg_INTERPRETER}" STREQUAL "")
find_program("${program}" NAMES ${arg_NAMES})
else()
find_file(SCRIPT_${arg_PROGRAM_NAME} NAMES ${arg_NAMES})
if(SCRIPT_${arg_PROGRAM_NAME})
vcpkg_list(SET program_tmp ${${interpreter}} ${SCRIPT_${arg_PROGRAM_NAME}})
set("${program}" "${program_tmp}" CACHE INTERNAL "")
else()
set("${program}" "" CACHE INTERNAL "")
endif()
unset(SCRIPT_${arg_PROGRAM_NAME} CACHE)
endif()
if("${version_command}" STREQUAL "")
set(version_is_good ON) # can't check for the version being good, so assume it is
elseif(${program}) # only do a version check if ${program} has a value
z_vcpkg_find_acquire_program_version_check(version_is_good
${arg_EXACT_VERSION_MATCH}
COMMAND ${${program}} ${arg_VERSION_COMMAND}
MIN_VERSION "${arg_MIN_VERSION}"
PROGRAM_NAME "${arg_PROGRAM_NAME}"
)
endif()
if(NOT version_is_good)
unset("${program}" PARENT_SCOPE)
unset("${program}" CACHE)
endif()
endfunction()
function(z_vcpkg_find_acquire_program_find_internal program)
cmake_parse_arguments(PARSE_ARGV 1 arg
""
"INTERPRETER"
"NAMES;PATHS"
)
if("${arg_INTERPRETER}" STREQUAL "")
find_program(${program}
NAMES ${arg_NAMES}
PATHS ${arg_PATHS}
NO_DEFAULT_PATH)
else()
vcpkg_find_acquire_program("${arg_INTERPRETER}")
find_file(SCRIPT_${program}
NAMES ${arg_NAMES}
PATHS ${arg_PATHS}
NO_DEFAULT_PATH)
if(SCRIPT_${program})
set("${program}" ${${arg_INTERPRETER}} ${SCRIPT_${program}} CACHE INTERNAL "")
endif()
unset(SCRIPT_${program} CACHE)
endif()
endfunction()
function(vcpkg_find_acquire_program program)
if(${program})
return()
endif()
set(raw_executable "OFF")
set(program_name "")
set(program_version "")
set(search_names "")
set(download_urls "")
set(download_filename "")
set(download_sha512 "")
set(rename_binary_to "")
set(tool_subdirectory "")
set(interpreter "")
set(supported_on_unix "")
set(post_install_command "")
set(paths_to_search "")
set(version_command "")
vcpkg_list(SET sourceforge_args)
set(brew_package_name "")
set(apt_package_name "")
if(program STREQUAL "PERL")
set(program_name perl)
set(program_version 5.32.1.1)
set(tool_subdirectory ${program_version})
set(paths_to_search ${DOWNLOADS}/tools/perl/${tool_subdirectory}/perl/bin)
set(brew_package_name "perl")
set(apt_package_name "perl")
set(download_urls
"https://strawberryperl.com/download/${program_version}/strawberry-perl-${program_version}-32bit.zip"
)
set(download_filename "strawberry-perl-${program_version}-32bit.zip")
set(download_sha512 936381254fea2e596db6a16c23b08ced25c4081fda484e1b8c4356755016e4b956bd00f3d2ee651d5f41a7695e9998f6c1ac3f4a237212b9c55aca8c5fea14e9)
elseif(program STREQUAL "NASM")
set(program_name nasm)
set(program_version 2.15.05)
set(paths_to_search "${DOWNLOADS}/tools/nasm/nasm-${program_version}")
set(brew_package_name "nasm")
set(apt_package_name "nasm")
set(download_urls
"https://www.nasm.us/pub/nasm/releasebuilds/${program_version}/win32/nasm-${program_version}-win32.zip"
"https://fossies.org/windows/misc/nasm-${program_version}-win32.zip"
)
set(download_filename "nasm-${program_version}-win32.zip")
set(download_sha512 9412b8caa07e15eac8f500f6f8fab9f038d95dc25e0124b08a80645607cf5761225f98546b52eac7b894420d64f26c3cbf22c19cd286bbe583f7c964256c97ed)
elseif(program STREQUAL "YASM")
set(program_name yasm)
set(program_version 1.3.0.6.g1962)
set(tool_subdirectory 1.3.0.6)
set(brew_package_name "yasm")
set(apt_package_name "yasm")
set(download_urls "https://www.tortall.net/projects/yasm/snapshots/v${program_version}/yasm-${program_version}.exe")
set(download_filename "yasm-${program_version}.exe")
set(rename_binary_to "yasm.exe")
set(raw_executable ON)
set(download_sha512 c1945669d983b632a10c5ff31e86d6ecbff143c3d8b2c433c0d3d18f84356d2b351f71ac05fd44e5403651b00c31db0d14615d7f9a6ecce5750438d37105c55b)
elseif(program STREQUAL "GIT")
set(program_name git)
if(CMAKE_HOST_WIN32)
set(base_version 2.32.0)
set(program_version 2.32.0.2)
set(tool_subdirectory "git-${program_version}-2-windows")
set(download_urls "https://github.com/git-for-windows/git/releases/download/v${base_version}.windows.2/PortableGit-${program_version}-32-bit.7z.exe")
set(download_filename "PortableGit-${program_version}-32-bit.7z.exe")
set(download_sha512 867d8534972cbaf7a4224e25a14d484f8d17ef186f8d79e9a758afb90cf69541375cb7615a39702311f4809cb8371ef85c2b1a15bfffe9e48f0e597ac011b348)
set(paths_to_search
"${DOWNLOADS}/tools/${tool_subdirectory}/mingw32/bin"
"${DOWNLOADS}/tools/git/${tool_subdirectory}/mingw32/bin")
else()
set(brew_package_name "git")
set(apt_package_name "git")
endif()
elseif(program STREQUAL "GN")
set(program_name gn)
set(rename_binary_to "gn")
if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt")
file(READ "${CURRENT_HOST_INSTALLED_DIR}/share/gn/version.txt" program_version)
set(paths_to_search "${CURRENT_HOST_INSTALLED_DIR}/tools/gn")
else() # Old behavior
message("Consider adding vcpkg-tool-gn as a host dependency of this port or create an issue at https://github.com/microsoft/vcpkg/issues")
set(cipd_download_gn "https://chrome-infra-packages.appspot.com/dl/gn/gn")
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
set(supported_on_unix ON)
EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH)
if(HOST_ARCH STREQUAL "aarch64")
set(program_version "GkfFAfAUyE-qfeWkdUMaeM1Ov64Fk3SjSj9pwKqZX7gC")
set(gn_platform "linux-arm64")
set(download_sha512 "E88201309A12C00CE60137261B8E1A759780C81D1925B819583B16D2095A16A7D32EFB2AF36C1E1D6EAA142BF6A6A811847D3140E4E94967EE28F4ADF6373E4B")
else()
set(program_version "Fv1ENXodhXmEXy_xpZr2gQkVJh57w_IsbsrEJOU0_EoC")
set(gn_platform "linux-amd64")
set(download_sha512 "A7A5CD5633C5547EC1B1A95958486DDAAC91F1A65881EDC0AD8F74DF44E82F08BA74358E9A72DFCDDE6F534A6B9C9A430D3E16ACE2E4346C4D2E9113F7654B3F")
endif()
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
set(supported_on_unix ON)
EXEC_PROGRAM(uname ARGS -m OUTPUT_VARIABLE HOST_ARCH)
if(HOST_ARCH STREQUAL "arm64")
set(program_version "qMPtGq7xZlpb-lHjP-SK27ftT4X71WIvguuyx6X14DEC")
set(gn_platform "mac-arm64")
set(download_sha512 "D096FB958D017807427911089AB5A7655AED117F6851C0491AC8063CEDB544423122EF64DF4264ECA86C20A2BDE9E64D7B72DA7ED8C95C2BA79A68B8247D36B8")
else()
set(program_version "0x2juPLNfP9603GIyZrUfflxK6LiMcppLAoxEpYuIYoC")
set(gn_platform "mac-amd64")
set(download_sha512 "2696ECE7B2C8008CABDDF10024017E2ECF875F8679424E77052252BDDC83A2096DF3C61D89CD25120EF27E0458C8914BEEED9D418593BDBC4F6ED33A8D4C3DC5")
endif()
else()
if($ENV{PROCESSOR_ARCHITECTURE} STREQUAL "ARM64")
set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
set(gn_platform "windows-amd64")
set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
else() # AMD64
set(program_version "q5ExVHmXyD34Q_Tzb-aRxsPipO-e37-csVRhVM7IJh0C")
set(gn_platform "windows-amd64")
set(download_sha512 "FA764AA44EB6F48ED50E855B4DC1DD1ABE35E45FD4AAC7F059A35293A14894C1B591215E34FB0CE9362E646EA9463BA3B489EFB7EBBAA2693D14238B50E4E686")
endif()
endif()
endif()
set(tool_subdirectory "${program_version}")
set(download_urls "${cipd_download_gn}/${gn_platform}/+/${program_version}")
set(download_filename "gn-${gn_platform}.zip")
elseif(program STREQUAL "GO")
set(program_name go)
set(tool_subdirectory 1.16.6.windows-386)
set(paths_to_search ${DOWNLOADS}/tools/go/${tool_subdirectory}/go/bin)
set(brew_package_name "go")
set(apt_package_name "golang-go")
set(download_urls "https://dl.google.com/go/go${tool_subdirectory}.zip")
set(download_filename "go${tool_subdirectory}.zip")
set(download_sha512 2a1e539ed628c0cca5935d24d22cf3a7165f5c80e12a4003ac184deae6a6d0aa31f582f3e8257b0730adfc09aeec3a0e62f4732e658c312d5382170bcd8c94d8)
elseif(program STREQUAL "PYTHON3")
if(CMAKE_HOST_WIN32)
set(program_name python)
set(program_version 3.10.2)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
set(tool_subdirectory "python-${program_version}-x86")
set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-win32.zip")
set(download_filename "python-${program_version}-embed-win32.zip")
set(download_sha512 d647d7141d1b13c899671b882e686a1b1cc6f759e5b7428ec858cdffd9ef019c78fb0b989174b98f30cb696297bfeff3d171f7eaabb339f5154886c030b8e4d9)
else()
set(tool_subdirectory "python-${program_version}-x64")
set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}-embed-amd64.zip")
set(download_filename "python-${program_version}-embed-amd64.zip")
set(download_sha512 e04e14f3b5e96f120a3b0d5fac07b2982b9f3394aef4591b140e84ff97c8532e1f8bf3e613bdf5aec6afeac108b975e754bf9727354bcfaa6673fc89826eac37)
endif()
set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
vcpkg_list(SET post_install_command "${CMAKE_COMMAND}" -E rm python310._pth)
else()
set(program_name python3)
set(brew_package_name "python")
set(apt_package_name "python3")
endif()
elseif(program STREQUAL "PYTHON2")
if(CMAKE_HOST_WIN32)
set(program_name python)
set(program_version 2.7.18)
if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
include("${CURRENT_HOST_INSTALLED_DIR}/share/vcpkg-tool-python2/details.cmake")
else() # Old behavior
if (VCPKG_TARGET_ARCHITECTURE STREQUAL x86)
set(tool_subdirectory "python-${program_version}-x86")
set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.msi")
set(download_filename "python-${program_version}.msi")
set(download_sha512 2c112733c777ddbf189b0a54047a9d5851ebce0564cc38b9687d79ce6c7a09006109dbad8627fb1a60c3ad55e261db850d9dfa454af0533b460b2afc316fe115)
else()
set(tool_subdirectory "python-${program_version}-x64")
set(download_urls "https://www.python.org/ftp/python/${program_version}/python-${program_version}.amd64.msi")
set(download_filename "python-${program_version}.amd64.msi")
set(download_sha512 6a81a413b80fd39893e7444fd47efa455d240cbb77a456c9d12f7cf64962b38c08cfa244cd9c50a65947c40f936c6c8c5782f7236d7b92445ab3dd01e82af23e)
endif()
set(paths_to_search "${DOWNLOADS}/tools/python/${tool_subdirectory}")
endif()
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
# macOS includes Python 2.7 built-in as `python`
set(program_name python)
set(brew_package_name "python2")
else()
set(program_name python2)
set(apt_package_name "python")
endif()
elseif(program STREQUAL "RUBY")
set(program_name "ruby")
set(program_version 2.7.4-1)
set(paths_to_search "${DOWNLOADS}/tools/ruby/rubyinstaller-${program_version}-x86/bin")
set(download_urls "https://github.com/oneclick/rubyinstaller2/releases/download/RubyInstaller-${program_version}/rubyinstaller-${program_version}-x86.7z")
set(download_filename "rubyinstaller-${program_version}-x86.7z")
set(download_sha512 4bf459c987b407bdda328c52d95060bf6ad48fc3e5ed5f64d4b205c5b4153c7a00cb6f9da6c0bcd5f2e001e9dc3dda0b72269ec4afdeffd658b93c085cd1d859)
elseif(program STREQUAL "JOM")
set(program_name jom)
set(tool_subdirectory "jom-1.1.3")
set(paths_to_search "${DOWNLOADS}/tools/jom/${tool_subdirectory}")
set(download_urls
"https://download.qt.io/official_releases/jom/jom_1_1_3.zip"
"https://mirrors.ocf.berkeley.edu/qt/official_releases/jom/jom_1_1_3.zip"
)
set(download_filename "jom_1_1_3.zip")
set(download_sha512 5b158ead86be4eb3a6780928d9163f8562372f30bde051d8c281d81027b766119a6e9241166b91de0aa6146836cea77e5121290e62e31b7a959407840fc57b33)
elseif(program STREQUAL "7Z")
set(program_name 7z)
set(paths_to_search "${DOWNLOADS}/tools/7z/Files/7-Zip")
set(download_urls "https://7-zip.org/a/7z1900.msi")
set(download_filename "7z1900.msi")
set(download_sha512 f73b04e2d9f29d4393fde572dcf3c3f0f6fa27e747e5df292294ab7536ae24c239bf917689d71eb10cc49f6b9a4ace26d7c122ee887d93cc935f268c404e9067)
elseif(program STREQUAL "NINJA")
set(program_name ninja)
set(program_version 1.10.2)
set(supported_on_unix ON)
if(CMAKE_HOST_WIN32)
set(download_filename "ninja-win-${program_version}.zip")
set(tool_subdirectory "${program_version}-windows")
set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-win.zip")
set(download_sha512 6004140d92e86afbb17b49c49037ccd0786ce238f340f7d0e62b4b0c29ed0d6ad0bab11feda2094ae849c387d70d63504393714ed0a1f4d3a1f155af7a4f1ba3)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
set(download_filename "ninja-mac-${program_version}.zip")
set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-mac.zip")
set(tool_subdirectory "${program_version}-osx")
set(paths_to_search "${DOWNLOADS}/tools/ninja-${program_version}-osx")
set(download_sha512 bcd12f6a3337591306d1b99a7a25a6933779ba68db79f17c1d3087d7b6308d245daac08df99087ff6be8dc7dd0dcdbb3a50839a144745fa719502b3a7a07260b)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
set(paths_to_search "${DOWNLOADS}/tools/${tool_subdirectory}-freebsd")
set(supported_on_unix OFF)
else()
set(download_filename "ninja-linux-${program_version}.zip")
set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-linux.zip")
set(tool_subdirectory "${program_version}-linux")
set(paths_to_search "${DOWNLOADS}/tools/ninja-${program_version}-linux")
set(download_sha512 93e802e9c17fb59636cddde4bad1ddaadad624f4ecfee00d5c78790330a4e9d433180e795718cda27da57215ce643c3929cf72c85337ee019d868c56f2deeef3)
endif()
set(version_command --version)
elseif(program STREQUAL "NUGET")
set(program_name nuget)
set(tool_subdirectory "5.11.0")
set(paths_to_search "${DOWNLOADS}/tools/nuget-${tool_subdirectory}-windows")
set(brew_package_name "nuget")
set(download_urls "https://dist.nuget.org/win-x86-commandline/v5.11.0/nuget.exe")
set(rename_binary_to "nuget.exe")
set(download_filename "nuget.5.11.0.exe")
set(raw_executable ON)
set(download_sha512 06a337c9404dec392709834ef2cdbdce611e104b510ef40201849595d46d242151749aef65bc2d7ce5ade9ebfda83b64c03ce14c8f35ca9957a17a8c02b8c4b7)
elseif(program STREQUAL "MESON") # Should always be found!
set(program_name meson)
set(search_names meson meson.py)
set(interpreter PYTHON3)
set(apt_package_name "meson")
set(brew_package_name "meson")
set(version_command --version)
set(extra_search_args EXACT_VERSION_MATCH)
if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/meson/version.txt")
file(READ "${CURRENT_HOST_INSTALLED_DIR}/share/meson/version.txt" program_version)
set(paths_to_search "${CURRENT_HOST_INSTALLED_DIR}/tools/meson")
else() # Old behavior
set(program_version 0.58.1)
set(ref aeda7f249c4a5dbbecc52e44f382246a2377b5b0)
set(paths_to_search "${DOWNLOADS}/tools/meson/meson-${ref}")
set(download_urls "https://github.com/mesonbuild/meson/archive/${ref}.tar.gz")
set(download_filename "meson-${ref}.tar.gz")
set(download_sha512 18a012a45274dbb4582e99fd69d920f38831e788d9860f9553c64847bedb1c2010ae0b5c0ef4a4350c03f5e0f95aaa0395378e1208109b59640c1a70b1e202d2)
set(supported_on_unix ON)
endif()
elseif(program STREQUAL "FLEX" OR program STREQUAL "BISON")
if(CMAKE_HOST_WIN32)
set(program_version 2.5.25)
set(download_urls "https://github.com/lexxmark/winflexbison/releases/download/v${program_version}/win_flex_bison-${program_version}.zip")
set(download_filename "win_flex_bison-${program_version}.zip")
set(download_sha512 2a829eb05003178c89f891dd0a67add360c112e74821ff28e38feb61dac5b66e9d3d5636ff9eef055616aaf282ee8d6be9f14c6ae4577f60bdcec96cec9f364e)
set(tool_subdirectory "${program_version}")
if(program STREQUAL "FLEX")
set(program_name win_flex)
else()
set(program_name win_bison)
endif()
set(paths_to_search ${DOWNLOADS}/tools/win_flex/${program_version})
if(NOT EXISTS "${paths_to_search}/data/m4sugar/m4sugar.m4")
file(REMOVE_RECURSE "${paths_to_search}")
endif()
elseif(program STREQUAL "FLEX")
set(program_name flex)
set(apt_package_name flex)
set(brew_package_name flex)
else()
set(program_name bison)
set(apt_package_name bison)
set(brew_package_name bison)
if (APPLE)
set(paths_to_search /usr/local/opt/bison/bin)
endif()
endif()
elseif(program STREQUAL "CLANG")
set(program_name clang)
set(tool_subdirectory "clang-12.0.0")
set(program_version 12.0.0)
if(CMAKE_HOST_WIN32)
set(paths_to_search
# Support LLVM in Visual Studio 2019
"$ENV{LLVMInstallDir}/x64/bin"
"$ENV{LLVMInstallDir}/bin"
"$ENV{VCINSTALLDIR}/Tools/Llvm/x64/bin"
"$ENV{VCINSTALLDIR}/Tools/Llvm/bin"
"${DOWNLOADS}/tools/${tool_subdirectory}-windows/bin"
"${DOWNLOADS}/tools/clang/${tool_subdirectory}/bin")
if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
set(host_arch "$ENV{PROCESSOR_ARCHITEW6432}")
else()
set(host_arch "$ENV{PROCESSOR_ARCHITECTURE}")
endif()
if(host_arch MATCHES "64")
set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win64.exe")
set(download_filename "LLVM-${program_version}-win64.7z.exe")
set(download_sha512 67a9b54abad5143fa5f79f0cfc184be1394c9fc894fa9cee709943cb6ccbde8f0ea6003d8fcc20eccf035631abe4009cc0f694ac84e7879331cebba8125e4c7f)
else()
set(download_urls "https://github.com/llvm/llvm-project/releases/download/llvmorg-${program_version}/LLVM-${program_version}-win32.exe")
set(download_filename "LLVM-${program_version}-win32.7z.exe")
set(download_sha512 92fa5252fd08c1414ee6d71e2544cd2c44872124c47225f8d98b3af711d20e699f2888bc30642dfd00e005013da1607a593674fb4878951cc434694f9a119199)
endif()
endif()
set(brew_package_name "llvm")
set(apt_package_name "clang")
elseif(program STREQUAL "GPERF")
set(program_name gperf)
set(program_version 3.0.1)
set(paths_to_search "${DOWNLOADS}/tools/gperf/bin")
set(download_urls "https://sourceforge.net/projects/gnuwin32/files/gperf/${program_version}/gperf-${program_version}-bin.zip/download")
set(download_filename "gperf-${program_version}-bin.zip")
set(download_sha512 3f2d3418304390ecd729b85f65240a9e4d204b218345f82ea466ca3d7467789f43d0d2129fcffc18eaad3513f49963e79775b10cc223979540fa2e502fe7d4d9)
elseif(program STREQUAL "GASPREPROCESSOR")
set(raw_executable true)
set(program_name gas-preprocessor)
set(tool_subdirectory "4daa6115")
set(interpreter PERL)
set(search_names "gas-preprocessor.pl")
set(paths_to_search "${DOWNLOADS}/tools/gas-preprocessor/${tool_subdirectory}")
set(rename_binary_to "gas-preprocessor.pl")
set(download_urls "https://raw.githubusercontent.com/FFmpeg/gas-preprocessor/4daa611556a0558dfe537b4f7ad80f7e50a079c1/gas-preprocessor.pl")
set(download_filename "gas-preprocessor-${tool_subdirectory}.pl")
set(download_sha512 2737ba3c1cf85faeb1fbfe015f7bad170f43a857a50a1b3d81fa93ba325d481f73f271c5a886ff8b7eef206662e19f0e9ef24861dfc608b67b8ea8a2062dc061)
elseif(program STREQUAL "DARK")
set(program_name dark)
set(tool_subdirectory "wix311-binaries")
set(paths_to_search "${DOWNLOADS}/tools/dark/${tool_subdirectory}")
set(download_urls "https://github.com/wixtoolset/wix3/releases/download/wix311rtm/wix311-binaries.zip")
set(download_filename "wix311-binaries.zip")
set(download_sha512 74f0fa29b5991ca655e34a9d1000d47d4272e071113fada86727ee943d913177ae96dc3d435eaf494d2158f37560cd4c2c5274176946ebdb17bf2354ced1c516)
elseif(program STREQUAL "SCONS")
set(program_name scons)
set(program_version 4.1.0)
set(tool_subdirectory "${program_version}")
set(interpreter PYTHON2)
set(search_names "scons.py")
set(download_urls "https://sourceforge.net/projects/scons/files/scons-local-${program_version}.zip/download")
set(download_filename "scons-local-${program_version}.zip")
set(download_sha512 b173176ce8aca25039c64fcc68ec1b9ad31e03a926fd545e7631b3f9b374d914adffc593f505e3e7e2867b0ffe85e8deb0b39afe314edf05d02974ce5db1badb)
elseif(program STREQUAL "SWIG")
set(program_version 4.0.2)
set(program_name swig)
if(CMAKE_HOST_WIN32)
vcpkg_list(SET sourceforge_args
REPO swig/swigwin
REF "swigwin-${program_version}"
FILENAME "swigwin-${program_version}.zip"
SHA512 b8f105f9b9db6acc1f6e3741990915b533cd1bc206eb9645fd6836457fd30789b7229d2e3219d8e35f2390605ade0fbca493ae162ec3b4bc4e428b57155db03d
NO_REMOVE_ONE_LEVEL
WORKING_DIRECTORY "${DOWNLOADS}/tools/swig"
)
set(tool_subdirectory "b8f105f9b9-f0518bc3b7/swigwin-${program_version}")
else()
set(apt_package_name "swig")
set(brew_package_name "swig")
endif()
elseif(program STREQUAL "DOXYGEN")
set(program_name doxygen)
set(program_version 1.9.1)
vcpkg_list(SET sourceforge_args
REPO doxygen
REF "rel-${program_version}"
FILENAME "doxygen-${program_version}.windows.bin.zip"
SHA512 c3eeb6b9fa4eab70fb6b0864fbbf94fb8050f3fee38d117cf470921a80e3569cc1c8b0272604d6731e05f01790cfaa70e159bec5d0882fc4f2d8ae4a5d52a21b
NO_REMOVE_ONE_LEVEL
WORKING_DIRECTORY "${DOWNLOADS}/tools/doxygen"
)
set(tool_subdirectory c3eeb6b9fa-76d69c6db5)
elseif(program STREQUAL "BAZEL")
set(program_name bazel)
set(program_version 4.2.2)
set(rename_binary_to "bazel")
if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
set(supported_on_unix ON)
set(tool_subdirectory "${program_version}-linux")
set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
set(download_filename "bazel-${tool_subdirectory}-x86_64")
set(raw_executable ON)
set(download_sha512 f38619e054df78cab38278a5901b2798f2e25b5cec53358d98278002e713d225fd3df96a209b7f22a2357835a279cee8ef1768e10561b3e9fe6361f324563bb9)
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
set(supported_on_unix ON)
set(tool_subdirectory "${program_version}-darwin")
set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64")
set(download_filename "bazel-${tool_subdirectory}-x86_64")
set(raw_executable ON)
set(download_sha512 a3fd8f9d71b0669d742439200f27ee0a3891c1f248df62c841ebb2b416a47534562f429f8a08793b074e9b74f2ede3d97a7e13ac9921c7ee2dc6a2dca8b7f275)
else()
set(tool_subdirectory "${program_version}-windows")
set(download_urls "https://github.com/bazelbuild/bazel/releases/download/${program_version}/bazel-${tool_subdirectory}-x86_64.zip")
set(download_filename "bazel-${tool_subdirectory}-x86_64.zip")
set(download_sha512 8a8196e242964114316232818cb81bfa19ebfd3a029ebf550a241e33b22a6e9ed636dade06411a8706c05c4e73def0bc8d7f45ff0ec5478bcc5de21b5638204d)
endif()
elseif(program STREQUAL "ARIA2")
set(program_name aria2c)
set(program_version 1.35.0)
set(paths_to_search "${DOWNLOADS}/tools/aria2c/aria2-${program_version}-win-32bit-build1")
set(download_urls "https://github.com/aria2/aria2/releases/download/release-${program_version}/aria2-${program_version}-win-32bit-build1.zip")
set(download_filename "aria2-${program_version}-win-32bit-build1.zip")
set(download_sha512 933537cad820b1cecf43a9eeca7e1b241dd7b1c902ee942441a166f2c38845f16046321efbdfa2f83c7e9fc50c7ecc5da6fd00e0c6e2124c07d3b783aa5092a4)
elseif(program STREQUAL "PKGCONFIG")
set(program_name pkg-config)
if(DEFINED ENV{PKG_CONFIG})
debug_message(STATUS "PKG_CONFIG found in ENV! Using $ENV{PKG_CONFIG}")
set(PKGCONFIG "$ENV{PKG_CONFIG}" CACHE INTERNAL "")
set(PKGCONFIG "${PKGCONFIG}" PARENT_SCOPE)
return()
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "OpenBSD")
# As of 6.8, the OpenBSD specific pkg-config doesn't support {pcfiledir}
set(supported_on_unix ON)
set(rename_binary_to "pkg-config")
set(program_version 0.29.2.1)
set(raw_executable ON)
set(download_filename "pkg-config.openbsd")
set(tool_subdirectory "openbsd")
set(download_urls "https://raw.githubusercontent.com/jgilje/pkg-config-openbsd/master/pkg-config")
set(download_sha512 b7ec9017b445e00ae1377e36e774cf3f5194ab262595840b449832707d11e443a102675f66d8b7e8b2e2f28cebd6e256835507b1e0c69644cc9febab8285080b)
set(version_command --version)
elseif(CMAKE_HOST_WIN32)
if(NOT EXISTS "${PKGCONFIG}")
set(VERSION 0.29.2-3)
set(program_version git-9.0.0.6373.5be8fcd83-1)
vcpkg_acquire_msys(
PKGCONFIG_ROOT
NO_DEFAULT_PACKAGES
DIRECT_PACKAGES
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-pkg-config-${VERSION}-any.pkg.tar.zst"
0c086bf306b6a18988cc982b3c3828c4d922a1b60fd24e17c3bead4e296ee6de48ce148bc6f9214af98be6a86cb39c37003d2dcb6561800fdf7d0d1028cf73a4
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-libwinpthread-${program_version}-any.pkg.tar.zst"
c89c27b5afe4cf5fdaaa354544f070c45ace5e9d2f2ebb4b956a148f61681f050e67976894e6f52e42e708dadbf730fee176ac9add3c9864c21249034c342810
)
endif()
set("${program}" "${PKGCONFIG_ROOT}/mingw32/bin/pkg-config.exe" CACHE INTERNAL "")
set("${program}" "${${program}}" PARENT_SCOPE)
return()
else()
set(brew_package_name pkg-config)
set(apt_package_name pkg-config)
set(paths_to_search "/bin" "/usr/bin" "/usr/local/bin")
endif()
else()
message(FATAL "unknown tool ${program} -- unable to acquire.")
endif()
if("${program_name}" STREQUAL "")
message(FATAL_ERROR "Internal error: failed to initialize program_name for program ${program}")
endif()
set(full_subdirectory "${DOWNLOADS}/tools/${program_name}/${tool_subdirectory}")
if(NOT "${tool_subdirectory}" STREQUAL "")
list(APPEND paths_to_search ${full_subdirectory})
endif()
if("${full_subdirectory}" MATCHES [[^(.*)[/\\]+$]])
# remove trailing slashes, which may turn into a trailing `\` which CMake _does not like_
set(full_subdirectory "${CMAKE_MATCH_1}")
endif()
if("${search_names}" STREQUAL "")
set(search_names "${program_name}")
endif()
z_vcpkg_find_acquire_program_find_internal("${program}"
INTERPRETER "${interpreter}"
PATHS ${paths_to_search}
NAMES ${search_names}
)
if(NOT ${program})
z_vcpkg_find_acquire_program_find_external("${program}"
${extra_search_args}
PROGRAM_NAME "${program_name}"
MIN_VERSION "${program_version}"
INTERPRETER "${interpreter}"
NAMES ${search_names}
VERSION_COMMAND ${version_command}
)
endif()
if(NOT ${program})
if(NOT VCPKG_HOST_IS_WINDOWS AND NOT supported_on_unix)
set(example ".")
if(NOT "${brew_package_name}" STREQUAL "" AND VCPKG_HOST_IS_OSX)
set(example ":\n brew install ${brew_package_name}")
elseif(NOT "${apt_package_name}" STREQUAL "" AND VCPKG_HOST_IS_LINUX)
set(example ":\n sudo apt-get install ${apt_package_name}")
endif()
message(FATAL_ERROR "Could not find ${program_name}. Please install it via your package manager${example}")
endif()
if(NOT "${sourceforge_args}" STREQUAL "")
# Locally change editable to suppress re-extraction each time
set(_VCPKG_EDITABLE 1)
vcpkg_from_sourceforge(OUT_SOURCE_PATH SFPATH ${sourceforge_args})
unset(_VCPKG_EDITABLE)
else()
vcpkg_download_distfile(archive_path
URLS ${download_urls}
SHA512 "${download_sha512}"
FILENAME "${download_filename}"
)
file(MAKE_DIRECTORY "${full_subdirectory}")
if(raw_executable)
if(NOT "${rename_binary_to}" STREQUAL "")
file(INSTALL "${archive_path}"
DESTINATION "${full_subdirectory}"
RENAME "${rename_binary_to}"
FILE_PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE
)
else()
file(COPY "${archive_path}"
DESTINATION "${full_subdirectory}"
FILE_PERMISSIONS
OWNER_READ OWNER_WRITE OWNER_EXECUTE
GROUP_READ GROUP_EXECUTE
WORLD_READ WORLD_EXECUTE
)
endif()
else()
cmake_path(GET download_filename EXTENSION archive_extension)
string(TOLOWER "${archive_extension}" archive_extension)
if("${archive_extension}" MATCHES [[\.msi$]])
cmake_path(NATIVE_PATH archive_path archive_native_path)
cmake_path(NATIVE_PATH full_subdirectory destination_native_path)
vcpkg_execute_in_download_mode(
COMMAND msiexec
/a "${archive_native_path}"
/qn "TARGETDIR=${destination_native_path}"
WORKING_DIRECTORY "${DOWNLOADS}"
)
elseif("${archive_extension}" MATCHES [[\.7z\.exe$]])
vcpkg_find_acquire_program(7Z)
vcpkg_execute_in_download_mode(
COMMAND ${7Z} x
"${archive_path}"
"-o${full_subdirectory}"
-y -bso0 -bsp0
WORKING_DIRECTORY "${full_subdirectory}"
)
else()
vcpkg_execute_in_download_mode(
COMMAND "${CMAKE_COMMAND}" -E tar xzf "${archive_path}"
WORKING_DIRECTORY "${full_subdirectory}"
)
endif()
endif()
endif()
if(NOT "${post_install_command}" STREQUAL "")
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND ${post_install_command}
WORKING_DIRECTORY "${full_subdirectory}"
LOGNAME "${program}-tool-post-install"
)
endif()
unset("${program}")
unset("${program}" CACHE)
z_vcpkg_find_acquire_program_find_internal("${program}"
INTERPRETER "${interpreter}"
PATHS ${paths_to_search}
NAMES ${search_names}
)
if(NOT ${program})
message(FATAL_ERROR "Unable to find ${program}")
endif()
endif()
set("${program}" "${${program}}" PARENT_SCOPE)
endfunction()

124
externals/vcpkg/scripts/cmake/vcpkg_find_fortran.cmake vendored Executable file
View File

@@ -0,0 +1,124 @@
function(vcpkg_find_fortran out_var)
if("${ARGC}" GREATER "1")
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra args: ${ARGN}")
endif()
vcpkg_list(SET additional_cmake_args)
set(CMAKE_BINARY_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}")
set(CMAKE_CURRENT_BINARY_DIR "${CMAKE_BINARY_DIR}")
set(CMAKE_PLATFORM_INFO_DIR "${CMAKE_BINARY_DIR}/Platform")
include(CMakeDetermineFortranCompiler)
if(NOT CMAKE_Fortran_COMPILER AND "${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}" STREQUAL "")
# If a user uses their own VCPKG_CHAINLOAD_TOOLCHAIN_FILE, they _must_ figure out fortran on their own.
if(WIN32)
message(STATUS "No Fortran compiler found on the PATH. Using MinGW gfortran!")
# If no Fortran compiler is on the path we switch to use gfortan from MinGW within vcpkg
if("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x86")
set(mingw_path mingw32)
set(machine_flag -m32)
vcpkg_acquire_msys(msys_root
DIRECT_PACKAGES
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-gcc-fortran-11.2.0-8-any.pkg.tar.zst"
9337dafdeb4f5eaf41bf13441c345b999dd0561b4fc757a67b4e362c3e0afea5828cd68b35d2823c545d74ea81b2c34bd1624f97817690a2931f3a890b5273bd
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-gcc-libgfortran-11.2.0-8-any.pkg.tar.zst"
3e6396eb4dcbe730bb63f4534e25b654008be49f0e113cf34cfb640dba3f67b508a6f5c78f7ab1cc57686936e709bc37a1fdbc20df5ee17fd708a21c1b844af4
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-gcc-libs-11.2.0-8-any.pkg.tar.zst"
bdf253bb627cfc108407ea0d1f5fc643da0b229a8f7fcc346fcdf7709e0ffbf8d1f75bdea755116c6b30834d1c764496a23c0546ef1048075d312136c6ebe9d9
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-gmp-6.2.1-3-any.pkg.tar.zst"
10787443380a89a3491596946354645899daad07bc159ffcee96243cb51637dfbc163d52751ffd14682b66be8fd65c0379c642df16132f16a80709c4af921bac
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-libwinpthread-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
c89c27b5afe4cf5fdaaa354544f070c45ace5e9d2f2ebb4b956a148f61681f050e67976894e6f52e42e708dadbf730fee176ac9add3c9864c21249034c342810
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-winpthreads-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
85980183879da0d0ea74b9ad1fdfb09e5ed9d2e2212877d47d0f621ce721566e205be0b1913a643d0a95b256441e0bafd803fa9c848a8203dffd7d72109e32c2
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-mpc-1.2.1-1-any.pkg.tar.zst"
f4cda83c26bf4225a8c387e0710ea086896e9c89e7863b9a2947982636664b64ffa880cbddfe6d85f8cf7cb3be18296b04874026cdf8b1b702a2820dad135ba4
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-mpfr-4.1.0.p13-1-any.pkg.tar.zst"
038a1cc6bb080d415b9fc19965a1f1c9419f5c42023e29c87f97b4f630c152602abb706036aa3e0f02e337e9d7ab3a43bd7b1234b3775a43ffceb348e79bac1a
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-gcc-11.2.0-8-any.pkg.tar.zst"
a6183f0fc80c2e37316b6eb60fdbdccc30b865053dad270c9c96e93cd6fdb2af28a75f981ac1de2fdc22a47494cdb54b8d41d4ecffdf1b1d3a54e85437c20dcf
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-binutils-2.37-4-any.pkg.tar.zst"
1c2fbb8b94778c562aed01010c06c804d1cc2c446837879e4f1187470259adaecd86699b084c69e254d98201333db69a55126ea2cd0c188e55c9af849c37315a
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-crt-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
495834d72313021b7553d92a897932f5efc66a0f6f79ebeec574ecd7ddd23e0eed9aacb32601007606abb10b44ba7c7c1ccf6d3437a4338839b2d7b1792327f9
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-headers-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
7959ae9267306c862b8b23be2ab21498f6e7890c936feae3ec9cf5607434e87e446f7c75ff7bd975f23aa24eb1c23d6068957f6af4e8c358f5f4861db64248b8
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-libiconv-1.16-2-any.pkg.tar.zst"
fe48d0d3c582fee1edb178425c6daf619d86362442c729047b3c356be26491164f92be1d87950429d2faca4ed3cf76cb4aafef1af3c87b780eee85ee85a4b4c5
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-windows-default-manifest-6.4-3-any.pkg.tar.xz"
5b99abc55eaa74cf85ca64a9c91542554cb5c1098bc71effba9bd36242694cfd348503fcd3507fb9ba97486108c092c925e2f38cd744493386b3dc9ab28bc526
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-zlib-1.2.11-9-any.pkg.tar.zst"
3e461e835641a2a755a42221011871f8a1ed5fa4b6b23c74db286e29bbcfa2fcd30d4a7c41216728df62c9131dbc1e554720da633ed6b2ba3d6f2b6d5d50a300
"https://repo.msys2.org/mingw/i686/mingw-w64-i686-zstd-1.5.2-1-any.pkg.tar.zst"
8e27911a2a5884faa95e1c55058ca15f233d432ed8aa607b04a019758aa21f1357bd5de5ce8709fa47f4fbed6eb00fdfd94e7e2d82023bbc1f1653e95f439e0a
)
elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x64")
set(mingw_path mingw64)
set(machine_flag -m64)
vcpkg_acquire_msys(msys_root
DIRECT_PACKAGES
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-fortran-11.2.0-8-any.pkg.tar.zst"
d56483e090f86410b87526dda7774e010d0bd6beda97edcaeb1dead1128fd5ad870bc761a8a190759c48d58c2526b6975fb849f9c03a6be193741a0fd0bf2812
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-libgfortran-11.2.0-8-any.pkg.tar.zst"
8537b55633bc83d81d528378590e417ffe8c26b6c327d8b6d7ba50a8b5f4e090fbe2dc500deb834120edf25ac3c493055f4de2dc64bde061be23ce0f625a8893
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-libs-11.2.0-8-any.pkg.tar.zst"
2481f7c8db7cca549911bc71715af86ca287ffed6d673c9a6c3a4c792b68899a129dd959214af7067f434e74fc518c43749e7d928cbd2232ab4fbc65880dad98
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gmp-6.2.1-3-any.pkg.tar.zst"
d0d4ed1a046b64f437e72bbcf722b30311dde5f5e768a520141423fc0a3127b116bd62cfd4b5cf5c01a71ee0f9cf6479fcc31277904652d8f6ddbf16e33e0b72
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libwinpthread-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
a2c9e60d23b1310a6cec1fadd2b15a8c07223f3fe90d41b1579e9fc27ee2b0b408456291a55fad54a156e6a247efc20f6fcc247cc567e64fe190938aa3b672e9
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-winpthreads-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
be03433e6006166e5b4794f2a01730cdb6c9f19fa96bd10a8bc50cf06ad389cbc66d44ea3eda46f53c3b2c89e2fc86aec21a372828e9527b24480c87ed88348c
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-mpc-1.2.1-1-any.pkg.tar.zst"
f2c137dbb0b6feea68dde9739c38b44dcb570324e3947adf991028e8f63c9ff50a11f47be15b90279ff40bcac7f320d952cfc14e69ba8d02cf8190c848d976a1
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-mpfr-4.1.0.p13-1-any.pkg.tar.zst"
a1425169c1570dbd736c31d50bedfab88636bf9565376e2da566be67fcc771e6c76f95895f382d81097e7c0580acb42aa49e34dec5d7a868d73a5dc6a7461c95
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-gcc-11.2.0-8-any.pkg.tar.zst"
26ab2cab684206978a254f1e1595b1ce688e6db12e57ed1d243a5f1b3b21b314f640c7c6fe90eedccb6b9788e1886415ca3290d03b1e71f67f8a99108068336a
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-binutils-2.37-4-any.pkg.tar.zst"
f09ea70810fb337d7f3ec673342ab90df511e6af451e273fe88fe41a2f30bd972b79c830b61bb5388743d00a0ba7885503e143987413db5170c4befffef66303
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-crt-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
63d081fedd1f70e8d58670d4d0698535a67f04c31caf02d0b23026ac23fc5064e9423d73c79854bbce41cc99dd0b70e4137af3a609e05cdd867fdcea120d356e
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-headers-git-9.0.0.6373.5be8fcd83-1-any.pkg.tar.zst"
05860f2bcfacf54089b750099f9ddc52d9b4b8ae8f69028a198dfb51fab09c37a941ae551e5d361a2a11302d48bd4fa95c44131ddee4c1df5a14f28013398f63
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-libiconv-1.16-2-any.pkg.tar.zst"
542ed5d898a57a79d3523458f8f3409669b411f87d0852bb566d66f75c96422433f70628314338993461bcb19d4bfac4dadd9d21390cb4d95ef0445669288658
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-windows-default-manifest-6.4-3-any.pkg.tar.xz"
77d02121416e42ff32a702e21266ce9031b4d8fc9ecdb5dc049d92570b658b3099b65d167ca156367d17a76e53e172ca52d468e440c2cdfd14701da210ffea37
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-zlib-1.2.11-9-any.pkg.tar.zst"
f386d3a8d8c169a62a4580af074b7fdc0760ef0fde22ef7020a349382dd374a9e946606c757d12da1c1fe68baf5e2eaf459446e653477035a63e0e20df8f4aa0
"https://repo.msys2.org/mingw/x86_64/mingw-w64-x86_64-zstd-1.5.2-1-any.pkg.tar.zst"
38ec5ca99c5b955bf8a892a3edaf4e18572977736809b7671c554526b13cb4e53d45c5b83e37e0fb7628483ba98831b3203e3e404dac720d5b2ed95cfe4505c4
)
else()
message(FATAL_ERROR "Unknown architecture '${VCPKG_TARGET_ARCHITECTURE}' for MinGW Fortran build!")
endif()
set(mingw_bin "${msys_root}/${mingw_path}/bin")
vcpkg_add_to_path(PREPEND "${mingw_bin}")
vcpkg_list(APPEND additional_cmake_args
-DCMAKE_GNUtoMS=ON
"-DCMAKE_Fortran_COMPILER=${mingw_bin}/gfortran.exe"
"-DCMAKE_C_COMPILER=${mingw_bin}/gcc.exe"
"-DCMAKE_Fortran_FLAGS_INIT:STRING= -mabi=ms ${machine_flag} ${VCPKG_Fortran_FLAGS}")
# This is for private use by vcpkg-gfortran
set(vcpkg_find_fortran_MSYS_ROOT "${msys_root}" PARENT_SCOPE)
set(VCPKG_USE_INTERNAL_Fortran TRUE PARENT_SCOPE)
set(VCPKG_POLICY_SKIP_DUMPBIN_CHECKS enabled PARENT_SCOPE)
set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake" PARENT_SCOPE) # Switching to MinGW toolchain for Fortran
if(VCPKG_CRT_LINKAGE STREQUAL "static")
set(VCPKG_CRT_LINKAGE dynamic PARENT_SCOPE)
message(STATUS "VCPKG_CRT_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic CRT linkage")
endif()
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
set(VCPKG_LIBRARY_LINKAGE dynamic PARENT_SCOPE)
message(STATUS "VCPKG_LIBRARY_LINKAGE linkage for ${PORT} using vcpkg's internal gfortran cannot be static due to linking against MinGW libraries. Forcing dynamic library linkage")
endif()
else()
message(FATAL_ERROR "Unable to find a Fortran compiler using 'CMakeDetermineFortranCompiler'. Please install one (e.g. gfortran) and make it available on the PATH!")
endif()
endif()
set("${out_var}" "${additional_cmake_args}" PARENT_SCOPE)
endfunction()

186
externals/vcpkg/scripts/cmake/vcpkg_fixup_cmake_targets.cmake vendored Executable file
View File

@@ -0,0 +1,186 @@
function(vcpkg_fixup_cmake_targets)
if(Z_VCPKG_CMAKE_CONFIG_FIXUP_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake-config; using both vcpkg-cmake-config and vcpkg_fixup_cmake_targets in the same port is unsupported.")
endif()
cmake_parse_arguments(PARSE_ARGV 0 arg "DO_NOT_DELETE_PARENT_CONFIG_PATH;NO_PREFIX_CORRECTION" "CONFIG_PATH;TARGET_PATH;TOOLS_PATH" "")
if(arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "vcpkg_fixup_cmake_targets was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT arg_TARGET_PATH)
set(arg_TARGET_PATH share/${PORT})
endif()
if(NOT arg_TOOLS_PATH)
set(arg_TOOLS_PATH tools/${PORT})
endif()
string(REPLACE "." "\\." EXECUTABLE_SUFFIX "${VCPKG_TARGET_EXECUTABLE_SUFFIX}")
set(DEBUG_SHARE ${CURRENT_PACKAGES_DIR}/debug/${arg_TARGET_PATH})
set(RELEASE_SHARE ${CURRENT_PACKAGES_DIR}/${arg_TARGET_PATH})
if(arg_CONFIG_PATH AND NOT RELEASE_SHARE STREQUAL "${CURRENT_PACKAGES_DIR}/${arg_CONFIG_PATH}")
if(arg_CONFIG_PATH STREQUAL "share")
file(RENAME ${CURRENT_PACKAGES_DIR}/debug/share ${CURRENT_PACKAGES_DIR}/debug/share2)
file(RENAME ${CURRENT_PACKAGES_DIR}/share ${CURRENT_PACKAGES_DIR}/share2)
set(arg_CONFIG_PATH share2)
endif()
set(DEBUG_CONFIG ${CURRENT_PACKAGES_DIR}/debug/${arg_CONFIG_PATH})
set(RELEASE_CONFIG ${CURRENT_PACKAGES_DIR}/${arg_CONFIG_PATH})
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
if(NOT EXISTS ${DEBUG_CONFIG})
message(FATAL_ERROR "'${DEBUG_CONFIG}' does not exist.")
endif()
# This roundabout handling enables CONFIG_PATH share
file(MAKE_DIRECTORY ${DEBUG_SHARE})
file(GLOB FILES ${DEBUG_CONFIG}/*)
file(COPY ${FILES} DESTINATION ${DEBUG_SHARE})
file(REMOVE_RECURSE ${DEBUG_CONFIG})
endif()
file(GLOB FILES ${RELEASE_CONFIG}/*)
file(COPY ${FILES} DESTINATION ${RELEASE_SHARE})
file(REMOVE_RECURSE ${RELEASE_CONFIG})
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
get_filename_component(DEBUG_CONFIG_DIR_NAME ${DEBUG_CONFIG} NAME)
string(TOLOWER "${DEBUG_CONFIG_DIR_NAME}" DEBUG_CONFIG_DIR_NAME)
if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
file(REMOVE_RECURSE ${DEBUG_CONFIG})
else()
get_filename_component(DEBUG_CONFIG_PARENT_DIR ${DEBUG_CONFIG} DIRECTORY)
get_filename_component(DEBUG_CONFIG_DIR_NAME ${DEBUG_CONFIG_PARENT_DIR} NAME)
string(TOLOWER "${DEBUG_CONFIG_DIR_NAME}" DEBUG_CONFIG_DIR_NAME)
if(DEBUG_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
file(REMOVE_RECURSE ${DEBUG_CONFIG_PARENT_DIR})
endif()
endif()
endif()
get_filename_component(RELEASE_CONFIG_DIR_NAME ${RELEASE_CONFIG} NAME)
string(TOLOWER "${RELEASE_CONFIG_DIR_NAME}" RELEASE_CONFIG_DIR_NAME)
if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
file(REMOVE_RECURSE ${RELEASE_CONFIG})
else()
get_filename_component(RELEASE_CONFIG_PARENT_DIR ${RELEASE_CONFIG} DIRECTORY)
get_filename_component(RELEASE_CONFIG_DIR_NAME ${RELEASE_CONFIG_PARENT_DIR} NAME)
string(TOLOWER "${RELEASE_CONFIG_DIR_NAME}" RELEASE_CONFIG_DIR_NAME)
if(RELEASE_CONFIG_DIR_NAME STREQUAL "cmake" AND NOT arg_DO_NOT_DELETE_PARENT_CONFIG_PATH)
file(REMOVE_RECURSE ${RELEASE_CONFIG_PARENT_DIR})
endif()
endif()
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
if(NOT EXISTS "${DEBUG_SHARE}")
message(FATAL_ERROR "'${DEBUG_SHARE}' does not exist.")
endif()
endif()
file(GLOB_RECURSE UNUSED_FILES
"${DEBUG_SHARE}/*[Tt]argets.cmake"
"${DEBUG_SHARE}/*[Cc]onfig.cmake"
"${DEBUG_SHARE}/*[Cc]onfigVersion.cmake"
"${DEBUG_SHARE}/*[Cc]onfig-version.cmake"
)
if(UNUSED_FILES)
file(REMOVE ${UNUSED_FILES})
endif()
file(GLOB_RECURSE RELEASE_TARGETS
"${RELEASE_SHARE}/*-release.cmake"
)
foreach(RELEASE_TARGET IN LISTS RELEASE_TARGETS)
file(READ ${RELEASE_TARGET} _contents)
string(REPLACE "${CURRENT_INSTALLED_DIR}" "\${_IMPORT_PREFIX}" _contents "${_contents}")
string(REGEX REPLACE "\\\${_IMPORT_PREFIX}/bin/([^ \"]+${EXECUTABLE_SUFFIX})" "\${_IMPORT_PREFIX}/${arg_TOOLS_PATH}/\\1" _contents "${_contents}")
file(WRITE ${RELEASE_TARGET} "${_contents}")
endforeach()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
file(GLOB_RECURSE DEBUG_TARGETS
"${DEBUG_SHARE}/*-debug.cmake"
)
foreach(DEBUG_TARGET IN LISTS DEBUG_TARGETS)
file(RELATIVE_PATH DEBUG_TARGET_REL "${DEBUG_SHARE}" "${DEBUG_TARGET}")
file(READ ${DEBUG_TARGET} _contents)
string(REPLACE "${CURRENT_INSTALLED_DIR}" "\${_IMPORT_PREFIX}" _contents "${_contents}")
string(REGEX REPLACE "\\\${_IMPORT_PREFIX}/bin/([^ \";]+${EXECUTABLE_SUFFIX})" "\${_IMPORT_PREFIX}/${arg_TOOLS_PATH}/\\1" _contents "${_contents}")
string(REPLACE "\${_IMPORT_PREFIX}/lib" "\${_IMPORT_PREFIX}/debug/lib" _contents "${_contents}")
string(REPLACE "\${_IMPORT_PREFIX}/bin" "\${_IMPORT_PREFIX}/debug/bin" _contents "${_contents}")
file(WRITE ${RELEASE_SHARE}/${DEBUG_TARGET_REL} "${_contents}")
file(REMOVE ${DEBUG_TARGET})
endforeach()
endif()
#Fix ${_IMPORT_PREFIX} in cmake generated targets and configs;
#Since those can be renamed we have to check in every *.cmake
file(GLOB_RECURSE MAIN_CMAKES "${RELEASE_SHARE}/*.cmake")
foreach(MAIN_CMAKE IN LISTS MAIN_CMAKES)
file(READ ${MAIN_CMAKE} _contents)
#This correction is not correct for all cases. To make it correct for all cases it needs to consider
#original folder deepness to CURRENT_PACKAGES_DIR in comparison to the moved to folder deepness which
#is always at least (>=) 2, e.g. share/${PORT}. Currently the code assumes it is always 2 although
#this requirement is only true for the *Config.cmake. The targets are not required to be in the same
#folder as the *Config.cmake!
if(NOT arg_NO_PREFIX_CORRECTION)
string(REGEX REPLACE
"get_filename_component\\(_IMPORT_PREFIX \"\\\${CMAKE_CURRENT_LIST_FILE}\" PATH\\)(\nget_filename_component\\(_IMPORT_PREFIX \"\\\${_IMPORT_PREFIX}\" PATH\\))*"
"get_filename_component(_IMPORT_PREFIX \"\${CMAKE_CURRENT_LIST_FILE}\" PATH)\nget_filename_component(_IMPORT_PREFIX \"\${_IMPORT_PREFIX}\" PATH)\nget_filename_component(_IMPORT_PREFIX \"\${_IMPORT_PREFIX}\" PATH)"
_contents "${_contents}") # see #1044 for details why this replacement is necessary. See #4782 why it must be a regex.
string(REGEX REPLACE
"get_filename_component\\(PACKAGE_PREFIX_DIR \"\\\${CMAKE_CURRENT_LIST_DIR}/\\.\\./(\\.\\./)*\" ABSOLUTE\\)"
"get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/../../\" ABSOLUTE)"
_contents "${_contents}")
string(REGEX REPLACE
"get_filename_component\\(PACKAGE_PREFIX_DIR \"\\\${CMAKE_CURRENT_LIST_DIR}/\\.\\.((\\\\|/)\\.\\.)*\" ABSOLUTE\\)"
"get_filename_component(PACKAGE_PREFIX_DIR \"\${CMAKE_CURRENT_LIST_DIR}/../../\" ABSOLUTE)"
_contents "${_contents}") # This is a meson-related workaround, see https://github.com/mesonbuild/meson/issues/6955
endif()
#Fix wrongly absolute paths to install dir with the correct dir using ${_IMPORT_PREFIX}
#This happens if vcpkg built libraries are directly linked to a target instead of using
#an imported target for it. We could add more logic here to identify defect target files.
#Since the replacement here in a multi config build always requires a generator expression
#in front of the absoulte path to ${CURRENT_INSTALLED_DIR}. So the match should always be at
#least >:${CURRENT_INSTALLED_DIR}.
#In general the following generator expressions should be there:
#\$<\$<CONFIG:DEBUG>:${CURRENT_INSTALLED_DIR}/debug/lib/somelib>
#and/or
#\$<\$<NOT:\$<CONFIG:DEBUG>>:${CURRENT_INSTALLED_DIR}/lib/somelib>
#with ${CURRENT_INSTALLED_DIR} being fully expanded
string(REPLACE "${CURRENT_INSTALLED_DIR}" [[${_IMPORT_PREFIX}]] _contents "${_contents}")
file(WRITE ${MAIN_CMAKE} "${_contents}")
endforeach()
# Remove /debug/<target_path>/ if it's empty.
file(GLOB_RECURSE REMAINING_FILES "${DEBUG_SHARE}/*")
if(NOT REMAINING_FILES)
file(REMOVE_RECURSE ${DEBUG_SHARE})
endif()
# Remove /debug/share/ if it's empty.
file(GLOB_RECURSE REMAINING_FILES "${CURRENT_PACKAGES_DIR}/debug/share/*")
if(NOT REMAINING_FILES)
file(REMOVE_RECURSE ${CURRENT_PACKAGES_DIR}/debug/share)
endif()
# Patch out any remaining absolute references
file(TO_CMAKE_PATH "${CURRENT_PACKAGES_DIR}" CMAKE_CURRENT_PACKAGES_DIR)
file(GLOB CMAKE_FILES ${RELEASE_SHARE}/*.cmake)
foreach(CMAKE_FILE IN LISTS CMAKE_FILES)
file(READ ${CMAKE_FILE} _contents)
string(REPLACE "${CMAKE_CURRENT_PACKAGES_DIR}" "\${CMAKE_CURRENT_LIST_DIR}/../.." _contents "${_contents}")
file(WRITE ${CMAKE_FILE} "${_contents}")
endforeach()
endfunction()

165
externals/vcpkg/scripts/cmake/vcpkg_fixup_pkgconfig.cmake vendored Executable file
View File

@@ -0,0 +1,165 @@
function(z_vcpkg_fixup_pkgconfig_check_files file config)
set(path_suffix_DEBUG /debug)
set(path_suffix_RELEASE "")
if(DEFINED ENV{PKG_CONFIG_PATH})
set(backup_env_pkg_config_path "$ENV{PKG_CONFIG_PATH}")
else()
unset(backup_env_pkg_config_path)
endif()
vcpkg_host_path_list(PREPEND ENV{PKG_CONFIG_PATH}
"${CURRENT_PACKAGES_DIR}${path_suffix_${config}}/lib/pkgconfig"
"${CURRENT_PACKAGES_DIR}/share/pkgconfig"
"${CURRENT_INSTALLED_DIR}${path_suffix_${config}}/lib/pkgconfig"
"${CURRENT_INSTALLED_DIR}/share/pkgconfig"
)
# First make sure everything is ok with the package and its deps
cmake_path(GET file STEM LAST_ONLY package_name)
debug_message("Checking package (${config}): ${package_name}")
execute_process(
COMMAND "${PKGCONFIG}" --print-errors --exists "${package_name}"
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}"
RESULT_VARIABLE error_var
OUTPUT_VARIABLE output
ERROR_VARIABLE output
OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_STRIP_TRAILING_WHITESPACE
)
if(NOT "${error_var}" EQUAL "0")
message(FATAL_ERROR "${PKGCONFIG} --exists ${package_name} failed with error code: ${error_var}
ENV{PKG_CONFIG_PATH}: \"$ENV{PKG_CONFIG_PATH}\"
output: ${output}"
)
else()
debug_message("pkg-config --exists ${package_name} output: ${output}")
endif()
if(DEFINED backup_env_pkg_config_path)
set(ENV{PKG_CONFIG_PATH} "${backup_env_pkg_config_path}")
else()
unset(ENV{PKG_CONFIG_PATH})
endif()
endfunction()
function(vcpkg_fixup_pkgconfig)
cmake_parse_arguments(PARSE_ARGV 0 arg
"SKIP_CHECK"
""
"RELEASE_FILES;DEBUG_FILES;SYSTEM_LIBRARIES;SYSTEM_PACKAGES;IGNORE_FLAGS"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(DEFINED arg_RELEASE_FILES AND NOT DEFINED arg_DEBUG_FILES)
message(FATAL_ERROR "DEBUG_FILES must be specified if RELEASE_FILES was specified.")
endif()
if(NOT DEFINED arg_RELEASE_FILES AND DEFINED arg_DEBUG_FILES)
message(FATAL_ERROR "RELEASE_FILES must be specified if DEBUG_FILES was specified.")
endif()
if(NOT DEFINED arg_RELEASE_FILES)
file(GLOB_RECURSE arg_RELEASE_FILES "${CURRENT_PACKAGES_DIR}/**/*.pc")
file(GLOB_RECURSE arg_DEBUG_FILES "${CURRENT_PACKAGES_DIR}/debug/**/*.pc")
foreach(debug_file IN LISTS arg_DEBUG_FILES)
vcpkg_list(REMOVE_ITEM arg_RELEASE_FILES "${debug_file}")
endforeach()
endif()
string(REGEX REPLACE "^([a-zA-Z]):/" [[/\1/]] unix_packages_dir "${CURRENT_PACKAGES_DIR}")
string(REGEX REPLACE "^([a-zA-Z]):/" [[/\1/]] unix_installed_dir "${CURRENT_INSTALLED_DIR}")
foreach(config IN ITEMS RELEASE DEBUG)
debug_message("${config} Files: ${arg_${config}_FILES}")
if("${VCPKG_BUILD_TYPE}" STREQUAL "debug" AND "${config}" STREQUAL "RELEASE")
continue()
endif()
if("${VCPKG_BUILD_TYPE}" STREQUAL "release" AND "${config}" STREQUAL "DEBUG")
continue()
endif()
foreach(file IN LISTS "arg_${config}_FILES")
message(STATUS "Fixing pkgconfig file: ${file}")
cmake_path(GET file PARENT_PATH pkg_lib_search_path)
if("${config}" STREQUAL "DEBUG")
set(relative_pc_path "${CURRENT_PACKAGES_DIR}/debug")
cmake_path(RELATIVE_PATH relative_pc_path BASE_DIRECTORY "${pkg_lib_search_path}")
else()
set(relative_pc_path "${CURRENT_PACKAGES_DIR}")
cmake_path(RELATIVE_PATH relative_pc_path BASE_DIRECTORY "${pkg_lib_search_path}")
endif()
#Correct *.pc file
file(READ "${file}" contents)
# this normalizes all files to end with a newline, and use LF instead of CRLF;
# this allows us to use regex matches easier to modify these files.
if(NOT "${contents}" MATCHES "\n$")
string(APPEND contents "\n")
endif()
string(REPLACE "\r\n" "\n" contents "${contents}")
string(REPLACE "${CURRENT_PACKAGES_DIR}" [[${prefix}]] contents "${contents}")
string(REPLACE "${CURRENT_INSTALLED_DIR}" [[${prefix}]] contents "${contents}")
string(REPLACE "${unix_packages_dir}" [[${prefix}]] contents "${contents}")
string(REPLACE "${unix_installed_dir}" [[${prefix}]] contents "${contents}")
string(REGEX REPLACE "(^|\n)prefix[\t ]*=[^\n]*" "" contents "${contents}")
if("${config}" STREQUAL "DEBUG")
# prefix points at the debug subfolder
string(REPLACE [[${prefix}/debug]] [[${prefix}]] contents "${contents}")
string(REPLACE [[${prefix}/include]] [[${prefix}/../include]] contents "${contents}")
string(REPLACE [[${prefix}/share]] [[${prefix}/../share]] contents "${contents}")
endif()
# quote -L, -I, and -l paths starting with `${blah}`
string(REGEX REPLACE " -([LIl])(\\\${[^}]*}[^ \n\t]*)" [[ -\1"\2"]] contents "${contents}")
# This section fuses XYZ.private and XYZ according to VCPKG_LIBRARY_LINKAGE
#
# Pkgconfig searches Requires.private transitively for Cflags in the dynamic case,
# which prevents us from removing it.
#
# Once this transformation is complete, users of vcpkg should never need to pass
# --static.
if("${VCPKG_LIBRARY_LINKAGE}" STREQUAL "static")
# how this works:
# we want to transform:
# Libs: $1
# Libs.private: $2
# into
# Libs: $1 $2
# and the same thing for Requires and Requires.private
foreach(item IN ITEMS "Libs" "Requires" "Cflags")
set(line "")
if("${contents}" MATCHES "(^|\n)${item}: *([^\n]*)")
string(APPEND line " ${CMAKE_MATCH_2}")
endif()
if("${contents}" MATCHES "(^|\n)${item}\\.private: *([^\n]*)")
string(APPEND line " ${CMAKE_MATCH_2}")
endif()
string(REGEX REPLACE "(^|\n)${item}(\\.private)?:[^\n]*\n" [[\1]] contents "${contents}")
if(NOT "${line}" STREQUAL "")
string(APPEND contents "${item}:${line}\n")
endif()
endforeach()
endif()
file(WRITE "${file}" "prefix=\${pcfiledir}/${relative_pc_path}\n${contents}")
endforeach()
if(NOT arg_SKIP_CHECK) # The check can only run after all files have been corrected!
vcpkg_find_acquire_program(PKGCONFIG)
debug_message("Using pkg-config from: ${PKGCONFIG}")
foreach(file IN LISTS "arg_${config}_FILES")
z_vcpkg_fixup_pkgconfig_check_files("${file}" "${config}")
endforeach()
endif()
endforeach()
debug_message("Fixing pkgconfig --- finished")
set(Z_VCPKG_FIXUP_PKGCONFIG_CALLED TRUE CACHE INTERNAL "See below" FORCE)
# Variable to check if this function has been called!
# Theoreotically vcpkg could look for *.pc files and automatically call this function
# or check if this function has been called if *.pc files are detected.
# The same is true for vcpkg_fixup_cmake_targets
endfunction()

93
externals/vcpkg/scripts/cmake/vcpkg_from_bitbucket.cmake vendored Executable file
View File

@@ -0,0 +1,93 @@
function(vcpkg_from_bitbucket)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
""
"OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF"
"PATCHES")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_from_bitbucket was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
endif()
if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
endif()
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
endif()
if(NOT DEFINED arg_REPO)
message(FATAL_ERROR "The Bitbucket repository must be specified.")
endif()
if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
endif()
if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
must be an organization name followed by a repository name separated by a single slash.")
endif()
set(org_name "${CMAKE_MATCH_1}")
set(repo_name "${CMAKE_MATCH_2}")
set(redownload_param "")
set(working_directory_param "")
set(sha512_param "SHA512" "${arg_SHA512}")
set(ref_to_use "${arg_REF}")
if(VCPKG_USE_HEAD_VERSION)
if(DEFINED arg_HEAD_REF)
set(redownload_param "ALWAYS_REDOWNLOAD")
set(sha512_param "SKIP_SHA512")
set(working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
set(ref_to_use "${arg_HEAD_REF}")
else()
message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
endif()
elseif(NOT DEFINED arg_REF)
message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
endif()
# avoid using either - or _, to allow both `foo/bar` and `foo-bar` to coexist
# we assume that no one will name a ref "foo_-bar"
string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
# exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
if(VCPKG_USE_HEAD_VERSION)
vcpkg_download_distfile(archive_version
URLS "https://api.bitbucket.com/2.0/repositories/${org_name}/${repo_name}/refs/branches/${arg_HEAD_REF}"
FILENAME "${downloaded_file_name}.version"
SKIP_SHA512
ALWAYS_REDOWNLOAD
)
# Parse the github refs response with regex.
# TODO: add json-pointer support to vcpkg
file(READ "${archive_version}" version_contents)
if(NOT version_contents MATCHES [["hash": "([a-f0-9]+)"]])
message(FATAL_ERROR "Failed to parse API response from '${version_url}':
${version_contents}
")
endif()
set(VCPKG_HEAD_VERSION "${CMAKE_MATCH_1}" PARENT_SCOPE)
endif()
# download the file information from bitbucket.
vcpkg_download_distfile(archive
URLS "https://bitbucket.com/${org_name}/${repo_name}/get/${ref_to_use}.tar.gz"
FILENAME "${downloaded_file_name}"
${sha512_param}
${redownload_param}
)
vcpkg_extract_source_archive_ex(
OUT_SOURCE_PATH SOURCE_PATH
ARCHIVE "${archive}"
REF "${sanitized_ref}"
PATCHES ${arg_PATCHES}
${working_directory_param}
)
set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
endfunction()

147
externals/vcpkg/scripts/cmake/vcpkg_from_git.cmake vendored Executable file
View File

@@ -0,0 +1,147 @@
function(vcpkg_from_git)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
""
"OUT_SOURCE_PATH;URL;REF;FETCH_REF;HEAD_REF;TAG"
"PATCHES"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_from_git was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(DEFINED arg_TAG)
message(WARNING "The TAG argument to vcpkg_from_git has been deprecated and has no effect.")
endif()
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified")
endif()
if(NOT DEFINED arg_URL)
message(FATAL_ERROR "URL must be specified")
endif()
if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified")
endif()
if(DEFINED arg_FETCH_REF AND NOT DEFINED arg_REF)
message(FATAL_ERROR "REF must be specified if FETCH_REF is specified")
endif()
vcpkg_list(SET git_fetch_shallow_param --depth 1)
vcpkg_list(SET extract_working_directory_param)
vcpkg_list(SET skip_patch_check_param)
set(git_working_directory "${DOWNLOADS}/git-tmp")
set(do_download OFF)
if(VCPKG_USE_HEAD_VERSION AND DEFINED arg_HEAD_REF)
vcpkg_list(SET working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
vcpkg_list(SET git_fetch_shallow_param --depth 1)
vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
set(ref_to_fetch "${arg_HEAD_REF}")
set(git_working_directory "${CURRENT_BUILDTREES_DIR}/src/git-tmp")
string(REPLACE "/" "_-" sanitized_ref "${arg_HEAD_REF}")
if(NOT _VCPKG_NO_DOWNLOADS)
set(do_download ON)
endif()
else()
if(NOT DEFINED arg_REF)
message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
endif()
if(VCPKG_USE_HEAD_VERSION)
message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
endif()
if(DEFINED arg_FETCH_REF)
set(ref_to_fetch "${arg_FETCH_REF}")
vcpkg_list(SET git_fetch_shallow_param)
else()
set(ref_to_fetch "${arg_REF}")
endif()
string(REPLACE "/" "_-" sanitized_ref "${arg_REF}")
endif()
set(temp_archive "${DOWNLOADS}/temp/${PORT}-${sanitized_ref}.tar.gz")
set(archive "${DOWNLOADS}/${PORT}-${sanitized_ref}.tar.gz")
if(NOT EXISTS "${archive}")
if(_VCPKG_NO_DOWNLOADS)
message(FATAL_ERROR "Downloads are disabled, but '${archive}' does not exist.")
endif()
set(do_download ON)
endif()
if(do_download)
message(STATUS "Fetching ${arg_URL} ${ref_to_fetch}...")
find_program(GIT NAMES git git.cmd)
file(MAKE_DIRECTORY "${DOWNLOADS}")
# Note: git init is safe to run multiple times
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${GIT}" init "${git_working_directory}"
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}"
LOGNAME "git-init-${TARGET_TRIPLET}"
)
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${GIT}" fetch "${arg_URL}" "${ref_to_fetch}" ${git_fetch_shallow_param} -n
WORKING_DIRECTORY "${git_working_directory}"
LOGNAME "git-fetch-${TARGET_TRIPLET}"
)
if(VCPKG_USE_HEAD_VERSION)
vcpkg_execute_in_download_mode(
COMMAND "${GIT}" rev-parse FETCH_HEAD
OUTPUT_VARIABLE rev_parse_ref
ERROR_VARIABLE rev_parse_ref
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${git_working_directory}"
)
if(error_code)
message(FATAL_ERROR "unable to determine FETCH_HEAD after fetching git repository")
endif()
string(STRIP "${rev_parse_ref}" rev_parse_ref)
set(VCPKG_HEAD_VERSION "${rev_parse_ref}" PARENT_SCOPE)
else()
vcpkg_execute_in_download_mode(
COMMAND "${GIT}" rev-parse "${arg_REF}"
OUTPUT_VARIABLE rev_parse_ref
ERROR_VARIABLE rev_parse_ref
RESULT_VARIABLE error_code
WORKING_DIRECTORY "${git_working_directory}"
)
if(error_code)
message(FATAL_ERROR "unable to rev-parse ${arg_REF} after fetching git repository")
endif()
string(STRIP "${rev_parse_ref}" rev_parse_ref)
if(NOT "${rev_parse_ref}" STREQUAL "${arg_REF}")
message(FATAL_ERROR "REF (${arg_REF}) does not match rev-parse'd reference (${rev_parse_ref})
[Expected : ( ${arg_REF} )])
[ Actual : ( ${rev_parse_ref} )]"
)
endif()
endif()
file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
vcpkg_execute_required_process(
ALLOW_IN_DOWNLOAD_MODE
COMMAND "${GIT}" -c core.autocrlf=false archive "${rev_parse_ref}" -o "${temp_archive}"
WORKING_DIRECTORY "${git_working_directory}"
LOGNAME git-archive
)
file(RENAME "${temp_archive}" "${archive}")
else()
message(STATUS "Using cached ${archive}")
endif()
vcpkg_extract_source_archive_ex(
OUT_SOURCE_PATH SOURCE_PATH
ARCHIVE "${archive}"
REF "${sanitized_ref}"
PATCHES ${arg_PATCHES}
NO_REMOVE_ONE_LEVEL
${extract_working_directory_param}
${skip_patch_check_param}
)
set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
endfunction()

122
externals/vcpkg/scripts/cmake/vcpkg_from_github.cmake vendored Executable file
View File

@@ -0,0 +1,122 @@
function(vcpkg_from_github)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
""
"OUT_SOURCE_PATH;REPO;REF;SHA512;HEAD_REF;GITHUB_HOST;AUTHORIZATION_TOKEN;FILE_DISAMBIGUATOR"
"PATCHES")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_from_github was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
endif()
if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
endif()
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
endif()
if(NOT DEFINED arg_REPO)
message(FATAL_ERROR "The GitHub repository must be specified.")
endif()
if(NOT DEFINED arg_GITHUB_HOST)
set(github_host "https://github.com")
set(github_api_url "https://api.github.com")
else()
set(github_host "${arg_GITHUB_HOST}")
set(github_api_url "${arg_GITHUB_HOST}/api/v3")
endif()
set(headers_param "")
if(DEFINED arg_AUTHORIZATION_TOKEN)
set(headers_param "HEADERS" "Authorization: token ${arg_AUTHORIZATION_TOKEN}")
endif()
if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
endif()
if(NOT arg_REPO MATCHES "^([^/]*)/([^/]*)$")
message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name:
must be an organization name followed by a repository name separated by a single slash.")
endif()
set(org_name "${CMAKE_MATCH_1}")
set(repo_name "${CMAKE_MATCH_2}")
if(VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_HEAD_REF)
message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
set(VCPKG_USE_HEAD_VERSION OFF)
elseif(NOT VCPKG_USE_HEAD_VERSION AND NOT DEFINED arg_REF)
message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
endif()
# exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
if(VCPKG_USE_HEAD_VERSION)
string(REPLACE "/" "_-" sanitized_head_ref "${arg_HEAD_REF}")
vcpkg_download_distfile(archive_version
URLS "${github_api_url}/repos/${org_name}/${repo_name}/git/refs/heads/${arg_HEAD_REF}"
FILENAME "${org_name}-${repo_name}-${sanitized_head_ref}.version"
${headers_param}
SKIP_SHA512
ALWAYS_REDOWNLOAD
)
# Parse the github refs response with regex.
file(READ "${archive_version}" version_contents)
string(JSON head_version
ERROR_VARIABLE head_version_err
GET "${version_contents}"
"object"
"sha"
)
if(NOT "${head_version_err}" STREQUAL "NOTFOUND")
message(FATAL_ERROR "Failed to parse API response from '${version_url}':
${version_contents}
Error was: ${head_version_err}
")
endif()
set(VCPKG_HEAD_VERSION "${head_version}" PARENT_SCOPE)
set(ref_to_use "${head_version}")
vcpkg_list(SET redownload_param ALWAYS_REDOWNLOAD)
vcpkg_list(SET sha512_param SKIP_SHA512)
vcpkg_list(SET working_directory_param WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/src/head")
vcpkg_list(SET skip_patch_check_param SKIP_PATCH_CHECK)
else()
set(ref_to_use "${arg_REF}")
vcpkg_list(SET redownload_param)
vcpkg_list(SET working_directory_param)
vcpkg_list(SET skip_patch_check_param)
vcpkg_list(SET sha512_param SHA512 "${arg_SHA512}")
endif()
string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
if(DEFINED arg_FILE_DISAMBIGUATOR AND NOT VCPKG_USE_HEAD_REF)
set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}-${arg_FILE_DISAMBIGUATOR}.tar.gz")
else()
set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
endif()
# Try to download the file information from github
vcpkg_download_distfile(archive
URLS "${github_host}/${org_name}/${repo_name}/archive/${ref_to_use}.tar.gz"
FILENAME "${downloaded_file_name}"
${headers_param}
${sha512_param}
${redownload_param}
)
vcpkg_extract_source_archive_ex(
OUT_SOURCE_PATH SOURCE_PATH
ARCHIVE "${archive}"
REF "${sanitized_ref}"
PATCHES ${arg_PATCHES}
${working_directory_param}
${skip_patch_check_param}
)
set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
endfunction()

120
externals/vcpkg/scripts/cmake/vcpkg_from_gitlab.cmake vendored Executable file
View File

@@ -0,0 +1,120 @@
include(vcpkg_execute_in_download_mode)
function(vcpkg_from_gitlab)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
""
"OUT_SOURCE_PATH;GITLAB_URL;REPO;REF;SHA512;HEAD_REF;FILE_DISAMBIGUATOR"
"PATCHES")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_from_gitlab was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_GITLAB_URL)
message(FATAL_ERROR "GITLAB_URL must be specified.")
endif()
if(DEFINED arg_REF AND NOT DEFINED arg_SHA512)
message(FATAL_ERROR "SHA512 must be specified if REF is specified.")
endif()
if(NOT DEFINED arg_REF AND DEFINED arg_SHA512)
message(FATAL_ERROR "REF must be specified if SHA512 is specified.")
endif()
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
endif()
if(NOT DEFINED arg_REPO)
message(FATAL_ERROR "The GitHub repository must be specified.")
endif()
set(headers_param "")
if(DEFINED arg_AUTHORIZATION_TOKEN)
set(headers_param "HEADERS" "Authorization: token ${arg_AUTHORIZATION_TOKEN}")
endif()
if(NOT DEFINED arg_REF AND NOT DEFINED arg_HEAD_REF)
message(FATAL_ERROR "At least one of REF or HEAD_REF must be specified.")
endif()
if(arg_REPO MATCHES [[^([^/]*)/([^/]*)$]]) # 2 elements
set(org_name "${CMAKE_MATCH_1}")
set(repo_name "${CMAKE_MATCH_2}")
set(gitlab_link "${arg_GITLAB_URL}/${org_name}/${repo_name}")
elseif(arg_REPO MATCHES [[^([^/]*)/([^/]*)/([^/]*)$]]) # 3 elements
set(org_name "${CMAKE_MATCH_1}")
set(group_name "${CMAKE_MATCH_2}")
set(repo_name "${CMAKE_MATCH_3}")
set(gitlab_link "${arg_GITLAB_URL}/${org_name}/${group_name}/${repo_name}")
else()
message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name. It must be:
- an organization name followed by a repository name separated by a single slash, or
- an organization name, group name, and repository name separated by slashes.")
endif()
set(redownload_param "")
set(working_directory_param "")
set(sha512_param "SHA512" "${arg_SHA512}")
set(ref_to_use "${arg_REF}")
if(VCPKG_USE_HEAD_VERSION)
if(DEFINED arg_HEAD_REF)
set(redownload_param "ALWAYS_REDOWNLOAD")
set(sha512_param "SKIP_SHA512")
set(working_directory_param "WORKING_DIRECTORY" "${CURRENT_BUILDTREES_DIR}/src/head")
set(ref_to_use "${arg_HEAD_REF}")
else()
message(STATUS "Package does not specify HEAD_REF. Falling back to non-HEAD version.")
endif()
elseif(NOT DEFINED arg_REF)
message(FATAL_ERROR "Package does not specify REF. It must be built using --head.")
endif()
# avoid using either - or _, to allow both `foo/bar` and `foo-bar` to coexist
# we assume that no one will name a ref "foo_-bar"
string(REPLACE "/" "_-" sanitized_ref "${ref_to_use}")
if(DEFINED arg_FILE_DISAMBIGUATOR AND NOT VCPKG_USE_HEAD_VERSION)
set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}-${arg_FILE_DISAMBIGUATOR}.tar.gz")
else()
set(downloaded_file_name "${org_name}-${repo_name}-${sanitized_ref}.tar.gz")
endif()
# exports VCPKG_HEAD_VERSION to the caller. This will get picked up by ports.cmake after the build.
if(VCPKG_USE_HEAD_VERSION)
# There are issues with the Gitlab API project paths being URL-escaped, so we use git here to get the head revision
vcpkg_execute_in_download_mode(COMMAND ${GIT} ls-remote
"${gitlab_link}.git" "${arg_HEAD_REF}"
RESULT_VARIABLE git_result
OUTPUT_VARIABLE git_output
)
if(NOT git_result EQUAL 0)
message(FATAL_ERROR "git ls-remote failed to read ref data of repository: '${gitlab_link}'")
endif()
if(NOT git_output MATCHES "^([a-f0-9]*)\t")
message(FATAL_ERROR "git ls-remote returned unexpected result:
${git_output}
")
endif()
# When multiple vcpkg_from_gitlab's are used after each other, only use the version from the first (hopefully the primary one).
if(NOT DEFINED VCPKG_HEAD_VERSION)
set(VCPKG_HEAD_VERSION "${CMAKE_MATCH_1}" PARENT_SCOPE)
endif()
endif()
# download the file information from gitlab
vcpkg_download_distfile(archive
URLS "${gitlab_link}/-/archive/${ref_to_use}/${repo_name}-${ref_to_use}.tar.gz"
FILENAME "${downloaded_file_name}"
${headers_param}
${sha512_param}
${redownload_param}
)
vcpkg_extract_source_archive_ex(
OUT_SOURCE_PATH SOURCE_PATH
ARCHIVE "${archive}"
REF "${sanitized_ref}"
PATCHES ${arg_PATCHES}
${working_directory_param}
)
set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
endfunction()

107
externals/vcpkg/scripts/cmake/vcpkg_from_sourceforge.cmake vendored Executable file
View File

@@ -0,0 +1,107 @@
function(vcpkg_from_sourceforge)
cmake_parse_arguments(PARSE_ARGV 0 "arg"
"DISABLE_SSL;NO_REMOVE_ONE_LEVEL"
"OUT_SOURCE_PATH;REPO;REF;SHA512;FILENAME;WORKING_DIRECTORY"
"PATCHES")
if(NOT DEFINED arg_OUT_SOURCE_PATH)
message(FATAL_ERROR "OUT_SOURCE_PATH must be specified.")
endif()
if(NOT DEFINED arg_SHA512)
message(FATAL_ERROR "SHA512 must be specified.")
endif()
if(NOT DEFINED arg_REPO)
message(FATAL_ERROR "The sourceforge repository must be specified.")
endif()
if(arg_DISABLE_SSL)
message(WARNING "DISABLE_SSL has been deprecated and has no effect")
endif()
set(sourceforge_host "https://sourceforge.net/projects")
if(arg_REPO MATCHES "^([^/]*)$") # just one element
set(org_name "${CMAKE_MATCH_1}")
set(repo_name "")
elseif(arg_REPO MATCHES "^([^/]*)/([^/]*)$") # two elements
set(org_name "${CMAKE_MATCH_1}")
set(repo_name "${CMAKE_MATCH_2}")
else()
message(FATAL_ERROR "REPO (${arg_REPO}) is not a valid repo name. It must be:
- an organization name without any slashes, or
- an organization name followed by a repository name separated by a single slash")
endif()
if(DEFINED arg_REF)
set(url "${sourceforge_host}/${org_name}/files/${repo_name}/${arg_REF}/${arg_FILENAME}")
elseif(DEFINED repo_name)
set(url "${sourceforge_host}/${org_name}/${repo_name}/files/${arg_FILENAME}")
else()
set(url "${sourceforge_host}/${org_name}/files/${arg_FILENAME}")
endif()
string(SUBSTRING "${arg_SHA512}" 0 10 sanitized_ref)
set(sourceforge_mirrors
cfhcable # United States
pilotfiber # New York, NY
gigenet # Chicago, IL
versaweb # Las Vegas, NV
ayera # Modesto, CA
netactuate # Durham, NC
phoenixnap # Tempe, AZ
astuteinternet # Vancouver, BC
freefr # Paris, France
netcologne # Cologne, Germany
deac-riga # Latvia
excellmedia # Hyderabad, India
iweb # Montreal, QC
jaist # Nomi, Japan
jztkft # Mezotur, Hungary
managedway # Detroit, MI
nchc # Taipei, Taiwan
netix # Bulgaria
ufpr # Curitiba, Brazil
tenet # Wynberg, South Africa
)
if(DEFINED SOURCEFORGE_MIRRORS AND NOT DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
message(WARNING "Extension point SOURCEFORGE_MIRRORS has been deprecated.
Please use the replacement VCPKG_SOURCEFORGE_EXTRA_MIRRORS variable instead.")
list(APPEND sourceforge_mirrors "${SOURCEFORGE_MIRRORS}")
list(REMOVE_DUPLICATES sourceforge_mirrors)
elseif(DEFINED VCPKG_SOURCEFORGE_EXTRA_MIRRORS)
list(APPEND sourceforge_mirrors "${VCPKG_SOURCEFORGE_EXTRA_MIRRORS}")
list(REMOVE_DUPLICATES sourceforge_mirrors)
endif()
set(all_urls "${url}/download")
foreach(mirror IN LISTS sourceforge_mirrors)
list(APPEND all_urls "${url}/download?use_mirror=${mirror}")
endforeach()
vcpkg_download_distfile(ARCHIVE
URLS ${all_urls}
SHA512 "${arg_SHA512}"
FILENAME "${arg_FILENAME}"
)
set(no_remove_one_level_param "")
set(working_directory_param "")
if(arg_NO_REMOVE_ONE_LEVEL)
set(no_remove_one_level_param "NO_REMOVE_ONE_LEVEL")
endif()
if(DEFINED arg_WORKING_DIRECTORY)
set(working_directory_param "WORKING_DIRECTORY" "${arg_WORKING_DIRECTORY}")
endif()
vcpkg_extract_source_archive_ex(
OUT_SOURCE_PATH SOURCE_PATH
ARCHIVE "${ARCHIVE}"
REF "${sanitized_ref}"
${no_remove_one_level_param}
${working_directory_param}
PATCHES ${arg_PATCHES}
)
set("${arg_OUT_SOURCE_PATH}" "${SOURCE_PATH}" PARENT_SCOPE)
endfunction()

7
externals/vcpkg/scripts/cmake/vcpkg_get_program_files_platform_bitness.cmake vendored Executable file
View File

@@ -0,0 +1,7 @@
function(vcpkg_get_program_files_platform_bitness out_var)
if(DEFINED ENV{ProgramW6432})
set("${out_var}" "$ENV{ProgramW6432}" PARENT_SCOPE)
else()
set("${out_var}" "$ENV{PROGRAMFILES}" PARENT_SCOPE)
endif()
endfunction()

7
externals/vcpkg/scripts/cmake/vcpkg_get_windows_sdk.cmake vendored Executable file
View File

@@ -0,0 +1,7 @@
function(vcpkg_get_windows_sdk out_var)
if("$ENV{WindowsSDKVersion}" MATCHES [[^([0-9.]*)\\?$]])
set("${out_var}" "${CMAKE_MATCH_1}" PARENT_SCOPE)
else()
message(FATAL_ERROR "Unexpected format for ENV{WindowsSDKVersion} ($ENV{WindowsSDKVersion})")
endif()
endfunction()

68
externals/vcpkg/scripts/cmake/vcpkg_host_path_list.cmake vendored Executable file
View File

@@ -0,0 +1,68 @@
function(z_vcpkg_translate_to_host_path_list out_var lst)
if(NOT DEFINED arg_UNPARSED_ARGUMENTS)
set("${out_var}" "" PARENT_SCOPE)
else()
if("${VCPKG_HOST_PATH_SEPARATOR}" STREQUAL ";")
set("${out_var}" "${lst}" PARENT_SCOPE)
string(FIND "${lst}" [[\;]] index_of_host_path_separator)
else()
vcpkg_list(JOIN lst "${VCPKG_HOST_PATH_SEPARATOR}" arguments)
set("${out_var}" "${arguments}" PARENT_SCOPE)
string(FIND "${lst}" "${VCPKG_HOST_PATH_SEPARATOR}" index_of_host_path_separator)
endif()
if(NOT "${index_of_host_path_separator}" EQUAL "-1")
message(FATAL_ERROR "Host path separator (${VCPKG_HOST_PATH_SEPARATOR}) in path; this is unsupported.")
endif()
endif()
endfunction()
function(vcpkg_host_path_list)
if("${ARGC}" LESS "2")
message(FATAL_ERROR "vcpkg_host_path_list requires at least two arguments.")
endif()
if("${ARGV1}" MATCHES "^ARGV([0-9]*)$|^ARG[CN]$|^CMAKE_CURRENT_FUNCTION|^CMAKE_MATCH_")
message(FATAL_ERROR "vcpkg_host_path_list does not support the list_var being ${ARGV1}.
Please use a different variable name.")
endif()
if("${ARGV1}" MATCHES [[^ENV\{(.*)\}$]])
set(list "$ENV{${CMAKE_MATCH_1}}")
set(env_var ON)
elseif("${ARGV1}" MATCHES [[^([A-Z]+)\{.*\}$]])
message(FATAL_ERROR "vcpkg_host_path_list does not support ${CMAKE_MATCH_1} variables;
only ENV{} and regular variables are supported.")
else()
set(list "${${ARGV1}}")
set(env_var OFF)
endif()
set(operation "${ARGV0}")
set(list_var "${ARGV1}")
cmake_parse_arguments(PARSE_ARGV 2 arg "" "" "")
z_vcpkg_translate_to_host_path_list(arguments "${arg_UNPARSED_ARGUMENTS}")
if("${operation}" STREQUAL "SET")
set(list "${arguments}")
elseif("${operation}" MATCHES "^(APPEND|PREPEND)$")
if("${arguments}" STREQUAL "")
# do nothing
elseif("${list}" STREQUAL "")
set(list "${arguments}")
elseif("${operation}" STREQUAL "PREPEND")
set(list "${arguments}${VCPKG_HOST_PATH_SEPARATOR}${list}")
else()
set(list "${list}${VCPKG_HOST_PATH_SEPARATOR}${arguments}")
endif()
else()
message(FATAL_ERROR "Operation ${operation} not recognized.")
endif()
if(env_var)
set("${list_var}" "${list}")
else()
set("${list_var}" "${list}" PARENT_SCOPE)
endif()
endfunction()

23
externals/vcpkg/scripts/cmake/vcpkg_install_cmake.cmake vendored Executable file
View File

@@ -0,0 +1,23 @@
function(vcpkg_install_cmake)
if(Z_VCPKG_CMAKE_INSTALL_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_install_cmake in the same port is unsupported.")
endif()
cmake_parse_arguments(PARSE_ARGV 0 "arg" "DISABLE_PARALLEL;ADD_BIN_TO_PATH" "" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "vcpkg_cmake_install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
vcpkg_list(SET params)
foreach(arg IN ITEMS DISABLE_PARALLEL ADD_BIN_TO_PATH)
if(arg_${arg})
vcpkg_list(APPEND params "${arg}")
endif()
endforeach()
vcpkg_build_cmake(Z_VCPKG_DISABLE_DEPRECATION MESSAGE
${params}
LOGFILE_ROOT install
TARGET install
)
endfunction()

116
externals/vcpkg/scripts/cmake/vcpkg_install_gn.cmake vendored Executable file
View File

@@ -0,0 +1,116 @@
function(z_vcpkg_install_gn_get_target_type out_var)
cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error: get_target_type was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
execute_process(
COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}"
WORKING_DIRECTORY "${arg_SOURCE_PATH}"
OUTPUT_VARIABLE output
OUTPUT_STRIP_TRAILING_WHITESPACE
)
if(output MATCHES [[type: ([A-Za-z0-9_]+)]])
set("${out_var}" "${CMAKE_MATCH_1}" PARENT_SCOPE)
else()
message(FATAL_ERROR "invalid result from `gn desc`: ${output}")
endif()
endfunction()
function(z_vcpkg_install_gn_get_desc out_var)
cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "SOURCE_PATH;BUILD_DIR;TARGET;WHAT_TO_DISPLAY" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error: get_desc was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
execute_process(
COMMAND "${GN}" desc "${arg_BUILD_DIR}" "${arg_TARGET}" "${arg_WHAT_TO_DISPLAY}"
WORKING_DIRECTORY "${arg_SOURCE_PATH}"
OUTPUT_VARIABLE output
OUTPUT_STRIP_TRAILING_WHITESPACE
)
string(REPLACE ";" "\\;" output "${output}")
string(REGEX REPLACE "\n|(\r\n)" ";" output "${output}")
set("${out_var}" "${output}" PARENT_SCOPE)
endfunction()
function(z_vcpkg_install_gn_install)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "SOURCE_PATH;BUILD_DIR;INSTALL_DIR" "TARGETS")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "Internal error: install was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
foreach(target IN LISTS arg_TARGETS)
# GN targets must start with a //
z_vcpkg_install_gn_get_desc(outputs
SOURCE_PATH "${arg_SOURCE_PATH}"
BUILD_DIR "${arg_BUILD_DIR}"
TARGET "//${target}"
WHAT_TO_DISPLAY outputs
)
z_vcpkg_install_gn_get_target_type(target_type
SOURCE_PATH "${arg_SOURCE_PATH}"
BUILD_DIR "${arg_BUILD_DIR}"
TARGET "//${target}"
)
foreach(output IN LISTS outputs)
if(output MATCHES "^//")
# relative path (e.g. //out/Release/target.lib)
string(REGEX REPLACE "^//" "${arg_SOURCE_PATH}/" output "${output}")
elseif(output MATCHES "^/" AND CMAKE_HOST_WIN32)
# absolute path (e.g. /C:/path/to/target.lib)
string(REGEX REPLACE "^/" "" output "${output}")
endif()
if(NOT EXISTS "${output}")
message(WARNING "Output for target `${target}` doesn't exist: ${output}.")
continue()
endif()
if(target_type STREQUAL "executable")
file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/tools")
elseif(output MATCHES "(\\.dll|\\.pdb)$")
file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/bin")
else()
file(INSTALL "${output}" DESTINATION "${arg_INSTALL_DIR}/lib")
endif()
endforeach()
endforeach()
endfunction()
function(vcpkg_install_gn)
if(Z_VCPKG_GN_INSTALL_GUARD)
message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-gn; using both vcpkg-gn and vcpkg_install_gn in the same port is unsupported.")
endif()
cmake_parse_arguments(PARSE_ARGV 0 arg "" "SOURCE_PATH" "TARGETS")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_install_gn was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_SOURCE_PATH)
message(FATAL_ERROR "SOURCE_PATH must be specified.")
endif()
vcpkg_build_ninja(TARGETS ${arg_TARGETS})
vcpkg_find_acquire_program(GN)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
z_vcpkg_install_gn_install(
SOURCE_PATH "${arg_SOURCE_PATH}"
BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
INSTALL_DIR "${CURRENT_PACKAGES_DIR}/debug"
TARGETS ${arg_TARGETS}
)
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
z_vcpkg_install_gn_install(
SOURCE_PATH "${arg_SOURCE_PATH}"
BUILD_DIR "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
INSTALL_DIR "${CURRENT_PACKAGES_DIR}"
TARGETS ${arg_TARGETS}
)
endif()
endfunction()

7
externals/vcpkg/scripts/cmake/vcpkg_install_make.cmake vendored Executable file
View File

@@ -0,0 +1,7 @@
function(vcpkg_install_make)
vcpkg_build_make(
${ARGN}
LOGFILE_ROOT
ENABLE_INSTALL
)
endfunction()

71
externals/vcpkg/scripts/cmake/vcpkg_install_meson.cmake vendored Executable file
View File

@@ -0,0 +1,71 @@
function(vcpkg_install_meson)
cmake_parse_arguments(PARSE_ARGV 0 arg "ADD_BIN_TO_PATH" "" "")
vcpkg_find_acquire_program(NINJA)
unset(ENV{DESTDIR}) # installation directory was already specified with '--prefix' option
if(VCPKG_TARGET_IS_OSX)
vcpkg_backup_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
set(ENV{SDKROOT} "${VCPKG_DETECTED_CMAKE_OSX_SYSROOT}")
set(ENV{MACOSX_DEPLOYMENT_TARGET} "${VCPKG_DETECTED_CMAKE_OSX_DEPLOYMENT_TARGET}")
endif()
foreach(buildtype IN ITEMS "debug" "release")
if(DEFINED VCPKG_BUILD_TYPE AND NOT VCPKG_BUILD_TYPE STREQUAL buildtype)
continue()
endif()
if(buildtype STREQUAL "debug")
set(short_buildtype "dbg")
else()
set(short_buildtype "rel")
endif()
message(STATUS "Package ${TARGET_TRIPLET}-${short_buildtype}")
if(arg_ADD_BIN_TO_PATH)
vcpkg_backup_env_variables(VARS PATH)
if(buildtype STREQUAL "debug")
vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/debug/bin")
else()
vcpkg_add_to_path(PREPEND "${CURRENT_INSTALLED_DIR}/bin")
endif()
endif()
vcpkg_execute_required_process(
COMMAND "${NINJA}" install -v
WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_buildtype}"
LOGNAME package-${TARGET_TRIPLET}-${short_buildtype}
)
if(arg_ADD_BIN_TO_PATH)
vcpkg_restore_env_variables(VARS PATH)
endif()
endforeach()
vcpkg_list(SET renamed_libs)
if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_LIBRARY_LINKAGE STREQUAL static AND NOT VCPKG_TARGET_IS_MINGW)
# Meson names all static libraries lib<name>.a which basically breaks the world
file(GLOB_RECURSE gen_libraries "${CURRENT_PACKAGES_DIR}*/**/lib*.a")
foreach(gen_library IN LISTS gen_libraries)
get_filename_component(libdir "${gen_library}" DIRECTORY)
get_filename_component(libname "${gen_library}" NAME)
string(REGEX REPLACE ".a$" ".lib" fixed_librawname "${libname}")
string(REGEX REPLACE "^lib" "" fixed_librawname "${fixed_librawname}")
file(RENAME "${gen_library}" "${libdir}/${fixed_librawname}")
# For cmake fixes.
string(REGEX REPLACE ".a$" "" origin_librawname "${libname}")
string(REGEX REPLACE ".lib$" "" fixed_librawname "${fixed_librawname}")
vcpkg_list(APPEND renamed_libs ${fixed_librawname})
set(${librawname}_old ${origin_librawname})
set(${librawname}_new ${fixed_librawname})
endforeach()
file(GLOB_RECURSE cmake_files "${CURRENT_PACKAGES_DIR}*/*.cmake")
foreach(cmake_file IN LISTS cmake_files)
foreach(current_lib IN LISTS renamed_libs)
vcpkg_replace_string("${cmake_file}" "${${current_lib}_old}" "${${current_lib}_new}")
endforeach()
endforeach()
endif()
if(VCPKG_TARGET_IS_OSX)
vcpkg_restore_env_variables(VARS SDKROOT MACOSX_DEPLOYMENT_TARGET)
endif()
endfunction()

155
externals/vcpkg/scripts/cmake/vcpkg_install_msbuild.cmake vendored Executable file
View File

@@ -0,0 +1,155 @@
function(vcpkg_install_msbuild)
cmake_parse_arguments(
PARSE_ARGV 0
"arg"
"USE_VCPKG_INTEGRATION;ALLOW_ROOT_INCLUDES;REMOVE_ROOT_INCLUDES;SKIP_CLEAN"
"SOURCE_PATH;PROJECT_SUBPATH;INCLUDES_SUBPATH;LICENSE_SUBPATH;RELEASE_CONFIGURATION;DEBUG_CONFIGURATION;PLATFORM;PLATFORM_TOOLSET;TARGET_PLATFORM_VERSION;TARGET"
"OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "vcpkg_install_msbuild was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_RELEASE_CONFIGURATION)
set(arg_RELEASE_CONFIGURATION Release)
endif()
if(NOT DEFINED arg_DEBUG_CONFIGURATION)
set(arg_DEBUG_CONFIGURATION Debug)
endif()
if(NOT DEFINED arg_PLATFORM)
if(VCPKG_TARGET_ARCHITECTURE STREQUAL "x64")
set(arg_PLATFORM x64)
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "x86")
set(arg_PLATFORM Win32)
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm")
set(arg_PLATFORM ARM)
elseif(VCPKG_TARGET_ARCHITECTURE STREQUAL "arm64")
set(arg_PLATFORM arm64)
else()
message(FATAL_ERROR "Unsupported target architecture")
endif()
endif()
if(NOT DEFINED arg_PLATFORM_TOOLSET)
set(arg_PLATFORM_TOOLSET "${VCPKG_PLATFORM_TOOLSET}")
endif()
if(NOT DEFINED arg_TARGET_PLATFORM_VERSION)
vcpkg_get_windows_sdk(arg_TARGET_PLATFORM_VERSION)
endif()
if(NOT DEFINED arg_TARGET)
set(arg_TARGET Rebuild)
endif()
list(APPEND arg_OPTIONS
"/t:${arg_TARGET}"
"/p:Platform=${arg_PLATFORM}"
"/p:PlatformToolset=${arg_PLATFORM_TOOLSET}"
"/p:VCPkgLocalAppDataDisabled=true"
"/p:UseIntelMKL=No"
"/p:WindowsTargetPlatformVersion=${arg_TARGET_PLATFORM_VERSION}"
"/p:VcpkgTriplet=${TARGET_TRIPLET}"
"/p:VcpkgInstalledDir=${_VCPKG_INSTALLED_DIR}"
"/p:VcpkgManifestInstall=false"
"/p:UseMultiToolTask=true"
"/p:MultiProcMaxCount=${VCPKG_CONCURRENCY}"
"/p:EnforceProcessCountAcrossBuilds=true"
"/m:${VCPKG_CONCURRENCY}"
)
if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
# Disable LTCG for static libraries because this setting introduces ABI incompatibility between minor compiler versions
# TODO: Add a way for the user to override this if they want to opt-in to incompatibility
list(APPEND arg_OPTIONS "/p:WholeProgramOptimization=false")
endif()
if(arg_USE_VCPKG_INTEGRATION)
list(APPEND arg_OPTIONS
"/p:ForceImportBeforeCppTargets=${SCRIPTS}/buildsystems/msbuild/vcpkg.targets"
"/p:VcpkgApplocalDeps=false"
)
endif()
get_filename_component(source_path_suffix "${arg_SOURCE_PATH}" NAME)
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
message(STATUS "Building ${arg_PROJECT_SUBPATH} for Release")
file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
file(COPY "${arg_SOURCE_PATH}" DESTINATION "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
set(source_copy_path "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/${source_path_suffix}")
vcpkg_execute_required_process(
COMMAND msbuild "${source_copy_path}/${arg_PROJECT_SUBPATH}"
"/p:Configuration=${arg_RELEASE_CONFIGURATION}"
${arg_OPTIONS}
${arg_OPTIONS_RELEASE}
WORKING_DIRECTORY "${source_copy_path}"
LOGNAME "build-${TARGET_TRIPLET}-rel"
)
file(GLOB_RECURSE libs "${source_copy_path}/*.lib")
file(GLOB_RECURSE dlls "${source_copy_path}/*.dll")
file(GLOB_RECURSE exes "${source_copy_path}/*.exe")
if(NOT libs STREQUAL "")
file(COPY ${libs} DESTINATION "${CURRENT_PACKAGES_DIR}/lib")
endif()
if(NOT dlls STREQUAL "")
file(COPY ${dlls} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
endif()
if(NOT exes STREQUAL "")
file(COPY ${exes} DESTINATION "${CURRENT_PACKAGES_DIR}/tools/${PORT}")
vcpkg_copy_tool_dependencies("${CURRENT_PACKAGES_DIR}/tools/${PORT}")
endif()
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
message(STATUS "Building ${arg_PROJECT_SUBPATH} for Debug")
file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
file(COPY "${arg_SOURCE_PATH}" DESTINATION "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
set(source_copy_path "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/${source_path_suffix}")
vcpkg_execute_required_process(
COMMAND msbuild "${source_copy_path}/${arg_PROJECT_SUBPATH}"
"/p:Configuration=${arg_DEBUG_CONFIGURATION}"
${arg_OPTIONS}
${arg_OPTIONS_DEBUG}
WORKING_DIRECTORY "${source_copy_path}"
LOGNAME "build-${TARGET_TRIPLET}-dbg"
)
file(GLOB_RECURSE libs "${source_copy_path}/*.lib")
file(GLOB_RECURSE dlls "${source_copy_path}/*.dll")
if(NOT libs STREQUAL "")
file(COPY ${libs} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/lib")
endif()
if(NOT dlls STREQUAL "")
file(COPY ${dlls} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
endif()
endif()
vcpkg_copy_pdbs()
if(NOT arg_SKIP_CLEAN)
vcpkg_clean_msbuild()
endif()
if(DEFINED arg_INCLUDES_SUBPATH)
file(COPY "${arg_SOURCE_PATH}/${arg_INCLUDES_SUBPATH}/"
DESTINATION "${CURRENT_PACKAGES_DIR}/include/"
)
file(GLOB root_includes
LIST_DIRECTORIES false
"${CURRENT_PACKAGES_DIR}/include/*")
if(NOT root_includes STREQUAL "")
if(arg_REMOVE_ROOT_INCLUDES)
file(REMOVE ${root_includes})
elseif(arg_ALLOW_ROOT_INCLUDES)
else()
message(FATAL_ERROR "Top-level files were found in ${CURRENT_PACKAGES_DIR}/include; this may indicate a problem with the call to `vcpkg_install_msbuild()`.\nTo avoid conflicts with other libraries, it is recommended to not put includes into the root `include/` directory.\nPass either ALLOW_ROOT_INCLUDES or REMOVE_ROOT_INCLUDES to handle these files.\n")
endif()
endif()
endif()
if(DEFINED arg_LICENSE_SUBPATH)
file(INSTALL "${arg_SOURCE_PATH}/${arg_LICENSE_SUBPATH}"
DESTINATION "${CURRENT_PACKAGES_DIR}/share/${PORT}"
RENAME copyright
)
endif()
endfunction()

54
externals/vcpkg/scripts/cmake/vcpkg_install_nmake.cmake vendored Executable file
View File

@@ -0,0 +1,54 @@
function(vcpkg_install_nmake)
vcpkg_list(SET multi_value_args
TARGET
OPTIONS OPTIONS_DEBUG OPTIONS_RELEASE
PRERUN_SHELL PRERUN_SHELL_DEBUG PRERUN_SHELL_RELEASE)
cmake_parse_arguments(PARSE_ARGV 0 arg
"NO_DEBUG"
"SOURCE_PATH;PROJECT_SUBPATH;PROJECT_NAME"
"${multi_value_args}"
)
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(NOT DEFINED arg_SOURCE_PATH)
message(FATAL_ERROR "SOURCE_PATH must be specified")
endif()
if(NOT VCPKG_HOST_IS_WINDOWS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} only support windows.")
endif()
# backwards-compatibility hack
# gdal passes `arg_OPTIONS_DEBUG` (and RELEASE) as a single argument,
# so we need to split them again
set(arg_OPTIONS_DEBUG ${arg_OPTIONS_DEBUG})
set(arg_OPTIONS_RELEASE ${arg_OPTIONS_RELEASE})
vcpkg_list(SET extra_args)
# switch args
if(arg_NO_DEBUG)
vcpkg_list(APPEND extra_args NO_DEBUG)
endif()
# single args
foreach(arg IN ITEMS PROJECT_SUBPATH PROJECT_NAME)
if(DEFINED "arg_${arg}")
vcpkg_list(APPEND extra_args ${arg} "${arg_${arg}}")
endif()
endforeach()
# multi-value args
foreach(arg IN LISTS multi_value_args)
if(DEFINED "arg_${arg}")
vcpkg_list(APPEND extra_args ${arg} ${arg_${arg}})
endif()
endforeach()
vcpkg_build_nmake(
SOURCE_PATH "${arg_SOURCE_PATH}"
ENABLE_INSTALL
LOGFILE_ROOT install
${extra_args})
endfunction()

45
externals/vcpkg/scripts/cmake/vcpkg_install_qmake.cmake vendored Executable file
View File

@@ -0,0 +1,45 @@
function(vcpkg_install_qmake)
z_vcpkg_function_arguments(args)
vcpkg_build_qmake(${args})
file(GLOB_RECURSE release_libs
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.lib"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.a"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.so.*"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dylib"
)
file(GLOB_RECURSE release_bins
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/*.dll"
)
file(GLOB_RECURSE debug_libs
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.lib"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.a"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.so.*"
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dylib"
)
file(GLOB_RECURSE debug_bins
"${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg/*.dll"
)
if("${release_libs}" STREQUAL "" AND "${debug_libs}" STREQUAL "")
message(FATAL_ERROR "Build did not appear to produce any libraries. If this is intended, use `vcpkg_build_qmake()` directly.")
endif()
if(NOT "${release_libs}" STREQUAL "")
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/lib")
file(COPY ${release_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/lib")
endif()
if(NOT "${debug_libs}" STREQUAL "")
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/lib")
file(COPY ${debug_libs} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/lib")
endif()
if(NOT "${release_bins}" STREQUAL "")
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/bin")
file(COPY ${release_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/bin")
endif()
if(NOT "${debug_bins}" STREQUAL "")
file(MAKE_DIRECTORY "${CURRENT_PACKAGES_DIR}/debug/bin")
file(COPY ${debug_bins} DESTINATION "${CURRENT_PACKAGES_DIR}/debug/bin")
endif()
endfunction()

165
externals/vcpkg/scripts/cmake/vcpkg_list.cmake vendored Executable file
View File

@@ -0,0 +1,165 @@
macro(z_vcpkg_list_escape_once_more lst)
string(REPLACE [[\;]] [[\\;]] "${lst}" "${${lst}}")
endmacro()
function(vcpkg_list)
# NOTE: as this function replaces an existing CMake command,
# it does not use cmake_parse_arguments
# vcpkg_list(<operation> <list_var> ...)
# A0 A1
if(ARGC LESS "2")
message(FATAL_ERROR "vcpkg_list requires at least two arguments.")
endif()
if(ARGV1 MATCHES "^ARGV([0-9]*)$|^ARG[CN]$|^CMAKE_CURRENT_FUNCTION")
message(FATAL_ERROR "vcpkg_list does not support the list_var being ${ARGV1}.
Please use a different variable name.")
endif()
set(list "${${ARGV1}}")
set(operation "${ARGV0}")
set(list_var "${ARGV1}")
if(operation STREQUAL "SET")
z_vcpkg_function_arguments(args 2)
set("${list_var}" "${args}" PARENT_SCOPE)
return()
endif()
# Normal reading functions
if(operation STREQUAL "LENGTH")
# vcpkg_list(LENGTH <list-var> <out-var>)
# A0 A1 A2
if(NOT ARGC EQUAL "3")
message(FATAL_ERROR "vcpkg_list sub-command ${operation} requires two arguments.")
endif()
list(LENGTH list out)
set("${ARGV2}" "${out}" PARENT_SCOPE)
return()
endif()
if(operation MATCHES "^(GET|JOIN|FIND)$")
# vcpkg_list(<operation> <list-var> <arg> <out-var>)
# A0 A1 A2 A3
if(NOT ARGC EQUAL "4")
message(FATAL_ERROR "vcpkg_list sub-command ${operation} requires three arguments.")
endif()
if(operation STREQUAL "GET")
list(LENGTH list length)
if(length EQUAL "0")
message(FATAL_ERROR "vcpkg_list GET given empty list")
elseif(ARGV2 GREATER_EQUAL length OR ARGV2 LESS "-${length}")
message(FATAL_ERROR "vcpkg_list index: ${ARGV2} is not in range")
endif()
endif()
list("${operation}" list "${ARGV2}" out)
set("${ARGV3}" "${out}" PARENT_SCOPE)
return()
endif()
if(operation STREQUAL "SUBLIST")
# vcpkg_list(SUBLIST <list-var> <begin> <length> <out-var>)
# A0 A1 A2 A3 A4
if(NOT ARGC EQUAL "5")
message(FATAL_ERROR "vcpkg_list sub-command SUBLIST requires four arguments.")
endif()
list(LENGTH list length)
if(ARGV2 LESS "0" OR (ARGV2 GREATER_EQUAL length AND NOT ARGV2 EQUAL "0"))
message(FATAL_ERROR "vcpkg_list begin index: ${ARGV2} is out of range")
endif()
z_vcpkg_list_escape_once_more(list)
list(SUBLIST list "${ARGV2}" "${ARGV3}" out)
set("${ARGV4}" "${out}" PARENT_SCOPE)
return()
endif()
# modification functions
if(operation MATCHES "^(APPEND|PREPEND)$")
# vcpkg_list(<operation> <list> [<element>...])
# A0 A1 A2...
# if ARGC <= 2, then we don't have to do anything
if(ARGC GREATER 2)
z_vcpkg_function_arguments(args 2)
if(list STREQUAL "")
set("${list_var}" "${args}" PARENT_SCOPE)
elseif(operation STREQUAL "APPEND")
set("${list_var}" "${list};${args}" PARENT_SCOPE)
else()
set("${list_var}" "${args};${list}" PARENT_SCOPE)
endif()
endif()
return()
endif()
if(operation STREQUAL "INSERT")
# vcpkg_list(INSERT <list> <index> [<element>...])
# A0 A1 A2 A3...
list(LENGTH list length)
if(ARGV2 LESS "-{$length}" OR ARGV2 GREATER length)
message(FATAL_ERROR "vcpkg_list index: ${ARGV2} out of range")
endif()
if(ARGC GREATER 3)
# list(LENGTH) is one of the few subcommands that's fine
list(LENGTH list length)
if(ARGV2 LESS "0")
math(EXPR ARGV2 "${length} + ${ARGV2}")
endif()
if(ARGV2 LESS "0" OR ARGV2 GREATER length)
message(FATAL_ERROR "list index: ${ARGV2} out of range (-${length}, ${length})")
endif()
z_vcpkg_function_arguments(args 3)
if(list STREQUAL "")
set("${list_var}" "${args}" PARENT_SCOPE)
elseif(ARGV2 EQUAL "0")
set("${list_var}" "${args};${list}" PARENT_SCOPE)
elseif(ARGV2 EQUAL length)
set("${list_var}" "${list};${args}" PARENT_SCOPE)
else()
vcpkg_list(SUBLIST list 0 "${ARGV2}" list_start)
vcpkg_list(SUBLIST list "${ARGV2}" -1 list_end)
set("${list_var}" "${list_start};${args};${list_end}" PARENT_SCOPE)
endif()
elseif(ARGC LESS 3)
message(FATAL_ERROR "vcpkg_list sub-command INSERT requires at least two arguments.")
endif()
return()
endif()
if(operation MATCHES "^(POP_BACK|POP_FRONT|REVERSE|REMOVE_DUPLICATES)$")
# vcpkg_list(<operation> <list>)
# A0 A1
if(NOT ARGC EQUAL 2)
message(FATAL_ERROR "vcpkg_list sub-command ${operation} requires one argument.")
endif()
z_vcpkg_list_escape_once_more(list)
list("${operation}" list)
set("${list_var}" "${list}" PARENT_SCOPE)
return()
endif()
if(operation MATCHES "^(REMOVE_AT|REMOVE_ITEM)$")
# vcpkg_list(<operation> <list> <index-or-item>)
# A0 A1 A2
if(NOT ARGC EQUAL 3)
message(FATAL_ERROR "vcpkg_list sub-command ${operation} requires two arguments.")
endif()
if(operation STREQUAL "REMOVE_AT")
list(LENGTH list length)
if(ARGV2 GREATER_EQUAL length OR ARGV2 LESS "-${length}")
message(FATAL_ERROR "vcpkg_list index: ${ARGV2} out of range")
endif()
endif()
z_vcpkg_list_escape_once_more(list)
string(REPLACE [[;]] [[\;]] ARGV2 "${ARGV2}")
list("${operation}" list "${ARGV2}")
set("${list_var}" "${list}" PARENT_SCOPE)
return()
endif()
message(FATAL_ERROR "vcpkg_list sub-command ${operation} is not yet implemented.")
endfunction()

35
externals/vcpkg/scripts/cmake/vcpkg_minimum_required.cmake vendored Executable file
View File

@@ -0,0 +1,35 @@
function(vcpkg_minimum_required)
cmake_parse_arguments(PARSE_ARGV 0 arg "" "VERSION" "")
if(NOT DEFINED VCPKG_BASE_VERSION)
message(FATAL_ERROR "Your vcpkg executable is outdated and is not compatible with the current CMake scripts.
Please re-acquire vcpkg by running bootstrap-vcpkg."
)
endif()
if(NOT DEFINED arg_VERSION)
message(FATAL_ERROR "VERSION must be specified")
endif()
set(vcpkg_date_regex "^[12][0-9][0-9][0-9]-[01][0-9]-[0-3][0-9]$")
if(NOT "${VCPKG_BASE_VERSION}" MATCHES "${vcpkg_date_regex}")
message(FATAL_ERROR
"vcpkg internal failure; VCPKG_BASE_VERSION (${VCPKG_BASE_VERSION}) was not a valid date."
)
endif()
if(NOT "${arg_VERSION}" MATCHES "${vcpkg_date_regex}")
message(FATAL_ERROR
"VERSION (${arg_VERSION}) was not a valid date - expected something of the form 'YYYY-MM-DD'"
)
endif()
string(REPLACE "-" "." VCPKG_BASE_VERSION_as_dotted "${VCPKG_BASE_VERSION}")
string(REPLACE "-" "." arg_VERSION_as_dotted "${arg_VERSION}")
if("${VCPKG_BASE_VERSION_as_dotted}" VERSION_LESS "${arg_VERSION_as_dotted}")
message(FATAL_ERROR
"Your vcpkg executable is from ${VCPKG_BASE_VERSION} which is older than required by the caller "
"of vcpkg_minimum_required(VERSION ${arg_VERSION}). "
"Please re-acquire vcpkg by running bootstrap-vcpkg."
)
endif()
endfunction()

5
externals/vcpkg/scripts/cmake/vcpkg_replace_string.cmake vendored Executable file
View File

@@ -0,0 +1,5 @@
function(vcpkg_replace_string filename match replace)
file(READ "${filename}" contents)
string(REPLACE "${match}" "${replace}" contents "${contents}")
file(WRITE "${filename}" "${contents}")
endfunction()

4
externals/vcpkg/scripts/cmake/vcpkg_test_cmake.cmake vendored Executable file
View File

@@ -0,0 +1,4 @@
# DEPRECATED
function(vcpkg_test_cmake)
message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_test_cmake was a no-op and has been removed. Please remove the call to `vcpkg_test_cmake()`.")
endfunction()

45
externals/vcpkg/scripts/cmake/z_vcpkg_apply_patches.cmake vendored Executable file
View File

@@ -0,0 +1,45 @@
function(z_vcpkg_apply_patches)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "QUIET" "SOURCE_PATH" "PATCHES")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "internal error: z_vcpkg_apply_patches was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
find_program(GIT NAMES git git.cmd REQUIRED)
if(DEFINED ENV{GIT_CONFIG_NOSYSTEM})
set(git_config_nosystem_backup "$ENV{GIT_CONFIG_NOSYSTEM}")
else()
unset(git_config_nosystem_backup)
endif()
set(ENV{GIT_CONFIG_NOSYSTEM} 1)
set(patchnum 0)
foreach(patch IN LISTS arg_PATCHES)
get_filename_component(absolute_patch "${patch}" ABSOLUTE BASE_DIR "${CURRENT_PORT_DIR}")
message(STATUS "Applying patch ${patch}")
set(logname "patch-${TARGET_TRIPLET}-${patchnum}")
vcpkg_execute_in_download_mode(
COMMAND "${GIT}" -c core.longpaths=true -c core.autocrlf=false --work-tree=. --git-dir=.git apply "${absolute_patch}" --ignore-whitespace --whitespace=nowarn --verbose
OUTPUT_FILE "${CURRENT_BUILDTREES_DIR}/${logname}-out.log"
ERROR_VARIABLE error
WORKING_DIRECTORY "${arg_SOURCE_PATH}"
RESULT_VARIABLE error_code
)
file(WRITE "${CURRENT_BUILDTREES_DIR}/${logname}-err.log" "${error}")
if(error_code)
if(arg_QUIET)
message(STATUS "Applying patch ${patch} - failure silenced")
else()
message(FATAL_ERROR "Applying patch failed: ${error}")
endif()
endif()
math(EXPR patchnum "${patchnum} + 1")
endforeach()
if(DEFINED git_config_nosystem_backup)
set(ENV{GIT_CONFIG_NOSYSTEM} "${git_config_nosystem_backup}")
else()
unset(ENV{GIT_CONFIG_NOSYSTEM})
endif()
endfunction()

8
externals/vcpkg/scripts/cmake/z_vcpkg_escape_regex_control_characters.cmake vendored Executable file
View File

@@ -0,0 +1,8 @@
function(z_vcpkg_escape_regex_control_characters out_var string)
if(ARGC GREATER "2")
message(FATAL_ERROR "z_vcpkg_escape_regex_control_characters passed extra arguments: ${ARGN}")
endif()
# uses | instead of [] to avoid confusion; additionally, CMake doesn't support `]` in a `[]`
string(REGEX REPLACE [[\[|\]|\(|\)|\.|\+|\*|\^|\\|\$|\?|\|]] [[\\\0]] escaped_content "${string}")
set("${out_var}" "${escaped_content}" PARENT_SCOPE)
endfunction()

12
externals/vcpkg/scripts/cmake/z_vcpkg_forward_output_variable.cmake vendored Executable file
View File

@@ -0,0 +1,12 @@
macro(z_vcpkg_forward_output_variable ptr_to_parent_var var_to_forward)
if("${ARGC}" GREATER "2")
message(FATAL_ERROR "z_vcpkg_forward_output_variable was passed extra arguments: ${ARGN}")
endif()
if(DEFINED "${ptr_to_parent_var}")
if(DEFINED "${var_to_forward}")
set("${${ptr_to_parent_var}}" "${${var_to_forward}}" PARENT_SCOPE)
else()
unset("${${ptr_to_parent_var}}" PARENT_SCOPE)
endif()
endif()
endmacro()

36
externals/vcpkg/scripts/cmake/z_vcpkg_function_arguments.cmake vendored Executable file
View File

@@ -0,0 +1,36 @@
# NOTE: this function definition is copied directly to scripts/buildsystems/vcpkg.cmake
# do not make changes here without making the same change there.
macro(z_vcpkg_function_arguments OUT_VAR)
if("${ARGC}" EQUAL 1)
set(z_vcpkg_function_arguments_FIRST_ARG 0)
elseif("${ARGC}" EQUAL 2)
set(z_vcpkg_function_arguments_FIRST_ARG "${ARGV1}")
if(NOT z_vcpkg_function_arguments_FIRST_ARG GREATER_EQUAL "0" AND NOT z_vcpkg_function_arguments_FIRST_ARG LESS "0")
message(FATAL_ERROR "z_vcpkg_function_arguments: index (${z_vcpkg_function_arguments_FIRST_ARG}) is not a number")
elseif(z_vcpkg_function_arguments_FIRST_ARG LESS "0" OR z_vcpkg_function_arguments_FIRST_ARG GREATER ARGC)
message(FATAL_ERROR "z_vcpkg_function_arguments: index (${z_vcpkg_function_arguments_FIRST_ARG}) out of range")
endif()
else()
# vcpkg bug
message(FATAL_ERROR "z_vcpkg_function_arguments: invalid arguments (${ARGV})")
endif()
set("${OUT_VAR}" "")
# this allows us to get the value of the enclosing function's ARGC
set(z_vcpkg_function_arguments_ARGC_NAME "ARGC")
set(z_vcpkg_function_arguments_ARGC "${${z_vcpkg_function_arguments_ARGC_NAME}}")
math(EXPR z_vcpkg_function_arguments_LAST_ARG "${z_vcpkg_function_arguments_ARGC} - 1")
# GREATER_EQUAL added in CMake 3.7
if(NOT z_vcpkg_function_arguments_LAST_ARG LESS z_vcpkg_function_arguments_FIRST_ARG)
foreach(z_vcpkg_function_arguments_N RANGE "${z_vcpkg_function_arguments_FIRST_ARG}" "${z_vcpkg_function_arguments_LAST_ARG}")
string(REPLACE ";" "\\;" z_vcpkg_function_arguments_ESCAPED_ARG "${ARGV${z_vcpkg_function_arguments_N}}")
# adds an extra ";" on the front
set("${OUT_VAR}" "${${OUT_VAR}};${z_vcpkg_function_arguments_ESCAPED_ARG}")
endforeach()
# and then removes that extra semicolon
string(SUBSTRING "${${OUT_VAR}}" 1 -1 "${OUT_VAR}")
endif()
endmacro()

38
externals/vcpkg/scripts/cmake/z_vcpkg_get_cmake_vars.cmake vendored Executable file
View File

@@ -0,0 +1,38 @@
function(z_vcpkg_get_cmake_vars out_file)
cmake_parse_arguments(PARSE_ARGV 1 arg "" "" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
if(DEFINED VCPKG_BUILD_TYPE)
set(cmake_vars_file "${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-${VCPKG_BUILD_TYPE}.cmake.log")
set(cache_var "Z_VCPKG_GET_CMAKE_VARS_FILE_${VCPKG_BUILD_TYPE}")
else()
set(cmake_vars_file "${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}.cmake.log")
set(cache_var Z_VCPKG_GET_CMAKE_VARS_FILE)
endif()
if(NOT DEFINED CACHE{${cache_var}})
set(${cache_var} "${cmake_vars_file}"
CACHE PATH "The file to include to access the CMake variables from a generated project.")
vcpkg_configure_cmake(
SOURCE_PATH "${SCRIPTS}/get_cmake_vars"
OPTIONS_DEBUG "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log"
OPTIONS_RELEASE "-DVCPKG_OUTPUT_FILE:PATH=${CURRENT_BUILDTREES_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log"
PREFER_NINJA
LOGNAME get-cmake-vars-${TARGET_TRIPLET}
Z_GET_CMAKE_VARS_USAGE # ignore vcpkg_cmake_configure, be quiet, don't set variables...
)
set(include_string "")
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
string(APPEND include_string "include(\"\${CMAKE_CURRENT_LIST_DIR}/cmake-vars-${TARGET_TRIPLET}-rel.cmake.log\")\n")
endif()
if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
string(APPEND include_string "include(\"\${CMAKE_CURRENT_LIST_DIR}/cmake-vars-${TARGET_TRIPLET}-dbg.cmake.log\")\n")
endif()
file(WRITE "${cmake_vars_file}" "${include_string}")
endif()
set("${out_file}" "${${cache_var}}" PARENT_SCOPE)
endfunction()

15
externals/vcpkg/scripts/cmake/z_vcpkg_prettify_command_line.cmake vendored Executable file
View File

@@ -0,0 +1,15 @@
function(z_vcpkg_prettify_command_line out_var)
set(output_list "")
z_vcpkg_function_arguments(args 1)
foreach(v IN LISTS args)
string(REPLACE [[\]] [[\\]] v "${v}")
if(v MATCHES "( )")
string(REPLACE [["]] [[\"]] v "${v}")
list(APPEND output_list "\"${v}\"")
else()
list(APPEND output_list "${v}")
endif()
endforeach()
list(JOIN output_list " " output)
set("${out_var}" "${output}" PARENT_SCOPE)
endfunction()

35
externals/vcpkg/scripts/cmake/z_vcpkg_setup_pkgconfig_path.cmake vendored Executable file
View File

@@ -0,0 +1,35 @@
function(z_vcpkg_setup_pkgconfig_path)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "BASE_DIRS")
if(NOT DEFINED arg_BASE_DIRS OR "${arg_BASE_DIRS}" STREQUAL "")
message(FATAL_ERROR "BASE_DIRS is required.")
endif()
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
vcpkg_backup_env_variables(VARS PKG_CONFIG PKG_CONFIG_PATH)
vcpkg_find_acquire_program(PKGCONFIG)
get_filename_component(pkgconfig_path "${PKGCONFIG}" DIRECTORY)
vcpkg_add_to_path("${pkgconfig_path}")
set(ENV{PKG_CONFIG} "${PKGCONFIG}") # Set via native file?
foreach(base_dir IN LISTS arg_BASE_DIRS)
vcpkg_host_path_list(PREPEND ENV{PKG_CONFIG_PATH} "${base_dir}/share/pkgconfig/")
endforeach()
foreach(base_dir IN LISTS arg_BASE_DIRS)
vcpkg_host_path_list(PREPEND ENV{PKG_CONFIG_PATH} "${base_dir}/lib/pkgconfig/")
endforeach()
endfunction()
function(z_vcpkg_restore_pkgconfig_path)
cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "" "")
if(DEFINED arg_UNPARSED_ARGUMENTS)
message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
endif()
vcpkg_restore_env_variables(VARS PKG_CONFIG PKG_CONFIG_PATH)
endfunction()