]> git.saurik.com Git - apt.git/blobdiff - cmdline/apt-cache.cc
commented out a stray debugging line that will break debconf
[apt.git] / cmdline / apt-cache.cc
index 51db343f970b726b42c7cb73ec013780dd146457..e15f9d48d02fbdad14e96bf271b9cdf825c755f3 100644 (file)
@@ -1,14 +1,12 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
-// $Id: apt-cache.cc,v 1.15 1998/12/06 06:22:58 jgg Exp $
+// $Id: apt-cache.cc,v 1.56 2002/02/15 03:40:00 jgg Exp $
 /* ######################################################################
    
    apt-cache - Manages the cache files
    
    apt-cache provides some functions fo manipulating the cache files.
-   It uses the command line interface common to all the APT tools. The
-   only really usefull function right now is dumpavail which is used
-   by the dselect method. Everything else is ment as a debug aide.
+   It uses the command line interface common to all the APT tools. 
    
    Returns 100 on failure, 0 on success.
    
 // Include Files                                                       /*{{{*/
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcachegen.h>
-#include <apt-pkg/deblistparser.h>
 #include <apt-pkg/init.h>
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/cmndline.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/pkgrecords.h>
+#include <apt-pkg/srcrecords.h>
+#include <apt-pkg/version.h>
+#include <apt-pkg/policy.h>
+#include <apt-pkg/tagfile.h>
+#include <apt-pkg/algorithms.h>
+#include <apt-pkg/sptr.h>
 
-#include <iostream.h>
 #include <config.h>
+#include <apti18n.h>
+
+#include <locale.h>
+#include <iostream.h>
+#include <unistd.h>
+#include <errno.h>
+#include <regex.h>
+#include <stdio.h>
                                                                        /*}}}*/
 
+pkgCache *GCache = 0;
+pkgSourceList *SrcList = 0;
+
+// LocalitySort - Sort a version list by package file locality         /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+int LocalityCompare(const void *a, const void *b)
+{
+   pkgCache::VerFile *A = *(pkgCache::VerFile **)a;
+   pkgCache::VerFile *B = *(pkgCache::VerFile **)b;
+   
+   if (A == 0 && B == 0)
+      return 0;
+   if (A == 0)
+      return 1;
+   if (B == 0)
+      return -1;
+   
+   if (A->File == B->File)
+      return A->Offset - B->Offset;
+   return A->File - B->File;
+}
+
+void LocalitySort(pkgCache::VerFile **begin,
+                 unsigned long Count,size_t Size)
+{   
+   qsort(begin,Count,Size,LocalityCompare);
+}
+                                                                       /*}}}*/
 // UnMet - Show unmet dependencies                                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool UnMet(pkgCache &Cache)
