1# Overridden to allow spaces in file names. 2actions Chmod1 3{ 4 $(CHMOD) "$(MODE)" "$(1)" 5} 6 7# Overridden to allow spaces in file names. 8actions 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#------------------------------------------------------------------------------- 17rule 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". 62if $(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 79rule 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 185rule 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. 224actions As 225{ 226 $(CC) -c "$(2)" -O2 $(ASFLAGS) -D_ASSEMBLER $(ASDEFS) $(ASHDRS) -o "$(1)" ; 227} 228 229rule Lex 230{ 231 Depends $(1) : $(2) [ on $(1) return $(PLATFORM) ] ; 232 MakeLocateArch $(1) ; 233 LocalClean clean : $(1) ; 234} 235 236actions Lex 237{ 238 $(LEX) $(LEXFLAGS) -o$(1) $(2) 239} 240 241rule 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 260actions Yacc1 261{ 262 bison $(YACCFLAGS) -o $(1[1]) $(2) 263 [ -f $(1[1]).h ] && mv $(1[1]).h $(1[2]) || true 264} 265 266rule 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 339actions Cc 340{ 341 $(CC) $(CCFLAGS) -c "$(2)" $(CCDEFS) $(CCHDRS) -o "$(1)" ; 342} 343 344rule 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 417actions C++ 418{ 419 $(C++) -c "$(2)" $(C++FLAGS) $(CCDEFS) $(CCHDRS) -o "$(1)" ; 420} 421 422actions 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 430rule 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 441rule 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 529rule 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 540rule 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. 572rule 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 594rule 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 638rule 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 648rule 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 658rule 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 671rule 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). 712rule 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 745actions File 746{ 747 $(CP) "$(>)" "$(<)" 748} 749