Attachment #269911 for bug #363137




from portage import _unicode_decode
from portage.const import PORTAGE_PACKAGE_ATOM
from portage.dbapi import dbapi
from portage.dep import Atom, extract_affecting_use, check_required_use, human_readable_required_use
from portage.eapi import eapi_has_strong_blocks, eapi_has_required_use
from portage.exception import InvalidAtom, InvalidDependString
from portage.output import colorize, create_color_func, \

from _emerge.UnmergeDepPriority import UnmergeDepPriority
from _emerge.UseFlagDisplay import pkg_use_display

from _emerge.resolver.backtracking import Backtracker, BacktrackParameter
from _emerge.resolver.slot_collision import slot_conflict_handler
from _emerge.resolver.circular_dependency import circular_dependency_handler
from _emerge.resolver.output import display

if sys.hexversion >= 0x3000000:
	basestring = str

		# contains all sets added to the graph
		self.sets = {}
		# contains non-set atoms given as arguments
		self.sets['__non_set_args__'] = InternalPackageSet()
		# contains all atoms from all sets added to the graph, including
		# atoms given as arguments
		self.atoms = InternalPackageSet()
		self.atom_arg_map = {}

class _dynamic_depgraph_config(object):

	def __init__(self, depgraph, myparams, allow_backtracking,
		runtime_pkg_mask, needed_unstable_keywords, needed_use_config_changes, needed_license_changes):
		self.myparams = myparams.copy()
		self._vdb_loaded = False
		self._allow_backtracking = allow_backtracking

		self._ignored_deps = []
		self._highest_pkg_cache = {}

		if runtime_pkg_mask is None:
			runtime_pkg_mask = {}
		else:
			runtime_pkg_mask = dict((k, v.copy()) for (k, v) in \
				runtime_pkg_mask.items())

		if needed_unstable_keywords is None:
			self._needed_unstable_keywords = set()
		else:
			self._needed_unstable_keywords = needed_unstable_keywords.copy()

		if needed_license_changes is None:
			self._needed_license_changes = {}
		else:
			self._needed_license_changes = needed_license_changes.copy()

		if needed_use_config_changes is None:
			self._needed_use_config_changes = {}
		else:
			self._needed_use_config_changes = \
				dict((k.copy(), (v[0].copy(), v[1].copy())) for (k, v) in \
					needed_use_config_changes.items())

		self._autounmask = depgraph._frozen_config.myopts.get('--autounmask', 'n') == True

		self._runtime_pkg_mask = runtime_pkg_mask
		self._need_restart = False
		# For conditions that always require user intervention, such as
		# unsatisfied REQUIRED_USE (currently has no autounmask support).
		self._skip_restart = False
		self._backtrack_infos = {}

		self._autounmask = depgraph._frozen_config.myopts.get('--autounmask', 'n') == True
		self._success_without_autounmask = False

		for myroot in depgraph._frozen_config.trees:
			self.sets[myroot] = _depgraph_sets()

	_dep_keys = ["DEPEND", "RDEPEND", "PDEPEND"]
	
	def __init__(self, settings, trees, myopts, myparams, spinner,
		frozen_config=None, runtime_pkg_mask=None, needed_unstable_keywords=None, \
			needed_use_config_changes=None, needed_license_changes=None, allow_backtracking=False):
		if frozen_config is None:
			frozen_config = _frozen_depgraph_config(settings, trees,
			myopts, spinner)
		self._frozen_config = frozen_config
		self._dynamic_config = _dynamic_depgraph_config(self, myparams,
			allow_backtracking, runtime_pkg_mask, needed_unstable_keywords, \
			needed_use_config_changes, needed_license_changes)

		self._select_atoms = self._select_atoms_highest_available
		self._select_package = self._select_pkg_highest_available

					# PROVIDE when necessary, while match_from_list does not.
					parent, atom = parent_atom
					atom_set = InternalPackageSet(
						initial_atoms=(atom,))
					if atom_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg)):
						parent_atoms.add(parent_atom)
					else:

							(dep.parent,
							self._dynamic_config._runtime_pkg_mask[
							dep.parent]), noiselevel=-1)
				else:
					# Do not backtrack if only USE have to be changed in
					# order to satisfy the dependency.
					dep_pkg, existing_node = \
						self._select_package(dep.root, dep.atom.without_use,
							onlydeps=dep.onlydeps)
					if dep_pkg is None:
						self._dynamic_config._runtime_pkg_mask.setdefault(
							dep.parent, {})["missing dependency"] = \
								set([(dep.parent, dep.root, dep.atom)])
						self._dynamic_config._need_restart = True
						if "--debug" in self._frozen_config.myopts:
							msg = []

				# Use package set for matching since it will match via
				# PROVIDE when necessary, while match_from_list does not.
				matches = bool(InternalPackageSet(initial_atoms=(atom,),
					).findAtomForPackage(existing_node,
					modified_use=self._pkg_use_enabled(existing_node)))

		return (existing_node, matches)

								self._dynamic_config._runtime_pkg_mask[
								existing_node]), noiselevel=-1)
					elif self._dynamic_config._allow_backtracking and \
						not self._accept_blocker_conflicts():
						not self.need_restart():

						self._add_slot_conflict(pkg)
						if dep.atom is not None and dep.parent is not None:
							self._add_parent_atom(pkg, (dep.parent, dep.atom))

						if arg_atoms:
							for parent_atom in arg_atoms:
								parent, atom = parent_atom


							all_match = True
							for parent, atom in parent_atoms:
								i = InternalPackageSet(initial_atoms=(atom,))
									allow_repo=True)
								if not i.findAtomForPackage(to_be_masked):
									all_match = False
									break

							elif pkg > existing_node:
								backtrack_data.reverse()

						to_be_masked, parent_atoms = backtrack_data[-1]

						self._dynamic_config._runtime_pkg_mask.setdefault(
							to_be_masked, {})["slot conflict"] = parent_atoms
						self._dynamic_config._need_restart = True
						if "--debug" in self._frozen_config.myopts:
							msg = []

				self._add_parent_atom(pkg, parent_atom)

		""" This section determines whether we go deeper into dependencies or not.
		    We want to go deeper on a few occasions:
		    Installing package A, we need to make sure package A's deps are met.
		    emerge --deep <pkgspec>; we need to recursively check dependencies of pkgspec
		    If we are in --nodeps (no recursion) mode, we obviously only check 1 level of dependencies.
		"""
		if arg_atoms:
			depth = 0

				for atom in pkg_atom_map[pkg1]:
					cp_atoms.add(atom)
					atom_pkg_graph.add(pkg1, atom)
					atom_set = InternalPackageSet(initial_atoms=(atom,))
						allow_repo=True)
					for pkg2 in pkgs:
						if pkg2 is pkg1:
							continue

		deps = []
		for cat in categories:
			deps.append(Atom(insert_category_into_atom(
				atom_without_category, cat)))
		return deps

	def _have_new_virt(self, root, atom_cp):

					raise portage.exception.PackageNotFound(
						"%s is not in a valid portage tree hierarchy or does not exist" % x)
				pkg = self._pkg(mykey, "ebuild", root_config,
					onlydeps=onlydeps)
					os.path.dirname(os.path.dirname(os.path.dirname(ebuild_path)))))
				args.append(PackageArg(arg=x, package=pkg,
					root_config=root_config))
			elif x.startswith(os.path.sep):

					args.append(SetArg(arg=x, pset=pset,
						root_config=root_config))
					continue
				if not is_valid_package_atom(x):
					portage.writemsg("\n\n!!! '%s' is not a valid package atom.\n" % x,
						noiselevel=-1)
					portage.writemsg("!!! Please check ebuild(5) for full details.\n")

				#   2) It takes away freedom from the resolver to choose other
				#      possible expansions when necessary.
				if "/" in x:
					args.append(AtomArg(arg=x, atom=Atom(x),
						root_config=root_config))
					continue
				expanded_atoms = self._dep_expand(root_config, x)

				if expanded_atoms:
					atom = expanded_atoms[0]
				else:
					null_atom = Atom(insert_category_into_atom(x, "null"))
						allow_repo=True)
					cat, atom_pn = portage.catsplit(null_atom.cp)
					virts_p = root_config.settings.get_virts_p().get(atom_pn)
					if virts_p:
						# Allow the depgraph to choose which virtual.
						atom = Atom(null_atom.replace('null/', 'virtual/', 1))
							allow_repo=True)
					else:
						atom = null_atom


			set(self._dynamic_config.digraph).intersection( \
			self._dynamic_config._needed_license_changes) :
			#We failed if the user needs to change the configuration
			self._dynamic_config._success_without_autounmask = True
			return False, myfavorites

		# We're true here unless we are missing binaries.

		for root in self._dynamic_config.sets:
			depgraph_sets = self._dynamic_config.sets[root]
			depgraph_sets.sets.setdefault('__non_set_args__',
				InternalPackageSet()).clear()
			depgraph_sets.atoms.clear()
			depgraph_sets.atom_arg_map.clear()
			set_atoms[root] = []

		if target_atom is not None and isinstance(node, Package):
			affecting_use = set()
			for dep_str in "DEPEND", "RDEPEND", "PDEPEND":
				affecting_use.update(extract_affecting_use(
					node.metadata[dep_str], target_atom))
						node.metadata[dep_str], target_atom))
				except InvalidDependString:
					if not node.installed:
						raise
			affecting_use.difference_update(node.use.mask, node.use.force)
			pkg_name = _unicode_decode("%s") % (node.cpv,)
			if affecting_use:

		a matching package has been masked by backtracking.
		"""
		backtrack_mask = False
		atom_set = InternalPackageSet(initial_atoms=(atom.without_use,))
			allow_repo=True)
		xinfo = '"%s"' % atom.unevaluated_atom
		if arg:
			xinfo='"%s"' % arg

				continue
			match = db.match
			if hasattr(db, "xmatch"):
				cpv_list = db.xmatch("match-all", atom.without_use)
			else:
				cpv_list = db.match(atom.without_use)

			if atom.repo is None and hasattr(db, "getRepositories"):
				repo_list = db.getRepositories()
			else:
				repo_list = [atom.repo]

			# descending order
			cpv_list.reverse()
			for cpv in cpv_list:
				metadata, mreasons  = get_mask_info(root_config, cpv, pkgsettings, db, \
					pkg_type, built, installed, db_keys, _pkg_use_enabled=self._pkg_use_enabled)

				if metadata is not None:
					pkg = self._pkg(cpv, pkg_type, root_config,
						installed=installed)
					# pkg.metadata contains calculated USE for ebuilds,
					# required later for getMissingLicenses.
					metadata = pkg.metadata
					if pkg.cp != atom.cp:
						# A cpv can be returned from dbapi.match() as an
						# old-style virtual match even in cases when the
						# package does not actually PROVIDE the virtual.
						# Filter out any such false matches here.
						if not atom_set.findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg)):
							continue
					if pkg in self._dynamic_config._runtime_pkg_mask:
						backtrack_reasons = \
							self._dynamic_config._runtime_pkg_mask[pkg]
						mreasons.append('backtracking: %s' % \
							', '.join(sorted(backtrack_reasons)))
						backtrack_mask = True
					if not mreasons and self._frozen_config.excluded_pkgs.findAtomForPackage(pkg, \
						modified_use=self._pkg_use_enabled(pkg)):
						mreasons = ["exclude option"]
					if mreasons:
						masked_pkg_instances.add(pkg)
					if atom.unevaluated_atom.use:
						try:
							if not pkg.iuse.is_valid_flag(atom.unevaluated_atom.use.required) \
								or atom.violated_conditionals(self._pkg_use_enabled(pkg), pkg.iuse.is_valid_flag).use:
								missing_use.append(pkg)
								if not mreasons:
									continue
						except InvalidAtom:
							writemsg("violated_conditionals raised " + \
								"InvalidAtom: '%s' parent: %s" % \
								(atom, myparent), noiselevel=-1)
							raise
					if not mreasons and \
						not pkg.built and \
						pkg.metadata["REQUIRED_USE"] and \
						eapi_has_required_use(pkg.metadata["EAPI"]):
						if not check_required_use(
							pkg.metadata["REQUIRED_USE"],
							self._pkg_use_enabled(pkg),
							pkg.iuse.is_valid_flag):
							required_use_unsatisfied.append(pkg)
							continue
					if pkg.built and not mreasons:
						mreasons = ["use flag configuration mismatch"]
				masked_packages.append(
					(root_config, pkgsettings, cpv, metadata, mreasons))
							mreasons = ["use flag configuration mismatch"]
					masked_packages.append(
						(root_config, pkgsettings, cpv, repo, metadata, mreasons))

		if check_backtrack:
			if backtrack_mask:

			# that the user wants the latest version, so only the first
			# instance is displayed.
			pkg = required_use_unsatisfied[0]
			output_cpv = pkg.cpv
			writemsg_stdout("\n!!! " + \
				colorize("BAD", "The ebuild selected to satisfy ") + \
				colorize("INFORM", xinfo) + \

			mask_docs = True
		else:
			writemsg_stdout("\nemerge: there are no ebuilds to satisfy "+green(xinfo)+".\n", noiselevel=-1)

			if self._frozen_config.myopts.get('--misspell-suggestions', 'y') == 'y' and \
				isinstance(myparent, AtomArg):
				cp = myparent.atom.cp.lower()
				cat, pkg = portage.catsplit(cp)
				if cat == "null":

		db = root_config.trees[self.pkg_tree_map[pkg_type]].dbapi

		if hasattr(db, "xmatch"):
			cpv_list = db.xmatch("match-all", atom)
			# to bypass unnecessary cache access for things like IUSE
			# and SLOT. Later, we cache the metadata in a Package
			# instance, and use that for further matching. This
			# optimization is especially relevant since
			# pordbapi.aux_get() does not cache calls that have
			# myrepo or mytree arguments.
			cpv_list = db.xmatch("match-all-cpv-only", atom)
		else:
			cpv_list = db.match(atom)


				if not slot_available:
					continue
				inst_pkg = self._pkg(cpv, "installed",
					root_config, installed=installed)
				# Remove the slot from the atom and verify that
				# the package matches the resulting atom.
				if portage.match_from_list(

					return

		if cpv_list:
			atom_set = InternalPackageSet(initial_atoms=(atom,),
				allow_repo=True)
			if atom.repo is None and hasattr(db, "getRepositories"):
				repo_list = db.getRepositories()
			else:
				repo_list = [atom.repo]

			# descending order
			cpv_list.reverse()
			for cpv in cpv_list:
				try:
					pkg = self._pkg(cpv, pkg_type, root_config,
						installed=installed, onlydeps=onlydeps)
				except portage.exception.PackageNotFound:
					pass
				else:
					if pkg.cp != atom.cp:
					else:
						# A cpv can be returned from dbapi.match() as an
						# old-style virtual match even in cases when the
						# package does not actually PROVIDE the virtual.
						# Filter out any such false matches here.
						if not InternalPackageSet(initial_atoms=(atom,)
							).findAtomForPackage(pkg, modified_use=self._pkg_use_enabled(pkg)):
						# This might not be the case if there are several repos with
						# the same cpv, but different metadata keys, like SLOT.
						# Also, for portdbapi, parts of the match that require
						# metadata access are deferred until we have cached the
						# metadata in a Package instance.
						if not atom_set.findAtomForPackage(pkg,
							modified_use=self._pkg_use_enabled(pkg)):
							continue
					yield pkg

	def _select_pkg_highest_available(self, root, atom, onlydeps=False):
		cache_key = (root, atom, onlydeps)


		if masked_by_unstable_keywords:
			self._dynamic_config._needed_unstable_keywords.add(pkg)
			backtrack_infos = self._dynamic_config._backtrack_infos
			backtrack_infos.setdefault("config", {})
			backtrack_infos["config"].setdefault("needed_unstable_keywords", set())
			backtrack_infos["config"]["needed_unstable_keywords"].add(pkg)
			

		if missing_licenses:
			self._dynamic_config._needed_license_changes.setdefault(pkg, set()).update(missing_licenses)
			backtrack_infos = self._dynamic_config._backtrack_infos
			backtrack_infos.setdefault("config", {})
			backtrack_infos["config"].setdefault("needed_license_changes", set())
			backtrack_infos["config"]["needed_license_changes"].add((pkg, frozenset(missing_licenses)))

		return True


			if required_use and check_required_use(required_use, old_use, pkg.iuse.is_valid_flag) and \
				not check_required_use(required_use, new_use, pkg.iuse.is_valid_flag):
				return old_use
			
			self._dynamic_config._needed_use_config_changes[pkg] = (new_use, new_changes)
			backtrack_infos = self._dynamic_config._backtrack_infos
			backtrack_infos.setdefault("config", {})
			backtrack_infos["config"].setdefault("needed_use_config_changes", [])
			backtrack_infos["config"]["needed_use_config_changes"].append((pkg, (new_use, new_changes)))
			if want_restart_for_use_change(pkg, new_use):
				self._dynamic_config._need_restart = True
		return new_use

		if not isinstance(atom, portage.dep.Atom):
			atom = portage.dep.Atom(atom)
		atom_cp = atom.cp
		atom_set = InternalPackageSet(initial_atoms=(atom,))
		existing_node = None
		myeb = None
		rebuilt_binaries = 'rebuilt_binaries' in self._dynamic_config.myparams

						# list only contains unbuilt ebuilds since USE can't
						# be changed for built packages.
						higher_version_rejected = False
						repo_priority = pkg.repo_priority
						for rejected in packages_with_invalid_use_config:
							if rejected.cp != pkg.cp:
								continue
							if rejected > pkg:
								higher_version_rejected = True
								break
							if portage.dep.cpvequal(rejected.cpv, pkg.cpv):
								# If version is identical then compare
								# repo priority (see bug #350254).
								rej_repo_priority = rejected.repo_priority
								if rej_repo_priority is not None and \
									(repo_priority is None or
									rej_repo_priority > repo_priority):
									higher_version_rejected = True
									break
						if higher_version_rejected:
							continue


								else:
									try:
										pkg_eb = self._pkg(
											pkg.cpv, "ebuild", root_config)
									except portage.exception.PackageNotFound:
										continue
										for pkg_eb in self._iter_match_pkgs(pkg.root_config,
											"ebuild", Atom("=%s" % (pkg.cpv,))):
											if self._pkg_visibility_check(pkg_eb, \
												allow_unstable_keywords=allow_unstable_keywords,
												allow_license_changes=allow_license_changes):
												pkg_eb_visible = True
												break
										if not pkg_eb_visible:
											continue
									else:
										if not self._pkg_visibility_check(pkg_eb, \
											allow_unstable_keywords=allow_unstable_keywords,

		return 1

	def _pkg(self, cpv, type_name, root_config, installed=False, 
		onlydeps=False):
		"""
		Get a package instance from the cache, or create a new
		one if necessary. Raises PackageNotFound from aux_get if it
		failures for some reason (package does not exist or is
		corrupt).
		"""
		if type_name != "ebuild":
			# For installed (and binary) packages we don't care for the repo
			# when it comes to hashing, because there can only be one cpv.
			# So overwrite the repo_key with type_name.
			repo_key = type_name
			myrepo = None
		elif myrepo is None:
			raise AssertionError(
				"depgraph._pkg() called without 'myrepo' argument")
		else:
			repo_key = myrepo

		operation = "merge"
		if installed or onlydeps:
			operation = "nomerge"

		# that refers to FakeVartree instead of the real vartree.
		root_config = self._frozen_config.roots[root_config.root]
		pkg = self._frozen_config._pkg_cache.get(
			(type_name, root_config.root, cpv, operation))
		if pkg is None and onlydeps and not installed:
			# Maybe it already got pulled in as a "merge" node.
			pkg = self._dynamic_config.mydbapi[root_config.root].get(
				(type_name, root_config.root, cpv, 'merge'))

		if pkg is None:
			tree_type = self.pkg_tree_map[type_name]
			db = root_config.trees[tree_type].dbapi
			db_keys = list(self._frozen_config._trees_orig[root_config.root][
				tree_type].dbapi._aux_cache_keys)

			try:
				metadata = zip(db_keys, db.aux_get(cpv, db_keys))
			except KeyError:
				raise portage.exception.PackageNotFound(cpv)

			pkg = Package(built=(type_name != "ebuild"), cpv=cpv,
				installed=installed, metadata=metadata, onlydeps=onlydeps,
				root_config=root_config, type_name=type_name)

			self._frozen_config._pkg_cache[pkg] = pkg

			if not self._pkg_visibility_check(pkg) and \

		graph = self._dynamic_config._scheduler_graph
		trees = self._frozen_config.trees
		pruned_pkg_cache = {}
		for pkg in pkg_cache:
			if pkg in graph or \
				(pkg.installed and pkg in trees[pkg.root]['vartree'].dbapi):
				pruned_pkg_cache[pkg] = pkg

		for root in trees:
			trees[root]['vartree']._pkg_cache = pruned_pkg_cache
			self.break_refs(trees[root]['vartree'].dbapi)

		self.break_refs(pruned_pkg_cache)
		sched_config = \
			_scheduler_graph_config(trees, pruned_pkg_cache, graph, mergelist)


		# redundantly displaying this exact same merge list
		# again via _show_merge_list().
		self._dynamic_config._displayed_list = mylist
		display = Display()

		return display(self, mylist, favorites, verbosity)


			pkgsettings = self._frozen_config.pkgsettings[pkg.root]
			mreasons = get_masking_status(pkg, pkgsettings, root_config, use=self._pkg_use_enabled(pkg))
			masked_packages.append((root_config, pkgsettings,
				pkg.cpv, pkg.metadata, mreasons))
		if masked_packages:
			writemsg("\n" + colorize("BAD", "!!!") + \
				" The following updates are masked by LICENSE changes:\n",

			pkgsettings = self._frozen_config.pkgsettings[pkg.root]
			mreasons = get_masking_status(pkg, pkgsettings, root_config, use=self._pkg_use_enabled)
			masked_packages.append((root_config, pkgsettings,
				pkg.cpv, pkg.metadata, mreasons))
		if masked_packages:
			writemsg("\n" + colorize("BAD", "!!!") + \
				" The following installed packages are masked:\n",

		if not isinstance(mergelist, list):
			mergelist = []

		favorites = resume_data.get("favorites")
		args_set = self._dynamic_config.sets[
			self._frozen_config.target_root].sets['__non_set_args__']
		if isinstance(favorites, list):
			args = self._load_favorites(favorites)
		else:
			args = []

		fakedb = self._dynamic_config.mydbapi
		trees = self._frozen_config.trees
		serialized_tasks = []

			if action != "merge":
				continue
			root_config = self._frozen_config.roots[myroot]

			# Use the resume "favorites" list to see if a repo was specified
			# for this package.
			depgraph_sets = self._dynamic_config.sets[root_config.root]
			repo = None
			for atom in depgraph_sets.atoms.getAtoms():
				if atom.repo and portage.dep.match_from_list(atom, [pkg_key]):
					repo = atom.repo
					break

			atom = "=" + pkg_key
			if repo:
				atom = atom + _repo_separator + repo

			try:
				pkg = self._pkg(pkg_key, pkg_type, root_config)
			except portage.exception.PackageNotFound:
				continue

			pkg = None
			for pkg in self._iter_match_pkgs(root_config, pkg_type, atom):
				if not self._pkg_visibility_check(pkg) or \
					self._frozen_config.excluded_pkgs.findAtomForPackage(pkg,
						modified_use=self._pkg_use_enabled(pkg)):
					continue
				break

			if pkg is None:
				# It does no exist or it is corrupt.
				if skip_missing:
					# TODO: log these somewhere
					continue
				raise

			if "merge" == pkg.operation and \
				self._frozen_config.excluded_pkgs.findAtomForPackage(pkg, \

			# recognized, deep traversal of dependencies is required.
			self._dynamic_config.myparams["deep"] = True

			favorites = resume_data.get("favorites")
			args_set = self._dynamic_config.sets[
				self._frozen_config.target_root].sets['__non_set_args__']
			if isinstance(favorites, list):
				args = self._load_favorites(favorites)
			else:
				args = []

			for task in serialized_tasks:
				if isinstance(task, Package) and \
					task.operation == "merge":

					root_config=root_config))
			else:
				try:
					x = Atom(x)
				except portage.exception.InvalidAtom:
					continue
				args.append(AtomArg(arg=x, atom=x,

		return self._dynamic_config._need_restart and \
			not self._dynamic_config._skip_restart

	def get_backtrack_parameters(self):
		return {
			"needed_unstable_keywords":
				self._dynamic_config._needed_unstable_keywords.copy(), \
			"runtime_pkg_mask":
				self._dynamic_config._runtime_pkg_mask.copy(),
			"needed_use_config_changes":
				self._dynamic_config._needed_use_config_changes.copy(),
			"needed_license_changes":
				self._dynamic_config._needed_license_changes.copy(),
			}
			

class _dep_check_composite_db(dbapi):

				else:
					try:
						pkg_eb = self._depgraph._pkg(
							pkg.cpv, "ebuild", pkg.root_config)
							myrepo=pkg.repo)
					except portage.exception.PackageNotFound:
						return False
						for pkg_eb in self._depgraph._iter_match_pkgs(
							pkg.root_config, "ebuild",
							Atom("=%s" % (pkg.cpv,))):
							if self._depgraph._pkg_visibility_check(pkg_eb):
								pkg_eb_visible = True
								break
						if not pkg_eb_visible:
							return False
					else:
						if not self._depgraph._pkg_visibility_check(pkg_eb):
							return False

		if expanded_atoms:
			atom = expanded_atoms[0]
		else:
			null_atom = Atom(insert_category_into_atom(atom, "null"))
				allow_repo=True)
			cat, atom_pn = portage.catsplit(null_atom.cp)
			virts_p = root_config.settings.get_virts_p().get(atom_pn)
			if virts_p:
				# Allow the resolver to choose which virtual.
				atom = Atom(null_atom.replace('null/', 'virtual/', 1))
					allow_repo=True)
			else:
				atom = null_atom
		return atom


def _spinner_stop(spinner):
	if spinner is None or \
		spinner.update is spinner.update_quiet:
		return

	portage.writemsg_stdout("\b\b... done!\n")
		# update_basic is used for non-tty output,
		# so don't output backspaces in that case.
		portage.writemsg_stdout("\b\b")

	portage.writemsg_stdout("... done!\n")

def backtrack_depgraph(settings, trees, myopts, myparams, 
	myaction, myfiles, spinner):

	finally:
		_spinner_stop(spinner)

def _backtrack_depgraph(settings, trees, myopts, myparams, 
	myaction, myfiles, spinner):

	backtrack_max = myopts.get('--backtrack', 10)
	backtrack_parameters = {}
	needed_unstable_keywords = None
	allow_backtracking = backtrack_max > 0
	allow_backtracking = max_retries > 0
	backtracker = Backtracker(max_depth)
	backtracked = 0

	frozen_config = _frozen_depgraph_config(settings, trees,
		myopts, spinner)
	while True:
	while backtracker:
		backtrack_parameters = backtracker.get()

		mydepgraph = depgraph(settings, trees, myopts, myparams, spinner,
			frozen_config=frozen_config,
			allow_backtracking=allow_backtracking,
			**backtrack_parameters)
		success, favorites = mydepgraph.select_files(myfiles)
		if not success:
			if mydepgraph.need_restart() and backtracked < backtrack_max:
				backtrack_parameters = mydepgraph.get_backtrack_parameters()
				backtracked += 1
			elif backtracked and allow_backtracking:
				if "--debug" in myopts:
					writemsg_level(
						"\n\nbacktracking aborted after %s tries\n\n" % \
						backtracked, noiselevel=-1, level=logging.DEBUG)
				# Backtracking failed, so disable it and do
				# a plain dep calculation + error message.
				allow_backtracking = False
				#Don't reset needed_unstable_keywords here, since we don't want to
				#send the user through a "one step at a time" unmasking session for
				#no good reason.
				backtrack_parameters.pop('runtime_pkg_mask', None)
			else:
				break
		else:
			break

	if not (success or mydepgraph.success_without_autounmask()) and backtracked:

		if "--debug" in myopts:
			writemsg_level(
				"\n\nbacktracking aborted after %s tries\n\n" % \
				backtracked, noiselevel=-1, level=logging.DEBUG)

		mydepgraph = depgraph(settings, trees, myopts, myparams, spinner,
			frozen_config=frozen_config,
			allow_backtracking=False,
			backtrack_parameters=backtracker.get_best_run())
		success, favorites = mydepgraph.select_files(myfiles)

	return (success, mydepgraph, favorites)


def resume_depgraph(settings, trees, mtimedb, myopts, myparams, spinner):
	"""
	Raises PackageSetNotFound if myfiles contains a missing package set.

	return (success, mydepgraph, dropped_tasks)

