]> git.saurik.com Git - apt.git/blobdiff - apt-pkg/pkgcachegen.cc
projects / apt.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge remote-tracking branch 'upstream/debian/sid' into debian/experimental
[apt.git] / apt-pkg / pkgcachegen.cc
diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 8a7c1e979f6428aa9a550bdf907b08e9f2f09fa4..ac1cea0eb60f804d3d30235ed1f3d5a5f0246fab 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -10,7 +10,7 @@
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
    ##################################################################### */
                                                                        /*}}}*/
 // Include Files                                                       /*{{{*/
-#define APT_COMPATIBILITY 986
+#include <config.h>
 
 #include <apt-pkg/pkgcachegen.h>
 #include <apt-pkg/error.h>
 
 #include <apt-pkg/pkgcachegen.h>
 #include <apt-pkg/error.h>
@@ -18,26 +18,37 @@
 #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/aptconfiguration.h>
 #include <apt-pkg/strutl.h>
 #include <apt-pkg/sptr.h>
 #include <apt-pkg/pkgsystem.h>
 #include <apt-pkg/macros.h>
 #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>
-
-#include <apti18n.h>
-
+#include <apt-pkg/metaindex.h>
+#include <apt-pkg/fileutl.h>
+#include <apt-pkg/hashsum_template.h>
+#include <apt-pkg/indexfile.h>
+#include <apt-pkg/md5.h>
+#include <apt-pkg/mmap.h>
+#include <apt-pkg/pkgcache.h>
+#include <apt-pkg/cacheiterators.h>
+
+#include <stddef.h>
+#include <string.h>
+#include <iostream>
+#include <string>
 #include <vector>
 #include <vector>
-
 #include <sys/stat.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <unistd.h>
-#include <errno.h>
-#include <stdio.h>
+
+#include <apti18n.h>
                                                                        /*}}}*/
                                                                        /*}}}*/
-typedef vector<pkgIndexFile *>::iterator FileIterator;
+typedef std::vector<pkgIndexFile *>::iterator FileIterator;
 template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap;
 
 template <typename Iter> std::vector<Iter*> pkgCacheGenerator::Dynamic<Iter>::toReMap;
 
+static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
+                           MD5SumValue const &CurMd5, std::string const &CurLang);
+
+using std::string;
+
 // CacheGenerator::pkgCacheGenerator - Constructor                     /*{{{*/
 // ---------------------------------------------------------------------
 /* We set the dirty flag and make sure that is written to the disk */
 // CacheGenerator::pkgCacheGenerator - Constructor                     /*{{{*/
 // ---------------------------------------------------------------------
 /* We set the dirty flag and make sure that is written to the disk */
@@ -63,11 +74,31 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
       // Starting header
       *Cache.HeaderP = pkgCache::Header();
       map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
       // Starting header
       *Cache.HeaderP = pkgCache::Header();
       map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
+      if (unlikely(idxVerSysName == 0))
+        return;
       Cache.HeaderP->VerSysName = idxVerSysName;
       Cache.HeaderP->VerSysName = idxVerSysName;
-      map_ptrloc const idxArchitecture = WriteStringInMap(_config->Find("APT::Architecture"));
-      Cache.HeaderP->Architecture = idxArchitecture;
-      if (unlikely(idxVerSysName == 0 || idxArchitecture == 0))
+      // this pointer is set in ReMap, but we need it now for WriteUniqString
+      Cache.StringItemP = (pkgCache::StringItem *)Map.Data();
+      map_ptrloc const idxArchitecture = WriteUniqString(_config->Find("APT::Architecture"));
+      if (unlikely(idxArchitecture == 0))
         return;
         return;
+      Cache.HeaderP->Architecture = idxArchitecture;
+
+      std::vector<std::string> archs = APT::Configuration::getArchitectures();
+      if (archs.size() > 1)
+      {
+        std::vector<std::string>::const_iterator a = archs.begin();
+        std::string list = *a;
+        for (++a; a != archs.end(); ++a)
+           list.append(",").append(*a);
+        map_ptrloc const idxArchitectures = WriteStringInMap(list);
+        if (unlikely(idxArchitectures == 0))
+           return;
+        Cache.HeaderP->Architectures = idxArchitectures;
+      }
+      else
+        Cache.HeaderP->Architectures = idxArchitecture;
+
       Cache.ReMap();
    }
    else
       Cache.ReMap();
    }
    else
@@ -98,6 +129,7 @@ pkgCacheGenerator::~pkgCacheGenerator()
       return;
    
    Cache.HeaderP->Dirty = false;
       return;
    
    Cache.HeaderP->Dirty = false;
+   Cache.HeaderP->CacheFileSize = Map.Size();
    Map.Sync(0,sizeof(pkgCache::Header));
 }
                                                                        /*}}}*/
    Map.Sync(0,sizeof(pkgCache::Header));
 }
                                                                        /*}}}*/
