* apt-pkg/indexrecords.cc:

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

diff --git a/apt-pkg/packagemanager.cc b/apt-pkg/packagemanager.cc
index b9ef0f5d7c2644a258f1986ce82bb7bc4113a5c2..a370f15a3868a04e4018948e1d39dd498b36b0b2 100644 (file)
--- a/apt-pkg/packagemanager.cc
+++ b/apt-pkg/packagemanager.cc
@@ -250,7 +250,7 @@ bool pkgPackageManager::CheckRConflicts(PkgIterator Pkg,DepIterator D,
         continue;
       
       // Ignore self conflicts, ignore conflicts from irrelevent versions
         continue;
       
       // Ignore self conflicts, ignore conflicts from irrelevent versions

-      if (D.ParentPkg() == Pkg || D.ParentVer() != D.ParentPkg().CurrentVer())
+      if (D.IsIgnorable(Pkg) || D.ParentVer() != D.ParentPkg().CurrentVer())

         continue;
       
       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)
         continue;
       
       if (Cache.VS().CheckDep(Ver,D->CompareOp,D.TargetVer()) == false)


@@ -322,22 +322,22 @@ bool pkgPackageManager::ConfigureAll()
    only shown when debuging*/
 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 {
    only shown when debuging*/
 bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
 {

-   // If this is true, only check and correct and dependancies without the Loop flag
+   // If this is true, only check and correct and dependencies without the Loop flag

    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 
    if (Debug) {
       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.Name() << " (" << InstallVer.VerStr() << ")";
       if (PkgLoop)
    bool PkgLoop = List->IsFlag(Pkg,pkgOrderList::Loop);
 
    if (Debug) {
       VerIterator InstallVer = VerIterator(Cache,Cache[Pkg].InstallVer);
       clog << OutputInDepth(Depth) << "SmartConfigure " << Pkg.Name() << " (" << InstallVer.VerStr() << ")";
       if (PkgLoop)

-        clog << " (Only Correct Dependancies)";
+        clog << " (Only Correct Dependencies)";

       clog << endl;
    }
 
    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
       
       clog << endl;
    }
 
    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
       

-   /* Because of the ordered list, most dependancies should be unpacked, 
+   /* Because of the ordered list, most dependencies should be unpacked, 

       however if there is a loop (A depends on B, B depends on A) this will not 
       however if there is a loop (A depends on B, B depends on A) this will not 

-      be the case, so check for dependancies before configuring. */
+      be the case, so check for dependencies before configuring. */

    bool Bad = false;
    for (DepIterator D = instVer.DependsList();
        D.end() == false; )
    bool Bad = false;
    for (DepIterator D = instVer.DependsList();
        D.end() == false; )


@@ -404,22 +404,27 @@ bool pkgPackageManager::SmartConfigure(PkgIterator Pkg, int const Depth)
         
         /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
         if (InstallVer != 0 && Bad) {
         
         /* If the dependany is still not satisfied, try, if possible, unpacking a package to satisfy it */
         if (InstallVer != 0 && Bad) {

-           Bad = false;
-           if (List->IsNow(DepPkg) && !List->IsFlag(DepPkg,pkgOrderList::Loop)) {
-              List->Flag(Pkg,pkgOrderList::Loop);
-              if (Debug) 
-                 cout << OutputInDepth(Depth) << "Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
-              SmartUnPack(DepPkg, true, Depth + 1);
-              List->RmFlag(Pkg,pkgOrderList::Loop);
+           if (List->IsNow(DepPkg)) {
+              Bad = false;
+              if (List->IsFlag(Pkg,pkgOrderList::Loop))
+              {
+                 if (Debug)
+                    std::clog << OutputInDepth(Depth) << "Package " << Pkg << " loops in SmartConfigure" << std::endl;
+              }
+              else
+              {
+                 List->Flag(Pkg,pkgOrderList::Loop);
+                 if (Debug)
+                    cout << OutputInDepth(Depth) << "Unpacking " << DepPkg.Name() << " to avoid loop" << endl;
+                 SmartUnPack(DepPkg, true, Depth + 1);
+                 List->RmFlag(Pkg,pkgOrderList::Loop);
+              }

            }
         }
         
         if (Start==End) {
            }
         }
         
         if (Start==End) {

-           if (Bad && Debug) {
-              if (!List->IsFlag(DepPkg,pkgOrderList::Loop)) {
-                  _error->Warning("Could not satisfy dependancies for %s",Pkg.Name());
-               } 
-           }
+           if (Bad && Debug && List->IsFlag(DepPkg,pkgOrderList::Loop) == false)
+                 std::clog << OutputInDepth(Depth) << "Could not satisfy dependencies for " << Pkg.Name() << std::endl;

            break;
         } else {
             Start++;
            break;
         } else {
             Start++;


@@ -524,7 +529,6 @@ bool pkgPackageManager::SmartRemove(PkgIterator Pkg)
    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 
    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);
    List->Flag(Pkg,pkgOrderList::Configured,pkgOrderList::States);
 
    return Remove(Pkg,(Cache[Pkg].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge);

-   return true;

 }
                                                                        /*}}}*/
 // PM::SmartUnPack - Install helper                                    /*{{{*/
 }
                                                                        /*}}}*/
 // PM::SmartUnPack - Install helper                                    /*{{{*/


@@ -551,14 +555,6 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
       cout << endl;
    }
 
       cout << endl;
    }
 