def get_mask_info(root_config, cpv, pkgsettings,
	db, pkg_type, built, installed, db_keys, _pkg_use_enabled=None):
	eapi_masked = False
	try:
		metadata = dict(zip(db_keys,
			db.aux_get(cpv, db_keys)))
	except KeyError:
		metadata = None


			if _pkg_use_enabled is not None:
				modified_use = _pkg_use_enabled(pkg)

			mreasons = get_masking_status(pkg, pkgsettings, root_config, use=modified_use)

	return metadata, mreasons

def show_masked_packages(masked_packages):

	# show one of them to avoid redundant appearance.
	shown_cpvs = set()
	have_eapi_mask = False
	for (root_config, pkgsettings, cpv,
		metadata, mreasons) in masked_packages:
		if cpv in shown_cpvs:
		if repo:
			output_cpv += _repo_separator + repo
		if output_cpv in shown_cpvs:
			continue
		shown_cpvs.add(cpv)
		comment, filename = None, None
		if "package.mask" in mreasons:
			comment, filename = \

				# above via mreasons.
				pass

		writemsg_stdout("- "+cpv+" (masked by: "+", ".join(mreasons)+")\n", noiselevel=-1)

		if comment and comment not in shown_comments:
			writemsg_stdout(filename + ":\n" + comment + "\n",

	writemsg("section of the Gentoo Linux x86 Handbook (architecture is irrelevant):\n\n", noiselevel=-1)
	writemsg("http://www.gentoo.org/doc/en/handbook/handbook-x86.xml?full=1#blocked\n\n", noiselevel=-1)

def get_masking_status(pkg, pkgsettings, root_config, use=None):
	return [mreason.message for \
		mreason in _get_masking_status(pkg, pkgsettings, root_config, use=use)]

def _get_masking_status(pkg, pkgsettings, root_config, use=None):

def _get_masking_status(pkg, pkgsettings, root_config, myrepo=None, use=None):
	mreasons = _getmaskingstatus(
		pkg, settings=pkgsettings,
		portdb=root_config.trees["porttree"].dbapi)

	if not pkg.installed:
		if not pkgsettings._accept_chost(pkg.cpv, pkg.metadata):




	print("          [ "+green("--complete-graph")+"             ] [ "+green("--deep")+"       ]")
	print("          [ "+green("--jobs") + " " + turquoise("JOBS")+" ] [ "+green("--keep-going")+" ] [ " + green("--load-average")+" " + turquoise("LOAD") + "            ]")
	print("          [ "+green("--newuse")+"    ] [ "+green("--noconfmem")+"  ] [ "+green("--nospinner")+"  ]")
	print("          [ "+green("--oneshot")+"   ] [ "+green("--onlydeps")+"   ] [ " + green("--misspell-suggestions")+" < " + turquoise("y") + " | "+ turquoise("n")+" > ]")
	print("          [ "+green("--reinstall ")+turquoise("changed-use")+"      ] [ " + green("--with-bdeps")+" < " + turquoise("y") + " | "+ turquoise("n")+" >         ]")
	print(bold("Actions:")+"  [ "+green("--depclean")+" | "+green("--list-sets")+" | "+green("--search")+" | "+green("--sync")+" | "+green("--version")+"        ]")


		print("              With this option, output such as USE=\"dar -bar -foo\" will instead")
		print("              be displayed as USE=\"-bar dar -foo\"")
		print()
		print("       "+green("--ask")+" ("+green("-a")+" short option)")
			" [ %s | %s ] (%s short option)" % \
			(turquoise("y"), turquoise("n"), green("-a")))
		desc = "Before performing the action, display what will take place (server info for " + \
			"--sync, --pretend output for merge, and so forth), then ask " + \
			"whether to proceed with the action or abort.  Using --ask is more " + \

		print("              printed out accompanied by a '+' for enabled and a '-' for")
		print("              disabled USE flags.")
		print()
		print("       "+green("--quiet")+" ("+green("-q")+" short option)")
			" [ %s | %s ] (%s short option)" % \
			(turquoise("y"), turquoise("n"), green("-q")))
		print("              Effects vary, but the general outcome is a reduced or condensed")
		print("              output from portage's displays.")
		print()
		print("       "+green("--quiet-build"))
			" [ %s | %s ]" % (turquoise("y"), turquoise("n")))
		desc = "Redirect all build output to logs alone, and do not " + \
			"display it on stdout."
		for line in wrap(desc, desc_width):

