src/solverdebug.c

   1 /*
   2  * Copyright (c) 2008, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * solverdebug.c
  10  *
  11  * debug functions for the SAT solver
  12  */
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <unistd.h>
  17 #include <string.h>
  18 #include <assert.h>
  19
  20 #include "solver.h"
  21 #include "solver_private.h"
  22 #include "solverdebug.h"
  23 #include "bitmap.h"
  24 #include "pool.h"
  25 #include "poolarch.h"
  26 #include "util.h"
  27 #include "evr.h"
  28 #include "policy.h"
  29
  30
  31 /*
  32  * create obsoletesmap from solver decisions
  33  *
  34  * for solvables in installed repo:
  35  *   0 - not obsoleted
  36  *   p - one of the packages that obsolete us
  37  * for all others:
  38  *   n - number of packages this package obsoletes
  39  *
  40  */
  41
  42 /* OBSOLETE: use transaction code instead! */
  43
  44 Id *
  45 solver_create_decisions_obsoletesmap(Solver *solv)
  46 {
  47   Pool *pool = solv->pool;
  48   Repo *installed = solv->installed;
  49   Id p, *obsoletesmap = NULL;
  50   int i;
  51   Solvable *s;
  52
  53   obsoletesmap = (Id *)solv_calloc(pool->nsolvables, sizeof(Id));
  54   if (installed)
  55     {
  56       for (i = 0; i < solv->decisionq.count; i++)
  57         {
  58           Id pp, n;
  59           int noobs;
  60
  61           n = solv->decisionq.elements[i];
  62           if (n < 0)
  63             continue;
  64           if (n == SYSTEMSOLVABLE)
  65             continue;
  66           s = pool->solvables + n;
  67           if (s->repo == installed)             /* obsoletes don't count for already installed packages */
  68             continue;
  69           noobs = solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n);
  70           FOR_PROVIDES(p, pp, s->name)
  71             {
  72               Solvable *ps = pool->solvables + p;
  73               if (noobs && (s->name != ps->name || s->evr != ps->evr || s->arch != ps->arch))
  74                 continue;
  75               if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
  76                 continue;
  77               if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
  78                 continue;
  79               if (ps->repo == installed && !obsoletesmap[p])
  80                 {
  81                   obsoletesmap[p] = n;
  82                   obsoletesmap[n]++;
  83                 }
  84             }
  85         }
  86       for (i = 0; i < solv->decisionq.count; i++)
  87         {
  88           Id obs, *obsp;
  89           Id pp, n;
  90
  91           n = solv->decisionq.elements[i];
  92           if (n < 0)
  93             continue;
  94           if (n == SYSTEMSOLVABLE)
  95             continue;
  96           s = pool->solvables + n;
  97           if (s->repo == installed)             /* obsoletes don't count for already installed packages */
  98             continue;
  99           if (!s->obsoletes)
 100             continue;
 101           if (solv->noobsoletes.size && MAPTST(&solv->noobsoletes, n))
 102             continue;
 103           obsp = s->repo->idarraydata + s->obsoletes;
 104           while ((obs = *obsp++) != 0)
 105             {
 106               FOR_PROVIDES(p, pp, obs)
 107                 {
 108                   Solvable *ps = pool->solvables + p;
 109                   if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
 110                     continue;
 111                   if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps))
 112                     continue;
 113                   if (pool->solvables[p].repo == installed && !obsoletesmap[p])
 114                     {
 115                       obsoletesmap[p] = n;
 116                       obsoletesmap[n]++;
 117                     }
 118                 }
 119             }
 120         }
 121     }
 122   return obsoletesmap;
 123 }
 124
 125 void
 126 solver_printruleelement(Solver *solv, int type, Rule *r, Id v)
 127 {
 128   Pool *pool = solv->pool;
 129   Solvable *s;
 130   if (v < 0)
 131     {
 132       s = pool->solvables + -v;
 133       POOL_DEBUG(type, "    !%s [%d]", pool_solvable2str(pool, s), -v);
 134     }
 135   else
 136     {
 137       s = pool->solvables + v;
 138       POOL_DEBUG(type, "    %s [%d]", pool_solvable2str(pool, s), v);
 139     }
 140   if (pool->installed && s->repo == pool->installed)
 141     POOL_DEBUG(type, "I");
 142   if (r)
 143     {
 144       if (r->w1 == v)
 145         POOL_DEBUG(type, " (w1)");
 146       if (r->w2 == v)
 147         POOL_DEBUG(type, " (w2)");
 148     }
 149   if (solv->decisionmap[s - pool->solvables] > 0)
 150     POOL_DEBUG(type, " Install.level%d", solv->decisionmap[s - pool->solvables]);
 151   if (solv->decisionmap[s - pool->solvables] < 0)
 152     POOL_DEBUG(type, " Conflict.level%d", -solv->decisionmap[s - pool->solvables]);
 153   POOL_DEBUG(type, "\n");
 154 }
 155
 156
 157 /*
 158  * print rule
 159  */
 160
 161 void
 162 solver_printrule(Solver *solv, int type, Rule *r)
 163 {
 164   Pool *pool = solv->pool;
 165   int i;
 166   Id d, v;
 167
 168   if (r >= solv->rules && r < solv->rules + solv->nrules)   /* r is a solver rule */
 169     POOL_DEBUG(type, "Rule #%d:", (int)(r - solv->rules));
 170   else
 171     POOL_DEBUG(type, "Rule:");                 /* r is any rule */
 172   if (r && r->d < 0)
 173     POOL_DEBUG(type, " (disabled)");
 174   POOL_DEBUG(type, "\n");
 175   d = r->d < 0 ? -r->d - 1 : r->d;
 176   for (i = 0; ; i++)
 177     {
 178       if (i == 0)
 179           /* print direct literal */
 180         v = r->p;
 181       else if (!d)
 182         {
 183           if (i == 2)
 184             break;
 185           /* binary rule --> print w2 as second literal */
 186           v = r->w2;
 187         }
 188       else
 189           /* every other which is in d */
 190         v = solv->pool->whatprovidesdata[d + i - 1];
 191       if (v == ID_NULL)
 192         break;
 193       solver_printruleelement(solv, type, r, v);
 194     }
 195   POOL_DEBUG(type, "    next rules: %d %d\n", r->n1, r->n2);
 196 }
 197
 198 void
 199 solver_printruleclass(Solver *solv, int type, Rule *r)
 200 {
 201   Pool *pool = solv->pool;
 202   Id p = r - solv->rules;
 203   assert(p >= 0);
 204   if (p < solv->learntrules)
 205     if (MAPTST(&solv->weakrulemap, p))
 206       POOL_DEBUG(type, "WEAK ");
 207   if (solv->learntrules && p >= solv->learntrules)
 208     POOL_DEBUG(type, "LEARNT ");
 209   else if (p >= solv->choicerules && p < solv->choicerules_end)
 210     POOL_DEBUG(type, "CHOICE ");
 211   else if (p >= solv->infarchrules && p < solv->infarchrules_end)
 212     POOL_DEBUG(type, "INFARCH ");
 213   else if (p >= solv->duprules && p < solv->duprules_end)
 214     POOL_DEBUG(type, "DUP ");
 215   else if (p >= solv->jobrules && p < solv->jobrules_end)
 216     POOL_DEBUG(type, "JOB ");
 217   else if (p >= solv->updaterules && p < solv->updaterules_end)
 218     POOL_DEBUG(type, "UPDATE ");
 219   else if (p >= solv->featurerules && p < solv->featurerules_end)
 220     POOL_DEBUG(type, "FEATURE ");
 221   solver_printrule(solv, type, r);
 222 }
 223
 224 void
 225 solver_printproblem(Solver *solv, Id v)
 226 {
 227   Pool *pool = solv->pool;
 228   int i;
 229   Rule *r;
 230   Id *jp;
 231
 232   if (v > 0)
 233     solver_printruleclass(solv, SOLV_DEBUG_SOLUTIONS, solv->rules + v);
 234   else
 235     {
 236       v = -(v + 1);
 237       POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "JOB %d\n", v);
 238       jp = solv->ruletojob.elements;
 239       for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++, jp++)
 240         if (*jp == v)
 241           {
 242             POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "- ");
 243             solver_printrule(solv, SOLV_DEBUG_SOLUTIONS, r);
 244           }
 245       POOL_DEBUG(SOLV_DEBUG_SOLUTIONS, "ENDJOB\n");
 246     }
 247 }
 248
 249 void
 250 solver_printwatches(Solver *solv, int type)
 251 {
 252   Pool *pool = solv->pool;
 253   int counter;
 254
 255   POOL_DEBUG(type, "Watches: \n");
 256   for (counter = -(pool->nsolvables - 1); counter < pool->nsolvables; counter++)
 257     POOL_DEBUG(type, "    solvable [%d] -- rule [%d]\n", counter, solv->watches[counter + pool->nsolvables]);
 258 }
 259
 260 void
 261 solver_printdecisionq(Solver *solv, int type)
 262 {
 263   Pool *pool = solv->pool;
 264   int i;
 265   Id p, why;
 266
 267   POOL_DEBUG(type, "Decisions:\n");
 268   for (i = 0; i < solv->decisionq.count; i++)
 269     {
 270       p = solv->decisionq.elements[i];
 271       if (p > 0)
 272         POOL_DEBUG(type, "%d %d install  %s, ", i, solv->decisionmap[p], pool_solvid2str(pool, p));
 273       else
 274         POOL_DEBUG(type, "%d %d conflict %s, ", i, -solv->decisionmap[-p], pool_solvid2str(pool, -p));
 275       why = solv->decisionq_why.elements[i];
 276       if (why > 0)
 277         {
 278           POOL_DEBUG(type, "forced by ");
 279           solver_printruleclass(solv, type, solv->rules + why);
 280         }
 281       else if (why < 0)
 282         {
 283           POOL_DEBUG(type, "chosen from ");
 284           solver_printruleclass(solv, type, solv->rules - why);
 285         }
 286       else
 287         POOL_DEBUG(type, "picked for some unknown reason.\n");
 288     }
 289 }
 290
 291 /*
 292  * printdecisions
 293  */
 294
 295 void
 296 solver_printdecisions(Solver *solv)
 297 {
 298   Pool *pool = solv->pool;
 299   Repo *installed = solv->installed;
 300   Transaction *trans = solver_create_transaction(solv);
 301   Id p, type;
 302   int i, j;
 303   Solvable *s;
 304   Queue iq;
 305   Queue recommendations;
 306   Queue suggestions;
 307   Queue orphaned;
 308
 309   POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 310   POOL_DEBUG(SOLV_DEBUG_RESULT, "transaction:\n");
 311
 312   queue_init(&iq);
 313   for (i = 0; i < trans->steps.count; i++)
 314     {
 315       p = trans->steps.elements[i];
 316       s = pool->solvables + p;
 317       type = transaction_type(trans, p, SOLVER_TRANSACTION_SHOW_ACTIVE|SOLVER_TRANSACTION_SHOW_ALL|SOLVER_TRANSACTION_SHOW_OBSOLETES|SOLVER_TRANSACTION_SHOW_MULTIINSTALL);
 318       switch(type)
 319         {
 320         case SOLVER_TRANSACTION_MULTIINSTALL:
 321           POOL_DEBUG(SOLV_DEBUG_RESULT, "  multi install %s", pool_solvable2str(pool, s));
 322           break;
 323         case SOLVER_TRANSACTION_MULTIREINSTALL:
 324           POOL_DEBUG(SOLV_DEBUG_RESULT, "  multi reinstall %s", pool_solvable2str(pool, s));
 325           break;
 326         case SOLVER_TRANSACTION_INSTALL:
 327           POOL_DEBUG(SOLV_DEBUG_RESULT, "  install   %s", pool_solvable2str(pool, s));
 328           break;
 329         case SOLVER_TRANSACTION_REINSTALL:
 330           POOL_DEBUG(SOLV_DEBUG_RESULT, "  reinstall %s", pool_solvable2str(pool, s));
 331           break;
 332         case SOLVER_TRANSACTION_DOWNGRADE:
 333           POOL_DEBUG(SOLV_DEBUG_RESULT, "  downgrade %s", pool_solvable2str(pool, s));
 334           break;
 335         case SOLVER_TRANSACTION_CHANGE:
 336           POOL_DEBUG(SOLV_DEBUG_RESULT, "  change    %s", pool_solvable2str(pool, s));
 337           break;
 338         case SOLVER_TRANSACTION_UPGRADE:
 339         case SOLVER_TRANSACTION_OBSOLETES:
 340           POOL_DEBUG(SOLV_DEBUG_RESULT, "  upgrade   %s", pool_solvable2str(pool, s));
 341           break;
 342         case SOLVER_TRANSACTION_ERASE:
 343           POOL_DEBUG(SOLV_DEBUG_RESULT, "  erase     %s", pool_solvable2str(pool, s));
 344           break;
 345         default:
 346           break;
 347         }
 348       switch(type)
 349         {
 350         case SOLVER_TRANSACTION_INSTALL:
 351         case SOLVER_TRANSACTION_ERASE:
 352         case SOLVER_TRANSACTION_MULTIINSTALL:
 353         case SOLVER_TRANSACTION_MULTIREINSTALL:
 354           POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 355           break;
 356         case SOLVER_TRANSACTION_REINSTALL:
 357         case SOLVER_TRANSACTION_DOWNGRADE:
 358         case SOLVER_TRANSACTION_CHANGE:
 359         case SOLVER_TRANSACTION_UPGRADE:
 360         case SOLVER_TRANSACTION_OBSOLETES:
 361           transaction_all_obs_pkgs(trans, p, &iq);
 362           if (iq.count)
 363             {
 364               POOL_DEBUG(SOLV_DEBUG_RESULT, "  (obsoletes");
 365               for (j = 0; j < iq.count; j++)
 366                 POOL_DEBUG(SOLV_DEBUG_RESULT, " %s", pool_solvid2str(pool, iq.elements[j]));
 367               POOL_DEBUG(SOLV_DEBUG_RESULT, ")");
 368             }
 369           POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 370           break;
 371         default:
 372           break;
 373         }
 374     }
 375   queue_free(&iq);
 376
 377   POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 378
 379   queue_init(&recommendations);
 380   queue_init(&suggestions);
 381   queue_init(&orphaned);
 382   solver_get_recommendations(solv, &recommendations, &suggestions, 0);
 383   if (recommendations.count)
 384     {
 385       POOL_DEBUG(SOLV_DEBUG_RESULT, "recommended packages:\n");
 386       for (i = 0; i < recommendations.count; i++)
 387         {
 388           s = pool->solvables + recommendations.elements[i];
 389           if (solv->decisionmap[recommendations.elements[i]] > 0)
 390             {
 391               if (installed && s->repo == installed)
 392                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (installed)\n", pool_solvable2str(pool, s));
 393               else
 394                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (selected)\n", pool_solvable2str(pool, s));
 395             }
 396           else
 397             POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s\n", pool_solvable2str(pool, s));
 398         }
 399       POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 400     }
 401
 402   if (suggestions.count)
 403     {
 404       POOL_DEBUG(SOLV_DEBUG_RESULT, "suggested packages:\n");
 405       for (i = 0; i < suggestions.count; i++)
 406         {
 407           s = pool->solvables + suggestions.elements[i];
 408           if (solv->decisionmap[suggestions.elements[i]] > 0)
 409             {
 410               if (installed && s->repo == installed)
 411                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (installed)\n", pool_solvable2str(pool, s));
 412               else
 413                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (selected)\n", pool_solvable2str(pool, s));
 414             }
 415           else
 416             POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s\n", pool_solvable2str(pool, s));
 417         }
 418       POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 419     }
 420   if (orphaned.count)
 421     {
 422       POOL_DEBUG(SOLV_DEBUG_RESULT, "orphaned packages:\n");
 423       for (i = 0; i < orphaned.count; i++)
 424         {
 425           s = pool->solvables + orphaned.elements[i];
 426           if (solv->decisionmap[solv->orphaned.elements[i]] > 0)
 427             POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (kept)\n", pool_solvable2str(pool, s));
 428           else
 429             POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s (erased)\n", pool_solvable2str(pool, s));
 430         }
 431       POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 432     }
 433   queue_free(&recommendations);
 434   queue_free(&suggestions);
 435   queue_free(&orphaned);
 436   transaction_free(trans);
 437 }
 438
 439 static inline
 440 const char *id2strnone(Pool *pool, Id id)
 441 {
 442   return !id || id == 1 ? "(none)" : pool_id2str(pool, id);
 443 }
 444
 445 void
 446 transaction_print(Transaction *trans)
 447 {
 448   Pool *pool = trans->pool;
 449   Queue classes, pkgs;
 450   int i, j, mode, l, linel;
 451   char line[76];
 452   const char *n;
 453
 454   queue_init(&classes);
 455   queue_init(&pkgs);
 456   mode = 0;
 457   transaction_classify(trans, mode, &classes);
 458   for (i = 0; i < classes.count; i += 4)
 459     {
 460       Id class = classes.elements[i];
 461       Id cnt = classes.elements[i + 1];
 462       switch(class)
 463         {
 464         case SOLVER_TRANSACTION_ERASE:
 465           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d erased packages:\n", cnt);
 466           break;
 467         case SOLVER_TRANSACTION_INSTALL:
 468           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d installed packages:\n", cnt);
 469           break;
 470         case SOLVER_TRANSACTION_REINSTALLED:
 471           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d reinstalled packages:\n", cnt);
 472           break;
 473         case SOLVER_TRANSACTION_DOWNGRADED:
 474           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d downgraded packages:\n", cnt);
 475           break;
 476         case SOLVER_TRANSACTION_CHANGED:
 477           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d changed packages:\n", cnt);
 478           break;
 479         case SOLVER_TRANSACTION_UPGRADED:
 480           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d upgraded packages:\n", cnt);
 481           break;
 482         case SOLVER_TRANSACTION_VENDORCHANGE:
 483           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d vendor changes from '%s' to '%s':\n", cnt, id2strnone(pool, classes.elements[i + 2]), id2strnone(pool, classes.elements[i + 3]));
 484           break;
 485         case SOLVER_TRANSACTION_ARCHCHANGE:
 486           POOL_DEBUG(SOLV_DEBUG_RESULT, "%d arch changes from %s to %s:\n", cnt, pool_id2str(pool, classes.elements[i + 2]), pool_id2str(pool, classes.elements[i + 3]));
 487           break;
 488         default:
 489           class = SOLVER_TRANSACTION_IGNORE;
 490           break;
 491         }
 492       if (class == SOLVER_TRANSACTION_IGNORE)
 493         continue;
 494       transaction_classify_pkgs(trans, mode, class, classes.elements[i + 2], classes.elements[i + 3], &pkgs);
 495       *line = 0;
 496       linel = 0;
 497       for (j = 0; j < pkgs.count; j++)
 498         {
 499           Id p = pkgs.elements[j];
 500           Solvable *s = pool->solvables + p;
 501           Solvable *s2;
 502
 503           switch(class)
 504             {
 505             case SOLVER_TRANSACTION_DOWNGRADED:
 506             case SOLVER_TRANSACTION_UPGRADED:
 507               s2 = pool->solvables + transaction_obs_pkg(trans, p);
 508               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - %s -> %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, s2));
 509               break;
 510             case SOLVER_TRANSACTION_VENDORCHANGE:
 511             case SOLVER_TRANSACTION_ARCHCHANGE:
 512               n = pool_id2str(pool, s->name);
 513               l = strlen(n);
 514               if (l + linel > sizeof(line) - 3)
 515                 {
 516                   if (*line)
 517                     POOL_DEBUG(SOLV_DEBUG_RESULT, "    %s\n", line);
 518                   *line = 0;
 519                   linel = 0;
 520                 }
 521               if (l + linel > sizeof(line) - 3)
 522                 POOL_DEBUG(SOLV_DEBUG_RESULT, "    %s\n", n);
 523               else
 524                 {
 525                   if (*line)
 526                     {
 527                       strcpy(line + linel, ", ");
 528                       linel += 2;
 529                     }
 530                   strcpy(line + linel, n);
 531                   linel += l;
 532                 }
 533               break;
 534             default:
 535               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - %s\n", pool_solvable2str(pool, s));
 536               break;
 537             }
 538         }
 539       if (*line)
 540         POOL_DEBUG(SOLV_DEBUG_RESULT, "    %s\n", line);
 541       POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 542     }
 543   queue_free(&classes);
 544   queue_free(&pkgs);
 545 }
 546
 547 void
 548 solver_printproblemruleinfo(Solver *solv, Id probr)
 549 {
 550   Pool *pool = solv->pool;
 551   Id dep, source, target;
 552
 553   switch (solver_ruleinfo(solv, probr, &source, &target, &dep))
 554     {
 555     case SOLVER_RULE_DISTUPGRADE:
 556       POOL_DEBUG(SOLV_DEBUG_RESULT, "%s does not belong to a distupgrade repository\n", pool_solvid2str(pool, source));
 557       return;
 558     case SOLVER_RULE_INFARCH:
 559       POOL_DEBUG(SOLV_DEBUG_RESULT, "%s has inferior architecture\n", pool_solvid2str(pool, source));
 560       return;
 561     case SOLVER_RULE_UPDATE:
 562       POOL_DEBUG(SOLV_DEBUG_RESULT, "problem with installed package %s\n", pool_solvid2str(pool, source));
 563       return;
 564     case SOLVER_RULE_JOB:
 565       POOL_DEBUG(SOLV_DEBUG_RESULT, "conflicting requests\n");
 566       return;
 567     case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
 568       POOL_DEBUG(SOLV_DEBUG_RESULT, "nothing provides requested %s\n", pool_dep2str(pool, dep));
 569       return;
 570     case SOLVER_RULE_RPM:
 571       POOL_DEBUG(SOLV_DEBUG_RESULT, "some dependency problem\n");
 572       return;
 573     case SOLVER_RULE_RPM_NOT_INSTALLABLE:
 574       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s is not installable\n", pool_solvid2str(pool, source));
 575       return;
 576     case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
 577       POOL_DEBUG(SOLV_DEBUG_RESULT, "nothing provides %s needed by %s\n", pool_dep2str(pool, dep), pool_solvid2str(pool, source));
 578       return;
 579     case SOLVER_RULE_RPM_SAME_NAME:
 580       POOL_DEBUG(SOLV_DEBUG_RESULT, "cannot install both %s and %s\n", pool_solvid2str(pool, source), pool_solvid2str(pool, target));
 581       return;
 582     case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
 583       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s conflicts with %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
 584       return;
 585     case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
 586       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
 587       return;
 588     case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
 589       POOL_DEBUG(SOLV_DEBUG_RESULT, "installed package %s obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
 590       return;
 591     case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
 592       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s implicitly obsoletes %s provided by %s\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep), pool_solvid2str(pool, target));
 593       return;
 594     case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
 595       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s requires %s, but none of the providers can be installed\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
 596       return;
 597     case SOLVER_RULE_RPM_SELF_CONFLICT:
 598       POOL_DEBUG(SOLV_DEBUG_RESULT, "package %s conflicts with %s provided by itself\n", pool_solvid2str(pool, source), pool_dep2str(pool, dep));
 599       return;
 600     case SOLVER_RULE_UNKNOWN:
 601     case SOLVER_RULE_FEATURE:
 602     case SOLVER_RULE_LEARNT:
 603     case SOLVER_RULE_CHOICE:
 604       POOL_DEBUG(SOLV_DEBUG_RESULT, "bad rule type\n");
 605       return;
 606     }
 607 }
 608
 609 void
 610 solver_printprobleminfo(Solver *solv, Id problem)
 611 {
 612   solver_printproblemruleinfo(solv, solver_findproblemrule(solv, problem));
 613 }
 614
 615 void
 616 solver_printcompleteprobleminfo(Solver *solv, Id problem)
 617 {
 618   Queue q;
 619   Id probr;
 620   int i, nobad = 0;
 621
 622   queue_init(&q);
 623   solver_findallproblemrules(solv, problem, &q);
 624   for (i = 0; i < q.count; i++)
 625     {
 626       probr = q.elements[i];
 627       if (!(probr >= solv->updaterules && probr < solv->updaterules_end) && !(probr >= solv->jobrules && probr < solv->jobrules_end))
 628         {
 629           nobad = 1;
 630           break;
 631         }
 632     }
 633   for (i = 0; i < q.count; i++)
 634     {
 635       probr = q.elements[i];
 636       if (nobad && ((probr >= solv->updaterules && probr < solv->updaterules_end) || (probr >= solv->jobrules && probr < solv->jobrules_end)))
 637         continue;
 638       solver_printproblemruleinfo(solv, probr);
 639     }
 640   queue_free(&q);
 641 }
 642
 643 void
 644 solver_printsolution(Solver *solv, Id problem, Id solution)
 645 {
 646   Pool *pool = solv->pool;
 647   Id p, rp, element, how, what, select;
 648   Solvable *s, *sd;
 649
 650   element = 0;
 651   while ((element = solver_next_solutionelement(solv, problem, solution, element, &p, &rp)) != 0)
 652     {
 653       if (p == SOLVER_SOLUTION_JOB)
 654         {
 655           /* job, rp is index into job queue */
 656           how = solv->job.elements[rp - 1];
 657           what = solv->job.elements[rp];
 658           select = how & SOLVER_SELECTMASK;
 659           switch (how & SOLVER_JOBMASK)
 660             {
 661             case SOLVER_INSTALL:
 662               if (select == SOLVER_SOLVABLE && solv->installed && pool->solvables[what].repo == solv->installed)
 663                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not keep %s installed\n", pool_solvid2str(pool, what));
 664               else if (select == SOLVER_SOLVABLE_PROVIDES)
 665                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not install a solvable %s\n", solver_select2str(pool, select, what));
 666               else
 667                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not install %s\n", solver_select2str(pool, select, what));
 668               break;
 669             case SOLVER_ERASE:
 670               if (select == SOLVER_SOLVABLE && !(solv->installed && pool->solvables[what].repo == solv->installed))
 671                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not forbid installation of %s\n", pool_solvid2str(pool, what));
 672               else if (select == SOLVER_SOLVABLE_PROVIDES)
 673                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not deinstall all solvables %s\n", solver_select2str(pool, select, what));
 674               else
 675                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not deinstall %s\n", solver_select2str(pool, select, what));
 676               break;
 677             case SOLVER_UPDATE:
 678               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not install most recent version of %s\n", solver_select2str(pool, select, what));
 679               break;
 680             case SOLVER_LOCK:
 681               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do not lock %s\n", solver_select2str(pool, select, what));
 682               break;
 683             default:
 684               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - do something different\n");
 685               break;
 686             }
 687         }
 688       else if (p == SOLVER_SOLUTION_INFARCH)
 689         {
 690           s = pool->solvables + rp;
 691           if (solv->installed && s->repo == solv->installed)
 692             POOL_DEBUG(SOLV_DEBUG_RESULT, "  - keep %s despite the inferior architecture\n", pool_solvable2str(pool, s));
 693           else
 694             POOL_DEBUG(SOLV_DEBUG_RESULT, "  - install %s despite the inferior architecture\n", pool_solvable2str(pool, s));
 695         }
 696       else if (p == SOLVER_SOLUTION_DISTUPGRADE)
 697         {
 698           s = pool->solvables + rp;
 699           if (solv->installed && s->repo == solv->installed)
 700             POOL_DEBUG(SOLV_DEBUG_RESULT, "  - keep obsolete %s\n", pool_solvable2str(pool, s));
 701           else
 702             POOL_DEBUG(SOLV_DEBUG_RESULT, "  - install %s from excluded repository\n", pool_solvable2str(pool, s));
 703         }
 704       else
 705         {
 706           /* policy, replace p with rp */
 707           s = pool->solvables + p;
 708           sd = rp ? pool->solvables + rp : 0;
 709           if (sd)
 710             {
 711               int illegal = policy_is_illegal(solv, s, sd, 0);
 712               if ((illegal & POLICY_ILLEGAL_DOWNGRADE) != 0)
 713                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow downgrade of %s to %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
 714               if ((illegal & POLICY_ILLEGAL_NAMECHANGE) != 0)
 715                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow name change of %s to %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
 716               if ((illegal & POLICY_ILLEGAL_ARCHCHANGE) != 0)
 717                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow architecture change of %s to %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
 718               if ((illegal & POLICY_ILLEGAL_VENDORCHANGE) != 0)
 719                 {
 720                   if (sd->vendor)
 721                     POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow vendor change from '%s' (%s) to '%s' (%s)\n", pool_id2str(pool, s->vendor), pool_solvable2str(pool, s), pool_id2str(pool, sd->vendor), pool_solvable2str(pool, sd));
 722                   else
 723                     POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow vendor change from '%s' (%s) to no vendor (%s)\n", pool_id2str(pool, s->vendor), pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
 724                 }
 725               if (!illegal)
 726                 POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow replacement of %s with %s\n", pool_solvable2str(pool, s), pool_solvable2str(pool, sd));
 727             }
 728           else
 729             {
 730               POOL_DEBUG(SOLV_DEBUG_RESULT, "  - allow deinstallation of %s\n", pool_solvable2str(pool, s));
 731             }
 732         }
 733     }
 734 }
 735
 736 void
 737 solver_printallsolutions(Solver *solv)
 738 {
 739   Pool *pool = solv->pool;
 740   int pcnt;
 741   Id problem, solution;
 742
 743   POOL_DEBUG(SOLV_DEBUG_RESULT, "Encountered problems! Here are the solutions:\n\n");
 744   pcnt = 0;
 745   problem = 0;
 746   while ((problem = solver_next_problem(solv, problem)) != 0)
 747     {
 748       pcnt++;
 749       POOL_DEBUG(SOLV_DEBUG_RESULT, "Problem %d:\n", pcnt);
 750       POOL_DEBUG(SOLV_DEBUG_RESULT, "====================================\n");
 751 #if 1
 752       solver_printprobleminfo(solv, problem);
 753 #else
 754       solver_printcompleteprobleminfo(solv, problem);
 755 #endif
 756       POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 757       solution = 0;
 758       while ((solution = solver_next_solution(solv, problem, solution)) != 0)
 759         {
 760           solver_printsolution(solv, problem, solution);
 761           POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 762         }
 763     }
 764 }
 765
 766 void
 767 solver_printtrivial(Solver *solv)
 768 {
 769   Pool *pool = solv->pool;
 770   Queue in, out;
 771   Id p;
 772   const char *n;
 773   Solvable *s;
 774   int i;
 775
 776   queue_init(&in);
 777   for (p = 1, s = pool->solvables + p; p < solv->pool->nsolvables; p++, s++)
 778     {
 779       n = pool_id2str(pool, s->name);
 780       if (strncmp(n, "patch:", 6) != 0 && strncmp(n, "pattern:", 8) != 0)
 781         continue;
 782       queue_push(&in, p);
 783     }
 784   if (!in.count)
 785     {
 786       queue_free(&in);
 787       return;
 788     }
 789   queue_init(&out);
 790   solver_trivial_installable(solv, &in, &out);
 791   POOL_DEBUG(SOLV_DEBUG_RESULT, "trivial installable status:\n");
 792   for (i = 0; i < in.count; i++)
 793     POOL_DEBUG(SOLV_DEBUG_RESULT, "  %s: %d\n", pool_solvid2str(pool, in.elements[i]), out.elements[i]);
 794   POOL_DEBUG(SOLV_DEBUG_RESULT, "\n");
 795   queue_free(&in);
 796   queue_free(&out);
 797 }
 798
 799 const char *
 800 solver_select2str(Pool *pool, Id select, Id what)
 801 {
 802   const char *s;
 803   char *b;
 804   select &= SOLVER_SELECTMASK;
 805   if (select == SOLVER_SOLVABLE)
 806     return pool_solvid2str(pool, what);
 807   if (select == SOLVER_SOLVABLE_NAME)
 808     return pool_dep2str(pool, what);
 809   if (select == SOLVER_SOLVABLE_PROVIDES)
 810     {
 811       s = pool_dep2str(pool, what);
 812       b = pool_alloctmpspace(pool, 11 + strlen(s));
 813       sprintf(b, "providing %s", s);
 814       return b;
 815     }
 816   if (select == SOLVER_SOLVABLE_ONE_OF)
 817     {
 818       Id p;
 819       b = 0;
 820       while ((p = pool->whatprovidesdata[what++]) != 0)
 821         {
 822           s = pool_solvid2str(pool, p);
 823           if (b)
 824             b = pool_tmpappend(pool, b, ", ", s);
 825           else
 826             b = pool_tmpjoin(pool, s, 0, 0);
 827           pool_freetmpspace(pool, s);
 828         }
 829       return b ? b : "nothing";
 830     }
 831   if (select == SOLVER_SOLVABLE_REPO)
 832     {
 833       b = pool_alloctmpspace(pool, 20);
 834       sprintf(b, "repo #%d", what);
 835       return b;
 836     }
 837   if (select == SOLVER_SOLVABLE_ALL)
 838     return "all packages";
 839   return "unknown job select";
 840 }
 841
 842 const char *
 843 pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
 844 {
 845   Id select = how & SOLVER_SELECTMASK;
 846   const char *strstart = 0, *strend = 0;
 847   char *s;
 848   int o;
 849
 850   switch (how & SOLVER_JOBMASK)
 851     {
 852     case SOLVER_NOOP:
 853       return "do nothing";
 854     case SOLVER_INSTALL:
 855       if (select == SOLVER_SOLVABLE && pool->installed && pool->solvables[what].repo == pool->installed)
 856         strstart = "keep ", strend = "installed";
 857       else if (select == SOLVER_SOLVABLE || select == SOLVER_SOLVABLE_NAME)
 858         strstart = "install ";
 859       else if (select == SOLVER_SOLVABLE_PROVIDES)
 860         strstart = "install a package ";
 861       else
 862         strstart = "install one of ";
 863       break;
 864     case SOLVER_ERASE:
 865       if (select == SOLVER_SOLVABLE && !(pool->installed && pool->solvables[what].repo == pool->installed))
 866         strstart = "keep ", strend = "unstalled";
 867       else if (select == SOLVER_SOLVABLE_PROVIDES)
 868         strstart = "deinstall all packages ";
 869       else
 870         strstart = "deinstall ";
 871       break;
 872     case SOLVER_UPDATE:
 873       strstart = "update ";
 874       break;
 875     case SOLVER_WEAKENDEPS:
 876       strstart = "weaken deps of ";
 877       break;
 878     case SOLVER_NOOBSOLETES:
 879       strstart = "multi version ";
 880       break;
 881     case SOLVER_LOCK:
 882       strstart = "update ";
 883       break;
 884     case SOLVER_DISTUPGRADE:
 885       strstart = "dist upgrade ";
 886       break;
 887     case SOLVER_VERIFY:
 888       strstart = "verify ";
 889       break;
 890     case SOLVER_DROP_ORPHANED:
 891       strstart = "deinstall ", strend = "if orphaned";
 892       break;
 893     case SOLVER_USERINSTALLED:
 894       strstart = "regard ", strend = "as userinstalled";
 895       break;
 896     default:
 897       strstart = "unknown job ";
 898       break;
 899     }
 900   s = pool_tmpjoin(pool, strstart, solver_select2str(pool, select, what), strend);
 901   how &= flagmask;
 902   if ((how & ~(SOLVER_SELECTMASK|SOLVER_JOBMASK)) == 0)
 903     return s;
 904   o = strlen(s);
 905   s = pool_tmpappend(pool, s, " ", 0);
 906   if (how & SOLVER_WEAK)
 907     s = pool_tmpappend(pool, s, ",weak", 0);
 908   if (how & SOLVER_ESSENTIAL)
 909     s = pool_tmpappend(pool, s, ",essential", 0);
 910   if (how & SOLVER_CLEANDEPS)
 911     s = pool_tmpappend(pool, s, ",cleandeps", 0);
 912   if (how & SOLVER_SETEV)
 913     s = pool_tmpappend(pool, s, ",setev", 0);
 914   if (how & SOLVER_SETEVR)
 915     s = pool_tmpappend(pool, s, ",setevr", 0);
 916   if (how & SOLVER_SETARCH)
 917     s = pool_tmpappend(pool, s, ",setarch", 0);
 918   if (how & SOLVER_SETVENDOR)
 919     s = pool_tmpappend(pool, s, ",setvendor", 0);
 920   if (how & SOLVER_SETREPO)
 921     s = pool_tmpappend(pool, s, ",setrepo", 0);
 922   if (how & SOLVER_NOAUTOSET)
 923     s = pool_tmpappend(pool, s, ",noautoset", 0);
 924   if (s[o + 1] != ',')
 925     s = pool_tmpappend(pool, s, ",?", 0);
 926   s[o + 1] = '[';
 927   return pool_tmpappend(pool, s, "]", 0);
 928 }
 929
 930 const char *
 931 pool_selection2str(Pool *pool, Queue *selection, Id flagmask)
 932 {
 933   char *s;
 934   const char *s2;
 935   int i;
 936   s = pool_tmpjoin(pool, 0, 0, 0);
 937   for (i = 0; i < selection->count; i += 2)
 938     {
 939       Id how = selection->elements[i];
 940       if (*s)
 941         s = pool_tmpappend(pool, s, " + ", 0);
 942       s2 = solver_select2str(pool, how & SOLVER_SELECTMASK, selection->elements[i + 1]);
 943       s = pool_tmpappend(pool, s, s2, 0);
 944       pool_freetmpspace(pool, s2);
 945       how &= flagmask & SOLVER_SETMASK;
 946       if (how)
 947         {
 948           int o = strlen(s);
 949           s = pool_tmpappend(pool, s, " ", 0);
 950             s = pool_tmpappend(pool, s, ",setev", 0);
 951           if (how & SOLVER_SETEVR)
 952             s = pool_tmpappend(pool, s, ",setevr", 0);
 953           if (how & SOLVER_SETARCH)
 954             s = pool_tmpappend(pool, s, ",setarch", 0);
 955           if (how & SOLVER_SETVENDOR)
 956             s = pool_tmpappend(pool, s, ",setvendor", 0);
 957           if (how & SOLVER_SETREPO)
 958             s = pool_tmpappend(pool, s, ",setrepo", 0);
 959           if (how & SOLVER_NOAUTOSET)
 960             s = pool_tmpappend(pool, s, ",noautoset", 0);
 961           if (s[o + 1] != ',')
 962             s = pool_tmpappend(pool, s, ",?", 0);
 963           s[o + 1] = '[';
 964           s = pool_tmpappend(pool, s, "]", 0);
 965         }
 966     }
 967   return s;
 968 }
 969
 970 const char *
 971 solver_problemruleinfo2str(Solver *solv, SolverRuleinfo type, Id source, Id target, Id dep)
 972 {
 973   Pool *pool = solv->pool;
 974   char *s;
 975   switch (type)
 976     {
 977     case SOLVER_RULE_DISTUPGRADE:
 978       return pool_tmpjoin(pool, pool_solvid2str(pool, source), " does not belong to a distupgrade repository", 0);
 979     case SOLVER_RULE_INFARCH:
 980       return pool_tmpjoin(pool, pool_solvid2str(pool, source), " has inferior architecture", 0);
 981     case SOLVER_RULE_UPDATE:
 982       return pool_tmpjoin(pool, "problem with installed package ", pool_solvid2str(pool, source), 0);
 983     case SOLVER_RULE_JOB:
 984       return "conflicting requests";
 985     case SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP:
 986       return pool_tmpjoin(pool, "nothing provides requested ", pool_dep2str(pool, dep), 0);
 987     case SOLVER_RULE_RPM:
 988       return "some dependency problem";
 989     case SOLVER_RULE_RPM_NOT_INSTALLABLE:
 990       return pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " is not installable");
 991     case SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP:
 992       s = pool_tmpjoin(pool, "nothing provides ", pool_dep2str(pool, dep), 0);
 993       return pool_tmpappend(pool, s, " needed by ", pool_solvid2str(pool, source));
 994     case SOLVER_RULE_RPM_SAME_NAME:
 995       s = pool_tmpjoin(pool, "cannot install both ", pool_solvid2str(pool, source), 0);
 996       return pool_tmpappend(pool, s, " and ", pool_solvid2str(pool, target));
 997     case SOLVER_RULE_RPM_PACKAGE_CONFLICT:
 998       s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
 999       s = pool_tmpappend(pool, s, " conflicts with ", pool_dep2str(pool, dep));
1000       return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
1001     case SOLVER_RULE_RPM_PACKAGE_OBSOLETES:
1002       s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
1003       s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep));
1004       return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
1005     case SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES:
1006       s = pool_tmpjoin(pool, "installed package ", pool_solvid2str(pool, source), 0);
1007       s = pool_tmpappend(pool, s, " obsoletes ", pool_dep2str(pool, dep));
1008       return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
1009     case SOLVER_RULE_RPM_IMPLICIT_OBSOLETES:
1010       s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), 0);
1011       s = pool_tmpappend(pool, s, " implicitly obsoletes ", pool_dep2str(pool, dep));
1012       return pool_tmpappend(pool, s, " provided by ", pool_solvid2str(pool, target));
1013     case SOLVER_RULE_RPM_PACKAGE_REQUIRES:
1014       s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " requires ");
1015       return pool_tmpappend(pool, s, pool_dep2str(pool, dep), ", but none of the providers can be installed");
1016     case SOLVER_RULE_RPM_SELF_CONFLICT:
1017       s = pool_tmpjoin(pool, "package ", pool_solvid2str(pool, source), " conflicts with ");
1018       return pool_tmpappend(pool, s, pool_dep2str(pool, dep), " provided by itself");
1019     default:
1020       return "bad problem rule type";
1021     }
1022 }
1023
1024 const char *
1025 solver_solutionelement2str(Solver *solv, Id p, Id rp)
1026 {
1027   Pool *pool = solv->pool;
1028   if (p == SOLVER_SOLUTION_JOB)
1029     {
1030       Id how = solv->job.elements[rp - 1];
1031       Id what = solv->job.elements[rp];
1032       return pool_tmpjoin(pool, "do not ask to ", pool_job2str(pool, how, what, 0), 0);
1033     }
1034   else if (p == SOLVER_SOLUTION_INFARCH)
1035     {
1036       Solvable *s = pool->solvables + rp;
1037       if (solv->installed && s->repo == solv->installed)
1038         return pool_tmpjoin(pool, "keep ", pool_solvable2str(pool, s), " despite the inferior architecture");
1039       else
1040         return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " despite the inferior architecture");
1041     }
1042   else if (p == SOLVER_SOLUTION_DISTUPGRADE)
1043     {
1044       Solvable *s = pool->solvables + rp;
1045       if (solv->installed && s->repo == solv->installed)
1046         return pool_tmpjoin(pool, "keep obsolete ", pool_solvable2str(pool, s), 0);
1047       else
1048         return pool_tmpjoin(pool, "install ", pool_solvable2str(pool, s), " from excluded repository");
1049     }
1050   else if (p > 0 && rp == 0)
1051     return pool_tmpjoin(pool, "allow deinstallation of ", pool_solvid2str(pool, p), 0);
1052   else if (p > 0 && rp > 0)
1053     {
1054       const char *sp = pool_solvid2str(pool, p);
1055       const char *srp = pool_solvid2str(pool, rp);
1056       const char *str = pool_tmpjoin(pool, "allow replacement of ", sp, 0);
1057       return pool_tmpappend(pool, str, " with ", srp);
1058     }
1059   else
1060     return "bad solution element";
1061 }
1062
1063 const char *
1064 policy_illegal2str(Solver *solv, int illegal, Solvable *s, Solvable *rs)
1065 {
1066   Pool *pool = solv->pool;
1067   const char *str;
1068   if (illegal == POLICY_ILLEGAL_DOWNGRADE)
1069     {
1070       str = pool_tmpjoin(pool, "downgrade of ", pool_solvable2str(pool, s), 0);
1071       return pool_tmpappend(pool, str, " to ", pool_solvable2str(pool, rs));
1072     }
1073   if (illegal == POLICY_ILLEGAL_NAMECHANGE)
1074     {
1075       str = pool_tmpjoin(pool, "name change of ", pool_solvable2str(pool, s), 0);
1076       return pool_tmpappend(pool, str, " to ", pool_solvable2str(pool, rs));
1077     }
1078   if (illegal == POLICY_ILLEGAL_ARCHCHANGE)
1079     {
1080       str = pool_tmpjoin(pool, "architecture change of ", pool_solvable2str(pool, s), 0);
1081       return pool_tmpappend(pool, str, " to ", pool_solvable2str(pool, rs));
1082     }
1083   if (illegal == POLICY_ILLEGAL_VENDORCHANGE)
1084     {
1085       str = pool_tmpjoin(pool, "vendor change from '", pool_id2str(pool, s->vendor), "' (");
1086       if (rs->vendor)
1087         {
1088           str = pool_tmpappend(pool, str, pool_solvable2str(pool, s), ") to '");
1089           str = pool_tmpappend(pool, str, pool_id2str(pool, rs->vendor), "' (");
1090         }
1091       else
1092         str = pool_tmpappend(pool, str, pool_solvable2str(pool, s), ") to no vendor (");
1093       return pool_tmpappend(pool, str, pool_solvable2str(pool, rs), ")");
1094     }
1095   return "unknown illegal change";
1096 }