# FIncludes <dirs> ;
#
# Overridden to support a second argument, the option to be used.
#
rule FIncludes
{
	return $(2:E="--bad-include-option ")$(1) ;
}


# FSysIncludes <dirs> ;
#
# Counterpart of FIncludes for system include search paths.
#
rule FSysIncludes
{
	return $(2:E="--bad-include-option ")$(1) ;
}


rule SubDirSysHdrs
{
	# SubDirSysHdrs <dirs> ;
	#
	# Adds directories to the system include search paths for the current
	# subdirectory. Counterpart of SubDirHdrs which adds non-system include
	# search paths.
	#
	# <dirs>: The directories to be added to the current subdir's system
	#         include search paths.
	#
	SUBDIRSYSHDRS += [ FDirName $(1) ] ;
}


rule ObjectSysHdrs
{
	# ObjectSysHdrs <sources or objects> : <headers> : <gristed objects>
	#
	# Adds directories to the system include search paths for the given
	# sources or objects. Counterpart of ObjectHdrs which adds non-system
	# include search paths.
	#
	# NOTE: With this incarnation of the Haiku build system this rule doesn't
	# need to be invoked *after* the rule that generates the objects anymore.
	# Actually it is even encouraged to do that *before*. Same for ObjectHdrs.
	#
	# <sources or objects>: The targets for which to add system include
	#                       search paths.
	# <dirs>: The directories to be added to the given objects' system
	#         include search paths.
	#

	local objects = [ FGristFiles $(1:S=$(SUFOBJ)) ] $(3) ;
	local headers = $(2) ;

	local file ;
	for file in $(objects) {
		on $(file) {
			local sysHeaders = $(SYSHDRS) $(headers) ;
			SYSHDRS on $(file) = $(sysHeaders) ;

			# reformat ASHDRS and CCHDRS
			local fileHeaders ;

			if $(PLATFORM) = host {
				fileHeaders =
					[ FIncludes $(HDRS) : $(HOST_LOCAL_INCLUDES_OPTION) ]
					$(HOST_INCLUDES_SEPARATOR)
					[ FSysIncludes $(sysHeaders)
						: $(HOST_SYSTEM_INCLUDES_OPTION) ] ;
			} else {
				local architecture = $(TARGET_PACKAGING_ARCH) ;
				fileHeaders =
					[ FIncludes $(HDRS)
						: $(TARGET_LOCAL_INCLUDES_OPTION_$(architecture)) ]
					$(TARGET_INCLUDES_SEPARATOR_$(architecture))
					[ FSysIncludes $(sysHeaders)
						: $(TARGET_SYSTEM_INCLUDES_OPTION_$(architecture)) ] ;
			}

			ASHDRS on $(file) = $(fileHeaders) ;
			CCHDRS on $(file) = $(fileHeaders) ;
		}
	}
}


rule SourceHdrs
{
	# SourceHdrs <sources> : <headers> [ : <gristed objects> ] ;
	#
	# Is a wrapper for ObjectHdrs, that passes <sources> and <headers> or,
	# if supplied <objects> and <headers>, and also adjusts HDRSEARCH (not
	# done by ObjectHdrs).

	local sources = [ FGristFiles $(1) ] ;
	local headers = $(2) ;
	local objects = $(3) ;

	ObjectHdrs $(sources) : $(headers) : $(objects) ;

	# Also add the header search dirs to HDRSEARCH. Note, that these dirs
	# will be listed after the STDHDRS (if any), but that's better than not
	# being listed at all.
	HDRSEARCH on $(sources) += $(headers) ;
}


rule SourceSysHdrs
{
	# SourceSysHdrs <sources> : <headers> [ : <gristed objects> ] ;
	#
	# Is a wrapper for ObjectSysHdrs, that passes <sources> and <headers> or,
	# if supplied <objects> and <headers>, and also adjusts HDRSEARCH (not
	# done by ObjectSysHdrs).

	local sources = [ FGristFiles $(1) ] ;
	local headers = $(2) ;
	local objects = $(3) ;

	ObjectSysHdrs $(sources) : $(headers) : $(objects) ;

	# Also add the header search dirs to HDRSEARCH. Note, that these dirs
	# will be listed after the STDHDRS (if any), but that's better than not
	# being listed at all.
	HDRSEARCH on $(sources) += $(headers) ;
}


rule PublicHeaders
{
	# PublicHeaders <group list>
	#
	# Returns the directory names for the public header dirs identified by
	# <group list>.

	local list = $(1) ;
	local dirs ;
	local i ;
	for i in $(list) {
		dirs += [ FDirName $(HAIKU_TOP) headers os $(i) ] ;
	}
	return $(dirs) ;
}