@@ -110,11 +142,11 @@ void pkgCacheGenerator::ReMap(void const * const oldMap, void const * const newM
 
    Cache.ReMap(false);
 
 
    Cache.ReMap(false);
 
-   CurrentFile += (pkgCache::PackageFile*) newMap - (pkgCache::PackageFile*) oldMap;
+   CurrentFile += (pkgCache::PackageFile const * const) newMap - (pkgCache::PackageFile const * const) oldMap;
 
    for (size_t i = 0; i < _count(UniqHash); ++i)
       if (UniqHash[i] != 0)
 
    for (size_t i = 0; i < _count(UniqHash); ++i)
       if (UniqHash[i] != 0)
-        UniqHash[i] += (pkgCache::StringItem*) newMap - (pkgCache::StringItem*) oldMap;
+        UniqHash[i] += (pkgCache::StringItem const * const) newMap - (pkgCache::StringItem const * const) oldMap;
 
    for (std::vector<pkgCache::GrpIterator*>::const_iterator i = Dynamic<pkgCache::GrpIterator>::toReMap.begin();
        i != Dynamic<pkgCache::GrpIterator>::toReMap.end(); ++i)
 
    for (std::vector<pkgCache::GrpIterator*>::const_iterator i = Dynamic<pkgCache::GrpIterator>::toReMap.begin();
        i != Dynamic<pkgCache::GrpIterator>::toReMap.end(); ++i)
@@ -181,82 +213,157 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       if (PackageName.empty() == true)
         return false;
 
       if (PackageName.empty() == true)
         return false;
 
-      string const Arch = List.Architecture();
- 
+      Counter++;
+      if (Counter % 100 == 0 && Progress != 0)
+        Progress->Progress(List.Offset());
+
+      string Arch = List.Architecture();
+      string const Version = List.Version();
+      if (Version.empty() == true && Arch.empty() == true)
+      {
+        // package descriptions
+        if (MergeListGroup(List, PackageName) == false)
+           return false;
+        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);
       if (NewPackage(Pkg, PackageName, Arch) == false)
       // Get a pointer to the package structure
       pkgCache::PkgIterator Pkg;
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
       if (NewPackage(Pkg, PackageName, Arch) == false)
-        return _error->Error(_("Error occurred while processing %s (NewPackage)"),PackageName.c_str());
-      Counter++;
-      if (Counter % 100 == 0 && Progress != 0)
-        Progress->Progress(List.Offset());
+        // 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", 1);
+
 
 
-      /* Get a pointer to the version structure. We know the list is sorted
-         so we use that fact in the search. Insertion of new versions is
-        done with correct sorting */
-      string Version = List.Version();
       if (Version.empty() == true)
       {
       if (Version.empty() == true)
       {
-        // we first process the package, then the descriptions
-        // (this has the bonus that we get MMap error when we run out
-        //  of MMap space)
-        pkgCache::VerIterator Ver(Cache);
-        Dynamic<pkgCache::VerIterator> DynVer(Ver);
-        if (List.UsePackage(Pkg, Ver) == false)
-           return _error->Error(_("Error occurred while processing %s (UsePackage1)"),
-                                PackageName.c_str());
-
-        // Find the right version to write the description
-        MD5SumValue CurMd5 = List.Description_md5();
-        Ver = Pkg.VersionList();
-
-        for (; Ver.end() == false; ++Ver)
-        {
-           pkgCache::DescIterator Desc = Ver.DescriptionList();
-           Dynamic<pkgCache::DescIterator> DynDesc(Desc);
-           map_ptrloc *LastDesc = &Ver->DescriptionList;
-           bool duplicate=false;
-
-           // don't add a new description if we have one for the given
-           // md5 && language
-           for ( ; Desc.end() == false; ++Desc)
-              if (MD5SumValue(Desc.md5()) == CurMd5 && 
-                  Desc.LanguageCode() == List.DescriptionLanguage())
-                 duplicate=true;
-           if(duplicate)
-              continue;
-           
-           for (Desc = Ver.DescriptionList();
-                Desc.end() == false;
-                LastDesc = &Desc->NextDesc, ++Desc)
-           {
-              if (MD5SumValue(Desc.md5()) == CurMd5) 
-               {
-                 // Add new description
-                 void const * const oldMap = Map.Data();
-                 map_ptrloc const descindex = NewDescription(Desc, List.DescriptionLanguage(), CurMd5, *LastDesc);
-                 if (oldMap != Map.Data())
-                    LastDesc += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
-                 *LastDesc = descindex;
-                 Desc->ParentPkg = Pkg.Index();
-                 
-                 if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
-                    return _error->Error(_("Error occurred while processing %s (NewFileDesc1)"),PackageName.c_str());
-                 break;
-              }
-           }
-        }
+        if (MergeListPackage(List, Pkg) == false)
+           return false;
+      }
+      else
+      {
+        if (MergeListVersion(List, Pkg, Version, OutVer) == false)
+           return false;
+      }
+
+      if (OutVer != 0)
+      {
+        FoundFileDeps |= List.HasFileDeps();
+        return true;
+      }
+   }
+
+   if (Cache.HeaderP->PackageCount >= (1ULL<<sizeof(Cache.PkgP->ID)*8)-1)
+      return _error->Error(_("Wow, you exceeded the number of package "
+                            "names this APT is capable of."));
+   if (Cache.HeaderP->VersionCount >= (1ULL<<(sizeof(Cache.VerP->ID)*8))-1)
+      return _error->Error(_("Wow, you exceeded the number of versions "
+                            "this APT is capable of."));
+   if (Cache.HeaderP->DescriptionCount >= (1ULL<<(sizeof(Cache.DescP->ID)*8))-1)
+      return _error->Error(_("Wow, you exceeded the number of descriptions "
+                            "this APT is capable of."));
+   if (Cache.HeaderP->DependsCount >= (1ULL<<(sizeof(Cache.DepP->ID)*8))-1ULL)
+      return _error->Error(_("Wow, you exceeded the number of dependencies "
+                            "this APT is capable of."));
+
+   FoundFileDeps |= List.HasFileDeps();
+   return true;
+}
+// CacheGenerator::MergeListGroup                                      /*{{{*/
+bool pkgCacheGenerator::MergeListGroup(ListParser &List, std::string const &GrpName)
+{
+   pkgCache::GrpIterator Grp = Cache.FindGrp(GrpName);
+   // a group has no data on it's own, only packages have it but these
+   // stanzas like this come from Translation- files to add descriptions,
+   // but without a version we don't need a description for it…
+   if (Grp.end() == true)
+      return true;
+   Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
 
 
+   pkgCache::PkgIterator Pkg;
+   Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
+   for (Pkg = Grp.PackageList(); Pkg.end() == false; Pkg = Grp.NextPkg(Pkg))
+      if (MergeListPackage(List, Pkg) == false)
+        return false;
+
+   return true;
+}
+                                                                       /*}}}*/
+// CacheGenerator::MergeListPackage                                    /*{{{*/
+bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator &Pkg)
+{
+   // we first process the package, then the descriptions
+   // (for deb this package processing is in fact a no-op)
+   pkgCache::VerIterator Ver(Cache);
+   Dynamic<pkgCache::VerIterator> DynVer(Ver);
+   if (List.UsePackage(Pkg, Ver) == false)
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "UsePackage", 1);
+
+   // Find the right version to write the description
+   MD5SumValue CurMd5 = List.Description_md5();
+   if (CurMd5.Value().empty() == true && List.Description("").empty() == true)
+      return true;
+   std::vector<std::string> availDesc = List.AvailableDescriptionLanguages();
+   for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
+   {
+      pkgCache::DescIterator VerDesc = Ver.DescriptionList();
+
+      // a version can only have one md5 describing it
+      if (VerDesc.end() == true || MD5SumValue(VerDesc.md5()) != CurMd5)
         continue;
         continue;
+
+      map_ptrloc md5idx = VerDesc->md5sum;
+      for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang)
+      {
+        // don't add a new description if we have one for the given
+        // md5 && language
+        if (IsDuplicateDescription(VerDesc, CurMd5, *CurLang) == true)
+           continue;
+
+        AddNewDescription(List, Ver, *CurLang, CurMd5, md5idx);
       }
 
       }
 
