commit: 88e2ca3511032435742bd8d7d1c01d8a29588ba3 Author: Andrei Horodniceanu <a.horodniceanu <AT> proton <DOT> me> AuthorDate: Sat Mar 2 14:27:21 2024 +0000 Commit: Horodniceanu Andrei <a.horodniceanu <AT> proton <DOT> me> CommitDate: Sat Apr 13 22:47:25 2024 +0000 URL: https://gitweb.gentoo.org/repo/user/dlang.git/commit/?id=88e2ca35
dlang-compilers-r1.eclass: new eclass Signed-off-by: Andrei Horodniceanu <a.horodniceanu <AT> proton.me> eclass/dlang-compilers-r1.eclass | 293 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 293 insertions(+) diff --git a/eclass/dlang-compilers-r1.eclass b/eclass/dlang-compilers-r1.eclass new file mode 100644 index 0000000..933b05a --- /dev/null +++ b/eclass/dlang-compilers-r1.eclass @@ -0,0 +1,293 @@ +# Copyright 2024 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +# @ECLASS: dlang-compilers-r1.eclass +# @MAINTAINER: +# Andrei Horodniceanu <[email protected]> +# @AUTHOR: +# Andrei Horodniceanu <[email protected]> +# Based on dlang-compilers.eclass by Marco Leise <[email protected]>. +# @BUGREPORTS: +# Please report bugs via https://github.com/gentoo/dlang/issues +# @VCSURL: https://github.com/gentoo/dlang +# @BLURB: Support data for dlang-utils.eclass +# @DESCRIPTION: +# Contains the available D compiler versions with their stable +# architectures and the language version they support. + +if [[ ! ${_DLANG_COMPILERS_R1_ECLASS} ]] ; then +_DLANG_COMPILERS_R1_ECLASS=1 + +# @ECLASS_VARIABLE: _DLANG_DMD_FRONTENDS +# @INTERNAL +# @DESCRIPTION: +# A list of dmd implementations with their dlang frontend version (which +# happens to coincide with the implementation version) and the +# architectures they support as a list of keywords. Only stable and +# unstable keywords will appear. +# +# The elements are ordered, the higher implementation version has the +# higher index. +# +# Example value for an element: +# @CODE +# "2.102 2.102 ~amd64 x86" +# @CODE +# Where the first 2.102 represents the implementation version, +# the second one represents the D language version the implementation +# supports and, lastly, there are two keywords. +readonly _DLANG_DMD_FRONTENDS=( + "2.101 2.101 ~amd64 ~x86" + "2.102 2.102 ~amd64 ~x86" + "2.103 2.103 ~amd64 ~x86" + "2.104 2.104 ~amd64 ~x86" + "2.105 2.105 ~amd64 ~x86" + "2.106 2.106 ~amd64 ~x86" + "2.107 2.107 ~amd64 ~x86" +) + +# @ECLASS_VARIABLE: _DLANG_GDC_FRONTENDS +# @INTERNAL +# @DESCRIPTION: +# A list of gdc implementations with their dlang frontend version and +# the architectures they support as a list of keywords. Only stable and +# unstable keywords will appear. +# +# The elements are ordered, the higher implementation version has the +# higher index. +# +# Example value for an element: +# @CODE +# "13 2.103 amd64 ~arm64 x86" +# @CODE +# Where 13 represents the implementation version, 2.103 represents the D +# language version the implementation supports and, lastly, there are +# three keywords. +readonly _DLANG_GDC_FRONTENDS=( + "12 2.100 ~amd64 ~arm64 ~x86" + "13 2.103 ~amd64 ~arm64 ~x86" +) + +# @ECLASS_VARIABLE: _DLANG_LDC2_FRONTENDS +# @INTERNAL +# @DESCRIPTION: +# A list of ldc2 implementations with their dlang frontend version and +# the architectures they support as a list of keywords. Only stable and +# unstable keywords will appear. +# +# The elements are ordered, the higher implementation version has the +# higher index. +# +# Example value for an element: +# @CODE +# 1.34 2.104 ~amd64 ~arm64 +# @CODE +# Where 1.34 represents the implementation version, 2.104 represents the +# D language version the implementation supports and, lastly, there are +# two keywords. +readonly _DLANG_LDC2_FRONTENDS=( + "1.32 2.102 ~amd64 ~arm64 ~x86" + "1.33 2.103 ~amd64 ~arm64 ~x86" + "1.34 2.104 ~amd64 ~arm64 ~x86" + "1.35 2.105 ~amd64 ~arm64 ~x86" + "1.36 2.106 ~amd64 ~arm64 ~x86" +) + +# @FUNCTION: _dlang_accumulate_implementations +# @INTERNAL +# @DESCRIPTION: +# Set the global variable _DLANG_ALL_IMPLS based on the three arrays: +# _DLANG_(DMD|LDC2|GDC)_FRONTENDS. This function should be called once, +# in global scope. +_dlang_accumulate_implementations() { + local line result=() + for line in "${_DLANG_DMD_FRONTENDS[@]/#/dmd-}" \ + "${_DLANG_GDC_FRONTENDS[@]/#/gdc-}" \ + "${_DLANG_LDC2_FRONTENDS[@]/#/ldc2-}" + do + line=( ${line} ) + # We only need the first component (name + version) + local impl=${line[0]/\./_} + result+=( "${impl}" ) + done + + if [[ ${_DLANG_ALL_IMPLS+1} ]]; then + if [[ ${_DLANG_ALL_IMPLS[@]} != ${result[@]} ]]; then + eerror "_DLANG_ALL_IMPLS has changed between inherits!" + eerror "Before: ${_DLANG_ALL_IMPLS[*]}" + eerror "Now : ${result[*]}" + die "_DLANG_ALL_IMPLS integrity check failed!" + fi + else + _DLANG_ALL_IMPLS=( "${result[@]}" ) + readonly _DLANG_ALL_IMPLS + fi +} +_dlang_accumulate_implementations +unset -f _dlang_accumulate_implementations + +# @ECLASS_VARIABLE: _DLANG_ALL_IMPLS +# @INTERNAL +# @DESCRIPTION: +# All supported Dlang implementations, most preferred last. + +# @ECLASS_VARIABLE: _DLANG_HISTORICAL_IMPLS +# @INTERNAL +# @DESCRIPTION: +# All historical Dlang implementations that are no longer supported. +readonly _DLANG_HISTORICAL_IMPLS=( + gdc-11 +) + +# @FUNCTION: dlang_compilers_stabs_required_use +# @USAGE: <use_expand_name> [<impls>...] +# @DESCRIPTION: +# Generate a required-use expression which ensures that only supported +# implementations can be selected. +# +# Check _dlang_get_bad_arches for a more detailed description of what +# an implementation being supported means. +# +# <use_expand_name> is a string used to transform implementations as +# they appear in <impls> into USE flags. Possible values are +# "dlang_targets" and "dlang_single_target". +# +# Example: If we had the implementation dmd-2_105 with the keywords, +# i.e. the keywords in _DLANG_DMD_FRONTENDS, `amd64 ~x86' and $KEYWORDS +# has the contents `amd64 arm64 x86' the output should be: +# @CODE +# "<use_expand_name>_dmd-2_105? ( !x86 ) <use_expand_name>_dmd-2_105? ( !arm64 )" +# @CODE +dlang_compilers_stabs_required_use() { + debug-print-function ${FUNCNAME} "${@}" + + local use_expand_name=${1} + local impls=( ${@:2} ) + + local result=() impl + for impl in "${impls[@]}"; do + local badArches=( $(_dlang_get_bad_arches "${impl}") ) + local arch + for arch in "${badArches[@]}"; do + result+=( "${use_expand_name}_${impl}? ( !${arch} )" ) + done + done + + echo "${result[@]}" +} + +# @FUNCTION: dlang_compilers_stabs_impl_dep +# @USAGE: <impl> <dep_string> +# @DESCRIPTION: +# Print a dependency string based on <dep_string>, USE disabled on +# architectures found in $KEYWORDS that are not supported by <impl>. +# +# To see what it means for an architecture to be unsupported check +# _dlang_get_bad_arches. +# +# Example: If we had the implementation dmd-2_105 with the keywords, +# i.e. the keywords in _DLANG_DMD_FRONTENDS, `amd64 ~x86' and $KEYWORDS +# has the contents `amd64 arm64 x86' the output should be: +# @CODE +# "!arm64? ( !x86? ( <dep_string> ) ) " +# @CODE +# Where <dep_string> looks like `dlang_single_target_dmd-2_105? ( dev-lang/dmd:2.105= ) ' +dlang_compilers_stabs_impl_dep() { + debug-print-function ${FUNCNAME} "${@}" + + local impl=${1} dep=${2} + local badArches=( $(_dlang_get_bad_arches "${impl}") ) + + local arch + for arch in "${badArches[@]}"; do + dep="!${arch}? ( ${dep}) " + done + + echo "${dep}" +} + +# @FUNCTION: _dlang_get_bad_arches +# @USAGE: <impl> +# @INTERNAL +# @DESCRIPTION: +# Output a string of all the arches that are unsupported by <impl> in +# regards to $KEYWORDS. +# +# An architecture is considered unsupported if it: +# +# - appears in $KEYWORDS (either as stable or unstable) and it doesn't +# appear in the keywords of <impl>, the ones from the +# _DLANG_*_FRONTENDS arrays. +# +# - appears in $KEYWORDS as stable and it appears in the keywords of +# <impl> as unstable. +# +# For example, if we had the implementation dmd-2_105 with the keywords, +# i.e. the keywords in _DLANG_DMD_FRONTENDS, `amd64 ~x86' and $KEYWORDS +# has the contents `amd64 arm64 x86' the output should be, in no +# particular order: +# @CODE +# x86 arm64 +# @CODE +_dlang_get_bad_arches() { + debug-print-function ${FUNCNAME} "${@}" + + local details=( $(_dlang_get_impl_details "${1}") ) + local implKeywords=( ${details[@]:2} ) + + local result=() keyword + # Meh, $KEYWORDS can contain -* (like for dmd) and that is globing + # so bad. + local keywords + read -ra keywords <<<"${KEYWORDS}" + for keyword in "${keywords[@]}"; do + [[ ${keyword::1} == - ]] && continue + + local arch=${keyword} + [[ ${keyword::1} == "~" ]] && arch=${keyword:1} + + local found=0 + if [[ ${keyword::1} == "~" ]]; then + # An unstable package accepts a stable or an unstable implementation + has "${arch}" "${implKeywords[@]}" && found=1 + has "~${arch}" "${implKeywords[@]}" && found=1 + else + # A stable package accepts only a stable implementation + has "${arch}" "${implKeywords[@]}" && found=1 + fi + + if [[ ${found} == 0 ]]; then + result+=( "${arch}" ) + fi + done + + echo "${result[@]}" +} + +# @FUNCTION: _dlang_get_impl_details +# @USAGE: <impl> +# @INTERNAL +# @DESCRIPTION: +# Print the details of the implementation denoted by <impl>, as they +# appear in _DLANG_*_FRONTENDS. +_dlang_get_impl_details() { + debug-print-function ${FUNCNAME} "${@}" + + local impl="${1/_/.}" + + # Yay, optimizations + local name=${impl%-*} ver=${impl#*-} + local arr=_DLANG_${name^^}_FRONTENDS[@] + + local details + for details in "${!arr}"; do + if [[ ${details%% *} == ${ver} ]]; then + echo "${details}" + return + fi + done + + die "Unknown implementation: ${impl}" +} + +fi
