1rule FSameTargetWithPrependedGrist 2{ 3 # SameTargetWithPrependedGrist <target> : <grist to prepend> ; 4 # 5 local target = $(1) ; 6 local gristToPrepend = $(2) ; 7 local grist = $(target:G) ; 8 9 if $(grist) { 10 grist = $(gristToPrepend)!$(grist) ; 11 } else { 12 grist = $(gristToPrepend) ; 13 } 14 15 return $(target:G=$(grist)) ; 16} 17 18rule InitScript 19{ 20 # Note: The script must have been LOCATEd before. 21 local script = $(1) ; 22 local initScript 23 = [ FSameTargetWithPrependedGrist $(script) : init-script ] ; 24 25 if ! [ on $(script) return $(__is_initialized) ] { 26 __is_initialized on $(script) = true ; 27 28 MakeLocate $(initScript) : [ on $(script) return $(LOCATE) ] ; 29 Always $(initScript) ; 30 Depends $(script) : $(initScript) ; 31 32 InitScript1 $(initScript) ; 33 } 34 35 return $(initScript) ; 36} 37 38actions InitScript1 39{ 40 $(RM) $(1) 41 touch $(1) 42} 43 44rule AddVariableToScript script : variable : value 45{ 46 # AddVariableToScript <script> : <variable> : <value> ; 47 48 # interpret an empty variable value as empty string 49 if ! $(value) { 50 value = "" ; 51 } 52 53 InitScript $(script) ; 54 55 VARIABLE_DEFS on $(script) += "echo $(variable)=\\\"$(value[1])\\\" >> " ; 56 57 # if the value is an array, add the other array elements 58 value = $(value[2-]) ; 59 while $(value) { 60 VARIABLE_DEFS on $(script) 61 += "echo $(variable)=\\\" \\\$$(variable) $(value[1])\\\" >> " ; 62 value = $(value[2-]) ; 63 } 64 65 AddVariableToScript1 $(script) ; 66} 67 68actions together AddVariableToScript1 69{ 70 $(VARIABLE_DEFS)$(1); 71} 72 73rule AddTargetVariableToScript 74{ 75 # AddTargetVariableToScript <script> : <target> [ : <variable> ] ; 76 # 77 local script = $(1) ; 78 local target = $(2) ; 79 local variable = $(3:E=$(target:BS)) ; 80 81 InitScript $(script) ; 82 83 # That's not completely save, if one has more than on target with the 84 # same base name. A unique pseudo target would have to be introduced 85 # to do it more correctly. 86 VARIABLE_NAME($(target:BS)) on $(script) = $(variable) ; 87 88 Depends $(script) : $(target) ; 89 AddTargetVariableToScript1 $(script) : $(target) ; 90} 91 92actions AddTargetVariableToScript1 93{ 94 echo "$(VARIABLE_NAME($(2:BS)))=\"$(2)\"" >> $(1) 95} 96 97 98#pragma mark - 99 100rule AddDirectoryToContainer container : directoryTokens 101{ 102 # AddDirectoryToContainer <container> : <directoryTokens> 103 104 local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ; 105 local directory = [ FDirName $(directoryTokens) ] ; 106 directory = $(directory:G=$(containerGrist)) ; 107 108 if ! [ on $(directory) return $(__is_on_image) ] { 109 HAIKU_INSTALL_DIRECTORIES on $(container) += $(directory) ; 110 __is_on_image on $(directory) = true ; 111 DIRECTORY_TOKENS on $(directory) = $(directoryTokens) ; 112 NotFile $(directory) ; 113 114 # mark the parent dir as not to be created 115 local parent = [ FReverse $(directoryTokens) ] ; 116 parent = [ FReverse $(parent[2-]) ] ; 117 if $(parent) { 118 parent = [ FDirName $(parent) ] ; 119 parent = $(parent:G=$(containerGrist)) ; 120 DONT_CREATE on $(parent) = true ; 121 } 122 } 123 124 return $(directory) ; 125} 126 127rule FilterContainerUpdateTargets targets : filterVariable 128{ 129 # FilterContainerUpdateTargets targets : filterVariable 130 131 local filteredTargets ; 132 local target ; 133 for target in $(targets) { 134 if [ on $(target) return $($(filterVariable)) ] { 135 filteredTargets += $(target) ; 136 } 137 } 138 return $(filteredTargets) ; 139} 140 141 142rule IncludeAllTargetsInContainer container 143{ 144 local filterVar 145 = [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ; 146 if $(filterVar) { 147 return $($(filterVar)) ; 148 } 149 150 return ; 151} 152 153 154rule AddFilesToContainer container : directoryTokens : targets : destName 155{ 156 # AddFilesToContainer <container> : <directoryTokens> : <targets> 157 # [ : dest name ] 158 # 159 local directory = [ AddDirectoryToContainer $(container) 160 : $(directoryTokens) ] ; 161 local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ; 162 163 # If the image shall only be updated, we filter out all targets not marked 164 # accordingly. 165 if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 166 && ! [ IncludeAllTargetsInContainer $(container) ] { 167 local filterVar 168 = [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ; 169 if $(filterVar) { 170 targets = [ FilterContainerUpdateTargets $(targets) 171 : $(filterVar) ] ; 172 } 173 } 174 175 # We create a unique dummy target per target to install. 176 local installTargetsVar 177 = [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ; 178 local target ; 179 for target in $(targets) { 180 local name ; 181 if $(destName) { 182 name = $(destName) ; 183 } else { 184 name = $(target:G=:D=) ; 185 } 186 187 local destTarget = $(name:G=$(containerGrist)__$(directory:G=)) ; 188 TARGET on $(destTarget) = $(target) ; 189 INSTALL_DIR on $(destTarget) = $(directory) ; 190 $(installTargetsVar) on $(target) += $(destTarget) ; 191 TARGETS_TO_INSTALL on $(directory) += $(destTarget) ; 192 193 # If the target is associated with catalog files, add those, too. 194 local catalogs = [ on $(target) return $(HAIKU_CATALOG_FILES) ] ; 195 if $(catalogs) { 196 local signature 197 = [ on $(target) return $(HAIKU_CATALOG_SIGNATURE) ] ; 198 AddFilesToHaikuImage system data locale catalogs $(signature) 199 : $(catalogs) ; 200 } 201 } 202} 203 204rule FFilesInContainerDirectory container : directoryTokens 205{ 206 local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ; 207 local directory = [ FDirName $(directoryTokens) ] ; 208 directory = $(directory:G=$(containerGrist)) ; 209 210 if [ on $(directory) return $(__is_on_image) ] { 211 on $(directory) return $(TARGETS_TO_INSTALL) ; 212 } 213 214 return ; 215} 216 217rule AddSymlinkToContainer container : directoryTokens : linkTarget : linkName 218{ 219 # AddSymlinkToContainer <container> : <directory> : <link target> 220 # [ : <link name> ] ; 221 # 222 223 # If the image shall only be updated, we don't add any symlinks. 224 if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 225 && ! [ IncludeAllTargetsInContainer $(container) ] { 226 return ; 227 } 228 229 local directory = [ AddDirectoryToContainer $(container) 230 : $(directoryTokens) ] ; 231 232 if ! $(linkName) { 233 local path = [ FReverse [ FSplitPath $(linkTarget) ] ] ; 234 linkName = $(path[1]) ; 235 } 236 237 local link = $(directory)/$(linkName) ; 238 SYMLINK_TARGET on $(link) = $(linkTarget) ; 239 SYMLINKS_TO_INSTALL on $(directory) += $(link) ; 240} 241 242rule FSymlinksInContainerDirectory container : directoryTokens 243{ 244 local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ; 245 local directory = [ FDirName $(directoryTokens) ] ; 246 directory = $(directory:G=$(containerGrist)) ; 247 248 if [ on $(directory) return $(__is_on_image) ] { 249 on $(directory) return $(SYMLINKS_TO_INSTALL) ; 250 } 251 252 return ; 253} 254 255rule CopyDirectoryToContainer container : directoryTokens : sourceDirectory 256 : targetDirectoryName : excludePatterns : alwaysUpdate 257{ 258 # CopyDirectoryToContainer <container> : <directoryTokens> 259 # : <sourceDirectory> : <targetDirectoryName> : <excludePatterns> 260 # : <alwaysUpdate> ; 261 # 262 263 # If the image shall only be updated, we don't copy any directories 264 if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 265 && ! [ IncludeAllTargetsInContainer $(container) ] 266 && ! $(alwaysUpdate) { 267 return ; 268 } 269 270 if ! $(targetDirectoryName) { 271 local path = [ FReverse [ FSplitPath $(sourceDirectory) ] ] ; 272 targetDirectoryName = $(path[1]) ; 273 } 274 275 local directory = [ AddDirectoryToContainer $(container) 276 : $(directoryTokens) $(targetDirectoryName) ] ; 277 278 local targetDir = $(directory)/-/$(sourceDirectory) ; 279 EXCLUDE_PATTERNS on $(targetDir) = $(excludePatterns) ; 280 SOURCE_DIRECTORY on $(targetDir) = $(sourceDirectory) ; 281 TARGET_DIRECTORY on $(targetDir) = $(directory) ; 282 DIRECTORIES_TO_INSTALL on $(directory) += $(targetDir) ; 283} 284 285rule ExtractArchiveToContainer container : directoryTokens : archiveFile 286 : extractedSubDir 287{ 288 # ExtractArchiveToContainer <container> : <directory> : <archiveFile> 289 # : <extractedSubDir> ; 290 291 local directory = [ AddDirectoryToContainer $(container) 292 : $(directoryTokens) ] ; 293 294 ARCHIVE_FILES_TO_INSTALL on $(directory) += $(archiveFile) ; 295 ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(archiveFile) = $(extractedSubDir) ; 296} 297 298rule AddDriversToContainer container : relativeDirectoryTokens : targets 299{ 300 # AddDriversToContainer <container> : <relative directory> : <targets> ; 301 # 302 local directoryTokens = system add-ons kernel drivers dev 303 $(relativeDirectoryTokens) ; 304 305 AddFilesToContainer $(container) : system add-ons kernel drivers bin 306 : $(targets) ; 307 308 # If the image shall only be updated, we don't add any symlinks. 309 if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 310 && ! [ IncludeAllTargetsInContainer $(container) ] { 311 return ; 312 } 313 314 # get the relative symlink path prefix 315 local linkPrefix = ; 316 for i in $(relativeDirectoryTokens) { 317 linkPrefix += .. ; 318 } 319 linkPrefix += .. bin ; 320 321 # add the symlinks 322 local name ; 323 for name in $(targets:BS) { 324 AddSymlinkToContainer $(container) : $(directoryTokens) 325 : [ FDirName $(linkPrefix) $(name) ] : $(name) ; 326 } 327} 328 329rule AddNewDriversToContainer container : relativeDirectoryTokens 330 : targets 331{ 332 # AddNewDriversToContainer <container> : <directory> : <targets> ; 333 # 334 local directoryTokens = system add-ons kernel drivers 335 $(relativeDirectoryTokens) ; 336 337 AddFilesToContainer $(container) : $(directoryTokens) 338 : $(targets) ; 339} 340 341rule AddBootModuleSymlinksToContainer container : targets 342{ 343 # AddBootModuleSymlinksToContainer <container> : <targets> ; 344 # 345 346 # If the image shall only be updated, we don't add any symlinks. 347 if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 348 && ! [ IncludeAllTargetsInContainer $(container) ] { 349 return ; 350 } 351 352 # add the symlinks 353 local installTargetsVar 354 = [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ; 355 local target ; 356 for target in $(targets) { 357 # Symlink to the first place where the target has been installed. 358 local destTarget = [ on $(target) return $($(installTargetsVar)[1]) ] ; 359 local installDir = [ on $(destTarget) return $(INSTALL_DIR) ] ; 360 361 if ! $(installDir) { 362 Echo "ERROR: AddBootModuleSymlinksToContainer: Can't create a " 363 "symlink to target" \"$(target)"\"." ; 364 Exit "ERROR: Add*ToContainer has not been invoked for it yet." ; 365 } 366 367 local name = $(target:BS) ; 368 local linkTarget = [ FDirName /boot $(installDir:G=) $(name) ] ; 369 370 AddSymlinkToContainer $(container) : system add-ons kernel boot 371 : $(linkTarget) : $(name) ; 372 } 373} 374 375 376rule CreateContainerMakeDirectoriesScript container : script 377{ 378 MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ; 379 Always $(script) ; 380 381 local initScript = [ InitScript $(script) ] ; 382 383 local scriptBody 384 = [ FSameTargetWithPrependedGrist $(script) : script-body ] ; 385 LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ; 386 Depends $(scriptBody) : $(initScript) ; 387 Depends $(script) : $(scriptBody) ; 388 389 # collect the directories to create 390 local dirsToCreate ; 391 local directories 392 = [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] ; 393 local dir ; 394 for dir in $(directories) { 395 if ! [ on $(dir) return $(DONT_CREATE) ] { 396 dirsToCreate += $(dir) ; 397 } 398 } 399 400 # If the image shall only be updated, we don't create directories. 401 if $(dirsToCreate) 402 && ( ! [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] 403 || [ IncludeAllTargetsInContainer $(container) ] ) { 404 Depends $(scriptBody) : $(dirsToCreate) ; 405 CreateContainerMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ; 406 407 local serializationDependency = $(scriptBody) ; 408 # Used to create a dependency chain between the dummy targets. 409 # This forces jam to build them one after the other, thus preventing 410 # concurrent writes to the script file when building with multiple 411 # jobs. 412 413 # For directories with attributes, we convert those the specified 414 # resource files to files with attributes and add commands to the script 415 # adding the attributes to the directories. 416 for dir in $(directories) { 417 local resourceFiles = [ on $(dir) return $(ATTRIBUTE_FILES) ] ; 418 if $(resourceFiles) { 419 local dirTokens = [ on $(dir) return $(DIRECTORY_TOKENS) ] ; 420 421 # translate resources file to file with attributes 422 local attributeFile = $(script)-attributes-$(dirTokens:J=-) ; 423 ResAttr $(attributeFile) : $(resourceFiles) ; 424 425 # use a unique dummy target for this file, on which we 426 # can define the TARGET_DIR variable 427 local dummyTarget = $(script)-attributes-dummy-$(dir:G=) ; 428 NotFile $(dummyTarget) ; 429 TARGET_DIR on $(dummyTarget) = $(dir:G=) ; 430 431 Depends $(dummyTarget) : $(initScript) $(attributeFile) 432 $(serializationDependency) ; 433 Depends $(script) : $(dummyTarget) ; 434 serializationDependency = $(dummyTarget) ; 435 436 AppendToContainerMakeDirectoriesScriptAttributes $(dummyTarget) 437 : $(initScript) $(attributeFile) ; 438 } 439 } 440 } 441} 442 443actions piecemeal CreateContainerMakeDirectoriesScript1 444{ 445 echo \$mkdir -p "\"\${tPrefix}$(2:G=)\"" >> $(1) 446} 447 448actions AppendToContainerMakeDirectoriesScriptAttributes 449{ 450 echo \$copyAttrs "\"\${sPrefix}$(2[2])\"" \ 451 "\"\${tPrefix}$(TARGET_DIR)\"" >> $(2[1]) 452} 453 454rule CreateContainerCopyFilesScript container : script 455{ 456 MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ; 457 Always $(script) ; 458 459 local initScript = [ InitScript $(script) ] ; 460 461 local scriptBody 462 = [ FSameTargetWithPrependedGrist $(script) : script-body ] ; 463 LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ; 464 Depends $(scriptBody) : $(initScript) ; 465 Depends $(script) : $(scriptBody) ; 466 467 local serializationDependency = $(scriptBody) ; 468 # Used to create a dependency chain between the dummy targets. 469 # This forces jam to build them one after the other, thus preventing 470 # concurrent writes to the script file when building with multiple 471 # jobs. 472 473 local dir ; 474 for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] { 475 # filter the targets that shall be renamed; they have to be copied 476 # individually 477 local destTargets = [ on $(dir) return $(TARGETS_TO_INSTALL) ] ; 478 local remainingTargets ; 479 local destTarget ; 480 for destTarget in $(destTargets) { 481 local target = [ on $(destTarget) return $(TARGET) ] ; 482 local name = $(destTarget:BS) ; 483 if $(name) != $(target:BS) { 484 # use a unique dummy target for this file, on which we 485 # can define the TARGET_DIR variable 486 local dummyTarget = $(script)-dummy-$(dir:G=)-$(target) ; 487 NotFile $(dummyTarget) ; 488 TARGET_DIR on $(dummyTarget) = $(dir:G=) ; 489 INSTALL_TARGET_NAME on $(dummyTarget) = $(name) ; 490 491 Depends $(dummyTarget) : $(initScript) $(target) 492 $(serializationDependency) ; 493 Depends $(script) : $(dummyTarget) ; 494 serializationDependency = $(dummyTarget) ; 495 496 AppendToContainerCopyFilesScriptSingleFile $(dummyTarget) 497 : $(initScript) $(target) ; 498 } else { 499 remainingTargets += $(target) ; 500 } 501 } 502 targets = $(remainingTargets) ; 503 504 if $(targets) { 505 # use a unique dummy target for this directory, on which we 506 # can define the TARGET_DIR variable 507 local dummyTarget = $(script)-dummy-$(dir:G=) ; 508 NotFile $(dummyTarget) ; 509 TARGET_DIR on $(dummyTarget) = $(dir:G=) ; 510 511 Depends $(dummyTarget) : $(initScript) $(targets) 512 $(serializationDependency) ; 513 Depends $(script) : $(dummyTarget) ; 514 serializationDependency = $(dummyTarget) ; 515 516 OUTPUT_SCRIPT on $(dummyTarget) = $(initScript) ; 517 AppendToContainerCopyFilesScript $(dummyTarget) : $(targets) ; 518 } 519 520 local symlinks = [ on $(dir) return $(SYMLINKS_TO_INSTALL) ] ; 521 local symlink ; 522 for symlink in $(symlinks) { 523 NotFile $(symlink) ; 524 525 Depends $(script) : $(symlink) ; 526 Depends $(symlink) : $(initScript) $(serializationDependency) ; 527 serializationDependency = $(symlink) ; 528 529 AddSymlinkToContainerCopyFilesScript $(symlink) : $(initScript) ; 530 } 531 532 local targetDirs = [ on $(dir) return $(DIRECTORIES_TO_INSTALL) ] ; 533 local targetDir ; 534 for targetDir in $(targetDirs) { 535 NotFile $(targetDir) ; 536 537 Depends $(script) : $(targetDir) ; 538 Depends $(targetDir) : $(initScript) $(serializationDependency) ; 539 serializationDependency = $(targetDir) ; 540 541 AddDirectoryToContainerCopyFilesScript $(targetDir) 542 : $(initScript) ; 543 } 544 } 545} 546 547 548actions piecemeal AppendToContainerCopyFilesScript bind OUTPUT_SCRIPT 549{ 550 echo \$cp "\"\${sPrefix}$(2)\"" "\"\${tPrefix}$(TARGET_DIR)\"" \ 551 >> $(OUTPUT_SCRIPT) 552} 553 554 555actions AppendToContainerCopyFilesScriptSingleFile 556{ 557 echo \$cp "\"\${sPrefix}$(2[2])\"" \ 558 "\"\${tPrefix}$(TARGET_DIR)/$(INSTALL_TARGET_NAME)\"" >> $(2[1]) 559} 560 561 562actions AddSymlinkToContainerCopyFilesScript 563{ 564 echo \$ln -sfn "\"$(SYMLINK_TARGET)\"" "\"\${tPrefix}$(1:G=)\"" >> $(2[1]) 565} 566 567 568actions AddDirectoryToContainerCopyFilesScript 569{ 570 echo \$cp -r $(EXCLUDE_PATTERNS) "\"\${sPrefix}$(SOURCE_DIRECTORY)/.\"" \ 571 "\"\${tPrefix}$(TARGET_DIRECTORY:G=)\"" >> $(2[1]) 572} 573 574 575rule CreateContainerExtractFilesScript container : script 576{ 577 MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ; 578 Always $(script) ; 579 580 local initScript = [ InitScript $(script) ] ; 581 582 local scriptBody 583 = [ FSameTargetWithPrependedGrist $(script) : script-body ] ; 584 LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ; 585 Depends $(scriptBody) : $(initScript) ; 586 Depends $(script) : $(scriptBody) ; 587 588 local serializationDependency = $(scriptBody) ; 589 # Used to create a dependency chain between the dummy targets. 590 # This forces jam to build them one after the other, thus preventing 591 # concurrent writes to the script file when building with multiple 592 # jobs. 593 594 local dir ; 595 for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] { 596 local archiveFiles = [ on $(dir) return $(ARCHIVE_FILES_TO_INSTALL) ] ; 597 local archiveFile ; 598 for archiveFile in $(archiveFiles) { 599 # use a unique dummy target for this file, on which we 600 # can define the TARGET_DIR variable 601 local dummyTarget = $(script)-dummy-$(dir:G=)-$(archiveFile) ; 602 NotFile $(dummyTarget) ; 603 TARGET_DIR on $(dummyTarget) = $(dir:G=) ; 604 605 local extractedSubDir = [ on $(archiveFile) 606 return $(ARCHIVE_SUBDIR_TO_INSTALL_FROM) ] ; 607 ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(dummyTarget) = 608 $(extractedSubDir:E=.) ; 609 610 Depends $(dummyTarget) : $(initScript) $(archiveFile) 611 $(serializationDependency) ; 612 Depends $(script) : $(dummyTarget) ; 613 serializationDependency = $(dummyTarget) ; 614 615 AddExtractFileToContainerExtractFilesScript $(dummyTarget) 616 : $(initScript) $(archiveFile) ; 617 } 618 } 619} 620 621 622actions AddExtractFileToContainerExtractFilesScript 623{ 624 echo extractFile "\"$(2[2])\"" "\"$(TARGET_DIR)\"" \ 625 "\"$(ARCHIVE_SUBDIR_TO_INSTALL_FROM)\"" >> $(2[1]) 626} 627 628 629#pragma mark - Haiku Image rules 630 631rule SetUpdateHaikuImageOnly flag 632{ 633 HAIKU_CONTAINER_UPDATE_ONLY on $(HAIKU_IMAGE_CONTAINER_NAME) = $(flag) ; 634} 635 636rule IsUpdateHaikuImageOnly 637{ 638 on $(HAIKU_IMAGE_CONTAINER_NAME) return $(HAIKU_CONTAINER_UPDATE_ONLY) ; 639} 640 641rule AddDirectoryToHaikuImage directoryTokens : attributeFiles 642{ 643 # AddDirectoryToHaikuImage <directoryTokens> 644 645 local dir = [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) 646 : $(directoryTokens) ] ; 647 648 if $(attributeFiles) { 649 SEARCH on $(attributeFiles) 650 += [ FDirName $(HAIKU_TOP) data image_directories ] ; 651 ATTRIBUTE_FILES on $(dir) += $(attributeFiles) ; 652 } 653 654 return $(dir) ; 655} 656 657rule AddFilesToHaikuImage directory : targets : destName 658{ 659 # AddFilesToHaikuImage <directory> : <targets> [ : dest name ] 660 661 AddFilesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory) 662 : $(targets) : $(destName) ; 663} 664 665rule FFilesInHaikuImageDirectory directoryTokens 666{ 667 return [ FFilesInContainerDirectory $(HAIKU_IMAGE_CONTAINER_NAME) 668 : $(directoryTokens) ] ; 669} 670 671rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName 672{ 673 # AddSymlinkToHaikuImage <directory> : <link target> [ : <link name> ] ; 674 675 AddSymlinkToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens) 676 : $(linkTarget) : $(linkName) ; 677} 678 679rule FSymlinksInHaikuImageDirectory directoryTokens 680{ 681 return [ FSymlinksInContainerDirectory $(HAIKU_IMAGE_CONTAINER_NAME) 682 : $(directoryTokens) ] ; 683} 684 685rule CopyDirectoryToHaikuImage directoryTokens : sourceDirectory 686 : targetDirectoryName : excludePatterns : alwaysUpdate 687{ 688 CopyDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens) 689 : $(sourceDirectory) : $(targetDirectoryName) : $(excludePatterns) 690 : $(alwaysUpdate) ; 691} 692 693rule AddSourceDirectoryToHaikuImage dirTokens : alwaysUpdate 694{ 695 # AddSourceDirectoryToHaikuImage <dirTokens> : <alwaysUpdate> ; 696 697 CopyDirectoryToHaikuImage home HaikuSources 698 : [ FDirName $(HAIKU_TOP) $(dirTokens) ] 699 : : -x .svn : $(alwaysUpdate) ; 700} 701 702rule AddHeaderDirectoryToHaikuImage dirTokens : dirName : alwaysUpdate 703{ 704 # AddHeaderDirectoryToHaikuImage <dirTokens> : [ <dirName> ] 705 # : <alwaysUpdate> ; 706 707 CopyDirectoryToHaikuImage develop headers 708 : [ FDirName $(HAIKU_TOP) headers $(dirTokens) ] 709 : $(dirName) : -x .svn : $(alwaysUpdate) ; 710} 711 712rule AddWifiFirmwareToHaikuImage driver : package : archive : extract 713{ 714 #AddWifiFirmwareToHaikuImage <driver> : <package> : <archive> : <extract> 715 716 # complete location to wifi firmware archive 717 local firmwareArchive = [ FDirName 718 $(HAIKU_TOP) data system data firmware $(driver) $(archive) ] ; 719 720 local dirTokens = system data firmware $(driver) ; 721 if $(extract) = true || $(extract) = 1 { 722 ExtractArchiveToHaikuImage $(dirTokens) : $(firmwareArchive) : 723 : $(package) ; 724 } else { 725 AddFilesToHaikuImage $(dirTokens) : $(firmwareArchive) ; 726 } 727} 728 729rule ExtractArchiveToHaikuImage dirTokens : archiveFile : alwaysUpdate 730 : extractedSubDir 731{ 732 # ExtractArchiveToHaikuImage <dirTokens> : <archiveFile> : <alwaysUpdate> 733 # : <extractedSubDir> ; 734 735 # If the image shall only be updated, we extract only, if explicitely 736 # requested. 737 if ! [ IsUpdateHaikuImageOnly ] || $(alwaysUpdate) { 738 ExtractArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens) 739 : $(archiveFile) : $(extractedSubDir) ; 740 } 741} 742 743rule AddDriversToHaikuImage relativeDirectoryTokens : targets 744{ 745 # AddDriversToHaikuImage <relative directory> : <targets> ; 746 747 AddDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME) 748 : $(relativeDirectoryTokens) : $(targets) ; 749} 750 751rule AddNewDriversToHaikuImage relativeDirectoryTokens : targets 752{ 753 # AddNewDriversToHaikuImage <relative directory> : <targets> ; 754 755 AddNewDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME) 756 : $(relativeDirectoryTokens) : $(targets) ; 757} 758 759rule AddBootModuleSymlinksToHaikuImage targets 760{ 761 # AddBootModuleSymlinksToHaikuImage <targets> ; 762 763 AddBootModuleSymlinksToContainer $(HAIKU_IMAGE_CONTAINER_NAME) 764 : $(targets) ; 765} 766 767rule AddOptionalHaikuImagePackages packages 768{ 769 local package ; 770 for package in $(packages) { 771 if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] { 772 HAIKU_OPTIONAL_PACKAGE_ADDED on $(package) = 1 ; 773 HAIKU_ADDED_OPTIONAL_PACKAGES += $(package) ; 774 } 775 local dependencies = [ on $(package) 776 return $(HAIKU_OPTIONAL_PACKAGE_DEPENDENCIES) ] ; 777 AddOptionalHaikuImagePackages $(dependencies) ; 778 } 779} 780 781rule SuppressOptionalHaikuImagePackages packages 782{ 783 local package ; 784 for package in $(packages) { 785 if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_SUPPRESSED) ] { 786 HAIKU_OPTIONAL_PACKAGE_SUPPRESSED on $(package) = 1 ; 787 } 788 } 789} 790 791rule IsOptionalHaikuImagePackageAdded package 792{ 793 if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_EXISTS) ] { 794 HAIKU_OPTIONAL_PACKAGE_EXISTS on $(package) = 1 ; 795 HAIKU_EXISTING_OPTIONAL_PACKAGES += $(package) ; 796 } 797 798 if [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] && 799 ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_SUPPRESSED) ] { 800 return 1 ; 801 } 802 803 return ; 804} 805 806rule OptionalPackageDependencies package : dependencies 807{ 808 HAIKU_OPTIONAL_PACKAGE_DEPENDENCIES on $(package) = $(dependencies) ; 809 if [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] { 810 AddOptionalHaikuImagePackages $(dependencies) ; 811 } 812} 813 814rule InstallSourceArchive file : url 815{ 816 if $(HAIKU_INCLUDE_SOURCES) = 1 { 817 # download archive file 818 local archiveFile = [ DownloadFile $(file) : $(url) ] ; 819 820 # copy directly into image 821 AddFilesToHaikuImage _sources_ : $(archiveFile) ; 822 } 823} 824 825rule InstallOptionalHaikuImagePackage package : url : dirTokens : isCDPackage 826{ 827 # download archive file 828 local archiveFile = [ DownloadFile $(package) : $(url) ] ; 829 830 if ( $(isCDPackage) = true || $(isCDPackage) = 1 ) && $(HAIKU_CD_NAME) { 831 # TODO: If HAIKU_CD_NAME is set, that doesn't mean we're building a CD 832 # image! 833 # copy onto image 834 AddFilesToHaikuImage _packages_ : $(archiveFile) ; 835 } else { 836 # extract onto image 837 ExtractArchiveToHaikuImage $(dirTokens) : $(archiveFile) ; 838 } 839} 840 841rule AddEntryToHaikuImageUserGroupFile file : entry 842{ 843 local allEntries = [ on $(file) return $(HAIKU_IMAGE_USER_GROUP_ENTRIES) ] ; 844 845 if $(allEntries) { 846 allEntries = $(allEntries)|$(entry) ; 847 } else { 848 allEntries = $(entry) ; 849 850 Always $(file) ; 851 MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ; 852 BuildHaikuImageUserGroupFile $(file) ; 853 AddFilesToHaikuImage common etc : $(file) ; 854 } 855 856 HAIKU_IMAGE_USER_GROUP_ENTRIES on $(file) = $(allEntries) ; 857} 858 859actions BuildHaikuImageUserGroupFile 860{ 861 echo "$(HAIKU_IMAGE_USER_GROUP_ENTRIES)" | tr '|' '\n' > $(1) 862} 863 864rule AddUserToHaikuImage user : uid : gid : home : shell : realName 865{ 866 if ! $(user) || ! $(uid) || ! $(gid) || ! $(home) { 867 Exit "Invalid haiku user specification passed to AddUserToHaikuImage." ; 868 } 869 870 local entry 871 = $(user):x:$(uid):$(gid):$(realName:E=$(user)):$(home):$(shell:E="") ; 872 873 AddEntryToHaikuImageUserGroupFile <haiku-image>passwd : $(entry) ; 874} 875 876rule AddGroupToHaikuImage group : gid : members 877{ 878 if ! $(group) || ! $(gid) { 879 Exit "Invalid haiku group specification passed to" 880 "AddGroupToHaikuImage." ; 881 } 882 883 local entry = $(group):x:$(gid):$(members:J=,:E) ; 884 885 AddEntryToHaikuImageUserGroupFile <haiku-image>group : $(entry) ; 886} 887 888rule AddEntryToHaikuImageExpanderRuleFile file : entry 889{ 890 local allEntries 891 = [ on $(file) return $(HAIKU_IMAGE_EXPANDER_RULES_ENTRIES) ] ; 892 893 if $(allEntries) { 894 allEntries = $(allEntries)!$(entry) ; 895 } else { 896 allEntries = $(entry) ; 897 898 Always $(file) ; 899 MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ; 900 BuildHaikuImageExpanderRules $(file) ; 901 AddFilesToHaikuImage common data : $(file) ; 902 } 903 904 HAIKU_IMAGE_EXPANDER_RULES_ENTRIES on $(file) = $(allEntries) ; 905} 906 907actions BuildHaikuImageExpanderRules 908{ 909 echo -e "$(HAIKU_IMAGE_EXPANDER_RULES_ENTRIES)" | tr '!' '\n' > $(1) 910} 911 912rule AddExpanderRuleToHaikuImage mimetype : extension : list : extract 913{ 914 #AddExpanderRuleToHaikuImage <mimetype> : <extension> : <list> : <extract> 915 916 if ! $(mimetype) || ! $(extension) || ! $(list) || ! $(extract) { 917 Exit "Invalid expander rule specification passed to AddExpanderRule." ; 918 } 919 920 local entry = "\\\"$(mimetype)\\\"\\\t$(extension)\\\t\\\"$(list)\\\"\\\t\\\"$(extract)\\\"" ; 921 AddEntryToHaikuImageExpanderRuleFile <haiku-image>expander.rules 922 : $(entry) ; 923} 924 925rule AddInstalledPackagesFileToHaikuImage 926{ 927 #AddInstalledPackagesFileToHaikuImage 928 local file = <haiku-image>InstalledPackages ; 929 930 Always $(file) ; 931 MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ; 932 BuildHaikuImageInstalledPackagesFile $(file) ; 933 AddFilesToHaikuImage common data optional-packages : $(file) ; 934} 935 936actions BuildHaikuImageInstalledPackagesFile 937{ 938 echo -e "$(HAIKU_ADDED_OPTIONAL_PACKAGES)" | tr '\ ' '\n' > $(1) 939} 940 941rule AddOptionalPackageDescriptionToHaikuImage file : searchPath 942{ 943 if $(searchPath) { 944 SEARCH on $(file) = [ FDirName $(searchPath) ] ; 945 } 946 947 HAIKU_IMAGE_OPTIONAL_PACKAGE_DESCRIPTIONS += $(file) ; 948} 949 950rule AddLicenseToHaikuImage file : name : searchPath 951{ 952 if $(searchPath) { 953 SEARCH on $(file) = [ FDirName $(searchPath) ] ; 954 } 955 956 if $(name) && $(file:BS) = $(name) { 957 name = ; 958 } 959 960 AddFilesToHaikuImage system data licenses : $(file) : $(name) ; 961} 962 963 964rule CreateHaikuImageMakeDirectoriesScript script 965{ 966 CreateContainerMakeDirectoriesScript $(HAIKU_IMAGE_CONTAINER_NAME) 967 : $(script) ; 968} 969 970rule CreateHaikuImageCopyFilesScript script 971{ 972 CreateContainerCopyFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ; 973} 974 975rule CreateHaikuImageExtractFilesScript script 976{ 977 CreateContainerExtractFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) 978 : $(script) ; 979} 980 981rule BuildHaikuImage haikuImage : scripts : isImage : isVMwareImage 982{ 983 # BuildHaikuImage <haiku image> : <scripts> : <is image> : <isVMwareImage> ; 984 985 if $(isImage) = 1 || $(isImage) = true { 986 IS_IMAGE on $(haikuImage) = 1 ; 987 } else { 988 IS_IMAGE on $(haikuImage) = "" ; 989 } 990 991 if $(isVMwareImage) = 1 || $(isVMwareImage) = true { 992 IS_VMWARE_IMAGE on $(haikuImage) = 1 ; 993 } else { 994 IS_VMWARE_IMAGE on $(haikuImage) = "" ; 995 } 996 997 local mainScript = build_haiku_image ; 998 SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ; 999 1000 Depends $(haikuImage) : $(mainScript) $(scripts) ; 1001 BuildHaikuImage1 $(haikuImage) : $(mainScript) $(scripts) ; 1002} 1003 1004actions BuildHaikuImage1 1005{ 1006 export imagePath="$(1)" 1007 export isImage="$(IS_IMAGE)" 1008 export isVMwareImage="$(IS_VMWARE_IMAGE)" 1009 $(2[1]) $(2[2-]) 1010} 1011 1012rule BuildVMWareImage vmwareImage : plainImage : imageSize 1013{ 1014 # BuildVMWareImage <vmware image> : <plain image> : <image size in MB> 1015 1016 IMAGE_SIZE on $(vmwareImage) = $(imageSize) ; 1017 1018 Depends $(vmwareImage) : <build>vmdkheader $(plainImage) ; 1019 BuildVMWareImage1 $(vmwareImage) : <build>vmdkheader $(plainImage) ; 1020} 1021 1022actions BuildVMWareImage1 1023{ 1024 $(RM) $(1) 1025 $(2[1]) -h 64k -i$(IMAGE_SIZE)M $(1) && 1026 cat $(2[2]) >> $(1) 1027} 1028 1029 1030#pragma mark - Network Boot Archive rules 1031 1032rule AddDirectoryToNetBootArchive directoryTokens 1033{ 1034 # AddDirectoryToNetBootArchive <directoryTokens> 1035 1036 return [ AddDirectoryToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1037 : $(directoryTokens) ] ; 1038} 1039 1040rule AddFilesToNetBootArchive directory : targets : destName 1041{ 1042 # AddFilesToNetBootArchive <directory> : <targets> [ : dest name ] 1043 1044 AddFilesToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(directory) 1045 : $(targets) : $(destName) ; 1046} 1047 1048rule AddSymlinkToNetBootArchive directoryTokens : linkTarget : linkName 1049{ 1050 # AddSymlinkToNetBootArchive <directory> : <link target> [ : <link name> ] ; 1051 1052 AddSymlinkToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1053 : $(directoryTokens) : $(linkTarget) : $(linkName) ; 1054} 1055 1056rule AddDriversToNetBootArchive relativeDirectoryTokens : targets 1057{ 1058 # AddDriversToNetBootArchive <relative directory> : <targets> ; 1059 1060 AddDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1061 : $(relativeDirectoryTokens) : $(targets) ; 1062} 1063 1064rule AddNewDriversToNetBootArchive relativeDirectoryTokens : targets 1065{ 1066 # AddNewDriversToNetBootArchive <relative directory> : <targets> ; 1067 1068 AddNewDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1069 : $(relativeDirectoryTokens) : $(targets) ; 1070} 1071 1072rule AddDriverRegistrationToNetBootArchive relativeDirectoryTokens : target 1073 : links 1074{ 1075 # AddDriverRegistrationToNetBootArchive <directory> : <link target> 1076 # : <link names> ] ; 1077 1078 AddDriverRegistrationToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1079 : $(relativeDirectoryTokens) : $(target) : $(links) ; 1080} 1081 1082rule AddBootModuleSymlinksToNetBootArchive targets 1083{ 1084 # AddBootModuleSymlinksToNetBootArchive <targets> ; 1085 1086 AddBootModuleSymlinksToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1087 : $(targets) ; 1088} 1089 1090rule CreateNetBootArchiveMakeDirectoriesScript script 1091{ 1092 CreateContainerMakeDirectoriesScript 1093 $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(script) ; 1094} 1095 1096rule CreateNetBootArchiveCopyFilesScript script 1097{ 1098 CreateContainerCopyFilesScript $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) 1099 : $(script) ; 1100} 1101 1102rule BuildNetBootArchive archive : scripts 1103{ 1104 # BuildNetBootArchive <archive> : <scripts> ; 1105 1106 local mainScript = build_archive ; 1107 SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ; 1108 1109 Depends $(archive) : $(mainScript) $(scripts) ; 1110 BuildNetBootArchive1 $(archive) : $(mainScript) $(scripts) ; 1111} 1112 1113actions BuildNetBootArchive1 1114{ 1115 $(2[1]) $(1) $(2[2-]) 1116} 1117 1118 1119#pragma mark - Alternative GCC Archive rules 1120 1121 1122rule AddDirectoryToAlternativeGCCArchive directoryTokens 1123{ 1124 # AddDirectoryToAlternativeGCCArchive <directoryTokens> 1125 1126 return [ AddDirectoryToContainer 1127 $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(directoryTokens) ] ; 1128} 1129 1130rule AddFilesToAlternativeGCCArchive directory : targets : destName 1131{ 1132 # AddFilesToAlternativeGCCArchive <directory> : <targets> [ : dest name ] 1133 1134 AddFilesToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) 1135 : $(directory) : $(targets) : $(destName) ; 1136} 1137 1138rule AddSymlinkToAlternativeGCCArchive directoryTokens : linkTarget : linkName 1139{ 1140 # AddSymlinkToAlternativeGCCArchive <directory> : <link target> 1141 # [ : <link name> ] ; 1142 1143 AddSymlinkToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) 1144 : $(directoryTokens) : $(linkTarget) : $(linkName) ; 1145} 1146 1147rule CopyDirectoryToAlternativeGCCArchive directoryTokens : sourceDirectory 1148 : targetDirectoryName : excludePatterns : alwaysUpdate 1149{ 1150 CopyDirectoryToContainer $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) 1151 : $(directoryTokens) : $(sourceDirectory) : $(targetDirectoryName) 1152 : $(excludePatterns) : $(alwaysUpdate) ; 1153} 1154 1155rule CreateAlternativeGCCArchiveMakeDirectoriesScript script 1156{ 1157 CreateContainerMakeDirectoriesScript 1158 $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(script) ; 1159} 1160 1161rule CreateAlternativeGCCArchiveCopyFilesScript script 1162{ 1163 CreateContainerCopyFilesScript 1164 $(HAIKU_ALTERNATIVE_GCC_ARCHIVE_CONTAINER_NAME) : $(script) ; 1165} 1166 1167rule BuildAlternativeGCCArchive archive : scripts 1168{ 1169 # BuildAlternativeGCCArchive <archive> : <scripts> ; 1170 1171 local mainScript = build_archive ; 1172 SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ; 1173 1174 Depends $(archive) : $(mainScript) $(scripts) ; 1175 BuildAlternativeGCCArchive1 $(archive) : $(mainScript) $(scripts) ; 1176} 1177 1178actions BuildAlternativeGCCArchive1 1179{ 1180 $(2[1]) $(1) $(2[2-]) 1181} 1182 1183 1184#pragma mark - Haiku Hybrid Image rules 1185 1186 1187rule AddFilesToHaikuHybridImage directory : targets : destName 1188 : useABISubDir 1189{ 1190 # AddFilesToHaikuHybridImage <directory> : <targets> : <destName> 1191 # : <useABISubDir> 1192 # 1193 # Convenience rule calling both AddFilesToHaikuImage and 1194 # AddFilesToAlternativeGCCArchive. 1195 # 1196 # <useABISubDir> 1197 # if non-empty, specifies that an ABI subdirectory shall be appended to 1198 # <directory> for the alternative GCC archive. 1199 1200 local alternativeSubDir ; 1201 if $(useABISubDir) { 1202 alternativeSubDir = gcc$(HAIKU_GCC_VERSION[1]) ; 1203 } 1204 1205 AddFilesToHaikuImage $(directory) : $(targets) : $(destName) ; 1206 AddFilesToAlternativeGCCArchive $(directory) $(alternativeSubDir) 1207 : $(targets) : $(destName) ; 1208} 1209 1210rule AddSymlinkToHaikuHybridImage directoryTokens : linkTarget : linkName 1211 : useSymlinkTargetABISubDir : useABISubDir 1212{ 1213 # AddSymlinkToHaikuHybridImage <directoryTokens> : <linkTarget> : <linkName> 1214 # [ : <useSymlinkTargetABISubDir> [ : <useABISubDir> ] ] 1215 # 1216 # Convenience rule calling both AddSymlinkToHaikuImage and 1217 # AddSymlinkToAlternativeGCCArchive. 1218 # 1219 # <linkTarget> 1220 # Can be a list of components that will be joined to path inserting 1221 # "/"s inbetween. 1222 # <useSymlinkTargetABISubDir> 1223 # If non-empty, specifies that an ABI subdirectory shall be inserted 1224 # into <linkTarget> (between the first and second component) for the 1225 # alternative GCC archive. 1226 # <useABISubDir> 1227 # If non-empty, specifies that an ABI subdirectory part shall be appended 1228 # to the directory tokens for the alternative GCC archive. 1229 1230 local alternativeDirTokens = $(directoryTokens) ; 1231 if $(useABISubDir) { 1232 alternativeDirTokens += gcc$(HAIKU_GCC_VERSION[1]) ; 1233 } 1234 1235 local alternativeLinkTarget = $(linkTarget) ; 1236 if $(useSymlinkTargetABISubDir) { 1237 alternativeLinkTarget = $(linkTarget[1]) gcc$(HAIKU_GCC_VERSION[1]) 1238 $(linkTarget[2-]) ; 1239 } 1240 linkTarget = $(linkTarget:J=/) ; 1241 alternativeLinkTarget = $(alternativeLinkTarget:J=/) ; 1242 1243 AddSymlinkToHaikuImage $(directoryTokens) : $(linkTarget) : $(linkName) ; 1244 AddSymlinkToAlternativeGCCArchive $(alternativeDirTokens) 1245 : $(alternativeLinkTarget) : $(linkName) ; 1246} 1247 1248rule AddLibrariesToHaikuHybridImage directory : libs 1249{ 1250 # AddLibraryToHaikuHybridImage <directory> : <libs> 1251 # 1252 # Installs libraries with the appropriate links onto the image. 1253 # 1254 1255 local lib ; 1256 for lib in $(libs) { 1257 local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ; 1258 if $(abiVersion) { 1259 local abiVersionedLib = $(lib).$(abiVersion) ; 1260 AddFilesToHaikuHybridImage $(directory) 1261 : $(lib) : $(abiVersionedLib) : true ; 1262 AddSymlinkToHaikuHybridImage $(directory) 1263 : $(abiVersionedLib) : $(lib) : : true ; 1264 } else { 1265 AddFilesToHaikuHybridImage $(directory) : $(lib) : : true ; 1266 } 1267 } 1268} 1269 1270 1271#pragma mark - Floppy Boot Archive rules 1272 1273 1274rule AddDirectoryToFloppyBootArchive directoryTokens 1275{ 1276 # AddDirectoryToFloppyBootArchive <directoryTokens> 1277 1278 return [ AddDirectoryToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1279 : $(directoryTokens) ] ; 1280} 1281 1282rule AddFilesToFloppyBootArchive directory : targets : destName 1283{ 1284 # AddFilesToFloppyBootArchive <directory> : <targets> [ : dest name ] 1285 1286 AddFilesToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) : $(directory) 1287 : $(targets) : $(destName) ; 1288} 1289 1290rule AddSymlinkToFloppyBootArchive directoryTokens : linkTarget : linkName 1291{ 1292 # AddSymlinkToFloppyBootArchive <directory> : <link target> 1293 # [ : <link name> ] ; 1294 1295 AddSymlinkToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1296 : $(directoryTokens) : $(linkTarget) : $(linkName) ; 1297} 1298 1299rule AddDriversToFloppyBootArchive relativeDirectoryTokens : targets 1300{ 1301 # AddDriversToFloppyBootArchive <relative directory> : <targets> ; 1302 1303 AddDriversToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1304 : $(relativeDirectoryTokens) : $(targets) ; 1305} 1306 1307rule AddNewDriversToFloppyBootArchive relativeDirectoryTokens : targets 1308{ 1309 # AddNewDriversToFloppyBootArchive <relative directory> : <targets> ; 1310 1311 AddNewDriversToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1312 : $(relativeDirectoryTokens) : $(targets) ; 1313} 1314 1315rule AddDriverRegistrationToFloppyBootArchive relativeDirectoryTokens : target 1316 : links 1317{ 1318 # AddDriverRegistrationToFloppyBootArchive <directory> : <link target> 1319 # : <link names> ] ; 1320 1321 AddDriverRegistrationToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1322 : $(relativeDirectoryTokens) : $(target) : $(links) ; 1323} 1324 1325rule AddBootModuleSymlinksToFloppyBootArchive targets 1326{ 1327 # AddBootModuleSymlinksToFloppyBootArchive <targets> ; 1328 1329 AddBootModuleSymlinksToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1330 : $(targets) ; 1331} 1332 1333rule CreateFloppyBootArchiveMakeDirectoriesScript script 1334{ 1335 CreateContainerMakeDirectoriesScript 1336 $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) : $(script) ; 1337} 1338 1339rule CreateFloppyBootArchiveCopyFilesScript script 1340{ 1341 CreateContainerCopyFilesScript $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) 1342 : $(script) ; 1343} 1344 1345rule BuildFloppyBootArchive archive : scripts 1346{ 1347 # BuildHFloppyBootArchive <archive> : <scripts> ; 1348 1349 local mainScript = build_archive ; 1350 SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ; 1351 1352 Depends $(archive) : $(mainScript) $(scripts) ; 1353 BuildFloppyBootArchive1 $(archive) : $(mainScript) $(scripts) ; 1354} 1355 1356actions BuildFloppyBootArchive1 1357{ 1358 $(2[1]) $(1) $(2[2-]) 1359} 1360 1361# warning: that is quite x86 dependant... 1362 1363rule BuildFloppyBootImage image : haikuLoader : archive 1364{ 1365 Depends $(image) : $(haikuLoader) ; 1366 Depends $(image) : $(archive) ; 1367 #MakeLocateDebug $(image) ; 1368 FLOPPY_IMAGE_SIZE on $(image) = $(HAIKU_BOOT_FLOPPY_IMAGE_SIZE) ; 1369 ARCHIVE_IMAGE_OFFSET on $(image) = $(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ; 1370 BuildFloppyBootImage1 $(image) : $(haikuLoader) $(archive) ; 1371 if $(HAIKU_BOOT_PLATFORM) = atari_m68k { 1372 Depends $(image) : <build>fixup_tos_boot_checksum ; 1373 BuildFloppyBootImageFixupM68K $(image) 1374 : <build>fixup_tos_boot_checksum ; 1375 } 1376 if $(HAIKU_BOOT_PLATFORM) = amiga_m68k { 1377 Depends $(image) : <build>fixup_amiga_boot_checksum ; 1378 BuildFloppyBootImageFixupM68K $(image) 1379 : <build>fixup_amiga_boot_checksum ; 1380 } 1381} 1382 1383actions BuildFloppyBootImage1 1384{ 1385 haiku_loader_size=`stat -c %s "$(>[1])"` 1386 if [ $? -ne 0 ] ; then 1387 # FreeBSD's stat command don't support -c/--format option 1388 # and use %z specifier for file size 1389 haiku_loader_size=`stat -f %z "$(>[1])"` 1390 fi 1391 archive_image_offset=`echo "$(ARCHIVE_IMAGE_OFFSET) * 1024" | bc` 1392 if [ $haiku_loader_size -gt $archive_image_offset ] ; then 1393 echo "Error: $(>[1]) is too big ($haiku_loader_size) to fit " 1394 echo " before the boot archive starting at $archive_image_offset!" 1395 exit 1 1396 fi 1397 $(RM) $(<) 1398 # make an empty image 1399 dd if=/dev/zero of=$(<) bs=1k count=$(FLOPPY_IMAGE_SIZE) 1400 # add haiku_loader 1401 dd if=$(>[1]) of=$(<) conv=notrunc 1402 # add the boot drivers tgz archive 1403 dd if=$(>[2]) of=$(<) bs=$(ARCHIVE_IMAGE_OFFSET)k seek=1 conv=notrunc 1404} 1405 1406actions BuildFloppyBootImageFixupM68K 1407{ 1408 # fixup the boot sector checksum 1409 $(>[1]) $(<) 1410} 1411 1412#pragma mark - CD Boot Image rules 1413 1414rule BuildCDBootImage image : bootfloppy : extrafiles 1415{ 1416 Depends $(image) : $(bootfloppy) ; 1417 Depends $(image) : $(extrafiles) ; 1418 BOOTIMG on $(image) = $(bootfloppy) ; 1419 1420 BuildCDBootImage1 $(image) : $(bootfloppy) $(extrafiles) ; 1421} 1422 1423actions BuildCDBootImage1 1424{ 1425 $(RM) $(<) 1426 mkisofs -b $(BOOTIMG) -r -J -V bootimg -o $(<) $(>[1]) $(>[2-]) 1427} 1428 1429 1430#pragma mark - CD Boot PPC Image rules 1431 1432rule BuildCDBootPPCImage image : hfsmaps : elfloader : coffloader : chrpscript 1433 : extrafiles 1434{ 1435 Depends $(image) : $(elfloader) ; 1436 Depends $(image) : $(coffloader) ; 1437 Depends $(image) : $(chrpscript) ; 1438 Depends $(image) : $(extrafiles) ; 1439 Depends $(image) : $(hfsmaps) ; 1440 MAPS on $(image) = $(hfsmaps) ; 1441 1442 BuildCDBootPPCImage1 $(image) : $(elfloader) $(coffloader) $(chrpscript) 1443 $(extrafiles) ; 1444} 1445 1446actions BuildCDBootPPCImage1 bind MAPS 1447{ 1448 $(RM) $(<) 1449 mkdir -p $(HAIKU_OUTPUT_DIR)/cd/ppc 1450 cp $(>) $(HAIKU_OUTPUT_DIR)/cd/ppc/ 1451 cp $(>[3]) $(HAIKU_OUTPUT_DIR)/cd/ppc/bootinfo.txt 1452 cp $(>[1]) $(HAIKU_OUTPUT_DIR)/cd/ofwboot.elf 1453 cp $(>[2]) $(HAIKU_OUTPUT_DIR)/cd/ofwboot.xcf 1454 #mkisofs -r -U -chrp-boot -V bootimg -o $(<) $(>[1]) $(>[2-]) 1455 #mkisofs -hfs -r -U -chrp-boot -part -map $(MAPS) -no-desktop \ 1456 # -hfs-volid bootimg -V bootimg -prep-boot $(>[1]:D=) -o $(<) $(>[1]) 1457 # - $(>[2-]) 1458 #mkisofs -v -hfs -part -map $(MAPS) -no-desktop -hfs-volid bootimg \ 1459 # -V bootimg -hfs-bless $(HAIKU_OUTPUT_DIR)/cd/ppc -r -o $(<) $(>[1]) \ 1460 # $(>[2-]) $(HAIKU_OUTPUT_DIR)/cd 1461 #mkisofs -r -U -chrp-boot -V bootimg -prep-boot $(>[1]:D=) -o $(<) $(>[1]) \ 1462 # $(>[2-]) 1463 #mkisofs -r -U -V bootimg -prep-boot $(>[1]:D=) -o $(<) $(>[1]) $(>[2-]) 1464 # $(HAIKU_OUTPUT_DIR)/cd 1465 # -hfs -hfs-bless . 1466 mkisofs -v -hfs -part -map $(MAPS) -no-desktop -hfs-volid bootimg \ 1467 -V bootimg -hfs-bless $(HAIKU_OUTPUT_DIR)/cd/ppc -prep-boot \ 1468 ppc/$(>[2]:D=) -r -o $(<) $(HAIKU_OUTPUT_DIR)/cd 1469 #$(RM) -R $(HAIKU_OUTPUT_DIR)/cd 1470} 1471 1472 1473