Only check ChangeLog if we're dealing with an ebuild (bug #170604) (branches/2.1.2 r6702)

svn path=/main/branches/2.1.2.9/; revision=7437

1 files changed, 411 insertions, 1235 deletions

diff --git a/bin/emerge b/bin/emerge
index 7202174b..7023f02a 100755
--- a/bin/emerge
+++ b/bin/emerge
@@ -40,8 +40,6 @@ from output import blue, bold, colorize, darkblue, darkgreen, darkred, green, \
 from output import create_color_func
 good = create_color_func("GOOD")
 bad = create_color_func("BAD")
-# white looks bad on terminals with white background
-from output import bold as white
 
 import portage_dep
 portage_dep._dep_check_strict = True
@@ -50,7 +48,6 @@ import portage_locks
 import portage_exception
 from portage_data import secpass
 from portage_util import normalize_path as normpath
-from portage_util import writemsg
 
 if not hasattr(__builtins__, "set"):
 	from sets import Set as set
@@ -136,11 +133,7 @@ def userquery(prompt, responses=None, colours=None):
 	KeyboardInterrupt is converted to SystemExit to avoid tracebacks being
 	printed."""
 	if responses is None:
-		responses = ["Yes", "No"]
-		colours = [
-			create_color_func("PROMPT_CHOICE_DEFAULT"),
-			create_color_func("PROMPT_CHOICE_OTHER")
-		]
+		responses, colours = ["Yes", "No"], [green, red]
 	elif colours is None:
 		colours=[bold]
 	colours=(colours*len(responses))[:len(responses)]
@@ -211,11 +204,10 @@ shortmapping={
 
 def emergelog(xterm_titles, mystr, short_msg=None):
 	if xterm_titles:
-		if short_msg == None:
-			short_msg = mystr
-		if "HOSTNAME" in os.environ:
-			short_msg = os.environ["HOSTNAME"]+": "+short_msg
-		xtermTitle(short_msg)
+		if short_msg:
+			xtermTitle(short_msg)
+		else:
+			xtermTitle(mystr)
 	try:
 		file_path = "/var/log/emerge.log"
 		mylogfile = open(file_path, "a")
@@ -343,20 +335,27 @@ def create_depgraph_params(myopts, myaction):
 	# recurse:   go into the dependencies
 	# deep:      go into the dependencies of already merged packages
 	# empty:     pretend nothing is merged
-	myparams = set(["recurse"])
+	myparams = ["recurse"]
+	add=[]
+	sub=[]
 	if "--update" in myopts or \
 		"--newuse" in myopts or \
-		"--reinstall" in myopts or \
 		"--noreplace" in myopts or \
 		myaction in ("system", "world"):
-		myparams.add("selective")
+		add.extend(["selective"])
 	if "--emptytree" in myopts:
-		myparams.add("empty")
-		myparams.discard("selective")
+		add.extend(["empty"])
+		sub.extend(["selective"])
 	if "--nodeps" in myopts:
-		myparams.discard("recurse")
+		sub.extend(["recurse"])
 	if "--deep" in myopts:
-		myparams.add("deep")
+		add.extend(["deep"])
+	for x in add:
+		if (x not in myparams) and (x not in sub):
+			myparams.append(x)
+	for x in sub:
+		if x in myparams:
+			myparams.remove(x)
 	return myparams
 
 # search functionality
@@ -439,7 +438,7 @@ class search:
 				if self.searchre.search(full_desc):
 					self.matches["desc"].append([full_package,masked])
 		self.mlen=0
-		for mtype in self.matches:
+		for mtype in self.matches.keys():
 			self.matches[mtype].sort()
 			self.mlen += len(self.matches[mtype])
 
@@ -448,7 +447,7 @@ class search:
 		print "\b\b  \n[ Results for search key : "+white(self.searchkey)+" ]"
 		print "[ Applications found : "+white(str(self.mlen))+" ]"
 		print " "
-		for mtype in self.matches:
+		for mtype in self.matches.keys():
 			for match,masked in self.matches[mtype]:
 				if mtype=="pkg":
 					catpack=match
@@ -565,10 +564,8 @@ def getlist(settings, mode):
 
 def clean_world(vardb, cpv):
 	"""Remove a package from the world file when unmerged."""
-	world_set = WorldSet(vardb.settings)
-	world_set.lock()
-	world_set.load()
-	worldlist = list(world_set)
+	world_filename = os.path.join(vardb.root, portage.WORLD_FILE)
+	worldlist = portage_util.grabfile(world_filename)
 	mykey = portage.cpv_getkey(cpv)
 	newworldlist = []
 	for x in worldlist:
@@ -587,162 +584,15 @@ def clean_world(vardb, cpv):
 			#this doesn't match the package we're unmerging; keep it.
 			newworldlist.append(x)
 
-	world_set.clear()
-	world_set.update(newworldlist)
-	world_set.save()
-	world_set.unlock()
-
-class AtomSet(object):
-	def __init__(self, atoms=None):
-		self._atoms = {}
-		if atoms:
-			self.update(atoms)
-	def clear(self):
-		self._atoms.clear()
-	def add(self, atom):
-		cp = portage.dep_getkey(atom)
-		cp_list = self._atoms.get(cp)
-		if cp_list is None:
-			cp_list = []
-			self._atoms[cp] = cp_list
-		if atom not in cp_list:
-			cp_list.append(atom)
-	def update(self, atoms):
-		for atom in atoms:
-			self.add(atom)
-	def __contains__(self, atom):
-		cp = portage.dep_getkey(atom)
-		if cp in self._atoms and atom in self._atoms[cp]:
-			return True
-		return False
-	def findAtomForPackage(self, cpv, metadata):
-		"""Return the best match for a given package from the arguments, or
-		None if there are no matches.  This matches virtual arguments against
-		the PROVIDE metadata.  This can raise an InvalidDependString exception
-		if an error occurs while parsing PROVIDE."""
-		cpv_slot = "%s:%s" % (cpv, metadata["SLOT"])
-		cp = portage.dep_getkey(cpv)
-		atoms = self._atoms.get(cp)
-		if atoms:
-			best_match = portage.best_match_to_list(cpv_slot, atoms)
-			if best_match:
-				return best_match
-		if not metadata["PROVIDE"]:
-			return None
-		provides = portage.flatten(portage_dep.use_reduce(
-			portage_dep.paren_reduce(metadata["PROVIDE"]),
-			uselist=metadata["USE"].split()))
-		for provide in provides:
-			provided_cp = portage.dep_getkey(provide)
-			atoms = self._atoms.get(provided_cp)
-			if atoms:
-				transformed_atoms = [atom.replace(provided_cp, cp) for atom in atoms]
-				best_match = portage.best_match_to_list(cpv_slot, transformed_atoms)
-				if best_match:
-					return atoms[transformed_atoms.index(best_match)]
-		return None
-	def __iter__(self):
-		for atoms in self._atoms.itervalues():
-			for atom in atoms:
-				yield atom
-
-class SystemSet(AtomSet):
-	def __init__(self, settings, **kwargs):
-		AtomSet.__init__(self, **kwargs)
-		self.update(getlist(settings, "system"))
-
-class WorldSet(AtomSet):
-	def __init__(self, settings, **kwargs):
-		AtomSet.__init__(self, **kwargs)
-		self.world_file = os.path.join(settings["ROOT"], portage.WORLD_FILE)
-		self._lock = None
-	def _ensure_dirs(self):
-		portage_util.ensure_dirs(os.path.dirname(self.world_file),
-			gid=portage.portage_gid, mode=02750, mask=02)
-	def load(self):
-		self.clear()
-		self.update(portage_util.grabfile_package(self.world_file))
-	def save(self):
-		self._ensure_dirs()
-		portage.write_atomic(self.world_file,
-			"\n".join(sorted(self)) + "\n")
-	def lock(self):
-		self._ensure_dirs()
-		self._lock = portage_locks.lockfile(self.world_file, wantnewlockfile=1)
-	def unlock(self):
-		portage_locks.unlockfile(self._lock)
-		self._lock = None
-
-class RootConfig(object):
-	"""This is used internally by depgraph to track information about a
-	particular $ROOT."""
-	def __init__(self, trees):
-		self.trees = trees
-		self.settings = trees["vartree"].settings
-		self.root = self.settings["ROOT"]
-		self.sets = {}
-		world_set = WorldSet(self.settings)
-		world_set.load()
-		self.sets["world"] = world_set
-		system_set = SystemSet(self.settings)
-		self.sets["system"] = system_set
-
-def create_world_atom(pkg_key, metadata, args_set, root_config):
-	"""Create a new atom for the world file if one does not exist.  If the
-	argument atom is precise enough to identify a specific slot then a slot
-	atom will be returned. Atoms that are in the system set may also be stored
-	in world since system atoms can only match one slot while world atoms can
-	be greedy with respect to slots.  Unslotted system packages will not be
-	stored in world."""
-	arg_atom = args_set.findAtomForPackage(pkg_key, metadata)
-	cp = portage.dep_getkey(arg_atom)
-	new_world_atom = cp
-	sets = root_config.sets
-	portdb = root_config.trees["porttree"].dbapi
-	vardb = root_config.trees["vartree"].dbapi
-	available_slots = set(portdb.aux_get(cpv, ["SLOT"])[0] \
-		for cpv in portdb.match(cp))
-	slotted = len(available_slots) > 1 or \
-		(len(available_slots) == 1 and "0" not in available_slots)
-	if not slotted:
-		# check the vdb in case this is multislot
-		available_slots = set(vardb.aux_get(cpv, ["SLOT"])[0] \
-			for cpv in vardb.match(cp))
-		slotted = len(available_slots) > 1 or \
-			(len(available_slots) == 1 and "0" not in available_slots)
-	if slotted and arg_atom != cp:
-		# If the user gave a specific atom, store it as a
-		# slot atom in the world file.
-		slot_atom = "%s:%s" % (cp, metadata["SLOT"])
-		# First verify the slot is in the portage tree to avoid
-		# adding a bogus slot like that produced by multislot.
-		if portdb.match(slot_atom):
-			# Now verify that the argument is precise enough to identify a
-			# specific slot.
-			matches = portdb.match(arg_atom)
-			matched_slots = set()
-			for cpv in matches:
-				matched_slots.add(portdb.aux_get(cpv, ["SLOT"])[0])
-			if len(matched_slots) == 1:
-				new_world_atom = slot_atom
-	if new_world_atom == sets["world"].findAtomForPackage(pkg_key, metadata):
-		# Both atoms would be identical, so there's nothing to add.
-		return None
-	if not slotted:
-		# Unlike world atoms, system atoms are not greedy for slots, so they
-		# can't be safely excluded from world if they are slotted.
-		system_atom = sets["system"].findAtomForPackage(pkg_key, metadata)
-		if system_atom:
-			if not portage.dep_getkey(system_atom).startswith("virtual/"):
-				return None
-			# System virtuals aren't safe to exclude from world since they can
-			# match multiple old-style virtuals but only one of them will be
-			# pulled in by update or depclean.
-			providers = portdb.mysettings.getvirtuals().get(
-				portage.dep_getkey(system_atom))
-			if providers and len(providers) == 1 and providers[0] == cp:
-				return None
-	return new_world_atom
+	portage_util.ensure_dirs(os.path.join(vardb.root, portage.PRIVATE_PATH),
+		gid=portage.portage_gid, mode=02770)
+	portage_util.write_atomic(world_filename, "\n".join(newworldlist))
+
+def genericdict(mylist):
+	mynewdict={}
+	for x in mylist:
+		mynewdict[portage.dep_getkey(x)]=x
+	return mynewdict
 
 def filter_iuse_defaults(iuse):
 	for flag in iuse:
@@ -774,15 +624,13 @@ class DepPriority(object):
 		levels:
 
 		MEDIUM   The upper boundary for medium dependencies.
-		MEDIUM_SOFT   The upper boundary for medium-soft dependencies.
 		SOFT     The upper boundary for soft dependencies.
 		MIN      The lower boundary for soft dependencies.
 	"""
-	__slots__ = ("__weakref__", "satisfied", "buildtime", "runtime", "runtime_post")
+	__slots__ = ("__weakref__", "satisfied", "buildtime", "runtime")
 	MEDIUM = -1
-	MEDIUM_SOFT = -2
-	SOFT   = -3
-	MIN    = -6
+	SOFT   = -2
+	MIN    = -4
 	def __init__(self, **kwargs):
 		for myattr in self.__slots__:
 			if myattr == "__weakref__":
@@ -795,15 +643,11 @@ class DepPriority(object):
 				return 0
 			if self.runtime:
 				return -1
-			if self.runtime_post:
-				return -2
 		if self.buildtime:
-			return -3
+			return -2
 		if self.runtime:
-			return -4
-		if self.runtime_post:
-			return -5
-		return -6
+			return -3
+		return -4
 	def __lt__(self, other):
 		return self.__int__() < other
 	def __le__(self, other):
@@ -823,10 +667,8 @@ class DepPriority(object):
 		myvalue = self.__int__()
 		if myvalue > self.MEDIUM:
 			return "hard"
-		if myvalue > self.MEDIUM_SOFT:
-			return "medium"
 		if myvalue > self.SOFT:
-			return "medium-soft"
+			return "medium"
 		return "soft"
 
 class FakeVartree(portage.vartree):
@@ -854,7 +696,7 @@ class FakeVartree(portage.vartree):
 			if os.access(vdb_path, os.W_OK):
 				vdb_lock = portage_locks.lockdir(vdb_path)
 			mykeys = ["SLOT", "COUNTER", "PROVIDE", "USE", "IUSE",
-				"RESTRICT", "DEPEND", "RDEPEND", "PDEPEND", "repository"]
+				"DEPEND", "RDEPEND", "PDEPEND"]
 			real_dbapi = real_vartree.dbapi
 			slot_counters = {}
 			for cpv in real_dbapi.cpv_all():
