s = pool->solvables + p;
if (s->name != sn->name || s->arch != sn->arch)
continue;
- if (!MAPTST(&solv->noobsoletes, p))
+ if (!MAPTST(&solv->multiversion, p))
continue;
if (pool_match_nevr(pool, pool->solvables + p, con))
continue;
}
p = 0; /* make it a negative assertion, aka 'uninstallable' */
}
- if (p && ispatch && solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && ISRELDEP(con))
+ if (p && ispatch && solv->multiversion.size && MAPTST(&solv->multiversion, p) && ISRELDEP(con))
{
- /* our patch conflicts with a noobsoletes (aka multiversion) package */
+ /* our patch conflicts with a multiversion package */
p = -makemultiversionconflict(solv, p, con);
}
/* rule: -n|-p: either solvable _or_ provider of conflict */
*/
if ((!installed || s->repo != installed) || !pool->noinstalledobsoletes)
{
- int noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
+ int multi = solv->multiversion.size && MAPTST(&solv->multiversion, n);
int isinstalled = (installed && s->repo == installed);
- if (s->obsoletes && (!noobs || solv->keepexplicitobsoletes))
+ if (s->obsoletes && (!multi || solv->keepexplicitobsoletes))
{
obsp = s->repo->idarraydata + s->obsoletes;
/* foreach obsoletes */
continue;
/* we still obsolete packages with same nevra, like rpm does */
/* (actually, rpm mixes those packages. yuck...) */
- if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
+ if (multi && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
continue;
if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
continue;
- if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
+ if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
continue;
if (s->name == ps->name)
addrpmrule(solv, -n, -p, SOLVER_RULE_RPM_SAME_NAME, 0);
if (!allow_all && !solv->dupmap_all && solv->dupinvolvedmap.size && MAPTST(&solv->dupinvolvedmap, p))
addduppackages(solv, s, &qs);
- if (!allow_all && qs.count && solv->noobsoletes.size)
+ if (!allow_all && qs.count && solv->multiversion.size)
{
int i, j;
d = pool_queuetowhatprovides(pool, &qs);
- /* filter out all noobsoletes packages as they don't update */
+ /* filter out all multiversion packages as they don't update */
for (i = j = 0; i < qs.count; i++)
{
- if (MAPTST(&solv->noobsoletes, qs.elements[i]))
+ if (MAPTST(&solv->multiversion, qs.elements[i]))
{
- /* it's ok if they have same nevra */
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)
+ {
+ qs.elements[j++] = qs.elements[i];
+ continue;
+ }
+ /* it's ok if they have same nevra */
if (ps->name != s->name || ps->evr != s->evr || ps->arch != s->arch)
continue;
}
/*
* 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 noobs map.
+ * solv->keepexplicitobsoletes is not set, p is not in the multiversion map.
* Entries may get added multiple times.
*/
static void
Id obs, *obsp;
Id lastp2 = 0;
- if (!solv->keepexplicitobsoletes || !(solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p)))
+ if (!solv->keepexplicitobsoletes || !(solv->multiversion.size && MAPTST(&solv->multiversion, p)))
{
FOR_PROVIDES(p2, pp2, s->name)
{
continue;
if (!pool->implicitobsoleteusesprovides && ps->name != s->name)
continue;
- if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
+ if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
continue;
queue_push(q, p2);
lastp2 = p2;
{
if (pool->disttype != DISTTYPE_DEB)
{
- const char *evr = pool_id2str(pool, rd->evr);
- if (strchr(evr, '-'))
- set |= SOLVER_SETEVR;
- else
- set |= SOLVER_SETEV;
+ const char *rel = strrchr(pool_id2str(pool, rd->evr), '-');
+ set |= rel ? SOLVER_SETEVR : SOLVER_SETEV;
}
else
set |= SOLVER_SETEVR;
return;
/* now the hard part: disable some update rules */
- /* first check if we have noobs or installed packages in the job */
+ /* first check if we have multiversion or installed packages in the job */
i = j = 0;
FOR_JOB_SELECT(p, pp, select, what)
{
if (pool->solvables[p].repo == installed)
j = p;
- else if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, p) && !solv->keepexplicitobsoletes)
+ else if (solv->multiversion.size && MAPTST(&solv->multiversion, p) && !solv->keepexplicitobsoletes)
return;
i++;
}
solver_reenablepolicyrules(Solver *solv, int jobidx)
{
Queue *job = &solv->job;
- int i, j;
+ int i, j, k, ai;
Queue q, allq;
Rule *r;
Id lastjob = -1;
- Id qbuf[32], allqbuf[128];
+ Id qbuf[32], allqbuf[32];
queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
- queue_init_buffer(&allq, allqbuf, sizeof(allqbuf)/sizeof(*allqbuf));
jobtodisablelist(solv, job->elements[jobidx - 1], job->elements[jobidx], &q);
if (!q.count)
- return;
+ {
+ queue_free(&q);
+ return;
+ }
+ /* now remove everything from q that is disabled by other jobs */
+
+ /* first remove cleandeps packages, they count as DISABLE_UPDATE */
+ if (solv->cleandepsmap.size)
+ {
+ solver_createcleandepsmap(solv, &solv->cleandepsmap, 0);
+ for (j = k = 0; j < q.count; j += 2)
+ {
+ if (q.elements[j] == DISABLE_UPDATE)
+ {
+ Id p = q.elements[j + 1];
+ if (p >= solv->installed->start && p < solv->installed->end && MAPTST(&solv->cleandepsmap, p - solv->installed->start))
+ continue; /* remove element from q */
+ }
+ q.elements[k++] = q.elements[j];
+ q.elements[k++] = q.elements[j + 1];
+ }
+ q.count = k;
+ if (!q.count)
+ {
+ queue_free(&q);
+ return;
+ }
+ }
+
+ /* now go through the disable list of all other jobs */
+ queue_init_buffer(&allq, allqbuf, sizeof(allqbuf)/sizeof(*allqbuf));
for (i = solv->jobrules; i < solv->jobrules_end; i++)
{
r = solv->rules + i;
continue;
lastjob = j;
jobtodisablelist(solv, job->elements[j], job->elements[j + 1], &allq);
+ if (!allq.count)
+ continue;
+ /* remove all elements in allq from q */
+ for (j = k = 0; j < q.count; j += 2)
+ {
+ Id type = q.elements[j], arg = q.elements[j + 1];
+ for (ai = 0; ai < allq.count; ai += 2)
+ if (allq.elements[ai] == type && allq.elements[ai + 1] == arg)
+ break;
+ if (ai < allq.count)
+ continue; /* found it in allq, remove element from q */
+ q.elements[k++] = q.elements[j];
+ q.elements[k++] = q.elements[j + 1];
+ }
+ q.count = k;
+ if (!q.count)
+ {
+ queue_free(&q);
+ queue_free(&allq);
+ return;
+ }
+ queue_empty(&allq);
}
- if (solv->cleandepsmap.size)
- {
- solver_createcleandepsmap(solv, &solv->cleandepsmap, 0);
- for (i = solv->installed->start; i < solv->installed->end; i++)
- if (MAPTST(&solv->cleandepsmap, i - solv->installed->start))
- queue_push2(&allq, DISABLE_UPDATE, i);
- }
+ queue_free(&allq);
+
+ /* now re-enable anything that's left in q */
for (j = 0; j < q.count; j += 2)
{
Id type = q.elements[j], arg = q.elements[j + 1];
- for (i = 0; i < allq.count; i += 2)
- if (allq.elements[i] == type && allq.elements[i + 1] == arg)
- break;
- if (i < allq.count)
- continue; /* still disabled */
switch(type)
{
case DISABLE_UPDATE:
break;
}
}
- queue_free(&allq);
queue_free(&q);
}
*depp = solv->job.elements[jidx + 1];
if ((r->d == 0 || r->d == -1) && r->w2 == 0 && r->p == -SYSTEMSOLVABLE)
{
- if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_NAME))
- return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
- if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES))
+ Id how = solv->job.elements[jidx];
+ if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_NAME))
+ return SOLVER_RULE_JOB_UNKNOWN_PACKAGE;
+ if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES))
return SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP;
- if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_NAME))
+ if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_NAME))
return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
- if ((solv->job.elements[jidx] & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_PROVIDES))
+ if ((how & (SOLVER_JOBMASK|SOLVER_SELECTMASK)) == (SOLVER_ERASE|SOLVER_SOLVABLE_PROVIDES))
return SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM;
+ return SOLVER_RULE_JOB_UNSUPPORTED;
}
return SOLVER_RULE_JOB;
}
return solv->job.elements[idx];
}
+Id
+solver_rule2solvable(Solver *solv, Id rid)
+{
+ if (rid >= solv->updaterules && rid < solv->updaterules_end)
+ return rid - solv->updaterules;
+ if (rid >= solv->featurerules && rid < solv->featurerules_end)
+ return rid - solv->featurerules;
+ return 0;
+}
+
+/* check if the newest versions of pi still provides the dependency we're looking for */
+static int
+solver_choicerulecheck(Solver *solv, Id pi, Rule *r, Map *m)
+{
+ Pool *pool = solv->pool;
+ Rule *ur;
+ Queue q;
+ Id p, pp, qbuf[32];
+ int i;
+
+ ur = solv->rules + solv->updaterules + (pi - pool->installed->start);
+ if (!ur->p)
+ ur = solv->rules + solv->featurerules + (pi - pool->installed->start);
+ if (!ur->p)
+ return 0;
+ queue_init_buffer(&q, qbuf, sizeof(qbuf)/sizeof(*qbuf));
+ FOR_RULELITERALS(p, pp, ur)
+ if (p > 0)
+ queue_push(&q, p);
+ if (q.count > 1)
+ policy_filter_unwanted(solv, &q, POLICY_MODE_CHOOSE);
+ for (i = 0; i < q.count; i++)
+ if (MAPTST(m, q.elements[i]))
+ break;
+ /* 1: none of the newest versions provide it */
+ i = i == q.count ? 1 : 0;
+ queue_free(&q);
+ return i;
+}
+
+static inline void
+queue_removeelement(Queue *q, Id el)
+{
+ int i, j;
+ for (i = 0; i < q->count; i++)
+ if (q->elements[i] == el)
+ break;
+ if (i < q->count)
+ {
+ for (j = i++; i < q->count; i++)
+ if (q->elements[i] != el)
+ q->elements[j++] = q->elements[i];
+ queue_truncate(q, j);
+ }
+}
+
void
solver_addchoicerules(Solver *solv)
{
Solvable *s, *s2;
Id lastaddedp, lastaddedd;
int lastaddedcnt;
+ unsigned int now;
solv->choicerules = solv->nrules;
if (!pool->installed)
solv->choicerules_end = solv->nrules;
return;
}
+ now = solv_timems(0);
solv->choicerules_ref = solv_calloc(solv->rpmrules_end, sizeof(Id));
queue_init(&q);
queue_init(&qi);
continue;
if (!pool->implicitobsoleteusesprovides && s->name != s2->name)
continue;
- if (pool->obsoleteusescolors && !pool_colormatch(pool, s, s2))
+ if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, s2))
continue;
break;
}
continue;
if (policy_is_illegal(solv, s2, s, 0))
continue;
+#if 0
+ if (solver_choicerulecheck(solv, p2, r, &m))
+ continue;
queue_push(&qi, p2);
+#else
+ queue_push2(&qi, p2, p);
+#endif
queue_push(&q, p);
continue;
}
continue;
if (policy_is_illegal(solv, s2, s, 0))
continue;
+#if 0
+ if (solver_choicerulecheck(solv, p2, r, &m))
+ continue;
queue_push(&qi, p2);
+#else
+ queue_push2(&qi, p2, p);
+#endif
queue_push(&q, p);
continue;
}
/* package p is independent of the installed ones */
havechoice = 1;
}
- if (!havechoice || !q.count)
+ if (!havechoice || !q.count || !qi.count)
continue; /* no choice */
- /* now check the update rules of the installed package.
- * if all packages of the update rules are contained in
- * the dependency rules, there's no need to set up the choice rule */
- map_empty(&m);
FOR_RULELITERALS(p, pp, r)
if (p > 0)
MAPSET(&m, p);
+
+ /* do extra checking */
+ for (i = j = 0; i < qi.count; i += 2)
+ {
+ p2 = qi.elements[i];
+ if (!p2)
+ continue;
+ if (solver_choicerulecheck(solv, p2, r, &m))
+ {
+ /* oops, remove element p from q */
+ queue_removeelement(&q, qi.elements[i + 1]);
+ continue;
+ }
+ qi.elements[j++] = p2;
+ }
+ queue_truncate(&qi, j);
+ if (!q.count || !qi.count)
+ {
+ FOR_RULELITERALS(p, pp, r)
+ if (p > 0)
+ MAPCLR(&m, p);
+ continue;
+ }
+
+
+ /* now check the update rules of the installed package.
+ * if all packages of the update rules are contained in
+ * the dependency rules, there's no need to set up the choice rule */
for (i = 0; i < qi.count; i++)
{
Rule *ur;
if (qi.elements[i] == qi.elements[j])
qi.elements[j] = 0;
}
+ /* empty map again */
+ FOR_RULELITERALS(p, pp, r)
+ if (p > 0)
+ MAPCLR(&m, p);
if (i == qi.count)
{
#if 0
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
/* just one installed literal */
if (r->d == 0 && r->w2 == 0 && pool->solvables[r->p].repo == installed)
continue;
- /* noobs is bad */
- if (solv->noobsoletes.size && !solv->keepexplicitobsoletes)
+ /* multiversion is bad */
+ if (solv->multiversion.size && !solv->keepexplicitobsoletes)
{
FOR_RULELITERALS(p, jp, r)
- if (MAPTST(&solv->noobsoletes, p))
+ if (MAPTST(&solv->multiversion, p))
break;
if (p)
continue;
*/
/* leave first element zero to make things easier */
/* also add trailing zero */
- queue_insertn(&edges, 0, 1 + count + 1);
+ queue_insertn(&edges, 0, 1 + count + 1, 0);
/* first requires and recommends */
for (i = 0; i < count; i++)
projects / platform / upstream / libsolv.git / blobdiff