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 = 6;
  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       return NeedsConfigure;
 279
 280    if (Pkg->CurrentState == pkgCache::State::HalfInstalled ||
 281        Pkg->InstState != pkgCache::State::Ok)
 282       return NeedsUnpack;
 283
 284    return NeedsNothing;
 285 }
 286                                                                         /*}}}*/
 287 // DepIterator::IsCritical - Returns true if the dep is important       /*{{{*/
 288 // ---------------------------------------------------------------------
 289 /* Currently critical deps are defined as depends, predepends and
 290    conflicts (including dpkg's Breaks fields). */
 291 bool pkgCache::DepIterator::IsCritical()
 292 {
 293    if (Dep->Type == pkgCache::Dep::Conflicts ||
 294        Dep->Type == pkgCache::Dep::DpkgBreaks ||
 295        Dep->Type == pkgCache::Dep::Obsoletes ||
 296        Dep->Type == pkgCache::Dep::Depends ||
 297        Dep->Type == pkgCache::Dep::PreDepends)
 298       return true;
 299    return false;
 300 }
 301                                                                         /*}}}*/
 302 // DepIterator::SmartTargetPkg - Resolve dep target pointers w/provides /*{{{*/
 303 // ---------------------------------------------------------------------
 304 /* This intellegently looks at dep target packages and tries to figure
 305    out which package should be used. This is needed to nicely handle
 306    provide mapping. If the target package has no other providing packages
 307    then it returned. Otherwise the providing list is looked at to
 308    see if there is one one unique providing package if so it is returned.
 309    Otherwise true is returned and the target package is set. The return
 310    result indicates whether the node should be expandable
 311
 312    In Conjunction with the DepCache the value of Result may not be
 313    super-good since the policy may have made it uninstallable. Using
 314    AllTargets is better in this case. */
 315 bool pkgCache::DepIterator::SmartTargetPkg(PkgIterator &Result)
 316 {
 317    Result = TargetPkg();
 318
 319    // No provides at all
 320    if (Result->ProvidesList == 0)
 321       return false;
 322
 323    // There is the Base package and the providing ones which is at least 2
 324    if (Result->VersionList != 0)
 325       return true;
 326
 327    /* We have to skip over indirect provisions of the package that
 328       owns the dependency. For instance, if libc5-dev depends on the
 329       virtual package libc-dev which is provided by libc5-dev and libc6-dev
 330       we must ignore libc5-dev when considering the provides list. */
 331    PrvIterator PStart = Result.ProvidesList();
 332    for (; PStart.end() != true && PStart.OwnerPkg() == ParentPkg(); PStart++);
 333
 334    // Nothing but indirect self provides
 335    if (PStart.end() == true)
 336       return false;
 337
 338    // Check for single packages in the provides list
 339    PrvIterator P = PStart;
 340    for (; P.end() != true; P++)
 341    {
 342       // Skip over self provides
 343       if (P.OwnerPkg() == ParentPkg())
 344          continue;
 345       if (PStart.OwnerPkg() != P.OwnerPkg())
 346          break;
 347    }
 348
 349    Result = PStart.OwnerPkg();
 350
 351    // Check for non dups
 352    if (P.end() != true)
 353       return true;
 354
 355    return false;
 356 }
 357                                                                         /*}}}*/
 358 // DepIterator::AllTargets - Returns the set of all possible targets    /*{{{*/
 359 // ---------------------------------------------------------------------
 360 /* This is a more useful version of TargetPkg() that follows versioned
 361    provides. It includes every possible package-version that could satisfy
 362    the dependency. The last item in the list has a 0. The resulting pointer
 363    must be delete [] 'd */
 364 pkgCache::Version **pkgCache::DepIterator::AllTargets()
 365 {
 366    Version **Res = 0;
 367    unsigned long Size =0;
 368    while (1)
 369    {
 370       Version **End = Res;
 371       PkgIterator DPkg = TargetPkg();
 372
 373       // Walk along the actual package providing versions
 374       for (VerIterator I = DPkg.VersionList(); I.end() == false; I++)
 375       {
 376          if (Owner->VS->CheckDep(I.VerStr(),Dep->CompareOp,TargetVer()) == false)
 377             continue;
 378
 379          if ((Dep->Type == pkgCache::Dep::Conflicts ||
 380               Dep->Type == pkgCache::Dep::DpkgBreaks ||
 381               Dep->Type == pkgCache::Dep::Obsoletes) &&
 382              ParentPkg() == I.ParentPkg())
 383             continue;
 384
 385          Size++;
 386          if (Res != 0)
 387             *End++ = I;
 388       }
 389
 390       // Follow all provides
 391       for (PrvIterator I = DPkg.ProvidesList(); I.end() == false; I++)
 392       {
 393          if (Owner->VS->CheckDep(I.ProvideVersion(),Dep->CompareOp,TargetVer()) == false)
 394             continue;
 395
 396          if ((Dep->Type == pkgCache::Dep::Conflicts ||
 397               Dep->Type == pkgCache::Dep::DpkgBreaks ||
 398               Dep->Type == pkgCache::Dep::Obsoletes) &&
 399              ParentPkg() == I.OwnerPkg())
 400             continue;
 401
 402          Size++;
 403          if (Res != 0)
 404             *End++ = I.OwnerVer();
 405       }
 406
 407       // Do it again and write it into the array
 408       if (Res == 0)
 409       {
 410          Res = new Version *[Size+1];
 411          Size = 0;
 412       }
 413       else
 414       {
 415          *End = 0;
 416          break;
 417       }
 418    }
 419
 420    return Res;
 421 }
 422                                                                         /*}}}*/
 423 // DepIterator::GlobOr - Compute an OR group                            /*{{{*/
 424 // ---------------------------------------------------------------------
 425 /* This Takes an iterator, iterates past the current dependency grouping
 426    and returns Start and End so that so End is the final element
 427    in the group, if End == Start then D is End++ and End is the
 428    dependency D was pointing to. Use in loops to iterate sensibly. */
 429 void pkgCache::DepIterator::GlobOr(DepIterator &Start,DepIterator &End)
 430 {
 431    // Compute a single dependency element (glob or)
 432    Start = *this;
 433    End = *this;
 434    for (bool LastOR = true; end() == false && LastOR == true;)
 435    {
 436       LastOR = (Dep->CompareOp & pkgCache::Dep::Or) == pkgCache::Dep::Or;
 437       (*this)++;
 438       if (LastOR == true)
 439          End = (*this);
 440    }
 441 }
 442                                                                         /*}}}*/
 443 // VerIterator::CompareVer - Fast version compare for same pkgs         /*{{{*/
 444 // ---------------------------------------------------------------------
 445 /* This just looks over the version list to see if B is listed before A. In
 446    most cases this will return in under 4 checks, ver lists are short. */
 447 int pkgCache::VerIterator::CompareVer(const VerIterator &B) const
 448 {
 449    // Check if they are equal
 450    if (*this == B)
 451       return 0;
 452    if (end() == true)
 453       return -1;
 454    if (B.end() == true)
 455       return 1;
 456
 457    /* Start at A and look for B. If B is found then A > B otherwise
 458       B was before A so A < B */
 459    VerIterator I = *this;
 460    for (;I.end() == false; I++)
 461       if (I == B)
 462          return 1;
 463    return -1;
 464 }
 465                                                                         /*}}}*/
 466 // VerIterator::Downloadable - Checks if the version is downloadable    /*{{{*/
 467 // ---------------------------------------------------------------------
 468 /* */
 469 bool pkgCache::VerIterator::Downloadable() const
 470 {
 471    VerFileIterator Files = FileList();
 472    for (; Files.end() == false; Files++)
 473       if ((Files.File()->Flags & pkgCache::Flag::NotSource) != pkgCache::Flag::NotSource)
 474          return true;
 475    return false;
 476 }
 477                                                                         /*}}}*/
 478 // VerIterator::Automatic - Check if this version is 'automatic'        /*{{{*/
 479 // ---------------------------------------------------------------------
 480 /* This checks to see if any of the versions files are not NotAutomatic.
 481    True if this version is selectable for automatic installation. */
 482 bool pkgCache::VerIterator::Automatic() const
 483 {
 484    VerFileIterator Files = FileList();
 485    for (; Files.end() == false; Files++)
 486       if ((Files.File()->Flags & pkgCache::Flag::NotAutomatic) != pkgCache::Flag::NotAutomatic)
 487          return true;
 488    return false;
 489 }
 490                                                                         /*}}}*/
 491 // VerIterator::NewestFile - Return the newest file version relation    /*{{{*/
 492 // ---------------------------------------------------------------------
 493 /* This looks at the version numbers associated with all of the sources
 494    this version is in and returns the highest.*/
 495 pkgCache::VerFileIterator pkgCache::VerIterator::NewestFile() const
 496 {
 497    VerFileIterator Files = FileList();
 498    VerFileIterator Highest = Files;
 499    for (; Files.end() == false; Files++)
 500    {
 501       if (Owner->VS->CmpReleaseVer(Files.File().Version(),Highest.File().Version()) > 0)
 502          Highest = Files;
 503    }
 504
 505    return Highest;
 506 }
 507                                                                         /*}}}*/
 508 // VerIterator::RelStr - Release description string                     /*{{{*/
 509 // ---------------------------------------------------------------------
 510 /* This describes the version from a release-centric manner. The output is a
 511    list of Label:Version/Archive */
 512 string pkgCache::VerIterator::RelStr()
 513 {
 514    bool First = true;
 515    string Res;
 516    for (pkgCache::VerFileIterator I = this->FileList(); I.end() == false; I++)
 517    {
 518       // Do not print 'not source' entries'
 519       pkgCache::PkgFileIterator File = I.File();
 520       if ((File->Flags & pkgCache::Flag::NotSource) == pkgCache::Flag::NotSource)
 521          continue;
 522
 523       // See if we have already printed this out..
 524       bool Seen = false;
 525       for (pkgCache::VerFileIterator J = this->FileList(); I != J; J++)
 526       {
 527          pkgCache::PkgFileIterator File2 = J.File();
 528          if (File2->Label == 0 || File->Label == 0)
 529             continue;
 530
 531          if (strcmp(File.Label(),File2.Label()) != 0)
 532             continue;
 533
 534          if (File2->Version == File->Version)
 535          {
 536             Seen = true;
 537             break;
 538          }
 539          if (File2->Version == 0 || File->Version == 0)
 540             break;
 541          if (strcmp(File.Version(),File2.Version()) == 0)
 542             Seen = true;
 543       }
 544
 545       if (Seen == true)
 546          continue;
 547
 548       if (First == false)
 549          Res += ", ";
 550       else
 551          First = false;
 552
 553       if (File->Label != 0)
 554          Res = Res + File.Label() + ':';
 555
 556       if (File->Archive != 0)
 557       {
 558          if (File->Version == 0)
 559             Res += File.Archive();
 560          else
 561             Res = Res + File.Version() + '/' +  File.Archive();
 562       }
 563       else
 564       {
 565          // No release file, print the host name that this came from
 566          if (File->Site == 0 || File.Site()[0] == 0)
 567             Res += "localhost";
 568          else
 569             Res += File.Site();
 570       }
 571    }
 572    return Res;
 573 }
 574                                                                         /*}}}*/
 575 // PkgFileIterator::IsOk - Checks if the cache is in sync with the file /*{{{*/
 576 // ---------------------------------------------------------------------
 577 /* This stats the file and compares its stats with the ones that were
 578    stored during generation. Date checks should probably also be
 579    included here. */
 580 bool pkgCache::PkgFileIterator::IsOk()
 581 {
 582    struct stat Buf;
 583    if (stat(FileName(),&Buf) != 0)
 584       return false;
 585
 586    if (Buf.st_size != (signed)File->Size || Buf.st_mtime != File->mtime)
 587       return false;
 588
 589    return true;
 590 }
 591                                                                         /*}}}*/
 592 // PkgFileIterator::RelStr - Return the release string                  /*{{{*/
 593 // ---------------------------------------------------------------------
 594 /* */
 595 string pkgCache::PkgFileIterator::RelStr()
 596 {
 597    string Res;
 598    if (Version() != 0)
 599       Res = Res + (Res.empty() == true?"v=":",v=") + Version();
 600    if (Origin() != 0)
 601       Res = Res + (Res.empty() == true?"o=":",o=")  + Origin();
 602    if (Archive() != 0)
 603       Res = Res + (Res.empty() == true?"a=":",a=")  + Archive();
 604    if (Label() != 0)
 605       Res = Res + (Res.empty() == true?"l=":",l=")  + Label();
 606    if (Component() != 0)
 607       Res = Res + (Res.empty() == true?"c=":",c=")  + Component();
 608    return Res;
 609 }
 610                                                                         /*}}}*/
 611 // VerIterator::TranslatedDescription - Return the a DescIter for locale/*{{{*/
 612 // ---------------------------------------------------------------------
 613 /* return a DescIter for the current locale or the default if none is
 614  * found
 615  */
 616 pkgCache::DescIterator pkgCache::VerIterator::TranslatedDescription() const
 617 {
 618    pkgCache::DescIterator DescDefault = DescriptionList();
 619    pkgCache::DescIterator Desc = DescDefault;
 620    for (; Desc.end() == false; Desc++)
 621       if (pkgIndexFile::LanguageCode() == Desc.LanguageCode())
 622          break;
 623    if (Desc.end() == true) Desc = DescDefault;
 624    return Desc;
 625 };
 626
 627                                                                         /*}}}*/