merge lp:~mvo/apt/ubuntu-mirror-method-improvements

[apt.git] / apt-pkg / orderlist.cc

diff --git a/apt-pkg/orderlist.cc b/apt-pkg/orderlist.cc
index cb52d160ed67b9e04b3cb62e6bf557ea137dde50..7c950292ace11ed299290451cf33a816e800c048 100644 (file)
--- a/apt-pkg/orderlist.cc
+++ b/apt-pkg/orderlist.cc
@@ -1,13 +1,13 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: orderlist.cc,v 1.7 1999/07/19 01:49:44 jgg Exp $
+// $Id: orderlist.cc,v 1.14 2001/05/07 05:49:43 jgg Exp $

 /* ######################################################################
 
    Order List - Represents and Manipulates an ordered list of packages.
    
    A list of packages can be ordered by a number of conflicting criteria
    each given a specific priority. Each package also has a set of flags
 /* ######################################################################
 
    Order List - Represents and Manipulates an ordered list of packages.
    
    A list of packages can be ordered by a number of conflicting criteria
    each given a specific priority. Each package also has a set of flags

-   indicating some usefull things about it that are derived in the 
+   indicating some useful things about it that are derived in the 

    course of sorting. The pkgPackageManager class uses this class for
    all of it's installation ordering needs.
 
    course of sorting. The pkgPackageManager class uses this class for
    all of it's installation ordering needs.
 


@@ -39,31 +39,48 @@
          ordering.  
    
    Each of the features can be enabled in the sorting routine at an 
          ordering.  
    
    Each of the features can be enabled in the sorting routine at an 

-   arbitary priority to give quite abit of control over the final unpacking
+   arbitrary priority to give quite abit of control over the final unpacking

    order.
 
    The rules listed above may never be violated and are called Critical.
    When a critical rule is violated then a loop condition is recorded
    and will have to be delt with in the caller.
    order.
 
    The rules listed above may never be violated and are called Critical.
    When a critical rule is violated then a loop condition is recorded
    and will have to be delt with in the caller.

+
+   The ordering keeps two lists, the main list and the 'After List'. The
+   purpose of the after list is to allow packages to be delayed. This is done
+   by setting the after flag on the package. Any package which requires this
+   package to be ordered before will inherit the after flag and so on. This
+   is used for CD swap ordering where all packages on a second CD have the 
+   after flag set. This forces them and all their dependents to be ordered
+   toward the end.
+   
+   There are complications in this algorithm when presented with cycles.
+   For all known practical cases it works, all cases where it doesn't work
+   is fixable by tweaking the package descriptions. However, it should be
+   possible to impove this further to make some better choices when 
+   presented with cycles. 

    
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

-#ifdef __GNUG__
-#pragma implementation "apt-pkg/orderlist.h"
-#endif 

 #include <apt-pkg/orderlist.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/orderlist.h>
 #include <apt-pkg/depcache.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/version.h>

+#include <apt-pkg/sptr.h>
+#include <apt-pkg/configuration.h>
+
+#include <iostream>

                                                                        /*}}}*/
 
                                                                        /*}}}*/
 

+using namespace std;
+

 pkgOrderList *pkgOrderList::Me = 0;
 
 // OrderList::pkgOrderList - Constructor                               /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 pkgOrderList *pkgOrderList::Me = 0;
 
 // OrderList::pkgOrderList - Constructor                               /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgOrderList::pkgOrderList(pkgDepCache &Cache) : Cache(Cache)
