check build-dep candidate if install is forbidden

[apt.git] / cmdline / apt-get.cc

diff --git a/cmdline/apt-get.cc b/cmdline/apt-get.cc
index a81e829e896a14cc234c66e0e2edc32f3b6fa69b..870c77280957dd85075844d49194b4dc312f95d2 100644 (file)
--- a/cmdline/apt-get.cc
+++ b/cmdline/apt-get.cc
@@ -25,8 +25,7 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/

-#define _LARGEFILE_SOURCE
-#define _LARGEFILE64_SOURCE
+#include <config.h>

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


@@ -37,6 +36,7 @@
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/algorithms.h>
 #include <apt-pkg/acquire-item.h>
 #include <apt-pkg/strutl.h>

+#include <apt-pkg/fileutl.h>

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


@@ -45,9 +45,10 @@
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/md5.h>
 #include <apt-pkg/versionmatch.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/md5.h>
 #include <apt-pkg/versionmatch.h>

-
-#include <config.h>
-#include <apti18n.h>
+#include <apt-pkg/progress.h>
+#include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/pkgrecords.h>
+#include <apt-pkg/indexfile.h>

 
 #include "acqprogress.h"
 
 
 #include "acqprogress.h"
 


@@ -68,8 +69,7 @@
 #include <sys/wait.h>
 #include <sstream>
 
 #include <sys/wait.h>
 #include <sstream>
 

-#define statfs statfs64
-#define statvfs statvfs64
+#include <apti18n.h>

                                                                        /*}}}*/
 
 #define RAMFS_MAGIC     0x858458f6
                                                                        /*}}}*/
 
 #define RAMFS_MAGIC     0x858458f6


@@ -254,6 +254,9 @@ bool ShowList(ostream &out,string Title,string List,string VersionsList)
  */
 void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
 {
  */
 void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
 {

+   if (Cache->BrokenCount() == 0)
+      return;
+

    out << _("The following packages have unmet dependencies:") << endl;
    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
    {
    out << _("The following packages have unmet dependencies:") << endl;
    for (unsigned J = 0; J < Cache->Head().PackageCount; J++)
    {


@@ -368,7 +371,7 @@ void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
            
            if (Start == End)
               break;
            
            if (Start == End)
               break;

-           Start++;
+           ++Start;

         }       
       }            
    }   
         }       
       }            
    }   


@@ -542,7 +545,7 @@ bool ShowEssential(ostream &out,CacheFile &Cache)
         continue;
 
       // Print out any essential package depenendents that are to be removed
         continue;
 
       // Print out any essential package depenendents that are to be removed

-      for (pkgCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; D++)
+      for (pkgCache::DepIterator D = I.CurrentVer().DependsList(); D.end() == false; ++D)

       {
         // Skip everything but depends
         if (D->Type != pkgCache::Dep::PreDepends &&
       {
         // Skip everything but depends
         if (D->Type != pkgCache::Dep::PreDepends &&


@@ -579,7 +582,7 @@ void Stats(ostream &out,pkgDepCache &Dep)
    unsigned long Downgrade = 0;
    unsigned long Install = 0;
    unsigned long ReInstall = 0;
    unsigned long Downgrade = 0;
    unsigned long Install = 0;
    unsigned long ReInstall = 0;

-   for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
+   for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; ++I)

    {
       if (Dep[I].NewInstall() == true)
         Install++;
    {
       if (Dep[I].NewInstall() == true)
         Install++;


@@ -628,20 +631,18 @@ public:
                explicitlyNamed = true;
        }
 
                explicitlyNamed = true;
        }
 

-       virtual void showTaskSelection(APT::PackageSet const &pkgset, string const &pattern) {
-               for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
-                       ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
-                                Pkg.FullName(true).c_str(), pattern.c_str());
+       virtual void showTaskSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
+               ioprintf(out, _("Note, selecting '%s' for task '%s'\n"),
+                               Pkg.FullName(true).c_str(), pattern.c_str());

                explicitlyNamed = false;
        }
                explicitlyNamed = false;
        }

-       virtual void showRegExSelection(APT::PackageSet const &pkgset, string const &pattern) {
-               for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
-                       ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
-                                Pkg.FullName(true).c_str(), pattern.c_str());
+       virtual void showRegExSelection(pkgCache::PkgIterator const &Pkg, string const &pattern) {
+               ioprintf(out, _("Note, selecting '%s' for regex '%s'\n"),
+                               Pkg.FullName(true).c_str(), pattern.c_str());

                explicitlyNamed = false;
        }
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,
                explicitlyNamed = false;
        }
        virtual void showSelectedVersion(pkgCache::PkgIterator const &Pkg, pkgCache::VerIterator const Ver,

-                                string const &ver, bool const &verIsRel) {
+                                string const &ver, bool const verIsRel) {

                if (ver == Ver.VerStr())
                        return;
                selectedByRelease.push_back(make_pair(Ver, ver));
                if (ver == Ver.VerStr())
                        return;
                selectedByRelease.push_back(make_pair(Ver, ver));


@@ -662,22 +663,22 @@ public:
                                        pkgCache::PkgIterator Pkg = I.OwnerPkg();
 
                                        if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {
                                        pkgCache::PkgIterator Pkg = I.OwnerPkg();
 
                                        if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer()) {

-                                               out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();
+                                               c1out << "  " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr();

                                                if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
                                                if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)

-                                                       out << _(" [Installed]");
-                                               out << endl;
+                                                       c1out << _(" [Installed]");
+                                               c1out << endl;

                                                ++provider;
                                        }
                                }
                                // if we found no candidate which provide this package, show non-candidates
                                if (provider == 0)
                                                ++provider;
                                        }
                                }
                                // if we found no candidate which provide this package, show non-candidates
                                if (provider == 0)

