src/rules.h

   1 /*
   2  * Copyright (c) 2007-2009, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * rules.h
  10  *
  11  */
  12
  13 #ifndef LIBSOLV_RULES_H
  14 #define LIBSOLV_RULES_H
  15
  16 #ifdef __cplusplus
  17 extern "C" {
  18 #endif
  19
  20 /* ----------------------------------------------
  21  * Rule
  22  *
  23  *   providerN(B) == Package Id of package providing tag B
  24  *   N = 1, 2, 3, in case of multiple providers
  25  *
  26  * A requires B : !A | provider1(B) | provider2(B)
  27  *
  28  * A conflicts B : (!A | !provider1(B)) & (!A | !provider2(B)) ...
  29  *
  30  * 'not' is encoded as a negative Id
  31  *
  32  * Binary rule: p = first literal, d = 0, w2 = second literal, w1 = p
  33  *
  34  * There are a lot of rules, so the struct is kept as small as
  35  * possible. Do not add new members unless there is no other way.
  36  */
  37
  38 typedef struct _Rule {
  39   Id p;         /* first literal in rule */
  40   Id d;         /* Id offset into 'list of providers terminated by 0' as used by whatprovides; pool->whatprovides + d */
  41                 /* in case of binary rules, d == 0, w1 == p, w2 == other literal */
  42                 /* in case of disabled rules: ~d, aka -d - 1 */
  43   Id w1, w2;    /* watches, literals not-yet-decided */
  44                 /* if !w2, assertion, not rule */
  45   Id n1, n2;    /* next rules in linked list, corresponding to w1, w2 */
  46 } Rule;
  47
  48
  49 typedef enum {
  50   SOLVER_RULE_UNKNOWN = 0,
  51   SOLVER_RULE_RPM = 0x100,
  52   SOLVER_RULE_RPM_NOT_INSTALLABLE,
  53   SOLVER_RULE_RPM_NOTHING_PROVIDES_DEP,
  54   SOLVER_RULE_RPM_PACKAGE_REQUIRES,
  55   SOLVER_RULE_RPM_SELF_CONFLICT,
  56   SOLVER_RULE_RPM_PACKAGE_CONFLICT,
  57   SOLVER_RULE_RPM_SAME_NAME,
  58   SOLVER_RULE_RPM_PACKAGE_OBSOLETES,
  59   SOLVER_RULE_RPM_IMPLICIT_OBSOLETES,
  60   SOLVER_RULE_RPM_INSTALLEDPKG_OBSOLETES,
  61   SOLVER_RULE_UPDATE = 0x200,
  62   SOLVER_RULE_FEATURE = 0x300,
  63   SOLVER_RULE_JOB = 0x400,
  64   SOLVER_RULE_JOB_NOTHING_PROVIDES_DEP,
  65   SOLVER_RULE_JOB_PROVIDED_BY_SYSTEM,
  66   SOLVER_RULE_JOB_UNKNOWN_PACKAGE,
  67   SOLVER_RULE_JOB_UNSUPPORTED,
  68   SOLVER_RULE_DISTUPGRADE = 0x500,
  69   SOLVER_RULE_INFARCH = 0x600,
  70   SOLVER_RULE_CHOICE = 0x700,
  71   SOLVER_RULE_LEARNT = 0x800,
  72   SOLVER_RULE_BEST = 0x900
  73 } SolverRuleinfo;
  74
  75 #define SOLVER_RULE_TYPEMASK    0xff00
  76
  77 struct _Solver;
  78
  79 /*-------------------------------------------------------------------
  80  * disable rule
  81  */
  82
  83 static inline void
  84 solver_disablerule(struct _Solver *solv, Rule *r)
  85 {
  86   if (r->d >= 0)
  87     r->d = -r->d - 1;
  88 }
  89
  90 /*-------------------------------------------------------------------
  91  * enable rule
  92  */
  93
  94 static inline void
  95 solver_enablerule(struct _Solver *solv, Rule *r)
  96 {
  97   if (r->d < 0)
  98     r->d = -r->d - 1;
  99 }
 100
 101 extern Rule *solver_addrule(struct _Solver *solv, Id p, Id d);
 102 extern void solver_unifyrules(struct _Solver *solv);
 103 extern int solver_rulecmp(struct _Solver *solv, Rule *r1, Rule *r2);
 104 extern void solver_shrinkrules(struct _Solver *solv, int nrules);
 105
 106 /* rpm rules */
 107 extern void solver_addrpmrulesforsolvable(struct _Solver *solv, Solvable *s, Map *m);
 108 extern void solver_addrpmrulesforweak(struct _Solver *solv, Map *m);
 109 extern void solver_addrpmrulesforlinked(struct _Solver *solv, Map *m);
 110 extern void solver_addrpmrulesforupdaters(struct _Solver *solv, Solvable *s, Map *m, int allow_all);
 111
 112 /* update/feature rules */
 113 extern void solver_addupdaterule(struct _Solver *solv, Solvable *s, int allow_all);
 114
 115 /* infarch rules */
 116 extern void solver_addinfarchrules(struct _Solver *solv, Map *addedmap);
 117
 118 /* dup rules */
 119 extern void solver_createdupmaps(struct _Solver *solv);
 120 extern void solver_freedupmaps(struct _Solver *solv);
 121 extern void solver_addduprules(struct _Solver *solv, Map *addedmap);
 122
 123 /* choice rules */
 124 extern void solver_addchoicerules(struct _Solver *solv);
 125 extern void solver_disablechoicerules(struct _Solver *solv, Rule *r);
 126
 127 /* best rules */
 128 extern void solver_addbestrules(struct _Solver *solv, int havebestinstalljobs);
 129
 130 /* policy rule disabling/reenabling */
 131 extern void solver_disablepolicyrules(struct _Solver *solv);
 132 extern void solver_reenablepolicyrules(struct _Solver *solv, int jobidx);
 133 extern void solver_reenablepolicyrules_cleandeps(struct _Solver *solv, Id pkg);
 134
 135 /* rule info */
 136 extern int solver_allruleinfos(struct _Solver *solv, Id rid, Queue *rq);
 137 extern SolverRuleinfo solver_ruleinfo(struct _Solver *solv, Id rid, Id *fromp, Id *top, Id *depp);
 138 extern SolverRuleinfo solver_ruleclass(struct _Solver *solv, Id rid);
 139 extern void solver_ruleliterals(struct _Solver *solv, Id rid, Queue *q);
 140 extern int  solver_rule2jobidx(struct _Solver *solv, Id rid);
 141 extern Id   solver_rule2job(struct _Solver *solv, Id rid, Id *whatp);
 142 extern Id   solver_rule2solvable(struct _Solver *solv, Id rid);
 143 extern void solver_rule2rules(struct _Solver *solv, Id rid, Queue *q, int recursive);
 144
 145 /* orphan handling */
 146 extern void solver_breakorphans(struct _Solver *solv);
 147 extern void solver_check_brokenorphanrules(struct _Solver *solv, Queue *dq);
 148
 149 #ifdef __cplusplus
 150 }
 151 #endif
 152
 153 #endif
 154