+pkgOrderList::pkgOrderList(pkgDepCache *pCache) : Cache(*pCache)

 {
    FileList = 0;
    Primary = 0;
 {
    FileList = 0;
    Primary = 0;


@@ -71,11 +88,12 @@ pkgOrderList::pkgOrderList(pkgDepCache &Cache) : Cache(Cache)
    RevDepends = 0;
    Remove = 0;
    LoopCount = -1;
    RevDepends = 0;
    Remove = 0;
    LoopCount = -1;

-
+   Debug = _config->FindB("Debug::pkgOrderList",false);
+   

    /* Construct the arrays, egcs 1.0.1 bug requires the package count
       hack */
    /* Construct the arrays, egcs 1.0.1 bug requires the package count
       hack */

-   unsigned long Size = Cache.HeaderP->PackageCount;
-   Flags = new unsigned char[Size];
+   unsigned long Size = Cache.Head().PackageCount;
+   Flags = new unsigned short[Size];

    End = List = new Package *[Size];
    memset(Flags,0,sizeof(*Flags)*Size);
 }
    End = List = new Package *[Size];
    memset(Flags,0,sizeof(*Flags)*Size);
 }


@@ -102,28 +120,37 @@ bool pkgOrderList::IsMissing(PkgIterator Pkg)
    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && 
        Cache[Pkg].Keep() == true)
       return false;
    if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && 
        Cache[Pkg].Keep() == true)
       return false;

+
+   if (FileList == 0)
+      return false;

    
    

-   if (FileList != 0 && FileList[Pkg->ID].empty() == false)
+   if (FileList[Pkg->ID].empty() == false)

       return false;
       return false;

