* [ABI BREAK] apt-pkg/pkgcache.h:

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

diff --git a/apt-pkg/edsp.cc b/apt-pkg/edsp.cc
index 489dd293336a3c4a47b17b6a787bfb69e4644e4a..6ce9da784ee9b8d0b923b84b9220fe1569fc8ea2 100644 (file)
--- a/apt-pkg/edsp.cc
+++ b/apt-pkg/edsp.cc
@@ -5,19 +5,28 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
+#include <config.h>
+
 #include <apt-pkg/edsp.h>
 #include <apt-pkg/error.h>
+#include <apt-pkg/cacheset.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/policy.h>
 #include <apt-pkg/tagfile.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/progress.h>
 
-#include <apti18n.h>
 #include <limits>
-
 #include <stdio.h>
+
+#include <string>
+
+#include <apti18n.h>
                                                                        /*}}}*/
 
+using std::string;
+
 // we could use pkgCache::DepType and ::Priority, but these would be localized strings…
 const char * const EDSP::PrioMap[] = {0, "important", "required", "standard",
                                      "optional", "extra"};
@@ -82,11 +91,11 @@ void EDSP::WriteScenarioVersion(pkgDepCache &Cache, FILE* output, pkgCache::PkgI
    if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
       fprintf(output, "Essential: yes\n");
    fprintf(output, "Section: %s\n", Ver.Section());
-   if (Ver->MultiArch == pkgCache::Version::Allowed || Ver->MultiArch == pkgCache::Version::AllAllowed)
+   if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed)
       fprintf(output, "Multi-Arch: allowed\n");
-   else if (Ver->MultiArch == pkgCache::Version::Foreign || Ver->MultiArch == pkgCache::Version::AllForeign)
+   else if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
       fprintf(output, "Multi-Arch: foreign\n");
-   else if (Ver->MultiArch == pkgCache::Version::Same)
+   else if ((Ver->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
       fprintf(output, "Multi-Arch: same\n");
    signed short Pin = std::numeric_limits<signed short>::min();
    for (pkgCache::VerFileIterator File = Ver.FileList(); File.end() == false; ++File) {
@@ -109,8 +118,7 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
-      // Ignore implicit dependencies for multiarch here
-      if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
+      if (Dep.IsMultiArchImplicit() == true)
         continue;
       if (orGroup == false)
         dependencies[Dep->Type].append(", ");
@@ -131,8 +139,7 @@ void EDSP::WriteScenarioDependency(pkgDepCache &Cache, FILE* output, pkgCache::P
    string provides;
    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
    {
-      // Ignore implicit provides for multiarch here
-      if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0)
+      if (Prv.IsMultiArchImplicit() == true)
         continue;
       provides.append(", ").append(Prv.Name());
    }
@@ -150,8 +157,7 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
    bool orGroup = false;
    for (pkgCache::DepIterator Dep = Ver.DependsList(); Dep.end() == false; ++Dep)
    {
-      // Ignore implicit dependencies for multiarch here
-      if (strcmp(Pkg.Arch(), Dep.TargetPkg().Arch()) != 0)
+      if (Dep.IsMultiArchImplicit() == true)
         continue;
       if (orGroup == false)
       {
@@ -184,8 +190,7 @@ void EDSP::WriteScenarioLimitedDependency(pkgDepCache &Cache, FILE* output,
    string provides;
    for (pkgCache::PrvIterator Prv = Ver.ProvidesList(); Prv.end() == false; ++Prv)
    {
-      // Ignore implicit provides for multiarch here
-      if (strcmp(Pkg.Arch(), Prv.ParentPkg().Arch()) != 0 || strcmp(Pkg.Name(),Prv.Name()) == 0)
+      if (Prv.IsMultiArchImplicit() == true)
         continue;
       if (pkgset.find(Prv.ParentPkg()) == pkgset.end())
         continue;
@@ -209,9 +214,11 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
       if (Progress != NULL && p % 100 == 0)
          Progress->Progress(p);
       string* req;
-      if (Cache[Pkg].Delete() == true)
+      pkgDepCache::StateCache &P = Cache[Pkg];
+      if (P.Delete() == true)
         req = &del;
-      else if (Cache[Pkg].NewInstall() == true || Cache[Pkg].Upgrade() == true)
+      else if (P.NewInstall() == true || P.Upgrade() == true || P.ReInstall() == true ||
+              (P.Mode == pkgDepCache::ModeKeep && (P.iFlags & pkgDepCache::Protected) == pkgDepCache::Protected))
         req = &inst;
       else
         continue;
@@ -231,7 +238,7 @@ bool EDSP::WriteRequest(pkgDepCache &Cache, FILE* output, bool const Upgrade,
    if (_config->FindB("APT::Solver::Strict-Pinning", true) == false)
       fprintf(output, "Strict-Pinning: no\n");
    string solverpref("APT::Solver::");
-   solverpref.append(_config->Find("APT::Solver::Name", "internal")).append("::Preferences");
+   solverpref.append(_config->Find("APT::Solver", "internal")).append("::Preferences");
    if (_config->Exists(solverpref) == true)
       fprintf(output, "Preferences: %s\n", _config->Find(solverpref,"").c_str());
    fprintf(output, "\n");
@@ -267,19 +274,25 @@ bool EDSP::ReadResponse(int const input, pkgDepCache &Cache, OpProgress *Progres
                        type = "Remove";
                else if (section.Exists("Progress") == true) {
                        if (Progress != NULL) {
-                               string const msg = section.FindS("Message");
+                               string msg = section.FindS("Message");
                                if (msg.empty() == true)
-                                       Progress->SubProgress(100, _("Prepare for receiving solution"));
-                               else
-                                       Progress->SubProgress(100, msg);
-                               Progress->Progress(section.FindI("Percentage", 0));
+                                       msg = _("Prepare for receiving solution");
+                               Progress->SubProgress(100, msg, section.FindI("Percentage", 0));
                        }
                        continue;
                } else if (section.Exists("Error") == true) {
+                       std::string msg = SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n");
+                       if (msg.empty() == true) {
+                               msg = _("External solver failed without a proper error message");
+                               _error->Error("%s", msg.c_str());
+                       } else
+                               _error->Error("External solver failed with: %s", msg.substr(0,msg.find('\n')).c_str());
+                       if (Progress != NULL)
+                               Progress->Done();
                        std::cerr << "The solver encountered an error of type: " << section.FindS("Error") << std::endl;
                        std::cerr << "The following information might help you to understand what is wrong:" << std::endl;
-                       std::cerr << SubstVar(SubstVar(section.FindS("Message"), "\n .\n", "\n\n"), "\n ", "\n") << std::endl << std::endl;
-                       break;
+                       std::cerr << msg << std::endl << std::endl;
+                       return false;
                } else if (section.Exists("Autoremove") == true)
                        type = "Autoremove";
                else
@@ -551,7 +564,7 @@ bool EDSP::ResolveExternal(const char* const solver, pkgDepCache &Cache,
        if (Progress != NULL)
                Progress->OverallProgress(25, 100, 75, _("Execute external solver"));
        if (EDSP::ReadResponse(solver_out, Cache, Progress) == false)
-               return _error->Error("Reading solver response failed");
+               return false;
 
        return true;
 }