+bool UnMet(CommandLine &CmdL)
 {
+   pkgCache &Cache = *GCache;
    bool Important = _config->FindB("APT::Cache::Important",false);
    
    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
@@ -46,9 +88,6 @@ bool UnMet(pkgCache &Cache)
            pkgCache::DepIterator End;
            D.GlobOr(Start,End);
            
-/*         cout << "s: Check " << Start.TargetPkg().Name() << ',' <<
-              End.TargetPkg().Name() << endl;*/
-              
            // Skip conflicts and replaces
            if (End->Type != pkgCache::Dep::PreDepends &&
                End->Type != pkgCache::Dep::Depends && 
@@ -89,8 +128,8 @@ bool UnMet(pkgCache &Cache)
            
            // Oops, it failed..
            if (Header == false)
-                 cout << "Package " << P.Name() << " version " << 
-              V.VerStr() << " has an unmet dep:" << endl;
+              ioprintf(cout,_("Package %s version %s has an unmet dep:\n"),
+                       P.Name(),V.VerStr());
            Header = true;
            
            // Print out the dep type
@@ -121,39 +160,46 @@ bool UnMet(pkgCache &Cache)
 // DumpPackage - Show a dump of a package record                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
+bool DumpPackage(CommandLine &CmdL)
 {   
+   pkgCache &Cache = *GCache;
    for (const char **I = CmdL.FileList + 1; *I != 0; I++)
    {
       pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
       if (Pkg.end() == true)
       {
-        _error->Warning("Unable to locate package %s",*I);
+        _error->Warning(_("Unable to locate package %s"),*I);
         continue;
       }
 
       cout << "Package: " << Pkg.Name() << endl;
-      cout << "Versions: ";
+      cout << "Versions: " << endl;
       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
       {
         cout << Cur.VerStr();
         for (pkgCache::VerFileIterator Vf = Cur.FileList(); Vf.end() == false; Vf++)
            cout << "(" << Vf.File().FileName() << ")";
-        cout << ',';
+        cout << endl;
       }
       
       cout << endl;
       
       cout << "Reverse Depends: " << endl;
       for (pkgCache::DepIterator D = Pkg.RevDependsList(); D.end() != true; D++)
-        cout << "  " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name() << endl;
-
+      {
+        cout << "  " << D.ParentPkg().Name() << ',' << D.TargetPkg().Name();
+        if (D->Version != 0)
+           cout << ' ' << DeNull(D.TargetVer()) << endl;
+        else
+           cout << endl;
+      }
+      
       cout << "Dependencies: " << endl;
       for (pkgCache::VerIterator Cur = Pkg.VersionList(); Cur.end() != true; Cur++)
       {
         cout << Cur.VerStr() << " - ";
         for (pkgCache::DepIterator Dep = Cur.DependsList(); Dep.end() != true; Dep++)
-           cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << Dep.TargetVer() << ") ";
+           cout << Dep.TargetPkg().Name() << " (" << (int)Dep->CompareOp << " " << DeNull(Dep.TargetVer()) << ") ";
         cout << endl;
       }      
 
@@ -167,9 +213,7 @@ bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
       }
       cout << "Reverse Provides: " << endl;
       for (pkgCache::PrvIterator Prv = Pkg.ProvidesList(); Prv.end() != true; Prv++)
-        cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr();
-      cout << endl;
-            
+        cout << Prv.OwnerPkg().Name() << " " << Prv.OwnerVer().VerStr() << endl;            
    }
 
    return true;
@@ -178,16 +222,18 @@ bool DumpPackage(pkgCache &Cache,CommandLine &CmdL)
 // Stats - Dump some nice statistics                                   /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool Stats(pkgCache &Cache)
+bool Stats(CommandLine &Cmd)
 {
-   cout << "Total Package Names : " << Cache.Head().PackageCount << endl;
-   pkgCache::PkgIterator I = Cache.PkgBegin();
-   
+   pkgCache &Cache = *GCache;
+   cout << _("Total Package Names : ") << Cache.Head().PackageCount << " (" <<
+      SizeToStr(Cache.Head().PackageCount*Cache.Head().PackageSz) << ')' << endl;
+
    int Normal = 0;
    int Virtual = 0;
    int NVirt = 0;
    int DVirt = 0;
    int Missing = 0;
+   pkgCache::PkgIterator I = Cache.PkgBegin();
    for (;I.end() != true; I++)
    {
       if (I->VersionList != 0 && I->ProvidesList == 0)
@@ -219,43 +265,71 @@ bool Stats(pkgCache &Cache)
         continue;
       }
    }
-   cout << "  Normal Packages: " << Normal << endl;
-   cout << "  Pure Virtual Packages: " << Virtual << endl;
-   cout << "  Single Virtual Packages: " << DVirt << endl;
-   cout << "  Mixed Virtual Packages: " << NVirt << endl;
-   cout << "  Missing: " << Missing << endl;
-   
-   cout << "Total Distinct Versions: " << Cache.Head().VersionCount << endl;
-   cout << "Total Dependencies: " << Cache.Head().DependsCount << endl;
-   return true;
-}
-                                                                       /*}}}*/
-// Check - Check some things about the cache                           /*{{{*/
-// ---------------------------------------------------------------------
-/* Debug aide mostly */
-bool Check(pkgCache &Cache)
-{
-   pkgCache::PkgIterator Pkg = Cache.PkgBegin();
-   for (;Pkg.end() != true; Pkg++)
+   cout << _("  Normal Packages: ") << Normal << endl;
+   cout << _("  Pure Virtual Packages: ") << Virtual << endl;
+   cout << _("  Single Virtual Packages: ") << DVirt << endl;
+   cout << _("  Mixed Virtual Packages: ") << NVirt << endl;
+   cout << _("  Missing: ") << Missing << endl;
+   
+   cout << _("Total Distinct Versions: ") << Cache.Head().VersionCount << " (" <<
+      SizeToStr(Cache.Head().VersionCount*Cache.Head().VersionSz) << ')' << endl;
+   cout << _("Total Dependencies: ") << Cache.Head().DependsCount << " (" << 
+      SizeToStr(Cache.Head().DependsCount*Cache.Head().DependencySz) << ')' << endl;
+   
+   cout << _("Total Ver/File relations: ") << Cache.Head().VerFileCount << " (" <<
+      SizeToStr(Cache.Head().VerFileCount*Cache.Head().VerFileSz) << ')' << endl;
+   cout << _("Total Provides Mappings: ") << Cache.Head().ProvidesCount << " (" <<
+      SizeToStr(Cache.Head().ProvidesCount*Cache.Head().ProvidesSz) << ')' << endl;
+   
+   // String list stats
+   unsigned long Size = 0;
+   unsigned long Count = 0;
+   for (pkgCache::StringItem *I = Cache.StringItemP + Cache.Head().StringList;
+        I!= Cache.StringItemP; I = Cache.StringItemP + I->NextItem)
    {
-      if (Pkg.Section() == 0 && Pkg->VersionList != 0)
-        cout << "Bad section " << Pkg.Name() << endl;
-      
-      for (pkgCache::VerIterator Cur = Pkg.VersionList(); 
-          Cur.end() != true; Cur++)
+      Count++;
+      Size += strlen(Cache.StrP + I->String) + 1;
+   }
+   cout << _("Total Globbed Strings: ") << Count << " (" << SizeToStr(Size) << ')' << endl;
+
+   unsigned long DepVerSize = 0;
+   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+   {
+      for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
       {
-        if (Cur->Priority < 1 || Cur->Priority > 5)
-           cout << "Bad prio " << Pkg.Name() << ',' << Cur.VerStr() << " == " << (int)Cur->Priority << endl;
+        for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
+        {
+           if (D->Version != 0)
+              DepVerSize += strlen(D.TargetVer()) + 1;
+        }
       }
    }
+   cout << _("Total Dependency Version space: ") << SizeToStr(DepVerSize) << endl;
+   
+   unsigned long Slack = 0;
+   for (int I = 0; I != 7; I++)
+      Slack += Cache.Head().Pools[I].ItemSize*Cache.Head().Pools[I].Count;
+   cout << _("Total Slack space: ") << SizeToStr(Slack) << endl;
+   
+   unsigned long Total = 0;
+   Total = Slack + Size + Cache.Head().DependsCount*Cache.Head().DependencySz + 
+           Cache.Head().VersionCount*Cache.Head().VersionSz +
+           Cache.Head().PackageCount*Cache.Head().PackageSz + 
+           Cache.Head().VerFileCount*Cache.Head().VerFileSz +
+           Cache.Head().ProvidesCount*Cache.Head().ProvidesSz;
+   cout << _("Total Space Accounted for: ") << SizeToStr(Total) << endl;
+   
    return true;
 }
                                                                        /*}}}*/
 // Dump - show everything                                              /*{{{*/
 // ---------------------------------------------------------------------
-/* */
-bool Dump(pkgCache &Cache)
+/* This is worthless except fer debugging things */
+bool Dump(CommandLine &Cmd)
 {
+   pkgCache &Cache = *GCache;
+   cout << "Using Versioning System: " << Cache.VS->Label << endl;
+   
    for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
    {
       cout << "Package: " << P.Name() << endl;
@@ -264,17 +338,26 @@ bool Dump(pkgCache &Cache)
         cout << " Version: " << V.VerStr() << endl;
         cout << "     File: " << V.FileList().File().FileName() << endl;
         for (pkgCache::DepIterator D = V.DependsList(); D.end() == false; D++)
-           cout << "  Depends: " << D.TargetPkg().Name() << ' ' << D.TargetVer() << endl;
+           cout << "  Depends: " << D.TargetPkg().Name() << ' ' << 
+                            DeNull(D.TargetVer()) << endl;
       }      
    }
 
-   for (pkgCache::PkgFileIterator F(Cache); F.end() == false; F++)
+   for (pkgCache::PkgFileIterator F = Cache.FileBegin(); F.end() == false; F++)
    {
       cout << "File: " << F.FileName() << endl;
+      cout << " Type: " << F.IndexType() << endl;
       cout << " Size: " << F->Size << endl;
       cout << " ID: " << F->ID << endl;
       cout << " Flags: " << F->Flags << endl;
-      cout << " Time: " << ctime(&F->mtime) << endl;
+      cout << " Time: " << TimeRFC1123(F->mtime) << endl;
+      cout << " Archive: " << DeNull(F.Archive()) << endl;
+      cout << " Component: " << DeNull(F.Component()) << endl;
+      cout << " Version: " << DeNull(F.Version()) << endl;
+      cout << " Origin: " << DeNull(F.Origin()) << endl;
+      cout << " Site: " << DeNull(F.Site()) << endl;
+      cout << " Label: " << DeNull(F.Label()) << endl;
+      cout << " Architecture: " << DeNull(F.Architecture()) << endl;
    }
 
    return true;
@@ -282,52 +365,435 @@ bool Dump(pkgCache &Cache)
                                                                        /*}}}*/
 // DumpAvail - Print out the available list                            /*{{{*/
 // ---------------------------------------------------------------------
-/* This is needed to make dpkg --merge happy */
-bool DumpAvail(pkgCache &Cache)
+/* This is needed to make dpkg --merge happy.. I spent a bit of time to 
+   make this run really fast, perhaps I went a little overboard.. */
+bool DumpAvail(CommandLine &Cmd)
 {
-   unsigned char *Buffer = new unsigned char[Cache.HeaderP->MaxVerFileSize];
+   pkgCache &Cache = *GCache;
 
-   for (pkgCache::PkgFileIterator I = Cache.FileBegin(); I.end() == false; I++)
-   {
-      if ((I->Flags & pkgCache::Flag::NotSource) != 0)
+   pkgPolicy Plcy(&Cache);
+   if (ReadPinFile(Plcy) == false)
+      return false;
+   
+   unsigned long Count = Cache.HeaderP->PackageCount+1;
+   pkgCache::VerFile **VFList = new pkgCache::VerFile *[Count];
+   memset(VFList,0,sizeof(*VFList)*Count);
+   
+   // Map versions that we want to write out onto the VerList array.
+   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+   {    
+      if (P->VersionList == 0)
         continue;
       
-      if (I.IsOk() == false)
+      /* Find the proper version to use. If the policy says there are no
+         possible selections we return the installed version, if available..
+                This prevents dselect from making it obsolete. */
+      pkgCache::VerIterator V = Plcy.GetCandidateVer(P);
+      if (V.end() == true)
       {
-        delete [] Buffer;
-        return _error->Error("Package file %s is out of sync.",I.FileName());
+        if (P->CurrentVer == 0)
+           continue;
+        V = P.CurrentVer();
       }
       
-      FileFd PkgF(I.FileName(),FileFd::ReadOnly);
+      pkgCache::VerFileIterator VF = V.FileList();
+      for (; VF.end() == false ; VF++)
+        if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
+           break;
+      
+      /* Okay, here we have a bit of a problem.. The policy has selected the
+         currently installed package - however it only exists in the
+                status file.. We need to write out something or dselect will mark
+         the package as obsolete! Thus we emit the status file entry, but
+         below we remove the status line to make it valid for the 
+         available file. However! We only do this if their do exist *any*
+         non-source versions of the package - that way the dselect obsolete
+         handling works OK. */
+      if (VF.end() == true)
+      {
+        for (pkgCache::VerIterator Cur = P.VersionList(); Cur.end() != true; Cur++)
+        {
+           for (VF = Cur.FileList(); VF.end() == false; VF++)
+           {    
+              if ((VF.File()->Flags & pkgCache::Flag::NotSource) == 0)
+              {
+                 VF = V.FileList();
+                 break;
+              }
+           }
+           
+           if (VF.end() == false)
+              break;
+        }
+      }
+      
+      VFList[P->ID] = VF;
+   }
+   
+   LocalitySort(VFList,Count,sizeof(*VFList));
+
+   // Iterate over all the package files and write them out.
+   char *Buffer = new char[Cache.HeaderP->MaxVerFileSize+10];
+   for (pkgCache::VerFile **J = VFList; *J != 0;)
+   {
+      pkgCache::PkgFileIterator File(Cache,(*J)->File + Cache.PkgFileP);
+      if (File.IsOk() == false)
+      {
+        _error->Error(_("Package file %s is out of sync."),File.FileName());
+        break;
+      }
+
+      FileFd PkgF(File.FileName(),FileFd::ReadOnly);
       if (_error->PendingError() == true)
+        break;
+      
+      /* Write all of the records from this package file, since we
+                already did locality sorting we can now just seek through the
+                file in read order. We apply 1 more optimization here, since often
+                there will be < 1 byte gaps between records (for the \n) we read that
+                into the next buffer and offset a bit.. */
+      unsigned long Pos = 0;
+      for (; *J != 0; J++)
       {
-        delete [] Buffer;
-        return false;
+        if ((*J)->File + Cache.PkgFileP != File)
+           break;
+        
+        const pkgCache::VerFile &VF = **J;
+
+        // Read the record and then write it out again.
+        unsigned long Jitter = VF.Offset - Pos;
+        if (Jitter > 8)
+        {
+           if (PkgF.Seek(VF.Offset) == false)
+              break;
+           Jitter = 0;
+        }
+        
+        if (PkgF.Read(Buffer,VF.Size + Jitter) == false)
+           break;
+        Buffer[VF.Size + Jitter] = '\n';
+        
+        // See above..
+        if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
+        {
+           pkgTagSection Tags;
+           TFRewriteData RW[] = {{"Status",0},{"Config-Version",0},{}};
+           const char *Zero = 0;
+           if (Tags.Scan(Buffer+Jitter,VF.Size+1) == false ||
+               TFRewrite(stdout,Tags,&Zero,RW) == false)
+           {
+              _error->Error("Internal Error, Unable to parse a package record");
+              break;
+           }
+           fputc('\n',stdout);
+        }
+        else
+        {
+           if (fwrite(Buffer+Jitter,VF.Size+1,1,stdout) != 1)
+              break;
+        }
+        
+        Pos = VF.Offset + VF.Size;
       }
 
-      /* Write all of the records from this package file, we search the entire
-         structure to find them */
-      for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+      fflush(stdout);
+      if (_error->PendingError() == true)
+         break;
+   }
+   
+   delete [] Buffer;
+   delete [] VFList;
+   return !_error->PendingError();
+}
+                                                                       /*}}}*/
+// Depends - Print out a dependency tree                               /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool Depends(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   SPtrArray<unsigned> Colours = new unsigned[Cache.Head().PackageCount];
+   memset(Colours,0,sizeof(*Colours)*Cache.Head().PackageCount);
+   
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
+      if (Pkg.end() == true)
       {
-        for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; V++)
+        _error->Warning(_("Unable to locate package %s"),*I);
+        continue;
+      }
+      Colours[Pkg->ID] = 1;
+   }
+   
+   bool Recurse = _config->FindB("APT::Cache::RecurseDepends",false);
+   bool DidSomething;
+   do
+   {
+      DidSomething = false;
+      for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
+      {
+        if (Colours[Pkg->ID] != 1)
+           continue;
+        Colours[Pkg->ID] = 2;
+        DidSomething = true;
+        
+        pkgCache::VerIterator Ver = Pkg.VersionList();
+        if (Ver.end() == true)
         {
-           if (V->FileList == 0)
-              continue;
-           if (V.FileList().File() != I)
-              continue;
+           cout << '<' << Pkg.Name() << '>' << endl;
+           continue;
+        }
+        
+        cout << Pkg.Name() << endl;
+        
+        for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
+        {
+           if ((D->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or)
+              cout << " |";
+           else
+              cout << "  ";
+           
+           // Show the package
+           pkgCache::PkgIterator Trg = D.TargetPkg();
+           if (Trg->VersionList == 0)
+              cout << D.DepType() << ": <" << Trg.Name() << ">" << endl;
+           else
+              cout << D.DepType() << ": " << Trg.Name() << endl;
            
-           // Read the record and then write it out again.
-           if (PkgF.Seek(V.FileList()->Offset) == false ||
-               PkgF.Read(Buffer,V.FileList()->Size) == false ||
-               write(STDOUT_FILENO,Buffer,V.FileList()->Size) != V.FileList()->Size)
+           if (Recurse == true)
+              Colours[D.TargetPkg()->ID]++;
+           
+           // Display all solutions
+           SPtrArray<pkgCache::Version *> List = D.AllTargets();
+           pkgPrioSortList(Cache,List);
+           for (pkgCache::Version **I = List; *I != 0; I++)
            {
-              delete [] Buffer;
-              return false;
+              pkgCache::VerIterator V(Cache,*I);
+              if (V != Cache.VerP + V.ParentPkg()->VersionList ||
+                  V->ParentPkg == D->Package)
+                 continue;
+              cout << "    " << V.ParentPkg().Name() << endl;
+              
+              if (Recurse == true)
+                 Colours[D.ParentPkg()->ID]++;
+           }
+        }
+      }      
+   }   
+   while (DidSomething == true);
+   
+   return true;
+}
+                                                                       /*}}}*/
+// Dotty - Generate a graph for Dotty                                  /*{{{*/
+// ---------------------------------------------------------------------
+/* Dotty is the graphvis program for generating graphs. It is a fairly
+   simple queuing algorithm that just writes dependencies and nodes. 
+   http://www.research.att.com/sw/tools/graphviz/ */
+bool Dotty(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   bool GivenOnly = _config->FindB("APT::Cache::GivenOnly",false);
+   
+   /* Normal packages are boxes
+      Pure Provides are triangles
+      Mixed are diamonds
+      Hexagons are missing packages*/
+   const char *Shapes[] = {"hexagon","triangle","box","diamond"};
+   
+   /* Initialize the list of packages to show.
+      1 = To Show
+      2 = To Show no recurse
+      3 = Emitted no recurse
+      4 = Emitted
+      0 = None */
+   enum States {None=0, ToShow, ToShowNR, DoneNR, Done};
+   enum TheFlags {ForceNR=(1<<0)};
+   unsigned char *Show = new unsigned char[Cache.Head().PackageCount];
+   unsigned char *Flags = new unsigned char[Cache.Head().PackageCount];
+   unsigned char *ShapeMap = new unsigned char[Cache.Head().PackageCount];
+   
+   // Show everything if no arguments given
+   if (CmdL.FileList[1] == 0)
+      for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
+        Show[I] = ToShow;
+   else
+      for (unsigned long I = 0; I != Cache.Head().PackageCount; I++)
+        Show[I] = None;
+   memset(Flags,0,sizeof(*Flags)*Cache.Head().PackageCount);
+   
+   // Map the shapes
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
+   {   
+      if (Pkg->VersionList == 0)
+      {
+        // Missing
+        if (Pkg->ProvidesList == 0)
+           ShapeMap[Pkg->ID] = 0;
+        else
+           ShapeMap[Pkg->ID] = 1;
+      }
+      else
+      {
+        // Normal
+        if (Pkg->ProvidesList == 0)
+           ShapeMap[Pkg->ID] = 2;
+        else
+           ShapeMap[Pkg->ID] = 3;
+      }
+   }
+   
+   // Load the list of packages from the command line into the show list
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      // Process per-package flags
+      string P = *I;
+      bool Force = false;
+      if (P.length() > 3)
+      {
+        if (P.end()[-1] == '^')
+        {
+           Force = true;
+           P.erase(P.end()-1);
+        }
+        
+        if (P.end()[-1] == ',')
+           P.erase(P.end()-1);
+      }
+      
+      // Locate the package
+      pkgCache::PkgIterator Pkg = Cache.FindPkg(P);
+      if (Pkg.end() == true)
+      {
+        _error->Warning(_("Unable to locate package %s"),*I);
+        continue;
+      }
+      Show[Pkg->ID] = ToShow;
+      
+      if (Force == true)
+        Flags[Pkg->ID] |= ForceNR;
+   }
+   
+   // Little header
+   printf("digraph packages {\n");
+   printf("concentrate=true;\n");
+   printf("size=\"30,40\";\n");
+   
+   bool Act = true;
+   while (Act == true)
+   {
+      Act = false;
+      for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
+      {
+        // See we need to show this package
+        if (Show[Pkg->ID] == None || Show[Pkg->ID] >= DoneNR)
+           continue;
+        
+        // Colour as done
+        if (Show[Pkg->ID] == ToShowNR || (Flags[Pkg->ID] & ForceNR) == ForceNR)
+        {
+           // Pure Provides and missing packages have no deps!
+           if (ShapeMap[Pkg->ID] == 0 || ShapeMap[Pkg->ID] == 1)
+              Show[Pkg->ID] = Done;
+           else
+              Show[Pkg->ID] = DoneNR;
+        }       
+        else
+           Show[Pkg->ID] = Done;
+        Act = true;
+
+        // No deps to map out
+        if (Pkg->VersionList == 0 || Show[Pkg->ID] == DoneNR)
+           continue;
+        
+        pkgCache::VerIterator Ver = Pkg.VersionList();
+        for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; D++)
+        {
+           // See if anything can meet this dep
+           // Walk along the actual package providing versions
+           bool Hit = false;
+           pkgCache::PkgIterator DPkg = D.TargetPkg();
+           for (pkgCache::VerIterator I = DPkg.VersionList();
+                     I.end() == false && Hit == false; I++)
+           {
+              if (Cache.VS->CheckDep(I.VerStr(),D->CompareOp,D.TargetVer()) == true)
+                 Hit = true;
+           }
+           
+           // Follow all provides
+           for (pkgCache::PrvIterator I = DPkg.ProvidesList(); 
+                     I.end() == false && Hit == false; I++)
+           {
+              if (Cache.VS->CheckDep(I.ProvideVersion(),D->CompareOp,D.TargetVer()) == false)
+                 Hit = true;
+           }
+           
+           // Only graph critical deps     
+           if (D.IsCritical() == true)
+           {
+              printf("\"%s\" -> \"%s\"",Pkg.Name(),D.TargetPkg().Name());
+              
+              // Colour the node for recursion
+              if (Show[D.TargetPkg()->ID] <= DoneNR)
+              {
+                 /* If a conflicts does not meet anything in the database
+                    then show the relation but do not recurse */
+                 if (Hit == false && 
+                     (D->Type == pkgCache::Dep::Conflicts ||
+                      D->Type == pkgCache::Dep::Obsoletes))
+                 {
+                    if (Show[D.TargetPkg()->ID] == None && 
+                        Show[D.TargetPkg()->ID] != ToShow)
+                       Show[D.TargetPkg()->ID] = ToShowNR;
+                 }               
+                 else
+                 {
+                    if (GivenOnly == true && Show[D.TargetPkg()->ID] != ToShow)
+                       Show[D.TargetPkg()->ID] = ToShowNR;
+                    else
+                       Show[D.TargetPkg()->ID] = ToShow;
+                 }
+              }
+              
+              // Edge colour
+              switch(D->Type)
+              {
+                 case pkgCache::Dep::Conflicts:
+                 case pkgCache::Dep::Obsoletes:
+                 printf("[color=springgreen];\n");
+                 break;
+                 
+                 case pkgCache::Dep::PreDepends:
+                 printf("[color=blue];\n");
+                 break;
+                 
+                 default:
+                 printf(";\n");
+                 break;
+              }               
            }       
         }
       }