-      pkgCache::VerIterator Ver = Pkg.VersionList();
-      Dynamic<pkgCache::VerIterator> DynVer(Ver);
-      map_ptrloc *LastVer = &Pkg->VersionList;
-      void const * oldMap = Map.Data();
+      // we can stop here as all "same" versions will share the description
+      break;
+   }
+
+   return true;
+}
+                                                                       /*}}}*/
+// CacheGenerator::MergeListVersion                                    /*{{{*/
+bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator &Pkg,
+                                        std::string const &Version, pkgCache::VerIterator* &OutVer)
+{
+   pkgCache::VerIterator Ver = Pkg.VersionList();
+   Dynamic<pkgCache::VerIterator> DynVer(Ver);
+   map_ptrloc *LastVer = &Pkg->VersionList;
+   void const * oldMap = Map.Data();
+
+   unsigned short const Hash = List.VersionHash();
+   if (Ver.end() == false)
+   {
+      /* We know the list is sorted so we use that fact in the search.
+         Insertion of new versions is done with correct sorting */
       int Res = 1;
       int Res = 1;
-      unsigned long const Hash = List.VersionHash();
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
       for (; Ver.end() == false; LastVer = &Ver->NextVer, Ver++)
       {
         Res = Cache.VS->CmpVersion(Version,Ver.VerStr());
@@ -264,7 +371,7 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
         if (Res > 0)
            break;
         // Versionstrings are equal - is hash also equal?
         if (Res > 0)
            break;
         // Versionstrings are equal - is hash also equal?
-        if (Res == 0 && Ver->Hash == Hash)
+        if (Res == 0 && List.SameVersion(Hash, Ver) == true)
            break;
         // proceed with the next till we have either the right
         // or we found another version (which will be lower)
            break;
         // proceed with the next till we have either the right
         // or we found another version (which will be lower)
@@ -274,94 +381,170 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       if (Res == 0 && Ver.end() == false && Ver->Hash == Hash)
       {
         if (List.UsePackage(Pkg,Ver) == false)
       if (Res == 0 && Ver.end() == false && Ver->Hash == Hash)
       {
         if (List.UsePackage(Pkg,Ver) == false)
-           return _error->Error(_("Error occurred while processing %s (UsePackage2)"),
-                                PackageName.c_str());
+           return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                                Pkg.Name(), "UsePackage", 2);
 
         if (NewFileVer(Ver,List) == false)
 
         if (NewFileVer(Ver,List) == false)
-           return _error->Error(_("Error occurred while processing %s (NewFileVer1)"),
-                                PackageName.c_str());
-        
+           return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                                Pkg.Name(), "NewFileVer", 1);
+
         // Read only a single record and return
         if (OutVer != 0)
         {
            *OutVer = Ver;
         // Read only a single record and return
         if (OutVer != 0)
         {
            *OutVer = Ver;
-           FoundFileDeps |= List.HasFileDeps();
            return true;
         }
            return true;
         }
-        
-        continue;
+
+        return true;
       }
       }
+   }
 
 
-      // Add a new version
-      map_ptrloc const verindex = NewVersion(Ver,Version,*LastVer);
-      if (verindex == 0 && _error->PendingError())
-        return _error->Error(_("Error occurred while processing %s (NewVersion%d)"),
-                             PackageName.c_str(), 1);
-
-      if (oldMap != Map.Data())
-        LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
-      *LastVer = verindex;
-      Ver->ParentPkg = Pkg.Index();
-      Ver->Hash = Hash;
-
-      if (List.NewVersion(Ver) == false)
-        return _error->Error(_("Error occurred while processing %s (NewVersion%d)"),
-                             PackageName.c_str(), 2);
-
-      if (List.UsePackage(Pkg,Ver) == false)
-        return _error->Error(_("Error occurred while processing %s (UsePackage3)"),
-                             PackageName.c_str());
-      
-      if (NewFileVer(Ver,List) == false)
-        return _error->Error(_("Error occurred while processing %s (NewVersion%d)"),
-                             PackageName.c_str(), 3);
+   // Add a new version
+   map_ptrloc const verindex = NewVersion(Ver, Version, Pkg.Index(), Hash, *LastVer);
+   if (verindex == 0 && _error->PendingError())
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewVersion", 1);
 
 
-      // Read only a single record and return
-      if (OutVer != 0)
+   if (oldMap != Map.Data())
+        LastVer += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
+   *LastVer = verindex;
+
+   if (unlikely(List.NewVersion(Ver) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewVersion", 2);
+
+   if (unlikely(List.UsePackage(Pkg,Ver) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "UsePackage", 3);
+
+   if (unlikely(NewFileVer(Ver,List) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewFileVer", 2);
+
+   pkgCache::GrpIterator Grp = Pkg.Group();
+   Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
+
+   /* If it is the first version of this package we need to add implicit
+      Multi-Arch dependencies to all other package versions in the group now -
+      otherwise we just add them for this new version */
+   if (Pkg.VersionList()->NextVer == 0)
+   {
+      pkgCache::PkgIterator P = Grp.PackageList();
+      Dynamic<pkgCache::PkgIterator> DynP(P);
+      for (; P.end() != true; P = Grp.NextPkg(P))
       {
       {
-        *OutVer = Ver;
-        FoundFileDeps |= List.HasFileDeps();
-        return true;
-      }      
+        if (P->ID == Pkg->ID)
+           continue;
+        pkgCache::VerIterator V = P.VersionList();
+        Dynamic<pkgCache::VerIterator> DynV(V);
+        for (; V.end() != true; ++V)
+           if (unlikely(AddImplicitDepends(V, Pkg) == false))
+              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;
 
 
-      /* Record the Description data. Description data always exist in
-        Packages and Translation-* files. */
-      pkgCache::DescIterator Desc = Ver.DescriptionList();
-      Dynamic<pkgCache::DescIterator> DynDesc(Desc);
-      map_ptrloc *LastDesc = &Ver->DescriptionList;
-
-      // Skip to the end of description set
-      for (; Desc.end() == false; LastDesc = &Desc->NextDesc, Desc++);
-
-      // Add new description
-      oldMap = Map.Data();
-      map_ptrloc const descindex = NewDescription(Desc, List.DescriptionLanguage(), List.Description_md5(), *LastDesc);
-      if (oldMap != Map.Data())
-        LastDesc += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
-      *LastDesc = descindex;
-      Desc->ParentPkg = Pkg.Index();
-
-      if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
-        return _error->Error(_("Error occurred while processing %s (NewFileDesc2)"),PackageName.c_str());
+              map_ptrloc *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)"),
+                          Pkg.Name(), "AddImplicitDepends", 2);
 
 
-   FoundFileDeps |= List.HasFileDeps();
+   // Read only a single record and return
+   if (OutVer != 0)
+   {
+      *OutVer = Ver;
+      return true;
+   }
+
+   /* Record the Description(s) based on their master md5sum */
+   MD5SumValue CurMd5 = List.Description_md5();
+   if (CurMd5.Value().empty() == true && List.Description("").empty() == true)
+      return true;
+
+   /* Before we add a new description we first search in the group for
+      a version with a description of the same MD5 - if so we reuse this
+      description group instead of creating our own for this version */
+   for (pkgCache::PkgIterator P = Grp.PackageList();
+       P.end() == false; P = Grp.NextPkg(P))
+   {
+      for (pkgCache::VerIterator V = P.VersionList();
+          V.end() == false; ++V)
+      {
+        if (V->DescriptionList == 0 || MD5SumValue(V.DescriptionList().md5()) != CurMd5)
+           continue;
+        Ver->DescriptionList = V->DescriptionList;
+      }
+   }
+
+   // We haven't found reusable descriptions, so add the first description(s)
+   map_ptrloc md5idx = Ver->DescriptionList == 0 ? 0 : Ver.DescriptionList()->md5sum;
+   std::vector<std::string> availDesc = List.AvailableDescriptionLanguages();
+   for (std::vector<std::string>::const_iterator CurLang = availDesc.begin(); CurLang != availDesc.end(); ++CurLang)
+      if (AddNewDescription(List, Ver, *CurLang, CurMd5, md5idx) == false)
+        return false;
+   return true;
+}
+                                                                       /*}}}*/
+bool pkgCacheGenerator::AddNewDescription(ListParser &List, pkgCache::VerIterator &Ver, std::string const &lang, MD5SumValue const &CurMd5, map_ptrloc &md5idx) /*{{{*/
+{
+   pkgCache::DescIterator Desc;
+   Dynamic<pkgCache::DescIterator> DynDesc(Desc);
+
+   map_ptrloc const descindex = NewDescription(Desc, lang, CurMd5, md5idx);
+   if (unlikely(descindex == 0 && _error->PendingError()))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+           Ver.ParentPkg().Name(), "NewDescription", 1);
+
+   md5idx = Desc->md5sum;
+   Desc->ParentPkg = Ver.ParentPkg().Index();
+
+   // we add at the end, so that the start is constant as we need
+   // that to be able to efficiently share these lists
+   pkgCache::DescIterator VerDesc = Ver.DescriptionList(); // old value might be invalid after ReMap
+   for (;VerDesc.end() == false && VerDesc->NextDesc != 0; ++VerDesc);
+   map_ptrloc * const LastNextDesc = (VerDesc.end() == true) ? &Ver->DescriptionList : &VerDesc->NextDesc;
+   *LastNextDesc = descindex;
+
+   if (NewFileDesc(Desc,List) == false)
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+           Ver.ParentPkg().Name(), "NewFileDesc", 1);
 
 
-   if (Cache.HeaderP->PackageCount >= (1ULL<<sizeof(Cache.PkgP->ID)*8)-1)
-      return _error->Error(_("Wow, you exceeded the number of package "
-                            "names this APT is capable of."));
-   if (Cache.HeaderP->VersionCount >= (1ULL<<(sizeof(Cache.VerP->ID)*8))-1)
-      return _error->Error(_("Wow, you exceeded the number of versions "
-                            "this APT is capable of."));
-   if (Cache.HeaderP->DescriptionCount >= (1ULL<<(sizeof(Cache.DescP->ID)*8))-1)
-      return _error->Error(_("Wow, you exceeded the number of descriptions "
-                            "this APT is capable of."));
-   if (Cache.HeaderP->DependsCount >= (1ULL<<(sizeof(Cache.DepP->ID)*8))-1ULL)
-      return _error->Error(_("Wow, you exceeded the number of dependencies "
-                            "this APT is capable of."));
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
+                                                                       /*}}}*/
 // CacheGenerator::MergeFileProvides - Merge file provides             /*{{{*/
 // ---------------------------------------------------------------------
 /* If we found any file depends while parsing the main list we need to 
 // CacheGenerator::MergeFileProvides - Merge file provides             /*{{{*/
 // ---------------------------------------------------------------------
 /* If we found any file depends while parsing the main list we need to 
@@ -386,21 +569,22 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
       pkgCache::PkgIterator Pkg = Cache.FindPkg(PackageName);
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
       if (Pkg.end() == true)
       pkgCache::PkgIterator Pkg = Cache.FindPkg(PackageName);
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
       if (Pkg.end() == true)
-        return _error->Error(_("Error occurred while processing %s (FindPkg)"),
-                               PackageName.c_str());
+        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());
 
       Counter++;
       if (Counter % 100 == 0 && Progress != 0)
         Progress->Progress(List.Offset());
 
-      unsigned long Hash = List.VersionHash();
+      unsigned short Hash = List.VersionHash();
       pkgCache::VerIterator Ver = Pkg.VersionList();
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {
       pkgCache::VerIterator Ver = Pkg.VersionList();
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {
-        if (Ver->Hash == Hash && Version.c_str() == Ver.VerStr())
+        if (List.SameVersion(Hash, Ver) == true && Version == Ver.VerStr())
         {
            if (List.CollectFileProvides(Cache,Ver) == false)
         {
            if (List.CollectFileProvides(Cache,Ver) == false)
-              return _error->Error(_("Error occurred while processing %s (CollectFileProvides)"),PackageName.c_str());
+              return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                                   PackageName.c_str(), "CollectFileProvides", 1);
            break;
         }
       }
            break;
         }
       }
@@ -434,8 +618,11 @@ bool pkgCacheGenerator::NewGroup(pkgCache::GrpIterator &Grp, const string &Name)
 
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);
 
    // Insert it into the hash table
    unsigned long const Hash = Cache.Hash(Name);
-   Grp->Next = Cache.HeaderP->GrpHashTable[Hash];
-   Cache.HeaderP->GrpHashTable[Hash] = Group;
+   map_ptrloc *insertAt = &Cache.HeaderP->GrpHashTable[Hash];
+   while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.GrpP + *insertAt)->Name) > 0)
+      insertAt = &(Cache.GrpP + *insertAt)->Next;
+   Grp->Next = *insertAt;
+   *insertAt = Group;
 
    Grp->ID = Cache.HeaderP->GroupCount++;
    return true;
 
    Grp->ID = Cache.HeaderP->GroupCount++;
    return true;
@@ -464,11 +651,14 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
    // Insert the package into our package list
    if (Grp->FirstPackage == 0) // the group is new
    {
    // Insert the package into our package list
    if (Grp->FirstPackage == 0) // the group is new
    {
+      Grp->FirstPackage = Package;
       // Insert it into the hash table
       unsigned long const Hash = Cache.Hash(Name);
       // 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;
+      map_ptrloc *insertAt = &Cache.HeaderP->PkgHashTable[Hash];
+      while (*insertAt != 0 && strcasecmp(Name.c_str(), Cache.StrP + (Cache.PkgP + *insertAt)->Name) > 0)
+        insertAt = &(Cache.PkgP + *insertAt)->NextPackage;
+      Pkg->NextPackage = *insertAt;
+      *insertAt = Package;
    }
    else // Group the Packages together
    {
    }
    else // Group the Packages together
    {
@@ -491,6 +681,77 @@ bool pkgCacheGenerator::NewPackage(pkgCache::PkgIterator &Pkg,const string &Name
 
    return true;
 }
 
    return true;
 }
+                                                                       /*}}}*/
+// CacheGenerator::AddImplicitDepends                                  /*{{{*/
+bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G,
+                                          pkgCache::PkgIterator &P,
+                                          pkgCache::VerIterator &V)
+{
+   // copy P.Arch() into a string here as a cache remap
+   // in NewDepends() later may alter the pointer location
+   string Arch = P.Arch() == NULL ? "" : P.Arch();
+   map_ptrloc *OldDepLast = NULL;
+   /* MultiArch handling introduces a lot of implicit Dependencies:
+      - MultiArch: same → Co-Installable if they have the same version
+      - All others conflict with all other group members */
+   bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
+   pkgCache::PkgIterator D = G.PackageList();
+   Dynamic<pkgCache::PkgIterator> DynD(D);
+   map_ptrloc const VerStrIdx = V->VerStr;
+   for (; D.end() != true; D = G.NextPkg(D))
+   {
+      if (Arch == D.Arch() || D->VersionList == 0)
+        continue;
+      /* We allow only one installed arch at the time
+        per group, therefore each group member conflicts
+        with all other group members */
+      if (coInstall == true)
+      {
+        // Replaces: ${self}:other ( << ${binary:Version})
+        NewDepends(D, V, VerStrIdx,
+                   pkgCache::Dep::Less, pkgCache::Dep::Replaces,
+                   OldDepLast);
+        // Breaks: ${self}:other (!= ${binary:Version})
+        NewDepends(D, V, VerStrIdx,
+                   pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
+                   OldDepLast);
+      } else {
+        // Conflicts: ${self}:other
+        NewDepends(D, V, 0,
+                   pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
+                   OldDepLast);
+      }
+   }
+   return true;
+}
+bool pkgCacheGenerator::AddImplicitDepends(pkgCache::VerIterator &V,
+                                          pkgCache::PkgIterator &D)
+{
+   /* MultiArch handling introduces a lot of implicit Dependencies:
+      - MultiArch: same → Co-Installable if they have the same version
+      - All others conflict with all other group members */
+   map_ptrloc *OldDepLast = NULL;
+   bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
+   if (coInstall == true)
+   {
+      map_ptrloc const VerStrIdx = V->VerStr;
+      // Replaces: ${self}:other ( << ${binary:Version})
+      NewDepends(D, V, VerStrIdx,
+                pkgCache::Dep::Less, pkgCache::Dep::Replaces,
+                OldDepLast);
+      // Breaks: ${self}:other (!= ${binary:Version})
+      NewDepends(D, V, VerStrIdx,
+                pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
+                OldDepLast);
+   } else {
+      // Conflicts: ${self}:other
+      NewDepends(D, V, 0,
+                pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
+                OldDepLast);
+   }
+   return true;
+}
+
                                                                        /*}}}*/
 // CacheGenerator::NewFileVer - Create a new File<->Version association        /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // CacheGenerator::NewFileVer - Create a new File<->Version association        /*{{{*/
 // ---------------------------------------------------------------------
@@ -530,6 +791,8 @@ bool pkgCacheGenerator::NewFileVer(pkgCache::VerIterator &Ver,
 /* This puts a version structure in the linked list */
 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
                                            const string &VerStr,
 /* This puts a version structure in the linked list */
 unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
                                            const string &VerStr,
+                                           map_ptrloc const ParentPkg,
+                                           unsigned long const Hash,
                                            unsigned long Next)
 {
    // Get a structure
                                            unsigned long Next)
 {
    // Get a structure
@@ -539,13 +802,39 @@ unsigned long pkgCacheGenerator::NewVersion(pkgCache::VerIterator &Ver,
    
    // Fill it in
    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
    
    // Fill it in
    Ver = pkgCache::VerIterator(Cache,Cache.VerP + Version);
+   //Dynamic<pkgCache::VerIterator> DynV(Ver); // caller MergeListVersion already takes care of it
    Ver->NextVer = Next;
    Ver->NextVer = Next;
+   Ver->ParentPkg = ParentPkg;
+   Ver->Hash = Hash;
    Ver->ID = Cache.HeaderP->VersionCount++;
    Ver->ID = Cache.HeaderP->VersionCount++;
+
+   // try to find the version string in the group for reuse
+   pkgCache::PkgIterator Pkg = Ver.ParentPkg();
+   pkgCache::GrpIterator Grp = Pkg.Group();
+   if (Pkg.end() == false && Grp.end() == false)
+   {
+      for (pkgCache::PkgIterator P = Grp.PackageList(); P.end() == false; P = Grp.NextPkg(P))
+      {
+        if (Pkg == P)
+           continue;
+        for (pkgCache::VerIterator V = P.VersionList(); V.end() == false; ++V)
+        {
+           int const cmp = strcmp(V.VerStr(), VerStr.c_str());
+           if (cmp == 0)
+           {
+              Ver->VerStr = V->VerStr;
+              return Version;
+           }
+           else if (cmp < 0)
+              break;
+        }
+      }
+   }
+   // haven't found the version string, so create
    map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
    if (unlikely(idxVerStr == 0))
       return 0;
    Ver->VerStr = idxVerStr;
    map_ptrloc const idxVerStr = WriteStringInMap(VerStr);
    if (unlikely(idxVerStr == 0))
       return 0;
    Ver->VerStr = idxVerStr;
-   
    return Version;
 }
                                                                        /*}}}*/
    return Version;
 }
                                                                        /*}}}*/
@@ -587,9 +876,9 @@ bool pkgCacheGenerator::NewFileDesc(pkgCache::DescIterator &Desc,
 // ---------------------------------------------------------------------
 /* This puts a description structure in the linked list */
 map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
 // ---------------------------------------------------------------------
 /* This puts a description structure in the linked list */
 map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
-                                           const string &Lang, 
-                                            const MD5SumValue &md5sum,
-                                           map_ptrloc Next)
+                                           const string &Lang,
+                                           const MD5SumValue &md5sum,
+                                           map_ptrloc idxmd5str)
 {
    // Get a structure
    map_ptrloc const Description = AllocateInMap(sizeof(pkgCache::Description));
 {
    // Get a structure
    map_ptrloc const Description = AllocateInMap(sizeof(pkgCache::Description));
@@ -598,95 +887,59 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
 
    // Fill it in
    Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description);
 
    // Fill it in
    Desc = pkgCache::DescIterator(Cache,Cache.DescP + Description);
-   Desc->NextDesc = Next;
    Desc->ID = Cache.HeaderP->DescriptionCount++;
    Desc->ID = Cache.HeaderP->DescriptionCount++;
-   map_ptrloc const idxlanguage_code = WriteStringInMap(Lang);
-   map_ptrloc const idxmd5sum = WriteStringInMap(md5sum.Value());
-   if (unlikely(idxlanguage_code == 0 || idxmd5sum == 0))
+   map_ptrloc const idxlanguage_code = WriteUniqString(Lang);
+   if (unlikely(idxlanguage_code == 0))
       return 0;
    Desc->language_code = idxlanguage_code;
       return 0;
    Desc->language_code = idxlanguage_code;
-   Desc->md5sum = idxmd5sum;
+
+   if (idxmd5str != 0)
+      Desc->md5sum = idxmd5str;
+   else
+   {
+      map_ptrloc const idxmd5sum = WriteStringInMap(md5sum.Value());
+      if (unlikely(idxmd5sum == 0))
+        return 0;
+      Desc->md5sum = idxmd5sum;
+   }
 
    return Description;
 }
                                                                        /*}}}*/
 
    return Description;
 }
                                                                        /*}}}*/
