bunch of micro-optimizations for depcache

DepCache functions are called a lot, so if we can squeeze some drops out
of them for free we should do so. Takes also the opportunity to remove
some whitespace errors from these functions.

Git-Dch: Ignore

diff --git a/apt-pkg/deb/deblistparser.cc b/apt-pkg/deb/deblistparser.cc
index 4e49e1c78abf85cef98bd4ad5fafb98917b2e986..7c21bd8b373fd4ed6f81260aee984f5ea1174f33 100644 (file)
--- a/apt-pkg/deb/deblistparser.cc
+++ b/apt-pkg/deb/deblistparser.cc
@@ -209,23 +209,22 @@ bool debListParser::NewVersion(pkgCache::VerIterator &Ver)
         Ver->Priority = pkgCache::State::Extra;
    }
 
         Ver->Priority = pkgCache::State::Extra;
    }
 

-   if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
-      return false;

    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
       return false;
    if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
       return false;

-   if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
-      return false;
-   if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
+   if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)

       return false;
    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
       return false;
    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
       return false;
       return false;
    if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
       return false;
    if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false)
       return false;

+   if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
+      return false;
+   if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
+      return false;

    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
       return false;
    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
       return false;
    if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
       return false;
    if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false)
       return false;

-

    // Obsolete.
    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
       return false;
    // Obsolete.
    if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false)
       return false;

diff --git a/apt-pkg/deb/debversion.cc b/apt-pkg/deb/debversion.cc
index a5eacb7f50f2a9f0ae1876906b598d743f1d33c3..043025912ca41ad2a5079ae2620689934fb51559 100644 (file)
--- a/apt-pkg/deb/debversion.cc
+++ b/apt-pkg/deb/debversion.cc
@@ -34,29 +34,26 @@ debVersioningSystem::debVersioningSystem()
 
 // debVS::CmpFragment - Compare versions                               /*{{{*/
 // ---------------------------------------------------------------------
 
 // debVS::CmpFragment - Compare versions                               /*{{{*/
 // ---------------------------------------------------------------------

