linamh/eclass/multilib-native.eclass

# Copyright 1999-2008 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: $
#
# @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 osname mythreading myarch PRIV_LIB 
		SITE_LIB SITE_ARCH VENDOR_LIB VENDOR_ARCH ARCH_LIB"

# @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 [[ -f "${T}"/eclass-debug.log ]]; then
		EMULTILIB_INHERITED="$(grep ${1} "${T}"/eclass-debug.log | cut -d ' ' -f 4 | cut -d '_' -f 1)"
	else
		if [[ "$1" != pkg_postrm ]]; then 
			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 ..."
		fi
		EMULTILIB_INHERITED="${INHERITED}"
	fi

	EMULTILIB_INHERITED="${EMULTILIB_INHERITED//base/}"
	EMULTILIB_INHERITED="${EMULTILIB_INHERITED//multilib-native/}"

	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
			if [[ -a ${D}/${binary} ]]; then
				mv ${D}/${binary} ${D}/${binary}-${ABI} || \
					die "${D}/${binary} not found!"
				einfo "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}!"
					einfo "ln -s /usr/bin/abi-wrapper ${D}/${binary}"
				fi
			else
				ewarn "${D}/${binary} does not exist, please inform the people in #gentoo-multilib-overlay on freenode"
			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
}