-   // Check if it is already unpacked
-   if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
-       Cache[Pkg].Keep() == true)
-   {
-      cout << OutputInDepth(Depth) << "SmartUnPack called on Package " << Pkg.Name() << " but its unpacked" << endl;
-      return false;
-   }
- 

    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 
    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.
    VerIterator const instVer = Cache[Pkg].InstVerIter(Cache);
 
    /* PreUnpack Checks: This loop checks and attempts to rectify and problems that would prevent the package being unpacked.


@@ -685,7 +681,13 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
            VerIterator Ver(Cache,*I);
            PkgIterator BrokenPkg = Ver.ParentPkg();
            VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);
            VerIterator Ver(Cache,*I);
            PkgIterator BrokenPkg = Ver.ParentPkg();
            VerIterator InstallVer(Cache,Cache[BrokenPkg].InstallVer);

-           
+           if (BrokenPkg.CurrentVer() != Ver)
+           {
+              if (Debug)
+                 std::clog << OutputInDepth(Depth) << "  Ignore not-installed version " << Ver.VerStr() << " of " << Pkg.FullName() << " for " << End << std::endl;
+              continue;
+           }
+

            // Check if it needs to be unpacked
            if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false && 
                List->IsNow(BrokenPkg)) {
            // Check if it needs to be unpacked
            if (List->IsFlag(BrokenPkg,pkgOrderList::InList) && Cache[BrokenPkg].Delete() == false && 
                List->IsNow(BrokenPkg)) {


@@ -736,7 +738,7 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
 
    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 
 
    List->Flag(Pkg,pkgOrderList::UnPacked,pkgOrderList::States);
 

-   if (Immediate == true && instVer->MultiArch == pkgCache::Version::Same)
+   if (Immediate == true && (instVer->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)

    {
       /* Do lockstep M-A:same unpacking in two phases:
         First unpack all installed architectures, then the not installed.
    {
       /* Do lockstep M-A:same unpacking in two phases:
         First unpack all installed architectures, then the not installed.


@@ -768,7 +770,8 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
            return false;
       }
    }
            return false;
       }
    }

-   else if (Install(Pkg,FileNames[Pkg->ID]) == false)
+   // packages which are already unpacked don't need to be unpacked again
+   else if (Pkg.State() != pkgCache::PkgIterator::NeedsConfigure && Install(Pkg,FileNames[Pkg->ID]) == false)

       return false;
 
    if (Immediate == true) {
       return false;
 
    if (Immediate == true) {