-/* This compares a fragment of the version. This is a slightly adapted 
-   version of what dpkg uses. */
-#define order(x) ((x) == '~' ? -1    \
-               : isdigit((x)) ? 0   \
-               : !(x) ? 0           \
-               : isalpha((x)) ? (x) \
-               : (x) + 256)
-int debVersioningSystem::CmpFragment(const char *A,const char *AEnd,
-                                    const char *B,const char *BEnd)
+/* This compares a fragment of the version. This is a slightly adapted
+   version of what dpkg uses in dpkg/lib/dpkg/version.c.
+   In particular, the a | b = NULL check is removed as we check this in the
+   caller, we use an explicit end for a | b strings and we check ~ explicit. */
+static int order(char c)

 {
 {

-   if (A >= AEnd && B >= BEnd)
+   if (isdigit(c))

       return 0;
       return 0;

-   if (A >= AEnd)
-   {
-      if (*B == '~') return 1;
+   else if (isalpha(c))
+      return c;
+   else if (c == '~')

       return -1;
       return -1;

-   }
-   if (B >= BEnd)
-   {
-      if (*A == '~') return -1;
-      return 1;
-   }
-
+   else if (c)
+      return c + 256;
+   else
+      return 0;
+}
+int debVersioningSystem::CmpFragment(const char *A,const char *AEnd,
+                                    const char *B,const char *BEnd)
+{

    /* Iterate over the whole string
       What this does is to split the whole string into groups of
       numeric and non numeric portions. For instance:
    /* Iterate over the whole string
       What this does is to split the whole string into groups of
       numeric and non numeric portions. For instance:


@@ -77,19 +74,19 @@ int debVersioningSystem::CmpFragment(const char *A,const char *AEnd,
         int rc = order(*rhs);
         if (vc != rc)
            return vc - rc;
         int rc = order(*rhs);
         if (vc != rc)
            return vc - rc;

-        lhs++; rhs++;
+        ++lhs; ++rhs;

       }
 
       while (*lhs == '0')
       }
 
       while (*lhs == '0')

-        lhs++;
+        ++lhs;

       while (*rhs == '0')
       while (*rhs == '0')

-        rhs++;
+        ++rhs;

       while (isdigit(*lhs) && isdigit(*rhs))
       {
         if (!first_diff)
            first_diff = *lhs - *rhs;
       while (isdigit(*lhs) && isdigit(*rhs))
       {
         if (!first_diff)
            first_diff = *lhs - *rhs;

-        lhs++;
-        rhs++;
+        ++lhs;
+        ++rhs;

       }
 
       if (isdigit(*lhs))
       }
 
       if (isdigit(*lhs))

diff --git a/apt-pkg/depcache.cc b/apt-pkg/depcache.cc
index 0e972dbad65fde202f98272a7045cb5883c35636..6271a024a4aa6c340c8bc518e7489537123382d5 100644 (file)
--- a/apt-pkg/depcache.cc
+++ b/apt-pkg/depcache.cc
@@ -95,7 +95,7 @@ pkgDepCache::ActionGroup::~ActionGroup()
 // DepCache::pkgDepCache - Constructors                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // DepCache::pkgDepCache - Constructors                                        /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-pkgDepCache::pkgDepCache(pkgCache *pCache,Policy *Plcy) :
+pkgDepCache::pkgDepCache(pkgCache * const pCache,Policy * const Plcy) :

   group_level(0), Cache(pCache), PkgState(0), DepState(0),
    iUsrSize(0), iDownloadSize(0), iInstCount(0), iDelCount(0), iKeepCount(0),
    iBrokenCount(0), iPolicyBrokenCount(0), iBadCount(0), d(NULL)
   group_level(0), Cache(pCache), PkgState(0), DepState(0),
    iUsrSize(0), iDownloadSize(0), iInstCount(0), iDelCount(0), iKeepCount(0),
    iBrokenCount(0), iPolicyBrokenCount(0), iBadCount(0), d(NULL)


@@ -121,7 +121,7 @@ pkgDepCache::~pkgDepCache()
 // DepCache::Init - Generate the initial extra structures.             /*{{{*/
 // ---------------------------------------------------------------------
 /* This allocats the extension buffers and initializes them. */
 // DepCache::Init - Generate the initial extra structures.             /*{{{*/
 // ---------------------------------------------------------------------
 /* This allocats the extension buffers and initializes them. */

-bool pkgDepCache::Init(OpProgress *Prog)
+bool pkgDepCache::Init(OpProgress * const Prog)

 {
    // Suppress mark updates during this operation (just in case) and
    // run a mark operation when Init terminates.
 {
    // Suppress mark updates during this operation (just in case) and
    // run a mark operation when Init terminates.


@@ -132,7 +132,7 @@ bool pkgDepCache::Init(OpProgress *Prog)
    PkgState = new StateCache[Head().PackageCount];
    DepState = new unsigned char[Head().DependsCount];
    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);
    PkgState = new StateCache[Head().PackageCount];
    DepState = new unsigned char[Head().DependsCount];
    memset(PkgState,0,sizeof(*PkgState)*Head().PackageCount);

-   memset(DepState,0,sizeof(*DepState)*Head().DependsCount); 
+   memset(DepState,0,sizeof(*DepState)*Head().DependsCount);

 
    if (Prog != 0)
    {
 
    if (Prog != 0)
    {


@@ -140,7 +140,7 @@ bool pkgDepCache::Init(OpProgress *Prog)
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
    }
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Candidate versions"));
    }

-   
+

    /* Set the current state of everything. In this state all of the
       packages are kept exactly as is. See AllUpgrade */
    int Done = 0;
    /* Set the current state of everything. In this state all of the
       packages are kept exactly as is. See AllUpgrade */
    int Done = 0;


@@ -148,7 +148,7 @@ bool pkgDepCache::Init(OpProgress *Prog)
    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);
    {
       if (Prog != 0 && Done%20 == 0)
         Prog->Progress(Done);

-      
+

       // Find the proper cache slot
       StateCache &State = PkgState[I->ID];
       State.iFlags = 0;
       // Find the proper cache slot
       StateCache &State = PkgState[I->ID];
       State.iFlags = 0;


@@ -157,28 +157,27 @@ bool pkgDepCache::Init(OpProgress *Prog)
       State.CandidateVer = GetCandidateVer(I);
       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;
       State.CandidateVer = GetCandidateVer(I);
       State.InstallVer = I.CurrentVer();
       State.Mode = ModeKeep;

-      
+

       State.Update(I,*this);
       State.Update(I,*this);

-   }   
-   
+   }
+

    if (Prog != 0)
    {
    if (Prog != 0)
    {

-      

       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
                            Head().PackageCount,
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
    }
       Prog->OverallProgress(Head().PackageCount,2*Head().PackageCount,
                            Head().PackageCount,
                            _("Building dependency tree"));
       Prog->SubProgress(Head().PackageCount,_("Dependency generation"));
    }

-   
+

    Update(Prog);
 
    if(Prog != 0)
       Prog->Done();
 
    return true;
    Update(Prog);
 
    if(Prog != 0)
       Prog->Done();
 
    return true;

-} 
+}

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

-bool pkgDepCache::readStateFile(OpProgress *Prog)                      /*{{{*/
+bool pkgDepCache::readStateFile(OpProgress * const Prog)               /*{{{*/

 {
    FileFd state_file;
    string const state = _config->FindFile("Dir::State::extended_states");
 {
    FileFd state_file;
    string const state = _config->FindFile("Dir::State::extended_states");


@@ -186,7 +185,7 @@ bool pkgDepCache::readStateFile(OpProgress *Prog)                   /*{{{*/
       state_file.Open(state, FileFd::ReadOnly);
       off_t const file_size = state_file.Size();
       if(Prog != NULL)
       state_file.Open(state, FileFd::ReadOnly);
       off_t const file_size = state_file.Size();
       if(Prog != NULL)

-        Prog->OverallProgress(0, file_size, 1, 
+        Prog->OverallProgress(0, file_size, 1,

                               _("Reading state information"));
 
       pkgTagFile tagfile(&state_file);
                               _("Reading state information"));
 
       pkgTagFile tagfile(&state_file);


@@ -230,7 +229,7 @@ bool pkgDepCache::readStateFile(OpProgress *Prog)                   /*{{{*/
    return true;
 }
                                                                        /*}}}*/
    return true;
 }
                                                                        /*}}}*/

