]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/pkgcachegen.cc
* cmdline/cacheset.cc:
[apt.git] / apt-pkg / pkgcachegen.cc
index c1b546a0089ed57e9df5b158a8d2428dbf5f5354..5649cd6f8c41c67b6654d65d67a6dbbddcf99dbb 100644 (file)
@@ -22,6 +22,7 @@
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
+#include <apt-pkg/macros.h>
 
 #include <apt-pkg/tagfile.h>
 
@@ -33,7 +34,6 @@
 #include <unistd.h>
 #include <errno.h>
 #include <stdio.h>
-#include <system.h>
                                                                        /*}}}*/
 typedef vector<pkgIndexFile *>::iterator FileIterator;
 
@@ -117,7 +117,8 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       std::vector<string> genArch;
       if (List.ArchitectureAll() == true) {
         genArch = APT::Configuration::getArchitectures();
-        genArch.push_back("all");
+        if (genArch.size() != 1)
+           genArch.push_back("all");
       } else
         genArch.push_back(List.Architecture());
 
@@ -188,17 +189,22 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       pkgCache::VerIterator Ver = Pkg.VersionList();
       map_ptrloc *LastVer = &Pkg->VersionList;
       int Res = 1;
+      unsigned long const Hash = List.VersionHash();
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
-        if (Res >= 0)
+        // Version is higher as current version - insert here
+        if (Res > 0)
            break;
+        // Versionstrings are equal - is hash also equal?
+        if (Res == 0 && Ver->Hash == Hash)
+           break;
+        // proceed with the next till we have either the right
+        // or we found another version (which will be lower)
       }
-      
-      /* We already have a version for this item, record that we
-         saw it */
-      unsigned long Hash = List.VersionHash();
-      if (Res == 0 && Ver->Hash == Hash)
+
+      /* We already have a version for this item, record that we saw it */
+      if (Res == 0 && Ver.end() == false && Ver->Hash == Hash)
       {
         if (List.UsePackage(Pkg,Ver) == false)
            return _error->Error(_("Error occurred while processing %s (UsePackage2)"),
@@ -217,17 +223,6 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         }
         
         continue;
-      }      
-
-      // Skip to the end of the same version set.
-      if (Res == 0)
-      {
-        for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
-        {
-           Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
-           if (Res != 0)
-              break;
-        }
       }
 
       // Add a new version
