apt-pkg/depcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: depcache.cc,v 1.20 1999/09/09 06:08:45 jgg Exp $
   4 /* ######################################################################
   5
   6    Dependency Cache - Caches Dependency information.
   7
   8    ##################################################################### */
   9                                                                         /*}}}*/
  10 // Include Files                                                        /*{{{*/
  11 #ifdef __GNUG__
  12 #pragma implementation "apt-pkg/depcache.h"
  13 #endif
  14 #include <apt-pkg/depcache.h>
  15
  16 #include <apt-pkg/version.h>
  17 #include <apt-pkg/error.h>
  18                                                                         /*}}}*/
  19
  20 // DepCache::pkgDepCache - Constructors                                 /*{{{*/
  21 // ---------------------------------------------------------------------
  22 /* */
  23 pkgDepCache::pkgDepCache(MMap &Map,OpProgress &Prog) :
  24              pkgCache(Map), PkgState(0), DepState(0)
  25 {
  26    if (_error->PendingError() == false)
  27       Init(&Prog);
  28 }
  29 pkgDepCache::pkgDepCache(MMap &Map) :
  30              pkgCache(Map), PkgState(0), DepState(0)
  31 {
  32    if (_error->PendingError() == false)
  33       Init(0);
  34 }
  35                                                                         /*}}}*/
  36 // DepCache::~pkgDepCache - Destructor                                  /*{{{*/
  37 // ---------------------------------------------------------------------
  38 /* */
  39 pkgDepCache::~pkgDepCache()
  40 {
  41    delete [] PkgState;
  42    delete [] DepState;
  43 }
  44                                                                         /*}}}*/
  45 // DepCache::Init - Generate the initial extra structures.              /*{{{*/
  46 // ---------------------------------------------------------------------
  47 /* This allocats the extension buffers and initializes them. */
  48 bool pkgDepCache::Init(OpProgress *Prog)
  49 {
  50    delete [] PkgState;
  51    delete [] DepState;
  52    PkgState = new StateCache[Head().PackageCount];
  53    DepState = new unsigned char[Head().DependsCount];
  54    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);
  55    memset(DepState,0,sizeof(*DepState)*Head().DependsCount);
  56
  57    if (Prog != 0)
  58    {
  59       Prog->OverallProgress(0,2*Head().PackageCount,Head().PackageCount,
  60                             "Building Dependency Tree");
  61       Prog->SubProgress(Head().PackageCount,"Candidate Versions");
  62    }
  63
  64    /* Set the current state of everything. In this state all of the
  65       packages are kept exactly as is. See AllUpgrade */
  66    int Done = 0;
  67    for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
  68    {
  69       if (Prog != 0)
  70          Prog->Progress(Done);
  71
  72       // Find the proper cache slot
  73       StateCache &State = PkgState[I->ID];
  74       State.iFlags = 0;
  75
  76       // Figure out the install version
  77       State.CandidateVer = GetCandidateVer(I);
  78       State.InstallVer = I.CurrentVer();
  79       State.Mode = ModeKeep;
  80
  81       State.Update(I,*this);
  82    }
  83
  84    if (Prog != 0)
  85    {
  86
  87       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
  88                             Head().PackageCount,
  89                             "Building Dependency Tree");
  90       Prog->SubProgress(Head().PackageCount,"Dependency Generation");
  91    }
  92
  93    Update(Prog);
  94
  95    return true;
  96 }
  97                                                                         /*}}}*/
  98 // DepCache::GetCandidateVer - Returns the Candidate install version    /*{{{*/
  99 // ---------------------------------------------------------------------
 100 /* The default just returns the target version if it exists or the
 101    highest version. */
 102 pkgDepCache::VerIterator pkgDepCache::GetCandidateVer(PkgIterator Pkg,
 103                                                       bool AllowCurrent)
 104 {
 105    // Try to use an explicit target
 106    if (Pkg->TargetVer == 0 ||
 107        (AllowCurrent == false && Pkg.TargetVer() == Pkg.CurrentVer()))
 108       return pkgCache::GetCandidateVer(Pkg,AllowCurrent);
 109    else
 110       return Pkg.TargetVer();
 111 }
 112                                                                         /*}}}*/
 113 // DepCache::IsImportantDep - True if the dependency is important       /*{{{*/
 114 // ---------------------------------------------------------------------
 115 /* */
 116 bool pkgDepCache::IsImportantDep(DepIterator Dep)
 117 {
 118    return Dep.IsCritical();
 119 }
 120                                                                         /*}}}*/
 121
 122 // DepCache::CheckDep - Checks a single dependency                      /*{{{*/
 123 // ---------------------------------------------------------------------
 124 /* This first checks the dependency against the main target package and
 125    then walks along the package provides list and checks if each provides
 126    will be installed then checks the provides against the dep. Res will be
 127    set to the package which was used to satisfy the dep. */
 128 bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
 129 {
 130    Res = Dep.TargetPkg();
 131
 132    /* Check simple depends. A depends -should- never self match but
 133       we allow it anyhow because dpkg does. Technically it is a packaging
 134       bug. Conflicts may never self match */
 135    if (Dep.TargetPkg() != Dep.ParentPkg() || Dep->Type != Dep::Conflicts)
 136    {
 137       PkgIterator Pkg = Dep.TargetPkg();
 138       // Check the base package
 139       if (Type == NowVersion && Pkg->CurrentVer != 0)
 140          if (pkgCheckDep(Dep.TargetVer(),
 141                          Pkg.CurrentVer().VerStr(),Dep->CompareOp) == true)
 142             return true;
 143
 144       if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0)
 145          if (pkgCheckDep(Dep.TargetVer(),
 146                          PkgState[Pkg->ID].InstVerIter(*this).VerStr(),
 147                          Dep->CompareOp) == true)
 148             return true;
 149
 150       if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0)
 151          if (pkgCheckDep(Dep.TargetVer(),
 152                          PkgState[Pkg->ID].CandidateVerIter(*this).VerStr(),
 153                          Dep->CompareOp) == true)
 154             return true;
 155    }
 156
 157    // Check the providing packages
 158    PrvIterator P = Dep.TargetPkg().ProvidesList();
 159    PkgIterator Pkg = Dep.ParentPkg();
 160    for (; P.end() != true; P++)
 161    {
 162       /* Provides may never be applied against the same package if it is
 163          a conflicts. See the comment above. */
 164       if (P.OwnerPkg() == Pkg && Dep->Type == Dep::Conflicts)
 165          continue;
 166
 167       // Check if the provides is a hit
 168       if (Type == NowVersion)
 169       {
 170          if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
 171             continue;
 172       }
 173
 174       if (Type == InstallVersion)
 175       {
 176          StateCache &State = PkgState[P.OwnerPkg()->ID];
 177          if (State.InstallVer != (Version *)P.OwnerVer())
 178             continue;
 179       }
 180
 181       if (Type == CandidateVersion)
 182       {
 183          StateCache &State = PkgState[P.OwnerPkg()->ID];
 184          if (State.CandidateVer != (Version *)P.OwnerVer())
 185             continue;
 186       }
 187
 188       // Compare the versions.
 189       if (pkgCheckDep(Dep.TargetVer(),P.ProvideVersion(),Dep->CompareOp) == true)
 190       {
 191          Res = P.OwnerPkg();
 192          return true;
 193       }
 194    }
 195
 196    return false;
 197 }
 198                                                                         /*}}}*/
 199 // DepCache::AddSizes - Add the packages sizes to the counters          /*{{{*/
 200 // ---------------------------------------------------------------------
 201 /* Call with Mult = -1 to preform the inverse opration */
 202 void pkgDepCache::AddSizes(const PkgIterator &Pkg,long Mult)
 203 {
 204    StateCache &P = PkgState[Pkg->ID];
 205
 206    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
 207        P.Keep() == true)
 208       return;
 209
 210    // Compute the size data
 211    if (P.NewInstall() == true)
 212    {
 213       iUsrSize += Mult*P.InstVerIter(*this)->InstalledSize;
 214       iDownloadSize += Mult*P.InstVerIter(*this)->Size;
 215       return;
 216    }
 217
 218    // Upgrading
 219    if (Pkg->CurrentVer != 0 && P.InstallVer != (Version *)Pkg.CurrentVer() &&
 220        P.InstallVer != 0)
 221    {
 222       iUsrSize += Mult*((signed)P.InstVerIter(*this)->InstalledSize -
 223                         (signed)Pkg.CurrentVer()->InstalledSize);
 224       iDownloadSize += Mult*P.InstVerIter(*this)->Size;
 225       return;
 226    }
 227
 228    // Reinstall
 229    if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
 230        P.Delete() == false)
 231    {
 232       iDownloadSize += Mult*P.InstVerIter(*this)->Size;
 233       return;
 234    }
 235
 236    // Removing
 237    if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
 238    {
 239       iUsrSize -= Mult*Pkg.CurrentVer()->InstalledSize;
 240       return;
 241    }
 242 }
 243                                                                         /*}}}*/
 244 // DepCache::AddStates - Add the package to the state counter           /*{{{*/
 245 // ---------------------------------------------------------------------
 246 /* This routine is tricky to use, you must make sure that it is never
 247    called twice for the same package. This means the Remove/Add section
 248    should be as short as possible and not encompass any code that will
 249    calld Remove/Add itself. Remember, dependencies can be circular so
 250    while processing a dep for Pkg it is possible that Add/Remove
 251    will be called on Pkg */
 252 void pkgDepCache::AddStates(const PkgIterator &Pkg,int Add)
 253 {
 254    StateCache &State = PkgState[Pkg->ID];
 255
 256    // The Package is broken
 257    if ((State.DepState & DepInstMin) != DepInstMin)
 258       iBrokenCount += Add;
 259
 260    // Bad state
 261    if (Pkg.State() != PkgIterator::NeedsNothing)
 262       iBadCount += Add;
 263
 264    // Not installed
 265    if (Pkg->CurrentVer == 0)
 266    {
 267       if (State.Mode == ModeDelete &&
 268           (State.iFlags | Purge) == Purge && Pkg.Purge() == false)
 269          iDelCount += Add;
 270
 271       if (State.Mode == ModeInstall)
 272          iInstCount += Add;
 273       return;
 274    }
 275
 276    // Installed, no upgrade
 277    if (State.Upgradable() == false)
 278    {
 279       if (State.Mode == ModeDelete)
 280          iDelCount += Add;
 281       return;
 282    }
 283
 284    // Alll 3 are possible
 285    if (State.Mode == ModeDelete)
 286       iDelCount += Add;
 287    if (State.Mode == ModeKeep)
 288       iKeepCount += Add;
 289    if (State.Mode == ModeInstall)
 290       iInstCount += Add;
 291 }
 292                                                                         /*}}}*/
 293 // DepCache::BuildGroupOrs - Generate the Or group dep data             /*{{{*/
 294 // ---------------------------------------------------------------------
 295 /* The or group results are stored in the last item of the or group. This
 296    allows easy detection of the state of a whole or'd group. */
 297 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 298 {
 299    unsigned char Group = 0;
 300
 301    for (DepIterator D = V.DependsList(); D.end() != true; D++)
 302    {
 303       // Build the dependency state.
 304       unsigned char &State = DepState[D->ID];
 305
 306       /* Invert for Conflicts. We have to do this twice to get the
 307          right sense for a conflicts group */
 308       if (D->Type == Dep::Conflicts)
 309          State = ~State;
 310
 311       // Add to the group if we are within an or..
 312       State &= 0x7;
 313       Group |= State;
 314       State |= Group << 3;
 315       if ((D->CompareOp & Dep::Or) != Dep::Or)
 316          Group = 0;
 317
 318       // Invert for Conflicts
 319       if (D->Type == Dep::Conflicts)
 320          State = ~State;
 321    }
 322 }
 323                                                                         /*}}}*/
 324 // DepCache::VersionState - Perform a pass over a dependency list       /*{{{*/
 325 // ---------------------------------------------------------------------
 326 /* This is used to run over a dependency list and determine the dep
 327    state of the list, filtering it through both a Min check and a Policy
 328    check. The return result will have SetMin/SetPolicy low if a check
 329    fails. It uses the DepState cache for it's computations. */
 330 unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
 331                                        unsigned char SetMin,
 332                                        unsigned char SetPolicy)
 333 {
 334    unsigned char Dep = 0xFF;
 335
 336    while (D.end() != true)
 337    {
 338       // Compute a single dependency element (glob or)
 339       DepIterator Start = D;
 340       unsigned char State = 0;
 341       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 342       {
 343          State |= DepState[D->ID];
 344          LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
 345       }
 346
 347       // Minimum deps that must be satisfied to have a working package
 348       if (Start.IsCritical() == true)
 349          if ((State & Check) != Check)
 350             Dep &= ~SetMin;
 351
 352       // Policy deps that must be satisfied to install the package
 353       if (IsImportantDep(Start) == true &&
 354           (State & Check) != Check)
 355          Dep &= ~SetPolicy;
 356    }
 357
 358    return Dep;
 359 }
 360                                                                         /*}}}*/
 361 // DepCache::DependencyState - Compute the 3 results for a dep          /*{{{*/
 362 // ---------------------------------------------------------------------
 363 /* This is the main dependency computation bit. It computes the 3 main
 364    results for a dependencys, Now, Install and Candidate. Callers must
 365    invert the result if dealing with conflicts. */
 366 unsigned char pkgDepCache::DependencyState(DepIterator &D)
 367 {
 368    unsigned char State = 0;
 369
 370    if (CheckDep(D,NowVersion) == true)
 371       State |= DepNow;
 372    if (CheckDep(D,InstallVersion) == true)
 373       State |= DepInstall;
 374    if (CheckDep(D,CandidateVersion) == true)
 375       State |= DepCVer;
 376
 377    return State;
 378 }
 379                                                                         /*}}}*/
 380 // DepCache::UpdateVerState - Compute the Dep member of the state       /*{{{*/
 381 // ---------------------------------------------------------------------
 382 /* This determines the combined dependency representation of a package
 383    for its two states now and install. This is done by using the pre-generated
 384    dependency information. */
 385 void pkgDepCache::UpdateVerState(PkgIterator Pkg)
 386 {
 387    // Empty deps are always true
 388    StateCache &State = PkgState[Pkg->ID];
 389    State.DepState = 0xFF;
 390
 391    // Check the Current state
 392    if (Pkg->CurrentVer != 0)
 393    {
 394       DepIterator D = Pkg.CurrentVer().DependsList();
 395       State.DepState &= VersionState(D,DepNow,DepNowMin,DepNowPolicy);
 396    }
 397
 398    /* Check the candidate state. We do not compare against the whole as
 399       a candidate state but check the candidate version against the
 400       install states */
 401    if (State.CandidateVer != 0)
 402    {
 403       DepIterator D = State.CandidateVerIter(*this).DependsList();
 404       State.DepState &= VersionState(D,DepInstall,DepCandMin,DepCandPolicy);
 405    }
 406
 407    // Check target state which can only be current or installed
 408    if (State.InstallVer != 0)
 409    {
 410       DepIterator D = State.InstVerIter(*this).DependsList();
 411       State.DepState &= VersionState(D,DepInstall,DepInstMin,DepInstPolicy);
 412    }
 413 }
 414                                                                         /*}}}*/
 415 // DepCache::Update - Figure out all the state information              /*{{{*/
 416 // ---------------------------------------------------------------------
 417 /* This will figure out the state of all the packages and all the
 418    dependencies based on the current policy. */
 419 void pkgDepCache::Update(OpProgress *Prog)
 420 {
 421    iUsrSize = 0;
 422    iDownloadSize = 0;
 423    iDelCount = 0;
 424    iInstCount = 0;
 425    iKeepCount = 0;
 426    iBrokenCount = 0;
 427    iBadCount = 0;
 428
 429    // Perform the depends pass
 430    int Done = 0;
 431    for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
 432    {
 433       if (Prog != 0 && Done%20 == 0)
 434          Prog->Progress(Done);
 435       for (VerIterator V = I.VersionList(); V.end() != true; V++)
 436       {
 437          unsigned char Group = 0;
 438
 439          for (DepIterator D = V.DependsList(); D.end() != true; D++)
 440          {
 441             // Build the dependency state.
 442             unsigned char &State = DepState[D->ID];
 443             State = DependencyState(D);;
 444
 445             // Add to the group if we are within an or..
 446             Group |= State;
 447             State |= Group << 3;
 448             if ((D->CompareOp & Dep::Or) != Dep::Or)
 449                Group = 0;
 450
 451             // Invert for Conflicts
 452             if (D->Type == Dep::Conflicts)
 453                State = ~State;
 454          }
 455       }
 456
 457       // Compute the pacakge dependency state and size additions
 458       AddSizes(I);
 459       UpdateVerState(I);
 460       AddStates(I);
 461    }
 462
 463    if (Prog != 0)
 464       Prog->Progress(Done);
 465 }
 466                                                                         /*}}}*/
 467 // DepCache::Update - Update the deps list of a package                 /*{{{*/
 468 // ---------------------------------------------------------------------
 469 /* This is a helper for update that only does the dep portion of the scan.
 470    It is mainly ment to scan reverse dependencies. */
 471 void pkgDepCache::Update(DepIterator D)
 472 {
 473    // Update the reverse deps
 474    for (;D.end() != true; D++)
 475    {
 476       unsigned char &State = DepState[D->ID];
 477       State = DependencyState(D);
 478
 479       // Invert for Conflicts
 480       if (D->Type == Dep::Conflicts)
 481          State = ~State;
 482
 483       RemoveStates(D.ParentPkg());
 484       BuildGroupOrs(D.ParentVer());
 485       UpdateVerState(D.ParentPkg());
 486       AddStates(D.ParentPkg());
 487    }
 488 }
 489                                                                         /*}}}*/
 490 // DepCache::Update - Update the related deps of a package              /*{{{*/
 491 // ---------------------------------------------------------------------
 492 /* This is called whenever the state of a package changes. It updates
 493    all cached dependencies related to this package. */
 494 void pkgDepCache::Update(PkgIterator const &Pkg)
 495 {
 496    // Recompute the dep of the package
 497    RemoveStates(Pkg);
 498    UpdateVerState(Pkg);
 499    AddStates(Pkg);
 500
 501    // Update the reverse deps
 502    Update(Pkg.RevDependsList());
 503
 504    // Update the provides map for the current ver
 505    if (Pkg->CurrentVer != 0)
 506       for (PrvIterator P = Pkg.CurrentVer().ProvidesList();
 507            P.end() != true; P++)
 508          Update(P.ParentPkg().RevDependsList());
 509
 510    // Update the provides map for the candidate ver
 511    if (PkgState[Pkg->ID].CandidateVer != 0)
 512       for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();
 513            P.end() != true; P++)
 514          Update(P.ParentPkg().RevDependsList());
 515 }
 516
 517                                                                         /*}}}*/
 518
 519 // DepCache::MarkKeep - Put the package in the keep state               /*{{{*/
 520 // ---------------------------------------------------------------------
 521 /* */
 522 void pkgDepCache::MarkKeep(PkgIterator const &Pkg,bool Soft)
 523 {
 524    // Simplifies other routines.
 525    if (Pkg.end() == true)
 526       return;
 527
 528    /* Reject an attempt to keep a non-source broken installed package, those
 529       must be upgraded */
 530    if (Pkg.State() == PkgIterator::NeedsUnpack &&
 531        Pkg.CurrentVer().Downloadable() == false)
 532       return;
 533
 534    /* We changed the soft state all the time so the UI is a bit nicer
 535       to use */
 536    StateCache &P = PkgState[Pkg->ID];
 537    if (Soft == true)
 538       P.iFlags |= AutoKept;
 539    else
 540       P.iFlags &= ~AutoKept;
 541
 542    // Check that it is not already kept
 543    if (P.Mode == ModeKeep)
 544       return;
 545
 546    // We dont even try to keep virtual packages..
 547    if (Pkg->VersionList == 0)
 548       return;
 549
 550    P.Flags &= ~Flag::Auto;
 551    RemoveSizes(Pkg);
 552    RemoveStates(Pkg);
 553
 554    P.Mode = ModeKeep;
 555    if (Pkg->CurrentVer == 0)
 556       P.InstallVer = 0;
 557    else
 558       P.InstallVer = Pkg.CurrentVer();
 559
 560    AddStates(Pkg);
 561
 562    Update(Pkg);
 563
 564    AddSizes(Pkg);
 565 }
 566                                                                         /*}}}*/
 567 // DepCache::MarkDelete - Put the package in the delete state           /*{{{*/
 568 // ---------------------------------------------------------------------
 569 /* */
 570 void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge)
 571 {
 572    // Simplifies other routines.
 573    if (Pkg.end() == true)
 574       return;
 575
 576    // Check that it is not already marked for delete
 577    StateCache &P = PkgState[Pkg->ID];
 578    P.iFlags &= ~(AutoKept | Purge);
 579    if (rPurge == true)
 580       P.iFlags |= Purge;
 581
 582    if ((P.Mode == ModeDelete || P.InstallVer == 0) &&
 583        (Pkg.Purge() == true || rPurge == false))
 584       return;
 585
 586    // We dont even try to delete virtual packages..
 587    if (Pkg->VersionList == 0)
 588       return;
 589
 590    RemoveSizes(Pkg);
 591    RemoveStates(Pkg);
 592
 593    if (Pkg->CurrentVer == 0 && (Pkg.Purge() == true || rPurge == false))
 594       P.Mode = ModeKeep;
 595    else
 596       P.Mode = ModeDelete;
 597    P.InstallVer = 0;
 598    P.Flags &= Flag::Auto;
 599
 600    AddStates(Pkg);
 601    Update(Pkg);
 602    AddSizes(Pkg);
 603 }
 604                                                                         /*}}}*/
 605 // DepCache::MarkInstall - Put the package in the install state         /*{{{*/
 606 // ---------------------------------------------------------------------
 607 /* */
 608 void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst)
 609 {
 610    // Simplifies other routines.
 611    if (Pkg.end() == true)
 612       return;
 613
 614    /* Check that it is not already marked for install and that it can be
 615       installed */
 616    StateCache &P = PkgState[Pkg->ID];
 617    P.iFlags &= ~AutoKept;
 618    if (P.InstBroken() == false && (P.Mode == ModeInstall ||
 619         P.CandidateVer == (Version *)Pkg.CurrentVer()))
 620    {
 621       if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)
 622          MarkKeep(Pkg);
 623       return;
 624    }
 625
 626    // We dont even try to install virtual packages..
 627    if (Pkg->VersionList == 0)
 628       return;
 629
 630    /* Target the candidate version and remove the autoflag. We reset the
 631       autoflag below if this was called recursively. Otherwise the user
 632       should have the ability to de-auto a package by changing its state */
 633    RemoveSizes(Pkg);
 634    RemoveStates(Pkg);
 635
 636    P.Mode = ModeInstall;
 637    P.InstallVer = P.CandidateVer;
 638    P.Flags &= ~Flag::Auto;
 639    if (P.CandidateVer == (Version *)Pkg.CurrentVer())
 640       P.Mode = ModeKeep;
 641
 642    AddStates(Pkg);
 643    Update(Pkg);
 644    AddSizes(Pkg);
 645
 646    if (AutoInst == false)
 647       return;
 648
 649    DepIterator Dep = P.InstVerIter(*this).DependsList();
 650    for (; Dep.end() != true;)
 651    {
 652       // Grok or groups
 653       DepIterator Start = Dep;
 654       bool Result = true;
 655       for (bool LastOR = true; Dep.end() == false && LastOR == true; Dep++)
 656       {
 657          LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
 658
 659          if ((DepState[Dep->ID] & DepInstall) == DepInstall)
 660             Result = false;
 661       }
 662
 663       // Dep is satisfied okay.
 664       if (Result == false)
 665          continue;
 666
 667       /* Check if this dep should be consider for install. If it is a user
 668          defined important dep and we are installed a new package then
 669          it will be installed. Otherwise we only worry about critical deps */
 670       if (IsImportantDep(Start) == false)
 671          continue;
 672       if (Pkg->CurrentVer != 0 && Start.IsCritical() == false)
 673          continue;
 674
 675       // Now we have to take action...
 676       PkgIterator P = Start.SmartTargetPkg();
 677       if ((DepState[Start->ID] & DepCVer) == DepCVer)
 678       {
 679          MarkInstall(P,true);
 680
 681          // Set the autoflag, after MarkInstall because MarkInstall unsets it
 682          if (P->CurrentVer == 0)
 683             PkgState[P->ID].Flags |= Flag::Auto;
 684
 685          continue;
 686       }
 687
 688       // For conflicts we just de-install the package and mark as auto
 689       if (Start->Type == Dep::Conflicts)
 690       {
 691          Version **List = Start.AllTargets();
 692          for (Version **I = List; *I != 0; I++)
 693          {
 694             VerIterator Ver(*this,*I);
 695             PkgIterator Pkg = Ver.ParentPkg();
 696
 697             MarkDelete(Pkg);
 698             PkgState[Pkg->ID].Flags |= Flag::Auto;
 699          }
 700          delete [] List;
 701          continue;
 702       }
 703    }
 704 }
 705                                                                         /*}}}*/
 706
 707 // StateCache::Update - Compute the various static display things       /*{{{*/
 708 // ---------------------------------------------------------------------
 709 /* This is called whenever the Candidate version changes. */
 710 void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
 711 {
 712    // Some info
 713    VerIterator Ver = CandidateVerIter(Cache);
 714
 715    // Use a null string or the version string
 716    if (Ver.end() == true)
 717       CandVersion = "";
 718    else
 719       CandVersion = Ver.VerStr();
 720
 721    // Find the current version
 722    CurVersion = "";
 723    if (Pkg->CurrentVer != 0)
 724       CurVersion = Pkg.CurrentVer().VerStr();
 725
 726    // Strip off the epochs for display
 727    CurVersion = StripEpoch(CurVersion);
 728    CandVersion = StripEpoch(CandVersion);
 729
 730    // Figure out if its up or down or equal
 731    Status = Ver.CompareVer(Pkg.CurrentVer());
 732    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
 733      Status = 2;
 734 }
 735                                                                         /*}}}*/
 736 // StateCache::StripEpoch - Remove the epoch specifier from the version /*{{{*/
 737 // ---------------------------------------------------------------------
 738 /* */
 739 const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
 740 {
 741    if (Ver == 0)
 742       return 0;
 743
 744    // Strip any epoch
 745    for (const char *I = Ver; *I != 0; I++)
 746       if (*I == ':')
 747          return I + 1;
 748    return Ver;
 749 }
 750                                                                         /*}}}*/