Consider md5sum no longer a usable hash

[apt.git] / apt-pkg / pkgcachegen.cc

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index cf845b0fb3abf6bb96aca187fbb522b1e294ad36..802af172cc8143c75fc01f21050418dff8e574d8 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -18,8 +18,6 @@
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/configuration.h>
 #include <apt-pkg/progress.h>
 #include <apt-pkg/sourcelist.h>
 #include <apt-pkg/configuration.h>

-#include <apt-pkg/strutl.h>
-#include <apt-pkg/sptr.h>

 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/macros.h>
 #include <apt-pkg/metaindex.h>
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/macros.h>
 #include <apt-pkg/metaindex.h>


@@ -42,7 +40,8 @@
 #include <unistd.h>
 
 #include <apti18n.h>
 #include <unistd.h>
 
 #include <apti18n.h>

-                                                                       /*}}}*/
+
+template<class T> using Dynamic = pkgCacheGenerator::Dynamic<T>;                                                       /*}}}*/

 typedef std::vector<pkgIndexFile *>::iterator FileIterator;
 template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap;
 
 typedef std::vector<pkgIndexFile *>::iterator FileIterator;
 template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap;
 


@@ -56,7 +55,7 @@ using std::string;
 /* We set the dirty flag and make sure that is written to the disk */
 pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
                    Map(*pMap), Cache(pMap,false), Progress(Prog),
 /* We set the dirty flag and make sure that is written to the disk */
 pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
                    Map(*pMap), Cache(pMap,false), Progress(Prog),

-                    CurrentRlsFile(NULL), CurrentFile(NULL), FoundFileDeps(0), d(NULL)
+                    CurrentRlsFile(NULL), CurrentFile(NULL), d(NULL)

 {
    if (_error->PendingError() == true)
       return;
 {
    if (_error->PendingError() == true)
       return;


@@ -229,22 +228,6 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         continue;
       }
 
         continue;
       }
 

-      if (Arch.empty() == true)
-      {
-        // use the pseudo arch 'none' for arch-less packages
-        Arch = "none";
-        /* We might built a SingleArchCache here, which we don't want to blow up
-           just for these :none packages to a proper MultiArchCache, so just ensure
-           that we have always a native package structure first for SingleArch */
-        pkgCache::PkgIterator NP;
-        Dynamic<pkgCache::PkgIterator> DynPkg(NP);
-        if (NewPackage(NP, PackageName, _config->Find("APT::Architecture")) == false)
-        // TRANSLATOR: The first placeholder is a package name,
-        // the other two should be copied verbatim as they include debug info
-        return _error->Error(_("Error occurred while processing %s (%s%d)"),
-                             PackageName.c_str(), "NewPackage", 0);
-      }
-

       // Get a pointer to the package structure
       pkgCache::PkgIterator Pkg;
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
       // Get a pointer to the package structure
       pkgCache::PkgIterator Pkg;
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);


@@ -267,10 +250,7 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       }
 
       if (OutVer != 0)
       }
 
       if (OutVer != 0)

-      {
-        FoundFileDeps |= List.HasFileDeps();

         return true;
         return true;

-      }

    }
 
    if (Cache.HeaderP->PackageCount >= std::numeric_limits<map_id_t>::max())
    }
 
    if (Cache.HeaderP->PackageCount >= std::numeric_limits<map_id_t>::max())


@@ -286,7 +266,6 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       return _error->Error(_("Wow, you exceeded the number of dependencies "
                             "this APT is capable of."));
 
       return _error->Error(_("Wow, you exceeded the number of dependencies "
                             "this APT is capable of."));
 

-   FoundFileDeps |= List.HasFileDeps();

    return true;
 }
 // CacheGenerator::MergeListGroup                                      /*{{{*/
    return true;
 }
 // CacheGenerator::MergeListGroup                                      /*{{{*/


