Add modified toolchain-binutils.eclass

11 files changed, 6105 insertions, 0 deletions

diff --git a/eclass/autotools.eclass b/eclass/autotools.eclass
new file mode 100644
index 0000000..d58bb80
--- /dev/null
+++ b/eclass/autotools.eclass
@@ -0,0 +1,369 @@
+# Copyright 1999-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/autotools.eclass,v 1.101 2010/08/21 19:39:52 vapier Exp $
+
+# @ECLASS: autotools.eclass
+# @MAINTAINER:
+# base-system@gentoo.org
+# @BLURB: Regenerates auto* build scripts
+# @DESCRIPTION:
+# This eclass is for safely handling autotooled software packages that need to
+# regenerate their build scripts.  All functions will abort in case of errors.
+#
+# NB:  If you add anything, please comment it!
+
+inherit eutils libtool
+
+# @ECLASS-VARIABLE: WANT_AUTOCONF
+# @DESCRIPTION:
+# The major version of autoconf your package needs
+: ${WANT_AUTOCONF:=latest}
+
+# @ECLASS-VARIABLE: WANT_AUTOMAKE
+# @DESCRIPTION:
+# The major version of automake your package needs
+: ${WANT_AUTOMAKE:=latest}
+
+# @ECLASS-VARIABLE: _LATEST_AUTOMAKE
+# @INTERNAL
+# @DESCRIPTION:
+# CONSTANT!
+# The latest major version/slot of automake available on each arch.
+# If a newer version is stable on any arch, and is NOT reflected in this list,
+# then circular dependencies may arise during emerge @system bootstraps.
+# Do NOT change this variable in your ebuilds!
+_LATEST_AUTOMAKE='1.11'
+
+_automake_atom="sys-devel/automake"
+_autoconf_atom="sys-devel/autoconf"
+if [[ -n ${WANT_AUTOMAKE} ]]; then
+	case ${WANT_AUTOMAKE} in
+		none)   _automake_atom="" ;; # some packages don't require automake at all
+		# if you change the "latest" version here, change also autotools_run_tool
+		# this MUST reflect the latest stable major version for each arch!
+		latest) _automake_atom="|| ( `printf '=sys-devel/automake-%s* ' ${_LATEST_AUTOMAKE}` )" ;;
+		*)      _automake_atom="=sys-devel/automake-${WANT_AUTOMAKE}*" ;;
+	esac
+	export WANT_AUTOMAKE
+fi
+
+if [[ -n ${WANT_AUTOCONF} ]] ; then
+	case ${WANT_AUTOCONF} in
+		none)       _autoconf_atom="" ;; # some packages don't require autoconf at all
+		2.1)        _autoconf_atom="=sys-devel/autoconf-${WANT_AUTOCONF}*" ;;
+		# if you change the “latest” version here, change also autotools_run_tool
+		latest|2.5) _autoconf_atom=">=sys-devel/autoconf-2.61" ;;
+		*)          _autoconf_atom="INCORRECT-WANT_AUTOCONF-SETTING-IN-EBUILD" ;;
+	esac
+	export WANT_AUTOCONF
+fi
+
+AUTOTOOLS_DEPEND="${_automake_atom} ${_autoconf_atom}"
+[[ ${CATEGORY}/${PN} != "sys-devel/libtool" ]] && AUTOTOOLS_DEPEND="${AUTOTOOLS_DEPEND} >=sys-devel/libtool-2.2.6b"
+RDEPEND=""
+
+# @ECLASS-VARIABLE: AUTOTOOLS_AUTO_DEPEND
+# @DESCRIPTION:
+# Set to 'no' to disable automatically adding to DEPEND.  This lets
+# ebuilds former conditional depends by using ${AUTOTOOLS_DEPEND} in
+# their own DEPEND string.
+: ${AUTOTOOLS_AUTO_DEPEND:=yes}
+if [[ ${AUTOTOOLS_AUTO_DEPEND} != "no" ]] ; then
+	DEPEND=${AUTOTOOLS_DEPEND}
+fi
+
+unset _automake_atom _autoconf_atom
+
+# @ECLASS-VARIABLE: AM_OPTS
+# @DEFAULT_UNSET
+# @DESCRIPTION:
+# Additional options to pass to automake during
+# eautoreconf call.
+
+# @ECLASS-VARIABLE: AT_NOELIBTOOLIZE
+# @DEFAULT_UNSET
+# @DESCRIPTION:
+# Don't run elibtoolize command if set to 'yes',
+# useful when elibtoolize needs to be ran with
+# particular options
+
+# XXX: M4DIR should be deprecated
+# @ECLASS-VARIABLE: AT_M4DIR
+# @DESCRIPTION:
+# Additional director(y|ies) aclocal should search
+: ${AT_M4DIR:=${M4DIR}}
+
+# @FUNCTION: eautoreconf
+# @DESCRIPTION:
+# This function mimes the behavior of autoreconf, but uses the different
+# eauto* functions to run the tools. It doesn't accept parameters, but
+# the directory with include files can be specified with AT_M4DIR variable.
+#
+# Should do a full autoreconf - normally what most people will be interested in.
+# Also should handle additional directories specified by AC_CONFIG_SUBDIRS.
+eautoreconf() {
+	local x auxdir g
+
+	if [[ -z ${AT_NO_RECURSIVE} ]]; then
+		# Take care of subdirs
+		for x in $(autotools_get_subdirs); do
+			if [[ -d ${x} ]] ; then
+				pushd "${x}" >/dev/null
+				AT_NOELIBTOOLIZE="yes" eautoreconf
+				popd >/dev/null
+			fi
+		done
+	fi
+
+	auxdir=$(autotools_get_auxdir)
+
+	einfo "Running eautoreconf in '${PWD}' ..."
+	[[ -n ${auxdir} ]] && mkdir -p ${auxdir}
+	eaclocal
+	[[ ${CHOST} == *-darwin* ]] && g=g
+	if ${LIBTOOLIZE:-${g}libtoolize} -n --install >& /dev/null ; then
+		_elibtoolize --copy --force --install
+	else
+		_elibtoolize --copy --force
+	fi
+	eautoconf
+	eautoheader
+	FROM_EAUTORECONF="yes" eautomake ${AM_OPTS}
+
+	[[ ${AT_NOELIBTOOLIZE} == "yes" ]] && return 0
+
+	# Call it here to prevent failures due to elibtoolize called _before_
+	# eautoreconf.  We set $S because elibtoolize runs on that #265319
+	S=${PWD} elibtoolize --force
+
+	return 0
+}
+
+# @FUNCTION: eaclocal
+# @DESCRIPTION:
+# These functions runs the autotools using autotools_run_tool with the
+# specified parametes. The name of the tool run is the same of the function
+# without e prefix.
+# They also force installing the support files for safety.
+# Respects AT_M4DIR for additional directories to search for macro's.
+# Always adds ${EPREFIX}/usr/share/aclocal to accommodate situations where
+# aclocal comes from another EPREFIX (for example cross-EPREFIX builds).
+eaclocal() {
+	local aclocal_opts
+
+	local amflags_file
+	for amflags_file in GNUmakefile.am Makefile.am GNUmakefile.in Makefile.in ; do
+		[[ -e ${amflags_file} ]] || continue
+		aclocal_opts=$(sed -n '/^ACLOCAL_AMFLAGS[[:space:]]*=/s:[^=]*=::p' ${amflags_file})
+		eval aclocal_opts=\"${aclocal_opts}\"
+		break
+	done
+
+	if [[ -n ${AT_M4DIR} ]] ; then
+		for x in ${AT_M4DIR} ; do
+			case "${x}" in
+			"-I")
+				# We handle it below
+				;;
+			*)
+				[[ ! -d ${x} ]] && ewarn "eaclocal: '${x}' does not exist"
+				aclocal_opts="${aclocal_opts} -I ${x}"
+				;;
+			esac
+		done
+	fi
+
+	# in some cases (cross-eprefix build), EPREFIX may not be included
+	# by aclocal by default, since it only knows about BPREFIX.
+	local eprefix_include=
+	[[ -d ${EPREFIX}/usr/share/aclocal ]] &&
+		eprefix_include="-I ${EPREFIX}/usr/share/aclocal"
+
+	[[ ! -f aclocal.m4 || -n $(grep -e 'generated.*by aclocal' aclocal.m4) ]] && \
+		autotools_run_tool aclocal "$@" ${aclocal_opts} ${eprefix_include}
+}
+
+# @FUNCTION: _elibtoolize
+# @DESCRIPTION:
+# Runs libtoolize.  Note the '_' prefix .. to not collide with elibtoolize() from
+# libtool.eclass.
+_elibtoolize() {
+	local opts g=
+
+	# Check if we should run libtoolize (AM_PROG_LIBTOOL is an older macro,
+	# check for both it and the current AC_PROG_LIBTOOL)
+	[[ -n $(autotools_check_macro AC_PROG_LIBTOOL AM_PROG_LIBTOOL LT_INIT) ]] || return 0
+
+	[[ -f GNUmakefile.am || -f Makefile.am ]] && opts="--automake"
+
+	[[ ${CHOST} == *-darwin* ]] && g=g
+	autotools_run_tool ${LIBTOOLIZE:-${g}libtoolize} "$@" ${opts}
+
+	# Need to rerun aclocal
+	eaclocal
+}
+
+# @FUNCTION: eautoheader
+# @DESCRIPTION:
+# Runs autoheader.
+eautoheader() {
+	# Check if we should run autoheader
+	[[ -n $(autotools_check_macro "AC_CONFIG_HEADERS") ]] || return 0
+	NO_FAIL=1 autotools_run_tool autoheader "$@"
+}
+
+# @FUNCTION: eautoconf
+# @DESCRIPTION:
+# Runs autoconf.
+eautoconf() {
+	if [[ ! -f configure.ac && ! -f configure.in ]] ; then
+		echo
+		eerror "No configure.{ac,in} present in '${PWD}'!"
+		echo
+		die "No configure.{ac,in} present!"
+	fi
+
+	autotools_run_tool autoconf "$@"
+}
+
+# @FUNCTION: eautomake
+# @DESCRIPTION:
+# Runs automake.
+eautomake() {
+	local extra_opts
+	local makefile_name
+
+	# Run automake if:
+	#  - a Makefile.am type file exists
+	#  - a Makefile.in type file exists and the configure
+	#    script is using the AM_INIT_AUTOMAKE directive
+	for makefile_name in {GNUmakefile,{M,m}akefile}.{am,in} "" ; do
+		[[ -f ${makefile_name} ]] && break
+	done
+	[[ -z ${makefile_name} ]] && return 0
+
+	if [[ ${makefile_name} == *.in ]] ; then
+		if ! grep -qs AM_INIT_AUTOMAKE configure.?? ; then
+			return 0
+		fi
+
+	elif [[ -z ${FROM_EAUTORECONF} && -f ${makefile_name%.am}.in ]]; then
+		local used_automake
+		local installed_automake
+
+		installed_automake=$(WANT_AUTOMAKE= automake --version | head -n 1 | \
+			sed -e 's:.*(GNU automake) ::')
+		used_automake=$(head -n 1 < ${makefile_name%.am}.in | \
+			sed -e 's:.*by automake \(.*\) from .*:\1:')
+
+		if [[ ${installed_automake} != ${used_automake} ]]; then
+			einfo "Automake used for the package (${used_automake}) differs from"
+			einfo "the installed version (${installed_automake})."
+			eautoreconf
+			return 0
+		fi
+	fi
+
+	[[ -f INSTALL && -f AUTHORS && -f ChangeLog && -f NEWS ]] \
+		|| extra_opts="${extra_opts} --foreign"
+
+	# --force-missing seems not to be recognized by some flavours of automake
+	autotools_run_tool automake --add-missing --copy ${extra_opts} "$@"
+}
+
+# @FUNCTION: eautopoint
+# @DESCRIPTION:
+# Runs autopoint (from the gettext package).
+eautopoint() {
+	autotools_run_tool autopoint "$@"
+}
+
+# Internal function to run an autotools' tool
+autotools_run_tool() {
+	if [[ ${EBUILD_PHASE} != "unpack" && ${EBUILD_PHASE} != "prepare" ]]; then
+		ewarn "QA Warning: running $1 in ${EBUILD_PHASE} phase"
+	fi
+
+	# We do the “latest” → version switch here because it solves
+	# possible order problems, see bug #270010 as an example.
+	# During bootstrap in prefix there might be no automake merged yet
+	# due to --nodeps, but still available somewhere in PATH.
+	# For example, ncurses needs local libtool on aix and hpux.
+	if [[ ${WANT_AUTOMAKE} == "latest" ]] &&
+		ROOT=/ has_version "sys-devel/automake"; then
+		local pv
+		for pv in ${_LATEST_AUTOMAKE} ; do
+			# has_version respects ROOT, but in this case, we don't want it to,
+			# thus "ROOT=/" prefix:
+			ROOT=/ has_version "=sys-devel/automake-${pv}*" && export WANT_AUTOMAKE="$pv"
+		done
+		[[ ${WANT_AUTOMAKE} == "latest" ]] && \
+			die "Cannot find the latest automake! Tried ${_LATEST_AUTOMAKE}"
+	fi
+	[[ ${WANT_AUTOCONF} == "latest" ]] && export WANT_AUTOCONF=2.5
+
+	local STDERR_TARGET="${T}/$1.out"
+	# most of the time, there will only be one run, but if there are
+	# more, make sure we get unique log filenames
+	if [[ -e ${STDERR_TARGET} ]] ; then
+		STDERR_TARGET="${T}/$1-$$.out"
+	fi
+
+	printf "***** $1 *****\n***** PWD: ${PWD}\n***** $*\n\n" > "${STDERR_TARGET}"
+
+	ebegin "Running $@"
+	"$@" >> "${STDERR_TARGET}" 2>&1
+	eend $?
+
+	if [[ $? != 0 && ${NO_FAIL} != 1 ]] ; then
+		echo
+		eerror "Failed Running $1 !"
+		eerror
+		eerror "Include in your bugreport the contents of:"
+		eerror
+		eerror "  ${STDERR_TARGET}"
+		echo
+		die "Failed Running $1 !"
+	fi
+}
+
+# Internal function to check for support
+autotools_check_macro() {
+	[[ -f configure.ac || -f configure.in ]] || return 0
+	local macro
+	for macro ; do
+		WANT_AUTOCONF="2.5" autoconf --trace="${macro}" 2>/dev/null
+	done
+	return 0
+}
+
+# Internal function to get additional subdirs to configure
+autotools_get_subdirs() {
+	local subdirs_scan_out
+
+	subdirs_scan_out=$(autotools_check_macro "AC_CONFIG_SUBDIRS")
+	[[ -n ${subdirs_scan_out} ]] || return 0
+
+	echo "${subdirs_scan_out}" | gawk \
+	'($0 !~ /^[[:space:]]*(#|dnl)/) {
+		if (match($0, /AC_CONFIG_SUBDIRS:(.*)$/, res))
+			print res[1]
+	}' | uniq
+
+	return 0
+}
+
+autotools_get_auxdir() {
+	local auxdir_scan_out
+
+	auxdir_scan_out=$(autotools_check_macro "AC_CONFIG_AUX_DIR")
+	[[ -n ${auxdir_scan_out} ]] || return 0
+
+	echo ${auxdir_scan_out} | gawk \
+	'($0 !~ /^[[:space:]]*(#|dnl)/) {
+		if (match($0, /AC_CONFIG_AUX_DIR:(.*)$/, res))
+			print res[1]
+	}' | uniq
+
+	return 0
+}
diff --git a/eclass/eutils.eclass b/eclass/eutils.eclass
new file mode 100644
index 0000000..a28c7e2
--- /dev/null
+++ b/eclass/eutils.eclass
@@ -0,0 +1,2008 @@
+# Copyright 1999-2009 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/eutils.eclass,v 1.355 2011/03/18 20:36:37 vapier Exp $
+
+# @ECLASS: eutils.eclass
+# @MAINTAINER:
+# base-system@gentoo.org
+# @BLURB: many extra (but common) functions that are used in ebuilds
+# @DESCRIPTION:
+# The eutils eclass contains a suite of functions that complement
+# the ones that ebuild.sh already contain.  The idea is that the functions
+# are not required in all ebuilds but enough utilize them to have a common
+# home rather than having multiple ebuilds implementing the same thing.
+#
+# Due to the nature of this eclass, some functions may have maintainers
+# different from the overall eclass!
+
+inherit multilib portability
+
+DESCRIPTION="Based on the ${ECLASS} eclass"
+
+if has "${EAPI:-0}" 0 1 2; then
+
+# @FUNCTION: epause
+# @USAGE: [seconds]
+# @DESCRIPTION:
+# Sleep for the specified number of seconds (default of 5 seconds).  Useful when
+# printing a message the user should probably be reading and often used in
+# conjunction with the ebeep function.  If the EPAUSE_IGNORE env var is set,
+# don't wait at all. Defined in EAPIs 0 1 and 2.
+epause() {
+	[[ -z ${EPAUSE_IGNORE} ]] && sleep ${1:-5}
+}
+
+# @FUNCTION: ebeep
+# @USAGE: [number of beeps]
+# @DESCRIPTION:
+# Issue the specified number of beeps (default of 5 beeps).  Useful when
+# printing a message the user should probably be reading and often used in
+# conjunction with the epause function.  If the EBEEP_IGNORE env var is set,
+# don't beep at all. Defined in EAPIs 0 1 and 2.
+ebeep() {
+	local n
+	if [[ -z ${EBEEP_IGNORE} ]] ; then
+		for ((n=1 ; n <= ${1:-5} ; n++)) ; do
+			echo -ne "\a"
+			sleep 0.1 &>/dev/null ; sleep 0,1 &>/dev/null
+			echo -ne "\a"
+			sleep 1
+		done
+	fi
+}
+
+else
+
+ebeep() {
+	ewarn "QA Notice: ebeep is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
+}
+
+epause() {
+	ewarn "QA Notice: epause is not defined in EAPI=${EAPI}, please file a bug at http://bugs.gentoo.org"
+}
+
+fi
+
+# @FUNCTION: eqawarn
+# @USAGE: [message]
+# @DESCRIPTION:
+# Proxy to einfo for package managers that don't provide eqawarn and use the PM
+# implementation if available.
+if ! declare -F eqawarn >/dev/null ; then
+	eqawarn() {
+		einfo "$@"
+	}
+fi
+
+# @FUNCTION: ecvs_clean
+# @USAGE: [list of dirs]
+# @DESCRIPTION:
+# Remove CVS directories recursiveley.  Useful when a source tarball contains
+# internal CVS directories.  Defaults to $PWD.
+ecvs_clean() {
+	[[ -z $* ]] && set -- .
+	find "$@" -type d -name 'CVS' -prune -print0 | xargs -0 rm -rf
+	find "$@" -type f -name '.cvs*' -print0 | xargs -0 rm -rf
+}
+
+# @FUNCTION: esvn_clean
+# @USAGE: [list of dirs]
+# @DESCRIPTION:
+# Remove .svn directories recursiveley.  Useful when a source tarball contains
+# internal Subversion directories.  Defaults to $PWD.
+esvn_clean() {
+	[[ -z $* ]] && set -- .
+	find "$@" -type d -name '.svn' -prune -print0 | xargs -0 rm -rf
+}
+
+# @FUNCTION: eshopts_push
+# @USAGE: [options to `set` or `shopt`]
+# @DESCRIPTION:
+# Often times code will want to enable a shell option to change code behavior.
+# Since changing shell options can easily break other pieces of code (which
+# assume the default state), eshopts_push is used to (1) push the current shell
+# options onto a stack and (2) pass the specified arguments to set.
+#
+# If the first argument is '-s' or '-u', we assume you want to call `shopt`
+# rather than `set` as there are some options only available via that.
+#
+# A common example is to disable shell globbing so that special meaning/care
+# may be used with variables/arguments to custom functions.  That would be:
+# @CODE
+#		eshopts_push -o noglob
+#		for x in ${foo} ; do
+#			if ...some check... ; then
+#				eshopts_pop
+#				return 0
+#			fi
+#		done
+#		eshopts_pop
+# @CODE
+eshopts_push() {
+	# have to assume __ESHOPTS_SAVE__ isn't screwed with
+	# as a `declare -a` here will reset its value
+	local i=${#__ESHOPTS_SAVE__[@]}
+	if [[ $1 == -[su] ]] ; then
+		__ESHOPTS_SAVE__[$i]=$(shopt -p)
+		[[ $# -eq 0 ]] && return 0
+		shopt "$@" || die "eshopts_push: bad options to shopt: $*"
+	else
+		__ESHOPTS_SAVE__[$i]=$-
+		[[ $# -eq 0 ]] && return 0
+		set "$@" || die "eshopts_push: bad options to set: $*"
+	fi
+}
+
+# @FUNCTION: eshopts_pop
+# @USAGE:
+# @DESCRIPTION:
+# Restore the shell options to the state saved with the corresponding
+# eshopts_push call.  See that function for more details.
+eshopts_pop() {
+	[[ $# -ne 0 ]] && die "eshopts_pop takes no arguments"
+	local i=$(( ${#__ESHOPTS_SAVE__[@]} - 1 ))
+	[[ ${i} -eq -1 ]] && die "eshopts_{push,pop}: unbalanced pair"
+	local s=${__ESHOPTS_SAVE__[$i]}
+	unset __ESHOPTS_SAVE__[$i]
+	if [[ ${s} == "shopt -"* ]] ; then
+		eval "${s}" || die "eshopts_pop: sanity: invalid shopt options: ${s}"
+	else
+		set +$-     || die "eshopts_pop: sanity: invalid shell settings: $-"
+		set -${s}   || die "eshopts_pop: sanity: unable to restore saved shell settings: ${s}"
+	fi
+}
+
+# @VARIABLE: EPATCH_SOURCE
+# @DESCRIPTION:
+# Default directory to search for patches.
+EPATCH_SOURCE="${WORKDIR}/patch"
+# @VARIABLE: EPATCH_SUFFIX
+# @DESCRIPTION:
+# Default extension for patches (do not prefix the period yourself).
+EPATCH_SUFFIX="patch.bz2"
+# @VARIABLE: EPATCH_OPTS
+# @DESCRIPTION:
+# Default options for patch:
+# @CODE
+#	-g0 - keep RCS, ClearCase, Perforce and SCCS happy #24571
+#	--no-backup-if-mismatch - do not leave .orig files behind
+#	-E - automatically remove empty files
+# @CODE
+EPATCH_OPTS="-g0 -E --no-backup-if-mismatch"
+# @VARIABLE: EPATCH_EXCLUDE
+# @DESCRIPTION:
+# List of patches not to apply.	 Note this is only file names,
+# and not the full path.  Globs accepted.
+EPATCH_EXCLUDE=""
+# @VARIABLE: EPATCH_SINGLE_MSG
+# @DESCRIPTION:
+# Change the printed message for a single patch.
+EPATCH_SINGLE_MSG=""
+# @VARIABLE: EPATCH_MULTI_MSG
+# @DESCRIPTION:
+# Change the printed message for multiple patches.
+EPATCH_MULTI_MSG="Applying various patches (bugfixes/updates) ..."
+# @VARIABLE: EPATCH_FORCE
+# @DESCRIPTION:
+# Only require patches to match EPATCH_SUFFIX rather than the extended
+# arch naming style.
+EPATCH_FORCE="no"
+
+# @FUNCTION: epatch
+# @USAGE: [patches] [dirs of patches]
+# @DESCRIPTION:
+# epatch is designed to greatly simplify the application of patches.  It can
+# process patch files directly, or directories of patches.  The patches may be
+# compressed (bzip/gzip/etc...) or plain text.  You generally need not specify
+# the -p option as epatch will automatically attempt -p0 to -p5 until things
+# apply successfully.
+#
+# If you do not specify any options, then epatch will default to the directory
+# specified by EPATCH_SOURCE.
+#
+# When processing directories, epatch will apply all patches that match:
+# @CODE
+#	if ${EPATCH_FORCE} != "yes"
+#		??_${ARCH}_foo.${EPATCH_SUFFIX}
+#	else
+#		*.${EPATCH_SUFFIX}
+# @CODE
+# The leading ?? are typically numbers used to force consistent patch ordering.
+# The arch field is used to apply patches only for the host architecture with
+# the special value of "all" means apply for everyone.  Note that using values
+# other than "all" is highly discouraged -- you should apply patches all the
+# time and let architecture details be detected at configure/compile time.
+#
+# If EPATCH_SUFFIX is empty, then no period before it is implied when searching
+# for patches to apply.
+#
+# Refer to the other EPATCH_xxx variables for more customization of behavior.
+epatch() {
+	_epatch_draw_line() {
+		# create a line of same length as input string
+		[[ -z $1 ]] && set "$(printf "%65s" '')"
+		echo "${1//?/=}"
+	}
+
+	unset P4CONFIG P4PORT P4USER # keep perforce at bay #56402
+
+	# Let the rest of the code process one user arg at a time --
+	# each arg may expand into multiple patches, and each arg may
+	# need to start off with the default global EPATCH_xxx values
+	if [[ $# -gt 1 ]] ; then
+		local m
+		for m in "$@" ; do
+			epatch "${m}"
+		done
+		return 0
+	fi
+
+	local SINGLE_PATCH="no"
+	# no args means process ${EPATCH_SOURCE}
+	[[ $# -eq 0 ]] && set -- "${EPATCH_SOURCE}"
+
+	if [[ -f $1 ]] ; then
+		SINGLE_PATCH="yes"
+		set -- "$1"
+		# Use the suffix from the single patch (localize it); the code
+		# below will find the suffix for us
+		local EPATCH_SUFFIX=$1
+
+	elif [[ -d $1 ]] ; then
+		# Some people like to make dirs of patches w/out suffixes (vim)
+		set -- "$1"/*${EPATCH_SUFFIX:+."${EPATCH_SUFFIX}"}
+
+	else
+		# sanity check ... if it isn't a dir or file, wtf man ?
+		[[ $# -ne 0 ]] && EPATCH_SOURCE=$1
+		echo
+		eerror "Cannot find \$EPATCH_SOURCE!  Value for \$EPATCH_SOURCE is:"
+		eerror
+		eerror "  ${EPATCH_SOURCE}"
+		eerror "  ( ${EPATCH_SOURCE##*/} )"
+		echo
+		die "Cannot find \$EPATCH_SOURCE!"
+	fi
+
+	local PIPE_CMD
+	case ${EPATCH_SUFFIX##*\.} in
+		xz)      PIPE_CMD="xz -dc"    ;;
+		lzma)    PIPE_CMD="lzma -dc"  ;;
+		bz2)     PIPE_CMD="bzip2 -dc" ;;
+		gz|Z|z)  PIPE_CMD="gzip -dc"  ;;
+		ZIP|zip) PIPE_CMD="unzip -p"  ;;
+		*)       ;;
+	esac
+
+	[[ ${SINGLE_PATCH} == "no" ]] && einfo "${EPATCH_MULTI_MSG}"
+
+	local x
+	for x in "$@" ; do
+		# If the patch dir given contains subdirs, or our EPATCH_SUFFIX
+		# didn't match anything, ignore continue on
+		[[ ! -f ${x} ]] && continue
+
+		local patchname=${x##*/}
+
+		# Apply single patches, or forced sets of patches, or
+		# patches with ARCH dependant names.
+		#	???_arch_foo.patch
+		# Else, skip this input altogether
+		local a=${patchname#*_} # strip the ???_
+		a=${a%%_*}              # strip the _foo.patch
+		if ! [[ ${SINGLE_PATCH} == "yes" || \
+				${EPATCH_FORCE} == "yes" || \
+				${a} == all     || \
+				${a} == ${ARCH} ]]
+		then
+			continue
+		fi
+
+		# Let people filter things dynamically
+		if [[ -n ${EPATCH_EXCLUDE} ]] ; then
+			# let people use globs in the exclude
+			eshopts_push -o noglob
+
+			local ex
+			for ex in ${EPATCH_EXCLUDE} ; do
+				if [[ ${patchname} == ${ex} ]] ; then
+					eshopts_pop
+					continue 2
+				fi
+			done
+
+			eshopts_pop
+		fi
+
+		if [[ ${SINGLE_PATCH} == "yes" ]] ; then
+			if [[ -n ${EPATCH_SINGLE_MSG} ]] ; then
+				einfo "${EPATCH_SINGLE_MSG}"
+			else
+				einfo "Applying ${patchname} ..."
+			fi
+		else
+			einfo "  ${patchname} ..."
+		fi
+
+		# most of the time, there will only be one run per unique name,
+		# but if there are more, make sure we get unique log filenames
+		local STDERR_TARGET="${T}/${patchname}.out"
+		if [[ -e ${STDERR_TARGET} ]] ; then
+			STDERR_TARGET="${T}/${patchname}-$$.out"
+		fi
+
+		printf "***** %s *****\n\n" "${patchname}" > "${STDERR_TARGET}"
+
+		# Decompress the patch if need be
+		local count=0
+		local PATCH_TARGET
+		if [[ -n ${PIPE_CMD} ]] ; then
+			PATCH_TARGET="${T}/$$.patch"
+			echo "PIPE_COMMAND:  ${PIPE_CMD} ${x} > ${PATCH_TARGET}" >> "${STDERR_TARGET}"
+
+			if ! (${PIPE_CMD} "${x}" > "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
+				echo
+				eerror "Could not extract patch!"
+				#die "Could not extract patch!"
+				count=5
+				break
+			fi
+		else
+			PATCH_TARGET=${x}
+		fi
+
+		# Check for absolute paths in patches.  If sandbox is disabled,
+		# people could (accidently) patch files in the root filesystem.
+		# Or trigger other unpleasantries #237667.  So disallow -p0 on
+		# such patches.
+		local abs_paths=$(egrep -n '^[-+]{3} /' "${PATCH_TARGET}" | awk '$2 != "/dev/null" { print }')
+		if [[ -n ${abs_paths} ]] ; then
+			count=1
+			printf "NOTE: skipping -p0 due to absolute paths in patch:\n%s\n" "${abs_paths}" >> "${STDERR_TARGET}"
+		fi
+		# Similar reason, but with relative paths.
+		local rel_paths=$(egrep -n '^[-+]{3} [^	]*[.][.]/' "${PATCH_TARGET}")
+		if [[ -n ${rel_paths} ]] ; then
+			eqawarn "QA Notice: Your patch uses relative paths '../'."
+			eqawarn " In the future this will cause a failure."
+			eqawarn "${rel_paths}"
+		fi
+
+		# Dynamically detect the correct -p# ... i'm lazy, so shoot me :/
+		while [[ ${count} -lt 5 ]] ; do
+			# Generate some useful debug info ...
+			(
+			_epatch_draw_line "***** ${patchname} *****"
+			echo
+			echo "PATCH COMMAND:  patch -p${count} ${EPATCH_OPTS} < '${PATCH_TARGET}'"
+			echo
+			_epatch_draw_line "***** ${patchname} *****"
+			) >> "${STDERR_TARGET}"
+
+			if (patch -p${count} ${EPATCH_OPTS} --dry-run -f < "${PATCH_TARGET}") >> "${STDERR_TARGET}" 2>&1 ; then
+				(
+				_epatch_draw_line "***** ${patchname} *****"
+				echo
+				echo "ACTUALLY APPLYING ${patchname} ..."
+				echo
+				_epatch_draw_line "***** ${patchname} *****"
+				patch -p${count} ${EPATCH_OPTS} < "${PATCH_TARGET}" 2>&1
+				) >> "${STDERR_TARGET}"
+
+				if [ $? -ne 0 ] ; then
+					echo
+					eerror "A dry-run of patch command succeeded, but actually"
+					eerror "applying the patch failed!"
+					#die "Real world sux compared to the dreamworld!"
+					count=5
+				fi
+				break
+			fi
+
+			: $(( count++ ))
+		done
+
+		# if we had to decompress the patch, delete the temp one
+		if [[ -n ${PIPE_CMD} ]] ; then
+			rm -f "${PATCH_TARGET}"
+		fi
+
+		if [[ ${count} -ge 5 ]] ; then
+			echo
+			eerror "Failed Patch: ${patchname} !"
+			eerror " ( ${PATCH_TARGET} )"
+			eerror
+			eerror "Include in your bugreport the contents of:"
+			eerror
+			eerror "  ${STDERR_TARGET}"
+			echo
+			die "Failed Patch: ${patchname}!"
+		fi
+
+		# if everything worked, delete the patch log
+		rm -f "${STDERR_TARGET}"
+		eend 0
+	done
+
+	[[ ${SINGLE_PATCH} == "no" ]] && einfo "Done with patching"
+	: # everything worked
+}
+epatch_user() {
+	[[ $# -ne 0 ]] && die "epatch_user takes no options"
+
+	# don't clobber any EPATCH vars that the parent might want
+	local EPATCH_SOURCE check base=${PORTAGE_CONFIGROOT%/}/etc/portage/patches
+	for check in {${CATEGORY}/${PF},${CATEGORY}/${P},${CATEGORY}/${PN}}; do
+		EPATCH_SOURCE=${base}/${CTARGET}/${check}
+		[[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${CHOST}/${check}
+		[[ -r ${EPATCH_SOURCE} ]] || EPATCH_SOURCE=${base}/${check}
+		if [[ -d ${EPATCH_SOURCE} ]] ; then
+			EPATCH_SOURCE=${EPATCH_SOURCE} \
+			EPATCH_SUFFIX="patch" \
+			EPATCH_FORCE="yes" \
+			EPATCH_MULTI_MSG="Applying user patches from ${EPATCH_SOURCE} ..." \
+			epatch
+			return 0
+		fi
+	done
+	return 1
+}
+
+# @FUNCTION: emktemp
+# @USAGE: [temp dir]
+# @DESCRIPTION:
+# Cheap replacement for when debianutils (and thus mktemp)
+# does not exist on the users system.
+emktemp() {
+	local exe="touch"
+	[[ $1 == -d ]] && exe="mkdir" && shift
+	local topdir=$1
+
+	if [[ -z ${topdir} ]] ; then
+		[[ -z ${T} ]] \
+			&& topdir="/tmp" \
+			|| topdir=${T}
+	fi
+
+	if ! type -P mktemp > /dev/null ; then
+		# system lacks `mktemp` so we have to fake it
+		local tmp=/
+		while [[ -e ${tmp} ]] ; do
+			tmp=${topdir}/tmp.${RANDOM}.${RANDOM}.${RANDOM}
+		done
+		${exe} "${tmp}" || ${exe} -p "${tmp}"
+		echo "${tmp}"
+	else
+		# the args here will give slightly wierd names on BSD,
+		# but should produce a usable file on all userlands
+		if [[ ${exe} == "touch" ]] ; then
+			TMPDIR="${topdir}" mktemp -t tmp.XXXXXXXXXX
+		else
+			TMPDIR="${topdir}" mktemp -dt tmp.XXXXXXXXXX
+		fi
+	fi
+}
+
+# @FUNCTION: egetent
+# @USAGE: <database> <key>
+# @MAINTAINER:
+# base-system@gentoo.org (Linux)
+# Joe Jezak <josejx@gmail.com> (OS X)
+# usata@gentoo.org (OS X)
+# Aaron Walker <ka0ttic@gentoo.org> (FreeBSD)
+# @DESCRIPTION:
+# Small wrapper for getent (Linux),
+# nidump (< Mac OS X 10.5), dscl (Mac OS X 10.5),
+# and pw (FreeBSD) used in enewuser()/enewgroup()
+egetent() {
+	case ${CHOST} in
+	*-darwin[678])
+		case "$2" in
+		*[!0-9]*) # Non numeric
+			nidump $1 . | awk -F":" "{ if (\$1 ~ /^$2$/) {print \$0;exit;} }"
+			;;
+		*)	# Numeric
+			nidump $1 . | awk -F":" "{ if (\$3 == $2) {print \$0;exit;} }"
+			;;
+		esac
+		;;
+	*-darwin*)
+		local mytype=$1
+		[[ "passwd" == $mytype ]] && mytype="Users"
+		[[ "group" == $mytype ]] && mytype="Groups"
+		case "$2" in
+		*[!0-9]*) # Non numeric
+			dscl . -read /$mytype/$2 2>/dev/null |grep RecordName
+			;;
+		*)	# Numeric
+			local mykey="UniqueID"
+			[[ $mytype == "Groups" ]] && mykey="PrimaryGroupID"
+			dscl . -search /$mytype $mykey $2 2>/dev/null
+			;;
+		esac
+		;;
+	*-freebsd*|*-dragonfly*)
+		local opts action="user"
+		[[ $1 == "passwd" ]] || action="group"
+
+		# lookup by uid/gid
+		if [[ $2 == [[:digit:]]* ]] ; then
+			[[ ${action} == "user" ]] && opts="-u" || opts="-g"
+		fi
+
+		pw show ${action} ${opts} "$2" -q
+		;;
+	*-netbsd*|*-openbsd*)
+		grep "$2:\*:" /etc/$1
+		;;
+	*)
+		type -p nscd >& /dev/null && nscd -i "$1"
+		getent "$1" "$2"
+		;;
+	esac
+}
+
+# @FUNCTION: enewuser
+# @USAGE: <user> [uid] [shell] [homedir] [groups] [params]
+# @DESCRIPTION:
+# Same as enewgroup, you are not required to understand how to properly add
+# a user to the system.  The only required parameter is the username.
+# Default uid is (pass -1 for this) next available, default shell is
+# /bin/false, default homedir is /dev/null, there are no default groups,
+# and default params sets the comment as 'added by portage for ${PN}'.
+enewuser() {
+	# in Prefix Portage, we may be unprivileged, such that we can't handle this
+	rootuid=$(python -c 'from portage.const import rootuid; print rootuid')
+	if [[ ${rootuid} != 0 ]] ; then
+		ewarn "'enewuser()' disabled in Prefixed Portage with non root user"
+		return 0
+	fi
+
+	case ${EBUILD_PHASE} in
+		unpack|compile|test|install)
+		eerror "'enewuser()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
+		eerror "Package fails at QA and at life.  Please file a bug."
+		die "Bad package!  enewuser is only for use in pkg_* functions!"
+	esac
+
+	# get the username
+	local euser=$1; shift
+	if [[ -z ${euser} ]] ; then
+		eerror "No username specified !"
+		die "Cannot call enewuser without a username"
+	fi
+
+	# lets see if the username already exists
+	if [[ -n $(egetent passwd "${euser}") ]] ; then
+		return 0
+	fi
+	einfo "Adding user '${euser}' to your system ..."
+
+	# options to pass to useradd
+	local opts=
+
+	# handle uid
+	local euid=$1; shift
+	if [[ -n ${euid} && ${euid} != -1 ]] ; then
+		if [[ ${euid} -gt 0 ]] ; then
+			if [[ -n $(egetent passwd ${euid}) ]] ; then
+				euid="next"
+			fi
+		else
+			eerror "Userid given but is not greater than 0 !"
+			die "${euid} is not a valid UID"
+		fi
+	else
+		euid="next"
+	fi
+	if [[ ${euid} == "next" ]] ; then
+		for ((euid = 101; euid <= 999; euid++)); do
+			[[ -z $(egetent passwd ${euid}) ]] && break
+		done
+	fi
+	opts="${opts} -u ${euid}"
+	einfo " - Userid: ${euid}"
+
+	# handle shell
+	local eshell=$1; shift
+	if [[ ! -z ${eshell} ]] && [[ ${eshell} != "-1" ]] ; then
+		if [[ ! -e ${EROOT}${eshell} ]] ; then
+			eerror "A shell was specified but it does not exist !"
+			die "${eshell} does not exist in ${EROOT}"
+		fi
+		if [[ ${eshell} == */false || ${eshell} == */nologin ]] ; then
+			eerror "Do not specify ${eshell} yourself, use -1"
+			die "Pass '-1' as the shell parameter"
+		fi
+	else
+		for shell in /sbin/nologin /usr/sbin/nologin /bin/false /usr/bin/false /dev/null ; do
+			[[ -x ${ROOT}${shell} ]] && break
+		done
+
+		if [[ ${shell} == "/dev/null" ]] ; then
+			eerror "Unable to identify the shell to use, proceeding with userland default."
+			case ${USERLAND} in
+				GNU) shell="/bin/false" ;;
+				BSD) shell="/sbin/nologin" ;;
+				Darwin) shell="/usr/sbin/nologin" ;;
+				*) die "Unable to identify the default shell for userland ${USERLAND}"
+			esac
+		fi
+
+		eshell=${shell}
+	fi
+	einfo " - Shell: ${eshell}"
+	opts="${opts} -s ${eshell}"
+
+	# handle homedir
+	local ehome=$1; shift
+	if [[ -z ${ehome} ]] || [[ ${ehome} == "-1" ]] ; then
+		ehome="/dev/null"
+	fi
+	einfo " - Home: ${ehome}"
+	opts="${opts} -d ${ehome}"
+
+	# handle groups
+	local egroups=$1; shift
+	if [[ ! -z ${egroups} ]] ; then
+		local oldifs=${IFS}
+		local defgroup="" exgroups=""
+
+		export IFS=","
+		for g in ${egroups} ; do
+			export IFS=${oldifs}
+			if [[ -z $(egetent group "${g}") ]] ; then
+				eerror "You must add group ${g} to the system first"
+				die "${g} is not a valid GID"
+			fi
+			if [[ -z ${defgroup} ]] ; then
+				defgroup=${g}
+			else
+				exgroups="${exgroups},${g}"
+			fi
+			export IFS=","
+		done
+		export IFS=${oldifs}
+
+		opts="${opts} -g ${defgroup}"
+		if [[ ! -z ${exgroups} ]] ; then
+			opts="${opts} -G ${exgroups:1}"
+		fi
+	else
+		egroups="(none)"
+	fi
+	einfo " - Groups: ${egroups}"
+
+	# handle extra and add the user
+	local oldsandbox=${SANDBOX_ON}
+	export SANDBOX_ON="0"
+	case ${CHOST} in
+	*-darwin*)
+		### Make the user
+		if [[ -z $@ ]] ; then
+			dscl . create /users/${euser} uid ${euid}
+			dscl . create /users/${euser} shell ${eshell}
+			dscl . create /users/${euser} home ${ehome}
+			dscl . create /users/${euser} realname "added by portage for ${PN}"
+			### Add the user to the groups specified
+			local oldifs=${IFS}
+			export IFS=","
+			for g in ${egroups} ; do
+				dscl . merge /groups/${g} users ${euser}
+			done
+			export IFS=${oldifs}
+		else
+			einfo "Extra options are not supported on Darwin yet"
+			einfo "Please report the ebuild along with the info below"
+			einfo "eextra: $@"
+			die "Required function missing"
+		fi
+		;;
+	*-freebsd*|*-dragonfly*)
+		if [[ -z $@ ]] ; then
+			pw useradd ${euser} ${opts} \
+				-c "added by portage for ${PN}" \
+				die "enewuser failed"
+		else
+			einfo " - Extra: $@"
+			pw useradd ${euser} ${opts} \
+				"$@" || die "enewuser failed"
+		fi
+		;;
+
+	*-netbsd*)
+		if [[ -z $@ ]] ; then
+			useradd ${opts} ${euser} || die "enewuser failed"
+		else
+			einfo " - Extra: $@"
+			useradd ${opts} ${euser} "$@" || die "enewuser failed"
+		fi
+		;;
+
+	*-openbsd*)
+		if [[ -z $@ ]] ; then
+			useradd -u ${euid} -s ${eshell} \
+				-d ${ehome} -c "Added by portage for ${PN}" \
+				-g ${egroups} ${euser} || die "enewuser failed"
+		else
+			einfo " - Extra: $@"
+			useradd -u ${euid} -s ${eshell} \
+				-d ${ehome} -c "Added by portage for ${PN}" \
+				-g ${egroups} ${euser} "$@" || die "enewuser failed"
+		fi
+		;;
+
+	*)
+		if [[ -z $@ ]] ; then
+			useradd -r ${opts} \
+				-c "added by portage for ${PN}" \
+				${euser} \
+				|| die "enewuser failed"
+		else
+			einfo " - Extra: $@"
+			useradd -r ${opts} "$@" \
+				${euser} \
+				|| die "enewuser failed"
+		fi
+		;;
+	esac
+
+	if [[ ! -e ${EROOT}/${ehome} ]] ; then
+		einfo " - Creating ${ehome} in ${EROOT}"
+		mkdir -p "${EROOT}/${ehome}"
+		chown ${euser} "${EROOT}/${ehome}"
+		chmod 755 "${EROOT}/${ehome}"
+	fi
+
+	export SANDBOX_ON=${oldsandbox}
+}
+
+# @FUNCTION: enewgroup
+# @USAGE: <group> [gid]
+# @DESCRIPTION:
+# This function does not require you to understand how to properly add a
+# group to the system.  Just give it a group name to add and enewgroup will
+# do the rest.  You may specify the gid for the group or allow the group to
+# allocate the next available one.
+enewgroup() {
+	# in Prefix Portage, we may be unprivileged, such that we can't handle this
+	rootuid=$(python -c 'from portage.const import rootuid; print rootuid')
+	if [[ ${rootuid} != 0 ]] ; then
+		ewarn "'enewgroup()' disabled in Prefixed Portage with non root user"
+		return 0
+	fi
+
+	case ${EBUILD_PHASE} in
+		unpack|compile|test|install)
+		eerror "'enewgroup()' called from '${EBUILD_PHASE}()' which is not a pkg_* function."
+		eerror "Package fails at QA and at life.  Please file a bug."
+		die "Bad package!  enewgroup is only for use in pkg_* functions!"
+	esac
+
+	# get the group
+	local egroup="$1"; shift
+	if [ -z "${egroup}" ]
+	then
+		eerror "No group specified !"
+		die "Cannot call enewgroup without a group"
+	fi
+
+	# see if group already exists
+	if [[ -n $(egetent group "${egroup}") ]]; then
+		return 0
+	fi
+	einfo "Adding group '${egroup}' to your system ..."
+
+	# options to pass to useradd
+	local opts=
+
+	# handle gid
+	local egid="$1"; shift
+	if [ ! -z "${egid}" ]
+	then
+		if [ "${egid}" -gt 0 ]
+		then
+			if [ -z "`egetent group ${egid}`" ]
+			then
+				if [[ "${CHOST}" == *-darwin* ]]; then
+					opts="${opts} ${egid}"
+				else
+					opts="${opts} -g ${egid}"
+				fi
+			else
+				egid="next available; requested gid taken"
+			fi
+		else
+			eerror "Groupid given but is not greater than 0 !"
+			die "${egid} is not a valid GID"
+		fi
+	else
+		egid="next available"
+	fi
+	einfo " - Groupid: ${egid}"
+
+	# handle extra
+	local eextra="$@"
+	opts="${opts} ${eextra}"
+
+	# add the group
+	local oldsandbox="${SANDBOX_ON}"
+	export SANDBOX_ON="0"
+	case ${CHOST} in
+	*-darwin*)
+		if [ ! -z "${eextra}" ];
+		then
+			einfo "Extra options are not supported on Darwin/OS X yet"
+			einfo "Please report the ebuild along with the info below"
+			einfo "eextra: ${eextra}"
+			die "Required function missing"
+		fi
+
+		# If we need the next available
+		case ${egid} in
+		*[!0-9]*) # Non numeric
+			for ((egid = 101; egid <= 999; egid++)); do
+				[[ -z $(egetent group ${egid}) ]] && break
+			done
+		esac
+		dscl . create /groups/${egroup} gid ${egid}
+		dscl . create /groups/${egroup} passwd '*'
+		;;
+
+	*-freebsd*|*-dragonfly*)
+		case ${egid} in
+			*[!0-9]*) # Non numeric
+				for ((egid = 101; egid <= 999; egid++)); do
+					[[ -z $(egetent group ${egid}) ]] && break
+				done
+		esac
+		pw groupadd ${egroup} -g ${egid} || die "enewgroup failed"
+		;;
+
+	*-netbsd*)
+		case ${egid} in
+		*[!0-9]*) # Non numeric
+			for ((egid = 101; egid <= 999; egid++)); do
+				[[ -z $(egetent group ${egid}) ]] && break
+			done
+		esac
+		groupadd -g ${egid} ${egroup} || die "enewgroup failed"
+		;;
+
+	*)
+		# We specify -r so that we get a GID in the system range from login.defs
+		groupadd -r ${opts} ${egroup} || die "enewgroup failed"
+		;;
+	esac
+	export SANDBOX_ON="${oldsandbox}"
+}
+
+# @FUNCTION: edos2unix
+# @USAGE: <file> [more files ...]
+# @DESCRIPTION:
+# A handy replacement for dos2unix, recode, fixdos, etc...  This allows you
+# to remove all of these text utilities from DEPEND variables because this
+# is a script based solution.  Just give it a list of files to convert and
+# they will all be changed from the DOS CRLF format to the UNIX LF format.
+edos2unix() {
+	echo "$@" | xargs sed -i 's/\r$//'
+}
+
+# Make a desktop file !
+# Great for making those icons in kde/gnome startmenu !
+# Amaze your friends !	Get the women !	 Join today !
+#
+# make_desktop_entry(<command>, [name], [icon], [type], [fields])
+#
+# binary:	what command does the app run with ?
+# name:		the name that will show up in the menu
+# icon:		give your little like a pretty little icon ...
+#			this can be relative (to /usr/share/pixmaps) or
+#			a full path to an icon
+# type:		what kind of application is this ?	for categories:
+#			http://standards.freedesktop.org/menu-spec/latest/apa.html
+# fields:	extra fields to append to the desktop file; a printf string
+make_desktop_entry() {
+	[[ -z $1 ]] && die "make_desktop_entry: You must specify the executable"
+
+	local exec=${1}
+	local name=${2:-${PN}}
+	local icon=${3:-${PN}}
+	local type=${4}
+	local fields=${5}
+
+	if [[ -z ${type} ]] ; then
+		local catmaj=${CATEGORY%%-*}
+		local catmin=${CATEGORY##*-}
+		case ${catmaj} in
+			app)
+				case ${catmin} in
+					accessibility) type=Accessibility;;
+					admin)         type=System;;
+					antivirus)     type=System;;
+					arch)          type=Archiving;;
+					backup)        type=Archiving;;
+					cdr)           type=DiscBurning;;
+					dicts)         type=Dictionary;;
+					doc)           type=Documentation;;
+					editors)       type=TextEditor;;
+					emacs)         type=TextEditor;;
+					emulation)     type=Emulator;;
+					laptop)        type=HardwareSettings;;
+					office)        type=Office;;
+					pda)           type=PDA;;
+					vim)           type=TextEditor;;
+					xemacs)        type=TextEditor;;
+				esac
+				;;
+
+			dev)
+				type="Development"
+				;;
+
+			games)
+				case ${catmin} in
+					action|fps) type=ActionGame;;
+					arcade)     type=ArcadeGame;;
+					board)      type=BoardGame;;
+					emulation)  type=Emulator;;
+					kids)       type=KidsGame;;
+					puzzle)     type=LogicGame;;
+					roguelike)  type=RolePlaying;;
+					rpg)        type=RolePlaying;;
+					simulation) type=Simulation;;
+					sports)     type=SportsGame;;
+					strategy)   type=StrategyGame;;
+				esac
+				type="Game;${type}"
+				;;
+
+			gnome)
+				type="Gnome;GTK"
+				;;
+
+			kde)
+				type="KDE;Qt"
+				;;
+
+			mail)
+				type="Network;Email"
+				;;
+
+			media)
+				case ${catmin} in
+					gfx)
+						type=Graphics
+						;;
+					*)
+						case ${catmin} in
+							radio) type=Tuner;;
+							sound) type=Audio;;
+							tv)    type=TV;;
+							video) type=Video;;
+						esac
+						type="AudioVideo;${type}"
+						;;
+				esac
+				;;
+
+			net)
+				case ${catmin} in
+					dialup) type=Dialup;;
+					ftp)    type=FileTransfer;;
+					im)     type=InstantMessaging;;
+					irc)    type=IRCClient;;
+					mail)   type=Email;;
+					news)   type=News;;
+					nntp)   type=News;;
+					p2p)    type=FileTransfer;;
+					voip)   type=Telephony;;
+				esac
+				type="Network;${type}"
+				;;
+
+			sci)
+				case ${catmin} in
+					astro*)  type=Astronomy;;
+					bio*)    type=Biology;;
+					calc*)   type=Calculator;;
+					chem*)   type=Chemistry;;
+					elec*)   type=Electronics;;
+					geo*)    type=Geology;;
+					math*)   type=Math;;
+					physics) type=Physics;;
+					visual*) type=DataVisualization;;
+				esac
+				type="Education;Science;${type}"
+				;;
+
+			sys)
+				type="System"
+				;;
+
+			www)
+				case ${catmin} in
+					client) type=WebBrowser;;
+				esac
+				type="Network;${type}"
+				;;
+
+			*)
+				type=
+				;;
+		esac
+	fi
+	if [ "${SLOT}" == "0" ] ; then
+		local desktop_name="${PN}"
+	else
+		local desktop_name="${PN}-${SLOT}"
+	fi
+	local desktop="${T}/$(echo ${exec} | sed 's:[[:space:]/:]:_:g')-${desktop_name}.desktop"
+	#local desktop=${T}/${exec%% *:-${desktop_name}}.desktop
+
+	# Don't append another ";" when a valid category value is provided.
+	type=${type%;}${type:+;}
+
+	eshopts_push -s extglob
+	if [[ -n ${icon} && ${icon} != /* ]] && [[ ${icon} == *.xpm || ${icon} == *.png || ${icon} == *.svg ]]; then
+		ewarn "As described in the Icon Theme Specification, icon file extensions are not"
+		ewarn "allowed in .desktop files if the value is not an absolute path."
+		icon=${icon%.@(xpm|png|svg)}
+	fi
+	eshopts_pop
+
+	cat <<-EOF > "${desktop}"
+	[Desktop Entry]
+	Name=${name}
+	Type=Application
+	Comment=${DESCRIPTION}
+	Exec=${exec}
+	TryExec=${exec%% *}
+	Icon=${icon}
+	Categories=${type}
+	EOF
+
+	if [[ ${fields:-=} != *=* ]] ; then
+		# 5th arg used to be value to Path=
+		ewarn "make_desktop_entry: update your 5th arg to read Path=${fields}"
+		fields="Path=${fields}"
+	fi
+	[[ -n ${fields} ]] && printf '%b\n' "${fields}" >> "${desktop}"
+
+	(
+		# wrap the env here so that the 'insinto' call
+		# doesn't corrupt the env of the caller
+		insinto /usr/share/applications
+		doins "${desktop}"
+	) || die "installing desktop file failed"
+}
+
+# @FUNCTION: validate_desktop_entries
+# @USAGE: [directories]
+# @MAINTAINER:
+# Carsten Lohrke <carlo@gentoo.org>
+# @DESCRIPTION:
+# Validate desktop entries using desktop-file-utils
+validate_desktop_entries() {
+	if [[ -x "${EPREFIX}"/usr/bin/desktop-file-validate ]] ; then
+		einfo "Checking desktop entry validity"
+		local directories=""
+		for d in /usr/share/applications $@ ; do
+			[[ -d ${ED}${d} ]] && directories="${directories} ${ED}${d}"
+		done
+		if [[ -n ${directories} ]] ; then
+			for FILE in $(find ${directories} -name "*\.desktop" \
+							-not -path '*.hidden*' | sort -u 2>/dev/null)
+			do
+				local temp=$(desktop-file-validate ${FILE} | grep -v "warning:" | \
+								sed -e "s|error: ||" -e "s|${FILE}:|--|g" )
+				[[ -n $temp ]] && elog ${temp/--/${FILE/${ED}/}:}
+			done
+		fi
+		echo ""
+	else
+		einfo "Passing desktop entry validity check. Install dev-util/desktop-file-utils, if you want to help to improve Gentoo."
+	fi
+}
+
+# @FUNCTION: make_session_desktop
+# @USAGE: <title> <command> [command args...]
+# @DESCRIPTION:
+# Make a GDM/KDM Session file.  The title is the file to execute to start the
+# Window Manager.  The command is the name of the Window Manager.
+#
+# You can set the name of the file via the ${wm} variable.
+make_session_desktop() {
+	[[ -z $1 ]] && eerror "$0: You must specify the title" && return 1
+	[[ -z $2 ]] && eerror "$0: You must specify the command" && return 1
+
+	local title=$1
+	local command=$2
+	local desktop=${T}/${wm:-${PN}}.desktop
+	shift 2
+
+	cat <<-EOF > "${desktop}"
+	[Desktop Entry]
+	Name=${title}
+	Comment=This session logs you into ${title}
+	Exec=${command} $*
+	TryExec=${command}
+	Type=XSession
+	EOF
+
+	(
+	# wrap the env here so that the 'insinto' call
+	# doesn't corrupt the env of the caller
+	insinto /usr/share/xsessions
+	doins "${desktop}"
+	)
+}
+
+# @FUNCTION: domenu
+# @USAGE: <menus>
+# @DESCRIPTION:
+# Install the list of .desktop menu files into the appropriate directory
+# (/usr/share/applications).
+domenu() {
+	(
+	# wrap the env here so that the 'insinto' call
+	# doesn't corrupt the env of the caller
+	local i j ret=0
+	insinto /usr/share/applications
+	for i in "$@" ; do
+		if [[ -f ${i} ]] ; then
+			doins "${i}"
+			((ret+=$?))
+		elif [[ -d ${i} ]] ; then
+			for j in "${i}"/*.desktop ; do
+				doins "${j}"
+				((ret+=$?))
+			done
+		else
+			((++ret))
+		fi
+	done
+	exit ${ret}
+	)
+}
+
+# @FUNCTION: newmenu
+# @USAGE: <menu> <newname>
+# @DESCRIPTION:
+# Like all other new* functions, install the specified menu as newname.
+newmenu() {
+	(
+	# wrap the env here so that the 'insinto' call
+	# doesn't corrupt the env of the caller
+	insinto /usr/share/applications
+	newins "$@"
+	)
+}
+
+# @FUNCTION: doicon
+# @USAGE: <list of icons>
+# @DESCRIPTION:
+# Install the list of icons into the icon directory (/usr/share/pixmaps).
+# This is useful in conjunction with creating desktop/menu files.
+doicon() {
+	(
+	# wrap the env here so that the 'insinto' call
+	# doesn't corrupt the env of the caller
+	local i j ret
+	insinto /usr/share/pixmaps
+	for i in "$@" ; do
+		if [[ -f ${i} ]] ; then
+			doins "${i}"
+			((ret+=$?))
+		elif [[ -d ${i} ]] ; then
+			for j in "${i}"/*.png ; do
+				doins "${j}"
+				((ret+=$?))
+			done
+		else
+			((++ret))
+		fi
+	done
+	exit ${ret}
+	)
+}
+
+# @FUNCTION: newicon
+# @USAGE: <icon> <newname>
+# @DESCRIPTION:
+# Like all other new* functions, install the specified icon as newname.
+newicon() {
+	(
+	# wrap the env here so that the 'insinto' call
+	# doesn't corrupt the env of the caller
+	insinto /usr/share/pixmaps
+	newins "$@"
+	)
+}
+
+# for internal use only (unpack_pdv and unpack_makeself)
+find_unpackable_file() {
+	local src=$1
+	if [[ -z ${src} ]] ; then
+		src=${DISTDIR}/${A}
+	else
+		if [[ -e ${DISTDIR}/${src} ]] ; then
+			src=${DISTDIR}/${src}
+		elif [[ -e ${PWD}/${src} ]] ; then
+			src=${PWD}/${src}
+		elif [[ -e ${src} ]] ; then
+			src=${src}
+		fi
+	fi
+	[[ ! -e ${src} ]] && return 1
+	echo "${src}"
+}
+
+# @FUNCTION: unpack_pdv
+# @USAGE: <file to unpack> <size of off_t>
+# @DESCRIPTION:
+# Unpack those pesky pdv generated files ...
+# They're self-unpacking programs with the binary package stuffed in
+# the middle of the archive.  Valve seems to use it a lot ... too bad
+# it seems to like to segfault a lot :(.  So lets take it apart ourselves.
+#
+# You have to specify the off_t size ... I have no idea how to extract that
+# information out of the binary executable myself.  Basically you pass in
+# the size of the off_t type (in bytes) on the machine that built the pdv
+# archive.
+#
+# One way to determine this is by running the following commands:
+#
+# @CODE
+# 	strings <pdv archive> | grep lseek
+# 	strace -elseek <pdv archive>
+# @CODE
+#
+# Basically look for the first lseek command (we do the strings/grep because
+# sometimes the function call is _llseek or something) and steal the 2nd
+# parameter.  Here is an example:
+#
+# @CODE
+# 	vapier@vapier 0 pdv_unpack # strings hldsupdatetool.bin | grep lseek
+# 	lseek
+# 	vapier@vapier 0 pdv_unpack # strace -elseek ./hldsupdatetool.bin
+# 	lseek(3, -4, SEEK_END)					= 2981250
+# @CODE
+#
+# Thus we would pass in the value of '4' as the second parameter.
+unpack_pdv() {
+	local src=$(find_unpackable_file "$1")
+	local sizeoff_t=$2
+
+	[[ -z ${src} ]] && die "Could not locate source for '$1'"
+	[[ -z ${sizeoff_t} ]] && die "No idea what off_t size was used for this pdv :("
+
+	local shrtsrc=$(basename "${src}")
+	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
+	local metaskip=$(tail -c ${sizeoff_t} "${src}" | hexdump -e \"%i\")
+	local tailskip=$(tail -c $((${sizeoff_t}*2)) "${src}" | head -c ${sizeoff_t} | hexdump -e \"%i\")
+
+	# grab metadata for debug reasons
+	local metafile=$(emktemp)
+	tail -c +$((${metaskip}+1)) "${src}" > "${metafile}"
+
+	# rip out the final file name from the metadata
+	local datafile=$(tail -c +$((${metaskip}+1)) "${src}" | strings | head -n 1)
+	datafile=$(basename "${datafile}")
+
+	# now lets uncompress/untar the file if need be
+	local tmpfile=$(emktemp)
+	tail -c +$((${tailskip}+1)) ${src} 2>/dev/null | head -c 512 > ${tmpfile}
+
+	local iscompressed=$(file -b "${tmpfile}")
+	if [[ ${iscompressed:0:8} == "compress" ]] ; then
+		iscompressed=1
+		mv ${tmpfile}{,.Z}
+		gunzip ${tmpfile}
+	else
+		iscompressed=0
+	fi
+	local istar=$(file -b "${tmpfile}")
+	if [[ ${istar:0:9} == "POSIX tar" ]] ; then
+		istar=1
+	else
+		istar=0
+	fi
+
+	#for some reason gzip dies with this ... dd cant provide buffer fast enough ?
+	#dd if=${src} ibs=${metaskip} count=1 \
+	#	| dd ibs=${tailskip} skip=1 \
+	#	| gzip -dc \
+	#	> ${datafile}
+	if [ ${iscompressed} -eq 1 ] ; then
+		if [ ${istar} -eq 1 ] ; then
+			tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
+				| head -c $((${metaskip}-${tailskip})) \
+				| tar -xzf -
+		else
+			tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
+				| head -c $((${metaskip}-${tailskip})) \
+				| gzip -dc \
+				> ${datafile}
+		fi
+	else
+		if [ ${istar} -eq 1 ] ; then
+			tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
+				| head -c $((${metaskip}-${tailskip})) \
+				| tar --no-same-owner -xf -
+		else
+			tail -c +$((${tailskip}+1)) ${src} 2>/dev/null \
+				| head -c $((${metaskip}-${tailskip})) \
+				> ${datafile}
+		fi
+	fi
+	true
+	#[ -s "${datafile}" ] || die "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
+	#assert "failure unpacking pdv ('${metaskip}' '${tailskip}' '${datafile}')"
+}
+
+# @FUNCTION: unpack_makeself
+# @USAGE: [file to unpack] [offset] [tail|dd]
+# @DESCRIPTION:
+# Unpack those pesky makeself generated files ...
+# They're shell scripts with the binary package tagged onto
+# the end of the archive.  Loki utilized the format as does
+# many other game companies.
+#
+# If the file is not specified, then ${A} is used.  If the
+# offset is not specified then we will attempt to extract
+# the proper offset from the script itself.
+unpack_makeself() {
+	local src_input=${1:-${A}}
+	local src=$(find_unpackable_file "${src_input}")
+	local skip=$2
+	local exe=$3
+
+	[[ -z ${src} ]] && die "Could not locate source for '${src_input}'"
+
+	local shrtsrc=$(basename "${src}")
+	echo ">>> Unpacking ${shrtsrc} to ${PWD}"
+	if [[ -z ${skip} ]] ; then
+		local ver=$(grep -m1 -a '#.*Makeself' "${src}" | awk '{print $NF}')
+		local skip=0
+		exe=tail
+		case ${ver} in
+			1.5.*|1.6.0-nv)	# tested 1.5.{3,4,5} ... guessing 1.5.x series is same
+				skip=$(grep -a ^skip= "${src}" | cut -d= -f2)
+				;;
+			2.0|2.0.1)
+				skip=$(grep -a ^$'\t'tail "${src}" | awk '{print $2}' | cut -b2-)
+				;;
+			2.1.1)
+				skip=$(grep -a ^offset= "${src}" | awk '{print $2}' | cut -b2-)
+				(( skip++ ))
+				;;
+			2.1.2)
+				skip=$(grep -a ^offset= "${src}" | awk '{print $3}' | head -n 1)
+				(( skip++ ))
+				;;
+			2.1.3)
+				skip=`grep -a ^offset= "${src}" | awk '{print $3}'`
+				(( skip++ ))
+				;;
+			2.1.4|2.1.5)
+				skip=$(grep -a offset=.*head.*wc "${src}" | awk '{print $3}' | head -n 1)
+				skip=$(head -n ${skip} "${src}" | wc -c)
+				exe="dd"
+				;;
+			*)
+				eerror "I'm sorry, but I was unable to support the Makeself file."
+				eerror "The version I detected was '${ver}'."
+				eerror "Please file a bug about the file ${shrtsrc} at"
+				eerror "http://bugs.gentoo.org/ so that support can be added."
+				die "makeself version '${ver}' not supported"
+				;;
+		esac
+		debug-print "Detected Makeself version ${ver} ... using ${skip} as offset"
+	fi
+	case ${exe} in
+		tail)	exe="tail -n +${skip} '${src}'";;
+		dd)		exe="dd ibs=${skip} skip=1 if='${src}'";;
+		*)		die "makeself cant handle exe '${exe}'"
+	esac
+
+	# lets grab the first few bytes of the file to figure out what kind of archive it is
+	local tmpfile=$(emktemp)
+	eval ${exe} 2>/dev/null | head -c 512 > "${tmpfile}"
+	local filetype=$(file -b "${tmpfile}")
+	case ${filetype} in
+		*tar\ archive*)
+			eval ${exe} | tar --no-same-owner -xf -
+			;;
+		bzip2*)
+			eval ${exe} | bzip2 -dc | tar --no-same-owner -xf -
+			;;
+		gzip*)
+			eval ${exe} | tar --no-same-owner -xzf -
+			;;
+		compress*)
+			eval ${exe} | gunzip | tar --no-same-owner -xf -
+			;;
+		*)
+			eerror "Unknown filetype \"${filetype}\" ?"
+			false
+			;;
+	esac
+	assert "failure unpacking (${filetype}) makeself ${shrtsrc} ('${ver}' +${skip})"
+}
+
+# @FUNCTION: check_license
+# @USAGE: [license]
+# @DESCRIPTION:
+# Display a license for user to accept.  If no license is
+# specified, then ${LICENSE} is used.
+check_license() {
+	local lic=$1
+	if [ -z "${lic}" ] ; then
+		lic="${PORTDIR}/licenses/${LICENSE}"
+	else
+		if [ -e "${PORTDIR}/licenses/${lic}" ] ; then
+			lic="${PORTDIR}/licenses/${lic}"
+		elif [ -e "${PWD}/${lic}" ] ; then
+			lic="${PWD}/${lic}"
+		elif [ -e "${lic}" ] ; then
+			lic="${lic}"
+		fi
+	fi
+	local l="`basename ${lic}`"
+
+	# here is where we check for the licenses the user already
+	# accepted ... if we don't find a match, we make the user accept
+	local alic
+	eshopts_push -o noglob # so that bash doesn't expand "*"
+	for alic in ${ACCEPT_LICENSE} ; do
+		if [[ ${alic} == ${l} ]]; then
+			eshopts_pop
+			return 0
+		fi
+	done
+	eshopts_pop
+	[ ! -f "${lic}" ] && die "Could not find requested license ${lic}"
+
+	local licmsg=$(emktemp)
+	cat <<-EOF > ${licmsg}
+	**********************************************************
+	The following license outlines the terms of use of this
+	package.  You MUST accept this license for installation to
+	continue.  When you are done viewing, hit 'q'.	If you
+	CTRL+C out of this, the install will not run!
+	**********************************************************
+
+	EOF
+	cat ${lic} >> ${licmsg}
+	${PAGER:-less} ${licmsg} || die "Could not execute pager (${PAGER}) to accept ${lic}"
+	einfon "Do you accept the terms of this license (${l})? [yes/no] "
+	read alic
+	case ${alic} in
+		yes|Yes|y|Y)
+			return 0
+			;;
+		*)
+			echo;echo;echo
+			eerror "You MUST accept the license to continue!  Exiting!"
+			die "Failed to accept license"
+			;;
+	esac
+}
+
+# @FUNCTION: cdrom_get_cds
+# @USAGE: <file on cd1> [file on cd2] [file on cd3] [...]
+# @DESCRIPTION:
+# Aquire cd(s) for those lovely cd-based emerges.  Yes, this violates
+# the whole 'non-interactive' policy, but damnit I want CD support !
+#
+# With these cdrom functions we handle all the user interaction and
+# standardize everything.  All you have to do is call cdrom_get_cds()
+# and when the function returns, you can assume that the cd has been
+# found at CDROM_ROOT.
+#
+# The function will attempt to locate a cd based upon a file that is on
+# the cd.  The more files you give this function, the more cds
+# the cdrom functions will handle.
+#
+# Normally the cdrom functions will refer to the cds as 'cd #1', 'cd #2',
+# etc...  If you want to give the cds better names, then just export
+# the appropriate CDROM_NAME variable before calling cdrom_get_cds().
+# Use CDROM_NAME for one cd, or CDROM_NAME_# for multiple cds.  You can
+# also use the CDROM_NAME_SET bash array.
+#
+# For those multi cd ebuilds, see the cdrom_load_next_cd() function.
+cdrom_get_cds() {
+	# first we figure out how many cds we're dealing with by
+	# the # of files they gave us
+	local cdcnt=0
+	local f=
+	for f in "$@" ; do
+		((++cdcnt))
+		export CDROM_CHECK_${cdcnt}="$f"
+	done
+	export CDROM_TOTAL_CDS=${cdcnt}
+	export CDROM_CURRENT_CD=1
+
+	# now we see if the user gave use CD_ROOT ...
+	# if they did, let's just believe them that it's correct
+	if [[ -n ${CD_ROOT}${CD_ROOT_1} ]] ; then
+		local var=
+		cdcnt=0
+		while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
+			((++cdcnt))
+			var="CD_ROOT_${cdcnt}"
+			[[ -z ${!var} ]] && var="CD_ROOT"
+			if [[ -z ${!var} ]] ; then
+				eerror "You must either use just the CD_ROOT"
+				eerror "or specify ALL the CD_ROOT_X variables."
+				eerror "In this case, you will need ${CDROM_TOTAL_CDS} CD_ROOT_X variables."
+				die "could not locate CD_ROOT_${cdcnt}"
+			fi
+		done
+		export CDROM_ROOT=${CD_ROOT_1:-${CD_ROOT}}
+		einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
+		export CDROM_SET=-1
+		for f in ${CDROM_CHECK_1//:/ } ; do
+			((++CDROM_SET))
+			[[ -e ${CDROM_ROOT}/${f} ]] && break
+		done
+		export CDROM_MATCH=${f}
+		return
+	fi
+
+	# User didn't help us out so lets make sure they know they can
+	# simplify the whole process ...
+	if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
+		einfo "This ebuild will need the ${CDROM_NAME:-cdrom for ${PN}}"
+		echo
+		einfo "If you do not have the CD, but have the data files"
+		einfo "mounted somewhere on your filesystem, just export"
+		einfo "the variable CD_ROOT so that it points to the"
+		einfo "directory containing the files."
+		echo
+		einfo "For example:"
+		einfo "export CD_ROOT=/mnt/cdrom"
+		echo
+	else
+		if [[ -n ${CDROM_NAME_SET} ]] ; then
+			# Translate the CDROM_NAME_SET array into CDROM_NAME_#
+			cdcnt=0
+			while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
+				((++cdcnt))
+				export CDROM_NAME_${cdcnt}="${CDROM_NAME_SET[$((${cdcnt}-1))]}"
+			done
+		fi
+
+		einfo "This package will need access to ${CDROM_TOTAL_CDS} cds."
+		cdcnt=0
+		while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
+			((++cdcnt))
+			var="CDROM_NAME_${cdcnt}"
+			[[ ! -z ${!var} ]] && einfo " CD ${cdcnt}: ${!var}"
+		done
+		echo
+		einfo "If you do not have the CDs, but have the data files"
+		einfo "mounted somewhere on your filesystem, just export"
+		einfo "the following variables so they point to the right place:"
+		einfon ""
+		cdcnt=0
+		while [[ ${cdcnt} -lt ${CDROM_TOTAL_CDS} ]] ; do
+			((++cdcnt))
+			echo -n " CD_ROOT_${cdcnt}"
+		done
+		echo
+		einfo "Or, if you have all the files in the same place, or"
+		einfo "you only have one cdrom, you can export CD_ROOT"
+		einfo "and that place will be used as the same data source"
+		einfo "for all the CDs."
+		echo
+		einfo "For example:"
+		einfo "export CD_ROOT_1=/mnt/cdrom"
+		echo
+	fi
+
+	export CDROM_SET=""
+	export CDROM_CURRENT_CD=0
+	cdrom_load_next_cd
+}
+
+# @FUNCTION: cdrom_load_next_cd
+# @DESCRIPTION:
+# Some packages are so big they come on multiple CDs.  When you're done reading
+# files off a CD and want access to the next one, just call this function.
+# Again, all the messy details of user interaction are taken care of for you.
+# Once this returns, just read the variable CDROM_ROOT for the location of the
+# mounted CD.  Note that you can only go forward in the CD list, so make sure
+# you only call this function when you're done using the current CD.
+cdrom_load_next_cd() {
+	local var
+	((++CDROM_CURRENT_CD))
+
+	unset CDROM_ROOT
+	var=CD_ROOT_${CDROM_CURRENT_CD}
+	[[ -z ${!var} ]] && var="CD_ROOT"
+	if [[ -z ${!var} ]] ; then
+		var="CDROM_CHECK_${CDROM_CURRENT_CD}"
+		_cdrom_locate_file_on_cd ${!var}
+	else
+		export CDROM_ROOT=${!var}
+	fi
+
+	einfo "Found CD #${CDROM_CURRENT_CD} root at ${CDROM_ROOT}"
+}
+
+# this is used internally by the cdrom_get_cds() and cdrom_load_next_cd()
+# functions.  this should *never* be called from an ebuild.
+# all it does is try to locate a give file on a cd ... if the cd isn't
+# found, then a message asking for the user to insert the cdrom will be
+# displayed and we'll hang out here until:
+# (1) the file is found on a mounted cdrom
+# (2) the user hits CTRL+C
+_cdrom_locate_file_on_cd() {
+	local mline=""
+	local showedmsg=0 showjolietmsg=0
+
+	while [[ -z ${CDROM_ROOT} ]] ; do
+		local i=0
+		local -a cdset=(${*//:/ })
+		if [[ -n ${CDROM_SET} ]] ; then
+			cdset=(${cdset[${CDROM_SET}]})
+		fi
+
+		while [[ -n ${cdset[${i}]} ]] ; do
+			local dir=$(dirname ${cdset[${i}]})
+			local file=$(basename ${cdset[${i}]})
+
+			local point= node= fs= foo=
+			while read point node fs foo ; do
+				[[ " cd9660 iso9660 udf " != *" ${fs} "* ]] && \
+					! [[ ${fs} == "subfs" && ",${opts}," == *",fs=cdfss,"* ]] \
+					&& continue
+				point=${point//\040/ }
+				[[ ! -d ${point}/${dir} ]] && continue
+				[[ -z $(find "${point}/${dir}" -maxdepth 1 -iname "${file}") ]] && continue
+				export CDROM_ROOT=${point}
+				export CDROM_SET=${i}
+				export CDROM_MATCH=${cdset[${i}]}
+				return
+			done <<< "$(get_mounts)"
+
+			((++i))
+		done
+
+		echo
+		if [[ ${showedmsg} -eq 0 ]] ; then
+			if [[ ${CDROM_TOTAL_CDS} -eq 1 ]] ; then
+				if [[ -z ${CDROM_NAME} ]] ; then
+					einfo "Please insert+mount the cdrom for ${PN} now !"
+				else
+					einfo "Please insert+mount the ${CDROM_NAME} cdrom now !"
+				fi
+			else
+				if [[ -z ${CDROM_NAME_1} ]] ; then
+					einfo "Please insert+mount cd #${CDROM_CURRENT_CD} for ${PN} now !"
+				else
+					local var="CDROM_NAME_${CDROM_CURRENT_CD}"
+					einfo "Please insert+mount the ${!var} cdrom now !"
+				fi
+			fi
+			showedmsg=1
+		fi
+		einfo "Press return to scan for the cd again"
+		einfo "or hit CTRL+C to abort the emerge."
+		echo
+		if [[ ${showjolietmsg} -eq 0 ]] ; then
+			showjolietmsg=1
+		else
+			ewarn "If you are having trouble with the detection"
+			ewarn "of your CD, it is possible that you do not have"
+			ewarn "Joliet support enabled in your kernel.  Please"
+			ewarn "check that CONFIG_JOLIET is enabled in your kernel."
+			ebeep 5
+		fi
+		read || die "something is screwed with your system"
+	done
+}
+
+# @FUNCTION: strip-linguas
+# @USAGE: [<allow LINGUAS>|<-i|-u> <directories of .po files>]
+# @DESCRIPTION:
+# Make sure that LINGUAS only contains languages that
+# a package can support.  The first form allows you to
+# specify a list of LINGUAS.  The -i builds a list of po
+# files found in all the directories and uses the
+# intersection of the lists.  The -u builds a list of po
+# files found in all the directories and uses the union
+# of the lists.
+strip-linguas() {
+	local ls newls nols
+	if [[ $1 == "-i" ]] || [[ $1 == "-u" ]] ; then
+		local op=$1; shift
+		ls=$(find "$1" -name '*.po' -exec basename {} .po ';'); shift
+		local d f
+		for d in "$@" ; do
+			if [[ ${op} == "-u" ]] ; then
+				newls=${ls}
+			else
+				newls=""
+			fi
+			for f in $(find "$d" -name '*.po' -exec basename {} .po ';') ; do
+				if [[ ${op} == "-i" ]] ; then
+					hasq ${f} ${ls} && newls="${newls} ${f}"
+				else
+					hasq ${f} ${ls} || newls="${newls} ${f}"
+				fi
+			done
+			ls=${newls}
+		done
+	else
+		ls="$@"
+	fi
+
+	nols=""
+	newls=""
+	for f in ${LINGUAS} ; do
+		if hasq ${f} ${ls} ; then
+			newls="${newls} ${f}"
+		else
+			nols="${nols} ${f}"
+		fi
+	done
+	[[ -n ${nols} ]] \
+		&& ewarn "Sorry, but ${PN} does not support the LINGUAS:" ${nols}
+	export LINGUAS=${newls:1}
+}
+
+# @FUNCTION: preserve_old_lib
+# @USAGE: <libs to preserve> [more libs]
+# @DESCRIPTION:
+# These functions are useful when a lib in your package changes ABI SONAME.
+# An example might be from libogg.so.0 to libogg.so.1.  Removing libogg.so.0
+# would break packages that link against it.  Most people get around this
+# by using the portage SLOT mechanism, but that is not always a relevant
+# solution, so instead you can call this from pkg_preinst.  See also the
+# preserve_old_lib_notify function.
+preserve_old_lib() {
+	if [[ ${EBUILD_PHASE} != "preinst" ]] ; then
+		eerror "preserve_old_lib() must be called from pkg_preinst() only"
+		die "Invalid preserve_old_lib() usage"
+	fi
+	[[ -z $1 ]] && die "Usage: preserve_old_lib <library to preserve> [more libraries to preserve]"
+
+	# let portage worry about it
+	has preserve-libs ${FEATURES} && return 0
+
+	# cannot preserve-libs on aix yet.
+	[[ ${CHOST} == *-aix* ]] && {
+		einfo "Not preserving libs on AIX (yet), not implemented."
+		return 0
+	}
+
+	local lib dir
+	for lib in "$@" ; do
+		[[ -e ${EROOT}/${lib} ]] || continue
+		dir=${lib%/*}
+		dodir ${dir} || die "dodir ${dir} failed"
+		cp "${EROOT}"/${lib} "${ED}"/${lib} || die "cp ${lib} failed"
+		touch "${ED}"/${lib}
+	done
+}
+
+# @FUNCTION: preserve_old_lib_notify
+# @USAGE: <libs to notify> [more libs]
+# @DESCRIPTION:
+# Spit helpful messages about the libraries preserved by preserve_old_lib.
+preserve_old_lib_notify() {
+	if [[ ${EBUILD_PHASE} != "postinst" ]] ; then
+		eerror "preserve_old_lib_notify() must be called from pkg_postinst() only"
+		die "Invalid preserve_old_lib_notify() usage"
+	fi
+
+	# let portage worry about it
+	has preserve-libs ${FEATURES} && return 0
+
+	local lib notice=0
+	for lib in "$@" ; do
+		[[ -e ${EROOT}/${lib} ]] || continue
+		if [[ ${notice} -eq 0 ]] ; then
+			notice=1
+			ewarn "Old versions of installed libraries were detected on your system."
+			ewarn "In order to avoid breaking packages that depend on these old libs,"
+			ewarn "the libraries are not being removed.  You need to run revdep-rebuild"
+			ewarn "in order to remove these old dependencies.  If you do not have this"
+			ewarn "helper program, simply emerge the 'gentoolkit' package."
+			ewarn
+		fi
+		# temp hack for #348634 #357225
+		[[ ${PN} == "mpfr" ]] && lib=${lib##*/}
+		ewarn "  # revdep-rebuild --library '${lib}'"
+	done
+	if [[ ${notice} -eq 1 ]] ; then
+		ewarn
+		ewarn "Once you've finished running revdep-rebuild, it should be safe to"
+		ewarn "delete the old libraries.  Here is a copy & paste for the lazy:"
+		for lib in "$@" ; do
+			ewarn "  # rm '${lib}'"
+		done
+	fi
+}
+
+# @FUNCTION: built_with_use
+# @USAGE: [--hidden] [--missing <action>] [-a|-o] <DEPEND ATOM> <List of USE flags>
+# @DESCRIPTION:
+#
+# Deprecated: Use EAPI 2 use deps in DEPEND|RDEPEND and with has_version calls.
+#
+# A temporary hack until portage properly supports DEPENDing on USE
+# flags being enabled in packages.  This will check to see if the specified
+# DEPEND atom was built with the specified list of USE flags.  The
+# --missing option controls the behavior if called on a package that does
+# not actually support the defined USE flags (aka listed in IUSE).
+# The default is to abort (call die).  The -a and -o flags control
+# the requirements of the USE flags.  They correspond to "and" and "or"
+# logic.  So the -a flag means all listed USE flags must be enabled
+# while the -o flag means at least one of the listed IUSE flags must be
+# enabled.  The --hidden option is really for internal use only as it
+# means the USE flag we're checking is hidden expanded, so it won't be found
+# in IUSE like normal USE flags.
+#
+# Remember that this function isn't terribly intelligent so order of optional
+# flags matter.
+built_with_use() {
+	local hidden="no"
+	if [[ $1 == "--hidden" ]] ; then
+		hidden="yes"
+		shift
+	fi
+
+	local missing_action="die"
+	if [[ $1 == "--missing" ]] ; then
+		missing_action=$2
+		shift ; shift
+		case ${missing_action} in
+			true|false|die) ;;
+			*) die "unknown action '${missing_action}'";;
+		esac
+	fi
+
+	local opt=$1
+	[[ ${opt:0:1} = "-" ]] && shift || opt="-a"
+
+	local PKG=$(best_version $1)
+	[[ -z ${PKG} ]] && die "Unable to resolve $1 to an installed package"
+	shift
+
+	local USEFILE="${EROOT}"/var/db/pkg/${PKG}/USE
+	local IUSEFILE="${EROOT}"/var/db/pkg/${PKG}/IUSE
+
+	# if the IUSE file doesn't exist, the read will error out, we need to handle
+	# this gracefully
+	if [[ ! -e ${USEFILE} ]] || [[ ! -e ${IUSEFILE} && ${hidden} == "no" ]] ; then
+		case ${missing_action} in
+			true)	return 0;;
+			false)	return 1;;
+			die)	die "Unable to determine what USE flags $PKG was built with";;
+		esac
+	fi
+
+	if [[ ${hidden} == "no" ]] ; then
+		local IUSE_BUILT=( $(<"${IUSEFILE}") )
+		# Don't check USE_EXPAND #147237
+		local expand
+		for expand in $(echo ${USE_EXPAND} | tr '[:upper:]' '[:lower:]') ; do
+			if [[ $1 == ${expand}_* ]] ; then
+				expand=""
+				break
+			fi
+		done
+		if [[ -n ${expand} ]] ; then
+			if ! has $1 ${IUSE_BUILT[@]#[-+]} ; then
+				case ${missing_action} in
+					true)  return 0;;
+					false) return 1;;
+					die)   die "$PKG does not actually support the $1 USE flag!";;
+				esac
+			fi
+		fi
+	fi
+
+	local USE_BUILT=$(<${USEFILE})
+	while [[ $# -gt 0 ]] ; do
+		if [[ ${opt} = "-o" ]] ; then
+			has $1 ${USE_BUILT} && return 0
+		else
+			has $1 ${USE_BUILT} || return 1
+		fi
+		shift
+	done
+	[[ ${opt} = "-a" ]]
+}
+
+# @FUNCTION: epunt_cxx
+# @USAGE: [dir to scan]
+# @DESCRIPTION:
+# Many configure scripts wrongly bail when a C++ compiler could not be
+# detected.  If dir is not specified, then it defaults to ${S}.
+#
+# http://bugs.gentoo.org/73450
+epunt_cxx() {
+	local dir=$1
+	[[ -z ${dir} ]] && dir=${S}
+	ebegin "Removing useless C++ checks"
+	local f
+	find "${dir}" -name configure | while read f ; do
+		patch --no-backup-if-mismatch -p0 "${f}" "${PORTDIR}/eclass/ELT-patches/nocxx/nocxx.patch" > /dev/null
+	done
+	eend 0
+}
+
+# @FUNCTION: make_wrapper
+# @USAGE: <wrapper> <target> [chdir] [libpaths] [installpath]
+# @DESCRIPTION:
+# Create a shell wrapper script named wrapper in installpath
+# (defaults to the bindir) to execute target (default of wrapper) by
+# first optionally setting LD_LIBRARY_PATH to the colon-delimited
+# libpaths followed by optionally changing directory to chdir.
+make_wrapper() {
+	local wrapper=$1 bin=$2 chdir=$3 libdir=$4 path=$5
+	local tmpwrapper=$(emktemp)
+	# We don't want to quote ${bin} so that people can pass complex
+	# things as $bin ... "./someprog --args"
+	cat << EOF > "${tmpwrapper}"
+#!${EPREFIX}/bin/sh
+cd "${chdir:-.}"
+if [ -n "${libdir}" ] ; then
+	if [ "\${LD_LIBRARY_PATH+set}" = "set" ] ; then
+		export LD_LIBRARY_PATH="\${LD_LIBRARY_PATH}:${EPREFIX}${libdir}"
+	else
+		export LD_LIBRARY_PATH="${EPREFIX}${libdir}"
+	fi
+	# ultra-dirty, just do the same for Darwin
+	if [ "\${DYLD_LIBRARY_PATH+set}" = "set" ] ; then
+		export DYLD_LIBRARY_PATH="\${DYLD_LIBRARY_PATH}:${EPERFIX}${libdir}"
+	else
+		export DYLD_LIBRARY_PATH="${EPREFIX}${libdir}"
+	fi
+fi
+exec "${EPREFIX}"${bin} "\$@"
+EOF
+	chmod go+rx "${tmpwrapper}"
+	if [[ -n ${path} ]] ; then
+		(
+		exeinto "${path}"
+		newexe "${tmpwrapper}" "${wrapper}"
+		) || die
+	else
+		newbin "${tmpwrapper}" "${wrapper}" || die
+	fi
+}
+
+# @FUNCTION: path_exists
+# @USAGE: [-a|-o] <paths>
+# @DESCRIPTION:
+# Check if the specified paths exist.  Works for all types of paths
+# (files/dirs/etc...).  The -a and -o flags control the requirements
+# of the paths.  They correspond to "and" and "or" logic.  So the -a
+# flag means all the paths must exist while the -o flag means at least
+# one of the paths must exist.  The default behavior is "and".  If no
+# paths are specified, then the return value is "false".
+path_exists() {
+	local opt=$1
+	[[ ${opt} == -[ao] ]] && shift || opt="-a"
+
+	# no paths -> return false
+	# same behavior as: [[ -e "" ]]
+	[[ $# -eq 0 ]] && return 1
+
+	local p r=0
+	for p in "$@" ; do
+		[[ -e ${p} ]]
+		: $(( r += $? ))
+	done
+
+	case ${opt} in
+		-a) return $(( r != 0 )) ;;
+		-o) return $(( r == $# )) ;;
+	esac
+}
diff --git a/eclass/flag-o-matic.eclass b/eclass/flag-o-matic.eclass
new file mode 100644
index 0000000..60223b8
--- /dev/null
+++ b/eclass/flag-o-matic.eclass
@@ -0,0 +1,780 @@
+# Copyright 1999-2009 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/flag-o-matic.eclass,v 1.150 2011/02/25 10:51:44 dirtyepic Exp $
+
+# @ECLASS: flag-o-matic.eclass
+# @MAINTAINER:
+# toolchain@gentoo.org
+# @BLURB: common functions to manipulate and query toolchain flags
+# @DESCRIPTION:
+# This eclass contains a suite of functions to help developers sanely
+# and safely manage toolchain flags in their builds.
+
+inherit eutils toolchain-funcs multilib
+
+################ DEPRECATED functions ################
+# The following are still present to avoid breaking existing
+# code more than necessary; however they are deprecated. Please
+# use gcc-specs-* from toolchain-funcs.eclass instead, if you
+# need to know which hardened techs are active in the compiler.
+# See bug #100974
+#
+# has_hardened
+# has_pie
+# has_pic
+# has_ssp_all
+# has_ssp
+
+
+# {C,CXX,F,FC}FLAGS that we allow in strip-flags
+# Note: shell globs and character lists are allowed
+setup-allowed-flags() {
+	if [[ -z ${ALLOWED_FLAGS} ]] ; then
+		export ALLOWED_FLAGS="-pipe"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -O -O0 -O1 -O2 -mcpu -march -mtune"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fstack-protector -fstack-protector-all"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fbounds-checking -fno-strict-overflow"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-PIE -fno-pie -fno-unit-at-a-time"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -g -g[0-9] -ggdb -ggdb[0-9] -gstabs -gstabs+"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-ident -fpermissive"
+		export ALLOWED_FLAGS="${ALLOWED_FLAGS} -W* -w"
+	fi
+	# allow a bunch of flags that negate features / control ABI
+	ALLOWED_FLAGS="${ALLOWED_FLAGS} -fno-stack-protector -fno-stack-protector-all \
+		-fno-strict-aliasing -fno-bounds-checking -fstrict-overflow -fno-omit-frame-pointer"
+	ALLOWED_FLAGS="${ALLOWED_FLAGS} -mregparm -mno-app-regs -mapp-regs \
+		-mno-mmx -mno-sse -mno-sse2 -mno-sse3 -mno-ssse3 -mno-sse4 -mno-sse4.1 \
+		-mno-sse4.2 -mno-avx -mno-aes -mno-pclmul -mno-sse4a -mno-3dnow \
+		-mno-popcnt -mno-abm \
+		-mips1 -mips2 -mips3 -mips4 -mips32 -mips64 -mips16 -mplt \
+		-msoft-float -mno-soft-float -mhard-float -mno-hard-float -mfpu \
+		-mieee -mieee-with-inexact -mschedule -mfloat-gprs -mspe -mno-spe \
+		-mtls-direct-seg-refs -mno-tls-direct-seg-refs \
+		-mflat -mno-flat -mno-faster-structs -mfaster-structs \
+		-m32 -m64 -mabi -mlittle-endian -mbig-endian -EL -EB -fPIC \
+		-mlive-g0 -mcmodel -mstack-bias -mno-stack-bias \
+		-msecure-plt -m*-toc -D* -U*"
+
+	# 4.5
+	ALLOWED_FLAGS="${ALLOWED_FLAGS} -mno-fma4 -mno-movbe -mno-xop -mno-lwp"
+	# 4.6
+	ALLOWED_FLAGS="${ALLOWED_FLAGS} -mno-fsgsbase -mno-rdrnd -mno-f16c \
+		-mno-bmi -mno-tbm"
+
+	# {C,CXX,F,FC}FLAGS that we are think is ok, but needs testing
+	# NOTE:  currently -Os have issues with gcc3 and K6* arch's
+	export UNSTABLE_FLAGS="-Os -O3 -freorder-blocks"
+	return 0
+}
+
+# inverted filters for hardened compiler.  This is trying to unpick
+# the hardened compiler defaults.
+_filter-hardened() {
+	local f
+	for f in "$@" ; do
+		case "${f}" in
+			# Ideally we should only concern ourselves with PIE flags,
+			# not -fPIC or -fpic, but too many places filter -fPIC without
+			# thinking about -fPIE.
+			-fPIC|-fpic|-fPIE|-fpie|-Wl,pie|-pie)
+				gcc-specs-pie || continue
+				is-flagq -nopie || append-flags -nopie;;
+			-fstack-protector)
+				gcc-specs-ssp || continue
+				is-flagq -fno-stack-protector || append-flags $(test-flags -fno-stack-protector);;
+			-fstack-protector-all)
+				gcc-specs-ssp-to-all || continue
+				is-flagq -fno-stack-protector-all || append-flags $(test-flags -fno-stack-protector-all);;
+			-fno-strict-overflow)
+				gcc-specs-nostrict || continue
+				is-flagq -fstrict-overflow || append-flags $(test-flags -fstrict-overflow);;
+		esac
+	done
+}
+
+# Remove occurrences of strings from variable given in $1
+# Strings removed are matched as globs, so for example
+# '-O*' would remove -O1, -O2 etc.
+_filter-var() {
+	local f x VAR VAL
+	declare -a new
+
+	VAR=$1
+	shift
+	eval VAL=\${${VAR}}
+	for f in ${VAL}; do
+		for x in "$@"; do
+			# Note this should work with globs like -O*
+			[[ ${f} == ${x} ]] && continue 2
+		done
+		eval new\[\${\#new\[@]}]=\${f}
+	done
+	eval export ${VAR}=\${new\[*]}
+}
+
+# @FUNCTION: filter-flags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Remove particular <flags> from {C,CPP,CXX,F,FC}FLAGS.  Accepts shell globs.
+filter-flags() {
+	_filter-hardened "$@"
+	_filter-var CFLAGS "$@"
+	_filter-var CPPFLAGS "$@"
+	_filter-var CXXFLAGS "$@"
+	_filter-var FFLAGS "$@"
+	_filter-var FCFLAGS "$@"
+	return 0
+}
+
+# @FUNCTION: filter-lfs-flags
+# @DESCRIPTION:
+# Remove flags that enable Large File Support.
+filter-lfs-flags() {
+	[[ -n $@ ]] && die "filter-lfs-flags takes no arguments"
+	filter-flags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE -D_LARGE_FILES -D_LARGE_FILE_API
+}
+
+# @FUNCTION: append-cppflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to the current CPPFLAGS.
+append-cppflags() {
+	[[ -z $* ]] && return 0
+	export CPPFLAGS="${CPPFLAGS} $*"
+	return 0
+}
+
+# @FUNCTION: append-cflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to the current CFLAGS.
+append-cflags() {
+	[[ -z $* ]] && return 0
+	export CFLAGS="${CFLAGS} $*"
+	return 0
+}
+
+# @FUNCTION: append-cxxflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to the current CXXFLAGS.
+append-cxxflags() {
+	[[ -z $* ]] && return 0
+	export CXXFLAGS="${CXXFLAGS} $*"
+	return 0
+}
+
+# @FUNCTION: append-fflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to the current {F,FC}FLAGS.
+append-fflags() {
+	[[ -z $* ]] && return 0
+	export FFLAGS="${FFLAGS} $*"
+	export FCFLAGS="${FCFLAGS} $*"
+	return 0
+}
+
+# @FUNCTION: append-lfs-flags
+# @DESCRIPTION:
+# Add flags that enable Large File Support.
+append-lfs-flags() {
+	[[ -n $@ ]] && die "append-lfs-flags takes no arguments"
+	case ${CHOST} in
+	*-aix*) append-cppflags -D_LARGE_FILES -D_LARGE_FILE_API ;;
+	*) append-cppflags -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_LARGEFILE64_SOURCE ;;
+	esac
+}
+
+# @FUNCTION: append-flags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to your current {C,CXX,F,FC}FLAGS.
+append-flags() {
+	[[ -z $* ]] && return 0
+	append-cflags "$@"
+	append-cxxflags "$@"
+	append-fflags "$@"
+	return 0
+}
+
+# @FUNCTION: replace-flags
+# @USAGE: <old> <new>
+# @DESCRIPTION:
+# Replace the <old> flag with <new>.  Accepts shell globs for <old>.
+replace-flags() {
+	[[ $# != 2 ]] \
+		&& echo && eerror "Usage: replace-flags <old flag> <new flag>" \
+		&& die "replace-flags takes 2 arguments, not $#"
+
+	local f fset
+	declare -a new_CFLAGS new_CXXFLAGS new_FFLAGS new_FCFLAGS
+
+	for fset in CFLAGS CXXFLAGS FFLAGS FCFLAGS; do
+		# Looping over the flags instead of using a global
+		# substitution ensures that we're working with flag atoms.
+		# Otherwise globs like -O* have the potential to wipe out the
+		# list of flags.
+		for f in ${!fset}; do
+			# Note this should work with globs like -O*
+			[[ ${f} == ${1} ]] && f=${2}
+			eval new_${fset}\[\${\#new_${fset}\[@]}]=\${f}
+		done
+		eval export ${fset}=\${new_${fset}\[*]}
+	done
+
+	return 0
+}
+
+# @FUNCTION: replace-cpu-flags
+# @USAGE: <old> <new>
+# @DESCRIPTION:
+# Replace cpu flags (like -march/-mcpu/-mtune) that select the <old> cpu
+# with flags that select the <new> cpu.  Accepts shell globs for <old>.
+replace-cpu-flags() {
+	local newcpu="$#" ; newcpu="${!newcpu}"
+	while [ $# -gt 1 ] ; do
+		# quote to make sure that no globbing is done (particularly on
+		# ${oldcpu}) prior to calling replace-flags
+		replace-flags "-march=${1}" "-march=${newcpu}"
+		replace-flags "-mcpu=${1}" "-mcpu=${newcpu}"
+		replace-flags "-mtune=${1}" "-mtune=${newcpu}"
+		shift
+	done
+	return 0
+}
+
+_is_flagq() {
+	local x
+	for x in ${!1} ; do
+		[[ ${x} == $2 ]] && return 0
+	done
+	return 1
+}
+
+# @FUNCTION: is-flagq
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is in {C,CXX,F,FC}FLAGS, else returns shell false.  Accepts shell globs.
+is-flagq() {
+	[[ -n $2 ]] && die "Usage: is-flag <flag>"
+	_is_flagq CFLAGS $1 || _is_flagq CXXFLAGS $1 || _is_flagq FFLAGS $1 || _is_flagq FCFLAGS $1
+}
+
+# @FUNCTION: is-flag
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Echo's "true" if flag is set in {C,CXX,F,FC}FLAGS.  Accepts shell globs.
+is-flag() {
+	is-flagq "$@" && echo true
+}
+
+# @FUNCTION: is-ldflagq
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is in LDFLAGS, else returns shell false.  Accepts shell globs.
+is-ldflagq() {
+	[[ -n $2 ]] && die "Usage: is-ldflag <flag>"
+	_is_flagq LDFLAGS $1
+}
+
+# @FUNCTION: is-ldflag
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Echo's "true" if flag is set in LDFLAGS.  Accepts shell globs.
+is-ldflag() {
+	is-ldflagq "$@" && echo true
+}
+
+# @FUNCTION: filter-mfpmath
+# @USAGE: <math types>
+# @DESCRIPTION:
+# Remove specified math types from the fpmath flag.  For example, if the user
+# has -mfpmath=sse,386, running `filter-mfpmath sse` will leave the user with
+# -mfpmath=386.
+filter-mfpmath() {
+	local orig_mfpmath new_math prune_math
+
+	# save the original -mfpmath flag
+	orig_mfpmath=$(get-flag -mfpmath)
+	# get the value of the current -mfpmath flag
+	new_math=$(get-flag mfpmath)
+	new_math=" ${new_math//,/ } "
+	# figure out which math values are to be removed
+	prune_math=""
+	for prune_math in "$@" ; do
+		new_math=${new_math/ ${prune_math} / }
+	done
+	new_math=$(echo ${new_math})
+	new_math=${new_math// /,}
+
+	if [[ -z ${new_math} ]] ; then
+		# if we're removing all user specified math values are
+		# slated for removal, then we just filter the flag
+		filter-flags ${orig_mfpmath}
+	else
+		# if we only want to filter some of the user specified
+		# math values, then we replace the current flag
+		replace-flags ${orig_mfpmath} -mfpmath=${new_math}
+	fi
+	return 0
+}
+
+# @FUNCTION: strip-flags
+# @DESCRIPTION:
+# Strip C[XX]FLAGS of everything except known good/safe flags.
+strip-flags() {
+	local x y flag NEW_CFLAGS NEW_CXXFLAGS NEW_FFLAGS NEW_FCFLAGS
+
+	setup-allowed-flags
+
+	local NEW_CFLAGS=""
+	local NEW_CXXFLAGS=""
+	local NEW_FFLAGS=""
+	local NEW_FCFLAGS=""
+
+	# Allow unstable C[XX]FLAGS if we are using unstable profile ...
+
+	#
+	#
+	# In Gentoo Prefix, this is useless. Not a problem, but on aix6 it causes
+	# bash to hang and I can't figure it out. So it is disabled for now.
+	# --darkside@g.o (14 Jan 2009)
+
+	if use !prefix; then
+		if has "~$(tc-arch)" ${ACCEPT_KEYWORDS} ; then
+			ALLOWED_FLAGS="${ALLOWED_FLAGS} ${UNSTABLE_FLAGS}"
+		fi
+	fi
+
+	set -f	# disable pathname expansion
+
+	for x in ${CFLAGS}; do
+		for y in ${ALLOWED_FLAGS}; do
+			flag=${x%%=*}
+			if [ "${flag%%${y}}" = "" ] ; then
+				NEW_CFLAGS="${NEW_CFLAGS} ${x}"
+				break
+			fi
+		done
+	done
+
+	for x in ${CXXFLAGS}; do
+		for y in ${ALLOWED_FLAGS}; do
+			flag=${x%%=*}
+			if [ "${flag%%${y}}" = "" ] ; then
+				NEW_CXXFLAGS="${NEW_CXXFLAGS} ${x}"
+				break
+			fi
+		done
+	done
+
+	for x in ${FFLAGS}; do
+		for y in ${ALLOWED_FLAGS}; do
+			flag=${x%%=*}
+			if [ "${flag%%${y}}" = "" ] ; then
+				NEW_FFLAGS="${NEW_FFLAGS} ${x}"
+				break
+			fi
+		done
+	done
+
+	for x in ${FCFLAGS}; do
+		for y in ${ALLOWED_FLAGS}; do
+			flag=${x%%=*}
+			if [ "${flag%%${y}}" = "" ] ; then
+				NEW_FCFLAGS="${NEW_FCFLAGS} ${x}"
+				break
+			fi
+		done
+	done
+
+	# In case we filtered out all optimization flags fallback to -O2
+	if [ "${CFLAGS/-O}" != "${CFLAGS}" -a "${NEW_CFLAGS/-O}" = "${NEW_CFLAGS}" ]; then
+		NEW_CFLAGS="${NEW_CFLAGS} -O2"
+	fi
+	if [ "${CXXFLAGS/-O}" != "${CXXFLAGS}" -a "${NEW_CXXFLAGS/-O}" = "${NEW_CXXFLAGS}" ]; then
+		NEW_CXXFLAGS="${NEW_CXXFLAGS} -O2"
+	fi
+	if [ "${FFLAGS/-O}" != "${FFLAGS}" -a "${NEW_FFLAGS/-O}" = "${NEW_FFLAGS}" ]; then
+		NEW_FFLAGS="${NEW_FFLAGS} -O2"
+	fi
+	if [ "${FCFLAGS/-O}" != "${FCFLAGS}" -a "${NEW_FCFLAGS/-O}" = "${NEW_FCFLAGS}" ]; then
+		NEW_FCFLAGS="${NEW_FCFLAGS} -O2"
+	fi
+
+	set +f	# re-enable pathname expansion
+
+	export CFLAGS="${NEW_CFLAGS}"
+	export CXXFLAGS="${NEW_CXXFLAGS}"
+	export FFLAGS="${NEW_FFLAGS}"
+	export FCFLAGS="${NEW_FCFLAGS}"
+	return 0
+}
+
+test-flag-PROG() {
+	local comp=$1
+	local flags="$2"
+
+	[[ -z ${comp} || -z ${flags} ]] && \
+		return 1
+
+	local PROG=$(tc-get${comp})
+	${PROG} ${flags} -S -o /dev/null -xc /dev/null \
+		> /dev/null 2>&1
+}
+
+# @FUNCTION: test-flag-CC
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is supported by the C compiler, else returns shell false.
+test-flag-CC() { test-flag-PROG "CC" "$1"; }
+
+# @FUNCTION: test-flag-CXX
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is supported by the C++ compiler, else returns shell false.
+test-flag-CXX() { test-flag-PROG "CXX" "$1"; }
+
+# @FUNCTION: test-flag-F77
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is supported by the Fortran 77 compiler, else returns shell false.
+test-flag-F77() { test-flag-PROG "F77" "$1"; }
+
+# @FUNCTION: test-flag-FC
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Returns shell true if <flag> is supported by the Fortran 90 compiler, else returns shell false.
+test-flag-FC() { test-flag-PROG "FC" "$1"; }
+
+test-flags-PROG() {
+	local comp=$1
+	local flags
+	local x
+
+	shift
+
+	[[ -z ${comp} ]] && return 1
+
+	x=""
+	for x in "$@" ; do
+		test-flag-${comp} "${x}" && flags="${flags}${flags:+ }${x}" || \
+			ewarn "removing ${x} because ${comp} rejected it"
+	done
+
+	echo "${flags}"
+
+	# Just bail if we dont have any flags
+	[[ -n ${flags} ]]
+}
+
+# @FUNCTION: test-flags-CC
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Returns shell true if <flags> are supported by the C compiler, else returns shell false.
+test-flags-CC() { test-flags-PROG "CC" "$@"; }
+
+# @FUNCTION: test-flags-CXX
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Returns shell true if <flags> are supported by the C++ compiler, else returns shell false.
+test-flags-CXX() { test-flags-PROG "CXX" "$@"; }
+
+# @FUNCTION: test-flags-F77
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Returns shell true if <flags> are supported by the Fortran 77 compiler, else returns shell false.
+test-flags-F77() { test-flags-PROG "F77" "$@"; }
+
+# @FUNCTION: test-flags-FC
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Returns shell true if <flags> are supported by the Fortran 90 compiler, else returns shell false.
+test-flags-FC() { test-flags-PROG "FC" "$@"; }
+
+# @FUNCTION: test-flags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Short-hand that should hopefully work for both C and C++ compiler, but
+# its really only present due to the append-flags() abomination.
+test-flags() { test-flags-CC "$@"; }
+
+# @FUNCTION: test_flag
+# @DESCRIPTION:
+# DEPRICIATED, use test-flags()
+test_flag() {
+	ewarn "test_flag: deprecated, please use test-flags()!" >&2
+
+	test-flags-CC "$@"
+}
+
+# @FUNCTION: test_version_info
+# @USAGE: <version>
+# @DESCRIPTION:
+# Returns shell true if the current C compiler version matches <version>, else returns shell false.
+# Accepts shell globs.
+test_version_info() {
+	if [[ $($(tc-getCC) --version 2>&1) == *$1* ]]; then
+		return 0
+	else
+		return 1
+	fi
+}
+
+# @FUNCTION: strip-unsupported-flags
+# @DESCRIPTION:
+# Strip {C,CXX,F,FC}FLAGS of any flags not supported by the active toolchain.
+strip-unsupported-flags() {
+	export CFLAGS=$(test-flags-CC ${CFLAGS})
+	export CXXFLAGS=$(test-flags-CXX ${CXXFLAGS})
+	export FFLAGS=$(test-flags-F77 ${FFLAGS})
+	export FCFLAGS=$(test-flags-FC ${FCFLAGS})
+}
+
+# @FUNCTION: get-flag
+# @USAGE: <flag>
+# @DESCRIPTION:
+# Find and echo the value for a particular flag.  Accepts shell globs.
+get-flag() {
+	local f findflag="$1"
+
+	# this code looks a little flaky but seems to work for
+	# everything we want ...
+	# for example, if CFLAGS="-march=i686":
+	# `get-flag -march` == "-march=i686"
+	# `get-flag march` == "i686"
+	for f in ${CFLAGS} ${CXXFLAGS} ${FFLAGS} ${FCFLAGS} ; do
+		if [ "${f/${findflag}}" != "${f}" ] ; then
+			printf "%s\n" "${f/-${findflag}=}"
+			return 0
+		fi
+	done
+	return 1
+}
+
+# @FUNCTION: has_hardened
+# @DESCRIPTION:
+# DEPRECATED - use gcc-specs-relro or gcc-specs-now from toolchain-funcs
+has_hardened() {
+	ewarn "has_hardened: deprecated, please use gcc-specs-{relro,now}()!" >&2
+
+	test_version_info Hardened && return 0
+	# The specs file wont exist unless gcc has GCC_SPECS support
+	[[ -f ${GCC_SPECS} && ${GCC_SPECS} != ${GCC_SPECS/hardened/} ]]
+}
+
+# @FUNCTION: has_pic
+# @DESCRIPTION:
+# DEPRECATED - use gcc-specs-pie from toolchain-funcs
+# indicate whether PIC is set
+has_pic() {
+	ewarn "has_pic: deprecated, please use gcc-specs-pie()!" >&2
+
+	[[ ${CFLAGS/-fPIC} != ${CFLAGS} || \
+	   ${CFLAGS/-fpic} != ${CFLAGS} ]] || \
+	gcc-specs-pie
+}
+
+# @FUNCTION: has_pie
+# @DESCRIPTION:
+# DEPRECATED - use gcc-specs-pie from toolchain-funcs
+# indicate whether PIE is set
+has_pie() {
+	ewarn "has_pie: deprecated, please use gcc-specs-pie()!" >&2
+
+	[[ ${CFLAGS/-fPIE} != ${CFLAGS} || \
+	   ${CFLAGS/-fpie} != ${CFLAGS} ]] || \
+	gcc-specs-pie
+}
+
+# @FUNCTION: has_ssp_all
+# @DESCRIPTION:
+# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
+# indicate whether code for SSP is being generated for all functions
+has_ssp_all() {
+	ewarn "has_ssp_all: deprecated, please use gcc-specs-ssp()!" >&2
+
+	# note; this matches only -fstack-protector-all
+	[[ ${CFLAGS/-fstack-protector-all} != ${CFLAGS} || \
+	   -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP_ALL__) ]] || \
+	gcc-specs-ssp-to-all
+}
+
+# @FUNCTION: has_ssp
+# @DESCRIPTION:
+# DEPRECATED - use gcc-specs-ssp from toolchain-funcs
+# indicate whether code for SSP is being generated
+has_ssp() {
+	ewarn "has_ssp: deprecated, please use gcc-specs-ssp()!" >&2
+
+	# note; this matches both -fstack-protector and -fstack-protector-all
+	[[ ${CFLAGS/-fstack-protector} != ${CFLAGS} || \
+	   -n $(echo | $(tc-getCC) ${CFLAGS} -E -dM - | grep __SSP__) ]] || \
+	gcc-specs-ssp
+}
+
+# @FUNCTION: has_m64
+# @DESCRIPTION:
+# This doesn't test if the flag is accepted, it tests if the flag actually
+# WORKS. Non-multilib gcc will take both -m32 and -m64. If the flag works
+# return code is 0, else the return code is 1.
+has_m64() {
+	# this doesnt test if the flag is accepted, it tests if the flag
+	# actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
+	# please dont replace this function with test_flag in some future
+	# clean-up!
+
+	local temp="$(emktemp)"
+	echo "int main() { return(0); }" > "${temp}".c
+	MY_CC=$(tc-getCC)
+	${MY_CC/ .*/} -m64 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
+	local ret=$?
+	rm -f "${temp}".c
+	[[ ${ret} != 1 ]] && return 0
+	return 1
+}
+
+# @FUNCTION: has_m32
+# @DESCRIPTION:
+# This doesn't test if the flag is accepted, it tests if the flag actually
+# WORKS. Non-mulilib gcc will take both -m32 and -64. If the flag works return
+# code is 0, else return code is 1.
+has_m32() {
+	# this doesnt test if the flag is accepted, it tests if the flag
+	# actually -WORKS-. non-multilib gcc will take both -m32 and -m64!
+	# please dont replace this function with test_flag in some future
+	# clean-up!
+
+	[ "$(tc-arch)" = "amd64" ] && has_multilib_profile && return 0
+
+	local temp=$(emktemp)
+	echo "int main() { return(0); }" > "${temp}".c
+	MY_CC=$(tc-getCC)
+	${MY_CC/ .*/} -m32 -o "$(emktemp)" "${temp}".c > /dev/null 2>&1
+	local ret=$?
+	rm -f "${temp}".c
+	[[ ${ret} != 1 ]] && return 0
+	return 1
+}
+
+# @FUNCTION: replace-sparc64-flags
+# @DESCRIPTION:
+# Sets mcpu to v8 and uses the original value as mtune if none specified.
+replace-sparc64-flags() {
+	local SPARC64_CPUS="ultrasparc3 ultrasparc v9"
+
+	if [ "${CFLAGS/mtune}" != "${CFLAGS}" ]; then
+		for x in ${SPARC64_CPUS}; do
+			CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8}"
+		done
+	else
+		for x in ${SPARC64_CPUS}; do
+			CFLAGS="${CFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
+		done
+	fi
+
+	if [ "${CXXFLAGS/mtune}" != "${CXXFLAGS}" ]; then
+		for x in ${SPARC64_CPUS}; do
+			CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8}"
+		done
+	else
+		for x in ${SPARC64_CPUS}; do
+			CXXFLAGS="${CXXFLAGS/-mcpu=${x}/-mcpu=v8 -mtune=${x}}"
+		done
+	fi
+
+	export CFLAGS CXXFLAGS
+}
+
+# @FUNCTION: append-libs
+# @USAGE: <libs>
+# @DESCRIPTION:
+# Add extra <libs> to the current LIBS.
+append-libs() {
+	[[ -z $* ]] && return 0
+	local flag
+	for flag in "$@"; do
+		[[ ${flag} == -l* ]] && flag=${flag#-l}
+		export LIBS="${LIBS} -l${flag}"
+	done
+
+	return 0
+}
+
+# @FUNCTION: append-ldflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Add extra <flags> to the current LDFLAGS.
+append-ldflags() {
+	[[ -z $* ]] && return 0
+	local flag
+	for flag in "$@"; do
+		[[ ${flag} == -l* ]] && \
+			ewarn "Appending a library link instruction (${flag}); libraries to link to should not be passed through LDFLAGS"
+	done
+
+	export LDFLAGS="${LDFLAGS} $(test-flags "$@")"
+	return 0
+}
+
+# @FUNCTION: filter-ldflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Remove particular <flags> from LDFLAGS.  Accepts shell globs.
+filter-ldflags() {
+	_filter-var LDFLAGS "$@"
+	return 0
+}
+
+# @FUNCTION: raw-ldflags
+# @USAGE: <flags>
+# @DESCRIPTION:
+# Turn C style ldflags (-Wl,-foo) into straight ldflags - the results
+# are suitable for passing directly to 'ld'; note LDFLAGS is usually passed
+# to gcc where it needs the '-Wl,'.
+raw-ldflags() {
+	local x input="$@"
+	[[ -z ${input} ]] && input=${LDFLAGS}
+	set --
+	for x in ${input} ; do
+		x=${x#-Wl,}
+		set -- "$@" ${x//,/ }
+	done
+	echo "$@"
+}
+
+# @FUNCTION: no-as-needed
+# @RETURN: Flag to disable asneeded behavior for use with append-ldflags.
+no-as-needed() {
+	case $($(tc-getLD) -v 2>&1 </dev/null) in
+		*GNU*) # GNU ld
+		echo "-Wl,--no-as-needed" ;;
+	esac
+}
+
+# Some tests for when we screw with things and want to make
+# sure we didn't break anything
+#TESTS() {
+#	CFLAGS="-a -b -c=1"
+#	CXXFLAGS="-x -y -z=2"
+#	LDFLAGS="-l -m -n=3"
+#
+#	die() { exit 1; }
+#	(is-flag 1 2 3) && die
+#	(is-ldflag 1 2 3) && die
+#
+#	is-flagq -l && die
+#	is-ldflagq -a && die
+#	is-flagq -a || die
+#	is-flagq -x || die
+#	is-ldflagq -n=* || die
+#	is-ldflagq -n && die
+#
+#	strip-unsupported-flags
+#	[[ ${CFLAGS} == "-c=1" ]] || die
+#	[[ ${CXXFLAGS} == "-y -z=2" ]] || die
+#
+#	echo "All tests pass"
+#}
+#TESTS
diff --git a/eclass/gnuconfig.eclass b/eclass/gnuconfig.eclass
new file mode 100644
index 0000000..c681cdf
--- /dev/null
+++ b/eclass/gnuconfig.eclass
@@ -0,0 +1,103 @@
+# Copyright 1999-2006 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/gnuconfig.eclass,v 1.33 2006/06/21 19:35:28 vapier Exp $
+#
+# THIS ECLASS IS DEAD: It has been integrated into portage
+#
+# Author: Will Woods <wwoods@gentoo.org>
+#
+# This eclass is used to automatically update files that typically come with
+# automake to the newest version available on the system. The most common use
+# of this is to update config.guess and config.sub when configure dies from
+# misguessing your canonical system name (CHOST). It can also be used to update
+# other files that come with automake, e.g. depcomp, mkinstalldirs, etc.
+#
+# usage: gnuconfig_update [file1 file2 ...]
+# if called without arguments, config.guess and config.sub will be updated.
+# All files in the source tree ($S) with the given name(s) will be replaced
+# with the newest available versions chosen from the list of locations in
+# gnuconfig_findnewest(), below.
+#
+# gnuconfig_update should generally be called from src_unpack()
+
+
+DEPEND="sys-devel/gnuconfig"
+
+DESCRIPTION="Based on the ${ECLASS} eclass"
+
+# Wrapper function for gnuconfig_do_update. If no arguments are given, update
+# config.sub and config.guess (old default behavior), otherwise update the
+# named files.
+gnuconfig_update() {
+
+# hmm some packages (like binutils gcc glibc) still use this ...
+#	echo
+#	ewarn "QA Notice: Please stop using me, portage updates files for you."
+#	echo
+
+	local startdir	# declared here ... used in gnuconfig_do_update
+
+	if [[ $1 == /* ]] ; then
+		startdir=$1
+		shift
+	else
+		startdir=${S}
+	fi
+
+	if [[ $# -gt 0 ]] ; then
+		gnuconfig_do_update "$@"
+	else
+		gnuconfig_do_update config.sub config.guess
+	fi
+
+	return $?
+}
+
+# Copy the newest available version of specified files over any old ones in the
+# source dir. This function shouldn't be called directly - use gnuconfig_update
+#
+# Note that since bash using dynamic scoping, startdir is available here from
+# the gnuconfig_update function
+gnuconfig_do_update() {
+	local configsubs_dir target targetlist file
+
+	[[ $# -eq 0 ]] && die "do not call gnuconfig_do_update; use gnuconfig_update"
+
+	configsubs_dir=$(gnuconfig_findnewest)
+	einfo "Using GNU config files from ${configsubs_dir}"
+	for file in "$@" ; do
+		if [[ ! -r ${configsubs_dir}/${file} ]] ; then
+			eerror "Can't read ${configsubs_dir}/${file}, skipping.."
+			continue
+		fi
+		targetlist=$(find "${startdir}" -name "${file}")
+		if [[ -n ${targetlist} ]] ; then
+			for target in ${targetlist} ; do
+				[[ -L ${target} ]] && rm -f "${target}"
+				einfo "  Updating ${target/$startdir\//}"
+				cp -f "${configsubs_dir}/${file}" "${target}"
+				eend $?
+			done
+		else
+			ewarn "  No ${file} found in ${startdir}, skipping ..."
+		fi
+	done
+
+	return 0
+}
+
+# this searches the standard locations for the newest config.{sub|guess}, and
+# returns the directory where they can be found.
+gnuconfig_findnewest() {
+	local locations="
+		${EPREFIX}/usr/share/gnuconfig/config.sub
+		${EPREFIX}/usr/share/automake-1.9/config.sub
+		${EPREFIX}/usr/share/automake-1.8/config.sub
+		${EPREFIX}/usr/share/automake-1.7/config.sub
+		${EPREFIX}/usr/share/automake-1.6/config.sub
+		${EPREFIX}/usr/share/automake-1.5/config.sub
+		${EPREFIX}/usr/share/automake-1.4/config.sub
+		${EPREFIX}/usr/share/libtool/config.sub
+	"
+	grep -s '^timestamp' ${locations} | sort -n -t\' -k2 | tail -n 1 | sed 's,/config.sub:.*$,,'
+}
diff --git a/eclass/libtool.eclass b/eclass/libtool.eclass
new file mode 100644
index 0000000..f248ac6
--- /dev/null
+++ b/eclass/libtool.eclass
@@ -0,0 +1,466 @@
+# Copyright 1999-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/libtool.eclass,v 1.90 2010/08/22 22:44:45 vapier Exp $
+
+# @ECLASS: libtool.eclass
+# @MAINTAINER:
+# base-system@gentoo.org
+# @BLURB: quickly update bundled libtool code
+# @DESCRIPTION:
+# This eclass patches ltmain.sh distributed with libtoolized packages with the
+# relink and portage patch among others
+#
+# Note, this eclass does not require libtool as it only applies patches to
+# generated libtool files.  We do not run the libtoolize program because that
+# requires a regeneration of the main autotool files in order to work properly.
+
+DESCRIPTION="Based on the ${ECLASS} eclass"
+
+inherit toolchain-funcs
+
+ELT_PATCH_DIR="${ECLASSDIR}/ELT-patches"
+
+#
+# See if we can apply $2 on $1, and if so, do it
+#
+ELT_try_and_apply_patch() {
+	local ret=0
+	local file=$1
+	local patch=$2
+
+	# We only support patchlevel of 0 - why worry if its static patches?
+	if patch -p0 --dry-run "${file}" "${patch}" &> "${T}/elibtool.log" ; then
+		einfo "  Applying $(basename "$(dirname "${patch}")")-${patch##*/}.patch ..."
+		patch -p0 -g0 --no-backup-if-mismatch "${file}" "${patch}" \
+			&> "${T}/elibtool.log"
+		ret=$?
+		export ELT_APPLIED_PATCHES="${ELT_APPLIED_PATCHES} ${patch##*/}"
+	else
+		ret=1
+	fi
+
+	return "${ret}"
+}
+
+#
+# Get string version of ltmain.sh or ltconfig (passed as $1)
+#
+ELT_libtool_version() {
+	(
+	unset VERSION
+	eval $(grep -e '^[[:space:]]*VERSION=' "$1")
+	echo "${VERSION:-0}"
+	)
+}
+
+#
+# Run through the patches in $2 and see if any
+# apply to $1 ...
+#
+ELT_walk_patches() {
+	local patch
+	local ret=1
+	local file=$1
+	local patch_set=$2
+	local patch_dir="${ELT_PATCH_DIR}/${patch_set}"
+	local rem_int_dep=$3
+
+	[[ -z ${patch_set} ]] && return 1
+	[[ ! -d ${patch_dir} ]] && return 1
+
+	pushd "${ELT_PATCH_DIR}" >/dev/null
+
+	# Go through the patches in reverse order (newer version to older)
+	for patch in $(find "${patch_set}" -maxdepth 1 -type f | LC_ALL=C sort -r) ; do
+		# For --remove-internal-dep ...
+		if [[ -n ${rem_int_dep} ]] ; then
+			# For replace @REM_INT_DEP@ with what was passed
+			# to --remove-internal-dep
+			local tmp="${T}/$$.rem_int_deps.patch"
+			sed -e "s|@REM_INT_DEP@|${rem_int_dep}|g" "${patch}" > "${tmp}"
+			patch=${tmp}
+		fi
+
+		if ELT_try_and_apply_patch "${file}" "${patch}" ; then
+			# Break to unwind w/popd rather than return directly
+			ret=0
+			break
+		fi
+	done
+
+	popd >/dev/null
+	return ${ret}
+}
+
+# @FUNCTION: elibtoolize
+# @USAGE: [dirs] [--portage] [--reverse-deps] [--patch-only] [--remove-internal-dep=xxx] [--shallow] [--no-uclibc]
+# @DESCRIPTION:
+# Apply a smorgasbord of patches to bundled libtool files.  This function
+# should always be safe to run.  If no directories are specified, then
+# ${S} will be searched for appropriate files.
+#
+# If the --shallow option is used, then only ${S}/ltmain.sh will be patched.
+#
+# The other options should be avoided in general unless you know what's going on.
+elibtoolize() {
+	local x
+	local do_portage="no"
+	local do_reversedeps="no"
+	local do_only_patches="no"
+	local do_uclibc="yes"
+	local do_force="no"
+	local deptoremove=
+	local do_shallow="no"
+	local elt_patches="install-sh ltmain portage relink max_cmd_len sed test tmp cross as-needed"
+
+	for x in "$@" ; do
+		case ${x} in
+			--portage)
+				# Only apply portage patch, and don't
+				# 'libtoolize --copy --force' if all patches fail.
+				do_portage="yes"
+				;;
+			--reverse-deps)
+				# Apply the reverse-deps patch
+				# http://bugzilla.gnome.org/show_bug.cgi?id=75635
+				do_reversedeps="yes"
+				elt_patches+=" fix-relink"
+				;;
+			--patch-only)
+				# Do not run libtoolize if none of the patches apply ..
+				do_only_patches="yes"
+				;;
+			--remove-internal-dep=*)
+				# We will replace @REM_INT_DEP@ with what is needed
+				# in ELT_walk_patches() ...
+				deptoremove=${x#--remove-internal-dep=}
+
+				# Add the patch for this ...
+				[[ -n ${deptoremove} ]] && elt_patches+=" rem-int-dep"
+				;;
+			--shallow)
+				# Only patch the ltmain.sh in ${S}
+				do_shallow="yes"
+				;;
+			--no-uclibc)
+				do_uclibc="no"
+				;;
+			"--force")
+				do_force="yes"
+				;;
+			*)
+				eerror "Invalid elibtoolize option: ${x}"
+				die "elibtoolize called with ${x} ??"
+		esac
+	done
+
+	[[ ${do_uclibc} == "yes" ]] && elt_patches+=" uclibc-conf uclibc-ltconf"
+
+	case ${CHOST} in
+		*-aix*)     elt_patches+=" hardcode aixrtl aix-noundef" ;; #213277
+		*-darwin*)  elt_patches+=" darwin-ltconf darwin-ltmain darwin-conf" ;;
+		*-freebsd*) elt_patches+=" fbsd-conf fbsd-ltconf" ;;
+		*-hpux*)    elt_patches+=" hpux-conf deplibs hc-flag-ld hardcode hardcode-relink relink-prog no-lc" ;;
+		*-irix*)    elt_patches+=" irix-ltmain" ;;
+		*-mint*)    elt_patches+=" mint-conf" ;;
+	esac
+
+	# Reuse "$@" for dirs to patch
+	set --
+	if [[ ${do_shallow} == "yes" ]] ; then
+		[[ -f ${S}/ltmain.sh ]] && set -- "${S}"
+	else
+		set -- $(find "${S}" -name ltmain.sh -printf '%h ')
+	fi
+
+	local d p
+	for d in "$@" ; do
+		export ELT_APPLIED_PATCHES=
+
+		[[ ${do_force} == no && -f ${d}/.elibtoolized ]] && continue
+
+		einfo "Running elibtoolize in: ${d#${WORKDIR}/}/"
+
+		for p in ${elt_patches} ; do
+			local ret=0
+
+			case ${p} in
+				portage)
+					# Stupid test to see if its already applied ...
+					if ! grep -qs 'We do not want portage' "${d}/ltmain.sh" ; then
+						ELT_walk_patches "${d}/ltmain.sh" "${p}"
+						ret=$?
+					fi
+					;;
+				rem-int-dep)
+					ELT_walk_patches "${d}/ltmain.sh" "${p}" "${deptoremove}"
+					ret=$?
+					;;
+				fix-relink)
+					# Do not apply if we do not have the relink patch applied ...
+					if grep -qs 'inst_prefix_dir' "${d}/ltmain.sh" ; then
+						ELT_walk_patches "${d}/ltmain.sh" "${p}"
+						ret=$?
+					fi
+					;;
+				max_cmd_len)
+					# Do not apply if $max_cmd_len is not used ...
+					if grep -qs 'max_cmd_len' "${d}/ltmain.sh" ; then
+						ELT_walk_patches "${d}/ltmain.sh" "${p}"
+						ret=$?
+					fi
+					;;
+				as-needed)
+					ELT_walk_patches "${d}/ltmain.sh" "${p}"
+					ret=$?
+					;;
+				uclibc-conf)
+					if grep -qs 'Transform linux' "${d}/configure" ; then
+						ELT_walk_patches "${d}/configure" "${p}"
+						ret=$?
+					# ltmain.sh and co might be in a subdirectory ...
+					elif [[ ! -e ${d}/configure ]] && \
+					     grep -qs 'Transform linux' "${d}/../configure" ; then
+						ELT_walk_patches "${d}/../configure" "${p}"
+						ret=$?
+					fi
+					;;
+				uclibc-ltconf)
+					# Newer libtoolize clears ltconfig, as not used anymore
+					if [[ -s ${d}/ltconfig ]] ; then
+						ELT_walk_patches "${d}/ltconfig" "${p}"
+						ret=$?
+					fi
+					;;
+				fbsd-conf)
+					if grep -qs 'version_type=freebsd-' "${d}/configure" ; then
+						ELT_walk_patches "${d}/configure" "${p}"
+						ret=$?
+					# ltmain.sh and co might be in a subdirectory ...
+					elif [[ ! -e ${d}/configure ]] && \
+					     grep -qs 'version_type=freebsd-' "${d}/../configure" ; then
+						ELT_walk_patches "${d}/../configure" "${p}"
+						ret=$?
+					fi
+					;;
+				fbsd-ltconf)
+					if [[ -s ${d}/ltconfig ]] ; then
+						ELT_walk_patches "${d}/ltconfig" "${p}"
+						ret=$?
+					fi
+					;;
+				darwin-conf)
+					if grep -qs '&& echo \.so ||' "${d}/configure" ; then
+						ELT_walk_patches "${d}/configure" "${p}"
+						ret=$?
+					# ltmain.sh and co might be in a subdirectory ...
+					elif [[ ! -e ${d}/configure ]] && \
+					     grep -qs '&& echo \.so ||' "${d}/../configure" ; then
+						ELT_walk_patches "${d}/../configure" "${p}"
+						ret=$?
+					fi
+					;;
+				darwin-ltconf)
+					# Newer libtoolize clears ltconfig, as not used anymore
+					if [[ -s ${d}/ltconfig ]] ; then
+						ELT_walk_patches "${d}/ltconfig" "${p}"
+						ret=$?
+					fi
+					;;
+				darwin-ltmain)
+					# special case to avoid false positives (failing to apply
+					# ltmain.sh path message), newer libtools have this patch
+					# built in, so not much to patch around then
+					if [[ -e ${d}/ltmain.sh ]] && \
+					   ! grep -qs 'verstring="-compatibility_version' "${d}/ltmain.sh" ; then
+						ELT_walk_patches "${d}/ltmain.sh" "${p}"
+						ret=$?
+					fi
+					;;
+				aixrtl|hpux-conf)
+					ret=1
+					local subret=0
+					# apply multiple patches as often as they match
+					while [[ $subret -eq 0 ]]; do
+						subret=1
+						if [[ -e ${d}/configure ]]; then
+							ELT_walk_patches "${d}/configure" "${p}"
+							subret=$?
+						# ltmain.sh and co might be in a subdirectory ...
+						elif [[ ! -e ${d}/configure && -e ${d}/../configure ]] ; then
+							ELT_walk_patches "${d}/../configure" "${p}"
+							subret=$?
+						fi
+						if [[ $subret -eq 0 ]]; then
+							# have at least one patch succeeded.
+							ret=0
+						fi
+					done
+					;;
+				mint-conf)
+					ret=1
+					local subret=1
+					if [[ -e ${d}/configure ]]; then
+						ELT_walk_patches "${d}/configure" "${p}"
+						subret=$?
+					# ltmain.sh and co might be in a subdirectory ...
+					elif [[ ! -e ${d}/configure && -e ${d}/../configure ]] ; then
+						ELT_walk_patches "${d}/../configure" "${p}"
+						subret=$?
+					fi
+					if [[ $subret -eq 0 ]]; then
+						# have at least one patch succeeded.
+						ret=0
+					fi
+					;;
+				install-sh)
+					ELT_walk_patches "${d}/install-sh" "${p}"
+					ret=$?
+					;;
+				cross)
+					if tc-is-cross-compiler ; then
+						ELT_walk_patches "${d}/ltmain.sh" "${p}"
+						ret=$?
+					fi
+					;;
+				*)
+					ELT_walk_patches "${d}/ltmain.sh" "${p}"
+					ret=$?
+					;;
+			esac
+
+			if [[ ${ret} -ne 0 ]] ; then
+				case ${p} in
+					relink)
+						local version=$(ELT_libtool_version "${d}/ltmain.sh")
+						# Critical patch, but could be applied ...
+						# FIXME:  Still need a patch for ltmain.sh > 1.4.0
+						if ! grep -qs 'inst_prefix_dir' "${d}/ltmain.sh" && \
+						   [[ $(VER_to_int "${version}") -ge $(VER_to_int "1.4.0") ]] ; then
+							ewarn "  Could not apply relink.patch!"
+						fi
+						;;
+					portage)
+						# Critical patch - for this one we abort, as it can really
+						# cause breakage without it applied!
+						if [[ ${do_portage} == "yes" ]] ; then
+							# Stupid test to see if its already applied ...
+							if ! grep -qs 'We do not want portage' "${d}/ltmain.sh" ; then
+								echo
+								eerror "Portage patch requested, but failed to apply!"
+								eerror "Please file a bug report to add a proper patch."
+								die "Portage patch requested, but failed to apply!"
+							fi
+						else
+							if grep -qs 'We do not want portage' "${d}/ltmain.sh" ; then
+							#	ewarn "  Portage patch seems to be already applied."
+							#	ewarn "  Please verify that it is not needed."
+								:
+							else
+							    local version=$(ELT_libtool_version "${d}"/ltmain.sh)
+								echo
+								eerror "Portage patch failed to apply (ltmain.sh version ${version})!"
+								eerror "Please file a bug report to add a proper patch."
+								die "Portage patch failed to apply!"
+							fi
+							# We do not want to run libtoolize ...
+							ELT_APPLIED_PATCHES="portage"
+						fi
+						;;
+					uclibc-*)
+						[[ ${CHOST} == *-uclibc ]] && ewarn "  uClibc patch set '${p}' failed to apply!"
+						;;
+					fbsd-*)
+						if [[ ${CHOST} == *-freebsd* ]] ; then
+							if [[ -z $(grep 'Handle Gentoo/FreeBSD as it was Linux' \
+								"${d}/configure" "${d}/../configure" 2>/dev/null) ]]; then
+								eerror "  FreeBSD patch set '${p}' failed to apply!"
+								die "FreeBSD patch set '${p}' failed to apply!"
+							fi
+						fi
+						;;
+					darwin-*)
+						[[ ${CHOST} == *"-darwin"* ]] && ewarn "  Darwin patch set '${p}' failed to apply!"
+						;;
+				esac
+			fi
+		done
+
+		if [[ -z ${ELT_APPLIED_PATCHES} ]] ; then
+			if [[ ${do_portage} == "no" && \
+				  ${do_reversedeps} == "no" && \
+				  ${do_only_patches} == "no" && \
+				  ${deptoremove} == "" ]]
+			then
+				ewarn "Cannot apply any patches, please file a bug about this"
+				die
+			fi
+		fi
+
+		rm -f "${d}/libtool"
+
+		> "${d}/.elibtoolized"
+	done
+}
+
+uclibctoolize() { die "Use elibtoolize"; }
+darwintoolize() { die "Use elibtoolize"; }
+
+# char *VER_major(string)
+#
+#    Return the Major (X of X.Y.Z) version
+#
+VER_major() {
+	[[ -z $1 ]] && return 1
+
+	local VER=$@
+	echo "${VER%%[^[:digit:]]*}"
+}
+
+# char *VER_minor(string)
+#
+#    Return the Minor (Y of X.Y.Z) version
+#
+VER_minor() {
+	[[ -z $1 ]] && return 1
+
+	local VER=$@
+	VER=${VER#*.}
+	echo "${VER%%[^[:digit:]]*}"
+}
+
+# char *VER_micro(string)
+#
+#    Return the Micro (Z of X.Y.Z) version.
+#
+VER_micro() {
+	[[ -z $1 ]] && return 1
+
+	local VER=$@
+	VER=${VER#*.*.}
+	echo "${VER%%[^[:digit:]]*}"
+}
+
+# int VER_to_int(string)
+#
+#    Convert a string type version (2.4.0) to an int (132096)
+#    for easy compairing or versions ...
+#
+VER_to_int() {
+	[[ -z $1 ]] && return 1
+
+	local VER_MAJOR=$(VER_major "$1")
+	local VER_MINOR=$(VER_minor "$1")
+	local VER_MICRO=$(VER_micro "$1")
+	local VER_int=$(( VER_MAJOR * 65536 + VER_MINOR * 256 + VER_MICRO ))
+
+	# We make version 1.0.0 the minimum version we will handle as
+	# a sanity check ... if its less, we fail ...
+	if [[ ${VER_int} -ge 65536 ]] ; then
+		echo "${VER_int}"
+		return 0
+	fi
+
+	echo 1
+	return 1
+}
diff --git a/eclass/multilib.eclass b/eclass/multilib.eclass
new file mode 100644
index 0000000..3a5ab6f
--- /dev/null
+++ b/eclass/multilib.eclass
@@ -0,0 +1,455 @@
+# Copyright 1999-2011 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/multilib.eclass,v 1.90 2011/03/18 22:03:25 vapier Exp $
+
+# @ECLASS: multilib.eclass
+# @MAINTAINER:
+# amd64@gentoo.org
+# toolchain@gentoo.org
+# @BLURB: This eclass is for all functions pertaining to handling multilib configurations.
+# @DESCRIPTION:
+# This eclass is for all functions pertaining to handling multilib configurations.
+
+___ECLASS_RECUR_MULTILIB="yes"
+[[ -z ${___ECLASS_RECUR_TOOLCHAIN_FUNCS} ]] && inherit toolchain-funcs
+
+# Defaults:
+export MULTILIB_ABIS=${MULTILIB_ABIS:-"default"}
+export DEFAULT_ABI=${DEFAULT_ABI:-"default"}
+export CFLAGS_default
+export LDFLAGS_default
+export CHOST_default=${CHOST_default:-${CHOST}}
+export CTARGET_default=${CTARGET_default:-${CTARGET:-${CHOST_default}}}
+export LIBDIR_default=${CONF_LIBDIR:-"lib"}
+export KERNEL_ABI=${KERNEL_ABI:-${DEFAULT_ABI}}
+
+# @FUNCTION: has_multilib_profile
+# @DESCRIPTION:
+# Return true if the current profile is a multilib profile and lists more than
+# one abi in ${MULTILIB_ABIS}.  When has_multilib_profile returns true, that
+# profile should enable the 'multilib' use flag. This is so you can DEPEND on
+# a package only for multilib or not multilib.
+has_multilib_profile() {
+	[ -n "${MULTILIB_ABIS}" -a "${MULTILIB_ABIS}" != "${MULTILIB_ABIS/ /}" ]
+}
+
+# @FUNCTION: get_libdir
+# @RETURN: the libdir for the selected ABI
+# @DESCRIPTION:
+# This function simply returns the desired lib directory. With portage
+# 2.0.51, we now have support for installing libraries to lib32/lib64
+# to accomidate the needs of multilib systems. It's no longer a good idea
+# to assume all libraries will end up in lib. Replace any (sane) instances
+# where lib is named directly with $(get_libdir) if possible.
+#
+# Jeremy Huddleston <eradicator@gentoo.org> (23 Dec 2004):
+#   Added support for ${ABI} and ${DEFAULT_ABI}.  If they're both not set,
+#   fall back on old behavior.  Any profile that has these set should also
+#   depend on a newer version of portage (not yet released) which uses these
+#   over CONF_LIBDIR in econf, dolib, etc...
+get_libdir() {
+	local CONF_LIBDIR
+	if [ -n  "${CONF_LIBDIR_OVERRIDE}" ] ; then
+		# if there is an override, we want to use that... always.
+		echo ${CONF_LIBDIR_OVERRIDE}
+	else
+		get_abi_LIBDIR
+	fi
+}
+
+# @FUNCTION: get_multilibdir
+# @RETURN: Returns the multilibdir
+get_multilibdir() {
+	if has_multilib_profile; then
+		eerror "get_multilibdir called, but it shouldn't be needed with the new multilib approach.  Please file a bug at http://bugs.gentoo.org and assign it to eradicator@gentoo.org"
+		exit 1
+	fi
+	echo ${CONF_MULTILIBDIR:=lib32}
+}
+
+# @FUNCTION: get_libdir_override
+# @DESCRIPTION:
+# Sometimes you need to override the value returned by get_libdir. A good
+# example of this is xorg-x11, where lib32 isnt a supported configuration,
+# and where lib64 -must- be used on amd64 (for applications that need lib
+# to be 32bit, such as adobe acrobat). Note that this override also bypasses
+# portage version sanity checking.
+# get_libdir_override expects one argument, the result get_libdir should
+# return:
+#
+#   get_libdir_override lib64
+get_libdir_override() {
+	if has_multilib_profile; then
+		eerror "get_libdir_override called, but it shouldn't be needed with the new multilib approach.  Please file a bug at http://bugs.gentoo.org and assign it to eradicator@gentoo.org"
+		exit 1
+	fi
+	CONF_LIBDIR="$1"
+	CONF_LIBDIR_OVERRIDE="$1"
+	LIBDIR_default="$1"
+}
+
+# @FUNCTION: get_abi_var
+# @USAGE: <VAR> [ABI]
+# @RETURN: returns the value of ${<VAR>_<ABI>} which should be set in make.defaults
+# @DESCRIPTION:
+# ex:
+# CFLAGS=$(get_abi_var CFLAGS sparc32) # CFLAGS=-m32
+#
+# Note that the prefered method is to set CC="$(tc-getCC) $(get_abi_CFLAGS)"
+# This will hopefully be added to portage soon...
+#
+# If <ABI> is not specified, ${ABI} is used.
+# If <ABI> is not specified and ${ABI} is not defined, ${DEFAULT_ABI} is used.
+# If <ABI> is not specified and ${ABI} and ${DEFAULT_ABI} are not defined, we return an empty string.
+get_abi_var() {
+	local flag=$1
+	local abi
+	if [ $# -gt 1 ]; then
+		abi=${2}
+	elif [ -n "${ABI}" ]; then
+		abi=${ABI}
+	elif [ -n "${DEFAULT_ABI}" ]; then
+		abi=${DEFAULT_ABI}
+	else
+		abi="default"
+	fi
+
+	local var="${flag}_${abi}"
+	echo ${!var}
+}
+
+# @FUNCTION: get_abi_CFLAGS
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var CFLAGS'
+get_abi_CFLAGS() { get_abi_var CFLAGS "$@"; }
+
+# @FUNCTION: get_abi_ASFLAGS
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var ASFLAGS'
+get_abi_ASFLAGS() { get_abi_var ASFLAGS "$@"; }
+
+# @FUNCTION: get_abi_LDFLAGS
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var LDFLAGS'
+get_abi_LDFLAGS() { get_abi_var LDFLAGS "$@"; }
+
+# @FUNCTION: get_abi_CHOST
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var CHOST'
+get_abi_CHOST() { get_abi_var CHOST "$@"; }
+
+# @FUNCTION: get_abi_CTARGET
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var CTARGET'
+get_abi_CTARGET() { get_abi_var CTARGET "$@"; }
+
+# @FUNCTION: get_abi_FAKE_TARGETS
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var FAKE_TARGETS'
+get_abi_FAKE_TARGETS() { get_abi_var FAKE_TARGETS "$@"; }
+
+# @FUNCTION: get_abi_LIBDIR
+# @USAGE: [ABI]
+# @DESCRIPTION:
+# Alias for 'get_abi_var LIBDIR'
+get_abi_LIBDIR() { get_abi_var LIBDIR "$@"; }
+
+# @FUNCTION: get_install_abis
+# @DESCRIPTION:
+# Return a list of the ABIs we want to install for with
+# the last one in the list being the default.
+get_install_abis() {
+	local 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
+				hasq ${x} ${ABI_DENY} || order="${order} ${x}"
+			fi
+		done
+		hasq ${DEFAULT_ABI} ${ABI_DENY} || order="${order} ${DEFAULT_ABI}"
+
+		if [[ -n ${ABI_ALLOW} ]] ; then
+			local ordera=""
+			for x in ${order} ; do
+				if hasq ${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
+}
+
+# @FUNCTION: get_all_abis
+# @DESCRIPTION: 
+# Return a list of the ABIs supported by this profile.
+# the last one in the list being the default.
+get_all_abis() {
+	local order=""
+
+	if [[ -z ${MULTILIB_ABIS} ]] ; then
+		echo "default"
+		return 0
+	fi
+
+	for x in ${MULTILIB_ABIS}; do
+		if [[ ${x} != ${DEFAULT_ABI} ]] ; then
+			order="${order:+${order} }${x}"
+		fi
+	done
+	order="${order:+${order} }${DEFAULT_ABI}"
+
+	echo ${order}
+	return 0
+}
+
+# @FUNCTION: get_all_libdirs
+# @DESCRIPTION:
+# Returns a list of all the libdirs used by this profile.  This includes
+# those that might not be touched by the current ebuild and always includes
+# "lib".
+get_all_libdirs() {
+	local libdirs
+	local abi
+	local dir
+
+	for abi in ${MULTILIB_ABIS}; do
+		libdirs+=" $(get_abi_LIBDIR ${abi})"
+	done
+	[[ " ${libdirs} " != *" lib "* ]] && libdirs+=" lib"
+
+	echo "${libdirs}"
+}
+
+# @FUNCTION: is_final_abi
+# @DESCRIPTION:
+# Return true if ${ABI} is the last ABI on our list (or if we're not
+# using the new multilib configuration.  This can be used to determine
+# if we're in the last (or only) run through src_{unpack,compile,install}
+is_final_abi() {
+	has_multilib_profile || return 0
+	set -- $(get_install_abis)
+	local LAST_ABI=$#
+	[[ ${!LAST_ABI} == ${ABI} ]]
+}
+
+# @FUNCTION: number_abis
+# @DESCRIPTION:
+# echo the number of ABIs we will be installing for
+number_abis() {
+	set -- `get_install_abis`
+	echo $#
+}
+
+# @FUNCTION: get_libname
+# @USAGE: [version]
+# @DESCRIPTION:
+# Returns libname with proper suffix {.so,.dylib,.dll,etc} and optionally
+# supplied version for the current platform identified by CHOST.
+#
+# Example:
+#     get_libname ${PV}
+#     Returns: .so.${PV} (ELF) || .${PV}.dylib (MACH) || ...
+get_libname() {
+	local libname
+	local ver=$1
+	case ${CHOST} in
+		*-cygwin|mingw*|*-mingw*) libname="dll";;
+		*-darwin*)                libname="dylib";;
+		*-mint*)                  libname="irrelevant";;
+		hppa*-hpux*)              libname="sl";;
+		*)                        libname="so";;
+	esac
+
+	if [[ -z $* ]] ; then
+		echo ".${libname}"
+	else
+		for ver in "$@" ; do
+			case ${CHOST} in
+				*-darwin*) echo ".${ver}.${libname}";;
+				*-mint*)   echo ".${libname}";;
+				*)         echo ".${libname}.${ver}";;
+			esac
+		done
+	fi
+}
+
+# @FUNCTION: get_modname
+# @USAGE:
+# @DESCRIPTION:
+# Returns modulename with proper suffix {.so,.bundle,etc} for the current
+# platform identified by CHOST.
+#
+# Example:
+#     libfoo$(get_modname)
+#     Returns: libfoo.so (ELF) || libfoo.bundle (MACH) || ...
+get_modname() {
+	local modname
+	local ver=$1
+	case ${CHOST} in
+		*-darwin*)                modname="bundle";;
+		*)                        modname="so";;
+	esac
+
+	echo ".${modname}"
+}
+
+# This is for the toolchain to setup profile variables when pulling in
+# a crosscompiler (and thus they aren't set in the profile)
+multilib_env() {
+	local CTARGET=${1:-${CTARGET}}
+
+	case ${CTARGET} in
+		x86_64*)
+			export CFLAGS_x86=${CFLAGS_x86--m32}
+			export CHOST_x86=${CTARGET/x86_64/i686}
+			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}
+			export CTARGET_amd64=${CHOST_amd64}
+			export LIBDIR_amd64="lib64"
+
+			export CFLAGS_x32=${CFLAGS_x32--mx32}
+			export CHOST_x32=${CTARGET}
+			export CTARGET_x32=${CHOST_x32}
+			export LIBDIR_x32="libx32"
+
+			: ${MULTILIB_ABIS=amd64 x86}
+			: ${DEFAULT_ABI=amd64}
+		;;
+		mips64*)
+			export CFLAGS_o32=${CFLAGS_o32--mabi=32}
+			export CHOST_o32=${CTARGET/mips64/mips}
+			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}
+		;;
+		s390x*)
+			export CFLAGS_s390=${CFLAGS_s390--m31} # the 31 is not a typo
+			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}
+		;;
+		sparc*)
+			export CFLAGS_sparc32=${CFLAGS_sparc32}
+			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
+}
+
+# @FUNCTION: multilib_toolchain_setup
+# @DESCRIPTION:
+# Hide multilib details here for packages which are forced to be compiled for a
+# specific ABI when run on another ABI (like x86-specific packages on amd64)
+multilib_toolchain_setup() {
+	local v vv
+
+	export ABI=$1
+
+	# First restore any saved state we have laying around.
+	if [[ ${__DEFAULT_ABI_SAVED} == "true" ]] ; then
+		for v in CHOST CBUILD AS CC CXX LD ; do
+			vv="__abi_saved_${v}"
+			export ${v}="${!vv}"
+			unset ${vv}
+		done
+		unset __DEFAULT_ABI_SAVED
+	fi
+
+	# We want to avoid the behind-the-back magic of gcc-config as it
+	# screws up ccache and distcc.  See #196243 for more info.
+	if [[ ${ABI} != ${DEFAULT_ABI} ]] ; then
+		# Back that multilib-ass up so we can restore it later
+		for v in CHOST CBUILD AS CC CXX LD ; do
+			export __abi_saved_${v}="${!v}"
+		done
+		export __DEFAULT_ABI_SAVED="true"
+
+		# Set the CHOST native first so that we pick up the native
+		# toolchain and not a cross-compiler by accident #202811.
+		export CHOST=$(get_abi_CHOST ${DEFAULT_ABI})
+		export AS="$(tc-getAS) $(get_abi_ASFLAGS)"
+		export CC="$(tc-getCC) $(get_abi_CFLAGS)"
+		export CXX="$(tc-getCXX) $(get_abi_CFLAGS)"
+		export LD="$(tc-getLD) $(get_abi_LDFLAGS)"
+		export CHOST=$(get_abi_CHOST $1)
+		export CBUILD=$(get_abi_CHOST $1)
+	fi
+}
diff --git a/eclass/portability.eclass b/eclass/portability.eclass
new file mode 100644
index 0000000..3269a3c
--- /dev/null
+++ b/eclass/portability.eclass
@@ -0,0 +1,183 @@
+# Copyright 1999-2005 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/portability.eclass,v 1.17 2010/09/24 14:29:49 vapier Exp $
+#
+# Author: Diego Pettenò <flameeyes@gentoo.org>
+#
+# This eclass is created to avoid using non-portable GNUisms inside ebuilds
+#
+# NB:  If you add anything, please comment it!
+
+# treecopy orig1 orig2 orig3 .... dest
+#
+# mimic cp --parents copy, but working on BSD userland as well
+treecopy() {
+	dest=${!#}
+	files_count=$#
+
+	while(( $# > 1 )); do
+		dirstruct=$(dirname "$1")
+		mkdir -p "${dest}/${dirstruct}"
+		cp -pPR "$1" "${dest}/${dirstruct}"
+
+		shift
+	done
+}
+
+# seq min max
+#
+# compatibility function that mimes seq command if not available
+seq() {
+	# First try `seq`
+	local p=$(type -P seq)
+	if [[ -n ${p} ]] ; then
+		"${p}" "$@"
+		return $?
+	fi
+
+	case $# in
+		1) min=1  max=$1 step=1  ;;
+		2) min=$1 max=$2 step=1  ;;
+		3) min=$1 max=$3 step=$2 ;;
+		*) die "seq called with wrong number of arguments" ;;
+	esac
+
+	# Then try `jot`
+	p=$(type -P jot)
+	if [[ -n ${p} ]] ; then
+		local reps
+		# BSD userland
+		if [[ ${step} != 0 ]] ; then
+			reps=$(( (max - min) / step + 1 ))
+		else
+			reps=0
+		fi
+
+		jot $reps $min $max $step
+		return $?
+	fi
+
+	# Screw it, do the output ourselves
+	while :; do
+		[[ $max < $min && $step > 0 ]] && break
+		[[ $min < $max && $step < 0 ]] && break
+		echo $min
+		: $(( min += step ))
+	done
+	return 0
+}
+
+# Gets the linker flag to link to dlopen() function
+dlopen_lib() {
+	# - Solaris needs nothing
+	# - Darwin needs nothing
+	# - *BSD needs nothing
+	# - Linux needs -ldl (glibc and uclibc)
+	# - Interix needs -ldl
+	case "${CHOST}" in
+		*-linux-gnu*|*-linux-uclibc|*-interix*)
+			echo "-ldl"
+		;;
+	esac
+}
+
+# Gets the home directory for the specified user
+# it's a wrap around egetent as the position of the home directory in the line
+# varies depending on the os used.
+#
+# To use that, inherit eutils, not portability!
+egethome() {
+	ent=$(egetent passwd $1)
+
+	case ${CHOST} in
+	*-darwin*|*-freebsd*|*-dragonfly*)
+		# Darwin, OSX, FreeBSD and DragonFly use position 9 to store homedir
+		echo ${ent} | cut -d: -f9
+		;;
+	*)
+		# Linux, NetBSD and OpenBSD use position 6 instead
+		echo ${ent} | cut -d: -f6
+		;;
+	esac
+}
+
+# Gets the shell for the specified user
+# it's a wrap around egetent as the position of the home directory in the line
+# varies depending on the os used.
+#
+# To use that, inherit eutils, not portability!
+egetshell() {
+	ent=$(egetent passwd "$1")
+
+	case ${CHOST} in
+	*-darwin*|*-freebsd*|*-dragonfly*)
+		# Darwin, OSX, FreeBSD and DragonFly use position 9 to store homedir
+		echo ${ent} | cut -d: -f10
+		;;
+	*)
+		# Linux, NetBSD and OpenBSD use position 6 instead
+		echo ${ent} cut -d: -f7
+		;;
+	esac
+}
+
+# Returns true if specified user has a shell that precludes logins
+# on whichever operating system.
+is-login-disabled() {
+	shell=$(egetshell "$1")
+
+	case ${shell} in
+		/bin/false|/usr/bin/false|/sbin/nologin|/usr/sbin/nologin)
+			return 0 ;;
+		*)
+			return 1 ;;
+	esac
+}
+
+# Gets the name of the BSD-ish make command (pmake from NetBSD)
+#
+# This will return make (provided by system packages) for BSD userlands,
+# or bsdmake for Darwin userlands and pmake for the rest of userlands,
+# both of which are provided by sys-devel/pmake package.
+#
+# Note: the bsdmake for Darwin userland is with compatibility with MacOSX
+# default name.
+get_bmake() {
+	if [[ ${USERLAND} == *BSD ]]; then
+		echo make
+	elif [[ ${USERLAND} == "Darwin" ]]; then
+		echo bsdmake
+	else
+		echo pmake
+	fi
+}
+
+# Portable method of getting mount names and points.
+# Returns as "point node fs options"
+# Remember to convert 040 back to a space.
+get_mounts() {
+	local point= node= fs= opts= foo=
+
+	# Linux has /proc/mounts which should always exist
+	if [[ $(uname -s) == "Linux" ]] ; then
+		while read node point fs opts foo ; do
+			echo "${point} ${node} ${fs} ${opts}"
+		done < /proc/mounts
+		return
+	fi
+
+	# OK, pray we have a -p option that outputs mounts in fstab format
+	# using tabs as the seperator.
+	# Then pray that there are no tabs in the either.
+	# Currently only FreeBSD supports this and the other BSDs will
+	# have to be patched.
+	# Athough the BSD's may support /proc, they do NOT put \040 in place
+	# of the spaces and we should not force a /proc either.
+	local IFS=$'\t'
+	LC_ALL=C mount -p | while read node point fs foo ; do
+		opts=${fs#* }
+		fs=${fs%% *}
+		echo "${point// /\040} ${node// /\040} ${fs%% *} ${opts// /\040}"
+	done
+}
+
diff --git a/eclass/prefix.eclass b/eclass/prefix.eclass
new file mode 100644
index 0000000..a347df7
--- /dev/null
+++ b/eclass/prefix.eclass
@@ -0,0 +1,52 @@
+# Copyright 1999-2009 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Id: prefix.eclass,v 1.3 2009/11/16 21:39:00 grobian Exp $
+
+# @ECLASS: prefix.eclass
+# @MAINTAINER:
+# Feel free to contact the Prefix team through <prefix@gentoo.org> if
+# you have problems, suggestions or questions.
+# @BLURB: Eclass to provide Prefix functionality
+# @DESCRIPTION:
+# Gentoo Prefix allows users to install into a self defined offset
+# located somewhere in the filesystem.  Prefix ebuilds require
+# additional functions and variables which are defined by this eclass.
+
+# @ECLASS-VARIABLE: EPREFIX
+# @DESCRIPTION:
+# The offset prefix of a Gentoo Prefix installation.  When Gentoo Prefix
+# is not used, ${EPREFIX} should be "".  Prefix Portage sets EPREFIX,
+# hence this eclass has nothing to do here in that case.
+# Note that setting EPREFIX in the environment with Prefix Portage sets
+# Portage into cross-prefix mode.
+if [[ ! ${EPREFIX+set} ]]; then
+	export EPREFIX=''
+fi
+
+
+# @FUNCTION: eprefixify
+# @USAGE: <list of to be eprefixified files>
+# @DESCRIPTION:
+# replaces @GENTOO_PORTAGE_EPREFIX@ with ${EPREFIX} for the given files,
+# dies if no arguments are given, a file does not exist, or changing a
+# file failed.
+eprefixify() {
+	[[ $# -lt 1 ]] && die "at least one argument required"
+
+	einfo "Adjusting to prefix ${EPREFIX:-/}"
+	local x
+	for x in "$@" ; do
+		if [[ -e ${x} ]] ; then
+			ebegin "  ${x##*/}"
+			sed -i -e "s|@GENTOO_PORTAGE_EPREFIX@|${EPREFIX}|g" "${x}"
+			eend $? || die "failed to eprefixify ${x}"
+		else
+			die "${x} does not exist"
+		fi
+	done
+
+	return 0
+}
+
+
+# vim: tw=72:
diff --git a/eclass/toolchain-binutils.eclass b/eclass/toolchain-binutils.eclass
new file mode 100644
index 0000000..361f24c
--- /dev/null
+++ b/eclass/toolchain-binutils.eclass
@@ -0,0 +1,418 @@
+# Copyright 1999-2010 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-binutils.eclass,v 1.98 2011/03/18 19:51:55 vapier Exp $
+#
+# Maintainer: Toolchain Ninjas <toolchain@gentoo.org>
+#
+# We install binutils into CTARGET-VERSION specific directories.  This lets
+# us easily merge multiple versions for multiple targets (if we wish) and
+# then switch the versions on the fly (with `binutils-config`).
+#
+# binutils-9999           -> live cvs
+# binutils-9999_preYYMMDD -> nightly snapshot date YYMMDD
+# binutils-#              -> normal release
+
+extra_eclass=""
+if [[ -n ${BINUTILS_TYPE} ]] ; then
+	BTYPE=${BINUTILS_TYPE}
+else
+	case ${PV} in
+	9999)      BTYPE="cvs";;
+	9999_pre*) BTYPE="snap";;
+	*)         BTYPE="rel";;
+	esac
+fi
+
+if [[ ${BTYPE} == "cvs" ]] ; then
+	extra_eclass="cvs"
+	ECVS_SERVER="sourceware.org:/cvs/src"
+	ECVS_MODULE="binutils"
+	ECVS_USER="anoncvs"
+	ECVS_PASS="anoncvs"
+	BVER="cvs"
+elif [[ ${BTYPE} == "snap" ]] ; then
+	BVER=${PV/9999_pre}
+elif [[ ${BTYPE} == "rel" ]] ; then
+	BVER=${PV}
+else
+	BVER=${BINUTILS_VER}
+fi
+
+inherit eutils libtool flag-o-matic gnuconfig multilib versionator ${extra_eclass}
+EXPORT_FUNCTIONS src_unpack src_compile src_test src_install pkg_postinst pkg_postrm
+
+export CTARGET=${CTARGET:-${CHOST}}
+if [[ ${CTARGET} == ${CHOST} ]] ; then
+	if [[ ${CATEGORY/cross-} != ${CATEGORY} ]] ; then
+		export CTARGET=${CATEGORY/cross-}
+	fi
+fi
+is_cross() { [[ ${CHOST} != ${CTARGET} ]] ; }
+
+# TPREFIX is the prefix of the CTARGET installation, not used during
+# compilation, but stored in the env.d file such that the wrapper can use it
+export TPREFIX=${TPREFIX:-${EPREFIX}}
+
+DESCRIPTION="Tools necessary to build programs"
+HOMEPAGE="http://sources.redhat.com/binutils/"
+
+case ${BTYPE} in
+	cvs)  SRC_URI="";;
+	snap) SRC_URI="ftp://gcc.gnu.org/pub/binutils/snapshots/binutils-${BVER}.tar.bz2";;
+	rel)
+		SRC_URI="mirror://kernel/linux/devel/binutils/binutils-${PV}.tar.bz2
+			mirror://kernel/linux/devel/binutils/test/binutils-${PV}.tar.bz2
+			mirror://gnu/binutils/binutils-${PV}.tar.bz2"
+esac
+add_src_uri() {
+	[[ -z $2 ]] && return
+	local a=$1
+	set -- mirror://gentoo http://dev.gentoo.org/~vapier/dist
+	SRC_URI="${SRC_URI} ${@/%//${a}}"
+}
+add_src_uri binutils-${PV}-patches-${PATCHVER}.tar.bz2 ${PATCHVER}
+add_src_uri binutils-${PV}-uclibc-patches-${UCLIBC_PATCHVER}.tar.bz2 ${UCLIBC_PATCHVER}
+add_src_uri elf2flt-${ELF2FLT_VER}.tar.bz2 ${ELF2FLT_VER}
+
+if version_is_at_least 2.18 ; then
+	LICENSE="|| ( GPL-3 LGPL-3 )"
+else
+	LICENSE="|| ( GPL-2 LGPL-2 )"
+fi
+IUSE="nls multitarget multislot p_bootstrap test vanilla"
+if use multislot ; then
+	SLOT="${CTARGET}-${BVER}"
+elif is_cross ; then
+	SLOT="${CTARGET}"
+else
+	SLOT="0"
+fi
+
+RDEPEND=">=sys-devel/binutils-config-1.9"
+DEPEND="${RDEPEND}
+	test? ( dev-util/dejagnu )
+	nls? ( sys-devel/gettext )
+	sys-devel/flex"
+
+S=${WORKDIR}/binutils
+[[ ${BVER} != "cvs" ]] && S=${S}-${BVER}
+
+LIBPATH=/usr/$(get_libdir)/binutils/${CTARGET}/${BVER}
+INCPATH=${LIBPATH}/include
+DATAPATH=/usr/share/binutils-data/${CTARGET}/${BVER}
+MY_BUILDDIR=${WORKDIR}/build
+if is_cross ; then
+	BINPATH=/usr/${CHOST}/${CTARGET}/binutils-bin/${BVER}
+else
+	BINPATH=/usr/${CTARGET}/binutils-bin/${BVER}
+fi
+
+tc-binutils_unpack() {
+	unpack ${A}
+	mkdir -p "${MY_BUILDDIR}"
+	[[ -d ${WORKDIR}/patch ]] && mkdir "${WORKDIR}"/patch/skip
+}
+
+tc-binutils_apply_patches() {
+	cd "${S}"
+
+	if ! use vanilla ; then
+		EPATCH_EXCLUDE=
+		[[ ${SYMLINK_LIB} != "yes" ]] && EPATCH_EXCLUDE+=" 65_all_binutils-*-amd64-32bit-path.patch"
+		if [[ -n ${PATCHVER} ]] ; then
+			EPATCH_SOURCE=${WORKDIR}/patch
+			if [[ ${CTARGET} == mips* ]] ; then
+				# remove gnu-hash for mips (bug #233233)
+				EPATCH_EXCLUDE+=" 77_all_generate-gnu-hash.patch"
+			fi
+			[[ -n $(ls "${EPATCH_SOURCE}"/*.bz2 2>/dev/null) ]] \
+				&& EPATCH_SUFFIX="patch.bz2" \
+				|| EPATCH_SUFFIX="patch"
+			epatch
+		fi
+		if [[ -n ${UCLIBC_PATCHVER} ]] ; then
+			EPATCH_SOURCE=${WORKDIR}/uclibc-patches
+			[[ -n $(ls "${EPATCH_SOURCE}"/*.bz2 2>/dev/null) ]] \
+				&& EPATCH_SUFFIX="patch.bz2" \
+				|| EPATCH_SUFFIX="patch"
+			EPATCH_MULTI_MSG="Applying uClibc fixes ..." \
+			epatch
+		elif [[ ${CTARGET} == *-uclibc* ]] ; then
+			# starting with binutils-2.17.50.0.17, we no longer need
+			# uClibc patchsets :D
+			if grep -qs 'linux-gnu' "${S}"/ltconfig ; then
+				die "sorry, but this binutils doesn't yet support uClibc :("
+			fi
+		fi
+		epatch_user
+	fi
+
+	# fix locale issues if possible #122216
+	if [[ -e ${FILESDIR}/binutils-configure-LANG.patch ]] ; then
+		einfo "Fixing misc issues in configure files"
+		for f in $(grep -l 'autoconf version 2.13' $(find "${S}" -name configure)) ; do
+			ebegin "  Updating ${f/${S}\/}"
+			patch "${f}" "${FILESDIR}"/binutils-configure-LANG.patch >& "${T}"/configure-patch.log \
+				|| eerror "Please file a bug about this"
+			eend $?
+		done
+	fi
+	# fix conflicts with newer glibc #272594
+	if [[ -e libiberty/testsuite/test-demangle.c ]] ; then
+		sed -i 's:\<getline\>:get_line:g' libiberty/testsuite/test-demangle.c
+	fi
+
+	# Fix po Makefile generators
+	sed -i \
+		-e '/^datadir = /s:$(prefix)/@DATADIRNAME@:@datadir@:' \
+		-e '/^gnulocaledir = /s:$(prefix)/share:$(datadir):' \
+		*/po/Make-in || die "sed po's failed"
+
+	# Run misc portage update scripts
+	gnuconfig_update
+	elibtoolize --portage --no-uclibc
+}
+
+toolchain-binutils_src_unpack() {
+	tc-binutils_unpack
+	tc-binutils_apply_patches
+}
+
+toolchain-binutils_src_compile() {
+	# prevent makeinfo from running in releases.  it may not always be
+	# installed, and older binutils may fail with newer texinfo.
+	# besides, we never patch the doc files anyways, so regenerating
+	# in the first place is useless. #193364
+	find . '(' -name '*.info' -o -name '*.texi' ')' -print0 | xargs -0 touch -r .
+
+	# make sure we filter $LINGUAS so that only ones that
+	# actually work make it through #42033
+	strip-linguas -u */po
+
+	# keep things sane
+	strip-flags
+
+	local x
+	echo
+	for x in CATEGORY CBUILD CHOST CTARGET CFLAGS LDFLAGS ; do
+		einfo "$(printf '%10s' ${x}:) ${!x}"
+	done
+	echo
+
+	cd "${MY_BUILDDIR}"
+	set --
+	# enable gold if available (installed as ld.gold)
+	if grep -q 'enable-gold=default' "${S}"/configure ; then
+		set -- "$@" --enable-gold
+	# old ways - remove when 2.21 is stable
+	elif grep -q 'enable-gold=both/ld' "${S}"/configure ; then
+		set -- "$@" --enable-gold=both/ld
+	elif grep -q 'enable-gold=both/bfd' "${S}"/configure ; then
+		set -- "$@" --enable-gold=both/bfd
+	fi
+	if [[ ${CHOST} != *"-mint"* ]]; then  #353410
+		if grep -q -e '--enable-plugins' "${S}"/ld/configure ; then
+			set -- "$@" --enable-plugins
+		fi
+	fi
+	use nls \
+		&& set -- "$@" --without-included-gettext \
+		|| set -- "$@" --disable-nls
+	[[ ${CHOST} == *"-solaris"* ]] && use nls && append-libs -lintl
+	use multitarget && set -- "$@" --enable-targets=all
+	[[ -n ${CBUILD} ]] && set -- "$@" --build=${CBUILD}
+	is_cross && set -- "$@" --with-sysroot=${EPREFIX}/usr/${CTARGET}
+	# glibc-2.3.6 lacks support for this ... so rather than force glibc-2.5+
+	# on everyone in alpha (for now), we'll just enable it when possible
+	has_version ">=${CATEGORY}/glibc-2.5" && set -- "$@" --enable-secureplt
+	has_version ">=sys-libs/glibc-2.5" && set -- "$@" --enable-secureplt
+	set -- "$@" \
+		--prefix=${EPREFIX}/usr \
+		--host=${CHOST} \
+		--target=${CTARGET} \
+		--datadir=${EPREFIX}${DATAPATH} \
+		--infodir=${EPREFIX}${DATAPATH}/info \
+		--mandir=${EPREFIX}${DATAPATH}/man \
+		--bindir=${EPREFIX}${BINPATH} \
+		--libdir=${EPREFIX}${LIBPATH} \
+		--libexecdir=${EPREFIX}${LIBPATH} \
+		--includedir=${EPREFIX}${INCPATH} \
+		--enable-64-bit-bfd \
+		--disable-werror \
+		${EXTRA_ECONF}
+	use p_bootstrap || set -- "$@" --enable-shared
+	echo ./configure "$@"
+	"${S}"/configure "$@" || die
+
+	emake all || die "emake failed"
+
+	# only build info pages if we user wants them, and if
+	# we have makeinfo (may not exist when we bootstrap)
+	if type -p makeinfo > /dev/null ; then
+		emake info || die "make info failed"
+	fi
+	# we nuke the manpages when we're left with junk
+	# (like when we bootstrap, no perl -> no manpages)
+	find . -name '*.1' -a -size 0 | xargs rm -f
+
+	# elf2flt only works on some arches / targets
+	if [[ -n ${ELF2FLT_VER} ]] && [[ ${CTARGET} == *linux* || ${CTARGET} == *-elf* ]] ; then
+		cd "${WORKDIR}"/elf2flt-${ELF2FLT_VER}
+
+		local x supported_arches=$(sed -n '/defined(TARGET_/{s:^.*TARGET_::;s:)::;p}' elf2flt.c | sort -u)
+		for x in ${supported_arches} UNSUPPORTED ; do
+			[[ ${CTARGET} == ${x}* ]] && break
+		done
+
+		if [[ ${x} != "UNSUPPORTED" ]] ; then
+			append-flags -I"${S}"/include
+			set -- "$@" \
+				--with-bfd-include-dir=${MY_BUILDDIR}/bfd \
+				--with-libbfd=${MY_BUILDDIR}/bfd/libbfd.a \
+				--with-libiberty=${MY_BUILDDIR}/libiberty/libiberty.a \
+				--with-binutils-ldscript-dir=${EPREFIX}/${LIBPATH}/ldscripts
+			echo ./configure "$@"
+			./configure "$@" || die
+			emake || die "make elf2flt failed"
+		fi
+	fi
+}
+
+toolchain-binutils_src_test() {
+	cd "${MY_BUILDDIR}"
+	emake -k check || die "check failed :("
+}
+
+toolchain-binutils_src_install() {
+	local x d
+
+	cd "${MY_BUILDDIR}"
+	emake DESTDIR="${D}" tooldir="${EPREFIX}/${LIBPATH}" install || die
+	rm -rf "${ED}"/${LIBPATH}/bin
+
+	# Newer versions of binutils get fancy with ${LIBPATH} #171905
+	cd "${ED}"/${LIBPATH}
+	for d in ../* ; do
+		[[ ${d} == ../${BVER} ]] && continue
+		mv ${d}/* . || die
+		rmdir ${d} || die
+	done
+
+	# Now we collect everything intp the proper SLOT-ed dirs
+	# When something is built to cross-compile, it installs into
+	# /usr/$CHOST/ by default ... we have to 'fix' that :)
+	if is_cross ; then
+		cd "${ED}"/${BINPATH}
+		for x in * ; do
+			mv ${x} ${x/${CTARGET}-}
+		done
+
+		if [[ -d ${ED}/usr/${CHOST}/${CTARGET} ]] ; then
+			mv "${ED}"/usr/${CHOST}/${CTARGET}/include "${ED}"/${INCPATH}
+			mv "${ED}"/usr/${CHOST}/${CTARGET}/lib/* "${ED}"/${LIBPATH}/
+			rm -r "${ED}"/usr/${CHOST}/{include,lib}
+		fi
+	fi
+	insinto ${INCPATH}
+	doins "${S}/include/libiberty.h"
+	if [[ -d ${ED}/${LIBPATH}/lib ]] ; then
+		mv "${ED}"/${LIBPATH}/lib/* "${ED}"/${LIBPATH}/
+		rm -r "${ED}"/${LIBPATH}/lib
+	fi
+
+	# Insert elf2flt where appropriate
+	if [[ -x ${WORKDIR}/elf2flt-${ELF2FLT_VER}/elf2flt ]] ; then
+		cd "${WORKDIR}"/elf2flt-${ELF2FLT_VER}
+		insinto ${LIBPATH}/ldscripts
+		doins elf2flt.ld || die "doins elf2flt.ld failed"
+		exeinto ${BINPATH}
+		doexe elf2flt flthdr || die "doexe elf2flt flthdr failed"
+		mv "${ED}"/${BINPATH}/{ld,ld.real} || die
+		newexe ld-elf2flt ld || die "doexe ld-elf2flt failed"
+		newdoc README README.elf2flt
+	fi
+
+	# Now, some binutils are tricky and actually provide
+	# for multiple TARGETS.  Really, we're talking just
+	# 32bit/64bit support (like mips/ppc/sparc).  Here
+	# we want to tell binutils-config that it's cool if
+	# it generates multiple sets of binutil symlinks.
+	# e.g. sparc gets {sparc,sparc64}-unknown-linux-gnu
+	local targ=${CTARGET/-*} src="" dst=""
+	local FAKE_TARGETS=${CTARGET}
+	case ${targ} in
+		mips*)    src="mips"    dst="mips64";;
+		powerpc*) src="powerpc" dst="powerpc64";;
+		s390*)    src="s390"    dst="s390x";;
+		sparc*)   src="sparc"   dst="sparc64";;
+	esac
+	case ${targ} in
+		mips64*|powerpc64*|s390x*|sparc64*) targ=${src} src=${dst} dst=${targ};;
+	esac
+	[[ -n ${src}${dst} ]] && FAKE_TARGETS="${FAKE_TARGETS} ${CTARGET/${src}/${dst}}"
+
+	# Generate an env.d entry for this binutils
+	cd "${S}"
+	insinto /etc/env.d/binutils
+	cat <<-EOF > env.d
+		TARGET="${CTARGET}"
+		VER="${BVER}"
+		LIBPATH="${EPREFIX}/${LIBPATH}"
+		FAKE_TARGETS="${FAKE_TARGETS}"
+		TPREFIX="${TPREFIX}"
+	EOF
+	newins env.d ${CTARGET}-${BVER}
+
+	# Handle documentation
+	if ! is_cross ; then
+		cd "${S}"
+		dodoc README
+		docinto bfd
+		dodoc bfd/ChangeLog* bfd/README bfd/PORTING bfd/TODO
+		docinto binutils
+		dodoc binutils/ChangeLog binutils/NEWS binutils/README
+		docinto gas
+		dodoc gas/ChangeLog* gas/CONTRIBUTORS gas/NEWS gas/README*
+		docinto gprof
+		dodoc gprof/ChangeLog* gprof/TEST gprof/TODO gprof/bbconv.pl
+		docinto ld
+		dodoc ld/ChangeLog* ld/README ld/NEWS ld/TODO
+		docinto libiberty
+		dodoc libiberty/ChangeLog* libiberty/README
+		docinto opcodes
+		dodoc opcodes/ChangeLog*
+	fi
+	# Remove shared info pages
+	rm -f "${ED}"/${DATAPATH}/info/{dir,configure.info,standards.info}
+	# Trim all empty dirs
+	find "${ED}" -type d | xargs rmdir >& /dev/null
+}
+
+toolchain-binutils_pkg_postinst() {
+	# Make sure this ${CTARGET} has a binutils version selected
+	[[ -e ${EROOT}/etc/env.d/binutils/config-${CTARGET} ]] && return 0
+	binutils-config ${CTARGET}-${BVER}
+}
+
+toolchain-binutils_pkg_postrm() {
+	local current_profile=$(binutils-config -c ${CTARGET})
+
+	# If no other versions exist, then uninstall for this
+	# target ... otherwise, switch to the newest version
+	# Note: only do this if this version is unmerged.  We
+	#       rerun binutils-config if this is a remerge, as
+	#       we want the mtimes on the symlinks updated (if
+	#       it is the same as the current selected profile)
+	if [[ ! -e ${EPREFIX}${BINPATH}/ld ]] && [[ ${current_profile} == ${CTARGET}-${BVER} ]] ; then
+		local choice=$(binutils-config -l | grep ${CTARGET} | awk '{print $2}')
+		choice=${choice//$'\n'/ }
+		choice=${choice/* }
+		if [[ -z ${choice} ]] ; then
+			env -i ROOT="${ROOT}" "${EPREFIX}"/usr/bin/binutils-config -u ${CTARGET}
+		else
+			binutils-config ${choice}
+		fi
+	elif [[ $(CHOST=${CTARGET} binutils-config -c) == ${CTARGET}-${BVER} ]] ; then
+		binutils-config ${CTARGET}-${BVER}
+	fi
+}
diff --git a/eclass/toolchain-funcs.eclass b/eclass/toolchain-funcs.eclass
new file mode 100644
index 0000000..1907607
--- /dev/null
+++ b/eclass/toolchain-funcs.eclass
@@ -0,0 +1,694 @@
+# Copyright 1999-2007 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/toolchain-funcs.eclass,v 1.103 2010/10/28 04:16:27 vapier Exp $
+
+# @ECLASS: toolchain-funcs.eclass
+# @MAINTAINER:
+# Toolchain Ninjas <toolchain@gentoo.org>
+# @BLURB: functions to query common info about the toolchain
+# @DESCRIPTION:
+# The toolchain-funcs aims to provide a complete suite of functions
+# for gleaning useful information about the toolchain and to simplify
+# ugly things like cross-compiling and multilib.  All of this is done
+# in such a way that you can rely on the function always returning
+# something sane.
+
+___ECLASS_RECUR_TOOLCHAIN_FUNCS="yes"
+[[ -z ${___ECLASS_RECUR_MULTILIB} ]] && inherit multilib
+inherit prefix
+
+DESCRIPTION="Based on the ${ECLASS} eclass"
+
+tc-getPROG() {
+	local var=$1
+	local prog=$2
+
+	if [[ -n ${!var} ]] ; then
+		echo "${!var}"
+		return 0
+	fi
+
+	local search=
+	[[ -n $3 ]] && search=$(type -p "$3-${prog}")
+	[[ -z ${search} && -n ${CHOST} ]] && search=$(type -p "${CHOST}-${prog}")
+	[[ -n ${search} ]] && prog=${search##*/}
+
+	export ${var}=${prog}
+	echo "${!var}"
+}
+
+# @FUNCTION: tc-getAR
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the archiver
+tc-getAR() { tc-getPROG AR ar "$@"; }
+# @FUNCTION: tc-getAS
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the assembler
+tc-getAS() { tc-getPROG AS as "$@"; }
+# @FUNCTION: tc-getCC
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the C compiler
+tc-getCC() { tc-getPROG CC gcc "$@"; }
+# @FUNCTION: tc-getCPP
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the C preprocessor
+tc-getCPP() { tc-getPROG CPP cpp "$@"; }
+# @FUNCTION: tc-getCXX
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the C++ compiler
+tc-getCXX() { tc-getPROG CXX g++ "$@"; }
+# @FUNCTION: tc-getLD
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the linker
+tc-getLD() { tc-getPROG LD ld "$@"; }
+# @FUNCTION: tc-getSTRIP
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the strip program
+tc-getSTRIP() { tc-getPROG STRIP strip "$@"; }
+# @FUNCTION: tc-getNM
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the symbol/object thingy
+tc-getNM() { tc-getPROG NM nm "$@"; }
+# @FUNCTION: tc-getRANLIB
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the archiver indexer
+tc-getRANLIB() { tc-getPROG RANLIB ranlib "$@"; }
+# @FUNCTION: tc-getOBJCOPY
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the object copier
+tc-getOBJCOPY() { tc-getPROG OBJCOPY objcopy "$@"; }
+# @FUNCTION: tc-getF77
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the Fortran 77 compiler
+tc-getF77() { tc-getPROG F77 gfortran "$@"; }
+# @FUNCTION: tc-getFC
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the Fortran 90 compiler
+tc-getFC() { tc-getPROG FC gfortran "$@"; }
+# @FUNCTION: tc-getGCJ
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the java compiler
+tc-getGCJ() { tc-getPROG GCJ gcj "$@"; }
+# @FUNCTION: tc-getPKG_CONFIG
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the pkg-config tool
+tc-getPKG_CONFIG() { tc-getPROG PKG_CONFIG pkg-config "$@"; }
+# @FUNCTION: tc-getRC
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the Windows resource compiler
+tc-getRC() { tc-getPROG RC windres "$@"; }
+# @FUNCTION: tc-getDLLWRAP
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the Windows dllwrap utility
+tc-getDLLWRAP() { tc-getPROG DLLWRAP dllwrap "$@"; }
+
+# @FUNCTION: tc-getBUILD_CC
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the C compiler for building binaries to run on the build machine
+tc-getBUILD_CC() {
+	local v
+	for v in CC_FOR_BUILD BUILD_CC HOSTCC ; do
+		if [[ -n ${!v} ]] ; then
+			export BUILD_CC=${!v}
+			echo "${!v}"
+			return 0
+		fi
+	done
+
+	local search=
+	if [[ -n ${CBUILD} ]] ; then
+		search=$(type -p ${CBUILD}-gcc)
+		search=${search##*/}
+	fi
+	search=${search:-gcc}
+
+	export BUILD_CC=${search}
+	echo "${search}"
+}
+
+# @FUNCTION: tc-export
+# @USAGE: <list of toolchain variables>
+# @DESCRIPTION:
+# Quick way to export a bunch of compiler vars at once.
+tc-export() {
+	local var
+	for var in "$@" ; do
+		[[ $(type -t tc-get${var}) != "function" ]] && die "tc-export: invalid export variable '${var}'"
+		eval tc-get${var} > /dev/null
+	done
+}
+
+# @FUNCTION: tc-is-cross-compiler
+# @RETURN: Shell true if we are using a cross-compiler, shell false otherwise
+tc-is-cross-compiler() {
+	return $([[ ${CBUILD:-${CHOST}} != ${CHOST} ]])
+}
+
+# @FUNCTION: tc-is-softfloat
+# @DESCRIPTION:
+# See if this toolchain is a softfloat based one.
+# @CODE
+# The possible return values:
+#  - only: the target is always softfloat (never had fpu)
+#  - yes:  the target should support softfloat
+#  - no:   the target doesn't support softfloat
+# @CODE
+# This allows us to react differently where packages accept
+# softfloat flags in the case where support is optional, but
+# rejects softfloat flags where the target always lacks an fpu.
+tc-is-softfloat() {
+	case ${CTARGET} in
+		bfin*|h8300*)
+			echo "only" ;;
+		*)
+			[[ ${CTARGET//_/-} == *-softfloat-* ]] \
+				&& echo "yes" \
+				|| echo "no"
+			;;
+	esac
+}
+
+# @FUNCTION: tc-is-hardfloat
+# @DESCRIPTION:
+# See if this toolchain is a hardfloat based one.
+# @CODE
+# The possible return values:
+#  - yes:  the target should support hardfloat
+#  - no:   the target doesn't support hardfloat
+tc-is-hardfloat() {
+	[[ ${CTARGET//_/-} == *-hardfloat-* ]] \
+		&& echo "yes" \
+		|| echo "no"
+}
+
+# @FUNCTION: tc-is-static-only
+# @DESCRIPTION:
+# Return shell true if the target does not support shared libs, shell false
+# otherwise.
+tc-is-static-only() {
+	local host=${CTARGET:-${CHOST}}
+
+	# *MiNT doesn't have shared libraries, only platform so far
+	return $([[ ${host} == *-mint* ]])
+}
+
+# @FUNCTION: tc-has-openmp
+# @USAGE: [toolchain prefix]
+# @DESCRIPTION:
+# See if the toolchain supports OpenMP.
+tc-has-openmp() {
+	local base="${T}/test-tc-openmp"
+	cat <<-EOF > "${base}.c"
+	#include <omp.h>
+	int main() {
+		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}
+}
+
+# @FUNCTION: tc-has-tls
+# @USAGE: [-s|-c|-l] [toolchain prefix]
+# @DESCRIPTION:
+# See if the toolchain supports thread local storage (TLS).  Use -s to test the
+# compiler, -c to also test the assembler, and -l to also test the C library
+# (the default).
+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}
+}
+
+
+# Parse information from CBUILD/CHOST/CTARGET rather than
+# use external variables from the profile.
+tc-ninja_magic_to_arch() {
+ninj() { [[ ${type} == "kern" ]] && echo $1 || echo $2 ; }
+
+	local type=$1
+	local host=$2
+	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}}
+
+	case ${host} in
+		powerpc-apple-darwin*)    echo ppc-macos;;
+		powerpc64-apple-darwin*)  echo ppc64-macos;;
+		i?86-apple-darwin*)       echo x86-macos;;
+		x86_64-apple-darwin*)     echo x64-macos;;
+		sparc-sun-solaris*)       echo sparc-solaris;;
+		sparcv9-sun-solaris*)     echo sparc64-solaris;;
+		i?86-pc-solaris*)         echo x86-solaris;;
+		x86_64-pc-solaris*)       echo x64-solaris;;
+		powerpc-ibm-aix*)         echo ppc-aix;;
+		mips-sgi-irix*)           echo mips-irix;;
+		ia64w-hp-hpux*)           echo ia64w-hpux;;
+		ia64-hp-hpux*)            echo ia64-hpux;;
+		hppa*64*-hp-hpux*)        echo hppa64-hpux;;
+		hppa*-hp-hpux*)           echo hppa-hpux;;
+		i?86-pc-freebsd*)         echo x86-freebsd;;
+		x86_64-pc-freebsd*)       echo x64-freebsd;;
+		powerpc-unknown-openbsd*) echo ppc-openbsd;;
+		i?86-pc-openbsd*)         echo x86-openbsd;;
+		x86_64-pc-openbsd*)       echo x64-openbsd;;
+		i?86-pc-netbsd*)          echo x86-netbsd;;
+		i?86-pc-interix*)         echo x86-interix;;
+		i?86-pc-winnt*)           echo x86-winnt;;
+
+		alpha*)		echo alpha;;
+		arm*)		echo arm;;
+		avr*)		ninj avr32 avr;;
+		bfin*)		ninj blackfin bfin;;
+		cris*)		echo cris;;
+		hppa*)		ninj parisc hppa;;
+		i?86*)
+			# Starting with linux-2.6.24, the 'x86_64' and 'i386'
+			# trees have been unified into 'x86'.
+			# FreeBSD still uses i386
+			if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -lt $(KV_to_int 2.6.24) || ${host} == *freebsd* ]] ; then
+				echo i386
+			else
+				echo x86
+			fi
+			;;
+		ia64*)		echo ia64;;
+		m68*)		echo m68k;;
+		mips*)		echo mips;;
+		nios2*)		echo nios2;;
+		nios*)		echo nios;;
+		powerpc*)
+			# Starting with linux-2.6.15, the 'ppc' and 'ppc64' trees
+			# have been unified into simply 'powerpc', but until 2.6.16,
+			# ppc32 is still using ARCH="ppc" as default
+			if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.16) ]] ; then
+				echo powerpc
+			elif [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -eq $(KV_to_int 2.6.15) ]] ; then
+				if [[ ${host} == powerpc64* ]] || [[ ${PROFILE_ARCH} == "ppc64" ]] ; then
+					echo powerpc
+				else
+					echo ppc
+				fi
+			elif [[ ${host} == powerpc64* ]] ; then
+				echo ppc64
+			elif [[ ${PROFILE_ARCH} == "ppc64" ]] ; then
+				ninj ppc64 ppc
+			else
+				echo ppc
+			fi
+			;;
+		s390*)		echo s390;;
+		sh64*)		ninj sh64 sh;;
+		sh*)		echo sh;;
+		sparc64*)	ninj sparc64 sparc;;
+		sparc*)		[[ ${PROFILE_ARCH} == "sparc64" ]] \
+						&& ninj sparc64 sparc \
+						|| echo sparc
+					;;
+		vax*)		echo vax;;
+		x86_64*)
+			# Starting with linux-2.6.24, the 'x86_64' and 'i386'
+			# trees have been unified into 'x86'.
+			if [[ ${type} == "kern" ]] && [[ $(KV_to_int ${KV}) -ge $(KV_to_int 2.6.24) ]] ; then
+				echo x86
+			else
+				ninj x86_64 amd64
+			fi
+			;;
+
+		# since our usage of tc-arch is largely concerned with
+		# normalizing inputs for testing ${CTARGET}, let's filter
+		# other cross targets (mingw and such) into the unknown.
+		*)			echo unknown;;
+	esac
+}
+# @FUNCTION: tc-arch-kernel
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the kernel arch according to the compiler target
+tc-arch-kernel() {
+	tc-ninja_magic_to_arch kern "$@"
+}
+# @FUNCTION: tc-arch
+# @USAGE: [toolchain prefix]
+# @RETURN: name of the portage arch according to the compiler target
+tc-arch() {
+	tc-ninja_magic_to_arch portage "$@"
+}
+
+tc-endian() {
+	local host=$1
+	[[ -z ${host} ]] && host=${CTARGET:-${CHOST}}
+	host=${host%%-*}
+
+	case ${host} in
+		alpha*)		echo big;;
+		arm*b*)		echo big;;
+		arm*)		echo little;;
+		cris*)		echo little;;
+		hppa*)		echo big;;
+		i?86*)		echo little;;
+		ia64*)		echo little;;
+		m68*)		echo big;;
+		mips*l*)	echo little;;
+		mips*)		echo big;;
+		powerpc*)	echo big;;
+		s390*)		echo big;;
+		sh*b*)		echo big;;
+		sh*)		echo little;;
+		sparc*)		echo big;;
+		x86_64*)	echo little;;
+		*)			echo wtf;;
+	esac
+}
+
+# Internal func.  The first argument is the version info to expand.
+# Query the preprocessor to improve compatibility across different
+# compilers rather than maintaining a --version flag matrix. #335943
+_gcc_fullversion() {
+	local ver="$1"; shift
+	set -- `$(tc-getCPP "$@") -E -P - <<<"__GNUC__ __GNUC_MINOR__ __GNUC_PATCHLEVEL__"`
+	eval echo "$ver"
+}
+
+# @FUNCTION: gcc-fullversion
+# @RETURN: compiler version (major.minor.micro: [3.4.6])
+gcc-fullversion() {
+	_gcc_fullversion '$1.$2.$3' "$@"
+}
+# @FUNCTION: gcc-version
+# @RETURN: compiler version (major.minor: [3.4].6)
+gcc-version() {
+	_gcc_fullversion '$1.$2' "$@"
+}
+# @FUNCTION: gcc-major-version
+# @RETURN: major compiler version (major: [3].4.6)
+gcc-major-version() {
+	_gcc_fullversion '$1' "$@"
+}
+# @FUNCTION: gcc-minor-version
+# @RETURN: minor compiler version (minor: 3.[4].6)
+gcc-minor-version() {
+	_gcc_fullversion '$2' "$@"
+}
+# @FUNCTION: gcc-micro-version
+# @RETURN: micro compiler version (micro: 3.4.[6])
+gcc-micro-version() {
+	_gcc_fullversion '$3' "$@"
+}
+
+# Returns the installation directory - internal toolchain
+# function for use by _gcc-specs-exists (for flag-o-matic).
+_gcc-install-dir() {
+	echo "$(LC_ALL=C $(tc-getCC) -print-search-dirs 2> /dev/null |\
+		awk '$1=="install:" {print $2}')"
+}
+# Returns true if the indicated specs file exists - internal toolchain
+# function for use by flag-o-matic.
+_gcc-specs-exists() {
+	[[ -f $(_gcc-install-dir)/$1 ]]
+}
+
+# Returns requested gcc specs directive unprocessed - for used by
+# gcc-specs-directive()
+# Note; later specs normally overwrite earlier ones; however if a later
+# spec starts with '+' then it appends.
+# gcc -dumpspecs is parsed first, followed by files listed by "gcc -v"
+# as "Reading <file>", in order.  Strictly speaking, if there's a
+# $(gcc_install_dir)/specs, the built-in specs aren't read, however by
+# the same token anything from 'gcc -dumpspecs' is overridden by
+# the contents of $(gcc_install_dir)/specs so the result is the
+# same either way.
+_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
+}
+
+# Return the requested gcc specs directive, with all included
+# specs expanded.
+# Note, it does not check for inclusion loops, which cause it
+# to never finish - but such loops are invalid for gcc and we're
+# assuming gcc is operational.
+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
+}
+
+# Returns true if gcc sets relro
+gcc-specs-relro() {
+	local directive
+	directive=$(gcc-specs-directive link_command)
+	return $([[ "${directive/\{!norelro:}" != "${directive}" ]])
+}
+# Returns true if gcc sets now
+gcc-specs-now() {
+	local directive
+	directive=$(gcc-specs-directive link_command)
+	return $([[ "${directive/\{!nonow:}" != "${directive}" ]])
+}
+# Returns true if gcc builds PIEs
+gcc-specs-pie() {
+	local directive
+	directive=$(gcc-specs-directive cc1)
+	return $([[ "${directive/\{!nopie:}" != "${directive}" ]])
+}
+# Returns true if gcc builds with the stack protector
+gcc-specs-ssp() {
+	local directive
+	directive=$(gcc-specs-directive cc1)
+	return $([[ "${directive/\{!fno-stack-protector:}" != "${directive}" ]])
+}
+# Returns true if gcc upgrades fstack-protector to fstack-protector-all
+gcc-specs-ssp-to-all() {
+	local directive
+	directive=$(gcc-specs-directive cc1)
+	return $([[ "${directive/\{!fno-stack-protector-all:}" != "${directive}" ]])
+}
+# Returns true if gcc builds with fno-strict-overflow
+gcc-specs-nostrict() {
+	local directive
+	directive=$(gcc-specs-directive cc1)
+	return $([[ "${directive/\{!fstrict-overflow:}" != "${directive}" ]])
+}
+
+
+# @FUNCTION: gen_usr_ldscript
+# @USAGE: [-a] <list of libs to create linker scripts for>
+# @DESCRIPTION:
+# This function generate linker scripts in /usr/lib for dynamic
+# libs in /lib.  This is to fix linking problems when you have
+# the .so in /lib, and the .a in /usr/lib.  What happens is that
+# in some cases when linking dynamic, the .a in /usr/lib is used
+# instead of the .so in /lib due to gcc/libtool tweaking ld's
+# library search path.  This causes many builds to fail.
+# See bug #4411 for more info.
+#
+# Note that you should in general use the unversioned name of
+# the library (libfoo.so), as ldconfig should usually update it
+# correctly to point to the latest version of the library present.
+gen_usr_ldscript() {
+	local lib libdir=$(get_libdir) output_format="" auto=false suffix=$(get_libname)
+	[[ -z ${ED+set} ]] && local ED=${D%/}${EPREFIX}/
+
+	tc-is-static-only && return
+
+	# Just make sure it exists
+	dodir /usr/${libdir}
+
+	if [[ $1 == "-a" ]] ; then
+		auto=true
+		shift
+		dodir /${libdir}
+	fi
+
+	# OUTPUT_FORMAT gives hints to the linker as to what binary format
+	# is referenced ... makes multilib saner
+	output_format=$($(tc-getCC) ${CFLAGS} ${LDFLAGS} -Wl,--verbose 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
+			# Ensure /lib/${lib} exists to avoid dangling scripts/symlinks.
+			# This especially is for AIX where $(get_libname) can return ".a",
+			# so /lib/${lib} might be moved to /usr/lib/${lib} (by accident).
+			[[ -r ${ED}/${libdir}/${lib} ]] || continue
+			#TODO: better die here?
+		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
+			if [[ -z ${tlib} ]] ; then
+				ewarn "gen_usr_ldscript: unable to read install_name from ${lib}"
+				tlib=${lib}
+			fi
+			tlib=${tlib##*/}
+
+			if ${auto} ; then
+				mv "${ED}"/usr/${libdir}/${lib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die
+				# some install_names are funky: they encode a version
+				if [[ ${tlib} != ${lib%${suffix}}.*${suffix#.} ]] ; then
+					mv "${ED}"/usr/${libdir}/${tlib%${suffix}}.*${suffix#.} "${ED}"/${libdir}/ || die
+				fi
+				[[ ${tlib} != ${lib} ]] && rm -f "${ED}"/${libdir}/${lib}
+			fi
+
+			# Mach-O files have an id, which is like a soname, it tells how
+			# another object linking against this lib should reference it.
+			# Since we moved the lib from usr/lib into lib this reference is
+			# wrong.  Hence, we update it here.  We don't configure with
+			# libdir=/lib because that messes up libtool files.
+			# Make sure we don't lose the specific version, so just modify the
+			# existing install_name
+			if [[ ! -w "${ED}/${libdir}/${tlib}" ]] ; then
+				chmod u+w "${ED}${libdir}/${tlib}" # needed to write to it
+				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}"
+			# Now as we don't use GNU binutils and our linker doesn't
+			# understand linker scripts, just create a symlink.
+			pushd "${ED}/usr/${libdir}" > /dev/null
+			ln -snf "../../${libdir}/${tlib}" "${lib}"
+			popd > /dev/null
+			;;
+		*-aix*|*-irix*|*64*-hpux*|*-interix*|*-winnt*)
+			if ${auto} ; then
+				mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die
+				# no way to retrieve soname on these platforms (?)
+				tlib=$(readlink "${ED}"/${libdir}/${lib})
+				tlib=${tlib##*/}
+				if [[ -z ${tlib} ]] ; then
+					# ok, apparently was not a symlink, don't remove it and
+					# just link to it
+					tlib=${lib}
+				else
+					rm -f "${ED}"/${libdir}/${lib}
+				fi
+			else
+				tlib=${lib}
+			fi
+
+			# we don't have GNU binutils on these platforms, so we symlink
+			# instead, which seems to work fine.  Keep it relative, otherwise
+			# we break some QA checks in Portage
+			# on interix, the linker scripts would work fine in _most_
+			# situations. if a library links to such a linker script the
+			# absolute path to the correct library is inserted into the binary,
+			# which is wrong, since anybody linking _without_ libtool will miss
+			# some dependencies, since the stupid linker cannot find libraries
+			# hardcoded with absolute paths (as opposed to the loader, which
+			# seems to be able to do this).
+			# this has been seen while building shared-mime-info which needs
+			# libxml2, but links without libtool (and does not add libz to the
+			# command line by itself).
+			pushd "${ED}/usr/${libdir}" > /dev/null
+			ln -snf "../../${libdir}/${tlib}" "${lib}"
+			popd > /dev/null
+			;;
+		hppa*-hpux*) # PA-RISC 32bit (SOM) only, others (ELF) match *64*-hpux* above.
+			if ${auto} ; then
+				tlib=$(chatr "${ED}"/usr/${libdir}/${lib} | sed -n '/internal name:/{n;s/^ *//;p;q}')
+				[[ -z ${tlib} ]] && tlib=${lib}
+				tlib=${tlib##*/} # 'internal name' can have a path component
+				mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die
+				# some SONAMEs are funky: they encode a version before the .so
+				if [[ ${tlib} != ${lib}* ]] ; then
+					mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die
+				fi
+				[[ ${tlib} != ${lib} ]] &&
+				rm -f "${ED}"/${libdir}/${lib}
+			else
+				tlib=$(chatr "${ED}"/${libdir}/${lib} | sed -n '/internal name:/{n;s/^ *//;p;q}')
+				[[ -z ${tlib} ]] && tlib=${lib}
+				tlib=${tlib##*/} # 'internal name' can have a path component
+			fi
+			pushd "${ED}"/usr/${libdir} >/dev/null
+			ln -snf "../../${libdir}/${tlib}" "${lib}"
+			# need the internal name in usr/lib too, to be available at runtime
+			# when linked with /path/to/lib.sl (hardcode_direct_absolute=yes)
+			[[ ${tlib} != ${lib} ]] &&
+			ln -snf "../../${libdir}/${tlib}" "${tlib}"
+			popd >/dev/null
+			;;
+		*)
+			if ${auto} ; then
+				tlib=$(scanelf -qF'%S#F' "${ED}"/usr/${libdir}/${lib})
+				if [[ -z ${tlib} ]] ; then
+					ewarn "gen_usr_ldscript: unable to read SONAME from ${lib}"
+					tlib=${lib}
+				fi
+				mv "${ED}"/usr/${libdir}/${lib}* "${ED}"/${libdir}/ || die
+				# some SONAMEs are funky: they encode a version before the .so
+				if [[ ${tlib} != ${lib}* ]] ; then
+					mv "${ED}"/usr/${libdir}/${tlib}* "${ED}"/${libdir}/ || die
+				fi
+				[[ ${tlib} != ${lib} ]] && 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 http://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
+}
diff --git a/eclass/versionator.eclass b/eclass/versionator.eclass
new file mode 100644
index 0000000..05acf48
--- /dev/null
+++ b/eclass/versionator.eclass
@@ -0,0 +1,577 @@
+# Copyright 1999-2008 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: /var/cvsroot/gentoo-x86/eclass/versionator.eclass,v 1.17 2010/07/19 20:17:35 vapier Exp $
+
+# @ECLASS: versionator.eclass
+# @MAINTAINER:
+# base-system@gentoo.org
+# @BLURB: functions which simplify manipulation of ${PV} and similar version strings
+# @DESCRIPTION:
+# This eclass provides functions which simplify manipulating $PV and similar
+# variables. Most functions default to working with $PV, although other
+# values can be used.
+# @EXAMPLE:
+# Simple Example 1: $PV is 1.2.3b, we want 1_2.3b:
+#     MY_PV=$(replace_version_separator 1 '_' )
+#
+# Simple Example 2: $PV is 1.4.5, we want 1:
+#     MY_MAJORV=$(get_major_version )
+#
+# Rather than being a number, the index parameter can be a separator character
+# such as '-', '.' or '_'. In this case, the first separator of this kind is
+# selected.
+#
+# There's also:
+#     version_is_at_least             want      have
+#  which may be buggy, so use with caution.
+
+inherit eutils
+
+# @FUNCTION: get_all_version_components
+# @USAGE: [version]
+# @DESCRIPTION:
+# Split up a version string into its component parts. If no parameter is
+# supplied, defaults to $PV.
+#     0.8.3       ->  0 . 8 . 3
+#     7c          ->  7 c
+#     3.0_p2      ->  3 . 0 _ p2
+#     20040905    ->  20040905
+#     3.0c-r1     ->  3 . 0 c - r1
+get_all_version_components() {
+	eshopts_push -s extglob
+	local ver_str=${1:-${PV}} result result_idx=0
+	result=( )
+
+	# sneaky cache trick cache to avoid having to parse the same thing several
+	# times.
+	if [[ "${VERSIONATOR_CACHE_VER_STR}" == "${ver_str}" ]] ; then
+		echo ${VERSIONATOR_CACHE_RESULT}
+		eshopts_pop
+		return
+	fi
+	export VERSIONATOR_CACHE_VER_STR="${ver_str}"
+
+	while [[ -n "$ver_str" ]] ; do
+		case "${ver_str:0:1}" in
+			# number: parse whilst we have a number
+			[[:digit:]])
+				result[$result_idx]="${ver_str%%[^[:digit:]]*}"
+				ver_str="${ver_str##+([[:digit:]])}"
+				result_idx=$(($result_idx + 1))
+				;;
+
+			# separator: single character
+			[-_.])
+				result[$result_idx]="${ver_str:0:1}"
+				ver_str="${ver_str:1}"
+				result_idx=$(($result_idx + 1))
+				;;
+
+			# letter: grab the letters plus any following numbers
+			[[:alpha:]])
+				local not_match="${ver_str##+([[:alpha:]])*([[:digit:]])}"
+				result[$result_idx]=${ver_str:0:$((${#ver_str} - ${#not_match}))}
+				ver_str="${not_match}"
+				result_idx=$(($result_idx + 1))
+				;;
+
+			# huh?
+			*)
+				result[$result_idx]="${ver_str:0:1}"
+				ver_str="${ver_str:1}"
+				result_idx=$(($result_idx + 1))
+				;;
+		esac
+	done
+
+	export VERSIONATOR_CACHE_RESULT="${result[@]}"
+	echo ${result[@]}
+	eshopts_pop
+}
+
+# @FUNCTION: get_version_components
+# @USAGE: [version]
+# @DESCRIPTION:
+# Get the important version components, excluding '.', '-' and '_'. Defaults to
+# $PV if no parameter is supplied.
+#     0.8.3       ->  0 8 3
+#     7c          ->  7 c
+#     3.0_p2      ->  3 0 p2
+#     20040905    ->  20040905
+#     3.0c-r1     ->  3 0 c r1
+get_version_components() {
+	eshopts_push -s extglob
+	local c="$(get_all_version_components "${1:-${PV}}")"
+	c=( ${c[@]//[-._]/ } )
+	echo ${c[@]}
+	eshopts_pop
+}
+
+# @FUNCTION: get_major_version
+# @USAGE: [version]
+# @DESCRIPTION:
+# Get the major version of a value. Defaults to $PV if no parameter is supplied.
+#     0.8.3       ->  0
+#     7c          ->  7
+#     3.0_p2      ->  3
+#     20040905    ->  20040905
+#     3.0c-r1     ->  3
+get_major_version() {
+	eshopts_push -s extglob
+	local c
+	c=( $(get_all_version_components "${1:-${PV}}" ) )
+	echo ${c[0]}
+	eshopts_pop
+}
+
+# @FUNCTION: get_version_component_range
+# @USAGE: [version]
+# @DESCRIPTION:
+# Get a particular component or range of components from the version. If no
+# version parameter is supplied, defaults to $PV.
+#    1      1.2.3       -> 1
+#    1-2    1.2.3       -> 1.2
+#    2-     1.2.3       -> 2.3
+get_version_component_range() {
+	eshopts_push -s extglob
+	local c v="${2:-${PV}}" range="${1}" range_start range_end i=-1 j=0
+	c=( $(get_all_version_components ${v} ) )
+	range_start="${range%-*}" ; range_start="${range_start:-1}"
+	range_end="${range#*-}"   ; range_end="${range_end:-${#c[@]}}"
+
+	while (( j < ${range_start} )) ; do
+		i=$(($i + 1))
+		[[ $i -gt ${#c[@]} ]] && eshopts_pop && return
+		[[ -n "${c[${i}]//[-._]}" ]] && j=$(($j + 1))
+	done
+
+	while (( j <= ${range_end} )) ; do
+		echo -n ${c[$i]}
+		[[ $i -gt ${#c[@]} ]] && eshopts_pop && return
+		[[ -n "${c[${i}]//[-._]}" ]] && j=$(($j + 1))
+		i=$(($i + 1))
+	done
+	eshopts_pop
+}
+
+# @FUNCTION: get_after_major_version
+# @USAGE: [version]
+# @DESCRIPTION:
+# Get everything after the major version and its separator (if present) of a
+# value. Defaults to $PV if no parameter is supplied.
+#     0.8.3       ->  8.3
+#     7c          ->  c
+#     3.0_p2      ->  0_p2
+#     20040905    ->  (empty string)
+#     3.0c-r1     ->  0c-r1
+get_after_major_version() {
+	eshopts_push -s extglob
+	echo $(get_version_component_range 2- "${1:-${PV}}" )
+	eshopts_pop
+}
+
+# @FUNCTION: replace_version_separator
+# @USAGE: <search> <replacement> [subject]
+# @DESCRIPTION:
+# Replace the $1th separator with $2 in $3 (defaults to $PV if $3 is not
+# supplied). If there are fewer than $1 separators, don't change anything.
+#     1 '_' 1.2.3       -> 1_2.3
+#     2 '_' 1.2.3       -> 1.2_3
+#     1 '_' 1b-2.3      -> 1b_2.3
+# Rather than being a number, $1 can be a separator character such as '-', '.'
+# or '_'. In this case, the first separator of this kind is selected.
+replace_version_separator() {
+	eshopts_push -s extglob
+	local w i c found=0 v="${3:-${PV}}"
+	w=${1:-1}
+	c=( $(get_all_version_components ${v} ) )
+	if [[ "${w//[[:digit:]]/}" == "${w}" ]] ; then
+		# it's a character, not an index
+		for (( i = 0 ; i < ${#c[@]} ; i = $i + 1 )) ; do
+			if [[ "${c[${i}]}" == "${w}" ]] ; then
+				c[${i}]="${2}"
+				break
+			fi
+		done
+	else
+		for (( i = 0 ; i < ${#c[@]} ; i = $i + 1 )) ; do
+			if [[ -n "${c[${i}]//[^-._]}" ]] ; then
+				found=$(($found + 1))
+				if [[ "$found" == "${w}" ]] ; then
+					c[${i}]="${2}"
+					break
+				fi
+			fi
+		done
+	fi
+	c=${c[@]}
+	echo ${c// }
+	eshopts_pop
+}
+
+# @FUNCTION: replace_all_version_separators
+# @USAGE: <replacement> [subject]
+# @DESCRIPTION:
+# Replace all version separators in $2 (defaults to $PV) with $1.
+#     '_' 1b.2.3        -> 1b_2_3
+replace_all_version_separators() {
+	eshopts_push -s extglob
+	local c
+	c=( $(get_all_version_components "${2:-${PV}}" ) )
+	c="${c[@]//[-._]/$1}"
+	echo ${c// }
+	eshopts_pop
+}
+
+# @FUNCTION: delete_version_separator
+# @USAGE: <search> [subject]
+# @DESCRIPTION:
+# Delete the $1th separator in $2 (defaults to $PV if $2 is not supplied). If
+# there are fewer than $1 separators, don't change anything.
+#     1 1.2.3       -> 12.3
+#     2 1.2.3       -> 1.23
+#     1 1b-2.3      -> 1b2.3
+# Rather than being a number, $1 can be a separator character such as '-', '.'
+# or '_'. In this case, the first separator of this kind is deleted.
+delete_version_separator() {
+	eshopts_push -s extglob
+	replace_version_separator "${1}" "" "${2}"
+	eshopts_pop
+}
+
+# @FUNCTION: delete_all_version_separators
+# @USAGE: [subject]
+# @DESCRIPTION:
+# Delete all version separators in $1 (defaults to $PV).
+#     1b.2.3        -> 1b23
+delete_all_version_separators() {
+	eshopts_push -s extglob
+	replace_all_version_separators "" "${1}"
+	eshopts_pop
+}
+
+# @FUNCTION: get_version_component_count
+# @USAGE: [version]
+# @DESCRIPTION:
+# How many version components are there in $1 (defaults to $PV)?
+#     1.0.1       ->  3
+#     3.0c-r1     ->  4
+get_version_component_count() {
+	eshopts_push -s extglob
+	local a
+	a=( $(get_version_components "${1:-${PV}}" ) )
+	echo ${#a[@]}
+	eshopts_pop
+}
+
+# @FUNCTION: get_last_version_component_index
+# @USAGE: [version]
+# @DESCRIPTION:
+# What is the index of the last version component in $1 (defaults to $PV)?
+# Equivalent to get_version_component_count - 1.
+#     1.0.1       ->  3
+#     3.0c-r1     ->  4
+get_last_version_component_index() {
+	eshopts_push -s extglob
+	echo $(( $(get_version_component_count "${1:-${PV}}" ) - 1 ))
+	eshopts_pop
+}
+
+# @FUNCTION: version_is_at_least
+# @USAGE: <want> [have]
+# @DESCRIPTION:
+# Is $2 (defaults to $PVR) at least version $1? Intended for use in eclasses
+# only. May not be reliable, be sure to do very careful testing before actually
+# using this.
+version_is_at_least() {
+	eshopts_push -s extglob
+	local want_s="$1" have_s="${2:-${PVR}}" r
+	version_compare "${want_s}" "${have_s}"
+	r=$?
+	case $r in
+		1|2)
+			eshopts_pop
+			return 0
+			;;
+		3)
+			eshopts_pop
+			return 1
+			;;
+		*)
+			eshopts_pop
+			die "versionator compare bug [atleast, ${want_s}, ${have_s}, ${r}]"
+			;;
+	esac
+	eshopts_pop
+}
+
+# @FUNCTION: version_compare
+# @USAGE: <A> <B>
+# @DESCRIPTION:
+# Takes two parameters (A, B) which are versions. If A is an earlier version
+# than B, returns 1. If A is identical to B, return 2. If A is later than B,
+# return 3. You probably want version_is_at_least rather than this function.
+# May not be very reliable. Test carefully before using this.
+version_compare() {
+	eshopts_push -s extglob
+	local ver_a=${1} ver_b=${2} parts_a parts_b cur_idx_a=0 cur_idx_b=0
+	parts_a=( $(get_all_version_components "${ver_a}" ) )
+	parts_b=( $(get_all_version_components "${ver_b}" ) )
+
+	### compare number parts.
+	local inf_loop=0
+	while true ; do
+		inf_loop=$(( ${inf_loop} + 1 ))
+		[[ ${inf_loop} -gt 20 ]] && \
+			die "versionator compare bug [numbers, ${ver_a}, ${ver_b}]"
+
+		# grab the current number components
+		local cur_tok_a=${parts_a[${cur_idx_a}]}
+		local cur_tok_b=${parts_b[${cur_idx_b}]}
+
+		# number?
+		if [[ -n ${cur_tok_a} ]] && [[ -z ${cur_tok_a//[[:digit:]]} ]] ; then
+			cur_idx_a=$(( ${cur_idx_a} + 1 ))
+			[[ ${parts_a[${cur_idx_a}]} == "." ]] \
+				&& cur_idx_a=$(( ${cur_idx_a} + 1 ))
+		else
+			cur_tok_a=""
+		fi
+
+		if [[ -n ${cur_tok_b} ]] && [[ -z ${cur_tok_b//[[:digit:]]} ]] ; then
+			cur_idx_b=$(( ${cur_idx_b} + 1 ))
+			[[ ${parts_b[${cur_idx_b}]} == "." ]] \
+				&& cur_idx_b=$(( ${cur_idx_b} + 1 ))
+		else
+			cur_tok_b=""
+		fi
+
+		# done with number components?
+		[[ -z ${cur_tok_a} ]] && [[ -z ${cur_tok_b} ]] && break
+
+		# to avoid going into octal mode, strip any leading zeros. otherwise
+		# bash will throw a hissy fit on versions like 6.3.068.
+		cur_tok_a=${cur_tok_a##+(0)}
+		cur_tok_b=${cur_tok_b##+(0)}
+
+		# if a component is blank, make it zero.
+		[[ -z ${cur_tok_a} ]] && cur_tok_a=0
+		[[ -z ${cur_tok_b} ]] && cur_tok_b=0
+
+		# compare
+		[[ ${cur_tok_a} -lt ${cur_tok_b} ]] && eshopts_pop && return 1
+		[[ ${cur_tok_a} -gt ${cur_tok_b} ]] && eshopts_pop && return 3
+	done
+
+	### number parts equal. compare letter parts.
+	local letter_a=
+	letter_a=${parts_a[${cur_idx_a}]}
+	if [[ ${#letter_a} -eq 1 ]] && [[ -z ${letter_a/[a-z]} ]] ; then
+		cur_idx_a=$(( ${cur_idx_a} + 1 ))
+	else
+		letter_a="@"
+	fi
+
+	local letter_b=
+	letter_b=${parts_b[${cur_idx_b}]}
+	if [[ ${#letter_b} -eq 1 ]] && [[ -z ${letter_b/[a-z]} ]] ; then
+		cur_idx_b=$(( ${cur_idx_b} + 1 ))
+	else
+		letter_b="@"
+	fi
+
+	# compare
+	[[ ${letter_a} < ${letter_b} ]] && eshopts_pop && return 1
+	[[ ${letter_a} > ${letter_b} ]] && eshopts_pop && return 3
+
+	### letter parts equal. compare suffixes in order.
+	local suffix rule part r_lt r_gt
+	for rule in "alpha=1" "beta=1" "pre=1" "rc=1" "p=3" "r=3" ; do
+		suffix=${rule%%=*}
+		r_lt=${rule##*=}
+		[[ ${r_lt} -eq 1 ]] && r_gt=3 || r_gt=1
+
+		local suffix_a=
+		for part in ${parts_a[@]} ; do
+			[[ ${part#${suffix}} != ${part} ]] && \
+				[[ -z ${part##${suffix}*([[:digit:]])} ]] && \
+				suffix_a=${part#${suffix}}0
+		done
+
+		local suffix_b=
+		for part in ${parts_b[@]} ; do
+			[[ ${part#${suffix}} != ${part} ]] && \
+				[[ -z ${part##${suffix}*([[:digit:]])} ]] && \
+				suffix_b=${part#${suffix}}0
+		done
+
+		[[ -z ${suffix_a} ]] && [[ -z ${suffix_b} ]] && continue
+
+		[[ -z ${suffix_a} ]] && eshopts_pop && return ${r_gt}
+		[[ -z ${suffix_b} ]] && eshopts_pop && return ${r_lt}
+
+		# avoid octal problems
+		suffix_a=${suffix_a##+(0)} ; suffix_a=${suffix_a:-0}
+		suffix_b=${suffix_b##+(0)} ; suffix_b=${suffix_b:-0}
+
+		[[ ${suffix_a} -lt ${suffix_b} ]] && eshopts_pop && return 1
+		[[ ${suffix_a} -gt ${suffix_b} ]] && eshopts_pop && return 3
+	done
+
+	### no differences.
+	eshopts_pop
+	return 2
+}
+
+# @FUNCTION: version_sort
+# @USAGE: <version> [more versions...]
+# @DESCRIPTION:
+# Returns its parameters sorted, highest version last. We're using a quadratic
+# algorithm for simplicity, so don't call it with more than a few dozen items.
+# Uses version_compare, so be careful.
+version_sort() {
+	eshopts_push -s extglob
+	local items= left=0
+	items=( $@ )
+	while [[ ${left} -lt ${#items[@]} ]] ; do
+		local lowest_idx=${left}
+		local idx=$(( ${lowest_idx} + 1 ))
+		while [[ ${idx} -lt ${#items[@]} ]] ; do
+			version_compare "${items[${lowest_idx}]}" "${items[${idx}]}"
+			[[ $? -eq 3 ]] && lowest_idx=${idx}
+			idx=$(( ${idx} + 1 ))
+		done
+		local tmp=${items[${lowest_idx}]}
+		items[${lowest_idx}]=${items[${left}]}
+		items[${left}]=${tmp}
+		left=$(( ${left} + 1 ))
+	done
+	echo ${items[@]}
+	eshopts_pop
+}
+
+# @FUNCTION: version_format_string
+# @USAGE: <format> [version]
+# @DESCRIPTION:
+# Reformat complicated version strings.  The first argument is the string
+# to reformat with while the rest of the args are passed on to the
+# get_version_components function.  You should make sure to single quote
+# the first argument since it'll have variables that get delayed expansion.s
+# @EXAMPLE:
+# P="cow-hat-1.2.3_p4"
+# MY_P=$(version_format_string '${PN}_source_$1_$2-$3_$4')
+# Now MY_P will be: cow-hat_source_1_2-3_p4
+version_format_string() {
+	local fstr=$1
+	shift
+	set -- $(get_version_components "$@")
+	eval echo "${fstr}"
+}
+
+__versionator__test_version_compare() {
+	eshopts_push -s extglob
+	local lt=1 eq=2 gt=3 p q
+
+	__versionator__test_version_compare_t() {
+		version_compare "${1}" "${3}"
+		local r=$?
+		[[ ${r} -eq ${2} ]] || echo "FAIL: ${@} (got ${r} exp ${2})"
+	}
+
+	echo "
+		0             $lt 1
+		1             $lt 2
+		2             $gt 1
+		2             $eq 2
+		0             $eq 0
+		10            $lt 20
+		68            $eq 068
+		068           $gt 67
+		068           $lt 69
+
+		1.0           $lt 2.0
+		2.0           $eq 2.0
+		2.0           $gt 1.0
+
+		1.0           $gt 0.0
+		0.0           $eq 0.0
+		0.0           $lt 1.0
+
+		0.1           $lt 0.2
+		0.2           $eq 0.2
+		0.3           $gt 0.2
+
+		1.2           $lt 2.1
+		2.1           $gt 1.2
+
+		1.2.3         $lt 1.2.4
+		1.2.4         $gt 1.2.3
+
+		1.2.0         $eq 1.2
+		1.2.1         $gt 1.2
+		1.2           $lt 1.2.1
+
+		1.2b          $eq 1.2b
+		1.2b          $lt 1.2c
+		1.2b          $gt 1.2a
+		1.2b          $gt 1.2
+		1.2           $lt 1.2a
+
+		1.3           $gt 1.2a
+		1.3           $lt 1.3a
+
+		1.0_alpha7    $lt 1.0_beta7
+		1.0_beta      $lt 1.0_pre
+		1.0_pre5      $lt 1.0_rc2
+		1.0_rc2       $lt 1.0
+
+		1.0_p1        $gt 1.0
+		1.0_p1-r1     $gt 1.0_p1
+
+		1.0_alpha6-r1 $gt 1.0_alpha6
+		1.0_beta6-r1  $gt 1.0_alpha6-r2
+
+		1.0_pre1      $lt 1.0-p1
+
+		1.0p          $gt 1.0_p1
+		1.0r          $gt 1.0-r1
+		1.6.15        $gt 1.6.10-r2
+		1.6.10-r2     $lt 1.6.15
+
+	" | while read a b c ; do
+		[[ -z "${a}${b}${c}" ]] && continue;
+		__versionator__test_version_compare_t "${a}" "${b}" "${c}"
+	done
+
+
+	for q in "alpha beta pre rc=${lt};${gt}" "p r=${gt};${lt}" ; do
+		for p in ${q%%=*} ; do
+			local c=${q##*=}
+			local alt=${c%%;*} agt=${c##*;}
+			__versionator__test_version_compare_t "1.0" $agt "1.0_${p}"
+			__versionator__test_version_compare_t "1.0" $agt "1.0_${p}1"
+			__versionator__test_version_compare_t "1.0" $agt "1.0_${p}068"
+
+			__versionator__test_version_compare_t "2.0_${p}"    $alt "2.0"
+			__versionator__test_version_compare_t "2.0_${p}1"   $alt "2.0"
+			__versionator__test_version_compare_t "2.0_${p}068" $alt "2.0"
+
+			__versionator__test_version_compare_t "1.0_${p}"  $eq "1.0_${p}"
+			__versionator__test_version_compare_t "0.0_${p}"  $lt "0.0_${p}1"
+			__versionator__test_version_compare_t "666_${p}3" $gt "666_${p}"
+
+			__versionator__test_version_compare_t "1_${p}7"  $lt "1_${p}8"
+			__versionator__test_version_compare_t "1_${p}7"  $eq "1_${p}7"
+			__versionator__test_version_compare_t "1_${p}7"  $gt "1_${p}6"
+			__versionator__test_version_compare_t "1_${p}09" $eq "1_${p}9"
+		done
+	done
+
+	for p in "-r" "_p" ; do
+		__versionator__test_version_compare_t "7.2${p}1" $lt "7.2${p}2"
+		__versionator__test_version_compare_t "7.2${p}2" $gt "7.2${p}1"
+		__versionator__test_version_compare_t "7.2${p}3" $gt "7.2${p}2"
+		__versionator__test_version_compare_t "7.2${p}2" $lt "7.2${p}3"
+	done
+	eshopts_pop
+}