-bool pkgDepCache::writeStateFile(OpProgress * /*prog*/, bool InstalledOnly)    /*{{{*/
+bool pkgDepCache::writeStateFile(OpProgress * const /*prog*/, bool const InstalledOnly)        /*{{{*/

 {
    bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
    
 {
    bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
    


@@ -340,7 +339,7 @@ bool pkgDepCache::writeStateFile(OpProgress * /*prog*/, bool InstalledOnly) /*{{
    then walks along the package provides list and checks if each provides 
    will be installed then checks the provides against the dep. Res will be 
    set to the package which was used to satisfy the dep. */
    then walks along the package provides list and checks if each provides 
    will be installed then checks the provides against the dep. Res will be 
    set to the package which was used to satisfy the dep. */

-bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
+bool pkgDepCache::CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Res)

 {
    Res = Dep.TargetPkg();
 
 {
    Res = Dep.TargetPkg();
 


@@ -351,22 +350,26 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
    {
       PkgIterator Pkg = Dep.TargetPkg();
       // Check the base package
    {
       PkgIterator Pkg = Dep.TargetPkg();
       // Check the base package

-      if (Type == NowVersion && Pkg->CurrentVer != 0)
-        if (Dep.IsSatisfied(Pkg.CurrentVer()) == true)
+      if (Type == NowVersion)
+      {
+        if (Pkg->CurrentVer != 0 && Dep.IsSatisfied(Pkg.CurrentVer()) == true)

            return true;
            return true;

-      
-      if (Type == InstallVersion && PkgState[Pkg->ID].InstallVer != 0)
-        if (Dep.IsSatisfied(PkgState[Pkg->ID].InstVerIter(*this)) == true)
+      }
+      else if (Type == InstallVersion)
+      {
+        if (PkgState[Pkg->ID].InstallVer != 0 &&
+              Dep.IsSatisfied(PkgState[Pkg->ID].InstVerIter(*this)) == true)

            return true;
            return true;

-      
-      if (Type == CandidateVersion && PkgState[Pkg->ID].CandidateVer != 0)
-        if (Dep.IsSatisfied(PkgState[Pkg->ID].CandidateVerIter(*this)) == true)
+      }
+      else if (Type == CandidateVersion)
+        if (PkgState[Pkg->ID].CandidateVer != 0 &&
+              Dep.IsSatisfied(PkgState[Pkg->ID].CandidateVerIter(*this)) == true)

            return true;
    }
            return true;
    }

-   
+

    if (Dep->Type == Dep::Obsoletes)
       return false;
    if (Dep->Type == Dep::Obsoletes)
       return false;

-   
+

    // Check the providing packages
    PrvIterator P = Dep.TargetPkg().ProvidesList();
    for (; P.end() != true; ++P)
    // Check the providing packages
    PrvIterator P = Dep.TargetPkg().ProvidesList();
    for (; P.end() != true; ++P)


@@ -380,21 +383,19 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
         if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
            continue;
       }
         if (P.OwnerPkg().CurrentVer() != P.OwnerVer())
            continue;
       }

-      
-      if (Type == InstallVersion)
+      else if (Type == InstallVersion)

       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.InstallVer != (Version *)P.OwnerVer())
            continue;
       }
       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.InstallVer != (Version *)P.OwnerVer())
            continue;
       }

-
-      if (Type == CandidateVersion)
+      else if (Type == CandidateVersion)

       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.CandidateVer != (Version *)P.OwnerVer())
            continue;
       }
       {
         StateCache &State = PkgState[P.OwnerPkg()->ID];
         if (State.CandidateVer != (Version *)P.OwnerVer())
            continue;
       }

-      
+

       // Compare the versions.
       if (Dep.IsSatisfied(P) == true)
       {
       // Compare the versions.
       if (Dep.IsSatisfied(P) == true)
       {


@@ -402,7 +403,7 @@ bool pkgDepCache::CheckDep(DepIterator Dep,int Type,PkgIterator &Res)
         return true;
       }
    }
         return true;
       }
    }

-   
+

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


