444b035d5d
Missed that when adding the script. Therefore it would be created in the current directory and when building multiple packages concurrently the script would be overwritten.
454 lines
13 KiB
Plaintext
454 lines
13 KiB
Plaintext
#-------------------------------------------------------------------------------
|
|
# Packages for OBOS alpha/beta testers
|
|
#-------------------------------------------------------------------------------
|
|
|
|
rule Copy
|
|
{
|
|
if $(2) {
|
|
SEARCH on $(2) += $(SEARCH_SOURCE) ;
|
|
Depends $(1) : <build>copyattr $(2) ;
|
|
Copy1 $(1) : <build>copyattr $(2) ;
|
|
}
|
|
}
|
|
|
|
actions Copy1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
"$(2[1])" -d "$(2[2-])" "$(1)"
|
|
}
|
|
|
|
rule Packages
|
|
{
|
|
local packagenames = $(1) ;
|
|
local packagefiles = $(2) ;
|
|
local path = $(3) ;
|
|
for name in $(packagenames) {
|
|
Package $(name) : $(packagefiles) : $(path) ;
|
|
}
|
|
}
|
|
|
|
rule FPackageConfigSubPath
|
|
{
|
|
# FPackageConfigSubPath <packagename>
|
|
#
|
|
local packagename = $(1) ;
|
|
|
|
local configSubPath ;
|
|
on $(packagename) {
|
|
if $(PLATFORM) = host {
|
|
configSubPath = $(HOST_PLATFORM) $(HOST_ARCH) ;
|
|
} else {
|
|
configSubPath = $(TARGET_PLATFORM) $(TARGET_ARCH) ;
|
|
}
|
|
|
|
if $(DEBUG) = 0 {
|
|
configSubPath += release ;
|
|
} else {
|
|
configSubPath += debug_$(DEBUG) ;
|
|
}
|
|
}
|
|
|
|
return $(configSubPath) ;
|
|
}
|
|
|
|
rule Package
|
|
{
|
|
local packagename = $(1) ;
|
|
local packagefiles = $(2) ;
|
|
local path = $(3) ;
|
|
|
|
local configSubPath = [ FPackageConfigSubPath $(packagename) ] ;
|
|
local packagezip = $(packagename:S=.zip:G=_packages) ;
|
|
local targetDir = [ FDirName $(HAIKU_PACKAGE_DIR) $(configSubPath) ] ;
|
|
local packagedir = [ FDirName $(targetDir) $(packagename) ] ;
|
|
|
|
local installscript = install.sh ;
|
|
local packageinstallscript = $(installscript:G=_packages!$(packagename)) ;
|
|
local installzip = install.zip ;
|
|
local packageinstallzip = $(installzip:G=_packages!$(packagename)) ;
|
|
|
|
local packageobjectdir = [ FDirName $(HAIKU_PACKAGE_OBJECT_DIR)
|
|
$(configSubPath) $(packagename) ] ;
|
|
local packagefiledir = [ FDirName $(packageobjectdir) $(path) ] ;
|
|
local packagefileinstallzip
|
|
= $(installzip:G=_package_objects!$(packagename)) ;
|
|
|
|
# add the files to the install.zip
|
|
local packagefilegrist = [ FGrist _package_files $(packagename) $(path) ] ;
|
|
for file in $(packagefiles) {
|
|
if $(path[0]) = "boot" {
|
|
local packagefile = $(file:G=$(packagefilegrist)) ;
|
|
MakeLocate $(packagefile) : $(packagefiledir) ;
|
|
Copy $(packagefile) : $(file) ;
|
|
Clean cleanPackages : $(packagefile) ;
|
|
PackageInstallZip $(packagefileinstallzip) : $(packagefile) ;
|
|
} else {
|
|
local packagefile = $(file:G=_packages!$(packagename)) ;
|
|
MakeLocate $(packagefile) : $(packagedir) ;
|
|
Copy $(packagefile) : [ FGristFiles $(file) ] ;
|
|
Clean cleanPackages : $(packagefile) ;
|
|
Depends $(packagezip) : $(packagefile) ;
|
|
}
|
|
}
|
|
|
|
# general setup for this package -- only on first invocation
|
|
if ! $(_setup_$(packagename)) {
|
|
_setup_$(packagename) = true ;
|
|
|
|
NotFile $(packagename) ;
|
|
LocalDepends packages : $(packagename) ;
|
|
|
|
MakeLocate $(packagezip) : $(targetDir) ;
|
|
MakeLocate $(packageinstallscript) : $(packagedir) ;
|
|
MakeLocate $(packageinstallzip) : $(packagedir) ;
|
|
MakeLocate $(packagefileinstallzip) : $(packageobjectdir) ;
|
|
|
|
PackageInstallScript $(packageinstallscript) : $(packagedir) ;
|
|
LinkInstallZip $(packageinstallzip) : $(packagefileinstallzip) ;
|
|
Depends $(packagename) : $(packagezip) ;
|
|
PackageZip $(packagezip) : $(packagedir)
|
|
: $(packageinstallscript) $(packageinstallzip) ;
|
|
}
|
|
|
|
}
|
|
|
|
rule PackageSymLink
|
|
{
|
|
# PackageSymLink <packageName> : <symlink path components>
|
|
# : <symlink target>
|
|
#
|
|
local packagename = $(1) ;
|
|
local symlinkPath = $(2) ;
|
|
local symlinkTarget = $(3) ;
|
|
|
|
local configSubPath = [ FPackageConfigSubPath $(packagename) ] ;
|
|
|
|
local symlinkDir = [ FReverse $(symlinkPath) ] ;
|
|
local symlink = $(symlinkDir[1]) ;
|
|
symlinkDir = [ FReverse $(symlinkDir[2-]) ] ;
|
|
local symlinkGrist = [ FGrist _package $(packagename) $(symlinkDir) ] ;
|
|
symlink = $(symlink:G=$(symlinkGrist)) ;
|
|
|
|
if $(symlinkDir[1]) = boot {
|
|
local installzip = install.zip ;
|
|
local packagefileinstallzip
|
|
= $(installzip:G=_package_objects!$(packagename)) ;
|
|
|
|
local packageobjectdir = [ FDirName $(HAIKU_PACKAGE_OBJECT_DIR)
|
|
$(configSubPath) $(packagename) ] ;
|
|
symlinkDir = [ FDirName $(packageobjectdir) $(symlinkDir) ] ;
|
|
|
|
PackageInstallZip $(packagefileinstallzip) : $(symlink) ;
|
|
|
|
} else {
|
|
local packagezip = $(packagename:S=.zip:G=_packages) ;
|
|
|
|
local packagedir = [ FDirName $(HAIKU_PACKAGE_DIR) $(configSubPath)
|
|
$(packagename) ] ;
|
|
symlinkDir = [ FDirName $(packagedir) $(symlinkDir) ] ;
|
|
|
|
Depends $(packagezip) : $(symlink) ;
|
|
}
|
|
|
|
MakeLocate $(symlink) : $(symlinkDir) ;
|
|
SymLink $(symlink) : $(symlinkTarget) : false ;
|
|
Clean cleanPackages : $(symlink) ;
|
|
}
|
|
|
|
rule PackageDriverSymLink
|
|
{
|
|
# PackageDriverSymLink <packageName> : <devRelativeSymlinkComponents> ;
|
|
# <packageName>: Package name.
|
|
# <devRelativeSymlinkComponents>: Path components relative to the
|
|
# /boot/home/config/add-ons/kernel/drivers/dev directory, e.g.
|
|
# "graphics mga.driver" (no quotation, of course).
|
|
#
|
|
local packageName = $(1) ;
|
|
local symlinkComponents = $(2) ;
|
|
|
|
# construct the symlink contents
|
|
local symlinkPath = [ FReverse $(symlinkComponents) ] ;
|
|
symlinkPath = bin $(symlinkPath[1]) ;
|
|
|
|
for i in $(symlinkComponents) {
|
|
symlinkPath = $(DOTDOT) $(symlinkPath) ;
|
|
}
|
|
|
|
PackageSymLink $(packageName)
|
|
: boot home config add-ons kernel drivers dev $(symlinkComponents)
|
|
: [ FDirName $(symlinkPath) ] ;
|
|
}
|
|
|
|
rule PackageZip
|
|
{
|
|
local dir = $(2:G=dir) ;
|
|
Depends $(1) : $(dir) $(3) ;
|
|
Clean cleanPackages : $(1) ;
|
|
PackageZip1 $(1) : $(dir) ;
|
|
}
|
|
|
|
actions together PackageZip1 {
|
|
cd "$(2:P)" ;
|
|
zip -rq "$(1:BS)" "$(2:BS)" ;
|
|
}
|
|
|
|
rule PackageInstallScript
|
|
{
|
|
MakeLocate $(1) : $(2) ;
|
|
Clean cleanPackages : $(1) ;
|
|
PackageInstallScript1 $(1) : $(2:G=dir) ;
|
|
}
|
|
|
|
actions together PackageInstallScript1
|
|
{
|
|
echo '#!/bin/sh
|
|
base=`dirname "$0"`
|
|
cd "$base"
|
|
if [ -n "$TTY" ]
|
|
then
|
|
unzip -d / install.zip
|
|
else
|
|
response=`alert "Would you like to automatically overwrite existing files, or receive a prompt?" "Overwrite" "Prompt"`
|
|
if [ $response == "Overwrite" ]
|
|
then
|
|
unzip -od / install.zip
|
|
alert "Finished installing" "Thanks"
|
|
else
|
|
if [ -e /boot/beos/apps/Terminal ]
|
|
then
|
|
terminal=/boot/beos/apps/Terminal
|
|
else
|
|
terminal=`query Terminal | head -1`
|
|
fi
|
|
$terminal -t "installer" /bin/sh "$0"
|
|
fi
|
|
fi' > "$(1)" ;
|
|
chmod 755 "$(1)" ;
|
|
}
|
|
|
|
rule PackageInstallZip
|
|
{
|
|
Depends $(1) : $(2) ;
|
|
Clean cleanPackages : $(1) ;
|
|
}
|
|
|
|
actions together PackageInstallZip
|
|
{
|
|
cd "$(1:P)" ;
|
|
zip -rqy "$(1:BS)" boot ;
|
|
}
|
|
|
|
rule LinkInstallZip
|
|
{
|
|
Depends $(1) : $(2) ;
|
|
Clean cleanPackages : $(1) ;
|
|
}
|
|
|
|
actions together LinkInstallZip
|
|
{
|
|
ln -sf "`pwd`/$(2)" "$(1)" ;
|
|
}
|
|
|
|
|
|
# TODO: The stuff above should be moved (Copy) or removed (the rest).
|
|
|
|
|
|
#pragma mark - Haiku Packages
|
|
|
|
|
|
rule FHaikuPackageGrist package
|
|
{
|
|
local grist = [ Match "<(.*)>" : $(package:G) ] ;
|
|
return hpkg_$(grist:E="")-$(package:G=) ;
|
|
}
|
|
|
|
|
|
rule HaikuPackage package
|
|
{
|
|
local grist = [ FHaikuPackageGrist $(package) ] ;
|
|
|
|
HAIKU_CONTAINER_GRIST on $(package) = $(grist) ;
|
|
HAIKU_INCLUDE_IN_CONTAINER_VAR on $(package) = HAIKU_INCLUDE_IN_PACKAGES ;
|
|
HAIKU_INSTALL_TARGETS_VAR on $(package)
|
|
= $(grist)_HAIKU_PACKAGE_INSTALL_TARGETS ;
|
|
HAIKU_CONTAINER_SYSTEM_DIR_TOKENS on $(package) = ;
|
|
|
|
HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE = $(package) ;
|
|
|
|
if $(HAIKU_PACKAGES_UPDATE_ONLY) {
|
|
HAIKU_CONTAINER_UPDATE_ONLY on $(package) = 1 ;
|
|
HAIKU_CONTAINER_INHERIT_UPDATE_VARIABLE on $(package)
|
|
= HAIKU_INCLUDE_IN_IMAGE ;
|
|
} else if $(HAIKU_UPDATE_ALL_PACKAGES) {
|
|
HAIKU_INCLUDE_IN_IMAGE on $(package) = 1 ;
|
|
}
|
|
|
|
HAIKU_CONTAINER_ALWAYS_CREATE_DIRECTORIES on $(package) = 1 ;
|
|
}
|
|
|
|
|
|
rule BuildHaikuPackage package : packageInfo
|
|
{
|
|
packageInfo = $(packageInfo:G=package-info) ;
|
|
|
|
local grist = [ FHaikuPackageGrist $(package) ] ;
|
|
|
|
local tempDir = [ FDirName $(HAIKU_PACKAGES_BUILD_DIR) $(grist) ] ;
|
|
local scriptDir = [ FDirName $(tempDir) scripts ] ;
|
|
|
|
# locate the package and package info
|
|
MakeLocate $(package) : $(HAIKU_PACKAGES_DIR) ;
|
|
SEARCH on $(packageInfo) +=
|
|
[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) $(HAIKU_PACKAGING_ARCH) ]
|
|
[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) any ]
|
|
[ FDirName $(HAIKU_PACKAGE_INFOS_DIR) generic ]
|
|
;
|
|
LocalDepends $(package) : $(packageInfo) ;
|
|
|
|
# prepare the script that initializes the shell variables
|
|
local initVariablesScript = <$(grist)>haiku.package-init-vars ;
|
|
MakeLocate $(initVariablesScript) : $(scriptDir) ;
|
|
Always $(initVariablesScript) ;
|
|
|
|
local script = $(initVariablesScript) ;
|
|
AddVariableToScript $(script) : sourceDir : $(HAIKU_TOP) ;
|
|
AddVariableToScript $(script) : outputDir : $(HAIKU_OUTPUT_DIR) ;
|
|
AddVariableToScript $(script) : tmpDir : $(tempDir) ;
|
|
AddVariableToScript $(script) : addBuildCompatibilityLibDir
|
|
: $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR) ;
|
|
AddVariableToScript $(script) : compressionLevel
|
|
: [ on $(package) return $(HAIKU_PACKAGE_COMPRESSION_LEVEL) ] ;
|
|
AddVariableToScript $(script) : updateOnly
|
|
: [ on $(package) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] ;
|
|
AddVariableToScript $(script) : cc : $(TARGET_CC) ;
|
|
AddVariableToScript $(script) : packagingArch : $(HAIKU_PACKAGING_ARCH) ;
|
|
AddTargetVariableToScript $(script) : <build>addattr ;
|
|
AddTargetVariableToScript $(script) : <build>copyattr ;
|
|
AddTargetVariableToScript $(script) : <mimedb>mime_db : mimeDB ;
|
|
AddTargetVariableToScript $(script) : <build>mimeset ;
|
|
AddTargetVariableToScript $(script) : <build>package ;
|
|
AddTargetVariableToScript $(script) : <build>rc ;
|
|
AddTargetVariableToScript $(script) : <build>resattr ;
|
|
AddTargetVariableToScript $(script) : <build>unzip ;
|
|
if $(HOST_RM_ATTRS_TARGET) {
|
|
AddTargetVariableToScript $(script) : $(HOST_RM_ATTRS_TARGET)
|
|
: rmAttrs ;
|
|
} else {
|
|
AddVariableToScript $(script) : rmAttrs : rm ;
|
|
}
|
|
|
|
# create the other scripts
|
|
local makeDirsScript = <$(grist)>haiku.package-make-dirs ;
|
|
local copyFilesScript = <$(grist)>haiku.package-copy-files ;
|
|
local extractFilesScript = <$(grist)>haiku.package-extract-files ;
|
|
|
|
MakeLocate $(makeDirsScript) $(copyFilesScript) $(extractFilesScript)
|
|
: $(scriptDir) ;
|
|
|
|
CreateContainerMakeDirectoriesScript $(package) : $(makeDirsScript) ;
|
|
CreateContainerCopyFilesScript $(package) : $(copyFilesScript) ;
|
|
CreateContainerExtractFilesScript $(package) : $(extractFilesScript) ;
|
|
|
|
local scripts = $(initVariablesScript) $(makeDirsScript)
|
|
$(copyFilesScript) $(extractFilesScript) ;
|
|
|
|
# call the build actions
|
|
local mainScript = build_haiku_package ;
|
|
SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
|
|
|
|
LocalDepends $(package) : $(mainScript) $(scripts) ;
|
|
BuildHaikuPackage1 $(package) : $(mainScript) $(packageInfo) $(scripts) ;
|
|
}
|
|
|
|
|
|
actions BuildHaikuPackage1
|
|
{
|
|
$(2[1]) "$(1)" "$(2[2])" $(2[3-])
|
|
}
|
|
|
|
|
|
rule AddDirectoryToPackage directoryTokens : attributeFiles
|
|
{
|
|
return [ AddDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(directoryTokens) : $(attributeFiles) ] ;
|
|
}
|
|
|
|
|
|
rule AddFilesToPackage directory : targets : destName
|
|
{
|
|
AddFilesToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE) : $(directory)
|
|
: $(targets) : $(destName) ;
|
|
}
|
|
|
|
|
|
rule AddSymlinkToPackage directoryTokens : linkTarget : linkName
|
|
{
|
|
linkTarget = $(linkTarget:J=/) ;
|
|
|
|
AddSymlinkToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(directoryTokens) : $(linkTarget) : $(linkName) ;
|
|
}
|
|
|
|
|
|
rule CopyDirectoryToPackage directoryTokens : sourceDirectory
|
|
: targetDirectoryName : excludePatterns : flags
|
|
{
|
|
CopyDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(directoryTokens) : $(sourceDirectory) : $(targetDirectoryName)
|
|
: $(excludePatterns) : $(flags) ;
|
|
}
|
|
|
|
|
|
rule AddHeaderDirectoryToPackage dirTokens : dirName : flags
|
|
{
|
|
AddHeaderDirectoryToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(dirTokens) : $(dirName) : $(flags) ;
|
|
}
|
|
|
|
|
|
rule AddWifiFirmwareToPackage driver : subDirToExtract : archive
|
|
: extract
|
|
{
|
|
AddWifiFirmwareToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(driver) : $(subDirToExtract) : $(archive) : $(extract) ;
|
|
}
|
|
|
|
|
|
rule ExtractArchiveToPackage dirTokens : archiveFile : flags : extractedSubDir
|
|
{
|
|
ExtractArchiveToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(dirTokens) : $(archiveFile) : $(flags) : $(extractedSubDir) ;
|
|
}
|
|
|
|
|
|
rule AddDriversToPackage relativeDirectoryTokens : targets
|
|
{
|
|
AddDriversToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
|
|
rule AddNewDriversToPackage relativeDirectoryTokens : targets
|
|
{
|
|
AddNewDriversToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
|
|
rule AddBootModuleSymlinksToPackage targets
|
|
{
|
|
AddBootModuleSymlinksToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(targets) ;
|
|
}
|
|
|
|
|
|
rule AddLibrariesToPackage directory : libs
|
|
{
|
|
AddLibrariesToContainer $(HAIKU_CURRENTLY_BUILT_HAIKU_PACKAGE)
|
|
: $(directory) : $(libs) ;
|
|
}
|
|
|
|
|
|
# default value for the package compression level
|
|
HAIKU_PACKAGE_COMPRESSION_LEVEL ?= 9 ;
|