-// CacheGenerator::FinishCache - do various finish operations          /*{{{*/
+// CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
 // ---------------------------------------------------------------------
 // ---------------------------------------------------------------------
-/* This prepares the Cache for delivery */
-bool pkgCacheGenerator::FinishCache(OpProgress *Progress)
+/* This creates a dependency element in the tree. It is linked to the
+   version and to the package that it is pointing to. */
+bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
+                                  pkgCache::VerIterator &Ver,
+                                  string const &Version,
+                                  unsigned int const &Op,
+                                  unsigned int const &Type,
+                                  map_ptrloc* &OldDepLast)
 {
 {
-   // 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)
+   map_ptrloc index = 0;
+   if (Version.empty() == false)
    {
    {
-      // Create Conflicts in between the group
-      pkgCache::GrpIterator G = GetCache().GrpBegin();
-      Dynamic<pkgCache::GrpIterator> DynG(G);
-      for (; G.end() != true; ++G)
+      int const CmpOp = Op & 0x0F;
+      // =-deps are used (79:1) for lockstep on same-source packages (e.g. data-packages)
+      if (CmpOp == pkgCache::Dep::Equals && strcmp(Version.c_str(), Ver.VerStr()) == 0)
+        index = Ver->VerStr;
+
+      if (index == 0)
       {
       {
-        string const PkgName = G.Name();
-        pkgCache::PkgIterator P = G.PackageList();
-        Dynamic<pkgCache::PkgIterator> DynP(P);
-        for (; P.end() != true; P = G.NextPkg(P))
-        {
-           pkgCache::PkgIterator allPkg;
-           Dynamic<pkgCache::PkgIterator> DynallPkg(allPkg);
-           pkgCache::VerIterator V = P.VersionList();
-           Dynamic<pkgCache::VerIterator> DynV(V);
-           for (; V.end() != true; ++V)
-           {
-               // copy P.Arch() into a string here as a cache remap
-               // in NewDepends() later may alter the pointer location
-              string Arch = P.Arch() == NULL ? "" : P.Arch();
-              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::Same) == pkgCache::Version::Same);
-              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);
-                 Dynamic<pkgCache::PkgIterator> DynD(D);
-                 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::NotEquals, pkgCache::Dep::DpkgBreaks,
-                               OldDepLast);
-                 } else {
-                       // Conflicts: ${self}:other
-                       NewDepends(D, V, "",
-                                  pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
-                                  OldDepLast);
-                 }
-              }
-           }
-        }
+        void const * const oldMap = Map.Data();
+        index = WriteStringInMap(Version);
+        if (unlikely(index == 0))
+           return false;
+        if (OldDepLast != 0 && oldMap != Map.Data())
+           OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
       }
    }
       }
    }
