Merge from CVS

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

diff --git a/cmdline/apt-get.cc b/cmdline/apt-get.cc
index b74bdbc4ad3ee3d4825b0482732057cb66ce9b4c..0d7e5239c9052a93e92b42bdb98a6975fd6e83f3 100644 (file)
--- a/cmdline/apt-get.cc
+++ b/cmdline/apt-get.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: apt-get.cc,v 1.141 2003/09/10 19:28:55 mdz Exp $
+// $Id: apt-get.cc,v 1.156 2004/08/28 01:05:16 mdz Exp $

 /* ######################################################################
    
    apt-get - Cover for dpkg
 /* ######################################################################
    
    apt-get - Cover for dpkg


@@ -270,7 +270,7 @@ void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
         // Compute a single dependency element (glob or)
         pkgCache::DepIterator Start;
         pkgCache::DepIterator End;
         // Compute a single dependency element (glob or)
         pkgCache::DepIterator Start;
         pkgCache::DepIterator End;

-        D.GlobOr(Start,End);
+        D.GlobOr(Start,End); // advances D

 
         if (Cache->IsImportantDep(End) == false)
            continue;
 
         if (Cache->IsImportantDep(End) == false)
            continue;


@@ -357,7 +357,7 @@ void ShowBroken(ostream &out,CacheFile &Cache,bool Now)
 /* */
 void ShowNew(ostream &out,CacheFile &Cache)
 {
 /* */
 void ShowNew(ostream &out,CacheFile &Cache)
 {

-   /* Print out a list of packages that are going to be removed extra
+   /* Print out a list of packages that are going to be installed extra

       to what the user asked */
    string List;
    string VersionsList;
       to what the user asked */
    string List;
    string VersionsList;


@@ -418,7 +418,7 @@ void ShowKept(ostream &out,CacheFile &Cache)
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }

-   ShowList(out,_("The following packages have been kept back"),List,VersionsList);
+   ShowList(out,_("The following packages have been kept back:"),List,VersionsList);

 }
                                                                        /*}}}*/
 // ShowUpgraded - Show upgraded packages                               /*{{{*/
 }
                                                                        /*}}}*/
 // ShowUpgraded - Show upgraded packages                               /*{{{*/


@@ -439,7 +439,7 @@ void ShowUpgraded(ostream &out,CacheFile &Cache)
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }

-   ShowList(out,_("The following packages will be upgraded"),List,VersionsList);
+   ShowList(out,_("The following packages will be upgraded:"),List,VersionsList);

 }
                                                                        /*}}}*/
 // ShowDowngraded - Show downgraded packages                           /*{{{*/
 }
                                                                        /*}}}*/
 // ShowDowngraded - Show downgraded packages                           /*{{{*/


@@ -460,7 +460,7 @@ bool ShowDowngraded(ostream &out,CacheFile &Cache)
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }
       List += string(I.Name()) + " ";
       VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
    }

-   return ShowList(out,_("The following packages will be DOWNGRADED"),List,VersionsList);
+   return ShowList(out,_("The following packages will be DOWNGRADED:"),List,VersionsList);

 }
                                                                        /*}}}*/
 // ShowHold - Show held but changed packages                           /*{{{*/
 }
                                                                        /*}}}*/
 // ShowHold - Show held but changed packages                           /*{{{*/


@@ -673,7 +673,7 @@ bool CacheFile::CheckDeps(bool AllowBroken)
 /* This displays the informative messages describing what is going to 
    happen and then calls the download routines */
 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
 /* This displays the informative messages describing what is going to 
    happen and then calls the download routines */
 bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,

