#include <cassert>
#include <apt-pkg/pkgcachegen.h>
#include <apt-pkg/cachefile.h>
+#include <apt-pkg/cacheset.h>
#include <apt-pkg/init.h>
#include <apt-pkg/progress.h>
#include <apt-pkg/sourcelist.h>
#include <apt-pkg/tagfile.h>
#include <apt-pkg/algorithms.h>
#include <apt-pkg/sptr.h>
-#include <apt-pkg/cacheset.h>
#include <config.h>
#include <apti18n.h>
using namespace std;
+// CacheSetHelper saving virtual packages /*{{{*/
+class CacheSetHelperVirtuals: public APT::CacheSetHelper {
+public:
+ APT::PackageSet virtualPkgs;
+
+ virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
+ virtualPkgs.insert(Pkg);
+ return CacheSetHelper::canNotFindCandidateVer(Cache, Pkg);
+ }
+
+ virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
+ virtualPkgs.insert(Pkg);
+ return CacheSetHelper::canNotFindNewestVer(Cache, Pkg);
+ }
+
+ virtual APT::VersionSet canNotFindAllVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
+ virtualPkgs.insert(Pkg);
+ return CacheSetHelper::canNotFindAllVer(Cache, Pkg);
+ }
+
+ CacheSetHelperVirtuals(bool const &ShowErrors = true, GlobalError::MsgType const &ErrorType = GlobalError::NOTICE) : CacheSetHelper(ShowErrors, ErrorType) {}
+};
+ /*}}}*/
// LocalitySort - Sort a version list by package file locality /*{{{*/
// ---------------------------------------------------------------------
/* */
// UnMet - Show unmet dependencies /*{{{*/
// ---------------------------------------------------------------------
/* */
-bool UnMet(CommandLine &CmdL)
+bool ShowUnMet(pkgCache::VerIterator const &V, bool const &Important)
{
- bool const Important = _config->FindB("APT::Cache::Important",false);
-
- pkgCacheFile CacheFile;
- if (unlikely(CacheFile.GetPkgCache() == NULL))
- return false;
-
- for (pkgCache::PkgIterator P = CacheFile.GetPkgCache()->PkgBegin(); P.end() == false; P++)
- {
- for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
- {
bool Header = false;
for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
{
pkgCache::DepIterator Start;
pkgCache::DepIterator End;
D.GlobOr(Start,End);
-
- // Skip conflicts and replaces
- if (End->Type != pkgCache::Dep::PreDepends &&
- End->Type != pkgCache::Dep::Depends &&
- End->Type != pkgCache::Dep::Suggests &&
- End->Type != pkgCache::Dep::Recommends)
- continue;
// Important deps only
if (Important == true)
if (End->Type != pkgCache::Dep::PreDepends &&
End->Type != pkgCache::Dep::Depends)
continue;
-
+
+ // Skip conflicts and replaces
+ if (End.IsNegative() == true)
+ continue;
+
// Verify the or group
bool OK = false;
pkgCache::DepIterator RealStart = Start;
// Oops, it failed..
if (Header == false)
ioprintf(cout,_("Package %s version %s has an unmet dep:\n"),
- P.FullName(true).c_str(),V.VerStr());
+ V.ParentPkg().FullName(true).c_str(),V.VerStr());
Header = true;
// Print out the dep type
while (1);
cout << endl;
- }
- }
- }
+ }
+ return true;
+}
+bool UnMet(CommandLine &CmdL)
+{
+ bool const Important = _config->FindB("APT::Cache::Important",false);
+
+ pkgCacheFile CacheFile;
+ if (unlikely(CacheFile.GetPkgCache() == NULL))
+ return false;
+
+ if (CmdL.FileSize() <= 1)
+ {
+ for (pkgCache::PkgIterator P = CacheFile.GetPkgCache()->PkgBegin(); P.end() == false; P++)
+ for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
+ if (ShowUnMet(V, Important) == false)
+ return false;
+ }
+ else
+ {
+ CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
+ APT::VersionSet verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1,
+ APT::VersionSet::CANDIDATE, helper);
+ for (APT::VersionSet::iterator V = verset.begin(); V != verset.end(); ++V)
+ if (ShowUnMet(V, Important) == false)
+ return false;
+ }
return true;
}
/*}}}*/
bool DumpPackage(CommandLine &CmdL)
{
pkgCacheFile CacheFile;
- APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList);
+ APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+ APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
{
return !_error->PendingError();
}
/*}}}*/
-// Depends - Print out a dependency tree /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-bool Depends(CommandLine &CmdL)
+// ShowDepends - Helper for printing out a dependency tree /*{{{*/
+bool ShowDepends(CommandLine &CmdL, bool const RevDepends)
{
pkgCacheFile CacheFile;
pkgCache *Cache = CacheFile.GetPkgCache();
if (unlikely(Cache == NULL))
return false;
- SPtrArray<unsigned> Colours = new unsigned[Cache->Head().PackageCount];
- memset(Colours,0,sizeof(*Colours)*Cache->Head().PackageCount);
-
- APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList);
- for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
- Colours[Pkg->ID] = 1;
-
- bool Recurse = _config->FindB("APT::Cache::RecurseDepends",false);
- bool Installed = _config->FindB("APT::Cache::Installed",false);
- bool Important = _config->FindB("APT::Cache::Important",false);
- bool DidSomething;
- do
+ CacheSetHelperVirtuals helper(false);
+ APT::VersionSet verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
+ if (verset.empty() == true && helper.virtualPkgs.empty() == true)
+ return _error->Error(_("No packages found"));
+ std::vector<bool> Shown(Cache->Head().PackageCount);
+
+ bool const Recurse = _config->FindB("APT::Cache::RecurseDepends", false);
+ bool const Installed = _config->FindB("APT::Cache::Installed", false);
+ bool const Important = _config->FindB("APT::Cache::Important", false);
+ bool const ShowDepType = _config->FindB("APT::Cache::ShowDependencyType", RevDepends == false);
+ bool const ShowPreDepends = _config->FindB("APT::Cache::ShowPre-Depends", true);
+ bool const ShowDepends = _config->FindB("APT::Cache::ShowDepends", true);
+ bool const ShowRecommends = _config->FindB("APT::Cache::ShowRecommends", Important == false);
+ bool const ShowSuggests = _config->FindB("APT::Cache::ShowSuggests", Important == false);
+ bool const ShowReplaces = _config->FindB("APT::Cache::ShowReplaces", Important == false);
+ bool const ShowConflicts = _config->FindB("APT::Cache::ShowConflicts", Important == false);
+ bool const ShowBreaks = _config->FindB("APT::Cache::ShowBreaks", Important == false);
+ bool const ShowEnhances = _config->FindB("APT::Cache::ShowEnhances", Important == false);
+ bool const ShowOnlyFirstOr = _config->FindB("APT::Cache::ShowOnlyFirstOr", false);
+
+ while (verset.empty() != true)
{
- DidSomething = false;
- for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
- {
- if (Colours[Pkg->ID] != 1)
- continue;
- Colours[Pkg->ID] = 2;
- DidSomething = true;
-
- pkgCache::VerIterator Ver = Pkg.VersionList();
- if (Ver.end() == true)
- {
- cout << '<' << Pkg.FullName(true) << '>' << endl;
- continue;
- }
-
+ pkgCache::VerIterator Ver = *verset.begin();
+ verset.erase(verset.begin());
+ pkgCache::PkgIterator Pkg = Ver.ParentPkg();
+ Shown[Pkg->ID] = true;
+
cout << Pkg.FullName(true) << endl;
-
- for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
+
+ if (RevDepends == true)
+ cout << "Reverse Depends:" << endl;
+ for (pkgCache::DepIterator D = RevDepends ? Pkg.RevDependsList() : Ver.DependsList();
+ D.end() == false; D++)
{
- // Important deps only
- if (Important == true)
- if (D->Type != pkgCache::Dep::PreDepends &&
- D->Type != pkgCache::Dep::Depends)
- continue;
-
- pkgCache::PkgIterator Trg = D.TargetPkg();
+ switch (D->Type) {
+ case pkgCache::Dep::PreDepends: if (!ShowPreDepends) continue; break;
+ case pkgCache::Dep::Depends: if (!ShowDepends) continue; break;
+ case pkgCache::Dep::Recommends: if (!ShowRecommends) continue; break;
+ case pkgCache::Dep::Suggests: if (!ShowSuggests) continue; break;
+ case pkgCache::Dep::Replaces: if (!ShowReplaces) continue; break;
+ case pkgCache::Dep::Conflicts: if (!ShowConflicts) continue; break;
+ case pkgCache::Dep::DpkgBreaks: if (!ShowBreaks) continue; break;
+ case pkgCache::Dep::Enhances: if (!ShowEnhances) continue; break;
+ }
+
+ pkgCache::PkgIterator Trg = RevDepends ? D.ParentPkg() : D.TargetPkg();
if((Installed && Trg->CurrentVer != 0) || !Installed)
{
- if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+ if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or && ShowOnlyFirstOr == false)
cout << " |";
else
cout << " ";
// Show the package
+ if (ShowDepType == true)
+ cout << D.DepType() << ": ";
if (Trg->VersionList == 0)
- cout << D.DepType() << ": <" << Trg.FullName(true) << ">" << endl;
+ cout << "<" << Trg.FullName(true) << ">" << endl;
else
- cout << D.DepType() << ": " << Trg.FullName(true) << endl;
+ cout << Trg.FullName(true) << endl;
- if (Recurse == true)
- Colours[D.TargetPkg()->ID]++;
+ if (Recurse == true && Shown[Trg->ID] == false)
+ {
+ Shown[Trg->ID] = true;
+ verset.insert(APT::VersionSet::FromPackage(CacheFile, Trg, APT::VersionSet::CANDIDATE, helper));
+ }
}
V->ParentPkg == D->Package)
continue;
cout << " " << V.ParentPkg().FullName(true) << endl;
-
- if (Recurse == true)
- Colours[D.ParentPkg()->ID]++;
+
+ if (Recurse == true && Shown[V.ParentPkg()->ID] == false)
+ {
+ Shown[V.ParentPkg()->ID] = true;
+ verset.insert(APT::VersionSet::FromPackage(CacheFile, V.ParentPkg(), APT::VersionSet::CANDIDATE, helper));
+ }
}
+
+ if (ShowOnlyFirstOr == true)
+ while ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or) ++D;
}
- }
- }
- while (DidSomething == true);
-
+ }
+
+ for (APT::PackageSet::const_iterator Pkg = helper.virtualPkgs.begin();
+ Pkg != helper.virtualPkgs.end(); ++Pkg)
+ cout << '<' << Pkg.FullName(true) << '>' << endl;
+
return true;
}
/*}}}*/
-// RDepends - Print out a reverse dependency tree - mbc /*{{{*/
+// Depends - Print out a dependency tree /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool Depends(CommandLine &CmdL)
+{
+ return ShowDepends(CmdL, false);
+}
+ /*}}}*/
+// RDepends - Print out a reverse dependency tree /*{{{*/
// ---------------------------------------------------------------------
/* */
bool RDepends(CommandLine &CmdL)
{
- pkgCacheFile CacheFile;
- pkgCache *Cache = CacheFile.GetPkgCache();
- if (unlikely(Cache == NULL))
- return false;
-
- SPtrArray<unsigned> Colours = new unsigned[Cache->Head().PackageCount];
- memset(Colours,0,sizeof(*Colours)*Cache->Head().PackageCount);
-
- APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList);
- for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
- Colours[Pkg->ID] = 1;
-
- bool Recurse = _config->FindB("APT::Cache::RecurseDepends",false);
- bool Installed = _config->FindB("APT::Cache::Installed",false);
- bool DidSomething;
- do
- {
- DidSomething = false;
- for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
- {
- if (Colours[Pkg->ID] != 1)
- continue;
- Colours[Pkg->ID] = 2;
- DidSomething = true;
-
- pkgCache::VerIterator Ver = Pkg.VersionList();
- if (Ver.end() == true)
- {
- cout << '<' << Pkg.FullName(true) << '>' << endl;
- continue;
- }
-
- cout << Pkg.FullName(true) << endl;
-
- cout << "Reverse Depends:" << endl;
- for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() == false; D++)
- {
- // Show the package
- pkgCache::PkgIterator Trg = D.ParentPkg();
-
- if((Installed && Trg->CurrentVer != 0) || !Installed)
- {
-
- if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
- cout << " |";
- else
- cout << " ";
-
- if (Trg->VersionList == 0)
- cout << D.DepType() << ": <" << Trg.FullName(true) << ">" << endl;
- else
- cout << Trg.FullName(true) << endl;
-
- if (Recurse == true)
- Colours[D.ParentPkg()->ID]++;
-
- }
-
- // Display all solutions
- SPtrArray<pkgCache::Version *> List = D.AllTargets();
- pkgPrioSortList(*Cache,List);
- for (pkgCache::Version **I = List; *I != 0; I++)
- {
- pkgCache::VerIterator V(*Cache,*I);
- if (V != Cache->VerP + V.ParentPkg()->VersionList ||
- V->ParentPkg == D->Package)
- continue;
- cout << " " << V.ParentPkg().FullName(true) << endl;
-
- if (Recurse == true)
- Colours[D.ParentPkg()->ID]++;
- }
- }
- }
- }
- while (DidSomething == true);
-
- return true;
+ return ShowDepends(CmdL, true);
}
/*}}}*/
// xvcg - Generate a graph for xvcg /*{{{*/
ShapeMap[Pkg->ID] = 3;
}
}
-
+
// Load the list of packages from the command line into the show list
- for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+ APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+ std::list<APT::PackageSet::Modifier> mods;
+ mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
+ mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
+ std::map<unsigned short, APT::PackageSet> pkgsets =
+ APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0, helper);
+
+ for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
+ Pkg != pkgsets[0].end(); ++Pkg)
+ Show[Pkg->ID] = ToShow;
+ for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
+ Pkg != pkgsets[1].end(); ++Pkg)
{
- // Process per-package flags
- string P = *I;
- bool Force = false;
- if (P.length() > 3)
- {
- if (P.end()[-1] == '^')
- {
- Force = true;
- P.erase(P.end()-1);
- }
-
- if (P.end()[-1] == ',')
- P.erase(P.end()-1);
- }
-
- // Locate the package
- pkgCache::PkgIterator Pkg = Cache->FindPkg(P);
- if (Pkg.end() == true)
- {
- _error->Warning(_("Unable to locate package %s"),*I);
- continue;
- }
Show[Pkg->ID] = ToShow;
-
- if (Force == true)
- Flags[Pkg->ID] |= ForceNR;
+ Flags[Pkg->ID] |= ForceNR;
}
-
+
// Little header
cout << "graph: { title: \"packages\"" << endl <<
"xmax: 700 ymax: 700 x: 30 y: 30" << endl <<
{
/* If a conflicts does not meet anything in the database
then show the relation but do not recurse */
- if (Hit == false &&
- (D->Type == pkgCache::Dep::Conflicts ||
- D->Type == pkgCache::Dep::DpkgBreaks ||
- D->Type == pkgCache::Dep::Obsoletes))
+ if (Hit == false && D.IsNegative() == true)
{
if (Show[D.TargetPkg()->ID] == None &&
Show[D.TargetPkg()->ID] != ToShow)
ShapeMap[Pkg->ID] = 3;
}
}
-
+
// Load the list of packages from the command line into the show list
- for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+ APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+ std::list<APT::PackageSet::Modifier> mods;
+ mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
+ mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
+ std::map<unsigned short, APT::PackageSet> pkgsets =
+ APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0, helper);
+
+ for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
+ Pkg != pkgsets[0].end(); ++Pkg)
+ Show[Pkg->ID] = ToShow;
+ for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
+ Pkg != pkgsets[1].end(); ++Pkg)
{
- // Process per-package flags
- string P = *I;
- bool Force = false;
- if (P.length() > 3)
- {
- if (P.end()[-1] == '^')
- {
- Force = true;
- P.erase(P.end()-1);
- }
-
- if (P.end()[-1] == ',')
- P.erase(P.end()-1);
- }
-
- // Locate the package
- pkgCache::PkgIterator Pkg = Cache->FindPkg(P);
- if (Pkg.end() == true)
- {
- _error->Warning(_("Unable to locate package %s"),*I);
- continue;
- }
Show[Pkg->ID] = ToShow;
-
- if (Force == true)
- Flags[Pkg->ID] |= ForceNR;
+ Flags[Pkg->ID] |= ForceNR;
}
-
+
// Little header
printf("digraph packages {\n");
printf("concentrate=true;\n");
{
/* If a conflicts does not meet anything in the database
then show the relation but do not recurse */
- if (Hit == false &&
- (D->Type == pkgCache::Dep::Conflicts ||
- D->Type == pkgCache::Dep::Obsoletes))
+ if (Hit == false && D.IsNegative() == true)
{
if (Show[D.TargetPkg()->ID] == None &&
Show[D.TargetPkg()->ID] != ToShow)
{
case pkgCache::Dep::Conflicts:
case pkgCache::Dep::Obsoletes:
+ case pkgCache::Dep::DpkgBreaks:
printf("[color=springgreen];\n");
break;
}
printf("}\n");
+ delete[] Show;
+ delete[] Flags;
+ delete[] ShapeMap;
return true;
-}
- /*}}}*/
-// DoAdd - Perform an adding operation /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-bool DoAdd(CommandLine &CmdL)
-{
- return _error->Error("Unimplemented");
-#if 0
- // Make sure there is at least one argument
- if (CmdL.FileSize() <= 1)
- return _error->Error("You must give at least one file name");
-
- // Open the cache
- FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
- if (_error->PendingError() == true)
- return false;
-
- DynamicMMap Map(CacheF,MMap::Public);
- if (_error->PendingError() == true)
- return false;
-
- OpTextProgress Progress(*_config);
- pkgCacheGenerator Gen(Map,Progress);
- if (_error->PendingError() == true)
- return false;
-
- unsigned long Length = CmdL.FileSize() - 1;
- for (const char **I = CmdL.FileList + 1; *I != 0; I++)
- {
- Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
- Progress.SubProgress(Length);
-
- // Do the merge
- FileFd TagF(*I,FileFd::ReadOnly);
- debListParser Parser(TagF);
- if (_error->PendingError() == true)
- return _error->Error("Problem opening %s",*I);
-
- if (Gen.SelectFile(*I,"") == false)
- return _error->Error("Problem with SelectFile");
-
- if (Gen.MergeList(Parser) == false)
- return _error->Error("Problem with MergeList");
- }
-
- Progress.Done();
- GCache = &Gen.GetCache();
- Stats(CmdL);
-
- return true;
-#endif
}
/*}}}*/
// DisplayRecord - Displays the complete record for the package /*{{{*/
pkgCache::PkgFileIterator I = Vf.File();
if (I.IsOk() == false)
return _error->Error(_("Package file %s is out of sync."),I.FileName());
-
- FileFd PkgF(I.FileName(),FileFd::ReadOnly);
- if (_error->PendingError() == true)
+
+ FileFd PkgF;
+ if (PkgF.Open(I.FileName(), FileFd::ReadOnlyGzip) == false)
return false;
-
+
// Read the record
unsigned char *Buffer = new unsigned char[Cache->HeaderP->MaxVerFileSize+1];
Buffer[V.FileList()->Size] = '\n';
continue;
pkgCache::VerIterator V = Plcy->GetCandidateVer(P);
if (V.end() == false)
- DFList[G->ID].Df = V.DescriptionList().FileList();
+ DFList[G->ID].Df = V.TranslatedDescription().FileList();
if (DFList[G->ID].NameMatch == false)
continue;
continue;
unsigned long id = Prv.OwnerPkg().Group()->ID;
- DFList[id].Df = V.DescriptionList().FileList();
+ DFList[id].Df = V.TranslatedDescription().FileList();
DFList[id].NameMatch = true;
}
}
return _error->Error("Write to stdout failed");
return true;
}
-
-
-/* show automatically installed packages (sorted) */
+ /*}}}*/
+/* ShowAuto - show automatically installed packages (sorted) {{{*/
bool ShowAuto(CommandLine &CmdL)
{
pkgCacheFile CacheFile;
for (vector<string>::iterator I = packages.begin(); I != packages.end(); I++)
cout << *I << "\n";
+ _error->Notice(_("This command is deprecated. Please use 'apt-mark showauto' instead."));
return true;
}
/*}}}*/
bool ShowPackage(CommandLine &CmdL)
{
pkgCacheFile CacheFile;
+ CacheSetHelperVirtuals helper(true, GlobalError::NOTICE);
APT::VersionSet::Version const select = _config->FindB("APT::Cache::AllVersions", true) ?
- APT::VersionSet::ALL : APT::VersionSet::INSTALLED;
- APT::VersionSet const verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList, select);
+ APT::VersionSet::ALL : APT::VersionSet::CANDIDATE;
+ APT::VersionSet const verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1, select, helper);
for (APT::VersionSet::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
if (DisplayRecord(CacheFile, Ver) == false)
return false;
- if (verset.empty() == false)
- return true;
- return _error->Error(_("No packages found"));
+ if (verset.empty() == true)
+ {
+ if (helper.virtualPkgs.empty() == true)
+ return _error->Error(_("No packages found"));
+ else
+ _error->Notice(_("No packages found"));
+ }
+ return true;
}
/*}}}*/
// ShowPkgNames - Show package names /*{{{*/
_error->Warning(_("Unable to locate package %s"),*I);
continue;
}
- }
- if (found > 0)
- return true;
- return _error->Error(_("No packages found"));
+ }
+ if (found == 0)
+ _error->Notice(_("No packages found"));
+ return true;
}
/*}}}*/
// Policy - Show the results of the preferences file /*{{{*/
return true;
}
- string const myArch = _config->Find("APT::Architecture");
char const * const msgInstalled = _(" Installed: ");
char const * const msgCandidate = _(" Candidate: ");
short const InstalledLessCandidate =
(InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
// Print out detailed information for each package
- APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList);
- for (APT::PackageSet::const_iterator I = pkgset.begin(); I != pkgset.end(); ++I)
+ APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+ APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList + 1, helper);
+ for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
{
- pkgCache::PkgIterator Pkg = I.Group().FindPkg("any");
-
- for (; Pkg.end() != true; Pkg = I.Group().NextPkg(Pkg)) {
- if (strcmp(Pkg.Arch(),"all") == 0)
- continue;
-
cout << Pkg.FullName(true) << ":" << endl;
// Installed version
Indx->Describe(true).c_str());
}
}
- }
}
return true;
if (_error->PendingError() == true)
_error->Discard();
- APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList);
- for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
+ APT::CacheSetHelper helper(true, GlobalError::NOTICE);
+ for (const char **I = CmdL.FileList + 1; *I != 0; I++)
{
- if (Pkg.end() == false)
+ _error->PushToStack();
+ APT::PackageSet pkgset = APT::PackageSet::FromString(CacheFile, *I, helper);
+ for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
{
for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; V++)
{
}
}
-
SrcRecs.Restart();
pkgSrcRecords::Parser *SrcParser;
- while ((SrcParser = SrcRecs.Find(Pkg.Name(),false)) != 0)
+ bool foundSomething = false;
+ while ((SrcParser = SrcRecs.Find(*I, false)) != 0)
{
+ foundSomething = true;
// Maybe support Release info here too eventually
cout << setw(10) << SrcParser->Package() << " | "
<< setw(10) << SrcParser->Version() << " | "
<< SrcParser->Index().Describe(true) << endl;
}
+ if (foundSomething == true)
+ _error->RevertToStack();
+ else
+ _error->MergeWithStack();
}
return true;
cout <<
_("Usage: apt-cache [options] command\n"
- " apt-cache [options] add file1 [file2 ...]\n"
" apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
" apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
"\n"
- "apt-cache is a low-level tool used to manipulate APT's binary\n"
- "cache files, and query information from them\n"
+ "apt-cache is a low-level tool used to query information\n"
+ "from APT's binary cache files\n"
"\n"
"Commands:\n"
- " add - Add a package file to the source cache\n"
" gencaches - Build both the package and source cache\n"
" showpkg - Show some general information for a single package\n"
" showsrc - Show source records\n"
" unmet - Show unmet dependencies\n"
" search - Search the package list for a regex pattern\n"
" show - Show a readable record for the package\n"
- " showauto - Display a list of automatically installed packages\n"
" depends - Show raw dependency information for a package\n"
" rdepends - Show reverse dependency information for a package\n"
" pkgnames - List the names of all packages in the system\n"
return true;
}
/*}}}*/
-// CacheInitialize - Initialize things for apt-cache /*{{{*/
-// ---------------------------------------------------------------------
-/* */
-void CacheInitialize()
-{
- _config->Set("quiet",0);
- _config->Set("help",false);
-}
- /*}}}*/
int main(int argc,const char *argv[]) /*{{{*/
{
CommandLine::Args Args[] = {
{'n',"names-only","APT::Cache::NamesOnly",0},
{0,"all-names","APT::Cache::AllNames",0},
{0,"recurse","APT::Cache::RecurseDepends",0},
+ {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
+ {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
{'c',"config-file",0,CommandLine::ConfigFile},
{'o',"option",0,CommandLine::ArbItem},
{0,"installed","APT::Cache::Installed",0},
+ {0,"pre-depends","APT::Cache::ShowPreDepends",0},
+ {0,"depends","APT::Cache::ShowDepends",0},
+ {0,"recommends","APT::Cache::ShowRecommends",0},
+ {0,"suggests","APT::Cache::ShowSuggests",0},
+ {0,"replaces","APT::Cache::ShowReplaces",0},
+ {0,"breaks","APT::Cache::ShowBreaks",0},
+ {0,"conflicts","APT::Cache::ShowConflicts",0},
+ {0,"enhances","APT::Cache::ShowEnhances",0},
{0,0,0,0}};
CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
- {"add",&DoAdd},
{"gencaches",&GenCaches},
{"showsrc",&ShowSrcPackage},
{0,0}};
{"madison",&Madison},
{0,0}};
- CacheInitialize();
-
// Set up gettext support
setlocale(LC_ALL,"");
textdomain(PACKAGE);
}
// Deal with stdout not being a tty
- if (isatty(STDOUT_FILENO) && _config->FindI("quiet",0) < 1)
+ if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
_config->Set("quiet","1");
-// if (_config->FindB("APT::Cache::Generate",true) == false)
+ if (_config->Exists("APT::Cache::Generate") == true)
+ _config->Set("pkgCacheFile::Generate", _config->FindB("APT::Cache::Generate", true));
+
if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
CmdL.DispatchArg(CmdsB);
// Print any errors or warnings found during parsing
- if (_error->empty() == false)
- {
- bool Errors = _error->PendingError();
+ bool const Errors = _error->PendingError();
+ if (_config->FindI("quiet",0) > 0)
_error->DumpErrors();
- return Errors == true?100:0;
- }
-
- return 0;
+ else
+ _error->DumpErrors(GlobalError::DEBUG);
+ return Errors == true ? 100 : 0;
}
/*}}}*/
projects / apt.git / blobdiff