+   }   
+   
+   /* Draw the box colours after the fact since we can not tell what colour
+      they should be until everything is finished drawing */
+   for (pkgCache::PkgIterator Pkg = Cache.PkgBegin(); Pkg.end() == false; Pkg++)
+   {
+      if (Show[Pkg->ID] < DoneNR)
+        continue;
+      
+      // Orange box for early recursion stoppage
+      if (Show[Pkg->ID] == DoneNR)
+        printf("\"%s\" [color=orange,shape=%s];\n",Pkg.Name(),
+               Shapes[ShapeMap[Pkg->ID]]);
+      else
+        printf("\"%s\" [shape=%s];\n",Pkg.Name(),
+               Shapes[ShapeMap[Pkg->ID]]);
    }
    
+   printf("}\n");
    return true;
 }
                                                                        /*}}}*/
@@ -336,6 +802,8 @@ bool DumpAvail(pkgCache &Cache)
 /* */
 bool DoAdd(CommandLine &CmdL)
 {
+   return _error->Error("Unimplemented");
+#if 0   
    // Make sure there is at least one argument
    if (CmdL.FileSize() <= 1)
       return _error->Error("You must give at least one file name");
@@ -366,7 +834,7 @@ bool DoAdd(CommandLine &CmdL)
       if (_error->PendingError() == true)
         return _error->Error("Problem opening %s",*I);
       
-      if (Gen.SelectFile(*I) == false)
+      if (Gen.SelectFile(*I,"") == false)
         return _error->Error("Problem with SelectFile");
         
       if (Gen.MergeList(Parser) == false)
@@ -374,7 +842,395 @@ bool DoAdd(CommandLine &CmdL)
    }
 
    Progress.Done();