@@ -444,40 +423,6 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
               return _error->Error(_("Error occurred while processing %s (%s%d)"),
                                    Pkg.Name(), "AddImplicitDepends", 1);
       }
               return _error->Error(_("Error occurred while processing %s (%s%d)"),
                                    Pkg.Name(), "AddImplicitDepends", 1);
       }

-      /* :none packages are packages without an architecture. They are forbidden by
-        debian-policy, so usually they will only be in (old) dpkg status files -
-        and dpkg will complain about them - and are pretty rare. We therefore do
-        usually not create conflicts while the parent is created, but only if a :none
-        package (= the target) appears. This creates incorrect dependencies on :none
-        for architecture-specific dependencies on the package we copy from, but we
-        will ignore this bug as architecture-specific dependencies are only allowed
-        in jessie and until then the :none packages should be extinct (hopefully).
-        In other words: This should work long enough to allow graceful removal of
-        these packages, it is not supposed to allow users to keep using them … */
-      if (strcmp(Pkg.Arch(), "none") == 0)
-      {
-        pkgCache::PkgIterator M = Grp.FindPreferredPkg();
-        if (M.end() == false && Pkg != M)
-        {
-           pkgCache::DepIterator D = M.RevDependsList();
-           Dynamic<pkgCache::DepIterator> DynD(D);
-           for (; D.end() == false; ++D)
-           {
-              if ((D->Type != pkgCache::Dep::Conflicts &&
-                   D->Type != pkgCache::Dep::DpkgBreaks &&
-                   D->Type != pkgCache::Dep::Replaces) ||
-                  D.ParentPkg().Group() == Grp)
-                 continue;
-
-              map_pointer_t *OldDepLast = NULL;
-              pkgCache::VerIterator ConVersion = D.ParentVer();
-              Dynamic<pkgCache::VerIterator> DynV(ConVersion);
-              // duplicate the Conflicts/Breaks/Replaces for :none arch
-              NewDepends(Pkg, ConVersion, D->Version,
-                    D->CompareOp, D->Type, OldDepLast);
-           }
-        }
-      }

    }
    if (unlikely(AddImplicitDepends(Grp, Pkg, Ver) == false))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
    }
    if (unlikely(AddImplicitDepends(Grp, Pkg, Ver) == false))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),


@@ -547,57 +492,6 @@ bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterato
 }
                                                                        /*}}}*/
                                                                        /*}}}*/
 }
                                                                        /*}}}*/
                                                                        /*}}}*/

-// CacheGenerator::MergeFileProvides - Merge file provides             /*{{{*/
-// ---------------------------------------------------------------------
-/* If we found any file depends while parsing the main list we need to 
-   resolve them. Since it is undesired to load the entire list of files
-   into the cache as virtual packages we do a two stage effort. MergeList
-   identifies the file depends and this creates Provdies for them by
-   re-parsing all the indexs. */
-bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
-{
-   List.Owner = this;
-   
-   unsigned int Counter = 0;
-   while (List.Step() == true)
-   {
-      string PackageName = List.Package();
-      if (PackageName.empty() == true)
-        return false;
-      string Version = List.Version();
-      if (Version.empty() == true)
-        continue;
-      
-      pkgCache::PkgIterator Pkg = Cache.FindPkg(PackageName);
-      Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
-      if (Pkg.end() == true)
-        return _error->Error(_("Error occurred while processing %s (%s%d)"),
-                               PackageName.c_str(), "FindPkg", 1);
-      Counter++;
-      if (Counter % 100 == 0 && Progress != 0)
-        Progress->Progress(List.Offset());
-
-      unsigned short Hash = List.VersionHash();
-      pkgCache::VerIterator Ver = Pkg.VersionList();
-      Dynamic<pkgCache::VerIterator> DynVer(Ver);
-      for (; Ver.end() == false; ++Ver)
-      {
-        if (List.SameVersion(Hash, Ver) == true && Version == Ver.VerStr())
-        {
-           if (List.CollectFileProvides(Cache,Ver) == false)
-              return _error->Error(_("Error occurred while processing %s (%s%d)"),
-                                   PackageName.c_str(), "CollectFileProvides", 1);
-           break;
-        }
-      }
-      
-      if (Ver.end() == true)
-        _error->Warning(_("Package %s %s was not found while processing file dependencies"),PackageName.c_str(),Version.c_str());
-   }
-
-   return true;
-}
-                                                                       /*}}}*/

 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */
 // CacheGenerator::NewGroup - Add a new group                          /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a new group structure and adds it to the hash table */