-                    bool Saftey = true)
+                    bool Safety = true)

 {
    if (_config->FindB("APT::Get::Purge",false) == true)
    {
 {
    if (_config->FindB("APT::Get::Purge",false) == true)
    {


@@ -811,7 +811,7 @@ bool InstallPackages(CacheFile &Cache,bool ShwKept,bool Ask = true,
         return _error->Error(_("There are problems and -y was used without --force-yes"));
    }         
 
         return _error->Error(_("There are problems and -y was used without --force-yes"));
    }         
 

-   if (Essential == true && Saftey == true)
+   if (Essential == true && Safety == true)

    {
       if (_config->FindB("APT::Get::Trivial-Only",false) == true)
         return _error->Error(_("Trivial Only specified but this is not a trivial operation."));
    {
       if (_config->FindB("APT::Get::Trivial-Only",false) == true)
         return _error->Error(_("Trivial Only specified but this is not a trivial operation."));


@@ -1037,10 +1037,9 @@ bool TryToInstall(pkgCache::PkgIterator Pkg,pkgDepCache &Cache,
       else
       {
         ioprintf(c1out,
       else
       {
         ioprintf(c1out,

-        _("Package %s has no available version, but exists in the database.\n"
-          "This typically means that the package was mentioned in a dependency and\n"
-          "never uploaded, has been obsoleted or is not available with the contents\n"
-          "of sources.list\n"),Pkg.Name());
+        _("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.Name());

         
         string List;
         string VersionsList;
         
         string List;
         string VersionsList;


@@ -1533,69 +1532,60 @@ bool DoInstall(CommandLine &CmdL)
           continue;
 
         for (pkgCache::VerIterator V = I.VersionList(); V.end() == false; V++)
           continue;
 
         for (pkgCache::VerIterator V = I.VersionList(); V.end() == false; V++)

-          {
-            for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
-              {
+         {
+            for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; )
+             {

                 pkgCache::DepIterator Start;
                 pkgCache::DepIterator End;
                 pkgCache::DepIterator Start;
                 pkgCache::DepIterator End;

-                D.GlobOr(Start,End);
+                D.GlobOr(Start,End); // advances D

 
                 /* 
                  * If this is a virtual package, we need to check the list of
                  * packages that provide it and see if any of those are
                  * installed
                  */
 
                 /* 
                  * If this is a virtual package, we need to check the list of
                  * packages that provide it and see if any of those are
                  * installed
                  */

-                pkgCache::PrvIterator Prv = Start.TargetPkg().ProvidesList();
+                

                 bool providedBySomething = false;
                 bool providedBySomething = false;

-                for (; Prv.end() != true; Prv++)
-                   if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false) {
+                for (pkgCache::PrvIterator Prv = Start.TargetPkg().ProvidesList();
+                      Prv.end() != true;
+                      Prv++)
+                   if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
+                    {

                       providedBySomething = true;
                       break;
                    }
 
                 if (providedBySomething) continue;
             
                       providedBySomething = true;
                       break;
                    }
 
                 if (providedBySomething) continue;
             

-                do
-                  {
-                    if (Start->Type == pkgCache::Dep::Suggests) {
+                 for(;;)
+                 {
+                     /* Skip if package is  installed already, or is about to be */
+                     string target = string(Start.TargetPkg().Name()) + " ";
+
+                     if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
+                         || Cache[Start.TargetPkg()].Install())
+                       break;

 
 

-                      /* A suggests relations, let's see if we have it 
-                         installed already */
+                     /* Skip if we already saw it */
+                     if (int(SuggestsList.find(target)) != -1 || int(RecommendsList.find(target)) != -1)
+                       break; 

 
 

-                      string target = string(Start.TargetPkg().Name()) + " ";
-                      if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install || Cache[Start.TargetPkg()].Install())
-                        break;
-                      /* Does another package suggest it as well?  If so,
-                         don't print it twice */
-                      if (int(SuggestsList.find(target)) > -1)
-                        break; 
+                    if (Start->Type == pkgCache::Dep::Suggests) {

                       SuggestsList += target;
                       SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
                     }
                     
                     if (Start->Type == pkgCache::Dep::Recommends) {
                       SuggestsList += target;
                       SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
                     }
                     
                     if (Start->Type == pkgCache::Dep::Recommends) {

-
-                      /* A recommends relation, let's see if we have it
-                         installed already */
-
-                      string target = string(Start.TargetPkg().Name()) + " ";
-                      if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install || Cache[Start.TargetPkg()].Install())
-                        break;
-                      
-                      /* Does another package recommend it as well?  If so,
-                         don't print it twice */
-
-                      if (int(RecommendsList.find(target)) > -1)
-                        break;

                       RecommendsList += target;
                       RecommendsList += target;

-                      SuggestsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";
+                      RecommendsVersions += string(Cache[Start.TargetPkg()].CandVersion) + "\n";

                     }
                     }

-             if (Start == End)
-               break;
-             Start++;
-           } while (1);
-              }
-          }
+
+                     if (Start >= End)
+                        break;
+                     Start++;
+                 }
+             }
+         }

       }
       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);
       }
       ShowList(c1out,_("Suggested packages:"),SuggestsList,SuggestsVersions);
       ShowList(c1out,_("Recommended packages:"),RecommendsList,RecommendsVersions);


@@ -2053,7 +2043,7 @@ bool DoBuildDep(CommandLine &CmdL)
         rec.Package = Opts->Value;
         rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
         rec.Op = 0;
         rec.Package = Opts->Value;
         rec.Type = pkgSrcRecords::Parser::BuildDependIndep;
         rec.Op = 0;

-        BuildDeps.insert(BuildDeps.begin(), rec);
+        BuildDeps.push_back(rec);

       }
 
       if (BuildDeps.size() == 0)
       }
 
       if (BuildDeps.size() == 0)


