From 4666a76e5d4808e2cc017dbe8b15b89d77541923 Mon Sep 17 00:00:00 2001 From: Zac Medico Date: Sun, 21 Oct 2007 23:23:42 +0000 Subject: [PATCH] Combine depgraph._select_dep() into create() so that create() simply calls itself recursively. In order to implement backtracking, create() will eventually operate on a stack instead of calling itself. svn path=/main/trunk/; revision=8221 --- pym/_emerge/__init__.py | 182 +++++++++++++++++----------------------- 1 file changed, 75 insertions(+), 107 deletions(-) diff --git a/pym/_emerge/__init__.py b/pym/_emerge/__init__.py index d76a244c4..e08e36310 100644 --- a/pym/_emerge/__init__.py +++ b/pym/_emerge/__init__.py @@ -1417,14 +1417,80 @@ class depgraph(object): if arg: depth = 0 depth += 1 - + update = "--update" in self.myopts and depth <= 1 + debug = "--debug" in self.myopts + buildpkgonly = "--buildpkgonly" in self.myopts + nodeps = "--nodeps" in self.myopts + empty = "empty" in self.myparams + deep = "deep" in self.myparams + strict = mytype != "installed" try: for dep_root, dep_string, dep_priority in deps: if not dep_string: continue - if not self._select_dep(dep_root, dep_string, myuse, - jbigkey, depth, dep_priority): + if debug: + print + print "Parent: ", jbigkey + print "Depstring:", dep_string + print "Priority:", dep_priority + vardb = self.roots[dep_root].trees["vartree"].dbapi + try: + self._populate_filtered_repo(dep_root, dep_string, + myuse=myuse, strict=strict) + selected_atoms = self._select_atoms(dep_root, + dep_string, myuse=myuse, strict=strict) + except portage.exception.InvalidDependString, e: + show_invalid_depstring_notice(jbigkey, dep_string, str(e)) return 0 + if debug: + print "Candidates:", selected_atoms + for x in selected_atoms: + selected_pkg = None + if x.startswith("!"): + if not buildpkgonly and \ + not nodeps and \ + jbigkey not in self._slot_collision_nodes: + if mytype != "installed" and not addme: + # It's safe to ignore blockers if the + # parent is an --onlydeps node. + continue + # The blocker applies to the root where + # th parent is or will be installed. + self.blocker_parents.setdefault( + ("blocks", myroot, x[1:]), set()).add(jbigkey) + continue + dep_pkg, existing_node = self._select_package(dep_root, x) + if not dep_pkg: + self._show_unsatisfied_dep(dep_root, x, + myparent=jbigkey) + return 0 + # In some cases, dep_check will return deps that shouldn't + # be proccessed any further, so they are identified and + # discarded here. Try to discard as few as possible since + # discarded dependencies reduce the amount of information + # available for optimization of merge order. + if vardb.match(x) and \ + not (existing_node or empty or deep or update): + myarg = None + if dep_root == self.target_root: + try: + myarg = self._set_atoms.findAtomForPackage( + dep_pkg.cpv, dep_pkg.metadata) + except portage.exception.InvalidDependString: + if not dep_pkg.installed: + # This shouldn't happen since the package + # should have been masked. + raise + if not myarg: + continue + mypriority = dep_priority.copy() + if vardb.match(x): + mypriority.satisfied = True + if not self.create(dep_pkg, myparent=jbigkey, + priority=mypriority, depth=depth): + return 0 + if debug: + print "Exiting...", jbigkey except ValueError, e: if not e.args or not isinstance(e.args[0], list) or \ len(e.args[0]) < 2: @@ -1651,7 +1717,7 @@ class depgraph(object): return (not missing,myfavorites) def _populate_filtered_repo(self, myroot, depstring, - myparent=None, myuse=None, exclude_installed=False): + strict=True, myuse=None, exclude_installed=False): """Extract all of the atoms from the depstring, select preferred packages from appropriate repositories, and use them to populate the filtered repository. This will raise InvalidDependString when @@ -1660,13 +1726,10 @@ class depgraph(object): filtered_db = self._filtered_trees[myroot]["porttree"].dbapi pkgsettings = self.pkgsettings[myroot] usepkgonly = "--usepkgonly" in self.myopts - if myparent: - p_type, p_root, p_key, p_status = myparent from portage.dep import paren_reduce, use_reduce try: - if myparent and p_type == "installed": - portage.dep._dep_check_strict = False + portage.dep._dep_check_strict = strict atoms = paren_reduce(depstring) atoms = use_reduce(atoms, uselist=myuse) atoms = list(iter_atoms(atoms)) @@ -1956,9 +2019,12 @@ class depgraph(object): e_cpv, self._mydbapi_keys))) cpv_slot = "%s:%s" % (e_cpv, metadata["SLOT"]) if portage.dep.match_from_list(atom, [cpv_slot]): + e_installed = e_type == "installed" + e_built = e_type != "ebuild" matched_packages.append( Package(type_name=e_type, root=root, - cpv=e_cpv, metadata=metadata)) + cpv=e_cpv, metadata=metadata, + built=e_built, installed=e_installed)) else: existing_node = None break @@ -2066,104 +2132,6 @@ class depgraph(object): # ordered by type preference ("ebuild" type is the last resort) return matched_packages[-1], existing_node - def _select_dep(self, myroot, depstring, myuse, - myparent, depth, priority): - """ Given a depstring, create the depgraph such that all dependencies are satisfied. - @param myroot: $ROOT where these dependencies should be merged to. - @param myuse: List of USE flags enabled for myparent. - @param myparent: The node whose depstring is being passed in. - @param priority: DepPriority indicating the dependency type. - @param depth: The depth of recursion in dependencies relative to the - nearest argument atom. - @returns: 1 on success and 0 on failure - """ - - if not depstring: - return 1 # nothing to do - - vardb = self.roots[myroot].trees["vartree"].dbapi - strict = True - if myparent: - p_type, p_root, p_key, p_status = myparent - if p_type == "installed": - strict = False - - if "--debug" in self.myopts: - print - print "Parent: ",myparent - print "Depstring:",depstring - print "Priority:", priority - - try: - self._populate_filtered_repo( - myroot, depstring, myparent=myparent, myuse=myuse) - mymerge = self._select_atoms(myroot, depstring, - myuse=myuse, strict=strict) - except portage.exception.InvalidDependString, e: - if myparent: - show_invalid_depstring_notice( - myparent, depstring, str(e)) - else: - sys.stderr.write("\n%s\n%s\n" % (depstring, str(e))) - return 0 - - if "--debug" in self.myopts: - print "Candidates:",mymerge - for x in mymerge: - selected_pkg = None - if x.startswith("!"): - if "--buildpkgonly" not in self.myopts and \ - "--nodeps" not in self.myopts and \ - myparent not in self._slot_collision_nodes: - p_type, p_root, p_key, p_status = myparent - if p_type != "installed" and p_status != "merge": - # It's safe to ignore blockers from --onlydeps nodes. - continue - self.blocker_parents.setdefault( - ("blocks", p_root, x[1:]), set()).add(myparent) - continue - else: - - pkg, existing_node = self._select_package(myroot, x) - if not pkg: - self._show_unsatisfied_dep(myroot, x, myparent=myparent) - return 0 - - # In some cases, dep_check will return deps that shouldn't - # be proccessed any further, so they are identified and - # discarded here. Try to discard as few as possible since - # discarded dependencies reduce the amount of information - # available for optimization of merge order. - if myparent and vardb.match(x) and \ - not existing_node and \ - "empty" not in self.myparams and \ - "deep" not in self.myparams and \ - not ("--update" in self.myopts and depth <= 1): - myarg = None - if myroot == self.target_root: - try: - myarg = self._set_atoms.findAtomForPackage( - pkg.cpv, pkg.metadata) - except portage.exception.InvalidDependString: - # This is already handled inside - # self.create() when necessary. - pass - if not myarg: - continue - - mypriority = None - if myparent: - mypriority = priority.copy() - if vardb.match(x): - mypriority.satisfied = True - if not self.create(pkg, myparent=myparent, - priority=mypriority, depth=depth): - return 0 - - if "--debug" in self.myopts: - print "Exiting...",myparent - return 1 - def _select_arg(self, root, atom, arg, addme): pprovided = self.pkgsettings[root].pprovideddict.get( portage.dep_getkey(atom)) -- 2.26.2