rule PrivateHeaders
{
	# PrivateHeaders <group list>
	#
	# Returns the directory names for the private header dirs identified by
	# <group list>.

	local list = $(1) ;
	local dirs ;
	local i ;
	for i in $(list) {
		dirs += [ FDirName $(HAIKU_TOP) headers private $(i) ] ;
	}
	return $(dirs) ;
}


rule PrivateBuildHeaders
{
	# PrivateBuildHeaders <group list>
	#
	# Returns the directory names for the private build header dirs identified
	# by <group list>.

	local list = $(1) ;
	local dirs ;
	local i ;
	for i in $(list) {
		dirs += [ FDirName $(HAIKU_TOP) headers build private $(i) ] ;
	}
	return $(dirs) ;
}


rule LibraryHeaders
{
	# LibraryHeaders <group list>
	#
	# Returns the directory names for the library header dirs identified by
	# <group list>.

	local list = $(1) ;
	local dirs ;
	local i ;
	for i in $(list) {
		dirs += [ FDirName $(HAIKU_TOP) headers libs $(i) ] ;
	}
	return $(dirs) ;
}


rule ArchHeaders
{
	# usage: ArchHeaders <arch> ;
	#
	# <arch> specifies the architecture (e.g. x86).

	return [ FDirName $(HAIKU_TOP) headers private kernel arch $(1) ] ;
}


rule UseHeaders
{
	# UseHeaders <headers> [ : <system> ] ;
	#
	# Adds the C header dirs <headers> to the header search
	# dirs of the subdirectory.
	# If <system> is "true", the dirs are added as system otherwise local
	# search dirs.
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	local header ;
	if $(2) = true {
		for header in $(1) {
			SubDirSysHdrs $(header) ;
		}
	} else {
		for header in $(1) {
			SubDirHdrs $(header) ;
		}
	}
}


rule UsePublicHeaders
{
	# UsePublicHeaders <group list> ;
	#
	# Adds the public C header dirs given by <group list> to the header search
	# dirs of the subdirectory.
	# NOTE: This rule must be invoked *before* the rule that builds the
	# objects.

	UseHeaders [ PublicHeaders $(1) ] : true ;
}


rule UsePublicObjectHeaders
{
	# UsePublicObjectHeaders <sources> : <group list> [ : <objects> ] ;
	#
	# Adds the public C header dirs given by <group list> to the header search
	# dirs of either the object targets of <sources> or if supplied to
	# <objects>. Also adjusts HDRSEARCH of <sources>.

	SourceSysHdrs $(1) : [ PublicHeaders $(2) ] : $(3) ;
}


rule UsePrivateHeaders
{
	# UsePrivateHeaders <group list> [ : <system> ] ;
	#
	# Adds the private C header dirs given by <group list> to the header search
	# dirs of the subdirectory.
	# <system> specifies whether to add the dirs as system or local header
	# search dirs. Defaults to "true".
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	local system = $(2) ;
	system ?= true ;

	UseHeaders [ PrivateHeaders $(1) ] : $(system) ;
}


rule UsePrivateObjectHeaders
{
	# UsePrivateObjectHeaders <sources> : <group list> [ : <objects>
	#	[ : <system> ] ] ;
	#
	# Adds the private C header dirs given by <group list> to the header search
	# dirs of either the object targets of <sources> or if supplied to
	# <objects>. Also adjusts HDRSEARCH of <sources>.
	# <system> specifies whether to add the dirs as system or local header
	# search dirs. Defaults to "true".

	local system = $(4) ;
	system ?= true ;

	if $(system) = true {
		SourceSysHdrs $(1) : [ PrivateHeaders $(2) ] : $(3) ;
	} else {
		SourceHdrs $(1) : [ PrivateHeaders $(2) ] : $(3) ;
	}
}


rule UsePrivateBuildHeaders
{
	# UsePrivateBuildHeaders <group list> [ : <system> ] ;
	#
	# Adds the private build C header dirs given by <group list> to the header
	# search dirs of the subdirectory.
	# <system> specifies whether to add the dirs as system or local header
	# search dirs. Defaults to "true".
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	local system = $(2) ;
	system ?= true ;

	UseHeaders [ PrivateBuildHeaders $(1) ] : $(system) ;
}


rule UseCppUnitHeaders
{
	SubDirSysHdrs [ FDirName $(HAIKU_TOP) headers tools cppunit ] ;
}


rule UseCppUnitObjectHeaders
{
	# UseCppUnitObjectHeaders <sources> [ : <objects> ] ;
	SourceSysHdrs $(1) : [ FDirName $(HAIKU_TOP) headers tools cppunit ]
		: $(2) ;
}


rule UseArchHeaders
{
	# usage: UseArchHeaders <arch> ;
	#
	# <arch> specifies the architecture (e.g. x86).
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	local headers = [ ArchHeaders $(1) ] ;

	UseHeaders $(headers) : true ;
}


