ceph/src/boost/tools/build/src/build/version.jam

   1 # Copyright 2021 Nikita Kniazev
   2 # Copyright 2002, 2003, 2004, 2006 Vladimir Prus
   3 # Copyright 2008, 2012 Jurko Gospodnetic
   4 # Distributed under the Boost Software License, Version 1.0.
   5 # (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt)
   6
   7 import numbers ;
   8
   9
  10 # Mirror engine JAM_VERSION
  11 .major = "4" ;
  12 .minor = "8" ;
  13
  14
  15 rule boost-build ( )
  16 {
  17     return "$(.major).$(.minor)-git" ;
  18 }
  19
  20
  21 rule print ( )
  22 {
  23     if [ verify-engine-version ]
  24     {
  25         ECHO "B2" [ boost-build ] ;
  26     }
  27 }
  28
  29
  30 rule verify-engine-version ( )
  31 {
  32     local v = [ modules.peek : JAM_VERSION ] ;
  33
  34     if $(v[1]) != $(.major) || $(v[2]) != $(.minor)
  35     {
  36         local argv = [ modules.peek : ARGV ] ;
  37         local e = $(argv[1]) ;
  38         local l = [ modules.binding version ] ;
  39         l = $(l:D) ;
  40         l = $(l:D) ;
  41         ECHO "warning: mismatched versions of B2 engine and core" ;
  42         ECHO "warning: B2 engine ($(e)) is $(v:J=.)" ;
  43         ECHO "warning: B2 core (at $(l)) is" [ boost-build ] ;
  44     }
  45     else
  46     {
  47         return true ;
  48     }
  49 }
  50
  51
  52 # Utility rule for testing whether all elements in a sequence are equal to 0.
  53 #
  54 local rule is-all-zeroes ( sequence * )
  55 {
  56     local result = "true" ;
  57     for local e in $(sequence)
  58     {
  59         if $(e) != "0"
  60         {
  61             result = "" ;
  62         }
  63     }
  64     return $(result) ;
  65 }
  66
  67
  68 # Returns "true" if the first version is less than the second one.
  69 #
  70 rule version-less ( lhs + : rhs + )
  71 {
  72     numbers.check $(lhs) ;
  73     numbers.check $(rhs) ;
  74
  75     local done ;
  76     local result ;
  77
  78     while ! $(done) && $(lhs) && $(rhs)
  79     {
  80         if [ numbers.less $(lhs[1]) $(rhs[1]) ]
  81         {
  82             done = "true" ;
  83             result = "true" ;
  84         }
  85         else if [ numbers.less $(rhs[1]) $(lhs[1])  ]
  86         {
  87             done = "true" ;
  88         }
  89         else
  90         {
  91             lhs = $(lhs[2-]) ;
  92             rhs = $(rhs[2-]) ;
  93         }
  94     }
  95     if ( ! $(done) && ! $(lhs) && ! [ is-all-zeroes $(rhs) ] )
  96     {
  97         result = "true" ;
  98     }
  99
 100     return $(result) ;
 101 }
 102
 103 # Returns "true" if the required version is compatible with the having one.
 104 # This uses sematic versioning where (major.x.y) is compatible with
 105 # (major.n.m) and (major.x.z). And is incompatible for other values.
 106 #
 107 rule version-compatible ( req + : has + )
 108 {
 109     numbers.check $(req) ;
 110     numbers.check $(has) ;
 111
 112     if $(req) = $(has)
 113     {
 114         return true ;
 115     }
 116
 117     while $(req) && [ numbers.equal $(req[1]) $(has[1]:E=0) ]
 118     {
 119         req = $(req[2-]) ;
 120         has = $(has[2-]) ;
 121     }
 122
 123     if $(req)
 124     {
 125         return ;
 126     }
 127
 128     return true ;
 129 }
 130
 131
 132 # Returns "true" if the current JAM version version is at least the given
 133 # version.
 134 #
 135 rule check-jam-version ( version + )
 136 {
 137     local version-tag = $(version:J=.) ;
 138     if ! $(version-tag)
 139     {
 140         import errors ;
 141         errors.error Invalid version "specifier:" : $(version:E="(undefined)") ;
 142     }
 143
 144     if ! $(.jam-version-check.$(version-tag))-is-defined
 145     {
 146         local jam-version = [ modules.peek : JAM_VERSION ] ;
 147         if ! $(jam-version)
 148         {
 149             import errors ;
 150             errors.error "Unable to deduce Boost Jam version. Your Boost Jam"
 151                 "installation is most likely terribly outdated." ;
 152         }
 153         .jam-version-check.$(version-tag) = "true" ;
 154         if [ version-less [ modules.peek : JAM_VERSION ] : $(version) ]
 155         {
 156             .jam-version-check.$(version-tag) = "" ;
 157         }
 158     }
 159     return $(.jam-version-check.$(version-tag)) ;
 160 }
 161
 162
 163 rule __test__ ( )
 164 {
 165     import assert ;
 166
 167     local jam-version = [ modules.peek : JAM_VERSION ] ;
 168     local future-version = $(jam-version) ;
 169     future-version += "1" ;
 170
 171     assert.true  check-jam-version $(jam-version)    ;
 172     assert.false check-jam-version $(future-version) ;
 173
 174     assert.true  version-less  0          :  1          ;
 175     assert.false version-less  0          :  0          ;
 176     assert.true  version-less  1          :  2          ;
 177     assert.false version-less  1          :  1          ;
 178     assert.false version-less  2          :  1          ;
 179     assert.true  version-less  3 1 20     :  3 4 10     ;
 180     assert.false version-less  3 1 10     :  3 1 10     ;
 181     assert.false version-less  3 4 10     :  3 1 20     ;
 182     assert.true  version-less  3 1 20 5 1 :  3 4 10     ;
 183     assert.false version-less  3 1 10 5 1 :  3 1 10     ;
 184     assert.false version-less  3 4 10 5 1 :  3 1 20     ;
 185     assert.true  version-less  3 1 20     :  3 4 10 5 1 ;
 186     assert.true  version-less  3 1 10     :  3 1 10 5 1 ;
 187     assert.false version-less  3 4 10     :  3 1 20 5 1 ;
 188     assert.false version-less  3 1 10     :  3 1 10 0 0 ;
 189     assert.false version-less  3 1 10 0 0 :  3 1 10     ;
 190     assert.false version-less  3 1 10 0   :  3 1 10 0 0 ;
 191     assert.false version-less  3 1 10 0   : 03 1 10 0 0 ;
 192     assert.false version-less 03 1 10 0   :  3 1 10 0 0 ;
 193
 194     # TODO: Add tests for invalid input data being sent to version-less.
 195
 196
 197     assert.true  version-compatible 4     : 4     ;
 198     assert.true  version-compatible 4     : 4 9   ;
 199     assert.false version-compatible 4 9   : 4     ;
 200     assert.true  version-compatible 4 9   : 4 9   ;
 201     assert.false version-compatible 4 9 1 : 4 9   ;
 202     assert.true  version-compatible 4 9 1 : 4 9 1 ;
 203     assert.false version-compatible 4 8   : 4 9   ;
 204     assert.false version-compatible 4 8 1 : 4 9   ;
 205     assert.false version-compatible 4 8 1 : 4 9 1 ;
 206     assert.true  version-compatible 5     : 5     ;
 207     assert.false version-compatible 5     : 4     ;
 208     assert.false version-compatible 5     : 4 9   ;
 209     assert.false version-compatible 5 1   : 5     ;
 210     assert.true  version-compatible 5 1   : 5 1   ;
 211     assert.false version-compatible 5 1   : 5 2   ;
 212     assert.false version-compatible 5 1 1 : 5     ;
 213     assert.false version-compatible 5 1 1 : 5 1   ;
 214     assert.false version-compatible 5 2   : 5     ;
 215     assert.false version-compatible 5 2   : 5 1   ;
 216     assert.true  version-compatible 5 2   : 5 2   ;
 217     assert.true  version-compatible 4     : 4 0   ;
 218     assert.true  version-compatible 4 0   : 4     ;
 219     assert.true  version-compatible 04    : 4     ;
 220     assert.true  version-compatible 04    : 04    ;
 221     assert.true  version-compatible 04    : 4     ;
 222     assert.true  version-compatible 04 00 : 04    ;
 223     assert.true  version-compatible 04    : 04 00 ;
 224 }
 225