cmdline/apt-cache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: apt-cache.cc,v 1.27 1999/02/19 07:56:07 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
  35 pkgCache *GCache = 0;
  36
  37 // UnMet - Show unmet dependencies                                      /*{{{*/
  38 // ---------------------------------------------------------------------
  39 /* */
  40 bool 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 /* */
 132 bool 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 /* */
 190 bool 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 */
 279 bool 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 /* */
 301 bool 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 // GetCandidateVer - Returns the Candidate install version              /*{{{*/
 335 // ---------------------------------------------------------------------
 336 /* This should really use the DepCache or something.. Copied from there. */
 337 static pkgCache::VerIterator GetCandidateVer(pkgCache::PkgIterator Pkg)
 338 {
 339    /* Not source/not automatic versions cannot be a candidate version
 340     unless they are already installed */
 341    for (pkgCache::VerIterator I = Pkg.VersionList(); I.end() == false; I++)
 342    {
 343       if (Pkg.CurrentVer() == I)
 344          return I;
 345       for (pkgCache::VerFileIterator J = I.FileList(); J.end() == false; J++)
 346          if ((J.File()->Flags & pkgCache::Flag::NotSource) == 0 &&
 347              (J.File()->Flags & pkgCache::Flag::NotAutomatic) == 0)
 348             return I;
 349    }
 350
 351    return pkgCache::VerIterator(*GCache,0);
 352 }
 353                                                                         /*}}}*/
 354 // DumpAvail - Print out the available list                             /*{{{*/
 355 // ---------------------------------------------------------------------
 356 /* This is needed to make dpkg --merge happy */
 357 bool DumpAvail(CommandLine &Cmd)
 358 {
 359    pkgCache &Cache = *GCache;
 360    unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
 361
 362    for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
 363    {
 364       if ((I->Flags & pkgCache::Flag::NotSource) != 0)
 365          continue;
 366
 367       if (I.IsOk() == false)
 368       {
 369          delete [] Buffer;
 370          return _error->Error("Package file %s is out of sync.",I.FileName());
 371       }
 372
 373       FileFd PkgF(I.FileName(),FileFd::ReadOnly);
 374       if (_error->PendingError() == true)
 375       {
 376          delete [] Buffer;
 377          return false;
 378       }
 379
 380       /* Write all of the records from this package file, we search the entire
 381          structure to find them */
 382       for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
 383       {
 384          // Find the proper version to use. We should probably use the DepCache.
 385          pkgCache::VerIterator V = GetCandidateVer(P);
 386
 387          if (V.end() == true || V.FileList().File() != I)
 388             continue;
 389
 390          // Read the record and then write it out again.
 391          if (PkgF.Seek(V.FileList()->Offset) == false ||
 392              PkgF.Read(Buffer,V.FileList()->Size) == false ||
 393              write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
 394          {
 395             delete [] Buffer;
 396             return false;
 397          }
 398       }
 399    }
 400
 401    return true;
 402 }
 403                                                                         /*}}}*/
 404 // DoAdd - Perform an adding operation                                  /*{{{*/
 405 // ---------------------------------------------------------------------
 406 /* */
 407 bool DoAdd(CommandLine &CmdL)
 408 {
 409    // Make sure there is at least one argument
 410    if (CmdL.FileSize() <= 1)
 411       return _error->Error("You must give at least one file name");
 412
 413    // Open the cache
 414    FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::WriteAny);
 415    if (_error->PendingError() == true)
 416       return false;
 417
 418    DynamicMMap Map(CacheF,MMap::Public);
 419    if (_error->PendingError() == true)
 420       return false;
 421
 422    OpTextProgress Progress(*_config);
 423    pkgCacheGenerator Gen(Map,Progress);
 424    if (_error->PendingError() == true)
 425       return false;
 426
 427    unsigned long Length = CmdL.FileSize() - 1;
 428    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
 429    {
 430       Progress.OverallProgress(I - CmdL.FileList,Length,1,"Generating cache");
 431       Progress.SubProgress(Length);
 432
 433       // Do the merge
 434       FileFd TagF(*I,FileFd::ReadOnly);
 435       debListParser Parser(TagF);
 436       if (_error->PendingError() == true)
 437          return _error->Error("Problem opening %s",*I);
 438
 439       if (Gen.SelectFile(*I) == false)
 440          return _error->Error("Problem with SelectFile");
 441
 442       if (Gen.MergeList(Parser) == false)
 443          return _error->Error("Problem with MergeList");
 444    }
 445
 446    Progress.Done();
 447    GCache = &Gen.GetCache();
 448    Stats(CmdL);
 449
 450    return true;
 451 }
 452                                                                         /*}}}*/
 453 // Search - Perform a search                                            /*{{{*/
 454 // ---------------------------------------------------------------------
 455 /* This searches the package names and pacakge descriptions for a pattern */
 456 bool Search(CommandLine &CmdL)
 457 {
 458    pkgCache &Cache = *GCache;
 459
 460    // Make sure there is at least one argument
 461    if (CmdL.FileSize() != 2)
 462       return _error->Error("You must give exactly one pattern");
 463
 464    // Compile the regex pattern
 465    regex_t Pattern;
 466    if (regcomp(&Pattern,CmdL.FileList[1],REG_EXTENDED | REG_ICASE |
 467                REG_NOSUB) != 0)
 468       return _error->Error("Regex compilation error");
 469
 470    // Create the text record parser
 471    pkgRecords Recs(Cache);
 472    if (_error->PendingError() == true)
 473       return false;
 474
 475    // Search package names
 476    pkgCache::PkgIterator I = Cache.PkgBegin();
 477    for (;I.end() != true; I++)
 478    {
 479       if (regexec(&Pattern,I.Name(),0,0,0) == 0)
 480       {
 481          cout << I.Name();
 482          if (I->VersionList != 0)
 483          {
 484             pkgRecords::Parser &P = Recs.Lookup(I.VersionList().FileList());
 485             cout << " - " << P.ShortDesc() << endl;
 486          }
 487          else
 488             cout << " [virtual package]" << endl;
 489       }
 490    }
 491
 492    regfree(&Pattern);
 493    return true;
 494 }
 495                                                                         /*}}}*/
 496 // GenCaches - Call the main cache generator                            /*{{{*/
 497 // ---------------------------------------------------------------------
 498 /* */
 499 bool GenCaches(CommandLine &Cmd)
 500 {
 501    OpTextProgress Progress(*_config);
 502
 503    pkgSourceList List;
 504    List.ReadMainList();
 505    return pkgMakeStatusCache(List,Progress);
 506 }
 507                                                                         /*}}}*/
 508 // ShowHelp - Show a help screen                                        /*{{{*/
 509 // ---------------------------------------------------------------------
 510 /* */
 511 bool ShowHelp(CommandLine &Cmd)
 512 {
 513    cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
 514        " compiled on " << __DATE__ << "  " << __TIME__ << endl;
 515    if (_config->FindB("version") == true)
 516       return 100;
 517
 518    cout << "Usage: apt-cache [options] command" << endl;
 519    cout << "       apt-cache [options] add file1 [file1 ...]" << endl;
 520    cout << "       apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
 521    cout << endl;
 522    cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
 523    cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
 524    cout << "It is not ment for ordinary use only as a debug aide." << endl;
 525    cout << endl;
 526    cout << "Commands:" << endl;
 527    cout << "   add - Add an package file to the source cache" << endl;
 528    cout << "   gencaches - Build both the package and source cache" << endl;
 529    cout << "   showpkg - Show some general information for a single package" << endl;
 530    cout << "   stats - Show some basic statistics" << endl;
 531    cout << "   dump - Show the entire file in a terse form" << endl;
 532    cout << "   dumpavail - Print an available file to stdout" << endl;
 533    cout << "   unmet - Show unmet dependencies" << endl;
 534    cout << "   check - Check the cache a bit" << endl;
 535    cout << "   search - Search the package list for a regex pattern" << endl;
 536    cout << endl;
 537    cout << "Options:" << endl;
 538    cout << "  -h   This help text." << endl;
 539    cout << "  -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
 540    cout << "  -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
 541    cout << "  -q   Disable progress indicator." << endl;
 542    cout << "  -i   Show only important deps for the unmet command." << endl;
 543    cout << "  -c=? Read this configuration file" << endl;
 544    cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
 545    cout << "See the apt-cache(8) and apt.conf(5) manual pages for more information." << endl;
 546    return 100;
 547 }
 548                                                                         /*}}}*/
 549 // CacheInitialize - Initialize things for apt-cache                    /*{{{*/
 550 // ---------------------------------------------------------------------
 551 /* */
 552 void CacheInitialize()
 553 {
 554    _config->Set("quiet",0);
 555    _config->Set("help",false);
 556 }
 557                                                                         /*}}}*/
 558
 559 int main(int argc,const char *argv[])
 560 {
 561    CommandLine::Args Args[] = {
 562       {'h',"help","help",0},
 563       {'v',"version","version",0},
 564       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
 565       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
 566       {'q',"quiet","quiet",CommandLine::IntLevel},
 567       {'i',"important","APT::Cache::Important",0},
 568       {'c',"config-file",0,CommandLine::ConfigFile},
 569       {'o',"option",0,CommandLine::ArbItem},
 570       {0,0,0,0}};
 571    CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
 572                                     {"add",&DoAdd},
 573                                     {"gencaches",&GenCaches},
 574                                     {0,0}};
 575    CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
 576                                     {"stats",&Stats},
 577                                     {"dump",&Dump},
 578                                     {"dumpavail",&DumpAvail},
 579                                     {"unmet",&UnMet},
 580                                     {"check",&Check},
 581                                     {"search",&Search},
 582                                     {0,0}};
 583
 584    CacheInitialize();
 585
 586    // Parse the command line and initialize the package library
 587    CommandLine CmdL(Args,_config);
 588    if (pkgInitialize(*_config) == false ||
 589        CmdL.Parse(argc,argv) == false)
 590    {
 591       _error->DumpErrors();
 592       return 100;
 593    }
 594
 595    // See if the help should be shown
 596    if (_config->FindB("help") == true ||
 597        CmdL.FileSize() == 0)
 598       return ShowHelp(CmdL);
 599
 600    if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
 601    {
 602       // Open the cache file
 603       FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
 604       MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
 605       if (_error->PendingError() == false)
 606       {
 607          pkgCache Cache(Map);
 608          GCache = &Cache;
 609          if (_error->PendingError() == false)
 610             CmdL.DispatchArg(CmdsB);
 611       }
 612    }
 613
 614    // Print any errors or warnings found during parsing
 615    if (_error->empty() == false)
 616    {
 617       bool Errors = _error->PendingError();
 618       _error->DumpErrors();
 619       return Errors == true?100:0;
 620    }
 621
 622    return 0;
 623 }