-   return true;
+   return NewDepends(Pkg, Ver, index, Op, Type, OldDepLast);
 }
 }
-                                                                       /*}}}*/
-// CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
-// ---------------------------------------------------------------------
-/* This creates a dependency element in the tree. It is linked to the
-   version and to the package that it is pointing to. */
 bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
                                   pkgCache::VerIterator &Ver,
 bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
                                   pkgCache::VerIterator &Ver,
-                                  string const &Version,
+                                  map_ptrloc const Version,
                                   unsigned int const &Op,
                                   unsigned int const &Type,
                                   map_ptrloc* &OldDepLast)
                                   unsigned int const &Op,
                                   unsigned int const &Type,
                                   map_ptrloc* &OldDepLast)
@@ -696,29 +949,16 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
    map_ptrloc const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
    if (unlikely(Dependency == 0))
       return false;
    map_ptrloc const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
    if (unlikely(Dependency == 0))
       return false;
-   
+
    // Fill it in
    pkgCache::DepIterator Dep(Cache,Cache.DepP + Dependency);
    Dynamic<pkgCache::DepIterator> DynDep(Dep);
    Dep->ParentVer = Ver.Index();
    Dep->Type = Type;
    Dep->CompareOp = Op;
    // Fill it in
    pkgCache::DepIterator Dep(Cache,Cache.DepP + Dependency);
    Dynamic<pkgCache::DepIterator> DynDep(Dep);
    Dep->ParentVer = Ver.Index();
    Dep->Type = Type;
    Dep->CompareOp = Op;