@@ -1030,13 +872,6 @@ class BlockerCache(DictMixin):
 		"""
 		return self.BlockerData(*self._cache_data["blockers"][cpv])
 
-	def keys(self):
-		"""This needs to be implemented so that self.__repr__() doesn't raise
-		an AttributeError."""
-		if self._cache_data and "blockers" in self._cache_data:
-			return self._cache_data["blockers"].keys()
-		return []
-
 def show_invalid_depstring_notice(parent_node, depstring, error_msg):
 
 	from formatter import AbstractFormatter, DumbWriter
@@ -1093,13 +928,10 @@ class depgraph:
 		self.pkg_node_map = {}
 		# Maps slot atom to digraph node for all nodes added to the graph.
 		self._slot_node_map = {}
-		# Maps nodes to the reasons they were selected for reinstallation.
-		self._reinstall_nodes = {}
 		self.mydbapi = {}
-		self._mydbapi_keys = ["SLOT", "DEPEND", "RDEPEND", "PDEPEND",
-			"USE", "IUSE", "PROVIDE", "RESTRICT", "repository"]
+		self._mydbapi_keys = ["SLOT", "DEPEND", "RDEPEND", "PDEPEND"]
+		self.useFlags = {}
 		self.trees = {}
-		self.roots = {}
 		for myroot in trees:
 			self.trees[myroot] = {}
 			for tree in ("porttree", "bintree"):
@@ -1112,7 +944,6 @@ class depgraph:
 			self.pkg_node_map[myroot] = {}
 			self._slot_node_map[myroot] = {}
 			vardb = self.trees[myroot]["vartree"].dbapi
-			self.roots[myroot] = RootConfig(self.trees[myroot])
 			# This fakedbapi instance will model the state that the vdb will
 			# have after new packages have been installed.
 			fakedb = portage.fakedbapi(settings=self.pkgsettings[myroot])
@@ -1127,6 +958,7 @@ class depgraph:
 						metadata=dict(izip(self._mydbapi_keys,
 						vardb.aux_get(pkg, self._mydbapi_keys))))
 			del vardb, fakedb
+			self.useFlags[myroot] = {}
 			if "--usepkg" in self.myopts:
 				self.trees[myroot]["bintree"].populate(
 					"--getbinpkg" in self.myopts,
@@ -1140,15 +972,7 @@ class depgraph:
 		self._parent_child_digraph = digraph()
 		self.orderedkeys=[]
 		self.outdatedpackages=[]
-		# contains all sets added to the graph
-		self._sets = {}
-		# contains atoms given as arguments
-		self._sets["args"] = AtomSet()
-		# contains all atoms from all sets added to the graph, including
-		# atoms given as arguments
-		self._set_atoms = AtomSet()
-		# contains all nodes pulled in by self._set_atoms
-		self._set_nodes = set()
+		self.args_keys = []
 		self.blocker_digraph = digraph()
 		self.blocker_parents = {}
 		self._unresolved_blocker_parents = {}
@@ -1212,24 +1036,6 @@ class depgraph:
 		f.end_paragraph(1)
 		f.writer.flush()
 
-	def _reinstall_for_flags(self, forced_flags,
-		orig_use, orig_iuse, cur_use, cur_iuse):
-		"""Return a set of flags that trigger reinstallation, or None if there
-		are no such flags."""
-		if "--newuse" in self.myopts:
-			flags = orig_iuse.symmetric_difference(
-				cur_iuse).difference(forced_flags)
-			flags.update(orig_iuse.intersection(orig_use).symmetric_difference(
-				cur_iuse.intersection(cur_use)))
-			if flags:
-				return flags
-		elif "changed-use" == self.myopts.get("--reinstall"):
-			flags = orig_iuse.intersection(orig_use).symmetric_difference(
-				cur_iuse.intersection(cur_use))
-			if flags:
-				return flags
-		return None
-
 	def create(self, mybigkey, myparent=None, addme=1, myuse=None,
 		priority=DepPriority(), rev_dep=False, arg=None):
 		"""
@@ -1271,7 +1077,8 @@ class depgraph:
 				self.blocker_parents.setdefault(
 					tuple(mybigkey), set()).add(myparent)
 			return 1
-
+		if not arg and myroot == self.target_root:
+			arg = portage.best_match_to_list(mykey, self.args_keys)
 		# select the correct /var database that we'll be checking against
 		vardbapi = self.trees[myroot]["vartree"].dbapi
 		portdb = self.trees[myroot]["porttree"].dbapi
@@ -1282,28 +1089,11 @@ class depgraph:
 		# directive, otherwise we add a "merge" directive.
 
 		mydbapi = self.trees[myroot][self.pkg_tree_map[mytype]].dbapi
-		metadata = dict(izip(self._mydbapi_keys,
-			mydbapi.aux_get(mykey, self._mydbapi_keys)))
-		if mytype == "ebuild":
-			pkgsettings.setcpv(mykey, mydb=portdb)
-			metadata["USE"] = pkgsettings["USE"]
-			myuse = pkgsettings["USE"].split()
-		else:
-			# The myuse parameter to this method is deprecated, so get it
-			# directly from the metadata here.
-			myuse = metadata["USE"].split()
 
-		if not arg and myroot == self.target_root:
-			try:
-				arg = self._set_atoms.findAtomForPackage(mykey, metadata)
-			except portage_exception.InvalidDependString, e:
-				if mytype != "installed":
-					show_invalid_depstring_notice(tuple(mybigkey+["merge"]),
-						metadata["PROVIDE"], str(e))
-					return 0
-				del e
+		if myuse is None:
+			self.pkgsettings[myroot].setcpv(mykey, mydb=portdb)
+			myuse = self.pkgsettings[myroot]["USE"].split()
 
-		reinstall_for_flags = None
 		merging=1
 		if mytype == "installed":
 			merging = 0
@@ -1316,23 +1106,23 @@ class depgraph:
 			""" If we aren't merging, perform the --newuse check.
 			    If the package has new iuse flags or different use flags then if
 			    --newuse is specified, we need to merge the package. """
-			if merging == 0 and \
-				myroot == self.target_root and \
-				("--newuse" in self.myopts or
-				"--reinstall" in self.myopts) and \
+			if merging==0 and "--newuse" in self.myopts and \
 				vardbapi.cpv_exists(mykey):
 				pkgsettings.setcpv(mykey, mydb=mydbapi)
 				forced_flags = set()
 				forced_flags.update(pkgsettings.useforce)
 				forced_flags.update(pkgsettings.usemask)
 				old_use = vardbapi.aux_get(mykey, ["USE"])[0].split()
-				iuses = set(filter_iuse_defaults(metadata["IUSE"].split()))
+				iuses = set(filter_iuse_defaults(
+					mydbapi.aux_get(mykey, ["IUSE"])[0].split()))
 				old_iuse = set(filter_iuse_defaults(
 					vardbapi.aux_get(mykey, ["IUSE"])[0].split()))
-				reinstall_for_flags = self._reinstall_for_flags(
-					forced_flags, old_use, old_iuse, myuse, iuses)
-				if reinstall_for_flags:
+				if iuses.symmetric_difference(
+					old_iuse).difference(forced_flags):
 					merging = 1
+				elif old_iuse.intersection(old_use) != \
+					iuses.intersection(myuse):
+					merging=1
 
 		if addme and merging == 1:
 			mybigkey.append("merge")
@@ -1341,15 +1131,16 @@ class depgraph:
 		jbigkey = tuple(mybigkey)
 
 		if addme:
+			metadata = dict(izip(self._mydbapi_keys,
+				mydbapi.aux_get(mykey, self._mydbapi_keys)))
 			if merging == 0 and vardbapi.cpv_exists(mykey) and \
 				mytype != "installed":
-				mytype = "installed"
 				mybigkey[0] = "installed"
 				mydbapi = vardbapi
 				jbigkey = tuple(mybigkey)
 				metadata = dict(izip(self._mydbapi_keys,
 					mydbapi.aux_get(mykey, self._mydbapi_keys)))
-				myuse = metadata["USE"].split()
+				myuse = mydbapi.aux_get(mykey, ["USE"])[0].split()
 			slot_atom = "%s:%s" % (portage.dep_getkey(mykey), metadata["SLOT"])
 			existing_node = self._slot_node_map[myroot].get(
 				slot_atom, None)
@@ -1390,6 +1181,7 @@ class depgraph:
 				# self.pkg_node_map and self.mydbapi since that data will
 				# be used for blocker validation.
 				self.pkg_node_map[myroot].setdefault(mykey, jbigkey)
+				self.useFlags[myroot].setdefault(mykey, myuse)
 				# Even though the graph is now invalid, continue to process
 				# dependencies so that things like --fetchonly can still
 				# function despite collisions.
@@ -1397,8 +1189,7 @@ class depgraph:
 				self.mydbapi[myroot].cpv_inject(mykey, metadata=metadata)
 				self._slot_node_map[myroot][slot_atom] = jbigkey
 				self.pkg_node_map[myroot][mykey] = jbigkey
-				if reinstall_for_flags:
-					self._reinstall_nodes[jbigkey] = reinstall_for_flags
+				self.useFlags[myroot][mykey] = myuse
 
 			if rev_dep and myparent:
 				self.digraph.addnode(myparent, jbigkey,
@@ -1407,9 +1198,6 @@ class depgraph:
 				self.digraph.addnode(jbigkey, myparent,
 					priority=priority)
 
-		if arg:
-			self._set_nodes.add(jbigkey)
-
 		# Do this even when addme is False (--onlydeps) so that the
 		# parent/child relationship is always known in case
 		# self._show_slot_collision_notice() needs to be called later.
@@ -1433,8 +1221,9 @@ class depgraph:
 
 		edepend={}
 		depkeys = ["DEPEND","RDEPEND","PDEPEND"]
-		for k in depkeys:
-			edepend[k] = metadata[k]
+		depvalues = mydbapi.aux_get(mykey, depkeys)
+		for i in xrange(len(depkeys)):
+			edepend[depkeys[i]] = depvalues[i]
 
 		if mytype == "ebuild":
 			if "--buildpkgonly" in self.myopts:
@@ -1469,7 +1258,7 @@ class depgraph:
 				# Post Depend -- Add to the list without a parent, as it depends
 				# on a package being present AND must be built after that package.
 				if not self.select_dep(myroot, edepend["PDEPEND"], myparent=mp,
-					myuse=myuse, priority=DepPriority(runtime_post=True),
+					myuse=myuse, priority=DepPriority(), rev_deps=True,
 					parent_arg=arg):
 					return 0
 		except ValueError, e:
@@ -1496,7 +1285,6 @@ class depgraph:
 		"given a list of .tbz2s, .ebuilds and deps, create the appropriate depgraph and return a favorite list"
 		myfavorites=[]
 		myroot = self.target_root
-		vardb = self.trees[myroot]["vartree"].dbapi
 		portdb = self.trees[myroot]["porttree"].dbapi
 		bindb = self.trees[myroot]["bintree"].dbapi
 		pkgsettings = self.pkgsettings[myroot]
@@ -1518,38 +1306,26 @@ class depgraph:
 					else:
 						print "\n\n!!! Binary package '"+str(x)+"' does not exist."
 						print "!!! Please ensure the tbz2 exists as specified.\n"
-						return 0, myfavorites
+						sys.exit(1)
 				mytbz2=xpak.tbz2(x)
 				mykey=mytbz2.getelements("CATEGORY")[0]+"/"+os.path.splitext(os.path.basename(x))[0]
 				if os.path.realpath(x) != \
 					os.path.realpath(self.trees[myroot]["bintree"].getname(mykey)):
 					print colorize("BAD", "\n*** You need to adjust PKGDIR to emerge this package.\n")
-					return 0, myfavorites
+					sys.exit(1)
 				if not self.create(["binary", myroot, mykey],
-					None, "--onlydeps" not in self.myopts,
-					myuse=mytbz2.getelements("USE"), arg=x):
+					None, "--onlydeps" not in self.myopts):
 					return (0,myfavorites)
-				arg_atoms.append((x, "="+mykey))
+				elif not "--oneshot" in self.myopts:
+					myfavorites.append(mykey)
 			elif ext==".ebuild":
-				ebuild_path = portage_util.normalize_path(os.path.abspath(x))
-				pkgdir = os.path.dirname(ebuild_path)
-				tree_root = os.path.dirname(os.path.dirname(pkgdir))
-				cp = pkgdir[len(tree_root)+1:]
-				e = portage_exception.PackageNotFound(
-					("%s is not in a valid portage tree " + \
-					"hierarchy or does not exist") % x)
-				if not portage.isvalidatom(cp):
-					raise e
-				cat = portage.catsplit(cp)[0]
-				mykey = cat + "/" + os.path.basename(ebuild_path[:-7])
-				if not portage.isvalidatom("="+mykey):
-					raise e
+				x = os.path.realpath(x)
+				mykey=os.path.basename(os.path.normpath(x+"/../.."))+"/"+os.path.splitext(os.path.basename(x))[0]
 				ebuild_path = portdb.findname(mykey)
 				if ebuild_path:
-					if ebuild_path != os.path.join(os.path.realpath(tree_root),
-						cp, os.path.basename(ebuild_path)):
+					if os.path.realpath(ebuild_path) != x:
 						print colorize("BAD", "\n*** You need to adjust PORTDIR or PORTDIR_OVERLAY to emerge this package.\n")
-						return 0, myfavorites
+						sys.exit(1)
 					if mykey not in portdb.xmatch(
 						"match-visible", portage.dep_getkey(mykey)):
 						print colorize("BAD", "\n*** You are emerging a masked package. It is MUCH better to use")
@@ -1561,9 +1337,10 @@ class depgraph:
 					raise portage_exception.PackageNotFound(
 						"%s is not in a valid portage tree hierarchy or does not exist" % x)
 				if not self.create(["ebuild", myroot, mykey],
-					None, "--onlydeps" not in self.myopts, arg=x):
+					None, "--onlydeps" not in self.myopts):
 					return (0,myfavorites)
