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