@@ -2066,8 +2056,18 @@ bool DoBuildDep(CommandLine &CmdL)
       unsigned int ExpectedInst = 0;
       vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;
       pkgProblemResolver Fix(Cache);
       unsigned int ExpectedInst = 0;
       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);
+
+         if (skipAlternatives == true)
+         {
+            if (!hasAlternatives)
+               skipAlternatives = false; // end of or group
+            continue;
+         }
+

          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
             (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
          {
          if ((*D).Type == pkgSrcRecords::Parser::BuildConflict ||
             (*D).Type == pkgSrcRecords::Parser::BuildConflictIndep)
          {


@@ -2089,16 +2089,21 @@ bool DoBuildDep(CommandLine &CmdL)
         else // BuildDep || BuildDepIndep
          {
            pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);
         else // BuildDep || BuildDepIndep
          {
            pkgCache::PkgIterator Pkg = Cache->FindPkg((*D).Package);

+            if (_config->FindB("Debug::BuildDeps",false) == true)
+                 cout << "Looking for " << (*D).Package << "...\n";
+

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

-               // Check if there are any alternatives
-               if (((*D).Op & pkgCache::Dep::Or) != pkgCache::Dep::Or)
-                 return _error->Error(_("%s dependency for %s cannot be satisfied "
-                                         "because the package %s cannot be found"),
-                                        Last->BuildDepType((*D).Type),Src.c_str(),
-                                         (*D).Package.c_str());
-               // Try the next alternative
-               continue;
+               if (_config->FindB("Debug::BuildDeps",false) == true)
+                    cout << " (not found)" << (*D).Package << endl;
+
+               if (hasAlternatives)
+                  continue;
+
+               return _error->Error(_("%s dependency for %s cannot be satisfied "
+                                      "because the package %s cannot be found"),
+                                    Last->BuildDepType((*D).Type),Src.c_str(),
+                                    (*D).Package.c_str());

             }
 
             /*
             }
 
             /*


@@ -2111,9 +2116,6 @@ bool DoBuildDep(CommandLine &CmdL)
              * this would require we do a Resolve cycle for each package we 
              * add to the install list. Ugh
              */
              * this would require we do a Resolve cycle for each package we 
              * add to the install list. Ugh
              */

-            while (D != BuildDeps.end() && 
-                   (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or))
-               D++;

                        
            /* 
             * If this is a virtual package, we need to check the list of
                        
            /* 
             * If this is a virtual package, we need to check the list of


@@ -2121,9 +2123,11 @@ bool DoBuildDep(CommandLine &CmdL)
             * installed
             */
             pkgCache::PrvIterator Prv = Pkg.ProvidesList();
             * installed
             */
             pkgCache::PrvIterator Prv = Pkg.ProvidesList();

-           bool providedBySomething = !Prv.end();

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

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

               if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
                  break;
             }
               if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
                  break;
             }


@@ -2131,9 +2135,8 @@ bool DoBuildDep(CommandLine &CmdL)
             // Get installed version and version we are going to install
            pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
 
             // Get installed version and version we are going to install
            pkgCache::VerIterator IV = (*Cache)[Pkg].InstVerIter(*Cache);
 

-            if (!providedBySomething || (*D).Version[0] != '\0') {
-                 /* We either have a versioned dependency (so a provides won't do)
-                    or nothing is providing this package */
+            if ((*D).Version[0] != '\0') {
+                 // Versioned dependency

 
                  pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
 
 
                  pkgCache::VerIterator CV = (*Cache)[Pkg].CandidateVerIter(*Cache);
 


@@ -2143,25 +2146,77 @@ bool DoBuildDep(CommandLine &CmdL)
                            break;
                  }
                  if (CV.end() == true)
                            break;
                  }
                  if (CV.end() == true)

+                  if (hasAlternatives)
+                  {
+                     continue;
+                  }
+                  else
+                  {

                       return _error->Error(_("%s dependency for %s cannot be satisfied "
                                              "because no available versions of package %s "
                                              "can satisfy version requirements"),
                                            Last->BuildDepType((*D).Type),Src.c_str(),
                                            (*D).Package.c_str());
                       return _error->Error(_("%s dependency for %s cannot be satisfied "
                                              "because no available versions of package %s "
                                              "can satisfy version requirements"),
                                            Last->BuildDepType((*D).Type),Src.c_str(),
                                            (*D).Package.c_str());

+                  }
+            }
+            else
+            {
+               // Only consider virtual packages if there is no versioned dependency
+               if (Prv.end() == false)
+               {
+                  if (_config->FindB("Debug::BuildDeps",false) == true)
+                     cout << "  Is provided by installed package " << Prv.OwnerPkg().Name() << endl;
+                  skipAlternatives = hasAlternatives;
+                  continue;
+               }

             }
 
             }
 

