don't try to get acquire lock in simulation mode

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

diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc
index 7c09d3a38fe4b6965feac4fa194aa43fa5e998cb..f38f956e48c7b110c64ee91f229a7f1e0f021186 100644 (file)
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -8,28 +8,41 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

+#include<config.h>
+

 #include <apt-pkg/depcache.h>
 #include <apt-pkg/depcache.h>

-#include <apt-pkg/version.h>

 #include <apt-pkg/versionmatch.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/versionmatch.h>
 #include <apt-pkg/error.h>

-#include <apt-pkg/sptr.h>
-#include <apt-pkg/algorithms.h>
-

 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/aptconfiguration.h>
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/aptconfiguration.h>

-#include <apt-pkg/pkgsystem.h>

 #include <apt-pkg/tagfile.h>
 #include <apt-pkg/tagfile.h>

-
+#include <apt-pkg/progress.h>
+#include <apt-pkg/cacheset.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+#include <apt-pkg/prettyprinters.h>
+#include <apt-pkg/cachefile.h>
+#include <apt-pkg/macros.h>
+
+#include <stdio.h>
+#include <string.h>
+#include <list>
+#include <string>
+#include <utility>
+#include <vector>
+#include <algorithm>

 #include <iostream>
 #include <iostream>

-#include <sstream>    

 #include <set>
 
 #include <sys/stat.h>
 
 #include <set>
 
 #include <sys/stat.h>
 

-#include <apti18n.h>    
+#include <apti18n.h>

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

+
+using std::string;
+

 // helper for Install-Recommends-Sections and Never-MarkAuto-Sections  /*{{{*/
 static bool 
 ConfigValueInSubTree(const char* SubTree, const char *needle)
 // helper for Install-Recommends-Sections and Never-MarkAuto-Sections  /*{{{*/
 static bool 
 ConfigValueInSubTree(const char* SubTree, const char *needle)


@@ -51,7 +64,7 @@ ConfigValueInSubTree(const char* SubTree, const char *needle)
 }
                                                                        /*}}}*/
 pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) :            /*{{{*/
 }
                                                                        /*}}}*/
 pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) :            /*{{{*/

-  cache(cache), released(false)
+  d(NULL), cache(cache), released(false)

 {
   ++cache.group_level;
 }
 {
   ++cache.group_level;
 }


@@ -70,7 +83,7 @@ void pkgDepCache::ActionGroup::release()
            cache.MarkAndSweep();
        }
 
            cache.MarkAndSweep();
        }
 

-      released = false;
+      released = true;

     }
 }
 
     }
 }
 


@@ -82,8 +95,10 @@ pkgDepCache::ActionGroup::~ActionGroup()
 // DepCache::pkgDepCache - Constructors                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // DepCache::pkgDepCache - Constructors                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgDepCache::pkgDepCache(pkgCache *pCache,Policy *Plcy) :
-  group_level(0), Cache(pCache), PkgState(0), DepState(0)
+pkgDepCache::pkgDepCache(pkgCache * const pCache,Policy * const Plcy) :
+  group_level(0), Cache(pCache), PkgState(0), DepState(0),
+   iUsrSize(0), iDownloadSize(0), iInstCount(0), iDelCount(0), iKeepCount(0),
+   iBrokenCount(0), iPolicyBrokenCount(0), iBadCount(0), d(NULL)

 {
    DebugMarker = _config->FindB("Debug::pkgDepCache::Marker", false);
    DebugAutoInstall = _config->FindB("Debug::pkgDepCache::AutoInstall", false);
 {
    DebugMarker = _config->FindB("Debug::pkgDepCache::Marker", false);
    DebugAutoInstall = _config->FindB("Debug::pkgDepCache::AutoInstall", false);


@@ -106,7 +121,7 @@ pkgDepCache::~pkgDepCache()
 // DepCache::Init - Generate the initial extra structures.             /*{{{*/
 // ---------------------------------------------------------------------
 /* This allocats the extension buffers and initializes them. */
 // DepCache::Init - Generate the initial extra structures.             /*{{{*/
 // ---------------------------------------------------------------------
 /* This allocats the extension buffers and initializes them. */

-bool pkgDepCache::Init(OpProgress *Prog)
+bool pkgDepCache::Init(OpProgress * const Prog)

 {
    // Suppress mark updates during this operation (just in case) and
    // run a mark operation when Init terminates.
 {
    // Suppress mark updates during this operation (just in case) and
    // run a mark operation when Init terminates.


@@ -117,7 +132,7 @@ bool pkgDepCache::Init(OpProgress *Prog)
    PkgState = new StateCache[Head().PackageCount];
    DepState = new unsigned char[Head().DependsCount];
    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);
    PkgState = new StateCache[Head().PackageCount];
    DepState = new unsigned char[Head().DependsCount];
    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);

-   memset(DepState,0,sizeof(*DepState)*Head().DependsCount); 
+   memset(DepState,0,sizeof(*DepState)*Head().DependsCount);

 
    if (Prog != 0)
    {
 
    if (Prog != 0)
    {


@@ -125,58 +140,57 @@ bool pkgDepCache::Init(OpProgress *Prog)
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
    }
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
    }

-   
+

    /* Set the current state of everything. In this state all of the
       packages are kept exactly as is. See AllUpgrade */
    int Done = 0;
    /* Set the current state of everything. In this state all of the
       packages are kept exactly as is. See AllUpgrade */
    int Done = 0;

-   for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
+   for (PkgIterator I = PkgBegin(); I.end() != true; ++I, ++Done)

    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);
    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);

-      
+

       // Find the proper cache slot
       StateCache &State = PkgState[I->ID];
       State.iFlags = 0;
 
       // Figure out the install version
       // Find the proper cache slot
       StateCache &State = PkgState[I->ID];
       State.iFlags = 0;
 
       // Figure out the install version

-      State.CandidateVer = GetCandidateVer(I);
+      State.CandidateVer = LocalPolicy->GetCandidateVer(I);

       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;
       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;

-      
+

       State.Update(I,*this);
       State.Update(I,*this);

-   }   
-   
+   }
+

    if (Prog != 0)
    {
    if (Prog != 0)
    {

-      

       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
                            Head().PackageCount,
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
    }
       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
                            Head().PackageCount,
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
    }

-   
+

    Update(Prog);
 
    if(Prog != 0)
       Prog->Done();
 
    return true;
    Update(Prog);
 
    if(Prog != 0)
       Prog->Done();
 
    return true;

-} 
+}

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

-bool pkgDepCache::readStateFile(OpProgress *Prog)                      /*{{{*/
+bool pkgDepCache::readStateFile(OpProgress * const Prog)               /*{{{*/

 {
    FileFd state_file;
    string const state = _config->FindFile("Dir::State::extended_states");
    if(RealFileExists(state)) {
       state_file.Open(state, FileFd::ReadOnly);
 {
    FileFd state_file;
    string const state = _config->FindFile("Dir::State::extended_states");
    if(RealFileExists(state)) {
       state_file.Open(state, FileFd::ReadOnly);

-      int const file_size = state_file.Size();
+      off_t const file_size = state_file.Size();

       if(Prog != NULL)
       if(Prog != NULL)

-        Prog->OverallProgress(0, file_size, 1, 
+        Prog->OverallProgress(0, file_size, 1,

                               _("Reading state information"));
 
       pkgTagFile tagfile(&state_file);
       pkgTagSection section;
                               _("Reading state information"));
 
       pkgTagFile tagfile(&state_file);
       pkgTagSection section;

-      int amt = 0;
+      off_t amt = 0;

       bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
       while(tagfile.Step(section)) {
         string const pkgname = section.FindS("Package");
       bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
       while(tagfile.Step(section)) {
         string const pkgname = section.FindS("Package");


@@ -215,7 +229,7 @@ bool pkgDepCache::readStateFile(OpProgress *Prog)                   /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly) /*{{{*/
+bool pkgDepCache::writeStateFile(OpProgress * const /*prog*/, bool const InstalledOnly)        /*{{{*/

 {
    bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
    
 {
    bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
    


@@ -224,9 +238,11 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)     /*{{{*/
 
    FileFd StateFile;
    string const state = _config->FindFile("Dir::State::extended_states");
 
    FileFd StateFile;
    string const state = _config->FindFile("Dir::State::extended_states");

+   if (CreateAPTDirectoryIfNeeded(_config->FindDir("Dir::State"), flNotFile(state)) == false)
+      return false;

 
    // if it does not exist, create a empty one
 
    // if it does not exist, create a empty one

-   if(!RealFileExists(state)) 
+   if(!RealFileExists(state))

    {
       StateFile.Open(state, FileFd::WriteAtomic);
       StateFile.Close();
    {
       StateFile.Open(state, FileFd::WriteAtomic);
       StateFile.Close();


@@ -237,17 +253,14 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)    /*{{{*/
       return _error->Error(_("Failed to open StateFile %s"),
                           state.c_str());
 
       return _error->Error(_("Failed to open StateFile %s"),
                           state.c_str());
 

-   FILE *OutFile;
-   string const outfile = state + ".tmp";
-   if((OutFile = fopen(outfile.c_str(),"w")) == NULL)
-      return _error->Error(_("Failed to write temporary StateFile %s"),
-                          outfile.c_str());
+   FileFd OutFile(state, FileFd::ReadWrite | FileFd::Atomic);
+   if (OutFile.IsOpen() == false || OutFile.Failed() == true)
+      return _error->Error(_("Failed to write temporary StateFile %s"), state.c_str());

 
    // first merge with the existing sections
    pkgTagFile tagfile(&StateFile);
    pkgTagSection section;
    std::set<string> pkgs_seen;
 
    // first merge with the existing sections
    pkgTagFile tagfile(&StateFile);
    pkgTagSection section;
    std::set<string> pkgs_seen;

-   const char *nullreorderlist[] = {0};

    while(tagfile.Step(section)) {
         string const pkgname = section.FindS("Package");
         string pkgarch = section.FindS("Architecture");
    while(tagfile.Step(section)) {
         string const pkgname = section.FindS("Package");
         string pkgarch = section.FindS("Architecture");


@@ -256,7 +269,7 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)      /*{{{*/
         // Silently ignore unknown packages and packages with no actual
         // version.
         pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);
         // Silently ignore unknown packages and packages with no actual
         // version.
         pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);

-        if(pkg.end() || pkg.VersionList().end()) 
+        if(pkg.end() || pkg.VersionList().end())

            continue;
         StateCache const &P = PkgState[pkg->ID];
         bool newAuto = (P.Flags & Flag::Auto);
            continue;
         StateCache const &P = PkgState[pkg->ID];
         bool newAuto = (P.Flags & Flag::Auto);


@@ -277,22 +290,18 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)    /*{{{*/
         if(_config->FindB("Debug::pkgAutoRemove",false))
            std::clog << "Update existing AutoInstall info: " 
                      << pkg.FullName() << std::endl;
         if(_config->FindB("Debug::pkgAutoRemove",false))
            std::clog << "Update existing AutoInstall info: " 
                      << pkg.FullName() << std::endl;

-        TFRewriteData rewrite[3];
-        rewrite[0].Tag = "Architecture";
-        rewrite[0].Rewrite = pkg.Arch();
-        rewrite[0].NewTag = 0;
-        rewrite[1].Tag = "Auto-Installed";
-        rewrite[1].Rewrite = newAuto ? "1" : "0";
-        rewrite[1].NewTag = 0;
-        rewrite[2].Tag = 0;
-        TFRewrite(OutFile, section, nullreorderlist, rewrite);
-        fprintf(OutFile,"\n");
+
+        std::vector<pkgTagSection::Tag> rewrite;
+        rewrite.push_back(pkgTagSection::Tag::Rewrite("Architecture", pkg.Arch()));
+        rewrite.push_back(pkgTagSection::Tag::Rewrite("Auto-Installed", newAuto ? "1" : "0"));
+        section.Write(OutFile, NULL, rewrite);
+        if (OutFile.Write("\n", 1) == false)
+           return false;

         pkgs_seen.insert(pkg.FullName());
    }
         pkgs_seen.insert(pkg.FullName());
    }

-   
+

    // then write the ones we have not seen yet
    // then write the ones we have not seen yet

-   std::ostringstream ostr;
-   for(pkgCache::PkgIterator pkg=Cache->PkgBegin(); !pkg.end(); pkg++) {
+   for(pkgCache::PkgIterator pkg=Cache->PkgBegin(); !pkg.end(); ++pkg) {

       StateCache const &P = PkgState[pkg->ID];
       if(P.Flags & Flag::Auto) {
         if (pkgs_seen.find(pkg.FullName()) != pkgs_seen.end()) {
       StateCache const &P = PkgState[pkg->ID];
       if(P.Flags & Flag::Auto) {
         if (pkgs_seen.find(pkg.FullName()) != pkgs_seen.end()) {


@@ -310,19 +319,17 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)    /*{{{*/
            continue;
         if(debug_autoremove)
            std::clog << "Writing new AutoInstall: " << pkg.FullName() << std::endl;
            continue;
         if(debug_autoremove)
            std::clog << "Writing new AutoInstall: " << pkg.FullName() << std::endl;

-        ostr.str(string(""));
-        ostr << "Package: " << pkg.Name()
-             << "\nArchitecture: " << pkgarch
-             << "\nAuto-Installed: 1\n\n";
-        fprintf(OutFile,"%s",ostr.str().c_str());
+        std::string stanza = "Package: ";
+        stanza.append(pkg.Name())
+             .append("\nArchitecture: ").append(pkgarch)
+             .append("\nAuto-Installed: 1\n\n");
+        if (OutFile.Write(stanza.c_str(), stanza.length()) == false)
+           return false;

       }
    }
       }
    }

-   fclose(OutFile);
-
-   // move the outfile over the real file and set permissions
-   rename(outfile.c_str(), state.c_str());
+   if (OutFile.Close() == false)
+      return false;

    chmod(state.c_str(), 0644);
    chmod(state.c_str(), 0644);

-

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


@@ -332,136 +339,77 @@ bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)   /*{{{*/
    then walks along the package provides list and checks if each provides 
    will be installed then checks the provides against the dep. Res will be 
    set to the package which was used to satisfy the dep. */
    then walks along the package provides list and checks if each provides 
    will be installed then checks the provides against the dep. Res will be 
    set to the package which was used to satisfy the dep. */

-bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
+bool pkgDepCache::CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Res)

 {
    Res = Dep.TargetPkg();
 
    /* Check simple depends. A depends -should- never self match but 
       we allow it anyhow because dpkg does. Technically it is a packaging
       bug. Conflicts may never self match */
 {
    Res = Dep.TargetPkg();
 
    /* Check simple depends. A depends -should- never self match but 
       we allow it anyhow because dpkg does. Technically it is a packaging
       bug. Conflicts may never self match */

-   if (Dep.TargetPkg() != Dep.ParentPkg() ||
-       (Dep->Type != Dep::Conflicts && Dep->Type != Dep::DpkgBreaks && Dep->Type != Dep::Obsoletes))
+   if (Dep.IsIgnorable(Res) == false)

    {
    {

-      PkgIterator Pkg = Dep.TargetPkg();

       // Check the base package
       // Check the base package

-      if (Type == NowVersion && Pkg->CurrentVer != 0)
-        if (VS().CheckDep(Pkg.CurrentVer().VerStr(),Dep->CompareOp,
-                                Dep.TargetVer()) == true)
+      if (Type == NowVersion)
+      {
+        if (Res->CurrentVer != 0 && Dep.IsSatisfied(Res.CurrentVer()) == true)

            return true;
            return true;

-      
-      if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0)
-        if (VS().CheckDep(PkgState[Pkg->ID].InstVerIter(*this).VerStr(),
-                                Dep->CompareOp,Dep.TargetVer()) == true)
+      }
+      else if (Type == InstallVersion)
+      {
+        if (PkgState[Res->ID].InstallVer != 0 &&
+              Dep.IsSatisfied(PkgState[Res->ID].InstVerIter(*this)) == true)

            return true;
            return true;

-      
-      if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0)
-        if (VS().CheckDep(PkgState[Pkg->ID].CandidateVerIter(*this).VerStr(),
-                                Dep->CompareOp,Dep.TargetVer()) == true)
+      }
+      else if (Type == CandidateVersion)
+        if (PkgState[Res->ID].CandidateVer != 0 &&
+              Dep.IsSatisfied(PkgState[Res->ID].CandidateVerIter(*this)) == true)

            return true;
    }
            return true;
    }

-   
+

    if (Dep->Type == Dep::Obsoletes)
       return false;
    if (Dep->Type == Dep::Obsoletes)
       return false;

-   
+

    // Check the providing packages
    PrvIterator P = Dep.TargetPkg().ProvidesList();
    // Check the providing packages
    PrvIterator P = Dep.TargetPkg().ProvidesList();

-   PkgIterator Pkg = Dep.ParentPkg();
-   for (; P.end() != true; P++)
+   for (; P.end() != true; ++P)

    {
    {

-      /* Provides may never be applied against the same package (or group)
-         if it is a conflicts. See the comment above. */
-      if (P.OwnerPkg()->Group == Pkg->Group &&
-         (Dep->Type == Dep::Conflicts || Dep->Type == Dep::DpkgBreaks))
+      if (Dep.IsIgnorable(P) == true)

         continue;
         continue;

-      
+

       // Check if the provides is a hit
       if (Type == NowVersion)
       {
         if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
            continue;
       }
       // Check if the provides is a hit
       if (Type == NowVersion)
       {
         if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
            continue;
       }

-      
-      if (Type == InstallVersion)
+      else if (Type == InstallVersion)

       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.InstallVer != (Version *)P.OwnerVer())
            continue;
       }
       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.InstallVer != (Version *)P.OwnerVer())
            continue;
       }

