fix partial (206 and 416) support in https

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

diff --git a/apt-pkg/pkgcachegen.cc b/apt-pkg/pkgcachegen.cc
index 54b07c465390ed86f8d61fa26c0c30fb0833916e..7ce7aba7bc742cd7a56f10d16d6c0b8b82b2e97a 100644 (file)
--- a/apt-pkg/pkgcachegen.cc
+++ b/apt-pkg/pkgcachegen.cc
@@ -69,7 +69,9 @@ pkgCacheGenerator::pkgCacheGenerator(DynamicMMap *pMap,OpProgress *Prog) :
       *Cache.HeaderP = pkgCache::Header();
       map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
       Cache.HeaderP->VerSysName = idxVerSysName;
       *Cache.HeaderP = pkgCache::Header();
       map_ptrloc const idxVerSysName = WriteStringInMap(_system->VS->Label);
       Cache.HeaderP->VerSysName = idxVerSysName;

-      map_ptrloc const idxArchitecture = WriteStringInMap(_config->Find("APT::Architecture"));
+      // 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"));

       Cache.HeaderP->Architecture = idxArchitecture;
       if (unlikely(idxVerSysName == 0 || idxArchitecture == 0))
         return;
       Cache.HeaderP->Architecture = idxArchitecture;
       if (unlikely(idxVerSysName == 0 || idxArchitecture == 0))
         return;


@@ -209,6 +211,7 @@ bool pkgCacheGenerator::MergeList(ListParser &List,
            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;
            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
         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


@@ -293,40 +296,41 @@ bool pkgCacheGenerator::MergeListPackage(ListParser &List, pkgCache::PkgIterator
 
    // 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();

+   if (CurMd5.Value().empty() == true || List.Description().empty() == true)
+      return true;

    std::string CurLang = List.DescriptionLanguage();
 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {
    std::string CurLang = List.DescriptionLanguage();
 
    for (Ver = Pkg.VersionList(); Ver.end() == false; ++Ver)
    {

-      pkgCache::DescIterator Desc = Ver.DescriptionList();
+      pkgCache::DescIterator VerDesc = Ver.DescriptionList();

 
       // a version can only have one md5 describing it
 
       // a version can only have one md5 describing it

-      if (Desc.end() == true || MD5SumValue(Desc.md5()) != CurMd5)
+      if (VerDesc.end() == true || MD5SumValue(VerDesc.md5()) != CurMd5)

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

-      if (IsDuplicateDescription(Desc, CurMd5, CurLang) == true)
+      if (IsDuplicateDescription(VerDesc, CurMd5, CurLang) == true)

         continue;
 
         continue;
 

+      pkgCache::DescIterator Desc;

       Dynamic<pkgCache::DescIterator> DynDesc(Desc);
       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);
+      map_ptrloc const descindex = NewDescription(Desc, CurLang, CurMd5, VerDesc->md5sum);

       if (unlikely(descindex == 0 && _error->PendingError()))
         return _error->Error(_("Error occurred while processing %s (%s%d)"),
                              Pkg.Name(), "NewDescription", 1);
       if (unlikely(descindex == 0 && _error->PendingError()))
         return _error->Error(_("Error occurred while processing %s (%s%d)"),
                              Pkg.Name(), "NewDescription", 1);

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

       Desc->ParentPkg = Pkg.Index();
 
       Desc->ParentPkg = Pkg.Index();
 

-      if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
+      // we add at the end, so that the start is constant as we need
+      // that to be able to efficiently share these lists
+      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)"),
                              Pkg.Name(), "NewFileDesc", 1);
 
         return _error->Error(_("Error occurred while processing %s (%s%d)"),
                              Pkg.Name(), "NewFileDesc", 1);
 


@@ -388,7 +392,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    }
 
    // Add a new version
    }
 
    // Add a new version

-   map_ptrloc const verindex = NewVersion(Ver,Version,*LastVer);
+   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);
    if (verindex == 0 && _error->PendingError())
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewVersion", 1);


@@ -396,8 +400,6 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    if (oldMap != Map.Data())
         LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
    *LastVer = verindex;
    if (oldMap != Map.Data())
         LastVer += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
    *LastVer = verindex;

-   Ver->ParentPkg = Pkg.Index();
-   Ver->Hash = Hash;

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