-   Stats(Gen.GetCache());
+   GCache = &Gen.GetCache();
+   Stats(CmdL);
+   
+   return true;
+#endif   
+}
+                                                                       /*}}}*/
+// DisplayRecord - Displays the complete record for the package                /*{{{*/
+// ---------------------------------------------------------------------
+/* This displays the package record from the proper package index file. 
+   It is not used by DumpAvail for performance reasons. */
+bool DisplayRecord(pkgCache::VerIterator V)
+{
+   // Find an appropriate file
+   pkgCache::VerFileIterator Vf = V.FileList();
+   for (; Vf.end() == false; Vf++)
+      if ((Vf.File()->Flags & pkgCache::Flag::NotSource) == 0)
+        break;
+   if (Vf.end() == true)
+      Vf = V.FileList();
+      
+   // Check and load the package list file
+   pkgCache::PkgFileIterator I = Vf.File();
+   if (I.IsOk() == false)
+      return _error->Error(_("Package file %s is out of sync."),I.FileName());
+   
+   FileFd PkgF(I.FileName(),FileFd::ReadOnly);
+   if (_error->PendingError() == true)
+      return false;
+   
+   // Read the record and then write it out again.
+   unsigned char *Buffer = new unsigned char[GCache->HeaderP->MaxVerFileSize+1];
+   Buffer[V.FileList()->Size] = '\n';
+   if (PkgF.Seek(V.FileList()->Offset) == false ||
+       PkgF.Read(Buffer,V.FileList()->Size) == false ||
+       write(STDOUT_FILENO,Buffer,V.FileList()->Size+1) != V.FileList()->Size+1)
+   {
+      delete [] Buffer;
+      return false;
+   }
+   
+   delete [] Buffer;
+
+   return true;
+}
+                                                                       /*}}}*/
+// Search - Perform a search                                           /*{{{*/
+// ---------------------------------------------------------------------
+/* This searches the package names and pacakge descriptions for a pattern */
+struct ExVerFile
+{
+   pkgCache::VerFile *Vf;
+   bool NameMatch;
+};
+
+bool Search(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   bool ShowFull = _config->FindB("APT::Cache::ShowFull",false);
+   bool NamesOnly = _config->FindB("APT::Cache::NamesOnly",false);
+   unsigned NumPatterns = CmdL.FileSize() -1;
+   
+   pkgDepCache::Policy Plcy;
+   
+   // Make sure there is at least one argument
+   if (NumPatterns < 1)
+      return _error->Error(_("You must give exactly one pattern"));
+   
+   // Compile the regex pattern
+   regex_t *Patterns = new regex_t[NumPatterns];
+   memset(Patterns,0,sizeof(*Patterns)*NumPatterns);
+   for (unsigned I = 0; I != NumPatterns; I++)
+   {
+      if (regcomp(&Patterns[I],CmdL.FileList[I+1],REG_EXTENDED | REG_ICASE | 
+                 REG_NOSUB) != 0)
+      {
+        for (; I != 0; I--)
+           regfree(&Patterns[I]);
+        return _error->Error("Regex compilation error");
+      }      
+   }
+   
+   // Create the text record parser
+   pkgRecords Recs(Cache);
+   if (_error->PendingError() == true)
+   {
+      for (unsigned I = 0; I != NumPatterns; I++)
+        regfree(&Patterns[I]);
+      return false;
+   }
+   
+   ExVerFile *VFList = new ExVerFile[Cache.HeaderP->PackageCount+1];
+   memset(VFList,0,sizeof(*VFList)*Cache.HeaderP->PackageCount+1);
+
+   // Map versions that we want to write out onto the VerList array.
+   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+   {
+      VFList[P->ID].NameMatch = NumPatterns != 0;
+      for (unsigned I = 0; I != NumPatterns; I++)
+      {
+        if (regexec(&Patterns[I],P.Name(),0,0,0) == 0)
+           VFList[P->ID].NameMatch &= true;
+        else
+           VFList[P->ID].NameMatch = false;
+      }
+        
+      // Doing names only, drop any that dont match..
+      if (NamesOnly == true && VFList[P->ID].NameMatch == false)
+        continue;
+        
+      // Find the proper version to use. 
+      pkgCache::VerIterator V = Plcy.GetCandidateVer(P);
+      if (V.end() == false)
+        VFList[P->ID].Vf = V.FileList();
+   }
+      
+   // Include all the packages that provide matching names too
+   for (pkgCache::PkgIterator P = Cache.PkgBegin(); P.end() == false; P++)
+   {
+      if (VFList[P->ID].NameMatch == false)
+        continue;
+
+      for (pkgCache::PrvIterator Prv = P.ProvidesList() ; Prv.end() == false; Prv++)
+      {
+        pkgCache::VerIterator V = Plcy.GetCandidateVer(Prv.OwnerPkg());
+        if (V.end() == false)
+        {
+           VFList[Prv.OwnerPkg()->ID].Vf = V.FileList();
+           VFList[Prv.OwnerPkg()->ID].NameMatch = true;
+        }
+      }
+   }
+
+   LocalitySort(&VFList->Vf,Cache.HeaderP->PackageCount,sizeof(*VFList));
+
+   // Iterate over all the version records and check them
+   for (ExVerFile *J = VFList; J->Vf != 0; J++)
+   {
+      pkgRecords::Parser &P = Recs.Lookup(pkgCache::VerFileIterator(Cache,J->Vf));
+
+      bool Match = true;
+      if (J->NameMatch == false)
+      {
+        string LongDesc = P.LongDesc();
+        Match = NumPatterns != 0;
+        for (unsigned I = 0; I != NumPatterns; I++)
+        {
+           if (regexec(&Patterns[I],LongDesc.c_str(),0,0,0) == 0)
+              Match &= true;
+           else
+              Match = false;
+        }
+      }
+      
+      if (Match == true)
+      {
+        if (ShowFull == true)
+        {
+           const char *Start;
+           const char *End;
+           P.GetRec(Start,End);
+           fwrite(Start,End-Start,1,stdout);
+           putc('\n',stdout);
+        }       
+        else
+           printf("%s - %s\n",P.Name().c_str(),P.ShortDesc().c_str());
+      }
+   }
+   
+   delete [] VFList;
+   for (unsigned I = 0; I != NumPatterns; I++)
+      regfree(&Patterns[I]);
+   if (ferror(stdout))
+       return _error->Error("Write to stdout failed");
+   return true;
+}
+                                                                       /*}}}*/
+// ShowPackage - Dump the package record to the screen                 /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ShowPackage(CommandLine &CmdL)
+{   
+   pkgCache &Cache = *GCache;
+   pkgDepCache::Policy Plcy;
+   
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
+      if (Pkg.end() == true)
+      {
+        _error->Warning(_("Unable to locate package %s"),*I);
+        continue;
+      }
+
+      // Find the proper version to use.
+      if (_config->FindB("APT::Cache::AllVersions","true") == true)
+      {
+        pkgCache::VerIterator V;
+        for (V = Pkg.VersionList(); V.end() == false; V++)
+        {
+           if (DisplayRecord(V) == false)
+              return false;
+        }
+      }
+      else
+      {
+        pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
+        if (V.end() == true || V.FileList().end() == true)
+           continue;
+        if (DisplayRecord(V) == false)
+           return false;
+      }      
+   }
+   return true;
+}
+                                                                       /*}}}*/
+// ShowPkgNames - Show package names                                   /*{{{*/
+// ---------------------------------------------------------------------
+/* This does a prefix match on the first argument */
+bool ShowPkgNames(CommandLine &CmdL)
+{
+   pkgCache &Cache = *GCache;
+   pkgCache::PkgIterator I = Cache.PkgBegin();
+   bool All = _config->FindB("APT::Cache::AllNames","false");
+   
+   if (CmdL.FileList[1] != 0)
+   {
+      for (;I.end() != true; I++)
+      {
+        if (All == false && I->VersionList == 0)
+           continue;
+        
+        if (strncmp(I.Name(),CmdL.FileList[1],strlen(CmdL.FileList[1])) == 0)
+           cout << I.Name() << endl;
+      }
+
+      return true;
+   }
+   
+   // Show all pkgs
+   for (;I.end() != true; I++)
+   {
+      if (All == false && I->VersionList == 0)
+        continue;
+      cout << I.Name() << endl;
+   }
+   
+   return true;
+}
+                                                                       /*}}}*/
+// ShowSrcPackage - Show source package records                                /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool ShowSrcPackage(CommandLine &CmdL)
+{
+   pkgSourceList List;
+   List.ReadMainList();
+   
+   // Create the text record parsers
+   pkgSrcRecords SrcRecs(List);
+   if (_error->PendingError() == true)
+      return false;
+
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      SrcRecs.Restart();
+      
+      pkgSrcRecords::Parser *Parse;
+      while ((Parse = SrcRecs.Find(*I,false)) != 0)
+        cout << Parse->AsStr() << endl;;
+   }      
+   return true;
+}
+                                                                       /*}}}*/
+// Policy - Show the results of the preferences file                   /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+bool Policy(CommandLine &CmdL)
+{
+   if (SrcList == 0)
+      return _error->Error("Generate must be enabled for this function");
+   
+   pkgCache &Cache = *GCache;
+   pkgPolicy Plcy(&Cache);
+   if (ReadPinFile(Plcy) == false)
+      return false;
+   
+   // Print out all of the package files
+   if (CmdL.FileList[1] == 0)
+   {
+      cout << _("Package Files:") << endl;   
+      for (pkgCache::PkgFileIterator F = Cache.FileBegin(); F.end() == false; F++)
+      {
+        // Locate the associated index files so we can derive a description
+        pkgIndexFile *Indx;
+        if (SrcList->FindIndex(F,Indx) == false &&
+            _system->FindIndex(F,Indx) == false)
+           return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
+        printf(_("%4i %s\n"),
+               Plcy.GetPriority(F),Indx->Describe(true).c_str());
+        
+        // Print the reference information for the package
+        string Str = F.RelStr();
+        if (Str.empty() == false)
+           printf("     release %s\n",F.RelStr().c_str());
+        if (F.Site() != 0 && F.Site()[0] != 0)
+           printf("     origin %s\n",F.Site());
+      }
+      
+      // Show any packages have explicit pins
+      cout << _("Pinned Packages:") << endl;
+      pkgCache::PkgIterator I = Cache.PkgBegin();
+      for (;I.end() != true; I++)
+      {
+        if (Plcy.GetPriority(I) == 0)
+           continue;
+
+        // Print the package name and the version we are forcing to
+        cout << "     " << I.Name() << " -> ";
+        
+        pkgCache::VerIterator V = Plcy.GetMatch(I);
+        if (V.end() == true)
+           cout << _("(not found)") << endl;
+        else
+           cout << V.VerStr() << endl;
+      }     
+      
+      return true;
+   }
+   
+   // Print out detailed information for each package
+   for (const char **I = CmdL.FileList + 1; *I != 0; I++)
+   {
+      pkgCache::PkgIterator Pkg = Cache.FindPkg(*I);
+      if (Pkg.end() == true)
+      {
+        _error->Warning(_("Unable to locate package %s"),*I);
+        continue;
+      }
+      
+      cout << Pkg.Name() << ":" << endl;
+      
+      // Installed version
+      cout << _("  Installed: ");
+      if (Pkg->CurrentVer == 0)
+        cout << _("(none)") << endl;
+      else
+        cout << Pkg.CurrentVer().VerStr() << endl;
+      
+      // Candidate Version 
+      cout << _("  Candidate: ");
+      pkgCache::VerIterator V = Plcy.GetCandidateVer(Pkg);
+      if (V.end() == true)
+        cout << _("(none)") << endl;
+      else
+        cout << V.VerStr() << endl;
+
+      // Pinned version
+      if (Plcy.GetPriority(Pkg) != 0)
+      {
+        cout << _("  Package Pin: ");
+        V = Plcy.GetMatch(Pkg);
+        if (V.end() == true)
+           cout << _("(not found)") << endl;
+        else
+           cout << V.VerStr() << endl;
+      }
+      
+      // Show the priority tables
+      cout << _("  Version Table:") << endl;
+      for (V = Pkg.VersionList(); V.end() == false; V++)
+      {
+        if (Pkg.CurrentVer() == V)
+           cout << " *** " << V.VerStr();
+        else
+           cout << "     " << V.VerStr();
+        cout << " " << Plcy.GetPriority(Pkg) << endl;
+        for (pkgCache::VerFileIterator VF = V.FileList(); VF.end() == false; VF++)
+        {
+           // Locate the associated index files so we can derive a description
+           pkgIndexFile *Indx;
+           if (SrcList->FindIndex(VF.File(),Indx) == false &&
+               _system->FindIndex(VF.File(),Indx) == false)
+              return _error->Error(_("Cache is out of sync, can't x-ref a package file"));
+           printf(_("       %4i %s\n"),Plcy.GetPriority(VF.File()),
+                  Indx->Describe(true).c_str());
+        }       
+      }      
+   }
    
    return true;
 }