+
+   // Missing Pseudo packages are missing if the real package is missing
+   if (pkgCache::VerIterator(Cache, Cache[Pkg].CandidateVer).Pseudo() == true)
+      return IsMissing(Pkg.Group().FindPkg("all"));
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-

 // OrderList::DoRun - Does an order run                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* The caller is expeted to have setup the desired probe state */
 bool pkgOrderList::DoRun()
 {   
    // Temp list
 // OrderList::DoRun - Does an order run                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* The caller is expeted to have setup the desired probe state */
 bool pkgOrderList::DoRun()
 {   
    // Temp list

-   unsigned long Size = Cache.HeaderP->PackageCount;
-   Package **NList = new Package *[Size];
-
+   unsigned long Size = Cache.Head().PackageCount;
+   SPtrArray<Package *> NList = new Package *[Size];
+   SPtrArray<Package *> AfterList = new Package *[Size];
+   AfterEnd = AfterList;
+   

    Depth = 0;
    WipeFlags(Added | AddPending | Loop | InList);
 
    for (iterator I = List; I != End; I++)
       Flag(*I,InList);
    Depth = 0;
    WipeFlags(Added | AddPending | Loop | InList);
 
    for (iterator I = List; I != End; I++)
       Flag(*I,InList);

-   
+

    // Rebuild the main list into the temp list.
    iterator OldEnd = End;
    End = NList;
    // Rebuild the main list into the temp list.
    iterator OldEnd = End;
    End = NList;


@@ -131,13 +158,16 @@ bool pkgOrderList::DoRun()
       if (VisitNode(PkgIterator(Cache,*I)) == false)
       {
         End = OldEnd;
       if (VisitNode(PkgIterator(Cache,*I)) == false)
       {
         End = OldEnd;

-        delete [] NList;

         return false;
       }
    
         return false;
       }
    

+   // Copy the after list to the end of the main list
+   for (Package **I = AfterList; I != AfterEnd; I++)
+      *End++ = *I;
+   

    // Swap the main list to the new list
    delete [] List;
    // Swap the main list to the new list
    delete [] List;

-   List = NList;
+   List = NList.UnGuard();

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -149,22 +179,35 @@ bool pkgOrderList::DoRun()
 bool pkgOrderList::OrderCritical()
 {
    FileList = 0;
 bool pkgOrderList::OrderCritical()
 {
    FileList = 0;

-   
-   Primary = &DepUnPackPre;
+
+   Primary = &pkgOrderList::DepUnPackPreD;

    Secondary = 0;
    RevDepends = 0;
    Remove = 0;
    LoopCount = 0;
    Secondary = 0;
    RevDepends = 0;
    Remove = 0;
    LoopCount = 0;

-   
+

    // Sort
    Me = this;
    // Sort
    Me = this;

-   qsort(List,End - List,sizeof(*List),&OrderCompareB);   
-   
+   qsort(List,End - List,sizeof(*List),&OrderCompareB);
+

    if (DoRun() == false)
       return false;
    if (DoRun() == false)
       return false;

-   
+

    if (LoopCount != 0)
       return _error->Error("Fatal, predepends looping detected");
    if (LoopCount != 0)
       return _error->Error("Fatal, predepends looping detected");

+
+   if (Debug == true)
+   {
+      clog << "** Critical Unpack ordering done" << endl;
+
+      for (iterator I = List; I != End; I++)
+      {
+        PkgIterator P(Cache,*I);
+        if (IsNow(P) == true)
+           clog << "  " << P.FullName() << ' ' << IsMissing(P) << ',' << IsFlag(P,After) << endl;
+      }
+   }
+

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -176,41 +219,67 @@ bool pkgOrderList::OrderUnpack(string *FileList)
 {
    this->FileList = FileList;
 
 {
    this->FileList = FileList;
 

-   Primary = &DepUnPackCrit;
-   Secondary = &DepConfigure;
-   RevDepends = &DepUnPackDep;
-   Remove = &DepRemove;
+   // Setup the after flags
+   if (FileList != 0)
+   {
+      WipeFlags(After);
+
+      // Set the inlist flag
+      for (iterator I = List; I != End; I++)
+      {
+        PkgIterator P(Cache,*I);
+        if (IsMissing(P) == true && IsNow(P) == true)
+            Flag(*I,After);
+      }
+   }
+
+   Primary = &pkgOrderList::DepUnPackCrit;
+   Secondary = &pkgOrderList::DepConfigure;
+   RevDepends = &pkgOrderList::DepUnPackDep;
+   Remove = &pkgOrderList::DepRemove;

    LoopCount = -1;
 
    // Sort
    Me = this;
    qsort(List,End - List,sizeof(*List),&OrderCompareA);
 
    LoopCount = -1;
 
    // Sort
    Me = this;
    qsort(List,End - List,sizeof(*List),&OrderCompareA);
 

+   if (Debug == true)
+      clog << "** Pass A" << endl;

    if (DoRun() == false)
       return false;
    if (DoRun() == false)
       return false;

-   
+
+   if (Debug == true)
+      clog << "** Pass B" << endl;

    Secondary = 0;
    if (DoRun() == false)
       return false;
 
    Secondary = 0;
    if (DoRun() == false)
       return false;
 

+   if (Debug == true)
+      clog << "** Pass C" << endl;

    LoopCount = 0;
    RevDepends = 0;
    Remove = 0;             // Otherwise the libreadline remove problem occures
    if (DoRun() == false)
       return false;
 
    LoopCount = 0;
    RevDepends = 0;
    Remove = 0;             // Otherwise the libreadline remove problem occures
    if (DoRun() == false)
       return false;
 

+   if (Debug == true)
+      clog << "** Pass D" << endl;

    LoopCount = 0;
    LoopCount = 0;

-   Primary = &DepUnPackPre;
+   Primary = &pkgOrderList::DepUnPackPre;

    if (DoRun() == false)
       return false;
 
    if (DoRun() == false)
       return false;
 

-/*   cout << "----------END" << endl;
-
-   for (iterator I = List; I != End; I++)
+   if (Debug == true)

    {
    {

-      PkgIterator P(Cache,*I);
-      cout << P.Name() << endl;
-   }*/
+      clog << "** Unpack ordering done" << endl;
+
+      for (iterator I = List; I != End; I++)
+      {
+        PkgIterator P(Cache,*I);
+        if (IsNow(P) == true)
+           clog << "  " << P.FullName() << ' ' << IsMissing(P) << ',' << IsFlag(P,After) << endl;
+      }
+   }

 
    return true;
 }
 
    return true;
 }


@@ -222,7 +291,7 @@ bool pkgOrderList::OrderUnpack(string *FileList)
 bool pkgOrderList::OrderConfigure()
 {
    FileList = 0;
 bool pkgOrderList::OrderConfigure()
 {
    FileList = 0;

-   Primary = &DepConfigure;
+   Primary = &pkgOrderList::DepConfigure;

    Secondary = 0;
    RevDepends = 0;
    Remove = 0;
    Secondary = 0;
    RevDepends = 0;
    Remove = 0;


@@ -230,32 +299,40 @@ bool pkgOrderList::OrderConfigure()
    return DoRun();
 }
                                                                        /*}}}*/
    return DoRun();
 }
                                                                        /*}}}*/

-

 // OrderList::Score - Score the package for sorting                    /*{{{*/
 // ---------------------------------------------------------------------
 /* Higher scores order earlier */
 int pkgOrderList::Score(PkgIterator Pkg)
 {
 // OrderList::Score - Score the package for sorting                    /*{{{*/
 // ---------------------------------------------------------------------
 /* Higher scores order earlier */
 int pkgOrderList::Score(PkgIterator Pkg)
 {

+   static int const ScoreDelete = _config->FindI("OrderList::Score::Delete", 500);
+

    // Removal is always done first
    if (Cache[Pkg].Delete() == true)
    // Removal is always done first
    if (Cache[Pkg].Delete() == true)

-      return 200;
-   
+      return ScoreDelete;
+

    // This should never happen..
    if (Cache[Pkg].InstVerIter(Cache).end() == true)
       return -1;
    // This should never happen..
    if (Cache[Pkg].InstVerIter(Cache).end() == true)
       return -1;

-   
+
+   static int const ScoreEssential = _config->FindI("OrderList::Score::Essential", 200);
+   static int const ScoreImmediate = _config->FindI("OrderList::Score::Immediate", 10);
+   static int const ScorePreDepends = _config->FindI("OrderList::Score::PreDepends", 50);
+

    int Score = 0;
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
    int Score = 0;
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)

-      Score += 100;
+      Score += ScoreEssential;
+
+   if (IsFlag(Pkg,Immediate) == true)
+      Score += ScoreImmediate;

 
 

-   for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList(); 
+   for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();

        D.end() == false; D++)
       if (D->Type == pkgCache::Dep::PreDepends)
       {
        D.end() == false; D++)
       if (D->Type == pkgCache::Dep::PreDepends)
       {

-        Score += 50;
+        Score += ScorePreDepends;

         break;
       }
         break;
       }

-      
+

    // Important Required Standard Optional Extra
    signed short PrioMap[] = {0,5,4,3,1,0};
    if (Cache[Pkg].InstVerIter(Cache)->Priority <= 5)
    // Important Required Standard Optional Extra
    signed short PrioMap[] = {0,5,4,3,1,0};
    if (Cache[Pkg].InstVerIter(Cache)->Priority <= 5)


@@ -312,16 +389,16 @@ int pkgOrderList::OrderCompareA(const void *a, const void *b)
 
    // We order packages with a set state toward the front
    int Res;
 
    // We order packages with a set state toward the front
    int Res;

-   if ((Res = BoolCompare(Me->IsNow(A),Me->IsNow(B))) == 0)
+   if ((Res = BoolCompare(Me->IsNow(A),Me->IsNow(B))) != 0)

       return -1*Res;
    
    // We order missing files to toward the end
       return -1*Res;
    
    // We order missing files to toward the end

-   if (Me->FileList != 0)
+/*   if (Me->FileList != 0)

    {
       if ((Res = BoolCompare(Me->IsMissing(A),
    {
       if ((Res = BoolCompare(Me->IsMissing(A),

-                            Me->IsMissing(B))) == 0)
+                            Me->IsMissing(B))) != 0)

         return Res;
         return Res;

-   }
+   }*/

    
    if (A.State() != pkgCache::PkgIterator::NeedsNothing && 
        B.State() == pkgCache::PkgIterator::NeedsNothing)
    
    if (A.State() != pkgCache::PkgIterator::NeedsNothing && 
        B.State() == pkgCache::PkgIterator::NeedsNothing)


@@ -333,6 +410,7 @@ int pkgOrderList::OrderCompareA(const void *a, const void *b)
    
    int ScoreA = Me->Score(A);
    int ScoreB = Me->Score(B);
    
    int ScoreA = Me->Score(A);
    int ScoreB = Me->Score(B);

+

    if (ScoreA > ScoreB)
       return -1;
    
    if (ScoreA > ScoreB)
       return -1;
    


@@ -344,7 +422,7 @@ int pkgOrderList::OrderCompareA(const void *a, const void *b)
                                                                        /*}}}*/
 // OrderList::OrderCompareB - Order the installation by source         /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // OrderList::OrderCompareB - Order the installation by source         /*{{{*/
 // ---------------------------------------------------------------------

-/* This orders by installation source. This is usefull to handle
+/* This orders by installation source. This is useful to handle

    inter-source breaks */
 int pkgOrderList::OrderCompareB(const void *a, const void *b)
 {
    inter-source breaks */
 int pkgOrderList::OrderCompareB(const void *a, const void *b)
 {


@@ -369,6 +447,7 @@ int pkgOrderList::OrderCompareB(const void *a, const void *b)
    
    int ScoreA = Me->Score(A);
    int ScoreB = Me->Score(B);
    
    int ScoreA = Me->Score(A);
    int ScoreB = Me->Score(B);

+

    if (ScoreA > ScoreB)
       return -1;
    
    if (ScoreA > ScoreB)
       return -1;
    


@@ -378,7 +457,6 @@ int pkgOrderList::OrderCompareB(const void *a, const void *b)
    return strcmp(A.Name(),B.Name());
 }
                                                                        /*}}}*/
    return strcmp(A.Name(),B.Name());
 }
                                                                        /*}}}*/

-

 // OrderList::VisitDeps - Visit forward install dependencies           /*{{{*/
 // ---------------------------------------------------------------------
 /* This calls the dependency function for the normal forwards dependencies
 // OrderList::VisitDeps - Visit forward install dependencies           /*{{{*/
 // ---------------------------------------------------------------------
 /* This calls the dependency function for the normal forwards dependencies


@@ -422,33 +500,35 @@ bool pkgOrderList::VisitRProvides(DepFunc F,VerIterator Ver)
 // ---------------------------------------------------------------------
 /* This routine calls visit on all providing packages. */
 bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)
 // ---------------------------------------------------------------------
 /* This routine calls visit on all providing packages. */
 bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)