rule UseArchObjectHeaders
{
	# usage: UseArchObjectHeaders <sources> : <arch> : [ <objects> ] ;
	#
	# <arch> specifies the architecture (e.g. x86).
	# <sources_or_objects> Source or object files.

	local sources = $(1) ;
	local headers = [ ArchHeaders $(2) ] ;
	local objects = $(3) ;
	local targets ;
	if $(objects) {
		targets = $(objects) ;
	} else {
		targets = [ FGristFiles $(sources:S=$(SUFOBJ)) ] ;
	}

	SourceSysHdrs $(sources) : $(headers) : $(objects) ;
}


rule UsePosixObjectHeaders
{
	# UsePosixObjectHeaders <sources> [ : <objects> ] ;
	#
	# Adds the POSIX header dir to the header search
	# dirs of either the object targets of <sources> or if supplied to
	# <objects>. Also adjusts HDRSEARCH of <sources>.

	SourceSysHdrs $(1) : [ FDirName $(HAIKU_TOP) headers posix ] : $(2) ;
}


rule UseLibraryHeaders
{
	# UseLibraryHeaders <group list> ;
	#
	# Adds the library header dirs given by <group list> to the header search
	# dirs of the subdirectory.
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	UseHeaders [ LibraryHeaders $(1) ] : true ;
}


rule UseLegacyHeaders
{
	# usage: UseLegacyHeaders <group list> ;
	#
	# NOTE: This rule must be invoked *before* the rule that builds the objects.

	UseHeaders [ FDirName $(HAIKU_TOP) headers legacy $(1) ] : true ;
}


rule UseLegacyObjectHeaders
{
	# UseLegacyObjectHeaders <sources> [ : <objects> ] ;
	#
	# Adds the legacy header dir to the header search
	# dirs of either the object targets of <sources> or if supplied to
	# <objects>. Also adjusts HDRSEARCH of <sources>.

	SourceSysHdrs $(1) : [ FDirName $(HAIKU_TOP) headers legacy ] : $(2) ;
}


rule UsePrivateKernelHeaders
{
	UseHeaders $(TARGET_PRIVATE_KERNEL_HEADERS) : true ;
}


rule UsePrivateSystemHeaders
{
	UseHeaders $(TARGET_PRIVATE_SYSTEM_HEADERS_$(TARGET_PACKAGING_ARCH))
		: true ;
}


rule UseBuildFeatureHeaders feature : attribute
{
	# UseBuildFeatureHeaders <feature> : [ <attribute> ] ;
	# A shorthand for
	# UseHeaders [ BuildFeatureAttribute <feature> : <attribute> ] : true ;
	# Moreover the default value for <attribute> is "headers", which usually
	# allows the rule to be called with the feature name as the only parameter.

	local headers = [ BuildFeatureAttribute $(feature) : $(attribute:E=headers)
		: path ] ;
	UseHeaders $(headers) : true ;
}


rule FStandardOSHeaders
{
	local osIncludes = add-ons add-ons/file_system add-ons/graphics
					   add-ons/input_server add-ons/registrar
					   add-ons/screen_saver
					   add-ons/tracker app codec device drivers game
					   interface kernel locale media mail midi midi2
					   net storage support translation ;

	return [ FDirName $(HAIKU_TOP) headers os ]
		[ PublicHeaders $(osIncludes) ] ;
}


rule FStandardHeaders architecture
{
	local osIncludes = add-ons add-ons/file_system add-ons/graphics
					   add-ons/input_server add-ons/registrar
					   add-ons/screen_saver
					   add-ons/tracker app device drivers game codec
					   interface kernel locale media mail midi midi2
					   net storage support translation ;

	local headers = ;

	if $(HAIKU_CC_IS_CLANG_$(architecture)) = 1 {
		headers += [ FDirName $(HAIKU_OUTPUT_DIR) clang_headers ] ;
	}

	# The c++ headers.
	headers += [ C++HeaderDirectories $(architecture) ] ;

	# The gcc headers.
	headers += [ GccHeaderDirectories $(architecture) ] ;

	# Use headers directory, to allow to do things like include <posix/string.h>
	headers += [ FDirName $(HAIKU_TOP) headers ] ;

	# Use posix headers directory
	headers += [ FDirName $(HAIKU_TOP) headers posix ] ;

	# Use glibc headers
	headers += [ FDirName $(HAIKU_TOP) headers glibc ] ;

	# Use public OS header directories
	headers += [ FDirName $(HAIKU_TOP) headers os ] ;
	headers += [ PublicHeaders $(osIncludes) ] ;

	# Use the root of the private headers -- not so nice, but simplifies things.
	headers += [ PrivateHeaders $(DOT) ] ;

	return $(headers) ;
}


# SUBDIRSYSHDRS shall be reset automatically for each subdir
SUBDIRRESET += SYSHDRS ;