@@ -459,12 +461,10 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
 
               map_ptrloc *OldDepLast = NULL;
               pkgCache::VerIterator ConVersion = D.ParentVer();
 
               map_ptrloc *OldDepLast = NULL;
               pkgCache::VerIterator ConVersion = D.ParentVer();

+              Dynamic<pkgCache::VerIterator> DynV(ConVersion);

               // duplicate the Conflicts/Breaks/Replaces for :none arch
               // duplicate the Conflicts/Breaks/Replaces for :none arch

-              if (D->Version == 0)
-                 NewDepends(Pkg, ConVersion, "", 0, D->Type, OldDepLast);
-              else
-                 NewDepends(Pkg, ConVersion, D.TargetVer(),
-                            D->CompareOp, D->Type, OldDepLast);
+              NewDepends(Pkg, ConVersion, D->Version,
+                    D->CompareOp, D->Type, OldDepLast);

            }
         }
       }
            }
         }
       }


@@ -482,7 +482,7 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
 
    /* Record the Description (it is not translated) */
    MD5SumValue CurMd5 = List.Description_md5();
 
    /* Record the Description (it is not translated) */
    MD5SumValue CurMd5 = List.Description_md5();

-   if (CurMd5.Value().empty() == true)
+   if (CurMd5.Value().empty() == true || List.Description().empty() == true)

       return true;
    std::string CurLang = List.DescriptionLanguage();
 
       return true;
    std::string CurLang = List.DescriptionLanguage();
 