Lines 50-56 if sys.hexversion >= 0x3000000: Link Here

(-)a/pym/_emerge/main.py (-69 / +31 lines)
50	long = int	50	long = int
51		51
52	options=[	52	options=[
53	"--alphabetical",	53	"--ask", "--alphabetical",
54	"--ask-enter-invalid",	54	"--ask-enter-invalid",
55	"--buildpkgonly",	55	"--buildpkgonly",
56	"--changed-use",	56	"--changed-use",
Lines 65-70 options=[ Link Here
65	"--nodeps", "--noreplace",	65	"--nodeps", "--noreplace",
66	"--nospinner", "--oneshot",	66	"--nospinner", "--oneshot",
67	"--onlydeps", "--pretend",	67	"--onlydeps", "--pretend",
		68	"--quiet",
		69	"--quiet-build",
68	"--quiet-unmerge-warn",	70	"--quiet-unmerge-warn",
69	"--resume",	71	"--resume",
70	"--searchdesc",	72	"--searchdesc",
Lines 77-82 options=[ Link Here
77		79
78	shortmapping={	80	shortmapping={
79	"1":"--oneshot",	81	"1":"--oneshot",
		82	"a":"--ask",
80	"B":"--buildpkgonly",	83	"B":"--buildpkgonly",
81	"c":"--depclean",	84	"c":"--depclean",
82	"C":"--unmerge",	85	"C":"--unmerge",
Lines 88-93 shortmapping={ Link Here
88	"n":"--noreplace", "N":"--newuse",	91	"n":"--noreplace", "N":"--newuse",
89	"o":"--onlydeps", "O":"--nodeps",	92	"o":"--onlydeps", "O":"--nodeps",
90	"p":"--pretend", "P":"--prune",	93	"p":"--pretend", "P":"--prune",
		94	"q":"--quiet",
91	"r":"--resume",	95	"r":"--resume",
92	"s":"--search", "S":"--searchdesc",	96	"s":"--search", "S":"--searchdesc",
93	"t":"--tree",	97	"t":"--tree",
Lines 114-125 def chk_updated_info_files(root, infodirs, prev_mtimes, retval): Link Here
114		118
115	if not regen_infodirs:	119	if not regen_infodirs:
116	portage.writemsg_stdout("\n")	120	portage.writemsg_stdout("\n")
117	if portage.util.noiselimit >= 0:	121	out.einfo("GNU info directory index is up-to-date.")
118	out.einfo("GNU info directory index is up-to-date.")
119	else:	122	else:
120	portage.writemsg_stdout("\n")	123	portage.writemsg_stdout("\n")
121	if portage.util.noiselimit >= 0:	124	out.einfo("Regenerating GNU info directory index...")
122	out.einfo("Regenerating GNU info directory index...")
123		125
124	dir_extensions = ("", ".gz", ".bz2")	126	dir_extensions = ("", ".gz", ".bz2")
125	icount=0	127	icount=0
Lines 206-212 def chk_updated_info_files(root, infodirs, prev_mtimes, retval): Link Here
206	(icount, badcount))	208	(icount, badcount))
207	writemsg_level(errmsg, level=logging.ERROR, noiselevel=-1)	209	writemsg_level(errmsg, level=logging.ERROR, noiselevel=-1)
208	else:	210	else:
209	if icount > 0 and portage.util.noiselimit >= 0:	211	if icount > 0:
210	out.einfo("Processed %d info files." % (icount,))	212	out.einfo("Processed %d info files." % (icount,))
211		213
212	def display_preserved_libs(vardbapi, myopts):	214	def display_preserved_libs(vardbapi, myopts):
Lines 423-429 def insert_optional_args(args): Link Here
423	new_args = []	425	new_args = []
424		426
425	default_arg_opts = {	427	default_arg_opts = {
426	'--ask' : y_or_n,
427	'--autounmask' : y_or_n,	428	'--autounmask' : y_or_n,
428	'--buildpkg' : y_or_n,	429	'--buildpkg' : y_or_n,
429	'--complete-graph' : y_or_n,	430	'--complete-graph' : y_or_n,
Lines 436-443 def insert_optional_args(args): Link Here
436	'--jobs' : valid_integers,	437	'--jobs' : valid_integers,
437	'--keep-going' : y_or_n,	438	'--keep-going' : y_or_n,
438	'--package-moves' : y_or_n,	439	'--package-moves' : y_or_n,
439	'--quiet' : y_or_n,
440	'--quiet-build' : y_or_n,
441	'--rebuilt-binaries' : y_or_n,	440	'--rebuilt-binaries' : y_or_n,
442	'--root-deps' : ('rdeps',),	441	'--root-deps' : ('rdeps',),
443	'--select' : y_or_n,	442	'--select' : y_or_n,
Lines 458-470 def insert_optional_args(args): Link Here
458	# Don't make things like "-kn" expand to "-k n"	457	# Don't make things like "-kn" expand to "-k n"
459	# since existence of -n makes it too ambiguous.	458	# since existence of -n makes it too ambiguous.
460	short_arg_opts_n = {	459	short_arg_opts_n = {
461	'a' : y_or_n,
462	'b' : y_or_n,	460	'b' : y_or_n,
463	'g' : y_or_n,	461	'g' : y_or_n,
464	'G' : y_or_n,	462	'G' : y_or_n,
465	'k' : y_or_n,	463	'k' : y_or_n,
466	'K' : y_or_n,	464	'K' : y_or_n,
467	'q' : y_or_n,
468	}	465	}
469		466
470	arg_stack = args[:]	467	arg_stack = args[:]
Lines 563-575 def parse_opts(tmpcmdline, silent=False): Link Here
563	true_y = ("True", "y")	560	true_y = ("True", "y")
564	argument_options = {	561	argument_options = {
565		562
566	"--ask": {
567	"shortopt" : "-a",
568	"help" : "prompt before performing any actions",
569	"type" : "choice",
570	"choices" : true_y_or_n
571	},
572
573	"--autounmask": {	563	"--autounmask": {
574	"help" : "automatically unmask packages",	564	"help" : "automatically unmask packages",
575	"type" : "choice",	565	"type" : "choice",
Lines 707-725 def parse_opts(tmpcmdline, silent=False): Link Here
707	"choices" : true_y_or_n	697	"choices" : true_y_or_n
708	},	698	},
709		699
710	"--quiet": {
711	"shortopt" : "-q",
712	"help" : "reduced or condensed output",
713	"type" : "choice",
714	"choices" : true_y_or_n
715	},
716
717	"--quiet-build": {
718	"help" : "redirect build output to logs",
719	"type" : "choice",
720	"choices" : true_y_or_n
721	},
722
723	"--rebuilt-binaries": {	700	"--rebuilt-binaries": {
724	"help" : "replace installed packages with binary " + \	701	"help" : "replace installed packages with binary " + \
725	"packages that have been rebuilt",	702	"packages that have been rebuilt",
Lines 778-783 def parse_opts(tmpcmdline, silent=False): Link Here
778	"choices" : true_y_or_n	755	"choices" : true_y_or_n
779	},	756	},
780		757
		758	"--misspell-suggestions": {
		759	"help" : "enable package name suggestions when not existing",
		760	"type" : "choice",
		761	"choices" : true_y_or_n
		762	},
		763
781	}	764	}
782		765
783	if _ENABLE_DYN_LINK_MAP:	766	if _ENABLE_DYN_LINK_MAP:
Lines 817-827 def parse_opts(tmpcmdline, silent=False): Link Here
817		800
818	myoptions, myargs = parser.parse_args(args=tmpcmdline)	801	myoptions, myargs = parser.parse_args(args=tmpcmdline)
819		802
820	if myoptions.ask in true_y:
821	myoptions.ask = True
822	else:
823	myoptions.ask = None
824
825	if myoptions.autounmask in true_y:	803	if myoptions.autounmask in true_y:
826	myoptions.autounmask = True	804	myoptions.autounmask = True
827		805
Lines 897-912 def parse_opts(tmpcmdline, silent=False): Link Here
897	if myoptions.package_moves in true_y:	875	if myoptions.package_moves in true_y:
898	myoptions.package_moves = True	876	myoptions.package_moves = True
899		877
900	if myoptions.quiet in true_y:
901	myoptions.quiet = True
902	else:
903	myoptions.quiet = None
904
905	if myoptions.quiet_build in true_y:
906	myoptions.quiet_build = True
907	else:
908	myoptions.quiet_build = None
909
910	if myoptions.rebuilt_binaries in true_y:	878	if myoptions.rebuilt_binaries in true_y:
911	myoptions.rebuilt_binaries = True	879	myoptions.rebuilt_binaries = True
912		880
Lines 1258-1268 def expand_set_arguments(myfiles, myaction, root_config): Link Here
1258		1226
1259	def repo_name_check(trees):	1227	def repo_name_check(trees):
1260	missing_repo_names = set()	1228	missing_repo_names = set()
1261	for root_trees in trees.values():	1229	for root, root_trees in trees.items():
1262	porttree = root_trees.get("porttree")	1230	if "porttree" in root_trees:
1263	if porttree:	1231	portdb = root_trees["porttree"].dbapi
1264	portdb = porttree.dbapi	1232	missing_repo_names.update(portdb.porttrees)
1265	missing_repo_names.update(portdb.getMissingRepoNames())	1233	repos = portdb.getRepositories()
		1234	for r in repos:
		1235	missing_repo_names.discard(portdb.getRepositoryPath(r))
1266	if portdb.porttree_root in missing_repo_names and \	1236	if portdb.porttree_root in missing_repo_names and \
1267	not os.path.exists(os.path.join(	1237	not os.path.exists(os.path.join(
1268	portdb.porttree_root, "profiles")):	1238	portdb.porttree_root, "profiles")):
Lines 1281-1287 def repo_name_check(trees): Link Here
1281	msg.extend(textwrap.wrap("NOTE: Each repo_name entry " + \	1251	msg.extend(textwrap.wrap("NOTE: Each repo_name entry " + \
1282	"should be a plain text file containing a unique " + \	1252	"should be a plain text file containing a unique " + \
1283	"name for the repository on the first line.", 70))	1253	"name for the repository on the first line.", 70))
1284	msg.append("\n")
1285	writemsg_level("".join("%s\n" % l for l in msg),	1254	writemsg_level("".join("%s\n" % l for l in msg),
1286	level=logging.WARNING, noiselevel=-1)	1255	level=logging.WARNING, noiselevel=-1)
1287		1256
Lines 1293-1299 def repo_name_duplicate_check(trees): Link Here
1293	if 'porttree' in root_trees:	1262	if 'porttree' in root_trees:
1294	portdb = root_trees['porttree'].dbapi	1263	portdb = root_trees['porttree'].dbapi
1295	if portdb.settings.get('PORTAGE_REPO_DUPLICATE_WARN') != '0':	1264	if portdb.settings.get('PORTAGE_REPO_DUPLICATE_WARN') != '0':
1296	for repo_name, paths in portdb.getIgnoredRepos():	1265	for repo_name, paths in portdb._ignored_repos:
1297	k = (root, repo_name, portdb.getRepositoryPath(repo_name))	1266	k = (root, repo_name, portdb.getRepositoryPath(repo_name))
1298	ignored_repos.setdefault(k, []).extend(paths)	1267	ignored_repos.setdefault(k, []).extend(paths)
1299		1268
Lines 1304-1310 def repo_name_duplicate_check(trees): Link Here
1304	msg.append(' profiles/repo_name entries:')	1273	msg.append(' profiles/repo_name entries:')
1305	msg.append('')	1274	msg.append('')
1306	for k in sorted(ignored_repos):	1275	for k in sorted(ignored_repos):
1307	msg.append(' %s overrides' % ", ".join(k))	1276	msg.append(' %s overrides' % (k,))
1308	for path in ignored_repos[k]:	1277	for path in ignored_repos[k]:
1309	msg.append(' %s' % (path,))	1278	msg.append(' %s' % (path,))
1310	msg.append('')	1279	msg.append('')
Lines 1313-1319 def repo_name_duplicate_check(trees): Link Here
1313	"to avoid having duplicates ignored. " + \	1282	"to avoid having duplicates ignored. " + \
1314	"Set PORTAGE_REPO_DUPLICATE_WARN=\"0\" in " + \	1283	"Set PORTAGE_REPO_DUPLICATE_WARN=\"0\" in " + \
1315	"/etc/make.conf if you would like to disable this warning."))	1284	"/etc/make.conf if you would like to disable this warning."))
1316	msg.append("\n")
1317	writemsg_level(''.join('%s\n' % l for l in msg),	1285	writemsg_level(''.join('%s\n' % l for l in msg),
1318	level=logging.WARNING, noiselevel=-1)	1286	level=logging.WARNING, noiselevel=-1)
1319		1287
Lines 1355-1368 def check_procfs(): Link Here
1355	level=logging.ERROR, noiselevel=-1)	1323	level=logging.ERROR, noiselevel=-1)
1356	return 1	1324	return 1
1357		1325
1358	def emerge_main(args=None):	1326	def emerge_main():
1359	"""	1327	global portage # NFC why this is necessary now - genone
1360	@param args: command arguments (default: sys.argv[1:])
1361	@type args: list
1362	"""
1363	if args is None:
1364	args = sys.argv[1:]
1365
1366	portage._disable_legacy_globals()	1328	portage._disable_legacy_globals()
1367	portage.dep._internal_warnings = True	1329	portage.dep._internal_warnings = True
1368	# Disable color until we're sure that it should be enabled (after	1330	# Disable color until we're sure that it should be enabled (after
Lines 1372-1378 def emerge_main(args=None): Link Here
1372	# possible, such as --config-root. They will be parsed again later,	1334	# possible, such as --config-root. They will be parsed again later,
1373	# together with EMERGE_DEFAULT_OPTS (which may vary depending on the	1335	# together with EMERGE_DEFAULT_OPTS (which may vary depending on the
1374	# the value of --config-root).	1336	# the value of --config-root).
1375	myaction, myopts, myfiles = parse_opts(args, silent=True)	1337	myaction, myopts, myfiles = parse_opts(sys.argv[1:], silent=True)
1376	if "--debug" in myopts:	1338	if "--debug" in myopts:
1377	os.environ["PORTAGE_DEBUG"] = "1"	1339	os.environ["PORTAGE_DEBUG"] = "1"
1378	if "--config-root" in myopts:	1340	if "--config-root" in myopts:
Lines 1393-1399 def emerge_main(args=None): Link Here
1393	tmpcmdline = []	1355	tmpcmdline = []
1394	if "--ignore-default-opts" not in myopts:	1356	if "--ignore-default-opts" not in myopts:
1395	tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())	1357	tmpcmdline.extend(settings["EMERGE_DEFAULT_OPTS"].split())
1396	tmpcmdline.extend(args)	1358	tmpcmdline.extend(sys.argv[1:])
1397	myaction, myopts, myfiles = parse_opts(tmpcmdline)	1359	myaction, myopts, myfiles = parse_opts(tmpcmdline)
1398		1360
1399	if myaction not in ('help', 'info', 'version') and \	1361	if myaction not in ('help', 'info', 'version') and \
Lines 1557-1566 def emerge_main(args=None): Link Here
1557		1519
1558	if settings.get("PORTAGE_DEBUG", "") == "1":	1520	if settings.get("PORTAGE_DEBUG", "") == "1":
1559	spinner.update = spinner.update_quiet	1521	spinner.update = spinner.update_quiet
		1522	portage.debug=1