-
-      if (Type == CandidateVersion)
+      else if (Type == CandidateVersion)

       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.CandidateVer != (Version *)P.OwnerVer())
            continue;
       }
       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.CandidateVer != (Version *)P.OwnerVer())
            continue;
       }

-      
+

       // Compare the versions.
       // Compare the versions.

-      if (VS().CheckDep(P.ProvideVersion(),Dep->CompareOp,Dep.TargetVer()) == true)
+      if (Dep.IsSatisfied(P) == true)

       {
         Res = P.OwnerPkg();
         return true;
       }
    }
       {
         Res = P.OwnerPkg();
         return true;
       }
    }

-   
+

    return false;
 }
                                                                        /*}}}*/
 // DepCache::AddSizes - Add the packages sizes to the counters         /*{{{*/
 // ---------------------------------------------------------------------
    return false;
 }
                                                                        /*}}}*/
 // DepCache::AddSizes - Add the packages sizes to the counters         /*{{{*/
 // ---------------------------------------------------------------------

-/* Call with Mult = -1 to preform the inverse opration
-   The Mult increases the complexity of the calulations here and is unused -
-   or do we really have a usecase for removing the size of a package two
-   times? So let us replace it with a simple bool and be done with it… */
-__deprecated void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
-{
-   StateCache &P = PkgState[Pkg->ID];
-   
-   if (Pkg->VersionList == 0)
-      return;
-   
-   if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure && 
-       P.Keep() == true)
-      return;
-   
-   // Compute the size data
-   if (P.NewInstall() == true)
-   {
-      iUsrSize += (signed long long)(Mult*P.InstVerIter(*this)->InstalledSize);
-      iDownloadSize += (signed long long)(Mult*P.InstVerIter(*this)->Size);
-      return;
-   }
-   
-   // Upgrading
-   if (Pkg->CurrentVer != 0 && 
-       (P.InstallVer != (Version *)Pkg.CurrentVer() || 
-       (P.iFlags & ReInstall) == ReInstall) && P.InstallVer != 0)
-   {
-      iUsrSize += (signed long long)(Mult*((signed long long)P.InstVerIter(*this)->InstalledSize - 
-                       (signed long long)Pkg.CurrentVer()->InstalledSize));
-      iDownloadSize += (signed long long)(Mult*P.InstVerIter(*this)->Size);
-      return;
-   }
-   
-   // Reinstall
-   if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
-       P.Delete() == false)
-   {
-      iDownloadSize += (signed long long)(Mult*P.InstVerIter(*this)->Size);
-      return;
-   }
-   
-   // Removing
-   if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
-   {
-      iUsrSize -= (signed long long)(Mult*Pkg.CurrentVer()->InstalledSize);
-      return;
-   }   
-}
-                                                                       /*}}}*/
-// DepCache::AddSizes - Add the packages sizes to the counters         /*{{{*/
-// ---------------------------------------------------------------------

 /* Call with Inverse = true to preform the inverse opration */
 /* Call with Inverse = true to preform the inverse opration */

-void pkgDepCache::AddSizes(const PkgIterator &Pkg, bool const &Inverse)
+void pkgDepCache::AddSizes(const PkgIterator &Pkg, bool const Inverse)

 {
    StateCache &P = PkgState[Pkg->ID];
    
 {
    StateCache &P = PkgState[Pkg->ID];
    


@@ -532,50 +480,50 @@ void pkgDepCache::AddSizes(const PkgIterator &Pkg, bool const &Inverse)
    calld Remove/Add itself. Remember, dependencies can be circular so
    while processing a dep for Pkg it is possible that Add/Remove
    will be called on Pkg */
    calld Remove/Add itself. Remember, dependencies can be circular so
    while processing a dep for Pkg it is possible that Add/Remove
    will be called on Pkg */

-void pkgDepCache::AddStates(const PkgIterator &Pkg,int Add)
+void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert)

 {
 {

+   signed char const Add = (Invert == false) ? 1 : -1;

    StateCache &State = PkgState[Pkg->ID];
    StateCache &State = PkgState[Pkg->ID];

-   
+

    // The Package is broken (either minimal dep or policy dep)
    if ((State.DepState & DepInstMin) != DepInstMin)
       iBrokenCount += Add;
    if ((State.DepState & DepInstPolicy) != DepInstPolicy)
       iPolicyBrokenCount += Add;
    // The Package is broken (either minimal dep or policy dep)
    if ((State.DepState & DepInstMin) != DepInstMin)
       iBrokenCount += Add;
    if ((State.DepState & DepInstPolicy) != DepInstPolicy)
       iPolicyBrokenCount += Add;

-   
+

    // Bad state
    if (Pkg.State() != PkgIterator::NeedsNothing)
       iBadCount += Add;
    // Bad state
    if (Pkg.State() != PkgIterator::NeedsNothing)
       iBadCount += Add;

-   
+

    // Not installed
    if (Pkg->CurrentVer == 0)
    {
    // Not installed
    if (Pkg->CurrentVer == 0)
    {

-      if (State.Mode == ModeDelete && 
-         (State.iFlags | Purge) == Purge && Pkg.Purge() == false)
+      if (State.Mode == ModeDelete &&
+         (State.iFlags & Purge) == Purge && Pkg.Purge() == false)

         iDelCount += Add;
         iDelCount += Add;

-      
+

       if (State.Mode == ModeInstall)
         iInstCount += Add;
       return;
    }
       if (State.Mode == ModeInstall)
         iInstCount += Add;
       return;
    }

-   
+

    // Installed, no upgrade
    if (State.Status == 0)
    // Installed, no upgrade
    if (State.Status == 0)

-   {    
+   {

       if (State.Mode == ModeDelete)
         iDelCount += Add;
       else
         if ((State.iFlags & ReInstall) == ReInstall)
            iInstCount += Add;
       if (State.Mode == ModeDelete)
         iDelCount += Add;
       else
         if ((State.iFlags & ReInstall) == ReInstall)
            iInstCount += Add;

-      

       return;
    }
       return;
    }

-   
+

    // Alll 3 are possible
    if (State.Mode == ModeDelete)
    // Alll 3 are possible
    if (State.Mode == ModeDelete)

-      iDelCount += Add;   
-   if (State.Mode == ModeKeep)
+      iDelCount += Add;
+   else if (State.Mode == ModeKeep)

       iKeepCount += Add;
       iKeepCount += Add;

-   if (State.Mode == ModeInstall)
+   else if (State.Mode == ModeInstall)

       iInstCount += Add;
 }
                                                                        /*}}}*/
       iInstCount += Add;
 }
                                                                        /*}}}*/


@@ -586,32 +534,27 @@ void pkgDepCache::AddStates(const PkgIterator &Pkg,int Add)
 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 {
    unsigned char Group = 0;
 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 {
    unsigned char Group = 0;

-   
-   for (DepIterator D = V.DependsList(); D.end() != true; D++)
+   for (DepIterator D = V.DependsList(); D.end() != true; ++D)

    {
       // Build the dependency state.
       unsigned char &State = DepState[D->ID];
 
       /* Invert for Conflicts. We have to do this twice to get the
          right sense for a conflicts group */
    {
       // Build the dependency state.
       unsigned char &State = DepState[D->ID];
 
       /* Invert for Conflicts. We have to do this twice to get the
          right sense for a conflicts group */

-      if (D->Type == Dep::Conflicts ||
-         D->Type == Dep::DpkgBreaks ||
-         D->Type == Dep::Obsoletes)
+      if (D.IsNegative() == true)

         State = ~State;
         State = ~State;

-      
+

       // Add to the group if we are within an or..
       State &= 0x7;
       Group |= State;
       State |= Group << 3;
       if ((D->CompareOp & Dep::Or) != Dep::Or)
         Group = 0;
       // Add to the group if we are within an or..
       State &= 0x7;
       Group |= State;
       State |= Group << 3;
       if ((D->CompareOp & Dep::Or) != Dep::Or)
         Group = 0;

-      
+

       // Invert for Conflicts
       // Invert for Conflicts

-      if (D->Type == Dep::Conflicts ||
-         D->Type == Dep::DpkgBreaks ||
-         D->Type == Dep::Obsoletes)
+      if (D.IsNegative() == true)

         State = ~State;
         State = ~State;

-   }    
+   }

 }
                                                                        /*}}}*/
 // DepCache::VersionState - Perform a pass over a dependency list      /*{{{*/
 }
                                                                        /*}}}*/
 // DepCache::VersionState - Perform a pass over a dependency list      /*{{{*/


@@ -620,34 +563,31 @@ void pkgDepCache::BuildGroupOrs(VerIterator const &V)
    state of the list, filtering it through both a Min check and a Policy
    check. The return result will have SetMin/SetPolicy low if a check
    fails. It uses the DepState cache for it's computations. */
    state of the list, filtering it through both a Min check and a Policy
    check. The return result will have SetMin/SetPolicy low if a check
    fails. It uses the DepState cache for it's computations. */

-unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
-                                      unsigned char SetMin,
-                                      unsigned char SetPolicy)
+unsigned char pkgDepCache::VersionState(DepIterator D, unsigned char const Check,
+                                      unsigned char const SetMin,
+                                      unsigned char const SetPolicy) const

 {
    unsigned char Dep = 0xFF;
 {
    unsigned char Dep = 0xFF;

-   

    while (D.end() != true)
    {
    while (D.end() != true)
    {

-      // Compute a single dependency element (glob or)
-      DepIterator Start = D;
-      unsigned char State = 0;
-      for (bool LastOR = true; D.end() == false && LastOR == true; D++)
-      {
-        State |= DepState[D->ID];
-        LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
-      }
-       
+      // the last or-dependency has the state of all previous or'ed
+      DepIterator Start, End;
+      D.GlobOr(Start, End);
+      // ignore if we are called with Dep{Install,…} or DepG{Install,…}
+      // the later would be more correct, but the first is what we get
+      unsigned char const State = DepState[End->ID] | (DepState[End->ID] >> 3);
+

       // Minimum deps that must be satisfied to have a working package
       if (Start.IsCritical() == true)
       // Minimum deps that must be satisfied to have a working package
       if (Start.IsCritical() == true)

+      {

         if ((State & Check) != Check)
         if ((State & Check) != Check)

-           Dep &= ~SetMin;
-      
+           return Dep &= ~(SetMin | SetPolicy);
+      }

       // Policy deps that must be satisfied to install the package
       // Policy deps that must be satisfied to install the package

-      if (IsImportantDep(Start) == true && 
+      else if (IsImportantDep(Start) == true &&

          (State & Check) != Check)
         Dep &= ~SetPolicy;
    }
          (State & Check) != Check)
         Dep &= ~SetPolicy;
    }

-

    return Dep;
 }
                                                                        /*}}}*/
    return Dep;
 }
                                                                        /*}}}*/


