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