the previously used VERSION didn't work everywhere so we are switching

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

diff --git a/cmdline/apt-get.cc b/cmdline/apt-get.cc
index 69b9dcda947e6b827667e8fd361774840845ac15..ac1566f307ba566f497f79937d6bf582cacb8f58 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


@@ -135,6 +135,11 @@ bool YnPrompt(bool Default=true)
       c1out << _("Y") << endl;
       return true;
    }
       c1out << _("Y") << endl;
       return true;
    }

+   else if (_config->FindB("APT::Get::Assume-No",false) == true)
+   {
+      c1out << _("N") << endl;
+      return false;
+   }

 
    char response[1024] = "";
    cin.getline(response, sizeof(response));
 
    char response[1024] = "";
    cin.getline(response, sizeof(response));


@@ -623,20 +628,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));


@@ -657,22 +660,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)
                                        for (I = Pkg.ProvidesList(); I.end() == false; ++I)
                                                ++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()
+                                               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());


@@ -691,9 +694,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;
        }


@@ -702,7 +705,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);
                }


@@ -710,11 +713,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);
        }
 


@@ -739,6 +763,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;
                        }


@@ -764,7 +801,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) {


@@ -888,7 +925,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;
       }


@@ -1684,8 +1737,9 @@ bool DoAutomaticRemove(CacheFile &Cache)
            // install it in the first place, so nuke it instead of show it
            if (Cache[Pkg].Install() == true && Pkg.CurrentVer() == 0)
            {
            // 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
            else if(hideAutoRemove == false && Cache[Pkg].Delete() == false) 
            }
            // only show stuff in the list that is not yet marked for removal
            else if(hideAutoRemove == false && Cache[Pkg].Delete() == false) 


@@ -1709,33 +1763,41 @@ 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;
+                   if (smallList == false)
+                   {
+                      autoremovelist += Pkg.FullName(true) + " ";
+                      autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
+                   }
+                }
+                tooMuch.erase(Pkg);
+                Changed = true;
+                break;

               }
               }

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

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


@@ -1893,8 +1955,7 @@ bool DoInstall(CommandLine &CmdL)
       {
         // Call the scored problem resolver
         Fix->InstallProtect();
       {
         // Call the scored problem resolver
         Fix->InstallProtect();

-        if (Fix->Resolve(true) == false)
-           _error->Discard();
+        Fix->Resolve(true);

         delete Fix;
       }
 
         delete Fix;
       }
 


@@ -1920,8 +1981,11 @@ bool DoInstall(CommandLine &CmdL)
         c1out << _("The following information may help to resolve the situation:") << endl;
         c1out << endl;
         ShowBroken(c1out,Cache,false);
         c1out << _("The following information may help to resolve the situation:") << endl;
         c1out << endl;
         ShowBroken(c1out,Cache,false);

-        return _error->Error(_("Broken packages"));
-      }   
+        if (_error->PendingError() == true)
+           return false;
+        else
+           return _error->Error(_("Broken packages"));
+      }

    }
    if (!DoAutomaticRemove(Cache)) 
       return false;
    }
    if (!DoAutomaticRemove(Cache)) 
       return false;


@@ -2279,8 +2343,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;


@@ -2292,7 +2356,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) 
    {


@@ -2311,6 +2375,8 @@ bool DoDownload(CommandLine &CmdL)
       strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
       // get the most appropriate hash
       HashString hash;
       strprintf(descr, _("Downloading %s %s"), Pkg.Name(), Ver.VerStr());
       // get the most appropriate hash
       HashString hash;

+      if (rec.SHA512Hash() != "")
+         hash = HashString("sha512", rec.SHA512Hash());

       if (rec.SHA256Hash() != "")
          hash = HashString("sha256", rec.SHA256Hash());
       else if (rec.SHA1Hash() != "")
       if (rec.SHA256Hash() != "")
          hash = HashString("sha256", rec.SHA256Hash());
       else if (rec.SHA1Hash() != "")


@@ -2834,21 +2900,27 @@ bool DoBuildDep(CommandLine &CmdL)
               if ((BADVER(Ver)) == false)
               {
                  string forbidden;
               if ((BADVER(Ver)) == false)
               {
                  string forbidden;

-                 if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All);
+                 if (Ver->MultiArch == pkgCache::Version::None || Ver->MultiArch == pkgCache::Version::All)
+                 {
+                    if (colon == string::npos)
+                    {
+                       Pkg = Ver.ParentPkg().Group().FindPkg(hostArch);
+                    }
+                 }

                  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);


@@ -3149,14 +3221,14 @@ 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();
+      for (APT::VersionList::const_iterator Ver = verset.begin();

           Ver != verset.end(); ++Ver)
         return DownloadChangelog(Cache, Fetcher, Ver, "");
 
           Ver != verset.end(); ++Ver)
         return DownloadChangelog(Cache, Fetcher, Ver, "");
 


@@ -3179,7 +3251,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) 
    {


@@ -3223,7 +3295,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)


@@ -3345,7 +3417,8 @@ int main(int argc,const char *argv[])                                     /*{{{*/
       {'s',"dry-run","APT::Get::Simulate",0},
       {'s',"no-act","APT::Get::Simulate",0},
       {'y',"yes","APT::Get::Assume-Yes",0},
       {'s',"dry-run","APT::Get::Simulate",0},
       {'s',"no-act","APT::Get::Simulate",0},
       {'y',"yes","APT::Get::Assume-Yes",0},

-      {'y',"assume-yes","APT::Get::Assume-Yes",0},      
+      {'y',"assume-yes","APT::Get::Assume-Yes",0},
+      {0,"assume-no","APT::Get::Assume-No",0},

       {'f',"fix-broken","APT::Get::Fix-Broken",0},
       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
       {'m',"ignore-missing","APT::Get::Fix-Missing",0},
       {'f',"fix-broken","APT::Get::Fix-Broken",0},
       {'u',"show-upgraded","APT::Get::Show-Upgraded",0},
       {'m',"ignore-missing","APT::Get::Fix-Missing",0},


@@ -3375,6 +3448,7 @@ int main(int argc,const char *argv[])                                     /*{{{*/
       {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
       {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean},
       {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},
       {0,"install-recommends","APT::Install-Recommends",CommandLine::Boolean},
       {0,"install-suggests","APT::Install-Suggests",CommandLine::Boolean},
       {0,"fix-policy","APT::Get::Fix-Policy-Broken",0},

+      {0,"solver","APT::Solver",CommandLine::HasArg},

       {'c',"config-file",0,CommandLine::ConfigFile},
       {'o',"option",0,CommandLine::ArbItem},
       {0,0,0,0}};
       {'c',"config-file",0,CommandLine::ConfigFile},
       {'o',"option",0,CommandLine::ArbItem},
       {0,0,0,0}};