1560	portage.util.noiselimit = 0	1523	portage.util.noiselimit = 0
1561	if "python-trace" in settings.features:	1524	if "python-trace" in settings.features:
1562	import portage.debug as portage_debug	1525	import portage.debug
1563	portage_debug.set_trace(True)	1526	portage.debug.set_trace(True)
1564		1527
1565	if not ("--quiet" in myopts):	1528	if not ("--quiet" in myopts):
1566	if '--nospinner' in myopts or \	1529	if '--nospinner' in myopts or \
Lines 1753-1759 def emerge_main(args=None): Link Here
1753		1716
1754	for x in myfiles:	1717	for x in myfiles:
1755	if x.startswith(SETPREFIX) or \	1718	if x.startswith(SETPREFIX) or \
1756	is_valid_package_atom(x, allow_repo=True):	1719	is_valid_package_atom(x):
1757	continue	1720	continue
1758	if x[:1] == os.sep:	1721	if x[:1] == os.sep:
1759	continue	1722	continue
1760	-

Return to bug 363137

Lines 19-25 def shorthelp(): Link Here

(-)a/pym/_emerge/help.py (-9 / +4 lines)
19	print(" [ "+green("--complete-graph")+" ] [ "+green("--deep")+" ]")	19	print(" [ "+green("--complete-graph")+" ] [ "+green("--deep")+" ]")
20	print(" [ "+green("--jobs") + " " + turquoise("JOBS")+" ] [ "+green("--keep-going")+" ] [ " + green("--load-average")+" " + turquoise("LOAD") + " ]")	20	print(" [ "+green("--jobs") + " " + turquoise("JOBS")+" ] [ "+green("--keep-going")+" ] [ " + green("--load-average")+" " + turquoise("LOAD") + " ]")
21	print(" [ "+green("--newuse")+" ] [ "+green("--noconfmem")+" ] [ "+green("--nospinner")+" ]")	21	print(" [ "+green("--newuse")+" ] [ "+green("--noconfmem")+" ] [ "+green("--nospinner")+" ]")
22	print(" [ "+green("--oneshot")+" ] [ "+green("--onlydeps")+" ]")	22	print(" [ "+green("--oneshot")+" ] [ "+green("--onlydeps")+" ] [ " + green("--misspell-suggestions")+" < " + turquoise("y") + " \| "+ turquoise("n")+" > ]")
23	print(" [ "+green("--reinstall ")+turquoise("changed-use")+" ] [ " + green("--with-bdeps")+" < " + turquoise("y") + " \| "+ turquoise("n")+" > ]")	23	print(" [ "+green("--reinstall ")+turquoise("changed-use")+" ] [ " + green("--with-bdeps")+" < " + turquoise("y") + " \| "+ turquoise("n")+" > ]")
24	print(bold("Actions:")+" [ "+green("--depclean")+" \| "+green("--list-sets")+" \| "+green("--search")+" \| "+green("--sync")+" \| "+green("--version")+" ]")	24	print(bold("Actions:")+" [ "+green("--depclean")+" \| "+green("--list-sets")+" \| "+green("--search")+" \| "+green("--sync")+" \| "+green("--version")+" ]")
25		25
Lines 280-288 def help(myopts, havecolor=1): Link Here
280	print(" With this option, output such as USE=\"dar -bar -foo\" will instead")	280	print(" With this option, output such as USE=\"dar -bar -foo\" will instead")
281	print(" be displayed as USE=\"-bar dar -foo\"")	281	print(" be displayed as USE=\"-bar dar -foo\"")
282	print()	282	print()
283	print(" " + green("--ask") + \	283	print(" "+green("--ask")+" ("+green("-a")+" short option)")
284	" [ %s \| %s ] (%s short option)" % \
285	(turquoise("y"), turquoise("n"), green("-a")))
286	desc = "Before performing the action, display what will take place (server info for " + \	284	desc = "Before performing the action, display what will take place (server info for " + \
287	"--sync, --pretend output for merge, and so forth), then ask " + \	285	"--sync, --pretend output for merge, and so forth), then ask " + \
288	"whether to proceed with the action or abort. Using --ask is more " + \	286	"whether to proceed with the action or abort. Using --ask is more " + \
Lines 580-593 def help(myopts, havecolor=1): Link Here
580	print(" printed out accompanied by a '+' for enabled and a '-' for")	578	print(" printed out accompanied by a '+' for enabled and a '-' for")
581	print(" disabled USE flags.")	579	print(" disabled USE flags.")
582	print()	580	print()
583	print(" " + green("--quiet") + \	581	print(" "+green("--quiet")+" ("+green("-q")+" short option)")
584	" [ %s \| %s ] (%s short option)" % \
585	(turquoise("y"), turquoise("n"), green("-q")))
586	print(" Effects vary, but the general outcome is a reduced or condensed")	582	print(" Effects vary, but the general outcome is a reduced or condensed")
587	print(" output from portage's displays.")	583	print(" output from portage's displays.")
588	print()	584	print()
589	print(" " + green("--quiet-build") + \	585	print(" "+green("--quiet-build"))
590	" [ %s \| %s ]" % (turquoise("y"), turquoise("n")))
591	desc = "Redirect all build output to logs alone, and do not " + \	586	desc = "Redirect all build output to logs alone, and do not " + \
592	"display it on stdout."	587	"display it on stdout."
593	for line in wrap(desc, desc_width):	588	for line in wrap(desc, desc_width):