1# ProjectBuilder Jambase 2# Copyright (c) 1999,2000 Apple Computer, Inc. 3# All rights reserved. 4 5CROSS_ROOT default = "" ; 6 7JAMBASE_DIR default = $(JAMBASE:D) ; 8 9OS default = macos ; 10if $(OS) = MACOS { 11 OS = macos ; 12} 13 14if OS != "" { 15 include $(JAMBASE_DIR)/platform-$(OS).jam ; 16} 17 18# Copyright (c) 1999-2002 Apple Computer, Inc. 19# All rights reserved. 20 21# This file defines various functions for transforming text and 22# manipulating variables 23 24/ default = / ; 25 26# NonObjectFiles <non-object files returned> : <list of files> 27# Returns only files not in $(OBJECT_FILES_$(VARIANT) 28# or $(OBJECT_FILES_$(VARIANT)_$(ARCH)) for ARCH in $(ARCHS) 29rule NonObjectFiles 30{ 31 $(1) = ; 32 for X in $(2) { 33 if ! $(X) in $(OBJECT_FILES_$(VARIANT)) { 34 REJECT = ; 35 for ARCH in $(ARCHS) { 36 if $(X) in $(OBJECT_FILES_$(VARIANT)_$(ARCH)) { 37 REJECT = YES ; 38 } 39 } 40 if ! $(REJECT) { 41 $(1) += $(X) ; 42 } 43 } 44 } 45} 46 47# 48# RemovePrefixPath <variable> : <prefix> : <path-with-prefix> 49# removes the given prefix from the path and puts the result 50# in the given variable 51# 52rule RemovePrefixPath 53{ 54 local newname = $(3:BS) ; 55 local newdir = $(3:D) ; 56 local INDEX ; 57 if $(2) != "." { 58 for INDEX in 1 2 3 4 5 6 7 8 9 10 { 59 if $(newdir) != $(2) { 60 newname = $(newdir:BS)/$(newname) ; 61 newdir = $(newdir:D) ; 62 } 63 } 64 } 65 else { 66 newname = $(3) ; 67 } 68 $(1) = $(newname) ; 69} 70# Copyright (c) 1999-2002 Apple Computer, Inc. 71# All rights reserved. 72 73# Built-in definitions of common build settings. These can be 74# overridden by any higher layer (project-level, target-level, 75# build-phase-level, command-line etc). 76 77# the four 'root' directories 78export deferred SRCROOT = $(PWD) ; 79export deferred OBJROOT = $(SYMROOT) ; 80export deferred SYMROOT = $(SRCROOT)/build ; 81export deferred DSTROOT = /tmp/$(PROJECT_NAME).dst ; 82 83# synonyms for the above 84export deferred SOURCE_ROOT = $(SRCROOT) ; 85export deferred TEMP_ROOT = $(OBJROOT) ; 86export deferred BUILD_ROOT = $(SYMROOT) ; 87export deferred INSTALL_ROOT = $(DSTROOT) ; 88 89# more specific directories inside the TEMP_ROOT 90export deferred TEMP_DIR = $(OBJROOT)/$(PROJECT_NAME).build/$(TARGET_NAME).build ; 91export deferred DERIVED_FILE_DIR = $(TEMP_DIR)/DerivedSources ; 92 deferred OBJECT_FILE_DIR = $(TEMP_DIR)/Objects ; 93 deferred CLASS_FILE_DIR = $(TEMP_DIR)/JavaClasses ; 94 deferred FILE_LIST = $(OBJECT_FILE_DIR)/LinkFileList ; 95 deferred PRECOMP_TRUSTFILE = $(TEMP_DIR)/TrustedPrecomps.txt ; 96 97# more specific directories inside the BUILD_ROOT 98export deferred BUILD_DIR = $(SYMROOT) ; 99 100# more specific directories inside the INSTALL_ROOT 101export deferred INSTALL_DIR = $(DSTROOT)/$(INSTALL_PATH) ; 102 103# installation parameters 104export deferred INSTALL_OWNER = $(USER) ; 105export deferred INSTALL_GROUP = $(GROUP) ; 106export deferred INSTALL_MODE_FLAG = "a-w,a+rX" ; 107 108# language-independent code generation settings 109 deferred OPTIMIZATION_LEVEL = 0 ; 110 deferred OPTIMIZATION_CFLAGS = -Os ; 111 deferred DEBUGGING_SYMBOLS = YES ; 112 deferred PROFILING_CODE = NO ; 113 deferred PREBINDING = YES ; 114 115# Java-specific (some are marginally obsolete) 116 deferred JAVA_ARCHIVE_CLASSES = YES ; 117 deferred JAVA_ARCHIVE_TYPE = JAR ; 118 deferred JAVA_APP_STUB = $(SYSTEM_LIBRARY_DIR)/Frameworks/JavaVM.framework/Resources/MacOS/JavaApplicationStub ; 119 deferred JAVA_JAR_FLAGS = cv ; 120 deferred JAVA_SOURCE_SUBDIR = . ; 121 deferred JAVA_FRAMEWORK_RESOURCES_DIRS = Resources ; 122 deferred JAVA_FRAMEWORK_JARS = ; 123 deferred JAVA_USE_DEPENDENCIES = YES ; 124 deferred JAVA_ZIP_FLAGS = -urg ; 125 deferred JAVAC_SOURCE_FILE_ENCODING = MACINTOSH ; 126 127# miscellaneous 128export deferred DEVELOPMENT_LANGUAGE = English ; 129export deferred FRAMEWORK_VERSION = A ; 130 deferred REMOVE_CVS_FROM_RESOURCES = YES ; 131 deferred COPY_PHASE_STRIP = NO ; 132 deferred CLONE_HEADERS = NO ; 133 deferred KEEP_PRIVATE_EXTERNS = YES ; # this currently affects the master.o file only 134 135 136rule ConditionalDefinitions 137{ 138 # default mapping of build actions to build variants 139 switch $(ACTION) { 140 case build : deferred BUILD_COMPONENTS = headers build ; 141 case copysrc : deferred BUILD_COMPONENTS = source ; 142 case copyhdrs : deferred BUILD_COMPONENTS = headers ; 143 case copyrsrcs : deferred BUILD_COMPONENTS = resources ; 144 case install : deferred BUILD_COMPONENTS = headers build ; 145 deferred DEPLOYMENT_LOCATION = YES ; 146 deferred DEPLOYMENT_POSTPROCESSING = YES ; 147 case installdebugonly : deferred BUILD_COMPONENTS = build ; 148 deferred DEPLOYMENT_LOCATION = YES ; 149 deferred DEPLOYMENT_POSTPROCESSING = YES ; 150 deferred BUILD_VARIANTS = debug ; 151 case installprofileonly : deferred BUILD_COMPONENTS = build ; 152 deferred DEPLOYMENT_LOCATION = YES ; 153 deferred DEPLOYMENT_POSTPROCESSING = YES ; 154 deferred BUILD_VARIANTS = profile ; 155 case installdebugprofileonly : deferred BUILD_COMPONENTS = build ; 156 deferred DEPLOYMENT_LOCATION = YES ; 157 deferred DEPLOYMENT_POSTPROCESSING = YES ; 158 deferred BUILD_VARIANTS = debug profile ; 159 case installhdrs : deferred BUILD_COMPONENTS = headers ; 160 deferred DEPLOYMENT_LOCATION = YES ; 161 deferred DEPLOYMENT_POSTPROCESSING = YES ; 162 case installsrc : deferred BUILD_COMPONENTS = source ; 163 deferred DEPLOYMENT_LOCATION = YES ; 164 deferred DEPLOYMENT_POSTPROCESSING = YES ; 165 case installrsrcs : deferred BUILD_COMPONENTS = resources ; 166 deferred DEPLOYMENT_LOCATION = YES ; 167 deferred DEPLOYMENT_POSTPROCESSING = YES ; 168 } 169 170 # conditional locations enabling install-in-place 171 if $(DEPLOYMENT_LOCATION) = YES { 172 if $(SKIP_INSTALL) || ! $(INSTALL_PATH) { 173 # !!!:cmolick:20020301 uninstalled products might best go to 174 # the built products dir, or a subfolder if there are asides 175 export deferred TARGET_BUILD_DIR = $(TEMP_ROOT)/UninstalledProducts ; 176 } 177 else { 178 export deferred TARGET_BUILD_DIR = $(INSTALL_ROOT)/$(INSTALL_PATH) ; 179 } 180 deferred BASE_PROJECT_HEADER_DIR = $(TEMP_ROOT)/ProjectHeaders ; 181 if $(INSTALLED_PRODUCT_ASIDES) = YES { 182 # built products go in subfolder when there are asides 183 export deferred BUILT_PRODUCTS_DIR = $(BUILD_ROOT)/BuiltProducts ; 184 } 185 else { 186 # built products go in build folder when there are no asides 187 export deferred BUILT_PRODUCTS_DIR = $(BUILD_ROOT) ; 188 } 189 } 190 else { 191 export deferred TARGET_BUILD_DIR = $(BUILD_DIR) ; 192 export deferred BUILT_PRODUCTS_DIR = $(BUILD_DIR) ; 193 deferred BASE_PROJECT_HEADER_DIR = $(BUILD_ROOT)/ProjectHeaders ; 194 } 195} 196# Copyright (c) 1999-2002 Apple Computer, Inc. 197# All rights reserved. 198 199# old skool... 200# Source root is SRCROOT, or ., or working directory 201# Root values are overridden by default 202#SRCROOT default = $(PWD) ; 203#SRCROOT default = . ; 204#SOURCE_ROOT default = $(SRCROOT) ; 205 206# Maps legacy Makefile variables to modern Jambase variables 207# Set global C flags, architectures, and architecture flags for linking 208GLOBAL_CFLAGS default = $(RC_NONARCH_CFLAGS) ; 209ARCHITECTURES default = $(RC_ARCHS) ; 210SUPPORTED_ARCHITECTURES = i386 ppc ; 211VALID_ARCHS default = i386 ppc ; 212for ARCH in $(SUPPORTED_ARCHITECTURES) { 213 if $(RC_$(ARCH)) = YES { 214 $(ARCH) = YES ; 215 } 216} 217 218# More compatibility definitions for things that we have 219# renamed that we had already told external users about 220export deferred TEMP_FILES_DIR = $(TEMP_DIR) ; 221export deferred DERIVED_SOURCES_DIR = $(DERIVED_FILE_DIR) ; 222export deferred BUILD_PATH = $(TEMP_ROOT) ; 223 224export deferred PROJECT = $(PROJECT_NAME) ; 225export deferred TARGETNAME = $(TARGET_NAME) ; 226 227# (the following four are build settings to the generated package files 228# written by PBXCore -- the new names have underscores to indicate that 229# they are private, and they have more consistent names -- we should 230# be able to remove the old compatibility settings soon) 231export deferred PRODUCT_SETTINGS_PATH = $(_INFO_PLIST_FILE_PATH) ; 232export deferred PKGINFO_FILE_PATH = $(_PKGINFO_FILE_PATH) ; 233export deferred VERSION_SETTINGS_PATH = $(_VERSION_PLIST_FILE_PATH) ; 234export deferred DEVELOPMENT_SETTINGS_PATH = $(_PBDEVELOPMENT_PLIST_FILE_PATH) ; 235# Copyright (c) 1999-2002 Apple Computer, Inc. 236# All rights reserved. 237 238# !!!cmolick:20000821 hardcoded tool paths because variables not set yet 239APPLE_INTERNAL_TOOLS default = /AppleInternal/Developer/Tools ; 240SYSTEM_DEVELOPER_TOOLS default = /Developer/Tools ; 241# Variables for invoking commands using explict paths 242# except where built in shell functions should be used 243ASM default = /usr/bin/as ; 244BRIDGET default = /usr/bin/bridget ; 245# !!!:anders:20020110 The following has been moved to the BeginProduct rule, so that 246# definitions of USE_GCC3 in the target or build style can take effect. 247# CC default = /usr/bin/cc ; 248CD default = cd ; 249CHMOD default = /bin/chmod ; 250CHOWN default = /usr/sbin/chown ; 251CP default = /bin/cp ; 252DITTO default = /usr/bin/ditto ; 253ECHO default = echo ; 254EGREP default = /usr/bin/egrep ; 255FASTCP default = /usr/lib/fastcp ; 256FIXPRECOMPS default = /usr/bin/fixPrecomps ; 257FIND default = /usr/bin/find ; 258GATHERHEADERDOC default = /usr/bin/gatherHeaderDoc ; 259HEADERDOC2HTML default = /usr/bin/headerdoc2html ; 260INTERFACER default = $(APPLE_INTERNAL_TOOLS)/Interfacer ; 261JAR default = /usr/bin/jar ; 262export JAVA_COMPILER default = /usr/bin/javac ; 263export JAVACONFIG default = /usr/bin/javaconfig ; 264# !!!:anders:20020110 The following has been moved to the BeginProduct rule, so that 265# definitions of USE_GCC3 in the target or build style can take effect. 266# LD default = /usr/bin/cc ; 267LEX default = /usr/bin/lex ; 268LIBTOOL default = /usr/bin/libtool ; 269LN default = /bin/ln ; 270LNRESOLVE default = $(SYSTEM_DEVELOPER_TOOLS)/lnresolve ; 271MAKEPSEUDOLIB default = $(APPLE_INTERNAL_TOOLS)/MakePseudoLibrary ; 272MERGEINFO default = /usr/lib/mergeInfo ; 273MKDIR default = /bin/mkdir ; 274MIG default = /usr/bin/mig ; 275MV default = /bin/mv ; 276NMEDIT default = /usr/bin/nmedit ; 277OSAC default = /usr/bin/osacompile ; 278OSAL default = /usr/bin/osalang ; 279OSAS default = /usr/bin/osascript ; 280PAX default = /bin/pax ; 281PBXCP default = $(SYSTEM_DEVELOPER_TOOLS)/pbxcp ; 282RANLIB default = /usr/bin/ranlib ; 283REGGEN default = reggen ; 284RESMERGER default = $(SYSTEM_DEVELOPER_TOOLS)/ResMerger ; 285RESOURCE_PRESERVING_CP default = $(SYSTEM_DEVELOPER_TOOLS)/CpMac ; 286REZ default = $(SYSTEM_DEVELOPER_TOOLS)/Rez ; 287RM default = /bin/rm ; 288RPCGEN default = /usr/bin/rpcgen ; 289SED default = /usr/bin/sed ; 290SETFILE default = $(SYSTEM_DEVELOPER_TOOLS)/SetFile ; 291SH default = /bin/sh ; 292STRIP default = /usr/bin/strip ; 293TOUCH default = /usr/bin/touch ; 294UNZIP default = /usr/bin/unzip ; 295XARGS default = /usr/bin/xargs ; 296YACC default = /usr/bin/yacc ; 297ZIP default = /usr/bin/zip ; 298 299# Basic operations: 300 301# Rm <files> 302# Removes <files> from the filesystem. Note that the actions are only 303# executed once, no matter how many times the rule is invoked. 304actions together piecemeal Rm 305{ 306 $(RM) -r "$(1)" 307} 308 309# RelativeRm <files> : <location> 310# Removes <files> from <location> after removing grist. 311actions together piecemeal RelativeRm 312{ 313 $(RM) -rf "$(2)$(/)$(1:G=)" 314} 315 316# Mkdir <directory> 317# Creates <directory> 318rule Mkdir 319{ 320 # Only existence of the directory matters 321 NOUPDATE $(1) ; 322} 323actions together piecemeal Mkdir 324{ 325 $(MKDIR) -p "$(1)" 326} 327 328# MkEmptyDir <directory> 329# Makes a directory if necessary, and insures it is empty 330actions together MkEmptyDir 331{ 332 ( $(MKDIR) -p "$(1)" && $(CD) "$(1)" && $(RM) -rf "*" ) 333} 334 335# SymLink <link> : <to> 336# Makes a symbolic link to the path indicated. 337# Link target is treated as a nonfile to preserve the value 338rule SymLink 339{ 340 if ! $(2) in $(PRODUCT_FILES) && $(2) != $(PRODUCT_CLASS_FILE_DIR) { 341 NOTFILE $(2) ; 342 } 343} 344actions SymLink 345{ 346 $(LN) -sf "$(2)" "$(1)" 347} 348 349# Touch <files> 350# Touches files in the filesystem. 351actions Touch 352{ 353 $(TOUCH) "$(1)" 354} 355 356# TouchConditionally <fileToTouch> : <fileToCompareAgainst> 357# Touches a file in the filesystem if <fileToCompareAgainst> is newer. 358rule TouchConditionally 359{ 360 DEPENDS $(1) : $(2) ; 361} 362actions TouchConditionally 363{ 364 $(TOUCH) "$(1:G=)" 365} 366 367# Echo <file> : <text> 368# Echoes text into a file. 369rule Echo 370{ 371 local FILE ; 372 NOTFILE $(2) ; 373 Echo.remove $(1) ; 374 for FILE in $(2) { 375 Echo.append $(1) : $(FILE) ; 376 } 377} 378actions together piecemeal quietly Echo.remove 379{ 380 $(RM) -rf "$(1)" 381} 382actions quietly Echo.append 383{ 384 $(ECHO) "$(2)" >> "$(1)" 385} 386 387# ChangeOwnerAndGroup and ChangeMode to use when installing files 388# All these use the -H option to avoid traversing bad symbolic links 389rule ChangeOwnerAndGroup 390{ 391 if $(INSTALL_OWNER) { 392 if $(INSTALL_GROUP) { 393 ChangeOwnerAndGroup.Action $(1) ; 394 } 395 else { 396 ChangeOwner.Action $(1) ; 397 } 398 } 399} 400actions ChangeOwnerAndGroup.Action 401{ 402 if [ -e "$(1)" ] 403 then $(CHOWN) -RH $(INSTALL_OWNER):$(INSTALL_GROUP) "$(1)" 404 fi 405} 406actions ChangeOwner.Action 407{ 408 if [ -e "$(1)" ] 409 then $(CHOWN) -RH $(INSTALL_OWNER) "$(1)" 410 fi 411} 412actions ChangeMode 413{ 414 if [ -e "$(1)" ] 415 then $(CHMOD) -RH $(INSTALL_MODE_FLAG) "$(1)" 416 fi 417} 418 419# Strip <target> 420# Runs strip to remove debugging symbols from the executable of the target 421actions Strip 422{ 423 $(STRIP) $(STRIPFLAGS) "$(1)" 424} 425 426# SetFile <fork file> 427# Appends type and creator to a file 428rule SetFile 429{ 430 local MACOS_TYPE_ARG ; 431 local MACOS_CREATOR_ARG ; 432 if $(MACOS_TYPE) { 433 MACOS_TYPE_ARG = -t '$(MACOS_TYPE)' ; 434 } 435 if $(MACOS_CREATOR) { 436 MACOS_CREATOR_ARG = -c '$(MACOS_CREATOR)' ; 437 } 438 SETFILEFLAGS on $(1) = $(MACOS_TYPE_ARG) $(MACOS_CREATOR_ARG) "$(OTHER_SETFILEFLAGS)" ; 439} 440actions SetFile 441{ 442 $(SETFILE) $(SETFILEFLAGS) "$(1)" 443} 444 445# Rez <fork file> : <target file> 446# Appends resource fork data to a file 447rule Rez 448{ 449 local MACOS_TYPE_ARG ; 450 local MACOS_CREATOR_ARG ; 451 DEPENDS $(1) : $(2) ; 452 if $(MACOS_TYPE) { 453 MACOS_TYPE_ARG = -t '$(MACOS_TYPE)' ; 454 } 455 if $(MACOS_CREATOR) { 456 MACOS_CREATOR_ARG = -c '$(MACOS_CREATOR)' ; 457 } 458 REZFLAGS on $(1) = -append -d SystemSevenOrLater=1 $(MACOS_TYPE_ARG) $(MACOS_CREATOR_ARG) $(OTHER_REZFLAGS) ; 459 if ! $(REZ_EXECUTABLE) = "YES" { 460 # by default use data forks 461 REZFLAGS on $(1) += -useDF ; 462 } 463} 464actions Rez 465{ 466 $(REZ) "$(2)" "$(REZFLAGS)" -o "$(1)" 467} 468 469# ResMerge <fork file> : <rsrc file> 470# Merges the resources from binary resource file 'rsrc file' into 'fork file' 471rule ResMerge 472{ 473 local MACOS_TYPE_ARG ; 474 local MACOS_CREATOR_ARG ; 475 DEPENDS $(1) : $(2) ; 476 if $(MACOS_TYPE) { 477 MACOS_TYPE_ARG = -fileType '$(MACOS_TYPE)' ; 478 } 479 if $(MACOS_CREATOR) { 480 MACOS_CREATOR_ARG = -fileCreator '$(MACOS_CREATOR)' ; 481 } 482 RESMERGEFLAGS on $(1) = -append $(MACOS_TYPE_ARG) $(MACOS_CREATOR_ARG) $(OTHER_RESMERGERFLAGS) ; 483 if ! $(REZ_EXECUTABLE) = "YES" { 484 # by default use data forks 485 RESMERGEFLAGS on $(1) += -dstIs DF ; 486 } 487} 488actions ResMerge 489{ 490 $(RESMERGER) "$(2)" "$(RESMERGEFLAGS)" -o "$(1)" 491} 492 493# RezCollector and ResMergerCollector either compile 494# resource manager resources together, or split compiles 495# by file with the first compile being treated differently. 496# This code assumes collectors will be declared product files 497# only after the first Collector rule evaluation. 498rule RezCollector 499{ 500 DEPENDS $(1) : $(2) ; 501 REZFLAGS on $(1) = -d SystemSevenOrLater=1 -useDF $(OTHER_REZFLAGS) ; 502 if $(REZ_TOGETHER) = YES { 503 RezCollector.together $(1) : $(2) ; 504 } 505 else { 506 if ! $(1) in $(PRODUCT_FILES) { 507 RezCollector.initial $(1) : $(2) ; 508 } 509 else { 510 RezCollector.append $(1) : $(2) ; 511 } 512 } 513} 514actions together piecemeal RezCollector.together 515{ 516 if [ -f "$(1)" ]; then 517 _appendoption=-append 518 fi 519 $(REZ) -o "$(1)" $_appendoption "$(REZFLAGS)" "$(2)" 520} 521actions RezCollector.initial 522{ 523 $(RM) -f "$(1)" && \ 524 $(REZ) -o "$(1)" "$(REZFLAGS)" "$(2)" 525} 526actions RezCollector.append 527{ 528 $(REZ) -o "$(1)" -append "$(REZFLAGS)" "$(2)" 529} 530 531rule ResMergerCollector 532{ 533 DEPENDS $(1) : $(2) ; 534 RESMERGEFLAGS on $(1) = -dstIs DF $(OTHER_RESMERGERFLAGS) ; 535 if $(REZ_TOGETHER) = YES { 536 ResMergerCollector.together $(1) : $(2) ; 537 } 538 else { 539 if ! $(1) in $(PRODUCT_FILES) { 540 ResMergerCollector.initial $(1) : $(2) ; 541 } 542 else { 543 ResMergerCollector.append $(1) : $(2) ; 544 } 545 } 546} 547actions together piecemeal ResMergerCollector.together 548{ 549 if [ -f "$(1)" ]; then 550 _appendoption=-append 551 fi 552 $(RESMERGER) -o "$(1)" $_appendoption "$(RESMERGEFLAGS)" "$(2)" 553} 554actions ResMergerCollector.initial 555{ 556 $(RM) -f "$(1)" && \ 557 $(RESMERGER) -o "$(1)" "$(RESMERGEFLAGS)" "$(2)" 558} 559actions ResMergerCollector.append 560{ 561 $(RESMERGER) -o "$(1)" -append "$(RESMERGEFLAGS)" "$(2)" 562} 563 564# ResMergerProduct - used to transfer collector resources to final destination 565rule ResMergerProduct 566{ 567 local MACOS_TYPE_ARG ; 568 local MACOS_CREATOR_ARG ; 569 DEPENDS $(1) : $(2) ; 570 if $(MACOS_TYPE) { 571 MACOS_TYPE_ARG = -fileType '$(MACOS_TYPE)' ; 572 } 573 if $(MACOS_CREATOR) { 574 MACOS_CREATOR_ARG = -fileCreator '$(MACOS_CREATOR)' ; 575 } 576 RESMERGEFLAGS on $(1) = $(MACOS_TYPE_ARG) $(MACOS_CREATOR_ARG) -srcIs DF $(OTHER_RESMERGERFLAGS) ; 577 if $(REZ_EXECUTABLE) = "YES" { 578 ResMergerProductResourceFork $(1) : $(2) ; 579 } 580 else { 581 RESMERGEFLAGS on $(1) += -dstIs DF ; 582 ResMergerProductDataFork $(1) : $(2) ; 583 } 584} 585actions ResMergerProductResourceFork 586{ 587 $(REZ) -o "$(1)" < /dev/null && \ 588 $(RESMERGER) "$(2)" $(RESMERGEFLAGS) -o "$(1)" 589} 590actions ResMergerProductDataFork 591{ 592 $(RM) -f "$(1)" && \ 593 $(RESMERGER) "$(2)" $(RESMERGEFLAGS) -o "$(1)" 594} 595 596# Fixprecomps <precomp> : <header> 597# Ensures that the precompiled header is up to date 598if $(FIXPRECOMPS) { 599 rule Fixprecomps 600 { 601 DEPENDS $(1) : $(2) ; 602 } 603 actions Fixprecomps 604 { 605 $(FIXPRECOMPS) -precomps "$(1)" 606 } 607} else { 608 rule Fixprecomps 609 { 610 # if we don't have a fixprecomps command, we'll just 611 # quietly do nothing 612 NOTFILE $(1) ; 613 } 614} 615 616 617# Copy operations: 618 619# Cp <destination> : <source> 620# Reliably copies files only. 621# Leaf names of the source and destination are expected to match. 622rule Cp 623{ 624 DEPENDS $(1) : $(2) ; 625} 626# !!!:cmolick:20020130 use of lnresolve allows references to be symbolic links 627actions together piecemeal Cp 628{ 629 _source=`$(LNRESOLVE) "$(2)"` 630 $(CP) "$(CPFLAGS)" "$_source" "$(1)" 631} 632 633# PBXCp <destination-file> : <source-file> 634# Reliably copies files only. Does not currently respect Mac OS 635# Finder info or resource forks, but it does skip CVS directories 636# and it does optionally strip Mach-O executables. 637# Leaf names of the source and destination are expected to match. 638rule PBXCp 639{ 640 if $(ACTION) != installhdrs { 641 DEPENDS $(1) : $(2) ; 642 } 643 PBXCP_FLAGS on $(1) = ; 644 VERBOSE_PBXCP default = NO ; 645 if $(VERBOSE_PBXCP) = YES { 646 PBXCP_FLAGS on $(1) += -V ; 647 } 648 PBXCP_FLAGS on $(1) += -exclude .DS_Store ; 649 if $(REMOVE_CVS_FROM_RESOURCES) = YES { 650 PBXCP_FLAGS on $(1) += -exclude CVS ; 651 } 652 if $(COPY_PHASE_STRIP) = YES && $(ACTION) != installhdrs { 653 PBXCP_FLAGS on $(1) += -strip-debug-symbols ; 654 } 655 # Because any content copied may have been generated, and so may be 656 # in the form of a symlink to the actual content, it is necessary 657 # to resolve one level of symbolic link for all sources copied. 658 PBXCP_FLAGS on $(1) += -resolve-src-symlinks ; 659 660 PBXCp.CopyToDirectory $(1) : $(2) ; 661} 662actions together piecemeal updated PBXCp.CopyToDirectory 663{ 664 $(PBXCP) $(PBXCP_FLAGS:Q) $(2:Q) $(1:DQ) 665} 666 667# Ditto <destination> : <source> 668# Directory to directory copies. 669rule Ditto 670{ 671 DEPENDS $(1) : $(2) ; 672} 673actions Ditto 674{ 675 $(DITTO) $(2:Q) $(1:Q) 676} 677 678# RobustCp <destination> : <source> 679# RobustCp is like Cp, but is made more robust by first removing 680# any previous copy results and then conditionally removing CVS 681# directories from the destination. 682rule RobustCp 683{ 684 if ! $(ACTION) = installhdrs { 685 DEPENDS $(1) : $(2) ; 686 } 687 if $(REMOVE_CVS_FROM_RESOURCES) = YES && $(DEPLOYMENT_POSTPROCESSING) = YES { 688 RobustCp.CleanBeforeAndAfter $(1) : $(2) ; 689 } 690 else { 691 RobustCp.CleanBefore $(1) : $(2) ; 692 } 693 if $(COPY_PHASE_STRIP) = YES && ! $(ACTION) = installhdrs { 694 StripBinaries $(1) ; 695 } 696} 697actions RobustCp.CleanBeforeAndAfter 698{ 699 if [ -d "$(1)" ] 700 then $(RM) -r "$(1)" 701 fi 702 if [ -e "$(2)" ] 703 then 704 _source=`$(LNRESOLVE) "$(2)"` 705 $(CP) -fRP "$_source" "$(1)" 706 if [ -d "$_source" ] 707 then 708 $(FIND) "$(1)" -name CVS -type d -prune -print0 | $(XARGS) -0 rm -r 709 fi 710 fi 711} 712actions RobustCp.CleanBefore 713{ 714 if [ -d "$(1)" ] 715 then $(RM) -r "$(1)" 716 fi 717 if [ -e "$(2)" ] 718 then _source=`$(LNRESOLVE) "$(2)"` 719 $(CP) -fRP "$_source" "$(1)" 720 fi 721} 722 723# StripBinaries <starting directory> 724# Uses find to run strip -s on all binaries starting from a file or directory 725actions StripBinaries 726{ 727 if [ -f "$(1)" ]; then 728 filetype=`file "$(1)"` 729 macho=`echo $filetype | fgrep Mach-O | sed 's/:.*//'` 730 ararch=`echo $filetype | fgrep ar\ archive | sed 's/:.*//'` 731 if [ "x$macho" != "x" ]; then 732 $(STRIP) -S "$macho" 733 fi 734 if [ "x$ararch" != "x" ]; then 735 $(STRIP) -S "$ararch" 736 fi 737 else 738 machos=`cd "$(1)"; $(FIND) . -type f -print0 | xargs -0 file | fgrep Mach-O | sed 's/:.*//'` 739 ararchs=`cd "$(1)"; $(FIND) . -type f -print0 | xargs -0 file | fgrep ar\ archive | sed 's/:.*//'` 740 if [ "x$machos" != "x" ]; then 741 cd "$(1)"; 742 origIFS=$IFS 743 IFS=" 744" 745 for curbinary in $machos ; do 746 $(STRIP) -S "$curbinary" 747 done 748 IFS=$oldIFS 749 fi 750 if [ "x$ararchs" != "x" ]; then 751 cd "$(1)"; 752 origIFS=$IFS 753 IFS=" 754" 755 for curbinary in $ararchs ; do 756 $(STRIP) -S "$curbinary" 757 done 758 IFS=$oldIFS 759 fi 760 fi 761} 762 763# ResourcePreservingCp <destination> : <source> 764# where the leaf names of <destination> and <source> are the same 765# and CpMac is to be used to insure resources are preserved. 766# Although CpMac is invoked with -r, this command is only reliable 767# for individual file copies becaues there is no preremove of 768# a directory destination which could cause nesting of the copy. 769rule ResourcePreservingCp 770{ 771 DEPENDS $(1) : $(2) ; 772} 773actions together piecemeal ResourcePreservingCp 774{ 775 $(RESOURCE_PRESERVING_CP) -r "$(2)" "$(1)" 776} 777 778# ResourcePreservingMv <destination> : <source> : <junk> 779# where the leaf names of <destination> and <source> are the same 780# and CpMac is to be used to insure resources are preserved. 781# The <junk> is removed after copying. 782rule ResourcePreservingMv 783{ 784 DEPENDS $(1) : $(2) ; 785} 786actions together piecemeal ResourcePreservingMv 787{ 788 $(RESOURCE_PRESERVING_CP) -r "$(2)" "$(1)" 789} 790 791# CloneHeader <primary target> : <header> : <target directory> 792# Writes in the target directory a stub clone of the header 793# which contains only an #import directive with the path 794# to the real header in quotes. 795# Individual header clones depend on the PROJECT_HEADER_CLONE 796# nonfile target which is depended on by the product and object files. 797rule CloneHeader 798{ 799 # derive name of header clone and find full path to header 800 local HEADER_CLONE ; 801 if $(3) = $(PUBLIC_HEADER_CLONE_DIR) { 802 HEADER_CLONE = $(2:BSG=PublicHeaderClone) ; 803 } 804 else { 805 if $(3) = $(PRIVATE_HEADER_CLONE_DIR) { 806 HEADER_CLONE = $(2:BSG=PrivateHeaderClone) ; 807 } 808 else { 809 HEADER_CLONE = $(2:BSG=ProjectHeaderClone) ; 810 } 811 } 812 local HEADER_PATH ; 813 if AbsolutePath in $($(2:G=)_ATTRIBUTES) { 814 HEADER_PATH = $(2:G=) ; 815 } 816 else { 817 HEADER_PATH = $(SOURCE_ROOT)$(/)$(2:G=) ; 818 } 819 LOCATE on $(HEADER_CLONE) = $(3) ; 820 DEPENDS $(HEADER_CLONE) : $(3) ; 821 if ! $(3) in $(PRODUCT_FILES) { 822 Mkdir $(3) ; 823 ProductFile $(3) ; 824 } 825 if $(3) = $(PRIVATE_HEADER_CLONE_DIR) && $(PRIVATE_HEADER_CLONE_LINK) { 826 DEPENDS $(HEADER_CLONE) : $(PRIVATE_HEADER_CLONE_LINK) ; 827 if ! $(PRIVATE_HEADER_CLONE_LINK) in $(PRODUCT_FILES) { 828 SymLink $(PRIVATE_HEADER_CLONE_LINK) : $(PRIVATE_HEADER_CLONE_LINK_PATH) ; 829 ProductFile $(PRIVATE_HEADER_CLONE_LINK) ; 830 } 831 } 832 if $(3) = $(PUBLIC_HEADER_CLONE_DIR) && $(PUBLIC_HEADER_CLONE_LINK) { 833 DEPENDS $(HEADER_CLONE) : $(PUBLIC_HEADER_CLONE_LINK) ; 834 if ! $(PUBLIC_HEADER_CLONE_LINK) in $(PRODUCT_FILES) { 835 SymLink $(PUBLIC_HEADER_CLONE_LINK) : $(PUBLIC_HEADER_CLONE_LINK_PATH) ; 836 ProductFile $(PUBLIC_HEADER_CLONE_LINK) ; 837 } 838 } 839 # make clone and record as build phase product 840 ImportStub $(HEADER_CLONE) : $(HEADER_PATH) ; 841 ProductFile $(HEADER_CLONE) ; 842 LOCATE on $(HEADER_CLONE) = $(3) ; 843} 844 845# ImportStub <stub file> : <stub import file> 846# Generates a file with one line which is an #import directive 847# and the second parameter quoted which should be a full path 848# to the real file to be imported. 849rule ImportStub 850{ 851 DEPENDS $(1) : $(2) ; 852 NOUPDATE $(1) ; 853} 854actions ImportStub 855{ 856 echo "#import" \""$(2)"\" > "$(1)" 857} 858 859# AbsolutePathImportStub <stub file> : <stub import file> 860# Generates a file with one line which is an #import directive 861# and the second parameter quoted which should be a full path 862# to the real file to be imported. 863# If $2 is not an absolute path, $(SRCROOT) will be prepended to make it absolute. 864rule AbsolutePathImportStub 865{ 866 DEPENDS $(1) : $(2) ; 867 NOUPDATE $(1) ; 868} 869actions AbsolutePathImportStub 870{ 871 firstChar=`echo "$(2)" | colrm 2` 872 if [ z$firstChar = z"/" -o z$firstChar = z"~" ] ; then 873 includePath="$(2)" 874 else 875 includePath="$(SRCROOT)/$(2)" 876 fi 877 echo "#include" \""${includePath}"\" > "$(1)" 878} 879 880# HeaderDoc <headerdoc target (table of contents for header)> : <header> 881rule HeaderDoc 882{ 883 DEPENDS $(1) : $(2) ; 884} 885actions HeaderDoc 886{ 887 $(HEADERDOC2HTML) -o "$(HEADERDOC_DIR)" "$(2)" 888} 889 890# GatheredHeaderDoc <gathered headerdoc target> 891rule GatheredHeaderDoc 892{ 893} 894actions GatheredHeaderDoc 895{ 896 $(GATHERHEADERDOC) "$(HEADERDOC_DIR)" 897} 898 899# Source derivation operations: 900 901# Lex <file>.{c|m} : <file>.l[m] 902# Runs lex to generate <file>.c or <file>.m based on scanner input 903rule Lex 904{ 905 DEPENDS $(1) : $(2) ; 906} 907 908actions Lex 909{ 910 $(LEX) $(LEXFLAGS) "-o$(1)" "$(2)" 911} 912 913# Yacc <file>.h <file>.{c|m} : <file>.y[m] 914# Uses yacc to generate parser from description 915rule Yacc 916{ 917 DEPENDS $(1) : $(2) ; 918} 919 920actions Yacc 921# Generate result by noting location, going to derived source directory, 922# running yacc, then copying the results to what is desired. 923{ 924 origin=`/bin/pwd` && $(CD) "$(1[1]:D)" && $(YACC) $(YACCFLAGS) -d "$origin/$(2)" && $(CP) y.tab.h "$(1[1])" && $(CP) y.tab.c "$(1[2])" 925} 926 927# RPCGen <proto>.h <proto>_xdr.c : <proto>.x 928# Generates RPC stubs from specifications 929# 930rule RPCGen 931{ 932 DEPENDS $(1) : $(2) ; 933} 934 935# Generate header and C code with two calls to rpcgen 936actions RPCGen 937{ 938 $(RPCGEN) $(RPCGENFLAGS) -h -o "$(1[1])" "$(2)" 939 $(RPCGEN) $(RPCGENFLAGS) -c -o "$(1[2])" "$(2)" 940} 941 942# Mig <file>.h <file>User.c : <file>.defs OR 943# Mig <file>Server.h <file>Server.c : <file>.defs 944# Runs mig to create client and server files from a definition file. 945rule Mig 946{ 947 DEPENDS $(1) : $(2) ; 948 # was: $(MACH_SERVER) = YES || $(MACH_CLIENT_AND_SERVER) = YES 949 if Server in $($(2)_ATTRIBUTES) { 950 Mig.server $(1) : $(2) ; 951 } 952 else { 953 Mig.client $(1) : $(2) ; 954 } 955} 956actions Mig.client 957{ 958 origin=`pwd` && $(CD) "$(1[1]:D)" && $(MIG) $(OTHER_MIGFLAGS) "$origin/$(2)" 959} 960actions Mig.server 961{ 962 origin=`pwd` && $(CD) "$(1[1]:D)" && $(MIG) $(OTHER_MIGFLAGS) -sheader "$(2:B)Server.h" "$origin/$(2)" 963} 964 965# Bridget <primary target> : <jobs file> 966rule Bridget 967{ 968 # set up common settings and paths needed for bridget usage 969 JAVA_HEADERS default = /Developer/Java/Headers /System/Library/Frameworks/JavaVM.framework/Headers ; 970 if ! $(BRIDGET_FILES_DIR) { 971 BRIDGET_FILES_DIR = $(DERIVED_FILE_DIR)$(/)JavaBridgeFiles ; 972 Mkdir $(BRIDGET_FILES_DIR) ; 973 ProductFile $(BRIDGET_FILES_DIR) ; 974 } 975 if $(BRIDGE_JAVA) = YES { 976 # produce the file list draft 977 # conditionally update the file list from the draft 978 BRIDGET_DERIVED_JAVA_FILE_LIST = $(FILE_LIST:G=BridgetDerivedJavaFileList)BridgetDerivedJavaFileList ; 979 NOTFILE $(BRIDGET_DERIVED_JAVA_FILE_LIST) ; 980 DEPENDS $(1) : $(BRIDGET_DERIVED_JAVA_FILE_LIST) ; 981 DEPENDS $(BRIDGET_DERIVED_JAVA_FILE_LIST) : $(2) ; 982 DEPENDS $(BRIDGET_DERIVED_JAVA_FILE_LIST) : $(BRIDGET_FILES_DIR) ; 983 DEPENDS $(BRIDGET_DERIVED_JAVA_FILE_LIST) : $(OBJECT_FILE_DIR) ; 984 Bridget.UpdateJavaFileList $(BRIDGET_DERIVED_JAVA_FILE_LIST) : $(2) ; 985 # derive files using file list 986 # compile derived files (nonfile target?) 987 BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG = $(FILE_LIST:G=BridgetDeriveAndCompileJavaTag)BridgetDeriveAndCompileJavaTag ; 988 ProductFile $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) ; 989 DEPENDS $(1) : $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) ; 990 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(BRIDGET_DERIVED_JAVA_FILE_LIST) ; 991 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(BRIDGET_FILES_DIR) ; 992 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(CLASS_FILE_DIR) ; 993 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(2) ; 994 if $(JAVA_COMPILER:B) = jikes { 995 Bridget. DeriveAndCompileJava.jikes $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(2) ; 996 } 997 else { 998 Bridget.DeriveAndCompileJava.javac $(BRIDGET_DERIVE_AND_COMPILE_JAVA_TAG) : $(2) ; 999 } 1000 } 1001 if $(BRIDGE_OBJC) = YES { 1002 # Produce the derived C file list draft 1003 # and conditionally update the file list from the draft. 1004 BRIDGET_DERIVED_C_FILE_LIST = $(FILE_LIST:G=BridgetDerivedCFileList)BridgetDerivedCFileList ; 1005 NOTFILE $(BRIDGET_DERIVED_C_FILE_LIST) ; 1006 DEPENDS $(1) : $(BRIDGET_DERIVED_C_FILE_LIST) ; 1007 DEPENDS $(BRIDGET_DERIVED_C_FILE_LIST) : $(2) ; 1008 DEPENDS $(BRIDGET_DERIVED_C_FILE_LIST) : $(BRIDGET_FILES_DIR) ; 1009 DEPENDS $(BRIDGET_DERIVED_C_FILE_LIST) : $(OBJECT_FILE_DIR) ; 1010 Bridget.UpdateCFileList $(BRIDGET_DERIVED_C_FILE_LIST) : $(2) ; 1011 BRIDGET_DERIVE_AND_COMPILE_C_TAG = $(FILE_LIST:G=BridgetDeriveAndCompileCTag)BridgetDeriveAndCompileCTag ; 1012 ProductFile $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) ; 1013 DEPENDS $(1) : $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) ; 1014 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) : $(BRIDGET_DERIVED_C_FILE_LIST) ; 1015 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) : $(BRIDGET_FILES_DIR) ; 1016 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) : $(OBJECT_FILE_DIR) ; 1017 DEPENDS $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) : $(2) ; 1018 # derive files using file list 1019 # compile derived files (nonfile target?) 1020 BRIDGET_FILE_LIST default = $(FILE_LIST)Bridget ; 1021 BRIDGET_CFLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -fpascal-strings $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) ; 1022 BRIDGET_CFLAGS on $(1) += -pipe ; 1023 # seed search paths with target-wide values 1024 HEADER_SEARCH_PATHS on $(1) = $(HEADER_SEARCH_PATHS) ; 1025 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 1026 1027 # We must compile with the extension-specific build flags 1028 BRIDGET_CFLAGS on $(1) += $($(2:S)_CFLAGS) ; 1029 # Add debug flags, if appropriate. 1030 if $(DEBUGGING_SYMBOLS) = YES { 1031 BRIDGET_CFLAGS on $(1) += -g ; 1032 } 1033 # Add profiling flags, if appropriate. 1034 if $(PROFILING_CODE) = YES { 1035 BRIDGET_CFLAGS on $(1) += -pg ; 1036 } 1037 # Pass the trusted-precomp file name to the compiler to keep track 1038 # of which precompiled headers it has already sanity checked. 1039 if $(OS) in MACOS DARWIN { 1040 BRIDGET_CFLAGS on $(1) += -precomp-trustfile $(PRECOMP_TRUSTFILE) ; 1041 } 1042 if $(CPP_HEADERMAP_FILE) { 1043 BRIDGET_CFLAGS on $(1) += "-Wp,-header-mapfile,$(CPP_HEADERMAP_FILE)" ; 1044 } 1045 if YES in $(GENERATE_CPP_ILOG_FILES) { 1046 local INCLUSION_LOG_FILE default = $(OBJECT_FILE_DIR)-$(VARIANT)$(/)$(ARCH)$(/)$(1:DB).ilog ; 1047 BRIDGET_CFLAGS on $(1) += "-Wp,-inclusion-log-file,$(INCLUSION_LOG_FILE)" ; 1048 } 1049 if $(PREFIX_HEADER) { 1050 PREFIX_HEADER_CFLAGS on $(1) += -include $(PREFIX_HEADER) ; 1051 } 1052 Bridget.DeriveAndCompileC $(BRIDGET_DERIVE_AND_COMPILE_C_TAG) : $(2) ; 1053 } 1054} 1055# Bridget.UpdateJavaFileList <list update target> <bridget file> generates draft 1056# and updates definitive list if it is missing or out of date 1057actions Bridget.UpdateJavaFileList 1058{ 1059 $(BRIDGET) -listjava "-I$(BRIDGET_FILES_DIR)" "-I$(SOURCE_ROOT)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(JAVA_HEADERS_DIR)" "$(BRIDGETFLAGS)" "$(OTHER_BRIDGETFLAGS)" "$(2)" >> "$(1:G=)Draft" && \ 1060 if [ ! -e "$(1:G=)" ]; then 1061 cp "$(1:G=)Draft" "$(1:G=)" 1062 else 1063 _file_list_diffs=`diff --brief "$(1:G=)Draft" "$(1:G=)"` 1064 if [ "x$_file_list_diffs" != "x" ]; then 1065 cp "$(1:G=)Draft" "$(1:G=)" 1066 fi 1067 fi 1068} 1069actions Bridget.DeriveAndCompileJava.javac 1070{ 1071 $(BRIDGET) -java -o "$(BRIDGET_FILES_DIR)" "-I$(BRIDGET_FILES_DIR)" "-I$(SOURCE_ROOT)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(JAVA_HEADERS_DIR)" "$(BRIDGETFLAGS)" "$(OTHER_BRIDGETFLAGS)" "$(2)" && \ 1072 frameworkjars="" && \ 1073 for i in `echo $(JAVA_FRAMEWORK_JARS)/*.jar $(JAVA_FRAMEWORK_JARS)/*.zip ` ; do if [ -f "$i" ] ; then frameworkjars="$frameworkjars":"$i" ; fi ; done && \ 1074 classpath="$(CLASS_FILE_DIR)$(LINKED_CLASS_ARCHIVES)$frameworkjars:"`$(JAVACONFIG) DefaultClasspath` && \ 1075 cd "$(BRIDGET_FILES_DIR)" && \ 1076 $(JAVA_COMPILER) $(JAVAC_FLAGS) -sourcepath "$(JAVA_SOURCE_PATH)" -classpath "$classpath" -d "$(CLASS_FILE_DIR)" @"$(BRIDGET_DERIVED_JAVA_FILE_LIST:G=)" && \ 1077 /usr/bin/touch "$(1:G=)" 1078} 1079actions Bridget.DeriveAndCompileJava.jikes 1080{ 1081 $(BRIDGET) -java -o "$(BRIDGET_FILES_DIR)" "-I$(BRIDGET_FILES_DIR)" "-I$(SOURCE_ROOT)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(JAVA_HEADERS_DIR)" "$(BRIDGETFLAGS)" "$(OTHER_BRIDGETFLAGS)" "$(2)" && \ 1082 frameworkjars="" && \ 1083 for i in `echo $(JAVA_FRAMEWORK_JARS)/*.jar $(JAVA_FRAMEWORK_JARS)/*.zip ` ; do if [ -f "$i" ] ; then frameworkjars="$frameworkjars":"$i" ; fi ; done && \ 1084 classpath="$(CLASS_FILE_DIR)$(LINKED_CLASS_ARCHIVES)$frameworkjars:"`$(JAVACONFIG) DefaultClasspath` && \ 1085 cd "$(BRIDGET_FILES_DIR)" && \ 1086 $(JAVA_COMPILER) +E $(JAVAC_FLAGS) -classpath "$classpath" -d "$(CLASS_FILE_DIR)" `cat "$(BRIDGET_DERIVED_JAVA_FILE_LIST:G=)"` && \ 1087 /usr/bin/touch "$(1:G=)" 1088} 1089 1090# Bridget.CompileC.UpdateFileList <list update target> <bridget file> generates draft 1091# and updates definitive list if it is missing or out of date 1092actions Bridget.UpdateCFileList 1093{ 1094 $(BRIDGET) -listobjc "-I$(BRIDGET_FILES_DIR)" "-I$(SOURCE_ROOT)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(JAVA_HEADERS_DIR)" "$(BRIDGETFLAGS)" "$(OTHER_BRIDGETFLAGS)" "$(2)" >> "$(1:G=)Draft" && \ 1095 if [ ! -e "$(1:G=)" ]; then 1096 cp "$(1:G=)Draft" "$(1:G=)" 1097 else 1098 _file_list_diffs=`diff --brief "$(1:G=)Draft" "$(1:G=)"` 1099 if [ "x$_file_list_diffs" != "x" ]; then 1100 cp "$(1:G=)Draft" "$(1:G=)" 1101 fi 1102 fi 1103} 1104actions Bridget.DeriveAndCompileC 1105{ 1106 $(BRIDGET) -stub -init -o "$(BRIDGET_FILES_DIR)" "-I$(BRIDGET_FILES_DIR)" "-I$(SOURCE_ROOT)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(JAVA_HEADERS_DIR)" "$(BRIDGETFLAGS)" "$(OTHER_BRIDGETFLAGS)" "$(2)" && \ 1107 cd "$(BRIDGET_FILES_DIR)" && \ 1108 $(CC) -c $(ARCH_FLAGS) -O -fno-common -no-cpp-precomp -dynamic "$(FLAGS)" $(GLOBAL_CFLAGS) "-I$(DERIVED_PATHS)" "-I$(HEADER_SEARCH_PATHS)" "-I$(JAVA_HEADERS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(TARGET_BUILD_DIR)/$(PUBLIC_HEADER_DIR:G=)" "-I$(TARGET_BUILD_DIR)/$(PRIVATE_HEADER_DIR:G=)" "$(BRIDGET_CFLAGS)" $(PREFIX_HEADER_CFLAGS) `cat "$(BRIDGET_DERIVED_C_FILE_LIST:G=)"` && \ 1109 find "$(BRIDGET_FILES_DIR)" -type f -name '*.o' -print > "$(BRIDGET_FILE_LIST:G=)" && \ 1110 /usr/bin/touch "$(1:G=)" 1111} 1112 1113# GenerateVectorLibraryIntermediates <vector stub> <vector object file> : <exports file> 1114# Generates and compiles vector stub 1115rule GenerateVectorLibraryIntermediates 1116{ 1117 DEPENDS $(1) : $(2) ; 1118 LOCATE on $(2) = $(SOURCE_ROOT) ; 1119 VECTOR_STUB on $(1) = $(VECTOR_STUB) ; 1120 VECTOR_OBJECT_FILE on $(1) = $(VECTOR_OBJECT_FILE) ; 1121 VECTOR_FRAGMENT_NAME on $(1) = $(VECTOR_FRAGMENT_NAME) ; 1122 DYLIB_INSTALLED_NAME on $(1) = $(DYLIB_INSTALLED_NAME) ; 1123 DEPENDS $(VECTOR_STUB) : $(DERIVED_FILE_DIR) ; 1124} 1125actions GenerateVectorLibraryIntermediates 1126{ 1127 $(MAKEPSEUDOLIB) "$(2)" -p -strip -fragname "$(VECTOR_FRAGMENT_NAME)" -vector "$(VECTOR_STUB)" -dylibpath "$(DYLIB_INSTALLED_NAME)" 1128 $(CC) -Wa,-L -c $(ARCH_FLAGS) -O -fno-common -no-cpp-precomp -dynamic "$(FLAGS)" $(GLOBAL_CFLAGS) -o "$(VECTOR_OBJECT_FILE)" "$(VECTOR_STUB)" 1129} 1130 1131MASTER_INTERFACES default = /AppleInternal/Carbon/interfaces ; 1132# !!!:cmolick:20010412 Apple internal RC_ settings nonempty in offical builds 1133INTERFACER_TARGET_UPDATE default = \"$(RC_ProjectName)-$(RC_ProjectSourceVersion)~$(RC_ProjectBuildVersion)\" ; 1134 1135rule InterfacerHeaders 1136{ 1137 INTERFACER_CACHE default = $(TEMP_DIR)$(/)InterfacerCache ; 1138 local BUILD_DIR_AND_SEPARATOR = $(TARGET_BUILD_DIR)$(/) ; 1139 INTERFACER_HEADERS = $(1:G=InterfacerHeaders) ; 1140 if $(INTERFACER_TARGET_UPDATE) { 1141 INTERFACER_HEADER_OPTIONS += -externalHeader $(INTERFACER_TARGET_UPDATE) ; 1142 } 1143 FULL_PUBLIC_HEADER_DIR = $(BUILD_DIR_AND_SEPARATOR)$(PUBLIC_HEADER_DIR:G=) ; 1144 FULL_PUBLIC_HEADER_DIR on $(INTERFACER_HEADERS) = $(FULL_PUBLIC_HEADER_DIR) ; 1145 FULL_PRIVATE_HEADER_DIR = $(BUILD_DIR_AND_SEPARATOR)$(PRIVATE_HEADER_DIR:G=) ; 1146 FULL_PRIVATE_HEADER_DIR on $(INTERFACER_HEADERS) = $(FULL_PRIVATE_HEADER_DIR) ; 1147 # Create symlink to public header dir in versioned frameworks 1148 if $(PUBLIC_HEADER_LINK) 1149 && ! $(PUBLIC_HEADER_LINK) in $(PRODUCT_FILES) { 1150 SymLink $(PUBLIC_HEADER_LINK) : $(PUBLIC_HEADER_LINK_PATH) ; 1151 ProductFile $(PUBLIC_HEADER_LINK) ; 1152 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 1153 ASIDE_PUBLIC_HEADER_LINK default = $(PUBLIC_HEADER_LINK:G=aside) ; 1154 SymLink $(ASIDE_PUBLIC_HEADER_LINK) : $(PUBLIC_HEADER_LINK_PATH) ; 1155 ProductFileAside $(ASIDE_PUBLIC_HEADER_LINK) ; 1156 } 1157 NOUPDATE $(PUBLIC_HEADER_LINK) ; 1158 } 1159 # Create symlink to private header dir in versioned frameworks 1160 if $(PRIVATE_HEADER_LINK) 1161 && ! $(PRIVATE_HEADER_LINK) in $(PRODUCT_FILES) { 1162 SymLink $(PRIVATE_HEADER_LINK) : $(PRIVATE_HEADER_LINK_PATH) ; 1163 ProductFile $(PRIVATE_HEADER_LINK) ; 1164 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 1165 ASIDE_PRIVATE_HEADER_LINK default = $(PRIVATE_HEADER_LINK:G=aside) ; 1166 SymLink $(ASIDE_PRIVATE_HEADER_LINK) : $(PRIVATE_HEADER_LINK_PATH) ; 1167 ProductFileAside $(ASIDE_PRIVATE_HEADER_LINK) ; 1168 } 1169 NOUPDATE $(PRIVATE_HEADER_LINK) ; 1170 } 1171 1172 if $(_BUILD_PHASING) = YES { 1173 BUILD_PHASE_PRODUCTS += $(INTERFACER_HEADERS) ; 1174 } 1175 1176# Mkdir $(FULL_PUBLIC_HEADER_DIR) ; 1177# DEPENDS $(INTERFACER_HEADERS) : $(FULL_PUBLIC_HEADER_DIR) ; 1178# DEPENDS $(INTERFACER_HEADERS) : $(BUILD_DIR_AND_SEPARATOR)$(PUBLIC_HEADER_DIR:G=) ; 1179# if ! $(PUBLIC_HEADER_LINK) in $(PRODUCT_FILES) { 1180# SymLink $(BUILD_DIR_AND_SEPARATOR)$(PUBLIC_HEADER_LINK:G=) : $(PUBLIC_HEADER_LINK_PATH) ; 1181# } 1182# Mkdir $(FULL_PRIVATE_HEADER_DIR) ; 1183# DEPENDS $(INTERFACER_HEADERS) : $(FULL_PRIVATE_HEADER_DIR) ; 1184# DEPENDS $(INTERFACER_HEADERS) : $(BUILD_DIR_AND_SEPARATOR)$(PRIVATE_HEADER_DIR:G=) ; 1185# if ! $(PRIVATE_HEADER_LINK) in $(PRODUCT_FILES) { 1186# SymLink $(BUILD_DIR_AND_SEPARATOR)$(PRIVATE_HEADER_LINK:G=) : $(PRIVATE_HEADER_LINK_PATH) ; 1187# } 1188# if $(_BUILD_PHASING) = YES { 1189# BUILD_PHASE_PRODUCTS += $(FULL_PUBLIC_HEADER_DIR) ; 1190# BUILD_PHASE_PRODUCTS += $(FULL_PRIVATE_HEADER_DIR) ; 1191# BUILD_PHASE_PRODUCTS += $(BUILD_DIR_AND_SEPARATOR)$(PUBLIC_HEADER_LINK:G=) ; 1192# BUILD_PHASE_PRODUCTS += $(BUILD_DIR_AND_SEPARATOR)$(PRIVATE_HEADER_LINK:G=) ; 1193# } 1194 # Create a public header directory 1195 if ! $(PUBLIC_HEADER_DIR) in $(PRODUCT_FILES) { 1196 Mkdir $(PUBLIC_HEADER_DIR) ; 1197 ProductFile $(PUBLIC_HEADER_DIR) ; 1198 DEPENDS $(INTERFACER_HEADERS) : $(PUBLIC_HEADER_DIR) ; 1199 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 1200 ASIDE_PUBLIC_HEADER_DIR default = $(PUBLIC_HEADER_DIR:G=aside) ; 1201 Mkdir $(ASIDE_PUBLIC_HEADER_DIR) ; 1202 ProductFileAside $(ASIDE_PUBLIC_HEADER_DIR) ; 1203 } 1204 } 1205 # Create a private header directory 1206 if ! $(PRIVATE_HEADER_DIR) in $(PRODUCT_FILES) { 1207 Mkdir $(PRIVATE_HEADER_DIR) ; 1208 ProductFile $(PRIVATE_HEADER_DIR) ; 1209 DEPENDS $(INTERFACER_HEADERS) : $(PRIVATE_HEADER_DIR) ; 1210 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 1211 ASIDE_PRIVATE_HEADER_DIR default = $(PRIVATE_HEADER_DIR:G=aside) ; 1212 Mkdir $(ASIDE_PRIVATE_HEADER_DIR) ; 1213 ProductFileAside $(ASIDE_PRIVATE_HEADER_DIR) ; 1214 } 1215 } 1216 1217 Interfacer.Headers $(INTERFACER_HEADERS) ; 1218 # Interfacer headers are required (ideally these should be phase products) 1219 DEPENDS $(1) : $(INTERFACER_HEADERS) ; 1220} 1221 1222actions Interfacer.Headers 1223{ 1224 $(INTERFACER) -masterInterfaces "$(MASTER_INTERFACES)/" -cacheFolder "$(INTERFACER_CACHE)/" $(INTERFACER_HEADER_OPTIONS) -c -rez -framework "$(1:D=:S=:G=)" -p -generated "c=$(FULL_PUBLIC_HEADER_DIR:G=)/" -generatedPriv "c=$(FULL_PRIVATE_HEADER_DIR:G=)/" -generated "rez=$(FULL_PUBLIC_HEADER_DIR:G=)/" -generatedPriv "rez=$(FULL_PRIVATE_HEADER_DIR:G=)/" 1225} 1226 1227rule InterfacerExportSetsAndGlue 1228{ 1229 INTERFACER_CACHE default = $(TEMP_DIR)$(/)InterfacerCache ; 1230 EXPORT_SETS_DIR default = $(DERIVED_FILE_DIR)$(/)ExportSets ; 1231 UPP_GLUE_DIR default = $(DERIVED_FILE_DIR)$(/)UPPGlue ; 1232 COMPONENT_GLUE_DIR default = $(DERIVED_FILE_DIR)$(/)ComponentGlue ; 1233 RAW_GENERATED_EXPORTS_FILE default = $(EXPORT_SETS_DIR)$(/)fw_$(PRODUCT_NAME)_X.exp ; 1234 RAW_GENERATED_PRIVATE_EXPORTS_FILE default = $(EXPORT_SETS_DIR)$(/)fw_$(PRODUCT_NAME)Priv_X.exp ; 1235 # !!!:cmolick:20000602 private exports file optional...bad depend? 1236 PROCESSED_EXPORTS_FILE default = $(DERIVED_FILE_DIR)$(/)$(PRODUCT_NAME).exp ; 1237 DEPENDS $(RAW_GENERATED_EXPORTS_FILE) : $(DERIVED_FILE_DIR) ; 1238 DEPENDS $(RAW_GENERATED_PRIVATE_EXPORTS_FILE) : $(DERIVED_FILE_DIR) ; 1239 DEPENDS $(PROCESSED_EXPORTS_FILE) : $(DERIVED_FILE_DIR) ; 1240 # object file dir needs to be in place for glue object file list 1241 # !!!:cmolick:20020105 this dependence appears superfluous 1242 # DEPENDS $(PROCESSED_EXPORTS_FILE) : $(RAW_GENERATED_EXPORTS_FILE) ; 1243 DEPENDS $(1) : $(PROCESSED_EXPORTS_FILE) ; 1244 if $(GENERATE_HEADERS) = YES { 1245 DEPENDS $(RAW_GENERATED_EXPORTS_FILE) : $(INTERFACER_HEADERS) ; 1246 DEPENDS $(PROCESSED_EXPORTS_FILE) : $(INTERFACER_HEADERS) ; 1247 } 1248 if $(_BUILD_PHASING) = YES { 1249 BUILD_PHASE_PRODUCTS += $(RAW_GENERATED_EXPORTS_FILE) $(PROCESSED_EXPORTS_FILE) ; 1250 } 1251 HEADER_SEARCH_PATHS on $(RAW_GENERATED_EXPORTS_FILE) = $(HEADER_SEARCH_PATHS) ; 1252 FRAMEWORK_SEARCH_PATHS on $(RAW_GENERATED_EXPORTS_FILE) = $(FRAMEWORK_SEARCH_PATHS) ; 1253 if $(GENERATE_COMPONENT_GLUE) = YES { 1254 INTERFACER_FLAGS += -componentGlueC ; 1255 INTERFACER_COMPONENT_GLUE_FLAGS = -generated "componentGlueC=$(COMPONENT_GLUE_DIR)/" -generatedPriv "componentGlueC=$(COMPONENT_GLUE_DIR)/" ; 1256 } 1257 for VARIANT in $(BUILD_VARIANTS) { 1258 DEPENDS $(PROCESSED_EXPORTS_FILE) : $(OBJECT_FILE_DIR_$(VARIANT)) ; 1259 } 1260 GLUE_FILE_LIST default = $(TEMP_DIR)$(/)GlueFileList ; 1261 #!!!:cmolick:20020319 bad build_variants reference was here at one time 1262 Interfacer.RawExportSetsAndGlue $(RAW_GENERATED_EXPORTS_FILE) $(GLUE_FILE_LIST) : $(1) ; 1263 ProductFile $(RAW_GENERATED_EXPORTS_FILE) ; 1264 ProductFile $(GLUE_FILE_LIST) ; 1265 ADDITIONAL_EXPORTS_FILE on $(PROCESSED_EXPORTS_FILE) = $(ADDITIONAL_EXPORTS_FILE) ; 1266 ADDITIONAL_TRADITIONAL_EXPORTS_FILE on $(PROCESSED_EXPORTS_FILE) = $(ADDITIONAL_TRADITIONAL_EXPORTS_FILE) ; 1267 Interfacer.PrepareExportList $(PROCESSED_EXPORTS_FILE) : $(RAW_GENERATED_EXPORTS_FILE) ; 1268 ProductFile $(PROCESSED_EXPORTS_FILE) ; 1269 #!!!:cmolick:200203019 this dependence seems necessary for correct order 1270 DEPENDS $(PROCESSED_EXPORTS_FILE) : $(RAW_GENERATED_EXPORTS_FILE) ; 1271 EXPORTED_SYMBOLS_FILE default = $(PROCESSED_EXPORTS_FILE) ; 1272 ProcessFile $(1) : $(EXPORTED_SYMBOLS_FILE) ; 1273} 1274 1275actions Interfacer.RawExportSetsAndGlue 1276# Generates export sets and UPP glue with Interfacer, 1277# then attempts to compile UPP glue and add resulting 1278# object files to a list to use at link time. 1279{ 1280 $(INTERFACER) -masterInterfaces "$(MASTER_INTERFACES)/" -cacheFolder "$(INTERFACER_CACHE)/" -exportset -uppGlueC "$(INTERFACER_FLAGS)" -framework "$(2[1]:G=:D=:S=)" -p -generated "exportset=$(EXPORT_SETS_DIR)/" -generatedPriv "exportset=$(EXPORT_SETS_DIR)/" -generated "uppGlueC=$(UPP_GLUE_DIR)/" -generatedPriv "uppGlueC=$(UPP_GLUE_DIR)/" $(INTERFACER_COMPONENT_GLUE_FLAGS) 1281 if [ -e "$(UPP_GLUE_DIR)" ]; then 1282 _upp_glue_modules=`ls "$(UPP_GLUE_DIR)"` 1283 if [ ! "$_upp_glue_modules" = x"$_upp_glue_modules" ]; then 1284 cd "$(UPP_GLUE_DIR)" 1285 for _upp_glue in *.c ; do 1286 $(CC) -c $(ARCH_FLAGS) -O -fno-common -no-cpp-precomp -dynamic -Wmost -Wno-four-char-constants -fpascal-strings -fwritable-strings -fexceptions -DCARBON_THRASH=1 -DforCarbon=1 -DACCESSORS_CALLS_ARE_FUNCTIONS=1 -DUSE_INVOKEUPP_C_GLUE=1 "$(FLAGS)" $(GLOBAL_CFLAGS) "-I$(DERIVED_PATHS)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(BUILT_PRODUCTS_DIR)/$(PUBLIC_HEADER_DIR:G=)" "-I$(BUILT_PRODUCTS_DIR)/$(PRIVATE_HEADER_DIR:G=)" $_upp_glue 1287 done 1288 find "$(UPP_GLUE_DIR)" -type f -name '*.i.o' -print > "$(GLUE_FILE_LIST)" 1289 fi 1290 fi 1291 if [ -e "$(COMPONENT_GLUE_DIR)" ]; then 1292 _component_glue_modules=`ls "$(COMPONENT_GLUE_DIR)"` 1293 if [ ! "$_component_glue_modules" = x"$_component_glue_modules" ]; then 1294 cd "$(COMPONENT_GLUE_DIR)" 1295 for _component_glue in *.c ; do 1296 $(CC) -c $(ARCH_FLAGS) -O -fno-common -no-cpp-precomp -dynamic -Wmost -Wno-four-char-constants -fpascal-strings -fwritable-strings -fexceptions -DCARBON_THRASH=1 -DforCarbon=1 -DACCESSORS_CALLS_ARE_FUNCTIONS=1 -DUSE_INVOKEUPP_C_GLUE=1 "$(FLAGS)" $(GLOBAL_CFLAGS) "-I$(DERIVED_PATHS)" "-I$(HEADER_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(BUILT_PRODUCTS_DIR)/$(PUBLIC_HEADER_DIR:G=)" "-I$(BUILT_PRODUCTS_DIR)/$(PRIVATE_HEADER_DIR:G=)" $_component_glue 1297 done 1298 find "$(COMPONENT_GLUE_DIR)" -type f -name '*.i.o' -print >> "$(GLUE_FILE_LIST)" 1299 fi 1300 fi 1301} 1302 1303actions Interfacer.PrepareExportList 1304# Translates PEF-oriented Interfacer export list output into 1305# nmedit-compatible export lists for use with mach-o. 1306{ 1307 _initial_working_dir=`pwd` 1308 cd "$(EXPORT_SETS_DIR)" 1309 ls | $(EGREP) '^fw_$(PRODUCT_NAME)(Priv)?_.+.exp$' > "$(EXPORT_SETS_DIR)$(/)_GeneratedExports" 1310 cat `cat "$(EXPORT_SETS_DIR)$(/)_GeneratedExports"` > "$(EXPORT_SETS_DIR)$(/)_Generated.exp" 1311 cat "$(EXPORT_SETS_DIR)$(/)_Generated.exp" | grep -v ^\* | grep -v ^# | grep -v ^\$ | sort | uniq -u | sed -e '1,$ s/^/_/' > "$(1)" 1312 cd "$_initial_working_dir" 1313 _additional_exports_file="$(ADDITIONAL_EXPORTS_FILE)" 1314 if [ "x$_additional_exports_file" != "x" ]; then 1315 if [ -f "$_additional_exports_file" ]; then 1316 cat "$_additional_exports_file" >> "$(1)" 1317 fi 1318 fi 1319 _additional_traditional_exports_file="$(ADDITIONAL_TRADITIONAL_EXPORTS_FILE)" 1320 if [ "x$_additional_traditional_exports_file" != "x" ]; then 1321 if [ -f "$_additional_traditional_exports_file" ]; then 1322 cat "$_additional_traditional_exports_file" | 1323 grep -v ^\* | grep -v ^# | grep -v ^\$ | sort | uniq -u | sed -e '1,$ s/^/_/' >> "$(1)" 1324 fi 1325 fi 1326} 1327 1328 1329# Linking, class archive generation, and related operations: 1330# 1331# Variables used by linking operations: 1332# FLAGS.o of target, LDFLAGS, SECTORDER_FLAGS 1333# LIBRARY_SEARCH_PATHS, FRAMEWORK_SEARCH_PATHS, 1334# and optionally LINK_FILE_LIST and INIT_ROUTINE 1335 1336# ClassArchive <archive> : <class file dir> 1337# Generates an archive that stores class files in the given directory 1338rule ClassArchive { 1339 if $(JAVA_ARCHIVE_TYPE) = JAR { 1340 local JARFLAGS = $(JAVA_JAR_FLAGS) ; 1341 if $(JAVA_MANIFEST_FILE) { 1342 DEPENDS $(1) : $(JAVA_MANIFEST_FILE) ; 1343 JAVA_MANIFEST_FILE on $(1) = $(SOURCE_ROOT)$(/)$(JAVA_MANIFEST_FILE) ; 1344 JARFLAGS = $(JARFLAGS)m ; 1345 } 1346 JARFLAGS = $(JARFLAGS)f ; 1347 if $(JAVA_ARCHIVE_COMPRESSION) != YES { 1348 JARFLAGS = $(JARFLAGS)0 ; 1349 } 1350 JARFLAGS += -J-Dfile.encoding=UTF8 ; 1351 JARFLAGS on $(1) = $(JARFLAGS) ; 1352 CLASS_FILE_DIR on $(1) = $(CLASS_FILE_DIR) ; 1353 ClassArchive.jarArchive $(1) : $(2) ; 1354 } 1355 else { 1356 if $(JAVA_ARCHIVE_TYPE) = ZIP { 1357 local ZIPFLAGS = $(JAVA_ZIP_FLAGS) ; 1358 if $(JAVA_ARCHIVE_COMPRESSION) != YES { 1359 ZIPFLAGS = $(ZIPFLAGS)0 ; 1360 } 1361 ZIPFLAGS on $(1) = $(ZIPFLAGS) ; 1362 CLASS_FILE_DIR on $(1) = $(CLASS_FILE_DIR) ; 1363 ClassArchive.zipArchive $(1) : $(2) ; 1364 } 1365 } 1366} 1367# Use jar command to generate an archive 1368# from the class file list after removing "./" from each file path 1369actions ClassArchive.jarArchive { 1370 cd "$(2)" && $(MKDIR) -p "$(1:D)" && $(JAR) $(JARFLAGS) $(OTHER_JARFLAGS) "$(JAVA_MANIFEST_FILE)" "$(1)" . 1371} 1372# Use zip command to generate an archive 1373# from the class file list after removing "./" from each file path 1374actions ClassArchive.zipArchive { 1375 cd "$(2)" && $(MKDIR) -p "$(1:D)" && $(ZIP) $(ZIPFLAGS) $(OTHER_ZIPFLAGS) "$(1)" . 1376} 1377 1378# Bulk copy of class files 1379# ClassCopy <product class file dir> : <compiled class file dir> 1380actions ClassCopy { 1381 $(MKDIR) -p "$(1:G=)" && cd "$(2:G=)" && $(PAX) -pe -rw . "$(1:G=)" 1382} 1383 1384# Unarchive <location> : <archive> 1385rule Unarchive 1386{ 1387 _DESTINATION_DIR = $(1:G=) ; 1388 if ! $(_DESTINATION_DIR) in $(PRODUCT_FILES) { 1389 Mkdir $(_DESTINATION_DIR) ; 1390 ProductFile $(_DESTINATION_DIR) ; 1391 } 1392 DEPENDS $(1) : $(_DESTINATION_DIR) ; 1393 DEPENDS $(1) : $(2) ; 1394 switch $(2:S) { 1395 case ".jar" : UnarchiveJar $(1) : $(2) ; 1396 case ".zip" : UnarchiveZip $(1) : $(2) ; 1397 } 1398} 1399 1400# we use unzip to unarchive jars since it's much faster than jar, and we can exclude the manifest file 1401actions UnarchiveJar 1402{ 1403 $(UNZIP) -oq "$(2)" -x META-INF/MANIFEST.MF -d "$(1:G=)" 1404} 1405 1406actions UnarchiveZip 1407{ 1408 $(UNZIP) -oq "$(2)" -d "$(1:G=)" 1409} 1410 1411# ProcessSingleObjectLink <executable> : <inputs> : <rule> 1412# Calls link rule which then calls ProcessLink 1413# in order to generate a master object file 1414# which is also used for symbol editing 1415rule ProcessSingleObjectLink 1416{ 1417 local OTHER_LINKED_FILES ; 1418 # Master object file kept in other directory to avoid name conflict 1419 1420 MASTER_OBJECT_FILE_$(VARIANT) default = $(OBJECT_FILE_DIR_$(VARIANT))$(/)ProjectBuilderMasterObjectFile.o ; 1421 NonObjectFiles OTHER_LINKED_FILES : $(LINKED_FILES_$(VARIANT)) ; 1422 MasterObjectFile $(MASTER_OBJECT_FILE_$(VARIANT)) : $(OBJECT_FILES_$(VARIANT)) : $(EXPORTED_SYMBOLS_FILE) ; 1423 if $(OTHER_LINKED_FILES) = "" { 1424 OTHER_LINKED_FILES = $(MASTER_OBJECT_FILE_$(VARIANT)) ; 1425 } 1426 else { 1427 OTHER_LINKED_FILES += $(MASTER_OBJECT_FILE_$(VARIANT)) ; 1428 } 1429 if $(VECTOR_OBJECT_FILE) { 1430 OTHER_LINKED_FILES += $(VECTOR_OBJECT_FILE) ; 1431 } 1432 $(3) $(INNER_PRODUCT_$(VARIANT)) : $(OTHER_LINKED_FILES) ; 1433} 1434 1435# ProcessLinkWithArchitectureSpecificEditing <executable> : <inputs> : <rule> 1436rule ProcessLinkWithArchitectureSpecificEditing 1437{ 1438 for ARCH in $(ARCHS) { 1439 MASTER_OBJECT_FILE_$(ARCH)_$(VARIANT) default = $(OBJECT_FILE_DIR_$(VARIANT))$(/)ProjectBuilderMasterObjectFile$(ARCH).o ; 1440 MasterObjectFile $(MASTER_OBJECT_FILE_$(ARCH)_$(VARIANT)) : $(OBJECT_FILES_$(ARCH)_$(VARIANT)) : $(EXPORTED_SYMBOLS_FILE_$(ARCH)) ; 1441 } 1442 NonObjectFiles OTHER_LINKED_FILES : $(LINKED_FILES_$(VARIANT)) ; 1443 for ARCH in $(ARCHS) { 1444 if $(OTHER_LINKED_FILES) = "" { 1445 OTHER_LINKED_FILES = $(MASTER_OBJECT_FILE_$(ARCH)_$(VARIANT)) ; 1446 } 1447 else { 1448 OTHER_LINKED_FILES += $(MASTER_OBJECT_FILE_$(ARCH)_$(VARIANT)) ; 1449 } 1450 } 1451 if $(VECTOR_OBJECT_FILE) { 1452 OTHER_LINKED_FILES += $(VECTOR_OBJECT_FILE) ; 1453 } 1454 $(3) $(INNER_PRODUCT_$(VARIANT)) : $(OTHER_LINKED_FILES) ; 1455} 1456 1457# ProcessLink <executable> : <inputs> : <rule> 1458# Processes <inputs> into <rule>.ARGUMENTS for later use by the <rule> rule 1459# where <inputs> are object files, libraries, frameworks, object file lists, 1460# and such and where <rule> is one of StaticLibrary, DynamicLibrary, or 1461# StandaloneExecutable. 1462rule ProcessLink 1463{ 1464 local RULE = $(3) ; 1465 # Link as standalone executable unless another rule is specified 1466 RULE default = StandaloneExecutable ; 1467 # Set rule-specific flags such as StandaloneExecutable.FILELIST_FLAG 1468 # and store the values in local variables 1469 local FILELIST_FLAG = $($(RULE).FILELIST_FLAG:G=) ; 1470 local LIBRARY_FLAG = $($(RULE).LIBRARY_FLAG:G=) ; 1471 local FRAMEWORK_FLAG = $($(RULE).FRAMEWORK_FLAG:G=) ; 1472 local FILELIST_NOSPACE = $($(RULE).FILELIST_FLAG:G) ; 1473 local LIBRARY_NOSPACE = $($(RULE).LIBRARY_FLAG:G) ; 1474 local FRAMEWORK_NOSPACE = $($(RULE).FRAMEWORK_FLAG:G) ; 1475 local BATCH_OFILES = $($(RULE).BATCH_OFILES) ; 1476 # The product depends on all of the input files, although 1477 # library and framework references may not be resolvable. 1478 DEPENDS $(1) : $(2) ; 1479 # link depends on file list 1480 LINK_FILE_LIST_$(VARIANT) = $(FILE_LIST_$(VARIANT)) ; 1481 DEPENDS $(1) : $(LINK_FILE_LIST_$(VARIANT)) ; 1482 # Deal with each input file in turn 1483 local LINKED ; 1484 local ARGUMENT ; 1485 for LINKED in $(2) { 1486 $(RULE).FILES$(LINKED:S) on $(1) += $(LINKED) ; 1487 switch $(LINKED:BS) { 1488 case *.o : 1489 # If $(BATCH_OFILES) is true then object file lists are generated. 1490 if $(BATCH_OFILES) != NO { 1491 ClearFileList $(LINK_FILE_LIST_$(VARIANT)) ; 1492 AppendToFileList $(LINK_FILE_LIST_$(VARIANT)) : $(LINKED) ; 1493 DEPENDS $(LINK_FILE_LIST_$(VARIANT)) : $(LINKED) ; 1494 } else { 1495 $(RULE).ARGUMENTS on $(1) += $(LINKED) ; 1496 } 1497 case *.objects : 1498 if $(FILELIST_NOSPACE) { 1499 ARGUMENT = $(FILELIST_FLAG)$(LINKED) ; 1500 NOTFILE $(ARGUMENT) ; 1501 } else { 1502 NOTFILE $(FILELIST_FLAG) ; 1503 ARGUMENT = $(FILELIST_FLAG) $(LINKED) ; 1504 } 1505 $(RULE).ARGUMENTS on $(1) += $(ARGUMENT) ; 1506 case lib*.a : 1507 if $(LIBRARY_FLAG) { 1508 LINKED = $(LINKED:A) ; 1509 } 1510 NOCARE $(LINKED) ; 1511 if $(LIBRARY_NOSPACE) { 1512 ARGUMENT = $(LIBRARY_FLAG)$(LINKED) ; 1513 } else { 1514 ARGUMENT = $(LIBRARY_FLAG) $(LINKED) ; 1515 } 1516 $(RULE).ARGUMENTS on $(1) += $(ARGUMENT) ; 1517 NOTFILE $(ARGUMENT) ; 1518 case *.lib : 1519 NOCARE $(LINKED) ; 1520 if $(LIBRARY_FLAG) { 1521 if $(LIBRARY_NOSPACE) { 1522 ARGUMENT = $(LIBRARY_FLAG)$(LINKED:A) ; 1523 } else { 1524 ARGUMENT = $(LIBRARY_FLAG) $(LINKED:A) ; 1525 } 1526 $(RULE).ARGUMENTS on $(1) += $(ARGUMENT) ; 1527 NOTFILE $(ARGUMENT) ; 1528 } else { 1529 ECHO jam: warning: For target $(1), rule $(RULE) will ignore $(LINKED) ; 1530 } 1531 case *.dylib : 1532 NOCARE $(LINKED) ; 1533 if $(LIBRARY_FLAG) { 1534 if $(LIBRARY_NOSPACE) { 1535 ARGUMENT = $(LIBRARY_FLAG)$(LINKED:A) ; 1536 } else { 1537 ARGUMENT = $(LIBRARY_FLAG) $(LINKED:A) ; 1538 } 1539 $(RULE).ARGUMENTS on $(1) += $(ARGUMENT) ; 1540 NOTFILE $(ARGUMENT) ; 1541 } else { 1542 ECHO jam: warning: For target $(1), rule $(RULE) will ignore $(LINKED) ; 1543 } 1544 case *.framework : 1545 NOCARE $(LINKED) ; 1546 if $(FRAMEWORK_FLAG) { 1547 if $(FRAMEWORK_NOSPACE) { 1548 ARGUMENT = $(FRAMEWORK_FLAG)$(LINKED:B) ; 1549 } else { 1550 ARGUMENT = $(FRAMEWORK_FLAG) $(LINKED:B) ; 1551 } 1552 $(RULE).ARGUMENTS on $(1) += $(ARGUMENT) ; 1553 NOTFILE $(ARGUMENT) ; 1554 } else { 1555 ECHO jam: warning: For target $(1), rule $(RULE) will ignore $(LINKED) ; 1556 } 1557 case *.jar : 1558 # silently ignore Java archives since they are valid, but not used for native linking 1559 case *.zip : 1560 # silently ignore Java archives since they are valid, but not used for native linking 1561 case * : 1562 ECHO Warning: $(RULE): Unknown extension on "$(LINKED:BS)" when linking with $(RULE) ; 1563 } 1564 } 1565 # include any object files compiled from objc generated with bridget 1566 if $(BRIDGET_FILE_LIST) { 1567 AppendFileToFileList $(LINK_FILE_LIST_$(VARIANT)) : $(BRIDGET_FILE_LIST) ; 1568 } 1569 if $(BATCH_OFILES) != NO { 1570 $(RULE).LinkUsingFileList $(1) : $(LINK_FILE_LIST_$(VARIANT)) ; 1571 } 1572 else { 1573 $(RULE).Link $(1) ; 1574 } 1575} 1576 1577actions quietly together piecemeal ClearFileList 1578{ 1579 $(RM) -rf "$(1)" 1580} 1581 1582actions quietly together piecemeal AppendToFileList 1583{ 1584 for file_reference in "$(2)" 1585 do 1586 $(ECHO) "$file_reference" >> "$(1)" 1587 done 1588} 1589 1590actions quietly together piecemeal AppendFileToFileList 1591{ 1592 cat "$(2)" >> "$(1)" 1593} 1594 1595# StaticLibrary <library> : <inputs> 1596# Stores <inputs> in <library> where <inputs> are object files, 1597# libraries, frameworks, object file lists, and such 1598rule StaticLibrary 1599{ 1600 LIBRARY_SEARCH_PATHS on $(1) = $(LIBRARY_SEARCH_PATHS) ; 1601 ProcessLink $(1) : $(2) : StaticLibrary ; 1602 FLAGS.o on $(1) = $(LDFLAGS) $(SECTORDER_FLAGS) ; 1603} 1604actions together StaticLibrary 1605{ 1606} 1607actions quietly together piecemeal StaticLibrary.Link bind StaticLibrary.ARGUMENTS 1608{ 1609 ( $(LIBTOOL) -o "$(1)" "$(2)" "-L$(LIBRARY_SEARCH_PATHS)" "$(StaticLibrary.ARGUMENTS)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) && $(RANLIB) "$(1)" ) 1610} 1611actions quietly together piecemeal StaticLibrary.LinkUsingFileList bind StaticLibrary.ARGUMENTS 1612{ 1613 ( $(LIBTOOL) -o "$(1)" "-L$(LIBRARY_SEARCH_PATHS)" -filelist "$(2)" "$(StaticLibrary.ARGUMENTS)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) && $(RANLIB) "$(1)" ) 1614} 1615StaticLibrary.FRAMEWORK_FLAG = ; 1616StaticLibrary.LIBRARY_FLAG = ; 1617StaticLibrary.BATCH_OFILES default = YES ; 1618 1619# StandaloneExecutable <executable> : <inputs> 1620# Links <inputs> to produce <executable>, where <inputs> are objects, 1621# libraries, frameworks, and such. 1622rule StandaloneExecutable 1623{ 1624 ProcessLink $(1) : $(2) ; 1625 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 1626 LIBRARY_SEARCH_PATHS on $(1) = $(LIBRARY_SEARCH_PATHS) ; 1627 FLAGS.o on $(1) = $(ARCH_FLAGS) $(LDFLAGS) $(SECTORDER_FLAGS) ; 1628 if $(INIT_ROUTINE) { 1629 FLAGS.o on $(1) += -init $(INIT_ROUTINE) ; 1630 } 1631} 1632StandaloneExecutable.FILELIST_FLAG = -filelist ; 1633StandaloneExecutable.FRAMEWORK_FLAG = -framework ; 1634StandaloneExecutable.LIBRARY_FLAG = <nospace>-l ; 1635StandaloneExecutable.BATCH_OFILES default = YES ; 1636actions together StandaloneExecutable 1637{ 1638} 1639actions quietly together StandaloneExecutable.Link bind StandaloneExecutable.ARGUMENTS 1640{ 1641 $(_LD_FOR_LINKING) -o "$(1)" "-L$(LIBRARY_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) "$(StandaloneExecutable.ARGUMENTS)" 1642} 1643actions quietly together StandaloneExecutable.LinkUsingFileList bind StandaloneExecutable.ARGUMENTS 1644{ 1645 $(_LD_FOR_LINKING) -o "$(1)" "-L$(LIBRARY_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" -filelist "$(2)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) "$(StandaloneExecutable.ARGUMENTS)" 1646} 1647 1648 1649# DynamicLibrary <library> : <objects> : <libraries> 1650# Links <objects> and <libraries> to produce <library>, using $(FLAGS.o) 1651rule DynamicLibrary 1652{ 1653 LIBRARY_SEARCH_PATHS on $(1) = $(LIBRARY_SEARCH_PATHS) ; 1654 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 1655 ProcessLink $(1) : $(2) : DynamicLibrary ; 1656 FLAGS.o on $(1) = $(ARCH_FLAGS) $(LDFLAGS) $(SECTORDER_FLAGS) ; 1657 if $(INIT_ROUTINE) { 1658 FLAGS.o on $(1) += -init $(INIT_ROUTINE) ; 1659 } 1660} 1661actions together DynamicLibrary 1662{ 1663} 1664actions quietly together DynamicLibrary.Link bind DynamicLibrary.ARGUMENTS DynamicLibrary.DEFFILE 1665{ 1666 $(_LD_FOR_LINKING) -o "$(1)" $(DynamicLibrary.DEFFILE_FLAG)"$(DynamicLibrary.DEFFILE)" "-L$(LIBRARY_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" "$(DynamicLibrary.ARGUMENTS)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) 1667} 1668actions quietly together DynamicLibrary.LinkUsingFileList bind DynamicLibrary.ARGUMENTS DynamicLibrary.DEFFILE 1669{ 1670 $(_LD_FOR_LINKING) -o "$(1)" $(DynamicLibrary.DEFFILE_FLAG)"$(DynamicLibrary.DEFFILE)" "-L$(LIBRARY_SEARCH_PATHS)" "-F$(FRAMEWORK_SEARCH_PATHS)" -filelist "$(2)" "$(DynamicLibrary.ARGUMENTS)" "$(FLAGS.o)" $(INSTALLED_NAME_FLAG) 1671} 1672DynamicLibrary.DEFFILE_FLAG = "-Xlinker -DEF:" ; 1673DynamicLibrary.FILELIST_FLAG = -filelist ; 1674DynamicLibrary.FRAMEWORK_FLAG = -framework ; 1675DynamicLibrary.LIBRARY_FLAG = <nospace>-l ; 1676DynamicLibrary.BATCH_OFILES default = YES ; 1677 1678# MasterObjectFile <master object file> : <object files> : <exports file> : [<arch>] 1679# Merges many object files into one in order to edit 1680# the list of exported symbols 1681rule MasterObjectFile 1682{ 1683 local OBJECT_FILE ; 1684 if $(4) { 1685 LINK_FILE_LIST_$(VARIANT) = $(FILE_LIST_$(VARIANT))Prelink_$(4) ; 1686 } 1687 else { 1688 LINK_FILE_LIST_$(VARIANT) = $(FILE_LIST_$(VARIANT))Prelink ; 1689 } 1690 # object files must be present before master can be assembled 1691 DEPENDS $(1) : $(2) ; 1692 # list object files in a file to limit link line length 1693 DEPENDS $(1) : $(LINK_FILE_LIST_$(VARIANT)) ; 1694 ClearFileList $(LINK_FILE_LIST_$(VARIANT)) ; 1695 for LINKED in $(2) { 1696 AppendToFileList $(LINK_FILE_LIST_$(VARIANT)) : $(LINKED) ; 1697 DEPENDS $(LINK_FILE_LIST_$(VARIANT)) : $(LINKED) ; 1698 } 1699 if $(KEEP_PRIVATE_EXTERNS) != NO { 1700 KEEP_PRIVATE_EXTERNS_FLAG on $(1) = -keep_private_externs ; 1701 } 1702 if $(GLUE_FILE_LIST) { 1703 DEPENDS $(LINK_FILE_LIST_$(VARIANT)) : $(GLUE_FILE_LIST) ; 1704 AppendFileToFileList $(LINK_FILE_LIST_$(VARIANT)) : $(GLUE_FILE_LIST) ; 1705 } 1706 PRELINK_FLAGS on $(1) = $(PRELINK_FLAGS) ; 1707 PRELINK_LIBS on $(1) = $(PRELINK_LIBS) ; 1708 if $(_BUILD_PHASING) = YES { 1709 BUILD_PHASE_PRODUCTS += $(1) ; 1710 } 1711 MasterObjectFile.Combine $(1) : $(LINK_FILE_LIST_$(VARIANT)) ; 1712 if $(3) { 1713 INCLUDES $(1) : $(3) ; 1714 MasterObjectFile.EditExports $(1) : $(3) ; 1715 } 1716} 1717actions MasterObjectFile.Combine 1718{ 1719 $(_LD_FOR_LINKING) $(ARCH_FLAGS) $(KEEP_PRIVATE_EXTERNS_FLAG) $(GLOBAL_CFLAGS) "$(PRELINK_FLAGS)" -nostdlib -filelist "$(2)" -r -o "$(1)" "$(PRELINK_LIBS)" 1720} 1721actions MasterObjectFile.EditExports 1722{ 1723 $(NMEDIT) -s "$(2)" "$(1)" -o "$(1)" 1724} 1725 1726# Ranlib <library> 1727# Ranlib for static library 1728actions Ranlib 1729{ 1730 $(RANLIB) "$(1)" 1731} 1732 1733# VersioningSystem_next-cvs <product> 1734# Handles automatic generation of CVSVersionInfo.txt file for projects that use NeXT CVS-style versioning. 1735rule VersioningSystem_next-cvs 1736{ 1737 local VERSION_INFO_FILE ; 1738 VERSION_INFO_FILE default = $(1:B)_vers.c ; 1739 # Make sure that the C file containing the version string gets created. 1740 VersioningSystem_next-cvs.Create $(VERSION_INFO_FILE) : $(1:B) ; 1741 DerivedFiles $(VERSION_INFO_FILE) ; 1742 SUPPRESS_PREFIX_HEADER = YES ; 1743 ProcessFile $(1) : $(VERSION_INFO_FILE) ; 1744 SUPPRESS_PREFIX_HEADER = NO ; 1745 1746 # Set up default values for the variables. 1747 CVS_VERS_FILE default = CVSVersionInfo.txt ; 1748} 1749rule VersioningSystem_next-cvs.Create 1750{ 1751 DEPENDS $(1) : $(CVS_VERS_FILE) ; 1752} 1753actions VersioningSystem_next-cvs.Create 1754{ 1755 versFile="$(CVS_VERS_FILE)" 1756 awk=/usr/bin/awk 1757 user=`$awk '/\\$\Id:/ {print $7;}' $versFile` 1758 timestamp=`$awk '/\\$\Id:/ {print $5 " " $6;}' $versFile` 1759 fileVers=`$awk '/\\$\Id:/ {print $4;}' $versFile` 1760 name=`$awk '/^ProjectName:/ {print $2;}' $versFile` 1761 tag=`$awk '/\\$\Name:/ {print $3;}' $versFile` 1762 versNum=`$awk '/^ProjectVersion:/ {print $2;}' $versFile` 1763 proj="$(2:B)" 1764 clean_proj_name=`echo $proj | sed 's/[^0-9A-Za-z]/_/g'` 1765 # the keyword name is the current tag and only gets filled in if the files are extracted at 1766 # that tag. If the tag has a value, then it is a released version, if the tag is '$' then 1767 # it has no value and is a development version. 1768 case $tag in '$') vers="$versNum.dev";; *) vers=$versNum;; esac 1769 q='"' 1770 vers_str="Project:$proj Version:$vers (Checkpoint by:$user on:$timestamp revision:$fileVers)" 1771 vers_suffix="$(CURRENT_PROJECT_VERSION_SUFFIX)" 1772 echo "const char "$clean_proj_name"_VERS_STRING[] = $q@(#)$vers_str$q;" > "$(1)" 1773 echo "const char "$clean_proj_name"_VERS_NUM[] = $q$vers$vers_suffix$q;" >> "$(1)" 1774} 1775 1776# VersioningSystem_apple-generic <product> 1777# Generates <product>_vers.c to define version symbol 1778rule VersioningSystem_apple-generic 1779{ 1780 # Set values to use 1781 local VERSION_INFO_FILE ; 1782 VERSION_INFO_FILE default = $(1:B)_vers.c ; 1783 1784 # variables used need to be defined on the version info file target 1785 CURRENT_PROJECT_VERSION on $(VERSION_INFO_FILE) = $(CURRENT_PROJECT_VERSION) ; 1786 VERSION_INFO_EXPORT_DECL on $(VERSION_INFO_FILE) default = $(VERSION_INFO_EXPORT_DECL) ; 1787 VERSION_INFO_PREFIX on $(VERSION_INFO_FILE) default = $(VERSION_INFO_PREFIX) ; 1788 VERSION_INFO_SUFFIX on $(VERSION_INFO_FILE) default = $(VERSION_INFO_SUFFIX) ; 1789 VERSION_INFO_BUILDER on $(VERSION_INFO_FILE) default = $(USER) ; 1790 1791 # Create versioning code 1792 VersioningSystem_apple-generic.Create $(VERSION_INFO_FILE) : $(1) ; 1793 DerivedFiles $(VERSION_INFO_FILE) ; 1794 SUPPRESS_PREFIX_HEADER = YES ; 1795 ProcessFile $(1) : $(VERSION_INFO_FILE) ; 1796 SUPPRESS_PREFIX_HEADER = NO ; 1797} 1798actions VersioningSystem_apple-generic.Create 1799{ 1800 raw_project_name="$(PROJECT)" 1801 project_name=`echo $raw_project_name | sed 's/[^0-9A-Za-z]/_/g'` 1802 raw_target_name="$(2:B)" 1803 target_name=`echo $raw_target_name | sed 's/[^0-9A-Za-z]/_/g'` 1804 project_vers="$(CURRENT_PROJECT_VERSION)" 1805 vers_info_export_decl="$(VERSION_INFO_EXPORT_DECL)" 1806 vers_info_prefix="$(VERSION_INFO_PREFIX)" 1807 vers_info_suffix="$(VERSION_INFO_SUFFIX)" 1808 vers_info_builder="$(VERSION_INFO_BUILDER)" 1809 echo ${vers_info_export_decl} " const unsigned char ${vers_info_prefix}${target_name}VersionString${vers_info_suffix}[] = \"@(#)PROGRAM:${target_name} PROJECT:${project_name}-${project_vers} DEVELOPER:${vers_info_builder} BUILT:\" __DATE__ \" \" __TIME__ \"\n\";" > "$(1)" 1810 echo ${vers_info_export_decl} " const double ${vers_info_prefix}${target_name}VersionNumber${vers_info_suffix} = (double)${project_vers};" >> "$(1)" 1811} 1812 1813# KernelModuleGeneratedSource 1814# Creates a kernel module source stub based on the values 1815# of MODULE_VERSION, MODULE_START, and MODULE_STOP 1816rule KernelModuleGeneratedSource 1817{ 1818 MODULE_INFO_FILE_$(VARIANT) default = $(1:B)_info.c ; 1819 DerivedFiles $(MODULE_INFO_FILE_$(VARIANT)) ; 1820 DEPENDS $(MODULE_INFO_FILE_$(VARIANT)) : $(MODULE_INFO_PLIST) ; 1821 MODULE_VERSION on $(MODULE_INFO_FILE_$(VARIANT)) = $(MODULE_VERSION) ; 1822 MODULE_NAME on $(MODULE_INFO_FILE_$(VARIANT)) = $(MODULE_NAME) ; 1823 if $(MODULE_IOKIT) = "YES" { 1824 MODULE_START on $(MODULE_INFO_FILE_$(VARIANT)) = 0 ; 1825 MODULE_STOP on $(MODULE_INFO_FILE_$(VARIANT)) = 0 ; 1826 } 1827 else { 1828 if $(MODULE_START) = "" { 1829 MODULE_START on $(MODULE_INFO_FILE_$(VARIANT)) = 0 ; 1830 } else { 1831 MODULE_START on $(MODULE_INFO_FILE_$(VARIANT)) = $(MODULE_START) ; 1832 } 1833 if $(MODULE_STOP) = "" { 1834 MODULE_STOP on $(MODULE_INFO_FILE_$(VARIANT)) = 0 ; 1835 } else { 1836 MODULE_STOP on $(MODULE_INFO_FILE_$(VARIANT)) = $(MODULE_STOP) ; 1837 } 1838 } 1839 KernelModuleGeneratedSource.Create $(MODULE_INFO_FILE_$(VARIANT)) ; 1840 SUPPRESS_PREFIX_HEADER = YES ; 1841 ProcessFile $(1) : $(MODULE_INFO_FILE_$(VARIANT)) ; 1842 SUPPRESS_PREFIX_HEADER = NO ; 1843} 1844actions KernelModuleGeneratedSource.Create 1845{ 1846 /bin/echo "#include <mach/mach_types.h>" > "$(1)" 1847 /bin/echo " " >> "$(1)" 1848 /bin/echo "extern kern_return_t _start(kmod_info_t *ki, void *data);" >> "$(1)" 1849 /bin/echo "extern kern_return_t _stop(kmod_info_t *ki, void *data);" >> "$(1)" 1850 if [ $(MODULE_START) != 0 ]; then 1851 /bin/echo "__private_extern__ kern_return_t $(MODULE_START)(kmod_info_t *ki, void *data);" >> "$(1)" 1852 fi 1853 if [ $(MODULE_STOP) != 0 ]; then 1854 /bin/echo "__private_extern__ kern_return_t $(MODULE_STOP)(kmod_info_t *ki, void *data);" >> "$(1)" 1855 fi 1856 /bin/echo " " >> "$(1)" 1857 /bin/echo "KMOD_EXPLICIT_DECL($(MODULE_NAME), \"$(MODULE_VERSION)\", _start, _stop)" >> "$(1)" 1858 /bin/echo "__private_extern__ kmod_start_func_t *_realmain = $(MODULE_START);" >> "$(1)" 1859 /bin/echo "__private_extern__ kmod_stop_func_t *_antimain = $(MODULE_STOP);" >> "$(1)" 1860 /bin/echo "__private_extern__ int _kext_apple_cc = __APPLE_CC__ ;" >> "$(1)" 1861} 1862 1863# GenerateFrameworkStub <framework stub> 1864# Invokes a custom tool to generate a Mach-O framework executable stub at the specified path 1865# Also be sure to the FRAMEWORK_INSTALL_NAME variable on the <framework stub> 1866actions GenerateFrameworkStub 1867{ 1868 $(MKDIR:Q) -p $(DERIVED_FILE_DIR:Q) 1869 dummy_class_name=`echo -n $(1:B) | tr -c '[:alnum:]' '_'` 1870 $(ECHO:Q) "@interface NSFramework_${dummy_class_name}" > $(DERIVED_FILE_DIR:Q)/framework_stub.m 1871 $(ECHO:Q) "@end" >> $(DERIVED_FILE_DIR:Q)/framework_stub.m 1872 $(ECHO:Q) "@implementation NSFramework_${dummy_class_name}" >> $(DERIVED_FILE_DIR:Q)/framework_stub.m 1873 $(ECHO:Q) "@end" >> $(DERIVED_FILE_DIR:Q)/framework_stub.m 1874 $(CC:Q) -c $(DERIVED_FILE_DIR:Q)/framework_stub.m -o $(DERIVED_FILE_DIR:Q)/framework_stub.o 1875 $(_LD_FOR_LINKING:Q) -dynamiclib $(INSTALLED_NAME_FLAG) $(DYLIB_VERSION_FLAGS:Q) -L$(LIBRARY_SEARCH_PATHS:Q) -F$(FRAMEWORK_SEARCH_PATHS:Q) $(DynamicLibrary.ARGUMENTS:Q) $(DERIVED_FILE_DIR:Q)/framework_stub.o -o $(1:Q) 1876 $(STRIP:Q) $(STRIPFLAGS:Q) $(1:Q) 1877} 1878# Copyright (c) 1999-2002 Apple Computer, Inc. 1879# All rights reserved. 1880 1881# Define reasonable base locations, to be overridden by default 1882 1883# Build intermediates go into TEMP_ROOT which defaults to 1884# build/intermediates in current directory, or OBJROOT if defined 1885TEMP_ROOT default = $(OBJROOT) ; 1886 1887# Builds go into the BUILD_ROOT which defaults to 1888# build/products in current directory, or SYMROOT if defined 1889BUILD_ROOT default = $(SYMROOT) ; 1890 1891# Installation root defaults to root, or DSTROOT if defined 1892INSTALL_ROOT default = $(DSTROOT) ; 1893 1894# Set initial values for installation information and framework version 1895_BUILD_PHASING default = YES ; 1896export INSTALL_OWNER default = $(USER) ; 1897export INSTALL_GROUP default = $(GROUP) ; 1898export INSTALL_MODE_FLAG default = "ugo-w,o+rX" ; 1899export FRAMEWORK_VERSION default = "A" ; 1900REMOVE_CVS_FROM_RESOURCES default = YES ; 1901COPY_PHASE_STRIP default = NO ; 1902PREBINDING default = YES ; 1903SET_DIR_MODE_OWNER_GROUP default = YES ; 1904SET_FILE_MODE_OWNER_GROUP default = NO ; 1905 1906# Set initial optimization level, debug, and profile settings 1907export OPTIMIZATION_LEVEL default = 0 ; 1908export DEBUGGING_SYMBOLS default = YES ; 1909export PROFILING_CODE default = NO ; 1910 1911# Default settings for Java builds 1912JAVA_ARCHIVE_CLASSES default = YES ; 1913JAVA_ARCHIVE_TYPE default = JAR ; 1914JAVA_APP_STUB default = /System/Library/Frameworks/JavaVM.framework/Resources/MacOS/JavaApplicationStub ; 1915JAVA_JAR_FLAGS default = cv ; 1916JAVA_SOURCE_SUBDIR default = . ; 1917JAVA_FRAMEWORK_RESOURCES_DIRS default = Resources ; 1918export JAVA_FRAMEWORK_JARS default = ; 1919JAVA_USE_DEPENDENCIES default = YES ; 1920JAVA_ZIP_FLAGS default = -urg ; 1921 1922JAVA_COMPILER_DEBUGGING_SYMBOLS default = YES ; 1923JAVA_COMPILER_DISABLE_WARNINGS default = NO ; 1924JAVA_COMPILER_DEPRECATED_WARNINGS default = NO ; 1925 1926# These default flags probably shouldn't be overridden by users. 1927JAVAC_DEFAULT_FLAGS default = -J-Xms64m -J-XX:NewSize=4M -J-Dfile.encoding=UTF8 ; 1928JIKES_DEFAULT_FLAGS default = +E +OLDCSO ; 1929 1930# Default variants and flags 1931# !!!:cmolick:20020226 using all three is an interesting test case 1932# BUILD_VARIANTS default = normal debug profile ; 1933BUILD_VARIANTS default = normal ; 1934_BUILD_PHASES = ; 1935cc_normal_FLAGS default = ; 1936cc_debug_FLAGS default = -g ; 1937cc_profile_FLAGS default = -pg ; 1938 1939# !!!:cmolick:20020109 Installed product asides on by default for debugging 1940#INSTALLED_PRODUCT_ASIDES default = YES ; 1941 1942# BeginProduct <product> 1943# 1944# Initializes the directory and file list variables 1945# 1946# Variable references: 1947# BUILD_ROOT Base directory for builds 1948# TARGET_NAME Name of the target that builds this product 1949# PRODUCT_NAME Name of the product that's built 1950# TEMP_ROOT Base directory for intermediates 1951# BASE_PROJECT_HEADER_DIR Base directory for project headers 1952# HEADER_SUBDIRECTORY Path prefix in header #include lines 1953# INSTALL_ROOT Base directory for installations 1954# INSTALL_PATH Subdirectory where product is installed 1955# PUBLIC_HEADER_DIR Location for public headers 1956# 1957# Variables set: 1958# HEADER_SUBDIRECTORY Base product name 1959# BUILD_COMPONENTS List may include: headers, build, source 1960# OPTIMIZATION_CFLAGS Optimization flags for C compiles 1961# OTHER_CPLUSPLUSFLAGS C++ flags default to C values 1962# WARNING_CPLUSPLUSFLAGS 1963# INCLUDED_ARCHS Architectures intended for this build 1964# NATIVE_ARCH Architecture of the build machine 1965# ARCHS Architectures used for this build 1966# ARCH_FLAGS Architecture flags used for most tools 1967# SOURCE_DIR 1968# BUILD_DIR Target-specific directory for builds 1969# TEMP_DIR For target-specific intermediates 1970# BASE_PROJECT_HEADER_DIR Location for header clone folders 1971# PROJECT_HEADER_DIR Project header file directory in $(TEMP_DIR) 1972# OBJECT_FILE_DIR Object file directory in $(TEMP_DIR) 1973# CLASS_FILE_DIR Class file directory in $(TEMP_DIR) 1974# FILE_LIST Base name for lists of files generated 1975# DERIVED_FILE_DIR Derived source directory in $(TEMP_DIR) 1976# INSTALL_DIR Directory in $(INSTALL_ROOT) for installations 1977# HEADER_SEARCH_PATHS Project header directories prepended 1978# FRAMEWORK_SEARCH_PATHS Product build root appended 1979# DERIVED_FILES Initialized empty 1980# OBJECT_FILES Initialized empty 1981# LINKED_FILES Initialized empty 1982# PRODUCT_FILES Initialized empty 1983# PRECOMP_TRUSTFILE List of trusted precompiled headers 1984# 1985rule BeginProduct 1986{ 1987 # target representing the build must be a nonfile pseudotarget 1988 NOTFILE $(1) ; 1989 1990 # define the header subdirectory early since we'll use it to 1991 # compute the project header directory 1992 HEADER_SUBDIRECTORY = $(1:B) ; 1993 1994 # the following sequence of tests sets up CC, CPLUSPLUS, LD, and LDPLUSPLUS appropriately, 1995 # depending on whether we're using GCC 2.95.2 or GCC 3.x (either explicitly or implicitly) 1996 1997 # hack to detect attempt to use GCC 3, and to set the 'USE_GCC3' build setting accordingly 1998 if ( $(CC) = "/usr/bin/gcc3" ) { 1999 USE_GCC3 default = YES ; 2000 } 2001 # if USE_GCC2 has not been explicitly set to YES, and if the default compiler (as detected 2002 # by pbxbuild) is GCC 3, we set USE_GCC3 to YES so the rest of the logic knows it can do 2003 # GCC 3 specific stuff 2004 if ( $(USE_GCC2) != YES ) && ( $(_DEFAULT_GCC_VERSION) != "" ) && ( $(_DEFAULT_GCC_VERSION) != "2.95.2" ) { 2005 USE_GCC3 default = YES ; 2006 } 2007 2008 # set up CC, CPLUSPLUS, LD, and LDPLUSPLUS appropriately (this logic is temporary, and is 2009 # expected to be phased out once we have per-build-phase compiler choices) 2010 if $(USE_GCC3) = YES { 2011 CC default = /usr/bin/gcc3 ; 2012 CPLUSPLUS default = /usr/bin/g++3 ; 2013 # for GCC 3, we use -precomp support (as opposed to PFE support) by default for now 2014 USE_GCC3_PFE_SUPPORT default = NO ; 2015 } 2016 else if $(USE_GCC2) = YES { 2017 if $(_DEFAULT_GCC_VERSION) = "2.95.2" { 2018 CC default = /usr/bin/cc ; 2019 CPLUSPLUS default = /usr/bin/c++ ; 2020 } 2021 else { 2022 CC default = /usr/bin/gcc2 ; 2023 CPLUSPLUS default = /usr/bin/g++2 ; 2024 } 2025 } 2026 else { 2027 CC default = /usr/bin/cc ; 2028 CPLUSPLUS default = /usr/bin/c++ ; 2029 } 2030 LD default = $(CC) ; 2031 LDPLUSPLUS default = $(CPLUSPLUS) ; 2032 _LD_FOR_LINKING = $(LD) ; # this might get reset to $(LDPLUSPLUS) in the CompileCplusplus rule 2033 2034 # Variant suffixes 2035 for VARIANT in $(BUILD_VARIANTS) { 2036 if $(VARIANT) = normal { 2037 VARIANT_SUFFIX_$(VARIANT) = "" ; 2038 } 2039 else { 2040 VARIANT_SUFFIX_$(VARIANT) = _$(VARIANT) ; 2041 } 2042 } 2043 # Set reasonable optimization flags for installs if not already set 2044 OPTIMIZATION_CFLAGS default = -Os ; 2045 # C++ options match C options by default 2046 OTHER_CPLUSPLUSFLAGS default = $(OTHER_CFLAGS) ; 2047 WARNING_CPLUSPLUSFLAGS default = $(WARNING_CFLAGS) ; 2048 # Set up architecture options for product 2049 INCLUDED_ARCHS default = $(SUPPORTED_ARCHITECTURES) ; 2050 SUPPORTED_ARCHITECTURE_FLAGS = ; 2051 ARCHS = ; 2052 if ! $(RC_ARCHS) { 2053 $(NATIVE_ARCH) = YES ; 2054 RC_$(NATIVE_ARCH) = YES ; 2055 } 2056 for SUPPORTED_ARCHITECTURE in $(SUPPORTED_ARCHITECTURES) { 2057 if $($(SUPPORTED_ARCHITECTURE)) = YES 2058 && ( $(SUPPORTED_ARCHITECTURE) in $(INCLUDED_ARCHS) ) 2059 && ( $(SUPPORTED_ARCHITECTURE) in $(VALID_ARCHS) ) { 2060 SUPPORTED_ARCHITECTURE_FLAGS += -arch $(SUPPORTED_ARCHITECTURE) ; 2061 ARCHS += $(SUPPORTED_ARCHITECTURE) ; 2062 } 2063 } 2064 ARCH_FLAGS default = $(SUPPORTED_ARCHITECTURE_FLAGS) ; 2065 # Initialize the directory variables 2066 # SOURCE_DIR is the location of installed sources 2067 SOURCE_DIR default = $(INSTALL_ROOT) ; 2068 BUILD_DIR default = $(BUILD_ROOT) ; 2069 # create base build dir 2070 Mkdir $(BUILD_DIR) ; 2071 ProductFile $(BUILD_DIR) ; 2072 # create active build dir 2073 if $(TARGET_BUILD_DIR) && ($(TARGET_BUILD_DIR) != $(BUILD_DIR)) { 2074 Mkdir $(TARGET_BUILD_DIR) ; 2075 } 2076 # asides 2077 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 2078 ASIDE_DIR default = $(BUILD_ROOT) ; 2079 Mkdir $(ASIDE_DIR) ; 2080 ProductFile $(ASIDE_DIR) ; 2081 } 2082 # define other important locations 2083 TEMP_DIR default = $(TEMP_ROOT)$(/)$(PROJECT_NAME).build$(/)$(TARGET_NAME).build ; 2084 if $(CLONE_HEADERS) = YES { 2085 if $(HEADER_SUBDIRECTORY) { 2086 PROJECT_HEADER_DIR default = $(BASE_PROJECT_HEADER_DIR)$(/)$(HEADER_SUBDIRECTORY) ; 2087 } 2088 else { 2089 PROJECT_HEADER_DIR default = $(BASE_PROJECT_HEADER_DIR) ; 2090 } 2091 } 2092 OBJECT_FILE_DIR default = $(TEMP_DIR)$(/)Objects ; 2093 export CLASS_FILE_DIR default = $(TEMP_DIR)$(/)JavaClasses ; 2094 for VARIANT in $(BUILD_VARIANTS) { 2095 OBJECT_FILE_DIR_$(VARIANT) default = $(OBJECT_FILE_DIR)-$(VARIANT) ; 2096 FILE_LIST_$(VARIANT) default = $(OBJECT_FILE_DIR_$(VARIANT))$(/)LinkFileList ; 2097 # initialize file lists 2098 OBJECT_FILES_$(VARIANT) = ; 2099 LINKED_FILES_$(VARIANT) = ; 2100 } 2101 if $(JAVA_ARCHIVE_CLASSES) != YES && ( $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Library ) { 2102 export PRODUCT_CLASS_FILE_DIR default = $(TARGET_BUILD_DIR)$(/)$(PRODUCT_NAME) ; 2103 } 2104 DERIVED_FILE_DIR default = $(TEMP_DIR)$(/)DerivedSources ; 2105 if $(INSTALL_PATH) { 2106 INSTALL_DIR default = $(INSTALL_ROOT)$(/)$(INSTALL_PATH) ; 2107 } 2108 else { 2109 INSTALL_DIR default = $(INSTALL_ROOT) ; 2110 } 2111 # Initialize the search paths 2112 if $(CLONE_HEADERS) = YES { 2113 if $(TARGET_BUILD_DIR) != $(BUILD_DIR) { 2114 HEADER_SEARCH_PATHS = $(PROJECT_HEADER_DIR) $(TARGET_BUILD_DIR)$(/)include $(BUILD_DIR)$(/)include $(HEADER_SEARCH_PATHS) ; 2115 } 2116 else { 2117 HEADER_SEARCH_PATHS = $(PROJECT_HEADER_DIR) $(BUILD_DIR)$(/)include $(HEADER_SEARCH_PATHS) ; 2118 } 2119 FRAMEWORK_SEARCH_PATHS = $(BASE_PROJECT_HEADER_DIR) $(BUILD_ROOT) $(INSTALL_DIR) $(FRAMEWORK_SEARCH_PATHS) ; 2120 } 2121 else { 2122 if $(TARGET_BUILD_DIR) != $(BUILD_DIR) { 2123 HEADER_SEARCH_PATHS = $(TARGET_BUILD_DIR)$(/)include $(BUILD_DIR)$(/)include $(HEADER_SEARCH_PATHS) ; 2124 } 2125 else { 2126 HEADER_SEARCH_PATHS = $(BUILD_DIR)$(/)include $(HEADER_SEARCH_PATHS) ; 2127 } 2128 FRAMEWORK_SEARCH_PATHS = $(BUILD_ROOT) $(FRAMEWORK_SEARCH_PATHS) ; 2129 } 2130 LIBRARY_SEARCH_PATHS = $(BUILD_ROOT) $(LIBRARY_SEARCH_PATHS) ; 2131 if $(DEPLOYMENT_LOCATION) = YES && $(BUILT_PRODUCTS_DIR) { 2132 HEADER_SEARCH_PATHS = $(BUILT_PRODUCTS_DIR)$(/)include $(HEADER_SEARCH_PATHS) ; 2133 FRAMEWORK_SEARCH_PATHS = $(BUILT_PRODUCTS_DIR) $(FRAMEWORK_SEARCH_PATHS) ; 2134 LIBRARY_SEARCH_PATHS = $(BUILT_PRODUCTS_DIR) $(LIBRARY_SEARCH_PATHS) ; 2135 } 2136 # Initialize the file lists 2137 DERIVED_FILES = ; 2138 PRODUCT_FILES = ; 2139 PRECOMP_TRUSTFILE default = $(TEMP_DIR)$(/)TrustedPrecomps.txt ; 2140 # Make symlink to product in products dir, 2141 # and also set product mode and ownership 2142 # unless there is no nonempty product name. 2143 if $(DEPLOYMENT_LOCATION) = YES { 2144 if $(WRAPPER) 2145 && $(PRODUCT_TYPE) != Tool 2146 && $(PRODUCT_TYPE) != Library { 2147 # Use WRAPPER when defined for bundle product 2148 _INSTALLED_PRODUCT = $(TARGET_BUILD_DIR)$(/)$(WRAPPER) ; 2149 _PRODUCT_REFERENCE default = $(BUILT_PRODUCTS_DIR:G=ProductRef)$(/)$(WRAPPER) ; 2150 #!!!:cmolick:20020517:this may be bad for non-deployment location 2151 if $(DEPLOYMENT_POSTPROCESSING) = YES { 2152 SetModeOwnerAndGroup $(_INSTALLED_PRODUCT:G=ModeOwnerGroup) : $(_INSTALLED_PRODUCT) ; 2153 } 2154 SymLink $(_PRODUCT_REFERENCE) : $(_INSTALLED_PRODUCT) ; 2155 DEPENDS $(_PRODUCT_REFERENCE) : $(BUILT_PRODUCTS_DIR) ; 2156 DEPENDS $(1) : $(_PRODUCT_REFERENCE) ; 2157 } 2158 else { 2159 if $(1:G=) { 2160 # Use nonempty, ungristed primary target for tool or library product 2161 _INSTALLED_PRODUCT = $(TARGET_BUILD_DIR)$(/)$(1:G=) ; 2162 _PRODUCT_REFERENCE default = $(BUILT_PRODUCTS_DIR:G=ProductRef)$(/)$(1:G=) ; 2163 SymLink $(_PRODUCT_REFERENCE) : $(_INSTALLED_PRODUCT) ; 2164 DEPENDS $(_PRODUCT_REFERENCE) : $(BUILT_PRODUCTS_DIR) ; 2165 DEPENDS $(1) : $(_PRODUCT_REFERENCE) ; 2166 } 2167 } 2168 } 2169 # Run the hack script to build debug and profile variants, if appropriate. 2170 if $(INTERNAL_BUILD_VARIANTS) 2171 && ( $(RC_JASPER) || $(INTERNAL_BUILD_VARIANTS_ONLY_IN_JASPER) != YES ) 2172 && ( $(ACTION) = build || $(ACTION) = install ) { 2173 # build variants list should be used only by this call in this case 2174 _INTERNAL_BUILD_VARIANTS = $(INTERNAL_BUILD_VARIANTS) ; 2175 INTERNAL_BUILD_VARIANTS = ; 2176 INTERNAL_BUILD_VARIANTS on $(1) = $(_INTERNAL_BUILD_VARIANTS) ; 2177 RunVariantHackScript $(1) ; 2178 } 2179} 2180 2181# EndProduct <product> 2182# 2183# Creates BUILD_DIR, OBJECT_FILE_DIR, CLASS_FILE_DIR, DERIVED_FILE_DIR, 2184# and the PROJECT_HEADER_DIR if necessary, then sets up the build action. 2185rule EndProduct 2186{ 2187 # Create required directories. This is done here to allow 2188 # variables to be overridden before this rule is evaluated. 2189 if $(CLONE_HEADERS) = YES && $(PROJECT_HEADER_DIR) { 2190 Mkdir $(PROJECT_HEADER_DIR) ; 2191 PRODUCT_FILES += $(PROJECT_HEADER_DIR) ; 2192 DEPENDS $(1) : $(PROJECT_HEADER_DIR) ; 2193 } 2194 for VARIANT in $(BUILD_VARIANTS) { 2195 Mkdir $(OBJECT_FILE_DIR_$(VARIANT)) ; 2196 PRODUCT_FILES += $(OBJECT_FILE_DIR_$(VARIANT)) ; 2197 DEPENDS $(1) : $(OBJECT_FILE_DIR_$(VARIANT)) ; 2198 } 2199 if $(DEPLOYMENT_LOCATION) { 2200 Mkdir $(BUILT_PRODUCTS_DIR) ; 2201 PRODUCT_FILES += $(BUILT_PRODUCTS_DIR) ; 2202 DEPENDS $(1) : $(BUILT_PRODUCTS_DIR) ; 2203 } 2204 Mkdir $(CLASS_FILE_DIR) ; 2205 PRODUCT_FILES += $(CLASS_FILE_DIR) ; 2206 DEPENDS $(1) : $(CLASS_FILE_DIR) ; 2207 Mkdir $(DERIVED_FILE_DIR) ; 2208 PRODUCT_FILES += $(DERIVED_FILE_DIR) ; 2209 DEPENDS $(1) : $(DERIVED_FILE_DIR) ; 2210 # Set up post-phase processing 2211 if $(POST_PHASE_PRODUCTS) { 2212 DEPENDS $(1) : $(POST_PHASE_PRODUCTS) ; 2213 DEPENDS $(POST_PHASE_PRODUCTS) : $(_BUILD_PHASES) ; 2214 } 2215 # Alternative catch-all mechanism to set mode and ownership of files 2216 # that for some reason require this post build processing. 2217 if $(ACTION) = install { 2218 for ALTERNATE_PERMISSIONS_FILE in $(ALTERNATE_PERMISSIONS_FILES) { 2219 ALTERNATE_PERMISSIONS_FILE_PATH = $(INSTALL_DIR)$(/)$(ALTERNATE_PERMISSIONS_FILE) ; 2220 ALTERNATE_PERMISSIONS_TARGET = $(ALTERNATE_PERMISSIONS_FILE:G=AlternatePermissions) ; 2221 NOTFILE $(ALTERNATE_PERMISSIONS_TARGET) ; 2222 DEPENDS $(1) : $(ALTERNATE_PERMISSIONS_TARGET) ; 2223 DEPENDS $(ALTERNATE_PERMISSIONS_TARGET) : $(_BUILD_PHASES) ; 2224 if $(ALTERNATE_MODE) { 2225 INSTALL_MODE_FLAG on $(ALTERNATE_PERMISSIONS_TARGET) = $(ALTERNATE_MODE) ; 2226 } 2227 if $(ALTERNATE_OWNER) { 2228 INSTALL_OWNER on $(ALTERNATE_PERMISSIONS_TARGET) = $(ALTERNATE_OWNER) ; 2229 } 2230 if $(ALTERNATE_GROUP) { 2231 INSTALL_GROUP on $(ALTERNATE_PERMISSIONS_TARGET) = $(ALTERNATE_GROUP) ; 2232 } 2233 SetModeOwnerAndGroup $(ALTERNATE_PERMISSIONS_TARGET) : $(ALTERNATE_PERMISSIONS_FILE_PATH) ; 2234 } 2235 } 2236 # Define actions for this target 2237 Actions $(1) ; 2238} 2239 2240# BeginWrappedProduct <product> 2241# 2242# Sets additional variables required for wrapped products, 2243# primarily to assign locations within the product wrapper. 2244# WRAPPER Local convenience variable 2245# WRAPPER_SUFFIX Based on WRAPPER_EXTENSION by default 2246# RESOURCE_DIR Base bundle resources location 2247# APPLESCRIPTS_DIR Compiled AppleScript files folder 2248# [PUBLIC|PRIVATE]_HEADER_[CLONE_][DIR|LINK|LINK_PATH] Header folders 2249# WRAPPER_CLONE_DIR Base location for header clone framework 2250# CURRENT_VERSION[_CLONE]_[DIR|LINK|LINK_PATH] 2251# HEADERDOC_DIR Headerdoc output folder 2252# PRODUCT_CLASS_FILE_DIR Defined if JAVA_ARCHIVE_CLASSES is set 2253# 2254rule BeginWrappedProduct 2255{ 2256 # define wrapper using appropriate extension and suffix 2257 if $(WRAPPER_EXTENSION) { 2258 WRAPPER_SUFFIX = .$(WRAPPER_EXTENSION) ; 2259 } 2260 if $(WRAPPER_SUFFIX) { 2261 WRAPPER = $(1:G=:S=$(WRAPPER_SUFFIX)) ; 2262 } 2263 else { 2264 WRAPPER = $(1:G=) ; 2265 } 2266 # set up the basic product variables 2267 BeginProduct $(1) ; 2268 # define and create wrapper and make primary nonfile target depend on it 2269 LOCATE on $(WRAPPER) = $(TARGET_BUILD_DIR) ; 2270 Mkdir $(WRAPPER) ; 2271 PRODUCT_FILES += $(WRAPPER) ; 2272 DEPENDS $(1) : $(WRAPPER) ; 2273 if $(PRODUCT_TYPE) = Application { 2274 # Application wrappers 2275 if $(PURE_JAVA) = YES { 2276 RESOURCE_DIR default = $(WRAPPER) ; 2277 } 2278 else { 2279 RESOURCE_DIR default = $(WRAPPER)$(/)Contents$(/)Resources ; 2280 } 2281 LOCATE on $(RESOURCE_DIR) = $(TARGET_BUILD_DIR) ; 2282 RESOURCE_LINK = "" ; 2283 APPLESCRIPTS_DIR default = $(RESOURCE_DIR)$(/)Scripts ; 2284 LOCATE on $(APPLESCRIPTS_DIR) = $(TARGET_BUILD_DIR) ; 2285 PUBLIC_HEADER_DIR default = $(WRAPPER)$(/)"Contents"$(/)Headers ; 2286 LOCATE on $(PUBLIC_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2287 PUBLIC_HEADER_LINK default = "" ; 2288 PRIVATE_HEADER_DIR default = $(WRAPPER)$(/)"Contents"$(/)PrivateHeaders ; 2289 LOCATE on $(PRIVATE_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2290 PRIVATE_HEADER_LINK default = "" ; 2291 CURRENT_VERSION_DIR default = "" ; 2292 CURRENT_VERSION_LINK default = "" ; 2293 if $(CLONE_HEADERS) = YES { 2294 WRAPPER_CLONE_DIR = $(BASE_PROJECT_HEADER_DIR)$(/)$(WRAPPER) ; 2295 PUBLIC_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)"Contents"$(/)Headers ; 2296 LOCATE on $(PUBLIC_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2297 PUBLIC_HEADER_CLONE_LINK default = "" ; 2298 PRIVATE_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)"Contents"$(/)PrivateHeaders ; 2299 LOCATE on $(PRIVATE_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2300 PRIVATE_HEADER_CLONE_LINK default = "" ; 2301 CURRENT_VERSION_CLONE_DIR default = "" ; 2302 CURRENT_VERSION_CLONE_LINK default = "" ; 2303 } 2304 } # application wrappers 2305 else if $(PRODUCT_TYPE) = Framework { 2306 # Framework wrappers 2307 RESOURCE_DIR default = $(WRAPPER)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)Resources ; 2308 LOCATE on $(RESOURCE_DIR) = $(TARGET_BUILD_DIR) ; 2309 RESOURCE_LINK default = $(WRAPPER)$(/)Resources ; 2310 LOCATE on $(RESOURCE_LINK) = $(TARGET_BUILD_DIR) ; 2311 RESOURCE_LINK_PATH default = Versions$(/)Current$(/)Resources ; 2312 APPLESCRIPTS_DIR default = $(RESOURCE_DIR)$(/)Scripts ; 2313 LOCATE on $(APPLESCRIPTS_DIR) = $(TARGET_BUILD_DIR) ; 2314 HAS_PUBLIC_HEADERS = "NO" ; 2315 PUBLIC_HEADER_DIR default = $(WRAPPER)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)Headers ; 2316 LOCATE on $(PUBLIC_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2317 PUBLIC_HEADER_LINK default = $(WRAPPER)$(/)Headers ; 2318 LOCATE on $(PUBLIC_HEADER_LINK) = $(TARGET_BUILD_DIR) ; 2319 PUBLIC_HEADER_LINK_PATH default = Versions$(/)Current$(/)Headers ; 2320 PRIVATE_HEADER_DIR default = $(WRAPPER)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)PrivateHeaders ; 2321 LOCATE on $(PRIVATE_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2322 PRIVATE_HEADER_LINK default = $(WRAPPER)$(/)PrivateHeaders ; 2323 LOCATE on $(PRIVATE_HEADER_LINK) = $(TARGET_BUILD_DIR) ; 2324 PRIVATE_HEADER_LINK_PATH default = Versions$(/)Current$(/)PrivateHeaders ; 2325 CURRENT_VERSION_DIR default = $(WRAPPER:G=)$(/)Versions$(/)$(FRAMEWORK_VERSION) ; 2326 LOCATE on $(CURRENT_VERSION_DIR) = $(TARGET_BUILD_DIR) ; 2327 CURRENT_VERSION_LINK default = $(WRAPPER:G=)$(/)Versions$(/)Current ; 2328 LOCATE on $(CURRENT_VERSION_LINK) = $(TARGET_BUILD_DIR) ; 2329 CURRENT_VERSION_LINK_PATH default = Versions$(/)Current ; 2330 if $(CLONE_HEADERS) = YES { 2331 WRAPPER_CLONE_DIR = $(BASE_PROJECT_HEADER_DIR)$(/)$(WRAPPER) ; 2332 PUBLIC_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)Headers ; 2333 LOCATE on $(PUBLIC_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2334 PUBLIC_HEADER_CLONE_LINK default = $(WRAPPER_CLONE_DIR)$(/)Headers ; 2335 LOCATE on $(PUBLIC_HEADER_CLONE_LINK) = $(TARGET_BUILD_DIR) ; 2336 PUBLIC_HEADER_CLONE_LINK_PATH default = Versions$(/)Current$(/)Headers ; 2337 PRIVATE_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)PrivateHeaders ; 2338 LOCATE on $(PRIVATE_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2339 PRIVATE_HEADER_CLONE_LINK default = $(WRAPPER_CLONE_DIR)$(/)PrivateHeaders ; 2340 LOCATE on $(PRIVATE_HEADER_CLONE_LINK) = $(TARGET_BUILD_DIR) ; 2341 PRIVATE_HEADER_CLONE_LINK_PATH default = Versions$(/)Current$(/)PrivateHeaders ; 2342 CURRENT_VERSION_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Versions$(/)$(FRAMEWORK_VERSION) ; 2343 CURRENT_VERSION_CLONE_LINK default = $(WRAPPER_CLONE_DIR)$(/)Versions$(/)Current ; 2344 CURRENT_VERSION_CLONE_LINK_PATH default = Versions$(/)Current ; 2345 } 2346 if $(ASIDE_DIR) { 2347 ASIDE_CURRENT_VERSION_DIR default = $(WRAPPER:G=aside)$(/)Versions$(/)$(FRAMEWORK_VERSION) ; 2348 ASIDE_CURRENT_VERSION_LINK default = $(WRAPPER:G=aside)$(/)Versions$(/)Current ; 2349 ASIDE_CURRENT_VERSION_LINK_PATH default = Versions$(/)Current ; 2350 ASIDE_CURRENT_VERSION_LINK_PATH = $(ASIDE_CURRENT_VERSION_LINK_PATH:G=aside) ; 2351 Mkdir $(ASIDE_CURRENT_VERSION_DIR) ; 2352 ProductFileAside $(ASIDE_CURRENT_VERSION_DIR) ; 2353 DEPENDS $(1) : $(ASIDE_CURRENT_VERSION_DIR) ; 2354 NOUPDATE $(ASIDE_CURRENT_VERSION_DIR) ; 2355 SymLink $(ASIDE_CURRENT_VERSION_LINK) : $(FRAMEWORK_VERSION) ; 2356 ProductFileAside $(ASIDE_CURRENT_VERSION_LINK) ; 2357 DEPENDS $(1) : $(ASIDE_CURRENT_VERSION_LINK) ; 2358 DEPENDS $(ASIDE_CURRENT_VERSION_LINK) : $(ASIDE_CURRENT_VERSION_DIR) ; 2359 NOUPDATE $(ASIDE_CURRENT_VERSION_LINK) ; 2360 } 2361 # Create current version directory and link now because 2362 # they are implicit and needed by almost everything else: 2363 # Current version dir 2364 Mkdir $(CURRENT_VERSION_DIR) ; 2365 ProductFile $(CURRENT_VERSION_DIR) ; 2366 DEPENDS $(1) : $(CURRENT_VERSION_DIR) ; # need this or build phase 2367 NOUPDATE $(CURRENT_VERSION_DIR) ; 2368 # Current version link 2369 SymLink $(CURRENT_VERSION_LINK) : $(FRAMEWORK_VERSION) ; 2370 ProductFile $(CURRENT_VERSION_LINK) ; 2371 DEPENDS $(1) : $(CURRENT_VERSION_LINK) ; # need this or build phase 2372 DEPENDS $(CURRENT_VERSION_LINK) : $(CURRENT_VERSION_DIR) ; 2373 NOUPDATE $(CURRENT_VERSION_LINK) ; 2374 if $(CLONE_HEADERS) = YES { 2375 Mkdir $(CURRENT_VERSION_CLONE_DIR) ; 2376 ProductFile $(CURRENT_VERSION_CLONE_DIR) ; 2377 NOUPDATE $(CURRENT_VERSION_CLONE_DIR) ; 2378 # Current version link 2379 SymLink $(CURRENT_VERSION_CLONE_LINK) : $(FRAMEWORK_VERSION) ; 2380 ProductFile $(CURRENT_VERSION_CLONE_LINK) ; 2381 DEPENDS $(1) : $(CURRENT_VERSION_CLONE_LINK) ; 2382 DEPENDS $(CURRENT_VERSION_CLONE_LINK) : $(CURRENT_VERSION_CLONE_DIR) ; 2383 NOUPDATE $(CURRENT_VERSION_CLONE_LINK) ; 2384 # Make sure someone depends on the clone current symlink so it will get created. 2385 DEPENDS $(PUBLIC_HEADER_CLONE_LINK) : $(CURRENT_VERSION_CLONE_LINK) ; 2386 DEPENDS $(PRIVATE_HEADER_CLONE_LINK) : $(CURRENT_VERSION_CLONE_LINK) ; 2387 } 2388 } # framework wrappers 2389 else { 2390 # Default bundle wrappers 2391 if $(BUNDLE_STYLE) = SHALLOW { 2392 # shallow bundles do not have the Contents/Resources folders 2393 RESOURCE_DIR default = $(WRAPPER) ; 2394 LOCATE on $(RESOURCE_DIR) = $(TARGET_BUILD_DIR) ; 2395 APPLESCRIPTS_DIR default = $(WRAPPER)$(/)Scripts ; 2396 LOCATE on $(APPLESCRIPTS_DIR) = $(TARGET_BUILD_DIR) ; 2397 PUBLIC_HEADER_DIR default = $(WRAPPER)$(/)Headers ; 2398 LOCATE on $(PUBLIC_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2399 PRIVATE_HEADER_DIR default = $(WRAPPER)$(/)PrivateHeaders ; 2400 LOCATE on $(PRIVATE_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2401 if $(CLONE_HEADERS) = YES { 2402 WRAPPER_CLONE_DIR = $(BASE_PROJECT_HEADER_DIR)$(/)$(WRAPPER) ; 2403 PUBLIC_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Headers ; 2404 LOCATE on $(PUBLIC_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2405 PRIVATE_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)PrivateHeaders ; 2406 LOCATE on $(PRIVATE_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2407 } 2408 } 2409 else { 2410 # else, BUNDLE_STYLE=DEEP bundles do have Contents/Resources folders 2411 RESOURCE_DIR default = $(WRAPPER)$(/)Contents$(/)Resources ; 2412 LOCATE on $(RESOURCE_DIR) = $(TARGET_BUILD_DIR) ; 2413 APPLESCRIPTS_DIR default = $(RESOURCE_DIR)$(/)Scripts ; 2414 LOCATE on $(APPLESCRIPTS_DIR) = $(TARGET_BUILD_DIR) ; 2415 PUBLIC_HEADER_DIR default = $(WRAPPER)$(/)Contents$(/)Headers ; 2416 LOCATE on $(PUBLIC_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2417 PRIVATE_HEADER_DIR default = $(WRAPPER)$(/)Contents$(/)PrivateHeaders ; 2418 LOCATE on $(PRIVATE_HEADER_DIR) = $(TARGET_BUILD_DIR) ; 2419 if $(CLONE_HEADERS) = YES { 2420 WRAPPER_CLONE_DIR = $(BASE_PROJECT_HEADER_DIR)$(/)$(WRAPPER) ; 2421 PUBLIC_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Contents$(/)Headers ; 2422 LOCATE on $(PUBLIC_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2423 PRIVATE_HEADER_CLONE_DIR default = $(WRAPPER_CLONE_DIR)$(/)Contents$(/)PrivateHeaders ; 2424 LOCATE on $(PRIVATE_HEADER_CLONE_DIR) = $(TARGET_BUILD_DIR) ; 2425 } 2426 } 2427 RESOURCE_LINK default = "" ; 2428 PUBLIC_HEADER_LINK default = "" ; 2429 PRIVATE_HEADER_LINK default = "" ; 2430 CURRENT_VERSION_DIR default = "" ; 2431 CURRENT_VERSION_LINK default = "" ; 2432 if $(CLONE_HEADERS) = YES { 2433 PUBLIC_HEADER_CLONE_LINK default = "" ; 2434 PRIVATE_HEADER_CLONE_LINK default = "" ; 2435 CURRENT_VERSION_CLONE_DIR default = "" ; 2436 CURRENT_VERSION_CLONE_LINK default = "" ; 2437 } 2438 } # all bundle layouts 2439 # define location for optional header documentation generation 2440 if $(GENERATE_HEADERDOC) = YES && $(RESOURCE_DIR) { 2441 HEADERDOC_DIR default = $(TARGET_BUILD_DIR)$(/)$(RESOURCE_DIR)$(/)Documentation ; 2442 Mkdir $(HEADERDOC_DIR) ; 2443 ProductFile $(HEADERDOC_DIR) ; 2444 } 2445 2446 # wrapped products may define a location for unarchived classes 2447 if $(JAVA_ARCHIVE_CLASSES) != YES { 2448 export PRODUCT_CLASS_FILE_DIR default = $(TARGET_BUILD_DIR)$(/)$(RESOURCE_DIR)$(/)Java ; 2449 } 2450} 2451 2452# EndWrappedProduct <product> 2453# 2454# Sets up additional dependence related to object files. 2455# Files depended on by object files should be in compile rules, 2456# and dependence on object files should be in link rules. 2457rule EndWrappedProduct 2458{ 2459 # Wrapper touch updates base container directory timestamp 2460 # This must be conditional on the "build" component, 2461 # otherwize installhdrs builds with no headers will fail. 2462 if build in $(BUILD_COMPONENTS) { 2463 WRAPPER_TOUCH = $(1:G=Touch) ; 2464 LOCATE on $(WRAPPER_TOUCH) = $(TARGET_BUILD_DIR) ; 2465 DEPENDS $(WRAPPER_TOUCH) : $(BUILD_PHASE) ; 2466 DEPENDS $(1) : $(WRAPPER_TOUCH) ; 2467 Touch $(WRAPPER_TOUCH) ; 2468 } 2469 # wrapper logic complete, now handle final build issues 2470 EndProduct $(1) ; 2471} 2472# Copyright (c) 1999-2002 Apple Computer, Inc. 2473# All rights reserved. 2474 2475# Rules for target types include Begin and End rules 2476# for Tool, Library, Bundle, Application, and Framework 2477 2478TOOL_SUFFIX default = "" ; 2479rule BeginTool 2480{ 2481 export PRODUCT_TYPE = Tool ; 2482 BeginProduct $(1) ; 2483} 2484 2485rule EndTool 2486{ 2487 EndProduct $(1) ; 2488} 2489 2490# Library variable names have the form: $(OS)_$(LIBRARY_STYLE)_LIBRARY_$(VARIABLENAME) 2491MACOS_STATIC_LIBRARY_PREFIX = lib ; 2492MACOS_STATIC_LIBRARY_SUFFIX = .a ; 2493MACOS_DYNAMIC_LIBRARY_PREFIX = "" ; 2494MACOS_DYNAMIC_LIBRARY_SUFFIX = "" ; 2495DARWIN_STATIC_LIBRARY_PREFIX = lib ; 2496DARWIN_STATIC_LIBRARY_SUFFIX = .a ; 2497DARWIN_DYNAMIC_LIBRARY_PREFIX = "" ; 2498DARWIN_DYNAMIC_LIBRARY_SUFFIX = "" ; 2499DYNAMIC_LIBRARY_PREFIX = $($(OS)_DYNAMIC_LIBRARY_PREFIX) ; 2500DYNAMIC_LIBRARY_SUFFIX = $($(OS)_DYNAMIC_LIBRARY_SUFFIX) ; 2501 2502rule BeginLibrary 2503{ 2504 # These evaluations here to pick up style from target settings 2505 LIBRARY_PREFIX = $($(OS)_$(LIBRARY_STYLE)_LIBRARY_PREFIX) ; 2506 LIBRARY_SUFFIX = $($(OS)_$(LIBRARY_STYLE)_LIBRARY_SUFFIX) ; 2507 export PRODUCT_TYPE = Library ; 2508 BeginProduct $(1) ; 2509} 2510 2511rule EndLibrary 2512{ 2513 EndProduct $(1) ; 2514} 2515 2516rule BeginBundle 2517{ 2518 export PRODUCT_TYPE = Bundle ; 2519 BeginWrappedProduct $(1) ; 2520} 2521 2522rule EndBundle 2523{ 2524 EndWrappedProduct $(1) ; 2525} 2526 2527rule BeginApplication 2528{ 2529 export PRODUCT_TYPE = Application ; 2530 BeginWrappedProduct $(1) ; 2531} 2532 2533rule EndApplication 2534{ 2535 EndWrappedProduct $(1) ; 2536} 2537 2538rule BeginFramework 2539{ 2540 export PRODUCT_TYPE = Framework ; 2541 BeginWrappedProduct $(1) ; 2542} 2543 2544rule EndFramework 2545{ 2546 EndWrappedProduct $(1) ; 2547} 2548# Copyright (c) 1999-2002 Apple Computer, Inc. 2549# All rights reserved. 2550 2551# Variables referenced: 2552# BUILD_DIR Location of built product 2553# RESOURCE_DIR Directory for resource files in product 2554# *_LINK, *_LINK_PATH Wrapper versioning information 2555# *_HEADER_DIR Directories for headers of product 2556# _INFO_PLIST_FILE_PATH Path to Info.plist file (if any), generated by PBXCore 2557# _PKGINFO_FILE_PATH Path to PkgInfo file (if any), generated by PBXCore 2558# _VERSION_PLIST_FILE_PATH Path to version.plist file (if any), generated by PBXCore 2559# _PBDEVELOPMENT_PLIST_FILE_PATH Path to pbdevelopment.plist file (if any), generated by PBXCore 2560# VERSIONING_SYSTEM Versioning system to use for product 2561# JAVA_COMPILE_TARGET Nonfile target representing all java compiles 2562# REZ_EXECUTABLE Run Rez directly on executable to produce fork if YES 2563# PRESERVE_RESOURCES Files to be recopied with CpMac after install tar copy 2564# APPLESCRIPTS_DIR Directory for compiled AppleScripts 2565# 2566# Variables set: 2567# DERIVED_FILES Intermediate sources 2568# OBJECT_FILES Object files produced by compilations 2569# LINKED_FILES Files to be used by a link rule 2570# PRODUCT_FILES Files that belong in the built product 2571# INFO_PLIST_FILE Info.plist file in product wrapper, copied from PRODUCT_SETTINGS_PATH 2572# PKGINFO_FILE PkgInfo file in product wrapper, copied from _PKGINFO_FILE_PATH 2573# HDRRULE, HDRSCAN Target specific header scanning information 2574# FLAGS Target specific compilation flags 2575# HEADER_SEARCH_PATHS, FRAMEWORK_SEARCH_PATHS Target specific search paths 2576# 2577# Build phase variables: 2578# BUILD_PHASE Target for current build phase 2579# PREVIOUS_BUILD_PHASE Target for previous build phase 2580# BUILD_PHASE_PRODUCTS Products of current build phase 2581# PHASE_TARGETS List of all phase targets for conflict checks 2582 2583# Source and resource handling rules by extension 2584.h_RULE = ProcessHeader ; 2585.nib_RULE = ProcessResource ; 2586.rtf_RULE = ProcessResource ; 2587.exe_RULE = ProcessResource ; 2588.java_RULE = ProcessUsingJavaCompiler ; 2589.applescript_RULE = ProcessAppleScript ; 2590.s_RULE = ProcessC ; 2591.c_RULE = ProcessC ; 2592.adb_RULE = ProcessC ; # unsupported 2593.ads_RULE = ProcessC ; # unsupported 2594.f_RULE = ProcessC ; # unsupported 2595.C_RULE = ProcessCplusplus ; 2596.cc_RULE = ProcessCplusplus ; 2597.cp_RULE = ProcessCplusplus ; 2598.cpp_RULE = ProcessCplusplus ; 2599.CPP_RULE = ProcessCplusplus ; 2600.cxx_RULE = ProcessCplusplus ; 2601.CXX_RULE = ProcessCplusplus ; 2602# !!!:cmolick:20020226 note: .C++ not accepted by c++ compiler driver 2603.c++_RULE = ProcessCplusplus ; 2604.m_RULE = ProcessC ; 2605.mm_RULE = ProcessCplusplus ; 2606.M_RULE = ProcessCplusplus ; 2607.exp_RULE = ProcessExportsFile ; 2608.defs_RULE = ProcessUsingMig ; 2609.mig_RULE = ProcessUsingMig ; 2610.l_RULE = ProcessUsingLex ; 2611.lm_RULE = ProcessUsingLex ; 2612.LM_RULE = ProcessUsingLex ; 2613.lmm_RULE = ProcessUsingLex ; 2614.lpp_RULE = ProcessUsingLex ; 2615.LPP_RULE = ProcessUsingLex ; 2616.lxx_RULE = ProcessUsingLex ; 2617.LXX_RULE = ProcessUsingLex ; 2618.y_RULE = ProcessUsingYacc ; 2619.ym_RULE = ProcessUsingYacc ; 2620.YM_RULE = ProcessUsingYacc ; 2621.ymm_RULE = ProcessUsingYacc ; 2622.ypp_RULE = ProcessUsingYacc ; 2623.YPP_RULE = ProcessUsingYacc ; 2624.yxx_RULE = ProcessUsingYacc ; 2625.YXX_RULE = ProcessUsingYacc ; 2626.x_RULE = ProcessUsingRPCGen ; 2627.jobs_RULE = ProcessUsingBridget ; 2628.framework_RULE = ProcessFrameworkOrLibrary ; 2629.r_RULE = ProcessRezFile ; 2630.rsrc_RULE = ProcessRezFile ; 2631.RSRC_RULE = ProcessRezFile ; 2632.ppob_RULE = ProcessRezFile ; 2633 2634# Set the initial list of phase targets to empty 2635PHASE_TARGETS = ; 2636 2637# PhaseTarget <phase target variable> <product> <phase name> 2638# Sets up the given phase target variable based on the target 2639# and phase name and uses the list of phase targets to attempt 2640# avoid collisions between targets for phases with the same name. 2641rule PhaseTarget 2642{ 2643 local PHASE_SUFFIXES = 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 ; 2644 local PHASE_TARGET = $(2:G=$(3)) ; 2645 if $(PHASE_TARGET) in $(PHASE_TARGETS) { 2646 # attempt differentiation by adding last nonmatching suffix 2647 for PHASE_SUFFIX in $(PHASE_SUFFIXES) { 2648 ALTERNATE_PHASE_TARGET = $(2:G=$(3)$(PHASE_SUFFIX)) ; 2649 if ! $(ALTERNATE_PHASE_TARGET) in $(PHASE_TARGETS) { 2650 PHASE_TARGET = $(ALTERNATE_PHASE_TARGET) ; 2651 } 2652 } 2653 } 2654 PHASE_TARGETS += $(PHASE_TARGET) ; 2655 $(1) = $(PHASE_TARGET) ; 2656 NOTFILE $(PHASE_TARGET) ; 2657} 2658 2659# BuildPhase <phase> <product> <previous phase> 2660# Set up product (and variant hack) dependence on phase 2661# and phase dependence on previous phase 2662# and defines an action to indicate phase completion 2663rule BuildPhase 2664{ 2665 # retain a list of all phases 2666 _BUILD_PHASES += $(1) ; 2667 # retain name for action echo 2668 PHASE_NAME on $(1) = $(1:G) ; 2669 # this build phase depends on the previous phase 2670 if $(3) { 2671 DEPENDS $(1) : $(3) ; 2672 } 2673 # phase required for parent target 2674 DEPENDS $(2) : $(1) ; 2675} 2676actions BuildPhase 2677{ 2678 $(ECHO) Completed phase "$(PHASE_NAME)" for "$(1)" 2679} 2680 2681# DerivedFiles <derived-files> 2682# Locates derived files in the derived file directory, 2683# sees the derived paths with the derived file directory if necessary, 2684# creates derived subpaths and ads them to derived paths as necessary, 2685# and makes the derived file depend on all derived paths. 2686rule DerivedFiles 2687{ 2688 local DERIVED_FILE ; 2689 for DERIVED_FILE in $(1) { 2690 # record any derived headers 2691 if $(DERIVED_FILE:S) = ".h" { 2692 DERIVED_HEADERS += $(DERIVED_FILE) ; 2693 } 2694 # derived file is a build phase product 2695 if $(_BUILD_PHASING) = YES { 2696 BUILD_PHASE_PRODUCTS += $(DERIVED_FILE) ; 2697 } 2698 # make and depend on containing directory 2699 LOCATE on $(DERIVED_FILE) = $(DERIVED_FILE_DIR) ; 2700 if ! $(DERIVED_PATHS) { 2701 DERIVED_PATHS = $(DERIVED_FILE_DIR) ; 2702 } 2703 local DIR = $(DERIVED_FILE_DIR)$(/)$(DERIVED_FILE:D) ; 2704 if ! ( $(DIR) in $(DERIVED_PATHS) ) { 2705 Mkdir $(DIR) ; 2706 if $(_BUILD_PHASING) = YES { 2707 BUILD_PHASE_PRODUCTS += $(DIR) ; 2708 } 2709 DERIVED_PATHS += $(DIR) ; 2710 } 2711 DEPENDS $(DERIVED_FILE) : $(DERIVED_PATHS) ; 2712 } 2713} 2714 2715# ProductFile <product-file> 2716# The product file location is set to BUILD_DIR. 2717# If the reference and containing directory are not already 2718# in the list of product files, then they are added. They also 2719# become build phase products unless phasing is turned off. 2720rule ProductFile 2721{ 2722 LOCATE on $(1) = $(TARGET_BUILD_DIR) ; 2723 if ! $(1) in $(PRODUCT_FILES) { 2724 PRODUCT_FILES += $(1) ; 2725 if $(_BUILD_PHASING) = YES { 2726 BUILD_PHASE_PRODUCTS += $(1) ; 2727 } 2728 } 2729} 2730 2731# ProductFileAside <file> 2732# Same as ProductFile, but default location is ASIDE_DIR. 2733rule ProductFileAside 2734{ 2735 LOCATE on $(1) = $(ASIDE_DIR) ; 2736 if ! $(1) in $(PRODUCT_FILES) { 2737 PRODUCT_FILES += $(1) ; 2738 if $(_BUILD_PHASING) = YES { 2739 BUILD_PHASE_PRODUCTS += $(1) ; 2740 } 2741 } 2742} 2743 2744# SetModeOwnerAndGroup <nonfile gristed target> : <base target> 2745# Uses given nonfile gristed target to set mode, owner, and group 2746# of the base product 2747rule SetModeOwnerAndGroup 2748{ 2749 NOTFILE $(1) ; 2750 LOCATE on $(1) = $(TARGET_BUILD_DIR) ; 2751 POST_PHASE_PRODUCTS += $(1) ; 2752 if $(INSTALL_MODE_FLAG) { 2753 SetMode $(1) : $(2) ; 2754 } 2755 if $(INSTALL_OWNER) { 2756 if $(INSTALL_GROUP) { 2757 SetOwnerAndGroup $(1) : $(2) ; 2758 } 2759 else { 2760 SetOwner $(1) : $(2) ; 2761 } 2762 } 2763 else if $(INSTALL_GROUP) { 2764 SetGroup $(1) : $(2) ; 2765 } 2766} 2767actions SetMode 2768{ 2769 $(CHMOD) -RH $(INSTALL_MODE_FLAG) "$(2:G=)" 2770} 2771actions SetOwner 2772{ 2773 $(CHOWN) -RH $(INSTALL_OWNER) "$(2:G=)" 2774} 2775actions SetGroup 2776{ 2777 $(CHOWN) -RH :$(INSTALL_GROUP) "$(2:G=)" 2778} 2779actions SetOwnerAndGroup 2780{ 2781 $(CHOWN) -RH $(INSTALL_OWNER):$(INSTALL_GROUP) "$(2:G=)" 2782} 2783 2784rule NoOp 2785{ 2786 if $(_BUILD_PHASING) = YES { 2787 PhaseTarget BUILD_PHASE : $(1) : NoOp ; 2788 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 2789 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 2790 } 2791} 2792 2793# ProcessHeaders <product> <headers> 2794# 2795# Process individual headers, call Interfacer to generate headers, 2796# precompile and assemble implicitly included headers as necessary, 2797# and run headerdoc. 2798rule ProcessHeaders 2799{ 2800 if ( headers in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) ) 2801 && ( $(ARCHS) || $(NULL_BUILD_IF_NO_VALID_ARCH) != YES ) { 2802 2803 local FILE ; 2804 if $(_BUILD_PHASING) = YES { 2805 PhaseTarget BUILD_PHASE : $(1) : CopyHeaders ; 2806 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 2807 BUILD_PHASE_PRODUCTS = ; 2808 } 2809 for FILE in $(2) { 2810 if $(_BUILD_PHASING) = YES { 2811 ProcessHeader $(BUILD_PHASE) : $(FILE) ; 2812 } 2813 else { 2814 ProcessHeader $(1) : $(FILE) ; 2815 } 2816 } 2817 2818 # conditionally gather documentation generated from headers 2819 if build in $(BUILD_COMPONENTS) && $(GATHERHEADERDOC) && $(GENERATE_HEADERDOC) = YES && $(HEADERDOC_DIR) && HEADERDOC_TARGETS { 2820 GATHERED_HEADERDOC_TARGET = masterTOC.html ; 2821 LOCATE on $(GATHERED_HEADERDOC_TARGET) = $(HEADERDOC_DIR) ; 2822 DEPENDS $(GATHERED_HEADERDOC_TARGET) : $(HEADERDOC_DIR) ; 2823 DEPENDS $(GATHERED_HEADERDOC_TARGET) : $(HEADERDOC_TARGETS) ; 2824 GatheredHeaderDoc $(GATHERED_HEADERDOC_TARGET) ; 2825 if $(_BUILD_PHASING) = YES { 2826 BUILD_PHASE_PRODUCTS += $(GATHERED_HEADERDOC_TARGET) ; 2827 } 2828 } 2829 } 2830 # generate interfacer derived headers 2831 if headers in $(BUILD_COMPONENTS) && $(GENERATE_HEADERS) = YES { 2832 InterfacerHeaders $(1) ; 2833 } 2834 # :mferris:20011107 Only do IMPLICITLY_INCLUDED_HEADERS business if we are actually building. No need to do this for installhdrs, and currently, we cannot handle the precompiling aspect of this during installhdrs. If we ever support building framework precomps (ie if we ever have to invoke the compiler during installhdrs), this needs to be revisited. 2835 if ( build in $(BUILD_COMPONENTS) ) 2836 && ( $(ARCHS) || $(NULL_BUILD_IF_NO_VALID_ARCH) != YES ) { 2837 # if we have a prefix file, and if we're supposed to precompile it, we do so using either GCC 3's PFE mechanism or using cpp-precomp 2838 if ( $(PREFIX_HEADER) != "" && $(PRECOMPILE_PREFIX_HEADER) = YES ) { 2839 PFE_FILE_C_DIALECTS default = "c" "objective-c" "c++" "objective-c++" ; 2840 PRECOMP_DESTINATION_DIR default = $(TEMP_DIR)$(/)PrefixHeaders ; 2841 Mkdir $(PRECOMP_DESTINATION_DIR) ; 2842 PRODUCT_FILES += $(PRECOMP_DESTINATION_DIR) ; 2843 if $(_BUILD_PHASING) = YES { 2844 BUILD_PHASE_PRODUCTS += $(PRECOMP_DESTINATION_DIR) ; 2845 } 2846 if $(USE_GCC3_PFE_SUPPORT) = YES { 2847 # We need to precompile the prefix file, and we're using GCC 3. This means that we need to make an arbitrary number of PFE files, one per language-and-architecture combination. PFE_FILE_C_DIALECTS gives the languages and ARCHS gives the architectures (although PFE_FILE_C_DIALECTS is only used _inside_ the action of MakePFEFile -- from Jam's perspective, we treat each architecture's PFE file as an atomic unit). The "effective prefix file" is set to nothing, since we won't be passing a -include directive. The "EFFECTIVE_PFE_FILE_$(ARCH)" is set to the produced PFE file. 2848 for ARCH in $(ARCHS) { 2849 EFFECTIVE_PFE_FILE_$(ARCH) = $(PRECOMP_DESTINATION_DIR)$(/)$(PREFIX_HEADER:BS="-$(ARCH).pfe") ; 2850 MakePFEFile $(EFFECTIVE_PFE_FILE_$(ARCH)) : $(PREFIX_HEADER) ; 2851 PRODUCT_FILES += $(EFFECTIVE_PFE_FILE_$(ARCH)) ; 2852 if $(_BUILD_PHASING) = YES { 2853 BUILD_PHASE_PRODUCTS += $(EFFECTIVE_PFE_FILE_$(ARCH)) ; 2854 } 2855 } 2856 EFFECTIVE_PREFIX_HEADER = ; # because with a PFE file, we don't actually pass a -include argument 2857 } 2858 else { 2859 # We need to precompile the prefix file, and we're not using GCC 3. This means that we create a header stub in a special directory under the TEMP_DIR, precompile that for both C and C++, and then pass the prefix file in the -include. The "effective prefix file" is set to the prefix file stub. 2860 local PREFIX_HEADER_STUB = $(PRECOMP_DESTINATION_DIR)$(/)$(PREFIX_HEADER:BS) ; 2861 DEPENDS $(PREFIX_HEADER_STUB) : $(PRECOMP_DESTINATION_DIR) ; 2862 AbsolutePathImportStub $(PREFIX_HEADER_STUB) : $(PREFIX_HEADER) ; 2863 INCLUDES $(PREFIX_HEADER_STUB) : $(PREFIX_HEADER) ; 2864 if ( "c" in $(PFE_FILE_C_DIALECTS) ) || ( "objective-c" in $(PFE_FILE_C_DIALECTS) ) { 2865 C_PRECOMP_FILE_DESTINATION_PATH = $(PRECOMP_DESTINATION_DIR)$(/)$(PREFIX_HEADER_STUB:BS="-gcc3.p") ; 2866 PrecompileHeader $(C_PRECOMP_FILE_DESTINATION_PATH) : $(PREFIX_HEADER_STUB) ; 2867 PRODUCT_FILES += $(C_PRECOMP_FILE_DESTINATION_PATH) ; 2868 if $(_BUILD_PHASING) = YES { 2869 BUILD_PHASE_PRODUCTS += $(C_PRECOMP_FILE_DESTINATION_PATH) ; 2870 } 2871 } 2872 if ( "c++" in $(PFE_FILE_C_DIALECTS) ) || ( "objective-c++" in $(PFE_FILE_C_DIALECTS) ) { 2873 CPLUSPLUS_PRECOMP_FILE_DESTINATION_PATH = $(PRECOMP_DESTINATION_DIR)$(/)$(PREFIX_HEADER_STUB:BS="-gcc3.pp") ; 2874 PrecompileHeader $(CPLUSPLUS_PRECOMP_FILE_DESTINATION_PATH) : $(PREFIX_HEADER_STUB) ; 2875 PRODUCT_FILES += $(CPLUSPLUS_PRECOMP_FILE_DESTINATION_PATH) ; 2876 if $(_BUILD_PHASING) = YES { 2877 BUILD_PHASE_PRODUCTS += $(CPLUSPLUS_PRECOMP_FILE_DESTINATION_PATH) ; 2878 } 2879 } 2880 EFFECTIVE_PREFIX_HEADER = $(PREFIX_HEADER_STUB) ; 2881 } 2882 } 2883 else { 2884 EFFECTIVE_PREFIX_HEADER = $(PREFIX_HEADER) ; 2885 } 2886 } 2887 # phase end logic 2888 # THIS *MUST* COME *AFTER* ALL OTHER WORK FOR THIS PHASE!!! 2889 # cmolick:20020213 ideally this should be within action conditionals, 2890 # but that is difficult now that there are three disjointed ones, 2891 # so checking to see if the build phase is defined is a hack 2892 # the problem of bad DEPENDS here on clean for now. 2893 if $(_BUILD_PHASING) = YES && $(BUILD_PHASE) { 2894 if $(BUILD_PHASE_PRODUCTS) { 2895 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 2896 } 2897 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 2898 } 2899} 2900 2901# CreateMasterImplicitHeader <master implicit header path> 2902rule CreateMasterImplicitHeader 2903{ 2904 # Creation of this header depends on all the header copies 2905 for HEADER_COPY in $(IMPLICITLY_INCLUDED_HEADER_COPIES) { 2906 DEPENDS $(1) : $(HEADER_COPY) ; 2907 } 2908 # Master implicit header depends on destination dir 2909 DEPENDS $(1) : $(PRECOMP_DESTINATION_DIR) ; 2910} 2911actions CreateMasterImplicitHeader 2912{ 2913 $(RM) -f "$(1)" 2914 $(TOUCH) "$(1)" 2915 $(ECHO) "/* Generated master implicit inclusion header */" >> "$(1)" 2916 for header in "$(IMPLICITLY_INCLUDED_HEADER_COPIES)" 2917 do 2918 $(ECHO) "#include \"$header\"" >> "$(1)" 2919 done 2920} 2921 2922# ProcessHeader <product or phase> <header> 2923# 2924# Clone header and generate headerdoc from header as necessary, 2925# and copy header to subfolders of product as appropriate. 2926rule ProcessHeader 2927{ 2928 if source in $(BUILD_COMPONENTS) { 2929 local HEADER_SOURCE_COPY ; 2930 local HEADER_SOURCE_DIR ; 2931 # make directory first if necessary 2932 if $(2:D) { 2933 HEADER_SOURCE_DIR = $(SOURCE_DIR)/$(2:D:G=) ; 2934 Mkdir $(HEADER_SOURCE_DIR) ; 2935 HEADER_SOURCE_COPY = $(HEADER_SOURCE_DIR)/$(2:D=:G=) ; 2936 DEPENDS $(HEADER_SOURCE_COPY) : $(HEADER_SOURCE_DIR) ; 2937 } 2938 else { 2939 HEADER_SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 2940 DEPENDS $(HEADER_SOURCE_COPY) : $(SOURCE_DIR) ; 2941 Mkdir $(SOURCE_DIR) ; 2942 } 2943 Cp $(HEADER_SOURCE_COPY) : $(2) ; 2944 if $(_BUILD_PHASING) = YES { 2945 BUILD_PHASE_PRODUCTS += $(HEADER_SOURCE_COPY) ; 2946 } 2947 } 2948 if build in $(BUILD_COMPONENTS) { 2949 # Scan this header to see if it includes other headers. 2950 if $(ENABLE_HEADER_SCANNING) != NO && $(INDEX_BASED_HEADER_DEPENDENCIES) != YES { 2951 HDRRULE on $(2) = ProcessC.HdrRule ; 2952 HDRSCAN on $(2) = $(HDRPATTERN) ; 2953 } 2954 # Set search path for header so dependence analysis will find it 2955 SEARCH on $(2:D=) += $(2:D) ; 2956 2957 # Clone header to project header directory unless it was derived 2958 if ! $(2) in $(DERIVED_HEADERS) && $(CLONE_HEADERS) = YES { 2959 CloneHeader $(1) : $(2) : $(PROJECT_HEADER_DIR) ; 2960 } 2961 # conditionally generate documentation from headers 2962 if $(GENERATE_HEADERDOC) = YES && $(HEADERDOC_DIR) { 2963 HEADERDOC_TARGET = $(2:B)$(/)toc.html ; 2964 LOCATE on $(HEADERDOC_TARGET) = $(HEADERDOC_DIR) ; 2965 HeaderDoc $(HEADERDOC_TARGET) : $(2) ; 2966 DEPENDS $(HEADERDOC_TARGET) : $(HEADERDOC_DIR) ; 2967 if $(_BUILD_PHASING) = YES { 2968 BUILD_PHASE_PRODUCTS += $(HEADERDOC_TARGET) ; 2969 } 2970 HEADERDOC_TARGETS += $(HEADERDOC_TARGET) ; 2971 } 2972 } 2973 local ATTRIBUTES = $($(2)_ATTRIBUTES) ; 2974 local HEADER_ATTRIBUTE ; 2975 for HEADER_ATTRIBUTE in $(ATTRIBUTES) { 2976 switch $(HEADER_ATTRIBUTE) { 2977 case Project : 2978 # Define option as valid, but take no action 2979 case Public : 2980 HAS_PUBLIC_HEADERS = YES ; 2981 # Create a public header directory 2982 if ! $(PUBLIC_HEADER_DIR) in $(PRODUCT_FILES) { 2983 Mkdir $(PUBLIC_HEADER_DIR) ; 2984 ProductFile $(PUBLIC_HEADER_DIR) ; 2985 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 2986 ASIDE_PUBLIC_HEADER_DIR default = $(PUBLIC_HEADER_DIR:G=aside) ; 2987 Mkdir $(ASIDE_PUBLIC_HEADER_DIR) ; 2988 ProductFileAside $(ASIDE_PUBLIC_HEADER_DIR) ; 2989 } 2990 } 2991 # Create symlink to public header dir in versioned frameworks 2992 if $(PUBLIC_HEADER_LINK) 2993 && ! $(PUBLIC_HEADER_LINK) in $(PRODUCT_FILES) { 2994 SymLink $(PUBLIC_HEADER_LINK) : $(PUBLIC_HEADER_LINK_PATH) ; 2995 DEPENDS $(PUBLIC_HEADER_LINK) : $(PUBLIC_HEADER_DIR) ; 2996 ProductFile $(PUBLIC_HEADER_LINK) ; 2997 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 2998 ASIDE_PUBLIC_HEADER_LINK default = $(PUBLIC_HEADER_LINK:G=aside) ; 2999 SymLink $(ASIDE_PUBLIC_HEADER_LINK) : $(PUBLIC_HEADER_LINK_PATH) ; 3000 DEPENDS $(ASIDE_PUBLIC_HEADER_LINK) : $(ASIDE_PUBLIC_HEADER_DIR) ; 3001 ProductFileAside $(ASIDE_PUBLIC_HEADER_LINK) ; 3002 } 3003 NOUPDATE $(PUBLIC_HEADER_LINK) ; 3004 } 3005 # Public headers get stub "clones" put in the public header dir 3006 if build in $(BUILD_COMPONENTS) && $(CLONE_HEADERS) = YES { 3007 CloneHeader $(1) : $(2) : $(PUBLIC_HEADER_CLONE_DIR) ; 3008 } 3009 if headers in $(BUILD_COMPONENTS) { 3010 if $(PUBLIC_HEADER_DIR) { 3011 local HEADER_COPY = $(PUBLIC_HEADER_DIR)$(/)$(2:BS:G=) ; 3012 #DEPENDS $(PUBLIC_HEADER_DIR:G=populated) : $(2) ; 3013 #PBXCp $(PUBLIC_HEADER_DIR:G=populated) : $(2) ; 3014 #ProductFile $(PUBLIC_HEADER_DIR:G=populated) ; 3015 DEPENDS $(HEADER_COPY) : $(2) ; 3016 PBXCp $(HEADER_COPY) : $(2) ; 3017 ProductFile $(HEADER_COPY) ; 3018 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3019 ASIDE_HEADER_COPY = $(HEADER_COPY:G=aside) ; 3020 #DEPENDS $(ASIDE_PUBLIC_HEADER_DIR:G=aside-populated) : $(2) ; 3021 #PBXCp $(ASIDE_PUBLIC_HEADER_DIR:G=aside-populated) : $(2) ; 3022 #ProductFileAside $(ASIDE_PUBLIC_HEADER_DIR:G=aside-populated) ; 3023 DEPENDS $(ASIDE_HEADER_COPY) : $(2) ; 3024 PBXCp $(ASIDE_HEADER_COPY) : $(2) ; 3025 ProductFileAside $(ASIDE_HEADER_COPY) ; 3026 } 3027 } 3028 else { 3029 ECHO warning: public header $(2) ignored because PUBLIC_HEADER_DIR has no value ; 3030 } 3031 } 3032 case Private : 3033 HAS_PRIVATE_HEADERS = YES ; 3034 # create a private header directory 3035 if ! $(PRIVATE_HEADER_DIR) in $(PRODUCT_FILES) { 3036 Mkdir $(PRIVATE_HEADER_DIR) ; 3037 ProductFile $(PRIVATE_HEADER_DIR) ; 3038 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3039 ASIDE_PRIVATE_HEADER_DIR default = $(PRIVATE_HEADER_DIR:G=aside) ; 3040 Mkdir $(ASIDE_PRIVATE_HEADER_DIR) ; 3041 ProductFileAside $(ASIDE_PRIVATE_HEADER_DIR) ; 3042 } 3043 } 3044 # accompanying link in versioned frameworks 3045 if $(PRIVATE_HEADER_LINK) 3046 && ! $(PRIVATE_HEADER_LINK) in $(PRODUCT_FILES) { 3047 SymLink $(PRIVATE_HEADER_LINK) : $(PRIVATE_HEADER_LINK_PATH) ; 3048 DEPENDS $(PRIVATE_HEADER_LINK) : $(PRIVATE_HEADER_DIR) ; 3049 ProductFile $(PRIVATE_HEADER_LINK) ; 3050 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3051 ASIDE_PRIVATE_HEADER_LINK default = $(PRIVATE_HEADER_LINK:G=aside) ; 3052 SymLink $(ASIDE_PRIVATE_HEADER_LINK) : $(PRIVATE_HEADER_LINK_PATH) ; 3053 DEPENDS $(ASIDE_PRIVATE_HEADER_LINK) : $(ASIDE_PRIVATE_HEADER_DIR) ; 3054 ProductFileAside $(ASIDE_PRIVATE_HEADER_LINK) ; 3055 } 3056 NOUPDATE $(PRIVATE_HEADER_LINK) ; 3057 } 3058 # Private headers get stub "clones" put in private header dir 3059 if build in $(BUILD_COMPONENTS) && $(CLONE_HEADERS) = YES { 3060 CloneHeader $(1) : $(2) : $(PRIVATE_HEADER_CLONE_DIR) ; 3061 } 3062 if headers in $(BUILD_COMPONENTS) { 3063 if $(PRIVATE_HEADER_DIR) { 3064 local HEADER_COPY = $(PRIVATE_HEADER_DIR)$(/)$(2:BS:G=) ; 3065 #DEPENDS $(PRIVATE_HEADER_DIR:G=populated) : $(2) ; 3066 #PBXCp $(PRIVATE_HEADER_DIR:G=populated) : $(2) ; 3067 #ProductFile $(PRIVATE_HEADER_DIR:G=populated) ; 3068 DEPENDS $(HEADER_COPY) : $(2) ; 3069 PBXCp $(HEADER_COPY) : $(2) ; 3070 ProductFile $(HEADER_COPY) ; 3071 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3072 ASIDE_HEADER_COPY = $(HEADER_COPY:G=aside) ; 3073 #DEPENDS $(ASIDE_PRIVATE_HEADER_DIR:G=aside-populated) : $(2) ; 3074 #PBXCp $(ASIDE_PRIVATE_HEADER_DIR:G=aside-populated) : $(2) ; 3075 #ProductFileAside $(ASIDE_PRIVATE_HEADER_DIR:G=aside-populated) ; 3076 DEPENDS $(ASIDE_HEADER_COPY) : $(2) ; 3077 PBXCp $(ASIDE_HEADER_COPY) : $(2) ; 3078 ProductFileAside $(ASIDE_HEADER_COPY) ; 3079 } 3080 } 3081 else { 3082 ECHO warning: private header $(2) ignored because PRIVATE_HEADER_DIR has no value ; 3083 } 3084 } 3085 case * : 3086 if $(HEADER_ATTRIBUTE) != AbsolutePath { 3087 ECHO jam: warning: Ignoring unknown header attribute $(HEADER_ATTRIBUTE) ; 3088 } 3089 } 3090 } 3091} 3092 3093rule PrecompileHeader 3094{ 3095 DEPENDS $(1) : $(2) ; 3096 if $(KERNEL_MODULE) = YES { 3097 local KERNEL_FRAMEWORK = $(SYSTEM_LIBRARY_DIR)/Frameworks/Kernel.framework ; 3098 local KERNEL_HEADERS = $(KERNEL_FRAMEWORK)/Headers ; 3099 local KERNEL_INCLUDE_PATHS = $(KERNEL_HEADERS) $(KERNEL_HEADERS)/bsd $(KERNEL_FRAMEWORK)/PrivateHeaders ; 3100 local KERNEL_COMPILE_OPTIONS = -fno-builtin -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float ; 3101 local KERNEL_DEFINITIONS = -DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE -DNeXT ; 3102 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -nostdinc $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) $(OTHER_CFLAGS) -I$(KERNEL_INCLUDE_PATHS) -I$(PROJECT_HEADER_DIR) $(KERNEL_COMPILE_OPTIONS) -static $(KERNEL_DEFINITIONS) ; 3103 GLOBAL_CFLAGS on $(1) = ; 3104 if $(ARCH) in ppc { 3105 KERNEL_COMPILE_OPTIONS += -mlong-branch ; 3106 } 3107 } 3108 else { 3109 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -fpascal-strings $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) ; # We must compile with the extension-specific build flags 3110 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Application { 3111 USE_DYNAMIC_NO_PIC default = YES ; 3112 } else { 3113 USE_DYNAMIC_NO_PIC default = NO ; 3114 } 3115 if $(USE_DYNAMIC_NO_PIC) = YES { 3116 FLAGS on $(1) += -mdynamic-no-pic ; 3117 } 3118 FLAGS on $(1) += $(OTHER_CFLAGS) ; 3119 } 3120 FLAGS on $(1) += -pipe ; 3121 if ( $(USE_GCC3) = YES ) { 3122 FLAGS on $(1) += -fmessage-length=0 ; 3123 } 3124 # seed search paths with target-wide values 3125 HEADER_SEARCH_PATHS on $(1) = $(HEADER_SEARCH_PATHS) ; 3126 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 3127 # extension-specific build flags 3128 FLAGS on $(1) += $($(2:S)_CFLAGS) ; 3129 # Add debug flags, if appropriate. 3130 if $(DEBUGGING_SYMBOLS) = YES { 3131 FLAGS on $(1) += -g ; 3132 } 3133 # Add profiling flags, if appropriate. 3134 if $(PROFILING_CODE) = YES { 3135 FLAGS on $(1) += -pg ; 3136 } 3137 if $(OS) in MACOS DARWIN { 3138 FLAGS on $(1) += -precomp-trustfile $(PRECOMP_TRUSTFILE) ; 3139 } 3140 if $(CPP_HEADERMAP_FILE) { 3141 FLAGS on $(1) += "-Wp,-header-mapfile,$(CPP_HEADERMAP_FILE)" ; 3142 } 3143 if $(1:S) = .pp { 3144 # Hack: gcc3 doesn't support Objective-C++ yet (as of dec 10 2001) 3145 if $(USE_GCC3) = YES { 3146 FLAGS on $(1) += -x c++ ; 3147 } 3148 else { 3149 FLAGS on $(1) += -x objective-c++ ; 3150 } 3151 } 3152 if YES in $(GENERATE_CPP_ILOG_FILES) { 3153 local INCLUSION_LOG_FILE default = $(TEMP_DIR)$(/)ImplicitHeaderPrecompile$(ARCH)$(/)$(2:DB).ilog ; 3154 FLAGS on $(1) += "-Wp,-inclusion-log-file,$(INCLUSION_LOG_FILE)" ; 3155 } 3156 Mkdir $(PRECOMP_DESTINATION_DIR) ; 3157 DEPENDS $(1) : $(PRECOMP_DESTINATION_DIR) ; 3158 SEARCH on $(2) = $(SOURCE_ROOT) ; 3159} 3160actions PrecompileHeader 3161{ 3162 $(CC) -precomp -o "$(1)" "-F$(FRAMEWORK_SEARCH_PATHS)" "-I$(HEADER_SEARCH_PATHS)" $(ARCH_FLAGS) "$(FLAGS)" $(GLOBAL_CFLAGS) "-I$(DERIVED_PATHS)" "-I$(SOURCE_ROOT)" "$(PREFIX_HEADER_CFLAGS)" "$(OTHER_PRECOMP_CFLAGS)" "$(2)" 3163} 3164 3165rule MakePFEFile 3166{ 3167 DEPENDS $(1) : $(2) ; 3168 if $(KERNEL_MODULE) = YES { 3169 local KERNEL_FRAMEWORK = $(SYSTEM_LIBRARY_DIR)/Frameworks/Kernel.framework ; 3170 local KERNEL_HEADERS = $(KERNEL_FRAMEWORK)/Headers ; 3171 local KERNEL_INCLUDE_PATHS = $(KERNEL_HEADERS) $(KERNEL_HEADERS)/bsd $(KERNEL_FRAMEWORK)/PrivateHeaders ; 3172 local KERNEL_COMPILE_OPTIONS = -fno-builtin -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float ; 3173 if $(ARCH) in ppc { 3174 KERNEL_COMPILE_OPTIONS += -mlong-branch ; 3175 } 3176 KERNEL_COMPILE_OPTIONS += -fapple-kext ; 3177 local KERNEL_DEFINITIONS = -DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE -DNeXT ; 3178 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -nostdinc $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) $(OTHER_CFLAGS) -I$(KERNEL_INCLUDE_PATHS) -I$(PROJECT_HEADER_DIR) $(KERNEL_COMPILE_OPTIONS) -static $(KERNEL_DEFINITIONS) ; 3179 GLOBAL_CFLAGS on $(1) = ; 3180 } 3181 else { 3182 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -fpascal-strings $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) ; # We must compile with the extension-specific build flags 3183 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Application { 3184 USE_DYNAMIC_NO_PIC default = YES ; 3185 } else { 3186 USE_DYNAMIC_NO_PIC default = NO ; 3187 } 3188 if $(USE_DYNAMIC_NO_PIC) = YES { 3189 FLAGS on $(1) += -mdynamic-no-pic ; 3190 } 3191 FLAGS on $(1) += $(OTHER_CFLAGS) ; 3192 } 3193 FLAGS on $(1) += -pipe ; 3194 if $(USE_GCC3) = YES { 3195 FLAGS on $(1) += -fmessage-length=0 ; 3196 } 3197 # seed search paths with target-wide values 3198 HEADER_SEARCH_PATHS on $(1) = $(HEADER_SEARCH_PATHS) ; 3199 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 3200 # extension-specific build flags 3201 FLAGS on $(1) += $($(2:S)_CFLAGS) ; 3202 # Add debug flags, if appropriate. 3203 if $(DEBUGGING_SYMBOLS) = YES { 3204 FLAGS on $(1) += -g ; 3205 } 3206 # Add profiling flags, if appropriate. 3207 if $(PROFILING_CODE) = YES { 3208 FLAGS on $(1) += -pg ; 3209 } 3210 if $(CPP_HEADERMAP_FILE) { 3211 FLAGS on $(1) += "-Wp,-header-mapfile,$(CPP_HEADERMAP_FILE)" ; 3212 } 3213 if YES in $(GENERATE_CPP_ILOG_FILES) { 3214 local INCLUSION_LOG_FILE default = $(OBJECT_FILE_DIR)-$(VARIANT)$(/)$(ARCH)$(/)$(2:DB).ilog ; 3215 FLAGS on $(1) += "-Wp,-inclusion-log-file,$(INCLUSION_LOG_FILE)" ; 3216 } 3217 ARCH on $(1) = $(ARCH) ; 3218 Mkdir $(PRECOMP_DESTINATION_DIR) ; 3219 DEPENDS $(1) : $(PRECOMP_DESTINATION_DIR) ; 3220 SEARCH on $(2) = $(SOURCE_ROOT) ; 3221} 3222actions MakePFEFile 3223{ 3224 for c_dialect in $(PFE_FILE_C_DIALECTS) ; do dummy_file=`mktemp /tmp/.null-XXXXXXXX`; $(CC:Q) -c -x ${c_dialect} -F$(FRAMEWORK_SEARCH_PATHS:Q) -I$(HEADER_SEARCH_PATHS:Q) "$(FLAGS)" $(GLOBAL_CFLAGS) -I$(DERIVED_PATHS:Q) -I$(SOURCE_ROOT:Q) $(PREFIX_HEADER_CFLAGS:Q) $(OTHER_PRECOMP_CFLAGS:Q) $(2:Q) -o ${dummy_file} --dump-pch $(1:Q) ; exit_code=$? ; rm ${dummy_file} ; if [ ${exit_code} != 0 ] ; then exit ${exit_code} ; fi ; done 3225} 3226 3227 3228# ProcessResources <product> <bundle resources> 3229# 3230# Process individual resource files, copy property list settings file, 3231# and write the package info file if appropriate. 3232rule ProcessResources 3233{ 3234 if ( build in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) ) 3235 && ( $(ARCHS) || $(NULL_BUILD_IF_NO_VALID_ARCH) != YES ) { 3236 local FILE ; 3237 if $(_BUILD_PHASING) = YES { 3238 PhaseTarget BUILD_PHASE : $(1) : CopyResources ; 3239 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 3240 BUILD_PHASE_PRODUCTS = ; 3241 } 3242 for FILE in $(2) { 3243 if $(_BUILD_PHASING) = YES { 3244 ProcessResource $(BUILD_PHASE) : $(FILE) ; 3245 } 3246 else { 3247 ProcessResource $(1) : $(FILE) ; 3248 } 3249 } 3250 # product settings, version settings, and package info written only during build 3251 if build in $(BUILD_COMPONENTS) { 3252 # product settings property list 3253 if $(_INFO_PLIST_FILE_PATH) 3254 && $(PURE_JAVA) != YES { 3255 # if available and not pure java 3256 if $(PRODUCT_TYPE) = Framework { 3257 INFO_PLIST_FILE default = $(RESOURCE_DIR)$(/)Info.plist ; 3258 if ! $(RESOURCE_DIR) in $(PRODUCT_FILES) { 3259 Mkdir $(RESOURCE_DIR) ; 3260 ProductFile $(RESOURCE_DIR) ; 3261 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3262 ASIDE_RESOURCE_DIR default = $(RESOURCE_DIR:G=aside) ; 3263 Mkdir $(ASIDE_RESOURCE_DIR) ; 3264 ProductFileAside $(ASIDE_RESOURCE_DIR) ; 3265 } 3266 } 3267 DEPENDS $(INFO_PLIST_FILE) : $(RESOURCE_DIR) ; 3268 if $(RESOURCE_LINK) 3269 && ! $(RESOURCE_LINK) in $(PRODUCT_FILES) { 3270 SymLink $(RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3271 ProductFile $(RESOURCE_LINK) ; 3272 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3273 ASIDE_RESOURCE_LINK default = $(RESOURCE_LINK:G=aside) ; 3274 SymLink $(ASIDE_RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3275 ProductFileAside $(ASIDE_RESOURCE_LINK) ; 3276 } 3277 } 3278 DEPENDS $(INFO_PLIST_FILE) : $(RESOURCE_LINK) ; 3279 } 3280 else { 3281 if $(BUNDLE_STYLE) = SHALLOW { 3282 INFO_PLIST_FILE default = $(1:G=)$(/)Info.plist ; 3283 } 3284 else { 3285 INFO_PLIST_FILE default = $(1:G=)$(/)Contents$(/)Info.plist ; 3286 } 3287 INFO_PLIST_DIR = $(INFO_PLIST_FILE:D) ; 3288 if ! $(INFO_PLIST_DIR) in $(PRODUCT_FILES) { 3289 Mkdir $(INFO_PLIST_DIR) ; 3290 ProductFile $(INFO_PLIST_DIR) ; 3291 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3292 ASIDE_INFO_PLIST_DIR default = $(INFO_PLIST_DIR:G=aside) ; 3293 Mkdir $(ASIDE_INFO_PLIST_DIR) ; 3294 ProductFileAside $(ASIDE_INFO_PLIST_DIR) ; 3295 } 3296 } 3297 DEPENDS $(INFO_PLIST_FILE) : $(INFO_PLIST_DIR) ; 3298 } 3299 Cp $(INFO_PLIST_FILE) : $(_INFO_PLIST_FILE_PATH) ; 3300 ProductFile $(INFO_PLIST_FILE) ; 3301 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3302 ASIDE_INFO_PLIST_FILE default = $(INFO_PLIST_FILE:G=aside) ; 3303 DEPENDS $(ASIDE_INFO_PLIST_FILE) : $(ASIDE_INFO_PLIST_DIR) ; 3304 Cp $(ASIDE_INFO_PLIST_FILE) : $(PRODUCT_SETTINGS_PATH) ; 3305 ProductFileAside $(ASIDE_INFO_PLIST_FILE) ; 3306 } 3307 } 3308 # version settings property list 3309 if $(_VERSION_PLIST_FILE_PATH) 3310 && $(PURE_JAVA) != YES { 3311 # if available and not pure java 3312 if $(PRODUCT_TYPE) = Framework { 3313 VERSION_PLIST_FILE default = $(RESOURCE_DIR)$(/)version.plist ; 3314 if ! $(RESOURCE_DIR) in $(PRODUCT_FILES) { 3315 Mkdir $(RESOURCE_DIR) ; 3316 ProductFile $(RESOURCE_DIR) ; 3317 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3318 ASIDE_RESOURCE_DIR default = $(RESOURCE_DIR:G=aside) ; 3319 Mkdir $(ASIDE_RESOURCE_DIR) ; 3320 ProductFileAside $(ASIDE_RESOURCE_DIR) ; 3321 } 3322 } 3323 DEPENDS $(VERSION_PLIST_FILE) : $(RESOURCE_DIR) ; 3324 # create accompanying link in the case of versioned frameworks 3325 if $(RESOURCE_LINK) 3326 && ! $(RESOURCE_LINK) in $(PRODUCT_FILES) { 3327 SymLink $(RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3328 ProductFile $(RESOURCE_LINK) ; 3329 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3330 ASIDE_RESOURCE_LINK default = $(RESOURCE_LINK:G=aside) ; 3331 DEPENDS $(ASIDE_RESOURCE_LINK) : $(ASIDE_RESOURCE_DIR) ; 3332 SymLink $(ASIDE_RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3333 ProductFileAside $(ASIDE_RESOURCE_LINK) ; 3334 } 3335 } 3336 DEPENDS $(VERSION_PLIST_FILE) : $(RESOURCE_LINK) ; 3337 } 3338 else { 3339 if $(BUNDLE_STYLE) = SHALLOW { 3340 VERSION_PLIST_FILE default = $(1:G=)$(/)Contents$(/)version.plist ; 3341 } 3342 else { 3343 VERSION_PLIST_FILE default = $(1:G=)$(/)Contents$(/)version.plist ; 3344 } 3345 VERSION_PLIST_DIR = $(VERSION_PLIST_FILE:D) ; 3346 if ! $(VERSION_PLIST_DIR) in $(PRODUCT_FILES) { 3347 Mkdir $(VERSION_PLIST_DIR) ; 3348 ProductFile $(VERSION_PLIST_DIR) ; 3349 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3350 ASIDE_VERSION_PLIST_DIR default = $(VERSION_PLIST_DIR) ; 3351 Mkdir $(ASIDE_VERSION_PLIST_DIR) ; 3352 ProductFileAside $(ASIDE_VERSION_PLIST_DIR) ; 3353 } 3354 } 3355 DEPENDS $(VERSION_PLIST_FILE) : $(VERSION_PLIST_DIR) ; 3356 } 3357 Cp $(VERSION_PLIST_FILE) : $(_VERSION_PLIST_FILE_PATH) ; 3358 ProductFile $(VERSION_PLIST_FILE) ; 3359 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3360 ASIDE_VERSION_PLIST_FILE default = $(VERSION_PLIST_FILE:G=aside) ; 3361 Cp $(ASIDE_VERSION_PLIST_FILE) : $(VERSION_PLIST_FILE) ; 3362 DEPENDS $(ASIDE_VERSION_PLIST_FILE) : $(ASIDE_VERSION_PLIST_DIR) ; 3363 ProductFileAside $(ASIDE_VERSION_PLIST_FILE) ; 3364 } 3365 } 3366 # development settings property list 3367 # This plist gets copied into the bundle if we are doing a development build or removed from the symroot otherwise. Right now, "development build" means that the ACTION is "build" (as opposed to "install"). 3368 if $(DEVELOPMENT_SETTINGS_PATH) 3369 && $(PURE_JAVA) != YES && $(ACTION) = build { 3370 # if available and not pure java 3371 if $(PRODUCT_TYPE) = Framework { 3372 DEVELOPMENT_PLIST_FILE default = $(RESOURCE_DIR)$(/)pbdevelopment.plist ; 3373 if ! $(RESOURCE_DIR) in $(PRODUCT_FILES) { 3374 Mkdir $(RESOURCE_DIR) ; 3375 ProductFile $(RESOURCE_DIR) ; 3376 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3377 ASIDE_RESOURCE_DIR default = $(RESOURCE_DIR:G=aside) ; 3378 Mkdir $(ASIDE_RESOURCE_DIR) ; 3379 ProductFileAsides $(ASIDE_RESOURCE_DIR) ; 3380 } 3381 } 3382 DEPENDS $(DEVELOPMENT_PLIST_FILE) : $(RESOURCE_DIR) ; 3383 # create accompanying link in the case of versioned frameworks 3384 if $(RESOURCE_LINK) 3385 && ! $(RESOURCE_LINK) in $(PRODUCT_FILES) { 3386 SymLink $(RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3387 ProductFile $(RESOURCE_LINK) ; 3388 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3389 ASIDE_RESOURCE_LINK default = $(RESOURCE_LINK:G=aside) ; 3390 SymLink $(ASIDE_RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3391 DEPENDS $(ASIDE_RESOURCE_LINK) : $(ASIDE_RESOURCE_DIR) ; 3392 ProductFileAside $(ASIDE_RESOURCE_LINK) ; 3393 } 3394 } 3395 DEPENDS $(DEVELOPMENT_PLIST_FILE) : $(RESOURCE_LINK) ; 3396 } 3397 else { 3398 if $(BUNDLE_STYLE) = SHALLOW { 3399 DEVELOPMENT_PLIST_FILE default = $(1:G=)$(/)pbdevelopment.plist ; 3400 } 3401 else { 3402 DEVELOPMENT_PLIST_FILE default = $(1:G=)$(/)Contents$(/)pbdevelopment.plist ; 3403 } 3404 DEVELOPMENT_PLIST_DIR = $(DEVELOPMENT_PLIST_FILE:D) ; 3405 if ! $(DEVELOPMENT_PLIST_DIR) in $(PRODUCT_FILES) { 3406 Mkdir $(DEVELOPMENT_PLIST_DIR) ; 3407 ProductFile $(DEVELOPMENT_PLIST_DIR) ; 3408 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3409 ASIDE_DEVELOPMENT_PLIST_DIR default = $(DEVELOPMENT_PLIST_DIR:G=aside) ; 3410 Mkdir $(ASIDE_DEVELOPMENT_PLIST_DIR) ; 3411 ProductFileAsides $(ASIDE_DEVELOPMENT_PLIST) ; 3412 } 3413 } 3414 DEPENDS $(DEVELOPMENT_PLIST_FILE) : $(DEVELOPMENT_PLIST_DIR) ; 3415 } 3416 Cp $(DEVELOPMENT_PLIST_FILE) : $(DEVELOPMENT_SETTINGS_PATH) ; 3417 ProductFile $(DEVELOPMENT_PLIST_FILE) ; 3418 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3419 ASIDE_DEVELOPMENT_PLIST_FILE default = $(DEVELOPMENT_PLIST_FILE:G=aside) ; 3420 Cp $(ASIDE_DEVELOPMENT_PLIST_FILE) : $(DEVELOPMENT_SETTINGS_PATH) ; 3421 DEPENDS $(ASIDE_DEVELOPMENT_PLIST_FILE) : $(DEVELOPMENT_PLIST_DIR) ; 3422 ProductFileAside $(ASIDE_DEVELOPMENT_PLIST_FILE) ; 3423 } 3424 } 3425 # Write package info file with type and creator if available 3426 # and if not framework or oldest layout or pure java 3427 if $(_PKGINFO_FILE_PATH) 3428 && ( $(PRODUCT_TYPE) != Framework 3429 && $(PRODUCT_TYPE) != Bundle 3430 && $(PURE_JAVA) != YES || $(GENERATE_PKGINFO_FILE) = YES ) { 3431 if $(BUNDLE_STYLE) = SHALLOW || $(PRODUCT_TYPE) = Framework { 3432 PKGINFO_FILE default = $(1:G=)$(/)PkgInfo ; 3433 } 3434 else { 3435 PKGINFO_FILE default = $(1:G=)$(/)Contents$(/)PkgInfo ; 3436 } 3437 PKGINFO_DIR = $(PKGINFO:D) ; 3438 if ! $(PKGINFO_DIR) in $(PRODUCT_FILES) { 3439 Mkdir $(PKGINFO_DIR) ; 3440 ProductFile $(PKGINFO_DIR) ; 3441 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATIN) = YES { 3442 ASIDE_PKGINFO_DIR default = $(PKGINFO_DIR:G=aside) ; 3443 Mkdir $(ASIDE_PKGINFO_DIR) ; 3444 ProductFileAside $(ASIDE_PKGINFO_DIR) ; 3445 } 3446 } 3447 Cp $(PKGINFO_FILE) : $(_PKGINFO_FILE_PATH) ; 3448 ProductFile $(PKGINFO_FILE) ; 3449 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3450 ASIDE_PKGINFO_FILE default = $(PKGINFO_FILE:G=aside) ; 3451 DEPENDS $(ASIDE_PKGINFO_FILE) : $(ASIDE_PKGINFO_DIR) ; 3452 Cp $(ASIDE_PKGINFO_FILE) : $(_PKGINFO_FILE_PATH) ; 3453 ProductFileAside $(ASIDE_PKGINFO_FILE) ; 3454 } 3455 } 3456 } 3457 if $(_BUILD_PHASING) = YES { 3458 if $(BUILD_PHASE_PRODUCTS) { 3459 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 3460 } 3461 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 3462 } 3463 } 3464} 3465 3466# ProcessResource <product or phase> <bundle resource> 3467# 3468# Copies resources to nonlocalized or localized folders as appropriate 3469rule ProcessResource 3470{ 3471 if source in $(BUILD_COMPONENTS) { 3472 local RESOURCE_SOURCE_COPY ; 3473 local RESOURCE_SOURCE_DIR ; 3474 # make directory first if necessary 3475 if $(2:D) { 3476 RESOURCE_SOURCE_DIR = $(SOURCE_DIR)/$(2:D:G=) ; 3477 Mkdir $(RESOURCE_SOURCE_DIR) ; 3478 RESOURCE_SOURCE_COPY = $(RESOURCE_SOURCE_DIR)/$(2:D=:G=) ; 3479 DEPENDS $(RESOURCE_SOURCE_COPY) : $(RESOURCE_SOURCE_DIR) ; 3480 } 3481 else { 3482 RESOURCE_SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 3483 DEPENDS $(RESOURCE_SOURCE_COPY) : $(SOURCE_DIR) ; 3484 Mkdir $(SOURCE_DIR) ; 3485 } 3486 # copy resource to source location 3487 Cp $(RESOURCE_SOURCE_COPY) : $(2) ; 3488 if $(_BUILD_PHASING) = YES { 3489 BUILD_PHASE_PRODUCTS += $(RESOURCE_SOURCE_COPY) ; 3490 } 3491 } 3492 if build in $(BUILD_COMPONENTS) { 3493 local REGION = $($(2)_REGION) ; 3494 local SPECIFIC_REGION ; 3495 # resource directory must exist 3496 if ! $(RESOURCE_DIR) in $(PRODUCT_FILES) { 3497 Mkdir $(RESOURCE_DIR) ; 3498 ProductFile $(RESOURCE_DIR) ; 3499 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3500 ASIDE_RESOURCE_DIR default = $(RESOURCE_DIR:G=aside) ; 3501 Mkdir $(ASIDE_RESOURCE_DIR) ; 3502 ProductFileAside $(ASIDE_RESOURCE_DIR) ; 3503 } 3504 } 3505 # create accompanying link in the case of versioned frameworks 3506 if $(RESOURCE_LINK) 3507 && ! $(RESOURCE_LINK) in $(PRODUCT_FILES) { 3508 SymLink $(RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3509 ProductFile $(RESOURCE_LINK) ; 3510 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3511 ASIDE_RESOURCE_LINK default = $(RESOURCE_LINK:G=aside) ; 3512 SymLink $(ASIDE_RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 3513 DEPENDS $(ASIDE_RESOURCE_LINK) : $(ASIDE_RESOURCE_DIR) ; 3514 ProductFileAside $(ASIDE_RESOURCE_LINK) ; 3515 } 3516 } 3517 if ! $(REGION) 3518 || ( $(BUNDLE_STYLE) = SHALLOW && $(REGION) = $(DEVELOPMENT_LANGUAGE) ) { 3519 # non-localized resource 3520 # or development language resource for shallow bundle 3521 local NONLOCALIZED_RESOURCE_DIR NONLOCALIZED_RESOURCE ; 3522 NONLOCALIZED_RESOURCE_DIR = $(RESOURCE_DIR) ; 3523 if ! $(NONLOCALIZED_RESOURCE_DIR) in $(PRODUCT_FILES) { 3524 Mkdir $(NONLOCALIZED_RESOURCE_DIR) ; 3525 ProductFile $(NONLOCALIZED_RESOURCE_DIR) ; 3526 } 3527 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3528 ASIDE_NONLOCALIZED_RESOURCE_DIR = $(NONLOCALIZED_RESOURCE_DIR:G=aside) ; 3529 if ! $(ASIDE_NONLOCALIZED_RESOURCE_DIR) in $(PRODUCT_FILES) { 3530 Mkdir $(ASIDE_NONLOCALIZED_RESOURCE_DIR) ; 3531 ProductFileAside $(ASIDE_NONLOCALIZED_RESOURCE_DIR) ; 3532 } 3533 } 3534 NONLOCALIZED_RESOURCE = $(NONLOCALIZED_RESOURCE_DIR)$(/)$(2:BS) ; 3535 #DEPENDS $(NONLOCALIZED_RESOURCE_DIR:G=populated) : $(2) ; 3536 #PBXCp $(NONLOCALIZED_RESOURCE_DIR:G=populated) : $(2) ; 3537 #ProductFile $(NONLOCALIZED_RESOURCE_DIR:G=populated) ; 3538 DEPENDS $(NONLOCALIZED_RESOURCE) : $(2) ; 3539 PBXCp $(NONLOCALIZED_RESOURCE) : $(2) ; 3540 ProductFile $(NONLOCALIZED_RESOURCE) ; 3541 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3542 ASIDE_NONLOCALIZED_RESOURCE = $(NONLOCALIZED_RESOURCE:G=aside) ; 3543 #DEPENDS $(ASIDE_NONLOCALIZED_RESOURCE_DIR:G=aside-populated) : $(2) ; 3544 #PBXCp $(ASIDE_NONLOCALIZED_RESOURCE_DIR:G=aside-populated) : $(2) ; 3545 #ProductFileAside $(ASIDE_NONLOCALIZED_RESOURCE_DIR:G=aside-populated) ; 3546 DEPENDS $(ASIDE_NONLOCALIZED_RESOURCE) : $(2) ; 3547 PBXCp $(ASIDE_NONLOCALIZED_RESOURCE) : $(2) ; 3548 ProductFileAside $(ASIDE_NONLOCALIZED_RESOURCE) ; 3549 } 3550 } else for SPECIFIC_REGION in $(REGION) { 3551 # for each localization of a resource (only one ever expected) 3552 local LOCALIZED_RESOURCE_DIR LOCALIZED_RESOURCE ; 3553 LOCALIZED_RESOURCE_DIR = $(RESOURCE_DIR)$(/)$(SPECIFIC_REGION:S=.lproj) ; 3554 # localized resource directory must exist 3555 if ! $(LOCALIZED_RESOURCE_DIR) in $(PRODUCT_FILES) { 3556 Mkdir $(LOCALIZED_RESOURCE_DIR) ; 3557 ProductFile $(LOCALIZED_RESOURCE_DIR) ; 3558 } 3559 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3560 ASIDE_LOCALIZED_RESOURCE_DIR = $(LOCALIZED_RESOURCE_DIR:G=aside) ; 3561 if ! $(ASIDE_LOCALIZED_RESOURCE_DIR) in $(PRODUCT_FILES) { 3562 Mkdir $(ASIDE_LOCALIZED_RESOURCE_DIR) ; 3563 ProductFileAside $(ASIDE_LOCALIZED_RESOURCE_DIR) ; 3564 } 3565 } 3566 LOCALIZED_RESOURCE = $(LOCALIZED_RESOURCE_DIR)$(/)$(2:BS) ; 3567 #DEPENDS $(LOCALIZED_RESOURCE_DIR:G=populated) : $(2) ; 3568 #PBXCp $(LOCALIZED_RESOURCE_DIR:G=populated) : $(2) ; 3569 #ProductFile $(LOCALIZED_RESOURCE_DIR:G=populated) ; 3570 DEPENDS $(LOCALIZED_RESOURCE) : $(2) ; 3571 PBXCp $(LOCALIZED_RESOURCE) : $(2) ; 3572 ProductFile $(LOCALIZED_RESOURCE) ; 3573 if $(INSTALLED_PRODUCT_ASIDES) = YES && $(DEPLOYMENT_LOCATION) = YES { 3574 ASIDE_LOCALIZED_RESOURCE = $(LOCALIZED_RESOURCE:G=aside) ; 3575 #DEPENDS $(ASIDE_LOCALIZED_RESOURCE_DIR:G=aside-populated) : $(2) ; 3576 #PBXCp $(ASIDE_LOCALIZED_RESOURCE_DIR:G=aside-populated) : $(2) ; 3577 #ProductFileAside $(ASIDE_LOCALIZED_RESOURCE_DIR:G=aside-populated) ; 3578 DEPENDS $(ASIDE_LOCALIZED_RESOURCE) : $(2) ; 3579 PBXCp $(ASIDE_LOCALIZED_RESOURCE) : $(2) ; 3580 ProductFileAside $(ASIDE_LOCALIZED_RESOURCE) ; 3581 } 3582 } 3583 } 3584} 3585 3586actions CopyProjectFiles 3587{ 3588 if [ -d $(2) ]; then 3589 $(CP) -pRP $(2) $(1) 3590 elif [ -d $(2:S=.pbxproj) ]; then 3591 $(CP) -pRP $(2:S=.pbxproj) $(1) 3592 fi 3593} 3594 3595# ProcessSources <product> <source files> 3596# 3597# Process individual source files and generate versioning stub, 3598# kernel module stub, and use Interfacer to make exports and glue 3599rule ProcessSources 3600{ 3601 if build in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) { 3602 local FILE ; 3603 if $(_BUILD_PHASING) = YES { 3604 PhaseTarget BUILD_PHASE : $(1) : DeriveAndCompileSources ; 3605 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 3606 BUILD_PHASE_PRODUCTS = ; 3607 } 3608 # copy project files if copying source 3609 if source in $(BUILD_COMPONENTS) { 3610 local PROJECT_FILES = $(SOURCE_ROOT)/$(PROJECT).pbproj ; 3611 local LEGACY_PROJECT_FILES = $(SOURCE_ROOT)/$(PROJECT).pbxproj ; 3612 local PROJECT_FILES_COPY = $(INSTALL_ROOT)/$(PROJECT).pbproj ; 3613 CopyProjectFiles $(PROJECT_FILES_COPY) : $(PROJECT_FILES) : $(LEGACY_PROJECT_FILES) ; 3614 DEPENDS $(PROJECT_FILES_COPY) : $(INSTALL_ROOT) ; 3615 Mkdir $(INSTALL_ROOT) ; 3616 DEPENDS $(PROJECT_FILES_COPY) : $(PROJECT_FILES) ; 3617 NOCARE $(PROJECT_FILES) ; 3618 DEPENDS $(PROJECT_FILES_COPY) : $(LEGACY_PROJECT_FILES) ; 3619 NOCARE $(LEGACY_PROJECT_FILES) ; 3620 BUILD_PHASE_PRODUCTS += $(PROJECT_FILES_COPY) ; 3621 } 3622 for FILE in $(2) { 3623 if $(_BUILD_PHASING) = YES { 3624 ProcessSource $(BUILD_PHASE) : $(FILE) ; 3625 } 3626 else { 3627 ProcessSource $(1) : $(FILE) ; 3628 } 3629 } 3630 # any build component implies handling: header cloning, versioning, 3631 # kernel module generation, and interfacer usage 3632 if build in $(BUILD_COMPONENTS) { 3633 # generate versioning system derived sources 3634 if $(VERSIONING_SYSTEM) { 3635 local RULE = VersioningSystem_$(VERSIONING_SYSTEM) ; 3636 $(RULE) $(1) ; 3637 } 3638 # generate kernel module or extension info source 3639 if $(KERNEL_MODULE) = YES { 3640 KernelModuleGeneratedSource $(1) ; 3641 } 3642 # generate interfacer derived sources 3643 if $(GENERATE_EXPORT_SETS_AND_GLUE) = YES { 3644 InterfacerExportSetsAndGlue $(1) ; 3645 } 3646 } 3647 if $(_BUILD_PHASING) = YES { 3648 if $(BUILD_PHASE_PRODUCTS) { 3649 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 3650 # product reference link must be in place before any compiles 3651 if $(PRODUCT_REFERENCE) { 3652 DEPENDS $(BUILD_PHASE_PRODUCTS) : $(PRODUCT_REFERENCE) ; 3653 } 3654 } 3655 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 3656 } 3657 # Actually copy headers (over clones) only when compiles are finished 3658 } 3659} 3660 3661# ProcessSource <product> <source file> 3662# 3663# Call ProcessFile to process a source file with the correct 3664# extension-specific rule, and start header scanning. 3665rule ProcessSource 3666{ 3667 # scan non-Java for header file references in any source 3668 if $(2:S) != ".java" { 3669 if $(ENABLE_HEADER_SCANNING) != NO && $(INDEX_BASED_HEADER_DEPENDENCIES) != YES { 3670 HDRRULE on $(2) = ProcessC.HdrRule ; 3671 HDRSCAN on $(2) = $(HDRPATTERN) ; 3672 } 3673 } 3674 ProcessFile $(1) : $(2) ; 3675} 3676 3677rule ProcessFiles 3678{ 3679 local FILE ; 3680 for FILE in $(2) { 3681 ProcessFile $(1) : $(FILE) ; 3682 } 3683} 3684 3685rule ProcessFile 3686{ 3687 local SOURCE_COPY ; 3688 local SOURCE_SUBDIR ; 3689 if source in $(BUILD_COMPONENTS) { 3690 # copy to source location 3691 # make directory first if necessary 3692 if $(2:D) { 3693 SOURCE_SUBDIR = $(SOURCE_DIR)/$(2:D:G=) ; 3694 Mkdir $(SOURCE_SUBDIR) ; 3695 SOURCE_COPY = $(SOURCE_SUBDIR)/$(2:D=:G=) ; 3696 DEPENDS $(SOURCE_COPY) : $(SOURCE_SUBDIR) ; 3697 if $(_BUILD_PHASING) = YES { 3698 BUILD_PHASE_PRODUCTS += $(SOURCE_SUBDIR) ; 3699 } 3700 } 3701 else { 3702 SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 3703 DEPENDS $(SOURCE_COPY) : $(SOURCE_DIR) ; 3704 Mkdir $(SOURCE_DIR) ; 3705 } 3706 Cp $(SOURCE_COPY) : $(2) ; 3707 if $(_BUILD_PHASING) = YES { 3708 BUILD_PHASE_PRODUCTS += $(SOURCE_COPY) ; 3709 } 3710 } 3711 if build in $(BUILD_COMPONENTS) { 3712 # process file with rule based on the file suffix 3713 local EXCLUDED_OSS = $($(2)_EXCLUDED_OSS) ; 3714 local INCLUDED_OSS = $($(2)_INCLUDED_OSS) ; 3715 local RULE = $($(2:S)_RULE) ; 3716 3717 if $(EXCLUDED_OSS) && ( $(OS) in $(EXCLUDED_OSS) ) { 3718 # do nothing -- file excluded from build 3719 } else if $(INCLUDED_OSS) && ! ( $(OS) in $(INCLUDED_OSS) ) { 3720 # do nothing -- file excluded from build 3721 } else if $(RULE) { 3722 $(RULE) $(1) : $(2) ; 3723 } else { 3724 ECHO jam: warning: no rule for file $(2) ; 3725 } 3726 } 3727} 3728 3729# ProcessFrameworksAndLibraries <product> <linked files> 3730# 3731# Link object files and/or archive classes 3732rule ProcessFrameworksAndLibraries 3733{ 3734 if ( build in $(BUILD_COMPONENTS) ) 3735 && ( $(ARCHS) || $(NULL_BUILD_IF_NO_VALID_ARCH) != YES ) { 3736 if $(_BUILD_PHASING) = YES { 3737 PhaseTarget BUILD_PHASE : $(1) : LinkWithFrameworksAndLibraries ; 3738 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 3739 BUILD_PHASE_PRODUCTS = $(INNER_PRODUCT) ; 3740 } 3741 for VARIANT in $(BUILD_VARIANTS) { 3742 # add to linked files, including java .jar files even when there are no native object files! 3743 # This was never questioned, but the long comment was added after this 3744 # step was repeatedly moved outside this block by integration errors. 3745 LINKED_FILES_$(VARIANT) += $(2) ; 3746 3747 # only link if there are object files 3748 if $(OBJECT_FILES_$(VARIANT)) { 3749 if ! ( $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = STATIC ) { 3750 GENERATE_MASTER_OBJECT_FILE default = YES ; 3751 } 3752 # define products 3753 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Library { 3754 # simple product 3755 INNER_PRODUCT default = $(1:G=) ; 3756 INNER_PRODUCT_$(VARIANT) default = $(INNER_PRODUCT)$(VARIANT_SUFFIX_$(VARIANT)) ; 3757 INNER_PRODUCT_LINK_$(VARIANT) default = ; 3758 ProductFile $(INNER_PRODUCT_$(VARIANT)) ; 3759 if $(DEPLOYMENT_POSTPROCESSING) = YES { 3760 SetModeOwnerAndGroup $(INNER_PRODUCT:G=ModeOwnerGroup) : $(INNER_PRODUCT) ; 3761 } 3762 } 3763 else { 3764 if $(PRODUCT_TYPE) = Framework { 3765 # versioned bundle 3766 INNER_PRODUCT default = $(1:G=)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)$(1:BG=) ; 3767 INNER_PRODUCT_$(VARIANT) default = $(INNER_PRODUCT)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3768 INNER_PRODUCT_LINK default = $(1:G=)$(/)$(1:BG=) ; 3769 INNER_PRODUCT_LINK_$(VARIANT) default = $(INNER_PRODUCT_LINK)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3770 INNER_PRODUCT_LINK_PATH default = Versions$(/)Current$(/)$(1:BG=) ; 3771 INNER_PRODUCT_LINK_PATH_$(VARIANT) default = $(INNER_PRODUCT_LINK_PATH)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3772 } 3773 else { 3774 # standard bundle 3775 if $(BUNDLE_STYLE) = SHALLOW { 3776 INNER_PRODUCT default = $(1:G=)$(/)$(1:BG=) ; 3777 } 3778 else { 3779 INNER_PRODUCT default = $(1:G=)$(/)Contents$(/)MacOS$(/)$(1:BG=) ; 3780 } 3781 INNER_PRODUCT_$(VARIANT) default = $(INNER_PRODUCT)$(VARIANT_SUFFIX_$(VARIANT))$(TOOL_SUFFIX) ; 3782 INNER_PRODUCT_LINK_$(VARIANT) default = ; 3783 } 3784 # inner product should always be ready before the link to it 3785 if $(INNER_PRODUCT_LINK_$(VARIANT)) { 3786 DEPENDS $(INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_$(VARIANT)) ; 3787 } 3788 # inner product directory needed for all bundle types 3789 INNER_PRODUCT_DIR_$(VARIANT) = $(INNER_PRODUCT_$(VARIANT):D) ; 3790 if ! $(INNER_PRODUCT_DIR_$(VARIANT)) in $(PRODUCT_FILES) { 3791 Mkdir $(INNER_PRODUCT_DIR_$(VARIANT)) ; 3792 ProductFile $(INNER_PRODUCT_DIR_$(VARIANT)) ; 3793 } 3794 if $(INNER_PRODUCT_$(VARIANT)) && $(INNER_PRODUCT_DIR_$(VARIANT)) { 3795 DEPENDS $(INNER_PRODUCT_$(VARIANT)) : $(INNER_PRODUCT_DIR_$(VARIANT)) ; 3796 } 3797 # optionally make inner product dir aside 3798 if $(ASIDE_DIR) { 3799 ASIDE_INNER_PRODUCT_DIR_$(VARIANT) = $(INNER_PRODUCT_DIR_$(VARIANT):G=aside) ; 3800 if ! $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) in $(PRODUCT_FILES) { 3801 Mkdir $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) ; 3802 ProductFileAside $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) ; 3803 } 3804 } 3805 } 3806 # Link inner product 3807 # There are three kinds of linking that may be done, 3808 # and three link rules that may be used: 3809 # Linking a master object file that may be edited 3810 # is the first case assumed to be the most common, 3811 # linking using a master object file and 3812 # architecture-specific exports files is supported, 3813 # as is basic linking. 3814 # The link rules can be used to construct a static library, 3815 # a dynamic library, or a directly launchable executable. 3816 # Finally, static libraries need to have ranlib run after all else. 3817 LINK_FILE_LIST_$(VARIANT) on $(INNER_PRODUCT_$(VARIANT)) = $(FILE_LIST_$(VARIANT)) ; 3818 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Application { 3819 # stand alone executable 3820 if $(GENERATE_MASTER_OBJECT_FILE) = YES || $(EXPORTED_SYMBOLS_FILE) { 3821 ProcessSingleObjectLink $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : StandaloneExecutable ; 3822 } 3823 else { 3824 for ARCH in $(ARCHS) { 3825 THIN_MASTER_OBJECT_FILE default = $(EXPORTED_SYMBOLS_FILE_$(ARCH)) ; 3826 } 3827 if $(THIN_MASTER_OBJECT_FILE) { 3828 ProcessLinkWithArchitectureSpecificEditing $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : StandaloneExecutable ; 3829 } 3830 else { 3831 StandaloneExecutable $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) ; 3832 } 3833 } 3834 } 3835 else { 3836 if $(LIBRARY_STYLE) = STATIC && $(KERNEL_MODULE) != YES { 3837 # static library 3838 if $(GENERATE_MASTER_OBJECT_FILE) = YES || $(EXPORTED_SYMBOLS_FILE) { 3839 ProcessSingleObjectLink $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : StaticLibrary ; 3840 } 3841 else { 3842 for ARCH in $(ARCHS) { 3843 THIN_MASTER_OBJECT_FILE default = $(EXPORTED_SYMBOLS_FILE_$(ARCH)) ; 3844 } 3845 if $(THIN_MASTER_OBJECT_FILE) { 3846 ProcessLinkWithArchitectureSpecificEditing $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : StaticLibrary ; 3847 } 3848 else { 3849 StaticLibrary $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) ; 3850 } 3851 } 3852 } 3853 else { 3854 # dylibs, bundles, frameworks, and kernel extensions 3855 if $(GENERATE_MASTER_OBJECT_FILE) = YES || $(EXPORTED_SYMBOLS_FILE) { 3856 ProcessSingleObjectLink $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : DynamicLibrary ; 3857 } 3858 else { 3859 # use architecture-specific exported symbols file if provided 3860 for ARCH in $(ARCHS) { 3861 THIN_MASTER_OBJECT_FILE default = $(EXPORTED_SYMBOLS_FILE_$(ARCH)) ; 3862 } 3863 if $(THIN_MASTER_OBJECT_FILE) { 3864 ProcessLinkWithArchitectureSpecificEditing $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) : DynamicLibrary ; 3865 } 3866 else { 3867 DynamicLibrary $(INNER_PRODUCT_$(VARIANT)) : $(LINKED_FILES_$(VARIANT)) ; 3868 } 3869 } 3870 } 3871 } 3872 ProductFile $(INNER_PRODUCT_$(VARIANT)) ; 3873 DEPENDS $(INNER_PRODUCT_$(VARIANT)) : $(TARGET_BUILD_DIR) ; 3874 # optionally copy inner product aside 3875 if $(ASIDE_DIR) { 3876 ASIDE_INNER_PRODUCT_$(VARIANT) = $(INNER_PRODUCT_$(VARIANT):G=aside) ; 3877 ProductFileAside $(ASIDE_INNER_PRODUCT_$(VARIANT)) ; 3878 Cp $(ASIDE_INNER_PRODUCT_$(VARIANT)) : $(INNER_PRODUCT_$(VARIANT)) ; 3879 if $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) { 3880 DEPENDS $(ASIDE_INNER_PRODUCT_$(VARIANT)) : $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) ; 3881 } 3882 } 3883 # preen 3884 if $(DEPLOYMENT_POSTPROCESSING) = YES && $(UNSTRIPPED_PRODUCT) != YES { 3885 STRIPPED_PRODUCT_$(VARIANT) default = $(INNER_PRODUCT_$(VARIANT):G=strip) ; 3886 DEPENDS $(STRIPPED_PRODUCT_$(VARIANT)) : $(INNER_PRODUCT_$(VARIANT)) ; 3887 if $(PRODUCT_TYPE) != Tool && $(PRODUCT_TYPE) != Application { 3888 STRIPFLAGS default = -S ; 3889 } 3890 Strip $(STRIPPED_PRODUCT_$(VARIANT)) ; 3891 if $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = STATIC { 3892 Ranlib $(STRIPPED_PRODUCT_$(VARIANT)) ; 3893 } 3894 ProductFile $(STRIPPED_PRODUCT_$(VARIANT)) ; 3895 } 3896 # make inner product symlink, if any 3897 if $(INNER_PRODUCT_LINK_$(VARIANT)) { 3898 SymLink $(INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_LINK_PATH_$(VARIANT)) ; 3899 ProductFile $(INNER_PRODUCT_LINK_$(VARIANT)) ; 3900 DEPENDS $(INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_$(VARIANT)) ; 3901 # optionally copy inner product link aside 3902 if $(ASIDE_DIR) { 3903 ASIDE_INNER_PRODUCT_LINK_$(VARIANT) = $(INNER_PRODUCT_LINK_$(VARIANT):G=aside) ; 3904 ProductFileAside $(ASIDE_INNER_PRODUCT_LINK_$(VARIANT)) ; 3905 SymLink $(ASIDE_INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_LINK_PATH_$(VARIANT)) ; 3906 DEPENDS $(ASIDE_INNER_PRODUCT_LINK_$(VARIANT)) : $(ASIDE_INNER_PRODUCT_$(VARIANT)) ; 3907 DEPENDS $(ASIDE_INNER_PRODUCT_LINK_$(VARIANT)) : $(ASIDE_INNER_PRODUCT_DIR_$(VARIANT)) ; 3908 } 3909 } 3910 # static libraries must have ranlib run on them after all else 3911 if $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = STATIC { 3912 RANLIB_INNER_PRODUCT_$(VARIANT) default = $(INNER_PRODUCT_$(VARIANT):G=ranlib) ; 3913 # ranlib depends on link, strip, modeownergroup 3914 DEPENDS $(RANLIB_INNER_PRODUCT_$(VARIANT)) : $(INNER_PRODUCT_$(VARIANT)) ; 3915 if $(STRIPPED_PRODUCT_$(VARIANT)) { 3916 DEPENDS $(RANLIB_INNER_PRODUCT_$(VARIANT)) : $(STRIPPED_PRODUCT_$(VARIANT)) ; 3917 } 3918 ProductFile $(RANLIB_INNER_PRODUCT_$(VARIANT)) ; 3919 } 3920 # Basic link options determine if this is kext, bundle, or library 3921 if $(KERNEL_MODULE) = YES { 3922 MODULE_OBJECT_PATH = $(OBJECT_FILE_DIR_$(VARIANT))$(/)$(MODULE_OBJECT_FILE_$(VARIANT)) ; 3923 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -static -nostdlib -r -lkmodc++ "$(MODULE_OBJECT_PATH)" -lkmod -lcc_kext ; 3924 } 3925 else { 3926 if $(PREBINDING) = YES 3927 && $(PRODUCT_TYPE) != Bundle 3928 && ! ( $(PRODUCT_TYPE) = Library && ( $(LIBRARY_STYLE) = BUNDLE || $(LIBRARY_STYLE) = STATIC ) ) { 3929 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -prebind ; 3930 } 3931 if $(PRODUCT_TYPE) = Bundle 3932 || ( $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = BUNDLE ) { 3933 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -bundle ; 3934 } else { 3935 if $(PRODUCT_TYPE) = Framework 3936 || ( $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = DYNAMIC ) { 3937 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -dynamiclib ; 3938 } 3939 else { 3940 if $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = STATIC { 3941 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -static ; 3942 } 3943 } 3944 } 3945 # Dynamic library link options set version and installed name 3946 if ( $(PRODUCT_TYPE) = Library && $(LIBRARY_STYLE) = DYNAMIC ) 3947 || $(PRODUCT_TYPE) = Framework { 3948 if $(DYLIB_COMPATIBILITY_VERSION) { 3949 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -compatibility_version "$(DYLIB_COMPATIBILITY_VERSION)" ; 3950 } 3951 if $(DYLIB_CURRENT_VERSION) { 3952 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += -current_version "$(DYLIB_CURRENT_VERSION)" ; 3953 } 3954 if $(INSTALL_PATH) { 3955 DYLIB_INSTALLED_NAME_$(VARIANT) default = $(INSTALL_PATH)$(/)$(INNER_PRODUCT_$(VARIANT):G=) ; 3956 INSTALLED_NAME_FLAG on $(INNER_PRODUCT_$(VARIANT)) = -install_name \"`echo \"$(DYLIB_INSTALLED_NAME_$(VARIANT))\" | $(SED) 's!//*!/!g'`\" ; 3957 } 3958 } 3959 } 3960 # other link options 3961 OTHER_LDFLAGS_$(VARIANT) default = $(OTHER_LDFLAGS) ; 3962 if $(OTHER_LDFLAGS_$(VARIANT)) { 3963 FLAGS.o on $(INNER_PRODUCT_$(VARIANT)) += $(OTHER_LDFLAGS_$(VARIANT)) ; 3964 } 3965 } 3966 else { 3967 # no object files present, indicating pure Java 3968 if $(PRODUCT_TYPE) = Framework { 3969 if $(CURRENT_VERSION_LINK) { 3970 INNER_PRODUCT_$(VARIANT) default = $(1:G=)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)$(1:B)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3971 INNER_PRODUCT_LINK_$(VARIANT) default = $(1:G=)$(/)$(1:BG=)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3972 INNER_PRODUCT_LINK_PATH_$(VARIANT) default = Versions$(/)Current$(/)$(1:BG=)$(VARIANT_SUFFIX_$(VARIANT))$(DYNAMIC_LIBRARY_SUFFIX) ; 3973 # inner product link 3974 SymLink $(INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_LINK_PATH_$(VARIANT)) ; 3975 ProductFile $(INNER_PRODUCT_LINK_$(VARIANT)) ; 3976 NOUPDATE $(INNER_PRODUCT_LINK_$(VARIANT)) ; 3977 } 3978 else { 3979 INNER_PRODUCT_$(VARIANT) default = $(1:G=)$(/)$(1:BG=)_$(VARIANT)$(DYNAMIC_LIBRARY_SUFFIX) ; 3980 } 3981 ProductFile $(INNER_PRODUCT_$(VARIANT)) ; 3982 if $(DYLIB_COMPATIBILITY_VERSION) { 3983 DYLIB_VERSION_FLAGS on $(INNER_PRODUCT_$(VARIANT)) += -compatibility_version "$(DYLIB_COMPATIBILITY_VERSION)" ; 3984 } 3985 else { 3986 DYLIB_VERSION_FLAGS on $(INNER_PRODUCT_$(VARIANT)) += -compatibility_version 1 ; 3987 } 3988 if $(DYLIB_CURRENT_VERSION) { 3989 DYLIB_VERSION_FLAGS on $(INNER_PRODUCT_$(VARIANT)) += -current_version "$(DYLIB_CURRENT_VERSION)" ; 3990 } 3991 else { 3992 DYLIB_VERSION_FLAGS on $(INNER_PRODUCT_$(VARIANT)) += -current_version 1 ; 3993 } 3994 if $(INSTALL_PATH) { 3995 FRAMEWORK_INSTALLED_NAME_$(VARIANT) default = $(INSTALL_PATH)$(/)$(INNER_PRODUCT_$(VARIANT):G=) ; 3996 INSTALLED_NAME_FLAG on $(INNER_PRODUCT_$(VARIANT)) = -install_name \"`echo \"$(FRAMEWORK_INSTALLED_NAME_$(VARIANT))\" | $(SED) 's!//*!/!g'`\" ; 3997 } 3998 GenerateFrameworkStub $(INNER_PRODUCT_$(VARIANT)) ; 3999 INNER_PRODUCT_DIR = $(INNER_PRODUCT_$(VARIANT):D) ; 4000 if ! $(INNER_PRODUCT_DIR) in $(PRODUCT_FILES) { 4001 Mkdir $(INNER_PRODUCT_DIR) ; 4002 ProductFile $(INNER_PRODUCT_DIR) ; 4003 DEPENDS $(INNER_PRODUCT_$(VARIANT)) : $(INNER_PRODUCT_DIR) ; 4004 } 4005 if $(INNER_PRODUCT_LINK_$(VARIANT)) { 4006 SymLink $(INNER_PRODUCT_LINK_$(VARIANT)) : $(INNER_PRODUCT_LINK_PATH_$(VARIANT)) ; 4007 NOUPDATE $(INNER_PRODUCT_LINK_$(VARIANT)) ; 4008 ProductFile $(INNER_PRODUCT_LINK_$(VARIANT)) ; 4009 } 4010 } 4011 } 4012 # Java processing compatible with the presense of object files 4013 if $(COMPILED_JAVA) { 4014 # provide stub executable if necessary 4015 if $(JAVA_ONLY) = YES { 4016 INNER_PRODUCT_$(VARIANT) default = $(1:G=)$(/)Contents$(/)MacOS$(/)$(1:BG=) ; 4017 # must first make subfolder and depend on that 4018 INNER_PRODUCT_SUBDIR = $(INNER_PRODUCT_$(VARIANT):D) ; 4019 if ! $(INNER_PRODUCT_SUBDIR) in $(PRODUCT_FILES) { 4020 Mkdir $(INNER_PRODUCT_SUBDIR) ; 4021 ProductFile $(INNER_PRODUCT_SUBDIR) ; 4022 } 4023 Cp $(INNER_PRODUCT_$(VARIANT)) : $(JAVA_APP_STUB) ; 4024 ProductFile $(INNER_PRODUCT_$(VARIANT)) ; 4025 } 4026 } 4027 # Add jar/zip files that are in the link phase to the classpath 4028 if $(OTHER_JAVA_CLASS_PATH) { 4029 export LINKED_CLASS_ARCHIVES = :"$(OTHER_JAVA_CLASS_PATH)" ; 4030 } 4031 else { 4032 export LINKED_CLASS_ARCHIVES = "" ; 4033 } 4034 for JAVA_CLASS_SEARCH_PATH in $(JAVA_CLASS_SEARCH_PATHS) { 4035 LINKED_CLASS_ARCHIVES = "$(LINKED_CLASS_ARCHIVES):$(JAVA_CLASS_SEARCH_PATH)" ; 4036 } 4037 local ARCHIVE ; 4038 4039 for ARCHIVE in $(LINKED_FILES_$(VARIANT)) { 4040 switch $(ARCHIVE) { 4041 case *.framework : 4042 local FW_SUBDIR ; 4043 for FW_SUBDIR in $(JAVA_FRAMEWORK_RESOURCES_DIRS) { 4044 LINKED_CLASS_ARCHIVES = $(LINKED_CLASS_ARCHIVES):$(ARCHIVE)$(/)$(FW_SUBDIR)$(/)Java ; 4045 JAVA_FRAMEWORK_JARS += $(ARCHIVE)$(/)$(FW_SUBDIR)$(/)Java ; 4046 } 4047 case *.jar : 4048 LINKED_CLASS_ARCHIVES = $(LINKED_CLASS_ARCHIVES):$(ARCHIVE) ; 4049 if Merge in $($(ARCHIVE)_ATTRIBUTES) { 4050 # merge archive contents by unpacking them into hierarchy 4051 local DESTINATION_TARGET = $(CLASS_FILE_DIR:G=Unarchive$(ARCHIVE)) ; 4052 NOTFILE $(DESTINATION_TARGET) ; 4053 DEPENDS $(DESTINATION_TARGET) : $(JAVA_COMPILE_TARGET) ; 4054 if $(MERGED_ARCHIVES) { 4055 MERGED_ARCHIVES += $(DESTINATION_TARGET) ; 4056 } 4057 else { 4058 MERGED_ARCHIVES = $(DESTINATION_TARGET) ; 4059 } 4060 Unarchive $(DESTINATION_TARGET) : $(ARCHIVE) ; 4061 } 4062 case *.zip : 4063 LINKED_CLASS_ARCHIVES = $(LINKED_CLASS_ARCHIVES):$(ARCHIVE) ; 4064 if Merge in $($(ARCHIVE)_ATTRIBUTES) { 4065 # merge archive contents by unpacking them into hierarchy 4066 local DESTINATION_TARGET = $(CLASS_FILE_DIR:G=Unarchive$(ARCHIVE)) ; 4067 NOTFILE $(DESTINATION_TARGET) ; 4068 DEPENDS $(DESTINATION_TARGET) : $(JAVA_COMPILE_TARGET) ; 4069 if $(MERGED_ARCHIVES) { 4070 MERGED_ARCHIVES += $(DESTINATION_TARGET) ; 4071 } 4072 else { 4073 MERGED_ARCHIVES = $(DESTINATION_TARGET) ; 4074 } 4075 Unarchive $(DESTINATION_TARGET) : $(ARCHIVE) ; 4076 } 4077 } 4078 } 4079 # generate an archive if there are compiled or merged classes 4080 if $(COMPILED_JAVA) || $(MERGED_ARCHIVES) || $(COPIED_JAVA_RESOURCES) { 4081 if $(JAVA_ARCHIVE_CLASSES) != NO { 4082 # java archive suffix applies to applications and frameworks 4083 if $(JAVA_ARCHIVE_TYPE) = JAR { 4084 CLASS_ARCHIVE_SUFFIX default = .jar ; 4085 } 4086 else { 4087 if $(JAVA_ARCHIVE_TYPE) = ZIP { 4088 CLASS_ARCHIVE_SUFFIX default = .zip ; 4089 } 4090 } 4091 if ( $(PRODUCT_TYPE) = Bundle 4092 || $(PRODUCT_TYPE) = Application 4093 || $(PRODUCT_TYPE) = Framework ) { 4094 # Assume bundled products with object files are Cocoa 4095 CLASS_ARCHIVE default = $(RESOURCE_DIR)$(/)Java$(/)$(1:B)$(CLASS_ARCHIVE_SUFFIX) ; 4096 ProductFile $(CLASS_ARCHIVE) ; 4097 } 4098 else { 4099 CLASS_ARCHIVE default = $(1:B:G=)$(CLASS_ARCHIVE_SUFFIX) ; 4100 # It is critical for the class archive to be declared 4101 # a product file before any symlinks to it are made 4102 # which would conditionally involved declaring the 4103 # symbolic link content to not be a file. 4104 ProductFile $(CLASS_ARCHIVE) ; 4105 # ref. w/suffix for tool or library in deployment location 4106 if $(DEPLOYMENT_LOCATION) = YES { 4107 _ARCHIVE_REFERENCE default = $(BUILT_PRODUCTS_DIR:G=ArchiveRef)$(/)$(CLASS_ARCHIVE) ; 4108 SymLink $(_ARCHIVE_REFERENCE) : $(CLASS_ARCHIVE) ; 4109 DEPENDS $(_ARCHIVE_REFERENCE) : $(BUILT_PRODUCTS_DIR) ; 4110 DEPENDS $(1) : $(_ARCHIVE_REFERENCE) ; 4111 } 4112 # Make a link to the product without extension 4113 # to allow for references missing extension. 4114 _SUFFIX_FREE_ARCHIVE_REFERENCE = $(CLASS_ARCHIVE:S=) ; 4115 LOCATE on $(_SUFFIX_FREE_ARCHIVE_REFERENCE) = $(TARGET_BUILD_DIR) ; 4116 SymLink $(_SUFFIX_FREE_ARCHIVE_REFERENCE) : $(CLASS_ARCHIVE) ; 4117 DEPENDS $(_SUFFIX_FREE_ARCHIVE_REFERENCE) : $(TARGET_BUILD_DIR) ; 4118 DEPENDS $(1) : $(_SUFFIX_FREE_ARCHIVE_REFERENCE) ; 4119 } 4120 # class archive depends on target build dir 4121 DEPENDS $(CLASS_ARCHIVE) : $(TARGET_BUILD_DIR) ; 4122 # class archive depends on class archive dir (if defined) 4123 CLASS_ARCHIVE_DIR = $(CLASS_ARCHIVE:D:G=) ; 4124 if $(CLASS_ARCHIVE_DIR) && ! $(CLASS_ARCHIVE_DIR) in $(PRODUCT_FILES) { 4125 Mkdir $(CLASS_ARCHIVE_DIR) ; 4126 ProductFile $(CLASS_ARCHIVE_DIR) ; 4127 } 4128 # class files unknown, so archive depends on java compile log 4129 ClassArchive $(CLASS_ARCHIVE) : $(CLASS_FILE_DIR) ; 4130 if $(MERGED_ARCHIVES) { 4131 DEPENDS $(CLASS_ARCHIVE) : $(MERGED_ARCHIVES) ; 4132 } 4133 if $(COMPILED_JAVA) { 4134 DEPENDS $(CLASS_ARCHIVE) : $(JAVA_COMPILE_TARGET) ; 4135 } 4136 if $(COPIED_JAVA_RESOURCES) { 4137 DEPENDS $(CLASS_ARCHIVE) : $(COPIED_JAVA_RESOURCES) ; 4138 } 4139 } 4140 if $(JAVA_ARCHIVE_CLASSES) != YES { 4141 # !!!:cmolick:20020123 product class file dir not always made?! 4142 Mkdir $(PRODUCT_CLASS_FILE_DIR) ; 4143 ProductFile $(PRODUCT_CLASS_FILE_DIR) ; 4144 Ditto $(PRODUCT_CLASS_FILE_DIR) : $(CLASS_FILE_DIR) ; 4145 if $(MERGED_ARCHIVES) { 4146 DEPENDS $(PRODUCT_CLASS_FILE_DIR) : $(MERGED_ARCHIVES) ; 4147 } 4148 else { 4149 DEPENDS $(PRODUCT_CLASS_FILE_DIR) : $(JAVA_COMPILE_TARGET) ; 4150 } 4151 } 4152 } 4153 # Export the path to the inner product, if any. 4154 export INNER_PRODUCT_SUBPATH = $(INNER_PRODUCT:G=) ; 4155 # Build phasing bookkeeping 4156 if $(_BUILD_PHASING) = YES { 4157 if $(BUILD_PHASE_PRODUCTS) { 4158 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4159 } 4160 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4161 } 4162 } 4163 } 4164} 4165 4166rule ProcessFrameworkOrLibrary 4167{ 4168 for VARIANT in $(BUILD_VARIANTS) { 4169 LINKED_FILES_$(VARIANT) += $(2) ; 4170 } 4171} 4172 4173# ProcessRezFiles <product> <rez and resmerger input files> 4174# 4175# Processes Rez and ResMerger input files, or if there are none 4176# and type and creator are set uses SetFile to set type and creator. 4177rule ProcessRezFiles 4178{ 4179 if ( build in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) ) 4180 && ( $(ARCHS) || $(NULL_BUILD_IF_NO_VALID_ARCH) != YES ) { 4181 local FILE ; 4182 if $(_BUILD_PHASING) = YES { 4183 PhaseTarget BUILD_PHASE : $(1) : RezResourceManagerFiles ; 4184 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 4185 BUILD_PHASE_PRODUCTS = ; 4186 } 4187 if $(2) { 4188 for FILE in $(2) { 4189 if $(_BUILD_PHASING) = YES { 4190 ProcessRezFile $(BUILD_PHASE) : $(FILE) ; 4191 } 4192 else { 4193 ProcessRezFile $(1) : $(FILE) ; 4194 } 4195 } 4196 } 4197 else { 4198 if ( $(MACOS_TYPE) || $(MACOS_CREATOR) ) && $(REZ_EXECUTABLE) = YES { 4199 local RESOURCE_FORK = $(INNER_PRODUCT:G=ResourceFork) ; 4200 if ! $(INNER_PRODUCT) in $(PRESERVE_RESOURCES) { 4201 PRESERVE_RESOURCES += $(INNER_PRODUCT) ; 4202 } 4203 ProductFile $(RESOURCE_FORK) ; 4204 if $(ALWAYS_REZ) = YES { 4205 ALWAYS $(RESOURCE_FORK) ; 4206 } 4207 SetFile $(RESOURCE_FORK) ; 4208 } 4209 } 4210 if $(_BUILD_PHASING) = YES { 4211 if $(BUILD_PHASE_PRODUCTS) { 4212 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4213 } 4214 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4215 } 4216 } 4217} 4218 4219# ProcessRezFile <product or phase> <rez or resmerger input file> 4220# 4221# Sets up the compile of one Rez or ResMerger input file. 4222# RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR folder for resource collectors 4223# RESOURCE_MANAGER_RESOURCE_COLLECTOR resource collector 4224# RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION) localized collector 4225# RESOURCE_MANAGER_RESOURCE final resource destination 4226# RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR localized final folder 4227# RESOURCE_MANAGER_RESOURCE_$(REGION) localized final destination 4228rule ProcessRezFile 4229{ 4230 if source in $(BUILD_COMPONENTS) { 4231 local REZ_SOURCE_COPY ; 4232 local REZ_SOURCE_DIR ; 4233 # make directory first if necessary 4234 if $(2:D) { 4235 REZ_SOURCE_DIR = $(SOURCE_DIR)/$(2:D:G=) ; 4236 Mkdir $(REZ_SOURCE_DIR) ; 4237 REZ_SOURCE_COPY = $(REZ_SOURCE_DIR)/$(2:D=:G=) ; 4238 DEPENDS $(REZ_SOURCE_COPY) : $(REZ_SOURCE_DIR) ; 4239 } 4240 else { 4241 REZ_SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 4242 DEPENDS $(REZ_SOURCE_COPY) : $(SOURCE_DIR) ; 4243 Mkdir $(SOURCE_DIR) ; 4244 } 4245 # copy rez files to source location 4246 Cp $(REZ_SOURCE_COPY) : $(2) ; 4247 if $(_BUILD_PHASING) = YES { 4248 BUILD_PHASE_PRODUCTS += $(REZ_SOURCE_COPY) ; 4249 } 4250 } 4251 if build in $(BUILD_COMPONENTS) { 4252 local REGION = $($(2)_REGION) ; 4253 # scan for header files 4254 if $(ENABLE_HEADER_SCANNING) != NO && $(INDEX_BASED_HEADER_DEPENDENCIES) != YES { 4255 HDRRULE on $(2) = ProcessC.HdrRule ; 4256 HDRSCAN on $(2) = $(HDRPATTERN) ; 4257 } 4258 # all resources require a folder to hold any collector 4259 if ! $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) { 4260 RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR = $(TEMP_DIR)$(/)ResourceManagerResources ; 4261 Mkdir $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4262 ProductFile $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4263 } 4264 if $(REZ_EXECUTABLE) = YES { 4265 # Optionally accumulate ResourceManager resources 4266 # on a resource fork of the executable 4267 PRESERVE_RESOURCES += $(INNER_PRODUCT) ; 4268 if ! $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) { 4269 RESOURCE_MANAGER_RESOURCE_COLLECTOR = $(INNER_PRODUCT:BG=ResourceManagerResourceCollector) ; 4270 DEPENDS $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4271 } 4272 if $(2:S) = ".r" { 4273 RezCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(2) ; 4274 } else { 4275 ResMergerCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(2) ; 4276 } 4277 # The collector must be declared a product file 4278 # only after the first Collector rule invocation 4279 # to correctly initialize the collector. 4280 ProductFile $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) ; 4281 # location must be set after ProductFile invocation 4282 LOCATE on $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) = $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4283 if ! $(RESOURCE_MANAGER_RESOURCE) { 4284 RESOURCE_MANAGER_RESOURCE = $(INNER_PRODUCT:G=ResourceManagerResource) ; 4285 ProductFile $(RESOURCE_MANAGER_RESOURCE) ; 4286 ResMergerProduct $(RESOURCE_MANAGER_RESOURCE) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) ; 4287 } 4288 } 4289 else { 4290 # By default ResourceManager resources are stored in data forks 4291 # as Resources/<product>.rsrc files if non localized, or 4292 # Resources/<region>.lproj/Localized.rsrc files if localized. 4293 if $(REGION) { 4294 # localized resource collector 4295 if ! $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) { 4296 RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION) = $(REGION).rsrc ; 4297 DEPENDS $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4298 } 4299 if $(2:S) = ".r" { 4300 RezCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) : $(2) ; 4301 } else { 4302 ResMergerCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) : $(2) ; 4303 } 4304 # collector declared product after first Collector rule invocation 4305 ProductFile $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) ; 4306 # set location only after ProductFile invocation 4307 LOCATE on $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) = $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4308 # localized resource folder 4309 RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR = $(RESOURCE_DIR)$(/)$(REGION).lproj ; 4310 Mkdir $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) ; 4311 ProductFile $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) ; 4312 # localized resource 4313 if ! $(RESOURCE_MANAGER_RESOURCE_$(REGION)) { 4314 RESOURCE_MANAGER_RESOURCE_$(REGION) = $(RESOURCE_DIR)$(/)$(REGION).lproj$(/)Localized.rsrc ; 4315 ProductFile $(RESOURCE_MANAGER_RESOURCE_$(REGION)) ; 4316 # folder for localized resource 4317 RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR = $(RESOURCE_DIR)$(/)$(REGION).lproj ; 4318 Mkdir $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) ; 4319 ProductFile $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) ; 4320 DEPENDS $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) : $(RESOURCE_DIR) ; 4321 # get product from collector 4322 ResMergerProduct $(RESOURCE_MANAGER_RESOURCE_$(REGION)) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_$(REGION)) ; 4323 DEPENDS $(RESOURCE_MANAGER_RESOURCE_$(REGION)) : $(RESOURCE_MANAGER_RESOURCE_$(REGION)_DIR) ; 4324 } 4325 } 4326 else { 4327 # nonlocalized resource collector 4328 if ! $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) { 4329 RESOURCE_MANAGER_RESOURCE_COLLECTOR = $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR)$(/)$(1:S=.rsrc:G=) ; 4330 DEPENDS $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR_DIR) ; 4331 } 4332 if $(2:S) = ".r" { 4333 RezCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(2) ; 4334 } else { 4335 ResMergerCollector $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) : $(2) ; 4336 } 4337 # collector declared product after Collector rule invocation 4338 ProductFile $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) ; 4339 # nonlocalized resource 4340 if ! $(RESOURCE_MANAGER_RESOURCE) { 4341 RESOURCE_MANAGER_RESOURCE = $(RESOURCE_DIR)$(/)$(1:S=.rsrc:G=) ; 4342 ProductFile $(RESOURCE_MANAGER_RESOURCE) ; 4343 # get product from collector 4344 ResMergerProduct $(RESOURCE_MANAGER_RESOURCE) : $(RESOURCE_MANAGER_RESOURCE_COLLECTOR) ; 4345 DEPENDS $(RESOURCE_MANAGER_RESOURCE) : $(RESOURCE_DIR) ; 4346 if $(ALWAYS_REZ) = YES { 4347 ALWAYS $(RESOURCE_MANAGER_RESOURCE) ; 4348 } 4349 } 4350 } 4351 4352 if ! $(RESOURCE_DIR) in $(PRODUCT_FILES) { 4353 Mkdir $(RESOURCE_DIR) ; 4354 ProductFile $(RESOURCE_DIR) ; 4355 } 4356 } 4357 # create accompanying link in the case of versioned frameworks 4358 if $(RESOURCE_LINK) 4359 && ! $(RESOURCE_LINK) in $(PRODUCT_FILES) { 4360 SymLink $(RESOURCE_LINK) : $(RESOURCE_LINK_PATH) ; 4361 ProductFile $(RESOURCE_LINK) ; 4362 } 4363 } 4364} 4365 4366rule ProcessScriptBuildPhaseFiles 4367{ 4368 if build in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) { 4369 if $(_BUILD_PHASING) = YES { 4370 PhaseTarget BUILD_PHASE : $(1) : Script ; 4371 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 4372 BUILD_PHASE_PRODUCTS = ; 4373 } 4374 if build in $(BUILD_COMPONENTS) 4375 || ( headers in $(BUILD_COMPONENTS) && $(INSTALLHDRS_SCRIPT_PHASE) = YES ) { 4376 SEARCH on $(2) = $(SOURCE_ROOT) $(TEMP_ROOT) ; 4377 PHASE_SCRIPT_EXECUTION = $(2:G=Execution) ; 4378 NOTFILE $(PHASE_SCRIPT_EXECUTION) ; 4379 ALWAYS $(PHASE_SCRIPT_EXECUTION) ; 4380 DEPENDS $(1) : $(PHASE_SCRIPT_EXECUTION) ; 4381 PhaseScriptExecution $(PHASE_SCRIPT_EXECUTION) : $(2) ; 4382 if ! $(PHASE_SCRIPT_EXECUTION) in $(PRODUCT_FILES) { 4383 if $(_BUILD_PHASING) = YES { 4384 BUILD_PHASE_PRODUCTS += $(PHASE_SCRIPT_EXECUTION) ; 4385 } 4386 } 4387 } 4388 if $(_BUILD_PHASING) = YES { 4389 if $(BUILD_PHASE_PRODUCTS) { 4390 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4391 } 4392 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4393 } 4394 } 4395} 4396 4397rule PhaseScriptExecution 4398{ 4399 JAMSHOULDSETENV on $(1) = YES ; 4400 DEPENDS $(1) : $(2) ; 4401} 4402actions exportvars PhaseScriptExecution 4403{ 4404 echo "=== Script ===" 4405 cat "$(2)" 4406 echo "--- Output ---" 4407 "$(2)" 4408 _result=$? 4409 echo "=== Exit code: ${_result} ===" 4410 exit ${_result} 4411} 4412 4413rule ProcessCopyFiles 4414{ 4415 if $(_BUILD_PHASING) = YES { 4416 PhaseTarget BUILD_PHASE : $(1) : CopyFiles ; 4417 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 4418 BUILD_PHASE_PRODUCTS = ; 4419 } 4420 if build in $(BUILD_COMPONENTS) 4421 || ( headers in $(BUILD_COMPONENTS) && $(INSTALLHDRS_COPY_PHASE) = YES ) { 4422 SEARCH on $(2) = $(SOURCE_ROOT) ; 4423 for FILE in $(2) { 4424 ProcessCopyFile $(1) : $(FILE) : $(COPYFILES_DESTINATION_PATH) ; 4425 } 4426 } 4427 if $(_BUILD_PHASING) = YES { 4428 if $(BUILD_PHASE_PRODUCTS) { 4429 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4430 } 4431 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4432 } 4433} 4434 4435rule ProcessCopyFile 4436{ 4437 if source in $(BUILD_COMPONENTS) { 4438 local SOURCE_COPY ; 4439 local SOURCE_SUBDIR ; 4440 # copy files to source location 4441 # make directory first if necessary 4442 if $(2:D) { 4443 SOURCE_SUBDIR = $(2:D:G=SourceCopy) ; 4444 Mkdir $(SOURCE_SUBDIR) ; 4445 SOURCE_COPY = $(SOURCE_SUBDIR)/$(2:D=:G=) ; 4446 DEPENDS $(SOURCE_COPY) : $(SOURCE_SUBDIR) ; 4447 } 4448 else { 4449 SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 4450 DEPENDS $(SOURCE_COPY) : $(SOURCE_DIR) ; 4451 Mkdir $(SOURCE_DIR) ; 4452 } 4453 Cp $(SOURCE_COPY) : $(2) ; 4454 if $(_BUILD_PHASING) = YES { 4455 BUILD_PHASE_PRODUCTS += $(SOURCE_COPY) ; 4456 } 4457 } 4458 if build in $(BUILD_COMPONENTS) || headers in $(BUILD_COMPONENTS) { 4459 local DESTINATION_DIR = $(3) ; 4460 if ! $(DESTINATION_DIR) in $(PRODUCT_FILES) { 4461 Mkdir $(DESTINATION_DIR) ; 4462 ProductFile $(DESTINATION_DIR) ; 4463 } 4464 local DESTINATION_BASE = $(2:BS) ; 4465 local DESTINATION default = $(3)$(/)$(DESTINATION_BASE) ; 4466 DEPENDS $(DESTINATION) : $(DESTINATION_DIR) ; 4467 DEPENDS $(DESTINATION) : $(2) ; 4468 ProductFile $(DESTINATION) ; 4469 LOCATE on $(DESTINATION) = $(DESTINATION_DIR) ; 4470 RobustCp $(DESTINATION) : $(2) ; 4471 } 4472} 4473 4474rule ProcessJavaResourceFiles 4475{ 4476 if build in $(BUILD_COMPONENTS) { 4477 local FILE ; 4478 if $(_BUILD_PHASING) = YES { 4479 PhaseTarget BUILD_PHASE : $(1) : JavaArchiveFiles ; 4480 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 4481 BUILD_PHASE_PRODUCTS = ; 4482 } 4483 LOCATE on $(2) = $(SOURCE_ROOT) ; 4484 for FILE in $(2) { 4485 ProcessJavaResourceFile $(1) : $(FILE) : $(CLASS_FILE_DIR) ; 4486 } 4487 if $(_BUILD_PHASING) = YES { 4488 if $(BUILD_PHASE_PRODUCTS) { 4489 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4490 } 4491 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4492 } 4493 } 4494} 4495 4496rule ProcessJavaResourceFile 4497{ 4498 local ARCHIVE_PATH ; 4499 local ARCHIVE_DESTINATION ; 4500 local ARCHIVE_DESTINATION_FILE ; 4501 4502 # copy any other reference - formulate destination first 4503 if $($(2)_JAVA_ARCHIVE_SUBDIR) { 4504 ARCHIVE_DESTINATION_DIR = $(3)$(/)$($(2)_JAVA_ARCHIVE_SUBDIR) ; 4505 } 4506 else { 4507 # if there's no setting, just copy the file to the root of the archive. 4508 ARCHIVE_DESTINATION_DIR = $(3) ; 4509 } 4510 ARCHIVE_DESTINATION_FILE = $(ARCHIVE_DESTINATION_DIR)/$(2:BS) ; 4511 Mkdir $(ARCHIVE_DESTINATION_DIR) ; 4512 ProductFile $(ARCHIVE_DESTINATION_DIR) ; 4513 PBXCp $(ARCHIVE_DESTINATION_FILE:G=populated) : $(2) ; 4514 ProductFile $(ARCHIVE_DESTINATION_FILE:G=populated) ; 4515 4516 # copied content depends on source 4517 DEPENDS $(ARCHIVE_DESTINATION_FILE) : $(2) ; 4518 # set contents present for archival flag by making COPIED_JAVA_RESOURCES nonempty 4519 COPIED_JAVA_RESOURCES += $(2) ; 4520} 4521 4522# Following rules are used by ProcessSource 4523# to attend to specific types of source file. 4524 4525rule ProcessUsingJavaCompiler 4526{ 4527 # Because what class files will be generated by the java compiler 4528 # can't be known in advance, an abstract target is used for this step. 4529 if $(JAVA_COMPILE_TARGET) = "" { 4530 JAVA_COMPILE_TARGET = $(1:G=CompileJava) ; 4531 NOTFILE $(JAVA_COMPILE_TARGET) ; 4532 DEPENDS $(1) : $(JAVA_COMPILE_TARGET) ; 4533 DEPENDS $(JAVA_COMPILE_TARGET) : $(CLASS_FILE_DIR) ; 4534 # bridge derived java to be generated and compiled first 4535 if $(JAVA_BRIDGE_COMPILE_TARGET) { 4536 DEPENDS $(JAVA_COMPILE_TARGET) : $(JAVA_BRIDGE_COMPILE_TARGET) ; 4537 } 4538 } 4539 4540 export JAVA_SOURCE_PATH default = $(SOURCE_ROOT)$(/)$(JAVA_SOURCE_SUBDIR) ; 4541 4542 # start with the compiler-specific flags. 4543 if $(JAVA_COMPILER:B) = jikes { 4544 export JAVAC_FLAGS = $(JIKES_DEFAULT_FLAGS) ; 4545 } 4546 else if $(JAVA_COMPILER:B) = javac { 4547 export JAVAC_FLAGS = $(JAVAC_DEFAULT_FLAGS) ; 4548 } 4549 else { 4550 export JAVAC_FLAGS = ; 4551 } 4552 4553 if $(JAVA_COMPILER_DISABLE_WARNINGS) = YES { 4554 JAVAC_FLAGS += "-nowarn" ; 4555 } 4556 if $(JAVA_COMPILER_DEPRECATED_WARNINGS) = YES { 4557 JAVAC_FLAGS += "-deprecation" ; 4558 } 4559 JAVAC_FLAGS += $(JAVA_COMPILER_FLAGS) ; 4560 4561 if $(JAVA_COMPILER_TARGET_VM_VERSION) { 4562 if $(JAVA_COMPILER:B) = jikes { 4563 ECHO warning: Target VM version not supported by jikes ; 4564 } 4565 else { 4566 JAVAC_FLAGS += "-target "$(JAVA_COMPILER_TARGET_VM_VERSION) ; 4567 } 4568 } 4569 4570 if $(JAVA_COMPILER_DEBUGGING_SYMBOLS) = YES { 4571 JAVAC_FLAGS += "-g" ; 4572 } 4573 4574 if $(JAVAC_SOURCE_FILE_ENCODING) { 4575 JAVAC_FLAGS += -encoding "$(JAVAC_SOURCE_FILE_ENCODING)" ; 4576 } 4577 4578 if $(JAVA_USE_DEPENDENCIES) = "NO" || ( ! $($(2)_JAVA_IMPORTS) && empty$($(2)_JAVA_IMPORTS) != empty ) { 4579 # With no dependence, or dependence info usage off 4580 # build with combinded compiler invocations but no file list 4581 DEPENDS $(JAVA_COMPILE_TARGET) : $(2) ; 4582 ALWAYS $(JAVA_COMPILE_TARGET) ; 4583 JAVAC_FLAGS on $(JAVA_COMPILE_TARGET) = $(JAVAC_FLAGS) ; 4584 JAVA_COMPILER on $(JAVA_COMPILE_TARGET) = $(JAVA_COMPILER) ; 4585 if $(JAVA_COMPILER:B) = jikes { 4586 JavaCompile.jikes $(JAVA_COMPILE_TARGET) : $(2) ; 4587 } 4588 else { 4589 JavaCompile.default $(JAVA_COMPILE_TARGET) : $(2) ; 4590 } 4591 COMPILED_JAVA += $(2) ; 4592 if ! $(JAVA_COMPILE_TARGET) in $(PRODUCT_FILES) { 4593 ProductFile $(JAVA_COMPILE_TARGET) ; 4594 } 4595 } 4596 else { 4597 # Using dependence info, set up file list for java compiles 4598 JAVA_FILE_LIST default = $(TEMP_DIR)$(/)JavaFileList ; 4599 # define and act on target to clear list 4600 if ! $(CLEAR_JAVA_FILE_LIST) { 4601 CLEAR_JAVA_FILE_LIST = $(JAVA_FILE_LIST:G=ClearFileList) ; 4602 ClearJavaFileList $(CLEAR_JAVA_FILE_LIST) ; 4603 DEPENDS $(JAVA_COMPILE_TARGET) : $(CLEAR_JAVA_FILE_LIST) ; 4604 } 4605 # set up compile target to use file list 4606 if ! $(JAVA_COMPILE_TARGET) in $(PRODUCT_FILES) { 4607 JAVAC_FLAGS on $(JAVA_COMPILE_TARGET) = $(JAVAC_FLAGS) ; 4608 JAVA_COMPILER on $(JAVA_COMPILE_TARGET) = $(JAVA_COMPILER) ; 4609 JAVA_FILE_LIST_REFERENCE = @$(JAVA_FILE_LIST) ; 4610 NOTFILE $(JAVA_FILE_LIST_REFERENCE) ; 4611 if $(JAVA_COMPILER:B) = jikes { 4612 JavaCompile.jikes $(JAVA_COMPILE_TARGET) : $(JAVA_FILE_LIST_REFERENCE) ; 4613 } 4614 else { 4615 JavaCompile.default $(JAVA_COMPILE_TARGET) : $(JAVA_FILE_LIST_REFERENCE) ; 4616 } 4617 ProductFile $(JAVA_COMPILE_TARGET) ; 4618 } 4619 # set up class file dependence used to add java files to compile list 4620 local CLASS_FILE ; 4621 # use the main class, if it's there 4622 if $($(2)_MAIN_CLASS) { 4623 CLASS_FILE = $(CLASS_FILE_DIR)$(/)$($(2)_MAIN_CLASS) ; 4624 } 4625 else { 4626 local JAVA_SOURCE ; 4627 RemovePrefixPath JAVA_SOURCE : $(JAVA_SOURCE_SUBDIR) : $(2) ; 4628 CLASS_FILE = $(CLASS_FILE_DIR)$(/)$(JAVA_SOURCE:S=.class) ; 4629 } 4630 DEPENDS $(CLASS_FILE) : $(2) ; 4631 if $($(2)_JAVA_IMPORTS) { 4632 DEPENDS $(CLASS_FILE) : $($(2)_JAVA_IMPORTS) ; 4633 DEPENDS $(CLEAR_JAVA_FILE_LIST) : $($(2)_JAVA_IMPORTS) ; 4634 } 4635 DEPENDS $(JAVA_COMPILE_TARGET) : $(CLASS_FILE) ; 4636 JAVA_FILE_LIST on $(CLASS_FILE) = $(JAVA_FILE_LIST) ; 4637 AppendToJavaFileList $(CLASS_FILE) : $(2) ; 4638 DEPENDS $(CLEAR_JAVA_FILE_LIST) : $(2) ; 4639 COMPILED_JAVA += $(2) ; 4640 } 4641} 4642 4643actions quietly together piecemeal ClearJavaFileList 4644{ 4645 $(RM) -rf "$(JAVA_FILE_LIST)" && $(TOUCH) "$(JAVA_FILE_LIST)" 4646} 4647 4648# Appends reference to list only if not already present 4649actions quietly together piecemeal AppendToJavaFileList 4650{ 4651 _grep_result=`/usr/bin/grep -e \""$(2)"\" "$(JAVA_FILE_LIST)"` 4652 if [ "x$_grep_result" = "x" ] 4653 then $(ECHO) \""$(2)"\" >> "$(JAVA_FILE_LIST)" 4654 fi 4655} 4656 4657actions together piecemeal JavaCompile.default { 4658 frameworkjars="" 4659 for i in `echo $(JAVA_FRAMEWORK_JARS)/*.jar $(JAVA_FRAMEWORK_JARS)/*.zip ` ; do if [ -f "$i" ] ; then frameworkjars="$frameworkjars":"$i" ; fi ; done 4660 classpath="$(CLASS_FILE_DIR)$(LINKED_CLASS_ARCHIVES)$frameworkjars:"`$(JAVACONFIG) DefaultClasspath` 4661 $(JAVA_COMPILER) $(JAVAC_FLAGS) -sourcepath "$(JAVA_SOURCE_PATH)" -classpath "$classpath" -d "$(CLASS_FILE_DIR)" '$(2)' 4662} 4663actions together piecemeal JavaCompile.jikes { 4664 frameworkjars="" 4665 for i in `echo $(JAVA_FRAMEWORK_JARS)/*.jar $(JAVA_FRAMEWORK_JARS)/*.zip ` ; do if [ -f "$i" ] ; then frameworkjars="$frameworkjars":"$i" ; fi ; done 4666 classpath="$(CLASS_FILE_DIR)$(LINKED_CLASS_ARCHIVES)$frameworkjars:"`$(JAVACONFIG) DefaultClasspath` 4667 $(JAVA_COMPILER) $(JAVAC_FLAGS) -sourcepath "$(JAVA_SOURCE_PATH)" -classpath "$classpath" -d "$(CLASS_FILE_DIR)" '$(2)' 4668} 4669 4670rule ProcessApplescripts 4671{ 4672 if build in $(BUILD_COMPONENTS) || source in $(BUILD_COMPONENTS) { 4673 local FILE ; 4674 if $(_BUILD_PHASING) = YES { 4675 PhaseTarget BUILD_PHASE : $(1) : CompileAppleScripts ; 4676 BuildPhase $(BUILD_PHASE) : $(1) : $(PREVIOUS_BUILD_PHASE) ; 4677 BUILD_PHASE_PRODUCTS = ; 4678 } 4679 if $(CONTEXTNAME) = "" 4680 { 4681 for FILE in $(2) { 4682 if $(_BUILD_PHASING) = YES { 4683 ProcessAppleScript $(BUILD_PHASE) : $(FILE) : $(FILE) ; 4684 } 4685 else { 4686 ProcessAppleScript $(1) : $(FILE) : $(FILE) ; 4687 } 4688 } 4689 } 4690 else 4691 { 4692 ProcessAppleScript $(1) : $(2) : $(CONTEXTNAME) ; 4693 } 4694 if $(_BUILD_PHASING) = YES { 4695 if $(BUILD_PHASE_PRODUCTS) { 4696 DEPENDS $(BUILD_PHASE) : $(BUILD_PHASE_PRODUCTS) ; 4697 } 4698 PREVIOUS_BUILD_PHASE = $(BUILD_PHASE) ; 4699 } 4700 } 4701} 4702 4703rule ProcessAppleScript 4704{ 4705 if source in $(BUILD_COMPONENTS) { 4706 # make directory first if necessary 4707 if $(2:D) { 4708 SCRIPT_SOURCE_DIR = $(2:D:G=) ; 4709 Mkdir $(SCRIPT_SOURCE_DIR) ; 4710 SCRIPT_SOURCE_COPY = $(SCRIPT_SOURCE_DIR)/$(2:D=:G=) ; 4711 DEPENDS $(SCRIPT_SOURCE_COPY) : $(SCRIPT_SOURCE_DIR) ; 4712 } 4713 else { 4714 SCRIPT_SOURCE_COPY = $(SOURCE_DIR)/$(2:D=:G=) ; 4715 DEPENDS $(SCRIPT_SOURCE_COPY) : $(SOURCE_DIR) ; 4716 Mkdir $(SOURCE_DIR) ; 4717 } 4718 # copy script to source location 4719 Cp $(SCRIPT_SOURCE_COPY) : $(2) ; 4720 if $(_BUILD_PHASING) = YES { 4721 BUILD_PHASE_PRODUCTS += $(SCRIPT_SOURCE_COPY) ; 4722 } 4723 } 4724 if build in $(BUILD_COMPONENTS) { 4725 if $(2) = $(3) { 4726 # third argument is a file (ignore subfolder for result) 4727 APPLESCRIPT_FILE = $(APPLESCRIPTS_DIR)$(/)$(3:BS=.scpt) ; 4728 } 4729 else { 4730 # third argument is a context name 4731 APPLESCRIPT_FILE = $(APPLESCRIPTS_DIR)$(/)$(3:S=.scpt) ; 4732 } 4733 DEPENDS $(APPLESCRIPT_FILE) : $(APPLESCRIPTS_DIR) ; 4734 if ! $(APPLESCRIPTS_DIR) in $(PRODUCT_FILES) { 4735 Mkdir $(APPLESCRIPTS_DIR) ; 4736 ProductFile $(APPLESCRIPTS_DIR) ; 4737 } 4738 DEPENDS $(APPLESCRIPT_FILE) : $(2) ; 4739 OTHER_OSAFLAGS on $(APPLESCRIPT_FILE) = $(OTHER_OSAFLAGS) ; 4740 OSACompile $(APPLESCRIPT_FILE) : $(2) ; 4741 ProductFile $(APPLESCRIPT_FILE) ; 4742 } 4743} 4744 4745actions OSACompile 4746{ 4747 $(OSAC) -d -i $(SYSTEM_LIBRARY_DIR)/Frameworks/AppleScriptKit.framework -U "$(2:BS)" -o "$(1)" $(OTHER_OSAFLAGS) "$(2)" 4748} 4749 4750rule ProcessC 4751{ 4752 for VARIANT in $(BUILD_VARIANTS) { 4753 for ARCH in $(ARCHS) { 4754 local OBJECT_FILE ; 4755 local OBJECT_SUBDIR = $(OBJECT_FILE_DIR_$(VARIANT))$(/)$(ARCH) ; 4756 # $(2)_UNIQUENAME is defined only if the basename of the file isn't unique within the target. 4757 if $($(2)_UNIQUENAME) { 4758 OBJECT_FILE = $($(2)_UNIQUENAME:G=$(VARIANT)-$(ARCH)).o ; 4759 } 4760 else { 4761 OBJECT_FILE = $(2:D=:S=:G=$(VARIANT)-$(ARCH)).o ; 4762 } 4763 DEPENDS $(OBJECT_FILE) : $(OBJECT_SUBDIR) ; 4764 if ! $(OBJECT_SUBDIR) in $(PRODUCT_FILES) { 4765 Mkdir $(OBJECT_SUBDIR) ; 4766#!!!:needs to be a product file without LOCATE 4767# ProductFile $(OBJECT_SUBDIR) ; 4768 PRODUCT_FILES += $(OBJECT_SUBDIR) ; 4769 if $(_BUILD_PHASING) = YES { 4770 BUILD_PHASE_PRODUCTS += $(OBJECT_SUBDIR) ; 4771 } 4772 } 4773 ARCH on $(OBJECT_FILE) = $(ARCH) ; 4774 PER_ARCH_CFLAGS = $(PER_ARCH_CFLAGS_$(ARCH)) ; 4775 if $(JAVA_BRIDGET_TARGET) { 4776 DEPENDS $(OBJECT_FILE) : $(JAVA_BRIDGET_TARGET) ; 4777 } 4778 CompileC $(OBJECT_FILE) : $(2) ; 4779 if $(2:BS) != $(VECTOR_STUB:BS) { 4780 # add object file to object files and phase products 4781 # unless it is the compiled generated vector stub 4782 OBJECT_FILES_$(VARIANT) += $(OBJECT_FILE) ; 4783 OBJECT_FILES_$(VARIANT)_$(ARCH) += $(OBJECT_FILE) ; 4784 if $(_BUILD_PHASING) = YES { 4785 BUILD_PHASE_PRODUCTS += $(OBJECT_FILE) ; 4786 } 4787 } 4788 LOCATE on $(OBJECT_FILE) = $(OBJECT_SUBDIR) ; 4789 if $(2) = $(MODULE_INFO_FILE) { 4790 MODULE_OBJECT_FILE_$(VARIANT) = $(OBJECT_FILE) ; 4791 LOCATE on $(MODULE_OBJECT_FILE_$(VARIANT)) = $(OBJECT_SUBDIR) ; 4792 DEPENDS $(1) : $(MODULE_OBJECT_FILE_$(VARIANT)) ; 4793 } 4794 else { 4795 # object file is added to linked files 4796 # unless it is the compiled generated vector stub 4797 if $(2:BS) != $(VECTOR_STUB:BS) { 4798 LINKED_FILES_$(VARIANT) += $(OBJECT_FILE) ; 4799 } 4800 } 4801 } 4802 } 4803} 4804 4805rule ProcessCplusplus 4806{ 4807 for VARIANT in $(BUILD_VARIANTS) { 4808 for ARCH in $(ARCHS) { 4809 local OBJECT_FILE ; 4810 local OBJECT_SUBDIR = $(OBJECT_FILE_DIR_$(VARIANT))$(/)$(ARCH) ; 4811 # $(2)_UNIQUENAME is defined only if the basename of the file isn't unique within the target. 4812 if $($(2)_UNIQUENAME) { 4813 OBJECT_FILE = $($(2)_UNIQUENAME:G=$(VARIANT)-$(ARCH)).o ; 4814 } 4815 else { 4816 OBJECT_FILE = $(2:D=:S=:G=$(VARIANT)-$(ARCH)).o ; 4817 } 4818 DEPENDS $(OBJECT_FILE) : $(OBJECT_SUBDIR) ; 4819 if ! $(OBJECT_SUBDIR) in $(PRODUCT_FILES) { 4820 Mkdir $(OBJECT_SUBDIR) ; 4821 # !!!:cmolick:20010727 should be a ProductFile 4822 if $(_BUILD_PHASING) = YES { 4823 BUILD_PHASE_PRODUCTS += $(OBJECT_SUBDIR) ; 4824 } 4825 } 4826 ARCH on $(OBJECT_FILE) = $(ARCH) ; 4827 PER_ARCH_CPLUSPLUSFLAGS_$(ARCH) default = $(PER_ARCH_CFLAGS_$(ARCH)) ; 4828 PER_ARCH_CPLUSPLUSFLAGS = $(PER_ARCH_CPLUSPLUSFLAGS_$(ARCH)) ; 4829 CompileCplusplus $(OBJECT_FILE) : $(2) ; 4830 OBJECT_FILES_$(VARIANT) += $(OBJECT_FILE) ; 4831 OBJECT_FILES_$(VARIANT)_$(ARCH) += $(OBJECT_FILE) ; 4832 if $(_BUILD_PHASING) = YES { 4833 BUILD_PHASE_PRODUCTS += $(OBJECT_FILE) ; 4834 } 4835 if $(2) = $(MODULE_INFO_FILE_$(VARIANT)) { 4836 MODULE_OBJECT_FILE_$(VARIANT) = $(OBJECT_FILE) ; 4837 LOCATE on $(MODULE_OBJECT_FILE_$(VARIANT)) = $(OBJECT_SUBDIR) ; 4838 DEPENDS $(1) : $(MODULE_OBJECT_FILE_$(VARIANT)) ; 4839 } 4840 else { 4841 LOCATE on $(OBJECT_FILE) = $(OBJECT_SUBDIR) ; 4842 LINKED_FILES_$(VARIANT) += $(OBJECT_FILE) ; 4843 } 4844 } 4845 } 4846} 4847 4848HDRPATTERN = "^[ ]*#[ ]*include[ ]*[<\"](.*)[\">].*$" ; 4849HDRPATTERN += "^[ ]*#[ ]*import[ ]*[<\"](.*)[\">].*$" ; 4850 4851rule ProcessC.HdrRule 4852{ 4853 # header reference in subdirectory source may be to header in that subdirectory 4854 local LOCAL_HEADERS = $(2:D=$(1:D)) ; 4855 # or header reference may be to elsewhere 4856 local FOREIGN_HEADERS = $(2) ; 4857 # compiled sources may include headers in subdirectories 4858 INCLUDES $(1) : $(LOCAL_HEADERS) $(FOREIGN_HEADERS) ; 4859 # headers not found are ignored 4860 NOCARE $(LOCAL_HEADERS) $(FOREIGN_HEADERS) ; 4861} 4862 4863rule CompileC 4864{ 4865 # object file depends on the source file 4866 DEPENDS $(1) : $(2) ; 4867 # Initialize the flags, and set search paths to nothing 4868 if $(KERNEL_MODULE) = YES { 4869 local KERNEL_FRAMEWORK = $(SYSTEM_LIBRARY_DIR)/Frameworks/Kernel.framework ; 4870 local KERNEL_HEADERS = $(KERNEL_FRAMEWORK)/Headers ; 4871 local KERNEL_INCLUDE_PATHS = $(KERNEL_HEADERS) $(KERNEL_HEADERS)/bsd $(KERNEL_FRAMEWORK)/PrivateHeaders ; 4872 local KERNEL_COMPILE_OPTIONS = -fno-builtin -finline -fno-keep-inline-functions -force_cpusubtype_ALL -msoft-float ; 4873 if $(ARCH) in ppc { 4874 KERNEL_COMPILE_OPTIONS += -mlong-branch ; 4875 } 4876 local KERNEL_DEFINITIONS = -DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE -DNeXT ; 4877 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -nostdinc $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) $(OTHER_CFLAGS) -I$(KERNEL_INCLUDE_PATHS) -I$(PROJECT_HEADER_DIR) $(KERNEL_COMPILE_OPTIONS) -static $(KERNEL_DEFINITIONS) ; 4878 GLOBAL_CFLAGS on $(1) = ; 4879 } 4880 else { 4881 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CFLAGS) -fno-common -fpascal-strings $(OPTIMIZATION_CFLAGS) $(WARNING_CFLAGS) $(OTHER_CFLAGS) ; 4882 } 4883 FLAGS on $(1) += -pipe ; 4884 if $(USE_GCC3) = YES { 4885 FLAGS on $(1) += -fmessage-length=0 ; 4886 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Application { 4887 USE_DYNAMIC_NO_PIC default = YES ; 4888 } else { 4889 USE_DYNAMIC_NO_PIC default = NO ; 4890 } 4891 if $(USE_DYNAMIC_NO_PIC) = YES { 4892 FLAGS on $(1) += -mdynamic-no-pic ; 4893 } 4894 } 4895 # seed search paths with target-wide values 4896 HEADER_SEARCH_PATHS on $(1) = $(HEADER_SEARCH_PATHS) ; 4897 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 4898 4899 # If the source file is in a subdirectory, then search that 4900 # subdirectory for headers 4901 if $(2:D) { 4902 HEADER_SEARCH_PATHS on $(1) += $(2:D) ; 4903 } 4904 # We must compile with the extension-specific build flags 4905 FLAGS on $(1) += $($(2:S)_CFLAGS) ; 4906 # Add variant-specific flags 4907 local _VARIANT_FLAGS = $($(CC:BS)_$(VARIANT)_FLAGS) ; 4908 if $(_VARIANT_FLAGS) { 4909 FLAGS on $(1) += $(_VARIANT_FLAGS) ; 4910 } 4911 # Add debug flags, if appropriate. 4912 if $(DEBUGGING_SYMBOLS) = YES { 4913 FLAGS on $(1) += -g ; 4914 } 4915 # Add profiling flags, if appropriate. 4916 if $(PROFILING_CODE) = YES { 4917 FLAGS on $(1) += -pg ; 4918 } 4919 # Pass the trusted-precomp file name to the compiler to keep track 4920 # of which precompiled headers it has already sanity checked. 4921 if $(OS) in MACOS DARWIN && $(EFFECTIVE_PFE_FILE_$(ARCH)) = "" { 4922 FLAGS on $(1) += -precomp-trustfile $(PRECOMP_TRUSTFILE) ; 4923 } 4924 if $(CPP_HEADERMAP_FILE) { 4925 FLAGS on $(1) += "-Wp,-header-mapfile,$(CPP_HEADERMAP_FILE)" ; 4926 } 4927 if YES in $(GENERATE_CPP_ILOG_FILES) { 4928 local INCLUSION_LOG_FILE default = $(OBJECT_FILE_DIR)-$(VARIANT)$(/)$(ARCH)$(/)$(1:DB).ilog ; 4929 FLAGS on $(1) += "-Wp,-inclusion-log-file,$(INCLUSION_LOG_FILE)" ; 4930 } 4931 if $(INDEX_GENERATION_PIPE_NAME) != "" { 4932 FLAGS on $(1) += "-fgen-index=$(INDEX_GENERATION_PIPE_NAME)" ; 4933 } 4934 if $(EFFECTIVE_PFE_FILE_$(ARCH)) != "" && $(SUPPRESS_PREFIX_HEADER) != YES { 4935 PREFIX_HEADER_CFLAGS on $(1) = --load-pch "$(EFFECTIVE_PFE_FILE_$(ARCH))" ; 4936 DEPENDS $(1) : $(EFFECTIVE_PFE_FILE_$(ARCH)) ; 4937 } 4938 if $(EFFECTIVE_PREFIX_HEADER) != "" && $(SUPPRESS_PREFIX_HEADER) != YES { 4939 PREFIX_HEADER_CFLAGS on $(1) += -include "$(EFFECTIVE_PREFIX_HEADER)" ; 4940 DEPENDS $(1) : $(EFFECTIVE_PREFIX_HEADER) ; 4941 } 4942} 4943 4944actions CompileC 4945{ 4946 $(CC:Q) -c -F$(FRAMEWORK_SEARCH_PATHS:Q) -I$(HEADER_SEARCH_PATHS:Q) "$(FLAGS)" $(GLOBAL_CFLAGS) -I$(DERIVED_PATHS:Q) $(PREFIX_HEADER_CFLAGS:Q) $(2:Q) -o $(1:Q) 4947} 4948 4949rule CompileCplusplus 4950{ 4951 # object file depends on the source file 4952 DEPENDS $(1) : $(2) ; 4953 # Initialize the flags, and set search paths to nothing 4954 if $(KERNEL_MODULE) = YES { 4955 local KERNEL_FRAMEWORK = $(SYSTEM_LIBRARY_DIR)/Frameworks/Kernel.framework ; 4956 local KERNEL_HEADERS = $(KERNEL_FRAMEWORK)/Headers ; 4957 local KERNEL_INCLUDE_PATHS = $(KERNEL_HEADERS) $(KERNEL_HEADERS)/bsd $(KERNEL_FRAMEWORK)/PrivateHeaders ; 4958 #!!!:cmolick:20020228 different default flags for gcc3 kext builds 4959 if $(USE_GCC3) = YES { 4960 KERNEL_COMPILE_OPTIONS = -fno-builtin -finline -fno-keep-inline-functions -force_cpusubtype_ALL -fno-rtti -fno-exceptions -fcheck-new -msoft-float -fapple-kext ; 4961 } 4962 else { 4963 KERNEL_COMPILE_OPTIONS = -fno-builtin -finline -fno-keep-inline-functions -force_cpusubtype_ALL -fno-rtti -fno-exceptions -fcheck-new -fvtable-thunks -msoft-float ; 4964 if $(MODULE_IOKIT) = YES { 4965 KERNEL_COMPILE_OPTIONS += -findirect-virtual-calls ; 4966 } 4967 } 4968 if $(ARCH) in ppc { 4969 KERNEL_COMPILE_OPTIONS += -mlong-branch ; 4970 } 4971 local KERNEL_DEFINITIONS = -DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE -DNeXT ; 4972 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CPLUSPLUSFLAGS) -fno-common -nostdinc $(OPTIMIZATION_CFLAGS) $(WARNING_CPLUSPLUSFLAGS) $(OTHER_CPLUSPLUSFLAGS) -I$(KERNEL_INCLUDE_PATHS) -I$(PROJECT_HEADER_DIR) $(KERNEL_COMPILE_OPTIONS) -static $(KERNEL_DEFINITIONS) ; 4973 GLOBAL_CFLAGS on $(1) = ; 4974 } 4975 else { 4976 FLAGS on $(1) = -arch $(ARCH) $(PER_ARCH_CPLUSPLUSFLAGS) -fno-common -fpascal-strings $(OPTIMIZATION_CFLAGS) $(WARNING_CPLUSPLUSFLAGS) ; 4977 if $(2:S) = .CPP { 4978 FLAGS on $(1) += -x c++ ; 4979 } 4980 FLAGS on $(1) += $(OTHER_CPLUSPLUSFLAGS) ; 4981 } 4982 FLAGS on $(1) += -pipe ; 4983 if ( $(USE_GCC3) = YES ) { 4984 FLAGS on $(1) += -fmessage-length=0 ; 4985 if $(PRODUCT_TYPE) = Tool || $(PRODUCT_TYPE) = Application { 4986 USE_DYNAMIC_NO_PIC default = YES ; 4987 } else { 4988 USE_DYNAMIC_NO_PIC default = NO ; 4989 } 4990 if $(USE_DYNAMIC_NO_PIC) = YES { 4991 FLAGS on $(1) += -mdynamic-no-pic ; 4992 } 4993 } 4994 # seed search paths with target-wide values 4995 HEADER_SEARCH_PATHS on $(1) = $(HEADER_SEARCH_PATHS) ; 4996 FRAMEWORK_SEARCH_PATHS on $(1) = $(FRAMEWORK_SEARCH_PATHS) ; 4997 # If the source file is in a subdirectory, then search that 4998 # subdirectory for headers 4999 if $(2:D) { 5000 HEADER_SEARCH_PATHS on $(1) += $(2:D) ; 5001 } 5002 # We must compile with the extension-specific build flags 5003 FLAGS on $(1) += $($(2:S)_CC_FLAGS) ; 5004 # Add variant-specific flags 5005 local _VARIANT_FLAGS = $($(CC:BS)_$(VARIANT)_FLAGS) ; 5006 if $(_VARIANT_FLAGS) { 5007 FLAGS on $(1) += $(_VARIANT_FLAGS) ; 5008 } 5009 # Add debug flags, if appropriate. 5010 if $(DEBUGGING_SYMBOLS) = YES { 5011 FLAGS on $(1) += -g ; 5012 } 5013 # Add profiling flags, if appropriate. 5014 if $(PROFILING_CODE) = YES { 5015 FLAGS on $(1) += -pg ; 5016 } 5017 # Pass the trusted-precomp file name to the compiler to keep track 5018 # of which precompiled headers it has already sanity checked. 5019 if $(OS) in MACOS DARWIN && $(EFFECTIVE_PFE_FILE_$(ARCH)) = "" { 5020 FLAGS on $(1) += -precomp-trustfile $(PRECOMP_TRUSTFILE) ; 5021 } 5022 if $(CPP_HEADERMAP_FILE) { 5023 FLAGS on $(1) += "-Wp,-header-mapfile,$(CPP_HEADERMAP_FILE)" ; 5024 } 5025 if YES in $(GENERATE_CPP_ILOG_FILES) { 5026 local INCLUSION_LOG_FILE default = $(OBJECT_FILE_DIR)-$(VARIANT)$(/)$(ARCH)$(/)$(1:DB).ilog ; 5027 FLAGS on $(1) += "-Wp,-inclusion-log-file,$(INCLUSION_LOG_FILE)" ; 5028 } 5029 if $(EFFECTIVE_PFE_FILE_$(ARCH)) != "" && $(SUPPRESS_PREFIX_HEADER) != YES { 5030 PREFIX_HEADER_CFLAGS on $(1) = --load-pch "$(EFFECTIVE_PFE_FILE_$(ARCH))" ; 5031 DEPENDS $(1) : $(EFFECTIVE_PFE_FILE_$(ARCH)) ; 5032 } 5033 if $(EFFECTIVE_PREFIX_HEADER) != "" && $(SUPPRESS_PREFIX_HEADER) != YES { 5034 PREFIX_HEADER_CFLAGS on $(1) += -include "$(EFFECTIVE_PREFIX_HEADER)" ; 5035 DEPENDS $(1) : $(EFFECTIVE_PREFIX_HEADER) ; 5036 } 5037 _LD_FOR_LINKING = $(LDPLUSPLUS) ; 5038} 5039 5040actions CompileCplusplus 5041{ 5042 $(CPLUSPLUS:Q) -c -F$(FRAMEWORK_SEARCH_PATHS:Q) -I$(HEADER_SEARCH_PATHS:Q) "$(FLAGS)" $(GLOBAL_CFLAGS) -I$(DERIVED_PATHS:Q) $(PREFIX_HEADER_CFLAGS:Q) $(2:Q) -o $(1:Q) 5043} 5044 5045VECTOR_SUFFIX default = ; 5046rule ProcessExportsFile 5047{ 5048 if $(CFM_BRIDGE) = YES { 5049 local DYLIB_INSTALLED_NAME ; 5050 VECTOR_STUB default = $(DERIVED_FILE_DIR)$(/)$(1:B)Vector.s ; 5051 VECTOR_OBJECT_FILE default = $(TEMP_DIR)$(/)$(1:B)Vector.o ; 5052 if $(VECTOR_SUFFIX) { 5053 VECTOR_FRAGMENT_NAME default = CFMPriv_$(1:B)$(VECTOR_SUFFIX) ; 5054 } 5055 else { 5056 VECTOR_FRAGMENT_NAME default = CFMPriv_$(1:B) ; 5057 } 5058 DEPENDS $(VECTOR_STUB) : $(CURRENT_VERSION_DIR) ; 5059 DEPENDS $(VECTOR_STUB) : $(DERIVED_FILE_DIR) ; 5060 Mkdir $(CURRENT_VERSION_DIR) ; 5061 if $(INSTALL_PATH) { 5062 DYLIB_INSTALLED_NAME default = $(INSTALL_PATH)$(/)$(1:G=)$(/)Versions$(/)$(FRAMEWORK_VERSION)$(/)$(1:B:G=) ; 5063 if $(DYNAMIC_LIBRARY_SUFFIX) { 5064 DYLIB_INSTALLED_NAME = $(DYLIB_INSTALLED_NAME)$(DYNAMIC_LIBRARY_SUFFIX) ; 5065 } 5066 } 5067 DYLIB_INSTALLED_NAME on $(1) = $(DYLIB_INSTALLED_NAME) ; 5068 GenerateVectorLibraryIntermediates $(VECTOR_STUB) $(VECTOR_OBJECT_FILE) : $(2) ; 5069 BUILD_PHASE_PRODUCTS += $(VECTOR_STUB) ; 5070 } 5071} 5072 5073rule ProcessUsingMig 5074{ 5075 local TEMP_FILES ; 5076 local FILE_BASE = $(2:B) ; 5077 if AbsolutePath in $($(2)_ATTRIBUTES) { 5078 FILE_BASE = $(DERIVED_FILE_DIR)$(2:DB) ; 5079 } 5080# was if $(MACH_SERVER) != YES || $(MACH_CLIENT_AND_SERVER) = YES { 5081 if Client in $($(2)_ATTRIBUTES) { 5082 TEMP_FILES = $(FILE_BASE).h $(FILE_BASE)User.c ; 5083 } 5084# was if $(MACH_SERVER) = YES || $(MACH_CLIENT_AND_SERVER) = YES { 5085 if Server in $($(2)_ATTRIBUTES) { 5086 TEMP_FILES += $(FILE_BASE)Server.h $(FILE_BASE)Server.c ; 5087 } 5088 if Client in $($(2)_ATTRIBUTES) || Server in $($(2)_ATTRIBUTES) { 5089 Mig $(TEMP_FILES) : $(2) ; 5090 DerivedFiles $(TEMP_FILES) ; 5091 ProcessFiles $(1) : $(TEMP_FILES) ; 5092 } 5093} 5094 5095rule ProcessUsingLex 5096{ 5097 local TEMP_FILES ; 5098 local FILE_BASE = $(2:B) ; 5099 if AbsolutePath in $($(2)_ATTRIBUTES) { 5100 FILE_BASE = $(DERIVED_FILE_DIR)$(2:DB) ; 5101 } 5102 switch $(2:S) { 5103 case ".l" : TEMP_FILES += $(FILE_BASE).c ; 5104 case ".lm" : TEMP_FILES += $(FILE_BASE).m ; 5105 case ".LM" : TEMP_FILES += $(FILE_BASE).M ; 5106 case ".lmm" : TEMP_FILES += $(FILE_BASE).mm ; 5107 case ".lpp" : TEMP_FILES += $(FILE_BASE).cpp ; 5108 case ".LPP" : TEMP_FILES += $(FILE_BASE).CPP ; 5109 case ".lxx" : TEMP_FILES += $(FILE_BASE).cxx ; 5110 case ".LXX" : TEMP_FILES += $(FILE_BASE).CXX ; 5111 } 5112 DEPENDS $(TEMP_FILES) : $(DERIVED_FILE_DIR) ; 5113 Lex $(TEMP_FILES) : $(2) ; 5114 DerivedFiles $(TEMP_FILES) ; 5115 ProcessFiles $(1) : $(TEMP_FILES) ; 5116} 5117 5118rule ProcessUsingYacc 5119{ 5120 local FILE_BASE = $(2:B) ; 5121 if AbsolutePath in $($(2)_ATTRIBUTES) { 5122 FILE_BASE = $(DERIVED_FILE_DIR)$(2:DB) ; 5123 } 5124 local TEMP_FILES = $(FILE_BASE).h ; 5125 switch $(2:S) { 5126 case ".y" : TEMP_FILES += $(FILE_BASE).c ; 5127 case ".ym" : TEMP_FILES += $(FILE_BASE).m ; 5128 case ".YM" : TEMP_FILES += $(FILE_BASE).M ; 5129 case ".ymm" : TEMP_FILES += $(FILE_BASE).mm ; 5130 case ".ypp" : TEMP_FILES += $(FILE_BASE).cpp ; 5131 case ".YPP" : TEMP_FILES += $(FILE_BASE).CPP ; 5132 case ".yxx" : TEMP_FILES += $(FILE_BASE).cxx ; 5133 case ".YXX" : TEMP_FILES += $(FILE_BASE).CXX ; 5134 } 5135 DEPENDS $(TEMP_FILES) : $(DERIVED_FILE_DIR) ; 5136 Yacc $(TEMP_FILES) : $(2) ; 5137 DerivedFiles $(TEMP_FILES) ; 5138 ProcessFiles $(1) : $(TEMP_FILES) ; 5139} 5140 5141rule ProcessUsingRPCGen 5142{ 5143 local FILE_BASE = $(2:B) ; 5144 if AbsolutePath in $($(2)_ATTRIBUTES) { 5145 FILE_BASE = $(DERIVED_FILE_DIR)$(2:DB) ; 5146 } 5147 local TEMP_FILES = $(FILE_BASE).h $(FILE_BASE)_xdr.c ; 5148 DEPENDS $(TEMP_FILES) : $(DERIVED_FILE_DIR) ; 5149 RPCGen $(TEMP_FILES) : $(2) ; 5150 DerivedFiles $(TEMP_FILES) ; 5151 ProcessFiles $(1) : $(TEMP_FILES) ; 5152} 5153 5154rule ProcessUsingBridget 5155{ 5156 Bridget $(1) : $(2) ; 5157} 5158# Copyright (c) 1999-2002 Apple Computer, Inc. 5159# All rights reserved. 5160 5161# High level rules for build actions on targets 5162 5163# Actions <product> 5164# Defines all available build actions 5165rule Actions 5166{ 5167 Clean clean : $(1) ; 5168 BuildAction build : $(1) ; 5169 BuildAction copysrc : $(1) ; 5170 NOTFILE copysrc ; 5171 BuildAction copyhdrs : $(1) ; 5172 NOTFILE copyhdrs ; 5173 BuildAction copyrsrcs : $(1) ; 5174 NOTFILE copyrsrcs ; 5175 BuildAction install : $(1) ; 5176 BuildAction installdebugonly : $(1) ; 5177 NOTFILE installdebug ; 5178 BuildAction installprofileonly : $(1) ; 5179 NOTFILE installprofile ; 5180 BuildAction installdebugprofileonly : $(1) ; 5181 NOTFILE installdebugprofile ; 5182 BuildAction installsrc : $(1) ; 5183 NOTFILE installsrc ; 5184 BuildAction installhdrs : $(1) ; 5185 NOTFILE installhdrs ; 5186 BuildAction installrsrcs : $(1) ; 5187 NOTFILE installrsrcs ; 5188} 5189 5190# Clean clean : <product> 5191# Deletes the product and the files associated with building it 5192rule Clean 5193{ 5194 # locate built product and remove 5195 local BUILT_PRODUCT = $(2:G=) ; 5196 LOCATE on $(BUILT_PRODUCT) = $(TARGET_BUILD_DIR) ; 5197 Clean.Remove clean : $(BUILT_PRODUCT) ; 5198 5199 # remove temporary directories 5200 Clean.Remove clean : $(TEMP_DIR) ; 5201 5202 # Removal of archive in case of tools that are class archives, 5203 # this is which don't necessarily end with TOOL_SUFFIX. 5204 local ARCHIVE_SUFFIX ; 5205 local ARCHIVE_TARGET ; 5206 if $(JAVA_ARCHIVE_TYPE) = JAR { 5207 ARCHIVE_SUFFIX default = .jar ; 5208 } 5209 if $(JAVA_ARCHIVE_TYPE) = ZIP { 5210 ARCHIVE_SUFFIX default = .zip ; 5211 } 5212 ARCHIVE_SUFFIX default = "" ; 5213 ARCHIVE_TARGET = $(2:G=)$(ARCHIVE_SUFFIX) ; 5214 LOCATE on $(ARCHIVE_TARGET) = $(TARGET_BUILD_DIR) ; 5215 Clean.RemoveArchive clean : $(ARCHIVE_TARGET) ; 5216 # remove project header clones for this target 5217 if $(PROJECT_HEADER_DIR) { 5218 Clean.Remove clean : $(PROJECT_HEADER_DIR) ; 5219 } 5220 if $(WRAPPER_CLONE_DIR) { 5221 Clean.Remove clean : $(WRAPPER_CLONE_DIR) ; 5222 } 5223 # whole project content to remove on full clean 5224 Clean.Remove clean : $(PRECOMP_TRUSTFILE) ; 5225} 5226 5227actions quietly piecemeal together existing Clean.Remove 5228{ 5229 $(RM) -rf "$(2)" 5230} 5231 5232actions Clean.RemoveArchive 5233{ 5234 if [ -f "$(2)" ]; then 5235 $(RM) -rf "$(2)" 5236 fi 5237} 5238 5239rule BuildAction 5240{ 5241 local ACTION_TARGET = $(2:G=$(1)BuildAction) ; 5242 ACTION on $(2) = $(ACTION) ; 5243 DEPENDS $(1) : $(ACTION_TARGET) ; 5244 DEPENDS $(ACTION_TARGET) : $(2) ; 5245 NOTFILE $(ACTION_TARGET) ; 5246} 5247 5248# RunVariantHackScript varianthack : <product> 5249# Runs /AppleInternal/Developer/Tools/AppleInternalDebugAndProfileBuild.sh, 5250rule RunVariantHackScript 5251{ 5252 if $(RC_JASPER) || $(INTERNAL_BUILD_VARIANTS_ONLY_IN_JASPER) != YES { 5253 local VARIANT_HACK_TARGET = $(1:G=varianthack) ; 5254 DEPENDS $(1) : $(VARIANT_HACK_TARGET) ; 5255 NOTFILE $(VARIANT_HACK_TARGET) ; 5256 } 5257} 5258actions exportvars RunVariantHackScript 5259{ 5260 /bin/sh /AppleInternal/Developer/Tools/AppleInternalDebugAndProfileBuilder.sh $(INTERNAL_BUILD_VARIANTS) 5261} 5262# Copyright (c) 1999,2000 Apple Computer, Inc. 5263# All rights reserved. 5264 5265include $(JAMFILE) ; 5266