~ubuntu-core-dev/apt/oneiric

            

            if (Start == End)

               break;

         }       

      }     

   }   

         continue;

 

      // Print out any essential package depenendents that are to be removed

      {

         // Skip everything but depends

         if (D->Type != pkgCache::Dep::PreDepends &&

   unsigned long Downgrade = 0;

   unsigned long Install = 0;

   unsigned long ReInstall = 0;

   {

      if (Dep[I].NewInstall() == true)

         Install++;

                                }

                                // if we found no candidate which provide this package, show non-candidates

                                if (provider == 0)

                                                out << "  " << I.OwnerPkg().FullName(true) << " " << I.OwnerVer().VerStr()

                                                    << _(" [Not candidate version]") << endl;

                                else

                                SPtrArray<bool> Seen = new bool[Cache.GetPkgCache()->Head().PackageCount];

                                memset(Seen,0,Cache.GetPkgCache()->Head().PackageCount*sizeof(*Seen));

                                for (pkgCache::DepIterator Dep = Pkg.RevDependsList();

                                        if (Dep->Type != pkgCache::Dep::Replaces)

                                                continue;

                                        if (Seen[Dep.ParentPkg()->ID] == true)

struct TryToRemove {

   pkgCacheFile* Cache;

   pkgProblemResolver* Fix;

   bool PurgePkgs;

 

   TryToRemove(pkgCacheFile &Cache, pkgProblemResolver *PM) : Cache(&Cache), Fix(PM),

                                PurgePkgs(_config->FindB("APT::Get::Purge", false)) {};

   List = new pkgCache::Package *[Cache->Head().PackageCount];

   memset(List,0,sizeof(*List)*Cache->Head().PackageCount);

   pkgCache::PkgIterator I = Cache->PkgBegin();

      List[I->ID] = I;

 

   SortCache = *this;

      if ((DCache->PolicyBrokenCount() > 0))

      {

         // upgrade all policy-broken packages with ForceImportantDeps=True

            if ((*DCache)[I].NowPolicyBroken() == true) 

               DCache->MarkInstall(I,true,0, false, true);

      }

   if (_config->FindB("APT::Get::Purge",false) == true)

   {

      pkgCache::PkgIterator I = Cache->PkgBegin();

      {

         if (I.Purge() == false && Cache[I].Mode == pkgDepCache::ModeDelete)

            Cache->MarkDelete(I,true);

   if (_config->FindB("APT::Get::Print-URIs") == true)

   {

      pkgAcquire::UriIterator I = Fetcher.UriBegin();

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 

               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;

      return true;

         {

            if ((*I)->Local == true)

            {

               continue;

            }

 

      

      // Print out errors

      bool Failed = false;

      {

         if ((*I)->Status == pkgAcquire::Item::StatDone &&

             (*I)->Complete == true)

         // 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

         {

            // try first only exact matches, later fuzzy matches

            if (Ver.end() == true)

               continue;

 

            for (pkgCache::VerFileIterator VF = Ver.FileList();

            {

               /* 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)

         return false;

 

      pkgAcquire::UriIterator I = Fetcher.UriBegin();

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 

               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;

      return true;

               if(Start.TargetPkg().ProvidesList() != 0)

               {

                  pkgCache::PrvIterator I = Start.TargetPkg().ProvidesList();

                  {

                     pkgCache::PkgIterator Pkg = I.OwnerPkg();

                     if (Cache[Pkg].CandidateVerIter(Cache) == I.OwnerVer() && 

 

               if (Start >= End)

                  break;

            }

            

            if(foundInstalledInOrGroup == false)

 

   // Install everything with the install flag set

   pkgCache::PkgIterator I = Cache->PkgBegin();

   {

      /* Install the package only if it is a new install, the autoupgrader

         will deal with the rest */

 

   /* Now install their deps too, if we do this above then order of

      the status file is significant for | groups */

   {

      /* Install the package only if it is a new install, the autoupgrader

         will deal with the rest */

   }

   

   // Apply erasures now, they override everything else.

   {

      // Remove packages 

      if (I->SelectedState == pkgCache::State::DeInstall ||

      // Hold back held packages.

      if (_config->FindB("APT::Ignore-Hold",false) == false)

      {

         {

            if (I->SelectedState == pkgCache::State::Hold)

            {

   if (_config->FindB("APT::Get::Print-URIs") == true)

   {

      pkgAcquire::UriIterator I = Fetcher.UriBegin();

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 

               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;

      return true;

 

      // Load them into the fetcher

      for (vector<pkgSrcRecords::File>::const_iterator I = Lst.begin();

      {

         // Try to guess what sort of file it is we are getting.

         if (I->Type == "dsc")

   if (_config->FindB("APT::Get::Print-URIs") == true)

   {

      pkgAcquire::UriIterator I = Fetcher.UriBegin();

         cout << '\'' << I->URI << "' " << flNotDir(I->Owner->DestFile) << ' ' << 

               I->Owner->FileSize << ' ' << I->Owner->HashSum() << endl;

      delete[] Dsc;

 

   // Print error messages

   bool Failed = false;

   {

      if ((*I)->Status == pkgAcquire::Item::StatDone &&

          (*I)->Complete == true)

   if (Process == 0)

   {

      bool const fixBroken = _config->FindB("APT::Get::Fix-Broken", false);

      {

         string Dir = Dsc[I].Package + '-' + Cache->VS().UpstreamVersion(Dsc[I].Version.c_str());

         

         BuildDeps.push_back(rec);

      }

 

      {

         ioprintf(c1out,_("%s has no build depends.\n"),Src.c_str());

         continue;

      vector <pkgSrcRecords::Parser::BuildDepRec>::iterator D;

      pkgProblemResolver Fix(Cache);

      bool skipAlternatives = false; // skip remaining alternatives in an or group

      {

         bool hasAlternatives = (((*D).Op & pkgCache::Dep::Or) == pkgCache::Dep::Or);

 

                * installed

                */

               pkgCache::PrvIterator Prv = Pkg.ProvidesList();

               {

                  if (_config->FindB("Debug::BuildDeps",false) == true)

                     cout << "  Checking provider " << Prv.OwnerPkg().FullName() << endl;