recheck dependencies in SmartUnpack after a change, too

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 5147d7547e16d5690de12e9eeabac0af40a57e42..ec072fddd76ac5bd9757673c4c76c0ce36e8c20d 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -35,9 +35,14 @@
 
 #include <apti18n.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;
 

+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 */


@@ -201,7 +206,10 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
       pkgCache::PkgIterator Pkg;
       Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
       if (NewPackage(Pkg, PackageName, Arch) == false)
       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());
+        // 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);

 
 
       if (Version.empty() == true)
 
 
       if (Version.empty() == true)


@@ -242,8 +250,11 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
 bool pkgCacheGenerator::MergeListGroup(ListParser &List, std::string const &GrpName)
 {
    pkgCache::GrpIterator Grp = Cache.FindGrp(GrpName);
 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)
    if (Grp.end() == true)

-      return _error->Error("Information merge for non-existent group %s requested", GrpName.c_str());
+      return true;

    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
 
    pkgCache::PkgIterator Pkg;
    Dynamic<pkgCache::GrpIterator> DynGrp(Grp);
 
    pkgCache::PkgIterator Pkg;


@@ -263,48 +274,47 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator
    pkgCache::VerIterator Ver(Cache);
    Dynamic<pkgCache::VerIterator> DynVer(Ver);
    if (List.UsePackage(Pkg, Ver) == false)
    pkgCache::VerIterator Ver(Cache);
    Dynamic<pkgCache::VerIterator> DynVer(Ver);
    if (List.UsePackage(Pkg, Ver) == false)

-      return _error->Error(_("Error occurred while processing %s (UsePackage1)"),
-                          Pkg.Name());
+      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();
 
    // Find the right version to write the description
    MD5SumValue CurMd5 = List.Description_md5();

+   std::string CurLang = List.DescriptionLanguage();

 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {
       pkgCache::DescIterator Desc = Ver.DescriptionList();
 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {
       pkgCache::DescIterator Desc = Ver.DescriptionList();

-      Dynamic<pkgCache::DescIterator> DynDesc(Desc);
-      map_ptrloc *LastDesc = &Ver->DescriptionList;

 
 

+      // a version can only have one md5 describing it
+      if (MD5SumValue(Desc.md5()) != CurMd5)
+        continue;

 
       // don't add a new description if we have one for the given
       // md5 && language
 
       // don't add a new description if we have one for the given
       // md5 && language

-      bool duplicate = false;
-      for ( ; Desc.end() == false; ++Desc)
-        if (MD5SumValue(Desc.md5()) == CurMd5 &&
-            Desc.LanguageCode() == List.DescriptionLanguage())
-              duplicate=true;
-      if (duplicate == true)
+      if (IsDuplicateDescription(Desc, CurMd5, CurLang) == true)

         continue;
 
         continue;
 

-      for (Desc = Ver.DescriptionList();
-          Desc.end() == false;
-           LastDesc = &Desc->NextDesc, ++Desc)
-      {
-        if (MD5SumValue(Desc.md5()) != CurMd5)
-           continue;
-
-        // 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)"), Pkg.Name());
-        break;
-       }
+      Dynamic<pkgCache::DescIterator> DynDesc(Desc);
+      // we add at the end, so that the start is constant as we need
+      // that to be able to efficiently share these lists
+      map_ptrloc *LastDesc = &Ver->DescriptionList;
+      for (;Desc.end() == false && Desc->NextDesc != 0; ++Desc);
+      if (Desc.end() == false)
+        LastDesc = &Desc->NextDesc;
+
+      void const * const oldMap = Map.Data();
+      map_ptrloc const descindex = NewDescription(Desc, CurLang, 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 (%s%d)"),
+                             Pkg.Name(), "NewFileDesc", 1);
+
+      // we can stop here as all "same" versions will share the description
+      break;

    }
 
    return true;
    }
 
    return true;


@@ -342,12 +352,12 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
       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)"),
-                                Pkg.Name());
+           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)"),
-                                Pkg.Name());
+           return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                                Pkg.Name(), "NewFileVer", 1);

 
         // Read only a single record and return
         if (OutVer != 0)
 
         // Read only a single record and return
         if (OutVer != 0)


@@ -363,8 +373,8 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    // Add a new version
    map_ptrloc const verindex = NewVersion(Ver,Version,*LastVer);
    if (verindex == 0 && _error->PendingError())
    // 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)"),
-                          Pkg.Name(), 1);
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewVersion", 1);

 
    if (oldMap != Map.Data())
         LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
 
    if (oldMap != Map.Data())
         LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;


@@ -372,17 +382,43 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    Ver->ParentPkg = Pkg.Index();
    Ver->Hash = Hash;
 
    Ver->ParentPkg = Pkg.Index();
    Ver->Hash = Hash;
 

