haiku/build/jam/MiscRules

rule SetupObjectsDir
{
	local relPath = [ FDirName $(SUBDIR_TOKENS[2-]) ] ;
	COMMON_PLATFORM_LOCATE_TARGET =
		[ FDirName $(HAIKU_COMMON_PLATFORM_OBJECT_DIR) $(relPath) ] ;

	local var ;
	for var in COMMON_ARCH COMMON_DEBUG DEBUG_$(HAIKU_DEBUG_LEVELS) {
		HOST_$(var)_LOCATE_TARGET
			= [ FDirName $(HOST_$(var)_OBJECT_DIR) $(relPath) ] ;
		TARGET_$(var)_LOCATE_TARGET
			= [ FDirName $(TARGET_$(var)_OBJECT_DIR) $(relPath) ] ;
	}

	LOCATE_TARGET = $(COMMON_PLATFORM_LOCATE_TARGET) ;
	LOCATE_SOURCE = $(LOCATE_TARGET) ;
	SEARCH_SOURCE = $(SUBDIR) $(LOCATE_SOURCE)
		$(HOST_COMMON_DEBUG_LOCATE_TARGET)		# Also add the standard output
		$(TARGET_COMMON_DEBUG_LOCATE_TARGET)	# dirs for generated sources.
	;
}

rule SubIncludeGPL
{
	# SubInclude rule that can be used to conditionally include GPL licensed
	# add-ons
	if $(INCLUDE_GPL_ADDONS) = 1 {
		SubInclude $(1) ;
	} 
}


# pragma mark - MakeLocate variants


rule MakeLocateCommonPlatform
{
	MakeLocate $(1) : $(COMMON_PLATFORM_LOCATE_TARGET) ;
}

rule MakeLocatePlatform
{
	local files = $(1) ;
	local file ;
	for file in $(files) {
		if [ on $(file) return $(PLATFORM) ] = host {
			MakeLocate $(file) : $(HOST_COMMON_ARCH_LOCATE_TARGET) ;
		} else {
			MakeLocate $(file) : $(TARGET_COMMON_ARCH_LOCATE_TARGET) ;
		}
	}
}

rule MakeLocateArch
{
	local files = $(1) ;
	local file ;
	for file in $(files) {
		if [ on $(file) return $(PLATFORM) ] = host {
			MakeLocate $(file) : $(HOST_COMMON_DEBUG_LOCATE_TARGET) ;
		} else {
			MakeLocate $(file) : $(TARGET_COMMON_DEBUG_LOCATE_TARGET) ;
		}
	}
}

rule MakeLocateDebug
{
	local files = $(1) ;
	local file ;
	for file in $(files) {
		on $(file) {
			if $(PLATFORM) = host {
				MakeLocate $(file) : $(HOST_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
			} else {
				MakeLocate $(file) : $(TARGET_DEBUG_$(DEBUG)_LOCATE_TARGET) ;
			}
		}
	}
}


# pragma mark - Deferred SubIncludes


# The variable used to collect the deferred SubIncludes.
HAIKU_DEFERRED_SUB_INCLUDES = ;

rule DeferredSubInclude params
{
	# DeferredSubInclude <subdir tokens> ;
	#
	# Takes the same parameter as SubInclude. The the subdirectory referred to
	# by <subdir tokens> will be included when ExecuteDeferredSubIncludes is
	# invoked, i.e. at the end of the root Jamfile.

	HAIKU_DEFERRED_SUB_INCLUDES += "/" $(params) ;
}

rule ExecuteDeferredSubIncludes
{
	# ExecuteDeferredSubIncludes ;
	#
	# Performs the deferred SubIncludes scheduled by DeferredSubInclude.

	local tokensList = $(HAIKU_DEFERRED_SUB_INCLUDES) ;
	while $(tokensList) {
		# chop off leading "/"
		tokensList = $(tokensList[2-]) ;

		# get the tokens for the next include
		local tokens ;
		while $(tokensList) && $(tokensList[1]) != "/" {
			tokens += $(tokensList[1]) ;
			tokensList = $(tokensList[2-]) ;
		}

		# perform the include
		if $(tokens) {
			SubInclude $(tokens) ;
		}
	}
}

rule HaikuSubInclude tokens
{
	# HaikuSubInclude <tokens> ;
	#
	# Current subdir relative SubInclude.
	# <tokens> - subdir tokens specifying the subdirectory to be include
	#            (relative to the current subdir)

	if $(tokens) {
		SubInclude HAIKU_TOP $(SUBDIR_TOKENS) $(tokens) ;
	}
}


# pragma mark - Unique IDs/targets


# private to NextID; incremented with each NextID invocation
HAIKU_NEXT_ID = 0 ;

rule NextID
{
	# NextID ;

	local result = $(HAIKU_NEXT_ID:J=) ;
	HAIKU_NEXT_ID = [ AddNumAbs $(HAIKU_NEXT_ID) : 1 ] ;
	return $(result) ;
}

rule NewUniqueTarget basename
{
	# NewUniqueTarget [ basename ] ;

	local id = [ NextID ] ;
	return $(basename[1]:E=_target:G=unique!target)_$(id) ;
}