@@ -656,17 +596,17 @@ unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
 /* This is the main dependency computation bit. It computes the 3 main
    results for a dependencys, Now, Install and Candidate. Callers must
    invert the result if dealing with conflicts. */
 /* This is the main dependency computation bit. It computes the 3 main
    results for a dependencys, Now, Install and Candidate. Callers must
    invert the result if dealing with conflicts. */

-unsigned char pkgDepCache::DependencyState(DepIterator &D)
+unsigned char pkgDepCache::DependencyState(DepIterator const &D)

 {
    unsigned char State = 0;
 {
    unsigned char State = 0;

-   
+

    if (CheckDep(D,NowVersion) == true)
       State |= DepNow;
    if (CheckDep(D,InstallVersion) == true)
       State |= DepInstall;
    if (CheckDep(D,CandidateVersion) == true)
       State |= DepCVer;
    if (CheckDep(D,NowVersion) == true)
       State |= DepNow;
    if (CheckDep(D,InstallVersion) == true)
       State |= DepInstall;
    if (CheckDep(D,CandidateVersion) == true)
       State |= DepCVer;

-   
+

    return State;
 }
                                                                        /*}}}*/
    return State;
 }
                                                                        /*}}}*/


@@ -675,7 +615,7 @@ unsigned char pkgDepCache::DependencyState(DepIterator &D)
 /* This determines the combined dependency representation of a package
    for its two states now and install. This is done by using the pre-generated
    dependency information. */
 /* This determines the combined dependency representation of a package
    for its two states now and install. This is done by using the pre-generated
    dependency information. */

-void pkgDepCache::UpdateVerState(PkgIterator Pkg)
+void pkgDepCache::UpdateVerState(PkgIterator const &Pkg)

 {   
    // Empty deps are always true
    StateCache &State = PkgState[Pkg->ID];
 {   
    // Empty deps are always true
    StateCache &State = PkgState[Pkg->ID];


@@ -705,136 +645,32 @@ void pkgDepCache::UpdateVerState(PkgIterator Pkg)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

-// DepCache::RemovePseudoInstalledPkg - MultiArch helper for Update()  /*{{{*/
-// ---------------------------------------------------------------------
-/* We "install" arch all packages for all archs if it is installed. Many
-   of these will be broken. This method will look at these broken Pkg and
-   "remove" it. */
-bool pkgDepCache::RemovePseudoInstalledPkg(PkgIterator &Pkg, std::set<unsigned long> &recheck) {
-   if (unlikely(Pkg->CurrentVer == 0))
-      return false;
-
-   VerIterator V = Pkg.CurrentVer();
-   if (V->MultiArch != Version::All)
-      return false;
-
-   // Never ever kill an "all" package - they have no dependency so they can't be broken
-   if (strcmp(Pkg.Arch(),"all") == 0)
-      return false;
-
-   unsigned char const CurDepState = VersionState(V.DependsList(),DepInstall,DepInstMin,DepInstPolicy);
-   if ((CurDepState & DepInstMin) == DepInstMin) {
-      // okay, the package isn't broken, but is the package also required?
-      // If it has no real dependencies, no installed rdepends and doesn't
-      // provide something of value, we will kill it as not required.
-      // These pseudopackages have otherwise interesting effects if they get
-      // a new dependency in a newer version…
-      for (pkgCache::DepIterator D = V.DependsList();
-          D.end() != true; ++D)
-        if (D.IsCritical() == true && D.ParentPkg()->Group != Pkg->Group)
-           return false;
-      for (DepIterator D = Pkg.RevDependsList(); D.end() != true; ++D)
-      {
-        if (D.IsCritical() == false)
-           continue;
-        PkgIterator const P = D.ParentPkg();
-        if (P->Group == Pkg->Group)
-           continue;
-        if (P->CurrentVer != 0)
-           return false;
-      }
-      for (PrvIterator Prv = V.ProvidesList(); Prv.end() != true; Prv++)
-        for (DepIterator d = Prv.ParentPkg().RevDependsList();
-             d.end() != true; ++d)
-        {
-           PkgIterator const P = d.ParentPkg();
-           if (P->CurrentVer != 0 &&
-               P->Group != Pkg->Group)
-              return false;
-        }
-   }
-
-   // Dependencies for this arch all package are not statisfied
-   // so we installed it only for our convenience: get right of it now.
-   RemoveSizes(Pkg);
-   RemoveStates(Pkg);
-
-   Pkg->CurrentVer = 0;
-   PkgState[Pkg->ID].InstallVer = 0;
-
-   AddStates(Pkg);
-   Update(Pkg);
-   AddSizes(Pkg);
-
-   // After the remove previously satisfied pseudo pkg could be now
-   // no longer satisfied, so we need to recheck the reverse dependencies
-   for (DepIterator d = Pkg.RevDependsList(); d.end() != true; ++d)
-   {
-      PkgIterator const P = d.ParentPkg();
-      if (P->CurrentVer != 0)
-        recheck.insert(P.Index());
-   }
-
-   for (DepIterator d = V.DependsList(); d.end() != true; ++d)
-   {
-      PkgIterator const P = d.TargetPkg();
-      for (PrvIterator Prv = P.ProvidesList(); Prv.end() != true; ++Prv)
-      {
-        PkgIterator const O = Prv.OwnerPkg();
-        if (O->CurrentVer != 0)
-           recheck.insert(O.Index());
-      }
-
-      if (P->CurrentVer != 0)
-        recheck.insert(P.Index());
-   }
-
-   for (PrvIterator Prv = V.ProvidesList(); Prv.end() != true; Prv++)
-   {
-      for (DepIterator d = Prv.ParentPkg().RevDependsList();
-          d.end() != true; ++d)
-      {
-        PkgIterator const P = d.ParentPkg();
-        if (P->CurrentVer == 0)
-           continue;
-
-           recheck.insert(P.Index());
-      }
-   }
-
-
-   return true;
-}
-                                                                       /*}}}*/

 // DepCache::Update - Figure out all the state information             /*{{{*/
 // ---------------------------------------------------------------------
 /* This will figure out the state of all the packages and all the 
    dependencies based on the current policy. */
 // DepCache::Update - Figure out all the state information             /*{{{*/
 // ---------------------------------------------------------------------
 /* This will figure out the state of all the packages and all the 
    dependencies based on the current policy. */

-void pkgDepCache::Update(OpProgress *Prog)
+void pkgDepCache::Update(OpProgress * const Prog)

 {   
    iUsrSize = 0;
    iDownloadSize = 0;
 {   
    iUsrSize = 0;
    iDownloadSize = 0;

-   iDelCount = 0;

    iInstCount = 0;
    iInstCount = 0;

+   iDelCount = 0;

    iKeepCount = 0;
    iBrokenCount = 0;
    iKeepCount = 0;
    iBrokenCount = 0;

+   iPolicyBrokenCount = 0;

    iBadCount = 0;
 
    iBadCount = 0;
 

-   std::set<unsigned long> recheck;
-

    // Perform the depends pass
    int Done = 0;
    // Perform the depends pass
    int Done = 0;

-   bool const checkMultiArch = APT::Configuration::getArchitectures().size() > 1;
-   unsigned long killed = 0;
-   for (PkgIterator I = PkgBegin(); I.end() != true; I++,Done++)
+   for (PkgIterator I = PkgBegin(); I.end() != true; ++I, ++Done)

    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);
    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);

-      for (VerIterator V = I.VersionList(); V.end() != true; V++)
+      for (VerIterator V = I.VersionList(); V.end() != true; ++V)

       {
         unsigned char Group = 0;
 
       {
         unsigned char Group = 0;
 

-        for (DepIterator D = V.DependsList(); D.end() != true; D++)
+        for (DepIterator D = V.DependsList(); D.end() != true; ++D)

         {
            // Build the dependency state.
            unsigned char &State = DepState[D->ID];
         {
            // Build the dependency state.
            unsigned char &State = DepState[D->ID];


@@ -847,9 +683,7 @@ void pkgDepCache::Update(OpProgress *Prog)
               Group = 0;
 
            // Invert for Conflicts
               Group = 0;
 
            // Invert for Conflicts

-           if (D->Type == Dep::Conflicts ||
-               D->Type == Dep::DpkgBreaks ||
-               D->Type == Dep::Obsoletes)
+           if (D.IsNegative() == true)

               State = ~State;
         }
       }
               State = ~State;
         }
       }


@@ -858,69 +692,6 @@ void pkgDepCache::Update(OpProgress *Prog)
       AddSizes(I);
       UpdateVerState(I);
       AddStates(I);
       AddSizes(I);
       UpdateVerState(I);
       AddStates(I);

-
-      if (checkMultiArch != true || I->CurrentVer == 0)
-        continue;
-
-      VerIterator const V = I.CurrentVer();
-      if (V->MultiArch != Version::All)
-        continue;
-
-      recheck.insert(I.Index());
-      --Done; // no progress if we need to recheck the package
-   }
-
-   if (checkMultiArch == true) {
-      /* FIXME: recheck breaks proper progress reporting as we don't know
-               how many packages we need to recheck. To lower the effect
-               a bit we increase with a kill, but we should do something more clever… */
-      while(recheck.empty() == false)
-        for (std::set<unsigned long>::const_iterator p = recheck.begin();
-            p != recheck.end();) {
-           if (Prog != 0 && Done%20 == 0)
-              Prog->Progress(Done);
-           PkgIterator P = PkgIterator(*Cache, Cache->PkgP + *p);
-           if (RemovePseudoInstalledPkg(P, recheck) == true) {
-              ++killed;
-              ++Done;
-           }
-           recheck.erase(p++);
-        }
-
-      /* Okay, we have killed a great amount of pseudopackages -
-        we have killed so many that we have now arch "all" packages
-        without an installed pseudo package, but we NEED an installed
-        pseudo package, so we will search now for a pseudo package
-        we can install without breaking everything. */
-      for (GrpIterator G = Cache->GrpBegin(); G.end() != true; ++G)
-      {
-        PkgIterator P = G.FindPkg("all");
-        if (P.end() == true)
-           continue;
-        if (P->CurrentVer == 0)
-           continue;
-        bool installed = false;
-        for (P = G.FindPkg("any"); P.end() != true; P = G.NextPkg(P))
-        {
-           if (strcmp(P.Arch(), "all") == 0)
-              continue;
-           if (P->CurrentVer == 0)
-              continue;
-           installed = true;
-           break;
-        }
-        if (installed == false)
-           recheck.insert(G.Index());
-      }
-
-      while (recheck.empty() != true)
-      {
-        std::set<unsigned long>::const_iterator g = recheck.begin();
-        unsigned long const G = *g;
-        recheck.erase(g);
-        if (unlikely(ReInstallPseudoForGroup(G, recheck) == false))
-           _error->Warning(_("Internal error, group '%s' has no installable pseudo package"), GrpIterator(*Cache, Cache->GrpP + G).Name());
-      }

    }
 
    if (Prog != 0)
    }
 
    if (Prog != 0)


