summaryrefslogtreecommitdiff
path: root/apt-pkg
diff options
context:
space:
mode:
Diffstat (limited to 'apt-pkg')
-rw-r--r--apt-pkg/solver3.cc76
-rw-r--r--apt-pkg/solver3.h44
2 files changed, 60 insertions, 60 deletions
diff --git a/apt-pkg/solver3.cc b/apt-pkg/solver3.cc
index c18420d71..5065b9a87 100644
--- a/apt-pkg/solver3.cc
+++ b/apt-pkg/solver3.cc
@@ -170,8 +170,8 @@ APT::Solver::Solver(pkgCache &cache, pkgDepCache::Policy &policy)
pkgObsolete(cache.Head().PackageCount)
{
static_assert(sizeof(APT::Solver::State) == 3 * sizeof(int));
- static_assert(sizeof(APT::Solver::Reason) == sizeof(map_pointer<pkgCache::Package>));
- static_assert(sizeof(APT::Solver::Reason) == sizeof(map_pointer<pkgCache::Version>));
+ static_assert(sizeof(APT::Solver::Var) == sizeof(map_pointer<pkgCache::Package>));
+ static_assert(sizeof(APT::Solver::Var) == sizeof(map_pointer<pkgCache::Version>));
}
// This function determines if a work item is less important than another.
@@ -214,7 +214,7 @@ void APT::Solver::Work::Dump(pkgCache &cache)
}
// Prints an implication graph part of the form A -> B -> C, possibly with "not"
-std::string APT::Solver::WhyStr(Reason reason)
+std::string APT::Solver::WhyStr(Var reason)
{
std::vector<std::string> out;
@@ -305,14 +305,14 @@ bool APT::Solver::Obsolete(pkgCache::PkgIterator pkg) const
return true;
}
-bool APT::Solver::Install(pkgCache::PkgIterator Pkg, Reason reason, Group group)
+bool APT::Solver::Install(pkgCache::PkgIterator Pkg, Var reason, Group group)
{
if ((*this)[Pkg].decision == Decision::MUST)
return true;
// Check conflicting selections
if ((*this)[Pkg].decision == Decision::MUSTNOT)
- return _error->Error("Conflict: %s -> %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Reason(Pkg)).c_str());
+ return _error->Error("Conflict: %s -> %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Var(Pkg)).c_str());
bool anyInstallable = false;
for (auto ver = Pkg.VersionList(); not ver.end(); ver++)
@@ -324,7 +324,7 @@ bool APT::Solver::Install(pkgCache::PkgIterator Pkg, Reason reason, Group group)
_error->Error("Conflict: %s -> %s but no versions are installable",
WhyStr(reason).c_str(), Pkg.FullName().c_str());
for (auto ver = Pkg.VersionList(); not ver.end(); ver++)
- _error->Error("Uninstallable version: %s", WhyStr(Reason(ver)).c_str());
+ _error->Error("Uninstallable version: %s", WhyStr(Var(ver)).c_str());
return false;
}
@@ -332,10 +332,10 @@ bool APT::Solver::Install(pkgCache::PkgIterator Pkg, Reason reason, Group group)
if (unlikely(debug >= 1))
std::cerr << "[" << depth() << "] Install:" << Pkg.FullName() << " (" << WhyStr(reason) << ")\n";
(*this)[Pkg] = {reason, depth(), Decision::MUST};
- solved.push_back(Solved{Reason(Pkg), std::nullopt});
+ solved.push_back(Solved{Var(Pkg), std::nullopt});
// Insert the work item.
- Work workItem{Reason(Pkg), depth(), group};
+ Work workItem{Var(Pkg), depth(), group};
for (auto ver = Pkg.VersionList(); not ver.end(); ver++)
if (IsAllowedVersion(ver))
workItem.solutions.push_back(ver);
@@ -353,7 +353,7 @@ bool APT::Solver::Install(pkgCache::PkgIterator Pkg, Reason reason, Group group)
return true;
}
-bool APT::Solver::Install(pkgCache::VerIterator Ver, Reason reason, Group group)
+bool APT::Solver::Install(pkgCache::VerIterator Ver, Var reason, Group group)
{
if ((*this)[Ver].decision == Decision::MUST)
return true;
@@ -366,33 +366,33 @@ bool APT::Solver::Install(pkgCache::VerIterator Ver, Reason reason, Group group)
return _error->Error("Conflict: %s -> %s but %s",
WhyStr(reason).c_str(),
(Ver.ParentPkg().FullName() + "=" + Ver.VerStr()).c_str(),
- WhyStr(Reason(Ver)).c_str());
+ WhyStr(Var(Ver)).c_str());
if ((*this)[Ver.ParentPkg()].decision == Decision::MUSTNOT)
return _error->Error("Conflict: %s -> %s but %s",
WhyStr(reason).c_str(),
(Ver.ParentPkg().FullName() + "=" + Ver.VerStr()).c_str(),
- WhyStr(Reason(Ver.ParentPkg())).c_str());
+ WhyStr(Var(Ver.ParentPkg())).c_str());
for (auto otherVer = Ver.ParentPkg().VersionList(); not otherVer.end(); otherVer++)
if (otherVer->ID != Ver->ID && (*this)[otherVer].decision == Decision::MUST)
return _error->Error("Conflict: %s -> %s but %s",
WhyStr(reason).c_str(),
(Ver.ParentPkg().FullName() + "=" + Ver.VerStr()).c_str(),
- WhyStr(Reason(otherVer)).c_str());
+ WhyStr(Var(otherVer)).c_str());
// Note decision
if (unlikely(debug >= 1))
std::cerr << "[" << depth() << "] Install:" << Ver.ParentPkg().FullName() << "=" << Ver.VerStr() << " (" << WhyStr(reason) << ")\n";
(*this)[Ver] = {reason, depth(), Decision::MUST};
- solved.push_back(Solved{Reason(Ver), std::nullopt});
+ solved.push_back(Solved{Var(Ver), std::nullopt});
if ((*this)[Ver.ParentPkg()].decision != Decision::MUST)
{
- (*this)[Ver.ParentPkg()] = {Reason(Ver), depth(), Decision::MUST};
- solved.push_back(Solved{Reason(Ver.ParentPkg()), std::nullopt});
+ (*this)[Ver.ParentPkg()] = {Var(Ver), depth(), Decision::MUST};
+ solved.push_back(Solved{Var(Ver.ParentPkg()), std::nullopt});
}
for (auto OV = Ver.ParentPkg().VersionList(); not OV.end(); ++OV)
{
- if (OV != Ver && not Reject(OV, Reason(Ver), group))
+ if (OV != Ver && not Reject(OV, Var(Ver), group))
return false;
}
@@ -403,14 +403,14 @@ bool APT::Solver::Install(pkgCache::VerIterator Ver, Reason reason, Group group)
pkgCache::DepIterator end;
dep.GlobOr(start, end); // advances dep
- if (not EnqueueOrGroup(start, end, Reason(Ver)))
+ if (not EnqueueOrGroup(start, end, Var(Ver)))
return false;
}
return true;
}
-bool APT::Solver::Reject(pkgCache::PkgIterator Pkg, Reason reason, Group group)
+bool APT::Solver::Reject(pkgCache::PkgIterator Pkg, Var reason, Group group)
{
if ((*this)[Pkg].decision == Decision::MUSTNOT)
return true;
@@ -418,17 +418,17 @@ bool APT::Solver::Reject(pkgCache::PkgIterator Pkg, Reason reason, Group group)
// Check conflicting selections
for (auto ver = Pkg.VersionList(); not ver.end(); ver++)
if ((*this)[ver].decision == Decision::MUST)
- return _error->Error("Conflict: %s -> not %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Reason(ver)).c_str());
+ return _error->Error("Conflict: %s -> not %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Var(ver)).c_str());
if ((*this)[Pkg].decision == Decision::MUST)
- return _error->Error("Conflict: %s -> not %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Reason(Pkg)).c_str());
+ return _error->Error("Conflict: %s -> not %s but %s", WhyStr(reason).c_str(), Pkg.FullName().c_str(), WhyStr(Var(Pkg)).c_str());
// Reject the package and its versions.
if (unlikely(debug >= 1))
std::cerr << "[" << depth() << "] Reject:" << Pkg.FullName() << " (" << WhyStr(reason) << ")\n";
(*this)[Pkg] = {reason, depth(), Decision::MUSTNOT};
- solved.push_back(Solved{Reason(Pkg), std::nullopt});
+ solved.push_back(Solved{Var(Pkg), std::nullopt});
for (auto ver = Pkg.VersionList(); not ver.end(); ver++)
- if (not Reject(ver, Reason(Pkg), group))
+ if (not Reject(ver, Var(Pkg), group))
return false;
needsRescore = true;
@@ -437,7 +437,7 @@ bool APT::Solver::Reject(pkgCache::PkgIterator Pkg, Reason reason, Group group)
}
// \brief Do not install this version
-bool APT::Solver::Reject(pkgCache::VerIterator Ver, Reason reason, Group group)
+bool APT::Solver::Reject(pkgCache::VerIterator Ver, Var reason, Group group)
{
(void)group;
@@ -449,13 +449,13 @@ bool APT::Solver::Reject(pkgCache::VerIterator Ver, Reason reason, Group group)
return _error->Error("Conflict: %s -> not %s but %s",
WhyStr(reason).c_str(),
(Ver.ParentPkg().FullName() + "=" + Ver.VerStr()).c_str(),
- WhyStr(Reason(Ver)).c_str());
+ WhyStr(Var(Ver)).c_str());
// Mark the package as rejected and propagate up as needed.
if (unlikely(debug >= 1))
std::cerr << "[" << depth() << "] Reject:" << Ver.ParentPkg().FullName() << "=" << Ver.VerStr() << " (" << WhyStr(reason) << ")\n";
(*this)[Ver] = {reason, depth(), Decision::MUSTNOT};
- solved.push_back(Solved{Reason(Ver), std::nullopt});
+ solved.push_back(Solved{Var(Ver), std::nullopt});
if (auto pkg = Ver.ParentPkg(); (*this)[pkg].decision != Decision::MUSTNOT)
{
bool anyInstallable = false;
@@ -468,18 +468,18 @@ bool APT::Solver::Reject(pkgCache::VerIterator Ver, Reason reason, Group group)
else if ((*this)[pkg].decision == Decision::MUST) // Must install, but none available
{
_error->Error("Conflict: %s but no versions are installable",
- WhyStr(Reason(pkg)).c_str());
+ WhyStr(Var(pkg)).c_str());
for (auto otherVer = pkg.VersionList(); not otherVer.end(); otherVer++)
if ((*this)[otherVer].decision == Decision::MUSTNOT)
- _error->Error("Uninstallable version: %s", WhyStr(Reason(otherVer)).c_str());
+ _error->Error("Uninstallable version: %s", WhyStr(Var(otherVer)).c_str());
return _error->Error("Uninstallable version: %s -> not %s",
WhyStr(reason).c_str(),
(Ver.ParentPkg().FullName() + "=" + Ver.VerStr()).c_str());
}
else if ((*this)[Ver.ParentPkg()].decision != Decision::MUSTNOT) // Last installable invalidated
{
- (*this)[Ver.ParentPkg()] = {Reason(Ver), depth(), Decision::MUSTNOT};
- solved.push_back(Solved{Reason(Ver), std::nullopt});
+ (*this)[Ver.ParentPkg()] = {Var(Ver), depth(), Decision::MUSTNOT};
+ solved.push_back(Solved{Var(Ver), std::nullopt});
}
}
@@ -512,14 +512,14 @@ bool APT::Solver::EnqueueCommonDependencies(pkgCache::PkgIterator Pkg)
}
if (not allHaveDep)
continue;
- if (not EnqueueOrGroup(start, end, Reason(Pkg)))
+ if (not EnqueueOrGroup(start, end, Var(Pkg)))
return false;
}
return true;
}
-bool APT::Solver::EnqueueOrGroup(pkgCache::DepIterator start, pkgCache::DepIterator end, Reason reason)
+bool APT::Solver::EnqueueOrGroup(pkgCache::DepIterator start, pkgCache::DepIterator end, Var reason)
{
auto TgtPkg = start.TargetPkg();
auto Ver = start.ParentVer();
@@ -551,7 +551,7 @@ bool APT::Solver::EnqueueOrGroup(pkgCache::DepIterator start, pkgCache::DepItera
if (unlikely(debug >= 3))
std::cerr << "Reject: " << Ver.ParentPkg().FullName() << "=" << Ver.VerStr() << " -> " << tgti.ParentPkg().FullName() << "=" << tgti.VerStr() << "\n";
// FIXME: We should be collecting these and marking the heap only once.
- if (not Reject(pkgCache::VerIterator(cache, *tgt), Reason(Ver), Group::HoldOrDelete))
+ if (not Reject(pkgCache::VerIterator(cache, *tgt), Var(Ver), Group::HoldOrDelete))
return false;
}
else
@@ -713,7 +713,7 @@ bool APT::Solver::RejectReverseDependencies(pkgCache::VerIterator Ver)
if (unlikely(debug >= 3))
std::cerr << "Propagate NOT " << Ver.ParentPkg().FullName() << "=" << Ver.VerStr() << " to " << RDV.ParentPkg().FullName() << "=" << RDV.VerStr() << " for dependency group starting with" << start.TargetPkg().FullName() << std::endl;
- if (not Reject(RDV, Reason(Ver), Group::HoldOrDelete))
+ if (not Reject(RDV, Var(Ver), Group::HoldOrDelete))
return false;
}
return true;
@@ -740,7 +740,7 @@ void APT::Solver::Push(Work work)
}
choices.push_back(solved.size());
- solved.push_back(Solved{Reason(), std::move(work)});
+ solved.push_back(Solved{Var(), std::move(work)});
// Pop() will call MergeWithStack() when reverting to level 0, or RevertToStack after dumping to the debug log.
_error->PushToStack();
}
@@ -763,7 +763,7 @@ void APT::Solver::UndoOne()
}
auto &state = (*this)[solvedItem.assigned];
state.decision = Decision::NONE;
- state.reason = Reason();
+ state.reason = Var();
state.depth = 0;
}
@@ -894,7 +894,7 @@ bool APT::Solver::Solve()
auto item = std::move(work.back());
work.pop_back();
- solved.push_back(Solved{Reason(), item});
+ solved.push_back(Solved{Var(), item});
if (std::any_of(item.solutions.begin(), item.solutions.end(), [this](auto ver)
{ return (*this)[ver].decision == Decision::MUST; }))
@@ -949,7 +949,7 @@ bool APT::Solver::Solve()
if ((*this)[sol].decision == Decision::MUSTNOT)
_error->Error("Not considered: %s=%s: %s", pkgCache::VerIterator(cache, sol).ParentPkg().FullName().c_str(),
pkgCache::VerIterator(cache, sol).VerStr(),
- WhyStr(Reason(pkgCache::VerIterator(cache, sol))).c_str());
+ WhyStr(Var(pkgCache::VerIterator(cache, sol))).c_str());
if (not Pop())
return false;
}
@@ -1016,7 +1016,7 @@ bool APT::Solver::FromDepCache(pkgDepCache &depcache)
}
else
{
- Work w{Reason(), depth(), Group, isOptional, Upgrade};
+ Work w{Var(), depth(), Group, isOptional, Upgrade};
for (auto V = P.VersionList(); not V.end(); ++V)
if (IsAllowedVersion(V))
w.solutions.push_back(V);
diff --git a/apt-pkg/solver3.h b/apt-pkg/solver3.h
index eb8d246bf..b0ced904a 100644
--- a/apt-pkg/solver3.h
+++ b/apt-pkg/solver3.h
@@ -32,7 +32,7 @@ class Solver
{
enum class Decision : uint16_t;
enum class Hint : uint16_t;
- struct Reason;
+ struct Var;
struct CompareProviders3;
struct State;
struct Work;
@@ -105,7 +105,7 @@ class Solver
return verStates[V->ID];
}
// \brief Helper function for safe access to either state.
- inline State &operator[](Reason r);
+ inline State &operator[](Var r);
mutable std::vector<char> pkgObsolete;
bool Obsolete(pkgCache::PkgIterator pkg) const;
@@ -151,7 +151,7 @@ class Solver
// \brief Reject reverse dependencies. Must call std::make_heap() after.
bool RejectReverseDependencies(pkgCache::VerIterator Ver);
// \brief Enqueue a single or group
- bool EnqueueOrGroup(pkgCache::DepIterator start, pkgCache::DepIterator end, Reason reason);
+ bool EnqueueOrGroup(pkgCache::DepIterator start, pkgCache::DepIterator end, Var reason);
// \brief Check if a version is allowed by policy.
bool IsAllowedVersion(pkgCache::Version *V);
@@ -177,13 +177,13 @@ class Solver
Solver(pkgCache &Cache, pkgDepCache::Policy &Policy);
// \brief Mark the package for install. This is annoying as it incurs a decision
- bool Install(pkgCache::PkgIterator Pkg, Reason reason, Group group);
+ bool Install(pkgCache::PkgIterator Pkg, Var reason, Group group);
// \brief Install a version.
- bool Install(pkgCache::VerIterator Ver, Reason reason, Group group);
+ bool Install(pkgCache::VerIterator Ver, Var reason, Group group);
// \brief Do not install this package
- bool Reject(pkgCache::PkgIterator Pkg, Reason reason, Group group);
+ bool Reject(pkgCache::PkgIterator Pkg, Var reason, Group group);
// \brief Do not install this version.
- bool Reject(pkgCache::VerIterator Ver, Reason reason, Group group);
+ bool Reject(pkgCache::VerIterator Ver, Var reason, Group group);
// \brief Apply the selections from the dep cache to the solver
bool FromDepCache(pkgDepCache &depcache);
@@ -194,7 +194,7 @@ class Solver
bool Solve();
// Print dependency chain
- std::string WhyStr(Reason reason);
+ std::string WhyStr(Var reason);
};
}; // namespace APT
@@ -203,18 +203,18 @@ class Solver
* \brief Tagged union holding either a package, version, or nothing; representing the reason for installing something.
*
* We want to keep track of the reason why things are being installed such that
- * we can have sensible debugging abilities.
+ * we can have sensible debugging abilities; and we want to generically refer to
+ * both packages and versions as variables, hence this class was added.
*
- * If the reason is empty, this means the package is automatically installed.
*/
-struct APT::Solver::Reason
+struct APT::Solver::Var
{
uint32_t IsVersion : 1;
uint32_t MapPtr : 31;
- Reason() : IsVersion(0), MapPtr(0) {}
- explicit Reason(pkgCache::PkgIterator const &Pkg) : IsVersion(0), MapPtr(Pkg.MapPointer()) {}
- explicit Reason(pkgCache::VerIterator const &Ver) : IsVersion(1), MapPtr(Ver.MapPointer()) {}
+ Var() : IsVersion(0), MapPtr(0) {}
+ explicit Var(pkgCache::PkgIterator const &Pkg) : IsVersion(0), MapPtr(Pkg.MapPointer()) {}
+ explicit Var(pkgCache::VerIterator const &Ver) : IsVersion(1), MapPtr(Ver.MapPointer()) {}
// \brief Return the package, if any, otherwise 0.
map_pointer<pkgCache::Package> Pkg() const
@@ -255,8 +255,8 @@ struct APT::Solver::Reason
*/
struct APT::Solver::Work
{
- // \brief Reason for the work
- Reason reason;
+ // \brief Var for the work
+ Var reason;
// \brief The depth at which the item has been added
depth_type depth;
// \brief The group we are in
@@ -285,7 +285,7 @@ struct APT::Solver::Work
// \brief Dump the work item to std::cerr
void Dump(pkgCache &cache);
- inline Work(Reason reason, depth_type depth, Group group, bool optional = false, bool upgrade = false) : reason(reason), depth(depth), group(group), size(0), optional(optional), upgrade(upgrade), dirty(false) {}
+ inline Work(Var reason, depth_type depth, Group group, bool optional = false, bool upgrade = false) : reason(reason), depth(depth), group(group), size(0), optional(optional), upgrade(upgrade), dirty(false) {}
};
// \brief This essentially describes the install state in RFC2119 terms.
@@ -328,8 +328,8 @@ struct APT::Solver::State
// You can follow the reason chain upwards as long as the depth
// doesn't increase to unwind.
//
- // Reasons < 0 are package ID, reasons > 0 are version IDs.
- Reason reason{};
+ // Vars < 0 are package ID, reasons > 0 are version IDs.
+ Var reason{};
// \brief The depth at which the decision has been taken
depth_type depth{0};
@@ -349,13 +349,13 @@ struct APT::Solver::State
*/
struct APT::Solver::Solved
{
- // \brief A variable that has been assigned. We store this as a reason (FIXME: Rename Reason to Var)
- Reason assigned;
+ // \brief A variable that has been assigned. We store this as a reason (FIXME: Rename Var to Var)
+ Var assigned;
// \brief A work item that has been solved. This needs to be put back on the queue.
std::optional<Work> work;
};
-inline APT::Solver::State &APT::Solver::operator[](Reason r)
+inline APT::Solver::State &APT::Solver::operator[](Var r)
{
if (auto P = r.Pkg())
return (*this)[cache.PkgP + P];
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2026-07-18 18:33:29 +0000