50ffb21291
... before copying the new contents to the image. This caters to the typical use case of updating an existing Haiku, making manual intervention to get the new packages activated unnecessary. The downside is that manually added packages will be removed as well.
1586 lines
45 KiB
Plaintext
1586 lines
45 KiB
Plaintext
rule FSameTargetWithPrependedGrist
|
|
{
|
|
# SameTargetWithPrependedGrist <target> : <grist to prepend> ;
|
|
#
|
|
local target = $(1) ;
|
|
local gristToPrepend = $(2) ;
|
|
local grist = $(target:G) ;
|
|
|
|
if $(grist) {
|
|
grist = $(gristToPrepend)!$(grist) ;
|
|
} else {
|
|
grist = $(gristToPrepend) ;
|
|
}
|
|
|
|
return $(target:G=$(grist)) ;
|
|
}
|
|
|
|
rule InitScript
|
|
{
|
|
# Note: The script must have been LOCATEd before.
|
|
local script = $(1) ;
|
|
local initScript
|
|
= [ FSameTargetWithPrependedGrist $(script) : init-script ] ;
|
|
|
|
if ! [ on $(script) return $(__is_initialized) ] {
|
|
__is_initialized on $(script) = true ;
|
|
|
|
MakeLocate $(initScript) : [ on $(script) return $(LOCATE) ] ;
|
|
Always $(initScript) ;
|
|
Depends $(script) : $(initScript) ;
|
|
|
|
InitScript1 $(initScript) ;
|
|
}
|
|
|
|
return $(initScript) ;
|
|
}
|
|
|
|
actions InitScript1
|
|
{
|
|
$(RM) $(1)
|
|
touch $(1)
|
|
}
|
|
|
|
rule AddVariableToScript script : variable : value
|
|
{
|
|
# AddVariableToScript <script> : <variable> : <value> ;
|
|
|
|
# interpret an empty variable value as empty string
|
|
if ! $(value) {
|
|
value = "" ;
|
|
}
|
|
|
|
InitScript $(script) ;
|
|
|
|
VARIABLE_DEFS on $(script) += "echo $(variable)=\\\"$(value[1])\\\" >> " ;
|
|
|
|
# if the value is an array, add the other array elements
|
|
value = $(value[2-]) ;
|
|
while $(value) {
|
|
VARIABLE_DEFS on $(script)
|
|
+= "echo $(variable)=\\\" \\\$$(variable) $(value[1])\\\" >> " ;
|
|
value = $(value[2-]) ;
|
|
}
|
|
|
|
AddVariableToScript1 $(script) ;
|
|
}
|
|
|
|
actions together AddVariableToScript1
|
|
{
|
|
$(VARIABLE_DEFS)$(1);
|
|
}
|
|
|
|
|
|
rule AddTargetVariableToScript script : targets : variable
|
|
{
|
|
# AddTargetVariableToScript <script> : <targets> [ : <variable> ] ;
|
|
#
|
|
# If <targets> contains multiple targets, their paths must not contain
|
|
# whitespaces or other characters that need to be escaped in the shell.
|
|
#
|
|
variable ?= $(3:E=$(targets[1]:BS)) ;
|
|
|
|
local initScript = [ InitScript $(script) ] ;
|
|
|
|
serialization = [ on $(script) return $(HAIKU_SERIALIZATION) ] ;
|
|
|
|
local variableTarget = [ NewUniqueTarget ] ;
|
|
NotFile $(variableTarget) ;
|
|
Depends $(variableTarget) : $(initScript) $(targets) $(serialization) ;
|
|
Depends $(script) : $(variableTarget) ;
|
|
|
|
HAIKU_SERIALIZATION on $(script) = $(variableTarget) ;
|
|
|
|
HAIKU_VARIABLE_NAME on $(variableTarget) = $(variable) ;
|
|
AddTargetVariableToScript1 $(variableTarget) : $(initScript) $(targets) ;
|
|
}
|
|
|
|
|
|
actions AddTargetVariableToScript1
|
|
{
|
|
script="$(2[1])"
|
|
echo "$(HAIKU_VARIABLE_NAME)=" >> "$script"
|
|
|
|
firstSeen=
|
|
for value in "$(2[2-])" ; do
|
|
if [ -z "$firstSeen" ]; then
|
|
echo "$(HAIKU_VARIABLE_NAME)=\"$value\"" >> "$script"
|
|
firstSeen=1
|
|
else
|
|
echo "$(HAIKU_VARIABLE_NAME)=\"\$$(HAIKU_VARIABLE_NAME) $value\"" \
|
|
>> "$script"
|
|
fi
|
|
done
|
|
}
|
|
|
|
|
|
#pragma mark -
|
|
|
|
rule AddDirectoryToContainer container : directoryTokens : attributeFiles
|
|
{
|
|
# AddDirectoryToContainer <container> : <directoryTokens> : <attributeFiles>
|
|
|
|
local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
|
|
local directory = [ FDirName $(directoryTokens) ] ;
|
|
directory = $(directory:G=$(containerGrist)) ;
|
|
|
|
if ! [ on $(directory) return $(__is_on_image) ] {
|
|
HAIKU_INSTALL_DIRECTORIES on $(container) += $(directory) ;
|
|
__is_on_image on $(directory) = true ;
|
|
DIRECTORY_TOKENS on $(directory) = $(directoryTokens) ;
|
|
NotFile $(directory) ;
|
|
|
|
# mark the parent dir as not to be created
|
|
local parent = [ FReverse $(directoryTokens) ] ;
|
|
parent = [ FReverse $(parent[2-]) ] ;
|
|
if $(parent) {
|
|
parent = [ FDirName $(parent) ] ;
|
|
parent = $(parent:G=$(containerGrist)) ;
|
|
DONT_CREATE on $(parent) = true ;
|
|
}
|
|
}
|
|
|
|
if $(attributeFiles) {
|
|
SEARCH on $(attributeFiles)
|
|
+= [ FDirName $(HAIKU_TOP) data image_directories ] ;
|
|
ATTRIBUTE_FILES on $(dir) += $(attributeFiles) ;
|
|
}
|
|
|
|
return $(directory) ;
|
|
}
|
|
|
|
rule FilterContainerUpdateTargets targets : filterVariable
|
|
{
|
|
# FilterContainerUpdateTargets targets : filterVariable
|
|
|
|
local filteredTargets ;
|
|
local target ;
|
|
for target in $(targets) {
|
|
if [ on $(target) return $($(filterVariable)) ] {
|
|
filteredTargets += $(target) ;
|
|
}
|
|
}
|
|
return $(filteredTargets) ;
|
|
}
|
|
|
|
|
|
rule IncludeAllTargetsInContainer container
|
|
{
|
|
local filterVar
|
|
= [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ;
|
|
if $(filterVar) {
|
|
return $($(filterVar)) ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
|
|
rule PropagateContainerUpdateTargetFlags toTarget : fromTarget
|
|
{
|
|
if [ on $(fromTarget) return $(HAIKU_INCLUDE_IN_IMAGE) ] {
|
|
HAIKU_INCLUDE_IN_IMAGE on $(toTarget) = 1 ;
|
|
}
|
|
|
|
if [ on $(fromTarget) return $(HAIKU_INCLUDE_IN_PACKAGES) ] {
|
|
HAIKU_INCLUDE_IN_PACKAGES on $(toTarget) = 1 ;
|
|
}
|
|
}
|
|
|
|
|
|
rule AddFilesToContainer container : directoryTokens : targets : destName
|
|
{
|
|
# AddFilesToContainer <container> : <directoryTokens> : <targets>
|
|
# [ : dest name ]
|
|
#
|
|
local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
|
|
targets = [ FFilterByBuildFeatures $(targets) ] ;
|
|
|
|
# If the image shall only be updated, we filter out all targets not marked
|
|
# accordingly.
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! [ IncludeAllTargetsInContainer $(container) ] {
|
|
local filterVar
|
|
= [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ;
|
|
if $(filterVar) {
|
|
targets = [ FilterContainerUpdateTargets $(targets)
|
|
: $(filterVar) ] ;
|
|
|
|
# If there are any targets, mark the container as to be included in
|
|
# an update, too, if it has set the update inheritance variable.
|
|
# This makes updating a target that lives in a package on an image
|
|
# work.
|
|
if $(targets) {
|
|
local updateVariable = [ on $(container) return
|
|
$(HAIKU_CONTAINER_INHERIT_UPDATE_VARIABLE) ] ;
|
|
if $(updateVariable) {
|
|
$(updateVariable) on $(container) = 1 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ! $(targets) {
|
|
return ;
|
|
}
|
|
|
|
local directory = [ AddDirectoryToContainer $(container)
|
|
: $(directoryTokens) ] ;
|
|
|
|
# We create a unique dummy target per target to install.
|
|
local installTargetsVar
|
|
= [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ;
|
|
local target ;
|
|
for target in $(targets) {
|
|
local name ;
|
|
if $(destName) {
|
|
name = $(destName) ;
|
|
} else {
|
|
name = $(target:G=:D=) ;
|
|
}
|
|
|
|
local destTarget = $(name:G=$(containerGrist)__$(directory:G=)) ;
|
|
TARGET on $(destTarget) = $(target) ;
|
|
INSTALL_DIR on $(destTarget) = $(directory) ;
|
|
$(installTargetsVar) on $(target) += $(destTarget) ;
|
|
TARGETS_TO_INSTALL on $(directory) += $(destTarget) ;
|
|
|
|
# If the target is associated with catalog files, add those, too.
|
|
local catalogs = [ on $(target) return $(HAIKU_CATALOG_FILES) ] ;
|
|
if $(catalogs) {
|
|
local signature
|
|
= [ on $(target) return $(HAIKU_CATALOG_SIGNATURE) ] ;
|
|
AddFilesToContainer $(container)
|
|
: $(systemDirTokens) data locale catalogs $(signature)
|
|
: $(catalogs) ;
|
|
}
|
|
|
|
# If the target is associated with MIME DB entries, add those, too.
|
|
local mimeDBEntries = [ on $(target) return $(HAIKU_MIME_DB_ENTRIES) ] ;
|
|
if $(mimeDBEntries) {
|
|
# Make sure we add the entries only once by tracking the containers
|
|
# we have already added it to.
|
|
local containers = [ on $(mimeDBEntries)
|
|
return $(HAIKU_MIME_DB_ENTRIES_IN_CONTAINERS) ] ;
|
|
if ! $(container) in $(containers) {
|
|
HAIKU_MIME_DB_ENTRIES_IN_CONTAINERS on $(mimeDBEntries)
|
|
= $(containers) $(container) ;
|
|
CopyDirectoryToContainer $(container) : data
|
|
: $(mimeDBEntries) : mime_db : : alwaysUpdate isTarget ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
rule FFilesInContainerDirectory container : directoryTokens
|
|
{
|
|
local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
|
|
local directory = [ FDirName $(directoryTokens) ] ;
|
|
directory = $(directory:G=$(containerGrist)) ;
|
|
|
|
if [ on $(directory) return $(__is_on_image) ] {
|
|
on $(directory) return $(TARGETS_TO_INSTALL) ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
rule AddSymlinkToContainer container : directoryTokens : linkTarget : linkName
|
|
{
|
|
# AddSymlinkToContainer <container> : <directory> : <link target>
|
|
# [ : <link name> ] ;
|
|
#
|
|
|
|
# If the image shall only be updated, we don't add any symlinks.
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! [ IncludeAllTargetsInContainer $(container) ] {
|
|
return ;
|
|
}
|
|
|
|
local directory = [ AddDirectoryToContainer $(container)
|
|
: $(directoryTokens) ] ;
|
|
|
|
if ! $(linkName) {
|
|
local path = [ FReverse [ FSplitPath $(linkTarget) ] ] ;
|
|
linkName = $(path[1]) ;
|
|
}
|
|
|
|
local link = $(directory)/$(linkName) ;
|
|
SYMLINK_TARGET on $(link) = $(linkTarget) ;
|
|
SYMLINKS_TO_INSTALL on $(directory) += $(link) ;
|
|
}
|
|
|
|
rule FSymlinksInContainerDirectory container : directoryTokens
|
|
{
|
|
local containerGrist = [ on $(container) return $(HAIKU_CONTAINER_GRIST) ] ;
|
|
local directory = [ FDirName $(directoryTokens) ] ;
|
|
directory = $(directory:G=$(containerGrist)) ;
|
|
|
|
if [ on $(directory) return $(__is_on_image) ] {
|
|
on $(directory) return $(SYMLINKS_TO_INSTALL) ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
rule CopyDirectoryToContainer container : directoryTokens : sourceDirectory
|
|
: targetDirectoryName : excludePatterns : flags
|
|
{
|
|
# CopyDirectoryToContainer <container> : <directoryTokens>
|
|
# : <sourceDirectory> : <targetDirectoryName> : <excludePatterns>
|
|
# [ : <flags> ] ;
|
|
#
|
|
# Supported flags: alwaysUpdate, isTarget
|
|
# isTarget: <sourceDirectory> is a target, not a path
|
|
|
|
# If the image shall only be updated, we don't copy any directories
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! [ IncludeAllTargetsInContainer $(container) ]
|
|
&& ! alwaysUpdate in $(flags) {
|
|
return ;
|
|
}
|
|
|
|
if ! $(targetDirectoryName) {
|
|
targetDirectoryName = $(sourceDirectory[1]:BS) ;
|
|
}
|
|
|
|
# If sourceDirectory is a path, not a target, make it a target, so we can
|
|
# treat both the same way.
|
|
if ! isTarget in $(flags) {
|
|
sourceDirectory = $(sourceDirectory:G=copy-directory-to-container) ;
|
|
SEARCH on $(sourceDirectory) = ;
|
|
TARGET on $(sourceDirectory) = ;
|
|
}
|
|
|
|
local directory = [ AddDirectoryToContainer $(container)
|
|
: $(directoryTokens) $(targetDirectoryName) ] ;
|
|
|
|
local targetDir = $(directory)/-/$(sourceDirectory) ;
|
|
Depends $(targetDir) : $(sourceDirectory) ;
|
|
EXCLUDE_PATTERNS on $(targetDir) = $(excludePatterns) ;
|
|
SOURCE_DIRECTORY on $(targetDir) = $(sourceDirectory) ;
|
|
TARGET_DIRECTORY on $(targetDir) = $(directory) ;
|
|
DIRECTORIES_TO_INSTALL on $(directory) += $(targetDir) ;
|
|
}
|
|
|
|
|
|
rule AddHeaderDirectoryToContainer container : dirTokens : dirName
|
|
: flags
|
|
{
|
|
# AddHeaderDirectoryToContainer <container> : <dirTokens> : [ <dirName> ]
|
|
# [ : <flags> ] ;
|
|
#
|
|
# Supported flags: alwaysUpdate
|
|
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
|
|
CopyDirectoryToContainer $(container) : $(systemDirTokens) develop headers
|
|
: [ FDirName $(HAIKU_TOP) headers $(dirTokens) ]
|
|
: $(dirName) : -x .svn : $(flags) ;
|
|
}
|
|
|
|
|
|
rule AddWifiFirmwareToContainer container : driver : package : archive : extract
|
|
{
|
|
# AddWifiFirmwareToContainer <container> : <driver> : <package> : <archive>
|
|
# : <extract>
|
|
|
|
# complete location to wifi firmware archive
|
|
local firmwareArchive = [ FDirName
|
|
$(HAIKU_TOP) data system data firmware $(driver) $(archive) ] ;
|
|
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
|
|
local dirTokens = $(systemDirTokens) data firmware $(driver) ;
|
|
if $(extract) = true || $(extract) = 1 {
|
|
ExtractArchiveToContainer $(container) : $(dirTokens)
|
|
: $(firmwareArchive) : : $(package) ;
|
|
} else {
|
|
AddFilesToContainer $(container) : $(dirTokens) : $(firmwareArchive) ;
|
|
}
|
|
}
|
|
|
|
|
|
rule ExtractArchiveToContainer container : directoryTokens : archiveFile
|
|
: flags : extractedSubDir
|
|
{
|
|
# ExtractArchiveToContainer <container> : <directory> : <archiveFile>
|
|
# : [ <flags> ] : <extractedSubDir> ;
|
|
#
|
|
# Supported flags: alwaysUpdate
|
|
|
|
# If the container shall only be updated, we extract only, if explicitely
|
|
# requested.
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! alwaysUpdate in $(flags) {
|
|
return ;
|
|
}
|
|
|
|
local directory = [ AddDirectoryToContainer $(container)
|
|
: $(directoryTokens) ] ;
|
|
|
|
ARCHIVE_FILES_TO_INSTALL on $(directory) += $(archiveFile) ;
|
|
ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(archiveFile) = $(extractedSubDir) ;
|
|
}
|
|
|
|
rule AddDriversToContainer container : relativeDirectoryTokens : targets
|
|
{
|
|
# AddDriversToContainer <container> : <relative directory> : <targets> ;
|
|
#
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
local directoryTokens = $(systemDirTokens) add-ons kernel drivers dev
|
|
$(relativeDirectoryTokens) ;
|
|
|
|
targets = [ FFilterByBuildFeatures $(targets) ] ;
|
|
|
|
# A driver can be in multiple categories. Avoid adding it to the bin/
|
|
# directory more than once.
|
|
local binTargets ;
|
|
local target ;
|
|
for target in $(targets) {
|
|
local containers
|
|
= [ on $(target) return $(HAIKU_DRIVER_IN_CONTAINERS) ] ;
|
|
if ! $(container) in $(containers) {
|
|
HAIKU_DRIVER_IN_CONTAINERS on $(target)
|
|
= $(containers) $(container) ;
|
|
binTargets += $(target) ;
|
|
}
|
|
}
|
|
|
|
AddFilesToContainer $(container)
|
|
: $(systemDirTokens) add-ons kernel drivers bin
|
|
: $(binTargets) ;
|
|
|
|
# If the image shall only be updated, we don't add any symlinks.
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! [ IncludeAllTargetsInContainer $(container) ] {
|
|
return ;
|
|
}
|
|
|
|
# get the relative symlink path prefix
|
|
local linkPrefix = ;
|
|
for i in $(relativeDirectoryTokens) {
|
|
linkPrefix += .. ;
|
|
}
|
|
linkPrefix += .. bin ;
|
|
|
|
# add the symlinks
|
|
local name ;
|
|
for name in $(targets:BS) {
|
|
AddSymlinkToContainer $(container) : $(directoryTokens)
|
|
: [ FDirName $(linkPrefix) $(name) ] : $(name) ;
|
|
}
|
|
}
|
|
|
|
rule AddNewDriversToContainer container : relativeDirectoryTokens
|
|
: targets
|
|
{
|
|
# AddNewDriversToContainer <container> : <directory> : <targets> ;
|
|
#
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
local directoryTokens = $(systemDirTokens) add-ons kernel drivers
|
|
$(relativeDirectoryTokens) ;
|
|
|
|
targets = [ FFilterByBuildFeatures $(targets) ] ;
|
|
|
|
AddFilesToContainer $(container) : $(directoryTokens)
|
|
: $(targets) ;
|
|
}
|
|
|
|
rule AddBootModuleSymlinksToContainer container : targets
|
|
{
|
|
# AddBootModuleSymlinksToContainer <container> : <targets> ;
|
|
#
|
|
|
|
# If the container shall only be updated, we don't add any symlinks.
|
|
|
|
if [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
&& ! [ IncludeAllTargetsInContainer $(container) ] {
|
|
return ;
|
|
}
|
|
|
|
local systemDirTokens
|
|
= [ on $(container) return $(HAIKU_CONTAINER_SYSTEM_DIR_TOKENS) ] ;
|
|
targets = [ FFilterByBuildFeatures $(targets) ] ;
|
|
|
|
# add the symlinks
|
|
local installTargetsVar
|
|
= [ on $(container) return $(HAIKU_INSTALL_TARGETS_VAR) ] ;
|
|
local target ;
|
|
for target in $(targets) {
|
|
# Symlink to the first place where the target has been installed.
|
|
local destTarget = [ on $(target) return $($(installTargetsVar)[1]) ] ;
|
|
local installDir = [ on $(destTarget) return $(INSTALL_DIR) ] ;
|
|
|
|
if ! $(installDir) {
|
|
Echo "ERROR: AddBootModuleSymlinksToContainer: Can't create a "
|
|
"symlink to target" \"$(target)"\"." ;
|
|
Exit "ERROR: Add*ToContainer has not been invoked for it yet." ;
|
|
}
|
|
|
|
# chop off the system dir prefix from installDir
|
|
installDir = [ on $(installDir) return $(DIRECTORY_TOKENS) ] ;
|
|
local dummy ;
|
|
for dummy in $(systemDirTokens) {
|
|
installDir = $(installDir[2-]) ;
|
|
}
|
|
|
|
local name = $(target:BS) ;
|
|
local linkTarget = [ FDirName ../../.. $(installDir) $(name) ] ;
|
|
|
|
AddSymlinkToContainer $(container)
|
|
: $(systemDirTokens) add-ons kernel boot
|
|
: $(linkTarget) : $(name) ;
|
|
}
|
|
}
|
|
|
|
|
|
rule AddLibrariesToContainer container : directory : libs
|
|
{
|
|
# AddLibrariesToContainer <container> : <directory> : <libs>
|
|
#
|
|
# Installs libraries with the appropriate links into the container.
|
|
#
|
|
|
|
local lib ;
|
|
for lib in $(libs) {
|
|
local abiVersion = [ on $(lib) return $(HAIKU_LIB_ABI_VERSION) ] ;
|
|
if $(abiVersion) {
|
|
local abiVersionedLib = $(lib:G=).$(abiVersion) ;
|
|
AddFilesToContainer $(container) : $(directory) : $(lib)
|
|
: $(abiVersionedLib) ;
|
|
AddSymlinkToContainer $(container) : $(directory)
|
|
: $(abiVersionedLib) : $(lib:G=) ;
|
|
} else {
|
|
AddFilesToContainer $(container) : $(directory) : $(lib) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
rule CreateContainerMakeDirectoriesScript container : script
|
|
{
|
|
MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
|
|
Always $(script) ;
|
|
|
|
local initScript = [ InitScript $(script) ] ;
|
|
|
|
local scriptBody
|
|
= [ FSameTargetWithPrependedGrist $(script) : script-body ] ;
|
|
LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ;
|
|
Depends $(scriptBody) : $(initScript) ;
|
|
Depends $(script) : $(scriptBody) ;
|
|
|
|
# collect the directories to create
|
|
local dirsToCreate ;
|
|
local directories
|
|
= [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] ;
|
|
local dir ;
|
|
for dir in $(directories) {
|
|
if ! [ on $(dir) return $(DONT_CREATE) ] {
|
|
dirsToCreate += $(dir) ;
|
|
}
|
|
}
|
|
|
|
# If the image shall only be updated, we don't create directories.
|
|
if $(dirsToCreate)
|
|
&& ( ! [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ]
|
|
|| [ IncludeAllTargetsInContainer $(container) ]
|
|
|| [ on $(container) return
|
|
$(HAIKU_CONTAINER_ALWAYS_CREATE_DIRECTORIES) ] ) {
|
|
Depends $(scriptBody) : $(dirsToCreate) ;
|
|
CreateContainerMakeDirectoriesScript1 $(scriptBody) : $(dirsToCreate) ;
|
|
|
|
local serializationDependency = $(scriptBody) ;
|
|
# Used to create a dependency chain between the dummy targets.
|
|
# This forces jam to build them one after the other, thus preventing
|
|
# concurrent writes to the script file when building with multiple
|
|
# jobs.
|
|
|
|
# For directories with attributes, we convert those the specified
|
|
# resource files to files with attributes and add commands to the script
|
|
# adding the attributes to the directories.
|
|
for dir in $(directories) {
|
|
local resourceFiles = [ on $(dir) return $(ATTRIBUTE_FILES) ] ;
|
|
if $(resourceFiles) {
|
|
local dirTokens = [ on $(dir) return $(DIRECTORY_TOKENS) ] ;
|
|
|
|
# translate resources file to file with attributes
|
|
local attributeFile = $(script)-attributes-$(dirTokens:J=-) ;
|
|
ResAttr $(attributeFile) : $(resourceFiles) ;
|
|
|
|
# use a unique dummy target for this file, on which we
|
|
# can define the TARGET_DIR variable
|
|
local dummyTarget = $(script)-attributes-dummy-$(dir:G=) ;
|
|
NotFile $(dummyTarget) ;
|
|
TARGET_DIR on $(dummyTarget) = $(dir:G=) ;
|
|
|
|
Depends $(dummyTarget) : $(initScript) $(attributeFile)
|
|
$(serializationDependency) ;
|
|
Depends $(script) : $(dummyTarget) ;
|
|
serializationDependency = $(dummyTarget) ;
|
|
|
|
AppendToContainerMakeDirectoriesScriptAttributes $(dummyTarget)
|
|
: $(initScript) $(attributeFile) ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
actions piecemeal CreateContainerMakeDirectoriesScript1
|
|
{
|
|
echo \$mkdir -p "\"\${tPrefix}$(2:G=)\"" >> $(1)
|
|
}
|
|
|
|
actions AppendToContainerMakeDirectoriesScriptAttributes
|
|
{
|
|
echo \$copyAttrs "\"\${sPrefix}$(2[2])\"" \
|
|
"\"\${tPrefix}$(TARGET_DIR)\"" >> $(2[1])
|
|
}
|
|
|
|
rule CreateContainerCopyFilesScript container : script
|
|
{
|
|
MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
|
|
Always $(script) ;
|
|
|
|
local initScript = [ InitScript $(script) ] ;
|
|
|
|
local scriptBody
|
|
= [ FSameTargetWithPrependedGrist $(script) : script-body ] ;
|
|
LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ;
|
|
Depends $(scriptBody) : $(initScript) ;
|
|
Depends $(script) : $(scriptBody) ;
|
|
|
|
local serializationDependency = $(scriptBody) ;
|
|
# Used to create a dependency chain between the dummy targets.
|
|
# This forces jam to build them one after the other, thus preventing
|
|
# concurrent writes to the script file when building with multiple
|
|
# jobs.
|
|
|
|
local dir ;
|
|
for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] {
|
|
# filter the targets that shall be renamed; they have to be copied
|
|
# individually
|
|
local destTargets = [ on $(dir) return $(TARGETS_TO_INSTALL) ] ;
|
|
local remainingTargets ;
|
|
local destTarget ;
|
|
for destTarget in $(destTargets) {
|
|
local target = [ on $(destTarget) return $(TARGET) ] ;
|
|
local name = $(destTarget:BS) ;
|
|
if $(name) != $(target:BS) {
|
|
# use a unique dummy target for this file, on which we
|
|
# can define the TARGET_DIR variable
|
|
local dummyTarget = $(script)-dummy-$(dir:G=)-$(target) ;
|
|
NotFile $(dummyTarget) ;
|
|
TARGET_DIR on $(dummyTarget) = $(dir:G=) ;
|
|
INSTALL_TARGET_NAME on $(dummyTarget) = $(name) ;
|
|
|
|
Depends $(dummyTarget) : $(initScript) $(target)
|
|
$(serializationDependency) ;
|
|
Depends $(script) : $(dummyTarget) ;
|
|
serializationDependency = $(dummyTarget) ;
|
|
|
|
AppendToContainerCopyFilesScriptSingleFile $(dummyTarget)
|
|
: $(initScript) $(target) ;
|
|
} else {
|
|
remainingTargets += $(target) ;
|
|
}
|
|
}
|
|
targets = $(remainingTargets) ;
|
|
|
|
if $(targets) {
|
|
# use a unique dummy target for this directory, on which we
|
|
# can define the TARGET_DIR variable
|
|
local dummyTarget = $(script)-dummy-$(dir:G=) ;
|
|
NotFile $(dummyTarget) ;
|
|
TARGET_DIR on $(dummyTarget) = $(dir:G=) ;
|
|
|
|
Depends $(dummyTarget) : $(initScript) $(targets)
|
|
$(serializationDependency) ;
|
|
Depends $(script) : $(dummyTarget) ;
|
|
serializationDependency = $(dummyTarget) ;
|
|
|
|
OUTPUT_SCRIPT on $(dummyTarget) = $(initScript) ;
|
|
AppendToContainerCopyFilesScript $(dummyTarget) : $(targets) ;
|
|
}
|
|
|
|
local symlinks = [ on $(dir) return $(SYMLINKS_TO_INSTALL) ] ;
|
|
local symlink ;
|
|
for symlink in $(symlinks) {
|
|
NotFile $(symlink) ;
|
|
|
|
Depends $(script) : $(symlink) ;
|
|
Depends $(symlink) : $(initScript) $(serializationDependency) ;
|
|
serializationDependency = $(symlink) ;
|
|
|
|
AddSymlinkToContainerCopyFilesScript $(symlink) : $(initScript) ;
|
|
}
|
|
|
|
local targetDirs = [ on $(dir) return $(DIRECTORIES_TO_INSTALL) ] ;
|
|
local targetDir ;
|
|
for targetDir in $(targetDirs) {
|
|
NotFile $(targetDir) ;
|
|
|
|
Depends $(script) : $(targetDir) ;
|
|
Depends $(targetDir) : $(initScript) $(serializationDependency) ;
|
|
serializationDependency = $(targetDir) ;
|
|
|
|
AddDirectoryToContainerCopyFilesScript $(targetDir)
|
|
: $(initScript) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
actions piecemeal AppendToContainerCopyFilesScript bind OUTPUT_SCRIPT
|
|
{
|
|
echo \$cp "\"\${sPrefix}$(2)\"" "\"\${tPrefix}$(TARGET_DIR)\"" \
|
|
>> $(OUTPUT_SCRIPT)
|
|
}
|
|
|
|
|
|
actions AppendToContainerCopyFilesScriptSingleFile
|
|
{
|
|
echo \$cp "\"\${sPrefix}$(2[2])\"" \
|
|
"\"\${tPrefix}$(TARGET_DIR)/$(INSTALL_TARGET_NAME)\"" >> $(2[1])
|
|
}
|
|
|
|
|
|
actions AddSymlinkToContainerCopyFilesScript
|
|
{
|
|
echo \$ln -sfn "\"$(SYMLINK_TARGET)\"" "\"\${tPrefix}$(1:G=)\"" >> $(2[1])
|
|
}
|
|
|
|
|
|
actions AddDirectoryToContainerCopyFilesScript bind SOURCE_DIRECTORY
|
|
{
|
|
echo \$cp -r $(EXCLUDE_PATTERNS) "\"\${sPrefix}$(SOURCE_DIRECTORY)/.\"" \
|
|
"\"\${tPrefix}$(TARGET_DIRECTORY:G=)\"" >> $(2[1])
|
|
}
|
|
|
|
|
|
rule CreateContainerExtractFilesScript container : script
|
|
{
|
|
MakeLocate $(script) : $(HAIKU_OUTPUT_DIR) ;
|
|
Always $(script) ;
|
|
|
|
local initScript = [ InitScript $(script) ] ;
|
|
|
|
local scriptBody
|
|
= [ FSameTargetWithPrependedGrist $(script) : script-body ] ;
|
|
LOCATE on $(scriptBody) = [ on $(script) return $(LOCATE) ] ;
|
|
Depends $(scriptBody) : $(initScript) ;
|
|
Depends $(script) : $(scriptBody) ;
|
|
|
|
local serializationDependency = $(scriptBody) ;
|
|
# Used to create a dependency chain between the dummy targets.
|
|
# This forces jam to build them one after the other, thus preventing
|
|
# concurrent writes to the script file when building with multiple
|
|
# jobs.
|
|
|
|
local dir ;
|
|
for dir in [ on $(container) return $(HAIKU_INSTALL_DIRECTORIES) ] {
|
|
local archiveFiles = [ on $(dir) return $(ARCHIVE_FILES_TO_INSTALL) ] ;
|
|
local archiveFile ;
|
|
for archiveFile in $(archiveFiles) {
|
|
# use a unique dummy target for this file, on which we
|
|
# can define the TARGET_DIR variable
|
|
local dummyTarget = $(script)-dummy-$(dir:G=)-$(archiveFile) ;
|
|
NotFile $(dummyTarget) ;
|
|
TARGET_DIR on $(dummyTarget) = $(dir:G=) ;
|
|
|
|
local extractedSubDir = [ on $(archiveFile)
|
|
return $(ARCHIVE_SUBDIR_TO_INSTALL_FROM) ] ;
|
|
ARCHIVE_SUBDIR_TO_INSTALL_FROM on $(dummyTarget) =
|
|
$(extractedSubDir:E=.) ;
|
|
|
|
Depends $(dummyTarget) : $(initScript) $(archiveFile)
|
|
$(serializationDependency) ;
|
|
Depends $(script) : $(dummyTarget) ;
|
|
serializationDependency = $(dummyTarget) ;
|
|
|
|
AddExtractFileToContainerExtractFilesScript $(dummyTarget)
|
|
: $(initScript) $(archiveFile) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
actions AddExtractFileToContainerExtractFilesScript
|
|
{
|
|
echo extractFile "\"$(2[2])\"" "\"$(TARGET_DIR)\"" \
|
|
"\"$(ARCHIVE_SUBDIR_TO_INSTALL_FROM)\"" >> $(2[1])
|
|
}
|
|
|
|
|
|
rule AddPackagesAndRepositoryVariablesToContainerScript script : container
|
|
{
|
|
AddVariableToScript $(script) : downloadDir : $(HAIKU_DOWNLOAD_DIR) ;
|
|
AddTargetVariableToScript $(script) : <build>package ;
|
|
AddTargetVariableToScript $(script) : <build>get_package_dependencies
|
|
: getPackageDependencies ;
|
|
|
|
# Add a variable to indicate whether packages dependencies shall be
|
|
# resolved. We always want to do that in non-update mode, but also in update
|
|
# mode when all packages are updated.
|
|
local updateOnly
|
|
= [ on $(container) return $(HAIKU_CONTAINER_UPDATE_ONLY) ] ;
|
|
local resolvePackageDependencies ;
|
|
if ( ! $(updateOnly) || $(HAIKU_UPDATE_ALL_PACKAGES) )
|
|
&& ! $(HAIKU_BOOTSTRAP_BUILD) {
|
|
resolvePackageDependencies = 1 ;
|
|
}
|
|
AddVariableToScript $(script) : resolvePackageDependencies
|
|
: $(resolvePackageDependencies) ;
|
|
|
|
AddVariableToScript $(script) : updateAllPackages
|
|
: $(HAIKU_UPDATE_ALL_PACKAGES) ;
|
|
|
|
# Add variable "systemPackages" with the packages copied/updated.
|
|
local allPackages = [ on $(container) return $(HAIKU_PACKAGES_IN_IMAGE) ] ;
|
|
if $(updateOnly) && ! [ IncludeAllTargetsInContainer $(container) ] {
|
|
allPackages = [ FilterContainerUpdateTargets $(allPackages)
|
|
: [ on $(container) return $(HAIKU_INCLUDE_IN_CONTAINER_VAR) ] ] ;
|
|
}
|
|
|
|
AddTargetVariableToScript $(script) : $(allPackages) : systemPackages ;
|
|
|
|
# Generate the repository package lists and add variables for the
|
|
# repositories.
|
|
local repository ;
|
|
local repositoryFiles ;
|
|
for repository in $(HAIKU_REPOSITORIES) {
|
|
repositoryFiles
|
|
+= [ on $(repository) return $(HAIKU_REPOSITORY_CACHE_FILE) ] ;
|
|
}
|
|
|
|
AddTargetVariableToScript $(script) : $(repositoryFiles) : repositories ;
|
|
}
|
|
|
|
|
|
#pragma mark - Haiku Image rules
|
|
|
|
rule SetUpdateHaikuImageOnly flag
|
|
{
|
|
HAIKU_CONTAINER_UPDATE_ONLY on $(HAIKU_IMAGE_CONTAINER_NAME) = $(flag) ;
|
|
}
|
|
|
|
rule IsUpdateHaikuImageOnly
|
|
{
|
|
on $(HAIKU_IMAGE_CONTAINER_NAME) return $(HAIKU_CONTAINER_UPDATE_ONLY) ;
|
|
}
|
|
|
|
rule AddDirectoryToHaikuImage directoryTokens : attributeFiles
|
|
{
|
|
# AddDirectoryToHaikuImage <directoryTokens> : <attributeFiles>
|
|
|
|
return [ AddDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(directoryTokens) : $(attributeFiles) ] ;
|
|
}
|
|
|
|
rule AddFilesToHaikuImage directory : targets : destName
|
|
{
|
|
# AddFilesToHaikuImage <directory> : <targets> [ : dest name ]
|
|
|
|
AddFilesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory)
|
|
: $(targets) : $(destName) ;
|
|
}
|
|
|
|
rule FFilesInHaikuImageDirectory directoryTokens
|
|
{
|
|
return [ FFilesInContainerDirectory $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(directoryTokens) ] ;
|
|
}
|
|
|
|
rule AddSymlinkToHaikuImage directoryTokens : linkTarget : linkName
|
|
{
|
|
# AddSymlinkToHaikuImage <directory> : <link target> [ : <link name> ] ;
|
|
|
|
linkTarget = $(linkTarget:J=/) ;
|
|
|
|
AddSymlinkToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens)
|
|
: $(linkTarget) : $(linkName) ;
|
|
}
|
|
|
|
rule FSymlinksInHaikuImageDirectory directoryTokens
|
|
{
|
|
return [ FSymlinksInContainerDirectory $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(directoryTokens) ] ;
|
|
}
|
|
|
|
rule CopyDirectoryToHaikuImage directoryTokens : sourceDirectory
|
|
: targetDirectoryName : excludePatterns : flags
|
|
{
|
|
CopyDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directoryTokens)
|
|
: $(sourceDirectory) : $(targetDirectoryName) : $(excludePatterns)
|
|
: $(flags) ;
|
|
}
|
|
|
|
rule AddSourceDirectoryToHaikuImage dirTokens : flags
|
|
{
|
|
# AddSourceDirectoryToHaikuImage <dirTokens> : <flags> ;
|
|
|
|
CopyDirectoryToHaikuImage home HaikuSources
|
|
: [ FDirName $(HAIKU_TOP) $(dirTokens) ]
|
|
: : : $(flags) ;
|
|
}
|
|
|
|
rule AddHeaderDirectoryToHaikuImage dirTokens : dirName : flags
|
|
{
|
|
# AddHeaderDirectoryToHaikuImage <dirTokens> : [ <dirName> ]
|
|
# : <flags> ;
|
|
|
|
AddHeaderDirectoryToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
|
|
: $(dirName) : $(flags) ;
|
|
}
|
|
|
|
rule AddWifiFirmwareToHaikuImage driver : package : archive : extract
|
|
{
|
|
# AddWifiFirmwareToHaikuImage <driver> : <package> : <archive> : <extract>
|
|
|
|
AddWifiFirmwareToHaikuImage $(HAIKU_IMAGE_CONTAINER_NAME) : $(driver)
|
|
: $(package) : $(archive) : $(extract) ;
|
|
}
|
|
|
|
rule ExtractArchiveToHaikuImage dirTokens : archiveFile : flags
|
|
: extractedSubDir
|
|
{
|
|
# ExtractArchiveToHaikuImage <dirTokens> : <archiveFile> : <flags>
|
|
# : <extractedSubDir> ;
|
|
|
|
ExtractArchiveToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(dirTokens)
|
|
: $(archiveFile) : $(flags) : $(extractedSubDir) ;
|
|
}
|
|
|
|
rule AddDriversToHaikuImage relativeDirectoryTokens : targets
|
|
{
|
|
# AddDriversToHaikuImage <relative directory> : <targets> ;
|
|
|
|
AddDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddNewDriversToHaikuImage relativeDirectoryTokens : targets
|
|
{
|
|
# AddNewDriversToHaikuImage <relative directory> : <targets> ;
|
|
|
|
AddNewDriversToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddBootModuleSymlinksToHaikuImage targets
|
|
{
|
|
# AddBootModuleSymlinksToHaikuImage <targets> ;
|
|
|
|
AddBootModuleSymlinksToContainer $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(targets) ;
|
|
}
|
|
|
|
rule AddPackageFilesToHaikuImage location : packages
|
|
{
|
|
packages = [ FFilterByBuildFeatures $(packages) ] ;
|
|
HAIKU_PACKAGES_IN_IMAGE on $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
= [ on $(HAIKU_IMAGE_CONTAINER_NAME) return $(HAIKU_PACKAGES_IN_IMAGE) ]
|
|
$(packages) ;
|
|
HAIKU_PACKAGE_INSTALLATION_LOCATION on $(packages) = $(location) ;
|
|
AddFilesToHaikuImage $(location) packages : $(packages) ;
|
|
}
|
|
|
|
rule AddOptionalHaikuImagePackages packages
|
|
{
|
|
local package ;
|
|
for package in $(packages) {
|
|
if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] {
|
|
HAIKU_OPTIONAL_PACKAGE_ADDED on $(package) = 1 ;
|
|
HAIKU_ADDED_OPTIONAL_PACKAGES += $(package) ;
|
|
}
|
|
local dependencies = [ on $(package)
|
|
return $(HAIKU_OPTIONAL_PACKAGE_DEPENDENCIES) ] ;
|
|
AddOptionalHaikuImagePackages $(dependencies) ;
|
|
}
|
|
}
|
|
|
|
rule SuppressOptionalHaikuImagePackages packages
|
|
{
|
|
local package ;
|
|
for package in $(packages) {
|
|
if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_SUPPRESSED) ] {
|
|
HAIKU_OPTIONAL_PACKAGE_SUPPRESSED on $(package) = 1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
rule IsOptionalHaikuImagePackageAdded package
|
|
{
|
|
if ! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_EXISTS) ] {
|
|
HAIKU_OPTIONAL_PACKAGE_EXISTS on $(package) = 1 ;
|
|
HAIKU_EXISTING_OPTIONAL_PACKAGES += $(package) ;
|
|
}
|
|
|
|
if [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] &&
|
|
! [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_SUPPRESSED) ] {
|
|
return 1 ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
rule OptionalPackageDependencies package : dependencies
|
|
{
|
|
HAIKU_OPTIONAL_PACKAGE_DEPENDENCIES on $(package) = $(dependencies) ;
|
|
if [ on $(package) return $(HAIKU_OPTIONAL_PACKAGE_ADDED) ] {
|
|
AddOptionalHaikuImagePackages $(dependencies) ;
|
|
}
|
|
}
|
|
|
|
|
|
rule AddHaikuImagePackages packages
|
|
{
|
|
# AddHaikuImagePackages <packages> ;
|
|
# Adds the given packages <packages> to the image.
|
|
|
|
packages = [ FFilterByBuildFeatures $(packages) ] ;
|
|
|
|
local package ;
|
|
for package in $(packages) {
|
|
local resolvedPackage = [ IsPackageAvailable $(package) ] ;
|
|
if ! $(resolvedPackage) {
|
|
Echo "AddHaikuImagePackages: package" $(package)
|
|
"not available!" ;
|
|
continue ;
|
|
}
|
|
|
|
if ! [ on $(resolvedPackage) return $(HAIKU_PACKAGE_ADDED) ] {
|
|
HAIKU_PACKAGE_ADDED on $(resolvedPackage) = 1 ;
|
|
HAIKU_ADDED_PACKAGES += $(resolvedPackage) ;
|
|
|
|
# download the package file and add it to the image
|
|
local file = [ FetchPackage $(package) ] ;
|
|
|
|
if $(HAIKU_UPDATE_ALL_PACKAGES) {
|
|
HAIKU_INCLUDE_IN_IMAGE on $(file) = 1 ;
|
|
}
|
|
|
|
AddPackageFilesToHaikuImage system : $(file) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
rule IsHaikuImagePackageAdded package
|
|
{
|
|
local resolvedPackage = [ IsPackageAvailable $(package) ] ;
|
|
if $(resolvedPackage)
|
|
&& [ on $(resolvedPackage) return $(HAIKU_PACKAGE_ADDED) ] {
|
|
return 1 ;
|
|
}
|
|
|
|
return ;
|
|
}
|
|
|
|
|
|
rule BuildHaikuImagePackageList target
|
|
{
|
|
if ! $(target) {
|
|
return ;
|
|
}
|
|
|
|
# get the file names of all added packages
|
|
local packageFiles ;
|
|
local package ;
|
|
for package in $(HAIKU_ADDED_PACKAGES) {
|
|
packageFiles += [ FetchPackage $(package) : nameResolved ] ;
|
|
}
|
|
|
|
# extract the versioned package names (without revision)
|
|
packageFiles = [ Match "(.*)-[^-]*-[^-]*" : $(packageFiles:B) ] ;
|
|
|
|
HAIKU_IMAGE_PACKAGES on $(target) = $(packageFiles) ;
|
|
}
|
|
|
|
|
|
actions BuildHaikuImagePackageList
|
|
{
|
|
echo $(HAIKU_IMAGE_PACKAGES) | xargs -n 1 echo | LC_ALL=C sort -u > $(1)
|
|
}
|
|
|
|
|
|
rule InstallSourceArchive file : url
|
|
{
|
|
if $(HAIKU_INCLUDE_SOURCES) = 1 {
|
|
# download archive file
|
|
local archiveFile = [ DownloadFile $(file) : $(url) ] ;
|
|
|
|
# copy directly into image
|
|
AddFilesToHaikuImage _sources_ : $(archiveFile) ;
|
|
}
|
|
}
|
|
|
|
rule InstallOptionalHaikuImagePackage url : dirTokens : flags
|
|
{
|
|
# TODO: Remove the non-hpkg cases!
|
|
# Currently the semantics differs depending on whether the cdPackage flag
|
|
# has been specified and the type of the package file:
|
|
# * For a hpkg <dirTokens> is ignored. The package will be copied into the
|
|
# system/packages directory.
|
|
# * For a regular archive and cdPackage, <dirTokens> is ignored and
|
|
# the package will be copied to the _package_ directory of the CD image.
|
|
# * For a regular archive and without cdPackage, <dirTokens> specifies the
|
|
# directory relative to the image's root directory where the content of
|
|
# the archive will be extracted to.
|
|
#
|
|
# Supported flags: cdPackage
|
|
|
|
local package = $(url:BS) ;
|
|
|
|
# download archive file
|
|
local archiveFile = [ DownloadFile $(package) : $(url) ] ;
|
|
|
|
if $(package:S) = .hpkg {
|
|
if $(HAIKU_UPDATE_ALL_PACKAGES) {
|
|
HAIKU_INCLUDE_IN_IMAGE on $(archiveFile) = 1 ;
|
|
}
|
|
AddPackageFilesToHaikuImage system : $(archiveFile) ;
|
|
} else if cdPackage in $(flags) && $(HAIKU_CD_NAME) {
|
|
# TODO: If HAIKU_CD_NAME is set, that doesn't mean we're building a CD
|
|
# image!
|
|
# copy onto image
|
|
AddFilesToHaikuImage _packages_ : $(archiveFile) ;
|
|
} else {
|
|
# extract onto image
|
|
ExtractArchiveToHaikuImage $(dirTokens) : $(archiveFile) : $(flags) ;
|
|
}
|
|
}
|
|
|
|
rule AddEntryToHaikuImageUserGroupFile file : entry
|
|
{
|
|
local allEntries = [ on $(file) return $(HAIKU_IMAGE_USER_GROUP_ENTRIES) ] ;
|
|
|
|
if $(allEntries) {
|
|
allEntries = $(allEntries)|$(entry) ;
|
|
} else {
|
|
allEntries = $(entry) ;
|
|
|
|
Always $(file) ;
|
|
MakeLocate $(file) : $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) ;
|
|
BuildHaikuImageUserGroupFile $(file) ;
|
|
AddFilesToHaikuImage system settings etc : $(file) ;
|
|
}
|
|
|
|
HAIKU_IMAGE_USER_GROUP_ENTRIES on $(file) = $(allEntries) ;
|
|
}
|
|
|
|
actions BuildHaikuImageUserGroupFile
|
|
{
|
|
echo "$(HAIKU_IMAGE_USER_GROUP_ENTRIES)" | tr '|' '\n' > $(1)
|
|
}
|
|
|
|
rule AddUserToHaikuImage user : uid : gid : home : shell : realName
|
|
{
|
|
if ! $(user) || ! $(uid) || ! $(gid) || ! $(home) {
|
|
Exit "Invalid haiku user specification passed to AddUserToHaikuImage." ;
|
|
}
|
|
|
|
local entry
|
|
= $(user):x:$(uid):$(gid):$(realName:E=$(user)):$(home):$(shell:E="") ;
|
|
|
|
AddEntryToHaikuImageUserGroupFile <haiku-image>passwd : $(entry) ;
|
|
}
|
|
|
|
rule AddGroupToHaikuImage group : gid : members
|
|
{
|
|
if ! $(group) || ! $(gid) {
|
|
Exit "Invalid haiku group specification passed to"
|
|
"AddGroupToHaikuImage." ;
|
|
}
|
|
|
|
local entry = $(group):x:$(gid):$(members:J=,:E) ;
|
|
|
|
AddEntryToHaikuImageUserGroupFile <haiku-image>group : $(entry) ;
|
|
}
|
|
|
|
|
|
rule AddLibrariesToHaikuImage directory : libs
|
|
{
|
|
# AddLibraryToHaikuImage <directory> : <libs>
|
|
#
|
|
# Installs libraries with the appropriate links onto the image.
|
|
#
|
|
|
|
AddLibrariesToContainer $(HAIKU_IMAGE_CONTAINER_NAME) : $(directory)
|
|
: $(libs) ;
|
|
}
|
|
|
|
|
|
rule CreateHaikuImageMakeDirectoriesScript script
|
|
{
|
|
CreateContainerMakeDirectoriesScript $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(script) ;
|
|
}
|
|
|
|
rule CreateHaikuImageCopyFilesScript script
|
|
{
|
|
CreateContainerCopyFilesScript $(HAIKU_IMAGE_CONTAINER_NAME) : $(script) ;
|
|
}
|
|
|
|
rule CreateHaikuImageExtractFilesScript script
|
|
{
|
|
CreateContainerExtractFilesScript $(HAIKU_IMAGE_CONTAINER_NAME)
|
|
: $(script) ;
|
|
}
|
|
|
|
rule BuildHaikuImage haikuImage : scripts : isImage : isVMwareImage
|
|
{
|
|
# BuildHaikuImage <haiku image> : <scripts> : <is image> : <isVMwareImage> ;
|
|
|
|
if $(isImage) = 1 || $(isImage) = true {
|
|
IS_IMAGE on $(haikuImage) = 1 ;
|
|
} else {
|
|
IS_IMAGE on $(haikuImage) = "" ;
|
|
}
|
|
|
|
if $(isVMwareImage) = 1 || $(isVMwareImage) = true {
|
|
IS_VMWARE_IMAGE on $(haikuImage) = 1 ;
|
|
} else {
|
|
IS_VMWARE_IMAGE on $(haikuImage) = "" ;
|
|
}
|
|
|
|
local mainScript = build_haiku_image ;
|
|
SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
|
|
|
|
Depends $(haikuImage) : $(mainScript) $(scripts) ;
|
|
BuildHaikuImage1 $(haikuImage) : $(mainScript) $(scripts) ;
|
|
}
|
|
|
|
actions BuildHaikuImage1
|
|
{
|
|
export imagePath="$(1)"
|
|
export isImage="$(IS_IMAGE)"
|
|
export isVMwareImage="$(IS_VMWARE_IMAGE)"
|
|
$(2[1]) $(2[2-])
|
|
}
|
|
|
|
rule BuildVMWareImage vmwareImage : plainImage : imageSize
|
|
{
|
|
# BuildVMWareImage <vmware image> : <plain image> : <image size in MB>
|
|
|
|
IMAGE_SIZE on $(vmwareImage) = $(imageSize) ;
|
|
|
|
Depends $(vmwareImage) : <build>vmdkheader $(plainImage) ;
|
|
BuildVMWareImage1 $(vmwareImage) : <build>vmdkheader $(plainImage) ;
|
|
}
|
|
|
|
actions BuildVMWareImage1
|
|
{
|
|
$(RM) $(1)
|
|
$(2[1]) -h 64k -i$(IMAGE_SIZE)M $(1) &&
|
|
cat $(2[2]) >> $(1)
|
|
}
|
|
|
|
|
|
#pragma mark - Network Boot Archive rules
|
|
|
|
rule AddDirectoryToNetBootArchive directoryTokens
|
|
{
|
|
# AddDirectoryToNetBootArchive <directoryTokens>
|
|
|
|
return [ AddDirectoryToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(directoryTokens) ] ;
|
|
}
|
|
|
|
rule AddFilesToNetBootArchive directory : targets : destName
|
|
{
|
|
# AddFilesToNetBootArchive <directory> : <targets> [ : dest name ]
|
|
|
|
AddFilesToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(directory)
|
|
: $(targets) : $(destName) ;
|
|
}
|
|
|
|
rule AddSymlinkToNetBootArchive directoryTokens : linkTarget : linkName
|
|
{
|
|
# AddSymlinkToNetBootArchive <directory> : <link target> [ : <link name> ] ;
|
|
|
|
AddSymlinkToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(directoryTokens) : $(linkTarget) : $(linkName) ;
|
|
}
|
|
|
|
rule AddDriversToNetBootArchive relativeDirectoryTokens : targets
|
|
{
|
|
# AddDriversToNetBootArchive <relative directory> : <targets> ;
|
|
|
|
AddDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddNewDriversToNetBootArchive relativeDirectoryTokens : targets
|
|
{
|
|
# AddNewDriversToNetBootArchive <relative directory> : <targets> ;
|
|
|
|
AddNewDriversToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddDriverRegistrationToNetBootArchive relativeDirectoryTokens : target
|
|
: links
|
|
{
|
|
# AddDriverRegistrationToNetBootArchive <directory> : <link target>
|
|
# : <link names> ] ;
|
|
|
|
AddDriverRegistrationToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(target) : $(links) ;
|
|
}
|
|
|
|
rule AddBootModuleSymlinksToNetBootArchive targets
|
|
{
|
|
# AddBootModuleSymlinksToNetBootArchive <targets> ;
|
|
|
|
AddBootModuleSymlinksToContainer $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(targets) ;
|
|
}
|
|
|
|
rule CreateNetBootArchiveMakeDirectoriesScript script
|
|
{
|
|
CreateContainerMakeDirectoriesScript
|
|
$(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME) : $(script) ;
|
|
}
|
|
|
|
rule CreateNetBootArchiveCopyFilesScript script
|
|
{
|
|
CreateContainerCopyFilesScript $(HAIKU_NET_BOOT_ARCHIVE_CONTAINER_NAME)
|
|
: $(script) ;
|
|
}
|
|
|
|
rule BuildNetBootArchive archive : scripts
|
|
{
|
|
# BuildNetBootArchive <archive> : <scripts> ;
|
|
|
|
local mainScript = build_archive ;
|
|
SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
|
|
|
|
Depends $(archive) : $(mainScript) $(scripts) ;
|
|
BuildNetBootArchive1 $(archive) : $(mainScript) $(scripts) ;
|
|
}
|
|
|
|
actions BuildNetBootArchive1
|
|
{
|
|
$(2[1]) $(1) $(2[2-])
|
|
}
|
|
|
|
|
|
#pragma mark - Floppy Boot Archive rules
|
|
|
|
|
|
rule AddDirectoryToFloppyBootArchive directoryTokens
|
|
{
|
|
# AddDirectoryToFloppyBootArchive <directoryTokens>
|
|
|
|
return [ AddDirectoryToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(directoryTokens) ] ;
|
|
}
|
|
|
|
rule AddFilesToFloppyBootArchive directory : targets : destName
|
|
{
|
|
# AddFilesToFloppyBootArchive <directory> : <targets> [ : dest name ]
|
|
|
|
AddFilesToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) : $(directory)
|
|
: $(targets) : $(destName) ;
|
|
}
|
|
|
|
rule AddSymlinkToFloppyBootArchive directoryTokens : linkTarget : linkName
|
|
{
|
|
# AddSymlinkToFloppyBootArchive <directory> : <link target>
|
|
# [ : <link name> ] ;
|
|
|
|
AddSymlinkToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(directoryTokens) : $(linkTarget) : $(linkName) ;
|
|
}
|
|
|
|
rule AddDriversToFloppyBootArchive relativeDirectoryTokens : targets
|
|
{
|
|
# AddDriversToFloppyBootArchive <relative directory> : <targets> ;
|
|
|
|
AddDriversToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddNewDriversToFloppyBootArchive relativeDirectoryTokens : targets
|
|
{
|
|
# AddNewDriversToFloppyBootArchive <relative directory> : <targets> ;
|
|
|
|
AddNewDriversToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(targets) ;
|
|
}
|
|
|
|
rule AddDriverRegistrationToFloppyBootArchive relativeDirectoryTokens : target
|
|
: links
|
|
{
|
|
# AddDriverRegistrationToFloppyBootArchive <directory> : <link target>
|
|
# : <link names> ] ;
|
|
|
|
AddDriverRegistrationToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(relativeDirectoryTokens) : $(target) : $(links) ;
|
|
}
|
|
|
|
rule AddBootModuleSymlinksToFloppyBootArchive targets
|
|
{
|
|
# AddBootModuleSymlinksToFloppyBootArchive <targets> ;
|
|
|
|
AddBootModuleSymlinksToContainer $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(targets) ;
|
|
}
|
|
|
|
rule CreateFloppyBootArchiveMakeDirectoriesScript script
|
|
{
|
|
CreateContainerMakeDirectoriesScript
|
|
$(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME) : $(script) ;
|
|
}
|
|
|
|
rule CreateFloppyBootArchiveCopyFilesScript script
|
|
{
|
|
CreateContainerCopyFilesScript $(HAIKU_FLOPPY_BOOT_IMAGE_CONTAINER_NAME)
|
|
: $(script) ;
|
|
}
|
|
|
|
rule BuildFloppyBootArchive archive : scripts
|
|
{
|
|
# BuildHFloppyBootArchive <archive> : <scripts> ;
|
|
|
|
local mainScript = build_archive ;
|
|
SEARCH on $(mainScript) = [ FDirName $(HAIKU_TOP) build scripts ] ;
|
|
|
|
Depends $(archive) : $(mainScript) $(scripts) ;
|
|
BuildFloppyBootArchive1 $(archive) : $(mainScript) $(scripts) ;
|
|
}
|
|
|
|
actions BuildFloppyBootArchive1
|
|
{
|
|
$(2[1]) $(1) $(2[2-])
|
|
}
|
|
|
|
# warning: that is quite x86 dependant...
|
|
|
|
rule BuildFloppyBootImage image : haikuLoader : archive
|
|
{
|
|
Depends $(image) : $(haikuLoader) ;
|
|
Depends $(image) : $(archive) ;
|
|
#MakeLocateDebug $(image) ;
|
|
FLOPPY_IMAGE_SIZE on $(image) = $(HAIKU_BOOT_FLOPPY_IMAGE_SIZE) ;
|
|
ARCHIVE_IMAGE_OFFSET on $(image) = $(HAIKU_BOOT_ARCHIVE_IMAGE_OFFSET) ;
|
|
BuildFloppyBootImage1 $(image) : $(haikuLoader) $(archive) ;
|
|
if $(HAIKU_BOOT_PLATFORM) = atari_m68k {
|
|
Depends $(image) : <build>fixup_tos_boot_checksum ;
|
|
BuildFloppyBootImageFixupM68K $(image)
|
|
: <build>fixup_tos_boot_checksum ;
|
|
}
|
|
if $(HAIKU_BOOT_PLATFORM) = amiga_m68k {
|
|
Depends $(image) : <build>fixup_amiga_boot_checksum ;
|
|
BuildFloppyBootImageFixupM68K $(image)
|
|
: <build>fixup_amiga_boot_checksum ;
|
|
}
|
|
}
|
|
|
|
actions BuildFloppyBootImage1
|
|
{
|
|
haiku_loader_size=`stat -c %s "$(>[1])"`
|
|
drivers_tgz_size=`stat -c %s "$(>[2])"`
|
|
if [ $? -ne 0 ] ; then
|
|
# FreeBSD's stat command don't support -c/--format option
|
|
# and use %z specifier for file size
|
|
haiku_loader_size=`stat -f %z "$(>[1])"`
|
|
drivers_tgz_size=`stat -f %z "$(>[2])"`
|
|
fi
|
|
archive_image_offset=`echo "$(ARCHIVE_IMAGE_OFFSET) * 1024" | bc`
|
|
floppy_tgz_size=\
|
|
`echo "($(FLOPPY_IMAGE_SIZE) - $(ARCHIVE_IMAGE_OFFSET)) * 1024" | bc`
|
|
if [ $haiku_loader_size -gt $archive_image_offset ] ; then
|
|
echo "Error: $(>[1]) is too big ($haiku_loader_size) to fit "
|
|
echo " before the boot archive starting at $archive_image_offset!"
|
|
exit 1
|
|
fi
|
|
if [ $drivers_tgz_size -gt $floppy_tgz_size ] ; then
|
|
echo "Error: $(>[2]) is too big ($drivers_tgz_size) to fit "
|
|
echo " in the boot floppy ($floppy_tgz_size)!"
|
|
exit 1
|
|
fi
|
|
$(RM) $(<)
|
|
# make an empty image
|
|
dd if=/dev/zero of=$(<) bs=1k count=$(FLOPPY_IMAGE_SIZE)
|
|
# add haiku_loader
|
|
dd if=$(>[1]) of=$(<) conv=notrunc
|
|
# add the boot drivers tgz archive
|
|
dd if=$(>[2]) of=$(<) bs=$(ARCHIVE_IMAGE_OFFSET)k seek=1 conv=notrunc
|
|
}
|
|
|
|
actions BuildFloppyBootImageFixupM68K
|
|
{
|
|
# fixup the boot sector checksum
|
|
$(>[1]) $(<)
|
|
}
|
|
|
|
#pragma mark - CD Boot Image rules
|
|
|
|
rule BuildCDBootImage image : bootfloppy : extrafiles
|
|
{
|
|
Depends $(image) : $(bootfloppy) ;
|
|
Depends $(image) : $(extrafiles) ;
|
|
BOOTIMG on $(image) = $(bootfloppy) ;
|
|
|
|
BuildCDBootImage1 $(image) : $(bootfloppy) $(extrafiles) ;
|
|
}
|
|
|
|
actions BuildCDBootImage1
|
|
{
|
|
$(RM) $(<)
|
|
mkisofs -b $(BOOTIMG) -r -J -V bootimg -o $(<) $(>[1]) $(>[2-])
|
|
}
|
|
|
|
|
|
#pragma mark - CD Boot PPC Image rules
|
|
|
|
rule BuildCDBootPPCImage image : hfsmaps : elfloader : coffloader : chrpscript
|
|
: extrafiles
|
|
{
|
|
Depends $(image) : $(elfloader) ;
|
|
Depends $(image) : $(coffloader) ;
|
|
Depends $(image) : $(chrpscript) ;
|
|
Depends $(image) : $(extrafiles) ;
|
|
Depends $(image) : $(hfsmaps) ;
|
|
MAPS on $(image) = $(hfsmaps) ;
|
|
|
|
BuildCDBootPPCImage1 $(image) : $(elfloader) $(coffloader) $(chrpscript)
|
|
$(extrafiles) ;
|
|
}
|
|
|
|
actions BuildCDBootPPCImage1 bind MAPS
|
|
{
|
|
$(RM) $(<)
|
|
mkdir -p $(HAIKU_OUTPUT_DIR)/cd/ppc
|
|
mkdir -p $(HAIKU_OUTPUT_DIR)/cd/boot
|
|
# CHRP Boot script
|
|
cp $(>[3]) $(HAIKU_OUTPUT_DIR)/cd/ppc/bootinfo.txt
|
|
cp $(>[3]) $(HAIKU_OUTPUT_DIR)/cd/boot/boot.chrp
|
|
# Haiku Bootloaders
|
|
cp $(>[2]) $(HAIKU_OUTPUT_DIR)/cd/boot/haikuloader.xcf
|
|
cp $(>[1]) $(HAIKU_OUTPUT_DIR)/cd/boot/haikuloader.elf
|
|
# Extras (readme files, etc)
|
|
cp $(>[4]) $(HAIKU_OUTPUT_DIR)/cd/
|
|
|
|
mkisofs -v -hfs -part -map $(MAPS) -no-desktop -hfs-volid bootimg \
|
|
-V bootimg -hfs-bless $(HAIKU_OUTPUT_DIR)/cd/boot -prep-boot \
|
|
boot/haikuloader.xcf -r -o $(<) $(HAIKU_OUTPUT_DIR)/cd \
|
|
|| \
|
|
genisoimage -v -hfs -part -map $(MAPS) -no-desktop -hfs-volid bootimg \
|
|
-V bootimg -hfs-bless $(HAIKU_OUTPUT_DIR)/cd/boot -prep-boot \
|
|
boot/haikuloader.xcf -r -o $(<) $(HAIKU_OUTPUT_DIR)/cd
|
|
$(RM) -R $(HAIKU_OUTPUT_DIR)/cd
|
|
}
|
|
|
|
|