if (mainmode == MODE_ERASE || mainmode == MODE_ERASECLEAN)
solv->allowuninstall = 1; /* don't nag */
- solver_solve(solv, &job);
- if (!solv->problems.count)
+ if (!solver_solve(solv, &job))
break;
pcnt = solver_problem_count(solv);
printf("Found %d problems:\n", pcnt);
*
*/
-void
+int
repo_add_content(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
join_freemem();
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
* for further information
*/
-void repo_add_content(Repo *repo, FILE *fp, int flags);
+extern int repo_add_content(Repo *repo, FILE *fp, int flags);
}
}
-void
+int
repo_add_debpackages(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
sat_free(buf);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
-void
+int
repo_add_debdb(Repo *repo, const char *rootdir, int flags)
{
FILE *fp;
}
repo_add_debpackages(repo, fp, flags);
fclose(fp);
+ return 0;
}
-void
+int
repo_add_debs(Repo *repo, const char **debs, int ndebs, int flags)
{
Pool *pool = repo->pool;
}
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
Id
* for further information
*/
-extern void repo_add_debpackages(Repo *repo, FILE *fp, int flags);
-extern void repo_add_debdb(Repo *repo, const char *rootdir, int flags);
-extern void repo_add_debs(Repo *repo, const char **debs, int ndebs, int flags);
+extern int repo_add_debpackages(Repo *repo, FILE *fp, int flags);
+extern int repo_add_debdb(Repo *repo, const char *rootdir, int flags);
+extern int repo_add_debs(Repo *repo, const char **debs, int ndebs, int flags);
extern Id repo_add_deb(Repo *repo, const char *deb, int flags);
#define DEBS_ADD_WITH_PKGID (1 << 8)
* for further information
*/
-void repo_add_deltainfoxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_deltainfoxml(Repo *repo, FILE *fp, int flags);
*
*/
-void
+int
repo_add_helix(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_helix took %d ms\n", sat_timems(now));
POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
+ return 0;
}
#include "pool.h"
#include "repo.h"
-extern void repo_add_helix(Repo *repo, FILE *fp, int flags);
+extern int repo_add_helix(Repo *repo, FILE *fp, int flags);
#ifdef __cplusplus
}
* for further information
*/
-void repo_add_code11_products(Repo *repo, const char *dirpath, int flags);
-void repo_add_products(Repo *repo, const char *proddir, const char *root, int flags);
+extern int repo_add_code11_products(Repo *repo, const char *dirpath, int flags);
+extern int repo_add_products(Repo *repo, const char *proddir, const char *root, int flags);
}
-void
+int
repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags)
{
DIR *dir;
dir = opendir(dirpath);
if (!dir)
- return;
+ return 0;
while ((entry = readdir(dir)))
{
if (!(flags & REPO_NO_INTERNALIZE) && (flags & REPO_REUSE_REPODATA) != 0)
repodata_internalize(repo_last_repodata(repo));
+ return 0;
}
* for further information
*/
-void repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags);
+extern int repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags);
* for further information
*/
-void repo_add_repomdxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_repomdxml(Repo *repo, FILE *fp, int flags);
*
*/
-void
+int
repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
{
Pool *pool = repo->pool;
POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_rpmdb took %d ms\n", sat_timems(now));
POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
+ return 0;
}
}
-void
+int
repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags)
{
int i, sigdsize, sigcnt, l;
sat_free(rpmhead);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
Id
return 1;
}
-void
+int
repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
{
Pool *pool = repo->pool;
memset(&state, 0, sizeof(state));
if (!(state.dbenv = opendbenv(rootdir)))
- return;
+ return 0;
entries = getinstalledrpmdbids(&state, "Name", "gpg-pubkey", &nentries, &namedata);
for (i = 0 ; i < nentries; i++)
{
freestate(&state);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
-void
+int
repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags)
{
Pool *pool = repo->pool;
sat_free(buf);
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
struct headerToken_s;
-extern void repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags);
-extern void repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags);
+extern int repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags);
+extern int repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags);
extern Id repo_add_rpm(Repo *repo, const char *rpm, int flags);
-void repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags);
-void repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags);
+extern int repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags);
+extern int repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags);
#define RPMDB_REPORT_PROGRESS (1 << 8)
#define RPM_ADD_WITH_PKGID (1 << 9)
#define RPM_ITERATE_FILELIST_WITHCOL (1 << 2)
#define RPM_ITERATE_FILELIST_NOGHOSTS (1 << 3)
-void *rpm_byrpmdbid(Id rpmdbid, const char *rootdir, void **statep);
-void *rpm_byfp(FILE *fp, const char *name, void **statep);
-void *rpm_byrpmh(struct headerToken_s *h, void **statep);
+extern void *rpm_byrpmdbid(Id rpmdbid, const char *rootdir, void **statep);
+extern void *rpm_byfp(FILE *fp, const char *name, void **statep);
+extern void *rpm_byrpmh(struct headerToken_s *h, void **statep);
-char *rpm_query(void *rpmhandle, Id what);
-void rpm_iterate_filelist(void *rpmhandle, int flags, void (*cb)(void *, const char *, int, const char *), void *cbdata);
-int rpm_installedrpmdbids(const char *rootdir, const char *index, const char *match, Queue *rpmdbidq);
+extern char *rpm_query(void *rpmhandle, Id what);
+extern void rpm_iterate_filelist(void *rpmhandle, int flags, void (*cb)(void *, const char *, int, const char *), void *cbdata);
+extern int rpm_installedrpmdbids(const char *rootdir, const char *index, const char *match, Queue *rpmdbidq);
*
*/
-void
+int
repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
{
Pool *pool = repo->pool;
POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", sat_timems(now));
POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
+ return 0;
}
* for further information
*/
-extern void repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags);
+extern int repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags);
* flags: flags
*/
-void
+int
repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int flags)
{
Pool *pool = repo->pool;
free(pd.common.tmp);
free(line);
join_freemem();
+ return 0;
}
#define SUSETAGS_EXTEND (1 << 9)
#define SUSETAGS_RECORD_SHARES (1 << 10)
-extern void repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int flags);
+extern int repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int flags);
#define BUFF_SIZE 8192
-void
+int
repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags)
{
Pool *pool = repo->pool;
if (!(flags & REPO_NO_INTERNALIZE))
repodata_internalize(data);
+ return 0;
}
-/* EOF */
* for further information
*/
-void repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags);
* 4) encode data into buffers using the mapping tables
* 5) write everything to disk
*/
-void
+int
repo_write(Repo *repo, FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata, Id **keyarrayp)
{
Pool *pool = repo->pool;
sat_free(cbdata.keymapstart);
sat_free(cbdata.dirused);
sat_free(repodataused);
+ return 0;
}
struct repodata_write_data {
return key->storage;
}
-void
+int
repodata_write(Repodata *data, FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata)
{
struct repodata_write_data wd;
wd.keyfilter = keyfilter;
wd.kfdata = kfdata;
wd.repodataid = data - data->repo->repodata;
- repo_write(data->repo, fp, repodata_write_keyfilter, &wd, 0);
+ return repo_write(data->repo, fp, repodata_write_keyfilter, &wd, 0);
}
#include "repo.h"
-void repo_write(Repo *repo, FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata, Id **keyarrayp);
-int repo_write_stdkeyfilter(Repo *repo, Repokey *key, void *kfdata);
+extern int repo_write(Repo *repo, FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata, Id **keyarrayp);
+extern int repo_write_stdkeyfilter(Repo *repo, Repokey *key, void *kfdata);
-void repodata_write(Repodata *data , FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata);
+extern int repodata_write(Repodata *data , FILE *fp, int (*keyfilter)(Repo *repo, Repokey *key, void *kfdata), void *kfdata);
#endif
* for further information
*/
-void repo_add_zyppdb_products(Repo *repo, const char *dirpath, int flags);
+extern int repo_add_zyppdb_products(Repo *repo, const char *dirpath, int flags);
map_grow;
map_init;
map_init_clone;
- policy_create_obsolete_index;
policy_filter_unwanted;
policy_findupdatepackages;
policy_illegal2str;
solver_calculate_noobsmap;
solver_create;
solver_create_decisions_obsoletesmap;
+ solver_create_state_maps;
solver_dep_installed;
solver_disablechoicerules;
solver_disablepolicyrules;
#include <string.h>
#include "solver.h"
+#include "solver_private.h"
#include "evr.h"
#include "policy.h"
#include "poolvendor.h"
plist->count = j;
}
-void
+static void
prune_to_best_arch(const Pool *pool, Queue *plist)
{
Id a, bestscore;
* sort list of packages (given through plist) by name and evr
* return result through plist
*/
-void
+static void
prune_to_best_version(Pool *pool, Queue *plist)
{
int i, j;
* (rates arch higher than version, but thats a policy)
*/
-void
+static void
prune_best_arch_name_version(const Solver *solv, Pool *pool, Queue *plist)
{
if (solv && solv->bestSolvableCb)
#define POLICY_MODE_RECOMMEND 1
#define POLICY_MODE_SUGGEST 2
-/* This functions can be used for sorting solvables to a specific order like architecture, version. */
-/* Solvables which does not fit to the system will be deleted from the list. */
-extern void prune_best_arch_name_version(const Solver *solv, Pool *pool, Queue *plist);
-
-extern void prune_to_best_arch(const Pool *pool, Queue *plist);
-extern void prune_to_best_version(Pool *pool, Queue *plist);
-
-
-/* The following default policies can be overloaded by the application by using callbacks which are
- * descibed in solver.h:
- *
- * Finding best candidate
- *
- * Callback definition:
- * void bestSolvable (Pool *pool, Queue *canditates)
- * candidates : List of canditates which has to be sorted by the function call
- * return candidates: Sorted list of the candidates(first is the best).
- *
- * Checking if two solvables has compatible architectures
- *
- * Callback definition:
- * int archCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
- *
- * return 0 it the two solvables has compatible architectures
- *
- * Checking if two solvables has compatible vendors
- *
- * Callback definition:
- * int vendorCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
- *
- * return 0 it the two solvables has compatible architectures
- *
- * Evaluate update candidate
- *
- * Callback definition:
- * void pdateCandidateCb (Pool *pool, Solvable *solvable, Queue *canditates)
- * solvable : for which updates should be search
- * candidates : List of candidates (This list depends on other
- * restrictions like architecture and vendor policies too)
- */
#define POLICY_ILLEGAL_DOWNGRADE 1
#define POLICY_ILLEGAL_ARCHCHANGE 2
extern int policy_illegal_archchange(Solver *solv, Solvable *s1, Solvable *s2);
extern int policy_illegal_vendorchange(Solver *solv, Solvable *s1, Solvable *s2);
extern int policy_is_illegal(Solver *solv, Solvable *s1, Solvable *s2, int ignore);
-extern void policy_findupdatepackages(Solver *solv,
- Solvable *s,
- Queue *qs,
- int allowall); /* do not regard policies for vendor,architecuture,... change */
+extern void policy_findupdatepackages(Solver *solv, Solvable *s, Queue *qs, int allowall);
extern void policy_create_obsolete_index(Solver *solv);
int implicitobsoleteusesprovides; /* true: implicit obsoletes due to same name are matched against provides, not names */
int obsoleteusescolors; /* true: obsoletes check arch color */
int noinstalledobsoletes; /* true: ignore obsoletes of installed packages */
- int novirtualconflicts; /* true: conflicts on names, not on provides */
int allowselfconflicts; /* true: packages which conflict with itself are installable */
+
#ifdef MULTI_SEMANTICS
int disttype;
#endif
#include <assert.h>
#include "solver.h"
+#include "solver_private.h"
#include "bitmap.h"
#include "pool.h"
#include "util.h"
int idarraysize;
Offset lastoff; /* start of last array in idarraydata */
- Id *rpmdbid; /* solvable side data */
-
Repodata *repodata; /* our stores for non-solvable related data */
unsigned nrepodata; /* number of our stores.. */
+
+ Id *rpmdbid; /* solvable side data: rpm database id */
} Repo;
extern Repo *repo_create(Pool *pool, const char *name);
} Dataiterator;
-int datamatcher_init(Datamatcher *ma, const char *match, int flags);
+int datamatcher_init(Datamatcher *ma, const char *match, int flags);
void datamatcher_free(Datamatcher *ma);
-int datamatcher_match(Datamatcher *ma, const char *str);
+int datamatcher_match(Datamatcher *ma, const char *str);
/*
* Dataiterator
* keyname: if non-null, limit search to this keyname
* match: if non-null, limit search to this match
*/
-int dataiterator_init(Dataiterator *di, Pool *pool, Repo *repo, Id p, Id keyname, const char *match, int flags);
+int dataiterator_init(Dataiterator *di, Pool *pool, Repo *repo, Id p, Id keyname, const char *match, int flags);
void dataiterator_init_clone(Dataiterator *di, Dataiterator *from);
void dataiterator_set_search(Dataiterator *di, Repo *repo, Id p);
void dataiterator_set_keyname(Dataiterator *di, Id keyname);
-int dataiterator_set_match(Dataiterator *di, const char *match, int flags);
+int dataiterator_set_match(Dataiterator *di, const char *match, int flags);
void dataiterator_prepend_keyname(Dataiterator *di, Id keyname);
void dataiterator_free(Dataiterator *di);
-int dataiterator_step(Dataiterator *di);
+int dataiterator_step(Dataiterator *di);
void dataiterator_setpos(Dataiterator *di);
void dataiterator_setpos_parent(Dataiterator *di);
-int dataiterator_match(Dataiterator *di, Datamatcher *ma);
+int dataiterator_match(Dataiterator *di, Datamatcher *ma);
void dataiterator_skip_attribute(Dataiterator *di);
void dataiterator_skip_solvable(Dataiterator *di);
void dataiterator_skip_repo(Dataiterator *di);
#include <assert.h>
#include "solver.h"
+#include "solver_private.h"
#include "bitmap.h"
#include "pool.h"
#include "poolarch.h"
#include <assert.h>
#include "solver.h"
+#include "solver_private.h"
#include "bitmap.h"
#include "pool.h"
#include "util.h"
queue_init(&solv->learnt_why);
queue_init(&solv->learnt_pool);
queue_init(&solv->branches);
- queue_init(&solv->covenantq);
queue_init(&solv->weakruleq);
queue_init(&solv->ruleassertions);
queue_free(&solv->recommendations);
queue_free(&solv->orphaned);
queue_free(&solv->branches);
- queue_free(&solv->covenantq);
queue_free(&solv->weakruleq);
queue_free(&solv->ruleassertions);
*
*/
-void
+int
solver_solve(Solver *solv, Queue *job)
{
Pool *pool = solv->pool;
POOL_DEBUG(SAT_DEBUG_STATS, "fixsystem=%d updatesystem=%d dosplitprovides=%d, noupdateprovide=%d noinfarchcheck=%d\n", solv->fixsystem, solv->updatesystem, solv->dosplitprovides, solv->noupdateprovide, solv->noinfarchcheck);
POOL_DEBUG(SAT_DEBUG_STATS, "distupgrade=%d distupgrade_removeunsupported=%d\n", solv->distupgrade, solv->distupgrade_removeunsupported);
POOL_DEBUG(SAT_DEBUG_STATS, "allowuninstall=%d, allowdowngrade=%d, allowarchchange=%d, allowvendorchange=%d\n", solv->allowuninstall, solv->allowdowngrade, solv->allowarchchange, solv->allowvendorchange);
- POOL_DEBUG(SAT_DEBUG_STATS, "promoteepoch=%d, novirtualconflicts=%d, allowselfconflicts=%d\n", pool->promoteepoch, pool->novirtualconflicts, pool->allowselfconflicts);
+ POOL_DEBUG(SAT_DEBUG_STATS, "promoteepoch=%d, allowselfconflicts=%d\n", pool->promoteepoch, pool->allowselfconflicts);
POOL_DEBUG(SAT_DEBUG_STATS, "obsoleteusesprovides=%d, implicitobsoleteusesprovides=%d, obsoleteusescolors=%d\n", pool->obsoleteusesprovides, pool->implicitobsoleteusesprovides, pool->obsoleteusescolors);
POOL_DEBUG(SAT_DEBUG_STATS, "dontinstallrecommended=%d, ignorealreadyrecommended=%d, dontshowinstalledrecommended=%d\n", solv->dontinstallrecommended, solv->ignorealreadyrecommended, solv->dontshowinstalledrecommended);
POOL_DEBUG(SAT_DEBUG_STATS, "final solver statistics: %d problems, %d learned rules, %d unsolvable\n", solv->problems.count / 2, solv->stats_learned, solv->stats_unsolvable);
POOL_DEBUG(SAT_DEBUG_STATS, "solver_solve took %d ms\n", sat_timems(solve_start));
+ return solv->problems.count ? solv->problems.count / 2 : 0;
}
/***********************************************************************/
return change;
}
+void
+solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap)
+{
+ pool_create_state_maps(solv->pool, &solv->decisionq, installedmap, conflictsmap);
+}
+
void
solver_trivial_installable(Solver *solv, Queue *pkgs, Queue *res)
{
Map installedmap;
- solver_create_state_maps(solv, &installedmap, 0);
+ pool_create_state_maps(solv->pool, &solv->decisionq, &installedmap, 0);
pool_trivial_installable_noobsoletesmap(solv->pool, &installedmap, pkgs, res, solv->noobsoletes.size ? &solv->noobsoletes : 0);
map_free(&installedmap);
}
typedef void (*UpdateCandidateCb) (Pool *pool, Solvable *solvable, Queue *canditates);
-struct _Solver;
-
-typedef struct _Solver {
+#if 1
+struct _Solver {
Pool *pool; /* back pointer to pool */
Queue job; /* copy of the job we're solving */
* candidates : List of canditates which has to be sorted by the function call
* return candidates: Sorted list of the candidates(first is the best).
*/
- BestSolvableCb bestSolvableCb;
+ BestSolvableCb bestSolvableCb;
/* Checking if two solvables has compatible architectures
*
*
* return 0 it the two solvables has compatible architectures
*/
- ArchCheckCb archCheckCb;
+ ArchCheckCb archCheckCb;
/* Checking if two solvables has compatible vendors
*
*
* return 0 it the two solvables has compatible architectures
*/
- VendorCheckCb vendorCheckCb;
+ VendorCheckCb vendorCheckCb;
/* Evaluate update candidate
*
* candidates : List of candidates (This list depends on other
* restrictions like architecture and vendor policies too)
*/
- UpdateCandidateCb updateCandidateCb;
+ UpdateCandidateCb updateCandidateCb;
-
- /* some strange queue that doesn't belong here */
- Queue covenantq; /* Covenants honored by this solver (generic locks) */
-
-
Map dupmap; /* dup these packages*/
int dupmap_all; /* dup all packages */
Map dupinvolvedmap; /* packages involved in dup process */
Map cleandepsmap; /* try to drop these packages as of cleandeps erases */
Queue *ruleinfoq; /* tmp space for solver_ruleinfo() */
-} Solver;
+};
+
+#endif
+
+typedef struct _Solver Solver;
/*
* queue commands
extern Solver *solver_create(Pool *pool);
extern void solver_free(Solver *solv);
-extern void solver_solve(Solver *solv, Queue *job);
-
-extern void solver_run_sat(Solver *solv, int disablerules, int doweak);
-extern void solver_reset(Solver *solv);
-
-extern int solver_dep_installed(Solver *solv, Id dep);
-extern int solver_splitprovides(Solver *solv, Id dep);
+extern int solver_solve(Solver *solv, Queue *job);
extern void solver_calculate_noobsmap(Pool *pool, Queue *job, Map *noobsmap);
-
-/* obsolete */
-extern SolverRuleinfo solver_problemruleinfo(Solver *solv, Queue *job, Id rid, Id *depp, Id *sourcep, Id *targetp);
+extern void solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap);
/* XXX: why is this not static? */
Id *solver_create_decisions_obsoletesmap(Solver *solv);
-static inline int
-solver_dep_fulfilled(Solver *solv, Id dep)
-{
- Pool *pool = solv->pool;
- Id p, pp;
-
- if (ISRELDEP(dep))
- {
- Reldep *rd = GETRELDEP(pool, dep);
- if (rd->flags == REL_AND)
- {
- if (!solver_dep_fulfilled(solv, rd->name))
- return 0;
- return solver_dep_fulfilled(solv, rd->evr);
- }
- if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
- return solver_splitprovides(solv, rd->evr);
- if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
- return solver_dep_installed(solv, rd->evr);
- }
- FOR_PROVIDES(p, pp, dep)
- {
- if (solv->decisionmap[p] > 0)
- return 1;
- }
- return 0;
-}
-
-static inline int
-solver_is_supplementing(Solver *solv, Solvable *s)
-{
- Id sup, *supp;
- if (!s->supplements)
- return 0;
- supp = s->repo->idarraydata + s->supplements;
- while ((sup = *supp++) != 0)
- if (solver_dep_fulfilled(solv, sup))
- return 1;
- return 0;
-}
-
-static inline int
-solver_is_enhancing(Solver *solv, Solvable *s)
-{
- Id enh, *enhp;
- if (!s->enhances)
- return 0;
- enhp = s->repo->idarraydata + s->enhances;
- while ((enh = *enhp++) != 0)
- if (solver_dep_fulfilled(solv, enh))
- return 1;
- return 0;
-}
-
void solver_calc_duchanges(Solver *solv, DUChanges *mps, int nmps);
int solver_calc_installsizechange(Solver *solv);
void solver_trivial_installable(Solver *solv, Queue *pkgs, Queue *res);
void solver_find_involved(Solver *solv, Queue *installedq, Solvable *s, Queue *q);
-static inline void
-solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap)
-{
- pool_create_state_maps(solv->pool, &solv->decisionq, installedmap, conflictsmap);
-}
-
/* iterate over all literals of a rule */
/* WARNING: loop body must not relocate whatprovidesdata, e.g. by
* looking up the providers of a dependency */
--- /dev/null
+/*
+ * Copyright (c) 2011, Novell Inc.
+ *
+ * This program is licensed under the BSD license, read LICENSE.BSD
+ * for further information
+ */
+
+/*
+ * solver_p.h - private functions
+ *
+ */
+
+#ifndef LIBSOLV_SOLVER_P_H
+#define LIBSOLV_SOLVER_P_H
+
+#if 0
+struct _Solver {
+ Pool *pool; /* back pointer to pool */
+ Queue job; /* copy of the job we're solving */
+
+ Transaction trans; /* calculated transaction */
+
+ Repo *installed; /* copy of pool->installed */
+
+ /* list of rules, ordered
+ * rpm rules first, then features, updates, jobs, learnt
+ * see start/end offsets below
+ */
+ Rule *rules; /* all rules */
+ Id nrules; /* [Offset] index of the last rule */
+
+ Queue ruleassertions; /* Queue of all assertion rules */
+
+ /* start/end offset for rule 'areas' */
+
+ Id rpmrules_end; /* [Offset] rpm rules end */
+
+ Id featurerules; /* feature rules start/end */
+ Id featurerules_end;
+
+ Id updaterules; /* policy rules, e.g. keep packages installed or update. All literals > 0 */
+ Id updaterules_end;
+
+ Id jobrules; /* user rules */
+ Id jobrules_end;
+
+ Id infarchrules; /* inferior arch rules */
+ Id infarchrules_end;
+
+ Id duprules; /* dist upgrade rules */
+ Id duprules_end;
+
+ Id choicerules; /* choice rules (always weak) */
+ Id choicerules_end;
+ Id *choicerules_ref;
+
+ Id learntrules; /* learnt rules, (end == nrules) */
+
+ Map noupdate; /* don't try to update these
+ installed solvables */
+ Map noobsoletes; /* ignore obsoletes for these (multiinstall) */
+
+ Map updatemap; /* bring these installed packages to the newest version */
+ int updatemap_all; /* bring all packages to the newest version */
+
+ Map fixmap; /* fix these packages */
+ int fixmap_all; /* fix all packages */
+
+ Queue weakruleq; /* index into 'rules' for weak ones */
+ Map weakrulemap; /* map rule# to '1' for weak rules, 1..learntrules */
+
+ Id *watches; /* Array of rule offsets
+ * watches has nsolvables*2 entries and is addressed from the middle
+ * middle-solvable : decision to conflict, offset point to linked-list of rules
+ * middle+solvable : decision to install: offset point to linked-list of rules
+ */
+
+ Queue ruletojob; /* index into job queue: jobs for which a rule exits */
+
+ /* our decisions: */
+ Queue decisionq; /* >0:install, <0:remove/conflict */
+ Queue decisionq_why; /* index of rule, Offset into rules */
+
+ Id *decisionmap; /* map for all available solvables,
+ * = 0: undecided
+ * > 0: level of decision when installed,
+ * < 0: level of decision when conflict */
+
+ /* learnt rule history */
+ Queue learnt_why;
+ Queue learnt_pool;
+
+ Queue branches;
+ int (*solution_callback)(struct _Solver *solv, void *data);
+ void *solution_callback_data;
+
+ int propagate_index; /* index into decisionq for non-propagated decisions */
+
+ Queue problems; /* list of lists of conflicting rules, < 0 for job rules */
+ Queue solutions; /* refined problem storage space */
+
+ Queue recommendations; /* recommended packages */
+ Queue suggestions; /* suggested packages */
+ Queue orphaned; /* orphaned packages */
+
+ int stats_learned; /* statistic */
+ int stats_unsolvable; /* statistic */
+
+ Map recommendsmap; /* recommended packages from decisionmap */
+ Map suggestsmap; /* suggested packages from decisionmap */
+ int recommends_index; /* recommendsmap/suggestsmap is created up to this level */
+
+ Id *obsoletes; /* obsoletes for each installed solvable */
+ Id *obsoletes_data; /* data area for obsoletes */
+ Id *multiversionupdaters; /* updaters for multiversion packages in updatesystem mode */
+
+ /*-------------------------------------------------------------------------------------------------------------
+ * Solver configuration
+ *-------------------------------------------------------------------------------------------------------------*/
+
+ int fixsystem; /* repair errors in rpm dependency graph */
+ int allowdowngrade; /* allow to downgrade installed solvable */
+ int allowarchchange; /* allow to change architecture of installed solvables */
+ int allowvendorchange; /* allow to change vendor of installed solvables */
+ int allowuninstall; /* allow removal of installed solvables */
+ int updatesystem; /* update all packages to the newest version */
+ int noupdateprovide; /* true: update packages needs not to provide old package */
+ int dosplitprovides; /* true: consider legacy split provides */
+ int dontinstallrecommended; /* true: do not install recommended packages */
+ int ignorealreadyrecommended; /* true: ignore recommended packages that were already recommended by the installed packages */
+ int dontshowinstalledrecommended; /* true: do not show recommended packages that are already installed */
+
+ /* distupgrade also needs updatesystem and dosplitprovides */
+ int distupgrade;
+ int distupgrade_removeunsupported;
+
+ int noinfarchcheck; /* true: do not forbid inferior architectures */
+
+ /* Callbacks for defining the bahaviour of the SAT solver */
+
+ /* Finding best candidate
+ *
+ * Callback definition:
+ * void bestSolvable (Pool *pool, Queue *canditates)
+ * candidates : List of canditates which has to be sorted by the function call
+ * return candidates: Sorted list of the candidates(first is the best).
+ */
+ BestSolvableCb bestSolvableCb;
+
+ /* Checking if two solvables has compatible architectures
+ *
+ * Callback definition:
+ * int archCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
+ *
+ * return 0 it the two solvables has compatible architectures
+ */
+ ArchCheckCb archCheckCb;
+
+ /* Checking if two solvables has compatible vendors
+ *
+ * Callback definition:
+ * int vendorCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
+ *
+ * return 0 it the two solvables has compatible architectures
+ */
+ VendorCheckCb vendorCheckCb;
+
+ /* Evaluate update candidate
+ *
+ * Callback definition:
+ * void pdateCandidateCb (Pool *pool, Solvable *solvable, Queue *canditates)
+ * solvable : for which updates should be search
+ * candidates : List of candidates (This list depends on other
+ * restrictions like architecture and vendor policies too)
+ */
+ UpdateCandidateCb updateCandidateCb;
+
+ Map dupmap; /* dup these packages*/
+ int dupmap_all; /* dup all packages */
+ Map dupinvolvedmap; /* packages involved in dup process */
+
+ Map droporphanedmap; /* packages to drop in dup mode */
+ int droporphanedmap_all;
+
+ Map cleandepsmap; /* try to drop these packages as of cleandeps erases */
+
+ Queue *ruleinfoq; /* tmp space for solver_ruleinfo() */
+};
+#endif
+
+extern void solver_run_sat(Solver *solv, int disablerules, int doweak);
+extern void solver_reset(Solver *solv);
+
+extern int solver_dep_installed(Solver *solv, Id dep);
+extern int solver_splitprovides(Solver *solv, Id dep);
+
+static inline int
+solver_dep_fulfilled(Solver *solv, Id dep)
+{
+ Pool *pool = solv->pool;
+ Id p, pp;
+
+ if (ISRELDEP(dep))
+ {
+ Reldep *rd = GETRELDEP(pool, dep);
+ if (rd->flags == REL_AND)
+ {
+ if (!solver_dep_fulfilled(solv, rd->name))
+ return 0;
+ return solver_dep_fulfilled(solv, rd->evr);
+ }
+ if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
+ return solver_splitprovides(solv, rd->evr);
+ if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
+ return solver_dep_installed(solv, rd->evr);
+ }
+ FOR_PROVIDES(p, pp, dep)
+ {
+ if (solv->decisionmap[p] > 0)
+ return 1;
+ }
+ return 0;
+}
+
+static inline int
+solver_is_supplementing(Solver *solv, Solvable *s)
+{
+ Id sup, *supp;
+ if (!s->supplements)
+ return 0;
+ supp = s->repo->idarraydata + s->supplements;
+ while ((sup = *supp++) != 0)
+ if (solver_dep_fulfilled(solv, sup))
+ return 1;
+ return 0;
+}
+
+static inline int
+solver_is_enhancing(Solver *solv, Solvable *s)
+{
+ Id enh, *enhp;
+ if (!s->enhances)
+ return 0;
+ enhp = s->repo->idarraydata + s->enhances;
+ while ((enh = *enhp++) != 0)
+ if (solver_dep_fulfilled(solv, enh))
+ return 1;
+ return 0;
+}
+
+#endif /* LIBSOLV_SOLVER_P_H */
#include <assert.h>
#include "solver.h"
+#include "solver_private.h"
#include "solverdebug.h"
#include "bitmap.h"
#include "pool.h"
if (conflicts.count)
{
Queue job;
+ int problemcnt;
+
queue_init(&job);
pool_add_fileconflicts_deps(pool, &conflicts);
pool_addfileprovides(pool);
pool_createwhatprovides(pool);
pool_setdebuglevel(pool, 0);
Solver *solv = solver_create(pool);
- solv->fixsystem = 1;
+ queue_push2(&job, SOLVER_VERIFY|SOLVER_SOLVABLE_ALL, 0);
#if 0
solv->allowuninstall = 1;
#endif
- solver_solve(solv, &job);
- if (solv->problems.count)
+ problemcnt = solver_solve(solv, &job);
+ if (problemcnt)
solver_printallsolutions(solv);
else
solver_printtransaction(solv);
for (i = 0; i < cand.count; i++)
{
Solvable *s;
+ int problemcount;
p = cand.elements[i];
if (nocheck && p >= nocheck)
queue_push(&job, archlock);
}
solv->dontinstallrecommended = 1;
- solver_solve(solv, &job);
- if (solv->problems.count)
+ problemcount = solver_solve(solv, &job);
+ if (problemcount)
{
Id problem = 0;
Solvable *s2;
solv = solver_create(pool);
solv->dontinstallrecommended = 0;
++solver_runs;
- solver_solve(solv, &job);
- if (solv->problems.count)
+ if (solver_solve(solv, &job))
{
c->status = 1;
printf("error installing original package\n");
solv = solver_create(pool);
/*solv->dontinstallrecommended = 1;*/
++solver_runs;
- solver_solve(solv, &job);
- if (solv->problems.count)
+ if (solver_solve(solv, &job))
{
c->status = 1;
showproblems(solv, s, 0, 0);
solv = solver_create(pool);
solv->dontinstallrecommended = 1;
++solver_runs;
- solver_solve(solv, &job);
-
- if (solv->problems.count)
+ if (solver_solve(solv, &job))
{
c->status = 1;
showproblems(solv, s, &cand, &badguys);
projects / thirdparty / libsolv.git / commitdiff
