updated portage to 2.2.8-r1HEADmaster

44 files changed, 1709 insertions, 703 deletions

diff --git a/portage_with_autodep/pym/portage/package/ebuild/__init__.pyo b/portage_with_autodep/pym/portage/package/ebuild/__init__.pyo
index 927b4bc..ff34626 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/__init__.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/__init__.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.py b/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.py
index 0c613ce..af606f1 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.py
@@ -11,7 +11,7 @@ from portage.dep import ExtendedAtomDict, _repo_separator, _slot_separator
 from portage.localization import _
 from portage.package.ebuild._config.helper import ordered_by_atom_specificity
 from portage.util import grabdict_package, stack_lists, writemsg
-from portage.versions import cpv_getkey, _pkg_str
+from portage.versions import _pkg_str
 
 class KeywordsManager(object):
 	"""Manager class to handle keywords processing and validation"""
@@ -77,7 +77,9 @@ class KeywordsManager(object):
 
 
 	def getKeywords(self, cpv, slot, keywords, repo):
-		if not hasattr(cpv, 'slot'):
+		try:
+			cpv.slot
+		except AttributeError:
 			pkg = _pkg_str(cpv, slot=slot, repo=repo)
 		else:
 			pkg = cpv
@@ -91,6 +93,47 @@ class KeywordsManager(object):
 					keywords.extend(pkg_keywords)
 		return stack_lists(keywords, incremental=True)
 
