From: Michael Schroeder <mls@suse.de>
Date: Wed, 25 May 2011 13:28:34 +0000 (+0200)
Subject: - add solver_private.h, make repo_ functions return an int, make solver_solv return... 
X-Git-Tag: BASE-SuSE-Code-12_1-Branch~49
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=66e7a252604ae81a027a2c7b8c437b7228eddcc4;p=thirdparty%2Flibsolv.git

- add solver_private.h, make repo_ functions return an int, make solver_solv return the problem count
---

diff --git a/examples/solv.c b/examples/solv.c
index d8e1acca..2e8b3436 100644
--- a/examples/solv.c
+++ b/examples/solv.c
@@ -2947,8 +2947,7 @@ rerunsolver:
       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);
diff --git a/ext/repo_content.c b/ext/repo_content.c
index 29279cb0..102f4813 100644
--- a/ext/repo_content.c
+++ b/ext/repo_content.c
@@ -196,7 +196,7 @@ add_multiple_urls(Repodata *data, Id handle, char *value, Id type)
  *
  */
 
-void
+int
 repo_add_content(Repo *repo, FILE *fp, int flags)
 {
   Pool *pool = repo->pool;
@@ -545,4 +545,5 @@ repo_add_content(Repo *repo, FILE *fp, int flags)
   join_freemem();
   if (!(flags & REPO_NO_INTERNALIZE))
     repodata_internalize(data);
+  return 0;
 }
diff --git a/ext/repo_content.h b/ext/repo_content.h
index c2e79bc6..2a70ce43 100644
--- a/ext/repo_content.h
+++ b/ext/repo_content.h
@@ -5,4 +5,4 @@
  * for further information
  */
 
-void repo_add_content(Repo *repo, FILE *fp, int flags);
+extern int repo_add_content(Repo *repo, FILE *fp, int flags);
diff --git a/ext/repo_deb.c b/ext/repo_deb.c
index d299f9a1..6e89d195 100644
--- a/ext/repo_deb.c
+++ b/ext/repo_deb.c
@@ -347,7 +347,7 @@ control2solvable(Solvable *s, Repodata *data, char *control)
     }
 }
 
-void
+int
 repo_add_debpackages(Repo *repo, FILE *fp, int flags)
 {
   Pool *pool = repo->pool;
@@ -409,9 +409,10 @@ repo_add_debpackages(Repo *repo, FILE *fp, int flags)
   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;
@@ -425,9 +426,10 @@ repo_add_debdb(Repo *repo, const char *rootdir, int flags)
     }
   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;
@@ -597,6 +599,7 @@ repo_add_debs(Repo *repo, const char **debs, int ndebs, int flags)
     }
   if (!(flags & REPO_NO_INTERNALIZE))
     repodata_internalize(data);
+  return 0;
 }
 
 Id
diff --git a/ext/repo_deb.h b/ext/repo_deb.h
index ded3675b..4d3e0194 100644
--- a/ext/repo_deb.h
+++ b/ext/repo_deb.h
@@ -5,9 +5,9 @@
  * 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)
diff --git a/ext/repo_deltainfoxml.h b/ext/repo_deltainfoxml.h
index 6621565f..6647b159 100644
--- a/ext/repo_deltainfoxml.h
+++ b/ext/repo_deltainfoxml.h
@@ -5,4 +5,4 @@
  * for further information
  */
 
-void repo_add_deltainfoxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_deltainfoxml(Repo *repo, FILE *fp, int flags);
diff --git a/ext/repo_helix.c b/ext/repo_helix.c
index d5255f9f..9db6befc 100644
--- a/ext/repo_helix.c
+++ b/ext/repo_helix.c
@@ -805,7 +805,7 @@ characterData(void *userData, const XML_Char *s, int len)
  * 
  */
 
-void
+int
 repo_add_helix(Repo *repo, FILE *fp, int flags)
 {
   Pool *pool = repo->pool;
@@ -868,4 +868,5 @@ repo_add_helix(Repo *repo, FILE *fp, int flags)
   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;
 }