+   Dep->Version = Version;
    Dep->ID = Cache.HeaderP->DependsCount++;
 
    Dep->ID = Cache.HeaderP->DependsCount++;
 
-   // Probe the reverse dependency list for a version string that matches
-   if (Version.empty() == false)
-   {
-/*      for (pkgCache::DepIterator I = Pkg.RevDependsList(); I.end() == false; I++)
-        if (I->Version != 0 && I.TargetVer() == Version)
-           Dep->Version = I->Version;*/
-      if (Dep->Version == 0) {
-        map_ptrloc const index = WriteStringInMap(Version);
-        if (unlikely(index == 0))
-           return false;
-        Dep->Version = index;
-      }
-   }
-
    // Link it to the package
    Dep->Package = Pkg.Index();
    Dep->NextRevDepends = Pkg->RevDepends;
    // Link it to the package
    Dep->Package = Pkg.Index();
    Dep->NextRevDepends = Pkg->RevDepends;
@@ -731,7 +971,7 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
       for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
         OldDepLast = &D->NextDepends;
    } else if (oldMap != Map.Data())
       for (pkgCache::DepIterator D = Ver.DependsList(); D.end() == false; ++D)
         OldDepLast = &D->NextDepends;
    } else if (oldMap != Map.Data())
-      OldDepLast += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
+      OldDepLast += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
 
    Dep->NextDepends = *OldDepLast;
    *OldDepLast = Dep.Index();
 
    Dep->NextDepends = *OldDepLast;
    *OldDepLast = Dep.Index();
