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 9f734cca29775ee821cbe82099890cb72da2b51b..f38f956e48c7b110c64ee91f229a7f1e0f021186 100644 (file)
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -8,27 +8,42 @@
     ##################################################################### */
                                                                         /*}}}*/
  // 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/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/fileutl.h>
  #include <apt-pkg/strutl.h>
  #include <apt-pkg/configuration.h>
-#include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/aptconfiguration.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
+// helper for Install-Recommends-Sections and Never-MarkAuto-Sections  /*{{{*/
  static bool 
  ConfigValueInSubTree(const char* SubTree, const char *needle)
  {
  static bool 
  ConfigValueInSubTree(const char* SubTree, const char *needle)
  {
@@ -47,9 +62,9 @@ ConfigValueInSubTree(const char* SubTree, const char *needle)
     }
     return false;
  }
     }
     return false;
  }
-
-pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) :
-  cache(cache), released(false)
+                                                                       /*}}}*/
+pkgDepCache::ActionGroup::ActionGroup(pkgDepCache &cache) :            /*{{{*/
+  d(NULL), cache(cache), released(false)
  {
    ++cache.group_level;
  }
  {
    ++cache.group_level;
  }
@@ -68,7 +83,7 @@ void pkgDepCache::ActionGroup::release()
             cache.MarkAndSweep();
         }
  
             cache.MarkAndSweep();
         }
  
-      released = false;
+      released = true;
      }
  }
  
      }
  }
  
@@ -76,12 +91,14 @@ pkgDepCache::ActionGroup::~ActionGroup()
  {
    release();
  }
  {
    release();
  }
-
+                                                                       /*}}}*/
  // 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);
@@ -104,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.
@@ -115,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)
     {
@@ -123,96 +140,111 @@ 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)
+      if (Prog != 0 && Done%20 == 0)
          Prog->Progress(Done);
          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;
  {
     FileFd state_file;
-   string state = _config->FindDir("Dir::State") + "extended_states";
-   if(FileExists(state)) {
+   string const state = _config->FindFile("Dir::State::extended_states");
+   if(RealFileExists(state)) {
        state_file.Open(state, FileFd::ReadOnly);
        state_file.Open(state, FileFd::ReadOnly);
-      int 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)) {
        while(tagfile.Step(section)) {
-        string pkgname = section.FindS("Package");
-        pkgCache::PkgIterator pkg=Cache->FindPkg(pkgname);
-        // Silently ignore unknown packages and packages with no actual
-        // version.
-        if(!pkg.end() && !pkg.VersionList().end()) {
-           short reason = section.FindI("Auto-Installed", 0);
-           if(reason > 0)
-              PkgState[pkg->ID].Flags  |= Flag::Auto;
-           if(_config->FindB("Debug::pkgAutoRemove",false))
-              std::cout << "Auto-Installed : " << pkgname << std::endl;
-           amt+=section.size();
-           if(Prog != NULL)
-              Prog->OverallProgress(amt, file_size, 1, 
-                                    _("Reading state information"));
+        string const pkgname = section.FindS("Package");
+        string pkgarch = section.FindS("Architecture");
+        if (pkgarch.empty() == true)
+           pkgarch = "any";
+        pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);
+        // Silently ignore unknown packages and packages with no actual version.
+        if(pkg.end() == true || pkg->VersionList == 0)
+           continue;
+
+        short const reason = section.FindI("Auto-Installed", 0);
+        if(reason > 0)
+        {
+           PkgState[pkg->ID].Flags |= Flag::Auto;
+           if (unlikely(debug_autoremove))
+              std::clog << "Auto-Installed : " << pkg.FullName() << std::endl;
+           if (pkgarch == "any")
+           {
+              pkgCache::GrpIterator G = pkg.Group();
+              for (pkg = G.NextPkg(pkg); pkg.end() != true; pkg = G.NextPkg(pkg))
+                 if (pkg->VersionList != 0)
+                    PkgState[pkg->ID].Flags |= Flag::Auto;
+           }
          }
          }
+        amt += section.size();
          if(Prog != NULL)
          if(Prog != NULL)
-           Prog->OverallProgress(file_size, file_size, 1, 
+           Prog->OverallProgress(amt, file_size, 1, 
                                   _("Reading state information"));
        }
                                   _("Reading state information"));
        }
+      if(Prog != NULL)
+        Prog->OverallProgress(file_size, file_size, 1,
+                              _("Reading state information"));
     }
  
     return true;
  }
     }
  
     return true;
  }
