From: Michael Schroeder <mls@suse.de>
Date: Thu, 2 Nov 2017 15:34:24 +0000 (+0100)
Subject: make disableproblem/enableproblem static
X-Git-Tag: 0.6.31~46
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=602d45c2859a87df3df733f613e6cf7c6c970a92;p=thirdparty%2Flibsolv.git

make disableproblem/enableproblem static
---

diff --git a/src/problems.c b/src/problems.c
index f60671cf..29d51705 100644
--- a/src/problems.c
+++ b/src/problems.c
@@ -24,7 +24,132 @@
 #include "evr.h"
 #include "solverdebug.h"
 
-/* turn a problem rule into a problem id by normalizing it */
+/**********************************************************************************/
+
+/* a problem is an item on the solver's problem list. It can either be >0, in that
+ * case it is a update/infarch/dup rule, or it can be <0, which makes it refer to a job
+ * consisting of multiple job rules.
+ */
+
+static void
+solver_disableproblem(Solver *solv, Id v)
+{
+  int i;
+  Id *jp;
+
+  if (v > 0)
+    {
+      if (v >= solv->infarchrules && v < solv->infarchrules_end)
+	{
+	  Pool *pool = solv->pool;
+	  Id name = pool->solvables[-solv->rules[v].p].name;
+	  while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
+	    v--;
+	  for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
+	    solver_disablerule(solv, solv->rules + v);
+	  return;
+	}
+      if (v >= solv->duprules && v < solv->duprules_end)
+	{
+	  Pool *pool = solv->pool;
+	  Id name = pool->solvables[-solv->rules[v].p].name;
+	  while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
+	    v--;
+	  for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
+	    solver_disablerule(solv, solv->rules + v);
+	  return;
+	}
+      solver_disablerule(solv, solv->rules + v);
+      return;
+    }
+  v = -(v + 1);
+  jp = solv->ruletojob.elements;
+  if (solv->bestrules_pkg)
+    {
+      int ni = solv->bestrules_end - solv->bestrules;
+      for (i = 0; i < ni; i++)
+	{
+	  int j = solv->bestrules_pkg[i];
+	  if (j < 0 && jp[-j - solv->jobrules] == v)
+	    solver_disablerule(solv, solv->rules + solv->bestrules + i);
+	}
+    }
+  for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++)
+    if (*jp == v)
+      solver_disablerule(solv, solv->rules + i);
+}
+
+/*-------------------------------------------------------------------
+ * enableproblem
+ */
+
+static void
+solver_enableproblem(Solver *solv, Id v)
+{
+  Rule *r;
+  int i;
+  Id *jp;
+
+  if (v > 0)
+    {
+      if (v >= solv->infarchrules && v < solv->infarchrules_end)
+	{
+	  Pool *pool = solv->pool;
+	  Id name = pool->solvables[-solv->rules[v].p].name;
+	  while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
+	    v--;
+	  for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
+	    solver_enablerule(solv, solv->rules + v);
+	  return;
+	}
+      if (v >= solv->duprules && v < solv->duprules_end)
+	{
+	  Pool *pool = solv->pool;
+	  Id name = pool->solvables[-solv->rules[v].p].name;
+	  while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
+	    v--;
+	  for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
+	    solver_enablerule(solv, solv->rules + v);
+	  return;
+	}
+      if (v >= solv->featurerules && v < solv->featurerules_end)
+	{
+	  /* do not enable feature rule if update rule is enabled */
+	  r = solv->rules + (v - solv->featurerules + solv->updaterules);
+	  if (r->d >= 0)
+	    return;
+	}
+      solver_enablerule(solv, solv->rules + v);
+      if (v >= solv->updaterules && v < solv->updaterules_end)
+	{
+	  /* disable feature rule when enabling update rule */
+	  r = solv->rules + (v - solv->updaterules + solv->featurerules);
+	  if (r->p)
+	    solver_disablerule(solv, r);
+	}
+      return;
+    }
+  v = -(v + 1);
+  jp = solv->ruletojob.elements;
+  if (solv->bestrules_pkg)
+    {
+      int ni = solv->bestrules_end - solv->bestrules;
+      for (i = 0; i < ni; i++)
+	{
+	  int j = solv->bestrules_pkg[i];
+	  if (j < 0 && jp[-j - solv->jobrules] == v)
+	    solver_enablerule(solv, solv->rules + solv->bestrules + i);
+	}
+    }
+  for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++)
+    if (*jp == v)
+      solver_enablerule(solv, solv->rules + i);
+}
+
+
+/*-------------------------------------------------------------------
+ * turn a problem rule into a problem id by normalizing it
+ */
 static Id
 solver_ruletoproblem(Solver *solv, Id rid)
 {
@@ -49,7 +174,8 @@ solver_ruletoproblem(Solver *solv, Id rid)
   return rid;
 }
 