-{
-   Version **List = D.AllTargets();
+{   
+   SPtrArray<Version *> List = D.AllTargets();

    for (Version **I = List; *I != 0; I++)
    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();
    for (Version **I = List; *I != 0; I++)
    {
       VerIterator Ver(Cache,*I);
       PkgIterator Pkg = Ver.ParentPkg();

-      
-      if (Cache[Pkg].Keep() == true)
+
+      if (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)

         continue;
       
         continue;
       

-      if (D->Type != pkgCache::Dep::Conflicts && Cache[Pkg].InstallVer != *I)
+      if (D->Type != pkgCache::Dep::Conflicts &&
+         D->Type != pkgCache::Dep::DpkgBreaks &&
+         D->Type != pkgCache::Dep::Obsoletes &&
+         Cache[Pkg].InstallVer != *I)

         continue;
       
         continue;
       

-      if (D->Type == pkgCache::Dep::Conflicts && (Version *)Pkg.CurrentVer() != *I)
+      if ((D->Type == pkgCache::Dep::Conflicts ||
+          D->Type == pkgCache::Dep::DpkgBreaks ||
+          D->Type == pkgCache::Dep::Obsoletes) &&
+         (Version *)Pkg.CurrentVer() != *I)

         continue;
       
       // Skip over missing files
       if (Critical == false && IsMissing(D.ParentPkg()) == true)
         continue;
         continue;
       
       // Skip over missing files
       if (Critical == false && IsMissing(D.ParentPkg()) == true)
         continue;

-        
+

       if (VisitNode(Pkg) == false)
       if (VisitNode(Pkg) == false)

-      {
-        delete [] List;

         return false;
         return false;

-      }

    }
    }

-   delete [] List;

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -465,8 +545,12 @@ bool pkgOrderList::VisitNode(PkgIterator Pkg)
        IsFlag(Pkg,AddPending) == true || IsFlag(Pkg,InList) == false)
       return true;
 
        IsFlag(Pkg,AddPending) == true || IsFlag(Pkg,InList) == false)
       return true;
 

