2 * Copyright (c) 2007-2009, Novell Inc.
4 * This program is licensed under the BSD license, read LICENSE.BSD
5 * for further information
20 #include "solver_private.h"
25 #include "solverdebug.h"
28 /**********************************************************************************/
30 /* a problem is an item on the solver's problem list. It can either be >0, in that
31 * case it is a update/infarch/dup rule, or it can be <0, which makes it refer to a job
32 * consisting of multiple job rules.
36 solver_disableproblem(Solver *solv, Id v)
44 if (v >= solv->infarchrules && v < solv->infarchrules_end)
46 Pool *pool = solv->pool;
47 Id name = pool->solvables[-solv->rules[v].p].name;
48 while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
50 for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
51 solver_disablerule(solv, solv->rules + v);
54 if (v >= solv->duprules && v < solv->duprules_end)
56 Pool *pool = solv->pool;
57 Id name = pool->solvables[-solv->rules[v].p].name;
58 while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
60 for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
61 solver_disablerule(solv, solv->rules + v);
64 solver_disablerule(solv, solv->rules + v);
66 /* XXX: doesn't work */
67 if (v >= solv->updaterules && v < solv->updaterules_end)
69 /* enable feature rule if we disabled the update rule */
70 r = solv->rules + (v - solv->updaterules + solv->featurerules);
72 solver_enablerule(solv, r);
78 jp = solv->ruletojob.elements;
79 for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++)
81 solver_disablerule(solv, r);
84 /*-------------------------------------------------------------------
89 solver_enableproblem(Solver *solv, Id v)
97 if (v >= solv->infarchrules && v < solv->infarchrules_end)
99 Pool *pool = solv->pool;
100 Id name = pool->solvables[-solv->rules[v].p].name;
101 while (v > solv->infarchrules && pool->solvables[-solv->rules[v - 1].p].name == name)
103 for (; v < solv->infarchrules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
104 solver_enablerule(solv, solv->rules + v);
107 if (v >= solv->duprules && v < solv->duprules_end)
109 Pool *pool = solv->pool;
110 Id name = pool->solvables[-solv->rules[v].p].name;
111 while (v > solv->duprules && pool->solvables[-solv->rules[v - 1].p].name == name)
113 for (; v < solv->duprules_end && pool->solvables[-solv->rules[v].p].name == name; v++)
114 solver_enablerule(solv, solv->rules + v);
117 if (v >= solv->featurerules && v < solv->featurerules_end)
119 /* do not enable feature rule if update rule is enabled */
120 r = solv->rules + (v - solv->featurerules + solv->updaterules);
124 solver_enablerule(solv, solv->rules + v);
125 if (v >= solv->updaterules && v < solv->updaterules_end)
127 /* disable feature rule when enabling update rule */
128 r = solv->rules + (v - solv->updaterules + solv->featurerules);
130 solver_disablerule(solv, r);
135 jp = solv->ruletojob.elements;
136 for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++)
138 solver_enablerule(solv, r);
142 /*-------------------------------------------------------------------
145 * Reenable all disabled weak rules (marked in weakrulemap)
150 enableweakrules(Solver *solv)
155 for (i = 1, r = solv->rules + i; i < solv->learntrules; i++, r++)
157 if (r->d >= 0) /* already enabled? */
159 if (!MAPTST(&solv->weakrulemap, i))
161 solver_enablerule(solv, r);
166 /*-------------------------------------------------------------------
170 * at this point, all rules that led to conflicts are disabled.
171 * we re-enable all rules of a problem set but rule "sug", then
172 * continue to disable more rules until there as again a solution.
175 /* FIXME: think about conflicting assertions */
178 refine_suggestion(Solver *solv, Id *problem, Id sug, Queue *refined, int essentialok)
180 Pool *pool = solv->pool;
186 IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS)
188 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "refine_suggestion start\n");
189 for (i = 0; problem[i]; i++)
191 if (problem[i] == sug)
192 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "=> ");
193 solver_printproblem(solv, problem[i]);
196 queue_empty(refined);
197 if (!essentialok && sug < 0 && (solv->job.elements[-sug - 1] & SOLVER_ESSENTIAL) != 0)
199 queue_init(&disabled);
200 queue_push(refined, sug);
202 /* re-enable all problem rules with the exception of "sug"(gestion) */
205 for (i = 0; problem[i]; i++)
206 if (problem[i] != sug)
207 solver_enableproblem(solv, problem[i]);
210 solver_reenablepolicyrules(solv, -sug);
211 else if (sug >= solv->updaterules && sug < solv->updaterules_end)
213 /* enable feature rule */
214 Rule *r = solv->rules + solv->featurerules + (sug - solv->updaterules);
216 solver_enablerule(solv, r);
219 enableweakrules(solv);
223 int njob, nfeature, nupdate, pass;
224 queue_empty(&solv->problems);
227 if (!solv->problems.count)
228 solver_run_sat(solv, 0, 0);
230 if (!solv->problems.count)
232 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "no more problems!\n");
233 break; /* great, no more problems */
235 disabledcnt = disabled.count;
236 /* start with 1 to skip over proof index */
237 njob = nfeature = nupdate = 0;
238 for (pass = 0; pass < 2; pass++)
240 for (i = 1; i < solv->problems.count - 1; i++)
242 /* ignore solutions in refined */
243 v = solv->problems.elements[i];
245 break; /* end of problem reached */
248 /* check if v is in the given problems list
249 * we allow disabling all problem rules *after* sug in
250 * pass 2, to prevent getting the same solution twice */
251 for (j = 0; problem[j]; j++)
252 if (problem[j] == v || (pass && problem[j] == sug))
257 if (v >= solv->featurerules && v < solv->featurerules_end)
263 if (!essentialok && (solv->job.elements[-v -1] & SOLVER_ESSENTIAL) != 0)
264 continue; /* not that one! */
267 queue_push(&disabled, v);
269 if (disabled.count != disabledcnt)
272 if (disabled.count == disabledcnt)
274 /* no solution found, this was an invalid suggestion! */
275 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "no solution found!\n");
279 if (!njob && nupdate && nfeature)
281 /* got only update rules, filter out feature rules */
282 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "throwing away feature rules\n");
283 for (i = j = disabledcnt; i < disabled.count; i++)
285 v = disabled.elements[i];
286 if (v < solv->featurerules || v >= solv->featurerules_end)
287 disabled.elements[j++] = v;
292 if (disabled.count == disabledcnt + 1)
294 /* just one suggestion, add it to refined list */
295 v = disabled.elements[disabledcnt];
296 if (!nfeature && v != sug)
297 queue_push(refined, v); /* do not record feature rules */
298 solver_disableproblem(solv, v);
299 if (v >= solv->updaterules && v < solv->updaterules_end)
301 Rule *r = solv->rules + (v - solv->updaterules + solv->featurerules);
303 solver_enablerule(solv, r); /* enable corresponding feature rule */
306 solver_reenablepolicyrules(solv, -v);
310 /* more than one solution, disable all */
311 /* do not push anything on refine list, as we do not know which solution to choose */
312 /* thus, the user will get another problem if he selects this solution, where he
313 * can choose the right one */
314 IF_POOLDEBUG (SOLV_DEBUG_SOLUTIONS)
316 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "more than one solution found:\n");
317 for (i = disabledcnt; i < disabled.count; i++)
318 solver_printproblem(solv, disabled.elements[i]);
320 for (i = disabledcnt; i < disabled.count; i++)
322 v = disabled.elements[i];
323 solver_disableproblem(solv, v);
324 if (v >= solv->updaterules && v < solv->updaterules_end)
326 Rule *r = solv->rules + (v - solv->updaterules + solv->featurerules);
328 solver_enablerule(solv, r);
333 /* all done, get us back into the same state as before */
334 /* enable refined rules again */
335 for (i = 0; i < disabled.count; i++)
336 solver_enableproblem(solv, disabled.elements[i]);
337 queue_free(&disabled);
338 /* reset policy rules */
339 for (i = 0; problem[i]; i++)
340 solver_enableproblem(solv, problem[i]);
341 solver_disablepolicyrules(solv);
342 /* disable problem rules again */
343 for (i = 0; problem[i]; i++)
344 solver_disableproblem(solv, problem[i]);
345 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "refine_suggestion end\n");
349 /*-------------------------------------------------------------------
350 * sorting helper for problems
352 * bring update rules before job rules
353 * make essential job rules last
357 problems_sortcmp(const void *ap, const void *bp, void *dp)
360 Id a = *(Id *)ap, b = *(Id *)bp;
367 int af = job->elements[-a - 1] & SOLVER_ESSENTIAL;
368 int bf = job->elements[-b - 1] & SOLVER_ESSENTIAL;
377 * convert a solution rule into a job modifier
380 convertsolution(Solver *solv, Id why, Queue *solutionq)
382 Pool *pool = solv->pool;
385 queue_push(solutionq, 0);
386 queue_push(solutionq, -why);
389 if (why >= solv->infarchrules && why < solv->infarchrules_end)
392 /* infarch rule, find replacement */
393 assert(solv->rules[why].p < 0);
394 name = pool->solvables[-solv->rules[why].p].name;
395 while (why > solv->infarchrules && pool->solvables[-solv->rules[why - 1].p].name == name)
398 for (; why < solv->infarchrules_end && pool->solvables[-solv->rules[why].p].name == name; why++)
399 if (solv->decisionmap[-solv->rules[why].p] > 0)
401 p = -solv->rules[why].p;
405 return; /* false alarm */
406 queue_push(solutionq, SOLVER_SOLUTION_INFARCH);
407 queue_push(solutionq, p);
410 if (why >= solv->duprules && why < solv->duprules_end)
413 /* dist upgrade rule, find replacement */
414 assert(solv->rules[why].p < 0);
415 name = pool->solvables[-solv->rules[why].p].name;
416 while (why > solv->duprules && pool->solvables[-solv->rules[why - 1].p].name == name)
419 for (; why < solv->duprules_end && pool->solvables[-solv->rules[why].p].name == name; why++)
420 if (solv->decisionmap[-solv->rules[why].p] > 0)
422 p = -solv->rules[why].p;
426 return; /* false alarm */
427 queue_push(solutionq, SOLVER_SOLUTION_DISTUPGRADE);
428 queue_push(solutionq, p);
431 if (why >= solv->updaterules && why < solv->updaterules_end)
433 /* update rule, find replacement package */
437 /* check if this is a false positive, i.e. the update rule is fulfilled */
438 rr = solv->rules + why;
439 FOR_RULELITERALS(p, dp, rr)
440 if (p > 0 && solv->decisionmap[p] > 0)
441 return; /* false alarm */
443 p = solv->installed->start + (why - solv->updaterules);
444 rr = solv->rules + solv->featurerules + (why - solv->updaterules);
446 rr = solv->rules + why;
447 if (solv->dupmap_all && solv->rules[why].p != p && solv->decisionmap[p] > 0)
449 /* distupgrade case, allow to keep old package */
450 queue_push(solutionq, SOLVER_SOLUTION_DISTUPGRADE);
451 queue_push(solutionq, p);
454 if (solv->decisionmap[p] > 0)
455 return; /* false alarm, turned out we can keep the package */
458 int mvrp = 0; /* multi-version replacement */
459 FOR_RULELITERALS(rp, dp, rr)
461 if (rp > 0 && solv->decisionmap[rp] > 0 && pool->solvables[rp].repo != solv->installed)
464 if (!(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, rp)))
470 /* found only multi-version replacements */
471 /* have to split solution into two parts */
472 queue_push(solutionq, p);
473 queue_push(solutionq, mvrp);
476 queue_push(solutionq, p);
477 queue_push(solutionq, rp);
480 if (why >= solv->bestrules && why < solv->bestrules_end)
485 /* check false positive */
486 rr = solv->rules + why;
487 FOR_RULELITERALS(p, dp, rr)
488 if (p > 0 && solv->decisionmap[p] > 0)
489 return; /* false alarm */
490 /* check update/feature rule */
491 p = solv->bestrules_pkg[why - solv->bestrules];
495 queue_push(solutionq, 0);
496 queue_push(solutionq, solv->ruletojob.elements[-p - solv->jobrules] + 1);
499 rr = solv->rules + solv->featurerules + (p - solv->installed->start);
501 rr = solv->rules + solv->updaterules + (p - solv->installed->start);
502 mvrp = 0; /* multi-version replacement */
503 FOR_RULELITERALS(rp, dp, rr)
504 if (rp > 0 && solv->decisionmap[rp] > 0)
507 if (!(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, rp)))
512 queue_push(solutionq, SOLVER_SOLUTION_BEST); /* split, see above */
513 queue_push(solutionq, mvrp);
514 queue_push(solutionq, p);
515 queue_push(solutionq, 0);
520 queue_push(solutionq, SOLVER_SOLUTION_BEST);
521 queue_push(solutionq, rp);
528 * convert problem data into a form usable for refining.
529 * Returns the number of problems.
532 solver_prepare_solutions(Solver *solv)
536 if (!solv->problems.count)
538 queue_empty(&solv->solutions);
539 queue_push(&solv->solutions, 0); /* dummy so idx is always nonzero */
540 idx = solv->solutions.count;
541 queue_push(&solv->solutions, -1); /* unrefined */
542 /* proofidx stays in position, thus we start with 1 */
543 for (i = 1; i < solv->problems.count; i++)
545 Id p = solv->problems.elements[i];
546 queue_push(&solv->solutions, p);
549 /* end of problem reached */
550 solv->problems.elements[j++] = idx;
551 if (i + 1 >= solv->problems.count)
553 /* start another problem */
554 solv->problems.elements[j++] = solv->problems.elements[++i]; /* copy proofidx */
555 idx = solv->solutions.count;
556 queue_push(&solv->solutions, -1); /* unrefined */
558 solv->problems.count = j;
563 * refine the simple solution rule list provided by
564 * the solver into multiple lists of job modifiers.
567 create_solutions(Solver *solv, int probnr, int solidx)
569 Pool *pool = solv->pool;
571 Queue problem, solution, problems_save;
575 int oldmistakes = solv->cleandeps_mistakes ? solv->cleandeps_mistakes->count : 0;
578 now = solv_timems(0);
580 /* save decisionq, decisionq_why, decisionmap */
581 for (i = 0; i < solv->decisionq.count; i++)
583 Id p = solv->decisionq.elements[i];
584 queue_push(&redoq, p);
585 queue_push(&redoq, solv->decisionq_why.elements[i]);
586 queue_push(&redoq, solv->decisionmap[p > 0 ? p : -p]);
588 /* save problems queue */
589 problems_save = solv->problems;
590 memset(&solv->problems, 0, sizeof(solv->problems));
592 /* extract problem from queue */
593 queue_init(&problem);
594 for (i = solidx + 1; i < solv->solutions.count; i++)
596 Id v = solv->solutions.elements[i];
599 queue_push(&problem, v);
601 extraflags &= solv->job.elements[-v - 1];
603 if (extraflags == -1)
605 if (problem.count > 1)
606 solv_sort(problem.elements, problem.count, sizeof(Id), problems_sortcmp, &solv->job);
607 queue_push(&problem, 0); /* mark end for refine_suggestion */
610 for (i = 0; i < problem.count; i++)
611 printf("PP %d %d\n", i, problem.elements[i]);
614 /* refine each solution element */
617 queue_init(&solution);
618 for (i = 0; i < problem.count; i++)
620 int solstart = solv->solutions.count;
621 refine_suggestion(solv, problem.elements, problem.elements[i], &solution, essentialok);
622 queue_push(&solv->solutions, 0); /* reserve room for number of elements */
623 for (j = 0; j < solution.count; j++)
624 convertsolution(solv, solution.elements[j], &solv->solutions);
625 if (solv->solutions.count == solstart + 1)
627 solv->solutions.count--; /* this one did not work out */
628 if (nsol || i + 1 < problem.count)
629 continue; /* got one or still hope */
632 /* nothing found, start over */
633 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "nothing found, re-run with essentialok = 1\n");
638 /* this is bad, we found no solution */
639 /* for now just offer a rule */
640 POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "nothing found, already did essentialok, fake it\n");
641 queue_push(&solv->solutions, 0);
642 for (j = 0; j < problem.count; j++)
644 convertsolution(solv, problem.elements[j], &solv->solutions);
645 if (solv->solutions.count > solstart + 1)
648 if (solv->solutions.count == solstart + 1)
650 solv->solutions.count--;
651 continue; /* sorry */
654 /* patch in number of solution elements */
655 solv->solutions.elements[solstart] = (solv->solutions.count - (solstart + 1)) / 2;
656 queue_push(&solv->solutions, 0); /* add end marker */
657 queue_push(&solv->solutions, 0); /* add end marker */
658 queue_push(&solv->solutions, problem.elements[i]); /* just for bookkeeping */
659 queue_push(&solv->solutions, extraflags & SOLVER_CLEANDEPS); /* our extraflags */
660 solv->solutions.elements[solidx + 1 + nsol++] = solstart;
662 solv->solutions.elements[solidx + 1 + nsol] = 0; /* end marker */
663 solv->solutions.elements[solidx] = nsol;
664 queue_free(&problem);
665 queue_free(&solution);
667 /* restore decisions */
668 memset(solv->decisionmap, 0, pool->nsolvables * sizeof(Id));
669 queue_empty(&solv->decisionq);
670 queue_empty(&solv->decisionq_why);
671 for (i = 0; i < redoq.count; i += 3)
673 Id p = redoq.elements[i];
674 queue_push(&solv->decisionq, p);
675 queue_push(&solv->decisionq_why, redoq.elements[i + 1]);
676 solv->decisionmap[p > 0 ? p : -p] = redoq.elements[i + 2];
679 /* restore problems */
680 queue_free(&solv->problems);
681 solv->problems = problems_save;
683 if (solv->cleandeps_mistakes)
686 queue_truncate(solv->cleandeps_mistakes, oldmistakes);
689 queue_free(solv->cleandeps_mistakes);
690 solv->cleandeps_mistakes = solv_free(solv->cleandeps_mistakes);
694 POOL_DEBUG(SOLV_DEBUG_STATS, "create_solutions for problem #%d took %d ms\n", probnr, solv_timems(now));
698 /**************************************************************************/
701 solver_problem_count(Solver *solv)
703 return solv->problems.count / 2;
707 solver_next_problem(Solver *solv, Id problem)
710 return solv->problems.count ? 1 : 0;
711 return (problem + 1) * 2 - 1 < solv->problems.count ? problem + 1 : 0;
715 solver_solution_count(Solver *solv, Id problem)
717 Id solidx = solv->problems.elements[problem * 2 - 1];
718 if (solv->solutions.elements[solidx] < 0)
719 create_solutions(solv, problem, solidx);
720 return solv->solutions.elements[solidx];
724 solver_next_solution(Solver *solv, Id problem, Id solution)
726 Id solidx = solv->problems.elements[problem * 2 - 1];
727 if (solv->solutions.elements[solidx] < 0)
728 create_solutions(solv, problem, solidx);
729 return solv->solutions.elements[solidx + solution + 1] ? solution + 1 : 0;
733 solver_solutionelement_count(Solver *solv, Id problem, Id solution)
735 Id solidx = solv->problems.elements[problem * 2 - 1];
736 solidx = solv->solutions.elements[solidx + solution];
737 return solv->solutions.elements[solidx];
741 solver_solutionelement_internalid(Solver *solv, Id problem, Id solution)
743 Id solidx = solv->problems.elements[problem * 2 - 1];
744 solidx = solv->solutions.elements[solidx + solution];
745 return solv->solutions.elements[solidx + 2 * solv->solutions.elements[solidx] + 3];
749 solver_solutionelement_extrajobflags(Solver *solv, Id problem, Id solution)
751 Id solidx = solv->problems.elements[problem * 2 - 1];
752 solidx = solv->solutions.elements[solidx + solution];
753 return solv->solutions.elements[solidx + 2 * solv->solutions.elements[solidx] + 4];
758 * return the next item of the proposed solution
759 * here are the possibilities for p / rp and what
760 * the solver expects the application to do:
762 * -------------------------------------------------------
763 * SOLVER_SOLUTION_INFARCH pkgid
764 * -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
765 * SOLVER_SOLUTION_DISTUPGRADE pkgid
766 * -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
767 * SOLVER_SOLUTION_BEST pkgid
768 * -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
769 * SOLVER_SOLUTION_JOB jobidx
770 * -> remove job (jobidx - 1, jobidx) from job queue
772 * -> add (SOLVER_ERASE|SOLVER_SOLVABLE, p) to the job
773 * pkgid (> 0) pkgid (> 0)
774 * -> add (SOLVER_INSTALL|SOLVER_SOLVABLE, rp) to the job
775 * (this will replace package p)
777 * Thus, the solver will either ask the application to remove
778 * a specific job from the job queue, or ask to add an install/erase
784 solver_next_solutionelement(Solver *solv, Id problem, Id solution, Id element, Id *p, Id *rp)
786 Id solidx = solv->problems.elements[problem * 2 - 1];
787 solidx = solv->solutions.elements[solidx + solution];
790 solidx += 1 + element * 2;
791 if (!solv->solutions.elements[solidx] && !solv->solutions.elements[solidx + 1])
793 *p = solv->solutions.elements[solidx];
794 *rp = solv->solutions.elements[solidx + 1];
799 solver_take_solutionelement(Solver *solv, Id p, Id rp, Id extrajobflags, Queue *job)
803 if (p == SOLVER_SOLUTION_JOB)
805 job->elements[rp - 1] = SOLVER_NOOP;
806 job->elements[rp] = 0;
809 if (rp <= 0 && p <= 0)
810 return; /* just in case */
812 p = SOLVER_INSTALL|SOLVER_SOLVABLE|extrajobflags;
816 p = SOLVER_ERASE|SOLVER_SOLVABLE|extrajobflags;
818 for (i = 0; i < job->count; i += 2)
819 if (job->elements[i] == p && job->elements[i + 1] == rp)
821 queue_push2(job, p, rp);
825 solver_take_solution(Solver *solv, Id problem, Id solution, Queue *job)
827 Id p, rp, element = 0;
828 Id extrajobflags = solver_solutionelement_extrajobflags(solv, problem, solution);
829 while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &rp)) != 0)
830 solver_take_solutionelement(solv, p, rp, extrajobflags, job);
834 /*-------------------------------------------------------------------
840 findproblemrule_internal(Solver *solv, Id idx, Id *reqrp, Id *conrp, Id *sysrp, Id *jobrp)
843 Id lreqr, lconr, lsysr, ljobr;
846 int i, reqset = 0; /* 0: unset, 1: installed, 2: jobassert, 3: assert */
848 /* find us a jobassert rule */
849 for (i = idx; (rid = solv->learnt_pool.elements[i]) != 0; i++)
851 if (rid < solv->jobrules || rid >= solv->jobrules_end)
853 r = solv->rules + rid;
854 d = r->d < 0 ? -r->d - 1 : r->d;
855 if (!d && r->w2 == 0 && r->p > 0)
862 /* the problem rules are somewhat ordered from "near to the problem" to
863 * "near to the job" */
864 lreqr = lconr = lsysr = ljobr = 0;
865 while ((rid = solv->learnt_pool.elements[idx++]) != 0)
868 if (rid >= solv->learntrules)
869 findproblemrule_internal(solv, solv->learnt_why.elements[rid - solv->learntrules], &lreqr, &lconr, &lsysr, &ljobr);
870 else if ((rid >= solv->jobrules && rid < solv->jobrules_end) || (rid >= solv->infarchrules && rid < solv->infarchrules_end) || (rid >= solv->duprules && rid < solv->duprules_end) || (rid >= solv->bestrules && rid < solv->bestrules_end))
875 else if (rid >= solv->updaterules && rid < solv->updaterules_end)
882 assert(rid < solv->rpmrules_end);
883 r = solv->rules + rid;
884 d = r->d < 0 ? -r->d - 1 : r->d;
892 if (!d && r->w2 == 0 && reqset < 3)
894 if (*reqrp > 0 && r->p < -1)
896 Id op = -solv->rules[*reqrp].p;
897 if (op > 1 && solv->pool->solvables[op].arch != solv->pool->solvables[-r->p].arch)
898 continue; /* different arch, skip */
900 /* prefer assertions */
904 else if (jobassert && r->p == -jobassert)
906 /* prefer rules of job assertions */
910 else if (solv->installed && r->p < 0 && solv->pool->solvables[-r->p].repo == solv->installed && reqset <= 1)
912 /* prefer rules of job installed package so that the user doesn't get confused by strange packages */
921 if (!*reqrp && lreqr)
923 if (!*conrp && lconr)
925 if (!*jobrp && ljobr)
927 if (!*sysrp && lsysr)
934 * search for a rule that describes the problem to the
935 * user. Actually a pretty hopeless task that may leave the user
936 * puzzled. To get all of the needed information use
937 * solver_findallproblemrules() instead.
941 solver_findproblemrule(Solver *solv, Id problem)
943 Id reqr, conr, sysr, jobr;
944 Id idx = solv->problems.elements[2 * problem - 2];
945 reqr = conr = sysr = jobr = 0;
946 findproblemrule_internal(solv, idx, &reqr, &conr, &sysr, &jobr);
948 return reqr; /* some requires */
950 return conr; /* some conflict */
952 return sysr; /* an update rule */
954 return jobr; /* a user request */
959 /*-------------------------------------------------------------------*/
962 findallproblemrules_internal(Solver *solv, Id idx, Queue *rules)
965 while ((rid = solv->learnt_pool.elements[idx++]) != 0)
967 if (rid >= solv->learntrules)
969 findallproblemrules_internal(solv, solv->learnt_why.elements[rid - solv->learntrules], rules);
972 queue_pushunique(rules, rid);
977 * find all problem rule
979 * return all rules that lead to the problem. This gives the user
980 * all of the information to understand the problem, but the result
981 * can be a large number of rules.
985 solver_findallproblemrules(Solver *solv, Id problem, Queue *rules)
988 findallproblemrules_internal(solv, solv->problems.elements[2 * problem - 2], rules);