@@ -382,50 +1238,57 @@ bool DoAdd(CommandLine &CmdL)
 // GenCaches - Call the main cache generator                           /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool GenCaches()
+bool GenCaches(CommandLine &Cmd)
 {
    OpTextProgress Progress(*_config);
    
    pkgSourceList List;
-   List.ReadMainList();
+   if (List.ReadMainList() == false)
+      return false;   
    return pkgMakeStatusCache(List,Progress);
 }
                                                                        /*}}}*/
 // ShowHelp - Show a help screen                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
-int ShowHelp()
+bool ShowHelp(CommandLine &Cmd)
 {
-   cout << PACKAGE << ' ' << VERSION << " for " << ARCHITECTURE <<
-       " compiled on " << __DATE__ << "  " << __TIME__ << endl;
-   
-   cout << "Usage: apt-cache [options] command" << endl;
-   cout << "       apt-cache [options] add file1 [file1 ...]" << endl;
-   cout << "       apt-cache [options] showpkg pkg1 [pkg2 ...]" << endl;
-   cout << endl;
-   cout << "apt-cache is a low-level tool used to manipulate APT's binary" << endl;
-   cout << "cache files stored in " << _config->FindFile("Dir::Cache") << endl;
-   cout << "It is not ment for ordinary use only as a debug aide." << endl;
-   cout << endl;
-   cout << "Commands:" << endl;
-   cout << "   add - Add an package file to the source cache" << endl;
-   cout << "   gencaches - Build both the package and source cache" << endl;
-   cout << "   showpkg - Show some general information for a single package" << endl;
-   cout << "   stats - Show some basic statistics" << endl;
-   cout << "   dump - Show the entire file in a terse form" << endl;
-   cout << "   dumpavail - Print an available file to stdout" << endl;
-   cout << "   unmet - Show unmet dependencies" << endl;
-   cout << "   check - Check the cache a bit" << endl;
-   cout << endl;
-   cout << "Options:" << endl;
-   cout << "  -h   This help text." << endl;
-   cout << "  -p=? The package cache. [" << _config->FindFile("Dir::Cache::pkgcache") << ']' << endl;
-   cout << "  -s=? The source cache. [" << _config->FindFile("Dir::Cache::srcpkgcache") << ']' << endl;
-   cout << "  -q   Disable progress indicator. " << endl;
-   cout << "  -c=? Read this configuration file" << endl;
-   cout << "  -o=? Set an arbitary configuration option, ie -o dir::cache=/tmp" << endl;
-   cout << "See the apt-cache(8) and apt.conf(8) manual pages for more information." << endl;
-   return 100;
+   ioprintf(cout,_("%s %s for %s %s compiled on %s %s\n"),PACKAGE,VERSION,
+           COMMON_OS,COMMON_CPU,__DATE__,__TIME__);
+   
+   cout << 
+    _("Usage: apt-cache [options] command\n"
+      "       apt-cache [options] add file1 [file1 ...]\n"
+      "       apt-cache [options] showpkg pkg1 [pkg2 ...]\n"
+      "\n"
+      "apt-cache is a low-level tool used to manipulate APT's binary\n"
+      "cache files, and query information from them\n"
+      "\n"
+      "Commands:\n"
+      "   add - Add an package file to the source cache\n"
+      "   gencaches - Build both the package and source cache\n"
+      "   showpkg - Show some general information for a single package\n"
+      "   stats - Show some basic statistics\n"
+      "   dump - Show the entire file in a terse form\n"
+      "   dumpavail - Print an available file to stdout\n"
+      "   unmet - Show unmet dependencies\n"
+      "   search - Search the package list for a regex pattern\n"
+      "   show - Show a readable record for the package\n"
+      "   depends - Show raw dependency information for a package\n"
+      "   pkgnames - List the names of all packages\n"
+      "   dotty - Generate package graphs for GraphVis\n"
+      "   policy - Show policy settings\n"
+      "\n"
+      "Options:\n"
+      "  -h   This help text.\n"
+      "  -p=? The package cache.\n"
+      "  -s=? The source cache.\n"
+      "  -q   Disable progress indicator.\n"
+      "  -i   Show only important deps for the unmet command.\n"
+      "  -c=? Read this configuration file\n"
+      "  -o=? Set an arbitary configuration option, eg -o dir::cache=/tmp\n"
+      "See the apt-cache(8) and apt.conf(5) manual pages for more information.\n");
+   return true;
 }
                                                                        /*}}}*/
 // CacheInitialize - Initialize things for apt-cache                   /*{{{*/
