X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Frepo.c;h=da4021908046fc881be6021e855b94fcd9da80ff;hb=18ebbaf4f619e79231f5ad18a2ab8c135d22ef56;hp=55e9fd880894a20238818964c1f30dc4e20d32bd;hpb=1414c61996bba1f0b181a4e2bfbce892d0022d8b;p=platform%2Fupstream%2Flibsolv.git diff --git a/src/repo.c b/src/repo.c index 55e9fd8..da40219 100644 --- a/src/repo.c +++ b/src/repo.c @@ -41,11 +41,18 @@ repo_create(Pool *pool, const char *name) Repo *repo; pool_freewhatprovides(pool); - repo = (Repo *)sat_calloc(1, sizeof(*repo)); - pool->repos = (Repo **)sat_realloc2(pool->repos, pool->nrepos + 1, sizeof(Repo *)); - pool->repos[pool->nrepos++] = repo; - repo->repoid = pool->nrepos; - repo->name = name ? strdup(name) : 0; + repo = (Repo *)solv_calloc(1, sizeof(*repo)); + if (!pool->nrepos) + { + pool->nrepos = 1; /* start with repoid 1 */ + pool->repos = (Repo **)solv_calloc(2, sizeof(Repo *)); + } + else + pool->repos = (Repo **)solv_realloc2(pool->repos, pool->nrepos + 1, sizeof(Repo *)); + pool->repos[pool->nrepos] = repo; + pool->urepos++; + repo->repoid = pool->nrepos++; + repo->name = name ? solv_strdup(name) : 0; repo->pool = pool; repo->start = pool->nsolvables; repo->end = pool->nsolvables; @@ -53,17 +60,18 @@ repo_create(Pool *pool, const char *name) return repo; } -static void +void repo_freedata(Repo *repo) { int i; - for (i = 0; i < repo->nrepodata; i++) + for (i = 1; i < repo->nrepodata; i++) repodata_freedata(repo->repodata + i); - sat_free(repo->repodata); - sat_free(repo->idarraydata); - sat_free(repo->rpmdbid); - sat_free((char *)repo->name); - sat_free(repo); + solv_free(repo->repodata); + solv_free(repo->idarraydata); + solv_free(repo->rpmdbid); + solv_free(repo->lastidhash); + solv_free((char *)repo->name); + solv_free(repo); } /* delete all solvables and repodata blocks from this repo */ @@ -84,21 +92,23 @@ repo_empty(Repo *repo, int reuseids) if (s->repo != repo) break; pool_free_solvable_block(pool, i + 1, repo->end - (i + 1), reuseids); + repo->end = i + 1; } /* zero out (i.e. free) solvables belonging to this repo */ for (i = repo->start, s = pool->solvables + i; i < repo->end; i++, s++) if (s->repo == repo) memset(s, 0, sizeof(*s)); + repo->end = repo->start; repo->nsolvables = 0; /* free all data belonging to this repo */ - repo->idarraydata = sat_free(repo->idarraydata); + repo->idarraydata = solv_free(repo->idarraydata); repo->idarraysize = 0; repo->lastoff = 0; - repo->rpmdbid = sat_free(repo->rpmdbid); - for (i = 0; i < repo->nrepodata; i++) + repo->rpmdbid = solv_free(repo->rpmdbid); + for (i = 1; i < repo->nrepodata; i++) repodata_freedata(repo->repodata + i); - sat_free(repo->repodata); + solv_free(repo->repodata); repo->repodata = 0; repo->nrepodata = 0; } @@ -117,44 +127,28 @@ repo_free(Repo *repo, int reuseids) if (repo == pool->installed) pool->installed = 0; repo_empty(repo, reuseids); - for (i = 0; i < pool->nrepos; i++) /* find repo in pool */ + for (i = 1; i < pool->nrepos; i++) /* find repo in pool */ if (pool->repos[i] == repo) break; if (i == pool->nrepos) /* repo not in pool, return */ return; - if (i < pool->nrepos - 1) - { - memmove(pool->repos + i, pool->repos + i + 1, (pool->nrepos - 1 - i) * sizeof(Repo *)); - /* fix repo ids */ - for (; i < pool->nrepos - 1; i++) - pool->repos[i]->repoid = i + 1; - } - pool->nrepos--; + if (i == pool->nrepos - 1 && reuseids) + pool->nrepos--; + else + pool->repos[i] = 0; + pool->urepos--; repo_freedata(repo); } -void -repo_freeallrepos(Pool *pool, int reuseids) -{ - int i; - - pool_freewhatprovides(pool); - for (i = 0; i < pool->nrepos; i++) - repo_freedata(pool->repos[i]); - pool->repos = sat_free(pool->repos); - pool->nrepos = 0; - /* the first two solvables don't belong to a repo */ - pool_free_solvable_block(pool, 2, pool->nsolvables - 2, reuseids); -} - -Id repo_add_solvable(Repo *repo) +Id +repo_add_solvable(Repo *repo) { Id p = pool_add_solvable(repo->pool); if (!repo->start || repo->start == repo->end) repo->start = repo->end = p; /* warning: sidedata must be extended before adapting start/end */ if (repo->rpmdbid) - repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1); + repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, 1); if (p < repo->start) repo->start = p; if (p + 1 > repo->end) @@ -164,10 +158,11 @@ Id repo_add_solvable(Repo *repo) return p; } -Id repo_add_solvable_block(Repo *repo, int count) +Id +repo_add_solvable_block(Repo *repo, int count) { Id p; - Solvable *s; + Solvable *s; if (!count) return 0; p = pool_add_solvable_block(repo->pool, count); @@ -186,12 +181,14 @@ Id repo_add_solvable_block(Repo *repo, int count) return p; } -void repo_free_solvable(Repo *repo, Id p, int reuseids) +void +repo_free_solvable(Repo *repo, Id p, int reuseids) { repo_free_solvable_block(repo, p, 1, reuseids); } -void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids) +void +repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids) { Solvable *s; Repodata *data; @@ -202,9 +199,73 @@ void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids) for (s = repo->pool->solvables + start, i = count; i--; s++) s->repo = 0; pool_free_solvable_block(repo->pool, start, count, reuseids); - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - if (data->end > repo->end) - repodata_shrink(data, repo->end); + FOR_REPODATAS(repo, i, data) + { + int dstart, dend; + if (data->end > repo->end) + repodata_shrink(data, repo->end); + dstart = data->start > start ? data->start : start; + dend = data->end < start + count ? data->end : start + count; + if (dstart < dend) + { + if (data->attrs) + { + int j; + for (j = dstart; j < dend; j++) + data->attrs[j - data->start] = solv_free(data->attrs[j - data->start]); + } + if (data->incoreoffset) + memset(data->incoreoffset + (dstart - data->start), 0, (dend - dstart) * sizeof(Id)); + } + } +} + +/* specialized version of repo_add_solvable_block that inserts the new solvable + * block before the indicated repo, which gets relocated. + * used in repo_add_rpmdb + */ +Id +repo_add_solvable_block_before(Repo *repo, int count, Repo *beforerepo) +{ + Pool *pool = repo->pool; + Id p; + Solvable *s; + Repodata *data; + int i; + + if (!count || !beforerepo || beforerepo->end != pool->nsolvables || beforerepo->start == beforerepo->end) + return repo_add_solvable_block(repo, count); + p = beforerepo->start; + /* make sure all solvables belong to beforerepo */ + for (i = p, s = pool->solvables + i; i < beforerepo->end; i++, s++) + if (s->repo && s->repo != beforerepo) + return repo_add_solvable_block(repo, count); + /* now move beforerepo to back */ + pool_add_solvable_block(pool, count); /* must return beforerepo->end! */ + memmove(pool->solvables + p + count, pool->solvables + p, (beforerepo->end - p) * sizeof(Solvable)); + memset(pool->solvables + p, 0, sizeof(Solvable) * count); + /* adapt repodata */ + FOR_REPODATAS(beforerepo, i, data) + { + if (data->start < p) + continue; + data->start += count; + data->end += count; + } + beforerepo->start += count; + beforerepo->end += count; + /* we now have count free solvables at id p */ + /* warning: sidedata must be extended before adapting start/end */ + if (repo->rpmdbid) + repo->rpmdbid = (Id *)repo_sidedata_extend(repo, repo->rpmdbid, sizeof(Id), p, count); + if (p < repo->start) + repo->start = p; + if (p + count > repo->end) + repo->end = p + count; + repo->nsolvables += count; + for (s = pool->solvables + p; count--; s++) + s->repo = repo; + return p; } @@ -220,7 +281,7 @@ void repo_free_solvable_block(Repo *repo, Id start, int count, int reuseids) void * repo_sidedata_create(Repo *repo, size_t size) { - return sat_calloc_block(repo->end - repo->start, size, REPO_SIDEDATA_BLOCK); + return solv_calloc_block(repo->end - repo->start, size, REPO_SIDEDATA_BLOCK); } void * @@ -230,7 +291,7 @@ repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count) if (p < repo->start) { int d = repo->start - p; - b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); + b = solv_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); memmove((char *)b + d * size, b, n * size); memset(b, 0, d * size); n += d; @@ -238,7 +299,7 @@ repo_sidedata_extend(Repo *repo, void *b, size_t size, Id p, int count) if (p + count > repo->end) { int d = p + count - repo->end; - b = sat_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); + b = solv_extend(b, n, d, size, REPO_SIDEDATA_BLOCK); memset((char *)b + n * size, 0, d * size); } return b; @@ -263,7 +324,7 @@ repo_addid(Repo *repo, Offset olddeps, Id id) if (!idarray) /* alloc idarray if not done yet */ { idarraysize = 1; - idarray = sat_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK); + idarray = solv_extend_resize(0, 1, sizeof(Id), IDARRAY_BLOCK); idarray[0] = 0; repo->lastoff = 0; } @@ -271,7 +332,7 @@ repo_addid(Repo *repo, Offset olddeps, Id id) if (!olddeps) /* no deps yet */ { olddeps = idarraysize; - idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); + idarray = solv_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); } else if (olddeps == repo->lastoff) /* extend at end */ idarraysize--; @@ -281,14 +342,14 @@ repo_addid(Repo *repo, Offset olddeps, Id id) olddeps = idarraysize; for (; idarray[i]; i++) { - idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); + idarray = solv_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); idarray[idarraysize++] = idarray[i]; } - idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); + idarray = solv_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); } idarray[idarraysize++] = id; /* insert Id into array */ - idarray = sat_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); + idarray = solv_extend(idarray, idarraysize, 1, sizeof(Id), IDARRAY_BLOCK); idarray[idarraysize++] = 0; /* ensure NULL termination */ repo->idarraydata = idarray; @@ -298,13 +359,140 @@ repo_addid(Repo *repo, Offset olddeps, Id id) return olddeps; } +#define REPO_ADDID_DEP_HASHTHRES 64 +#define REPO_ADDID_DEP_HASHMIN 128 + +/* + * Optimization for packages with an excessive amount of provides/requires: + * if the number of deps exceed a threshold, we build a hash of the already + * seen ids. + */ +static Offset +repo_addid_dep_hash(Repo *repo, Offset olddeps, Id id, Id marker, int size) +{ + Id oid, *oidp; + int before; + Hashval h, hh; + Id hid; + + before = 0; + if (marker) + { + if (marker < 0) + { + marker = -marker; + before = 1; + } + if (marker == id) + marker = 0; + } + + /* maintain hash and lastmarkerpos */ + if (repo->lastidhash_idarraysize != repo->idarraysize || (Hashval)size * 2 > repo->lastidhash_mask || repo->lastmarker != marker) + { + repo->lastmarkerpos = 0; + if ((Hashval)size * 2 > repo->lastidhash_mask) + { + repo->lastidhash_mask = mkmask(size < REPO_ADDID_DEP_HASHMIN ? REPO_ADDID_DEP_HASHMIN : size); + repo->lastidhash = solv_realloc2(repo->lastidhash, repo->lastidhash_mask + 1, sizeof(Id)); + } + memset(repo->lastidhash, 0, (repo->lastidhash_mask + 1) * sizeof(Id)); + for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != 0; oidp++) + { + h = oid & repo->lastidhash_mask; + hh = HASHCHAIN_START; + while (repo->lastidhash[h] != 0) + h = HASHCHAIN_NEXT(h, hh, repo->lastidhash_mask); + repo->lastidhash[h] = oid; + if (marker && oid == marker) + repo->lastmarkerpos = oidp - repo->idarraydata; + } + repo->lastmarker = marker; + repo->lastidhash_idarraysize = repo->idarraysize; + } + + /* check the hash! */ + h = id & repo->lastidhash_mask; + hh = HASHCHAIN_START; + while ((hid = repo->lastidhash[h]) != 0 && hid != id) + h = HASHCHAIN_NEXT(h, hh, repo->lastidhash_mask); + /* put new element in hash */ + if (!hid) + repo->lastidhash[h] = id; + else if (marker == SOLVABLE_FILEMARKER && (!before || !repo->lastmarkerpos)) + return olddeps; + if (marker && !before && !repo->lastmarkerpos) + { + /* we have to add the marker first */ + repo->lastmarkerpos = repo->idarraysize - 1; + olddeps = repo_addid(repo, olddeps, marker); + /* now put marker in hash */ + h = marker & repo->lastidhash_mask; + hh = HASHCHAIN_START; + while (repo->lastidhash[h] != 0) + h = HASHCHAIN_NEXT(h, hh, repo->lastidhash_mask); + repo->lastidhash[h] = marker; + repo->lastidhash_idarraysize = repo->idarraysize; + } + if (!hid) + { + /* new entry, insert in correct position */ + if (marker && before && repo->lastmarkerpos) + { + /* need to add it before the marker */ + olddeps = repo_addid(repo, olddeps, id); /* dummy to make room */ + memmove(repo->idarraydata + repo->lastmarkerpos + 1, repo->idarraydata + repo->lastmarkerpos, (repo->idarraysize - repo->lastmarkerpos - 2) * sizeof(Id)); + repo->idarraydata[repo->lastmarkerpos++] = id; + } + else + { + /* just append it to the end */ + olddeps = repo_addid(repo, olddeps, id); + } + repo->lastidhash_idarraysize = repo->idarraysize; + return olddeps; + } + /* we already have it in the hash */ + if (!marker) + return olddeps; + if (marker == SOLVABLE_FILEMARKER) + { + /* check if it is in the wrong half */ + /* (we already made sure that "before" and "lastmarkerpos" are set, see above) */ + for (oidp = repo->idarraydata + repo->lastmarkerpos + 1; (oid = *oidp) != 0; oidp++) + if (oid == id) + break; + if (!oid) + return olddeps; + /* yes, wrong half. copy it over */ + memmove(repo->idarraydata + repo->lastmarkerpos + 1, repo->idarraydata + repo->lastmarkerpos, (oidp - (repo->idarraydata + repo->lastmarkerpos)) * sizeof(Id)); + repo->idarraydata[repo->lastmarkerpos++] = id; + return olddeps; + } + if (before) + return olddeps; + /* check if it is in the correct half */ + for (oidp = repo->idarraydata + repo->lastmarkerpos + 1; (oid = *oidp) != 0; oidp++) + if (oid == id) + return olddeps; + /* nope, copy it over */ + for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != 0; oidp++) + if (oid == id) + break; + if (!oid) + return olddeps; /* should not happen */ + memmove(oidp, oidp + 1, (repo->idarraydata + repo->idarraysize - oidp - 2) * sizeof(Id)); + repo->idarraydata[repo->idarraysize - 2] = id; + repo->lastmarkerpos--; /* marker has been moved */ + return olddeps; +} /* * add dependency (as Id) to repo, also unifies dependencies * olddeps = offset into idarraydata * marker= 0 for normal dep * marker > 0 add dep after marker - * marker < 0 add dep after -marker + * marker < 0 add dep before -marker * returns new start of dependency array */ Offset @@ -320,24 +508,36 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker) return repo_addid(repo, olddeps, id); } - if (!marker) + /* check if we should use the hash optimization */ + if (olddeps == repo->lastoff) { - for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++) + int size = repo->idarraysize - 1 - repo->lastoff; + if (size >= REPO_ADDID_DEP_HASHTHRES) + return repo_addid_dep_hash(repo, olddeps, id, marker, size); + } + + before = 0; + if (marker) + { + if (marker < 0) { - if (oid == id) - return olddeps; + marker = -marker; + before = 1; } - return repo_addid(repo, olddeps, id); + if (marker == id) + marker = 0; } - before = 0; - markerp = 0; - if (marker < 0) + if (!marker) { - before = 1; - marker = -marker; + for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != 0; oidp++) + if (oid == id) + return olddeps; + return repo_addid(repo, olddeps, id); } - for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != ID_NULL; oidp++) + + markerp = 0; + for (oidp = repo->idarraydata + olddeps; (oid = *oidp) != 0; oidp++) { if (oid == marker) markerp = oidp; @@ -347,11 +547,20 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker) if (oid) { + if (marker == SOLVABLE_FILEMARKER) + { + if (!markerp || !before) + return olddeps; + /* we found it, but in the second half */ + memmove(markerp + 1, markerp, (oidp - markerp) * sizeof(Id)); + *markerp = id; + return olddeps; + } if (markerp || before) return olddeps; - /* we found it, but in the wrong half */ + /* we found it, but in the first half */ markerp = oidp++; - for (; (oid = *oidp) != ID_NULL; oidp++) + for (; (oid = *oidp) != 0; oidp++) if (oid == marker) break; if (!oid) @@ -383,6 +592,20 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker) return repo_addid(repo, olddeps, id); } +/* return standard marker for the keyname dependency. + * 1: return positive marker, -1: return negative marker + */ +Id +solv_depmarker(Id keyname, Id marker) +{ + if (marker != 1 && marker != -1) + return marker; + if (keyname == SOLVABLE_PROVIDES) + return marker < 0 ? -SOLVABLE_FILEMARKER : SOLVABLE_FILEMARKER; + if (keyname == SOLVABLE_REQUIRES) + return marker < 0 ? -SOLVABLE_PREREQMARKER : SOLVABLE_PREREQMARKER; + return 0; +} /* * reserve Ids @@ -391,7 +614,6 @@ repo_addid_dep(Repo *repo, Offset olddeps, Id id, Id marker) * * reserved ids will always begin at offset idarraysize */ - Offset repo_reserve_ids(Repo *repo, Offset olddeps, int num) { @@ -400,7 +622,7 @@ repo_reserve_ids(Repo *repo, Offset olddeps, int num) if (!repo->idarraysize) /* ensure buffer space */ { repo->idarraysize = 1; - repo->idarraydata = sat_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK); + repo->idarraydata = solv_extend_resize(0, 1 + num, sizeof(Id), IDARRAY_BLOCK); repo->idarraydata[0] = 0; repo->lastoff = 1; return 1; @@ -420,7 +642,7 @@ repo_reserve_ids(Repo *repo, Offset olddeps, int num) ; count = idend - idstart - 1 + num; /* new size */ - repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK); + repo->idarraydata = solv_extend(repo->idarraydata, repo->idarraysize, count, sizeof(Id), IDARRAY_BLOCK); /* move old deps to end */ olddeps = repo->lastoff = repo->idarraysize; memcpy(repo->idarraydata + olddeps, idstart, count - num); @@ -433,7 +655,7 @@ repo_reserve_ids(Repo *repo, Offset olddeps, int num) repo->idarraysize--; /* make room*/ - repo->idarraydata = sat_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK); + repo->idarraydata = solv_extend(repo->idarraydata, repo->idarraysize, num, sizeof(Id), IDARRAY_BLOCK); /* appending or new */ repo->lastoff = olddeps ? olddeps : repo->idarraysize; @@ -442,227 +664,7 @@ repo_reserve_ids(Repo *repo, Offset olddeps, int num) } - -Offset -repo_fix_supplements(Repo *repo, Offset provides, Offset supplements, Offset freshens) -{ - Pool *pool = repo->pool; - Id id, idp, idl; - char buf[1024], *p, *dep; - int i, l; - - if (provides) - { - for (i = provides; repo->idarraydata[i]; i++) - { - id = repo->idarraydata[i]; - if (ISRELDEP(id)) - continue; - dep = (char *)pool_id2str(pool, id); - if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2) - { - idp = 0; - strcpy(buf + 2, dep); - dep = buf + 2 + 7; - if ((p = strchr(dep, ':')) != 0 && p != dep) - { - *p++ = 0; - idp = pool_str2id(pool, dep, 1); - dep = p; - } - id = 0; - while ((p = strchr(dep, ';')) != 0) - { - if (p == dep) - { - dep = p + 1; - continue; - } - *p++ = 0; -#if 0 - strncpy(dep - 9, "language:", 9); - idl = pool_str2id(pool, dep - 9, 1); -#else - idl = pool_str2id(pool, dep, 1); - idl = pool_rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1); -#endif - if (id) - id = pool_rel2id(pool, id, idl, REL_OR, 1); - else - id = idl; - dep = p; - } - if (dep[0] && dep[1]) - { - for (p = dep; *p && *p != ')'; p++) - ; - *p = 0; -#if 0 - strncpy(dep - 9, "language:", 9); - idl = pool_str2id(pool, dep - 9, 1); -#else - idl = pool_str2id(pool, dep, 1); - idl = pool_rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1); -#endif - if (id) - id = pool_rel2id(pool, id, idl, REL_OR, 1); - else - id = idl; - } - if (idp) - id = pool_rel2id(pool, idp, id, REL_AND, 1); - if (id) - supplements = repo_addid_dep(repo, supplements, id, 0); - } - else if ((p = strchr(dep, ':')) != 0 && p != dep && p[1] == '/' && strlen(dep) < sizeof(buf)) - { - strcpy(buf, dep); - p = buf + (p - dep); - *p++ = 0; - idp = pool_str2id(pool, buf, 1); - /* strip trailing slashes */ - l = strlen(p); - while (l > 1 && p[l - 1] == '/') - p[--l] = 0; - id = pool_str2id(pool, p, 1); - id = pool_rel2id(pool, idp, id, REL_WITH, 1); - id = pool_rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1); - supplements = repo_addid_dep(repo, supplements, id, 0); - } - } - } - if (supplements) - { - for (i = supplements; repo->idarraydata[i]; i++) - { - id = repo->idarraydata[i]; - if (ISRELDEP(id)) - continue; - dep = (char *)pool_id2str(pool, id); - if (!strncmp(dep, "system:modalias(", 16)) - dep += 7; - if (!strncmp(dep, "modalias(", 9) && dep[9] && dep[10] && strlen(dep) < sizeof(buf)) - { - strcpy(buf, dep); - p = strchr(buf + 9, ':'); - if (p && p != buf + 9 && strchr(p + 1, ':')) - { - *p++ = 0; - idp = pool_str2id(pool, buf + 9, 1); - p[strlen(p) - 1] = 0; - id = pool_str2id(pool, p, 1); - id = pool_rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1); - id = pool_rel2id(pool, idp, id, REL_AND, 1); - } - else - { - p = buf + 9; - p[strlen(p) - 1] = 0; - id = pool_str2id(pool, p, 1); - id = pool_rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1); - } - if (id) - repo->idarraydata[i] = id; - } - else if (!strncmp(dep, "packageand(", 11) && strlen(dep) < sizeof(buf)) - { - strcpy(buf, dep); - id = 0; - dep = buf + 11; - while ((p = strchr(dep, ':')) != 0) - { - if (p == dep) - { - dep = p + 1; - continue; - } - *p++ = 0; - idp = pool_str2id(pool, dep, 1); - if (id) - id = pool_rel2id(pool, id, idp, REL_AND, 1); - else - id = idp; - dep = p; - } - if (dep[0] && dep[1]) - { - dep[strlen(dep) - 1] = 0; - idp = pool_str2id(pool, dep, 1); - if (id) - id = pool_rel2id(pool, id, idp, REL_AND, 1); - else - id = idp; - } - if (id) - repo->idarraydata[i] = id; - } - else if (!strncmp(dep, "filesystem(", 11) && strlen(dep) < sizeof(buf)) - { - strcpy(buf, dep + 11); - if ((p = strrchr(buf, ')')) != 0) - *p = 0; - id = pool_str2id(pool, buf, 1); - id = pool_rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1); - repo->idarraydata[i] = id; - } - } - } - if (freshens && repo->idarraydata[freshens]) - { - Id idsupp = 0, idfresh = 0; - if (!supplements) - return freshens; - for (i = supplements; repo->idarraydata[i]; i++) - { - if (!idsupp) - idsupp = repo->idarraydata[i]; - else - idsupp = pool_rel2id(pool, idsupp, repo->idarraydata[i], REL_OR, 1); - } - for (i = freshens; repo->idarraydata[i]; i++) - { - if (!idfresh) - idfresh = repo->idarraydata[i]; - else - idfresh = pool_rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1); - } - if (!idsupp) - idsupp = idfresh; - else - idsupp = pool_rel2id(pool, idsupp, idfresh, REL_AND, 1); - supplements = repo_addid_dep(repo, 0, idsupp, 0); - } - return supplements; -} - -Offset -repo_fix_conflicts(Repo *repo, Offset conflicts) -{ - char buf[1024], *p, *dep; - Pool *pool = repo->pool; - Id id; - int i; - - if (!conflicts) - return conflicts; - for (i = conflicts; repo->idarraydata[i]; i++) - { - id = repo->idarraydata[i]; - if (ISRELDEP(id)) - continue; - dep = (char *)pool_id2str(pool, id); - if (!strncmp(dep, "otherproviders(", 15) && strlen(dep) < sizeof(buf) - 2) - { - strcpy(buf, dep + 15); - if ((p = strchr(buf, ')')) != 0) - *p = 0; - id = pool_str2id(pool, buf, 1); - id = pool_rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1); - repo->idarraydata[i] = id; - } - } - return conflicts; -} +/***********************************************************************/ struct matchdata { @@ -670,28 +672,41 @@ struct matchdata int flags; Datamatcher matcher; int stop; + Id *keyskip; int (*callback)(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv); void *callback_data; }; -int +static int repo_matchvalue(void *cbdata, Solvable *s, Repodata *data, Repokey *key, KeyValue *kv) { struct matchdata *md = cbdata; if (md->matcher.match) { - if (!repodata_stringify(md->pool, data, key, kv, md->flags)) + const char *str; + if (key->name == SOLVABLE_FILELIST && key->type == REPOKEY_TYPE_DIRSTRARRAY && (md->matcher.flags & SEARCH_FILES) != 0) + if (!datamatcher_checkbasename(&md->matcher, kv->str)) + return 0; + if (!(str = repodata_stringify(md->pool, data, key, kv, md->flags))) return 0; - if (!datamatcher_match(&md->matcher, kv->str)) + if (!datamatcher_match(&md->matcher, str)) return 0; } + else + { + /* stringify filelist if requested */ + if (key->name == SOLVABLE_FILELIST && key->type == REPOKEY_TYPE_DIRSTRARRAY && (md->matcher.flags & SEARCH_FILES) != 0) + repodata_stringify(md->pool, data, key, kv, md->flags); + } md->stop = md->callback(md->callback_data, s, data, key, kv); return md->stop; } -static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = { +/* list of all keys we store in the solvable */ +/* also used in the dataiterator code in repodata.c */ +Repokey repo_solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = { { SOLVABLE_NAME, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, { SOLVABLE_ARCH, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, { SOLVABLE_EVR, REPOKEY_TYPE_ID, 0, KEY_STORAGE_SOLVABLE }, @@ -704,7 +719,7 @@ static Repokey solvablekeys[RPM_RPMDBID - SOLVABLE_NAME + 1] = { { SOLVABLE_SUGGESTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, { SOLVABLE_SUPPLEMENTS, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, { SOLVABLE_ENHANCES, REPOKEY_TYPE_IDARRAY, 0, KEY_STORAGE_SOLVABLE }, - { RPM_RPMDBID, REPOKEY_TYPE_U32, 0, KEY_STORAGE_SOLVABLE }, + { RPM_RPMDBID, REPOKEY_TYPE_NUM, 0, KEY_STORAGE_SOLVABLE }, }; static void @@ -717,7 +732,7 @@ domatch_idarray(Solvable *s, Id keyname, struct matchdata *md, Id *ida) { kv.id = *ida; kv.eof = ida[1] ? 0 : 1; - repo_matchvalue(md, s, 0, solvablekeys + (keyname - SOLVABLE_NAME), &kv); + repo_matchvalue(md, s, 0, repo_solvablekeys + (keyname - SOLVABLE_NAME), &kv); kv.entry++; } } @@ -728,8 +743,9 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) KeyValue kv; Pool *pool = repo->pool; Repodata *data; - int i, j, flags; + int i, flags; Solvable *s; + Id *keyskip; kv.parent = 0; md->stop = 0; @@ -744,12 +760,10 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) } return; } - else if (p < 0) - /* The callback only supports solvables, so we can't iterate over the - extra things. */ - return; + if (p < 0 && p != SOLVID_META) + return; /* SOLVID_POS not supported yet */ flags = md->flags; - if (!(flags & SEARCH_NO_STORAGE_SOLVABLE)) + if (p > 0 && !(flags & SEARCH_NO_STORAGE_SOLVABLE)) { s = pool->solvables + p; switch(keyname) @@ -759,7 +773,7 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) if (s->name) { kv.id = s->name; - repo_matchvalue(md, s, 0, solvablekeys + 0, &kv); + repo_matchvalue(md, s, 0, repo_solvablekeys + 0, &kv); } if (keyname || md->stop > SEARCH_NEXT_KEY) return; @@ -767,7 +781,7 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) if (s->arch) { kv.id = s->arch; - repo_matchvalue(md, s, 0, solvablekeys + 1, &kv); + repo_matchvalue(md, s, 0, repo_solvablekeys + 1, &kv); } if (keyname || md->stop > SEARCH_NEXT_KEY) return; @@ -775,7 +789,7 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) if (s->evr) { kv.id = s->evr; - repo_matchvalue(md, s, 0, solvablekeys + 2, &kv); + repo_matchvalue(md, s, 0, repo_solvablekeys + 2, &kv); } if (keyname || md->stop > SEARCH_NEXT_KEY) return; @@ -783,7 +797,7 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) if (s->vendor) { kv.id = s->vendor; - repo_matchvalue(md, s, 0, solvablekeys + 3, &kv); + repo_matchvalue(md, s, 0, repo_solvablekeys + 3, &kv); } if (keyname || md->stop > SEARCH_NEXT_KEY) return; @@ -830,8 +844,9 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) case RPM_RPMDBID: if (repo->rpmdbid) { - kv.num = repo->rpmdbid[p - repo->start]; - repo_matchvalue(md, s, 0, solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv); + kv.num = (unsigned int)repo->rpmdbid[p - repo->start]; + kv.num2 = 0; + repo_matchvalue(md, s, 0, repo_solvablekeys + (RPM_RPMDBID - SOLVABLE_NAME), &kv); } if (keyname || md->stop > SEARCH_NEXT_KEY) return; @@ -841,42 +856,23 @@ repo_search_md(Repo *repo, Id p, Id keyname, struct matchdata *md) } } - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + if (keyname) { - if (p < data->start || p >= data->end) - continue; - if (keyname && !repodata_precheck_keyname(data, keyname)) - continue; - if (keyname == SOLVABLE_FILELIST && !(md->flags & SEARCH_COMPLETE_FILELIST)) - { - /* do not search filelist extensions */ - if (data->state != REPODATA_AVAILABLE) - continue; - for (j = 1; j < data->nkeys; j++) - if (data->keys[j].name != REPOSITORY_SOLVABLES && data->keys[j].name != SOLVABLE_FILELIST) - break; - if (j == data->nkeys) - continue; - } - if (data->state == REPODATA_STUB) - { - if (keyname) - { - for (j = 1; j < data->nkeys; j++) - if (keyname == data->keys[j].name) - break; - if (j == data->nkeys) - continue; - } - /* load it */ - if (data->loadcallback) - data->loadcallback(data); - else - data->state = REPODATA_ERROR; - } - if (data->state == REPODATA_ERROR) + if (keyname == SOLVABLE_FILELIST) + data = repo_lookup_filelist_repodata(repo, p, &md->matcher); + else + data = repo_lookup_repodata_opt(repo, p, keyname); + if (data) + repodata_search(data, p, keyname, md->flags, repo_matchvalue, md); + return; + } + + keyskip = repo_create_keyskip(repo, p, &md->keyskip); + FOR_REPODATAS(repo, i, data) + { + if (p != SOLVID_META && (p < data->start || p >= data->end)) continue; - repodata_search(data, p, keyname, md->flags, repo_matchvalue, md); + repodata_search_keyskip(data, p, keyname, md->flags, keyskip, repo_matchvalue, md); if (md->stop > SEARCH_NEXT_KEY) break; } @@ -899,18 +895,181 @@ repo_search(Repo *repo, Id p, Id keyname, const char *match, int flags, int (*ca repo_search_md(repo, p, keyname, &md); if (match) datamatcher_free(&md.matcher); + solv_free(md.keyskip); +} + +Repodata * +repo_lookup_repodata(Repo *repo, Id entry, Id keyname) +{ + Repodata *data; + int rdid; + Id type; + + if (entry == SOLVID_POS) + { + Pool *pool = repo->pool; + return pool->pos.repo == repo && pool->pos.repodataid ? pool->pos.repo->repodata + pool->pos.repodataid : 0; + } + for (rdid = repo->nrepodata - 1, data = repo->repodata + rdid; rdid > 0; rdid--, data--) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + if ((type = repodata_lookup_type(data, entry, keyname)) != 0) + return type == REPOKEY_TYPE_DELETED ? 0 : data; + } + return 0; +} + +/* like repo_lookup_repodata, but may return a repodata that contains no match instead of NULL */ +Repodata * +repo_lookup_repodata_opt(Repo *repo, Id entry, Id keyname) +{ + Repodata *data, *found = 0; + int rdid; + Id type; + + if (entry == SOLVID_POS) + { + Pool *pool = repo->pool; + return pool->pos.repo == repo && pool->pos.repodataid ? pool->pos.repo->repodata + pool->pos.repodataid : 0; + } + for (rdid = repo->nrepodata - 1, data = repo->repodata + rdid; rdid > 0; rdid--, data--) + { + if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) + continue; + if (!repodata_precheck_keyname(data, keyname)) + continue; + if (found && (type = repodata_lookup_type(found, entry, keyname)) != 0) + return type == REPOKEY_TYPE_DELETED ? 0 : found; + found = data; + } + return found; +} + +Repodata * +repo_lookup_filelist_repodata(Repo *repo, Id entry, Datamatcher *matcher) +{ + Repodata *data; + int haveextension; + int rdid; + Id type; + + if (entry <= 0 || !matcher || !matcher->match || ((matcher->flags & (SEARCH_STRINGMASK|SEARCH_NOCASE)) != SEARCH_STRING + && (matcher->flags & (SEARCH_STRINGMASK|SEARCH_NOCASE)) != SEARCH_GLOB)) + return repo_lookup_repodata_opt(repo, entry, SOLVABLE_FILELIST); /* cannot use filtered filelist */ + + haveextension = 0; + for (rdid = repo->nrepodata - 1, data = repo->repodata + rdid; rdid > 0; rdid--, data--) + { + if (entry < data->start || entry >= data->end) + continue; + if (data->filelisttype == REPODATA_FILELIST_FILTERED) + { + if (data->state != REPODATA_AVAILABLE) + { + if (data->state != REPODATA_STUB) + continue; + repodata_load(data); + if (data->state != REPODATA_AVAILABLE || entry < data->start || entry >= data->end) + continue; + } + /* does this contain any data about the solvable we're looking for? */ + if (!data->incoreoffset[entry - data->start]) + continue; /* no, ignore */ + if (haveextension && repodata_filelistfilter_matches(data, matcher->match)) + return data; + break; /* fall back to normal code */ + } + if (!repodata_has_keyname(data, SOLVABLE_FILELIST)) + continue; + if (data->filelisttype == REPODATA_FILELIST_EXTENSION) + { + haveextension++; + continue; + } + if ((type = repodata_lookup_type(data, entry, SOLVABLE_FILELIST)) != 0) + { + if (haveextension) + break; /* need to look in extension */ + return type == REPOKEY_TYPE_DELETED ? 0 : data; + } + } + /* cannot use filtered filelist */ + return repo_lookup_repodata_opt(repo, entry, SOLVABLE_FILELIST); +} + + +/* the keyskip array has the following format: + * 0: keyname area size + * 1: repoid base + * 2: repoid end + * 3: entry for keyname 0 + * 4: entry for keyname 1 + * ... + */ +Id * +repo_create_keyskip(Repo *repo, Id entry, Id **oldkeyskip) +{ + Repodata *data, *last = 0; + Id *keyskip; + int rdid, cnt = 0; + + if (repo->nrepodata <= 2) + return 0; /* just one repodata, nothing to filter */ + keyskip = oldkeyskip ? *oldkeyskip : 0; + if (keyskip) + { + if (keyskip[1] >= 0x10000000) + keyskip = solv_free(keyskip); + else + keyskip[1] = keyskip[2]; + } + FOR_REPODATAS(repo, rdid, data) + { + if (entry != SOLVID_META) + { + if (data->state != REPODATA_AVAILABLE && data->state != REPODATA_LOADING) + { + if (data->state != REPODATA_STUB) + continue; + repodata_load(data); + if (data->state != REPODATA_AVAILABLE) + continue; + } + if ((entry < data->start || entry >= data->end)) + continue; + if (!data->incoreoffset[entry - data->start]) + continue; + } + if (last) + keyskip = repodata_fill_keyskip(last, entry, keyskip); + last = data; + cnt++; + } + if (cnt <= 1) + { + if (oldkeyskip) + *oldkeyskip = keyskip; + return 0; + } + keyskip = repodata_fill_keyskip(last, entry, keyskip); + if (keyskip) + keyskip[2] = keyskip[1] + repo->nrepodata; + if (oldkeyskip) + *oldkeyskip = keyskip; + return keyskip; } const char * repo_lookup_str(Repo *repo, Id entry, Id keyname) { - Pool *pool = repo->pool; Repodata *data; - int i; - const char *str; if (entry >= 0) { + Pool *pool = repo->pool; switch (keyname) { case SOLVABLE_NAME: @@ -923,57 +1082,33 @@ repo_lookup_str(Repo *repo, Id entry, Id keyname) return pool_id2str(pool, pool->solvables[entry].vendor); } } - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - str = repodata_lookup_str(data, entry, keyname); - if (str) - return str; - if (repodata_lookup_type(data, entry, keyname)) - return 0; - } - return 0; + data = repo_lookup_repodata_opt(repo, entry, keyname); + return data ? repodata_lookup_str(data, entry, keyname) : 0; } -unsigned int -repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned int notfound) +unsigned long long +repo_lookup_num(Repo *repo, Id entry, Id keyname, unsigned long long notfound) { Repodata *data; - int i; - unsigned int value; if (entry >= 0) { if (keyname == RPM_RPMDBID) { if (repo->rpmdbid && entry >= repo->start && entry < repo->end) - return repo->rpmdbid[entry - repo->start]; + return (unsigned int)repo->rpmdbid[entry - repo->start]; return notfound; } } - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - if (repodata_lookup_num(data, entry, keyname, &value)) - return value; - if (repodata_lookup_type(data, entry, keyname)) - return notfound; - } - return notfound; + data = repo_lookup_repodata_opt(repo, entry, keyname); + return data ? repodata_lookup_num(data, entry, keyname, notfound) : notfound; } Id repo_lookup_id(Repo *repo, Id entry, Id keyname) { Repodata *data; - int i; Id id; if (entry >= 0) @@ -990,18 +1125,9 @@ repo_lookup_id(Repo *repo, Id entry, Id keyname) return repo->pool->solvables[entry].vendor; } } - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - id = repodata_lookup_id(data, entry, keyname); - if (id) - return data->localpool ? repodata_globalize_id(data, id, 1) : id; - if (repodata_lookup_type(data, entry, keyname)) - return 0; - } + data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data && (id = repodata_lookup_id(data, entry, keyname)) != 0) + return data->localpool ? repodata_globalize_id(data, id, 1) : id; return 0; } @@ -1044,47 +1170,62 @@ repo_lookup_idarray(Repo *repo, Id entry, Id keyname, Queue *q) return lookup_idarray_solvable(repo, repo->pool->solvables[entry].enhances, q); } } - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data && repodata_lookup_idarray(data, entry, keyname, q)) { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - if (repodata_lookup_idarray(data, entry, keyname, q)) + if (data->localpool) { - if (data->localpool) - { - for (i = 0; i < q->count; i++) - q->elements[i] = repodata_globalize_id(data, q->elements[i], 1); - } - return 1; + for (i = 0; i < q->count; i++) + q->elements[i] = repodata_globalize_id(data, q->elements[i], 1); } - if (repodata_lookup_type(data, entry, keyname)) - break; + return 1; } queue_empty(q); return 0; } +int +repo_lookup_deparray(Repo *repo, Id entry, Id keyname, Queue *q, Id marker) +{ + int r = repo_lookup_idarray(repo, entry, keyname, q); + if (!r) + return 0; + if (marker == -1 || marker == 1) + marker = solv_depmarker(keyname, marker); + if (marker && q->count) + { + int i; + if (marker < 0) + { + marker = -marker; + for (i = 0; i < q->count; i++) + if (q->elements[i] == marker) + { + queue_truncate(q, i); + return r; + } + } + else + { + for (i = 0; i < q->count; i++) + if (q->elements[i] == marker) + { + queue_deleten(q, 0, i + 1); + return r; + } + queue_empty(q); + } + } + return r; +} + const unsigned char * repo_lookup_bin_checksum(Repo *repo, Id entry, Id keyname, Id *typep) { - Repodata *data; - int i; const unsigned char *chk; - - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - chk = repodata_lookup_bin_checksum(data, entry, keyname, typep); - if (chk) - return chk; - if (repodata_lookup_type(data, entry, keyname)) - return 0; - } + Repodata *data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data && (chk = repodata_lookup_bin_checksum(data, entry, keyname, typep)) != 0) + return chk; *typep = 0; return 0; } @@ -1093,46 +1234,39 @@ const char * repo_lookup_checksum(Repo *repo, Id entry, Id keyname, Id *typep) { const unsigned char *chk = repo_lookup_bin_checksum(repo, entry, keyname, typep); - return chk ? pool_bin2hex(repo->pool, chk, sat_chksum_len(*typep)) : 0; + return chk ? pool_bin2hex(repo->pool, chk, solv_chksum_len(*typep)) : 0; } int repo_lookup_void(Repo *repo, Id entry, Id keyname) { - Repodata *data; - int i; - Id type; - - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - type = repodata_lookup_type(data, entry, keyname); - if (type) - return type == REPOKEY_TYPE_VOID; - } + Repodata *data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data) + return repodata_lookup_void(data, entry, keyname); return 0; } Id repo_lookup_type(Repo *repo, Id entry, Id keyname) { - Repodata *data; - int i; Id type; + Repodata *data; + if (keyname >= SOLVABLE_NAME && keyname <= RPM_RPMDBID) + return repo_solvablekeys[keyname - SOLVABLE_NAME].type; + data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data && (type = repodata_lookup_type(data, entry, keyname)) != 0 && type != REPOKEY_TYPE_DELETED) + return type; + return 0; +} - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) - { - if (entry != SOLVID_META && (entry < data->start || entry >= data->end)) - continue; - if (!repodata_precheck_keyname(data, keyname)) - continue; - type = repodata_lookup_type(data, entry, keyname); - if (type) - return type == REPOKEY_TYPE_DELETED ? 0 : type; - } +const void * +repo_lookup_binary(Repo *repo, Id entry, Id keyname, int *lenp) +{ + const void *bin; + Repodata *data = repo_lookup_repodata_opt(repo, entry, keyname); + if (data && (bin = repodata_lookup_binary(data, entry, keyname, lenp)) != 0) + return bin; + *lenp = 0; return 0; } @@ -1141,10 +1275,11 @@ repo_lookup_type(Repo *repo, Id entry, Id keyname) Repodata * repo_add_repodata(Repo *repo, int flags) { + Repodata *data; int i; if ((flags & REPO_USE_LOADING) != 0) { - for (i = repo->nrepodata - 1; i >= 0; i--) + for (i = repo->nrepodata - 1; i > 0; i--) if (repo->repodata[i].state == REPODATA_LOADING) { Repodata *data = repo->repodata + i; @@ -1158,18 +1293,36 @@ repo_add_repodata(Repo *repo, int flags) } if ((flags & REPO_REUSE_REPODATA) != 0) { - for (i = repo->nrepodata - 1; i >= 0; i--) + for (i = repo->nrepodata - 1; i > 0; i--) if (repo->repodata[i].state != REPODATA_STUB) return repo->repodata + i; } - return repodata_create(repo, (flags & REPO_LOCALPOOL) ? 1 : 0); + if (!repo->nrepodata) + { + repo->nrepodata = 2; /* start with id 1 */ + repo->repodata = solv_calloc(repo->nrepodata, sizeof(*data)); + } + else + { + repo->nrepodata++; + repo->repodata = solv_realloc2(repo->repodata, repo->nrepodata, sizeof(*data)); + } + data = repo->repodata + repo->nrepodata - 1; + repodata_initdata(data, repo, (flags & REPO_LOCALPOOL) ? 1 : 0); + return data; +} + +Repodata * +repo_id2repodata(Repo *repo, Id id) +{ + return id ? repo->repodata + id : 0; } Repodata * repo_last_repodata(Repo *repo) { int i; - for (i = repo->nrepodata - 1; i >= 0; i--) + for (i = repo->nrepodata - 1; i > 0; i--) if (repo->repodata[i].state != REPODATA_STUB) return repo->repodata + i; return repo_add_repodata(repo, 0); @@ -1204,7 +1357,7 @@ repo_set_id(Repo *repo, Id p, Id keyname, Id id) } void -repo_set_num(Repo *repo, Id p, Id keyname, unsigned int num) +repo_set_num(Repo *repo, Id p, Id keyname, unsigned long long num) { Repodata *data; if (p >= 0) @@ -1213,7 +1366,7 @@ repo_set_num(Repo *repo, Id p, Id keyname, unsigned int num) { if (!repo->rpmdbid) repo->rpmdbid = repo_sidedata_create(repo, sizeof(Id)); - repo->rpmdbid[p] = num; + repo->rpmdbid[p - repo->start] = (Id)num; return; } } @@ -1269,12 +1422,198 @@ repo_add_poolstr_array(Repo *repo, Id p, Id keyname, const char *str) } void +repo_add_deparray(Repo *repo, Id p, Id keyname, Id dep, Id marker) +{ + Repodata *data; + if (marker == -1 || marker == 1) + marker = solv_depmarker(keyname, marker); + if (p >= 0) + { + Solvable *s = repo->pool->solvables + p; + switch (keyname) + { + case SOLVABLE_PROVIDES: + s->provides = repo_addid_dep(repo, s->provides, dep, marker); + return; + case SOLVABLE_OBSOLETES: + s->obsoletes = repo_addid_dep(repo, s->obsoletes, dep, marker); + return; + case SOLVABLE_CONFLICTS: + s->conflicts = repo_addid_dep(repo, s->conflicts, dep, marker); + return; + case SOLVABLE_REQUIRES: + s->requires = repo_addid_dep(repo, s->requires, dep, marker); + return; + case SOLVABLE_RECOMMENDS: + s->recommends = repo_addid_dep(repo, s->recommends, dep, marker); + return; + case SOLVABLE_SUGGESTS: + s->suggests = repo_addid_dep(repo, s->suggests, dep, marker); + return; + case SOLVABLE_SUPPLEMENTS: + s->supplements = repo_addid_dep(repo, s->supplements, dep, marker); + return; + case SOLVABLE_ENHANCES: + s->enhances = repo_addid_dep(repo, s->enhances, dep, marker); + return; + } + } + data = repo_last_repodata(repo); + repodata_add_idarray(data, p, keyname, dep); +} + +void +repo_add_idarray(Repo *repo, Id p, Id keyname, Id id) +{ + repo_add_deparray(repo, p, keyname, id, 0); +} + +static Offset +repo_set_idarray_solvable(Repo *repo, Queue *q) +{ + Offset o = 0; + int i; + for (i = 0; i < q->count; i++) + repo_addid_dep(repo, o, q->elements[i], 0); + return o; +} + +void +repo_set_deparray(Repo *repo, Id p, Id keyname, Queue *q, Id marker) +{ + Repodata *data; + if (marker == -1 || marker == 1) + marker = solv_depmarker(keyname, marker); + if (marker) + { + /* complex case, splice old and new arrays */ + int i; + Queue q2; + queue_init(&q2); + repo_lookup_deparray(repo, p, keyname, &q2, -marker); + if (marker > 0) + { + if (q->count) + { + queue_push(&q2, marker); + for (i = 0; i < q->count; i++) + queue_push(&q2, q->elements[i]); + } + } + else + { + if (q2.count) + queue_insert(&q2, 0, -marker); + queue_insertn(&q2, 0, q->count, q->elements); + } + repo_set_deparray(repo, p, keyname, &q2, 0); + queue_free(&q2); + return; + } + if (p >= 0) + { + Solvable *s = repo->pool->solvables + p; + switch (keyname) + { + case SOLVABLE_PROVIDES: + s->provides = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_OBSOLETES: + s->obsoletes = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_CONFLICTS: + s->conflicts = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_REQUIRES: + s->requires = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_RECOMMENDS: + s->recommends = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_SUGGESTS: + s->suggests = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_SUPPLEMENTS: + s->supplements = repo_set_idarray_solvable(repo, q); + return; + case SOLVABLE_ENHANCES: + s->enhances = repo_set_idarray_solvable(repo, q); + return; + } + } + data = repo_last_repodata(repo); + repodata_set_idarray(data, p, keyname, q); +} + +void +repo_set_idarray(Repo *repo, Id p, Id keyname, Queue *q) +{ + repo_set_deparray(repo, p, keyname, q, 0); +} + +void +repo_unset(Repo *repo, Id p, Id keyname) +{ + Repodata *data; + if (p >= 0) + { + Solvable *s = repo->pool->solvables + p; + switch (keyname) + { + case SOLVABLE_NAME: + s->name = 0; + return; + case SOLVABLE_ARCH: + s->arch = 0; + return; + case SOLVABLE_EVR: + s->evr = 0; + return; + case SOLVABLE_VENDOR: + s->vendor = 0; + return; + case RPM_RPMDBID: + if (repo->rpmdbid) + repo->rpmdbid[p - repo->start] = 0; + return; + case SOLVABLE_PROVIDES: + s->provides = 0; + return; + case SOLVABLE_OBSOLETES: + s->obsoletes = 0; + return; + case SOLVABLE_CONFLICTS: + s->conflicts = 0; + return; + case SOLVABLE_REQUIRES: + s->requires = 0; + return; + case SOLVABLE_RECOMMENDS: + s->recommends = 0; + return; + case SOLVABLE_SUGGESTS: + s->suggests = 0; + return; + case SOLVABLE_SUPPLEMENTS: + s->supplements = 0; + case SOLVABLE_ENHANCES: + s->enhances = 0; + return; + default: + break; + } + } + data = repo_last_repodata(repo); + repodata_unset(data, p, keyname); +} + +void repo_internalize(Repo *repo) { int i; Repodata *data; - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + FOR_REPODATAS(repo, i, data) if (data->attrs || data->xattrs) repodata_internalize(data); } @@ -1285,10 +1624,7 @@ repo_disable_paging(Repo *repo) int i; Repodata *data; - for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++) + FOR_REPODATAS(repo, i, data) repodata_disable_paging(data); } -// EOF -/* -vim:cinoptions={.5s,g0,p5,t0,(0,^-0.5s,n-0.5s:tw=78:cindent:sw=4: -*/ +