-   if (List.NewVersion(Ver) == false)
-      return _error->Error(_("Error occurred while processing %s (NewVersion%d)"),
-                          Pkg.Name(), 2);
+   if (unlikely(List.NewVersion(Ver) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewVersion", 2);

 
 

-   if (List.UsePackage(Pkg,Ver) == false)
-      return _error->Error(_("Error occurred while processing %s (UsePackage3)"),
-                          Pkg.Name());
+   if (unlikely(List.UsePackage(Pkg,Ver) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "UsePackage", 3);

 
 

-   if (NewFileVer(Ver,List) == false)
-      return _error->Error(_("Error occurred while processing %s (NewVersion%d)"),
-                          Pkg.Name(), 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))
+      {
+        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);
+      }
+   }
+   if (unlikely(AddImplicitDepends(Grp, Pkg, Ver) == false))
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "AddImplicitDepends", 2);

 
    // Read only a single record and return
    if (OutVer != 0)
 
    // Read only a single record and return
    if (OutVer != 0)


@@ -391,25 +427,43 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
       return true;
    }
 
       return true;
    }
 

-   /* Record the Description data. Description data always exist in
-      Packages and Translation-* files. */
+   /* Record the Description (it is not translated) */
+   MD5SumValue CurMd5 = List.Description_md5();
+   if (CurMd5.Value().empty() == true)
+      return true;
+   std::string CurLang = List.DescriptionLanguage();
+
+   /* 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 (IsDuplicateDescription(V.DescriptionList(), CurMd5, "") == false)
+           continue;
+        Ver->DescriptionList = V->DescriptionList;
+        return true;
+      }
+   }
+
+   // We haven't found reusable descriptions, so add the first description

    pkgCache::DescIterator Desc = Ver.DescriptionList();
    Dynamic<pkgCache::DescIterator> DynDesc(Desc);
    map_ptrloc *LastDesc = &Ver->DescriptionList;
 
    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();
    oldMap = Map.Data();

-   map_ptrloc const descindex = NewDescription(Desc, List.DescriptionLanguage(), List.Description_md5(), *LastDesc);
+   map_ptrloc const descindex = NewDescription(Desc, CurLang, 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)
    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)"),Pkg.Name());
+      return _error->Error(_("Error occurred while processing %s (%s%d)"),
+                          Pkg.Name(), "NewFileDesc", 2);

 
    return true;
 }
 
    return true;
 }


@@ -439,8 +493,8 @@ 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());


@@ -453,7 +507,8 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
         if (Ver->Hash == Hash && Version.c_str() == Ver.VerStr())
         {
            if (List.CollectFileProvides(Cache,Ver) == false)
         if (Ver->Hash == Hash && Version.c_str() == Ver.VerStr())
         {
            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;
         }
       }


@@ -544,6 +599,75 @@ 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);
+   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, 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);
+      }
+   }
+   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)
+   {
+      // 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);
+   }
+   return true;
+}
+

                                                                        /*}}}*/
 // CacheGenerator::NewFileVer - Create a new File<->Version association        /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // CacheGenerator::NewFileVer - Create a new File<->Version association        /*{{{*/
 // ---------------------------------------------------------------------


@@ -663,76 +787,6 @@ map_ptrloc pkgCacheGenerator::NewDescription(pkgCache::DescIterator &Desc,
    return Description;
 }
                                                                        /*}}}*/
    return Description;
 }
                                                                        /*}}}*/

-// 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
-      pkgCache::GrpIterator G = GetCache().GrpBegin();
-      Dynamic<pkgCache::GrpIterator> DynG(G);
-      for (; G.end() != true; ++G)
-      {
-        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);
-                 }
-              }
-           }
-        }
-      }
-   }
-   return true;
-}
-                                                                       /*}}}*/

 // CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a dependency element in the tree. It is linked to the
 // CacheGenerator::NewDepends - Create a dependency element            /*{{{*/
 // ---------------------------------------------------------------------
 /* This creates a dependency element in the tree. It is linked to the


@@ -1169,14 +1223,14 @@ bool pkgCacheGenerator::MakeStatusCache(pkgSourceList &List,OpProgress *Progress
                        MMap **OutMap,bool AllowMem)
 {
    bool const Debug = _config->FindB("Debug::pkgCacheGen", false);
                        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);


@@ -1295,9 +1349,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
    {


@@ -1340,9 +1391,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;


@@ -1372,7 +1420,7 @@ __deprecated bool pkgMakeOnlyStatusCache(OpProgress &Progress,DynamicMMap **OutM
    { 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;


@@ -1393,9 +1441,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();


@@ -1403,3 +1448,22 @@ bool pkgCacheGenerator::MakeOnlyStatusCache(OpProgress *Progress,DynamicMMap **O
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

+// IsDuplicateDescription                                              /*{{{*/
+bool IsDuplicateDescription(pkgCache::DescIterator Desc,
+                           MD5SumValue const &CurMd5, std::string const &CurLang)
+{
+   // Descriptions in the same link-list have all the same md5
+   if (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;
+}
+                                                                       /*}}}*/