#!/bin/bash
# Copyright 1999-2015 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2

# Prevent aliases from causing portage to act inappropriately.
# Make sure it's before everything so we don't mess aliases that follow.
unalias -a

# Make sure this isn't exported to scripts we execute.
unset BASH_COMPAT

source "${PORTAGE_BIN_PATH}/isolated-functions.sh" || exit 1

# Set up the bash version compatibility level.  This does not disable
# features when running with a newer version, but makes it so that when
# bash changes behavior in an incompatible way, the older behavior is
# used instead.
proc __check_bash_version {
	# Figure out which min version of bash we require.
	local maj min
	if ___eapi_bash_3_2  {
		setvar maj = '3', min = '2'
	} elif ___eapi_bash_4_2  {
		setvar maj = '4', min = '2'
	} else {
		return
	}

	# Make sure the active bash is sane.
	if [[ ${BASH_VERSINFO[0]} -lt ${maj} ]] ||
	   [[ ${BASH_VERSINFO[0]} -eq ${maj} && ${BASH_VERSINFO[1]} -lt ${min} ]]  {
		die ">=bash-${maj}.${min} is required"
	}

	# Set the compat level in case things change with newer ones.  We must not
	# export this into the env otherwise we might break  other shell scripts we
	# execute (e.g. ones in /usr/bin).
	setvar BASH_COMPAT = ""${maj}.${min}""

	# The variable above is new to bash-4.3.  For older versions, we have to use
	# a compat knob.  Further, the compat knob only exists with older versions
	# (e.g. bash-4.3 has compat42 but not compat43).  This means we only need to
	# turn the knob with older EAPIs, and only when running newer bash versions:
	# there is no bash-3.3 (it went 3.2 to 4.0), and when requiring bash-4.2, the
	# var works with bash-4.3+, and you don't need to set compat to 4.2 when you
	# are already running 4.2.
	if ___eapi_bash_3_2 && [[ ${BASH_VERSINFO[0]} -gt 3 ]]  {
		shopt -s compat32
	}
}
__check_bash_version

if [[ $EBUILD_PHASE != depend ]]  {
	source "${PORTAGE_BIN_PATH}/phase-functions.sh" || die
	source "${PORTAGE_BIN_PATH}/save-ebuild-env.sh" || die
	source "${PORTAGE_BIN_PATH}/phase-helpers.sh" || die
	source "${PORTAGE_BIN_PATH}/bashrc-functions.sh" || die
} else {
	# These dummy functions are for things that are likely to be called
	# in global scope, even though they are completely useless during
	# the "depend" phase.
	setvar funcs = ""diropts docompress exeopts get_KV insopts
		KV_major KV_micro KV_minor KV_to_int
		libopts register_die_hook register_success_hook
		__strip_duplicate_slashes
		use useq usev use_with use_enable""
	___eapi_has_usex && setvar funcs = "" usex""
	___eapi_has_in_iuse && setvar funcs = "" in_iuse""
	___eapi_has_get_libdir && setvar funcs = "" get_libdir""
	# These functions die because calls to them during the "depend" phase
	# are considered to be severe QA violations.
	setvar funcs = "" best_version has_version portageq""
	___eapi_has_master_repositories && setvar funcs = "" master_repositories""
	___eapi_has_repository_path && setvar funcs = "" repository_path""
	___eapi_has_available_eclasses && setvar funcs = "" available_eclasses""
	___eapi_has_eclass_path && setvar funcs = "" eclass_path""
	___eapi_has_license_path && setvar funcs = "" license_path""
	for x in ${funcs}  {
		eval "${x}() { die \"\${FUNCNAME}() calls are not allowed in global scope\"; }"
	}
	unset funcs x

	# prevent the shell from finding external executables
	# note: we can't use empty because it implies current directory
	setvar _PORTAGE_ORIG_PATH = ${PATH}
	export PATH=/dev/null
	proc command_not_found_handle {
		die "External commands disallowed while sourcing ebuild: ${*}"
	}
}

# Don't use sandbox's BASH_ENV for new shells because it does
# 'source /etc/profile' which can interfere with the build
# environment by modifying our PATH.
unset BASH_ENV