diff --git a/ext/repo_helix.h b/ext/repo_helix.h
index 0b2bec96..d883dd98 100644
--- a/ext/repo_helix.h
+++ b/ext/repo_helix.h
@@ -21,7 +21,7 @@ extern "C" {
 #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
 }
diff --git a/ext/repo_products.h b/ext/repo_products.h
index 6f4ce853..748b8135 100644
--- a/ext/repo_products.h
+++ b/ext/repo_products.h
@@ -5,5 +5,5 @@
  * 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);
diff --git a/ext/repo_releasefile_products.c b/ext/repo_releasefile_products.c
index ec202a98..7a7c217f 100644
--- a/ext/repo_releasefile_products.c
+++ b/ext/repo_releasefile_products.c
@@ -110,7 +110,7 @@ add_releasefile_product(Repo *repo, FILE *fp)
 }
 
 
-void
+int
 repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags)
 {
   DIR *dir;
@@ -120,7 +120,7 @@ repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags)
 
   dir = opendir(dirpath);
   if (!dir)
-    return;
+    return 0;
 
   while ((entry = readdir(dir)))
     {
@@ -145,5 +145,6 @@ repo_add_releasefile_products(Repo *repo, const char *dirpath, int flags)
 
   if (!(flags & REPO_NO_INTERNALIZE) && (flags & REPO_REUSE_REPODATA) != 0)
     repodata_internalize(repo_last_repodata(repo));
+  return 0;
 }
 
diff --git a/ext/repo_releasefile_products.h b/ext/repo_releasefile_products.h
index 34311ac1..05359751 100644
--- a/ext/repo_releasefile_products.h
+++ b/ext/repo_releasefile_products.h
@@ -5,4 +5,4 @@
  * 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);
diff --git a/ext/repo_repomdxml.h b/ext/repo_repomdxml.h
index 49d86fb5..90d9d693 100644
--- a/ext/repo_repomdxml.h
+++ b/ext/repo_repomdxml.h
@@ -5,4 +5,4 @@
  * for further information
  */
 
-void repo_add_repomdxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_repomdxml(Repo *repo, FILE *fp, int flags);
diff --git a/ext/repo_rpmdb.c b/ext/repo_rpmdb.c
index 0755fac4..e152a2ce 100644
--- a/ext/repo_rpmdb.c
+++ b/ext/repo_rpmdb.c
@@ -1362,7 +1362,7 @@ count_headers(const char *rootdir, DB_ENV *dbenv)
  *
  */
 
-void
+int
 repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
 {
   Pool *pool = repo->pool;
@@ -1738,6 +1738,7 @@ repo_add_rpmdb(Repo *repo, Repo *ref, const char *rootdir, int flags)
   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;
 }
 
 
@@ -1748,7 +1749,7 @@ getu32(const unsigned char *dp)
 }
 
 
-void
+int
 repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags)
 {
   int i, sigdsize, sigcnt, l;
@@ -1944,6 +1945,7 @@ repo_add_rpms(Repo *repo, const char **rpms, int nrpms, int flags)
     sat_free(rpmhead);
   if (!(flags & REPO_NO_INTERNALIZE))
     repodata_internalize(data);
+  return 0;
 }
 
 Id
@@ -3054,7 +3056,7 @@ pubkey2solvable(Solvable *s, Repodata *data, char *pubkey)
   return 1;
 }
 
-void
+int
 repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
 {
   Pool *pool = repo->pool;
@@ -3070,7 +3072,7 @@ repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
 
   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++)
     {
@@ -3095,9 +3097,10 @@ repo_add_rpmdb_pubkeys(Repo *repo, const char *rootdir, int flags)
   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;
@@ -3137,4 +3140,5 @@ repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags)
   sat_free(buf);
   if (!(flags & REPO_NO_INTERNALIZE))
     repodata_internalize(data);
+  return 0;
 }
diff --git a/ext/repo_rpmdb.h b/ext/repo_rpmdb.h
index c5903b89..9fcce63e 100644
--- a/ext/repo_rpmdb.h
+++ b/ext/repo_rpmdb.h
@@ -10,11 +10,11 @@
 
 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)