-				arg_atoms.append((x, "="+mykey))
+				elif not "--oneshot" in self.myopts:
+					myfavorites.append(mykey)
 			else:
 				if not is_valid_package_atom(x):
 					portage.writemsg("\n\n!!! '%s' is not a valid package atom.\n" % x,
@@ -1576,22 +1353,13 @@ class depgraph:
 					if "--usepkg" in self.myopts:
 						mykey = portage.dep_expand(x, mydb=bindb,
 							settings=pkgsettings)
-					if "--usepkgonly" in self.myopts or \
-						(mykey and not portage.dep_getkey(mykey).startswith("null/")):
+					if (mykey and not mykey.startswith("null/")) or \
+						"--usepkgonly" in self.myopts:
 						arg_atoms.append((x, mykey))
 						continue
 
-					try:
-						mykey = portage.dep_expand(x,
-							mydb=portdb, settings=pkgsettings)
-					except ValueError, e:
-						mykey = portage.dep_expand(x,
-							mydb=vardb, settings=pkgsettings)
-						cp = portage.dep_getkey(mykey)
-						if cp.startswith("null/") or \
-							cp not in e[0]:
-							raise
-						del e
+					mykey = portage.dep_expand(x,
+						mydb=portdb, settings=pkgsettings)
 					arg_atoms.append((x, mykey))
 				except ValueError, errpkgs:
 					print "\n\n!!! The short ebuild name \"" + x + "\" is ambiguous.  Please specify"
@@ -1650,19 +1418,9 @@ class depgraph:
 							greedy_atoms.append((myarg, myslot_atom))
 			arg_atoms = greedy_atoms
 
-		oneshot = "--oneshot" in self.myopts or \
-			"--onlydeps" in self.myopts or \
-			"--update" in self.myopts
 		""" These are used inside self.create() in order to ensure packages
 		that happen to match arguments are not incorrectly marked as nomerge."""
-		args_set = self._sets["args"]
-		for myarg, myatom in arg_atoms:
-			if myatom in args_set:
-				continue
-			args_set.add(myatom)
-			self._set_atoms.add(myatom)
-			if not oneshot:
-				myfavorites.append(myatom)
+		self.args_keys = [x[1] for x in arg_atoms]
 		for myarg, myatom in arg_atoms:
 				try:
 					self.mysd = self.select_dep(myroot, myatom, arg=myarg)
@@ -1689,6 +1447,10 @@ class depgraph:
 
 				if not self.mysd:
 					return (0,myfavorites)
+				elif not "--oneshot" in self.myopts:
+					mykey = portage.dep_getkey(myatom)
+					if mykey not in myfavorites:
+						myfavorites.append(mykey)
 
 		missing=0
 		if "--usepkgonly" in self.myopts:
@@ -1762,11 +1524,11 @@ class depgraph:
 				return 0
 			mymerge = mycheck[1]
 
-		if not mymerge and arg:
+		if not mymerge and arg and \
+			portage.best_match_to_list(depstring, self.args_keys):
 			# A provided package has been specified on the command line.  The
 			# package will not be merged and a warning will be displayed.
-			if depstring in self._set_atoms:
-				self._pprovided_args.append((arg, depstring))
+			self._pprovided_args.append(arg)
 
 		if myparent:
 			# The parent is added after it's own dep_check call so that it
@@ -1779,17 +1541,9 @@ class depgraph:
 			if p_status == "merge":
 				# Update old-style virtuals if this package provides any.
 				# These are needed for dep_virtual calls inside dep_check.
-				p_db = self.mydbapi[p_root] # contains cached metadata
-				if myparent in self._slot_collision_nodes:
-					# The metadata isn't cached due to the slot collision.
-					p_db = self.trees[p_root][self.pkg_tree_map[p_type]].dbapi
+				p_db = self.trees[p_root][self.pkg_tree_map[p_type]].dbapi
 				try:
 					self.pkgsettings[p_root].setinst(p_key, p_db)
-					# For consistency, also update the global virtuals.
-					settings = self.roots[p_root].settings
-					settings.unlock()
-					settings.setinst(p_key, p_db)
-					settings.lock()
 				except portage_exception.InvalidDependString, e:
 					provide = p_db.aux_get(p_key, ["PROVIDE"])[0]
 					show_invalid_depstring_notice(myparent, provide, str(e))
@@ -1834,9 +1588,7 @@ class depgraph:
 					if myeb_pkg_matches:
 						myeb_pkg = portage.best(myeb_pkg_matches)
 
-				if myeb_pkg and \
-					("--newuse" in self.myopts or \
-					"--reinstall" in self.myopts):
+				if myeb_pkg and "--newuse" in self.myopts:
 					iuses = set(filter_iuse_defaults(
 						bindb.aux_get(myeb_pkg, ["IUSE"])[0].split()))
 					old_use = bindb.aux_get(myeb_pkg, ["USE"])[0].split()
@@ -1855,8 +1607,11 @@ class depgraph:
 					if "--usepkgonly" not in self.myopts and myeb:
 						cur_iuse = set(filter_iuse_defaults(
 							portdb.aux_get(myeb, ["IUSE"])[0].split()))
-					if self._reinstall_for_flags(
-						forced_flags, old_use, iuses, now_use, cur_iuse):
+					if iuses.symmetric_difference(
+						cur_iuse).difference(forced_flags):
+						myeb_pkg = None
+					elif iuses.intersection(old_use) != \
+						cur_iuse.intersection(now_use):
 						myeb_pkg = None
 				if myeb_pkg:
 					binpkguseflags = \
@@ -1910,10 +1665,9 @@ class depgraph:
 								mreasons = portage.getmaskingstatus(p,
 									settings=pkgsettings, portdb=portdb)
 								print "- "+p+" (masked by: "+", ".join(mreasons)+")"
-								comment, filename = portage.getmaskingreason(p,
-									settings=pkgsettings, portdb=portdb, return_location=True)
+								comment = portage.getmaskingreason(p,
+									settings=pkgsettings, portdb=portdb)
 								if comment and comment != oldcomment:
-									print filename+":"
 									print comment
 									oldcomment = comment
 							print
@@ -1951,9 +1705,8 @@ class depgraph:
 					e_type, myroot, e_cpv, e_status = existing_node
 					if portage.match_from_list(x, [e_cpv]):
 						# The existing node can be reused.
-						# Just pass in None for myuse since
-						# self.create() doesn't use it anymore.
-						selected_pkg = [e_type, myroot, e_cpv, None]
+						selected_pkg = [e_type, myroot, e_cpv,
+							self.useFlags[myroot][e_cpv]]
 
 			if myparent:
 				#we are a dependency, so we want to be unconditionally added
@@ -2237,9 +1990,6 @@ class depgraph:
 			self._altlist_cache[reversed] = retlist[:]
 			return retlist
 		mygraph=self.digraph.copy()
-		for node in mygraph.order[:]:
-			if node[-1] == "nomerge":
-				mygraph.remove(node)
 		self._merge_order_bias(mygraph)
 		myblockers = self.blocker_digraph.copy()
 		retlist=[]
@@ -2254,34 +2004,32 @@ class depgraph:
 				if "portage" == portage.catsplit(portage.dep_getkey(cpv))[-1]:
 					asap_nodes.append(node)
 					break
-		ignore_priority_soft_range = [None]
-		ignore_priority_soft_range.extend(
-			xrange(DepPriority.MIN, DepPriority.SOFT + 1))
+		ignore_priority_range = [None]
+		ignore_priority_range.extend(
+			xrange(DepPriority.MIN, DepPriority.MEDIUM + 1))
 		tree_mode = "--tree" in self.myopts
-		# Tracks whether or not the current iteration should prefer asap_nodes
-		# if available.  This is set to False when the previous iteration
-		# failed to select any nodes.  It is reset whenever nodes are
-		# successfully selected.
-		prefer_asap = True
 		while not mygraph.empty():
-			selected_nodes = None
-			if prefer_asap and asap_nodes:
+			ignore_priority = None
+			nodes = None
+			if asap_nodes:
 				"""ASAP nodes are merged before their soft deps."""
-				asap_nodes = [node for node in asap_nodes \
-					if mygraph.contains(node)]
 				for node in asap_nodes:
+					if not mygraph.contains(node):
+						asap_nodes.remove(node)
+						continue
 					if not mygraph.child_nodes(node,
 						ignore_priority=DepPriority.SOFT):
-						selected_nodes = [node]
+						nodes = [node]
 						asap_nodes.remove(node)
 						break
-			if not selected_nodes and \
-				not (prefer_asap and asap_nodes):
-				for ignore_priority in ignore_priority_soft_range:
+			if not nodes:
+				for ignore_priority in ignore_priority_range:
 					nodes = get_nodes(ignore_priority=ignore_priority)
 					if nodes:
 						break
-				if nodes:
+			selected_nodes = None
+			if nodes:
+				if ignore_priority <= DepPriority.SOFT:
 					if ignore_priority is None and not tree_mode:
 						# Greedily pop all of these nodes since no relationship
 						# has been ignored.  This optimization destroys --tree
@@ -2300,65 +2048,30 @@ class depgraph:
 						if not selected_nodes:
 							# settle for a root node
 							selected_nodes = [nodes[0]]
-			if not selected_nodes:
-				nodes = get_nodes(ignore_priority=DepPriority.MEDIUM)
-				if nodes:
+				else:
 					"""Recursively gather a group of nodes that RDEPEND on
 					eachother.  This ensures that they are merged as a group
 					and get their RDEPENDs satisfied as soon as possible."""
-					def gather_deps(ignore_priority,
-						mergeable_nodes, selected_nodes, node):
+					def gather_deps(mergeable_nodes, selected_nodes, node):
 						if node in selected_nodes:
 							return True
 						if node not in mergeable_nodes:
 							return False
 						selected_nodes.add(node)
 						for child in mygraph.child_nodes(node,
-							ignore_priority=ignore_priority):
-							if not gather_deps(ignore_priority,
+							ignore_priority=DepPriority.SOFT):
+							if not gather_deps(
 								mergeable_nodes, selected_nodes, child):
 								return False
 						return True
 					mergeable_nodes = set(nodes)
-					if prefer_asap and asap_nodes:
-						nodes = asap_nodes
-					for ignore_priority in xrange(DepPriority.SOFT,
-						DepPriority.MEDIUM_SOFT + 1):
-						for node in nodes:
-							selected_nodes = set()
-							if gather_deps(ignore_priority,
-								mergeable_nodes, selected_nodes, node):
-								break
-							else:
-								selected_nodes = None
-						if selected_nodes:
+					for node in nodes:
+						selected_nodes = set()
+						if gather_deps(
+							mergeable_nodes, selected_nodes, node):
 							break
-
-					if prefer_asap and asap_nodes and not selected_nodes:
-						# We failed to find any asap nodes to merge, so ignore
-						# them for the next iteration.
-						prefer_asap = False
-						continue
-
-					if selected_nodes and ignore_priority > DepPriority.SOFT:
-						# Try to merge ignored medium deps as soon as possible.
-						for node in selected_nodes:
-							children = set(mygraph.child_nodes(node))
-							soft = children.difference(
-								mygraph.child_nodes(node,
-								ignore_priority=DepPriority.SOFT))
-							medium_soft = children.difference(
-								mygraph.child_nodes(node,
-								ignore_priority=DepPriority.MEDIUM_SOFT))
-							medium_soft.difference_update(soft)
-							for child in medium_soft:
-								if child in selected_nodes:
-									continue
-								if child in asap_nodes:
-									continue
-								# TODO: Try harder to make these nodes get
-								# merged absolutely as soon as possible.
-								asap_nodes.append(child)
+						else:
+							selected_nodes = None
 
 			if not selected_nodes:
 				if not myblockers.is_empty():
@@ -2370,16 +2083,8 @@ class depgraph:
 					if not circular_blocks:
 						circular_blocks = True
 						blocker_deps = myblockers.leaf_nodes()
-					while blocker_deps:
-						# Some of these nodes might have already been selected
-						# by the normal node selection process after the
-						# circular_blocks flag has been set.  Therefore, we
-						# have to verify that they're still in the graph so
-						# that they're not selected more than once.
-						node = blocker_deps.pop()
-						if mygraph.contains(node):
-							selected_nodes = [node]
-							break
+					if blocker_deps:
+						selected_nodes = [blocker_deps.pop()]
 
 			if not selected_nodes:
 				# No leaf nodes are available, so we have a circular
@@ -2419,10 +2124,6 @@ class depgraph:
 				print "!!! disabling USE flags that trigger optional dependencies."
 				sys.exit(1)
 
-			# At this point, we've succeeded in selecting one or more nodes, so
-			# it's now safe to reset the prefer_asap to it's default state.
-			prefer_asap = True
-
 			for node in selected_nodes:
 				retlist.append(list(node))
 				mygraph.remove(node)
@@ -2460,45 +2161,32 @@ class depgraph:
 			return [x for x in mylist \
 				if x in matches or not portdb.cpv_exists(x)]
 		world_problems = False
+		if mode=="system":
+			mylist = getlist(self.settings, "system")
+		else:
+			#world mode
+			worldlist = getlist(self.settings, "world")
+			sysdict = genericdict(getlist(self.settings, "system"))
+			worlddict=genericdict(worldlist)
 
-		root_config = self.roots[self.target_root]
-		world_set = root_config.sets["world"]
-		system_set = root_config.sets["system"]
-		mylist = list(system_set)
-		self._sets["system"] = system_set
-		if mode == "world":
-			self._sets["world"] = world_set
-			for x in world_set:
+			for x in worlddict.keys():
 				if not portage.isvalidatom(x):
 					world_problems = True
-					continue
-				elif not vardb.match(x):
+				elif not self.trees[self.target_root]["vartree"].dbapi.match(x):
 					world_problems = True
-					available = False
-					if "--usepkgonly" not in self.myopts and \
-						portdb.match(x):
-						available = True
-					elif "--usepkg" in self.myopts:
-						mymatches = bindb.match(x)
-						if "--usepkgonly" not in self.myopts:
-							mymatches = visible(mymatches)
-						if mymatches:
-							available = True
-					if not available:
-						continue
-				mylist.append(x)
+				else:
+					sysdict[x]=worlddict[x]
+
+			mylist = sysdict.keys()
 
 		newlist = []
 		for atom in mylist:
 			mykey = portage.dep_getkey(atom)
 			if True:
 				newlist.append(atom)
-				if mode == "system" or atom not in world_set:
-					# only world is greedy for slots, not system
-					continue
-				# Make sure all installed slots are updated when possible.
-				# Do this with --emptytree also, to ensure that all slots are
-				# remerged.
+				"""Make sure all installed slots are updated when possible.
+				Do this with --emptytree also, to ensure that all slots are
+				remerged."""
 				myslots = set()
 				for cpv in vardb.match(mykey):
 					myslots.add(vardb.aux_get(cpv, ["SLOT"])[0])
@@ -2539,10 +2227,7 @@ class depgraph:
 						if available:
 							newlist.append(myslot_atom)
 		mylist = newlist
-
-		for myatom in mylist:
-			self._set_atoms.add(myatom)
-
+		
 		missing_atoms = []
 		for mydep in mylist:
 			try:
@@ -2568,12 +2253,10 @@ class depgraph:
 
 		return 1
 
-	def display(self, mylist, favorites=[], verbosity=None):
+	def display(self,mylist,verbosity=None):
 		if verbosity is None:
 			verbosity = ("--quiet" in self.myopts and 1 or \
 				"--verbose" in self.myopts and 3 or 2)
-		favorites_set = AtomSet()
-		favorites_set.update(favorites)
 		changelogs=[]
 		p=[]
 		blockers = []
@@ -2586,8 +2269,7 @@ class depgraph:
 		else:
 			def create_use_string(name, cur_iuse, iuse_forced, cur_use,
 				old_iuse, old_use,
-				is_new, reinst_flags,
-				all_flags=(verbosity == 3 or "--quiet" in self.myopts),
+				is_new, all_flags=(verbosity == 3 or "--quiet" in self.myopts),
 				alphabetical=("--alphabetical" in self.myopts)):
 				enabled = []
 				if alphabetical:
@@ -2605,18 +2287,16 @@ class depgraph:
 				for flag in any_iuse:
 					flag_str = None
 					isEnabled = False
-					reinst_flag = reinst_flags and flag in reinst_flags
 					if flag in enabled_flags:
 						isEnabled = True
-						if is_new or flag in old_use and \
-							(all_flags or reinst_flag):
+						if is_new or flag in old_use and all_flags:
 							flag_str = red(flag)
 						elif flag not in old_iuse:
 							flag_str = yellow(flag) + "%*"
 						elif flag not in old_use:
 							flag_str = green(flag) + "*"
 					elif flag in removed_iuse:
-						if all_flags or reinst_flag:
+						if all_flags:
 							flag_str = yellow("-" + flag) + "%"
 							if flag in old_use:
 								flag_str += "*"
@@ -2624,9 +2304,7 @@ class depgraph:
 							removed.append(flag_str)
 						continue
 					else:
-						if is_new or flag in old_iuse and \
-							flag not in old_use and \
-							(all_flags or reinst_flag):
+						if is_new or flag in old_iuse and flag not in old_use and all_flags:
 							flag_str = blue("-" + flag)
 						elif flag not in old_iuse:
 							flag_str = yellow("-" + flag)
@@ -2650,7 +2328,12 @@ class depgraph:
 					ret = '%s="%s" ' % (name, ret)
 				return ret
 
-		repo_display = RepoDisplay(self.roots)
+		if verbosity == 3:
+			# FIXME: account for the possibility of different overlays in
+			# /etc/make.conf vs. ${PORTAGE_CONFIGROOT}/etc/make.conf
+			overlays = self.settings["PORTDIR_OVERLAY"].split()
+			overlays_real = [os.path.realpath(t) \
+				for t in self.settings["PORTDIR_OVERLAY"].split()]
 
 		tree_nodes = []
 		display_list = []
@@ -2677,12 +2360,7 @@ class depgraph:
 					traversed_nodes = set() # prevent endless circles
 					traversed_nodes.add(graph_key)
 					def add_parents(current_node, ordered):
-						parent_nodes = None
-						# Do not traverse to parents if this node is an
-						# an argument or a direct member of a set that has
-						# been specified as an argument (system or world).
-						if current_node not in self._set_nodes:
-							parent_nodes = mygraph.parent_nodes(current_node)
+						parent_nodes = mygraph.parent_nodes(current_node)
 						if parent_nodes:
 							child_nodes = set(mygraph.child_nodes(current_node))
 							selected_parent = None
@@ -2737,15 +2415,12 @@ class depgraph:
 				depth >= mylist[i+1][1]:
 					del mylist[i]
 
-		from portage import flatten
-		from portage_dep import use_reduce, paren_reduce
+		display_overlays=False
 		# files to fetch list - avoids counting a same file twice
 		# in size display (verbose mode)
 		myfetchlist=[]
-
 		for mylist_index in xrange(len(mylist)):
 			x, depth, ordered = mylist[mylist_index]
-			pkg_node = tuple(x)
 			pkg_type = x[0]
 			myroot = x[1]
 			pkg_key = x[2]
@@ -2777,48 +2452,35 @@ class depgraph:
 					addl += bad(" (is blocking %s)") % block_parents
 				blockers.append(addl)
 			else:
-				pkg_status = x[3]
-				pkg_merge = ordered and pkg_status != "nomerge"
-				if pkg_node in self._slot_collision_nodes or \
-					(pkg_status == "nomerge" and pkg_type != "installed"):
-					# The metadata isn't cached due to a slot collision or
-					# --onlydeps.
-					mydbapi = self.trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
-				else:
-					mydbapi = self.mydbapi[myroot] # contains cached metadata
-				metadata = dict(izip(self._mydbapi_keys,
-					mydbapi.aux_get(pkg_key, self._mydbapi_keys)))
-				ebuild_path = None
-				repo_name = metadata["repository"]
-				if pkg_type == "ebuild":
-					ebuild_path = portdb.findname(pkg_key)
-					if not ebuild_path: # shouldn't happen
-						raise portage_exception.PackageNotFound(pkg_key)
-					repo_path_real = os.path.dirname(os.path.dirname(
-						os.path.dirname(ebuild_path)))
-					pkgsettings.setcpv(pkg_key)
-					metadata["USE"] = pkgsettings["USE"]
-				else:
-					repo_path_real = portdb.getRepositoryPath(repo_name)
-				pkg_use = metadata["USE"].split()
+				mydbapi = self.trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
+				binary_package = True
+				if "ebuild" == pkg_type:
+					if "merge" == x[3] or \
+						not vartree.dbapi.cpv_exists(pkg_key):
+						"""An ebuild "merge" node or a --onlydeps "nomerge"
+						node."""
+						binary_package = False
+						pkgsettings.setcpv(pkg_key, mydb=portdb)
+						if pkg_key not in self.useFlags[myroot]:
+							self.useFlags[myroot][pkg_key] = \
+								pkgsettings["USE"].split()
+					else:
+						# An ebuild "nomerge" node, so USE come from the vardb.
+						mydbapi = vartree.dbapi
+				if pkg_key not in self.useFlags[myroot]:
+					"""If this is a --resume then the USE flags need to be
+					fetched from the appropriate locations here."""
+					self.useFlags[myroot][pkg_key] = mydbapi.aux_get(
+						pkg_key, ["USE"])[0].split()
 
-				try:
-					restrict = flatten(use_reduce(paren_reduce(
-						mydbapi.aux_get(pkg_key, ["RESTRICT"])[0]),
-						uselist=pkg_use))
-				except portage_exception.InvalidDependString, e:
-					if pkg_status != "nomerge":
-						restrict = mydbapi.aux_get(pkg_key, ["RESTRICT"])[0]
-						show_invalid_depstring_notice(x, restrict, str(e))
-						del e
-						return 1
-					restrict = []
 				if "ebuild" == pkg_type and x[3] != "nomerge" and \
-					"fetch" in restrict:
+					"fetch" in portdb.aux_get(
+					x[2], ["RESTRICT"])[0].split():
 					fetch = red("F")
 					if ordered:
 						counters.restrict_fetch += 1
-					if portdb.fetch_check(pkg_key, pkg_use):
+					if portdb.fetch_check(
+						pkg_key, self.useFlags[myroot][pkg_key]):
 						fetch = green("f")
 						if ordered:
 							counters.restrict_fetch_satisfied += 1
@@ -2871,19 +2533,19 @@ class depgraph:
 
 				verboseadd=""
 				
-				if True:
+				if pkg_key in self.useFlags[myroot]:
 					# USE flag display
 					cur_iuse = list(filter_iuse_defaults(
 						mydbapi.aux_get(pkg_key, ["IUSE"])[0].split()))
 
 					forced_flags = set()
-					pkgsettings.setcpv(pkg_key) # for package.use.{mask,force}
-					forced_flags.update(pkgsettings.useforce)
-					forced_flags.update(pkgsettings.usemask)
+					if not binary_package:
+						forced_flags.update(pkgsettings.useforce)
+						forced_flags.update(pkgsettings.usemask)
 
 					cur_iuse = portage.unique_array(cur_iuse)
 					cur_iuse.sort()
-					cur_use = pkg_use
+					cur_use = self.useFlags[myroot][pkg_key]
 					cur_use = [flag for flag in cur_use if flag in cur_iuse]
 
 					if myoldbest:
@@ -2912,8 +2574,7 @@ class depgraph:
 					use_expand_hidden = \
 						pkgsettings["USE_EXPAND_HIDDEN"].lower().split()
 
-					def map_to_use_expand(myvals, forcedFlags=False,
-						removeHidden=True):
+					def map_to_use_expand(myvals, forcedFlags=False):
 						ret = {}
 						forced = {}
 						for exp in use_expand:
@@ -2928,34 +2589,13 @@ class depgraph:
 						ret["USE"] = myvals
 						forced["USE"] = [val for val in myvals \
 							if val in forced_flags]
-						if removeHidden:
-							for exp in use_expand_hidden:
-								ret.pop(exp, None)
+						for exp in use_expand_hidden:
+							if exp in ret:
+								del ret[exp]
 						if forcedFlags:
 							return ret, forced
 						return ret
 
-					# Prevent USE_EXPAND_HIDDEN flags from being hidden if they
-					# are the only thing that triggered reinstallation.
-					reinst_flags_map = {}
-					reinstall_for_flags = self._reinstall_nodes.get(pkg_node)
-					reinst_expand_map = None
-					if reinstall_for_flags:
-						reinst_flags_map = map_to_use_expand(
-							list(reinstall_for_flags), removeHidden=False)
-						for k in list(reinst_flags_map):
-							if not reinst_flags_map[k]:
-								del reinst_flags_map[k]
-						if not reinst_flags_map.get("USE"):
-							reinst_expand_map = reinst_flags_map.copy()
-							reinst_expand_map.pop("USE", None)
-					if reinst_expand_map and \
-						not set(reinst_expand_map).difference(
-						use_expand_hidden):
-						use_expand_hidden = \
-							set(use_expand_hidden).difference(
-							reinst_expand_map)
-
 					cur_iuse_map, iuse_forced = \
 						map_to_use_expand(cur_iuse, forcedFlags=True)
 					cur_use_map = map_to_use_expand(cur_use)
@@ -2971,25 +2611,25 @@ class depgraph:
 						verboseadd += create_use_string(key.upper(),
 							cur_iuse_map[key], iuse_forced[key],
 							cur_use_map[key], old_iuse_map[key],
-							old_use_map[key], is_new,
-							reinst_flags_map.get(key))
+							old_use_map[key], is_new)
 
 				if verbosity == 3:
 					# size verbose
 					mysize=0
