apt-pkg/pkgcache.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: pkgcache.cc,v 1.37 2003/02/10 01:40:58 doogie Exp $
   4 /* ######################################################################
   5
   6    Package Cache - Accessor code for the cache
   7
   8    Please see doc/apt-pkg/cache.sgml for a more detailed description of
   9    this format. Also be sure to keep that file up-to-date!!
  10
  11    This is the general utility functions for cache managment. They provide
  12    a complete set of accessor functions for the cache. The cacheiterators
  13    header contains the STL-like iterators that can be used to easially
  14    navigate the cache as well as seemlessly dereference the mmap'd
  15    indexes. Use these always.
  16
  17    The main class provides for ways to get package indexes and some
  18    general lookup functions to start the iterators.
  19
  20    ##################################################################### */
  21                                                                         /*}}}*/
  22 // Include Files                                                        /*{{{*/
  23 #include <apt-pkg/pkgcache.h>
  24 #include <apt-pkg/indexfile.h>
  25 #include <apt-pkg/version.h>
  26 #include <apt-pkg/error.h>
  27 #include <apt-pkg/strutl.h>
  28 #include <apt-pkg/configuration.h>
  29
  30 #include <apti18n.h>
  31
  32 #include <string>
  33 #include <sys/stat.h>
  34 #include <unistd.h>
  35
  36 #include <ctype.h>
  37 #include <system.h>
  38                                                                         /*}}}*/
  39
  40 using std::string;
  41
  42
  43 // Cache::Header::Header - Constructor                                  /*{{{*/
  44 // ---------------------------------------------------------------------
  45 /* Simply initialize the header */
  46 pkgCache::Header::Header()
  47 {
  48    Signature = 0x98FE76DC;
  49
  50    /* Whenever the structures change the major version should be bumped,
  51       whenever the generator changes the minor version should be bumped. */
  52    MajorVersion = 7;
  53    MinorVersion = 0;
  54    Dirty = false;
  55
  56    HeaderSz = sizeof(pkgCache::Header);
  57    PackageSz = sizeof(pkgCache::Package);
  58    PackageFileSz = sizeof(pkgCache::PackageFile);
  59    VersionSz = sizeof(pkgCache::Version);
  60    DescriptionSz = sizeof(pkgCache::Description);
  61    DependencySz = sizeof(pkgCache::Dependency);
  62    ProvidesSz = sizeof(pkgCache::Provides);
  63    VerFileSz = sizeof(pkgCache::VerFile);
  64    DescFileSz = sizeof(pkgCache::DescFile);
  65
  66    PackageCount = 0;
  67    VersionCount = 0;
  68    DescriptionCount = 0;
  69    DependsCount = 0;
  70    PackageFileCount = 0;
  71    VerFileCount = 0;
  72    DescFileCount = 0;
  73    ProvidesCount = 0;
  74    MaxVerFileSize = 0;
  75    MaxDescFileSize = 0;
  76
  77    FileList = 0;
  78    StringList = 0;
  79    VerSysName = 0;
  80    Architecture = 0;
  81    memset(HashTable,0,sizeof(HashTable));
  82    memset(Pools,0,sizeof(Pools));
  83 }
  84                                                                         /*}}}*/
  85 // Cache::Header::CheckSizes - Check if the two headers have same *sz   /*{{{*/
  86 // ---------------------------------------------------------------------
  87 /* */
  88 bool pkgCache::Header::CheckSizes(Header &Against) const
  89 {
  90    if (HeaderSz == Against.HeaderSz &&
  91        PackageSz == Against.PackageSz &&
  92        PackageFileSz == Against.PackageFileSz &&
  93        VersionSz == Against.VersionSz &&
  94        DescriptionSz == Against.DescriptionSz &&
  95        DependencySz == Against.DependencySz &&
  96        VerFileSz == Against.VerFileSz &&
  97        DescFileSz == Against.DescFileSz &&
  98        ProvidesSz == Against.ProvidesSz)
  99       return true;
 100    return false;
 101 }
 102                                                                         /*}}}*/
 103
 104 // Cache::pkgCache - Constructor                                        /*{{{*/
 105 // ---------------------------------------------------------------------
 106 /* */
 107 pkgCache::pkgCache(MMap *Map, bool DoMap) : Map(*Map)
 108 {
 109    if (DoMap == true)
 110       ReMap();
 111 }
 112                                                                         /*}}}*/
 113 // Cache::ReMap - Reopen the cache file                                 /*{{{*/
 114 // ---------------------------------------------------------------------
 115 /* If the file is already closed then this will open it open it. */
 116 bool pkgCache::ReMap()
 117 {
 118    // Apply the typecasts.
 119    HeaderP = (Header *)Map.Data();
 120    PkgP = (Package *)Map.Data();
 121    VerFileP = (VerFile *)Map.Data();
 122    DescFileP = (DescFile *)Map.Data();
 123    PkgFileP = (PackageFile *)Map.Data();
 124    VerP = (Version *)Map.Data();
 125    DescP = (Description *)Map.Data();
 126    ProvideP = (Provides *)Map.Data();
 127    DepP = (Dependency *)Map.Data();
 128    StringItemP = (StringItem *)Map.Data();
 129    StrP = (char *)Map.Data();
 130
 131    if (Map.Size() == 0 || HeaderP == 0)
 132       return _error->Error(_("Empty package cache"));
 133
 134    // Check the header
 135    Header DefHeader;
 136    if (HeaderP->Signature != DefHeader.Signature ||
 137        HeaderP->Dirty == true)
 138       return _error->Error(_("The package cache file is corrupted"));
 139
 140    if (HeaderP->MajorVersion != DefHeader.MajorVersion ||
 141        HeaderP->MinorVersion != DefHeader.MinorVersion ||
 142        HeaderP->CheckSizes(DefHeader) == false)
 143       return _error->Error(_("The package cache file is an incompatible version"));
 144
 145    // Locate our VS..
 146    if (HeaderP->VerSysName == 0 ||
 147        (VS = pkgVersioningSystem::GetVS(StrP + HeaderP->VerSysName)) == 0)
 148       return _error->Error(_("This APT does not support the versioning system '%s'"),StrP + HeaderP->VerSysName);
 149
 150    // Chcek the arhcitecture
 151    if (HeaderP->Architecture == 0 ||
 152        _config->Find("APT::Architecture") != StrP + HeaderP->Architecture)
 153       return _error->Error(_("The package cache was built for a different architecture"));
 154    return true;
 155 }
 156                                                                         /*}}}*/
 157 // Cache::Hash - Hash a string                                          /*{{{*/
 158 // ---------------------------------------------------------------------
 159 /* This is used to generate the hash entries for the HashTable. With my
 160    package list from bo this function gets 94% table usage on a 512 item
 161    table (480 used items) */
 162 unsigned long pkgCache::sHash(const string &Str) const
 163 {
 164    unsigned long Hash = 0;
 165    for (string::const_iterator I = Str.begin(); I != Str.end(); I++)
 166       Hash = 5*Hash + tolower(*I);
 167    return Hash % _count(HeaderP->HashTable);
 168 }
 169
 170 unsigned long pkgCache::sHash(const char *Str) const
 171 {
 172    unsigned long Hash = 0;
 173    for (const char *I = Str; *I != 0; I++)
 174       Hash = 5*Hash + tolower(*I);
 175    return Hash % _count(HeaderP->HashTable);
 176 }
 177
 178                                                                         /*}}}*/
 179 // Cache::FindPkg - Locate a package by name                            /*{{{*/
 180 // ---------------------------------------------------------------------
 181 /* Returns 0 on error, pointer to the package otherwise */
 182 pkgCache::PkgIterator pkgCache::FindPkg(const string &Name)
 183 {
 184    // Look at the hash bucket
 185    Package *Pkg = PkgP + HeaderP->HashTable[Hash(Name)];
 186    for (; Pkg != PkgP; Pkg = PkgP + Pkg->NextPackage)
 187    {
 188       if (Pkg->Name != 0 && StrP[Pkg->Name] == Name[0] &&
 189           stringcasecmp(Name,StrP + Pkg->Name) == 0)
 190          return PkgIterator(*this,Pkg);
 191    }
 192    return PkgIterator(*this,0);
 193 }
 194                                                                         /*}}}*/
 195 // Cache::CompTypeDeb - Return a string describing the compare type     /*{{{*/
 196 // ---------------------------------------------------------------------
 197 /* This returns a string representation of the dependency compare
 198    type in the weird debian style.. */
 199 const char *pkgCache::CompTypeDeb(unsigned char Comp)
 200 {
 201    const char *Ops[] = {"","<=",">=","<<",">>","=","!="};
 202    if ((unsigned)(Comp & 0xF) < 7)
 203       return Ops[Comp & 0xF];
 204    return "";
 205 }
 206                                                                         /*}}}*/
 207 // Cache::CompType - Return a string describing the compare type        /*{{{*/
 208 // ---------------------------------------------------------------------
 209 /* This returns a string representation of the dependency compare
 210    type */
 211 const char *pkgCache::CompType(unsigned char Comp)
 212 {
 213    const char *Ops[] = {"","<=",">=","<",">","=","!="};
 214    if ((unsigned)(Comp & 0xF) < 7)
 215       return Ops[Comp & 0xF];
 216    return "";
 217 }
 218                                                                         /*}}}*/
 219 // Cache::DepType - Return a string describing the dep type             /*{{{*/
 220 // ---------------------------------------------------------------------
 221 /* */
 222 const char *pkgCache::DepType(unsigned char Type)
 223 {
 224    const char *Types[] = {"",_("Depends"),_("PreDepends"),_("Suggests"),
 225                           _("Recommends"),_("Conflicts"),_("Replaces"),
 226                           _("Obsoletes"),_("Breaks")};
 227    if (Type < sizeof(Types)/sizeof(*Types))
 228       return Types[Type];
 229    return "";
 230 }
 231                                                                         /*}}}*/
 232 // Cache::Priority - Convert a priority value to a string               /*{{{*/
 233 // ---------------------------------------------------------------------
 234 /* */
 235 const char *pkgCache::Priority(unsigned char Prio)
 236 {
 237    const char *Mapping[] = {0,_("important"),_("required"),_("standard"),
 238                             _("optional"),_("extra")};
 239    if (Prio < _count(Mapping))
 240       return Mapping[Prio];
 241    return 0;
 242 }
 243                                                                         /*}}}*/
 244 // Bases for iterator classes                                           /*{{{*/
 245 void pkgCache::VerIterator::_dummy() {}
 246 void pkgCache::DepIterator::_dummy() {}
 247 void pkgCache::PrvIterator::_dummy() {}
 248 void pkgCache::DescIterator::_dummy() {}
 249                                                                         /*}}}*/
 250 // PkgIterator::operator ++ - Postfix incr                              /*{{{*/
 251 // ---------------------------------------------------------------------
 252 /* This will advance to the next logical package in the hash table. */
 253 void pkgCache::PkgIterator::operator ++(int)
 254 {
 255    // Follow the current links
 256    if (Pkg != Owner->PkgP)
 257       Pkg = Owner->PkgP + Pkg->NextPackage;
 258
 259    // Follow the hash table
 260    while (Pkg == Owner->PkgP && (HashIndex+1) < (signed)_count(Owner->HeaderP->HashTable))
 261    {
 262       HashIndex++;
 263       Pkg = Owner->PkgP + Owner->HeaderP->HashTable[HashIndex];
 264    }
 265 };
 266                                                                         /*}}}*/
 267 // PkgIterator::State - Check the State of the package                  /*{{{*/
 268 // ---------------------------------------------------------------------
 269 /* By this we mean if it is either cleanly installed or cleanly removed. */
 270 pkgCache::PkgIterator::OkState pkgCache::PkgIterator::State() const
 271 {
 272    if (Pkg->InstState == pkgCache::State::ReInstReq ||
 273        Pkg->InstState == pkgCache::State::HoldReInstReq)
 274       return NeedsUnpack;
 275
 276    if (Pkg->CurrentState == pkgCache::State::UnPacked ||
 277        Pkg->CurrentState == pkgCache::State::HalfConfigured ||
 278        Pkg->CurrentState == pkgCache::State::TriggersPending ||
 279        Pkg->CurrentState == pkgCache::State::TriggersAwaited)
 280       return NeedsConfigure;
 281
 282    if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||
 283        Pkg->InstState != pkgCache::State::Ok)
 284       return NeedsUnpack;
 285
 286    return NeedsNothing;
 287 }
 288                                                                         /*}}}*/
 289 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 290 // ---------------------------------------------------------------------
 291 /* Currently critical deps are defined as depends, predepends and
 292    conflicts (including dpkg's Breaks fields). */
 293 bool pkgCache::DepIterator::IsCritical()
 294 {
 295    if (Dep->Type == pkgCache::Dep::Conflicts ||
 296        Dep->Type == pkgCache::Dep::DpkgBreaks ||
 297        Dep->Type == pkgCache::Dep::Obsoletes ||
 298        Dep->Type == pkgCache::Dep::Depends ||
 299        Dep->Type == pkgCache::Dep::PreDepends)
 300       return true;
 301    return false;
 302 }
 303                                                                         /*}}}*/
 304 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 305 // ---------------------------------------------------------------------
 306 /* This intellegently looks at dep target packages and tries to figure
 307    out which package should be used. This is needed to nicely handle
 308    provide mapping. If the target package has no other providing packages
 309    then it returned. Otherwise the providing list is looked at to
 310    see if there is one one unique providing package if so it is returned.
 311    Otherwise true is returned and the target package is set. The return
 312    result indicates whether the node should be expandable
 313
 314    In Conjunction with the DepCache the value of Result may not be
 315    super-good since the policy may have made it uninstallable. Using
 316    AllTargets is better in this case. */
 317 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 318 {
 319    Result = TargetPkg();
 320
 321    // No provides at all
 322    if (Result->ProvidesList == 0)
 323       return false;
 324
 325    // There is the Base package and the providing ones which is at least 2
 326    if (Result->VersionList != 0)
 327       return true;
 328
 329    /* We have to skip over indirect provisions of the package that
 330       owns the dependency. For instance, if libc5-dev depends on the
 331       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 332       we must ignore libc5-dev when considering the provides list. */
 333    PrvIterator PStart = Result.ProvidesList();
 334    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);
 335
 336    // Nothing but indirect self provides
 337    if (PStart.end() == true)
 338       return false;
 339
 340    // Check for single packages in the provides list
 341    PrvIterator P = PStart;
 342    for (; P.end() != true; P++)
 343    {
 344       // Skip over self provides
 345       if (P.OwnerPkg() == ParentPkg())
 346          continue;
 347       if (PStart.OwnerPkg() != P.OwnerPkg())
 348          break;
 349    }
 350
 351    Result = PStart.OwnerPkg();
 352
 353    // Check for non dups
 354    if (P.end() != true)
 355       return true;
 356
 357    return false;
 358 }
 359                                                                         /*}}}*/
 360 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 361 // ---------------------------------------------------------------------
 362 /* This is a more useful version of TargetPkg() that follows versioned
 363    provides. It includes every possible package-version that could satisfy
 364    the dependency. The last item in the list has a 0. The resulting pointer
 365    must be delete [] 'd */
 366 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 367 {
 368    Version **Res = 0;
 369    unsigned long Size =0;
 370    while (1)
 371    {
 372       Version **End = Res;
 373       PkgIterator DPkg = TargetPkg();
 374
 375       // Walk along the actual package providing versions
 376       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
 377       {
 378          if (Owner->VS->CheckDep(I.VerStr(),Dep->CompareOp,TargetVer()) == false)
 379             continue;
 380
 381          if ((Dep->Type == pkgCache::Dep::Conflicts ||
 382               Dep->Type == pkgCache::Dep::DpkgBreaks ||
 383               Dep->Type == pkgCache::Dep::Obsoletes) &&
 384              ParentPkg() == I.ParentPkg())
 385             continue;
 386
 387          Size++;
 388          if (Res != 0)
 389             *End++ = I;
 390       }
 391
 392       // Follow all provides
 393       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
 394       {
 395          if (Owner->VS->CheckDep(I.ProvideVersion(),Dep->CompareOp,TargetVer()) == false)
 396             continue;
 397
 398          if ((Dep->Type == pkgCache::Dep::Conflicts ||
 399               Dep->Type == pkgCache::Dep::DpkgBreaks ||
 400               Dep->Type == pkgCache::Dep::Obsoletes) &&
 401              ParentPkg() == I.OwnerPkg())
 402             continue;
 403
 404          Size++;
 405          if (Res != 0)
 406             *End++ = I.OwnerVer();
 407       }
 408
 409       // Do it again and write it into the array
 410       if (Res == 0)
 411       {
 412          Res = new Version *[Size+1];
 413          Size = 0;
 414       }
 415       else
 416       {
 417          *End = 0;
 418          break;
 419       }
 420    }
 421
 422    return Res;
 423 }
 424                                                                         /*}}}*/
 425 // DepIterator::GlobOr - Compute an OR group                            /*{{{*/
 426 // ---------------------------------------------------------------------
 427 /* This Takes an iterator, iterates past the current dependency grouping
 428    and returns Start and End so that so End is the final element
 429    in the group, if End == Start then D is End++ and End is the
 430    dependency D was pointing to. Use in loops to iterate sensibly. */
 431 void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
 432 {
 433    // Compute a single dependency element (glob or)
 434    Start = *this;
 435    End = *this;
 436    for (bool LastOR = true; end() == false && LastOR == true;)
 437    {
 438       LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 439       (*this)++;
 440       if (LastOR == true)
 441          End = (*this);
 442    }
 443 }
 444                                                                         /*}}}*/
 445 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 446 // ---------------------------------------------------------------------
 447 /* This just looks over the version list to see if B is listed before A. In
 448    most cases this will return in under 4 checks, ver lists are short. */
 449 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 450 {
 451    // Check if they are equal
 452    if (*this == B)
 453       return 0;
 454    if (end() == true)
 455       return -1;
 456    if (B.end() == true)
 457       return 1;
 458
 459    /* Start at A and look for B. If B is found then A > B otherwise
 460       B was before A so A < B */
 461    VerIterator I = *this;
 462    for (;I.end() == false; I++)
 463       if (I == B)
 464          return 1;
 465    return -1;
 466 }
 467                                                                         /*}}}*/
 468 // VerIterator::Downloadable - Checks if the version is downloadable    /*{{{*/
 469 // ---------------------------------------------------------------------
 470 /* */
 471 bool pkgCache::VerIterator::Downloadable() const
 472 {
 473    VerFileIterator Files = FileList();
 474    for (; Files.end() == false; Files++)
 475       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
 476          return true;
 477    return false;
 478 }
 479                                                                         /*}}}*/
 480 // VerIterator::Automatic - Check if this version is 'automatic'        /*{{{*/
 481 // ---------------------------------------------------------------------
 482 /* This checks to see if any of the versions files are not NotAutomatic.
 483    True if this version is selectable for automatic installation. */
 484 bool pkgCache::VerIterator::Automatic() const
 485 {
 486    VerFileIterator Files = FileList();
 487    for (; Files.end() == false; Files++)
 488       if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
 489          return true;
 490    return false;
 491 }
 492                                                                         /*}}}*/
 493 // VerIterator::NewestFile - Return the newest file version relation    /*{{{*/
 494 // ---------------------------------------------------------------------
 495 /* This looks at the version numbers associated with all of the sources
 496    this version is in and returns the highest.*/
 497 pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
 498 {
 499    VerFileIterator Files = FileList();
 500    VerFileIterator Highest = Files;
 501    for (; Files.end() == false; Files++)
 502    {
 503       if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
 504          Highest = Files;
 505    }
 506
 507    return Highest;
 508 }
 509                                                                         /*}}}*/
 510 // VerIterator::RelStr - Release description string                     /*{{{*/
 511 // ---------------------------------------------------------------------
 512 /* This describes the version from a release-centric manner. The output is a
 513    list of Label:Version/Archive */
 514 string pkgCache::VerIterator::RelStr()
 515 {
 516    bool First = true;
 517    string Res;
 518    for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; I++)
 519    {
 520       // Do not print 'not source' entries'
 521       pkgCache::PkgFileIterator File = I.File();
 522       if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
 523          continue;
 524
 525       // See if we have already printed this out..
 526       bool Seen = false;
 527       for (pkgCache::VerFileIterator J = this->FileList(); I != J; J++)
 528       {
 529          pkgCache::PkgFileIterator File2 = J.File();
 530          if (File2->Label == 0 || File->Label == 0)
 531             continue;
 532
 533          if (strcmp(File.Label(),File2.Label()) != 0)
 534             continue;
 535
 536          if (File2->Version == File->Version)
 537          {
 538             Seen = true;
 539             break;
 540          }
 541          if (File2->Version == 0 || File->Version == 0)
 542             break;
 543          if (strcmp(File.Version(),File2.Version()) == 0)
 544             Seen = true;
 545       }
 546
 547       if (Seen == true)
 548          continue;
 549
 550       if (First == false)
 551          Res += ", ";
 552       else
 553          First = false;
 554
 555       if (File->Label != 0)
 556          Res = Res + File.Label() + ':';
 557
 558       if (File->Archive != 0)
 559       {
 560          if (File->Version == 0)
 561             Res += File.Archive();
 562          else
 563             Res = Res + File.Version() + '/' +  File.Archive();
 564       }
 565       else
 566       {
 567          // No release file, print the host name that this came from
 568          if (File->Site == 0 || File.Site()[0] == 0)
 569             Res += "localhost";
 570          else
 571             Res += File.Site();
 572       }
 573    }
 574    return Res;
 575 }
 576                                                                         /*}}}*/
 577 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 578 // ---------------------------------------------------------------------
 579 /* This stats the file and compares its stats with the ones that were
 580    stored during generation. Date checks should probably also be
 581    included here. */
 582 bool pkgCache::PkgFileIterator::IsOk()
 583 {
 584    struct stat Buf;
 585    if (stat(FileName(),&Buf) != 0)
 586       return false;
 587
 588    if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
 589       return false;
 590
 591    return true;
 592 }
 593                                                                         /*}}}*/
 594 // PkgFileIterator::RelStr - Return the release string                  /*{{{*/
 595 // ---------------------------------------------------------------------
 596 /* */
 597 string pkgCache::PkgFileIterator::RelStr()
 598 {
 599    string Res;
 600    if (Version() != 0)
 601       Res = Res + (Res.empty() == true?"v=":",v=") + Version();
 602    if (Origin() != 0)
 603       Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();
 604    if (Archive() != 0)
 605       Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();
 606    if (Label() != 0)
 607       Res = Res + (Res.empty() == true?"l=":",l=")  + Label();
 608    if (Component() != 0)
 609       Res = Res + (Res.empty() == true?"c=":",c=")  + Component();
 610    return Res;
 611 }
 612                                                                         /*}}}*/
 613 // VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/
 614 // ---------------------------------------------------------------------
 615 /* return a DescIter for the current locale or the default if none is
 616  * found
 617  */
 618 pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const
 619 {
 620    pkgCache::DescIterator DescDefault = DescriptionList();
 621    pkgCache::DescIterator Desc = DescDefault;
 622    for (; Desc.end() == false; Desc++)
 623       if (pkgIndexFile::LanguageCode() == Desc.LanguageCode())
 624          break;
 625    if (Desc.end() == true)
 626       Desc = DescDefault;
 627    return Desc;
 628 };
 629
 630                                                                         /*}}}*/