@@ -442,20 +1305,49 @@ int main(int argc,const char *argv[])
 {
    CommandLine::Args Args[] = {
       {'h',"help","help",0},
+      {'v',"version","version",0},
       {'p',"pkg-cache","Dir::Cache::pkgcache",CommandLine::HasArg},
       {'s',"src-cache","Dir::Cache::srcpkgcache",CommandLine::HasArg},
       {'q',"quiet","quiet",CommandLine::IntLevel},
       {'i',"important","APT::Cache::Important",0},
+      {'f',"full","APT::Cache::ShowFull",0},
+      {'g',"generate","APT::Cache::Generate",0},
+      {'a',"all-versions","APT::Cache::AllVersions",0},
+      {0,"names-only","APT::Cache::NamesOnly",0},
+      {0,"all-names","APT::Cache::AllNames",0},
+      {0,"recurse","APT::Cache::RecurseDepends",0},
       {'c',"config-file",0,CommandLine::ConfigFile},
       {'o',"option",0,CommandLine::ArbItem},
       {0,0,0,0}};
+   CommandLine::Dispatch CmdsA[] = {{"help",&ShowHelp},
+                                    {"add",&DoAdd},
+                                    {"gencaches",&GenCaches},
+                                    {"showsrc",&ShowSrcPackage},
+                                    {0,0}};
+   CommandLine::Dispatch CmdsB[] = {{"showpkg",&DumpPackage},
+                                    {"stats",&Stats},
+                                    {"dump",&Dump},
+                                    {"dumpavail",&DumpAvail},
+                                    {"unmet",&UnMet},
+                                    {"search",&Search},
+                                    {"depends",&Depends},
+                                    {"dotty",&Dotty},
+                                    {"show",&ShowPackage},
+                                    {"pkgnames",&ShowPkgNames},
+                                    {"policy",&Policy},
+                                    {0,0}};
 
    CacheInitialize();
-   
+
+   // Set up gettext support
+   setlocale(LC_ALL,"");
+   textdomain(PACKAGE);
+
    // Parse the command line and initialize the package library
    CommandLine CmdL(Args,_config);
-   if (pkgInitialize(*_config) == false ||
-       CmdL.Parse(argc,argv) == false)
+   if (pkgInitConfig(*_config) == false ||
+       CmdL.Parse(argc,argv) == false ||
+       pkgInitSystem(*_config,_system) == false)
    {
       _error->DumpErrors();
       return 100;
@@ -464,73 +1356,42 @@ int main(int argc,const char *argv[])
    // See if the help should be shown
    if (_config->FindB("help") == true ||
        CmdL.FileSize() == 0)
-      return ShowHelp();
-   
-   while (1)
    {
-      if (strcmp(CmdL.FileList[0],"add") == 0)
-      {
-        DoAdd(CmdL);
-        break;
-      }
+      ShowHelp(CmdL);
+      return 0;
+   }
+   
+   // Deal with stdout not being a tty
+   if (ttyname(STDOUT_FILENO) == 0 && _config->FindI("quiet",0) < 1)
+      _config->Set("quiet","1");
 
-      if (strcmp(CmdL.FileList[0],"gencaches") == 0)
+   if (CmdL.DispatchArg(CmdsA,false) == false && _error->PendingError() == false)
+   { 
+      MMap *Map = 0;
+      if (_config->FindB("APT::Cache::Generate",true) == false)
       {
-        GenCaches();
-        break;
+        Map = new MMap(*new FileFd(_config->FindFile("Dir::Cache::pkgcache"),
+                                   FileFd::ReadOnly),MMap::Public|MMap::ReadOnly);
       }
-
-      // Open the cache file
-      FileFd CacheF(_config->FindFile("Dir::Cache::pkgcache"),FileFd::ReadOnly);
-      if (_error->PendingError() == true)
-        break;
-      
-      MMap Map(CacheF,MMap::Public | MMap::ReadOnly);
-      if (_error->PendingError() == true)
-        break;
-      
-      pkgCache Cache(Map);   
-      if (_error->PendingError() == true)
-        break;
-    
-      if (strcmp(CmdL.FileList[0],"showpkg") == 0)
+      else
       {
-        DumpPackage(Cache,CmdL);
-        break;
-      }
+        // Open the cache file
+        SrcList = new pkgSourceList;
+        SrcList->ReadMainList();
 
-      if (strcmp(CmdL.FileList[0],"stats") == 0)
-      {
-        Stats(Cache);
-        break;
-      }
-      
-      if (strcmp(CmdL.FileList[0],"dump") == 0)
-      {
-        Dump(Cache);
-        break;
-      }
-      
-      if (strcmp(CmdL.FileList[0],"dumpavail") == 0)
-      {
-        DumpAvail(Cache);
-        break;
+        // Generate it and map it
+        OpProgress Prog;
+        pkgMakeStatusCache(*SrcList,Prog,&Map,true);
       }
       
-      if (strcmp(CmdL.FileList[0],"unmet") == 0)
-      {
-        UnMet(Cache);
-        break;
-      }
-
-      if (strcmp(CmdL.FileList[0],"check") == 0)
+      if (_error->PendingError() == false)
       {
-        Check(Cache);
-        break;
+        pkgCache Cache(Map);   
+        GCache = &Cache;
+        if (_error->PendingError() == false)
+           CmdL.DispatchArg(CmdsB);
       }
-            
-      _error->Error("Invalid operation %s", CmdL.FileList[0]);
-      break;
+      delete Map;
    }
    
    // Print any errors or warnings found during parsing