make/common/Utils.gmk - toolchain/jdk/jdk11 - Git at Google

 #
 # Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # This code is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 2 only, as
 # published by the Free Software Foundation.  Oracle designates this
 # particular file as subject to the "Classpath" exception as provided
 # by Oracle in the LICENSE file that accompanied this code.
 #
 # This code is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 # version 2 for more details (a copy is included in the LICENSE file that
 # accompanied this code).
 #
 # You should have received a copy of the GNU General Public License version
 # 2 along with this work; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 # or visit www.oracle.com if you need additional information or have any
 # questions.
 #

 ifeq (,$(_MAKEBASE_GMK))
   $(error You must include MakeBase.gmk prior to including Utils.gmk)
 endif

 ################################################################################
 #
 # Common utility functions
 #
 ################################################################################

 ### Debug functions

 # Prints the name and value of a variable
 PrintVar = \
     $(info $(strip $1) >$($(strip $1))<)

 ################################################################################
 # This macro translates $ into \$ to protect the $ from expansion in the shell.
 # To make this macro resilient against already escaped strings, first remove
 # any present escapes before escaping so that no double escapes are added.
 EscapeDollar = $(subst $$,\$$,$(subst \$$,$$,$(strip $1)))

 ################################################################################
 # This macro works just like EscapeDollar above, but for #.
 EscapeHash = $(subst \#,\\\#,$(subst \\\#,\#,$(strip $1)))

 ################################################################################
 # This macro translates $ into $$ to protect the string from make itself.
 DoubleDollar = $(subst $$,$$$$,$(strip $1))

 ################################################################################
 # Creates a sequence of increasing numbers (inclusive).
 # Param 1 - starting number
 # Param 2 - ending number
 sequence = \
     $(wordlist $1, $2, $(strip \
         $(eval SEQUENCE_COUNT :=) \
         $(call _sequence-do,$(strip $2))))

 _sequence-do = \
     $(if $(word $1, $(SEQUENCE_COUNT)),, \
       $(eval SEQUENCE_COUNT += .) \
       $(words $(SEQUENCE_COUNT)) \
       $(call _sequence-do,$1))

 ################################################################################
 # Replace question marks with space in string. This macro needs to be called on
 # files from FindFiles in case any of them contains space in their file name,
 # since FindFiles replaces space with ?.
 # Param 1 - String to replace in
 DecodeSpace = \
     $(subst ?,$(SPACE),$(strip $1))
 EncodeSpace = \
     $(subst $(SPACE),?,$(strip $1))

 ################################################################################
 # Assign a variable only if it is empty
 # Param 1 - Variable to assign
 # Param 2 - Value to assign
 SetIfEmpty = \
     $(if $($(strip $1)),,$(eval $(strip $1) := $2))

 ################################################################################
 # Take two paths and return the path of the last common directory.
 # Ex: /foo/bar/baz, /foo/bar/banan -> /foo/bar
 #     foo/bar/baz, /foo/bar -> <empty>
 #
 # The x prefix is used to preserve the presence of the initial slash
 #
 # $1 - Path to compare
 # $2 - Other path to compare
 FindCommonPathPrefix = \
     $(patsubst x%,%,$(subst $(SPACE),/,$(strip \
         $(call FindCommonPathPrefixHelper, \
             $(subst /,$(SPACE),x$(strip $1)), $(subst /,$(SPACE),x$(strip $2))) \
     )))

 FindCommonPathPrefixHelper = \
     $(if $(call equals, $(firstword $1), $(firstword $2)), \
       $(firstword $1) \
       $(call FindCommonPathPrefixHelper, \
           $(wordlist 2, $(words $1), $1), $(wordlist 2, $(words $2), $2) \
       ) \
     )

 # Convert a partial path into as many directory levels of ../, removing
 # leading and following /.
 # Ex: foo/bar/baz/ -> ../../..
 #     foo/bar -> ../..
 #     /foo -> ..
 DirToDotDot = \
     $(subst $(SPACE),/,$(foreach d, $(subst /,$(SPACE),$1),..))

 # Computes the relative path from a directory to a file
 # $1 - File to compute the relative path to
 # $2 - Directory to compute the relative path from
 RelativePath = \
     $(eval $1_prefix := $(call FindCommonPathPrefix, $1, $2)) \
     $(eval $1_dotdots := $(call DirToDotDot, $(patsubst $($(strip $1)_prefix)%, %, $2))) \
     $(eval $1_dotdots := $(if $($(strip $1)_dotdots),$($(strip $1)_dotdots),.)) \
     $(eval $1_suffix := $(patsubst $($(strip $1)_prefix)/%, %, $1)) \
     $($(strip $1)_dotdots)/$($(strip $1)_suffix)

 ################################################################################
 # Filter out duplicate sub strings while preserving order. Keeps the first occurance.
 uniq = \
     $(strip $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1))))

 # Returns all whitespace-separated words in $2 where at least one of the
 # whitespace-separated words in $1 is a substring.
 containing = \
     $(strip \
         $(foreach v,$(strip $2),\
           $(call uniq,$(foreach p,$(strip $1),$(if $(findstring $p,$v),$v)))))

 # Returns all whitespace-separated words in $2 where none of the
 # whitespace-separated words in $1 is a substring.
 not-containing = \
     $(strip $(filter-out $(call containing,$1,$2),$2))

 # Return a list of all string elements that are duplicated in $1.
 dups = \
     $(strip $(foreach v, $(sort $1), $(if $(filter-out 1, \
         $(words $(filter $v, $1))), $v)))

 # String equals
 equals = \
     $(and $(findstring $(strip $1),$(strip $2)),\
         $(findstring $(strip $2),$(strip $1)))

 # Remove a whole list of prefixes
 # $1 - List of prefixes
 # $2 - List of elements to process
 remove-prefixes = \
     $(strip $(if $1,$(patsubst $(firstword $1)%,%,\
       $(call remove-prefixes,$(filter-out $(firstword $1),$1),$2)),$2))

 # Convert the string given to upper case, without any $(shell)
 # Inspired by http://lists.gnu.org/archive/html/help-make/2013-09/msg00009.html
 uppercase_table := a,A b,B c,C d,D e,E f,F g,G h,H i,I j,J k,K l,L m,M n,N o,O \
     p,P q,Q r,R s,S t,T u,U v,V w,W x,X y,Y z,Z

 uppercase_internal = \
   $(if $(strip $1), $$(subst $(firstword $1), $(call uppercase_internal, \
       $(wordlist 2, $(words $1), $1), $2)), $2)

 # Convert a string to upper case. Works only on a-z.
 # $1 - The string to convert
 uppercase = \
   $(strip \
     $(eval uppercase_result := $(call uppercase_internal, $(uppercase_table), $1)) \
     $(uppercase_result) \
   )

 ################################################################################
 # Boolean operators.

 # Return the word "true" if all the boolean words given as argument is "true",
 # and returns "false" otherwise. Boolean words must be "true" or "false". It is
 # an error to supply a non-boolean word. An empty string is considered "true".
 And = \
   $(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \
   $(if $(strip $(filter-out true, $1)), false, true))

 # Return the word "false" if all the boolean words given as argument is "false",
 # and returns "true" otherwise. Boolean words must be "true" or "false". It is
 # an error to supply a non-boolean word.  An empty string is considered "false".
 Or = \
   $(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \
   $(if $(strip $(filter-out false, $1)), true, false))

 ################################################################################
 # Parse a multiple-keyword variable, like FOO="KEYWORD1=val1;KEYWORD2=val2;..."
 # These will be converted into a series of variables like FOO_KEYWORD1=val1,
 # FOO_KEYWORD2=val2, etc. Unknown keywords will cause an error.
 #
 # Parameter 1 is the name of the rule, and is also the name of the variable.
 #
 # Remaining parameters are named arguments. These include:
 #   SINGLE_KEYWORDS   A list of valid keywords with single string values
 #   STRING_KEYWORDS   A list of valid keywords, processed as string. This means
 #       that '%20' will be replaced by ' ' to allow for multi-word strings.
 #
 ParseKeywordVariable = $(NamedParamsMacroTemplate)
 define ParseKeywordVariableBody
   ifneq ($$($1), )
     # To preserve spaces, substitute them with a hopefully unique pattern
     # before splitting and then re-substitute spaces back.
     $1_MANGLED := $$(subst $$(SPACE),||||,$$($1))
     $$(foreach mangled_part, $$(subst ;, , $$($1_MANGLED)), \
       $$(eval mangled_part_eval := $$(call DoubleDollar, $$(mangled_part))) \
       $$(eval part := $$$$(subst ||||,$$$$(SPACE),$$$$(mangled_part_eval))) \
       $$(eval $1_NO_MATCH := true) \
       $$(foreach keyword, $$($1_SINGLE_KEYWORDS), \
         $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
         $$(if $$(filter $$(keyword)=%, $$(part)), \
           $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part)))) \
           $$(eval $1_NO_MATCH := ) \
         ) \
       ) \
       $$(foreach keyword, $$($1_STRING_KEYWORDS), \
         $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
         $$(if $$(filter $$(keyword)=%, $$(part)), \
           $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(subst %20, , $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part))))) \
           $$(eval $1_NO_MATCH := ) \
         ) \
       ) \
       $$(if $$($1_NO_MATCH), \
         $$(if $$(filter $$(part), $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS)), \
           $$(info Keyword $$(part) for $1 needs to be assigned a value.) \
         , \
           $$(info $$(part) is not a valid keyword for $1.) \
           $$(info Valid keywords: $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS).) \
         ) \
         $$(error Cannot continue) \
       ) \
     )
   endif
 endef

 ################################################################################
 # ShellQuote
 #
 # Quotes a string with single quotes and replaces single quotes with '\'' so
 # that the contents survives being given to the shell.
 ShellQuote = \
     $(SQUOTE)$(subst $(SQUOTE),$(SQUOTE)\$(SQUOTE)$(SQUOTE),$(strip $1))$(SQUOTE)

 ################################################################################
 # Find lib dir for module
 # Param 1 - module name
 FindLibDirForModule = \
     $(SUPPORT_OUTPUTDIR)/modules_libs/$(strip $1)

 ################################################################################
 # Find executable dir for module
 # Param 1 - module name
 FindExecutableDirForModule = \
     $(SUPPORT_OUTPUTDIR)/modules_cmds/$(strip $1)

 ################################################################################
 # Return a string suitable for use after a -classpath or --module-path option. It
 # will be correct and safe to use on all platforms. Arguments are given as space
 # separate classpath entries. Safe for multiple nested calls.
 # param 1 : A space separated list of classpath entries
 # The surrounding strip is needed to keep additional whitespace out
 PathList = \
   "$(subst $(SPACE),:,$(strip $(subst $(DQUOTE),,$1)))"

 ################################################################################
 # Check if a specified hotspot variant is being built, or at least one of a
 # list of variants. Will return 'true' or 'false'.
 # $1 - the variant to test for
 check-jvm-variant = \
   $(strip \
     $(if $(filter-out $(VALID_JVM_VARIANTS), $1), \
       $(error Internal error: Invalid variant tested: $1)) \
     $(if $(filter $1, $(JVM_VARIANTS)), true, false))

 ################################################################################
 # Check if our build or target conforms to certain restrictions. This set of
 # functions all work in similar ways, testing the property that the name
 # implies, so e.g. isTargetCpu test the CPU of the target system.
 #
 # $1 - A property, or a space separated list of properties to test for.
 #
 # Returns true if the actual property matches one of the properties in the list,
 # and false otherwise.
 #
 # Examples: $(call isTargetOs, linux solaris) will return true when executed
 # on either linux or solaris, and false otherwise.
 # $(call isBuildCpuArch, x86) will return true iff the build CPU Arch is x86.

 isTargetOs = \
   $(strip $(if $(filter $(OPENJDK_TARGET_OS), $1), true, false))

 isTargetOsType = \
   $(strip $(if $(filter $(OPENJDK_TARGET_OS_TYPE), $1), true, false))

 isTargetCpu = \
   $(strip $(if $(filter $(OPENJDK_TARGET_CPU), $1), true, false))

 isTargetCpuArch = \
   $(strip $(if $(filter $(OPENJDK_TARGET_CPU_ARCH), $1), true, false))

 isTargetCpuBits = \
   $(strip $(if $(filter $(OPENJDK_TARGET_CPU_BITS), $1), true, false))

 isBuildOs = \
   $(strip $(if $(filter $(OPENJDK_BUILD_OS), $1), true, false))

 isBuildOsType = \
   $(strip $(if $(filter $(OPENJDK_BUILD_OS_TYPE), $1), true, false))

 isBuildOsEnv = \
   $(strip $(if $(filter $(OPENJDK_BUILD_OS_ENV), $1), true, false))

 isBuildCpu = \
   $(strip $(if $(filter $(OPENJDK_BUILD_CPU), $1), true, false))

 isBuildCpuArch = \
   $(strip $(if $(filter $(OPENJDK_BUILD_CPU_ARCH), $1), true, false))

 ################################################################################
 # Converts a space separated list to a comma separated list.
 #
 # Replacing double-comma with a single comma is to workaround the issue with
 # some version of make on windows that doesn't substitute spaces with one comma
 # properly.
 CommaList = \
   $(strip \
       $(subst $(COMMA)$(COMMA),$(COMMA),$(subst $(SPACE),$(COMMA),$(strip $1))) \
   )

 ################################################################################
 # Converts a space separated list to a colon separated list.
 #
 # Replacing double-colon with a single colon is to workaround the issue with
 # some version of make on windows that doesn't substitute spaces with one colon
 # properly.
 ColonList = \
   $(strip \
       $(subst ::,:,$(subst $(SPACE),:,$(strip $1))) \
   )

 ################################################################################
 # Given a list of files, filters out locale specific files for translations
 # that should be excluded from this build.
 # $1 - The list of files to filter
 # $2 - The suffix of the files that should be considered (.java or .properties)
 FilterExcludedTranslations = \
   $(strip $(if $(EXCLUDE_TRANSLATIONS), \
     $(filter-out \
         $(foreach suffix, $2, \
           $(addprefix %_, $(addsuffix $(suffix), $(EXCLUDE_TRANSLATIONS))) \
         ), \
         $1 \
     ), \
     $1 \
   ))
	#
	# Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
	# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	#
	# This code is free software; you can redistribute it and/or modify it
	# under the terms of the GNU General Public License version 2 only, as
	# published by the Free Software Foundation. Oracle designates this
	# particular file as subject to the "Classpath" exception as provided
	# by Oracle in the LICENSE file that accompanied this code.
	#
	# This code is distributed in the hope that it will be useful, but WITHOUT
	# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	# version 2 for more details (a copy is included in the LICENSE file that
	# accompanied this code).
	#
	# You should have received a copy of the GNU General Public License version
	# 2 along with this work; if not, write to the Free Software Foundation,
	# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	#
	# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	# or visit www.oracle.com if you need additional information or have any
	# questions.
	#

	ifeq (,$(_MAKEBASE_GMK))
	$(error You must include MakeBase.gmk prior to including Utils.gmk)
	endif

	################################################################################
	#
	# Common utility functions
	#
	################################################################################

	### Debug functions

	# Prints the name and value of a variable
	PrintVar = \
	$(info $(strip $1) >$($(strip $1))<)

	################################################################################
	# This macro translates $ into \$ to protect the $ from expansion in the shell.
	# To make this macro resilient against already escaped strings, first remove
	# any present escapes before escaping so that no double escapes are added.
	EscapeDollar = $(subst $$,\$$,$(subst \$$,$$,$(strip $1)))

	################################################################################
	# This macro works just like EscapeDollar above, but for #.
	EscapeHash = $(subst \#,\\\#,$(subst \\\#,\#,$(strip $1)))

	################################################################################
	# This macro translates $ into $$ to protect the string from make itself.
	DoubleDollar = $(subst $$,$$$$,$(strip $1))

	################################################################################
	# Creates a sequence of increasing numbers (inclusive).
	# Param 1 - starting number
	# Param 2 - ending number
	sequence = \
	$(wordlist $1, $2, $(strip \
	$(eval SEQUENCE_COUNT :=) \
	$(call _sequence-do,$(strip $2))))

	_sequence-do = \
	$(if $(word $1, $(SEQUENCE_COUNT)),, \
	$(eval SEQUENCE_COUNT += .) \
	$(words $(SEQUENCE_COUNT)) \
	$(call _sequence-do,$1))

	################################################################################
	# Replace question marks with space in string. This macro needs to be called on
	# files from FindFiles in case any of them contains space in their file name,
	# since FindFiles replaces space with ?.
	# Param 1 - String to replace in
	DecodeSpace = \
	$(subst ?,$(SPACE),$(strip $1))
	EncodeSpace = \
	$(subst $(SPACE),?,$(strip $1))

	################################################################################
	# Assign a variable only if it is empty
	# Param 1 - Variable to assign
	# Param 2 - Value to assign
	SetIfEmpty = \
	$(if $($(strip $1)),,$(eval $(strip $1) := $2))

	################################################################################
	# Take two paths and return the path of the last common directory.
	# Ex: /foo/bar/baz, /foo/bar/banan -> /foo/bar
	# foo/bar/baz, /foo/bar -> <empty>
	#
	# The x prefix is used to preserve the presence of the initial slash
	#
	# $1 - Path to compare
	# $2 - Other path to compare
	FindCommonPathPrefix = \
	$(patsubst x%,%,$(subst $(SPACE),/,$(strip \
	$(call FindCommonPathPrefixHelper, \
	$(subst /,$(SPACE),x$(strip $1)), $(subst /,$(SPACE),x$(strip $2))) \
	)))

	FindCommonPathPrefixHelper = \
	$(if $(call equals, $(firstword $1), $(firstword $2)), \
	$(firstword $1) \
	$(call FindCommonPathPrefixHelper, \
	$(wordlist 2, $(words $1), $1), $(wordlist 2, $(words $2), $2) \
	) \
	)

	# Convert a partial path into as many directory levels of ../, removing
	# leading and following /.
	# Ex: foo/bar/baz/ -> ../../..
	# foo/bar -> ../..
	# /foo -> ..
	DirToDotDot = \
	$(subst $(SPACE),/,$(foreach d, $(subst /,$(SPACE),$1),..))

	# Computes the relative path from a directory to a file
	# $1 - File to compute the relative path to
	# $2 - Directory to compute the relative path from
	RelativePath = \
	$(eval $1_prefix := $(call FindCommonPathPrefix, $1, $2)) \
	$(eval $1_dotdots := $(call DirToDotDot, $(patsubst $($(strip $1)_prefix)%, %, $2))) \
	$(eval $1_dotdots := $(if $($(strip $1)_dotdots),$($(strip $1)_dotdots),.)) \
	$(eval $1_suffix := $(patsubst $($(strip $1)_prefix)/%, %, $1)) \
	$($(strip $1)_dotdots)/$($(strip $1)_suffix)

	################################################################################
	# Filter out duplicate sub strings while preserving order. Keeps the first occurance.
	uniq = \
	$(strip $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1))))

	# Returns all whitespace-separated words in $2 where at least one of the
	# whitespace-separated words in $1 is a substring.
	containing = \
	$(strip \
	$(foreach v,$(strip $2),\
	$(call uniq,$(foreach p,$(strip $1),$(if $(findstring $p,$v),$v)))))

	# Returns all whitespace-separated words in $2 where none of the
	# whitespace-separated words in $1 is a substring.
	not-containing = \
	$(strip $(filter-out $(call containing,$1,$2),$2))

	# Return a list of all string elements that are duplicated in $1.
	dups = \
	$(strip $(foreach v, $(sort $1), $(if $(filter-out 1, \
	$(words $(filter $v, $1))), $v)))

	# String equals
	equals = \
	$(and $(findstring $(strip $1),$(strip $2)),\
	$(findstring $(strip $2),$(strip $1)))

	# Remove a whole list of prefixes
	# $1 - List of prefixes
	# $2 - List of elements to process
	remove-prefixes = \
	$(strip $(if $1,$(patsubst $(firstword $1)%,%,\
	$(call remove-prefixes,$(filter-out $(firstword $1),$1),$2)),$2))

	# Convert the string given to upper case, without any $(shell)
	# Inspired by http://lists.gnu.org/archive/html/help-make/2013-09/msg00009.html
	uppercase_table := a,A b,B c,C d,D e,E f,F g,G h,H i,I j,J k,K l,L m,M n,N o,O \
	p,P q,Q r,R s,S t,T u,U v,V w,W x,X y,Y z,Z

	uppercase_internal = \
	$(if $(strip $1), $$(subst $(firstword $1), $(call uppercase_internal, \
	$(wordlist 2, $(words $1), $1), $2)), $2)

	# Convert a string to upper case. Works only on a-z.
	# $1 - The string to convert
	uppercase = \
	$(strip \
	$(eval uppercase_result := $(call uppercase_internal, $(uppercase_table), $1)) \
	$(uppercase_result) \
	)

	################################################################################
	# Boolean operators.

	# Return the word "true" if all the boolean words given as argument is "true",
	# and returns "false" otherwise. Boolean words must be "true" or "false". It is
	# an error to supply a non-boolean word. An empty string is considered "true".
	And = \
	$(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \
	$(if $(strip $(filter-out true, $1)), false, true))

	# Return the word "false" if all the boolean words given as argument is "false",
	# and returns "true" otherwise. Boolean words must be "true" or "false". It is
	# an error to supply a non-boolean word. An empty string is considered "false".
	Or = \
	$(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \
	$(if $(strip $(filter-out false, $1)), true, false))

	################################################################################
	# Parse a multiple-keyword variable, like FOO="KEYWORD1=val1;KEYWORD2=val2;..."
	# These will be converted into a series of variables like FOO_KEYWORD1=val1,
	# FOO_KEYWORD2=val2, etc. Unknown keywords will cause an error.
	#
	# Parameter 1 is the name of the rule, and is also the name of the variable.
	#
	# Remaining parameters are named arguments. These include:
	# SINGLE_KEYWORDS A list of valid keywords with single string values
	# STRING_KEYWORDS A list of valid keywords, processed as string. This means
	# that '%20' will be replaced by ' ' to allow for multi-word strings.
	#
	ParseKeywordVariable = $(NamedParamsMacroTemplate)
	define ParseKeywordVariableBody
	ifneq ($$($1), )
	# To preserve spaces, substitute them with a hopefully unique pattern
	# before splitting and then re-substitute spaces back.
	$1_MANGLED := $$(subst $$(SPACE),\|\|\|\|,$$($1))
	$$(foreach mangled_part, $$(subst ;, , $$($1_MANGLED)), \
	$$(eval mangled_part_eval := $$(call DoubleDollar, $$(mangled_part))) \
	$$(eval part := $$$$(subst \|\|\|\|,$$$$(SPACE),$$$$(mangled_part_eval))) \
	$$(eval $1_NO_MATCH := true) \
	$$(foreach keyword, $$($1_SINGLE_KEYWORDS), \
	$$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
	$$(if $$(filter $$(keyword)=%, $$(part)), \
	$$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part)))) \
	$$(eval $1_NO_MATCH := ) \
	) \
	) \
	$$(foreach keyword, $$($1_STRING_KEYWORDS), \
	$$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
	$$(if $$(filter $$(keyword)=%, $$(part)), \
	$$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(subst %20, , $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part))))) \
	$$(eval $1_NO_MATCH := ) \
	) \
	) \
	$$(if $$($1_NO_MATCH), \
	$$(if $$(filter $$(part), $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS)), \
	$$(info Keyword $$(part) for $1 needs to be assigned a value.) \
	, \
	$$(info $$(part) is not a valid keyword for $1.) \
	$$(info Valid keywords: $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS).) \
	) \
	$$(error Cannot continue) \
	) \
	)
	endif
	endef

	################################################################################
	# ShellQuote
	#
	# Quotes a string with single quotes and replaces single quotes with '\'' so
	# that the contents survives being given to the shell.
	ShellQuote = \
	$(SQUOTE)$(subst $(SQUOTE),$(SQUOTE)\$(SQUOTE)$(SQUOTE),$(strip $1))$(SQUOTE)

	################################################################################
	# Find lib dir for module
	# Param 1 - module name
	FindLibDirForModule = \
	$(SUPPORT_OUTPUTDIR)/modules_libs/$(strip $1)

	################################################################################
	# Find executable dir for module
	# Param 1 - module name
	FindExecutableDirForModule = \
	$(SUPPORT_OUTPUTDIR)/modules_cmds/$(strip $1)

	################################################################################
	# Return a string suitable for use after a -classpath or --module-path option. It
	# will be correct and safe to use on all platforms. Arguments are given as space
	# separate classpath entries. Safe for multiple nested calls.
	# param 1 : A space separated list of classpath entries
	# The surrounding strip is needed to keep additional whitespace out
	PathList = \
	"$(subst $(SPACE),:,$(strip $(subst $(DQUOTE),,$1)))"

	################################################################################
	# Check if a specified hotspot variant is being built, or at least one of a
	# list of variants. Will return 'true' or 'false'.
	# $1 - the variant to test for
	check-jvm-variant = \
	$(strip \
	$(if $(filter-out $(VALID_JVM_VARIANTS), $1), \
	$(error Internal error: Invalid variant tested: $1)) \
	$(if $(filter $1, $(JVM_VARIANTS)), true, false))

	################################################################################
	# Check if our build or target conforms to certain restrictions. This set of
	# functions all work in similar ways, testing the property that the name
	# implies, so e.g. isTargetCpu test the CPU of the target system.
	#
	# $1 - A property, or a space separated list of properties to test for.
	#
	# Returns true if the actual property matches one of the properties in the list,
	# and false otherwise.
	#
	# Examples: $(call isTargetOs, linux solaris) will return true when executed
	# on either linux or solaris, and false otherwise.
	# $(call isBuildCpuArch, x86) will return true iff the build CPU Arch is x86.

	isTargetOs = \
	$(strip $(if $(filter $(OPENJDK_TARGET_OS), $1), true, false))

	isTargetOsType = \
	$(strip $(if $(filter $(OPENJDK_TARGET_OS_TYPE), $1), true, false))

	isTargetCpu = \
	$(strip $(if $(filter $(OPENJDK_TARGET_CPU), $1), true, false))

	isTargetCpuArch = \
	$(strip $(if $(filter $(OPENJDK_TARGET_CPU_ARCH), $1), true, false))

	isTargetCpuBits = \
	$(strip $(if $(filter $(OPENJDK_TARGET_CPU_BITS), $1), true, false))

	isBuildOs = \
	$(strip $(if $(filter $(OPENJDK_BUILD_OS), $1), true, false))

	isBuildOsType = \
	$(strip $(if $(filter $(OPENJDK_BUILD_OS_TYPE), $1), true, false))

	isBuildOsEnv = \
	$(strip $(if $(filter $(OPENJDK_BUILD_OS_ENV), $1), true, false))

	isBuildCpu = \
	$(strip $(if $(filter $(OPENJDK_BUILD_CPU), $1), true, false))

	isBuildCpuArch = \
	$(strip $(if $(filter $(OPENJDK_BUILD_CPU_ARCH), $1), true, false))

	################################################################################
	# Converts a space separated list to a comma separated list.
	#
	# Replacing double-comma with a single comma is to workaround the issue with
	# some version of make on windows that doesn't substitute spaces with one comma
	# properly.
	CommaList = \
	$(strip \
	$(subst $(COMMA)$(COMMA),$(COMMA),$(subst $(SPACE),$(COMMA),$(strip $1))) \
	)

	################################################################################
	# Converts a space separated list to a colon separated list.
	#
	# Replacing double-colon with a single colon is to workaround the issue with
	# some version of make on windows that doesn't substitute spaces with one colon
	# properly.
	ColonList = \
	$(strip \
	$(subst ::,:,$(subst $(SPACE),:,$(strip $1))) \
	)

	################################################################################
	# Given a list of files, filters out locale specific files for translations
	# that should be excluded from this build.
	# $1 - The list of files to filter
	# $2 - The suffix of the files that should be considered (.java or .properties)
	FilterExcludedTranslations = \
	$(strip $(if $(EXCLUDE_TRANSLATIONS), \
	$(filter-out \
	$(foreach suffix, $2, \
	$(addprefix %_, $(addsuffix $(suffix), $(EXCLUDE_TRANSLATIONS))) \
	), \
	$1 \
	), \
	$1 \
	))