b0944c78b0
* All packaging architecture dependent variables do now have a respective suffix and are set up for each configured packaging architecture, save for the kernel and boot loader variables, which are still only set up for the primary architecture. For convenience TARGET_PACKAGING_ARCH, TARGET_ARCH, TARGET_LIBSUPC++, and TARGET_LIBSTDC++ are set to the respective values for the primary packaging architecture by default. * Introduce a set of MultiArch* rules to help with building targets for multiple packaging architectures. Generally the respective targets are (additionally) gristed with the packaging architecture. For libraries the additional grist is usually omitted for the primary architecture (e.g. libroot.so and <x86>libroot.so for x86_gcc2/x86 hybrid), so that Jamfiles for targets built only for the primary architecture don't need to be changed. * Add multi-arch build support for all targets needed for the stage 1 cross devel package as well as for libbe (untested).
309 lines
8.6 KiB
Plaintext
309 lines
8.6 KiB
Plaintext
# BeOS specific rules
|
|
|
|
rule AddFileDataAttribute target : attrName : attrType : dataFile
|
|
{
|
|
# AddFileAttribute <target> : <attrName> : <attrType> : <dataFile> ;
|
|
# Adds a single attribute to a file, retrieving the attribute data from
|
|
# a separate file.
|
|
# <target>: The file to which the attribute shall be added.
|
|
# <attrName>: The name of the attribute.
|
|
# <attrType>: Attribute type as supported by addattr (string, int, etc.)
|
|
# <dataFile>: The data to be written to the attribute will be read from
|
|
# that file.
|
|
# Note that this is supposed to be a build target, not a path
|
|
# name - if you need to add a data file in a different path,
|
|
# you have to locate it first.
|
|
#
|
|
|
|
# We need to create a temporary file in which we store the attribute name
|
|
# and type. Otherwise we wouldn't have these data available in the
|
|
# addattr actions.
|
|
local id = [ NextID ] ;
|
|
local attrMetaFile
|
|
= [ FGristFiles $(target:G=)-attr-$(attrName)-$(attrType)-$(id) ] ;
|
|
|
|
ATTRIBUTE_NAME on $(attrMetaFile) = $(attrName) ;
|
|
ATTRIBUTE_TYPE on $(attrMetaFile) = $(attrType) ;
|
|
MakeLocateArch $(attrMetaFile) ;
|
|
CreateAttributeMetaFile $(attrMetaFile) ;
|
|
|
|
Depends $(target) : <build>addattr $(attrMetaFile) $(dataFile) ;
|
|
AddFileDataAttribute1 $(target)
|
|
: <build>addattr $(attrMetaFile) $(dataFile) ;
|
|
}
|
|
|
|
actions CreateAttributeMetaFile
|
|
{
|
|
echo "-t $(ATTRIBUTE_TYPE)" "$(ATTRIBUTE_NAME)" > "$(1)"
|
|
}
|
|
|
|
actions AddFileDataAttribute1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -f $(2[3]) `cat $(2[2])` $(1)
|
|
}
|
|
|
|
rule AddStringDataResource
|
|
{
|
|
# AddStringDataResource <target> : <resourceID> : <dataString>
|
|
# Adds a single resource to the resources of an executable/library.
|
|
# <target>: The executable/library.
|
|
# <resourceID>: A resource ID string as understood by xres (type:id[:name]).
|
|
# <dataString>: The string <dataString> will be written to the resource.
|
|
# Defaults to "".
|
|
#
|
|
local target = $(1) ;
|
|
local resourceID = $(2) ;
|
|
local dataString = $(3:E="") ;
|
|
|
|
# the resource file
|
|
local resources
|
|
= [ FGristFiles $(target:B)-added-string-data-resources.rsrc ] ;
|
|
|
|
# add the resource file to the target, if not yet done
|
|
if ! [ on $(resources) return $(RESOURCES_ADDED) ] {
|
|
RESOURCES_ADDED on $(resources) = true ;
|
|
MakeLocateArch $(resources) ;
|
|
Depends $(resources) : <build>xres ;
|
|
AddStringDataResource1 $(resources) : <build>xres ;
|
|
AddResources $(target) : $(resources) ;
|
|
}
|
|
|
|
RESOURCE_STRINGS on $(resources)
|
|
+= "-a "$(resourceID)" -s \""$(dataString)"\"" ;
|
|
}
|
|
|
|
actions together AddStringDataResource1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -o "$(1)" $(RESOURCE_STRINGS)
|
|
}
|
|
|
|
rule AddFileDataResource
|
|
{
|
|
# AddFileDataResource <target> : <resourceID> : [ <dataFile> ]
|
|
# Adds a single resource to the resources of an executable/library.
|
|
# <target>: The executable/library.
|
|
# <resourceID>: A resource ID string as understood by xres (type:id[:name]).
|
|
# <dataFile>: The data to be written into the resource will be read from
|
|
# that file.
|
|
# Note that this is supposed to be a build target, not a path
|
|
# name - if you need to add a data file in a different path, you
|
|
# have to locate it first.
|
|
#
|
|
local target = $(1) ;
|
|
local resourceID = $(2) ;
|
|
local dataFile = $(3) ;
|
|
|
|
# the resource file
|
|
local resources
|
|
= <added-resources>file-data-$(resourceID)-$(dataFile).rsrc ;
|
|
|
|
# add it to the resources of the given target
|
|
AddResources $(target) : $(resources) ;
|
|
|
|
# if the rule for creating the resource file has not been invoked yet, do it
|
|
if ! [ on $(resources) return $(RESOURCES_DEFINED) ] {
|
|
RESOURCES_DEFINED on $(resources) = true ;
|
|
RESOURCE_ID on $(resources) = $(resourceID) ;
|
|
MakeLocateArch $(resources) ;
|
|
|
|
Depends $(resources) : <build>xres $(dataFile) ;
|
|
AddFileDataResource1 $(resources) : <build>xres $(dataFile) ;
|
|
}
|
|
}
|
|
|
|
actions AddFileDataResource1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -o "$(1)" -a "$(RESOURCE_ID)" "$(2[2])" ;
|
|
}
|
|
|
|
rule XRes
|
|
{
|
|
# XRes <target> : <resource files>
|
|
if $(2)
|
|
{
|
|
Depends $(1) : <build>xres $(2) ;
|
|
XRes1 $(1) : <build>xres $(2) ;
|
|
}
|
|
}
|
|
|
|
actions XRes1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -o "$(1)" "$(2[2-])" ;
|
|
}
|
|
|
|
rule SetVersion
|
|
{
|
|
# SetVersion <target>
|
|
|
|
Depends $(1) : <build>setversion ;
|
|
SetVersion1 $(1) : <build>setversion ;
|
|
}
|
|
|
|
actions SetVersion1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) "$(1)" -system $(HAIKU_BUILD_VERSION) -short "$(HAIKU_BUILD_DESCRIPTION)" ;
|
|
}
|
|
|
|
rule SetType target : type
|
|
{
|
|
# SetType <target> [ : <type> ]
|
|
# Sets the MIME type on the target. If none is given, the executable MIME
|
|
# type is used.
|
|
|
|
TARGET_MIME_TYPE on $(target) = $(type:E=$(TARGET_EXECUTABLE_MIME_TYPE)) ;
|
|
|
|
Depends $(target) : <build>settype ;
|
|
SetType1 $(target) : <build>settype ;
|
|
}
|
|
|
|
actions SetType1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -t $(TARGET_MIME_TYPE) "$(1)" ;
|
|
}
|
|
|
|
rule MimeSet target
|
|
{
|
|
# MimeSet <target> ;
|
|
|
|
Depends $(target) : <build>mimeset <mimedb>mime_db ;
|
|
MimeSet1 $(target) : <build>mimeset <mimedb>mime_db ;
|
|
}
|
|
|
|
|
|
actions MimeSet1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -f --mimedb "$(2[2])" "$(1)"
|
|
}
|
|
|
|
|
|
rule CreateAppMimeDBEntries target
|
|
{
|
|
# MimeSetApp <target> ;
|
|
# Create the app meta MIME DB entries for the given target. The
|
|
# HAIKU_MIME_DB_ENTRIES variable on <target> is set to the generated
|
|
# resulting target directory that contains the MIME DB entries.
|
|
|
|
local appGrist = $(target:G) ;
|
|
local appMimeDB = $(target:BS)_mimedb ;
|
|
appMimeDB = $(appMimeDB:G=mimedb-app-$(appGrist:E=)) ;
|
|
MakeLocateDebug $(appMimeDB) ;
|
|
Depends $(appMimeDB) : <build>mimeset $(target) <mimedb>mime_db ;
|
|
CreateAppMimeDBEntries1 $(appMimeDB)
|
|
: <build>mimeset $(target) <mimedb>mime_db ;
|
|
|
|
HAIKU_MIME_DB_ENTRIES on $(target) = $(appMimeDB) ;
|
|
}
|
|
|
|
|
|
actions CreateAppMimeDBEntries1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
|
|
appMimeDB="$(1)"
|
|
$(RM) -rf "$appMimeDB"
|
|
$(MKDIR) "$appMimeDB"
|
|
$(2[1]) -f --apps --mimedb "$appMimeDB" --mimedb "$(2[3])" "$(2[2])"
|
|
}
|
|
|
|
|
|
rule ResComp
|
|
{
|
|
# ResComp <resource file> : <rdef file> ;
|
|
#
|
|
# <resource file> and <rdef file> must be gristed.
|
|
|
|
# get compiler and defines for the platform
|
|
local cc ;
|
|
local defines ;
|
|
local localIncludesOption ;
|
|
|
|
on $(1) { # use on $(1) variable values
|
|
defines = $(DEFINES) ;
|
|
|
|
if $(PLATFORM) = host {
|
|
defines += $(HOST_DEFINES) ;
|
|
cc = $(HOST_CC) ;
|
|
localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
|
|
} else {
|
|
defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
|
|
$(TARGET_DEFINES) ;
|
|
cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
|
|
localIncludesOption
|
|
= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
|
|
}
|
|
}
|
|
|
|
DEFINES on $(1) = $(defines) ;
|
|
CCDEFS on $(1) = [ FDefines $(defines) ] ;
|
|
HDRS on $(1) = [ FIncludes $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS)
|
|
: $(localIncludesOption) ] ;
|
|
RCHDRS on $(1) = [ FIncludes $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS)
|
|
: "-I " ] ;
|
|
CC on $(1) = $(cc) ;
|
|
|
|
# set up other vars
|
|
SEARCH on $(2) += $(SEARCH_SOURCE) ;
|
|
MakeLocateArch $(1) ;
|
|
Depends $(1) : $(2) <build>rc ;
|
|
LocalClean clean : $(1) ;
|
|
ResComp1 $(1) : <build>rc $(2) ;
|
|
}
|
|
|
|
# Note: We pipe the input files into the preprocessor, since *.rdef files are
|
|
# considered linker scripts, and thus we can use preprocessor features.
|
|
actions ResComp1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
cat "$(2[2-])" | $(CC) -E $(CCDEFS) $(HDRS) - | egrep -v '^#' | $(2[1]) $(RCHDRS) --auto-names -o "$(1)" -
|
|
}
|
|
|
|
rule ResAttr attributeFile : _resourceFiles : deleteAttributeFile
|
|
{
|
|
# ResAttr <attribute file> : <resource files> [ : <delete file> ] ;
|
|
#
|
|
# <attribute file> and <resource files> must be gristed.
|
|
# <resource files> can also be .rdef files -- they will be compiled first in
|
|
# this case.
|
|
# <clear file> is a boolean that specifies wether or not the target file
|
|
# should be removed before writing. Defaults to true.
|
|
|
|
local resourceFiles ;
|
|
local resourceFile ;
|
|
deleteAttributeFile ?= true ;
|
|
deleteAttributeFile1 on $(1) = $(deleteAttributeFile) ;
|
|
|
|
for resourceFile in $(_resourceFiles) {
|
|
# if the specified resource file is an .rdef file, we compile it first
|
|
if $(resourceFile:S) = ".rdef" {
|
|
local rdefFile = $(resourceFile) ;
|
|
resourceFile = $(rdefFile:S=.rsrc) ;
|
|
ResComp $(resourceFile) : $(rdefFile) ;
|
|
} else {
|
|
SEARCH on $(resourceFile) += $(SEARCH_SOURCE) ;
|
|
}
|
|
|
|
resourceFiles += $(resourceFile) ;
|
|
}
|
|
|
|
MakeLocateArch $(attributeFile) ;
|
|
Depends $(attributeFile) : $(resourceFiles) <build>resattr ;
|
|
LocalClean clean : $(attributeFile) ;
|
|
ResAttr1 $(attributeFile) : <build>resattr $(resourceFiles) ;
|
|
}
|
|
|
|
actions ResAttr1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
if [ \\"$(deleteAttributeFile1)\\" = "true" ]; then
|
|
$(RM) $(1)
|
|
fi
|
|
$(2[1]) -O -o "$(1)" "$(2[2-])"
|
|
}
|