-                                       for (I = Pkg.ProvidesList(); I.end() == false; I++)
-                                               out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()
+                                       for (I = Pkg.ProvidesList(); I.end() == false; ++I)
+                                               c1out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()

                                                    << _(" [Not candidate version]") << endl;
                                else
                                        out << _("You should explicitly select one to install.") << endl;
                        } else {
                                                    << _(" [Not candidate version]") << endl;
                                else
                                        out << _("You should explicitly select one to install.") << endl;
                        } else {

-                               ioprintf(out,
+                               ioprintf(c1out,

                                        _("Package %s is not available, but is referred to by another package.\n"
                                          "This may mean that the package is missing, has been obsoleted, or\n"
                                          "is only available from another source\n"),Pkg.FullName(true).c_str());
                                        _("Package %s is not available, but is referred to by another package.\n"
                                          "This may mean that the package is missing, has been obsoleted, or\n"
                                          "is only available from another source\n"),Pkg.FullName(true).c_str());


@@ -687,7 +688,7 @@ public:
                                SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];
                                memset(Seen,0,Cache.GetPkgCache()->Head().PackageCount*sizeof(*Seen));
                                for (pkgCache::DepIterator Dep = Pkg.RevDependsList();
                                SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];
                                memset(Seen,0,Cache.GetPkgCache()->Head().PackageCount*sizeof(*Seen));
                                for (pkgCache::DepIterator Dep = Pkg.RevDependsList();

-                                    Dep.end() == false; Dep++) {
+                                    Dep.end() == false; ++Dep) {

                                        if (Dep->Type != pkgCache::Dep::Replaces)
                                                continue;
                                        if (Seen[Dep.ParentPkg()->ID] == true)
                                        if (Dep->Type != pkgCache::Dep::Replaces)
                                                continue;
                                        if (Seen[Dep.ParentPkg()->ID] == true)


@@ -696,9 +697,9 @@ public:
                                        List += Dep.ParentPkg().FullName(true) + " ";
                                        //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
                                }
                                        List += Dep.ParentPkg().FullName(true) + " ";
                                        //VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
                                }

-                               ShowList(out,_("However the following packages replace it:"),List,VersionsList);
+                               ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);

                        }
                        }

-                       out << std::endl;
+                       c1out << std::endl;

                }
                return false;
        }
                }
                return false;
        }


@@ -707,7 +708,7 @@ public:
                APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::CANDIDATE);
                if (verset.empty() == false)
                        return *(verset.begin());
                APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::CANDIDATE);
                if (verset.empty() == false)
                        return *(verset.begin());

-               if (ShowError == true) {
+               else if (ShowError == true) {

                        _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
                        virtualPkgs.insert(Pkg);
                }
                        _error->Error(_("Package '%s' has no installation candidate"),Pkg.FullName(true).c_str());
                        virtualPkgs.insert(Pkg);
                }


@@ -715,11 +716,32 @@ public:
        }
 
        virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
        }
 
        virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {

-               APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::NEWEST);
-               if (verset.empty() == false)
-                       return *(verset.begin());
-               if (ShowError == true)
-                       ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
+               if (Pkg->ProvidesList != 0)
+               {
+                       APT::VersionSet const verset = tryVirtualPackage(Cache, Pkg, APT::VersionSet::NEWEST);
+                       if (verset.empty() == false)
+                               return *(verset.begin());
+                       if (ShowError == true)
+                               ioprintf(out, _("Virtual packages like '%s' can't be removed\n"), Pkg.FullName(true).c_str());
+               }
+               else
+               {
+                       pkgCache::GrpIterator Grp = Pkg.Group();
+                       pkgCache::PkgIterator P = Grp.PackageList();
+                       for (; P.end() != true; P = Grp.NextPkg(P))
+                       {
+                               if (P == Pkg)
+                                       continue;
+                               if (P->CurrentVer != 0) {
+                                       // TRANSLATORS: Note, this is not an interactive question
+                                       ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
+                                                Pkg.FullName(true).c_str(), P.FullName(true).c_str());
+                                       break;
+                               }
+                       }
+                       if (P.end() == true)
+                               ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
+               }

                return pkgCache::VerIterator(Cache, 0);
        }
 
                return pkgCache::VerIterator(Cache, 0);
        }
 


@@ -744,6 +766,19 @@ public:
                                Prov = PPkg;
                                found_one = true;
                        } else if (PPkg != Prov) {
                                Prov = PPkg;
                                found_one = true;
                        } else if (PPkg != Prov) {

+                               // same group, so it's a foreign package
+                               if (PPkg->Group == Prov->Group) {
+                                       // do we already have the requested arch?
+                                       if (strcmp(Pkg.Arch(), Prov.Arch()) == 0 ||
+                                           strcmp(Prov.Arch(), "all") == 0 ||
+                                           unlikely(strcmp(PPkg.Arch(), Prov.Arch()) == 0)) // packages have only on candidate, but just to be sure
+                                               continue;
+                                       // see which architecture we prefer more and switch to it
+                                       std::vector<std::string> archs = APT::Configuration::getArchitectures();
+                                       if (std::find(archs.begin(), archs.end(), PPkg.Arch()) < std::find(archs.begin(), archs.end(), Prov.Arch()))
+                                               Prov = PPkg;
+                                       continue;
+                               }

                                found_one = false; // we found at least two
                                break;
                        }
                                found_one = false; // we found at least two
                                break;
                        }