@@ -484,47 +485,46 @@ void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert)
 {
    signed char const Add = (Invert == false) ? 1 : -1;
    StateCache &State = PkgState[Pkg->ID];
 {
    signed char const Add = (Invert == false) ? 1 : -1;
    StateCache &State = PkgState[Pkg->ID];

-   
+

    // The Package is broken (either minimal dep or policy dep)
    if ((State.DepState & DepInstMin) != DepInstMin)
       iBrokenCount += Add;
    if ((State.DepState & DepInstPolicy) != DepInstPolicy)
       iPolicyBrokenCount += Add;
    // The Package is broken (either minimal dep or policy dep)
    if ((State.DepState & DepInstMin) != DepInstMin)
       iBrokenCount += Add;
    if ((State.DepState & DepInstPolicy) != DepInstPolicy)
       iPolicyBrokenCount += Add;

-   
+

    // Bad state
    if (Pkg.State() != PkgIterator::NeedsNothing)
       iBadCount += Add;
    // Bad state
    if (Pkg.State() != PkgIterator::NeedsNothing)
       iBadCount += Add;

-   
+

    // Not installed
    if (Pkg->CurrentVer == 0)
    {
       if (State.Mode == ModeDelete &&
          (State.iFlags & Purge) == Purge && Pkg.Purge() == false)
         iDelCount += Add;
    // Not installed
    if (Pkg->CurrentVer == 0)
    {
       if (State.Mode == ModeDelete &&
          (State.iFlags & Purge) == Purge && Pkg.Purge() == false)
         iDelCount += Add;

-      
+

       if (State.Mode == ModeInstall)
         iInstCount += Add;
       return;
    }
       if (State.Mode == ModeInstall)
         iInstCount += Add;
       return;
    }

-   
+

    // Installed, no upgrade
    if (State.Status == 0)
    // Installed, no upgrade
    if (State.Status == 0)

-   {    
+   {

       if (State.Mode == ModeDelete)
         iDelCount += Add;
       else
         if ((State.iFlags & ReInstall) == ReInstall)
            iInstCount += Add;
       if (State.Mode == ModeDelete)
         iDelCount += Add;
       else
         if ((State.iFlags & ReInstall) == ReInstall)
            iInstCount += Add;

-      

       return;
    }
       return;
    }

-   
+

    // Alll 3 are possible
    if (State.Mode == ModeDelete)
    // Alll 3 are possible
    if (State.Mode == ModeDelete)

-      iDelCount += Add;   
-   if (State.Mode == ModeKeep)
+      iDelCount += Add;
+   else if (State.Mode == ModeKeep)

       iKeepCount += Add;
       iKeepCount += Add;

-   if (State.Mode == ModeInstall)
+   else if (State.Mode == ModeInstall)

       iInstCount += Add;
 }
                                                                        /*}}}*/
       iInstCount += Add;
 }
                                                                        /*}}}*/


@@ -535,7 +535,6 @@ void pkgDepCache::AddStates(const PkgIterator &Pkg, bool const Invert)
 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 {
    unsigned char Group = 0;
 void pkgDepCache::BuildGroupOrs(VerIterator const &V)
 {
    unsigned char Group = 0;

-   

    for (DepIterator D = V.DependsList(); D.end() != true; ++D)
    {
       // Build the dependency state.
    for (DepIterator D = V.DependsList(); D.end() != true; ++D)
    {
       // Build the dependency state.


@@ -545,18 +544,18 @@ void pkgDepCache::BuildGroupOrs(VerIterator const &V)
          right sense for a conflicts group */
       if (D.IsNegative() == true)
         State = ~State;
          right sense for a conflicts group */
       if (D.IsNegative() == true)
         State = ~State;

-      
+

       // Add to the group if we are within an or..
       State &= 0x7;
       Group |= State;
       State |= Group << 3;
       if ((D->CompareOp & Dep::Or) != Dep::Or)
         Group = 0;
       // Add to the group if we are within an or..
       State &= 0x7;
       Group |= State;
       State |= Group << 3;
       if ((D->CompareOp & Dep::Or) != Dep::Or)
         Group = 0;

-      
+

       // Invert for Conflicts
       if (D.IsNegative() == true)
         State = ~State;
       // Invert for Conflicts
       if (D.IsNegative() == true)
         State = ~State;

-   }    
+   }

 }
                                                                        /*}}}*/
 // DepCache::VersionState - Perform a pass over a dependency list      /*{{{*/
 }
                                                                        /*}}}*/
 // DepCache::VersionState - Perform a pass over a dependency list      /*{{{*/


@@ -565,34 +564,31 @@ void pkgDepCache::BuildGroupOrs(VerIterator const &V)
    state of the list, filtering it through both a Min check and a Policy
    check. The return result will have SetMin/SetPolicy low if a check
    fails. It uses the DepState cache for it's computations. */
    state of the list, filtering it through both a Min check and a Policy
    check. The return result will have SetMin/SetPolicy low if a check
    fails. It uses the DepState cache for it's computations. */

-unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
-                                      unsigned char SetMin,
-                                      unsigned char SetPolicy)
+unsigned char pkgDepCache::VersionState(DepIterator D, unsigned char const Check,
+                                      unsigned char const SetMin,
+                                      unsigned char const SetPolicy) const

 {
    unsigned char Dep = 0xFF;
 {
    unsigned char Dep = 0xFF;

-   

    while (D.end() != true)
    {
    while (D.end() != true)
    {

-      // Compute a single dependency element (glob or)
-      DepIterator Start = D;
-      unsigned char State = 0;
-      for (bool LastOR = true; D.end() == false && LastOR == true; ++D)
-      {
-        State |= DepState[D->ID];
-        LastOR = (D->CompareOp & Dep::Or) == Dep::Or;
-      }
-       
+      // the last or-dependency has the state of all previous or'ed
+      DepIterator Start, End;
+      D.GlobOr(Start, End);
+      // ignore if we are called with Dep{Install,…} or DepG{Install,…}
+      // the later would be more correct, but the first is what we get
+      unsigned char const State = DepState[End->ID] | (DepState[End->ID] >> 3);
+

       // Minimum deps that must be satisfied to have a working package
       if (Start.IsCritical() == true)
       // Minimum deps that must be satisfied to have a working package
       if (Start.IsCritical() == true)

+      {

         if ((State & Check) != Check)
         if ((State & Check) != Check)

-           Dep &= ~SetMin;
-      
+           return Dep &= ~(SetMin | SetPolicy);
+      }

       // Policy deps that must be satisfied to install the package
       // Policy deps that must be satisfied to install the package

-      if (IsImportantDep(Start) == true && 
+      else if (IsImportantDep(Start) == true &&

          (State & Check) != Check)
         Dep &= ~SetPolicy;
    }
          (State & Check) != Check)
         Dep &= ~SetPolicy;
    }

-

    return Dep;
 }
                                                                        /*}}}*/
    return Dep;
 }
                                                                        /*}}}*/


