Newer sub/guess scripts

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

diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
index 111acee7cf33f2afcf7f57e6b601cc1f1c74de46..aa3e8565eb40285fa123ba2ed3d4e7c27b3e4ed4 100644 (file)
--- a/apt-pkg/pkgcache.cc
+++ b/apt-pkg/pkgcache.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: pkgcache.cc,v 1.10 1998/10/08 05:02:06 jgg Exp $
+// $Id: pkgcache.cc,v 1.32 2001/02/20 07:03:17 jgg Exp $

 /* ######################################################################
    
    Package Cache - Accessor code for the cache
 /* ######################################################################
    
    Package Cache - Accessor code for the cache


@@ -24,14 +24,21 @@
 #pragma implementation "apt-pkg/pkgcache.h"
 #pragma implementation "apt-pkg/cacheiterators.h"
 #endif 
 #pragma implementation "apt-pkg/pkgcache.h"
 #pragma implementation "apt-pkg/cacheiterators.h"
 #endif 

+

 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/error.h>
 #include <apt-pkg/pkgcache.h>
 #include <apt-pkg/version.h>
 #include <apt-pkg/error.h>

-#include <system.h>
+#include <apt-pkg/strutl.h>
+#include <apt-pkg/configuration.h>

 
 

+#include <apti18n.h>
+    

 #include <string>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <string>
 #include <sys/stat.h>
 #include <unistd.h>

+
+#include <system.h>
+

                                                                        /*}}}*/
 
 // Cache::Header::Header - Constructor                                 /*{{{*/
                                                                        /*}}}*/
 
 // Cache::Header::Header - Constructor                                 /*{{{*/


@@ -43,9 +50,9 @@ pkgCache::Header::Header()
    
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */
    
    /* Whenever the structures change the major version should be bumped,
       whenever the generator changes the minor version should be bumped. */

-   MajorVersion = 2;
-   MinorVersion = 0;
-   Dirty = true;
+   MajorVersion = 3;
+   MinorVersion = 5;
+   Dirty = false;

    
    HeaderSz = sizeof(pkgCache::Header);
    PackageSz = sizeof(pkgCache::Package);
    
    HeaderSz = sizeof(pkgCache::Header);
    PackageSz = sizeof(pkgCache::Package);


@@ -59,10 +66,14 @@ pkgCache::Header::Header()
    VersionCount = 0;
    DependsCount = 0;
    PackageFileCount = 0;
    VersionCount = 0;
    DependsCount = 0;
    PackageFileCount = 0;

+   VerFileCount = 0;
+   ProvidesCount = 0;

    MaxVerFileSize = 0;
    
    FileList = 0;
    StringList = 0;
    MaxVerFileSize = 0;
    
    FileList = 0;
    StringList = 0;

+   VerSysName = 0;
+   Architecture = 0;

    memset(HashTable,0,sizeof(HashTable));
    memset(Pools,0,sizeof(Pools));
 }
    memset(HashTable,0,sizeof(HashTable));
    memset(Pools,0,sizeof(Pools));
 }


@@ -87,9 +98,10 @@ bool pkgCache::Header::CheckSizes(Header &Against) const
 // Cache::pkgCache - Constructor                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Cache::pkgCache - Constructor                                       /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgCache::pkgCache(MMap &Map) : Map(Map)
+pkgCache::pkgCache(MMap *Map, bool DoMap) : Map(*Map)

 {
 {

-   ReMap();
+   if (DoMap == true)
+      ReMap();

 }
                                                                        /*}}}*/
 // Cache::ReMap - Reopen the cache file                                        /*{{{*/
 }
                                                                        /*}}}*/
 // Cache::ReMap - Reopen the cache file                                        /*{{{*/


@@ -108,20 +120,29 @@ bool pkgCache::ReMap()
    StringItemP = (StringItem *)Map.Data();
    StrP = (char *)Map.Data();
 
    StringItemP = (StringItem *)Map.Data();
    StrP = (char *)Map.Data();
 

-   if (Map.Size() == 0)
-      return false;
+   if (Map.Size() == 0 || HeaderP == 0)
+      return _error->Error(_("Empty package cache"));

    
    // Check the header
    Header DefHeader;
    if (HeaderP->Signature != DefHeader.Signature ||
        HeaderP->Dirty == true)
    
    // Check the header
    Header DefHeader;
    if (HeaderP->Signature != DefHeader.Signature ||
        HeaderP->Dirty == true)

