apt-pkg/depcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: depcache.cc,v 1.17 1999/04/16 21:46:13 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 == ModeInstall)
 268          iInstCount += Add;
 269       return;
 270    }
 271
 272    // Installed, no upgrade
 273    if (State.Upgradable() == false)
 274    {
 275       if (State.Mode == ModeDelete)
 276          iDelCount += Add;
 277       return;
 278    }
 279
 280    // Alll 3 are possible
 281    if (State.Mode == ModeDelete)
 282       iDelCount += Add;
 283    if (State.Mode == ModeKeep)
 284       iKeepCount += Add;
 285    if (State.Mode == ModeInstall)
 286       iInstCount += Add;
 287 }
 288                                                                         /*}}}*/
 289 // DepCache::BuildGroupOrs - Generate the Or group dep data             /*{{{*/
 290 // ---------------------------------------------------------------------
 291 /* The or group results are stored in the last item of the or group. This
 292    allows easy detection of the state of a whole or'd group. */
 293 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 294 {
 295    unsigned char Group = 0;
 296
 297    for (DepIterator D = V.DependsList(); D.end() != true; D++)
 298    {
 299       // Build the dependency state.
 300       unsigned char &State = DepState[D->ID];
 301
 302       /* Invert for Conflicts. We have to do this twice to get the
 303          right sense for a conflicts group */
 304       if (D->Type == Dep::Conflicts)
 305          State = ~State;
 306
 307       // Add to the group if we are within an or..
 308       State &= 0x7;
 309       Group |= State;
 310       State |= Group << 3;
 311       if ((D->CompareOp & Dep::Or) != Dep::Or)
 312          Group = 0;
 313
 314       // Invert for Conflicts
 315       if (D->Type == Dep::Conflicts)
 316          State = ~State;
 317    }
 318 }
 319                                                                         /*}}}*/
 320 // DepCache::VersionState - Perform a pass over a dependency list       /*{{{*/
 321 // ---------------------------------------------------------------------
 322 /* This is used to run over a dependency list and determine the dep
 323    state of the list, filtering it through both a Min check and a Policy
 324    check. The return result will have SetMin/SetPolicy low if a check
 325    fails. It uses the DepState cache for it's computations. */
 326 unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
 327                                        unsigned char SetMin,
 328                                        unsigned char SetPolicy)
 329 {
 330    unsigned char Dep = 0xFF;
 331
 332    while (D.end() != true)
 333    {
 334       // Compute a single dependency element (glob or)
 335       DepIterator Start = D;
 336       unsigned char State = 0;
 337       for (bool LastOR = true; D.end() == false && LastOR == true; D++)
 338       {
 339          State |= DepState[D->ID];
 340          LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
 341       }
 342
 343       // Minimum deps that must be satisfied to have a working package
 344       if (Start.IsCritical() == true)
 345          if ((State & Check) != Check)
 346             Dep &= ~SetMin;
 347
 348       // Policy deps that must be satisfied to install the package
 349       if (IsImportantDep(Start) == true &&
 350           (State & Check) != Check)
 351          Dep &= ~SetPolicy;
 352    }
 353
 354    return Dep;
 355 }
 356                                                                         /*}}}*/
 357 // DepCache::DependencyState - Compute the 3 results for a dep          /*{{{*/
 358 // ---------------------------------------------------------------------
 359 /* This is the main dependency computation bit. It computes the 3 main
 360    results for a dependencys, Now, Install and Candidate. Callers must
 361    invert the result if dealing with conflicts. */
 362 unsigned char pkgDepCache::DependencyState(DepIterator &D)
 363 {
 364    unsigned char State = 0;
 365
 366    if (CheckDep(D,NowVersion) == true)
 367       State |= DepNow;
 368    if (CheckDep(D,InstallVersion) == true)
 369       State |= DepInstall;
 370    if (CheckDep(D,CandidateVersion) == true)
 371       State |= DepCVer;
 372
 373    return State;
 374 }
 375                                                                         /*}}}*/
 376 // DepCache::UpdateVerState - Compute the Dep member of the state       /*{{{*/
 377 // ---------------------------------------------------------------------
 378 /* This determines the combined dependency representation of a package
 379    for its two states now and install. This is done by using the pre-generated
 380    dependency information. */
 381 void pkgDepCache::UpdateVerState(PkgIterator Pkg)
 382 {
 383    // Empty deps are always true
 384    StateCache &State = PkgState[Pkg->ID];
 385    State.DepState = 0xFF;
 386
 387    // Check the Current state
 388    if (Pkg->CurrentVer != 0)
 389    {
 390       DepIterator D = Pkg.CurrentVer().DependsList();
 391       State.DepState &= VersionState(D,DepNow,DepNowMin,DepNowPolicy);
 392    }
 393
 394    /* Check the candidate state. We do not compare against the whole as
 395       a candidate state but check the candidate version against the
 396       install states */
 397    if (State.CandidateVer != 0)
 398    {
 399       DepIterator D = State.CandidateVerIter(*this).DependsList();
 400       State.DepState &= VersionState(D,DepInstall,DepCandMin,DepCandPolicy);
 401    }
 402
 403    // Check target state which can only be current or installed
 404    if (State.InstallVer != 0)
 405    {
 406       DepIterator D = State.InstVerIter(*this).DependsList();
 407       State.DepState &= VersionState(D,DepInstall,DepInstMin,DepInstPolicy);
 408    }
 409 }
 410                                                                         /*}}}*/
 411 // DepCache::Update - Figure out all the state information              /*{{{*/
 412 // ---------------------------------------------------------------------
 413 /* This will figure out the state of all the packages and all the
 414    dependencies based on the current policy. */
 415 void pkgDepCache::Update(OpProgress *Prog)
 416 {
 417    iUsrSize = 0;
 418    iDownloadSize = 0;
 419    iDelCount = 0;
 420    iInstCount = 0;
 421    iKeepCount = 0;
 422    iBrokenCount = 0;
 423    iBadCount = 0;
 424
 425    // Perform the depends pass
 426    int Done = 0;
 427    for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
 428    {
 429       if (Prog != 0 && Done%20 == 0)
 430          Prog->Progress(Done);
 431       for (VerIterator V = I.VersionList(); V.end() != true; V++)
 432       {
 433          unsigned char Group = 0;
 434
 435          for (DepIterator D = V.DependsList(); D.end() != true; D++)
 436          {
 437             // Build the dependency state.
 438             unsigned char &State = DepState[D->ID];
 439             State = DependencyState(D);;
 440
 441             // Add to the group if we are within an or..
 442             Group |= State;
 443             State |= Group << 3;
 444             if ((D->CompareOp & Dep::Or) != Dep::Or)
 445                Group = 0;
 446
 447             // Invert for Conflicts
 448             if (D->Type == Dep::Conflicts)
 449                State = ~State;
 450          }
 451       }
 452
 453       // Compute the pacakge dependency state and size additions
 454       AddSizes(I);
 455       UpdateVerState(I);
 456       AddStates(I);
 457    }
 458
 459    if (Prog != 0)
 460       Prog->Progress(Done);
 461 }
 462                                                                         /*}}}*/
 463 // DepCache::Update - Update the deps list of a package                 /*{{{*/
 464 // ---------------------------------------------------------------------
 465 /* This is a helper for update that only does the dep portion of the scan.
 466    It is mainly ment to scan reverse dependencies. */
 467 void pkgDepCache::Update(DepIterator D)
 468 {
 469    // Update the reverse deps
 470    for (;D.end() != true; D++)
 471    {
 472       unsigned char &State = DepState[D->ID];
 473       State = DependencyState(D);
 474
 475       // Invert for Conflicts
 476       if (D->Type == Dep::Conflicts)
 477          State = ~State;
 478
 479       RemoveStates(D.ParentPkg());
 480       BuildGroupOrs(D.ParentVer());
 481       UpdateVerState(D.ParentPkg());
 482       AddStates(D.ParentPkg());
 483    }
 484 }
 485                                                                         /*}}}*/
 486 // DepCache::Update - Update the related deps of a package              /*{{{*/
 487 // ---------------------------------------------------------------------
 488 /* This is called whenever the state of a package changes. It updates
 489    all cached dependencies related to this package. */
 490 void pkgDepCache::Update(PkgIterator const &Pkg)
 491 {
 492    // Recompute the dep of the package
 493    RemoveStates(Pkg);
 494    UpdateVerState(Pkg);
 495    AddStates(Pkg);
 496
 497    // Update the reverse deps
 498    Update(Pkg.RevDependsList());
 499
 500    // Update the provides map for the current ver
 501    if (Pkg->CurrentVer != 0)
 502       for (PrvIterator P = Pkg.CurrentVer().ProvidesList();
 503            P.end() != true; P++)
 504          Update(P.ParentPkg().RevDependsList());
 505
 506    // Update the provides map for the candidate ver
 507    for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();
 508         P.end() != true; P++)
 509       Update(P.ParentPkg().RevDependsList());
 510 }
 511
 512                                                                         /*}}}*/
 513
 514 // DepCache::MarkKeep - Put the package in the keep state               /*{{{*/
 515 // ---------------------------------------------------------------------
 516 /* */
 517 void pkgDepCache::MarkKeep(PkgIterator const &Pkg,bool Soft)
 518 {
 519    // Simplifies other routines.
 520    if (Pkg.end() == true)
 521       return;
 522
 523    /* We changed the soft state all the time so the UI is a bit nicer
 524       to use */
 525    StateCache &P = PkgState[Pkg->ID];
 526    if (Soft == true)
 527       P.iFlags |= AutoKept;
 528    else
 529       P.iFlags &= ~AutoKept;
 530
 531    // Check that it is not already kept
 532    if (P.Mode == ModeKeep)
 533       return;
 534
 535    // We dont even try to keep virtual packages..
 536    if (Pkg->VersionList == 0)
 537       return;
 538
 539    P.Flags &= ~Flag::Auto;
 540    RemoveSizes(Pkg);
 541    RemoveStates(Pkg);
 542
 543    P.Mode = ModeKeep;
 544    if (Pkg->CurrentVer == 0)
 545       P.InstallVer = 0;
 546    else
 547       P.InstallVer = Pkg.CurrentVer();
 548
 549    AddStates(Pkg);
 550
 551    Update(Pkg);
 552
 553    AddSizes(Pkg);
 554 }
 555                                                                         /*}}}*/
 556 // DepCache::MarkDelete - Put the package in the delete state           /*{{{*/
 557 // ---------------------------------------------------------------------
 558 /* */
 559 void pkgDepCache::MarkDelete(PkgIterator const &Pkg)
 560 {
 561    // Simplifies other routines.
 562    if (Pkg.end() == true)
 563       return;
 564
 565    // Check that it is not already marked for delete
 566    StateCache &P = PkgState[Pkg->ID];
 567    P.iFlags &= ~AutoKept;
 568    if (P.Mode == ModeDelete || P.InstallVer == 0)
 569       return;
 570
 571    // We dont even try to delete virtual packages..
 572    if (Pkg->VersionList == 0)
 573       return;
 574
 575    RemoveSizes(Pkg);
 576    RemoveStates(Pkg);
 577
 578    if (Pkg->CurrentVer == 0)
 579       P.Mode = ModeKeep;
 580    else
 581       P.Mode = ModeDelete;
 582    P.InstallVer = 0;
 583    P.Flags &= Flag::Auto;
 584
 585    AddStates(Pkg);
 586    Update(Pkg);
 587    AddSizes(Pkg);
 588 }
 589                                                                         /*}}}*/
 590 // DepCache::MarkInstall - Put the package in the install state         /*{{{*/
 591 // ---------------------------------------------------------------------
 592 /* */
 593 void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst)
 594 {
 595    // Simplifies other routines.
 596    if (Pkg.end() == true)
 597       return;
 598
 599    /* Check that it is not already marked for install and that it can be
 600       installed */
 601    StateCache &P = PkgState[Pkg->ID];
 602    P.iFlags &= ~AutoKept;
 603    if (P.InstBroken() == false && (P.Mode == ModeInstall ||
 604         P.CandidateVer == (Version *)Pkg.CurrentVer()))
 605    {
 606       if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)
 607          MarkKeep(Pkg);
 608       return;
 609    }
 610
 611    // We dont even try to install virtual packages..
 612    if (Pkg->VersionList == 0)
 613       return;
 614
 615    /* Target the candidate version and remove the autoflag. We reset the
 616       autoflag below if this was called recursively. Otherwise the user
 617       should have the ability to de-auto a package by changing its state */
 618    RemoveSizes(Pkg);
 619    RemoveStates(Pkg);
 620
 621    P.Mode = ModeInstall;
 622    P.InstallVer = P.CandidateVer;
 623    P.Flags &= ~Flag::Auto;
 624    if (P.CandidateVer == (Version *)Pkg.CurrentVer())
 625       P.Mode = ModeKeep;
 626
 627    AddStates(Pkg);
 628    Update(Pkg);
 629    AddSizes(Pkg);
 630
 631    if (AutoInst == false)
 632       return;
 633
 634    DepIterator Dep = P.InstVerIter(*this).DependsList();
 635    for (; Dep.end() != true;)
 636    {
 637       // Grok or groups
 638       DepIterator Start = Dep;
 639       bool Result = true;
 640       for (bool LastOR = true; Dep.end() == false && LastOR == true; Dep++)
 641       {
 642          LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
 643
 644          if ((DepState[Dep->ID] & DepInstall) == DepInstall)
 645             Result = false;
 646       }
 647
 648       // Dep is satisfied okay.
 649       if (Result == false)
 650          continue;
 651
 652       /* Check if this dep should be consider for install. If it is a user
 653          defined important dep and we are installed a new package then
 654          it will be installed. Otherwise we only worry about critical deps */
 655       if (IsImportantDep(Start) == false)
 656          continue;
 657       if (Pkg->CurrentVer != 0 && Start.IsCritical() == false)
 658          continue;
 659
 660       // Now we have to take action...
 661       PkgIterator P = Start.SmartTargetPkg();
 662       if ((DepState[Start->ID] & DepCVer) == DepCVer)
 663       {
 664          MarkInstall(P,true);
 665
 666          // Set the autoflag, after MarkInstall because MarkInstall unsets it
 667          if (P->CurrentVer == 0)
 668             PkgState[P->ID].Flags |= Flag::Auto;
 669
 670          continue;
 671       }
 672
 673       // For conflicts we just de-install the package and mark as auto
 674       if (Start->Type == Dep::Conflicts)
 675       {
 676          Version **List = Start.AllTargets();
 677          for (Version **I = List; *I != 0; I++)
 678          {
 679             VerIterator Ver(*this,*I);
 680             PkgIterator Pkg = Ver.ParentPkg();
 681
 682             MarkDelete(Pkg);
 683             PkgState[Pkg->ID].Flags |= Flag::Auto;
 684          }
 685          delete [] List;
 686          continue;
 687       }
 688    }
 689 }
 690                                                                         /*}}}*/
 691
 692 // StateCache::Update - Compute the various static display things       /*{{{*/
 693 // ---------------------------------------------------------------------
 694 /* This is called whenever the Candidate version changes. */
 695 void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
 696 {
 697    // Some info
 698    VerIterator Ver = CandidateVerIter(Cache);
 699
 700    // Use a null string or the version string
 701    if (Ver.end() == true)
 702       CandVersion = "";
 703    else
 704       CandVersion = Ver.VerStr();
 705
 706    // Find the current version
 707    CurVersion = "";
 708    if (Pkg->CurrentVer != 0)
 709       CurVersion = Pkg.CurrentVer().VerStr();
 710
 711    // Strip off the epochs for display
 712    CurVersion = StripEpoch(CurVersion);
 713    CandVersion = StripEpoch(CandVersion);
 714
 715    // Figure out if its up or down or equal
 716    Status = Ver.CompareVer(Pkg.CurrentVer());
 717    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
 718      Status = 2;
 719 }
 720                                                                         /*}}}*/
 721 // StateCache::StripEpoch - Remove the epoch specifier from the version /*{{{*/
 722 // ---------------------------------------------------------------------
 723 /* */
 724 const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
 725 {
 726    if (Ver == 0)
 727       return 0;
 728
 729    // Strip any epoch
 730    for (const char *I = Ver; *I != 0; I++)
 731       if (*I == ':')
 732          return I + 1;
 733    return Ver;
 734 }
 735                                                                         /*}}}*/