@@ -758,6 +998,9 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
 
    // Locate the target package
    pkgCache::PkgIterator Pkg = Grp.FindPkg(Arch);
 
    // Locate the target package
    pkgCache::PkgIterator Pkg = Grp.FindPkg(Arch);
+   // we don't create 'none' packages and their dependencies if we can avoid it …
+   if (Pkg.end() == true && Arch == "none" && strcmp(Ver.ParentPkg().Arch(), "none") != 0)
+      return true;
    Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
    if (Pkg.end() == true) {
       if (unlikely(Owner->NewPackage(Pkg, PackageName, Arch) == false))
    Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
    if (Pkg.end() == true) {
       if (unlikely(Owner->NewPackage(Pkg, PackageName, Arch) == false))
@@ -804,8 +1047,12 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
    Prv->Version = Ver.Index();
    Prv->NextPkgProv = Ver->ProvidesList;
    Ver->ProvidesList = Prv.Index();
    Prv->Version = Ver.Index();
    Prv->NextPkgProv = Ver->ProvidesList;
    Ver->ProvidesList = Prv.Index();
-   if (Version.empty() == false && unlikely((Prv->ProvideVersion = WriteString(Version)) == 0))
-      return false;
+   if (Version.empty() == false) {
+      map_ptrloc const idxProvideVersion = WriteString(Version);
+      Prv->ProvideVersion = idxProvideVersion;
+      if (unlikely(idxProvideVersion == 0))
+        return false;
+   }
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;
    
    // Locate the target package
    pkgCache::PkgIterator Pkg;
@@ -821,6 +1068,12 @@ bool pkgCacheGenerator::ListParser::NewProvides(pkgCache::VerIterator &Ver,
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
+bool pkgCacheGenerator::ListParser::SameVersion(unsigned short const Hash,/*{{{*/
+      pkgCache::VerIterator const &Ver)
+{
+   return Hash == Ver->Hash;
+}
+                                                                       /*}}}*/
 // CacheGenerator::SelectFile - Select the current file being parsed   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used to select which file is to be associated with all newly
 // CacheGenerator::SelectFile - Select the current file being parsed   /*{{{*/
 // ---------------------------------------------------------------------
 /* This is used to select which file is to be associated with all newly
@@ -901,8 +1154,8 @@ unsigned long pkgCacheGenerator::WriteUniqString(const char *S,
    if (unlikely(idxString == 0))
       return 0;
    if (oldMap != Map.Data()) {
    if (unlikely(idxString == 0))
       return 0;
    if (oldMap != Map.Data()) {
-      Last += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
-      I += (pkgCache::StringItem*) Map.Data() - (pkgCache::StringItem*) oldMap;
+      Last += (map_ptrloc const * const) Map.Data() - (map_ptrloc const * const) oldMap;
+      I += (pkgCache::StringItem const * const) Map.Data() - (pkgCache::StringItem const * const) oldMap;
    }
    *Last = Item;
 
    }
    *Last = Item;
 
@@ -935,7 +1188,7 @@ static bool CheckValidity(const string &CacheFile,
       return false;
    }
 
       return false;
    }
 
-   if (List.GetLastModifiedTime() < GetModificationTime(CacheFile))
+   if (List.GetLastModifiedTime() > GetModificationTime(CacheFile))
    {
       if (Debug == true)
         std::clog << "sources.list is newer than the cache" << std::endl;
    {
       if (Debug == true)
         std::clog << "sources.list is newer than the cache" << std::endl;
@@ -1025,10 +1278,10 @@ static bool CheckValidity(const string &CacheFile,
 static unsigned long ComputeSize(FileIterator Start,FileIterator End)
 {
    unsigned long TotalSize = 0;
 static unsigned long ComputeSize(FileIterator Start,FileIterator End)
 {
    unsigned long TotalSize = 0;
-   for (; Start != End; ++Start)
+   for (; Start < End; ++Start)
    {
       if ((*Start)->HasPackages() == false)
    {
       if ((*Start)->HasPackages() == false)
-        continue;      
+        continue;
       TotalSize += (*Start)->Size();
    }
    return TotalSize;
       TotalSize += (*Start)->Size();
    }
    return TotalSize;
@@ -1109,21 +1362,21 @@ DynamicMMap* pkgCacheGenerator::CreateDynamicMMap(FileFd *CacheF, unsigned long
    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. */
    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. */
-__deprecated bool pkgMakeStatusCache(pkgSourceList &List,OpProgress &Progress,
+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)
 {
    bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
                        MMap **OutMap, bool AllowMem)
    { return pkgCacheGenerator::MakeStatusCache(List, &Progress, OutMap, AllowMem); }
 bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress,
                        MMap **OutMap,bool AllowMem)
 {
    bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
-   
-   vector<pkgIndexFile *> Files;
-   for (vector<metaIndex *>::const_iterator i = List.begin();
+
+   std::vector<pkgIndexFile *> Files;
+   for (std::vector<metaIndex *>::const_iterator i = List.begin();
         i != List.end();
         ++i)
    {
         i != List.end();
         ++i)
    {
-      vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles();
-      for (vector<pkgIndexFile *>::const_iterator j = Indexes->begin();
+      std::vector <pkgIndexFile *> *Indexes = (*i)->GetIndexFiles();
+      for (std::vector<pkgIndexFile *>::const_iterator j = Indexes->begin();
           j != Indexes->end();
           ++j)
          Files.push_back (*j);
           j != Indexes->end();
           ++j)
          Files.push_back (*j);
@@ -1203,10 +1456,11 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
         }
         _error->RevertToStack();
       }
         }
         _error->RevertToStack();
       }
-      else if (Debug == true)
+      else
       {
         _error->MergeWithStack();
       {
         _error->MergeWithStack();
-        std::clog << "Open filebased MMap" << std::endl;
+        if (Debug == true)
+           std::clog << "Open filebased MMap" << std::endl;
       }
    }
    if (Writeable == false || CacheFile.empty() == true)
       }
    }
    if (Writeable == false || CacheFile.empty() == true)
