1 # 2 # Copyright (c) 2011, 2020, Oracle and/or its affiliates. All rights reserved. 3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 # 5 # This code is free software; you can redistribute it and/or modify it 6 # under the terms of the GNU General Public License version 2 only, as 7 # published by the Free Software Foundation. Oracle designates this 8 # particular file as subject to the "Classpath" exception as provided 9 # by Oracle in the LICENSE file that accompanied this code. 10 # 11 # This code is distributed in the hope that it will be useful, but WITHOUT 12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 # version 2 for more details (a copy is included in the LICENSE file that 15 # accompanied this code). 16 # 17 # You should have received a copy of the GNU General Public License version 18 # 2 along with this work; if not, write to the Free Software Foundation, 19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 # 21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 # or visit www.oracle.com if you need additional information or have any 23 # questions. 24 # 25 26 ifeq (,$(_MAKEBASE_GMK)) 27 $(error You must include MakeBase.gmk prior to including Utils.gmk) 28 endif 29 30 ################################################################################ 31 # 32 # Common utility functions 33 # 34 ################################################################################ 35 36 ### Debug functions 37 38 # Prints the name and value of a variable 39 PrintVar = \ 40 $(info $(strip $1) >$($(strip $1))<) 41 42 ################################################################################ 43 # This macro translates $ into \$ to protect the $ from expansion in the shell. 44 # To make this macro resilient against already escaped strings, first remove 45 # any present escapes before escaping so that no double escapes are added. 46 EscapeDollar = $(subst $$,\$$,$(subst \$$,$$,$(strip $1))) 47 48 ################################################################################ 49 # This macro works just like EscapeDollar above, but for #. 50 EscapeHash = $(subst \#,\\\#,$(subst \\\#,\#,$(strip $1))) 51 52 ################################################################################ 53 # This macro translates $ into $$ to protect the string from make itself. 54 DoubleDollar = $(subst $$,$$$$,$(strip $1)) 55 56 ################################################################################ 57 # Creates a sequence of increasing numbers (inclusive). 58 # Param 1 - starting number 59 # Param 2 - ending number 60 sequence = \ 61 $(wordlist $1, $2, $(strip \ 62 $(eval SEQUENCE_COUNT :=) \ 63 $(call _sequence-do,$(strip $2)))) 64 65 _sequence-do = \ 66 $(if $(word $1, $(SEQUENCE_COUNT)),, \ 67 $(eval SEQUENCE_COUNT += .) \ 68 $(words $(SEQUENCE_COUNT)) \ 69 $(call _sequence-do,$1)) 70 71 ################################################################################ 72 # Replace question marks with space in string. This macro needs to be called on 73 # files from FindFiles in case any of them contains space in their file name, 74 # since FindFiles replaces space with ?. 75 # Param 1 - String to replace in 76 DecodeSpace = \ 77 $(subst ?,$(SPACE),$(strip $1)) 78 79 EncodeSpace = \ 80 $(subst $(SPACE),?,$(strip $1)) 81 82 ################################################################################ 83 # Assign a variable only if it is empty 84 # Param 1 - Variable to assign 85 # Param 2 - Value to assign 86 SetIfEmpty = \ 87 $(if $($(strip $1)),,$(eval $(strip $1) := $2)) 88 89 ################################################################################ 90 # Take two paths and return the path of the last common directory. 91 # Ex: /foo/bar/baz, /foo/bar/banan -> /foo/bar 92 # foo/bar/baz, /foo/bar -> <empty> 93 # 94 # The x prefix is used to preserve the presence of the initial slash 95 # 96 # $1 - Path to compare 97 # $2 - Other path to compare 98 FindCommonPathPrefix = \ 99 $(patsubst x%,%,$(subst $(SPACE),/,$(strip \ 100 $(call FindCommonPathPrefixHelper, \ 101 $(subst /,$(SPACE),x$(strip $1)), $(subst /,$(SPACE),x$(strip $2))) \ 102 ))) 103 104 FindCommonPathPrefixHelper = \ 105 $(if $(call equals, $(firstword $1), $(firstword $2)), \ 106 $(firstword $1) \ 107 $(call FindCommonPathPrefixHelper, \ 108 $(wordlist 2, $(words $1), $1), $(wordlist 2, $(words $2), $2) \ 109 ) \ 110 ) 111 112 # Convert a partial path into as many directory levels of ../, removing 113 # leading and following /. 114 # Ex: foo/bar/baz/ -> ../../.. 115 # foo/bar -> ../.. 116 # /foo -> .. 117 DirToDotDot = \ 118 $(subst $(SPACE),/,$(foreach d, $(subst /,$(SPACE),$1),..)) 119 120 # Computes the relative path from a directory to a file 121 # $1 - File to compute the relative path to 122 # $2 - Directory to compute the relative path from 123 RelativePath = \ 124 $(eval $1_prefix := $(call FindCommonPathPrefix, $1, $2)) \ 125 $(eval $1_dotdots := $(call DirToDotDot, $(patsubst $($(strip $1)_prefix)%, %, $2))) \ 126 $(eval $1_dotdots := $(if $($(strip $1)_dotdots),$($(strip $1)_dotdots),.)) \ 127 $(eval $1_suffix := $(patsubst $($(strip $1)_prefix)/%, %, $1)) \ 128 $($(strip $1)_dotdots)/$($(strip $1)_suffix) 129 130 ################################################################################ 131 # Filter out duplicate sub strings while preserving order. Keeps the first occurance. 132 uniq = \ 133 $(strip $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))) 134 135 # Returns all whitespace-separated words in $2 where at least one of the 136 # whitespace-separated words in $1 is a substring. 137 containing = \ 138 $(strip \ 139 $(foreach v,$(strip $2),\ 140 $(call uniq,$(foreach p,$(strip $1),$(if $(findstring $p,$v),$v))))) 141 142 # Returns all whitespace-separated words in $2 where none of the 143 # whitespace-separated words in $1 is a substring. 144 not-containing = \ 145 $(strip $(filter-out $(call containing,$1,$2),$2)) 146 147 # Return a list of all string elements that are duplicated in $1. 148 dups = \ 149 $(strip $(foreach v, $(sort $1), $(if $(filter-out 1, \ 150 $(words $(filter $v, $1))), $v))) 151 152 # String equals 153 equals = \ 154 $(if $(strip $1)$(strip $2),$(strip \ 155 $(and $(findstring $(strip $1),$(strip $2)),\ 156 $(findstring $(strip $2),$(strip $1)))), \ 157 true \ 158 ) 159 160 # Remove a whole list of prefixes 161 # $1 - List of prefixes 162 # $2 - List of elements to process 163 remove-prefixes = \ 164 $(strip $(if $1,$(patsubst $(firstword $1)%,%,\ 165 $(call remove-prefixes,$(filter-out $(firstword $1),$1),$2)),$2)) 166 167 # Convert the string given to upper case, without any $(shell) 168 # Inspired by http://lists.gnu.org/archive/html/help-make/2013-09/msg00009.html 169 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 \ 170 p,P q,Q r,R s,S t,T u,U v,V w,W x,X y,Y z,Z 171 172 uppercase_internal = \ 173 $(if $(strip $1), $$(subst $(firstword $1), $(call uppercase_internal, \ 174 $(wordlist 2, $(words $1), $1), $2)), $2) 175 176 # Convert a string to upper case. Works only on a-z. 177 # $1 - The string to convert 178 uppercase = \ 179 $(strip \ 180 $(eval uppercase_result := $(call uppercase_internal, $(uppercase_table), $1)) \ 181 $(uppercase_result) \ 182 ) 183 184 ################################################################################ 185 # Boolean operators. 186 187 # Return the word "true" if all the boolean words given as argument is "true", 188 # and returns "false" otherwise. Boolean words must be "true" or "false". It is 189 # an error to supply a non-boolean word. An empty string is considered "true". 190 And = \ 191 $(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \ 192 $(if $(strip $(filter-out true, $1)), false, true)) 193 194 # Return the word "false" if all the boolean words given as argument is "false", 195 # and returns "true" otherwise. Boolean words must be "true" or "false". It is 196 # an error to supply a non-boolean word. An empty string is considered "false". 197 Or = \ 198 $(strip $(if $(filter-out true false, $1), $(error Non-boolean values: $1)) \ 199 $(if $(strip $(filter-out false, $1)), true, false)) 200 201 ################################################################################ 202 # Parse a multiple-keyword variable, like FOO="KEYWORD1=val1;KEYWORD2=val2;..." 203 # These will be converted into a series of variables like FOO_KEYWORD1=val1, 204 # FOO_KEYWORD2=val2, etc. Unknown keywords will cause an error. 205 # 206 # Parameter 1 is the name of the rule, and is also the name of the variable. 207 # 208 # Remaining parameters are named arguments. These include: 209 # SINGLE_KEYWORDS A list of valid keywords with single string values 210 # STRING_KEYWORDS A list of valid keywords, processed as string. This means 211 # that '%20' will be replaced by ' ' to allow for multi-word strings. 212 # 213 ParseKeywordVariable = $(NamedParamsMacroTemplate) 214 define ParseKeywordVariableBody 215 ifneq ($$($1), ) 216 # To preserve spaces, substitute them with a hopefully unique pattern 217 # before splitting and then re-substitute spaces back. 218 $1_MANGLED := $$(subst $$(SPACE),||||,$$($1)) 219 $$(foreach mangled_part, $$(subst ;, , $$($1_MANGLED)), \ 220 $$(eval mangled_part_eval := $$(call DoubleDollar, $$(mangled_part))) \ 221 $$(eval part := $$$$(subst ||||,$$$$(SPACE),$$$$(mangled_part_eval))) \ 222 $$(eval $1_NO_MATCH := true) \ 223 $$(foreach keyword, $$($1_SINGLE_KEYWORDS), \ 224 $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \ 225 $$(if $$(filter $$(keyword)=%, $$(part)), \ 226 $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part)))) \ 227 $$(eval $1_NO_MATCH := ) \ 228 ) \ 229 ) \ 230 $$(foreach keyword, $$($1_STRING_KEYWORDS), \ 231 $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \ 232 $$(if $$(filter $$(keyword)=%, $$(part)), \ 233 $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(subst %20, , $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part))))) \ 234 $$(eval $1_NO_MATCH := ) \ 235 ) \ 236 ) \ 237 $$(if $$($1_NO_MATCH), \ 238 $$(if $$(filter $$(part), $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS)), \ 239 $$(info Keyword $$(part) for $1 needs to be assigned a value.) \ 240 , \ 241 $$(info $$(part) is not a valid keyword for $1.) \ 242 $$(info Valid keywords: $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS).) \ 243 ) \ 244 $$(error Cannot continue) \ 245 ) \ 246 ) 247 endif 248 endef 249 250 ################################################################################ 251 # ShellQuote 252 # 253 # Quotes a string with single quotes and replaces single quotes with '\'' so 254 # that the contents survives being given to the shell. 255 ShellQuote = \ 256 $(SQUOTE)$(subst $(SQUOTE),$(SQUOTE)\$(SQUOTE)$(SQUOTE),$(strip $1))$(SQUOTE) 257 258 ################################################################################ 259 # Find lib dir for module 260 # Param 1 - module name 261 FindLibDirForModule = \ 262 $(SUPPORT_OUTPUTDIR)/modules_libs/$(strip $1) 263 264 ################################################################################ 265 # Find executable dir for module 266 # Param 1 - module name 267 FindExecutableDirForModule = \ 268 $(SUPPORT_OUTPUTDIR)/modules_cmds/$(strip $1) 269 270 ################################################################################ 271 # Return a string suitable for use after a -classpath or --module-path option. It 272 # will be correct and safe to use on all platforms. Arguments are given as space 273 # separate classpath entries. Safe for multiple nested calls. 274 # param 1 : A space separated list of classpath entries 275 # The surrounding strip is needed to keep additional whitespace out 276 PathList = \ 277 "$(subst $(SPACE),$(PATH_SEP),$(strip $(subst $(DQUOTE),,$1)))" 278 279 ################################################################################ 280 # Check if a specified hotspot variant is being built, or at least one of a 281 # list of variants. Will return 'true' or 'false'. 282 # $1 - the variant to test for 283 check-jvm-variant = \ 284 $(strip \ 285 $(if $(filter-out $(VALID_JVM_VARIANTS), $1), \ 286 $(error Internal error: Invalid variant tested: $1)) \ 287 $(if $(filter $1, $(JVM_VARIANTS)), true, false)) 288 289 ################################################################################ 290 # Check if our build or target conforms to certain restrictions. This set of 291 # functions all work in similar ways, testing the property that the name 292 # implies, so e.g. isTargetCpu test the CPU of the target system. 293 # 294 # $1 - A property, or a space separated list of properties to test for. 295 # 296 # Returns true if the actual property matches one of the properties in the list, 297 # and false otherwise. 298 # 299 # Examples: $(call isTargetOs, linux windows) will return true when executed 300 # on either linux or windows, and false otherwise. 301 # $(call isBuildCpuArch, x86) will return true iff the build CPU Arch is x86. 302 303 isTargetOs = \ 304 $(strip $(if $(filter $(OPENJDK_TARGET_OS), $1), true, false)) 305 306 isTargetOsType = \ 307 $(strip $(if $(filter $(OPENJDK_TARGET_OS_TYPE), $1), true, false)) 308 309 isTargetCpu = \ 310 $(strip $(if $(filter $(OPENJDK_TARGET_CPU), $1), true, false)) 311 312 isTargetCpuArch = \ 313 $(strip $(if $(filter $(OPENJDK_TARGET_CPU_ARCH), $1), true, false)) 314 315 isTargetCpuBits = \ 316 $(strip $(if $(filter $(OPENJDK_TARGET_CPU_BITS), $1), true, false)) 317 318 isBuildOs = \ 319 $(strip $(if $(filter $(OPENJDK_BUILD_OS), $1), true, false)) 320 321 isBuildOsType = \ 322 $(strip $(if $(filter $(OPENJDK_BUILD_OS_TYPE), $1), true, false)) 323 324 isBuildOsEnv = \ 325 $(strip $(if $(filter $(OPENJDK_BUILD_OS_ENV), $1), true, false)) 326 327 isBuildCpu = \ 328 $(strip $(if $(filter $(OPENJDK_BUILD_CPU), $1), true, false)) 329 330 isBuildCpuArch = \ 331 $(strip $(if $(filter $(OPENJDK_BUILD_CPU_ARCH), $1), true, false)) 332 333 ################################################################################ 334 # Converts a space separated list to a comma separated list. 335 # 336 # Replacing double-comma with a single comma is to workaround the issue with 337 # some version of make on windows that doesn't substitute spaces with one comma 338 # properly. 339 CommaList = \ 340 $(strip \ 341 $(subst $(COMMA)$(COMMA),$(COMMA),$(subst $(SPACE),$(COMMA),$(strip $1))) \ 342 ) 343 344 ################################################################################ 345 # Converts a space separated list to a colon separated list. 346 # 347 # Replacing double-colon with a single colon is to workaround the issue with 348 # some version of make on windows that doesn't substitute spaces with one colon 349 # properly. 350 ColonList = \ 351 $(strip \ 352 $(subst ::,:,$(subst $(SPACE),:,$(strip $1))) \ 353 ) 354 355 ################################################################################ 356 # Given a list of files, filters out locale specific files for translations 357 # that should be excluded from this build. 358 # $1 - The list of files to filter 359 # $2 - The suffix of the files that should be considered (.java or .properties) 360 FilterExcludedTranslations = \ 361 $(strip $(if $(EXCLUDE_TRANSLATIONS), \ 362 $(filter-out \ 363 $(foreach suffix, $2, \ 364 $(addprefix %_, $(addsuffix $(suffix), $(EXCLUDE_TRANSLATIONS))) \ 365 ), \ 366 $1 \ 367 ), \ 368 $1 \ 369 ))