-      return _error->Error("The package cache file is corrupted");
+      return _error->Error(_("The package cache file is corrupted"));

    
    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
        HeaderP->MinorVersion != DefHeader.MinorVersion ||
        HeaderP->CheckSizes(DefHeader) == false)
    
    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
        HeaderP->MinorVersion != DefHeader.MinorVersion ||
        HeaderP->CheckSizes(DefHeader) == false)

-      return _error->Error("The package cache file is an incompatible version");
-   
+      return _error->Error(_("The package cache file is an incompatible version"));
+
+   // Locate our VS..
+   if (HeaderP->VerSysName == 0 ||
+       (VS = pkgVersioningSystem::GetVS(StrP + HeaderP->VerSysName)) == 0)
+      return _error->Error(_("This APT does not support the Versioning System '%s'"),StrP + HeaderP->VerSysName);
+
+   // Chcek the arhcitecture
+   if (HeaderP->Architecture == 0 ||
+       _config->Find("APT::Architecture") != StrP + HeaderP->Architecture)
+      return _error->Error(_("The package cache was build for a different architecture"));

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


@@ -130,23 +151,20 @@ bool pkgCache::ReMap()
 /* This is used to generate the hash entries for the HashTable. With my
    package list from bo this function gets 94% table usage on a 512 item
    table (480 used items) */
 /* This is used to generate the hash entries for the HashTable. With my
    package list from bo this function gets 94% table usage on a 512 item
    table (480 used items) */

-unsigned long pkgCache::sHash(string Str)
+unsigned long pkgCache::sHash(string Str) const

 {
    unsigned long Hash = 0;
    for (const char *I = Str.begin(); I != Str.end(); I++)
 {
    unsigned long Hash = 0;
    for (const char *I = Str.begin(); I != Str.end(); I++)

-      Hash += *I * ((Str.end() - I + 1));
-   Header H;
-   return Hash % _count(H.HashTable);
+      Hash = 5*Hash + tolower(*I);
+   return Hash % _count(HeaderP->HashTable);

 }
 
 }
 

-unsigned long pkgCache::sHash(const char *Str)
+unsigned long pkgCache::sHash(const char *Str) const

 {
    unsigned long Hash = 0;
 {
    unsigned long Hash = 0;

-   const char *End = Str + strlen(Str);
-   for (const char *I = Str; I != End; I++)
-      Hash += *I * ((End - I + 1));
-   Header H;
-   return Hash % _count(H.HashTable);
+   for (const char *I = Str; *I != 0; I++)
+      Hash = 5*Hash + tolower(*I);
+   return Hash % _count(HeaderP->HashTable);

 }
 
                                                                        /*}}}*/
 }
 
                                                                        /*}}}*/


@@ -159,18 +177,57 @@ pkgCache::PkgIterator pkgCache::FindPkg(string Name)
    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
    {
    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
    {

-      if (Pkg->Name != 0 && StrP + Pkg->Name == Name)
+      if (Pkg->Name != 0 && StrP[Pkg->Name] == Name[0] &&
+         stringcasecmp(Name.begin(),Name.end(),StrP + Pkg->Name) == 0)

         return PkgIterator(*this,Pkg);
    }
    return PkgIterator(*this,0);
 }
                                                                        /*}}}*/
         return PkgIterator(*this,Pkg);
    }
    return PkgIterator(*this,0);
 }
                                                                        /*}}}*/

