+++ /dev/null
-# Generic Makefile.cvs for CMake-based projects:
-#
-# Create a subdirecory build/ and call cmake from there with /usr prefix.
-#
-# Intentionally using /usr rather than the default /usr/local since this is for
-# internal use, and we are the distribution makers: /usr/local is off limits
-# for us.
-#
-# Author: Stefan Hundhammer <sh@suse.de>
-
-BUILD_SUBDIR = build
-HERE_FROM_BUILD_SUBDIR = ..
-PREFIX = /usr
-CMAKE = /usr/bin/cmake
-
-all: cmake
-
-
-cmake: create-build-subdir create-toplevel-makefile
- ( cd $(BUILD_SUBDIR) && $(CMAKE) -DCMAKE_INSTALL_PREFIX=$(PREFIX) $(HERE_FROM_BUILD_SUBDIR) )
-
-
-create-build-subdir:
- test -d $(BUILD_SUBDIR) || mkdir $(BUILD_SUBDIR)
-
-
-create-toplevel-makefile:
- echo 'all:' >Makefile
- echo -e '\t$$(MAKE) $$(MAKEFLAGS) -C $(BUILD_SUBDIR)' >>Makefile
-
Id id;
if (!*arch)
return 0;
- id = str2id(pool, arch, 0);
+ id = pool_str2id(pool, arch, 0);
if (id == ARCH_SRC || id == ARCH_NOSRC || id == ARCH_NOARCH)
return id;
if (pool->id2arch && (id > pool->lastarch || !pool->id2arch[id]))
depglob(Pool *pool, char *name, Queue *job, int what)
{
Id p, pp;
- Id id = str2id(pool, name, 0);
+ Id id = pool_str2id(pool, name, 0);
int i, match = 0;
if (id)
if (!s->repo || !pool_installable(pool, s))
continue;
id = s->name;
- if (fnmatch(name, id2str(pool, id), 0) == 0)
+ if (fnmatch(name, pool_id2str(pool, id), 0) == 0)
{
for (i = 0; i < job->count; i += 2)
if (job->elements[i] == SOLVER_SOLVABLE_NAME && job->elements[i + 1] == id)
{
if (!pool->whatprovides[id])
continue;
- if (fnmatch(name, id2str(pool, id), 0) == 0)
+ if (fnmatch(name, pool_id2str(pool, id), 0) == 0)
{
if (!match && what == DEPGLOB_NAMEDEP)
printf("[using capability match for '%s']\n", name);
fprintf(stderr, "limitrelation only works on name/provides jobs\n");
exit(1);
}
- job->elements[i + 1] = rel2id(pool, job->elements[i + 1], evr, flags, 1);
+ job->elements[i + 1] = pool_rel2id(pool, job->elements[i + 1], evr, flags, 1);
if (flags == REL_ARCH)
job->elements[i] |= SOLVER_SETARCH;
if (flags == REL_EQ && select == SOLVER_SOLVABLE_NAME && job->elements[i])
{
#ifndef DEBIAN
- const char *evrstr = id2str(pool, evr);
+ const char *evrstr = pool_id2str(pool, evr);
if (!strchr(evrstr, '-'))
job->elements[i] |= SOLVER_SETEV;
else
{
*r = 0;
limitrelation(pool, job, REL_ARCH, archid);
- limitrelation(pool, job, flags, str2id(pool, evr, 1));
+ limitrelation(pool, job, flags, pool_str2id(pool, evr, 1));
*r = '.';
}
else
- limitrelation(pool, job, flags, str2id(pool, evr, 1));
+ limitrelation(pool, job, flags, pool_str2id(pool, evr, 1));
return job->count / 2;
}
if (depglob(pool, name, job, DEPGLOB_NAMEDEP))
{
name[nend] = oldnend;
- limitrelation(pool, job, rflags, str2id(pool, r, 1));
+ limitrelation(pool, job, rflags, pool_str2id(pool, r, 1));
return job->count / 2;
}
if ((r2 = strrchr(name, '.')) != 0 && r2[1] && (archid = str2archid(pool, r2 + 1)) != 0)
name[nend] = oldnend;
*r2 = '.';
limitrelation(pool, job, REL_ARCH, archid);
- limitrelation(pool, job, rflags, str2id(pool, r, 1));
+ limitrelation(pool, job, rflags, pool_str2id(pool, r, 1));
return job->count / 2;
}
*r2 = '.';
if (!fp)
return 0;
rewind(fp);
- return rpm_byfp(fp, solvable2str(pool, s), &fcstate->rpmdbstate);
+ return rpm_byfp(fp, pool_solvable2str(pool, s), &fcstate->rpmdbstate);
}
Solvable *s = pool->solvables + evr;
Id p, pp, cap;
- cap = str2id(pool, pool_tmpjoin(pool, "product(", id2str(pool, s->name) + 8, ")"), 0);
+ cap = pool_str2id(pool, pool_tmpjoin(pool, "product(", pool_id2str(pool, s->name) + 8, ")"), 0);
if (!cap)
return 0;
- cap = rel2id(pool, cap, s->evr, REL_EQ, 0);
+ cap = pool_rel2id(pool, cap, s->evr, REL_EQ, 0);
if (!cap)
return 0;
FOR_PROVIDES(p, pp, cap)
type = SOLVER_SOLVABLE_PROVIDES;
bp += 9;
}
- id = str2id(pool, bp, 1);
+ id = pool_str2id(pool, bp, 1);
if (pool->installed)
{
FOR_JOB_SELECT(p, pp, type, id)
Solvable *s = pool_id2solvable(pool, p);
if (!MAPTST(&m, p))
continue;
- printf(" - %s: %s\n", solvable2str(pool, s), solvable_lookup_str(s, SOLVABLE_SUMMARY));
+ printf(" - %s: %s\n", pool_solvable2str(pool, s), solvable_lookup_str(s, SOLVABLE_SUMMARY));
}
map_free(&m);
exit(0);
if (mainmode == MODE_INFO)
{
const char *str;
- printf("Name: %s\n", solvable2str(pool, s));
+ printf("Name: %s\n", pool_solvable2str(pool, s));
printf("Repo: %s\n", s->repo->name);
printf("Summary: %s\n", solvable_lookup_str(s, SOLVABLE_SUMMARY));
str = solvable_lookup_str(s, SOLVABLE_URL);
#else
const char *sum = solvable_lookup_str_poollang(s, SOLVABLE_SUMMARY);
#endif
- printf(" - %s [%s]\n", solvable2str(pool, s), s->repo->name);
+ printf(" - %s [%s]\n", pool_solvable2str(pool, s), s->repo->name);
if (sum)
printf(" %s\n", sum);
}
Id p2;
s = pool->solvables + p;
- if (strncmp(id2str(pool, s->name), "patch:", 6) != 0)
+ if (strncmp(pool_id2str(pool, s->name), "patch:", 6) != 0)
continue;
FOR_PROVIDES(p2, pp, s->name)
{
Solvable *s2 = pool->solvables + p2;
if (s2->name != s->name)
continue;
- r = evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
+ r = pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
if (r < 0 || (r == 0 && p > p2))
break;
}
queue_push2(&job, SOLVER_DISTUPGRADE|SOLVER_SOLVABLE_REPO, repofilter);
// multiversion test
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae", 1));
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae-base", 1));
- // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, str2id(pool, "kernel-pae-extra", 1));
+ // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae", 1));
+ // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-base", 1));
+ // queue_push2(&job, SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME, pool_str2id(pool, "kernel-pae-extra", 1));
#ifdef SOFTLOCKS_PATH
addsoftlocks(pool, &job);
if (pool->installed && pool->installed->nsolvables)
{
/* try a delta first */
- char *matchname = strdup(id2str(pool, s->name));
+ char *matchname = strdup(pool_id2str(pool, s->name));
dataiterator_init(&di, pool, s->repo, SOLVID_META, DELTA_PACKAGE_NAME, matchname, SEARCH_STRING);
dataiterator_prepend_keyname(&di, REPOSITORY_DELTAINFO);
while (dataiterator_step(&di))
seq = pool_tmpjoin(pool, seqname, "-", seqevr);
seq = pool_tmpappend(pool, seq, "-", seqnum);
#ifdef FEDORA
- sprintf(cmd, "/usr/bin/applydeltarpm -a %s -c -s ", id2str(pool, s->arch));
+ sprintf(cmd, "/usr/bin/applydeltarpm -a %s -c -s ", pool_id2str(pool, s->arch));
#else
sprintf(cmd, "/usr/bin/applydeltarpm -c -s ");
#endif
/* got it, now reconstruct */
newfd = opentmpfile();
#ifdef FEDORA
- sprintf(cmd, "applydeltarpm -a %s /dev/fd/%d /dev/fd/%d", id2str(pool, s->arch), fileno(fp), newfd);
+ sprintf(cmd, "applydeltarpm -a %s /dev/fd/%d /dev/fd/%d", pool_id2str(pool, s->arch), fileno(fp), newfd);
#else
sprintf(cmd, "applydeltarpm /dev/fd/%d /dev/fd/%d", fileno(fp), newfd);
#endif
{
printf("\n");
for (i = 0; i < conflicts.count; i += 5)
- printf("file %s of package %s conflicts with package %s\n", id2str(pool, conflicts.elements[i]), solvid2str(pool, conflicts.elements[i + 1]), solvid2str(pool, conflicts.elements[i + 3]));
+ printf("file %s of package %s conflicts with package %s\n", pool_id2str(pool, conflicts.elements[i]), pool_solvid2str(pool, conflicts.elements[i + 1]), pool_solvid2str(pool, conflicts.elements[i + 3]));
printf("\n");
if (yesno("Re-run solver (y/n/q)? "))
{
switch(type)
{
case SOLVER_TRANSACTION_ERASE:
- printf("erase %s\n", solvid2str(pool, p));
+ printf("erase %s\n", pool_solvid2str(pool, p));
#ifndef DEBIAN
if (!s->repo->rpmdbid || !s->repo->rpmdbid[p - s->repo->start])
continue;
/* strip epoch from evr */
- evr = evrp = id2str(pool, s->evr);
+ evr = evrp = pool_id2str(pool, s->evr);
while (*evrp >= '0' && *evrp <= '9')
evrp++;
if (evrp > evr && evrp[0] == ':' && evrp[1])
evr = evrp + 1;
- nvra = pool_tmpjoin(pool, id2str(pool, s->name), "-", evr);
- nvra = pool_tmpappend(pool, nvra, ".", id2str(pool, s->arch));
+ nvra = pool_tmpjoin(pool, pool_id2str(pool, s->name), "-", evr);
+ nvra = pool_tmpappend(pool, nvra, ".", pool_id2str(pool, s->arch));
runrpm("-e", nvra, -1); /* too bad that --querybynumber doesn't work */
#else
- rundpkg("--remove", id2str(pool, s->name), 0);
+ rundpkg("--remove", pool_id2str(pool, s->name), 0);
#endif
break;
case SOLVER_TRANSACTION_INSTALL:
case SOLVER_TRANSACTION_MULTIINSTALL:
- printf("install %s\n", solvid2str(pool, p));
+ printf("install %s\n", pool_solvid2str(pool, p));
for (j = 0; j < newpkgs; j++)
if (checkq.elements[j] == p)
break;
const Id *a = ap;
const Id *b = bp;
if (a[0] != b[0])
- return strcmp(id2str(pool, a[0]), id2str(pool, b[0]));
+ return strcmp(pool_id2str(pool, a[0]), pool_id2str(pool, b[0]));
if (a[1] != b[1])
return a[1] - b[1];
if (a[3] != b[3])
continue; /* md5 sum matches */
if (pool->obsoleteusescolors && fsi[33] && fsj[33] && (fsi[33] & fsj[33]) == 0)
continue; /* colors do not conflict */
- queue_push(conflicts, str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[ii] + 34, 1));
+ queue_push(conflicts, pool_str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[ii] + 34, 1));
queue_push(conflicts, p);
- queue_push(conflicts, str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[ii], 1));
+ queue_push(conflicts, pool_str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[ii], 1));
queue_push(conflicts, q);
- queue_push(conflicts, str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[jj], 1));
+ queue_push(conflicts, pool_str2id(pool, (char *)cbdata.filesspace + cbdata.files.elements[jj], 1));
}
}
}
dependencies sometimes. */
if (!strncmp (name, "package:", 8))
name += 8;
- id = str2id(pool, name, 1);
+ id = pool_str2id(pool, name, 1);
if (*line == '<' || *line == '>' || *line == '=') /* rel follows */
{
char *rel = splitword(&line);
pool_debug(pool, SAT_FATAL, "repo_content: unknown relation '%s'\n", rel);
continue;
}
- id = rel2id(pool, id, str2id(pool, evr, 1), flags + 1, 1);
+ id = pool_rel2id(pool, id, pool_str2id(pool, evr, 1), flags + 1, 1);
}
olddeps = repo_addid_dep(pd->repo, olddeps, id, marker);
}
else
repodata_set_poolstr(data, SOLVID_META, SUSETAGS_DEFAULTVENDOR, value);
if (s)
- s->vendor = str2id(pool, value, 1);
+ s->vendor = pool_str2id(pool, value, 1);
defvendor = strdup(value);
continue;
}
{
/* this solvable was created without seeing a
PRODUCT entry, just set the name and continue */
- s->name = str2id(pool, join(&pd, "product", ":", value), 1);
+ s->name = pool_str2id(pool, join(&pd, "product", ":", value), 1);
continue;
}
if (s)
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (code10)
s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, 0);
}
s = pool_id2solvable(pool, repo_add_solvable(repo));
repodata_extend(data, s - pool->solvables);
handle = s - pool->solvables;
- s->name = str2id(pool, join(&pd, "product", ":", value), 1);
+ s->name = pool_str2id(pool, join(&pd, "product", ":", value), 1);
if (datadir)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DATADIR, datadir);
if (descrdir)
repodata_set_str(data, s - pool->solvables, SUSETAGS_DESCRDIR, descrdir);
if (defvendor)
- s->vendor = str2id(pool, defvendor, 1);
+ s->vendor = pool_str2id(pool, defvendor, 1);
continue;
}
else if (code11 && istag ("DISTRIBUTION"))
repodata_set_str(data, s - pool->solvables, SOLVABLE_DISTRIBUTION, value);
else if (istag ("UPDATEURLS"))
- add_multiple_urls(data, handle, value, str2id(pool, "update", 1));
+ add_multiple_urls(data, handle, value, pool_str2id(pool, "update", 1));
else if (istag ("EXTRAURLS"))
- add_multiple_urls(data, handle, value, str2id(pool, "extra", 1));
+ add_multiple_urls(data, handle, value, pool_str2id(pool, "extra", 1));
else if (istag ("OPTIONALURLS"))
- add_multiple_urls(data, handle, value, str2id(pool, "optional", 1));
+ add_multiple_urls(data, handle, value, pool_str2id(pool, "optional", 1));
else if (istag ("RELNOTESURL"))
- add_multiple_urls(data, handle, value, str2id(pool, "releasenotes", 1));
+ add_multiple_urls(data, handle, value, pool_str2id(pool, "releasenotes", 1));
else if (istag ("SHORTLABEL"))
repodata_set_str(data, s - pool->solvables, PRODUCT_SHORTLABEL, value);
else if (istag ("LABEL")) /* LABEL is the products SUMMARY. */
else if (istag ("FLAGS"))
add_multiple_strings(data, handle, PRODUCT_FLAGS, value);
else if (istag ("VENDOR")) /* actually already handled above */
- s->vendor = str2id(pool, value, 1);
+ s->vendor = pool_str2id(pool, value, 1);
else if (istag ("BASEARCHS"))
{
char *arch;
if ((arch = splitword(&value)) != 0)
{
- s->arch = str2id(pool, arch, 1);
+ s->arch = pool_str2id(pool, arch, 1);
while ((arch = splitword(&value)) != 0)
{
otherarchs = sat_extend(otherarchs, numotherarchs, 1, sizeof(Id), 7);
- otherarchs[numotherarchs++] = str2id(pool, arch, 1);
+ otherarchs[numotherarchs++] = pool_str2id(pool, arch, 1);
}
}
}
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (code10)
s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, 0);
/* self provides */
if (s->name && p->arch != ARCH_SRC && p->arch != ARCH_NOSRC)
- p->provides = repo_addid_dep(repo, p->provides, rel2id(pool, p->name, p->evr, REL_EQ, 1), 0);
+ p->provides = repo_addid_dep(repo, p->provides, pool_rel2id(pool, p->name, p->evr, REL_EQ, 1), 0);
/* now merge the attributes */
repodata_merge_attrs(data, p - pool->solvables, s - pool->solvables);
while (*p == ' ' || *p == '\t' || *p == '\n')
p++;
}
- name = strn2id(pool, n, ne - n, 1);
+ name = pool_strn2id(pool, n, ne - n, 1);
if (e)
{
- evr = strn2id(pool, e, ee - e, 1);
- name = rel2id(pool, name, evr, flags, 1);
+ evr = pool_strn2id(pool, e, ee - e, 1);
+ name = pool_rel2id(pool, name, evr, flags, 1);
}
if (*p == '|')
{
Id id = parseonedep(pool, p + 1);
if (id)
- name = rel2id(pool, name, id, REL_OR, 1);
+ name = pool_rel2id(pool, name, id, REL_OR, 1);
}
return name;
}
{
case 'A' << 8 | 'R':
if (!strcasecmp(tag, "architecture"))
- s->arch = str2id(pool, q, 1);
+ s->arch = pool_str2id(pool, q, 1);
break;
case 'B' << 8 | 'R':
if (!strcasecmp(tag, "breaks"))
break;
case 'P' << 8 | 'A':
if (!strcasecmp(tag, "package"))
- s->name = str2id(pool, q, 1);
+ s->name = pool_str2id(pool, q, 1);
break;
case 'P' << 8 | 'R':
if (!strcasecmp(tag, "pre-depends"))
*q2 = 0;
break;
}
- if (s->name && !strcmp(q, id2str(pool, s->name)))
+ if (s->name && !strcmp(q, pool_id2str(pool, s->name)))
repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
else
- repodata_set_id(data, s - pool->solvables, SOLVABLE_SOURCENAME, str2id(pool, q, 1));
+ repodata_set_id(data, s - pool->solvables, SOLVABLE_SOURCENAME, pool_str2id(pool, q, 1));
havesource = 1;
}
break;
break;
case 'V' << 8 | 'E':
if (!strcasecmp(tag, "version"))
- s->evr = str2id(pool, q, 1);
+ s->evr = pool_str2id(pool, q, 1);
break;
}
}
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
if (s->name && !havesource)
repodata_set_void(data, s - pool->solvables, SOLVABLE_SOURCENAME);
if (s->obsoletes)
#if 0
fprintf(stderr, "evr: %s\n", pd->content);
#endif
- return str2id(pool, pd->content, 1);
+ return pool_str2id(pool, pd->content, 1);
}
static void parse_delta_location( struct parsedata *pd,
s1 = strrchr (s, '/');
if (s1)
{
- pd->delta.locdir = strn2id(pool, s, s1 - s, 1);
+ pd->delta.locdir = pool_strn2id(pool, s, s1 - s, 1);
s = s1 + 1;
}
/* Guess suffix. */
}
if (*s1 == '.')
*s1++ = 0;
- pd->delta.locsuffix = str2id(pool, s1, 1);
+ pd->delta.locsuffix = pool_str2id(pool, s1, 1);
}
/* Last '-'. */
s1 = strrchr (s, '-');
if (s2 > s && *s2 == '-')
{
*s2++ = 0;
- pd->delta.locevr = str2id(pool, s2, 1);
+ pd->delta.locevr = pool_str2id(pool, s2, 1);
}
- pd->delta.locname = str2id(pool, s, 1);
+ pd->delta.locname = pool_str2id(pool, s, 1);
free(real_str);
}
}
case STATE_NEWPACKAGE:
if ((str = find_attr("name", atts)) != 0)
{
- pd->newpkgname = str2id(pool, str, 1);
+ pd->newpkgname = pool_str2id(pool, str, 1);
}
pd->newpkgevr = makeevr_atts(pool, pd, atts);
if ((str = find_attr("arch", atts)) != 0)
{
- pd->newpkgarch = str2id(pool, str, 1);
+ pd->newpkgarch = pool_str2id(pool, str, 1);
}
break;
break;
if (*s2 == '-')
{
- pd->delta.seqevr = strn2id(pool, s2 + 1, s1 - s2 - 1, 1);
- pd->delta.seqname = strn2id(pool, str, s2 - str, 1);
+ pd->delta.seqevr = pool_strn2id(pool, s2 + 1, s1 - s2 - 1, 1);
+ pd->delta.seqname = pool_strn2id(pool, str, s2 - str, 1);
str = s1 + 1;
}
}
fprintf(stderr, "evr: %s\n", pd->content);
#endif
// intern and create
- return str2id(pool, pd->content, 1);
+ return pool_str2id(pool, pd->content, 1);
}
pd->acontent = l + 256;
}
sprintf(pd->content, "%s:%s", k, n);
- name = str2id(pool, pd->content, 1);
+ name = pool_str2id(pool, pd->content, 1);
}
else
{
- name = str2id(pool, n, 1); /* package: just intern <name> */
+ name = pool_str2id(pool, n, 1); /* package: just intern <name> */
}
if (f) /* operator ? */
if (flags > 7)
flags = 0;
/* intern rel */
- id = rel2id(pool, name, evr, flags, 1);
+ id = pool_rel2id(pool, name, evr, flags, 1);
}
else
id = name; /* no operator */
if (!ISRELDEP(pid))
continue; /* wrong provides name */
prd = GETRELDEP(pool, pid);
- depname = id2str(pool, prd->name);
+ depname = pool_id2str(pool, prd->name);
if (!strncmp(depname, "kernel-", 7))
return depname + 7;
}
if (!ISRELDEP(pid))
{
- depname = id2str(pool, pid);
+ depname = pool_id2str(pool, pid);
}
else
{
Reldep *prd = GETRELDEP(pool, pid);
- depname = id2str(pool, prd->name);
+ depname = pool_id2str(pool, prd->name);
}
if (!strncmp(depname, "kernel-", 7))
return depname + 7;
pd->release ? pd->evrspace + pd->release : 0);
/* ensure self-provides */
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s->supplements = repo_fix_supplements(pd->repo, s->provides, s->supplements, pd->freshens);
s->conflicts = repo_fix_conflicts(pd->repo, s->conflicts);
pd->freshens = 0;
if (ISRELDEP(pid))
{
prd = GETRELDEP(pool, pid);
- depname = id2str(pool, prd->name);
+ depname = pool_id2str(pool, prd->name);
}
else
{
- depname = id2str(pool, pid);
+ depname = pool_id2str(pool, pid);
}
{
char newdep[100];
snprintf(newdep, sizeof(newdep), "kernel(%s:%s", cflavor, depname + 7);
- pid = str2id(pool, newdep, 1);
+ pid = pool_str2id(pool, newdep, 1);
if (prd)
- pid = rel2id(pool, pid, prd->evr, prd->flags, 1);
+ pid = pool_rel2id(pool, pid, prd->evr, prd->flags, 1);
}
npr = repo_addid_dep(pd->repo, npr, pid, 0);
if (ISRELDEP(pid))
{
prd = GETRELDEP(pool, pid);
- depname = id2str(pool, prd->name);
+ depname = pool_id2str(pool, prd->name);
}
else
{
- depname = id2str(pool, pid);
+ depname = pool_id2str(pool, pid);
}
if (!strncmp(depname, "kernel(", 7) && !strchr(depname, ':'))
{
char newdep[100];
snprintf(newdep, sizeof(newdep), "kernel(%s:%s", cflavor, depname + 7);
- pid = str2id(pool, newdep, 1);
+ pid = pool_str2id(pool, newdep, 1);
if (prd)
- pid = rel2id(pool, pid, prd->evr, prd->flags, 1);
+ pid = pool_rel2id(pool, pid, prd->evr, prd->flags, 1);
}
npr = repo_addid_dep(pd->repo, npr, pid, 0);
}
}
break;
case STATE_NAME:
- s->name = str2id(pool, pd->content, 1);
+ s->name = pool_str2id(pool, pd->content, 1);
break;
case STATE_VENDOR:
- s->vendor = str2id(pool, pd->content, 1);
+ s->vendor = pool_str2id(pool, pd->content, 1);
break;
case STATE_BUILDTIME:
t = atoi (pd->content);
pd->version = 0;
pd->release = 0;
/* use highest evr */
- if (!s->evr || evrcmp(pool, s->evr, evr, EVRCMP_MATCH_RELEASE) <= 0)
+ if (!s->evr || pool_evrcmp(pool, s->evr, evr, EVRCMP_MATCH_RELEASE) <= 0)
s->evr = evr;
break;
case STATE_EPOCH:
break;
case STATE_ARCH:
case STATE_PARCH:
- s->arch = str2id(pool, pd->content, 1);
+ s->arch = pool_str2id(pool, pd->content, 1);
break;
default:
break;
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
pd->solvable = 0;
break;
case STATE_VENDOR:
- s->vendor = str2id(pd->pool, pd->content, 1);
+ s->vendor = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_NAME:
- s->name = str2id(pd->pool, join2("product", ":", pd->content), 1);
+ s->name = pool_str2id(pd->pool, join2("product", ":", pd->content), 1);
break;
case STATE_VERSION:
pd->tmpvers = strdup(pd->content);
pd->tmprel = strdup(pd->content);
break;
case STATE_ARCH:
- s->arch = str2id(pd->pool, pd->content, 1);
+ s->arch = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_PRODUCTLINE:
repodata_set_str(pd->data, pd->handle, PRODUCT_PRODUCTLINE, pd->content);
if (pd->tmpurltype)
{
repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, str2id(pd->pool, pd->tmpurltype, 1));
+ repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pd->pool, pd->tmpurltype, 1));
}
pd->tmpurltype = sat_free((void *)pd->tmpurltype);
break;
&& (*ptr1 == ' ' || isdigit(*ptr1) || *ptr1 == '.'))
--ptr1;
*(++ptr1) = 0;
- name = str2id(pool, join2("product", ":", buf), 1);
+ name = pool_str2id(pool, join2("product", ":", buf), 1);
if (ptr)
{
*ptr1 = tolower(*ptr1);
++ptr1;
}
- arch = str2id(pool, ptr, 1);
+ arch = pool_str2id(pool, ptr, 1);
}
}
}
s->evr = version ? version : ID_EMPTY;
s->arch = arch ? arch : ARCH_NOARCH;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
}
}
flags |= 2;
if ((f[i] & DEP_GREATER) != 0)
flags |= 1;
- name = str2id(pool, n[i], 1);
+ name = pool_str2id(pool, n[i], 1);
if (v[i][0] == '0' && v[i][1] == ':' && v[i][2])
- evr = str2id(pool, v[i] + 2, 1);
+ evr = pool_str2id(pool, v[i] + 2, 1);
else
- evr = str2id(pool, v[i], 1);
- *ida++ = rel2id(pool, name, evr, flags, 1);
+ evr = pool_str2id(pool, v[i], 1);
+ *ida++ = pool_rel2id(pool, name, evr, flags, 1);
}
else
- *ida++ = str2id(pool, n[i], 1);
+ *ida++ = pool_str2id(pool, n[i], 1);
}
*ida++ = 0;
repo->idarraysize += cc + 1;
}
strcpy(fn, dn[di[i]]);
strcat(fn, bn[i]);
- olddeps = repo_addid_dep(repo, olddeps, str2id(pool, fn, 1), SOLVABLE_FILEMARKER);
+ olddeps = repo_addid_dep(repo, olddeps, pool_str2id(pool, fn, 1), SOLVABLE_FILEMARKER);
#endif
if (data)
{
else if (!strcmp(sarch, "nosrc.rpm"))
repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
else
- repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, strn2id(pool, sarch, strlen(sarch) - 4, 1));
+ repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, pool_strn2id(pool, sarch, strlen(sarch) - 4, 1));
if (evr && !strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
else
- repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, strn2id(pool, sevr, sarch - sevr - 1, 1));
+ repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, pool_strn2id(pool, sevr, sarch - sevr - 1, 1));
if (name && !strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
else
- repodata_set_id(data, handle, SOLVABLE_SOURCENAME, strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
+ repodata_set_id(data, handle, SOLVABLE_SOURCENAME, pool_strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
}
static int
name = headstring(rpmhead, TAG_NAME);
if (!strcmp(name, "gpg-pubkey"))
return 0;
- s->name = str2id(pool, name, 1);
+ s->name = pool_str2id(pool, name, 1);
if (!s->name)
{
fprintf(stderr, "package has no name\n");
}
sourcerpm = headstring(rpmhead, TAG_SOURCERPM);
if (sourcerpm)
- s->arch = str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
+ s->arch = pool_str2id(pool, headstring(rpmhead, TAG_ARCH), 1);
else
{
if (headexists(rpmhead, TAG_NOSOURCE) || headexists(rpmhead, TAG_NOPATCH))
if (!s->arch)
s->arch = ARCH_NOARCH;
evr = headtoevr(rpmhead);
- s->evr = str2id(pool, evr, 1);
- s->vendor = str2id(pool, headstring(rpmhead, TAG_VENDOR), 1);
+ s->evr = pool_str2id(pool, evr, 1);
+ s->vendor = pool_str2id(pool, headstring(rpmhead, TAG_VENDOR), 1);
s->provides = makedeps(pool, repo, rpmhead, TAG_PROVIDENAME, TAG_PROVIDEVERSION, TAG_PROVIDEFLAGS, 0);
if ((flags & RPM_ADD_NO_FILELIST) == 0)
s->provides = addfileprovides(pool, repo, data, s, rpmhead, s->provides);
if (s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s->requires = makedeps(pool, repo, rpmhead, TAG_REQUIRENAME, TAG_REQUIREVERSION, TAG_REQUIREFLAGS, (flags & RPM_ADD_NO_RPMLIBREQS) ? MAKEDEPS_NO_RPMLIB : 0);
s->conflicts = makedeps(pool, repo, rpmhead, TAG_CONFLICTNAME, TAG_CONFLICTVERSION, TAG_CONFLICTFLAGS, 0);
s->obsoletes = makedeps(pool, repo, rpmhead, TAG_OBSOLETENAME, TAG_OBSOLETEVERSION, TAG_OBSOLETEFLAGS, 0);
if (ISRELDEP(name))
name = copyreldep(pool, frompool, name);
else
- name = str2id(pool, id2str(frompool, name), 1);
+ name = pool_str2id(pool, pool_id2str(frompool, name), 1);
if (ISRELDEP(evr))
evr = copyreldep(pool, frompool, evr);
else
- evr = str2id(pool, id2str(frompool, evr), 1);
- return rel2id(pool, name, evr, rd->flags, 1);
+ evr = pool_str2id(pool, pool_id2str(frompool, evr), 1);
+ return pool_rel2id(pool, name, evr, rd->flags, 1);
}
static Offset
if (ISRELDEP(id))
id = copyreldep(pool, frompool, id);
else
- id = str2id(pool, id2str(frompool, id), 1);
+ id = pool_str2id(pool, pool_id2str(frompool, id), 1);
*ida++ = id;
}
*ida = 0;
if (parent)
parent = copydir(pool, data, fromspool, fromdata, parent, cache);
if (fromspool != &pool->ss)
- compid = str2id(pool, stringpool_id2str(fromspool, compid), 1);
+ compid = pool_str2id(pool, stringpool_id2str(fromspool, compid), 1);
compid = dirpool_add_dir(&data->dirpool, parent, compid, 1);
if (cache)
{
keyname = key->name;
if (keyname >= ID_NUM_INTERNAL)
- keyname = str2id(pool, id2str(frompool, keyname), 1);
+ keyname = pool_str2id(pool, pool_id2str(frompool, keyname), 1);
switch(key->type)
{
case REPOKEY_TYPE_ID:
if (ISRELDEP(id))
id = copyreldep(pool, frompool, id);
else
- id = str2id(pool, stringpool_id2str(fromspool, id), 1);
+ id = pool_str2id(pool, stringpool_id2str(fromspool, id), 1);
}
if (key->type == REPOKEY_TYPE_ID)
repodata_set_id(data, handle, keyname, id);
if (ISRELDEP(id))
break; /* can't do those at the moment */
if (pool != frompool || fromdata->localpool)
- id = str2id(pool, stringpool_id2str(fromspool, id), 1);
+ id = pool_str2id(pool, stringpool_id2str(fromspool, id), 1);
repodata_add_idarray(data, handle, keyname, id);
break;
default:
else
{
if (r->name)
- s->name = str2id(pool, id2str(fromrepo->pool, r->name), 1);
+ s->name = pool_str2id(pool, pool_id2str(fromrepo->pool, r->name), 1);
if (r->evr)
- s->evr = str2id(pool, id2str(fromrepo->pool, r->evr), 1);
+ s->evr = pool_str2id(pool, pool_id2str(fromrepo->pool, r->evr), 1);
if (r->arch)
- s->arch = str2id(pool, id2str(fromrepo->pool, r->arch), 1);
+ s->arch = pool_str2id(pool, pool_id2str(fromrepo->pool, r->arch), 1);
if (r->vendor)
- s->vendor = str2id(pool, id2str(fromrepo->pool, r->vendor), 1);
+ s->vendor = pool_str2id(pool, pool_id2str(fromrepo->pool, r->vendor), 1);
}
s->provides = copydeps(pool, repo, r->provides, fromrepo);
s->requires = copydeps(pool, repo, r->requires, fromrepo);
Id *rpmdbid;
if (a->name != b->name)
- return strcmp(id2str(pool, a->name), id2str(pool, b->name));
+ return strcmp(pool_id2str(pool, a->name), pool_id2str(pool, b->name));
rpmdbid = repo->rpmdbid;
return rpmdbid[(a - pool->solvables) - repo->start] - rpmdbid[(b - pool->solvables) - repo->start];
}
sprintf(evrbuf, "%02x%02x%02x%02x-%02x%02x%02x%02x", dig->pubkey.signid[4], dig->pubkey.signid[5], dig->pubkey.signid[6], dig->pubkey.signid[7], dig->pubkey.time[0], dig->pubkey.time[1], dig->pubkey.time[2], dig->pubkey.time[3]);
repodata_set_num(data, s - s->repo->pool->solvables, SOLVABLE_BUILDTIME, btime);
- s->name = str2id(pool, "gpg-pubkey", 1);
- s->evr = str2id(pool, evrbuf, 1);
+ s->name = pool_str2id(pool, "gpg-pubkey", 1);
+ s->evr = pool_str2id(pool, evrbuf, 1);
s->arch = 1;
for (i = 0; i < 8; i++)
sprintf(keyid + 2 * i, "%02x", dig->pubkey.signid[i]);
#if 0
fprintf(stderr, "evr: %s\n", pd->content);
#endif
- return str2id(pool, pd->content, 1);
+ return pool_str2id(pool, pd->content, 1);
}
pd->acontent = l + 256;
}
sprintf(pd->content, "%s:%s", k, n);
- name = str2id(pool, pd->content, 1);
+ name = pool_str2id(pool, pd->content, 1);
}
else
- name = str2id(pool, (char *)n, 1);
+ name = pool_str2id(pool, (char *)n, 1);
if (f)
{
Id evr = makeevr_atts(pool, pd, atts);
if (!strcmp(f, flagtab[flags]))
break;
flags = flags < 6 ? flags + 1 : 0;
- id = rel2id(pool, name, evr, flags, 1);
+ id = pool_rel2id(pool, name, evr, flags, 1);
}
else
id = name;
#if 0
- fprintf(stderr, "new dep %s%s%s\n", id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
+ fprintf(stderr, "new dep %s%s%s\n", pool_id2str(pool, d), id2rel(pool, d), id2evr(pool, d));
#endif
return repo_addid_dep(pd->common.repo, olddeps, id, marker);
}
else if (!strcmp(sarch, "nosrc.rpm"))
repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, ARCH_NOSRC);
else
- repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, strn2id(pool, sarch, strlen(sarch) - 4, 1));
- evr = id2str(pool, s->evr);
+ repodata_set_constantid(data, handle, SOLVABLE_SOURCEARCH, pool_strn2id(pool, sarch, strlen(sarch) - 4, 1));
+ evr = pool_id2str(pool, s->evr);
if (evr && !strncmp(sevr, evr, sarch - sevr - 1) && evr[sarch - sevr - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCEEVR);
else
- repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, strn2id(pool, sevr, sarch - sevr - 1, 1));
- name = id2str(pool, s->name);
+ repodata_set_id(data, handle, SOLVABLE_SOURCEEVR, pool_strn2id(pool, sevr, sarch - sevr - 1, 1));
+ name = pool_id2str(pool, s->name);
if (name && !strncmp(sourcerpm, name, sevr - sourcerpm - 1) && name[sevr - sourcerpm - 1] == 0)
repodata_set_void(data, handle, SOLVABLE_SOURCENAME);
else
- repodata_set_id(data, handle, SOLVABLE_SOURCENAME, strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
+ repodata_set_id(data, handle, SOLVABLE_SOURCENAME, pool_strn2id(pool, sourcerpm, sevr - sourcerpm - 1, 1));
}
/*-----------------------------------------------*/
{
case STATE_SOLVABLE:
if (pd->kind && !s->name) /* add namespace in case of NULL name */
- s->name = str2id(pool, join2(pd->kind, ":", ""), 1);
+ s->name = pool_str2id(pool, join2(pd->kind, ":", ""), 1);
if (!s->arch)
s->arch = ARCH_NOARCH;
if (!s->evr)
s->evr = ID_EMPTY; /* some patterns have this */
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
s->supplements = repo_fix_supplements(repo, s->provides, s->supplements, pd->freshens);
s->conflicts = repo_fix_conflicts(repo, s->conflicts);
pd->freshens = 0;
break;
case STATE_NAME:
if (pd->kind)
- s->name = str2id(pool, join2(pd->kind, ":", pd->content), 1);
+ s->name = pool_str2id(pool, join2(pd->kind, ":", pd->content), 1);
else
- s->name = str2id(pool, pd->content, 1);
+ s->name = pool_str2id(pool, pd->content, 1);
break;
case STATE_ARCH:
- s->arch = str2id(pool, pd->content, 1);
+ s->arch = pool_str2id(pool, pd->content, 1);
break;
case STATE_VENDOR:
- s->vendor = str2id(pool, pd->content, 1);
+ s->vendor = pool_str2id(pool, pd->content, 1);
break;
case STATE_RPM_GROUP:
repodata_set_poolstr(pd->data, handle, SOLVABLE_GROUP, pd->content);
}
case STATE_FILE:
#if 0
- id = str2id(pool, pd->content, 1);
+ id = pool_str2id(pool, pd->content, 1);
s->provides = repo_addid_dep(repo, s->provides, id, SOLVABLE_FILEMARKER);
#endif
if ((p = strrchr(pd->content, '/')) != 0)
if (pd->content[0])
{
repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, str2id(pool, "releasenotes", 1));
+ repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "releasenotes", 1));
}
break;
case STATE_UPDATEURL:
if (pd->content[0])
{
repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, str2id(pool, "update", 1));
+ repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "update", 1));
}
break;
case STATE_OPTIONALURL:
if (pd->content[0])
{
repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, pd->content);
- repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, str2id(pool, "optional", 1));
+ repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pool_str2id(pool, "optional", 1));
}
break;
case STATE_FLAG:
if (line[6] == '/')
{
/* A file dependency. Do not try to parse it */
- id = str2id(pool, line + 6, 1);
+ id = pool_str2id(pool, line + 6, 1);
}
else
{
exit(1);
}
if (kind)
- id = str2id(pool, join2(kind, ":", sp[0]), 1);
+ id = pool_str2id(pool, join2(kind, ":", sp[0]), 1);
else
- id = str2id(pool, sp[0], 1);
+ id = pool_str2id(pool, sp[0], 1);
if (i == 3)
{
evrid = makeevr(pool, sp[2]);
pool_debug(pool, SAT_FATAL, "susetags: unknown relation in %d: '%s'\n", pd->lineno, sp[1]);
exit(1);
}
- id = rel2id(pool, id, evrid, flags + 1, 1);
+ id = pool_rel2id(pool, id, evrid, flags + 1, 1);
}
}
return repo_addid_dep(pd->repo, olddeps, id, marker);
exit(1);
}
- Id name = str2id(pool, sp[0], 1);
+ Id name = pool_str2id(pool, sp[0], 1);
Id evr = makeevr(pool, join2(sp[1], "-", sp[2]));
- Id arch = str2id(pool, sp[3], 1);
+ Id arch = pool_str2id(pool, sp[3], 1);
/* XXX: could record a dep here, depends on where we want to store the data */
if (name == s->name)
repodata_set_void(pd->data, handle, SOLVABLE_SOURCENAME);
if (l == 1 && dir[0] == '.')
l = 0;
if (dir && l)
- repodata_set_id(data, handle, DELTA_LOCATION_DIR, strn2id(pool, dir, l, 1));
+ repodata_set_id(data, handle, DELTA_LOCATION_DIR, pool_strn2id(pool, dir, l, 1));
if ((p = strrchr(file, '.')) != 0)
{
*p = 0;
*p = 0;
}
}
- repodata_set_id(data, handle, DELTA_LOCATION_SUFFIX, str2id(pool, p + 1, 1));
+ repodata_set_id(data, handle, DELTA_LOCATION_SUFFIX, pool_str2id(pool, p + 1, 1));
}
if ((p = strrchr(file, '-')) != 0)
{
p = op;
*p = 0;
}
- repodata_set_id(data, handle, DELTA_LOCATION_EVR, str2id(pool, p + 1, 1));
+ repodata_set_id(data, handle, DELTA_LOCATION_EVR, pool_str2id(pool, p + 1, 1));
}
- repodata_set_id(data, handle, DELTA_LOCATION_NAME, str2id(pool, file, 1));
+ repodata_set_id(data, handle, DELTA_LOCATION_NAME, pool_str2id(pool, file, 1));
}
lastreal = p + 1;
for (p = lastreal; *p; p++)
{
- str = id2str(pool, *p);
+ str = pool_id2str(pool, *p);
if (*str != '/')
lastreal = p + 1;
}
{
char fname_buf[128];
const char *fname;
- str = id2str(pool, *p);
+ str = pool_id2str(pool, *p);
sp = strrchr(str, '/');
/* Need to copy filename now, before we add string that could
realloc the stringspace (and hence invalidate str). */
to do twice (in case we see the same package twice). */
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
s->provides = repo_addid_dep(pd->repo, s->provides,
- rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
/* XXX This uses repo_addid_dep internally, so should also be
harmless to do twice. */
s->supplements = repo_fix_supplements(pd->repo, s->provides, s->supplements, freshens);
Id evr;
if (split(line + 5, sp, 5) != 5)
continue;
- repodata_set_id(data, handle, DELTA_SEQ_NAME, str2id(pool, sp[0], 1));
+ repodata_set_id(data, handle, DELTA_SEQ_NAME, pool_str2id(pool, sp[0], 1));
evr = makeevr(pool, join2(sp[1], "-", sp[2]));
repodata_set_id(data, handle, DELTA_SEQ_EVR, evr);
- /* repodata_set_id(data, handle, DELTA_SEQ_ARCH, str2id(pool, sp[3], 1)); */
+ /* repodata_set_id(data, handle, DELTA_SEQ_ARCH, pool_str2id(pool, sp[3], 1)); */
repodata_set_str(data, handle, DELTA_SEQ_NUM, sp[4]);
repodata_set_id(data, handle, DELTA_BASE_EVR, evr);
continue;
exit(1);
}
handle = repodata_new_handle(data);
- repodata_set_id(data, handle, DELTA_PACKAGE_NAME, str2id(pool, sp[0], 1));
+ repodata_set_id(data, handle, DELTA_PACKAGE_NAME, pool_str2id(pool, sp[0], 1));
repodata_set_id(data, handle, DELTA_PACKAGE_EVR, makeevr(pool, join2(sp[1], "-", sp[2])));
- repodata_set_id(data, handle, DELTA_PACKAGE_ARCH, str2id(pool, sp[3], 1));
+ repodata_set_id(data, handle, DELTA_PACKAGE_ARCH, pool_str2id(pool, sp[3], 1));
repodata_add_flexarray(data, SOLVID_META, REPOSITORY_DELTAINFO, handle);
indelta = 1;
continue;
Id name, evr, arch;
/* we don't use the create flag here as a simple pre-check for existance */
if (pd.kind)
- name = str2id(pool, join2(pd.kind, ":", sp[0]), 0);
+ name = pool_str2id(pool, join2(pd.kind, ":", sp[0]), 0);
else
- name = str2id(pool, sp[0], 0);
+ name = pool_str2id(pool, sp[0], 0);
evr = makeevr(pool, join2(sp[1], "-", sp[2]));
- arch = str2id(pool, sp[3], 0);
+ arch = pool_str2id(pool, sp[3], 0);
if (name && arch)
{
if (repo->start + last_found_pack + 1 < repo->end)
/* normal operation. create a new solvable. */
s = pool_id2solvable(pool, repo_add_solvable(repo));
if (pd.kind)
- s->name = str2id(pool, join2(pd.kind, ":", sp[0]), 1);
+ s->name = pool_str2id(pool, join2(pd.kind, ":", sp[0]), 1);
else
- s->name = str2id(pool, sp[0], 1);
+ s->name = pool_str2id(pool, sp[0], 1);
s->evr = makeevr(pool, join2(sp[1], "-", sp[2]));
- s->arch = str2id(pool, sp[3], 1);
+ s->arch = pool_str2id(pool, sp[3], 1);
s->vendor = defvendor;
createdpkgs = 1;
}
}
continue;
case CTAG('=', 'V', 'n', 'd'): /* vendor */
- s->vendor = str2id(pool, line + 6, 1);
+ s->vendor = pool_str2id(pool, line + 6, 1);
continue;
/* From here it's the attribute tags. */
pool_debug(pool, SAT_FATAL, "susetags: bad location line: %d: %s\n", pd.lineno, line);
exit(1);
}
- repodata_set_location(data, handle, atoi(sp[0]), i == 3 ? sp[2] : id2str(pool, s->arch), sp[1]);
+ repodata_set_location(data, handle, atoi(sp[0]), i == 3 ? sp[2] : pool_id2str(pool, s->arch), sp[1]);
}
continue;
case CTAG('=', 'S', 'r', 'c'):
pool_debug(pool, SAT_FATAL, "susetags: bad =Shr line: %s\n", line + 6);
exit(1);
}
- name = str2id(pool, sp[0], 1);
+ name = pool_str2id(pool, sp[0], 1);
evr = makeevr(pool, join2(sp[1], "-", sp[2]));
- arch = str2id(pool, sp[3], 1);
+ arch = pool_str2id(pool, sp[3], 1);
if (last_found_pack >= pd.nshare)
{
pd.share_with = sat_realloc2(pd.share_with, last_found_pack + 256, sizeof(*pd.share_with));
#if 0
fprintf(stderr, "evr: %s\n", pd->content);
#endif
- return str2id(pool, pd->content, 1);
+ return pool_str2id(pool, pd->content, 1);
}
solvable = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
pd->datanum = pd->solvable - pool->solvables;
- solvable->vendor = str2id(pool, from, 1);
- solvable->evr = str2id(pool, version, 1);
+ solvable->vendor = pool_str2id(pool, from, 1);
+ solvable->evr = pool_str2id(pool, version, 1);
solvable->arch = ARCH_NOARCH;
if (type)
repodata_set_str(pd->data, pd->datanum, SOLVABLE_PATCHCATEGORY, type);
name = atts[1];
}
/* generated Id for name */
- n = str2id(pool, name, 1);
+ n = pool_str2id(pool, name, 1);
rel_id = n;
if (arch)
{
/* generate Id for arch and combine with name */
- a = str2id(pool, arch, 1);
- rel_id = rel2id(pool, n, a, REL_ARCH, 1);
+ a = pool_str2id(pool, arch, 1);
+ rel_id = pool_rel2id(pool, n, a, REL_ARCH, 1);
}
- rel_id = rel2id(pool, rel_id, evr, REL_LT, 1);
+ rel_id = pool_rel2id(pool, rel_id, evr, REL_LT, 1);
solvable->conflicts = repo_addid_dep(pd->repo, solvable->conflicts, rel_id, 0);
case STATE_UPDATES:
break;
case STATE_UPDATE:
- s->provides = repo_addid_dep(repo, s->provides, rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(repo, s->provides, pool_rel2id(pool, s->name, s->evr, REL_EQ, 1), 0);
break;
case STATE_ID:
- s->name = str2id(pool, join2("patch", ":", pd->content), 1);
+ s->name = pool_str2id(pool, join2("patch", ":", pd->content), 1);
break;
/* <title>imlib-1.9.15-6.fc8</title> */
case STATE_TITLE:
#if 0
if (s)
- fprintf(stderr, "solvable %d (%s): key (%d)%s %d\n", s ? s - repo->pool->solvables : 0, s ? id2str(repo->pool, s->name) : "", key->name, id2str(repo->pool, key->name), key->type);
+ fprintf(stderr, "solvable %d (%s): key (%d)%s %d\n", s ? s - repo->pool->solvables : 0, s ? pool_id2str(repo->pool, s->name) : "", key->name, pool_id2str(repo->pool, key->name), key->type);
#endif
return repo_write_collect_needed(cbdata, repo, data, key, kv);
}
for (i = 0; verticals[i]; i++)
if (key->name == verticals[i])
return KEY_STORAGE_VERTICAL_OFFSET;
- keyname = id2str(repo->pool, key->name);
+ keyname = pool_id2str(repo->pool, key->name);
for (i = 0; languagetags[i] != 0; i++)
if (!strncmp(keyname, languagetags[i], strlen(languagetags[i])))
return KEY_STORAGE_VERTICAL_OFFSET;
fprintf(stderr, "dirpoolusage: %d\n", dirpoolusage);
fprintf(stderr, "nkeys: %d\n", target.nkeys);
for (i = 1; i < target.nkeys; i++)
- fprintf(stderr, " %2d: %s[%d] %d %d %d\n", i, id2str(pool, target.keys[i].name), target.keys[i].name, target.keys[i].type, target.keys[i].size, target.keys[i].storage);
+ fprintf(stderr, " %2d: %s[%d] %d %d %d\n", i, pool_id2str(pool, target.keys[i].name), target.keys[i].name, target.keys[i].type, target.keys[i].size, target.keys[i].storage);
#endif
/* copy keys if requested */
/* put mapped ids right into target.keys */
for (i = 1, key = target.keys + i; i < target.nkeys; i++, key++)
{
- key->name = stringpool_str2id(spool, id2str(pool, key->name), 1);
+ key->name = stringpool_str2id(spool, pool_id2str(pool, key->name), 1);
if (key->type == REPOKEY_TYPE_CONSTANTID)
{
- key->type = stringpool_str2id(spool, id2str(pool, key->type), 1);
+ key->type = stringpool_str2id(spool, pool_id2str(pool, key->type), 1);
type_constantid = key->type;
- key->size = stringpool_str2id(spool, id2str(pool, key->size), 1);
+ key->size = stringpool_str2id(spool, pool_id2str(pool, key->size), 1);
}
else
- key->type = stringpool_str2id(spool, id2str(pool, key->type), 1);
+ key->type = stringpool_str2id(spool, pool_id2str(pool, key->type), 1);
}
if (poolusage == 2)
stringpool_freehash(spool); /* free some mem */
if (!s->evr)
s->evr = ID_EMPTY;
if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
- s->provides = repo_addid_dep(pd->repo, s->provides, rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
+ s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
pd->solvable = 0;
break;
case STATE_NAME:
- s->name = str2id(pd->pool, join2("product", ":", pd->content), 1);
+ s->name = pool_str2id(pd->pool, join2("product", ":", pd->content), 1);
break;
case STATE_ARCH:
- s->arch = str2id(pd->pool, pd->content, 1);
+ s->arch = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_SUMMARY:
repodata_set_str(pd->data, pd->handle, langtag(pd, SOLVABLE_SUMMARY, pd->tmplang), pd->content);
pd->tmplang = sat_free((void *)pd->tmplang);
break;
case STATE_VENDOR:
- s->vendor = str2id(pd->pool, pd->content, 1);
+ s->vendor = pool_str2id(pd->pool, pd->content, 1);
break;
case STATE_INSTALLTIME:
repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, atol(pd->content));
{
if (!strncmp(s, "0:", 2) && s[2])
s += 2;
- return str2id(pool, s, 1);
+ return pool_str2id(pool, s, 1);
}
/**
static inline void repodata_set_tstr(Repodata *data, Id handle, const char *attrname, const char *lang, const char *str)
{
Id attrid;
- attrid = str2id(data->repo->pool, join2(attrname, ":", lang), 1);
+ attrid = pool_str2id(data->repo->pool, join2(attrname, ":", lang), 1);
repodata_set_str(data, handle, attrid, str);
}
s2 = 0;
if (s1 && s2)
{
- r = vercmp(evr1, s1, evr2, s2);
+ r = sat_vercmp(evr1, s1, evr2, s2);
if (r)
return r;
evr1 = s1 + 1;
r = 0;
if (mode != EVRCMP_MATCH || (evr1 != (r1 ? r1 : s1) && evr2 != (r2 ? r2 : s2)))
- r = vercmp(evr1, r1 ? r1 : s1, evr2, r2 ? r2 : s2);
+ r = sat_vercmp(evr1, r1 ? r1 : s1, evr2, r2 ? r2 : s2);
if (r)
return r;
if (r1 && r2)
{
if (s1 != ++r1 && s2 != ++r2)
- r = vercmp(r1, s1, r2, s2);
+ r = sat_vercmp(r1, s1, r2, s2);
}
return r;
}
const char *evr1, *evr2;
if (evr1id == evr2id)
return 0;
- evr1 = id2str(pool, evr1id);
- evr2 = id2str(pool, evr2id);
- return evrcmp_str(pool, evr1, evr2, mode);
+ evr1 = pool_id2str(pool, evr1id);
+ evr2 = pool_id2str(pool, evr2id);
+ return pool_evrcmp_str(pool, evr1, evr2, mode);
}
int
const char *r1;
int r;
- evr1 = id2str(pool, evrid);
+ evr1 = pool_id2str(pool, evrid);
for (s1 = evr1; *s1 >= '0' && *s1 <= '9'; s1++)
;
if (s1 != evr1 && *s1 == ':')
{
if (epoch)
{
- r = vercmp(evr1, s1, epoch, epoch + strlen(epoch));
+ r = sat_vercmp(evr1, s1, epoch, epoch + strlen(epoch));
if (r)
return r;
}
r1 = s1;
if (version)
{
- r = vercmp(evr1, r1 ? r1 : s1, version, version + strlen(version));
+ r = sat_vercmp(evr1, r1 ? r1 : s1, version, version + strlen(version));
if (r)
return r;
}
{
if (!r1)
return -1;
- r = vercmp(r1 + 1, s1, release, release + strlen(release));
+ r = sat_vercmp(r1 + 1, s1, release, release + strlen(release));
if (r)
return r;
}
extern int pool_evrmatch(const Pool *pool, Id evrid, const char *epoch, const char *version, const char *release);
/* obsolete, do not use in new code */
+#ifdef OBSOLETE_INTERFACE
static inline int vercmp(const char *s1, const char *q1, const char *s2, const char *q2)
{
return sat_vercmp(s1, q1, s2, q2);
{
return pool_evrmatch(pool, evrid, epoch, version, release);
}
+#endif
#ifdef __cplusplus
}
const char *na, *nb;
/* different names. We use real strcmp here so that the result
* is not depending on some random solvable order */
- na = id2str(pool, sa->name);
- nb = id2str(pool, sb->name);
+ na = pool_id2str(pool, sa->name);
+ nb = pool_id2str(pool, sb->name);
return strcmp(na, nb);
}
/* the same name, bring installed solvables to the front */
s = pool->solvables + plist->elements[i];
POOL_DEBUG(SAT_DEBUG_POLICY, "- %s[%s]\n",
- solvable2str(pool, s),
+ pool_solvable2str(pool, s),
(pool->installed && s->repo == pool->installed) ? "installed" : "not installed");
if (!best) /* if no best yet, the current is best */
if (best->evr != s->evr) /* compare evr */
{
- if (evrcmp(pool, best->evr, s->evr, EVRCMP_COMPARE) < 0)
+ if (pool_evrcmp(pool, best->evr, s->evr, EVRCMP_COMPARE) < 0)
best = s;
}
}
int ret = 0;
if (!(ignore & POLICY_ILLEGAL_DOWNGRADE) && !solv->allowdowngrade)
{
- if (is->name == s->name && evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE) > 0)
+ if (is->name == s->name && pool_evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE) > 0)
ret |= POLICY_ILLEGAL_DOWNGRADE;
}
if (!(ignore & POLICY_ILLEGAL_ARCHCHANGE) && !solv->allowarchchange)
ps = pool->solvables + p;
if (s->name == ps->name) /* name match */
{
- if (!allow_all && !solv->allowdowngrade && evrcmp(pool, s->evr, ps->evr, EVRCMP_COMPARE) > 0)
+ if (!allow_all && !solv->allowdowngrade && pool_evrcmp(pool, s->evr, ps->evr, EVRCMP_COMPARE) > 0)
continue;
}
else if (!solv->noupdateprovide && ps->obsoletes) /* provides/obsoletes combination ? */
return 1;
if (flags != 2 && flags != 5)
flags ^= 5;
- if ((flags & (1 << (1 + evrcmp(pool, s->evr, evr, EVRCMP_DEPCMP)))) != 0)
+ if ((flags & (1 << (1 + pool_evrcmp(pool, s->evr, evr, EVRCMP_DEPCMP)))) != 0)
return 1;
return 0;
}
else
{
int f = flags == 5 ? 5 : flags == 2 ? pflags : (flags ^ 5) & (pflags | 5);
- if ((f & (1 << (1 + evrcmp(pool, pevr, evr, EVRCMP_DEPCMP)))) != 0)
+ if ((f & (1 << (1 + pool_evrcmp(pool, pevr, evr, EVRCMP_DEPCMP)))) != 0)
return 1;
}
return 0;
{
/* simple version comparison relation */
#if 0
- POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: what provides %s?\n", dep2str(pool, name));
+ POOL_DEBUG(SAT_DEBUG_STATS, "addrelproviders: what provides %s?\n", pool_dep2str(pool, name));
#endif
pp = pool_whatprovides_ptr(pool, name);
while (ISRELDEP(name))
queue_push(&plist, p);
}
/* make our system solvable provide all unknown rpmlib() stuff */
- if (plist.count == 0 && !strncmp(id2str(pool, name), "rpmlib(", 7))
+ if (plist.count == 0 && !strncmp(pool_id2str(pool, name), "rpmlib(", 7))
queue_push(&plist, SYSTEMSOLVABLE);
}
/* add providers to whatprovides */
if (MAPTST(&csf->seen, dep))
continue;
MAPSET(&csf->seen, dep);
- s = id2str(pool, dep);
+ s = pool_id2str(pool, dep);
if (*s != '/')
continue;
csf->ids = sat_extend(csf->ids, csf->nfiles, 1, sizeof(Id), SEARCHFILES_BLOCK);
{
#if 0
for (i = 0; i < cbd->nfiles; i++)
- if (!MAPTST(&cbd->providedids, cbd->ids[i]) && !repodata_filelistfilter_matches(data, id2str(pool, cbd->ids[i])))
- printf("need complete filelist because of %s\n", id2str(pool, cbd->ids[i]));
+ if (!MAPTST(&cbd->providedids, cbd->ids[i]) && !repodata_filelistfilter_matches(data, pool_id2str(pool, cbd->ids[i])))
+ printf("need complete filelist because of %s\n", pool_id2str(pool, cbd->ids[i]));
#endif
for (i = 0; i < cbd->nfiles; i++)
- if (!MAPTST(&cbd->providedids, cbd->ids[i]) && !repodata_filelistfilter_matches(data, id2str(pool, cbd->ids[i])))
+ if (!MAPTST(&cbd->providedids, cbd->ids[i]) && !repodata_filelistfilter_matches(data, pool_id2str(pool, cbd->ids[i])))
break;
if (i < cbd->nfiles)
incomplete = 1;
{
#if 0
for (i = 0; i < sf.nfiles; i++)
- POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in filelist\n", id2str(pool, sf.ids[i]));
+ POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in filelist\n", pool_id2str(pool, sf.ids[i]));
#endif
pool_addfileprovides_search(pool, &cbd, &sf, 0);
if (idp)
{
#if 0
for (i = 0; i < isf.nfiles; i++)
- POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in installed filelist\n", id2str(pool, isf.ids[i]));
+ POOL_DEBUG(SAT_DEBUG_STATS, "looking up %s in installed filelist\n", pool_id2str(pool, isf.ids[i]));
#endif
if (installed)
pool_addfileprovides_search(pool, &cbd, &isf, installed);
if (!lang)
return id;
- n = id2str(pool, id);
+ n = pool_id2str(pool, id);
l = strlen(n) + strlen(lang) + 2;
if (l > sizeof(buf))
p = sat_malloc(strlen(n) + strlen(lang) + 2);
else
p = buf;
sprintf(p, "%s:%s", n, lang);
- id = str2id(pool, p, create);
+ id = pool_str2id(pool, p, create);
if (p != buf)
free(p);
return id;
if (data->localpool)
compstr = stringpool_id2str(&data->spool, comp);
else
- compstr = id2str(data->repo->pool, comp);
+ compstr = pool_id2str(data->repo->pool, comp);
compl = strlen(compstr);
for (i = mptree[mp].child; i; i = mptree[i].sibling)
if (mptree[i].compl == compl && !strncmp(mptree[i].comp, compstr, compl))
{
int ispatch = 0; /* see solver.c patch handling */
- if (!strncmp("patch:", id2str(pool, s->name), 6))
+ if (!strncmp("patch:", pool_id2str(pool, s->name), 6))
ispatch = 1;
conp = s->repo->idarraydata + s->conflicts;
while ((con = *conp++) != 0)
p = conflicts->elements[i + 1];
md5 = conflicts->elements[i + 2];
q = conflicts->elements[i + 3];
- id = rel2id(pool, fn, md5, REL_FILECONFLICT, 1);
+ id = pool_rel2id(pool, fn, md5, REL_FILECONFLICT, 1);
s = pool->solvables + p;
if (!s->repo)
continue;
}
/* obsolete, do not use anymore */
+#ifdef OBSOLETE_INTERFACE
static inline const char *solvable2str(Pool *pool, Solvable *s)
{
return pool_solvable2str(pool, s);
{
return pool_solvable2str(pool, pool->solvables + p);
}
+#endif
void pool_set_languages(Pool *pool, const char **languages, int nlanguages);
Id pool_id2langid(Pool *pool, Id id, const char *lang, int create);
l = strcspn(arch, ":=>");
if (l)
{
- id = strn2id(pool, arch, l, 1);
+ id = pool_strn2id(pool, arch, l, 1);
if (id > lastarch)
{
id2arch = sat_realloc2(id2arch, (id + 255 + 1), sizeof(Id));
return ARCHCOLOR_ALL;
if (!pool->id2color)
pool->id2color = sat_calloc(pool->lastarch + 1, 1);
- s = id2str(pool, arch);
+ s = pool_id2str(pool, arch);
if (arch == ARCH_NOARCH || arch == ARCH_ALL)
color = ARCHCOLOR_ALL;
else if (!strcmp(s, "s390x") || strstr(s, "64"))
{
Reldep *rd = GETRELDEP(pool, id);
/* add 2 for parens */
- l += 2 + dep2strlen(pool, rd->name) + strlen(id2rel(pool, id));
+ l += 2 + dep2strlen(pool, rd->name) + strlen(pool_id2rel(pool, id));
id = rd->evr;
}
return l + strlen(pool->ss.stringspace + pool->ss.strings[id]);
*p++ = '(';
dep2strcpy(pool, p, rd->name, rd->flags);
p += strlen(p);
- strcpy(p, id2rel(pool, id));
+ strcpy(p, pool_id2rel(pool, id));
p += strlen(p);
dep2strcpy(pool, p, rd->evr, rd->flags);
strcat(p, ")");
*p = 0;
return;
}
- strcpy(p, id2rel(pool, id));
+ strcpy(p, pool_id2rel(pool, id));
p += strlen(p);
id = rd->evr;
oldrel = rd->flags;
/* deprecated names, do not use in new code */
+#ifdef OBSOLETE_INTERFACE
static inline Id str2id(Pool *pool, const char *str, int create)
{
return pool_str2id(pool, str, create);
{
return pool_dep2str(pool, id);
}
+#endif
#endif /* LIBSOLV_POOLID_H */
for (i = 0; i < pool->vendormap.count; i += 2)
if (pool->vendormap.elements[i] == vendor)
return pool->vendormap.elements[i + 1];
- vstr = id2str(pool, vendor);
+ vstr = pool_id2str(pool, vendor);
m = 1;
mask = 0;
for (v = pool->vendorclasses; ; v++)
id = repo->idarraydata[i];
if (ISRELDEP(id))
continue;
- dep = (char *)id2str(pool, id);
+ dep = (char *)pool_id2str(pool, id);
if (!strncmp(dep, "locale(", 7) && strlen(dep) < sizeof(buf) - 2)
{
idp = 0;
if ((p = strchr(dep, ':')) != 0 && p != dep)
{
*p++ = 0;
- idp = str2id(pool, dep, 1);
+ idp = pool_str2id(pool, dep, 1);
dep = p;
}
id = 0;
*p++ = 0;
#if 0
strncpy(dep - 9, "language:", 9);
- idl = str2id(pool, dep - 9, 1);
+ idl = pool_str2id(pool, dep - 9, 1);
#else
- idl = str2id(pool, dep, 1);
- idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
+ idl = pool_str2id(pool, dep, 1);
+ idl = pool_rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
#endif
if (id)
- id = rel2id(pool, id, idl, REL_OR, 1);
+ id = pool_rel2id(pool, id, idl, REL_OR, 1);
else
id = idl;
dep = p;
*p = 0;
#if 0
strncpy(dep - 9, "language:", 9);
- idl = str2id(pool, dep - 9, 1);
+ idl = pool_str2id(pool, dep - 9, 1);
#else
- idl = str2id(pool, dep, 1);
- idl = rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
+ idl = pool_str2id(pool, dep, 1);
+ idl = pool_rel2id(pool, NAMESPACE_LANGUAGE, idl, REL_NAMESPACE, 1);
#endif
if (id)
- id = rel2id(pool, id, idl, REL_OR, 1);
+ id = pool_rel2id(pool, id, idl, REL_OR, 1);
else
id = idl;
}
if (idp)
- id = rel2id(pool, idp, id, REL_AND, 1);
+ id = pool_rel2id(pool, idp, id, REL_AND, 1);
if (id)
supplements = repo_addid_dep(repo, supplements, id, 0);
}
strcpy(buf, dep);
p = buf + (p - dep);
*p++ = 0;
- idp = str2id(pool, buf, 1);
+ idp = pool_str2id(pool, buf, 1);
/* strip trailing slashes */
l = strlen(p);
while (l > 1 && p[l - 1] == '/')
p[--l] = 0;
- id = str2id(pool, p, 1);
- id = rel2id(pool, idp, id, REL_WITH, 1);
- id = rel2id(pool, NAMESPACE_SPLITPROVIDES, id, REL_NAMESPACE, 1);
+ 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);
}
}
id = repo->idarraydata[i];
if (ISRELDEP(id))
continue;
- dep = (char *)id2str(pool, id);
+ 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))
if (p && p != buf + 9 && strchr(p + 1, ':'))
{
*p++ = 0;
- idp = str2id(pool, buf + 9, 1);
+ idp = pool_str2id(pool, buf + 9, 1);
p[strlen(p) - 1] = 0;
- id = str2id(pool, p, 1);
- id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
- id = rel2id(pool, idp, id, REL_AND, 1);
+ 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 = str2id(pool, p, 1);
- id = rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
+ id = pool_str2id(pool, p, 1);
+ id = pool_rel2id(pool, NAMESPACE_MODALIAS, id, REL_NAMESPACE, 1);
}
if (id)
repo->idarraydata[i] = id;
continue;
}
*p++ = 0;
- idp = str2id(pool, dep, 1);
+ idp = pool_str2id(pool, dep, 1);
if (id)
- id = rel2id(pool, id, idp, REL_AND, 1);
+ 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 = str2id(pool, dep, 1);
+ idp = pool_str2id(pool, dep, 1);
if (id)
- id = rel2id(pool, id, idp, REL_AND, 1);
+ id = pool_rel2id(pool, id, idp, REL_AND, 1);
else
id = idp;
}
strcpy(buf, dep + 11);
if ((p = strrchr(buf, ')')) != 0)
*p = 0;
- id = str2id(pool, buf, 1);
- id = rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1);
+ id = pool_str2id(pool, buf, 1);
+ id = pool_rel2id(pool, NAMESPACE_FILESYSTEM, id, REL_NAMESPACE, 1);
repo->idarraydata[i] = id;
}
}
if (!idsupp)
idsupp = repo->idarraydata[i];
else
- idsupp = rel2id(pool, idsupp, repo->idarraydata[i], REL_OR, 1);
+ 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 = rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1);
+ idfresh = pool_rel2id(pool, idfresh, repo->idarraydata[i], REL_OR, 1);
}
if (!idsupp)
idsupp = idfresh;
else
- idsupp = rel2id(pool, idsupp, idfresh, REL_AND, 1);
+ idsupp = pool_rel2id(pool, idsupp, idfresh, REL_AND, 1);
supplements = repo_addid_dep(repo, 0, idsupp, 0);
}
return supplements;
id = repo->idarraydata[i];
if (ISRELDEP(id))
continue;
- dep = (char *)id2str(pool, id);
+ 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 = str2id(pool, buf, 1);
- id = rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1);
+ id = pool_str2id(pool, buf, 1);
+ id = pool_rel2id(pool, NAMESPACE_OTHERPROVIDERS, id, REL_NAMESPACE, 1);
repo->idarraydata[i] = id;
}
}
switch (keyname)
{
case SOLVABLE_NAME:
- return id2str(pool, pool->solvables[entry].name);
+ return pool_id2str(pool, pool->solvables[entry].name);
case SOLVABLE_ARCH:
- return id2str(pool, pool->solvables[entry].arch);
+ return pool_id2str(pool, pool->solvables[entry].arch);
case SOLVABLE_EVR:
- return id2str(pool, pool->solvables[entry].evr);
+ return pool_id2str(pool, pool->solvables[entry].evr);
case SOLVABLE_VENDOR:
- return id2str(pool, pool->solvables[entry].vendor);
+ return pool_id2str(pool, pool->solvables[entry].vendor);
}
}
for (i = 0, data = repo->repodata; i < repo->nrepodata; i++, data++)
case SOLVABLE_ARCH:
case SOLVABLE_EVR:
case SOLVABLE_VENDOR:
- repo_set_id(repo, p, keyname, str2id(repo->pool, str, 1));
+ repo_set_id(repo, p, keyname, pool_str2id(repo->pool, str, 1));
return;
}
}
case SOLVABLE_ARCH:
case SOLVABLE_EVR:
case SOLVABLE_VENDOR:
- repo_set_id(repo, p, keyname, str2id(repo->pool, str, 1));
+ repo_set_id(repo, p, keyname, pool_str2id(repo->pool, str, 1));
return;
}
}
if (idmap)
id = idmap[id];
else if ((flags & REPO_LOCALPOOL) != 0)
- id = str2id(pool, stringpool_id2str(spool, id), 1);
+ id = pool_str2id(pool, stringpool_id2str(spool, id), 1);
type = read_id(&data, numid);
if (idmap)
type = idmap[type];
else if ((flags & REPO_LOCALPOOL) != 0)
- type = str2id(pool, stringpool_id2str(spool, type), 1);
+ type = pool_str2id(pool, stringpool_id2str(spool, type), 1);
if (type < REPOKEY_TYPE_VOID || type > REPOKEY_TYPE_FLEXARRAY)
{
- pool_debug(pool, SAT_ERROR, "unsupported data type '%s'\n", id2str(pool, type));
+ pool_debug(pool, SAT_ERROR, "unsupported data type '%s'\n", pool_id2str(pool, type));
data.error = SOLV_ERROR_UNSUPPORTED;
type = REPOKEY_TYPE_VOID;
}
if (keys[i].type == REPOKEY_TYPE_CONSTANTID && idmap)
keys[i].size = idmap[keys[i].size];
#if 0
- fprintf(stderr, "key %d %s %s %d %d\n", i, id2str(pool,id), id2str(pool, keys[i].type),
+ fprintf(stderr, "key %d %s %s %d %d\n", i, pool_id2str(pool,id), pool_id2str(pool, keys[i].type),
keys[i].size, keys[i].storage);
#endif
}
data.mainschemaoffsets[keyp - 1 - (schemadata + schemata[data.mainschema])] = data.incoredatalen;
#if 0
-printf("=> %s %s %p\n", id2str(pool, keys[key].name), id2str(pool, keys[key].type), s);
+printf("=> %s %s %p\n", pool_id2str(pool, keys[key].name), pool_id2str(pool, keys[key].type), s);
#endif
id = keys[key].name;
if (keys[key].storage == KEY_STORAGE_VERTICAL_OFFSET)
else if (keys[key].storage == KEY_STORAGE_INCORE)
incore_add_id(&data, did);
#if 0
- POOL_DEBUG(SAT_DEBUG_STATS, "%s -> %s\n", id2str(pool, id), id2str(pool, did));
+ POOL_DEBUG(SAT_DEBUG_STATS, "%s -> %s\n", pool_id2str(pool, id), pool_id2str(pool, did));
#endif
break;
case REPOKEY_TYPE_U32:
dp = data_read_u32(dp, &h);
#if 0
- POOL_DEBUG(SAT_DEBUG_STATS, "%s -> %u\n", id2str(pool, id), h);
+ POOL_DEBUG(SAT_DEBUG_STATS, "%s -> %u\n", pool_id2str(pool, id), h);
#endif
if (s && id == RPM_RPMDBID)
{
else if (id == SOLVABLE_ENHANCES)
s->enhances = ido;
#if 0
- POOL_DEBUG(SAT_DEBUG_STATS, "%s ->\n", id2str(pool, id));
+ POOL_DEBUG(SAT_DEBUG_STATS, "%s ->\n", pool_id2str(pool, id));
for (; repo->idarraydata[ido]; ido++)
- POOL_DEBUG(SAT_DEBUG_STATS," %s\n", dep2str(pool, repo->idarraydata[ido]));
+ POOL_DEBUG(SAT_DEBUG_STATS," %s\n", pool_dep2str(pool, repo->idarraydata[ido]));
#endif
break;
case REPOKEY_TYPE_FIXARRAY:
if (data->localpool)
id = stringpool_strn2id(&data->spool, dir, dire - dir, create);
else
- id = strn2id(data->repo->pool, dir, dire - dir, create);
+ id = pool_strn2id(data->repo->pool, dir, dire - dir, create);
if (!id)
return 0;
parent = dirpool_add_dir(&data->dirpool, parent, id, create);
return 0;
if (data->localpool)
return stringpool_id2str(&data->spool, id);
- return id2str(data->repo->pool, id);
+ return pool_id2str(data->repo->pool, id);
}
int
{
if (!id || !data || !data->localpool)
return id;
- return str2id(data->repo->pool, stringpool_id2str(&data->spool, id), create);
+ return pool_str2id(data->repo->pool, stringpool_id2str(&data->spool, id), create);
}
Id
{
if (!id || !data || !data->localpool)
return id;
- return stringpool_str2id(&data->spool, id2str(data->repo->pool, id), create);
+ return stringpool_str2id(&data->spool, pool_id2str(data->repo->pool, id), create);
}
if (data && data->localpool)
kv->str = stringpool_id2str(&data->spool, kv->id);
else
- kv->str = id2str(pool, kv->id);
+ kv->str = pool_id2str(pool, kv->id);
if ((flags & SEARCH_SKIP_KIND) != 0 && key->storage == KEY_STORAGE_SOLVABLE)
{
const char *s;
if (data->localpool)
id = stringpool_str2id(&data->spool, str, 1);
else
- id = str2id(data->repo->pool, str, 1);
+ id = pool_str2id(data->repo->pool, str, 1);
key.name = keyname;
key.type = REPOKEY_TYPE_ID;
key.size = 0;
static inline const char *
evrid2vrstr(Pool *pool, Id evrid)
{
- const char *p, *evr = id2str(pool, evrid);
+ const char *p, *evr = pool_id2str(pool, evrid);
if (!evr)
return evr;
for (p = evr; *p >= '0' && *p <= '9'; p++)
s = pool->solvables + solvid;
if (dir && l)
{
- str = id2str(pool, s->arch);
+ str = pool_id2str(pool, s->arch);
if (!strncmp(dir, str, l) && !str[l])
repodata_set_void(data, solvid, SOLVABLE_MEDIADIR);
else if (!dir[l])
}
}
fp = file;
- str = id2str(pool, s->name);
+ str = pool_id2str(pool, s->name);
l = strlen(str);
if ((!l || !strncmp(fp, str, l)) && fp[l] == '-')
{
if ((!l || !strncmp(fp, str, l)) && fp[l] == '.')
{
fp += l + 1;
- str = id2str(pool, s->arch);
+ str = pool_id2str(pool, s->arch);
l = strlen(str);
if ((!l || !strncmp(fp, str, l)) && !strcmp(fp + l, ".rpm"))
{
if (data->localpool)
id = stringpool_str2id(&data->spool, str, 1);
else
- id = str2id(data->repo->pool, str, 1);
+ id = pool_str2id(data->repo->pool, str, 1);
repodata_add_idarray(data, solvid, keyname, id);
}
}
key = data->keys + *keyp;
#if 0
- fprintf(stderr, "internalize %d(%d):%s:%s\n", entry, entry + data->start, id2str(data->repo->pool, key->name), id2str(data->repo->pool, key->type));
+ fprintf(stderr, "internalize %d(%d):%s:%s\n", entry, entry + data->start, pool_id2str(data->repo->pool, key->name), pool_id2str(data->repo->pool, key->type));
#endif
ndp = dp;
if (oldcount)
&& s->arch != ARCH_NOSRC
&& !pool_installable(pool, s))
{
- POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable\n", solvable2str(pool, s), (Id)(s - pool->solvables));
+ POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable\n", pool_solvable2str(pool, s), (Id)(s - pool->solvables));
addrpmrule(solv, -n, 0, SOLVER_RULE_RPM_NOT_INSTALLABLE, 0);
}
/* yet another SUSE hack, sigh */
- if (pool->nscallback && !strncmp("product:", id2str(pool, s->name), 8))
+ if (pool->nscallback && !strncmp("product:", pool_id2str(pool, s->name), 8))
{
Id buddy = pool->nscallback(pool, pool->nscallbackdata, NAMESPACE_PRODUCTBUDDY, n);
if (buddy > 0 && buddy != SYSTEMSOLVABLE && buddy != n && buddy < pool->nsolvables)
/* didn't find an installed provider: previously broken dependency */
if (!p)
{
- POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "ignoring broken requires %s of installed package %s\n", dep2str(pool, req), solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "ignoring broken requires %s of installed package %s\n", pool_dep2str(pool, req), pool_solvable2str(pool, s));
continue;
}
}
if (!*dp)
{
/* nothing provides req! */
- POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable (%s)\n", solvable2str(pool, s), (Id)(s - pool->solvables), dep2str(pool, req));
+ POOL_DEBUG(SAT_DEBUG_RULE_CREATION, "package %s [%d] is not installable (%s)\n", pool_solvable2str(pool, s), (Id)(s - pool->solvables), pool_dep2str(pool, req));
addrpmrule(solv, -n, 0, SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP, req);
continue;
}
IF_POOLDEBUG (SAT_DEBUG_RULE_CREATION)
{
- POOL_DEBUG(SAT_DEBUG_RULE_CREATION," %s requires %s\n", solvable2str(pool, s), dep2str(pool, req));
+ POOL_DEBUG(SAT_DEBUG_RULE_CREATION," %s requires %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, req));
for (i = 0; dp[i]; i++)
- POOL_DEBUG(SAT_DEBUG_RULE_CREATION, " provided by %s\n", solvid2str(pool, dp[i]));
+ POOL_DEBUG(SAT_DEBUG_RULE_CREATION, " provided by %s\n", pool_solvid2str(pool, dp[i]));
}
/* add 'requires' dependency */
* XXX: we should really handle this different, looking
* at the name is a bad hack
*/
- if (!strncmp("patch:", id2str(pool, s->name), 6))
+ if (!strncmp("patch:", pool_id2str(pool, s->name), 6))
ispatch = 1;
conp = s->repo->idarraydata + s->conflicts;
/* foreach conflicts of 's' */
if (rd->flags == REL_EQ && select == SOLVER_SOLVABLE_NAME)
{
#if !defined(DEBIAN_SEMANTICS)
- const char *evr = id2str(pool, rd->evr);
+ const char *evr = pool_id2str(pool, rd->evr);
if (strchr(evr, '-'))
set |= SOLVER_SETEVR;
else
if (illegal && illegal == POLICY_ILLEGAL_DOWNGRADE && (set & SOLVER_SETEV) != 0)
{
/* it's ok if the EV is different */
- if (evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE_EVONLY) != 0)
+ if (pool_evrcmp(pool, is->evr, s->evr, EVRCMP_COMPARE_EVONLY) != 0)
illegal = 0;
}
if (illegal)
continue;
MAPCLR(&im, ip);
#ifdef CLEANDEPSDEBUG
- printf("hello %s\n", solvable2str(pool, s));
+ printf("hello %s\n", pool_solvable2str(pool, s));
#endif
if (s->requires)
{
if (MAPTST(&im, p))
{
#ifdef CLEANDEPSDEBUG
- printf("%s requires %s\n", solvid2str(pool, ip), solvid2str(pool, p));
+ printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
#endif
queue_push(&iq, p);
}
if (MAPTST(&im, p))
{
#ifdef CLEANDEPSDEBUG
- printf("%s recommends %s\n", solvid2str(pool, ip), solvid2str(pool, p));
+ printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
#endif
queue_push(&iq, p);
}
if (sup)
{
#ifdef CLEANDEPSDEBUG
- printf("%s supplemented\n", solvid2str(pool, ip));
+ printf("%s supplemented\n", pool_solvid2str(pool, ip));
#endif
queue_push(&iq, ip);
}
ip = queue_shift(&iq);
s = pool->solvables + ip;
#ifdef CLEANDEPSDEBUG
- printf("bye %s\n", solvable2str(pool, s));
+ printf("bye %s\n", pool_solvable2str(pool, s));
#endif
if (s->requires)
{
if (MAPTST(&userinstalled, p - installed->start))
continue;
#ifdef CLEANDEPSDEBUG
- printf("%s requires %s\n", solvid2str(pool, ip), solvid2str(pool, p));
+ printf("%s requires %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
#endif
MAPSET(&im, p);
queue_push(&iq, p);
if (MAPTST(&userinstalled, p - installed->start))
continue;
#ifdef CLEANDEPSDEBUG
- printf("%s recommends %s\n", solvid2str(pool, ip), solvid2str(pool, p));
+ printf("%s recommends %s\n", pool_solvid2str(pool, ip), pool_solvid2str(pool, p));
#endif
MAPSET(&im, p);
queue_push(&iq, p);
if (sup)
{
#ifdef CLEANDEPSDEBUG
- printf("%s supplemented\n", solvid2str(pool, ip));
+ printf("%s supplemented\n", pool_solvid2str(pool, ip));
#endif
MAPSET(&im, ip);
queue_push(&iq, ip);
{
const char *n, *e, *a;
char *p;
- n = id2str(pool, s->name);
- e = id2str(pool, s->evr);
- a = id2str(pool, s->arch);
+ n = pool_id2str(pool, s->name);
+ e = pool_id2str(pool, s->evr);
+ a = pool_id2str(pool, s->arch);
p = pool_alloctmpspace(pool, strlen(n) + strlen(e) + strlen(a) + 3);
sprintf(p, "%s-%s.%s", n, e, a);
return p;
static inline const char *
evrid2vrstr(Pool *pool, Id evrid)
{
- const char *p, *evr = id2str(pool, evrid);
+ const char *p, *evr = pool_id2str(pool, evrid);
if (!evr)
return evr;
for (p = evr; *p >= '0' && *p <= '9'; p++)
if (medianrp)
*medianrp = solvable_lookup_num(s, SOLVABLE_MEDIANR, 1);
if (solvable_lookup_void(s, SOLVABLE_MEDIADIR))
- mediadir = id2str(pool, s->arch);
+ mediadir = pool_id2str(pool, s->arch);
else
mediadir = solvable_lookup_str(s, SOLVABLE_MEDIADIR);
if (mediadir)
if (solvable_lookup_void(s, SOLVABLE_MEDIAFILE))
{
const char *name, *evr, *arch;
- name = id2str(pool, s->name);
+ name = pool_id2str(pool, s->name);
evr = evrid2vrstr(pool, s->evr);
- arch = id2str(pool, s->arch);
+ arch = pool_id2str(pool, s->arch);
/* name-vr.arch.rpm */
loc = pool_alloctmpspace(pool, l + strlen(name) + strlen(evr) + strlen(arch) + 7);
if (mediadir)
return prov;
}
}
- return rel2id(pool, s->name, s->evr, REL_EQ, 1);
+ return pool_rel2id(pool, s->name, s->evr, REL_EQ, 1);
}
{
Solvable *s = solv->pool->solvables + vv;
if (v < 0)
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, "conflicting %s (assertion)\n", solvable2str(solv->pool, s));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, "conflicting %s (assertion)\n", pool_solvable2str(solv->pool, s));
else
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, "installing %s (assertion)\n", solvable2str(solv->pool, s));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, "installing %s (assertion)\n", pool_solvable2str(solv->pool, s));
}
continue;
}
{
Solvable *s = solv->pool->solvables + vv;
if (v < 0)
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, "conflicting %s (weak assertion)\n", solvable2str(solv->pool, s));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, "conflicting %s (weak assertion)\n", pool_solvable2str(solv->pool, s));
else
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, "installing %s (weak assertion)\n", solvable2str(solv->pool, s));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, "installing %s (weak assertion)\n", pool_solvable2str(solv->pool, s));
}
continue;
}
IF_POOLDEBUG (SAT_DEBUG_PROPAGATE)
{
if (p > 0)
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> move w%d to %s\n", (pkg == r->w1 ? 1 : 2), solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> move w%d to %s\n", (pkg == r->w1 ? 1 : 2), pool_solvid2str(pool, p));
else
- POOL_DEBUG(SAT_DEBUG_PROPAGATE," -> move w%d to !%s\n", (pkg == r->w1 ? 1 : 2), solvid2str(pool, -p));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE," -> move w%d to !%s\n", (pkg == r->w1 ? 1 : 2), pool_solvid2str(pool, -p));
}
*rp = *next_rp;
IF_POOLDEBUG (SAT_DEBUG_PROPAGATE)
{
if (other_watch > 0)
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> decided to install %s\n", solvid2str(pool, other_watch));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> decided to install %s\n", pool_solvid2str(pool, other_watch));
else
- POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> decided to conflict %s\n", solvid2str(pool, -other_watch));
+ POOL_DEBUG(SAT_DEBUG_PROPAGATE, " -> decided to conflict %s\n", pool_solvid2str(pool, -other_watch));
}
} /* foreach rule involving 'pkg' */
}
p = dq->elements[0];
- POOL_DEBUG(SAT_DEBUG_POLICY, "installing %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "installing %s\n", pool_solvid2str(pool, p));
return setpropagatelearn(solv, level, p, disablerules, ruleid);
}
olevel = level;
if (solv->cleandepsmap.size && MAPTST(&solv->cleandepsmap, i - installed->start))
{
- POOL_DEBUG(SAT_DEBUG_POLICY, "cleandeps erasing %s\n", solvid2str(pool, i));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "cleandeps erasing %s\n", pool_solvid2str(pool, i));
level = setpropagatelearn(solv, level, -i, disablerules, 0);
}
else
{
- POOL_DEBUG(SAT_DEBUG_POLICY, "keeping %s\n", solvid2str(pool, i));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "keeping %s\n", pool_solvid2str(pool, i));
level = setpropagatelearn(solv, level, i, disablerules, r - solv->rules);
}
if (level == 0)
/* simple case, just one package. no need to choose */
p = dq.elements[0];
if (dqs.count)
- POOL_DEBUG(SAT_DEBUG_POLICY, "installing supplemented %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
else
- POOL_DEBUG(SAT_DEBUG_POLICY, "installing recommended %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
queue_push(&solv->recommendations, p);
level = setpropagatelearn(solv, level, p, 0, 0);
continue; /* back to main loop */
p = dqs.elements[i];
if (solv->decisionmap[p] || !MAPTST(&dqmap, p))
continue;
- POOL_DEBUG(SAT_DEBUG_POLICY, "installing supplemented %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
queue_push(&solv->recommendations, p);
olevel = level;
level = setpropagatelearn(solv, level, p, 0, 0);
queue_push(&solv->branches, -level);
}
p = dq.elements[0];
- POOL_DEBUG(SAT_DEBUG_POLICY, "installing recommended %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
queue_push(&solv->recommendations, p);
olevel = level;
level = setpropagatelearn(solv, level, p, 0, 0);
continue;
if (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))
continue;
- POOL_DEBUG(SAT_DEBUG_SOLVER, "keeping orphaned %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_SOLVER, "keeping orphaned %s\n", pool_solvid2str(pool, p));
level = setpropagatelearn(solv, level, p, 0, 0);
installedone = 1;
if (level < olevel)
p = solv->orphaned.elements[i];
if (solv->decisionmap[p])
continue; /* already decided */
- POOL_DEBUG(SAT_DEBUG_SOLVER, "removing orphaned %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_SOLVER, "removing orphaned %s\n", pool_solvid2str(pool, p));
olevel = level;
level = setpropagatelearn(solv, level, -p, 0, 0);
if (level < olevel)
if (solv->branches.elements[i - 1] < 0)
break;
p = solv->branches.elements[i];
- POOL_DEBUG(SAT_DEBUG_SOLVER, "branching with %s\n", solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_SOLVER, "branching with %s\n", pool_solvid2str(pool, p));
queue_empty(&dq);
for (j = i + 1; j < solv->branches.count; j++)
queue_push(&dq, solv->branches.elements[j]);
/* kill old solvable so that we do not loop */
p = solv->branches.elements[lasti];
solv->branches.elements[lasti] = 0;
- POOL_DEBUG(SAT_DEBUG_SOLVER, "minimizing %d -> %d with %s\n", solv->decisionmap[p], lastl, solvid2str(pool, p));
+ POOL_DEBUG(SAT_DEBUG_SOLVER, "minimizing %d -> %d with %s\n", solv->decisionmap[p], lastl, pool_solvid2str(pool, p));
minimizationsteps++;
level = lastl;
if (r->d < 0 && decisionmap[-p])
{
/* rule is now disabled, remove from decisionmap */
- POOL_DEBUG(SAT_DEBUG_SCHUBI, "removing conflict for package %s[%d]\n", solvid2str(pool, -p), -p);
+ POOL_DEBUG(SAT_DEBUG_SCHUBI, "removing conflict for package %s[%d]\n", pool_solvid2str(pool, -p), -p);
queue_push(removed, -p);
queue_push(removed, decisionmap[-p]);
decisionmap[-p] = 0;
}
if (new)
{
- POOL_DEBUG(SAT_DEBUG_SCHUBI, "re-conflicting package %s[%d]\n", solvid2str(pool, -new), -new);
+ POOL_DEBUG(SAT_DEBUG_SCHUBI, "re-conflicting package %s[%d]\n", pool_solvid2str(pool, -new), -new);
decisionmap[-new] = -1;
new = 0;
n = 0; /* redo all rules */
#define SOLVER_SETMASK 0x2f000000
/* old API compatibility, do not use in new code */
-#if 1
+#ifdef OBSOLETE_INTERFACE
+
#define SOLVER_INSTALL_SOLVABLE (SOLVER_INSTALL|SOLVER_SOLVABLE)
#define SOLVER_ERASE_SOLVABLE (SOLVER_ERASE|SOLVER_SOLVABLE)
#define SOLVER_INSTALL_SOLVABLE_NAME (SOLVER_INSTALL|SOLVER_SOLVABLE_NAME)
#define SOLVER_NOOBSOLETES_SOLVABLE (SOLVER_NOOBSOLETES|SOLVER_SOLVABLE)
#define SOLVER_NOOBSOLETES_SOLVABLE_NAME (SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_NAME)
#define SOLVER_NOOBSOLETES_SOLVABLE_PROVIDES (SOLVER_NOOBSOLETES|SOLVER_SOLVABLE_PROVIDES)
-#endif
/* backward compatibility */
#define SOLVER_PROBLEM_UPDATE_RULE SOLVER_RULE_UPDATE
#define SOLVER_PROBLEM_DISTUPGRADE_RULE SOLVER_RULE_DISTUPGRADE
#define SOLVER_PROBLEM_INFARCH_RULE SOLVER_RULE_INFARCH
+#endif
+
extern Solver *solver_create(Pool *pool);
extern void solver_free(Solver *solv);
if (v < 0)
{
s = pool->solvables + -v;
- POOL_DEBUG(type, " !%s [%d]", solvable2str(pool, s), -v);
+ POOL_DEBUG(type, " !%s [%d]", pool_solvable2str(pool, s), -v);
}
else
{
s = pool->solvables + v;
- POOL_DEBUG(type, " %s [%d]", solvable2str(pool, s), v);
+ POOL_DEBUG(type, " %s [%d]", pool_solvable2str(pool, s), v);
}
if (pool->installed && s->repo == pool->installed)
POOL_DEBUG(type, "I");
{
p = solv->decisionq.elements[i];
if (p > 0)
- POOL_DEBUG(type, "%d %d install %s, ", i, solv->decisionmap[p], solvid2str(pool, p));
+ POOL_DEBUG(type, "%d %d install %s, ", i, solv->decisionmap[p], pool_solvid2str(pool, p));
else
- POOL_DEBUG(type, "%d %d conflict %s, ", i, -solv->decisionmap[-p], solvid2str(pool, -p));
+ POOL_DEBUG(type, "%d %d conflict %s, ", i, -solv->decisionmap[-p], pool_solvid2str(pool, -p));
why = solv->decisionq_why.elements[i];
if (why > 0)
{
switch(type)
{
case SOLVER_TRANSACTION_MULTIINSTALL:
- POOL_DEBUG(SAT_DEBUG_RESULT, " multi install %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " multi install %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_MULTIREINSTALL:
- POOL_DEBUG(SAT_DEBUG_RESULT, " multi reinstall %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " multi reinstall %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_INSTALL:
- POOL_DEBUG(SAT_DEBUG_RESULT, " install %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " install %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_REINSTALL:
- POOL_DEBUG(SAT_DEBUG_RESULT, " reinstall %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " reinstall %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_DOWNGRADE:
- POOL_DEBUG(SAT_DEBUG_RESULT, " downgrade %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " downgrade %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_CHANGE:
- POOL_DEBUG(SAT_DEBUG_RESULT, " change %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " change %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_UPGRADE:
case SOLVER_TRANSACTION_OBSOLETES:
- POOL_DEBUG(SAT_DEBUG_RESULT, " upgrade %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " upgrade %s", pool_solvable2str(pool, s));
break;
case SOLVER_TRANSACTION_ERASE:
- POOL_DEBUG(SAT_DEBUG_RESULT, " erase %s", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " erase %s", pool_solvable2str(pool, s));
break;
default:
break;
{
POOL_DEBUG(SAT_DEBUG_RESULT, " (obsoletes");
for (j = 0; j < iq.count; j++)
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s", solvid2str(pool, iq.elements[j]));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s", pool_solvid2str(pool, iq.elements[j]));
POOL_DEBUG(SAT_DEBUG_RESULT, ")");
}
POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
if (solv->decisionmap[solv->recommendations.elements[i]] > 0)
{
if (installed && s->repo == installed)
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (installed)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (installed)\n", pool_solvable2str(pool, s));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (selected)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (selected)\n", pool_solvable2str(pool, s));
}
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s\n", pool_solvable2str(pool, s));
}
POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
}
if (solv->decisionmap[solv->suggestions.elements[i]] > 0)
{
if (installed && s->repo == installed)
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (installed)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (installed)\n", pool_solvable2str(pool, s));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (selected)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (selected)\n", pool_solvable2str(pool, s));
}
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s\n", pool_solvable2str(pool, s));
}
POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
}
{
s = pool->solvables + solv->orphaned.elements[i];
if (solv->decisionmap[solv->orphaned.elements[i]] > 0)
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (kept)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (kept)\n", pool_solvable2str(pool, s));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s (erased)\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s (erased)\n", pool_solvable2str(pool, s));
}
POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
}
static inline
const char *id2strnone(Pool *pool, Id id)
{
- return !id || id == 1 ? "(none)" : id2str(pool, id);
+ return !id || id == 1 ? "(none)" : pool_id2str(pool, id);
}
void
POOL_DEBUG(SAT_DEBUG_RESULT, "%d vendor changes from '%s' to '%s':\n", cnt, id2strnone(pool, classes.elements[i + 2]), id2strnone(pool, classes.elements[i + 3]));
break;
case SOLVER_TRANSACTION_ARCHCHANGE:
- POOL_DEBUG(SAT_DEBUG_RESULT, "%d arch changes from %s to %s:\n", cnt, id2str(pool, classes.elements[i + 2]), id2str(pool, classes.elements[i + 3]));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "%d arch changes from %s to %s:\n", cnt, pool_id2str(pool, classes.elements[i + 2]), pool_id2str(pool, classes.elements[i + 3]));
break;
default:
class = SOLVER_TRANSACTION_IGNORE;
case SOLVER_TRANSACTION_DOWNGRADED:
case SOLVER_TRANSACTION_UPGRADED:
s2 = pool->solvables + transaction_obs_pkg(trans, p);
- POOL_DEBUG(SAT_DEBUG_RESULT, " - %s -> %s\n", solvable2str(pool, s), solvable2str(pool, s2));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - %s -> %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, s2));
break;
case SOLVER_TRANSACTION_VENDORCHANGE:
case SOLVER_TRANSACTION_ARCHCHANGE:
- n = id2str(pool, s->name);
+ n = pool_id2str(pool, s->name);
l = strlen(n);
if (l + linel > sizeof(line) - 3)
{
}
break;
default:
- POOL_DEBUG(SAT_DEBUG_RESULT, " - %s\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - %s\n", pool_solvable2str(pool, s));
break;
}
}
switch (solver_ruleinfo(solv, probr, &source, &target, &dep))
{
case SOLVER_RULE_DISTUPGRADE:
- POOL_DEBUG(SAT_DEBUG_RESULT, "%s does not belong to a distupgrade repository\n", solvid2str(pool, source));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "%s does not belong to a distupgrade repository\n", pool_solvid2str(pool, source));
return;
case SOLVER_RULE_INFARCH:
- POOL_DEBUG(SAT_DEBUG_RESULT, "%s has inferior architecture\n", solvid2str(pool, source));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "%s has inferior architecture\n", pool_solvid2str(pool, source));
return;
case SOLVER_RULE_UPDATE:
- POOL_DEBUG(SAT_DEBUG_RESULT, "problem with installed package %s\n", solvid2str(pool, source));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "problem with installed package %s\n", pool_solvid2str(pool, source));
return;
case SOLVER_RULE_JOB:
POOL_DEBUG(SAT_DEBUG_RESULT, "conflicting requests\n");
return;
case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
- POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides requested %s\n", dep2str(pool, dep));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides requested %s\n", pool_dep2str(pool, dep));
return;
case SOLVER_RULE_RPM:
POOL_DEBUG(SAT_DEBUG_RESULT, "some dependency problem\n");
return;
case SOLVER_RULE_RPM_NOT_INSTALLABLE:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s is not installable\n", solvid2str(pool, source));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s is not installable\n", pool_solvid2str(pool, source));
return;
case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
- POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides %s needed by %s\n", dep2str(pool, dep), solvid2str(pool, source));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "nothing provides %s needed by %s\n", pool_dep2str(pool, dep), pool_solvid2str(pool, source));
return;
case SOLVER_RULE_RPM_SAME_NAME:
- POOL_DEBUG(SAT_DEBUG_RESULT, "cannot install both %s and %s\n", solvid2str(pool, source), solvid2str(pool, target));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "cannot install both %s and %s\n", pool_solvid2str(pool, source), pool_solvid2str(pool, target));
return;
case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
return;
case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
return;
case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
- POOL_DEBUG(SAT_DEBUG_RESULT, "installed package %s obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "installed package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
return;
case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s implicitely obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s implicitely obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
return;
case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s requires %s, but none of the providers can be installed\n", solvid2str(pool, source), dep2str(pool, dep));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s requires %s, but none of the providers can be installed\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
return;
case SOLVER_RULE_RPM_SELF_CONFLICT:
- POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by itself\n", solvid2str(pool, source), dep2str(pool, dep));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "package %s conflicts with %s provided by itself\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
return;
case SOLVER_RULE_UNKNOWN:
case SOLVER_RULE_FEATURE:
{
case SOLVER_INSTALL:
if (select == SOLVER_SOLVABLE && solv->installed && pool->solvables[what].repo == solv->installed)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - do not keep %s installed\n", solvid2str(pool, what));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - do not keep %s installed\n", pool_solvid2str(pool, what));
else if (select == SOLVER_SOLVABLE_PROVIDES)
POOL_DEBUG(SAT_DEBUG_RESULT, " - do not install a solvable %s\n", solver_select2str(pool, select, what));
else
break;
case SOLVER_ERASE:
if (select == SOLVER_SOLVABLE && !(solv->installed && pool->solvables[what].repo == solv->installed))
- POOL_DEBUG(SAT_DEBUG_RESULT, " - do not forbid installation of %s\n", solvid2str(pool, what));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - do not forbid installation of %s\n", pool_solvid2str(pool, what));
else if (select == SOLVER_SOLVABLE_PROVIDES)
POOL_DEBUG(SAT_DEBUG_RESULT, " - do not deinstall all solvables %s\n", solver_select2str(pool, select, what));
else
{
s = pool->solvables + rp;
if (solv->installed && s->repo == solv->installed)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - keep %s despite the inferior architecture\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - keep %s despite the inferior architecture\n", pool_solvable2str(pool, s));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " - install %s despite the inferior architecture\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - install %s despite the inferior architecture\n", pool_solvable2str(pool, s));
}
else if (p == SOLVER_SOLUTION_DISTUPGRADE)
{
s = pool->solvables + rp;
if (solv->installed && s->repo == solv->installed)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - keep obsolete %s\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - keep obsolete %s\n", pool_solvable2str(pool, s));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " - install %s from excluded repository\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - install %s from excluded repository\n", pool_solvable2str(pool, s));
}
else
{
{
int illegal = policy_is_illegal(solv, s, sd, 0);
if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow downgrade of %s to %s\n", solvable2str(pool, s), solvable2str(pool, sd));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow downgrade of %s to %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow architecture change of %s to %s\n", solvable2str(pool, s), solvable2str(pool, sd));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow architecture change of %s to %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
{
if (sd->vendor)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow vendor change from '%s' (%s) to '%s' (%s)\n", id2str(pool, s->vendor), solvable2str(pool, s), id2str(pool, sd->vendor), solvable2str(pool, sd));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow vendor change from '%s' (%s) to '%s' (%s)\n", pool_id2str(pool, s->vendor), pool_solvable2str(pool, s), pool_id2str(pool, sd->vendor), pool_solvable2str(pool, sd));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow vendor change from '%s' (%s) to no vendor (%s)\n", id2str(pool, s->vendor), solvable2str(pool, s), solvable2str(pool, sd));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow vendor change from '%s' (%s) to no vendor (%s)\n", pool_id2str(pool, s->vendor), pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
}
if (!illegal)
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow replacement of %s with %s\n", solvable2str(pool, s), solvable2str(pool, sd));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow replacement of %s with %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
}
else
{
- POOL_DEBUG(SAT_DEBUG_RESULT, " - allow deinstallation of %s\n", solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " - allow deinstallation of %s\n", pool_solvable2str(pool, s));
}
}
}
queue_init(&in);
for (p = 1, s = pool->solvables + p; p < solv->pool->nsolvables; p++, s++)
{
- n = id2str(pool, s->name);
+ n = pool_id2str(pool, s->name);
if (strncmp(n, "patch:", 6) != 0 && strncmp(n, "pattern:", 8) != 0)
continue;
queue_push(&in, p);
solver_trivial_installable(solv, &in, &out);
POOL_DEBUG(SAT_DEBUG_RESULT, "trivial installable status:\n");
for (i = 0; i < in.count; i++)
- POOL_DEBUG(SAT_DEBUG_RESULT, " %s: %d\n", solvid2str(pool, in.elements[i]), out.elements[i]);
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %s: %d\n", pool_solvid2str(pool, in.elements[i]), out.elements[i]);
POOL_DEBUG(SAT_DEBUG_RESULT, "\n");
queue_free(&in);
queue_free(&out);
const char *s;
char *b;
if (select == SOLVER_SOLVABLE)
- return solvid2str(pool, what);
+ return pool_solvid2str(pool, what);
if (select == SOLVER_SOLVABLE_NAME)
- return dep2str(pool, what);
+ return pool_dep2str(pool, what);
if (select == SOLVER_SOLVABLE_PROVIDES)
{
- s = dep2str(pool, what);
+ s = pool_dep2str(pool, what);
b = pool_alloctmpspace(pool, 11 + strlen(s));
sprintf(b, "providing %s", s);
return b;
b = 0;
while ((p = pool->whatprovidesdata[what++]) != 0)
{
- s = solvid2str(pool, p);
+ s = pool_solvid2str(pool, p);
if (b)
b = pool_tmpappend(pool, b, ", ", s);
else
switch (type)
{
case SOLVER_RULE_DISTUPGRADE:
- return pool_tmpjoin(pool, solvid2str(pool, source), " does not belong to a distupgrade repository", 0);
+ return pool_tmpjoin(pool, pool_solvid2str(pool, source), " does not belong to a distupgrade repository", 0);
case SOLVER_RULE_INFARCH:
- return pool_tmpjoin(pool, solvid2str(pool, source), " has inferior architecture", 0);
+ return pool_tmpjoin(pool, pool_solvid2str(pool, source), " has inferior architecture", 0);
case SOLVER_RULE_UPDATE:
- return pool_tmpjoin(pool, "problem with installed package ", solvid2str(pool, source), 0);
+ return pool_tmpjoin(pool, "problem with installed package ", pool_solvid2str(pool, source), 0);
case SOLVER_RULE_JOB:
return "conflicting requests";
case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
- return pool_tmpjoin(pool, "nothing provides requested ", dep2str(pool, dep), 0);
+ return pool_tmpjoin(pool, "nothing provides requested ", pool_dep2str(pool, dep), 0);
case SOLVER_RULE_RPM:
return "some dependency problem";
case SOLVER_RULE_RPM_NOT_INSTALLABLE:
- return pool_tmpjoin(pool, "package ", solvid2str(pool, source), " is not installable");
+ return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is not installable");
case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
- s = pool_tmpjoin(pool, "nothing provides ", dep2str(pool, dep), 0);
- return pool_tmpappend(pool, s, " needed by ", solvid2str(pool, source));
+ s = pool_tmpjoin(pool, "nothing provides ", pool_dep2str(pool, dep), 0);
+ return pool_tmpappend(pool, s, " needed by ", pool_solvid2str(pool, source));
case SOLVER_RULE_RPM_SAME_NAME:
- s = pool_tmpjoin(pool, "cannot install both ", solvid2str(pool, source), 0);
- return pool_tmpappend(pool, s, " and ", solvid2str(pool, target));
+ s = pool_tmpjoin(pool, "cannot install both ", pool_solvid2str(pool, source), 0);
+ return pool_tmpappend(pool, s, " and ", pool_solvid2str(pool, target));
case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
- s = pool_tmpjoin(pool, "package ", solvid2str(pool, source), 0);
- s = pool_tmpappend(pool, s, " conflicts with ", dep2str(pool, dep));
- return pool_tmpappend(pool, s, " provided by ", solvid2str(pool, target));
+ s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
+ s = pool_tmpappend(pool, s, " conflicts with ", pool_dep2str(pool, dep));
+ return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
- s = pool_tmpjoin(pool, "package ", solvid2str(pool, source), 0);
- s = pool_tmpappend(pool, s, " obsoletes ", dep2str(pool, dep));
- return pool_tmpappend(pool, s, " provided by ", solvid2str(pool, target));
+ s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
+ s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep));
+ return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
- s = pool_tmpjoin(pool, "installed package ", solvid2str(pool, source), 0);
- s = pool_tmpappend(pool, s, " obsoletes ", dep2str(pool, dep));
- return pool_tmpappend(pool, s, " provided by ", solvid2str(pool, target));
+ s = pool_tmpjoin(pool, "installed package ", pool_solvid2str(pool, source), 0);
+ s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep));
+ return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
- s = pool_tmpjoin(pool, "package ", solvid2str(pool, source), 0);
- s = pool_tmpappend(pool, s, " implicitely obsoletes ", dep2str(pool, dep));
- return pool_tmpappend(pool, s, " provided by ", solvid2str(pool, target));
+ s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
+ s = pool_tmpappend(pool, s, " implicitely obsoletes ", pool_dep2str(pool, dep));
+ return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
- s = pool_tmpjoin(pool, "package ", solvid2str(pool, source), " requires ");
- return pool_tmpappend(pool, s, dep2str(pool, dep), ", but none of the providers can be installed");
+ s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " requires ");
+ return pool_tmpappend(pool, s, pool_dep2str(pool, dep), ", but none of the providers can be installed");
case SOLVER_RULE_RPM_SELF_CONFLICT:
- s = pool_tmpjoin(pool, "package ", solvid2str(pool, source), " conflicts with ");
- return pool_tmpappend(pool, s, dep2str(pool, dep), " provided by itself");
+ s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " conflicts with ");
+ return pool_tmpappend(pool, s, pool_dep2str(pool, dep), " provided by itself");
default:
return "bad problem rule type";
}
{
Solvable *s = pool->solvables + rp;
if (solv->installed && s->repo == solv->installed)
- return pool_tmpjoin(pool, "keep ", solvable2str(pool, s), " despite the inferior architecture");
+ return pool_tmpjoin(pool, "keep ", pool_solvable2str(pool, s), " despite the inferior architecture");
else
- return pool_tmpjoin(pool, "install ", solvable2str(pool, s), " despite the inferior architecture");
+ return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the inferior architecture");
}
else if (p == SOLVER_SOLUTION_DISTUPGRADE)
{
Solvable *s = pool->solvables + rp;
if (solv->installed && s->repo == solv->installed)
- return pool_tmpjoin(pool, "keep obsolete ", solvable2str(pool, s), 0);
+ return pool_tmpjoin(pool, "keep obsolete ", pool_solvable2str(pool, s), 0);
else
- return pool_tmpjoin(pool, "install ", solvable2str(pool, s), " from excluded repository");
+ return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " from excluded repository");
}
else if (p > 0 && rp == 0)
- return pool_tmpjoin(pool, "allow deinstallation of ", solvid2str(pool, p), 0);
+ return pool_tmpjoin(pool, "allow deinstallation of ", pool_solvid2str(pool, p), 0);
else if (p > 0 && rp > 0)
{
- const char *sp = solvid2str(pool, p);
- const char *srp = solvid2str(pool, rp);
+ const char *sp = pool_solvid2str(pool, p);
+ const char *srp = pool_solvid2str(pool, rp);
const char *str = pool_tmpjoin(pool, "allow replacement of ", sp, 0);
return pool_tmpappend(pool, str, " with ", srp);
}
const char *str;
if (illegal == POLICY_ILLEGAL_DOWNGRADE)
{
- str = pool_tmpjoin(pool, "downgrade of ", solvable2str(pool, s), 0);
- return pool_tmpappend(pool, str, " to ", solvable2str(pool, rs));
+ str = pool_tmpjoin(pool, "downgrade of ", pool_solvable2str(pool, s), 0);
+ return pool_tmpappend(pool, str, " to ", pool_solvable2str(pool, rs));
}
if (illegal == POLICY_ILLEGAL_ARCHCHANGE)
{
- str = pool_tmpjoin(pool, "architecture change of ", solvable2str(pool, s), 0);
- return pool_tmpappend(pool, str, " to ", solvable2str(pool, rs));
+ str = pool_tmpjoin(pool, "architecture change of ", pool_solvable2str(pool, s), 0);
+ return pool_tmpappend(pool, str, " to ", pool_solvable2str(pool, rs));
}
if (illegal == POLICY_ILLEGAL_VENDORCHANGE)
{
- str = pool_tmpjoin(pool, "vendor change from '", id2str(pool, s->vendor), "' (");
+ str = pool_tmpjoin(pool, "vendor change from '", pool_id2str(pool, s->vendor), "' (");
if (rs->vendor)
{
- str = pool_tmpappend(pool, str, solvable2str(pool, s), ") to '");
- str = pool_tmpappend(pool, str, id2str(pool, rs->vendor), "' (");
+ str = pool_tmpappend(pool, str, pool_solvable2str(pool, s), ") to '");
+ str = pool_tmpappend(pool, str, pool_id2str(pool, rs->vendor), "' (");
}
else
- str = pool_tmpappend(pool, str, solvable2str(pool, s), ") to no vendor (");
- return pool_tmpappend(pool, str, solvable2str(pool, rs), ")");
+ str = pool_tmpappend(pool, str, pool_solvable2str(pool, s), ") to no vendor (");
+ return pool_tmpappend(pool, str, pool_solvable2str(pool, rs), ")");
}
return "unknown illegal change";
}
return -1;
if (obs->name == s->name)
return 1;
- return strcmp(id2str(pool, oas->name), id2str(pool, obs->name));
+ return strcmp(pool_id2str(pool, oas->name), pool_id2str(pool, obs->name));
}
- r = evrcmp(pool, oas->evr, obs->evr, EVRCMP_COMPARE);
+ r = pool_evrcmp(pool, oas->evr, obs->evr, EVRCMP_COMPARE);
if (r)
return -r; /* highest version first */
return oa - ob;
{
if (s->evr == s2->evr && solvable_identical(s, s2))
return SOLVER_TRANSACTION_REINSTALLED;
- r = evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
+ r = pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
if (r < 0)
return SOLVER_TRANSACTION_UPGRADED;
else if (r > 0)
{
if (s->evr == s2->evr && solvable_identical(s, s2))
return SOLVER_TRANSACTION_REINSTALL;
- r = evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
+ r = pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE);
if (r > 0)
return SOLVER_TRANSACTION_UPGRADE;
else if (r < 0)
if (!s->repo)
return SOLVER_TRANSACTION_IGNORE;
- n = id2str(pool, s->name);
+ n = pool_id2str(pool, s->name);
if (!strncmp(n, "patch:", 6))
return SOLVER_TRANSACTION_IGNORE;
if (!strncmp(n, "pattern:", 8))
return r;
r = a[2] - b[2];
if (r)
- return a[2] && b[2] ? strcmp(id2str(pool, a[2]), id2str(pool, b[2])) : r;
+ return a[2] && b[2] ? strcmp(pool_id2str(pool, a[2]), pool_id2str(pool, b[2])) : r;
r = a[3] - b[3];
if (r)
- return a[3] && b[3] ? strcmp(id2str(pool, a[3]), id2str(pool, b[3])) : r;
+ return a[3] && b[3] ? strcmp(pool_id2str(pool, a[3]), pool_id2str(pool, b[3])) : r;
return 0;
}
sa = pool->solvables + a;
sb = pool->solvables + b;
if (sa->name != sb->name)
- return strcmp(id2str(pool, sa->name), id2str(pool, sb->name));
+ return strcmp(pool_id2str(pool, sa->name), pool_id2str(pool, sb->name));
if (sa->evr != sb->evr)
{
- int r = evrcmp(pool, sa->evr, sb->evr, EVRCMP_COMPARE);
+ int r = pool_evrcmp(pool, sa->evr, sb->evr, EVRCMP_COMPARE);
if (r)
return r;
}
if ((!installed || s->repo != installed) && p > 0)
{
#if 0
- const char *n = id2str(pool, s->name);
+ const char *n = pool_id2str(pool, s->name);
if (!strncmp(n, "patch:", 6))
continue;
if (!strncmp(n, "pattern:", 8))
if (from == to)
return 0;
- /* printf("edge %d(%s) -> %d(%s) type %x\n", from, solvid2str(pool, od->tes[from].p), to, solvid2str(pool, od->tes[to].p), type); */
+ /* printf("edge %d(%s) -> %d(%s) type %x\n", from, pool_solvid2str(pool, od->tes[from].p), to, pool_solvid2str(pool, od->tes[to].p), type); */
te = od->tes + from;
for (i = te->edges; od->edgedata[i]; i += 2)
}
if (!inpre)
continue;
- dep = id2str(pool, req);
+ dep = pool_id2str(pool, req);
if (*dep == '/' && strcmp(dep, "/sbin/ldconfig") != 0)
return 1;
}
int provbyinst;
#if 0
- printf("addsolvableedges %s\n", solvable2str(pool, s));
+ printf("addsolvableedges %s\n", pool_solvable2str(pool, s));
#endif
p = s - pool->solvables;
queue_init(&reqq);
{
provbyinst = 1;
#if 0
- printf("IGNORE inst provides %s by %s\n", dep2str(pool, req), solvable2str(pool, s2));
+ printf("IGNORE inst provides %s by %s\n", pool_dep2str(pool, req), pool_solvable2str(pool, s2));
reqq.count = 0; /* provided by package that stays installed */
break;
#else
if (trans->transaction_installed[reqq.elements[i] - pool->installed->start] == reqq.elements[j])
continue; /* no self edge */
#if 0
- printf("add interrreq uninst->inst edge (%s -> %s -> %s)\n", solvid2str(pool, reqq.elements[i]), dep2str(pool, req), solvid2str(pool, reqq.elements[j]));
+ printf("add interrreq uninst->inst edge (%s -> %s -> %s)\n", pool_solvid2str(pool, reqq.elements[i]), pool_dep2str(pool, req), pool_solvid2str(pool, reqq.elements[j]));
#endif
addedge(od, reqq.elements[i], reqq.elements[j], pre == TYPE_PREREQ ? TYPE_PREREQ_P : TYPE_REQ_P);
}
if (pool->solvables[p].repo != installed)
{
#if 0
- printf("add inst->inst edge choice %d (%s -> %s -> %s)\n", choice, solvid2str(pool, p), dep2str(pool, req), solvid2str(pool, p2));
+ printf("add inst->inst edge choice %d (%s -> %s -> %s)\n", choice, pool_solvid2str(pool, p), pool_dep2str(pool, req), pool_solvid2str(pool, p2));
#endif
addedge(od, p, p2, pre);
}
else
{
#if 0
- printf("add uninst->inst edge choice %d (%s -> %s -> %s)\n", choice, solvid2str(pool, p), dep2str(pool, req), solvid2str(pool, p2));
+ printf("add uninst->inst edge choice %d (%s -> %s -> %s)\n", choice, pool_solvid2str(pool, p), pool_dep2str(pool, req), pool_solvid2str(pool, p2));
#endif
addedge(od, p, p2, pre == TYPE_PREREQ ? TYPE_PREREQ_P : TYPE_REQ_P);
}
}
#endif
#if 0
- printf("add uninst->uninst edge choice %d (%s -> %s -> %s)\n", choice, solvid2str(pool, p), dep2str(pool, req), solvid2str(pool, p2));
+ printf("add uninst->uninst edge choice %d (%s -> %s -> %s)\n", choice, pool_solvid2str(pool, p), pool_dep2str(pool, req), pool_solvid2str(pool, p2));
#endif
addedge(od, p2, p, pre == TYPE_PREREQ ? TYPE_PREREQ_P : TYPE_REQ_P);
}
{
/* deinstall p before installing p2 */
#if 0
- printf("add conflict uninst->inst edge (%s -> %s -> %s)\n", solvid2str(pool, p2), dep2str(pool, con), solvid2str(pool, p));
+ printf("add conflict uninst->inst edge (%s -> %s -> %s)\n", pool_solvid2str(pool, p2), pool_dep2str(pool, con), pool_solvid2str(pool, p));
#endif
addedge(od, p2, p, TYPE_CON);
}
{
/* deinstall p2 before installing p */
#if 0
- printf("add conflict uninst->inst edge (%s -> %s -> %s)\n", solvid2str(pool, p), dep2str(pool, con), solvid2str(pool, p2));
+ printf("add conflict uninst->inst edge (%s -> %s -> %s)\n", pool_solvid2str(pool, p), pool_dep2str(pool, con), pool_solvid2str(pool, p2));
#endif
addedge(od, p, p2, TYPE_CON);
}
{
/* deinstall/update p before installing p2 */
#if 0
- printf("add trigger uninst->inst edge (%s -> %s -> %s)\n", solvid2str(pool, p2), dep2str(pool, tri), solvid2str(pool, p));
+ printf("add trigger uninst->inst edge (%s -> %s -> %s)\n", pool_solvid2str(pool, p2), pool_dep2str(pool, tri), pool_solvid2str(pool, p));
#endif
addedge(od, p2, p, TYPE_CON);
}
{
te = od->tes + cycle[k];
if ((od->edgedata[cycle[k + 1] + 1] & TYPE_BROKEN) != 0)
- POOL_DEBUG(SAT_DEBUG_STATS, "%s ##%x##> ", solvid2str(pool, te->p), od->edgedata[cycle[k + 1] + 1]);
+ POOL_DEBUG(SAT_DEBUG_STATS, "%s ##%x##> ", pool_solvid2str(pool, te->p), od->edgedata[cycle[k + 1] + 1]);
else
- POOL_DEBUG(SAT_DEBUG_STATS, "%s --%x--> ", solvid2str(pool, te->p), od->edgedata[cycle[k + 1] + 1]);
+ POOL_DEBUG(SAT_DEBUG_STATS, "%s --%x--> ", pool_solvid2str(pool, te->p), od->edgedata[cycle[k + 1] + 1]);
}
POOL_DEBUG(SAT_DEBUG_STATS, "\n");
}
for (i = 1, te = od->tes + i; i < od->ntes; i++, te++)
{
Solvable *s = pool->solvables + te->p;
- POOL_DEBUG(SAT_DEBUG_RESULT, "TE %4d: %c%s\n", i, s->repo == pool->installed ? '-' : '+', solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, "TE %4d: %c%s\n", i, s->repo == pool->installed ? '-' : '+', pool_solvable2str(pool, s));
if (s->repo != pool->installed)
{
queue_empty(&obsq);
transaction_all_obs_pkgs(od->trans, te->p, &obsq);
for (j = 0; j < obsq.count; j++)
- POOL_DEBUG(SAT_DEBUG_RESULT, " -%s\n", solvid2str(pool, obsq.elements[j]));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " -%s\n", pool_solvid2str(pool, obsq.elements[j]));
}
for (j = te->edges; od->edgedata[j]; j += 2)
{
te2 = od->tes + od->edgedata[j];
if ((od->edgedata[j + 1] & TYPE_BROKEN) == 0)
- POOL_DEBUG(SAT_DEBUG_RESULT, " --%x--> TE %4d: %s\n", od->edgedata[j + 1], od->edgedata[j], solvid2str(pool, te2->p));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " --%x--> TE %4d: %s\n", od->edgedata[j + 1], od->edgedata[j], pool_solvid2str(pool, te2->p));
else
- POOL_DEBUG(SAT_DEBUG_RESULT, " ##%x##> TE %4d: %s\n", od->edgedata[j + 1], od->edgedata[j], solvid2str(pool, te2->p));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " ##%x##> TE %4d: %s\n", od->edgedata[j + 1], od->edgedata[j], pool_solvid2str(pool, te2->p));
}
}
}
#if 0
printf("addcycleedges\n");
for (i = 0; (j = cycle[i]) != 0; i++)
- printf("cycle %s\n", solvid2str(pool, od->tes[j].p));
+ printf("cycle %s\n", pool_solvid2str(pool, od->tes[j].p));
#endif
/* first add all the tail cycle edges */
/* We found an edge to the cycle. Add an extra edge to the tail */
/* the TE was not reachable, so we're not creating a new cycle! */
#if 0
- printf("adding TO TAIL cycle edge %d->%d %s->%s!\n", i, tail, solvid2str(pool, od->tes[i].p), solvid2str(pool, od->tes[tail].p));
+ printf("adding TO TAIL cycle edge %d->%d %s->%s!\n", i, tail, pool_solvid2str(pool, od->tes[i].p), pool_solvid2str(pool, od->tes[tail].p));
#endif
j -= te->edges; /* in case we move */
addteedge(od, i, tail, TYPE_CYCLETAIL);
if (od->tes[k].mark == -1)
{
#if 0
- printf("adding FROM HEAD cycle edge %d->%d %s->%s [%s]!\n", head, k, solvid2str(pool, od->tes[head].p), solvid2str(pool, od->tes[k].p), solvid2str(pool, od->tes[cycle[i]].p));
+ printf("adding FROM HEAD cycle edge %d->%d %s->%s [%s]!\n", head, k, pool_solvid2str(pool, od->tes[head].p), pool_solvid2str(pool, od->tes[k].p), pool_solvid2str(pool, od->tes[cycle[i]].p));
#endif
addteedge(od, head, k, TYPE_CYCLEHEAD);
od->tes[k].mark = -2; /* no need to add that one again */
te = od.tes + i;
queue_push(tr, te->p);
#if 0
-printf("do %s [%d]\n", solvid2str(pool, te->p), temedianr[i]);
+printf("do %s [%d]\n", pool_solvid2str(pool, te->p), temedianr[i]);
#endif
s = pool->solvables + te->p;
for (j = te->edges; od.invedgedata[j]; j++)
{
Solvable *s = pool->solvables + te2->p;
#if 0
-printf("free %s [%d]\n", solvid2str(pool, te2->p), temedianr[od.invedgedata[j]]);
+printf("free %s [%d]\n", pool_solvid2str(pool, te2->p), temedianr[od.invedgedata[j]]);
#endif
if (installed && s->repo == installed)
queue_push(&uninstq, od.invedgedata[j]);
MAPSET(seen, pkg);
s = pool->solvables + pkg;
#if 0
- printf("- %*s%c%s\n", depth * 2, "", s->repo == pool->installed ? '-' : '+', solvable2str(pool, s));
+ printf("- %*s%c%s\n", depth * 2, "", s->repo == pool->installed ? '-' : '+', pool_solvable2str(pool, s));
#endif
if (s->requires)
{
}
if (onlyprereq && !inpre)
continue;
- if (!strncmp(id2str(pool, req), "rpmlib(", 7))
+ if (!strncmp(pool_id2str(pool, req), "rpmlib(", 7))
continue;
good = 0;
/* first check kept packages, then freshly installed, then not yet uninstalled */
}
if (!good)
{
- POOL_DEBUG(SAT_DEBUG_RESULT, " %c%s: nothing provides %s needed by %c%s\n", pool->solvables[tepkg].repo == pool->installed ? '-' : '+', solvid2str(pool, tepkg), dep2str(pool, req), s->repo == pool->installed ? '-' : '+', solvable2str(pool, s));
+ POOL_DEBUG(SAT_DEBUG_RESULT, " %c%s: nothing provides %s needed by %c%s\n", pool->solvables[tepkg].repo == pool->installed ? '-' : '+', pool_solvid2str(pool, tepkg), pool_dep2str(pool, req), s->repo == pool->installed ? '-' : '+', pool_solvable2str(pool, s));
}
}
}
for (i = 0; verticals[i]; i++)
if (key->name == verticals[i])
return KEY_STORAGE_VERTICAL_OFFSET;
- keyname = id2str(data->pool, key->name);
+ keyname = pool_id2str(data->pool, key->name);
for (i = 0; languagetags[i] != 0; i++)
if (!strncmp(keyname, languagetags[i], strlen(languagetags[i])))
return KEY_STORAGE_VERTICAL_OFFSET;
for (i = 0; verticals[i]; i++)
if (key->name == verticals[i])
return KEY_STORAGE_VERTICAL_OFFSET;
- keyname = id2str(data->pool, key->name);
+ keyname = pool_id2str(data->pool, key->name);
for (i = 0; languagetags[i] != 0; i++)
if (!strncmp(keyname, languagetags[i], strlen(languagetags[i])))
return KEY_STORAGE_VERTICAL_OFFSET;
char *lang = kfdata;
int i;
- name = id2str(repo->pool, key->name);
+ name = pool_id2str(repo->pool, key->name);
p = strrchr(name, ':');
if (!p || strcmp(p + 1, lang) != 0)
return KEY_STORAGE_DROPPED;
for (i = 0; verticals[i]; i++)
{
- const char *vname = id2str(pool, verticals[i]);
+ const char *vname = pool_id2str(pool, verticals[i]);
if (!strncmp(name, vname, p - name) && vname[p - name] == 0)
return KEY_STORAGE_VERTICAL_OFFSET;
}
if (key->name == SOLVABLE_FILELIST || key->name == SOLVABLE_DISKUSAGE)
return KEY_STORAGE_DROPPED;
- name = id2str(repo->pool, key->name);
+ name = pool_id2str(repo->pool, key->name);
p = strrchr(name, ':');
if (p)
{
{
for (j = 1, key = data->keys + j; j < data->nkeys; j++, key++)
{
- const char *keyname = id2str(repo->pool, key->name);
+ const char *keyname = pool_id2str(repo->pool, key->name);
if (key->name == SOLVABLE_DISKUSAGE)
has_DU = 1;
if (key->name == SOLVABLE_FILELIST)
unsigned int j;
printf("\nrepodata %d has %d keys, %d schemata\n", i + 1, data->nkeys - 1, data->nschemata - 1);
for (j = 1; j < data->nkeys; j++)
- printf(" %s (type %s size %d storage %d)\n", id2str(repo->pool, data->keys[j].name), id2str(repo->pool, data->keys[j].type), data->keys[j].size, data->keys[j].storage);
+ printf(" %s (type %s size %d storage %d)\n", pool_id2str(repo->pool, data->keys[j].name), pool_id2str(repo->pool, data->keys[j].type), data->keys[j].size, data->keys[j].storage);
if (data->localpool)
printf(" localpool has %d strings, size is %d\n", data->spool.nstrings, data->spool.sstrings);
if (data->dirpool.ndirs)
printf("%s:\n", kind);
ids = repo->idarraydata + ido;
while((id = *ids++) != 0)
- printf(" %s\n", dep2str(pool, id));
+ printf(" %s\n", pool_dep2str(pool, id));
}
#endif
KeyValue *kvp;
int indent = 0;
- keyname = id2str(repo->pool, key->name);
+ keyname = pool_id2str(repo->pool, key->name);
for (kvp = kv; (kvp = kvp->parent) != 0; indent += 2)
printf(" ");
switch(key->type)
if (data && data->localpool)
kv->str = stringpool_id2str(&data->spool, kv->id);
else
- kv->str = id2str(repo->pool, kv->id);
+ kv->str = pool_id2str(repo->pool, kv->id);
printf("%s: %s\n", keyname, kv->str);
break;
case REPOKEY_TYPE_CONSTANTID:
- printf("%s: %s\n", keyname, dep2str(repo->pool, kv->id));
+ printf("%s: %s\n", keyname, pool_dep2str(repo->pool, kv->id));
break;
case REPOKEY_TYPE_IDARRAY:
if (!kv->entry)
if (data && data->localpool)
printf(" %s\n", stringpool_id2str(&data->spool, kv->id));
else
- printf(" %s\n", dep2str(repo->pool, kv->id));
+ printf(" %s\n", pool_dep2str(repo->pool, kv->id));
break;
case REPOKEY_TYPE_STR:
printf("%s: %s\n", keyname, kv->str);
case REPOKEY_TYPE_MD5:
case REPOKEY_TYPE_SHA1:
case REPOKEY_TYPE_SHA256:
- printf("%s: %s (%s)\n", keyname, repodata_chk2str(data, key->type, (unsigned char *)kv->str), id2str(repo->pool, key->type));
+ printf("%s: %s (%s)\n", keyname, repodata_chk2str(data, key->type, (unsigned char *)kv->str), pool_id2str(repo->pool, key->type));
break;
case REPOKEY_TYPE_VOID:
printf("%s: (void)\n", keyname);
if (di.data && di.data->localpool)
di.kv.str = stringpool_id2str(&di.data->spool, di.kv.id);
else
- di.kv.str = id2str(repo->pool, di.kv.id);
+ di.kv.str = pool_id2str(repo->pool, di.kv.id);
break;
case REPOKEY_TYPE_STR:
case REPOKEY_TYPE_DIRSTRARRAY:
}
fprintf (stdout, "found: %d:%s %d %s %d %d %d\n",
di.solvid,
- id2str(repo->pool, di.key->name),
+ pool_id2str(repo->pool, di.key->name),
di.kv.id,
di.kv.str, di.kv.num, di.kv.num2, di.kv.eof);
}
printf("solvable %d (%d):\n", n, i);
#if 0
if (s->name || s->evr || s->arch)
- printf("name: %s %s %s\n", id2str(pool, s->name), id2str(pool, s->evr), id2str(pool, s->arch));
+ printf("name: %s %s %s\n", pool_id2str(pool, s->name), pool_id2str(pool, s->evr), pool_id2str(pool, s->arch));
if (s->vendor)
- printf("vendor: %s\n", id2str(pool, s->vendor));
+ printf("vendor: %s\n", pool_id2str(pool, s->vendor));
printids(repo, "provides", s->provides);
printids(repo, "obsoletes", s->obsoletes);
printids(repo, "conflicts", s->conflicts);
pool_findfileconflicts(pool, &todo, 0, &conflicts, &iterate_handle, (void *)&state);
queue_free(&todo);
for (i = 0; i < conflicts.count; i += 5)
- printf("%s: %s[%s] %s[%s]\n", id2str(pool, conflicts.elements[i]), solvid2str(pool, conflicts.elements[i + 1]), id2str(pool, conflicts.elements[i + 2]), solvid2str(pool, conflicts.elements[i + 3]), id2str(pool, conflicts.elements[i + 4]));
+ printf("%s: %s[%s] %s[%s]\n", pool_id2str(pool, conflicts.elements[i]), pool_solvid2str(pool, conflicts.elements[i + 1]), pool_id2str(pool, conflicts.elements[i + 2]), pool_solvid2str(pool, conflicts.elements[i + 3]), pool_id2str(pool, conflicts.elements[i + 4]));
if (conflicts.count)
{
Queue job;
}
pool_addfileprovides(pool);
pool_createwhatprovides(pool);
- rpmid = str2id(pool, "rpm", 0);
- rpmarch = str2id(pool, arch, 0);
+ rpmid = pool_str2id(pool, "rpm", 0);
+ rpmarch = pool_str2id(pool, arch, 0);
rpmrel = 0;
#ifndef DEBIAN
if (rpmid && rpmarch)
break;
}
if (p < pool->nsolvables)
- rpmrel = rel2id(pool, rpmid, rpmarch, REL_ARCH, 1);
+ rpmrel = pool_rel2id(pool, rpmid, rpmarch, REL_ARCH, 1);
}
#endif
}
#if 0
Solvable *s = pool->solvables + p;
- if (!strcmp(id2str(pool, s->name), "libusb-compat-devel"))
+ if (!strcmp(pool_id2str(pool, s->name), "libusb-compat-devel"))
{
cand.elements[j++] = p;
continue;
ptr;
ptr = strtok_r(NULL, " ", &save))
{
- if (*ptr && strstr(solvid2str(pool, p), ptr))
+ if (*ptr && strstr(pool_solvid2str(pool, p), ptr))
{
match = 1;
break;
Solvable *s2;
status = 1;
- printf("can't install %s:\n", solvable2str(pool, s));
+ printf("can't install %s:\n", pool_solvable2str(pool, s));
while ((problem = solver_next_problem(solv, problem)) != 0)
{
solver_findallproblemrules(solv, problem, &rids);
dep = rinfo.elements[k + 3];
switch (rinfo.elements[k])
{
- case SOLVER_PROBLEM_DISTUPGRADE_RULE:
+ case SOLVER_RULE_DISTUPGRADE:
break;
- case SOLVER_PROBLEM_INFARCH_RULE:
+ case SOLVER_RULE_INFARCH:
s = pool_id2solvable(pool, source);
- printf(" %s has inferior architecture\n", solvable2str(pool, s));
+ printf(" %s has inferior architecture\n", pool_solvable2str(pool, s));
break;
- case SOLVER_PROBLEM_UPDATE_RULE:
+ case SOLVER_RULE_UPDATE:
break;
- case SOLVER_PROBLEM_JOB_RULE:
+ case SOLVER_RULE_JOB:
break;
- case SOLVER_PROBLEM_RPM_RULE:
+ case SOLVER_RULE_RPM:
printf(" some dependency problem\n");
break;
- case SOLVER_PROBLEM_JOB_NOTHING_PROVIDES_DEP:
- printf(" nothing provides requested %s\n", dep2str(pool, dep));
+ case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
+ printf(" nothing provides requested %s\n", pool_dep2str(pool, dep));
break;
- case SOLVER_PROBLEM_NOT_INSTALLABLE:
+ case SOLVER_RULE_RPM_NOT_INSTALLABLE:
s = pool_id2solvable(pool, source);
- printf(" package %s is not installable\n", solvable2str(pool, s));
+ printf(" package %s is not installable\n", pool_solvable2str(pool, s));
break;
- case SOLVER_PROBLEM_NOTHING_PROVIDES_DEP:
+ case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
s = pool_id2solvable(pool, source);
- printf(" nothing provides %s needed by %s\n", dep2str(pool, dep), solvable2str(pool, s));
+ printf(" nothing provides %s needed by %s\n", pool_dep2str(pool, dep), pool_solvable2str(pool, s));
if (ISRELDEP(dep))
{
Reldep *rd = GETRELDEP(pool, dep);
{
Id rp, rpp;
FOR_PROVIDES(rp, rpp, rd->name)
- printf(" (we have %s)\n", solvable2str(pool, pool->solvables + rp));
+ printf(" (we have %s)\n", pool_solvable2str(pool, pool->solvables + rp));
}
}
break;
- case SOLVER_PROBLEM_SAME_NAME:
+ case SOLVER_RULE_RPM_SAME_NAME:
s = pool_id2solvable(pool, source);
s2 = pool_id2solvable(pool, target);
- printf(" cannot install both %s and %s\n", solvable2str(pool, s), solvable2str(pool, s2));
+ printf(" cannot install both %s and %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, s2));
break;
- case SOLVER_PROBLEM_PACKAGE_CONFLICT:
+ case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
s = pool_id2solvable(pool, source);
s2 = pool_id2solvable(pool, target);
- printf(" package %s conflicts with %s provided by %s\n", solvable2str(pool, s), dep2str(pool, dep), solvable2str(pool, s2));
+ printf(" package %s conflicts with %s provided by %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, dep), pool_solvable2str(pool, s2));
break;
- case SOLVER_PROBLEM_PACKAGE_OBSOLETES:
+ case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
s = pool_id2solvable(pool, source);
s2 = pool_id2solvable(pool, target);
- printf(" package %s obsoletes %s provided by %s\n", solvable2str(pool, s), dep2str(pool, dep), solvable2str(pool, s2));
+ printf(" package %s obsoletes %s provided by %s\n", pool_solvable2str(pool, s), pool_dep2str(pool, dep), pool_solvable2str(pool, s2));
break;
- case SOLVER_PROBLEM_DEP_PROVIDERS_NOT_INSTALLABLE:
+ case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
s = pool_id2solvable(pool, source);
- printf(" package %s requires %s, but none of the providers can be installed\n", solvable2str(pool, s), dep2str(pool, dep));
+ printf(" package %s requires %s, but none of the providers can be installed\n", pool_solvable2str(pool, s), pool_dep2str(pool, dep));
break;
- case SOLVER_PROBLEM_SELF_CONFLICT:
+ case SOLVER_RULE_RPM_SELF_CONFLICT:
s = pool_id2solvable(pool, source);
- printf(" package %s conflicts with %s provided by itself\n", solvable2str(pool, s), dep2str(pool, dep));
+ printf(" package %s conflicts with %s provided by itself\n", pool_solvable2str(pool, s), pool_dep2str(pool, dep));
break;
}
}
#if 0
else
{
- if (!strcmp(id2str(pool, s->name), "libusb-compat-devel"))
+ if (!strcmp(pool_id2str(pool, s->name), "libusb-compat-devel"))
{
solver_printdecisions(solv);
}
queue_init(&rids);
queue_init(&rinfo);
- printf("can't install %s:\n", solvable2str(pool, s));
+ printf("can't install %s:\n", pool_solvable2str(pool, s));
while ((problem = solver_next_problem(solv, problem)) != 0)
{
solver_findallproblemrules(solv, problem, &rids);
dep = rinfo.elements[k + 3];
switch (rinfo.elements[k])
{
- case SOLVER_PROBLEM_DISTUPGRADE_RULE:
+ case SOLVER_RULE_DISTUPGRADE:
break;
- case SOLVER_PROBLEM_INFARCH_RULE:
- printf(" %s has inferior architecture\n", solvid2str(pool, source));
+ case SOLVER_RULE_INFARCH:
+ printf(" %s has inferior architecture\n", pool_solvid2str(pool, source));
break;
- case SOLVER_PROBLEM_UPDATE_RULE:
- printf(" update rule for %s\n", solvid2str(pool, source));
+ case SOLVER_RULE_UPDATE:
+ printf(" update rule for %s\n", pool_solvid2str(pool, source));
if (badguys)
queue_pushunique(badguys, source);
if (!cand)
cand->elements[l] = -source;
}
break;
- case SOLVER_PROBLEM_JOB_RULE:
+ case SOLVER_RULE_JOB:
break;
- case SOLVER_PROBLEM_RPM_RULE:
+ case SOLVER_RULE_RPM:
printf(" some dependency problem\n");
break;
- case SOLVER_PROBLEM_JOB_NOTHING_PROVIDES_DEP:
- printf(" nothing provides requested %s\n", dep2str(pool, dep));
+ case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
+ printf(" nothing provides requested %s\n", pool_dep2str(pool, dep));
break;
- case SOLVER_PROBLEM_NOT_INSTALLABLE:
- printf(" package %s is not installable\n", solvid2str(pool, source));
+ case SOLVER_RULE_RPM_NOT_INSTALLABLE:
+ printf(" package %s is not installable\n", pool_solvid2str(pool, source));
break;
- case SOLVER_PROBLEM_NOTHING_PROVIDES_DEP:
- printf(" nothing provides %s needed by %s\n", dep2str(pool, dep), solvid2str(pool, source));
+ case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
+ printf(" nothing provides %s needed by %s\n", pool_dep2str(pool, dep), pool_solvid2str(pool, source));
if (ISRELDEP(dep))
{
Reldep *rd = GETRELDEP(pool, dep);
{
Id rp, rpp;
FOR_PROVIDES(rp, rpp, rd->name)
- printf(" (we have %s)\n", solvid2str(pool, rp));
+ printf(" (we have %s)\n", pool_solvid2str(pool, rp));
}
}
break;
- case SOLVER_PROBLEM_SAME_NAME:
- printf(" cannot install both %s and %s\n", solvid2str(pool, source), solvid2str(pool, target));
+ case SOLVER_RULE_RPM_SAME_NAME:
+ printf(" cannot install both %s and %s\n", pool_solvid2str(pool, source), pool_solvid2str(pool, target));
break;
- case SOLVER_PROBLEM_PACKAGE_CONFLICT:
- printf(" package %s conflicts with %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
+ printf(" package %s conflicts with %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
break;
- case SOLVER_PROBLEM_PACKAGE_OBSOLETES:
- printf(" package %s obsoletes %s provided by %s\n", solvid2str(pool, source), dep2str(pool, dep), solvid2str(pool, target));
+ case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
+ printf(" package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
break;
- case SOLVER_PROBLEM_DEP_PROVIDERS_NOT_INSTALLABLE:
- printf(" package %s requires %s, but none of the providers can be installed\n", solvid2str(pool, source), dep2str(pool, dep));
+ case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
+ printf(" package %s requires %s, but none of the providers can be installed\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
break;
- case SOLVER_PROBLEM_SELF_CONFLICT:
- printf(" package %s conflicts with %s provided by itself\n", solvid2str(pool, source), dep2str(pool, dep));
+ case SOLVER_RULE_RPM_SELF_CONFLICT:
+ printf(" package %s conflicts with %s provided by itself\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
break;
}
}
if (p < 0 || p == SYSTEMSOLVABLE)
continue;
- /* printf(" toinstall %s\n", solvid2str(pool, p));*/
+ /* printf(" toinstall %s\n", pool_solvid2str(pool, p));*/
/* oh my! */
pool->solvables[p].repo = instrepo;
}
printf("instrepo..\n");
FOR_REPO_SOLVABLES(instrepo, p, s)
- printf(" %s\n", solvable2str(pool, s));
+ printf(" %s\n", pool_solvable2str(pool, s));
printf("done.\n");
}
Repo *instrepo;
} context_t;
-#define SHOW_PATCH(c) if (!(c)->shown++) printf("%s:\n", solvable2str(pool, s));
+#define SHOW_PATCH(c) if (!(c)->shown++) printf("%s:\n", pool_solvable2str(pool, s));
#define PERF_DEBUGGING 0
static Pool *pool;
if (!s2->conflicts)
continue;
- if (evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) <= 0)
+ if (pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) <= 0)
continue;
conp2 = s2->repo->idarraydata + s2->conflicts;
while ((con2 = *conp2++) != 0)
if (!con)
{
SHOW_PATCH(c);
- printf(" %s contained %s\n", solvable2str(pool, s2), dep2str(pool, rd2->name));
+ printf(" %s contained %s\n", pool_solvable2str(pool, s2), pool_dep2str(pool, rd2->name));
}
else
{
- if (evrcmp(pool, rd->evr, rd2->evr, EVRCMP_COMPARE) < 0)
+ if (pool_evrcmp(pool, rd->evr, rd2->evr, EVRCMP_COMPARE) < 0)
{
SHOW_PATCH(c);
printf(" %s required newer version %s-%s of %s-%s\n",
- solvable2str(pool, s2), dep2str(pool, rd2->name), dep2str(pool, rd2->evr),
- dep2str(pool, rd->name), dep2str(pool, rd->evr));
+ pool_solvable2str(pool, s2), pool_dep2str(pool, rd2->name), pool_dep2str(pool, rd2->evr),
+ pool_dep2str(pool, rd->name), pool_dep2str(pool, rd->evr));
}
}
/* also set up some minimal system */
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES|SOLVER_WEAK);
- queue_push(&job, str2id(pool, "rpm", 1));
+ queue_push(&job, pool_str2id(pool, "rpm", 1));
queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE_PROVIDES|SOLVER_WEAK);
- queue_push(&job, str2id(pool, "aaa_base", 1));
+ queue_push(&job, pool_str2id(pool, "aaa_base", 1));
solv = solver_create(pool);
solv->dontinstallrecommended = 0;
queue_push(&job, i);
}
}
- queue_push(&job, SOLVER_INSTALL_SOLVABLE);
+ queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE);
queue_push(&job, pid);
solv = solver_create(pool);
/*solv->dontinstallrecommended = 1;*/
Solvable *s = pool->solvables + p;
if (!s->repo)
continue;
- if (strchr(id2str(pool, s->name), ':'))
+ if (strchr(pool_id2str(pool, s->name), ':'))
continue; /* only packages, please */
if (!pool_installable(pool, s))
continue;
queue_push(&job, i);
}
}
- queue_push(&job, SOLVER_INSTALL_SOLVABLE);
+ queue_push(&job, SOLVER_INSTALL|SOLVER_SOLVABLE);
queue_push(&job, pid);
solv = solver_create(pool);
solv->dontinstallrecommended = 1;
{
Solvable *s2 = pool_id2solvable(pool, rp);
if (rp < c->updatestart
- && evrcmp(pool, rd->evr, s2->evr, EVRCMP_COMPARE) < 0
+ && pool_evrcmp(pool, rd->evr, s2->evr, EVRCMP_COMPARE) < 0
&& pool_match_nevr_rel(pool, s2, rd->name)
)
{
SHOW_PATCH(c);
printf(" conflict %s < %s satisfied by non-updated package %s\n",
- dep2str(pool, rd->name), dep2str(pool, rd->evr), solvable2str(pool, s2));
+ pool_dep2str(pool, rd->name), pool_dep2str(pool, rd->evr), pool_solvable2str(pool, s2));
break;
}
}
continue;
if (!pool_installable(pool, s))
continue;
- pname = id2str(pool, s->name);
+ pname = pool_id2str(pool, s->name);
if (strncmp(pname, "patch:", 6) != 0)
continue;
l = strlen(pname + 6);
if (mypatch[l] != '-')
continue;
- if (strcmp(mypatch + l + 1, id2str(pool, s->evr)) != 0)
+ if (strcmp(mypatch + l + 1, pool_id2str(pool, s->evr)) != 0)
continue;
}
}
FOR_PROVIDES(p, pp, s->name)
{
Solvable *s2 = pool->solvables + p;
- if (evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) < 0)
+ if (pool_evrcmp(pool, s->evr, s2->evr, EVRCMP_COMPARE) < 0)
break;
}
if (p) {
continue;
#if 0
- printf("testing patch %s-%s\n", pname + 6, id2str(pool, s->evr));
+ printf("testing patch %s-%s\n", pname + 6, pool_id2str(pool, s->evr));
#endif
test_all_old_patches_included(&c, pid);
qp = strchr(query, ':');
if (qp)
{
- type = strn2id(pool, query, qp - query, 0);
+ type = pool_strn2id(pool, query, qp - query, 0);
if (!type)
exit(0);
qp++;
else
qp = query;
snprintf(qbuf, sizeof(qbuf), "repository:repomd:%s", qp);
- id = str2id(pool, qbuf, 0);
+ id = pool_str2id(pool, qbuf, 0);
if (!id)
exit(0);
dataiterator_init(&di, pool, repo, SOLVID_META, id, 0, 0);
{
case REPOKEY_TYPE_ID:
case REPOKEY_TYPE_CONSTANTID:
- printf("%s\n", id2str(pool, di.kv.id));
+ printf("%s\n", pool_id2str(pool, di.kv.id));
break;
case REPOKEY_TYPE_STR:
printf("%s\n", di.kv.str);
Id id;
snprintf(qbuf, sizeof(qbuf), "susetags:%s", arg);
- id = str2id(pool, qbuf, 0);
+ id = pool_str2id(pool, qbuf, 0);
if (!id)
return;
str = repo_lookup_str(repo, SOLVID_META, id);
projects / platform / upstream / libsolv.git / commitdiff