518840e305
* Update MimeSet rule to use the MIME DB the build system creates. * Add CreateAppMimeDBEntries rule and call it from Link for targets that might be applications that need to be registered with the MIME DB. For the target the rule is invoked with it creates a directory into which the entries for the types to be registered are written. The directory is associated with the target via the HAIKU_MIME_DB_ENTRIES variable. * AddFilesToContainer: If a target is added that has MIME DB entries, also add those to the container. * build_haiku_package: Call mimeset for the package contents.
303 lines
8.3 KiB
Plaintext
303 lines
8.3 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
|
|
{
|
|
# SetType <target>
|
|
|
|
Depends $(1) : <build>settype ;
|
|
SetType1 $(1) : <build>settype ;
|
|
}
|
|
|
|
actions SetType1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -t $(TARGET_EXECUTABLE_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) ;
|
|
cc = $(TARGET_CC) ;
|
|
localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
|
|
}
|
|
}
|
|
|
|
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-])"
|
|
}
|