be sure that the RFC1123StrToTime method is run in a LANG=C environment

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

diff --git a/apt-pkg/cacheset.cc b/apt-pkg/cacheset.cc
index 5dbd1a4dfa4322a476d3c980139ee252c0fb052d..43ade4b4e7eb2cd27f8e5d0210e72c597572d0b7 100644 (file)
--- a/apt-pkg/cacheset.cc
+++ b/apt-pkg/cacheset.cc
@@ -76,6 +76,39 @@ PackageSet PackageSet::FromRegEx(pkgCacheFile &Cache, std::string pattern, std::
        return pkgset;
 }
                                                                        /*}}}*/
        return pkgset;
 }
                                                                        /*}}}*/

+// GroupedFromCommandLine - Return all versions specified on commandline/*{{{*/
+std::map<unsigned short, PackageSet> PackageSet::GroupedFromCommandLine(
+               pkgCacheFile &Cache, const char **cmdline,
+               std::list<PackageSet::Modifier> const &mods,
+               unsigned short const &fallback, std::ostream &out) {
+       std::map<unsigned short, PackageSet> pkgsets;
+       for (const char **I = cmdline; *I != 0; ++I) {
+               unsigned short modID = fallback;
+               std::string str = *I;
+               for (std::list<PackageSet::Modifier>::const_iterator mod = mods.begin();
+                    mod != mods.end(); ++mod) {
+                       size_t const alength = strlen(mod->Alias);
+                       switch(mod->Pos) {
+                       case PackageSet::Modifier::POSTFIX:
+                               if (str.compare(str.length() - alength, alength,
+                                   mod->Alias, 0, alength) != 0)
+                                       continue;
+                               str.erase(str.length() - alength);
+                               modID = mod->ID;
+                               break;
+                       case PackageSet::Modifier::PREFIX:
+                               continue;
+                       case PackageSet::Modifier::NONE:
+                               continue;
+                       }
+                       break;
+               }
+               PackageSet pset = PackageSet::FromString(Cache, str, out);
+               pkgsets[modID].insert(pset.begin(), pset.end());
+       }
+       return pkgsets;
+}
+                                                                       /*}}}*/

 // FromCommandLine - Return all packages specified on commandline      /*{{{*/
 PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out) {
        PackageSet pkgset;
 // FromCommandLine - Return all packages specified on commandline      /*{{{*/
 PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline, std::ostream &out) {
        PackageSet pkgset;


@@ -87,17 +120,31 @@ PackageSet PackageSet::FromCommandLine(pkgCacheFile &Cache, const char **cmdline
 }
                                                                        /*}}}*/
 // FromString - Return all packages matching a specific string         /*{{{*/
 }
                                                                        /*}}}*/
 // FromString - Return all packages matching a specific string         /*{{{*/

-PackageSet PackageSet::FromString(pkgCacheFile &Cache, const char * const str, std::ostream &out) {
-       pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(str);
-       if (Grp.end() == false) {
-               pkgCache::PkgIterator Pkg = Grp.FindPreferredPkg();
+PackageSet PackageSet::FromString(pkgCacheFile &Cache, std::string const &str, std::ostream &out) {
+       std::string pkg = str;
+       size_t archfound = pkg.find_last_of(':');
+       std::string arch;
+       if (archfound != std::string::npos) {
+               arch = pkg.substr(archfound+1);
+               pkg.erase(archfound);
+       }
+
+       pkgCache::PkgIterator Pkg;
+       if (arch.empty() == true) {
+               pkgCache::GrpIterator Grp = Cache.GetPkgCache()->FindGrp(pkg);
+               if (Grp.end() == false)
+                       Pkg = Grp.FindPreferredPkg();
+       } else
+               Pkg = Cache.GetPkgCache()->FindPkg(pkg, arch);
+
+       if (Pkg.end() == false) {

                PackageSet pkgset;
                pkgset.insert(Pkg);
                return pkgset;
        }
        PackageSet regex = FromRegEx(Cache, str, out);
        if (regex.empty() == true)
                PackageSet pkgset;
                pkgset.insert(Pkg);
                return pkgset;
        }
        PackageSet regex = FromRegEx(Cache, str, out);
        if (regex.empty() == true)

-               _error->Warning(_("Unable to locate package %s"), str);
+               _error->Warning(_("Unable to locate package %s"), str.c_str());

        return regex;
 }
                                                                        /*}}}*/
        return regex;
 }
                                                                        /*}}}*/