@@ -29,11 +29,11 @@ void repo_add_pubkeys(Repo *repo, const char **keys, int nkeys, int flags);
 #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);
diff --git a/ext/repo_rpmmd.c b/ext/repo_rpmmd.c
index 74c15323..99bea2c5 100644
--- a/ext/repo_rpmmd.c
+++ b/ext/repo_rpmmd.c
@@ -1136,7 +1136,7 @@ characterData(void *userData, const XML_Char *s, int len)
  *
  */
 
-void
+int
 repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
 {
   Pool *pool = repo->pool;
@@ -1226,4 +1226,5 @@ repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
   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;
 }
diff --git a/ext/repo_rpmmd.h b/ext/repo_rpmmd.h
index 931a7f3e..1e88df60 100644
--- a/ext/repo_rpmmd.h
+++ b/ext/repo_rpmmd.h
@@ -5,4 +5,4 @@
  * 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);
diff --git a/ext/repo_susetags.c b/ext/repo_susetags.c
index ad7f374b..80ea3047 100644
--- a/ext/repo_susetags.c
+++ b/ext/repo_susetags.c
@@ -539,7 +539,7 @@ lookup_shared_id(Repodata *data, Id p, Id keyname, Id voidid, int uninternalized
  * flags: flags
  */
 
-void
+int
 repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int flags)
 {
   Pool *pool = repo->pool;
@@ -1206,4 +1206,5 @@ repo_add_susetags(Repo *repo, FILE *fp, Id defvendor, const char *language, int
     free(pd.common.tmp);
   free(line);
   join_freemem();
+  return 0;
 }
diff --git a/ext/repo_susetags.h b/ext/repo_susetags.h
index 975622ed..de110c34 100644
--- a/ext/repo_susetags.h
+++ b/ext/repo_susetags.h
@@ -12,4 +12,4 @@
 #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);
diff --git a/ext/repo_updateinfoxml.c b/ext/repo_updateinfoxml.c
index 7c569fa4..84c9e16a 100644
--- a/ext/repo_updateinfoxml.c
+++ b/ext/repo_updateinfoxml.c
@@ -577,7 +577,7 @@ characterData(void *userData, const XML_Char *s, int len)
 
 #define BUFF_SIZE 8192
 
-void
+int
 repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags)
 {
   Pool *pool = repo->pool;
@@ -624,6 +624,6 @@ repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags)
 
   if (!(flags & REPO_NO_INTERNALIZE))
     repodata_internalize(data);
+  return 0;
 }
 
-/* EOF */
diff --git a/ext/repo_updateinfoxml.h b/ext/repo_updateinfoxml.h
index b20bb60a..bd0a61b6 100644
--- a/ext/repo_updateinfoxml.h
+++ b/ext/repo_updateinfoxml.h
@@ -5,4 +5,4 @@
  * for further information
  */
 
-void repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags);
+extern int repo_add_updateinfoxml(Repo *repo, FILE *fp, int flags);
diff --git a/ext/repo_write.c b/ext/repo_write.c
index 38c2e485..13917faf 100644
--- a/ext/repo_write.c
+++ b/ext/repo_write.c
@@ -967,7 +967,7 @@ repo_write_stdkeyfilter(Repo *repo, Repokey *key, void *kfdata)
  * 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;
@@ -1908,6 +1908,7 @@ fprintf(stderr, "dir %d used %d\n", i, cbdata.dirused ? cbdata.dirused[i] : 1);
   sat_free(cbdata.keymapstart);
   sat_free(cbdata.dirused);
   sat_free(repodataused);
+  return 0;
 }
 
 struct repodata_write_data {
@@ -1931,7 +1932,7 @@ repodata_write_keyfilter(Repo *repo, Repokey *key, void *kfdata)
   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;
@@ -1939,5 +1940,5 @@ repodata_write(Repodata *data, FILE *fp, int (*keyfilter)(Repo *repo, Repokey *k
   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);
 }
diff --git a/ext/repo_write.h b/ext/repo_write.h
index 87a79d43..9f93f057 100644
--- a/ext/repo_write.h
+++ b/ext/repo_write.h
@@ -17,9 +17,9 @@
 
 #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
diff --git a/ext/repo_zyppdb.h b/ext/repo_zyppdb.h
index 8c4a5da7..c3c7f39a 100644
--- a/ext/repo_zyppdb.h
+++ b/ext/repo_zyppdb.h
@@ -5,4 +5,4 @@
  * 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);