@@ -601,17 +597,17 @@ unsigned char pkgDepCache::VersionState(DepIterator D,unsigned char Check,
 /* This is the main dependency computation bit. It computes the 3 main
    results for a dependencys, Now, Install and Candidate. Callers must
    invert the result if dealing with conflicts. */
 /* This is the main dependency computation bit. It computes the 3 main
    results for a dependencys, Now, Install and Candidate. Callers must
    invert the result if dealing with conflicts. */

-unsigned char pkgDepCache::DependencyState(DepIterator &D)
+unsigned char pkgDepCache::DependencyState(DepIterator const &D)

 {
    unsigned char State = 0;
 {
    unsigned char State = 0;

-   
+

    if (CheckDep(D,NowVersion) == true)
       State |= DepNow;
    if (CheckDep(D,InstallVersion) == true)
       State |= DepInstall;
    if (CheckDep(D,CandidateVersion) == true)
       State |= DepCVer;
    if (CheckDep(D,NowVersion) == true)
       State |= DepNow;
    if (CheckDep(D,InstallVersion) == true)
       State |= DepInstall;
    if (CheckDep(D,CandidateVersion) == true)
       State |= DepCVer;

-   
+

    return State;
 }
                                                                        /*}}}*/
    return State;
 }
                                                                        /*}}}*/


@@ -620,7 +616,7 @@ unsigned char pkgDepCache::DependencyState(DepIterator &D)
 /* This determines the combined dependency representation of a package
    for its two states now and install. This is done by using the pre-generated
    dependency information. */
 /* This determines the combined dependency representation of a package
    for its two states now and install. This is done by using the pre-generated
    dependency information. */

-void pkgDepCache::UpdateVerState(PkgIterator Pkg)
+void pkgDepCache::UpdateVerState(PkgIterator const &Pkg)

 {   
    // Empty deps are always true
    StateCache &State = PkgState[Pkg->ID];
 {   
    // Empty deps are always true
    StateCache &State = PkgState[Pkg->ID];


@@ -654,7 +650,7 @@ void pkgDepCache::UpdateVerState(PkgIterator Pkg)
 // ---------------------------------------------------------------------
 /* This will figure out the state of all the packages and all the 
    dependencies based on the current policy. */
 // ---------------------------------------------------------------------
 /* This will figure out the state of all the packages and all the 
    dependencies based on the current policy. */

-void pkgDepCache::Update(OpProgress *Prog)
+void pkgDepCache::Update(OpProgress * const Prog)

 {   
    iUsrSize = 0;
    iDownloadSize = 0;
 {   
    iUsrSize = 0;
    iDownloadSize = 0;


@@ -1655,10 +1651,10 @@ const char *pkgDepCache::StateCache::StripEpoch(const char *Ver)
       return 0;
 
    // Strip any epoch
       return 0;
 
    // Strip any epoch

-   for (const char *I = Ver; *I != 0; I++)
-      if (*I == ':')
-        return I + 1;
-   return Ver;
+   char const * const I = strchr(Ver, ':');
+   if (I == nullptr)
+      return Ver;
+   return I + 1;

 }
                                                                        /*}}}*/
 // Policy::GetCandidateVer - Returns the Candidate install version     /*{{{*/
 }
                                                                        /*}}}*/
 // Policy::GetCandidateVer - Returns the Candidate install version     /*{{{*/


@@ -1701,17 +1697,17 @@ pkgCache::VerIterator pkgDepCache::Policy::GetCandidateVer(PkgIterator const &Pk
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // Policy::IsImportantDep - True if the dependency is important                /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep)
+bool pkgDepCache::Policy::IsImportantDep(DepIterator const &Dep) const

 {
    if(Dep.IsCritical())
       return true;
 {
    if(Dep.IsCritical())
       return true;

-   else if(Dep->Type == pkgCache::Dep::Recommends) 
+   else if(Dep->Type == pkgCache::Dep::Recommends)

    {
       if (InstallRecommends)
         return true;
       // we suport a special mode to only install-recommends for certain
       // sections
    {
       if (InstallRecommends)
         return true;
       // we suport a special mode to only install-recommends for certain
       // sections

-      // FIXME: this is a meant as a temporarly solution until the 
+      // FIXME: this is a meant as a temporarly solution until the

       //        recommends are cleaned up
       const char *sec = Dep.ParentVer().Section();
       if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec))
       //        recommends are cleaned up
       const char *sec = Dep.ParentVer().Section();
       if (sec && ConfigValueInSubTree("APT::Install-Recommends-Sections", sec))


@@ -1757,24 +1753,22 @@ bool pkgDepCache::MarkRequired(InRootSetFunc &userFunc)
    if (_config->Find("APT::Solver", "internal") != "internal")
       return true;
 
    if (_config->Find("APT::Solver", "internal") != "internal")
       return true;
 

-   bool follow_recommends;
-   bool follow_suggests;
-   bool debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);
+   bool const debug_autoremove = _config->FindB("Debug::pkgAutoRemove",false);

 
    // init the states
 
    // init the states

-   for(PkgIterator p = PkgBegin(); !p.end(); ++p)
+   map_id_t const PackagesCount = Head().PackageCount;
+   for(map_id_t i = 0; i < PackagesCount; ++i)

    {
    {

-      PkgState[p->ID].Marked  = false;
-      PkgState[p->ID].Garbage = false;
-
-      // debug output
-      if(debug_autoremove && PkgState[p->ID].Flags & Flag::Auto)
-        std::clog << "AutoDep: " << p.FullName() << std::endl;
+      PkgState[i].Marked  = false;
+      PkgState[i].Garbage = false;

    }
    }

+   if (debug_autoremove)
+      for(PkgIterator p = PkgBegin(); !p.end(); ++p)
+        if(PkgState[p->ID].Flags & Flag::Auto)
+           std::clog << "AutoDep: " << p.FullName() << std::endl;

 
 

-   // init vars
-   follow_recommends = MarkFollowsRecommends();
-   follow_suggests   = MarkFollowsSuggests();
+   bool const follow_recommends = MarkFollowsRecommends();
+   bool const follow_suggests   = MarkFollowsSuggests();

 
    // do the mark part, this is the core bit of the algorithm
    for(PkgIterator p = PkgBegin(); !p.end(); ++p)
 
    // do the mark part, this is the core bit of the algorithm
    for(PkgIterator p = PkgBegin(); !p.end(); ++p)

diff --git a/apt-pkg/depcache.h b/apt-pkg/depcache.h
index 2c3304ba8f82ac50877cf6da46364fbbb14e1121..aa281f695c0de1699bbdf1b2f3050ceab9f513f4 100644 (file)
--- a/apt-pkg/depcache.h
+++ b/apt-pkg/depcache.h
@@ -267,7 +267,7 @@ class pkgDepCache : protected pkgCache::Namespace
    
    // Helper functions
    void BuildGroupOrs(VerIterator const &V);
    
    // Helper functions
    void BuildGroupOrs(VerIterator const &V);

-   void UpdateVerState(PkgIterator Pkg);
+   void UpdateVerState(PkgIterator const &Pkg);

 
    // User Policy control
    class Policy
 
    // User Policy control
    class Policy


@@ -279,7 +279,7 @@ class pkgDepCache : protected pkgCache::Namespace
       }
 
       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);
       }
 
       virtual VerIterator GetCandidateVer(PkgIterator const &Pkg);

-      virtual bool IsImportantDep(DepIterator const &Dep);
+      virtual bool IsImportantDep(DepIterator const &Dep) const;

       virtual signed short GetPriority(PkgIterator const &Pkg);
       virtual signed short GetPriority(PkgFileIterator const &File);
 
       virtual signed short GetPriority(PkgIterator const &Pkg);
       virtual signed short GetPriority(PkgFileIterator const &File);
 


@@ -323,18 +323,18 @@ class pkgDepCache : protected pkgCache::Namespace
    Policy *LocalPolicy;
    
    // Check for a matching provides
    Policy *LocalPolicy;
    
    // Check for a matching provides

-   bool CheckDep(DepIterator Dep,int Type,PkgIterator &Res);
-   inline bool CheckDep(DepIterator Dep,int Type)
+   bool CheckDep(DepIterator const &Dep,int const Type,PkgIterator &Res);
+   inline bool CheckDep(DepIterator const &Dep,int const Type)

    {
       PkgIterator Res(*this,0);
       return CheckDep(Dep,Type,Res);
    }
    
    // Computes state information for deps and versions (w/o storing)
    {
       PkgIterator Res(*this,0);
       return CheckDep(Dep,Type,Res);
    }
    
    // Computes state information for deps and versions (w/o storing)

-   unsigned char DependencyState(DepIterator &D);
-   unsigned char VersionState(DepIterator D,unsigned char Check,
-                             unsigned char SetMin,
-                             unsigned char SetPolicy);
+   unsigned char DependencyState(DepIterator const &D);
+   unsigned char VersionState(DepIterator D,unsigned char const Check,
+                             unsigned char const SetMin,
+                             unsigned char const SetPolicy) const;

 
    // Recalculates various portions of the cache, call after changing something
    void Update(DepIterator Dep);           // Mostly internal
 
    // Recalculates various portions of the cache, call after changing something
    void Update(DepIterator Dep);           // Mostly internal


@@ -362,7 +362,7 @@ class pkgDepCache : protected pkgCache::Namespace
    
    // Policy implementation
    inline VerIterator GetCandidateVer(PkgIterator const &Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};
    
    // Policy implementation
    inline VerIterator GetCandidateVer(PkgIterator const &Pkg) {return LocalPolicy->GetCandidateVer(Pkg);};

-   inline bool IsImportantDep(DepIterator Dep) {return LocalPolicy->IsImportantDep(Dep);};
+   inline bool IsImportantDep(DepIterator Dep) const {return LocalPolicy->IsImportantDep(Dep);};

    inline Policy &GetPolicy() {return *LocalPolicy;};
    
    // Accessors
    inline Policy &GetPolicy() {return *LocalPolicy;};
    
    // Accessors


@@ -471,8 +471,8 @@ class pkgDepCache : protected pkgCache::Namespace
                            unsigned long Depth = 0, bool FromUser = true);
 
    // read persistent states
                            unsigned long Depth = 0, bool FromUser = true);
 
    // read persistent states