@@ -678,21 +572,31 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
       if (APT::Configuration::checkArchitecture(Pkg.Arch()) == true)
       {
         pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false); // native or any foreign pkg will do
       if (APT::Configuration::checkArchitecture(Pkg.Arch()) == true)
       {
         pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false); // native or any foreign pkg will do

-        if (M.end() == false)
-           for (pkgCache::PrvIterator Prv = M.ProvidesList(); Prv.end() == false; ++Prv)
+        if (M.end() == false) {
+           pkgCache::PrvIterator Prv;
+           Dynamic<pkgCache::PrvIterator> DynPrv(Prv);
+           for (Prv = M.ProvidesList(); Prv.end() == false; ++Prv)

            {
               if ((Prv->Flags & pkgCache::Flag::ArchSpecific) != 0)
                  continue;
               pkgCache::VerIterator Ver = Prv.OwnerVer();
            {
               if ((Prv->Flags & pkgCache::Flag::ArchSpecific) != 0)
                  continue;
               pkgCache::VerIterator Ver = Prv.OwnerVer();

+              Dynamic<pkgCache::VerIterator> DynVer(Ver);

               if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed ||
                   ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign &&
                        (Prv->Flags & pkgCache::Flag::MultiArchImplicit) == 0))
                  if (NewProvides(Ver, Pkg, Prv->ProvideVersion, Prv->Flags) == false)
                     return false;
            }
               if ((Ver->MultiArch & pkgCache::Version::Allowed) == pkgCache::Version::Allowed ||
                   ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign &&
                        (Prv->Flags & pkgCache::Flag::MultiArchImplicit) == 0))
                  if (NewProvides(Ver, Pkg, Prv->ProvideVersion, Prv->Flags) == false)
                     return false;
            }

+        }
+

 
 

-        for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false;  P = Grp.NextPkg(P))
-           for (pkgCache::VerIterator Ver = P.VersionList(); Ver.end() == false; ++Ver)
+        pkgCache::PkgIterator P;
+        pkgCache::VerIterator Ver;
+        Dynamic<pkgCache::PkgIterator> DynP(P);
+        Dynamic<pkgCache::VerIterator> DynVer(Ver);
+
+        for (P = Grp.PackageList(); P.end() == false;  P = Grp.NextPkg(P))
+           for (Ver = P.VersionList(); Ver.end() == false; ++Ver)

               if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
                  if (NewProvides(Ver, Pkg, Ver->VerStr, pkgCache::Flag::MultiArchImplicit) == false)
                     return false;
               if ((Ver->MultiArch & pkgCache::Version::Foreign) == pkgCache::Version::Foreign)
                  if (NewProvides(Ver, Pkg, Ver->VerStr, pkgCache::Flag::MultiArchImplicit) == false)
                     return false;


