]> git.saurik.com Git - apt.git/blame_incremental - cmdline/apt-cache.cc
projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fixed make system to rebuild binaries when shlib versio...
[apt.git] / cmdline / apt-cache.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: apt-cache.cc,v 1.33 1999/04/12 04:21:20 jgg 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. The
10 only really usefull function right now is dumpavail which is used
11 by the dselect method. Everything else is ment as a debug aide.
12
13 Returns 100 on failure, 0 on success.
14
15 ##################################################################### */
16 /*}}}*/
17// Include Files /*{{{*/
18#include <apt-pkg/error.h>
19#include <apt-pkg/pkgcachegen.h>
20#include <apt-pkg/deblistparser.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 <config.h>
28
29#include <iostream.h>
30#include <unistd.h>
31#include <errno.h>
32#include <regex.h>
33 /*}}}*/
34
35pkgCache *GCache = 0;
36
37// UnMet - Show unmet dependencies /*{{{*/
38// ---------------------------------------------------------------------
39/* */
40bool UnMet(CommandLine &CmdL)
41{
42 pkgCache &Cache = *GCache;
43 bool Important = _config->FindB("APT::Cache::Important",false);
44
45 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
46 {
47 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
48 {
49 bool Header = false;
50 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false;)
51 {
52 // Collect or groups
53 pkgCache::DepIterator Start;
54 pkgCache::DepIterator End;
55 D.GlobOr(Start,End);
56
57/* cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
58 End.TargetPkg().Name() << endl;*/
59
60 // Skip conflicts and replaces
61 if (End->Type != pkgCache::Dep::PreDepends &&
62 End->Type != pkgCache::Dep::Depends &&
63 End->Type != pkgCache::Dep::Suggests &&
64 End->Type != pkgCache::Dep::Recommends)
65 continue;
66
67 // Important deps only
68 if (Important == true)
69 if (End->Type != pkgCache::Dep::PreDepends &&
70 End->Type != pkgCache::Dep::Depends)
71 continue;
72
73 // Verify the or group
74 bool OK = false;
75 pkgCache::DepIterator RealStart = Start;
76 do
77 {
78 // See if this dep is Ok
79 pkgCache::Version **VList = Start.AllTargets();
80 if (*VList != 0)
81 {
82 OK = true;
83 delete [] VList;
84 break;
85 }
86 delete [] VList;
87
88 if (Start == End)
89 break;
90 Start++;
91 }
92 while (1);
93
94 // The group is OK
95 if (OK == true)
96 continue;
97
98 // Oops, it failed..
99 if (Header == false)
100 cout << "Package " << P.Name() << " version " <<
101 V.VerStr() << " has an unmet dep:" << endl;
102 Header = true;
103
104 // Print out the dep type
105 cout << " " << End.DepType() << ": ";
106
107 // Show the group
108 Start = RealStart;
109 do
110 {
111 cout << Start.TargetPkg().Name();
112 if (Start.TargetVer() != 0)
113 cout << " (" << Start.CompType() << " " << Start.TargetVer() <<
114 ")";
115 if (Start == End)
116 break;
117 cout << " | ";
118 Start++;
119 }
120 while (1);
121
122 cout << endl;
123 }
124 }
125 }
126 return true;
127}
128 /*}}}*/
129// DumpPackage - Show a dump of a package record /*{{{*/
130// ---------------------------------------------------------------------
131/* */
132bool DumpPackage(CommandLine &CmdL)
133{
134 pkgCache &Cache = *GCache;
135 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
136 {
137 pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
138 if (Pkg.end() == true)
139 {
140 _error->Warning("Unable to locate package %s",*I);
141 continue;
142 }
143
144 cout << "Package: " << Pkg.Name() << endl;
145 cout << "Versions: ";
146 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
147 {
148 cout << Cur.VerStr();
149 for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
150 cout << "(" << Vf.File().FileName() << ")";
151 cout << ',';
152 }
153
154 cout << endl;
155
156 cout << "Reverse Depends: " << endl;
157 for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
158 cout << " " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name() << endl;
159
160 cout << "Dependencies: " << endl;
161 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
162 {
163 cout << Cur.VerStr() << " - ";
164 for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
165 cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << Dep.TargetVer() << ") ";
166 cout << endl;
167 }
168
169 cout << "Provides: " << endl;
170 for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
171 {
172 cout << Cur.VerStr() << " - ";
173 for (pkgCache::PrvIterator Prv = Cur.ProvidesList(); Prv.end() != true; Prv++)
174 cout << Prv.ParentPkg().Name() << " ";
175 cout << endl;
176 }
177 cout << "Reverse Provides: " << endl;
178 for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
179 cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
180 cout << endl;
181
182 }
183
184 return true;
185}
186 /*}}}*/
187// Stats - Dump some nice statistics /*{{{*/
188// ---------------------------------------------------------------------
189/* */
190bool Stats(CommandLine &Cmd)
191{
192 pkgCache &Cache = *GCache;
193 cout << "Total Package Names : " << Cache.Head().PackageCount << " (" <<
194 SizeToStr(Cache.Head().PackageCount*Cache.Head().PackageSz) << ')' << endl;
195 pkgCache::PkgIterator I = Cache.PkgBegin();
196
197 int Normal = 0;
198 int Virtual = 0;
199 int NVirt = 0;
200 int DVirt = 0;
201 int Missing = 0;
202 for (;I.end() != true; I++)
203 {
204 if (I->VersionList != 0 && I->ProvidesList == 0)
205 {
206 Normal++;
207 continue;
208 }
209
210 if (I->VersionList != 0 && I->ProvidesList != 0)
211 {
212 NVirt++;
213 continue;
214 }
215
216 if (I->VersionList == 0 && I->ProvidesList != 0)
217 {
218 // Only 1 provides
219 if (I.ProvidesList()->NextProvides == 0)
220 {
221 DVirt++;
222 }
223 else
224 Virtual++;
225 continue;
226 }
227 if (I->VersionList == 0 && I->ProvidesList == 0)
228 {
229 Missing++;
230 continue;
231 }
232 }
233 cout << " Normal Packages: " << Normal << endl;
234 cout << " Pure Virtual Packages: " << Virtual << endl;
235 cout << " Single Virtual Packages: " << DVirt << endl;
236 cout << " Mixed Virtual Packages: " << NVirt << endl;
237 cout << " Missing: " << Missing << endl;
238
239 cout << "Total Distinct Versions: " << Cache.Head().VersionCount << " (" <<
240 SizeToStr(Cache.Head().VersionCount*Cache.Head().VersionSz) << ')' << endl;
241 cout << "Total Dependencies: " << Cache.Head().DependsCount << " (" <<
242 SizeToStr(Cache.Head().DependsCount*Cache.Head().DependencySz) << ')' << endl;
243
244 cout << "Total Ver/File relations: " << Cache.Head().VerFileCount << " (" <<
245 SizeToStr(Cache.Head().VerFileCount*Cache.Head().VerFileSz) << ')' << endl;
246 cout << "Total Provides Mappings: " << Cache.Head().ProvidesCount << " (" <<
247 SizeToStr(Cache.Head().ProvidesCount*Cache.Head().ProvidesSz) << ')' << endl;
248
249 // String list stats
250 unsigned long Size = 0;
251 unsigned long Count = 0;
252 for (pkgCache::StringItem *I = Cache.StringItemP + Cache.Head().StringList;
253 I!= Cache.StringItemP; I = Cache.StringItemP + I->NextItem)
254 {
255 Count++;
256 Size += strlen(Cache.StrP + I->String);
257 }
258 cout << "Total Globbed Strings: " << Count << " (" << SizeToStr(Size) << ')' << endl;
259
260 unsigned long Slack = 0;
261 for (int I = 0; I != 7; I++)
262 Slack += Cache.Head().Pools[I].ItemSize*Cache.Head().Pools[I].Count;
263 cout << "Total Slack space: " << SizeToStr(Slack) << endl;
264
265 unsigned long Total = 0;
266 Total = Slack + Size + Cache.Head().DependsCount*Cache.Head().DependencySz +
267 Cache.Head().VersionCount*Cache.Head().VersionSz +
268 Cache.Head().PackageCount*Cache.Head().PackageSz +
269 Cache.Head().VerFileCount*Cache.Head().VerFileSz +
270 Cache.Head().ProvidesCount*Cache.Head().ProvidesSz;
271 cout << "Total Space Accounted for: " << SizeToStr(Total) << endl;
272
273 return true;
274}
275 /*}}}*/
276// Check - Check some things about the cache /*{{{*/
277// ---------------------------------------------------------------------
278/* Debug aide mostly */
279bool Check(CommandLine &Cmd)
280{
281 pkgCache &Cache = *GCache;
282 pkgCache::PkgIterator Pkg = Cache.PkgBegin();
283 for (;Pkg.end() != true; Pkg++)
284 {
285 if (Pkg.Section() == 0 && Pkg->VersionList != 0)
286 cout << "Bad section " << Pkg.Name() << endl;
287
288 for (pkgCache::VerIterator Cur = Pkg.VersionList();
289 Cur.end() != true; Cur++)
290 {
291 if (Cur->Priority < 1 || Cur->Priority > 5)
292 cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
293 }
294 }
295 return true;
296}
297 /*}}}*/
298// Dump - show everything /*{{{*/
299// ---------------------------------------------------------------------
300/* */
301bool Dump(CommandLine &Cmd)
302{
303 pkgCache &Cache = *GCache;
304 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
305 {
306 cout << "Package: " << P.Name() << endl;
307 for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
308 {
309 cout << " Version: " << V.VerStr() << endl;
310 cout << " File: " << V.FileList().File().FileName() << endl;
311 for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
312 cout << " Depends: " << D.TargetPkg().Name() << ' ' << D.TargetVer() << endl;
313 }
314 }
315
316 for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
317 {
318 cout << "File: " << F.FileName() << endl;
319 cout << " Size: " << F->Size << endl;
320 cout << " ID: " << F->ID << endl;
321 cout << " Flags: " << F->Flags << endl;
322 cout << " Time: " << TimeRFC1123(F->mtime) << endl;
323 cout << " Archive: " << F.Archive() << endl;
324 cout << " Component: " << F.Component() << endl;
325 cout << " Version: " << F.Version() << endl;
326 cout << " Origin: " << F.Origin() << endl;
327 cout << " Label: " << F.Label() << endl;
328 cout << " Architecture: " << F.Architecture() << endl;
329 }
330
331 return true;
332}
333 /*}}}*/
334// DumpAvail - Print out the available list /*{{{*/
335// ---------------------------------------------------------------------
336/* This is needed to make dpkg --merge happy */
337bool DumpAvail(CommandLine &Cmd)
338{
339 pkgCache &Cache = *GCache;
340 unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
341
342 for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
343 {
344 if ((I->Flags & pkgCache::Flag::NotSource) != 0)
345 continue;
346
347 if (I.IsOk() == false)
348 {
349 delete [] Buffer;
350 return _error->Error("Package file %s is out of sync.",I.FileName());
351 }
352
353 FileFd PkgF(I.FileName(),FileFd::ReadOnly);
354 if (_error->PendingError() == true)
355 {
356 delete [] Buffer;
357 return false;
358 }
359
360 /* Write all of the records from this package file, we search the entire
361 structure to find them */
362 for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
363 {
364 // Find the proper version to use. We should probably use the DepCache.
365 pkgCache::VerIterator V = Cache.GetCandidateVer(P,false);
366
367 if (V.end() == true || V.FileList().File() != I)
368 continue;
369
370 // Read the record and then write it out again.
371 if (PkgF.Seek(V.FileList()->Offset) == false ||
372 PkgF.Read(Buffer,V.FileList()->Size) == false ||
373 write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
374 {
375 delete [] Buffer;
376 return false;
377 }
378 }
379 }
380
381 return true;
382}
383 /*}}}*/
384// DoAdd - Perform an adding operation /*{{{*/
385// ---------------------------------------------------------------------
386/* */
387bool DoAdd(CommandLine &CmdL)
388{
389 // Make sure there is at least one argument
390 if (CmdL.FileSize() <= 1)
391 return _error->Error("You must give at least one file name");
392
393 // Open the cache
394 FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
395 if (_error->PendingError() == true)
396 return false;
397
398 DynamicMMap Map(CacheF,MMap::Public);
399 if (_error->PendingError() == true)
400 return false;
401
402 OpTextProgress Progress(*_config);
403 pkgCacheGenerator Gen(Map,Progress);
404 if (_error->PendingError() == true)
405 return false;
406
407 unsigned long Length = CmdL.FileSize() - 1;
408 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
409 {
410 Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
411 Progress.SubProgress(Length);
412
413 // Do the merge
414 FileFd TagF(*I,FileFd::ReadOnly);
415 debListParser Parser(TagF);
416 if (_error->PendingError() == true)
417 return _error->Error("Problem opening %s",*I);
418
419 if (Gen.SelectFile(*I) == false)
420 return _error->Error("Problem with SelectFile");
421
422 if (Gen.MergeList(Parser) == false)
423 return _error->Error("Problem with MergeList");
424 }
425
426 Progress.Done();
427 GCache = &Gen.GetCache();
428 Stats(CmdL);
429
430 return true;
431}
432 /*}}}*/
433// DisplayRecord - Displays the complete record for the package /*{{{*/
434// ---------------------------------------------------------------------
435/* This displays the package record from the proper package index file.
436 It is not used by DumpAvail for performance reasons. */
437bool DisplayRecord(pkgCache::VerIterator V)
438{
439 // Find an appropriate file
440 pkgCache::VerFileIterator Vf = V.FileList();
441 for (; Vf.end() == false; Vf++)
442 if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
443 break;
444 if (Vf.end() == true)
445 Vf = V.FileList();
446
447 // Check and load the package list file
448 pkgCache::PkgFileIterator I = Vf.File();
449 if (I.IsOk() == false)
450 return _error->Error("Package file %s is out of sync.",I.FileName());
451
452 FileFd PkgF(I.FileName(),FileFd::ReadOnly);
453 if (_error->PendingError() == true)
454 return false;
455
456 // Read the record and then write it out again.
457 unsigned char *Buffer = new unsigned char[GCache->HeaderP->MaxVerFileSize];
458 if (PkgF.Seek(V.FileList()->Offset) == false ||
459 PkgF.Read(Buffer,V.FileList()->Size) == false ||
460 write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
461 {
462 delete [] Buffer;
463 return false;
464 }
465
466 delete [] Buffer;
467
468 return true;
469}
470 /*}}}*/
471// Search - Perform a search /*{{{*/
472// ---------------------------------------------------------------------
473/* This searches the package names and pacakge descriptions for a pattern */
474bool Search(CommandLine &CmdL)
475{
476 pkgCache &Cache = *GCache;
477 bool ShowFull = _config->FindB("APT::Cache::ShowFull",false);
478 bool NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
479
480 // Make sure there is at least one argument
481 if (CmdL.FileSize() != 2)
482 return _error->Error("You must give exactly one pattern");
483
484 // Compile the regex pattern
485 regex_t Pattern;
486 if (regcomp(&Pattern,CmdL.FileList[1],REG_EXTENDED | REG_ICASE |
487 REG_NOSUB) != 0)
488 return _error->Error("Regex compilation error");
489
490 // Create the text record parser
491 pkgRecords Recs(Cache);
492 if (_error->PendingError() == true)
493 return false;
494
495 // Search package names
496 pkgCache::PkgIterator I = Cache.PkgBegin();
497 for (;I.end() != true; I++)
498 {
499 // We search against the install version as that makes the most sense..
500 pkgCache::VerIterator V = Cache.GetCandidateVer(I);
501 if (V.end() == true)
502 continue;
503
504 pkgRecords::Parser &P = Recs.Lookup(V.FileList());
505
506 if (regexec(&Pattern,I.Name(),0,0,0) == 0 ||
507 (NamesOnly == false &&
508 regexec(&Pattern,P.LongDesc().c_str(),0,0,0) == 0))
509 {
510 if (ShowFull == true)
511 DisplayRecord(V);
512 else
513 cout << I.Name() << " - " << P.ShortDesc() << endl;
514 }
515 }
516
517 regfree(&Pattern);
518 return true;
519}
520 /*}}}*/
521// ShowPackage - Dump the package record to the screen /*{{{*/
522// ---------------------------------------------------------------------
523/* */
524bool ShowPackage(CommandLine &CmdL)
525{
526 pkgCache &Cache = *GCache;
527 for (const char **I = CmdL.FileList + 1; *I != 0; I++)
528 {
529 pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
530 if (Pkg.end() == true)
531 {
532 _error->Warning("Unable to locate package %s",*I);
533 continue;
534 }
535
536 // Find the proper version to use. We should probably use the DepCache.
537 pkgCache::VerIterator V = Cache.GetCandidateVer(Pkg);
538 if (V.end() == true || V.FileList().end() == true)
539 continue;
540 if (DisplayRecord(V) == false)
541 return false;
542 }
543 return true;
544}
545 /*}}}*/
546// GenCaches - Call the main cache generator /*{{{*/
547// ---------------------------------------------------------------------
548/* */
549bool GenCaches(CommandLine &Cmd)
550{
551 OpTextProgress Progress(*_config);
552
553 pkgSourceList List;
554 List.ReadMainList();
555 return pkgMakeStatusCache(List,Progress);
556}
557 /*}}}*/
558// ShowHelp - Show a help screen /*{{{*/
559// ---------------------------------------------------------------------
560/* */
561bool ShowHelp(CommandLine &Cmd)
562{
563 cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
564 " compiled on " << __DATE__ << " " << __TIME__ << endl;
565 if (_config->FindB("version") == true)
566 return 100;
567
568 cout << "Usage: apt-cache [options] command" << endl;
569 cout << " apt-cache [options] add file1 [file1 ...]" << endl;
570 cout << " apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
571 cout << endl;
572 cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
573 cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
574 cout << "It is not ment for ordinary use only as a debug aide." << endl;
575 cout << endl;
576 cout << "Commands:" << endl;
577 cout << " add - Add an package file to the source cache" << endl;
578 cout << " gencaches - Build both the package and source cache" << endl;
579 cout << " showpkg - Show some general information for a single package" << endl;
580 cout << " stats - Show some basic statistics" << endl;
581 cout << " dump - Show the entire file in a terse form" << endl;
582 cout << " dumpavail - Print an available file to stdout" << endl;
583 cout << " unmet - Show unmet dependencies" << endl;
584 cout << " check - Check the cache a bit" << endl;
585 cout << " search - Search the package list for a regex pattern" << endl;
586 cout << " show - Show a readable record for the package" << endl;
587 cout << endl;
588 cout << "Options:" << endl;
589 cout << " -h This help text." << endl;
590 cout << " -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
591 cout << " -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
592 cout << " -q Disable progress indicator." << endl;
593 cout << " -i Show only important deps for the unmet command." << endl;
594 cout << " -c=? Read this configuration file" << endl;
595 cout << " -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp" << endl;
596 cout << "See the apt-cache(8) and apt.conf(5) manual pages for more information." << endl;
597 return 100;
598}
599 /*}}}*/
600// CacheInitialize - Initialize things for apt-cache /*{{{*/
601// ---------------------------------------------------------------------
602/* */
603void CacheInitialize()
604{
605 _config->Set("quiet",0);
606 _config->Set("help",false);
607}
608 /*}}}*/
609
610int main(int argc,const char *argv[])
611{
612 CommandLine::Args Args[] = {
613 {'h',"help","help",0},
614 {'v',"version","version",0},
615 {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
616 {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
617 {'q',"quiet","quiet",CommandLine::IntLevel},
618 {'i',"important","APT::Cache::Important",0},
619 {'f',"full","APT::Cache::ShowFull",0},
620 {0,"names-only","APT::Cache::NamesOnly",0},
621 {'c',"config-file",0,CommandLine::ConfigFile},
622 {'o',"option",0,CommandLine::ArbItem},
623 {0,0,0,0}};
624 CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
625 {"add",&DoAdd},
626 {"gencaches",&GenCaches},
627 {0,0}};
628 CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
629 {"stats",&Stats},
630 {"dump",&Dump},
631 {"dumpavail",&DumpAvail},
632 {"unmet",&UnMet},
633 {"check",&Check},
634 {"search",&Search},
635 {"show",&ShowPackage},
636 {0,0}};
637
638 CacheInitialize();
639
640 // Parse the command line and initialize the package library
641 CommandLine CmdL(Args,_config);
642 if (pkgInitialize(*_config) == false ||
643 CmdL.Parse(argc,argv) == false)
644 {
645 _error->DumpErrors();
646 return 100;
647 }
648
649 // See if the help should be shown
650 if (_config->FindB("help") == true ||
651 CmdL.FileSize() == 0)
652 return ShowHelp(CmdL);
653
654 // Deal with stdout not being a tty
655 if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
656 _config->Set("quiet","1");
657
658 if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
659 {
660 // Open the cache file
661 FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
662 MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
663 if (_error->PendingError() == false)
664 {
665 pkgCache Cache(Map);
666 GCache = &Cache;
667 if (_error->PendingError() == false)
668 CmdL.DispatchArg(CmdsB);
669 }
670 }
671
672 // Print any errors or warnings found during parsing
673 if (_error->empty() == false)
674 {
675 bool Errors = _error->PendingError();
676 _error->DumpErrors();
677 return Errors == true?100:0;
678 }
679
680 return 0;
681}
APT (for Cydia)