build/jam/HelperRules

   1 # Rules without side effects.
   2
   3 # Vanilla Jam compatibility
   4 if ! $(INVOCATION_SUBDIR_SET) {
   5         rule FIsPrefix
   6         {
   7                 # FIsPrefix <a> : <b> ;
   8                 # Returns true, if list <a> is a prefix (a proper one or equal) of
   9                 # list <b>, an empty list otherwise.
  10                 local a = $(1) ;
  11                 local b = $(2) ;
  12                 while $(a) && $(a[1]) = $(b[1]) {
  13                         a = $(a[2-]) ;
  14                         b = $(b[2-]) ;
  15                 }
  16
  17                 if $(a) {
  18                         return ;
  19                 } else {
  20                         return true ;
  21                 }
  22         }
  23
  24         rule LocalClean { Clean $(1) : $(2) ; }
  25
  26         rule LocalDepends { Depends $(1) : $(2) ; }
  27
  28 } # vanilla Jam compatibility
  29
  30 rule FFilter
  31 {
  32         # FFilter <list> : <excludes> ;
  33         # Removes all occurrences of <excludes> in <list>.
  34
  35         local list = $(1) ;
  36         local excludes = $(2) ;
  37         local newList ;
  38         local item ;
  39         for item in $(list) {
  40                 local skip ;
  41                 local exclude ;
  42                 for exclude in $(excludes) {
  43                         if $(item) = $(exclude) {
  44                                 skip = true ;
  45                         }
  46                 }
  47                 if ! $(skip) {
  48                         newList += $(item) ;
  49                 }
  50         }
  51         return $(newList) ;
  52 }
  53
  54 rule FGetGrist
  55 {
  56         # FGetGrist <target> ;
  57         #
  58         # Returns the grist of a target, not including leading "<" and trailing ">".
  59
  60         local grist = $(1[1]:G) ;
  61         if ! $(grist) {
  62                 return ;
  63         }
  64
  65         return [ Match <(.*)> : $(grist) ] ;
  66 }
  67
  68 rule FSplitString string : delimiterChar
  69 {
  70         local result ;
  71
  72         while $(string) {
  73                 local split = [ Match $(delimiterChar)*([^$(delimiterChar)]+)(.*)
  74                         : $(string) ] ;
  75                 result += $(split[1]) ;
  76                 string = $(split[2-]) ;
  77         }
  78
  79         return $(result) ;
  80 }
  81
  82 rule FSplitPath
  83 {
  84         # SplitPath <path> ;
  85         # Decomposes a path into its components.
  86         local path = $(1:G=) ;
  87         local components ;
  88         # $(path:D) for "/" is "/". Therefore the second condition.
  89         while $(path:D) && $(path:D) != $(path)
  90         {
  91                 # Note: $(path:B) returns "." for "..", but $(path:D=) is fine.
  92                 components = $(path:D=) $(components) ;
  93                 path = $(path:D) ;
  94         }
  95         components = $(path) $(components) ;
  96         return $(components) ;
  97 }
  98
  99
 100 rule FConditionsHold conditions : predicate
 101 {
 102         # FConditionsHold <conditions> : <predicate> ;
 103         # Checks whether the conditions <conditions> are satisfied by the predicate
 104         # rule <predicate> and returns a respective result (if so: "1", if not:
 105         # empty list). The conditions are satisfied when <conditions> is not empty
 106         # and
 107         # * none of the negative conditions it contains hold and
 108         # * if <conditions> contains any positive conditions, at least one of those
 109         #   holds.
 110         # A positive condition is an element not starting with a "!". It holds when
 111         # the predicate rule <predicate> returns true for the element.
 112         # A negative condition is an element that starts with a "!". It holds when
 113         # the predicate rule <predicate> returns true for the string resulting from
 114         # removing the leading "!".
 115         #
 116         # <conditions> - The list of conditions.
 117         # <predicate> - The predicate rule invoked to test the elements.
 118         #
 119         # Examples:
 120         # For a predicate that holds for the elements of the set { a b c } the
 121         # following conditions hold:
 122         # { a }, { a d }, { !d }, { !d !e }, { a !d }, { b !e !f }
 123         # The following conditions don't hold:
 124         # { }, { d }, { d e }, { !a }, { !a b }, { !d e } { a b !c !d }
 125
 126         local hasPositive ;
 127         local hasNegative ;
 128         local positiveMatch ;
 129         local condition ;
 130         for condition in $(conditions) {
 131                 switch $(condition) {
 132                         case !* :
 133                         {
 134                                 hasNegative = 1 ;
 135                                 condition = [ Match "!(.*)" : $(condition) ] ;
 136                                 if [ $(predicate) $(condition) ] {
 137                                         return ;
 138                                 }
 139                         }
 140                         case * :
 141                         {
 142                                 hasPositive = 1 ;
 143                                 if [ $(predicate) $(condition) ] {
 144                                         positiveMatch = 1 ;
 145                                 }
 146                         }
 147                 }
 148         }
 149
 150         if $(hasPositive) {
 151                 return $(positiveMatch) ;
 152         }
 153         return $(hasNegative) ;
 154 }
 155
 156
 157 rule SetPlatformCompatibilityFlagVariables
 158 {
 159         # SetPlatformCompatibilityFlagVariables <platform var> : <var prefix>
 160         #       : <platform kind> [ : other platforms ] ;
 161
 162         local platformVar = $(1) ;
 163         local platform = $($(platformVar)) ;
 164         local varPrefix = $(2) ;
 165         local platformKind = $(3) ;
 166         local otherPlatforms = $(4) ;
 167
 168         if ! $(platform) {
 169                 ECHO "Variable $(platformVar) not set. Please run ./configure or" ;
 170                 EXIT "specify it manually." ;
 171         }
 172
 173         # special case: Haiku libbe.so built for testing under BeOS
 174         if $(platform) = libbe_test {
 175                 platform = $(HOST_PLATFORM) ;
 176         }
 177
 178         $(varPrefix)_PLATFORM_BEOS_COMPATIBLE = ;
 179         $(varPrefix)_PLATFORM_BONE_COMPATIBLE = ;
 180         $(varPrefix)_PLATFORM_DANO_COMPATIBLE = ;
 181         $(varPrefix)_PLATFORM_HAIKU_COMPATIBLE = ;
 182
 183         switch $(platform)
 184         {
 185                 case r5 :
 186                 {
 187                         $(varPrefix)_PLATFORM_BEOS_COMPATIBLE = true ;
 188                 }
 189
 190                 case bone :
 191                 {
 192                         $(varPrefix)_PLATFORM_BONE_COMPATIBLE = true ;
 193                 }
 194
 195                 case dano :
 196                 {
 197                         $(varPrefix)_PLATFORM_DANO_COMPATIBLE = true ;
 198                 }
 199
 200                 case haiku_host :
 201                 {
 202                         $(varPrefix)_PLATFORM_HAIKU_COMPATIBLE = true ;
 203                 }
 204
 205                 case haiku :
 206                 {
 207                         $(varPrefix)_PLATFORM_HAIKU_COMPATIBLE = true ;
 208                 }
 209
 210                 case host :
 211                         # not compatible to anything
 212
 213                 case * :
 214                 {
 215                         if ! ( $(platform) in $(otherPlatforms) ) {
 216                                 Exit Unsupported $(platformKind) platform: $(platform) ;
 217                         }
 218                 }
 219         }
 220
 221         # set lesser flags, e.g. "DANO" for "HAIKU" and "BEOS" for "BONE"
 222         $(varPrefix)_PLATFORM_HAIKU_COMPATIBLE
 223                 ?= $($(varPrefix)_PLATFORM_HAIKU_COMPATIBLE) ;
 224         $(varPrefix)_PLATFORM_DANO_COMPATIBLE
 225                 ?= $($(varPrefix)_PLATFORM_HAIKU_COMPATIBLE) ;
 226         $(varPrefix)_PLATFORM_BONE_COMPATIBLE
 227                 ?= $($(varPrefix)_PLATFORM_DANO_COMPATIBLE) ;
 228         $(varPrefix)_PLATFORM_BEOS_COMPATIBLE
 229                 ?= $($(varPrefix)_PLATFORM_BONE_COMPATIBLE) ;
 230
 231         # set the machine friendly flags
 232         $(varPrefix)_PLATFORM_(haiku)_COMPATIBLE
 233                 ?= $($(varPrefix)_PLATFORM_HAIKU_COMPATIBLE) ;
 234         $(varPrefix)_PLATFORM_(haiku_host)_COMPATIBLE
 235                 ?= $($(varPrefix)_PLATFORM_HAIKU_COMPATIBLE) ;
 236         $(varPrefix)_PLATFORM_(dano)_COMPATIBLE
 237                 ?= $($(varPrefix)_PLATFORM_DANO_COMPATIBLE) ;
 238         $(varPrefix)_PLATFORM_(bone)_COMPATIBLE
 239                 ?= $($(varPrefix)_PLATFORM_BONE_COMPATIBLE) ;
 240         $(varPrefix)_PLATFORM_(r5)_COMPATIBLE
 241                 ?= $($(varPrefix)_PLATFORM_BEOS_COMPATIBLE) ;
 242
 243         $(varPrefix)_PLATFORM_(libbe_test)_COMPATIBLE
 244                 ?= $($(varPrefix)_PLATFORM_BEOS_COMPATIBLE) ;
 245 }
 246
 247 rule FAnalyzeGCCVersion
 248 {
 249         # FAnalyzeGCCVersion <rawVersionVariable> ;
 250         #
 251         local varName = $(1) ;
 252         local rawVersion = $($(varName)) ;
 253
 254         if ! $(rawVersion) {
 255                 ECHO "Variable $(varName) not set. Please run ./configure or" ;
 256                 EXIT "specify it manually." ;
 257         }
 258
 259         local version = ;
 260         # split the raw version string at `.' and `-' characters
 261         while $(rawVersion) {
 262                 local split = [ Match "([^.-]*)[.-](.*)" : $(rawVersion) ] ;
 263                 if $(split) {
 264                         version += $(split[1]) ;
 265                         rawVersion = $(split[2]) ;
 266                 } else {
 267                         version += $(rawVersion) ;
 268                         rawVersion = ;
 269                 }
 270         }
 271
 272         return $(version) ;
 273 }
 274
 275 rule SetIncludePropertiesVariables prefix : suffix
 276 {
 277         # SetIncludePropertiesVariables <prefix> : <suffix> ;
 278         #
 279         suffix = $(suffix:E=) ;
 280         if $($(prefix)_GCC_VERSION$(suffix)[1]) < 4 {
 281                 $(prefix)_INCLUDES_SEPARATOR$(suffix) = -I- ;
 282                 $(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = -I ;
 283                 $(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = -I ;
 284         } else {
 285                 $(prefix)_INCLUDES_SEPARATOR$(suffix) = ;
 286                 $(prefix)_LOCAL_INCLUDES_OPTION$(suffix) = "-iquote " ;
 287                 $(prefix)_SYSTEM_INCLUDES_OPTION$(suffix) = "-I " ;
 288         }
 289 }
 290
 291
 292 #pragma mark -
 293
 294 rule SetPlatformForTarget
 295 {
 296         # SetPlatformForTarget <target> : <platform> ;
 297
 298         PLATFORM on $(1) = $(2) ;
 299 }
 300
 301 rule SetSubDirPlatform
 302 {
 303         # SetSubDirPlatform <platform> ;
 304
 305         PLATFORM = $(1) ;
 306 }
 307
 308 rule SetSupportedPlatformsForTarget
 309 {
 310         # SetSupportedPlatformsForTarget <target> : <platforms> ;
 311
 312         SUPPORTED_PLATFORMS on $(1) = $(2) ;
 313 }
 314
 315 rule SetSubDirSupportedPlatforms
 316 {
 317         # SetSubDirSupportedPlatforms <platforms> ;
 318
 319         SUPPORTED_PLATFORMS = $(1) ;
 320 }
 321
 322 rule AddSubDirSupportedPlatforms
 323 {
 324         # AddSubDirSupportedPlatforms <platforms> ;
 325
 326         SUPPORTED_PLATFORMS += $(1) ;
 327 }
 328
 329 rule SetSubDirSupportedPlatformsBeOSCompatible
 330 {
 331         # SetSubDirSupportedPlatformsBeOSCompatible ;
 332
 333         SUPPORTED_PLATFORMS = $(HAIKU_BEOS_COMPATIBLE_PLATFORMS) ;
 334 }
 335
 336 rule IsPlatformSupportedForTarget
 337 {
 338         # IsPlatformSupportedForTarget <target> [ : <platform> ]
 339         #
 340
 341         on $(1) {
 342                 if $(PLATFORM) in $(SUPPORTED_PLATFORMS) {
 343                         return true ;
 344                 } else {
 345                         return ;
 346                 }
 347         }
 348 }
 349
 350 rule InheritPlatform
 351 {
 352         # InheritPlatform <children> : <parent> ;
 353         # PLATFORM and SUPPORTED_PLATFORMS are set on <children> to their value
 354         # on <parent>.
 355         #
 356         local children = $(1) ;
 357         local parent = $(2) ;
 358
 359         on $(parent) {
 360                 PLATFORM on $(children) = $(PLATFORM) ;
 361                 SUPPORTED_PLATFORMS on $(children) = $(SUPPORTED_PLATFORMS) ;
 362         }
 363 }
 364
 365 rule SubDirAsFlags
 366 {
 367         SUBDIRASFLAGS += $(<) ;
 368 }
 369