-					if pkg_type == "ebuild" and pkg_merge:
+					if x[0] == "ebuild" and ordered and x[-1] != "nomerge":
 						try:
 							myfilesdict = portdb.getfetchsizes(pkg_key,
-								useflags=pkg_use, debug=self.edebug)
+								useflags=self.useFlags[myroot][pkg_key],
+								debug=self.edebug)
 						except portage_exception.InvalidDependString, e:
 							src_uri = portdb.aux_get(pkg_key, ["SRC_URI"])[0]
 							show_invalid_depstring_notice(x, src_uri, str(e))
 							del e
-							return 1
+							sys.exit(1)
 						if myfilesdict is None:
 							myfilesdict="[empty/missing/bad digest]"
 						else:
-							for myfetchfile in myfilesdict:
+							for myfetchfile in myfilesdict.keys():
 								if myfetchfile not in myfetchlist:
 									mysize+=myfilesdict[myfetchfile]
 									myfetchlist.append(myfetchfile)
@@ -2997,38 +2637,17 @@ class depgraph:
 						verboseadd+=format_size(mysize)+" "
 
 					# overlay verbose
-					# assign index for a previous version in the same slot
-					has_previous = False
-					repo_name_prev = None
-					slot_atom = "%s:%s" % (portage.dep_getkey(pkg_key),
-						metadata["SLOT"])
-					slot_matches = vardb.match(slot_atom)
-					if slot_matches:
-						has_previous = True
-						repo_name_prev = vardb.aux_get(slot_matches[0],
-							["repository"])[0]
-
-					# now use the data to generate output
-					repoadd = None
-					if pkg_status == "nomerge" or not has_previous:
-						repoadd = repo_display.repoStr(repo_path_real)
+					# XXX: Invalid binaries have caused tracebacks here. 'if file_name'
+					# x = ['binary', '/', 'sys-apps/pcmcia-cs-3.2.7.2.6', 'merge']
+					file_name = portdb.findname(pkg_key)
+					if file_name: # It might not exist in the tree
+						dir_name=os.path.abspath(os.path.dirname(file_name)+"/../..")
+						if (overlays_real.count(dir_name)>0):
+							verboseadd+=teal("["+str(overlays_real.index(
+								os.path.normpath(dir_name))+1)+"]")+" "
+							display_overlays=True
 					else:
-						repo_path_prev = None
-						if repo_name_prev:
-							repo_path_prev = portdb.getRepositoryPath(
-								repo_name_prev)
-						# To avoid spam during the transition period, don't
-						# show ? if the installed package is missing a
-						# repository label.
-						if not repo_path_prev or \
-							repo_path_prev == repo_path_real:
-							repoadd = repo_display.repoStr(repo_path_real)
-						else:
-							repoadd = "%s=>%s" % (
-								repo_display.repoStr(repo_path_prev),
-								repo_display.repoStr(repo_path_real))
-					if repoadd:
-						verboseadd += teal("[%s]" % repoadd)
+						verboseadd += "[No ebuild?]"
 
 				xs=portage.pkgsplit(x[2])
 				if xs[2]=="r0":
@@ -3057,53 +2676,17 @@ class depgraph:
 						myoldbest=myoldbest[:-3]
 					myoldbest=blue("["+myoldbest+"]")
 
-				pkg_cp = xs[0]
-				root_config = self.roots[myroot]
-				system_set = root_config.sets["system"]
-				world_set  = root_config.sets["world"]
-
-				pkg_system = False
-				pkg_world = False
-				try:
-					pkg_system = system_set.findAtomForPackage(pkg_key, metadata)
-					pkg_world  = world_set.findAtomForPackage(pkg_key, metadata)
-					if not pkg_world and myroot == self.target_root and \
-						favorites_set.findAtomForPackage(pkg_key, metadata):
-						# Maybe it will be added to world now.
-						if create_world_atom(pkg_key, metadata,
-							favorites_set, root_config):
-							pkg_world = True
-				except portage_exception.InvalidDependString:
-					# This is reported elsewhere if relevant.
-					pass
-
-				def pkgprint(pkg):
-					if pkg_merge:
-						if pkg_system:
-							return colorize("PKG_MERGE_SYSTEM", pkg)
-						elif pkg_world:
-							return colorize("PKG_MERGE_WORLD", pkg)
-						else:
-							return colorize("PKG_MERGE", pkg)
-					else:
-						if pkg_system:
-							return colorize("PKG_NOMERGE_SYSTEM", pkg)
-						elif pkg_world:
-							return colorize("PKG_NOMERGE_WORLD", pkg)
-						else:
-							return colorize("PKG_NOMERGE", pkg)
-
 				if x[1]!="/":
 					if myoldbest:
 						myoldbest +=" "
 					if "--columns" in self.myopts:
 						if "--quiet" in self.myopts:
-							myprint=addl+" "+indent+pkgprint(pkg_cp)
+							myprint=addl+" "+indent+darkgreen(xs[0])
 							myprint=myprint+darkblue(" "+xs[1]+xs[2])+" "
 							myprint=myprint+myoldbest
 							myprint=myprint+darkgreen("to "+x[1])
 						else:
-							myprint="["+pkgprint(pkg_type)+" "+addl+"] "+indent+pkgprint(pkg_cp)
+							myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
 							if (newlp-nc_len(myprint)) > 0:
 								myprint=myprint+(" "*(newlp-nc_len(myprint)))
 							myprint=myprint+"["+darkblue(xs[1]+xs[2])+"] "