@@ -1242,9 +1496,6 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
                     Files.begin()+EndOfSource,Files.end()) == false)
         return false;
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
                     Files.begin()+EndOfSource,Files.end()) == false)
         return false;
-
-      // FIXME: move me to a better place
-      Gen.FinishCache(Progress);
    }
    else
    {
    }
    else
    {
@@ -1287,9 +1538,6 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
                     Files.begin()+EndOfSource,Files.end()) == false)
         return false;
       if (BuildCache(Gen,Progress,CurrentSize,TotalSize,
                     Files.begin()+EndOfSource,Files.end()) == false)
         return false;
-
-      // FIXME: move me to a better place
-      Gen.FinishCache(Progress);
    }
    if (Debug == true)
       std::clog << "Caches are ready for shipping" << std::endl;
    }
    if (Debug == true)
       std::clog << "Caches are ready for shipping" << std::endl;
@@ -1315,11 +1563,11 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
 // CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // CacheGenerator::MakeOnlyStatusCache - Build only a status files cache/*{{{*/
 // ---------------------------------------------------------------------
 /* */
-__deprecated bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
+APT_DEPRECATED bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutMap)
    { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
 bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
 {
    { return pkgCacheGenerator::MakeOnlyStatusCache(&Progress, OutMap); }
 bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **OutMap)
 {
-   vector<pkgIndexFile *> Files;
+   std::vector<pkgIndexFile *> Files;
    unsigned long EndOfSource = Files.size();
    if (_system->AddStatusFiles(Files) == false)
       return false;
    unsigned long EndOfSource = Files.size();
    if (_system->AddStatusFiles(Files) == false)
       return false;
@@ -1340,9 +1588,6 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
                  Files.begin()+EndOfSource,Files.end()) == false)
       return false;
 
                  Files.begin()+EndOfSource,Files.end()) == false)
       return false;
 
-   // FIXME: move me to a better place
-   Gen.FinishCache(Progress);
-
    if (_error->PendingError() == true)
       return false;
    *OutMap = Map.UnGuard();
    if (_error->PendingError() == true)
       return false;
    *OutMap = Map.UnGuard();
@@ -1350,3 +1595,22 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/
+// IsDuplicateDescription                                              /*{{{*/
+static bool IsDuplicateDescription(pkgCache::DescIterator Desc,
+                           MD5SumValue const &CurMd5, std::string const &CurLang)
+{
+   // Descriptions in the same link-list have all the same md5
+   if (Desc.end() == true || MD5SumValue(Desc.md5()) != CurMd5)
+      return false;
+   for (; Desc.end() == false; ++Desc)
+      if (Desc.LanguageCode() == CurLang)
+        return true;
+   return false;
+}
+                                                                       /*}}}*/
+// CacheGenerator::FinishCache                                         /*{{{*/
+bool pkgCacheGenerator::FinishCache(OpProgress * /*Progress*/)
+{
+   return true;
+}
+                                                                       /*}}}*/
APT (for Cydia)