+	def isStable(self, pkg, global_accept_keywords, backuped_accept_keywords):
+		mygroups = self.getKeywords(pkg, None, pkg._metadata["KEYWORDS"], None)
+		pgroups = global_accept_keywords.split()
+
+		unmaskgroups = self.getPKeywords(pkg, None, None,
+			global_accept_keywords)
+		pgroups.extend(unmaskgroups)
+
+		egroups = backuped_accept_keywords.split()
+
+		if unmaskgroups or egroups:
+			pgroups = self._getEgroups(egroups, pgroups)
+		else:
+			pgroups = set(pgroups)
+
+		if self._getMissingKeywords(pkg, pgroups, mygroups):
+			return False
+
+		if pkg.cpv._settings.local_config:
+			# If replacing all keywords with unstable variants would mask the
+			# package, then it's considered stable.
+			unstable = []
+			for kw in mygroups:
+				if kw[:1] != "~":
+					kw = "~" + kw
+				unstable.append(kw)
+
+			return bool(self._getMissingKeywords(pkg, pgroups, set(unstable)))
+		else:
+			# For repoman, if the package has an effective stable keyword that
+			# intersects with the effective ACCEPT_KEYWORDS for the current
+			# profile, then consider it stable.
+			for kw in pgroups:
+				if kw[:1] != "~":
+					if kw in mygroups or '*' in mygroups:
+						return True
+					if kw == '*':
+						for x in mygroups:
+							if x[:1] != "~":
+								return True
+			return False
 
 	def getMissingKeywords(self,
 							cpv,
@@ -237,7 +280,7 @@ class KeywordsManager(object):
 			if not mygroups:
 				# If KEYWORDS is empty then we still have to return something
 				# in order to distinguish from the case of "none missing".
-				mygroups.append("**")
+				mygroups = ["**"]
 			missing = mygroups
 		return missing
 
@@ -261,9 +304,11 @@ class KeywordsManager(object):
 		"""
 
 		pgroups = global_accept_keywords.split()
-		if not hasattr(cpv, 'slot'):
+		try:
+			cpv.slot
+		except AttributeError:
 			cpv = _pkg_str(cpv, slot=slot, repo=repo)
-		cp = cpv_getkey(cpv)
+		cp = cpv.cp
 
 		unmaskgroups = []
 		if self._p_accept_keywords:
@@ -288,4 +333,3 @@ class KeywordsManager(object):
 				for x in pkg_accept_keywords:
 					unmaskgroups.extend(x)
 		return unmaskgroups
-
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.pyo
index 15043f0..b922211 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/KeywordsManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/LicenseManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/LicenseManager.pyo
index 4a38298..4ddda5e 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/LicenseManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/LicenseManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.py b/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.py
index f7a1177..80b6a70 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.py
@@ -1,6 +1,8 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = (
 	'LocationsManager',
 )
@@ -13,10 +15,12 @@ import portage
 from portage import os, eapi_is_supported, _encodings, _unicode_encode
 from portage.const import CUSTOM_PROFILE_PATH, GLOBAL_CONFIG_PATH, \
 	PROFILE_PATH, USER_CONFIG_PATH
+from portage.eapi import eapi_allows_directories_on_profile_level_and_repository_level
 from portage.exception import DirectoryNotFound, ParseError
 from portage.localization import _
 from portage.util import ensure_dirs, grabfile, \
 	normalize_path, shlex_split, writemsg
+from portage.util._path import exists_raise_eaccess, isdir_raise_eaccess
 from portage.repository.config import parse_layout_conf, \
 	_portage1_profiles_allow_directories
 
@@ -27,7 +31,7 @@ _PORTAGE1_DIRECTORIES = frozenset([
 	'use.mask', 'use.force'])
 
 _profile_node = collections.namedtuple('_profile_node',
-	'location portage1_directories')
+	'location portage1_directories user_config')
 
 _allow_parent_colon = frozenset(
 	["portage-2"])
@@ -45,9 +49,13 @@ class LocationsManager(object):
 
 		if self.eprefix is None:
 			self.eprefix = portage.const.EPREFIX
+		elif self.eprefix:
+			self.eprefix = normalize_path(self.eprefix)
+			if self.eprefix == os.sep:
+				self.eprefix = ""
 
 		if self.config_root is None:
-			self.config_root = self.eprefix + os.sep
+			self.config_root = portage.const.EPREFIX + os.sep
 
 		self.config_root = normalize_path(os.path.abspath(
 			self.config_root)).rstrip(os.path.sep) + os.path.sep
@@ -72,14 +80,26 @@ class LocationsManager(object):
 		known_repos = tuple(known_repos)
 
 		if self.config_profile_path is None:
+			deprecated_profile_path = os.path.join(
+				self.config_root, 'etc', 'make.profile')
 			self.config_profile_path = \
 				os.path.join(self.config_root, PROFILE_PATH)
-			if os.path.isdir(self.config_profile_path):
+			if isdir_raise_eaccess(self.config_profile_path):
 				self.profile_path = self.config_profile_path
+				if isdir_raise_eaccess(deprecated_profile_path) and not \
+					os.path.samefile(self.profile_path,
+					deprecated_profile_path):
+					# Don't warn if they refer to the same path, since
+					# that can be used for backward compatibility with
+					# old software.
+					writemsg("!!! %s\n" %
+						_("Found 2 make.profile dirs: "
+						"using '%s', ignoring '%s'") %
+						(self.profile_path, deprecated_profile_path),
+						noiselevel=-1)
 			else:
-				self.config_profile_path = \
-					os.path.join(self.abs_user_config, 'make.profile')
-				if os.path.isdir(self.config_profile_path):
+				self.config_profile_path = deprecated_profile_path
+				if isdir_raise_eaccess(self.config_profile_path):
 					self.profile_path = self.config_profile_path
 				else:
 					self.profile_path = None
@@ -99,9 +119,9 @@ class LocationsManager(object):
 				self._addProfile(os.path.realpath(self.profile_path),
 					repositories, known_repos)
 			except ParseError as e:
-				writemsg(_("!!! Unable to parse profile: '%s'\n") % \
-					self.profile_path, noiselevel=-1)
-				writemsg("!!! ParseError: %s\n" % str(e), noiselevel=-1)
+				if not portage._sync_disabled_warnings:
+					writemsg(_("!!! Unable to parse profile: '%s'\n") % self.profile_path, noiselevel=-1)
+					writemsg("!!! ParseError: %s\n" % str(e), noiselevel=-1)
 				self.profiles = []
 				self.profiles_complex = []
 
@@ -111,14 +131,15 @@ class LocationsManager(object):
 			if os.path.exists(custom_prof):
 				self.user_profile_dir = custom_prof
 				self.profiles.append(custom_prof)
-				self.profiles_complex.append(_profile_node(custom_prof, True))
+				self.profiles_complex.append(
+					_profile_node(custom_prof, True, True))
 			del custom_prof
 
 		self.profiles = tuple(self.profiles)
 		self.profiles_complex = tuple(self.profiles_complex)
 
 	def _check_var_directory(self, varname, var):
-		if not os.path.isdir(var):
+		if not isdir_raise_eaccess(var):
 			writemsg(_("!!! Error: %s='%s' is not a directory. "
 				"Please correct this.\n") % (varname, var),
 				noiselevel=-1)
@@ -130,33 +151,9 @@ class LocationsManager(object):
 		allow_parent_colon = True
 		repo_loc = None
 		compat_mode = False
-		intersecting_repos = [x for x in known_repos if current_abs_path.startswith(x[0])]
-		if intersecting_repos:
-			# protect against nested repositories.  Insane configuration, but the longest
-			# path will be the correct one.
-			repo_loc, layout_data = max(intersecting_repos, key=lambda x:len(x[0]))
-			allow_directories = any(x in _portage1_profiles_allow_directories
-				for x in layout_data['profile-formats'])
-			compat_mode = layout_data['profile-formats'] == ('portage-1-compat',)
-			allow_parent_colon = any(x in _allow_parent_colon
-				for x in layout_data['profile-formats'])
 
-		if compat_mode:
-			offenders = _PORTAGE1_DIRECTORIES.intersection(os.listdir(currentPath))
-			offenders = sorted(x for x in offenders
-				if os.path.isdir(os.path.join(currentPath, x)))
-			if offenders:
-				warnings.warn(_("Profile '%(profile_path)s' in repository "
-					"'%(repo_name)s' is implicitly using 'portage-1' profile format, but "
-					"the repository profiles are not marked as that format.  This will break "
-					"in the future.  Please either convert the following paths "
-					"to files, or add\nprofile-formats = portage-1\nto the "
-					"repositories layout.conf.  Files: '%(files)s'\n")
-					% dict(profile_path=currentPath, repo_name=repo_loc,
-						files=', '.join(offenders)))
-
-		parentsFile = os.path.join(currentPath, "parent")
 		eapi_file = os.path.join(currentPath, "eapi")
+		eapi = "0"
 		f = None
 		try:
 			f = io.open(_unicode_encode(eapi_file,
@@ -174,7 +171,38 @@ class LocationsManager(object):
 		finally:
 			if f is not None:
 				f.close()
-		if os.path.exists(parentsFile):
+
+		intersecting_repos = [x for x in known_repos if current_abs_path.startswith(x[0])]
+		if intersecting_repos:
+			# protect against nested repositories.  Insane configuration, but the longest
+			# path will be the correct one.
+			repo_loc, layout_data = max(intersecting_repos, key=lambda x:len(x[0]))
+			allow_directories = eapi_allows_directories_on_profile_level_and_repository_level(eapi) or \
+				any(x in _portage1_profiles_allow_directories for x in layout_data['profile-formats'])
+			compat_mode = not eapi_allows_directories_on_profile_level_and_repository_level(eapi) and \
+				layout_data['profile-formats'] == ('portage-1-compat',)
+			allow_parent_colon = any(x in _allow_parent_colon
+				for x in layout_data['profile-formats'])
+
+		if compat_mode:
+			offenders = _PORTAGE1_DIRECTORIES.intersection(os.listdir(currentPath))
+			offenders = sorted(x for x in offenders
+				if os.path.isdir(os.path.join(currentPath, x)))
+			if offenders:
+				warnings.warn(_(
+					"\nThe selected profile is implicitly using the 'portage-1' format:\n"
+					"\tprofile = %(profile_path)s\n"
+					"But this repository is not using that format:\n"
+					"\trepo = %(repo_name)s\n"
+					"This will break in the future.  Please convert these dirs to files:\n"
+					"\t%(files)s\n"
+					"Or, add this line to the repository's layout.conf:\n"
+					"\tprofile-formats = portage-1")
+					% dict(profile_path=currentPath, repo_name=repo_loc,
+						files='\n\t'.join(offenders)))
+
+		parentsFile = os.path.join(currentPath, "parent")
+		if exists_raise_eaccess(parentsFile):
 			parents = grabfile(parentsFile)
 			if not parents:
 				raise ParseError(
@@ -196,7 +224,7 @@ class LocationsManager(object):
 					# of the current repo, so realpath it.
 					parentPath = os.path.realpath(parentPath)
 
-				if os.path.exists(parentPath):
+				if exists_raise_eaccess(parentPath):
 					self._addProfile(parentPath, repositories, known_repos)
 				else:
 					raise ParseError(
@@ -205,7 +233,7 @@ class LocationsManager(object):
 
 		self.profiles.append(currentPath)
 		self.profiles_complex.append(
-			_profile_node(currentPath, allow_directories))
+			_profile_node(currentPath, allow_directories, False))
 
 	def _expand_parent_colon(self, parentsFile, parentPath,
 		repo_loc, repositories):
@@ -253,29 +281,10 @@ class LocationsManager(object):
 
 		self.eroot = self.target_root.rstrip(os.sep) + self.eprefix + os.sep
 
-		# make.globals should not be relative to config_root
-		# because it only contains constants. However, if EPREFIX
-		# is set then there are two possible scenarios:
-		# 1) If $ROOT == "/" then make.globals should be
-		#    relative to EPREFIX.
-		# 2) If $ROOT != "/" then the correct location of
-		#    make.globals needs to be specified in the constructor
-		#    parameters, since it's a property of the host system
-		#    (and the current config represents the target system).
 		self.global_config_path = GLOBAL_CONFIG_PATH
-		if self.eprefix:
-			if self.target_root == "/":
-				# case (1) above
-				self.global_config_path = os.path.join(self.eprefix,
-					GLOBAL_CONFIG_PATH.lstrip(os.sep))
-			else:
-				# case (2) above
-				# For now, just assume make.globals is relative
-				# to EPREFIX.
-				# TODO: Pass in more info to the constructor,
-				# so we know the host system configuration.
-				self.global_config_path = os.path.join(self.eprefix,
-					GLOBAL_CONFIG_PATH.lstrip(os.sep))
+		if portage.const.EPREFIX:
+			self.global_config_path = os.path.join(portage.const.EPREFIX,
+				GLOBAL_CONFIG_PATH.lstrip(os.sep))
 
 	def set_port_dirs(self, portdir, portdir_overlay):
 		self.portdir = portdir
@@ -287,7 +296,7 @@ class LocationsManager(object):
 		for ov in shlex_split(self.portdir_overlay):
 			ov = normalize_path(ov)
 			profiles_dir = os.path.join(ov, "profiles")
-			if os.path.isdir(profiles_dir):
+			if isdir_raise_eaccess(profiles_dir):
 				self.overlay_profiles.append(profiles_dir)
 
 		self.profile_locations = [os.path.join(portdir, "profiles")] + self.overlay_profiles
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.pyo
index c64d313..5ef52ec 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/LocationsManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.py b/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.py
index bce1152..aeb04d7 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = (
@@ -8,11 +8,10 @@ __all__ = (
 import warnings
 
 from portage import os
-from portage.dep import ExtendedAtomDict, match_from_list, _repo_separator, _slot_separator
+from portage.dep import ExtendedAtomDict, match_from_list
 from portage.localization import _
 from portage.util import append_repo, grabfile_package, stack_lists, writemsg
-from portage.versions import cpv_getkey
-from _emerge.Package import Package
+from portage.versions import _pkg_str
 
 class MaskManager(object):
 
@@ -47,7 +46,7 @@ class MaskManager(object):
 						"the repository profiles are not marked as that format.  This will break "
 						"in the future.  Please either convert the following paths "
 						"to files, or add\nprofile-formats = portage-1\nto the "
-						"repositories layout.conf.\n")
+						"repository's layout.conf.\n")
 						% dict(repo_name=repo_config.name))
 
 			return pmask_cache[loc]
@@ -185,12 +184,15 @@ class MaskManager(object):
 		@return: A matching atom string or None if one is not found.
 		"""
 
-		cp = cpv_getkey(cpv)
-		mask_atoms = self._pmaskdict.get(cp)
+		try:
+			cpv.slot
+		except AttributeError:
+			pkg = _pkg_str(cpv, slot=slot, repo=repo)
+		else:
+			pkg = cpv
+
+		mask_atoms = self._pmaskdict.get(pkg.cp)
 		if mask_atoms:
-			pkg = "".join((cpv, _slot_separator, slot))
-			if repo and repo != Package.UNKNOWN_REPO:
-				pkg = "".join((pkg, _repo_separator, repo))
 			pkg_list = [pkg]
 			for x in mask_atoms:
 				if not match_from_list(x, pkg_list):
@@ -219,8 +221,15 @@ class MaskManager(object):
 		@return: A matching atom string or None if one is not found.
 		"""
 
-		cp = cpv_getkey(cpv)
-		return self._getMaskAtom(cpv, slot, repo, self._punmaskdict.get(cp))
+		try:
+			cpv.slot
+		except AttributeError:
+			pkg = _pkg_str(cpv, slot=slot, repo=repo)
+		else:
+			pkg = cpv
+
+		return self._getMaskAtom(pkg, slot, repo,
+			self._punmaskdict.get(pkg.cp))
 
 
 	def getRawMaskAtom(self, cpv, slot, repo):
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.pyo
index f48eb47..abc46de 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/MaskManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.py b/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.py
index e1ec7f4..0d00810 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = (
@@ -7,36 +7,49 @@ __all__ = (
 
 from _emerge.Package import Package
 from portage import os
-from portage.dep import dep_getrepo, dep_getslot, ExtendedAtomDict, remove_slot, _get_useflag_re
+from portage.dep import Atom, dep_getrepo, dep_getslot, ExtendedAtomDict, remove_slot, _get_useflag_re, _repo_separator
+from portage.eapi import eapi_has_use_aliases, eapi_supports_stable_use_forcing_and_masking
+from portage.exception import InvalidAtom
 from portage.localization import _
-from portage.util import grabfile, grabdict_package, read_corresponding_eapi_file, stack_lists, writemsg
-from portage.versions import cpv_getkey, _pkg_str
+from portage.util import grabfile, grabdict, grabdict_package, read_corresponding_eapi_file, stack_lists, writemsg
+from portage.versions import _pkg_str
 
 from portage.package.ebuild._config.helper import ordered_by_atom_specificity
 
 class UseManager(object):
 
-	def __init__(self, repositories, profiles, abs_user_config, user_config=True):
+	def __init__(self, repositories, profiles, abs_user_config, is_stable,
+		user_config=True):
 		#	file				variable
 		#--------------------------------
 		#	repositories
 		#--------------------------------
 		#	use.mask			_repo_usemask_dict
+		#	use.stable.mask			_repo_usestablemask_dict
 		#	use.force			_repo_useforce_dict
+		#	use.stable.force		_repo_usestableforce_dict
+		#	use.aliases			_repo_usealiases_dict
 		#	package.use.mask		_repo_pusemask_dict
+		#	package.use.stable.mask		_repo_pusestablemask_dict
 		#	package.use.force		_repo_puseforce_dict
+		#	package.use.stable.force	_repo_pusestableforce_dict
+		#	package.use.aliases		_repo_pusealiases_dict
 		#--------------------------------
 		#	profiles
 		#--------------------------------
 		#	use.mask			_usemask_list
+		#	use.stable.mask			_usestablemask_list
 		#	use.force			_useforce_list
+		#	use.stable.force		_usestableforce_list
 		#	package.use.mask		_pusemask_list
+		#	package.use.stable.mask		_pusestablemask_list
 		#	package.use			_pkgprofileuse
 		#	package.use.force		_puseforce_list
+		#	package.use.stable.force	_pusestableforce_list
 		#--------------------------------
 		#	user config
 		#--------------------------------
-		#	package.use			_pusedict	
+		#	package.use			_pusedict
 
 		# Dynamic variables tracked by the config class
 		#--------------------------------
@@ -49,26 +62,61 @@ class UseManager(object):
 		#--------------------------------
 		#	puse
 
+		self._user_config = user_config
+		self._is_stable = is_stable
 		self._repo_usemask_dict = self._parse_repository_files_to_dict_of_tuples("use.mask", repositories)
+		self._repo_usestablemask_dict = \
+			self._parse_repository_files_to_dict_of_tuples("use.stable.mask",
+				repositories, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._repo_useforce_dict = self._parse_repository_files_to_dict_of_tuples("use.force", repositories)
+		self._repo_usestableforce_dict = \
+			self._parse_repository_files_to_dict_of_tuples("use.stable.force",
+				repositories, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._repo_pusemask_dict = self._parse_repository_files_to_dict_of_dicts("package.use.mask", repositories)
+		self._repo_pusestablemask_dict = \
+			self._parse_repository_files_to_dict_of_dicts("package.use.stable.mask",
+				repositories, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._repo_puseforce_dict = self._parse_repository_files_to_dict_of_dicts("package.use.force", repositories)
+		self._repo_pusestableforce_dict = \
+			self._parse_repository_files_to_dict_of_dicts("package.use.stable.force",
+				repositories, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._repo_puse_dict = self._parse_repository_files_to_dict_of_dicts("package.use", repositories)
 
 		self._usemask_list = self._parse_profile_files_to_tuple_of_tuples("use.mask", profiles)
+		self._usestablemask_list = \
+			self._parse_profile_files_to_tuple_of_tuples("use.stable.mask",
+				profiles, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._useforce_list = self._parse_profile_files_to_tuple_of_tuples("use.force", profiles)
+		self._usestableforce_list = \
+			self._parse_profile_files_to_tuple_of_tuples("use.stable.force",
+				profiles, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._pusemask_list = self._parse_profile_files_to_tuple_of_dicts("package.use.mask", profiles)
+		self._pusestablemask_list = \
+			self._parse_profile_files_to_tuple_of_dicts("package.use.stable.mask",
+				profiles, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 		self._pkgprofileuse = self._parse_profile_files_to_tuple_of_dicts("package.use", profiles, juststrings=True)
 		self._puseforce_list = self._parse_profile_files_to_tuple_of_dicts("package.use.force", profiles)
+		self._pusestableforce_list = \
+			self._parse_profile_files_to_tuple_of_dicts("package.use.stable.force",
+				profiles, eapi_filter=eapi_supports_stable_use_forcing_and_masking)
 
 		self._pusedict = self._parse_user_files_to_extatomdict("package.use", abs_user_config, user_config)
 
+		self._repo_usealiases_dict = self._parse_repository_usealiases(repositories)
+		self._repo_pusealiases_dict = self._parse_repository_packageusealiases(repositories)
+
 		self.repositories = repositories
-	
-	def _parse_file_to_tuple(self, file_name, recursive=True):
+
+	def _parse_file_to_tuple(self, file_name, recursive=True, eapi_filter=None):
 		ret = []
 		lines = grabfile(file_name, recursive=recursive)
 		eapi = read_corresponding_eapi_file(file_name)
+		if eapi_filter is not None and not eapi_filter(eapi):
+			if lines:
+				writemsg(_("--- EAPI '%s' does not support '%s': '%s'\n") %
+					(eapi, os.path.basename(file_name), file_name),
+					noiselevel=-1)
+			return ()
 		useflag_re = _get_useflag_re(eapi)
 		for prefixed_useflag in lines:
 			if prefixed_useflag[:1] == "-":
@@ -82,11 +130,26 @@ class UseManager(object):
 				ret.append(prefixed_useflag)
 		return tuple(ret)
 
-	def _parse_file_to_dict(self, file_name, juststrings=False, recursive=True):
+	def _parse_file_to_dict(self, file_name, juststrings=False, recursive=True,
+		eapi_filter=None, user_config=False):
 		ret = {}
 		location_dict = {}
-		file_dict = grabdict_package(file_name, recursive=recursive, verify_eapi=True)
-		eapi = read_corresponding_eapi_file(file_name)
+		eapi = read_corresponding_eapi_file(file_name, default=None)
+		if eapi is None and not user_config:
+			eapi = "0"
+		if eapi is None:
+			ret = ExtendedAtomDict(dict)
+		else:
+			ret = {}
+		file_dict = grabdict_package(file_name, recursive=recursive,
+			allow_wildcard=(eapi is None), allow_repo=(eapi is None),
+			verify_eapi=(eapi is not None))
+		if eapi is not None and eapi_filter is not None and not eapi_filter(eapi):
+			if file_dict:
+				writemsg(_("--- EAPI '%s' does not support '%s': '%s'\n") %
+					(eapi, os.path.basename(file_name), file_name),
+					noiselevel=-1)
+			return ret
 		useflag_re = _get_useflag_re(eapi)
 		for k, v in file_dict.items():
 			useflags = []
@@ -119,31 +182,116 @@ class UseManager(object):
 
 		return ret
 
-	def _parse_repository_files_to_dict_of_tuples(self, file_name, repositories):
+	def _parse_repository_files_to_dict_of_tuples(self, file_name, repositories, eapi_filter=None):
 		ret = {}
 		for repo in repositories.repos_with_profiles():
-			ret[repo.name] = self._parse_file_to_tuple(os.path.join(repo.location, "profiles", file_name))
+			ret[repo.name] = self._parse_file_to_tuple(os.path.join(repo.location, "profiles", file_name), eapi_filter=eapi_filter)
 		return ret
 
-	def _parse_repository_files_to_dict_of_dicts(self, file_name, repositories):
+	def _parse_repository_files_to_dict_of_dicts(self, file_name, repositories, eapi_filter=None):
 		ret = {}
 		for repo in repositories.repos_with_profiles():
-			ret[repo.name] = self._parse_file_to_dict(os.path.join(repo.location, "profiles", file_name))
+			ret[repo.name] = self._parse_file_to_dict(os.path.join(repo.location, "profiles", file_name), eapi_filter=eapi_filter)
 		return ret
 
-	def _parse_profile_files_to_tuple_of_tuples(self, file_name, locations):
+	def _parse_profile_files_to_tuple_of_tuples(self, file_name, locations,
+		eapi_filter=None):
 		return tuple(self._parse_file_to_tuple(
 			os.path.join(profile.location, file_name),
-			recursive=profile.portage1_directories)
+			recursive=profile.portage1_directories, eapi_filter=eapi_filter)
 			for profile in locations)
 
-	def _parse_profile_files_to_tuple_of_dicts(self, file_name, locations, juststrings=False):
+	def _parse_profile_files_to_tuple_of_dicts(self, file_name, locations,
+		juststrings=False, eapi_filter=None):
 		return tuple(self._parse_file_to_dict(
 			os.path.join(profile.location, file_name), juststrings,
-			recursive=profile.portage1_directories)
+			recursive=profile.portage1_directories, eapi_filter=eapi_filter,
+			user_config=profile.user_config)
 			for profile in locations)
 
-	def getUseMask(self, pkg=None):
+	def _parse_repository_usealiases(self, repositories):
+		ret = {}
+		for repo in repositories.repos_with_profiles():
+			file_name = os.path.join(repo.location, "profiles", "use.aliases")
+			eapi = read_corresponding_eapi_file(file_name)
+			useflag_re = _get_useflag_re(eapi)
+			raw_file_dict = grabdict(file_name, recursive=True)
+			file_dict = {}
+			for real_flag, aliases in raw_file_dict.items():
+				if useflag_re.match(real_flag) is None:
+					writemsg(_("--- Invalid real USE flag in '%s': '%s'\n") % (file_name, real_flag), noiselevel=-1)
+				else:
+					for alias in aliases:
+						if useflag_re.match(alias) is None:
+							writemsg(_("--- Invalid USE flag alias for '%s' real USE flag in '%s': '%s'\n") %
+								(real_flag, file_name, alias), noiselevel=-1)
+						else:
+							if any(alias in v for k, v in file_dict.items() if k != real_flag):
+								writemsg(_("--- Duplicated USE flag alias in '%s': '%s'\n") %
+									(file_name, alias), noiselevel=-1)
+							else:
+								file_dict.setdefault(real_flag, []).append(alias)
+			ret[repo.name] = file_dict
+		return ret
+
+	def _parse_repository_packageusealiases(self, repositories):
+		ret = {}
+		for repo in repositories.repos_with_profiles():
+			file_name = os.path.join(repo.location, "profiles", "package.use.aliases")
+			eapi = read_corresponding_eapi_file(file_name)
+			useflag_re = _get_useflag_re(eapi)
+			lines = grabfile(file_name, recursive=True)
+			file_dict = {}
+			for line in lines:
+				elements = line.split()
+				atom = elements[0]
+				try:
+					atom = Atom(atom, eapi=eapi)
+				except InvalidAtom:
+					writemsg(_("--- Invalid atom in '%s': '%s'\n") % (file_name, atom))
+					continue
+				if len(elements) == 1:
+					writemsg(_("--- Missing real USE flag for '%s' in '%s'\n") % (atom, file_name), noiselevel=-1)
+					continue
+				real_flag = elements[1]
+				if useflag_re.match(real_flag) is None:
+					writemsg(_("--- Invalid real USE flag for '%s' in '%s': '%s'\n") % (atom, file_name, real_flag), noiselevel=-1)
+				else:
+					for alias in elements[2:]:
+						if useflag_re.match(alias) is None:
+							writemsg(_("--- Invalid USE flag alias for '%s' real USE flag for '%s' in '%s': '%s'\n") %
+								(real_flag, atom, file_name, alias), noiselevel=-1)
+						else:
+							# Duplicated USE flag aliases in entries for different atoms
+							# matching the same package version are detected in getUseAliases().
+							if any(alias in v for k, v in file_dict.get(atom.cp, {}).get(atom, {}).items() if k != real_flag):
+								writemsg(_("--- Duplicated USE flag alias for '%s' in '%s': '%s'\n") %
+									(atom, file_name, alias), noiselevel=-1)
+							else:
+								file_dict.setdefault(atom.cp, {}).setdefault(atom, {}).setdefault(real_flag, []).append(alias)
+			ret[repo.name] = file_dict
+		return ret
+
+	def _isStable(self, pkg):
+		if self._user_config:
+			try:
+				return pkg.stable
+			except AttributeError:
+				# KEYWORDS is unavailable (prior to "depend" phase)
+				return False
+
+		try:
+			pkg._metadata
+		except AttributeError:
+			# KEYWORDS is unavailable (prior to "depend" phase)
+			return False
+
+		# Since repoman uses different config instances for
+		# different profiles, we have to be careful to do the
+		# stable check against the correct profile here.
+		return self._is_stable(pkg)
+
+	def getUseMask(self, pkg=None, stable=None):
 		if pkg is None:
 			return frozenset(stack_lists(
 				self._usemask_list, incremental=True))
@@ -155,7 +303,12 @@ class UseManager(object):
 			repo = dep_getrepo(pkg)
 			pkg = _pkg_str(remove_slot(pkg), slot=slot, repo=repo)
 			cp = pkg.cp
+
+		if stable is None:
+			stable = self._isStable(pkg)
+
 		usemask = []
+
 		if hasattr(pkg, "repo") and pkg.repo != Package.UNKNOWN_REPO:
 			repos = []
 			try:
@@ -166,30 +319,56 @@ class UseManager(object):
 			repos.append(pkg.repo)
 			for repo in repos:
 				usemask.append(self._repo_usemask_dict.get(repo, {}))
+				if stable:
+					usemask.append(self._repo_usestablemask_dict.get(repo, {}))
 				cpdict = self._repo_pusemask_dict.get(repo, {}).get(cp)
 				if cpdict:
 					pkg_usemask = ordered_by_atom_specificity(cpdict, pkg)
 					if pkg_usemask:
 						usemask.extend(pkg_usemask)
+				if stable:
+					cpdict = self._repo_pusestablemask_dict.get(repo, {}).get(cp)
+					if cpdict:
+						pkg_usemask = ordered_by_atom_specificity(cpdict, pkg)
+						if pkg_usemask:
+							usemask.extend(pkg_usemask)
+
 		for i, pusemask_dict in enumerate(self._pusemask_list):
 			if self._usemask_list[i]:
 				usemask.append(self._usemask_list[i])
+			if stable and self._usestablemask_list[i]:
+				usemask.append(self._usestablemask_list[i])
 			cpdict = pusemask_dict.get(cp)
 			if cpdict:
 				pkg_usemask = ordered_by_atom_specificity(cpdict, pkg)
 				if pkg_usemask:
 					usemask.extend(pkg_usemask)
+			if stable:
+				cpdict = self._pusestablemask_list[i].get(cp)
+				if cpdict:
+					pkg_usemask = ordered_by_atom_specificity(cpdict, pkg)
+					if pkg_usemask:
+						usemask.extend(pkg_usemask)
+
 		return frozenset(stack_lists(usemask, incremental=True))
 
-	def getUseForce(self, pkg=None):
+	def getUseForce(self, pkg=None, stable=None):
 		if pkg is None:
 			return frozenset(stack_lists(
 				self._useforce_list, incremental=True))
 
 		cp = getattr(pkg, "cp", None)
 		if cp is None:
-			cp = cpv_getkey(remove_slot(pkg))
+			slot = dep_getslot(pkg)
+			repo = dep_getrepo(pkg)
+			pkg = _pkg_str(remove_slot(pkg), slot=slot, repo=repo)
+			cp = pkg.cp
+
+		if stable is None:
+			stable = self._isStable(pkg)
+
 		useforce = []
+
 		if hasattr(pkg, "repo") and pkg.repo != Package.UNKNOWN_REPO:
 			repos = []
 			try:
@@ -200,25 +379,90 @@ class UseManager(object):
 			repos.append(pkg.repo)
 			for repo in repos:
 				useforce.append(self._repo_useforce_dict.get(repo, {}))
+				if stable:
+					useforce.append(self._repo_usestableforce_dict.get(repo, {}))
 				cpdict = self._repo_puseforce_dict.get(repo, {}).get(cp)
 				if cpdict:
 					pkg_useforce = ordered_by_atom_specificity(cpdict, pkg)
 					if pkg_useforce:
 						useforce.extend(pkg_useforce)
+				if stable:
+					cpdict = self._repo_pusestableforce_dict.get(repo, {}).get(cp)
+					if cpdict:
+						pkg_useforce = ordered_by_atom_specificity(cpdict, pkg)
+						if pkg_useforce:
+							useforce.extend(pkg_useforce)
+
 		for i, puseforce_dict in enumerate(self._puseforce_list):
 			if self._useforce_list[i]:
 				useforce.append(self._useforce_list[i])
+			if stable and self._usestableforce_list[i]:
+				useforce.append(self._usestableforce_list[i])
 			cpdict = puseforce_dict.get(cp)
 			if cpdict:
 				pkg_useforce = ordered_by_atom_specificity(cpdict, pkg)
 				if pkg_useforce:
 					useforce.extend(pkg_useforce)
+			if stable:
+				cpdict = self._pusestableforce_list[i].get(cp)
+				if cpdict:
+					pkg_useforce = ordered_by_atom_specificity(cpdict, pkg)
+					if pkg_useforce:
+						useforce.extend(pkg_useforce)
+
 		return frozenset(stack_lists(useforce, incremental=True))
 
+	def getUseAliases(self, pkg):
+		if hasattr(pkg, "eapi") and not eapi_has_use_aliases(pkg.eapi):
+			return {}
+
+		cp = getattr(pkg, "cp", None)
+		if cp is None:
+			slot = dep_getslot(pkg)
+			repo = dep_getrepo(pkg)
+			pkg = _pkg_str(remove_slot(pkg), slot=slot, repo=repo)
+			cp = pkg.cp
+
+		usealiases = {}
+
+		if hasattr(pkg, "repo") and pkg.repo != Package.UNKNOWN_REPO:
+			repos = []
+			try:
+				repos.extend(repo.name for repo in
+					self.repositories[pkg.repo].masters)
+			except KeyError:
+				pass
+			repos.append(pkg.repo)
+			for repo in repos:
+				usealiases_dict = self._repo_usealiases_dict.get(repo, {})
+				for real_flag, aliases in usealiases_dict.items():
+					for alias in aliases:
+						if any(alias in v for k, v in usealiases.items() if k != real_flag):
+							writemsg(_("--- Duplicated USE flag alias for '%s%s%s': '%s'\n") %
+								(pkg.cpv, _repo_separator, pkg.repo, alias), noiselevel=-1)
+						else:
+							usealiases.setdefault(real_flag, []).append(alias)
+				cp_usealiases_dict = self._repo_pusealiases_dict.get(repo, {}).get(cp)
+				if cp_usealiases_dict:
+					usealiases_dict_list = ordered_by_atom_specificity(cp_usealiases_dict, pkg)
+					for usealiases_dict in usealiases_dict_list:
+						for real_flag, aliases in usealiases_dict.items():
+							for alias in aliases:
+								if any(alias in v for k, v in usealiases.items() if k != real_flag):
+									writemsg(_("--- Duplicated USE flag alias for '%s%s%s': '%s'\n") %
+										(pkg.cpv, _repo_separator, pkg.repo, alias), noiselevel=-1)
+								else:
+									usealiases.setdefault(real_flag, []).append(alias)
+
+		return usealiases
+
 	def getPUSE(self, pkg):
 		cp = getattr(pkg, "cp", None)
 		if cp is None:
-			cp = cpv_getkey(remove_slot(pkg))
+			slot = dep_getslot(pkg)
+			repo = dep_getrepo(pkg)
+			pkg = _pkg_str(remove_slot(pkg), slot=slot, repo=repo)
+			cp = pkg.cp
 		ret = ""
 		cpdict = self._pusedict.get(cp)
 		if cpdict:
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.pyo
index 2c9a609..16fa78e 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/UseManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/VirtualsManager.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/VirtualsManager.pyo
index b2ebd21..88010cc 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/VirtualsManager.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/VirtualsManager.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/__init__.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/__init__.pyo
index b03cc29..f3c8238 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/__init__.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/__init__.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/env_var_validation.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/env_var_validation.pyo
index aeee789..d78d7d2 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/env_var_validation.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/env_var_validation.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/features_set.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/features_set.pyo
index 9854444..ef59bc0 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/features_set.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/features_set.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/helper.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/helper.pyo
index f2b9261..d2a012f 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/helper.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/helper.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.py b/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.py
index 1a75de9..f241e65 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.py
@@ -1,6 +1,8 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = (
 	'case_insensitive_vars', 'default_globals', 'env_blacklist', \
 	'environ_filter', 'environ_whitelist', 'environ_whitelist_re',
@@ -13,14 +15,17 @@ import re
 # configuration files.
 env_blacklist = frozenset((
 	"A", "AA", "CATEGORY", "DEPEND", "DESCRIPTION", "EAPI",
-	"EBUILD_FORCE_TEST", "EBUILD_PHASE", "EBUILD_SKIP_MANIFEST",
+	"EBUILD_FORCE_TEST", "EBUILD_PHASE",
+	"EBUILD_PHASE_FUNC", "EBUILD_SKIP_MANIFEST",
 	"ED", "EMERGE_FROM", "EPREFIX", "EROOT",
-	"GREP_OPTIONS", "HOMEPAGE", "INHERITED", "IUSE",
+	"GREP_OPTIONS", "HDEPEND", "HOMEPAGE",
+	"INHERITED", "IUSE", "IUSE_EFFECTIVE",
 	"KEYWORDS", "LICENSE", "MERGE_TYPE",
 	"PDEPEND", "PF", "PKGUSE", "PORTAGE_BACKGROUND",
-	"PORTAGE_BACKGROUND_UNMERGE", "PORTAGE_BUILDIR_LOCKED",
-	"PORTAGE_BUILT_USE", "PORTAGE_CONFIGROOT", "PORTAGE_IUSE",
-	"PORTAGE_NONFATAL", "PORTAGE_REPO_NAME",
+	"PORTAGE_BACKGROUND_UNMERGE", "PORTAGE_BUILDDIR_LOCKED",
+	"PORTAGE_BUILT_USE", "PORTAGE_CONFIGROOT",
+	"PORTAGE_INTERNAL_CALLER", "PORTAGE_IUSE",
+	"PORTAGE_NONFATAL", "PORTAGE_PIPE_FD", "PORTAGE_REPO_NAME",
 	"PORTAGE_USE", "PROPERTIES", "PROVIDE", "RDEPEND", "REPOSITORY",
 	"RESTRICT", "ROOT", "SLOT", "SRC_URI"
 ))
@@ -39,7 +44,7 @@ environ_whitelist += [
 	"ACCEPT_LICENSE", "BASH_ENV", "BUILD_PREFIX", "COLUMNS", "D",
 	"DISTDIR", "DOC_SYMLINKS_DIR", "EAPI", "EBUILD",
 	"EBUILD_FORCE_TEST",
-	"EBUILD_PHASE", "ECLASSDIR", "ECLASS_DEPTH", "ED",
+	"EBUILD_PHASE", "EBUILD_PHASE_FUNC", "ECLASSDIR", "ECLASS_DEPTH", "ED",
 	"EMERGE_FROM", "EPREFIX", "EROOT",
 	"FEATURES", "FILESDIR", "HOME", "MERGE_TYPE", "NOCOLOR", "PATH",
 	"PKGDIR",
@@ -49,19 +54,26 @@ environ_whitelist += [
 	"PORTAGE_BINPKG_FILE", "PORTAGE_BINPKG_TAR_OPTS",
 	"PORTAGE_BINPKG_TMPFILE",
 	"PORTAGE_BIN_PATH",
-	"PORTAGE_BUILDDIR", "PORTAGE_BUNZIP2_COMMAND", "PORTAGE_BZIP2_COMMAND",
-	"PORTAGE_COLORMAP", "PORTAGE_COMPRESS_EXCLUDE_SUFFIXES",
+	"PORTAGE_BUILDDIR", "PORTAGE_BUILD_GROUP", "PORTAGE_BUILD_USER",
+	"PORTAGE_BUNZIP2_COMMAND", "PORTAGE_BZIP2_COMMAND",
+	"PORTAGE_COLORMAP", "PORTAGE_COMPRESS",
+	"PORTAGE_COMPRESS_EXCLUDE_SUFFIXES",
 	"PORTAGE_CONFIGROOT", "PORTAGE_DEBUG", "PORTAGE_DEPCACHEDIR",
+	"PORTAGE_DOHTML_UNWARNED_SKIPPED_EXTENSIONS",
+	"PORTAGE_DOHTML_UNWARNED_SKIPPED_FILES",
+	"PORTAGE_DOHTML_WARN_ON_SKIPPED_FILES",
 	"PORTAGE_EBUILD_EXIT_FILE", "PORTAGE_FEATURES",
 	"PORTAGE_GID", "PORTAGE_GRPNAME",
+	"PORTAGE_INTERNAL_CALLER",
 	"PORTAGE_INST_GID", "PORTAGE_INST_UID",
-	"PORTAGE_IPC_DAEMON", "PORTAGE_IUSE",
-	"PORTAGE_LOG_FILE", "PORTAGE_OVERRIDE_EPREFIX",
-	"PORTAGE_PYM_PATH", "PORTAGE_PYTHON", "PORTAGE_QUIET",
-	"PORTAGE_REPO_NAME", "PORTAGE_RESTRICT",
+	"PORTAGE_IPC_DAEMON", "PORTAGE_IUSE", "PORTAGE_ECLASS_LOCATIONS",
+	"PORTAGE_LOG_FILE", "PORTAGE_OVERRIDE_EPREFIX", "PORTAGE_PIPE_FD",
+	"PORTAGE_PYM_PATH", "PORTAGE_PYTHON",
+	"PORTAGE_PYTHONPATH", "PORTAGE_QUIET",
+	"PORTAGE_REPO_NAME", "PORTAGE_REPOSITORIES", "PORTAGE_RESTRICT",
 	"PORTAGE_SIGPIPE_STATUS",
 	"PORTAGE_TMPDIR", "PORTAGE_UPDATE_ENV", "PORTAGE_USERNAME",
-	"PORTAGE_VERBOSE", "PORTAGE_WORKDIR_MODE",
+	"PORTAGE_VERBOSE", "PORTAGE_WORKDIR_MODE", "PORTAGE_XATTR_EXCLUDE",
 	"PORTDIR", "PORTDIR_OVERLAY", "PREROOTPATH", "PROFILE_PATHS",
 	"REPLACING_VERSIONS", "REPLACED_BY_VERSION",
 	"ROOT", "ROOTPATH", "T", "TMP", "TMPDIR",
@@ -102,7 +114,7 @@ environ_whitelist += [
 environ_whitelist += [
 	"CVS_RSH", "ECHANGELOG_USER",
 	"GPG_AGENT_INFO", "LOG_SOCKET",
-	"SSH_AGENT_PID", "SSH_AUTH_SOCK"
+	"SSH_AGENT_PID", "SSH_AUTH_SOCK",
 	"STY", "WINDOW", "XAUTHORITY",
 ]
 
@@ -133,9 +145,11 @@ environ_filter += [
 
 # portage config variables and variables set directly by portage
 environ_filter += [
-	"ACCEPT_CHOSTS", "ACCEPT_KEYWORDS", "ACCEPT_PROPERTIES", "AUTOCLEAN",
+	"ACCEPT_CHOSTS", "ACCEPT_KEYWORDS", "ACCEPT_PROPERTIES",
+	"ACCEPT_RESTRICT", "AUTOCLEAN",
 	"CLEAN_DELAY", "COLLISION_IGNORE",
 	"CONFIG_PROTECT", "CONFIG_PROTECT_MASK",
+	"DCO_SIGNED_OFF_BY",
 	"EGENCACHE_DEFAULT_OPTS", "EMERGE_DEFAULT_OPTS",
 	"EMERGE_LOG_DIR",
 	"EMERGE_WARNING_DELAY",
@@ -144,8 +158,9 @@ environ_filter += [
 	"FETCHCOMMAND_RSYNC", "FETCHCOMMAND_SFTP",
 	"GENTOO_MIRRORS", "NOCONFMEM", "O",
 	"PORTAGE_BACKGROUND", "PORTAGE_BACKGROUND_UNMERGE",
-	"PORTAGE_BINHOST",
-	"PORTAGE_BINHOST_CHUNKSIZE", "PORTAGE_BUILDIR_LOCKED",
+	"PORTAGE_BINHOST", "PORTAGE_BINPKG_FORMAT",
+	"PORTAGE_BUILDDIR_LOCKED",
+	"PORTAGE_CHECKSUM_FILTER",
 	"PORTAGE_ELOG_CLASSES",
 	"PORTAGE_ELOG_MAILFROM", "PORTAGE_ELOG_MAILSUBJECT",
 	"PORTAGE_ELOG_MAILURI", "PORTAGE_ELOG_SYSTEM",
@@ -157,13 +172,20 @@ environ_filter += [
 	"PORTAGE_REPO_DUPLICATE_WARN",
 	"PORTAGE_RO_DISTDIRS",
 	"PORTAGE_RSYNC_EXTRA_OPTS", "PORTAGE_RSYNC_OPTS",
-	"PORTAGE_RSYNC_RETRIES", "PORTAGE_SYNC_STALE",
-	"PORTAGE_USE", "PORT_LOGDIR", "PORT_LOGDIR_CLEAN",
+	"PORTAGE_RSYNC_RETRIES", "PORTAGE_SSH_OPTS", "PORTAGE_SYNC_STALE",
+	"PORTAGE_USE",
+	"PORT_LOGDIR", "PORT_LOGDIR_CLEAN",
 	"QUICKPKG_DEFAULT_OPTS", "REPOMAN_DEFAULT_OPTS",
 	"RESUMECOMMAND", "RESUMECOMMAND_FTP",
 	"RESUMECOMMAND_HTTP", "RESUMECOMMAND_HTTPS",
 	"RESUMECOMMAND_RSYNC", "RESUMECOMMAND_SFTP",
-	"SYNC", "USE_EXPAND_HIDDEN", "USE_ORDER",
+	"UNINSTALL_IGNORE", "USE_EXPAND_HIDDEN", "USE_ORDER",
+	"__PORTAGE_HELPER"
+]
+
+# No longer supported variables
+environ_filter += [
+	"SYNC"
 ]
 
 environ_filter = frozenset(environ_filter)
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.pyo b/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.pyo
index 06ea37e..92c5d32 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_config/special_env_vars.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.py b/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.py
deleted file mode 100644
index d23677d..0000000
--- a/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright 2012 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-import textwrap
-
-import portage
-from portage.dep import _repo_separator
-from portage.elog import elog_process
-from portage.elog.messages import eerror
-
-def eapi_invalid(self, cpv, repo_name, settings,
-	eapi_var, eapi_parsed, eapi_lineno):
-
-	msg = []
-	msg.extend(textwrap.wrap(("EAPI assignment in ebuild '%s%s%s' does not"
-		" conform with PMS section 7.3.1 (see bug #402167):") %
-		(cpv, _repo_separator, repo_name), 70))
-
-	if not eapi_parsed:
-		# None means the assignment was not found, while an
-		# empty string indicates an (invalid) empty assingment.
-		msg.append(
-			"\tvalid EAPI assignment must"
-			" occur on or before line: %s" %
-			eapi_lineno)
-	else:
-		msg.append(("\tbash returned EAPI '%s' which does not match "
-			"assignment on line: %s") %
-			(eapi_var, eapi_lineno))
-
-	if 'parse-eapi-ebuild-head' in settings.features:
-		msg.extend(textwrap.wrap(("NOTE: This error will soon"
-			" become unconditionally fatal in a future version of Portage,"
-			" but at this time, it can by made non-fatal by setting"
-			" FEATURES=-parse-eapi-ebuild-head in"
-			" make.conf."), 70))
-	else:
-		msg.extend(textwrap.wrap(("NOTE: This error will soon"
-			" become unconditionally fatal in a future version of Portage."
-			" At the earliest opportunity, please enable"
-			" FEATURES=parse-eapi-ebuild-head in make.conf in order to"
-			" make this error fatal."), 70))
-
-	if portage.data.secpass >= 2:
-		# TODO: improve elog permission error handling (bug #416231)
-		for line in msg:
-			eerror(line, phase="other", key=cpv)
-		elog_process(cpv, settings,
-			phasefilter=("other",))
-
-	else:
-		out = portage.output.EOutput()
-		for line in msg:
-			out.eerror(line)
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.pyo b/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.pyo
deleted file mode 100644
index 0181c03..0000000
--- a/portage_with_autodep/pym/portage/package/ebuild/_eapi_invalid.pyo
+++ /dev/null
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_ipc/ExitCommand.pyo b/portage_with_autodep/pym/portage/package/ebuild/_ipc/ExitCommand.pyo
index 315cb0f..744bb83 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_ipc/ExitCommand.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_ipc/ExitCommand.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_ipc/IpcCommand.pyo b/portage_with_autodep/pym/portage/package/ebuild/_ipc/IpcCommand.pyo
index 9f75518..ae66c3e 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_ipc/IpcCommand.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_ipc/IpcCommand.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.py b/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.py
index 7bbb0e8..351c956 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.py
@@ -1,12 +1,13 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 import io
 
 import portage
 from portage import os
-from portage import _unicode_decode
-from portage.dep import Atom
+from portage.dep import Atom, _repo_name_re
 from portage.eapi import eapi_has_repo_deps
 from portage.elog import messages as elog_messages
 from portage.exception import InvalidAtom
@@ -20,6 +21,12 @@ class QueryCommand(IpcCommand):
 
 	_db = None
 
+	@classmethod
+	def get_db(cls):
+		if cls._db is not None:
+			return cls._db
+		return portage.db
+
 	def __init__(self, settings, phase):
 		IpcCommand.__init__(self)
 		self.settings = settings
@@ -30,41 +37,46 @@ class QueryCommand(IpcCommand):
 		@return: tuple of (stdout, stderr, returncode)
 		"""
 
-		cmd, root, atom_str = argv
+		# Python 3:
+		# cmd, root, *args = argv
+		cmd = argv[0]
+		root = argv[1]
+		args = argv[2:]
+
+		warnings = []
+		warnings_str = ''
 
+		db = self.get_db()
 		eapi = self.settings.get('EAPI')
-		allow_repo = eapi_has_repo_deps(eapi)
-		try:
-			atom = Atom(atom_str, allow_repo=allow_repo)
-		except InvalidAtom:
-			return ('', 'invalid atom: %s\n' % atom_str, 2)
 
-		warnings = []
-		try:
-			atom = Atom(atom_str, allow_repo=allow_repo, eapi=eapi)
-		except InvalidAtom as e:
-			warnings.append(_unicode_decode("QA Notice: %s: %s") % (cmd, e))
+		root = normalize_path(root).rstrip(os.path.sep) + os.path.sep
+		if root not in db:
+			return ('', '%s: Invalid ROOT: %s\n' % (cmd, root), 3)
 
-		use = self.settings.get('PORTAGE_BUILT_USE')
-		if use is None:
-			use = self.settings['PORTAGE_USE']
+		portdb = db[root]["porttree"].dbapi
+		vardb = db[root]["vartree"].dbapi
 
-		use = frozenset(use.split())
-		atom = atom.evaluate_conditionals(use)
+		if cmd in ('best_version', 'has_version'):
+			allow_repo = eapi_has_repo_deps(eapi)
+			try:
+				atom = Atom(args[0], allow_repo=allow_repo)
+			except InvalidAtom:
+				return ('', '%s: Invalid atom: %s\n' % (cmd, args[0]), 2)
 
-		db = self._db
-		if db is None:
-			db = portage.db
+			try:
+				atom = Atom(args[0], allow_repo=allow_repo, eapi=eapi)
+			except InvalidAtom as e:
+				warnings.append("QA Notice: %s: %s" % (cmd, e))
 
-		warnings_str = ''
-		if warnings:
-			warnings_str = self._elog('eqawarn', warnings)
+			use = self.settings.get('PORTAGE_BUILT_USE')
+			if use is None:
+				use = self.settings['PORTAGE_USE']
 
-		root = normalize_path(root).rstrip(os.path.sep) + os.path.sep
-		if root not in db:
-			return ('', 'invalid ROOT: %s\n' % root, 2)
+			use = frozenset(use.split())
+			atom = atom.evaluate_conditionals(use)
 
-		vardb = db[root]["vartree"].dbapi
+		if warnings:
+			warnings_str = self._elog('eqawarn', warnings)
 
 		if cmd == 'has_version':
 			if vardb.match(atom):
@@ -75,8 +87,35 @@ class QueryCommand(IpcCommand):
 		elif cmd == 'best_version':
 			m = best(vardb.match(atom))
 			return ('%s\n' % m, warnings_str, 0)
+		elif cmd in ('master_repositories', 'repository_path', 'available_eclasses', 'eclass_path', 'license_path'):
+			repo = _repo_name_re.match(args[0])
+			if repo is None:
+				return ('', '%s: Invalid repository: %s\n' % (cmd, args[0]), 2)
+			try:
+				repo = portdb.repositories[args[0]]
+			except KeyError:
+				return ('', warnings_str, 1)
+
+			if cmd == 'master_repositories':
+				return ('%s\n' % ' '.join(x.name for x in repo.masters), warnings_str, 0)
+			elif cmd == 'repository_path':
+				return ('%s\n' % repo.location, warnings_str, 0)
+			elif cmd == 'available_eclasses':
+				return ('%s\n' % ' '.join(sorted(repo.eclass_db.eclasses)), warnings_str, 0)
+			elif cmd == 'eclass_path':
+				try:
+					eclass = repo.eclass_db.eclasses[args[1]]
+				except KeyError:
+					return ('', warnings_str, 1)
+				return ('%s\n' % eclass.location, warnings_str, 0)
+			elif cmd == 'license_path':
+				paths = reversed([os.path.join(x.location, 'licenses', args[1]) for x in list(repo.masters) + [repo]])
+				for path in paths:
+					if os.path.exists(path):
+						return ('%s\n' % path, warnings_str, 0)
+				return ('', warnings_str, 1)
 		else:
-			return ('', 'invalid command: %s\n' % cmd, 2)
+			return ('', 'Invalid command: %s\n' % cmd, 3)
 
 	def _elog(self, elog_funcname, lines):
 		"""
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.pyo b/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.pyo
index 0e9ee96..3087272 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_ipc/QueryCommand.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_ipc/__init__.pyo b/portage_with_autodep/pym/portage/package/ebuild/_ipc/__init__.pyo
index d9f8d25..270e321 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_ipc/__init__.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_ipc/__init__.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.py b/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.py
index 94f8c79..0fc53c8 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.py
@@ -1,8 +1,9 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 import tempfile
 
+import portage
 from portage import os
 from portage import shutil
 from portage.const import EBUILD_PHASES
@@ -10,10 +11,12 @@ from portage.elog import elog_process
 from portage.package.ebuild.config import config
 from portage.package.ebuild.doebuild import doebuild_environment
 from portage.package.ebuild.prepare_build_dirs import prepare_build_dirs
+from portage.util._async.SchedulerInterface import SchedulerInterface
+from portage.util._eventloop.EventLoop import EventLoop
+from portage.util._eventloop.global_event_loop import global_event_loop
 from _emerge.EbuildPhase import EbuildPhase
-from _emerge.PollScheduler import PollScheduler
 
-def spawn_nofetch(portdb, ebuild_path, settings=None):
+def spawn_nofetch(portdb, ebuild_path, settings=None, fd_pipes=None):
 	"""
 	This spawns pkg_nofetch if appropriate. The settings parameter
 	is useful only if setcpv has already been called in order
@@ -47,7 +50,7 @@ def spawn_nofetch(portdb, ebuild_path, settings=None):
 		settings = config(clone=settings)
 
 	if 'PORTAGE_PARALLEL_FETCHONLY' in settings:
-		return
+		return os.EX_OK
 
 	# We must create our private PORTAGE_TMPDIR before calling
 	# doebuild_environment(), since lots of variables such
@@ -59,7 +62,7 @@ def spawn_nofetch(portdb, ebuild_path, settings=None):
 	settings['PORTAGE_TMPDIR'] = private_tmpdir
 	settings.backup_changes('PORTAGE_TMPDIR')
 	# private temp dir was just created, so it's not locked yet
-	settings.pop('PORTAGE_BUILDIR_LOCKED', None)
+	settings.pop('PORTAGE_BUILDDIR_LOCKED', None)
 
 	try:
 		doebuild_environment(ebuild_path, 'nofetch',
@@ -73,14 +76,18 @@ def spawn_nofetch(portdb, ebuild_path, settings=None):
 
 		if 'fetch' not in restrict and \
 			'nofetch' not in defined_phases:
-			return
+			return os.EX_OK
 
 		prepare_build_dirs(settings=settings)
 		ebuild_phase = EbuildPhase(background=False,
-			phase='nofetch', scheduler=PollScheduler().sched_iface,
-			settings=settings)
+			phase='nofetch',
+			scheduler=SchedulerInterface(portage._internal_caller and
+				global_event_loop() or EventLoop(main=False)),
+			fd_pipes=fd_pipes, settings=settings)
 		ebuild_phase.start()
 		ebuild_phase.wait()
 		elog_process(settings.mycpv, settings)
 	finally:
 		shutil.rmtree(private_tmpdir)
+
+	return ebuild_phase.returncode
diff --git a/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.pyo b/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.pyo
index ac449ea..d4c597c 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/_spawn_nofetch.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/config.py b/portage_with_autodep/pym/portage/package/ebuild/config.py
index 97cbd99..92e6c3f 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/config.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/config.py
@@ -1,6 +1,8 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = [
 	'autouse', 'best_from_dict', 'check_config_instance', 'config',
 ]
@@ -19,6 +21,8 @@ from _emerge.Package import Package
 import portage
 portage.proxy.lazyimport.lazyimport(globals(),
 	'portage.data:portage_gid',
+	'portage.dbapi.vartree:vartree',
+	'portage.package.ebuild.doebuild:_phase_func_map',
 )
 from portage import bsd_chflags, \
 	load_mod, os, selinux, _unicode_decode
@@ -29,10 +33,9 @@ from portage.const import CACHE_PATH, \
 	USER_VIRTUALS_FILE
 from portage.dbapi import dbapi
 from portage.dbapi.porttree import portdbapi
-from portage.dbapi.vartree import vartree
 from portage.dep import Atom, isvalidatom, match_from_list, use_reduce, _repo_separator, _slot_separator
 from portage.eapi import eapi_exports_AA, eapi_exports_merge_type, \
-	eapi_supports_prefix, eapi_exports_replace_vars
+	eapi_supports_prefix, eapi_exports_replace_vars, _get_eapi_attrs
 from portage.env.loaders import KeyValuePairFileLoader
 from portage.exception import InvalidDependString, PortageException
 from portage.localization import _
@@ -42,7 +45,8 @@ from portage.repository.config import load_repository_config
 from portage.util import ensure_dirs, getconfig, grabdict, \
 	grabdict_package, grabfile, grabfile_package, LazyItemsDict, \
 	normalize_path, shlex_split, stack_dictlist, stack_dicts, stack_lists, \
-	writemsg, writemsg_level
+	writemsg, writemsg_level, _eapi_cache
+from portage.util._path import exists_raise_eaccess, isdir_raise_eaccess
 from portage.versions import catpkgsplit, catsplit, cpv_getkey, _pkg_str
 
 from portage.package.ebuild._config import special_env_vars
@@ -55,10 +59,29 @@ from portage.package.ebuild._config.LocationsManager import LocationsManager
 from portage.package.ebuild._config.MaskManager import MaskManager
 from portage.package.ebuild._config.VirtualsManager import VirtualsManager
 from portage.package.ebuild._config.helper import ordered_by_atom_specificity, prune_incremental
+from portage.package.ebuild._config.unpack_dependencies import load_unpack_dependencies_configuration
 
 if sys.hexversion >= 0x3000000:
 	basestring = str
 
+_feature_flags_cache = {}
+
+def _get_feature_flags(eapi_attrs):
+	cache_key = (eapi_attrs.feature_flag_test, eapi_attrs.feature_flag_targetroot)
+	flags = _feature_flags_cache.get(cache_key)
+	if flags is not None:
+		return flags
+
+	flags = []
+	if eapi_attrs.feature_flag_test:
+		flags.append("test")
+	if eapi_attrs.feature_flag_targetroot:
+		flags.append("targetroot")
+
+	flags = frozenset(flags)
+	_feature_flags_cache[cache_key] = flags
+	return flags
+
 def autouse(myvartree, use_cache=1, mysettings=None):
 	warnings.warn("portage.autouse() is deprecated",
 		DeprecationWarning, stacklevel=2)
@@ -123,9 +146,9 @@ class config(object):
 	"""
 
 	_constant_keys = frozenset(['PORTAGE_BIN_PATH', 'PORTAGE_GID',
-		'PORTAGE_PYM_PATH'])
+		'PORTAGE_PYM_PATH', 'PORTAGE_PYTHONPATH'])
 
-	_setcpv_aux_keys = ('DEFINED_PHASES', 'DEPEND', 'EAPI',
+	_setcpv_aux_keys = ('DEFINED_PHASES', 'DEPEND', 'EAPI', 'HDEPEND',
 		'INHERITED', 'IUSE', 'REQUIRED_USE', 'KEYWORDS', 'LICENSE', 'PDEPEND',
 		'PROPERTIES', 'PROVIDE', 'RDEPEND', 'SLOT',
 		'repository', 'RESTRICT', 'LICENSE',)
@@ -146,7 +169,7 @@ class config(object):
 	def __init__(self, clone=None, mycpv=None, config_profile_path=None,
 		config_incrementals=None, config_root=None, target_root=None,
 		eprefix=None, local_config=True, env=None,
-		_unmatched_removal=False):
+		_unmatched_removal=False, repositories=None):
 		"""
 		@param clone: If provided, init will use deepcopy to copy by value the instance.
 		@type clone: Instance of config class.
@@ -160,7 +183,8 @@ class config(object):
 		@type config_incrementals: List
 		@param config_root: path to read local config from (defaults to "/", see PORTAGE_CONFIGROOT)
 		@type config_root: String
-		@param target_root: __init__ override of $ROOT env variable.
+		@param target_root: the target root, which typically corresponds to the
+			value of the $ROOT env variable (default is /)
 		@type target_root: String
 		@param eprefix: set the EPREFIX variable (default is portage.const.EPREFIX)
 		@type eprefix: String
@@ -173,14 +197,21 @@ class config(object):
 		@param _unmatched_removal: Enabled by repoman when the
 			--unmatched-removal option is given.
 		@type _unmatched_removal: Boolean
+		@param repositories: Configuration of repositories.
+			Defaults to portage.repository.config.load_repository_config().
+		@type repositories: Instance of portage.repository.config.RepoConfigLoader class.
 		"""
 
+		# This is important when config is reloaded after emerge --sync.
+		_eapi_cache.clear()
+
 		# When initializing the global portage.settings instance, avoid
 		# raising exceptions whenever possible since exceptions thrown
 		# from 'import portage' or 'import portage.exceptions' statements
 		# can practically render the api unusable for api consumers.
 		tolerant = hasattr(portage, '_initializing_globals')
 		self._tolerant = tolerant
+		self._unmatched_removal = _unmatched_removal
 
 		self.locked   = 0
 		self.mycpv    = None
@@ -191,8 +222,10 @@ class config(object):
 		self.uvlist = []
 		self._accept_chost_re = None
 		self._accept_properties = None
+		self._accept_restrict = None
 		self._features_overrides = []
 		self._make_defaults = None
+		self._parent_stable = None
 
 		# _unknown_features records unknown features that
 		# have triggered warning messages, and ensures that
@@ -205,6 +238,7 @@ class config(object):
 			# For immutable attributes, use shallow copy for
 			# speed and memory conservation.
 			self._tolerant = clone._tolerant
+			self._unmatched_removal = clone._unmatched_removal
 			self.categories = clone.categories
 			self.depcachedir = clone.depcachedir
 			self.incrementals = clone.incrementals
@@ -213,6 +247,8 @@ class config(object):
 			self.profiles = clone.profiles
 			self.packages = clone.packages
 			self.repositories = clone.repositories
+			self.unpack_dependencies = clone.unpack_dependencies
+			self._iuse_effective = clone._iuse_effective
 			self._iuse_implicit_match = clone._iuse_implicit_match
 			self._non_user_variables = clone._non_user_variables
 			self._env_d_blacklist = clone._env_d_blacklist
@@ -227,9 +263,12 @@ class config(object):
 			self._setcpv_args_hash = clone._setcpv_args_hash
 
 			# immutable attributes (internal policy ensures lack of mutation)
-			self._keywords_manager = clone._keywords_manager
+			self._locations_manager = clone._locations_manager
 			self._use_manager = clone._use_manager
-			self._mask_manager = clone._mask_manager
+			# force instantiation of lazy immutable objects when cloning, so
+			# that they're not instantiated more than once
+			self._keywords_manager_obj = clone._keywords_manager
+			self._mask_manager_obj = clone._mask_manager
 
 			# shared mutable attributes
 			self._unknown_features = clone._unknown_features
@@ -266,30 +305,55 @@ class config(object):
 			#all LicenseManager instances.
 			self._license_manager = clone._license_manager
 
-			self._virtuals_manager = copy.deepcopy(clone._virtuals_manager)
+			# force instantiation of lazy objects when cloning, so
+			# that they're not instantiated more than once
+			self._virtuals_manager_obj = copy.deepcopy(clone._virtuals_manager)
 
 			self._accept_properties = copy.deepcopy(clone._accept_properties)
 			self._ppropertiesdict = copy.deepcopy(clone._ppropertiesdict)
+			self._accept_restrict = copy.deepcopy(clone._accept_restrict)
+			self._paccept_restrict = copy.deepcopy(clone._paccept_restrict)
 			self._penvdict = copy.deepcopy(clone._penvdict)
 			self._expand_map = copy.deepcopy(clone._expand_map)
 
 		else:
+			# lazily instantiated objects
+			self._keywords_manager_obj = None
+			self._mask_manager_obj = None
+			self._virtuals_manager_obj = None
+
 			locations_manager = LocationsManager(config_root=config_root,
 				config_profile_path=config_profile_path, eprefix=eprefix,
 				local_config=local_config, target_root=target_root)
+			self._locations_manager = locations_manager
 
 			eprefix = locations_manager.eprefix
 			config_root = locations_manager.config_root
 			abs_user_config = locations_manager.abs_user_config
+			make_conf_paths = [
+				os.path.join(config_root, 'etc', 'make.conf'),
+				os.path.join(config_root, MAKE_CONF_FILE)
+			]
+			try:
+				if os.path.samefile(*make_conf_paths):
+					make_conf_paths.pop()
+			except OSError:
+				pass
 
-			make_conf = getconfig(
-				os.path.join(config_root, MAKE_CONF_FILE),
-				tolerant=tolerant, allow_sourcing=True) or {}
-
-			make_conf.update(getconfig(
-				os.path.join(abs_user_config, 'make.conf'),
-				tolerant=tolerant, allow_sourcing=True,
-				expand=make_conf) or {})
+			make_conf_count = 0
+			make_conf = {}
+			for x in make_conf_paths:
+				mygcfg = getconfig(x,
+					tolerant=tolerant, allow_sourcing=True,
+					expand=make_conf, recursive=True)
+				if mygcfg is not None:
+					make_conf.update(mygcfg)
+					make_conf_count += 1
+
+			if make_conf_count == 2:
+				writemsg("!!! %s\n" %
+					_("Found 2 make.conf files, using both '%s' and '%s'") %
+					tuple(make_conf_paths), noiselevel=-1)
 
 			# Allow ROOT setting to come from make.conf if it's not overridden
 			# by the constructor argument (from the calling environment).
@@ -315,15 +379,30 @@ class config(object):
 			# lead to unexpected results.
 
 			env_d = getconfig(os.path.join(eroot, "etc", "profile.env"),
-				expand=False) or {}
+				tolerant=tolerant, expand=False) or {}
 			expand_map = env_d.copy()
 			self._expand_map = expand_map
 
 			# Allow make.globals to set default paths relative to ${EPREFIX}.
 			expand_map["EPREFIX"] = eprefix
 
-			make_globals = getconfig(os.path.join(
-				self.global_config_path, 'make.globals'), expand=expand_map)
+			make_globals_path = os.path.join(
+				self.global_config_path, 'make.globals')
+			old_make_globals = os.path.join(config_root,
+				'etc', 'make.globals')
+			if os.path.isfile(old_make_globals) and \
+				not os.path.samefile(make_globals_path, old_make_globals):
+				# Don't warn if they refer to the same path, since
+				# that can be used for backward compatibility with
+				# old software.
+				writemsg("!!! %s\n" %
+					_("Found obsolete make.globals file: "
+					"'%s', (using '%s' instead)") %
+					(old_make_globals, make_globals_path),
+					noiselevel=-1)
+
+			make_globals = getconfig(make_globals_path,
+				tolerant=tolerant, expand=expand_map)
 			if make_globals is None:
 				make_globals = {}
 
@@ -412,6 +491,7 @@ class config(object):
 			known_repos = []
 			portdir = ""
 			portdir_overlay = ""
+			portdir_sync = None
 			for confs in [make_globals, make_conf, self.configdict["env"]]:
 				v = confs.get("PORTDIR")
 				if v is not None:
@@ -421,12 +501,52 @@ class config(object):
 				if v is not None:
 					portdir_overlay = v
 					known_repos.extend(shlex_split(v))
+				v = confs.get("SYNC")
+				if v is not None:
+					portdir_sync = v
+
 			known_repos = frozenset(known_repos)
 			self["PORTDIR"] = portdir
 			self["PORTDIR_OVERLAY"] = portdir_overlay
+			if portdir_sync:
+				self["SYNC"] = portdir_sync
 			self.lookuplist = [self.configdict["env"]]
-			self.repositories = load_repository_config(self)
+			if repositories is None:
+				self.repositories = load_repository_config(self)
+			else:
+				self.repositories = repositories
+
+			self['PORTAGE_REPOSITORIES'] = self.repositories.config_string()
+			self.backup_changes('PORTAGE_REPOSITORIES')
+
+			#filling PORTDIR and PORTDIR_OVERLAY variable for compatibility
+			main_repo = self.repositories.mainRepo()
+			if main_repo is not None:
+				self["PORTDIR"] = main_repo.user_location
+				self.backup_changes("PORTDIR")
+				expand_map["PORTDIR"] = self["PORTDIR"]
+
+			# repoman controls PORTDIR_OVERLAY via the environment, so no
+			# special cases are needed here.
+			portdir_overlay = list(self.repositories.repoUserLocationList())
+			if portdir_overlay and portdir_overlay[0] == self["PORTDIR"]:
+				portdir_overlay = portdir_overlay[1:]
+
+			new_ov = []
+			if portdir_overlay:
+				for ov in portdir_overlay:
+					ov = normalize_path(ov)
+					if isdir_raise_eaccess(ov) or portage._sync_disabled_warnings:
+						new_ov.append(portage._shell_quote(ov))
+					else:
+						writemsg(_("!!! Invalid PORTDIR_OVERLAY"
+							" (not a dir): '%s'\n") % ov, noiselevel=-1)
 
+			self["PORTDIR_OVERLAY"] = " ".join(new_ov)
+			self.backup_changes("PORTDIR_OVERLAY")
+			expand_map["PORTDIR_OVERLAY"] = self["PORTDIR_OVERLAY"]
+
+			locations_manager.set_port_dirs(self["PORTDIR"], self["PORTDIR_OVERLAY"])
 			locations_manager.load_profiles(self.repositories, known_repos)
 
 			profiles_complex = locations_manager.profiles_complex
@@ -446,11 +566,13 @@ class config(object):
 					x = Atom(x.lstrip('*'))
 				self.prevmaskdict.setdefault(x.cp, []).append(x)
 
+			self.unpack_dependencies = load_unpack_dependencies_configuration(self.repositories)
 
 			mygcfg = {}
-			if self.profiles:
-				mygcfg_dlists = [getconfig(os.path.join(x, "make.defaults"),
-					expand=expand_map) for x in self.profiles]
+			if profiles_complex:
+				mygcfg_dlists = [getconfig(os.path.join(x.location, "make.defaults"),
+					tolerant=tolerant, expand=expand_map, recursive=x.portage1_directories)
+					for x in profiles_complex]
 				self._make_defaults = mygcfg_dlists
 				mygcfg = stack_dicts(mygcfg_dlists,
 					incrementals=self.incrementals)
@@ -459,15 +581,11 @@ class config(object):
 			self.configlist.append(mygcfg)
 			self.configdict["defaults"]=self.configlist[-1]
 
-			mygcfg = getconfig(
-				os.path.join(config_root, MAKE_CONF_FILE),
-				tolerant=tolerant, allow_sourcing=True,
-				expand=expand_map) or {}
-
-			mygcfg.update(getconfig(
-				os.path.join(abs_user_config, 'make.conf'),
-				tolerant=tolerant, allow_sourcing=True,
-				expand=expand_map) or {})
+			mygcfg = {}
+			for x in make_conf_paths:
+				mygcfg.update(getconfig(x,
+					tolerant=tolerant, allow_sourcing=True,
+					expand=expand_map, recursive=True) or {})
 
 			# Don't allow the user to override certain variables in make.conf
 			profile_only_variables = self.configdict["defaults"].get(
@@ -520,66 +638,34 @@ class config(object):
 			self.backup_changes("PORTAGE_CONFIGROOT")
 			self["ROOT"] = target_root
 			self.backup_changes("ROOT")
-
-			# The PORTAGE_OVERRIDE_EPREFIX variable propagates the EPREFIX
-			# of this config instance to any portage commands or API
-			# consumers running in subprocesses.
 			self["EPREFIX"] = eprefix
 			self.backup_changes("EPREFIX")
-			self["PORTAGE_OVERRIDE_EPREFIX"] = eprefix
-			self.backup_changes("PORTAGE_OVERRIDE_EPREFIX")
 			self["EROOT"] = eroot
 			self.backup_changes("EROOT")
 
+			# The prefix of the running portage instance is used in the
+			# ebuild environment to implement the --host-root option for
+			# best_version and has_version.
+			self["PORTAGE_OVERRIDE_EPREFIX"] = portage.const.EPREFIX
+			self.backup_changes("PORTAGE_OVERRIDE_EPREFIX")
+
 			self._ppropertiesdict = portage.dep.ExtendedAtomDict(dict)
+			self._paccept_restrict = portage.dep.ExtendedAtomDict(dict)
 			self._penvdict = portage.dep.ExtendedAtomDict(dict)
 
-			#filling PORTDIR and PORTDIR_OVERLAY variable for compatibility
-			main_repo = self.repositories.mainRepo()
-			if main_repo is not None:
-				self["PORTDIR"] = main_repo.user_location
-				self.backup_changes("PORTDIR")
-
-			# repoman controls PORTDIR_OVERLAY via the environment, so no
-			# special cases are needed here.
-			portdir_overlay = list(self.repositories.repoUserLocationList())
-			if portdir_overlay and portdir_overlay[0] == self["PORTDIR"]:
-				portdir_overlay = portdir_overlay[1:]
-
-			new_ov = []
-			if portdir_overlay:
-				shell_quote_re = re.compile(r"[\s\\\"'$`]")
-				for ov in portdir_overlay:
-					ov = normalize_path(ov)
-					if os.path.isdir(ov):
-						if shell_quote_re.search(ov) is not None:
-							ov = portage._shell_quote(ov)
-						new_ov.append(ov)
-					else:
-						writemsg(_("!!! Invalid PORTDIR_OVERLAY"
-							" (not a dir): '%s'\n") % ov, noiselevel=-1)
-
-			self["PORTDIR_OVERLAY"] = " ".join(new_ov)
-			self.backup_changes("PORTDIR_OVERLAY")
-
-			locations_manager.set_port_dirs(self["PORTDIR"], self["PORTDIR_OVERLAY"])
-
 			self._repo_make_defaults = {}
 			for repo in self.repositories.repos_with_profiles():
 				d = getconfig(os.path.join(repo.location, "profiles", "make.defaults"),
-					expand=self.configdict["globals"].copy()) or {}
+					tolerant=tolerant, expand=self.configdict["globals"].copy(), recursive=repo.portage1_profiles) or {}
 				if d:
 					for k in chain(self._env_blacklist,
 						profile_only_variables, self._global_only_vars):
 						d.pop(k, None)
 				self._repo_make_defaults[repo.name] = d
 
-			#Read package.keywords and package.accept_keywords.
-			self._keywords_manager = KeywordsManager(profiles_complex, abs_user_config, \
-				local_config, global_accept_keywords=self.configdict["defaults"].get("ACCEPT_KEYWORDS", ""))
-
 			#Read all USE related files from profiles and optionally from user config.
-			self._use_manager = UseManager(self.repositories, profiles_complex, abs_user_config, user_config=local_config)
+			self._use_manager = UseManager(self.repositories, profiles_complex,
+				abs_user_config, self._isStable, user_config=local_config)
 			#Initialize all USE related variables we track ourselves.
 			self.usemask = self._use_manager.getUseMask()
 			self.useforce = self._use_manager.getUseForce()
@@ -595,13 +681,6 @@ class config(object):
 				self._license_manager.extract_global_changes( \
 					self.configdict["conf"].get("ACCEPT_LICENSE", ""))
 
-			#Read package.mask and package.unmask from profiles and optionally from user config
-			self._mask_manager = MaskManager(self.repositories, profiles_complex,
-				abs_user_config, user_config=local_config,
-				strict_umatched_removal=_unmatched_removal)
-
-			self._virtuals_manager = VirtualsManager(self.profiles)
-
 			if local_config:
 				#package.properties
 				propdict = grabdict_package(os.path.join(
@@ -616,6 +695,20 @@ class config(object):
 				for k, v in propdict.items():
 					self._ppropertiesdict.setdefault(k.cp, {})[k] = v
 
+				# package.accept_restrict
+				d = grabdict_package(os.path.join(
+					abs_user_config, "package.accept_restrict"),
+					recursive=True, allow_wildcard=True,
+					allow_repo=True, verify_eapi=False)
+				v = d.pop("*/*", None)
+				if v is not None:
+					if "ACCEPT_RESTRICT" in self.configdict["conf"]:
+						self.configdict["conf"]["ACCEPT_RESTRICT"] += " " + " ".join(v)
+					else:
+						self.configdict["conf"]["ACCEPT_RESTRICT"] = " ".join(v)
+				for k, v in d.items():
+					self._paccept_restrict.setdefault(k.cp, {})[k] = v
+
 				#package.env
 				penvdict = grabdict_package(os.path.join(
 					abs_user_config, "package.env"), recursive=1, allow_wildcard=True, \
@@ -702,21 +795,9 @@ class config(object):
 				self.backupenv["USE_ORDER"] = "env:pkg:conf:defaults:pkginternal:repo:env.d"
 
 			self.depcachedir = DEPCACHE_PATH
-			if eprefix:
-				# See comments about make.globals and EPREFIX
-				# above. DEPCACHE_PATH is similar.
-				if target_root == "/":
-					# case (1) above
-					self.depcachedir = os.path.join(eprefix,
-						DEPCACHE_PATH.lstrip(os.sep))
-				else:
-					# case (2) above
-					# For now, just assume DEPCACHE_PATH is relative
-					# to EPREFIX.
-					# TODO: Pass in more info to the constructor,
-					# so we know the host system configuration.
-					self.depcachedir = os.path.join(eprefix,
-						DEPCACHE_PATH.lstrip(os.sep))
+			if portage.const.EPREFIX:
+				self.depcachedir = os.path.join(portage.const.EPREFIX,
+					DEPCACHE_PATH.lstrip(os.sep))
 
 			if self.get("PORTAGE_DEPCACHEDIR", None):
 				self.depcachedir = self["PORTAGE_DEPCACHEDIR"]
@@ -783,12 +864,17 @@ class config(object):
 					self[var] = default_val
 				self.backup_changes(var)
 
+			if portage._internal_caller:
+				self["PORTAGE_INTERNAL_CALLER"] = "1"
+				self.backup_changes("PORTAGE_INTERNAL_CALLER")
+
 			# initialize self.features
 			self.regenerate()
 
 			if bsd_chflags:
 				self.features.add('chflags')
 
+			self._iuse_effective = self._calc_iuse_effective()
 			self._iuse_implicit_match = _iuse_implicit_match_cache(self)
 
 			self._validate_commands()
@@ -798,11 +884,6 @@ class config(object):
 					self[k] = self[k].lower()
 					self.backup_changes(k)
 
-			if main_repo is not None and not main_repo.sync:
-				main_repo_sync = self.get("SYNC")
-				if main_repo_sync:
-					main_repo.sync = main_repo_sync
-
 			# The first constructed config object initializes these modules,
 			# and subsequent calls to the _init() functions have no effect.
 			portage.output._init(config_root=self['PORTAGE_CONFIGROOT'])
@@ -882,6 +963,32 @@ class config(object):
 					noiselevel=-1)
 
 	@property
+	def _keywords_manager(self):
+		if self._keywords_manager_obj is None:
+			self._keywords_manager_obj = KeywordsManager(
+				self._locations_manager.profiles_complex,
+				self._locations_manager.abs_user_config,
+				self.local_config,
+				global_accept_keywords=self.configdict["defaults"].get("ACCEPT_KEYWORDS", ""))
+		return self._keywords_manager_obj
+
+	@property
+	def _mask_manager(self):
+		if self._mask_manager_obj is None:
+			self._mask_manager_obj = MaskManager(self.repositories,
+				self._locations_manager.profiles_complex,
+				self._locations_manager.abs_user_config,
+				user_config=self.local_config,
+				strict_umatched_removal=self._unmatched_removal)
+		return self._mask_manager_obj
+
+	@property
+	def _virtuals_manager(self):
+		if self._virtuals_manager_obj is None:
+			self._virtuals_manager_obj = VirtualsManager(self.profiles)
+		return self._virtuals_manager_obj
+
+	@property
 	def pkeywordsdict(self):
 		result = self._keywords_manager.pkeywordsdict.copy()
 		for k, v in result.items():
@@ -919,13 +1026,23 @@ class config(object):
 					writemsg(_("!!! INVALID ACCEPT_KEYWORDS: %s\n") % str(group),
 						noiselevel=-1)
 
-		profile_broken = not self.profile_path or \
-			not os.path.exists(os.path.join(self.profile_path, "parent")) and \
-			os.path.exists(os.path.join(self["PORTDIR"], "profiles"))
+		profile_broken = False
+
+		if not self.profile_path:
+			profile_broken = True
+		else:
+			# If any one of these files exists, then
+			# the profile is considered valid.
+			for x in ("make.defaults", "parent",
+				"packages", "use.force", "use.mask"):
+				if exists_raise_eaccess(os.path.join(self.profile_path, x)):
+					break
+			else:
+				profile_broken = True
 
-		if profile_broken:
+		if profile_broken and not portage._sync_disabled_warnings:
 			abs_profile_path = None
-			for x in (PROFILE_PATH, 'etc/portage/make.profile'):
+			for x in (PROFILE_PATH, 'etc/make.profile'):
 				x = os.path.join(self["PORTAGE_CONFIGROOT"], x)
 				try:
 					os.lstat(x)
@@ -1091,8 +1208,11 @@ class config(object):
 		the previously calculated USE settings.
 		"""
 
-		def __init__(self, use, usemask, iuse_implicit,
+		def __init__(self, settings, unfiltered_use,
+			use, usemask, iuse_implicit,
 			use_expand_split, use_expand_dict):
+			self._settings = settings
+			self._unfiltered_use = unfiltered_use
 			self._use = use
 			self._usemask = usemask
 			self._iuse_implicit = iuse_implicit
@@ -1147,13 +1267,32 @@ class config(object):
 				# Don't export empty USE_EXPAND vars unless the user config
 				# exports them as empty.  This is required for vars such as
 				# LINGUAS, where unset and empty have different meanings.
+				# The special '*' token is understood by ebuild.sh, which
+				# will unset the variable so that things like LINGUAS work
+				# properly (see bug #459350).
 				if has_wildcard:
-					# ebuild.sh will see this and unset the variable so
-					# that things like LINGUAS work properly
 					value = '*'
 				else:
 					if has_iuse:
-						value = ''
+						already_set = False
+						# Skip the first 'env' configdict, in order to
+						# avoid infinite recursion here, since that dict's
+						# __getitem__ calls the current __getitem__.
+						for d in self._settings.lookuplist[1:]:
+							if key in d:
+								already_set = True
+								break
+
+						if not already_set:
+							for x in self._unfiltered_use:
+								if x[:prefix_len] == prefix:
+									already_set = True
+									break
+
+						if already_set:
+							value = ''
+						else:
+							value = '*'
 					else:
 						# It's not in IUSE, so just allow the variable content
 						# to pass through if it is defined somewhere.  This
@@ -1189,7 +1328,7 @@ class config(object):
 		if not isinstance(mycpv, basestring):
 			pkg = mycpv
 			mycpv = pkg.cpv
-			mydb = pkg.metadata
+			mydb = pkg._metadata
 			explicit_iuse = pkg.iuse.all
 			args_hash = (mycpv, id(pkg))
 			if pkg.built:
@@ -1210,6 +1349,7 @@ class config(object):
 		iuse = ""
 		pkg_configdict = self.configdict["pkg"]
 		previous_iuse = pkg_configdict.get("IUSE")
+		previous_iuse_effective = pkg_configdict.get("IUSE_EFFECTIVE")
 		previous_features = pkg_configdict.get("FEATURES")
 
 		aux_keys = self._setcpv_aux_keys
@@ -1221,6 +1361,7 @@ class config(object):
 		pkg_configdict["CATEGORY"] = cat
 		pkg_configdict["PF"] = pf
 		repository = None
+		eapi = None
 		if mydb:
 			if not hasattr(mydb, "aux_get"):
 				for k in aux_keys:
@@ -1247,14 +1388,16 @@ class config(object):
 					# Empty USE means this dbapi instance does not contain
 					# built packages.
 					built_use = None
+			eapi = pkg_configdict['EAPI']
 
 			repository = pkg_configdict.pop("repository", None)
 			if repository is not None:
 				pkg_configdict["PORTAGE_REPO_NAME"] = repository
-			slot = pkg_configdict["SLOT"]
 			iuse = pkg_configdict["IUSE"]
 			if pkg is None:
-				cpv_slot = _pkg_str(self.mycpv, slot=slot, repo=repository)
+				self.mycpv = _pkg_str(self.mycpv, metadata=pkg_configdict,
+					settings=self)
+				cpv_slot = self.mycpv
 			else:
 				cpv_slot = pkg
 			pkginternaluse = []
@@ -1264,6 +1407,9 @@ class config(object):
 				elif x.startswith("-"):
 					pkginternaluse.append(x)
 			pkginternaluse = " ".join(pkginternaluse)
+
+		eapi_attrs = _get_eapi_attrs(eapi)
+
 		if pkginternaluse != self.configdict["pkginternal"].get("USE", ""):
 			self.configdict["pkginternal"]["USE"] = pkginternaluse
 			has_changed = True
@@ -1394,30 +1540,70 @@ class config(object):
 
 		# If reset() has not been called, it's safe to return
 		# early if IUSE has not changed.
-		if not has_changed and previous_iuse == iuse:
+		if not has_changed and previous_iuse == iuse and \
+			(previous_iuse_effective is not None == eapi_attrs.iuse_effective):
 			return
 
 		# Filter out USE flags that aren't part of IUSE. This has to
 		# be done for every setcpv() call since practically every
 		# package has different IUSE.
 		use = set(self["USE"].split())
+		unfiltered_use = frozenset(use)
 		if explicit_iuse is None:
 			explicit_iuse = frozenset(x.lstrip("+-") for x in iuse.split())
-		iuse_implicit_match = self._iuse_implicit_match
-		portage_iuse = self._get_implicit_iuse()
-		portage_iuse.update(explicit_iuse)
+
+		if eapi_attrs.iuse_effective:
+			iuse_implicit_match = self._iuse_effective_match
+			portage_iuse = set(self._iuse_effective)
+			portage_iuse.update(explicit_iuse)
+			self.configdict["pkg"]["IUSE_EFFECTIVE"] = \
+				" ".join(sorted(portage_iuse))
+		else:
+			iuse_implicit_match = self._iuse_implicit_match
+			portage_iuse = self._get_implicit_iuse()
+			portage_iuse.update(explicit_iuse)
 
 		# PORTAGE_IUSE is not always needed so it's lazily evaluated.
 		self.configdict["env"].addLazySingleton(
 			"PORTAGE_IUSE", _lazy_iuse_regex, portage_iuse)
 
-		ebuild_force_test = self.get("EBUILD_FORCE_TEST") == "1"
+		if pkg is None:
+			raw_restrict = pkg_configdict.get("RESTRICT")
+		else:
+			raw_restrict = pkg._raw_metadata["RESTRICT"]
+
+		restrict_test = False
+		if raw_restrict:
+			try:
+				if built_use is not None:
+					restrict = use_reduce(raw_restrict,
+						uselist=built_use, flat=True)
+				else:
+					# Use matchnone=True to ignore USE conditional parts
+					# of RESTRICT, since we want to know whether to mask
+					# the "test" flag _before_ we know the USE values
+					# that would be needed to evaluate the USE
+					# conditionals (see bug #273272).
+					restrict = use_reduce(raw_restrict,
+						matchnone=True, flat=True)
+			except PortageException:
+				pass
+			else:
+				restrict_test = "test" in restrict
+
+		ebuild_force_test = not restrict_test and \
+			self.get("EBUILD_FORCE_TEST") == "1"
+
 		if ebuild_force_test and \
 			not hasattr(self, "_ebuild_force_test_msg_shown"):
 				self._ebuild_force_test_msg_shown = True
 				writemsg(_("Forcing test.\n"), noiselevel=-1)
-		if "test" in self.features:
-			if "test" in self.usemask and not ebuild_force_test:
+
+		if "test" in explicit_iuse or iuse_implicit_match("test"):
+			if "test" not in self.features:
+				use.discard("test")
+			elif restrict_test or \
+				("test" in self.usemask and not ebuild_force_test):
 				# "test" is in IUSE and USE=test is masked, so execution
 				# of src_test() probably is not reliable. Therefore,
 				# temporarily disable FEATURES=test just for this package.
@@ -1430,6 +1616,13 @@ class config(object):
 					self.usemask = \
 						frozenset(x for x in self.usemask if x != "test")
 
+		if eapi_attrs.feature_flag_targetroot and \
+			("targetroot" in explicit_iuse or iuse_implicit_match("targetroot")):
+			if self["ROOT"] != "/":
+				use.add("targetroot")
+			else:
+				use.discard("targetroot")
+
 		# Allow _* flags from USE_EXPAND wildcards to pass through here.
 		use.difference_update([x for x in use \
 			if (x not in explicit_iuse and \
@@ -1440,7 +1633,8 @@ class config(object):
 		# comparison instead of startswith().
 		use_expand_split = set(x.lower() for \
 			x in self.get('USE_EXPAND', '').split())
-		lazy_use_expand = self._lazy_use_expand(use, self.usemask,
+		lazy_use_expand = self._lazy_use_expand(
+			self, unfiltered_use, use, self.usemask,
 			portage_iuse, use_expand_split, self._use_expand_dict)
 
 		use_expand_iuses = {}
@@ -1470,6 +1664,14 @@ class config(object):
 			self.configdict['env'].addLazySingleton(k,
 				lazy_use_expand.__getitem__, k)
 
+		for k in self.get("USE_EXPAND_UNPREFIXED", "").split():
+			var_split = self.get(k, '').split()
+			var_split = [ x for x in var_split if x in use ]
+			if var_split:
+				self.configlist[-1][k] = ' '.join(var_split)
+			elif k in self:
+				self.configlist[-1][k] = ''
+
 		# Filtered for the ebuild environment. Store this in a separate
 		# attribute since we still want to be able to see global USE
 		# settings for things like emerge --info.
@@ -1477,6 +1679,10 @@ class config(object):
 		self.configdict["env"]["PORTAGE_USE"] = \
 			" ".join(sorted(x for x in use if x[-2:] != '_*'))
 
+		# Clear the eapi cache here rather than in the constructor, since
+		# setcpv triggers lazy instantiation of things like _use_manager.
+		_eapi_cache.clear()
+
 	def _grab_pkg_env(self, penv, container, protected_keys=None):
 		if protected_keys is None:
 			protected_keys = ()
@@ -1510,9 +1716,42 @@ class config(object):
 					else:
 						container[k] = v
 
+	def _iuse_effective_match(self, flag):
+		return flag in self._iuse_effective
+
+	def _calc_iuse_effective(self):
+		"""
+		Beginning with EAPI 5, IUSE_EFFECTIVE is defined by PMS.
+		"""
+		iuse_effective = []
+		iuse_effective.extend(self.get("IUSE_IMPLICIT", "").split())
+
+		# USE_EXPAND_IMPLICIT should contain things like ARCH, ELIBC,
+		# KERNEL, and USERLAND.
+		use_expand_implicit = frozenset(
+			self.get("USE_EXPAND_IMPLICIT", "").split())
+
+		# USE_EXPAND_UNPREFIXED should contain at least ARCH, and
+		# USE_EXPAND_VALUES_ARCH should contain all valid ARCH flags.
+		for v in self.get("USE_EXPAND_UNPREFIXED", "").split():
+			if v not in use_expand_implicit:
+				continue
+			iuse_effective.extend(
+				self.get("USE_EXPAND_VALUES_" + v, "").split())
+
+		use_expand = frozenset(self.get("USE_EXPAND", "").split())
+		for v in use_expand_implicit:
+			if v not in use_expand:
+				continue
+			lower_v = v.lower()
+			for x in self.get("USE_EXPAND_VALUES_" + v, "").split():
+				iuse_effective.append(lower_v + "_" + x)
+
+		return frozenset(iuse_effective)
+
 	def _get_implicit_iuse(self):
 		"""
-		Some flags are considered to
+		Prior to EAPI 5, these flags are considered to
 		be implicit members of IUSE:
 		  * Flags derived from ARCH
 		  * Flags derived from USE_EXPAND_HIDDEN variables
@@ -1549,11 +1788,11 @@ class config(object):
 
 		return iuse_implicit
 
-	def _getUseMask(self, pkg):
-		return self._use_manager.getUseMask(pkg)
+	def _getUseMask(self, pkg, stable=None):
+		return self._use_manager.getUseMask(pkg, stable=stable)
 
-	def _getUseForce(self, pkg):
-		return self._use_manager.getUseForce(pkg)
+	def _getUseForce(self, pkg, stable=None):
+		return self._use_manager.getUseForce(pkg, stable=stable)
 
 	def _getMaskAtom(self, cpv, metadata):
 		"""
@@ -1618,6 +1857,11 @@ class config(object):
 				return x
 		return None
 
+	def _isStable(self, pkg):
+		return self._keywords_manager.isStable(pkg,
+			self.get("ACCEPT_KEYWORDS", ""),
+			self.configdict["backupenv"].get("ACCEPT_KEYWORDS", ""))
+
 	def _getKeywords(self, cpv, metadata):
 		return self._keywords_manager.getKeywords(cpv, metadata["SLOT"], \
 			metadata.get("KEYWORDS", ""), metadata.get("repository"))
@@ -1706,9 +1950,10 @@ class config(object):
 		@return: A list of properties that have not been accepted.
 		"""
 		accept_properties = self._accept_properties
-		if not hasattr(cpv, 'slot'):
-			cpv = _pkg_str(cpv, slot=metadata["SLOT"],
-				repo=metadata.get("repository"))
+		try:
+			cpv.slot
+		except AttributeError:
+			cpv = _pkg_str(cpv, metadata=metadata, settings=self)
 		cp = cpv_getkey(cpv)
 		cpdict = self._ppropertiesdict.get(cp)
 		if cpdict:
@@ -1720,7 +1965,6 @@ class config(object):
 
 		properties_str = metadata.get("PROPERTIES", "")
 		properties = set(use_reduce(properties_str, matchall=1, flat=True))
-		properties.discard('||')
 
 		acceptable_properties = set()
 		for x in accept_properties:
@@ -1738,40 +1982,58 @@ class config(object):
 		else:
 			use = []
 
-		properties_struct = use_reduce(properties_str, uselist=use, opconvert=True)
-		return self._getMaskedProperties(properties_struct, acceptable_properties)
-
-	def _getMaskedProperties(self, properties_struct, acceptable_properties):
-		if not properties_struct:
-			return []
-		if properties_struct[0] == "||":
-			ret = []
-			for element in properties_struct[1:]:
-				if isinstance(element, list):
-					if element:
-						tmp = self._getMaskedProperties(
-							element, acceptable_properties)
-						if not tmp:
-							return []
-						ret.extend(tmp)
-				else:
-					if element in acceptable_properties:
-						return[]
-					ret.append(element)
-			# Return all masked properties, since we don't know which combination
-			# (if any) the user will decide to unmask
-			return ret
-
-		ret = []
-		for element in properties_struct:
-			if isinstance(element, list):
-				if element:
-					ret.extend(self._getMaskedProperties(element,
-						acceptable_properties))
+		return [x for x in use_reduce(properties_str, uselist=use, flat=True)
+			if x not in acceptable_properties]
+
+	def _getMissingRestrict(self, cpv, metadata):
+		"""
+		Take a RESTRICT string and return a list of any tokens the user
+		may need to accept for the given package.  The returned list will not
+		contain any tokens that have already been accepted.  This method
+		can throw an InvalidDependString exception.
+
+		@param cpv: The package name (for package.accept_restrict support)
+		@type cpv: String
+		@param metadata: A dictionary of raw package metadata
+		@type metadata: dict
+		@rtype: List
+		@return: A list of tokens that have not been accepted.
+		"""
+		accept_restrict = self._accept_restrict
+		try:
+			cpv.slot
+		except AttributeError:
+			cpv = _pkg_str(cpv, metadata=metadata, settings=self)
+		cp = cpv_getkey(cpv)
+		cpdict = self._paccept_restrict.get(cp)
+		if cpdict:
+			paccept_restrict_list = ordered_by_atom_specificity(cpdict, cpv)
+			if paccept_restrict_list:
+				accept_restrict = list(self._accept_restrict)
+				for x in paccept_restrict_list:
+					accept_restrict.extend(x)
+
+		restrict_str = metadata.get("RESTRICT", "")
+		all_restricts = set(use_reduce(restrict_str, matchall=1, flat=True))
+
+		acceptable_restricts = set()
+		for x in accept_restrict:
+			if x == '*':
+				acceptable_restricts.update(all_restricts)
+			elif x == '-*':
+				acceptable_restricts.clear()
+			elif x[:1] == '-':
+				acceptable_restricts.discard(x[1:])
 			else:
-				if element not in acceptable_properties:
-					ret.append(element)
-		return ret
+				acceptable_restricts.add(x)
+
+		if "?" in restrict_str:
+			use = metadata["USE"].split()
+		else:
+			use = []
+
+		return [x for x in use_reduce(restrict_str, uselist=use, flat=True)
+			if x not in acceptable_restricts]
 
 	def _accept_chost(self, cpv, metadata):
 		"""
@@ -1840,7 +2102,8 @@ class config(object):
 		"""Reload things like /etc/profile.env that can change during runtime."""
 		env_d_filename = os.path.join(self["EROOT"], "etc", "profile.env")
 		self.configdict["env.d"].clear()
-		env_d = getconfig(env_d_filename, expand=False)
+		env_d = getconfig(env_d_filename,
+			tolerant=self._tolerant, expand=False)
 		if env_d:
 			# env_d will be None if profile.env doesn't exist.
 			for k in self._env_d_blacklist:
@@ -1909,6 +2172,18 @@ class config(object):
 			# repoman will accept any property
 			self._accept_properties = ('*',)
 
+		if self.local_config:
+			mysplit = []
+			for curdb in mydbs:
+				mysplit.extend(curdb.get('ACCEPT_RESTRICT', '').split())
+			mysplit = prune_incremental(mysplit)
+			self.configlist[-1]['ACCEPT_RESTRICT'] = ' '.join(mysplit)
+			if tuple(mysplit) != self._accept_restrict:
+				self._accept_restrict = tuple(mysplit)
+		else:
+			# repoman will accept any property
+			self._accept_restrict = ('*',)
+
 		increment_lists = {}
 		for k in myincrementals:
 			incremental_list = []
@@ -1963,6 +2238,8 @@ class config(object):
 			if v is not None:
 				use_expand_dict[k] = v
 
+		use_expand_unprefixed = self.get("USE_EXPAND_UNPREFIXED", "").split()
+
 		# In order to best accomodate the long-standing practice of
 		# setting default USE_EXPAND variables in the profile's
 		# make.defaults, we translate these variables into their
@@ -1976,6 +2253,12 @@ class config(object):
 					continue
 				use = cfg.get("USE", "")
 				expand_use = []
+
+				for k in use_expand_unprefixed:
+					v = cfg.get(k)
+					if v is not None:
+						expand_use.extend(v.split())
+
 				for k in use_expand_dict:
 					v = cfg.get(k)
 					if v is None:
@@ -2013,6 +2296,17 @@ class config(object):
 			iuse = [x.lstrip("+-") for x in iuse.split()]
 		myflags = set()
 		for curdb in self.uvlist:
+
+			for k in use_expand_unprefixed:
+				v = curdb.get(k)
+				if v is None:
+					continue
+				for x in v.split():
+					if x[:1] == "-":
+						myflags.discard(x[1:])
+					else:
+						myflags.add(x)
+
 			cur_use_expand = [x for x in use_expand if x in curdb]
 			mysplit = curdb.get("USE", "").split()
 			if not mysplit and not cur_use_expand:
@@ -2129,6 +2423,14 @@ class config(object):
 				elif k in self:
 					self.configlist[-1][k] = ''
 
+			for k in use_expand_unprefixed:
+				var_split = self.get(k, '').split()
+				var_split = [ x for x in var_split if x in myflags ]
+				if var_split:
+					self.configlist[-1][k] = ' '.join(var_split)
+				elif k in self:
+					self.configlist[-1][k] = ''
+
 	@property
 	def virts_p(self):
 		warnings.warn("portage config.virts_p attribute " + \
@@ -2189,8 +2491,22 @@ class config(object):
 			elif mykey == "PORTAGE_PYM_PATH":
 				return portage._pym_path
 
+			elif mykey == "PORTAGE_PYTHONPATH":
+				value = [x for x in \
+					self.backupenv.get("PYTHONPATH", "").split(":") if x]
+				need_pym_path = True
+				if value:
+					try:
+						need_pym_path = not os.path.samefile(value[0],
+							portage._pym_path)
+					except OSError:
+						pass
+				if need_pym_path:
+					value.insert(0, portage._pym_path)
+				return ":".join(value)
+
 			elif mykey == "PORTAGE_GID":
-				return _unicode_decode(str(portage_gid))
+				return "%s" % portage_gid
 
 		for d in self.lookuplist:
 			try:
@@ -2277,6 +2593,7 @@ class config(object):
 		environ_filter = self._environ_filter
 
 		eapi = self.get('EAPI')
+		eapi_attrs = _get_eapi_attrs(eapi)
 		phase = self.get('EBUILD_PHASE')
 		filter_calling_env = False
 		if self.mycpv is not None and \
@@ -2358,14 +2675,20 @@ class config(object):
 			not eapi_exports_replace_vars(eapi):
 			mydict.pop("REPLACED_BY_VERSION", None)
 
+		if phase is not None and eapi_attrs.exports_EBUILD_PHASE_FUNC:
+			phase_func = _phase_func_map.get(phase)
+			if phase_func is not None:
+				mydict["EBUILD_PHASE_FUNC"] = phase_func
+
 		return mydict
 
 	def thirdpartymirrors(self):
 		if getattr(self, "_thirdpartymirrors", None) is None:
-			profileroots = [os.path.join(self["PORTDIR"], "profiles")]
-			for x in shlex_split(self.get("PORTDIR_OVERLAY", "")):
-				profileroots.insert(0, os.path.join(x, "profiles"))
-			thirdparty_lists = [grabdict(os.path.join(x, "thirdpartymirrors")) for x in profileroots]
+			thirdparty_lists = []
+			for repo_name in reversed(self.repositories.prepos_order):
+				thirdparty_lists.append(grabdict(os.path.join(
+					self.repositories[repo_name].location,
+					"profiles", "thirdpartymirrors")))
 			self._thirdpartymirrors = stack_dictlist(thirdparty_lists, incremental=True)
 		return self._thirdpartymirrors
 
diff --git a/portage_with_autodep/pym/portage/package/ebuild/config.pyo b/portage_with_autodep/pym/portage/package/ebuild/config.pyo
index 742ee2b..f4123ed 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/config.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/config.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.py b/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.py
index 3fab4da..fdb19b4 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.py
@@ -1,10 +1,11 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = ['deprecated_profile_check']
 
 import io
 
+import portage
 from portage import os, _encodings, _unicode_encode
 from portage.const import DEPRECATED_PROFILE_FILE
 from portage.localization import _
@@ -12,16 +13,32 @@ from portage.output import colorize
 from portage.util import writemsg
 
 def deprecated_profile_check(settings=None):
-	config_root = "/"
+	config_root = None
+	eprefix = None
+	deprecated_profile_file = None
 	if settings is not None:
 		config_root = settings["PORTAGE_CONFIGROOT"]
-	deprecated_profile_file = os.path.join(config_root,
-		DEPRECATED_PROFILE_FILE)
-	if not os.access(deprecated_profile_file, os.R_OK):
-		return False
-	dcontent = io.open(_unicode_encode(deprecated_profile_file,
+		eprefix = settings["EPREFIX"]
+		for x in reversed(settings.profiles):
+			deprecated_profile_file = os.path.join(x, "deprecated")
+			if os.access(deprecated_profile_file, os.R_OK):
+				break
+		else:
+			deprecated_profile_file = None
+
+	if deprecated_profile_file is None:
+		deprecated_profile_file = os.path.join(config_root or "/",
+			DEPRECATED_PROFILE_FILE)
+		if not os.access(deprecated_profile_file, os.R_OK):
+			deprecated_profile_file = os.path.join(config_root or "/",
+				'etc', 'make.profile', 'deprecated')
+			if not os.access(deprecated_profile_file, os.R_OK):
+				return
+
+	with io.open(_unicode_encode(deprecated_profile_file,
 		encoding=_encodings['fs'], errors='strict'), 
-		mode='r', encoding=_encodings['content'], errors='replace').readlines()
+		mode='r', encoding=_encodings['content'], errors='replace') as f:
+		dcontent = f.readlines()
 	writemsg(colorize("BAD", _("\n!!! Your current profile is "
 		"deprecated and not supported anymore.")) + "\n", noiselevel=-1)
 	writemsg(colorize("BAD", _("!!! Use eselect profile to update your "
@@ -30,13 +47,37 @@ def deprecated_profile_check(settings=None):
 		writemsg(colorize("BAD", _("!!! Please refer to the "
 			"Gentoo Upgrading Guide.")) + "\n", noiselevel=-1)
 		return True
-	newprofile = dcontent[0]
+	newprofile = dcontent[0].rstrip("\n")
 	writemsg(colorize("BAD", _("!!! Please upgrade to the "
-		"following profile if possible:")) + "\n", noiselevel=-1)
-	writemsg(8*" " + colorize("GOOD", newprofile) + "\n", noiselevel=-1)
+		"following profile if possible:")) + "\n\n", noiselevel=-1)
+	writemsg(8*" " + colorize("GOOD", newprofile) + "\n\n", noiselevel=-1)
 	if len(dcontent) > 1:
 		writemsg(_("To upgrade do the following steps:\n"), noiselevel=-1)
 		for myline in dcontent[1:]:
 			writemsg(myline, noiselevel=-1)
 		writemsg("\n\n", noiselevel=-1)
+	else:
+		writemsg(_("You may use the following command to upgrade:\n\n"), noiselevel=-1)
+		writemsg(8*" " + colorize("INFORM", 'eselect profile set ' +
+			newprofile) + "\n\n", noiselevel=-1)
+
+	if settings is not None:
+		main_repo_loc = settings.repositories.mainRepoLocation()
+		new_profile_path = os.path.join(main_repo_loc,
+			"profiles", newprofile.rstrip("\n"))
+
+		if os.path.isdir(new_profile_path):
+			new_config = portage.config(config_root=config_root,
+				config_profile_path=new_profile_path,
+				eprefix=eprefix)
+
+			if not new_config.profiles:
+				writemsg("\n %s %s\n" % (colorize("WARN", "*"),
+					_("You must update portage before you "
+					"can migrate to the above profile.")), noiselevel=-1)
+				writemsg(" %s %s\n\n" % (colorize("WARN", "*"),
+					_("In order to update portage, "
+					"run 'emerge --oneshot portage'.")),
+					noiselevel=-1)
+
 	return True
diff --git a/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.pyo b/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.pyo
index 2b9362b..df43aab 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/deprecated_profile_check.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/digestcheck.py b/portage_with_autodep/pym/portage/package/ebuild/digestcheck.py
index 8705639..e207ba8 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/digestcheck.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/digestcheck.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2012 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = ['digestcheck']
@@ -6,6 +6,7 @@ __all__ = ['digestcheck']
 import warnings
 
 from portage import os, _encodings, _unicode_decode
+from portage.checksum import _hash_filter
 from portage.exception import DigestException, FileNotFound
 from portage.localization import _
 from portage.output import EOutput
@@ -28,6 +29,9 @@ def digestcheck(myfiles, mysettings, strict=False, justmanifest=None, mf=None):
 	if mysettings.get("EBUILD_SKIP_MANIFEST") == "1":
 		return 1
 	pkgdir = mysettings["O"]
+	hash_filter = _hash_filter(mysettings.get("PORTAGE_CHECKSUM_FILTER", ""))
+	if hash_filter.transparent:
+		hash_filter = None
 	if mf is None:
 		mf = mysettings.repositories.get_repo_for_location(
 			os.path.dirname(os.path.dirname(pkgdir)))
@@ -38,15 +42,16 @@ def digestcheck(myfiles, mysettings, strict=False, justmanifest=None, mf=None):
 		if not mf.thin and strict and "PORTAGE_PARALLEL_FETCHONLY" not in mysettings:
 			if mf.fhashdict.get("EBUILD"):
 				eout.ebegin(_("checking ebuild checksums ;-)"))
-				mf.checkTypeHashes("EBUILD")
+				mf.checkTypeHashes("EBUILD", hash_filter=hash_filter)
 				eout.eend(0)
 			if mf.fhashdict.get("AUX"):
 				eout.ebegin(_("checking auxfile checksums ;-)"))
-				mf.checkTypeHashes("AUX")
+				mf.checkTypeHashes("AUX", hash_filter=hash_filter)
 				eout.eend(0)
 			if mf.fhashdict.get("MISC"):
 				eout.ebegin(_("checking miscfile checksums ;-)"))
-				mf.checkTypeHashes("MISC", ignoreMissingFiles=True)
+				mf.checkTypeHashes("MISC", ignoreMissingFiles=True,
+					hash_filter=hash_filter)
 				eout.eend(0)
 		for f in myfiles:
 			eout.ebegin(_("checking %s ;-)") % f)
@@ -58,7 +63,7 @@ def digestcheck(myfiles, mysettings, strict=False, justmanifest=None, mf=None):
 				writemsg(_("\n!!! Missing digest for '%s'\n") % (f,),
 					noiselevel=-1)
 				return 0
-			mf.checkFileHashes(ftype, f)
+			mf.checkFileHashes(ftype, f, hash_filter=hash_filter)
 			eout.eend(0)
 	except FileNotFound as e:
 		eout.eend(1)
diff --git a/portage_with_autodep/pym/portage/package/ebuild/digestcheck.pyo b/portage_with_autodep/pym/portage/package/ebuild/digestcheck.pyo
index 66987a2..c6a8d4e 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/digestcheck.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/digestcheck.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/digestgen.py b/portage_with_autodep/pym/portage/package/ebuild/digestgen.py
index 6ad3397..95d02db 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/digestgen.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/digestgen.py
@@ -112,67 +112,64 @@ def digestgen(myarchives=None, mysettings=None, myportdb=None):
 					missing_files.append(myfile)
 					continue
 
-		if missing_files:
-				for myfile in missing_files:
-					uris = set()
-					all_restrict = set()
-					for cpv in distfiles_map[myfile]:
-						uris.update(myportdb.getFetchMap(
-							cpv, mytree=mytree)[myfile])
-						restrict = myportdb.aux_get(cpv, ['RESTRICT'],
-							mytree=mytree)[0]
-						# Here we ignore conditional parts of RESTRICT since
-						# they don't apply unconditionally. Assume such
-						# conditionals only apply on the client side where
-						# digestgen() does not need to be called.
-						all_restrict.update(use_reduce(restrict,
-							flat=True, matchnone=True))
-
-						# fetch() uses CATEGORY and PF to display a message
-						# when fetch restriction is triggered.
-						cat, pf = catsplit(cpv)
-						mysettings["CATEGORY"] = cat
-						mysettings["PF"] = pf
-
-					# fetch() uses PORTAGE_RESTRICT to control fetch
-					# restriction, which is only applied to files that
-					# are not fetchable via a mirror:// URI.
-					mysettings["PORTAGE_RESTRICT"] = " ".join(all_restrict)
-
-					try:
-						st = os.stat(os.path.join(
-							mysettings["DISTDIR"],myfile))
-					except OSError:
-						st = None
-
-					if not fetch({myfile : uris}, mysettings):
-						myebuild = os.path.join(mysettings["O"],
-							catsplit(cpv)[1] + ".ebuild")
-						spawn_nofetch(myportdb, myebuild)
-						writemsg(_("!!! Fetch failed for %s, can't update "
-							"Manifest\n") % myfile, noiselevel=-1)
-						if myfile in dist_hashes and \
-							st is not None and st.st_size > 0:
-							# stat result is obtained before calling fetch(),
-							# since fetch may rename the existing file if the
-							# digest does not match.
-							writemsg(_("!!! If you would like to "
-								"forcefully replace the existing "
-								"Manifest entry\n!!! for %s, use "
-								"the following command:\n") % myfile + \
-								"!!!    " + colorize("INFORM",
-								"ebuild --force %s manifest" % \
-								os.path.basename(myebuild)) + "\n",
-								noiselevel=-1)
-						return 0
+		for myfile in missing_files:
+			uris = set()
+			all_restrict = set()
+			for cpv in distfiles_map[myfile]:
+				uris.update(myportdb.getFetchMap(
+					cpv, mytree=mytree)[myfile])
+				restrict = myportdb.aux_get(cpv, ['RESTRICT'], mytree=mytree)[0]
+				# Here we ignore conditional parts of RESTRICT since
+				# they don't apply unconditionally. Assume such
+				# conditionals only apply on the client side where
+				# digestgen() does not need to be called.
+				all_restrict.update(use_reduce(restrict,
+					flat=True, matchnone=True))
+
+				# fetch() uses CATEGORY and PF to display a message
+				# when fetch restriction is triggered.
+				cat, pf = catsplit(cpv)
+				mysettings["CATEGORY"] = cat
+				mysettings["PF"] = pf
+
+			# fetch() uses PORTAGE_RESTRICT to control fetch
+			# restriction, which is only applied to files that
+			# are not fetchable via a mirror:// URI.
+			mysettings["PORTAGE_RESTRICT"] = " ".join(all_restrict)
+
+			try:
+				st = os.stat(os.path.join(mysettings["DISTDIR"], myfile))
+			except OSError:
+				st = None
+
+			if not fetch({myfile : uris}, mysettings):
+				myebuild = os.path.join(mysettings["O"],
+					catsplit(cpv)[1] + ".ebuild")
+				spawn_nofetch(myportdb, myebuild)
+				writemsg(_("!!! Fetch failed for %s, can't update Manifest\n")
+					% myfile, noiselevel=-1)
+				if myfile in dist_hashes and \
+					st is not None and st.st_size > 0:
+					# stat result is obtained before calling fetch(),
+					# since fetch may rename the existing file if the
+					# digest does not match.
+					cmd = colorize("INFORM", "ebuild --force %s manifest" %
+						os.path.basename(myebuild))
+					writemsg((_(
+						"!!! If you would like to forcefully replace the existing Manifest entry\n"
+						"!!! for %s, use the following command:\n") % myfile) +
+						"!!!    %s\n" % cmd,
+						noiselevel=-1)
+				return 0
+
 		writemsg_stdout(_(">>> Creating Manifest for %s\n") % mysettings["O"])
 		try:
 			mf.create(assumeDistHashesSometimes=True,
 				assumeDistHashesAlways=(
 				"assume-digests" in mysettings.features))
 		except FileNotFound as e:
-			writemsg(_("!!! File %s doesn't exist, can't update "
-				"Manifest\n") % e, noiselevel=-1)
+			writemsg(_("!!! File %s doesn't exist, can't update Manifest\n")
+				% e, noiselevel=-1)
 			return 0
 		except PortagePackageException as e:
 			writemsg(("!!! %s\n") % (e,), noiselevel=-1)
diff --git a/portage_with_autodep/pym/portage/package/ebuild/digestgen.pyo b/portage_with_autodep/pym/portage/package/ebuild/digestgen.pyo
index 66876ec..a4e9b62 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/digestgen.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/digestgen.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/doebuild.py b/portage_with_autodep/pym/portage/package/ebuild/doebuild.py
index 610172f..5351c52 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/doebuild.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/doebuild.py
@@ -1,14 +1,19 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = ['doebuild', 'doebuild_environment', 'spawn', 'spawnebuild']
 
+import grp
 import gzip
 import errno
 import io
 from itertools import chain
 import logging
 import os as _os
+import platform
+import pwd
 import re
 import signal
 import stat
@@ -25,7 +30,13 @@ portage.proxy.lazyimport.lazyimport(globals(),
 	'portage.package.ebuild.digestcheck:digestcheck',
 	'portage.package.ebuild.digestgen:digestgen',
 	'portage.package.ebuild.fetch:fetch',
+	'portage.package.ebuild._ipc.QueryCommand:QueryCommand',
+	'portage.dep._slot_operator:evaluate_slot_operator_equal_deps',
 	'portage.package.ebuild._spawn_nofetch:spawn_nofetch',
+	'portage.util._desktop_entry:validate_desktop_entry',
+	'portage.util._async.SchedulerInterface:SchedulerInterface',
+	'portage.util._eventloop.EventLoop:EventLoop',
+	'portage.util._eventloop.global_event_loop:global_event_loop',
 	'portage.util.ExtractKernelVersion:ExtractKernelVersion'
 )
 
@@ -43,7 +54,7 @@ from portage.dep import Atom, check_required_use, \
 from portage.eapi import eapi_exports_KV, eapi_exports_merge_type, \
 	eapi_exports_replace_vars, eapi_exports_REPOSITORY, \
 	eapi_has_required_use, eapi_has_src_prepare_and_src_configure, \
-	eapi_has_pkg_pretend
+	eapi_has_pkg_pretend, _get_eapi_attrs
 from portage.elog import elog_process, _preload_elog_modules
 from portage.elog.messages import eerror, eqawarn
 from portage.exception import DigestException, FileNotFound, \
@@ -55,14 +66,13 @@ from portage.package.ebuild.prepare_build_dirs import prepare_build_dirs
 from portage.util import apply_recursive_permissions, \
 	apply_secpass_permissions, noiselimit, normalize_path, \
 	writemsg, writemsg_stdout, write_atomic
-from portage.util.lafilefixer import rewrite_lafile	
+from portage.util.lafilefixer import rewrite_lafile
 from portage.versions import _pkgsplit
 from _emerge.BinpkgEnvExtractor import BinpkgEnvExtractor
 from _emerge.EbuildBuildDir import EbuildBuildDir
 from _emerge.EbuildPhase import EbuildPhase
 from _emerge.EbuildSpawnProcess import EbuildSpawnProcess
 from _emerge.Package import Package
-from _emerge.PollScheduler import PollScheduler
 from _emerge.RootConfig import RootConfig
 
 _unsandboxed_phases = frozenset([
@@ -72,6 +82,40 @@ _unsandboxed_phases = frozenset([
 	"prerm", "setup"
 ])
 
+# phases in which IPC with host is allowed
+_ipc_phases = frozenset([
+	"setup", "pretend",
+	"preinst", "postinst", "prerm", "postrm",
+])
+
+# phases in which networking access is allowed
+_networked_phases = frozenset([
+	# for VCS fetching
+	"unpack",
+	# + for network-bound IPC
+] + list(_ipc_phases))
+
+_phase_func_map = {
+	"config": "pkg_config",
+	"setup": "pkg_setup",
+	"nofetch": "pkg_nofetch",
+	"unpack": "src_unpack",
+	"prepare": "src_prepare",
+	"configure": "src_configure",
+	"compile": "src_compile",
+	"test": "src_test",
+	"install": "src_install",
+	"preinst": "pkg_preinst",
+	"postinst": "pkg_postinst",
+	"prerm": "pkg_prerm",
+	"postrm": "pkg_postrm",
+	"info": "pkg_info",
+	"pretend": "pkg_pretend",
+}
+
+_vdb_use_conditional_keys = Package._dep_keys + \
+	('LICENSE', 'PROPERTIES', 'PROVIDE', 'RESTRICT',)
+
 def _doebuild_spawn(phase, settings, actionmap=None, **kwargs):
 	"""
 	All proper ebuild phases which execute ebuild.sh are spawned
@@ -81,8 +125,18 @@ def _doebuild_spawn(phase, settings, actionmap=None, **kwargs):
 	if phase in _unsandboxed_phases:
 		kwargs['free'] = True
 
+	kwargs['ipc'] = 'ipc-sandbox' not in settings.features or \
+		phase in _ipc_phases
+	kwargs['networked'] = 'network-sandbox' not in settings.features or \
+		phase in _networked_phases
+
 	if phase == 'depend':
 		kwargs['droppriv'] = 'userpriv' in settings.features
+		# It's not necessary to close_fds for this phase, since
+		# it should not spawn any daemons, and close_fds is
+		# best avoided since it can interact badly with some
+		# garbage collectors (see _setup_pipes docstring).
+		kwargs['close_fds'] = False
 
 	if actionmap is not None and phase in actionmap:
 		kwargs.update(actionmap[phase]["args"])
@@ -100,17 +154,24 @@ def _doebuild_spawn(phase, settings, actionmap=None, **kwargs):
 
 	settings['EBUILD_PHASE'] = phase
 	try:
-		return spawn(cmd, settings, **kwargs)
+		return spawn(cmd, settings, **portage._native_kwargs(kwargs))
 	finally:
 		settings.pop('EBUILD_PHASE', None)
 
-def _spawn_phase(phase, settings, actionmap=None, **kwargs):
-	if kwargs.get('returnpid'):
-		return _doebuild_spawn(phase, settings, actionmap=actionmap, **kwargs)
+def _spawn_phase(phase, settings, actionmap=None, returnpid=False,
+		logfile=None, **kwargs):
+
+	if returnpid:
+		return _doebuild_spawn(phase, settings, actionmap=actionmap,
+			returnpid=returnpid, logfile=logfile, **kwargs)
 
+	# The logfile argument is unused here, since EbuildPhase uses
+	# the PORTAGE_LOG_FILE variable if set.
 	ebuild_phase = EbuildPhase(actionmap=actionmap, background=False,
-		phase=phase, scheduler=PollScheduler().sched_iface,
-		settings=settings)
+		phase=phase, scheduler=SchedulerInterface(portage._internal_caller and
+			global_event_loop() or EventLoop(main=False)),
+		settings=settings, **kwargs)
+
 	ebuild_phase.start()
 	ebuild_phase.wait()
 	return ebuild_phase.returncode
@@ -123,19 +184,28 @@ def _doebuild_path(settings, eapi=None):
 	# Note: PORTAGE_BIN_PATH may differ from the global constant
 	# when portage is reinstalling itself.
 	portage_bin_path = settings["PORTAGE_BIN_PATH"]
-	eprefix = settings["EPREFIX"]
+	eprefix = portage.const.EPREFIX
 	prerootpath = [x for x in settings.get("PREROOTPATH", "").split(":") if x]
 	rootpath = [x for x in settings.get("ROOTPATH", "").split(":") if x]
+	overrides = [x for x in settings.get(
+		"__PORTAGE_TEST_PATH_OVERRIDE", "").split(":") if x]
 
 	prefixes = []
 	if eprefix:
 		prefixes.append(eprefix)
 	prefixes.append("/")
 
-	path = []
+	path = overrides
+
+	if "xattr" in settings.features:
+		path.append(os.path.join(portage_bin_path, "ebuild-helpers", "xattr"))
 
-	if eapi not in (None, "0", "1", "2", "3"):
-		path.append(os.path.join(portage_bin_path, "ebuild-helpers", "4"))
+	if eprefix and uid != 0 and "fakeroot" not in settings.features:
+		path.append(os.path.join(portage_bin_path,
+			"ebuild-helpers", "unprivileged"))
+
+	if settings.get("USERLAND", "GNU") != "GNU":
+		path.append(os.path.join(portage_bin_path, "ebuild-helpers", "bsd"))
 
 	path.append(os.path.join(portage_bin_path, "ebuild-helpers"))
 	path.extend(prerootpath)
@@ -254,10 +324,11 @@ def doebuild_environment(myebuild, mydo, myroot=None, settings=None,
 	if hasattr(mydbapi, 'repositories'):
 		repo = mydbapi.repositories.get_repo_for_location(mytree)
 		mysettings['PORTDIR'] = repo.eclass_db.porttrees[0]
-		mysettings['PORTDIR_OVERLAY'] = ' '.join(repo.eclass_db.porttrees[1:])
+		mysettings['PORTAGE_ECLASS_LOCATIONS'] = repo.eclass_db.eclass_locations_string
 		mysettings.configdict["pkg"]["PORTAGE_REPO_NAME"] = repo.name
 
 	mysettings["PORTDIR"] = os.path.realpath(mysettings["PORTDIR"])
+	mysettings.pop("PORTDIR_OVERLAY", None)
 	mysettings["DISTDIR"] = os.path.realpath(mysettings["DISTDIR"])
 	mysettings["RPMDIR"]  = os.path.realpath(mysettings["RPMDIR"])
 
@@ -414,14 +485,14 @@ _doebuild_commands_without_builddir = (
 	'fetch', 'fetchall', 'help', 'manifest'
 )
 
-def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
-	fetchonly=0, cleanup=0, dbkey=None, use_cache=1, fetchall=0, tree=None,
+def doebuild(myebuild, mydo, _unused=DeprecationWarning, settings=None, debug=0, listonly=0,
+	fetchonly=0, cleanup=0, dbkey=DeprecationWarning, use_cache=1, fetchall=0, tree=None,
 	mydbapi=None, vartree=None, prev_mtimes=None,
 	fd_pipes=None, returnpid=False):
 	"""
 	Wrapper function that invokes specific ebuild phases through the spawning
 	of ebuild.sh
-	
+
 	@param myebuild: name of the ebuild to invoke the phase on (CPV)
 	@type myebuild: String
 	@param mydo: Phase to run
@@ -464,13 +535,13 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 	@return:
 	1. 0 for success
 	2. 1 for error
-	
+
 	Most errors have an accompanying error message.
-	
+
 	listonly and fetchonly are only really necessary for operations involving 'fetch'
 	prev_mtimes are only necessary for merge operations.
 	Other variables may not be strictly required, many have defaults that are set inside of doebuild.
-	
+
 	"""
 
 	if settings is None:
@@ -478,17 +549,22 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 	mysettings = settings
 	myroot = settings['EROOT']
 
-	if _unused is not None and _unused != mysettings['EROOT']:
+	if _unused is not DeprecationWarning:
 		warnings.warn("The third parameter of the "
-			"portage.doebuild() is now unused. Use "
-			"settings['ROOT'] instead.",
+			"portage.doebuild() is deprecated. Instead "
+			"settings['EROOT'] is used.",
+			DeprecationWarning, stacklevel=2)
+
+	if dbkey is not DeprecationWarning:
+		warnings.warn("portage.doebuild() called "
+			"with deprecated dbkey argument.",
 			DeprecationWarning, stacklevel=2)
 
 	if not tree:
 		writemsg("Warning: tree not specified to doebuild\n")
 		tree = "porttree"
-	
-	# chunked out deps for each phase, so that ebuild binary can use it 
+
+	# chunked out deps for each phase, so that ebuild binary can use it
 	# to collapse targets down.
 	actionmap_deps={
 	"pretend"  : [],
@@ -503,7 +579,7 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 	"package":["install"],
 	"merge"  :["install"],
 	}
-	
+
 	if mydbapi is None:
 		mydbapi = portage.db[myroot][tree].dbapi
 
@@ -518,7 +594,7 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 	                "fetch", "fetchall", "digest",
 	                "unpack", "prepare", "configure", "compile", "test",
 	                "install", "rpm", "qmerge", "merge",
-	                "package","unmerge", "manifest"]
+	                "package", "unmerge", "manifest", "nofetch"]
 
 	if mydo not in validcommands:
 		validcommands.sort()
@@ -532,8 +608,11 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		return 1
 
 	if returnpid and mydo != 'depend':
-		warnings.warn("portage.doebuild() called " + \
-			"with returnpid parameter enabled. This usage will " + \
+		# This case is not supported, since it bypasses the EbuildPhase class
+		# which implements important functionality (including post phase hooks
+		# and IPC for things like best/has_version and die).
+		warnings.warn("portage.doebuild() called "
+			"with returnpid parameter enabled. This usage will "
 			"not be supported in the future.",
 			DeprecationWarning, stacklevel=2)
 
@@ -541,9 +620,6 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		fetchall = 1
 		mydo = "fetch"
 
-	parallel_fetchonly = mydo in ("fetch", "fetchall") and \
-		"PORTAGE_PARALLEL_FETCHONLY" in mysettings
-
 	if mydo not in clean_phases and not os.path.exists(myebuild):
 		writemsg("!!! doebuild: %s not found for %s\n" % (myebuild, mydo),
 			noiselevel=-1)
@@ -650,7 +726,7 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		# we can temporarily override PORTAGE_TMPDIR with a random temp dir
 		# so that there's no need for locking and it can be used even if the
 		# user isn't in the portage group.
-		if mydo in ("info",):
+		if not returnpid and mydo in ("info",):
 			tmpdir = tempfile.mkdtemp()
 			tmpdir_orig = mysettings["PORTAGE_TMPDIR"]
 			mysettings["PORTAGE_TMPDIR"] = tmpdir
@@ -661,9 +737,10 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		if mydo in clean_phases:
 			builddir_lock = None
 			if not returnpid and \
-				'PORTAGE_BUILDIR_LOCKED' not in mysettings:
+				'PORTAGE_BUILDDIR_LOCKED' not in mysettings:
 				builddir_lock = EbuildBuildDir(
-					scheduler=PollScheduler().sched_iface,
+					scheduler=(portage._internal_caller and
+						global_event_loop() or EventLoop(main=False)),
 					settings=mysettings)
 				builddir_lock.lock()
 			try:
@@ -679,42 +756,7 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			if returnpid:
 				return _spawn_phase(mydo, mysettings,
 					fd_pipes=fd_pipes, returnpid=returnpid)
-			elif isinstance(dbkey, dict):
-				warnings.warn("portage.doebuild() called " + \
-					"with dict dbkey argument. This usage will " + \
-					"not be supported in the future.",
-					DeprecationWarning, stacklevel=2)
-				mysettings["dbkey"] = ""
-				pr, pw = os.pipe()
-				fd_pipes = {
-					0:sys.stdin.fileno(),
-					1:sys.stdout.fileno(),
-					2:sys.stderr.fileno(),
-					9:pw}
-				mypids = _spawn_phase(mydo, mysettings, returnpid=True,
-					fd_pipes=fd_pipes)
-				os.close(pw) # belongs exclusively to the child process now
-				f = os.fdopen(pr, 'rb', 0)
-				for k, v in zip(auxdbkeys,
-					(_unicode_decode(line).rstrip('\n') for line in f)):
-					dbkey[k] = v
-				f.close()
-				retval = os.waitpid(mypids[0], 0)[1]
-				portage.process.spawned_pids.remove(mypids[0])
-				# If it got a signal, return the signal that was sent, but
-				# shift in order to distinguish it from a return value. (just
-				# like portage.process.spawn() would do).
-				if retval & 0xff:
-					retval = (retval & 0xff) << 8
-				else:
-					# Otherwise, return its exit code.
-					retval = retval >> 8
-				if retval == os.EX_OK and len(dbkey) != len(auxdbkeys):
-					# Don't trust bash's returncode if the
-					# number of lines is incorrect.
-					retval = 1
-				return retval
-			elif dbkey:
+			elif dbkey and dbkey is not DeprecationWarning:
 				mysettings["dbkey"] = dbkey
 			else:
 				mysettings["dbkey"] = \
@@ -723,14 +765,25 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			return _spawn_phase(mydo, mysettings,
 				fd_pipes=fd_pipes, returnpid=returnpid)
 
-		# Validate dependency metadata here to ensure that ebuilds with invalid
-		# data are never installed via the ebuild command. Don't bother when
-		# returnpid == True since there's no need to do this every time emerge
-		# executes a phase.
+		elif mydo == "nofetch":
+
+			if returnpid:
+				writemsg("!!! doebuild: %s\n" %
+					_("returnpid is not supported for phase '%s'\n" % mydo),
+					noiselevel=-1)
+
+			return spawn_nofetch(mydbapi, myebuild, settings=mysettings,
+				fd_pipes=fd_pipes)
+
 		if tree == "porttree":
-			rval = _validate_deps(mysettings, myroot, mydo, mydbapi)
-			if rval != os.EX_OK:
-				return rval
+
+			if not returnpid:
+				# Validate dependency metadata here to ensure that ebuilds with
+				# invalid data are never installed via the ebuild command. Skip
+				# this when returnpid is True (assume the caller handled it).
+				rval = _validate_deps(mysettings, myroot, mydo, mydbapi)
+				if rval != os.EX_OK:
+					return rval
 
 		else:
 			# FEATURES=noauto only makes sense for porttree, and we don't want
@@ -739,20 +792,25 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			if "noauto" in mysettings.features:
 				mysettings.features.discard("noauto")
 
-		# The info phase is special because it uses mkdtemp so and
-		# user (not necessarily in the portage group) can run it.
-		if mydo not in ('info',) and \
+		# If we are not using a private temp dir, then check access
+		# to the global temp dir.
+		if tmpdir is None and \
 			mydo not in _doebuild_commands_without_builddir:
 			rval = _check_temp_dir(mysettings)
 			if rval != os.EX_OK:
 				return rval
 
 		if mydo == "unmerge":
+			if returnpid:
+				writemsg("!!! doebuild: %s\n" %
+					_("returnpid is not supported for phase '%s'\n" % mydo),
+					noiselevel=-1)
 			return unmerge(mysettings["CATEGORY"],
 				mysettings["PF"], myroot, mysettings, vartree=vartree)
 
 		phases_to_run = set()
-		if "noauto" in mysettings.features or \
+		if returnpid or \
+			"noauto" in mysettings.features or \
 			mydo not in actionmap_deps:
 			phases_to_run.add(mydo)
 		else:
@@ -803,9 +861,10 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 
 				if newstuff:
 					if builddir_lock is None and \
-						'PORTAGE_BUILDIR_LOCKED' not in mysettings:
+						'PORTAGE_BUILDDIR_LOCKED' not in mysettings:
 						builddir_lock = EbuildBuildDir(
-							scheduler=PollScheduler().sched_iface,
+							scheduler=(portage._internal_caller and
+								global_event_loop() or EventLoop(main=False)),
 							settings=mysettings)
 						builddir_lock.lock()
 					try:
@@ -823,12 +882,12 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		# in order to satisfy the sane $PWD requirement (from bug #239560)
 		# when pkg_nofetch is spawned.
 		have_build_dirs = False
-		if not parallel_fetchonly and \
-			mydo not in ('digest', 'fetch', 'help', 'manifest'):
+		if mydo not in ('digest', 'fetch', 'help', 'manifest'):
 			if not returnpid and \
-				'PORTAGE_BUILDIR_LOCKED' not in mysettings:
+				'PORTAGE_BUILDDIR_LOCKED' not in mysettings:
 				builddir_lock = EbuildBuildDir(
-					scheduler=PollScheduler().sched_iface,
+					scheduler=(portage._internal_caller and
+						global_event_loop() or EventLoop(main=False)),
 					settings=mysettings)
 				builddir_lock.lock()
 			mystatus = prepare_build_dirs(myroot, mysettings, cleanup)
@@ -871,9 +930,8 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			else:
 				vardb = vartree.dbapi
 				cpv = mysettings.mycpv
-				cp = portage.versions.cpv_getkey(cpv)
-				slot = mysettings["SLOT"]
-				cpv_slot = cp + ":" + slot
+				cpv_slot = "%s%s%s" % \
+					(cpv.cp, portage.dep._slot_separator, cpv.slot)
 				mysettings["REPLACING_VERSIONS"] = " ".join(
 					set(portage.versions.cpv_getversion(match) \
 						for match in vardb.match(cpv_slot) + \
@@ -883,8 +941,16 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 		# the sandbox -- and stop now.
 		if mydo in ("config", "help", "info", "postinst",
 			"preinst", "pretend", "postrm", "prerm"):
-			return _spawn_phase(mydo, mysettings,
-				fd_pipes=fd_pipes, logfile=logfile, returnpid=returnpid)
+			if mydo in ("preinst", "postinst"):
+				env_file = os.path.join(os.path.dirname(mysettings["EBUILD"]),
+					"environment.bz2")
+				if os.path.isfile(env_file):
+					mysettings["PORTAGE_UPDATE_ENV"] = env_file
+			try:
+				return _spawn_phase(mydo, mysettings,
+					fd_pipes=fd_pipes, logfile=logfile, returnpid=returnpid)
+			finally:
+				mysettings.pop("PORTAGE_UPDATE_ENV", None)
 
 		mycpv = "/".join((mysettings["CATEGORY"], mysettings["PF"]))
 
@@ -925,7 +991,8 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			if not fetch(fetchme, mysettings, listonly=listonly,
 				fetchonly=fetchonly, allow_missing_digests=True,
 				digests=dist_digests):
-				spawn_nofetch(mydbapi, myebuild, settings=mysettings)
+				spawn_nofetch(mydbapi, myebuild, settings=mysettings,
+					fd_pipes=fd_pipes)
 				if listonly:
 					# The convention for listonly mode is to report
 					# success in any case, even though fetch() may
@@ -957,11 +1024,7 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 				mf = None
 				_doebuild_manifest_cache = None
 				return not digestgen(mysettings=mysettings, myportdb=mydbapi)
-			elif mydo != 'fetch' and \
-				"digest" in mysettings.features:
-				# Don't do this when called by emerge or when called just
-				# for fetch (especially parallel-fetch) since it's not needed
-				# and it can interfere with parallel tasks.
+			elif "digest" in mysettings.features:
 				mf = None
 				_doebuild_manifest_cache = None
 				digestgen(mysettings=mysettings, myportdb=mydbapi)
@@ -970,14 +1033,17 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			if mydo in ("digest", "manifest"):
 				return 1
 
+		if mydo == "fetch":
+			# Return after digestgen for FEATURES=digest support.
+			# Return before digestcheck, since fetch() already
+			# checked any relevant digests.
+			return 0
+
 		# See above comment about fetching only when needed
 		if tree == 'porttree' and \
 			not digestcheck(checkme, mysettings, "strict" in features, mf=mf):
 			return 1
 
-		if mydo == "fetch":
-			return 0
-
 		# remove PORTAGE_ACTUAL_DISTDIR once cvs/svn is supported via SRC_URI
 		if tree == 'porttree' and \
 			((mydo != "setup" and "noauto" not in features) \
@@ -993,7 +1059,9 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 			if len(actionmap_deps.get(x, [])):
 				actionmap[x]["dep"] = ' '.join(actionmap_deps[x])
 
-		if mydo in actionmap:
+		regular_actionmap_phase = mydo in actionmap
+
+		if regular_actionmap_phase:
 			bintree = None
 			if mydo == "package":
 				# Make sure the package directory exists before executing
@@ -1017,6 +1085,9 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 				actionmap, mysettings, debug, logfile=logfile,
 				fd_pipes=fd_pipes, returnpid=returnpid)
 
+			if returnpid and isinstance(retval, list):
+				return retval
+
 			if retval == os.EX_OK:
 				if mydo == "package" and bintree is not None:
 					bintree.inject(mysettings.mycpv,
@@ -1028,7 +1099,15 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 					except OSError:
 						pass
 
-		elif mydo=="qmerge":
+		elif returnpid:
+			writemsg("!!! doebuild: %s\n" %
+				_("returnpid is not supported for phase '%s'\n" % mydo),
+				noiselevel=-1)
+
+		if regular_actionmap_phase:
+			# handled above
+			pass
+		elif mydo == "qmerge":
 			# check to ensure install was run.  this *only* pops up when users
 			# forget it and are using ebuild
 			if not os.path.exists(
@@ -1045,7 +1124,8 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 				mysettings["CATEGORY"], mysettings["PF"], mysettings["D"],
 				os.path.join(mysettings["PORTAGE_BUILDDIR"], "build-info"),
 				myroot, mysettings, myebuild=mysettings["EBUILD"], mytree=tree,
-				mydbapi=mydbapi, vartree=vartree, prev_mtimes=prev_mtimes)
+				mydbapi=mydbapi, vartree=vartree, prev_mtimes=prev_mtimes,
+				fd_pipes=fd_pipes)
 		elif mydo=="merge":
 			retval = spawnebuild("install", actionmap, mysettings, debug,
 				alwaysdep=1, logfile=logfile, fd_pipes=fd_pipes,
@@ -1061,7 +1141,9 @@ def doebuild(myebuild, mydo, _unused=None, settings=None, debug=0, listonly=0,
 					mysettings["D"], os.path.join(mysettings["PORTAGE_BUILDDIR"],
 					"build-info"), myroot, mysettings,
 					myebuild=mysettings["EBUILD"], mytree=tree, mydbapi=mydbapi,
-					vartree=vartree, prev_mtimes=prev_mtimes)
+					vartree=vartree, prev_mtimes=prev_mtimes,
+					fd_pipes=fd_pipes)
+
 		else:
 			writemsg_stdout(_("!!! Unknown mydo: %s\n") % mydo, noiselevel=-1)
 			return 1
@@ -1161,7 +1243,9 @@ def _prepare_env_file(settings):
 	"""
 
 	env_extractor = BinpkgEnvExtractor(background=False,
-		scheduler=PollScheduler().sched_iface, settings=settings)
+		scheduler=(portage._internal_caller and
+			global_event_loop() or EventLoop(main=False)),
+		settings=settings)
 
 	if env_extractor.dest_env_exists():
 		# There are lots of possible states when doebuild()
@@ -1243,7 +1327,7 @@ def _spawn_actionmap(settings):
 	misc_sh_binary = os.path.join(portage_bin_path,
 		os.path.basename(MISC_SH_BINARY))
 	ebuild_sh = _shell_quote(ebuild_sh_binary) + " %s"
-	misc_sh = _shell_quote(misc_sh_binary) + " dyn_%s"
+	misc_sh = _shell_quote(misc_sh_binary) + " __dyn_%s"
 
 	# args are for the to spawn function
 	actionmap = {
@@ -1299,10 +1383,10 @@ def _validate_deps(mysettings, myroot, mydo, mydbapi):
 
 	if not pkg.built and \
 		mydo not in ("digest", "help", "manifest") and \
-		pkg.metadata["REQUIRED_USE"] and \
-		eapi_has_required_use(pkg.metadata["EAPI"]):
-		result = check_required_use(pkg.metadata["REQUIRED_USE"],
-			pkg.use.enabled, pkg.iuse.is_valid_flag)
+		pkg._metadata["REQUIRED_USE"] and \
+		eapi_has_required_use(pkg.eapi):
+		result = check_required_use(pkg._metadata["REQUIRED_USE"],
+			pkg.use.enabled, pkg.iuse.is_valid_flag, eapi=pkg.eapi)
 		if not result:
 			reduced_noise = result.tounicode()
 			writemsg("\n  %s\n" % _("The following REQUIRED_USE flag" + \
@@ -1310,7 +1394,7 @@ def _validate_deps(mysettings, myroot, mydo, mydbapi):
 			writemsg("    %s\n" % reduced_noise,
 				noiselevel=-1)
 			normalized_required_use = \
-				" ".join(pkg.metadata["REQUIRED_USE"].split())
+				" ".join(pkg._metadata["REQUIRED_USE"].split())
 			if reduced_noise != normalized_required_use:
 				writemsg("\n  %s\n" % _("The above constraints " + \
 					"are a subset of the following complete expression:"),
@@ -1325,7 +1409,8 @@ def _validate_deps(mysettings, myroot, mydo, mydbapi):
 
 # XXX This would be to replace getstatusoutput completely.
 # XXX Issue: cannot block execution. Deadlock condition.
-def spawn(mystring, mysettings, debug=0, free=0, droppriv=0, sesandbox=0, fakeroot=0, **keywords):
+def spawn(mystring, mysettings, debug=False, free=False, droppriv=False,
+	sesandbox=False, fakeroot=False, networked=True, ipc=True, **keywords):
 	"""
 	Spawn a subprocess with extra portage-specific options.
 	Optiosn include:
@@ -1355,6 +1440,10 @@ def spawn(mystring, mysettings, debug=0, free=0, droppriv=0, sesandbox=0, fakero
 	@type sesandbox: Boolean
 	@param fakeroot: Run this command with faked root privileges
 	@type fakeroot: Boolean
+	@param networked: Run this command with networking access enabled
+	@type networked: Boolean
+	@param ipc: Run this command with host IPC access enabled
+	@type ipc: Boolean
 	@param keywords: Extra options encoded as a dict, to be passed to spawn
 	@type keywords: Dictionary
 	@rtype: Integer
@@ -1367,29 +1456,90 @@ def spawn(mystring, mysettings, debug=0, free=0, droppriv=0, sesandbox=0, fakero
 	fd_pipes = keywords.get("fd_pipes")
 	if fd_pipes is None:
 		fd_pipes = {
-			0:sys.stdin.fileno(),
-			1:sys.stdout.fileno(),
-			2:sys.stderr.fileno(),
+			0:portage._get_stdin().fileno(),
+			1:sys.__stdout__.fileno(),
+			2:sys.__stderr__.fileno(),
 		}
 	# In some cases the above print statements don't flush stdout, so
 	# it needs to be flushed before allowing a child process to use it
 	# so that output always shows in the correct order.
-	stdout_filenos = (sys.stdout.fileno(), sys.stderr.fileno())
+	stdout_filenos = (sys.__stdout__.fileno(), sys.__stderr__.fileno())
 	for fd in fd_pipes.values():
 		if fd in stdout_filenos:
-			sys.stdout.flush()
-			sys.stderr.flush()
+			sys.__stdout__.flush()
+			sys.__stderr__.flush()
 			break
 
 	features = mysettings.features
+
+	# Use Linux namespaces if available
+	if uid == 0 and platform.system() == 'Linux':
+		keywords['unshare_net'] = not networked
+		keywords['unshare_ipc'] = not ipc
+
 	# TODO: Enable fakeroot to be used together with droppriv.  The
 	# fake ownership/permissions will have to be converted to real
 	# permissions in the merge phase.
 	fakeroot = fakeroot and uid != 0 and portage.process.fakeroot_capable
-	if droppriv and uid == 0 and portage_gid and portage_uid and \
-		hasattr(os, "setgroups"):
-		keywords.update({"uid":portage_uid,"gid":portage_gid,
-			"groups":userpriv_groups,"umask":0o02})
+	portage_build_uid = os.getuid()
+	portage_build_gid = os.getgid()
+	if uid == 0 and portage_uid and portage_gid and hasattr(os, "setgroups"):
+		if droppriv:
+			keywords.update({
+				"uid": portage_uid,
+				"gid": portage_gid,
+				"groups": userpriv_groups,
+				"umask": 0o02
+			})
+
+			# Adjust pty ownership so that subprocesses
+			# can directly access /dev/fd/{1,2}.
+			stdout_fd = fd_pipes.get(1)
+			if stdout_fd is not None:
+				try:
+					subprocess_tty = _os.ttyname(stdout_fd)
+				except OSError:
+					pass
+				else:
+					try:
+						parent_tty = _os.ttyname(sys.__stdout__.fileno())
+					except OSError:
+						parent_tty = None
+
+					if subprocess_tty != parent_tty:
+						_os.chown(subprocess_tty,
+							int(portage_uid), int(portage_gid))
+
+		if "userpriv" in features and "userpriv" not in mysettings["PORTAGE_RESTRICT"].split() and secpass >= 2:
+			# Since Python 3.4, getpwuid and getgrgid
+			# require int type (no proxies).
+			portage_build_uid = int(portage_uid)
+			portage_build_gid = int(portage_gid)
+
+	if "PORTAGE_BUILD_USER" not in mysettings:
+		user = None
+		try:
+			user = pwd.getpwuid(portage_build_uid).pw_name
+		except KeyError:
+			if portage_build_uid == 0:
+				user = "root"
+			elif portage_build_uid == portage_uid:
+				user = portage.data._portage_username
+		if user is not None:
+			mysettings["PORTAGE_BUILD_USER"] = user
+
+	if "PORTAGE_BUILD_GROUP" not in mysettings:
+		group = None
+		try:
+			group = grp.getgrgid(portage_build_gid).gr_name
+		except KeyError:
+			if portage_build_gid == 0:
+				group = "root"
+			elif portage_build_gid == portage_gid:
+				group = portage.data._portage_grpname
+		if group is not None:
+			mysettings["PORTAGE_BUILD_GROUP"] = group
+
 	if not free:
 		free=((droppriv and "usersandbox" not in features) or \
 			(not droppriv and "sandbox" not in features and \
@@ -1423,12 +1573,15 @@ def spawn(mystring, mysettings, debug=0, free=0, droppriv=0, sesandbox=0, fakero
 			mysettings["PORTAGE_SANDBOX_T"])
 
 	if keywords.get("returnpid"):
-		return spawn_func(mystring, env=mysettings.environ(), **keywords)
+		return spawn_func(mystring, env=mysettings.environ(),
+			**portage._native_kwargs(keywords))
 
 	proc = EbuildSpawnProcess(
 		background=False, args=mystring,
-		scheduler=PollScheduler().sched_iface, spawn_func=spawn_func,
-		settings=mysettings, **keywords)
+		scheduler=SchedulerInterface(portage._internal_caller and
+			global_event_loop() or EventLoop(main=False)),
+		spawn_func=spawn_func,
+		settings=mysettings, **portage._native_kwargs(keywords))
 
 	proc.start()
 	proc.wait()
@@ -1440,8 +1593,8 @@ def spawnebuild(mydo, actionmap, mysettings, debug, alwaysdep=0,
 	logfile=None, fd_pipes=None, returnpid=False):
 
 	if returnpid:
-		warnings.warn("portage.spawnebuild() called " + \
-			"with returnpid parameter enabled. This usage will " + \
+		warnings.warn("portage.spawnebuild() called "
+			"with returnpid parameter enabled. This usage will "
 			"not be supported in the future.",
 			DeprecationWarning, stacklevel=2)
 
@@ -1534,7 +1687,52 @@ def _check_build_log(mysettings, out=None):
 
 	configure_opts_warn = []
 	configure_opts_warn_re = re.compile(
-		r'^configure: WARNING: [Uu]nrecognized options: ')
+		r'^configure: WARNING: [Uu]nrecognized options: (.*)')
+
+	qa_configure_opts = ""
+	try:
+		with io.open(_unicode_encode(os.path.join(
+			mysettings["PORTAGE_BUILDDIR"],
+			"build-info", "QA_CONFIGURE_OPTIONS"),
+			encoding=_encodings['fs'], errors='strict'),
+			mode='r', encoding=_encodings['repo.content'],
+			errors='replace') as qa_configure_opts_f:
+			qa_configure_opts = qa_configure_opts_f.read()
+	except IOError as e:
+		if e.errno not in (errno.ENOENT, errno.ESTALE):
+			raise
+
+	qa_configure_opts = qa_configure_opts.split()
+	if qa_configure_opts:
+		if len(qa_configure_opts) > 1:
+			qa_configure_opts = "|".join("(%s)" % x for x in qa_configure_opts)
+			qa_configure_opts = "^(%s)$" % qa_configure_opts
+		else:
+			qa_configure_opts = "^%s$" % qa_configure_opts[0]
+		qa_configure_opts = re.compile(qa_configure_opts)
+
+	qa_am_maintainer_mode = []
+	try:
+		with io.open(_unicode_encode(os.path.join(
+			mysettings["PORTAGE_BUILDDIR"],
+			"build-info", "QA_AM_MAINTAINER_MODE"),
+			encoding=_encodings['fs'], errors='strict'),
+			mode='r', encoding=_encodings['repo.content'],
+			errors='replace') as qa_am_maintainer_mode_f:
+			qa_am_maintainer_mode = [x for x in
+				qa_am_maintainer_mode_f.read().splitlines() if x]
+	except IOError as e:
+		if e.errno not in (errno.ENOENT, errno.ESTALE):
+			raise
+
+	if qa_am_maintainer_mode:
+		if len(qa_am_maintainer_mode) > 1:
+			qa_am_maintainer_mode = \
+				"|".join("(%s)" % x for x in qa_am_maintainer_mode)
+			qa_am_maintainer_mode = "^(%s)$" % qa_am_maintainer_mode
+		else:
+			qa_am_maintainer_mode = "^%s$" % qa_am_maintainer_mode[0]
+		qa_am_maintainer_mode = re.compile(qa_am_maintainer_mode)
 
 	# Exclude output from dev-libs/yaz-3.0.47 which looks like this:
 	#
@@ -1556,7 +1754,9 @@ def _check_build_log(mysettings, out=None):
 		for line in f:
 			line = _unicode_decode(line)
 			if am_maintainer_mode_re.search(line) is not None and \
-				am_maintainer_mode_exclude_re.search(line) is None:
+				am_maintainer_mode_exclude_re.search(line) is None and \
+				(not qa_am_maintainer_mode or
+					qa_am_maintainer_mode.search(line) is None):
 				am_maintainer_mode.append(line.rstrip("\n"))
 
 			if bash_command_not_found_re.match(line) is not None and \
@@ -1566,8 +1766,11 @@ def _check_build_log(mysettings, out=None):
 			if helper_missing_file_re.match(line) is not None:
 				helper_missing_file.append(line.rstrip("\n"))
 
-			if configure_opts_warn_re.match(line) is not None:
-				configure_opts_warn.append(line.rstrip("\n"))
+			m = configure_opts_warn_re.match(line)
+			if m is not None:
+				for x in m.group(1).split(", "):
+					if not qa_configure_opts or qa_configure_opts.match(x) is None:
+						configure_opts_warn.append(x)
 
 			if make_jobserver_re.match(line) is not None:
 				make_jobserver.append(line.rstrip("\n"))
@@ -1616,7 +1819,7 @@ def _check_build_log(mysettings, out=None):
 	if configure_opts_warn:
 		msg = [_("QA Notice: Unrecognized configure options:")]
 		msg.append("")
-		msg.extend("\t" + line for line in configure_opts_warn)
+		msg.extend("\t%s" % x for x in configure_opts_warn)
 		_eqawarn(msg)
 
 	if make_jobserver:
@@ -1629,7 +1832,7 @@ def _check_build_log(mysettings, out=None):
 	if f_real is not None:
 		f_real.close()
 
-def _post_src_install_chost_fix(settings):
+def _post_src_install_write_metadata(settings):
 	"""
 	It's possible that the ebuild has changed the
 	CHOST variable, so revert it to the initial
@@ -1637,10 +1840,16 @@ def _post_src_install_chost_fix(settings):
 	due to local environment settings like in bug #386829.
 	"""
 
+	eapi_attrs = _get_eapi_attrs(settings.configdict['pkg']['EAPI'])
+
 	build_info_dir = os.path.join(settings['PORTAGE_BUILDDIR'], 'build-info')
 
-	for k in ('IUSE',):
-		v = settings.get(k)
+	metadata_keys = ['IUSE']
+	if eapi_attrs.iuse_effective:
+		metadata_keys.append('IUSE_EFFECTIVE')
+
+	for k in metadata_keys:
+		v = settings.configdict['pkg'].get(k)
 		if v is not None:
 			write_atomic(os.path.join(build_info_dir, k), v + '\n')
 
@@ -1652,9 +1861,59 @@ def _post_src_install_chost_fix(settings):
 			if v is not None:
 				write_atomic(os.path.join(build_info_dir, k), v + '\n')
 
-_vdb_use_conditional_keys = ('DEPEND', 'LICENSE', 'PDEPEND',
-	'PROPERTIES', 'PROVIDE', 'RDEPEND', 'RESTRICT',)
-_vdb_use_conditional_atoms = frozenset(['DEPEND', 'PDEPEND', 'RDEPEND'])
+	with io.open(_unicode_encode(os.path.join(build_info_dir,
+		'BUILD_TIME'), encoding=_encodings['fs'], errors='strict'),
+		mode='w', encoding=_encodings['repo.content'],
+		errors='strict') as f:
+		f.write("%.0f\n" % (time.time(),))
+
+	use = frozenset(settings['PORTAGE_USE'].split())
+	for k in _vdb_use_conditional_keys:
+		v = settings.configdict['pkg'].get(k)
+		filename = os.path.join(build_info_dir, k)
+		if v is None:
+			try:
+				os.unlink(filename)
+			except OSError:
+				pass
+			continue
+
+		if k.endswith('DEPEND'):
+			if eapi_attrs.slot_operator:
+				continue
+			token_class = Atom
+		else:
+			token_class = None
+
+		v = use_reduce(v, uselist=use, token_class=token_class)
+		v = paren_enclose(v)
+		if not v:
+			try:
+				os.unlink(filename)
+			except OSError:
+				pass
+			continue
+		with io.open(_unicode_encode(os.path.join(build_info_dir,
+			k), encoding=_encodings['fs'], errors='strict'),
+			mode='w', encoding=_encodings['repo.content'],
+			errors='strict') as f:
+			f.write('%s\n' % v)
+
+	if eapi_attrs.slot_operator:
+		deps = evaluate_slot_operator_equal_deps(settings, use, QueryCommand.get_db())
+		for k, v in deps.items():
+			filename = os.path.join(build_info_dir, k)
+			if not v:
+				try:
+					os.unlink(filename)
+				except OSError:
+					pass
+				continue
+			with io.open(_unicode_encode(os.path.join(build_info_dir,
+				k), encoding=_encodings['fs'], errors='strict'),
+				mode='w', encoding=_encodings['repo.content'],
+				errors='strict') as f:
+				f.write('%s\n' % v)
 
 def _preinst_bsdflags(mysettings):
 	if bsd_chflags:
@@ -1696,6 +1955,33 @@ def _post_src_install_uid_fix(mysettings, out):
 	destdir = mysettings["D"]
 	ed_len = len(mysettings["ED"])
 	unicode_errors = []
+	desktop_file_validate = \
+		portage.process.find_binary("desktop-file-validate") is not None
+	xdg_dirs = mysettings.get('XDG_DATA_DIRS', '/usr/share').split(':')
+	xdg_dirs = tuple(os.path.join(i, "applications") + os.sep
+		for i in xdg_dirs if i)
+
+	qa_desktop_file = ""
+	try:
+		with io.open(_unicode_encode(os.path.join(
+			mysettings["PORTAGE_BUILDDIR"],
+			"build-info", "QA_DESKTOP_FILE"),
+			encoding=_encodings['fs'], errors='strict'),
+			mode='r', encoding=_encodings['repo.content'],
+			errors='replace') as f:
+			qa_desktop_file = f.read()
+	except IOError as e:
+		if e.errno not in (errno.ENOENT, errno.ESTALE):
+			raise
+
+	qa_desktop_file = qa_desktop_file.split()
+	if qa_desktop_file:
+		if len(qa_desktop_file) > 1:
+			qa_desktop_file = "|".join("(%s)" % x for x in qa_desktop_file)
+			qa_desktop_file = "^(%s)$" % qa_desktop_file
+		else:
+			qa_desktop_file = "^%s$" % qa_desktop_file[0]
+		qa_desktop_file = re.compile(qa_desktop_file)
 
 	while True:
 
@@ -1704,6 +1990,7 @@ def _post_src_install_uid_fix(mysettings, out):
 		counted_inodes = set()
 		fixlafiles_announced = False
 		fixlafiles = "fixlafiles" in mysettings.features
+		desktopfile_errors = []
 
 		for parent, dirs, files in os.walk(destdir):
 			try:
@@ -1743,6 +2030,16 @@ def _post_src_install_uid_fix(mysettings, out):
 				else:
 					fpath = os.path.join(parent, fname)
 
+				fpath_relative = fpath[ed_len - 1:]
+				if desktop_file_validate and fname.endswith(".desktop") and \
+					os.path.isfile(fpath) and \
+					fpath_relative.startswith(xdg_dirs) and \
+					not (qa_desktop_file and qa_desktop_file.match(fpath_relative.strip(os.sep)) is not None):
+
+					desktop_validate = validate_desktop_entry(fpath)
+					if desktop_validate:
+						desktopfile_errors.extend(desktop_validate)
+
 				if fixlafiles and \
 					fname.endswith(".la") and os.path.isfile(fpath):
 					f = open(_unicode_encode(fpath,
@@ -1809,6 +2106,11 @@ def _post_src_install_uid_fix(mysettings, out):
 		if not unicode_error:
 			break
 
+	if desktopfile_errors:
+		for l in _merge_desktopfile_error(desktopfile_errors):
+			l = l.replace(mysettings["ED"], '/')
+			eqawarn(l, phase='install', key=mysettings.mycpv, out=out)
+
 	if unicode_errors:
 		for l in _merge_unicode_error(unicode_errors):
 			eqawarn(l, phase='install', key=mysettings.mycpv, out=out)
@@ -1820,47 +2122,9 @@ def _post_src_install_uid_fix(mysettings, out):
 		'SIZE'), encoding=_encodings['fs'], errors='strict'),
 		mode='w', encoding=_encodings['repo.content'],
 		errors='strict')
-	f.write(_unicode_decode(str(size) + '\n'))
+	f.write('%d\n' % size)
 	f.close()
 
-	f = io.open(_unicode_encode(os.path.join(build_info_dir,
-		'BUILD_TIME'), encoding=_encodings['fs'], errors='strict'),
-		mode='w', encoding=_encodings['repo.content'],
-		errors='strict')
-	f.write(_unicode_decode("%.0f\n" % (time.time(),)))
-	f.close()
-
-	use = frozenset(mysettings['PORTAGE_USE'].split())
-	for k in _vdb_use_conditional_keys:
-		v = mysettings.configdict['pkg'].get(k)
-		filename = os.path.join(build_info_dir, k)
-		if v is None:
-			try:
-				os.unlink(filename)
-			except OSError:
-				pass
-			continue
-
-		if k.endswith('DEPEND'):
-			token_class = Atom
-		else:
-			token_class = None
-
-		v = use_reduce(v, uselist=use, token_class=token_class)
-		v = paren_enclose(v)
-		if not v:
-			try:
-				os.unlink(filename)
-			except OSError:
-				pass
-			continue
-		f = io.open(_unicode_encode(os.path.join(build_info_dir,
-			k), encoding=_encodings['fs'], errors='strict'),
-			mode='w', encoding=_encodings['repo.content'],
-			errors='strict')
-		f.write(_unicode_decode(v + '\n'))
-		f.close()
-
 	_reapply_bsdflags_to_image(mysettings)
 
 def _reapply_bsdflags_to_image(mysettings):
@@ -2009,6 +2273,20 @@ def _post_src_install_soname_symlinks(mysettings, out):
 	for line in qa_msg:
 		eqawarn(line, key=mysettings.mycpv, out=out)
 
+def _merge_desktopfile_error(errors):
+	lines = []
+
+	msg = _("QA Notice: This package installs one or more .desktop files "
+		"that do not pass validation.")
+	lines.extend(wrap(msg, 72))
+
+	lines.append("")
+	errors.sort()
+	lines.extend("\t" + x for x in errors)
+	lines.append("")
+
+	return lines
+
 def _merge_unicode_error(errors):
 	lines = []
 
@@ -2065,11 +2343,6 @@ def _handle_self_update(settings, vardb):
 	if settings["ROOT"] == "/" and \
 		portage.dep.match_from_list(
 		portage.const.PORTAGE_PACKAGE_ATOM, [cpv]):
-		inherited = frozenset(settings.get('INHERITED', '').split())
-		if not vardb.cpv_exists(cpv) or \
-			'9999' in cpv or \
-			'git' in inherited or \
-			'git-2' in inherited:
-			_prepare_self_update(settings)
-			return True
+		_prepare_self_update(settings)
+		return True
 	return False
diff --git a/portage_with_autodep/pym/portage/package/ebuild/doebuild.pyo b/portage_with_autodep/pym/portage/package/ebuild/doebuild.pyo
index a6ebb1d..846d99a 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/doebuild.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/doebuild.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/fetch.py b/portage_with_autodep/pym/portage/package/ebuild/fetch.py
index b795b28..5316f03 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/fetch.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/fetch.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 from __future__ import print_function
@@ -14,6 +14,10 @@ import stat
 import sys
 import tempfile
 
+try:
+	from urllib.parse import urlparse
+except ImportError:
+	from urlparse import urlparse
 
 import portage
 portage.proxy.lazyimport.lazyimport(globals(),
@@ -25,7 +29,8 @@ portage.proxy.lazyimport.lazyimport(globals(),
 
 from portage import OrderedDict, os, selinux, shutil, _encodings, \
 	_shell_quote, _unicode_encode
-from portage.checksum import hashfunc_map, perform_md5, verify_all
+from portage.checksum import (hashfunc_map, perform_md5, verify_all,
+	_filter_unaccelarated_hashes, _hash_filter, _apply_hash_filter)
 from portage.const import BASH_BINARY, CUSTOM_MIRRORS_FILE, \
 	GLOBAL_CONFIG_PATH
 from portage.data import portage_gid, portage_uid, secpass, userpriv_groups
@@ -63,9 +68,9 @@ def _spawn_fetch(settings, args, **kwargs):
 	if "fd_pipes" not in kwargs:
 
 		kwargs["fd_pipes"] = {
-			0 : sys.stdin.fileno(),
-			1 : sys.stdout.fileno(),
-			2 : sys.stdout.fileno(),
+			0 : portage._get_stdin().fileno(),
+			1 : sys.__stdout__.fileno(),
+			2 : sys.__stdout__.fileno(),
 		}
 
 	if "userfetch" in settings.features and \
@@ -184,7 +189,7 @@ def _check_digests(filename, digests, show_errors=1):
 		return False
 	return True
 
-def _check_distfile(filename, digests, eout, show_errors=1):
+def _check_distfile(filename, digests, eout, show_errors=1, hash_filter=None):
 	"""
 	@return a tuple of (match, stat_obj) where match is True if filename
 	matches all given digests (if any) and stat_obj is a stat result, or
@@ -210,6 +215,9 @@ def _check_distfile(filename, digests, eout, show_errors=1):
 			# Zero-byte distfiles are always invalid.
 			return (False, st)
 	else:
+		digests = _filter_unaccelarated_hashes(digests)
+		if hash_filter is not None:
+			digests = _apply_hash_filter(digests, hash_filter)
 		if _check_digests(filename, digests, show_errors=show_errors):
 			eout.ebegin("%s %s ;-)" % (os.path.basename(filename),
 				" ".join(sorted(digests))))
@@ -339,7 +347,7 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 				_("!!! For fetching to a read-only filesystem, "
 				"locking should be turned off.\n")), noiselevel=-1)
 			writemsg(_("!!! This can be done by adding -distlocks to "
-				"FEATURES in /etc/make.conf\n"), noiselevel=-1)
+				"FEATURES in /etc/portage/make.conf\n"), noiselevel=-1)
 #			use_locks = 0
 
 	# local mirrors are always added
@@ -353,6 +361,9 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 		if try_mirrors:
 			mymirrors += [x.rstrip("/") for x in mysettings["GENTOO_MIRRORS"].split() if x]
 
+	hash_filter = _hash_filter(mysettings.get("PORTAGE_CHECKSUM_FILTER", ""))
+	if hash_filter.transparent:
+		hash_filter = None
 	skip_manifest = mysettings.get("EBUILD_SKIP_MANIFEST") == "1"
 	if skip_manifest:
 		allow_missing_digests = True
@@ -395,12 +406,16 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 		for myfile, uri_set in myuris.items():
 			for myuri in uri_set:
 				file_uri_tuples.append((myfile, myuri))
+			if not uri_set:
+				file_uri_tuples.append((myfile, None))
 	else:
 		for myuri in myuris:
-			file_uri_tuples.append((os.path.basename(myuri), myuri))
+			if urlparse(myuri).scheme:
+				file_uri_tuples.append((os.path.basename(myuri), myuri))
+			else:
+				file_uri_tuples.append((os.path.basename(myuri), None))
 
 	filedict = OrderedDict()
-	primaryuri_indexes={}
 	primaryuri_dict = {}
 	thirdpartymirror_uris = {}
 	for myfile, myuri in file_uri_tuples:
@@ -408,6 +423,8 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 			filedict[myfile]=[]
 			for y in range(0,len(locations)):
 				filedict[myfile].append(locations[y]+"/distfiles/"+myfile)
+		if myuri is None:
+			continue
 		if myuri[:9]=="mirror://":
 			eidx = myuri.find("/", 9)
 			if eidx != -1:
@@ -422,10 +439,9 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 
 				# now try the official mirrors
 				if mirrorname in thirdpartymirrors:
-					random.shuffle(thirdpartymirrors[mirrorname])
-
 					uris = [locmirr.rstrip("/") + "/" + path \
 						for locmirr in thirdpartymirrors[mirrorname]]
+					random.shuffle(uris)
 					filedict[myfile].extend(uris)
 					thirdpartymirror_uris.setdefault(myfile, []).extend(uris)
 
@@ -438,26 +454,30 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 			if restrict_fetch or force_mirror:
 				# Only fetch from specific mirrors is allowed.
 				continue
-			if "primaryuri" in restrict:
-				# Use the source site first.
-				if myfile in primaryuri_indexes:
-					primaryuri_indexes[myfile] += 1
-				else:
-					primaryuri_indexes[myfile] = 0
-				filedict[myfile].insert(primaryuri_indexes[myfile], myuri)
-			else:
-				filedict[myfile].append(myuri)
 			primaryuris = primaryuri_dict.get(myfile)
 			if primaryuris is None:
 				primaryuris = []
 				primaryuri_dict[myfile] = primaryuris
 			primaryuris.append(myuri)
 
+	# Order primaryuri_dict values to match that in SRC_URI.
+	for uris in primaryuri_dict.values():
+		uris.reverse()
+
 	# Prefer thirdpartymirrors over normal mirrors in cases when
 	# the file does not yet exist on the normal mirrors.
 	for myfile, uris in thirdpartymirror_uris.items():
 		primaryuri_dict.setdefault(myfile, []).extend(uris)
 
+	# Now merge primaryuri values into filedict (includes mirrors
+	# explicitly referenced in SRC_URI).
+	if "primaryuri" in restrict:
+		for myfile, uris in filedict.items():
+			filedict[myfile] = primaryuri_dict.get(myfile, []) + uris
+	else:
+		for myfile in filedict:
+			filedict[myfile] += primaryuri_dict.get(myfile, [])
+
 	can_fetch=True
 
 	if listonly:
@@ -635,7 +655,7 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 				eout = EOutput()
 				eout.quiet = mysettings.get("PORTAGE_QUIET") == "1"
 				match, mystat = _check_distfile(
-					myfile_path, pruned_digests, eout)
+					myfile_path, pruned_digests, eout, hash_filter=hash_filter)
 				if match:
 					# Skip permission adjustment for symlinks, since we don't
 					# want to modify anything outside of the primary DISTDIR,
@@ -707,7 +727,7 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 					for x in ro_distdirs:
 						filename = os.path.join(x, myfile)
 						match, mystat = _check_distfile(
-							filename, pruned_digests, eout)
+							filename, pruned_digests, eout, hash_filter=hash_filter)
 						if match:
 							readonly_file = filename
 							break
@@ -732,7 +752,7 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 							"remaining space.\n"), noiselevel=-1)
 						if userfetch:
 							writemsg(_("!!! You may set FEATURES=\"-userfetch\""
-								" in /etc/make.conf in order to fetch with\n"
+								" in /etc/portage/make.conf in order to fetch with\n"
 								"!!! superuser privileges.\n"), noiselevel=-1)
 
 				if fsmirrors and not os.path.exists(myfile_path) and has_space:
@@ -793,8 +813,10 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 							eout.eend(0)
 							continue
 						else:
-							verified_ok, reason = verify_all(
-								myfile_path, mydigests[myfile])
+							digests = _filter_unaccelarated_hashes(mydigests[myfile])
+							if hash_filter is not None:
+								digests = _apply_hash_filter(digests, hash_filter)
+							verified_ok, reason = verify_all(myfile_path, digests)
 							if not verified_ok:
 								writemsg(_("!!! Previously fetched"
 									" file: '%s'\n") % myfile, noiselevel=-1)
@@ -816,7 +838,6 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 								eout = EOutput()
 								eout.quiet = \
 									mysettings.get("PORTAGE_QUIET", None) == "1"
-								digests = mydigests.get(myfile)
 								if digests:
 									digests = list(digests)
 									digests.sort()
@@ -844,8 +865,8 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 				protocol = loc[0:loc.find("://")]
 
 				global_config_path = GLOBAL_CONFIG_PATH
-				if mysettings['EPREFIX']:
-					global_config_path = os.path.join(mysettings['EPREFIX'],
+				if portage.const.EPREFIX:
+					global_config_path = os.path.join(portage.const.EPREFIX,
 							GLOBAL_CONFIG_PATH.lstrip(os.sep))
 
 				missing_file_param = False
@@ -954,11 +975,16 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 					writemsg_stdout(_(">>> Downloading '%s'\n") % \
 						_hide_url_passwd(loc))
 					variables = {
-						"DISTDIR": mysettings["DISTDIR"],
 						"URI":     loc,
 						"FILE":    myfile
 					}
 
+					for k in ("DISTDIR", "PORTAGE_SSH_OPTS"):
+						try:
+							variables[k] = mysettings[k]
+						except KeyError:
+							pass
+
 					myfetch = shlex_split(locfetch)
 					myfetch = [varexpand(x, mydict=variables) for x in myfetch]
 					myret = -1
@@ -1051,7 +1077,10 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 								# file NOW, for those users who don't have a stable/continuous
 								# net connection. This way we have a chance to try to download
 								# from another mirror...
-								verified_ok,reason = verify_all(mysettings["DISTDIR"]+"/"+myfile, mydigests[myfile])
+								digests = _filter_unaccelarated_hashes(mydigests[myfile])
+								if hash_filter is not None:
+									digests = _apply_hash_filter(digests, hash_filter)
+								verified_ok, reason = verify_all(myfile_path, digests)
 								if not verified_ok:
 									writemsg(_("!!! Fetched file: %s VERIFY FAILED!\n") % myfile,
 										noiselevel=-1)
@@ -1085,7 +1114,6 @@ def fetch(myuris, mysettings, listonly=0, fetchonly=0,
 								else:
 									eout = EOutput()
 									eout.quiet = mysettings.get("PORTAGE_QUIET", None) == "1"
-									digests = mydigests.get(myfile)
 									if digests:
 										eout.ebegin("%s %s ;-)" % \
 											(myfile, " ".join(sorted(digests))))
diff --git a/portage_with_autodep/pym/portage/package/ebuild/fetch.pyo b/portage_with_autodep/pym/portage/package/ebuild/fetch.pyo
index 3bd81df..6e2c242 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/fetch.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/fetch.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.py b/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.py
index 8a88c2f..70a6bf2 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 __all__ = ['getmaskingreason']
@@ -6,13 +6,12 @@ __all__ = ['getmaskingreason']
 import portage
 from portage import os
 from portage.const import USER_CONFIG_PATH
-from portage.dep import Atom, match_from_list, _slot_separator, _repo_separator
+from portage.dep import Atom, match_from_list
 from portage.exception import InvalidAtom
 from portage.localization import _
 from portage.repository.config import _gen_valid_repo
 from portage.util import grablines, normalize_path
-from portage.versions import catpkgsplit
-from _emerge.Package import Package
+from portage.versions import catpkgsplit, _pkg_str
 
 def getmaskingreason(mycpv, metadata=None, settings=None,
 	portdb=None, return_location=False, myrepo=None):
@@ -60,23 +59,20 @@ def getmaskingreason(mycpv, metadata=None, settings=None,
 
 	# Sometimes we can't access SLOT or repository due to corruption.
 	pkg = mycpv
-	if metadata is not None:
-		pkg = "".join((mycpv, _slot_separator, metadata["SLOT"]))
-	# At this point myrepo should be None, a valid name, or
-	# Package.UNKNOWN_REPO which we ignore.
-	if myrepo is not None and myrepo != Package.UNKNOWN_REPO:
-		pkg = "".join((pkg, _repo_separator, myrepo))
+	try:
+		pkg.slot
+	except AttributeError:
+		pkg = _pkg_str(mycpv, metadata=metadata, repo=myrepo)
+
 	cpv_slot_list = [pkg]
 
-	mycp=mysplit[0]+"/"+mysplit[1]
+	mycp = pkg.cp
 
-	# XXX- This is a temporary duplicate of code from the config constructor.
-	locations = [os.path.join(settings["PORTDIR"], "profiles")]
+	locations = []
+	if pkg.repo in settings.repositories:
+		for repo in settings.repositories[pkg.repo].masters + (settings.repositories[pkg.repo],):
+			locations.append(os.path.join(repo.location, "profiles"))
 	locations.extend(settings.profiles)
-	for ov in settings["PORTDIR_OVERLAY"].split():
-		profdir = os.path.join(normalize_path(ov), "profiles")
-		if os.path.isdir(profdir):
-			locations.append(profdir)
 	locations.append(os.path.join(settings["PORTAGE_CONFIGROOT"],
 		USER_CONFIG_PATH))
 	locations.reverse()
diff --git a/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.pyo b/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.pyo
index 1614244..6c0073d 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/getmaskingreason.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.py b/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.py
index 9bf605d..c8954aa 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.py
@@ -1,12 +1,15 @@
-# Copyright 2010-2012 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = ['getmaskingstatus']
 
 import sys
 
 import portage
 from portage import eapi_is_supported, _eapi_is_deprecated
+from portage.exception import InvalidDependString
 from portage.localization import _
 from portage.package.ebuild.config import config
 from portage.versions import catpkgsplit, _pkg_str
@@ -48,7 +51,7 @@ def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 		# emerge passed in a Package instance
 		pkg = mycpv
 		mycpv = pkg.cpv
-		metadata = pkg.metadata
+		metadata = pkg._metadata
 		installed = pkg.installed
 
 	if metadata is None:
@@ -65,10 +68,11 @@ def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 		else:
 			metadata["USE"] = ""
 
-	if not hasattr(mycpv, 'slot'):
+	try:
+		mycpv.slot
+	except AttributeError:
 		try:
-			mycpv = _pkg_str(mycpv, slot=metadata['SLOT'],
-				repo=metadata.get('repository'))
+			mycpv = _pkg_str(mycpv, metadata=metadata, settings=settings)
 		except portage.exception.InvalidData:
 			raise ValueError(_("invalid CPV: %s") % mycpv)
 
@@ -83,6 +87,7 @@ def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 	mygroups = settings._getKeywords(mycpv, metadata)
 	licenses = metadata["LICENSE"]
 	properties = metadata["PROPERTIES"]
+	restrict = metadata["RESTRICT"]
 	if not eapi_is_supported(eapi):
 		return [_MaskReason("EAPI", "EAPI %s" % eapi)]
 	elif _eapi_is_deprecated(eapi) and not installed:
@@ -122,6 +127,13 @@ def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 			if gp=="*":
 				kmask=None
 				break
+			elif gp == "~*":
+				for x in pgroups:
+					if x[:1] == "~":
+						kmask = None
+						break
+				if kmask is None:
+					break
 			elif gp=="-"+myarch and myarch in pgroups:
 				kmask="-"+myarch
 				break
@@ -161,6 +173,15 @@ def _getmaskingstatus(mycpv, settings, portdb, myrepo=None):
 	except portage.exception.InvalidDependString as e:
 		rValue.append(_MaskReason("invalid", "PROPERTIES: "+str(e)))
 
+	try:
+		missing_restricts = settings._getMissingRestrict(mycpv, metadata)
+		if missing_restricts:
+			msg = list(missing_restricts)
+			msg.append("in RESTRICT")
+			rValue.append(_MaskReason("RESTRICT", " ".join(msg)))
+	except InvalidDependString as e:
+		rValue.append(_MaskReason("invalid", "RESTRICT: %s" % (e,)))
+
 	# Only show KEYWORDS masks for installed packages
 	# if they're not masked for any other reason.
 	if kmask and (not installed or not rValue):
diff --git a/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.pyo b/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.pyo
index 9cf1d9d..27bb3c7 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/getmaskingstatus.pyo
diff --git a/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.py b/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.py
index b8fbdc5..6782160 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.py
+++ b/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.py
@@ -1,6 +1,8 @@
-# Copyright 2010-2011 Gentoo Foundation
+# Copyright 2010-2013 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+from __future__ import unicode_literals
+
 __all__ = ['prepare_build_dirs']
 
 import errno
@@ -338,12 +340,12 @@ def _prepare_workdir(mysettings):
 			try:
 				_ensure_log_subdirs(logdir, log_subdir)
 			except PortageException as e:
-				writemsg(_unicode_decode("!!! %s\n") % (e,), noiselevel=-1)
+				writemsg("!!! %s\n" % (e,), noiselevel=-1)
 
 			if os.access(log_subdir, os.W_OK):
 				logdir_subdir_ok = True
 			else:
-				writemsg(_unicode_decode("!!! %s: %s\n") %
+				writemsg("!!! %s: %s\n" %
 					(_("Permission Denied"), log_subdir), noiselevel=-1)
 
 	tmpdir_log_path = os.path.join(
diff --git a/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.pyo b/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.pyo
index 2dcfaea..fd6d446 100644
--- a/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.pyo
+++ b/portage_with_autodep/pym/portage/package/ebuild/prepare_build_dirs.pyo