e823d3f06f
Otherwise, Clang warns that we haven't set an architecture on ARM, which is set in CCFLAGS. Since these might also contain other flags that affect the preprocessor, there isn't any good reason to not pass it through, so do that.
314 lines
8.7 KiB
Plaintext
314 lines
8.7 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 flags ;
|
|
local localIncludesOption ;
|
|
|
|
on $(1) { # use on $(1) variable values
|
|
defines = $(DEFINES) ;
|
|
|
|
if $(PLATFORM) = host {
|
|
defines += $(HOST_DEFINES) ;
|
|
cc = $(HOST_CC) ;
|
|
flags += $(HOST_CCFLAGS) ;
|
|
localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
|
|
} else {
|
|
defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
|
|
$(TARGET_DEFINES) ;
|
|
cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
|
|
flags += $(TARGET_CCFLAGS_$(TARGET_PACKAGING_ARCH)) ;
|
|
localIncludesOption
|
|
= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
|
|
}
|
|
}
|
|
|
|
DEFINES on $(1) = $(defines) ;
|
|
CCDEFS on $(1) = [ FDefines $(defines) ] ;
|
|
CCFLAGS on $(1) = $(flags) ;
|
|
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) $(CCFLAGS) -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-])"
|
|
}
|