From 40d5592805eaa650df84c50b9fed3cbdc4823fc5 Mon Sep 17 00:00:00 2001 From: DongHun Kwak Date: Thu, 27 Oct 2016 14:53:59 +0900 Subject: [PATCH] Imported Upstream version 0.6.9 Change-Id: Icf4a1aa6525f6c2bfc9da6f3ba1609728f39a073 Signed-off-by: DongHun Kwak --- VERSION.cmake | 2 +- bindings/solv.i | 113 +++++ ext/CMakeLists.txt | 5 + ext/libsolvext.ver | 2 + ext/pool_parserpmrichdep.c | 138 ++++++ ext/pool_parserpmrichdep.h | 15 + ext/repo_deb.c | 96 +++- ext/repo_deb.h | 1 + ext/repo_rpmdb.c | 26 +- ext/repo_rpmmd.c | 22 +- ext/repo_susetags.c | 14 + ext/testcase.c | 668 ++++++++++++++++++--------- ext/testcase.h | 2 + package/libsolv.changes | 12 + src/knownid.h | 2 + src/libsolv.ver | 4 + src/policy.c | 282 ++++++++++- src/repodata.c | 2 + src/rules.c | 16 +- src/rules.h | 1 + src/solver.c | 356 ++++++++------ src/solver.h | 8 + src/solver_private.h | 4 +- test/testcases/choose/default.t | 13 + test/testcases/choose/enhanced.t | 14 + test/testcases/choose/oldversion.t | 16 + test/testcases/choose/suggested.t | 14 + test/testcases/choose/versioned.t | 15 + test/testcases/choose/versioned2.t | 15 + test/testcases/namespace/namespaceprovides.t | 2 + 30 files changed, 1517 insertions(+), 363 deletions(-) create mode 100644 ext/pool_parserpmrichdep.c create mode 100644 ext/pool_parserpmrichdep.h create mode 100644 test/testcases/choose/default.t create mode 100644 test/testcases/choose/enhanced.t create mode 100644 test/testcases/choose/oldversion.t create mode 100644 test/testcases/choose/suggested.t create mode 100644 test/testcases/choose/versioned.t create mode 100644 test/testcases/choose/versioned2.t diff --git a/VERSION.cmake b/VERSION.cmake index c129470..d1494ff 100644 --- a/VERSION.cmake +++ b/VERSION.cmake @@ -49,5 +49,5 @@ SET(LIBSOLVEXT_SOVERSION "0") SET(LIBSOLV_MAJOR "0") SET(LIBSOLV_MINOR "6") -SET(LIBSOLV_PATCH "8") +SET(LIBSOLV_PATCH "9") diff --git a/bindings/solv.i b/bindings/solv.i index 78e0021..50f0b50 100644 --- a/bindings/solv.i +++ b/bindings/solv.i @@ -593,6 +593,17 @@ typedef struct { } Ruleinfo; typedef struct { + Solver *solv; + Id type; + Id rid; + Id from_id; + Id dep_id; + Id chosen_id; + Queue choices; + int level; +} Alternative; + +typedef struct { Transaction *transaction; int mode; Id type; @@ -785,6 +796,17 @@ typedef struct { Id const type; } Solutionelement; +%nodefaultctor Alternative; +typedef struct { + Solver *const solv; + Id const type; + Id const rid; + Id const from_id; + Id const dep_id; + Id const chosen_id; + int level; +} Alternative; + %nodefaultctor Transaction; %nodefaultdtor Transaction; typedef struct { @@ -2858,6 +2880,40 @@ rb_eval_string( *OUTPUT = new_XRule($self, ruleid); return reason; } + + int alternatives_count() { + return solver_alternatives_count($self); + } + + %newobject alternative; + Alternative *alternative(Id aid) { + Alternative *a = solv_calloc(1, sizeof(*a)); + a->solv = $self; + queue_init(&a->choices); + a->type = solver_get_alternative($self, aid, &a->dep_id, &a->from_id, &a->chosen_id, &a->choices, &a->level); + if (!a->type) { + queue_free(&a->choices); + solv_free(a); + return 0; + } + if (a->type == SOLVER_ALTERNATIVE_TYPE_RULE) { + a->rid = a->dep_id; + a->dep_id = 0; + } + return a; + } + + %typemap(out) Queue all_alternatives Queue2Array(Alternative *, 1, Solver_alternative(arg1, id)); + %newobject all_alternatives; + Queue all_alternatives() { + Queue q; + int i, cnt; + queue_init(&q); + cnt = solver_alternatives_count($self); + for (i = 1; i <= cnt; i++) + queue_push(&q, i); + return q; + } } %extend Transaction { @@ -3202,3 +3258,60 @@ rb_eval_string( #endif } #endif + +%extend Alternative { + static const int SOLVER_ALTERNATIVE_TYPE_RULE = SOLVER_ALTERNATIVE_TYPE_RULE; + static const int SOLVER_ALTERNATIVE_TYPE_RECOMMENDS = SOLVER_ALTERNATIVE_TYPE_RECOMMENDS; + static const int SOLVER_ALTERNATIVE_TYPE_SUGGESTS = SOLVER_ALTERNATIVE_TYPE_SUGGESTS; + + ~Alternative() { + queue_free(&$self->choices); + solv_free($self); + } + %newobject chosen; + XSolvable * const chosen; + %newobject rule; + XRule * const rule; + %newobject depsolvable; + XSolvable * const depsolvable; + %newobject dep; + Dep * const dep; + %{ + SWIGINTERN XSolvable *Alternative_chosen_get(Alternative *a) { + return new_XSolvable(a->solv->pool, a->chosen_id); + } + SWIGINTERN XRule *Alternative_rule_get(Alternative *a) { + return new_XRule(a->solv, a->rid); + } + SWIGINTERN XSolvable *Alternative_depsolvable_get(Alternative *a) { + return new_XSolvable(a->solv->pool, a->from_id); + } + SWIGINTERN Dep *Alternative_dep_get(Alternative *a) { + return new_Dep(a->solv->pool, a->dep_id); + } + %} + + Queue choices_raw() { + Queue r; + queue_init_clone(&r, &$self->choices); + return r; + } + + %typemap(out) Queue choices Queue2Array(XSolvable *, 1, new_XSolvable(arg1->solv->pool, id)); + Queue choices() { + int i; + Queue r; + queue_init_clone(&r, &$self->choices); + for (i = 0; i < r.count; i++) + if (r.elements[i] < 0) + r.elements[i] = -r.elements[i]; + return r; + } + +#if defined(SWIGPERL) + %rename("str") __str__; +#endif + const char *__str__() { + return solver_alternative2str($self->solv, $self->type, $self->type == SOLVER_ALTERNATIVE_TYPE_RULE ? $self->rid : $self->dep_id, $self->from_id); + } +} diff --git a/ext/CMakeLists.txt b/ext/CMakeLists.txt index 5f017f2..bdf949d 100644 --- a/ext/CMakeLists.txt +++ b/ext/CMakeLists.txt @@ -43,6 +43,11 @@ IF (ENABLE_SUSEREPO) repo_susetags.h repo_zyppdb.h) ENDIF (ENABLE_SUSEREPO) +IF (ENABLE_COMPLEX_DEPS AND (ENABLE_SUSEREPO OR ENABLE_RPMMD OR ENABLE_RPMDB)) + SET (libsolvext_SRCS ${libsolvext_SRCS} + pool_parserpmrichdep.c) +ENDIF (ENABLE_COMPLEX_DEPS AND (ENABLE_SUSEREPO OR ENABLE_RPMMD OR ENABLE_RPMDB)) + IF (SUSE) SET (libsolvext_SRCS ${libsolvext_SRCS} repo_autopattern.c) diff --git a/ext/libsolvext.ver b/ext/libsolvext.ver index 5c176e2..654469b 100644 --- a/ext/libsolvext.ver +++ b/ext/libsolvext.ver @@ -1,5 +1,6 @@ SOLV_1.0 { global: + pool_deb_get_autoinstalled; pool_findfileconflicts; repo_add_appdata; repo_add_appdata_dir; @@ -58,6 +59,7 @@ SOLV_1.0 { solvsig_free; solvsig_verify; testcase_add_testtags; + testcase_dep2str; testcase_job2str; testcase_solvid2str; testcase_str2dep; diff --git a/ext/pool_parserpmrichdep.c b/ext/pool_parserpmrichdep.c new file mode 100644 index 0000000..742823a --- /dev/null +++ b/ext/pool_parserpmrichdep.c @@ -0,0 +1,138 @@ +/* + * Copyright (c) 2015, SUSE Inc. + * + * This program is licensed under the BSD license, read LICENSE.BSD + * for further information + */ + +/* this is used by repo_rpmmd, repo_rpmdb, and repo_susetags */ + +#include + +#include "pool.h" +#include "pool_parserpmrichdep.h" + +#define REL_THEN 0 +#define REL_ELSE 0 + +static struct RichOpComp { + const char *n; + int l; + Id fl; +} RichOps[] = { + { "&&", 2, REL_AND }, + { "&", 1, REL_AND }, + { "AND", 3, REL_AND }, + { "||", 2, REL_OR }, + { "|", 1, REL_OR }, + { "OR", 2, REL_OR }, + { "IF", 2, REL_COND }, + { "THEN", 4, REL_THEN }, + { "?", 1, REL_THEN }, + { "ELSE", 4, REL_ELSE }, + { ":", 1, REL_ELSE }, + { NULL, 0, 0}, +}; + +static Id +parseRichDep(Pool *pool, const char **depp, Id chainfl) +{ + const char *p = *depp; + const char *n; + Id id, evr; + int fl, bl; + struct RichOpComp *op; + + if (!chainfl && *p++ != '(') + return 0; + while (*p == ' ') + p++; + if (*p == ')') + return 0; + if (*p == '(') + { + id = parseRichDep(pool, &p, 0); + if (!id) + return 0; + } + else + { + n = p; + bl = 0; + while (*p && !(*p == ' ' || *p == ',' || (*p == ')' && bl-- <= 0))) + if (*p++ == '(') + bl++; + if (n == p) + return 0; + id = pool_strn2id(pool, n, p - n, 1); + while (*p == ' ') + p++; + if (*p) + { + fl = 0; + for (;; p++) + { + if (*p == '<') + fl |= REL_LT; + else if (*p == '=') + fl |= REL_EQ; + else if (*p == '>') + fl |= REL_GT; + else + break; + } + if (fl) + { + while (*p == ' ') + p++; + n = p; + bl = 0; + while (*p && !(*p == ' ' || *p == ',' || (*p == ')' && bl-- <= 0))) + if (*p++ == '(') + bl++; + if (p - n > 2 && n[0] == '0' && n[1] == ':') + n += 2; /* strip zero epoch */ + if (n == p) + return 0; + id = pool_rel2id(pool, id, pool_strn2id(pool, n, p - n, 1), fl, 1); + } + } + } + while (*p == ' ') + p++; + if (!*p) + return 0; + if (*p == ')') + { + *depp = p + 1; + return id; + } + n = p; + while (*p && *p != ' ') + p++; + for (op = RichOps; op->n; op++) + if (p - n == op->l && !strncmp(n, op->n, op->l)) + break; + fl = op->fl; + if (!fl) + return 0; + if (chainfl == REL_THEN && fl == REL_ELSE) + chainfl = 0; + if (chainfl && fl != chainfl) + return 0; + evr = parseRichDep(pool, &p, fl); + if (!evr) + return 0; + *depp = p; + return pool_rel2id(pool, id, evr, fl, 1); +} + +Id +pool_parserpmrichdep(Pool *pool, const char *dep) +{ + Id id = parseRichDep(pool, &dep, 0); + if (id && *dep) + id = 0; + return id; +} + diff --git a/ext/pool_parserpmrichdep.h b/ext/pool_parserpmrichdep.h new file mode 100644 index 0000000..09dce2c --- /dev/null +++ b/ext/pool_parserpmrichdep.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2014, SUSE Inc. + * + * This program is licensed under the BSD license, read LICENSE.BSD + * for further information + */ + +#ifndef POOL_PARSERPMRICHDEP_H +#define POOL_PARSERPMRICHDEP_H + +#include "pool.h" + +extern Id pool_parserpmrichdep(Pool *pool, const char *dep); + +#endif diff --git a/ext/repo_deb.c b/ext/repo_deb.c index 5af0c70..05d731b 100644 --- a/ext/repo_deb.c +++ b/ext/repo_deb.c @@ -17,6 +17,7 @@ #include "pool.h" #include "repo.h" #include "util.h" +#include "solver.h" /* for GET_USERINSTALLED_ flags */ #include "chksum.h" #include "repo_deb.h" @@ -204,7 +205,7 @@ control2solvable(Solvable *s, Repodata *data, char *control) if (*p) *p++ = 0; /* strip trailing space */ - while (end >= control && *end == ' ' && *end == '\t') + while (end >= control && (*end == ' ' || *end == '\t')) *end-- = 0; tag = control; control = p; @@ -313,6 +314,10 @@ control2solvable(Solvable *s, Repodata *data, char *control) havesource = 1; } break; + case 'S' << 8 | 'T': + if (!strcasecmp(tag, "status")) + repodata_set_poolstr(data, s - pool->solvables, SOLVABLE_INSTALLSTATUS, q); + break; case 'S' << 8 | 'U': if (!strcasecmp(tag, "suggests")) s->suggests = makedeps(repo, q, s->suggests, 0); @@ -613,3 +618,92 @@ repo_add_deb(Repo *repo, const char *deb, int flags) repodata_internalize(data); return s - pool->solvables; } + +void +pool_deb_get_autoinstalled(Pool *pool, FILE *fp, Queue *q, int flags) +{ + Id name = 0, arch = 0; + int autoinstalled = -1; + char *buf, *bp; + int x, l, bufl, eof = 0; + Id p, pp; + + queue_empty(q); + buf = solv_malloc(4096); + bufl = 4096; + l = 0; + while (!eof) + { + while (bufl - l < 1024) + { + bufl += 4096; + if (bufl > 1024 * 64) + break; /* hmm? */ + buf = solv_realloc(buf, bufl); + } + if (!fgets(buf + l, bufl - l, fp)) + { + eof = 1; + buf[l] = '\n'; + buf[l + 1] = 0; + } + l = strlen(buf); + if (l && buf[l - 1] == '\n') + buf[--l] = 0; + if (!*buf || eof) + { + l = 0; + if (name && autoinstalled > 0) + { + if ((flags & GET_USERINSTALLED_NAMES) != 0) + queue_push(q, name); + else + { + FOR_PROVIDES(p, pp, name) + { + Solvable *s = pool->solvables + p; + if (s->name != name) + continue; + if (arch && s->arch != arch) + continue; + queue_push(q, p); + } + } + } + name = arch = 0; + autoinstalled = -1; + continue; + } + /* strip trailing space */ + while (l && (buf[l - 1] == ' ' || buf[l - 1] == '\t')) + buf[--l] = 0; + l = 0; + + bp = strchr(buf, ':'); + if (!bp || bp - buf < 4) + continue; + *bp++ = 0; + while (*bp == ' ' || *bp == '\t') + bp++; + x = '@' + (buf[0] & 0x1f); + x = (x << 8) + '@' + (buf[1] & 0x1f); + switch(x) + { + case 'P' << 8 | 'A': + if (!strcasecmp(buf, "package")) + name = pool_str2id(pool, bp, 1); + break; + case 'A' << 8 | 'R': + if (!strcasecmp(buf, "architecture")) + arch = pool_str2id(pool, bp, 1); + break; + case 'A' << 8 | 'U': + if (!strcasecmp(buf, "auto-installed")) + autoinstalled = atoi(bp); + break; + default: + break; + } + } +} + diff --git a/ext/repo_deb.h b/ext/repo_deb.h index 7057da6..5993991 100644 --- a/ext/repo_deb.h +++ b/ext/repo_deb.h @@ -8,5 +8,6 @@ extern int repo_add_debpackages(Repo *repo, FILE *fp, int flags); extern int repo_add_debdb(Repo *repo, int flags); extern Id repo_add_deb(Repo *repo, const char *deb, int flags); +extern void pool_deb_get_autoinstalled(Pool *pool, FILE *fp, Queue *q, int flags); #define DEBS_ADD_WITH_PKGID (1 << 8) diff --git a/ext/repo_rpmdb.c b/ext/repo_rpmdb.c index b4541c3..71c69ab 100644 --- a/ext/repo_rpmdb.c +++ b/ext/repo_rpmdb.c @@ -47,6 +47,9 @@ #include "chksum.h" #include "repo_rpmdb.h" #include "repo_solv.h" +#ifdef ENABLE_COMPLEX_DEPS +#include "pool_parserpmrichdep.h" +#endif /* 3: added triggers */ /* 4: fixed triggers */ @@ -147,6 +150,7 @@ #define DEP_STRONG (1 << 27) #define DEP_PRE_IN ((1 << 6) | (1 << 9) | (1 << 10)) #define DEP_PRE_UN ((1 << 6) | (1 << 11) | (1 << 12)) +#define DEP_RICH (1 << 29) #define FILEFLAG_GHOST (1 << 6) @@ -404,7 +408,6 @@ setutf8string(Repodata *repodata, Id handle, Id tag, const char *str) repodata_set_str(repodata, handle, tag, str); } - /* * strong: 0: ignore strongness * 1: filter to strong @@ -512,6 +515,7 @@ makedeps(Pool *pool, Repo *repo, RpmHead *rpmhead, int tagn, int tagv, int tagf, ida = repo->idarraydata + olddeps; for (i = 0; ; i++) { + Id id; if (i == nc) { if (haspre != 1) @@ -532,9 +536,21 @@ makedeps(Pool *pool, Repo *repo, RpmHead *rpmhead, int tagn, int tagv, int tagf, if ((flags & RPM_ADD_NO_RPMLIBREQS) != 0) if (!strncmp(n[i], "rpmlib(", 7)) continue; +#ifdef ENABLE_COMPLEX_DEPS + if ((f[i] & (DEP_RICH|DEP_LESS| DEP_EQUAL|DEP_GREATER)) == DEP_RICH && n[i][0] == '(') + { + id = pool_parserpmrichdep(pool, n[i]); + if (id) + *ida++ = id; + else + cc--; + continue; + } +#endif + id = pool_str2id(pool, n[i], 1); if (f[i] & (DEP_LESS|DEP_GREATER|DEP_EQUAL)) { - Id name, evr; + Id evr; int fl = 0; if ((f[i] & DEP_LESS) != 0) fl |= REL_LT; @@ -542,15 +558,13 @@ makedeps(Pool *pool, Repo *repo, RpmHead *rpmhead, int tagn, int tagv, int tagf, fl |= REL_EQ; if ((f[i] & DEP_GREATER) != 0) fl |= REL_GT; - name = pool_str2id(pool, n[i], 1); if (v[i][0] == '0' && v[i][1] == ':' && v[i][2]) evr = pool_str2id(pool, v[i] + 2, 1); else evr = pool_str2id(pool, v[i], 1); - *ida++ = pool_rel2id(pool, name, evr, fl, 1); + id = pool_rel2id(pool, id, evr, fl, 1); } - else - *ida++ = pool_str2id(pool, n[i], 1); + *ida++ = id; } *ida++ = 0; repo->idarraysize += cc + 1; diff --git a/ext/repo_rpmmd.c b/ext/repo_rpmmd.c index 21dd913..4272b6f 100644 --- a/ext/repo_rpmmd.c +++ b/ext/repo_rpmmd.c @@ -19,7 +19,9 @@ #include "tools_util.h" #include "repo_rpmmd.h" #include "chksum.h" - +#ifdef ENABLE_COMPLEX_DEPS +#include "pool_parserpmrichdep.h" +#endif enum state { STATE_START, @@ -466,7 +468,7 @@ static char *flagtab[] = { static unsigned int adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts, int isreq) { - Id id, name, marker; + Id id, marker; const char *n, *f, *k; const char **a; @@ -496,10 +498,18 @@ adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts pd->acontent = l + 256; } sprintf(pd->content, "%s:%s", k, n); - name = pool_str2id(pool, pd->content, 1); + id = pool_str2id(pool, pd->content, 1); + } +#ifdef ENABLE_COMPLEX_DEPS + else if (!f && n[0] == '(') + { + id = pool_parserpmrichdep(pool, n); + if (!id) + return olddeps; } +#endif else - name = pool_str2id(pool, (char *)n, 1); + id = pool_str2id(pool, (char *)n, 1); if (f) { Id evr = makeevr_atts(pool, pd, atts); @@ -508,10 +518,8 @@ adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, const char **atts if (!strcmp(f, flagtab[flags])) break; flags = flags < 6 ? flags + 1 : 0; - id = pool_rel2id(pool, name, evr, flags, 1); + id = pool_rel2id(pool, id, evr, flags, 1); } - else - id = name; #if 0 fprintf(stderr, "new dep %s\n", pool_dep2str(pool, id)); #endif diff --git a/ext/repo_susetags.c b/ext/repo_susetags.c index 440e2d5..a96ba97 100644 --- a/ext/repo_susetags.c +++ b/ext/repo_susetags.c @@ -18,6 +18,9 @@ #include "chksum.h" #include "tools_util.h" #include "repo_susetags.h" +#ifdef ENABLE_COMPLEX_DEPS +#include "pool_parserpmrichdep.h" +#endif struct datashare { Id name; @@ -87,6 +90,17 @@ adddep(Pool *pool, struct parsedata *pd, unsigned int olddeps, char *line, Id ma /* A file dependency. Do not try to parse it */ id = pool_str2id(pool, line + 6, 1); } +#ifdef ENABLE_COMPLEX_DEPS + else if (line[6] == '(') + { + id = pool_parserpmrichdep(pool, line + 6); + if (!id) + { + pd->ret = pool_error(pool, -1, "susetags: line %d: bad dependency: '%s'\n", pd->lineno, line); + return olddeps; + } + } +#endif else { i = split(line + 6, sp, 4); /* name, , evr, ? */ diff --git a/ext/testcase.c b/ext/testcase.c index fa9c807..f0057e6 100644 --- a/ext/testcase.c +++ b/ext/testcase.c @@ -77,6 +77,7 @@ static struct resultflags2str { { TESTCASE_RESULT_ORPHANED, "orphaned" }, { TESTCASE_RESULT_RECOMMENDED, "recommended" }, { TESTCASE_RESULT_UNNEEDED, "unneeded" }, + { TESTCASE_RESULT_ALTERNATIVES, "alternatives" }, { 0, 0 } }; @@ -284,151 +285,339 @@ strqueue_diff(Strqueue *sq1, Strqueue *sq2, Strqueue *osq) strqueue_pushjoin(osq, "+", sq2->str[j++], 0); } -static inline int -pool_isknownarch(Pool *pool, Id id) -{ - if (!id || id == ID_EMPTY) - return 0; - if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH) - return 1; - if (!pool->id2arch || (id > pool->lastarch || !pool->id2arch[id])) - return 0; - return 1; -} -static Id -testcase_str2dep_simple(Pool *pool, const char **sp) +static const char * +testcase_id2str(Pool *pool, Id id, int isname) { - const char *s = *sp; - const char *n, *a; - Id id, evr; - int flags; - - while (*s == ' ' || *s == '\t') - s++; - n = s; - while (*s && *s != ' ' && *s != '\t' && *s != '<' && *s != '=' && *s != '>') - { - if (*s == '(') + const char *s = pool_id2str(pool, id); + const char *ss; + char *s2, *s2p; + int bad = 0, paren = 0, parenbad = 0; + + if (id == 0) + return ""; + if (id == 1) + return "\\00"; + if (strchr("[(<=>!", *s)) + bad++; + if (!strncmp(s, "namespace:", 10)) + bad++; + for (ss = s + bad; *ss; ss++) + { + if (*ss == ' ' || *ss == '\\' || *(unsigned char *)ss < 32 || *ss == '(' || *ss == ')') + bad++; + if (*ss == '(') + paren = paren == 0 ? 1 : -1; + else if (*ss == ')') { - while (*s && *s != ')') - s++; - continue; + paren = paren == 1 ? 0 : -1; + if (!paren) + parenbad += 2; } - s++; } - if ((a = strchr(n, '.')) != 0 && a + 1 < s && s[-1] != ')') + if (isname && ss - s > 4 && !strcmp(ss - 4, ":any")) + bad++; + if (!paren && !(bad - parenbad)) + return s; + + /* we need escaping! */ + s2 = s2p = pool_alloctmpspace(pool, strlen(s) + bad * 2 + 1); + ss = s; + if (!strncmp(s, "namespace:", 10)) { - Id archid = pool_strn2id(pool, a + 1, s - (a + 1), 0); - if (pool_isknownarch(pool, archid)) + strcpy(s2p, "namespace\\3a"); + s2p += 12; + s += 10; + } + for (; *ss; ss++) + { + *s2p++ = *ss; + if ((ss == s && strchr("[(<=>!", *s)) || *ss == ' ' || *ss == '\\' || *(unsigned char *)ss < 32 || *ss == '(' || *ss == ')') { - id = pool_strn2id(pool, n, a - n, 1); - id = pool_rel2id(pool, id, archid, REL_ARCH, 1); + s2p[-1] = '\\'; + solv_bin2hex((unsigned char *)ss, 1, s2p); + s2p += 2; } - else - id = pool_strn2id(pool, n, s - n, 1); } - else if (s - n > 4 && s[-4] == ':' && !strncmp(s - 4, ":any", 4)) + *s2p = 0; + if (isname && s2p - s2 > 4 && !strcmp(s2p - 4, ":any")) + strcpy(s2p - 4, "\\3aany"); + return s2; +} + +struct oplist { + Id flags; + const char *opname; +} oplist[] = { + { REL_EQ, "=" }, + { REL_GT | REL_LT | REL_EQ, "<=>" }, + { REL_LT | REL_EQ, "<=" }, + { REL_GT | REL_EQ, ">=" }, + { REL_GT, ">" }, + { REL_GT | REL_LT, "<>" }, + { REL_AND, "&" }, + { REL_OR , "|" }, + { REL_WITH , "+" }, + { REL_NAMESPACE , "" }, + { REL_ARCH, "." }, + { REL_MULTIARCH, "" }, + { REL_FILECONFLICT, "" }, + { REL_COND, "" }, + { REL_COMPAT, "compat >=" }, + { REL_KIND, "" }, + { REL_LT, "<" }, + { 0, 0 } +}; + +static const char * +testcase_dep2str_complex(Pool *pool, Id id, int addparens) +{ + Reldep *rd; + char *s; + const char *s2; + int needparens; + struct oplist *op; + + if (!ISRELDEP(id)) + return testcase_id2str(pool, id, 1); + rd = GETRELDEP(pool, id); + + /* check for special shortcuts */ + if (rd->flags == REL_NAMESPACE && !ISRELDEP(rd->name) && !strncmp(pool_id2str(pool, rd->name), "namespace:", 10)) { - id = pool_strn2id(pool, n, s - n - 4, 1); - id = pool_rel2id(pool, id, ARCH_ANY, REL_MULTIARCH, 1); + const char *ns = pool_id2str(pool, rd->name); + int nslen = strlen(ns); + /* special namespace formatting */ + const char *evrs = testcase_dep2str_complex(pool, rd->evr, 0); + s = pool_tmpappend(pool, evrs, ns, "()"); + memmove(s + nslen + 1, s, strlen(s) - nslen - 2); + memcpy(s, ns, nslen); + s[nslen] = '('; + return s; + } + if (rd->flags == REL_MULTIARCH && !ISRELDEP(rd->name) && rd->evr == ARCH_ANY) + { + /* special :any suffix */ + const char *ns = testcase_id2str(pool, rd->name, 1); + return pool_tmpappend(pool, ns, ":any", 0); + } + + needparens = 0; + if (ISRELDEP(rd->name)) + { + Reldep *rd2 = GETRELDEP(pool, rd->name); + needparens = 1; + if (rd->flags > 7 && rd->flags != REL_COMPAT && rd2->flags && rd2->flags <= 7) + needparens = 0; + } + s = (char *)testcase_dep2str_complex(pool, rd->name, needparens); + + if (addparens) + { + s = pool_tmpappend(pool, s, "(", 0); + memmove(s + 1, s, strlen(s + 1)); + s[0] = '('; + } + for (op = oplist; op->flags; op++) + if (rd->flags == op->flags) + break; + if (op->flags) + { + s = pool_tmpappend(pool, s, " ", op->opname); + s = pool_tmpappend(pool, s, " ", 0); } else - id = pool_strn2id(pool, n, s - n, 1); - if (!*s) { - *sp = s; - return id; + char buf[64]; + sprintf(buf, " <%u> ", rd->flags); + s = pool_tmpappend(pool, s, buf, 0); } - while (*s == ' ' || *s == '\t') - s++; - flags = 0; - if (*s == '!' && s[1] == '=') /* support != as synonym for <> */ + + needparens = 0; + if (ISRELDEP(rd->evr)) + { + Reldep *rd2 = GETRELDEP(pool, rd->evr); + needparens = 1; + if (rd->flags > 7 && rd2->flags && rd2->flags <= 7) + needparens = 0; + if (rd->flags == REL_AND && rd2->flags == REL_AND) + needparens = 0; /* chain */ + if (rd->flags == REL_OR && rd2->flags == REL_OR) + needparens = 0; /* chain */ + if (rd->flags > 0 && rd->flags < 8 && rd2->flags == REL_COMPAT) + needparens = 0; /* chain */ + } + if (!ISRELDEP(rd->evr)) + s2 = testcase_id2str(pool, rd->evr, 0); + else + s2 = testcase_dep2str_complex(pool, rd->evr, needparens); + if (addparens) + s = pool_tmpappend(pool, s, s2, ")"); + else + s = pool_tmpappend(pool, s, s2, 0); + pool_freetmpspace(pool, s2); + return s; +} + +const char * +testcase_dep2str(Pool *pool, Id id) +{ + return testcase_dep2str_complex(pool, id, 0); +} + + +/* Convert a simple string. Also handle the :any suffix */ +static Id +testcase_str2dep_simple(Pool *pool, const char **sp, int isname) +{ + int haveesc = 0; + int paren = 0; + int isany = 0; + Id id; + const char *s; + for (s = *sp; *s; s++) { - flags = REL_LT | REL_GT; - s += 2; + if (*s == '\\') + haveesc++; + if (*s == ' ' || *(unsigned char *)s < 32) + break; + if (*s == '(') + paren++; + if (*s == ')' && paren-- <= 0) + break; } - for (;;s++) + if (isname && s - *sp > 4 && !strncmp(s - 4, ":any", 4)) { - if (*s == '<') - flags |= REL_LT; - else if (*s == '=') - flags |= REL_EQ; - else if (*s == '>') - flags |= REL_GT; + isany = 1; + s -= 4; + } + if (!haveesc) + { + if (s - *sp == 6 && !strncmp(*sp, "", 6)) + id = 0; else - break; + id = pool_strn2id(pool, *sp, s - *sp, 1); } - if (!flags) + else if (s - *sp == 3 && !strncmp(*sp, "\\00", 3)) + id = 1; + else { - *sp = s; - return id; + char buf[128], *bp, *bp2; + const char *sp2; + bp = s - *sp >= 128 ? solv_malloc(s - *sp + 1) : buf; + for (bp2 = bp, sp2 = *sp; sp2 < s;) + { + *bp2++ = *sp2++; + if (bp2[-1] == '\\') + solv_hex2bin(&sp2, (unsigned char *)bp2 - 1, 1); + } + *bp2 = 0; + id = pool_str2id(pool, bp, 1); + if (bp != buf) + solv_free(bp); } - while (*s == ' ' || *s == '\t') - s++; - n = s; - while (*s && *s != ' ' && *s != '\t') - s++; - evr = pool_strn2id(pool, n, s - n, 1); - if (*s == ' ' && !strcmp(s, " compat >= ")) + if (isany) { - s += 11; - while (*s == ' ' || *s == '\t') - s++; - n = s; - while (*s && *s != ' ' && *s != '\t') - s++; - evr = pool_rel2id(pool, evr, pool_strn2id(pool, n, s - n, 1), REL_COMPAT, 1); + id = pool_rel2id(pool, id, ARCH_ANY, REL_MULTIARCH, 1); + s += 4; } *sp = s; - return pool_rel2id(pool, id, evr, flags, 1); + return id; } + static Id -testcase_str2dep_complex(Pool *pool, const char **sp) +testcase_str2dep_complex(Pool *pool, const char **sp, int relop) { const char *s = *sp; - Id id; -#ifdef ENABLE_COMPLEX_DEPS + Id flags, id, id2, namespaceid = 0; + struct oplist *op; + while (*s == ' ' || *s == '\t') s++; - if (*s == '(') + if (!strncmp(s, "namespace:", 10)) { - s++; - id = testcase_str2dep_complex(pool, &s); - if (*s == ')') - s++; - while (*s == ' ' || *s == '\t') - s++; + /* special namespace hack */ + const char *s2; + for (s2 = s + 10; *s2 && *s2 != '('; s2++) + ; + if (*s2 == '(') + { + namespaceid = pool_strn2id(pool, s, s2 - s, 1); + s = s2; + } } - else -#endif - id = testcase_str2dep_simple(pool, &s); - if (*s == '|') + if (*s == '(') { s++; - id = pool_rel2id(pool, id, testcase_str2dep_complex(pool, &s), REL_OR, 1); - } - else if (*s == '&') - { + id = testcase_str2dep_complex(pool, &s, 0); + if (!s || *s != ')') + { + *sp = 0; + return 0; + } s++; - id = pool_rel2id(pool, id, testcase_str2dep_complex(pool, &s), REL_AND, 1); } - else if (*s == 'I' && s[1] == 'F' && (s[2] == ' ' || s[2] == '\t')) + else + id = testcase_str2dep_simple(pool, &s, relop ? 0 : 1); + if (namespaceid) + id = pool_rel2id(pool, namespaceid, id, REL_NAMESPACE, 1); + + for (;;) { - s += 2; - id = pool_rel2id(pool, id, testcase_str2dep_complex(pool, &s), REL_COND, 1); + while (*s == ' ' || *s == '\t') + s++; + if (!*s || *s == ')' || (relop && strncmp(s, "compat >= ", 10) != 0)) + { + *sp = s; + return id; + } + + /* we have an op! Find the end */ + flags = -1; + if (s[0] == '<' && (s[1] >= '0' && s[1] <= '9')) + { + const char *s2; + for (s2 = s + 1; *s2 >= '0' && *s2 <= '9'; s2++) + ; + if (*s2 == '>') + { + flags = strtoul(s + 1, 0, 10); + s = s2 + 1; + } + } + if (flags == -1) + { + for (op = oplist; op->flags; op++) + if (!strncmp(s, op->opname, strlen(op->opname))) + break; + if (!op->flags) + { + *sp = 0; + return 0; + } + flags = op->flags; + s += strlen(op->opname); + } + id2 = testcase_str2dep_complex(pool, &s, flags > 0 && flags < 8); + if (!s) + { + *sp = 0; + return 0; + } + id = pool_rel2id(pool, id, id2, flags, 1); } - *sp = s; - return id; } Id testcase_str2dep(Pool *pool, const char *s) { - return testcase_str2dep_complex(pool, &s); + Id id = testcase_str2dep_complex(pool, &s, 0); + return s && !*s ? id : 0; } +/**********************************************************/ + const char * testcase_repoid2str(Pool *pool, Id repoid) { @@ -597,12 +786,12 @@ testcase_job2str(Pool *pool, Id how, Id what) else if (select == SOLVER_SOLVABLE_NAME) { selstr = " name "; - pkgstr = pool_dep2str(pool, what); + pkgstr = testcase_dep2str(pool, what); } else if (select == SOLVER_SOLVABLE_PROVIDES) { selstr = " provides "; - pkgstr = pool_dep2str(pool, what); + pkgstr = testcase_dep2str(pool, what); } else if (select == SOLVER_SOLVABLE_ONE_OF) { @@ -920,14 +1109,13 @@ static void writedeps(Repo *repo, FILE *fp, const char *tag, Id key, Solvable *s, Offset off) { Pool *pool = repo->pool; - Id id, *dp, *prvdp; + Id id, *dp; int tagwritten = 0; const char *idstr; if (!off) return; dp = repo->idarraydata + off; - prvdp = 0; while ((id = *dp++) != 0) { if (key == SOLVABLE_REQUIRES && id == SOLVABLE_PREREQMARKER) @@ -939,68 +1127,8 @@ writedeps(Repo *repo, FILE *fp, const char *tag, Id key, Solvable *s, Offset off continue; } if (key == SOLVABLE_PROVIDES && id == SOLVABLE_FILEMARKER) - { - prvdp = dp; - continue; - } - idstr = pool_dep2str(pool, id); - if (ISRELDEP(id)) - { - Reldep *rd = GETRELDEP(pool, id); - if (key == SOLVABLE_CONFLICTS && rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_OTHERPROVIDERS) - { - if (!strncmp(idstr, "namespace:", 10)) - idstr += 10; - } - if (key == SOLVABLE_SUPPLEMENTS) - { - if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_FILESYSTEM) - { - if (!strncmp(idstr, "namespace:", 10)) - idstr += 10; - } - else if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_MODALIAS) - { - if (!strncmp(idstr, "namespace:", 10)) - idstr += 10; - } - else if (rd->flags == REL_AND) - { - /* either packageand chain or modalias */ - idstr = 0; - if (ISRELDEP(rd->evr)) - { - Reldep *mrd = GETRELDEP(pool, rd->evr); - if (mrd->flags == REL_NAMESPACE && mrd->name == NAMESPACE_MODALIAS) - { - idstr = pool_tmpjoin(pool, "modalias(", pool_dep2str(pool, rd->name), ":"); - idstr = pool_tmpappend(pool, idstr, pool_dep2str(pool, mrd->evr), ")"); - } - else if (mrd->flags >= 8) - continue; - } - if (!idstr) - { - /* must be and chain */ - idstr = pool_dep2str(pool, rd->evr); - for (;;) - { - id = rd->name; - if (!ISRELDEP(id)) - break; - rd = GETRELDEP(pool, id); - if (rd->flags != REL_AND) - break; - idstr = pool_tmpjoin(pool, pool_dep2str(pool, rd->evr), ":", idstr); - } - idstr = pool_tmpjoin(pool, pool_dep2str(pool, id), ":", idstr); - idstr = pool_tmpjoin(pool, "packageand(", idstr, ")"); - } - } - else if (rd->flags >= 8) - continue; - } - } + continue; + idstr = testcase_dep2str(pool, id); if (!tagwritten) { fprintf(fp, "+%s\n", tag); @@ -1008,36 +1136,31 @@ writedeps(Repo *repo, FILE *fp, const char *tag, Id key, Solvable *s, Offset off } fprintf(fp, "%s\n", idstr); } - if (key == SOLVABLE_PROVIDES) + if (tagwritten) + fprintf(fp, "-%s\n", tag); +} + +static void +writefilelist(Repo *repo, FILE *fp, const char *tag, Solvable *s) +{ + Pool *pool = repo->pool; + int tagwritten = 0; + Dataiterator di; + + dataiterator_init(&di, pool, repo, s - pool->solvables, SOLVABLE_FILELIST, 0, 0); + while (dataiterator_step(&di)) { - /* add the filelist */ - Dataiterator di; - dataiterator_init(&di, pool, repo, s - pool->solvables, SOLVABLE_FILELIST, 0, 0); - while (dataiterator_step(&di)) + const char *s = repodata_dir2str(di.data, di.kv.id, di.kv.str); + if (!tagwritten) { - const char *s = repodata_dir2str(di.data, di.kv.id, di.kv.str); - if (prvdp) - { - Id id = pool_str2id(pool, s, 0); - if (id) - { - for (dp = prvdp; *dp; dp++) - if (*dp == id) - break; - if (*dp) - continue; /* already included */ - } - } - if (!tagwritten) - { - fprintf(fp, "+%s", tag); - tagwritten = 1; - } - fprintf(fp, "%s\n", s); + fprintf(fp, "+%s\n", tag); + tagwritten = 1; } + fprintf(fp, "%s\n", s); } if (tagwritten) fprintf(fp, "-%s\n", tag); + dataiterator_free(&di); } int @@ -1053,7 +1176,7 @@ testcase_write_testtags(Repo *repo, FILE *fp) const char *tmp; unsigned int ti; - fprintf(fp, "=Ver: 2.0\n"); + fprintf(fp, "=Ver: 3.0\n"); FOR_REPO_SOLVABLES(repo, p, s) { name = pool_id2str(pool, s->name); @@ -1079,6 +1202,7 @@ testcase_write_testtags(Repo *repo, FILE *fp) ti = solvable_lookup_num(s, SOLVABLE_BUILDTIME, 0); if (ti) fprintf(fp, "=Tim: %u\n", ti); + writefilelist(repo, fp, "Fls:", s); } return 0; } @@ -1091,7 +1215,7 @@ adddep(Repo *repo, Offset olddeps, char *str, Id marker) } static void -finish_solvable(Pool *pool, Repodata *data, Solvable *s, char *filelist, int nfilelist) +finish_v2_solvable(Pool *pool, Repodata *data, Solvable *s, char *filelist, int nfilelist) { if (nfilelist) { @@ -1110,8 +1234,6 @@ finish_solvable(Pool *pool, Repodata *data, Solvable *s, char *filelist, int nfi repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, p); } } - if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC) - s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0); s->supplements = repo_fix_supplements(s->repo, s->provides, s->supplements, 0); s->conflicts = repo_fix_conflicts(s->repo, s->conflicts); } @@ -1132,6 +1254,8 @@ testcase_add_testtags(Repo *repo, FILE *fp, int flags) char *filelist = 0; int afilelist = 0; int nfilelist = 0; + int tagsversion = 0; + int addselfprovides = 1; /* for compat reasons */ data = repo_add_repodata(repo, flags); s = 0; @@ -1181,9 +1305,18 @@ testcase_add_testtags(Repo *repo, FILE *fp, int flags) tag = line[1] << 16 | line[2] << 8 | line[3]; switch(tag) { + case 'V' << 16 | 'e' << 8 | 'r': + tagsversion = atoi(line + 6); + addselfprovides = tagsversion < 3 || strstr(line + 6, "addselfprovides") != 0; + break; case 'P' << 16 | 'k' << 8 | 'g': if (s) - finish_solvable(pool, data, s, filelist, nfilelist); + { + if (tagsversion == 2) + finish_v2_solvable(pool, data, s, filelist, nfilelist); + if (addselfprovides && s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC) + s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0); + } nfilelist = 0; if (split(line + 5, sp, 5) != 4) break; @@ -1213,27 +1346,44 @@ testcase_add_testtags(Repo *repo, FILE *fp, int flags) s->requires = adddep(repo, s->requires, line + 6, SOLVABLE_PREREQMARKER); break; case 'P' << 16 | 'r' << 8 | 'v': - if (line[6] == '/') + /* version 2 had the file list at the end of the provides */ + if (tagsversion == 2) { - int l = strlen(line + 6) + 1; - if (nfilelist + l > afilelist) + if (line[6] == '/') { - afilelist = nfilelist + l + 512; - filelist = solv_realloc(filelist, afilelist); + int l = strlen(line + 6) + 1; + if (nfilelist + l > afilelist) + { + afilelist = nfilelist + l + 512; + filelist = solv_realloc(filelist, afilelist); + } + memcpy(filelist + nfilelist, line + 6, l); + nfilelist += l; + break; + } + if (nfilelist) + { + int l; + for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1) + s->provides = repo_addid_dep(repo, s->provides, pool_str2id(pool, filelist + l, 1), 0); + nfilelist = 0; } - memcpy(filelist + nfilelist, line + 6, l); - nfilelist += l; - break; - } - if (nfilelist) - { - int l; - for (l = 0; l < nfilelist; l += strlen(filelist + l) + 1) - s->provides = repo_addid_dep(repo, s->provides, pool_str2id(pool, filelist + l, 1), 0); - nfilelist = 0; } s->provides = adddep(repo, s->provides, line + 6, 0); break; + case 'F' << 16 | 'l' << 8 | 's': + { + char *p = strrchr(line + 6, '/'); + Id did; + if (!p) + break; + *p++ = 0; + did = repodata_str2dir(data, line + 6, 1); + if (!did) + did = repodata_str2dir(data, "/", 1); + repodata_add_dirstr(data, s - pool->solvables, SOLVABLE_FILELIST, did, p); + break; + } case 'O' << 16 | 'b' << 8 | 's': s->obsoletes = adddep(repo, s->obsoletes, line + 6, 0); break; @@ -1257,7 +1407,12 @@ testcase_add_testtags(Repo *repo, FILE *fp, int flags) } } if (s) - finish_solvable(pool, data, s, filelist, nfilelist); + { + if (tagsversion == 2) + finish_v2_solvable(pool, data, s, filelist, nfilelist); + if (addselfprovides && s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC) + s->provides = repo_addid_dep(s->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0); + } solv_free(line); solv_free(filelist); repodata_free_dircache(data); @@ -1470,6 +1625,33 @@ testcase_solutionid(Solver *solv, Id problem, Id solution) return s; } +static const char * +testcase_alternativeid(Solver *solv, int type, Id id, Id from) +{ + const char *s; + Pool *pool = solv->pool; + Chksum *chk; + const unsigned char *md5; + int md5l; + chk = solv_chksum_create(REPOKEY_TYPE_MD5); + if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS) + { + s = testcase_solvid2str(pool, from); + solv_chksum_add(chk, s, strlen(s) + 1); + s = testcase_dep2str(pool, id); + solv_chksum_add(chk, s, strlen(s) + 1); + } + else if (type == SOLVER_ALTERNATIVE_TYPE_RULE) + { + s = testcase_ruleid(solv, id); + solv_chksum_add(chk, s, strlen(s) + 1); + } + md5 = solv_chksum_get(chk, &md5l); + s = pool_bin2hex(pool, md5, 4); + chk = solv_chksum_free(chk, 0); + return s; +} + static struct class2str { Id class; const char *str; @@ -1626,6 +1808,72 @@ testcase_solverresult(Solver *solv, int resultflags) queue_free(&q); queue_free(&qf); } + if ((resultflags & TESTCASE_RESULT_ALTERNATIVES) != 0) + { + char *altprefix; + Queue q, rq; + int cnt; + Id alternative; + queue_init(&q); + queue_init(&rq); + cnt = solver_alternatives_count(solv); + for (alternative = 1; alternative <= cnt; alternative++) + { + Id id, from, chosen; + char num[20]; + int type = solver_get_alternative(solv, alternative, &id, &from, &chosen, &q, 0); + altprefix = solv_dupjoin("alternative ", testcase_alternativeid(solv, type, id, from), " "); + strcpy(num, " 0 "); + if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS) + { + char *s = pool_tmpjoin(pool, altprefix, num, testcase_solvid2str(pool, from)); + s = pool_tmpappend(pool, s, " recommends ", testcase_dep2str(pool, id)); + strqueue_push(&sq, s); + } + else if (type == SOLVER_ALTERNATIVE_TYPE_RULE) + { + /* map choice rules back to pkg rules */ + if (solver_ruleclass(solv, id) == SOLVER_RULE_CHOICE) + id = solver_rule2pkgrule(solv, id); + solver_allruleinfos(solv, id, &rq); + for (i = 0; i < rq.count; i += 4) + { + int rtype = rq.elements[i]; + if ((rtype & SOLVER_RULE_TYPEMASK) == SOLVER_RULE_JOB) + { + const char *js = testcase_job2str(pool, rq.elements[i + 2], rq.elements[i + 3]); + char *s = pool_tmpjoin(pool, altprefix, num, " job "); + s = pool_tmpappend(pool, s, js, 0); + strqueue_push(&sq, s); + } + else if (rtype == SOLVER_RULE_PKG_REQUIRES) + { + char *s = pool_tmpjoin(pool, altprefix, num, testcase_solvid2str(pool, rq.elements[i + 1])); + s = pool_tmpappend(pool, s, " requires ", testcase_dep2str(pool, rq.elements[i + 3])); + strqueue_push(&sq, s); + } + } + } + for (i = 0; i < q.count; i++) + { + Id p = q.elements[i]; + if (i >= 9) + num[0] = '0' + (i + 1) / 10; + num[1] = '0' + (i + 1) % 10; + if (-p == chosen) + s = pool_tmpjoin(pool, altprefix, num, "+ "); + else if (p < 0) + s = pool_tmpjoin(pool, altprefix, num, "- "); + else if (p >= 0) + s = pool_tmpjoin(pool, altprefix, num, " "); + s = pool_tmpappend(pool, s, testcase_solvid2str(pool, p < 0 ? -p : p), 0); + strqueue_push(&sq, s); + } + solv_free(altprefix); + } + queue_free(&q); + queue_free(&rq); + } strqueue_sort(&sq); result = strqueue_join(&sq); diff --git a/ext/testcase.h b/ext/testcase.h index 4243e4f..14a2cca 100644 --- a/ext/testcase.h +++ b/ext/testcase.h @@ -14,8 +14,10 @@ #define TESTCASE_RESULT_ORPHANED (1 << 2) #define TESTCASE_RESULT_RECOMMENDED (1 << 3) #define TESTCASE_RESULT_UNNEEDED (1 << 4) +#define TESTCASE_RESULT_ALTERNATIVES (1 << 5) extern Id testcase_str2dep(Pool *pool, const char *s); +extern const char *testcase_dep2str(Pool *pool, Id id); extern const char *testcase_repoid2str(Pool *pool, Id repoid); extern const char *testcase_solvid2str(Pool *pool, Id p); extern Repo *testcase_str2repo(Pool *pool, const char *str); diff --git a/package/libsolv.changes b/package/libsolv.changes index 9579927..57dede3 100644 --- a/package/libsolv.changes +++ b/package/libsolv.changes @@ -1,4 +1,16 @@ ------------------------------------------------------------------- +Mon Mar 9 16:42:35 CET 2015 - mls@suse.de + +- rework splitprovides handling [bnc#921332] +- improve package choosing code +- new testcase dependency format +- add alternatives introspection +- make reorder_dq_for_jobrules also look at recommends/suggests +- rework branch handling +- add parser for rpm rich deps +- bump version to 0.6.9 + +------------------------------------------------------------------- Wed Jan 14 08:58:46 CET 2015 - ma@suse.de - fixes to build with swig 3.0.3 diff --git a/src/knownid.h b/src/knownid.h index a229121..c094bf5 100644 --- a/src/knownid.h +++ b/src/knownid.h @@ -258,6 +258,8 @@ KNOWNID(SIGNATURE_DATA, "signature:data"), KNOWNID(PRODUCT_REGISTER_FLAVOR, "product:regflavor"), /* installed and available product */ +KNOWNID(SOLVABLE_INSTALLSTATUS, "solvable:installstatus"), /* debian install status */ + KNOWNID(ID_NUM_INTERNAL, 0) #ifdef KNOWNID_INITIALIZE diff --git a/src/libsolv.ver b/src/libsolv.ver index 91337ea..c795b7a 100644 --- a/src/libsolv.ver +++ b/src/libsolv.ver @@ -314,6 +314,8 @@ SOLV_1.0 { solvable_trivial_installable_repo; solvable_unset; solver_allruleinfos; + solver_alternative2str; + solver_alternatives_count; solver_calc_duchanges; solver_calc_installsizechange; solver_calculate_multiversionmap; @@ -329,6 +331,7 @@ SOLV_1.0 { solver_findproblemrule; solver_free; solver_freedupmaps; + solver_get_alternative; solver_get_decisionblock; solver_get_decisionlevel; solver_get_decisionqueue; @@ -360,6 +363,7 @@ SOLV_1.0 { solver_problemruleinfo2str; solver_rule2job; solver_rule2jobidx; + solver_rule2pkgrule; solver_rule2rules; solver_rule2solvable; solver_ruleclass; diff --git a/src/policy.c b/src/policy.c index 9e5a934..a0ecec1 100644 --- a/src/policy.c +++ b/src/policy.c @@ -406,11 +406,41 @@ policy_update_recommendsmap(Solver *solv) } } +/* bring suggested/enhanced packages to front + * installed packages count as suggested */ +static void +prefer_suggested(Solver *solv, Queue *plist) +{ + Pool *pool = solv->pool; + int i, count; + + /* update our recommendsmap/suggestsmap */ + if (solv->recommends_index < solv->decisionq.count) + policy_update_recommendsmap(solv); + + for (i = 0, count = plist->count; i < count; i++) + { + Id p = plist->elements[i]; + Solvable *s = pool->solvables + p; + if ((pool->installed && s->repo == pool->installed) || + MAPTST(&solv->suggestsmap, p) || + solver_is_enhancing(solv, s)) + continue; /* good package */ + /* bring to back */ + if (i < plist->count - 1) + { + memmove(plist->elements + i, plist->elements + i + 1, (plist->count - 1 - i) * sizeof(Id)); + plist->elements[plist->count - 1] = p; + } + i--; + count--; + } +} + /* * prune to recommended/suggested packages. * does not prune installed packages (they are also somewhat recommended). */ - static void prune_to_recommended(Solver *solv, Queue *plist) { @@ -467,6 +497,7 @@ prune_to_recommended(Solver *solv, Queue *plist) if (j) plist->count = j; +#if 0 /* anything left to prune? */ if (plist->count - ninst < 2) return; @@ -500,6 +531,7 @@ prune_to_recommended(Solver *solv, Queue *plist) } if (j) plist->count = j; +#endif } static void @@ -836,6 +868,240 @@ prune_to_best_version(Pool *pool, Queue *plist) } +static int +sort_by_name_evr_sortcmp(const void *ap, const void *bp, void *dp) +{ + Pool *pool = dp; + Id a, *aa = (Id *)ap; + Id b, *bb = (Id *)bp; + Id r = aa[1] - bb[1]; + if (r) + return r < 0 ? -1 : 1; + a = aa[2] < 0 ? -aa[2] : aa[2]; + b = bb[2] < 0 ? -bb[2] : bb[2]; + if (pool->disttype != DISTTYPE_DEB) + { + /* treat release-less versions different */ + const char *as = pool_id2str(pool, a); + const char *bs = pool_id2str(pool, b); + if (strchr(as, '-')) + { + if (!strchr(bs, '-')) + return -2; + } + else + { + if (strchr(bs, '-')) + return 2; + } + } + r = pool_evrcmp(pool, b, a, EVRCMP_COMPARE); + if (!r && (aa[2] < 0 || bb[2] < 0)) + { + if (bb[2] >= 0) + return 1; + if (aa[2] >= 0) + return -1; + } + if (r) + return r < 0 ? -1 : 1; + return 0; +} + +/* common end of sort_by_srcversion and sort_by_common_dep */ +static void +sort_by_name_evr_array(Pool *pool, Queue *plist, int count, int ent) +{ + Id lastname; + int i, j, bad, havebad; + Id *pp, *elements = plist->elements; + + if (ent < 2) + { + queue_truncate(plist, count); + return; + } + solv_sort(elements + count * 2, ent, sizeof(Id) * 3, sort_by_name_evr_sortcmp, pool); + lastname = 0; + bad = havebad = 0; + for (i = 0, pp = elements + count * 2; i < ent; i++, pp += 3) + { + if (lastname && pp[1] == lastname) + { + if (pp[0] != pp[-3] && sort_by_name_evr_sortcmp(pp - 3, pp, pool) == -1) + { +#if 0 + printf("%s - %s: bad %s %s - %s\n", pool_solvid2str(pool, elements[pp[-3]]), pool_solvid2str(pool, elements[pp[0]]), pool_dep2str(pool, lastname), pool_id2str(pool, pp[-1] < 0 ? -pp[-1] : pp[-1]), pool_id2str(pool, pp[2] < 0 ? -pp[2] : pp[2])); +#endif + bad++; + havebad = 1; + } + } + else + { + bad = 0; + lastname = pp[1]; + } + elements[count + pp[0]] += bad; + } + +#if 0 +for (i = 0; i < count; i++) + printf("%s badness %d\n", pool_solvid2str(pool, elements[i]), elements[count + i]); +#endif + + if (havebad) + { + /* simple stable insertion sort */ + if (pool->installed) + for (i = 0; i < count; i++) + if (pool->solvables[elements[i]].repo == pool->installed) + elements[i + count] = 0; + for (i = 1; i < count; i++) + for (j = i, pp = elements + count + j; j > 0; j--, pp--) + if (pp[-1] > pp[0]) + { + Id *pp2 = pp - count; + Id p = pp[-1]; + pp[-1] = pp[0]; + pp[0] = p; + p = pp2[-1]; + pp2[-1] = pp2[0]; + pp2[0] = p; + } + else + break; + } + queue_truncate(plist, count); +} + +#if 0 +static void +sort_by_srcversion(Pool *pool, Queue *plist) +{ + int i, count = plist->count, ent = 0; + queue_insertn(plist, count, count, 0); + for (i = 0; i < count; i++) + { + Id name, evr, p = plist->elements[i]; + Solvable *s = pool->solvables + p; + if (solvable_lookup_void(s, SOLVABLE_SOURCENAME)) + name = s->name; + else + name = solvable_lookup_id(s, SOLVABLE_SOURCENAME); + if (solvable_lookup_void(s, SOLVABLE_SOURCEEVR)) + evr = s->evr; + else + evr = solvable_lookup_id(s, SOLVABLE_SOURCEEVR); + if (!name || !evr || ISRELDEP(evr)) + continue; + queue_push(plist, i); + queue_push2(plist, name, evr); + ent++; + } + sort_by_name_evr_array(pool, plist, count, ent); +} +#endif + +static void +sort_by_common_dep(Pool *pool, Queue *plist) +{ + int i, count = plist->count, ent = 0; + Id id, *dp; + queue_insertn(plist, count, count, 0); + for (i = 0; i < count; i++) + { + Id p = plist->elements[i]; + Solvable *s = pool->solvables + p; + if (!s->provides) + continue; + for (dp = s->repo->idarraydata + s->provides; (id = *dp++) != 0; ) + { + Reldep *rd; + if (!ISRELDEP(id)) + continue; + rd = GETRELDEP(pool, id); + if ((rd->flags == REL_EQ || rd->flags == (REL_EQ | REL_LT) || rd->flags == REL_LT) && !ISRELDEP(rd->evr)) + { + if (rd->flags == REL_EQ) + { + /* ignore hashes */ + const char *s = pool_id2str(pool, rd->evr); + if (strlen(s) >= 4) + { + while ((*s >= 'a' && *s <= 'f') || (*s >= '0' && *s <= '9')) + s++; + if (!*s) + continue; + } + } + queue_push(plist, i); + queue_push2(plist, rd->name, rd->flags == REL_LT ? -rd->evr : rd->evr); + ent++; + } + } + } + sort_by_name_evr_array(pool, plist, count, ent); +} + +/* check if we have an update candidate */ +static void +dislike_old_versions(Pool *pool, Queue *plist) +{ + int i, count = plist->count; + Id *elements = plist->elements; + int bad = 0; + + for (i = 0; i < count; i++) + { + Id p = elements[i]; + Solvable *s = pool->solvables + p; + Repo *repo = s->repo; + Id q, qq; + + if (!repo || repo == pool->installed) + continue; + FOR_PROVIDES(q, qq, s->name) + { + Solvable *qs = pool->solvables + q; + if (q == p) + continue; + if (s->name != qs->name || s->arch != qs->arch) + continue; + if (repo->priority != qs->repo->priority) + { + if (repo->priority > qs->repo->priority) + continue; + elements[i] = -p; + bad = 1; + break; + } + if (pool_evrcmp(pool, qs->evr, s->evr, EVRCMP_COMPARE) > 0) + { + elements[i] = -p; + bad = 1; + break; + } + } + } + if (!bad) + return; + /* now move negative elements to the back */ + for (i = 0; i < count; i++) + { + Id p = elements[i]; + if (p >= 0) + continue; + if (i < plist->count - 1) + { + memmove(elements + i, elements + i + 1, (plist->count - 1 - i) * sizeof(Id)); + elements[plist->count - 1] = -p; + } + i--; + count--; + } +} + /* * POLICY_MODE_CHOOSE: default, do all pruning steps * POLICY_MODE_RECOMMEND: leave out prune_to_recommended @@ -857,7 +1123,19 @@ policy_filter_unwanted(Solver *solv, Queue *plist, int mode) if (plist->count > 1) prune_to_best_version(pool, plist); if (plist->count > 1 && mode == POLICY_MODE_CHOOSE) - prune_to_recommended(solv, plist); + { + prune_to_recommended(solv, plist); + if (plist->count > 1) + { + /* do some fancy reordering */ +#if 0 + sort_by_srcversion(pool, plist); +#endif + dislike_old_versions(pool, plist); + sort_by_common_dep(pool, plist); + prefer_suggested(solv, plist); + } + } } diff --git a/src/repodata.c b/src/repodata.c index 4d57790..4ba1345 100644 --- a/src/repodata.c +++ b/src/repodata.c @@ -1444,6 +1444,8 @@ dataiterator_filelistcheck(Dataiterator *di) if (!needcomplete) { /* we don't need the complete filelist, so ignore all stubs */ + if (data->repo->nrepodata == 2) + return 1; for (j = 1; j < data->nkeys; j++) if (data->keys[j].name != REPOSITORY_SOLVABLES && data->keys[j].name != SOLVABLE_FILELIST) return 1; diff --git a/src/rules.c b/src/rules.c index 048cd99..c9bbf81 100644 --- a/src/rules.c +++ b/src/rules.c @@ -65,7 +65,7 @@ dep_possible(Solver *solv, Id dep, Map *m) return dep_possible(solv, rd->evr, m); } if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES) - return solver_splitprovides(solv, rd->evr); + return solver_splitprovides(solv, rd->evr, m); if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED) return solver_dep_installed(solv, rd->evr); } @@ -541,7 +541,7 @@ add_complex_deprules(Solver *solv, Id p, Id dep, int type, int dontfix, Queue *w queue_init(&bq); /* CNF expansion for requires, DNF + INVERT expansion for conflicts */ - i = pool_normalize_complex_dep(pool, dep, &bq, type == SOLVER_RULE_DEP_PACKAGE_REQUIRES ? 0 : (CPLXDEPS_TODNF | CPLXDEPS_EXPAND | CPLXDEPS_INVERT)); + i = pool_normalize_complex_dep(pool, dep, &bq, type == SOLVER_RULE_PKG_REQUIRES ? 0 : (CPLXDEPS_TODNF | CPLXDEPS_EXPAND | CPLXDEPS_INVERT)); /* handle special cases */ if (i == 0) { @@ -2763,6 +2763,14 @@ solver_rule2solvable(Solver *solv, Id rid) return 0; } +Id +solver_rule2pkgrule(Solver *solv, Id rid) +{ + if (rid >= solv->choicerules && rid < solv->choicerules_end) + return solv->choicerules_ref[rid - solv->choicerules]; + return 0; +} + static void solver_rule2rules_rec(Solver *solv, Id rid, Queue *q, Map *seen) { @@ -3563,7 +3571,11 @@ check_xsupp(Solver *solv, Queue *depq, Id dep) return check_xsupp(solv, depq, rd->evr); } if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES) +#if 0 return solver_splitprovides(solv, rd->evr); +#else + return 0; +#endif if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED) return solver_dep_installed(solv, rd->evr); } diff --git a/src/rules.h b/src/rules.h index 83a2679..8f55af3 100644 --- a/src/rules.h +++ b/src/rules.h @@ -145,6 +145,7 @@ extern int solver_rule2jobidx(struct _Solver *solv, Id rid); extern Id solver_rule2job(struct _Solver *solv, Id rid, Id *whatp); extern Id solver_rule2solvable(struct _Solver *solv, Id rid); extern void solver_rule2rules(struct _Solver *solv, Id rid, Queue *q, int recursive); +extern Id solver_rule2pkgrule(struct _Solver *solv, Id rid); /* orphan handling */ extern void solver_breakorphans(struct _Solver *solv); diff --git a/src/solver.c b/src/solver.c index 14fe78d..46d0ca3 100644 --- a/src/solver.c +++ b/src/solver.c @@ -44,16 +44,34 @@ * and is only true if pkg is installed and contains the specified path. * we also make sure that pkg is selected for an update, otherwise the * update would always be forced onto the user. + * Map m is the map used when called from dep_possible. */ + +static int +solver_is_updating(Solver *solv, Id p) +{ + /* check if the update rule is true */ + Pool *pool = solv->pool; + Rule *r; + Id l, pp; + if (solv->decisionmap[p] >= 0) + return 0; /* old package stayed */ + r = solv->rules + solv->updaterules + (p - solv->installed->start); + FOR_RULELITERALS(l, pp, r) + if (l > 0 && l != p && solv->decisionmap[l] > 0) + return 1; + return 0; +} + int -solver_splitprovides(Solver *solv, Id dep) +solver_splitprovides(Solver *solv, Id dep, Map *m) { Pool *pool = solv->pool; Id p, pp; Reldep *rd; Solvable *s; - if (!solv->dosplitprovides || !solv->installed || (!solv->updatemap_all && !solv->updatemap.size)) + if (!solv->dosplitprovides || !solv->installed) return 0; if (!ISRELDEP(dep)) return 0; @@ -76,8 +94,10 @@ solver_splitprovides(Solver *solv, Id dep) /* here we have packages that provide the correct name and contain the path, * now do extra filtering */ s = pool->solvables + p; - if (s->repo == solv->installed && s->name == rd->name && - (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p - solv->installed->start)))) + if (s->repo != solv->installed || s->name != rd->name) + continue; + /* check if the package is updated. if m is set, we're called from dep_possible */ + if (m || solver_is_updating(solv, p)) return 1; } return 0; @@ -147,7 +167,7 @@ solver_check_installsuppdepq_dep(Solver *solv, Id dep) return r1 == 2 || r2 == 2 ? 2 : 1; } if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES) - return solver_splitprovides(solv, rd->evr); + return solver_splitprovides(solv, rd->evr, 0); if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED) return solver_dep_installed(solv, rd->evr); if (rd->flags == REL_NAMESPACE && (q = solv->installsuppdepq) != 0) @@ -1243,13 +1263,7 @@ revert(Solver *solv, int level) solv->propagate_index = solv->decisionq.count; } while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] >= level) - { - solv->branches.count--; - while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] >= 0) - solv->branches.count--; - while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] < 0) - solv->branches.count--; - } + solv->branches.count -= solv->branches.elements[solv->branches.count - 2]; if (solv->recommends_index > solv->decisionq.count) solv->recommends_index = -1; /* rebuild recommends/suggests maps */ if (solv->decisionq.count < solv->decisioncnt_jobs) @@ -1379,6 +1393,7 @@ reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq) { Pool *pool = solv->pool; int i, j, haveone = 0, dqcount = dq->count; + int decisionqcount = solv->decisionq.count; Id p; Solvable *s; @@ -1390,25 +1405,34 @@ reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq) continue; if (solv->decisionmap[p] == 0) { + if (s->recommends || s->suggests) + queue_push(&solv->decisionq, p); solv->decisionmap[p] = level + 1; haveone = 1; } } if (!haveone) return; + policy_update_recommendsmap(solv); for (i = 0; i < dqcount; i++) - if (!solver_is_enhancing(solv, pool->solvables + dq->elements[i])) - { - queue_push(dq, dq->elements[i]); - dq->elements[i] = 0; - } + { + p = dq->elements[i]; + if (!(pool->solvables[p].repo == solv->installed || MAPTST(&solv->suggestsmap, p) || solver_is_enhancing(solv, pool->solvables + p))) + { + queue_push(dq, p); + dq->elements[i] = 0; + } + } dqcount = dq->count; for (i = 0; i < dqcount; i++) - if (dq->elements[i] && !solver_is_supplementing(solv, pool->solvables + dq->elements[i])) - { - queue_push(dq, dq->elements[i]); - dq->elements[i] = 0; - } + { + p = dq->elements[i]; + if (p && !(pool->solvables[p].repo == solv->installed || MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p))) + { + queue_push(dq, p); + dq->elements[i] = 0; + } + } for (i = j = 0; i < dq->count; i++) if (dq->elements[i]) dq->elements[j++] = dq->elements[i]; @@ -1416,6 +1440,62 @@ reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq) FOR_REPO_SOLVABLES(solv->installed, p, s) if (solv->decisionmap[p] == level + 1) solv->decisionmap[p] = 0; + if (solv->decisionq.count != decisionqcount) + { + solv->recommends_index = -1; + queue_truncate(&solv->decisionq, decisionqcount); + } +} + +/*------------------------------------------------------------------- + * + * branch handling + */ + +static void +createbranch(Solver *solv, int level, Queue *dq, Id p, Id data) +{ + Pool *pool = solv->pool; + int i; + IF_POOLDEBUG (SOLV_DEBUG_POLICY) + { + POOL_DEBUG (SOLV_DEBUG_POLICY, "creating a branch:\n"); + for (i = 0; i < dq->count; i++) + POOL_DEBUG (SOLV_DEBUG_POLICY, " - %s\n", pool_solvid2str(pool, dq->elements[i])); + } + queue_push(&solv->branches, -dq->elements[0]); + for (i = 1; i < dq->count; i++) + queue_push(&solv->branches, dq->elements[i]); + queue_push2(&solv->branches, p, data); + queue_push2(&solv->branches, dq->count + 4, level); +} + +static int +takebranch(Solver *solv, int pos, int end, const char *msg, int disablerules) +{ + Pool *pool = solv->pool; + int level; + Id p, why; +#if 0 + { + int i; + printf("branch group level %d [%d-%d] %d %d:\n", solv->branches.elements[end - 1], start, end, solv->branches.elements[end - 4], solv->branches.elements[end - 3]); + for (i = end - solv->branches.elements[end - 2]; i < end - 4; i++) + printf("%c %c%s\n", i == pos ? 'x' : ' ', solv->branches.elements[i] >= 0 ? ' ' : '-', pool_solvid2str(pool, solv->branches.elements[i] >= 0 ? solv->branches.elements[i] : -solv->branches.elements[i])); + } +#endif + level = solv->branches.elements[end - 1]; + p = solv->branches.elements[pos]; + solv->branches.elements[pos] = -p; + POOL_DEBUG(SOLV_DEBUG_SOLVER, "%s %d -> %d with %s\n", msg, solv->decisionmap[p], level, pool_solvid2str(pool, p)); + /* hack: set level to zero so that revert does not remove the branch */ + solv->branches.elements[end - 1] = 0; + revert(solv, level); + solv->branches.elements[end - 1] = level; + /* hack: revert simply sets the count, so we can still access the reverted elements */ + why = -solv->decisionq_why.elements[solv->decisionq_why.count]; + assert(why >= 0); + return setpropagatelearn(solv, level, p, disablerules, why); } /*------------------------------------------------------------------- @@ -1434,40 +1514,18 @@ selectandinstall(Solver *solv, int level, Queue *dq, int disablerules, Id ruleid { Pool *pool = solv->pool; Id p; - int i; if (dq->count > 1) policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE); - if (dq->count > 1) - { - /* XXX: didn't we already do that? */ - /* XXX: shouldn't we prefer installed packages? */ - /* XXX: move to policy.c? */ - /* choose the supplemented one */ - for (i = 0; i < dq->count; i++) - if (solver_is_supplementing(solv, pool->solvables + dq->elements[i])) - { - dq->elements[0] = dq->elements[i]; - dq->count = 1; - break; - } - } /* if we're resolving job rules and didn't resolve the installed packages yet, * do some special supplements ordering */ if (dq->count > 1 && ruleid >= solv->jobrules && ruleid < solv->jobrules_end && solv->installed && !solv->focus_installed) reorder_dq_for_jobrules(solv, level, dq); + /* if we have multiple candidates we open a branch */ if (dq->count > 1) - { - /* multiple candidates, open a branch */ - queue_push(&solv->branches, -dq->elements[0]); - for (i = 1; i < dq->count; i++) - queue_push(&solv->branches, dq->elements[i]); - queue_push(&solv->branches, level); - } + createbranch(solv, level, dq, 0, ruleid); p = dq->elements[0]; - POOL_DEBUG(SOLV_DEBUG_POLICY, "installing %s\n", pool_solvid2str(pool, p)); - return setpropagatelearn(solv, level, p, disablerules, ruleid); } @@ -2528,7 +2586,6 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) /* filter out all already supplemented packages if requested */ if (!solv->addalreadyrecommended && dqs.count) { - int dosplitprovides_old = solv->dosplitprovides; /* turn off all new packages */ for (i = 0; i < solv->decisionq.count; i++) { @@ -2539,7 +2596,6 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) if (s->repo && s->repo != solv->installed) solv->decisionmap[p] = -solv->decisionmap[p]; } - solv->dosplitprovides = 0; /* filter out old supplements */ for (i = j = 0; i < dqs.count; i++) { @@ -2563,7 +2619,6 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) if (s->repo && s->repo != solv->installed) solv->decisionmap[p] = -solv->decisionmap[p]; } - solv->dosplitprovides = dosplitprovides_old; } /* multiversion doesn't mix well with supplements. @@ -2679,13 +2734,10 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) if (!dq.count) continue; if (dq.count > 1) - { - /* multiple candidates, open a branch */ - queue_push(&solv->branches, -dq.elements[0]); - for (i = 1; i < dq.count; i++) - queue_push(&solv->branches, dq.elements[i]); - queue_push(&solv->branches, level); - } + policy_filter_unwanted(solv, &dq, POLICY_MODE_CHOOSE); + /* if we have multiple candidates we open a branch */ + if (dq.count > 1) + createbranch(solv, level, &dq, s - pool->solvables, rec); p = dq.elements[0]; POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p)); olevel = level; @@ -2812,7 +2864,6 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) if (solv->branches.count) { int l, endi = 0; - Id why; p = l = 0; for (i = solv->branches.count - 1; i >= 0; i--) { @@ -2821,6 +2872,7 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) { endi = i + 1; l = p; + i -= 3; /* skip: p data count */ } else if (p > 0) break; @@ -2831,21 +2883,7 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) { while (i > 0 && solv->branches.elements[i - 1] > 0) i--; - p = solv->branches.elements[i]; - solv->branches.elements[i] = -p; - while (i > 0 && solv->branches.elements[i - 1] < 0) - i--; - POOL_DEBUG(SOLV_DEBUG_SOLVER, "branching with %s\n", pool_solvid2str(pool, p)); - queue_empty(&dq); - queue_insertn(&dq, 0, endi - i, solv->branches.elements + i); - level = l; - revert(solv, level); - queue_insertn(&solv->branches, solv->branches.count, dq.count, dq.elements); - /* hack: revert simply sets the count, so we can still access the reverted elements */ - why = -solv->decisionq_why.elements[solv->decisionq_why.count]; - assert(why >= 0); - olevel = level; - level = setpropagatelearn(solv, level, p, disablerules, why); + level = takebranch(solv, i, endi, "branching", disablerules); if (level == 0) break; continue; @@ -2858,82 +2896,51 @@ solver_run_sat(Solver *solv, int disablerules, int doweak) /* auto-minimization step */ if (solv->branches.count) { - int l = 0, lasti = -1, lastsi = -1, endi = 0; - Id why; - p = l = 0; + int endi, lasti = -1, lastiend = -1; if (solv->recommends_index < solv->decisionq.count) policy_update_recommendsmap(solv); - for (i = solv->branches.count - 1; i >= 0; i--) + for (endi = solv->branches.count; endi > 0;) { - p = solv->branches.elements[i]; - if (p > 0 && !l) - { - l = p; - endi = i + 1; - lastsi = -1; - } - else if (p > 0) + int l, lastsi = -1, starti = endi - solv->branches.elements[endi - 2]; + l = solv->branches.elements[endi - 1]; + for (i = starti; i < endi - 4; i++) { - if (solv->decisionmap[p] > l + 1) - lasti = i; - else + p = solv->branches.elements[i]; + if (p <= 0) + continue; + if (solv->decisionmap[p] > l) { - if (MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p)) - { - lastsi = p; - } + lasti = i; + lastiend = endi; + lastsi = -1; + break; } + if (lastsi < 0 && (MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p))) + lastsi = i; } - else if (p < 0) + if (lastsi >= 0) { - l = 0; - if (lastsi >= 0) + /* we have a recommended package that could not be installed */ + /* take it if our current selection is not recommended */ + for (i = starti; i < endi - 4; i++) { - p = -p; - if (solv->decisionmap[p] == l) + p = -solv->branches.elements[i]; + if (p <= 0 || solv->decisionmap[p] != l + 1) + continue; + if (!(MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p))) { - if (!(MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p))) - lasti = lastsi; + lasti = lastsi; + lastiend = endi; + break; } } } + endi = starti; } if (lasti >= 0) { - int starti; - /* find start of branch */ - for (i = lasti; i && solv->branches.elements[i] >= 0; ) - i--; - while (i > 0 && solv->branches.elements[i] < 0) - i--; - starti = i ? i + 1 : 0; -#if 0 - printf("minimization group level %d [%d-%d]:\n", solv->branches.elements[endi - 1], starti, endi); - for (i = starti; i < endi - 1; i++) - printf("%c %c%s\n", i == lasti ? 'x' : ' ', solv->branches.elements[i] >= 0 ? ' ' : '-', pool_solvid2str(pool, solv->branches.elements[i] >= 0 ? solv->branches.elements[i] : -solv->branches.elements[i])); -#endif - l = solv->branches.elements[endi - 1]; - p = solv->branches.elements[lasti]; - solv->branches.elements[lasti] = -p; - POOL_DEBUG(SOLV_DEBUG_SOLVER, "minimizing %d -> %d with %s\n", solv->decisionmap[p], l, pool_solvid2str(pool, p)); minimizationsteps++; - queue_empty(&dq); - for (i = starti; i < endi - 1; i++) - if (solv->branches.elements[i] < 0) - queue_push(&dq, solv->branches.elements[i]); - for (i = starti; i < endi; i++) - if (solv->branches.elements[i] > 0) - queue_push(&dq, solv->branches.elements[i]); - if (dq.elements[dq.count - 2] <= 0) - queue_empty(&dq); - level = l; - revert(solv, level); - queue_insertn(&solv->branches, solv->branches.count, dq.count, dq.elements); - /* hack: revert simply sets the count, so we can still access the reverted elements */ - why = -solv->decisionq_why.elements[solv->decisionq_why.count]; - assert(why >= 0); - olevel = level; - level = setpropagatelearn(solv, level, p, disablerules, why); + level = takebranch(solv, lasti, lastiend, "minimizing", disablerules); if (level == 0) break; continue; /* back to main loop */ @@ -3644,7 +3651,10 @@ solver_solve(Solver *solv, Queue *job) * add rules for suggests, enhances */ oldnrules = solv->nrules; - solver_addpkgrulesforweak(solv, &addedmap); + if (hasdupjob && !solv->updatemap_all && solv->dosplitprovides && solv->installed) + solver_addpkgrulesforweak(solv, &addedmap); + else + solver_addpkgrulesforweak(solv, &addedmap); POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules because of weak dependencies\n", solv->nrules - oldnrules); #ifdef ENABLE_LINKED_PKGS @@ -4886,6 +4896,54 @@ pool_add_userinstalled_jobs(Pool *pool, Queue *q, Queue *job, int flags) } } +int +solver_alternatives_count(Solver *solv) +{ + Id *elements = solv->branches.elements; + int res, count; + for (res = 0, count = solv->branches.count; count; res++) + count -= elements[count - 2]; + return res; +} + +int +solver_get_alternative(Solver *solv, Id alternative, Id *idp, Id *fromp, Id *chosenp, Queue *choices, int *levelp) +{ + int cnt = solver_alternatives_count(solv); + int count = solv->branches.count; + Id *elements = solv->branches.elements; + if (choices) + queue_empty(choices); + if (alternative <= 0 || alternative > cnt) + return 0; + elements += count; + for (; cnt > alternative; cnt--) + elements -= elements[-2]; + if (levelp) + *levelp = elements[-1]; + if (fromp) + *fromp = elements[-4]; + if (idp) + *idp = elements[-3]; + if (chosenp) + { + int i; + *chosenp = 0; + for (i = elements[-2]; i > 4; i--) + { + Id p = -elements[-i]; + if (p > 0 && solv->decisionmap[p] == elements[-1] + 1) + { + *chosenp = p; + break; + } + } + } + if (choices) + queue_insertn(choices, 0, elements[-2] - 4, elements - elements[-2]); + return elements[-4] ? SOLVER_ALTERNATIVE_TYPE_RECOMMENDS : SOLVER_ALTERNATIVE_TYPE_RULE; +} + const char * solver_select2str(Pool *pool, Id select, Id what) { @@ -5025,3 +5083,37 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask) return pool_tmpappend(pool, s, "]", 0); } +const char * +solver_alternative2str(Solver *solv, int type, Id id, Id from) +{ + Pool *pool = solv->pool; + if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS) + { + const char *s = pool_dep2str(pool, id); + return pool_tmpappend(pool, s, ", recommended by ", pool_solvid2str(pool, from)); + } + if (type == SOLVER_ALTERNATIVE_TYPE_RULE) + { + int rtype; + Id depfrom, depto, dep; + char buf[64]; + if (solver_ruleclass(solv, id) == SOLVER_RULE_CHOICE) + id = solver_rule2pkgrule(solv, id); + rtype = solver_ruleinfo(solv, id, &depfrom, &depto, &dep); + if ((rtype & SOLVER_RULE_TYPEMASK) == SOLVER_RULE_JOB) + { + if ((depto & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_PROVIDES) + return pool_dep2str(pool, dep); + return solver_select2str(pool, depto & SOLVER_SELECTMASK, dep); + } + if (rtype == SOLVER_RULE_PKG_REQUIRES) + { + const char *s = pool_dep2str(pool, dep); + return pool_tmpappend(pool, s, ", required by ", pool_solvid2str(pool, depfrom)); + } + sprintf(buf, "Rule #%d", id); + return pool_tmpjoin(pool, buf, 0, 0); + } + return "unknown alternative type"; +} + diff --git a/src/solver.h b/src/solver.h index 2a7f060..1cb9f15 100644 --- a/src/solver.h +++ b/src/solver.h @@ -299,6 +299,10 @@ typedef struct _Solver Solver; #define GET_USERINSTALLED_NAMES (1 << 0) /* package names instead if ids */ #define GET_USERINSTALLED_INVERTED (1 << 1) /* autoinstalled */ +#define SOLVER_ALTERNATIVE_TYPE_RULE 1 +#define SOLVER_ALTERNATIVE_TYPE_RECOMMENDS 2 +#define SOLVER_ALTERNATIVE_TYPE_SUGGESTS 3 + extern Solver *solver_create(Pool *pool); extern void solver_free(Solver *solv); extern int solver_solve(Solver *solv, Queue *job); @@ -320,6 +324,8 @@ extern void pool_add_userinstalled_jobs(Pool *pool, Queue *q, Queue *job, int fl extern int solver_describe_decision(Solver *solv, Id p, Id *infop); extern void solver_describe_weakdep_decision(Solver *solv, Id p, Queue *whyq); +extern int solver_alternatives_count(Solver *solv); +extern int solver_get_alternative(Solver *solv, Id alternative, Id *idp, Id *fromp, Id *chosenp, Queue *choices, int *levelp); extern void solver_calculate_multiversionmap(Pool *pool, Queue *job, Map *multiversionmap); extern void solver_calculate_noobsmap(Pool *pool, Queue *job, Map *multiversionmap); /* obsolete */ @@ -334,6 +340,8 @@ extern int pool_isemptyupdatejob(Pool *pool, Id how, Id what); extern const char *solver_select2str(Pool *pool, Id select, Id what); extern const char *pool_job2str(Pool *pool, Id how, Id what, Id flagmask); +extern const char *solver_alternative2str(Solver *solv, int type, Id id, Id from); + /* iterate over all literals of a rule */ #define FOR_RULELITERALS(l, pp, r) \ diff --git a/src/solver_private.h b/src/solver_private.h index 170efc2..f30b03a 100644 --- a/src/solver_private.h +++ b/src/solver_private.h @@ -17,7 +17,7 @@ extern void solver_run_sat(Solver *solv, int disablerules, int doweak); extern void solver_reset(Solver *solv); extern int solver_dep_installed(Solver *solv, Id dep); -extern int solver_splitprovides(Solver *solv, Id dep); +extern int solver_splitprovides(Solver *solv, Id dep, Map *m); static inline int solver_dep_fulfilled(Solver *solv, Id dep) @@ -41,7 +41,7 @@ solver_dep_fulfilled(Solver *solv, Id dep) return solver_dep_fulfilled(solv, rd->evr); } if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES) - return solver_splitprovides(solv, rd->evr); + return solver_splitprovides(solv, rd->evr, 0); if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED) return solver_dep_installed(solv, rd->evr); } diff --git a/test/testcases/choose/default.t b/test/testcases/choose/default.t new file mode 100644 index 0000000..bb5b9f4 --- /dev/null +++ b/test/testcases/choose/default.t @@ -0,0 +1,13 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Pkg: B 1 1 noarch +#>=Prv: Y +#>=Pkg: A 1 1 noarch +#>=Prv: Y +system i686 rpm system +job install name X +result transaction,problems +#>install A-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/choose/enhanced.t b/test/testcases/choose/enhanced.t new file mode 100644 index 0000000..da6cfd5 --- /dev/null +++ b/test/testcases/choose/enhanced.t @@ -0,0 +1,14 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Pkg: B 1 1 noarch +#>=Prv: Y +#>=Enh: X +#>=Pkg: A 1 1 noarch +#>=Prv: Y +system i686 rpm system +job install name X +result transaction,problems +#>install B-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/choose/oldversion.t b/test/testcases/choose/oldversion.t new file mode 100644 index 0000000..d83e2b6 --- /dev/null +++ b/test/testcases/choose/oldversion.t @@ -0,0 +1,16 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Pkg: B 1 1 noarch +#>=Prv: Y +#>=Pkg: C 1 1 noarch +#>=Prv: Y +#>=Pkg: A 1 1 noarch +#>=Prv: Y +#>=Pkg: A 2 1 noarch +system i686 rpm system +job install name X +result transaction,problems +#>install B-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/choose/suggested.t b/test/testcases/choose/suggested.t new file mode 100644 index 0000000..cad4742 --- /dev/null +++ b/test/testcases/choose/suggested.t @@ -0,0 +1,14 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Sug: B +#>=Pkg: B 1 1 noarch +#>=Prv: Y +#>=Pkg: A 1 1 noarch +#>=Prv: Y +system i686 rpm system +job install name X +result transaction,problems +#>install B-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/choose/versioned.t b/test/testcases/choose/versioned.t new file mode 100644 index 0000000..d5089c8 --- /dev/null +++ b/test/testcases/choose/versioned.t @@ -0,0 +1,15 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Pkg: B 1 1 noarch +#>=Prv: Y = 2 +#>=Pkg: C 1 1 noarch +#>=Prv: Y = 1.1 +#>=Pkg: A 1 1 noarch +#>=Prv: Y = 1 +system i686 rpm system +job install name X +result transaction,problems +#>install B-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/choose/versioned2.t b/test/testcases/choose/versioned2.t new file mode 100644 index 0000000..99c5712 --- /dev/null +++ b/test/testcases/choose/versioned2.t @@ -0,0 +1,15 @@ +repo system 0 empty +repo test 0 testtags +#>=Pkg: X 1 1 noarch +#>=Req: Y +#>=Pkg: B 1 1 noarch +#>=Prv: Y < 2 +#>=Pkg: C 1 1 noarch +#>=Prv: Y <= 2 +#>=Pkg: A 1 1 noarch +#>=Prv: Y = 1 +system i686 rpm system +job install name X +result transaction,problems +#>install C-1-1.noarch@test +#>install X-1-1.noarch@test diff --git a/test/testcases/namespace/namespaceprovides.t b/test/testcases/namespace/namespaceprovides.t index 1dc8872..62ca982 100644 --- a/test/testcases/namespace/namespaceprovides.t +++ b/test/testcases/namespace/namespaceprovides.t @@ -1,8 +1,10 @@ repo system 0 testtags +#>=Ver: 2 #>=Pkg: B 1 1 noarch #>=Prv: locale(en) #>=Pkg: C 1 1 noarch repo test 0 testtags +#>=Ver: 2 #>=Pkg: A 1 1 noarch #>=Prv: locale(de) #>=Pkg: C-de 1 1 noarch -- 2.7.4