]> git.saurik.com Git - apt.git/blob - cmdline/apt-cache.cc
projects / apt.git / blob
? search:


70732e4d04762334cccfa02017e2413b336d634f
[apt.git] / cmdline / apt-cache.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description /*{{{*/
3 // $Id: apt-cache.cc,v 1.72 2004/04/30 04:34:03 mdz Exp $
4 /* ######################################################################
5
6 apt-cache - Manages the cache files
7
8 apt-cache provides some functions fo manipulating the cache files.
9 It uses the command line interface common to all the APT tools.
10
11 Returns 100 on failure, 0 on success.
12
13 ##################################################################### */
14 /*}}}*/
15 // Include Files /*{{{*/
16 #include <apt-pkg/error.h>
17 #include <cassert>
18 #include <apt-pkg/pkgcachegen.h>
19 #include <apt-pkg/cachefile.h>
20 #include <apt-pkg/cacheset.h>
21 #include <apt-pkg/init.h>
22 #include <apt-pkg/progress.h>
23 #include <apt-pkg/sourcelist.h>
24 #include <apt-pkg/cmndline.h>
25 #include <apt-pkg/strutl.h>
26 #include <apt-pkg/pkgrecords.h>
27 #include <apt-pkg/srcrecords.h>
28 #include <apt-pkg/version.h>
29 #include <apt-pkg/policy.h>
30 #include <apt-pkg/tagfile.h>
31 #include <apt-pkg/algorithms.h>
32 #include <apt-pkg/sptr.h>
33
34 #include <config.h>
35 #include <apti18n.h>
36
37 #include <locale.h>
38 #include <iostream>
39 #include <unistd.h>
40 #include <errno.h>
41 #include <regex.h>
42 #include <stdio.h>
43
44 #include <iomanip>
45 /*}}}*/
46
47 using namespace std;
48
49 // LocalitySort - Sort a version list by package file locality /*{{{*/
50 // ---------------------------------------------------------------------
51 /* */
52 int LocalityCompare(const void *a, const void *b)
53 {
54 pkgCache::VerFile *A = *(pkgCache::VerFile **)a;
55 pkgCache::VerFile *B = *(pkgCache::VerFile **)b;
56
57 if (A == 0 && B == 0)
58 return 0;
59 if (A == 0)
60 return 1;
61 if (B == 0)
62 return -1;
63
64 if (A->File == B->File)
65 return A->Offset - B->Offset;
66 return A->File - B->File;
67 }
68
69 void LocalitySort(pkgCache::VerFile **begin,
70 unsigned long Count,size_t Size)
71 {
72 qsort(begin,Count,Size,LocalityCompare);
73 }
74
75 void LocalitySort(pkgCache::DescFile **begin,
76 unsigned long Count,size_t Size)
77 {
78 qsort(begin,Count,Size,LocalityCompare);
79 }
80 /*}}}*/
81 // UnMet - Show unmet dependencies /*{{{*/
82 // ---------------------------------------------------------------------
83 /* */
84 bool ShowUnMet(pkgCache::VerIterator const &V, bool const &Important)
85 {
86 bool Header = false;
87 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
88 {
89 // Collect or groups
90 pkgCache::DepIterator Start;
91 pkgCache::DepIterator End;
92 D.GlobOr(Start,End);
93
94 // Important deps only
95 if (Important == true)
96 if (End->Type != pkgCache::Dep::PreDepends &&
97 End->Type != pkgCache::Dep::Depends)
98 continue;
99
100 // Skip conflicts and replaces
101 if (End->Type == pkgCache::Dep::DpkgBreaks ||
102 End->Type == pkgCache::Dep::Replaces ||
103 End->Type == pkgCache::Dep::Conflicts)
104 continue;
105
106 // Verify the or group
107 bool OK = false;
108 pkgCache::DepIterator RealStart = Start;
109 do
110 {
111 // See if this dep is Ok
112 pkgCache::Version **VList = Start.AllTargets();
113 if (*VList != 0)
114 {
115 OK = true;
116 delete [] VList;
117 break;
118 }
119 delete [] VList;
120
121 if (Start == End)
122 break;
123 Start++;
124 }
125 while (1);
126
127 // The group is OK
128 if (OK == true)
129 continue;
130
131 // Oops, it failed..
132 if (Header == false)
133 ioprintf(cout,_("Package %s version %s has an unmet dep:\n"),
134 V.ParentPkg().FullName(true).c_str(),V.VerStr());
135 Header = true;
136
137 // Print out the dep type
138 cout << " " << End.DepType() << ": ";
139
140 // Show the group
141 Start = RealStart;
142 do
143 {
144 cout << Start.TargetPkg().FullName(true);
145 if (Start.TargetVer() != 0)
146 cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
147 ")";
148 if (Start == End)
149 break;
150 cout << " | ";
151 Start++;
152 }
153 while (1);
154
155 cout << endl;
156 }
157 return true;
158 }
159 bool UnMet(CommandLine &CmdL)
160 {
161 bool const Important = _config->FindB("APT::Cache::Important",false);
162
163 pkgCacheFile CacheFile;
164 if (unlikely(CacheFile.GetPkgCache() == NULL))
165 return false;
166
167 if (CmdL.FileSize() <= 1)
168 {
169 for (pkgCache::PkgIterator P = CacheFile.GetPkgCache()->PkgBegin(); P.end() == false; P++)
170 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
171 if (ShowUnMet(V, Important) == false)
172 return false;
173 }
174 else
175 {
176 APT::VersionSet verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1);
177 for (APT::VersionSet::iterator V = verset.begin(); V != verset.end(); ++V)
178 if (ShowUnMet(V, Important) == false)
179 return false;
180 }
181 return true;
182 }
183 /*}}}*/
184 // DumpPackage - Show a dump of a package record /*{{{*/
185 // ---------------------------------------------------------------------
186 /* */
187 bool DumpPackage(CommandLine &CmdL)
188 {
189 pkgCacheFile CacheFile;
190 APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList + 1);
191
192 for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
193 {
194 cout << "Package: " << Pkg.FullName(true) << endl;
195 cout << "Versions: " << endl;
196 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
197 {
198 cout << Cur.VerStr();
199 for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
200 cout << " (" << Vf.File().FileName() << ")";
201 cout << endl;
202 for (pkgCache::DescIterator D = Cur.DescriptionList(); D.end() == false; D++)
203 {
204 cout << " Description Language: " << D.LanguageCode() << endl
205 << " File: " << D.FileList().File().FileName() << endl
206 << " MD5: " << D.md5() << endl;
207 }
208 cout << endl;
209 }
210
211 cout << endl;
212
213 cout << "Reverse Depends: " << endl;
214 for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
215 {
216 cout << " " << D.ParentPkg().FullName(true) << ',' << D.TargetPkg().FullName(true);
217 if (D->Version != 0)
218 cout << ' ' << DeNull(D.TargetVer()) << endl;
219 else
220 cout << endl;
221 }
222
223 cout << "Dependencies: " << endl;
224 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
225 {
226 cout << Cur.VerStr() << " - ";
227 for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
228 cout << Dep.TargetPkg().FullName(true) << " (" << (int)Dep->CompareOp << " " << DeNull(Dep.TargetVer()) << ") ";
229 cout << endl;
230 }
231
232 cout << "Provides: " << endl;
233 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
234 {
235 cout << Cur.VerStr() << " - ";
236 for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; Prv++)
237 cout << Prv.ParentPkg().FullName(true) << " ";
238 cout << endl;
239 }
240 cout << "Reverse Provides: " << endl;
241 for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
242 cout << Prv.OwnerPkg().FullName(true) << " " << Prv.OwnerVer().VerStr() << endl;
243 }
244
245 return true;
246 }
247 /*}}}*/
248 // Stats - Dump some nice statistics /*{{{*/
249 // ---------------------------------------------------------------------
250 /* */
251 bool Stats(CommandLine &Cmd)
252 {
253 pkgCacheFile CacheFile;
254 pkgCache *Cache = CacheFile.GetPkgCache();
255 if (unlikely(Cache == NULL))
256 return false;
257
258 cout << _("Total package names: ") << Cache->Head().GroupCount << " (" <<
259 SizeToStr(Cache->Head().GroupCount*Cache->Head().GroupSz) << ')' << endl
260 << _("Total package structures: ") << Cache->Head().PackageCount << " (" <<
261 SizeToStr(Cache->Head().PackageCount*Cache->Head().PackageSz) << ')' << endl;
262
263 int Normal = 0;
264 int Virtual = 0;
265 int NVirt = 0;
266 int DVirt = 0;
267 int Missing = 0;
268 pkgCache::PkgIterator I = Cache->PkgBegin();
269 for (;I.end() != true; I++)
270 {
271 if (I->VersionList != 0 && I->ProvidesList == 0)
272 {
273 Normal++;
274 continue;
275 }
276
277 if (I->VersionList != 0 && I->ProvidesList != 0)
278 {
279 NVirt++;
280 continue;
281 }
282
283 if (I->VersionList == 0 && I->ProvidesList != 0)
284 {
285 // Only 1 provides
286 if (I.ProvidesList()->NextProvides == 0)
287 {
288 DVirt++;
289 }
290 else
291 Virtual++;
292 continue;
293 }
294 if (I->VersionList == 0 && I->ProvidesList == 0)
295 {
296 Missing++;
297 continue;
298 }
299 }
300 cout << _(" Normal packages: ") << Normal << endl;
301 cout << _(" Pure virtual packages: ") << Virtual << endl;
302 cout << _(" Single virtual packages: ") << DVirt << endl;
303 cout << _(" Mixed virtual packages: ") << NVirt << endl;
304 cout << _(" Missing: ") << Missing << endl;
305
306 cout << _("Total distinct versions: ") << Cache->Head().VersionCount << " (" <<
307 SizeToStr(Cache->Head().VersionCount*Cache->Head().VersionSz) << ')' << endl;
308 cout << _("Total distinct descriptions: ") << Cache->Head().DescriptionCount << " (" <<
309 SizeToStr(Cache->Head().DescriptionCount*Cache->Head().DescriptionSz) << ')' << endl;
310 cout << _("Total dependencies: ") << Cache->Head().DependsCount << " (" <<
311 SizeToStr(Cache->Head().DependsCount*Cache->Head().DependencySz) << ')' << endl;
312
313 cout << _("Total ver/file relations: ") << Cache->Head().VerFileCount << " (" <<
314 SizeToStr(Cache->Head().VerFileCount*Cache->Head().VerFileSz) << ')' << endl;
315 cout << _("Total Desc/File relations: ") << Cache->Head().DescFileCount << " (" <<
316 SizeToStr(Cache->Head().DescFileCount*Cache->Head().DescFileSz) << ')' << endl;
317 cout << _("Total Provides mappings: ") << Cache->Head().ProvidesCount << " (" <<
318 SizeToStr(Cache->Head().ProvidesCount*Cache->Head().ProvidesSz) << ')' << endl;
319
320 // String list stats
321 unsigned long Size = 0;
322 unsigned long Count = 0;
323 for (pkgCache::StringItem *I = Cache->StringItemP + Cache->Head().StringList;
324 I!= Cache->StringItemP; I = Cache->StringItemP + I->NextItem)
325 {
326 Count++;
327 Size += strlen(Cache->StrP + I->String) + 1;
328 }
329 cout << _("Total globbed strings: ") << Count << " (" << SizeToStr(Size) << ')' << endl;
330
331 unsigned long DepVerSize = 0;
332 for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; P++)
333 {
334 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
335 {
336 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
337 {
338 if (D->Version != 0)
339 DepVerSize += strlen(D.TargetVer()) + 1;
340 }
341 }
342 }
343 cout << _("Total dependency version space: ") << SizeToStr(DepVerSize) << endl;
344
345 unsigned long Slack = 0;
346 for (int I = 0; I != 7; I++)
347 Slack += Cache->Head().Pools[I].ItemSize*Cache->Head().Pools[I].Count;
348 cout << _("Total slack space: ") << SizeToStr(Slack) << endl;
349
350 unsigned long Total = 0;
351 Total = Slack + Size + Cache->Head().DependsCount*Cache->Head().DependencySz +
352 Cache->Head().VersionCount*Cache->Head().VersionSz +
353 Cache->Head().PackageCount*Cache->Head().PackageSz +
354 Cache->Head().VerFileCount*Cache->Head().VerFileSz +
355 Cache->Head().ProvidesCount*Cache->Head().ProvidesSz;
356 cout << _("Total space accounted for: ") << SizeToStr(Total) << endl;
357
358 return true;
359 }
360 /*}}}*/
361 // Dump - show everything /*{{{*/
362 // ---------------------------------------------------------------------
363 /* This is worthless except fer debugging things */
364 bool Dump(CommandLine &Cmd)
365 {
366 pkgCacheFile CacheFile;
367 pkgCache *Cache = CacheFile.GetPkgCache();
368 if (unlikely(Cache == NULL))
369 return false;
370
371 cout << "Using Versioning System: " << Cache->VS->Label << endl;
372
373 for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; P++)
374 {
375 cout << "Package: " << P.FullName(true) << endl;
376 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
377 {
378 cout << " Version: " << V.VerStr() << endl;
379 cout << " File: " << V.FileList().File().FileName() << endl;
380 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
381 cout << " Depends: " << D.TargetPkg().FullName(true) << ' ' <<
382 DeNull(D.TargetVer()) << endl;
383 for (pkgCache::DescIterator D = V.DescriptionList(); D.end() == false; D++)
384 {
385 cout << " Description Language: " << D.LanguageCode() << endl
386 << " File: " << D.FileList().File().FileName() << endl
387 << " MD5: " << D.md5() << endl;
388 }
389 }
390 }
391
392 for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; F++)
393 {
394 cout << "File: " << F.FileName() << endl;
395 cout << " Type: " << F.IndexType() << endl;
396 cout << " Size: " << F->Size << endl;
397 cout << " ID: " << F->ID << endl;
398 cout << " Flags: " << F->Flags << endl;
399 cout << " Time: " << TimeRFC1123(F->mtime) << endl;
400 cout << " Archive: " << DeNull(F.Archive()) << endl;
401 cout << " Component: " << DeNull(F.Component()) << endl;
402 cout << " Version: " << DeNull(F.Version()) << endl;
403 cout << " Origin: " << DeNull(F.Origin()) << endl;
404 cout << " Site: " << DeNull(F.Site()) << endl;
405 cout << " Label: " << DeNull(F.Label()) << endl;
406 cout << " Architecture: " << DeNull(F.Architecture()) << endl;
407 }
408
409 return true;
410 }
411 /*}}}*/
412 // DumpAvail - Print out the available list /*{{{*/
413 // ---------------------------------------------------------------------
414 /* This is needed to make dpkg --merge happy.. I spent a bit of time to
415 make this run really fast, perhaps I went a little overboard.. */
416 bool DumpAvail(CommandLine &Cmd)
417 {
418 pkgCacheFile CacheFile;
419 pkgCache *Cache = CacheFile.GetPkgCache();
420 if (unlikely(Cache == NULL || CacheFile.BuildPolicy() == false))
421 return false;
422
423 unsigned long Count = Cache->HeaderP->PackageCount+1;
424 pkgCache::VerFile **VFList = new pkgCache::VerFile *[Count];
425 memset(VFList,0,sizeof(*VFList)*Count);
426
427 // Map versions that we want to write out onto the VerList array.
428 for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; P++)
429 {
430 if (P->VersionList == 0)
431 continue;
432
433 /* Find the proper version to use. If the policy says there are no
434 possible selections we return the installed version, if available..
435 This prevents dselect from making it obsolete. */
436 pkgCache::VerIterator V = CacheFile.GetPolicy()->GetCandidateVer(P);
437 if (V.end() == true)
438 {
439 if (P->CurrentVer == 0)
440 continue;
441 V = P.CurrentVer();
442 }
443
444 pkgCache::VerFileIterator VF = V.FileList();
445 for (; VF.end() == false ; VF++)
446 if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
447 break;
448
449 /* Okay, here we have a bit of a problem.. The policy has selected the
450 currently installed package - however it only exists in the
451 status file.. We need to write out something or dselect will mark
452 the package as obsolete! Thus we emit the status file entry, but
453 below we remove the status line to make it valid for the
454 available file. However! We only do this if their do exist *any*
455 non-source versions of the package - that way the dselect obsolete
456 handling works OK. */
457 if (VF.end() == true)
458 {
459 for (pkgCache::VerIterator Cur = P.VersionList(); Cur.end() != true; Cur++)
460 {
461 for (VF = Cur.FileList(); VF.end() == false; VF++)
462 {
463 if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
464 {
465 VF = V.FileList();
466 break;
467 }
468 }
469
470 if (VF.end() == false)
471 break;
472 }
473 }
474
475 VFList[P->ID] = VF;
476 }
477
478 LocalitySort(VFList,Count,sizeof(*VFList));
479
480 // Iterate over all the package files and write them out.
481 char *Buffer = new char[Cache->HeaderP->MaxVerFileSize+10];
482 for (pkgCache::VerFile **J = VFList; *J != 0;)
483 {
484 pkgCache::PkgFileIterator File(*Cache,(*J)->File + Cache->PkgFileP);
485 if (File.IsOk() == false)
486 {
487 _error->Error(_("Package file %s is out of sync."),File.FileName());
488 break;
489 }
490
491 FileFd PkgF(File.FileName(),FileFd::ReadOnly);
492 if (_error->PendingError() == true)
493 break;
494
495 /* Write all of the records from this package file, since we
496 already did locality sorting we can now just seek through the
497 file in read order. We apply 1 more optimization here, since often
498 there will be < 1 byte gaps between records (for the \n) we read that
499 into the next buffer and offset a bit.. */
500 unsigned long Pos = 0;
501 for (; *J != 0; J++)
502 {
503 if ((*J)->File + Cache->PkgFileP != File)
504 break;
505
506 const pkgCache::VerFile &VF = **J;
507
508 // Read the record and then write it out again.
509 unsigned long Jitter = VF.Offset - Pos;
510 if (Jitter > 8)
511 {
512 if (PkgF.Seek(VF.Offset) == false)
513 break;
514 Jitter = 0;
515 }
516
517 if (PkgF.Read(Buffer,VF.Size + Jitter) == false)
518 break;
519 Buffer[VF.Size + Jitter] = '\n';
520
521 // See above..
522 if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
523 {
524 pkgTagSection Tags;
525 TFRewriteData RW[] = {{"Status",0},{"Config-Version",0},{}};
526 const char *Zero = 0;
527 if (Tags.Scan(Buffer+Jitter,VF.Size+1) == false ||
528 TFRewrite(stdout,Tags,&Zero,RW) == false)
529 {
530 _error->Error("Internal Error, Unable to parse a package record");
531 break;
532 }
533 fputc('\n',stdout);
534 }
535 else
536 {
537 if (fwrite(Buffer+Jitter,VF.Size+1,1,stdout) != 1)
538 break;
539 }
540
541 Pos = VF.Offset + VF.Size;
542 }
543
544 fflush(stdout);
545 if (_error->PendingError() == true)
546 break;
547 }
548
549 delete [] Buffer;
550 delete [] VFList;
551 return !_error->PendingError();
552 }
553 /*}}}*/
554 // ShowDepends - Helper for printing out a dependency tree /*{{{*/
555 class CacheSetHelperDepends: public APT::CacheSetHelper {
556 public:
557 APT::PackageSet virtualPkgs;
558
559 virtual pkgCache::VerIterator canNotFindCandidateVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
560 virtualPkgs.insert(Pkg);
561 return pkgCache::VerIterator(Cache, 0);
562 }
563
564 virtual pkgCache::VerIterator canNotFindNewestVer(pkgCacheFile &Cache, pkgCache::PkgIterator const &Pkg) {
565 virtualPkgs.insert(Pkg);
566 return pkgCache::VerIterator(Cache, 0);
567 }
568
569 CacheSetHelperDepends() : CacheSetHelper(false) {}
570 };
571 bool ShowDepends(CommandLine &CmdL, bool const RevDepends)
572 {
573 pkgCacheFile CacheFile;
574 pkgCache *Cache = CacheFile.GetPkgCache();
575 if (unlikely(Cache == NULL))
576 return false;
577
578 CacheSetHelperDepends helper;
579 APT::VersionSet verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1, APT::VersionSet::CANDIDATE, helper);
580 if (verset.empty() == true && helper.virtualPkgs.empty() == true)
581 return false;
582 std::vector<bool> Shown(Cache->Head().PackageCount);
583
584 bool const Recurse = _config->FindB("APT::Cache::RecurseDepends", false);
585 bool const Installed = _config->FindB("APT::Cache::Installed", false);
586 bool const Important = _config->FindB("APT::Cache::Important", false);
587 bool const ShowDepType = _config->FindB("APT::Cache::ShowDependencyType", RevDepends == false);
588 bool const ShowPreDepends = _config->FindB("APT::Cache::ShowPre-Depends", true);
589 bool const ShowDepends = _config->FindB("APT::Cache::ShowDepends", true);
590 bool const ShowRecommends = _config->FindB("APT::Cache::ShowRecommends", Important == false);
591 bool const ShowSuggests = _config->FindB("APT::Cache::ShowSuggests", Important == false);
592 bool const ShowReplaces = _config->FindB("APT::Cache::ShowReplaces", Important == false);
593 bool const ShowConflicts = _config->FindB("APT::Cache::ShowConflicts", Important == false);
594 bool const ShowBreaks = _config->FindB("APT::Cache::ShowBreaks", Important == false);
595 bool const ShowEnhances = _config->FindB("APT::Cache::ShowEnhances", Important == false);
596 bool const ShowOnlyFirstOr = _config->FindB("APT::Cache::ShowOnlyFirstOr", false);
597
598 while (verset.empty() != true)
599 {
600 pkgCache::VerIterator Ver = *verset.begin();
601 verset.erase(verset.begin());
602 pkgCache::PkgIterator Pkg = Ver.ParentPkg();
603 Shown[Pkg->ID] = true;
604
605 cout << Pkg.FullName(true) << endl;
606
607 if (RevDepends == true)
608 cout << "Reverse Depends:" << endl;
609 for (pkgCache::DepIterator D = RevDepends ? Pkg.RevDependsList() : Ver.DependsList();
610 D.end() == false; D++)
611 {
612 switch (D->Type) {
613 case pkgCache::Dep::PreDepends: if (!ShowPreDepends) continue; break;
614 case pkgCache::Dep::Depends: if (!ShowDepends) continue; break;
615 case pkgCache::Dep::Recommends: if (!ShowRecommends) continue; break;
616 case pkgCache::Dep::Suggests: if (!ShowSuggests) continue; break;
617 case pkgCache::Dep::Replaces: if (!ShowReplaces) continue; break;
618 case pkgCache::Dep::Conflicts: if (!ShowConflicts) continue; break;
619 case pkgCache::Dep::DpkgBreaks: if (!ShowBreaks) continue; break;
620 case pkgCache::Dep::Enhances: if (!ShowEnhances) continue; break;
621 }
622
623 pkgCache::PkgIterator Trg = RevDepends ? D.ParentPkg() : D.TargetPkg();
624
625 if((Installed && Trg->CurrentVer != 0) || !Installed)
626 {
627
628 if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or && ShowOnlyFirstOr == false)
629 cout << " |";
630 else
631 cout << " ";
632
633 // Show the package
634 if (ShowDepType == true)
635 cout << D.DepType() << ": ";
636 if (Trg->VersionList == 0)
637 cout << "<" << Trg.FullName(true) << ">" << endl;
638 else
639 cout << Trg.FullName(true) << endl;
640
641 if (Recurse == true && Shown[Trg->ID] == false)
642 {
643 Shown[Trg->ID] = true;
644 verset.insert(APT::VersionSet::FromPackage(CacheFile, Trg, APT::VersionSet::CANDIDATE, helper));
645 }
646
647 }
648
649 // Display all solutions
650 SPtrArray<pkgCache::Version *> List = D.AllTargets();
651 pkgPrioSortList(*Cache,List);
652 for (pkgCache::Version **I = List; *I != 0; I++)
653 {
654 pkgCache::VerIterator V(*Cache,*I);
655 if (V != Cache->VerP + V.ParentPkg()->VersionList ||
656 V->ParentPkg == D->Package)
657 continue;
658 cout << " " << V.ParentPkg().FullName(true) << endl;
659
660 if (Recurse == true && Shown[V.ParentPkg()->ID] == false)
661 {
662 Shown[V.ParentPkg()->ID] = true;
663 verset.insert(APT::VersionSet::FromPackage(CacheFile, V.ParentPkg(), APT::VersionSet::CANDIDATE, helper));
664 }
665 }
666
667 if (ShowOnlyFirstOr == true)
668 while ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or) ++D;
669 }
670 }
671
672 for (APT::PackageSet::const_iterator Pkg = helper.virtualPkgs.begin();
673 Pkg != helper.virtualPkgs.end(); ++Pkg)
674 cout << '<' << Pkg.FullName(true) << '>' << endl;
675
676 return true;
677 }
678 /*}}}*/
679 // Depends - Print out a dependency tree /*{{{*/
680 // ---------------------------------------------------------------------
681 /* */
682 bool Depends(CommandLine &CmdL)
683 {
684 return ShowDepends(CmdL, false);
685 }
686 /*}}}*/
687 // RDepends - Print out a reverse dependency tree /*{{{*/
688 // ---------------------------------------------------------------------
689 /* */
690 bool RDepends(CommandLine &CmdL)
691 {
692 return ShowDepends(CmdL, true);
693 }
694 /*}}}*/
695 // xvcg - Generate a graph for xvcg /*{{{*/
696 // ---------------------------------------------------------------------
697 // Code contributed from Junichi Uekawa <dancer@debian.org> on 20 June 2002.
698
699 bool XVcg(CommandLine &CmdL)
700 {
701 pkgCacheFile CacheFile;
702 pkgCache *Cache = CacheFile.GetPkgCache();
703 if (unlikely(Cache == NULL))
704 return false;
705
706 bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
707
708 /* Normal packages are boxes
709 Pure Provides are triangles
710 Mixed are diamonds
711 rhomb are missing packages*/
712 const char *Shapes[] = {"ellipse","triangle","box","rhomb"};
713
714 /* Initialize the list of packages to show.
715 1 = To Show
716 2 = To Show no recurse
717 3 = Emitted no recurse
718 4 = Emitted
719 0 = None */
720 enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
721 enum TheFlags {ForceNR=(1<<0)};
722 unsigned char *Show = new unsigned char[Cache->Head().PackageCount];
723 unsigned char *Flags = new unsigned char[Cache->Head().PackageCount];
724 unsigned char *ShapeMap = new unsigned char[Cache->Head().PackageCount];
725
726 // Show everything if no arguments given
727 if (CmdL.FileList[1] == 0)
728 for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
729 Show[I] = ToShow;
730 else
731 for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
732 Show[I] = None;
733 memset(Flags,0,sizeof(*Flags)*Cache->Head().PackageCount);
734
735 // Map the shapes
736 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
737 {
738 if (Pkg->VersionList == 0)
739 {
740 // Missing
741 if (Pkg->ProvidesList == 0)
742 ShapeMap[Pkg->ID] = 0;
743 else
744 ShapeMap[Pkg->ID] = 1;
745 }
746 else
747 {
748 // Normal
749 if (Pkg->ProvidesList == 0)
750 ShapeMap[Pkg->ID] = 2;
751 else
752 ShapeMap[Pkg->ID] = 3;
753 }
754 }
755
756 // Load the list of packages from the command line into the show list
757 std::list<APT::PackageSet::Modifier> mods;
758 mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
759 mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
760 std::map<unsigned short, APT::PackageSet> pkgsets =
761 APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0);
762
763 for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
764 Pkg != pkgsets[0].end(); ++Pkg)
765 Show[Pkg->ID] = ToShow;
766 for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
767 Pkg != pkgsets[1].end(); ++Pkg)
768 {
769 Show[Pkg->ID] = ToShow;
770 Flags[Pkg->ID] |= ForceNR;
771 }
772
773 // Little header
774 cout << "graph: { title: \"packages\"" << endl <<
775 "xmax: 700 ymax: 700 x: 30 y: 30" << endl <<
776 "layout_downfactor: 8" << endl;
777
778 bool Act = true;
779 while (Act == true)
780 {
781 Act = false;
782 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
783 {
784 // See we need to show this package
785 if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
786 continue;
787
788 //printf ("node: { title: \"%s\" label: \"%s\" }\n", Pkg.Name(), Pkg.Name());
789
790 // Colour as done
791 if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
792 {
793 // Pure Provides and missing packages have no deps!
794 if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
795 Show[Pkg->ID] = Done;
796 else
797 Show[Pkg->ID] = DoneNR;
798 }
799 else
800 Show[Pkg->ID] = Done;
801 Act = true;
802
803 // No deps to map out
804 if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
805 continue;
806
807 pkgCache::VerIterator Ver = Pkg.VersionList();
808 for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
809 {
810 // See if anything can meet this dep
811 // Walk along the actual package providing versions
812 bool Hit = false;
813 pkgCache::PkgIterator DPkg = D.TargetPkg();
814 for (pkgCache::VerIterator I = DPkg.VersionList();
815 I.end() == false && Hit == false; I++)
816 {
817 if (Cache->VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
818 Hit = true;
819 }
820
821 // Follow all provides
822 for (pkgCache::PrvIterator I = DPkg.ProvidesList();
823 I.end() == false && Hit == false; I++)
824 {
825 if (Cache->VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
826 Hit = true;
827 }
828
829
830 // Only graph critical deps
831 if (D.IsCritical() == true)
832 {
833 printf ("edge: { sourcename: \"%s\" targetname: \"%s\" class: 2 ",Pkg.FullName(true).c_str(), D.TargetPkg().FullName(true).c_str() );
834
835 // Colour the node for recursion
836 if (Show[D.TargetPkg()->ID] <= DoneNR)
837 {
838 /* If a conflicts does not meet anything in the database
839 then show the relation but do not recurse */
840 if (Hit == false &&
841 (D->Type == pkgCache::Dep::Conflicts ||
842 D->Type == pkgCache::Dep::DpkgBreaks ||
843 D->Type == pkgCache::Dep::Obsoletes))
844 {
845 if (Show[D.TargetPkg()->ID] == None &&
846 Show[D.TargetPkg()->ID] != ToShow)
847 Show[D.TargetPkg()->ID] = ToShowNR;
848 }
849 else
850 {
851 if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
852 Show[D.TargetPkg()->ID] = ToShowNR;
853 else
854 Show[D.TargetPkg()->ID] = ToShow;
855 }
856 }
857
858 // Edge colour
859 switch(D->Type)
860 {
861 case pkgCache::Dep::Conflicts:
862 printf("label: \"conflicts\" color: lightgreen }\n");
863 break;
864 case pkgCache::Dep::DpkgBreaks:
865 printf("label: \"breaks\" color: lightgreen }\n");
866 break;
867 case pkgCache::Dep::Obsoletes:
868 printf("label: \"obsoletes\" color: lightgreen }\n");
869 break;
870
871 case pkgCache::Dep::PreDepends:
872 printf("label: \"predepends\" color: blue }\n");
873 break;
874
875 default:
876 printf("}\n");
877 break;
878 }
879 }
880 }
881 }
882 }
883
884 /* Draw the box colours after the fact since we can not tell what colour
885 they should be until everything is finished drawing */
886 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
887 {
888 if (Show[Pkg->ID] < DoneNR)
889 continue;
890
891 if (Show[Pkg->ID] == DoneNR)
892 printf("node: { title: \"%s\" label: \"%s\" color: orange shape: %s }\n", Pkg.FullName(true).c_str(), Pkg.FullName(true).c_str(),
893 Shapes[ShapeMap[Pkg->ID]]);
894 else
895 printf("node: { title: \"%s\" label: \"%s\" shape: %s }\n", Pkg.FullName(true).c_str(), Pkg.FullName(true).c_str(),
896 Shapes[ShapeMap[Pkg->ID]]);
897
898 }
899
900 delete[] Show;
901 delete[] Flags;
902 delete[] ShapeMap;
903
904 printf("}\n");
905 return true;
906 }
907 /*}}}*/
908 // Dotty - Generate a graph for Dotty /*{{{*/
909 // ---------------------------------------------------------------------
910 /* Dotty is the graphvis program for generating graphs. It is a fairly
911 simple queuing algorithm that just writes dependencies and nodes.
912 http://www.research.att.com/sw/tools/graphviz/ */
913 bool Dotty(CommandLine &CmdL)
914 {
915 pkgCacheFile CacheFile;
916 pkgCache *Cache = CacheFile.GetPkgCache();
917 if (unlikely(Cache == NULL))
918 return false;
919
920 bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
921
922 /* Normal packages are boxes
923 Pure Provides are triangles
924 Mixed are diamonds
925 Hexagons are missing packages*/
926 const char *Shapes[] = {"hexagon","triangle","box","diamond"};
927
928 /* Initialize the list of packages to show.
929 1 = To Show
930 2 = To Show no recurse
931 3 = Emitted no recurse
932 4 = Emitted
933 0 = None */
934 enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
935 enum TheFlags {ForceNR=(1<<0)};
936 unsigned char *Show = new unsigned char[Cache->Head().PackageCount];
937 unsigned char *Flags = new unsigned char[Cache->Head().PackageCount];
938 unsigned char *ShapeMap = new unsigned char[Cache->Head().PackageCount];
939
940 // Show everything if no arguments given
941 if (CmdL.FileList[1] == 0)
942 for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
943 Show[I] = ToShow;
944 else
945 for (unsigned long I = 0; I != Cache->Head().PackageCount; I++)
946 Show[I] = None;
947 memset(Flags,0,sizeof(*Flags)*Cache->Head().PackageCount);
948
949 // Map the shapes
950 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
951 {
952 if (Pkg->VersionList == 0)
953 {
954 // Missing
955 if (Pkg->ProvidesList == 0)
956 ShapeMap[Pkg->ID] = 0;
957 else
958 ShapeMap[Pkg->ID] = 1;
959 }
960 else
961 {
962 // Normal
963 if (Pkg->ProvidesList == 0)
964 ShapeMap[Pkg->ID] = 2;
965 else
966 ShapeMap[Pkg->ID] = 3;
967 }
968 }
969
970 // Load the list of packages from the command line into the show list
971 std::list<APT::PackageSet::Modifier> mods;
972 mods.push_back(APT::PackageSet::Modifier(0, ",", APT::PackageSet::Modifier::POSTFIX));
973 mods.push_back(APT::PackageSet::Modifier(1, "^", APT::PackageSet::Modifier::POSTFIX));
974 std::map<unsigned short, APT::PackageSet> pkgsets =
975 APT::PackageSet::GroupedFromCommandLine(CacheFile, CmdL.FileList + 1, mods, 0);
976
977 for (APT::PackageSet::const_iterator Pkg = pkgsets[0].begin();
978 Pkg != pkgsets[0].end(); ++Pkg)
979 Show[Pkg->ID] = ToShow;
980 for (APT::PackageSet::const_iterator Pkg = pkgsets[1].begin();
981 Pkg != pkgsets[1].end(); ++Pkg)
982 {
983 Show[Pkg->ID] = ToShow;
984 Flags[Pkg->ID] |= ForceNR;
985 }
986
987 // Little header
988 printf("digraph packages {\n");
989 printf("concentrate=true;\n");
990 printf("size=\"30,40\";\n");
991
992 bool Act = true;
993 while (Act == true)
994 {
995 Act = false;
996 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
997 {
998 // See we need to show this package
999 if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
1000 continue;
1001
1002 // Colour as done
1003 if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
1004 {
1005 // Pure Provides and missing packages have no deps!
1006 if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
1007 Show[Pkg->ID] = Done;
1008 else
1009 Show[Pkg->ID] = DoneNR;
1010 }
1011 else
1012 Show[Pkg->ID] = Done;
1013 Act = true;
1014
1015 // No deps to map out
1016 if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
1017 continue;
1018
1019 pkgCache::VerIterator Ver = Pkg.VersionList();
1020 for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
1021 {
1022 // See if anything can meet this dep
1023 // Walk along the actual package providing versions
1024 bool Hit = false;
1025 pkgCache::PkgIterator DPkg = D.TargetPkg();
1026 for (pkgCache::VerIterator I = DPkg.VersionList();
1027 I.end() == false && Hit == false; I++)
1028 {
1029 if (Cache->VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
1030 Hit = true;
1031 }
1032
1033 // Follow all provides
1034 for (pkgCache::PrvIterator I = DPkg.ProvidesList();
1035 I.end() == false && Hit == false; I++)
1036 {
1037 if (Cache->VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
1038 Hit = true;
1039 }
1040
1041 // Only graph critical deps
1042 if (D.IsCritical() == true)
1043 {
1044 printf("\"%s\" -> \"%s\"",Pkg.FullName(true).c_str(),D.TargetPkg().FullName(true).c_str());
1045
1046 // Colour the node for recursion
1047 if (Show[D.TargetPkg()->ID] <= DoneNR)
1048 {
1049 /* If a conflicts does not meet anything in the database
1050 then show the relation but do not recurse */
1051 if (Hit == false &&
1052 (D->Type == pkgCache::Dep::Conflicts ||
1053 D->Type == pkgCache::Dep::Obsoletes))
1054 {
1055 if (Show[D.TargetPkg()->ID] == None &&
1056 Show[D.TargetPkg()->ID] != ToShow)
1057 Show[D.TargetPkg()->ID] = ToShowNR;
1058 }
1059 else
1060 {
1061 if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
1062 Show[D.TargetPkg()->ID] = ToShowNR;
1063 else
1064 Show[D.TargetPkg()->ID] = ToShow;
1065 }
1066 }
1067
1068 // Edge colour
1069 switch(D->Type)
1070 {
1071 case pkgCache::Dep::Conflicts:
1072 case pkgCache::Dep::Obsoletes:
1073 printf("[color=springgreen];\n");
1074 break;
1075
1076 case pkgCache::Dep::PreDepends:
1077 printf("[color=blue];\n");
1078 break;
1079
1080 default:
1081 printf(";\n");
1082 break;
1083 }
1084 }
1085 }
1086 }
1087 }
1088
1089 /* Draw the box colours after the fact since we can not tell what colour
1090 they should be until everything is finished drawing */
1091 for (pkgCache::PkgIterator Pkg = Cache->PkgBegin(); Pkg.end() == false; Pkg++)
1092 {
1093 if (Show[Pkg->ID] < DoneNR)
1094 continue;
1095
1096 // Orange box for early recursion stoppage
1097 if (Show[Pkg->ID] == DoneNR)
1098 printf("\"%s\" [color=orange,shape=%s];\n",Pkg.FullName(true).c_str(),
1099 Shapes[ShapeMap[Pkg->ID]]);
1100 else
1101 printf("\"%s\" [shape=%s];\n",Pkg.FullName(true).c_str(),
1102 Shapes[ShapeMap[Pkg->ID]]);
1103 }
1104
1105 printf("}\n");
1106 return true;
1107 }
1108 /*}}}*/
1109 // DoAdd - Perform an adding operation /*{{{*/
1110 // ---------------------------------------------------------------------
1111 /* */
1112 bool DoAdd(CommandLine &CmdL)
1113 {
1114 return _error->Error("Unimplemented");
1115 #if 0
1116 // Make sure there is at least one argument
1117 if (CmdL.FileSize() <= 1)
1118 return _error->Error("You must give at least one file name");
1119
1120 // Open the cache
1121 FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
1122 if (_error->PendingError() == true)
1123 return false;
1124
1125 DynamicMMap Map(CacheF,MMap::Public);
1126 if (_error->PendingError() == true)
1127 return false;
1128
1129 OpTextProgress Progress(*_config);
1130 pkgCacheGenerator Gen(Map,Progress);
1131 if (_error->PendingError() == true)
1132 return false;
1133
1134 unsigned long Length = CmdL.FileSize() - 1;
1135 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1136 {
1137 Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
1138 Progress.SubProgress(Length);
1139
1140 // Do the merge
1141 FileFd TagF(*I,FileFd::ReadOnly);
1142 debListParser Parser(TagF);
1143 if (_error->PendingError() == true)
1144 return _error->Error("Problem opening %s",*I);
1145
1146 if (Gen.SelectFile(*I,"") == false)
1147 return _error->Error("Problem with SelectFile");
1148
1149 if (Gen.MergeList(Parser) == false)
1150 return _error->Error("Problem with MergeList");
1151 }
1152
1153 Progress.Done();
1154 GCache = &Gen.GetCache();
1155 Stats(CmdL);
1156
1157 return true;
1158 #endif
1159 }
1160 /*}}}*/
1161 // DisplayRecord - Displays the complete record for the package /*{{{*/
1162 // ---------------------------------------------------------------------
1163 /* This displays the package record from the proper package index file.
1164 It is not used by DumpAvail for performance reasons. */
1165 bool DisplayRecord(pkgCacheFile &CacheFile, pkgCache::VerIterator V)
1166 {
1167 pkgCache *Cache = CacheFile.GetPkgCache();
1168 if (unlikely(Cache == NULL))
1169 return false;
1170
1171 // Find an appropriate file
1172 pkgCache::VerFileIterator Vf = V.FileList();
1173 for (; Vf.end() == false; Vf++)
1174 if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
1175 break;
1176 if (Vf.end() == true)
1177 Vf = V.FileList();
1178
1179 // Check and load the package list file
1180 pkgCache::PkgFileIterator I = Vf.File();
1181 if (I.IsOk() == false)
1182 return _error->Error(_("Package file %s is out of sync."),I.FileName());
1183
1184 FileFd PkgF;
1185 if (PkgF.Open(I.FileName(), FileFd::ReadOnlyGzip) == false)
1186 return false;
1187
1188 // Read the record
1189 unsigned char *Buffer = new unsigned char[Cache->HeaderP->MaxVerFileSize+1];
1190 Buffer[V.FileList()->Size] = '\n';
1191 if (PkgF.Seek(V.FileList()->Offset) == false ||
1192 PkgF.Read(Buffer,V.FileList()->Size) == false)
1193 {
1194 delete [] Buffer;
1195 return false;
1196 }
1197
1198 // Get a pointer to start of Description field
1199 const unsigned char *DescP = (unsigned char*)strstr((char*)Buffer, "Description:");
1200
1201 // Write all but Description
1202 if (fwrite(Buffer,1,DescP - Buffer,stdout) < (size_t)(DescP - Buffer))
1203 {
1204 delete [] Buffer;
1205 return false;
1206 }
1207
1208 // Show the right description
1209 pkgRecords Recs(*Cache);
1210 pkgCache::DescIterator Desc = V.TranslatedDescription();
1211 pkgRecords::Parser &P = Recs.Lookup(Desc.FileList());
1212 cout << "Description" << ( (strcmp(Desc.LanguageCode(),"") != 0) ? "-" : "" ) << Desc.LanguageCode() << ": " << P.LongDesc();
1213
1214 // Find the first field after the description (if there is any)
1215 for(DescP++;DescP != &Buffer[V.FileList()->Size];DescP++)
1216 {
1217 if(*DescP == '\n' && *(DescP+1) != ' ')
1218 {
1219 // write the rest of the buffer
1220 const unsigned char *end=&Buffer[V.FileList()->Size];
1221 if (fwrite(DescP,1,end-DescP,stdout) < (size_t)(end-DescP))
1222 {
1223 delete [] Buffer;
1224 return false;
1225 }
1226
1227 break;
1228 }
1229 }
1230 // write a final newline (after the description)
1231 cout<<endl;
1232 delete [] Buffer;
1233
1234 return true;
1235 }
1236 /*}}}*/
1237
1238 struct ExDescFile
1239 {
1240 pkgCache::DescFile *Df;
1241 bool NameMatch;
1242 };
1243
1244 // Search - Perform a search /*{{{*/
1245 // ---------------------------------------------------------------------
1246 /* This searches the package names and package descriptions for a pattern */
1247 bool Search(CommandLine &CmdL)
1248 {
1249 bool const ShowFull = _config->FindB("APT::Cache::ShowFull",false);
1250 bool const NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
1251 unsigned int const NumPatterns = CmdL.FileSize() -1;
1252
1253 pkgCacheFile CacheFile;
1254 pkgCache *Cache = CacheFile.GetPkgCache();
1255 pkgDepCache::Policy *Plcy = CacheFile.GetPolicy();
1256 if (unlikely(Cache == NULL || Plcy == NULL))
1257 return false;
1258
1259 // Make sure there is at least one argument
1260 if (NumPatterns < 1)
1261 return _error->Error(_("You must give at least one search pattern"));
1262
1263 // Compile the regex pattern
1264 regex_t *Patterns = new regex_t[NumPatterns];
1265 memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
1266 for (unsigned I = 0; I != NumPatterns; I++)
1267 {
1268 if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE |
1269 REG_NOSUB) != 0)
1270 {
1271 for (; I != 0; I--)
1272 regfree(&Patterns[I]);
1273 return _error->Error("Regex compilation error");
1274 }
1275 }
1276
1277 if (_error->PendingError() == true)
1278 {
1279 for (unsigned I = 0; I != NumPatterns; I++)
1280 regfree(&Patterns[I]);
1281 return false;
1282 }
1283
1284 ExDescFile *DFList = new ExDescFile[Cache->HeaderP->GroupCount+1];
1285 memset(DFList,0,sizeof(*DFList)*Cache->HeaderP->GroupCount+1);
1286
1287 // Map versions that we want to write out onto the VerList array.
1288 for (pkgCache::GrpIterator G = Cache->GrpBegin(); G.end() == false; ++G)
1289 {
1290 if (DFList[G->ID].NameMatch == true)
1291 continue;
1292
1293 DFList[G->ID].NameMatch = true;
1294 for (unsigned I = 0; I != NumPatterns; I++)
1295 {
1296 if (regexec(&Patterns[I],G.Name(),0,0,0) == 0)
1297 continue;
1298 DFList[G->ID].NameMatch = false;
1299 break;
1300 }
1301
1302 // Doing names only, drop any that dont match..
1303 if (NamesOnly == true && DFList[G->ID].NameMatch == false)
1304 continue;
1305
1306 // Find the proper version to use
1307 pkgCache::PkgIterator P = G.FindPreferredPkg();
1308 if (P.end() == true)
1309 continue;
1310 pkgCache::VerIterator V = Plcy->GetCandidateVer(P);
1311 if (V.end() == false)
1312 DFList[G->ID].Df = V.DescriptionList().FileList();
1313
1314 if (DFList[G->ID].NameMatch == false)
1315 continue;
1316
1317 // Include all the packages that provide matching names too
1318 for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; Prv++)
1319 {
1320 pkgCache::VerIterator V = Plcy->GetCandidateVer(Prv.OwnerPkg());
1321 if (V.end() == true)
1322 continue;
1323
1324 unsigned long id = Prv.OwnerPkg().Group()->ID;
1325 DFList[id].Df = V.DescriptionList().FileList();
1326 DFList[id].NameMatch = true;
1327 }
1328 }
1329
1330 LocalitySort(&DFList->Df,Cache->HeaderP->GroupCount,sizeof(*DFList));
1331
1332 // Create the text record parser
1333 pkgRecords Recs(*Cache);
1334 // Iterate over all the version records and check them
1335 for (ExDescFile *J = DFList; J->Df != 0; J++)
1336 {
1337 pkgRecords::Parser &P = Recs.Lookup(pkgCache::DescFileIterator(*Cache,J->Df));
1338
1339 if (J->NameMatch == false && NamesOnly == false)
1340 {
1341 string const LongDesc = P.LongDesc();
1342 J->NameMatch = true;
1343 for (unsigned I = 0; I != NumPatterns; I++)
1344 {
1345 if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
1346 continue;
1347 J->NameMatch = false;
1348 break;
1349 }
1350 }
1351
1352 if (J->NameMatch == true)
1353 {
1354 if (ShowFull == true)
1355 {
1356 const char *Start;
1357 const char *End;
1358 P.GetRec(Start,End);
1359 fwrite(Start,End-Start,1,stdout);
1360 putc('\n',stdout);
1361 }
1362 else
1363 printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
1364 }
1365 }
1366
1367 delete [] DFList;
1368 for (unsigned I = 0; I != NumPatterns; I++)
1369 regfree(&Patterns[I]);
1370 if (ferror(stdout))
1371 return _error->Error("Write to stdout failed");
1372 return true;
1373 }
1374
1375
1376 /* show automatically installed packages (sorted) */
1377 bool ShowAuto(CommandLine &CmdL)
1378 {
1379 pkgCacheFile CacheFile;
1380 pkgCache *Cache = CacheFile.GetPkgCache();
1381 pkgDepCache *DepCache = CacheFile.GetDepCache();
1382 if (unlikely(Cache == NULL || DepCache == NULL))
1383 return false;
1384
1385 std::vector<string> packages;
1386 packages.reserve(Cache->HeaderP->PackageCount / 3);
1387
1388 for (pkgCache::PkgIterator P = Cache->PkgBegin(); P.end() == false; P++)
1389 if ((*DepCache)[P].Flags & pkgCache::Flag::Auto)
1390 packages.push_back(P.Name());
1391
1392 std::sort(packages.begin(), packages.end());
1393
1394 for (vector<string>::iterator I = packages.begin(); I != packages.end(); I++)
1395 cout << *I << "\n";
1396
1397 return true;
1398 }
1399 /*}}}*/
1400 // ShowPackage - Dump the package record to the screen /*{{{*/
1401 // ---------------------------------------------------------------------
1402 /* */
1403 bool ShowPackage(CommandLine &CmdL)
1404 {
1405 pkgCacheFile CacheFile;
1406 APT::VersionSet::Version const select = _config->FindB("APT::Cache::AllVersions", true) ?
1407 APT::VersionSet::ALL : APT::VersionSet::CANDIDATE;
1408 APT::VersionSet const verset = APT::VersionSet::FromCommandLine(CacheFile, CmdL.FileList + 1, select);
1409 for (APT::VersionSet::const_iterator Ver = verset.begin(); Ver != verset.end(); ++Ver)
1410 if (DisplayRecord(CacheFile, Ver) == false)
1411 return false;
1412
1413 if (verset.empty() == false)
1414 return true;
1415 return _error->Error(_("No packages found"));
1416 }
1417 /*}}}*/
1418 // ShowPkgNames - Show package names /*{{{*/
1419 // ---------------------------------------------------------------------
1420 /* This does a prefix match on the first argument */
1421 bool ShowPkgNames(CommandLine &CmdL)
1422 {
1423 pkgCacheFile CacheFile;
1424 if (unlikely(CacheFile.BuildCaches(NULL, false) == false))
1425 return false;
1426 pkgCache::GrpIterator I = CacheFile.GetPkgCache()->GrpBegin();
1427 bool const All = _config->FindB("APT::Cache::AllNames","false");
1428
1429 if (CmdL.FileList[1] != 0)
1430 {
1431 for (;I.end() != true; I++)
1432 {
1433 if (All == false && I->FirstPackage == 0)
1434 continue;
1435 if (I.FindPkg("any")->VersionList == 0)
1436 continue;
1437 if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
1438 cout << I.Name() << endl;
1439 }
1440
1441 return true;
1442 }
1443
1444 // Show all pkgs
1445 for (;I.end() != true; I++)
1446 {
1447 if (All == false && I->FirstPackage == 0)
1448 continue;
1449 if (I.FindPkg("any")->VersionList == 0)
1450 continue;
1451 cout << I.Name() << endl;
1452 }
1453
1454 return true;
1455 }
1456 /*}}}*/
1457 // ShowSrcPackage - Show source package records /*{{{*/
1458 // ---------------------------------------------------------------------
1459 /* */
1460 bool ShowSrcPackage(CommandLine &CmdL)
1461 {
1462 pkgCacheFile CacheFile;
1463 pkgSourceList *List = CacheFile.GetSourceList();
1464 if (unlikely(List == NULL))
1465 return false;
1466
1467 // Create the text record parsers
1468 pkgSrcRecords SrcRecs(*List);
1469 if (_error->PendingError() == true)
1470 return false;
1471
1472 unsigned found = 0;
1473 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
1474 {
1475 SrcRecs.Restart();
1476
1477 pkgSrcRecords::Parser *Parse;
1478 unsigned found_this = 0;
1479 while ((Parse = SrcRecs.Find(*I,false)) != 0) {
1480 cout << Parse->AsStr() << endl;;
1481 found++;
1482 found_this++;
1483 }
1484 if (found_this == 0) {
1485 _error->Warning(_("Unable to locate package %s"),*I);
1486 continue;
1487 }
1488 }
1489 if (found > 0)
1490 return true;
1491 return _error->Error(_("No packages found"));
1492 }
1493 /*}}}*/
1494 // Policy - Show the results of the preferences file /*{{{*/
1495 // ---------------------------------------------------------------------
1496 /* */
1497 bool Policy(CommandLine &CmdL)
1498 {
1499 pkgCacheFile CacheFile;
1500 pkgCache *Cache = CacheFile.GetPkgCache();
1501 pkgPolicy *Plcy = CacheFile.GetPolicy();
1502 pkgSourceList *SrcList = CacheFile.GetSourceList();
1503 if (unlikely(Cache == NULL || Plcy == NULL || SrcList == NULL))
1504 return false;
1505
1506 /* Should the MultiArchKiller be run to see which pseudo packages for an
1507 arch all package are currently installed? Activating it gives a speed
1508 penality for no real gain beside enhanced debugging, so in general no. */
1509 if (_config->FindB("APT::Cache::Policy::DepCache", false) == true)
1510 CacheFile.GetDepCache();
1511
1512 // Print out all of the package files
1513 if (CmdL.FileList[1] == 0)
1514 {
1515 cout << _("Package files:") << endl;
1516 for (pkgCache::PkgFileIterator F = Cache->FileBegin(); F.end() == false; F++)
1517 {
1518 // Locate the associated index files so we can derive a description
1519 pkgIndexFile *Indx;
1520 if (SrcList->FindIndex(F,Indx) == false &&
1521 _system->FindIndex(F,Indx) == false)
1522 return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1523
1524 printf("%4i %s\n",
1525 Plcy->GetPriority(F),Indx->Describe(true).c_str());
1526
1527 // Print the reference information for the package
1528 string Str = F.RelStr();
1529 if (Str.empty() == false)
1530 printf(" release %s\n",F.RelStr().c_str());
1531 if (F.Site() != 0 && F.Site()[0] != 0)
1532 printf(" origin %s\n",F.Site());
1533 }
1534
1535 // Show any packages have explicit pins
1536 cout << _("Pinned packages:") << endl;
1537 pkgCache::PkgIterator I = Cache->PkgBegin();
1538 for (;I.end() != true; I++)
1539 {
1540 if (Plcy->GetPriority(I) == 0)
1541 continue;
1542
1543 // Print the package name and the version we are forcing to
1544 cout << " " << I.FullName(true) << " -> ";
1545
1546 pkgCache::VerIterator V = Plcy->GetMatch(I);
1547 if (V.end() == true)
1548 cout << _("(not found)") << endl;
1549 else
1550 cout << V.VerStr() << endl;
1551 }
1552
1553 return true;
1554 }
1555
1556 string const myArch = _config->Find("APT::Architecture");
1557 char const * const msgInstalled = _(" Installed: ");
1558 char const * const msgCandidate = _(" Candidate: ");
1559 short const InstalledLessCandidate =
1560 mbstowcs(NULL, msgInstalled, 0) - mbstowcs(NULL, msgCandidate, 0);
1561 short const deepInstalled =
1562 (InstalledLessCandidate < 0 ? (InstalledLessCandidate*-1) : 0) - 1;
1563 short const deepCandidate =
1564 (InstalledLessCandidate > 0 ? (InstalledLessCandidate) : 0) - 1;
1565
1566 // Print out detailed information for each package
1567 APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList + 1);
1568 for (APT::PackageSet::const_iterator I = pkgset.begin(); I != pkgset.end(); ++I)
1569 {
1570 pkgCache::PkgIterator Pkg = I.Group().FindPkg("any");
1571
1572 for (; Pkg.end() != true; Pkg = I.Group().NextPkg(Pkg)) {
1573 if (strcmp(Pkg.Arch(),"all") == 0)
1574 continue;
1575
1576 cout << Pkg.FullName(true) << ":" << endl;
1577
1578 // Installed version
1579 cout << msgInstalled << OutputInDepth(deepInstalled, " ");
1580 if (Pkg->CurrentVer == 0)
1581 cout << _("(none)") << endl;
1582 else
1583 cout << Pkg.CurrentVer().VerStr() << endl;
1584
1585 // Candidate Version
1586 cout << msgCandidate << OutputInDepth(deepCandidate, " ");
1587 pkgCache::VerIterator V = Plcy->GetCandidateVer(Pkg);
1588 if (V.end() == true)
1589 cout << _("(none)") << endl;
1590 else
1591 cout << V.VerStr() << endl;
1592
1593 // Pinned version
1594 if (Plcy->GetPriority(Pkg) != 0)
1595 {
1596 cout << _(" Package pin: ");
1597 V = Plcy->GetMatch(Pkg);
1598 if (V.end() == true)
1599 cout << _("(not found)") << endl;
1600 else
1601 cout << V.VerStr() << endl;
1602 }
1603
1604 // Show the priority tables
1605 cout << _(" Version table:") << endl;
1606 for (V = Pkg.VersionList(); V.end() == false; V++)
1607 {
1608 if (Pkg.CurrentVer() == V)
1609 cout << " *** " << V.VerStr();
1610 else
1611 cout << " " << V.VerStr();
1612 cout << " " << Plcy->GetPriority(Pkg) << endl;
1613 for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1614 {
1615 // Locate the associated index files so we can derive a description
1616 pkgIndexFile *Indx;
1617 if (SrcList->FindIndex(VF.File(),Indx) == false &&
1618 _system->FindIndex(VF.File(),Indx) == false)
1619 return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
1620 printf(" %4i %s\n",Plcy->GetPriority(VF.File()),
1621 Indx->Describe(true).c_str());
1622 }
1623 }
1624 }
1625 }
1626
1627 return true;
1628 }
1629 /*}}}*/
1630 // Madison - Look a bit like katie's madison /*{{{*/
1631 // ---------------------------------------------------------------------
1632 /* */
1633 bool Madison(CommandLine &CmdL)
1634 {
1635 pkgCacheFile CacheFile;
1636 pkgSourceList *SrcList = CacheFile.GetSourceList();
1637
1638 if (SrcList == 0)
1639 return false;
1640
1641 // Create the src text record parsers and ignore errors about missing
1642 // deb-src lines that are generated from pkgSrcRecords::pkgSrcRecords
1643 pkgSrcRecords SrcRecs(*SrcList);
1644 if (_error->PendingError() == true)
1645 _error->Discard();
1646
1647 APT::PackageSet pkgset = APT::PackageSet::FromCommandLine(CacheFile, CmdL.FileList + 1);
1648 for (APT::PackageSet::const_iterator Pkg = pkgset.begin(); Pkg != pkgset.end(); ++Pkg)
1649 {
1650 if (Pkg.end() == false)
1651 {
1652 for (pkgCache::VerIterator V = Pkg.VersionList(); V.end() == false; V++)
1653 {
1654 for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
1655 {
1656 // This might be nice, but wouldn't uniquely identify the source -mdz
1657 // if (VF.File().Archive() != 0)
1658 // {
1659 // cout << setw(10) << Pkg.Name() << " | " << setw(10) << V.VerStr() << " | "
1660 // << VF.File().Archive() << endl;
1661 // }
1662
1663 // Locate the associated index files so we can derive a description
1664 for (pkgSourceList::const_iterator S = SrcList->begin(); S != SrcList->end(); S++)
1665 {
1666 vector<pkgIndexFile *> *Indexes = (*S)->GetIndexFiles();
1667 for (vector<pkgIndexFile *>::const_iterator IF = Indexes->begin();
1668 IF != Indexes->end(); IF++)
1669 {
1670 if ((*IF)->FindInCache(*(VF.File().Cache())) == VF.File())
1671 {
1672 cout << setw(10) << Pkg.FullName(true) << " | " << setw(10) << V.VerStr() << " | "
1673 << (*IF)->Describe(true) << endl;
1674 }
1675 }
1676 }
1677 }
1678 }
1679 }
1680
1681
1682 SrcRecs.Restart();
1683 pkgSrcRecords::Parser *SrcParser;
1684 while ((SrcParser = SrcRecs.Find(Pkg.Name(),false)) != 0)
1685 {
1686 // Maybe support Release info here too eventually
1687 cout << setw(10) << SrcParser->Package() << " | "
1688 << setw(10) << SrcParser->Version() << " | "
1689 << SrcParser->Index().Describe(true) << endl;
1690 }
1691 }
1692
1693 return true;
1694 }
1695 /*}}}*/
1696 // GenCaches - Call the main cache generator /*{{{*/
1697 // ---------------------------------------------------------------------
1698 /* */
1699 bool GenCaches(CommandLine &Cmd)
1700 {
1701 OpTextProgress Progress(*_config);
1702
1703 pkgCacheFile CacheFile;
1704 return CacheFile.BuildCaches(&Progress, true);
1705 }
1706 /*}}}*/
1707 // ShowHelp - Show a help screen /*{{{*/
1708 // ---------------------------------------------------------------------
1709 /* */
1710 bool ShowHelp(CommandLine &Cmd)
1711 {
1712 ioprintf(cout,_("%s %s for %s compiled on %s %s\n"),PACKAGE,VERSION,
1713 COMMON_ARCH,__DATE__,__TIME__);
1714
1715 if (_config->FindB("version") == true)
1716 return true;
1717
1718 cout <<
1719 _("Usage: apt-cache [options] command\n"
1720 " apt-cache [options] add file1 [file2 ...]\n"
1721 " apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
1722 " apt-cache [options] showsrc pkg1 [pkg2 ...]\n"
1723 "\n"
1724 "apt-cache is a low-level tool used to manipulate APT's binary\n"
1725 "cache files, and query information from them\n"
1726 "\n"
1727 "Commands:\n"
1728 " add - Add a package file to the source cache\n"
1729 " gencaches - Build both the package and source cache\n"
1730 " showpkg - Show some general information for a single package\n"
1731 " showsrc - Show source records\n"
1732 " stats - Show some basic statistics\n"
1733 " dump - Show the entire file in a terse form\n"
1734 " dumpavail - Print an available file to stdout\n"
1735 " unmet - Show unmet dependencies\n"
1736 " search - Search the package list for a regex pattern\n"
1737 " show - Show a readable record for the package\n"
1738 " showauto - Display a list of automatically installed packages\n"
1739 " depends - Show raw dependency information for a package\n"
1740 " rdepends - Show reverse dependency information for a package\n"
1741 " pkgnames - List the names of all packages in the system\n"
1742 " dotty - Generate package graphs for GraphViz\n"
1743 " xvcg - Generate package graphs for xvcg\n"
1744 " policy - Show policy settings\n"
1745 "\n"
1746 "Options:\n"
1747 " -h This help text.\n"
1748 " -p=? The package cache.\n"
1749 " -s=? The source cache.\n"
1750 " -q Disable progress indicator.\n"
1751 " -i Show only important deps for the unmet command.\n"
1752 " -c=? Read this configuration file\n"
1753 " -o=? Set an arbitrary configuration option, eg -o dir::cache=/tmp\n"
1754 "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
1755 return true;
1756 }
1757 /*}}}*/
1758 // CacheInitialize - Initialize things for apt-cache /*{{{*/
1759 // ---------------------------------------------------------------------
1760 /* */
1761 void CacheInitialize()
1762 {
1763 _config->Set("quiet",0);
1764 _config->Set("help",false);
1765 }
1766 /*}}}*/
1767 int main(int argc,const char *argv[]) /*{{{*/
1768 {
1769 CommandLine::Args Args[] = {
1770 {'h',"help","help",0},
1771 {'v',"version","version",0},
1772 {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
1773 {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
1774 {'q',"quiet","quiet",CommandLine::IntLevel},
1775 {'i',"important","APT::Cache::Important",0},
1776 {'f',"full","APT::Cache::ShowFull",0},
1777 {'g',"generate","APT::Cache::Generate",0},
1778 {'a',"all-versions","APT::Cache::AllVersions",0},
1779 {'n',"names-only","APT::Cache::NamesOnly",0},
1780 {0,"all-names","APT::Cache::AllNames",0},
1781 {0,"recurse","APT::Cache::RecurseDepends",0},
1782 {'t',"target-release","APT::Default-Release",CommandLine::HasArg},
1783 {'t',"default-release","APT::Default-Release",CommandLine::HasArg},
1784 {'c',"config-file",0,CommandLine::ConfigFile},
1785 {'o',"option",0,CommandLine::ArbItem},
1786 {0,"installed","APT::Cache::Installed",0},
1787 {0,"pre-depends","APT::Cache::ShowPreDepends",0},
1788 {0,"depends","APT::Cache::ShowDepends",0},
1789 {0,"recommends","APT::Cache::ShowRecommends",0},
1790 {0,"suggests","APT::Cache::ShowSuggests",0},
1791 {0,"replaces","APT::Cache::ShowReplaces",0},
1792 {0,"breaks","APT::Cache::ShowBreaks",0},
1793 {0,"conflicts","APT::Cache::ShowConflicts",0},
1794 {0,"enhances","APT::Cache::ShowEnhances",0},
1795 {0,0,0,0}};
1796 CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
1797 {"add",&DoAdd},
1798 {"gencaches",&GenCaches},
1799 {"showsrc",&ShowSrcPackage},
1800 {0,0}};
1801 CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
1802 {"stats",&Stats},
1803 {"dump",&Dump},
1804 {"dumpavail",&DumpAvail},
1805 {"unmet",&UnMet},
1806 {"search",&Search},
1807 {"depends",&Depends},
1808 {"rdepends",&RDepends},
1809 {"dotty",&Dotty},
1810 {"xvcg",&XVcg},
1811 {"show",&ShowPackage},
1812 {"pkgnames",&ShowPkgNames},
1813 {"showauto",&ShowAuto},
1814 {"policy",&Policy},
1815 {"madison",&Madison},
1816 {0,0}};
1817
1818 CacheInitialize();
1819
1820 // Set up gettext support
1821 setlocale(LC_ALL,"");
1822 textdomain(PACKAGE);
1823
1824 // Parse the command line and initialize the package library
1825 CommandLine CmdL(Args,_config);
1826 if (pkgInitConfig(*_config) == false ||
1827 CmdL.Parse(argc,argv) == false ||
1828 pkgInitSystem(*_config,_system) == false)
1829 {
1830 _error->DumpErrors();
1831 return 100;
1832 }
1833
1834 // See if the help should be shown
1835 if (_config->FindB("help") == true ||
1836 CmdL.FileSize() == 0)
1837 {
1838 ShowHelp(CmdL);
1839 return 0;
1840 }
1841
1842 // Deal with stdout not being a tty
1843 if (!isatty(STDOUT_FILENO) && _config->FindI("quiet", -1) == -1)
1844 _config->Set("quiet","1");
1845
1846 if (_config->Exists("APT::Cache::Generate") == true)
1847 _config->Set("pkgCacheFile::Generate", _config->FindB("APT::Cache::Generate", true));
1848
1849 if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
1850 CmdL.DispatchArg(CmdsB);
1851
1852 // Print any errors or warnings found during parsing
1853 bool const Errors = _error->PendingError();
1854 if (_config->FindI("quiet",0) > 0)
1855 _error->DumpErrors();
1856 else
1857 _error->DumpErrors(GlobalError::DEBUG);
1858 return Errors == true ? 100 : 0;
1859 }
1860 /*}}}*/
APT (for Cydia)