@@ -505,19 +505,16 @@ bool pkgCacheGenerator::MergeListVersion(ListParser &List, pkgCache::PkgIterator
    // We haven't found reusable descriptions, so add the first description
    pkgCache::DescIterator Desc = Ver.DescriptionList();
    Dynamic<pkgCache::DescIterator> DynDesc(Desc);
    // 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;

 
 

-   oldMap = Map.Data();
-   map_ptrloc const descindex = NewDescription(Desc, CurLang, CurMd5, *LastDesc);
+   map_ptrloc const descindex = NewDescription(Desc, CurLang, CurMd5, 0);

    if (unlikely(descindex == 0 && _error->PendingError()))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewDescription", 2);
    if (unlikely(descindex == 0 && _error->PendingError()))
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewDescription", 2);

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

    Desc->ParentPkg = Pkg.Index();
    Desc->ParentPkg = Pkg.Index();

+   Ver->DescriptionList = descindex;

 
 

-   if ((*LastDesc == 0 && _error->PendingError()) || NewFileDesc(Desc,List) == false)
+   if (NewFileDesc(Desc,List) == false)

       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewFileDesc", 2);
 
       return _error->Error(_("Error occurred while processing %s (%s%d)"),
                           Pkg.Name(), "NewFileDesc", 2);
 


@@ -560,7 +557,7 @@ bool pkgCacheGenerator::MergeFileProvides(ListParser &List)
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {
       Dynamic<pkgCache::VerIterator> DynVer(Ver);
       for (; Ver.end() == false; ++Ver)
       {

-        if (Ver->Hash == Hash && Version.c_str() == Ver.VerStr())
+        if (Ver->Hash == Hash && Version == Ver.VerStr())

         {
            if (List.CollectFileProvides(Cache,Ver) == false)
               return _error->Error(_("Error occurred while processing %s (%s%d)"),
         {
            if (List.CollectFileProvides(Cache,Ver) == false)
               return _error->Error(_("Error occurred while processing %s (%s%d)"),


@@ -598,8 +595,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;


@@ -628,11 +628,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
    {


@@ -671,6 +674,7 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G,
    bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
    pkgCache::PkgIterator D = G.PackageList();
    Dynamic<pkgCache::PkgIterator> DynD(D);
    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)
    for (; D.end() != true; D = G.NextPkg(D))
    {
       if (Arch == D.Arch() || D->VersionList == 0)


@@ -681,16 +685,16 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::GrpIterator &G,
       if (coInstall == true)
       {
         // Replaces: ${self}:other ( << ${binary:Version})
       if (coInstall == true)
       {
         // Replaces: ${self}:other ( << ${binary:Version})

-        NewDepends(D, V, V.VerStr(),
+        NewDepends(D, V, VerStrIdx,

                    pkgCache::Dep::Less, pkgCache::Dep::Replaces,
                    OldDepLast);
         // Breaks: ${self}:other (!= ${binary:Version})
                    pkgCache::Dep::Less, pkgCache::Dep::Replaces,
                    OldDepLast);
         // Breaks: ${self}:other (!= ${binary:Version})

-        NewDepends(D, V, V.VerStr(),
+        NewDepends(D, V, VerStrIdx,

                    pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
                    OldDepLast);
       } else {
         // Conflicts: ${self}:other
                    pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
                    OldDepLast);
       } else {
         // Conflicts: ${self}:other

-        NewDepends(D, V, "",
+        NewDepends(D, V, 0,

                    pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
                    OldDepLast);
       }
                    pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
                    OldDepLast);
       }


@@ -707,17 +711,18 @@ bool pkgCacheGenerator::AddImplicitDepends(pkgCache::VerIterator &V,
    bool const coInstall = ((V->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same);
    if (coInstall == true)
    {
    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})
       // Replaces: ${self}:other ( << ${binary:Version})

-      NewDepends(D, V, V.VerStr(),
+      NewDepends(D, V, VerStrIdx,

                 pkgCache::Dep::Less, pkgCache::Dep::Replaces,
                 OldDepLast);
       // Breaks: ${self}:other (!= ${binary:Version})
                 pkgCache::Dep::Less, pkgCache::Dep::Replaces,
                 OldDepLast);
       // Breaks: ${self}:other (!= ${binary:Version})

-      NewDepends(D, V, V.VerStr(),
+      NewDepends(D, V, VerStrIdx,

                 pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
                 OldDepLast);
    } else {
       // Conflicts: ${self}:other
                 pkgCache::Dep::NotEquals, pkgCache::Dep::DpkgBreaks,
                 OldDepLast);
    } else {
       // Conflicts: ${self}:other

-      NewDepends(D, V, "",
+      NewDepends(D, V, 0,

                 pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
                 OldDepLast);
    }
                 pkgCache::Dep::NoOp, pkgCache::Dep::Conflicts,
                 OldDepLast);
    }


@@ -763,6 +768,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


@@ -772,13 +779,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;
 }
                                                                        /*}}}*/


@@ -820,9 +853,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));


@@ -831,14 +864,21 @@ 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;
 }


@@ -853,35 +893,49 @@ bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
                                   unsigned int const &Op,
                                   unsigned int const &Type,
                                   map_ptrloc* &OldDepLast)
                                   unsigned int const &Op,
                                   unsigned int const &Type,
                                   map_ptrloc* &OldDepLast)

+{
+   map_ptrloc index = 0;
+   if (Version.empty() == false)
+   {
+      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)
+      {
+        void const * const oldMap = Map.Data();
+        index = WriteStringInMap(Version);
+        if (unlikely(index == 0))
+           return false;
+        if (OldDepLast != 0 && oldMap != Map.Data())
+           OldDepLast += (map_ptrloc*) Map.Data() - (map_ptrloc*) oldMap;
+      }
+   }
+   return NewDepends(Pkg, Ver, index, Op, Type, OldDepLast);
+}
+bool pkgCacheGenerator::NewDepends(pkgCache::PkgIterator &Pkg,
+                                  pkgCache::VerIterator &Ver,
+                                  map_ptrloc const Version,
+                                  unsigned int const &Op,
+                                  unsigned int const &Type,
+                                  map_ptrloc* &OldDepLast)

 {
    void const * const oldMap = Map.Data();
    // Get a structure
    map_ptrloc const Dependency = AllocateInMap(sizeof(pkgCache::Dependency));
    if (unlikely(Dependency == 0))
       return false;
 {
    void const * const oldMap = Map.Data();
    // Get a structure
    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;


@@ -922,7 +976,7 @@ bool pkgCacheGenerator::ListParser::NewDepends(pkgCache::VerIterator &Ver,
    // Locate the target package
    pkgCache::PkgIterator Pkg = Grp.FindPkg(Arch);
    // we don't create 'none' packages and their dependencies if we can avoid it …
    // 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")
+   if (Pkg.end() == true && Arch == "none" && strcmp(Ver.ParentPkg().Arch(), "none") != 0)

       return true;
    Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
    if (Pkg.end() == true) {
       return true;
    Dynamic<pkgCache::PkgIterator> DynPkg(Pkg);
    if (Pkg.end() == true) {


@@ -970,8 +1024,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;