diff options
| -rw-r--r-- | eclass/multilib-native.eclass | 712 |
1 files changed, 0 insertions, 712 deletions
diff --git a/eclass/multilib-native.eclass b/eclass/multilib-native.eclass deleted file mode 100644 index 5bc8d3c..0000000 --- a/eclass/multilib-native.eclass +++ /dev/null @@ -1,712 +0,0 @@ -# Copyright 1999-2008 Gentoo Foundation -# Distributed under the terms of the GNU General Public License v2 -# -# Got this from multilib overlay. Thanks! -# -# @ECLASS: multilib-native.eclass -# @MAINTAINER: -# Steven Newbury <steve@snewbury.org.uk> -# @BLURB: Provide infrastructure for native multilib ebuilds - -IUSE="${IUSE} lib32" - -DEPEND="${DEPEND} sys-apps/abi-wrapper" -RDEPEND="${RDEPEND} sys-apps/abi-wrapper" - -if use lib32; then - EMULTILIB_PKG="true" -fi - -inherit base multilib - -case "${EAPI:-0}" in - 2|3) - EXPORT_FUNCTIONS pkg_setup src_unpack src_prepare src_configure src_compile src_install pkg_preinst pkg_postinst pkg_postrm - ;; - *) - EXPORT_FUNCTIONS pkg_setup src_unpack src_compile src_install pkg_preinst pkg_postinst pkg_postrm - ;; -esac - -# ----------------------------------------------------------------------------- - -# @VARIABLE: EMULTILIB_SAVE_VARS -# @DESCRIPTION: Environment variables to save -# EMULTILIB_SAVE_VARS="${EMULTILIB_SAVE_VARS} -# AS CC CXX FC LD ASFLAGS CFLAGS CXXFLAGS FCFLAGS FFLAGS LDFLAGS -# CHOST CBUILD CDEFINE LIBDIR S CCACHE_DIR myconf PYTHON PERLBIN -# QMAKE QMAKESPEC QTBINDIR QTBASEDIR QTLIBDIR QTPCDIR -# QTPLUGINDIR CMAKE_BUILD_DIR mycmakeargs KDE_S POPPLER_MODULE_S -# ECONF_SOURCE MY_LIBDIR MOZLIBDIR SDKDIR G2CONF PKG_CONFIG_PATH -# DESTTREE SRC_PREP USE_64" -EMULTILIB_SAVE_VARS="${EMULTILIB_SAVE_VARS} - AS CC CXX FC LD ASFLAGS CFLAGS CXXFLAGS FCFLAGS FFLAGS LDFLAGS - CHOST CBUILD CDEFINE LIBDIR S CCACHE_DIR myconf PYTHON PERLBIN - QMAKE QMAKESPEC QTBINDIR QTBASEDIR QTLIBDIR QTPCDIR - QTPLUGINDIR CMAKE_BUILD_DIR mycmakeargs KDE_S POPPLER_MODULE_S - ECONF_SOURCE MY_LIBDIR MOZLIBDIR SDKDIR G2CONF PKG_CONFIG_PATH - DESTTREE SRC_PREP USE_64" - -# @VARIABLE: EMULTILIB_SOURCE_DIRNAME -# @DESCRIPTION: Holds the name of the source directory -# EMULTILIB_SOURCE_DIRNAME="" -EMULTILIB_SOURCE_DIRNAME="" - -# @VARIABLE: EMULTILIB_SOURCE -# @DESCRIPTION: -# PATH to the top-level source directory. This may be used in multilib-ised -# ebuilds choosing to make use of external build directories for installing -# files from the top of the source tree although for builds with external -# build directories it's sometimes more appropriate to use ${ECONF_SOURCE}. -# EMULTILIB_SOURCE="" -EMULTILIB_SOURCE="" - -# @VARIABLE: EMULTILIB_RELATIVE_BUILD_DIR -# @DESCRIPTION: -# EMULTILIB_RELATIVE_BUILD_DIR="" -EMULTILIB_RELATIVE_BUILD_DIR="" - -# @VARIABLE: CMAKE_BUILD_DIR -# @DESCRIPTION: -# Despite the name, this is used for all build systems within this eclass. -# Usually this is the same as ${S}, except when using an external build -# directory. (This is per ABI and so is saved/restored for each phase.) -# CMAKE_BUILD_DIR="" -CMAKE_BUILD_DIR="" - -# @VARIABLE: EMULTILIB_INHERITED -# @DESCRIPTION: -# Holds a list of inherited eclasses -# is this var is onlky used in multilib-native_check_inherited_funcs -EMULTILIB_INHERITED="" - -# ----------------------------------------------------------------------------- - -# @FUNCTION: multilib-native_pkg_setup -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the pkg_setup phase -multilib-native_pkg_setup() { - multilib-native_src_generic pkg_setup -} - -# @FUNCTION: multilib-native_src_unpack -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the src_unpack phase -multilib-native_src_unpack() { - multilib-native_src_generic src_unpack -} - -# @FUNCTION: multilib-native_src_prepare -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the src_prepare phase -multilib-native_src_prepare() { - multilib-native_src_generic src_prepare -} - -# @FUNCTION: multilib-native_src_configure -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the src_configure phase -multilib-native_src_configure() { - multilib-native_src_generic src_configure -} - -# @FUNCTION: multilib-native_src_compile -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the src_compile phase -multilib-native_src_compile() { - multilib-native_src_generic src_compile -} - -# @FUNCTION: multilib-native_src_install -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the src_install phase -multilib-native_src_install() { - multilib-native_src_generic src_install -} - -# @FUNCTION: multilib-native_pkg_preinst -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the pkg_preinst phase -multilib-native_pkg_preinst() { - multilib-native_src_generic pkg_preinst -} - -# @FUNCTION: multilib-native_pkg_postinst -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the pkg_postinst phase -multilib-native_pkg_postinst() { - multilib-native_src_generic pkg_postinst -} - -# @FUNCTION: multilib-native_pkg_postrm -# @USAGE: -# @DESCRIPTION: This is a multilib wrapper for the pkg_postrm phase -multilib-native_pkg_postrm() { - multilib-native_src_generic pkg_postrm -} - -# @FUNCTION: multilib_debug -# @USAGE: <name_of_variable> <content_of_variable> -# @DESCRIPTION: print debug output if MULTILIB_DEBUG is set -multilib_debug() { - [[ -n ${MULTILIB_DEBUG} ]] && einfo "MULTILIB_DEBUG: ${1}=\"${2}\"" -} - -# ----------------------------------------------------------------------------- - -# Internal function -# @FUNCTION: multilib-native_src_generic -# @USAGE: <phase> -# @DESCRIPTION: Run each phase for each "install ABI" -multilib-native_src_generic() { -# Recurse this function for each ABI from get_install_abis() - if [[ -n ${EMULTILIB_PKG} ]] && [[ -z ${OABI} ]] ; then - local abilist="" - if has_multilib_profile ; then - abilist=$(get_install_abis) - einfo "${1/src_/} multilib ${PN} for ABIs: ${abilist}" - elif is_crosscompile || tc-is-cross-compiler ; then - abilist=${DEFAULT_ABI} - fi - if [[ -n ${abilist} ]] ; then - OABI=${ABI} - for ABI in ${abilist} ; do - export ABI - multilib-native_src_generic ${1} - done - ABI=${OABI} - unset OABI - return 0 - fi - fi - -# If this is the first time through, initialise the source path variables early -# and unconditionally, whether building for multilib or not. (This allows -# multilib-native ebuilds to always make use of them.) Then save the initial -# environment. -# -# Sometimes, packages assume a directory structure ABOVE "S". ("S" is set to a -# subdirectory of the tree they unpack into ${WORKDIR}.) We need to deal with -# this by finding the top-level of the source tree and keeping track of ${S} -# relative to it. - - if [[ -z ${EMULTILIB_INITIALISED[$(multilib-native_abi_to_index_key "INIT")]} ]]; then - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: Determining EMULTILIB_SOURCE from S and WORKDIR" - EMULTILIB_RELATIVE_BUILD_DIR="${S#*${WORKDIR}\/}" - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: EMULTILIB_RELATIVE_BUILD_DIR=\"${EMULTILIB_RELATIVE_BUILD_DIR}\"" - EMULTILIB_SOURCE_DIRNAME="${EMULTILIB_RELATIVE_BUILD_DIR%%/*}" - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: EMULTILIB_SOURCE_DIRNAME=\"${EMULTILIB_SOURCE_DIRNAME}\"" - EMULTILIB_SOURCE="${WORKDIR}/${EMULTILIB_SOURCE_DIRNAME}" - CMAKE_BUILD_DIR="${S}" - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: EMULTILIB_SOURCE=\"${EMULTILIB_SOURCE}\"" - multilib-native_save_abi_env "INIT" - EMULTILIB_INITIALISED[$(multilib-native_abi_to_index_key "INIT")]=1 - fi - - if [[ -n ${EMULTILIB_PKG} ]] && has_multilib_profile; then - multilib-native_src_generic_sub ${1} - -# Save the environment for this ABI - multilib-native_save_abi_env "${ABI}" - -# If this is the default ABI and we have a build tree, update the INIT -# environment - [[ "${ABI}" == "${DEFAULT_ABI}" ]] && \ - [[ -d "${WORKDIR}/${PN}_build_${ABI}" ]] && \ - multilib-native_save_abi_env "INIT" - -# This assures the environment is correctly configured for non-multilib phases -# such as a src_unpack override in ebuilds. - multilib-native_restore_abi_env "INIT" - else - multilib-native_${1}_internal - fi -} - -# Internal function -# @FUNCTION: multilib-native_src_generic_sub -# @USAGE: <phase> -# @DESCRIPTION: This function gets used for each ABI pass of each phase -multilib-native_src_generic_sub() { -# We support two kinds of build: By default we copy/move the source dir for -# each ABI. Where supported with the underlying package, we can just create an -# external build dir. This requires a modified ebuild which makes use of the -# EMULTILIB_SOURCE variable (which points the the top of the original -# source dir) to install doc files etc. This latter behaviour is enabled with -# MULTILIB_EXT_SOURCE_BUILD. For CMake based packages default is reversed and -# the CMAKE_IN_SOURCE_BUILD environment variable is used to specify the former -# behaviour. -# - - if [[ -z ${EMULTILIB_INITIALISED[$(multilib-native_abi_to_index_key ${ABI})]} ]]; then - multilib-native_restore_abi_env "INIT" - multilib-native_setup_abi_env "${ABI}" - else - multilib-native_restore_abi_env "${ABI}" - fi - -# If this is the unpack or prepare phase we only need to run for the -# DEFAULT_ABI when we are building out of the source tree since it is shared -# between each ABI. -# -# After the unpack phase, some eclasses change into the unpacked source tree -# (gnome2.eclass for example), we need to change back to the WORKDIR otherwise -# the next ABI tree will get unpacked into a subdir of previous tree. - - - case ${1/*_} in - setup) - ;; - unpack) - [[ -d "${WORKDIR}" ]] && cd "${WORKDIR}" - if multilib-native_is_EBD && \ - [[ ! "${ABI}" == "${DEFAULT_ABI}" ]]; then - einfo "Skipping ${1} for ${ABI}" - return - fi - ;; - prepare) - if multilib-native_is_EBD; then - if [[ ! "${ABI}" == "${DEFAULT_ABI}" ]]; then - einfo "Skipping ${1} for ${ABI}" - return - fi - else - [[ ! -d "${WORKDIR}/${PN}_build_${ABI}" ]] && multilib-native_setup_build_directory - fi - if [[ -d "${S}" ]]; then - einfo "Working in ${S}" - cd "${S}" - else - ewarn "Not changing to non-existant source directory" - fi - ;; - configure|compile|install) - [[ ! -d "${WORKDIR}/${PN}_build_${ABI}" ]] && multilib-native_setup_build_directory - [[ -d "${S}" ]] && cd "${S}" - ;; - *) - [[ -d "${S}" ]] && cd "${S}" - ;; - esac - - - # FIXME: There is a failure case when there is no source directory - # at ${EMULTILIB_SOURCE}, creating a directory there is the *wrong* - # thing to do, certianly not unconditionally! - # mkdir -p "${EMULTILIB_SOURCE}" - -# Call the "real" phase function - multilib-native_${1}_internal - -# If we've just unpacked the source, move it into place. - if [[ ! "${1/unpack}" == "${1}" ]] && \ - ( [[ -d "${EMULTILIB_SOURCE}" ]] && \ - [[ ! -d "${WORKDIR}/${PN}_build_${ABI}" ]] ) && ! (multilib-native_is_EBD); then - einfo "Moving source tree from ${EMULTILIB_SOURCE} to ${WORKDIR}/${PN}_build_${ABI}" - mv "${EMULTILIB_SOURCE}" "${WORKDIR}/${PN}_build_${ABI}" - S="${CMAKE_BUILD_DIR}" - [[ -n ${KDE_S} ]] && KDE_S="${S}" - [[ -n ${POPPLER_MODULE_S} ]] && \ - POPPLER_MODULE_S=${S}/${POPPLER_MODULE} - fi -} - -multilib-native_setup_build_directory() { - if multilib-native_is_EBD; then - einfo "Preparing external build directory for ABI: ${ABI} ..." - einfo "Creating build directory: ${WORKDIR}/${PN}_build_${ABI}" - mkdir -p "${CMAKE_BUILD_DIR}" - ECONF_SOURCE="${S}" - else - if [[ -d ${EMULTILIB_SOURCE} ]]; then - if ! is_final_abi; then - einfo "Copying source tree from ${EMULTILIB_SOURCE} to ${WORKDIR}/${PN}_build_${ABI}" - cp -al "${EMULTILIB_SOURCE}" "${WORKDIR}/${PN}_build_${ABI}" - else - einfo "Moving source tree from ${EMULTILIB_SOURCE} to ${WORKDIR}/${PN}_build_${ABI}" - mv "${EMULTILIB_SOURCE}" "${WORKDIR}/${PN}_build_${ABI}" - fi - fi - fi - if ([[ -n "${CMAKE_BUILD_TYPE}" ]] && \ - [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]]) || \ - [[ -z "${CMAKE_BUILD_TYPE}" ]]; then - S="${CMAKE_BUILD_DIR}" - fi - -} - -# Internal function -# @FUNCTION: multilib-native_is_EBD -# @USAGE: -# @DESCRIPTION: Returns true if we're building with an "External Build Directory" -multilib-native_is_EBD() { -! ( [[ -n "${CMAKE_IN_SOURCE_BUILD}" ]] || \ - ( [[ -z "${CMAKE_BUILD_TYPE}" ]] && \ - [[ -z "${MULTILIB_EXT_SOURCE_BUILD}" ]] ) ) -} - -# Internal function -# @FUNCTION: multilib-native_setup_abi_env -# @USAGE: <ABI> -# @DESCRIPTION: Setup initial environment for ABI, flags, workarounds etc. -multilib-native_setup_abi_env() { - local pyver="" libsuffix="" - [[ -z $(multilib-native_abi_to_index_key ${1}) ]] && \ - die "Unknown ABI (${1})" - -# Set the CHOST native first so that we pick up the native #202811. - export CHOST=$(get_abi_CHOST ${DEFAULT_ABI}) - export AS="$(tc-getAS)" - export CC="$(tc-getCC)" - export CXX="$(tc-getCXX)" - export FC="$(tc-getFC)" - export LD="$(tc-getLD) $(get_abi_LDFLAGS)" - export ASFLAGS="${ASFLAGS} $(get_abi_ASFLAGS)" - export CFLAGS="${CFLAGS} $(get_abi_CFLAGS)" - export CXXFLAGS="${CXXFLAGS} $(get_abi_CFLAGS)" - export FCFLAGS="${FCFLAGS} ${CFLAGS}" - export FFLAGS="${FFLAGS} ${CFLAGS}" - export CHOST=$(get_abi_CHOST $1) - export CBUILD=$(get_abi_CHOST $1) - export CDEFINE="${CDEFINE} $(get_abi_CDEFINE $1)" - export LDFLAGS="${LDFLAGS} -L/$(get_abi_LIBDIR $1) -L/usr/$(get_abi_LIBDIR $1)" - - if [[ -z PKG_CONFIG_PATH ]]; then - export PKG_CONFIG_PATH="/usr/$(get_libdir)/pkgconfig" - else - PKG_CONFIG_PATH="${PKG_CONFIG_PATH/lib*\//$(get_libdir)/}:/usr/$(get_libdir)/pkgconfig" - fi - -# if ! [[ "${ABI}" == "${DEFAULT_ABI}" ]]; then -# built_with_use dev-lang/perl lib32 && [[ "$(readlink /usr/bin/perl)" == "/usr/bin/abi-wrapper" ]] || eerror multilib-native.eclass: please rebuild dev-lang/perl to avoid problems -# pyver=$(python --version 2>&1) -# pyver=${pyver/Python /python} -# pyver=${pyver%.*} -# built_with_use dev-lang/python lib32 && [[ "$(readlink /usr/bin/${pyver})" == "/usr/bin/abi-wrapper" ]] || eerror multilib-native.eclass: please rebuild dev-lang/python to avoid problems -# fi - -# ccache is ABI dependent - if [[ -z ${CCACHE_DIR} ]] ; then - CCACHE_DIR="/var/tmp/ccache-${1}" - else - CCACHE_DIR="${CCACHE_DIR}-${1}" - fi - - CMAKE_BUILD_DIR="${WORKDIR}/${PN}_build_${ABI}/${EMULTILIB_RELATIVE_BUILD_DIR/${EMULTILIB_SOURCE_DIRNAME}}" - - # Strip any trailing slash (fixes build failure with python.eclass) - CMAKE_BUILD_DIR="${CMAKE_BUILD_DIR%/}" - - EMULTILIB_INITIALISED[$(multilib-native_abi_to_index_key ${1})]=1 -} - -# Internal function -# @FUNCTION: multilib-native_abi_to_index_key -# @USAGE: <ABI> -# @RETURN: <index key> -# @DESCRIPTION: Return an array index key for a given ABI -multilib-native_abi_to_index_key() { -# Until we can count on bash version > 4, we can't use associative arrays. - local index=0 element="" - if [[ -z "${EMULTILIB_ARRAY_INDEX}" ]]; then - local abilist="" - abilist=$(get_install_abis) - EMULTILIB_ARRAY_INDEX=(INIT ${abilist}) - fi - for element in ${EMULTILIB_ARRAY_INDEX[@]}; do - [[ "${element}" == "${1}" ]] && echo "${index}" - let index++ - done -} - -# Internal function -# @FUNCTION: multilib-native_save_abi_env -# @USAGE: <ABI> -# @DESCRIPTION: Save environment for ABI -multilib-native_save_abi_env() { - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: Saving Environment:" "${1}" - local _var _array - for _var in ${EMULTILIB_SAVE_VARS}; do - _array="EMULTILIB_${_var}" - declare -p ${_var} &>/dev/null || continue - multilib_debug ${_array}[$(multilib-native_abi_to_index_key ${1})] "${!_var}" - eval "${_array}[$(multilib-native_abi_to_index_key ${1})]"=\"${!_var}\" - done -} - -# Internal function -# @FUNCTION: multilib-native_restore_abi_env -# @USAGE: <ABI> -# @DESCRIPTION: Restore environment for ABI -multilib-native_restore_abi_env() { - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: Restoring Environment:" "${1}" - local _var _array - for _var in ${EMULTILIB_SAVE_VARS}; do - _array="EMULTILIB_${_var}[$(multilib-native_abi_to_index_key ${1})]" - if ! (declare -p EMULTILIB_${_var} &>/dev/null) || \ - [[ -z ${!_array} ]]; then - if (declare -p ${_var} &>/dev/null); then - [[ -n ${MULTILIB_DEBUG} ]] && \ - einfo "MULTILIB_DEBUG: unsetting ${_var}" - unset ${_var} - fi - continue - fi - multilib_debug "${_var}" "${!_array}" - export ${_var}="${!_array}" - done -} - -# Internal function -# @FUNCTION multilib-native_check_inherited_funcs -# @USAGE: <phase> -# @DESCRIPTION: Checks all inherited eclasses for requested phase function -multilib-native_check_inherited_funcs() { -# Check all eclasses for given function, in order of inheritance. -# If none provides it, the var stays empty. If more have it, the last one wins. -# Ignore the ones we inherit ourselves, base doesn't matter, as we default on -# it. - local declared_func="" - if [[ -z ${EMULTILIB_INHERITED} ]]; then - if [[ -f "${T}"/eclass-debug.log ]]; then - EMULTILIB_INHERITED="$(grep EXPORT_FUNCTIONS "${T}"/eclass-debug.log | cut -d ' ' -f 4 | cut -d '_' -f 1)" - else - ewarn "You are using a package manager that does not provide "${T}"/eclass-debug.log." - ewarn "Join #gentoo-multilib-overlay on freenode to help finding another way for you." - ewarn "Falling back to old behaviour ..." - EMULTILIB_INHERITED="${INHERITED}" - fi - EMULTILIB_INHERITED="${EMULTILIB_INHERITED//base/}" - EMULTILIB_INHERITED="${EMULTILIB_INHERITED//multilib-native/}" - fi - - multilib_debug EMULTILIB_INHERITED ${EMULTILIB_INHERITED} - - for func in ${EMULTILIB_INHERITED}; do - if [[ -n $(declare -f ${func}_${1}) ]]; then - multilib_debug declared_func "${declared_func}" - declared_func="${func}_${1}" - fi - done - - if [[ "$declared_func" == "distutils_src_unpack" ]]; then - if ! has "${EAPI:-0}" 0 1; then - unset declared_func - fi - fi - -# Now if $declared_func is still empty, none of the inherited eclasses provides -# it, so default on base.eclass. Do nothing for "phase != src_*". - if [[ -z "${declared_func}" ]]; then - if [[ "${1/_*}" != "src" ]]; then - declared_func="return" - else - declared_func="base_${1}" - fi - fi - - if [[ -z ${SRC_URI} && ( "${declared_func}" == "base_src_prepare" || "${declared_func}" == "base_src_install" ) ]]; then - # those functions do not work if we do not have sources - declared_func="return" - fi - - einfo "Using ${declared_func} for ABI ${ABI} ..." - ${declared_func} -} - -# @FUNCTION: multilib-native_src_prepare_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom src_configure. -multilib-native_src_prepare_internal() { - multilib-native_check_inherited_funcs src_prepare -} - -# @FUNCTION: multilib-native_src_configure_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom src_configure. -multilib-native_src_configure_internal() { - multilib-native_check_inherited_funcs src_configure -} - -# @FUNCTION: multilib-native_src_compile_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom src_compile. -multilib-native_src_compile_internal() { - multilib-native_check_inherited_funcs src_compile -} - -# @FUNCTION: multilib-native_src_install_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom src_install -multilib-native_src_install_internal() { - multilib-native_check_inherited_funcs src_install -} - -# @FUNCTION: multilib-native_pkg_setup_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom pkg_setup -multilib-native_pkg_setup_internal() { - multilib-native_check_inherited_funcs pkg_setup -} - -# @FUNCTION: multilib-native_src_unpack_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom src_unpack -multilib-native_src_unpack_internal() { - multilib-native_check_inherited_funcs src_unpack -} - - -# @FUNCTION: multilib-native_pkg_preinst_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom pkg_preinst -multilib-native_pkg_preinst_internal() { - multilib-native_check_inherited_funcs pkg_preinst -} - - -# @FUNCTION: multilib-native_pkg_postinst_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom pkg_postinst -multilib-native_pkg_postinst_internal() { - multilib-native_check_inherited_funcs pkg_postinst -} - - -# @FUNCTION: multilib-native_pkg_postrm_internal -# @USAGE: -# @DESCRIPTION: Override this function if you want a custom pkg_postrm -multilib-native_pkg_postrm_internal() { - multilib-native_check_inherited_funcs pkg_postrm -} - -# @FUNCTION: is_crosscompile -# @USAGE: -# @DESCRIPTION: -# True if we are cross-compiling. -# This is identical to the version in -# toolchain.eclass, but inheriting that eclass from here breaks many packages -# so just define locally. -is_crosscompile() { - [[ ${CHOST} != ${CTARGET} ]] -} - -# @FUNCTION: _check_build_dir -# @USAGE: -# @DESCRIPTION: -# This function overrides the function of the same name -# in cmake-utils.eclass. We handle the build dir ourselves. -# Determine using IN or OUT source build -_check_build_dir() { - # @ECLASS-VARIABLE: CMAKE_USE_DIR - # @DESCRIPTION: - # Sets the directory where we are working with cmake. - # For example when application uses autotools and only one - # plugin needs to be done by cmake. By default it uses ${S}. - : ${CMAKE_USE_DIR:=${S}} - -# in/out source build - echo ">>> Working in BUILD_DIR: \"$CMAKE_BUILD_DIR\"" -} - -# @FUNCTION prep_ml_binaries -# @USAGE: -# @DESCRIPTION: Use wrapper to support non-default binaries -prep_ml_binaries() { - if [[ -n $EMULTILIB_PKG ]] ; then - for binary in "$@"; do - mv ${D}/${binary} ${D}/${binary}-${ABI} || \ - die "${D}/${binary} not found!" - echo mv ${D}/${binary} ${D}/${binary}-${ABI} - if is_final_abi; then - ln -s /usr/bin/abi-wrapper ${D}/${binary} || \ - die "could link abi-wrapper to ${D}/${binary}!" - echo ln -s /usr/bin/abi-wrapper ${D}/${binary} - fi - done - fi -} - -# @FUNCTION: prep_ml_includes -# @DESCRIPTION: -# Some includes (include/asm, glibc, etc) are ABI dependent. In this case, -# We can install them in different locations for each ABI and create a common -# header which includes the right one based on CDEFINE_${ABI}. If your -# package installs ABI-specific headers, just add 'prep_ml_includes' to the -# end of your src_install(). It takes a list of directories that include -# files are installed in (default is /usr/include if none are passed). -# -# Example: -# src_install() { -# ... -# prep_ml_includes /usr/qt/3/include -# } -prep_ml_includes() { - if [[ $(number_abis) -gt 1 ]] ; then - local dir - local dirs - local base - - if [[ $# -eq 0 ]] ; then - dirs=/usr/include - else - dirs="$@" - fi - - for dir in ${dirs} ; do - base=${T}/gentoo-multilib/${dir}/gentoo-multilib - mkdir -p "${base}" - [[ -d ${base}/${ABI} ]] && rm -rf "${base}/${ABI}" - mv "${D}/${dir}" "${base}/${ABI}" - done - - if is_final_abi; then - base=${T}/gentoo-multilib - - local files_differ= - local install_abis=$(get_install_abis) - local alternate_abis=${install_abis% *} - for dir in ${dirs}; do - pushd "${base}${dir}/gentoo-multilib/${ABI}" - for i in $(find . -type f); do - for diffabi in ${alternate_abis}; do - diff -q "${i}" ../${diffabi}/"${i}" >/dev/null || files_differ=1 - done - if [ -z "${files_differ}" ]; then - [ -d "${D}${dir}/${i%/*}" ] || mkdir -p "${D}${dir}/${i%/*}" - mv ${base}${dir}/gentoo-multilib/${ABI}/"${i}" "${D}${dir}/${i}" - einfo rm -rf ${base}${dir}/gentoo-multilib/*/"${i}" - rm -rf ${base}${dir}/gentoo-multilib/*/"${i}" - fi - files_differ= - done - popd - done - - - pushd "${base}" - find . | tar -c -T - -f - | tar -x --no-same-owner -f - -C "${D}" - popd - - # This 'set' stuff is required by mips profiles to properly pass - # CDEFINE's (which have spaces) to sub-functions - set -- - for dir in ${dirs} ; do - set -- "$@" "${dir}" - local abi - for abi in $(get_install_abis); do - set -- "$@" "$(get_abi_CDEFINE ${abi}):${dir}/gentoo-multilib/${abi}" - done - create_ml_includes "$@" - done - fi - fi -} |