make disableproblem/enableproblem static

diff --git a/src/problems.c b/src/problems.c
index f60671cfd1219eafcddae1b765b98607b3574c49..29d51705e8e5342231fabfb29470237f031513cf 100644 (file)
--- 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 395b71c15762f3f5e840fb2ed6e92fb22c9277b9..63319d6cbf09c686e2e7f03e0e9adaea184620bf 100644 (file)
--- 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 6129cf215fd427bec52a6405998da7e9a90050a1..42aec8251557b497737af0122403a6d6757d57dc 100644 (file)
--- 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;