@@ -929,80 +700,6 @@ void pkgDepCache::Update(OpProgress *Prog)
    readStateFile(Prog);
 }
                                                                        /*}}}*/
    readStateFile(Prog);
 }
                                                                        /*}}}*/

-// DepCache::ReInstallPseudoForGroup - MultiArch helper for Update()   /*{{{*/
-// ---------------------------------------------------------------------
-/* RemovePseudoInstalledPkg() is very successful. It even kills packages
-   to an amount that no pseudo package is left, but we need a pseudo package
-   for upgrading senarios so we need to reinstall one pseudopackage which
-   doesn't break everything. Thankfully we can't have architecture depending
-   negative dependencies so this problem is already eliminated */
-bool pkgDepCache::ReInstallPseudoForGroup(pkgCache::PkgIterator const &P, std::set<unsigned long> &recheck)
-{
-   if (P->CurrentVer != 0)
-      return true;
-   // recursive call for packages which provide this package
-   for (pkgCache::PrvIterator Prv = P.ProvidesList(); Prv.end() != true; ++Prv)
-      ReInstallPseudoForGroup(Prv.OwnerPkg(), recheck);
-   // check if we actually need to look at this group
-   unsigned long const G = P->Group;
-   std::set<unsigned long>::const_iterator Pi = recheck.find(G);
-   if (Pi == recheck.end())
-      return true;
-   recheck.erase(Pi); // remove here, so we can't fall into an endless loop
-   if (unlikely(ReInstallPseudoForGroup(G, recheck) == false))
-   {
-      recheck.insert(G);
-      return false;
-   }
-   return true;
-}
-bool pkgDepCache::ReInstallPseudoForGroup(unsigned long const &G, std::set<unsigned long> &recheck)
-{
-   std::vector<std::string> static const Archs = APT::Configuration::getArchitectures();
-   pkgCache::GrpIterator Grp(*Cache, Cache->GrpP + G);
-   if (unlikely(Grp.end() == true))
-      return false;
-   for (std::vector<std::string>::const_iterator a = Archs.begin();
-        a != Archs.end(); ++a)
-   {
-      pkgCache::PkgIterator P = Grp.FindPkg(*a);
-      if (P.end() == true)
-        continue;
-      pkgCache::VerIterator allV = Grp.FindPkg("all").CurrentVer();
-      for (VerIterator V = P.VersionList(); V.end() != true; ++V)
-      {
-        // search for the same version as the all package
-        if (allV->Hash != V->Hash || strcmp(allV.VerStr(),V.VerStr()) != 0)
-           continue;
-        unsigned char const CurDepState = VersionState(V.DependsList(),DepInstall,DepInstMin,DepInstPolicy);
-        // If it is broken, try to install dependencies first before retry
-        if ((CurDepState & DepInstMin) != DepInstMin)
-        {
-           for (pkgCache::DepIterator D = V.DependsList(); D.end() != true; ++D)
-           {
-              if (D->Type != pkgCache::Dep::PreDepends && D->Type != pkgCache::Dep::Depends)
-                 continue;
-              ReInstallPseudoForGroup(D.TargetPkg(), recheck);
-           }
-           unsigned char const CurDepState = VersionState(V.DependsList(),DepInstall,DepInstMin,DepInstPolicy);
-           // if package ist still broken… try another arch
-           if ((CurDepState & DepInstMin) != DepInstMin)
-              break;
-        }
-        // dependencies satisfied: reinstall the package
-        RemoveSizes(P);
-        RemoveStates(P);
-        P->CurrentVer = V.Index();
-        PkgState[P->ID].InstallVer = V;
-        AddStates(P);
-        Update(P);
-        AddSizes(P);
-        return true;
-      }
-   }
-   return false;
-}
-                                                                       /*}}}*/

 // DepCache::Update - Update the deps list of a package                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This is a helper for update that only does the dep portion of the scan. 
 // DepCache::Update - Update the deps list of a package                        /*{{{*/
 // ---------------------------------------------------------------------
 /* This is a helper for update that only does the dep portion of the scan. 


@@ -1010,15 +707,13 @@ bool pkgDepCache::ReInstallPseudoForGroup(unsigned long const &G, std::set<unsig
 void pkgDepCache::Update(DepIterator D)
 {
    // Update the reverse deps
 void pkgDepCache::Update(DepIterator D)
 {
    // Update the reverse deps

-   for (;D.end() != true; D++)
+   for (;D.end() != true; ++D)

    {      
       unsigned char &State = DepState[D->ID];
       State = DependencyState(D);
     
       // Invert for Conflicts
    {      
       unsigned char &State = DepState[D->ID];
       State = DependencyState(D);
     
       // Invert for Conflicts

-      if (D->Type == Dep::Conflicts ||
-         D->Type == Dep::DpkgBreaks ||
-         D->Type == Dep::Obsoletes)
+      if (D.IsNegative() == true)

         State = ~State;
 
       RemoveStates(D.ParentPkg());
         State = ~State;
 
       RemoveStates(D.ParentPkg());


@@ -1045,63 +740,59 @@ void pkgDepCache::Update(PkgIterator const &Pkg)
    // Update the provides map for the current ver
    if (Pkg->CurrentVer != 0)
       for (PrvIterator P = Pkg.CurrentVer().ProvidesList(); 
    // Update the provides map for the current ver
    if (Pkg->CurrentVer != 0)
       for (PrvIterator P = Pkg.CurrentVer().ProvidesList(); 

-          P.end() != true; P++)
+          P.end() != true; ++P)

         Update(P.ParentPkg().RevDependsList());
 
    // Update the provides map for the candidate ver
    if (PkgState[Pkg->ID].CandidateVer != 0)
       for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();
         Update(P.ParentPkg().RevDependsList());
 
    // Update the provides map for the candidate ver
    if (PkgState[Pkg->ID].CandidateVer != 0)
       for (PrvIterator P = PkgState[Pkg->ID].CandidateVerIter(*this).ProvidesList();

-          P.end() != true; P++)
+          P.end() != true; ++P)

         Update(P.ParentPkg().RevDependsList());
 }
                                                                        /*}}}*/
 // DepCache::MarkKeep - Put the package in the keep state              /*{{{*/
 // ---------------------------------------------------------------------
 /* */
         Update(P.ParentPkg().RevDependsList());
 }
                                                                        /*}}}*/
 // DepCache::MarkKeep - Put the package in the keep state              /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser,
+bool pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser,

                            unsigned long Depth)
 {
                            unsigned long Depth)
 {

-   // Simplifies other routines.
-   if (Pkg.end() == true)
-      return;
+   if (IsModeChangeOk(ModeKeep, Pkg, Depth, FromUser) == false)
+      return false;

 
    /* Reject an attempt to keep a non-source broken installed package, those
       must be upgraded */
    if (Pkg.State() == PkgIterator::NeedsUnpack && 
        Pkg.CurrentVer().Downloadable() == false)
 
    /* Reject an attempt to keep a non-source broken installed package, those
       must be upgraded */
    if (Pkg.State() == PkgIterator::NeedsUnpack && 
        Pkg.CurrentVer().Downloadable() == false)

-      return;
-   
-   /** \todo Can this be moved later in the method? */
-   ActionGroup group(*this);
+      return false;

 
    /* We changed the soft state all the time so the UI is a bit nicer
       to use */
    StateCache &P = PkgState[Pkg->ID];
 
    /* We changed the soft state all the time so the UI is a bit nicer
       to use */
    StateCache &P = PkgState[Pkg->ID];

+
+   // Check that it is not already kept
+   if (P.Mode == ModeKeep)
+      return true;
+

    if (Soft == true)
       P.iFlags |= AutoKept;
    else
       P.iFlags &= ~AutoKept;
    if (Soft == true)
       P.iFlags |= AutoKept;
    else
       P.iFlags &= ~AutoKept;

-   
-   // Check that it is not already kept
-   if (P.Mode == ModeKeep)
-      return;

 
 

-   // We dont even try to keep virtual packages..
-   if (Pkg->VersionList == 0)
-      return;
+   ActionGroup group(*this);
+

 #if 0 // reseting the autoflag here means we lose the 
       // auto-mark information if a user selects a package for removal
       // but changes  his mind then and sets it for keep again
       // - this makes sense as default when all Garbage dependencies
       //   are automatically marked for removal (as aptitude does).
       //   setting a package for keep then makes it no longer autoinstalled
 #if 0 // reseting the autoflag here means we lose the 
       // auto-mark information if a user selects a package for removal
       // but changes  his mind then and sets it for keep again
       // - this makes sense as default when all Garbage dependencies
       //   are automatically marked for removal (as aptitude does).
       //   setting a package for keep then makes it no longer autoinstalled

-      //   for all other use-case this action is rather suprising
+      //   for all other use-case this action is rather surprising

    if(FromUser && !P.Marked)
      P.Flags &= ~Flag::Auto;
 #endif
 
    if (DebugMarker == true)
    if(FromUser && !P.Marked)
      P.Flags &= ~Flag::Auto;
 #endif
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << "MarkKeep " << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkKeep " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;

 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);
 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);


@@ -1113,44 +804,75 @@ void pkgDepCache::MarkKeep(PkgIterator const &Pkg, bool Soft, bool FromUser,
       P.InstallVer = Pkg.CurrentVer();
 
    AddStates(Pkg);
       P.InstallVer = Pkg.CurrentVer();
 
    AddStates(Pkg);

-

    Update(Pkg);
    Update(Pkg);

-

    AddSizes(Pkg);
    AddSizes(Pkg);

+
+   return true;

 }
                                                                        /*}}}*/
 // DepCache::MarkDelete - Put the package in the delete state          /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 }
                                                                        /*}}}*/
 // DepCache::MarkDelete - Put the package in the delete state          /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
