apt-pkg/version.cc

   1 // -*- mode: cpp; mode: fold -*-
   2 // Description                                                          /*{{{*/
   3 // $Id: version.cc,v 1.2 1998/07/04 05:57:40 jgg Exp $
   4 /* ######################################################################
   5
   6    Version - Version string
   7
   8    Version comparing is done using the == and < operators. STL's
   9    function.h provides the remaining set of comparitors. A directly
  10    callable non-string class version is provided for functions manipulating
  11    the cache file (esp the sort function).
  12
  13    A version is defined to be equal if a case sensitive compare returns
  14    that the two strings are the same. For compatibility with the QSort
  15    function this version returns -1,0,1.
  16
  17    ##################################################################### */
  18                                                                         /*}}}*/
  19 // Include Files                                                        /*{{{*/
  20 #include <pkglib/version.h>
  21 #include <pkglib/pkgcache.h>
  22
  23 #include <stdlib.h>
  24                                                                         /*}}}*/
  25
  26 // Version::pkgVersion - Default Constructor                            /*{{{*/
  27 // ---------------------------------------------------------------------
  28 /* */
  29 pkgVersion::pkgVersion()
  30 {
  31 }
  32                                                                         /*}}}*/
  33 // Version::operator == - Checks if two versions are equal              /*{{{*/
  34 // ---------------------------------------------------------------------
  35 /* We can't simply perform a string compare because of epochs. */
  36 bool pkgVersion::operator ==(const pkgVersion &Vrhs) const
  37 {
  38    if (pkgVersionCompare(Value.begin(),Value.end(),
  39                      Vrhs.Value.begin(),Vrhs.Value.end()) == 0)
  40       return true;
  41    return false;
  42 }
  43                                                                         /*}}}*/
  44 // Version::operator < - Checks if this is less than another version    /*{{{*/
  45 // ---------------------------------------------------------------------
  46 /* All other forms of comparision can be built up from this single function.
  47     a > b -> b < a
  48     a <= b -> !(a > b) -> !(b < a)
  49     a >= b -> !(a < b)
  50  */
  51 bool pkgVersion::operator <(const pkgVersion &Vrhs) const
  52 {
  53    if (pkgVersionCompare(Value.begin(),Value.end(),
  54                      Vrhs.Value.begin(),Vrhs.Value.end()) == -1)
  55       return true;
  56    return false;
  57 }
  58                                                                         /*}}}*/
  59 // StrToLong - Convert the string between two iterators to a long       /*{{{*/
  60 // ---------------------------------------------------------------------
  61 /* */
  62 static unsigned long StrToLong(const char *begin,const char *end)
  63 {
  64    char S[40];
  65    char *I = S;
  66    for (; begin != end && I < S + 40;)
  67       *I++ = *begin++;
  68    *I = 0;
  69    return strtoul(S,0,10);
  70 }
  71                                                                         /*}}}*/
  72 // VersionCompare (op) - Greater than comparison for versions           /*{{{*/
  73 // ---------------------------------------------------------------------
  74 /* */
  75 int pkgVersionCompare(const char *A, const char *B)
  76 {
  77    return pkgVersionCompare(A,A + strlen(A),B,B + strlen(B));
  78 }
  79 int pkgVersionCompare(string A,string B)
  80 {
  81    return pkgVersionCompare(A.begin(),A.end(),B.begin(),B.end());
  82 }
  83
  84                                                                         /*}}}*/
  85 // VersionCompare - Greater than comparison for versions                /*{{{*/
  86 // ---------------------------------------------------------------------
  87 /* */
  88 int pkgVersionCompare(const char *A, const char *AEnd, const char *B,
  89                        const char *BEnd)
  90 {
  91    // lhs = left hand side, rhs = right hand side
  92    const char *lhs = A;
  93    const char *rhs = B;
  94
  95    /* Consider epochs. They need special handling because an epoch
  96       must not be compared against the first element of the real version.
  97       This works okay when both sides have an epoch but when only one
  98       does it must compare the missing epoch to 0 */
  99    for (;lhs != AEnd && *lhs != ':'; lhs++);
 100    for (;rhs != BEnd && *rhs != ':'; rhs++);
 101
 102    // Parse the epoch out
 103    unsigned long lhsEpoch = 0;
 104    unsigned long rhsEpoch = 0;
 105    if (lhs != AEnd && *lhs == ':')
 106       lhsEpoch = StrToLong(A,lhs);
 107    if (rhs != BEnd && *rhs == ':')
 108       rhsEpoch = StrToLong(B,rhs);
 109    if (lhsEpoch != rhsEpoch)
 110    {
 111       if (lhsEpoch > rhsEpoch)
 112          return 1;
 113       return -1;
 114    }
 115
 116    /* Iterate over the whole string
 117       What this does is to spilt the whole string into groups of
 118       numeric and non numeric portions. For instance:
 119          a67bhgs89
 120       Has 4 portions 'a', '67', 'bhgs', '89'. A more normal:
 121          2.7.2-linux-1
 122       Has '2', '.', '7', '.' ,'-linux-','1' */
 123    lhs = A;
 124    rhs = B;
 125    while (lhs != AEnd && rhs != BEnd)
 126    {
 127       // Starting points
 128       const char *Slhs = lhs;
 129       const char *Srhs = rhs;
 130
 131       // Compute ending points were we have passed over the portion
 132       bool Digit = (isdigit(*lhs) > 0?true:false);
 133       for (;lhs != AEnd && (isdigit(*lhs) > 0?true:false) == Digit; lhs++);
 134       for (;rhs != BEnd && (isdigit(*rhs) > 0?true:false) == Digit; rhs++);
 135
 136       if (Digit == true)
 137       {
 138          // If the lhs has a digit and the rhs does not then true
 139          if (rhs - Srhs == 0)
 140             return -1;
 141
 142          // Generate integers from the strings.
 143          unsigned long Ilhs = StrToLong(Slhs,lhs);
 144          unsigned long Irhs = StrToLong(Srhs,rhs);
 145          if (Ilhs != Irhs)
 146          {
 147             if (Ilhs > Irhs)
 148                return 1;
 149             return -1;
 150          }
 151       }
 152       else
 153       {
 154          // They are equal length so do a straight text compare
 155          for (;Slhs != lhs && Srhs != rhs; Slhs++, Srhs++)
 156          {
 157             if (*Slhs != *Srhs)
 158             {
 159                /* We need to compare non alpha chars as higher than alpha
 160                   chars (a < !) This is so things like  7.6p2-4 and 7.6-0
 161                   compare higher as well as . and -. I am not sure how
 162                   the dpkg code manages to achive the != '-' test, but it
 163                   is necessary. */
 164                int lc = *Slhs;
 165                int rc = *Srhs;
 166                if (isalpha(lc) == 0 && lc != '-') lc += 256;
 167                if (isalpha(rc) == 0 && rc != '-') rc += 256;
 168                if (lc > rc)
 169                   return 1;
 170                return -1;
 171             }
 172          }
 173
 174          // If the lhs is shorter than the right it is 'less'
 175          if (lhs - Slhs < rhs - Srhs)
 176             return -1;
 177
 178          // If the lhs is longer than the right it is 'more'
 179          if (lhs - Slhs > rhs - Srhs)
 180             return 1;
 181       }
 182    }
 183
 184    // The strings must be equal
 185    if (lhs == AEnd && rhs == BEnd)
 186       return 0;
 187
 188    // lhs is shorter
 189    if (lhs == AEnd)
 190       return -1;
 191
 192    // rhs is shorter
 193    if (rhs == BEnd)
 194       return 1;
 195
 196    // Shouldnt happen
 197    return 1;
 198 }
 199                                                                         /*}}}*/
 200 // CheckDep - Check a single dependency                                 /*{{{*/
 201 // ---------------------------------------------------------------------
 202 /* This simply preforms the version comparison and switch based on
 203    operator. */
 204 bool pkgCheckDep(const char *DepVer,const char *PkgVer,int Op)
 205 {
 206    if (DepVer == 0)
 207       return true;
 208    if (PkgVer == 0)
 209       return false;
 210
 211    // Perform the actuall comparision.
 212    int Res = pkgVersionCompare(PkgVer,DepVer);
 213    switch (Op & 0x0F)
 214    {
 215       case pkgCache::LessEq:
 216       if (Res <= 0)
 217          return true;
 218       break;
 219
 220       case pkgCache::GreaterEq:
 221       if (Res >= 0)
 222          return true;
 223       break;
 224
 225       case pkgCache::Less:
 226       if (Res < 0)
 227          return true;
 228       break;
 229
 230       case pkgCache::Greater:
 231       if (Res > 0)
 232          return true;
 233       break;
 234
 235       case pkgCache::Equals:
 236       if (Res == 0)
 237          return true;
 238       break;
 239
 240       case pkgCache::NotEquals:
 241       if (Res != 0)
 242          return true;
 243       break;
 244    }
 245
 246    return false;
 247 }
 248                                                                         /*}}}*/
 249