-/* for (int j = 0; j != Depth; j++) cout << ' ';
- cout << "Visit " << Pkg.Name() << endl;*/
+   if (Debug == true)
+   {
+      for (int j = 0; j != Depth; j++) clog << ' ';
+      clog << "Visit " << Pkg.FullName() << endl;
+   }
+   

    Depth++;
    
    // Color grey
    Depth++;
    
    // Color grey


@@ -475,8 +559,8 @@ bool pkgOrderList::VisitNode(PkgIterator Pkg)
    DepFunc Old = Primary;
    
    // Perform immedate configuration of the package if so flagged.
    DepFunc Old = Primary;
    
    // Perform immedate configuration of the package if so flagged.

-   if (IsFlag(Pkg,Immediate) == true && Primary != &DepUnPackPre)
-      Primary = &DepUnPackPreD;
+   if (IsFlag(Pkg,Immediate) == true && Primary != &pkgOrderList::DepUnPackPre)
+      Primary = &pkgOrderList::DepUnPackPreD;

 
    if (IsNow(Pkg) == true)
    {
 
    if (IsNow(Pkg) == true)
    {


@@ -511,20 +595,24 @@ bool pkgOrderList::VisitNode(PkgIterator Pkg)
    if (IsFlag(Pkg,Added) == false)
    {
       Flag(Pkg,Added,Added | AddPending);
    if (IsFlag(Pkg,Added) == false)
    {
       Flag(Pkg,Added,Added | AddPending);

-      *End = Pkg;
-      End++;
+      if (IsFlag(Pkg,After) == true)
+        *AfterEnd++ = Pkg;
+      else
+        *End++ = Pkg;

    }
    
    Primary = Old;
    Depth--;
    }
    
    Primary = Old;
    Depth--;

-   
-/* for (int j = 0; j != Depth; j++) cout << ' ';
-   cout << "Leave " << Pkg.Name() << ' ' << IsFlag(Pkg,Added) << ',' << IsFlag(Pkg,AddPending) << endl;*/

 
 

+   if (Debug == true)
+   {
+      for (int j = 0; j != Depth; j++) clog << ' ';
+      clog << "Leave " << Pkg.FullName() << ' ' << IsFlag(Pkg,Added) << ',' << IsFlag(Pkg,AddPending) << endl;
+   }
+   

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-

 // OrderList::DepUnPackCrit - Critical UnPacking ordering              /*{{{*/
 // ---------------------------------------------------------------------
 /* Critical unpacking ordering strives to satisfy Conflicts: and 
 // OrderList::DepUnPackCrit - Critical UnPacking ordering              /*{{{*/
 // ---------------------------------------------------------------------
 /* Critical unpacking ordering strives to satisfy Conflicts: and 


@@ -540,7 +628,8 @@ bool pkgOrderList::DepUnPackCrit(DepIterator D)
       {
         /* Reverse depenanices are only interested in conflicts,
            predepend breakage is ignored here */
       {
         /* Reverse depenanices are only interested in conflicts,
            predepend breakage is ignored here */

-        if (D->Type != pkgCache::Dep::Conflicts)
+        if (D->Type != pkgCache::Dep::Conflicts && 
+            D->Type != pkgCache::Dep::Obsoletes)

            continue;
 
         // Duplication elimination, consider only the current version
            continue;
 
         // Duplication elimination, consider only the current version


@@ -561,7 +650,10 @@ bool pkgOrderList::DepUnPackCrit(DepIterator D)
       {
         /* Forward critical dependencies MUST be correct before the 
            package can be unpacked. */
       {
         /* Forward critical dependencies MUST be correct before the 
            package can be unpacked. */

-        if (D->Type != pkgCache::Dep::Conflicts && D->Type != pkgCache::Dep::PreDepends)
+        if (D->Type != pkgCache::Dep::Conflicts &&
+            D->Type != pkgCache::Dep::DpkgBreaks &&
+            D->Type != pkgCache::Dep::Obsoletes &&
+            D->Type != pkgCache::Dep::PreDepends)

            continue;
                                 
         /* We wish to check if the dep is okay in the now state of the
            continue;
                                 
         /* We wish to check if the dep is okay in the now state of the


@@ -589,7 +681,7 @@ bool pkgOrderList::DepUnPackCrit(DepIterator D)
         DepFunc Old = Primary;
         bool Res = false;
         if (D->Type == pkgCache::Dep::PreDepends)
         DepFunc Old = Primary;
         bool Res = false;
         if (D->Type == pkgCache::Dep::PreDepends)

-           Primary = &DepUnPackPreD;
+           Primary = &pkgOrderList::DepUnPackPreD;

         Res = VisitProvides(D,true);
         Primary = Old;
         if (Res == false)
         Res = VisitProvides(D,true);
         Primary = Old;
         if (Res == false)


@@ -603,8 +695,7 @@ bool pkgOrderList::DepUnPackCrit(DepIterator D)
 // ---------------------------------------------------------------------
 /* Critical PreDepends (also configure immediate and essential) strives to
    ensure not only that all conflicts+predepends are met but that this
 // ---------------------------------------------------------------------
 /* Critical PreDepends (also configure immediate and essential) strives to
    ensure not only that all conflicts+predepends are met but that this

-   package will be immediately configurable when it is unpacked. 
-
+   package will be immediately configurable when it is unpacked.

    Loops are preprocessed and logged. */
 bool pkgOrderList::DepUnPackPreD(DepIterator D)
 {
    Loops are preprocessed and logged. */
 bool pkgOrderList::DepUnPackPreD(DepIterator D)
 {


@@ -669,7 +760,7 @@ bool pkgOrderList::DepUnPackPre(DepIterator D)
         else
            continue;
       }
         else
            continue;
       }

-
+      

       /* We wish to check if the dep is okay in the now state of the
          target package against the install state of this package. */
       if (CheckDep(D) == true)
       /* We wish to check if the dep is okay in the now state of the
          target package against the install state of this package. */
       if (CheckDep(D) == true)


@@ -679,7 +770,7 @@ bool pkgOrderList::DepUnPackPre(DepIterator D)
         if (IsFlag(D.TargetPkg(),AddPending) == false)
            continue;
       }
         if (IsFlag(D.TargetPkg(),AddPending) == false)
            continue;
       }

-      
+

       // This is the loop detection
       if (IsFlag(D.TargetPkg(),Added) == true || 
          IsFlag(D.TargetPkg(),AddPending) == true)
       // This is the loop detection
       if (IsFlag(D.TargetPkg(),Added) == true || 
          IsFlag(D.TargetPkg(),AddPending) == true)


@@ -733,9 +824,20 @@ bool pkgOrderList::DepUnPackDep(DepIterator D)
               return false;
         }
         else
               return false;
         }
         else

+        {

            if (D->Type == pkgCache::Dep::Depends)
               if (VisitProvides(D,false) == false)
                  return false;
            if (D->Type == pkgCache::Dep::Depends)
               if (VisitProvides(D,false) == false)
                  return false;

+
+           if (D->Type == pkgCache::Dep::DpkgBreaks)
+           {
+              if (CheckDep(D) == true)
+                continue;
+
+              if (VisitNode(D.TargetPkg()) == false)
+                return false;
+           }
+        }

       }
    return true;
 }
       }
    return true;
 }


