220d040227
* Instead of faking libstdc++.so from libstdc++.a, use libstdc++.so from the gcc_syslibs build feature for everything except x86_gcc2. * Use libgcc_s.so from the gcc_syslibs build feature for everything but x86_gcc2 (which still carries libgcc as part of libroot.so). * Drop filtering of libgcc objects for libroot, as that is no longer necessary since we're only using libgcc-as-single-object for libroot with x86_gcc2, where the filtered object file doesn't exist. Should the objects that used to be filtered cause any problems as part of libgcc_s.so, we can always filter them as part of the gcc build. * Use libsupc++.so from the gcc_syslibs build feature for everything but x86_gcc2. * Adjust all Jamfiles accordingly. * Deactivate building of faked libstdc++.so for non-x86-gcc2. For x86_gcc2, we still build libstdc++.so from the sources in the Haiku source tree as part of the Haiku build . * Put gcc_syslibs package onto the image, when needed.
763 lines
19 KiB
Plaintext
763 lines
19 KiB
Plaintext
rule AddSharedObjectGlueCode
|
|
{
|
|
# AddSharedObjectGlueCode <target> : <isExecutable> ;
|
|
|
|
# we link with -nostdlib and add the required libs manually, when building
|
|
# for Haiku
|
|
local platform ;
|
|
on $(1) {
|
|
platform = $(PLATFORM) ;
|
|
if $(platform) = haiku {
|
|
local stdLibs = [ MultiArchDefaultGristFiles libroot.so ]
|
|
[ TargetLibgcc ] ;
|
|
local type = EXECUTABLE ;
|
|
if $(2) != true {
|
|
type = LIBRARY ;
|
|
|
|
# special case for libroot: don't link it against itself
|
|
if $(DONT_LINK_AGAINST_LIBROOT) {
|
|
stdLibs = ;
|
|
}
|
|
}
|
|
|
|
local beginGlue
|
|
= $(HAIKU_$(type)_BEGIN_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
|
|
local endGlue
|
|
= $(HAIKU_$(type)_END_GLUE_CODE_$(TARGET_PACKAGING_ARCH)) ;
|
|
|
|
LINK_BEGIN_GLUE on $(1) = $(beginGlue) ;
|
|
LINK_END_GLUE on $(1) = $(endGlue) ;
|
|
|
|
NEEDLIBS on $(1) = [ on $(1) return $(NEEDLIBS) ] $(stdLibs) ;
|
|
Depends $(1) : $(stdLibs) $(beginGlue) $(endGlue) ;
|
|
LINKFLAGS on $(1) = [ on $(1) return $(LINKFLAGS) ] -nostdlib
|
|
-Xlinker --no-undefined ;
|
|
}
|
|
}
|
|
|
|
# link against the compatibility libraries needed for the target
|
|
if $(platform) != host && $(TARGET_HAIKU_COMPATIBILITY_LIBS) {
|
|
LinkAgainst $(1) : $(TARGET_HAIKU_COMPATIBILITY_LIBS) ;
|
|
}
|
|
}
|
|
|
|
rule Executable
|
|
{
|
|
# Executable <name> : <sources> : <libraries> : <res> ;
|
|
#
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
AddResources $(1) : $(4) ;
|
|
Main $(1) : $(2) ;
|
|
LinkAgainst $(1) : $(3) ;
|
|
LINKFLAGS on $(1) = [ on $(1) return $(LINKFLAGS) ]
|
|
-Xlinker -soname=_APP_ ;
|
|
|
|
# we link with -nostdlib and add the required libs manually, when building
|
|
# for Haiku
|
|
AddSharedObjectGlueCode $(1) : true ;
|
|
}
|
|
|
|
rule Application
|
|
{
|
|
# Application <name> : <sources> : <libraries> : <res> ;
|
|
Executable $(1) : $(2) : $(3) : $(4) ;
|
|
}
|
|
|
|
rule BinCommand
|
|
{
|
|
# BinCommand <name> : <sources> : <libraries> : <res> ;
|
|
Executable $(1) : $(2) : $(3) : $(4) ;
|
|
}
|
|
|
|
rule StdBinCommands
|
|
{
|
|
# StdBinCommands <sources> : <libs> : <res> ;
|
|
local libs = $(2) ;
|
|
local ress = $(3) ;
|
|
local source ;
|
|
for source in $(1)
|
|
{
|
|
local target = $(source:S=) ;
|
|
|
|
BinCommand $(target) : $(source) : $(libs) : $(ress) ;
|
|
}
|
|
}
|
|
|
|
rule Preference
|
|
{
|
|
# Preference <name> : <sources> : <libraries> : <res> ;
|
|
Executable $(1) : $(2) : $(3) : $(4) ;
|
|
}
|
|
|
|
rule Server
|
|
{
|
|
# Server <name> : <sources> : <libraries> : <res> ;
|
|
|
|
Executable $(1) : $(2) : $(3) : $(4) ;
|
|
}
|
|
|
|
rule Addon target : sources : libraries : isExecutable
|
|
{
|
|
# Addon <target> : <sources> : <is executable> : <libraries> ;
|
|
# <target>: The add-on.
|
|
# <sources>: Source files.
|
|
# <libraries>: Libraries to be linked against.
|
|
# <isExecutable>: true, if the target shall be executable as well.
|
|
|
|
if ! [ IsPlatformSupportedForTarget $(target) ] {
|
|
return ;
|
|
}
|
|
|
|
Main $(target) : $(sources) ;
|
|
|
|
local linkFlags = -Xlinker -soname=\"$(target:G=)\" ;
|
|
if $(isExecutable) != true {
|
|
linkFlags = -shared $(linkFlags) ;
|
|
}
|
|
LINKFLAGS on $(target) = [ on $(target) return $(LINKFLAGS) ] $(linkFlags) ;
|
|
LinkAgainst $(target) : $(libraries) ;
|
|
|
|
AddSharedObjectGlueCode $(target) : $(isExecutable) ;
|
|
}
|
|
|
|
rule Translator target : sources : libraries : isExecutable
|
|
{
|
|
# Translator <target> : <sources> : <libraries> : <isExecutable> ;
|
|
Addon $(target) : $(sources) : $(libraries) : $(isExecutable) ;
|
|
}
|
|
|
|
rule ScreenSaver target : sources : libraries
|
|
{
|
|
# ScreenSaver <target> : <sources> : <libraries> ;
|
|
Addon $(target) : $(sources) : $(libraries) : false ;
|
|
}
|
|
|
|
rule StaticLibrary
|
|
{
|
|
# StaticLibrary <lib> : <sources> : <otherObjects> ;
|
|
# Creates a static library from sources.
|
|
# <lib>: The static library to be built.
|
|
# <sources>: List of source files.
|
|
# <otherObjects>: List of additional object files.
|
|
#
|
|
local lib = $(1) ;
|
|
local sources = [ FGristFiles $(2) ] ;
|
|
local otherObjects = $(3) ;
|
|
local objects = $(sources:S=$(SUFOBJ)) ;
|
|
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
InheritPlatform $(objects) : $(lib) ;
|
|
|
|
StaticLibraryFromObjects $(lib) : $(objects) $(otherObjects) ;
|
|
Objects $(2) ;
|
|
}
|
|
|
|
rule StaticLibraryFromObjects
|
|
{
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
LibraryFromObjects $(1) : $(2) ;
|
|
}
|
|
|
|
rule AssembleNasm
|
|
{
|
|
Depends $(<) : $(>) [ on $(<) return $(PLATFORM) ] ;
|
|
}
|
|
|
|
actions AssembleNasm
|
|
{
|
|
if test $(ASFLAGS) ; then
|
|
$(HAIKU_NASM) -d $(ASFLAGS) -f elf32 -o $(1) $(2);
|
|
else
|
|
$(HAIKU_NASM) -f elf32 -o $(1) $(2);
|
|
fi
|
|
}
|
|
|
|
rule CompileDTS
|
|
{
|
|
Depends $(<) : $(>) ;
|
|
}
|
|
|
|
actions CompileDTS
|
|
{
|
|
dtc -O dtb -o $(1) $(2);
|
|
}
|
|
|
|
rule Ld
|
|
{
|
|
# Ld <name> : <objs> : <linkerscript> : <flags> ;
|
|
#
|
|
local target = $(1) ;
|
|
local objects = $(2) ;
|
|
local linkerScript = $(3) ;
|
|
local linkerFlags = $(4) ;
|
|
|
|
if $(linkerScript) {
|
|
linkerFlags += --script=$(linkerScript) ;
|
|
}
|
|
|
|
on $(target) {
|
|
if $(PLATFORM) = host {
|
|
LINK on $(target) = $(HOST_LD) ;
|
|
LINKFLAGS on $(target) = $(HOST_LDFLAGS) $(LINKFLAGS) $(linkerFlags) ;
|
|
} else {
|
|
LINK on $(target) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
|
|
LINKFLAGS on $(target) = $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH))
|
|
$(LINKFLAGS) $(linkerFlags) ;
|
|
}
|
|
|
|
NEEDLIBS on $(target) = $(NEEDLIBS) ;
|
|
LINKLIBS on $(target) = $(LINKLIBS) ;
|
|
}
|
|
|
|
LocalClean clean : $(target) ;
|
|
LocalDepends all : $(target) ;
|
|
Depends $(target) : $(objects) ;
|
|
|
|
MakeLocateDebug $(target) ;
|
|
|
|
on $(1) XRes $(1) : $(RESFILES) ;
|
|
if ! [ on $(1) return $(DONT_USE_BEOS_RULES) ] {
|
|
SetType $(1) ;
|
|
MimeSet $(1) ;
|
|
SetVersion $(1) ;
|
|
}
|
|
}
|
|
|
|
actions Ld
|
|
{
|
|
$(LINK) $(LINKFLAGS) -o "$(1)" "$(2)" "$(NEEDLIBS)" $(LINKLIBS)
|
|
}
|
|
|
|
rule CreateAsmStructOffsetsHeader header : source
|
|
{
|
|
# CreateAsmStructOffsetsHeader header : source
|
|
#
|
|
# Grist will be added to both header and source.
|
|
|
|
header = [ FGristFiles $(header) ] ;
|
|
source = [ FGristFiles $(source) ] ;
|
|
|
|
# find out which headers, defines, etc. to use
|
|
local headers ;
|
|
local sysHeaders ;
|
|
local defines ;
|
|
local flags ;
|
|
local includesSeparator ;
|
|
local localIncludesOption ;
|
|
local systemIncludesOption ;
|
|
|
|
on $(header) { # use on $(1) variable values
|
|
if ! $(PLATFORM) in $(SUPPORTED_PLATFORMS) {
|
|
return ;
|
|
}
|
|
|
|
# headers and defines
|
|
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) ;
|
|
}
|
|
|
|
} else {
|
|
sysHeaders += [ FStandardHeaders $(TARGET_PACKAGING_ARCH) ]
|
|
$(TARGET_HDRS_$(TARGET_PACKAGING_ARCH)) ;
|
|
defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
|
|
$(TARGET_DEFINES) ;
|
|
}
|
|
|
|
# optimization flags
|
|
if $(DEBUG) = 0 {
|
|
flags += $(OPTIM) ;
|
|
} else {
|
|
flags += -O0 ;
|
|
}
|
|
|
|
if $(PLATFORM) = host {
|
|
# warning flags
|
|
if $(WARNINGS) != 0 {
|
|
flags += $(HOST_WARNING_C++FLAGS) ;
|
|
if $(WARNINGS) = treatAsErrors {
|
|
flags += -Werror $(HOST_WERROR_FLAGS) ;
|
|
}
|
|
}
|
|
|
|
# debug and other flags
|
|
flags += $(HOST_C++FLAGS) $(HOST_DEBUG_$(DEBUG)_C++FLAGS)
|
|
$(SUBDIRC++FLAGS) $(C++FLAGS) ;
|
|
|
|
if $(USES_BE_API) {
|
|
flags += $(HOST_BE_API_C++FLAGS) ;
|
|
}
|
|
|
|
C++ on $(header) = $(HOST_C++) ;
|
|
|
|
includesSeparator = $(HOST_INCLUDES_SEPARATOR) ;
|
|
localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
|
|
systemIncludesOption = $(HOST_SYSTEM_INCLUDES_OPTION) ;
|
|
|
|
} else {
|
|
# warning flags
|
|
if $(WARNINGS) != 0 {
|
|
flags += $(TARGET_WARNING_C++FLAGS_$(TARGET_PACKAGING_ARCH)) ;
|
|
if $(WARNINGS) = treatAsErrors {
|
|
flags += -Werror
|
|
$(TARGET_WERROR_FLAGS_$(TARGET_PACKAGING_ARCH)) ;
|
|
}
|
|
}
|
|
|
|
# debug and other flags
|
|
flags += $(TARGET_C++FLAGS_$(TARGET_PACKAGING_ARCH))
|
|
$(TARGET_DEBUG_$(DEBUG)_C++FLAGS_$(TARGET_PACKAGING_ARCH))
|
|
$(SUBDIRC++FLAGS) $(C++FLAGS) ;
|
|
|
|
C++ on $(header) = $(TARGET_C++_$(TARGET_PACKAGING_ARCH)) ;
|
|
|
|
includesSeparator
|
|
= $(TARGET_INCLUDES_SEPARATOR_$(TARGET_PACKAGING_ARCH)) ;
|
|
localIncludesOption
|
|
= $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
|
|
systemIncludesOption
|
|
= $(TARGET_SYSTEM_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
|
|
}
|
|
}
|
|
|
|
# Turn off "invalid use of offsetof()" macro warning. We use offsetof() also
|
|
# for non-PODs. Since we're using the same compiler for the whole kernel and
|
|
# don't do virtual inheritence, that works well enough.
|
|
flags += -Wno-invalid-offsetof ;
|
|
# TODO: Rather get rid of the respective offsetof() instances.
|
|
|
|
# locate object, search for source, and set on target variables
|
|
|
|
Depends $(header) : $(source) $(PLATFORM) ;
|
|
SEARCH on $(source) += $(SEARCH_SOURCE) ;
|
|
MakeLocateArch $(header) ;
|
|
LocalClean clean : $(header) ;
|
|
|
|
HDRRULE on $(source) = HdrRule ;
|
|
HDRSCAN on $(source) = $(HDRPATTERN) ;
|
|
HDRSEARCH on $(source) = $(headers) $(sysHeaders) $(STDHDRS) ;
|
|
HDRGRIST on $(source) = $(HDRGRIST) ;
|
|
|
|
C++FLAGS on $(header) = $(flags) ;
|
|
CCHDRS on $(header) = [ FIncludes $(headers) : $(localIncludesOption) ]
|
|
$(includesSeparator)
|
|
[ FSysIncludes $(sysHeaders) : $(systemIncludesOption) ] ;
|
|
CCDEFS on $(header) = [ FDefines $(defines) ] ;
|
|
|
|
CreateAsmStructOffsetsHeader1 $(header) : $(source) ;
|
|
}
|
|
|
|
actions CreateAsmStructOffsetsHeader1
|
|
{
|
|
$(C++) -S "$(2)" $(C++FLAGS) $(CCDEFS) $(CCHDRS) -o - \
|
|
| grep "#define" | sed -e 's/[\$\#]\([0-9]\)/\1/' > "$(1)"
|
|
}
|
|
|
|
rule MergeObjectFromObjects
|
|
{
|
|
# MergeObjectFromObjects <name> : <objects> : <other objects> ;
|
|
# Merges object files to an object file.
|
|
# <name>: Name of the object file to create. No grist will be added.
|
|
# <objects>: Object files to be merged. Grist will be added.
|
|
# <other objects>: Object files or static libraries to be merged. No grist
|
|
# will be added.
|
|
#
|
|
local objects = [ FGristFiles $(2) ] ;
|
|
|
|
on $(1) {
|
|
if ! $(PLATFORM) in $(SUPPORTED_PLATFORMS) {
|
|
return ;
|
|
}
|
|
|
|
if $(PLATFORM) = host {
|
|
LINK on $(1) = $(HOST_LD) ;
|
|
LINKFLAGS on $(target) = $(HOST_LDFLAGS) ;
|
|
} else {
|
|
LINK on $(1) = $(TARGET_LD_$(TARGET_PACKAGING_ARCH)) ;
|
|
LINKFLAGS on $(target)
|
|
= $(TARGET_LDFLAGS_$(TARGET_PACKAGING_ARCH)) ;
|
|
}
|
|
}
|
|
|
|
MakeLocateDebug $(1) ;
|
|
Depends $(1) : $(objects) ;
|
|
Depends $(1) : $(3) ;
|
|
LocalDepends obj : $(1) ;
|
|
MergeObjectFromObjects1 $(1) : $(objects) $(3) ;
|
|
}
|
|
|
|
actions MergeObjectFromObjects1
|
|
{
|
|
$(LINK) $(LINKFLAGS) -r $(2) -o $(1) ;
|
|
}
|
|
|
|
rule MergeObject
|
|
{
|
|
# MergeObject <name> : <sources> : <other objects> ;
|
|
# Compiles source files and merges the object files to an object file.
|
|
# <name>: Name of the object file to create. No grist will be added.
|
|
# <sources>: Sources to be compiled. Grist will be added.
|
|
# <other objects>: Object files or static libraries to be merged. No grist
|
|
# will be added.
|
|
#
|
|
local target = $(1) ;
|
|
local sources = [ FGristFiles $(2) ] ;
|
|
local otherObjects = $(3) ;
|
|
local objects = $(sources:S=$(SUFOBJ)) ;
|
|
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
InheritPlatform $(objects) : $(target) ;
|
|
Objects $(sources) ;
|
|
MergeObjectFromObjects $(target) : $(objects) : $(otherObjects) ;
|
|
}
|
|
|
|
rule SharedLibraryFromObjects
|
|
{
|
|
# SharedLibraryFromObjects <lib> : <objects> : <libraries> ;
|
|
#
|
|
local _lib = $(1) ;
|
|
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
local soname = [ on $(_lib) return $(HAIKU_SONAME) ] ;
|
|
soname ?= $(_lib:BS) ;
|
|
|
|
MainFromObjects $(_lib) : $(2) ;
|
|
LINKFLAGS on $(_lib) = [ on $(_lib) return $(LINKFLAGS) ]
|
|
-shared -Xlinker -soname=\"$(soname)\" ;
|
|
LinkAgainst $(_lib) : $(3) ;
|
|
|
|
AddSharedObjectGlueCode $(_lib) : false ;
|
|
}
|
|
|
|
rule SharedLibrary
|
|
{
|
|
# SharedLibrary <lib> : <sources> : <libraries> : <abiVersion> ;
|
|
local lib = $(1) ;
|
|
local sources = [ FGristFiles $(2) ] ;
|
|
local objects = $(sources:S=$(SUFOBJ)) ;
|
|
local libs = $(3) ;
|
|
local abiVersion = $(4) ; # major ABI (soname) version for lib (if any)
|
|
|
|
if ! [ IsPlatformSupportedForTarget $(1) ] {
|
|
return ;
|
|
}
|
|
|
|
if $(abiVersion) {
|
|
HAIKU_SONAME on $(lib) = $(lib:BS).$(abiVersion) ;
|
|
HAIKU_LIB_ABI_VERSION on $(lib) = $(abiVersion) ;
|
|
}
|
|
|
|
InheritPlatform $(objects) : $(lib) ;
|
|
Objects $(sources) ;
|
|
SharedLibraryFromObjects $(lib) : $(objects) : $(libs) ;
|
|
}
|
|
|
|
rule LinkAgainst
|
|
{
|
|
# LinkAgainst <name> : <libs> [ : <mapLibs> ] ;
|
|
# Valid elements for <libs> are e.g. "be" or "libtranslation.so" or
|
|
# "/boot/.../libfoo.so". If the basename starts with "lib" or the thingy
|
|
# has a dirname or grist, it is added to the NEEDLIBS variable (i.e. the
|
|
# file will be bound!), otherwise it is prefixed "-l" and added to
|
|
# LINKLIBS. If you want to specify a target that isn't a library and
|
|
# also has neither grist nor a dirname, you can prepend "<nogrist>" as
|
|
# grist; it will be stripped by this rule.
|
|
# <mapLibs> specifies whether the to translate library names (e.g. "be"
|
|
# to "libbe.so" in case of target platform "haiku"). Defaults to "true".
|
|
#
|
|
local target = $(1) ;
|
|
local libs = $(2) ;
|
|
local mapLibs = $(3:E=true) ;
|
|
|
|
on $(target) {
|
|
local i ;
|
|
|
|
# map libraries, if desired and target platform is Haiku
|
|
local map = $(TARGET_LIBRARY_NAME_MAP_$(TARGET_PACKAGING_ARCH)) ;
|
|
if $(PLATFORM) != host && $(mapLibs) = true && $(map) {
|
|
local mappedLibs ;
|
|
|
|
for i in $(libs) {
|
|
local mapped = $($(map)_$(i)) ;
|
|
mapped ?= $(i) ;
|
|
mappedLibs += $(mapped) ;
|
|
}
|
|
|
|
libs = $(mappedLibs) ;
|
|
}
|
|
|
|
local linkLibs ;
|
|
local needLibs ;
|
|
|
|
for i in $(libs)
|
|
{
|
|
local isfile = ;
|
|
if $(i:D) || $(i:G) {
|
|
isfile = true ;
|
|
if $(i:G) = <nogrist> {
|
|
i = $(i:G=) ;
|
|
}
|
|
} else {
|
|
switch $(i:B)
|
|
{
|
|
# XXX: _APP_ and _KERNEL_ should not be needed for ELF.
|
|
case _APP_ : isfile = true ;
|
|
case _KERNEL_ : isfile = true ;
|
|
case lib* : isfile = true ;
|
|
case * : isfile = ;
|
|
}
|
|
if ! $(isfile) && ( $(i:S) = .so || $(i:S) = .a ) {
|
|
isfile = true ;
|
|
}
|
|
}
|
|
|
|
if $(isfile) {
|
|
needLibs += $(i) ;
|
|
} else {
|
|
linkLibs += $(i) ;
|
|
}
|
|
}
|
|
|
|
NEEDLIBS on $(1) = $(NEEDLIBS) $(needLibs) ;
|
|
LINKLIBS on $(1) = $(LINKLIBS) -l$(linkLibs) ;
|
|
|
|
if $(needLibs) && ! $(NO_LIBRARY_DEPENDENCIES) {
|
|
Depends $(1) : $(needLibs) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
rule AddResources
|
|
{
|
|
# AddResources <name> : <resourcefiles> ;
|
|
|
|
# add grist to the resource files which don't have any yet
|
|
local resfiles ;
|
|
local file ;
|
|
for file in $(2) {
|
|
if ! $(file:G) {
|
|
file = [ FGristFiles $(file) ] ;
|
|
}
|
|
resfiles += $(file) ;
|
|
}
|
|
|
|
SEARCH on $(resfiles) += $(SEARCH_SOURCE) ;
|
|
|
|
for file in $(resfiles) {
|
|
if $(file:S) = .rdef {
|
|
local rdef = $(file) ;
|
|
file = $(rdef:S=.rsrc) ;
|
|
ResComp $(file) : $(rdef) ;
|
|
}
|
|
InheritPlatform $(file) : $(1) ;
|
|
RESFILES on $(1) += $(file) ;
|
|
}
|
|
}
|
|
|
|
rule SetVersionScript target : versionScript
|
|
{
|
|
# SetVersionScript <target> : <versionScript>
|
|
#
|
|
# Sets the version script for <target>. Grist will be added to
|
|
# <versionScript> and SEARCH will be set on it.
|
|
|
|
versionScript = [ FGristFiles $(versionScript) ] ;
|
|
|
|
SEARCH on $(versionScript) += $(SEARCH_SOURCE) ;
|
|
|
|
VERSION_SCRIPT on $(target) = $(versionScript) ;
|
|
Depends $(target) : $(versionScript) ;
|
|
}
|
|
|
|
rule BuildPlatformObjects
|
|
{
|
|
# Usage BuildPlatformObjects <sources> ;
|
|
# <sources> The sources.
|
|
#
|
|
local sources = [ FGristFiles $(1) ] ;
|
|
local objects = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
|
|
|
|
PLATFORM on $(objects) = host ;
|
|
SUPPORTED_PLATFORMS on $(objects) = host ;
|
|
|
|
Objects $(sources) ;
|
|
}
|
|
|
|
actions CygwinExtensionFix
|
|
{
|
|
if test -f $(1).exe ; then
|
|
rm -f $(1)
|
|
mv $(1).exe $(1)
|
|
fi
|
|
}
|
|
|
|
rule BuildPlatformMain
|
|
{
|
|
# Usage BuildPlatformMain <target> : <sources> : <libraries> ;
|
|
# <target> The executable/library.
|
|
# <sources> The sources.
|
|
# <libraries> Libraries to link against.
|
|
#
|
|
local target = $(1) ;
|
|
local sources = $(2) ;
|
|
local libs = $(3) ;
|
|
local objects = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
|
|
|
|
PLATFORM on $(target) = host ;
|
|
SUPPORTED_PLATFORMS on $(target) = host ;
|
|
DONT_USE_BEOS_RULES on $(target) = true ;
|
|
|
|
local usesBeAPI = [ on $(target) return $(USES_BE_API) ] ;
|
|
if $(usesBeAPI) {
|
|
# propagate the flag to the objects
|
|
USES_BE_API on $(objects) = $(usesBeAPI) ;
|
|
|
|
# add the build libroot
|
|
if ! $(HOST_PLATFORM_BEOS_COMPATIBLE) {
|
|
local libroot = [ on $(target) return $(HOST_LIBROOT) ] ;
|
|
Depends $(target) : $(libroot) ;
|
|
NEEDLIBS on $(target) += $(libroot) ;
|
|
}
|
|
}
|
|
|
|
Main $(target) : $(sources) ;
|
|
LinkAgainst $(target) : $(libs) ;
|
|
if $(HOST_PLATFORM) = cygwin {
|
|
# Cygwin gcc adds the ".exe" extension. We cannot force
|
|
# jam to use SUFEXE as haiku target executables are not
|
|
# supposed to have this extension, thus finding
|
|
# dependencies will fail for these.
|
|
# The hack is to remove the extension after a successful
|
|
# build of the Target.
|
|
CygwinExtensionFix $(target) ;
|
|
}
|
|
}
|
|
|
|
rule BuildPlatformSharedLibrary
|
|
{
|
|
# Usage BuildPlatformSharedLibrary <target> : <sources> : <libraries> ;
|
|
# <target> The library.
|
|
# <sources> The sources.
|
|
# <libraries> Libraries to link against.
|
|
#
|
|
local target = $(1) ;
|
|
local sources = $(2) ;
|
|
local libs = $(3) ;
|
|
|
|
BuildPlatformMain $(target) : $(sources) : $(libs) ;
|
|
|
|
if $(HOST_PLATFORM) = darwin {
|
|
LINKFLAGS on $(target) = [ on $(target) return $(LINKFLAGS) ]
|
|
-dynamic -dynamiclib -Xlinker -flat_namespace ;
|
|
} else if $(HOST_PLATFORM) = cygwin {
|
|
LINKFLAGS on $(target) = [ on $(target) return $(LINKFLAGS) ]
|
|
-shared -Xlinker --allow-multiple-definition ;
|
|
} else {
|
|
LINKFLAGS on $(target) = [ on $(target) return $(LINKFLAGS) ]
|
|
-shared -Xlinker -soname=\"$(target:G=)\" ;
|
|
}
|
|
|
|
local objects = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
|
|
CCFLAGS on $(objects) += $(HOST_PIC_CCFLAGS) ;
|
|
C++FLAGS on $(objects) += $(HOST_PIC_C++FLAGS) ;
|
|
}
|
|
|
|
rule BuildPlatformMergeObject
|
|
{
|
|
# BuildPlatformMergeObject <name> : <sources> : <other objects> ;
|
|
# Compiles source files and merges the object files to an object file.
|
|
# <name>: Name of the object file to create. No grist will be added.
|
|
# <sources>: Sources to be compiled. Grist will be added.
|
|
# <other objects>: Object files or static libraries to be merged. No grist
|
|
# will be added.
|
|
#
|
|
local target = $(1) ;
|
|
local sources = $(2) ;
|
|
local otherObjects = $(3) ;
|
|
local objects = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
|
|
|
|
PLATFORM on $(target) = host ;
|
|
SUPPORTED_PLATFORMS on $(target) = host ;
|
|
|
|
local usesBeAPI = [ on $(target[1]) return $(USES_BE_API) ] ;
|
|
if $(usesBeAPI) {
|
|
# propagate the flag to the objects
|
|
USES_BE_API on $(objects) = $(usesBeAPI) ;
|
|
}
|
|
|
|
MergeObject $(target) : $(sources) : $(otherObjects) ;
|
|
}
|
|
|
|
rule BuildPlatformMergeObjectPIC target : sources : otherObjects
|
|
{
|
|
# BuildPlatformMergeObjectPIC <name> : <sources> : <other objects> ;
|
|
# Compiles source files and merges the object files to an object file.
|
|
# Same as BuildPlatformMergeObject rule but adds position-independent
|
|
# flags to the compiler (if any).
|
|
# <name>: Name of the object file to create. No grist will be added.
|
|
# <sources>: Sources to be compiled. Grist will be added.
|
|
# <other objects>: Object files or static libraries to be merged. No grist
|
|
# will be added.
|
|
#
|
|
ObjectCcFlags $(sources) : $(HOST_PIC_CCFLAGS) ;
|
|
ObjectC++Flags $(sources) : $(HOST_PIC_C++FLAGS) ;
|
|
|
|
BuildPlatformMergeObject $(target) : $(sources) : $(otherObjects) ;
|
|
}
|
|
|
|
rule BuildPlatformStaticLibrary lib : sources : otherObjects
|
|
{
|
|
# BuildPlatformStaticLibrary <lib> : <sources> ;
|
|
# Creates a static library from sources.
|
|
# <lib>: The static library to be built.
|
|
# <sources>: List of source files.
|
|
# <otherObjects>: List of additional object files.
|
|
#
|
|
|
|
local objects = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
|
|
|
|
PLATFORM on $(lib) = host ;
|
|
SUPPORTED_PLATFORMS on $(lib) = host ;
|
|
|
|
local usesBeAPI = [ on $(lib) return $(USES_BE_API) ] ;
|
|
if $(usesBeAPI) {
|
|
# propagate the flag to the objects
|
|
USES_BE_API on $(objects) = $(usesBeAPI) ;
|
|
}
|
|
|
|
StaticLibrary $(lib) : $(sources) : $(otherObjects) ;
|
|
}
|
|
|
|
rule BuildPlatformStaticLibraryPIC target : sources : otherObjects
|
|
{
|
|
# Like BuildPlatformStaticLibrary, but producing position independent code.
|
|
|
|
ObjectCcFlags $(sources) : $(HOST_PIC_CCFLAGS) ;
|
|
ObjectC++Flags $(sources) : $(HOST_PIC_C++FLAGS) ;
|
|
|
|
BuildPlatformStaticLibrary $(target) : $(sources) : $(otherObjects) ;
|
|
}
|