diff --git a/src/libsolv.ver b/src/libsolv.ver
index a992a6b9..8e17b42e 100644
--- a/src/libsolv.ver
+++ b/src/libsolv.ver
@@ -30,7 +30,6 @@ SOLV_1.0 {
 		map_grow;
 		map_init;
 		map_init_clone;
-		policy_create_obsolete_index;
 		policy_filter_unwanted;
 		policy_findupdatepackages;
 		policy_illegal2str;
@@ -253,6 +252,7 @@ SOLV_1.0 {
 		solver_calculate_noobsmap;
 		solver_create;
 		solver_create_decisions_obsoletesmap;
+		solver_create_state_maps;
 		solver_dep_installed;
 		solver_disablechoicerules;
 		solver_disablepolicyrules;
diff --git a/src/policy.c b/src/policy.c
index 8ca71f47..ab5f55be 100644
--- a/src/policy.c
+++ b/src/policy.c
@@ -16,6 +16,7 @@
 #include <string.h>
 
 #include "solver.h"
+#include "solver_private.h"
 #include "evr.h"
 #include "policy.h"
 #include "poolvendor.h"
@@ -259,7 +260,7 @@ prune_to_recommended(Solver *solv, Queue *plist)
     plist->count = j;
 }
 
-void
+static void
 prune_to_best_arch(const Pool *pool, Queue *plist)
 {
   Id a, bestscore;
@@ -350,7 +351,7 @@ prune_obsoleted(Pool *pool, Queue *plist)
  * 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;
@@ -407,7 +408,7 @@ prune_to_best_version(Pool *pool, Queue *plist)
  * (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)
diff --git a/src/policy.h b/src/policy.h
index b0729295..734ffde2 100644
--- a/src/policy.h
+++ b/src/policy.h
@@ -16,46 +16,6 @@
 #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
@@ -65,10 +25,7 @@ extern void policy_filter_unwanted(Solver *solv, Queue *plist, int mode);
 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);
 
diff --git a/src/pool.h b/src/pool.h
index 2b1a93bc..8887f438 100644
--- a/src/pool.h
+++ b/src/pool.h
@@ -87,8 +87,8 @@ struct _Pool {
   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
diff --git a/src/problems.c b/src/problems.c
index ce756147..6073e015 100644
--- a/src/problems.c
+++ b/src/problems.c
@@ -17,6 +17,7 @@
 #include <assert.h>
 
 #include "solver.h"
+#include "solver_private.h"
 #include "bitmap.h"
 #include "pool.h"
 #include "util.h"
diff --git a/src/repo.h b/src/repo.h
index fbec7bf5..fd2bde13 100644
--- a/src/repo.h
+++ b/src/repo.h
@@ -38,10 +38,10 @@ typedef struct _Repo {
   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);
@@ -216,9 +216,9 @@ typedef struct _Dataiterator
 
 } 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
@@ -246,18 +246,18 @@ int datamatcher_match(Datamatcher *ma, const char *str);
  * 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);
diff --git a/src/rules.c b/src/rules.c
index db397179..af8ca3c0 100644
--- a/src/rules.c
+++ b/src/rules.c
@@ -18,6 +18,7 @@
 #include <assert.h>
 
 #include "solver.h"
+#include "solver_private.h"
 #include "bitmap.h"
 #include "pool.h"
 #include "poolarch.h"
diff --git a/src/solver.c b/src/solver.c
index 2d708500..e8b35f3a 100644
--- a/src/solver.c
+++ b/src/solver.c
@@ -18,6 +18,7 @@
 #include <assert.h>
 
 #include "solver.h"
+#include "solver_private.h"
 #include "bitmap.h"
 #include "pool.h"
 #include "util.h"
@@ -1274,7 +1275,6 @@ solver_create(Pool *pool)
   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);
 
