Created
February 5, 2024 08:16
-
-
Save Sober7135/a44adea339a9e391d73729a108543aec to your computer and use it in GitHub Desktop.
/var/tmp/portage/dev-perl/XS-Parse-Keyword-0.380.0/temp/environment
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| declare -x ABI="amd64" | |
| declare -x ABI_MIPS="" | |
| declare -x ABI_S390="" | |
| declare -x ABI_X86="64" | |
| declare -x ADA_TARGET="" | |
| declare -x ALSA_CARDS="" | |
| declare -x AMDGPU_TARGETS="" | |
| declare -x APACHE2_MODULES="" | |
| declare -x APACHE2_MPMS="" | |
| declare -x ARCH="amd64" | |
| declare BDEPEND=$'\n\t>=dev-perl/ExtUtils-CChecker-0.110.0\n\t>=dev-perl/Module-Build-0.400.400\n\tvirtual/perl-ExtUtils-CBuilder\n\tvirtual/perl-ExtUtils-ParseXS\n\ttest? ( dev-perl/Test2-Suite )\n dev-lang/perl\n\t\t\t\t\t test? ( >=virtual/perl-Test-Simple-1 )' | |
| declare -x BINPKG_FORMAT="gpkg" | |
| declare -x BINPKG_GPG_SIGNING_BASE_COMMAND="/usr/bin/flock /run/lock/portage-binpkg-gpg.lock /usr/bin/gpg --sign --armor [PORTAGE_CONFIG]" | |
| declare -x BINPKG_GPG_SIGNING_DIGEST="SHA512" | |
| declare -x BINPKG_GPG_VERIFY_BASE_COMMAND="/usr/bin/gpg --verify --batch --no-tty --no-auto-check-trustdb --status-fd 2 [PORTAGE_CONFIG] [SIGNATURE]" | |
| declare -x BINPKG_GPG_VERIFY_GPG_HOME="/etc/portage/gnupg" | |
| declare -x BOOTSTRAP_USE="unicode internal-glib pkg-config split-usr xml python_targets_python3_11 python_single_target_python3_11 multilib systemd sysv-utils udev" | |
| declare -x CALLIGRA_FEATURES="" | |
| declare -x CAMERAS="" | |
| declare -x CBUILD="x86_64-pc-linux-gnu" | |
| declare -x CFLAGS="-march=native -O3 -pipe -flto" | |
| declare -x CFLAGS_amd64="-m64" | |
| declare -x CFLAGS_default | |
| declare -x CFLAGS_x32="-mx32" | |
| declare -x CFLAGS_x86="-m32 -mfpmath=sse" | |
| declare -x CHOST="x86_64-pc-linux-gnu" | |
| declare -x CHOST_amd64="x86_64-pc-linux-gnu" | |
| declare -x CHOST_default="x86_64-pc-linux-gnu" | |
| declare -x CHOST_x32="x86_64-pc-linux-gnux32" | |
| declare -x CHOST_x86="i686-pc-linux-gnu" | |
| declare -x COLLECTD_PLUGINS="" | |
| declare -x COMMON_FLAGS="-march=native -O3 -pipe -flto" | |
| declare -x CPU_FLAGS_ARM="" | |
| declare -x CPU_FLAGS_PPC="" | |
| declare -x CPU_FLAGS_X86="" | |
| declare -x CTARGET_default="x86_64-pc-linux-gnu" | |
| declare -x CURL_SSL="" | |
| declare -x CXXFLAGS="-march=native -O3 -pipe -flto" | |
| declare -x DEFAULT_ABI="amd64" | |
| declare -x DEFINED_PHASES=" compile configure install prepare test" | |
| declare DEPEND="dev-lang/perl" | |
| declare DESCRIPTION="XS functions to assist in parsing keyword syntax" | |
| declare -x DIROPTIONS="-m0755" | |
| declare -- DIST_A="XS-Parse-Keyword-0.38.tar.gz" | |
| declare -- DIST_AUTHOR="PEVANS" | |
| declare -a DIST_MAKE=([0]="OPTIMIZE=-march=native -O3 -pipe -flto") | |
| declare -- DIST_NAME="XS-Parse-Keyword" | |
| declare -- DIST_P="XS-Parse-Keyword-0.38" | |
| declare -- DIST_VERSION="0.38" | |
| declare -x EAPI="8" | |
| declare -x ELIBC="glibc" | |
| declare -x ENV_UNSET="CARGO_HOME DBUS_SESSION_BUS_ADDRESS DISPLAY GDK_PIXBUF_MODULE_FILE GOBIN GOPATH PERL5LIB PERL5OPT PERLPREFIX PERL_CORE PERL_MB_OPT PERL_MM_OPT XAUTHORITY XDG_CACHE_HOME XDG_CONFIG_HOME XDG_DATA_HOME XDG_RUNTIME_DIR XDG_STATE_HOME" | |
| declare -- EPOCHREALTIME="1707120006.736768" | |
| declare -- EPOCHSECONDS="1707120006" | |
| declare -x EXEOPTIONS="-m0755" | |
| declare -x FCFLAGS="-march=native -O3 -pipe -flto" | |
| declare -x FETCHCOMMAND_SSH="bash -c \"x=\\\${2#ssh://} ; host=\\\${x%%/*} ; port=\\\${host##*:} ; host=\\\${host%:*} ; [[ \\\${host} = \\\${port} ]] && port= ; exec rsync --rsh=\\\"ssh \\\${port:+-p\\\${port}} \\\${3}\\\" -avP \\\"\\\${host}:/\\\${x#*/}\\\" \\\"\\\$1\\\"\" rsync \"\${DISTDIR}/\${FILE}\" \"\${URI}\" \"\${PORTAGE_SSH_OPTS}\"" | |
| declare -x FFLAGS="-march=native -O3 -pipe -flto" | |
| declare -x FFTOOLS="" | |
| declare -x GCC_SPECS="" | |
| declare -x GPG_VERIFY_GROUP_DROP="nogroup" | |
| declare -x GPG_VERIFY_USER_DROP="nobody" | |
| declare -x GPSD_PROTOCOLS="" | |
| declare -x GRUB_PLATFORMS="" | |
| declare HOMEPAGE="https://metacpan.org/release/XS-Parse-Keyword" | |
| declare IDEPEND="" | |
| declare -x INHERITED=" multiprocessing perl-functions readme.gentoo-r1 toolchain-funcs multilib perl-module" | |
| declare -x INPUT_DEVICES="" | |
| declare -x INSOPTIONS="-m0644" | |
| declare IUSE="test" | |
| declare -x IUSE_EFFECTIVE="abi_x86_64 alpha amd64 amd64-linux arm arm64 arm64-macos elibc_Darwin elibc_SunOS elibc_bionic elibc_glibc elibc_mingw elibc_musl hppa ia64 kernel_Darwin kernel_SunOS kernel_linux loong m68k mips ppc ppc-macos ppc64 ppc64-linux prefix prefix-guest prefix-stack riscv s390 sparc test x64-macos x64-solaris x86 x86-linux" | |
| declare -x IUSE_IMPLICIT="abi_x86_64 prefix prefix-guest prefix-stack" | |
| declare -x KERNEL="linux" | |
| declare -x KERNEL_ABI="amd64" | |
| declare -x KEYWORDS="~alpha amd64 ~arm ~arm64 ~hppa ~ia64 ~loong ~m68k ~mips ~ppc ~ppc64 ~riscv ~s390 ~sparc x86 ~amd64-linux ~x86-linux ~arm64-macos ~ppc-macos ~x64-macos ~x64-solaris" | |
| declare -x L10N="" | |
| declare -x LANG="en_US.utf8" | |
| declare -x LCD_DEVICES="" | |
| declare -x LC_COLLATE="C" | |
| declare -x LC_MESSAGES="C.utf8" | |
| declare -x LDFLAGS="-Wl,-O1 -Wl,--as-needed" | |
| declare -x LDFLAGS_amd64="-m elf_x86_64" | |
| declare -x LDFLAGS_default | |
| declare -x LDFLAGS_x32="-m elf32_x86_64" | |
| declare -x LDFLAGS_x86="-m elf_i386" | |
| declare -x LEX="flex" | |
| declare -x LIBDIR_amd64="lib64" | |
| declare -x LIBDIR_default="lib" | |
| declare -x LIBDIR_x32="libx32" | |
| declare -x LIBDIR_x86="lib" | |
| declare -x LIBOPTIONS="-m0644" | |
| declare -x LIBREOFFICE_EXTENSIONS="" | |
| declare -x LICENSE="|| ( Artistic GPL-1+ )" | |
| declare -x LLVM_TARGETS="" | |
| declare -x LUA_SINGLE_TARGET="" | |
| declare -x LUA_TARGETS="" | |
| declare -x MAIL="/var/mail/root" | |
| declare -x MAKEOPTS="-j32 -l32" | |
| declare -x MANPAGER="manpager" | |
| declare -x MONKEYD_PLUGINS="" | |
| declare -x MULTILIB_ABIS="amd64 x86" | |
| declare -x MULTILIB_STRICT_DENY="64-bit.*shared object" | |
| declare -x MULTILIB_STRICT_DIRS="/lib32 /lib /usr/lib32 /usr/lib /usr/kde/*/lib32 /usr/kde/*/lib /usr/qt/*/lib32 /usr/qt/*/lib /usr/X11R6/lib32 /usr/X11R6/lib" | |
| declare -x MULTILIB_STRICT_EXEMPT="(perl5|gcc|binutils|eclipse-3|debug|portage|udev|systemd|clang|python-exec|llvm)" | |
| declare -x NGINX_MODULES_HTTP="" | |
| declare -x NGINX_MODULES_MAIL="" | |
| declare -x NGINX_MODULES_STREAM="" | |
| declare -x OFFICE_IMPLEMENTATION="" | |
| declare -x OPENMPI_FABRICS="" | |
| declare -x OPENMPI_OFED_FEATURES="" | |
| declare -x OPENMPI_RM="" | |
| declare -x PATH="/usr/lib/portage/python3.11/ebuild-helpers/xattr:/usr/lib/portage/python3.11/ebuild-helpers:/usr/local/sbin:/usr/local/bin:/usr/bin:/opt/bin:/usr/lib/llvm/17/bin:/opt/cuda/bin" | |
| declare PDEPEND="" | |
| declare -- PERL_EXPF="src_prepare src_configure src_compile src_test src_install" | |
| declare -x PHP_TARGETS="" | |
| declare -x PORTAGE_COMPRESSION_COMMAND="zstd -T32" | |
| declare -a PORTAGE_DOCOMPRESS=([0]="/usr/share/doc" [1]="/usr/share/info" [2]="/usr/share/man") | |
| declare -x PORTAGE_DOCOMPRESS_SIZE_LIMIT="128" | |
| declare -a PORTAGE_DOCOMPRESS_SKIP=([0]="/usr/share/doc/XS-Parse-Keyword-0.380.0/html") | |
| declare -a PORTAGE_DOSTRIP=([0]="/") | |
| declare -a PORTAGE_DOSTRIP_SKIP=() | |
| declare -x POSTGRES_TARGETS="" | |
| declare -- PREFER_BUILDPL="yes" | |
| declare -x PROFILE_ONLY_VARIABLES="ARCH ELIBC IUSE_IMPLICIT KERNEL USE_EXPAND_IMPLICIT USE_EXPAND_UNPREFIXED USE_EXPAND_VALUES_ARCH USE_EXPAND_VALUES_ELIBC USE_EXPAND_VALUES_KERNEL" | |
| declare -- PROPERTIES="" | |
| declare -x PYTHONDONTWRITEBYTECODE="1" | |
| declare -x PYTHON_SINGLE_TARGET="" | |
| declare -x PYTHON_TARGETS="" | |
| declare -x QEMU_SOFTMMU_TARGETS="" | |
| declare -x QEMU_USER_TARGETS="" | |
| declare RDEPEND="dev-lang/perl:=" | |
| declare -- README_GENTOO_SUFFIX="" | |
| declare REPOSITORY | |
| declare REQUIRED_USE="" | |
| declare RESTRICT="test" | |
| declare -x RESUMECOMMAND_SSH="bash -c \"x=\\\${2#ssh://} ; host=\\\${x%%/*} ; port=\\\${host##*:} ; host=\\\${host%:*} ; [[ \\\${host} = \\\${port} ]] && port= ; exec rsync --rsh=\\\"ssh \\\${port:+-p\\\${port}} \\\${3}\\\" -avP \\\"\\\${host}:/\\\${x#*/}\\\" \\\"\\\$1\\\"\" rsync \"\${DISTDIR}/\${FILE}\" \"\${URI}\" \"\${PORTAGE_SSH_OPTS}\"" | |
| declare -x RUBY_TARGETS="" | |
| declare -x S="/var/tmp/portage/dev-perl/XS-Parse-Keyword-0.380.0/work/XS-Parse-Keyword-0.38" | |
| declare -x SANDBOX_DEBUG="0" | |
| declare -x SANDBOX_DENY="" | |
| declare -x SANDBOX_METHOD="any" | |
| declare -x SANDBOX_PREDICT="/var/tmp/portage/dev-perl/XS-Parse-Keyword-0.380.0/homedir:/dev/crypto:/var/cache/man:/dev/nvidiactl:/dev/nvidia-caps:/dev/char:/var/cache/fontconfig" | |
| declare -x SANDBOX_READ="/:/var/tmp/portage" | |
| declare -x SANDBOX_VERBOSE="1" | |
| declare -x SANDBOX_WRITE=":/dev/console:/dev/fd:/dev/full:/dev/null:/dev/ptmx:/dev/pts/:/dev/pty:/dev/shm:/dev/tts:/dev/tty:/dev/vc/:/dev/zero:/proc/self/fd:/tmp/:/usr/lib/cf:/usr/lib/conftest:/usr/lib32/cf:/usr/lib32/conftest:/usr/lib64/cf:/usr/lib64/conftest:/usr/tmp/:/usr/tmp/cf:/usr/tmp/conftest:/var/tmp/:/var/tmp/portage:/var/tmp/portage/dev-perl/XS-Parse-Keyword-0.380.0/homedir/.bash_history" | |
| declare -x SANE_BACKENDS="" | |
| declare -x SHELL="/bin/fish" | |
| declare -x SLOT="0" | |
| declare -i SRANDOM="2799339418" | |
| declare SRC_URI="mirror://cpan/authors/id/P/PE/PEVANS/XS-Parse-Keyword-0.38.tar.gz" | |
| declare -x SUDO_COMMAND="/usr/sbin/emerge -a1tv dev-perl/XS-Parse-Keyword" | |
| declare -x SUDO_GID="1000" | |
| declare -x SUDO_UID="1000" | |
| declare -x SUDO_USER="w" | |
| declare -x SYMLINK_LIB="no" | |
| declare -x TWISTED_DISABLE_WRITING_OF_PLUGIN_CACHE="1" | |
| declare -x USE="abi_x86_64 amd64 elibc_glibc kernel_linux" | |
| declare -x USERLAND="GNU" | |
| declare -x USE_EXPAND_IMPLICIT="ARCH ELIBC KERNEL" | |
| declare -x USE_EXPAND_UNPREFIXED="ARCH" | |
| declare -x USE_EXPAND_VALUES_ARCH="alpha amd64 amd64-linux arm arm64 arm64-macos hppa ia64 loong m68k mips ppc ppc64 ppc64-linux ppc-macos riscv s390 sparc x64-macos x64-solaris x86 x86-linux" | |
| declare -x USE_EXPAND_VALUES_ELIBC="bionic Darwin glibc mingw musl SunOS" | |
| declare -x USE_EXPAND_VALUES_KERNEL="Darwin linux SunOS" | |
| declare -x UWSGI_PLUGINS="" | |
| declare -x VIDEO_CARDS="" | |
| declare -x VOICEMAIL_STORAGE="" | |
| declare -x XTABLES_ADDONS="" | |
| declare -- _MULTILIB_ECLASS="1" | |
| declare -- _MULTIPROCESSING_ECLASS="1" | |
| declare -- _README_GENTOO_ECLASS="1" | |
| declare -- _TOOLCHAIN_FUNCS_ECLASS="1" | |
| declare -x __E_DESTTREE="/usr" | |
| declare -x __E_DOCDESTTREE="" | |
| declare -x __E_EXEDESTTREE="" | |
| declare -x __E_INSDESTTREE="" | |
| declare -x ac_cv_c_undeclared_builtin_options="none needed" | |
| declare -x enable_year2038="no" | |
| declare -x gl_cv_compiler_check_decl_option="-Werror=implicit-function-declaration" | |
| declare -x gl_cv_func_getcwd_path_max="yes" | |
| declare -- perlinfo_done="false" | |
| declare -- pm_echovar="" | |
| __eapi6_src_install () | |
| { | |
| if [[ -f Makefile || -f GNUmakefile || -f makefile ]]; then | |
| emake DESTDIR="${D}" install; | |
| fi; | |
| einstalldocs | |
| } | |
| __eapi6_src_prepare () | |
| { | |
| if ___is_indexed_array_var PATCHES; then | |
| [[ ${#PATCHES[@]} -gt 0 ]] && eapply "${PATCHES[@]}"; | |
| else | |
| if [[ -n ${PATCHES} ]]; then | |
| eapply ${PATCHES}; | |
| fi; | |
| fi; | |
| eapply_user | |
| } | |
| __eapi7_ver_compare () | |
| { | |
| local va=${1} vb=${2} a an al as ar b bn bl bs br re LC_ALL=C; | |
| re="^([0-9]+(\.[0-9]+)*)([a-z]?)((_(alpha|beta|pre|rc|p)[0-9]*)*)(-r[0-9]+)?$"; | |
| [[ ${va} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${va}"; | |
| an=${BASH_REMATCH[1]}; | |
| al=${BASH_REMATCH[3]}; | |
| as=${BASH_REMATCH[4]}; | |
| ar=${BASH_REMATCH[7]}; | |
| [[ ${vb} =~ ${re} ]] || die "${FUNCNAME}: invalid version: ${vb}"; | |
| bn=${BASH_REMATCH[1]}; | |
| bl=${BASH_REMATCH[3]}; | |
| bs=${BASH_REMATCH[4]}; | |
| br=${BASH_REMATCH[7]}; | |
| __eapi7_ver_compare_int "${an%%.*}" "${bn%%.*}" || return; | |
| while [[ ${an} == *.* && ${bn} == *.* ]]; do | |
| an=${an#*.}; | |
| bn=${bn#*.}; | |
| a=${an%%.*}; | |
| b=${bn%%.*}; | |
| if [[ ${a} == 0* || ${b} == 0* ]]; then | |
| [[ ${a} =~ 0+$ ]] && a=${a%"${BASH_REMATCH[0]}"}; | |
| [[ ${b} =~ 0+$ ]] && b=${b%"${BASH_REMATCH[0]}"}; | |
| [[ ${a} > ${b} ]] && return 3; | |
| [[ ${a} < ${b} ]] && return 1; | |
| else | |
| __eapi7_ver_compare_int "${a}" "${b}" || return; | |
| fi; | |
| done; | |
| [[ ${an} == *.* ]] && return 3; | |
| [[ ${bn} == *.* ]] && return 1; | |
| [[ ${al} > ${bl} ]] && return 3; | |
| [[ ${al} < ${bl} ]] && return 1; | |
| as=${as#_}${as:+_}; | |
| bs=${bs#_}${bs:+_}; | |
| while [[ -n ${as} && -n ${bs} ]]; do | |
| a=${as%%_*}; | |
| b=${bs%%_*}; | |
| if [[ ${a%%[0-9]*} == "${b%%[0-9]*}" ]]; then | |
| __eapi7_ver_compare_int "${a##*[a-z]}" "${b##*[a-z]}" || return; | |
| else | |
| [[ ${a%%[0-9]*} == p ]] && return 3; | |
| [[ ${b%%[0-9]*} == p ]] && return 1; | |
| [[ ${a} > ${b} ]] && return 3 || return 1; | |
| fi; | |
| as=${as#*_}; | |
| bs=${bs#*_}; | |
| done; | |
| if [[ -n ${as} ]]; then | |
| [[ ${as} == p[_0-9]* ]] && return 3 || return 1; | |
| else | |
| if [[ -n ${bs} ]]; then | |
| [[ ${bs} == p[_0-9]* ]] && return 1 || return 3; | |
| fi; | |
| fi; | |
| __eapi7_ver_compare_int "${ar#-r}" "${br#-r}" || return; | |
| return 2 | |
| } | |
| __eapi7_ver_compare_int () | |
| { | |
| local a=$1 b=$2 d=$(( ${#1}-${#2} )); | |
| if [[ ${d} -gt 0 ]]; then | |
| printf -v b "%0${d}d%s" 0 "${b}"; | |
| else | |
| if [[ ${d} -lt 0 ]]; then | |
| printf -v a "%0$(( -d ))d%s" 0 "${a}"; | |
| fi; | |
| fi; | |
| [[ ${a} > ${b} ]] && return 3; | |
| [[ ${a} == "${b}" ]] | |
| } | |
| __eapi7_ver_parse_range () | |
| { | |
| local range=${1}; | |
| local max=${2}; | |
| [[ ${range} == [0-9]* ]] || die "${FUNCNAME}: range must start with a number"; | |
| start=${range%-*}; | |
| [[ ${range} == *-* ]] && end=${range#*-} || end=${start}; | |
| if [[ -n ${end} ]]; then | |
| [[ ${start} -le ${end} ]] || die "${FUNCNAME}: end of range must be >= start"; | |
| [[ ${end} -le ${max} ]] || end=${max}; | |
| else | |
| end=${max}; | |
| fi | |
| } | |
| __eapi7_ver_split () | |
| { | |
| local v=${1} LC_ALL=C; | |
| comp=(); | |
| local s c; | |
| while [[ -n ${v} ]]; do | |
| s=${v%%[a-zA-Z0-9]*}; | |
| v=${v:${#s}}; | |
| [[ ${v} == [0-9]* ]] && c=${v%%[^0-9]*} || c=${v%%[^a-zA-Z]*}; | |
| v=${v:${#c}}; | |
| comp+=("${s}" "${c}"); | |
| done | |
| } | |
| __eapi8_src_prepare () | |
| { | |
| local f; | |
| if ___is_indexed_array_var PATCHES; then | |
| [[ ${#PATCHES[@]} -gt 0 ]] && eapply -- "${PATCHES[@]}"; | |
| else | |
| if [[ -n ${PATCHES} ]]; then | |
| eapply -- ${PATCHES}; | |
| fi; | |
| fi; | |
| eapply_user | |
| } | |
| _clang_fullversion () | |
| { | |
| local ver="$1"; | |
| shift; | |
| set -- $($(tc-getCPP "$@") -E -P - <<< "__clang_major__ __clang_minor__ __clang_patchlevel__"); | |
| eval echo "${ver}" | |
| } | |
| _gcc-install-dir () | |
| { | |
| echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null | awk '$1=="install:" {print $2}')" | |
| } | |
| _gcc-specs-directive_raw () | |
| { | |
| local cc=$(tc-getCC); | |
| local specfiles=$(LC_ALL=C ${cc} -v 2>&1 | awk '$1=="Reading" {print $NF}'); | |
| ${cc} -dumpspecs 2> /dev/null | cat - ${specfiles} | awk -v directive=$1 'BEGIN { pspec=""; spec=""; outside=1 } | |
| $1=="*"directive":" { pspec=spec; spec=""; outside=0; next } | |
| outside || NF==0 || ( substr($1,1,1)=="*" && substr($1,length($1),1)==":" ) { outside=1; next } | |
| spec=="" && substr($0,1,1)=="+" { spec=pspec " " substr($0,2); next } | |
| { spec=spec $0 } | |
| END { print spec }'; | |
| return 0 | |
| } | |
| _gcc-specs-exists () | |
| { | |
| [[ -f $(_gcc-install-dir)/$1 ]] | |
| } | |
| _gcc_fullversion () | |
| { | |
| local ver="$1"; | |
| shift; | |
| set -- $($(tc-getCPP "$@") -E -P - <<< "__GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__"); | |
| eval echo "${ver}" | |
| } | |
| _get_all_makeopts () | |
| { | |
| echo "${MAKEOPTS} ${GNUMAKEFLAGS} ${MAKEFLAGS}" | |
| } | |
| _tc-getPROG () | |
| { | |
| local tuple=$1; | |
| local v var vars=$2; | |
| local prog=($3); | |
| var=${vars%% *}; | |
| for v in ${vars}; | |
| do | |
| if [[ -n ${!v} ]]; then | |
| export ${var}="${!v}"; | |
| echo "${!v}"; | |
| return 0; | |
| fi; | |
| done; | |
| local search=; | |
| [[ -n $4 ]] && search=$(type -p $4-${prog[0]}); | |
| [[ -z ${search} && -n ${!tuple} ]] && search=$(type -p ${!tuple}-${prog[0]}); | |
| [[ -n ${search} ]] && prog[0]=${search##*/}; | |
| export ${var}="${prog[*]}"; | |
| echo "${!var}" | |
| } | |
| _tc-has-openmp () | |
| { | |
| local base="${T}/test-tc-openmp"; | |
| cat <<-EOF > "${base}.c" | |
| #include <omp.h> | |
| int main(void) { | |
| int nthreads, tid, ret = 0; | |
| #pragma omp parallel private(nthreads, tid) | |
| { | |
| tid = omp_get_thread_num(); | |
| nthreads = omp_get_num_threads(); ret += tid + nthreads; | |
| } | |
| return ret; | |
| } | |
| EOF | |
| $(tc-getCC "$@") -fopenmp "${base}.c" -o "${base}" >&/dev/null; | |
| local ret=$?; | |
| rm -f "${base}"*; | |
| return ${ret} | |
| } | |
| clang-fullversion () | |
| { | |
| _clang_fullversion '$1.$2.$3' "$@" | |
| } | |
| clang-major-version () | |
| { | |
| _clang_fullversion '$1' "$@" | |
| } | |
| clang-micro-version () | |
| { | |
| _clang_fullversion '$3' "$@" | |
| } | |
| clang-minor-version () | |
| { | |
| _clang_fullversion '$2' "$@" | |
| } | |
| clang-version () | |
| { | |
| _clang_fullversion '$1.$2' "$@" | |
| } | |
| eapply () | |
| { | |
| local failed patch_cmd=patch; | |
| local -x LC_COLLATE=POSIX; | |
| type -P gpatch > /dev/null && patch_cmd=gpatch; | |
| function _eapply_patch () | |
| { | |
| local f=${1}; | |
| local prefix=${2}; | |
| ebegin "${prefix:-Applying }${f##*/}"; | |
| local all_opts=(-p1 -f -g0 --no-backup-if-mismatch "${patch_options[@]}"); | |
| if ${patch_cmd} "${all_opts[@]}" --dry-run -s -F0 < "${f}" &> /dev/null; then | |
| all_opts+=(-s -F0); | |
| fi; | |
| ${patch_cmd} "${all_opts[@]}" < "${f}"; | |
| failed=${?}; | |
| if ! eend "${failed}"; then | |
| __helpers_die "patch -p1 ${patch_options[*]} failed with ${f}"; | |
| fi | |
| }; | |
| local patch_options=() files=(); | |
| local i found_doublehyphen; | |
| for ((i = 1; i <= ${#@}; ++i )) | |
| do | |
| if [[ ${@:i:1} == -- ]]; then | |
| patch_options=("${@:1:i-1}"); | |
| files=("${@:i+1}"); | |
| found_doublehyphen=1; | |
| break; | |
| fi; | |
| done; | |
| if [[ -z ${found_doublehyphen} ]]; then | |
| for ((i = 1; i <= ${#@}; ++i )) | |
| do | |
| if [[ ${@:i:1} != -* ]]; then | |
| patch_options=("${@:1:i-1}"); | |
| files=("${@:i}"); | |
| break; | |
| fi; | |
| done; | |
| for i in "${files[@]}"; | |
| do | |
| if [[ ${i} == -* ]]; then | |
| die "eapply: all options must be passed before non-options"; | |
| fi; | |
| done; | |
| fi; | |
| if [[ ${#files[@]} -eq 0 ]]; then | |
| die "eapply: no files specified"; | |
| fi; | |
| local f; | |
| for f in "${files[@]}"; | |
| do | |
| if [[ -d ${f} ]]; then | |
| function _eapply_get_files () | |
| { | |
| local LC_ALL=POSIX; | |
| local prev_shopt=$(shopt -p nullglob); | |
| shopt -s nullglob; | |
| local f; | |
| for f in "${1}"/*; | |
| do | |
| if [[ ${f} == *.diff || ${f} == *.patch ]]; then | |
| files+=("${f}"); | |
| fi; | |
| done; | |
| ${prev_shopt} | |
| }; | |
| local files=(); | |
| _eapply_get_files "${f}"; | |
| [[ ${#files[@]} -eq 0 ]] && die "No *.{patch,diff} files in directory ${f}"; | |
| einfo "Applying patches from ${f} ..."; | |
| local f2; | |
| for f2 in "${files[@]}"; | |
| do | |
| _eapply_patch "${f2}" ' '; | |
| [[ ${failed} -ne 0 ]] && return "${failed}"; | |
| done; | |
| else | |
| _eapply_patch "${f}"; | |
| [[ ${failed} -ne 0 ]] && return "${failed}"; | |
| fi; | |
| done; | |
| return 0 | |
| } | |
| eapply_user () | |
| { | |
| [[ ${EBUILD_PHASE} == prepare ]] || die "eapply_user() called during invalid phase: ${EBUILD_PHASE}"; | |
| local tagfile=${T}/.portage_user_patches_applied; | |
| [[ -f ${tagfile} ]] && return; | |
| >> "${tagfile}"; | |
| local basedir=${PORTAGE_CONFIGROOT%/}/etc/portage/patches; | |
| local columns=${COLUMNS:-0}; | |
| [[ ${columns} == 0 ]] && columns=$(set -- $( ( stty size < /dev/tty ) 2> /dev/null || echo 24 80); echo $2); | |
| (( columns > 0 )) || (( columns = 80 )); | |
| local applied d f; | |
| local -A _eapply_user_patches; | |
| local prev_shopt=$(shopt -p nullglob); | |
| shopt -s nullglob; | |
| for d in "${basedir}"/${CATEGORY}/{${P}-${PR},${P},${PN}}{:${SLOT%/*},}; | |
| do | |
| for f in "${d}"/*; | |
| do | |
| if [[ ( ${f} == *.diff || ${f} == *.patch ) && -z ${_eapply_user_patches[${f##*/}]} ]]; then | |
| _eapply_user_patches[${f##*/}]=${f}; | |
| fi; | |
| done; | |
| done; | |
| if [[ ${#_eapply_user_patches[@]} -gt 0 ]]; then | |
| while read -r -d '' f; do | |
| f=${_eapply_user_patches[${f}]}; | |
| if [[ -s ${f} ]]; then | |
| if [[ -z ${applied} ]]; then | |
| einfo "${PORTAGE_COLOR_INFO}$(for ((column = 0; column < ${columns} - 3; column++)) | |
| do | |
| echo -n =; | |
| done)${PORTAGE_COLOR_NORMAL}"; | |
| einfo "Applying user patches from ${basedir} ..."; | |
| fi; | |
| eapply "${f}"; | |
| applied=1; | |
| fi; | |
| done < <(printf -- '%s\0' "${!_eapply_user_patches[@]}" | LC_ALL=C sort -z); | |
| fi; | |
| ${prev_shopt}; | |
| if [[ -n ${applied} ]]; then | |
| einfo "User patches applied."; | |
| einfo "${PORTAGE_COLOR_INFO}$(for ((column = 0; column < ${columns} - 3; column++)) | |
| do | |
| echo -n =; | |
| done)${PORTAGE_COLOR_NORMAL}"; | |
| fi | |
| } | |
| econf_build () | |
| { | |
| local CBUILD=${CBUILD:-${CHOST}}; | |
| function econf_env () | |
| { | |
| CHOST=${CBUILD} econf "$@" | |
| }; | |
| tc-env_build econf_env "$@" | |
| } | |
| einstalldocs () | |
| { | |
| ( if [[ $(declare -p DOCS 2> /dev/null) != *=* ]]; then | |
| local d; | |
| for d in README* ChangeLog AUTHORS NEWS TODO CHANGES THANKS BUGS FAQ CREDITS CHANGELOG; | |
| do | |
| [[ -f ${d} && -s ${d} ]] && docinto / && dodoc "${d}"; | |
| done; | |
| else | |
| if ___is_indexed_array_var DOCS; then | |
| [[ ${#DOCS[@]} -gt 0 ]] && docinto / && dodoc -r "${DOCS[@]}"; | |
| else | |
| [[ -n ${DOCS} ]] && docinto / && dodoc -r ${DOCS}; | |
| fi; | |
| fi ); | |
| ( if ___is_indexed_array_var HTML_DOCS; then | |
| [[ ${#HTML_DOCS[@]} -gt 0 ]] && docinto html && dodoc -r "${HTML_DOCS[@]}"; | |
| else | |
| [[ -n ${HTML_DOCS} ]] && docinto html && dodoc -r ${HTML_DOCS}; | |
| fi ) | |
| } | |
| gcc-fullversion () | |
| { | |
| _gcc_fullversion '$1.$2.$3' "$@" | |
| } | |
| gcc-major-version () | |
| { | |
| _gcc_fullversion '$1' "$@" | |
| } | |
| gcc-micro-version () | |
| { | |
| _gcc_fullversion '$3' "$@" | |
| } | |
| gcc-minor-version () | |
| { | |
| _gcc_fullversion '$2' "$@" | |
| } | |
| gcc-specs-directive () | |
| { | |
| local directive subdname subdirective; | |
| directive="$(_gcc-specs-directive_raw $1)"; | |
| while [[ ${directive} == *%\(*\)* ]]; do | |
| subdname=${directive/*%\(}; | |
| subdname=${subdname/\)*}; | |
| subdirective="$(_gcc-specs-directive_raw ${subdname})"; | |
| directive="${directive//\%(${subdname})/${subdirective}}"; | |
| done; | |
| echo "${directive}"; | |
| return 0 | |
| } | |
| gcc-specs-nostrict () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive cc1); | |
| [[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]] | |
| } | |
| gcc-specs-now () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive link_command); | |
| [[ "${directive/\{!nonow:}" != "${directive}" ]] | |
| } | |
| gcc-specs-pie () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive cc1); | |
| [[ "${directive/\{!nopie:}" != "${directive}" ]] | |
| } | |
| gcc-specs-relro () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive link_command); | |
| [[ "${directive/\{!norelro:}" != "${directive}" ]] | |
| } | |
| gcc-specs-ssp () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive cc1); | |
| [[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]] | |
| } | |
| gcc-specs-ssp-to-all () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive cc1); | |
| [[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]] | |
| } | |
| gcc-specs-stack-check () | |
| { | |
| local directive; | |
| directive=$(gcc-specs-directive cc1); | |
| [[ "${directive/\{!fno-stack-check:}" != "${directive}" ]] | |
| } | |
| gcc-version () | |
| { | |
| _gcc_fullversion '$1.$2' "$@" | |
| } | |
| gen_usr_ldscript () | |
| { | |
| ewarn "${FUNCNAME}: Please migrate to usr-ldscript.eclass"; | |
| local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname); | |
| [[ -z ${ED+set} ]] && local ED=${D%/}${EPREFIX}/; | |
| tc-is-static-only && return; | |
| if [[ $(type -t multilib_is_native_abi) == "function" ]]; then | |
| multilib_is_native_abi || return 0; | |
| fi; | |
| case ${CTARGET:-${CHOST}} in | |
| *-darwin*) | |
| ;; | |
| *-android*) | |
| return 0 | |
| ;; | |
| *linux*) | |
| use prefix && return 0 | |
| ;; | |
| *) | |
| return 0 | |
| ;; | |
| esac; | |
| dodir /usr/${libdir}; | |
| if [[ $1 == "-a" ]]; then | |
| auto=true; | |
| shift; | |
| dodir /${libdir}; | |
| fi; | |
| local flags=(${CFLAGS} ${LDFLAGS} -Wl,--verbose); | |
| if $(tc-getLD) --version | grep -q 'GNU gold'; then | |
| local d="${T}/bfd-linker"; | |
| mkdir -p "${d}"; | |
| ln -sf $(type -P ${CHOST}-ld.bfd) "${d}"/ld; | |
| flags+=(-B"${d}"); | |
| fi; | |
| output_format=$($(tc-getCC) "${flags[@]}" 2>&1 | sed -n 's/^OUTPUT_FORMAT("\([^"]*\)",.*/\1/p'); | |
| [[ -n ${output_format} ]] && output_format="OUTPUT_FORMAT ( ${output_format} )"; | |
| for lib in "$@"; | |
| do | |
| local tlib; | |
| if ${auto}; then | |
| lib="lib${lib}${suffix}"; | |
| else | |
| [[ -r ${ED}/${libdir}/${lib} ]] || continue; | |
| fi; | |
| case ${CTARGET:-${CHOST}} in | |
| *-darwin*) | |
| if ${auto}; then | |
| tlib=$(scanmacho -qF'%S#F' "${ED}"/usr/${libdir}/${lib}); | |
| else | |
| tlib=$(scanmacho -qF'%S#F' "${ED}"/${libdir}/${lib}); | |
| fi; | |
| [[ -z ${tlib} ]] && die "unable to read install_name from ${lib}"; | |
| tlib=${tlib##*/}; | |
| if ${auto}; then | |
| mv "${ED}"/usr/${libdir}/${lib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die; | |
| if [[ ${tlib} != ${lib%${suffix}}.*${suffix#.} ]]; then | |
| mv "${ED}"/usr/${libdir}/${tlib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die; | |
| fi; | |
| rm -f "${ED}"/${libdir}/${lib}; | |
| fi; | |
| if [[ ! -w "${ED}/${libdir}/${tlib}" ]]; then | |
| chmod u+w "${ED}${libdir}/${tlib}"; | |
| local nowrite=yes; | |
| fi; | |
| install_name_tool -id "${EPREFIX}"/${libdir}/${tlib} "${ED}"/${libdir}/${tlib} || die "install_name_tool failed"; | |
| [[ -n ${nowrite} ]] && chmod u-w "${ED}${libdir}/${tlib}"; | |
| pushd "${ED}/usr/${libdir}" > /dev/null; | |
| ln -snf "../../${libdir}/${tlib}" "${lib}"; | |
| popd > /dev/null | |
| ;; | |
| *) | |
| if ${auto}; then | |
| tlib=$(scanelf -qF'%S#F' "${ED}"/usr/${libdir}/${lib}); | |
| [[ -z ${tlib} ]] && die "unable to read SONAME from ${lib}"; | |
| mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die; | |
| if [[ ${tlib} != ${lib}* ]]; then | |
| mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die; | |
| fi; | |
| rm -f "${ED}"/${libdir}/${lib}; | |
| else | |
| tlib=${lib}; | |
| fi; | |
| cat > "${ED}/usr/${libdir}/${lib}" <<-END_LDSCRIPT | |
| /* GNU ld script | |
| Since Gentoo has critical dynamic libraries in /lib, and the static versions | |
| in /usr/lib, we need to have a "fake" dynamic lib in /usr/lib, otherwise we | |
| run into linking problems. This "fake" dynamic lib is a linker script that | |
| redirects the linker to the real lib. And yes, this works in the cross- | |
| compiling scenario as the sysroot-ed linker will prepend the real path. | |
| See bug https://bugs.gentoo.org/4411 for more info. | |
| */ | |
| ${output_format} | |
| GROUP ( ${EPREFIX}/${libdir}/${tlib} ) | |
| END_LDSCRIPT | |
| ;; | |
| esac | |
| fperms a+x "/usr/${libdir}/${lib}" || die "could not change perms on ${lib}"; | |
| done | |
| } | |
| get_abi_CFLAGS () | |
| { | |
| get_abi_var CFLAGS "$@" | |
| } | |
| get_abi_CHOST () | |
| { | |
| get_abi_var CHOST "$@" | |
| } | |
| get_abi_CTARGET () | |
| { | |
| get_abi_var CTARGET "$@" | |
| } | |
| get_abi_FAKE_TARGETS () | |
| { | |
| get_abi_var FAKE_TARGETS "$@" | |
| } | |
| get_abi_LDFLAGS () | |
| { | |
| get_abi_var LDFLAGS "$@" | |
| } | |
| get_abi_LIBDIR () | |
| { | |
| get_abi_var LIBDIR "$@" | |
| } | |
| get_abi_var () | |
| { | |
| local flag=$1; | |
| local abi=${2:-${ABI:-${DEFAULT_ABI:-default}}}; | |
| local var="${flag}_${abi}"; | |
| echo ${!var} | |
| } | |
| get_all_abis () | |
| { | |
| local x order="" mvar dvar; | |
| mvar="MULTILIB_ABIS"; | |
| dvar="DEFAULT_ABI"; | |
| if [[ -n $1 ]]; then | |
| mvar="$1_${mvar}"; | |
| dvar="$1_${dvar}"; | |
| fi; | |
| if [[ -z ${!mvar} ]]; then | |
| echo "default"; | |
| return 0; | |
| fi; | |
| for x in ${!mvar}; | |
| do | |
| if [[ ${x} != ${!dvar} ]]; then | |
| order="${order:+${order} }${x}"; | |
| fi; | |
| done; | |
| order="${order:+${order} }${!dvar}"; | |
| echo ${order}; | |
| return 0 | |
| } | |
| get_all_libdirs () | |
| { | |
| local libdirs abi; | |
| for abi in ${MULTILIB_ABIS}; | |
| do | |
| libdirs+=" $(get_abi_LIBDIR ${abi})"; | |
| done; | |
| [[ " ${libdirs} " != *" lib "* ]] && libdirs+=" lib"; | |
| echo "${libdirs}" | |
| } | |
| get_exeext () | |
| { | |
| case ${CHOST} in | |
| mingw* | *-mingw*) | |
| echo ".exe" | |
| ;; | |
| esac | |
| } | |
| get_install_abis () | |
| { | |
| local x order=""; | |
| if [[ -z ${MULTILIB_ABIS} ]]; then | |
| echo "default"; | |
| return 0; | |
| fi; | |
| if [[ ${EMULTILIB_PKG} == "true" ]]; then | |
| for x in ${MULTILIB_ABIS}; | |
| do | |
| if [[ ${x} != "${DEFAULT_ABI}" ]]; then | |
| has ${x} ${ABI_DENY} || order="${order} ${x}"; | |
| fi; | |
| done; | |
| has ${DEFAULT_ABI} ${ABI_DENY} || order="${order} ${DEFAULT_ABI}"; | |
| if [[ -n ${ABI_ALLOW} ]]; then | |
| local ordera=""; | |
| for x in ${order}; | |
| do | |
| if has ${x} ${ABI_ALLOW}; then | |
| ordera="${ordera} ${x}"; | |
| fi; | |
| done; | |
| order=${ordera}; | |
| fi; | |
| else | |
| order=${DEFAULT_ABI}; | |
| fi; | |
| if [[ -z ${order} ]]; then | |
| die "The ABI list is empty. Are you using a proper multilib profile? Perhaps your USE flags or MULTILIB_ABIS are too restrictive for this package."; | |
| fi; | |
| echo ${order}; | |
| return 0 | |
| } | |
| get_libdir () | |
| { | |
| local libdir_var="LIBDIR_${ABI}"; | |
| local libdir="lib"; | |
| [[ -n ${ABI} && -n ${!libdir_var} ]] && libdir=${!libdir_var}; | |
| echo "${libdir}" | |
| } | |
| get_libname () | |
| { | |
| local libname; | |
| local ver=$1; | |
| case ${CHOST} in | |
| mingw* | *-mingw*) | |
| libname="dll" | |
| ;; | |
| *-darwin*) | |
| libname="dylib" | |
| ;; | |
| *) | |
| libname="so" | |
| ;; | |
| esac; | |
| if [[ -z $* ]]; then | |
| echo ".${libname}"; | |
| else | |
| for ver in "$@"; | |
| do | |
| case ${CHOST} in | |
| *-darwin*) | |
| echo ".${ver}.${libname}" | |
| ;; | |
| *) | |
| echo ".${libname}.${ver}" | |
| ;; | |
| esac; | |
| done; | |
| fi | |
| } | |
| get_makeopts_jobs () | |
| { | |
| makeopts_jobs "$(_get_all_makeopts)" "${1:-1}" | |
| } | |
| get_makeopts_loadavg () | |
| { | |
| makeopts_loadavg "$(_get_all_makeopts)" "${1:-999}" | |
| } | |
| get_modname () | |
| { | |
| local modname; | |
| local ver=$1; | |
| case ${CHOST} in | |
| *-darwin*) | |
| modname="bundle" | |
| ;; | |
| *) | |
| modname="so" | |
| ;; | |
| esac; | |
| echo ".${modname}" | |
| } | |
| get_nproc () | |
| { | |
| local nproc; | |
| if type -P nproc &> /dev/null; then | |
| nproc=$(nproc); | |
| fi; | |
| if [[ -z ${nproc} ]] && type -P sysctl &> /dev/null; then | |
| nproc=$(sysctl -n hw.ncpu 2> /dev/null); | |
| fi; | |
| if [[ -z ${nproc} ]] && type -P python &> /dev/null; then | |
| nproc=$(python -c 'import multiprocessing; print(multiprocessing.cpu_count());' 2> /dev/null); | |
| fi; | |
| if [[ -n ${nproc} ]]; then | |
| echo "${nproc}"; | |
| else | |
| echo "${1:-1}"; | |
| fi | |
| } | |
| has_multilib_profile () | |
| { | |
| [ -n "${MULTILIB_ABIS}" -a "${MULTILIB_ABIS}" != "${MULTILIB_ABIS/ /}" ] | |
| } | |
| in_iuse () | |
| { | |
| local use=${1}; | |
| if [[ -z "${use}" ]]; then | |
| echo "!!! in_iuse() called without a parameter." 1>&2; | |
| echo "!!! in_iuse <USEFLAG>" 1>&2; | |
| die "in_iuse() called without a parameter"; | |
| fi; | |
| local liuse=(${IUSE_EFFECTIVE}); | |
| has "${use}" "${liuse[@]#[+-]}" | |
| } | |
| is_final_abi () | |
| { | |
| has_multilib_profile || return 0; | |
| set -- $(get_install_abis); | |
| local LAST_ABI=$#; | |
| [[ ${!LAST_ABI} == ${ABI} ]] | |
| } | |
| makeopts_jobs () | |
| { | |
| [[ $# -eq 0 ]] && set -- "$(_get_all_makeopts)"; | |
| local jobs=$(echo " $* " | sed -r -n -e 's:.*[[:space:]](-[a-z]*j|--jobs[=[:space:]])[[:space:]]*([0-9]+).*:\2:p' -e "s:.*[[:space:]](-[a-z]*j|--jobs)[[:space:]].*:${2:-$(( $(get_nproc) + 1 ))}:p"); | |
| echo ${jobs:-1} | |
| } | |
| makeopts_loadavg () | |
| { | |
| [[ $# -eq 0 ]] && set -- "$(_get_all_makeopts)"; | |
| local lavg=$(echo " $* " | sed -r -n -e 's:.*[[:space:]](-[a-z]*l|--(load-average|max-load)[=[:space:]])[[:space:]]*([0-9]+(\.[0-9]+)?)[[:space:]].*:\3:p' -e "s:.*[[:space:]](-[a-z]*l|--(load-average|max-load))[[:space:]].*:${2:-999}:p"); | |
| echo ${lavg:-${2:-999}} | |
| } | |
| multilib_env () | |
| { | |
| local CTARGET=${1:-${CTARGET}}; | |
| local cpu=${CTARGET%%*-}; | |
| if [[ ${CTARGET} = *-musl* ]]; then | |
| : "${MULTILIB_ABIS=default}"; | |
| : "${DEFAULT_ABI=default}"; | |
| export MULTILIB_ABIS DEFAULT_ABI; | |
| return; | |
| fi; | |
| case ${cpu} in | |
| aarch64*) | |
| export CFLAGS_arm=${CFLAGS_arm-}; | |
| case ${cpu} in | |
| aarch64*be) | |
| export CHOST_arm="armv8b-${CTARGET#*-}" | |
| ;; | |
| *) | |
| export CHOST_arm="armv8l-${CTARGET#*-}" | |
| ;; | |
| esac; | |
| CHOST_arm=${CHOST_arm/%-gnu/-gnueabi}; | |
| export CTARGET_arm=${CHOST_arm}; | |
| export LIBDIR_arm="lib"; | |
| export CFLAGS_arm64=${CFLAGS_arm64-}; | |
| export CHOST_arm64=${CTARGET}; | |
| export CTARGET_arm64=${CHOST_arm64}; | |
| export LIBDIR_arm64="lib64"; | |
| : "${MULTILIB_ABIS=arm64}"; | |
| : "${DEFAULT_ABI=arm64}" | |
| ;; | |
| x86_64*) | |
| export CFLAGS_x86=${CFLAGS_x86--m32}; | |
| export CHOST_x86=${CTARGET/x86_64/i686}; | |
| CHOST_x86=${CHOST_x86/%-gnux32/-gnu}; | |
| export CTARGET_x86=${CHOST_x86}; | |
| if [[ ${SYMLINK_LIB} == "yes" ]]; then | |
| export LIBDIR_x86="lib32"; | |
| else | |
| export LIBDIR_x86="lib"; | |
| fi; | |
| export CFLAGS_amd64=${CFLAGS_amd64--m64}; | |
| export CHOST_amd64=${CTARGET/%-gnux32/-gnu}; | |
| export CTARGET_amd64=${CHOST_amd64}; | |
| export LIBDIR_amd64="lib64"; | |
| export CFLAGS_x32=${CFLAGS_x32--mx32}; | |
| export CHOST_x32=${CTARGET/%-gnu/-gnux32}; | |
| export CTARGET_x32=${CHOST_x32}; | |
| export LIBDIR_x32="libx32"; | |
| case ${CTARGET} in | |
| *-gnux32) | |
| : "${MULTILIB_ABIS=x32 amd64 x86}"; | |
| : "${DEFAULT_ABI=x32}" | |
| ;; | |
| *) | |
| : "${MULTILIB_ABIS=amd64 x86}"; | |
| : "${DEFAULT_ABI=amd64}" | |
| ;; | |
| esac | |
| ;; | |
| loongarch64*) | |
| export CFLAGS_lp64d=${CFLAGS_lp64d--mabi=lp64d}; | |
| export CHOST_lp64d=${CTARGET}; | |
| export CTARGET_lp64d=${CTARGET}; | |
| export LIBDIR_lp64d=${LIBDIR_lp64d-lib64}; | |
| : "${MULTILIB_ABIS=lp64d}"; | |
| : "${DEFAULT_ABI=lp64d}" | |
| ;; | |
| mips64* | mipsisa64*) | |
| export CFLAGS_o32=${CFLAGS_o32--mabi=32}; | |
| export CHOST_o32=${CTARGET/mips64/mips}; | |
| export CHOST_o32=${CHOST_o32/mipsisa64/mipsisa32}; | |
| export CTARGET_o32=${CHOST_o32}; | |
| export LIBDIR_o32="lib"; | |
| export CFLAGS_n32=${CFLAGS_n32--mabi=n32}; | |
| export CHOST_n32=${CTARGET}; | |
| export CTARGET_n32=${CHOST_n32}; | |
| export LIBDIR_n32="lib32"; | |
| export CFLAGS_n64=${CFLAGS_n64--mabi=64}; | |
| export CHOST_n64=${CTARGET}; | |
| export CTARGET_n64=${CHOST_n64}; | |
| export LIBDIR_n64="lib64"; | |
| : "${MULTILIB_ABIS=n64 n32 o32}"; | |
| : "${DEFAULT_ABI=n32}" | |
| ;; | |
| powerpc64*) | |
| export CFLAGS_ppc=${CFLAGS_ppc--m32}; | |
| export CHOST_ppc=${CTARGET/powerpc64/powerpc}; | |
| export CTARGET_ppc=${CHOST_ppc}; | |
| export LIBDIR_ppc="lib"; | |
| export CFLAGS_ppc64=${CFLAGS_ppc64--m64}; | |
| export CHOST_ppc64=${CTARGET}; | |
| export CTARGET_ppc64=${CHOST_ppc64}; | |
| export LIBDIR_ppc64="lib64"; | |
| : "${MULTILIB_ABIS=ppc64 ppc}"; | |
| : "${DEFAULT_ABI=ppc64}" | |
| ;; | |
| riscv64*) | |
| : "${MULTILIB_ABIS=lp64d lp64 ilp32d ilp32}"; | |
| : "${DEFAULT_ABI=lp64d}"; | |
| local _libdir_riscvdefaultabi_variable="LIBDIR_${DEFAULT_ABI}"; | |
| local _libdir_riscvdefaultabi=${!_libdir_riscvdefaultabi_variable}; | |
| export ${_libdir_riscvdefaultabi_variable}=${_libdir_riscvdefaultabi:-lib64}; | |
| export CFLAGS_lp64d=${CFLAGS_lp64d--mabi=lp64d -march=rv64gc}; | |
| export CHOST_lp64d=${CTARGET}; | |
| export CTARGET_lp64d=${CTARGET}; | |
| export LIBDIR_lp64d=${LIBDIR_lp64d-lib64/lp64d}; | |
| export CFLAGS_lp64=${CFLAGS_lp64--mabi=lp64 -march=rv64imac}; | |
| export CHOST_lp64=${CTARGET}; | |
| export CTARGET_lp64=${CTARGET}; | |
| export LIBDIR_lp64=${LIBDIR_lp64-lib64/lp64}; | |
| export CFLAGS_ilp32d=${CFLAGS_ilp32d--mabi=ilp32d -march=rv32imafdc}; | |
| export CHOST_ilp32d=${CTARGET/riscv64/riscv32}; | |
| export CTARGET_ilp32d=${CTARGET/riscv64/riscv32}; | |
| export LIBDIR_ilp32d=${LIBDIR_ilp32d-lib32/ilp32d}; | |
| export CFLAGS_ilp32=${CFLAGS_ilp32--mabi=ilp32 -march=rv32imac}; | |
| export CHOST_ilp32=${CTARGET/riscv64/riscv32}; | |
| export CTARGET_ilp32=${CTARGET/riscv64/riscv32}; | |
| export LIBDIR_ilp32=${LIBDIR_ilp32-lib32/ilp32} | |
| ;; | |
| riscv32*) | |
| : "${MULTILIB_ABIS=ilp32d ilp32}"; | |
| : "${DEFAULT_ABI=ilp32d}"; | |
| local _libdir_riscvdefaultabi_variable="LIBDIR_${DEFAULT_ABI}"; | |
| local _libdir_riscvdefaultabi=${!_libdir_riscvdefaultabi_variable}; | |
| export ${_libdir_riscvdefaultabi_variable}=${_libdir_riscvdefaultabi:-lib}; | |
| export CFLAGS_ilp32d=${CFLAGS_ilp32d--mabi=ilp32d -march=rv32imafdc}; | |
| export CHOST_ilp32d=${CTARGET}; | |
| export CTARGET_ilp32d=${CTARGET}; | |
| export LIBDIR_ilp32d=${LIBDIR_ilp32d-lib32/ilp32d}; | |
| export CFLAGS_ilp32=${CFLAGS_ilp32--mabi=ilp32 -march=rv32imac}; | |
| export CHOST_ilp32=${CTARGET}; | |
| export CTARGET_ilp32=${CTARGET}; | |
| export LIBDIR_ilp32=${LIBDIR_ilp32-lib32/ilp32} | |
| ;; | |
| s390x*) | |
| export CFLAGS_s390=${CFLAGS_s390--m31}; | |
| export CHOST_s390=${CTARGET/s390x/s390}; | |
| export CTARGET_s390=${CHOST_s390}; | |
| export LIBDIR_s390="lib"; | |
| export CFLAGS_s390x=${CFLAGS_s390x--m64}; | |
| export CHOST_s390x=${CTARGET}; | |
| export CTARGET_s390x=${CHOST_s390x}; | |
| export LIBDIR_s390x="lib64"; | |
| : "${MULTILIB_ABIS=s390x s390}"; | |
| : "${DEFAULT_ABI=s390x}" | |
| ;; | |
| sparc64*) | |
| export CFLAGS_sparc32=${CFLAGS_sparc32--m32}; | |
| export CHOST_sparc32=${CTARGET/sparc64/sparc}; | |
| export CTARGET_sparc32=${CHOST_sparc32}; | |
| export LIBDIR_sparc32="lib"; | |
| export CFLAGS_sparc64=${CFLAGS_sparc64--m64}; | |
| export CHOST_sparc64=${CTARGET}; | |
| export CTARGET_sparc64=${CHOST_sparc64}; | |
| export LIBDIR_sparc64="lib64"; | |
| : "${MULTILIB_ABIS=sparc64 sparc32}"; | |
| : "${DEFAULT_ABI=sparc64}" | |
| ;; | |
| *) | |
| : "${MULTILIB_ABIS=default}"; | |
| : "${DEFAULT_ABI=default}" | |
| ;; | |
| esac; | |
| export MULTILIB_ABIS DEFAULT_ABI | |
| } | |
| multilib_toolchain_setup () | |
| { | |
| local v vv; | |
| export ABI=$1; | |
| local save_restore_variables=(CBUILD CHOST AR CC CXX F77 FC LD NM OBJCOPY OBJDUMP PKG_CONFIG RANLIB READELF STRINGS STRIP PKG_CONFIG_LIBDIR PKG_CONFIG_PATH PKG_CONFIG_SYSTEM_INCLUDE_PATH PKG_CONFIG_SYSTEM_LIBRARY_PATH); | |
| if [[ ${_DEFAULT_ABI_SAVED} == "true" ]]; then | |
| for v in "${save_restore_variables[@]}"; | |
| do | |
| vv="_abi_saved_${v}"; | |
| [[ ${!vv+set} == "set" ]] && export ${v}="${!vv}" || unset ${v}; | |
| unset ${vv}; | |
| done; | |
| unset _DEFAULT_ABI_SAVED; | |
| fi; | |
| if [[ ${ABI} != ${DEFAULT_ABI} ]]; then | |
| for v in "${save_restore_variables[@]}"; | |
| do | |
| vv="_abi_saved_${v}"; | |
| [[ ${!v+set} == "set" ]] && export ${vv}="${!v}" || unset ${vv}; | |
| done; | |
| export _DEFAULT_ABI_SAVED="true"; | |
| if [[ ${CBUILD} == "${CHOST}" ]]; then | |
| export CBUILD=$(get_abi_CHOST $1); | |
| fi; | |
| export CHOST=$(get_abi_CHOST ${DEFAULT_ABI}); | |
| export AR="$(tc-getAR)"; | |
| export CC="$(tc-getCC) $(get_abi_CFLAGS)"; | |
| export CXX="$(tc-getCXX) $(get_abi_CFLAGS)"; | |
| export F77="$(tc-getF77) $(get_abi_CFLAGS)"; | |
| export FC="$(tc-getFC) $(get_abi_CFLAGS)"; | |
| export LD="$(tc-getLD) $(get_abi_LDFLAGS)"; | |
| export NM="$(tc-getNM)"; | |
| export OBJCOPY="$(tc-getOBJCOPY)"; | |
| export OBJDUMP="$(tc-getOBJDUMP)"; | |
| export PKG_CONFIG="$(tc-getPKG_CONFIG)"; | |
| export RANLIB="$(tc-getRANLIB)"; | |
| export READELF="$(tc-getREADELF)"; | |
| export STRINGS="$(tc-getSTRINGS)"; | |
| export STRIP="$(tc-getSTRIP)"; | |
| export CHOST=$(get_abi_CHOST $1); | |
| export PKG_CONFIG_LIBDIR=${EPREFIX}/usr/$(get_libdir)/pkgconfig; | |
| export PKG_CONFIG_PATH=${EPREFIX}/usr/share/pkgconfig; | |
| export PKG_CONFIG_SYSTEM_INCLUDE_PATH=${EPREFIX}/usr/include; | |
| export PKG_CONFIG_SYSTEM_LIBRARY_PATH=${EPREFIX}/$(get_libdir):${EPREFIX}/usr/$(get_libdir); | |
| fi | |
| } | |
| number_abis () | |
| { | |
| set -- `get_install_abis`; | |
| echo $# | |
| } | |
| perl-module_pkg_postinst () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| if [[ ${CATEGORY} != perl-core ]]; then | |
| eerror "perl-module.eclass: You are calling perl-module_pkg_postinst outside the perl-core category."; | |
| die " This does not do anything; the call can be removed."; | |
| fi; | |
| perl_link_duallife_scripts | |
| } | |
| perl-module_pkg_postrm () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| if [[ ${CATEGORY} != perl-core ]]; then | |
| eerror "perl-module.eclass: You are calling perl-module_pkg_postrm outside the perl-core category."; | |
| die " This does not do anything; the call can be removed."; | |
| fi; | |
| perl_link_duallife_scripts | |
| } | |
| perl-module_src_compile () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| perl_set_version; | |
| case ${EAPI} in | |
| 7) | |
| if [[ $(declare -p mymake 2>&-) != "declare -a mymake="* ]]; then | |
| local mymake_local=(${mymake}); | |
| else | |
| local mymake_local=("${mymake[@]}"); | |
| fi | |
| ;; | |
| *) | |
| local mymake_local=("${DIST_MAKE[@]}") | |
| ;; | |
| esac; | |
| if [[ -f Build ]]; then | |
| ./Build build || die "Compilation failed"; | |
| else | |
| if [[ -f Makefile ]]; then | |
| set -- OTHERLDFLAGS="${LDFLAGS}" "${mymake_local[@]}"; | |
| emake "$@"; | |
| fi; | |
| fi | |
| } | |
| perl-module_src_configure () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| export CCLD=$(tc-getCC); | |
| unset LD; | |
| perl_check_env; | |
| perl_set_version; | |
| [[ -z ${pm_echovar} ]] && export PERL_MM_USE_DEFAULT=1; | |
| export PERL_EXTUTILS_AUTOINSTALL="--skipdeps"; | |
| export PERL_CANARY_STABILITY_DISABLE=1; | |
| if [[ $(declare -p myconf 2>&-) != "declare -a myconf="* ]]; then | |
| local myconf_local=(${myconf}); | |
| else | |
| local myconf_local=("${myconf[@]}"); | |
| fi; | |
| if [[ ( ${PREFER_BUILDPL} == yes || ! -f Makefile.PL ) && -f Build.PL ]]; then | |
| if grep -q '\(use\|require\)\s*Module::Build::Tiny' Build.PL; then | |
| einfo "Using Module::Build::Tiny"; | |
| if [[ ${BDEPEND} != *dev-perl/Module-Build-Tiny* && ${PN} != Module-Build-Tiny ]]; then | |
| eerror "QA Notice: The ebuild uses Module::Build::Tiny but doesn't depend on it."; | |
| eerror " Add dev-perl/Module-Build-Tiny to BDEPEND!"; | |
| fi; | |
| else | |
| einfo "Using Module::Build"; | |
| if [[ ${BDEPEND} != *virtual/perl-Module-Build* && ${BDEPEND} != *dev-perl/Module-Build* && ${PN} != Module-Build ]]; then | |
| eerror "QA Notice: The ebuild uses Module::Build but doesn't depend on it."; | |
| eerror " Add dev-perl/Module-Build to BDEPEND!"; | |
| fi; | |
| fi; | |
| set -- --installdirs=vendor --libdoc= --destdir="${D}" --create_packlist=1 "${myconf_local[@]}"; | |
| einfo "perl Build.PL" "$@"; | |
| perl Build.PL "$@" <<< "${pm_echovar}" || die "Unable to build!"; | |
| else | |
| if [[ -f Makefile.PL ]]; then | |
| einfo "Using ExtUtils::MakeMaker"; | |
| set -- PREFIX="${EPREFIX}"/usr INSTALLDIRS=vendor INSTALLMAN3DIR='none' DESTDIR="${D}" "${myconf_local[@]}"; | |
| einfo "perl Makefile.PL" "$@"; | |
| perl Makefile.PL "$@" <<< "${pm_echovar}" || die "Unable to build!"; | |
| fi; | |
| fi; | |
| if [[ ! -f Build.PL && ! -f Makefile.PL ]]; then | |
| einfo "No Make or Build file detected..."; | |
| return; | |
| fi | |
| } | |
| perl-module_src_install () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| perl_set_version; | |
| local f; | |
| if [[ -f Build ]]; then | |
| mytargets="${mytargets:-install}"; | |
| mbparams="${mbparams:---pure}"; | |
| einfo "./Build ${mytargets} ${mbparams}"; | |
| ./Build ${mytargets} ${mbparams} || die "./Build ${mytargets} ${mbparams} failed"; | |
| else | |
| if [[ -f Makefile ]]; then | |
| case "${CATEGORY}" in | |
| dev-perl | perl-core) | |
| mytargets="pure_install" | |
| ;; | |
| *) | |
| mytargets="install" | |
| ;; | |
| esac; | |
| if [[ $(declare -p myinst 2>&-) != "declare -a myinst="* ]]; then | |
| local myinst_local=(${myinst}); | |
| else | |
| local myinst_local=("${myinst[@]}"); | |
| fi; | |
| emake "${myinst_local[@]}" ${mytargets}; | |
| fi; | |
| fi; | |
| case ${EAPI} in | |
| 7) | |
| ;; | |
| *) | |
| perl_fix_permissions | |
| ;; | |
| esac; | |
| perl_delete_module_manpages; | |
| perl_delete_localpod; | |
| perl_fix_packlist; | |
| perl_delete_emptybsdir; | |
| perl_remove_temppath; | |
| for f in Change* CHANGES README* TODO FAQ ${mydoc}; | |
| do | |
| [[ -s ${f} ]] && dodoc ${f}; | |
| done; | |
| if in_iuse examples && use examples; then | |
| [[ ${#DIST_EXAMPLES[@]} -eq 0 ]] || perl_doexamples "${DIST_EXAMPLES[@]}"; | |
| fi; | |
| perl_link_duallife_scripts; | |
| case ${EAPI} in | |
| 7) | |
| ;; | |
| *) | |
| if has 'features' ${DIST_WIKI}; then | |
| DISABLE_AUTOFORMATTING=yes; | |
| DOC_CONTENTS="This package may require additional dependencies and/or preparation steps for\n"; | |
| DOC_CONTENTS+="some optional features. For details, see\n"; | |
| DOC_CONTENTS+="$(perl_get_wikiurl_features)"; | |
| einfo; | |
| readme.gentoo_create_doc; | |
| readme.gentoo_print_elog; | |
| fi | |
| ;; | |
| esac | |
| } | |
| perl-module_src_prepare () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| default; | |
| if [[ -n ${PERL_RM_FILES[@]} ]]; then | |
| debug-print "$FUNCNAME: stripping unneeded files"; | |
| perl_rm_files "${PERL_RM_FILES[@]}"; | |
| fi; | |
| perl_fix_osx_extra | |
| } | |
| perl-module_src_test () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| local my_test_control; | |
| local my_test_verbose; | |
| local my_test_makeopts; | |
| [[ -n "${DIST_TEST_OVERRIDE}" ]] && ewarn "DIST_TEST_OVERRIDE is set to ${DIST_TEST_OVERRIDE}"; | |
| my_test_control=${DIST_TEST_OVERRIDE:-${DIST_TEST:-do parallel}}; | |
| if ! has 'do' ${my_test_control} && ! has 'parallel' ${my_test_control}; then | |
| einfo Skipping tests due to DIST_TEST=${my_test_control}; | |
| return 0; | |
| fi; | |
| if has 'do' ${my_test_control} && ! has 'parallel' ${my_test_control}; then | |
| my_test_makeopts="-j1"; | |
| fi; | |
| if has verbose ${my_test_control}; then | |
| my_test_verbose=1; | |
| else | |
| my_test_verbose=0; | |
| fi; | |
| if has parallel ${my_test_control}; then | |
| export HARNESS_OPTIONS=j$(makeopts_jobs); | |
| einfo "Test::Harness Jobs=$(makeopts_jobs)"; | |
| fi; | |
| if ! has network ${my_test_control}; then | |
| export NO_NETWORK_TESTING=1; | |
| fi; | |
| export NONINTERACTIVE_TESTING=1; | |
| case ${EAPI} in | |
| 7) | |
| ;; | |
| *) | |
| if has 'tests' ${DIST_WIKI}; then | |
| ewarn "This package may require additional dependencies and/or preparation steps for"; | |
| ewarn "comprehensive testing. For details, see:"; | |
| ewarn "$(perl_get_wikiurl_tests)"; | |
| fi | |
| ;; | |
| esac; | |
| perl_set_version; | |
| if [[ -f Build ]]; then | |
| ./Build test verbose=${my_test_verbose} || die "test failed"; | |
| else | |
| if [[ -f Makefile ]]; then | |
| emake ${my_test_makeopts} test TEST_VERBOSE=${my_test_verbose}; | |
| fi; | |
| fi | |
| } | |
| perl_check_env () | |
| { | |
| local errored value; | |
| for i in PERL_MM_OPT PERL5LIB PERL5OPT PERL_MB_OPT PERL_CORE PERLPREFIX; | |
| do | |
| [[ -v $i ]] || continue; | |
| if [[ ${errored:-0} == 0 ]]; then | |
| if [[ -n ${I_KNOW_WHAT_I_AM_DOING} ]]; then | |
| elog "perl-module.eclass: Suspicious environment values found."; | |
| else | |
| eerror "perl-module.eclass: Suspicious environment values found."; | |
| fi; | |
| fi; | |
| errored=1; | |
| value=${!i}; | |
| if [[ -n ${I_KNOW_WHAT_I_AM_DOING} ]]; then | |
| elog " $i=\"$value\""; | |
| else | |
| eerror " $i=\"$value\""; | |
| fi; | |
| done; | |
| [[ ${errored:-0} == 0 ]] && return; | |
| if [[ -n ${I_KNOW_WHAT_I_AM_DOING} ]]; then | |
| elog "Continuing anyway, seems you know what you're doing."; | |
| return; | |
| fi; | |
| eerror "Your environment settings may lead to undefined behavior and/or build failures."; | |
| die "Please fix your environment ( ~/.bashrc, package.env, ... ), see above for details." | |
| } | |
| perl_delete_emptybsdir () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| perl_set_version; | |
| if [[ -d ${D}/${VENDOR_ARCH} ]]; then | |
| find "${D}/${VENDOR_ARCH}" -type f -a -name '*.bs' -a -empty -delete; | |
| find "${D}" -depth -mindepth 1 -type d -empty -delete; | |
| fi | |
| } | |
| perl_delete_localpod () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| find "${D}" -type f -name perllocal.pod -delete; | |
| find "${D}" -depth -mindepth 1 -type d -empty -delete | |
| } | |
| perl_delete_module_manpages () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| if [[ -d "${ED}"/usr/share/man ]]; then | |
| find "${ED}"/usr/share/man -type f -name "*.3pm" -delete; | |
| find "${ED}"/usr/share/man -depth -type d -empty -delete; | |
| fi | |
| } | |
| perl_delete_packlist () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| perl_set_version; | |
| if [[ -d ${D}/${VENDOR_ARCH} ]]; then | |
| find "${D}/${VENDOR_ARCH}" -type f -a -name .packlist -delete; | |
| perl_delete_emptybsdir; | |
| fi | |
| } | |
| perl_doexamples () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| einfo "Installing examples into /usr/share/doc/${PF}/examples"; | |
| docompress -x /usr/share/doc/${PF}/examples; | |
| docinto examples/; | |
| dodoc -r $@ | |
| } | |
| perl_domodule () | |
| { | |
| local target_prefix=""; | |
| local files=(); | |
| local doins_opts=(); | |
| local recursive="false"; | |
| local target; | |
| local file; | |
| while [[ $# -gt 0 ]]; do | |
| case $1 in | |
| -C | --target-prefix) | |
| [[ -z "${2}" || "${2:0:1}" == "-" ]] && die "${FUNCNAME}: -C|--target-prefix expects an argument, got \"$2\"!"; | |
| target_prefix="${2}"; | |
| shift 2 | |
| ;; | |
| -r) | |
| recursive="true"; | |
| shift | |
| ;; | |
| *) | |
| [[ -z "${1}" || "${1:0:1}" == "-" ]] && die "${FUNCNAME}: Unknown argument \"${1}\"!"; | |
| files+=("${1}"); | |
| shift 1 | |
| ;; | |
| esac; | |
| done; | |
| if [[ "true" == $recursive ]]; then | |
| doins_opts+=("-r"); | |
| fi; | |
| for file in "${files[@]}"; | |
| do | |
| [[ -e "${file}" ]] || die "$FUNCNAME: Argument \"${file}\" is not an existing file"; | |
| [[ "false" == ${recursive} && -d "${file}" ]] && die "$FUNCNAME: Argument \"${file}\" is a directory ( needs -r parameter )"; | |
| done; | |
| target="$(perl_get_vendorlib)"; | |
| [[ -z "${target_prefix}" ]] || target="${target%/}/${target_prefix#/}"; | |
| insinto "/${target#/}"; | |
| doins "${doins_opts[@]}" "${files[@]}" | |
| } | |
| perl_fix_osx_extra () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| local f; | |
| find "${S}" -type f -name "._*" -print0 | while read -rd '' f; do | |
| einfo "Removing AppleDouble encoded Macintosh file: ${f#${S}/}"; | |
| rm -f "${f}"; | |
| f=${f#${S}/}; | |
| grep -q "${f}" "${S}"/MANIFEST && elog "AppleDouble encoded Macintosh file in MANIFEST: ${f#${S}/}"; | |
| done | |
| } | |
| perl_fix_packlist () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| local packlist_temp="${T}/.gentoo_packlist_temp"; | |
| find "${D}" -type f -name '.packlist' -print0 | while read -rd '' f; do | |
| if file "${f}" | grep -q -i " text"; then | |
| einfo "Fixing packlist file /${f#${D}}"; | |
| sed -i -e "s:${D%/}/:/:g" "${f}"; | |
| sort -u "${f}" > "${packlist_temp}"; | |
| mv "${packlist_temp}" "${f}"; | |
| cat "${f}" | while read -r entry; do | |
| if [[ ! -e ${D}/${entry} ]]; then | |
| einfo "Pruning surplus packlist entry ${entry}"; | |
| grep -v -x -F "${entry}" "${f}" > "${packlist_temp}"; | |
| mv "${packlist_temp}" "${f}"; | |
| fi; | |
| done; | |
| fi; | |
| done | |
| } | |
| perl_fix_permissions () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| perl_set_version; | |
| einfo Fixing installed file permissions; | |
| fperms -R u+w / | |
| } | |
| perl_get_module_version () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ $# -gt 0 ]] || die "${FUNCNAME}: No module name provided"; | |
| [[ $# -lt 2 ]] || die "${FUNCNAME}: Too many parameters ($#)"; | |
| if ! perl_has_module "$@"; then | |
| echo "(Not Installed)"; | |
| return 1; | |
| fi; | |
| perl -we 'my $mn = $ARGV[0]; | |
| $mn =~ s{(::|\x{27})}{/}g; | |
| local $@; | |
| eval { require qq[${mn}.pm]; 1 } or do { | |
| print q[(Compilation failed in require)]; | |
| exit 1; | |
| }; | |
| my $stash = \%{ $ARGV[0] . q[::] }; | |
| if ( not exists $stash->{VERSION} ) { | |
| print q[(No VERSION property)]; | |
| exit 0; | |
| } | |
| if ( not defined ${$stash->{VERSION}} ) { | |
| print q[(undef)]; | |
| exit 0; | |
| } | |
| print ${$stash->{VERSION}}; | |
| exit 0; ' "$@" | |
| } | |
| perl_get_raw_vendorlib () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ $# -lt 1 ]] || die "${FUNCNAME}: Too many parameters ($#)"; | |
| perl -MConfig -e'exists $Config{$ARGV[0]} || die qq{No such Config key "$ARGV[0]"}; | |
| print $Config{$ARGV[0]}; | |
| exit 0' -- "installvendorlib" || die "Can't extract installvendorlib from Perl Configuration" | |
| } | |
| perl_get_vendorlib () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ $# -lt 1 ]] || die "${FUNCNAME}: Too many parameters ($#)"; | |
| perl -M5.014 -MConfig -e'exists $Config{$ARGV[0]} || die qq{No such Config key "$ARGV[0]"}; | |
| print $Config{$ARGV[0]} =~ s{\A\Q$ARGV[1]\E}{}r; | |
| exit 0' -- "installvendorlib" "$EPREFIX" || die "Can't extract installvendorlib from Perl Configuration" | |
| } | |
| perl_get_wikiurl () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| if [[ -z "${1}" ]]; then | |
| echo "https://wiki.gentoo.org/wiki/Project:Perl/maint-notes/${CATEGORY}/${PN}"; | |
| else | |
| echo "https://wiki.gentoo.org/wiki/Project:Perl/maint-notes/${CATEGORY}/${PN}#${1}"; | |
| fi | |
| } | |
| perl_get_wikiurl_features () | |
| { | |
| perl_get_wikiurl Optional_Features | |
| } | |
| perl_get_wikiurl_tests () | |
| { | |
| perl_get_wikiurl Testing | |
| } | |
| perl_has_module () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ $# -gt 0 ]] || die "${FUNCNAME}: No module name provided"; | |
| [[ $# -lt 2 ]] || die "${FUNCNAME}: Too many parameters ($#)"; | |
| perl -we 'my $mn = $ARGV[0]; | |
| $mn =~ s{(::|\x{27})}{/}g; | |
| for(@INC){ | |
| next if ref $_; | |
| exit 0 if -r $_ . q[/] . $mn . q[.pm] | |
| } | |
| exit 1' "$@" | |
| } | |
| perl_has_module_version () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ $# -gt 0 ]] || die "${FUNCNAME}: No module name provided"; | |
| [[ $# -gt 1 ]] || die "${FUNCNAME}: No module version provided"; | |
| [[ $# -lt 3 ]] || die "${FUNCNAME}: Too many parameters ($#)"; | |
| perl -we 'my $mn = $ARGV[0]; | |
| $mn =~ s{(::|\x{27})}{/}g; | |
| exit ( eval { | |
| require qq[${mn}.pm]; | |
| $ARGV[0]->VERSION($ARGV[1]); | |
| 1 | |
| } ? 0 : 1 )' "$@" | |
| } | |
| perl_link_duallife_scripts () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| [[ ${CATEGORY} != perl-core ]] && return 0; | |
| local i ff; | |
| if has "${EBUILD_PHASE:-none}" "postinst" "postrm"; then | |
| for i in "${DUALLIFESCRIPTS[@]}"; | |
| do | |
| alternatives_auto_makesym "/${i}" "/${i}-[0-9]*"; | |
| done; | |
| for i in "${DUALLIFEMAN[@]}"; | |
| do | |
| ff=`echo "${EROOT}"/${i%.1}-${PV}-${P}.1*`; | |
| ff=${ff##*.1}; | |
| alternatives_auto_makesym "/${i}${ff}" "/${i%.1}-[0-9]*"; | |
| done; | |
| else | |
| pushd "${ED}" > /dev/null; | |
| for i in $(find usr/bin -maxdepth 1 -type f 2> /dev/null); | |
| do | |
| mv ${i}{,-${PV}-${P}} || die; | |
| DUALLIFESCRIPTS[${#DUALLIFESCRIPTS[*]}]=${i}; | |
| done; | |
| for i in $(find usr/share/man/man1 -maxdepth 1 -type f 2> /dev/null); | |
| do | |
| mv ${i} ${i%.1}-${PV}-${P}.1 || die; | |
| DUALLIFEMAN[${#DUALLIFEMAN[*]}]=${i}; | |
| done; | |
| popd > /dev/null; | |
| fi | |
| } | |
| perl_remove_temppath () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| find "${D}" -type f -not -name '*.so' -print0 | while read -rd '' f; do | |
| if file "${f}" | grep -q -i " text"; then | |
| grep -q "${D}" "${f}" && ewarn "QA: File contains a temporary path ${f}"; | |
| sed -i -e "s:${D%/}/:/:g" "${f}"; | |
| fi; | |
| done | |
| } | |
| perl_rm_files () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| local skipfile="${T}/.gentoo_makefile_skip"; | |
| local manifile="${S}/MANIFEST"; | |
| local manitemp="${T}/.gentoo_manifest_temp"; | |
| oldifs="$IFS"; | |
| IFS="\n"; | |
| for filename in "$@"; | |
| do | |
| einfo "Removing un-needed ${filename}"; | |
| rm -f "${S}/${filename}"; | |
| [[ -e "${manifile}" ]] && echo "${filename}" >> "${skipfile}"; | |
| done; | |
| if [[ -e "${manifile}" && -e "${skipfile}" ]]; then | |
| einfo "Fixing Manifest"; | |
| grep -v -F -f "${skipfile}" "${manifile}" > "${manitemp}"; | |
| mv -f -- "${manitemp}" "${manifile}"; | |
| rm -- "${skipfile}"; | |
| fi; | |
| IFS="$oldifs" | |
| } | |
| perl_set_version () | |
| { | |
| debug-print-function ${FUNCNAME} "$@"; | |
| debug-print "$FUNCNAME: perlinfo_done=${perlinfo_done}"; | |
| ${perlinfo_done} && return 0; | |
| perlinfo_done=true; | |
| local f version install{{site,vendor}{arch,lib},archlib}; | |
| eval "$(perl -V:{version,install{{site,vendor}{arch,lib},archlib}})"; | |
| PERL_VERSION=${version}; | |
| SITE_ARCH=${installsitearch}; | |
| SITE_LIB=${installsitelib}; | |
| ARCH_LIB=${installarchlib}; | |
| VENDOR_LIB=${installvendorlib}; | |
| VENDOR_ARCH=${installvendorarch} | |
| } | |
| pkg_nofetch () | |
| { | |
| default | |
| } | |
| readme.gentoo_create_doc () | |
| { | |
| debug-print-function ${FUNCNAME} "${@}"; | |
| if [[ -n "${DOC_CONTENTS}" ]]; then | |
| if [[ -n "${DISABLE_AUTOFORMATTING}" ]]; then | |
| echo "${DOC_CONTENTS}" > "${T}"/README.gentoo || die; | |
| else | |
| local saved_flags=$-; | |
| set -f; | |
| echo -e ${DOC_CONTENTS} | fold -s -w 70 | sed 's/[[:space:]]*$//' > "${T}"/README.gentoo; | |
| assert; | |
| set +f -${saved_flags}; | |
| fi; | |
| else | |
| if [[ -f "${FILESDIR}/README.gentoo-${SLOT%/*}" ]]; then | |
| cp "${FILESDIR}/README.gentoo-${SLOT%/*}" "${T}"/README.gentoo || die; | |
| else | |
| if [[ -f "${FILESDIR}/README.gentoo${README_GENTOO_SUFFIX}" ]]; then | |
| cp "${FILESDIR}/README.gentoo${README_GENTOO_SUFFIX}" "${T}"/README.gentoo || die; | |
| else | |
| die "You are not specifying README.gentoo contents!"; | |
| fi; | |
| fi; | |
| fi; | |
| ( docinto .; | |
| dodoc "${T}"/README.gentoo ) || die; | |
| README_GENTOO_DOC_VALUE=$(< "${T}/README.gentoo") | |
| } | |
| readme.gentoo_print_elog () | |
| { | |
| debug-print-function ${FUNCNAME} "${@}"; | |
| if [[ -z "${README_GENTOO_DOC_VALUE}" ]]; then | |
| die "readme.gentoo_print_elog invoked without matching readme.gentoo_create_doc call!"; | |
| else | |
| if ! [[ -n "${REPLACING_VERSIONS}" ]] || [[ -n "${FORCE_PRINT_ELOG}" ]]; then | |
| echo -e "${README_GENTOO_DOC_VALUE}" | while read -r ELINE; do | |
| elog "${ELINE}"; | |
| done; | |
| elog ""; | |
| elog "(Note: Above message is only printed the first time package is"; | |
| elog "installed. Please look at ${EPREFIX}/usr/share/doc/${PF}/README.gentoo*"; | |
| elog "for future reference)"; | |
| fi; | |
| fi | |
| } | |
| src_compile () | |
| { | |
| perl-module_src_compile "$@" | |
| } | |
| src_configure () | |
| { | |
| perl-module_src_configure "$@" | |
| } | |
| src_install () | |
| { | |
| perl-module_src_install "$@" | |
| } | |
| src_prepare () | |
| { | |
| perl-module_src_prepare "$@" | |
| } | |
| src_test () | |
| { | |
| perl-module_src_test "$@" | |
| } | |
| src_unpack () | |
| { | |
| default | |
| } | |
| 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) | |
| 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-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; | |
| : "${flags:=-fPIC -shared -Wl,-z,defs}"; | |
| [[ $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"; | |
| case $(tc-get-compiler-type) in | |
| clang) | |
| $(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die; | |
| llvm-bcanalyzer "${f}" &> /dev/null && return 0 | |
| ;; | |
| gcc) | |
| $(tc-getCC) ${CFLAGS} -c -o "${f}" -x c - <<< "" || die; | |
| [[ $($(tc-getREADELF) -S "${f}") == *.gnu.lto* ]] && return 0 | |
| ;; | |
| esac; | |
| return 1 | |
| } | |
| 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-gold "$@" && ! tc-ld-is-lld "$@"; 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 LDFLAGS="${LDFLAGS} -fuse-ld=bfd"; | |
| fi | |
| } | |
| 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-gold"; | |
| 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-lld"; | |
| 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-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 | |
| 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" | |
| ;; | |
| arm*) | |
| echo "yes" | |
| ;; | |
| *) | |
| echo "no" | |
| ;; | |
| esac | |
| } | |
| 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 | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment