X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frules.c;h=b5f3e3e1c66e763c04856157da8b0e086ef8c68a;hb=refs%2Ftags%2Fupstream%2F0.6.30;hp=5654330bdc36b5a4cddd82c6dc58e31dc2a6be76;hpb=c948f862b552adbe2cdee24096357b887dfbb088;p=platform%2Fupstream%2Flibsolv.git

diff --git a/src/rules.c b/src/rules.c
index 5654330..b5f3e3e 100644
--- a/src/rules.c
+++ b/src/rules.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2007-2009, Novell Inc.
+ * Copyright (c) 2007-2017, SUSE Inc.
  *
  * This program is licensed under the BSD license, read LICENSE.BSD
  * for further information
@@ -32,51 +32,6 @@
 #define RULES_BLOCK 63
 
 static void addpkgruleinfo(Solver *solv, Id p, Id p2, Id d, int type, Id dep);
-static void solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded);
-
-/*-------------------------------------------------------------------
- * Check if dependency is possible
- *
- * mirrors solver_dep_fulfilled but uses map m instead of the decisionmap.
- * used in solver_addpkgrulesforweak and solver_createcleandepsmap.
- */
-
-static inline int
-dep_possible(Solver *solv, Id dep, Map *m)
-{
-  Pool *pool = solv->pool;
-  Id p, pp;
-
-  if (ISRELDEP(dep))
-    {
-      Reldep *rd = GETRELDEP(pool, dep);
-      if (rd->flags >= 8)
-	 {
-	  if (rd->flags == REL_COND || rd->flags == REL_UNLESS)
-	    return 1;
-	  if (rd->flags == REL_AND)
-	    {
-	      if (!dep_possible(solv, rd->name, m))
-		return 0;
-	      return dep_possible(solv, rd->evr, m);
-	    }
-	  if (rd->flags == REL_OR)
-	    {
-	      if (dep_possible(solv, rd->name, m))
-		return 1;
-	      return dep_possible(solv, rd->evr, m);
-	    }
-	  if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
-	    return solver_splitprovides(solv, rd->evr, m);
-	}
-    }
-  FOR_PROVIDES(p, pp, dep)
-    {
-      if (MAPTST(m, p))
-	return 1;
-    }
-  return 0;
-}
 
 static inline int
 is_otherproviders_dep(Pool *pool, Id dep)
@@ -1205,7 +1160,7 @@ solver_addpkgrulesforweak(Solver *solv, Map *m)
 	  /* find possible supplements */
 	  supp = s->repo->idarraydata + s->supplements;
 	  while ((sup = *supp++) != 0)
-	    if (dep_possible(solv, sup, m))
+	    if (solver_dep_possible(solv, sup, m))
 	      break;
 	}
 
@@ -1214,7 +1169,7 @@ solver_addpkgrulesforweak(Solver *solv, Map *m)
 	{
 	  supp = s->repo->idarraydata + s->enhances;
 	  while ((sup = *supp++) != 0)
-	    if (dep_possible(solv, sup, m))
+	    if (solver_dep_possible(solv, sup, m))
 	      break;
 	}
       /* if nothing found, goto next solvables */
@@ -1294,58 +1249,6 @@ dup_maykeepinstalled(Solver *solv, Solvable *s)
 }
 
 
-static Id
-finddistupgradepackages(Solver *solv, Solvable *s, Queue *qs)
-{
-  Pool *pool = solv->pool;
-  int i, j;
-
-  policy_findupdatepackages(solv, s, qs, 2);
-  if (qs->count)
-    {
-      /* remove installed packages we can't keep */
-      for (i = j = 0; i < qs->count; i++)
-	{
-	  Solvable *ns = pool->solvables + qs->elements[i];
-	  if (ns->repo == pool->installed && !dup_maykeepinstalled(solv, ns))
-	    continue;
-	  qs->elements[j++] = qs->elements[i];
-	}
-      queue_truncate(qs, j);
-    }
-  /* check if it is ok to keep the installed package */
-  if (dup_maykeepinstalled(solv, s))
-    return s - pool->solvables;
-  /* nope, it must be some other package */
-  return -SYSTEMSOLVABLE;
-}
-
-#if 0
-/* add packages from the dup repositories to the update candidates
- * this isn't needed for the global dup mode as all packages are
- * from dup repos in that case */
-static void
-addduppackages(Solver *solv, Solvable *s, Queue *qs)
-{
-  Queue dupqs;
-  Id p, dupqsbuf[64];
-  int i;
-  int oldnoupdateprovide = solv->noupdateprovide;
-
-  queue_init_buffer(&dupqs, dupqsbuf, sizeof(dupqsbuf)/sizeof(*dupqsbuf));
-  solv->noupdateprovide = 1;
-  policy_findupdatepackages(solv, s, &dupqs, 2);
-  solv->noupdateprovide = oldnoupdateprovide;
-  for (i = 0; i < dupqs.count; i++)
-    {
-      p = dupqs.elements[i];
-      if (MAPTST(&solv->dupmap, p))
-        queue_pushunique(qs, p);
-    }
-  queue_free(&dupqs);
-}
-#endif
-
 /* stash away the original updaters for multiversion packages. We do this so that
  * we can update the package later */
 static inline void
@@ -1392,7 +1295,7 @@ solver_addfeaturerule(Solver *solv, Solvable *s)
   queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
   p = s - pool->solvables;
   policy_findupdatepackages(solv, s, &qs, 1);
-  if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+  if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
     {
       if (!dup_maykeepinstalled(solv, s))
 	{
@@ -1440,8 +1343,8 @@ solver_addupdaterule(Solver *solv, Solvable *s)
   Id p, d;
   Queue qs;
   Id qsbuf[64];
-  int isorphaned = 0;
   Rule *r;
+  int dupinvolved = 0;
 
   p = s - pool->solvables;
   /* Orphan detection. We cheat by looking at the feature rule, which
@@ -1464,12 +1367,10 @@ solver_addupdaterule(Solver *solv, Solvable *s)
       return;
     }
 
-  queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
   /* find update candidates for 's' */
-  if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
-    p = finddistupgradepackages(solv, s, &qs);
-  else
-    policy_findupdatepackages(solv, s, &qs, 0);
+  queue_init_buffer(&qs, qsbuf, sizeof(qsbuf)/sizeof(*qsbuf));
+  dupinvolved = solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p));
+  policy_findupdatepackages(solv, s, &qs, dupinvolved ? 2 : 0);
 
   if (qs.count && solv->multiversion.size)
     {
@@ -1500,44 +1401,41 @@ solver_addupdaterule(Solver *solv, Solvable *s)
 		}
 	      qs.elements[j++] = qs.elements[i];
 	    }
-	  if (j < qs.count)		/* filtered at least one package? */
+
+	  if (j == 0 && dupinvolved && !dup_maykeepinstalled(solv, s))
 	    {
-	      if (j == 0 && p == -SYSTEMSOLVABLE)
+	      /* this is a multiversion orphan */
+	      queue_push(&solv->orphaned, p);
+	      set_specialupdaters(solv, s, d);
+	      if (solv->keep_orphans && !(solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))))
 		{
-		  /* this is a multiversion orphan */
-		  queue_push(&solv->orphaned, s - pool->solvables);
-		  set_specialupdaters(solv, s, d);
-		  if (solv->keep_orphans && !(solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, s - pool->solvables - solv->installed->start))))
-		    {
-		      /* we need to keep the orphan */
-		      queue_free(&qs);
-		      solver_addrule(solv, s - pool->solvables, 0, 0);
-		      return;
-		    }
-		  /* we can drop it as long as we update */
-		  isorphaned = 1;
-		  j = qs.count;		/* force the update */
+		  /* we need to keep the orphan */
+		  queue_free(&qs);
+		  solver_addrule(solv, p, 0, 0);
+		  return;
 		}
-	      else if (d && (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, s - pool->solvables - solv->installed->start))))
+	      /* we can drop it as long as we update */
+	      j = qs.count;
+	    }
+
+	  if (j < qs.count)		/* filtered at least one package? */
+	    {
+	      if (d && (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p - solv->installed->start))))
 		{
 		  /* non-orphan multiversion package, set special updaters if we want an update */
 		  set_specialupdaters(solv, s, d);
 		}
 	      qs.count = j;
 	    }
-	  else if (p != -SYSTEMSOLVABLE)
+	  else
 	    {
 	      /* could fallthrough, but then we would do pool_queuetowhatprovides twice */
 	      queue_free(&qs);
-	      solver_addrule(solv, s - pool->solvables, 0, d);	/* allow update of s */
+	      solver_addrule(solv, p, 0, d);	/* allow update of s */
 	      return;
 	    }
 	}
     }
-  if (!isorphaned && p == -SYSTEMSOLVABLE && qs.count && solv->dupmap.size)
-    p = s - pool->solvables;		/* let the dup rules sort it out */
-  if (qs.count && p == -SYSTEMSOLVABLE)
-    p = queue_shift(&qs);
   if (qs.count > 1)
     {
       d = pool_queuetowhatprovides(pool, &qs);
@@ -1664,9 +1562,10 @@ solver_addinfarchrules(Solver *solv, Map *addedmap)
 	  a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
 	  if (a != 1 && installed && ps->repo == installed)
 	    {
-	      if (!solv->dupmap_all && !(solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
-	        queue_pushunique(&allowedarchs, ps->arch);	/* also ok to keep this architecture */
-	      continue;		/* ignore installed solvables when calculating the best arch */
+	      if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+		continue;
+	      queue_pushunique(&allowedarchs, ps->arch);	/* also ok to keep this architecture */
+	      continue;		/* but ignore installed solvables when calculating the best arch */
 	    }
 	  if (a && a != 1 && (!bestarch || a < bestarch))
 	    {
@@ -1692,7 +1591,7 @@ solver_addinfarchrules(Solver *solv, Map *addedmap)
 	      ps = pool->solvables + p;
 	      if (ps->name != s->name || ps->repo != installed || !MAPTST(addedmap, p))
 		continue;
-	      if (solv->dupmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
+	      if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
 		continue;
 	      a = ps->arch;
 	      a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
@@ -1834,7 +1733,7 @@ reenableinfarchrule(Solver *solv, Id name)
  ***/
 
 static inline void
-add_cleandeps_package(Solver *solv, Id p)
+add_cleandeps_updatepkg(Solver *solv, Id p)
 {
   if (!solv->cleandeps_updatepkgs)
     {
@@ -1852,6 +1751,9 @@ solver_addtodupmaps(Solver *solv, Id p, Id how, int targeted)
   Repo *installed = solv->installed;
   Id pi, pip, obs, *obsp;
 
+  if (!solv->dupinvolvedmap.size)
+    map_grow(&solv->dupinvolvedmap, pool->nsolvables);
+
   MAPSET(&solv->dupinvolvedmap, p);
   if (targeted)
     MAPSET(&solv->dupmap, p);
@@ -1868,14 +1770,14 @@ solver_addtodupmaps(Solver *solv, Id p, Id how, int targeted)
 	    if (pool->solvables[pi2].repo != installed)
 	      MAPSET(&solv->dupinvolvedmap, pi2);
 	}
-      if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0)
+      if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0 && !solv->bestupdatemap_all)
 	{
 	  if (!solv->bestupdatemap.size)
 	    map_grow(&solv->bestupdatemap, installed->end - installed->start);
 	  MAPSET(&solv->bestupdatemap, pi - installed->start);
 	}
       if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
-	add_cleandeps_package(solv, pi);
+	add_cleandeps_updatepkg(solv, pi);
       if (!targeted && ps->repo != installed)
 	MAPSET(&solv->dupmap, pi);
     }
@@ -1913,19 +1815,23 @@ solver_addtodupmaps(Solver *solv, Id p, Id how, int targeted)
 		    if (pool->solvables[pi2].repo != installed)
 		      MAPSET(&solv->dupinvolvedmap, pi2);
 		}
-	      if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0)
+	      if (ps->repo == installed && (how & SOLVER_FORCEBEST) != 0 && !solv->bestupdatemap_all)
 		{
 		  if (!solv->bestupdatemap.size)
 		    map_grow(&solv->bestupdatemap, installed->end - installed->start);
 		  MAPSET(&solv->bestupdatemap, pi - installed->start);
 		}
 	      if (ps->repo == installed && (how & SOLVER_CLEANDEPS) != 0)
-		add_cleandeps_package(solv, pi);
+		add_cleandeps_updatepkg(solv, pi);
 	    }
 	}
     }
 }
 
+/* create the two dupmaps:
+ * - dupmap: packages in that map are good to install/keep
+ * - dupinvolvedmap: packages are subject to dup mode
+ */
 void
 solver_createdupmaps(Solver *solv)
 {
@@ -1937,7 +1843,8 @@ solver_createdupmaps(Solver *solv)
   int i, targeted;
 
   map_init(&solv->dupmap, pool->nsolvables);
-  map_init(&solv->dupinvolvedmap, pool->nsolvables);
+  solv->dupinvolvedmap_all = 0;
+  map_init(&solv->dupinvolvedmap, 0);
   for (i = 0; i < job->count; i += 2)
     {
       how = job->elements[i];
@@ -1966,11 +1873,22 @@ solver_createdupmaps(Solver *solv)
 	    }
 	  else if (select == SOLVER_SOLVABLE_ALL)
 	    {
+	      solv->dupinvolvedmap_all = 1;
 	      FOR_POOL_SOLVABLES(p)
 		{
-		  MAPSET(&solv->dupinvolvedmap, p);
-		  if (installed && pool->solvables[p].repo != installed)
-		    MAPSET(&solv->dupmap, p);
+		  Solvable *s = pool->solvables + p;
+		  if (!s->repo || s->repo == installed)
+		    continue;
+		  if (!pool_installable(pool, s))
+		    continue;
+		  MAPSET(&solv->dupmap, p);
+		}
+	      if ((how & SOLVER_FORCEBEST) != 0)
+		solv->bestupdatemap_all = 1;
+	      if ((how & SOLVER_CLEANDEPS) != 0 && installed)
+		{
+		  FOR_REPO_SOLVABLES(installed, p, s)
+		    add_cleandeps_updatepkg(solv, p);
 		}
 	    }
 	  else
@@ -2002,7 +1920,8 @@ solver_createdupmaps(Solver *solv)
 	  break;
 	}
     }
-  MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE);
+  if (solv->dupinvolvedmap.size)
+    MAPCLR(&solv->dupinvolvedmap, SYSTEMSOLVABLE);
 }
 
 void
@@ -2024,6 +1943,8 @@ solver_addduprules(Solver *solv, Map *addedmap)
   Rule *r;
 
   solv->duprules = solv->nrules;
+  if (solv->dupinvolvedmap_all)
+    solv->updatemap_all = 1;
   for (i = 1; i < pool->nsolvables; i++)
     {
       if (i == SYSTEMSOLVABLE || !MAPTST(addedmap, i))
@@ -2039,13 +1960,16 @@ solver_addduprules(Solver *solv, Map *addedmap)
 	    first = 0;
 	  if (first)
 	    break;
-	  if (!MAPTST(&solv->dupinvolvedmap, p))
+	  if (!solv->dupinvolvedmap_all && !MAPTST(&solv->dupinvolvedmap, p))
 	    continue;
 	  if (installed && ps->repo == installed)
 	    {
-	      if (!solv->updatemap.size)
-		map_grow(&solv->updatemap, installed->end - installed->start);
-	      MAPSET(&solv->updatemap, p - installed->start);
+	      if (!solv->updatemap_all)
+		{
+		  if (!solv->updatemap.size)
+		    map_grow(&solv->updatemap, installed->end - installed->start);
+		  MAPSET(&solv->updatemap, p - installed->start);
+		}
 	      if (!MAPTST(&solv->dupmap, p))
 		{
 		  Id ip, ipp;
@@ -2060,24 +1984,35 @@ solver_addduprules(Solver *solv, Map *addedmap)
 		    }
 		  if (ip)
 		    {
-		      /* ok, found a good one. we may keep this package. */
+		      /* ok, identical to a good one. we may keep this package. */
 		      MAPSET(&solv->dupmap, p);		/* for best rules processing */
 		      continue;
 		    }
+		  /* check if it's orphaned. If yes, we may keep it */
 		  r = solv->rules + solv->updaterules + (p - installed->start);
 		  if (!r->p)
-		      r = solv->rules + solv->featurerules + (p - installed->start);
-		  if (r->p && solv->specialupdaters && solv->specialupdaters[p - installed->start])
+		    r = solv->rules + solv->featurerules + (p - installed->start);
+		  if (!r->p)
+		    {
+		      /* no update/feature rule, this is an orphan */
+		      MAPSET(&solv->dupmap, p);		/* for best rules processing */
+		      continue;
+		    }
+		  if (solv->specialupdaters && solv->specialupdaters[p - installed->start])
 		    {
 		      /* this is a multiversion orphan, we're good if an update is installed */
 		      solver_addrule(solv, -p, 0, solv->specialupdaters[p - installed->start]);
 		      continue;
 		    }
-		  if (!r->p || (r->p == p && !r->d && !r->w2))
+		  if (r->p == p && !r->d && !r->w2)
 		    {
-		      /* this is an orphan */
-		      MAPSET(&solv->dupmap, p);		/* for best rules processing */
-		      continue;
+		      r = solv->rules + solv->featurerules + (p - installed->start);
+		      if (!r->p || (!r->d && !r->w2))
+			{
+			  /* this is an orphan */
+			  MAPSET(&solv->dupmap, p);		/* for best rules processing */
+			  continue;
+			}
 		    }
 		  solver_addrule(solv, -p, 0, 0);	/* no match, sorry */
 		}
@@ -2137,120 +2072,6 @@ reenableduprule(Solver *solv, Id name)
 #define DISABLE_INFARCH	2
 #define DISABLE_DUP	3
 
-/*
- * add all installed packages that package p obsoletes to Queue q.
- * Package p is not installed. Also, we know that if
- * solv->keepexplicitobsoletes is not set, p is not in the multiversion map.
- * Entries may get added multiple times.
- */
-static void
-add_obsoletes(Solver *solv, Id p, Queue *q)
-{
-  Pool *pool = solv->pool;
-  Repo *installed = solv->installed;
-  Id p2, pp2;
-  Solvable *s = pool->solvables + p;
-  Id obs, *obsp;
-  Id lastp2 = 0;
-
-  if (!solv->keepexplicitobsoletes || !(solv->multiversion.size && MAPTST(&solv->multiversion, p)))
-    {
-      FOR_PROVIDES(p2, pp2, s->name)
-	{
-	  Solvable *ps = pool->solvables + p2;
-	  if (ps->repo != installed)
-	    continue;
-	  if (!pool->implicitobsoleteusesprovides && ps->name != s->name)
-	    continue;
-	  if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
-	    continue;
-	  queue_push(q, p2);
-	  lastp2 = p2;
-	}
-    }
-  if (!s->obsoletes)
-    return;
-  obsp = s->repo->idarraydata + s->obsoletes;
-  while ((obs = *obsp++) != 0)
-    FOR_PROVIDES(p2, pp2, obs)
-      {
-	Solvable *ps = pool->solvables + p2;
-	if (ps->repo != installed)
-	  continue;
-	if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
-	  continue;
-	if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
-	  continue;
-	if (p2 == lastp2)
-	  continue;
-	queue_push(q, p2);
-	lastp2 = p2;
-      }
-}
-
-/*
- * Call add_obsoletes and intersect the result with the
- * elements in Queue q starting at qstart.
- * Assumes that it's the first call if qstart == q->count.
- * May use auxillary map m for the intersection process, all
- * elements of q starting at qstart must have their bit cleared.
- * (This is also true after the function returns.)
- */
-static void
-intersect_obsoletes(Solver *solv, Id p, Queue *q, int qstart, Map *m)
-{
-  int i, j;
-  int qcount = q->count;
-
-  add_obsoletes(solv, p, q);
-  if (qcount == qstart)
-    return;	/* first call */
-  if (qcount == q->count)
-    j = qstart;	
-  else if (qcount == qstart + 1)
-    {
-      /* easy if there's just one element */
-      j = qstart;
-      for (i = qcount; i < q->count; i++)
-	if (q->elements[i] == q->elements[qstart])
-	  {
-	    j++;	/* keep the element */
-	    break;
-	  }
-    }
-  else if (!m->size && q->count - qstart <= 8)
-    {
-      /* faster than a map most of the time */
-      int k;
-      for (i = j = qstart; i < qcount; i++)
-	{
-	  Id ip = q->elements[i];
-	  for (k = qcount; k < q->count; k++)
-	    if (q->elements[k] == ip)
-	      {
-		q->elements[j++] = ip;
-		break;
-	      }
-	}
-    }
-  else
-    {
-      /* for the really pathologic cases we use the map */
-      Repo *installed = solv->installed;
-      if (!m->size)
-	map_init(m, installed->end - installed->start);
-      for (i = qcount; i < q->count; i++)
-	MAPSET(m, q->elements[i] - installed->start);
-      for (i = j = qstart; i < qcount; i++)
-	if (MAPTST(m, q->elements[i] - installed->start))
-	  {
-	    MAPCLR(m, q->elements[i] - installed->start);
-	    q->elements[j++] = q->elements[i];
-	  }
-    }
-  queue_truncate(q, j);
-}
-
 static void
 jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
 {
@@ -2343,30 +2164,19 @@ jobtodisablelist(Solver *solv, Id how, Id what, Queue *q)
 	return;
       /* now the hard part: disable some update rules */
 
-      /* first check if we have multiversion or installed packages in the job */
-      i = j = 0;
+      /* first check if we have installed or multiversion packages in the job */
       FOR_JOB_SELECT(p, pp, select, what)
 	{
 	  if (pool->solvables[p].repo == installed)
-	    j = p;
-	  else if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
 	    return;
-	  i++;
-	}
-      if (j)	/* have installed packages */
-	{
-	  /* this is for dupmap_all jobs, it can go away if we create
-	   * duprules for them */
-	  if (i == 1 && (set & SOLVER_SETREPO) != 0)
-	    queue_push2(q, DISABLE_UPDATE, j);
-	  return;
+	  if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
+	    return;
 	}
-
       omap.size = 0;
       qstart = q->count;
       FOR_JOB_SELECT(p, pp, select, what)
 	{
-	  intersect_obsoletes(solv, p, q, qstart, &omap);
+	  solver_intersect_obsoleted(solv, p, q, qstart, &omap);
 	  if (q->count == qstart)
 	    break;
 	}
@@ -3439,11 +3249,6 @@ solver_addbestrules(Solver *solv, int havebestinstalljobs)
   int i, oldcnt;
 
   solv->bestrules = solv->nrules;
-  if (!installed)
-    {
-      solv->bestrules_end = solv->nrules;
-      return;
-    }
   queue_init(&q);
   queue_init(&q2);
   queue_init(&r2pkg);
@@ -3483,7 +3288,7 @@ solver_addbestrules(Solver *solv, int havebestinstalljobs)
 	}
     }
 
-  if (solv->bestupdatemap_all || solv->bestupdatemap.size)
+  if (installed && (solv->bestupdatemap_all || solv->bestupdatemap.size))
     {
       Map m;
 
@@ -3810,1125 +3615,6 @@ for (j = 0; j < qq.count; j++)
   POOL_DEBUG(SOLV_DEBUG_STATS, "yumobs rule creation took %d ms\n", solv_timems(now));
 }
 
-#undef CLEANDEPSDEBUG
-
-/*
- * This functions collects all packages that are looked at
- * when a dependency is checked. We need it to "pin" installed
- * packages when removing a supplemented package in createcleandepsmap.
- * Here's an not uncommon example:
- *   A contains "Supplements: packageand(B, C)"
- *   B contains "Requires: A"
- * Now if we remove C, the supplements is no longer true,
- * thus we also remove A. Without the dep_pkgcheck function, we
- * would now also remove B, but this is wrong, as adding back
- * C doesn't make the supplements true again. Thus we "pin" B
- * when we remove A.
- * There's probably a better way to do this, but I haven't come
- * up with it yet ;)
- */
-static inline void
-dep_pkgcheck(Solver *solv, Id dep, Map *m, Queue *q)
-{
-  Pool *pool = solv->pool;
-  Id p, pp;
-
-  if (ISRELDEP(dep))
-    {
-      Reldep *rd = GETRELDEP(pool, dep);
-      if (rd->flags >= 8)
-	{
-	  if (rd->flags == REL_AND)
-	    {
-	      dep_pkgcheck(solv, rd->name, m, q);
-	      dep_pkgcheck(solv, rd->evr, m, q);
-	      return;
-	    }
-	  if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
-	    return;
-	}
-    }
-  FOR_PROVIDES(p, pp, dep)
-    if (!m || MAPTST(m, p))
-      queue_push(q, p);
-}
-
-static int
-check_xsupp(Solver *solv, Queue *depq, Id dep)
-{
-  Pool *pool = solv->pool;
-  Id p, pp;
-
-  if (ISRELDEP(dep))
-    {
-      Reldep *rd = GETRELDEP(pool, dep);
-      if (rd->flags >= 8)
-	{
-	  if (rd->flags == REL_AND)
-	    {
-	      if (!check_xsupp(solv, depq, rd->name))
-		return 0;
-	      return check_xsupp(solv, depq, rd->evr);
-	    }
-	  if (rd->flags == REL_OR)
-	    {
-	      if (check_xsupp(solv, depq, rd->name))
-		return 1;
-	      return check_xsupp(solv, depq, rd->evr);
-	    }
-	  if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
-#if 0
-	    return solver_splitprovides(solv, rd->evr);
-#else
-	    return 0;
-#endif
-	}
-      if (depq && rd->flags == REL_NAMESPACE)
-	{
-	  int i;
-	  for (i = 0; i < depq->count; i++)
-	    if (depq->elements[i] == dep || depq->elements[i] == rd->name)
-	     return 1;
-	}
-    }
-  FOR_PROVIDES(p, pp, dep)
-    if (p == SYSTEMSOLVABLE || pool->solvables[p].repo == solv->installed)
-      return 1;
-  return 0;
-}
-
-static inline int
-queue_contains(Queue *q, Id id)
-{
-  int i;
-  for (i = 0; i < q->count; i++)
-    if (q->elements[i] == id)
-      return 1;
-  return 0;
-}
-
-#ifdef ENABLE_COMPLEX_DEPS
-static void
-complex_cleandeps_remove(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq)
-{
-  int i;
-  Queue dq;
-  Id p;
-
-  queue_init(&dq);
-  i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
-  if (i == 0 || i == 1)
-    {
-      queue_free(&dq);
-      return;
-    }
-  for (i = 0; i < dq.count; i++)
-    {
-      for (; (p = dq.elements[i]) != 0; i++)
-	{
-	  if (p < 0)
-	    {
-	      if (!MAPTST(installedm, -p))
-	        break;
-	      continue;
-	    }
-	  if (p != SYSTEMSOLVABLE && MAPTST(im, p))
-	    {
-#ifdef CLEANDEPSDEBUG
-	      printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-	      queue_push(iq, p);
-	    }
-	}
-      while (dq.elements[i])
-	i++;
-    }
-  queue_free(&dq);
-}
-
-static void
-complex_cleandeps_addback(Pool *pool, Id ip, Id req, Map *im, Map *installedm, Queue *iq, Map *userinstalled)
-{
-  int i, blk;
-  Queue dq;
-  Id p;
-
-  queue_init(&dq);
-  i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
-  if (i == 0 || i == 1)
-    {
-      queue_free(&dq);
-      return;
-    }
-  for (i = 0; i < dq.count; i++)
-    {
-      blk = i;
-      for (; (p = dq.elements[i]) != 0; i++)
-	{
-	  if (p < 0)
-	    {
-	      if (!MAPTST(installedm, -p))
-	        break;
-	    }
-	  else if (p == ip)
-	    break;
-	}
-      if (!p)
-	{
-	  for (i = blk; (p = dq.elements[i]) != 0; i++)
-	    {
-	      if (p < 0)
-		continue;
-	      if (MAPTST(im, p))
-		continue;
-	      if (!MAPTST(installedm, p))
-		continue;
-	      if (p == ip || MAPTST(userinstalled, p - pool->installed->start))
-		continue;
-#ifdef CLEANDEPSDEBUG
-	      printf("%s requires/recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-	      MAPSET(im, p);
-	      queue_push(iq, p);
-	    }
-	}
-      while (dq.elements[i])
-	i++;
-    }
-  queue_free(&dq);
-}
-
-#endif
-
-/*
- * Find all installed packages that are no longer
- * needed regarding the current solver job.
- *
- * The algorithm is:
- * - remove pass: remove all packages that could have
- *   been dragged in by the obsoleted packages.
- *   i.e. if package A is obsolete and contains "Requires: B",
- *   also remove B, as installing A will have pulled in B.
- *   after this pass, we have a set of still installed packages
- *   with broken dependencies.
- * - add back pass:
- *   now add back all packages that the still installed packages
- *   require.
- *
- * The cleandeps packages are the packages removed in the first
- * pass and not added back in the second pass.
- *
- * If we search for unneeded packages (unneeded is true), we
- * simply remove all packages except the userinstalled ones in
- * the first pass.
- */
-static void
-solver_createcleandepsmap(Solver *solv, Map *cleandepsmap, int unneeded)
-{
-  Pool *pool = solv->pool;
-  Repo *installed = solv->installed;
-  Queue *job = &solv->job;
-  Map userinstalled;
-  Map im;
-  Map installedm;
-  Rule *r;
-  Id rid, how, what, select;
-  Id p, pp, ip, jp;
-  Id req, *reqp, sup, *supp;
-  Solvable *s;
-  Queue iq, iqcopy, xsuppq;
-  int i;
-
-  map_empty(cleandepsmap);
-  if (!installed || installed->end == installed->start)
-    return;
-  map_init(&userinstalled, installed->end - installed->start);
-  map_init(&im, pool->nsolvables);
-  map_init(&installedm, pool->nsolvables);
-  queue_init(&iq);
-  queue_init(&xsuppq);
-
-  for (i = 0; i < job->count; i += 2)
-    {
-      how = job->elements[i];
-      if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
-	{
-	  what = job->elements[i + 1];
-	  select = how & SOLVER_SELECTMASK;
-	  if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
-	    {
-	      FOR_REPO_SOLVABLES(installed, p, s)
-	        MAPSET(&userinstalled, p - installed->start);
-	    }
-	  FOR_JOB_SELECT(p, pp, select, what)
-	    if (pool->solvables[p].repo == installed)
-	      MAPSET(&userinstalled, p - installed->start);
-	}
-      if ((how & (SOLVER_JOBMASK | SOLVER_SELECTMASK)) == (SOLVER_ERASE | SOLVER_SOLVABLE_PROVIDES))
-	{
-	  what = job->elements[i + 1];
-	  if (ISRELDEP(what))
-	    {
-	      Reldep *rd = GETRELDEP(pool, what);
-	      if (rd->flags != REL_NAMESPACE)
-		continue;
-	      if (rd->evr == 0)
-		{
-		  queue_pushunique(&iq, rd->name);
-		  continue;
-		}
-	      FOR_PROVIDES(p, pp, what)
-		if (p)
-		  break;
-	      if (p)
-		continue;
-	      queue_pushunique(&iq, what);
-	    }
-	}
-    }
-
-  /* have special namespace cleandeps erases */
-  if (iq.count)
-    {
-      for (ip = installed->start; ip < installed->end; ip++)
-	{
-	  s = pool->solvables + ip;
-	  if (s->repo != installed)
-	    continue;
-	  if (!s->supplements)
-	    continue;
-	  supp = s->repo->idarraydata + s->supplements;
-	  while ((sup = *supp++) != 0)
-	    if (ISRELDEP(sup) && check_xsupp(solv, &iq, sup) && !check_xsupp(solv, 0, sup))
-	      {
-#ifdef CLEANDEPSDEBUG
-		printf("xsupp %s from %s\n", pool_dep2str(pool, sup), pool_solvid2str(pool, ip));
-#endif
-	        queue_pushunique(&xsuppq, sup);
-	      }
-	}
-      queue_empty(&iq);
-    }
-
-  /* also add visible patterns to userinstalled for openSUSE */
-  if (1)
-    {
-      Dataiterator di;
-      dataiterator_init(&di, pool, 0, 0, SOLVABLE_ISVISIBLE, 0, 0);
-      while (dataiterator_step(&di))
-	{
-	  Id *dp;
-	  if (di.solvid <= 0)
-	    continue;
-	  s = pool->solvables + di.solvid;
-	  if (!s->repo || !s->requires)
-	    continue;
-	  if (s->repo != installed && !pool_installable(pool, s))
-	    continue;
-	  if (strncmp(pool_id2str(pool, s->name), "pattern:", 8) != 0)
-	    continue;
-	  dp = s->repo->idarraydata + s->requires;
-	  for (dp = s->repo->idarraydata + s->requires; *dp; dp++)
-	    FOR_PROVIDES(p, pp, *dp)
-	      if (pool->solvables[p].repo == installed)
-		{
-		  if (strncmp(pool_id2str(pool, pool->solvables[p].name), "pattern", 7) != 0)
-		    continue;
-		  MAPSET(&userinstalled, p - installed->start);
-		}
-	}
-      dataiterator_free(&di);
-    }
-  if (1)
-    {
-      /* all products and their buddies are userinstalled */
-      for (p = installed->start; p < installed->end; p++)
-	{
-	  Solvable *s = pool->solvables + p;
-	  if (s->repo != installed)
-	    continue;
-	  if (!strncmp("product:", pool_id2str(pool, s->name), 8))
-	    {
-	      MAPSET(&userinstalled, p - installed->start);
-#ifdef ENABLE_LINKED_PKGS
-	      if (solv->instbuddy && solv->instbuddy[p - installed->start] > 1)
-		{
-		  Id buddy = solv->instbuddy[p - installed->start];
-		  if (buddy >= installed->start && buddy < installed->end)
-		    MAPSET(&userinstalled, buddy - installed->start);
-		}
-#endif
-	    }
-	}
-    }
-
-  /* add all positive elements (e.g. locks) to "userinstalled" */
-  for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
-    {
-      r = solv->rules + rid;
-      if (r->d < 0)
-	continue;
-      i = solv->ruletojob.elements[rid - solv->jobrules];
-      if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
-	continue;
-      FOR_RULELITERALS(p, jp, r)
-	if (p > 0 && pool->solvables[p].repo == installed)
-	  MAPSET(&userinstalled, p - installed->start);
-    }
-
-  /* add all cleandeps candidates to iq */
-  for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
-    {
-      r = solv->rules + rid;
-      if (r->d < 0)				/* disabled? */
-	continue;
-      if (r->d == 0 && r->p < 0 && r->w2 == 0)	/* negative assertion (erase job)? */
-	{
-	  p = -r->p;
-	  if (pool->solvables[p].repo != installed)
-	    continue;
-	  MAPCLR(&userinstalled, p - installed->start);
-	  if (unneeded)
-	    continue;
-	  i = solv->ruletojob.elements[rid - solv->jobrules];
-	  how = job->elements[i];
-	  if ((how & (SOLVER_JOBMASK|SOLVER_CLEANDEPS)) == (SOLVER_ERASE|SOLVER_CLEANDEPS))
-	    queue_push(&iq, p);
-	}
-      else if (r->p > 0)			/* install job */
-	{
-	  if (unneeded)
-	    continue;
-	  i = solv->ruletojob.elements[rid - solv->jobrules];
-	  if ((job->elements[i] & SOLVER_CLEANDEPS) == SOLVER_CLEANDEPS)
-	    {
-	      /* check if the literals all obsolete some installed package */
-	      Map om;
-	      int iqstart;
-
-	      /* just one installed literal */
-	      if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
-		continue;
-	      /* multiversion is bad */
-	      if (solv->multiversion.size && !solv->keepexplicitobsoletes)
-		{
-		  FOR_RULELITERALS(p, jp, r)
-		    if (MAPTST(&solv->multiversion, p))
-		      break;
-		  if (p)
-		    continue;
-		}
-
-	      om.size = 0;
-	      iqstart = iq.count;
-	      FOR_RULELITERALS(p, jp, r)
-		{
-		  if (p < 0)
-		    {
-		      queue_truncate(&iq, iqstart);	/* abort */
-		      break;
-		    }
-		  if (pool->solvables[p].repo == installed)
-		    {
-		      if (iq.count == iqstart)
-			queue_push(&iq, p);
-		      else
-			{
-			  for (i = iqstart; i < iq.count; i++)
-			    if (iq.elements[i] == p)
-			      break;
-			  queue_truncate(&iq, iqstart);
-			  if (i < iq.count)
-			    queue_push(&iq, p);
-			}
-		    }
-		  else
-		    intersect_obsoletes(solv, p, &iq, iqstart, &om);
-		  if (iq.count == iqstart)
-		    break;
-		}
-	      if (om.size)
-	        map_free(&om);
-	    }
-	}
-    }
-  queue_init_clone(&iqcopy, &iq);
-
-  if (!unneeded)
-    {
-      if (solv->cleandeps_updatepkgs)
-	for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
-	  queue_push(&iq, solv->cleandeps_updatepkgs->elements[i]);
-    }
-
-  if (unneeded)
-    queue_empty(&iq);	/* just in case... */
-
-  /* clear userinstalled bit for the packages we really want to delete/update */
-  for (i = 0; i < iq.count; i++)
-    {
-      p = iq.elements[i];
-      if (pool->solvables[p].repo != installed)
-	continue;
-      MAPCLR(&userinstalled, p - installed->start);
-    }
-
-  for (p = installed->start; p < installed->end; p++)
-    {
-      if (pool->solvables[p].repo != installed)
-	continue;
-      MAPSET(&installedm, p);
-      if (unneeded && !MAPTST(&userinstalled, p - installed->start))
-	continue;
-      MAPSET(&im, p);
-    }
-  MAPSET(&installedm, SYSTEMSOLVABLE);
-  MAPSET(&im, SYSTEMSOLVABLE);
-
-#ifdef CLEANDEPSDEBUG
-  printf("REMOVE PASS\n");
-#endif
-
-  for (;;)
-    {
-      if (!iq.count)
-	{
-	  if (unneeded)
-	    break;
-	  /* supplements pass */
-	  for (ip = installed->start; ip < installed->end; ip++)
-	    {
-	      if (!MAPTST(&installedm, ip))
-		continue;
-	      s = pool->solvables + ip;
-	      if (!s->supplements)
-		continue;
-	      if (!MAPTST(&im, ip))
-		continue;
-	      if (MAPTST(&userinstalled, ip - installed->start))
-		continue;
-	      supp = s->repo->idarraydata + s->supplements;
-	      while ((sup = *supp++) != 0)
-		if (dep_possible(solv, sup, &im))
-		  break;
-	      if (!sup)
-		{
-		  supp = s->repo->idarraydata + s->supplements;
-		  while ((sup = *supp++) != 0)
-		    if (dep_possible(solv, sup, &installedm) || (xsuppq.count && queue_contains(&xsuppq, sup)))
-		      {
-		        /* no longer supplemented, also erase */
-			int iqcount = iq.count;
-			/* pin packages, see comment above dep_pkgcheck */
-			dep_pkgcheck(solv, sup, &im, &iq);
-			for (i = iqcount; i < iq.count; i++)
-			  {
-			    Id pqp = iq.elements[i];
-			    if (pool->solvables[pqp].repo == installed)
-			      MAPSET(&userinstalled, pqp - installed->start);
-			  }
-			queue_truncate(&iq, iqcount);
-#ifdef CLEANDEPSDEBUG
-		        printf("%s supplemented [%s]\n", pool_solvid2str(pool, ip), pool_dep2str(pool, sup));
-#endif
-		        queue_push(&iq, ip);
-		      }
-		}
-	    }
-	  if (!iq.count)
-	    break;	/* no supplementing package found, we're done */
-	}
-      ip = queue_shift(&iq);
-      s = pool->solvables + ip;
-      if (!MAPTST(&im, ip))
-	continue;
-      if (!MAPTST(&installedm, ip))
-	continue;
-      if (s->repo == installed && MAPTST(&userinstalled, ip - installed->start))
-	continue;
-      MAPCLR(&im, ip);
-#ifdef CLEANDEPSDEBUG
-      printf("removing %s\n", pool_solvable2str(pool, s));
-#endif
-      if (s->requires)
-	{
-	  reqp = s->repo->idarraydata + s->requires;
-	  while ((req = *reqp++) != 0)
-	    {
-	      if (req == SOLVABLE_PREREQMARKER)
-		continue;
-#ifdef ENABLE_COMPLEX_DEPS
-	      if (pool_is_complex_dep(pool, req))
-		{
-		  complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
-		  continue;
-		}
-#endif
-	      FOR_PROVIDES(p, pp, req)
-		{
-		  if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
-		    {
-#ifdef CLEANDEPSDEBUG
-		      printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-		      queue_push(&iq, p);
-		    }
-		}
-	    }
-	}
-      if (s->recommends)
-	{
-	  reqp = s->repo->idarraydata + s->recommends;
-	  while ((req = *reqp++) != 0)
-	    {
-#ifdef ENABLE_COMPLEX_DEPS
-	      if (pool_is_complex_dep(pool, req))
-		{
-		  complex_cleandeps_remove(pool, ip, req, &im, &installedm, &iq);
-		  continue;
-		}
-#endif
-	      FOR_PROVIDES(p, pp, req)
-		{
-		  if (p != SYSTEMSOLVABLE && MAPTST(&im, p))
-		    {
-#ifdef CLEANDEPSDEBUG
-		      printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-		      queue_push(&iq, p);
-		    }
-		}
-	    }
-	}
-    }
-
-  /* turn userinstalled into remove set for pruning */
-  map_empty(&userinstalled);
-  for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
-    {
-      r = solv->rules + rid;
-      if (r->p >= 0 || r->d != 0 || r->w2 != 0)
-	continue;	/* disabled or not erase */
-      p = -r->p;
-      MAPCLR(&im, p);
-      if (pool->solvables[p].repo == installed)
-        MAPSET(&userinstalled, p - installed->start);
-    }
-  if (!unneeded && solv->cleandeps_updatepkgs)
-    {
-      for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
-	{
-	  p = solv->cleandeps_updatepkgs->elements[i];
-	  if (pool->solvables[p].repo == installed)
-	    MAPSET(&userinstalled, p - installed->start);
-	}
-    }
-  MAPSET(&im, SYSTEMSOLVABLE);	/* in case we cleared it above */
-  for (p = installed->start; p < installed->end; p++)
-    if (MAPTST(&im, p))
-      queue_push(&iq, p);
-  for (rid = solv->jobrules; rid < solv->jobrules_end; rid++)
-    {
-      r = solv->rules + rid;
-      if (r->d < 0)
-	continue;
-      FOR_RULELITERALS(p, jp, r)
-	if (p > 0)
-          queue_push(&iq, p);
-    }
-  /* also put directly addressed packages on the install queue
-   * so we can mark patterns as installed */
-  for (i = 0; i < job->count; i += 2)
-    {
-      how = job->elements[i];
-      if ((how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
-	{
-	  what = job->elements[i + 1];
-	  select = how & SOLVER_SELECTMASK;
-	  if (select == SOLVER_SOLVABLE && pool->solvables[what].repo != installed)
-            queue_push(&iq, what);
-	}
-    }
-
-#ifdef CLEANDEPSDEBUG
-  printf("ADDBACK PASS\n");
-#endif
-  for (;;)
-    {
-      if (!iq.count)
-	{
-	  /* supplements pass */
-	  for (ip = installed->start; ip < installed->end; ip++)
-	    {
-	      if (!MAPTST(&installedm, ip))
-		continue;
-	      if (MAPTST(&userinstalled, ip - installed->start))
-	        continue;
-	      s = pool->solvables + ip;
-	      if (!s->supplements)
-		continue;
-	      if (MAPTST(&im, ip))
-		continue;
-	      supp = s->repo->idarraydata + s->supplements;
-	      while ((sup = *supp++) != 0)
-		if (dep_possible(solv, sup, &im))
-		  break;
-	      if (sup)
-		{
-#ifdef CLEANDEPSDEBUG
-		  printf("%s supplemented\n", pool_solvid2str(pool, ip));
-#endif
-		  MAPSET(&im, ip);
-		  queue_push(&iq, ip);
-		}
-	    }
-	  if (!iq.count)
-	    break;
-	}
-      ip = queue_shift(&iq);
-      s = pool->solvables + ip;
-#ifdef CLEANDEPSDEBUG
-      printf("adding back %s\n", pool_solvable2str(pool, s));
-#endif
-      if (s->repo == installed && pool->implicitobsoleteusescolors)
-	{
-	  Id a, bestarch = 0;
-	  FOR_PROVIDES(p, pp, s->name)
-	    {
-	      Solvable *ps = pool->solvables + p;
-	      if (ps->name != s->name || ps->repo == installed)
-	        continue;
-	      a = ps->arch;
-	      a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
-	      if (a && a != 1 && (!bestarch || a < bestarch))
-		bestarch = a;
-	    }
-	  if (bestarch && (s->arch > pool->lastarch || pool->id2arch[s->arch] != bestarch))
-	    {
-	      FOR_PROVIDES(p, pp, s->name)
-		{
-		  Solvable *ps = pool->solvables + p;
-		  if (ps->repo == installed && ps->name == s->name && ps->evr == s->evr && ps->arch != s->arch && ps->arch < pool->lastarch && pool->id2arch[ps->arch] == bestarch)
-		    if (!MAPTST(&im, p))
-		      {
-#ifdef CLEANDEPSDEBUG
-		        printf("%s lockstep %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-		        MAPSET(&im, p);
-		        queue_push(&iq, p);
-		      }
-		}
-	    }
-	}
-      if (s->requires)
-	{
-	  reqp = s->repo->idarraydata + s->requires;
-	  while ((req = *reqp++) != 0)
-	    {
-#ifdef ENABLE_COMPLEX_DEPS
-	      if (pool_is_complex_dep(pool, req))
-		{
-		  complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
-		  continue;
-		}
-#endif
-	      FOR_PROVIDES(p, pp, req)
-		if (p == ip)
-		  break;
-	      if (p)
-		continue;
-	      FOR_PROVIDES(p, pp, req)
-		{
-		  if (MAPTST(&im, p))
-		    continue;
-		  if (MAPTST(&installedm, p))
-		    {
-		      if (p == ip)
-			continue;
-		      if (MAPTST(&userinstalled, p - installed->start))
-			continue;
-#ifdef CLEANDEPSDEBUG
-		      printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-		      MAPSET(&im, p);
-		      queue_push(&iq, p);
-		    }
-		}
-	    }
-	}
-      if (s->recommends)
-	{
-	  reqp = s->repo->idarraydata + s->recommends;
-	  while ((req = *reqp++) != 0)
-	    {
-#ifdef ENABLE_COMPLEX_DEPS
-	      if (pool_is_complex_dep(pool, req))
-		{
-		  complex_cleandeps_addback(pool, ip, req, &im, &installedm, &iq, &userinstalled);
-		  continue;
-		}
-#endif
-	      FOR_PROVIDES(p, pp, req)
-		if (p == ip)
-		  break;
-	      if (p)
-		continue;
-	      FOR_PROVIDES(p, pp, req)
-		{
-		  if (MAPTST(&im, p))
-		    continue;
-		  if (MAPTST(&installedm, p))
-		    {
-		      if (p == ip)
-			continue;
-		      if (MAPTST(&userinstalled, p - installed->start))
-			continue;
-#ifdef CLEANDEPSDEBUG
-		      printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
-#endif
-		      MAPSET(&im, p);
-		      queue_push(&iq, p);
-		    }
-		}
-	    }
-	}
-    }
-
-  queue_free(&iq);
-  /* make sure the updatepkgs and mistakes are not in the cleandeps map */
-  if (solv->cleandeps_updatepkgs)
-    for (i = 0; i < solv->cleandeps_updatepkgs->count; i++)
-      MAPSET(&im, solv->cleandeps_updatepkgs->elements[i]);
-  if (solv->cleandeps_mistakes)
-    for (i = 0; i < solv->cleandeps_mistakes->count; i++)
-      MAPSET(&im, solv->cleandeps_mistakes->elements[i]);
-  /* also remove original iq packages */
-  for (i = 0; i < iqcopy.count; i++)
-    MAPSET(&im, iqcopy.elements[i]);
-  queue_free(&iqcopy);
-  for (p = installed->start; p < installed->end; p++)
-    {
-      if (pool->solvables[p].repo != installed)
-	continue;
-      if (!MAPTST(&im, p))
-        MAPSET(cleandepsmap, p - installed->start);
-    }
-  map_free(&im);
-  map_free(&installedm);
-  map_free(&userinstalled);
-  queue_free(&xsuppq);
-#ifdef CLEANDEPSDEBUG
-  printf("=== final cleandeps map:\n");
-  for (p = installed->start; p < installed->end; p++)
-    if (MAPTST(cleandepsmap, p - installed->start))
-      printf("  - %s\n", pool_solvid2str(pool, p));
-#endif
-}
-
-
-struct trj_data {
-  Queue *edges;
-  Id *low;
-  Id idx;
-  Id nstack;
-  Id firstidx;
-};
-
-/* Tarjan's SCC algorithm, slightly modifed */
-static void
-trj_visit(struct trj_data *trj, Id node)
-{
-  Id *low = trj->low;
-  Queue *edges = trj->edges;
-  Id nnode, myidx, stackstart;
-  int i;
-
-  low[node] = myidx = trj->idx++;
-  low[(stackstart = trj->nstack++)] = node;
-  for (i = edges->elements[node]; (nnode = edges->elements[i]) != 0; i++)
-    {
-      Id l = low[nnode];
-      if (!l)
-	{
-	  if (!edges->elements[edges->elements[nnode]])
-	    {
-	      trj->idx++;
-	      low[nnode] = -1;
-	      continue;
-	    }
-	  trj_visit(trj, nnode);
-	  l = low[nnode];
-	}
-      if (l < 0)
-	continue;
-      if (l < trj->firstidx)
-	{
-	  int k;
-	  for (k = l; low[low[k]] == l; k++)
-	    low[low[k]] = -1;
-	}
-      else if (l < low[node])
-	low[node] = l;
-    }
-  if (low[node] == myidx)
-    {
-      if (myidx != trj->firstidx)
-	myidx = -1;
-      for (i = stackstart; i < trj->nstack; i++)
-	low[low[i]] = myidx;
-      trj->nstack = stackstart;
-    }
-}
-
-#ifdef ENABLE_COMPLEX_DEPS
-static void
-complex_unneeded(Pool *pool, Id ip, Id req, Queue *edges, Map *cleandepsmap, Queue *unneededq)
-{
-  int i, j;
-  Queue dq;
-  Id p;
-
-  queue_init(&dq);
-  i = pool_normalize_complex_dep(pool, req, &dq, CPLXDEPS_EXPAND);
-  if (i == 0 || i == 1)
-    {
-      queue_free(&dq);
-      return;
-    }
-  for (i = 0; i < dq.count; i++)
-    {
-      for (; (p = dq.elements[i]) != 0; i++)
-	{
-	  if (p < 0)
-	    {
-	      if (pool->solvables[-p].repo != pool->installed)
-	        break;
-	      continue;
-	    }
-	  if (p == ip || pool->solvables[p].repo != pool->installed || !MAPTST(cleandepsmap, p - pool->installed->start))
-	    continue;
-	  for (j = 0; j < unneededq->count; j++)
-	    if (p == unneededq->elements[j])
-	      {
-		if (edges->elements[edges->count - 1] != j + 1)
-		  queue_push(edges, j + 1);
-	        break;
-	      }
-	}
-      while (dq.elements[i])
-	i++;
-    }
-  queue_free(&dq);
-}
-#endif
-
-void
-solver_get_unneeded(Solver *solv, Queue *unneededq, int filtered)
-{
-  Repo *installed = solv->installed;
-  int i;
-  Map cleandepsmap;
-
-  queue_empty(unneededq);
-  if (!installed || installed->end == installed->start)
-    return;
-
-  map_init(&cleandepsmap, installed->end - installed->start);
-  solver_createcleandepsmap(solv, &cleandepsmap, 1);
-  for (i = installed->start; i < installed->end; i++)
-    if (MAPTST(&cleandepsmap, i - installed->start))
-      queue_push(unneededq, i);
-
-  if (filtered && unneededq->count > 1)
-    {
-      Pool *pool = solv->pool;
-      Queue edges;
-      Id *nrequires;
-      Map installedm;
-      int j, pass, count = unneededq->count;
-      Id *low;
-
-      map_init(&installedm, pool->nsolvables);
-      for (i = installed->start; i < installed->end; i++)
-	if (pool->solvables[i].repo == installed)
-	  MAPSET(&installedm, i);
-
-      nrequires = solv_calloc(count, sizeof(Id));
-      queue_init(&edges);
-      queue_prealloc(&edges, count * 4 + 10);	/* pre-size */
-
-      /*
-       * Go through the solvables in the nodes queue and create edges for
-       * all requires/recommends/supplements between the nodes.
-       * The edges are stored in the edges queue, we add 1 to the node
-       * index so that nodes in the edges queue are != 0 and we can
-       * terminate the edge list with 0.
-       * Thus for node element 5, the edges are stored starting at
-       * edges.elements[6] and are 0-terminated.
-       */
-      /* leave first element zero to make things easier */
-      /* also add trailing zero */
-      queue_insertn(&edges, 0, 1 + count + 1, 0);
-
-      /* first requires and recommends */
-      for (i = 0; i < count; i++)
-	{
-	  Solvable *s = pool->solvables + unneededq->elements[i];
-	  int oldcount = edges.count;
-	  edges.elements[i + 1] = oldcount;
-	  for (pass = 0; pass < 2; pass++)
-	    {
-	      unsigned int off = pass == 0 ? s->requires : s->recommends;
-	      Id p, pp, dep, *dp;
-	      if (off)
-		for (dp = s->repo->idarraydata + off; (dep = *dp) != 0; dp++)
-		  {
-#ifdef ENABLE_COMPLEX_DEPS
-		    if (pool_is_complex_dep(pool, dep))
-		      {
-			complex_unneeded(pool, s - pool->solvables, dep, &edges, &cleandepsmap, unneededq);
-			continue;
-		      }
-#endif
-		    FOR_PROVIDES(p, pp, dep)
-		      {
-			Solvable *sp = pool->solvables + p;
-			if (s == sp || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
-			  continue;
-			for (j = 0; j < count; j++)
-			  if (p == unneededq->elements[j])
-			    {
-			      if (edges.elements[edges.count - 1] != j + 1)
-			        queue_push(&edges, j + 1);
-			    }
-		      }
-		  }
-	      if (pass == 0)
-	        nrequires[i] = edges.count - oldcount;
-	    }
-	  queue_push(&edges, 0);
-	}
-#if 0
-      printf("requires + recommends\n");
-      for (i = 0; i < count; i++)
-	{
-	  int j;
-	  printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
-	  for (j = edges.elements[i + 1]; edges.elements[j]; j++)
-	    printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
-	}
-#endif
-
-      /* then add supplements */
-      for (i = 0; i < count; i++)
-	{
-	  Solvable *s = pool->solvables + unneededq->elements[i];
-	  if (s->supplements)
-	    {
-	      Id *dp;
-	      int k;
-	      for (dp = s->repo->idarraydata + s->supplements; *dp; dp++)
-		if (dep_possible(solv, *dp, &installedm))
-		  {
-		    Queue iq;
-		    Id iqbuf[16];
-		    queue_init_buffer(&iq, iqbuf, sizeof(iqbuf)/sizeof(*iqbuf));
-		    dep_pkgcheck(solv, *dp, 0, &iq);
-		    for (k = 0; k < iq.count; k++)
-		      {
-			Id p = iq.elements[k];
-			Solvable *sp = pool->solvables + p;
-			if (p == unneededq->elements[i] || sp->repo != installed || !MAPTST(&cleandepsmap, p - installed->start))
-			  continue;
-			for (j = 0; j < count; j++)
-			  if (p == unneededq->elements[j])
-			    break;
-			/* now add edge from j + 1 to i + 1 */
-			queue_insert(&edges, edges.elements[j + 1] + nrequires[j], i + 1);
-			/* addapt following edge pointers */
-			for (j = j + 2; j < count + 1; j++)
-			  edges.elements[j]++;
-		      }
-		    queue_free(&iq);
-		  }
-	    }
-	}
-#if 0
-      /* print result */
-      printf("+ supplements\n");
-      for (i = 0; i < count; i++)
-	{
-	  int j;
-	  printf("  %s (%d requires):\n", pool_solvid2str(pool, unneededq->elements[i]), nrequires[i]);
-	  for (j = edges.elements[i + 1]; edges.elements[j]; j++)
-	    printf("    - %s\n", pool_solvid2str(pool, unneededq->elements[edges.elements[j] - 1]));
-        }
-#endif
-      map_free(&installedm);
-
-      /* now run SCC algo two times, first with requires+recommends+supplements,
-       * then again without the requires. We run it the second time to get rid
-       * of packages that got dragged in via recommends/supplements */
-      /*
-       * low will contain the result of the SCC search.
-       * it must be of at least size 2 * (count + 1) and
-       * must be zero initialized.
-       * The layout is:
-       *    0  low low ... low stack stack ...stack 0
-       *            count              count
-       */
-      low = solv_calloc(count + 1, 2 * sizeof(Id));
-      for (pass = 0; pass < 2; pass++)
-	{
-	  struct trj_data trj;
-	  if (pass)
-	    {
-	      memset(low, 0, (count + 1) * (2 * sizeof(Id)));
-	      for (i = 0; i < count; i++)
-		{
-	          edges.elements[i + 1] += nrequires[i];
-		  if (!unneededq->elements[i])
-		    low[i + 1] = -1;	/* ignore this node */
-		}
-	    }
-	  trj.edges = &edges;
-	  trj.low = low;
-	  trj.idx = count + 1;	/* stack starts here */
-	  for (i = 1; i <= count; i++)
-	    {
-	      if (low[i])
-		continue;
-	      if (edges.elements[edges.elements[i]])
-		{
-		  trj.firstidx = trj.nstack = trj.idx;
-		  trj_visit(&trj, i);
-		}
-	      else
-		{
-		  Id myidx = trj.idx++;
-		  low[i] = myidx;
-		  low[myidx] = i;
-		}
-	    }
-	  /* prune packages */
-	  for (i = 0; i < count; i++)
-	    if (low[i + 1] <= 0)
-	      unneededq->elements[i] = 0;
-	}
-      solv_free(low);
-      solv_free(nrequires);
-      queue_free(&edges);
-
-      /* finally remove all pruned entries from unneededq */
-      for (i = j = 0; i < count; i++)
-	if (unneededq->elements[i])
-	  unneededq->elements[j++] = unneededq->elements[i];
-      queue_truncate(unneededq, j);
-    }
-  map_free(&cleandepsmap);
-}
-
-
 void
 solver_breakorphans(Solver *solv)
 {