// -*- mode: cpp; mode: fold -*-
// Description /*{{{*/
-// $Id: orderlist.cc,v 1.11 2000/01/16 08:45:47 jgg Exp $
+// $Id: orderlist.cc,v 1.14 2001/05/07 05:49:43 jgg Exp $
/* ######################################################################
Order List - Represents and Manipulates an ordered list of packages.
A list of packages can be ordered by a number of conflicting criteria
each given a specific priority. Each package also has a set of flags
- indicating some usefull things about it that are derived in the
+ indicating some useful things about it that are derived in the
course of sorting. The pkgPackageManager class uses this class for
all of it's installation ordering needs.
ordering.
Each of the features can be enabled in the sorting routine at an
- arbitary priority to give quite abit of control over the final unpacking
+ arbitrary priority to give quite abit of control over the final unpacking
order.
The rules listed above may never be violated and are called Critical.
after flag set. This forces them and all their dependents to be ordered
toward the end.
+ There are complications in this algorithm when presented with cycles.
+ For all known practical cases it works, all cases where it doesn't work
+ is fixable by tweaking the package descriptions. However, it should be
+ possible to impove this further to make some better choices when
+ presented with cycles.
+
##################################################################### */
/*}}}*/
// Include Files /*{{{*/
-#ifdef __GNUG__
-#pragma implementation "apt-pkg/orderlist.h"
-#endif
#include <apt-pkg/orderlist.h>
#include <apt-pkg/depcache.h>
#include <apt-pkg/error.h>
#include <apt-pkg/version.h>
+#include <apt-pkg/sptr.h>
+#include <apt-pkg/configuration.h>
+
+#include <iostream>
/*}}}*/
+using namespace std;
+
pkgOrderList *pkgOrderList::Me = 0;
// OrderList::pkgOrderList - Constructor /*{{{*/
// ---------------------------------------------------------------------
/* */
-pkgOrderList::pkgOrderList(pkgDepCache &Cache) : Cache(Cache)
+pkgOrderList::pkgOrderList(pkgDepCache *pCache) : Cache(*pCache)
{
FileList = 0;
Primary = 0;
RevDepends = 0;
Remove = 0;
LoopCount = -1;
-
+ Debug = _config->FindB("Debug::pkgOrderList",false);
+
/* Construct the arrays, egcs 1.0.1 bug requires the package count
hack */
- unsigned long Size = Cache.HeaderP->PackageCount;
+ unsigned long Size = Cache.Head().PackageCount;
Flags = new unsigned short[Size];
End = List = new Package *[Size];
memset(Flags,0,sizeof(*Flags)*Size);
if (Pkg.State() == pkgCache::PkgIterator::NeedsConfigure &&
Cache[Pkg].Keep() == true)
return false;
+
+ if (FileList == 0)
+ return false;
- if (FileList != 0 && FileList[Pkg->ID].empty() == false)
+ if (FileList[Pkg->ID].empty() == false)
return false;
return true;
}
/*}}}*/
-
// OrderList::DoRun - Does an order run /*{{{*/
// ---------------------------------------------------------------------
/* The caller is expeted to have setup the desired probe state */
bool pkgOrderList::DoRun()
{
// Temp list
- unsigned long Size = Cache.HeaderP->PackageCount;
- Package **NList = new Package *[Size];
- AfterList = new Package *[Size];
+ unsigned long Size = Cache.Head().PackageCount;
+ SPtrArray<Package *> NList = new Package *[Size];
+ SPtrArray<Package *> AfterList = new Package *[Size];
AfterEnd = AfterList;
Depth = 0;
if (VisitNode(PkgIterator(Cache,*I)) == false)
{
End = OldEnd;
- delete [] NList;
- delete [] AfterList;
return false;
}
// Swap the main list to the new list
delete [] List;
- delete [] AfterList;
- List = NList;
+ List = NList.UnGuard();
return true;
}
/*}}}*/
Me = this;
qsort(List,End - List,sizeof(*List),&OrderCompareA);
+ if (Debug == true)
+ clog << "** Pass A" << endl;
if (DoRun() == false)
return false;
+ if (Debug == true)
+ clog << "** Pass B" << endl;
Secondary = 0;
if (DoRun() == false)
return false;
+ if (Debug == true)
+ clog << "** Pass C" << endl;
LoopCount = 0;
RevDepends = 0;
Remove = 0; // Otherwise the libreadline remove problem occures
if (DoRun() == false)
return false;
-
+
+ if (Debug == true)
+ clog << "** Pass D" << endl;
LoopCount = 0;
Primary = &pkgOrderList::DepUnPackPre;
if (DoRun() == false)
return false;
-/* cout << "----------END" << endl;
-
- for (iterator I = List; I != End; I++)
+ if (Debug == true)
{
- PkgIterator P(Cache,*I);
- if (IsNow(P) == true)
- cout << P.Name() << ' ' << IsMissing(P) << ',' << IsFlag(P,After) << endl;
- }*/
+ clog << "** Unpack ordering done" << endl;
+
+ for (iterator I = List; I != End; I++)
+ {
+ PkgIterator P(Cache,*I);
+ if (IsNow(P) == true)
+ clog << P.Name() << ' ' << IsMissing(P) << ',' << IsFlag(P,After) << endl;
+ }
+ }
return true;
}
return DoRun();
}
/*}}}*/
-
// OrderList::Score - Score the package for sorting /*{{{*/
// ---------------------------------------------------------------------
/* Higher scores order earlier */
if ((Pkg->Flags & pkgCache::Flag::Essential) == pkgCache::Flag::Essential)
Score += 100;
+ if (IsFlag(Pkg,Immediate) == true)
+ Score += 10;
+
for (DepIterator D = Cache[Pkg].InstVerIter(Cache).DependsList();
D.end() == false; D++)
if (D->Type == pkgCache::Dep::PreDepends)
/*}}}*/
// OrderList::OrderCompareB - Order the installation by source /*{{{*/
// ---------------------------------------------------------------------
-/* This orders by installation source. This is usefull to handle
+/* This orders by installation source. This is useful to handle
inter-source breaks */
int pkgOrderList::OrderCompareB(const void *a, const void *b)
{
return strcmp(A.Name(),B.Name());
}
/*}}}*/
-
// OrderList::VisitDeps - Visit forward install dependencies /*{{{*/
// ---------------------------------------------------------------------
/* This calls the dependency function for the normal forwards dependencies
/* This routine calls visit on all providing packages. */
bool pkgOrderList::VisitProvides(DepIterator D,bool Critical)
{
- Version **List = D.AllTargets();
+ SPtrArray<Version *> List = D.AllTargets();
for (Version **I = List; *I != 0; I++)
{
VerIterator Ver(Cache,*I);
if (Cache[Pkg].Keep() == true && Pkg.State() == PkgIterator::NeedsNothing)
continue;
- if (D->Type != pkgCache::Dep::Conflicts && Cache[Pkg].InstallVer != *I)
+ if (D->Type != pkgCache::Dep::Conflicts &&
+ D->Type != pkgCache::Dep::DpkgBreaks &&
+ D->Type != pkgCache::Dep::Obsoletes &&
+ Cache[Pkg].InstallVer != *I)
continue;
- if (D->Type == pkgCache::Dep::Conflicts && (Version *)Pkg.CurrentVer() != *I)
+ if ((D->Type == pkgCache::Dep::Conflicts ||
+ D->Type == pkgCache::Dep::DpkgBreaks ||
+ D->Type == pkgCache::Dep::Obsoletes) &&
+ (Version *)Pkg.CurrentVer() != *I)
continue;
// Skip over missing files
continue;
if (VisitNode(Pkg) == false)
- {
- delete [] List;
return false;
- }
}
- delete [] List;
return true;
}
/*}}}*/
IsFlag(Pkg,AddPending) == true || IsFlag(Pkg,InList) == false)
return true;
-/* for (int j = 0; j != Depth; j++) cout << ' ';
- cout << "Visit " << Pkg.Name() << endl;*/
+ if (Debug == true)
+ {
+ for (int j = 0; j != Depth; j++) clog << ' ';
+ clog << "Visit " << Pkg.Name() << endl;
+ }
+
Depth++;
// Color grey
Primary = Old;
Depth--;
-
-/* for (int j = 0; j != Depth; j++) cout << ' ';
- cout << "Leave " << Pkg.Name() << ' ' << IsFlag(Pkg,Added) << ',' << IsFlag(Pkg,AddPending) << endl;*/
+ if (Debug == true)
+ {
+ for (int j = 0; j != Depth; j++) clog << ' ';
+ clog << "Leave " << Pkg.Name() << ' ' << IsFlag(Pkg,Added) << ',' << IsFlag(Pkg,AddPending) << endl;
+ }
+
return true;
}
/*}}}*/
-
// OrderList::DepUnPackCrit - Critical UnPacking ordering /*{{{*/
// ---------------------------------------------------------------------
/* Critical unpacking ordering strives to satisfy Conflicts: and
{
/* Reverse depenanices are only interested in conflicts,
predepend breakage is ignored here */
- if (D->Type != pkgCache::Dep::Conflicts)
+ if (D->Type != pkgCache::Dep::Conflicts &&
+ D->Type != pkgCache::Dep::Obsoletes)
continue;
// Duplication elimination, consider only the current version
{
/* Forward critical dependencies MUST be correct before the
package can be unpacked. */
- if (D->Type != pkgCache::Dep::Conflicts && D->Type != pkgCache::Dep::PreDepends)
+ if (D->Type != pkgCache::Dep::Conflicts &&
+ D->Type != pkgCache::Dep::DpkgBreaks &&
+ D->Type != pkgCache::Dep::Obsoletes &&
+ D->Type != pkgCache::Dep::PreDepends)
continue;
/* We wish to check if the dep is okay in the now state of the
// ---------------------------------------------------------------------
/* Critical PreDepends (also configure immediate and essential) strives to
ensure not only that all conflicts+predepends are met but that this
- package will be immediately configurable when it is unpacked.
-
+ package will be immediately configurable when it is unpacked.
Loops are preprocessed and logged. */
bool pkgOrderList::DepUnPackPreD(DepIterator D)
{
else
continue;
}
-
+
/* We wish to check if the dep is okay in the now state of the
target package against the install state of this package. */
if (CheckDep(D) == true)
if (IsFlag(D.TargetPkg(),AddPending) == false)
continue;
}
-
+
// This is the loop detection
if (IsFlag(D.TargetPkg(),Added) == true ||
IsFlag(D.TargetPkg(),AddPending) == true)
return false;
}
else
+ {
if (D->Type == pkgCache::Dep::Depends)
if (VisitProvides(D,false) == false)
return false;
+
+ if (D->Type == pkgCache::Dep::DpkgBreaks)
+ {
+ if (CheckDep(D) == true)
+ continue;
+
+ if (VisitNode(D.TargetPkg()) == false)
+ return false;
+ }
+ }
}
return true;
}
return true;
}
/*}}}*/
-
// OrderList::AddLoop - Add a loop to the loop list /*{{{*/
// ---------------------------------------------------------------------
/* We record the loops. This is a relic since loop breaking is done
/* */
void pkgOrderList::WipeFlags(unsigned long F)
{
- unsigned long Size = Cache.HeaderP->PackageCount;
+ unsigned long Size = Cache.Head().PackageCount;
for (unsigned long I = 0; I != Size; I++)
Flags[I] &= ~F;
}
this fails to produce a suitable result. */
bool pkgOrderList::CheckDep(DepIterator D)
{
- Version **List = D.AllTargets();
+ SPtrArray<Version *> List = D.AllTargets();
bool Hit = false;
for (Version **I = List; *I != 0; I++)
{
if ((Version *)Pkg.CurrentVer() != *I ||
Pkg.State() != PkgIterator::NeedsNothing)
continue;
-
+
/* Conflicts requires that all versions are not present, depends
just needs one */
- if (D->Type != pkgCache::Dep::Conflicts)
+ if (D->Type != pkgCache::Dep::Conflicts &&
+ D->Type != pkgCache::Dep::DpkgBreaks &&
+ D->Type != pkgCache::Dep::Obsoletes)
{
/* Try to find something that does not have the after flag set
if at all possible */
continue;
}
- delete [] List;
return true;
}
else
if (IsFlag(Pkg,After) == true)
Flag(D.ParentPkg(),After);
- delete [] List;
return false;
}
}
- delete [] List;
// We found a hit, but it had the after flag set
if (Hit == true && D->Type == pkgCache::Dep::PreDepends)
/* Conflicts requires that all versions are not present, depends
just needs one */
- if (D->Type == pkgCache::Dep::Conflicts)
+ if (D->Type == pkgCache::Dep::Conflicts ||
+ D->Type == pkgCache::Dep::Obsoletes)
return true;
return false;
}
projects / apt.git / blobdiff