# This is just a temporary workaround for portage-9999 users since
# earlier portage versions do not detect a version change in this case
# (9999 to 9999) and therefore they try execute an incompatible version of
# ebuild.sh during the upgrade.
export PORTAGE_BZIP2_COMMAND=${PORTAGE_BZIP2_COMMAND:-bzip2} 

# These two functions wrap sourcing and calling respectively.  At present they
# perform a qa check to make sure eclasses and ebuilds and profiles don't mess
# with shell opts (shopts).  Ebuilds/eclasses changing shopts should reset them 
# when they are done.

proc __qa_source {
	local shopts=$(shopt) OLDIFS="$IFS"
	local retval
	source @ARGV
	setvar retval = ""$?
	set +e
	[[ $shopts != $(shopt) ]] &&
		eqawarn "QA Notice: Global shell options changed and were not restored while sourcing '$[join(ARGV)]'"
	[[ "$IFS" != "$OLDIFS" ]] &&
		eqawarn "QA Notice: Global IFS changed and was not restored while sourcing '$[join(ARGV)]'"
	return $retval
}

proc __qa_call {
	local shopts=$(shopt) OLDIFS="$IFS"
	local retval
	@ARGV
	setvar retval = ""$?
	set +e
	[[ $shopts != $(shopt) ]] &&
		eqawarn "QA Notice: Global shell options changed and were not restored while calling '$[join(ARGV)]'"
	[[ "$IFS" != "$OLDIFS" ]] &&
		eqawarn "QA Notice: Global IFS changed and was not restored while calling '$[join(ARGV)]'"
	return $retval
}

setvar EBUILD_SH_ARGS = ""$[join(ARGV)]""

shift $Argc

# Unset some variables that break things.
unset GZIP BZIP BZIP2 CDPATH GREP_OPTIONS GREP_COLOR GLOBIGNORE

[[ $PORTAGE_QUIET != "" ]] && export PORTAGE_QUIET

# sandbox support functions; defined prior to profile.bashrc srcing, since the profile might need to add a default exception (/usr/lib64/conftest fex)
proc __sb_append_var {
	local _v=$1 ; shift
	local var="SANDBOX_${_v}"
	[[ -z $1 || -n $2 ]] && die "Usage: add$(LC_ALL=C tr "[:upper:]" "[:lower:]" <<< "${_v}") <colon-delimited list of paths>"
	export ${var}="${!var:+${!var}:}$1"
}
# bash-4 version:
# local var="SANDBOX_${1^^}"
# addread() { __sb_append_var ${0#add} "$@" ; }
proc addread { __sb_append_var READ    @ARGV ; }
proc addwrite { __sb_append_var WRITE   @ARGV ; }
proc adddeny { __sb_append_var DENY    @ARGV ; }
proc addpredict { __sb_append_var PREDICT @ARGV ; }

addwrite ${PORTAGE_TMPDIR}
addread "/:${PORTAGE_TMPDIR}"
[[ -n ${PORTAGE_GPG_DIR} ]] && addpredict ${PORTAGE_GPG_DIR}

# Avoid sandbox violations in temporary directories.
if [[ -w $T ]]  {
	export TEMP=$T
	export TMP=$T
	export TMPDIR=$T
} elif [[ $SANDBOX_ON = 1 ]]  {
	for x in TEMP TMP TMPDIR  {
		[[ -n ${!x} ]] && addwrite ${!x}
	}
	unset x
}

# the sandbox is disabled by default except when overridden in the relevant stages
export SANDBOX_ON=0

# Ensure that $PWD is sane whenever possible, to protect against
# exploitation of insecure search path for python -c in ebuilds.
# See bug #239560, bug #469338, and bug #595028.
if [[ -d ${HOME} ]] {
	# Use portage's temporary HOME directory if available.
	cd ${HOME} || die
} else {
	cd ${PORTAGE_PYM_PATH} || \
		die "PORTAGE_PYM_PATH does not exist: '${PORTAGE_PYM_PATH}'"
}

#if no perms are specified, dirs/files will have decent defaults
#(not secretive, but not stupid)
umask 022

