}
// Print out each package and the failed dependencies
- out <<" " << I.Name() << ":";
- unsigned Indent = strlen(I.Name()) + 3;
+ out << " " << I.FullName(true) << " :";
+ unsigned const Indent = I.FullName(true).size() + 3;
bool First = true;
pkgCache::VerIterator Ver;
out << ' ' << End.DepType() << ": ";
FirstOr = false;
- out << Start.TargetPkg().Name();
+ out << Start.TargetPkg().FullName(true);
// Show a quick summary of the version requirements
if (Start.TargetVer() != 0)
{
pkgCache::PkgIterator I(Cache,Cache.List[J]);
if (Cache[I].NewInstall() == true) {
- List += string(I.Name()) + " ";
+ if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
+ continue;
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CandVersion) + "\n";
}
}
pkgCache::PkgIterator I(Cache,Cache.List[J]);
if (Cache[I].Delete() == true)
{
+ if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
+ continue;
if ((Cache[I].iFlags & pkgDepCache::Purge) == pkgDepCache::Purge)
- List += string(I.Name()) + "* ";
+ List += I.FullName(true) + "* ";
else
- List += string(I.Name()) + " ";
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CandVersion)+ "\n";
}
I->CurrentVer == 0 || Cache[I].Delete() == true)
continue;
- List += string(I.Name()) + " ";
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
ShowList(out,_("The following packages have been kept back:"),List,VersionsList);
// Not interesting
if (Cache[I].Upgrade() == false || Cache[I].NewInstall() == true)
continue;
-
- List += string(I.Name()) + " ";
+ if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
+ continue;
+
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
ShowList(out,_("The following packages will be upgraded:"),List,VersionsList);
// Not interesting
if (Cache[I].Downgrade() == false || Cache[I].NewInstall() == true)
continue;
-
- List += string(I.Name()) + " ";
+ if (Cache[I].CandidateVerIter(Cache).Pseudo() == true)
+ continue;
+
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
return ShowList(out,_("The following packages will be DOWNGRADED:"),List,VersionsList);
pkgCache::PkgIterator I(Cache,Cache.List[J]);
if (Cache[I].InstallVer != (pkgCache::Version *)I.CurrentVer() &&
I->SelectedState == pkgCache::State::Hold) {
- List += string(I.Name()) + " ";
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CurVersion) + " => " + Cache[I].CandVersion + "\n";
}
}
if (Added[I->ID] == false)
{
Added[I->ID] = true;
- List += string(I.Name()) + " ";
+ List += I.FullName(true) + " ";
//VersionsList += string(Cache[I].CurVersion) + "\n"; ???
}
}
Added[P->ID] = true;
char S[300];
- snprintf(S,sizeof(S),_("%s (due to %s) "),P.Name(),I.Name());
+ snprintf(S,sizeof(S),_("%s (due to %s) "),P.FullName(true).c_str(),I.FullName(true).c_str());
List += S;
//VersionsList += "\n"; ???
}
unsigned long ReInstall = 0;
for (pkgCache::PkgIterator I = Dep.PkgBegin(); I.end() == false; I++)
{
+ if (pkgCache::VerIterator(Dep, Dep[I].CandidateVer).Pseudo() == true)
+ continue;
+
if (Dep[I].NewInstall() == true)
Install++;
else
{
struct statvfs Buf;
string OutputDir = _config->FindDir("Dir::Cache::Archives");
- if (statvfs(OutputDir.c_str(),&Buf) != 0)
- return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
- OutputDir.c_str());
- if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
+ if (statvfs(OutputDir.c_str(),&Buf) != 0) {
+ if (errno == EOVERFLOW)
+ return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
+ OutputDir.c_str());
+ else
+ return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
+ OutputDir.c_str());
+ } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
{
struct statfs Stat;
if (statfs(OutputDir.c_str(),&Stat) != 0
if (found_one == true)
{
ioprintf(c1out,_("Note, selecting %s instead of %s\n"),
- Prov.Name(),Pkg.Name());
+ Prov.FullName(true).c_str(),Pkg.FullName(true).c_str());
Pkg = Prov;
}
}
{
if (AllowFail == true)
ioprintf(c1out,_("Skipping %s, it is already installed and upgrade is not set.\n"),
+ Pkg.FullName(true).c_str());
+ return true;
+ }
+
+ // Ignore request for install if package would be new
+ if (_config->FindB("APT::Get::Only-Upgrade", false) == true &&
+ Pkg->CurrentVer == 0)
+ {
+ if (AllowFail == true)
+ ioprintf(c1out,_("Skipping %s, it is not installed and only upgrades are requested.\n"),
Pkg.Name());
return true;
}
-
+
// Check if there is something at all to install
pkgDepCache::StateCache &State = Cache[Pkg];
if (Remove == true && Pkg->CurrentVer == 0)
if (AllowFail == false)
return false;
- ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.Name());
+ ioprintf(c1out,_("Package %s is not installed, so not removed\n"),Pkg.FullName(true).c_str());
return true;
}
if (Pkg->ProvidesList != 0)
{
ioprintf(c1out,_("Package %s is a virtual package provided by:\n"),
- Pkg.Name());
+ Pkg.FullName(true).c_str());
pkgCache::PrvIterator I = Pkg.ProvidesList();
for (; I.end() == false; I++)
if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer())
{
if (Cache[Pkg].Install() == true && Cache[Pkg].NewInstall() == false)
- c1out << " " << Pkg.Name() << " " << I.OwnerVer().VerStr() <<
+ c1out << " " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr() <<
_(" [Installed]") << endl;
else
- c1out << " " << Pkg.Name() << " " << I.OwnerVer().VerStr() << endl;
+ c1out << " " << Pkg.FullName(true) << " " << I.OwnerVer().VerStr() << endl;
}
}
c1out << _("You should explicitly select one to install.") << endl;
ioprintf(c1out,
_("Package %s is not available, but is referred to by another package.\n"
"This may mean that the package is missing, has been obsoleted, or\n"
- "is only available from another source\n"),Pkg.Name());
+ "is only available from another source\n"),Pkg.FullName(true).c_str());
string List;
string VersionsList;
if (Seen[Dep.ParentPkg()->ID] == true)
continue;
Seen[Dep.ParentPkg()->ID] = true;
- List += string(Dep.ParentPkg().Name()) + " ";
+ List += Dep.ParentPkg().FullName(true) + " ";
//VersionsList += string(Dep.ParentPkg().CurVersion) + "\n"; ???
}
ShowList(c1out,_("However the following packages replace it:"),List,VersionsList);
}
- _error->Error(_("Package %s has no installation candidate"),Pkg.Name());
+ _error->Error(_("Package %s has no installation candidate"),Pkg.FullName(true).c_str());
return false;
}
{
if (Pkg->CurrentVer == 0 || Pkg.CurrentVer().Downloadable() == false)
ioprintf(c1out,_("Reinstallation of %s is not possible, it cannot be downloaded.\n"),
- Pkg.Name());
+ Pkg.FullName(true).c_str());
else
Cache.SetReInstall(Pkg,true);
}
{
if (AllowFail == true)
ioprintf(c1out,_("%s is already the newest version.\n"),
- Pkg.Name());
+ Pkg.FullName(true).c_str());
}
}
else
{
if (IsRel == true)
return _error->Error(_("Release '%s' for '%s' was not found"),
- VerTag,Pkg.Name());
+ VerTag,Pkg.FullName(true).c_str());
return _error->Error(_("Version '%s' for '%s' was not found"),
- VerTag,Pkg.Name());
+ VerTag,Pkg.FullName(true).c_str());
}
if (strcmp(VerTag,Ver.VerStr()) != 0)
{
ioprintf(c1out,_("Selected version %s (%s) for %s\n"),
- Ver.VerStr(),Ver.RelStr().c_str(),Pkg.Name());
+ Ver.VerStr(),Ver.RelStr().c_str(),Pkg.FullName(true).c_str());
}
Cache.SetCandidateVersion(Ver);
pkgSrcRecords &SrcRecs,string &Src,
pkgDepCache &Cache)
{
- // We want to pull the version off the package specification..
string VerTag;
- string DefRel;
+ string DefRel = _config->Find("APT::Default-Release");
string TmpSrc = Name;
- const size_t found = TmpSrc.find_last_of("/=");
- // honor default release
- if (found != string::npos && TmpSrc[found] == '/')
- {
- DefRel = TmpSrc.substr(found+1);
+ // extract the version/release from the pkgname
+ const size_t found = TmpSrc.find_last_of("/=");
+ if (found != string::npos) {
+ if (TmpSrc[found] == '/')
+ DefRel = TmpSrc.substr(found+1);
+ else
+ VerTag = TmpSrc.substr(found+1);
TmpSrc = TmpSrc.substr(0,found);
}
- else
- DefRel = _config->Find("APT::Default-Release");
-
- pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
- if (found != string::npos && TmpSrc[found] == '=')
+ /* Lookup the version of the package we would install if we were to
+ install a version and determine the source package name, then look
+ in the archive for a source package of the same name. */
+ bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
+ const pkgCache::PkgIterator Pkg = Cache.FindPkg(TmpSrc);
+ if (MatchSrcOnly == false && Pkg.end() == false)
{
- VerTag = TmpSrc.substr(found+1);
- TmpSrc = TmpSrc.substr(0,found);
- }
- else if(!Pkg.end() && DefRel.empty() == false)
- {
- // we have a default release, try to locate the pkg. we do it like
- // this because GetCandidateVer() will not "downgrade", that means
- // "apt-get source -t stable apt" won't work on a unstable system
- for (pkgCache::VerIterator Ver = Pkg.VersionList(); Ver.end() == false;
- Ver++)
+ if(VerTag.empty() == false || DefRel.empty() == false)
{
- for (pkgCache::VerFileIterator VF = Ver.FileList(); VF.end() == false;
- VF++)
+ bool fuzzy = false;
+ // we have a default release, try to locate the pkg. we do it like
+ // this because GetCandidateVer() will not "downgrade", that means
+ // "apt-get source -t stable apt" won't work on a unstable system
+ for (pkgCache::VerIterator Ver = Pkg.VersionList();; Ver++)
{
- /* If this is the status file, and the current version is not the
- version in the status file (ie it is not installed, or somesuch)
- then it is not a candidate for installation, ever. This weeds
- out bogus entries that may be due to config-file states, or
- other. */
- if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
- pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
- continue;
-
- if((VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
- (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
+ // try first only exact matches, later fuzzy matches
+ if (Ver.end() == true)
{
- pkgRecords::Parser &Parse = Recs.Lookup(VF);
- VerTag = Parse.SourceVer();
- if (VerTag.empty())
- VerTag = Ver.VerStr();
- break;
+ if (fuzzy == true)
+ break;
+ fuzzy = true;
+ Ver = Pkg.VersionList();
}
+ // We match against a concrete version (or a part of this version)
+ if (VerTag.empty() == false &&
+ (fuzzy == true || Cache.VS().CmpVersion(VerTag, Ver.VerStr()) != 0) && // exact match
+ (fuzzy == false || strncmp(VerTag.c_str(), Ver.VerStr(), VerTag.size()) != 0)) // fuzzy match
+ continue;
+
+ for (pkgCache::VerFileIterator VF = Ver.FileList();
+ VF.end() == false; VF++)
+ {
+ /* If this is the status file, and the current version is not the
+ version in the status file (ie it is not installed, or somesuch)
+ then it is not a candidate for installation, ever. This weeds
+ out bogus entries that may be due to config-file states, or
+ other. */
+ if ((VF.File()->Flags & pkgCache::Flag::NotSource) ==
+ pkgCache::Flag::NotSource && Pkg.CurrentVer() != Ver)
+ continue;
+
+ // or we match against a release
+ if(VerTag.empty() == false ||
+ (VF.File().Archive() != 0 && VF.File().Archive() == DefRel) ||
+ (VF.File().Codename() != 0 && VF.File().Codename() == DefRel))
+ {
+ pkgRecords::Parser &Parse = Recs.Lookup(VF);
+ Src = Parse.SourcePkg();
+ // no SourcePkg name, so it is the "binary" name
+ if (Src.empty() == true)
+ Src = TmpSrc;
+ // the Version we have is possibly fuzzy or includes binUploads,
+ // so we use the Version of the SourcePkg (empty if same as package)
+ VerTag = Parse.SourceVer();
+ if (VerTag.empty() == true)
+ VerTag = Ver.VerStr();
+ break;
+ }
+ }
+ if (Src.empty() == false)
+ break;
+ }
+ if (Src.empty() == true)
+ {
+ // Sources files have no codename information
+ if (VerTag.empty() == true && DefRel.empty() == false)
+ _error->Warning(_("Ignore unavailable target release '%s' of package '%s'"), DefRel.c_str(), TmpSrc.c_str());
+ DefRel.clear();
}
}
- }
-
- /* Lookup the version of the package we would install if we were to
- install a version and determine the source package name, then look
- in the archive for a source package of the same name. */
- bool MatchSrcOnly = _config->FindB("APT::Get::Only-Source");
- if (MatchSrcOnly == false)
- {
- if (Pkg.end() == false)
+ if (Src.empty() == true)
{
+ // if we don't have found a fitting package yet so we will
+ // choose a good candidate and proceed with that.
+ // Maybe we will find a source later on with the right VerTag
pkgCache::VerIterator Ver = Cache.GetCandidateVer(Pkg);
- if (Ver.end() == false)
+ if (Ver.end() == false)
{
pkgRecords::Parser &Parse = Recs.Lookup(Ver.FileList());
Src = Parse.SourcePkg();
+ if (VerTag.empty() == true)
+ VerTag = Parse.SourceVer();
}
- }
+ }
+ }
+
+ if (Src.empty() == true)
+ Src = TmpSrc;
+ else
+ {
+ /* if we have a source pkg name, make sure to only search
+ for srcpkg names, otherwise apt gets confused if there
+ is a binary package "pkg1" and a source package "pkg1"
+ with the same name but that comes from different packages */
+ MatchSrcOnly = true;
+ if (Src != TmpSrc)
+ {
+ ioprintf(c1out, _("Picking '%s' as source package instead of '%s'\n"), Src.c_str(), TmpSrc.c_str());
+ }
}
// The best hit
pkgSrcRecords::Parser *Last = 0;
unsigned long Offset = 0;
string Version;
- bool IsMatch = false;
- // No source package name..
- if (Src.empty() == true)
- Src = TmpSrc;
- else
- // if we have a source pkg name, make sure to only search
- // for srcpkg names, otherwise apt gets confused if there
- // is a binary package "pkg1" and a source package "pkg1"
- // with the same name but that comes from different packages
- MatchSrcOnly = true;
-
- // If we are matching by version then we need exact matches to be happy
- if (VerTag.empty() == false)
- IsMatch = true;
-
/* Iterate over all of the hits, which includes the resulting
binary packages in the search */
pkgSrcRecords::Parser *Parse;
- SrcRecs.Restart();
- while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
+ while (true)
{
- string Ver = Parse->Version();
-
- // show name mismatches
- if (IsMatch == true && Parse->Package() != Src)
- ioprintf(c1out, _("No source package '%s' picking '%s' instead\n"), Src.c_str(), Parse->Package().c_str());
-
- if (VerTag.empty() == false)
+ SrcRecs.Restart();
+ while ((Parse = SrcRecs.Find(Src.c_str(), MatchSrcOnly)) != 0)
{
- /* Don't want to fall through because we are doing exact version
- matching. */
- if (Cache.VS().CmpVersion(VerTag,Ver) != 0)
+ const string Ver = Parse->Version();
+
+ // Ignore all versions which doesn't fit
+ if (VerTag.empty() == false &&
+ Cache.VS().CmpVersion(VerTag, Ver) != 0) // exact match
continue;
-
- Last = Parse;
- Offset = Parse->Offset();
- break;
+
+ // Newer version or an exact match? Save the hit
+ if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0) {
+ Last = Parse;
+ Offset = Parse->Offset();
+ Version = Ver;
+ }
+
+ // was the version check above an exact match? If so, we don't need to look further
+ if (VerTag.empty() == false && VerTag.size() == Ver.size())
+ break;
}
-
- // Newer version or an exact match
- if (Last == 0 || Cache.VS().CmpVersion(Version,Ver) < 0 ||
- (Parse->Package() == Src && IsMatch == false))
- {
- IsMatch = Parse->Package() == Src;
- Last = Parse;
- Offset = Parse->Offset();
- Version = Ver;
- }
+ if (Last != 0 || VerTag.empty() == true)
+ break;
+ //if (VerTag.empty() == false && Last == 0)
+ _error->Warning(_("Ignore unavailable version '%s' of package '%s'"), VerTag.c_str(), TmpSrc.c_str());
+ VerTag.clear();
}
-
+
if (Last == 0 || Last->Jump(Offset) == false)
return 0;
-
+
return Last;
}
/*}}}*/
{
if(Pkg.CurrentVer() != 0 || Cache[Pkg].Install())
if(Debug)
- std::cout << "We could delete %s" << Pkg.Name() << std::endl;
+ std::cout << "We could delete %s" << Pkg.FullName(true).c_str() << std::endl;
if (doAutoRemove)
{
// only show stuff in the list that is not yet marked for removal
if(Cache[Pkg].Delete() == false)
{
+ ++autoRemoveCount;
// we don't need to fill the strings if we don't need them
- if (smallList == true)
- ++autoRemoveCount;
- else
+ if (smallList == false)
{
- autoremovelist += string(Pkg.Name()) + " ";
+ autoremovelist += Pkg.FullName(true) + " ";
autoremoveversions += string(Cache[Pkg].CandVersion) + "\n";
}
}
if (doAutoRemove == false && (autoremovelist.empty() == false || autoRemoveCount != 0))
{
if (smallList == false)
- ShowList(c1out, _("The following packages were automatically installed and are no longer required:"), autoremovelist, autoremoveversions);
+ ShowList(c1out, P_("The following package is automatically installed and is no longer required:",
+ "The following packages were automatically installed and are no longer required:",
+ autoRemoveCount), autoremovelist, autoremoveversions);
else
- ioprintf(c1out, _("%lu packages were automatically installed and are no longer required.\n"), autoRemoveCount);
+ ioprintf(c1out, P_("%lu package was automatically installed and is no longer required.\n",
+ "%lu packages were automatically installed and are no longer required.\n", autoRemoveCount), autoRemoveCount);
c1out << _("Use 'apt-get autoremove' to remove them.") << std::endl;
}
// Now see if we had destroyed anything (if we had done anything)
if(!Remove &&
Cache[Pkg].Install() == false &&
(Cache[Pkg].Flags & pkgCache::Flag::Auto) &&
- _config->FindB("APT::Get::ReInstall",false) == false)
+ _config->FindB("APT::Get::ReInstall",false) == false &&
+ _config->FindB("APT::Get::Only-Upgrade",false) == false &&
+ _config->FindB("APT::Get::Download-Only",false) == false)
{
ioprintf(c1out,_("%s set to manually installed.\n"),
- Pkg.Name());
+ Pkg.FullName(true).c_str());
Cache->MarkAuto(Pkg,false);
AutoMarkChanged++;
}
break;
if (*J == 0) {
- List += string(I.Name()) + " ";
+ List += I.FullName(true) + " ";
VersionsList += string(Cache[I].CandVersion) + "\n";
}
}
for(;;)
{
/* Skip if package is installed already, or is about to be */
- string target = string(Start.TargetPkg().Name()) + " ";
+ string target = Start.TargetPkg().FullName(true) + " ";
if ((*Start.TargetPkg()).SelectedState == pkgCache::State::Install
|| Cache[Start.TargetPkg()].Install())
// Check for enough free space
struct statvfs Buf;
string OutputDir = ".";
- if (statvfs(OutputDir.c_str(),&Buf) != 0)
- return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
- OutputDir.c_str());
- if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
+ if (statvfs(OutputDir.c_str(),&Buf) != 0) {
+ if (errno == EOVERFLOW)
+ return _error->WarningE("statvfs",_("Couldn't determine free space in %s"),
+ OutputDir.c_str());
+ else
+ return _error->Errno("statvfs",_("Couldn't determine free space in %s"),
+ OutputDir.c_str());
+ } else if (unsigned(Buf.f_bfree) < (FetchBytes - FetchPBytes)/Buf.f_bsize)
{
struct statfs Stat;
if (statfs(OutputDir.c_str(),&Stat) != 0
{
for (unsigned I = 0; I != J; I++)
ioprintf(cout,_("Fetch source %s\n"),Dsc[I].Package.c_str());
+ delete[] Dsc;
return true;
}
for (; I != Fetcher.UriEnd(); I++)
cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' <<
I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;
+ delete[] Dsc;
return true;
}
if (_config->FindB("APT::Get::Download-only",false) == true)
{
c1out << _("Download complete and in download only mode") << endl;
+ delete[] Dsc;
return true;
}
_exit(0);
}
-
+ delete[] Dsc;
+
// Wait for the subprocess
int Status = 0;
while (waitpid(Process,&Status,0) != Process)
// Process the build-dependencies
vector<pkgSrcRecords::Parser::BuildDepRec> BuildDeps;
- if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",false)) == false)
+ if (Last->BuildDepends(BuildDeps, _config->FindB("APT::Get::Arch-Only",true)) == false)
return _error->Error(_("Unable to get build-dependency information for %s"),Src.c_str());
// Also ensure that build-essential packages are present
for (; Prv.end() != true; Prv++)
{
if (_config->FindB("Debug::BuildDeps",false) == true)
- cout << " Checking provider " << Prv.OwnerPkg().Name() << endl;
+ cout << " Checking provider " << Prv.OwnerPkg().FullName() << endl;
if ((*Cache)[Prv.OwnerPkg()].InstVerIter(*Cache).end() == false)
break;
if (Prv.end() == false)
{
if (_config->FindB("Debug::BuildDeps",false) == true)
- cout << " Is provided by installed package " << Prv.OwnerPkg().Name() << endl;
+ cout << " Is provided by installed package " << Prv.OwnerPkg().FullName() << endl;
skipAlternatives = hasAlternatives;
continue;
}
return _error->Error(_("Failed to satisfy %s dependency for %s: Installed package %s is too new"),
Last->BuildDepType((*D).Type),
Src.c_str(),
- Pkg.Name());
+ Pkg.FullName(true).c_str());
}
}
return true;
}
/*}}}*/
-
// DoMoo - Never Ask, Never Tell /*{{{*/
// ---------------------------------------------------------------------
/* */
{0,"fix-missing","APT::Get::Fix-Missing",0},
{0,"ignore-hold","APT::Ignore-Hold",0},
{0,"upgrade","APT::Get::upgrade",0},
+ {0,"only-upgrade","APT::Get::Only-Upgrade",0},
{0,"force-yes","APT::Get::force-yes",0},
{0,"print-uris","APT::Get::Print-URIs",0},
{0,"diff-only","APT::Get::Diff-Only",0},
+ {0,"debian-only","APT::Get::Diff-Only",0},
{0,"tar-only","APT::Get::Tar-Only",0},
{0,"dsc-only","APT::Get::Dsc-Only",0},
{0,"purge","APT::Get::Purge",0},
HCoop / ntk / apt.git / blobdiff