+bool pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,

                              unsigned long Depth, bool FromUser)
 {
                              unsigned long Depth, bool FromUser)
 {

-   // Simplifies other routines.
-   if (Pkg.end() == true)
-      return;
+   if (IsModeChangeOk(ModeDelete, Pkg, Depth, FromUser) == false)
+      return false;

 
 

-   ActionGroup group(*this);
+   StateCache &P = PkgState[Pkg->ID];

 
    // Check that it is not already marked for delete
 
    // Check that it is not already marked for delete

-   StateCache &P = PkgState[Pkg->ID];
-   P.iFlags &= ~(AutoKept | Purge);
-   if (rPurge == true)
-      P.iFlags |= Purge;
-   

    if ((P.Mode == ModeDelete || P.InstallVer == 0) && 
        (Pkg.Purge() == true || rPurge == false))
    if ((P.Mode == ModeDelete || P.InstallVer == 0) && 
        (Pkg.Purge() == true || rPurge == false))

-      return;
-   
-   // We dont even try to delete virtual packages..
-   if (Pkg->VersionList == 0)
-      return;
+      return true;

 
 

-   // check if we are allowed to install the package
+   // check if we are allowed to remove the package

    if (IsDeleteOk(Pkg,rPurge,Depth,FromUser) == false)
    if (IsDeleteOk(Pkg,rPurge,Depth,FromUser) == false)

-      return;
+      return false;
+
+   P.iFlags &= ~(AutoKept | Purge);
+   if (rPurge == true)
+      P.iFlags |= Purge;
+
+   ActionGroup group(*this);
+
+   if (FromUser == false)
+   {
+      VerIterator const PV = P.InstVerIter(*this);
+      if (PV.end() == false)
+      {
+        // removed metapackages mark their dependencies as manual to prevent in "desktop depends browser, texteditor"
+        // the removal of browser to suggest the removal of desktop and texteditor.
+        // We ignore the auto-bit here as we can't deal with metapackage cascardes otherwise.
+        // We do not check for or-groups here as we don't know which package takes care of
+        // providing the feature the user likes e.g.:  browser1 | browser2 | browser3
+        // Temporary removals are effected by this as well, which is bad, but unlikely in practice
+        bool const PinNeverMarkAutoSection = (PV->Section != 0 && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", PV.Section()));
+        if (PinNeverMarkAutoSection)
+        {
+           for (DepIterator D = PV.DependsList(); D.end() != true; ++D)
+           {
+              if (D.IsMultiArchImplicit() == true || D.IsNegative() == true || IsImportantDep(D) == false)
+                 continue;
+
+              pkgCacheFile CacheFile(this);
+              APT::VersionList verlist = APT::VersionList::FromDependency(CacheFile, D, APT::CacheSetHelper::INSTALLED);
+              for (auto const &V : verlist)
+              {
+                 PkgIterator const DP = V.ParentPkg();
+                 if(DebugAutoInstall == true)
+                    std::clog << OutputInDepth(Depth) << "Setting " << DP.FullName(false) << " NOT as auto-installed (direct "
+                       << D.DepType() << " of " << Pkg.FullName(false) << " which is in APT::Never-MarkAuto-Sections)" << std::endl;
+
+                 MarkAuto(DP, false);
+              }
+           }
+        }
+      }
+   }

 
    if (DebugMarker == true)
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << (rPurge ? "MarkPurge " : "MarkDelete ") << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;

 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);
 
    RemoveSizes(Pkg);
    RemoveStates(Pkg);


@@ -1165,86 +887,212 @@ void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
    Update(Pkg);
    AddSizes(Pkg);
 
    Update(Pkg);
    AddSizes(Pkg);
 

-   // if we remove the pseudo package, we also need to remove the "real"
-   if (Pkg->CurrentVer != 0 && Pkg.CurrentVer().Pseudo() == true)
-      MarkDelete(Pkg.Group().FindPkg("all"), rPurge, Depth+1, FromUser);
-   else if (rPurge == true && Pkg->CurrentVer == 0 &&
-           Pkg->CurrentState != pkgCache::State::NotInstalled &&
-           strcmp(Pkg.Arch(), "all") != 0)
-   {
-      PkgIterator const allPkg = Pkg.Group().FindPkg("all");
-      if (allPkg.end() == false && allPkg->CurrentVer == 0 &&
-         allPkg->CurrentState != pkgCache::State::NotInstalled)
-        MarkDelete(allPkg, rPurge, Depth+1, FromUser);
-   }
+   return true;

 }
                                                                        /*}}}*/
 // DepCache::IsDeleteOk - check if it is ok to remove this package     /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 // DepCache::IsDeleteOk - check if it is ok to remove this package     /*{{{*/
 // ---------------------------------------------------------------------

-/* The default implementation just honors dpkg hold
-   But an application using this library can override this method
-   to control the MarkDelete behaviour */
+/* The default implementation tries to prevent deletion of install requests.
+   dpkg holds are enforced by the private IsModeChangeOk */

 bool pkgDepCache::IsDeleteOk(PkgIterator const &Pkg,bool rPurge,
                              unsigned long Depth, bool FromUser)
 {
 bool pkgDepCache::IsDeleteOk(PkgIterator const &Pkg,bool rPurge,
                              unsigned long Depth, bool FromUser)
 {

-   if (FromUser == false && Pkg->SelectedState == pkgCache::State::Hold && _config->FindB("APT::Ignore-Hold",false) == false)
-   {
-      if (DebugMarker == true)
-        std::clog << OutputInDepth(Depth) << "Hold prevents MarkDelete of " << Pkg << " FU=" << FromUser << std::endl;
-      return false;
-   }
-   else if (FromUser == false && Pkg->CurrentVer == 0)
+   return IsDeleteOkProtectInstallRequests(Pkg, rPurge, Depth, FromUser);
+}
+bool pkgDepCache::IsDeleteOkProtectInstallRequests(PkgIterator const &Pkg,
+      bool const /*rPurge*/, unsigned long const Depth, bool const FromUser)
+{
+   if (FromUser == false && Pkg->CurrentVer == 0)

    {
       StateCache &P = PkgState[Pkg->ID];
       if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto)
       {
         if (DebugMarker == true)
    {
       StateCache &P = PkgState[Pkg->ID];
       if (P.InstallVer != 0 && P.Status == 2 && (P.Flags & Flag::Auto) != Flag::Auto)
       {
         if (DebugMarker == true)

-           std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << Pkg << std::endl;
+           std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << APT::PrettyPkg(this, Pkg) << std::endl;

         return false;
       }
    }
         return false;
       }
    }

+   return true;
+}
+                                                                       /*}}}*/
+// DepCache::IsModeChangeOk - check if it is ok to change the mode     /*{{{*/
+// ---------------------------------------------------------------------
+/* this is used by all Mark methods on the very first line to check sanity
+   and prevents mode changes for packages on hold for example.
+   If you want to check Mode specific stuff you can use the virtual public
+   Is<Mode>Ok methods instead */
+static char const* PrintMode(char const mode)
+{
+        switch (mode)
+        {
+        case pkgDepCache::ModeInstall: return "Install";
+        case pkgDepCache::ModeKeep: return "Keep";
+        case pkgDepCache::ModeDelete: return "Delete";
+        case pkgDepCache::ModeGarbage: return "Garbage";
+        default: return "UNKNOWN";
+        }
+}
+bool pkgDepCache::IsModeChangeOk(ModeList const mode, PkgIterator const &Pkg,
+                                unsigned long const Depth, bool const FromUser)
+{
+   // we are not trying to hard…
+   if (unlikely(Depth > 100))
+      return false;
+
+   // general sanity
+   if (unlikely(Pkg.end() == true || Pkg->VersionList == 0))
+      return false;
+
+   // the user is always right
+   if (FromUser == true)
+      return true;
+
+   StateCache &P = PkgState[Pkg->ID];
+   // not changing the mode is obviously also fine as we might want to call
+   // e.g. MarkInstall multiple times with different arguments for the same package
+   if (P.Mode == mode)
+      return true;
+
+   // if previous state was set by user only user can reset it
+   if ((P.iFlags & Protected) == Protected)
+   {
+      if (unlikely(DebugMarker == true))
+        std::clog << OutputInDepth(Depth) << "Ignore Mark" << PrintMode(mode)
+                  << " of " << APT::PrettyPkg(this, Pkg) << " as its mode (" << PrintMode(P.Mode)
+                  << ") is protected" << std::endl;
+      return false;
+   }
+   // enforce dpkg holds
+   else if (mode != ModeKeep && Pkg->SelectedState == pkgCache::State::Hold &&
+           _config->FindB("APT::Ignore-Hold",false) == false)
+   {
+      if (unlikely(DebugMarker == true))
+        std::clog << OutputInDepth(Depth) << "Hold prevents Mark" << PrintMode(mode)
+                  << " of " << APT::PrettyPkg(this, Pkg) << std::endl;
+      return false;
+   }
+

    return true;
 }
                                                                        /*}}}*/
 // DepCache::MarkInstall - Put the package in the install state                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
    return true;
 }
                                                                        /*}}}*/
 // DepCache::MarkInstall - Put the package in the install state                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
