defaults/misc/Jambase.misc

   1 # This program is free software: you can redistribute it and/or modify
   2 # it under the terms of the GNU General Public License as published by
   3 # the Free Software Foundation, version 3 of the License ONLY.
   4 #
   5 # This program is distributed in the hope that it will be useful,
   6 # but WITHOUT ANY WARRANTY; without even the implied warranty of
   7 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   8 # GNU General Public License for more details.
   9 #
  10 # You should have received a copy of the GNU General Public License
  11 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  12
  13 # miscelaneous helper rules
  14
  15 #
  16 # Utility rules; no side effects on these
  17 #
  18
  19 # /FGrist path to file ;
  20 #
  21 # Returns a single string that is used as grist
  22 #
  23 rule FGrist {
  24   return $(<:J=!) ;
  25 }
  26
  27
  28 rule FGristFiles {
  29   return $(<:G=$(SOURCE_GRIST:E)) ;
  30 }
  31
  32
  33 ## LOCAL CHANGE: OPT_HEADER_CACHE_EXT
  34 # With header caching, there is no performance penalty to gristing
  35 # header files. It is also not correct to assume that header
  36 # files have global visibility.
  37 #
  38 # So FGristSourceFiles is the same as FGristFiles
  39 #rule FGristSourceFiles
  40
  41
  42 rule FSubDir {
  43   # If $(<) is the path to the current directory, compute the
  44   # path (using ../../ etc) back to that root directory.
  45   if ! $(<[1]) {
  46     return '.' ;
  47   } else {
  48     local _d = '..' ;
  49     for local _i in $(<[2-]) { _d = $(_d:R='..') ; }
  50     return $(_d) ;
  51   }
  52 }
  53
  54 # /FStripCommon v1 : v2 ;
  55 #
  56 # Strip common initial elements of variables v1 and v2.
  57 # Modifies the variable values themselves.
  58 rule FStripCommon {
  59   if $($(<)[1]) && $($(<)[1]) = $($(>)[1]) {
  60     $(<) = $($(<)[2-]) ;
  61     $(>) = $($(>)[2-]) ;
  62     FStripCommon $(<) : $(>) ;
  63   }
  64 }
  65
  66
  67 rule FRelPath {
  68   local _l _r ;
  69   # first strip off common parts
  70   _l = $(<) ;
  71   _r = $(>) ;
  72   FStripCommon _l : _r ;
  73   # now make path to root and path down
  74   _l = [ FSubDir $(_l) ] ;
  75   _r = [ FDirName $(_r) ] ;
  76   # Concatenate and save
  77   # XXX This should be better
  78   if $(_r) = '.' { return $(_l) ; } else { return $(_r:R=$(_l)) ; }
  79 }
  80
  81
  82 rule FAppendSuffix {
  83   # E.g., "FAppendSuffix yacc lex foo.bat : $(SUFEXE) ;"
  84   # returns (yacc,lex,foo.bat) on Unix and
  85   # (yacc.exe,lex.exe,foo.bat) on NT.
  86   if $(>) {
  87     local _o = ;
  88     for local _i in $(<) {
  89       if $(_i:S) { _o += $(_i) ; } else { _o += $(_i:S=$(>)) ; }
  90     }
  91     return $(_o) ;
  92   } else {
  93     return $(<) ;
  94   }
  95 }
  96
  97
  98 #
  99 # Operating system specific utility rules
 100 # First, the (generic) UNIX versions
 101 #
 102
 103 rule FDefines { return -D$(<) ; }
 104 rule FIncludes { return -I$(<) ; }
 105 rule FDIncludes { return -J$(<) ; }
 106
 107 rule FDirName {
 108   # Turn individual elements in $(<) into a usable path.
 109   local _s = '.' ;
 110   for local _i in $(<) { _s = $(_i:R=$(_s)) ; }
 111   return $(_s) ;
 112 }
 113
 114
 115 if $(NT) && $(JAM_TOOLSET) != MINGW && $(JAM_TOOLSET) != LCC {
 116   rule FDefines { return /D$(<) ; }
 117   rule FIncludes { return /I$(<) ; }
 118 }
 119
 120
 121 rule sys-has-command {
 122   if [ Command "which $(1:Q) 2>/dev/null 1>&2" ] {
 123     return ;
 124   } else {
 125     return 'tan' ;
 126   }
 127 }
 128
 129
 130 rule Undefines {
 131   UNDEFS on [ FAppendSuffix $(<) : $(SUFEXE) ] += $(UNDEFFLAG)$(>) ;
 132 }
 133
 134
 135 rule IsGCC {
 136   #if ( 'gcc' in $(CC) ) || ( $(JAM_TOOLSET) = MINGW ) { return 'tan'; }
 137   if ( ( $(CC) ~= '\bgcc$' ) || ( $(JAM_TOOLSET) = MINGW ) ) { return 'tan'; }
 138   return ;
 139 }
 140
 141
 142 rule IsG++ {
 143   #if ( 'g++' in $(C++) ) || ( $(JAM_TOOLSET) = MINGW ) { return 'tan'; }
 144   if ( ( $(CC) ~= '\bg\+\+$' ) || ( $(JAM_TOOLSET) = MINGW ) ) { return 'tan'; }
 145   return ;
 146 }
 147
 148
 149 rule JoinAndRemoveSpaces str {
 150   str = $(str:J) ;
 151   while tan {
 152     local pn = [ Match '^(.*)\s+(.*)$' : $(str) ] ;
 153     if $(pn) {
 154       str = $(pn[1]) $(pn[2]) ;
 155       str = $(str:J) ;
 156     } else {
 157       return $(str) ;
 158     }
 159   }
 160 }
 161
 162
 163 # adds "all" if JAM_TARGETS becomes empty
 164 # $(1): target name
 165 rule RemoveJamTarget {
 166   local newtgt _t ;
 167   newtgt = ;
 168   for _t in $(JAM_TARGETS) {
 169     if $(_t) = $(1) {
 170       # nothing to do
 171     } else {
 172       newtgt += $(_t) ;
 173     }
 174   }
 175   if $(newtgt) = "" { newtgt = "all" ; }
 176   JAM_TARGETS = $(newtgt) ;
 177 }
 178
 179
 180 rule CompareVersions a : b {
 181   local spa = [ Split $(a) : "." ] ;
 182   local spb = [ Split $(b) : "." ] ;
 183   local alen = [ ListLength $(spa) ] ;
 184   local blen = [ ListLength $(spb) ] ;
 185   local cnt = 1 ;
 186   local v0 = '' ;
 187   local v1 = '' ;
 188
 189   while tan {
 190     if [ ExprI1 $(cnt) ">" $(alen) ] {
 191       if [ ExprI1 $(cnt) ">" $(blen) ] {
 192         # equal
 193         return '0' ;
 194       }
 195       # b is longer, so a is lesser
 196       return '-1' ;
 197     } else if [ ExprI1 $(cnt) ">" $(blen) ] {
 198       # b is shorter, so a is greater
 199       return '1' ;
 200     }
 201
 202
 203     v0 = $(spa[$(cnt)]) ;
 204     v1 = $(spb[$(cnt)]) ;
 205
 206     if [ ExprI1 $(v0) "<" $(v1) ] {
 207       return '-1' ;
 208     }
 209     if [ ExprI1 $(v0) ">" $(v1) ] {
 210       return '1' ;
 211     }
 212     # equal
 213
 214     cnt = [ ExprI1 $(cnt) + 1 ] ;
 215   }
 216 }
 217
 218
 219 . Jambase.misc.fsys
 220 . Jambase.misc.opts