[continued from previous message]

x=${x#-Wl,};
set -- "$@" ${x//,/ }
;;
*)

;;
esac;
done;
echo "$@"
}
replace-cpu-flags ()
{
local newcpu="$#";
newcpu="${!newcpu}";
while [ $# -gt 1 ]; do
replace-flags "-march=${1}" "-march=${newcpu}";
replace-flags "-mcpu=${1}" "-mcpu=${newcpu}";
replace-flags "-mtune=${1}" "-mtune=${newcpu}";
shift;
done;
return 0
}
replace-flags ()
{
[[ $# != 2 ]] && die "Usage: replace-flags <old flag> <new flag>";
local f var new;
for var in $(all-flag-vars);
do
new=();
for f in ${!var};
do
[[ ${f} == ${1} ]] && f=${2};
new+=("${f}");
done;
export ${var}="${new[*]}";
done;
return 0
}
replace-sparc64-flags ()
{
[[ $# -ne 0 ]] && die "replace-sparc64-flags takes no arguments";
local SPARC64_CPUS="ultrasparc3 ultrasparc v9";
if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
for x in ${SPARC64_CPUS};
do
CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}";
done;
else
for x in ${SPARC64_CPUS};
do
CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}";
done;
fi;
if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
for x in ${SPARC64_CPUS};
do
CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}";
done;
else
for x in ${SPARC64_CPUS};
do
CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}";
done;
fi;
export CFLAGS CXXFLAGS
}
setup-allowed-flags ()
{
[[ ${EAPI} == 7 ]] || die "Internal function ${FUNCNAME} is not available in EAPI ${EAPI}.";
_setup-allowed-flags "$@"
}
src_compile ()
{
ego build
}
src_configure ()
{
default
}
src_install ()
{
dobin goimapnotify;
systemd_dounit "${FILESDIR}"/goimapnotify@.service
}
src_prepare ()
{
default
}
src_test ()
{
default
}
src_unpack ()
{
go-module_src_unpack "$@"
}
strip-flags ()
{
[[ $# -ne 0 ]] && die "strip-flags takes no arguments";
local x y var;
local ALLOWED_FLAGS;
_setup-allowed-flags;
set -f;
for var in $(all-flag-vars);
do
local new=();
for x in ${!var};
do
for y in "${ALLOWED_FLAGS[@]}";
do
if [[ ${x} == ${y} ]]; then
new+=("${x}");
break;
fi;
done;
done;
if _is_flagq ${var} "-O*" && ! _is_flagq new "-O*"; then
new+=(-O2);
fi;
if [[ ${!var} != "${new[*]}" ]]; then
einfo "strip-flags: ${var}: changed '${!var}' to '${new[*]}'";
fi;
export ${var}="${new[*]}";
done;
set +f;
return 0
}
strip-unsupported-flags ()
{
[[ $# -ne 0 ]] && die "strip-unsupported-flags takes no arguments";
export CFLAGS=$(test-flags-CC ${CFLAGS});
export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS});
export FFLAGS=$(test-flags-F77 ${FFLAGS});
export FCFLAGS=$(test-flags-FC ${FCFLAGS});
export LDFLAGS=$(test-flags-CCLD ${LDFLAGS})
}
systemd_dounit ()
{
debug-print-function ${FUNCNAME} "$@";
( insopts -m 0644;
insinto "$(_systemd_unprefix systemd_get_systemunitdir)";
doins "${@}" )
}
systemd_douserunit ()
{
debug-print-function ${FUNCNAME} "$@";
( insopts -m 0644;
insinto "$(_systemd_unprefix systemd_get_userunitdir)";
doins "${@}" )
}
systemd_enable_ntpunit ()
{
debug-print-function ${FUNCNAME} "$@";
if [[ ${#} -lt 2 ]]; then
die "Usage: systemd_enable_ntpunit <NN-name> <service>...";
fi;
local ntpunit_name=${1};
local services=("${@:2}");
if [[ ${ntpunit_name} != [0-9][0-9]-* ]]; then
die "ntpunit.d file must be named NN-name where NN are digits.";
else
if [[ ${ntpunit_name} == *.list ]]; then
die "The .list suffix is appended implicitly to ntpunit.d name.";
fi;
fi;
local unitdir=$(systemd_get_systemunitdir);
local s;
for s in "${services[@]}";
do
if [[ ! -f "${D}${unitdir}/${s}" ]]; then
die "ntp-units.d provider ${s} not installed (yet?) in \${D}.";
fi;
echo "${s}" >> "${T}"/${ntpunit_name}.list || die;
done;
( insopts -m 0644;
insinto "$(_systemd_unprefix systemd_get_utildir)"/ntp-units.d;
doins "${T}"/${ntpunit_name}.list );
local ret=${?};
rm "${T}"/${ntpunit_name}.list || die;
return ${ret}
}
systemd_enable_service ()
{
debug-print-function ${FUNCNAME} "$@";
[[ ${#} -eq 2 ]] || die "Synopsis: systemd_enable_service target service";
local target=${1};
local service=${2};
local ud=$(_systemd_unprefix systemd_get_systemunitdir);
local destname=${service##*/};
dodir "${ud}"/"${target}".wants && dosym ../"${service}" "${ud}"/"${target}".wants/"${destname}"
}
systemd_get_sleepdir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemdsleepdir /lib/systemd/system-sleep
}
systemd_get_systemgeneratordir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemdsystemgeneratordir /lib/systemd/system-generators
}
systemd_get_systempresetdir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemdsystempresetdir /lib/systemd/system-preset
}
systemd_get_systemunitdir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemdsystemunitdir /lib/systemd/system
}
systemd_get_userunitdir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemduserunitdir /usr/lib/systemd/user
}
systemd_get_utildir ()
{
debug-print-function ${FUNCNAME} "$@";
_systemd_get_dir systemdutildir /lib/systemd
}
systemd_install_dropin ()
{
debug-print-function ${FUNCNAME} "$@";
local basedir;
if [[ $# -ge 1 ]] && [[ $1 == "--user" ]]; then
basedir=$(_systemd_unprefix systemd_get_userunitdir);
shift 1;
else
basedir=$(_systemd_unprefix systemd_get_systemunitdir);
fi;
local unit=${1};
local src=${2};
[[ -n ${unit} ]] || die "No unit specified";
[[ -n ${src} ]] || die "No conf file specified";
[[ ${unit} == *.d ]] && die "Unit ${unit} must not have .d suffix";
( insopts -m 0644;
insinto "${basedir}/${unit}".d;
newins "${src}" 00gentoo.conf )
}
systemd_install_serviced ()
{
debug-print-function ${FUNCNAME} "$@";
local src=${1};
local service=${2};
[[ -n ${src} ]] || die "No file specified";
if [[ ! -n ${service} ]]; then
[[ ${src} == *.conf ]] || die "Source file needs .conf suffix";
service=${src##*/};
service=${service%.conf};
fi;
[[ ${service} == *.d ]] && die "Service must not have .d suffix";
( insopts -m 0644;
insinto /etc/systemd/system/"${service}".d;
newins "${src}" 00gentoo.conf )
}
systemd_is_booted ()
{
debug-print-function ${FUNCNAME} "$@";
[[ -d /run/systemd/system ]];
local ret=${?};
debug-print "${FUNCNAME}: [[ -d /run/systemd/system ]] -> ${ret}";
return ${ret}
}
systemd_newunit ()
{
debug-print-function ${FUNCNAME} "$@";
( insopts -m 0644;
insinto "$(_systemd_unprefix systemd_get_systemunitdir)";
newins "${@}" )
}
systemd_newuserunit ()
{
debug-print-function ${FUNCNAME} "$@";
( insopts -m 0644;
insinto "$(_systemd_unprefix systemd_get_userunitdir)";
newins "${@}" )
}
systemd_reenable ()
{
type systemctl &> /dev/null || return 0;
local x;
for x in "$@";
do
if systemctl --quiet --root="${ROOT:-/}" is-enabled "${x}"; then
systemctl --root="${ROOT:-/}" reenable "${x}";
fi;
done
}
systemd_update_catalog ()
{
debug-print-function ${FUNCNAME} "$@";
[[ ${EBUILD_PHASE} == post* ]] || die "${FUNCNAME} disallowed during ${EBUILD_PHASE_FUNC:-${EBUILD_PHASE}}";
local journalctl=${EPREFIX}/usr/bin/journalctl;
if [[ -x ${journalctl} ]]; then
ebegin "Updating systemd journal catalogs";
journalctl --update-catalog;
eend $?;
else
debug-print "${FUNCNAME}: journalctl not found.";
fi
}
tc-arch ()
{
tc-ninja_magic_to_arch portage "$@"
}
tc-arch-kernel ()
{
tc-ninja_magic_to_arch kern "$@"
}
tc-check-openmp ()
{
if ! _tc-has-openmp; then
eerror "Your current compiler does not support OpenMP!";
if tc-is-gcc; then
eerror "Enable OpenMP support by building sys-devel/gcc with USE=\"openmp\".";
else
if tc-is-clang; then
eerror "OpenMP support in sys-devel/clang is provided by sys-libs/libomp.";
fi;
fi;
die "Active compiler does not have required support for OpenMP";
fi
}
tc-cpp-is-true ()
{
local CONDITION=${1};
shift;
$(tc-getTARGET_CPP) "${@}" -P - <<-EOF > /dev/null 2>&1
#if ${CONDITION}
true
#else
#error false
#endif
EOF

}
tc-detect-is-softfloat ()
{
[[ $(tc-getTARGET_CPP) == "gcc -E" ]] && return 1;
case ${CTARGET:-${CHOST}} in
*-newlib | *-elf | *-eabi | arm64-apple-darwin*)
return 1
;;
arm*)
if tc-cpp-is-true "defined(__ARM_PCS_VFP)"; then
echo "no";
else
if tc-cpp-is-true "defined(__SOFTFP__)"; then
echo "yes";
else
echo "softfp";
fi;
fi;
return 0
;;
*)
return 1
;;
esac
}
tc-enables-cxx-assertions ()
{
tc-cpp-is-true "defined(_GLIBCXX_ASSERTIONS) || defined(_LIBCPP_ENABLE_ASSERTIONS) || defined(_LIBCPP_ENABLE_HARDENED_MODE)" ${CPPFLAGS} ${CXXFLAGS}
}
tc-enables-fortify-source ()
{
tc-cpp-is-true "defined(_FORTIFY_SOURCE)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS} }
tc-enables-pie ()
{
tc-cpp-is-true "defined(__PIE__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp ()
{
tc-cpp-is-true "defined(__SSP__) || defined(__SSP_STRONG__) || defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp-all ()
{
tc-cpp-is-true "defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-enables-ssp-strong ()
{
tc-cpp-is-true "defined(__SSP_STRONG__) || defined(__SSP_ALL__)" ${CPPFLAGS} ${CFLAGS} ${CXXFLAGS}
}
tc-endian ()
{
local host=$1;
[[ -z ${host} ]] && host=${CTARGET:-${CHOST}};
host=${host%%-*};
case ${host} in
aarch64*be)
echo big
;;
aarch64)
echo little
;;
alpha*)
echo little
;;
arc*b*)
echo big
;;
arc*)
echo little
;;
arm*b*)
echo big
;;
arm*)
echo little
;;
cris*)
echo little
;;
hppa*)
echo big
;;
i?86*)
echo little
;;
ia64*)
echo little
;;
loongarch*)
echo little
;;
m68*)
echo big
;;
mips*l*)
echo little
;;
mips*)
echo big
;;
powerpc*le)
echo little
;;
powerpc*)
echo big
;;
riscv*)
echo little
;;
s390*)
echo big
;;
sh*b*)
echo big
;;
sh*)
echo little
;;
sparc*)
echo big
;;
x86_64*)
echo little
;;
*)
echo wtf
;;
esac
}
tc-env_build ()
{
tc-export_build_env;
CFLAGS=${BUILD_CFLAGS} CXXFLAGS=${BUILD_CXXFLAGS} CPPFLAGS=${BUILD_CPPFLAGS} LDFLAGS=${BUILD_LDFLAGS} AR=$(tc-getBUILD_AR) AS=$(tc-getBUILD_AS) CC=$(tc-getBUILD_CC) CPP=$(tc-getBUILD_CPP) CXX=$(tc-getBUILD_CXX) LD=$(tc-getBUILD_LD) NM=$(tc-getBUILD_
NM) PKG_CONFIG=$(tc-getBUILD_PKG_CONFIG) RANLIB=$(tc-getBUILD_RANLIB) READELF=$(tc-getBUILD_READELF) "$@"
}
tc-export ()
{
local var;
for var in "$@";
do
[[ $(type -t "tc-get${var}") != "function" ]] && die "tc-export: invalid export variable '${var}'";
"tc-get${var}" > /dev/null;
done
}
tc-export_build_env ()
{
tc-export "$@";
if tc-is-cross-compiler; then
: "${BUILD_CFLAGS:=-O1 -pipe}";
: "${BUILD_CXXFLAGS:=-O1 -pipe}";
: "${BUILD_CPPFLAGS:= }";
: "${BUILD_LDFLAGS:= }";
else
: "${BUILD_CFLAGS:=${CFLAGS}}";
: "${BUILD_CXXFLAGS:=${CXXFLAGS}}";
: "${BUILD_CPPFLAGS:=${CPPFLAGS}}";
: "${BUILD_LDFLAGS:=${LDFLAGS}}";
fi;
export BUILD_{C,CXX,CPP,LD}FLAGS;
local v;
for v in BUILD_{C,CXX,CPP,LD}FLAGS;
do
export ${v#BUILD_}_FOR_BUILD="${!v}";
done
}
tc-get-build-ptr-size ()
{
$(tc-getBUILD_CPP) -P - <<< __SIZEOF_POINTER__ || die "Could not determine CBUILD pointer size"
}
tc-get-c-rtlib ()
{
local res=$($(tc-getCC) ${CPPFLAGS} ${CFLAGS} ${LDFLAGS} -print-libgcc-file-name 2> /dev/null);
case ${res} in
*libclang_rt*)
echo compiler-rt
;;
*libgcc*)
echo libgcc
;;
*)
return 1
;;
esac;
return 0
}
tc-get-compiler-type ()
{
local code='
#if defined(__PATHSCALE__)
HAVE_PATHCC
#elif defined(__clang__)
HAVE_CLANG
#elif defined(__GNUC__)
HAVE_GCC
#endif
';
local res=$($(tc-getCPP "$@") -E -P - <<< "${code}");
case ${res} in
*HAVE_PATHCC*)
echo pathcc
;;
*HAVE_CLANG*)
echo clang
;;
*HAVE_GCC*)
echo gcc
;;
*)
echo unknown
;;
esac
}
tc-get-cxx-stdlib ()
{
local code='#include <ciso646>

#if defined(_LIBCPP_VERSION)
HAVE_LIBCXX
#elif defined(__GLIBCXX__)
HAVE_LIBSTDCPP
#endif
';
local res=$($(tc-getCXX) ${CPPFLAGS} ${CXXFLAGS} -x c++ -E -P - <<< "${code}" 2> /dev/null);
case ${res} in
*HAVE_LIBCXX*)
echo libc++
;;
*HAVE_LIBSTDCPP*)
echo libstdc++
;;
*)
return 1
;;
esac;
return 0
}
tc-get-ptr-size ()
{
$(tc-getCPP) -P - <<< __SIZEOF_POINTER__ || die "Could not determine CHOST pointer size"
}
tc-getAR ()
{
tc-getPROG AR ar "$@"
}
tc-getAS ()
{
tc-getPROG AS as "$@"
}
tc-getBUILD_AR ()
{
tc-getBUILD_PROG AR ar "$@"
}
tc-getBUILD_AS ()
{
tc-getBUILD_PROG AS as "$@"
}
tc-getBUILD_CC ()
{
tc-getBUILD_PROG CC gcc "$@"
}
tc-getBUILD_CPP ()
{
tc-getBUILD_PROG CPP "$(tc-getBUILD_CC) -E" "$@"
}
tc-getBUILD_CXX ()
{
tc-getBUILD_PROG CXX g++ "$@"
}
tc-getBUILD_LD ()
{
tc-getBUILD_PROG LD ld "$@"
}
tc-getBUILD_NM ()
{
tc-getBUILD_PROG NM nm "$@"
}
tc-getBUILD_OBJCOPY ()
{
tc-getBUILD_PROG OBJCOPY objcopy "$@"
}
tc-getBUILD_PKG_CONFIG ()
{
tc-getBUILD_PROG PKG_CONFIG pkg-config "$@"
}
tc-getBUILD_PROG ()
{
local vars="BUILD_$1 $1_FOR_BUILD HOST$1";
tc-is-cross-compiler || vars+=" $1";
_tc-getPROG CBUILD "${vars}" "${@:2}"
}
tc-getBUILD_RANLIB ()
{
tc-getBUILD_PROG RANLIB ranlib "$@"
}
tc-getBUILD_READELF ()
{
tc-getBUILD_PROG READELF readelf "$@"
}
tc-getBUILD_STRINGS ()
{
tc-getBUILD_PROG STRINGS strings "$@"
}
tc-getBUILD_STRIP ()
{
tc-getBUILD_PROG STRIP strip "$@"
}
tc-getCC ()
{
tc-getPROG CC gcc "$@"
}
tc-getCPP ()
{
tc-getPROG CPP "${CC:-gcc} -E" "$@"
}
tc-getCXX ()
{
tc-getPROG CXX g++ "$@"
}
tc-getDLLWRAP ()
{
tc-getPROG DLLWRAP dllwrap "$@"
}
tc-getF77 ()
{
tc-getPROG F77 gfortran "$@"
}
tc-getFC ()
{
tc-getPROG FC gfortran "$@"
}
tc-getGCJ ()
{
tc-getPROG GCJ gcj "$@"
}
tc-getGO ()
{
tc-getPROG GO gccgo "$@"
}
tc-getLD ()
{
tc-getPROG LD ld "$@"
}
tc-getNM ()
{
tc-getPROG NM nm "$@"
}
tc-getOBJCOPY ()
{
tc-getPROG OBJCOPY objcopy "$@"
}
tc-getOBJDUMP ()
{
tc-getPROG OBJDUMP objdump "$@"
}
tc-getPKG_CONFIG ()
{
tc-getPROG PKG_CONFIG pkg-config "$@"
}
tc-getPROG ()
{
_tc-getPROG CHOST "$@"
}
tc-getRANLIB ()
{
tc-getPROG RANLIB ranlib "$@"
}
tc-getRC ()
{
tc-getPROG RC windres "$@"
}
tc-getREADELF ()
{
tc-getPROG READELF readelf "$@"
}
tc-getSTRINGS ()
{
tc-getPROG STRINGS strings "$@"
}
tc-getSTRIP ()
{
tc-getPROG STRIP strip "$@"
}
tc-getTARGET_CPP ()
{
if [[ -n ${CTARGET} ]]; then
_tc-getPROG CTARGET TARGET_CPP "gcc -E" "$@";
else
tc-getCPP "$@";
fi
}
tc-has-64bit-time_t ()
{
$(tc-getCC) ${CFLAGS} ${CPPFLAGS} -c -x c - -o /dev/null <<-EOF &> /dev/null
#include <sys/types.h>
int test[sizeof(time_t) >= 8 ? 1 : -1];
EOF

return $?
}
tc-has-tls ()
{
local base="${T}/test-tc-tls";
cat <<-EOF > "${base}.c"
int foo(int *i) {
static __thread int j = 0;
return *i ? j : *i;
}
EOF

local flags;
case $1 in
-s)
flags="-S"
;;
-c)
flags="-c"
;;
-l)

