}
}
- if (m && pool->implicitobsoleteusescolors && (s->arch > pool->lastarch || pool->id2arch[s->arch] != 1))
+ if (m && pool->implicitobsoleteusescolors && pool_arch2score(pool, s->arch) > 1)
{
- int a = pool->id2arch[s->arch];
+ unsigned int pa, a = pool_arch2score(pool, s->arch);
/* check lock-step candidates */
FOR_PROVIDES(p, pp, s->name)
{
Solvable *ps = pool->solvables + p;
if (s->name != ps->name || s->evr != ps->evr || MAPTST(m, p))
continue;
- if (ps->arch > pool->lastarch || pool->id2arch[ps->arch] == 1 || pool->id2arch[ps->arch] >= a)
+ pa = pool_arch2score(pool, ps->arch);
+ if (!pa || pa == 1 || pa >= a)
continue;
queue_push(&workq, p);
}
if (pool_is_complex_dep(pool, rec))
{
pool_add_pos_literals_complex_dep(pool, rec, &workq, m, 0);
- continue;
+ continue;
}
#endif
FOR_PROVIDES(p, pp, rec)
if (pool_is_complex_dep(pool, sug))
{
pool_add_pos_literals_complex_dep(pool, sug, &workq, m, 0);
- continue;
+ continue;
}
#endif
FOR_PROVIDES(p, pp, sug)
}
}
+/* check if multiversion solvable s2 has an obsoletes for installed solvable s */
+static int
+is_multiversion_obsoleteed(Pool *pool, Solvable *s, Solvable *s2)
+{
+ Id *wp, obs, *obsp;
+
+ if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2))
+ return 0;
+ obsp = s2->repo->idarraydata + s2->obsoletes;
+ if (!pool->obsoleteusesprovides)
+ {
+ while ((obs = *obsp++) != 0)
+ if (pool_match_nevr(pool, s, obs))
+ return 1;
+ }
+ else
+ {
+ while ((obs = *obsp++) != 0)
+ for (wp = pool_whatprovides_ptr(pool, obs); *wp; wp++)
+ if (pool->solvables + *wp == s)
+ return 1;
+ }
+ return 0;
+}
+
/*-------------------------------------------------------------------
*
* add rule for update
if (MAPTST(&solv->multiversion, qs.elements[i]))
{
Solvable *ps = pool->solvables + qs.elements[i];
- /* if keepexplicitobsoletes is set and the name is different,
- * we assume that there is an obsoletes. XXX: not 100% correct */
- if (solv->keepexplicitobsoletes && ps->name != s->name)
+ /* check if there is an explicit obsoletes */
+ if (solv->keepexplicitobsoletes && ps->obsoletes && is_multiversion_obsoleteed(pool, s, ps))
{
qs.elements[j++] = qs.elements[i];
continue;
r = solv->rules + solv->featurerules + (p - solv->installed->start);
if (r->p && r->d >= 0)
solver_disablerule(solv, r);
- if (solv->bestrules_pkg)
+ if (solv->bestrules_info)
{
int i, ni;
ni = solv->bestrules_end - solv->bestrules;
for (i = solv->bestrules_up - solv->bestrules; i < ni; i++)
- if (solv->bestrules_pkg[i] == p)
+ if (solv->bestrules_info[i] == p)
solver_disablerule(solv, solv->rules + solv->bestrules + i);
}
}
}
}
}
- if (solv->bestrules_pkg)
+ if (solv->bestrules_info)
{
int i, ni;
ni = solv->bestrules_end - solv->bestrules;
for (i = solv->bestrules_up - solv->bestrules; i < ni; i++)
- if (solv->bestrules_pkg[i] == p)
+ if (solv->bestrules_info[i] == p)
solver_enablerule(solv, solv->rules + solv->bestrules + i);
}
}
Pool *pool = solv->pool;
Repo *installed = pool->installed;
int first, i, j;
- Id p, pp, a, aa, bestarch;
+ Id p, pp, aa;
+ unsigned int a, bestscore;
Solvable *s, *ps, *bests;
Queue badq, allowedarchs;
Queue lsq;
continue;
s = pool->solvables + i;
first = i;
- bestarch = 0;
+ bestscore = 0;
bests = 0;
queue_empty(&allowedarchs);
FOR_PROVIDES(p, pp, s->name)
first = 0;
if (first)
break;
- a = ps->arch;
- a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
+ a = pool_arch2score(pool, ps->arch);
if (a != 1 && installed && ps->repo == installed)
{
if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
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))
+ if (a && a != 1 && (!bestscore || a < bestscore))
{
- bestarch = a;
+ bestscore = a;
bests = ps;
}
}
if (allowedarchs.count == 1 && bests && allowedarchs.elements[0] == bests->arch)
allowedarchs.count--; /* installed arch is best */
- if (allowedarchs.count && pool->implicitobsoleteusescolors && installed && bestarch)
+ if (allowedarchs.count && pool->implicitobsoleteusescolors && installed && bestscore)
{
/* need an extra pass for lockstep checking: we only allow to keep an inferior arch
* if the corresponding installed package is not lock-stepped */
continue;
if (solv->dupinvolvedmap_all || (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p)))
continue;
- a = ps->arch;
- a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
+ a = pool_arch2score(pool, ps->arch);
if (!a)
{
queue_pushunique(&allowedarchs, ps->arch); /* strange arch, allow */
continue;
}
- if (a == 1 || ((a ^ bestarch) & 0xffff0000) == 0)
+ if (a == 1 || ((a ^ bestscore) & 0xffff0000) == 0)
continue;
/* have installed package with inferior arch, check if lock-stepped */
FOR_PROVIDES(p2, pp2, s->name)
{
Solvable *s2 = pool->solvables + p2;
- Id a2;
+ unsigned int a2;
if (p2 == p || s2->name != s->name || s2->evr != pool->solvables[p].evr || s2->arch == pool->solvables[p].arch)
continue;
- a2 = s2->arch;
- a2 = (a2 <= pool->lastarch) ? pool->id2arch[a2] : 0;
- if (a2 && (a2 == 1 || ((a2 ^ bestarch) & 0xffff0000) == 0))
+ a2 = pool_arch2score(pool, s2->arch);
+ if (a2 && (a2 == 1 || ((a2 ^ bestscore) & 0xffff0000) == 0))
break;
}
if (!p2)
ps = pool->solvables + p;
if (ps->name != s->name || !MAPTST(addedmap, p))
continue;
- a = ps->arch;
- a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
- if (a != 1 && bestarch && ((a ^ bestarch) & 0xffff0000) != 0)
+ a = pool_arch2score(pool, ps->arch);
+ if (a != 1 && bestscore && ((a ^ bestscore) & 0xffff0000) != 0)
{
if (installed && ps->repo == installed)
{
}
for (j = 0; j < allowedarchs.count; j++)
{
+ unsigned int aas;
aa = allowedarchs.elements[j];
if (ps->arch == aa)
break;
- aa = (aa <= pool->lastarch) ? pool->id2arch[aa] : 0;
- if (aa && ((a ^ aa) & 0xffff0000) == 0)
+ aas = pool_arch2score(pool, aa);
+ if (aas && ((a ^ aas) & 0xffff0000) == 0)
break; /* compatible */
}
if (j == allowedarchs.count)
for (j = 0; j < badq.count; j++)
{
p = badq.elements[j];
- /* lock-step */
+ /* special lock-step handling */
if (pool->implicitobsoleteusescolors)
{
Id p2;
Solvable *s2 = pool->solvables + p2;
if (p2 == p || s2->name != s->name || s2->evr != pool->solvables[p].evr || s2->arch == pool->solvables[p].arch)
continue;
- a = s2->arch;
- a = (a <= pool->lastarch) ? pool->id2arch[a] : 0;
- if (a && (a == 1 || ((a ^ bestarch) & 0xffff000) == 0))
+ a = pool_arch2score(pool, s2->arch);
+ if (a && (a == 1 || ((a ^ bestscore) & 0xffff000) == 0))
{
queue_push(&lsq, p2);
if (installed && s2->repo == installed)
}
if (installed && pool->solvables[p].repo == installed && !haveinstalled)
continue; /* installed package not in lock-step */
+ if (lsq.count < 2)
+ solver_addrule(solv, -p, lsq.count ? lsq.elements[0] : 0, 0);
+ else
+ solver_addrule(solv, -p, 0, pool_queuetowhatprovides(pool, &lsq));
}
- if (lsq.count < 2)
- solver_addrule(solv, -p, lsq.count ? lsq.elements[0] : 0, 0);
else
- solver_addrule(solv, -p, 0, pool_queuetowhatprovides(pool, &lsq));
+ {
+ solver_addrule(solv, -p, 0, 0);
+ }
}
}
queue_free(&lsq);
if ((set & SOLVER_SETARCH) != 0 && solv->infarchrules != solv->infarchrules_end)
{
if (select == SOLVER_SOLVABLE)
- queue_push2(q, DISABLE_INFARCH, pool->solvables[what].name);
+ {
+ for (i = solv->infarchrules; i < solv->infarchrules_end; i++)
+ if (solv->rules[i].p == -what)
+ break;
+ if (i < solv->infarchrules_end)
+ queue_push2(q, DISABLE_INFARCH, pool->solvables[what].name);
+ }
else
{
int qcnt = q->count;
if (q->elements[i + 1] == s->name)
break;
if (i < q->count)
- continue;
- queue_push2(q, DISABLE_INFARCH, s->name);
+ continue; /* already have that DISABLE_INFARCH element */
+ for (i = solv->infarchrules; i < solv->infarchrules_end; i++)
+ if (solv->rules[i].p == -p)
+ break;
+ if (i < solv->infarchrules_end)
+ queue_push2(q, DISABLE_INFARCH, s->name);
}
}
}
if (pool->solvables[p].repo == installed)
return;
if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
- return;
+ return; /* will not obsolete anything, so just return */
}
omap.size = 0;
qstart = q->count;
#endif
}
return;
+
+ case SOLVER_LOCK:
+ if (!installed)
+ break;
+ qstart = q->count;
+ if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
+ {
+ FOR_REPO_SOLVABLES(installed, p, s)
+ {
+ for (i = qstart; i < q->count; i += 2)
+ if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name)
+ break;
+ if (i == q->count)
+ queue_push2(q, DISABLE_DUP, pool->solvables[p].name);
+ }
+ }
+ FOR_JOB_SELECT(p, pp, select, what)
+ {
+ if (pool->solvables[p].repo != installed)
+ continue;
+ for (i = qstart; i < q->count; i += 2)
+ if (q->elements[i] == DISABLE_DUP && q->elements[i + 1] == pool->solvables[p].name)
+ break;
+ if (i == q->count)
+ queue_push2(q, DISABLE_DUP, pool->solvables[p].name);
+ }
+ break;
+
default:
return;
}
}
if (rid >= solv->bestrules && rid < solv->bestrules_end)
{
- if (fromp && solv->bestrules_pkg[rid - solv->bestrules] > 0)
- *fromp = solv->bestrules_pkg[rid - solv->bestrules];
+ if (fromp && solv->bestrules_info[rid - solv->bestrules] > 0)
+ *fromp = solv->bestrules_info[rid - solv->bestrules];
return SOLVER_RULE_BEST;
}
if (rid >= solv->yumobsrules && rid < solv->yumobsrules_end)
return SOLVER_RULE_YUMOBS;
}
if (rid >= solv->choicerules && rid < solv->choicerules_end)
- {
- return SOLVER_RULE_CHOICE;
- }
+ return SOLVER_RULE_CHOICE;
+ if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end)
+ return SOLVER_RULE_RECOMMENDS;
if (rid >= solv->learntrules)
- {
- return SOLVER_RULE_LEARNT;
- }
+ return SOLVER_RULE_LEARNT;
return SOLVER_RULE_UNKNOWN;
}
return SOLVER_RULE_YUMOBS;
if (rid >= solv->choicerules && rid < solv->choicerules_end)
return SOLVER_RULE_CHOICE;
+ if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end)
+ return SOLVER_RULE_RECOMMENDS;
if (rid >= solv->learntrules && rid < solv->nrules)
return SOLVER_RULE_LEARNT;
return SOLVER_RULE_UNKNOWN;
solver_rule2pkgrule(Solver *solv, Id rid)
{
if (rid >= solv->choicerules && rid < solv->choicerules_end)
- return solv->choicerules_ref[rid - solv->choicerules];
+ return solv->choicerules_info[rid - solv->choicerules];
+ if (rid >= solv->recommendsrules && rid < solv->recommendsrules_end)
+ return solv->recommendsrules_info[rid - solv->recommendsrules];
return 0;
}
Pool *pool = solv->pool;
Map m, mneg;
Rule *r;
- Queue q, qi, qcheck;
+ Queue q, qi, qcheck, infoq;
int i, j, rid, havechoice;
Id p, d, pp;
Id p2, pp2;
return;
}
now = solv_timems(0);
- solv->choicerules_ref = solv_calloc(solv->pkgrules_end, sizeof(Id));
+ solv->choicerules_info = solv_calloc(solv->pkgrules_end, sizeof(Id));
queue_init(&q);
queue_init(&qi);
queue_init(&qcheck);
+ queue_init(&infoq);
map_init(&m, pool->nsolvables);
map_init(&mneg, pool->nsolvables);
/* set up negative assertion map from infarch and dup rules */
solver_addrule(solv, r->p, 0, d);
queue_push(&solv->weakruleq, solv->nrules - 1);
- solv->choicerules_ref[solv->nrules - 1 - solv->choicerules] = rid;
+ queue_push(&infoq, rid);
#if 0
printf("OLD ");
solver_printrule(solv, SOLV_DEBUG_RESULT, solv->rules + rid);
solver_printrule(solv, SOLV_DEBUG_RESULT, solv->rules + solv->nrules - 1);
#endif
}
+ if (infoq.count)
+ solv->choicerules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id));
queue_free(&q);
queue_free(&qi);
queue_free(&qcheck);
+ queue_free(&infoq);
map_free(&m);
map_free(&mneg);
solv->choicerules_end = solv->nrules;
- /* shrink choicerules_ref */
- solv->choicerules_ref = solv_realloc2(solv->choicerules_ref, solv->choicerules_end - solv->choicerules, sizeof(Id));
POOL_DEBUG(SOLV_DEBUG_STATS, "choice rule creation took %d ms\n", solv_timems(now));
}
-/* called when a choice rule is disabled by analyze_unsolvable. We also
- * have to disable all other choice rules so that the best packages get
- * picked */
+/* called when a choice rule needs to be disabled by analyze_unsolvable.
+ * We also have to disable all other choice rules so that the best packages
+ * get picked */
void
solver_disablechoicerules(Solver *solv, Rule *r)
{
Map m;
Rule *or;
- or = solv->rules + solv->choicerules_ref[(r - solv->rules) - solv->choicerules];
+ solver_disablerule(solv, r);
+ or = solv->rules + solv->choicerules_info[(r - solv->rules) - solv->choicerules];
map_init(&m, pool->nsolvables);
FOR_RULELITERALS(p, pp, or)
if (p > 0)
r = solv->rules + rid;
if (r->d < 0)
continue;
- or = solv->rules + solv->choicerules_ref[(r - solv->rules) - solv->choicerules];
+ or = solv->rules + solv->choicerules_info[rid - solv->choicerules];
FOR_RULELITERALS(p, pp, or)
if (p > 0 && MAPTST(&m, p))
break;
queue_truncate(q, j);
}
+static void
+prune_best_update(Solver *solv, Id p, Queue *q)
+{
+ if (solv->update_targets && solv->update_targets->elements[p - solv->installed->start])
+ prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - solv->installed->start], q);
+ if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
+ prune_to_dup_packages(solv, p, q);
+ /* select best packages, just look at prio and version */
+ policy_filter_unwanted(solv, q, POLICY_MODE_RECOMMEND);
+}
+
void
-solver_addbestrules(Solver *solv, int havebestinstalljobs)
+solver_addbestrules(Solver *solv, int havebestinstalljobs, int haslockjob)
{
Pool *pool = solv->pool;
Id p;
Repo *installed = solv->installed;
Queue q, q2;
Rule *r;
- Queue r2pkg;
+ Queue infoq;
int i, oldcnt;
+ Map *lockedmap = 0;
solv->bestrules = solv->nrules;
queue_init(&q);
queue_init(&q2);
- queue_init(&r2pkg);
+ queue_init(&infoq);
+ if (haslockjob)
+ {
+ int i;
+ lockedmap = solv_calloc(1, sizeof(Map));
+ map_init(lockedmap, pool->nsolvables);
+ for (i = 0, r = solv->rules + solv->jobrules; i < solv->ruletojob.count; i++, r++)
+ {
+ if (r->w2 || (solv->job.elements[solv->ruletojob.elements[i]] & SOLVER_JOBMASK) != SOLVER_LOCK)
+ continue;
+ p = r->p > 0 ? r->p : -r->p;
+ MAPSET(lockedmap, p);
+ }
+ }
if (havebestinstalljobs)
{
for (i = 0; i < solv->job.count; i += 2)
Id how = solv->job.elements[i];
if ((how & (SOLVER_JOBMASK | SOLVER_FORCEBEST)) == (SOLVER_INSTALL | SOLVER_FORCEBEST))
{
- int j;
+ int j, k;
Id p2, pp2;
for (j = 0; j < solv->ruletojob.count; j++)
{
policy_filter_unwanted(solv, &q, POLICY_MODE_RECOMMEND);
if (q.count == oldcnt)
continue; /* nothing filtered */
+ if (lockedmap)
+ {
+ FOR_RULELITERALS(p2, pp2, r)
+ {
+ if (p2 <= 0)
+ continue;
+ if (installed && pool->solvables[p2].repo == installed)
+ {
+ if (MAPTST(lockedmap, p2))
+ queue_pushunique(&q, p2); /* we always want that package */
+ }
+ else if (MAPTST(lockedmap, p2))
+ continue;
+ queue_push(&q2, p2);
+ }
+ policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND);
+ for (k = 0; k < q2.count; k++)
+ queue_pushunique(&q, q2.elements[k]);
+ }
if (q2.count)
queue_insertn(&q, 0, q2.count, q2.elements);
p2 = queue_shift(&q);
solver_addrule(solv, p2, 0, pool_queuetowhatprovides(pool, &q));
if ((how & SOLVER_WEAK) != 0)
queue_push(&solv->weakruleq, solv->nrules - 1);
- queue_push(&r2pkg, -(solv->jobrules + j));
+ queue_push(&infoq, -(solv->jobrules + j));
}
}
}
if (p2 > 0)
queue_push(&q, p2);
}
- if (solv->update_targets && solv->update_targets->elements[p - installed->start])
- prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - installed->start], &q);
- if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
- prune_to_dup_packages(solv, p, &q);
- /* select best packages, just look at prio and version */
- policy_filter_unwanted(solv, &q, POLICY_MODE_RECOMMEND);
+ if (lockedmap)
+ {
+ queue_empty(&q2);
+ queue_insertn(&q2, 0, q.count, q.elements);
+ }
+ prune_best_update(solv, p, &q);
if (!q.count)
continue; /* orphaned */
+ if (lockedmap)
+ {
+ int j;
+ /* always ok to keep installed locked packages */
+ if (MAPTST(lockedmap, p))
+ queue_pushunique(&q2, p);
+ for (j = 0; j < q2.count; j++)
+ {
+ Id p2 = q2.elements[j];
+ if (pool->solvables[p2].repo == installed && MAPTST(lockedmap, p2))
+ queue_pushunique(&q, p2);
+ }
+ /* filter out locked packages */
+ for (i = j = 0; j < q2.count; j++)
+ {
+ Id p2 = q2.elements[j];
+ if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2))
+ q2.elements[i++] = p2;
+ }
+ queue_truncate(&q2, i);
+ prune_best_update(solv, p, &q2);
+ for (j = 0; j < q2.count; j++)
+ queue_pushunique(&q, q2.elements[j]);
+ }
if (solv->bestobeypolicy)
{
/* also filter the best of the feature rule packages and add them */
FOR_RULELITERALS(p2, pp2, r)
if (p2 > 0)
queue_push(&q2, p2);
- if (solv->update_targets && solv->update_targets->elements[p - installed->start])
- prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[p - installed->start], &q2);
- if (solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
- prune_to_dup_packages(solv, p, &q2);
- policy_filter_unwanted(solv, &q2, POLICY_MODE_RECOMMEND);
+ prune_best_update(solv, p, &q2);
for (j = 0; j < q2.count; j++)
queue_pushunique(&q, q2.elements[j]);
+ if (lockedmap)
+ {
+ queue_empty(&q2);
+ FOR_RULELITERALS(p2, pp2, r)
+ if (p2 > 0)
+ if (pool->solvables[p2].repo == installed || !MAPTST(lockedmap, p2))
+ queue_push(&q2, p2);
+ prune_best_update(solv, p, &q2);
+ for (j = 0; j < q2.count; j++)
+ queue_pushunique(&q, q2.elements[j]);
+ }
}
}
if (solv->allowuninstall || solv->allowuninstall_all || (solv->allowuninstallmap.size && MAPTST(&solv->allowuninstallmap, p - installed->start)))
solver_addrule(solv, -p2, d, 0);
else
solver_addrule(solv, -p2, 0, -d);
- queue_push(&r2pkg, p);
+ queue_push(&infoq, p);
}
for (i = 0; i < q.count; i++)
MAPCLR(&m, q.elements[i]);
solver_addrule(solv, p2, q.count ? q.elements[0] : 0, 0);
else
solver_addrule(solv, p2, 0, pool_queuetowhatprovides(pool, &q));
- queue_push(&r2pkg, p);
+ queue_push(&infoq, p);
}
map_free(&m);
}
- if (r2pkg.count)
- solv->bestrules_pkg = solv_memdup2(r2pkg.elements, r2pkg.count, sizeof(Id));
+ if (infoq.count)
+ solv->bestrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id));
solv->bestrules_end = solv->nrules;
queue_free(&q);
queue_free(&q2);
- queue_free(&r2pkg);
+ queue_free(&infoq);
+ if (lockedmap)
+ {
+ map_free(lockedmap);
+ solv_free(lockedmap);
+ }
}
continue;
if ((pool->obsoleteusescolors || pool->implicitobsoleteusescolors) && !pool_colormatch(pool, s2, os))
continue;
- obsp2 = os->repo->idarraydata + os->obsoletes;
+ obsp2 = os->repo->idarraydata + os->obsoletes;
while ((obs2 = *obsp2++) != 0)
if (obs2 == obs)
break;
continue;
if ((pool->obsoleteusescolors || pool->implicitobsoleteusescolors) && !pool_colormatch(pool, s2, os))
continue;
- obsp2 = os->repo->idarraydata + os->obsoletes;
+ obsp2 = os->repo->idarraydata + os->obsoletes;
while ((obs2 = *obsp2++) != 0)
if (obs2 == obs)
break;
Repo *installed = solv->installed;
Id p, op, *opp;
Solvable *s;
- Queue qo, qq, yumobsinfoq;
+ Queue qo, qq, infoq;
int i, j, k;
unsigned int now;
queue_free(&qo);
return;
}
- queue_init(&yumobsinfoq);
+ queue_init(&infoq);
queue_init(&qq);
for (i = 0; i < qo.count; i++)
{
else
printf("%s\n", pool_solvid2str(pool, qq.elements[j]));
#endif
-
+
if (!qq.count)
continue;
/* at least two goups, build rules */
solver_addrule(solv, -p, qq.elements[groupstart], 0);
else
solver_addrule(solv, -p, 0, pool_ids2whatprovides(pool, qq.elements + groupstart, k - groupstart));
- queue_push(&yumobsinfoq, qo.elements[i]);
+ queue_push(&infoq, qo.elements[i]);
}
groupstart = k + 1;
groupk++;
}
}
}
- if (yumobsinfoq.count)
- solv->yumobsrules_info = solv_memdup2(yumobsinfoq.elements, yumobsinfoq.count, sizeof(Id));
- queue_free(&yumobsinfoq);
+ if (infoq.count)
+ solv->yumobsrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id));
+ queue_free(&infoq);
queue_free(&qq);
queue_free(&qo);
solv->yumobsrules_end = solv->nrules;
POOL_DEBUG(SOLV_DEBUG_STATS, "yumobs rule creation took %d ms\n", solv_timems(now));
}
+/* recommendsrules are a copy of some recommends package rule but
+ * with some disfavored literals removed */
+void
+solver_addrecommendsrules(Solver *solv)
+{
+ Pool *pool = solv->pool;
+ int i, havedis, havepos;
+ Id p, pp;
+ Queue q, infoq;
+
+ solv->recommendsrules = solv->nrules;
+ queue_init(&q);
+ queue_init(&infoq);
+ for (i = 0; i < solv->recommendsruleq->count; i++)
+ {
+ int rid = solv->recommendsruleq->elements[i];
+ Rule *r = solv->rules + rid;
+ queue_empty(&q);
+ havedis = havepos = 0;
+ FOR_RULELITERALS(p, pp, r)
+ {
+ if (p > 0 && solv->favormap[p] < 0)
+ havedis = 1;
+ else
+ {
+ if (p > 0)
+ havepos = 1;
+ queue_push(&q, p);
+ }
+ }
+ if (!havedis)
+ continue;
+ solver_disablerule(solv, r);
+ if (!havepos || q.count < 2)
+ continue;
+ if (q.count == 2)
+ solver_addrule(solv, q.elements[0], q.elements[1], 0);
+ else
+ solver_addrule(solv, q.elements[0], 0, pool_ids2whatprovides(pool, q.elements + 1, q.count - 1));
+ queue_push(&infoq, rid);
+ }
+ if (infoq.count)
+ solv->recommendsrules_info = solv_memdup2(infoq.elements, infoq.count, sizeof(Id));
+ queue_free(&infoq);
+ queue_free(&q);
+ solv->recommendsrules_end = solv->nrules;
+}
+
void
solver_breakorphans(Solver *solv)
{
Pool *pool = solv->pool;
int i;
Id l, pp;
-
+
queue_empty(dq);
if (!solv->brokenorphanrules)
return;
projects / platform / upstream / libsolv.git / blobdiff