-
-bool pkgDepCache::writeStateFile(OpProgress *prog, bool InstalledOnly)
+                                                                       /*}}}*/
+bool pkgDepCache::writeStateFile(OpProgress * const /*prog*/, bool const InstalledOnly)        /*{{{*/
  {
  {
-   if(_config->FindB("Debug::pkgAutoRemove",false))
+   bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
+   
+   if(debug_autoremove)
        std::clog << "pkgDepCache::writeStateFile()" << std::endl;
  
     FileFd StateFile;
        std::clog << "pkgDepCache::writeStateFile()" << std::endl;
  
     FileFd StateFile;
-   string state = _config->FindDir("Dir::State") + "extended_states";
+   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(!FileExists(state)) 
+   if(!RealFileExists(state))
     {
     {
-      StateFile.Open(state, FileFd::WriteEmpty);
+      StateFile.Open(state, FileFd::WriteAtomic);
        StateFile.Close();
     }
  
        StateFile.Close();
     }
  
@@ -221,153 +253,163 @@ 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 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)) {
     while(tagfile.Step(section)) {
-        string pkgname = section.FindS("Package");
+        string const pkgname = section.FindS("Package");
+        string pkgarch = section.FindS("Architecture");
+        if (pkgarch.empty() == true)
+           pkgarch = "native";
          // Silently ignore unknown packages and packages with no actual
          // version.
          // Silently ignore unknown packages and packages with no actual
          // version.
-        pkgCache::PkgIterator pkg=Cache->FindPkg(pkgname);
-        if(pkg.end() || pkg.VersionList().end()) 
+        pkgCache::PkgIterator pkg = Cache->FindPkg(pkgname, pkgarch);
+        if(pkg.end() || pkg.VersionList().end())
             continue;
             continue;
-        bool newAuto = (PkgState[pkg->ID].Flags & Flag::Auto);
+        StateCache const &P = PkgState[pkg->ID];
+        bool newAuto = (P.Flags & Flag::Auto);
+        // skip not installed or now-removed ones if requested
+        if (InstalledOnly && (
+            (pkg->CurrentVer == 0 && P.Mode != ModeInstall) ||
+            (pkg->CurrentVer != 0 && P.Mode == ModeDelete)))
+        {
+           // The section is obsolete if it contains no other tag
+           unsigned int const count = section.Count();
+           if (count < 2 ||
+               (count == 2 && section.Exists("Auto-Installed")) ||
+               (count == 3 && section.Exists("Auto-Installed") && section.Exists("Architecture")))
+              continue;
+           else
+              newAuto = false;
+        }
          if(_config->FindB("Debug::pkgAutoRemove",false))
          if(_config->FindB("Debug::pkgAutoRemove",false))
-           std::clog << "Update exisiting AutoInstall info: " 
-                     << pkg.Name() << std::endl;
-        TFRewriteData rewrite[2];
-        rewrite[0].Tag = "Auto-Installed";
-        rewrite[0].Rewrite = newAuto ? "1" : "0";
-        rewrite[0].NewTag = 0;
-        rewrite[1].Tag = 0;
-        TFRewrite(OutFile, section, nullreorderlist, rewrite);
-        fprintf(OutFile,"\n");
-        pkgs_seen.insert(pkgname);
+           std::clog << "Update existing AutoInstall info: " 
+                     << pkg.FullName() << std::endl;
+
+        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());
     }
     }
-   
+
     // 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++) {
-      if(PkgState[pkg->ID].Flags & Flag::Auto) {
-        if (pkgs_seen.find(pkg.Name()) != pkgs_seen.end()) {
-           if(_config->FindB("Debug::pkgAutoRemove",false))
-              std::clog << "Skipping already written " << pkg.Name() << std::endl;
+   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()) {
+           if(debug_autoremove)
+              std::clog << "Skipping already written " << pkg.FullName() << std::endl;
             continue;
          }
             continue;
          }
-         // skip not installed ones if requested
-         if(InstalledOnly && pkg->CurrentVer == 0)
-            continue;
-        if(_config->FindB("Debug::pkgAutoRemove",false))
-           std::clog << "Writing new AutoInstall: " 
-                     << pkg.Name() << std::endl;
-        ostr.str(string(""));
-        ostr << "Package: " << pkg.Name() 
-             << "\nAuto-Installed: 1\n\n";
-        fprintf(OutFile,"%s",ostr.str().c_str());
-        fprintf(OutFile,"\n");
+        // skip not installed ones if requested
+        if (InstalledOnly && (
+            (pkg->CurrentVer == 0 && P.Mode != ModeInstall) ||
+            (pkg->CurrentVer != 0 && P.Mode == ModeDelete)))
+           continue;
+        const char* const pkgarch = pkg.Arch();
+        if (strcmp(pkgarch, "all") == 0)
+           continue;
+        if(debug_autoremove)
+           std::clog << "Writing new AutoInstall: " << pkg.FullName() << std::endl;
+        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;
  }
