haiku/build/jam/MainBuildRules

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 ] ;
			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 $(<) : $(>) ;
}

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 += $(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) ;
	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) {
		# 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) ;
}