@@ -118,10 +165,19 @@ APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cm
                PackageSet pkgset = PackageSet::FromString(Cache, pkg.c_str(), out);
                for (PackageSet::const_iterator P = pkgset.begin();
                     P != pkgset.end(); ++P) {
                PackageSet pkgset = PackageSet::FromString(Cache, pkg.c_str(), out);
                for (PackageSet::const_iterator P = pkgset.begin();
                     P != pkgset.end(); ++P) {

-                       if (vertag != string::npos) {
+                       if (vertag == string::npos) {
+                               AddSelectedVersion(Cache, verset, P, fallback);
+                               continue;
+                       }
+                       pkgCache::VerIterator V;
+                       if (ver == "installed")
+                               V = getInstalledVer(Cache, P);
+                       else if (ver == "candidate")
+                               V = getCandidateVer(Cache, P);
+                       else {

                                pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release :
                                pkgVersionMatch Match(ver, (verIsRel == true ? pkgVersionMatch::Release :

-                                                       pkgVersionMatch::Version));
-                               pkgCache::VerIterator V = Match.Find(P);
+                                               pkgVersionMatch::Version));
+                               V = Match.Find(P);

                                if (V.end() == true) {
                                        if (verIsRel == true)
                                                _error->Error(_("Release '%s' for '%s' was not found"),
                                if (V.end() == true) {
                                        if (verIsRel == true)
                                                _error->Error(_("Release '%s' for '%s' was not found"),


@@ -131,64 +187,83 @@ APT::VersionSet VersionSet::FromCommandLine(pkgCacheFile &Cache, const char **cm
                                                                ver.c_str(), P.FullName(true).c_str());
                                        continue;
                                }
                                                                ver.c_str(), P.FullName(true).c_str());
                                        continue;
                                }

-                               if (strcmp(ver.c_str(), V.VerStr()) != 0)
-                                       ioprintf(out, _("Selected version %s (%s) for %s\n"),
-                                                V.VerStr(), V.RelStr().c_str(), P.FullName(true).c_str());
-                               verset.insert(V);
-                       } else {
-                               pkgCache::VerIterator V;
-                               switch(fallback) {
-                               case VersionSet::ALL:
-                                       for (V = P.VersionList(); V.end() != true; ++V)
-                                               verset.insert(V);
-                                       break;
-                               case VersionSet::CANDANDINST:
-                                       verset.insert(getInstalledVer(Cache, P));
-                                       verset.insert(getCandidateVer(Cache, P));
-                                       break;
-                               case VersionSet::CANDIDATE:
-                                       verset.insert(getCandidateVer(Cache, P));
-                                       break;
-                               case VersionSet::INSTALLED:
-                                       verset.insert(getInstalledVer(Cache, P));
-                                       break;
-                               case VersionSet::CANDINST:
-                                       V = getCandidateVer(Cache, P, true);
-                                       if (V.end() == true)
-                                               V = getInstalledVer(Cache, P, true);
-                                       if (V.end() == false)
-                                               verset.insert(V);
-                                       else
-                                               _error->Error(_("Can't select installed nor candidate version from package %s as it has neither of them"), P.FullName(true).c_str());
-                                       break;
-                               case VersionSet::INSTCAND:
-                                       V = getInstalledVer(Cache, P, true);
-                                       if (V.end() == true)
-                                               V = getCandidateVer(Cache, P, true);
-                                       if (V.end() == false)
-                                               verset.insert(V);
-                                       else
-                                               _error->Error(_("Can't select installed nor candidate version from package %s as it has neither of them"), P.FullName(true).c_str());
-                                       break;
-                               case VersionSet::NEWEST:
-                                       if (P->VersionList != 0)
-                                               verset.insert(P.VersionList());
-                                       else
-                                               _error->Error(_("Can't select newest version from package %s as it is purely virtual"), P.FullName(true).c_str());
-                                       break;
-                               }

                        }
                        }

+                       if (V.end() == true)
+                               continue;
+                       if (ver == V.VerStr())
+                               ioprintf(out, _("Selected version '%s' (%s) for '%s'\n"),
+                                        V.VerStr(), V.RelStr().c_str(), P.FullName(true).c_str());
+                       verset.insert(V);

                }
        }
        return verset;
 }
                                                                        /*}}}*/
                }
        }
        return verset;
 }
                                                                        /*}}}*/