-
+                                                                       /*}}}*/
  // DepCache::CheckDep - Checks a single dependency                     /*{{{*/
  // ---------------------------------------------------------------------
  /* This first checks the dependency against the main target package and
     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. */
  // DepCache::CheckDep - Checks a single dependency                     /*{{{*/
  // ---------------------------------------------------------------------
  /* This first checks the dependency against the main target package and
     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 if it is
-         a conflicts. See the comment above. */
-      if (P.OwnerPkg() == Pkg &&
-         (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 */
-void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
+/* Call with Inverse = true to preform the inverse opration */
+void pkgDepCache::AddSizes(const PkgIterator &Pkg, bool const Inverse)
  {
     StateCache &P = PkgState[Pkg->ID];
     
  {
     StateCache &P = PkgState[Pkg->ID];
     
@@ -381,8 +423,13 @@ void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
     // Compute the size data
     if (P.NewInstall() == true)
     {
     // Compute the size data
     if (P.NewInstall() == true)
     {
-      iUsrSize += (signed)(Mult*P.InstVerIter(*this)->InstalledSize);
-      iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
+      if (Inverse == false) {
+        iUsrSize += P.InstVerIter(*this)->InstalledSize;
+        iDownloadSize += P.InstVerIter(*this)->Size;
+      } else {
+        iUsrSize -= P.InstVerIter(*this)->InstalledSize;
+        iDownloadSize -= P.InstVerIter(*this)->Size;
+      }
        return;
     }
     
        return;
     }
     
@@ -391,9 +438,15 @@ void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
         (P.InstallVer != (Version *)Pkg.CurrentVer() || 
         (P.iFlags & ReInstall) == ReInstall) && P.InstallVer != 0)
     {
         (P.InstallVer != (Version *)Pkg.CurrentVer() || 
         (P.iFlags & ReInstall) == ReInstall) && P.InstallVer != 0)
     {
-      iUsrSize += (signed)(Mult*((signed)P.InstVerIter(*this)->InstalledSize - 
-                       (signed)Pkg.CurrentVer()->InstalledSize));
-      iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
+      if (Inverse == false) {
+        iUsrSize -= Pkg.CurrentVer()->InstalledSize;
+        iUsrSize += P.InstVerIter(*this)->InstalledSize;
+        iDownloadSize += P.InstVerIter(*this)->Size;
+      } else {
+        iUsrSize -= P.InstVerIter(*this)->InstalledSize;
+        iUsrSize += Pkg.CurrentVer()->InstalledSize;
+        iDownloadSize -= P.InstVerIter(*this)->Size;
+      }
        return;
     }
     
        return;
     }
     
@@ -401,14 +454,20 @@ void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
     if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
         P.Delete() == false)
     {
     if (Pkg.State() == pkgCache::PkgIterator::NeedsUnpack &&
         P.Delete() == false)
     {
-      iDownloadSize += (signed)(Mult*P.InstVerIter(*this)->Size);
+      if (Inverse == false)
+        iDownloadSize += P.InstVerIter(*this)->Size;
+      else
+        iDownloadSize -= P.InstVerIter(*this)->Size;
        return;
     }
     
     // Removing
     if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
     {
        return;
     }
     
     // Removing
     if (Pkg->CurrentVer != 0 && P.InstallVer == 0)
     {
-      iUsrSize -= (signed)(Mult*Pkg.CurrentVer()->InstalledSize);
+      if (Inverse == false)
+        iUsrSize -= Pkg.CurrentVer()->InstalledSize;
+      else
+        iUsrSize += Pkg.CurrentVer()->InstalledSize;
        return;
     }   
  }
        return;
     }   
  }
@@ -421,50 +480,50 @@ void pkgDepCache::AddSizes(const PkgIterator &Pkg,signed long Mult)
     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;
  }
                                                                         /*}}}*/
@@ -475,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      /*{{{*/
@@ -509,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;
  }
                                                                         /*}}}*/
@@ -545,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;
  }
                                                                         /*}}}*/
@@ -564,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];
@@ -598,27 +649,28 @@ void pkgDepCache::UpdateVerState(PkgIterator Pkg)
  // ---------------------------------------------------------------------
  /* This will figure out the state of all the packages and all the 
     dependencies based on the current policy. */
  // ---------------------------------------------------------------------
  /* 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;
-   
+
     // Perform the depends pass
     int Done = 0;
     // Perform the depends pass
     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);
-      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];
@@ -631,20 +683,18 @@ 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;
-        }       
+        }
        }
  
        }
  
-      // Compute the pacakge dependency state and size additions
+      // Compute the package dependency state and size additions
        AddSizes(I);
        UpdateVerState(I);
        AddStates(I);
     }
  
        AddSizes(I);
        UpdateVerState(I);
        AddStates(I);
     }
  
-   if (Prog != 0)      
+   if (Prog != 0)
        Prog->Progress(Done);
  
     readStateFile(Prog);
        Prog->Progress(Done);
  
     readStateFile(Prog);
@@ -657,15 +707,13 @@ void pkgDepCache::Update(OpProgress *Prog)
  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());
@@ -692,65 +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());
  }
          Update(P.ParentPkg().RevDependsList());
  }
-
                                                                         /*}}}*/
                                                                         /*}}}*/