-/* when the solver runs into a problem, it needs to disable all
+/*-------------------------------------------------------------------
+ * when the solver runs into a problem, it needs to disable all
  * involved non-pkg rules and record the rules for solution
  * generation.
  */
@@ -70,8 +196,10 @@ solver_recordproblem(Solver *solv, Id rid)
   queue_push(&solv->problems, v);
 }
 
-/* this is called when a problem is solved by disabling a rule.
- * It calls disableproblem and then re-enables policy rules */
+/*-------------------------------------------------------------------
+ * this is called when a problem is solved by disabling a rule.
+ * It calls disableproblem and then re-enables policy rules
+ */
 void
 solver_fixproblem(Solver *solv, Id rid)
 {
@@ -81,9 +209,22 @@ solver_fixproblem(Solver *solv, Id rid)
     solver_reenablepolicyrules(solv, -v);
 }
 
-/* try to fix a problem by auto-uninstalling packages */
+/*-------------------------------------------------------------------
+ * disable a set of problems
+ */
+void
+solver_disableproblemset(Solver *solv, int start)
+{
+  int i;
+  for (i = start + 1; i < solv->problems.count - 1; i++)
+    solver_disableproblem(solv, solv->problems.elements[i]);
+}
+
+/*-------------------------------------------------------------------
+ * try to fix a problem by auto-uninstalling packages
+ */
 Id
-solver_autouninstall(Solver *solv, Id *problem)
+solver_autouninstall(Solver *solv, int start)
 {
   Pool *pool = solv->pool;
   int i;
@@ -98,8 +239,9 @@ solver_autouninstall(Solver *solv, Id *problem)
 	return 0;		/* why did we get called? */
       m = &solv->allowuninstallmap;
     }
-  for (i = 0; (v = problem[i]) != 0; i++)
+  for (i = start + 1; i < solv->problems.count - 1; i++)
     {
+      v = solv->problems.elements[i];
       if (v < 0)
 	extraflags &= solv->job.elements[-v - 1];
       if (v >= solv->updaterules && v < solv->updaterules_end)
@@ -159,128 +301,6 @@ solver_autouninstall(Solver *solv, Id *problem)
   return v;
 }
 