@@ -700,8 +604,10 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
       // and negative dependencies, don't forget negative dependencies
       {
         pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false);
       // and negative dependencies, don't forget negative dependencies
       {
         pkgCache::PkgIterator const M = Grp.FindPreferredPkg(false);

-        if (M.end() == false)
-           for (pkgCache::DepIterator Dep = M.RevDependsList(); Dep.end() == false; ++Dep)
+        if (M.end() == false) {
+           pkgCache::DepIterator Dep;
+           Dynamic<pkgCache::DepIterator> DynDep(Dep);
+           for (Dep = M.RevDependsList(); Dep.end() == false; ++Dep)

            {
               if ((Dep->CompareOp & (pkgCache::Dep::ArchSpecific | pkgCache::Dep::MultiArchImplicit)) != 0)
                  continue;
            {
               if ((Dep->CompareOp & (pkgCache::Dep::ArchSpecific | pkgCache::Dep::MultiArchImplicit)) != 0)
                  continue;


@@ -709,10 +615,12 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
                     Dep->Type != pkgCache::Dep::Replaces)
                  continue;
               pkgCache::VerIterator Ver = Dep.ParentVer();
                     Dep->Type != pkgCache::Dep::Replaces)
                  continue;
               pkgCache::VerIterator Ver = Dep.ParentVer();

+              Dynamic<pkgCache::VerIterator> DynVer(Ver);

               map_pointer_t * unused = NULL;
               if (NewDepends(Pkg, Ver, Dep->Version, Dep->CompareOp, Dep->Type, unused) == false)
                  return false;
            }
               map_pointer_t * unused = NULL;
               if (NewDepends(Pkg, Ver, Dep->Version, Dep->CompareOp, Dep->Type, unused) == false)
                  return false;
            }

+        }

       }
 
       // this package is the new last package
       }
 
       // this package is the new last package