+// AddSelectedVersion - add version from package based on fallback     /*{{{*/
+bool VersionSet::AddSelectedVersion(pkgCacheFile &Cache, VersionSet &verset,
+               pkgCache::PkgIterator const &P, VersionSet::Version const &fallback,
+               bool const &AllowError) {
+       pkgCache::VerIterator V;
+       switch(fallback) {
+       case VersionSet::ALL:
+               if (P->VersionList != 0)
+                       for (V = P.VersionList(); V.end() != true; ++V)
+                               verset.insert(V);
+               else if (AllowError == false)
+                       return _error->Error(_("Can't select versions from package '%s' as it purely virtual"), P.FullName(true).c_str());
+               else
+                       return false;
+               break;
+       case VersionSet::CANDANDINST:
+               verset.insert(getInstalledVer(Cache, P, AllowError));
+               verset.insert(getCandidateVer(Cache, P, AllowError));
+               break;
+       case VersionSet::CANDIDATE:
+               verset.insert(getCandidateVer(Cache, P, AllowError));
+               break;
+       case VersionSet::INSTALLED:
+               verset.insert(getInstalledVer(Cache, P, AllowError));
+               break;
+       case VersionSet::CANDINST:
+               V = getCandidateVer(Cache, P, true);
+               if (V.end() == true)
+                       V = getInstalledVer(Cache, P, true);
+               if (V.end() == false)
+                       verset.insert(V);
+               else if (AllowError == false)
+                       return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
+               else
+                       return false;
+               break;
+       case VersionSet::INSTCAND:
+               V = getInstalledVer(Cache, P, true);
+               if (V.end() == true)
+                       V = getCandidateVer(Cache, P, true);
+               if (V.end() == false)
+                       verset.insert(V);
+               else if (AllowError == false)
+                       return _error->Error(_("Can't select installed nor candidate version from package '%s' as it has neither of them"), P.FullName(true).c_str());
+               else
+                       return false;
+               break;
+       case VersionSet::NEWEST:
+               if (P->VersionList != 0)
+                       verset.insert(P.VersionList());
+               else if (AllowError == false)
+                       return _error->Error(_("Can't select newest version from package '%s' as it is purely virtual"), P.FullName(true).c_str());
+               else
+                       return false;
+               break;
+       }
+       return true;
+}
+                                                                       /*}}}*/

 // getCandidateVer - Returns the candidate version of the given package        /*{{{*/
 pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
        if (unlikely(Cache.BuildDepCache() == false))
                return pkgCache::VerIterator(*Cache);
 // getCandidateVer - Returns the candidate version of the given package        /*{{{*/
 pkgCache::VerIterator VersionSet::getCandidateVer(pkgCacheFile &Cache,
                pkgCache::PkgIterator const &Pkg, bool const &AllowError) {
        if (unlikely(Cache.BuildDepCache() == false))
                return pkgCache::VerIterator(*Cache);

-       pkgCache::VerIterator Cand = Cache[Pkg].InstVerIter(Cache);
+       pkgCache::VerIterator Cand = Cache[Pkg].CandidateVerIter(Cache);

        if (AllowError == false && Cand.end() == true)
                _error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
        return Cand;
        if (AllowError == false && Cand.end() == true)
                _error->Error(_("Can't select candidate version from package %s as it has no candidate"), Pkg.FullName(true).c_str());
        return Cand;