;;
-*)
die "Usage: tc-has-tls [-c|-l] [toolchain prefix]"
;;
esac;
case "${CHOST}" in
*-darwin*)
: ${flags:=-dynamiclib}
;;
*)
: ${flags:=-fPIC -shared -Wl,-z,defs}
;;
esac;
[[ $1 == -* ]] && shift;
$(tc-getCC "$@") ${flags} "${base}.c" -o "${base}" >&/dev/null;
local ret=$?;
rm -f "${base}"*;
return ${ret}
}
tc-is-clang ()
{
[[ $(tc-get-compiler-type) == clang ]]
}
tc-is-cross-compiler ()
{
[[ ${CBUILD:-${CHOST}} != ${CHOST} ]]
}
tc-is-gcc ()
{
[[ $(tc-get-compiler-type) == gcc ]]
}
tc-is-lto ()
{
local f="${T}/test-lto.o";
local ret=1;
case $(tc-get-compiler-type) in
clang)
$(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die;
llvm-bcanalyzer "${f}" &> /dev/null && ret=0
;;
gcc)
$(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die;
[[ $($(tc-getREADELF) -S "${f}") == *.gnu.lto* ]] && ret=0
;;
esac;
rm -f "${f}" || die;
return "${ret}"
}
tc-is-softfloat ()
{
tc-detect-is-softfloat || tc-tuple-is-softfloat
}
tc-is-static-only ()
{
local host=${CTARGET:-${CHOST}};
[[ ${host} == *-mint* ]]
}
tc-ld-disable-gold ()
{
tc-ld-is-gold "$@" && tc-ld-force-bfd "$@"
}
tc-ld-force-bfd ()
{
if tc-ld-is-bfd "$@"; then
return;
fi;
ewarn "Forcing usage of the BFD linker";
local ld=$(unset LD; tc-getLD "$@");
local bfd_ld="${ld}.bfd";
local path_ld=$(type -P "${bfd_ld}" 2> /dev/null);
[[ -e ${path_ld} ]] && export LD=${bfd_ld};
if tc-is-gcc || tc-is-clang; then
export CFLAGS="${CFLAGS} -fuse-ld=bfd";
export CXXFLAGS="${CXXFLAGS} -fuse-ld=bfd";
export LDFLAGS="${LDFLAGS} -fuse-ld=bfd";
fi
}
tc-ld-is-bfd ()
{
local out;
local -x LC_ALL=C;
out=$($(tc-getLD "$@") --version 2>&1);
if [[ ${out} != "GNU ld"* ]]; then
return 1;
fi;
local base="${T}/test-tc-linker";
cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
rm -f "${base}"*;
if [[ ! ${out} =~ .*^"GNU ld".* ]]; then
return 1;
fi;
return 0
}
tc-ld-is-gold ()
{
local out;
local -x LC_ALL=C;
out=$($(tc-getLD "$@") --version 2>&1);
if [[ ${out} == *"GNU gold"* ]]; then
return 0;
fi;
local base="${T}/test-tc-linker";
cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
rm -f "${base}"*;
if [[ ${out} == *"GNU gold"* ]]; then
return 0;
fi;
return 1
}
tc-ld-is-lld ()
{
local out;
local -x LC_ALL=C;
out=$($(tc-getLD "$@") --version 2>&1);
if [[ ${out} == *"LLD"* ]]; then
return 0;
fi;
local base="${T}/test-tc-linker";
cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
rm -f "${base}"*;
if [[ ${out} == *"LLD"* ]]; then
return 0;
fi;
return 1
}
tc-ld-is-mold ()
{
local out;
local -x LC_ALL=C;
out=$($(tc-getLD "$@") --version 2>&1);
if [[ ${out} == *"mold"* ]]; then
return 0;
fi;
local base="${T}/test-tc-linker";
cat <<-EOF > "${base}.c"
int main(void) { return 0; }
EOF

out=$($(tc-getCC "$@") ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} -Wl,--version "${base}.c" -o "${base}" 2>&1);
rm -f "${base}"*;
if [[ ${out} == *"mold"* ]]; then
return 0;
fi;
return 1
}
tc-ninja_magic_to_arch ()
{
function _tc_echo_kernel_alias ()
{
[[ ${type} == "kern" ]] && echo $1 || echo $2
};
local type=$1;
local host=$2;
[[ -z ${host} ]] && host=${CTARGET:-${CHOST}};
case ${host} in
arm64*)
echo arm64
;;
aarch64*)
echo arm64
;;
alpha*)
echo alpha
;;
arc*)
echo arc
;;
arm*)
echo arm
;;
avr*)
_tc_echo_kernel_alias avr32 avr
;;
bfin*)
_tc_echo_kernel_alias blackfin bfin
;;
c6x*)
echo c6x
;;
cris*)
echo cris
;;
frv*)
echo frv
;;
hexagon*)
echo hexagon
;;
hppa*)
_tc_echo_kernel_alias parisc hppa
;;
i?86*)
echo x86
;;
ia64*)
echo ia64
;;
loongarch*)
_tc_echo_kernel_alias loongarch loong
;;
m68*)
echo m68k
;;
metag*)
echo metag
;;
microblaze*)
echo microblaze
;;
mips*)
echo mips
;;
nios2*)
echo nios2
;;
nios*)
echo nios
;;
or1k* | or32*)
echo openrisc
;;
powerpc*)
if [[ ${type} == "kern" ]]; then
echo powerpc;
else
if [[ ${host} == powerpc64* ]]; then
echo ppc64;
else
echo ppc;
fi;
fi
;;
riscv*)
echo riscv
;;
s390*)
echo s390
;;
score*)
echo score
;;
sh64*)
_tc_echo_kernel_alias sh64 sh
;;
sh*)
echo sh
;;
sparc64*)
_tc_echo_kernel_alias sparc64 sparc
;;
sparc*)
[[ ${PROFILE_ARCH} == "sparc64" ]] && _tc_echo_kernel_alias sparc64 sparc || echo sparc
;;
tile*)
echo tile
;;
vax*)
echo vax
;;
x86_64*)
if [[ ${type} == "kern" ]]; then
echo x86;
else
echo amd64;
fi
;;
xtensa*)
echo xtensa
;;
*)
echo unknown
;;
esac
}
tc-stack-grows-down ()
{
case ${ARCH} in
hppa | metag)
return 1
;;
esac;
return 0
}
tc-tuple-is-softfloat ()
{
local CTARGET=${CTARGET:-${CHOST}};
case ${CTARGET//_/-} in
bfin* | h8300*)
echo "only"
;;
*-softfloat-*)
echo "yes"
;;
*-softfp-*)
echo "softfp"
;;
arm*-hardfloat-* | arm*eabihf)
echo "no"
;;
*-newlib | *-elf | *-eabi)
echo "no"
;;
arm64-apple-darwin*)
echo "no"
;;
arm*)
echo "yes"
;;
*)
echo "no"
;;
esac
}
test-compile ()
{
local lang=$1;
local code=$2;
shift 2;
[[ -z "${lang}" ]] && return 1;
[[ -z "${code}" ]] && return 1;
local compiler filename_in filename_out args=() libs=();
case "${lang}" in
c)
compiler="$(tc-getCC)";
filename_in="${T}/test.c";
filename_out="${T}/test.o";
args+=(${CFLAGS[@]} -xc -c)
;;
c++)
compiler="$(tc-getCXX)";
filename_in="${T}/test.cc";
filename_out="${T}/test.o";
args+=(${CXXFLAGS[@]} -xc++ -c)
;;
f77)
compiler="$(tc-getF77)";
filename_in="${T}/test.f";
filename_out="${T}/test.o";
args+=(${FFFLAGS[@]} -xf77 -c)
;;
f95)
compiler="$(tc-getFC)";
filename_in="${T}/test.f90";
filename_out="${T}/test.o";
args+=(${FCFLAGS[@]} -xf95 -c)
;;
c+ld)
compiler="$(tc-getCC)";
filename_in="${T}/test.c";
filename_out="${T}/test.exe";
args+=(${CFLAGS[@]} ${LDFLAGS[@]} -xc);
libs+=(${LIBS[@]})
;;
c+++ld)
compiler="$(tc-getCXX)";
filename_in="${T}/test.cc";
filename_out="${T}/test.exe";
args+=(${CXXFLAGS[@]} ${LDFLAGS[@]} -xc++);
libs+=(${LIBS[@]})
;;
f77+ld)
compiler="$(tc-getF77)";
filename_in="${T}/test.f";
filename_out="${T}/test.exe";
args+=(${FFLAGS[@]} ${LDFLAGS[@]} -xf77);
libs+=(${LIBS[@]})
;;
f95+ld)
compiler="$(tc-getFC)";
filename_in="${T}/test.f90";
filename_out="${T}/test.exe";
args+=(${FCFLAGS[@]} ${LDFLAGS[@]} -xf95);
libs+=(${LIBS[@]})
;;
*)
die "Unknown compiled language ${lang}"
;;
esac;
printf "%s\n" "${code}" > "${filename_in}" || die "Failed to create '${test_in}'";
"${compiler}" ${args[@]} "${filename_in}" -o "${filename_out}" ${libs[@]} &> /dev/null
}
test-flag-CC ()
{
_test-flag-PROG CC c "$@"
}
test-flag-CCLD ()
{
_test-flag-PROG CC c+ld "$@"
}
test-flag-CXX ()
{
_test-flag-PROG CXX c++ "$@"
}
test-flag-F77 ()
{
_test-flag-PROG F77 f77 "$@"
}
test-flag-FC ()
{
_test-flag-PROG FC f95 "$@"
}
test-flag-PROG ()
{
[[ ${EAPI} == 7 ]] || die "Internal function ${FUNCNAME} is not available in EAPI ${EAPI}.";
_test-flag-PROG "$@"
}
test-flags ()
{
test-flags-CC "$@"
}
test-flags-CC ()
{
_test-flags-PROG CC "$@"
}
test-flags-CCLD ()
{
_test-flags-PROG CCLD "$@"
}
test-flags-CXX ()
{
_test-flags-PROG CXX "$@"
}
test-flags-F77 ()
{
_test-flags-PROG F77 "$@"
}
test-flags-FC ()
{
_test-flags-PROG FC "$@"
}
test-flags-PROG ()
{
[[ ${EAPI} == 7 ]] || die "Internal function ${FUNCNAME} is not available in EAPI ${EAPI}.";
_test-flags-PROG "$@"
}
test_version_info ()
{
if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
return 0;
else
return 1;
fi
}
ver_cut ()
{
local range=${1};
local v=${2:-${PV}};
local start end;
local -a comp;
__eapi7_ver_split "${v}";
local max=$((${#comp[@]}/2));
__eapi7_ver_parse_range "${range}" "${max}";
local IFS=;
if [[ ${start} -gt 0 ]]; then
start=$(( start*2 - 1 ));
fi;
echo "${comp[*]:start:end*2-start}"
}
ver_rs ()
{
local v;
(( ${#} & 1 )) && v=${@: -1} || v=${PV};
local start end i;
local -a comp;
__eapi7_ver_split "${v}";
local max=$((${#comp[@]}/2 - 1));
while [[ ${#} -ge 2 ]]; do
__eapi7_ver_parse_range "${1}" "${max}";
for ((i = start*2; i <= end*2; i+=2 ))
do
[[ ${i} -eq 0 && -z ${comp[i]} ]] && continue;
comp[i]=${2};
done;
shift 2;
done;
local IFS=;
echo "${comp[*]}"
}
ver_test ()
{
local va op vb;
if [[ $# -eq 3 ]]; then
va=${1};
shift;
else
va=${PVR};
fi;
[[ $# -eq 2 ]] || die "${FUNCNAME}: bad number of arguments";
op=${1};
vb=${2};
case ${op} in
-eq | -ne | -lt | -le | -gt | -ge)

;;
*)
die "${FUNCNAME}: invalid operator: ${op}"
;;
esac;
__eapi7_ver_compare "${va}" "${vb}";
test $? "${op}" 2
}

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)