@@ -340,29 +335,29 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */
-bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name) {
-       Grp = Cache.FindGrp(Name);
-       if (Grp.end() == false)
-               return true;
-
-       // Get a structure
-       unsigned long const Group = Map.Allocate(sizeof(pkgCache::Group));
-       if (unlikely(Group == 0))
-               return false;
+bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
+{
+   Grp = Cache.FindGrp(Name);
+   if (Grp.end() == false)
+      return true;
 
-       Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
-       Grp->Name = Map.WriteString(Name);
-       if (unlikely(Grp->Name == 0))
-               return false;
+   // Get a structure
+   unsigned long const Group = Map.Allocate(sizeof(pkgCache::Group));
+   if (unlikely(Group == 0))
+      return false;
 
-       // Insert it into the hash table
-       unsigned long const Hash = Cache.Hash(Name);
-       Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
-       Cache.HeaderP->GrpHashTable[Hash] = Group;
+   Grp = pkgCache::GrpIterator(Cache, Cache.GrpP + Group);
+   Grp->Name = Map.WriteString(Name);
+   if (unlikely(Grp->Name == 0))
+      return false;
 
-       Cache.HeaderP->GroupCount++;
+   // Insert it into the hash table
+   unsigned long const Hash = Cache.Hash(Name);
+   Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
+   Cache.HeaderP->GrpHashTable[Hash] = Group;
 
-       return true;
+   Grp->ID = Cache.HeaderP->GroupCount++;
+   return true;
 }
                                                                        /*}}}*/
 // CacheGenerator::NewPackage - Add a new package                      /*{{{*/
@@ -384,15 +379,23 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
       return false;
    Pkg = pkgCache::PkgIterator(Cache,Cache.PkgP + Package);
 
-   // Insert it into the hash table
-   unsigned long const Hash = Cache.Hash(Name);
-   Pkg->NextPackage = Cache.HeaderP->PkgHashTable[Hash];
-   Cache.HeaderP->PkgHashTable[Hash] = Package;
-
-   // remember the packages in the group
-   Grp->FirstPackage = Package;
-   if (Grp->LastPackage == 0)
-      Grp->LastPackage = Package;
+   // Insert the package into our package list
+   if (Grp->FirstPackage == 0) // the group is new
+   {
+      // Insert it into the hash table
+      unsigned long const Hash = Cache.Hash(Name);
+      Pkg->NextPackage = Cache.HeaderP->PkgHashTable[Hash];
+      Cache.HeaderP->PkgHashTable[Hash] = Package;
+      Grp->FirstPackage = Package;
+   }
+   else // Group the Packages together
+   {
+      // this package is the new last package
+      pkgCache::PkgIterator LastPkg(Cache, Cache.PkgP + Grp->LastPackage);
+      Pkg->NextPackage = LastPkg->NextPackage;
+      LastPkg->NextPackage = Package;
+   }
+   Grp->LastPackage = Package;
 
    // Set the name, arch and the ID
    Pkg->Name = Grp->Name;
@@ -523,68 +526,76 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
 // CacheGenerator::FinishCache - do various finish operations          /*{{{*/
 // ---------------------------------------------------------------------
 /* This prepares the Cache for delivery */
-bool pkgCacheGenerator::FinishCache(OpProgress &Progress) {
-       // FIXME: add progress reporting for this operation
-       // Do we have different architectures in your groups ?
-       vector<string> archs = APT::Configuration::getArchitectures();
-       if (archs.size() > 1) {
-               // Create Conflicts in between the group
-               for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++) {
-                       string const PkgName = G.Name();
-                       for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P)) {
-                               if (strcmp(P.Arch(),"all") == 0)
-                                       continue;
-                               pkgCache::PkgIterator allPkg;
-                               for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++) {
-                                       string const Arch = V.Arch(true);
-                                       map_ptrloc *OldDepLast = NULL;
-                                       /* MultiArch handling introduces a lot of implicit Dependencies:
-                                          - MultiArch: same → Co-Installable if they have the same version
-                                          - Architecture: all → Need to be Co-Installable for internal reasons
-                                          - All others conflict with all other group members */
-                                       bool const coInstall = (V->MultiArch == pkgCache::Version::All ||
-                                                               V->MultiArch == pkgCache::Version::Same);
-                                       if (V->MultiArch == pkgCache::Version::All && allPkg.end() == true)
-                                               allPkg = G.FindPkg("all");
-                                       for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A) {
-                                               if (*A == Arch)
-                                                       continue;
-                                               /* We allow only one installed arch at the time
-                                                  per group, therefore each group member conflicts
-                                                  with all other group members */
-                                               pkgCache::PkgIterator D = G.FindPkg(*A);
-                                               if (D.end() == true)
-                                                       continue;
-                                               if (coInstall == true) {
-                                                       // Replaces: ${self}:other ( << ${binary:Version})
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Less, pkgCache::Dep::Replaces,
-                                                                  OldDepLast);
-                                                       // Breaks: ${self}:other (!= ${binary:Version})
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
-                                                                  OldDepLast);
-                                                       NewDepends(D, V, V.VerStr(),
-                                                                  pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
-                                                                  OldDepLast);
-                                                       if (V->MultiArch == pkgCache::Version::All) {
-                                                               // Depend on ${self}:all which does depend on nothing
-                                                               NewDepends(allPkg, V, V.VerStr(),
-                                                                          pkgCache::Dep::Equals, pkgCache::Dep::Depends,
-                                                                          OldDepLast);
-                                                       }
-                                               } else {
-                                                       // Conflicts: ${self}:other
-                                                       NewDepends(D, V, "",
-                                                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
-                                                                  OldDepLast);
-                                               }
-                                       }
-                               }
-                       }
-               }
-       }
-       return true;
+bool pkgCacheGenerator::FinishCache(OpProgress *Progress)
+{
+   // FIXME: add progress reporting for this operation
+   // Do we have different architectures in your groups ?
+   vector<string> archs = APT::Configuration::getArchitectures();
+   if (archs.size() > 1)
+   {
+      // Create Conflicts in between the group
+      for (pkgCache::GrpIterator G = GetCache().GrpBegin(); G.end() != true; G++)
+      {
+        string const PkgName = G.Name();
+        for (pkgCache::PkgIterator P = G.PackageList(); P.end() != true; P = G.NextPkg(P))
+        {
+           if (strcmp(P.Arch(),"all") == 0)
+              continue;
+           pkgCache::PkgIterator allPkg;
+           for (pkgCache::VerIterator V = P.VersionList(); V.end() != true; V++)
+           {
+              string const Arch = V.Arch(true);
+              map_ptrloc *OldDepLast = NULL;
+              /* MultiArch handling introduces a lot of implicit Dependencies:
+               - MultiArch: same → Co-Installable if they have the same version
+               - Architecture: all → Need to be Co-Installable for internal reasons
+               - All others conflict with all other group members */
+              bool const coInstall = (V->MultiArch == pkgCache::Version::All ||
+                                       V->MultiArch == pkgCache::Version::Same);
+              if (V->MultiArch == pkgCache::Version::All && allPkg.end() == true)
+                 allPkg = G.FindPkg("all");
+              for (vector<string>::const_iterator A = archs.begin(); A != archs.end(); ++A)
+              {
+                 if (*A == Arch)
+                    continue;
+                 /* We allow only one installed arch at the time
+                    per group, therefore each group member conflicts
+                    with all other group members */
+                 pkgCache::PkgIterator D = G.FindPkg(*A);
+                 if (D.end() == true)
+                    continue;
+                 if (coInstall == true)
+                 {
+                    // Replaces: ${self}:other ( << ${binary:Version})
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Less, pkgCache::Dep::Replaces,
+                               OldDepLast);
+                    // Breaks: ${self}:other (!= ${binary:Version})
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Less, pkgCache::Dep::DpkgBreaks,
+                               OldDepLast);
+                    NewDepends(D, V, V.VerStr(),
+                               pkgCache::Dep::Greater, pkgCache::Dep::DpkgBreaks,
+                               OldDepLast);
+                    if (V->MultiArch == pkgCache::Version::All)
+                    {
+                       // Depend on ${self}:all which does depend on nothing
+                       NewDepends(allPkg, V, V.VerStr(),
+                                  pkgCache::Dep::Equals, pkgCache::Dep::Depends,
+                                  OldDepLast);
+                    }
+                 } else {
+                       // Conflicts: ${self}:other
+                       NewDepends(D, V, "",
+                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
+                                  OldDepLast);
+                 }
+              }
+           }
+        }
+      }
+   }
+   return true;
 }
                                                                        /*}}}*/
 // CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
