mirror of
git://projects.qi-hardware.com/wernermisc.git
synced 2024-11-15 08:50:38 +02:00
280 lines
5.7 KiB
C
280 lines
5.7 KiB
C
/*
|
|
* prereq.c - Determine prerequisite packages
|
|
*
|
|
* Written 2010 by Werner Almesberger
|
|
* Copyright 2010 Werner Almesberger
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*/
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <assert.h>
|
|
|
|
#include "id.h"
|
|
#include "qpkg.h"
|
|
#include "util.h"
|
|
#include "prereq.h"
|
|
|
|
|
|
struct list {
|
|
const struct ref *refs;
|
|
struct list *next;
|
|
};
|
|
|
|
struct stack {
|
|
struct pkg *pkg;
|
|
struct stack *next;
|
|
};
|
|
|
|
|
|
static struct pkg **best = NULL;
|
|
static struct pkg **installs = NULL;
|
|
static int n_best; /* undefined if best == NULL */
|
|
static int n_install = 0;
|
|
static int install_max = 0;
|
|
static int debug = 0;
|
|
|
|
|
|
static int epoch(const char **s, const struct id *id)
|
|
{
|
|
const char *end = id->s+id->len;
|
|
int n = 0;
|
|
|
|
while (*s != end && isdigit(**s)) {
|
|
n = 10*n+**s-'0';
|
|
(*s)++;
|
|
}
|
|
if (*s == id->s || (*s != end && **s == ':'))
|
|
return n;
|
|
*s = id->s;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int comp_versions(const struct id *va, const struct id *vb)
|
|
{
|
|
int epoch_a = 0, epoch_b = 0;
|
|
const char *a = va->s;
|
|
const char *b = vb->s;
|
|
const char *ea = a+va->len;
|
|
const char *eb = b+vb->len;
|
|
|
|
epoch_a = epoch(&a, va);
|
|
epoch_b = epoch(&b, vb);
|
|
if (epoch_a != epoch_b)
|
|
return epoch_a-epoch_b;
|
|
|
|
while (1) {
|
|
if (a == ea || b == eb)
|
|
return (a != ea)-(b != eb);
|
|
if (isdigit(*a) && isdigit(*b)) {
|
|
int na = 0, nb = 0;
|
|
|
|
while (a != ea && isdigit(*a)) {
|
|
na = na*10+*a-'0';
|
|
a++;
|
|
}
|
|
while (b != eb && isdigit(*b)) {
|
|
nb = nb*10+*b-'0';
|
|
b++;
|
|
}
|
|
if (na == nb)
|
|
continue;
|
|
|
|
return na-nb;
|
|
}
|
|
if (*a > *b)
|
|
return 1;
|
|
if (*a < *b)
|
|
return 1;
|
|
a++;
|
|
b++;
|
|
}
|
|
}
|
|
|
|
|
|
static void done(void)
|
|
{
|
|
int size;
|
|
|
|
if (best && n_best <= n_install)
|
|
return;
|
|
free(best);
|
|
size = sizeof(*installs)*(n_install+1);
|
|
best = alloc_size(size);
|
|
memcpy(best, installs, sizeof(*installs)*n_install);
|
|
n_best = n_install;
|
|
best[n_best] = NULL;
|
|
}
|
|
|
|
|
|
static void append_install(struct pkg *pkg)
|
|
{
|
|
if (n_install == install_max) {
|
|
install_max = (install_max+1)*2;
|
|
installs = realloc(installs, sizeof(*installs)*install_max);
|
|
if (!installs) {
|
|
perror("realloc");
|
|
exit(1);
|
|
}
|
|
}
|
|
installs[n_install++] = pkg;
|
|
assert(!pkg->mark && !(pkg->flags & QPKG_INSTALLED));
|
|
pkg->mark = 1;
|
|
}
|
|
|
|
|
|
static void backtrack(void)
|
|
{
|
|
assert(n_install);
|
|
n_install--;
|
|
installs[n_install]->mark = 0;
|
|
}
|
|
|
|
|
|
static int satisfies(const struct pkg *pkg, const struct ref *ref)
|
|
{
|
|
int cmp;
|
|
|
|
if (pkg->id != ref->pkg)
|
|
return 0;
|
|
if (!ref->version)
|
|
return 1;
|
|
assert(pkg->version);
|
|
cmp = comp_versions(pkg->version, ref->version);
|
|
//fprintf(stderr, "%.*s <%d> %.*s\n",
|
|
// ID2PF(pkg->version), cmp, ID2PF(ref->version));
|
|
switch (ref->relop) {
|
|
case rel_eq:
|
|
return !cmp;
|
|
case rel_ge:
|
|
return cmp >= 0;
|
|
case rel_lt:
|
|
return cmp < 0;
|
|
default:
|
|
abort();
|
|
}
|
|
}
|
|
|
|
|
|
static int conflicts(const struct pkg *pkg, const struct list *conf)
|
|
{
|
|
/* @@@ */
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void print_debug(const struct pkg *pkg, const struct stack *top,
|
|
int level)
|
|
{
|
|
const struct stack *p;
|
|
|
|
fprintf(stderr, "%*s", level, "");
|
|
fprintf(stderr, "%.*s %p", ID2PF(pkg->id), pkg);
|
|
if (pkg->version)
|
|
fprintf(stderr, " %.*s", ID2PF(pkg->version));
|
|
fprintf(stderr, " (");
|
|
for (p = top; p; p = p->next)
|
|
fprintf(stderr, "%s%.*s",
|
|
p == top ? "" : " ", ID2PF(p->pkg->id));
|
|
fprintf(stderr, ")");
|
|
if (pkg->mark)
|
|
fprintf(stderr, " +");
|
|
if (pkg->flags & QPKG_INSTALLED)
|
|
fprintf(stderr, " ***");
|
|
fprintf(stderr, "\n");
|
|
}
|
|
|
|
|
|
static void resolve(struct list *next_dep, const struct ref *dep,
|
|
struct stack *top, struct list *conf)
|
|
{
|
|
static int level = 0;
|
|
struct list more_deps;
|
|
struct list more_conf = {
|
|
.next = conf
|
|
};
|
|
struct stack stack;
|
|
struct pkg *pkg;
|
|
|
|
while (!dep) {
|
|
if (!next_dep) {
|
|
done();
|
|
return;
|
|
}
|
|
assert(top->pkg->flags & QPKG_ADDING);
|
|
top->pkg->flags &= ~QPKG_ADDING;
|
|
top = top->next;
|
|
dep = next_dep->refs;
|
|
next_dep = next_dep->next;
|
|
}
|
|
for (pkg = dep->pkg->jrb->val; pkg; pkg = pkg->more) {
|
|
if (best && n_install == n_best)
|
|
return;
|
|
if (debug)
|
|
print_debug(pkg, top, level);
|
|
if (!satisfies(pkg, dep))
|
|
continue;
|
|
if (pkg->flags & QPKG_ADDING) {
|
|
fprintf(stderr, "package %.*s version %.*s "
|
|
"has cyclic dependency\n",
|
|
ID2PF(pkg->id), ID2PF(pkg->version));
|
|
exit(1);
|
|
}
|
|
if ((pkg->flags & QPKG_INSTALLED) || pkg->mark) {
|
|
assert(!conflicts(pkg, conf));
|
|
resolve(next_dep, dep->next, top, conf);
|
|
continue;
|
|
}
|
|
if (conflicts(pkg, conf))
|
|
continue;
|
|
level++;
|
|
append_install(pkg);
|
|
more_deps.refs = dep->next;
|
|
more_deps.next = next_dep;
|
|
more_conf.refs = pkg->conflicts;
|
|
more_conf.next = conf;
|
|
stack.pkg = pkg;
|
|
stack.next = top;
|
|
pkg->flags |= QPKG_ADDING;
|
|
resolve(&more_deps, pkg->depends, &stack, &more_conf);
|
|
backtrack();
|
|
level--;
|
|
}
|
|
|
|
/*
|
|
* @@@ this shouldn't be all of the story yet. if we fail a dependency
|
|
* due to a conflict, the current algorithm may leave packages marked
|
|
* as QPKG_ADDING, possibly triggering a false cyclic dependency error.
|
|
*
|
|
* In the case if cycle detection, we could avoid all the hassle of
|
|
* maintaining this flag and just walk down the stack to see if we're
|
|
* already trying to add the package (the stack should be correct with
|
|
* the current algorithm), but we'll need this kind of accurate
|
|
* tracking of package state for ordering the dependencies and for
|
|
* "Provides" anyway.
|
|
*/
|
|
}
|
|
|
|
|
|
struct pkg **prereq(struct pkg *pkg)
|
|
{
|
|
struct stack stack = {
|
|
.pkg = pkg,
|
|
.next = NULL
|
|
};
|
|
/* @@@ make list of pre-existing conflicts */
|
|
pkg->flags |= QPKG_ADDING;
|
|
resolve(NULL, pkg->depends, &stack, NULL);
|
|
pkg->flags &= ~QPKG_ADDING;
|
|
free(installs);
|
|
return best;
|
|
}
|