+struct CompareProviders {
+   pkgCache::PkgIterator const Pkg;
+   explicit CompareProviders(pkgCache::DepIterator const &Dep) : Pkg(Dep.TargetPkg()) {};
+   //bool operator() (APT::VersionList::iterator const &AV, APT::VersionList::iterator const &BV)
+   bool operator() (pkgCache::VerIterator const &AV, pkgCache::VerIterator const &BV)
+   {
+      pkgCache::PkgIterator const A = AV.ParentPkg();
+      pkgCache::PkgIterator const B = BV.ParentPkg();
+      // Prefer MA:same packages if other architectures for it are installed
+      if ((AV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same ||
+         (BV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+      {
+        bool instA = false;
+        if ((AV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+        {
+           pkgCache::GrpIterator Grp = A.Group();
+           for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
+              if (P->CurrentVer != 0)
+              {
+                 instA = true;
+                 break;
+              }
+        }
+        bool instB = false;
+        if ((BV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+        {
+           pkgCache::GrpIterator Grp = B.Group();
+           for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
+           {
+              if (P->CurrentVer != 0)
+              {
+                 instB = true;
+                 break;
+              }
+           }
+        }
+        if (instA != instB)
+           return instA == false;
+      }
+      if ((A->CurrentVer == 0 || B->CurrentVer == 0) && A->CurrentVer != B->CurrentVer)
+        return A->CurrentVer == 0;
+      // Prefer packages in the same group as the target; e.g. foo:i386, foo:amd64
+      if (A->Group != B->Group)
+      {
+        if (A->Group == Pkg->Group && B->Group != Pkg->Group)
+           return false;
+        else if (B->Group == Pkg->Group && A->Group != Pkg->Group)
+           return true;
+      }
+      // we like essentials
+      if ((A->Flags & pkgCache::Flag::Essential) != (B->Flags & pkgCache::Flag::Essential))
+      {
+        if ((A->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
+           return false;
+        else if ((B->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
+           return true;
+      }
+      if ((A->Flags & pkgCache::Flag::Important) != (B->Flags & pkgCache::Flag::Important))
+      {
+        if ((A->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
+           return false;
+        else if ((B->Flags & pkgCache::Flag::Important) == pkgCache::Flag::Important)
+           return true;
+      }
+      // prefer native architecture
+      if (strcmp(A.Arch(), B.Arch()) != 0)
+      {
+        if (strcmp(A.Arch(), A.Cache()->NativeArch()) == 0)
+           return false;
+        else if (strcmp(B.Arch(), B.Cache()->NativeArch()) == 0)
+           return true;
+        std::vector<std::string> archs = APT::Configuration::getArchitectures();
+        for (std::vector<std::string>::const_iterator a = archs.begin(); a != archs.end(); ++a)
+           if (*a == A.Arch())
+              return false;
+           else if (*a == B.Arch())
+              return true;
+      }
+      // higher priority seems like a good idea
+      if (AV->Priority != BV->Priority)
+        return AV->Priority > BV->Priority;
+      // unable to decide…
+      return A->ID < B->ID;
+   }
+};
+bool pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,

                              unsigned long Depth, bool FromUser,
                              bool ForceImportantDeps)
 {
                              unsigned long Depth, bool FromUser,
                              bool ForceImportantDeps)
 {

-   if (Depth > 100)
-      return;
-   
-   // Simplifies other routines.
-   if (Pkg.end() == true)
-      return;
-   
-   ActionGroup group(*this);
+   if (IsModeChangeOk(ModeInstall, Pkg, Depth, FromUser) == false)
+      return false;
+
+   StateCache &P = PkgState[Pkg->ID];
+
+   // See if there is even any possible instalation candidate
+   if (P.CandidateVer == 0)
+      return false;

 
    /* Check that it is not already marked for install and that it can be 
       installed */
 
    /* Check that it is not already marked for install and that it can be 
       installed */

-   StateCache &P = PkgState[Pkg->ID];
-   P.iFlags &= ~AutoKept;

    if ((P.InstPolicyBroken() == false && P.InstBroken() == false) && 
        (P.Mode == ModeInstall ||
        P.CandidateVer == (Version *)Pkg.CurrentVer()))
    {
       if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)
    if ((P.InstPolicyBroken() == false && P.InstBroken() == false) && 
        (P.Mode == ModeInstall ||
        P.CandidateVer == (Version *)Pkg.CurrentVer()))
    {
       if (P.CandidateVer == (Version *)Pkg.CurrentVer() && P.InstallVer == 0)

-        MarkKeep(Pkg, false, FromUser, Depth+1);
-      return;
+        return MarkKeep(Pkg, false, FromUser, Depth+1);
+      return true;

    }
 
    }
 

-   // See if there is even any possible instalation candidate
-   if (P.CandidateVer == 0)
-      return;
-   // We dont even try to install virtual packages..
-   if (Pkg->VersionList == 0)
-      return;
-

    // check if we are allowed to install the package
    if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false)
    // check if we are allowed to install the package
    if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false)

-      return;
+      return false;
+
+   ActionGroup group(*this);
+   P.iFlags &= ~AutoKept;

 
    /* Target the candidate version and remove the autoflag. We reset the
       autoflag below if this was called recursively. Otherwise the user
 
    /* Target the candidate version and remove the autoflag. We reset the
       autoflag below if this was called recursively. Otherwise the user


@@ -1257,9 +1105,10 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
 
    if(FromUser)
      {
 
    if(FromUser)
      {

-       // Set it to manual if it's a new install or cancelling the
-       // removal of a garbage package.
-       if(P.Status == 2 || (!Pkg.CurrentVer().end() && !P.Marked))
+       // Set it to manual if it's a new install or already installed,
+       // but only if its not marked by the autoremover (aptitude depend on this behavior)
+       // or if we do automatic installation (aptitude never does it)
+       if(P.Status == 2 || (Pkg->CurrentVer != 0 && (AutoInst == true || P.Marked == false)))

         P.Flags &= ~Flag::Auto;
      }
    else
         P.Flags &= ~Flag::Auto;
      }
    else


@@ -1275,24 +1124,41 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
    Update(Pkg);
    AddSizes(Pkg);
 
    Update(Pkg);
    AddSizes(Pkg);
 

-   // always trigger the install of the all package for a pseudo package
-   if (P.CandidateVerIter(*Cache).Pseudo() == true)
-      MarkInstall(Pkg.Group().FindPkg("all"), AutoInst, Depth, FromUser, ForceImportantDeps);
-
-   if (AutoInst == false)
-      return;
+   if (AutoInst == false || _config->Find("APT::Solver", "internal") != "internal")
+      return true;

 
    if (DebugMarker == true)
 
    if (DebugMarker == true)

-      std::clog << OutputInDepth(Depth) << "MarkInstall " << Pkg << " FU=" << FromUser << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkInstall " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;

 
 

-   DepIterator Dep = P.InstVerIter(*this).DependsList();
+   bool MoveAutoBitToDependencies = false;
+   VerIterator const PV = P.InstVerIter(*this);
+   if (unlikely(PV.end() == true))
+      return false;
+   else if (PV->Section != 0 && (P.Flags & Flag::Auto) != Flag::Auto)
+   {
+      VerIterator const CurVer = Pkg.CurrentVer();
+      if (CurVer.end() == false && CurVer->Section != 0 && strcmp(CurVer.Section(), PV.Section()) != 0)
+      {
+        bool const CurVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", CurVer.Section());
+        bool const InstVerInMoveSection = ConfigValueInSubTree("APT::Move-Autobit-Sections", PV.Section());
+        MoveAutoBitToDependencies = (CurVerInMoveSection == false && InstVerInMoveSection == true);
+        if (MoveAutoBitToDependencies == true)
+        {
+           if(DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "Setting " << Pkg.FullName(false) << " as auto-installed, moving manual to its dependencies" << std::endl;
+           MarkAuto(Pkg, true);
+        }
+      }
+   }
+
+   DepIterator Dep = PV.DependsList();

    for (; Dep.end() != true;)
    {
       // Grok or groups
       DepIterator Start = Dep;
       bool Result = true;
       unsigned Ors = 0;
    for (; Dep.end() != true;)
    {
       // Grok or groups
       DepIterator Start = Dep;
       bool Result = true;
       unsigned Ors = 0;

-      for (bool LastOR = true; Dep.end() == false && LastOR == true; Dep++,Ors++)
+      for (bool LastOR = true; Dep.end() == false && LastOR == true; ++Dep, ++Ors)

       {
         LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
 
       {
         LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
 


@@ -1305,13 +1171,23 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
         continue;
 
       /* Check if this dep should be consider for install. If it is a user
         continue;
 
       /* Check if this dep should be consider for install. If it is a user

-         defined important dep and we are installed a new package then 
+         defined important dep and we are installed a new package then

         it will be installed. Otherwise we only check for important
         it will be installed. Otherwise we only check for important

-         deps that have changed from the installed version
-      */
+         deps that have changed from the installed version */

       if (IsImportantDep(Start) == false)
         continue;
       if (IsImportantDep(Start) == false)
         continue;

-      
+
+      /* If we are in an or group locate the first or that can
+         succeed. We have already cached this… */
+      for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; --Ors)
+        ++Start;
+
+      /* unsatisfiable dependency: IsInstallOkDependenciesSatisfiableByCandidates
+         would have prevented us to get here if not overridden, so just skip
+        over the problem here as the front-end will know what it is doing */
+      if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer && Start.IsNegative() == false)
+        continue;
+

       /* Check if any ImportantDep() (but not Critical) were added
        * since we installed the package.  Also check for deps that
        * were satisfied in the past: for instance, if a version
       /* Check if any ImportantDep() (but not Critical) were added
        * since we installed the package.  Also check for deps that
        * were satisfied in the past: for instance, if a version


@@ -1319,126 +1195,97 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
        * package should follow that Recommends rather than causing the
        * dependency to be removed. (bug #470115)
        */
        * package should follow that Recommends rather than causing the
        * dependency to be removed. (bug #470115)
        */

-      bool isNewImportantDep = false;
-      bool isPreviouslySatisfiedImportantDep = false;
-      if(!ForceImportantDeps && !Start.IsCritical())
+      if (Pkg->CurrentVer != 0 && ForceImportantDeps == false && Start.IsCritical() == false)

       {
       {

-        bool found=false;
-        VerIterator instVer = Pkg.CurrentVer();
-        if(!instVer.end())
+        bool isNewImportantDep = true;
+        bool isPreviouslySatisfiedImportantDep = false;
+        for (DepIterator D = Pkg.CurrentVer().DependsList(); D.end() != true; ++D)

         {
         {

-          for (DepIterator D = instVer.DependsList(); D.end() != true; D++)
-            {
-              //FIXME: deal better with or-groups(?)
-              if(IsImportantDep(D) && !D.IsCritical() &&
-                 Start.TargetPkg() == D.TargetPkg())
-                {
-                  if(!isPreviouslySatisfiedImportantDep)
-                    {
-                      DepIterator D2 = D;
-                      while((D2->CompareOp & Dep::Or) != 0)
-                        ++D2;
-
-                      isPreviouslySatisfiedImportantDep =
-                        (((*this)[D2] & DepGNow) != 0);
-                    }
-
-                  found=true;
-                }
-            }
-           // this is a new dep if it was not found to be already
-           // a important dep of the installed pacakge
-           isNewImportantDep = !found;
-        }
-      }
-      if(isNewImportantDep)
-        if(DebugAutoInstall == true)
-           std::clog << OutputInDepth(Depth) << "new important dependency: "
-                     << Start.TargetPkg().Name() << std::endl;
-      if(isPreviouslySatisfiedImportantDep)
-       if(DebugAutoInstall == true)
-         std::clog << OutputInDepth(Depth) << "previously satisfied important dependency on "
-                   << Start.TargetPkg().Name() << std::endl;
-
-      // skip important deps if the package is already installed
-      if (Pkg->CurrentVer != 0 && Start.IsCritical() == false 
-         && !isNewImportantDep && !isPreviouslySatisfiedImportantDep
-         && !ForceImportantDeps)
-        continue;
-      
-      /* If we are in an or group locate the first or that can 
-         succeed. We have already cached this.. */
-      for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; Ors--)
-        Start++;
-
-      /* This bit is for processing the possibilty of an install/upgrade
-         fixing the problem */
-      SPtrArray<Version *> List = Start.AllTargets();
-      if (Start->Type != Dep::DpkgBreaks &&
-         (DepState[Start->ID] & DepCVer) == DepCVer)
-      {
-        // Right, find the best version to install..
-        Version **Cur = List;
-        PkgIterator P = Start.TargetPkg();
-        PkgIterator InstPkg(*Cache,0);
-        
-        // See if there are direct matches (at the start of the list)
-        for (; *Cur != 0 && (*Cur)->ParentPkg == P.Index(); Cur++)
-        {
-           PkgIterator Pkg(*Cache,Cache->PkgP + (*Cur)->ParentPkg);
-           if (PkgState[Pkg->ID].CandidateVer != *Cur)
+           //FIXME: Should we handle or-group better here?
+           // We do not check if the package we look for is part of the same or-group
+           // we might find while searching, but could that really be a problem?
+           if (D.IsCritical() == true || IsImportantDep(D) == false ||
+               Start.TargetPkg() != D.TargetPkg())

               continue;
               continue;

-           InstPkg = Pkg;
-           break;
+
+           isNewImportantDep = false;
+
+           while ((D->CompareOp & Dep::Or) != 0)
+              ++D;
+
+           isPreviouslySatisfiedImportantDep = (((*this)[D] & DepGNow) != 0);
+           if (isPreviouslySatisfiedImportantDep == true)
+              break;

         }
 
         }
 

-        // Select the highest priority providing package
-        if (InstPkg.end() == true)
+        if(isNewImportantDep == true)

         {
         {

-           pkgPrioSortList(*Cache,Cur);
-           for (; *Cur != 0; Cur++)
-           {
-              PkgIterator Pkg(*Cache,Cache->PkgP + (*Cur)->ParentPkg);
-              if (PkgState[Pkg->ID].CandidateVer != *Cur)
-                 continue;
-              InstPkg = Pkg;
-              break;
-           }
+           if (DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "new important dependency: "
+                        << Start.TargetPkg().FullName() << std::endl;

         }
         }

-        
-        if (InstPkg.end() == false)
+        else if(isPreviouslySatisfiedImportantDep == true)

         {
         {

+           if (DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "previously satisfied important dependency on "
+                        << Start.TargetPkg().FullName() << std::endl;
+        }
+        else
+        {
+           if (DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "ignore old unsatisfied important dependency on "
+                        << Start.TargetPkg().FullName() << std::endl;
+           continue;
+        }
+      }
+
+      /* This bit is for processing the possibility of an install/upgrade
+         fixing the problem for "positive" dependencies */
+      if (Start.IsNegative() == false && (DepState[Start->ID] & DepCVer) == DepCVer)
+      {
+        pkgCacheFile CacheFile(this);
+        APT::VersionList verlist = APT::VersionList::FromDependency(CacheFile, Start, APT::CacheSetHelper::CANDIDATE);
+        CompareProviders comp(Start);
+
+        do {
+           APT::VersionList::iterator InstVer = std::max_element(verlist.begin(), verlist.end(), comp);
+
+           if (InstVer == verlist.end())
+              break;
+
+           pkgCache::PkgIterator InstPkg = InstVer.ParentPkg();

            if(DebugAutoInstall == true)
               std::clog << OutputInDepth(Depth) << "Installing " << InstPkg.Name()
                         << " as " << Start.DepType() << " of " << Pkg.Name()
                         << std::endl;
            if(DebugAutoInstall == true)
               std::clog << OutputInDepth(Depth) << "Installing " << InstPkg.Name()
                         << " as " << Start.DepType() << " of " << Pkg.Name()
                         << std::endl;

-           // now check if we should consider it a automatic dependency or not
-           if(Pkg.Section() && ConfigValueInSubTree("APT::Never-MarkAuto-Sections", Pkg.Section()))
-           {
+           if (MarkInstall(InstPkg, true, Depth + 1, false, ForceImportantDeps) == false)
+           {
+              verlist.erase(InstVer);
+              continue;
+           }
+
+           // now check if we should consider it a automatic dependency or not
+           if(InstPkg->CurrentVer == 0 && MoveAutoBitToDependencies)
+           {

               if(DebugAutoInstall == true)
               if(DebugAutoInstall == true)

-                 std::clog << OutputInDepth(Depth) << "Setting NOT as auto-installed (direct "
-                            << Start.DepType() << " of pkg in APT::Never-MarkAuto-Sections)" << std::endl;
-              MarkInstall(InstPkg,true,Depth + 1, true);
-           }
-           else 
-           {
-              // mark automatic dependency
-              MarkInstall(InstPkg,true,Depth + 1, false, ForceImportantDeps);
-              // Set the autoflag, after MarkInstall because MarkInstall unsets it
-              if (P->CurrentVer == 0)
-                 PkgState[InstPkg->ID].Flags |= Flag::Auto;
-           }
-        }
+                 std::clog << OutputInDepth(Depth) << "Setting " << InstPkg.FullName(false) << " NOT as auto-installed (direct "
+                    << Start.DepType() << " of " << Pkg.FullName(false) << " which is manual and in APT::Move-Autobit-Sections)" << std::endl;
+              MarkAuto(InstPkg, false);
+           }
+
+
+           break;
+        } while(true);

         continue;
       }
         continue;
       }

-
-      /* For conflicts we just de-install the package and mark as auto,
-         Conflicts may not have or groups.  For dpkg's Breaks we try to
-         upgrade the package. */
-      if (Start->Type == Dep::Conflicts || Start->Type == Dep::Obsoletes ||
-         Start->Type == Dep::DpkgBreaks)
+      /* Negative dependencies have no or-group
+        If the dependency isn't versioned, we try if an upgrade might solve the problem.
+        Otherwise we remove the offender if needed */
+      else if (Start.IsNegative() == true && Start->Type != pkgCache::Dep::Obsoletes)

       {
       {

-        for (Version **I = List; *I != 0; I++)
+        std::unique_ptr<Version *[]> List(Start.AllTargets());
+        pkgCache::PkgIterator TrgPkg = Start.TargetPkg();
+        for (Version **I = List.get(); *I != 0; I++)

         {
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();
         {
            VerIterator Ver(*this,*I);
            PkgIterator Pkg = Ver.ParentPkg();


@@ -1448,31 +1295,146 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
            if (PkgState[Pkg->ID].InstallVer == 0)
               continue;
 
            if (PkgState[Pkg->ID].InstallVer == 0)
               continue;
 

-           if (PkgState[Pkg->ID].CandidateVer != *I &&
-               Start->Type == Dep::DpkgBreaks)
-              MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps);
-           else
-              MarkDelete(Pkg,false,Depth + 1, false);
+            /* Ignore negative dependencies that we are not going to 
+               get installed */
+            if (PkgState[Pkg->ID].InstallVer != *I)
+               continue;
+
+           if ((Start->Version != 0 || TrgPkg != Pkg) &&
+               PkgState[Pkg->ID].CandidateVer != PkgState[Pkg->ID].InstallVer &&
+               PkgState[Pkg->ID].CandidateVer != *I &&
+               MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps) == true)
+              continue;
+           else if (Start->Type == pkgCache::Dep::Conflicts || 
+                     Start->Type == pkgCache::Dep::DpkgBreaks) 
+            {
+               if(DebugAutoInstall == true)
+                  std::clog << OutputInDepth(Depth) 
+                            << " Removing: " << Pkg.Name()
+                            << std::endl;
+               if (MarkDelete(Pkg,false,Depth + 1, false) == false)
+                  break;
+            }

         }
         continue;
         }
         continue;

-      }      
+      }

    }
    }

+
+   return Dep.end() == true;

 }
                                                                        /*}}}*/
 // DepCache::IsInstallOk - check if it is ok to install this package   /*{{{*/
 // ---------------------------------------------------------------------
 }
                                                                        /*}}}*/
 // DepCache::IsInstallOk - check if it is ok to install this package   /*{{{*/
 // ---------------------------------------------------------------------

-/* The default implementation just honors dpkg hold
-   But an application using this library can override this method
-   to control the MarkInstall behaviour */
+/* The default implementation checks if the installation of an M-A:same
+   package would lead us into a version-screw and if so forbids it.
+   dpkg holds are enforced by the private IsModeChangeOk */

 bool pkgDepCache::IsInstallOk(PkgIterator const &Pkg,bool AutoInst,
                              unsigned long Depth, bool FromUser)
 {
 bool pkgDepCache::IsInstallOk(PkgIterator const &Pkg,bool AutoInst,
                              unsigned long Depth, bool FromUser)
 {

-   if (FromUser == false && Pkg->SelectedState == pkgCache::State::Hold && _config->FindB("APT::Ignore-Hold",false) == false)
+   return IsInstallOkMultiArchSameVersionSynced(Pkg,AutoInst, Depth, FromUser) &&
+      IsInstallOkDependenciesSatisfiableByCandidates(Pkg,AutoInst, Depth, FromUser);
+}
+bool pkgDepCache::IsInstallOkMultiArchSameVersionSynced(PkgIterator const &Pkg,
+      bool const /*AutoInst*/, unsigned long const Depth, bool const FromUser)
+{
+   if (FromUser == true) // as always: user is always right
+      return true;
+
+   // if we have checked before and it was okay, it will still be okay
+   if (PkgState[Pkg->ID].Mode == ModeInstall &&
+        PkgState[Pkg->ID].InstallVer == PkgState[Pkg->ID].CandidateVer)
+      return true;
+
+   // ignore packages with none-M-A:same candidates
+   VerIterator const CandVer = PkgState[Pkg->ID].CandidateVerIter(*this);
+   if (unlikely(CandVer.end() == true) || CandVer == Pkg.CurrentVer() ||
+        (CandVer->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same)
+      return true;
+
+   GrpIterator const Grp = Pkg.Group();
+   for (PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))

    {
    {

-      if (DebugMarker == true)
-        std::clog << OutputInDepth(Depth) << "Hold prevents MarkInstall of " << Pkg << " FU=" << FromUser << std::endl;
+      // not installed or self-check: fine by definition
+      if (P->CurrentVer == 0 || P == Pkg)
+        continue;
+
+      // not having a candidate or being in sync
+      // (simple string-compare as stuff like '1' == '0:1-0' can't happen here)
+      VerIterator CV = PkgState[P->ID].CandidateVerIter(*this);
+      if (CV.end() == true || strcmp(CandVer.VerStr(), CV.VerStr()) == 0)
+        continue;
+
+      // packages losing M-A:same can be out-of-sync
+      if ((CV->MultiArch & pkgCache::Version::Same) != pkgCache::Version::Same)
+        continue;
+
+      // not downloadable means the package is obsolete, so allow out-of-sync
+      if (CV.Downloadable() == false)
+        continue;
+
+      PkgState[Pkg->ID].iFlags |= AutoKept;
+      if (unlikely(DebugMarker == true))
+        std::clog << OutputInDepth(Depth) << "Ignore MarkInstall of " << APT::PrettyPkg(this, Pkg)
+           << " as it is not in sync with its M-A:same sibling " << APT::PrettyPkg(this, P)
+           << " (" << CandVer.VerStr() << " != " << CV.VerStr() << ")" << std::endl;

       return false;
    }
       return false;
    }

+
+   return true;
+}
+bool pkgDepCache::IsInstallOkDependenciesSatisfiableByCandidates(PkgIterator const &Pkg,
+      bool const AutoInst, unsigned long const Depth, bool const /*FromUser*/)
+{
+   if (AutoInst == false)
+      return true;
+
+   VerIterator const CandVer = PkgState[Pkg->ID].CandidateVerIter(*this);
+   if (unlikely(CandVer.end() == true) || CandVer == Pkg.CurrentVer())
+      return true;
+
+   for (DepIterator Dep = CandVer.DependsList(); Dep.end() != true;)
+   {
+      // Grok or groups
+      DepIterator Start = Dep;
+      bool Result = true;
+      unsigned Ors = 0;
+      for (bool LastOR = true; Dep.end() == false && LastOR == true; ++Dep, ++Ors)
+      {
+        LastOR = (Dep->CompareOp & Dep::Or) == Dep::Or;
+
+        if ((DepState[Dep->ID] & DepInstall) == DepInstall)
+           Result = false;
+      }
+
+      if (Start.IsCritical() == false || Start.IsNegative() == true || Result == false)
+        continue;
+
+      /* If we are in an or group locate the first or that can succeed.
+         We have already cached this… */
+      for (; Ors > 1 && (DepState[Start->ID] & DepCVer) != DepCVer; --Ors)
+        ++Start;
+
+      if (Ors == 1 && (DepState[Start->ID] &DepCVer) != DepCVer)
+      {
+        if (DebugAutoInstall == true)
+           std::clog << OutputInDepth(Depth) << APT::PrettyDep(this, Start) << " can't be satisfied!" << std::endl;
+
+        // the dependency is critical, but can't be installed, so discard the candidate
+        // as the problemresolver will trip over it otherwise trying to install it (#735967)
+        if (Pkg->CurrentVer != 0 && (PkgState[Pkg->ID].iFlags & Protected) != Protected)
+         {
+           SetCandidateVersion(Pkg.CurrentVer());
+            StateCache &State = PkgState[Pkg->ID];
+           if (State.Mode != ModeDelete)
+           {
+              State.Mode = ModeKeep;
+              State.Update(Pkg, *this);
+           }
+         }
+        return false;
+      }
+   }
+

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


@@ -1484,32 +1446,48 @@ void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
    if (unlikely(Pkg.end() == true))
       return;
 
    if (unlikely(Pkg.end() == true))
       return;
 

+   APT::PackageList pkglist;
+   if (Pkg->CurrentVer != 0 &&
+       (Pkg.CurrentVer()-> MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
+   {
+      pkgCache::GrpIterator Grp = Pkg.Group();
+      for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
+      {
+        if (P->CurrentVer != 0)
+           pkglist.insert(P);
+      }
+   }
+   else
+      pkglist.insert(Pkg);
+

    ActionGroup group(*this);
 
    ActionGroup group(*this);
 

-   RemoveSizes(Pkg);
-   RemoveStates(Pkg);
-   
-   StateCache &P = PkgState[Pkg->ID];
-   if (To == true)
-      P.iFlags |= ReInstall;
-   else
-      P.iFlags &= ~ReInstall;
-   
-   AddStates(Pkg);
-   AddSizes(Pkg);
+   for (APT::PackageList::const_iterator Pkg = pkglist.begin(); Pkg != pkglist.end(); ++Pkg)
+   {
+      RemoveSizes(Pkg);
+      RemoveStates(Pkg);

 
 

-   if (unlikely(Pkg.CurrentVer().end() == true) || Pkg.CurrentVer().Pseudo() == false)
-      return;
+      StateCache &P = PkgState[Pkg->ID];
+      if (To == true)
+        P.iFlags |= ReInstall;
+      else
+        P.iFlags &= ~ReInstall;

 
 

-   SetReInstall(Pkg.Group().FindPkg("all"), To);
+      AddStates(Pkg);
+      AddSizes(Pkg);
+   }
+}
+                                                                       /*}}}*/
+pkgCache::VerIterator pkgDepCache::GetCandidateVersion(PkgIterator const &Pkg)/*{{{*/
+{
+   return PkgState[Pkg->ID].CandidateVerIter(*this);

 }
                                                                        /*}}}*/
 // DepCache::SetCandidateVersion - Change the candidate version                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 }
                                                                        /*}}}*/
 // DepCache::SetCandidateVersion - Change the candidate version                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-void pkgDepCache::SetCandidateVersion(VerIterator TargetVer, bool const &Pseudo)
+void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)

 {
 {

-

    pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
    StateCache &P = PkgState[Pkg->ID];
 
    pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
    StateCache &P = PkgState[Pkg->ID];
 


@@ -1530,27 +1508,6 @@ void pkgDepCache::SetCandidateVersion(VerIterator TargetVer, bool const &Pseudo)
    Update(Pkg);
    AddSizes(Pkg);
 
    Update(Pkg);
    AddSizes(Pkg);
 

-   if (TargetVer.Pseudo() == false || Pseudo == false)
-      return;
-
-   // the version was pseudo: set all other pseudos also
-   pkgCache::GrpIterator Grp = Pkg.Group();
-   for (Pkg = Grp.FindPkg("any"); Pkg.end() == false; ++Pkg)
-   {
-      StateCache &P = PkgState[Pkg->ID];
-      if (TargetVer.SimilarVer(P.CandidateVerIter(*this)) == true ||
-         (P.CandidateVerIter(*this).Pseudo() == false &&
-          strcmp(Pkg.Arch(), "all") != 0))
-        continue;
-
-      for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
-      {
-        if (TargetVer.SimilarVer(Ver) == false)
-           continue;
-        SetCandidateVersion(Ver, false);
-        break;
-      }
-   }

 }
                                                                        /*}}}*/
 // DepCache::SetCandidateRelease - Change the candidate version                /*{{{*/
 }
                                                                        /*}}}*/
 // DepCache::SetCandidateRelease - Change the candidate version                /*{{{*/


@@ -1625,7 +1582,7 @@ bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
         if (Cand.end() == true)
            continue;
         // check if the current candidate is enough for the versioned dependency - and installable?
         if (Cand.end() == true)
            continue;
         // check if the current candidate is enough for the versioned dependency - and installable?

-        if (VS().CheckDep(P.CandVersion(), Start->CompareOp, Start.TargetVer()) == true &&
+        if (Start.IsSatisfied(Cand) == true &&

             (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) == DepCandMin)
         {
            itsFine = true;
             (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) == DepCandMin)
         {
            itsFine = true;


@@ -1659,7 +1616,7 @@ bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
            V = Match.Find(D.TargetPkg());
 
         // check if the version from this release could satisfy the dependency
            V = Match.Find(D.TargetPkg());
 
         // check if the version from this release could satisfy the dependency

-        if (V.end() == true || VS().CheckDep(V.VerStr(), D->CompareOp, D.TargetVer()) == false)
+        if (V.end() == true || D.IsSatisfied(V) == false)

         {
            if (stillOr == true)
               continue;
         {
            if (stillOr == true)
               continue;


@@ -1683,7 +1640,7 @@ bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
         if (itsFine == false)
         {
            // change the candidate
         if (itsFine == false)
         {
            // change the candidate

-           Changed.push_back(make_pair(oldCand, TargetVer));
+           Changed.push_back(make_pair(V, TargetVer));

            if (SetCandidateRelease(V, TargetRel, Changed) == false)
            {
               if (stillOr == false)
            if (SetCandidateRelease(V, TargetRel, Changed) == false)
            {
               if (stillOr == false)


@@ -1747,11 +1704,7 @@ void pkgDepCache::StateCache::Update(PkgIterator Pkg,pkgCache &Cache)
    CurVersion = "";
    if (Pkg->CurrentVer != 0)
       CurVersion = Pkg.CurrentVer().VerStr();
    CurVersion = "";
    if (Pkg->CurrentVer != 0)
       CurVersion = Pkg.CurrentVer().VerStr();

-   
-   // Strip off the epochs for display
-   CurVersion = StripEpoch(CurVersion);
-   CandVersion = StripEpoch(CandVersion);
-   
+

    // Figure out if its up or down or equal
    Status = Ver.CompareVer(Pkg.CurrentVer());
    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)
    // Figure out if its up or down or equal
    Status = Ver.CompareVer(Pkg.CurrentVer());
    if (Pkg->CurrentVer == 0 || Pkg->VersionList == 0 || CandidateVer == 0)


@@ -1767,10 +1720,10 @@ const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
       return 0;
 
    // Strip any epoch
       return 0;
 
    // Strip any epoch

-   for (const char *I = Ver; *I != 0; I++)
-      if (*I == ':')
-        return I + 1;
-   return Ver;
+   char const * const I = strchr(Ver, ':');
+   if (I == nullptr)
+      return Ver;
+   return I + 1;

 }
                                                                        /*}}}*/
 // Policy::GetCandidateVer - Returns the Candidate install version     /*{{{*/
 }
                                                                        /*}}}*/
 // Policy::GetCandidateVer - Returns the Candidate install version     /*{{{*/


@@ -1781,22 +1734,22 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk
 {
    /* Not source/not automatic versions cannot be a candidate version 
       unless they are already installed */
 {
    /* Not source/not automatic versions cannot be a candidate version 
       unless they are already installed */

-   VerIterator Last(*(pkgCache *)this,0);
+   VerIterator Last;

    
    

-   for (VerIterator I = Pkg.VersionList(); I.end() == false; I++)
+   for (VerIterator I = Pkg.VersionList(); I.end() == false; ++I)

    {
       if (Pkg.CurrentVer() == I)
         return I;
       
    {
       if (Pkg.CurrentVer() == I)
         return I;
       

-      for (VerFileIterator J = I.FileList(); J.end() == false; J++)
+      for (VerFileIterator J = I.FileList(); J.end() == false; ++J)

       {
       {

-        if ((J.File()->Flags & Flag::NotSource) != 0)
+        if (J.File().Flagged(Flag::NotSource))

            continue;
 
         /* Stash the highest version of a not-automatic source, we use it
            if there is nothing better */
            continue;
 
         /* Stash the highest version of a not-automatic source, we use it
            if there is nothing better */

-        if ((J.File()->Flags & Flag::NotAutomatic) != 0 ||
-            (J.File()->Flags & Flag::ButAutomaticUpgrades) != 0)
+        if (J.File().Flagged(Flag::NotAutomatic) ||
+            J.File().Flagged(Flag::ButAutomaticUpgrades))

         {
            if (Last.end() == true)
               Last = I;
         {
            if (Last.end() == true)
               Last = I;


@@ -1813,28 +1766,36 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep)
+bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) const

 {
    if(Dep.IsCritical())
       return true;
 {
    if(Dep.IsCritical())
       return true;

-   else if(Dep->Type == pkgCache::Dep::Recommends) 
+   else if(Dep->Type == pkgCache::Dep::Recommends)

    {
    {

-      if ( _config->FindB("APT::Install-Recommends", false))
+      if (InstallRecommends)

         return true;
       // we suport a special mode to only install-recommends for certain
       // sections
         return true;
       // we suport a special mode to only install-recommends for certain
       // sections

-      // FIXME: this is a meant as a temporarly solution until the 
+      // FIXME: this is a meant as a temporarly solution until the

       //        recommends are cleaned up
       const char *sec = Dep.ParentVer().Section();
       if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec))
         return true;
    }
    else if(Dep->Type == pkgCache::Dep::Suggests)
       //        recommends are cleaned up
       const char *sec = Dep.ParentVer().Section();
       if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec))
         return true;
    }
    else if(Dep->Type == pkgCache::Dep::Suggests)

-     return _config->FindB("APT::Install-Suggests", false);
+      return InstallSuggests;

 
    return false;
 }
                                                                        /*}}}*/
 
    return false;
 }
                                                                        /*}}}*/

+// Policy::GetPriority - Get the priority of the package pin           /*{{{*/
+APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgIterator const &/*Pkg*/)
+{ return 0; }
+APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::VerIterator const &/*Ver*/, bool /*ConsiderFiles*/)
+{ return 0; }
+APT_CONST signed short pkgDepCache::Policy::GetPriority(pkgCache::PkgFileIterator const &/*File*/)
+{ return 0; }
+                                                                       /*}}}*/

 pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc()              /*{{{*/
 {
   DefaultRootSetFunc *f = new DefaultRootSetFunc;
 pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc()              /*{{{*/
 {
   DefaultRootSetFunc *f = new DefaultRootSetFunc;


@@ -1854,43 +1815,45 @@ bool pkgDepCache::MarkFollowsRecommends()
 
 bool pkgDepCache::MarkFollowsSuggests()
 {
 
 bool pkgDepCache::MarkFollowsSuggests()
 {

-  return _config->FindB("APT::AutoRemove::SuggestsImportant", false);
+  return _config->FindB("APT::AutoRemove::SuggestsImportant", true);

 }
 
 // pkgDepCache::MarkRequired - the main mark algorithm                 /*{{{*/
 bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
 {
 }
 
 // pkgDepCache::MarkRequired - the main mark algorithm                 /*{{{*/
 bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
 {

-   bool follow_recommends;
-   bool follow_suggests;
-   bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
+   if (_config->Find("APT::Solver", "internal") != "internal")
+      return true;
+
+   bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);

 
    // init the states
 
    // init the states

-   for(PkgIterator p = PkgBegin(); !p.end(); ++p)
+   map_id_t const PackagesCount = Head().PackageCount;
+   for(map_id_t i = 0; i < PackagesCount; ++i)

    {
    {

-      PkgState[p->ID].Marked  = false;
-      PkgState[p->ID].Garbage = false;
-
-      // debug output
-      if(debug_autoremove && PkgState[p->ID].Flags & Flag::Auto)
-        std::clog << "AutoDep: " << p.FullName() << std::endl;
+      PkgState[i].Marked  = false;
+      PkgState[i].Garbage = false;

    }
    }

+   if (debug_autoremove)
+      for(PkgIterator p = PkgBegin(); !p.end(); ++p)
+        if(PkgState[p->ID].Flags & Flag::Auto)
+           std::clog << "AutoDep: " << p.FullName() << std::endl;

 
 

-   // init vars
-   follow_recommends = MarkFollowsRecommends();
-   follow_suggests   = MarkFollowsSuggests();
-
-
+   bool const follow_recommends = MarkFollowsRecommends();
+   bool const follow_suggests   = MarkFollowsSuggests();

 
    // do the mark part, this is the core bit of the algorithm
    for(PkgIterator p = PkgBegin(); !p.end(); ++p)
    {
       if(!(PkgState[p->ID].Flags & Flag::Auto) ||
          (p->Flags & Flag::Essential) ||
 
    // do the mark part, this is the core bit of the algorithm
    for(PkgIterator p = PkgBegin(); !p.end(); ++p)
    {
       if(!(PkgState[p->ID].Flags & Flag::Auto) ||
          (p->Flags & Flag::Essential) ||

+         (p->Flags & Flag::Important) ||

          userFunc.InRootSet(p) ||
          // be nice even then a required package violates the policy (#583517)
          // and do the full mark process also for required packages
          (p.CurrentVer().end() != true &&
          userFunc.InRootSet(p) ||
          // be nice even then a required package violates the policy (#583517)
          // and do the full mark process also for required packages
          (p.CurrentVer().end() != true &&

-          p.CurrentVer()->Priority == pkgCache::State::Required))
+          p.CurrentVer()->Priority == pkgCache::State::Required) ||
+         // packages which can't be changed (like holds) can't be garbage
+         (IsModeChangeOk(ModeGarbage, p, 0, false) == false))

       {
         // the package is installed (and set to keep)
         if(PkgState[p->ID].Keep() && !p.CurrentVer().end())
       {
         // the package is installed (and set to keep)
         if(PkgState[p->ID].Keep() && !p.CurrentVer().end())


@@ -1966,28 +1929,6 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
    if(ver.end() == true)
       return;
 
    if(ver.end() == true)
       return;
 

-   // If the version belongs to a Multi-Arch all package
-   // we will mark all others in this Group with this version also
-   if (ver->MultiArch == pkgCache::Version::All &&
-       strcmp(ver.Arch(true), "all") == 0)
-   {
-      GrpIterator G = pkg.Group();
-      const char* const VerStr = ver.VerStr();
-      for (PkgIterator P = G.FindPkg("any");
-          P.end() != true; P = G.NextPkg(P))
-      {
-        for (VerIterator V = P.VersionList();
-             V.end() != true; ++V)
-        {
-           if (ver->Hash != V->Hash ||
-               strcmp(VerStr, V.VerStr()) != 0)
-              continue;
-           MarkPackage(P, V, follow_recommends, follow_suggests);
-           break;
-        }
-      }
-   }
-

      for(DepIterator d = ver.DependsList(); !d.end(); ++d)
      {
        if(d->Type == Dep::Depends ||
      for(DepIterator d = ver.DependsList(); !d.end(); ++d)
      {
        if(d->Type == Dep::Depends ||


@@ -2001,7 +1942,7 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
           for(VerIterator V = d.TargetPkg().VersionList(); 
               !V.end(); ++V)
           {
           for(VerIterator V = d.TargetPkg().VersionList(); 
               !V.end(); ++V)
           {

-             if(_system->VS->CheckDep(V.VerStr(), d->CompareOp, d.TargetVer()))
+             if(d.IsSatisfied(V))

              {
                if(debug_autoremove)
                  {
              {
                if(debug_autoremove)
                  {


@@ -2023,8 +1964,7 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
           for(PrvIterator prv=d.TargetPkg().ProvidesList(); 
               !prv.end(); ++prv)
           {
           for(PrvIterator prv=d.TargetPkg().ProvidesList(); 
               !prv.end(); ++prv)
           {

-             if(_system->VS->CheckDep(prv.ProvideVersion(), d->CompareOp, 
-                                      d.TargetVer()))
+             if(d.IsSatisfied(prv))

              {
                if(debug_autoremove)
                  {
              {
                if(debug_autoremove)
                  {


@@ -2076,3 +2016,17 @@ bool pkgDepCache::Sweep()                                                /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// DepCache::MarkAndSweep                                              /*{{{*/
+bool pkgDepCache::MarkAndSweep(InRootSetFunc &rootFunc)
+{
+   return MarkRequired(rootFunc) && Sweep();
+}
+bool pkgDepCache::MarkAndSweep()
+{
+   std::unique_ptr<InRootSetFunc> f(GetRootSetFunc());
+   if(f.get() != NULL)
+      return MarkAndSweep(*f.get());
+   else
+      return false;
+}
+                                                                       /*}}}*/