@@ -3112,21 +2695,21 @@ class depgraph:
 							myprint=myprint+myoldbest
 							myprint=myprint+darkgreen("to "+x[1])+" "+verboseadd
 					else:
-						if not pkg_merge:
-							myprint = "[%s      ] " % pkgprint("nomerge")
+						if x[-1] == "nomerge" or not ordered:
+							myprint = darkblue("[nomerge      ] ")
 						else:
 							myprint = "[" + pkg_type + " " + addl + "] "
-						myprint += indent + pkgprint(pkg_key) + " " + \
+						myprint += indent + darkgreen(pkg_key) + " " + \
 							myoldbest + darkgreen("to " + myroot) + " " + \
 							verboseadd
 				else:
 					if "--columns" in self.myopts:
 						if "--quiet" in self.myopts:
-							myprint=addl+" "+indent+pkgprint(pkg_cp)
+							myprint=addl+" "+indent+darkgreen(xs[0])
 							myprint=myprint+" "+green(xs[1]+xs[2])+" "
 							myprint=myprint+myoldbest
 						else:
-							myprint="["+pkgprint(pkg_type)+" "+addl+"] "+indent+pkgprint(pkg_cp)
+							myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(xs[0])
 							if (newlp-nc_len(myprint)) > 0:
 								myprint=myprint+(" "*(newlp-nc_len(myprint)))
 							myprint=myprint+green(" ["+xs[1]+xs[2]+"] ")
@@ -3134,10 +2717,10 @@ class depgraph:
 								myprint=myprint+(" "*(oldlp-nc_len(myprint)))
 							myprint=myprint+myoldbest+"  "+verboseadd
 					else:
-						if not pkg_merge:
-							myprint="["+pkgprint("nomerge")+"      ] "+indent+pkgprint(pkg_key)+" "+myoldbest+" "+verboseadd
+						if x[-1] == "nomerge" or not ordered:
+							myprint=darkblue("[nomerge      ] "+indent+x[2]+" "+myoldbest+" ")+verboseadd
 						else:
-							myprint="["+pkgprint(pkg_type)+" "+addl+"] "+indent+pkgprint(pkg_key)+" "+myoldbest+" "+verboseadd
+							myprint="["+x[0]+" "+addl+"] "+indent+darkgreen(x[2])+" "+myoldbest+" "+verboseadd
 				p.append(myprint)
 
 			mysplit = portage.pkgsplit(x[2])
@@ -3166,8 +2749,12 @@ class depgraph:
 		if verbosity == 3:
 			print
 			print counters
-			if p:
-				sys.stdout.write(str(repo_display))
+			if overlays and display_overlays:
+				print "Portage overlays:"
+				y=0
+				for x in overlays:
+					y=y+1
+					print " "+teal("["+str(y)+"]"),x
 
 		if "--changelog" in self.myopts:
 			print
@@ -3176,14 +2763,6 @@ class depgraph:
 				sys.stdout.write(text)
 
 		if self._pprovided_args:
-			arg_refs = {}
-			for arg_atom in self._pprovided_args:
-				arg, atom = arg_atom
-				arg_refs[arg_atom] = []
-				cp = portage.dep_getkey(atom)
-				for set_name, atom_set in self._sets.iteritems():
-					if atom in atom_set:
-						arg_refs[arg_atom].append(set_name)
 			msg = []
 			msg.append(bad("\nWARNING: "))
 			if len(self._pprovided_args) > 1:
@@ -3192,26 +2771,11 @@ class depgraph:
 			else:
 				msg.append("A requested package will not be " + \
 					"merged because it is listed in\n")
-			msg.append("package.provided:\n\n")
-			problems_sets = set()
-			for (arg, atom), refs in arg_refs.iteritems():
-				ref_string = ""
-				if refs:
-					problems_sets.update(refs)
-					refs.sort()
-					ref_string = ", ".join(["'%s'" % name for name in refs])
-					ref_string = " pulled in by " + ref_string
-				msg.append("  %s%s\n" % (colorize("INFORM", arg), ref_string))
+			msg.append("         package.provided:\n\n")
+			for arg in self._pprovided_args:
+				msg.append("             " + arg + "\n")
 			msg.append("\n")
-			if "world" in problems_sets:
-				msg.append("This problem can be solved in one of the following ways:\n\n")
-				msg.append("  A) Use emaint to clean offending packages from world (if not installed).\n")
-				msg.append("  B) Uninstall offending packages (cleans them from world).\n")
-				msg.append("  C) Remove offending entries from package.provided.\n\n")
-				msg.append("The best course of action depends on the reason that an offending\n")
-				msg.append("package.provided entry exists.\n\n")
 			sys.stderr.write("".join(msg))
-		return os.EX_OK
 
 	def calc_changelog(self,ebuildpath,current,next):
 		if ebuildpath == None or not os.path.exists(ebuildpath):
@@ -3265,134 +2829,8 @@ class depgraph:
 			if release.endswith('-r0'):
 				release = release[:-3]
 
-	def saveNomergeFavorites(self):
-		"""Find atoms in favorites that are not in the mergelist and add them
-		to the world file if necessary."""
-		for x in ("--fetchonly", "--fetch-all-uri",
-			"--oneshot", "--onlydeps", "--pretend"):
-			if x in self.myopts:
-				return
-		root_config = self.roots[self.target_root]
-		world_set = root_config.sets["world"]
-		world_set.lock()
-		world_set.load()
-		args_set = self._sets["args"]
-		portdb = self.trees[self.target_root]["porttree"].dbapi
-		added_favorites = set()
-		for x in self._set_nodes:
-			pkg_type, root, pkg_key, pkg_status = x
-			if pkg_status != "nomerge":
-				continue
-			metadata = dict(izip(self._mydbapi_keys,
-				self.mydbapi[root].aux_get(pkg_key, self._mydbapi_keys)))
-			try:
-				myfavkey = create_world_atom(pkg_key, metadata,
-					args_set, root_config)
-				if myfavkey:
-					if myfavkey in added_favorites:
-						continue
-					added_favorites.add(myfavkey)
-					world_set.add(myfavkey)
-					print ">>> Recording",myfavkey,"in \"world\" favorites file..."
-			except portage_exception.InvalidDependString, e:
-				writemsg("\n\n!!! '%s' has invalid PROVIDE: %s\n" % \
-					(pkg_key, str(e)), noiselevel=-1)
-				writemsg("!!! see '%s'\n\n" % os.path.join(
-					root, portage.VDB_PATH, pkg_key, "PROVIDE"), noiselevel=-1)
-				del e
-		if added_favorites:
-			world_set.save()
-		world_set.unlock()
-
-	def loadResumeCommand(self, resume_data):
-		"""
-		Add a resume command to the graph and validate it in the process.  This
-		will raise a PackageNotFound exception if a package is not available.
-		"""
-		self._sets["args"].update(resume_data.get("favorites", []))
-		mergelist = resume_data.get("mergelist", [])
-		fakedb = self.mydbapi
-		trees = self.trees
-		for x in mergelist:
-			if len(x) != 4:
-				continue
-			pkg_type, myroot, pkg_key, action = x
-			if pkg_type not in self.pkg_tree_map:
-				continue
-			if action != "merge":
-				continue
-			mydb = trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
-			try:
-				metadata = dict(izip(self._mydbapi_keys,
-					mydb.aux_get(pkg_key, self._mydbapi_keys)))
-			except KeyError:
-				# It does no exist or it is corrupt.
-				raise portage_exception.PackageNotFound(pkg_key)
-			fakedb[myroot].cpv_inject(pkg_key, metadata=metadata)
-			if pkg_type == "ebuild":
-				pkgsettings = self.pkgsettings[myroot]
-				pkgsettings.setcpv(pkg_key, mydb=fakedb[myroot])
-				fakedb[myroot].aux_update(pkg_key, {"USE":pkgsettings["USE"]})
-			self.spinner.update()
-
-class RepoDisplay(object):
-	def __init__(self, roots):
-		self._shown_repos = {}
-		self._unknown_repo = False
-		repo_paths = set()
-		for root_config in roots.itervalues():
-			portdir = root_config.settings.get("PORTDIR")
-			if portdir:
-				repo_paths.add(portdir)
-			overlays = root_config.settings.get("PORTDIR_OVERLAY")
-			if overlays:
-				repo_paths.update(overlays.split())
-		repo_paths = list(repo_paths)
-		self._repo_paths = repo_paths
-		self._repo_paths_real = [ os.path.realpath(repo_path) \
-			for repo_path in repo_paths ]
-
-		# pre-allocate index for PORTDIR so that it always has index 0.
-		for root_config in roots.itervalues():
-			portdb = root_config.trees["porttree"].dbapi
-			portdir = portdb.porttree_root
-			if portdir:
-				self.repoStr(portdir)
-
-	def repoStr(self, repo_path_real):
-		real_index = -1
-		if repo_path_real:
-			real_index = self._repo_paths_real.index(repo_path_real)
-		if real_index == -1:
-			s = "?"
-			self._unknown_repo = True
-		else:
-			shown_repos = self._shown_repos
-			repo_paths = self._repo_paths
-			repo_path = repo_paths[real_index]
-			index = shown_repos.get(repo_path)
-			if index is None:
-				index = len(shown_repos)
-				shown_repos[repo_path] = index
-			s = str(index)
-		return s
-
-	def __str__(self):
-		output = []
-		shown_repos = self._shown_repos
-		unknown_repo = self._unknown_repo
-		if shown_repos or self._unknown_repo:
-			output.append("Portage tree and overlays:\n")
-		show_repo_paths = list(shown_repos)
-		for repo_path, repo_index in shown_repos.iteritems():
-			show_repo_paths[repo_index] = repo_path
-		if show_repo_paths:
-			for index, repo_path in enumerate(show_repo_paths):
-				output.append(" "+teal("["+str(index)+"]")+" %s\n" % repo_path)
-		if unknown_repo:
-			output.append(" "+teal("[?]") + \
-				" indicates that the source repository could not be determined\n")
-		return "".join(output)
+	def outdated(self):
+		return self.outdatedpackages
 
 class PackageCounters(object):
 
@@ -3467,13 +2905,9 @@ class MergeTask(object):
 		if self.target_root != "/":
 			self.pkgsettings["/"] = \
 				portage.config(clone=trees["/"]["vartree"].settings)
-		self.curval = 0
 
 	def merge(self, mylist, favorites, mtimedb):
 		failed_fetches = []
-		fetchonly = "--fetchonly" in self.myopts or \
-			"--fetch-all-uri" in self.myopts
-		pretend = "--pretend" in self.myopts
 		mymergelist=[]
 		ldpath_mtimes = mtimedb["ldpath"]
 		xterm_titles = "notitles" not in self.settings.features
@@ -3500,6 +2934,7 @@ class MergeTask(object):
 				del mtimedb["resume"]["mergelist"][0]
 				del mylist[0]
 				mtimedb.commit()
+			validate_merge_list(self.trees, mylist)
 			mymergelist = mylist
 
 		# Verify all the manifests now so that the user is notified of failure
@@ -3530,12 +2965,35 @@ class MergeTask(object):
 				del x, mytype, myroot, mycpv, mystatus, quiet_config
 			del shown_verifying_msg, quiet_settings
 
-		root_config = RootConfig(self.trees[self.target_root])
-		system_set = root_config.sets["system"]
-		args_set = AtomSet(favorites)
-		world_set = root_config.sets["world"]
+		#buildsyspkg: I need mysysdict also on resume (moved from the else block)
+		mysysdict = genericdict(getlist(self.settings, "system"))
 		if "--resume" not in self.myopts:
-			mymergelist = mylist
+			myfavs = portage.grabfile(
+				os.path.join(self.target_root, portage.WORLD_FILE))
+			myfavdict=genericdict(myfavs)
+			for x in range(len(mylist)):
+				if mylist[x][3]!="nomerge":
+					# Add to the mergelist
+					mymergelist.append(mylist[x])
+				else:
+					myfavkey=portage.cpv_getkey(mylist[x][2])
+					if "--onlydeps" in self.myopts:
+						continue
+					# Add to the world file. Since we won't be able to later.
+					if "--fetchonly" not in self.myopts and \
+						myfavkey in favorites:
+						#don't record if already in system profile or already recorded
+						if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
+							#we don't have a favorites entry for this package yet; add one
+							myfavdict[myfavkey]=myfavkey
+							print ">>> Recording",myfavkey,"in \"world\" favorites file..."
+			if not ("--fetchonly" in self.myopts or \
+				"--fetch-all-uri" in self.myopts or \
+				"--pretend" in self.myopts):
+				portage.write_atomic(
+					os.path.join(self.target_root, portage.WORLD_FILE),
+					"\n".join(myfavdict.values()))
+
 			mtimedb["resume"]["mergelist"]=mymergelist[:]
 			mtimedb.commit()
 
@@ -3580,13 +3038,9 @@ class MergeTask(object):
 				del fetch_log, logfile, fd_pipes, fetch_env, fetch_args, \
 					resume_opts
 
-		metadata_keys = [k for k in portage.auxdbkeys \
-			if not k.startswith("UNUSED_")] + ["USE"]
-
 		mergecount=0
 		for x in mymergelist:
 			mergecount+=1
-			pkg_type = x[0]
 			myroot=x[1]
 			pkg_key = x[2]
 			pkgindex=2
@@ -3594,22 +3048,6 @@ class MergeTask(object):
 			bindb  = self.trees[myroot]["bintree"].dbapi
 			vartree = self.trees[myroot]["vartree"]
 			pkgsettings = self.pkgsettings[myroot]
-			metadata = {}
-			if pkg_type == "blocks":
-				pass
-			elif pkg_type == "ebuild":
-				mydbapi = portdb
-				metadata.update(izip(metadata_keys,
-					mydbapi.aux_get(pkg_key, metadata_keys)))
-				pkgsettings.setcpv(pkg_key, mydb=mydbapi)
-				metadata["USE"] = pkgsettings["USE"]
-			else:
-				if pkg_type == "binary":
-					mydbapi = bindb
-				else:
-					raise AssertionError("Package type: '%s'" % pkg_type)
-				metadata.update(izip(metadata_keys,
-					mydbapi.aux_get(pkg_key, metadata_keys)))
 			if x[0]=="blocks":
 				pkgindex=3
 			y = portdb.findname(pkg_key)
@@ -3629,7 +3067,7 @@ class MergeTask(object):
 			#buildsyspkg: Check if we need to _force_ binary package creation
 			issyspkg = ("buildsyspkg" in myfeat) \
 					and x[0] != "blocks" \