-
  // DepCache::MarkKeep - Put the package in the keep state              /*{{{*/
  // ---------------------------------------------------------------------
  /* */
  // 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 << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkKeep " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;
  
     RemoveSizes(Pkg);
     RemoveStates(Pkg);
  
     RemoveSizes(Pkg);
     RemoveStates(Pkg);
@@ -762,40 +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,
-                             unsigned long Depth)
+bool pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
+                             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];
+   if ((P.Mode == ModeDelete || P.InstallVer == 0) && 
+       (Pkg.Purge() == true || rPurge == false))
+      return true;
+
+   // check if we are allowed to remove the package
+   if (IsDeleteOk(Pkg,rPurge,Depth,FromUser) == false)
+      return false;
+
     P.iFlags &= ~(AutoKept | Purge);
     if (rPurge == true)
        P.iFlags |= Purge;
     P.iFlags &= ~(AutoKept | Purge);
     if (rPurge == true)
        P.iFlags |= Purge;
-   
-   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;
+
+   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) << "MarkDelete " << Pkg << 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);
@@ -809,53 +886,213 @@ void pkgDepCache::MarkDelete(PkgIterator const &Pkg, bool rPurge,
     AddStates(Pkg);   
     Update(Pkg);
     AddSizes(Pkg);
     AddStates(Pkg);   
     Update(Pkg);
     AddSizes(Pkg);
+
+   return true;
+}
+                                                                       /*}}}*/
+// DepCache::IsDeleteOk - check if it is ok to remove this package     /*{{{*/
+// ---------------------------------------------------------------------
+/* 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)
+{
+   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)
+           std::clog << OutputInDepth(Depth) << "Manual install request prevents MarkDelete of " << APT::PrettyPkg(this, Pkg) << std::endl;
+        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                /*{{{*/
  // ---------------------------------------------------------------------
  /* */
  }
                                                                         /*}}}*/
  // 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;