@@ -811,7 +913,6 @@ bool pkgOrderList::DepRemove(DepIterator D)
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-

 // OrderList::AddLoop - Add a loop to the loop list                    /*{{{*/
 // ---------------------------------------------------------------------
 /* We record the loops. This is a relic since loop breaking is done 
 // OrderList::AddLoop - Add a loop to the loop list                    /*{{{*/
 // ---------------------------------------------------------------------
 /* We record the loops. This is a relic since loop breaking is done 


@@ -842,7 +943,7 @@ bool pkgOrderList::AddLoop(DepIterator D)
 /* */
 void pkgOrderList::WipeFlags(unsigned long F)
 {
 /* */
 void pkgOrderList::WipeFlags(unsigned long F)
 {

-   unsigned long Size = Cache.HeaderP->PackageCount;
+   unsigned long Size = Cache.Head().PackageCount;

    for (unsigned long I = 0; I != Size; I++)
       Flags[I] &= ~F;
 }
    for (unsigned long I = 0; I != Size; I++)
       Flags[I] &= ~F;
 }


@@ -856,7 +957,8 @@ void pkgOrderList::WipeFlags(unsigned long F)
    this fails to produce a suitable result. */
 bool pkgOrderList::CheckDep(DepIterator D)
 {
    this fails to produce a suitable result. */
 bool pkgOrderList::CheckDep(DepIterator D)
 {

-   Version **List = D.AllTargets();
+   SPtrArray<Version *> List = D.AllTargets();
+   bool Hit = false;

    for (Version **I = List; *I != 0; I++)
    {
       VerIterator Ver(Cache,*I);
    for (Version **I = List; *I != 0; I++)
    {
       VerIterator Ver(Cache,*I);


@@ -867,8 +969,8 @@ bool pkgOrderList::CheckDep(DepIterator D)
                 way ordering works Added means the package will be unpacked
                 before this one and AddPending means after. It is therefore
                 correct to ignore AddPending in all cases, but that exposes
                 way ordering works Added means the package will be unpacked
                 before this one and AddPending means after. It is therefore
                 correct to ignore AddPending in all cases, but that exposes

-                reverse-ordering loops which should be ignore. */
-      if (IsFlag(Pkg,Added) == true || 
+                reverse-ordering loops which should be ignored. */
+      if (IsFlag(Pkg,Added) == true ||

          (IsFlag(Pkg,AddPending) == true && D.Reverse() == true))
       {
         if (Cache[Pkg].InstallVer != *I)
          (IsFlag(Pkg,AddPending) == true && D.Reverse() == true))
       {
         if (Cache[Pkg].InstallVer != *I)


@@ -879,20 +981,42 @@ bool pkgOrderList::CheckDep(DepIterator D)
             Pkg.State() != PkgIterator::NeedsNothing)
            continue;
       
             Pkg.State() != PkgIterator::NeedsNothing)
            continue;
       

-      delete [] List;
-      

       /* Conflicts requires that all versions are not present, depends
          just needs one */
       /* Conflicts requires that all versions are not present, depends
          just needs one */

-      if (D->Type != pkgCache::Dep::Conflicts)
+      if (D->Type != pkgCache::Dep::Conflicts && 
+         D->Type != pkgCache::Dep::DpkgBreaks && 
+         D->Type != pkgCache::Dep::Obsoletes)
+      {
+        /* Try to find something that does not have the after flag set
+           if at all possible */
+        if (IsFlag(Pkg,After) == true)
+        {
+           Hit = true;
+           continue;
+        }
+      

         return true;
         return true;

+      }

       else
       else

+      {
+        if (IsFlag(Pkg,After) == true)
+           Flag(D.ParentPkg(),After);
+        

         return false;
         return false;

+      }      

    }
    }

-   delete [] List;
- 
+
+   // We found a hit, but it had the after flag set
+   if (Hit == true && D->Type == pkgCache::Dep::PreDepends)
+   {
+      Flag(D.ParentPkg(),After);
+      return true;
+   }
+   

    /* Conflicts requires that all versions are not present, depends
       just needs one */
    /* Conflicts requires that all versions are not present, depends
       just needs one */

-   if (D->Type == pkgCache::Dep::Conflicts)
+   if (D->Type == pkgCache::Dep::Conflicts ||
+       D->Type == pkgCache::Dep::Obsoletes)

       return true;
    return false;
 }
       return true;
    return false;
 }