-					and system_set.findAtomForPackage(pkg_key, metadata) \
+					and mysysdict.has_key(portage.cpv_getkey(x[2])) \
 					and "--buildpkg" not in self.myopts
 			if x[0] in ["ebuild","blocks"]:
 				if x[0] == "blocks" and "--fetchonly" not in self.myopts:
@@ -3651,7 +3089,6 @@ class MergeTask(object):
 						print "!!! Fetch for",y,"failed, continuing..."
 						print
 						failed_fetches.append(pkg_key)
-					self.curval += 1
 					continue
 
 				portage.doebuild_environment(y, "setup", myroot,
@@ -3696,9 +3133,6 @@ class MergeTask(object):
 						retval = portage.doebuild(y, "package", myroot,
 							pkgsettings, self.edebug, mydbapi=portdb,
 							tree="porttree")
-						if retval != os.EX_OK or \
-							"--buildpkgonly" in self.myopts:
-							portage.elog_process(pkg_key, pkgsettings)
 						if retval != os.EX_OK:
 							return retval
 						bintree = self.trees[myroot]["bintree"]
@@ -3770,36 +3204,15 @@ class MergeTask(object):
 							short_msg = "emerge: (%s of %s) %s Fetch" % \
 								(mergecount, len(mymergelist), pkg_key)
 							emergelog(xterm_titles, msg, short_msg=short_msg)
-							try:
-								self.trees[myroot]["bintree"].gettbz2(pkg_key)
-							except portage_exception.FileNotFound:
-								writemsg("!!! Fetching Binary failed " + \
-									"for '%s'\n" % pkg_key, noiselevel=-1)
-								if not fetchonly:
-									return 1
-								failed_fetches.append(pkg_key)
-							except portage_exception.DigestException, e:
-								writemsg("\n!!! Digest verification failed:\n",
-									noiselevel=-1)
-								writemsg("!!! %s\n" % e.value[0],
-									noiselevel=-1)
-								writemsg("!!! Reason: %s\n" % e.value[1],
-									noiselevel=-1)
-								writemsg("!!! Got: %s\n" % e.value[2],
-									noiselevel=-1)
-								writemsg("!!! Expected: %s\n" % e.value[3],
-									noiselevel=-1)
-								os.unlink(mytbz2)
-								if not fetchonly:
-									return 1
-								failed_fetches.append(pkg_key)
+							if not self.trees[myroot]["bintree"].gettbz2(
+								pkg_key):
+								return 1
 					finally:
 						if tbz2_lock:
 							portage_locks.unlockfile(tbz2_lock)
 
 				if "--fetchonly" in self.myopts or \
 					"--fetch-all-uri" in self.myopts:
-					self.curval += 1
 					continue
 
 				short_msg = "emerge: ("+str(mergecount)+" of "+str(len(mymergelist))+") "+x[pkgindex]+" Merge Binary"
@@ -3815,22 +3228,24 @@ class MergeTask(object):
 				#need to check for errors
 			if "--buildpkgonly" not in self.myopts:
 				self.trees[x[1]]["vartree"].inject(x[2])
-				myfavkey = portage.cpv_getkey(x[2])
-				if not fetchonly and not pretend and \
-					args_set.findAtomForPackage(pkg_key, metadata):
-					world_set.lock()
-					world_set.load()
-					myfavkey = create_world_atom(pkg_key, metadata,
-						args_set, root_config)
-					if myfavkey:
-						world_set.add(myfavkey)
+				myfavkey=portage.cpv_getkey(x[2])
+				if "--fetchonly" not in self.myopts and \
+					"--fetch-all-uri" not in self.myopts and \
+					myfavkey in favorites:
+					myfavs = portage.grabfile(os.path.join(myroot, portage.WORLD_FILE))
+					myfavdict=genericdict(myfavs)
+					#don't record if already in system profile or already recorded
+					if (not mysysdict.has_key(myfavkey)) and (not myfavdict.has_key(myfavkey)):
+						#we don't have a favorites entry for this package yet; add one
+						myfavdict[myfavkey]=myfavkey
 						print ">>> Recording",myfavkey,"in \"world\" favorites file..."
 						emergelog(xterm_titles, " === ("+\
 							str(mergecount)+" of "+\
 							str(len(mymergelist))+\
 							") Updating world file ("+x[pkgindex]+")")
-						world_set.save()
-					world_set.unlock()
+						portage.write_atomic(
+						os.path.join(myroot, portage.WORLD_FILE),
+						"\n".join(myfavdict.values()))
 
 				if "--pretend" not in self.myopts and \
 					"--fetchonly" not in self.myopts and \
@@ -3905,7 +3320,6 @@ class MergeTask(object):
 			# in the event that portage is not allowed to exit normally
 			# due to power failure, SIGKILL, etc...
 			mtimedb.commit()
-			self.curval += 1
 
 		if "--pretend" not in self.myopts:
 			emergelog(xterm_titles, " *** Finished. Cleaning up...")
@@ -4090,32 +3504,9 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 						if y not in pkgmap[mykey]["selected"]:
 							pkgmap[mykey]["selected"].append(y)
 							numselected=numselected+len(mymatch)
-			elif unmerge_action == "prune":
-				if len(mymatch) == 1:
-					continue
-				best_version = mymatch[0]
-				best_slot = vartree.getslot(best_version)
-				best_counter = vartree.dbapi.cpv_counter(best_version)
-				for mypkg in mymatch[1:]:
-					myslot = vartree.getslot(mypkg)
-					mycounter = vartree.dbapi.cpv_counter(mypkg)
-					if (myslot == best_slot and mycounter > best_counter) or \
-						mypkg == portage.best([mypkg, best_version]):
-						if myslot == best_slot:
-							if mycounter < best_counter:
-								# On slot collision, keep the one with the
-								# highest counter since it is the most
-								# recently installed.
-								continue
-						best_version = mypkg
-						best_slot = myslot
-						best_counter = mycounter
-				pkgmap[mykey]["protected"].append(best_version)
-				pkgmap[mykey]["selected"] = [mypkg for mypkg in mymatch \
-					if mypkg != best_version]
-				numselected = numselected + len(pkgmap[mykey]["selected"])
+	
 			else:
-				# unmerge_action == "clean"
+				#unmerge_action in ["prune", clean"]
 				slotmap={}
 				for mypkg in mymatch:
 					if unmerge_action=="clean":
@@ -4127,7 +3518,7 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 					if not slotmap.has_key(myslot):
 						slotmap[myslot]={}
 					slotmap[myslot][localtree.dbapi.cpv_counter(mypkg)]=mypkg
-				for myslot in slotmap:
+				for myslot in slotmap.keys():
 					counterkeys=slotmap[myslot].keys()
 					counterkeys.sort()
 					if not counterkeys:
@@ -4154,7 +3545,7 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 	finally:
 		if vdb_lock:
 			portage_locks.unlockdir(vdb_lock)
-	for x in pkgmap:
+	for x in pkgmap.keys():
 		for y in localtree.dep_match(x):
 			if y not in pkgmap[x]["omitted"] and \
 			   y not in pkgmap[x]["selected"] and \
@@ -4169,13 +3560,9 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 			if "--pretend" not in myopts and "--ask" not in myopts:
 				countdown(int(settings["EMERGE_WARNING_DELAY"]),
 					colorize("UNMERGE_WARN", "Press Ctrl-C to Stop"))
-		if "--quiet" not in myopts:
-			print "\n "+white(x)
-		else:
-			print white(x)+": ",
+		print "\n "+white(x)
 		for mytype in ["selected","protected","omitted"]:
-			if "--quiet" not in myopts:
-				portage.writemsg_stdout((mytype + ": ").rjust(14), noiselevel=-1)
+			portage.writemsg_stdout((mytype + ": ").rjust(14), noiselevel=-1)
 			if pkgmap[x][mytype]:
 				for mypkg in pkgmap[x][mytype]:
 					mysplit=portage.catpkgsplit(mypkg)
@@ -4190,10 +3577,7 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 						portage.writemsg_stdout(
 							colorize("GOOD", myversion + " "), noiselevel=-1)
 			else:
-				portage.writemsg_stdout("none ", noiselevel=-1)
-			if "--quiet" not in myopts:
-				portage.writemsg_stdout("\n", noiselevel=-1)
-		if "--quiet" in myopts:
+				portage.writemsg_stdout("none", noiselevel=-1)
 			portage.writemsg_stdout("\n", noiselevel=-1)
 
 	portage.writemsg_stdout("\n>>> " + colorize("UNMERGE_WARN", "'Selected'") + \
@@ -4217,7 +3601,7 @@ def unmerge(settings, myopts, vartree, unmerge_action, unmerge_files,
 	if not autoclean:
 		countdown(int(settings["CLEAN_DELAY"]), ">>> Unmerging")
 
-	for x in pkgmap:
+	for x in pkgmap.keys():
 		for y in pkgmap[x]["selected"]:
 			print ">>> Unmerging "+y+"..."
 			emergelog(xterm_titles, "=== Unmerging... ("+y+")")
@@ -4340,11 +3724,6 @@ def post_emerge(settings, mtimedb, retval):
 	emergelog("notitles" not in settings.features,
 		" *** exiting successfully.")
 
-	# Dump the mod_echo output now so that our other notifications are shown
-	# last.
-	from elog_modules import mod_echo
-	mod_echo.finalize()
-
 	if "noinfo" not in settings.features:
 		chk_updated_info_files(target_root, infodirs, info_mtimes, retval)
 
@@ -4364,17 +3743,17 @@ def chk_updated_cfg_files(target_root, config_protect):
 			except OSError:
 				continue
 			if stat.S_ISDIR(mymode):
-				mycommand = "find '%s' -iname '._cfg????_*'" % x
+				mycommand = "cd '%s'; find . -iname '._cfg????_*'" % x
 			else:
-				mycommand = "find '%s' -maxdepth 1 -iname '._cfg????_%s'" % \
+				mycommand = "cd '%s'; find . -maxdepth 1 -iname '._cfg????_%s'" % \
 					os.path.split(x.rstrip(os.path.sep))
 			a = commands.getstatusoutput(mycommand + \
-				" ! -iname '.*~' ! -iname '.*.bak' -print0")
+				" ! -iname '.*~' ! -iname '.*.bak'")
 			if a[0] != 0:
 				print >> sys.stderr, " " + bad("*")+ " error scanning '%s'" % x
 			else:
-				files = a[1].split('\0')
-				if files != ['']:
+				files = a[1].split()
+				if files:
 					procount += 1
 					print colorize("WARN", " * IMPORTANT:"),
 					if stat.S_ISDIR(mymode):
@@ -4384,9 +3763,8 @@ def chk_updated_cfg_files(target_root, config_protect):
 						 print "config file '%s' needs updating." % x
 
 		if procount:
-			print " "+yellow("*")+" See the "+colorize("INFORM","CONFIGURATION FILES")+ \
-				" section of the " + bold("emerge")
-			print " "+yellow("*")+" man page to learn how to update config files."
+			#print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
+			print " "+yellow("*")+" Type "+green("emerge --help config")+" to learn how to update config files."
 
 def is_valid_package_atom(x):
 	try:
@@ -4401,6 +3779,20 @@ def is_valid_package_atom(x):
 		testatom = x
 	return portage.isvalidatom(testatom)
 
+def validate_merge_list(trees, mergelist):
+	"""Validate the list to make sure all the packages are still available.
+	This is needed for --resume."""
+	for (pkg_type, myroot, pkg_key, action) in mergelist:
+		if pkg_type == "binary" and \
+			not trees[myroot]["bintree"].dbapi.match("="+pkg_key) or \
+			pkg_type == "ebuild" and \
+			not trees[myroot]["porttree"].dbapi.xmatch(
+			"match-all", "="+pkg_key):
+			print red("!!! Error: The resume list contains packages that are no longer")
+			print red("!!!        available to be emerged. Please restart/continue")
+			print red("!!!        the merge operation manually.")
+			sys.exit(1)
+
 def show_blocker_docs_link():
 	print
 	print "For more information about " + bad("Blocked Packages") + ", please refer to the following"
@@ -4833,7 +4225,7 @@ def action_sync(settings, trees, mtimedb, myopts, myaction):
 	if os.path.exists(myportdir+"/metadata/cache") and updatecache_flg:
 		action_metadata(settings, portdb, myopts)
 
-	if portage._global_updates(trees, mtimedb["updates"]):
+	if portage.global_updates(settings, trees, mtimedb["updates"]):
 		mtimedb.commit()
 		# Reload the whole config from scratch.
 		settings, trees, mtimedb = load_emerge_config(trees=trees)
@@ -4857,8 +4249,9 @@ def action_sync(settings, trees, mtimedb, myopts, myaction):
 		print
 		print red(" * ")+bold("An update to portage is available.")+" It is _highly_ recommended"
 		print red(" * ")+"that you update portage now, before any other packages are updated."
-		print
-		print red(" * ")+"To update portage, run 'emerge portage' now."
+		print red(" * ")+"Please run 'emerge portage' and then update "+bold("ALL")+" of your"
+		print red(" * ")+"configuration files."
+		print red(" * ")+"To update portage, run 'emerge portage'."
 		print
 
 def action_metadata(settings, portdb, myopts):
@@ -5171,12 +4564,7 @@ def action_info(settings, trees, myopts, myfiles):
 
 		# Loop through each package
 		# Only print settings if they differ from global settings
-		header_title = "Package Settings"
-		print header_width * "="
-		print header_title.rjust(int(header_width/2 + len(header_title)/2))
-		print header_width * "="
-		from output import EOutput
-		out = EOutput()
+		header_printed = False
 		for pkg in mypkgs:
 			# Get all package specific variables
 			auxvalues = vardb.aux_get(pkg, auxkeys)
@@ -5206,6 +4594,16 @@ def action_info(settings, trees, myopts, myfiles):
 			# If a difference was found, print the info for
 			# this package.
 			if diff_values:
+
+				# If we have not yet printed the header, 
+				# print it now
+				if not header_printed:
+					header_title = "Package Settings"
+					print header_width * "="
+					print header_title.rjust(int(header_width/2 + len(header_title)/2))
+					print header_width * "="
+					header_printed = True
+
 				# Print package info
 				print "%s was built with the following:" % pkg
 				for myvar in mydesiredvars + ["USE"]:
@@ -5214,15 +4612,6 @@ def action_info(settings, trees, myopts, myfiles):
 						mylist.sort()
 						print "%s=\"%s\"" % (myvar, " ".join(mylist))
 				print
-			print ">>> Attempting to run pkg_info() for '%s'" % pkg
-			ebuildpath = vardb.findname(pkg)
-			if not ebuildpath or not os.path.exists(ebuildpath):
-				out.ewarn("No ebuild found for '%s'" % pkg)
-				continue
-			portage.doebuild(ebuildpath, "info", pkgsettings["ROOT"],
-				pkgsettings, debug=(settings.get("PORTAGE_DEBUG", "") == 1),
-				mydbapi=trees[settings["ROOT"]]["vartree"].dbapi,
-				tree="vartree")
 
 def action_search(settings, portdb, vartree, myopts, myfiles, spinner):
 	if not myfiles:
@@ -5240,35 +4629,30 @@ def action_search(settings, portdb, vartree, myopts, myfiles, spinner):
 			searchinstance.output()
 
 def action_depclean(settings, trees, ldpath_mtimes,
-	myopts, action, myfiles, spinner):
+	myopts, spinner):
 	# Kill packages that aren't explicitly merged or are required as a
 	# dependency of another package. World file is explicit.
 
-	msg = []
-	msg.append("Depclean may break link level dependencies.  Thus, it is\n")
-	msg.append("recommended to use a tool such as " + good("`revdep-rebuild`") + " (from\n")
-	msg.append("app-portage/gentoolkit) in order to detect such breakage.\n")
-	msg.append("\n")
-	msg.append("Also study the list of packages to be cleaned for any obvious\n")
-	msg.append("mistakes. Packages that are part of the world set will always\n")
-	msg.append("be kept.  They can be manually added to this set with\n")
-	msg.append(good("`emerge --noreplace <atom>`") + ".  Packages that are listed in\n")
-	msg.append("package.provided (see portage(5)) will be removed by\n")
-	msg.append("depclean, even if they are part of the world set.\n")
-	msg.append("\n")
-	msg.append("As a safety measure, depclean will not remove any packages\n")
-	msg.append("unless *all* required dependencies have been resolved.  As a\n")
-	msg.append("consequence, it is often necessary to run\n")
-	msg.append(good("`emerge --update --newuse --deep world`") + " prior to depclean.\n")
-
-	if action == "depclean" and "--quiet" not in myopts and not myfiles:
-		portage.writemsg_stdout("\n")
-		for x in msg:
-			portage.writemsg_stdout(colorize("BAD", "*** WARNING ***  ") + x)
+	warn_prefix = colorize("BAD", "*** WARNING ***  ")
+	print
+	print warn_prefix + "Depclean may break link level dependencies.  Thus, it is"
+	print warn_prefix + "recommended to use a tool such as " + good("`revdep-rebuild`") + " (from"
+	print warn_prefix + "app-portage/gentoolkit) in order to detect such breakage."
+	print warn_prefix
+	print warn_prefix + "Also study the list of packages to be cleaned for any obvious"
+	print warn_prefix + "mistakes. Packages that are part of the world set will always"
+	print warn_prefix + "be kept.  They can be manually added to this set with"
+	print warn_prefix + good("`emerge --noreplace <atom>`") + ".  Packages that are listed in"
+	print warn_prefix + "package.provided (see portage(5)) will be removed by"
+	print warn_prefix + "depclean, even if they are part of the world set."
+	print warn_prefix
+	print warn_prefix + "As a safety measure, depclean will not remove any packages"
+	print warn_prefix + "unless *all* required dependencies have been resolved.  As a"
+	print warn_prefix + "consequence, it is often necessary to run "
+	print warn_prefix + good("`emerge --update --newuse --deep world`") + " prior to depclean."
 
 	xterm_titles = "notitles" not in settings.features
 	myroot = settings["ROOT"]
-	portdb = trees[myroot]["porttree"].dbapi
 	dep_check_trees = {}
 	dep_check_trees[myroot] = {}
 	dep_check_trees[myroot]["vartree"] = \
@@ -5276,12 +4660,10 @@ def action_depclean(settings, trees, ldpath_mtimes,
 	vardb = dep_check_trees[myroot]["vartree"].dbapi
 	# Constrain dependency selection to the installed packages.
 	dep_check_trees[myroot]["porttree"] = dep_check_trees[myroot]["vartree"]
-	system_set = SystemSet(settings)
-	syslist = list(system_set)
-	world_set = WorldSet(settings)
-	world_set.load()
-	worldlist = list(world_set)
-	args_set = AtomSet()
+	syslist = getlist(settings, "system")
+	worldlist = getlist(settings, "world")
+	system_world_dict = genericdict(worldlist)
+	system_world_dict.update(genericdict(syslist))
 	fakedb = portage.fakedbapi(settings=settings)
 	myvarlist = vardb.cpv_all()
 
@@ -5298,65 +4680,18 @@ def action_depclean(settings, trees, ldpath_mtimes,
 		if "--pretend" not in myopts:
 			countdown(int(settings["EMERGE_WARNING_DELAY"]), ">>> Depclean")
 
-	if action == "depclean":
+	if not "--pretend" in myopts: #just check pretend, since --ask implies pretend
 		emergelog(xterm_titles, " >>> depclean")
-	if myfiles:
-		for x in myfiles:
-			if not is_valid_package_atom(x):
-				portage.writemsg("!!! '%s' is not a valid package atom.\n" % x,
-					noiselevel=-1)
-				portage.writemsg("!!! Please check ebuild(5) for full details.\n")
-				return
-			try:
-				atom = portage.dep_expand(x, mydb=vardb, settings=settings)
-			except ValueError, e:
-				print "!!! The short ebuild name \"" + x + "\" is ambiguous.  Please specify"
-				print "!!! one of the following fully-qualified ebuild names instead:\n"
-				for i in e[0]:
-					print "    " + colorize("INFORM", i)
-				print
-				return
-			args_set.add(atom)
-		matched_packages = False
-		for x in args_set:
-			if vardb.match(x):
-				matched_packages = True
-				break
-		if not matched_packages:
-			portage.writemsg_stdout(
-				">>> No packages selected for removal by %s\n" % action)
-			return
 
 	if "--quiet" not in myopts:
 		print "\nCalculating dependencies  ",
 
 	soft = 0
 	hard = 1
-	remaining_atoms = []
-	if action == "depclean":
-		for atom in worldlist:
-			if vardb.match(atom):
-				remaining_atoms.append((atom, 'world', hard))
-		for atom in syslist:
-			if vardb.match(atom):
-				remaining_atoms.append((atom, 'system', hard))
-	elif action == "prune":
-		for atom in syslist:
-			if vardb.match(atom):
-				remaining_atoms.append((atom, 'system', hard))
-		# Pull in everything that's installed since we don't want to prune a
-		# package if something depends on it.
-		remaining_atoms.extend((atom, 'world', hard) for atom in vardb.cp_all())
-		if not myfiles:
-			# Try to prune everything that's slotted.
-			for cp in vardb.cp_all():
-				if len(vardb.cp_list(cp)) > 1:
-					args_set.add(cp)
-
+	remaining_atoms = [(atom, 'world', hard) for atom in worldlist if vardb.match(atom)]
+	remaining_atoms += [(atom, 'system', hard) for atom in syslist if vardb.match(atom)]
 	unresolveable = {}
 	aux_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
-	metadata_keys = ["PROVIDE", "SLOT", "USE"]
-	graph = digraph()
 
 	while remaining_atoms:
 		atom, parent, priority = remaining_atoms.pop()
@@ -5365,58 +4700,13 @@ def action_depclean(settings, trees, ldpath_mtimes,
 			if not atom.startswith("!") and priority == hard:
 				unresolveable.setdefault(atom, []).append(parent)
 			continue
-		if action == "depclean" and parent == "world" and myfiles:
-			# Filter out packages given as arguments since the user wants
-			# to remove those.
-			filtered_pkgs = []
-			for pkg in pkgs:
-				metadata = dict(izip(metadata_keys,
-					vardb.aux_get(pkg, metadata_keys)))
-				arg_atom = None
-				try:
-					arg_atom = args_set.findAtomForPackage(pkg, metadata)
-				except portage_exception.InvalidDependString, e:
-					file_path = os.path.join(myroot, VDB_PATH, pkg, "PROVIDE")
-					portage.writemsg("\n\nInvalid PROVIDE: %s\n" % str(s),
-						noiselevel=-1)
-					portage.writemsg("See '%s'\n" % file_path,
-						noiselevel=-1)
-					del e
-				if not arg_atom:
-					filtered_pkgs.append(pkg)
-			pkgs = filtered_pkgs
-		prune_this = False
-		if action == "prune":
-			for pkg in pkgs:
-				metadata = dict(izip(metadata_keys,
-					vardb.aux_get(pkg, metadata_keys)))
-				try:
-					arg_atom = args_set.findAtomForPackage(pkg, metadata)
-				except portage_exception.InvalidDependString, e:
-					file_path = os.path.join(myroot, VDB_PATH, pkg, "PROVIDE")
-					portage.writemsg("\n\nInvalid PROVIDE: %s\n" % str(s),
-						noiselevel=-1)
-					portage.writemsg("See '%s'\n" % file_path,
-						noiselevel=-1)
-					del e
-					continue
-				if arg_atom:
-					prune_this = True
-					break
-		if len(pkgs) > 1 and (parent != "world" or prune_this):
+		if portage.dep_getkey(atom) not in system_world_dict:
 			# Prune all but the best matching slot, since that's all that a
-			# deep world update would pull in.  Don't prune if this atom comes
-			# directly from world though, since world atoms are greedy when
-			# they don't specify a slot.
-			visible_in_portdb = [cpv for cpv in pkgs if portdb.match("="+cpv)]
-			if visible_in_portdb:
-				# For consistency with the update algorithm, keep the highest
-				# visible version and prune any versions that are either masked
-				# or no longer exist in the portage tree.
-				pkgs = visible_in_portdb
+			# deep world update would pull in.  Don't prune if the cpv is in
+			# system or world though, since those sets trigger greedy update
+			# of all slots.
 			pkgs = [portage.best(pkgs)]
 		for pkg in pkgs:
-			graph.add(pkg, parent)
 			if fakedb.cpv_exists(pkg):
 				continue
 			spinner.update()
@@ -5470,88 +4760,21 @@ def action_depclean(settings, trees, ldpath_mtimes,
 		print
 		for atom in unresolveable:
 			print atom, "required by", " ".join(unresolveable[atom])
-	if unresolveable:
 		print
 		print "Have you forgotten to run " + good("`emerge --update --newuse --deep world`") + " prior to"
-		print "%s?  It may be necessary to manually uninstall packages that no longer" % action
+		print "depclean?  It may be necessary to manually uninstall packages that no longer"
 		print "exist in the portage tree since it may not be possible to satisfy their"
 		print "dependencies.  Also, be aware of the --with-bdeps option that is documented"
 		print "in " + good("`man emerge`") + "."
 		print
-		if action == "prune":
-			print "If you would like to ignore dependencies then use %s." % \
-				good("--nodeps")
 		return
 
-	def show_parents(child_node):
-		parent_nodes = graph.parent_nodes(child_node)
-		if not parent_nodes:
-			# With --prune, the highest version can be pulled in without any
-			# real parent since all installed packages are pulled in.  In that
-			# case there's nothing to show here.
-			return
-		parent_nodes.sort()
-		msg = []
-		msg.append("  %s pulled in by:\n" % str(child_node))
-		for parent_node in parent_nodes:
-			msg.append("    %s\n" % str(parent_node))
-		msg.append("\n")
-		portage.writemsg_stdout("".join(msg), noiselevel=-1)
-
-	cleanlist = []
-	if action == "depclean":
-		if myfiles:
-			for pkg in vardb.cpv_all():
-				metadata = dict(izip(metadata_keys,
-					vardb.aux_get(pkg, metadata_keys)))
-				arg_atom = None
-				try:
-					arg_atom = args_set.findAtomForPackage(pkg, metadata)
-				except portage_exception.InvalidDependString:
-					# this error has already been displayed by now
-					continue
-				if arg_atom:
-					if not fakedb.cpv_exists(pkg):
-						cleanlist.append(pkg)
-					elif "--verbose" in myopts:
-						show_parents(pkg)
-		else:
-			for pkg in vardb.cpv_all():
-				if not fakedb.cpv_exists(pkg):
-					cleanlist.append(pkg)
-				elif "--verbose" in myopts:
-					show_parents(pkg)
-	elif action == "prune":
-		# Prune really uses all installed instead of world.  It's not a real
-		# reverse dependency so don't display it as such.
-		if graph.contains("world"):
-			graph.remove("world")
-		for atom in args_set:
-			for pkg in vardb.match(atom):
-				if not fakedb.cpv_exists(pkg):
-					cleanlist.append(pkg)
-				elif "--verbose" in myopts:
-					show_parents(pkg)
-
-	if not cleanlist:
-		portage.writemsg_stdout(
-			">>> No packages selected for removal by %s\n" % action)
-		if "--verbose" not in myopts:
-			portage.writemsg_stdout(
-				">>> To see reverse dependencies, use %s\n" % \
-					good("--verbose"))
-		if action == "prune":
-			portage.writemsg_stdout(
-				">>> To ignore dependencies, use %s\n" % \
-					good("--nodeps"))
+	cleanlist = [pkg for pkg in vardb.cpv_all() if not fakedb.cpv_exists(pkg)]
 
 	if len(cleanlist):
 		unmerge(settings, myopts, trees[settings["ROOT"]]["vartree"],
 			"unmerge", cleanlist, ldpath_mtimes)
 
-	if action == "prune":
-		return
-
 	print "Packages installed:   "+str(len(myvarlist))
 	print "Packages in world:    "+str(len(worldlist))
 	print "Packages in system:   "+str(len(syslist))
@@ -5566,20 +4789,12 @@ def action_build(settings, trees, mtimedb,
 	myopts, myaction, myfiles, spinner):
 	ldpath_mtimes = mtimedb["ldpath"]
 	favorites=[]
-	merge_count = 0
-	pretend = "--pretend" in myopts
-	fetchonly = "--fetchonly" in myopts or "--fetch-all-uri" in myopts
-	if pretend or fetchonly:
-		# make the mtimedb readonly
-		mtimedb.filename = None
 	if "--quiet" not in myopts and \
 		("--pretend" in myopts or "--ask" in myopts or \
 		"--tree" in myopts or "--verbose" in myopts):
 		action = ""
 		if "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
 			action = "fetched"
-		elif "--buildpkgonly" in myopts:
-			action = "built"
 		else:
 			action = "merged"
 		if "--tree" in myopts and action != "fetched": # Tree doesn't work with fetching
@@ -5608,6 +4823,16 @@ def action_build(settings, trees, mtimedb,
 			mtimedb["resume"] = mtimedb["resume_backup"]
 			del mtimedb["resume_backup"]
 			mtimedb.commit()
+		# XXX: "myopts" is a list for backward compatibility.
+		myresumeopts = dict([(k,True) for k in mtimedb["resume"]["myopts"]])
+
+		for opt in ("--skipfirst", "--ask", "--tree"):
+			myresumeopts.pop(opt, None)
+
+		for myopt, myarg in myopts.iteritems():
+			if myopt not in myresumeopts:
+				myresumeopts[myopt] = myarg
+		myopts=myresumeopts
 
 		# Adjust config according to options of the command being resumed.
 		for myroot in trees:
@@ -5617,38 +4842,17 @@ def action_build(settings, trees, mtimedb,
 			mysettings.lock()
 			del myroot, mysettings
 
-		# "myopts" is a list for backward compatibility.
-		resume_opts = mtimedb["resume"].get("myopts", [])
-		if isinstance(resume_opts, list):
-			resume_opts = dict((k,True) for k in resume_opts)
-		for opt in ("--skipfirst", "--ask", "--tree"):
-			resume_opts.pop(opt, None)
-		myopts.update(resume_opts)
-		show_spinner = "--quiet" not in myopts and "--nodeps" not in myopts
-		if not show_spinner:
-			spinner.update = spinner.update_quiet
-		if show_spinner:
-			print "Calculating dependencies  ",
 		myparams = create_depgraph_params(myopts, myaction)
+		if "--quiet" not in myopts and "--nodeps" not in myopts:
+			print "Calculating dependencies  ",
 		mydepgraph = depgraph(settings, trees,
 			myopts, myparams, spinner)
-		try:
-			mydepgraph.loadResumeCommand(mtimedb["resume"])
-		except portage_exception.PackageNotFound:
-			if show_spinner:
-				print
-			from output import EOutput
-			out = EOutput()
-			out.eerror("Error: The resume list contains packages that are no longer")
-			out.eerror("       available to be emerged. Please restart/continue")
-			out.eerror("       the merge operation manually.")
-			return 1
-		if show_spinner:
+		if "--quiet" not in myopts and "--nodeps" not in myopts:
 			print "\b\b... done!"
 	else:
 		if ("--resume" in myopts):
 			print darkgreen("emerge: It seems we have nothing to resume...")
-			return os.EX_OK
+			sys.exit(0)
 
 		myparams = create_depgraph_params(myopts, myaction)
 		if myaction in ["system","world"]:
@@ -5658,7 +4862,7 @@ def action_build(settings, trees, mtimedb,
 			mydepgraph = depgraph(settings, trees, myopts, myparams, spinner)
 			if not mydepgraph.xcreate(myaction):
 				print "!!! Depgraph creation failed."
-				return 1
+				sys.exit(1)
 			if "--quiet" not in myopts and "--nodeps" not in myopts:
 				print "\b\b... done!"
 		else:
@@ -5670,9 +4874,9 @@ def action_build(settings, trees, mtimedb,
 				retval, favorites = mydepgraph.select_files(myfiles)
 			except portage_exception.PackageNotFound, e:
 				portage.writemsg("\n!!! %s\n" % str(e), noiselevel=-1)
-				return 1
+				sys.exit(1)
 			if not retval:
-				return 1
+				sys.exit(1)
 			if "--quiet" not in myopts and "--nodeps" not in myopts:
 				print "\b\b... done!"
 
@@ -5683,30 +4887,25 @@ def action_build(settings, trees, mtimedb,
 			for x in mydepgraph.missingbins:
 				sys.stderr.write("   "+str(x)+"\n")
 			sys.stderr.write("\nThese are required by '--usepkgonly' -- Terminating.\n\n")
-			return 1
+			sys.exit(1)
 
 	if "--pretend" not in myopts and \
 		("--ask" in myopts or "--tree" in myopts or \
 		"--verbose" in myopts) and \
 		not ("--quiet" in myopts and "--ask" not in myopts):
 		if "--resume" in myopts:
+			validate_merge_list(trees, mtimedb["resume"]["mergelist"])
 			mymergelist = mtimedb["resume"]["mergelist"]
 			if "--skipfirst" in myopts:
 				mymergelist = mymergelist[1:]
 			if len(mymergelist) == 0:
 				print colorize("INFORM", "emerge: It seems we have nothing to resume...")
-				return os.EX_OK
-			favorites = mtimedb["resume"]["favorites"]
-			retval = mydepgraph.display(mymergelist, favorites=favorites)
-			if retval != os.EX_OK:
-				return retval
+				sys.exit(0)
+			mydepgraph.display(mymergelist)
 			prompt="Would you like to resume merging these packages?"
 		else:
-			retval = mydepgraph.display(
-				mydepgraph.altlist(reversed=("--tree" in myopts)),
-				favorites=favorites)
-			if retval != os.EX_OK:
-				return retval
+			mydepgraph.display(
+				mydepgraph.altlist(reversed=("--tree" in myopts)))
 			mergecount=0
 			for x in mydepgraph.altlist():
 				if x[0] != "blocks" and x[3] != "nomerge":
@@ -5717,7 +4916,7 @@ def action_build(settings, trees, mtimedb,
 					print   "!!!        at the same time on the same system."
 					if "--quiet" not in myopts:
 						show_blocker_docs_link()
-					return 1
+					sys.exit(1)
 			if mergecount==0:
 				if "--noreplace" in myopts and favorites:
 					print
@@ -5730,7 +4929,7 @@ def action_build(settings, trees, mtimedb,
 					print
 					print "Nothing to merge; quitting."
 					print
-					return os.EX_OK
+					sys.exit(0)
 			elif "--fetchonly" in myopts or "--fetch-all-uri" in myopts:
 				prompt="Would you like to fetch the source files for these packages?"
 			else:
@@ -5740,39 +4939,29 @@ def action_build(settings, trees, mtimedb,
 			print
 			print "Quitting."
 			print
-			return os.EX_OK
+			sys.exit(0)
 		# Don't ask again (e.g. when auto-cleaning packages after merge)
 		myopts.pop("--ask", None)
 
 	if ("--pretend" in myopts) and not ("--fetchonly" in myopts or "--fetch-all-uri" in myopts):
 		if ("--resume" in myopts):
+			validate_merge_list(trees, mtimedb["resume"]["mergelist"])
 			mymergelist = mtimedb["resume"]["mergelist"]
 			if "--skipfirst" in myopts:
 				mymergelist = mymergelist[1:]
 			if len(mymergelist) == 0:
 				print colorize("INFORM", "emerge: It seems we have nothing to resume...")
-				return os.EX_OK
-			favorites = mtimedb["resume"]["favorites"]
-			retval = mydepgraph.display(mymergelist, favorites=favorites)
-			if retval != os.EX_OK:
-				return retval
+				sys.exit(0)
+			mydepgraph.display(mymergelist)
 		else:
-			retval = mydepgraph.display(
-				mydepgraph.altlist(reversed=("--tree" in myopts)),
-				favorites=favorites)
-			if retval != os.EX_OK:
-				return retval
-			if "--buildpkgonly" in myopts and \
-				not mydepgraph.digraph.hasallzeros(ignore_priority=DepPriority.MEDIUM):
-					print "\n!!! --buildpkgonly requires all dependencies to be merged."
-					print "!!! You have to merge the dependencies before you can build this package.\n"
-					return 1
+			mydepgraph.display(
+				mydepgraph.altlist(reversed=("--tree" in myopts)))
 	else:
 		if ("--buildpkgonly" in myopts):
 			if not mydepgraph.digraph.hasallzeros(ignore_priority=DepPriority.MEDIUM):
 				print "\n!!! --buildpkgonly requires all dependencies to be merged."
 				print "!!! Cannot merge requested packages. Merge deps and try again.\n"
-				return 1
+				sys.exit(1)
 
 		if ("--resume" in myopts):
 			favorites=mtimedb["resume"]["favorites"]
@@ -5785,7 +4974,8 @@ def action_build(settings, trees, mtimedb,
 			del mydepgraph
 			retval = mergetask.merge(
 				mtimedb["resume"]["mergelist"], favorites, mtimedb)
-			merge_count = mergetask.curval
+			if retval != os.EX_OK:
+				sys.exit(retval)
 		else:
 			if "resume" in mtimedb and \
 			"mergelist" in mtimedb["resume"] and \
@@ -5818,28 +5008,23 @@ def action_build(settings, trees, mtimedb,
 						pkglist.append(pkg)
 			else:
 				pkglist = mydepgraph.altlist()
-			if favorites:
-				mydepgraph.saveNomergeFavorites()
 			del mydepgraph
 			mergetask = MergeTask(settings, trees, myopts)
 			retval = mergetask.merge(pkglist, favorites, mtimedb)
-			merge_count = mergetask.curval
-
-		if retval == os.EX_OK and not (pretend or fetchonly):
-			mtimedb.pop("resume", None)
-			if "yes" == settings.get("AUTOCLEAN"):
-				portage.writemsg_stdout(">>> Auto-cleaning packages...\n")
-				vartree = trees[settings["ROOT"]]["vartree"]
-				unmerge(settings, myopts, vartree, "clean", ["world"],
-					ldpath_mtimes, autoclean=1)
-			else:
-				portage.writemsg_stdout(colorize("WARN", "WARNING:")
-					+ " AUTOCLEAN is disabled.  This can cause serious"
-					+ " problems due to overlapping packages.\n")
+			if retval != os.EX_OK:
+				sys.exit(retval)
 
-		if merge_count and not (pretend or fetchonly):
-			post_emerge(settings, mtimedb, retval)
-		return retval
+		if mtimedb.has_key("resume"):
+			del mtimedb["resume"]
+		if settings["AUTOCLEAN"] and "yes"==settings["AUTOCLEAN"]:
+			portage.writemsg_stdout(">>> Auto-cleaning packages...\n")
+			vartree = trees[settings["ROOT"]]["vartree"]
+			unmerge(settings, myopts, vartree, "clean", ["world"],
+				ldpath_mtimes, autoclean=1)
+		else:
+			portage.writemsg_stdout(colorize("WARN", "WARNING:")
+				+ " AUTOCLEAN is disabled.  This can cause serious"
+				+ " problems due to overlapping packages.\n")
 
 def multiple_actions(action1, action2):
 	sys.stderr.write("\n!!! Multiple actions requested... Please choose one only.\n")
@@ -5868,11 +5053,6 @@ def parse_opts(tmpcmdline, silent=False):
 			"help":"include unnecessary build time dependencies",
 			"type":"choice",
 			"choices":("y", "n")
-		},
-		"--reinstall": {
-			"help":"specify conditions to trigger package reinstallation",
-			"type":"choice",
-			"choices":["changed-use"]
 		}
 	}
 
@@ -6081,7 +5261,7 @@ def emerge_main():
 		portage.writemsg("!!! %s\n" % str(e))
 		del e
 
-	if portage._global_updates(trees, mtimedb["updates"]):
+	if portage.global_updates(settings, trees, mtimedb["updates"]):
 		mtimedb.commit()
 		# Reload the whole config from scratch.
 		settings, trees, mtimedb = load_emerge_config(trees=trees)
@@ -6090,7 +5270,7 @@ def emerge_main():
 	xterm_titles = "notitles" not in settings.features
 
 	tmpcmdline = []
-	if "--ignore-default-opts" not in myopts:
+	if "--ignore-default-opts" not in sys.argv:
 		tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())
 	tmpcmdline.extend(sys.argv[1:])
 	myaction, myopts, myfiles = parse_opts(tmpcmdline)
@@ -6143,6 +5323,7 @@ def emerge_main():
 	for x in myfiles:
 		ext = os.path.splitext(x)[1]
 		if (ext == ".ebuild" or ext == ".tbz2") and os.path.exists(os.path.abspath(x)):
+			print "emerging by path implies --oneshot... adding --oneshot to options."
 			print colorize("BAD", "\n*** emerging by path is broken and may not always work!!!\n")
 			break
 
@@ -6245,12 +5426,12 @@ def emerge_main():
 	# check if root user is the current user for the actions where emerge needs this
 	if portage.secpass < 2:
 		# We've already allowed "--version" and "--help" above.
-		if "--pretend" not in myopts and myaction not in ("search","info"):
+		if "--pretend" not in myopts and \
+		myaction not in ("search","info"):
 			need_superuser = not \
 				("--fetchonly" in myopts or \
 				"--fetch-all-uri" in myopts or \
-				myaction in ("metadata", "regen") or \
-				(myaction == "sync" and os.access(settings["PORTDIR"], os.W_OK)))
+				myaction in ("metadata", "regen"))
 			if portage.secpass < 1 or \
 				need_superuser:
 				if need_superuser:
@@ -6263,12 +5444,12 @@ def emerge_main():
 				if "--ask" in myopts:
 					myopts["--pretend"] = True
 					del myopts["--ask"]
-					print ("%s access is required... " + \
+					print ("%s access would be required... " + \
 						"adding --pretend to options.\n") % access_desc
 					if portage.secpass < 1 and not need_superuser:
 						portage_group_warning()
 				else:
-					sys.stderr.write(("emerge: %s access is " + \
+					sys.stderr.write(("emerge: %s access would be " + \
 						"required.\n\n") % access_desc)
 					if portage.secpass < 1 and not need_superuser:
 						portage_group_warning()
@@ -6344,8 +5525,7 @@ def emerge_main():
 		validate_ebuild_environment(trees)
 		action_search(settings, portdb, trees["/"]["vartree"],
 			myopts, myfiles, spinner)
-	elif myaction in ("clean", "unmerge") or \
-		(myaction == "prune" and "--nodeps" in myopts):
+	elif "unmerge"==myaction or "prune"==myaction or "clean"==myaction:
 		validate_ebuild_environment(trees)
 		vartree = trees[settings["ROOT"]]["vartree"]
 		if 1 == unmerge(settings, myopts, vartree, myaction, myfiles,
@@ -6353,24 +5533,20 @@ def emerge_main():
 			if "--pretend" not in myopts:
 				post_emerge(settings, mtimedb, 0)
 
-	elif myaction in ("depclean", "prune"):
+	elif "depclean"==myaction:
 		validate_ebuild_environment(trees)
 		action_depclean(settings, trees, mtimedb["ldpath"],
-			myopts, myaction, myfiles, spinner)
+			myopts, spinner)
 		if "--pretend" not in myopts:
 			post_emerge(settings, mtimedb, 0)
 	# "update", "system", or just process files:
 	else:
 		validate_ebuild_environment(trees)
-		retval = action_build(settings, trees, mtimedb,
+		action_build(settings, trees, mtimedb,
 			myopts, myaction, myfiles, spinner)
-		return retval
+		if "--pretend" not in myopts:
+			post_emerge(settings, mtimedb, 0)
 
 if __name__ == "__main__":
-	from portage_exception import PermissionDenied
-	try:
-		retval = emerge_main()
-	except PermissionDenied, e:
-		sys.stderr.write("Permission denied: '%s'\n" % str(e))
-		sys.exit(e.errno)
+	retval = emerge_main()
 	sys.exit(retval)