add multilib eclass

git-svn-id: https://svn.disconnected-by-peer.at/svn/linamh/trunk/linamh@2305 6952d904-891a-0410-993b-d76249ca496b
This commit is contained in:
geos_one 2010-08-19 19:14:29 +00:00
parent 9fddeeae31
commit 8af0f56384
2 changed files with 943 additions and 0 deletions

View File

@ -0,0 +1,717 @@
# 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
}

View File

@ -0,0 +1,226 @@
# Copyright 1999-2009 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: lucianm Exp $
#
# Author:
# Lucian Muresan <lucianm AT users DOT sourceforge DOT net>
# based upon code from the vdr-plugin.eclass by
# Matthias Schwarzott <zzam@gentoo.org>
# Joerg Bornkessel <hd_brummy@gentoo.org>
# orion5x-kernel.eclass
#
inherit kernel-2
IUSE_ORION_NAS_DEVICES="linkstation_pro_duo linkstation_pro_live linkstation_mini kurobox_pro qnap_ts_109_209 qnap_ts_409 dlink_dns_323 hp_mv2120 ts_78xx_sbc wrt350_v2 terastation_pro_v2 netronix_nh233 maxtor_shared_storage_2"
DEPEND="${DEPEND}
sys-block/devio
dev-embedded/u-boot-tools"
PROVIDE="virtual/linux-sources"
MY_MACHINE_TYPE=""
nasdevice_count=0
for nasdevice in ${IUSE_ORION_NAS_DEVICES}; do
IUSE="${IUSE} orion_nas_devices_${nasdevice}"
done
orion5x-kernel_add_nasdevice() {
#: ${nasdevice_count:=0}
: $(( nasdevice_count++ ))
if [[ ${nasdevice_count} -eq 2 ]]; then
ewarn
ewarn "Only one machine type can be patched after building the zImage!"
ewarn "Please select just one of '${IUSE_ORION_NAS_DEVICES}'!"
die "Multiple machine types selected"
fi
local dev="${1}"
local desc="device ${dev}"
if [[ -n "${2}" ]]; then
desc="${2}"
fi
einfo "Will patch the zImage for ${desc}"
MY_MACHINE_TYPE="${MY_MACHINE_TYPE} ${dev}"
}
orion5x-kernel_patch_help() {
einfo ""
einfo ""
einfo ""
einfo "You may add your own patches like this:"
einfo ""
einfo " - Add the following variable to your /etc/make.conf:"
einfo " ORION5X_KERNEL_PATCHES_DIR=\"/path/to/my/patches\""
einfo ""
einfo " - Create the following subdirectories inside your local patch directory:"
einfo " ${PN}/${PV}"
einfo ""
einfo " - Place your patches ending on *.diff or *.patch in the created"
einfo " \"${PV}\" directory, together with a file called \"0_list\" in which you"
einfo " list them in the order you want them applied."
einfo ""
}
orion5x-kernel_pkg_setup() {
kernel-2_pkg_setup
local nasdevice
for nasdevice in ${IUSE_ORION_NAS_DEVICES}; do
if use orion_nas_devices_${nasdevice}; then
orion5x-kernel_add_nasdevice ${nasdevice}
fi
done
if [[ ${nasdevice_count} -eq 0 ]]; then
ewarn
ewarn "You did not select a machine type to be patched after building the zImage!"
ewarn "Please set 'ORION_NAS_DEVICES' to just one of '${IUSE_ORION_NAS_DEVICES}'!"
die "No Orion machine type selected"
fi
if [ -z "${ORION5X_KERNEL_PATCHES_DIR}" ] ; then
orion5x-kernel_patch_help
else
if ! [ -d "${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}" ] ; then
orion5x-kernel_patch_help
fi
fi
}
orion5x-kernel_apply_local_patches() {
cd ${S}
if test -d "${ORION5X_KERNEL_PATCHES_DIR}/${PN}"; then
echo
local PATCH_LIST=$(cat ${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/0_list)
einfo "Applying local patches found in"
einfo "${ORION5X_KERNEL_PATCHES_DIR}:"
# for LOCALPATCH in ${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/*.{diff,patch}; do
# test -f "${LOCALPATCH}" && epatch "${LOCALPATCH}"
# done
for LOCALPATCH in ${PATCH_LIST}; do
cd ${S}
test -f "${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/${LOCALPATCH}" && patch -p 1 < "${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/${LOCALPATCH}"
#test -f "${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/${LOCALPATCH}" && epatch "${ORION5X_KERNEL_PATCHES_DIR}/${PN}/${PV}/${LOCALPATCH}"
done
fi
}
orion5x-kernel_generate_mach-type_patch(){
echo "diff --git a/arch/arm/boot/Makefile b/arch/arm/boot/Makefile
index 25f1230..789190e 100644
--- a/arch/arm/boot/Makefile
+++ b/arch/arm/boot/Makefile
@@ -55,6 +55,10 @@ \$(obj)/compressed/vmlinux: \$(obj)/Image FORCE
\$(obj)/zImage: \$(obj)/compressed/vmlinux FORCE
\$(call if_changed,objcopy)
+ devio > foo 'wl 0xe3a01c05,4' 'wl 0xe38110e5,4'
+ cat foo \$(obj)/zImage > zImage.new
+ mv zImage.new \$(obj)/zImage
+ rm foo
@echo ' Kernel: \$@ is ready'
endif" > ${WORKDIR}/force_mach-type.patch
}
orion5x-kernel_src_unpack(){
kernel-2_src_unpack
orion5x-kernel_apply_local_patches
# create mach-type patch in the working dir, to modify it according to the
# set orion nas device
orion5x-kernel_generate_mach-type_patch
if use orion_nas_devices_linkstation_pro_live; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811031,4' # Linkstation Pro/Live
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811031,4:" ${WORKDIR}/force_mach-type.patch
fi
#if use orion_nas_devices_kurobox_pro; then
#nothing to replace for the Kurobox Pro
#fi
if use orion_nas_devices_qnap_ts_109_209; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe381101d,4' # QNAP TS-109/TS-209
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe381101d,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_qnap_ts_409; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811041,4' # QNAP TS-409
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811041,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_dlink_dns_323; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811006,4' # D-Link DNS-323
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811006,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_hp_mv2120; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe381109d,4' # HP Media Vault MV2120
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe381109d,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_ts_78xx_sbc; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811074,4' # Technologic Systems TS-78xx SBC
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811074,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_maxtor_shared_storage_2; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe38110e6,4' # Maxtor Shared Storage II (2.6.27)
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe38110e6,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_wrt350_v2; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811061,4' # Linksys WRT350N v2
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811061,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_linkstation_pro_duo; then
#devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811027,4' # Buffalo Linkstation Pro Duo (Is this right?)
sed -i -e "s:0xe3a01c05,4:0xe3a01c07,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811027,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_linkstation_mini; then
#devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811042,4' # Buffalo Linkstation Mini (Is this right?)
sed -i -e "s:0xe3a01c05,4:0xe3a01c07,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811042,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_terastation_pro_v2; then
#devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811030,4' # Buffalo TS Pro V2 (not yet supported in Vanilla 2.6.26 as of Aug. 10th, 2008)
sed -i -e "s:0xe3a01c05,4:0xe3a01c06,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811030,4:" ${WORKDIR}/force_mach-type.patch
fi
if use orion_nas_devices_netronix_nh233; then
#devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811065,4' # Netronix NH-233
sed -i -e "s:0xe3a01c05,4:0xe3a01c07,4:" ${WORKDIR}/force_mach-type.patch
sed -i -e "s:0xe38110e5,4:0xe3811065,4:" ${WORKDIR}/force_mach-type.patch
fi
# finally patch with the correct orion nas device
epatch ${WORKDIR}/force_mach-type.patch
}
orion5x-kernel_pkg_postinst(){
postinst_sources
}
EXPORT_FUNCTIONS pkg_setup src_unpack pkg_postinst