+// Cache::CompTypeDeb - Return a string describing the compare type    /*{{{*/
+// ---------------------------------------------------------------------
+/* This returns a string representation of the dependency compare 
+   type in the weird debian style.. */
+const char *pkgCache::CompTypeDeb(unsigned char Comp)
+{
+   const char *Ops[] = {"","<=",">=","<<",">>","=","!="};
+   if ((unsigned)(Comp & 0xF) < 7)
+      return Ops[Comp & 0xF];
+   return "";   
+}
+                                                                       /*}}}*/
+// Cache::CompType - Return a string describing the compare type       /*{{{*/
+// ---------------------------------------------------------------------
+/* This returns a string representation of the dependency compare 
+   type */
+const char *pkgCache::CompType(unsigned char Comp)
+{
+   const char *Ops[] = {"","<=",">=","<",">","=","!="};
+   if ((unsigned)(Comp & 0xF) < 7)
+      return Ops[Comp & 0xF];
+   return "";   
+}
+                                                                       /*}}}*/
+// Cache::DepType - Return a string describing the dep type            /*{{{*/
+// ---------------------------------------------------------------------
+/* */
+const char *pkgCache::DepType(unsigned char Type)
+{
+   const char *Types[] = {"",_("Depends"),_("PreDepends"),_("Suggests"),
+                          _("Recommends"),_("Conflicts"),_("Replaces"),
+                          _("Obsoletes")};
+   if (Type < 8)
+      return Types[Type];
+   return "";
+}
+                                                                       /*}}}*/

 // Cache::Priority - Convert a priority value to a string              /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 const char *pkgCache::Priority(unsigned char Prio)
 {
 // Cache::Priority - Convert a priority value to a string              /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 const char *pkgCache::Priority(unsigned char Prio)
 {

-   const char *Mapping[] = {0,"important","required","standard","optional","extra"};
+   const char *Mapping[] = {0,_("important"),_("required"),_("standard"),
+                            _("optional"),_("extra")};

    if (Prio < _count(Mapping))
       return Mapping[Prio];
    return 0;
    if (Prio < _count(Mapping))
       return Mapping[Prio];
    return 0;


@@ -190,9 +247,9 @@ void pkgCache::PkgIterator::operator ++(int)
    // Follow the current links
    if (Pkg != Owner->PkgP)
       Pkg = Owner->PkgP + Pkg->NextPackage;
    // Follow the current links
    if (Pkg != Owner->PkgP)
       Pkg = Owner->PkgP + Pkg->NextPackage;

-   
+

    // Follow the hash table
    // Follow the hash table

-   while (Pkg == Owner->PkgP && HashIndex < (signed)_count(Owner->HeaderP->HashTable))
+   while (Pkg == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->HashTable))

    {
       HashIndex++;
       Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
    {
       HashIndex++;
       Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];


@@ -203,13 +260,16 @@ void pkgCache::PkgIterator::operator ++(int)
 // ---------------------------------------------------------------------
 /* By this we mean if it is either cleanly installed or cleanly removed. */
 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 // ---------------------------------------------------------------------
 /* By this we mean if it is either cleanly installed or cleanly removed. */
 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const

-{
+{  
+   if (Pkg->InstState == pkgCache::State::ReInstReq ||
+       Pkg->InstState == pkgCache::State::HoldReInstReq)
+      return NeedsUnpack;
+   

    if (Pkg->CurrentState == pkgCache::State::UnPacked ||
        Pkg->CurrentState == pkgCache::State::HalfConfigured)
       return NeedsConfigure;
    
    if (Pkg->CurrentState == pkgCache::State::UnPacked ||
        Pkg->CurrentState == pkgCache::State::HalfConfigured)
       return NeedsConfigure;
    

-   if (Pkg->CurrentState == pkgCache::State::UnInstalled ||
-       Pkg->CurrentState == pkgCache::State::HalfInstalled ||
+   if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||

        Pkg->InstState != pkgCache::State::Ok)
       return NeedsUnpack;
       
        Pkg->InstState != pkgCache::State::Ok)
       return NeedsUnpack;
       


@@ -222,8 +282,10 @@ pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
    conflicts. */
 bool pkgCache::DepIterator::IsCritical()
 {
    conflicts. */
 bool pkgCache::DepIterator::IsCritical()
 {

-   if (Dep->Type == Dep::Conflicts || Dep->Type == Dep::Depends ||
-       Dep->Type == Dep::PreDepends)
+   if (Dep->Type == pkgCache::Dep::Conflicts ||
+       Dep->Type == pkgCache::Dep::Obsoletes ||
+       Dep->Type == pkgCache::Dep::Depends ||
+       Dep->Type == pkgCache::Dep::PreDepends)

       return true;
    return false;
 }
       return true;
    return false;
 }


@@ -236,7 +298,11 @@ bool pkgCache::DepIterator::IsCritical()
    then it returned. Otherwise the providing list is looked at to 
    see if there is one one unique providing package if so it is returned.
    Otherwise true is returned and the target package is set. The return
    then it returned. Otherwise the providing list is looked at to 
    see if there is one one unique providing package if so it is returned.
    Otherwise true is returned and the target package is set. The return

-   result indicates whether the node should be expandable */
+   result indicates whether the node should be expandable 
+ 
+   In Conjunction with the DepCache the value of Result may not be 
+   super-good since the policy may have made it uninstallable. Using
+   AllTargets is better in this case. */

 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 {
    Result = TargetPkg();
 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 {
    Result = TargetPkg();


@@ -270,19 +336,22 @@ bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
       if (PStart.OwnerPkg() != P.OwnerPkg())
         break;
    }
       if (PStart.OwnerPkg() != P.OwnerPkg())
         break;
    }

+
+   Result = PStart.OwnerPkg();

    
    // Check for non dups
    if (P.end() != true)
       return true;
    
    // Check for non dups
    if (P.end() != true)
       return true;

-   Result = PStart.OwnerPkg();
+   

    return false;
 }
                                                                        /*}}}*/
 // DepIterator::AllTargets - Returns the set of all possible targets   /*{{{*/
 // ---------------------------------------------------------------------
    return false;
 }
                                                                        /*}}}*/
 // DepIterator::AllTargets - Returns the set of all possible targets   /*{{{*/
 // ---------------------------------------------------------------------

-/* This is a more usefull version of TargetPkg() that follows versioned
+/* This is a more useful version of TargetPkg() that follows versioned

    provides. It includes every possible package-version that could satisfy
    provides. It includes every possible package-version that could satisfy

-   the dependency. The last item in the list has a 0. */
+   the dependency. The last item in the list has a 0. The resulting pointer
+   must be delete [] 'd */

 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 {
    Version **Res = 0;
 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 {
    Version **Res = 0;


@@ -295,10 +364,12 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
       // Walk along the actual package providing versions
       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
       {
       // Walk along the actual package providing versions
       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
       {

-        if (pkgCheckDep(TargetVer(),I.VerStr(),Dep->CompareOp) == false)
+        if (Owner->VS->CheckDep(I.VerStr(),Dep->CompareOp,TargetVer()) == false)

            continue;
 
            continue;
 

-        if (Dep->Type == Dep::Conflicts && ParentPkg() == I.ParentPkg())
+        if ((Dep->Type == pkgCache::Dep::Conflicts ||
+             Dep->Type == pkgCache::Dep::Obsoletes) &&
+            ParentPkg() == I.ParentPkg())

            continue;
         
         Size++;
            continue;
         
         Size++;


@@ -309,10 +380,12 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
       // Follow all provides
       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
       {
       // Follow all provides
       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
       {

-        if (pkgCheckDep(TargetVer(),I.ProvideVersion(),Dep->CompareOp) == false)
+        if (Owner->VS->CheckDep(I.ProvideVersion(),Dep->CompareOp,TargetVer()) == false)

            continue;
         
            continue;
         

-        if (Dep->Type == Dep::Conflicts && ParentPkg() == I.OwnerPkg())
+        if ((Dep->Type == pkgCache::Dep::Conflicts ||
+             Dep->Type == pkgCache::Dep::Obsoletes) &&
+            ParentPkg() == I.OwnerPkg())

            continue;
         
         Size++;
            continue;
         
         Size++;


@@ -336,16 +409,24 @@ pkgCache::Version **pkgCache::DepIterator::AllTargets()
    return Res;
 }
                                                                        /*}}}*/
    return Res;
 }
                                                                        /*}}}*/

-// DepIterator::CompType - Return a string describing the compare type /*{{{*/
+// DepIterator::GlobOr - Compute an OR group                           /*{{{*/

 // ---------------------------------------------------------------------
 // ---------------------------------------------------------------------

-/* This returns a string representation of the dependency compare 
-   type */
-const char *pkgCache::DepIterator::CompType()
+/* This Takes an iterator, iterates past the current dependency grouping
+   and returns Start and End so that so End is the final element
+   in the group, if End == Start then D is End++ and End is the
+   dependency D was pointing to. Use in loops to iterate sensibly. */
+void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)

 {
 {

-   const char *Ops[] = {"","<=",">=","<",">","=","!="};
-   if ((Dep->CompareOp & 0xF) < sizeof(Ops))
-      return Ops[Dep->CompareOp & 0xF];
-   return "";   
+   // Compute a single dependency element (glob or)
+   Start = *this;
+   End = *this;
+   for (bool LastOR = true; end() == false && LastOR == true;)
+   {
+      LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
+      (*this)++;
+      if (LastOR == true)
+        End = (*this);
+   }

 }
                                                                        /*}}}*/
 // VerIterator::CompareVer - Fast version compare for same pkgs                /*{{{*/
 }
                                                                        /*}}}*/
 // VerIterator::CompareVer - Fast version compare for same pkgs                /*{{{*/


@@ -378,11 +459,108 @@ bool pkgCache::VerIterator::Downloadable() const
 {
    VerFileIterator Files = FileList();
    for (; Files.end() == false; Files++)
 {
    VerFileIterator Files = FileList();
    for (; Files.end() == false; Files++)

-      if ((Files.File()->Flags & Flag::NotSource) != Flag::NotSource)
+      if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)

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

+// VerIterator::Automatic - Check if this version is 'automatic'       /*{{{*/
+// ---------------------------------------------------------------------
+/* This checks to see if any of the versions files are not NotAutomatic. 
+   True if this version is selectable for automatic installation. */
+bool pkgCache::VerIterator::Automatic() const
+{
+   VerFileIterator Files = FileList();
+   for (; Files.end() == false; Files++)
+      if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
+        return true;
+   return false;
+}
+                                                                       /*}}}*/
+// VerIterator::NewestFile - Return the newest file version relation   /*{{{*/
+// ---------------------------------------------------------------------
+/* This looks at the version numbers associated with all of the sources
+   this version is in and returns the highest.*/
+pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
+{
+   VerFileIterator Files = FileList();
+   VerFileIterator Highest = Files;
+   for (; Files.end() == false; Files++)
+   {
+      if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
+        Highest = Files;
+   }
+   
+   return Highest;
+}
+                                                                       /*}}}*/
+// VerIterator::RelStr - Release description string                    /*{{{*/
+// ---------------------------------------------------------------------
+/* This describes the version from a release-centric manner. The output is a 
+   list of Label:Version/Archive */
+string pkgCache::VerIterator::RelStr()
+{
+   bool First = true;
+   string Res;
+   for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; I++)
+   {
+      // Do not print 'not source' entries'
+      pkgCache::PkgFileIterator File = I.File();
+      if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
+        continue;
+
+      // See if we have already printed this out..
+      bool Seen = false;
+      for (pkgCache::VerFileIterator J = this->FileList(); I != J; J++)
+      {
+        pkgCache::PkgFileIterator File2 = J.File();
+        if (File2->Label == 0 || File->Label == 0)
+           continue;
+
+        if (strcmp(File.Label(),File2.Label()) != 0)
+           continue;
+        
+        if (File2->Version == File->Version)
+        {
+           Seen = true;
+           break;
+        }
+        if (File2->Version == 0)
+           break;
+        if (strcmp(File.Version(),File2.Version()) == 0)
+           Seen = true;
+      }
+      
+      if (Seen == true)
+        continue;
+      
+      if (First == false)
+        Res += ", ";
+      else
+        First = false;
+      
+      if (File->Label != 0)
+        Res = Res + File.Label() + ':';
+
+      if (File->Archive != 0)
+      {
+        if (File->Version == 0)
+           Res += File.Archive();
+        else
+           Res = Res + File.Version() + '/' +  File.Archive();
+      }
+      else
+      {
+        // No release file, print the host name that this came from
+        if (File->Site == 0 || File.Site()[0] == 0)
+           Res += "localhost";
+        else
+           Res += File.Site();
+      }      
+   }   
+   return Res;
+}
+                                                                       /*}}}*/

 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file        /*{{{*/
 // ---------------------------------------------------------------------
 /* This stats the file and compares its stats with the ones that were
 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file        /*{{{*/
 // ---------------------------------------------------------------------
 /* This stats the file and compares its stats with the ones that were