387 lines
11 KiB
Plaintext
387 lines
11 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
|
|
{
|
|
# MimeSet <target>
|
|
|
|
Depends $(1) : <build>mimeset ;
|
|
MimeSet1 $(1) : <build>mimeset ;
|
|
}
|
|
|
|
actions MimeSet1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) -f "$(1)" ;
|
|
}
|
|
|
|
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-])"
|
|
}
|
|
|
|
# Localization rules
|
|
|
|
# Extract catalog entries from the sourcefile and put the output textfile in
|
|
# target. This output file is then used to create the binary catalog with
|
|
# linkcatkeys.
|
|
rule ExtractCatalogEntries target : source : signature
|
|
{
|
|
# get compiler and defines for the platform
|
|
local headers ;
|
|
local sysHeaders ;
|
|
local cc ;
|
|
local defines ;
|
|
local localIncludesOption ;
|
|
local systemIncludesOption ;
|
|
|
|
on $(target) { # use on $(target) variable values
|
|
headers = $(HAIKU_CONFIG_HEADERS) $(SEARCH_SOURCE) $(SUBDIRHDRS)
|
|
$(HDRS) ;
|
|
sysHeaders = $(SUBDIRSYSHDRS) $(SYSHDRS) ;
|
|
defines = $(DEFINES) ;
|
|
|
|
if $(PLATFORM) = host {
|
|
sysHeaders += $(HOST_HDRS) ;
|
|
defines += $(HOST_DEFINES) ;
|
|
|
|
if $(USES_BE_API) {
|
|
sysHeaders += $(HOST_BE_API_HEADERS) ;
|
|
}
|
|
|
|
defines += $(HOST_DEFINES) ;
|
|
cc = $(HOST_CC) ;
|
|
localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
|
|
systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
|
|
} else {
|
|
sysHeaders += $(TARGET_HDRS) ;
|
|
defines += $(TARGET_DEFINES) ;
|
|
defines += $(TARGET_DEFINES) ;
|
|
cc = $(TARGET_CC) ;
|
|
localIncludesOption = $(TARGET_LOCAL_INCLUDES_OPTION) ;
|
|
systemIncludesOption = $(TARGET_SYSTEM_INCLUDES_OPTION) ;
|
|
}
|
|
}
|
|
|
|
DEFINES on $(target) = $(defines) ;
|
|
CCDEFS on $(target) = [ FDefines $(defines) ] ;
|
|
HDRS on $(target) = [ FIncludes $(headers) : $(localIncludesOption) ]
|
|
$(includesSeparator)
|
|
[ FSysIncludes $(sysHeaders) : $(systemIncludesOption) ] ;
|
|
CC on $(target) = $(cc) ;
|
|
|
|
LOCALE_KIT_SIGNATURE on $(target) = $(signature) ;
|
|
|
|
SEARCH on $(source) += $(SEARCH_SOURCE) ;
|
|
|
|
MakeLocatePlatform $(target) ;
|
|
Depends $(target) : $(source) <build>collectcatkeys ;
|
|
LocalClean clean : $(target).pre ;
|
|
ExtractCatalogEntries1 $(target) : <build>collectcatkeys $(source) ;
|
|
}
|
|
|
|
actions ExtractCatalogEntries1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
cat "$(2[2-])" | $(CC) -E $(CCDEFS) $(HDRS) - > "$(1)".pre
|
|
$(2[1]) -s $(LOCALE_KIT_SIGNATURE) -w -o "$(1)" "$(1)".pre
|
|
}
|
|
|
|
# Link catalog entries from given catkey file into output compiled catalog file.
|
|
# Compiled catalog file will then be copied into the image, but only if the
|
|
# fingerprint matches the one from the untranslated catalog for the same file.
|
|
rule LinkApplicationCatalog target : sources : signature : language
|
|
{
|
|
MakeLocateArch $(target) ;
|
|
LOCALE_KIT_SIGNATURE on $(target) = $(signature) ;
|
|
Depends $(target) : $(sources) <build>linkcatkeys ;
|
|
LocalClean clean : $(target) ;
|
|
LinkApplicationCatalog1 $(target)
|
|
: <build>linkcatkeys $(language) $(sources) ;
|
|
}
|
|
|
|
actions LinkApplicationCatalog1
|
|
{
|
|
$(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
|
|
$(2[1]) "$(2[3-])" -l $(2[2]:B) -v -s $(LOCALE_KIT_SIGNATURE) -o "$(1)"
|
|
}
|
|
|
|
# General rules to invoke from jamfiles and that do (almost) everything related
|
|
# to localization
|
|
rule DoCatalogs appName # Application name
|
|
: signature # Application MIME signature (must match the one
|
|
# declared in the sourcecode)
|
|
: sources # List of cpp files where to search keys
|
|
: generatedCatalog # Name of the generated catalog (most probably
|
|
# en.catalog)
|
|
: translatedCatalogs # List of available translations
|
|
{
|
|
genCat = [ FGristFiles $(generatedCatalog) ] ;
|
|
trans = [ FGristFiles $(translatedCatalogs) ] ;
|
|
srcs = [ FGristFiles $(sources) ] ;
|
|
SEARCH on $(trans) += [ FDirName $(HAIKU_TOP) data catalogs $(SUBDIR_TOKENS[2-]) ] ;
|
|
|
|
ExtractCatalogEntries $(genCat:S=.catkeys) : $(srcs) : $(signature) ;
|
|
|
|
LinkApplicationCatalog $(genCat) : $(genCat:S=.catkeys)
|
|
: $(signature) : $(genCat:B) ;
|
|
|
|
for catalog in $(trans)
|
|
{
|
|
LinkApplicationCatalog $(catalog:S=.catalog) : $(catalog)
|
|
: $(signature) : $(catalog:B) ;
|
|
}
|
|
|
|
AddFilesToHaikuImage system data locale catalogs $(signature) :
|
|
$(genCat) $(trans:S=.catalog) ;
|
|
}
|