# debug-print() gets called from many places with verbose status information useful
# for tracking down problems. The output is in $T/eclass-debug.log.
# You can set ECLASS_DEBUG_OUTPUT to redirect the output somewhere else as well.
# The special "on" setting echoes the information, mixing it with the rest of the
# emerge output.
# You can override the setting by exporting a new one from the console, or you can
# set a new default in make.*. Here the default is "" or unset.

# in the future might use e* from /etc/init.d/functions.sh if i feel like it
proc debug-print {
	# if $T isn't defined, we're in dep calculation mode and
	# shouldn't do anything
	[[ $EBUILD_PHASE = depend || ! -d ${T} || ${#} -eq 0 ]] && return 0

	if [[ ${ECLASS_DEBUG_OUTPUT} == on ]] {
		printf 'debug: %s\n' ${@} >&2
	} elif [[ -n ${ECLASS_DEBUG_OUTPUT} ]] {
		printf 'debug: %s\n' ${@} >> "${ECLASS_DEBUG_OUTPUT}"
	}

	if [[ -w $T ]]  {
		# default target
		printf '%s\n' ${@} >> "${T}/eclass-debug.log"
		# let the portage user own/write to this file
		chgrp ${PORTAGE_GRPNAME:-portage} "${T}/eclass-debug.log"
		chmod g+w "${T}/eclass-debug.log"
	}
}

# The following 2 functions are debug-print() wrappers

proc debug-print-function {
	debug-print "${1}: entering function, parameters: ${*:2}"
}

proc debug-print-section {
	debug-print "now in section ${*}"
}

# Sources all eclasses in parameters
declare -ix ECLASS_DEPTH=0
proc inherit {
	setvar ECLASS_DEPTH = $(($ECLASS_DEPTH + 1))
	if [[ ${ECLASS_DEPTH} > 1 ]] {
		debug-print "*** Multiple Inheritence (Level: ${ECLASS_DEPTH})"
	}

	if [[ -n $ECLASS && -n ${!__export_funcs_var} ]]  {
		echo "QA Notice: EXPORT_FUNCTIONS is called before inherit in" \
			"$ECLASS.eclass. For compatibility with <=portage-2.1.6.7," \
			"only call EXPORT_FUNCTIONS after inherit(s)." \
			| fmt -w 75 | while read -r { eqawarn $REPLY ; }
	}

	local repo_location
	local location
	local potential_location
	local x

	# These variables must be restored before returning.
	local PECLASS=$ECLASS
	local prev_export_funcs_var=$__export_funcs_var

	local B_IUSE
	local B_REQUIRED_USE
	local B_DEPEND
	local B_RDEPEND
	local B_PDEPEND
	local B_HDEPEND
	while test $1 {
		setvar location = """"
		setvar potential_location = """"

		export ECLASS="$1"
		setvar __export_funcs_var = "__export_functions_$ECLASS_DEPTH"
		unset $__export_funcs_var

		if [[ ${EBUILD_PHASE} != depend && ${EBUILD_PHASE} != nofetch && \
			${EBUILD_PHASE} != *rm && ${EMERGE_FROM} != "binary" && \
			-z ${_IN_INSTALL_QA_CHECK} ]]
		{
			# This is disabled in the *rm phases because they frequently give
			# false alarms due to INHERITED in /var/db/pkg being outdated
			# in comparison the the eclasses from the portage tree. It's
			# disabled for nofetch, since that can be called by repoman and
			# that triggers bug #407449 due to repoman not exporting
			# non-essential variables such as INHERITED.
			if ! has $ECLASS $INHERITED $__INHERITED_QA_CACHE  {
				eqawarn "QA Notice: ECLASS '$ECLASS' inherited illegally in $CATEGORY/$PF $EBUILD_PHASE"
			}
		}

		for repo_location in "${PORTAGE_ECLASS_LOCATIONS[@]}" {
			setvar potential_location = ""${repo_location}/eclass/${1}.eclass""
			if [[ -f ${potential_location} ]] {
				setvar location = "${potential_location}"
				debug-print "  eclass exists: ${location}"
				break
			}
		}
		debug-print "inherit: $1 -> $location"
		[[ -z ${location} ]] && die "${1}.eclass could not be found by inherit()"

		# inherits in QA checks can't handle metadata assignments
		if [[ -z ${_IN_INSTALL_QA_CHECK} ]] {
			#We need to back up the values of *DEPEND to B_*DEPEND
			#(if set).. and then restore them after the inherit call.

			#turn off glob expansion
			set -f

			# Retain the old data and restore it later.
			unset B_IUSE B_REQUIRED_USE B_DEPEND B_RDEPEND B_PDEPEND B_HDEPEND
			test ${IUSE+set}       = set && setvar B_IUSE = "${IUSE}"
			test ${REQUIRED_USE+set} = set && setvar B_REQUIRED_USE = "${REQUIRED_USE}"
			test ${DEPEND+set}     = set && setvar B_DEPEND = "${DEPEND}"
			test ${RDEPEND+set}    = set && setvar B_RDEPEND = "${RDEPEND}"
			test ${PDEPEND+set}    = set && setvar B_PDEPEND = "${PDEPEND}"
			test ${HDEPEND+set}    = set && setvar B_HDEPEND = "${HDEPEND}"
			unset IUSE REQUIRED_USE DEPEND RDEPEND PDEPEND HDEPEND
			#turn on glob expansion
			set +f
		}

		__qa_source $location || die "died sourcing $location in inherit()"
		
		if [[ -z ${_IN_INSTALL_QA_CHECK} ]] {
			#turn off glob expansion
			set -f

			# If each var has a value, append it to the global variable E_* to
			# be applied after everything is finished. New incremental behavior.
			test ${IUSE+set}         = set && setvar E_IUSE = ""${E_IUSE:+ }${IUSE}""
			test ${REQUIRED_USE+set} = set && setvar E_REQUIRED_USE = ""${E_REQUIRED_USE:+ }${REQUIRED_USE}""
			test ${DEPEND+set}       = set && setvar E_DEPEND = ""${E_DEPEND:+ }${DEPEND}""
			test ${RDEPEND+set}      = set && setvar E_RDEPEND = ""${E_RDEPEND:+ }${RDEPEND}""
			test ${PDEPEND+set}      = set && setvar E_PDEPEND = ""${E_PDEPEND:+ }${PDEPEND}""
			test ${HDEPEND+set}      = set && setvar E_HDEPEND = ""${E_HDEPEND:+ }${HDEPEND}""

			test ${B_IUSE+set}     = set && setvar IUSE = "${B_IUSE}"
			test ${B_IUSE+set}     = set || unset IUSE
			
			test ${B_REQUIRED_USE+set}     = set && setvar REQUIRED_USE = "${B_REQUIRED_USE}"
			test ${B_REQUIRED_USE+set}     = set || unset REQUIRED_USE

			test ${B_DEPEND+set}   = set && setvar DEPEND = "${B_DEPEND}"
			test ${B_DEPEND+set}   = set || unset DEPEND

			test ${B_RDEPEND+set}  = set && setvar RDEPEND = "${B_RDEPEND}"
			test ${B_RDEPEND+set}  = set || unset RDEPEND

			test ${B_PDEPEND+set}  = set && setvar PDEPEND = "${B_PDEPEND}"
			test ${B_PDEPEND+set}  = set || unset PDEPEND

			test ${B_HDEPEND+set}  = set && setvar HDEPEND = "${B_HDEPEND}"
			test ${B_HDEPEND+set}  = set || unset HDEPEND

			#turn on glob expansion
			set +f

			if [[ -n ${!__export_funcs_var} ]]  {
				for x in ${!__export_funcs_var}  {
					debug-print "EXPORT_FUNCTIONS: $x -> ${ECLASS}_$x"
					declare -F "${ECLASS}_$x" >/dev/null || \
						die "EXPORT_FUNCTIONS: ${ECLASS}_$x is not defined"
					eval "$x() { ${ECLASS}_$x \"\$@\" ; }" > /dev/null
				}
			}
			unset $__export_funcs_var

			has $1 $INHERITED || export INHERITED="$INHERITED $1"
		}

		shift
	}
	((--ECLASS_DEPTH)) # Returns 1 when ECLASS_DEPTH reaches 0.
	if (( ECLASS_DEPTH > 0 ))  {
		export ECLASS=$PECLASS
		setvar __export_funcs_var = "$prev_export_funcs_var"
	} else {
		unset ECLASS __export_funcs_var
	}
	return 0
}

# Exports stub functions that call the eclass's functions, thereby making them default.
# For example, if ECLASS="base" and you call "EXPORT_FUNCTIONS src_unpack", the following
# code will be eval'd:
# src_unpack() { base_src_unpack; }
proc EXPORT_FUNCTIONS {
	if test -z $ECLASS {
		die "EXPORT_FUNCTIONS without a defined ECLASS"
	}
	eval $__export_funcs_var+='"' $[join(ARGV)]'"'
}

setvar PORTAGE_BASHRCS_SOURCED = '0'

# @FUNCTION: __source_all_bashrcs
# @DESCRIPTION:
# Source a relevant bashrc files and perform other miscellaneous
# environment initialization when appropriate.
#
# If EAPI is set then define functions provided by the current EAPI:
#
#  * default_* aliases for the current EAPI phase functions
#  * A "default" function which is an alias for the default phase
#    function for the current phase.
#
proc __source_all_bashrcs {
	[[ $PORTAGE_BASHRCS_SOURCED = 1 ]] && return 0
	setvar PORTAGE_BASHRCS_SOURCED = '1'
	local x

	local OCC="${CC}" OCXX="${CXX}"

	if [[ $EBUILD_PHASE != depend ]]  {
		# source the existing profile.bashrcs.
		save_IFS
		setvar IFS = '$'\n''
		local bashenv_files=($PORTAGE_BASHRC_FILES)
		restore_IFS
		for x in "${bashenv_files[@]}"  {
			__try_source ${x}
		}
	}

	# The user's bashrc is the ONLY non-portage bit of code
	# that can change shopts without a QA violation.
	__try_source --no-qa ${PORTAGE_BASHRC}

	if [[ $EBUILD_PHASE != depend ]]  {
		__source_env_files --no-qa ${PM_EBUILD_HOOK_DIR}
	}

	test ! -z ${OCC} && export CC="${OCC}"
	test ! -z ${OCXX} && export CXX="${OCXX}"
}

# @FUNCTION: __source_env_files
# @USAGE: [--no-qa] <ENV_DIRECTORY>
# @DESCRIPTION:
# Source the files relevant to the current package from the given path.
# If --no-qa is specified, use source instead of __qa_source to source the
# files.
proc __source_env_files {
	local argument=()
	if [[ $1 == --no-qa ]] {
		setvar argument = ''( --no-qa )
	shift
	}
	for x in "${1}"/${CATEGORY}/{${PN},${PN}:${SLOT%/*},${P},${PF}} {
		__try_source ${argument[@]} ${x}
	}
}

# @FUNCTION: __try_source
# @USAGE: [--no-qa] <FILE>
# @DESCRIPTION:
# If the path given as argument exists, source the file while preserving
# $-.
# If --no-qa is specified, source the file with source instead of __qa_source.
proc __try_source {
	local qa=true
	if [[ $1 == --no-qa ]] {
		setvar qa = 'false'
		shift
	}
	if [[ -r $1 && -f $1 ]] {
		local debug_on=false
		if [[ "$PORTAGE_DEBUG" == "1" ]] && [[ "${-/x/}" == "$-" ]] {
			setvar debug_on = 'true'
		}
		$debug_on && set -x
		# If $- contains x, then tracing has already been enabled
		# elsewhere for some reason. We preserve it's state so as
		# not to interfere.
		if [[ ${qa} ]] {
			source ${1}
		} else {
			__qa_source ${1}
		}
		$debug_on && set +x
	}
}
# === === === === === === === === === === === === === === === === === ===
# === === === === === functions end, main part begins === === === === ===
# === === === === === === === === === === === === === === === === === ===

export SANDBOX_ON="1"
export S=${WORKDIR}/${P}

# Turn of extended glob matching so that g++ doesn't get incorrectly matched.
shopt -u extglob

if [[ ${EBUILD_PHASE} == depend ]]  {
	setvar QA_INTERCEPTORS = ""awk bash cc egrep equery fgrep g++
		gawk gcc grep javac java-config nawk perl
		pkg-config python python-config sed""
} elif [[ ${EBUILD_PHASE} == clean* ]]  {
	unset QA_INTERCEPTORS
} else {
	setvar QA_INTERCEPTORS = ""autoconf automake aclocal libtoolize""
}
# level the QA interceptors if we're in depend
if [[ -n ${QA_INTERCEPTORS} ]]  {
	for BIN in ${QA_INTERCEPTORS} {
		setvar BIN_PATH = $(type -Pf ${BIN})
		if test "$?" != "0" {
			setvar BODY = ""echo \"*** missing command: ${BIN}\" >&2; return 127""
		} else {
			setvar BODY = ""${BIN_PATH} \"\$@\"; return \$?""
		}
		if [[ ${EBUILD_PHASE} == depend ]]  {
			setvar FUNC_SRC = ""${BIN}() {
				if [ \$ECLASS_DEPTH -gt 0 ]; then
					eqawarn \"QA Notice: '${BIN}' called in global scope: eclass \${ECLASS}\"
				else
					eqawarn \"QA Notice: '${BIN}' called in global scope: \${CATEGORY}/\${PF}\"
				fi
			${BODY}
			}""
		} elif has ${BIN} autoconf automake aclocal libtoolize  {
			setvar FUNC_SRC = ""${BIN}() {
				if ! has \${FUNCNAME[1]} eautoreconf eaclocal _elibtoolize \\
					eautoheader eautoconf eautomake autotools_run_tool \\
					autotools_check_macro autotools_get_subdirs \\
					autotools_get_auxdir ; then
					eqawarn \"QA Notice: '${BIN}' called by \${FUNCNAME[1]}: \${CATEGORY}/\${PF}\"
					eqawarn \"Use autotools.eclass instead of calling '${BIN}' directly.\"
				fi
			${BODY}
			}""
		} else {
			setvar FUNC_SRC = ""${BIN}() {
				eqawarn \"QA Notice: '${BIN}' called by \${FUNCNAME[1]}: \${CATEGORY}/\${PF}\"
			${BODY}
			}""
		}
		eval $FUNC_SRC || echo "error creating QA interceptor ${BIN}" >&2
	}
	unset BIN_PATH BIN BODY FUNC_SRC
}

# Subshell/helper die support (must export for the die helper).
export EBUILD_MASTER_PID=${BASHPID:-$(__bashpid)}
trap 'exit 1' SIGTERM

if ! has $EBUILD_PHASE clean cleanrm depend && \
	! [[ $EMERGE_FROM = ebuild && $EBUILD_PHASE = setup ]] && \
	test -f "${T}"/environment  {
	# The environment may have been extracted from environment.bz2 or
	# may have come from another version of ebuild.sh or something.
	# In any case, preprocess it to prevent any potential interference.
	# NOTE: export ${FOO}=... requires quoting, unlike normal exports
	__preprocess_ebuild_env || \
		die "error processing environment"
	# Colon separated SANDBOX_* variables need to be cumulative.
	for x in SANDBOX_DENY SANDBOX_READ SANDBOX_PREDICT SANDBOX_WRITE  {
		export PORTAGE_${x}="${!x}"
	}
	setvar PORTAGE_SANDBOX_ON = ${SANDBOX_ON}
	export SANDBOX_ON=1
	source "${T}"/environment || \
		die "error sourcing environment"
	# We have to temporarily disable sandbox since the
	# SANDBOX_{DENY,READ,PREDICT,WRITE} values we've just loaded
	# may be unusable (triggering in spurious sandbox violations)
	# until we've merged them with our current values.
	export SANDBOX_ON=0
	for x in SANDBOX_DENY SANDBOX_PREDICT SANDBOX_READ SANDBOX_WRITE  {
		setvar y = ""PORTAGE_${x}""
		if test -z ${!x}  {
			export ${x}="${!y}"
		} elif test -n ${!y} && test ${!y} != ${!x}  {
			# filter out dupes
			export ${x}="$(printf "${!y}:${!x}" | tr ":" "\0" | \
				sort -z -u | tr "\0" ":")"
		}
		export ${x}="${!x%:}"
		unset PORTAGE_${x}
	}
	unset x y
	export SANDBOX_ON=${PORTAGE_SANDBOX_ON}
	unset PORTAGE_SANDBOX_ON
	[[ -n $EAPI ]] || setvar EAPI = '0'
}

if ___eapi_enables_globstar {
	shopt -s globstar
}

# Convert quoted paths to array.
eval "PORTAGE_ECLASS_LOCATIONS=(${PORTAGE_ECLASS_LOCATIONS})"

# Source the ebuild every time for FEATURES=noauto, so that ebuild
# modifications take effect immediately.
if ! has $EBUILD_PHASE clean cleanrm  {
	if [[ $EBUILD_PHASE = setup && $EMERGE_FROM = ebuild ]] || \
		[[ $EBUILD_PHASE = depend || ! -f $T/environment || \
		-f $PORTAGE_BUILDDIR/.ebuild_changed || \
		" ${FEATURES} " == *" noauto "* ]]  {
		# The bashrcs get an opportunity here to set aliases that will be expanded
		# during sourcing of ebuilds and eclasses.
		__source_all_bashrcs

		# When EBUILD_PHASE != depend, INHERITED comes pre-initialized
		# from cache. In order to make INHERITED content independent of
		# EBUILD_PHASE during inherit() calls, we unset INHERITED after
		# we make a backup copy for QA checks.
		setvar __INHERITED_QA_CACHE = "$INHERITED"

		# Catch failed globbing attempts in case ebuild writer forgot to
		# escape '*' or likes.
		# Note: this needs to be done before unsetting EAPI.
		if ___eapi_enables_failglob_in_global_scope {
			shopt -s failglob
		}

		# *DEPEND and IUSE will be set during the sourcing of the ebuild.
		# In order to ensure correct interaction between ebuilds and
		# eclasses, they need to be unset before this process of
		# interaction begins.
		unset EAPI DEPEND RDEPEND PDEPEND HDEPEND INHERITED IUSE REQUIRED_USE \
			ECLASS E_IUSE E_REQUIRED_USE E_DEPEND E_RDEPEND E_PDEPEND \
			E_HDEPEND PROVIDES_EXCLUDE REQUIRES_EXCLUDE

		if [[ $PORTAGE_DEBUG != 1 || ${-/x/} != $- ]]  {
			source $EBUILD || die "error sourcing ebuild"
		} else {
			set -x
			source $EBUILD || die "error sourcing ebuild"
			set +x
		}

		if ___eapi_enables_failglob_in_global_scope {
			shopt -u failglob
		}

		if [[ "${EBUILD_PHASE}" != "depend" ]]  {
			setvar RESTRICT = ${PORTAGE_RESTRICT}
			[[ -e $PORTAGE_BUILDDIR/.ebuild_changed ]] && \
			rm "$PORTAGE_BUILDDIR/.ebuild_changed"
		}

		test ${EAPI+set} = set || setvar EAPI = '0'

		# export EAPI for helpers (especially since we unset it above)
		export EAPI

		if ___eapi_has_RDEPEND_DEPEND_fallback {
			export RDEPEND=${RDEPEND-${DEPEND}}
			debug-print "RDEPEND: not set... Setting to: ${DEPEND}"
		}

		# add in dependency info from eclasses
		setvar IUSE = ""${IUSE:+ }${E_IUSE}""
		setvar DEPEND = ""${DEPEND:+ }${E_DEPEND}""
		setvar RDEPEND = ""${RDEPEND:+ }${E_RDEPEND}""
		setvar PDEPEND = ""${PDEPEND:+ }${E_PDEPEND}""
		setvar HDEPEND = ""${HDEPEND:+ }${E_HDEPEND}""
		setvar REQUIRED_USE = ""${REQUIRED_USE:+ }${E_REQUIRED_USE}""
		
		unset ECLASS E_IUSE E_REQUIRED_USE E_DEPEND E_RDEPEND E_PDEPEND E_HDEPEND \
			__INHERITED_QA_CACHE

		# alphabetically ordered by $EBUILD_PHASE value
		case{
			0|1 {
				setvar _valid_phases = ""src_compile pkg_config pkg_info src_install
					pkg_nofetch pkg_postinst pkg_postrm pkg_preinst pkg_prerm
					pkg_setup src_test src_unpack""
				}
			2|3 {
				setvar _valid_phases = ""src_compile pkg_config src_configure pkg_info
					src_install pkg_nofetch pkg_postinst pkg_postrm pkg_preinst
					src_prepare pkg_prerm pkg_setup src_test src_unpack""
				}
			* {
				setvar _valid_phases = ""src_compile pkg_config src_configure pkg_info
					src_install pkg_nofetch pkg_postinst pkg_postrm pkg_preinst
					src_prepare pkg_prerm pkg_pretend pkg_setup src_test src_unpack""
				}
		}

		setvar DEFINED_PHASES = ''
		for _f in $_valid_phases  {
			if declare -F $_f >/dev/null  {
				setvar _f = ${_f#pkg_}
				setvar DEFINED_PHASES = "" ${_f#src_}""
			}
		}
		[[ -n $DEFINED_PHASES ]] || setvar DEFINED_PHASES = '-'

		unset _f _valid_phases

		if [[ $EBUILD_PHASE != depend ]]  {

			if has distcc $FEATURES  {
				[[ -n $DISTCC_LOG ]] && addwrite ${DISTCC_LOG%/*}
			}

			if has ccache $FEATURES  {

				if [[ -n $CCACHE_DIR ]]  {
					addread $CCACHE_DIR
					addwrite $CCACHE_DIR
				}

				[[ -n $CCACHE_SIZE ]] && ccache -M $CCACHE_SIZE &> /dev/null
			}
		}
	}
}

# unset USE_EXPAND variables that contain only the special "*" token
for x in ${USE_EXPAND}  {
	test ${!x} == "*" && unset ${x}
}
unset x

if has nostrip ${FEATURES} ${RESTRICT} || has strip ${RESTRICT}
{
	export DEBUGBUILD=1
}

if [[ $EBUILD_PHASE = depend ]]  {
	export SANDBOX_ON="0"
	set -f

	if test -n ${dbkey}  {
		if test ! -d ${dbkey%/*} {
			install -d -g ${PORTAGE_GID} -m2775 ${dbkey%/*}
		}
		# Make it group writable. 666&~002==664
		umask 002
	}

	setvar auxdbkeys = ""DEPEND RDEPEND SLOT SRC_URI RESTRICT HOMEPAGE LICENSE
		DESCRIPTION KEYWORDS INHERITED IUSE REQUIRED_USE PDEPEND PROVIDE EAPI
		PROPERTIES DEFINED_PHASES HDEPEND UNUSED_04
		UNUSED_03 UNUSED_02 UNUSED_01""

	if ! ___eapi_has_HDEPEND {
		unset HDEPEND
	}

	# The extra $(echo) commands remove newlines.
	if test -n ${dbkey}  {
		> "${dbkey}"
		for f in ${auxdbkeys}  {
			echo $(echo ${!f}) >> "${dbkey}" || exit $?
		}
	} else {
		for f in ${auxdbkeys}  {
			eval "echo \$(echo \${!f}) 1>&${PORTAGE_PIPE_FD}" || exit $?
		}
		eval "exec ${PORTAGE_PIPE_FD}>&-"
	}
	set +f
} else {
	# Note: readonly variables interfere with __preprocess_ebuild_env(), so
	# declare them only after it has already run.
	declare -r $PORTAGE_READONLY_METADATA $PORTAGE_READONLY_VARS
	if ___eapi_has_prefix_variables {
		declare -r ED EPREFIX EROOT
	}

	# If ${EBUILD_FORCE_TEST} == 1 and USE came from ${T}/environment
	# then it might not have USE=test like it's supposed to here.
	if [[ ${EBUILD_PHASE} == test && ${EBUILD_FORCE_TEST} == 1 &&
		test =~ ${PORTAGE_IUSE} ]] && ! has test ${USE}  {
		export USE="${USE} test"
	}
	declare -r USE

	if [[ -n $EBUILD_SH_ARGS ]]  {
		shell {
			# Don't allow subprocesses to inherit the pipe which
			# emerge uses to monitor ebuild.sh.
			if [[ -n ${PORTAGE_PIPE_FD} ]]  {
				eval "exec ${PORTAGE_PIPE_FD}>&-"
				unset PORTAGE_PIPE_FD
			}
			__ebuild_main ${EBUILD_SH_ARGS}
			exit 0
		}
		exit $?
	}
}

# Do not exit when ebuild.sh is sourced by other scripts.
true