@@ -1315,7 +1315,6 @@ solver_free(Solver *solv)
   queue_free(&solv->recommendations);
   queue_free(&solv->orphaned);
   queue_free(&solv->branches);
-  queue_free(&solv->covenantq);
   queue_free(&solv->weakruleq);
   queue_free(&solv->ruleassertions);
 
@@ -2488,7 +2487,7 @@ solver_addjobrule(Solver *solv, Id p, Id d, Id job, int weak)
  *
  */
 
-void
+int
 solver_solve(Solver *solv, Queue *job)
 {
   Pool *pool = solv->pool;
@@ -2511,7 +2510,7 @@ solver_solve(Solver *solv, Queue *job)
   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);
 
@@ -3005,6 +3004,7 @@ solver_solve(Solver *solv, Queue *job)
 
   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;
 }
 
 /***********************************************************************/
@@ -3043,11 +3043,17 @@ solver_calc_installsizechange(Solver *solv)
   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);
 }
diff --git a/src/solver.h b/src/solver.h
index 16f6dafc..cc930e9f 100644
--- a/src/solver.h
+++ b/src/solver.h
@@ -36,9 +36,8 @@ typedef int  (*VendorCheckCb) (Pool *pool, Solvable *solvable1, Solvable *solvab
 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 */
 
@@ -169,7 +168,7 @@ typedef struct _Solver {
    *     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
    *
@@ -178,7 +177,7 @@ typedef struct _Solver {
    *     
    *     return 0 it the two solvables has compatible architectures
    */
-   ArchCheckCb archCheckCb;
+  ArchCheckCb archCheckCb;
 
   /* Checking if two solvables has compatible vendors
    *
@@ -187,7 +186,7 @@ typedef struct _Solver {
    *     
    *     return 0 it the two solvables has compatible architectures
    */
-   VendorCheckCb vendorCheckCb;
+  VendorCheckCb vendorCheckCb;
     
   /* Evaluate update candidate
    *
@@ -197,13 +196,8 @@ typedef struct _Solver {
    *     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 */
@@ -214,7 +208,11 @@ typedef struct _Solver {
   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
@@ -292,88 +290,20 @@ typedef struct _Solver {
 
 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 */
diff --git a/src/solver_private.h b/src/solver_private.h
new file mode 100644
index 00000000..a563fa8c
--- /dev/null
+++ b/src/solver_private.h
@@ -0,0 +1,251 @@
+/*
+ * 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 */
diff --git a/src/solverdebug.c b/src/solverdebug.c
index 7cc737e1..44d7fca6 100644
--- a/src/solverdebug.c
+++ b/src/solverdebug.c
@@ -18,6 +18,7 @@
 #include <assert.h>
 
 #include "solver.h"
+#include "solver_private.h"
 #include "solverdebug.h"
 #include "bitmap.h"
 #include "pool.h"
diff --git a/tools/findfileconflicts.c b/tools/findfileconflicts.c
index 9c5a1a55..9d7f1a2f 100644
--- a/tools/findfileconflicts.c
+++ b/tools/findfileconflicts.c
@@ -54,18 +54,20 @@ int main()
   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);
diff --git a/tools/installcheck.c b/tools/installcheck.c
index 7d9e2865..91eeab01 100644
--- a/tools/installcheck.c
+++ b/tools/installcheck.c
@@ -242,6 +242,7 @@ main(int argc, char **argv)
   for (i = 0; i < cand.count; i++)
     {
       Solvable *s;
+      int problemcount;
 
       p = cand.elements[i];
       if (nocheck && p >= nocheck)
@@ -282,8 +283,8 @@ main(int argc, char **argv)
 	  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;
diff --git a/tools/patchcheck.c b/tools/patchcheck.c
index c107c6ca..ce8d8cde 100644
--- a/tools/patchcheck.c
+++ b/tools/patchcheck.c
@@ -290,8 +290,7 @@ test_all_packages_installable(context_t *c, Id pid)
           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");
@@ -320,8 +319,7 @@ test_all_packages_installable(context_t *c, Id pid)
           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);
@@ -420,9 +418,7 @@ test_can_upgrade_all_packages(context_t *c, Id pid)
       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);