cleanup the debian/rules file a bit

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

diff --git a/apt-pkg/algorithms.cc b/apt-pkg/algorithms.cc
index 5641869ab8cc995491c34681f565f3ab621f1a47..0fbce3c2af55b8ef9d9b39cc0331208eaf014195 100644 (file)
--- a/apt-pkg/algorithms.cc
+++ b/apt-pkg/algorithms.cc
@@ -374,6 +374,13 @@ bool pkgDistUpgrade(pkgDepCache &Cache)
 {
    pkgDepCache::ActionGroup group(Cache);
 
 {
    pkgDepCache::ActionGroup group(Cache);
 

+   /* Upgrade all installed packages first without autoinst to help the resolver
+      in versioned or-groups to upgrade the old solver instead of installing
+      a new one (if the old solver is not the first one [anymore]) */
+   for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; ++I)
+      if (I->CurrentVer != 0)
+        Cache.MarkInstall(I, false, 0, false);
+

    /* Auto upgrade all installed packages, this provides the basis 
       for the installation */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)
    /* Auto upgrade all installed packages, this provides the basis 
       for the installation */
    for (pkgCache::PkgIterator I = Cache.PkgBegin(); I.end() == false; I++)


@@ -987,6 +994,23 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 
               pkgCache::VerIterator Ver(Cache,*V);
               pkgCache::PkgIterator Pkg = Ver.ParentPkg();
 

+               /* This is a conflicts, and the version we are looking
+                  at is not the currently selected version of the 
+                  package, which means it is not necessary to 
+                  remove/keep */
+               if (Cache[Pkg].InstallVer != Ver &&
+                   (Start->Type == pkgCache::Dep::Conflicts ||
+                    Start->Type == pkgCache::Dep::DpkgBreaks ||
+                    Start->Type == pkgCache::Dep::Obsoletes)) 
+               {
+                  if (Debug) 
+                     clog << "  Conflicts//Breaks against version " 
+                          << Ver.VerStr() << " for " << Pkg.Name() 
+                          << " but that is not InstVer, ignoring"
+                          << endl;
+                  continue;
+               }
+

               if (Debug == true)
                  clog << "  Considering " << Pkg.FullName(false) << ' ' << (int)Scores[Pkg->ID] <<
                  " as a solution to " << I.FullName(false) << ' ' << (int)Scores[I->ID] << endl;
               if (Debug == true)
                  clog << "  Considering " << Pkg.FullName(false) << ' ' << (int)Scores[Pkg->ID] <<
                  " as a solution to " << I.FullName(false) << ' ' << (int)Scores[I->ID] << endl;


@@ -1045,6 +1069,7 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
                        else if (TryFixByInstall == true &&
                                 Start.TargetPkg()->CurrentVer == 0 &&
                                 Cache[Start.TargetPkg()].Delete() == false &&
                        else if (TryFixByInstall == true &&
                                 Start.TargetPkg()->CurrentVer == 0 &&
                                 Cache[Start.TargetPkg()].Delete() == false &&

+                                (Flags[Start.TargetPkg()->ID] & ToRemove) != ToRemove &&

                                 Cache.GetCandidateVer(Start.TargetPkg()).end() == false)
                        {
                           /* Before removing or keeping the package with the broken dependency
                                 Cache.GetCandidateVer(Start.TargetPkg()).end() == false)
                        {
                           /* Before removing or keeping the package with the broken dependency


@@ -1052,7 +1077,8 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
                              solving this dependency. This helps every time a previous solver
                              is removed by the resolver because of a conflict or alike but it is
                              dangerous as it could trigger new breaks/conflicts… */
                              solving this dependency. This helps every time a previous solver
                              is removed by the resolver because of a conflict or alike but it is
                              dangerous as it could trigger new breaks/conflicts… */

-                          std::cout << "  Try Installing " << Start.TargetPkg() << " before changing " << I.FullName(false) << std::endl;
+                          if (Debug == true)
+                             clog << "  Try Installing " << Start.TargetPkg() << " before changing " << I.FullName(false) << std::endl;

                           unsigned long const OldBroken = Cache.BrokenCount();
                           Cache.MarkInstall(Start.TargetPkg(), true, 1, false);
                           // FIXME: we should undo the complete MarkInstall process here
                           unsigned long const OldBroken = Cache.BrokenCount();
                           Cache.MarkInstall(Start.TargetPkg(), true, 1, false);
                           // FIXME: we should undo the complete MarkInstall process here


@@ -1068,22 +1094,14 @@ bool pkgProblemResolver::Resolve(bool BrokenFix)
               }
               else
               {
               }
               else
               {

-                 /* This is a conflicts, and the version we are looking
-                    at is not the currently selected version of the 
-                    package, which means it is not necessary to 
-                    remove/keep */
-                 if (Cache[Pkg].InstallVer != Ver &&
-                     (Start->Type == pkgCache::Dep::Conflicts ||
-                      Start->Type == pkgCache::Dep::Obsoletes))
-                    continue;
-

                  if (Start->Type == pkgCache::Dep::DpkgBreaks)
                  {
                     // first, try upgradring the package, if that
                     // does not help, the breaks goes onto the
                     // kill list
                  if (Start->Type == pkgCache::Dep::DpkgBreaks)
                  {
                     // first, try upgradring the package, if that
                     // does not help, the breaks goes onto the
                     // kill list

+                     //

                     // FIXME: use DoUpgrade(Pkg) instead?
                     // FIXME: use DoUpgrade(Pkg) instead?

-                    if (Cache[End] & pkgDepCache::DepGCVer) 
+                    if (Cache[End] & pkgDepCache::DepGCVer)

                     {
                        if (Debug)
                           clog << "  Upgrading " << Pkg.FullName(false) << " due to Breaks field in " << I.FullName(false) << endl;
                     {
                        if (Debug)
                           clog << "  Upgrading " << Pkg.FullName(false) << " due to Breaks field in " << I.FullName(false) << endl;