-
-   /* if the user doesn't request directly the install we have to check
-      if this install will conflict with any rule a application
-      like apt-get or aptitude might has set (for the user)
-      e.g. forbidden versions, holds or other magic stuff */
-   if(FromUser == false && !IsAutoInstallOk(Pkg, Depth))
-   {
-      MarkKeep(Pkg, false, FromUser, Depth);
-      return;
-   }
+   // check if we are allowed to install the package
+   if (IsInstallOk(Pkg,AutoInst,Depth,FromUser) == false)
+      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
@@ -868,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
@@ -885,21 +1123,42 @@ void pkgDepCache::MarkInstall(PkgIterator const &Pkg,bool AutoInst,
     AddStates(Pkg);
     Update(Pkg);
     AddSizes(Pkg);
     AddStates(Pkg);
     Update(Pkg);
     AddSizes(Pkg);
-   
-   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 << std::endl;
+      std::clog << OutputInDepth(Depth) << "MarkInstall " << APT::PrettyPkg(this, Pkg) << " FU=" << FromUser << std::endl;
+
+   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 = P.InstVerIter(*this).DependsList();
+   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;
  
@@ -912,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
@@ -926,149 +1195,246 @@ 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())
-      {
-        bool found=false;
-        VerIterator instVer = Pkg.CurrentVer();
-        if(!instVer.end())
-        {
-          for (DepIterator D = instVer.DependsList(); D.end() != true; D++)
-            {
-              //FIXME: deal better with or-groups(?)
-              DepIterator LocalStart = D;
-
-              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)
+      if (Pkg->CurrentVer != 0 && ForceImportantDeps == false && Start.IsCritical() == false)
        {
        {
-        // 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++)
+        bool isNewImportantDep = true;
+        bool isPreviouslySatisfiedImportantDep = false;
+        for (DepIterator D = Pkg.CurrentVer().DependsList(); D.end() != true; ++D)
          {
          {
-           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;
+        }
+        else if(isPreviouslySatisfiedImportantDep == true)
+        {
+           if (DebugAutoInstall == true)
+              std::clog << OutputInDepth(Depth) << "previously satisfied important dependency on "
+                        << Start.TargetPkg().FullName() << std::endl;
          }
          }
-        
-        if (InstPkg.end() == false) 
+        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();
  
-           if (Start->Type != Dep::DpkgBreaks)
-              MarkDelete(Pkg,false,Depth + 1);
-           else
-              if (PkgState[Pkg->ID].CandidateVer != *I)
-                 MarkInstall(Pkg,true,Depth + 1, false, ForceImportantDeps);
+           /* The List includes all packages providing this dependency,
+              even providers which are not installed, so skip them. */
+           if (PkgState[Pkg->ID].InstallVer == 0)
+              continue;
+
+            /* 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::IsAutoInstallOk - check if it is to install this package  /*{{{*/
+// DepCache::IsInstallOk - check if it is ok to install this package   /*{{{*/
  // ---------------------------------------------------------------------
  // ---------------------------------------------------------------------
-/* The default implementation is useless, but an application using this
-   library can override this method to control the MarkInstall behaviour */
-bool pkgDepCache::IsAutoInstallOk(const PkgIterator &Pkg, unsigned long Depth)
+/* 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)
+{
+   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))
+   {
+      // 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 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;
  }
                                                                         /*}}}*/
@@ -1077,19 +1443,44 @@ bool pkgDepCache::IsAutoInstallOk(const PkgIterator &Pkg, unsigned long Depth)
  /* */
  void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
  {
  /* */
  void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
  {
-   ActionGroup group(*this);
+   if (unlikely(Pkg.end() == true))
+      return;
  
  
-   RemoveSizes(Pkg);
-   RemoveStates(Pkg);
-   
-   StateCache &P = PkgState[Pkg->ID];
-   if (To == true)
-      P.iFlags |= ReInstall;
+   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
     else
-      P.iFlags &= ~ReInstall;
-   
-   AddStates(Pkg);
-   AddSizes(Pkg);
+      pkglist.insert(Pkg);
+
+   ActionGroup group(*this);
+
+   for (APT::PackageList::const_iterator Pkg = pkglist.begin(); Pkg != pkglist.end(); ++Pkg)
+   {
+      RemoveSizes(Pkg);
+      RemoveStates(Pkg);
+
+      StateCache &P = PkgState[Pkg->ID];
+      if (To == true)
+        P.iFlags |= ReInstall;
+      else
+        P.iFlags &= ~ReInstall;
+
+      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                /*{{{*/
@@ -1097,15 +1488,18 @@ void pkgDepCache::SetReInstall(PkgIterator const &Pkg,bool To)
  /* */
  void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
  {
  /* */
  void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
  {
-   ActionGroup group(*this);
-
     pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
     StateCache &P = PkgState[Pkg->ID];
  
     pkgCache::PkgIterator Pkg = TargetVer.ParentPkg();
     StateCache &P = PkgState[Pkg->ID];
  
+   if (P.CandidateVer == TargetVer)
+      return;
+
+   ActionGroup group(*this);
+
     RemoveSizes(Pkg);
     RemoveStates(Pkg);
  
     RemoveSizes(Pkg);
     RemoveStates(Pkg);
  
-   if (P.CandidateVer == P.InstallVer)
+   if (P.CandidateVer == P.InstallVer && P.Install() == true)
        P.InstallVer = (Version *)TargetVer;
     P.CandidateVer = (Version *)TargetVer;
     P.Update(Pkg,*this);
        P.InstallVer = (Version *)TargetVer;
     P.CandidateVer = (Version *)TargetVer;
     P.Update(Pkg,*this);
@@ -1113,8 +1507,173 @@ void pkgDepCache::SetCandidateVersion(VerIterator TargetVer)
     AddStates(Pkg);
     Update(Pkg);
     AddSizes(Pkg);
     AddStates(Pkg);
     Update(Pkg);
     AddSizes(Pkg);
+
+}
+                                                                       /*}}}*/
+// DepCache::SetCandidateRelease - Change the candidate version                /*{{{*/
+// ---------------------------------------------------------------------
+/* changes the candidate of a package and walks over all its dependencies
+   to check if it needs to change the candidate of the dependency, too,
+   to reach a installable versionstate */
+bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
+                                       std::string const &TargetRel)
+{
+   std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > Changed;
+   return SetCandidateRelease(TargetVer, TargetRel, Changed);
  }
  }
+bool pkgDepCache::SetCandidateRelease(pkgCache::VerIterator TargetVer,
+                                       std::string const &TargetRel,
+                                       std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> > &Changed)
+{
+   ActionGroup group(*this);
+   SetCandidateVersion(TargetVer);
+
+   if (TargetRel == "installed" || TargetRel == "candidate") // both doesn't make sense in this context
+      return true;
+
+   pkgVersionMatch Match(TargetRel, pkgVersionMatch::Release);
+   // save the position of the last element we will not undo - if we have to
+   std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::iterator newChanged = --(Changed.end());
+
+   for (pkgCache::DepIterator D = TargetVer.DependsList(); D.end() == false; ++D)
+   {
+      if (D->Type != pkgCache::Dep::PreDepends && D->Type != pkgCache::Dep::Depends &&
+         ((D->Type != pkgCache::Dep::Recommends && D->Type != pkgCache::Dep::Suggests) ||
+          IsImportantDep(D) == false))
+        continue;
+
+      // walk over an or-group and check if we need to do anything
+      // for simpilicity no or-group is handled as a or-group including one dependency
+      pkgCache::DepIterator Start = D;
+      bool itsFine = false;
+      for (bool stillOr = true; stillOr == true; ++Start)
+      {
+        stillOr = (Start->CompareOp & Dep::Or) == Dep::Or;
+        pkgCache::PkgIterator const P = Start.TargetPkg();
+        // virtual packages can't be a solution
+        if (P.end() == true || (P->ProvidesList == 0 && P->VersionList == 0))
+           continue;
+        pkgCache::VerIterator const Cand = PkgState[P->ID].CandidateVerIter(*this);
+        // no versioned dependency - but is it installable?
+        if (Start.TargetVer() == 0 || Start.TargetVer()[0] == '\0')
+        {
+           // Check if one of the providers is installable
+           if (P->ProvidesList != 0)
+           {
+              pkgCache::PrvIterator Prv = P.ProvidesList();
+              for (; Prv.end() == false; ++Prv)
+              {
+                 pkgCache::VerIterator const C = PkgState[Prv.OwnerPkg()->ID].CandidateVerIter(*this);
+                 if (C.end() == true || C != Prv.OwnerVer() ||
+                     (VersionState(C.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
+                    continue;
+                 break;
+              }
+              if (Prv.end() == true)
+                 continue;
+           }
+           // no providers, so check if we have an installable candidate version
+           else if (Cand.end() == true ||
+               (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) != DepCandMin)
+              continue;
+           itsFine = true;
+           break;
+        }
+        if (Cand.end() == true)
+           continue;
+        // check if the current candidate is enough for the versioned dependency - and installable?
+        if (Start.IsSatisfied(Cand) == true &&
+            (VersionState(Cand.DependsList(), DepInstall, DepCandMin, DepCandPolicy) & DepCandMin) == DepCandMin)
+        {
+           itsFine = true;
+           break;
+        }
+      }
+
+      if (itsFine == true) {
+        // something in the or-group was fine, skip all other members
+        for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
+        continue;
+      }
  
  
+      // walk again over the or-group and check each if a candidate switch would help
+      itsFine = false;
+      for (bool stillOr = true; stillOr == true; ++D)
+      {
+        stillOr = (D->CompareOp & Dep::Or) == Dep::Or;
+        // changing candidate will not help if the dependency is not versioned
+        if (D.TargetVer() == 0 || D.TargetVer()[0] == '\0')
+        {
+           if (stillOr == true)
+              continue;
+           break;
+        }
+
+        pkgCache::VerIterator V;
+        if (TargetRel == "newest")
+           V = D.TargetPkg().VersionList();
+        else
+           V = Match.Find(D.TargetPkg());
+
+        // check if the version from this release could satisfy the dependency
+        if (V.end() == true || D.IsSatisfied(V) == false)
+        {
+           if (stillOr == true)
+              continue;
+           break;
+        }
+
+        pkgCache::VerIterator oldCand = PkgState[D.TargetPkg()->ID].CandidateVerIter(*this);
+        if (V == oldCand)
+        {
+           // Do we already touched this Version? If so, their versioned dependencies are okay, no need to check again
+           for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = Changed.begin();
+                c != Changed.end(); ++c)
+           {
+              if (c->first->ParentPkg != V->ParentPkg)
+                 continue;
+              itsFine = true;
+              break;
+           }
+        }
+
+        if (itsFine == false)
+        {
+           // change the candidate
+           Changed.push_back(make_pair(V, TargetVer));
+           if (SetCandidateRelease(V, TargetRel, Changed) == false)
+           {
+              if (stillOr == false)
+                 break;
+              // undo the candidate changing
+              SetCandidateVersion(oldCand);
+              Changed.pop_back();
+              continue;
+           }
+           itsFine = true;
+        }
+
+        // something in the or-group was fine, skip all other members
+        for (; (D->CompareOp & Dep::Or) == Dep::Or; ++D);
+        break;
+      }
+
+      if (itsFine == false && (D->Type == pkgCache::Dep::PreDepends || D->Type == pkgCache::Dep::Depends))
+      {
+        // undo all changes which aren't lead to a solution
+        for (std::list<std::pair<pkgCache::VerIterator, pkgCache::VerIterator> >::const_iterator c = ++newChanged;
+             c != Changed.end(); ++c)
+           SetCandidateVersion(c->first);
+        Changed.erase(newChanged, Changed.end());
+        return false;
+      }
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// DepCache::MarkAuto - set the Auto flag for a package                        /*{{{*/
+// ---------------------------------------------------------------------
+/* */
  void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
  {
    StateCache &state = PkgState[Pkg->ID];
  void pkgDepCache::MarkAuto(const PkgIterator &Pkg, bool Auto)
  {
    StateCache &state = PkgState[Pkg->ID];
@@ -1145,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)
@@ -1165,36 +1720,36 @@ 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     /*{{{*/
  // ---------------------------------------------------------------------
  /* The default just returns the highest available version that is not
     a source and automatic. */
  // Policy::GetCandidateVer - Returns the Candidate install version     /*{{{*/
  // ---------------------------------------------------------------------
  /* The default just returns the highest available version that is not
     a source and automatic. */
-pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
+pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pkg)
  {
     /* 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)
+        if (J.File().Flagged(Flag::NotAutomatic) ||
+            J.File().Flagged(Flag::ButAutomaticUpgrades))
          {
             if (Last.end() == true)
                Last = I;
          {
             if (Last.end() == true)
                Last = I;
@@ -1208,83 +1763,40 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator Pkg)
     return Last;
  }
                                                                         /*}}}*/
     return Last;
  }
                                                                         /*}}}*/
-
  // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
  // ---------------------------------------------------------------------
  /* */
  // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
  // ---------------------------------------------------------------------
  /* */
-bool pkgDepCache::Policy::IsImportantDep(DepIterator 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;
  }
                                                                         /*}}}*/
-
-pkgDepCache::DefaultRootSetFunc::DefaultRootSetFunc()
-  : constructedSuccessfully(false)
-{
-  Configuration::Item const *Opts;
-  Opts = _config->Tree("APT::NeverAutoRemove");
-  if (Opts != 0 && Opts->Child != 0)
-    {
-      Opts = Opts->Child;
-      for (; Opts != 0; Opts = Opts->Next)
-       {
-         if (Opts->Value.empty() == true)
-           continue;
-
-         regex_t *p = new regex_t;
-         if(regcomp(p,Opts->Value.c_str(),
-                    REG_EXTENDED | REG_ICASE | REG_NOSUB) != 0)
-           {
-             regfree(p);
-             delete p;
-             _error->Error("Regex compilation error for APT::NeverAutoRemove");
-             return;
-           }
-
-         rootSetRegexp.push_back(p);
-       }
-    }
-
-  constructedSuccessfully = true;
-}
-
-pkgDepCache::DefaultRootSetFunc::~DefaultRootSetFunc()
-{
-  for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
-    {
-      regfree(rootSetRegexp[i]);
-      delete rootSetRegexp[i];
-    }
-}
-
-
-bool pkgDepCache::DefaultRootSetFunc::InRootSet(const pkgCache::PkgIterator &pkg)
-{
-   for(unsigned int i = 0; i < rootSetRegexp.size(); i++)
-      if (regexec(rootSetRegexp[i], pkg.Name(), 0, 0, 0) == 0)
-        return true;
-
-   return false;
-}
-
-pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc()
+// 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;
    if(f->wasConstructedSuccessfully())
  {
    DefaultRootSetFunc *f = new DefaultRootSetFunc;
    if(f->wasConstructedSuccessfully())
@@ -1295,7 +1807,7 @@ pkgDepCache::InRootSetFunc *pkgDepCache::GetRootSetFunc()
        return NULL;
      }
  }
        return NULL;
      }
  }
-
+                                                                       /*}}}*/
  bool pkgDepCache::MarkFollowsRecommends()
  {
    return _config->FindB("APT::AutoRemove::RecommendsImportant", true);
  bool pkgDepCache::MarkFollowsRecommends()
  {
    return _config->FindB("APT::AutoRemove::RecommendsImportant", true);
@@ -1303,40 +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);
  }
  
  }
  
-// the main mark algorithm
+// pkgDepCache::MarkRequired - the main mark algorithm                 /*{{{*/
  bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
  {
  bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
  {
-   bool follow_recommends;
-   bool follow_suggests;
+   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(_config->FindB("Debug::pkgAutoRemove",false) 
-        && PkgState[p->ID].Flags & Flag::Auto)
-        std::clog << "AutoDep: " << p.Name() << 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) ||
-         userFunc.InRootSet(p))
-          
+         (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 &&
+          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())
@@ -1351,19 +1868,25 @@ bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
  
     return true;
  }
  
     return true;
  }
-
-// mark a single package in Mark-and-Sweep
+                                                                       /*}}}*/
+// MarkPackage - mark a single package in Mark-and-Sweep               /*{{{*/
  void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
                               const pkgCache::VerIterator &ver,
  void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
                               const pkgCache::VerIterator &ver,
-                             bool follow_recommends,
-                             bool follow_suggests)
+                             bool const &follow_recommends,
+                             bool const &follow_suggests)
  {
     pkgDepCache::StateCache &state = PkgState[pkg->ID];
  {
     pkgDepCache::StateCache &state = PkgState[pkg->ID];
-   VerIterator currver            = pkg.CurrentVer();
-   VerIterator candver            = state.CandidateVerIter(*this);
-   VerIterator instver            = state.InstVerIter(*this);
+
+   // if we are marked already we are done
+   if(state.Marked)
+      return;
+
+   VerIterator const currver = pkg.CurrentVer();
+   VerIterator const instver = state.InstVerIter(*this);
  
  #if 0
  
  #if 0
+   VerIterator const candver = state.CandidateVerIter(*this);
+
     // If a package was garbage-collected but is now being marked, we
     // should re-select it 
     // For cases when a pkg is set to upgrade and this trigger the
     // If a package was garbage-collected but is now being marked, we
     // should re-select it 
     // For cases when a pkg is set to upgrade and this trigger the
@@ -1387,13 +1910,11 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
        !(ver == currver && instver.end() && !ver.end()))
        return;
  
        !(ver == currver && instver.end() && !ver.end()))
        return;
  
-   // if we are marked already we are done
-   if(state.Marked)
-      return;
+   bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove", false);
  
  
-   if(_config->FindB("Debug::pkgAutoRemove",false))
+   if(debug_autoremove)
       {
       {
-       std::clog << "Marking: " << pkg.Name();
+       std::clog << "Marking: " << pkg.FullName();
         if(!ver.end())
          std::clog << " " << ver.VerStr();
         if(!currver.end())
         if(!ver.end())
          std::clog << " " << ver.VerStr();
         if(!currver.end())
@@ -1405,8 +1926,9 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
  
     state.Marked=true;
  
  
     state.Marked=true;
  
-   if(!ver.end())
-   {
+   if(ver.end() == true)
+      return;
+
       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 ||
@@ -1420,14 +1942,13 @@ 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(_config->FindB("Debug::pkgAutoRemove",false))
+               if(debug_autoremove)
                   {
                   {
-                   std::clog << "Following dep: " << d.ParentPkg().Name()
+                   std::clog << "Following dep: " << d.ParentPkg().FullName()
                               << " " << d.ParentVer().VerStr() << " "
                               << " " << d.ParentVer().VerStr() << " "
-                             << d.DepType() << " "
-                             << d.TargetPkg().Name();
+                             << d.DepType() << " " << d.TargetPkg().FullName();
                     if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
                       {
                         std::clog << " (" << d.CompType() << " "
                     if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
                       {
                         std::clog << " (" << d.CompType() << " "
@@ -1435,7 +1956,7 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
                       }
                     std::clog << std::endl;
                   }
                       }
                     std::clog << std::endl;
                   }
-                MarkPackage(V.ParentPkg(), V, 
+                MarkPackage(V.ParentPkg(), V,
                              follow_recommends, follow_suggests);
               }
            }
                              follow_recommends, follow_suggests);
               }
            }
@@ -1443,22 +1964,20 @@ 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(_config->FindB("Debug::pkgAutoRemove",false))
+               if(debug_autoremove)
                   {
                   {
-                   std::clog << "Following dep: " << d.ParentPkg().Name()
-                             << " " << d.ParentVer().VerStr() << " "
-                             << d.DepType() << " "
-                             << d.TargetPkg().Name();
+                   std::clog << "Following dep: " << d.ParentPkg().FullName() << " "
+                             << d.ParentVer().VerStr() << " "
+                             << d.DepType() << " " << d.TargetPkg().FullName() << " ";
                     if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
                       {
                         std::clog << " (" << d.CompType() << " "
                                   << d.TargetVer() << ")";
                       }
                     std::clog << ", provided by "
                     if((d->CompareOp & ~pkgCache::Dep::Or) != pkgCache::Dep::NoOp)
                       {
                         std::clog << " (" << d.CompType() << " "
                                   << d.TargetVer() << ")";
                       }
                     std::clog << ", provided by "
-                             << prv.OwnerPkg().Name() << " "
+                             << prv.OwnerPkg().FullName() << " "
                               << prv.OwnerVer().VerStr()
                               << std::endl;
                   }
                               << prv.OwnerVer().VerStr()
                               << std::endl;
                   }
@@ -1469,14 +1988,15 @@ void pkgDepCache::MarkPackage(const pkgCache::PkgIterator &pkg,
            }
         }
       }
            }
         }
       }
-   }
  }
  }
-
-bool pkgDepCache::Sweep()
+                                                                       /*}}}*/
+bool pkgDepCache::Sweep()                                              /*{{{*/
  {
  {
+   bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
+
     // do the sweep
     for(PkgIterator p=PkgBegin(); !p.end(); ++p)
     // do the sweep
     for(PkgIterator p=PkgBegin(); !p.end(); ++p)
-  {
+   {
       StateCache &state=PkgState[p->ID];
  
       // skip required packages
       StateCache &state=PkgState[p->ID];
  
       // skip required packages
@@ -1488,10 +2008,25 @@ bool pkgDepCache::Sweep()
       if(!state.Marked && (!p.CurrentVer().end() || state.Install()))
       {
         state.Garbage=true;
       if(!state.Marked && (!p.CurrentVer().end() || state.Install()))
       {
         state.Garbage=true;
-       if(_config->FindB("Debug::pkgAutoRemove",false))
-          std::cout << "Garbage: " << p.Name() << std::endl;
+       if(debug_autoremove)
+          std::clog << "Garbage: " << p.FullName() << std::endl;
       }
    }   
  
     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;
+}
+                                                                       /*}}}*/