};
struct razor_property {
- uint name : 24;
- uint flags : 6;
- enum razor_property_type type : 2;
- enum razor_version_relation relation : 32;
+ uint32_t name;
+ uint32_t flags;
uint32_t version;
struct list_head packages;
};
array_init(&importer->properties);
}
+
void
razor_importer_finish_package(struct razor_importer *importer)
{
void
razor_importer_add_property(struct razor_importer *importer,
const char *name,
- enum razor_version_relation relation,
- const char *version,
- enum razor_property_type type)
+ uint32_t flags,
+ const char *version)
{
struct razor_property *p;
uint32_t *r;
p = array_add(&importer->set->properties, sizeof *p);
p->name = hashtable_tokenize(&importer->table, name);
- p->flags = 0;
- p->type = type;
- p->relation = relation;
+ p->flags = flags;
p->version = hashtable_tokenize(&importer->table, version);
list_set_ptr(&p->packages, importer->package -
(struct razor_package *) importer->set->packages.data);
r = array_add(&importer->properties, sizeof *r);
*r = p - (struct razor_property *) importer->set->properties.data;
- if (type == RAZOR_PROPERTY_REQUIRES && *name == '/') {
+ if (((flags & RAZOR_PROPERTY_TYPE_MASK) == RAZOR_PROPERTY_REQUIRES) &&
+ *name == '/') {
r = array_add(&importer->file_requires, sizeof *r);
*r = p->name;
}
if (prop1->name != prop2->name)
return strcmp(&pool[prop1->name], &pool[prop2->name]);
- else if (prop1->type != prop2->type)
- return prop1->type - prop2->type;
- else if (prop1->relation != prop2->relation)
- return prop1->relation - prop2->relation;
+ else if (prop1->flags != prop2->flags)
+ return prop1->flags - prop2->flags;
else
return versioncmp(&pool[prop1->version], &pool[prop2->version]);
}
rmap = malloc(count * sizeof *map);
pkgs = zalloc(count * sizeof *pkgs);
for (rp = set->properties.data, up = rp, i = 0; rp < rp_end; rp++, i++) {
- if (rp->name != up->name || rp->type != up->type ||
- rp->relation != up->relation || rp->version != up->version) {
+ if (rp->name != up->name ||
+ rp->flags != up->flags ||
+ rp->version != up->version) {
up++;
up->name = rp->name;
- up->flags = 0;
- up->type = rp->type;
- up->relation = rp->relation;
+ up->flags = rp->flags;
up->version = rp->version;
}
for (pkg = list_first(&entry->packages, &importer->set->package_pool); pkg; pkg = list_next(pkg)) {
prop = array_add(&importer->set->properties, sizeof *prop);
prop->name = *req;
- prop->type = RAZOR_PROPERTY_PROVIDES;
- prop->relation = RAZOR_VERSION_EQUAL;
+ prop->flags =
+ RAZOR_PROPERTY_PROVIDES | RAZOR_PROPERTY_EQUAL;
prop->version = hashtable_tokenize(&importer->table, "");
list_set_ptr(&prop->packages, pkg->data);
razor_property_iterator_next(struct razor_property_iterator *pi,
struct razor_property **property,
const char **name,
- enum razor_version_relation *relation,
- const char **version,
- enum razor_property_type *type)
+ uint32_t *flags,
+ const char **version)
{
char *pool;
int valid;
pool = pi->set->string_pool.data;
*property = p;
*name = &pool[p->name];
- *relation = p->relation;
+ *flags = p->flags;
*version = &pool[p->version];
- *type = p->type;
} else {
*property = NULL;
}
static uint32_t
add_property(struct razor_merger *merger,
- const char *name, enum razor_version_relation relation,
- const char *version, int type)
+ const char *name, uint32_t flags, const char *version)
{
struct razor_property *p;
p = array_add(&merger->set->properties, sizeof *p);
p->name = hashtable_tokenize(&merger->table, name);
- p->flags = 0;
- p->type = type;
- p->relation = relation;
+ p->flags = flags;
p->version = hashtable_tokenize(&merger->table, version);
return p - (struct razor_property *) merger->set->properties.data;
else
cmp = 1;
if (cmp == 0)
- cmp = p1->type - p2->type;
- if (cmp == 0)
- cmp = p1->relation - p2->relation;
+ cmp = p1->flags - p2->flags;
if (cmp == 0)
cmp = versioncmp(&pool1[p1->version],
&pool2[p2->version]);
if (cmp < 0) {
map1[i++] = add_property(merger,
&pool1[p1->name],
- p1->relation,
- &pool1[p1->version],
- p1->type);
+ p1->flags,
+ &pool1[p1->version]);
} else if (cmp > 0) {
map2[j++] = add_property(merger,
&pool2[p2->name],
- p2->relation,
- &pool2[p2->version],
- p2->type);
+ p2->flags,
+ &pool2[p2->version]);
} else {
- map1[i++] = map2[j++] = add_property(merger,
- &pool1[p1->name],
- p1->relation,
- &pool1[p1->version],
- p1->type);
+ map1[i++] = map2[j++] =
+ add_property(merger,
+ &pool1[p1->name],
+ p1->flags,
+ &pool1[p1->version]);
}
}
}
static int
provider_satisfies_requirement(struct razor_property *provider,
const char *provider_strings,
- enum razor_version_relation relation,
+ uint32_t flags,
const char *required)
{
int cmp, len;
if (!*required)
return 1;
if (!*provided) {
- if (relation >= RAZOR_VERSION_EQUAL)
- return 1;
- else
+ if (flags & RAZOR_PROPERTY_LESS)
return 0;
+ else
+ return 1;
}
cmp = versioncmp(provided, required);
- switch (relation) {
- case RAZOR_VERSION_LESS:
+ switch (flags & RAZOR_PROPERTY_RELATION_MASK) {
+ case RAZOR_PROPERTY_LESS:
return cmp < 0;
- case RAZOR_VERSION_LESS_OR_EQUAL:
+ case RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL:
if (cmp <= 0)
return 1;
/* fall through: FIXME, make sure this is correct */
- case RAZOR_VERSION_EQUAL:
+ case RAZOR_PROPERTY_EQUAL:
if (cmp == 0)
return 1;
return 1;
return 0;
- case RAZOR_VERSION_GREATER_OR_EQUAL:
+ case RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL:
return cmp >= 0;
- case RAZOR_VERSION_GREATER:
+ case RAZOR_PROPERTY_GREATER:
return cmp > 0;
}
}
static int
-prop_iter_next(struct prop_iter *pi,
- enum razor_property_type type, struct razor_property **p)
+prop_iter_next(struct prop_iter *pi, uint32_t flags, struct razor_property **p)
{
while (pi->p < pi->end) {
if ((pi->present[pi->p - pi->start] & ~TRANS_PROPERTY_SATISFIED) &&
- pi->p->type == type) {
+ (pi->p->flags & RAZOR_PROPERTY_TYPE_MASK) == flags) {
*p = pi->p++;
return 1;
}
static struct razor_property *
prop_iter_seek_to(struct prop_iter *pi,
- enum razor_property_type type, const char *match)
+ uint32_t flags, const char *match)
{
uint32_t name;
name = pi->p->name;
while (pi->p < pi->end &&
pi->p->name == name &&
- pi->p->type != type)
+ (pi->p->flags & RAZOR_PROPERTY_TYPE_MASK) != flags)
pi->p++;
if (pi->p == pi->end || pi->p->name != name)
static void
remove_matching_providers(struct razor_transaction *trans,
struct prop_iter *ppi,
- enum razor_version_relation relation,
+ uint32_t flags,
const char *version)
{
struct razor_property *p;
struct razor_package_iterator pkg_iter;
struct razor_set *set;
const char *n, *v, *a;
+ uint32_t type;
if (ppi->present == trans->system.properties)
set = trans->system.set;
set = trans->upstream.set;
pkgs = (struct razor_package *) set->packages.data;
+ type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;
for (p = ppi->p;
p < ppi->end &&
p->name == ppi->p->name &&
- p->type == ppi->p->type;
+ (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;
p++) {
if (!ppi->present[p - ppi->start])
continue;
if (!provider_satisfies_requirement(p, ppi->pool,
- relation, version))
+ flags, version))
continue;
razor_package_iterator_init_for_property(&pkg_iter, set, p);
struct razor_package_iterator pkg_iter;
struct razor_set *set;
const char *name, *version, *arch;
- uint32_t *flags;
+ uint32_t *flags, type;
if (ppi->present == trans->system.properties) {
set = trans->system.set;
}
pkgs = (struct razor_package *) set->packages.data;
+ type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;
for (p = ppi->p;
p < ppi->end &&
p->name == ppi->p->name &&
- p->type == ppi->p->type;
+ (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;
p++) {
if (!ppi->present[p - ppi->start])
continue;
if (!provider_satisfies_requirement(p, ppi->pool,
- r->relation,
+ r->flags,
&rpi->pool[r->version]))
continue;
static struct razor_package *
pick_matching_provider(struct razor_set *set,
struct prop_iter *ppi,
- enum razor_version_relation relation,
+ uint32_t flags,
const char *version)
{
struct razor_property *p;
struct razor_package *pkgs;
struct list *i;
+ uint32_t type;
/* This is where we decide which pkgs to pull in to satisfy a
* requirement. There may be several different providers
* from the first provider that matches. */
pkgs = set->packages.data;
+ type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;
for (p = ppi->p;
p < ppi->end &&
p->name == ppi->p->name &&
- p->type == ppi->p->type &&
+ (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type &&
ppi->present[p - ppi->start] == 0;
p++) {
if (!provider_satisfies_requirement(p, ppi->pool,
- relation, version))
+ flags, version))
continue;
i = list_first(&p->packages, &set->package_pool);
if (!prop_iter_seek_to(&spi, RAZOR_PROPERTY_PROVIDES,
&upi.pool[up->name]))
continue;
- remove_matching_providers(trans, &spi, up->relation,
+ remove_matching_providers(trans, &spi, up->flags,
&upi.pool[up->version]);
}
}
static int
any_provider_satisfies_requirement(struct prop_iter *ppi,
- enum razor_version_relation relation,
+ uint32_t flags,
const char *version)
{
struct razor_property *p;
+ uint32_t type;
+ type = ppi->p->flags & RAZOR_PROPERTY_TYPE_MASK;
for (p = ppi->p;
p < ppi->end &&
p->name == ppi->p->name &&
- p->type == ppi->p->type;
+ (p->flags & RAZOR_PROPERTY_TYPE_MASK) == type;
p++) {
if (ppi->present[p - ppi->start] > 0 &&
provider_satisfies_requirement(p, ppi->pool,
- relation, version))
+ flags, version))
return 1;
}
}
}
-static const char *relation_string[] = { "<", "<=", "=", ">=", ">" };
+const char *
+razor_property_relation_to_string(struct razor_property *p)
+{
+ switch (p->flags & RAZOR_PROPERTY_RELATION_MASK) {
+ case RAZOR_PROPERTY_LESS:
+ return "<";
+
+ case RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL:
+ return "<=";
+
+ case RAZOR_PROPERTY_EQUAL:
+ return "=";
+
+ case RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL:
+ return ">=";
+
+ case RAZOR_PROPERTY_GREATER:
+ return ">";
+
+ default:
+ return "?";
+ }
+}
+
+const char *
+razor_property_type_to_string(struct razor_property *p)
+{
+ switch (p->flags & RAZOR_PROPERTY_TYPE_MASK) {
+ case RAZOR_PROPERTY_REQUIRES:
+ return "requires";
+ case RAZOR_PROPERTY_PROVIDES:
+ return "provides";
+ case RAZOR_PROPERTY_CONFLICTS:
+ return "conflicts";
+ case RAZOR_PROPERTY_OBSOLETES:
+ return "obsoletes";
+ default:
+ return NULL;
+ }
+}
static void
mark_satisfied_requires(struct razor_transaction *trans,
&rpi.pool[rp->name]))
continue;
- if (any_provider_satisfies_requirement(&ppi, rp->relation,
+ if (any_provider_satisfies_requirement(&ppi, rp->flags,
&rpi.pool[rp->version]))
rpi.present[rp - rpi.start] |= TRANS_PROPERTY_SATISFIED;
}
fprintf(stderr, "updating %s because %s %s %s "
"isn't satisfied\n",
name, spi.pool + sp->name,
- relation_string[sp->relation],
+ razor_property_relation_to_string(sp),
spi.pool + sp->version);
trans->system.packages[pkg - spkgs] |=
TRANS_PACKAGE_UPDATE;
&spi.pool[sp->name]))
continue;
- if (!any_provider_satisfies_requirement(&upi, sp->relation,
+ if (!any_provider_satisfies_requirement(&upi, sp->flags,
&spi.pool[sp->version]))
continue;
if (pp == NULL)
continue;
pkg = pick_matching_provider(trans->upstream.set,
- ppi, rp->relation,
+ ppi, rp->flags,
&rpi->pool[rp->version]);
if (pkg == NULL)
continue;
"to satisfy %s %s %s\n",
ppi->pool + pkg->name,
ppi->pool + pp->name,
- relation_string[pp->relation],
+ razor_property_relation_to_string(pp),
ppi->pool + pp->version,
&rpi->pool[rp->name],
- relation_string[rp->relation],
+ razor_property_relation_to_string(rp),
&rpi->pool[rp->version]);
trans->upstream.packages[pkg - upkgs] |= TRANS_PACKAGE_UPDATE;
continue;
pkg = pick_matching_provider(trans->upstream.set, &ppi,
- RAZOR_VERSION_GREATER, version);
+ RAZOR_PROPERTY_GREATER, version);
if (pkg == NULL)
continue;
continue;
if (prop_iter_seek_to(&spi, RAZOR_PROPERTY_PROVIDES, name))
- remove_matching_providers(trans, &spi,
- RAZOR_VERSION_LESS, version);
+ remove_matching_providers(trans,
+ &spi,
+ RAZOR_PROPERTY_LESS,
+ version);
razor_transaction_install_package(trans, p);
fprintf(stderr, "installing %s-%s\n", name, version);
}
&name, &version, &arch))
fprintf(stderr, "%s %s %s is needed by %s-%s.%s\n",
&pool[rp->name],
- relation_string[rp->relation],
+ razor_property_relation_to_string(rp),
&pool[rp->version],
name, version, arch);
}
int
razor_transaction_unsatisfied_property(struct razor_transaction *trans,
const char *name,
- enum razor_version_relation rel,
- const char *version,
- enum razor_property_type type)
+ uint32_t flags,
+ const char *version)
{
struct prop_iter pi;
struct razor_property *p;
prop_iter_init(&pi, &trans->system);
- while (prop_iter_next(&pi, type, &p)) {
+ while (prop_iter_next(&pi, flags, &p)) {
if (!(trans->system.properties[p - pi.start] & TRANS_PROPERTY_SATISFIED) &&
- p->relation == rel &&
+ p->flags == flags &&
strcmp(&pi.pool[p->name], name) == 0 &&
strcmp(&pi.pool[p->version], version) == 0)
}
prop_iter_init(&pi, &trans->upstream);
- while (prop_iter_next(&pi, type, &p)) {
+ while (prop_iter_next(&pi, flags, &p)) {
if (!(trans->upstream.properties[p - pi.start] & TRANS_PROPERTY_SATISFIED) &&
- p->relation == rel &&
+ p->flags == flags &&
strcmp(&pi.pool[p->name], name) == 0 &&
strcmp(&pi.pool[p->version], version) == 0)
struct razor_package;
struct razor_property;
-enum razor_property_type {
- RAZOR_PROPERTY_REQUIRES,
- RAZOR_PROPERTY_PROVIDES,
- RAZOR_PROPERTY_CONFLICTS,
- RAZOR_PROPERTY_OBSOLETES
+enum razor_property_flags {
+ RAZOR_PROPERTY_LESS = 1 << 0,
+ RAZOR_PROPERTY_GREATER = 1 << 1,
+ RAZOR_PROPERTY_EQUAL = 1 << 2,
+ RAZOR_PROPERTY_RELATION_MASK =
+ RAZOR_PROPERTY_LESS |
+ RAZOR_PROPERTY_GREATER |
+ RAZOR_PROPERTY_EQUAL,
+
+ RAZOR_PROPERTY_REQUIRES = 0 << 3,
+ RAZOR_PROPERTY_PROVIDES = 1 << 3,
+ RAZOR_PROPERTY_CONFLICTS = 2 << 3,
+ RAZOR_PROPERTY_OBSOLETES = 3 << 3,
+ RAZOR_PROPERTY_TYPE_MASK = 3 << 3,
+
+ RAZOR_PROPERTY_PRE = 1 << 5,
+ RAZOR_PROPERTY_POST = 1 << 6,
+ RAZOR_PROPERTY_PREUN = 1 << 7,
+ RAZOR_PROPERTY_POSTUN = 1 << 8
};
-enum razor_version_relation {
- RAZOR_VERSION_LESS,
- RAZOR_VERSION_LESS_OR_EQUAL,
- RAZOR_VERSION_EQUAL,
- RAZOR_VERSION_GREATER_OR_EQUAL,
- RAZOR_VERSION_GREATER
-};
-extern const char * const razor_version_relations[];
+const char *
+razor_property_relation_to_string(struct razor_property *p);
+const char *
+razor_property_type_to_string(struct razor_property *p);
struct razor_set *razor_set_create(void);
struct razor_set *razor_set_open(const char *filename);
int razor_property_iterator_next(struct razor_property_iterator *pi,
struct razor_property **property,
const char **name,
- enum razor_version_relation *relation,
- const char **version,
- enum razor_property_type *type);
+ uint32_t *flags,
+ const char **version);
void
razor_property_iterator_destroy(struct razor_property_iterator *pi);
/* Temporary helper for test suite. */
int razor_transaction_unsatisfied_property(struct razor_transaction *trans,
const char *name,
- enum razor_version_relation rel,
- const char *version,
- enum razor_property_type type);
+ uint32_t flags,
+ const char *version);
/* Importer interface; for building a razor set from external sources,
* like yum, rpmdb or razor package files. */
const char *arch);
void razor_importer_add_property(struct razor_importer *importer,
const char *name,
- enum razor_version_relation relation,
- const char *version,
- enum razor_property_type type);
+ uint32_t flags,
+ const char *version);
void razor_importer_add_file(struct razor_importer *importer,
const char *name);
void razor_importer_finish_package(struct razor_importer *importer);
};
enum {
- RPMSENSE_LESS = (1 << 1),
- RPMSENSE_GREATER = (1 << 2),
- RPMSENSE_EQUAL = (1 << 3),
+ RPMSENSE_LESS = 1 << 1,
+ RPMSENSE_GREATER = 1 << 2,
+ RPMSENSE_EQUAL = 1 << 3,
+ RPMSENSE_PREREQ = 1 << 6,
+ RPMSENSE_SCRIPT_PRE = 1 << 9,
+ RPMSENSE_SCRIPT_POST = 1 << 10,
+ RPMSENSE_SCRIPT_PREUN = 1 << 11,
+ RPMSENSE_SCRIPT_POSTUN = 1 << 12,
};
enum {
return NULL;
}
-static enum razor_version_relation
+static uint32_t
rpm_to_razor_flags(uint32_t flags)
{
- switch (flags & (RPMSENSE_LESS | RPMSENSE_EQUAL | RPMSENSE_GREATER)) {
- case RPMSENSE_LESS:
- return RAZOR_VERSION_LESS;
- case RPMSENSE_LESS|RPMSENSE_EQUAL:
- return RAZOR_VERSION_LESS_OR_EQUAL;
- case RPMSENSE_EQUAL:
- return RAZOR_VERSION_EQUAL;
- case RPMSENSE_GREATER|RPMSENSE_EQUAL:
- return RAZOR_VERSION_GREATER_OR_EQUAL;
- case RPMSENSE_GREATER:
- return RAZOR_VERSION_GREATER;
- }
-
- /* FIXME? */
- return RAZOR_VERSION_EQUAL;
+ uint32_t razor_flags;
+
+ razor_flags = 0;
+ if (flags & RPMSENSE_LESS)
+ razor_flags |= RAZOR_PROPERTY_LESS;
+ if (flags & RPMSENSE_EQUAL)
+ razor_flags |= RAZOR_PROPERTY_EQUAL;
+ if (flags & RPMSENSE_GREATER)
+ razor_flags |= RAZOR_PROPERTY_GREATER;
+
+ if (flags & RPMSENSE_SCRIPT_PRE)
+ razor_flags |= RAZOR_PROPERTY_PRE;
+ if (flags & RPMSENSE_SCRIPT_POST)
+ razor_flags |= RAZOR_PROPERTY_POST;
+ if (flags & RPMSENSE_SCRIPT_PREUN)
+ razor_flags |= RAZOR_PROPERTY_PREUN;
+ if (flags & RPMSENSE_SCRIPT_POSTUN)
+ razor_flags |= RAZOR_PROPERTY_POSTUN;
+
+ return razor_flags;
}
static void
-import_properties(struct razor_importer *importer, unsigned long type,
+import_properties(struct razor_importer *importer, uint32_t type,
struct razor_rpm *rpm,
int name_tag, int version_tag, int flags_tag)
{
version = razor_rpm_get_indirect(rpm, version_tag, &count);
for (i = 0; i < count; i++) {
f = rpm_to_razor_flags(ntohl(flags[i]));
- razor_importer_add_property(importer, name, f, version, type);
+ razor_importer_add_property(importer, name, f | type, version);
name += strlen(name) + 1;
version += strlen(version) + 1;
}
uint_32 integer;
};
-static enum razor_version_relation
-rpm_to_razor_flags (uint_32 flags)
+static uint32_t
+rpm_to_razor_flags(uint32_t flags)
{
- switch (flags & (RPMSENSE_LESS | RPMSENSE_EQUAL | RPMSENSE_GREATER)) {
- case RPMSENSE_LESS:
- return RAZOR_VERSION_LESS;
- case RPMSENSE_LESS|RPMSENSE_EQUAL:
- return RAZOR_VERSION_LESS_OR_EQUAL;
- case RPMSENSE_EQUAL:
- return RAZOR_VERSION_EQUAL;
- case RPMSENSE_GREATER|RPMSENSE_EQUAL:
- return RAZOR_VERSION_GREATER_OR_EQUAL;
- case RPMSENSE_GREATER:
- return RAZOR_VERSION_GREATER;
- }
-
- /* FIXME? */
- return RAZOR_VERSION_EQUAL;
+ uint32_t razor_flags;
+
+ razor_flags = 0;
+ if (flags & RPMSENSE_LESS)
+ razor_flags |= RAZOR_PROPERTY_LESS;
+ if (flags & RPMSENSE_EQUAL)
+ razor_flags |= RAZOR_PROPERTY_EQUAL;
+ if (flags & RPMSENSE_GREATER)
+ razor_flags |= RAZOR_PROPERTY_GREATER;
+
+ if (flags & RPMSENSE_SCRIPT_PRE)
+ razor_flags |= RAZOR_PROPERTY_PRE;
+ if (flags & RPMSENSE_SCRIPT_POST)
+ razor_flags |= RAZOR_PROPERTY_POST;
+ if (flags & RPMSENSE_SCRIPT_PREUN)
+ razor_flags |= RAZOR_PROPERTY_PREUN;
+ if (flags & RPMSENSE_SCRIPT_POSTUN)
+ razor_flags |= RAZOR_PROPERTY_POSTUN;
+
+ return razor_flags;
}
static void
add_properties(struct razor_importer *importer,
- enum razor_property_type property_type,
+ uint32_t type_flags,
Header h, int_32 name_tag, int_32 version_tag, int_32 flags_tag)
{
union rpm_entry names, versions, flags;
for (i = 0; i < count; i++)
razor_importer_add_property(importer,
names.list[i],
- rpm_to_razor_flags (flags.flags[i]),
- versions.list[i],
- property_type);
+ rpm_to_razor_flags (flags.flags[i]) | type_flags,
+ versions.list[i]);
}
struct razor_set *
#include <string.h>
#include <stdio.h>
+#include <stdint.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <unistd.h>
struct import_property_context *current_property_context;
char name[256], arch[64], buffer[512], *p;
char pkgid[128];
+ uint32_t property_type;
int state;
};
-static enum razor_version_relation
-yum_to_razor_flags (const char *flags)
+static uint32_t
+yum_to_razor_relation (const char *flags)
{
- /* FIXME? */
- if (!flags)
- return RAZOR_VERSION_EQUAL;
-
if (flags[0] == 'L') {
if (flags[1] == 'T')
- return RAZOR_VERSION_LESS;
+ return RAZOR_PROPERTY_LESS;
else
- return RAZOR_VERSION_LESS_OR_EQUAL;
+ return RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL;
} else if (flags[0] == 'G') {
if (flags[1] == 'T')
- return RAZOR_VERSION_GREATER;
+ return RAZOR_PROPERTY_GREATER;
else
- return RAZOR_VERSION_GREATER_OR_EQUAL;
+ return RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL;
} else
- return RAZOR_VERSION_EQUAL;
+ return RAZOR_PROPERTY_EQUAL;
}
static void
yum_primary_start_element(void *data, const char *name, const char **atts)
{
struct yum_context *ctx = data;
- const char *n, *epoch, *version, *release, *flags;
+ const char *n, *epoch, *version, *release;
char buffer[128];
+ uint32_t pre, relation, flags;
int i;
if (strcmp(name, "name") == 0) {
ctx->state = YUM_STATE_CHECKSUM;
} else if (strcmp(name, "rpm:requires") == 0) {
ctx->state = YUM_STATE_REQUIRES;
+ ctx->property_type = RAZOR_PROPERTY_REQUIRES;
} else if (strcmp(name, "rpm:provides") == 0) {
ctx->state = YUM_STATE_PROVIDES;
+ ctx->property_type = RAZOR_PROPERTY_PROVIDES;
} else if (strcmp(name, "rpm:obsoletes") == 0) {
ctx->state = YUM_STATE_OBSOLETES;
+ ctx->property_type = RAZOR_PROPERTY_OBSOLETES;
} else if (strcmp(name, "rpm:conflicts") == 0) {
ctx->state = YUM_STATE_CONFLICTS;
+ ctx->property_type = RAZOR_PROPERTY_CONFLICTS;
} else if (strcmp(name, "rpm:entry") == 0 &&
ctx->state != YUM_STATE_BEGIN) {
n = NULL;
epoch = NULL;
version = NULL;
release = NULL;
- flags = NULL;
+ relation = RAZOR_PROPERTY_EQUAL;
+ pre = 0;
for (i = 0; atts[i]; i += 2) {
if (strcmp(atts[i], "name") == 0)
n = atts[i + 1];
else if (strcmp(atts[i], "rel") == 0)
release = atts[i + 1];
else if (strcmp(atts[i], "flags") == 0)
- flags = atts[i + 1];
+ relation = yum_to_razor_relation(atts[i + 1]);
+ else if (strcmp(atts[i], "pre") == 0)
+ pre =
+ RAZOR_PROPERTY_PRE |
+ RAZOR_PROPERTY_POST |
+ RAZOR_PROPERTY_PREUN |
+ RAZOR_PROPERTY_POSTUN;
}
if (n == NULL) {
}
razor_build_evr(buffer, sizeof buffer, epoch, version, release);
- switch (ctx->state) {
- case YUM_STATE_REQUIRES:
- razor_importer_add_property(ctx->importer, n,
- yum_to_razor_flags (flags),
- buffer,
- RAZOR_PROPERTY_REQUIRES);
- break;
- case YUM_STATE_PROVIDES:
- razor_importer_add_property(ctx->importer, n,
- yum_to_razor_flags (flags),
- buffer,
- RAZOR_PROPERTY_PROVIDES);
- break;
- case YUM_STATE_OBSOLETES:
- razor_importer_add_property(ctx->importer, n,
- yum_to_razor_flags (flags),
- buffer,
- RAZOR_PROPERTY_OBSOLETES);
- break;
- case YUM_STATE_CONFLICTS:
- razor_importer_add_property(ctx->importer, n,
- yum_to_razor_flags (flags),
- buffer,
- RAZOR_PROPERTY_CONFLICTS);
- break;
- }
+ flags = ctx->property_type | relation | pre;
+ razor_importer_add_property(ctx->importer, n, flags, buffer);
}
}
}
static int
-list_properties(const char *package_name,
- enum razor_property_type required_type)
+list_properties(const char *package_name, uint32_t type)
{
- static const char *relation_string[] = { "<", "<=", "=", ">=", ">" };
struct razor_set *set;
struct razor_property *property;
struct razor_package *package;
struct razor_property_iterator *pi;
const char *name, *version;
- enum razor_property_type type;
- enum razor_version_relation relation;
+ uint32_t flags;
set = razor_set_open(repo_filename);
if (package_name)
pi = razor_property_iterator_create(set, package);
while (razor_property_iterator_next(pi, &property,
- &name, &relation, &version,
- &type)) {
- if (type != required_type)
+ &name, &flags, &version)) {
+ if ((flags & RAZOR_PROPERTY_TYPE_MASK) != type)
continue;
- if (version[0] == '\0')
- printf("%s\n", name);
- else
- printf("%s %s %s\n", name,
- relation_string[relation], version);
+ printf("%s", name);
+ if (version[0] != '\0')
+ printf(" %s %s",
+ razor_property_relation_to_string(property),
+ version);
+
+ if (flags & ~(RAZOR_PROPERTY_RELATION_MASK | RAZOR_PROPERTY_TYPE_MASK)) {
+ printf(" [");
+ if (flags & RAZOR_PROPERTY_PRE)
+ printf(" pre");
+ if (flags & RAZOR_PROPERTY_POST)
+ printf(" post");
+ if (flags & RAZOR_PROPERTY_PREUN)
+ printf(" preun");
+ if (flags & RAZOR_PROPERTY_POSTUN)
+ printf(" postun");
+ printf(" ]");
+ }
+ printf("\n");
}
razor_property_iterator_destroy(pi);
static int
list_property_packages(const char *ref_name,
const char *ref_version,
- enum razor_property_type ref_type)
+ uint32_t type)
{
struct razor_set *set;
struct razor_property *property;
struct razor_property_iterator *pi;
const char *name, *version;
- enum razor_property_type type;
- enum razor_version_relation relation;
+ uint32_t flags;
if (ref_name == NULL)
return 0;
pi = razor_property_iterator_create(set, NULL);
while (razor_property_iterator_next(pi, &property,
- &name, &relation, &version,
- &type)) {
+ &name, &flags, &version)) {
if (strcmp(ref_name, name) != 0)
continue;
- if (ref_version && relation == RAZOR_VERSION_EQUAL &&
+ if (ref_version &&
+ (flags & RAZOR_PROPERTY_RELATION_MASK) == RAZOR_PROPERTY_EQUAL &&
strcmp(ref_version, version) != 0)
continue;
- if (ref_type != type)
+ if ((flags & RAZOR_PROPERTY_TYPE_MASK) != type)
continue;
list_packages_for_property(set, property);
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
+#include <stdint.h>
#include <dirent.h>
#include "razor.h"
struct razor_package_query *query,
const char *ref_name,
const char *ref_version,
- enum razor_property_type ref_type)
+ uint32_t ref_type)
{
struct razor_property *property;
struct razor_property_iterator *pi;
struct razor_package_iterator *pkgi;
const char *name, *version;
- enum razor_property_type type;
- enum razor_version_relation relation;
+ uint32_t flags;
pi = razor_property_iterator_create(set, NULL);
while (razor_property_iterator_next(pi, &property, &name,
- &relation, &version, &type)) {
+ &flags, &version)) {
if (strcmp(ref_name, name) != 0)
continue;
- if (ref_version && relation == RAZOR_VERSION_EQUAL &&
+ if (ref_version &&
+ (flags & RAZOR_PROPERTY_RELATION_MASK) == RAZOR_PROPERTY_EQUAL &&
strcmp(ref_version, version) != 0)
continue;
- if (ref_type != type)
+ if ((flags & RAZOR_PROPERTY_TYPE_MASK) != ref_type)
continue;
pkgi = razor_package_iterator_create_for_property(set,
return razor_package_query_finish(query);
}
-static const char *relation_string[] = { "<", "<=", "=", ">=", ">" };
-
static void
print_package_properties(struct razor_set *set,
struct razor_package *package,
- enum razor_property_type ref_type)
+ uint32_t ref_type)
{
struct razor_property *property;
struct razor_property_iterator *pi;
const char *name, *version;
- enum razor_property_type type;
- enum razor_version_relation relation;
+ uint32_t flags;
pi = razor_property_iterator_create(set, package);
while (razor_property_iterator_next(pi, &property,
- &name, &relation, &version,
- &type)) {
- if (type != ref_type)
+ &name, &flags, &version)) {
+ if ((flags & RAZOR_PROPERTY_TYPE_MASK) != ref_type)
continue;
if (version[0] == '\0')
printf("%s\n", name);
else
printf("%s %s %s\n", name,
- relation_string[relation], version);
+ razor_property_relation_to_string(property),
+ version);
}
razor_property_iterator_destroy(pi);
}
git://project.juiblex.co.uk / razor.git / commitdiff