-            /*
-            * TODO: if we depend on a version lower than what we already have 
-            * installed it is not clear what should be done; in practice
-            * this case should be rare, and right now nothing is 
-             * done about it :-( 
-            */
-           if (Prv.end() == true && // Nothing provides it; and
-                (IV.end() == true || //  It is not installed, or
-                Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == false))
-                                     //  the version installed doesn't 
-                                     //  satisfy constraints 
-              TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst);
+            if (IV.end() == false)
+            {
+               if (_config->FindB("Debug::BuildDeps",false) == true)
+                  cout << "  Is installed\n";
+
+               if (Cache->VS().CheckDep(IV.VerStr(),(*D).Op,(*D).Version.c_str()) == true)
+               {
+                  skipAlternatives = hasAlternatives;
+                  continue;
+               }
+
+               if (_config->FindB("Debug::BuildDeps",false) == true)
+                  cout << "    ...but the installed version doesn't meet the version requirement\n";
+
+               if (((*D).Op & pkgCache::Dep::LessEq) == pkgCache::Dep::LessEq)
+               {
+                  return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
+                                       Last->BuildDepType((*D).Type),
+                                       Src.c_str(),
+                                       Pkg.Name());
+               }
+            }
+
+
+            if (_config->FindB("Debug::BuildDeps",false) == true)
+               cout << "  Trying to install " << (*D).Package << endl;
+
+            if (TryToInstall(Pkg,Cache,Fix,false,false,ExpectedInst) == true)
+            {
+               // We successfully installed something; skip remaining alternatives
+               skipAlternatives = hasAlternatives;
+               continue;
+            }
+            else if (hasAlternatives)
+            {
+               if (_config->FindB("Debug::BuildDeps",false) == true)
+                  cout << "  Unsatisfiable, trying alternatives\n";
+               continue;
+            }
+            else
+            {
+               return _error->Error(_("Failed to satisfy %s dependency for %s: %s"),
+                                    Last->BuildDepType((*D).Type),
+                                    Src.c_str(),
+                                    (*D).Package.c_str());
+            }

         }             
       }
       
         }             
       }
       


@@ -2171,8 +2226,7 @@ bool DoBuildDep(CommandLine &CmdL)
       
       // Now we check the state of the packages,
       if (Cache->BrokenCount() != 0)
       
       // Now we check the state of the packages,
       if (Cache->BrokenCount() != 0)

-        return _error->Error(_("Some broken packages were found while trying to process build-dependencies.\n"
-                               "You might want to run `apt-get -f install' to correct these."));
+         return _error->Error(_("Build-dependencies for %s could not be satisfied."),*I);

    }
   
    if (InstallPackages(Cache, false, true) == false)
    }
   
    if (InstallPackages(Cache, false, true) == false)


@@ -2302,7 +2356,7 @@ void GetInitialize()
    _config->Set("APT::Get::Assume-Yes",false);
    _config->Set("APT::Get::Fix-Broken",false);
    _config->Set("APT::Get::Force-Yes",false);
    _config->Set("APT::Get::Assume-Yes",false);
    _config->Set("APT::Get::Fix-Broken",false);
    _config->Set("APT::Get::Force-Yes",false);

-   _config->Set("APT::Get::APT::Get::No-List-Cleanup",true);
+   _config->Set("APT::Get::List-Cleanup",true);

 }
                                                                        /*}}}*/
 // SigWinch - Window size change signal handler                                /*{{{*/
 }
                                                                        /*}}}*/
 // SigWinch - Window size change signal handler                                /*{{{*/


@@ -2403,7 +2457,7 @@ int main(int argc,const char *argv[])
    }
    
    // Deal with stdout not being a tty
    }
    
    // Deal with stdout not being a tty

-   if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
+   if (!isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)

       _config->Set("quiet","1");
 
    // Setup the output streams
       _config->Set("quiet","1");
 
    // Setup the output streams