build/jam/OverriddenJamRules

   1 # Overridden to allow spaces in file names.
   2 actions Chmod1
   3 {
   4         $(CHMOD) "$(MODE)" "$(1)"
   5 }
   6
   7 # Overridden to allow spaces in file names.
   8 actions piecemeal together existing Clean
   9 {
  10         $(RM) "$(>)"
  11 }
  12
  13 #-------------------------------------------------------------------------------
  14 # Link rule/action are overwritten as they don't handle linking files who's name
  15 # contain spaces very well. Also adds resources and version to executable.
  16 #-------------------------------------------------------------------------------
  17 rule Link
  18 {
  19         # Note: RESFILES must be set before invocation.
  20
  21         if [ on $(1) return $(PLATFORM) ] = host {
  22                 LINK on $(1) = $(HOST_LINK) ;
  23                 LINKFLAGS on $(1) = $(HOST_LINKFLAGS) [ on $(1) return $(LINKFLAGS) ] ;
  24         } else {
  25                 LINK on $(1) = $(TARGET_LINK_$(TARGET_PACKAGING_ARCH)) ;
  26                 LINKFLAGS on $(1) = $(TARGET_LINKFLAGS_$(TARGET_PACKAGING_ARCH))
  27                         [ on $(1) return $(LINKFLAGS) ] ;
  28         }
  29
  30         HAIKU_TARGET_IS_EXECUTABLE on $(1) = 1 ;
  31
  32         NEEDLIBS on $(1) = [ on $(1) return $(NEEDLIBS) ] ;
  33         LINKLIBS on $(1) = [ on $(1) return $(LINKLIBS) ] ;
  34
  35         MODE on $(<) = $(EXEMODE) ;
  36         on $(1) XRes $(1) : $(RESFILES) ;
  37         if ! [ on $(1) return $(DONT_USE_BEOS_RULES) ] {
  38                 SetType $(1) ;
  39                 MimeSet $(1) : sharedObject ;
  40                 SetVersion $(1) ;
  41
  42                 # For applications for the target also generate the MIME DB entries.
  43                 if [ on $(1) return $(PLATFORM) ] != host
  44                         && [ on $(1) return $(RESFILES) ] {
  45                         CreateAppMimeDBEntries $(1) ;
  46                 }
  47
  48                 # If the generic attribute emulation is enabled, make sure the tool to
  49                 # remove the attributes is built first.
  50                 if $(HOST_RM_ATTRS_TARGET) {
  51                         Depends $(1) : $(HOST_RM_ATTRS_TARGET) ;
  52                 }
  53         }
  54         Chmod $(<) ;
  55 }
  56
  57 # When using "real" attributes (i.e. BeOS attributes or xattr/extattr) on the
  58 # host platform, unlinking the main target by gcc will also automatically get
  59 # rid of the attributes. When using the generic attribute emulation, which
  60 # uses separate files, we need to remove the target explicitely first, so that
  61 # the attributes won't be "leaked".
  62 if $(HOST_PLATFORM_BEOS_COMPATIBLE) || $(HAIKU_HOST_USE_XATTR) = 1 {
  63         actions Link bind NEEDLIBS LINK_BEGIN_GLUE LINK_END_GLUE VERSION_SCRIPT
  64         {
  65                 $(LINK) $(LINKFLAGS) -o "$(1)" $(UNDEFS) "$(LINK_BEGIN_GLUE)" "$(2)" \
  66                         "$(NEEDLIBS)" $(LINKLIBS) "$(LINK_END_GLUE)" \
  67                         -Wl,--version-script,$(VERSION_SCRIPT)
  68         }
  69 } else {
  70         actions Link bind NEEDLIBS LINK_BEGIN_GLUE LINK_END_GLUE VERSION_SCRIPT
  71         {
  72                 $(RM) "$(1)"
  73                 $(LINK) $(LINKFLAGS) -o "$(1)" $(UNDEFS) "$(LINK_BEGIN_GLUE)" "$(2)" \
  74                         "$(NEEDLIBS)" $(LINKLIBS) "$(LINK_END_GLUE)" \
  75                         -Wl,--version-script,$(VERSION_SCRIPT)
  76         }
  77 }
  78
  79 rule Object
  80 {
  81         # find out which headers and defines to use
  82         local headers ;
  83         local sysHeaders ;
  84         local defines ;
  85
  86         on $(1) { # use on $(1) variable values
  87                 if ! $(PLATFORM) in $(SUPPORTED_PLATFORMS) {
  88                         return ;
  89                 }
  90
  91                 # Save HDRS for -I$(HDRS) on compile.
  92                 # We shouldn't need -I$(SEARCH_SOURCE) as cc can find headers
  93                 # in the .c file's directory, but generated .c files (from
  94                 # yacc, lex, etc) are located in $(LOCATE_TARGET), possibly
  95                 # different from $(SEARCH_SOURCE).
  96
  97                 headers = $(HAIKU_CONFIG_HEADERS) $(SEARCH_SOURCE) $(SUBDIRHDRS)
  98                         $(HDRS) ;
  99                 sysHeaders = $(SUBDIRSYSHDRS) $(SYSHDRS) ;
 100                 defines = $(DEFINES) ;
 101
 102                 if $(PLATFORM) = host {
 103                         sysHeaders += $(HOST_HDRS) ;
 104                         defines += $(HOST_DEFINES) ;
 105
 106                         if $(USES_BE_API) {
 107                                 sysHeaders += $(HOST_BE_API_HEADERS) ;
 108                         }
 109
 110                 } else {
 111                         sysHeaders += [ FStandardHeaders $(TARGET_PACKAGING_ARCH) ]
 112                                 $(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
 113                         defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
 114                                 $(TARGET_DEFINES) ;
 115                 }
 116         }
 117
 118         # locate object and search for source
 119
 120         LocalClean clean : $(<) ;
 121
 122         MakeLocateDebug $(<) ;
 123         SEARCH on $(>) = $(SEARCH_SOURCE) ;
 124
 125         HDRS on $(<) = $(headers) ;
 126         SYSHDRS on $(<) = $(sysHeaders) ;
 127
 128         # handle #includes for source: Jam scans for headers with
 129         # the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
 130         # with the scanned file as the target and the found headers
 131         # as the sources.  HDRSEARCH is the value of SEARCH used for
 132         # the found header files.  Finally, if jam must deal with
 133         # header files of the same name in different directories,
 134         # they can be distinguished with HDRGRIST.
 135
 136         # $(SEARCH_SOURCE:E) is where cc first looks for #include
 137         # "foo.h" files.  If the source file is in a distant directory,
 138         # look there.  Else, look in "" (the current directory).
 139
 140         HDRRULE on $(>) = HdrRule ;
 141         HDRSCAN on $(>) = $(HDRPATTERN) ;
 142         HDRSEARCH on $(>) = $(headers) $(sysHeaders) $(STDHDRS) ;
 143         HDRGRIST on $(>) = $(HDRGRIST) ;
 144
 145         # propagate target specific-defines
 146
 147         DEFINES on $(1) = $(defines) ;
 148
 149         # if source is not .c, generate .c with specific rule
 150
 151         switch $(>:S)
 152         {
 153             case .asm : As $(<) : $(>) ;
 154             case .nasm : AssembleNasm $(<) : $(>) ;
 155             case .c :   Cc $(<) : $(>) ;
 156             case .C :   C++ $(<) : $(>) ;
 157             case .cc :  C++ $(<) : $(>) ;
 158             case .cpp : C++ $(<) : $(>) ;
 159             case .f :   Fortran $(<) : $(>) ;
 160             case .l :   if [ on $(2) return $(GENERATE_C++) ] {
 161                                         InheritPlatform $(<:S=.cpp) : $(1) ;
 162                                                 C++ $(<) : $(<:S=.cpp) ;
 163                                                 Lex $(<:S=.cpp) : $(>) ;
 164                                         } else {
 165                                         InheritPlatform $(<:S=.c) : $(1) ;
 166                                                 Cc $(<) : $(<:S=.c) ;
 167                                                 Lex $(<:S=.c) : $(>) ;
 168                                         }
 169                 case *.o :      return ;
 170             case .s :   As $(<) : $(>) ;
 171             case .S :   As $(<) : $(>) ;
 172             case .y :   if [ on $(2) return $(GENERATE_C++) ] {
 173                                         InheritPlatform $(1:S=.cpp) $(1:S=.hpp) : $(1) ;
 174                                                 C++ $(1) : $(1:S=.cpp) ;
 175                                                 Yacc $(1:S=.cpp) $(1:S=.hpp) : $(2) ;
 176                                         } else {
 177                                         InheritPlatform $(1:S=.c) $(1:S=.h) : $(1) ;
 178                                                 Cc $(1) : $(1:S=.c) ;
 179                                                 Yacc $(1:S=.c) $(1:S=.h) : $(2) ;
 180                                         }
 181             case * :    UserObject $(<) : $(>) ;
 182         }
 183 }
 184
 185 rule As
 186 {
 187         local flags ;
 188         local includesSeparator ;
 189         local localIncludesOption ;
 190         local systemIncludesOption ;
 191         if [ on $(1) return $(PLATFORM) ] = host {
 192                 flags = [ on $(1) return $(HOST_ASFLAGS) $(ASFLAGS) ] ;
 193
 194                 CC on $(1) = $(HOST_CC) ;
 195
 196                 includesSeparator = $(HOST_INCLUDES_SEPARATOR) ;
 197                 localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 198                 systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 199
 200         } else {
 201                 flags = [ on $(1) return $(TARGET_ASFLAGS_$(TARGET_PACKAGING_ARCH))
 202                         $(ASFLAGS) ] ;
 203
 204                 CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 205
 206                 includesSeparator
 207                         = $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
 208                 localIncludesOption
 209                         = $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 210                 systemIncludesOption
 211                         = $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 212         }
 213
 214         Depends $(<) : $(>) [ on $(1) return $(PLATFORM) ] ;
 215         ASFLAGS on $(<) += $(flags) $(SUBDIRASFLAGS) ;
 216         ASHDRS on $(<) = [ on $(<) FIncludes $(HDRS) : $(localIncludesOption) ]
 217                 $(includesSeparator)
 218                 [ on $(<) FSysIncludes $(SYSHDRS) : $(systemIncludesOption) ] ;
 219         ASDEFS on $(<) = [ on $(<) FDefines $(DEFINES) ] ;
 220 }
 221
 222 # TODO: The KERNEL_CCFLAGS were used here before. Check whether we need any
 223 # flags we don't have now.
 224 actions As
 225 {
 226         $(CC) -c "$(2)" -O2 $(ASFLAGS) -D_ASSEMBLER $(ASDEFS) $(ASHDRS) -o "$(1)" ;
 227 }
 228
 229 rule Lex
 230 {
 231         Depends $(1) : $(2) [ on $(1) return $(PLATFORM) ] ;
 232         MakeLocateArch $(1) ;
 233         LocalClean clean : $(1) ;
 234 }
 235
 236 actions Lex
 237 {
 238         $(LEX) $(LEXFLAGS) -o$(1) $(2)
 239 }
 240
 241 rule Yacc
 242 {
 243         local source = $(1[1]) ;
 244         local header = $(1[2]) ;
 245         local yaccSource = $(2) ;
 246
 247         MakeLocateArch $(source) $(header) ;
 248
 249         Depends $(source) $(header)
 250                 : $(yaccSource) [ on $(source) return $(PLATFORM) ] ;
 251         Yacc1 $(source) $(header) : $(yaccSource) ;
 252         LocalClean clean : $(source) $(header) ;
 253
 254         # make sure someone includes $(header) else it will be
 255         # a deadly independent target
 256
 257         Includes $(source) : $(header) ;
 258 }
 259
 260 actions Yacc1
 261 {
 262         bison $(YACCFLAGS) -o $(1[1]) $(2)
 263         [ -f $(1[1]).h ] && mv $(1[1]).h $(1[2]) || true
 264 }
 265
 266 rule Cc
 267 {
 268         Depends $(<) : $(>) [ on $(1) return $(PLATFORM) ] ;
 269
 270         on $(1) {
 271                 local flags ;
 272                 local includesSeparator ;
 273                 local localIncludesOption ;
 274                 local systemIncludesOption ;
 275
 276                 # optimization flags
 277                 if $(DEBUG) = 0 {
 278                         flags += $(OPTIM) ;
 279                 } else {
 280                         flags += -O0 ;
 281                 }
 282
 283                 if $(PLATFORM) = host {
 284                         # warning flags
 285                         if $(WARNINGS) != 0 {
 286                                 flags += $(HOST_WARNING_CCFLAGS) ;
 287                                 if $(WARNINGS) = treatAsErrors {
 288                                         flags += -Werror $(HOST_WERROR_FLAGS) ;
 289                                 }
 290                         }
 291
 292                         # debug and other flags
 293                         flags += $(HOST_CCFLAGS) $(HOST_DEBUG_$(DEBUG)_CCFLAGS)
 294                                 $(SUBDIRCCFLAGS) $(CCFLAGS) ;
 295
 296                         if $(USES_BE_API) {
 297                                 flags += $(HOST_BE_API_CCFLAGS) ;
 298                         }
 299
 300                         CC on $(1) = $(HOST_CC) ;
 301
 302                         includesSeparator = $(HOST_INCLUDES_SEPARATOR) ;
 303                         localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 304                         systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 305
 306                 } else {
 307                         # warning flags
 308                         if $(WARNINGS) != 0 {
 309                                 flags += $(TARGET_WARNING_CCFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 310                                 if $(WARNINGS) = treatAsErrors {
 311                                         flags += -Werror
 312                                                 $(TARGET_WERROR_FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 313                                 }
 314                         }
 315
 316                         # debug and other flags
 317                         flags += $(TARGET_CCFLAGS_$(TARGET_PACKAGING_ARCH))
 318                                 $(TARGET_DEBUG_$(DEBUG)_CCFLAGS_$(TARGET_PACKAGING_ARCH))
 319                                 $(SUBDIRCCFLAGS) $(CCFLAGS) ;
 320
 321                         CC on $(1) = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 322
 323                         includesSeparator
 324                                 = $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
 325                         localIncludesOption
 326                                 = $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 327                         systemIncludesOption
 328                                 = $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 329                 }
 330
 331                 CCFLAGS on $(<) = $(flags) ;
 332                 CCHDRS on $(<) = [ FIncludes $(HDRS) : $(localIncludesOption) ]
 333                         $(includesSeparator)
 334                         [ FSysIncludes $(SYSHDRS) : $(systemIncludesOption) ] ;
 335                 CCDEFS on $(<) = [ FDefines $(DEFINES) ] ;
 336         }
 337 }
 338
 339 actions Cc
 340 {
 341         $(CC) $(CCFLAGS) -c "$(2)" $(CCDEFS) $(CCHDRS) -o "$(1)" ;
 342 }
 343
 344 rule C++
 345 {
 346         Depends $(<) : $(>) [ on $(1) return $(PLATFORM) ] ;
 347
 348         on $(1) {
 349                 local flags ;
 350                 local includesSeparator ;
 351                 local localIncludesOption ;
 352                 local systemIncludesOption ;
 353
 354                 # optimization flags
 355                 if $(DEBUG) = 0 {
 356                         flags += $(OPTIM) ;
 357                 } else {
 358                         flags += -O0 ;
 359                 }
 360
 361                 if $(PLATFORM) = host {
 362                         # warning flags
 363                         if $(WARNINGS) != 0 {
 364                                 flags += $(HOST_WARNING_C++FLAGS) ;
 365                                 if $(WARNINGS) = treatAsErrors {
 366                                         flags += -Werror $(HOST_WERROR_FLAGS) ;
 367                                 }
 368                         }
 369
 370                         # debug and other flags
 371                         flags += $(HOST_C++FLAGS) $(HOST_DEBUG_$(DEBUG)_C++FLAGS)
 372                                 $(SUBDIRC++FLAGS) $(C++FLAGS) ;
 373
 374                         if $(USES_BE_API) {
 375                                 flags += $(HOST_BE_API_C++FLAGS) ;
 376                         }
 377
 378                         C++ on $(1) = $(HOST_C++) ;
 379
 380                         includesSeparator = $(HOST_INCLUDES_SEPARATOR) ;
 381                         localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 382                         systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
 383
 384                 } else {
 385                         # warning flags
 386                         if $(WARNINGS) != 0 {
 387                                 flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 388                                 if $(WARNINGS) = treatAsErrors {
 389                                         flags += -Werror
 390                                                 $(TARGET_WERROR_FLAGS_$(TARGET_PACKAGING_ARCH)) ;
 391                                 }
 392                         }
 393
 394                         # debug and other flags
 395                         flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 396                                 $(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
 397                                 $(SUBDIRC++FLAGS) $(C++FLAGS) ;
 398
 399                         C++ on $(1) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
 400
 401                         includesSeparator
 402                                 = $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
 403                         localIncludesOption
 404                                 = $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 405                         systemIncludesOption
 406                                 = $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 407                 }
 408
 409                 C++FLAGS on $(<) = $(flags) ;
 410                 CCHDRS on $(<) = [ FIncludes $(HDRS) : $(localIncludesOption) ]
 411                         $(includesSeparator)
 412                         [ FSysIncludes $(SYSHDRS) : $(systemIncludesOption) ] ;
 413                 CCDEFS on $(<) = [ FDefines $(DEFINES) ] ;
 414         }
 415 }
 416
 417 actions C++
 418 {
 419         $(C++) -c "$(2)" $(C++FLAGS) $(CCDEFS) $(CCHDRS) -o "$(1)" ;
 420 }
 421
 422 actions together Archive
 423 {
 424         # Force recreation of the archive to avoid build errors caused by
 425         # stale dependencies after renaming or deleting object files.
 426         $(RM) $(<)
 427         $(AR) $(<) $(>)
 428 }
 429
 430 rule Library
 431 {
 432         local lib = $(1) ;
 433         local sources = [ FGristFiles $(2) ] ;
 434         local objects = $(sources:S=$(SUFOBJ)) ;
 435
 436         InheritPlatform $(objects) : $(lib) ;
 437         LibraryFromObjects $(lib) : $(objects) ;
 438         Objects $(sources) ;
 439 }
 440
 441 rule LibraryFromObjects
 442 {
 443         local _i _l _s ;
 444
 445         # Add grist to file names
 446         # bonefish: No, don't. The Library rule does that anyway, and when we
 447         # have an object from another dir, we certainly don't want that.
 448
 449         _s = $(>) ;
 450         _l = $(<:S=$(SUFLIB)) ;
 451
 452         on $(_l) {
 453                 # set the tools according to the platform
 454                 if $(PLATFORM) = host {
 455                         AR on $(_l) = $(HOST_AR) $(HOST_ARFLAGS) ;
 456                         RANLIB on $(_l) = $(HOST_RANLIB) ;
 457                 } else {
 458                         AR on $(_l) = $(TARGET_AR_$(TARGET_PACKAGING_ARCH))
 459                                 $(TARGET_ARFLAGS_$(TARGET_PACKAGING_ARCH)) ;
 460                         RANLIB on $(_l) = $(TARGET_RANLIB_$(TARGET_PACKAGING_ARCH)) ;
 461                 }
 462
 463                 # library depends on its member objects
 464
 465                 if $(KEEPOBJS)
 466                 {
 467                         LocalDepends obj : $(_s) ;
 468                 }
 469
 470                 LocalDepends lib : $(_l) ;
 471
 472                 # Set LOCATE for the library and its contents.  The bound
 473                 # value shows up as $(NEEDLIBS) on the Link actions.
 474                 # For compatibility, we only do this if the library doesn't
 475                 # already have a path.
 476
 477                 if ! $(_l:D)
 478                 {
 479                         # locate the library only, if it hasn't been located yet
 480                         local dir = $(LOCATE[1]) ;
 481                         if ! $(dir) {
 482                                 MakeLocateDebug $(_l) ;
 483                                 dir = [ on $(_l) return $(LOCATE[1]) ] ;
 484                                         # Note: The "on ..." is necessary, since our environment
 485                                         # isn't changed by MakeLocateDebug.
 486                         }
 487                         MakeLocate $(_l)($(_s:BS)) : $(dir) ;
 488                 }
 489
 490                 if $(NOARSCAN)
 491                 {
 492                         # If we can't scan the library to timestamp its contents,
 493                         # we have to just make the library depend directly on the
 494                         # on-disk object files.
 495
 496                         Depends $(_l) : $(_s) ;
 497                 }
 498                 else
 499                 {
 500                         # If we can scan the library, we make the library depend
 501                         # on its members and each member depend on the on-disk
 502                         # object file.
 503
 504                         Depends $(_l) : $(_l)($(_s:BS)) ;
 505
 506                         for _i in $(_s)
 507                         {
 508                         Depends $(_l)($(_i:BS)) : $(_i) ;
 509                         }
 510                 }
 511
 512                 LocalClean clean : $(_l) ;
 513
 514                 # bonefish: Not needed on the supported platforms. Maybe later...
 515                 # if $(CRELIB) { CreLib $(_l) : $(_s[1]) ; }
 516
 517                 Archive $(_l) : $(_s) ;
 518
 519                 if $(RANLIB) { Ranlib $(_l) ; }
 520
 521                 # If we can't scan the library, we have to leave the .o's around.
 522
 523                 if ! ( $(KEEPOBJS) || $(NOARSCAN) || $(NOARUPDATE) ) {
 524                         RmTemps $(_l) : $(_s) ;
 525                 }
 526         }
 527 }
 528
 529 rule Main
 530 {
 531         local target = $(1) ;
 532         local sources = [ FGristFiles $(2) ] ;
 533         local objects = $(sources:S=$(SUFOBJ)) ;
 534
 535         InheritPlatform $(objects) : $(target) ;
 536         MainFromObjects $(target) : $(objects) ;
 537         Objects $(sources) ;
 538 }
 539
 540 rule MainFromObjects
 541 {
 542         local _s _t ;
 543
 544         # Add grist to file names
 545         # Add suffix to exe
 546
 547         _s = [ FGristFiles $(>) ] ;
 548         _t = [ FAppendSuffix $(<) : $(SUFEXE) ] ;
 549
 550         # so 'jam foo' works when it's really foo.exe
 551
 552         if $(_t) != $(<)
 553         {
 554             Depends $(<) : $(_t) ;
 555             NotFile $(<) ;
 556         }
 557
 558         # make compiled sources a dependency of target
 559
 560         LocalDepends exe : $(_t) ;
 561         Depends $(_t) : $(_s) ;
 562         MakeLocateDebug $(_t) ;
 563
 564         LocalClean clean : $(_t) ;
 565
 566         Link $(_t) : $(_s) ;
 567 }
 568
 569 # Override Jam 2.5rc3 MakeLocate and MkDir to deal more intelligently
 570 # with grist set on the supplied directory name. Also do nothing for already
 571 # located files.
 572 rule MakeLocate
 573 {
 574         local dir = $(2[1]) ;
 575
 576         if $(dir)
 577         {
 578                 if ! $(dir:G) {
 579                         dir = $(dir:G=dir) ;
 580                 }
 581
 582                 local target ;
 583                 for target in $(1) {
 584                         # don't relocate once located
 585                     LOCATE on $(target) += $(dir:G=) ;
 586                         if [ on $(target) return $(LOCATE) ] = $(dir:G=) {
 587                             Depends $(target) : $(dir) ;
 588                         MkDir $(dir) ;
 589                         }
 590                 }
 591         }
 592 }
 593
 594 rule MkDir
 595 {
 596         local dir = $(<) ;
 597         if ! $(dir:G) {
 598                 dir = $(dir:G=dir) ;
 599         }
 600
 601         # make this and all super directories
 602         while true {
 603                 # If dir exists, don't update it
 604                 # Do this even for $(DOT).
 605                 NoUpdate $(dir) ;
 606
 607                 # Bail out when reaching the CWD (".") or a directory we've already
 608                 # made.
 609                 if $(dir:G=) = $(DOT) || $($(dir:G=)-mkdir) {
 610                         return ;
 611                 }
 612
 613                 local s ;
 614
 615                 # Cheesy gate to prevent multiple invocations on same dir
 616                 # MkDir1 has the actions
 617                 # Arrange for jam dirs
 618
 619                 $(dir:G=)-mkdir = true ;
 620                 MkDir1 $(dir) ;
 621                 LocalDepends dirs : $(dir) ;
 622
 623                 # Recursively make parent directories.
 624                 # $(dir:P) = $(dir)'s parent, & we recurse until root
 625
 626                 s = $(dir:P) ;  # parent keeps grist
 627
 628                 if $(s:G=) && $(s) != $(dir) {
 629                         Depends $(dir) : $(s) ;
 630                         dir = $(s) ;
 631                 } else if $(s) {
 632                         NotFile $(s) ;
 633                         break ;
 634                 }
 635         }
 636 }
 637
 638 rule ObjectCcFlags
 639 {
 640         # supports inheriting the global variable value
 641
 642         local file ;
 643         for file in [ FGristFiles $(1:S=$(SUFOBJ)) ] {
 644                 CCFLAGS on $(file) = [ on $(file) return $(CCFLAGS) ] $(2) ;
 645         }
 646 }
 647
 648 rule ObjectC++Flags
 649 {
 650         # supports inheriting the global variable value
 651
 652         local file ;
 653         for file in [ FGristFiles $(1:S=$(SUFOBJ)) ] {
 654                 C++FLAGS on $(file) = [ on $(file) return $(C++FLAGS) ] $(2) ;
 655         }
 656 }
 657
 658 rule ObjectDefines
 659 {
 660         # supports inheriting the global variable value and multiple files
 661
 662         if $(2) {
 663                 local file ;
 664                 for file in [ FGristFiles $(1:S=$(SUFOBJ)) ] {
 665                         DEFINES on $(file) = [ on $(file) return $(DEFINES) ] $(2) ;
 666                         CCDEFS on $(file) = [ on $(file) FDefines $(DEFINES) ] ;
 667                 }
 668         }
 669 }
 670
 671 rule ObjectHdrs
 672 {
 673         # ObjectHdrs <sources or objects> : <headers> : <gristed objects>
 674         # Note: Parameter 3 <gristed objects> is an extension.
 675
 676         local objects = [ FGristFiles $(1:S=$(SUFOBJ)) ] $(3) ;
 677         local headers = $(2) ;
 678
 679         local file ;
 680         for file in $(objects) {
 681                 on $(file) {
 682                         local localHeaders = $(HDRS) $(headers) ;
 683                         SYSHDRS on $(file) = $(localHeaders) ;
 684
 685                         # reformat ASHDRS and CCHDRS
 686                         local fileHeaders ;
 687
 688                         if $(PLATFORM) = host {
 689                                 fileHeaders =
 690                                         [ FIncludes $(localHeaders) : $(HOST_LOCAL_INCLUDES_OPTION) ]
 691                                         $(HOST_INCLUDES_SEPARATOR)
 692                                         [ FSysIncludes $(SYSHDRS)
 693                                                 : $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
 694                         } else {
 695                                 local architecture = $(TARGET_PACKAGING_ARCH) ;
 696                                 fileHeaders =
 697                                         [ FIncludes $(localHeaders)
 698                                                 : $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
 699                                         $(TARGET_INCLUDES_SEPARATOR_$(architecture))
 700                                         [ FSysIncludes $(SYSHDRS)
 701                                                 : $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
 702                         }
 703
 704                         ASHDRS on $(file) = $(fileHeaders) ;
 705                         CCHDRS on $(file) = $(fileHeaders) ;
 706                 }
 707         }
 708 }
 709
 710 # Overridden to avoid calling SubDir for a directory twice (in SubInclude
 711 # and from the Jamfile in the directory).
 712 rule SubInclude
 713 {
 714         # SubInclude TOP d1 ... ;
 715         #
 716         # Include a subdirectory's Jamfile.
 717
 718         if ! $($(<[1]))
 719         {
 720             Exit SubInclude $(<[1]) without prior SubDir $(<[1]) ;
 721         }
 722
 723         # Set up the config variables for the subdirectory.
 724         local config = [ ConfigObject $(1) ] ;
 725
 726         __configured = ;
 727         if ! [ on $(config) return $(__configured) ] {
 728                 # No custom configuration defined for the subdir. We use the variable
 729                 # values inherited by the closest ancestor.
 730                 config = $(HAIKU_INHERITED_SUBDIR_CONFIG) ;
 731         }
 732
 733         # store SUBDIR_TOKENS
 734         local oldSubDirTokens = $(SUBDIR_TOKENS) ;
 735
 736         on $(config) {
 737                 include [ FDirName $($(1[1])) $(1[2-) $(JAMFILE) ] ;
 738         }
 739
 740         # restore SUBDIR_TOKENS
 741         SUBDIR_TOKENS = $(oldSubDirTokens) ;
 742 }
 743
 744
 745 actions File
 746 {
 747         $(CP) "$(>)" "$(<)"
 748 }