-   bool readStateFile(OpProgress *prog);
-   bool writeStateFile(OpProgress *prog, bool InstalledOnly=true);
+   bool readStateFile(OpProgress * const prog);
+   bool writeStateFile(OpProgress * const prog, bool const InstalledOnly=true);

    
    // Size queries
    inline signed long long UsrSize() {return iUsrSize;};
    
    // Size queries
    inline signed long long UsrSize() {return iUsrSize;};


@@ -484,11 +484,11 @@ class pkgDepCache : protected pkgCache::Namespace
    inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
    inline unsigned long BadCount() {return iBadCount;};
 
    inline unsigned long PolicyBrokenCount() {return iPolicyBrokenCount;};
    inline unsigned long BadCount() {return iBadCount;};
 

-   bool Init(OpProgress *Prog);
+   bool Init(OpProgress * const Prog);

    // Generate all state information
    // Generate all state information

-   void Update(OpProgress *Prog = 0);
+   void Update(OpProgress * const Prog = 0);

 
 

-   pkgDepCache(pkgCache *Cache,Policy *Plcy = 0);
+   pkgDepCache(pkgCache * const Cache,Policy * const Plcy = 0);

    virtual ~pkgDepCache();
 
    protected:
    virtual ~pkgDepCache();
 
    protected:

diff --git a/apt-pkg/pkgcache.cc b/apt-pkg/pkgcache.cc
index aebbffe8b3ce9327c054b4528f2fec7e47e6eb36..897f1ee2a02d7fdf814c8c32a7402084c90ae261 100644 (file)
--- a/apt-pkg/pkgcache.cc
+++ b/apt-pkg/pkgcache.cc
@@ -697,29 +697,34 @@ void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
 // ---------------------------------------------------------------------
 /* Deps like self-conflicts should be ignored as well as implicit conflicts
    on virtual packages. */
 // ---------------------------------------------------------------------
 /* Deps like self-conflicts should be ignored as well as implicit conflicts
    on virtual packages. */

-bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &/*Pkg*/) const
+bool pkgCache::DepIterator::IsIgnorable(PkgIterator const &PT) const

 {
    if (IsNegative() == false)
       return false;
 
 {
    if (IsNegative() == false)
       return false;
 

-   pkgCache::PkgIterator PP = ParentPkg();
-   pkgCache::PkgIterator PT = TargetPkg();
+   pkgCache::PkgIterator const PP = ParentPkg();

    if (PP->Group != PT->Group)
       return false;
    // self-conflict
    if (PP == PT)
       return true;
    if (PP->Group != PT->Group)
       return false;
    // self-conflict
    if (PP == PT)
       return true;

-   pkgCache::VerIterator PV = ParentVer();
+   pkgCache::VerIterator const PV = ParentVer();

    // ignore group-conflict on a M-A:same package - but not our implicit dependencies
    // so that we can have M-A:same packages conflicting with their own real name
    if ((PV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
    {
       // Replaces: ${self}:other ( << ${binary:Version})
    // ignore group-conflict on a M-A:same package - but not our implicit dependencies
    // so that we can have M-A:same packages conflicting with their own real name
    if ((PV->MultiArch & pkgCache::Version::Same) == pkgCache::Version::Same)
    {
       // Replaces: ${self}:other ( << ${binary:Version})

-      if (S->Type == pkgCache::Dep::Replaces && S->CompareOp == pkgCache::Dep::Less && strcmp(PV.VerStr(), TargetVer()) == 0)
-        return false;
+      if (S->Type == pkgCache::Dep::Replaces)
+      {
+        if (S->CompareOp == pkgCache::Dep::Less && strcmp(PV.VerStr(), TargetVer()) == 0)
+           return false;
+      }

       // Breaks: ${self}:other (!= ${binary:Version})
       // Breaks: ${self}:other (!= ${binary:Version})

-      if (S->Type == pkgCache::Dep::DpkgBreaks && S->CompareOp == pkgCache::Dep::NotEquals && strcmp(PV.VerStr(), TargetVer()) == 0)
-        return false;
+      else if (S->Type == pkgCache::Dep::DpkgBreaks)
+      {
+        if (S->CompareOp == pkgCache::Dep::NotEquals && strcmp(PV.VerStr(), TargetVer()) == 0)
+           return false;
+      }

       return true;
    }
 
       return true;
    }
 

diff --git a/test/integration/test-apt-cache b/test/integration/test-apt-cache
index 97dc0f9393da8887f5ee26913aed0ac4b4059c39..7da2ab71ffd56c9351383f29985d45a6d4712d8f 100755 (executable)
--- a/test/integration/test-apt-cache
+++ b/test/integration/test-apt-cache
@@ -56,21 +56,21 @@ testsuccessequal "       foo |          1 | file:$(readlink -f .)/aptarchive uns
 
 testsuccessequal 'foo
   Depends: bar
 
 testsuccessequal 'foo
   Depends: bar

- |Recommends: <cool>
-  Recommends: <cooler>

   Conflicts: <foobar>
   Conflicts: <foobar>

-  Conflicts: <foobar:i386>' aptcache depends foo
+  Conflicts: <foobar:i386>
+ |Recommends: <cool>
+  Recommends: <cooler>' aptcache depends foo

 testsuccessequal 'foo
   Depends: bar
 testsuccessequal 'foo
   Depends: bar

-  Recommends: <cool>

   Conflicts: <foobar>
   Conflicts: <foobar>

-  Conflicts: <foobar:i386>' aptcache depends foo -o APT::Cache::ShowOnlyFirstOr=1
+  Conflicts: <foobar:i386>
+  Recommends: <cool>' aptcache depends foo -o APT::Cache::ShowOnlyFirstOr=1

 testsuccessequal 'foo
   Depends: bar
 testsuccessequal 'foo
   Depends: bar

- |Recommends: <cool> (>= 2)
-  Recommends: <cooler> (<< 5)

   Conflicts: <foobar>
   Conflicts: <foobar>

-  Conflicts: <foobar:i386>' aptcache depends foo -o APT::Cache::ShowVersion=1
+  Conflicts: <foobar:i386>
+ |Recommends: <cool> (>= 2)
+  Recommends: <cooler> (<< 5)' aptcache depends foo -o APT::Cache::ShowVersion=1

 testsuccessequal 'foo
   Depends: bar
   Conflicts: <foobar>
 testsuccessequal 'foo
   Depends: bar
   Conflicts: <foobar>


@@ -82,20 +82,20 @@ testsuccessequal 'foo
   Conflicts: <foobar:i386>' aptcache depends foo --important --no-depends --conflicts
 testsuccessequal 'foo
   Depends: bar
   Conflicts: <foobar:i386>' aptcache depends foo --important --no-depends --conflicts
 testsuccessequal 'foo
   Depends: bar

- |Recommends: <cool>
-  Recommends: <cooler>

   Conflicts: <foobar>
   Conflicts: <foobar:i386>
   Conflicts: <foobar>
   Conflicts: <foobar:i386>

+ |Recommends: <cool>
+  Recommends: <cooler>

 bar
   Depends: bar
   Breaks: foo
   Breaks: <foo:i386>
   Replaces: foo
   Replaces: <foo:i386>
 bar
   Depends: bar
   Breaks: foo
   Breaks: <foo:i386>
   Replaces: foo
   Replaces: <foo:i386>

-<cool>
-<cooler>

 <foobar>
 <foobar:i386>
 <foobar>
 <foobar:i386>

+<cool>
+<cooler>

 <foo:i386>' aptcache depends foo --recurse
 testsuccessequal 'foo
   Depends: bar
 <foo:i386>' aptcache depends foo --recurse
 testsuccessequal 'foo
   Depends: bar

diff --git a/test/integration/test-apt-showlist-orgroup-in-recommends b/test/integration/test-apt-showlist-orgroup-in-recommends
index bce421ac4ee41871fff64b0ee5a0ab5fdf910115..929f7feb9cfa6e17bbed851ea824d98c84492cfe 100755 (executable)
--- a/test/integration/test-apt-showlist-orgroup-in-recommends
+++ b/test/integration/test-apt-showlist-orgroup-in-recommends
@@ -13,7 +13,7 @@ insertinstalledpackage 'ddd' 'all' '1'
 insertpackage 'unstable' 'aaa' 'all' '1'
 insertpackage 'unstable' 'ddd' 'all' '1'
 insertpackage 'unstable' 'yyy' 'all' '1'
 insertpackage 'unstable' 'aaa' 'all' '1'
 insertpackage 'unstable' 'ddd' 'all' '1'
 insertpackage 'unstable' 'yyy' 'all' '1'

-insertpackage 'unstable' 'zzz' 'all' '1'
+insertpackage 'unstable' 'zzz' 'all' '1:1'

 insertpackage 'unstable' 'simple' 'all' '1' 'Recommends: aaa, bbb
 Suggests: ccc, ddd'
 insertpackage 'unstable' 'orgroup' 'all' '1' 'Recommends: aaa | bbb
 insertpackage 'unstable' 'simple' 'all' '1' 'Recommends: aaa, bbb
 Suggests: ccc, ddd'
 insertpackage 'unstable' 'orgroup' 'all' '1' 'Recommends: aaa | bbb