@@ -807,16 +818,23 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
 static bool CheckValidity(const string &CacheFile, FileIterator Start, 
                           FileIterator End,MMap **OutMap = 0)
 {
+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
    // No file, certainly invalid
    if (CacheFile.empty() == true || FileExists(CacheFile) == false)
+   {
+      if (Debug == true)
+        std::clog << "CacheFile doesn't exist" << std::endl;
       return false;
-   
+   }
+
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
    SPtr<MMap> Map = new MMap(CacheF,0);
    pkgCache Cache(Map);
    if (_error->PendingError() == true || Map->Size() == 0)
    {
+      if (Debug == true)
+        std::clog << "Errors are pending or Map is empty()" << std::endl;
       _error->Discard();
       return false;
    }
@@ -826,9 +844,15 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
    SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
    memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
    for (; Start != End; Start++)
-   {      
+   {
+      if (Debug == true)
+        std::clog << "Checking PkgFile " << (*Start)->Describe() << ": ";
       if ((*Start)->HasPackages() == false)
+      {
+         if (Debug == true)
+           std::clog << "Has NO packages" << std::endl;
         continue;
+      }
     
       if ((*Start)->Exists() == false)
       {
@@ -836,23 +860,40 @@ static bool CheckValidity(const string &CacheFile, FileIterator Start,
         _error->WarningE("stat",_("Couldn't stat source package list %s"),
                          (*Start)->Describe().c_str());
 #endif
+         if (Debug == true)
+           std::clog << "file doesn't exist" << std::endl;
         continue;
       }
 
       // FindInCache is also expected to do an IMS check.
       pkgCache::PkgFileIterator File = (*Start)->FindInCache(Cache);
       if (File.end() == true)
+      {
+        if (Debug == true)
+           std::clog << "FindInCache returned end-Pointer" << std::endl;
         return false;
+      }
 
       Visited[File->ID] = true;
+      if (Debug == true)
+        std::clog << "with ID " << File->ID << " is valid" << std::endl;
    }
    
    for (unsigned I = 0; I != Cache.HeaderP->PackageFileCount; I++)
       if (Visited[I] == false)
+      {
+        if (Debug == true)
+           std::clog << "File with ID" << I << " wasn't visited" << std::endl;
         return false;
+      }
    
    if (_error->PendingError() == true)
    {
+      if (Debug == true)
+      {
+        std::clog << "Validity failed because of pending errors:" << std::endl;
+        _error->DumpErrors();
+      }
       _error->Discard();
       return false;
    }
@@ -882,7 +923,7 @@ static unsigned long ComputeSize(FileIterator Start,FileIterator End)
 // ---------------------------------------------------------------------
 /* */
 static bool BuildCache(pkgCacheGenerator &Gen,
-                      OpProgress &Progress,
+                      OpProgress *Progress,
                       unsigned long &CurrentSize,unsigned long TotalSize,
                       FileIterator Start, FileIterator End)
 {
@@ -903,7 +944,8 @@ static bool BuildCache(pkgCacheGenerator &Gen,
       }
       
       unsigned long Size = (*I)->Size();
-      Progress.OverallProgress(CurrentSize,TotalSize,Size,_("Reading package lists"));
+      if (Progress != NULL)
+        Progress->OverallProgress(CurrentSize,TotalSize,Size,_("Reading package lists"));
       CurrentSize += Size;
       
       if ((*I)->Merge(Gen,Progress) == false)
@@ -912,13 +954,15 @@ static bool BuildCache(pkgCacheGenerator &Gen,
 
    if (Gen.HasFileDeps() == true)
    {
-      Progress.Done();
+      if (Progress != NULL)
+        Progress->Done();
       TotalSize = ComputeSize(Start, End);
       CurrentSize = 0;
       for (I = Start; I != End; I++)
       {
         unsigned long Size = (*I)->Size();
-        Progress.OverallProgress(CurrentSize,TotalSize,Size,_("Collecting File Provides"));
+        if (Progress != NULL)
+           Progress->OverallProgress(CurrentSize,TotalSize,Size,_("Collecting File Provides"));
         CurrentSize += Size;
         if ((*I)->MergeFileProvides(Gen,Progress) == false)
            return false;
@@ -928,7 +972,7 @@ static bool BuildCache(pkgCacheGenerator &Gen,
    return true;
 }
                                                                        /*}}}*/
-// MakeStatusCache - Construct the status cache                                /*{{{*/
+// CacheGenerator::MakeStatusCache - Construct the status cache                /*{{{*/
 // ---------------------------------------------------------------------
 /* This makes sure that the status cache (the cache that has all 
    index files from the sources list and all local ones) is ready
@@ -936,10 +980,14 @@ static bool BuildCache(pkgCacheGenerator &Gen,
    the cache will be stored there. This is pretty much mandetory if you
    are using AllowMem. AllowMem lets the function be run as non-root
    where it builds the cache 'fast' into a memory buffer. */
-bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
+__deprecated bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
+                       MMap **OutMap, bool AllowMem)
+   { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); }
+bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
                        MMap **OutMap,bool AllowMem)
 {
-   unsigned long MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);
+   bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
+   unsigned long const MapSize = _config->FindI("APT::Cache-Limit",24*1024*1024);
    
    vector<pkgIndexFile *> Files;
    for (vector<metaIndex *>::const_iterator i = List.begin();
@@ -953,14 +1001,27 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
          Files.push_back (*j);
    }
    
-   unsigned long EndOfSource = Files.size();
+   unsigned long const EndOfSource = Files.size();
    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    // Decide if we can write to the files..
-   string CacheFile = _config->FindFile("Dir::Cache::pkgcache");
-   string SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
-   
+   string const CacheFile = _config->FindFile("Dir::Cache::pkgcache");
+   string const SrcCacheFile = _config->FindFile("Dir::Cache::srcpkgcache");
+
+   // ensure the cache directory exists
+   if (CacheFile.empty() == false || SrcCacheFile.empty() == false)
+   {
+      string dir = _config->FindDir("Dir::Cache");
+      size_t const len = dir.size();
+      if (len > 5 && dir.find("/apt/", len - 6, 5) == len - 5)
+        dir = dir.substr(0, len - 5);
+      if (CacheFile.empty() == false)
+        CreateDirectory(dir, flNotFile(CacheFile));
+      if (SrcCacheFile.empty() == false)
+        CreateDirectory(dir, flNotFile(SrcCacheFile));
+   }
+
    // Decide if we can write to the cache
    bool Writeable = false;
    if (CacheFile.empty() == false)
@@ -968,18 +1029,26 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    else
       if (SrcCacheFile.empty() == false)
         Writeable = access(flNotFile(SrcCacheFile).c_str(),W_OK) == 0;
-   
+   if (Debug == true)
+      std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;
+
    if (Writeable == false && AllowMem == false && CacheFile.empty() == false)
       return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
-   
-   Progress.OverallProgress(0,1,1,_("Reading package lists"));
-   
+
+   if (Progress != NULL)
+      Progress->OverallProgress(0,1,1,_("Reading package lists"));
+
    // Cache is OK, Fin.
    if (CheckValidity(CacheFile,Files.begin(),Files.end(),OutMap) == true)
    {
-      Progress.OverallProgress(1,1,1,_("Reading package lists"));
+      if (Progress != NULL)
+        Progress->OverallProgress(1,1,1,_("Reading package lists"));
+      if (Debug == true)
+        std::clog << "pkgcache.bin is valid - no need to build anything" << std::endl;
       return true;
    }
+   else if (Debug == true)
+        std::clog << "pkgcache.bin is NOT valid" << std::endl;
    
    /* At this point we know we need to reconstruct the package cache,
       begin. */
@@ -993,11 +1062,15 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       Map = new DynamicMMap(*CacheF,MMap::Public,MapSize);
       if (_error->PendingError() == true)
         return false;
+      if (Debug == true)
+        std::clog << "Open filebased MMap" << std::endl;
    }
    else
    {
       // Just build it in memory..
       Map = new DynamicMMap(0,MapSize);
+      if (Debug == true)
+        std::clog << "Open memory Map (not filebased)" << std::endl;
    }
    
    // Lets try the source cache.
@@ -1006,18 +1079,20 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    if (CheckValidity(SrcCacheFile,Files.begin(),
                     Files.begin()+EndOfSource) == true)
    {
+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is valid - populate MMap with it." << std::endl;
       // Preload the map with the source cache
       FileFd SCacheF(SrcCacheFile,FileFd::ReadOnly);
-      unsigned long alloc = Map->RawAllocate(SCacheF.Size());
+      unsigned long const alloc = Map->RawAllocate(SCacheF.Size());
       if ((alloc == 0 && _error->PendingError())
                || SCacheF.Read((unsigned char *)Map->Data() + alloc,
                                SCacheF.Size()) == false)
         return false;
 
       TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());
-      
+
       // Build the status cache
-      pkgCacheGenerator Gen(Map.Get(),&Progress);
+      pkgCacheGenerator Gen(Map.Get(),Progress);
       if (_error->PendingError() == true)
         return false;
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
@@ -1029,10 +1104,12 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    }
    else
    {
+      if (Debug == true)
+        std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;
       TotalSize = ComputeSize(Files.begin(),Files.end());
       
       // Build the source cache
-      pkgCacheGenerator Gen(Map.Get(),&Progress);
+      pkgCacheGenerator Gen(Map.Get(),Progress);
       if (_error->PendingError() == true)
         return false;
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
@@ -1070,6 +1147,8 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
       // FIXME: move me to a better place
       Gen.FinishCache(Progress);
    }
+   if (Debug == true)
+      std::clog << "Caches are ready for shipping" << std::endl;
 
    if (_error->PendingError() == true)
       return false;
@@ -1089,10 +1168,12 @@ bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
    return true;
 }
                                                                        /*}}}*/
-// MakeOnlyStatusCache - Build a cache with just the status files      /*{{{*/
+// CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
 // ---------------------------------------------------------------------
 /* */
-bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
+__deprecated bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
+   { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
+bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
 {
    unsigned long MapSize = _config->FindI("APT::Cache-Limit",20*1024*1024);
    vector<pkgIndexFile *> Files;
@@ -1107,8 +1188,9 @@ bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
    TotalSize = ComputeSize(Files.begin()+EndOfSource,Files.end());
    
    // Build the status cache
-   Progress.OverallProgress(0,1,1,_("Reading package lists"));
-   pkgCacheGenerator Gen(Map.Get(),&Progress);
+   if (Progress != NULL)
+      Progress->OverallProgress(0,1,1,_("Reading package lists"));
+   pkgCacheGenerator Gen(Map.Get(),Progress);
    if (_error->PendingError() == true)
       return false;
    if (BuildCache(Gen,Progress,CurrentSize,TotalSize,