-/**********************************************************************************/
-
-/* a problem is an item on the solver's problem list. It can either be >0, in that
- * case it is a update/infarch/dup rule, or it can be <0, which makes it refer to a job
- * consisting of multiple job rules.
- */
-
-void
-solver_disableproblem(Solver *solv, Id v)
-{
-  int i;
-  Id *jp;
-
-  if (v > 0)
-    {
-      if (v >= solv->infarchrules && v < solv->infarchrules_end)
-	{
-	  Pool *pool = solv->pool;
-	  Id name = pool->solvables[-solv->rules[v].p].name;
-	  while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
-	    v--;
-	  for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
-	    solver_disablerule(solv, solv->rules + v);
-	  return;
-	}
-      if (v >= solv->duprules && v < solv->duprules_end)
-	{
-	  Pool *pool = solv->pool;
-	  Id name = pool->solvables[-solv->rules[v].p].name;
-	  while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
-	    v--;
-	  for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
-	    solver_disablerule(solv, solv->rules + v);
-	  return;
-	}
-      solver_disablerule(solv, solv->rules + v);
-      return;
-    }
-  v = -(v + 1);
-  jp = solv->ruletojob.elements;
-  if (solv->bestrules_pkg)
-    {
-      int ni = solv->bestrules_end - solv->bestrules;
-      for (i = 0; i < ni; i++)
-	{
-	  int j = solv->bestrules_pkg[i];
-	  if (j < 0 && jp[-j - solv->jobrules] == v)
-	    solver_disablerule(solv, solv->rules + solv->bestrules + i);
-	}
-    }
-  for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++)
-    if (*jp == v)
-      solver_disablerule(solv, solv->rules + i);
-}
-
-/*-------------------------------------------------------------------
- * enableproblem
- */
-
-void
-solver_enableproblem(Solver *solv, Id v)
-{
-  Rule *r;
-  int i;
-  Id *jp;
-
-  if (v > 0)
-    {
-      if (v >= solv->infarchrules && v < solv->infarchrules_end)
-	{
-	  Pool *pool = solv->pool;
-	  Id name = pool->solvables[-solv->rules[v].p].name;
-	  while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
-	    v--;
-	  for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
-	    solver_enablerule(solv, solv->rules + v);
-	  return;
-	}
-      if (v >= solv->duprules && v < solv->duprules_end)
-	{
-	  Pool *pool = solv->pool;
-	  Id name = pool->solvables[-solv->rules[v].p].name;
-	  while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
-	    v--;
-	  for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
-	    solver_enablerule(solv, solv->rules + v);
-	  return;
-	}
-      if (v >= solv->featurerules && v < solv->featurerules_end)
-	{
-	  /* do not enable feature rule if update rule is enabled */
-	  r = solv->rules + (v - solv->featurerules + solv->updaterules);
-	  if (r->d >= 0)
-	    return;
-	}
-      solver_enablerule(solv, solv->rules + v);
-      if (v >= solv->updaterules && v < solv->updaterules_end)
-	{
-	  /* disable feature rule when enabling update rule */
-	  r = solv->rules + (v - solv->updaterules + solv->featurerules);
-	  if (r->p)
-	    solver_disablerule(solv, r);
-	}
-      return;
-    }
-  v = -(v + 1);
-  jp = solv->ruletojob.elements;
-  if (solv->bestrules_pkg)
-    {
-      int ni = solv->bestrules_end - solv->bestrules;
-      for (i = 0; i < ni; i++)
-	{
-	  int j = solv->bestrules_pkg[i];
-	  if (j < 0 && jp[-j - solv->jobrules] == v)
-	    solver_enablerule(solv, solv->rules + solv->bestrules + i);
-	}
-    }
-  for (i = solv->jobrules; i < solv->jobrules_end; i++, jp++)
-    if (*jp == v)
-      solver_enablerule(solv, solv->rules + i);
-}
-
 
 /*-------------------------------------------------------------------
  * enable weak rules
diff --git a/src/problems.h b/src/problems.h
index 395b71c1..63319d6c 100644
--- a/src/problems.h
+++ b/src/problems.h
@@ -30,10 +30,9 @@ struct _Solver;
 
 void solver_recordproblem(struct _Solver *solv, Id rid);
 void solver_fixproblem(struct _Solver *solv, Id rid);
-Id solver_autouninstall(struct _Solver *solv, Id *problem);
+Id solver_autouninstall(struct _Solver *solv, int start);
+void solver_disableproblemset(struct _Solver *solv, int start);
 
-void solver_disableproblem(struct _Solver *solv, Id v);
-void solver_enableproblem(struct _Solver *solv, Id v);
 int solver_prepare_solutions(struct _Solver *solv);
 
 unsigned int solver_problem_count(struct _Solver *solv);
diff --git a/src/solver.c b/src/solver.c
index 6129cf21..42aec825 100644
--- a/src/solver.c
+++ b/src/solver.c
@@ -256,7 +256,7 @@ makeruledecisions(Solver *solv, int disablerules)
 	  if (doautouninstall)
 	    {
 	      if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
-		if (solver_autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+		if (solver_autouninstall(solv, oldproblemcount) != 0)
 		  {
 		    solv->problems.count = oldproblemcount;
 		    havedisabled = 1;
@@ -280,9 +280,7 @@ makeruledecisions(Solver *solv, int disablerules)
 	      return -1;
 	    }
 	  /* disable all problem rules */
-	  for (i = oldproblemcount + 1; i < solv->problems.count - 1; i++)
-	    solver_disableproblem(solv, solv->problems.elements[i]);
-
+	  solver_disableproblemset(solv, oldproblemcount);
 	  havedisabled = 1;
 	  break;	/* start over */
 	}
@@ -1010,7 +1008,7 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
   queue_free(&weakq);
 
   if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
-    if (solver_autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+    if (solver_autouninstall(solv, oldproblemcount) != 0)
       {
 	solv->problems.count = oldproblemcount;
 	solv->learnt_pool.count = oldlearntpoolcount;
@@ -1028,8 +1026,7 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
   /* + 2: index + trailing zero */
   if (disablerules && oldproblemcount + 2 < solv->problems.count)
     {
-      for (i = oldproblemcount + 1; i < solv->problems.count - 1; i++)
-        solver_disableproblem(solv, solv->problems.elements[i]);
+      solver_disableproblemset(solv, oldproblemcount);
       /* XXX: might want to enable all weak rules again */
       solver_reset(solv);
       return 0;