@@ -1063,10 +971,6 @@ bool pkgCacheListParser::NewDepends(pkgCache::VerIterator &Ver,
    if (unlikely(Owner->NewGroup(Grp, PackageName) == false))
       return false;
 
    if (unlikely(Owner->NewGroup(Grp, PackageName) == false))
       return false;
 

-   // Is it a file dependency?
-   if (unlikely(PackageName[0] == '/'))
-      FoundFileDeps = true;
-

    map_stringitem_t idxVersion = 0;
    if (Version.empty() == false)
    {
    map_stringitem_t idxVersion = 0;
    if (Version.empty() == false)
    {


@@ -1181,7 +1085,9 @@ bool pkgCacheGenerator::NewProvides(pkgCache::VerIterator &Ver,
 bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
                                string const &Version, uint8_t const Flags) {
    pkgCache &Cache = Owner->Cache;
 bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string const &Package,
                                string const &Version, uint8_t const Flags) {
    pkgCache &Cache = Owner->Cache;

-   pkgCache::GrpIterator const Grp = Cache.FindGrp(Package);
+   pkgCache::GrpIterator Grp = Cache.FindGrp(Package);
+   Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
+

    if (Grp.end() == true)
       return NewProvides(Ver, Package, Cache.NativeArch(), Version, Flags);
    else
    if (Grp.end() == true)
       return NewProvides(Ver, Package, Cache.NativeArch(), Version, Flags);
    else


@@ -1195,8 +1101,11 @@ bool pkgCacheListParser::NewProvidesAllArch(pkgCache::VerIterator &Ver, string c
 
       bool const isImplicit = (Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit;
       bool const isArchSpecific = (Flags & pkgCache::Flag::ArchSpecific) == pkgCache::Flag::ArchSpecific;
 
       bool const isImplicit = (Flags & pkgCache::Flag::MultiArchImplicit) == pkgCache::Flag::MultiArchImplicit;
       bool const isArchSpecific = (Flags & pkgCache::Flag::ArchSpecific) == pkgCache::Flag::ArchSpecific;

-      pkgCache::PkgIterator const OwnerPkg = Ver.ParentPkg();
-      for (pkgCache::PkgIterator Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+      pkgCache::PkgIterator OwnerPkg = Ver.ParentPkg();
+      Dynamic<pkgCache::PkgIterator> DynOwnerPkg(OwnerPkg);
+      pkgCache::PkgIterator Pkg;
+      Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
+      for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))

       {
         if (isImplicit && OwnerPkg == Pkg)
            continue;
       {
         if (isImplicit && OwnerPkg == Pkg)
            continue;


@@ -1358,8 +1267,8 @@ static bool CheckValidity(const string &CacheFile,
 
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);
 
    // Map it
    FileFd CacheF(CacheFile,FileFd::ReadOnly);

-   SPtr<MMap> Map = new MMap(CacheF,0);
-   pkgCache Cache(Map);
+   std::unique_ptr<MMap> Map(new MMap(CacheF,0));
+   pkgCache Cache(Map.get());

    if (_error->PendingError() == true || Map->Size() == 0)
    {
       if (Debug == true)
    if (_error->PendingError() == true || Map->Size() == 0)
    {
       if (Debug == true)


@@ -1368,8 +1277,8 @@ static bool CheckValidity(const string &CacheFile,
       return false;
    }
 
       return false;
    }
 

-   SPtrArray<bool> RlsVisited = new bool[Cache.HeaderP->ReleaseFileCount];
-   memset(RlsVisited,0,sizeof(*RlsVisited)*Cache.HeaderP->ReleaseFileCount);
+   std::unique_ptr<bool[]> RlsVisited(new bool[Cache.HeaderP->ReleaseFileCount]);
+   memset(RlsVisited.get(),0,sizeof(RlsVisited[0])*Cache.HeaderP->ReleaseFileCount);

    std::vector<pkgIndexFile *> Files;
    for (pkgSourceList::const_iterator i = List.begin(); i != List.end(); ++i)
    {
    std::vector<pkgIndexFile *> Files;
    for (pkgSourceList::const_iterator i = List.begin(); i != List.end(); ++i)
    {


@@ -1403,8 +1312,8 @@ static bool CheckValidity(const string &CacheFile,
 
    /* Now we check every index file, see if it is in the cache,
       verify the IMS data and check that it is on the disk too.. */
 
    /* Now we check every index file, see if it is in the cache,
       verify the IMS data and check that it is on the disk too.. */

-   SPtrArray<bool> Visited = new bool[Cache.HeaderP->PackageFileCount];
-   memset(Visited,0,sizeof(*Visited)*Cache.HeaderP->PackageFileCount);
+   std::unique_ptr<bool[]> Visited(new bool[Cache.HeaderP->PackageFileCount]);
+   memset(Visited.get(),0,sizeof(Visited[0])*Cache.HeaderP->PackageFileCount);

    for (std::vector<pkgIndexFile *>::const_reverse_iterator PkgFile = Files.rbegin(); PkgFile != Files.rend(); ++PkgFile)
    {
       if (Debug == true)
    for (std::vector<pkgIndexFile *>::const_reverse_iterator PkgFile = Files.rbegin(); PkgFile != Files.rend(); ++PkgFile)
    {
       if (Debug == true)


@@ -1450,7 +1359,7 @@ static bool CheckValidity(const string &CacheFile,
    }
    
    if (OutMap != 0)
    }
    
    if (OutMap != 0)

-      *OutMap = Map.UnGuard();
+      *OutMap = Map.release();

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -1489,13 +1398,9 @@ static bool BuildCache(pkgCacheGenerator &Gen,
                       FileIterator const Start, FileIterator const End)
 {
    std::vector<pkgIndexFile *> Files;
                       FileIterator const Start, FileIterator const End)
 {
    std::vector<pkgIndexFile *> Files;

-   bool const HasFileDeps = Gen.HasFileDeps();

    bool mergeFailure = false;
 
    auto const indexFileMerge = [&](pkgIndexFile * const I) {
    bool mergeFailure = false;
 
    auto const indexFileMerge = [&](pkgIndexFile * const I) {

-      if (HasFileDeps)
-        Files.push_back(I);
-

       if (I->HasPackages() == false || mergeFailure)
         return;
 
       if (I->HasPackages() == false || mergeFailure)
         return;
 


@@ -1547,24 +1452,6 @@ static bool BuildCache(pkgCacheGenerator &Gen,
       if (mergeFailure)
         return false;
    }
       if (mergeFailure)
         return false;
    }

-
-   if (HasFileDeps == true)
-   {
-      if (Progress != NULL)
-        Progress->Done();
-      TotalSize = ComputeSize(List, Start, End);
-      CurrentSize = 0;
-      for (std::vector<pkgIndexFile *>::const_iterator I = Files.begin(); I != Files.end(); ++I)
-      {
-        map_filesize_t Size = (*I)->Size();
-        if (Progress != NULL)
-           Progress->OverallProgress(CurrentSize,TotalSize,Size,_("Collecting File Provides"));
-        CurrentSize += Size;
-        if ((*I)->MergeFileProvides(Gen,Progress) == false)
-           return false;
-      }
-   }
-

    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/


@@ -1613,24 +1500,25 @@ static bool writeBackMMapToFile(pkgCacheGenerator * const Gen, DynamicMMap * con
    return true;
 }
 static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen,
    return true;
 }
 static bool loadBackMMapFromFile(std::unique_ptr<pkgCacheGenerator> &Gen,

-      SPtr<DynamicMMap> &Map, OpProgress * const Progress, std::string const &FileName)
+      std::unique_ptr<DynamicMMap> &Map, OpProgress * const Progress, std::string const &FileName)

 {
 {

-   Map = CreateDynamicMMap(NULL, 0);
+   Map.reset(CreateDynamicMMap(NULL, 0));

    FileFd CacheF(FileName, FileFd::ReadOnly);
    map_pointer_t const alloc = Map->RawAllocate(CacheF.Size());
    if ((alloc == 0 && _error->PendingError())
         || CacheF.Read((unsigned char *)Map->Data() + alloc,
            CacheF.Size()) == false)
       return false;
    FileFd CacheF(FileName, FileFd::ReadOnly);
    map_pointer_t const alloc = Map->RawAllocate(CacheF.Size());
    if ((alloc == 0 && _error->PendingError())
         || CacheF.Read((unsigned char *)Map->Data() + alloc,
            CacheF.Size()) == false)
       return false;

-   Gen.reset(new pkgCacheGenerator(Map.Get(),Progress));
+   Gen.reset(new pkgCacheGenerator(Map.get(),Progress));

    return true;
 }
 APT_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,
    return true;
 }
 APT_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)
+                       MMap **OutMap,bool)

 {
 {

+   // FIXME: deprecate the ignored AllowMem parameter

    bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
 
    std::vector<pkgIndexFile *> Files;
    bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
 
    std::vector<pkgIndexFile *> Files;


@@ -1695,20 +1583,10 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
 
       if (Debug == true)
         std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;
 
       if (Debug == true)
         std::clog << "Do we have write-access to the cache files? " << (Writeable ? "YES" : "NO") << std::endl;

-
-      if (Writeable == false && AllowMem == false)
-      {
-        if (CacheFile.empty() == false)
-           return _error->Error(_("Unable to write to %s"),flNotFile(CacheFile).c_str());
-        else if (SrcCacheFile.empty() == false)
-           return _error->Error(_("Unable to write to %s"),flNotFile(SrcCacheFile).c_str());
-        else
-           return _error->Error("Unable to create caches as file usage is disabled, but memory not allowed either!");
-      }

    }
 
    // At this point we know we need to construct something, so get storage ready
    }
 
    // At this point we know we need to construct something, so get storage ready

-   SPtr<DynamicMMap> Map = CreateDynamicMMap(NULL, 0);
+   std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0));

    if (Debug == true)
       std::clog << "Open memory Map (not filebased)" << std::endl;
 
    if (Debug == true)
       std::clog << "Open memory Map (not filebased)" << std::endl;
 


@@ -1729,7 +1607,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
    {
       if (Debug == true)
         std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;
    {
       if (Debug == true)
         std::clog << "srcpkgcache.bin is NOT valid - rebuild" << std::endl;

-      Gen.reset(new pkgCacheGenerator(Map.Get(),Progress));
+      Gen.reset(new pkgCacheGenerator(Map.get(),Progress));

 
       TotalSize += ComputeSize(&List, Files.begin(),Files.end());
       if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List,
 
       TotalSize += ComputeSize(&List, Files.begin(),Files.end());
       if (BuildCache(*Gen, Progress, CurrentSize, TotalSize, &List,


@@ -1737,7 +1615,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
         return false;
 
       if (Writeable == true && SrcCacheFile.empty() == false)
         return false;
 
       if (Writeable == true && SrcCacheFile.empty() == false)

-        if (writeBackMMapToFile(Gen.get(), Map.Get(), SrcCacheFile) == false)
+        if (writeBackMMapToFile(Gen.get(), Map.get(), SrcCacheFile) == false)

            return false;
    }
 
            return false;
    }
 


@@ -1750,7 +1628,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
         return false;
 
       if (Writeable == true && CacheFile.empty() == false)
         return false;
 
       if (Writeable == true && CacheFile.empty() == false)

-        if (writeBackMMapToFile(Gen.get(), Map.Get(), CacheFile) == false)
+        if (writeBackMMapToFile(Gen.get(), Map.get(), CacheFile) == false)

            return false;
    }
 
            return false;
    }
 


@@ -1774,7 +1652,7 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
    }
 
    if (OutMap != nullptr)
    }
 
    if (OutMap != nullptr)

-      *OutMap = Map.UnGuard();
+      *OutMap = Map.release();

 
    if (Debug == true)
       std::clog << "Everything is ready for shipping" << std::endl;
 
    if (Debug == true)
       std::clog << "Everything is ready for shipping" << std::endl;


@@ -1792,7 +1670,7 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
    if (_system->AddStatusFiles(Files) == false)
       return false;
 
    if (_system->AddStatusFiles(Files) == false)
       return false;
 

-   SPtr<DynamicMMap> Map = CreateDynamicMMap(NULL, 0);
+   std::unique_ptr<DynamicMMap> Map(CreateDynamicMMap(NULL, 0));

    map_filesize_t CurrentSize = 0;
    map_filesize_t TotalSize = 0;
    
    map_filesize_t CurrentSize = 0;
    map_filesize_t TotalSize = 0;
    


@@ -1801,7 +1679,7 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
    // Build the status cache
    if (Progress != NULL)
       Progress->OverallProgress(0,1,1,_("Reading package lists"));
    // Build the status cache
    if (Progress != NULL)
       Progress->OverallProgress(0,1,1,_("Reading package lists"));

-   pkgCacheGenerator Gen(Map.Get(),Progress);
+   pkgCacheGenerator Gen(Map.get(),Progress);

    if (_error->PendingError() == true)
       return false;
    if (BuildCache(Gen,Progress,CurrentSize,TotalSize, NULL,
    if (_error->PendingError() == true)
       return false;
    if (BuildCache(Gen,Progress,CurrentSize,TotalSize, NULL,


@@ -1810,7 +1688,7 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
 
    if (_error->PendingError() == true)
       return false;
 
    if (_error->PendingError() == true)
       return false;

-   *OutMap = Map.UnGuard();
+   *OutMap = Map.release();

    
    return true;
 }
    
    return true;
 }


@@ -1828,12 +1706,6 @@ static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
    return false;
 }
                                                                        /*}}}*/
    return false;
 }
                                                                        /*}}}*/

-// CacheGenerator::FinishCache                                         /*{{{*/
-bool pkgCacheGenerator::FinishCache(OpProgress * /*Progress*/)
-{
-   return true;
-}
-                                                                       /*}}}*/

 
 

-pkgCacheListParser::pkgCacheListParser() : Owner(NULL), OldDepLast(NULL), FoundFileDeps(false), d(NULL) {}
+pkgCacheListParser::pkgCacheListParser() : Owner(NULL), OldDepLast(NULL), d(NULL) {}

 pkgCacheListParser::~pkgCacheListParser() {}
 pkgCacheListParser::~pkgCacheListParser() {}