@@ -769,7 +804,7 @@ struct TryToInstall {
    unsigned long AutoMarkChanged;
    APT::PackageSet doAutoInstallLater;
 
    unsigned long AutoMarkChanged;
    APT::PackageSet doAutoInstallLater;
 

-   TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const &FixBroken) : Cache(&Cache), Fix(PM),
+   TryToInstall(pkgCacheFile &Cache, pkgProblemResolver *PM, bool const FixBroken) : Cache(&Cache), Fix(PM),

                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 
    void operator() (pkgCache::VerIterator const &Ver) {
                        FixBroken(FixBroken), AutoMarkChanged(0) {};
 
    void operator() (pkgCache::VerIterator const &Ver) {


@@ -874,9 +909,7 @@ struct TryToInstall {
 struct TryToRemove {
    pkgCacheFile* Cache;
    pkgProblemResolver* Fix;
 struct TryToRemove {
    pkgCacheFile* Cache;
    pkgProblemResolver* Fix;

-   bool FixBroken;

    bool PurgePkgs;
    bool PurgePkgs;

-   unsigned long AutoMarkChanged;

 
    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
                                PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};
 
    TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),
                                PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};


@@ -895,7 +928,23 @@ struct TryToRemove {
       if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
          (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
       {
       if ((Pkg->CurrentVer == 0 && PurgePkgs == false) ||
          (PurgePkgs == true && Pkg->CurrentState == pkgCache::State::NotInstalled))
       {

-        ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.FullName(true).c_str());
+        pkgCache::GrpIterator Grp = Pkg.Group();
+        pkgCache::PkgIterator P = Grp.PackageList();
+        for (; P.end() != true; P = Grp.NextPkg(P))
+        {
+           if (P == Pkg)
+              continue;
+           if (P->CurrentVer != 0 || (PurgePkgs == true && P->CurrentState != pkgCache::State::NotInstalled))
+           {
+              // TRANSLATORS: Note, this is not an interactive question
+              ioprintf(c1out,_("Package '%s' is not installed, so not removed. Did you mean '%s'?\n"),
+                       Pkg.FullName(true).c_str(), P.FullName(true).c_str());
+              break;
+           }
+        }
+        if (P.end() == true)
+           ioprintf(c1out,_("Package '%s' is not installed, so not removed\n"),Pkg.FullName(true).c_str());
+

         // MarkInstall refuses to install packages on hold
         Pkg->SelectedState = pkgCache::State::Hold;
       }
         // MarkInstall refuses to install packages on hold
         Pkg->SelectedState = pkgCache::State::Hold;
       }


@@ -928,7 +977,7 @@ void CacheFile::Sort()
    List = new pkgCache::Package *[Cache->Head().PackageCount];
    memset(List,0,sizeof(*List)*Cache->Head().PackageCount);
    pkgCache::PkgIterator I = Cache->PkgBegin();
    List = new pkgCache::Package *[Cache->Head().PackageCount];
    memset(List,0,sizeof(*List)*Cache->Head().PackageCount);
    pkgCache::PkgIterator I = Cache->PkgBegin();

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

       List[I->ID] = I;
 
    SortCache = *this;
       List[I->ID] = I;
 
    SortCache = *this;


@@ -960,7 +1009,7 @@ bool CacheFile::CheckDeps(bool AllowBroken)
       if ((DCache->PolicyBrokenCount() > 0))
       {
         // upgrade all policy-broken packages with ForceImportantDeps=True
       if ((DCache->PolicyBrokenCount() > 0))
       {
         // upgrade all policy-broken packages with ForceImportantDeps=True

-        for (pkgCache::PkgIterator I = Cache->PkgBegin(); !I.end(); I++)
+        for (pkgCache::PkgIterator I = Cache->PkgBegin(); !I.end(); ++I)

            if ((*DCache)[I].NowPolicyBroken() == true) 
               DCache->MarkInstall(I,true,0, false, true);
       }
            if ((*DCache)[I].NowPolicyBroken() == true) 
               DCache->MarkInstall(I,true,0, false, true);
       }


@@ -1051,7 +1100,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
    if (_config->FindB("APT::Get::Purge",false) == true)
    {
       pkgCache::PkgIterator I = Cache->PkgBegin();
    if (_config->FindB("APT::Get::Purge",false) == true)
    {
       pkgCache::PkgIterator I = Cache->PkgBegin();

-      for (; I.end() == false; I++)
+      for (; I.end() == false; ++I)

       {
         if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
            Cache->MarkDelete(I,true);
       {
         if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)
            Cache->MarkDelete(I,true);


@@ -1245,7 +1294,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();

-      for (; I != Fetcher.UriEnd(); I++)
+      for (; I != Fetcher.UriEnd(); ++I)

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;


@@ -1269,7 +1318,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
         {
            if ((*I)->Local == true)
            {
         {
            if ((*I)->Local == true)
            {

-              I++;
+              ++I;

               continue;
            }
 
               continue;
            }
 


@@ -1289,7 +1338,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
       
       // Print out errors
       bool Failed = false;
       
       // Print out errors
       bool Failed = false;

-      for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
+      for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)

       {
         if ((*I)->Status == pkgAcquire::Item::StatDone &&
             (*I)->Complete == true)
       {
         if ((*I)->Status == pkgAcquire::Item::StatDone &&
             (*I)->Complete == true)


@@ -1369,7 +1418,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
        "all files have been overwritten by other packages:",
        "The following packages disappeared from your system as\n"
        "all files have been overwritten by other packages:", disappearedPkgs.size()), disappear, "");
        "all files have been overwritten by other packages:",
        "The following packages disappeared from your system as\n"
        "all files have been overwritten by other packages:", disappearedPkgs.size()), disappear, "");

-   c0out << _("Note: This is done automatic and on purpose by dpkg.") << std::endl;
+   c0out << _("Note: This is done automatically and on purpose by dpkg.") << std::endl;

 
    return true;
 }
 
    return true;
 }


@@ -1449,7 +1498,7 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
         // we have a default release, try to locate the pkg. we do it like
         // this because GetCandidateVer() will not "downgrade", that means
         // "apt-get source -t stable apt" won't work on a unstable system
         // we have a default release, try to locate the pkg. we do it like
         // this because GetCandidateVer() will not "downgrade", that means
         // "apt-get source -t stable apt" won't work on a unstable system

-        for (pkgCache::VerIterator Ver = Pkg.VersionList();; Ver++)
+        for (pkgCache::VerIterator Ver = Pkg.VersionList();; ++Ver)

         {
            // try first only exact matches, later fuzzy matches
            if (Ver.end() == true)
         {
            // try first only exact matches, later fuzzy matches
            if (Ver.end() == true)


@@ -1470,7 +1519,7 @@ pkgSrcRecords::Parser *FindSrc(const char *Name,pkgRecords &Recs,
               continue;
 
            for (pkgCache::VerFileIterator VF = Ver.FileList();
               continue;
 
            for (pkgCache::VerFileIterator VF = Ver.FileList();

-                VF.end() == false; VF++) 
+                VF.end() == false; ++VF)

            {
               /* If this is the status file, and the current version is not the
                  version in the status file (ie it is not installed, or somesuch)
            {
               /* If this is the status file, and the current version is not the
                  version in the status file (ie it is not installed, or somesuch)


@@ -1622,7 +1671,7 @@ bool DoUpdate(CommandLine &CmdL)
         return false;
 
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
         return false;
 
       pkgAcquire::UriIterator I = Fetcher.UriBegin();

-      for (; I != Fetcher.UriEnd(); I++)
+      for (; I != Fetcher.UriEnd(); ++I)

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;


@@ -1632,10 +1681,14 @@ bool DoUpdate(CommandLine &CmdL)
    if (_config->FindB("APT::Get::Download",true) == true)
        ListUpdate(Stat, *List);
 
    if (_config->FindB("APT::Get::Download",true) == true)
        ListUpdate(Stat, *List);
 

-   // Rebuild the cache.   
-   if (Cache.BuildCaches() == false)
-      return false;
-   
+   // Rebuild the cache.
+   if (_config->FindB("pkgCacheFile::Generate", true) == true)
+   {
+      pkgCacheFile::RemoveCaches();
+      if (Cache.BuildCaches() == false)
+        return false;
+   }
+

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


@@ -1664,12 +1717,13 @@ bool DoAutomaticRemove(CacheFile &Cache)
    bool smallList = (hideAutoRemove == false &&
                strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
 
    bool smallList = (hideAutoRemove == false &&
                strcasecmp(_config->Find("APT::Get::HideAutoRemove","").c_str(),"small") == 0);
 

-   string autoremovelist, autoremoveversions;

    unsigned long autoRemoveCount = 0;
    APT::PackageSet tooMuch;
    unsigned long autoRemoveCount = 0;
    APT::PackageSet tooMuch;

+   APT::PackageList autoRemoveList;

    // look over the cache to see what can be removed
    // look over the cache to see what can be removed

-   for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); ! Pkg.end(); ++Pkg)
+   for (unsigned J = 0; J < Cache->Head().PackageCount; ++J)

    {
    {

+      pkgCache::PkgIterator Pkg(Cache,Cache.List[J]);

       if (Cache[Pkg].Garbage)
       {
         if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
       if (Cache[Pkg].Garbage)
       {
         if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())


@@ -1686,24 +1740,19 @@ bool DoAutomaticRemove(CacheFile &Cache)
         }
         else
         {
         }
         else
         {

+           if (hideAutoRemove == false && Cache[Pkg].Delete() == false)
+              autoRemoveList.insert(Pkg);

            // if the package is a new install and already garbage we don't need to
            // install it in the first place, so nuke it instead of show it
            if (Cache[Pkg].Install() == true && Pkg.CurrentVer() == 0)
            {
            // if the package is a new install and already garbage we don't need to
            // install it in the first place, so nuke it instead of show it
            if (Cache[Pkg].Install() == true && Pkg.CurrentVer() == 0)
            {

+              if (Pkg.CandVersion() != 0)
+                 tooMuch.insert(Pkg);

               Cache->MarkDelete(Pkg, false);
               Cache->MarkDelete(Pkg, false);

-              tooMuch.insert(Pkg);

            }
            // only show stuff in the list that is not yet marked for removal
            }
            // only show stuff in the list that is not yet marked for removal

-           else if(hideAutoRemove == false && Cache[Pkg].Delete() == false) 
-           {
+           else if(hideAutoRemove == false && Cache[Pkg].Delete() == false)

               ++autoRemoveCount;
               ++autoRemoveCount;

-              // we don't need to fill the strings if we don't need them
-              if (smallList == false)
-              {
-                autoremovelist += Pkg.FullName(true) + " ";
-                autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
-              }
-           }

         }
       }
    }
         }
       }
    }


@@ -1715,38 +1764,51 @@ bool DoAutomaticRemove(CacheFile &Cache)
       bool Changed;
       do {
         Changed = false;
       bool Changed;
       do {
         Changed = false;

-        for (APT::PackageSet::const_iterator P = tooMuch.begin();
-             P != tooMuch.end() && Changed == false; ++P)
+        for (APT::PackageSet::const_iterator Pkg = tooMuch.begin();
+             Pkg != tooMuch.end() && Changed == false; ++Pkg)

         {
         {

-           for (pkgCache::DepIterator R = P.RevDependsList();
-                R.end() == false; ++R)
-           {
-              if (R.IsNegative() == true ||
-                  Cache->IsImportantDep(R) == false)
-                 continue;
-              pkgCache::PkgIterator N = R.ParentPkg();
-              if (N.end() == true || (N->CurrentVer == 0 && (*Cache)[N].Install() == false))
-                 continue;
-              if (Debug == true)
-                 std::clog << "Save " << P << " as another installed garbage package depends on it" << std::endl;
-              Cache->MarkInstall(P, false);
-              if(hideAutoRemove == false)
+           APT::PackageSet too;
+           too.insert(*Pkg);
+           for (pkgCache::PrvIterator Prv = Cache[Pkg].CandidateVerIter(Cache).ProvidesList();
+                Prv.end() == false; ++Prv)
+              too.insert(Prv.ParentPkg());
+           for (APT::PackageSet::const_iterator P = too.begin();
+                P != too.end() && Changed == false; ++P) {
+              for (pkgCache::DepIterator R = P.RevDependsList();
+                   R.end() == false; ++R)

               {
               {

-                 ++autoRemoveCount;
-                 if (smallList == false)
-                 {
-                    autoremovelist += P.FullName(true) + " ";
-                    autoremoveversions += string(Cache[P].CandVersion) + "\n";
-                 }
+                 if (R.IsNegative() == true ||
+                     Cache->IsImportantDep(R) == false)
+                    continue;
+                pkgCache::PkgIterator N = R.ParentPkg();
+                if (N.end() == true || (N->CurrentVer == 0 && (*Cache)[N].Install() == false))
+                   continue;
+                if (Debug == true)
+                   std::clog << "Save " << Pkg << " as another installed garbage package depends on it" << std::endl;
+                Cache->MarkInstall(Pkg, false);
+                if (hideAutoRemove == false)
+                   ++autoRemoveCount;
+                tooMuch.erase(Pkg);
+                Changed = true;
+                break;

               }
               }

-              tooMuch.erase(P);
-              Changed = true;
-              break;

            }
         }
       } while (Changed == true);
    }
 
            }
         }
       } while (Changed == true);
    }
 

+   std::string autoremovelist, autoremoveversions;
+   if (smallList == false && autoRemoveCount != 0)
+   {
+      for (APT::PackageList::const_iterator Pkg = autoRemoveList.begin(); Pkg != autoRemoveList.end(); ++Pkg)
+      {
+        if (Cache[Pkg].Garbage == false)
+           continue;
+        autoremovelist += Pkg.FullName(true) + " ";
+        autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
+      }
+   }
+

    // Now see if we had destroyed anything (if we had done anything)
    if (Cache->BrokenCount() != 0)
    {
    // Now see if we had destroyed anything (if we had done anything)
    if (Cache->BrokenCount() != 0)
    {


@@ -1770,7 +1832,7 @@ bool DoAutomaticRemove(CacheFile &Cache)
       else
         ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
                  "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
       else
         ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
                  "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);

-      c1out << _("Use 'apt-get autoremove' to remove them.") << std::endl;
+      c1out << P_("Use 'apt-get autoremove' to remove it.", "Use 'apt-get autoremove' to remove them.", autoRemoveCount) << std::endl;

    }
    return true;
 }
    }
    return true;
 }


@@ -2007,7 +2069,7 @@ bool DoInstall(CommandLine &CmdL)
               if(Start.TargetPkg().ProvidesList() != 0)
               {
                  pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();
               if(Start.TargetPkg().ProvidesList() != 0)
               {
                  pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();

-                 for (; I.end() == false; I++)
+                 for (; I.end() == false; ++I)

                  {
                     pkgCache::PkgIterator Pkg = I.OwnerPkg();
                     if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() && 
                  {
                     pkgCache::PkgIterator Pkg = I.OwnerPkg();
                     if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() && 


@@ -2030,7 +2092,7 @@ bool DoInstall(CommandLine &CmdL)
 
               if (Start >= End)
                  break;
 
               if (Start >= End)
                  break;

-              Start++;
+              ++Start;

            }
            
            if(foundInstalledInOrGroup == false)
            }
            
            if(foundInstalledInOrGroup == false)


@@ -2144,7 +2206,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
 
    // Install everything with the install flag set
    pkgCache::PkgIterator I = Cache->PkgBegin();
 
    // Install everything with the install flag set
    pkgCache::PkgIterator I = Cache->PkgBegin();

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

    {
       /* Install the package only if it is a new install, the autoupgrader
          will deal with the rest */
    {
       /* Install the package only if it is a new install, the autoupgrader
          will deal with the rest */


@@ -2154,7 +2216,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
 
    /* Now install their deps too, if we do this above then order of
       the status file is significant for | groups */
 
    /* Now install their deps too, if we do this above then order of
       the status file is significant for | groups */

-   for (I = Cache->PkgBegin();I.end() != true; I++)
+   for (I = Cache->PkgBegin();I.end() != true; ++I)

    {
       /* Install the package only if it is a new install, the autoupgrader
          will deal with the rest */
    {
       /* Install the package only if it is a new install, the autoupgrader
          will deal with the rest */


@@ -2163,7 +2225,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
    }
    
    // Apply erasures now, they override everything else.
    }
    
    // Apply erasures now, they override everything else.

-   for (I = Cache->PkgBegin();I.end() != true; I++)
+   for (I = Cache->PkgBegin();I.end() != true; ++I)

    {
       // Remove packages 
       if (I->SelectedState == pkgCache::State::DeInstall ||
    {
       // Remove packages 
       if (I->SelectedState == pkgCache::State::DeInstall ||


@@ -2180,7 +2242,7 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
       // Hold back held packages.
       if (_config->FindB("APT::Ignore-Hold",false) == false)
       {
       // Hold back held packages.
       if (_config->FindB("APT::Ignore-Hold",false) == false)
       {

-        for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; I++)
+        for (pkgCache::PkgIterator I = Cache->PkgBegin(); I.end() == false; ++I)

         {
            if (I->SelectedState == pkgCache::State::Hold)
            {
         {
            if (I->SelectedState == pkgCache::State::Hold)
            {


@@ -2212,10 +2274,14 @@ bool DoDSelectUpgrade(CommandLine &CmdL)
 /* */
 bool DoClean(CommandLine &CmdL)
 {
 /* */
 bool DoClean(CommandLine &CmdL)
 {

+   std::string const archivedir = _config->FindDir("Dir::Cache::archives");
+   std::string const pkgcache = _config->FindFile("Dir::cache::pkgcache");
+   std::string const srcpkgcache = _config->FindFile("Dir::cache::srcpkgcache");
+

    if (_config->FindB("APT::Get::Simulate") == true)
    {
    if (_config->FindB("APT::Get::Simulate") == true)
    {

-      cout << "Del " << _config->FindDir("Dir::Cache::archives") << "* " <<
-        _config->FindDir("Dir::Cache::archives") << "partial/*" << endl;
+      cout << "Del " << archivedir << "* " << archivedir << "partial/*"<< endl
+          << "Del " << pkgcache << " " << srcpkgcache << endl;

       return true;
    }
    
       return true;
    }
    


@@ -2223,14 +2289,17 @@ bool DoClean(CommandLine &CmdL)
    FileFd Lock;
    if (_config->FindB("Debug::NoLocking",false) == false)
    {
    FileFd Lock;
    if (_config->FindB("Debug::NoLocking",false) == false)
    {

-      Lock.Fd(GetLock(_config->FindDir("Dir::Cache::Archives") + "lock"));
+      Lock.Fd(GetLock(archivedir + "lock"));

       if (_error->PendingError() == true)
         return _error->Error(_("Unable to lock the download directory"));
    }
    
    pkgAcquire Fetcher;
       if (_error->PendingError() == true)
         return _error->Error(_("Unable to lock the download directory"));
    }
    
    pkgAcquire Fetcher;

-   Fetcher.Clean(_config->FindDir("Dir::Cache::archives"));
-   Fetcher.Clean(_config->FindDir("Dir::Cache::archives") + "partial/");
+   Fetcher.Clean(archivedir);
+   Fetcher.Clean(archivedir + "partial/");
+
+   pkgCacheFile::RemoveCaches();
+

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


@@ -2280,8 +2349,8 @@ bool DoDownload(CommandLine &CmdL)
       return false;
    
    APT::CacheSetHelper helper(c0out);
       return false;
    
    APT::CacheSetHelper helper(c0out);

-   APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
-               CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
+   APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
+               CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);

 
    if (verset.empty() == true)
       return false;
 
    if (verset.empty() == true)
       return false;


@@ -2293,7 +2362,7 @@ bool DoDownload(CommandLine &CmdL)
 
    pkgRecords Recs(Cache);
    pkgSourceList *SrcList = Cache.GetSourceList();
 
    pkgRecords Recs(Cache);
    pkgSourceList *SrcList = Cache.GetSourceList();

-   for (APT::VersionSet::const_iterator Ver = verset.begin(); 
+   for (APT::VersionList::const_iterator Ver = verset.begin(); 

         Ver != verset.end(); 
         ++Ver) 
    {
         Ver != verset.end(); 
         ++Ver) 
    {


@@ -2328,7 +2397,7 @@ bool DoDownload(CommandLine &CmdL)
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();

-      for (; I != Fetcher.UriEnd(); I++)
+      for (; I != Fetcher.UriEnd(); ++I)

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       return true;


@@ -2430,7 +2499,7 @@ bool DoSource(CommandLine &CmdL)
                  Src.c_str(), vcs.c_str(), uri.c_str());
         if(vcs == "Bzr") 
            ioprintf(c1out,_("Please use:\n"
                  Src.c_str(), vcs.c_str(), uri.c_str());
         if(vcs == "Bzr") 
            ioprintf(c1out,_("Please use:\n"

-                            "bzr get %s\n"
+                            "bzr branch %s\n"

                             "to retrieve the latest (possibly unreleased) "
                             "updates to the package.\n"),
                     uri.c_str());
                             "to retrieve the latest (possibly unreleased) "
                             "updates to the package.\n"),
                     uri.c_str());


@@ -2446,7 +2515,7 @@ bool DoSource(CommandLine &CmdL)
 
       // Load them into the fetcher
       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();
 
       // Load them into the fetcher
       for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();

-          I != Lst.end(); I++)
+          I != Lst.end(); ++I)

       {
         // Try to guess what sort of file it is we are getting.
         if (I->Type == "dsc")
       {
         // Try to guess what sort of file it is we are getting.
         if (I->Type == "dsc")


@@ -2548,7 +2617,7 @@ bool DoSource(CommandLine &CmdL)
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();
    if (_config->FindB("APT::Get::Print-URIs") == true)
    {
       pkgAcquire::UriIterator I = Fetcher.UriBegin();

-      for (; I != Fetcher.UriEnd(); I++)
+      for (; I != Fetcher.UriEnd(); ++I)

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       delete[] Dsc;
         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 
               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
       delete[] Dsc;


@@ -2564,7 +2633,7 @@ bool DoSource(CommandLine &CmdL)
 
    // Print error messages
    bool Failed = false;
 
    // Print error messages
    bool Failed = false;

-   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); I++)
+   for (pkgAcquire::ItemIterator I = Fetcher.ItemsBegin(); I != Fetcher.ItemsEnd(); ++I)

    {
       if ((*I)->Status == pkgAcquire::Item::StatDone &&
          (*I)->Complete == true)
    {
       if ((*I)->Status == pkgAcquire::Item::StatDone &&
          (*I)->Complete == true)


@@ -2593,7 +2662,7 @@ bool DoSource(CommandLine &CmdL)
    if (Process == 0)
    {
       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);
    if (Process == 0)
    {
       bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);

-      for (unsigned I = 0; I != J; I++)
+      for (unsigned I = 0; I != J; ++I)

       {
         string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
         
       {
         string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());
         


@@ -2723,8 +2792,18 @@ bool DoBuildDep(CommandLine &CmdL)
             
       // Process the build-dependencies
       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
             
       // Process the build-dependencies
       vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;

-      if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
-       return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
+      // FIXME: Can't specify architecture to use for [wildcard] matching, so switch default arch temporary
+      if (hostArch.empty() == false)
+      {
+        std::string nativeArch = _config->Find("APT::Architecture");
+        _config->Set("APT::Architecture", hostArch);
+        bool Success = Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch);
+        _config->Set("APT::Architecture", nativeArch);
+        if (Success == false)
+           return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
+      }
+      else if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only", false), StripMultiArch) == false)
+           return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());

    
       // Also ensure that build-essential packages are present
       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");
    
       // Also ensure that build-essential packages are present
       Configuration::Item const *Opts = _config->Tree("APT::Build-Essential");


@@ -2742,7 +2821,7 @@ bool DoBuildDep(CommandLine &CmdL)
         BuildDeps.push_back(rec);
       }
 
         BuildDeps.push_back(rec);
       }
 

-      if (BuildDeps.size() == 0)
+      if (BuildDeps.empty() == true)

       {
         ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
         continue;
       {
         ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());
         continue;


@@ -2752,7 +2831,7 @@ bool DoBuildDep(CommandLine &CmdL)
       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
       pkgProblemResolver Fix(Cache);
       bool skipAlternatives = false; // skip remaining alternatives in an or group
       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
       pkgProblemResolver Fix(Cache);
       bool skipAlternatives = false; // skip remaining alternatives in an or group

-      for (D = BuildDeps.begin(); D != BuildDeps.end(); D++)
+      for (D = BuildDeps.begin(); D != BuildDeps.end(); ++D)

       {
          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
 
       {
          bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);
 


@@ -2801,7 +2880,7 @@ bool DoBuildDep(CommandLine &CmdL)
            pkgCache::PkgIterator Pkg;
 
            // Cross-Building?
            pkgCache::PkgIterator Pkg;
 
            // Cross-Building?

-           if (StripMultiArch == false)
+           if (StripMultiArch == false && D->Type != pkgSrcRecords::Parser::BuildDependIndep)

            {
               size_t const colon = D->Package.find(":");
               if (colon != string::npos &&
            {
               size_t const colon = D->Package.find(":");
               if (colon != string::npos &&


@@ -2810,48 +2889,63 @@ bool DoBuildDep(CommandLine &CmdL)
               else
                  Pkg = Cache->FindPkg(D->Package);
 
               else
                  Pkg = Cache->FindPkg(D->Package);
 

-              // We need to decide if host or build arch, so find a version we can look at
-              pkgCache::VerIterator Ver;
-

               // a bad version either is invalid or doesn't satify dependency
               // a bad version either is invalid or doesn't satify dependency

-              #define BADVER(Ver) Ver.end() == true || \
-                                  (Ver.end() == false && D->Version.empty() == false && \
-                                   Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false)
+              #define BADVER(Ver) (Ver.end() == true || \
+                                   (D->Version.empty() == false && \
+                                    Cache->VS().CheckDep(Ver.VerStr(),D->Op,D->Version.c_str()) == false))

 
 

+              APT::VersionList verlist;

               if (Pkg.end() == false)
               {
               if (Pkg.end() == false)
               {

-                 Ver = (*Cache)[Pkg].InstVerIter(*Cache);
-                 if (BADVER(Ver))
-                    Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
+                 pkgCache::VerIterator Ver = (*Cache)[Pkg].InstVerIter(*Cache);
+                 if (BADVER(Ver) == false)
+                    verlist.insert(Ver);
+                 Ver = (*Cache)[Pkg].CandidateVerIter(*Cache);
+                 if (BADVER(Ver) == false)
+                    verlist.insert(Ver);

               }
               }

-              if (BADVER(Ver))
+              if (verlist.empty() == true)

               {
                  pkgCache::PkgIterator HostPkg = Cache->FindPkg(D->Package, hostArch);
                  if (HostPkg.end() == false)
                  {
               {
                  pkgCache::PkgIterator HostPkg = Cache->FindPkg(D->Package, hostArch);
                  if (HostPkg.end() == false)
                  {

-                    Ver = (*Cache)[HostPkg].InstVerIter(*Cache);
-                    if (BADVER(Ver))
-                       Ver = (*Cache)[HostPkg].CandidateVerIter(*Cache);
+                    pkgCache::VerIterator Ver = (*Cache)[HostPkg].InstVerIter(*Cache);
+                    if (BADVER(Ver) == false)
+                       verlist.insert(Ver);
+                    Ver = (*Cache)[HostPkg].CandidateVerIter(*Cache);
+                    if (BADVER(Ver) == false)
+                       verlist.insert(Ver);

                  }
               }
                  }
               }

-              if ((BADVER(Ver)) == false)
+              #undef BADVER
+
+              string forbidden;
+              // We need to decide if host or build arch, so find a version we can look at
+              APT::VersionList::const_iterator Ver = verlist.begin();
+              for (; Ver != verlist.end(); ++Ver)

               {
               {

-                 string forbidden;
-                 if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All);
+                 forbidden.clear();
+                 if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
+                 {
+                    if (colon == string::npos)
+                       Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
+                    else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
+                       forbidden = "Multi-Arch: none";
+                 }

                  else if (Ver->MultiArch == pkgCache::Version::Same)
                  {
                  else if (Ver->MultiArch == pkgCache::Version::Same)
                  {

-                    if (colon != string::npos)
+                    if (colon == string::npos)

                        Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
                     else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
                        forbidden = "Multi-Arch: same";
                     // :native gets the buildArch
                  }
                        Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
                     else if (strcmp(D->Package.c_str() + colon, ":any") == 0)
                        forbidden = "Multi-Arch: same";
                     // :native gets the buildArch
                  }

-                 else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign)
+                 else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)

                  {
                     if (colon != string::npos)
                        forbidden = "Multi-Arch: foreign";
                  }
                  {
                     if (colon != string::npos)
                        forbidden = "Multi-Arch: foreign";
                  }

-                 else if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed)
+                 else if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)

                  {
                     if (colon == string::npos)
                        Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
                  {
                     if (colon == string::npos)
                        Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);


@@ -2868,21 +2962,32 @@ bool DoBuildDep(CommandLine &CmdL)
                     }
                     // native gets buildArch
                  }
                     }
                     // native gets buildArch
                  }

+

                  if (forbidden.empty() == false)
                  {
                     if (_config->FindB("Debug::BuildDeps",false) == true)
                  if (forbidden.empty() == false)
                  {
                     if (_config->FindB("Debug::BuildDeps",false) == true)

-                       cout << " :any is not allowed from M-A: same package " << (*D).Package << endl;
+                       cout << D->Package.substr(colon, string::npos) << " is not allowed from " << forbidden << " package " << (*D).Package << " (" << Ver.VerStr() << ")" << endl;
+                    continue;
+                 }
+
+                 //we found a good version
+                 break;
+              }
+              if (Ver == verlist.end())
+              {
+                 if (_config->FindB("Debug::BuildDeps",false) == true)
+                    cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
+
+                 if (forbidden.empty() == false)
+                 {

                     if (hasAlternatives)
                        continue;
                     return _error->Error(_("%s dependency for %s can't be satisfied "
                                            "because %s is not allowed on '%s' packages"),
                                          Last->BuildDepType(D->Type), Src.c_str(),
                     if (hasAlternatives)
                        continue;
                     return _error->Error(_("%s dependency for %s can't be satisfied "
                                            "because %s is not allowed on '%s' packages"),
                                          Last->BuildDepType(D->Type), Src.c_str(),

-                                         D->Package.c_str(), "Multi-Arch: same");
+                                         D->Package.c_str(), forbidden.c_str());

                  }
               }
                  }
               }

-              else if (_config->FindB("Debug::BuildDeps",false) == true)
-                 cout << " No multiarch info as we have no satisfying installed nor candidate for " << D->Package << " on build or host arch" << endl;
-              #undef BADVER

            }
            else
               Pkg = Cache->FindPkg(D->Package);
            }
            else
               Pkg = Cache->FindPkg(D->Package);


@@ -2931,7 +3036,7 @@ bool DoBuildDep(CommandLine &CmdL)
                * installed
                */
               pkgCache::PrvIterator Prv = Pkg.ProvidesList();
                * installed
                */
               pkgCache::PrvIterator Prv = Pkg.ProvidesList();

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

               {
                  if (_config->FindB("Debug::BuildDeps",false) == true)
                     cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;
               {
                  if (_config->FindB("Debug::BuildDeps",false) == true)
                     cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;


@@ -3152,16 +3257,20 @@ bool DoChangelog(CommandLine &CmdL)
       return false;
    
    APT::CacheSetHelper helper(c0out);
       return false;
    
    APT::CacheSetHelper helper(c0out);

-   APT::VersionSet verset = APT::VersionSet::FromCommandLine(Cache,
-               CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
+   APT::VersionList verset = APT::VersionList::FromCommandLine(Cache,
+               CmdL.FileList + 1, APT::VersionList::CANDIDATE, helper);

    if (verset.empty() == true)
       return false;
    pkgAcquire Fetcher;
 
    if (_config->FindB("APT::Get::Print-URIs", false) == true)
    if (verset.empty() == true)
       return false;
    pkgAcquire Fetcher;
 
    if (_config->FindB("APT::Get::Print-URIs", false) == true)

-      for (APT::VersionSet::const_iterator Ver = verset.begin();
+   {
+      bool Success = true;
+      for (APT::VersionList::const_iterator Ver = verset.begin();

           Ver != verset.end(); ++Ver)
           Ver != verset.end(); ++Ver)

-        return DownloadChangelog(Cache, Fetcher, Ver, "");
+        Success &= DownloadChangelog(Cache, Fetcher, Ver, "");
+      return Success;
+   }

 
    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
    Fetcher.Setup(&Stat);
 
    AcqTextStatus Stat(ScreenWidth, _config->FindI("quiet",0));
    Fetcher.Setup(&Stat);


@@ -3182,7 +3291,7 @@ bool DoChangelog(CommandLine &CmdL)
         return _error->Errno("mkdtemp", "mkdtemp failed");
    }
 
         return _error->Errno("mkdtemp", "mkdtemp failed");
    }
 

-   for (APT::VersionSet::const_iterator Ver = verset.begin(); 
+   for (APT::VersionList::const_iterator Ver = verset.begin(); 

         Ver != verset.end(); 
         ++Ver) 
    {
         Ver != verset.end(); 
         ++Ver) 
    {


@@ -3226,7 +3335,7 @@ bool DoMoo(CommandLine &CmdL)
 /* */
 bool ShowHelp(CommandLine &CmdL)
 {
 /* */
 bool ShowHelp(CommandLine &CmdL)
 {

-   ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
+   ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,PACKAGE_VERSION,

            COMMON_ARCH,__DATE__,__TIME__);
            
    if (_config->FindB("version") == true)
            COMMON_ARCH,__DATE__,__TIME__);
            
    if (_config->FindB("version") == true)